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   size_t n;
 912   char protoname[10];
 913
 914   if (!setconfig ()) {
 915         syslog (LOG_ERR, "%s: %m", CONFIG);
 916         return;
 917   }
 918   for (sep = servtab; sep; sep = sep->se_next)
 919         sep->se_checked = 0;
 920   cp = getconfigent ();
 921   while (cp != NULL) {
 922         for (sep = servtab; sep; sep = sep->se_next)
 923           if (matchconf (sep, cp))
 924                 break;
 925
 926         if (sep != 0) {
 927           int i;
 928
 929 #define SWAP(type, a, b) do {type c=(type)a; a=(type)b; b=(type)c;} while (0)
 930
 931           Block_Using_Signals(omask);
 932           /*
 933            * sep->se_wait may be holding the pid of a daemon
 934            * that we're waiting for.  If so, don't overwrite
 935            * it unless the config file explicitly says don't
 936            * wait.
 937            */
 938           if (
 939 #ifdef INETD_FEATURE_ENABLED
 940                    cp->se_bi == 0 &&
 941 #endif
 942                 (sep->se_wait == 1 || cp->se_wait == 0))
 943                 sep->se_wait = cp->se_wait;
 944           SWAP (int, cp->se_max, sep->se_max);
 945           SWAP (char *, sep->se_user, cp->se_user);
 946           SWAP (char *, sep->se_group, cp->se_group);
 947           SWAP (char *, sep->se_server, cp->se_server);
 948           for (i = 0; i < MAXARGV; i++)
 949                 SWAP (char *, sep->se_argv[i], cp->se_argv[i]);
 950 #undef SWAP
 951
 952 #ifdef CONFIG_FEATURE_INETD_RPC
 953           if (isrpcservice (sep))
 954                 unregister_rpc (sep);
 955           sep->se_rpcversl = cp->se_rpcversl;
 956           sep->se_rpcversh = cp->se_rpcversh;
 957 #endif
 958           sigprocmask(SIG_UNBLOCK, &omask, NULL);
 959           freeconfig (cp);
 960         } else {
 961           sep = enter (cp);
 962         }
 963         sep->se_checked = 1;
 964
 965         switch (sep->se_family) {
 966         case AF_UNIX:
 967           if (sep->se_fd != -1)
 968                 break;
 969           (void) unlink (sep->se_service);
 970           n = strlen (sep->se_service);
 971           if (n > sizeof sep->se_ctrladdr_un.sun_path - 1)
 972                 n = sizeof sep->se_ctrladdr_un.sun_path - 1;
 973           safe_strncpy (sep->se_ctrladdr_un.sun_path, sep->se_service, n + 1);
 974           sep->se_ctrladdr_un.sun_family = AF_UNIX;
 975           sep->se_ctrladdr_size = n + sizeof sep->se_ctrladdr_un.sun_family;
 976           setup (sep);
 977           break;
 978         case AF_INET:
 979           sep->se_ctrladdr_in.sin_family = AF_INET;
 980           /* se_ctrladdr_in was set in getconfigent */
 981           sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in;
 982
 983 #ifdef CONFIG_FEATURE_INETD_RPC
 984           if (isrpcservice (sep)) {
 985                 struct rpcent *rp;
 986
 987                 sep->se_rpcprog = atoi (sep->se_service);
 988                 if (sep->se_rpcprog == 0) {
 989                   rp = getrpcbyname (sep->se_service);
 990                   if (rp == 0) {
 991                         syslog (LOG_ERR, "%s: unknown rpc service", sep->se_service);
 992                         goto serv_unknown;
 993                   }
 994                   sep->se_rpcprog = rp->r_number;
 995                 }
 996                 if (sep->se_fd == -1)
 997                   setup (sep);
 998                 if (sep->se_fd != -1)
 999                   register_rpc (sep);
1000           } else
1001 #endif
1002              {
1003                 u_short port = htons (atoi (sep->se_service));
1004
1005                 if (!port) {
1006                    /*XXX*/ strncpy (protoname, sep->se_proto, sizeof (protoname));
1007                   if (isdigit (protoname[strlen (protoname) - 1]))
1008                         protoname[strlen (protoname) - 1] = '\0';
1009                   sp = getservbyname (sep->se_service, protoname);
1010                   if (sp == 0) {
1011                         syslog (LOG_ERR,
1012                                         "%s/%s: unknown service", sep->se_service, sep->se_proto);
1013                         goto serv_unknown;
1014                   }
1015                   port = sp->s_port;
1016                 }
1017                 if (port != sep->se_ctrladdr_in.sin_port) {
1018                   sep->se_ctrladdr_in.sin_port = port;
1019                   if (sep->se_fd != -1) {
1020                         FD_CLR (sep->se_fd, &allsock);
1021                         nsock--;
1022                         (void) close (sep->se_fd);
1023                   }
1024                   sep->se_fd = -1;
1025                 }
1026                 if (sep->se_fd == -1)
1027                   setup (sep);
1028           }
1029           break;
1030 #ifdef CONFIG_FEATURE_IPV6
1031         case AF_INET6:
1032           sep->se_ctrladdr_in6.sin6_family = AF_INET6;
1033           /* se_ctrladdr_in was set in getconfigent */
1034           sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in6;
1035
1036 #ifdef CONFIG_FEATURE_INETD_RPC
1037           if (isrpcservice (sep)) {
1038                 struct rpcent *rp;
1039
1040                 sep->se_rpcprog = atoi (sep->se_service);
1041                 if (sep->se_rpcprog == 0) {
1042                   rp = getrpcbyname (sep->se_service);
1043                   if (rp == 0) {
1044                         syslog (LOG_ERR, "%s: unknown rpc service", sep->se_service);
1045                         goto serv_unknown;
1046                   }
1047                   sep->se_rpcprog = rp->r_number;
1048                 }
1049                 if (sep->se_fd == -1)
1050                   setup (sep);
1051                 if (sep->se_fd != -1)
1052                   register_rpc (sep);
1053           } else
1054 #endif
1055                 {
1056                 u_short port = htons (atoi (sep->se_service));
1057
1058                 if (!port) {
1059                    /*XXX*/ strncpy (protoname, sep->se_proto, sizeof (protoname));
1060                   if (isdigit (protoname[strlen (protoname) - 1]))
1061                         protoname[strlen (protoname) - 1] = '\0';
1062                   sp = getservbyname (sep->se_service, protoname);
1063                   if (sp == 0) {
1064                         syslog (LOG_ERR,
1065                                         "%s/%s: unknown service", sep->se_service, sep->se_proto);
1066                         goto serv_unknown;
1067                   }
1068                   port = sp->s_port;
1069                 }
1070                 if (port != sep->se_ctrladdr_in6.sin6_port) {
1071                   sep->se_ctrladdr_in6.sin6_port = port;
1072                   if (sep->se_fd != -1) {
1073                         FD_CLR (sep->se_fd, &allsock);
1074                         nsock--;
1075                         (void) close (sep->se_fd);
1076                   }
1077                   sep->se_fd = -1;
1078                 }
1079                 if (sep->se_fd == -1)
1080                   setup (sep);
1081           }
1082           break;
1083 #endif /* CONFIG_FEATURE_IPV6 */
1084         }
1085   serv_unknown:
1086         if (cp->se_next != NULL) {
1087           servtab_t *tmp = cp;
1088
1089           cp = cp->se_next;
1090           free (tmp);
1091         } else {
1092           free (cp);
1093           cp = getconfigent ();
1094         }
1095   }
1096   endconfig ();
1097   /*
1098    * Purge anything not looked at above.
1099    */
1100   Block_Using_Signals(omask);
1101   sepp = &servtab;
1102   while ((sep = *sepp)) {
1103         if (sep->se_checked) {
1104           sepp = &sep->se_next;
1105           continue;
1106         }
1107         *sepp = sep->se_next;
1108         if (sep->se_fd != -1) {
1109           FD_CLR (sep->se_fd, &allsock);
1110           nsock--;
1111           (void) close (sep->se_fd);
1112         }
1113 #ifdef CONFIG_FEATURE_INETD_RPC
1114         if (isrpcservice (sep))
1115           unregister_rpc (sep);
1116 #endif
1117         if (sep->se_family == AF_UNIX)
1118           (void) unlink (sep->se_service);
1119         freeconfig (sep);
1120         free (sep);
1121   }
1122   sigprocmask(SIG_UNBLOCK, &omask, NULL);
1123 }
1124
1125
1126 static void reapchild (int sig ATTRIBUTE_UNUSED)
1127 {
1128   pid_t pid;
1129   int save_errno = errno, status;
1130   servtab_t *sep;
1131
1132   for (;;) {
1133         pid = wait3 (&status, WNOHANG, NULL);
1134         if (pid <= 0)
1135           break;
1136         for (sep = servtab; sep; sep = sep->se_next)
1137           if (sep->se_wait == pid) {
1138                 if (WIFEXITED (status) && WEXITSTATUS (status))
1139                   syslog (LOG_WARNING,
1140                                   "%s: exit status 0x%x",
1141                                   sep->se_server, WEXITSTATUS (status));
1142                 else if (WIFSIGNALED (status))
1143                   syslog (LOG_WARNING,
1144                                   "%s: exit signal 0x%x", sep->se_server, WTERMSIG (status));
1145                 sep->se_wait = 1;
1146                 FD_SET (sep->se_fd, &allsock);
1147                 nsock++;
1148           }
1149   }
1150   errno = save_errno;
1151 }
1152
1153 static void retry (int sig ATTRIBUTE_UNUSED)
1154 {
1155   servtab_t *sep;
1156
1157   timingout = 0;
1158   for (sep = servtab; sep; sep = sep->se_next) {
1159         if (sep->se_fd == -1) {
1160           switch (sep->se_family) {
1161           case AF_UNIX:
1162           case AF_INET:
1163 #ifdef CONFIG_FEATURE_IPV6
1164           case AF_INET6:
1165 #endif
1166                 setup (sep);
1167 #ifdef CONFIG_FEATURE_INETD_RPC
1168                 if (sep->se_fd != -1 && isrpcservice (sep))
1169                   register_rpc (sep);
1170 #endif
1171                 break;
1172           }
1173         }
1174   }
1175 }
1176
1177 static void goaway (int sig ATTRIBUTE_UNUSED)
1178 {
1179   servtab_t *sep;
1180
1181   /* XXX signal race walking sep list */
1182   for (sep = servtab; sep; sep = sep->se_next) {
1183         if (sep->se_fd == -1)
1184           continue;
1185
1186         switch (sep->se_family) {
1187         case AF_UNIX:
1188           (void) unlink (sep->se_service);
1189           break;
1190         case AF_INET:
1191 #ifdef CONFIG_FEATURE_IPV6
1192         case AF_INET6:
1193 #endif
1194 #ifdef CONFIG_FEATURE_INETD_RPC
1195           if (sep->se_wait == 1 && isrpcservice (sep))
1196                 unregister_rpc (sep);   /* XXX signal race */
1197 #endif
1198           break;
1199         }
1200         (void) close (sep->se_fd);
1201   }
1202   (void) unlink (_PATH_INETDPID);
1203   exit (0);
1204 }
1205
1206
1207 #ifdef INETD_SETPROCTITLE
1208 static char **Argv;
1209 static char *LastArg;
1210
1211 static void
1212 inetd_setproctitle (char *a, int s)
1213 {
1214   socklen_t size;
1215   char *cp;
1216   struct sockaddr_in prt_sin;
1217   char buf[80];
1218
1219   cp = Argv[0];
1220   size = sizeof (prt_sin);
1221   (void) snprintf (buf, sizeof buf, "-%s", a);
1222   if (getpeername (s, (struct sockaddr *) &prt_sin, &size) == 0) {
1223         char *sa = inet_ntoa (prt_sin.sin_addr);
1224
1225         buf[sizeof (buf) - 1 - strlen (sa) - 3] = '\0';
1226         strcat (buf, " [");
1227         strcat (buf, sa);
1228         strcat (buf, "]");
1229   }
1230   strncpy (cp, buf, LastArg - cp);
1231   cp += strlen (cp);
1232   while (cp < LastArg)
1233         *cp++ = ' ';
1234 }
1235 #endif
1236
1237
1238 int
1239 inetd_main (int argc, char *argv[])
1240 {
1241   servtab_t *sep;
1242   struct passwd *pwd;
1243   struct group *grp = NULL;
1244   int tmpint;
1245   struct sigaction sa, sapipe;
1246   int opt;
1247   pid_t pid;
1248   char buf[50];
1249   char *stoomany;
1250   sigset_t omask, wait_mask;
1251
1252 #ifdef INETD_SETPROCTITLE
1253   extern char **environ;
1254   char **envp = environ;
1255
1256   Argv = argv;
1257   if (envp == 0 || *envp == 0)
1258         envp = argv;
1259   while (*envp)
1260         envp++;
1261   LastArg = envp[-1] + strlen (envp[-1]);
1262 #endif
1263
1264   openlog (bb_applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
1265
1266   opt = bb_getopt_ulflags (argc, argv, "R:f", &stoomany);
1267   if(opt & 1) {
1268         char *e;
1269
1270         toomany = strtoul (stoomany, &e, 0);
1271         if (!(toomany >= 0 && *e == '\0')) {
1272                 toomany = TOOMANY;
1273                 syslog (LOG_ERR, "-R %s: bad value for service invocation rate", stoomany);
1274         }
1275   }
1276   argc -= optind;
1277   argv += optind;
1278
1279   uid = getuid ();
1280   if (uid != 0)
1281         CONFIG = NULL;
1282   if (argc > 0)
1283         CONFIG = argv[0];
1284   if (CONFIG == NULL)
1285         bb_error_msg_and_die ("non-root must specify a config file");
1286
1287   if (!(opt & 2)) {
1288 #ifdef BB_NOMMU
1289         /* reexec for vfork() do continue parent */
1290         vfork_daemon_rexec (0, 0, argc, argv, "-f");
1291 #else
1292         xdaemon (0, 0);
1293 #endif
1294   } else {
1295         setsid ();
1296   }
1297
1298   if (uid == 0) {
1299         gid_t gid = getgid ();
1300
1301         /* If run by hand, ensure groups vector gets trashed */
1302         setgroups (1, &gid);
1303   }
1304
1305   {
1306         FILE *fp;
1307
1308         if ((fp = fopen (_PATH_INETDPID, "w")) != NULL) {
1309                 fprintf (fp, "%u\n", getpid ());
1310                 (void) fclose (fp);
1311         }
1312   }
1313
1314   if (getrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0) {
1315         syslog (LOG_ERR, "getrlimit: %m");
1316   } else {
1317         rlim_ofile_cur = rlim_ofile.rlim_cur;
1318         if (rlim_ofile_cur == RLIM_INFINITY)    /* ! */
1319           rlim_ofile_cur = OPEN_MAX;
1320   }
1321
1322   memset ((char *) &sa, 0, sizeof (sa));
1323   sigemptyset (&sa.sa_mask);
1324   sigaddset (&sa.sa_mask, SIGALRM);
1325   sigaddset (&sa.sa_mask, SIGCHLD);
1326   sigaddset (&sa.sa_mask, SIGHUP);
1327   sa.sa_handler = retry;
1328   sigaction (SIGALRM, &sa, NULL);
1329   /* doconfig(); */
1330   config (SIGHUP);
1331   sa.sa_handler = config;
1332   sigaction (SIGHUP, &sa, NULL);
1333   sa.sa_handler = reapchild;
1334   sigaction (SIGCHLD, &sa, NULL);
1335   sa.sa_handler = goaway;
1336   sigaction (SIGTERM, &sa, NULL);
1337   sa.sa_handler = goaway;
1338   sigaction (SIGINT, &sa, NULL);
1339   sa.sa_handler = SIG_IGN;
1340   sigaction (SIGPIPE, &sa, &sapipe);
1341   memset(&wait_mask, 0, sizeof(wait_mask));
1342   {
1343         /* space for daemons to overwrite environment for ps */
1344 #define DUMMYSIZE       100
1345         char dummy[DUMMYSIZE];
1346
1347         (void) memset (dummy, 'x', DUMMYSIZE - 1);
1348         dummy[DUMMYSIZE - 1] = '\0';
1349
1350         (void) setenv ("inetd_dummy", dummy, 1);
1351   }
1352
1353   for (;;) {
1354         int n, ctrl = -1;
1355         fd_set readable;
1356
1357         if (nsock == 0) {
1358           Block_Using_Signals(omask);
1359           while (nsock == 0)
1360                 sigsuspend (&wait_mask);
1361           sigprocmask(SIG_UNBLOCK, &omask, NULL);
1362         }
1363
1364         readable = allsock;
1365         if ((n = select (maxsock + 1, &readable, NULL, NULL, NULL)) <= 0) {
1366           if (n < 0 && errno != EINTR) {
1367                 syslog (LOG_WARNING, "select: %m");
1368                 sleep (1);
1369           }
1370           continue;
1371         }
1372         for (sep = servtab; n && sep; sep = sep->se_next)
1373           if (sep->se_fd != -1 && FD_ISSET (sep->se_fd, &readable)) {
1374                 n--;
1375                 if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
1376                   ctrl = accept (sep->se_fd, NULL, NULL);
1377                   if (ctrl < 0) {
1378                         if (errno == EINTR)
1379                           continue;
1380                         syslog (LOG_WARNING, "accept (for %s): %m", sep->se_service);
1381                         continue;
1382                   }
1383                   if (sep->se_family == AF_INET && sep->se_socktype == SOCK_STREAM) {
1384                         struct sockaddr_in peer;
1385                         socklen_t plen = sizeof (peer);
1386
1387                         if (getpeername (ctrl, (struct sockaddr *) &peer, &plen) < 0) {
1388                           syslog (LOG_WARNING, "could not getpeername");
1389                           close (ctrl);
1390                           continue;
1391                         }
1392                         if (ntohs (peer.sin_port) == 20) {
1393                           /* XXX ftp bounce */
1394                           close (ctrl);
1395                           continue;
1396                         }
1397                   }
1398                 } else
1399                   ctrl = sep->se_fd;
1400                 Block_Using_Signals(omask);
1401                 pid = 0;
1402 #ifdef INETD_FEATURE_ENABLED
1403                 if (sep->se_bi == 0 || sep->se_bi->bi_fork)
1404 #endif
1405                 {
1406                   if (sep->se_count++ == 0)
1407                         (void) gettimeofday (&sep->se_time, NULL);
1408                   else if (toomany > 0 && sep->se_count >= sep->se_max) {
1409                         struct timeval now;
1410
1411                         (void) gettimeofday (&now, NULL);
1412                         if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL) {
1413                           sep->se_time = now;
1414                           sep->se_count = 1;
1415                         } else {
1416                           if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1417                                 close (ctrl);
1418                           if (sep->se_family == AF_INET &&
1419                                   ntohs (sep->se_ctrladdr_in.sin_port) >= IPPORT_RESERVED) {
1420                                 /*
1421                                  * Cannot close it -- there are
1422                                  * thieves on the system.
1423                                  * Simply ignore the connection.
1424                                  */
1425                                 --sep->se_count;
1426                                 continue;
1427                           }
1428                           syslog (LOG_ERR,
1429                                           "%s/%s server failing (looping), service terminated",
1430                                           sep->se_service, sep->se_proto);
1431                           if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1432                                 close (ctrl);
1433                           FD_CLR (sep->se_fd, &allsock);
1434                           (void) close (sep->se_fd);
1435                           sep->se_fd = -1;
1436                           sep->se_count = 0;
1437                           nsock--;
1438                           sigprocmask(SIG_UNBLOCK, &omask, NULL);
1439                           if (!timingout) {
1440                                 timingout = 1;
1441                                 alarm (RETRYTIME);
1442                           }
1443                           continue;
1444                         }
1445                   }
1446                   pid = fork ();
1447                 }
1448                 if (pid < 0) {
1449                   syslog (LOG_ERR, "fork: %m");
1450                   if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1451                         close (ctrl);
1452                   sigprocmask(SIG_UNBLOCK, &omask, NULL);
1453                   sleep (1);
1454                   continue;
1455                 }
1456                 if (pid && sep->se_wait) {
1457                   sep->se_wait = pid;
1458                   FD_CLR (sep->se_fd, &allsock);
1459                   nsock--;
1460                 }
1461                 sigprocmask(SIG_UNBLOCK, &omask, NULL);
1462                 if (pid == 0) {
1463 #ifdef INETD_FEATURE_ENABLED
1464                   if (sep->se_bi) {
1465                         (*sep->se_bi->bi_fn) (ctrl, sep);
1466                   } else
1467 #endif
1468                         {
1469                         if ((pwd = getpwnam (sep->se_user)) == NULL) {
1470                           syslog (LOG_ERR, "getpwnam: %s: No such user", sep->se_user);
1471                           if (sep->se_socktype != SOCK_STREAM)
1472                                 recv (0, buf, sizeof (buf), 0);
1473                           _exit (1);
1474                         }
1475                         if (setsid () < 0)
1476                           syslog (LOG_ERR, "%s: setsid: %m", sep->se_service);
1477                         if (sep->se_group && (grp = getgrnam (sep->se_group)) == NULL) {
1478                           syslog (LOG_ERR, "getgrnam: %s: No such group", sep->se_group);
1479                           if (sep->se_socktype != SOCK_STREAM)
1480                                 recv (0, buf, sizeof (buf), 0);
1481                           _exit (1);
1482                         }
1483                         if (uid != 0) {
1484                           /* a user running private inetd */
1485                           if (uid != pwd->pw_uid)
1486                                 _exit (1);
1487                         } else if (pwd->pw_uid) {
1488                           if (sep->se_group) {
1489                                 pwd->pw_gid = grp->gr_gid;
1490                           }
1491                           xsetgid ((gid_t) pwd->pw_gid);
1492                           initgroups (pwd->pw_name, pwd->pw_gid);
1493                           xsetuid((uid_t) pwd->pw_uid);
1494                         } else if (sep->se_group) {
1495                           xsetgid(grp->gr_gid);
1496                           setgroups (1, &grp->gr_gid);
1497                         }
1498                         dup2 (ctrl, 0);
1499                         close (ctrl);
1500                         dup2 (0, 1);
1501                         dup2 (0, 2);
1502                         if (rlim_ofile.rlim_cur != rlim_ofile_cur)
1503                           if (setrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0)
1504                                 syslog (LOG_ERR, "setrlimit: %m");
1505                         closelog ();
1506                         for (tmpint = rlim_ofile_cur - 1; --tmpint > 2;)
1507                           (void) close (tmpint);
1508                         sigaction (SIGPIPE, &sapipe, NULL);
1509                         execv (sep->se_server, sep->se_argv);
1510                         if (sep->se_socktype != SOCK_STREAM)
1511                           recv (0, buf, sizeof (buf), 0);
1512                         syslog (LOG_ERR, "execv %s: %m", sep->se_server);
1513                         _exit (1);
1514                   }
1515                 }
1516                 if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
1517                   close (ctrl);
1518           }
1519   }
1520 }
1521
1522 /*
1523  * Internet services provided internally by inetd:
1524  */
1525 #define BUFSIZE 4096
1526
1527 #if defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO) || \
1528     defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN) || \
1529     defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME)
1530 static int dg_badinput (struct sockaddr_in *dg_sin)
1531 {
1532   if (ntohs (dg_sin->sin_port) < IPPORT_RESERVED)
1533         return (1);
1534   if (dg_sin->sin_addr.s_addr == htonl (INADDR_BROADCAST))
1535         return (1);
1536   /* XXX compare against broadcast addresses in SIOCGIFCONF list? */
1537   return (0);
1538 }
1539 #endif
1540
1541 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
1542 /* Echo service -- echo data back */
1543 /* ARGSUSED */
1544 static void
1545 echo_stream (int s, servtab_t *sep)
1546 {
1547   char buffer[BUFSIZE];
1548   int i;
1549
1550   inetd_setproctitle (sep->se_service, s);
1551   while ((i = read (s, buffer, sizeof (buffer))) > 0 &&
1552                  write (s, buffer, i) > 0);
1553   exit (0);
1554 }
1555
1556 /* Echo service -- echo data back */
1557 /* ARGSUSED */
1558 static void
1559 echo_dg (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1560 {
1561   char buffer[BUFSIZE];
1562   int i;
1563   socklen_t size;
1564   /* struct sockaddr_storage ss; */
1565   struct sockaddr sa;
1566
1567   size = sizeof (sa);
1568   if ((i = recvfrom (s, buffer, sizeof (buffer), 0, &sa, &size)) < 0)
1569         return;
1570   if (dg_badinput ((struct sockaddr_in *) &sa))
1571         return;
1572   (void) sendto (s, buffer, i, 0, &sa, sizeof (sa));
1573 }
1574 #endif  /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO */
1575
1576 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
1577 /* Discard service -- ignore data */
1578 /* ARGSUSED */
1579 static void
1580 discard_stream (int s, servtab_t *sep)
1581 {
1582   char buffer[BUFSIZE];
1583
1584   inetd_setproctitle (sep->se_service, s);
1585   while ((errno = 0, read (s, buffer, sizeof (buffer)) > 0) ||
1586                  errno == EINTR);
1587   exit (0);
1588 }
1589
1590 /* Discard service -- ignore data */
1591 /* ARGSUSED */
1592 static void
1593 discard_dg (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1594 {
1595   char buffer[BUFSIZE];
1596
1597   (void) read (s, buffer, sizeof (buffer));
1598 }
1599 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */
1600
1601
1602 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
1603 #define LINESIZ 72
1604 static char ring[128];
1605 static char *endring;
1606
1607 static void
1608 initring (void)
1609 {
1610   int i;
1611
1612   endring = ring;
1613
1614   for (i = 0; i <= 128; ++i)
1615         if (isprint (i))
1616           *endring++ = i;
1617 }
1618
1619 /* Character generator */
1620 /* ARGSUSED */
1621 static void
1622 chargen_stream (int s, servtab_t *sep)
1623 {
1624   char *rs;
1625   int len;
1626   char text[LINESIZ + 2];
1627
1628   inetd_setproctitle (sep->se_service, s);
1629
1630   if (!endring) {
1631         initring ();
1632         rs = ring;
1633   }
1634
1635   text[LINESIZ] = '\r';
1636   text[LINESIZ + 1] = '\n';
1637   for (rs = ring;;) {
1638         if ((len = endring - rs) >= LINESIZ)
1639           memmove (text, rs, LINESIZ);
1640         else {
1641           memmove (text, rs, len);
1642           memmove (text + len, ring, LINESIZ - len);
1643         }
1644         if (++rs == endring)
1645           rs = ring;
1646         if (write (s, text, sizeof (text)) != sizeof (text))
1647           break;
1648   }
1649   exit (0);
1650 }
1651
1652 /* Character generator */
1653 /* ARGSUSED */
1654 static void
1655 chargen_dg (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1656 {
1657   /* struct sockaddr_storage ss; */
1658   struct sockaddr sa;
1659   static char *rs;
1660   int len;
1661   char text[LINESIZ + 2];
1662   socklen_t size;
1663
1664   if (endring == 0) {
1665         initring ();
1666         rs = ring;
1667   }
1668
1669   size = sizeof (sa);
1670   if (recvfrom (s, text, sizeof (text), 0, &sa, &size) < 0)
1671         return;
1672   if (dg_badinput ((struct sockaddr_in *) &sa))
1673         return;
1674
1675   if ((len = endring - rs) >= LINESIZ)
1676         memmove (text, rs, LINESIZ);
1677   else {
1678         memmove (text, rs, len);
1679         memmove (text + len, ring, LINESIZ - len);
1680   }
1681   if (++rs == endring)
1682         rs = ring;
1683   text[LINESIZ] = '\r';
1684   text[LINESIZ + 1] = '\n';
1685   (void) sendto (s, text, sizeof (text), 0, &sa, sizeof (sa));
1686 }
1687 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */
1688
1689
1690 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
1691 /*
1692  * Return a machine readable date and time, in the form of the
1693  * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
1694  * returns the number of seconds since midnight, Jan 1, 1970,
1695  * we must add 2208988800 seconds to this figure to make up for
1696  * some seventy years Bell Labs was asleep.
1697  */
1698
1699 static u_int machtime (void)
1700 {
1701   struct timeval tv;
1702
1703   if (gettimeofday (&tv, NULL) < 0) {
1704         fprintf (stderr, "Unable to get time of day\n");
1705         return (0L);
1706   }
1707   return (htonl ((u_int) tv.tv_sec + 2208988800UL));
1708 }
1709
1710 /* ARGSUSED */
1711 static void
1712 machtime_stream (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1713 {
1714   u_int result;
1715
1716   result = machtime ();
1717   (void) write (s, (char *) &result, sizeof (result));
1718 }
1719
1720 /* ARGSUSED */
1721 static void
1722 machtime_dg (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1723 {
1724   u_int result;
1725   /* struct sockaddr_storage ss; */
1726   struct sockaddr sa;
1727   struct sockaddr_in *dg_sin;
1728   socklen_t size;
1729
1730   size = sizeof (sa);
1731   if (recvfrom (s, (char *) &result, sizeof (result), 0, &sa, &size) < 0)
1732         return;
1733   /* if (dg_badinput((struct sockaddr *)&ss)) */
1734   dg_sin = (struct sockaddr_in *) &sa;
1735   if (dg_sin->sin_addr.s_addr == htonl (INADDR_BROADCAST) ||
1736           ntohs (dg_sin->sin_port) < IPPORT_RESERVED / 2)
1737         return;
1738   result = machtime ();
1739   (void) sendto (s, (char *) &result, sizeof (result), 0, &sa, sizeof (sa));
1740 }
1741 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME */
1742
1743
1744 #ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
1745 /* Return human-readable time of day */
1746 /* ARGSUSED */
1747 static void daytime_stream (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1748 {
1749   char buffer[256];
1750   time_t t;
1751
1752   t = time (NULL);
1753
1754   (void) sprintf (buffer, "%.24s\r\n", ctime (&t));
1755   (void) write (s, buffer, strlen (buffer));
1756 }
1757
1758 /* Return human-readable time of day */
1759 /* ARGSUSED */
1760 void
1761 daytime_dg (int s, servtab_t *sep ATTRIBUTE_UNUSED)
1762 {
1763   char buffer[256];
1764   time_t t;
1765   /* struct sockaddr_storage ss; */
1766   struct sockaddr sa;
1767   socklen_t size;
1768
1769   t = time ((time_t *) 0);
1770
1771   size = sizeof (sa);
1772   if (recvfrom (s, buffer, sizeof (buffer), 0, &sa, &size) < 0)
1773         return;
1774   if (dg_badinput ((struct sockaddr_in *) &sa))
1775         return;
1776   (void) sprintf (buffer, "%.24s\r\n", ctime (&t));
1777   (void) sendto (s, buffer, strlen (buffer), 0, &sa, sizeof (sa));
1778 }
1779 #endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */