1 /* 2 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* 7 * This module determines the type of socket (datagram, stream), the client 8 * socket address and port, the server socket address and port. In addition, 9 * it provides methods to map a transport address to a printable host name 10 * or address. Socket address information results are in static memory. 11 * 12 * The result from the hostname lookup method is STRING_PARANOID when a host 13 * pretends to have someone elses name, or when a host name is available but 14 * could not be verified. 15 * 16 * When lookup or conversion fails the result is set to STRING_UNKNOWN. 17 * 18 * Diagnostics are reported through syslog(3). 19 * 20 * Author: Wietse Venema, Eindhoven University of Technology, The Netherlands. 21 */ 22 23 #ifndef lint 24 static char sccsid[] = "@(#) socket.c 1.15 97/03/21 19:27:24"; 25 #endif 26 27 /* System libraries. */ 28 29 #include <sys/types.h> 30 #include <sys/param.h> 31 #include <sys/socket.h> 32 #include <netinet/in.h> 33 #include <arpa/inet.h> 34 #include <netdb.h> 35 #include <stdio.h> 36 #include <syslog.h> 37 #include <string.h> 38 39 extern char *inet_ntoa(); 40 41 /* Local stuff. */ 42 43 #include "tcpd.h" 44 45 /* Forward declarations. */ 46 47 static void sock_sink(); 48 49 #ifdef APPEND_DOT 50 51 /* 52 * Speed up DNS lookups by terminating the host name with a dot. Should be 53 * done with care. The speedup can give problems with lookups from sources 54 * that lack DNS-style trailing dot magic, such as local files or NIS maps. 55 */ 56 57 static struct hostent *tcpd_gethostbyname_dot(name, af) 58 char *name; 59 int af; 60 { 61 char dot_name[MAXHOSTNAMELEN + 1]; 62 63 /* 64 * Don't append dots to unqualified names. Such names are likely to come 65 * from local hosts files or from NIS. 66 */ 67 68 if (strchr(name, '.') == 0 || strlen(name) >= MAXHOSTNAMELEN - 1) { 69 return (tcpd_gethostbyname(name, af)); 70 } else { 71 sprintf(dot_name, "%s.", name); 72 return (tcpd_gethostbyname(dot_name, af)); 73 } 74 } 75 76 #define tcpd_gethostbyname tcpd_gethostbyname_dot 77 #endif 78 79 /* sock_host - look up endpoint addresses and install conversion methods */ 80 81 void sock_host(request) 82 struct request_info *request; 83 { 84 static struct sockaddr_gen client; 85 static struct sockaddr_gen server; 86 int len; 87 char buf[BUFSIZ]; 88 int fd = request->fd; 89 90 sock_methods(request); 91 92 /* 93 * Look up the client host address. Hal R. Brand <BRAND@addvax.llnl.gov> 94 * suggested how to get the client host info in case of UDP connections: 95 * peek at the first message without actually looking at its contents. We 96 * really should verify that client.sin_family gets the value AF_INET, 97 * but this program has already caused too much grief on systems with 98 * broken library code. 99 */ 100 101 len = sizeof(client); 102 if (getpeername(fd, (struct sockaddr *) & client, &len) < 0) { 103 request->sink = sock_sink; 104 len = sizeof(client); 105 if (recvfrom(fd, buf, sizeof(buf), MSG_PEEK, 106 (struct sockaddr *) & client, &len) < 0) { 107 tcpd_warn("can't get client address: %m"); 108 return; /* give up */ 109 } 110 #ifdef really_paranoid 111 memset(buf, 0 sizeof(buf)); 112 #endif 113 } 114 sockgen_simplify(&client); 115 request->client->sin = &client; 116 117 /* 118 * Determine the server binding. This is used for client username 119 * lookups, and for access control rules that trigger on the server 120 * address or name. 121 */ 122 123 len = sizeof(server); 124 if (getsockname(fd, (struct sockaddr *) & server, &len) < 0) { 125 tcpd_warn("getsockname: %m"); 126 return; 127 } 128 sockgen_simplify(&server); 129 request->server->sin = &server; 130 } 131 132 /* sock_hostaddr - map endpoint address to printable form */ 133 134 void sock_hostaddr(host) 135 struct host_info *host; 136 { 137 struct sockaddr_gen *sin = host->sin; 138 139 if (sin != 0) 140 #ifdef HAVE_IPV6 141 142 (void) inet_ntop(SGFAM(sin), SGADDRP(sin), host->addr, sizeof(host->addr)); 143 #else 144 STRN_CPY(host->addr, inet_ntoa(sin->sg_sin.sin_addr), sizeof(host->addr)); 145 #endif 146 } 147 148 /* sock_hostname - map endpoint address to host name */ 149 150 void sock_hostname(host) 151 struct host_info *host; 152 { 153 struct sockaddr_gen *sin = host->sin; 154 struct hostent *hp; 155 int i; 156 int herr; 157 158 /* 159 * On some systems, for example Solaris 2.3, gethostbyaddr(0.0.0.0) does 160 * not fail. Instead it returns "INADDR_ANY". Unfortunately, this does 161 * not work the other way around: gethostbyname("INADDR_ANY") fails. We 162 * have to special-case 0.0.0.0, in order to avoid false alerts from the 163 * host name/address checking code below. 164 */ 165 if (sin != 0 166 && !SG_IS_UNSPECIFIED(sin) 167 && (hp = gethostbyaddr(SGADDRP(sin), SGADDRSZ(sin), SGFAM(sin))) != 0) { 168 169 STRN_CPY(host->name, hp->h_name, sizeof(host->name)); 170 171 /* 172 * Verify that the address is a member of the address list returned 173 * by gethostbyname(hostname). 174 * 175 * Verify also that gethostbyaddr() and gethostbyname() return the same 176 * hostname, or rshd and rlogind may still end up being spoofed. 177 * 178 * On some sites, gethostbyname("localhost") returns "localhost.domain". 179 * This is a DNS artefact. We treat it as a special case. When we 180 * can't believe the address list from gethostbyname("localhost") 181 * we're in big trouble anyway. 182 */ 183 184 if ((hp = tcpd_gethostbyname(host->name, SGFAM(sin))) == 0) { 185 186 /* 187 * Unable to verify that the host name matches the address. This 188 * may be a transient problem or a botched name server setup. 189 */ 190 191 tcpd_warn("can't verify hostname: gethostbyname(%s) failed", 192 host->name); 193 194 } else if (STR_NE(host->name, hp->h_name) 195 && STR_NE(host->name, "localhost")) { 196 197 /* 198 * The gethostbyaddr() and gethostbyname() calls did not return 199 * the same hostname. This could be a nameserver configuration 200 * problem. It could also be that someone is trying to spoof us. 201 */ 202 203 tcpd_warn("host name/name mismatch: %s != %.*s", 204 host->name, STRING_LENGTH, hp->h_name); 205 206 } else { 207 #ifdef HAVE_IPV6 208 char buf[INET6_ADDRSTRLEN]; 209 #endif 210 211 /* 212 * The address should be a member of the address list returned by 213 * gethostbyname(). We should first verify that the h_addrtype 214 * field is AF_INET, but this program has already caused too much 215 * grief on systems with broken library code. 216 */ 217 218 for (i = 0; hp->h_addr_list[i]; i++) { 219 if (memcmp(hp->h_addr_list[i], 220 (char *) SGADDRP(sin), 221 SGADDRSZ(sin)) == 0) { 222 return; /* name is good, keep it */ 223 } 224 } 225 226 /* 227 * The host name does not map to the initial address. Perhaps 228 * someone has messed up. Perhaps someone compromised a name 229 * server. 230 */ 231 tcpd_warn("host name/address mismatch: %s != %.*s", 232 #ifdef HAVE_IPV6 233 inet_ntop(SGFAM(sin), SGADDRP(sin), buf, sizeof(buf)), 234 #else 235 inet_ntoa(sin->sg_sin.sin_addr), 236 #endif 237 STRING_LENGTH, hp->h_name); 238 } 239 strcpy(host->name, paranoid); /* name is bad, clobber it */ 240 } 241 } 242 243 /* sock_sink - absorb unreceived IP datagram */ 244 245 static void sock_sink(fd) 246 int fd; 247 { 248 char buf[BUFSIZ]; 249 struct sockaddr_in sin; 250 int size = sizeof(sin); 251 252 /* 253 * Eat up the not-yet received datagram. Some systems insist on a 254 * non-zero source address argument in the recvfrom() call below. 255 */ 256 257 (void) recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) & sin, &size); 258 } 259 260 /* 261 * If we receive a V4 connection on a V6 socket, we pretend we really 262 * got a V4 connection. 263 */ 264 void sockgen_simplify(sg) 265 sockaddr_gen *sg; 266 { 267 #ifdef HAVE_IPV6 268 if (sg->sg_family == AF_INET6 && 269 IN6_IS_ADDR_V4MAPPED(&sg->sg_sin6.sin6_addr)) { 270 struct sockaddr_in v4_addr; 271 272 #ifdef IN6_V4MAPPED_TO_INADDR /* Solaris 8 */ 273 IN6_V4MAPPED_TO_INADDR(&sg->sg_sin6.sin6_addr, &v4_addr.sin_addr); 274 #elif defined(IN6_MAPPED_TO_V4) /* Solaris 8 Beta only? */ 275 IN6_MAPPED_TO_V4(&sg->sg_sin6.sin6_addr, &v4_addr.sin_addr); 276 #else /* Do it the hard way */ 277 memcpy(&v4_addr.sin_addr, ((char*) &sg->sg_sin6.sin6_addr) + 12, 4); 278 #endif 279 v4_addr.sin_port = sg->sg_sin6.sin6_port; 280 v4_addr.sin_family = AF_INET; 281 memcpy(&sg->sg_sin, &v4_addr, sizeof(v4_addr)); 282 } 283 #else 284 return; 285 #endif /* HAVE_IPV6 */ 286 } 287