home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume26 / munetd / munetd.c < prev    next >
C/C++ Source or Header  |  1992-05-08  |  28KB  |  1,214 lines
  1. /*
  2.  * @(#)munetd.c    1.10 92/01/17    - pseudo tty server a la inetd
  3.  *          based on BSD 4.4 inetd.c
  4.  */
  5. /*
  6.  * Copyright (c) 1983 Regents of the University of California.
  7.  * All rights reserved.
  8.  *
  9.  * Redistribution and use in source and binary forms are permitted provided
  10.  * that: (1) source distributions retain this entire copyright notice and
  11.  * comment, and (2) distributions including binaries display the following
  12.  * acknowledgement:  ``This product includes software developed by the
  13.  * University of California, Berkeley and its contributors'' in the
  14.  * documentation or other materials provided with the distribution and in
  15.  * all advertising materials mentioning features or use of this software.
  16.  * Neither the name of the University nor the names of its contributors may
  17.  * be used to endorse or promote products derived from this software without
  18.  * specific prior written permission.
  19.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  20.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  21.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22.  */
  23.  
  24. #ifndef lint
  25. char copyright[] =
  26. "@(#) Copyright (c) 1983 Regents of the University of California.\n\
  27.  All rights reserved.\n";
  28. #endif /* not lint */
  29.  
  30. #ifndef lint
  31. static char bsdsccsid[] = "@(#)inetd.c     5.25 (Berkeley) 6/29/90";
  32. static char sccsid[] = "@(#)munetd.c    1.10 (Erasmus) 1/17/92";
  33. #endif /* not lint */
  34.  
  35. /*
  36.  * Inetd - Internet super-server
  37.  *
  38.  * This program invokes all internet services as needed.
  39.  * connection-oriented services are invoked each time a
  40.  * connection is made, by creating a process.  This process
  41.  * is passed the connection as file descriptor 0 and is
  42.  * expected to do a getpeername to find out the source host
  43.  * and port.
  44.  *
  45.  * Datagram oriented services are invoked when a datagram
  46.  * arrives; a process is created and passed a pending message
  47.  * on file descriptor 0.  Datagram servers may either connect
  48.  * to their peer, freeing up the original socket for inetd
  49.  * to receive further messages on, or ``take over the socket'',
  50.  * processing all arriving datagrams and, eventually, timing
  51.  * out.     The first type of server is said to be ``multi-threaded'';
  52.  * the second type of server ``single-threaded''. 
  53.  *
  54.  * Inetd uses a configuration file which is read at startup
  55.  * and, possibly, at some later time in response to a hangup signal.
  56.  * The configuration file is ``free format'' with fields given in the
  57.  * order shown below.  Continuation lines for an entry must being with
  58.  * a space or tab.  All fields must be present in each entry.
  59.  *
  60.  *    service name            must be in /etc/services
  61.  *    socket type            stream/dgram/raw/rdm/seqpacket
  62.  *    protocol            must be in /etc/protocols
  63.  *    wait/nowait            single-threaded/multi-threaded
  64.  *    user                user to run daemon as
  65.  *    server program            full path name
  66.  *    server program arguments    maximum of MAXARGS (20)
  67.  *
  68.  * Comment lines are indicated by a `#' in column 1.
  69.  */
  70. #include <sys/param.h>
  71. #include <sys/stat.h>
  72. #include <sys/ioctl.h>
  73. #include <sys/socket.h>
  74. #include <sys/un.h>
  75. #include <sys/file.h>
  76. #include <sys/wait.h>
  77. #include <sys/time.h>
  78. #include <sys/resource.h>
  79.  
  80. #include <netinet/in.h>
  81. #include <arpa/inet.h>
  82.  
  83. #include <errno.h>
  84. #include <signal.h>
  85. #include <netdb.h>
  86. #include <syslog.h>
  87. #include <pwd.h>
  88. #include <stdio.h>
  89. #include <string.h>
  90. #if 0
  91. #include "pathnames.h"
  92. #endif
  93.  
  94. #define    TOOMANY        40        /* don't start more than TOOMANY */
  95. #define    CNT_INTVL    60        /* servers in CNT_INTVL sec. */
  96. #define    RETRYTIME    (60*10)        /* retry after bind or server fail */
  97.  
  98. #define    SIGBLOCK    (sigmask(SIGCHLD)|sigmask(SIGHUP)|sigmask(SIGALRM))
  99.  
  100. extern    int errno;
  101.  
  102. void    config(), reapchild(), retry();
  103. char    *index();
  104. char    *malloc();
  105.  
  106. int    debug = 0;
  107. int    nsock, maxsock;
  108. fd_set    allsock;
  109. fd_set    allpty;
  110. int    options;
  111. int    timingout;
  112. struct    servent *sp;
  113.  
  114. struct    servtab {
  115.     char    *se_service;        /* name of service */
  116.     int    se_socktype;        /* type of socket to use */
  117.     int    se_family;        /* address family */
  118. #define AF_PTY    0xf0000000
  119. #define isrealsock(sep)    ((sep)->se_family == AF_INET || \
  120.             (sep)->se_family == AF_UNIX)
  121.     char    *se_proto;        /* protocol used */
  122.     int    se_rpcprog;        /* rpc program number */
  123.     int    se_rpcversl;        /* rpc program lowest version */
  124.     int    se_rpcversh;        /* rpc program highest version */
  125. #define isrpcservice(sep)    ((sep)->se_rpcversl != 0)
  126.     short    se_wait;        /* single threaded server */
  127.     short    se_checked;        /* looked at during merge */
  128.     char    *se_user;        /* user name to run as */
  129.     struct    biltin *se_bi;        /* if built-in, description */
  130.     char    *se_server;        /* server program */
  131. #define    MAXARGV 20
  132.     char    *se_argv[MAXARGV+1];    /* program arguments */
  133.     int    se_fd;            /* open descriptor */
  134.     union {
  135.         struct    sockaddr se_un_ctrladdr;
  136.         struct    sockaddr_in se_un_ctrladdr_in;
  137.         struct    sockaddr_un se_un_ctrladdr_un;
  138.     } se_un;            /* bound address */
  139. #define se_ctrladdr    se_un.se_un_ctrladdr
  140. #define se_ctrladdr_in    se_un.se_un_ctrladdr_in
  141. #define se_ctrladdr_un    se_un.se_un_ctrladdr_un
  142.     int    se_ctrladdr_size;
  143.     int    se_count;        /* number started since se_time */
  144.     struct    timeval se_time;    /* start of se_count */
  145.     struct    servtab *se_next;
  146. } *servtab;
  147.  
  148. int echo_stream(), discard_stream(), machtime_stream();
  149. int daytime_stream(), chargen_stream();
  150. int echo_dg(), discard_dg(), machtime_dg(), daytime_dg(), chargen_dg();
  151.  
  152. struct biltin {
  153.     char    *bi_service;        /* internally provided service name */
  154.     int    bi_socktype;        /* type of socket supported */
  155.     short    bi_fork;        /* 1 if should fork before call */
  156.     short    bi_wait;        /* 1 if should wait for child */
  157.     int    (*bi_fn)();        /* function which performs it */
  158. } biltins[] = {
  159.     /* Echo received data */
  160.     "echo",        SOCK_STREAM,    1, 0,    echo_stream,
  161.     "echo",        SOCK_DGRAM,    0, 0,    echo_dg,
  162.  
  163.     /* Internet /dev/null */
  164.     "discard",    SOCK_STREAM,    1, 0,    discard_stream,
  165.     "discard",    SOCK_DGRAM,    0, 0,    discard_dg,
  166.  
  167.     /* Return 32 bit time since 1900 */
  168.     "time",        SOCK_STREAM,    0, 0,    machtime_stream,
  169.     "time",        SOCK_DGRAM,    0, 0,    machtime_dg,
  170.  
  171.     /* Return human-readable time */
  172.     "daytime",    SOCK_STREAM,    0, 0,    daytime_stream,
  173.     "daytime",    SOCK_DGRAM,    0, 0,    daytime_dg,
  174.  
  175.     /* Familiar character generator */
  176.     "chargen",    SOCK_STREAM,    1, 0,    chargen_stream,
  177.     "chargen",    SOCK_DGRAM,    0, 0,    chargen_dg,
  178.     0
  179. };
  180.  
  181. #define NUMINT    (sizeof(intab) / sizeof(struct inent))
  182. #ifdef _PATH_INETDCONF
  183. char    *CONFIG = _PATH_INETDCONF;
  184. #else
  185. char    *CONFIG = "/etc/inetd.conf";
  186. #endif
  187. #ifdef _PATH_INETDPID
  188. char    *PIDFILE = _PATH_INETDPID;
  189. #else
  190. char    *PIDFILE = "/etc/inetd.pid";
  191. #endif
  192. char    **Argv;
  193. char     *LastArg;
  194.  
  195. main(argc, argv, envp)
  196.     int argc;
  197.     char *argv[], *envp[];
  198. {
  199.     extern char *optarg;
  200.     extern int optind;
  201.     register struct servtab *sep;
  202.     register struct passwd *pwd;
  203.     register int tmpint;
  204.     struct sigvec sv;
  205.     int ch, pid, dofork;
  206.     char buf[50];
  207.  
  208.     Argv = argv;
  209.     if (envp == 0 || *envp == 0)
  210.         envp = argv;
  211.     while (*envp)
  212.         envp++;
  213.     LastArg = envp[-1] + strlen(envp[-1]);
  214.  
  215.     while ((ch = getopt(argc, argv, "d")) != EOF)
  216.         switch(ch) {
  217.         case 'd':
  218.             debug = 1;
  219.             options |= SO_DEBUG;
  220.             break;
  221.         case '?':
  222.         default:
  223.             fprintf(stderr, "usage: munetd [-d]");
  224.             exit(1);
  225.         }
  226.     argc -= optind;
  227.     argv += optind;
  228.  
  229.     if (argc > 0)
  230.         CONFIG = argv[0];
  231. #ifdef sun
  232.     bump_nofile();
  233. #endif
  234.     if (debug == 0)
  235.         daemon(0, 0);
  236.     openlog("munetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
  237.     logpid();
  238.     bzero((char *)&sv, sizeof(sv));
  239.     sv.sv_mask = SIGBLOCK;
  240.     sv.sv_handler = retry;
  241.     sigvec(SIGALRM, &sv, (struct sigvec *)0);
  242.     config();
  243.     sv.sv_handler = config;
  244.     sigvec(SIGHUP, &sv, (struct sigvec *)0);
  245.     sv.sv_handler = reapchild;
  246.     sigvec(SIGCHLD, &sv, (struct sigvec *)0);
  247.  
  248.     {
  249.         /* space for daemons to overwrite environment for ps */
  250. #define    DUMMYSIZE    100
  251.         char dummy[DUMMYSIZE];
  252.  
  253.         (void)memset(dummy, 'x', DUMMYSIZE - 1);
  254.         dummy[DUMMYSIZE - 1] = '\0';
  255.  
  256.         (void)setenv("inetd_dummy", dummy, 1);
  257.     }
  258.  
  259.     for (;;) {
  260.         int n, ctrl;
  261.         fd_set readable, writable;
  262.  
  263.         if (nsock == 0) {
  264.         (void) sigblock(SIGBLOCK);
  265.         while (nsock == 0)
  266.             sigpause(0L);
  267.         (void) sigsetmask(0L);
  268.         }
  269.         readable = allsock;
  270.         writable = allpty;
  271.         if ((n = select(maxsock + 1, &readable, &writable,
  272.         (fd_set *)0, (struct timeval *)0)) <= 0) {
  273.             if (n < 0 && errno != EINTR)
  274.             syslog(LOG_WARNING, "select: %m\n");
  275.             sleep(1);
  276.             continue;
  277.         }
  278.         for (sep = servtab; n && sep; sep = sep->se_next)
  279.         if (sep->se_fd != -1 && (
  280.             FD_ISSET(sep->se_fd, &readable) ||
  281.             FD_ISSET(sep->se_fd, &writable)    )) {
  282.         n--;
  283.         if (debug)
  284.             fprintf(stderr, "someone wants %s\n", sep->se_service);
  285.         if (isrealsock(sep) && sep->se_socktype == SOCK_STREAM) {
  286.             ctrl = accept(sep->se_fd, (struct sockaddr *)0,
  287.                 (int *)0);
  288.             if (debug)
  289.                 fprintf(stderr, "accept, ctrl %d\n", ctrl);
  290.             if (ctrl < 0) {
  291.                 if (errno == EINTR)
  292.                     continue;
  293.                 syslog(LOG_WARNING, "accept (for %s): %m",
  294.                     sep->se_service);
  295.                 continue;
  296.             }
  297.         } else
  298.             ctrl = sep->se_fd;
  299.         (void) sigblock(SIGBLOCK);
  300.         pid = 0;
  301.         dofork = (sep->se_bi == 0 || sep->se_bi->bi_fork);
  302.         if (dofork) {
  303.             if (sep->se_count++ == 0)
  304.                 (void)gettimeofday(&sep->se_time,
  305.                     (struct timezone *)0);
  306.             else if (sep->se_count >= TOOMANY) {
  307.                 struct timeval now;
  308.  
  309.                 (void)gettimeofday(&now, (struct timezone *)0);
  310.                 if (now.tv_sec - sep->se_time.tv_sec >
  311.                     CNT_INTVL) {
  312.                     sep->se_time = now;
  313.                     sep->se_count = 1;
  314.                 } else {
  315.                     syslog(LOG_ERR,
  316.             "%s/%s server failing (looping), service terminated\n",
  317.                         sep->se_service, sep->se_proto);
  318.                     FD_CLR(sep->se_fd, &allsock);
  319.                     if (sep->se_family == AF_PTY)
  320.                         FD_CLR(sep->se_fd, &allpty);
  321.                     (void) close(sep->se_fd);
  322.                     sep->se_fd = -1;
  323.                     sep->se_count = 0;
  324.                     nsock--;
  325.                     sigsetmask(0L);
  326.                     if (!timingout) {
  327.                         timingout = 1;
  328.                         alarm(RETRYTIME);
  329.                     }
  330.                     continue;
  331.                 }
  332.             }
  333.             pid = fork();
  334.         }
  335.         if (pid < 0) {
  336.             if (isrealsock(sep) && sep->se_socktype == SOCK_STREAM)
  337.                 close(ctrl);
  338.             sigsetmask(0L);
  339.             sleep(1);
  340.             continue;
  341.         }
  342.         if (pid && sep->se_wait) {
  343.             sep->se_wait = pid;
  344.             FD_CLR(sep->se_fd, &allsock);
  345.             if (sep->se_family == AF_PTY)
  346.                 FD_CLR(sep->se_fd, &allpty);
  347.             nsock--;
  348.         }
  349.         sigsetmask(0L);
  350.         if (pid == 0) {
  351.             if (debug && dofork)
  352.                 setsid();
  353.             if (sep->se_bi)
  354.                 (*sep->se_bi->bi_fn)(ctrl, sep);
  355.             else {
  356.                 if ((pwd = getpwnam(sep->se_user)) == NULL) {
  357.                     syslog(LOG_ERR,
  358.                         "getpwnam: %s: No such user",
  359.                         sep->se_user);
  360.                     if (isrealsock(sep) &&
  361.                         sep->se_socktype != SOCK_STREAM)
  362.                         recv(0, buf, sizeof (buf), 0);
  363.                     _exit(1);
  364.                 }
  365.                 if (pwd->pw_uid) {
  366.                     (void) setgid((gid_t)pwd->pw_gid);
  367.                     initgroups(pwd->pw_name, pwd->pw_gid);
  368.                     (void) setuid((uid_t)pwd->pw_uid);
  369.                 }
  370.                 if (debug)
  371.                     fprintf(stderr, "%d execl %s\n",
  372.                         getpid(), sep->se_server);
  373.                 dup2(ctrl, 0);
  374.                 close(ctrl);
  375.                 dup2(0, 1);
  376.                 dup2(0, 2);
  377.                 for (tmpint = getdtablesize(); --tmpint > 2; )
  378.                     (void)close(tmpint);
  379.                 execv(sep->se_server, sep->se_argv);
  380.                 if (isrealsock(sep) &&
  381.                     sep->se_socktype != SOCK_STREAM)
  382.                     recv(0, buf, sizeof (buf), 0);
  383.                 syslog(LOG_ERR, "execv %s: %m", sep->se_server);
  384.                 _exit(1);
  385.             }
  386.         }
  387.         if (isrealsock(sep) && sep->se_socktype == SOCK_STREAM)
  388.             close(ctrl);
  389.         if (sep->se_family == AF_PTY) {
  390.             close(sep->se_fd);
  391.             sep->se_fd = -1;
  392.         }
  393.         }
  394.     }
  395. }
  396.  
  397. void
  398. reapchild()
  399. {
  400.     union wait status;
  401.     int pid;
  402.     register struct servtab *sep;
  403.  
  404.     for (;;) {
  405.         pid = wait3(&status, WNOHANG, (struct rusage *)0);
  406.         if (pid <= 0)
  407.             break;
  408.         if (debug)
  409.             fprintf(stderr, "%d reaped\n", pid);
  410.         for (sep = servtab; sep; sep = sep->se_next)
  411.             if (sep->se_wait == pid) {
  412.                 if (status.w_status)
  413.                     syslog(LOG_WARNING,
  414.                         "%s: exit status 0x%x",
  415.                         sep->se_server, status.w_retcode);
  416.                 sep->se_wait = 1;
  417.                 if (sep->se_family == AF_PTY) {
  418.                     setuppty(sep);
  419.                 } else {
  420.                     FD_SET(sep->se_fd, &allsock);
  421.                     nsock++;
  422.                 }
  423.                 if (debug)
  424.                     fprintf(stderr, "restored %s, fd %d\n",
  425.                         sep->se_service, sep->se_fd);
  426.             }
  427.     }
  428. }
  429.  
  430. void
  431. config()
  432. {
  433.     register struct servtab *sep, *cp, **sepp;
  434.     struct servtab *getconfigent(), *enter();
  435.     long omask;
  436.     int n;
  437.  
  438.     if (!setconfig()) {
  439.         syslog(LOG_ERR, "%s: %m", CONFIG);
  440.         return;
  441.     }
  442.     for (sep = servtab; sep; sep = sep->se_next)
  443.         sep->se_checked = 0;
  444.     while (cp = getconfigent()) {
  445.         for (sep = servtab; sep; sep = sep->se_next)
  446.             if (strcmp(sep->se_service, cp->se_service) == 0 &&
  447.                 strcmp(sep->se_proto, cp->se_proto) == 0)
  448.                 break;
  449.         if (sep != 0) {
  450.             int i;
  451.  
  452.             omask = sigblock(SIGBLOCK);
  453.             /*
  454.              * sep->se_wait may be holding the pid of a daemon
  455.              * that we're waiting for.  If so, don't overwrite
  456.              * it unless the config file explicitly says don't 
  457.              * wait.
  458.              */
  459.             if (cp->se_bi == 0 && 
  460.                 (sep->se_wait == 1 || cp->se_wait == 0))
  461.                 sep->se_wait = cp->se_wait;
  462. #define SWAP(a, b) { char *c = a; a = b; b = c; }
  463.             if (cp->se_user)
  464.                 SWAP(sep->se_user, cp->se_user);
  465.             if (cp->se_server)
  466.                 SWAP(sep->se_server, cp->se_server);
  467.             for (i = 0; i < MAXARGV; i++)
  468.                 SWAP(sep->se_argv[i], cp->se_argv[i]);
  469.             if (isrpcservice(sep))
  470.                 unregister_rpc(sep);
  471.             sep->se_rpcversl = cp->se_rpcversl;
  472.             sep->se_rpcversh = cp->se_rpcversh;
  473.             sigsetmask(omask);
  474.             freeconfig(cp);
  475.             if (debug)
  476.                 print_service("REDO", sep);
  477.         } else {
  478.             sep = enter(cp);
  479.             if (debug)
  480.                 print_service("ADD ", sep);
  481.         }
  482.         sep->se_checked = 1;
  483.  
  484.         switch (sep->se_family) {
  485.         case AF_UNIX:
  486.             if (sep->se_fd != -1)
  487.                 break;
  488.             (void)unlink(sep->se_service);
  489.             n = strlen(sep->se_service);
  490.             if (n > sizeof sep->se_ctrladdr_un.sun_path - 1) 
  491.                 n = sizeof sep->se_ctrladdr_un.sun_path - 1;
  492.             strncpy(sep->se_ctrladdr_un.sun_path, sep->se_service, n);
  493.             sep->se_ctrladdr_un.sun_family = AF_UNIX;
  494.             sep->se_ctrladdr_size = n +
  495.                     sizeof sep->se_ctrladdr_un.sun_family;
  496.             setup(sep);
  497.             break;
  498.         case AF_PTY:
  499.             if (sep->se_fd == -1 && sep->se_wait == 1)
  500.                 setuppty(sep);
  501.             break;
  502.         case AF_INET:
  503.             sep->se_ctrladdr_in.sin_family = AF_INET;
  504.             sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in;
  505.             if (isrpcservice(sep)) {
  506.                 struct rpcent *rp;
  507.  
  508.                 sep->se_rpcprog = atoi(sep->se_service);
  509.                 if (sep->se_rpcprog == 0) {
  510.                     rp = getrpcbyname(sep->se_service);
  511.                     if (rp == 0) {
  512.                         syslog(LOG_ERR,
  513.                             "%s: unknown service",
  514.                             sep->se_service);
  515.                         continue;
  516.                     }
  517.                     sep->se_rpcprog = rp->r_number;
  518.                 }
  519.                 if (sep->se_fd == -1)
  520.                     setup(sep);
  521.                 if (sep->se_fd != -1)
  522.                     register_rpc(sep);
  523.             } else {
  524.                 u_short port = htons(atoi(sep->se_service));
  525.  
  526.                 if (!port) {
  527.                     sp = getservbyname(sep->se_service,
  528.                                 sep->se_proto);
  529.                     if (sp == 0) {
  530.                         syslog(LOG_ERR,
  531.                             "%s/%s: unknown service",
  532.                             sep->se_service, sep->se_proto);
  533.                         continue;
  534.                     }
  535.                     port = sp->s_port;
  536.                 }
  537.                 if (port != sep->se_ctrladdr_in.sin_port) {
  538.                     sep->se_ctrladdr_in.sin_port = port;
  539.                     if (sep->se_fd != -1) {
  540.                         FD_CLR(sep->se_fd, &allsock);
  541.                         nsock--;
  542.                         (void) close(sep->se_fd);
  543.                     }
  544.                     sep->se_fd = -1;
  545.                 }
  546.                 if (sep->se_fd == -1)
  547.                     setup(sep);
  548.             }
  549.         }
  550.     }
  551.     endconfig();
  552.     /*
  553.      * Purge anything not looked at above.
  554.      */
  555.     omask = sigblock(SIGBLOCK);
  556.     sepp = &servtab;
  557.     while (sep = *sepp) {
  558.         if (sep->se_checked) {
  559.             sepp = &sep->se_next;
  560.             continue;
  561.         }
  562.         *sepp = sep->se_next;
  563.         if (sep->se_fd != -1) {
  564.             FD_CLR(sep->se_fd, &allsock);
  565.             if (sep->se_family == AF_PTY)
  566.                 FD_CLR(sep->se_fd, &allpty);
  567.             nsock--;
  568.             (void) close(sep->se_fd);
  569.         }
  570.         if (isrpcservice(sep))
  571.             unregister_rpc(sep);
  572.         if (sep->se_family == AF_UNIX)
  573.             (void)unlink(sep->se_service);
  574.         if (debug)
  575.             print_service("FREE", sep);
  576.         freeconfig(sep);
  577.         free((char *)sep);
  578.     }
  579.     (void) sigsetmask(omask);
  580. }
  581.  
  582. void
  583. retry()
  584. {
  585.     register struct servtab *sep;
  586.  
  587.     timingout = 0;
  588.     for (sep = servtab; sep; sep = sep->se_next)
  589.         if (sep->se_fd == -1) {
  590.             switch (sep->se_family) {
  591.             case AF_UNIX:
  592.             case AF_INET:
  593.                 setup(sep);
  594.                 if (sep->se_fd != -1 && isrpcservice(sep))
  595.                     register_rpc(sep);
  596.                 break;
  597.             case AF_PTY:
  598.                 if (sep->se_wait == 1)
  599.                     setuppty(sep);
  600.                 break;
  601.             }
  602.         }
  603. }
  604.  
  605. setup(sep)
  606.     register struct servtab *sep;
  607. {
  608.     int on = 1;
  609.  
  610.     if ((sep->se_fd = socket(sep->se_family, sep->se_socktype, 0)) < 0) {
  611.         syslog(LOG_ERR, "%s/%s: socket: %m",
  612.             sep->se_service, sep->se_proto);
  613.         return;
  614.     }
  615. #define    turnon(fd, opt) \
  616. setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
  617.     if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) &&
  618.         turnon(sep->se_fd, SO_DEBUG) < 0)
  619.         syslog(LOG_ERR, "setsockopt (SO_DEBUG): %m");
  620.     if (turnon(sep->se_fd, SO_REUSEADDR) < 0)
  621.         syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
  622. #undef turnon
  623.     if (bind(sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size) < 0) {
  624.         syslog(LOG_ERR, "%s/%s: bind: %m",
  625.             sep->se_service, sep->se_proto);
  626.         (void) close(sep->se_fd);
  627.         sep->se_fd = -1;
  628.         if (!timingout) {
  629.             timingout = 1;
  630.             alarm(RETRYTIME);
  631.         }
  632.         return;
  633.     }
  634.     if (sep->se_socktype == SOCK_STREAM)
  635.         listen(sep->se_fd, 10);
  636.  
  637.     FD_SET(sep->se_fd, &allsock);
  638.     nsock++;
  639.     if (sep->se_fd > maxsock)
  640.         maxsock = sep->se_fd;
  641. }
  642.  
  643. register_rpc(sep)
  644.     register struct servtab *sep;
  645. {
  646. #if RPC
  647.     int n;
  648.     struct sockaddr_in sin;
  649.     struct protoent *pp;
  650.  
  651.     if ((pp = getprotobyname(sep->se_proto+4)) == NULL) {
  652.         syslog(LOG_ERR, "%s: getproto: %m",
  653.             sep->se_proto);
  654.         return;
  655.     }
  656.     n = sizeof sin;
  657.     if (getsockname(sep->se_fd, &sin, &n) < 0) {
  658.         syslog(LOG_ERR, "%s/%s: getsockname: %m",
  659.             sep->se_service, sep->se_proto);
  660.         return;
  661.     }
  662.  
  663.     for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
  664.         if (debug)
  665.             fprintf(stderr, "pmap_set: %u %u %u %u\n",
  666.             sep->se_rpcprog, n, pp->p_proto, sin.sin_port);
  667.         if (!pmap_set(sep->se_rpcprog, n, pp->p_proto, sin.sin_port))
  668.             syslog(LOG_ERR, "pmap_set: %u %u %u %u: %m",
  669.             sep->se_rpcprog, n, pp->p_proto, sin.sin_port);
  670.     }
  671. #endif RPC
  672. }
  673.  
  674. unregister_rpc(sep)
  675.     register struct servtab *sep;
  676. {
  677.     int n;
  678.  
  679. #if RPC
  680.     for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
  681.         if (debug)
  682.             fprintf(stderr, "pmap_unset(%u, %u)\n",
  683.                 sep->se_rpcprog, n);
  684.         if (!pmap_unset(sep->se_rpcprog, n))
  685.             syslog(LOG_ERR, "pmap_unset(%u, %u)\n",
  686.                 sep->se_rpcprog, n);
  687.     }
  688. #endif RPC
  689. }
  690.  
  691. setuppty(sep)
  692.     register struct servtab *sep;
  693. {
  694.     if ((sep->se_fd = open(sep->se_service, O_RDWR, 0)) < 0) {
  695.         syslog(LOG_ERR, "%s/%s: open: %m",
  696.             sep->se_service, sep->se_proto);
  697.         if (!timingout) {
  698.             timingout = 1;
  699.             alarm(RETRYTIME);
  700.         }
  701.         return;
  702.     }
  703.     FD_SET(sep->se_fd, &allsock);
  704.     FD_SET(sep->se_fd, &allpty);
  705.     nsock++;
  706.     if (sep->se_fd > maxsock)
  707.         maxsock = sep->se_fd;
  708. }
  709.  
  710. struct servtab *
  711. enter(cp)
  712.     struct servtab *cp;
  713. {
  714.     register struct servtab *sep;
  715.     long omask;
  716.  
  717.     sep = (struct servtab *)malloc(sizeof (*sep));
  718.     if (sep == (struct servtab *)0) {
  719.         syslog(LOG_ERR, "Out of memory.");
  720.         exit(-1);
  721.     }
  722.     *sep = *cp;
  723.     sep->se_fd = -1;
  724.     sep->se_rpcprog = -1;
  725.     omask = sigblock(SIGBLOCK);
  726.     sep->se_next = servtab;
  727.     servtab = sep;
  728.     sigsetmask(omask);
  729.     return (sep);
  730. }
  731.  
  732. FILE    *fconfig = NULL;
  733. struct    servtab serv;
  734. char    line[256];
  735. char    *skip(), *nextline();
  736.  
  737. setconfig()
  738. {
  739.  
  740.     if (fconfig != NULL) {
  741.         fseek(fconfig, 0L, L_SET);
  742.         return (1);
  743.     }
  744.     fconfig = fopen(CONFIG, "r");
  745.     return (fconfig != NULL);
  746. }
  747.  
  748. endconfig()
  749. {
  750.     if (fconfig) {
  751.         (void) fclose(fconfig);
  752.         fconfig = NULL;
  753.     }
  754. }
  755.  
  756. struct servtab *
  757. getconfigent()
  758. {
  759.     register struct servtab *sep = &serv;
  760.     int argc;
  761.     char *cp, *arg, *strdup();
  762.  
  763. more:
  764.     while ((cp = nextline(fconfig)) && *cp == '#')
  765.         ;
  766.     if (cp == NULL)
  767.         return ((struct servtab *)0);
  768.     bzero((char *)sep, sizeof *sep);
  769.     sep->se_service = strdup(skip(&cp));
  770.     arg = skip(&cp);
  771.     if (strcmp(arg, "stream") == 0)
  772.         sep->se_socktype = SOCK_STREAM;
  773.     else if (strcmp(arg, "dgram") == 0)
  774.         sep->se_socktype = SOCK_DGRAM;
  775.     else if (strcmp(arg, "rdm") == 0)
  776.         sep->se_socktype = SOCK_RDM;
  777.     else if (strcmp(arg, "seqpacket") == 0)
  778.         sep->se_socktype = SOCK_SEQPACKET;
  779.     else if (strcmp(arg, "raw") == 0)
  780.         sep->se_socktype = SOCK_RAW;
  781.     else
  782.         sep->se_socktype = -1;
  783.  
  784.     sep->se_proto = strdup(skip(&cp));
  785.     if (strcmp(sep->se_proto, "pty") == 0) {
  786.         sep->se_family = AF_PTY;
  787.     } else if (strcmp(sep->se_proto, "unix") == 0) {
  788.         sep->se_family = AF_UNIX;
  789.     } else {
  790.         sep->se_family = AF_INET;
  791.         if (strncmp(sep->se_proto, "rpc/", 4) == 0) {
  792. #if RPC
  793.             char *cp, *ccp;
  794.             cp = index(sep->se_service, '/');
  795.             if (cp == 0) {
  796.                 syslog(LOG_ERR, "%s: no rpc version",
  797.                     sep->se_service);
  798.                 goto more;
  799.             }
  800.             *cp++ = '\0';
  801.             sep->se_rpcversl =
  802.                 sep->se_rpcversh = strtol(cp, &ccp, 0);
  803.             if (ccp == cp) {
  804.         badafterall:
  805.                 syslog(LOG_ERR, "%s/%s: bad rpc version",
  806.                     sep->se_service, cp);
  807.                 goto more;
  808.             }
  809.             if (*ccp == '-') {
  810.                 cp = ccp + 1;
  811.                 sep->se_rpcversh = strtol(cp, &ccp, 0); 
  812.                 if (ccp == cp)
  813.                     goto badafterall;
  814.             }
  815. #else
  816.             syslog(LOG_ERR, "%s: rpc services not suported",
  817.                 sep->se_service);
  818.             goto more;
  819. #endif RPC
  820.         }
  821.     }
  822.     arg = skip(&cp);
  823.     sep->se_wait = strcmp(arg, "wait") == 0;
  824.     if (sep->se_wait == 0 && sep->se_family == AF_PTY) {
  825.         syslog(LOG_ERR, "pty: only single threaded servers allowed: %s\n", sep->se_service);
  826.         sep->se_wait = 1;
  827.     }
  828.     sep->se_user = strdup(skip(&cp));
  829.     sep->se_server = strdup(skip(&cp));
  830.     if (strcmp(sep->se_server, "internal") == 0) {
  831.         register struct biltin *bi;
  832.  
  833.         for (bi = biltins; bi->bi_service; bi++)
  834.             if (bi->bi_socktype == sep->se_socktype &&
  835.                 strcmp(bi->bi_service, sep->se_service) == 0)
  836.                 break;
  837.         if (bi->bi_service == 0) {
  838.             syslog(LOG_ERR, "internal service %s unknown\n",
  839.                 sep->se_service);
  840.             goto more;
  841.         }
  842.         sep->se_bi = bi;
  843.         sep->se_wait = bi->bi_wait;
  844.     } else
  845.         sep->se_bi = NULL;
  846.     argc = 0;
  847.     for (arg = skip(&cp); cp; arg = skip(&cp))
  848.         if (argc < MAXARGV)
  849.             sep->se_argv[argc++] = strdup(arg);
  850.     while (argc <= MAXARGV)
  851.         sep->se_argv[argc++] = NULL;
  852.     return (sep);
  853. }
  854.  
  855. freeconfig(cp)
  856.     register struct servtab *cp;
  857. {
  858.     int i;
  859.  
  860.     if (cp->se_service)
  861.         free(cp->se_service);
  862.     if (cp->se_proto)
  863.         free(cp->se_proto);
  864.     if (cp->se_user)
  865.         free(cp->se_user);
  866.     if (cp->se_server)
  867.         free(cp->se_server);
  868.     for (i = 0; i < MAXARGV; i++)
  869.         if (cp->se_argv[i])
  870.             free(cp->se_argv[i]);
  871. }
  872.  
  873. char *
  874. skip(cpp)
  875.     char **cpp;
  876. {
  877.     register char *cp = *cpp;
  878.     char *start;
  879.  
  880. again:
  881.     while (*cp == ' ' || *cp == '\t')
  882.         cp++;
  883.     if (*cp == '\0') {
  884.         int c;
  885.  
  886.         c = getc(fconfig);
  887.         (void) ungetc(c, fconfig);
  888.         if (c == ' ' || c == '\t')
  889.             if (cp = nextline(fconfig))
  890.                 goto again;
  891.         *cpp = (char *)0;
  892.         return ((char *)0);
  893.     }
  894.     start = cp;
  895.     while (*cp && *cp != ' ' && *cp != '\t')
  896.         cp++;
  897.     if (*cp != '\0')
  898.         *cp++ = '\0';
  899.     *cpp = cp;
  900.     return (start);
  901. }
  902.  
  903. char *
  904. nextline(fd)
  905.     FILE *fd;
  906. {
  907.     char *cp;
  908.  
  909.     if (fgets(line, sizeof (line), fd) == NULL)
  910.         return ((char *)0);
  911.     cp = index(line, '\n');
  912.     if (cp)
  913.         *cp = '\0';
  914.     return (line);
  915. }
  916.  
  917. char *
  918. strdup(cp)
  919.     char *cp;
  920. {
  921.     char *new;
  922.  
  923.     if (cp == NULL)
  924.         cp = "";
  925.     new = malloc((unsigned)(strlen(cp) + 1));
  926.     if (new == (char *)0) {
  927.         syslog(LOG_ERR, "Out of memory.");
  928.         exit(-1);
  929.     }
  930.     (void)strcpy(new, cp);
  931.     return (new);
  932. }
  933.  
  934. setproctitle(a, s)
  935.     char *a;
  936.     int s;
  937. {
  938.     int size;
  939.     register char *cp;
  940.     struct sockaddr_in sin;
  941.     char buf[80];
  942.  
  943.     cp = Argv[0];
  944.     size = sizeof(sin);
  945.     if (getpeername(s, &sin, &size) == 0)
  946.         (void) sprintf(buf, "-%s [%s]", a, inet_ntoa(sin.sin_addr)); 
  947.     else
  948.         (void) sprintf(buf, "-%s", a); 
  949.     strncpy(cp, buf, LastArg - cp);
  950.     cp += strlen(cp);
  951.     while (cp < LastArg)
  952.         *cp++ = ' ';
  953. }
  954.  
  955. logpid()
  956. {
  957.     FILE *fp;
  958.  
  959.     if ((fp = fopen(PIDFILE, "w")) != NULL) {
  960.         fprintf(fp, "%u\n", getpid());
  961.         (void)fclose(fp);
  962.     }
  963. }
  964.  
  965. #ifdef sun
  966. bump_nofile()
  967. {
  968.     struct rlimit rl;
  969.  
  970.     if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
  971.         return -1;
  972.     rl.rlim_cur = rl.rlim_max;
  973.     if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
  974.         return -1;
  975.     return 0;
  976. }
  977. #endif
  978.  
  979. /*
  980.  * Internet services provided internally by inetd:
  981.  */
  982. #define    BUFSIZE    4096
  983.  
  984. /* ARGSUSED */
  985. echo_stream(s, sep)        /* Echo service -- echo data back */
  986.     int s;
  987.     struct servtab *sep;
  988. {
  989.     char buffer[BUFSIZE];
  990.     int i;
  991.  
  992.     setproctitle(sep->se_service, s);
  993.     while ((i = read(s, buffer, sizeof(buffer))) > 0 &&
  994.         write(s, buffer, i) > 0)
  995.         ;
  996.     exit(0);
  997. }
  998.  
  999. /* ARGSUSED */
  1000. echo_dg(s, sep)            /* Echo service -- echo data back */
  1001.     int s;
  1002.     struct servtab *sep;
  1003. {
  1004.     char buffer[BUFSIZE];
  1005.     int i, size;
  1006.     struct sockaddr sa;
  1007.  
  1008.     size = sizeof(sa);
  1009.     if ((i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size)) < 0)
  1010.         return;
  1011.     (void) sendto(s, buffer, i, 0, &sa, sizeof(sa));
  1012. }
  1013.  
  1014. /* ARGSUSED */
  1015. discard_stream(s, sep)        /* Discard service -- ignore data */
  1016.     int s;
  1017.     struct servtab *sep;
  1018. {
  1019.     char buffer[BUFSIZE];
  1020.  
  1021.     setproctitle(sep->se_service, s);
  1022.     while ((errno = 0, read(s, buffer, sizeof(buffer)) > 0) ||
  1023.             errno == EINTR)
  1024.         ;
  1025.     exit(0);
  1026. }
  1027.  
  1028. /* ARGSUSED */
  1029. discard_dg(s, sep)        /* Discard service -- ignore data */
  1030.     int s;
  1031.     struct servtab *sep;
  1032. {
  1033.     char buffer[BUFSIZE];
  1034.  
  1035.     (void) read(s, buffer, sizeof(buffer));
  1036. }
  1037.  
  1038. #include <ctype.h>
  1039. #define LINESIZ 72
  1040. char ring[128];
  1041. char *endring;
  1042.  
  1043. initring()
  1044. {
  1045.     register int i;
  1046.  
  1047.     endring = ring;
  1048.  
  1049.     for (i = 0; i <= 128; ++i)
  1050.         if (isprint(i))
  1051.             *endring++ = i;
  1052. }
  1053.  
  1054. /* ARGSUSED */
  1055. chargen_stream(s, sep)        /* Character generator */
  1056.     int s;
  1057.     struct servtab *sep;
  1058. {
  1059.     register char *rs;
  1060.     int len;
  1061.     char text[LINESIZ+2];
  1062.  
  1063.     setproctitle(sep->se_service, s);
  1064.  
  1065.     if (!endring) {
  1066.         initring();
  1067.         rs = ring;
  1068.     }
  1069.  
  1070.     text[LINESIZ] = '\r';
  1071.     text[LINESIZ + 1] = '\n';
  1072.     for (rs = ring;;) {
  1073.         if ((len = endring - rs) >= LINESIZ)
  1074.             bcopy(rs, text, LINESIZ);
  1075.         else {
  1076.             bcopy(rs, text, len);
  1077.             bcopy(ring, text + len, LINESIZ - len);
  1078.         }
  1079.         if (++rs == endring)
  1080.             rs = ring;
  1081.         if (write(s, text, sizeof(text)) != sizeof(text))
  1082.             break;
  1083.     }
  1084.     exit(0);
  1085. }
  1086.  
  1087. /* ARGSUSED */
  1088. chargen_dg(s, sep)        /* Character generator */
  1089.     int s;
  1090.     struct servtab *sep;
  1091. {
  1092.     struct sockaddr sa;
  1093.     static char *rs;
  1094.     int len, size;
  1095.     char text[LINESIZ+2];
  1096.  
  1097.     if (endring == 0) {
  1098.         initring();
  1099.         rs = ring;
  1100.     }
  1101.  
  1102.     size = sizeof(sa);
  1103.     if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0)
  1104.         return;
  1105.  
  1106.     if ((len = endring - rs) >= LINESIZ)
  1107.         bcopy(rs, text, LINESIZ);
  1108.     else {
  1109.         bcopy(rs, text, len);
  1110.         bcopy(ring, text + len, LINESIZ - len);
  1111.     }
  1112.     if (++rs == endring)
  1113.         rs = ring;
  1114.     text[LINESIZ] = '\r';
  1115.     text[LINESIZ + 1] = '\n';
  1116.     (void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa));
  1117. }
  1118.  
  1119. /*
  1120.  * Return a machine readable date and time, in the form of the
  1121.  * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
  1122.  * returns the number of seconds since midnight, Jan 1, 1970,
  1123.  * we must add 2208988800 seconds to this figure to make up for
  1124.  * some seventy years Bell Labs was asleep.
  1125.  */
  1126.  
  1127. long
  1128. machtime()
  1129. {
  1130.     struct timeval tv;
  1131.  
  1132.     if (gettimeofday(&tv, (struct timezone *)0) < 0) {
  1133.         fprintf(stderr, "Unable to get time of day\n");
  1134.         return (0L);
  1135.     }
  1136.     return (htonl((long)tv.tv_sec + 2208988800));
  1137. }
  1138.  
  1139. /* ARGSUSED */
  1140. machtime_stream(s, sep)
  1141.     int s;
  1142.     struct servtab *sep;
  1143. {
  1144.     long result;
  1145.  
  1146.     result = machtime();
  1147.     (void) write(s, (char *) &result, sizeof(result));
  1148. }
  1149.  
  1150. /* ARGSUSED */
  1151. machtime_dg(s, sep)
  1152.     int s;
  1153.     struct servtab *sep;
  1154. {
  1155.     long result;
  1156.     struct sockaddr sa;
  1157.     int size;
  1158.  
  1159.     size = sizeof(sa);
  1160.     if (recvfrom(s, (char *)&result, sizeof(result), 0, &sa, &size) < 0)
  1161.         return;
  1162.     result = machtime();
  1163.     (void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa));
  1164. }
  1165.  
  1166. /* ARGSUSED */
  1167. daytime_stream(s, sep)        /* Return human-readable time of day */
  1168.     int s;
  1169.     struct servtab *sep;
  1170. {
  1171.     char buffer[256];
  1172.     time_t time(), clock;
  1173.     char *ctime();
  1174.  
  1175.     clock = time((time_t *) 0);
  1176.  
  1177.     (void) sprintf(buffer, "%.24s\r\n", ctime(&clock));
  1178.     (void) write(s, buffer, strlen(buffer));
  1179. }
  1180.  
  1181. /* ARGSUSED */
  1182. daytime_dg(s, sep)        /* Return human-readable time of day */
  1183.     int s;
  1184.     struct servtab *sep;
  1185. {
  1186.     char buffer[256];
  1187.     time_t time(), clock;
  1188.     struct sockaddr sa;
  1189.     int size;
  1190.     char *ctime();
  1191.  
  1192.     clock = time((time_t *) 0);
  1193.  
  1194.     size = sizeof(sa);
  1195.     if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0)
  1196.         return;
  1197.     (void) sprintf(buffer, "%.24s\r\n", ctime(&clock));
  1198.     (void) sendto(s, buffer, strlen(buffer), 0, &sa, sizeof(sa));
  1199. }
  1200.  
  1201. /*
  1202.  * print_service:
  1203.  *    Dump relevant information to stderr
  1204.  */
  1205. print_service(action, sep)
  1206.     char *action;
  1207.     struct servtab *sep;
  1208. {
  1209.     fprintf(stderr,
  1210.         "%s: %s proto=%s, wait=%d, user=%s builtin=%x server=%s\n",
  1211.         action, sep->se_service, sep->se_proto,
  1212.         sep->se_wait, sep->se_user, (int)sep->se_bi, sep->se_server);
  1213. }
  1214.