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