networking/inetd.c

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