networking/inetd.c

   1 /*      $Slackware: inetd.c 1.79s 2001/02/06 13:18:00 volkerdi Exp $    */
   2 /*      $OpenBSD: inetd.c,v 1.79 2001/01/30 08:30:57 deraadt Exp $      */
   3 /*      $NetBSD: inetd.c,v 1.11 1996/02/22 11:14:41 mycroft Exp $       */
   4 /* Busybox port by Vladimir Oleynik (C) 2001-2005 <dzo@simtreas.ru>     */
   5 /*
   6  * Copyright (c) 1983,1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37
  38 /*
  39  * Inetd - Internet super-server
  40  *
  41  * This program invokes all internet services as needed.
  42  * connection-oriented services are invoked each time a
  43  * connection is made, by creating a process.  This process
  44  * is passed the connection as file descriptor 0 and is
  45  * expected to do a getpeername to find out the source host
  46  * and port.
  47  *
  48  * Datagram oriented services are invoked when a datagram
  49  * arrives; a process is created and passed a pending message
  50  * on file descriptor 0.  Datagram servers may either connect
  51  * to their peer, freeing up the original socket for inetd
  52  * to receive further messages on, or ``take over the socket'',
  53  * processing all arriving datagrams and, eventually, timing
  54  * out.  The first type of server is said to be ``multi-threaded'';
  55  * the second type of server ``single-threaded''.
  56  *
  57  * Inetd uses a configuration file which is read at startup
  58  * and, possibly, at some later time in response to a hangup signal.
  59  * The configuration file is ``free format'' with fields given in the
  60  * order shown below.  Continuation lines for an entry must begin with
  61  * a space or tab.  All fields must be present in each entry.
  62  *
  63  *      service name                    must be in /etc/services
  64  *      socket type                     stream/dgram/raw/rdm/seqpacket
  65  *      protocol                        must be in /etc/protocols
  66  *      wait/nowait[.max]               single-threaded/multi-threaded, max #
  67  *      user[.group] or user[:group]    user/group to run daemon as
  68  *      server program                  full path name
  69  *      server program arguments        maximum of MAXARGS (20)
  70  *
  71  * For RPC services
  72  *      service name/version            must be in /etc/rpc
  73  *      socket type                     stream/dgram/raw/rdm/seqpacket
  74  *      protocol                        must be in /etc/protocols
  75  *      wait/nowait[.max]               single-threaded/multi-threaded
  76  *      user[.group] or user[:group]    user to run daemon as
  77  *      server program                  full path name
  78  *      server program arguments        maximum of MAXARGS (20)
  79  *
  80  * For non-RPC services, the "service name" can be of the form
  81  * hostaddress:servicename, in which case the hostaddress is used
  82  * as the host portion of the address to listen on.  If hostaddress
  83  * consists of a single `*' character, INADDR_ANY is used.
  84  *
  85  * A line can also consist of just
  86  *      hostaddress:
  87  * where hostaddress is as in the preceding paragraph.  Such a line must
  88  * have no further fields; the specified hostaddress is remembered and
  89  * used for all further lines that have no hostaddress specified,
  90  * until the next such line (or EOF).  (This is why * is provided to
  91  * allow explicit specification of INADDR_ANY.)  A line
  92  *      *:
  93  * is implicitly in effect at the beginning of the file.
  94  *
  95  * The hostaddress specifier may (and often will) contain dots;
  96  * the service name must not.
  97  *
  98  * For RPC services, host-address specifiers are accepted and will
  99  * work to some extent; however, because of limitations in the
 100  * portmapper interface, it will not work to try to give more than
 101  * one line for any given RPC service, even if the host-address
 102  * specifiers are different.
 103  *
 104  * Comment lines are indicated by a `#' in column 1.
 105  */
 106
 107 /*
 108  * Here's the scoop concerning the user[.:]group feature:
 109  *
 110  * 1) set-group-option off.
 111  *
 112  *      a) user = root: NO setuid() or setgid() is done
 113  *
 114  *      b) other:       setgid(primary group as found in passwd)
 115  *                      initgroups(name, primary group)
 116  *                      setuid()
 117  *
 118  * 2) set-group-option on.
 119  *
 120  *      a) user = root: setgid(specified group)
 121  *                      NO initgroups()
 122  *                      NO setuid()
 123  *
 124  *      b) other:       setgid(specified group)
 125  *                      initgroups(name, specified group)
 126  *                      setuid()
 127  *
 128  */
 129
 130 #include <sys/param.h>
 131 #include <sys/stat.h>
 132 #include <sys/ioctl.h>
 133 #include <sys/socket.h>
 134 #include <sys/un.h>
 135 #include <sys/file.h>
 136 #include <sys/wait.h>
 137 #include <sys/time.h>
 138 #include <sys/resource.h>
 139
 140
 141 #include <netinet/in.h>
 142 #include <arpa/inet.h>
 143
 144 #include <errno.h>
 145 #include <signal.h>
 146 #include <netdb.h>
 147 #include <syslog.h>
 148 #include <stdio.h>
 149 #include <stdlib.h>
 150 #include <unistd.h>
 151 #include <string.h>
 152 #include <ctype.h>
 153 #include <time.h>
 154
 155 #include "busybox.h"
 156
 157 //#define CONFIG_FEATURE_INETD_RPC
 158 //#define CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO
 159 //#define CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD
 160 //#define CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME
 161 //#define CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME
 162 //#define CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
 163 //#define CONFIG_FEATURE_IPV6
 164
 165 #ifdef CONFIG_FEATURE_INETD_RPC
 166 #include <rpc/rpc.h>
 167 #include <rpc/pmap_clnt.h>
 168 #include <rpcsvc/nfs_prot.h>
 169 #endif
 170
 171 #define _PATH_INETDCONF "/etc/inetd.conf"
 172 #define _PATH_INETDPID  "/var/run/inetd.pid"
 173
 174
 175 #define TOOMANY         0               /* don't start more than TOOMANY */
 176
 177 #define CNT_INTVL       60              /* servers in CNT_INTVL sec. */
 178 #define RETRYTIME       (60*10)         /* retry after bind or server fail */
 179
 180 #ifndef RLIMIT_NOFILE
 181 #define RLIMIT_NOFILE   RLIMIT_OFILE
 182 #endif
 183
 184 #ifndef OPEN_MAX
 185 #define OPEN_MAX        64
 186 #endif
 187
 188 /* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
 189 #define FD_MARGIN       (8)
 190 static rlim_t rlim_ofile_cur = OPEN_MAX;
 191 static struct rlimit rlim_ofile;
 192
 193
 194 /* Check unsupporting builtin */
 195 #if defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO || \
 196         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD || \
 197         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME || \
 198         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME || \
 199         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
 200 # define INETD_FEATURE_ENABLED
 201 #endif
 202
 203 #if defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO || \
 204         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD || \
 205         defined CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
 206 # define INETD_SETPROCTITLE
 207 #endif
 208
 209 typedef struct servtab
 210 {
 211   char *se_hostaddr;                    /* host address to listen on */
 212   char *se_service;                     /* name of service */
 213   int se_socktype;                      /* type of socket to use */
 214   int se_family;                        /* address family */
 215   char *se_proto;                       /* protocol used */
 216 #ifdef CONFIG_FEATURE_INETD_RPC
 217   int se_rpcprog;                       /* rpc program number */
 218   int se_rpcversl;                      /* rpc program lowest version */
 219   int se_rpcversh;                      /* rpc program highest version */
 220 #define isrpcservice(sep)       ((sep)->se_rpcversl != 0)
 221 #else
 222 #define isrpcservice(sep)       0
 223 #endif
 224   pid_t se_wait;                        /* single threaded server */
 225   short se_checked;                     /* looked at during merge */
 226   char *se_user;                        /* user name to run as */
 227   char *se_group;                       /* group name to run as */
 228 #ifdef INETD_FEATURE_ENABLED
 229   const struct biltin *se_bi;                 /* if built-in, description */
 230 #endif
 231   char *se_server;                      /* server program */
 232 #define MAXARGV 20
 233   char *se_argv[MAXARGV + 1];           /* program arguments */
 234   int se_fd;                            /* open descriptor */
 235   union
 236   {
 237         struct sockaddr se_un_ctrladdr;
 238         struct sockaddr_in se_un_ctrladdr_in;
 239 #ifdef CONFIG_FEATURE_IPV6
 240         struct sockaddr_in6 se_un_ctrladdr_in6;
 241 #endif
 242         struct sockaddr_un se_un_ctrladdr_un;
 243   } se_un;                              /* bound address */
 244 #define se_ctrladdr     se_un.se_un_ctrladdr
 245 #define se_ctrladdr_in  se_un.se_un_ctrladdr_in
 246 #define se_ctrladdr_in6 se_un.se_un_ctrladdr_in6
 247 #define se_ctrladdr_un  se_un.se_un_ctrladdr_un
 248   int se_ctrladdr_size;
 249   int se_max;                           /* max # of instances of this service */
 250   int se_count;                         /* number started since se_time */
 251   struct timeval se_time;               /* start of se_count */
 252   struct servtab *se_next;
 253 } servtab_t;
 254
 255 static servtab_t *servtab;
 256
 257 #ifdef INETD_FEATURE_ENABLED
 258 struct biltin
 259 {
 260   const char *bi_service;               /* internally provided service name */
 261   int bi_socktype;                      /* type of socket supported */
 262   short bi_fork;                        /* 1 if should fork before call */
 263   short bi_wait;                        /* 1 if should wait for child */
 264   void (*bi_fn) (int, servtab_t *);
 265 };
 266
 267         /* Echo received data */
 268 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO
 269 static void echo_stream (int, servtab_t *);
 270 static void echo_dg (int, servtab_t *);
 271 #endif
 272         /* Internet /dev/null */
 273 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD
 274 static void discard_stream (int, servtab_t *);
 275 static void discard_dg (int, servtab_t *);
 276 #endif
 277         /* Return 32 bit time since 1900 */
 278 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME
 279 static void machtime_stream (int, servtab_t *);
 280 static void machtime_dg (int, servtab_t *);
 281 #endif
 282         /* Return human-readable time */
 283 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME
 284 static void daytime_stream (int, servtab_t *);
 285 static void daytime_dg (int, servtab_t *);
 286 #endif
 287         /* Familiar character generator */
 288 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
 289 static void chargen_stream (int, servtab_t *);
 290 static void chargen_dg (int, servtab_t *);
 291 #endif
 292
 293 static const struct biltin biltins[] = {
 294 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO
 295   /* Echo received data */
 296   {"echo", SOCK_STREAM, 1, 0, echo_stream,},
 297   {"echo", SOCK_DGRAM, 0, 0, echo_dg,},
 298 #endif
 299 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD
 300   /* Internet /dev/null */
 301   {"discard", SOCK_STREAM, 1, 0, discard_stream,},
 302   {"discard", SOCK_DGRAM, 0, 0, discard_dg,},
 303 #endif
 304 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME
 305   /* Return 32 bit time since 1900 */
 306   {"time", SOCK_STREAM, 0, 0, machtime_stream,},
 307   {"time", SOCK_DGRAM, 0, 0, machtime_dg,},
 308 #endif
 309 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME
 310   /* Return human-readable time */
 311   {"daytime", SOCK_STREAM, 0, 0, daytime_stream,},
 312   {"daytime", SOCK_DGRAM, 0, 0, daytime_dg,},
 313 #endif
 314 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
 315   /* Familiar character generator */
 316   {"chargen", SOCK_STREAM, 1, 0, chargen_stream,},
 317   {"chargen", SOCK_DGRAM, 0, 0, chargen_dg,},
 318 #endif
 319   {NULL, 0, 0, 0, NULL}
 320 };
 321 #endif /* INETD_FEATURE_ENABLED */
 322
 323 static int global_queuelen = 128;
 324 static int nsock, maxsock;
 325 static fd_set allsock;
 326 static int toomany = TOOMANY;
 327 static int timingout;
 328 static struct servent *sp;
 329 static uid_t uid;
 330
 331 static char *CONFIG = _PATH_INETDCONF;
 332
 333 static FILE *fconfig;
 334 static char line[1024];
 335 static char *defhost;
 336
 337 static char *newstr (char *cp)
 338 {
 339   if ((cp = strdup (cp ? cp : "")))
 340         return (cp);
 341   syslog (LOG_ERR, "strdup: %m");
 342   exit (1);
 343 }
 344
 345 static int setconfig (void)
 346 {
 347   free (defhost);
 348   defhost = newstr ("*");
 349   if (fconfig != NULL) {
 350         fseek (fconfig, 0L, SEEK_SET);
 351         return (1);
 352   }
 353   fconfig = fopen (CONFIG, "r");
 354   return (fconfig != NULL);
 355 }
 356
 357 static void endconfig (void)
 358 {
 359   if (fconfig) {
 360         (void) fclose (fconfig);
 361         fconfig = NULL;
 362   }
 363   free (defhost);
 364   defhost = 0;
 365 }
 366
 367 #ifdef CONFIG_FEATURE_INETD_RPC
 368 static void register_rpc (servtab_t *sep)
 369 {
 370   int n;
 371   struct sockaddr_in ir_sin;
 372   struct protoent *pp;
 373   socklen_t size;
 374
 375   if ((pp = getprotobyname (sep->se_proto + 4)) == NULL) {
 376         syslog (LOG_ERR, "%s: getproto: %m", sep->se_proto);
 377         return;
 378   }
 379   size = sizeof ir_sin;
 380   if (getsockname (sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) {
 381         syslog (LOG_ERR, "%s/%s: getsockname: %m",
 382                         sep->se_service, sep->se_proto);
 383         return;
 384   }
 385
 386   for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
 387         (void) pmap_unset (sep->se_rpcprog, n);
 388         if (!pmap_set (sep->se_rpcprog, n, pp->p_proto, ntohs (ir_sin.sin_port)))
 389           syslog (LOG_ERR, "%s %s: pmap_set: %u %u %u %u: %m",
 390                           sep->se_service, sep->se_proto,
 391                           sep->se_rpcprog, n, pp->p_proto, ntohs (ir_sin.sin_port));
 392   }
 393 }
 394
 395 static void unregister_rpc (servtab_t *sep)
 396 {
 397   int n;
 398
 399   for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
 400         if (!pmap_unset (sep->se_rpcprog, n))
 401           syslog (LOG_ERR, "pmap_unset(%u, %u)", sep->se_rpcprog, n);
 402   }
 403 }
 404 #endif /* CONFIG_FEATURE_INETD_RPC */
 405
 406 static void freeconfig (servtab_t *cp)
 407 {
 408   int i;
 409
 410   free (cp->se_hostaddr);
 411   free (cp->se_service);
 412   free (cp->se_proto);
 413   free (cp->se_user);
 414   free (cp->se_group);
 415   free (cp->se_server);
 416   for (i = 0; i < MAXARGV; i++)
 417         if (cp->se_argv[i])
 418           free (cp->se_argv[i]);
 419 }
 420
 421 static int bump_nofile (void)
 422 {
 423 #define FD_CHUNK        32
 424
 425   struct rlimit rl;
 426
 427   if (getrlimit (RLIMIT_NOFILE, &rl) < 0) {
 428         syslog (LOG_ERR, "getrlimit: %m");
 429         return -1;
 430   }
 431   rl.rlim_cur = MIN (rl.rlim_max, rl.rlim_cur + FD_CHUNK);
 432   rl.rlim_cur = MIN (FD_SETSIZE, rl.rlim_cur + FD_CHUNK);
 433   if (rl.rlim_cur <= rlim_ofile_cur) {
 434         syslog (LOG_ERR, "bump_nofile: cannot extend file limit, max = %d",
 435                         (int) rl.rlim_cur);
 436         return -1;
 437   }
 438
 439   if (setrlimit (RLIMIT_NOFILE, &rl) < 0) {
 440         syslog (LOG_ERR, "setrlimit: %m");
 441         return -1;
 442   }
 443
 444   rlim_ofile_cur = rl.rlim_cur;
 445   return 0;
 446 }
 447
 448 static void setup (servtab_t *sep)
 449 {
 450   int on = 1;
 451   int r;
 452
 453   if ((sep->se_fd = socket (sep->se_family, sep->se_socktype, 0)) < 0) {
 454         syslog (LOG_ERR, "%s/%s: socket: %m", sep->se_service, sep->se_proto);
 455         return;
 456   }
 457 #define turnon(fd, opt) \
 458 setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
 459   if (turnon (sep->se_fd, SO_REUSEADDR) < 0)
 460         syslog (LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
 461 #undef turnon
 462
 463 #ifdef CONFIG_FEATURE_INETD_RPC
 464   if (isrpcservice (sep)) {
 465         struct passwd *pwd;
 466
 467         /*
 468          * for RPC services, attempt to use a reserved port
 469          * if they are going to be running as root.
 470          *
 471          * Also, zero out the port for all RPC services; let bind()
 472          * find one.
 473          */
 474         sep->se_ctrladdr_in.sin_port = 0;
 475         if (sep->se_user && (pwd = getpwnam (sep->se_user)) &&
 476                 pwd->pw_uid == 0 && uid == 0)
 477           r = bindresvport (sep->se_fd, &sep->se_ctrladdr_in);
 478         else {
 479           r = bind (sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size);
 480           if (r == 0) {
 481                 socklen_t len = sep->se_ctrladdr_size;
 482                 int saveerrno = errno;
 483
 484                 /* update se_ctrladdr_in.sin_port */
 485                 r = getsockname (sep->se_fd, &sep->se_ctrladdr, &len);
 486                 if (r <= 0)
 487                   errno = saveerrno;
 488           }
 489         }
 490   } else
 491 #endif
 492         r = bind (sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size);
 493   if (r < 0) {
 494         syslog (LOG_ERR, "%s/%s (%d): bind: %m",
 495                         sep->se_service, sep->se_proto, sep->se_ctrladdr.sa_family);
 496         close (sep->se_fd);
 497         sep->se_fd = -1;
 498         if (!timingout) {
 499           timingout = 1;
 500           alarm (RETRYTIME);
 501         }
 502         return;
 503   }
 504   if (sep->se_socktype == SOCK_STREAM)
 505         listen (sep->se_fd, global_queuelen);
 506
 507   FD_SET (sep->se_fd, &allsock);
 508   nsock++;
 509   if (sep->se_fd > maxsock) {
 510         maxsock = sep->se_fd;
 511         if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
 512           bump_nofile ();
 513   }
 514 }
 515
 516 static char *nextline (void)
 517 {
 518   char *cp;
 519   FILE *fd = fconfig;
 520
 521   if (fgets (line, sizeof (line), fd) == NULL)
 522         return (NULL);
 523   cp = strchr (line, '\n');
 524   if (cp)
 525         *cp = '\0';
 526   return (line);
 527 }
 528
 529 static char *skip (char **cpp) /* int report; */
 530 {
 531   char *cp = *cpp;
 532   char *start;
 533
 534 /* erp: */
 535   if (*cpp == NULL) {
 536         /* if (report) */
 537         /* syslog(LOG_ERR, "syntax error in inetd config file"); */
 538         return (NULL);
 539   }
 540
 541 again:
 542   while (*cp == ' ' || *cp == '\t')
 543         cp++;
 544   if (*cp == '\0') {
 545         int c;
 546
 547         c = getc (fconfig);
 548         (void) ungetc (c, fconfig);
 549         if (c == ' ' || c == '\t')
 550           if ((cp = nextline ()))
 551                 goto again;
 552         *cpp = NULL;
 553         /* goto erp; */
 554         return (NULL);
 555   }
 556   start = cp;
 557   while (*cp && *cp != ' ' && *cp != '\t')
 558         cp++;
 559   if (*cp != '\0')
 560         *cp++ = '\0';
 561   /* if ((*cpp = cp) == NULL) */
 562   /* goto erp; */
 563
 564   *cpp = cp;
 565   return (start);
 566 }
 567
 568 static servtab_t *new_servtab(void)
 569 {
 570   servtab_t *sep;
 571
 572   sep = (servtab_t *) malloc (sizeof (servtab_t));
 573   if (sep == NULL) {
 574         syslog (LOG_ERR, bb_msg_memory_exhausted);
 575         exit (1);
 576   }
 577   return sep;
 578 }
 579
 580 static servtab_t *dupconfig (servtab_t *sep)
 581 {
 582   servtab_t *newtab;
 583   int argc;
 584
 585   newtab = new_servtab();
 586   memset (newtab, 0, sizeof (servtab_t));
 587   newtab->se_service = sep->se_service ? newstr (sep->se_service) : NULL;
 588   newtab->se_socktype = sep->se_socktype;
 589   newtab->se_family = sep->se_family;
 590   newtab->se_proto = sep->se_proto ? newstr (sep->se_proto) : NULL;
 591 #ifdef CONFIG_FEATURE_INETD_RPC
 592   newtab->se_rpcprog = sep->se_rpcprog;
 593   newtab->se_rpcversl = sep->se_rpcversl;
 594   newtab->se_rpcversh = sep->se_rpcversh;
 595 #endif
 596   newtab->se_wait = sep->se_wait;
 597   newtab->se_user = sep->se_user ? newstr (sep->se_user) : NULL;
 598   newtab->se_group = sep->se_group ? newstr (sep->se_group) : NULL;
 599 #ifdef INETD_FEATURE_ENABLED
 600   newtab->se_bi = sep->se_bi;
 601 #endif
 602   newtab->se_server = sep->se_server ? newstr (sep->se_server) : 0;
 603
 604   for (argc = 0; argc <= MAXARGV; argc++)
 605         newtab->se_argv[argc] = sep->se_argv[argc] ?
 606           newstr (sep->se_argv[argc]) : NULL;
 607   newtab->se_max = sep->se_max;
 608
 609   return (newtab);
 610 }
 611
 612 static servtab_t *getconfigent (void)
 613 {
 614   servtab_t *sep;
 615   int argc;
 616   char *cp, *arg;
 617   char *hostdelim;
 618   servtab_t *nsep;
 619   servtab_t *psep;
 620
 621   sep = new_servtab();
 622
 623   /* memset(sep, 0, sizeof *sep); */
 624 more:
 625   /* freeconfig(sep); */
 626
 627   while ((cp = nextline ()) && *cp == '#');
 628   if (cp == NULL) {
 629         /* free(sep); */
 630         return (NULL);
 631   }
 632
 633   memset ((char *) sep, 0, sizeof *sep);
 634   arg = skip (&cp);
 635   if (arg == NULL) {
 636         /* A blank line. */
 637         goto more;
 638   }
 639
 640   /* Check for a host name. */
 641   hostdelim = strrchr (arg, ':');
 642   if (hostdelim) {
 643         *hostdelim = '\0';
 644         sep->se_hostaddr = newstr (arg);
 645         arg = hostdelim + 1;
 646         /*
 647          * If the line is of the form `host:', then just change the
 648          * default host for the following lines.
 649          */
 650         if (*arg == '\0') {
 651           arg = skip (&cp);
 652           if (cp == NULL) {
 653                 free (defhost);
 654                 defhost = sep->se_hostaddr;
 655                 goto more;
 656           }
 657         }
 658   } else
 659         sep->se_hostaddr = newstr (defhost);
 660
 661   sep->se_service = newstr (arg);
 662   arg = skip (&cp);
 663
 664   if (strcmp (arg, "stream") == 0)
 665         sep->se_socktype = SOCK_STREAM;
 666   else if (strcmp (arg, "dgram") == 0)
 667         sep->se_socktype = SOCK_DGRAM;
 668   else if (strcmp (arg, "rdm") == 0)
 669         sep->se_socktype = SOCK_RDM;
 670   else if (strcmp (arg, "seqpacket") == 0)
 671         sep->se_socktype = SOCK_SEQPACKET;
 672   else if (strcmp (arg, "raw") == 0)
 673         sep->se_socktype = SOCK_RAW;
 674   else
 675         sep->se_socktype = -1;
 676
 677   sep->se_proto = newstr (skip (&cp));
 678
 679   if (strcmp (sep->se_proto, "unix") == 0) {
 680         sep->se_family = AF_UNIX;
 681   } else {
 682         sep->se_family = AF_INET;
 683         if (sep->se_proto[strlen (sep->se_proto) - 1] == '6')
 684 #ifdef CONFIG_FEATURE_IPV6
 685           sep->se_family = AF_INET6;
 686 #else
 687           syslog (LOG_ERR, "%s: IPV6 not supported", sep->se_proto);
 688 #endif
 689         if (strncmp (sep->se_proto, "rpc/", 4) == 0) {
 690 #ifdef CONFIG_FEATURE_INETD_RPC
 691           char *p, *ccp;
 692           long l;
 693
 694           p = strchr (sep->se_service, '/');
 695           if (p == 0) {
 696                 syslog (LOG_ERR, "%s: no rpc version", sep->se_service);
 697                 goto more;
 698           }
 699           *p++ = '\0';
 700           l = strtol (p, &ccp, 0);
 701           if (ccp == p || l < 0 || l > INT_MAX) {
 702           badafterall:
 703                 syslog (LOG_ERR, "%s/%s: bad rpc version", sep->se_service, p);
 704                 goto more;
 705           }
 706           sep->se_rpcversl = sep->se_rpcversh = l;
 707           if (*ccp == '-') {
 708                 p = ccp + 1;
 709                 l = strtol (p, &ccp, 0);
 710                 if (ccp == p || l < 0 || l > INT_MAX || l < sep->se_rpcversl || *ccp)
 711                   goto badafterall;
 712                 sep->se_rpcversh = l;
 713           } else if (*ccp != '\0')
 714                 goto badafterall;
 715 #else
 716         syslog (LOG_ERR, "%s: rpc services not supported", sep->se_service);
 717 #endif
 718         }
 719   }
 720   arg = skip (&cp);
 721   if (arg == NULL)
 722         goto more;
 723
 724   {
 725         char *s = strchr (arg, '.');
 726         if (s) {
 727           *s++ = '\0';
 728           sep->se_max = atoi (s);
 729         } else
 730           sep->se_max = toomany;
 731   }
 732   sep->se_wait = strcmp (arg, "wait") == 0;
 733   /* if ((arg = skip(&cp, 1)) == NULL) */
 734   /* goto more; */
 735   sep->se_user = newstr (skip (&cp));
 736   arg = strchr (sep->se_user, '.');
 737   if (arg == NULL)
 738         arg = strchr (sep->se_user, ':');
 739   if (arg) {
 740         *arg++ = '\0';
 741         sep->se_group = newstr (arg);
 742   }
 743   /* if ((arg = skip(&cp, 1)) == NULL) */
 744   /* goto more; */
 745
 746   sep->se_server = newstr (skip (&cp));
 747   if (strcmp (sep->se_server, "internal") == 0) {
 748 #ifdef INETD_FEATURE_ENABLED
 749         const struct biltin *bi;
 750
 751         for (bi = biltins; bi->bi_service; bi++)
 752           if (bi->bi_socktype == sep->se_socktype &&
 753                   strcmp (bi->bi_service, sep->se_service) == 0)
 754                 break;
 755         if (bi->bi_service == 0) {
 756           syslog (LOG_ERR, "internal service %s unknown", sep->se_service);
 757           goto more;
 758         }
 759         sep->se_bi = bi;
 760         sep->se_wait = bi->bi_wait;
 761 #else
 762         syslog (LOG_ERR, "internal service %s unknown", sep->se_service);
 763         goto more;
 764 #endif
 765   }
 766 #ifdef INETD_FEATURE_ENABLED
 767     else
 768         sep->se_bi = NULL;
 769 #endif
 770   argc = 0;
 771   for (arg = skip (&cp); cp; arg = skip (&cp)) {
 772         if (argc < MAXARGV)
 773           sep->se_argv[argc++] = newstr (arg);
 774   }
 775   while (argc <= MAXARGV)
 776         sep->se_argv[argc++] = NULL;
 777
 778   /*
 779    * Now that we've processed the entire line, check if the hostname
 780    * specifier was a comma separated list of hostnames. If so
 781    * we'll make new entries for each address.
 782    */
 783   while ((hostdelim = strrchr (sep->se_hostaddr, ',')) != NULL) {
 784         nsep = dupconfig (sep);
 785
 786         /*
 787          * NULL terminate the hostname field of the existing entry,
 788          * and make a dup for the new entry.
 789          */
 790         *hostdelim++ = '\0';
 791         nsep->se_hostaddr = newstr (hostdelim);
 792
 793         nsep->se_next = sep->se_next;
 794         sep->se_next = nsep;
 795   }
 796
 797   nsep = sep;
 798   while (nsep != NULL) {
 799         nsep->se_checked = 1;
 800         if (nsep->se_family == AF_INET) {
 801           if (!strcmp (nsep->se_hostaddr, "*"))
 802                 nsep->se_ctrladdr_in.sin_addr.s_addr = INADDR_ANY;
 803           else if (!inet_aton (nsep->se_hostaddr, &nsep->se_ctrladdr_in.sin_addr)) {
 804                 struct hostent *hp;
 805
 806                 hp = gethostbyname (nsep->se_hostaddr);
 807                 if (hp == 0) {
 808                   syslog (LOG_ERR, "%s: unknown host", nsep->se_hostaddr);
 809                   nsep->se_checked = 0;
 810                   goto skip;
 811                 } else if (hp->h_addrtype != AF_INET) {
 812                   syslog (LOG_ERR,
 813                                   "%s: address isn't an Internet "
 814                                   "address", nsep->se_hostaddr);
 815                   nsep->se_checked = 0;
 816                   goto skip;
 817                 } else {
 818                   int i = 1;
 819
 820                   memmove (&nsep->se_ctrladdr_in.sin_addr,
 821                                    hp->h_addr_list[0], sizeof (struct in_addr));
 822                   while (hp->h_addr_list[i] != NULL) {
 823                         psep = dupconfig (nsep);
 824                         psep->se_hostaddr = newstr (nsep->se_hostaddr);
 825                         psep->se_checked = 1;
 826                         memmove (&psep->se_ctrladdr_in.sin_addr,
 827                                          hp->h_addr_list[i], sizeof (struct in_addr));
 828                         psep->se_ctrladdr_size = sizeof (psep->se_ctrladdr_in);
 829                         i++;
 830                         /* Prepend to list, don't want to look up its */
 831                         /* hostname again. */
 832                         psep->se_next = sep;
 833                         sep = psep;
 834                   }
 835                 }
 836           }
 837         }
 838 /* XXX BUG?: is this skip: label supposed to remain? */
 839   skip:
 840         nsep = nsep->se_next;
 841   }
 842
 843   /*
 844    * Finally, free any entries which failed the gethostbyname
 845    * check.
 846    */
 847   psep = NULL;
 848   nsep = sep;
 849   while (nsep != NULL) {
 850         servtab_t *tsep;
 851
 852         if (nsep->se_checked == 0) {
 853           tsep = nsep;
 854           if (psep == NULL) {
 855                 sep = nsep->se_next;
 856                 nsep = sep;
 857           } else {
 858                 nsep = nsep->se_next;
 859                 psep->se_next = nsep;
 860           }
 861           freeconfig (tsep);
 862         } else {
 863           nsep->se_checked = 0;
 864           psep = nsep;
 865           nsep = nsep->se_next;
 866         }
 867   }
 868
 869   return (sep);
 870 }
 871
 872 #define Block_Using_Signals(m) do {     sigemptyset(&m); \
 873                                         sigaddset(&m, SIGCHLD); \
 874                                         sigaddset(&m, SIGHUP); \
 875                                         sigaddset(&m, SIGALRM); \
 876                                         sigprocmask(SIG_BLOCK, &m, NULL); \
 877                                 } while(0)
 878
 879
 880 static servtab_t *enter (servtab_t *cp)
 881 {
 882   servtab_t *sep;
 883   sigset_t omask;
 884
 885   sep = new_servtab();
 886   *sep = *cp;
 887   sep->se_fd = -1;
 888 #ifdef CONFIG_FEATURE_INETD_RPC
 889   sep->se_rpcprog = -1;
 890 #endif
 891   Block_Using_Signals(omask);
 892   sep->se_next = servtab;
 893   servtab = sep;
 894   sigprocmask(SIG_UNBLOCK, &omask, NULL);
 895   return (sep);
 896 }
 897
 898 static int matchconf (servtab_t *old, servtab_t *new)
 899 {
 900   if (strcmp (old->se_service, new->se_service) != 0)
 901         return (0);
 902
 903   if (strcmp (old->se_hostaddr, new->se_hostaddr) != 0)
 904         return (0);
 905
 906   if (strcmp (old->se_proto, new->se_proto) != 0)
 907         return (0);
 908
 909   /*
 910    * If the new servtab is bound to a specific address, check that the
 911    * old servtab is bound to the same entry. If the new service is not
 912    * bound to a specific address then the check of se_hostaddr above
 913    * is sufficient.
 914    */
 915
 916   if (old->se_family == AF_INET && new->se_family == AF_INET &&
 917           memcmp (&old->se_ctrladdr_in.sin_addr,
 918                           &new->se_ctrladdr_in.sin_addr,
 919                           sizeof (new->se_ctrladdr_in.sin_addr)) != 0)
 920         return (0);
 921
 922 #ifdef CONFIG_FEATURE_IPV6
 923   if (old->se_family == AF_INET6 && new->se_family == AF_INET6 &&
 924           memcmp (&old->se_ctrladdr_in6.sin6_addr,
 925                           &new->se_ctrladdr_in6.sin6_addr,
 926                           sizeof (new->se_ctrladdr_in6.sin6_addr)) != 0)
 927         return (0);
 928 #endif
 929   return (1);
 930 }
 931
 932 static void config (int sig __attribute__((unused)))
 933 {
 934   servtab_t *sep, *cp, **sepp;
 935   sigset_t omask;
 936   int add;
 937   size_t n;
 938   char protoname[10];
 939
 940   if (!setconfig ()) {
 941         syslog (LOG_ERR, "%s: %m", CONFIG);
 942         return;
 943   }
 944   for (sep = servtab; sep; sep = sep->se_next)
 945         sep->se_checked = 0;
 946   cp = getconfigent ();
 947   while (cp != NULL) {
 948         for (sep = servtab; sep; sep = sep->se_next)
 949           if (matchconf (sep, cp))
 950                 break;
 951         add = 0;
 952         if (sep != 0) {
 953           int i;
 954
 955 #define SWAP(type, a, b) do {type c=(type)a; a=(type)b; b=(type)c;} while (0)
 956
 957           Block_Using_Signals(omask);
 958           /*
 959            * sep->se_wait may be holding the pid of a daemon
 960            * that we're waiting for.  If so, don't overwrite
 961            * it unless the config file explicitly says don't
 962            * wait.
 963            */
 964           if (
 965 #ifdef INETD_FEATURE_ENABLED
 966                    cp->se_bi == 0 &&
 967 #endif
 968                 (sep->se_wait == 1 || cp->se_wait == 0))
 969                 sep->se_wait = cp->se_wait;
 970           SWAP (int, cp->se_max, sep->se_max);
 971           SWAP (char *, sep->se_user, cp->se_user);
 972           SWAP (char *, sep->se_group, cp->se_group);
 973           SWAP (char *, sep->se_server, cp->se_server);
 974           for (i = 0; i < MAXARGV; i++)
 975                 SWAP (char *, sep->se_argv[i], cp->se_argv[i]);
 976 #undef SWAP
 977
 978 #ifdef CONFIG_FEATURE_INETD_RPC
 979           if (isrpcservice (sep))
 980                 unregister_rpc (sep);
 981           sep->se_rpcversl = cp->se_rpcversl;
 982           sep->se_rpcversh = cp->se_rpcversh;
 983 #endif
 984           sigprocmask(SIG_UNBLOCK, &omask, NULL);
 985           freeconfig (cp);
 986           add = 1;
 987         } else {
 988           sep = enter (cp);
 989         }
 990         sep->se_checked = 1;
 991
 992         switch (sep->se_family) {
 993         case AF_UNIX:
 994           if (sep->se_fd != -1)
 995                 break;
 996           (void) unlink (sep->se_service);
 997           n = strlen (sep->se_service);
 998           if (n > sizeof sep->se_ctrladdr_un.sun_path - 1)
 999                 n = sizeof sep->se_ctrladdr_un.sun_path - 1;
1000           safe_strncpy (sep->se_ctrladdr_un.sun_path, sep->se_service, n + 1);
1001           sep->se_ctrladdr_un.sun_family = AF_UNIX;
1002           sep->se_ctrladdr_size = n + sizeof sep->se_ctrladdr_un.sun_family;
1003           setup (sep);
1004           break;
1005         case AF_INET:
1006           sep->se_ctrladdr_in.sin_family = AF_INET;
1007           /* se_ctrladdr_in was set in getconfigent */
1008           sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in;
1009
1010 #ifdef CONFIG_FEATURE_INETD_RPC
1011           if (isrpcservice (sep)) {
1012                 struct rpcent *rp;
1013
1014                 sep->se_rpcprog = atoi (sep->se_service);
1015                 if (sep->se_rpcprog == 0) {
1016                   rp = getrpcbyname (sep->se_service);
1017                   if (rp == 0) {
1018                         syslog (LOG_ERR, "%s: unknown rpc service", sep->se_service);
1019                         goto serv_unknown;
1020                   }
1021                   sep->se_rpcprog = rp->r_number;
1022                 }
1023                 if (sep->se_fd == -1)
1024                   setup (sep);
1025                 if (sep->se_fd != -1)
1026                   register_rpc (sep);
1027           } else
1028 #endif
1029              {
1030                 u_short port = htons (atoi (sep->se_service));
1031
1032                 if (!port) {
1033                    /*XXX*/ strncpy (protoname, sep->se_proto, sizeof (protoname));
1034                   if (isdigit (protoname[strlen (protoname) - 1]))
1035                         protoname[strlen (protoname) - 1] = '\0';
1036                   sp = getservbyname (sep->se_service, protoname);
1037                   if (sp == 0) {
1038                         syslog (LOG_ERR,
1039                                         "%s/%s: unknown service", sep->se_service, sep->se_proto);
1040                         goto serv_unknown;
1041                   }
1042                   port = sp->s_port;
1043                 }
1044                 if (port != sep->se_ctrladdr_in.sin_port) {
1045                   sep->se_ctrladdr_in.sin_port = port;
1046                   if (sep->se_fd != -1) {
1047                         FD_CLR (sep->se_fd, &allsock);
1048                         nsock--;
1049                         (void) close (sep->se_fd);
1050                   }
1051                   sep->se_fd = -1;
1052                 }
1053                 if (sep->se_fd == -1)
1054                   setup (sep);
1055           }
1056           break;
1057 #ifdef CONFIG_FEATURE_IPV6
1058         case AF_INET6:
1059           sep->se_ctrladdr_in6.sin6_family = AF_INET6;
1060           /* se_ctrladdr_in was set in getconfigent */
1061           sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in6;
1062
1063 #ifdef CONFIG_FEATURE_INETD_RPC
1064           if (isrpcservice (sep)) {
1065                 struct rpcent *rp;
1066
1067                 sep->se_rpcprog = atoi (sep->se_service);
1068                 if (sep->se_rpcprog == 0) {
1069                   rp = getrpcbyname (sep->se_service);
1070                   if (rp == 0) {
1071                         syslog (LOG_ERR, "%s: unknown rpc service", sep->se_service);
1072                         goto serv_unknown;
1073                   }
1074                   sep->se_rpcprog = rp->r_number;
1075                 }
1076                 if (sep->se_fd == -1)
1077                   setup (sep);
1078                 if (sep->se_fd != -1)
1079                   register_rpc (sep);
1080           } else
1081 #endif
1082                 {
1083                 u_short port = htons (atoi (sep->se_service));
1084
1085                 if (!port) {
1086                    /*XXX*/ strncpy (protoname, sep->se_proto, sizeof (protoname));
1087                   if (isdigit (protoname[strlen (protoname) - 1]))
1088                         protoname[strlen (protoname) - 1] = '\0';
1089                   sp = getservbyname (sep->se_service, protoname);
1090                   if (sp == 0) {
1091                         syslog (LOG_ERR,
1092                                         "%s/%s: unknown service", sep->se_service, sep->se_proto);
1093                         goto serv_unknown;
1094                   }
1095                   port = sp->s_port;
1096                 }
1097                 if (port != sep->se_ctrladdr_in6.sin6_port) {
1098                   sep->se_ctrladdr_in6.sin6_port = port;
1099                   if (sep->se_fd != -1) {
1100                         FD_CLR (sep->se_fd, &allsock);
1101                         nsock--;
1102                         (void) close (sep->se_fd);
1103                   }
1104                   sep->se_fd = -1;
1105                 }
1106                 if (sep->se_fd == -1)
1107                   setup (sep);
1108           }
1109           break;
1110 #endif /* CONFIG_FEATURE_IPV6 */
1111         }
1112   serv_unknown:
1113         if (cp->se_next != NULL) {
1114           servtab_t *tmp = cp;
1115
1116           cp = cp->se_next;
1117           free (tmp);
1118         } else {
1119           free (cp);
1120           cp = getconfigent ();
1121         }
1122   }
1123   endconfig ();
1124   /*
1125    * Purge anything not looked at above.
1126    */
1127   Block_Using_Signals(omask);
1128   sepp = &servtab;
1129   while ((sep = *sepp)) {
1130         if (sep->se_checked) {
1131           sepp = &sep->se_next;
1132           continue;
1133         }
1134         *sepp = sep->se_next;
1135         if (sep->se_fd != -1) {
1136           FD_CLR (sep->se_fd, &allsock);
1137           nsock--;
1138           (void) close (sep->se_fd);
1139         }
1140 #ifdef CONFIG_FEATURE_INETD_RPC
1141         if (isrpcservice (sep))
1142           unregister_rpc (sep);
1143 #endif
1144         if (sep->se_family == AF_UNIX)
1145           (void) unlink (sep->se_service);
1146         freeconfig (sep);
1147         free (sep);
1148   }
1149   sigprocmask(SIG_UNBLOCK, &omask, NULL);
1150 }
1151
1152
1153 static void reapchild (int sig __attribute__((unused)))
1154 {
1155   pid_t pid;
1156   int save_errno = errno, status;
1157   servtab_t *sep;
1158
1159   for (;;) {
1160         pid = wait3 (&status, WNOHANG, NULL);
1161         if (pid <= 0)
1162           break;
1163         for (sep = servtab; sep; sep = sep->se_next)
1164           if (sep->se_wait == pid) {
1165                 if (WIFEXITED (status) && WEXITSTATUS (status))
1166                   syslog (LOG_WARNING,
1167                                   "%s: exit status 0x%x",
1168                                   sep->se_server, WEXITSTATUS (status));
1169                 else if (WIFSIGNALED (status))
1170                   syslog (LOG_WARNING,
1171                                   "%s: exit signal 0x%x", sep->se_server, WTERMSIG (status));
1172                 sep->se_wait = 1;
1173                 FD_SET (sep->se_fd, &allsock);
1174                 nsock++;
1175           }
1176   }
1177   errno = save_errno;
1178 }
1179
1180 static void retry (int sig __attribute__((unused)))
1181 {
1182   servtab_t *sep;
1183
1184   timingout = 0;
1185   for (sep = servtab; sep; sep = sep->se_next) {
1186         if (sep->se_fd == -1) {
1187           switch (sep->se_family) {
1188           case AF_UNIX:
1189           case AF_INET:
1190 #ifdef CONFIG_FEATURE_IPV6
1191           case AF_INET6:
1192 #endif
1193                 setup (sep);
1194 #ifdef CONFIG_FEATURE_INETD_RPC
1195                 if (sep->se_fd != -1 && isrpcservice (sep))
1196                   register_rpc (sep);
1197 #endif
1198                 break;
1199           }
1200         }
1201   }
1202 }
1203
1204 static void goaway (int sig __attribute__((unused)))
1205 {
1206   servtab_t *sep;
1207
1208   /* XXX signal race walking sep list */
1209   for (sep = servtab; sep; sep = sep->se_next) {
1210         if (sep->se_fd == -1)
1211           continue;
1212
1213         switch (sep->se_family) {
1214         case AF_UNIX:
1215           (void) unlink (sep->se_service);
1216           break;
1217         case AF_INET:
1218 #ifdef CONFIG_FEATURE_IPV6
1219         case AF_INET6:
1220 #endif
1221 #ifdef CONFIG_FEATURE_INETD_RPC
1222           if (sep->se_wait == 1 && isrpcservice (sep))
1223                 unregister_rpc (sep);   /* XXX signal race */
1224 #endif
1225           break;
1226         }
1227         (void) close (sep->se_fd);
1228   }
1229   (void) unlink (_PATH_INETDPID);
1230   exit (0);
1231 }
1232
1233
1234 #ifdef INETD_SETPROCTITLE
1235 static char **Argv;
1236 static char *LastArg;
1237
1238 static void
1239 inetd_setproctitle (char *a, int s)
1240 {
1241   socklen_t size;
1242   char *cp;
1243   struct sockaddr_in prt_sin;
1244   char buf[80];
1245
1246   cp = Argv[0];
1247   size = sizeof (prt_sin);
1248   (void) snprintf (buf, sizeof buf, "-%s", a);
1249   if (getpeername (s, (struct sockaddr *) &prt_sin, &size) == 0) {
1250         char *sa = inet_ntoa (prt_sin.sin_addr);
1251
1252         buf[sizeof (buf) - 1 - strlen (sa) - 3] = '\0';
1253         strcat (buf, " [");
1254         strcat (buf, sa);
1255         strcat (buf, "]");
1256   }
1257   strncpy (cp, buf, LastArg - cp);
1258   cp += strlen (cp);
1259   while (cp < LastArg)
1260         *cp++ = ' ';
1261 }
1262 #endif
1263
1264
1265 int
1266 inetd_main (int argc, char *argv[])
1267 {
1268   servtab_t *sep;
1269   struct passwd *pwd;
1270   struct group *grp = NULL;
1271   int tmpint;
1272   struct sigaction sa, sapipe;
1273   int opt;
1274   pid_t pid;
1275   char buf[50];
1276   char *stoomany;
1277   sigset_t omask;
1278
1279 #ifdef INETD_SETPROCTITLE
1280   extern char **environ;
1281   char **envp = environ;
1282
1283   Argv = argv;
1284   if (envp == 0 || *envp == 0)
1285         envp = argv;
1286   while (*envp)
1287         envp++;
1288   LastArg = envp[-1] + strlen (envp[-1]);
1289 #endif
1290
1291   openlog (bb_applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
1292
1293   opt = bb_getopt_ulflags (argc, argv, "R:f", &stoomany);
1294   if(opt & 1) {
1295         char *e;
1296
1297         toomany = strtoul (stoomany, &e, 0);
1298         if (!(toomany >= 0 && *e == '\0')) {
1299                 toomany = TOOMANY;
1300                 syslog (LOG_ERR, "-R %s: bad value for service invocation rate", stoomany);
1301         }
1302   }
1303   argc -= optind;
1304   argv += optind;
1305
1306   uid = getuid ();
1307   if (uid != 0)
1308         CONFIG = NULL;
1309   if (argc > 0)
1310         CONFIG = argv[0];
1311   if (CONFIG == NULL)
1312         bb_error_msg_and_die ("non-root must specify a config file");
1313
1314   if (!(opt & 2)) {
1315 #if defined(__uClinux__)
1316         /* reexec for vfork() do continue parent */
1317         vfork_daemon_rexec (0, 0, argc, argv, "-f");
1318 #else
1319         daemon (0, 0);
1320 #endif /* uClinux */
1321   } else {
1322         setsid ();
1323   }
1324
1325   if (uid == 0) {
1326         gid_t gid = getgid ();
1327
1328         /* If run by hand, ensure groups vector gets trashed */
1329         setgroups (1, &gid);
1330   }
1331
1332   {
1333         FILE *fp;
1334
1335         if ((fp = fopen (_PATH_INETDPID, "w")) != NULL) {
1336                 fprintf (fp, "%u\n", getpid ());
1337                 (void) fclose (fp);
1338         }
1339   }
1340
1341   if (getrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0) {
1342         syslog (LOG_ERR, "getrlimit: %m");
1343   } else {
1344         rlim_ofile_cur = rlim_ofile.rlim_cur;
1345         if (rlim_ofile_cur == RLIM_INFINITY)    /* ! */
1346           rlim_ofile_cur = OPEN_MAX;
1347   }
1348
1349   memset ((char *) &sa, 0, sizeof (sa));
1350   sigemptyset (&sa.sa_mask);
1351   sigaddset (&sa.sa_mask, SIGALRM);
1352   sigaddset (&sa.sa_mask, SIGCHLD);
1353   sigaddset (&sa.sa_mask, SIGHUP);
1354   sa.sa_handler = retry;
1355   sigaction (SIGALRM, &sa, NULL);
1356   /* doconfig(); */
1357   config (SIGHUP);
1358   sa.sa_handler = config;
1359   sigaction (SIGHUP, &sa, NULL);
1360   sa.sa_handler = reapchild;
1361   sigaction (SIGCHLD, &sa, NULL);
1362   sa.sa_handler = goaway;
1363   sigaction (SIGTERM, &sa, NULL);
1364   sa.sa_handler = goaway;
1365   sigaction (SIGINT, &sa, NULL);
1366   sa.sa_handler = SIG_IGN;
1367   sigaction (SIGPIPE, &sa, &sapipe);
1368
1369   {
1370         /* space for daemons to overwrite environment for ps */
1371 #define DUMMYSIZE       100
1372         char dummy[DUMMYSIZE];
1373
1374         (void) memset (dummy, 'x', DUMMYSIZE - 1);
1375         dummy[DUMMYSIZE - 1] = '\0';
1376
1377         (void) setenv ("inetd_dummy", dummy, 1);
1378   }
1379
1380   for (;;) {
1381         int n, ctrl = -1;
1382         fd_set readable;
1383
1384         if (nsock == 0) {
1385           Block_Using_Signals(omask);
1386           while (nsock == 0)
1387                 sigpause (0L);
1388           sigprocmask(SIG_UNBLOCK, &omask, NULL);
1389         }
1390
1391         readable = allsock;
1392         if ((n = select (maxsock + 1, &readable, NULL, NULL, NULL)) <= 0) {
1393           if (n < 0 && errno != EINTR) {
1394                 syslog (LOG_WARNING, "select: %m");
1395                 sleep (1);
1396           }
1397           continue;
1398         }
1399         for (sep = servtab; n && sep; sep = sep->se_next)
1400           if (sep->se_fd != -1 && FD_ISSET (sep->se_fd, &readable)) {
1401                 n--;
1402                 if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
1403                   ctrl = accept (sep->se_fd, NULL, NULL);
1404                   if (ctrl < 0) {
1405                         if (errno == EINTR)
1406                           continue;
1407                         syslog (LOG_WARNING, "accept (for %s): %m", sep->se_service);
1408                         continue;
1409                   }
1410                   if (sep->se_family == AF_INET && sep->se_socktype == SOCK_STREAM) {
1411                         struct sockaddr_in peer;
1412                         socklen_t plen = sizeof (peer);
1413
1414                         if (getpeername (ctrl, (struct sockaddr *) &peer, &plen) < 0) {
1415                           syslog (LOG_WARNING, "could not getpeername");
1416                           close (ctrl);
1417                           continue;
1418                         }
1419                         if (ntohs (peer.sin_port) == 20) {
1420                           /* XXX ftp bounce */
1421                           close (ctrl);
1422                           continue;
1423                         }
1424                   }
1425                 } else
1426                   ctrl = sep->se_fd;
1427                 Block_Using_Signals(omask);
1428                 pid = 0;
1429 #ifdef INETD_FEATURE_ENABLED
1430                 if (sep->se_bi == 0 || sep->se_bi->bi_fork)
1431 #endif
1432                 {
1433                   if (sep->se_count++ == 0)
1434                         (void) gettimeofday (&sep->se_time, NULL);
1435                   else if (toomany > 0 && sep->se_count >= sep->se_max) {
1436                         struct timeval now;
1437
1438                         (void) gettimeofday (&now, NULL);
1439                         if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL) {
1440                           sep->se_time = now;
1441                           sep->se_count = 1;
1442                         } else {
1443                           if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1444                                 close (ctrl);
1445                           if (sep->se_family == AF_INET &&
1446                                   ntohs (sep->se_ctrladdr_in.sin_port) >= IPPORT_RESERVED) {
1447                                 /*
1448                                  * Cannot close it -- there are
1449                                  * thieves on the system.
1450                                  * Simply ignore the connection.
1451                                  */
1452                                 --sep->se_count;
1453                                 continue;
1454                           }
1455                           syslog (LOG_ERR,
1456                                           "%s/%s server failing (looping), service terminated",
1457                                           sep->se_service, sep->se_proto);
1458                           if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1459                                 close (ctrl);
1460                           FD_CLR (sep->se_fd, &allsock);
1461                           (void) close (sep->se_fd);
1462                           sep->se_fd = -1;
1463                           sep->se_count = 0;
1464                           nsock--;
1465                           sigprocmask(SIG_UNBLOCK, &omask, NULL);
1466                           if (!timingout) {
1467                                 timingout = 1;
1468                                 alarm (RETRYTIME);
1469                           }
1470                           continue;
1471                         }
1472                   }
1473                   pid = fork ();
1474                 }
1475                 if (pid < 0) {
1476                   syslog (LOG_ERR, "fork: %m");
1477                   if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1478                         close (ctrl);
1479                   sigprocmask(SIG_UNBLOCK, &omask, NULL);
1480                   sleep (1);
1481                   continue;
1482                 }
1483                 if (pid && sep->se_wait) {
1484                   sep->se_wait = pid;
1485                   FD_CLR (sep->se_fd, &allsock);
1486                   nsock--;
1487                 }
1488                 sigprocmask(SIG_UNBLOCK, &omask, NULL);
1489                 if (pid == 0) {
1490 #ifdef INETD_FEATURE_ENABLED
1491                   if (sep->se_bi) {
1492                         (*sep->se_bi->bi_fn) (ctrl, sep);
1493                   } else
1494 #endif
1495                         {
1496                         if ((pwd = getpwnam (sep->se_user)) == NULL) {
1497                           syslog (LOG_ERR, "getpwnam: %s: No such user", sep->se_user);
1498                           if (sep->se_socktype != SOCK_STREAM)
1499                                 recv (0, buf, sizeof (buf), 0);
1500                           _exit (1);
1501                         }
1502                         if (setsid () < 0)
1503                           syslog (LOG_ERR, "%s: setsid: %m", sep->se_service);
1504                         if (sep->se_group && (grp = getgrnam (sep->se_group)) == NULL) {
1505                           syslog (LOG_ERR, "getgrnam: %s: No such group", sep->se_group);
1506                           if (sep->se_socktype != SOCK_STREAM)
1507                                 recv (0, buf, sizeof (buf), 0);
1508                           _exit (1);
1509                         }
1510                         if (uid != 0) {
1511                           /* a user running private inetd */
1512                           if (uid != pwd->pw_uid)
1513                                 _exit (1);
1514                         } else if (pwd->pw_uid) {
1515                           if (sep->se_group) {
1516                                 pwd->pw_gid = grp->gr_gid;
1517                           }
1518                           setgid ((gid_t) pwd->pw_gid);
1519                           initgroups (pwd->pw_name, pwd->pw_gid);
1520                           setuid ((uid_t) pwd->pw_uid);
1521                         } else if (sep->se_group) {
1522                           setgid (grp->gr_gid);
1523                           setgroups (1, &grp->gr_gid);
1524                         }
1525                         dup2 (ctrl, 0);
1526                         close (ctrl);
1527                         dup2 (0, 1);
1528                         dup2 (0, 2);
1529                         if (rlim_ofile.rlim_cur != rlim_ofile_cur)
1530                           if (setrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0)
1531                                 syslog (LOG_ERR, "setrlimit: %m");
1532                         closelog ();
1533                         for (tmpint = rlim_ofile_cur - 1; --tmpint > 2;)
1534                           (void) close (tmpint);
1535                         sigaction (SIGPIPE, &sapipe, NULL);
1536                         execv (sep->se_server, sep->se_argv);
1537                         if (sep->se_socktype != SOCK_STREAM)
1538                           recv (0, buf, sizeof (buf), 0);
1539                         syslog (LOG_ERR, "execv %s: %m", sep->se_server);
1540                         _exit (1);
1541                   }
1542                 }
1543                 if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1544                   close (ctrl);
1545           }
1546   }
1547 }
1548
1549 /*
1550  * Internet services provided internally by inetd:
1551  */
1552 #define BUFSIZE 4096
1553
1554 #if defined(CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO) || \
1555     defined(CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN) || \
1556     defined(CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME)
1557 static int dg_badinput (struct sockaddr_in *dg_sin)
1558 {
1559   if (ntohs (dg_sin->sin_port) < IPPORT_RESERVED)
1560         return (1);
1561   if (dg_sin->sin_addr.s_addr == htonl (INADDR_BROADCAST))
1562         return (1);
1563   /* XXX compare against broadcast addresses in SIOCGIFCONF list? */
1564   return (0);
1565 }
1566 #endif
1567
1568 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO
1569 /* Echo service -- echo data back */
1570 /* ARGSUSED */
1571 static void
1572 echo_stream (int s, servtab_t *sep)
1573 {
1574   char buffer[BUFSIZE];
1575   int i;
1576
1577   inetd_setproctitle (sep->se_service, s);
1578   while ((i = read (s, buffer, sizeof (buffer))) > 0 &&
1579                  write (s, buffer, i) > 0);
1580   exit (0);
1581 }
1582
1583 /* Echo service -- echo data back */
1584 /* ARGSUSED */
1585 static void
1586 echo_dg (int s, servtab_t *sep __attribute__((unused)))
1587 {
1588   char buffer[BUFSIZE];
1589   int i;
1590   socklen_t size;
1591   /* struct sockaddr_storage ss; */
1592   struct sockaddr sa;
1593
1594   size = sizeof (sa);
1595   if ((i = recvfrom (s, buffer, sizeof (buffer), 0, &sa, &size)) < 0)
1596         return;
1597   if (dg_badinput ((struct sockaddr_in *) &sa))
1598         return;
1599   (void) sendto (s, buffer, i, 0, &sa, sizeof (sa));
1600 }
1601 #endif  /* CONFIG_FEATURE_INETD_SUPPORT_BILTIN_ECHO */
1602
1603 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD
1604 /* Discard service -- ignore data */
1605 /* ARGSUSED */
1606 static void
1607 discard_stream (int s, servtab_t *sep)
1608 {
1609   char buffer[BUFSIZE];
1610
1611   inetd_setproctitle (sep->se_service, s);
1612   while ((errno = 0, read (s, buffer, sizeof (buffer)) > 0) ||
1613                  errno == EINTR);
1614   exit (0);
1615 }
1616
1617 /* Discard service -- ignore data */
1618 /* ARGSUSED */
1619 static void
1620 discard_dg (int s, servtab_t *sep __attribute__((unused)))
1621 {
1622   char buffer[BUFSIZE];
1623
1624   (void) read (s, buffer, sizeof (buffer));
1625 }
1626 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DISCARD */
1627
1628
1629 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN
1630 #define LINESIZ 72
1631 static char ring[128];
1632 static char *endring;
1633
1634 static void
1635 initring (void)
1636 {
1637   int i;
1638
1639   endring = ring;
1640
1641   for (i = 0; i <= 128; ++i)
1642         if (isprint (i))
1643           *endring++ = i;
1644 }
1645
1646 /* Character generator */
1647 /* ARGSUSED */
1648 static void
1649 chargen_stream (int s, servtab_t *sep)
1650 {
1651   char *rs;
1652   int len;
1653   char text[LINESIZ + 2];
1654
1655   inetd_setproctitle (sep->se_service, s);
1656
1657   if (!endring) {
1658         initring ();
1659         rs = ring;
1660   }
1661
1662   text[LINESIZ] = '\r';
1663   text[LINESIZ + 1] = '\n';
1664   for (rs = ring;;) {
1665         if ((len = endring - rs) >= LINESIZ)
1666           memmove (text, rs, LINESIZ);
1667         else {
1668           memmove (text, rs, len);
1669           memmove (text + len, ring, LINESIZ - len);
1670         }
1671         if (++rs == endring)
1672           rs = ring;
1673         if (write (s, text, sizeof (text)) != sizeof (text))
1674           break;
1675   }
1676   exit (0);
1677 }
1678
1679 /* Character generator */
1680 /* ARGSUSED */
1681 static void
1682 chargen_dg (int s, servtab_t *sep __attribute__((unused)))
1683 {
1684   /* struct sockaddr_storage ss; */
1685   struct sockaddr sa;
1686   static char *rs;
1687   int len;
1688   char text[LINESIZ + 2];
1689   socklen_t size;
1690
1691   if (endring == 0) {
1692         initring ();
1693         rs = ring;
1694   }
1695
1696   size = sizeof (sa);
1697   if (recvfrom (s, text, sizeof (text), 0, &sa, &size) < 0)
1698         return;
1699   if (dg_badinput ((struct sockaddr_in *) &sa))
1700         return;
1701
1702   if ((len = endring - rs) >= LINESIZ)
1703         memmove (text, rs, LINESIZ);
1704   else {
1705         memmove (text, rs, len);
1706         memmove (text + len, ring, LINESIZ - len);
1707   }
1708   if (++rs == endring)
1709         rs = ring;
1710   text[LINESIZ] = '\r';
1711   text[LINESIZ + 1] = '\n';
1712   (void) sendto (s, text, sizeof (text), 0, &sa, sizeof (sa));
1713 }
1714 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BILTIN_CHARGEN */
1715
1716
1717 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME
1718 /*
1719  * Return a machine readable date and time, in the form of the
1720  * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
1721  * returns the number of seconds since midnight, Jan 1, 1970,
1722  * we must add 2208988800 seconds to this figure to make up for
1723  * some seventy years Bell Labs was asleep.
1724  */
1725
1726 static u_int machtime (void)
1727 {
1728   struct timeval tv;
1729
1730   if (gettimeofday (&tv, NULL) < 0) {
1731         fprintf (stderr, "Unable to get time of day\n");
1732         return (0L);
1733   }
1734   return (htonl ((u_int) tv.tv_sec + 2208988800UL));
1735 }
1736
1737 /* ARGSUSED */
1738 static void
1739 machtime_stream (int s, servtab_t *sep __attribute__((unused)))
1740 {
1741   u_int result;
1742
1743   result = machtime ();
1744   (void) write (s, (char *) &result, sizeof (result));
1745 }
1746
1747 /* ARGSUSED */
1748 static void
1749 machtime_dg (int s, servtab_t *sep __attribute__((unused)))
1750 {
1751   u_int result;
1752   /* struct sockaddr_storage ss; */
1753   struct sockaddr sa;
1754   struct sockaddr_in *dg_sin;
1755   socklen_t size;
1756
1757   size = sizeof (sa);
1758   if (recvfrom (s, (char *) &result, sizeof (result), 0, &sa, &size) < 0)
1759         return;
1760   /* if (dg_badinput((struct sockaddr *)&ss)) */
1761   dg_sin = (struct sockaddr_in *) &sa;
1762   if (dg_sin->sin_addr.s_addr == htonl (INADDR_BROADCAST) ||
1763           ntohs (dg_sin->sin_port) < IPPORT_RESERVED / 2)
1764         return;
1765   result = machtime ();
1766   (void) sendto (s, (char *) &result, sizeof (result), 0, &sa, sizeof (sa));
1767 }
1768 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BILTIN_TIME */
1769
1770
1771 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME
1772 /* Return human-readable time of day */
1773 /* ARGSUSED */
1774 static void daytime_stream (int s, servtab_t *sep __attribute__((unused)))
1775 {
1776   char buffer[256];
1777   time_t t;
1778
1779   t = time (NULL);
1780
1781   (void) sprintf (buffer, "%.24s\r\n", ctime (&t));
1782   (void) write (s, buffer, strlen (buffer));
1783 }
1784
1785 /* Return human-readable time of day */
1786 /* ARGSUSED */
1787 void
1788 daytime_dg (int s, servtab_t *sep __attribute__((unused)))
1789 {
1790   char buffer[256];
1791   time_t t;
1792   /* struct sockaddr_storage ss; */
1793   struct sockaddr sa;
1794   socklen_t size;
1795
1796   t = time ((time_t *) 0);
1797
1798   size = sizeof (sa);
1799   if (recvfrom (s, buffer, sizeof (buffer), 0, &sa, &size) < 0)
1800         return;
1801   if (dg_badinput ((struct sockaddr_in *) &sa))
1802         return;
1803   (void) sprintf (buffer, "%.24s\r\n", ctime (&t));
1804   (void) sendto (s, buffer, strlen (buffer), 0, &sa, sizeof (sa));
1805 }
1806 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BILTIN_DAYTIME */