networking/inetd.c

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