usr/src/lib/libwrap/tli.c

   1 /*
   2  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5
   6  /*
   7   * tli_host() determines the type of transport (connected, connectionless),
   8   * the transport address of a client host, and the transport address of a
   9   * server endpoint. In addition, it provides methods to map a transport
  10   * address to a printable host name or address. Socket address results are
  11   * in static memory; tli structures are allocated from the heap.
  12   *
  13   * The result from the hostname lookup method is STRING_PARANOID when a host
  14   * pretends to have someone elses name, or when a host name is available but
  15   * could not be verified.
  16   *
  17   * Diagnostics are reported through syslog(3).
  18   *
  19   * Author: Wietse Venema, Eindhoven University of Technology, The Netherlands.
  20   */
  21
  22 #ifndef lint
  23 static char sccsid[] = "@(#) tli.c 1.15 97/03/21 19:27:25";
  24 #endif
  25
  26 #ifdef TLI
  27
  28 /* System libraries. */
  29
  30 #include <sys/types.h>
  31 #include <sys/param.h>
  32 #include <sys/stream.h>
  33 #include <sys/stat.h>
  34 #include <sys/mkdev.h>
  35 #include <sys/tiuser.h>
  36 #include <sys/timod.h>
  37 #include <sys/socket.h>
  38 #include <netinet/in.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <unistd.h>
  42 #include <syslog.h>
  43 #include <errno.h>
  44 #include <netconfig.h>
  45 #include <netdir.h>
  46 #include <string.h>
  47
  48 extern char *nc_sperror();
  49 extern int errno;
  50 extern int t_errno;
  51 extern char *t_errlist[];
  52 extern int t_nerr;
  53
  54 /* Local stuff. */
  55
  56 #include "tcpd.h"
  57
  58 /* Forward declarations. */
  59
  60 static void tli_endpoints();
  61 static struct netconfig *tli_transport();
  62 static void tli_hostname();
  63 static void tli_hostaddr();
  64 static void tli_cleanup();
  65 static char *tli_error();
  66 static void tli_sink();
  67
  68 /* tli_host - look up endpoint addresses and install conversion methods */
  69
  70 void    tli_host(request)
  71 struct request_info *request;
  72 {
  73     static struct sockaddr_gen client;
  74     static struct sockaddr_gen server;
  75
  76     /*
  77      * If we discover that we are using an IP transport, pretend we never
  78      * were here. Otherwise, use the transport-independent method and stick
  79      * to generic network addresses. XXX hard-coded protocol family name.
  80      */
  81
  82     tli_endpoints(request);
  83     if ((request->config = tli_transport(request->fd)) != 0
  84         && (STR_EQ(request->config->nc_protofmly, "inet")
  85 #ifdef HAVE_IPV6
  86             || STR_EQ(request->config->nc_protofmly, "inet6")
  87 #endif
  88         )) {
  89         if (request->client->unit != 0) {
  90             memcpy(&client, request->client->unit->addr.buf,
  91                 SGSOCKADDRSZ((struct sockaddr_gen*)
  92                                 request->client->unit->addr.buf));
  93             request->client->sin = &client;
  94             sockgen_simplify(&client);
  95         }
  96         if (request->server->unit != 0) {
  97             memcpy(&server, request->server->unit->addr.buf,
  98                 SGSOCKADDRSZ((struct sockaddr_gen*)
  99                                 request->server->unit->addr.buf));
 100             request->server->sin = &server;
 101             sockgen_simplify(&server);
 102         }
 103         tli_cleanup(request);
 104         sock_methods(request);
 105     } else {
 106         request->hostname = tli_hostname;
 107         request->hostaddr = tli_hostaddr;
 108         request->cleanup = tli_cleanup;
 109     }
 110 }
 111
 112 /* tli_cleanup - cleanup some dynamically-allocated data structures */
 113
 114 static void tli_cleanup(request)
 115 struct request_info *request;
 116 {
 117     if (request->config != 0)
 118         freenetconfigent(request->config);
 119     if (request->client->unit != 0)
 120         t_free((char *) request->client->unit, T_UNITDATA);
 121     if (request->server->unit != 0)
 122         t_free((char *) request->server->unit, T_UNITDATA);
 123 }
 124
 125 /* tli_endpoints - determine TLI client and server endpoint information */
 126
 127 static void tli_endpoints(request)
 128 struct request_info *request;
 129 {
 130     struct t_unitdata *server;
 131     struct t_unitdata *client;
 132     int     fd = request->fd;
 133     int     flags;
 134
 135     /*
 136      * Determine the client endpoint address. With unconnected services, peek
 137      * at the sender address of the pending protocol data unit without
 138      * popping it off the receive queue. This trick works because only the
 139      * address member of the unitdata structure has been allocated.
 140      *
 141      * Beware of successful returns with zero-length netbufs (for example,
 142      * Solaris 2.3 with ticlts transport). The netdir(3) routines can't
 143      * handle that. Assume connection-less transport when TI_GETPEERNAME
 144      * produces no usable result, even when t_rcvudata() is unable to figure
 145      * out the peer address. Better to hang than to loop.
 146      */
 147
 148     if ((client = (struct t_unitdata *) t_alloc(fd, T_UNITDATA, T_ADDR)) == 0) {
 149         tcpd_warn("t_alloc: %s", tli_error());
 150         return;
 151     }
 152     if (ioctl(fd, TI_GETPEERNAME, &client->addr) < 0 || client->addr.len == 0) {
 153         request->sink = tli_sink;
 154         if (t_rcvudata(fd, client, &flags) < 0 || client->addr.len == 0) {
 155             tcpd_warn("can't get client address: %s", tli_error());
 156             t_free((void *) client, T_UNITDATA);
 157             return;
 158         }
 159     }
 160     request->client->unit = client;
 161
 162     /*
 163      * Look up the server endpoint address. This can be used for filtering on
 164      * server address or name, or to look up the client user.
 165      */
 166
 167     if ((server = (struct t_unitdata *) t_alloc(fd, T_UNITDATA, T_ADDR)) == 0) {
 168         tcpd_warn("t_alloc: %s", tli_error());
 169         return;
 170     }
 171     if (ioctl(fd, TI_GETMYNAME, &server->addr) < 0) {
 172         tcpd_warn("TI_GETMYNAME: %m");
 173         t_free((void *) server, T_UNITDATA);
 174         return;
 175     }
 176     request->server->unit = server;
 177 }
 178
 179 /* tli_transport - find out TLI transport type */
 180
 181 static struct netconfig *tli_transport(fd)
 182 int     fd;
 183 {
 184     struct stat from_client;
 185     struct stat from_config;
 186     void   *handlep;
 187     struct netconfig *config;
 188
 189     /*
 190      * Assuming that the network device is a clone device, we must compare
 191      * the major device number of stdin to the minor device number of the
 192      * devices listed in the netconfig table.
 193      */
 194
 195     if (fstat(fd, &from_client) != 0) {
 196         tcpd_warn("fstat(fd %d): %m", fd);
 197         return (0);
 198     }
 199     if ((handlep = setnetconfig()) == 0) {
 200         tcpd_warn("setnetconfig: %m");
 201         return (0);
 202     }
 203     while (config = getnetconfig(handlep)) {
 204         if (stat(config->nc_device, &from_config) == 0) {
 205             if (minor(from_config.st_rdev) == major(from_client.st_rdev) ||
 206                 /* XXX: Solaris 8 no longer has clone devices for IP */
 207                 major(from_config.st_rdev) == major(from_client.st_rdev))
 208                 break;
 209         }
 210     }
 211     if (config == 0) {
 212         tcpd_warn("unable to identify transport protocol");
 213         return (0);
 214     }
 215
 216     /*
 217      * Something else may clobber our getnetconfig() result, so we'd better
 218      * acquire our private copy.
 219      */
 220
 221     if ((config = getnetconfigent(config->nc_netid)) == 0) {
 222         tcpd_warn("getnetconfigent(%s): %s", config->nc_netid, nc_sperror());
 223         return (0);
 224     }
 225     return (config);
 226 }
 227
 228 /* tli_hostaddr - map TLI transport address to printable address */
 229
 230 static void tli_hostaddr(host)
 231 struct host_info *host;
 232 {
 233     struct request_info *request = host->request;
 234     struct netconfig *config = request->config;
 235     struct t_unitdata *unit = host->unit;
 236     char   *uaddr;
 237
 238     if (config != 0 && unit != 0
 239         && (uaddr = taddr2uaddr(config, &unit->addr)) != 0) {
 240         STRN_CPY(host->addr, uaddr, sizeof(host->addr));
 241         free(uaddr);
 242     }
 243 }
 244
 245 /* tli_hostname - map TLI transport address to hostname */
 246
 247 static void tli_hostname(host)
 248 struct host_info *host;
 249 {
 250     struct request_info *request = host->request;
 251     struct netconfig *config = request->config;
 252     struct t_unitdata *unit = host->unit;
 253     struct nd_hostservlist *servlist;
 254
 255     if (config != 0 && unit != 0
 256         && netdir_getbyaddr(config, &servlist, &unit->addr) == ND_OK) {
 257
 258         struct nd_hostserv *service = servlist->h_hostservs;
 259         struct nd_addrlist *addr_list;
 260         int     found = 0;
 261
 262         if (netdir_getbyname(config, service, &addr_list) != ND_OK) {
 263
 264             /*
 265              * Unable to verify that the name matches the address. This may
 266              * be a transient problem or a botched name server setup. We
 267              * decide to play safe.
 268              */
 269
 270             tcpd_warn("can't verify hostname: netdir_getbyname(%.*s) failed",
 271                       STRING_LENGTH, service->h_host);
 272
 273         } else {
 274
 275             /*
 276              * Look up the host address in the address list we just got. The
 277              * comparison is done on the textual representation, because the
 278              * transport address is an opaque structure that may have holes
 279              * with uninitialized garbage. This approach obviously loses when
 280              * the address does not have a textual representation.
 281              */
 282
 283             char   *uaddr = eval_hostaddr(host);
 284             char   *ua;
 285             int     i;
 286
 287             for (i = 0; found == 0 && i < addr_list->n_cnt; i++) {
 288                 if ((ua = taddr2uaddr(config, &(addr_list->n_addrs[i]))) != 0) {
 289                     found = !strcmp(ua, uaddr);
 290                     free(ua);
 291                 }
 292             }
 293             netdir_free((void *) addr_list, ND_ADDRLIST);
 294
 295             /*
 296              * When the host name does not map to the initial address, assume
 297              * someone has compromised a name server. More likely someone
 298              * botched it, but that could be dangerous, too.
 299              */
 300
 301             if (found == 0)
 302                 tcpd_warn("host name/address mismatch: %s != %.*s",
 303                           host->addr, STRING_LENGTH, service->h_host);
 304         }
 305         STRN_CPY(host->name, found ? service->h_host : paranoid,
 306                  sizeof(host->name));
 307         netdir_free((void *) servlist, ND_HOSTSERVLIST);
 308     }
 309 }
 310
 311 /* tli_error - convert tli error number to text */
 312
 313 static char *tli_error()
 314 {
 315     static char buf[40];
 316
 317     if (t_errno != TSYSERR) {
 318         if (t_errno < 0 || t_errno >= t_nerr) {
 319             snprintf(buf, sizeof (buf), "Unknown TLI error %d", t_errno);
 320             return (buf);
 321         } else {
 322             return (t_errlist[t_errno]);
 323         }
 324     } else {
 325         STRN_CPY(buf, strerror(errno), sizeof (buf));
 326         return (buf);
 327     }
 328 }
 329
 330 /* tli_sink - absorb unreceived datagram */
 331
 332 static void tli_sink(fd)
 333 int     fd;
 334 {
 335     struct t_unitdata *unit;
 336     int     flags;
 337
 338     /*
 339      * Something went wrong. Absorb the datagram to keep inetd from looping.
 340      * Allocate storage for address, control and data. If that fails, sleep
 341      * for a couple of seconds in an attempt to keep inetd from looping too
 342      * fast.
 343      */
 344
 345     if ((unit = (struct t_unitdata *) t_alloc(fd, T_UNITDATA, T_ALL)) == 0) {
 346         tcpd_warn("t_alloc: %s", tli_error());
 347         sleep(5);
 348     } else {
 349         (void) t_rcvudata(fd, unit, &flags);
 350         t_free((void *) unit, T_UNITDATA);
 351     }
 352 }
 353
 354 #endif /* TLI */