contrib/tcp_wrappers/socket.c

   1  /*
   2   * This module determines the type of socket (datagram, stream), the client
   3   * socket address and port, the server socket address and port. In addition,
   4   * it provides methods to map a transport address to a printable host name
   5   * or address. Socket address information results are in static memory.
   6   *
   7   * The result from the hostname lookup method is STRING_PARANOID when a host
   8   * pretends to have someone elses name, or when a host name is available but
   9   * could not be verified.
  10   *
  11   * When lookup or conversion fails the result is set to STRING_UNKNOWN.
  12   *
  13   * Diagnostics are reported through syslog(3).
  14   *
  15   * Author: Wietse Venema, Eindhoven University of Technology, The Netherlands.
  16   *
  17   * $FreeBSD: src/contrib/tcp_wrappers/socket.c,v 1.2.2.3 2001/07/04 20:18:11 kris Exp $
  18   * $DragonFly: src/contrib/tcp_wrappers/socket.c,v 1.2 2003/06/17 04:24:06 dillon Exp $
  19   */
  20
  21 #ifndef lint
  22 static char sccsid[] = "@(#) socket.c 1.15 97/03/21 19:27:24";
  23 #endif
  24
  25 /* System libraries. */
  26
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <netdb.h>
  32 #include <stdio.h>
  33 #include <syslog.h>
  34 #include <string.h>
  35
  36 #ifdef INET6
  37 #ifndef NI_WITHSCOPEID
  38 #define NI_WITHSCOPEID  0
  39 #endif
  40 #else
  41 extern char *inet_ntoa();
  42 #endif
  43
  44 /* Local stuff. */
  45
  46 #include "tcpd.h"
  47
  48 /* Forward declarations. */
  49
  50 static void sock_sink();
  51
  52 #ifdef APPEND_DOT
  53
  54  /*
  55   * Speed up DNS lookups by terminating the host name with a dot. Should be
  56   * done with care. The speedup can give problems with lookups from sources
  57   * that lack DNS-style trailing dot magic, such as local files or NIS maps.
  58   */
  59
  60 static struct hostent *gethostbyname_dot(name)
  61 char   *name;
  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 (gethostbyname(name));
  72     } else {
  73         sprintf(dot_name, "%s.", name);
  74         return (gethostbyname(dot_name));
  75     }
  76 }
  77
  78 #define gethostbyname 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 #ifdef INET6
  87     static struct sockaddr_storage client;
  88     static struct sockaddr_storage server;
  89 #else
  90     static struct sockaddr_in client;
  91     static struct sockaddr_in server;
  92 #endif
  93     int     len;
  94     char    buf[BUFSIZ];
  95     int     fd = request->fd;
  96
  97     sock_methods(request);
  98
  99     /*
 100      * Look up the client host address. Hal R. Brand <BRAND@addvax.llnl.gov>
 101      * suggested how to get the client host info in case of UDP connections:
 102      * peek at the first message without actually looking at its contents. We
 103      * really should verify that client.sin_family gets the value AF_INET,
 104      * but this program has already caused too much grief on systems with
 105      * broken library code.
 106      */
 107
 108     len = sizeof(client);
 109     if (getpeername(fd, (struct sockaddr *) & client, &len) < 0) {
 110         request->sink = sock_sink;
 111         len = sizeof(client);
 112         if (recvfrom(fd, buf, sizeof(buf), MSG_PEEK,
 113                      (struct sockaddr *) & client, &len) < 0) {
 114             tcpd_warn("can't get client address: %m");
 115             return;                             /* give up */
 116         }
 117 #ifdef really_paranoid
 118         memset(buf, 0 sizeof(buf));
 119 #endif
 120     }
 121 #ifdef INET6
 122     request->client->sin = (struct sockaddr *)&client;
 123 #else
 124     request->client->sin = &client;
 125 #endif
 126
 127     /*
 128      * Determine the server binding. This is used for client username
 129      * lookups, and for access control rules that trigger on the server
 130      * address or name.
 131      */
 132
 133     len = sizeof(server);
 134     if (getsockname(fd, (struct sockaddr *) & server, &len) < 0) {
 135         tcpd_warn("getsockname: %m");
 136         return;
 137     }
 138 #ifdef INET6
 139     request->server->sin = (struct sockaddr *)&server;
 140 #else
 141     request->server->sin = &server;
 142 #endif
 143 }
 144
 145 /* sock_hostaddr - map endpoint address to printable form */
 146
 147 void    sock_hostaddr(host)
 148 struct host_info *host;
 149 {
 150 #ifdef INET6
 151     struct sockaddr *sin = host->sin;
 152     int salen;
 153
 154     if (!sin)
 155         return;
 156 #ifdef SIN6_LEN
 157     salen = sin->sa_len;
 158 #else
 159     salen = (sin->sa_family == AF_INET) ? sizeof(struct sockaddr_in)
 160                                         : sizeof(struct sockaddr_in6);
 161 #endif
 162     getnameinfo(sin, salen, host->addr, sizeof(host->addr),
 163                 NULL, 0, NI_NUMERICHOST | NI_WITHSCOPEID);
 164 #else
 165     struct sockaddr_in *sin = host->sin;
 166
 167     if (sin != 0)
 168         STRN_CPY(host->addr, inet_ntoa(sin->sin_addr), sizeof(host->addr));
 169 #endif
 170 }
 171
 172 /* sock_hostname - map endpoint address to host name */
 173
 174 void    sock_hostname(host)
 175 struct host_info *host;
 176 {
 177 #ifdef INET6
 178     struct sockaddr *sin = host->sin;
 179     struct sockaddr_in sin4;
 180     struct addrinfo hints, *res, *res0 = NULL;
 181     int salen, alen, err = 1;
 182     char *ap = NULL, *rap, hname[NI_MAXHOST];
 183
 184     if (sin != NULL) {
 185         if (sin->sa_family == AF_INET6) {
 186             struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin;
 187
 188             if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
 189                 memset(&sin4, 0, sizeof(sin4));
 190 #ifdef SIN6_LEN
 191                 sin4.sin_len = sizeof(sin4);
 192 #endif
 193                 sin4.sin_family = AF_INET;
 194                 sin4.sin_port = sin6->sin6_port;
 195                 sin4.sin_addr.s_addr = *(u_int32_t *)&sin6->sin6_addr.s6_addr[12];
 196                 sin = (struct sockaddr *)&sin4;
 197             }
 198         }
 199         switch (sin->sa_family) {
 200         case AF_INET:
 201             ap = (char *)&((struct sockaddr_in *)sin)->sin_addr;
 202             alen = sizeof(struct in_addr);
 203             salen = sizeof(struct sockaddr_in);
 204             break;
 205         case AF_INET6:
 206             ap = (char *)&((struct sockaddr_in6 *)sin)->sin6_addr;
 207             alen = sizeof(struct in6_addr);
 208             salen = sizeof(struct sockaddr_in6);
 209             break;
 210         default:
 211             break;
 212         }
 213         if (ap)
 214             err = getnameinfo(sin, salen, hname, sizeof(hname),
 215                               NULL, 0, NI_WITHSCOPEID | NI_NAMEREQD);
 216     }
 217     if (!err) {
 218
 219         STRN_CPY(host->name, hname, sizeof(host->name));
 220
 221         /* reject numeric addresses */
 222         memset(&hints, 0, sizeof(hints));
 223         hints.ai_family = sin->sa_family;
 224         hints.ai_socktype = SOCK_STREAM;
 225         hints.ai_flags = AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST;
 226         if ((err = getaddrinfo(host->name, NULL, &hints, &res0)) == 0) {
 227             freeaddrinfo(res0);
 228             tcpd_warn("host name/name mismatch: "
 229                       "reverse lookup results in non-FQDN %s",
 230                       host->name);
 231             strcpy(host->name, paranoid);       /* name is bad, clobber it */
 232         }
 233         err = !err;
 234     }
 235     if (!err) {
 236         /* we are now sure that this is non-numeric */
 237
 238         /*
 239          * Verify that the address is a member of the address list returned
 240          * by gethostbyname(hostname).
 241          *
 242          * Verify also that gethostbyaddr() and gethostbyname() return the same
 243          * hostname, or rshd and rlogind may still end up being spoofed.
 244          *
 245          * On some sites, gethostbyname("localhost") returns "localhost.domain".
 246          * This is a DNS artefact. We treat it as a special case. When we
 247          * can't believe the address list from gethostbyname("localhost")
 248          * we're in big trouble anyway.
 249          */
 250
 251         memset(&hints, 0, sizeof(hints));
 252         hints.ai_family = sin->sa_family;
 253         hints.ai_socktype = SOCK_STREAM;
 254         hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
 255         if (getaddrinfo(host->name, NULL, &hints, &res0) != 0) {
 256
 257             /*
 258              * Unable to verify that the host name matches the address. This
 259              * may be a transient problem or a botched name server setup.
 260              */
 261
 262             tcpd_warn("can't verify hostname: getaddrinfo(%s, %s) failed",
 263                       host->name,
 264                       (sin->sa_family == AF_INET) ? "AF_INET" : "AF_INET6");
 265
 266         } else if ((res0->ai_canonname == NULL
 267                     || STR_NE(host->name, res0->ai_canonname))
 268                    && STR_NE(host->name, "localhost")) {
 269
 270             /*
 271              * The gethostbyaddr() and gethostbyname() calls did not return
 272              * the same hostname. This could be a nameserver configuration
 273              * problem. It could also be that someone is trying to spoof us.
 274              */
 275
 276             tcpd_warn("host name/name mismatch: %s != %.*s",
 277                       host->name, STRING_LENGTH,
 278                       (res0->ai_canonname == NULL) ? "" : res0->ai_canonname);
 279
 280         } else {
 281
 282             /*
 283              * The address should be a member of the address list returned by
 284              * gethostbyname(). We should first verify that the h_addrtype
 285              * field is AF_INET, but this program has already caused too much
 286              * grief on systems with broken library code.
 287              */
 288
 289             for (res = res0; res; res = res->ai_next) {
 290                 if (res->ai_family != sin->sa_family)
 291                     continue;
 292                 switch (res->ai_family) {
 293                 case AF_INET:
 294                     rap = (char *)&((struct sockaddr_in *)res->ai_addr)->sin_addr;
 295                     break;
 296                 case AF_INET6:
 297                     /* need to check scope_id */
 298                     if (((struct sockaddr_in6 *)sin)->sin6_scope_id !=
 299                         ((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id) {
 300                         continue;
 301                     }
 302                     rap = (char *)&((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
 303                     break;
 304                 default:
 305                     continue;
 306                 }
 307                 if (memcmp(rap, ap, alen) == 0) {
 308                     freeaddrinfo(res0);
 309                     return;                     /* name is good, keep it */
 310                 }
 311             }
 312
 313             /*
 314              * The host name does not map to the initial address. Perhaps
 315              * someone has messed up. Perhaps someone compromised a name
 316              * server.
 317              */
 318
 319             getnameinfo(sin, salen, hname, sizeof(hname),
 320                         NULL, 0, NI_NUMERICHOST | NI_WITHSCOPEID);
 321             tcpd_warn("host name/address mismatch: %s != %.*s",
 322                       hname, STRING_LENGTH,
 323                       (res0->ai_canonname == NULL) ? "" : res0->ai_canonname);
 324         }
 325         strcpy(host->name, paranoid);           /* name is bad, clobber it */
 326         if (res0)
 327             freeaddrinfo(res0);
 328     }
 329 #else /* INET6 */
 330     struct sockaddr_in *sin = host->sin;
 331     struct hostent *hp;
 332     int     i;
 333
 334     /*
 335      * On some systems, for example Solaris 2.3, gethostbyaddr(0.0.0.0) does
 336      * not fail. Instead it returns "INADDR_ANY". Unfortunately, this does
 337      * not work the other way around: gethostbyname("INADDR_ANY") fails. We
 338      * have to special-case 0.0.0.0, in order to avoid false alerts from the
 339      * host name/address checking code below.
 340      */
 341     if (sin != 0 && sin->sin_addr.s_addr != 0
 342         && (hp = gethostbyaddr((char *) &(sin->sin_addr),
 343                                sizeof(sin->sin_addr), AF_INET)) != 0) {
 344
 345         STRN_CPY(host->name, hp->h_name, sizeof(host->name));
 346
 347         /*
 348          * Verify that the address is a member of the address list returned
 349          * by gethostbyname(hostname).
 350          *
 351          * Verify also that gethostbyaddr() and gethostbyname() return the same
 352          * hostname, or rshd and rlogind may still end up being spoofed.
 353          *
 354          * On some sites, gethostbyname("localhost") returns "localhost.domain".
 355          * This is a DNS artefact. We treat it as a special case. When we
 356          * can't believe the address list from gethostbyname("localhost")
 357          * we're in big trouble anyway.
 358          */
 359
 360         if ((hp = gethostbyname(host->name)) == 0) {
 361
 362             /*
 363              * Unable to verify that the host name matches the address. This
 364              * may be a transient problem or a botched name server setup.
 365              */
 366
 367             tcpd_warn("can't verify hostname: gethostbyname(%s) failed",
 368                       host->name);
 369
 370         } else if (STR_NE(host->name, hp->h_name)
 371                    && STR_NE(host->name, "localhost")) {
 372
 373             /*
 374              * The gethostbyaddr() and gethostbyname() calls did not return
 375              * the same hostname. This could be a nameserver configuration
 376              * problem. It could also be that someone is trying to spoof us.
 377              */
 378
 379             tcpd_warn("host name/name mismatch: %s != %.*s",
 380                       host->name, STRING_LENGTH, hp->h_name);
 381
 382         } else {
 383
 384             /*
 385              * The address should be a member of the address list returned by
 386              * gethostbyname(). We should first verify that the h_addrtype
 387              * field is AF_INET, but this program has already caused too much
 388              * grief on systems with broken library code.
 389              */
 390
 391             for (i = 0; hp->h_addr_list[i]; i++) {
 392                 if (memcmp(hp->h_addr_list[i],
 393                            (char *) &sin->sin_addr,
 394                            sizeof(sin->sin_addr)) == 0)
 395                     return;                     /* name is good, keep it */
 396             }
 397
 398             /*
 399              * The host name does not map to the initial address. Perhaps
 400              * someone has messed up. Perhaps someone compromised a name
 401              * server.
 402              */
 403
 404             tcpd_warn("host name/address mismatch: %s != %.*s",
 405                       inet_ntoa(sin->sin_addr), STRING_LENGTH, hp->h_name);
 406         }
 407         strcpy(host->name, paranoid);           /* name is bad, clobber it */
 408     }
 409 #endif /* INET6 */
 410 }
 411
 412 /* sock_sink - absorb unreceived IP datagram */
 413
 414 static void sock_sink(fd)
 415 int     fd;
 416 {
 417     char    buf[BUFSIZ];
 418 #ifdef INET6
 419     struct sockaddr_storage sin;
 420 #else
 421     struct sockaddr_in sin;
 422 #endif
 423     int     size = sizeof(sin);
 424
 425     /*
 426      * Eat up the not-yet received datagram. Some systems insist on a
 427      * non-zero source address argument in the recvfrom() call below.
 428      */
 429
 430     (void) recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) & sin, &size);
 431 }