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