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