usr.sbin/inetd/inetd.c

   1 /*
   2  * Copyright (c) 1983, 1991, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 static const char copyright[] =
  36 "@(#) Copyright (c) 1983, 1991, 1993, 1994\n\
  37         The Regents of the University of California.  All rights reserved.\n";
  38 #endif /* not lint */
  39
  40 #ifndef lint
  41 #if 0
  42 static char sccsid[] = "@(#)from: inetd.c       8.4 (Berkeley) 4/13/94";
  43 #endif
  44 #endif /* not lint */
  45
  46 #include <sys/cdefs.h>
  47 __FBSDID("$FreeBSD$");
  48
  49 /*
  50  * Inetd - Internet super-server
  51  *
  52  * This program invokes all internet services as needed.  Connection-oriented
  53  * services are invoked each time a connection is made, by creating a process.
  54  * This process is passed the connection as file descriptor 0 and is expected
  55  * to do a getpeername to find out the source host and port.
  56  *
  57  * Datagram oriented services are invoked when a datagram
  58  * arrives; a process is created and passed a pending message
  59  * on file descriptor 0.  Datagram servers may either connect
  60  * to their peer, freeing up the original socket for inetd
  61  * to receive further messages on, or ``take over the socket'',
  62  * processing all arriving datagrams and, eventually, timing
  63  * out.  The first type of server is said to be ``multi-threaded'';
  64  * the second type of server ``single-threaded''.
  65  *
  66  * Inetd uses a configuration file which is read at startup
  67  * and, possibly, at some later time in response to a hangup signal.
  68  * The configuration file is ``free format'' with fields given in the
  69  * order shown below.  Continuation lines for an entry must begin with
  70  * a space or tab.  All fields must be present in each entry.
  71  *
  72  *      service name                    must be in /etc/services
  73  *                                      or name a tcpmux service
  74  *                                      or specify a unix domain socket
  75  *      socket type                     stream/dgram/raw/rdm/seqpacket
  76  *      protocol                        tcp[4][6][/faith,ttcp], udp[4][6], unix
  77  *      wait/nowait                     single-threaded/multi-threaded
  78  *      user                            user to run daemon as
  79  *      server program                  full path name
  80  *      server program arguments        maximum of MAXARGS (20)
  81  *
  82  * TCP services without official port numbers are handled with the
  83  * RFC1078-based tcpmux internal service. Tcpmux listens on port 1 for
  84  * requests. When a connection is made from a foreign host, the service
  85  * requested is passed to tcpmux, which looks it up in the servtab list
  86  * and returns the proper entry for the service. Tcpmux returns a
  87  * negative reply if the service doesn't exist, otherwise the invoked
  88  * server is expected to return the positive reply if the service type in
  89  * inetd.conf file has the prefix "tcpmux/". If the service type has the
  90  * prefix "tcpmux/+", tcpmux will return the positive reply for the
  91  * process; this is for compatibility with older server code, and also
  92  * allows you to invoke programs that use stdin/stdout without putting any
  93  * special server code in them. Services that use tcpmux are "nowait"
  94  * because they do not have a well-known port and hence cannot listen
  95  * for new requests.
  96  *
  97  * For RPC services
  98  *      service name/version            must be in /etc/rpc
  99  *      socket type                     stream/dgram/raw/rdm/seqpacket
 100  *      protocol                        rpc/tcp[4][6], rpc/udp[4][6]
 101  *      wait/nowait                     single-threaded/multi-threaded
 102  *      user                            user to run daemon as
 103  *      server program                  full path name
 104  *      server program arguments        maximum of MAXARGS
 105  *
 106  * Comment lines are indicated by a `#' in column 1.
 107  *
 108  * #ifdef IPSEC
 109  * Comment lines that start with "#@" denote IPsec policy string, as described
 110  * in ipsec_set_policy(3).  This will affect all the following items in
 111  * inetd.conf(8).  To reset the policy, just use "#@" line.  By default,
 112  * there's no IPsec policy.
 113  * #endif
 114  */
 115 #include <sys/param.h>
 116 #include <sys/ioctl.h>
 117 #include <sys/wait.h>
 118 #include <sys/time.h>
 119 #include <sys/resource.h>
 120 #include <sys/stat.h>
 121 #include <sys/un.h>
 122
 123 #include <netinet/in.h>
 124 #include <netinet/tcp.h>
 125 #include <arpa/inet.h>
 126 #include <rpc/rpc.h>
 127 #include <rpc/pmap_clnt.h>
 128
 129 #include <errno.h>
 130 #include <err.h>
 131 #include <fcntl.h>
 132 #include <grp.h>
 133 #include <netdb.h>
 134 #include <pwd.h>
 135 #include <signal.h>
 136 #include <stdio.h>
 137 #include <stdlib.h>
 138 #include <string.h>
 139 #include <syslog.h>
 140 #include <tcpd.h>
 141 #include <unistd.h>
 142 #include <libutil.h>
 143 #include <sysexits.h>
 144 #include <ctype.h>
 145
 146 #include "inetd.h"
 147 #include "pathnames.h"
 148
 149 #ifdef IPSEC
 150 #include <netinet6/ipsec.h>
 151 #ifndef IPSEC_POLICY_IPSEC      /* no ipsec support on old ipsec */
 152 #undef IPSEC
 153 #endif
 154 #endif
 155
 156 /* wrapper for KAME-special getnameinfo() */
 157 #ifndef NI_WITHSCOPEID
 158 #define NI_WITHSCOPEID  0
 159 #endif
 160
 161 #ifndef LIBWRAP_ALLOW_FACILITY
 162 # define LIBWRAP_ALLOW_FACILITY LOG_AUTH
 163 #endif
 164 #ifndef LIBWRAP_ALLOW_SEVERITY
 165 # define LIBWRAP_ALLOW_SEVERITY LOG_INFO
 166 #endif
 167 #ifndef LIBWRAP_DENY_FACILITY
 168 # define LIBWRAP_DENY_FACILITY LOG_AUTH
 169 #endif
 170 #ifndef LIBWRAP_DENY_SEVERITY
 171 # define LIBWRAP_DENY_SEVERITY LOG_WARNING
 172 #endif
 173
 174 #define ISWRAP(sep)     \
 175            ( ((wrap_ex && !(sep)->se_bi) || (wrap_bi && (sep)->se_bi)) \
 176         && (sep->se_family == AF_INET || sep->se_family == AF_INET6) \
 177         && ( ((sep)->se_accept && (sep)->se_socktype == SOCK_STREAM) \
 178             || (sep)->se_socktype == SOCK_DGRAM))
 179
 180 #ifdef LOGIN_CAP
 181 #include <login_cap.h>
 182
 183 /* see init.c */
 184 #define RESOURCE_RC "daemon"
 185
 186 #endif
 187
 188 #ifndef MAXCHILD
 189 #define MAXCHILD        -1              /* maximum number of this service
 190                                            < 0 = no limit */
 191 #endif
 192
 193 #ifndef MAXCPM
 194 #define MAXCPM          -1              /* rate limit invocations from a
 195                                            single remote address,
 196                                            < 0 = no limit */
 197 #endif
 198
 199 #ifndef MAXPERIP
 200 #define MAXPERIP        -1              /* maximum number of this service
 201                                            from a single remote address,
 202                                            < 0 = no limit */
 203 #endif
 204
 205 #ifndef TOOMANY
 206 #define TOOMANY         256             /* don't start more than TOOMANY */
 207 #endif
 208 #define CNT_INTVL       60              /* servers in CNT_INTVL sec. */
 209 #define RETRYTIME       (60*10)         /* retry after bind or server fail */
 210 #define MAX_MAXCHLD     32767           /* max allowable max children */
 211
 212 #define SIGBLOCK        (sigmask(SIGCHLD)|sigmask(SIGHUP)|sigmask(SIGALRM))
 213
 214 void            close_sep(struct servtab *);
 215 void            flag_signal(int);
 216 void            flag_config(int);
 217 void            config(void);
 218 int             cpmip(const struct servtab *, int);
 219 void            endconfig(void);
 220 struct servtab *enter(struct servtab *);
 221 void            freeconfig(struct servtab *);
 222 struct servtab *getconfigent(void);
 223 int             matchservent(const char *, const char *, const char *);
 224 char           *nextline(FILE *);
 225 void            addchild(struct servtab *, int);
 226 void            flag_reapchild(int);
 227 void            reapchild(void);
 228 void            enable(struct servtab *);
 229 void            disable(struct servtab *);
 230 void            flag_retry(int);
 231 void            retry(void);
 232 int             setconfig(void);
 233 void            setup(struct servtab *);
 234 #ifdef IPSEC
 235 void            ipsecsetup(struct servtab *);
 236 #endif
 237 void            unregisterrpc(register struct servtab *sep);
 238 static struct conninfo *search_conn(struct servtab *sep, int ctrl);
 239 static int      room_conn(struct servtab *sep, struct conninfo *conn);
 240 static void     addchild_conn(struct conninfo *conn, pid_t pid);
 241 static void     reapchild_conn(pid_t pid);
 242 static void     free_conn(struct conninfo *conn);
 243 static void     resize_conn(struct servtab *sep, int maxperip);
 244 static void     free_connlist(struct servtab *sep);
 245 static void     free_proc(struct procinfo *);
 246 static struct procinfo *search_proc(pid_t pid, int add);
 247 static int      hashval(char *p, int len);
 248
 249 int     allow_severity;
 250 int     deny_severity;
 251 int     wrap_ex = 0;
 252 int     wrap_bi = 0;
 253 int     debug = 0;
 254 int     log = 0;
 255 int     maxsock;                        /* highest-numbered descriptor */
 256 fd_set  allsock;
 257 int     options;
 258 int     timingout;
 259 int     toomany = TOOMANY;
 260 int     maxchild = MAXCHILD;
 261 int     maxcpm = MAXCPM;
 262 int     maxperip = MAXPERIP;
 263 struct  servent *sp;
 264 struct  rpcent *rpc;
 265 char    *hostname = NULL;
 266 struct  sockaddr_in *bind_sa4;
 267 int     v4bind_ok = 0;
 268 #ifdef INET6
 269 struct  sockaddr_in6 *bind_sa6;
 270 int     v6bind_ok = 0;
 271 #endif
 272 int     signalpipe[2];
 273 #ifdef SANITY_CHECK
 274 int     nsock;
 275 #endif
 276 uid_t   euid;
 277 gid_t   egid;
 278 mode_t  mask;
 279
 280 struct  servtab *servtab;
 281
 282 extern struct biltin biltins[];
 283
 284 const char      *CONFIG = _PATH_INETDCONF;
 285 const char      *pid_file = _PATH_INETDPID;
 286
 287 struct netconfig *udpconf, *tcpconf, *udp6conf, *tcp6conf;
 288
 289 static LIST_HEAD(, procinfo) proctable[PERIPSIZE];
 290
 291 int
 292 getvalue(const char *arg, int *value, const char *whine)
 293 {
 294         int  tmp;
 295         char *p;
 296
 297         tmp = strtol(arg, &p, 0);
 298         if (tmp < 0 || *p) {
 299                 syslog(LOG_ERR, whine, arg);
 300                 return 1;                       /* failure */
 301         }
 302         *value = tmp;
 303         return 0;                               /* success */
 304 }
 305
 306 int
 307 main(int argc, char **argv)
 308 {
 309         struct servtab *sep;
 310         struct passwd *pwd;
 311         struct group *grp;
 312         struct sigaction sa, saalrm, sachld, sahup, sapipe;
 313         int tmpint, ch, dofork;
 314         pid_t pid;
 315         char buf[50];
 316 #ifdef LOGIN_CAP
 317         login_cap_t *lc = NULL;
 318 #endif
 319         struct request_info req;
 320         int denied;
 321         char *service = NULL;
 322         union {
 323                 struct sockaddr peer_un;
 324                 struct sockaddr_in peer_un4;
 325                 struct sockaddr_in6 peer_un6;
 326                 struct sockaddr_storage peer_max;
 327         } p_un;
 328 #define peer    p_un.peer_un
 329 #define peer4   p_un.peer_un4
 330 #define peer6   p_un.peer_un6
 331 #define peermax p_un.peer_max
 332         int i;
 333         struct addrinfo hints, *res;
 334         const char *servname;
 335         int error;
 336         struct conninfo *conn;
 337
 338         openlog("inetd", LOG_PID | LOG_NOWAIT | LOG_PERROR, LOG_DAEMON);
 339
 340         while ((ch = getopt(argc, argv, "dlwWR:a:c:C:p:s:")) != -1)
 341                 switch(ch) {
 342                 case 'd':
 343                         debug = 1;
 344                         options |= SO_DEBUG;
 345                         break;
 346                 case 'l':
 347                         log = 1;
 348                         break;
 349                 case 'R':
 350                         getvalue(optarg, &toomany,
 351                                 "-R %s: bad value for service invocation rate");
 352                         break;
 353                 case 'c':
 354                         getvalue(optarg, &maxchild,
 355                                 "-c %s: bad value for maximum children");
 356                         break;
 357                 case 'C':
 358                         getvalue(optarg, &maxcpm,
 359                                 "-C %s: bad value for maximum children/minute");
 360                         break;
 361                 case 'a':
 362                         hostname = optarg;
 363                         break;
 364                 case 'p':
 365                         pid_file = optarg;
 366                         break;
 367                 case 's':
 368                         getvalue(optarg, &maxperip,
 369                                 "-s %s: bad value for maximum children per source address");
 370                         break;
 371                 case 'w':
 372                         wrap_ex++;
 373                         break;
 374                 case 'W':
 375                         wrap_bi++;
 376                         break;
 377                 case '?':
 378                 default:
 379                         syslog(LOG_ERR,
 380                                 "usage: inetd [-dlwW] [-a address] [-R rate]"
 381                                 " [-c maximum] [-C rate]"
 382                                 " [-p pidfile] [conf-file]");
 383                         exit(EX_USAGE);
 384                 }
 385         /*
 386          * Initialize Bind Addrs.
 387          *   When hostname is NULL, wild card bind addrs are obtained from
 388          *   getaddrinfo(). But getaddrinfo() requires at least one of
 389          *   hostname or servname is non NULL.
 390          *   So when hostname is NULL, set dummy value to servname.
 391          */
 392         servname = (hostname == NULL) ? "discard" /* dummy */ : NULL;
 393
 394         bzero(&hints, sizeof(struct addrinfo));
 395         hints.ai_flags = AI_PASSIVE;
 396         hints.ai_family = AF_UNSPEC;
 397         error = getaddrinfo(hostname, servname, &hints, &res);
 398         if (error != 0) {
 399                 syslog(LOG_ERR, "-a %s: %s", hostname, gai_strerror(error));
 400                 if (error == EAI_SYSTEM)
 401                         syslog(LOG_ERR, "%s", strerror(errno));
 402                 exit(EX_USAGE);
 403         }
 404         do {
 405                 if (res->ai_addr == NULL) {
 406                         syslog(LOG_ERR, "-a %s: getaddrinfo failed", hostname);
 407                         exit(EX_USAGE);
 408                 }
 409                 switch (res->ai_addr->sa_family) {
 410                 case AF_INET:
 411                         if (v4bind_ok)
 412                                 continue;
 413                         bind_sa4 = (struct sockaddr_in *)res->ai_addr;
 414                         /* init port num in case servname is dummy */
 415                         bind_sa4->sin_port = 0;
 416                         v4bind_ok = 1;
 417                         continue;
 418 #ifdef INET6
 419                 case AF_INET6:
 420                         if (v6bind_ok)
 421                                 continue;
 422                         bind_sa6 = (struct sockaddr_in6 *)res->ai_addr;
 423                         /* init port num in case servname is dummy */
 424                         bind_sa6->sin6_port = 0;
 425                         v6bind_ok = 1;
 426                         continue;
 427 #endif
 428                 }
 429                 if (v4bind_ok
 430 #ifdef INET6
 431                     && v6bind_ok
 432 #endif
 433                     )
 434                         break;
 435         } while ((res = res->ai_next) != NULL);
 436         if (!v4bind_ok
 437 #ifdef INET6
 438             && !v6bind_ok
 439 #endif
 440             ) {
 441                 syslog(LOG_ERR, "-a %s: unknown address family", hostname);
 442                 exit(EX_USAGE);
 443         }
 444
 445         euid = geteuid();
 446         egid = getegid();
 447         umask(mask = umask(0777));
 448
 449         argc -= optind;
 450         argv += optind;
 451
 452         if (argc > 0)
 453                 CONFIG = argv[0];
 454         if (debug == 0) {
 455                 FILE *fp;
 456                 if (daemon(0, 0) < 0) {
 457                         syslog(LOG_WARNING, "daemon(0,0) failed: %m");
 458                 }
 459                 /* From now on we don't want syslog messages going to stderr. */
 460                 closelog();
 461                 openlog("inetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
 462                 /*
 463                  * In case somebody has started inetd manually, we need to
 464                  * clear the logname, so that old servers run as root do not
 465                  * get the user's logname..
 466                  */
 467                 if (setlogin("") < 0) {
 468                         syslog(LOG_WARNING, "cannot clear logname: %m");
 469                         /* no big deal if it fails.. */
 470                 }
 471                 pid = getpid();
 472                 fp = fopen(pid_file, "w");
 473                 if (fp) {
 474                         fprintf(fp, "%ld\n", (long)pid);
 475                         fclose(fp);
 476                 } else {
 477                         syslog(LOG_WARNING, "%s: %m", pid_file);
 478                 }
 479         }
 480
 481         for (i = 0; i < PERIPSIZE; ++i)
 482                 LIST_INIT(&proctable[i]);
 483
 484         if (v4bind_ok) {
 485                 udpconf = getnetconfigent("udp");
 486                 tcpconf = getnetconfigent("tcp");
 487                 if (udpconf == NULL || tcpconf == NULL) {
 488                         syslog(LOG_ERR, "unknown rpc/udp or rpc/tcp");
 489                         exit(EX_USAGE);
 490                 }
 491         }
 492 #ifdef INET6
 493         if (v6bind_ok) {
 494                 udp6conf = getnetconfigent("udp6");
 495                 tcp6conf = getnetconfigent("tcp6");
 496                 if (udp6conf == NULL || tcp6conf == NULL) {
 497                         syslog(LOG_ERR, "unknown rpc/udp6 or rpc/tcp6");
 498                         exit(EX_USAGE);
 499                 }
 500         }
 501 #endif
 502
 503         sa.sa_flags = 0;
 504         sigemptyset(&sa.sa_mask);
 505         sigaddset(&sa.sa_mask, SIGALRM);
 506         sigaddset(&sa.sa_mask, SIGCHLD);
 507         sigaddset(&sa.sa_mask, SIGHUP);
 508         sa.sa_handler = flag_retry;
 509         sigaction(SIGALRM, &sa, &saalrm);
 510         config();
 511         sa.sa_handler = flag_config;
 512         sigaction(SIGHUP, &sa, &sahup);
 513         sa.sa_handler = flag_reapchild;
 514         sigaction(SIGCHLD, &sa, &sachld);
 515         sa.sa_handler = SIG_IGN;
 516         sigaction(SIGPIPE, &sa, &sapipe);
 517
 518         {
 519                 /* space for daemons to overwrite environment for ps */
 520 #define DUMMYSIZE       100
 521                 char dummy[DUMMYSIZE];
 522
 523                 (void)memset(dummy, 'x', DUMMYSIZE - 1);
 524                 dummy[DUMMYSIZE - 1] = '\0';
 525                 (void)setenv("inetd_dummy", dummy, 1);
 526         }
 527
 528         if (pipe(signalpipe) != 0) {
 529                 syslog(LOG_ERR, "pipe: %m");
 530                 exit(EX_OSERR);
 531         }
 532         FD_SET(signalpipe[0], &allsock);
 533 #ifdef SANITY_CHECK
 534         nsock++;
 535 #endif
 536         if (signalpipe[0] > maxsock)
 537             maxsock = signalpipe[0];
 538         if (signalpipe[1] > maxsock)
 539             maxsock = signalpipe[1];
 540
 541         for (;;) {
 542             int n, ctrl;
 543             fd_set readable;
 544
 545 #ifdef SANITY_CHECK
 546             if (nsock == 0) {
 547                 syslog(LOG_ERR, "%s: nsock=0", __FUNCTION__);
 548                 exit(EX_SOFTWARE);
 549             }
 550 #endif
 551             readable = allsock;
 552             if ((n = select(maxsock + 1, &readable, (fd_set *)0,
 553                 (fd_set *)0, (struct timeval *)0)) <= 0) {
 554                     if (n < 0 && errno != EINTR) {
 555                         syslog(LOG_WARNING, "select: %m");
 556                         sleep(1);
 557                     }
 558                     continue;
 559             }
 560             /* handle any queued signal flags */
 561             if (FD_ISSET(signalpipe[0], &readable)) {
 562                 int nsig;
 563                 if (ioctl(signalpipe[0], FIONREAD, &nsig) != 0) {
 564                     syslog(LOG_ERR, "ioctl: %m");
 565                     exit(EX_OSERR);
 566                 }
 567                 while (--nsig >= 0) {
 568                     char c;
 569                     if (read(signalpipe[0], &c, 1) != 1) {
 570                         syslog(LOG_ERR, "read: %m");
 571                         exit(EX_OSERR);
 572                     }
 573                     if (debug)
 574                         warnx("handling signal flag %c", c);
 575                     switch(c) {
 576                     case 'A': /* sigalrm */
 577                         retry();
 578                         break;
 579                     case 'C': /* sigchld */
 580                         reapchild();
 581                         break;
 582                     case 'H': /* sighup */
 583                         config();
 584                         break;
 585                     }
 586                 }
 587             }
 588             for (sep = servtab; n && sep; sep = sep->se_next)
 589                 if (sep->se_fd != -1 && FD_ISSET(sep->se_fd, &readable)) {
 590                     n--;
 591                     if (debug)
 592                             warnx("someone wants %s", sep->se_service);
 593                     dofork = !sep->se_bi || sep->se_bi->bi_fork || ISWRAP(sep);
 594                     conn = NULL;
 595                     if (sep->se_accept && sep->se_socktype == SOCK_STREAM) {
 596                             i = 1;
 597                             if (ioctl(sep->se_fd, FIONBIO, &i) < 0)
 598                                     syslog(LOG_ERR, "ioctl (FIONBIO, 1): %m");
 599                             ctrl = accept(sep->se_fd, (struct sockaddr *)0,
 600                                 (socklen_t *)0);
 601                             if (debug)
 602                                     warnx("accept, ctrl %d", ctrl);
 603                             if (ctrl < 0) {
 604                                     if (errno != EINTR)
 605                                             syslog(LOG_WARNING,
 606                                                 "accept (for %s): %m",
 607                                                 sep->se_service);
 608                                       if (sep->se_accept &&
 609                                           sep->se_socktype == SOCK_STREAM)
 610                                               close(ctrl);
 611                                     continue;
 612                             }
 613                             i = 0;
 614                             if (ioctl(sep->se_fd, FIONBIO, &i) < 0)
 615                                     syslog(LOG_ERR, "ioctl1(FIONBIO, 0): %m");
 616                             if (ioctl(ctrl, FIONBIO, &i) < 0)
 617                                     syslog(LOG_ERR, "ioctl2(FIONBIO, 0): %m");
 618                             if (cpmip(sep, ctrl) < 0) {
 619                                 close(ctrl);
 620                                 continue;
 621                             }
 622                             if (dofork &&
 623                                 (conn = search_conn(sep, ctrl)) != NULL &&
 624                                 !room_conn(sep, conn)) {
 625                                 close(ctrl);
 626                                 continue;
 627                             }
 628                     } else
 629                             ctrl = sep->se_fd;
 630                     if (log && !ISWRAP(sep)) {
 631                             char pname[INET6_ADDRSTRLEN] = "unknown";
 632                             socklen_t sl;
 633                             sl = sizeof peermax;
 634                             if (getpeername(ctrl, (struct sockaddr *)
 635                                             &peermax, &sl)) {
 636                                     sl = sizeof peermax;
 637                                     if (recvfrom(ctrl, buf, sizeof(buf),
 638                                         MSG_PEEK,
 639                                         (struct sockaddr *)&peermax,
 640                                         &sl) >= 0) {
 641                                       getnameinfo((struct sockaddr *)&peermax,
 642                                                   peer.sa_len,
 643                                                   pname, sizeof(pname),
 644                                                   NULL, 0,
 645                                                   NI_NUMERICHOST|
 646                                                   NI_WITHSCOPEID);
 647                                     }
 648                             } else {
 649                                     getnameinfo((struct sockaddr *)&peermax,
 650                                                 peer.sa_len,
 651                                                 pname, sizeof(pname),
 652                                                 NULL, 0,
 653                                                 NI_NUMERICHOST|
 654                                                 NI_WITHSCOPEID);
 655                             }
 656                             syslog(LOG_INFO,"%s from %s", sep->se_service, pname);
 657                     }
 658                     (void) sigblock(SIGBLOCK);
 659                     pid = 0;
 660                     /*
 661                      * Fork for all external services, builtins which need to
 662                      * fork and anything we're wrapping (as wrapping might
 663                      * block or use hosts_options(5) twist).
 664                      */
 665                     if (dofork) {
 666                             if (sep->se_count++ == 0)
 667                                 (void)gettimeofday(&sep->se_time, (struct timezone *)NULL);
 668                             else if (toomany > 0 && sep->se_count >= toomany) {
 669                                 struct timeval now;
 670
 671                                 (void)gettimeofday(&now, (struct timezone *)NULL);
 672                                 if (now.tv_sec - sep->se_time.tv_sec >
 673                                     CNT_INTVL) {
 674                                         sep->se_time = now;
 675                                         sep->se_count = 1;
 676                                 } else {
 677                                         syslog(LOG_ERR,
 678                         "%s/%s server failing (looping), service terminated",
 679                                             sep->se_service, sep->se_proto);
 680                                         if (sep->se_accept &&
 681                                             sep->se_socktype == SOCK_STREAM)
 682                                                 close(ctrl);
 683                                         close_sep(sep);
 684                                         free_conn(conn);
 685                                         sigsetmask(0L);
 686                                         if (!timingout) {
 687                                                 timingout = 1;
 688                                                 alarm(RETRYTIME);
 689                                         }
 690                                         continue;
 691                                 }
 692                             }
 693                             pid = fork();
 694                     }
 695                     if (pid < 0) {
 696                             syslog(LOG_ERR, "fork: %m");
 697                             if (sep->se_accept &&
 698                                 sep->se_socktype == SOCK_STREAM)
 699                                     close(ctrl);
 700                             free_conn(conn);
 701                             sigsetmask(0L);
 702                             sleep(1);
 703                             continue;
 704                     }
 705                     if (pid) {
 706                         addchild_conn(conn, pid);
 707                         addchild(sep, pid);
 708                     }
 709                     sigsetmask(0L);
 710                     if (pid == 0) {
 711                             if (dofork) {
 712                                 if (debug)
 713                                         warnx("+ closing from %d", maxsock);
 714                                 for (tmpint = maxsock; tmpint > 2; tmpint--)
 715                                         if (tmpint != ctrl)
 716                                                 (void) close(tmpint);
 717                                 sigaction(SIGALRM, &saalrm, (struct sigaction *)0);
 718                                 sigaction(SIGCHLD, &sachld, (struct sigaction *)0);
 719                                 sigaction(SIGHUP, &sahup, (struct sigaction *)0);
 720                                 /* SIGPIPE reset before exec */
 721                             }
 722                             /*
 723                              * Call tcpmux to find the real service to exec.
 724                              */
 725                             if (sep->se_bi &&
 726                                 sep->se_bi->bi_fn == (bi_fn_t *) tcpmux) {
 727                                     sep = tcpmux(ctrl);
 728                                     if (sep == NULL) {
 729                                             close(ctrl);
 730                                             _exit(0);
 731                                     }
 732                             }
 733                             if (ISWRAP(sep)) {
 734                                 inetd_setproctitle("wrapping", ctrl);
 735                                 service = sep->se_server_name ?
 736                                     sep->se_server_name : sep->se_service;
 737                                 request_init(&req, RQ_DAEMON, service, RQ_FILE, ctrl, NULL);
 738                                 fromhost(&req);
 739                                 deny_severity = LIBWRAP_DENY_FACILITY|LIBWRAP_DENY_SEVERITY;
 740                                 allow_severity = LIBWRAP_ALLOW_FACILITY|LIBWRAP_ALLOW_SEVERITY;
 741                                 denied = !hosts_access(&req);
 742                                 if (denied) {
 743                                     syslog(deny_severity,
 744                                         "refused connection from %.500s, service %s (%s%s)",
 745                                         eval_client(&req), service, sep->se_proto,
 746                                         (((struct sockaddr *)req.client->sin)->sa_family == AF_INET6 && !IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)req.client->sin)->sin6_addr)) ? "6" : "");
 747                                     if (sep->se_socktype != SOCK_STREAM)
 748                                         recv(ctrl, buf, sizeof (buf), 0);
 749                                     if (dofork) {
 750                                         sleep(1);
 751                                         _exit(0);
 752                                     }
 753                                 }
 754                                 if (log) {
 755                                     syslog(allow_severity,
 756                                         "connection from %.500s, service %s (%s%s)",
 757                                         eval_client(&req), service, sep->se_proto,
 758                                         (((struct sockaddr *)req.client->sin)->sa_family == AF_INET6 && !IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)req.client->sin)->sin6_addr)) ? "6" : "");
 759                                 }
 760                             }
 761                             if (sep->se_bi) {
 762                                 (*sep->se_bi->bi_fn)(ctrl, sep);
 763                             } else {
 764                                 if (debug)
 765                                         warnx("%d execl %s",
 766                                                 getpid(), sep->se_server);
 767                                 dup2(ctrl, 0);
 768                                 close(ctrl);
 769                                 dup2(0, 1);
 770                                 dup2(0, 2);
 771                                 if ((pwd = getpwnam(sep->se_user)) == NULL) {
 772                                         syslog(LOG_ERR,
 773                                             "%s/%s: %s: no such user",
 774                                                 sep->se_service, sep->se_proto,
 775                                                 sep->se_user);
 776                                         if (sep->se_socktype != SOCK_STREAM)
 777                                                 recv(0, buf, sizeof (buf), 0);
 778                                         _exit(EX_NOUSER);
 779                                 }
 780                                 grp = NULL;
 781                                 if (   sep->se_group != NULL
 782                                     && (grp = getgrnam(sep->se_group)) == NULL
 783                                    ) {
 784                                         syslog(LOG_ERR,
 785                                             "%s/%s: %s: no such group",
 786                                                 sep->se_service, sep->se_proto,
 787                                                 sep->se_group);
 788                                         if (sep->se_socktype != SOCK_STREAM)
 789                                                 recv(0, buf, sizeof (buf), 0);
 790                                         _exit(EX_NOUSER);
 791                                 }
 792                                 if (grp != NULL)
 793                                         pwd->pw_gid = grp->gr_gid;
 794 #ifdef LOGIN_CAP
 795                                 if ((lc = login_getclass(sep->se_class)) == NULL) {
 796                                         /* error syslogged by getclass */
 797                                         syslog(LOG_ERR,
 798                                             "%s/%s: %s: login class error",
 799                                                 sep->se_service, sep->se_proto,
 800                                                 sep->se_class);
 801                                         if (sep->se_socktype != SOCK_STREAM)
 802                                                 recv(0, buf, sizeof (buf), 0);
 803                                         _exit(EX_NOUSER);
 804                                 }
 805 #endif
 806                                 if (setsid() < 0) {
 807                                         syslog(LOG_ERR,
 808                                                 "%s: can't setsid(): %m",
 809                                                  sep->se_service);
 810                                         /* _exit(EX_OSERR); not fatal yet */
 811                                 }
 812 #ifdef LOGIN_CAP
 813                                 if (setusercontext(lc, pwd, pwd->pw_uid,
 814                                     LOGIN_SETALL) != 0) {
 815                                         syslog(LOG_ERR,
 816                                          "%s: can't setusercontext(..%s..): %m",
 817                                          sep->se_service, sep->se_user);
 818                                         _exit(EX_OSERR);
 819                                 }
 820 #else
 821                                 if (pwd->pw_uid) {
 822                                         if (setlogin(sep->se_user) < 0) {
 823                                                 syslog(LOG_ERR,
 824                                                  "%s: can't setlogin(%s): %m",
 825                                                  sep->se_service, sep->se_user);
 826                                                 /* _exit(EX_OSERR); not yet */
 827                                         }
 828                                         if (setgid(pwd->pw_gid) < 0) {
 829                                                 syslog(LOG_ERR,
 830                                                   "%s: can't set gid %d: %m",
 831                                                   sep->se_service, pwd->pw_gid);
 832                                                 _exit(EX_OSERR);
 833                                         }
 834                                         (void) initgroups(pwd->pw_name,
 835                                                         pwd->pw_gid);
 836                                         if (setuid(pwd->pw_uid) < 0) {
 837                                                 syslog(LOG_ERR,
 838                                                   "%s: can't set uid %d: %m",
 839                                                   sep->se_service, pwd->pw_uid);
 840                                                 _exit(EX_OSERR);
 841                                         }
 842                                 }
 843 #endif
 844                                 sigaction(SIGPIPE, &sapipe,
 845                                     (struct sigaction *)0);
 846                                 execv(sep->se_server, sep->se_argv);
 847                                 syslog(LOG_ERR,
 848                                     "cannot execute %s: %m", sep->se_server);
 849                                 if (sep->se_socktype != SOCK_STREAM)
 850                                         recv(0, buf, sizeof (buf), 0);
 851                             }
 852                             if (dofork)
 853                                 _exit(0);
 854                     }
 855                     if (sep->se_accept && sep->se_socktype == SOCK_STREAM)
 856                             close(ctrl);
 857                 }
 858         }
 859 }
 860
 861 /*
 862  * Add a signal flag to the signal flag queue for later handling
 863  */
 864
 865 void
 866 flag_signal(int c)
 867 {
 868         char ch = c;
 869
 870         if (write(signalpipe[1], &ch, 1) != 1) {
 871                 syslog(LOG_ERR, "write: %m");
 872                 _exit(EX_OSERR);
 873         }
 874 }
 875
 876 /*
 877  * Record a new child pid for this service. If we've reached the
 878  * limit on children, then stop accepting incoming requests.
 879  */
 880
 881 void
 882 addchild(struct servtab *sep, pid_t pid)
 883 {
 884         if (sep->se_maxchild <= 0)
 885                 return;
 886 #ifdef SANITY_CHECK
 887         if (sep->se_numchild >= sep->se_maxchild) {
 888                 syslog(LOG_ERR, "%s: %d >= %d",
 889                     __FUNCTION__, sep->se_numchild, sep->se_maxchild);
 890                 exit(EX_SOFTWARE);
 891         }
 892 #endif
 893         sep->se_pids[sep->se_numchild++] = pid;
 894         if (sep->se_numchild == sep->se_maxchild)
 895                 disable(sep);
 896 }
 897
 898 /*
 899  * Some child process has exited. See if it's on somebody's list.
 900  */
 901
 902 void
 903 flag_reapchild(int signo __unused)
 904 {
 905         flag_signal('C');
 906 }
 907
 908 void
 909 reapchild(void)
 910 {
 911         int k, status;
 912         pid_t pid;
 913         struct servtab *sep;
 914
 915         for (;;) {
 916                 pid = wait3(&status, WNOHANG, (struct rusage *)0);
 917                 if (pid <= 0)
 918                         break;
 919                 if (debug)
 920                         warnx("%d reaped, %s %u", pid,
 921                             WIFEXITED(status) ? "status" : "signal",
 922                             WIFEXITED(status) ? WEXITSTATUS(status)
 923                                 : WTERMSIG(status));
 924                 for (sep = servtab; sep; sep = sep->se_next) {
 925                         for (k = 0; k < sep->se_numchild; k++)
 926                                 if (sep->se_pids[k] == pid)
 927                                         break;
 928                         if (k == sep->se_numchild)
 929                                 continue;
 930                         if (sep->se_numchild == sep->se_maxchild)
 931                                 enable(sep);
 932                         sep->se_pids[k] = sep->se_pids[--sep->se_numchild];
 933                         if (WIFSIGNALED(status) || WEXITSTATUS(status))
 934                                 syslog(LOG_WARNING,
 935                                     "%s[%d]: exited, %s %u",
 936                                     sep->se_server, pid,
 937                                     WIFEXITED(status) ? "status" : "signal",
 938                                     WIFEXITED(status) ? WEXITSTATUS(status)
 939                                         : WTERMSIG(status));
 940                         break;
 941                 }
 942                 reapchild_conn(pid);
 943         }
 944 }
 945
 946 void
 947 flag_config(int signo __unused)
 948 {
 949         flag_signal('H');
 950 }
 951
 952 void
 953 config(void)
 954 {
 955         struct servtab *sep, *new, **sepp;
 956         long omask;
 957         int new_nomapped;
 958
 959         if (!setconfig()) {
 960                 syslog(LOG_ERR, "%s: %m", CONFIG);
 961                 return;
 962         }
 963         for (sep = servtab; sep; sep = sep->se_next)
 964                 sep->se_checked = 0;
 965         while ((new = getconfigent())) {
 966                 if (getpwnam(new->se_user) == NULL) {
 967                         syslog(LOG_ERR,
 968                                 "%s/%s: no such user '%s', service ignored",
 969                                 new->se_service, new->se_proto, new->se_user);
 970                         continue;
 971                 }
 972                 if (new->se_group && getgrnam(new->se_group) == NULL) {
 973                         syslog(LOG_ERR,
 974                                 "%s/%s: no such group '%s', service ignored",
 975                                 new->se_service, new->se_proto, new->se_group);
 976                         continue;
 977                 }
 978 #ifdef LOGIN_CAP
 979                 if (login_getclass(new->se_class) == NULL) {
 980                         /* error syslogged by getclass */
 981                         syslog(LOG_ERR,
 982                                 "%s/%s: %s: login class error, service ignored",
 983                                 new->se_service, new->se_proto, new->se_class);
 984                         continue;
 985                 }
 986 #endif
 987                 new_nomapped = new->se_nomapped;
 988                 for (sep = servtab; sep; sep = sep->se_next)
 989                         if (strcmp(sep->se_service, new->se_service) == 0 &&
 990                             strcmp(sep->se_proto, new->se_proto) == 0 &&
 991                             sep->se_rpc == new->se_rpc &&
 992                             sep->se_socktype == new->se_socktype &&
 993                             sep->se_family == new->se_family)
 994                                 break;
 995                 if (sep != 0) {
 996                         int i;
 997
 998 #define SWAP(t,a, b) { t c = a; a = b; b = c; }
 999                         omask = sigblock(SIGBLOCK);
1000                         if (sep->se_nomapped != new->se_nomapped) {
1001                                 /* for rpc keep old nommaped till unregister */
1002                                 if (!sep->se_rpc)
1003                                         sep->se_nomapped = new->se_nomapped;
1004                                 sep->se_reset = 1;
1005                         }
1006                         /* copy over outstanding child pids */
1007                         if (sep->se_maxchild > 0 && new->se_maxchild > 0) {
1008                                 new->se_numchild = sep->se_numchild;
1009                                 if (new->se_numchild > new->se_maxchild)
1010                                         new->se_numchild = new->se_maxchild;
1011                                 memcpy(new->se_pids, sep->se_pids,
1012                                     new->se_numchild * sizeof(*new->se_pids));
1013                         }
1014                         SWAP(pid_t *, sep->se_pids, new->se_pids);
1015                         sep->se_maxchild = new->se_maxchild;
1016                         sep->se_numchild = new->se_numchild;
1017                         sep->se_maxcpm = new->se_maxcpm;
1018                         resize_conn(sep, new->se_maxperip);
1019                         sep->se_maxperip = new->se_maxperip;
1020                         sep->se_bi = new->se_bi;
1021                         /* might need to turn on or off service now */
1022                         if (sep->se_fd >= 0) {
1023                               if (sep->se_maxchild > 0
1024                                   && sep->se_numchild == sep->se_maxchild) {
1025                                       if (FD_ISSET(sep->se_fd, &allsock))
1026                                           disable(sep);
1027                               } else {
1028                                       if (!FD_ISSET(sep->se_fd, &allsock))
1029                                           enable(sep);
1030                               }
1031                         }
1032                         sep->se_accept = new->se_accept;
1033                         SWAP(char *, sep->se_user, new->se_user);
1034                         SWAP(char *, sep->se_group, new->se_group);
1035 #ifdef LOGIN_CAP
1036                         SWAP(char *, sep->se_class, new->se_class);
1037 #endif
1038                         SWAP(char *, sep->se_server, new->se_server);
1039                         SWAP(char *, sep->se_server_name, new->se_server_name);
1040                         for (i = 0; i < MAXARGV; i++)
1041                                 SWAP(char *, sep->se_argv[i], new->se_argv[i]);
1042 #ifdef IPSEC
1043                         SWAP(char *, sep->se_policy, new->se_policy);
1044                         ipsecsetup(sep);
1045 #endif
1046                         sigsetmask(omask);
1047                         freeconfig(new);
1048                         if (debug)
1049                                 print_service("REDO", sep);
1050                 } else {
1051                         sep = enter(new);
1052                         if (debug)
1053                                 print_service("ADD ", sep);
1054                 }
1055                 sep->se_checked = 1;
1056                 if (ISMUX(sep)) {
1057                         sep->se_fd = -1;
1058                         continue;
1059                 }
1060                 switch (sep->se_family) {
1061                 case AF_INET:
1062                         if (!v4bind_ok) {
1063                                 sep->se_fd = -1;
1064                                 continue;
1065                         }
1066                         break;
1067 #ifdef INET6
1068                 case AF_INET6:
1069                         if (!v6bind_ok) {
1070                                 sep->se_fd = -1;
1071                                 continue;
1072                         }
1073                         break;
1074 #endif
1075                 }
1076                 if (!sep->se_rpc) {
1077                         if (sep->se_family != AF_UNIX) {
1078                                 sp = getservbyname(sep->se_service, sep->se_proto);
1079                                 if (sp == 0) {
1080                                         syslog(LOG_ERR, "%s/%s: unknown service",
1081                                         sep->se_service, sep->se_proto);
1082                                         sep->se_checked = 0;
1083                                         continue;
1084                                 }
1085                         }
1086                         switch (sep->se_family) {
1087                         case AF_INET:
1088                                 if (sp->s_port != sep->se_ctrladdr4.sin_port) {
1089                                         sep->se_ctrladdr4.sin_port =
1090                                                 sp->s_port;
1091                                         sep->se_reset = 1;
1092                                 }
1093                                 break;
1094 #ifdef INET6
1095                         case AF_INET6:
1096                                 if (sp->s_port !=
1097                                     sep->se_ctrladdr6.sin6_port) {
1098                                         sep->se_ctrladdr6.sin6_port =
1099                                                 sp->s_port;
1100                                         sep->se_reset = 1;
1101                                 }
1102                                 break;
1103 #endif
1104                         }
1105                         if (sep->se_reset != 0 && sep->se_fd >= 0)
1106                                 close_sep(sep);
1107                 } else {
1108                         rpc = getrpcbyname(sep->se_service);
1109                         if (rpc == 0) {
1110                                 syslog(LOG_ERR, "%s/%s unknown RPC service",
1111                                         sep->se_service, sep->se_proto);
1112                                 if (sep->se_fd != -1)
1113                                         (void) close(sep->se_fd);
1114                                 sep->se_fd = -1;
1115                                         continue;
1116                         }
1117                         if (sep->se_reset != 0 ||
1118                             rpc->r_number != sep->se_rpc_prog) {
1119                                 if (sep->se_rpc_prog)
1120                                         unregisterrpc(sep);
1121                                 sep->se_rpc_prog = rpc->r_number;
1122                                 if (sep->se_fd != -1)
1123                                         (void) close(sep->se_fd);
1124                                 sep->se_fd = -1;
1125                         }
1126                         sep->se_nomapped = new_nomapped;
1127                 }
1128                 sep->se_reset = 0;
1129                 if (sep->se_fd == -1)
1130                         setup(sep);
1131         }
1132         endconfig();
1133         /*
1134          * Purge anything not looked at above.
1135          */
1136         omask = sigblock(SIGBLOCK);
1137         sepp = &servtab;
1138         while ((sep = *sepp)) {
1139                 if (sep->se_checked) {
1140                         sepp = &sep->se_next;
1141                         continue;
1142                 }
1143                 *sepp = sep->se_next;
1144                 if (sep->se_fd >= 0)
1145                         close_sep(sep);
1146                 if (debug)
1147                         print_service("FREE", sep);
1148                 if (sep->se_rpc && sep->se_rpc_prog > 0)
1149                         unregisterrpc(sep);
1150                 freeconfig(sep);
1151                 free(sep);
1152         }
1153         (void) sigsetmask(omask);
1154 }
1155
1156 void
1157 unregisterrpc(struct servtab *sep)
1158 {
1159         u_int i;
1160         struct servtab *sepp;
1161         long omask;
1162         struct netconfig *netid4, *netid6;
1163
1164         omask = sigblock(SIGBLOCK);
1165         netid4 = sep->se_socktype == SOCK_DGRAM ? udpconf : tcpconf;
1166         netid6 = sep->se_socktype == SOCK_DGRAM ? udp6conf : tcp6conf;
1167         if (sep->se_family == AF_INET)
1168                 netid6 = NULL;
1169         else if (sep->se_nomapped)
1170                 netid4 = NULL;
1171         /*
1172          * Conflict if same prog and protocol - In that case one should look
1173          * to versions, but it is not interesting: having separate servers for
1174          * different versions does not work well.
1175          * Therefore one do not unregister if there is a conflict.
1176          * There is also transport conflict if destroying INET when INET46
1177          * exists, or destroying INET46 when INET exists
1178          */
1179         for (sepp = servtab; sepp; sepp = sepp->se_next) {
1180                 if (sepp == sep)
1181                         continue;
1182                 if (sepp->se_checked == 0 ||
1183                     !sepp->se_rpc ||
1184                     strcmp(sep->se_proto, sepp->se_proto) != 0 ||
1185                     sep->se_rpc_prog != sepp->se_rpc_prog)
1186                         continue;
1187                 if (sepp->se_family == AF_INET)
1188                         netid4 = NULL;
1189                 if (sepp->se_family == AF_INET6) {
1190                         netid6 = NULL;
1191                         if (!sep->se_nomapped)
1192                                 netid4 = NULL;
1193                 }
1194                 if (netid4 == NULL && netid6 == NULL)
1195                         return;
1196         }
1197         if (debug)
1198                 print_service("UNREG", sep);
1199         for (i = sep->se_rpc_lowvers; i <= sep->se_rpc_highvers; i++) {
1200                 if (netid4)
1201                         rpcb_unset(sep->se_rpc_prog, i, netid4);
1202                 if (netid6)
1203                         rpcb_unset(sep->se_rpc_prog, i, netid6);
1204         }
1205         if (sep->se_fd != -1)
1206                 (void) close(sep->se_fd);
1207         sep->se_fd = -1;
1208         (void) sigsetmask(omask);
1209 }
1210
1211 void
1212 flag_retry(int signo __unused)
1213 {
1214         flag_signal('A');
1215 }
1216
1217 void
1218 retry(void)
1219 {
1220         struct servtab *sep;
1221
1222         timingout = 0;
1223         for (sep = servtab; sep; sep = sep->se_next)
1224                 if (sep->se_fd == -1 && !ISMUX(sep))
1225                         setup(sep);
1226 }
1227
1228 void
1229 setup(struct servtab *sep)
1230 {
1231         int on = 1;
1232
1233         if ((sep->se_fd = socket(sep->se_family, sep->se_socktype, 0)) < 0) {
1234                 if (debug)
1235                         warn("socket failed on %s/%s",
1236                                 sep->se_service, sep->se_proto);
1237                 syslog(LOG_ERR, "%s/%s: socket: %m",
1238                     sep->se_service, sep->se_proto);
1239                 return;
1240         }
1241 #define turnon(fd, opt) \
1242 setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
1243         if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) &&
1244             turnon(sep->se_fd, SO_DEBUG) < 0)
1245                 syslog(LOG_ERR, "setsockopt (SO_DEBUG): %m");
1246         if (turnon(sep->se_fd, SO_REUSEADDR) < 0)
1247                 syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
1248 #ifdef SO_PRIVSTATE
1249         if (turnon(sep->se_fd, SO_PRIVSTATE) < 0)
1250                 syslog(LOG_ERR, "setsockopt (SO_PRIVSTATE): %m");
1251 #endif
1252         /* tftpd opens a new connection then needs more infos */
1253         if ((sep->se_family == AF_INET6) &&
1254             (strcmp(sep->se_proto, "udp") == 0) &&
1255             (sep->se_accept == 0) &&
1256             (setsockopt(sep->se_fd, IPPROTO_IPV6, IPV6_PKTINFO,
1257                         (char *)&on, sizeof (on)) < 0))
1258                 syslog(LOG_ERR, "setsockopt (IPV6_RECVPKTINFO): %m");
1259         if (sep->se_family == AF_INET6) {
1260                 int flag = sep->se_nomapped ? 1 : 0;
1261                 if (setsockopt(sep->se_fd, IPPROTO_IPV6, IPV6_V6ONLY,
1262                                (char *)&flag, sizeof (flag)) < 0)
1263                         syslog(LOG_ERR, "setsockopt (IPV6_V6ONLY): %m");
1264         }
1265 #undef turnon
1266         if (sep->se_type == TTCP_TYPE)
1267                 if (setsockopt(sep->se_fd, IPPROTO_TCP, TCP_NOPUSH,
1268                     (char *)&on, sizeof (on)) < 0)
1269                         syslog(LOG_ERR, "setsockopt (TCP_NOPUSH): %m");
1270 #ifdef IPV6_FAITH
1271         if (sep->se_type == FAITH_TYPE) {
1272                 if (setsockopt(sep->se_fd, IPPROTO_IPV6, IPV6_FAITH, &on,
1273                                 sizeof(on)) < 0) {
1274                         syslog(LOG_ERR, "setsockopt (IPV6_FAITH): %m");
1275                 }
1276         }
1277 #endif
1278 #ifdef IPSEC
1279         ipsecsetup(sep);
1280 #endif
1281         if (sep->se_family == AF_UNIX) {
1282                 (void) unlink(sep->se_ctrladdr_un.sun_path);
1283                 umask(0777); /* Make socket with conservative permissions */
1284         }
1285         if (bind(sep->se_fd, (struct sockaddr *)&sep->se_ctrladdr,
1286             sep->se_ctrladdr_size) < 0) {
1287                 if (debug)
1288                         warn("bind failed on %s/%s",
1289                                 sep->se_service, sep->se_proto);
1290                 syslog(LOG_ERR, "%s/%s: bind: %m",
1291                     sep->se_service, sep->se_proto);
1292                 (void) close(sep->se_fd);
1293                 sep->se_fd = -1;
1294                 if (!timingout) {
1295                         timingout = 1;
1296                         alarm(RETRYTIME);
1297                 }
1298                 if (sep->se_family == AF_UNIX)
1299                         umask(mask);
1300                 return;
1301         }
1302         if (sep->se_family == AF_UNIX) {
1303                 /* Ick - fch{own,mod} don't work on Unix domain sockets */
1304                 if (chown(sep->se_service, sep->se_sockuid, sep->se_sockgid) < 0)
1305                         syslog(LOG_ERR, "chown socket: %m");
1306                 if (chmod(sep->se_service, sep->se_sockmode) < 0)
1307                         syslog(LOG_ERR, "chmod socket: %m");
1308                 umask(mask);
1309         }
1310         if (sep->se_rpc) {
1311                 u_int i;
1312                 socklen_t len = sep->se_ctrladdr_size;
1313                 struct netconfig *netid, *netid2 = NULL;
1314                 struct sockaddr_in sock;
1315                 struct netbuf nbuf, nbuf2;
1316
1317                 if (getsockname(sep->se_fd,
1318                                 (struct sockaddr*)&sep->se_ctrladdr, &len) < 0){
1319                         syslog(LOG_ERR, "%s/%s: getsockname: %m",
1320                                sep->se_service, sep->se_proto);
1321                         (void) close(sep->se_fd);
1322                         sep->se_fd = -1;
1323                         return;
1324                 }
1325                 nbuf.buf = &sep->se_ctrladdr;
1326                 nbuf.len = sep->se_ctrladdr.sa_len;
1327                 if (sep->se_family == AF_INET)
1328                         netid = sep->se_socktype==SOCK_DGRAM? udpconf:tcpconf;
1329                 else  {
1330                         netid = sep->se_socktype==SOCK_DGRAM? udp6conf:tcp6conf;
1331                         if (!sep->se_nomapped) { /* INET and INET6 */
1332                                 netid2 = netid==udp6conf? udpconf:tcpconf;
1333                                 memset(&sock, 0, sizeof sock);  /* ADDR_ANY */
1334                                 nbuf2.buf = &sock;
1335                                 nbuf2.len = sock.sin_len = sizeof sock;
1336                                 sock.sin_family = AF_INET;
1337                                 sock.sin_port = sep->se_ctrladdr6.sin6_port;
1338                         }
1339                 }
1340                 if (debug)
1341                         print_service("REG ", sep);
1342                 for (i = sep->se_rpc_lowvers; i <= sep->se_rpc_highvers; i++) {
1343                         rpcb_unset(sep->se_rpc_prog, i, netid);
1344                         rpcb_set(sep->se_rpc_prog, i, netid, &nbuf);
1345                         if (netid2) {
1346                                 rpcb_unset(sep->se_rpc_prog, i, netid2);
1347                                 rpcb_set(sep->se_rpc_prog, i, netid2, &nbuf2);
1348                         }
1349                 }
1350         }
1351         if (sep->se_socktype == SOCK_STREAM)
1352                 listen(sep->se_fd, 64);
1353         enable(sep);
1354         if (debug) {
1355                 warnx("registered %s on %d",
1356                         sep->se_server, sep->se_fd);
1357         }
1358 }
1359
1360 #ifdef IPSEC
1361 void
1362 ipsecsetup(sep)
1363         struct servtab *sep;
1364 {
1365         char *buf;
1366         char *policy_in = NULL;
1367         char *policy_out = NULL;
1368         int level;
1369         int opt;
1370
1371         switch (sep->se_family) {
1372         case AF_INET:
1373                 level = IPPROTO_IP;
1374                 opt = IP_IPSEC_POLICY;
1375                 break;
1376 #ifdef INET6
1377         case AF_INET6:
1378                 level = IPPROTO_IPV6;
1379                 opt = IPV6_IPSEC_POLICY;
1380                 break;
1381 #endif
1382         default:
1383                 return;
1384         }
1385
1386         if (!sep->se_policy || sep->se_policy[0] == '\0') {
1387                 static char def_in[] = "in entrust", def_out[] = "out entrust";
1388                 policy_in = def_in;
1389                 policy_out = def_out;
1390         } else {
1391                 if (!strncmp("in", sep->se_policy, 2))
1392                         policy_in = sep->se_policy;
1393                 else if (!strncmp("out", sep->se_policy, 3))
1394                         policy_out = sep->se_policy;
1395                 else {
1396                         syslog(LOG_ERR, "invalid security policy \"%s\"",
1397                                 sep->se_policy);
1398                         return;
1399                 }
1400         }
1401
1402         if (policy_in != NULL) {
1403                 buf = ipsec_set_policy(policy_in, strlen(policy_in));
1404                 if (buf != NULL) {
1405                         if (setsockopt(sep->se_fd, level, opt,
1406                                         buf, ipsec_get_policylen(buf)) < 0 &&
1407                             debug != 0)
1408                                 warnx("%s/%s: ipsec initialization failed; %s",
1409                                       sep->se_service, sep->se_proto,
1410                                       policy_in);
1411                         free(buf);
1412                 } else
1413                         syslog(LOG_ERR, "invalid security policy \"%s\"",
1414                                 policy_in);
1415         }
1416         if (policy_out != NULL) {
1417                 buf = ipsec_set_policy(policy_out, strlen(policy_out));
1418                 if (buf != NULL) {
1419                         if (setsockopt(sep->se_fd, level, opt,
1420                                         buf, ipsec_get_policylen(buf)) < 0 &&
1421                             debug != 0)
1422                                 warnx("%s/%s: ipsec initialization failed; %s",
1423                                       sep->se_service, sep->se_proto,
1424                                       policy_out);
1425                         free(buf);
1426                 } else
1427                         syslog(LOG_ERR, "invalid security policy \"%s\"",
1428                                 policy_out);
1429         }
1430 }
1431 #endif
1432
1433 /*
1434  * Finish with a service and its socket.
1435  */
1436 void
1437 close_sep(struct servtab *sep)
1438 {
1439         if (sep->se_fd >= 0) {
1440                 if (FD_ISSET(sep->se_fd, &allsock))
1441                         disable(sep);
1442                 (void) close(sep->se_fd);
1443                 sep->se_fd = -1;
1444         }
1445         sep->se_count = 0;
1446         sep->se_numchild = 0;   /* forget about any existing children */
1447 }
1448
1449 int
1450 matchservent(const char *name1, const char *name2, const char *proto)
1451 {
1452         char **alias, *p;
1453         struct servent *se;
1454
1455         if (strcmp(proto, "unix") == 0) {
1456                 if ((p = strrchr(name1, '/')) != NULL)
1457                         name1 = p + 1;
1458                 if ((p = strrchr(name2, '/')) != NULL)
1459                         name2 = p + 1;
1460         }
1461         if (strcmp(name1, name2) == 0)
1462                 return(1);
1463         if ((se = getservbyname(name1, proto)) != NULL) {
1464                 if (strcmp(name2, se->s_name) == 0)
1465                         return(1);
1466                 for (alias = se->s_aliases; *alias; alias++)
1467                         if (strcmp(name2, *alias) == 0)
1468                                 return(1);
1469         }
1470         return(0);
1471 }
1472
1473 struct servtab *
1474 enter(struct servtab *cp)
1475 {
1476         struct servtab *sep;
1477         long omask;
1478
1479         sep = (struct servtab *)malloc(sizeof (*sep));
1480         if (sep == (struct servtab *)0) {
1481                 syslog(LOG_ERR, "malloc: %m");
1482                 exit(EX_OSERR);
1483         }
1484         *sep = *cp;
1485         sep->se_fd = -1;
1486         omask = sigblock(SIGBLOCK);
1487         sep->se_next = servtab;
1488         servtab = sep;
1489         sigsetmask(omask);
1490         return (sep);
1491 }
1492
1493 void
1494 enable(struct servtab *sep)
1495 {
1496         if (debug)
1497                 warnx(
1498                     "enabling %s, fd %d", sep->se_service, sep->se_fd);
1499 #ifdef SANITY_CHECK
1500         if (sep->se_fd < 0) {
1501                 syslog(LOG_ERR,
1502                     "%s: %s: bad fd", __FUNCTION__, sep->se_service);
1503                 exit(EX_SOFTWARE);
1504         }
1505         if (ISMUX(sep)) {
1506                 syslog(LOG_ERR,
1507                     "%s: %s: is mux", __FUNCTION__, sep->se_service);
1508                 exit(EX_SOFTWARE);
1509         }
1510         if (FD_ISSET(sep->se_fd, &allsock)) {
1511                 syslog(LOG_ERR,
1512                     "%s: %s: not off", __FUNCTION__, sep->se_service);
1513                 exit(EX_SOFTWARE);
1514         }
1515         nsock++;
1516 #endif
1517         FD_SET(sep->se_fd, &allsock);
1518         if (sep->se_fd > maxsock)
1519                 maxsock = sep->se_fd;
1520 }
1521
1522 void
1523 disable(struct servtab *sep)
1524 {
1525         if (debug)
1526                 warnx(
1527                     "disabling %s, fd %d", sep->se_service, sep->se_fd);
1528 #ifdef SANITY_CHECK
1529         if (sep->se_fd < 0) {
1530                 syslog(LOG_ERR,
1531                     "%s: %s: bad fd", __FUNCTION__, sep->se_service);
1532                 exit(EX_SOFTWARE);
1533         }
1534         if (ISMUX(sep)) {
1535                 syslog(LOG_ERR,
1536                     "%s: %s: is mux", __FUNCTION__, sep->se_service);
1537                 exit(EX_SOFTWARE);
1538         }
1539         if (!FD_ISSET(sep->se_fd, &allsock)) {
1540                 syslog(LOG_ERR,
1541                     "%s: %s: not on", __FUNCTION__, sep->se_service);
1542                 exit(EX_SOFTWARE);
1543         }
1544         if (nsock == 0) {
1545                 syslog(LOG_ERR, "%s: nsock=0", __FUNCTION__);
1546                 exit(EX_SOFTWARE);
1547         }
1548         nsock--;
1549 #endif
1550         FD_CLR(sep->se_fd, &allsock);
1551         if (sep->se_fd == maxsock)
1552                 maxsock--;
1553 }
1554
1555 FILE    *fconfig = NULL;
1556 struct  servtab serv;
1557 char    line[LINE_MAX];
1558
1559 int
1560 setconfig(void)
1561 {
1562
1563         if (fconfig != NULL) {
1564                 fseek(fconfig, 0L, SEEK_SET);
1565                 return (1);
1566         }
1567         fconfig = fopen(CONFIG, "r");
1568         return (fconfig != NULL);
1569 }
1570
1571 void
1572 endconfig(void)
1573 {
1574         if (fconfig) {
1575                 (void) fclose(fconfig);
1576                 fconfig = NULL;
1577         }
1578 }
1579
1580 struct servtab *
1581 getconfigent(void)
1582 {
1583         struct servtab *sep = &serv;
1584         int argc;
1585         char *cp, *arg, *s;
1586         char *versp;
1587         static char TCPMUX_TOKEN[] = "tcpmux/";
1588 #define MUX_LEN         (sizeof(TCPMUX_TOKEN)-1)
1589 #ifdef IPSEC
1590         char *policy;
1591 #endif
1592         int v4bind;
1593 #ifdef INET6
1594         int v6bind;
1595 #endif
1596         int i;
1597
1598 #ifdef IPSEC
1599         policy = NULL;
1600 #endif
1601 more:
1602         v4bind = 0;
1603 #ifdef INET6
1604         v6bind = 0;
1605 #endif
1606         while ((cp = nextline(fconfig)) != NULL) {
1607 #ifdef IPSEC
1608                 /* lines starting with #@ is not a comment, but the policy */
1609                 if (cp[0] == '#' && cp[1] == '@') {
1610                         char *p;
1611                         for (p = cp + 2; p && *p && isspace(*p); p++)
1612                                 ;
1613                         if (*p == '\0') {
1614                                 if (policy)
1615                                         free(policy);
1616                                 policy = NULL;
1617                         } else if (ipsec_get_policylen(p) >= 0) {
1618                                 if (policy)
1619                                         free(policy);
1620                                 policy = newstr(p);
1621                         } else {
1622                                 syslog(LOG_ERR,
1623                                         "%s: invalid ipsec policy \"%s\"",
1624                                         CONFIG, p);
1625                                 exit(EX_CONFIG);
1626                         }
1627                 }
1628 #endif
1629                 if (*cp == '#' || *cp == '\0')
1630                         continue;
1631                 break;
1632         }
1633         if (cp == NULL)
1634                 return ((struct servtab *)0);
1635         /*
1636          * clear the static buffer, since some fields (se_ctrladdr,
1637          * for example) don't get initialized here.
1638          */
1639         memset(sep, 0, sizeof *sep);
1640         arg = skip(&cp);
1641         if (cp == NULL) {
1642                 /* got an empty line containing just blanks/tabs. */
1643                 goto more;
1644         }
1645         if (arg[0] == ':') { /* :user:group:perm: */
1646                 char *user, *group, *perm;
1647                 struct passwd *pw;
1648                 struct group *gr;
1649                 user = arg+1;
1650                 if ((group = strchr(user, ':')) == NULL) {
1651                         syslog(LOG_ERR, "no group after user '%s'", user);
1652                         goto more;
1653                 }
1654                 *group++ = '\0';
1655                 if ((perm = strchr(group, ':')) == NULL) {
1656                         syslog(LOG_ERR, "no mode after group '%s'", group);
1657                         goto more;
1658                 }
1659                 *perm++ = '\0';
1660                 if ((pw = getpwnam(user)) == NULL) {
1661                         syslog(LOG_ERR, "no such user '%s'", user);
1662                         goto more;
1663                 }
1664                 sep->se_sockuid = pw->pw_uid;
1665                 if ((gr = getgrnam(group)) == NULL) {
1666                         syslog(LOG_ERR, "no such user '%s'", group);
1667                         goto more;
1668                 }
1669                 sep->se_sockgid = gr->gr_gid;
1670                 sep->se_sockmode = strtol(perm, &arg, 8);
1671                 if (*arg != ':') {
1672                         syslog(LOG_ERR, "bad mode '%s'", perm);
1673                         goto more;
1674                 }
1675                 *arg++ = '\0';
1676         } else {
1677                 sep->se_sockuid = euid;
1678                 sep->se_sockgid = egid;
1679                 sep->se_sockmode = 0200;
1680         }
1681         if (strncmp(arg, TCPMUX_TOKEN, MUX_LEN) == 0) {
1682                 char *c = arg + MUX_LEN;
1683                 if (*c == '+') {
1684                         sep->se_type = MUXPLUS_TYPE;
1685                         c++;
1686                 } else
1687                         sep->se_type = MUX_TYPE;
1688                 sep->se_service = newstr(c);
1689         } else {
1690                 sep->se_service = newstr(arg);
1691                 sep->se_type = NORM_TYPE;
1692         }
1693         arg = sskip(&cp);
1694         if (strcmp(arg, "stream") == 0)
1695                 sep->se_socktype = SOCK_STREAM;
1696         else if (strcmp(arg, "dgram") == 0)
1697                 sep->se_socktype = SOCK_DGRAM;
1698         else if (strcmp(arg, "rdm") == 0)
1699                 sep->se_socktype = SOCK_RDM;
1700         else if (strcmp(arg, "seqpacket") == 0)
1701                 sep->se_socktype = SOCK_SEQPACKET;
1702         else if (strcmp(arg, "raw") == 0)
1703                 sep->se_socktype = SOCK_RAW;
1704         else
1705                 sep->se_socktype = -1;
1706
1707         arg = sskip(&cp);
1708         if (strncmp(arg, "tcp", 3) == 0) {
1709                 sep->se_proto = newstr(strsep(&arg, "/"));
1710                 if (arg != NULL) {
1711                         if (strcmp(arg, "ttcp") == 0)
1712                                 sep->se_type = TTCP_TYPE;
1713                         else if (strcmp(arg, "faith") == 0)
1714                                 sep->se_type = FAITH_TYPE;
1715                 }
1716         } else {
1717                 if (sep->se_type == NORM_TYPE &&
1718                     strncmp(arg, "faith/", 6) == 0) {
1719                         arg += 6;
1720                         sep->se_type = FAITH_TYPE;
1721                 }
1722                 sep->se_proto = newstr(arg);
1723         }
1724         if (strncmp(sep->se_proto, "rpc/", 4) == 0) {
1725                 memmove(sep->se_proto, sep->se_proto + 4,
1726                     strlen(sep->se_proto) + 1 - 4);
1727                 sep->se_rpc = 1;
1728                 sep->se_rpc_prog = sep->se_rpc_lowvers =
1729                         sep->se_rpc_lowvers = 0;
1730                 memcpy(&sep->se_ctrladdr4, bind_sa4,
1731                        sizeof(sep->se_ctrladdr4));
1732                 if ((versp = rindex(sep->se_service, '/'))) {
1733                         *versp++ = '\0';
1734                         switch (sscanf(versp, "%u-%u",
1735                                        &sep->se_rpc_lowvers,
1736                                        &sep->se_rpc_highvers)) {
1737                         case 2:
1738                                 break;
1739                         case 1:
1740                                 sep->se_rpc_highvers =
1741                                         sep->se_rpc_lowvers;
1742                                 break;
1743                         default:
1744                                 syslog(LOG_ERR,
1745                                         "bad RPC version specifier; %s",
1746                                         sep->se_service);
1747                                 freeconfig(sep);
1748                                 goto more;
1749                         }
1750                 }
1751                 else {
1752                         sep->se_rpc_lowvers =
1753                                 sep->se_rpc_highvers = 1;
1754                 }
1755         }
1756         sep->se_nomapped = 0;
1757         if (strcmp(sep->se_proto, "unix") == 0) {
1758                 sep->se_family = AF_UNIX;
1759         } else {
1760                 while (isdigit(sep->se_proto[strlen(sep->se_proto) - 1])) {
1761 #ifdef INET6
1762                         if (sep->se_proto[strlen(sep->se_proto) - 1] == '6') {
1763                                 sep->se_proto[strlen(sep->se_proto) - 1] = '\0';
1764                                 v6bind = 1;
1765                                 continue;
1766                         }
1767 #endif
1768                         if (sep->se_proto[strlen(sep->se_proto) - 1] == '4') {
1769                                 sep->se_proto[strlen(sep->se_proto) - 1] = '\0';
1770                                 v4bind = 1;
1771                                 continue;
1772                         }
1773                         /* illegal version num */
1774                         syslog(LOG_ERR, "bad IP version for %s", sep->se_proto);
1775                         freeconfig(sep);
1776                         goto more;
1777                 }
1778 #ifdef INET6
1779                 if (v6bind && !v6bind_ok) {
1780                         syslog(LOG_INFO, "IPv6 bind is ignored for %s",
1781                                sep->se_service);
1782                         if (v4bind && v4bind_ok)
1783                                 v6bind = 0;
1784                         else {
1785                                 freeconfig(sep);
1786                                 goto more;
1787                         }
1788                 }
1789                 if (v6bind) {
1790                         sep->se_family = AF_INET6;
1791                         if (!v4bind || !v4bind_ok)
1792                                 sep->se_nomapped = 1;
1793                 } else
1794 #endif
1795                 { /* default to v4 bind if not v6 bind */
1796                         if (!v4bind_ok) {
1797                                 syslog(LOG_NOTICE, "IPv4 bind is ignored for %s",
1798                                        sep->se_service);
1799                                 freeconfig(sep);
1800                                 goto more;
1801                         }
1802                         sep->se_family = AF_INET;
1803                 }
1804         }
1805         /* init ctladdr */
1806         switch(sep->se_family) {
1807         case AF_INET:
1808                 memcpy(&sep->se_ctrladdr4, bind_sa4,
1809                        sizeof(sep->se_ctrladdr4));
1810                 sep->se_ctrladdr_size = sizeof(sep->se_ctrladdr4);
1811                 break;
1812 #ifdef INET6
1813         case AF_INET6:
1814                 memcpy(&sep->se_ctrladdr6, bind_sa6,
1815                        sizeof(sep->se_ctrladdr6));
1816                 sep->se_ctrladdr_size = sizeof(sep->se_ctrladdr6);
1817                 break;
1818 #endif
1819         case AF_UNIX:
1820                 if (strlen(sep->se_service) >= sizeof(sep->se_ctrladdr_un.sun_path)) {
1821                         syslog(LOG_ERR,
1822                             "domain socket pathname too long for service %s",
1823                             sep->se_service);
1824                         goto more;
1825                 }
1826                 memset(&sep->se_ctrladdr, 0, sizeof(sep->se_ctrladdr));
1827                 sep->se_ctrladdr_un.sun_family = sep->se_family;
1828                 sep->se_ctrladdr_un.sun_len = strlen(sep->se_service);
1829                 strcpy(sep->se_ctrladdr_un.sun_path, sep->se_service);
1830                 sep->se_ctrladdr_size = SUN_LEN(&sep->se_ctrladdr_un);
1831         }
1832         arg = sskip(&cp);
1833         if (!strncmp(arg, "wait", 4))
1834                 sep->se_accept = 0;
1835         else if (!strncmp(arg, "nowait", 6))
1836                 sep->se_accept = 1;
1837         else {
1838                 syslog(LOG_ERR,
1839                         "%s: bad wait/nowait for service %s",
1840                         CONFIG, sep->se_service);
1841                 goto more;
1842         }
1843         sep->se_maxchild = -1;
1844         sep->se_maxcpm = -1;
1845         sep->se_maxperip = -1;
1846         if ((s = strchr(arg, '/')) != NULL) {
1847                 char *eptr;
1848                 u_long val;
1849
1850                 val = strtoul(s + 1, &eptr, 10);
1851                 if (eptr == s + 1 || val > MAX_MAXCHLD) {
1852                         syslog(LOG_ERR,
1853                                 "%s: bad max-child for service %s",
1854                                 CONFIG, sep->se_service);
1855                         goto more;
1856                 }
1857                 if (debug)
1858                         if (!sep->se_accept && val != 1)
1859                                 warnx("maxchild=%lu for wait service %s"
1860                                     " not recommended", val, sep->se_service);
1861                 sep->se_maxchild = val;
1862                 if (*eptr == '/')
1863                         sep->se_maxcpm = strtol(eptr + 1, &eptr, 10);
1864                 if (*eptr == '/')
1865                         sep->se_maxperip = strtol(eptr + 1, &eptr, 10);
1866                 /*
1867                  * explicitly do not check for \0 for future expansion /
1868                  * backwards compatibility
1869                  */
1870         }
1871         if (ISMUX(sep)) {
1872                 /*
1873                  * Silently enforce "nowait" mode for TCPMUX services
1874                  * since they don't have an assigned port to listen on.
1875                  */
1876                 sep->se_accept = 1;
1877                 if (strcmp(sep->se_proto, "tcp")) {
1878                         syslog(LOG_ERR,
1879                                 "%s: bad protocol for tcpmux service %s",
1880                                 CONFIG, sep->se_service);
1881                         goto more;
1882                 }
1883                 if (sep->se_socktype != SOCK_STREAM) {
1884                         syslog(LOG_ERR,
1885                                 "%s: bad socket type for tcpmux service %s",
1886                                 CONFIG, sep->se_service);
1887                         goto more;
1888                 }
1889         }
1890         sep->se_user = newstr(sskip(&cp));
1891 #ifdef LOGIN_CAP
1892         if ((s = strrchr(sep->se_user, '/')) != NULL) {
1893                 *s = '\0';
1894                 sep->se_class = newstr(s + 1);
1895         } else
1896                 sep->se_class = newstr(RESOURCE_RC);
1897 #endif
1898         if ((s = strrchr(sep->se_user, ':')) != NULL) {
1899                 *s = '\0';
1900                 sep->se_group = newstr(s + 1);
1901         } else
1902                 sep->se_group = NULL;
1903         sep->se_server = newstr(sskip(&cp));
1904         if ((sep->se_server_name = rindex(sep->se_server, '/')))
1905                 sep->se_server_name++;
1906         if (strcmp(sep->se_server, "internal") == 0) {
1907                 struct biltin *bi;
1908
1909                 for (bi = biltins; bi->bi_service; bi++)
1910                         if (bi->bi_socktype == sep->se_socktype &&
1911                             matchservent(bi->bi_service, sep->se_service,
1912                             sep->se_proto))
1913                                 break;
1914                 if (bi->bi_service == 0) {
1915                         syslog(LOG_ERR, "internal service %s unknown",
1916                                 sep->se_service);
1917                         goto more;
1918                 }
1919                 sep->se_accept = 1;     /* force accept mode for built-ins */
1920                 sep->se_bi = bi;
1921         } else
1922                 sep->se_bi = NULL;
1923         if (sep->se_maxperip < 0)
1924                 sep->se_maxperip = maxperip;
1925         if (sep->se_maxcpm < 0)
1926                 sep->se_maxcpm = maxcpm;
1927         if (sep->se_maxchild < 0) {     /* apply default max-children */
1928                 if (sep->se_bi && sep->se_bi->bi_maxchild >= 0)
1929                         sep->se_maxchild = sep->se_bi->bi_maxchild;
1930                 else if (sep->se_accept)
1931                         sep->se_maxchild = maxchild > 0 ? maxchild : 0;
1932                 else
1933                         sep->se_maxchild = 1;
1934         }
1935         if (sep->se_maxchild > 0) {
1936                 sep->se_pids = malloc(sep->se_maxchild * sizeof(*sep->se_pids));
1937                 if (sep->se_pids == NULL) {
1938                         syslog(LOG_ERR, "malloc: %m");
1939                         exit(EX_OSERR);
1940                 }
1941         }
1942         argc = 0;
1943         for (arg = skip(&cp); cp; arg = skip(&cp))
1944                 if (argc < MAXARGV) {
1945                         sep->se_argv[argc++] = newstr(arg);
1946                 } else {
1947                         syslog(LOG_ERR,
1948                                 "%s: too many arguments for service %s",
1949                                 CONFIG, sep->se_service);
1950                         goto more;
1951                 }
1952         while (argc <= MAXARGV)
1953                 sep->se_argv[argc++] = NULL;
1954         for (i = 0; i < PERIPSIZE; ++i)
1955                 LIST_INIT(&sep->se_conn[i]);
1956 #ifdef IPSEC
1957         sep->se_policy = policy ? newstr(policy) : NULL;
1958 #endif
1959         return (sep);
1960 }
1961
1962 void
1963 freeconfig(struct servtab *cp)
1964 {
1965         int i;
1966
1967         if (cp->se_service)
1968                 free(cp->se_service);
1969         if (cp->se_proto)
1970                 free(cp->se_proto);
1971         if (cp->se_user)
1972                 free(cp->se_user);
1973         if (cp->se_group)
1974                 free(cp->se_group);
1975 #ifdef LOGIN_CAP
1976         if (cp->se_class)
1977                 free(cp->se_class);
1978 #endif
1979         if (cp->se_server)
1980                 free(cp->se_server);
1981         if (cp->se_pids)
1982                 free(cp->se_pids);
1983         for (i = 0; i < MAXARGV; i++)
1984                 if (cp->se_argv[i])
1985                         free(cp->se_argv[i]);
1986         free_connlist(cp);
1987 #ifdef IPSEC
1988         if (cp->se_policy)
1989                 free(cp->se_policy);
1990 #endif
1991 }
1992
1993
1994 /*
1995  * Safe skip - if skip returns null, log a syntax error in the
1996  * configuration file and exit.
1997  */
1998 char *
1999 sskip(char **cpp)
2000 {
2001         char *cp;
2002
2003         cp = skip(cpp);
2004         if (cp == NULL) {
2005                 syslog(LOG_ERR, "%s: syntax error", CONFIG);
2006                 exit(EX_DATAERR);
2007         }
2008         return (cp);
2009 }
2010
2011 char *
2012 skip(char **cpp)
2013 {
2014         char *cp = *cpp;
2015         char *start;
2016         char quote = '\0';
2017
2018 again:
2019         while (*cp == ' ' || *cp == '\t')
2020                 cp++;
2021         if (*cp == '\0') {
2022                 int c;
2023
2024                 c = getc(fconfig);
2025                 (void) ungetc(c, fconfig);
2026                 if (c == ' ' || c == '\t')
2027                         if ((cp = nextline(fconfig)))
2028                                 goto again;
2029                 *cpp = (char *)0;
2030                 return ((char *)0);
2031         }
2032         if (*cp == '"' || *cp == '\'')
2033                 quote = *cp++;
2034         start = cp;
2035         if (quote)
2036                 while (*cp && *cp != quote)
2037                         cp++;
2038         else
2039                 while (*cp && *cp != ' ' && *cp != '\t')
2040                         cp++;
2041         if (*cp != '\0')
2042                 *cp++ = '\0';
2043         *cpp = cp;
2044         return (start);
2045 }
2046
2047 char *
2048 nextline(FILE *fd)
2049 {
2050         char *cp;
2051
2052         if (fgets(line, sizeof (line), fd) == NULL)
2053                 return ((char *)0);
2054         cp = strchr(line, '\n');
2055         if (cp)
2056                 *cp = '\0';
2057         return (line);
2058 }
2059
2060 char *
2061 newstr(const char *cp)
2062 {
2063         char *cr;
2064
2065         if ((cr = strdup(cp != NULL ? cp : "")))
2066                 return (cr);
2067         syslog(LOG_ERR, "strdup: %m");
2068         exit(EX_OSERR);
2069 }
2070
2071 void
2072 inetd_setproctitle(const char *a, int s)
2073 {
2074         socklen_t size;
2075         struct sockaddr_storage ss;
2076         char buf[80], pbuf[INET6_ADDRSTRLEN];
2077
2078         size = sizeof(ss);
2079         if (getpeername(s, (struct sockaddr *)&ss, &size) == 0) {
2080                 getnameinfo((struct sockaddr *)&ss, size, pbuf, sizeof(pbuf),
2081                             NULL, 0, NI_NUMERICHOST|NI_WITHSCOPEID);
2082                 (void) sprintf(buf, "%s [%s]", a, pbuf);
2083         } else
2084                 (void) sprintf(buf, "%s", a);
2085         setproctitle("%s", buf);
2086 }
2087
2088 int
2089 check_loop(const struct sockaddr *sa, const struct servtab *sep)
2090 {
2091         struct servtab *se2;
2092         char pname[INET6_ADDRSTRLEN];
2093
2094         for (se2 = servtab; se2; se2 = se2->se_next) {
2095                 if (!se2->se_bi || se2->se_socktype != SOCK_DGRAM)
2096                         continue;
2097
2098                 switch (se2->se_family) {
2099                 case AF_INET:
2100                         if (((const struct sockaddr_in *)sa)->sin_port ==
2101                             se2->se_ctrladdr4.sin_port)
2102                                 goto isloop;
2103                         continue;
2104 #ifdef INET6
2105                 case AF_INET6:
2106                         if (((const struct sockaddr_in *)sa)->sin_port ==
2107                             se2->se_ctrladdr4.sin_port)
2108                                 goto isloop;
2109                         continue;
2110 #endif
2111                 default:
2112                         continue;
2113                 }
2114         isloop:
2115                 getnameinfo(sa, sa->sa_len, pname, sizeof(pname), NULL, 0,
2116                             NI_NUMERICHOST|NI_WITHSCOPEID);
2117                 syslog(LOG_WARNING, "%s/%s:%s/%s loop request REFUSED from %s",
2118                        sep->se_service, sep->se_proto,
2119                        se2->se_service, se2->se_proto,
2120                        pname);
2121                 return 1;
2122         }
2123         return 0;
2124 }
2125
2126 /*
2127  * print_service:
2128  *      Dump relevant information to stderr
2129  */
2130 void
2131 print_service(const char *action, const struct servtab *sep)
2132 {
2133         fprintf(stderr,
2134             "%s: %s proto=%s accept=%d max=%d user=%s group=%s"
2135 #ifdef LOGIN_CAP
2136             "class=%s"
2137 #endif
2138             " builtin=%p server=%s"
2139 #ifdef IPSEC
2140             " policy=\"%s\""
2141 #endif
2142             "\n",
2143             action, sep->se_service, sep->se_proto,
2144             sep->se_accept, sep->se_maxchild, sep->se_user, sep->se_group,
2145 #ifdef LOGIN_CAP
2146             sep->se_class,
2147 #endif
2148             (void *) sep->se_bi, sep->se_server
2149 #ifdef IPSEC
2150             , (sep->se_policy ? sep->se_policy : "")
2151 #endif
2152             );
2153 }
2154
2155 #define CPMHSIZE        256
2156 #define CPMHMASK        (CPMHSIZE-1)
2157 #define CHTGRAN         10
2158 #define CHTSIZE         6
2159
2160 typedef struct CTime {
2161         unsigned long   ct_Ticks;
2162         int             ct_Count;
2163 } CTime;
2164
2165 typedef struct CHash {
2166         union {
2167                 struct in_addr  c4_Addr;
2168                 struct in6_addr c6_Addr;
2169         } cu_Addr;
2170 #define ch_Addr4        cu_Addr.c4_Addr
2171 #define ch_Addr6        cu_Addr.c6_Addr
2172         int             ch_Family;
2173         time_t          ch_LTime;
2174         char            *ch_Service;
2175         CTime           ch_Times[CHTSIZE];
2176 } CHash;
2177
2178 CHash   CHashAry[CPMHSIZE];
2179
2180 int
2181 cpmip(const struct servtab *sep, int ctrl)
2182 {
2183         struct sockaddr_storage rss;
2184         socklen_t rssLen = sizeof(rss);
2185         int r = 0;
2186
2187         /*
2188          * If getpeername() fails, just let it through (if logging is
2189          * enabled the condition is caught elsewhere)
2190          */
2191
2192         if (sep->se_maxcpm > 0 &&
2193             getpeername(ctrl, (struct sockaddr *)&rss, &rssLen) == 0 ) {
2194                 time_t t = time(NULL);
2195                 int hv = 0xABC3D20F;
2196                 int i;
2197                 int cnt = 0;
2198                 CHash *chBest = NULL;
2199                 unsigned int ticks = t / CHTGRAN;
2200                 struct sockaddr_in *sin4;
2201 #ifdef INET6
2202                 struct sockaddr_in6 *sin6;
2203 #endif
2204
2205                 sin4 = (struct sockaddr_in *)&rss;
2206 #ifdef INET6
2207                 sin6 = (struct sockaddr_in6 *)&rss;
2208 #endif
2209                 {
2210                         char *p;
2211                         int addrlen;
2212
2213                         switch (rss.ss_family) {
2214                         case AF_INET:
2215                                 p = (char *)&sin4->sin_addr;
2216                                 addrlen = sizeof(struct in_addr);
2217                                 break;
2218 #ifdef INET6
2219                         case AF_INET6:
2220                                 p = (char *)&sin6->sin6_addr;
2221                                 addrlen = sizeof(struct in6_addr);
2222                                 break;
2223 #endif
2224                         default:
2225                                 /* should not happen */
2226                                 return -1;
2227                         }
2228
2229                         for (i = 0; i < addrlen; ++i, ++p) {
2230                                 hv = (hv << 5) ^ (hv >> 23) ^ *p;
2231                         }
2232                         hv = (hv ^ (hv >> 16));
2233                 }
2234                 for (i = 0; i < 5; ++i) {
2235                         CHash *ch = &CHashAry[(hv + i) & CPMHMASK];
2236
2237                         if (rss.ss_family == AF_INET &&
2238                             ch->ch_Family == AF_INET &&
2239                             sin4->sin_addr.s_addr == ch->ch_Addr4.s_addr &&
2240                             ch->ch_Service && strcmp(sep->se_service,
2241                             ch->ch_Service) == 0) {
2242                                 chBest = ch;
2243                                 break;
2244                         }
2245 #ifdef INET6
2246                         if (rss.ss_family == AF_INET6 &&
2247                             ch->ch_Family == AF_INET6 &&
2248                             IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr,
2249                                                &ch->ch_Addr6) != 0 &&
2250                             ch->ch_Service && strcmp(sep->se_service,
2251                             ch->ch_Service) == 0) {
2252                                 chBest = ch;
2253                                 break;
2254                         }
2255 #endif
2256                         if (chBest == NULL || ch->ch_LTime == 0 ||
2257                             ch->ch_LTime < chBest->ch_LTime) {
2258                                 chBest = ch;
2259                         }
2260                 }
2261                 if ((rss.ss_family == AF_INET &&
2262                      (chBest->ch_Family != AF_INET ||
2263                       sin4->sin_addr.s_addr != chBest->ch_Addr4.s_addr)) ||
2264                     chBest->ch_Service == NULL ||
2265                     strcmp(sep->se_service, chBest->ch_Service) != 0) {
2266                         chBest->ch_Family = sin4->sin_family;
2267                         chBest->ch_Addr4 = sin4->sin_addr;
2268                         if (chBest->ch_Service)
2269                                 free(chBest->ch_Service);
2270                         chBest->ch_Service = strdup(sep->se_service);
2271                         bzero(chBest->ch_Times, sizeof(chBest->ch_Times));
2272                 }
2273 #ifdef INET6
2274                 if ((rss.ss_family == AF_INET6 &&
2275                      (chBest->ch_Family != AF_INET6 ||
2276                       IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr,
2277                                          &chBest->ch_Addr6) == 0)) ||
2278                     chBest->ch_Service == NULL ||
2279                     strcmp(sep->se_service, chBest->ch_Service) != 0) {
2280                         chBest->ch_Family = sin6->sin6_family;
2281                         chBest->ch_Addr6 = sin6->sin6_addr;
2282                         if (chBest->ch_Service)
2283                                 free(chBest->ch_Service);
2284                         chBest->ch_Service = strdup(sep->se_service);
2285                         bzero(chBest->ch_Times, sizeof(chBest->ch_Times));
2286                 }
2287 #endif
2288                 chBest->ch_LTime = t;
2289                 {
2290                         CTime *ct = &chBest->ch_Times[ticks % CHTSIZE];
2291                         if (ct->ct_Ticks != ticks) {
2292                                 ct->ct_Ticks = ticks;
2293                                 ct->ct_Count = 0;
2294                         }
2295                         ++ct->ct_Count;
2296                 }
2297                 for (i = 0; i < CHTSIZE; ++i) {
2298                         CTime *ct = &chBest->ch_Times[i];
2299                         if (ct->ct_Ticks <= ticks &&
2300                             ct->ct_Ticks >= ticks - CHTSIZE) {
2301                                 cnt += ct->ct_Count;
2302                         }
2303                 }
2304                 if (cnt * (CHTSIZE * CHTGRAN) / 60 > sep->se_maxcpm) {
2305                         char pname[INET6_ADDRSTRLEN];
2306
2307                         getnameinfo((struct sockaddr *)&rss,
2308                                     ((struct sockaddr *)&rss)->sa_len,
2309                                     pname, sizeof(pname), NULL, 0,
2310                                     NI_NUMERICHOST|NI_WITHSCOPEID);
2311                         r = -1;
2312                         syslog(LOG_ERR,
2313                             "%s from %s exceeded counts/min (limit %d/min)",
2314                             sep->se_service, pname,
2315                             sep->se_maxcpm);
2316                 }
2317         }
2318         return(r);
2319 }
2320
2321 static struct conninfo *
2322 search_conn(struct servtab *sep, int ctrl)
2323 {
2324         struct sockaddr_storage ss;
2325         socklen_t sslen = sizeof(ss);
2326         struct conninfo *conn;
2327         int hv;
2328         char pname[NI_MAXHOST],  pname2[NI_MAXHOST];
2329
2330         if (sep->se_maxperip <= 0)
2331                 return NULL;
2332
2333         /*
2334          * If getpeername() fails, just let it through (if logging is
2335          * enabled the condition is caught elsewhere)
2336          */
2337         if (getpeername(ctrl, (struct sockaddr *)&ss, &sslen) != 0)
2338                 return NULL;
2339
2340         switch (ss.ss_family) {
2341         case AF_INET:
2342                 hv = hashval((char *)&((struct sockaddr_in *)&ss)->sin_addr,
2343                     sizeof(struct in_addr));
2344                 break;
2345 #ifdef INET6
2346         case AF_INET6:
2347                 hv = hashval((char *)&((struct sockaddr_in6 *)&ss)->sin6_addr,
2348                     sizeof(struct in6_addr));
2349                 break;
2350 #endif
2351         default:
2352                 /*
2353                  * Since we only support AF_INET and AF_INET6, just
2354                  * let other than AF_INET and AF_INET6 through.
2355                  */
2356                 return NULL;
2357         }
2358
2359         if (getnameinfo((struct sockaddr *)&ss, sslen, pname, sizeof(pname),
2360             NULL, 0, NI_NUMERICHOST | NI_WITHSCOPEID) != 0)
2361                 return NULL;
2362
2363         LIST_FOREACH(conn, &sep->se_conn[hv], co_link) {
2364                 if (getnameinfo((struct sockaddr *)&conn->co_addr,
2365                     conn->co_addr.ss_len, pname2, sizeof(pname2), NULL, 0,
2366                     NI_NUMERICHOST | NI_WITHSCOPEID) == 0 &&
2367                     strcmp(pname, pname2) == 0)
2368                         break;
2369         }
2370
2371         if (conn == NULL) {
2372                 if ((conn = malloc(sizeof(struct conninfo))) == NULL) {
2373                         syslog(LOG_ERR, "malloc: %m");
2374                         exit(EX_OSERR);
2375                 }
2376                 conn->co_proc = malloc(sep->se_maxperip * sizeof(*conn->co_proc));
2377                 if (conn->co_proc == NULL) {
2378                         syslog(LOG_ERR, "malloc: %m");
2379                         exit(EX_OSERR);
2380                 }
2381                 memcpy(&conn->co_addr, (struct sockaddr *)&ss, sslen);
2382                 conn->co_numchild = 0;
2383                 LIST_INSERT_HEAD(&sep->se_conn[hv], conn, co_link);
2384         }
2385
2386         /*
2387          * Since a child process is not invoked yet, we cannot
2388          * determine a pid of a child.  So, co_proc and co_numchild
2389          * should be filled leter.
2390          */
2391
2392         return conn;
2393 }
2394
2395 static int
2396 room_conn(struct servtab *sep, struct conninfo *conn)
2397 {
2398         char pname[NI_MAXHOST];
2399
2400         if (conn->co_numchild >= sep->se_maxperip) {
2401                 getnameinfo((struct sockaddr *)&conn->co_addr,
2402                     conn->co_addr.ss_len, pname, sizeof(pname), NULL, 0,
2403                     NI_NUMERICHOST | NI_WITHSCOPEID);
2404                 syslog(LOG_ERR, "%s from %s exceeded counts (limit %d)",
2405                     sep->se_service, pname, sep->se_maxperip);
2406                 return 0;
2407         }
2408         return 1;
2409 }
2410
2411 static void
2412 addchild_conn(struct conninfo *conn, pid_t pid)
2413 {
2414         struct procinfo *proc;
2415
2416         if (conn == NULL)
2417                 return;
2418
2419         if ((proc = search_proc(pid, 1)) != NULL) {
2420                 if (proc->pr_conn != NULL) {
2421                         syslog(LOG_ERR,
2422                             "addchild_conn: child already on process list");
2423                         exit(EX_OSERR);
2424                 }
2425                 proc->pr_conn = conn;
2426         }
2427
2428         conn->co_proc[conn->co_numchild++] = proc;
2429 }
2430
2431 static void
2432 reapchild_conn(pid_t pid)
2433 {
2434         struct procinfo *proc;
2435         struct conninfo *conn;
2436         int i;
2437
2438         if ((proc = search_proc(pid, 0)) == NULL)
2439                 return;
2440         if ((conn = proc->pr_conn) == NULL)
2441                 return;
2442         for (i = 0; i < conn->co_numchild; ++i)
2443                 if (conn->co_proc[i] == proc) {
2444                         conn->co_proc[i] = conn->co_proc[--conn->co_numchild];
2445                         break;
2446                 }
2447         free_proc(proc);
2448         free_conn(conn);
2449 }
2450
2451 static void
2452 resize_conn(struct servtab *sep, int maxpip)
2453 {
2454         struct conninfo *conn;
2455         int i, j;
2456
2457         if (sep->se_maxperip <= 0)
2458                 return;
2459         if (maxpip <= 0) {
2460                 free_connlist(sep);
2461                 return;
2462         }
2463         for (i = 0; i < PERIPSIZE; ++i) {
2464                 LIST_FOREACH(conn, &sep->se_conn[i], co_link) {
2465                         for (j = maxpip; j < conn->co_numchild; ++j)
2466                                 free_proc(conn->co_proc[j]);
2467                         conn->co_proc = realloc(conn->co_proc,
2468                             maxpip * sizeof(*conn->co_proc));
2469                         if (conn->co_proc == NULL) {
2470                                 syslog(LOG_ERR, "realloc: %m");
2471                                 exit(EX_OSERR);
2472                         }
2473                         if (conn->co_numchild > maxpip)
2474                                 conn->co_numchild = maxpip;
2475                 }
2476         }
2477 }
2478
2479 static void
2480 free_connlist(struct servtab *sep)
2481 {
2482         struct conninfo *conn;
2483         int i, j;
2484
2485         for (i = 0; i < PERIPSIZE; ++i) {
2486                 while ((conn = LIST_FIRST(&sep->se_conn[i])) != NULL) {
2487                         for (j = 0; j < conn->co_numchild; ++j)
2488                                 free_proc(conn->co_proc[j]);
2489                         conn->co_numchild = 0;
2490                         free_conn(conn);
2491                 }
2492         }
2493 }
2494
2495 static void
2496 free_conn(struct conninfo *conn)
2497 {
2498         if (conn == NULL)
2499                 return;
2500         if (conn->co_numchild <= 0) {
2501                 LIST_REMOVE(conn, co_link);
2502                 free(conn->co_proc);
2503                 free(conn);
2504         }
2505 }
2506
2507 static struct procinfo *
2508 search_proc(pid_t pid, int add)
2509 {
2510         struct procinfo *proc;
2511         int hv;
2512
2513         hv = hashval((char *)&pid, sizeof(pid));
2514         LIST_FOREACH(proc, &proctable[hv], pr_link) {
2515                 if (proc->pr_pid == pid)
2516                         break;
2517         }
2518         if (proc == NULL && add) {
2519                 if ((proc = malloc(sizeof(struct procinfo))) == NULL) {
2520                         syslog(LOG_ERR, "malloc: %m");
2521                         exit(EX_OSERR);
2522                 }
2523                 proc->pr_pid = pid;
2524                 proc->pr_conn = NULL;
2525                 LIST_INSERT_HEAD(&proctable[hv], proc, pr_link);
2526         }
2527         return proc;
2528 }
2529
2530 static void
2531 free_proc(struct procinfo *proc)
2532 {
2533         if (proc == NULL)
2534                 return;
2535         LIST_REMOVE(proc, pr_link);
2536         free(proc);
2537 }
2538
2539 static int
2540 hashval(char *p, int len)
2541 {
2542         int i, hv = 0xABC3D20F;
2543
2544         for (i = 0; i < len; ++i, ++p)
2545                 hv = (hv << 5) ^ (hv >> 23) ^ *p;
2546         hv = (hv ^ (hv >> 16)) & (PERIPSIZE - 1);
2547         return hv;
2548 }