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