source: trunk/third/inetd/inetd.c @ 15024

Revision 15024, 50.5 KB checked in by rbasch, 24 years ago (diff)
Handle a change to the switched/unswitched field in inetd.conf.
Line 
1/*      $NetBSD: inetd.c,v 1.38.2.2 1998/05/05 08:12:06 mycroft Exp $   */
2
3/*
4 * Copyright (c) 1983, 1991, 1993, 1994
5 *      The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *      This product includes software developed by the University of
18 *      California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#ifdef __NetBSD__
37#include <sys/cdefs.h>
38#else
39#define __COPYRIGHT(x) char *copyright = x
40#define __RCSID(x) char *rcsid = x
41char *__progname;
42#endif
43
44#ifndef lint
45__COPYRIGHT("@(#) Copyright (c) 1983, 1991, 1993, 1994\n\
46        The Regents of the University of California.  All rights reserved.\n");
47#if 0
48static char sccsid[] = "@(#)inetd.c     8.4 (Berkeley) 4/13/94";
49#else
50__RCSID("$NetBSD: inetd.c,v 1.38.2.2 1998/05/05 08:12:06 mycroft Exp $");
51#endif
52#endif /* not lint */
53
54/*
55 * Inetd - Internet super-server
56 *
57 * This program invokes all internet services as needed.  Connection-oriented
58 * services are invoked each time a connection is made, by creating a process.
59 * This process is passed the connection as file descriptor 0 and is expected
60 * to do a getpeername to find out the source host and port.
61 *
62 * Datagram oriented services are invoked when a datagram
63 * arrives; a process is created and passed a pending message
64 * on file descriptor 0.  Datagram servers may either connect
65 * to their peer, freeing up the original socket for inetd
66 * to receive further messages on, or ``take over the socket'',
67 * processing all arriving datagrams and, eventually, timing
68 * out.  The first type of server is said to be ``multi-threaded'';
69 * the second type of server ``single-threaded''.
70 *
71 * Inetd uses a configuration file which is read at startup
72 * and, possibly, at some later time in response to a hangup signal.
73 * The configuration file is ``free format'' with fields given in the
74 * order shown below.  Continuation lines for an entry must being with
75 * a space or tab.  All fields must be present in each entry.
76 *
77 *      service name                    must be in /etc/services or must
78 *                                      name a tcpmux service
79 *      socket type                     stream/dgram/raw/rdm/seqpacket
80 *      protocol                        must be in /etc/protocols
81 *      wait/nowait[.max]               single-threaded/multi-threaded, max #
82 *      user[.group]                    user/group to run daemon as
83 *      server program                  full path name
84 *      server program arguments        maximum of MAXARGS (20)
85 *
86 * For RPC services
87 *      service name/version            must be in /etc/rpc
88 *      socket type                     stream/dgram/raw/rdm/seqpacket
89 *      protocol                        must be in /etc/protocols
90 *      wait/nowait[.max]               single-threaded/multi-threaded
91 *      user[.group]                    user to run daemon as
92 *      server program                  full path name
93 *      server program arguments        maximum of MAXARGS (20)
94 *
95 * For non-RPC services, the "service name" can be of the form
96 * hostaddress:servicename, in which case the hostaddress is used
97 * as the host portion of the address to listen on.  If hostaddress
98 * consists of a single `*' character, INADDR_ANY is used.
99 *
100 * A line can also consist of just
101 *      hostaddress:
102 * where hostaddress is as in the preceding paragraph.  Such a line must
103 * have no further fields; the specified hostaddress is remembered and
104 * used for all further lines that have no hostaddress specified,
105 * until the next such line (or EOF).  (This is why * is provided to
106 * allow explicit specification of INADDR_ANY.)  A line
107 *      *:
108 * is implicitly in effect at the beginning of the file.
109 *
110 * The hostaddress specifier may (and often will) contain dots;
111 * the service name must not.
112 *
113 * For RPC services, host-address specifiers are accepted and will
114 * work to some extent; however, because of limitations in the
115 * portmapper interface, it will not work to try to give more than
116 * one line for any given RPC service, even if the host-address
117 * specifiers are different.
118 *
119 * TCP services without official port numbers are handled with the
120 * RFC1078-based tcpmux internal service. Tcpmux listens on port 1 for
121 * requests. When a connection is made from a foreign host, the service
122 * requested is passed to tcpmux, which looks it up in the servtab list
123 * and returns the proper entry for the service. Tcpmux returns a
124 * negative reply if the service doesn't exist, otherwise the invoked
125 * server is expected to return the positive reply if the service type in
126 * inetd.conf file has the prefix "tcpmux/". If the service type has the
127 * prefix "tcpmux/+", tcpmux will return the positive reply for the
128 * process; this is for compatibility with older server code, and also
129 * allows you to invoke programs that use stdin/stdout without putting any
130 * special server code in them. Services that use tcpmux are "nowait"
131 * because they do not have a well-known port and hence cannot listen
132 * for new requests.
133 *
134 * Comment lines are indicated by a `#' in column 1.
135 */
136
137/*
138 * Here's the scoop concerning the user.group feature:
139 *
140 * 1) set-group-option off.
141 *
142 *      a) user = root: NO setuid() or setgid() is done
143 *
144 *      b) other:       setuid()
145 *                      setgid(primary group as found in passwd)
146 *                      initgroups(name, primary group)
147 *
148 * 2) set-group-option on.
149 *
150 *      a) user = root: NO setuid()
151 *                      setgid(specified group)
152 *                      NO initgroups()
153 *
154 *      b) other:       setuid()
155 *                      setgid(specified group)
156 *                      initgroups(name, specified group)
157 *
158 */
159
160#include <sys/types.h>
161#include <sys/param.h>
162#include <sys/stat.h>
163#include <sys/ioctl.h>
164#include <sys/socket.h>
165#include <sys/un.h>
166#include <sys/wait.h>
167#include <sys/time.h>
168#include <sys/resource.h>
169
170#ifndef RLIMIT_NOFILE
171#define RLIMIT_NOFILE   RLIMIT_OFILE
172#endif
173
174#define RPC
175
176#include <netinet/in.h>
177#include <arpa/inet.h>
178#ifdef RPC
179#include <rpc/rpc.h>
180#include <rpc/pmap_clnt.h>
181#ifdef HAVE_RPC_RPCENT_H
182#include <rpc/rpcent.h>
183#endif
184#endif
185
186#include <errno.h>
187#include <fcntl.h>
188#include <grp.h>
189#include <netdb.h>
190#include <pwd.h>
191#include <signal.h>
192#include <stdio.h>
193#include <stdlib.h>
194#include <string.h>
195#include <syslog.h>
196#include <unistd.h>
197
198#include "pathnames.h"
199
200#ifdef LIBWRAP
201# include <tcpd.h>
202#ifndef LIBWRAP_ALLOW_FACILITY
203# define LIBWRAP_ALLOW_FACILITY LOG_AUTH
204#endif
205#ifndef LIBWRAP_ALLOW_SEVERITY
206# define LIBWRAP_ALLOW_SEVERITY LOG_INFO
207#endif
208#ifndef LIBWRAP_DENY_FACILITY
209# define LIBWRAP_DENY_FACILITY LOG_AUTH
210#endif
211#ifndef LIBWRAP_DENY_SEVERITY
212# define LIBWRAP_DENY_SEVERITY LOG_WARNING
213#endif
214int allow_severity = LIBWRAP_ALLOW_FACILITY|LIBWRAP_ALLOW_SEVERITY;
215int deny_severity = LIBWRAP_DENY_FACILITY|LIBWRAP_DENY_SEVERITY;
216#endif
217
218#define TOOMANY         40              /* don't start more than TOOMANY */
219#define CNT_INTVL       60              /* servers in CNT_INTVL sec. */
220#define RETRYTIME       (60*10)         /* retry after bind or server fail */
221
222sigset_t sig_block;
223
224int     debug;
225#ifdef LIBWRAP
226int     lflag;
227#endif
228int     access_on;
229int     nsock, maxsock;
230fd_set  allsock;
231int     options;
232int     timingout;
233struct  servent *sp;
234char    *curdom;
235
236#ifndef OPEN_MAX
237#define OPEN_MAX        64
238#endif
239
240/* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
241#define FD_MARGIN       (8)
242rlim_t rlim_ofile_cur = OPEN_MAX;
243
244#ifdef RLIMIT_NOFILE
245struct rlimit   rlim_ofile;
246#endif
247
248struct  servtab {
249        char    *se_hostaddr;           /* host address to listen on */
250        char    *se_service;            /* name of service */
251        int     se_socktype;            /* type of socket to use */
252        int     se_family;              /* address family */
253        char    *se_proto;              /* protocol used */
254        int     se_rpcprog;             /* rpc program number */
255        int     se_rpcversl;            /* rpc program lowest version */
256        int     se_rpcversh;            /* rpc program highest version */
257#define isrpcservice(sep)       ((sep)->se_rpcversl != 0)
258        pid_t   se_wait;                /* single threaded server */
259        short   se_switched;            /* switched by access_on/off */
260        short   se_checked;             /* looked at during merge */
261        char    *se_user;               /* user name to run as */
262        char    *se_group;              /* group name to run as */
263        struct  biltin *se_bi;          /* if built-in, description */
264        char    *se_server;             /* server program */
265#define MAXARGV 20
266        char    *se_argv[MAXARGV+1];    /* program arguments */
267        int     se_fd;                  /* open descriptor */
268        int     se_type;                /* type */
269        union {
270                struct  sockaddr se_un_ctrladdr;
271                struct  sockaddr_in se_un_ctrladdr_in;
272                struct  sockaddr_un se_un_ctrladdr_un;
273        } se_un;                        /* bound address */
274#define se_ctrladdr     se_un.se_un_ctrladdr
275#define se_ctrladdr_in  se_un.se_un_ctrladdr_in
276#define se_ctrladdr_un  se_un.se_un_ctrladdr_un
277        int     se_ctrladdr_size;
278        int     se_max;                 /* max # of instances of this service */
279        int     se_count;               /* number started since se_time */
280        struct  timeval se_time;        /* start of se_count */
281#ifdef MULOG
282        int     se_log;
283#define MULOG_RFC931    0x40000000
284#endif
285        struct  servtab *se_next;
286} *servtab;
287
288#define NORM_TYPE       0
289#define MUX_TYPE        1
290#define MUXPLUS_TYPE    2
291#define ISMUX(sep)      (((sep)->se_type == MUX_TYPE) || \
292                         ((sep)->se_type == MUXPLUS_TYPE))
293#define ISMUXPLUS(sep)  ((sep)->se_type == MUXPLUS_TYPE)
294
295
296#ifndef __P
297#define __P(x) x
298#endif
299
300void            chargen_dg __P((int, struct servtab *));
301void            chargen_stream __P((int, struct servtab *));
302void            close_sep __P((struct servtab *));
303void            config __P((int));
304void            access_switch __P((int));
305void            daytime_dg __P((int, struct servtab *));
306void            daytime_stream __P((int, struct servtab *));
307void            discard_dg __P((int, struct servtab *));
308void            discard_stream __P((int, struct servtab *));
309void            echo_dg __P((int, struct servtab *));
310void            echo_stream __P((int, struct servtab *));
311void            endconfig __P((void));
312struct servtab *enter __P((struct servtab *));
313void            freeconfig __P((struct servtab *));
314struct servtab *getconfigent __P((void));
315void            goaway __P((int));
316void            machtime_dg __P((int, struct servtab *));
317void            machtime_stream __P((int, struct servtab *));
318char           *newstr __P((char *));
319char           *nextline __P((FILE *));
320void            print_service __P((char *, struct servtab *));
321void            reapchild __P((int));
322void            retry __P((int));
323void            run_service __P((int, struct servtab *));
324int             setconfig __P((void));
325void            setup __P((struct servtab *));
326char           *sskip __P((char **));
327char           *skip __P((char **));
328void            tcpmux __P((int, struct servtab *));
329void            usage __P((void));
330void            logpid __P((void));
331void            register_rpc __P((struct servtab *sep));
332void            unregister_rpc __P((struct servtab *sep));
333void            bump_nofile __P((void));
334void            inetd_setproctitle __P((char *, int));
335void            initring __P((void));
336long            machtime __P((void));
337static int      getline __P((int, char *, int));
338int             main __P((int, char *[], char *[]));
339
340struct biltin {
341        char    *bi_service;            /* internally provided service name */
342        int     bi_socktype;            /* type of socket supported */
343        short   bi_fork;                /* 1 if should fork before call */
344        short   bi_wait;                /* 1 if should wait for child */
345        void    (*bi_fn) __P((int, struct servtab *));
346                                        /* function which performs it */
347} biltins[] = {
348        /* Echo received data */
349        { "echo",       SOCK_STREAM,    1, 0,   echo_stream },
350        { "echo",       SOCK_DGRAM,     0, 0,   echo_dg },
351
352        /* Internet /dev/null */
353        { "discard",    SOCK_STREAM,    1, 0,   discard_stream },
354        { "discard",    SOCK_DGRAM,     0, 0,   discard_dg },
355
356        /* Return 32 bit time since 1970 */
357        { "time",       SOCK_STREAM,    0, 0,   machtime_stream },
358        { "time",       SOCK_DGRAM,     0, 0,   machtime_dg },
359
360        /* Return human-readable time */
361        { "daytime",    SOCK_STREAM,    0, 0,   daytime_stream },
362        { "daytime",    SOCK_DGRAM,     0, 0,   daytime_dg },
363
364        /* Familiar character generator */
365        { "chargen",    SOCK_STREAM,    1, 0,   chargen_stream },
366        { "chargen",    SOCK_DGRAM,     0, 0,   chargen_dg },
367
368        { "tcpmux",     SOCK_STREAM,    1, 0,   tcpmux },
369
370        { NULL }
371};
372
373#define NUMINT  (sizeof(intab) / sizeof(struct inent))
374char    *CONFIG = _PATH_INETDCONF;
375char    **Argv;
376char    *LastArg;
377extern char     *__progname;
378
379#ifdef sun
380/*
381 * Sun's RPC library caches the result of `dtablesize()'
382 * This is incompatible with our "bumping" of file descriptors "on demand"
383 */
384int
385_rpc_dtablesize()
386{
387        return rlim_ofile_cur;
388}
389#endif
390
391int
392main(argc, argv, envp)
393        int argc;
394        char *argv[], *envp[];
395{
396        struct servtab *sep, *nsep;
397        struct sigaction sa;
398        int ch, dofork;
399        pid_t pid;
400
401        __progname = argv[0];
402        if (strchr(__progname, '/'))
403                __progname = strrchr(__progname, '/') + 1;
404
405        Argv = argv;
406        if (envp == 0 || *envp == 0)
407                envp = argv;
408        while (*envp)
409                envp++;
410        LastArg = envp[-1] + strlen(envp[-1]);
411
412        while ((ch = getopt(argc, argv,
413#ifdef LIBWRAP
414                                        "dln"
415#else
416                                        "dn"
417#endif
418                                           )) != -1)
419                switch(ch) {
420                case 'd':
421                        debug = 1;
422                        options |= SO_DEBUG;
423                        break;
424#ifdef LIBWRAP
425                case 'l':
426                        lflag = 1;
427                        break;
428#endif
429                case 'n':
430                        access_on = 1;
431                        break;
432                case '?':
433                default:
434                        usage();
435                }
436        argc -= optind;
437        argv += optind;
438
439        if (argc > 0)
440                CONFIG = argv[0];
441
442        if (debug == 0) {
443                int fd;
444
445                switch (fork ()) {
446                case -1:
447                        return (-1);
448                case 0:
449                        break;
450                default:
451                        _exit(0);
452                }
453
454                if (setsid() == -1) {
455                        fprintf(stderr, "%s: couldn't setsid\n", __progname);
456                        exit(1);
457                }
458                chdir("/");
459                if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
460                        dup2(fd, STDIN_FILENO);
461                        dup2(fd, STDOUT_FILENO);
462                        dup2(fd, STDERR_FILENO);
463                        if (fd > STDERR_FILENO)
464                                close(fd);
465                }
466        }
467        openlog(__progname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
468        logpid();
469
470#ifdef RLIMIT_NOFILE
471        if (getrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0) {
472                syslog(LOG_ERR, "getrlimit: %m");
473        } else {
474                rlim_ofile_cur = rlim_ofile.rlim_cur;
475                if (rlim_ofile_cur == RLIM_INFINITY)    /* ! */
476                        rlim_ofile_cur = OPEN_MAX;
477        }
478#endif
479
480        memset(&sa, 0, sizeof(sa));
481        sigemptyset(&sig_block);
482        sigaddset(&sig_block, SIGCHLD);
483        sigaddset(&sig_block, SIGHUP);
484        sigaddset(&sig_block, SIGALRM);
485        sigaddset(&sig_block, SIGUSR1);
486        sigaddset(&sig_block, SIGUSR2);
487        memcpy(&sa.sa_mask, &sig_block, sizeof(sigset_t));
488        sa.sa_handler = retry;
489        sigaction(SIGALRM, &sa, NULL);
490        config(SIGHUP);
491        sa.sa_handler = config;
492        sigaction(SIGHUP, &sa, NULL);
493        sa.sa_handler = access_switch;
494        sigaction(SIGUSR1, &sa, NULL);
495        sigaction(SIGUSR2, &sa, NULL);
496        sa.sa_handler = reapchild;
497        sigaction(SIGCHLD, &sa, NULL);
498        sa.sa_handler = goaway;
499        sigaction(SIGTERM, &sa, NULL);
500        sa.sa_handler = goaway;
501        sigaction(SIGINT, &sa, NULL);
502        sigemptyset(&sa.sa_mask);
503        sa.sa_handler = SIG_IGN;
504        sigaction(SIGPIPE, &sa, NULL);
505
506        {
507                /* space for daemons to overwrite environment for ps */
508#define DUMMYSIZE       100
509                char dummy[DUMMYSIZE];
510
511                (void)memset(dummy, 'x', DUMMYSIZE - 1);
512                dummy[DUMMYSIZE - 1] = '\0';
513
514                (void)setenv("inetd_dummy", dummy, 1);
515        }
516
517        for (;;) {
518            int n, ctrl;
519            fd_set readable;
520
521            if (nsock == 0) {
522                sigset_t prev_mask;
523                sigprocmask(SIG_SETMASK, &sig_block, &prev_mask);
524                while (nsock == 0)
525                    sigsuspend(&prev_mask);
526                sigprocmask(SIG_SETMASK, &prev_mask, NULL);
527            }
528            readable = allsock;
529            if ((n = select(maxsock + 1, &readable, (fd_set *)0,
530                (fd_set *)0, (struct timeval *)0)) <= 0) {
531                    if (n == -1 && errno != EINTR) {
532                        syslog(LOG_WARNING, "select: %m");
533                        sleep(1);
534                    }
535                    continue;
536            }
537            for (sep = servtab; n && sep; sep = nsep) {
538            nsep = sep->se_next;
539            if (sep->se_fd != -1 && FD_ISSET(sep->se_fd, &readable)) {
540                n--;
541                if (debug)
542                        fprintf(stderr, "someone wants %s\n", sep->se_service);
543                if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
544                        /* XXX here do the libwrap check-before-accept */
545                        ctrl = accept(sep->se_fd, (struct sockaddr *)0,
546                            (int *)0);
547                        if (debug)
548                                fprintf(stderr, "accept, ctrl %d\n", ctrl);
549                        if (ctrl < 0) {
550                                if (errno != EINTR)
551                                        syslog(LOG_WARNING,
552                                            "accept (for %s): %m",
553                                            sep->se_service);
554                                continue;
555                        }
556                } else
557                        ctrl = sep->se_fd;
558                sigprocmask(SIG_SETMASK, &sig_block, NULL);
559                pid = 0;
560#ifdef LIBWRAP_INTERNAL
561                dofork = 1;
562#else
563                dofork = (sep->se_bi == 0 || sep->se_bi->bi_fork);
564#endif
565                if (dofork) {
566                        if (sep->se_count++ == 0)
567                            (void)gettimeofday(&sep->se_time,
568                                (struct timezone *)0);
569                        else if (sep->se_count >= sep->se_max) {
570                                struct timeval now;
571
572                                (void)gettimeofday(&now, (struct timezone *)0);
573                                if (now.tv_sec - sep->se_time.tv_sec >
574                                    CNT_INTVL) {
575                                        sep->se_time = now;
576                                        sep->se_count = 1;
577                                } else {
578                                        syslog(LOG_ERR,
579                        "%s/%s server failing (looping), service terminated\n",
580                                            sep->se_service, sep->se_proto);
581                                        close_sep(sep);
582                                        sigprocmask(SIG_UNBLOCK,
583                                                    &sig_block, NULL);
584                                        if (!timingout) {
585                                                timingout = 1;
586                                                alarm(RETRYTIME);
587                                        }
588                                        continue;
589                                }
590                        }
591                        pid = fork();
592                        if (pid < 0) {
593                                syslog(LOG_ERR, "fork: %m");
594                                if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
595                                        close(ctrl);
596                                sigprocmask(SIG_UNBLOCK, &sig_block, NULL);
597                                sleep(1);
598                                continue;
599                        }
600                        if (pid != 0 && sep->se_wait) {
601                                sep->se_wait = pid;
602                                FD_CLR(sep->se_fd, &allsock);
603                                nsock--;
604                        }
605                        if (pid == 0) {
606                                sigemptyset(&sa.sa_mask);
607                                sa.sa_handler = SIG_DFL;
608                                sigaction(SIGPIPE, &sa, NULL);
609                                if (debug)
610                                        setsid();
611                        }
612                }
613                sigprocmask(SIG_UNBLOCK, &sig_block, NULL);
614                if (pid == 0) {
615                        run_service(ctrl, sep);
616                        if (dofork)
617                                exit(0);
618                }
619                if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
620                        close(ctrl);
621            }
622            }
623        }
624}
625
626void
627run_service(ctrl, sep)
628        int ctrl;
629        struct servtab *sep;
630{
631        struct passwd *pwd;
632        struct group *grp = NULL;       /* XXX gcc */
633        char buf[7];
634#ifdef LIBWRAP
635        struct request_info req;
636        int denied;
637        char *service = NULL;   /* XXX gcc */
638#endif
639
640#ifdef LIBWRAP
641#ifndef LIBWRAP_INTERNAL
642        if (sep->se_bi == 0)
643#endif
644        if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
645                request_init(&req, RQ_DAEMON, sep->se_argv[0] ?
646                    sep->se_argv[0] : sep->se_service, RQ_FILE, ctrl, NULL);
647                fromhost(&req);
648                denied = !hosts_access(&req);
649                if (denied || lflag) {
650                        sp = getservbyport(sep->se_ctrladdr_in.sin_port,
651                            sep->se_proto);
652                        if (sp == NULL) {
653                                (void)sprintf(buf, "%d",
654                                    ntohs(sep->se_ctrladdr_in.sin_port));
655                                service = buf;
656                        } else
657                                service = sp->s_name;
658                }
659                if (denied) {
660                        syslog(deny_severity,
661                            "refused connection from %.500s, service %s (%s)",
662                            eval_client(&req), service, sep->se_proto);
663                        goto reject;
664                }
665                if (lflag) {
666                        syslog(allow_severity,
667                            "connection from %.500s, service %s (%s)",
668                            eval_client(&req), service, sep->se_proto);
669                }
670        }
671#endif /* LIBWRAP */
672
673        if (sep->se_bi) {
674                (*sep->se_bi->bi_fn)(ctrl, sep);
675        } else {
676                if ((pwd = getpwnam(sep->se_user)) == NULL) {
677                        syslog(LOG_ERR, "%s/%s: %s: No such user",
678                            sep->se_service, sep->se_proto, sep->se_user);
679                        goto reject;
680                }
681                if (sep->se_group &&
682                    (grp = getgrnam(sep->se_group)) == NULL) {
683                        syslog(LOG_ERR, "%s/%s: %s: No such group",
684                            sep->se_service, sep->se_proto, sep->se_group);
685                        goto reject;
686                }
687                if (pwd->pw_uid) {
688                        if (sep->se_group)
689                                pwd->pw_gid = grp->gr_gid;
690                        if (setgid(pwd->pw_gid) < 0) {
691                                syslog(LOG_ERR,
692                                 "%s/%s: can't set gid %d: %m", sep->se_service,
693                                    sep->se_proto, pwd->pw_gid);
694                                goto reject;
695                        }
696                        (void) initgroups(pwd->pw_name,
697                            pwd->pw_gid);
698                        if (setuid(pwd->pw_uid) < 0) {
699                                syslog(LOG_ERR,
700                                 "%s/%s: can't set uid %d: %m", sep->se_service,
701                                    sep->se_proto, pwd->pw_uid);
702                                goto reject;
703                        }
704                } else if (sep->se_group) {
705                        (void) setgid((gid_t)grp->gr_gid);
706                }
707                if (debug)
708                        fprintf(stderr, "%d execl %s\n",
709                            getpid(), sep->se_server);
710#ifdef MULOG
711                if (sep->se_log)
712                        dolog(sep, ctrl);
713#endif
714                /* Set our control descriptor to not close-on-exec... */
715                if (fcntl(ctrl, F_SETFD, 0) < 0)
716                        syslog(LOG_ERR, "fcntl (F_SETFD, 0): %m");
717                /* ...and dup it to stdin, stdout, and stderr. */
718                if (ctrl != 0) {
719                        dup2(ctrl, 0);
720                        close(ctrl);
721                        ctrl = 0;
722                }
723                dup2(0, 1);
724                dup2(0, 2);
725#ifdef RLIMIT_NOFILE
726                if (rlim_ofile.rlim_cur != rlim_ofile_cur &&
727                    setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0)
728                        syslog(LOG_ERR, "setrlimit: %m");
729#endif
730                execv(sep->se_server, sep->se_argv);
731                syslog(LOG_ERR, "cannot execute %s: %m", sep->se_server);
732        reject:
733                if (sep->se_socktype != SOCK_STREAM)
734                        recv(ctrl, buf, sizeof (buf), 0);
735                _exit(1);
736        }
737}
738
739void
740reapchild(signo)
741        int signo;
742{
743        int status;
744        pid_t pid;
745        struct servtab *sep;
746
747        for (;;) {
748                pid = wait3(&status, WNOHANG, (struct rusage *)0);
749                if (pid <= 0)
750                        break;
751                if (debug)
752                        fprintf(stderr, "%d reaped, status %#x\n",
753                            pid, status);
754                for (sep = servtab; sep; sep = sep->se_next)
755                        if (sep->se_wait == pid) {
756                                if (WIFEXITED(status) && WEXITSTATUS(status))
757                                        syslog(LOG_WARNING,
758                                            "%s: exit status 0x%x",
759                                            sep->se_server, WEXITSTATUS(status));
760                                else if (WIFSIGNALED(status))
761                                        syslog(LOG_WARNING,
762                                            "%s: exit signal 0x%x",
763                                            sep->se_server, WTERMSIG(status));
764                                sep->se_wait = 1;
765                                FD_SET(sep->se_fd, &allsock);
766                                nsock++;
767                                if (debug)
768                                        fprintf(stderr, "restored %s, fd %d\n",
769                                            sep->se_service, sep->se_fd);
770                        }
771        }
772}
773
774void
775config(signo)
776        int signo;
777{
778        struct servtab *sep, *cp, **sepp;
779        sigset_t omask;
780        int n;
781
782        if (!setconfig()) {
783                syslog(LOG_ERR, "%s: %m", CONFIG);
784                return;
785        }
786        for (sep = servtab; sep; sep = sep->se_next)
787                sep->se_checked = 0;
788        while ((cp = getconfigent())) {
789                for (sep = servtab; sep; sep = sep->se_next)
790                        if (strcmp(sep->se_service, cp->se_service) == 0 &&
791                            strcmp(sep->se_hostaddr, cp->se_hostaddr) == 0 &&
792                            strcmp(sep->se_proto, cp->se_proto) == 0 &&
793                            ISMUX(sep) == ISMUX(cp))
794                                break;
795                if (sep != 0) {
796                        int i;
797
798#define SWAP(type, a, b) {type c=a; a=b; b=c;}
799
800                        sigprocmask(SIG_BLOCK, &sig_block, &omask);
801                        /*
802                         * sep->se_wait may be holding the pid of a daemon
803                         * that we're waiting for.  If so, don't overwrite
804                         * it unless the config file explicitly says don't
805                         * wait.
806                         */
807                        if (cp->se_bi == 0 &&
808                            (sep->se_wait == 1 || cp->se_wait == 0))
809                                sep->se_wait = cp->se_wait;
810                        SWAP(char *, sep->se_user, cp->se_user);
811                        SWAP(char *, sep->se_group, cp->se_group);
812                        SWAP(char *, sep->se_server, cp->se_server);
813                        for (i = 0; i < MAXARGV; i++)
814                                SWAP(char *, sep->se_argv[i], cp->se_argv[i]);
815                        SWAP(int, cp->se_type, sep->se_type);
816                        SWAP(int, cp->se_max, sep->se_max);
817#undef SWAP
818                        if (isrpcservice(sep))
819                                unregister_rpc(sep);
820                        sep->se_rpcversl = cp->se_rpcversl;
821                        sep->se_rpcversh = cp->se_rpcversh;
822                        sep->se_switched = cp->se_switched;
823                        sigprocmask(SIG_SETMASK, &omask, NULL);
824                        freeconfig(cp);
825                        if (debug)
826                                print_service("REDO", sep);
827                } else {
828                        sep = enter(cp);
829                        if (debug)
830                                print_service("ADD ", sep);
831                }
832                sep->se_checked = 1;
833
834                switch (sep->se_family) {
835                case AF_UNIX:
836                        if (sep->se_fd != -1) {
837                                if (!ISMUX(sep) &&
838                                    (sep->se_switched && !access_on)) {
839                                        close_sep(sep);
840                                        (void)unlink(sep->se_service);
841                                }
842                                break;
843                        }
844                        n = strlen(sep->se_service);
845                        if (n > sizeof(sep->se_ctrladdr_un.sun_path)) {
846                                syslog(LOG_ERR, "%s: address too long",
847                                    sep->se_service);
848                                sep->se_checked = 0;
849                                continue;
850                        }
851                        (void)unlink(sep->se_service);
852                        strncpy(sep->se_ctrladdr_un.sun_path,
853                            sep->se_service, n);
854                        sep->se_ctrladdr_un.sun_family = AF_UNIX;
855                        sep->se_ctrladdr_size = n +
856                            sizeof(sep->se_ctrladdr_un) -
857                            sizeof(sep->se_ctrladdr_un.sun_path);
858                        if (!ISMUX(sep) && (!sep->se_switched || access_on))
859                                setup(sep);
860                        break;
861                case AF_INET:
862                        sep->se_ctrladdr_in.sin_family = AF_INET;
863                        if (!strcmp(sep->se_hostaddr,"*"))
864                                sep->se_ctrladdr_in.sin_addr.s_addr =
865                                    INADDR_ANY;
866                        else if ((sep->se_ctrladdr_in.sin_addr.s_addr =
867                                  inet_addr(sep->se_hostaddr)) == -1) {
868                                /* Do we really want to support hostname lookups here? */
869                                struct hostent *hp;
870                                hp = gethostbyname(sep->se_hostaddr);
871                                if (hp == 0) {
872                                        syslog(LOG_ERR, "%s: unknown host",
873                                            sep->se_hostaddr);
874                                        sep->se_checked = 0;
875                                        continue;
876                                } else if (hp->h_addrtype != AF_INET) {
877                                        syslog(LOG_ERR,
878                                       "%s: address isn't an Internet address",
879                                            sep->se_hostaddr);
880                                        sep->se_checked = 0;
881                                        continue;
882                                } else if (hp->h_length != sizeof(struct in_addr)) {
883                                        syslog(LOG_ERR,
884                       "%s: address size wrong (under DNS corruption attack?)",
885                                            sep->se_hostaddr);
886                                        sep->se_checked = 0;
887                                        continue;
888                                } else {
889                                        memcpy(&sep->se_ctrladdr_in.sin_addr,
890                                            hp->h_addr_list[0],
891                                            sizeof(struct in_addr));
892                                }
893                        }
894                        if (ISMUX(sep)) {
895                                sep->se_fd = -1;
896                                continue;
897                        }
898                        sep->se_ctrladdr_size = sizeof(sep->se_ctrladdr_in);
899                        if (isrpcservice(sep)) {
900                                struct rpcent *rp;
901
902                                sep->se_rpcprog = atoi(sep->se_service);
903                                if (sep->se_rpcprog == 0) {
904                                        rp = getrpcbyname(sep->se_service);
905                                        if (rp == 0) {
906                                                syslog(LOG_ERR,
907                                                    "%s/%s: unknown service",
908                                                    sep->se_service,
909                                                    sep->se_proto);
910                                                sep->se_checked = 0;
911                                                continue;
912                                        }
913                                        sep->se_rpcprog = rp->r_number;
914                                }
915                                if (sep->se_fd == -1 && !ISMUX(sep) &&
916                                    (!sep->se_switched || access_on))
917                                        setup(sep);
918                                else if (sep->se_fd != -1 && !ISMUX(sep) &&
919                                         (sep->se_switched && !access_on)) {
920                                        close_sep(sep);
921                                        unregister_rpc(sep);
922                                }
923                                if (sep->se_fd != -1)
924                                        register_rpc(sep);
925                        } else {
926                                u_short port = htons(atoi(sep->se_service));
927
928                                if (!port) {
929                                        sp = getservbyname(sep->se_service,
930                                            sep->se_proto);
931                                        if (sp == 0) {
932                                                syslog(LOG_ERR,
933                                                    "%s/%s: unknown service",
934                                                    sep->se_service,
935                                                    sep->se_proto);
936                                                sep->se_checked = 0;
937                                                continue;
938                                        }
939                                        port = sp->s_port;
940                                }
941                                if (port != sep->se_ctrladdr_in.sin_port) {
942                                        sep->se_ctrladdr_in.sin_port = port;
943                                        if (sep->se_fd >= 0)
944                                                close_sep(sep);
945                                }
946                                if (sep->se_fd == -1 && !ISMUX(sep) &&
947                                    (!sep->se_switched || access_on))
948                                        setup(sep);
949                                else if (sep->se_fd != -1 && !ISMUX(sep) &&
950                                         (sep->se_switched && !access_on))
951                                        close_sep(sep);
952                        }
953                }
954        }
955        endconfig();
956        /*
957         * Purge anything not looked at above.
958         */
959        sigprocmask(SIG_BLOCK, &sig_block, &omask);
960        sepp = &servtab;
961        while ((sep = *sepp)) {
962                if (sep->se_checked) {
963                        sepp = &sep->se_next;
964                        continue;
965                }
966                *sepp = sep->se_next;
967                if (sep->se_fd >= 0)
968                        close_sep(sep);
969                if (isrpcservice(sep))
970                        unregister_rpc(sep);
971                if (sep->se_family == AF_UNIX)
972                        (void)unlink(sep->se_service);
973                if (debug)
974                        print_service("FREE", sep);
975                freeconfig(sep);
976                free((char *)sep);
977        }
978        sigprocmask(SIG_SETMASK, &omask, NULL);
979}
980
981void
982access_switch(signo)
983        int signo;
984{
985        struct servtab *sep, **sepp;
986        sigset_t omask;
987        int on;
988
989        on = signo == SIGUSR1;
990        if (on == access_on)
991                return;
992
993        sigprocmask(SIG_BLOCK, &sig_block, &omask);
994        access_on = on;
995        sepp = &servtab;
996        while (sep = *sepp) {
997                sepp = &sep->se_next;
998                if (!sep->se_switched)
999                        continue;
1000                if (access_on)
1001                        setup(sep);
1002                else
1003                        close_sep(sep);
1004        }
1005        sigprocmask(SIG_SETMASK, &omask, NULL);
1006}
1007
1008void
1009retry(signo)
1010        int signo;
1011{
1012        struct servtab *sep;
1013
1014        timingout = 0;
1015        for (sep = servtab; sep; sep = sep->se_next) {
1016                if (sep->se_fd == -1 && !ISMUX(sep) &&
1017                    (!sep->se_switched || access_on)) {
1018                        switch (sep->se_family) {
1019                        case AF_UNIX:
1020                        case AF_INET:
1021                                setup(sep);
1022                                if (sep->se_fd != -1 && isrpcservice(sep))
1023                                        register_rpc(sep);
1024                                break;
1025                        }
1026                }
1027        }
1028}
1029
1030void
1031goaway(signo)
1032        int signo;
1033{
1034        struct servtab *sep;
1035
1036        for (sep = servtab; sep; sep = sep->se_next) {
1037                if (sep->se_fd == -1)
1038                        continue;
1039
1040                switch (sep->se_family) {
1041                case AF_UNIX:
1042                        (void)unlink(sep->se_service);
1043                        break;
1044                case AF_INET:
1045                        if (sep->se_wait == 1 && isrpcservice(sep))
1046                                unregister_rpc(sep);
1047                        break;
1048                }
1049                (void)close(sep->se_fd);
1050        }
1051        (void)unlink(_PATH_INETDPID);
1052        exit(0);
1053}
1054
1055void
1056setup(sep)
1057        struct servtab *sep;
1058{
1059        int on = 1;
1060
1061        if ((sep->se_fd = socket(sep->se_family, sep->se_socktype, 0)) < 0) {
1062                if (debug)
1063                        fprintf(stderr, "socket failed on %s/%s: %s\n",
1064                            sep->se_service, sep->se_proto, strerror(errno));
1065                syslog(LOG_ERR, "%s/%s: socket: %m",
1066                    sep->se_service, sep->se_proto);
1067                return;
1068        }
1069        /* Set all listening sockets to close-on-exec. */
1070        if (fcntl(sep->se_fd, F_SETFD, FD_CLOEXEC) < 0)
1071                syslog(LOG_ERR, "fcntl (F_SETFD, FD_CLOEXEC): %m");
1072#define turnon(fd, opt) \
1073setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
1074        if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) &&
1075            turnon(sep->se_fd, SO_DEBUG) < 0)
1076                syslog(LOG_ERR, "setsockopt (SO_DEBUG): %m");
1077        if (turnon(sep->se_fd, SO_REUSEADDR) < 0)
1078                syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
1079#undef turnon
1080        if (bind(sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size) < 0) {
1081                if (debug)
1082                        fprintf(stderr, "bind failed on %s/%s: %s\n",
1083                            sep->se_service, sep->se_proto, strerror(errno));
1084                syslog(LOG_ERR, "%s/%s: bind: %m",
1085                    sep->se_service, sep->se_proto);
1086                (void) close(sep->se_fd);
1087                sep->se_fd = -1;
1088                if (!timingout) {
1089                        timingout = 1;
1090                        alarm(RETRYTIME);
1091                }
1092                return;
1093        }
1094        if (sep->se_socktype == SOCK_STREAM)
1095                listen(sep->se_fd, 10);
1096
1097        FD_SET(sep->se_fd, &allsock);
1098        nsock++;
1099        if (sep->se_fd > maxsock) {
1100                maxsock = sep->se_fd;
1101                if (maxsock > rlim_ofile_cur - FD_MARGIN)
1102                        bump_nofile();
1103        }
1104        if (debug)
1105                fprintf(stderr, "registered %s on %d\n",
1106                    sep->se_server, sep->se_fd);
1107}
1108
1109/*
1110 * Finish with a service and its socket.
1111 */
1112void
1113close_sep(sep)
1114        struct servtab *sep;
1115{
1116        if (sep->se_fd >= 0) {
1117                nsock--;
1118                FD_CLR(sep->se_fd, &allsock);
1119                (void) close(sep->se_fd);
1120                sep->se_fd = -1;
1121        }
1122        sep->se_count = 0;
1123        /*
1124         * Don't keep the pid of this running deamon: when reapchild()
1125         * reaps this pid, it would erroneously increment nsock.
1126         */
1127        if (sep->se_wait > 1)
1128                sep->se_wait = 1;
1129}
1130
1131void
1132register_rpc(sep)
1133        struct servtab *sep;
1134{
1135#ifdef RPC
1136        int n;
1137        struct sockaddr_in sin;
1138        struct protoent *pp;
1139
1140        if ((pp = getprotobyname(sep->se_proto+4)) == NULL) {
1141                syslog(LOG_ERR, "%s: getproto: %m",
1142                    sep->se_proto);
1143                return;
1144        }
1145        n = sizeof sin;
1146        if (getsockname(sep->se_fd, (struct sockaddr *)&sin, &n) < 0) {
1147                syslog(LOG_ERR, "%s/%s: getsockname: %m",
1148                    sep->se_service, sep->se_proto);
1149                return;
1150        }
1151
1152        for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
1153                if (debug)
1154                        fprintf(stderr, "pmap_set: %u %u %u %u\n",
1155                            sep->se_rpcprog, n, pp->p_proto,
1156                            ntohs(sin.sin_port));
1157                (void)pmap_unset(sep->se_rpcprog, n);
1158                if (!pmap_set(sep->se_rpcprog, n, pp->p_proto, ntohs(sin.sin_port)))
1159                        syslog(LOG_ERR, "pmap_set: %u %u %u %u: %m",
1160                            sep->se_rpcprog, n, pp->p_proto,
1161                            ntohs(sin.sin_port));
1162        }
1163#endif /* RPC */
1164}
1165
1166void
1167unregister_rpc(sep)
1168        struct servtab *sep;
1169{
1170#ifdef RPC
1171        int n;
1172
1173        for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
1174                if (debug)
1175                        fprintf(stderr, "pmap_unset(%u, %u)\n",
1176                            sep->se_rpcprog, n);
1177                if (!pmap_unset(sep->se_rpcprog, n))
1178                        syslog(LOG_ERR, "pmap_unset(%u, %u)\n",
1179                            sep->se_rpcprog, n);
1180        }
1181#endif /* RPC */
1182}
1183
1184
1185struct servtab *
1186enter(cp)
1187        struct servtab *cp;
1188{
1189        struct servtab *sep;
1190        sigset_t omask;
1191
1192        sep = (struct servtab *)malloc(sizeof (*sep));
1193        if (sep == (struct servtab *)0) {
1194                syslog(LOG_ERR, "Out of memory.");
1195                exit(-1);
1196        }
1197        *sep = *cp;
1198        sep->se_fd = -1;
1199        sep->se_rpcprog = -1;
1200        sigprocmask(SIG_BLOCK, &sig_block, &omask);
1201        sep->se_next = servtab;
1202        servtab = sep;
1203        sigprocmask(SIG_SETMASK, &omask, NULL);
1204        return (sep);
1205}
1206
1207FILE    *fconfig = NULL;
1208struct  servtab serv;
1209char    line[BUFSIZ];
1210char    *defhost;
1211
1212int
1213setconfig()
1214{
1215        if (defhost) free(defhost);
1216        defhost = newstr("*");
1217        if (fconfig != NULL) {
1218                fseek(fconfig, 0L, SEEK_SET);
1219                return (1);
1220        }
1221        fconfig = fopen(CONFIG, "r");
1222        return (fconfig != NULL);
1223}
1224
1225void
1226endconfig()
1227{
1228        if (fconfig) {
1229                (void) fclose(fconfig);
1230                fconfig = NULL;
1231        }
1232        if (defhost) {
1233                free(defhost);
1234                defhost = 0;
1235        }
1236}
1237
1238struct servtab *
1239getconfigent()
1240{
1241        struct servtab *sep = &serv;
1242        int argc;
1243        char *cp, *arg;
1244        static char TCPMUX_TOKEN[] = "tcpmux/";
1245#define MUX_LEN         (sizeof(TCPMUX_TOKEN)-1)
1246        char *hostdelim;
1247
1248more:
1249#ifdef MULOG
1250        while ((cp = nextline(fconfig)) && (*cp == '#' || *cp == '\0')) {
1251                /* Avoid use of `skip' if there is a danger of it looking
1252                 * at continuation lines.
1253                 */
1254                do {
1255                        cp++;
1256                } while (*cp == ' ' || *cp == '\t');
1257                if (*cp == '\0')
1258                        continue;
1259                if ((arg = skip(&cp)) == NULL)
1260                        continue;
1261                if (strcmp(arg, "DOMAIN"))
1262                        continue;
1263                if (curdom)
1264                        free(curdom);
1265                curdom = NULL;
1266                while (*cp == ' ' || *cp == '\t')
1267                        cp++;
1268                if (*cp == '\0')
1269                        continue;
1270                arg = cp;
1271                while (*cp && *cp != ' ' && *cp != '\t')
1272                        cp++;
1273                if (*cp != '\0')
1274                        *cp++ = '\0';
1275                curdom = newstr(arg);
1276        }
1277#else
1278        while ((cp = nextline(fconfig)) && (*cp == '#' || *cp == '\0'))
1279                ;
1280#endif
1281        if (cp == NULL)
1282                return ((struct servtab *)0);
1283        /*
1284         * clear the static buffer, since some fields (se_ctrladdr,
1285         * for example) don't get initialized here.
1286         */
1287        memset((caddr_t)sep, 0, sizeof *sep);
1288        arg = skip(&cp);
1289        if (cp == NULL) {
1290                /* got an empty line containing just blanks/tabs. */
1291                goto more;
1292        }
1293        /* Check for a host name. */
1294        hostdelim = strrchr(arg, ':');
1295        if (hostdelim) {
1296                *hostdelim = '\0';
1297                sep->se_hostaddr = newstr(arg);
1298                arg = hostdelim + 1;
1299                /*
1300                 * If the line is of the form `host:', then just change the
1301                 * default host for the following lines.
1302                 */
1303                if (*arg == '\0') {
1304                        arg = skip(&cp);
1305                        if (cp == NULL) {
1306                                free(defhost);
1307                                defhost = sep->se_hostaddr;
1308                                goto more;
1309                        }
1310                }
1311        } else
1312                sep->se_hostaddr = newstr(defhost);
1313        if (strncmp(arg, TCPMUX_TOKEN, MUX_LEN) == 0) {
1314                char *c = arg + MUX_LEN;
1315                if (*c == '+') {
1316                        sep->se_type = MUXPLUS_TYPE;
1317                        c++;
1318                } else
1319                        sep->se_type = MUX_TYPE;
1320                sep->se_service = newstr(c);
1321        } else {
1322                sep->se_service = newstr(arg);
1323                sep->se_type = NORM_TYPE;
1324        }
1325
1326        arg = sskip(&cp);
1327        if (strcmp(arg, "stream") == 0)
1328                sep->se_socktype = SOCK_STREAM;
1329        else if (strcmp(arg, "dgram") == 0)
1330                sep->se_socktype = SOCK_DGRAM;
1331        else if (strcmp(arg, "rdm") == 0)
1332                sep->se_socktype = SOCK_RDM;
1333        else if (strcmp(arg, "seqpacket") == 0)
1334                sep->se_socktype = SOCK_SEQPACKET;
1335        else if (strcmp(arg, "raw") == 0)
1336                sep->se_socktype = SOCK_RAW;
1337        else
1338                sep->se_socktype = -1;
1339
1340        sep->se_proto = newstr(sskip(&cp));
1341        if (strcmp(sep->se_proto, "unix") == 0) {
1342                sep->se_family = AF_UNIX;
1343        } else {
1344                sep->se_family = AF_INET;
1345                if (strncmp(sep->se_proto, "rpc/", 4) == 0) {
1346#ifdef RPC
1347                        char *cp, *ccp;
1348                        cp = strchr(sep->se_service, '/');
1349                        if (cp == 0) {
1350                                syslog(LOG_ERR, "%s: no rpc version",
1351                                    sep->se_service);
1352                                goto more;
1353                        }
1354                        *cp++ = '\0';
1355                        sep->se_rpcversl = sep->se_rpcversh =
1356                            strtol(cp, &ccp, 0);
1357                        if (ccp == cp) {
1358                badafterall:
1359                                syslog(LOG_ERR, "%s/%s: bad rpc version",
1360                                    sep->se_service, cp);
1361                                goto more;
1362                        }
1363                        if (*ccp == '-') {
1364                                cp = ccp + 1;
1365                                sep->se_rpcversh = strtol(cp, &ccp, 0);
1366                                if (ccp == cp)
1367                                        goto badafterall;
1368                        }
1369#else
1370                        syslog(LOG_ERR, "%s: rpc services not suported",
1371                            sep->se_service);
1372                        goto more;
1373#endif /* RPC */
1374                }
1375        }
1376        arg = sskip(&cp);
1377        {
1378                char *cp;
1379                cp = strchr(arg, '.');
1380                if (cp) {
1381                        *cp++ = '\0';
1382                        sep->se_max = atoi(cp);
1383                } else
1384                        sep->se_max = TOOMANY;
1385        }
1386        sep->se_wait = strcmp(arg, "wait") == 0;
1387        if (ISMUX(sep)) {
1388                /*
1389                 * Silently enforce "nowait" for TCPMUX services since
1390                 * they don't have an assigned port to listen on.
1391                 */
1392                sep->se_wait = 0;
1393
1394                if (strcmp(sep->se_proto, "tcp")) {
1395                        syslog(LOG_ERR,
1396                            "%s: bad protocol for tcpmux service %s",
1397                            CONFIG, sep->se_service);
1398                        goto more;
1399                }
1400                if (sep->se_socktype != SOCK_STREAM) {
1401                        syslog(LOG_ERR,
1402                            "%s: bad socket type for tcpmux service %s",
1403                            CONFIG, sep->se_service);
1404                        goto more;
1405                }
1406        }
1407        arg = sskip(&cp);
1408        sep->se_switched = strcmp(arg, "switched") == 0;
1409        sep->se_user = newstr(sskip(&cp));
1410        if ((sep->se_group = strchr(sep->se_user, '.')))
1411                *sep->se_group++ = '\0';
1412        sep->se_server = newstr(sskip(&cp));
1413        if (strcmp(sep->se_server, "internal") == 0) {
1414                struct biltin *bi;
1415
1416                for (bi = biltins; bi->bi_service; bi++)
1417                        if (bi->bi_socktype == sep->se_socktype &&
1418                            strcmp(bi->bi_service, sep->se_service) == 0)
1419                                break;
1420                if (bi->bi_service == 0) {
1421                        syslog(LOG_ERR, "internal service %s unknown",
1422                            sep->se_service);
1423                        goto more;
1424                }
1425                sep->se_bi = bi;
1426                sep->se_wait = bi->bi_wait;
1427        } else
1428                sep->se_bi = NULL;
1429        argc = 0;
1430        for (arg = skip(&cp); cp; arg = skip(&cp)) {
1431#if MULOG
1432                char *colon;
1433
1434                if (argc == 0 && (colon = strrchr(arg, ':'))) {
1435                        while (arg < colon) {
1436                                int     x;
1437                                char    *ccp;
1438
1439                                switch (*arg++) {
1440                                case 'l':
1441                                        x = 1;
1442                                        if (isdigit(*arg)) {
1443                                                x = strtol(arg, &ccp, 0);
1444                                                if (ccp == arg)
1445                                                        break;
1446                                                arg = ccp;
1447                                        }
1448                                        sep->se_log &= ~MULOG_RFC931;
1449                                        sep->se_log |= x;
1450                                        break;
1451                                case 'a':
1452                                        sep->se_log |= MULOG_RFC931;
1453                                        break;
1454                                default:
1455                                        break;
1456                                }
1457                        }
1458                        arg = colon + 1;
1459                }
1460#endif
1461                if (argc < MAXARGV)
1462                        sep->se_argv[argc++] = newstr(arg);
1463        }
1464        while (argc <= MAXARGV)
1465                sep->se_argv[argc++] = NULL;
1466        return (sep);
1467}
1468
1469void
1470freeconfig(cp)
1471        struct servtab *cp;
1472{
1473        int i;
1474
1475        if (cp->se_hostaddr)
1476                free(cp->se_hostaddr);
1477        if (cp->se_service)
1478                free(cp->se_service);
1479        if (cp->se_proto)
1480                free(cp->se_proto);
1481        if (cp->se_user)
1482                free(cp->se_user);
1483        /* Note: se_group is part of the newstr'ed se_user */
1484        if (cp->se_server)
1485                free(cp->se_server);
1486        for (i = 0; i < MAXARGV; i++)
1487                if (cp->se_argv[i])
1488                        free(cp->se_argv[i]);
1489}
1490
1491
1492/*
1493 * Safe skip - if skip returns null, log a syntax error in the
1494 * configuration file and exit.
1495 */
1496char *
1497sskip(cpp)
1498        char **cpp;
1499{
1500        char *cp;
1501
1502        cp = skip(cpp);
1503        if (cp == NULL) {
1504                syslog(LOG_ERR, "%s: syntax error", CONFIG);
1505                exit(-1);
1506        }
1507        return (cp);
1508}
1509
1510char *
1511skip(cpp)
1512        char **cpp;
1513{
1514        char *cp = *cpp;
1515        char *start;
1516
1517        if (*cpp == NULL)
1518                return ((char *)0);
1519
1520again:
1521        while (*cp == ' ' || *cp == '\t')
1522                cp++;
1523        if (*cp == '\0') {
1524                int c;
1525
1526                c = getc(fconfig);
1527                (void) ungetc(c, fconfig);
1528                if (c == ' ' || c == '\t')
1529                        if ((cp = nextline(fconfig)))
1530                                goto again;
1531                *cpp = (char *)0;
1532                return ((char *)0);
1533        }
1534        start = cp;
1535        while (*cp && *cp != ' ' && *cp != '\t')
1536                cp++;
1537        if (*cp != '\0')
1538                *cp++ = '\0';
1539        *cpp = cp;
1540        return (start);
1541}
1542
1543char *
1544nextline(fd)
1545        FILE *fd;
1546{
1547        char *cp;
1548
1549        if (fgets(line, sizeof (line), fd) == NULL)
1550                return ((char *)0);
1551        cp = strchr(line, '\n');
1552        if (cp)
1553                *cp = '\0';
1554        return (line);
1555}
1556
1557char *
1558newstr(cp)
1559        char *cp;
1560{
1561        if ((cp = strdup(cp ? cp : "")))
1562                return (cp);
1563        syslog(LOG_ERR, "strdup: %m");
1564        exit(-1);
1565}
1566
1567void
1568inetd_setproctitle(a, s)
1569        char *a;
1570        int s;
1571{
1572        int size;
1573        char *cp;
1574        struct sockaddr_in sin;
1575        char buf[80];
1576
1577        cp = Argv[0];
1578        size = sizeof(sin);
1579        if (getpeername(s, (struct sockaddr *)&sin, &size) == 0)
1580                (void)sprintf(buf, "-%.*s [%s]", sizeof(buf) - 20, a,
1581                    inet_ntoa(sin.sin_addr));
1582        else
1583                (void)sprintf(buf, "-%.*s", sizeof(buf) - 2, a);
1584        strncpy(cp, buf, LastArg - cp);
1585        cp += strlen(cp);
1586        while (cp < LastArg)
1587                *cp++ = ' ';
1588}
1589
1590void
1591logpid()
1592{
1593        FILE *fp;
1594
1595        if ((fp = fopen(_PATH_INETDPID, "w")) != NULL) {
1596                fprintf(fp, "%u\n", getpid());
1597                (void)fclose(fp);
1598        }
1599}
1600
1601void
1602bump_nofile()
1603{
1604#ifdef RLIMIT_NOFILE
1605
1606#define FD_CHUNK        32
1607
1608        struct rlimit rl;
1609
1610        if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
1611                syslog(LOG_ERR, "getrlimit: %m");
1612                return;
1613        }
1614#ifndef MIN
1615#define MIN(x,y) ( (x) < (y) ? (x) : (y) )
1616#endif
1617        rl.rlim_cur = MIN(rl.rlim_max, rl.rlim_cur + FD_CHUNK);
1618        if (rl.rlim_cur <= rlim_ofile_cur) {
1619                syslog(LOG_ERR,
1620                    "bump_nofile: cannot extend file limit, max = %d",
1621                    (int)rl.rlim_cur);
1622                return;
1623        }
1624
1625        if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
1626                syslog(LOG_ERR, "setrlimit: %m");
1627                return;
1628        }
1629
1630        rlim_ofile_cur = rl.rlim_cur;
1631        return;
1632
1633#else
1634        syslog(LOG_ERR, "bump_nofile: cannot extend file limit");
1635        return;
1636#endif
1637}
1638
1639/*
1640 * Internet services provided internally by inetd:
1641 */
1642#define BUFSIZE 4096
1643
1644/* ARGSUSED */
1645void
1646echo_stream(s, sep)             /* Echo service -- echo data back */
1647        int s;
1648        struct servtab *sep;
1649{
1650        char buffer[BUFSIZE];
1651        int i;
1652
1653        inetd_setproctitle(sep->se_service, s);
1654        while ((i = read(s, buffer, sizeof(buffer))) > 0 &&
1655            write(s, buffer, i) > 0)
1656                ;
1657}
1658
1659/* ARGSUSED */
1660void
1661echo_dg(s, sep)                 /* Echo service -- echo data back */
1662        int s;
1663        struct servtab *sep;
1664{
1665        char buffer[BUFSIZE];
1666        int i, size;
1667        struct sockaddr sa;
1668
1669        size = sizeof(sa);
1670        if ((i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size)) < 0)
1671                return;
1672        (void) sendto(s, buffer, i, 0, &sa, sizeof(sa));
1673}
1674
1675/* ARGSUSED */
1676void
1677discard_stream(s, sep)          /* Discard service -- ignore data */
1678        int s;
1679        struct servtab *sep;
1680{
1681        char buffer[BUFSIZE];
1682
1683        inetd_setproctitle(sep->se_service, s);
1684        while ((errno = 0, read(s, buffer, sizeof(buffer)) > 0) ||
1685                        errno == EINTR)
1686                ;
1687}
1688
1689/* ARGSUSED */
1690void
1691discard_dg(s, sep)              /* Discard service -- ignore data */
1692        int s;
1693        struct servtab *sep;
1694{
1695        char buffer[BUFSIZE];
1696
1697        (void) read(s, buffer, sizeof(buffer));
1698}
1699
1700#include <ctype.h>
1701#define LINESIZ 72
1702char ring[128];
1703char *endring;
1704
1705void
1706initring()
1707{
1708        int i;
1709
1710        endring = ring;
1711
1712        for (i = 0; i <= 128; ++i)
1713                if (isprint(i))
1714                        *endring++ = i;
1715}
1716
1717/* ARGSUSED */
1718void
1719chargen_stream(s, sep)          /* Character generator */
1720        int s;
1721        struct servtab *sep;
1722{
1723        int len;
1724        char *rs, text[LINESIZ+2];
1725
1726        inetd_setproctitle(sep->se_service, s);
1727
1728        if (!endring) {
1729                initring();
1730                rs = ring;
1731        }
1732
1733        text[LINESIZ] = '\r';
1734        text[LINESIZ + 1] = '\n';
1735        for (rs = ring;;) {
1736                if ((len = endring - rs) >= LINESIZ)
1737                        memmove(text, rs, LINESIZ);
1738                else {
1739                        memmove(text, rs, len);
1740                        memmove(text + len, ring, LINESIZ - len);
1741                }
1742                if (++rs == endring)
1743                        rs = ring;
1744                if (write(s, text, sizeof(text)) != sizeof(text))
1745                        break;
1746        }
1747}
1748
1749/* ARGSUSED */
1750void
1751chargen_dg(s, sep)              /* Character generator */
1752        int s;
1753        struct servtab *sep;
1754{
1755        struct sockaddr sa;
1756        static char *rs;
1757        int len, size;
1758        char text[LINESIZ+2];
1759
1760        if (endring == 0) {
1761                initring();
1762                rs = ring;
1763        }
1764
1765        size = sizeof(sa);
1766        if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0)
1767                return;
1768
1769        if ((len = endring - rs) >= LINESIZ)
1770                memmove(text, rs, LINESIZ);
1771        else {
1772                memmove(text, rs, len);
1773                memmove(text + len, ring, LINESIZ - len);
1774        }
1775        if (++rs == endring)
1776                rs = ring;
1777        text[LINESIZ] = '\r';
1778        text[LINESIZ + 1] = '\n';
1779        (void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa));
1780}
1781
1782/*
1783 * Return a machine readable date and time, in the form of the
1784 * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
1785 * returns the number of seconds since midnight, Jan 1, 1970,
1786 * we must add 2208988800 seconds to this figure to make up for
1787 * some seventy years Bell Labs was asleep.
1788 */
1789
1790long
1791machtime()
1792{
1793        struct timeval tv;
1794
1795        if (gettimeofday(&tv, (struct timezone *)0) < 0) {
1796                if (debug)
1797                        fprintf(stderr, "Unable to get time of day\n");
1798                return (0L);
1799        }
1800#define OFFSET ((u_long)25567 * 24*60*60)
1801        return (htonl((long)(tv.tv_sec + OFFSET)));
1802#undef OFFSET
1803}
1804
1805/* ARGSUSED */
1806void
1807machtime_stream(s, sep)
1808        int s;
1809        struct servtab *sep;
1810{
1811        long result;
1812
1813        result = machtime();
1814        (void) write(s, (char *) &result, sizeof(result));
1815}
1816
1817/* ARGSUSED */
1818void
1819machtime_dg(s, sep)
1820        int s;
1821        struct servtab *sep;
1822{
1823        long result;
1824        struct sockaddr sa;
1825        int size;
1826
1827        size = sizeof(sa);
1828        if (recvfrom(s, (char *)&result, sizeof(result), 0, &sa, &size) < 0)
1829                return;
1830        result = machtime();
1831        (void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa));
1832}
1833
1834/* ARGSUSED */
1835void
1836daytime_stream(s, sep)          /* Return human-readable time of day */
1837        int s;
1838        struct servtab *sep;
1839{
1840        char buffer[256];
1841        time_t clock;
1842        int len;
1843
1844        clock = time((time_t *) 0);
1845
1846        len = sprintf(buffer, "%.24s\r\n", ctime(&clock));
1847        (void) write(s, buffer, len);
1848}
1849
1850/* ARGSUSED */
1851void
1852daytime_dg(s, sep)              /* Return human-readable time of day */
1853        int s;
1854        struct servtab *sep;
1855{
1856        char buffer[256];
1857        time_t clock;
1858        struct sockaddr sa;
1859        int size, len;
1860
1861        clock = time((time_t *) 0);
1862
1863        size = sizeof(sa);
1864        if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0)
1865                return;
1866        len = sprintf(buffer, "%.24s\r\n", ctime(&clock));
1867        (void) sendto(s, buffer, len, 0, &sa, sizeof(sa));
1868}
1869
1870/*
1871 * print_service:
1872 *      Dump relevant information to stderr
1873 */
1874void
1875print_service(action, sep)
1876        char *action;
1877        struct servtab *sep;
1878{
1879        if (isrpcservice(sep))
1880                fprintf(stderr,
1881                    "%s: %s rpcprog=%d, rpcvers = %d/%d, proto=%s, wait.max=%d.%d, switched=%d, user.group=%s.%s builtin=%lx server=%s\n",
1882                    action, sep->se_service,
1883                    sep->se_rpcprog, sep->se_rpcversh, sep->se_rpcversl, sep->se_proto,
1884                    sep->se_wait, sep->se_max, sep->se_switched, sep->se_user,
1885                    sep->se_group ? sep->se_group : "",
1886                    (long)sep->se_bi, sep->se_server);
1887        else
1888                fprintf(stderr,
1889                    "%s: %s proto=%s, wait.max=%d.%d, switched=%d, user.group=%s.%s builtin=%lx server=%s\n",
1890                    action, sep->se_service, sep->se_proto,
1891                    sep->se_wait, sep->se_max, sep->se_switched, sep->se_user,
1892                    sep->se_group ? sep->se_group : "",
1893                    (long)sep->se_bi, sep->se_server);
1894}
1895
1896void
1897usage()
1898{
1899
1900#ifdef LIBWRAP
1901        (void)fprintf(stderr, "usage: %s [-dl] [conf]\n", __progname);
1902#else
1903        (void)fprintf(stderr, "usage: %s [-d] [conf]\n", __progname);
1904#endif
1905        exit(1);
1906}
1907
1908
1909/*
1910 *  Based on TCPMUX.C by Mark K. Lottor November 1988
1911 *  sri-nic::ps:<mkl>tcpmux.c
1912 */
1913
1914static int              /* # of characters upto \r,\n or \0 */
1915getline(fd, buf, len)
1916        int fd;
1917        char *buf;
1918        int len;
1919{
1920        int count = 0, n;
1921
1922        do {
1923                n = read(fd, buf, len-count);
1924                if (n == 0)
1925                        return (count);
1926                if (n < 0)
1927                        return (-1);
1928                while (--n >= 0) {
1929                        if (*buf == '\r' || *buf == '\n' || *buf == '\0')
1930                                return (count);
1931                        count++;
1932                        buf++;
1933                }
1934        } while (count < len);
1935        return (count);
1936}
1937
1938#define MAX_SERV_LEN    (256+2)         /* 2 bytes for \r\n */
1939
1940#define strwrite(fd, buf)       (void) write(fd, buf, sizeof(buf)-1)
1941
1942void
1943tcpmux(ctrl, sep)
1944        int ctrl;
1945        struct servtab *sep;
1946{
1947        char service[MAX_SERV_LEN+1];
1948        int len;
1949
1950        /* Get requested service name */
1951        if ((len = getline(ctrl, service, MAX_SERV_LEN)) < 0) {
1952                strwrite(ctrl, "-Error reading service name\r\n");
1953                goto reject;
1954        }
1955        service[len] = '\0';
1956
1957        if (debug)
1958                fprintf(stderr, "tcpmux: someone wants %s\n", service);
1959
1960        /*
1961         * Help is a required command, and lists available services,
1962         * one per line.
1963         */
1964        if (!strcasecmp(service, "help")) {
1965                strwrite(ctrl, "+Available services:\r\n");
1966                strwrite(ctrl, "help\r\n");
1967                for (sep = servtab; sep; sep = sep->se_next) {
1968                        if (!ISMUX(sep))
1969                                continue;
1970                        (void)write(ctrl, sep->se_service,
1971                            strlen(sep->se_service));
1972                        strwrite(ctrl, "\r\n");
1973                }
1974                goto reject;
1975        }
1976
1977        /* Try matching a service in inetd.conf with the request */
1978        for (sep = servtab; sep; sep = sep->se_next) {
1979                if (!ISMUX(sep))
1980                        continue;
1981                if (!strcasecmp(service, sep->se_service)) {
1982                        if (ISMUXPLUS(sep))
1983                                strwrite(ctrl, "+Go\r\n");
1984                        run_service(ctrl, sep);
1985                        return;
1986                }
1987        }
1988        strwrite(ctrl, "-Service not available\r\n");
1989reject:
1990        _exit(1);
1991}
1992
1993
1994#ifdef MULOG
1995dolog(sep, ctrl)
1996        struct servtab *sep;
1997        int             ctrl;
1998{
1999        struct sockaddr         sa;
2000        struct sockaddr_in      *sin = (struct sockaddr_in *)&sa;
2001        int                     len = sizeof(sa);
2002        struct hostent          *hp;
2003        char                    *host, *dp, buf[BUFSIZ], *rfc931_name();
2004        int                     connected = 1;
2005
2006        if (sep->se_family != AF_INET)
2007                return;
2008
2009        if (getpeername(ctrl, &sa, &len) < 0) {
2010                if (errno != ENOTCONN) {
2011                        syslog(LOG_ERR, "getpeername: %m");
2012                        return;
2013                }
2014                if (recvfrom(ctrl, buf, sizeof(buf), MSG_PEEK, &sa, &len) < 0) {
2015                        syslog(LOG_ERR, "recvfrom: %m");
2016                        return;
2017                }
2018                connected = 0;
2019        }
2020        if (sa.sa_family != AF_INET) {
2021                syslog(LOG_ERR, "unexpected address family %u", sa.sa_family);
2022                return;
2023        }
2024
2025        hp = gethostbyaddr((char *) &sin->sin_addr.s_addr,
2026                                sizeof (sin->sin_addr.s_addr), AF_INET);
2027
2028        host = hp?hp->h_name:inet_ntoa(sin->sin_addr);
2029
2030        switch (sep->se_log & ~MULOG_RFC931) {
2031        case 0:
2032                return;
2033        case 1:
2034                if (curdom == NULL || *curdom == '\0')
2035                        break;
2036                dp = host + strlen(host) - strlen(curdom);
2037                if (dp < host)
2038                        break;
2039                if (debug)
2040                        fprintf(stderr, "check \"%s\" against curdom \"%s\"\n",
2041                            host, curdom);
2042                if (strcasecmp(dp, curdom) == 0)
2043                        return;
2044                break;
2045        case 2:
2046        default:
2047                break;
2048        }
2049
2050        openlog("", LOG_NOWAIT, MULOG);
2051
2052        if (connected && (sep->se_log & MULOG_RFC931))
2053                syslog(LOG_INFO, "%s@%s wants %s",
2054                    rfc931_name(sin, ctrl), host, sep->se_service);
2055        else
2056                syslog(LOG_INFO, "%s wants %s",
2057                    host, sep->se_service);
2058}
2059
2060/*
2061 * From tcp_log by
2062 *  Wietse Venema, Eindhoven University of Technology, The Netherlands.
2063 */
2064#if 0
2065static char sccsid[] = "@(#) rfc931.c 1.3 92/08/31 22:54:46";
2066#endif
2067
2068#include <setjmp.h>
2069
2070#define RFC931_PORT     113             /* Semi-well-known port */
2071#define TIMEOUT         4
2072#define TIMEOUT2        10
2073
2074static sigjmp_buf timebuf;
2075
2076/* timeout - handle timeouts */
2077
2078static void timeout(sig)
2079int     sig;
2080{
2081        siglongjmp(timebuf, sig);
2082}
2083
2084/* rfc931_name - return remote user name */
2085
2086char *
2087rfc931_name(there, ctrl)
2088struct sockaddr_in *there;              /* remote link information */
2089int     ctrl;
2090{
2091        struct sockaddr_in here;        /* local link information */
2092        struct sockaddr_in sin;         /* for talking to RFC931 daemon */
2093        int             length;
2094        int             s;
2095        unsigned        remote;
2096        unsigned        local;
2097        static char     user[256];              /* XXX */
2098        char            buf[256];
2099        char            *cp;
2100        char            *result = "USER_UNKNOWN";
2101        int             len;
2102        struct sigaction sa;
2103
2104        /* Find out local port number of our stdin. */
2105
2106        length = sizeof(here);
2107        if (getsockname(ctrl, (struct sockaddr *) &here, &length) == -1) {
2108                syslog(LOG_ERR, "getsockname: %m");
2109                return (result);
2110        }
2111        /* Set up timer so we won't get stuck. */
2112
2113        if ((s = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
2114                syslog(LOG_ERR, "socket: %m");
2115                return (result);
2116        }
2117
2118        sin = here;
2119        sin.sin_port = htons(0);
2120        if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) == -1) {
2121                syslog(LOG_ERR, "bind: %m");
2122                return (result);
2123        }
2124
2125        memset(&sa, 0, sizeof(sa));
2126        sa_handler = timeout;
2127        sigaction(SIGALRM, &sa, NULL);
2128        if (sigsetjmp(timebuf)) {
2129                close(s);                       /* not: fclose(fp) */
2130                return (result);
2131        }
2132        alarm(TIMEOUT);
2133
2134        /* Connect to the RFC931 daemon. */
2135
2136        sin = *there;
2137        sin.sin_port = htons(RFC931_PORT);
2138        if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) == -1) {
2139                close(s);
2140                alarm(0);
2141                return (result);
2142        }
2143
2144        /* Query the RFC 931 server. Would 13-byte writes ever be broken up? */
2145        (void)sprintf(buf, "%u,%u\r\n", ntohs(there->sin_port),
2146            ntohs(here.sin_port));
2147
2148
2149        for (len = 0, cp = buf; len < strlen(buf); ) {
2150                int     n;
2151
2152                if ((n = write(s, cp, strlen(buf) - len)) == -1) {
2153                        close(s);
2154                        alarm(0);
2155                        return (result);
2156                }
2157                cp += n;
2158                len += n;
2159        }
2160
2161        /* Read response */
2162        for (cp = buf; cp < buf + sizeof(buf) - 1; ) {
2163                char    c;
2164                if (read(s, &c, 1) != 1) {
2165                        close(s);
2166                        alarm(0);
2167                        return (result);
2168                }
2169                if (c == '\n')
2170                        break;
2171                *cp++ = c;
2172        }
2173        *cp = '\0';
2174
2175        if (sscanf(buf, "%u , %u : USERID :%*[^:]:%255s", &remote, &local, user) == 3
2176                && ntohs(there->sin_port) == remote
2177                && ntohs(here.sin_port) == local) {
2178
2179                /* Strip trailing carriage return. */
2180                if (cp = strchr(user, '\r'))
2181                        *cp = 0;
2182                result = user;
2183        }
2184
2185        alarm(0);
2186        close(s);
2187        return (result);
2188}
2189#endif
Note: See TracBrowser for help on using the repository browser.