usr.sbin/inetd/inetd.c

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