1 /* vi: set sw=4 ts=4: */
2 /* $Slackware: inetd.c 1.79s 2001/02/06 13:18:00 volkerdi Exp $ */
3 /* $OpenBSD: inetd.c,v 1.79 2001/01/30 08:30:57 deraadt Exp $ */
4 /* $NetBSD: inetd.c,v 1.11 1996/02/22 11:14:41 mycroft Exp $ */
5 /* Busybox port by Vladimir Oleynik (C) 2001-2005 <dzo@simtreas.ru> */
6 /* IPv6 support, many bug fixes by Denys Vlasenko (c) 2008 */
8 * Copyright (c) 1983,1991 The Regents of the University of California.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the University of
22 * California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS" AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 /* Inetd - Internet super-server
42 * This program invokes configured services when a connection
43 * from a peer is established or a datagram arrives.
44 * Connection-oriented services are invoked each time a
45 * connection is made, by creating a process. This process
46 * is passed the connection as file descriptor 0 and is
47 * expected to do a getpeername to find out peer's host
49 * Datagram oriented services are invoked when a datagram
50 * arrives; a process is created and passed a pending message
51 * on file descriptor 0. peer's address can be obtained
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 begin with
58 * a space or tab. All fields must be present in each entry.
60 * service_name must be in /etc/services
61 * socket_type stream/dgram/raw/rdm/seqpacket
62 * protocol must be in /etc/protocols
63 * (usually "tcp" or "udp")
64 * wait/nowait[.max] single-threaded/multi-threaded, max #
65 * user[.group] or user[:group] user/group to run daemon as
66 * server_program full path name
67 * server_program_arguments maximum of MAXARGS (20)
70 * service_name/version must be in /etc/rpc
71 * socket_type stream/dgram/raw/rdm/seqpacket
72 * rpc/protocol "rpc/tcp" etc
73 * wait/nowait[.max] single-threaded/multi-threaded
74 * user[.group] or user[:group] user to run daemon as
75 * server_program full path name
76 * server_program_arguments maximum of MAXARGS (20)
78 * For non-RPC services, the "service name" can be of the form
79 * hostaddress:servicename, in which case the hostaddress is used
80 * as the host portion of the address to listen on. If hostaddress
81 * consists of a single '*' character, INADDR_ANY is used.
83 * A line can also consist of just
85 * where hostaddress is as in the preceding paragraph. Such a line must
86 * have no further fields; the specified hostaddress is remembered and
87 * used for all further lines that have no hostaddress specified,
88 * until the next such line (or EOF). (This is why * is provided to
89 * allow explicit specification of INADDR_ANY.) A line
91 * is implicitly in effect at the beginning of the file.
93 * The hostaddress specifier may (and often will) contain dots;
94 * the service name must not.
96 * For RPC services, host-address specifiers are accepted and will
97 * work to some extent; however, because of limitations in the
98 * portmapper interface, it will not work to try to give more than
99 * one line for any given RPC service, even if the host-address
100 * specifiers are different.
102 * Comment lines are indicated by a '#' in column 1.
105 /* inetd rules for passing file descriptors to children
106 * (http://www.freebsd.org/cgi/man.cgi?query=inetd):
108 * The wait/nowait entry specifies whether the server that is invoked by
109 * inetd will take over the socket associated with the service access point,
110 * and thus whether inetd should wait for the server to exit before listen-
111 * ing for new service requests. Datagram servers must use "wait", as
112 * they are always invoked with the original datagram socket bound to the
113 * specified service address. These servers must read at least one datagram
114 * from the socket before exiting. If a datagram server connects to its
115 * peer, freeing the socket so inetd can receive further messages on the
116 * socket, it is said to be a "multi-threaded" server; it should read one
117 * datagram from the socket and create a new socket connected to the peer.
118 * It should fork, and the parent should then exit to allow inetd to check
119 * for new service requests to spawn new servers. Datagram servers which
120 * process all incoming datagrams on a socket and eventually time out are
121 * said to be "single-threaded". The comsat(8), biff(1) and talkd(8)
122 * utilities are both examples of the latter type of datagram server. The
123 * tftpd(8) utility is an example of a multi-threaded datagram server.
125 * Servers using stream sockets generally are multi-threaded and use the
126 * "nowait" entry. Connection requests for these services are accepted by
127 * inetd, and the server is given only the newly-accepted socket connected
128 * to a client of the service. Most stream-based services operate in this
129 * manner. Stream-based servers that use "wait" are started with the lis-
130 * tening service socket, and must accept at least one connection request
131 * before exiting. Such a server would normally accept and process incoming
132 * connection requests until a timeout.
134 * In short: "stream" can be "wait" or "nowait"; "dgram" must be "wait".
137 /* Here's the scoop concerning the user[:group] feature:
138 * 1) group is not specified:
139 * a) user = root: NO setuid() or setgid() is done
140 * b) other: setgid(primary group as found in passwd)
141 * initgroups(name, primary group)
143 * 2) group is specified:
144 * a) user = root: setgid(specified group)
147 * b) other: setgid(specified group)
148 * initgroups(name, specified group)
157 #if ENABLE_FEATURE_INETD_RPC
159 #include <rpc/pmap_clnt.h>
163 /* stream version of chargen is forking but not execing,
164 * can't do that (easily) on NOMMU */
165 #undef ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
166 #define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN 0
169 #define _PATH_INETDPID "/var/run/inetd.pid"
171 #define CNT_INTERVAL 60 /* servers in CNT_INTERVAL sec. */
172 #define RETRYTIME 60 /* retry after bind or server fail */
174 // TODO: explain, or get rid of setrlimit games
176 #ifndef RLIMIT_NOFILE
177 #define RLIMIT_NOFILE RLIMIT_OFILE
184 /* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
187 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD \
188 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO \
189 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN \
190 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME \
191 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
192 # define INETD_BUILTINS_ENABLED
195 typedef struct servtab_t {
196 /* The most frequently referenced one: */
197 int se_fd; /* open descriptor */
198 /* NB: 'biggest fields last' saves on code size (~250 bytes) */
199 /* [addr:]service socktype proto wait user[:group] prog [args] */
200 char *se_local_hostname; /* addr to listen on */
201 char *se_service; /* "80" or "www" or "mount/2[-3]" */
202 /* socktype is in se_socktype */ /* "stream" "dgram" "raw" "rdm" "seqpacket" */
203 char *se_proto; /* "unix" or "[rpc/]tcp[6]" */
204 #if ENABLE_FEATURE_INETD_RPC
205 int se_rpcprog; /* rpc program number */
206 int se_rpcver_lo; /* rpc program lowest version */
207 int se_rpcver_hi; /* rpc program highest version */
208 #define is_rpc_service(sep) ((sep)->se_rpcver_lo != 0)
210 #define is_rpc_service(sep) 0
212 pid_t se_wait; /* 0:"nowait", 1:"wait", >1:"wait" */
213 /* and waiting for this pid */
214 socktype_t se_socktype; /* SOCK_STREAM/DGRAM/RDM/... */
215 family_t se_family; /* AF_UNIX/INET[6] */
216 /* se_proto_no is used by RPC code only... hmm */
217 smallint se_proto_no; /* IPPROTO_TCP/UDP, n/a for AF_UNIX */
218 smallint se_checked; /* looked at during merge */
219 unsigned se_max; /* allowed instances per minute */
220 unsigned se_count; /* number started since se_time */
221 unsigned se_time; /* whem we started counting */
222 char *se_user; /* user name to run as */
223 char *se_group; /* group name to run as, can be NULL */
224 #ifdef INETD_BUILTINS_ENABLED
225 const struct builtin *se_builtin; /* if built-in, description */
227 struct servtab_t *se_next;
228 len_and_sockaddr *se_lsa;
229 char *se_program; /* server program */
231 char *se_argv[MAXARGV + 1]; /* program arguments */
234 #ifdef INETD_BUILTINS_ENABLED
235 /* Echo received data */
236 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
237 static void echo_stream(int, servtab_t *);
238 static void echo_dg(int, servtab_t *);
240 /* Internet /dev/null */
241 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
242 static void discard_stream(int, servtab_t *);
243 static void discard_dg(int, servtab_t *);
245 /* Return 32 bit time since 1900 */
246 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
247 static void machtime_stream(int, servtab_t *);
248 static void machtime_dg(int, servtab_t *);
250 /* Return human-readable time */
251 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
252 static void daytime_stream(int, servtab_t *);
253 static void daytime_dg(int, servtab_t *);
255 /* Familiar character generator */
256 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
257 static void chargen_stream(int, servtab_t *);
258 static void chargen_dg(int, servtab_t *);
262 /* NB: not necessarily NUL terminated */
263 char bi_service7[7]; /* internally provided service name */
264 uint8_t bi_fork; /* 1 if stream fn should run in child */
265 void (*bi_stream_fn)(int, servtab_t *);
266 void (*bi_dgram_fn)(int, servtab_t *);
269 static const struct builtin builtins[] = {
270 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
271 { "echo", 1, echo_stream, echo_dg },
273 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
274 { "discard", 1, discard_stream, discard_dg },
276 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
277 { "chargen", 1, chargen_stream, chargen_dg },
279 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
280 { "time", 0, machtime_stream, machtime_dg },
282 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
283 { "daytime", 0, daytime_stream, daytime_dg },
286 #endif /* INETD_BUILTINS_ENABLED */
289 rlim_t rlim_ofile_cur;
290 struct rlimit rlim_ofile;
291 servtab_t *serv_list;
295 unsigned max_concurrency;
296 smallint alarm_armed;
297 uid_t real_uid; /* user ID who ran us */
298 unsigned config_lineno;
299 const char *config_filename;
301 char *default_local_hostname;
302 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
308 /* Used in next_line(), and as scratch read buffer */
309 char line[256]; /* _at least_ 256, see LINE_SIZE */
311 #define G (*(struct globals*)&bb_common_bufsiz1)
312 enum { LINE_SIZE = COMMON_BUFSIZE - offsetof(struct globals, line) };
313 struct BUG_G_too_big {
314 char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
316 #define rlim_ofile_cur (G.rlim_ofile_cur )
317 #define rlim_ofile (G.rlim_ofile )
318 #define serv_list (G.serv_list )
319 #define global_queuelen (G.global_queuelen)
320 #define prev_maxsock (G.prev_maxsock )
321 #define maxsock (G.maxsock )
322 #define max_concurrency (G.max_concurrency)
323 #define alarm_armed (G.alarm_armed )
324 #define real_uid (G.real_uid )
325 #define config_lineno (G.config_lineno )
326 #define config_filename (G.config_filename)
327 #define fconfig (G.fconfig )
328 #define default_local_hostname (G.default_local_hostname)
329 #define first_ps_byte (G.first_ps_byte )
330 #define last_ps_byte (G.last_ps_byte )
331 #define end_ring (G.end_ring )
332 #define ring_pos (G.ring_pos )
333 #define ring (G.ring )
334 #define allsock (G.allsock )
335 #define line (G.line )
336 #define INIT_G() do { \
337 rlim_ofile_cur = OPEN_MAX; \
338 global_queuelen = 128; \
339 config_filename = "/etc/inetd.conf"; \
342 static void maybe_close(int fd)
348 // TODO: move to libbb?
349 static len_and_sockaddr *xzalloc_lsa(int family)
351 len_and_sockaddr *lsa;
354 sz = sizeof(struct sockaddr_in);
355 if (family == AF_UNIX)
356 sz = sizeof(struct sockaddr_un);
357 #if ENABLE_FEATURE_IPV6
358 if (family == AF_INET6)
359 sz = sizeof(struct sockaddr_in6);
361 lsa = xzalloc(LSA_LEN_SIZE + sz);
363 lsa->u.sa.sa_family = family;
367 static void rearm_alarm(void)
375 static void block_CHLD_HUP_ALRM(sigset_t *m)
378 sigaddset(m, SIGCHLD);
379 sigaddset(m, SIGHUP);
380 sigaddset(m, SIGALRM);
381 sigprocmask(SIG_BLOCK, m, NULL);
384 static void unblock_sigs(sigset_t *m)
386 sigprocmask(SIG_UNBLOCK, m, NULL);
389 #if ENABLE_FEATURE_INETD_RPC
390 static void register_rpc(servtab_t *sep)
393 struct sockaddr_in ir_sin;
396 size = sizeof(ir_sin);
397 if (getsockname(sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) {
398 bb_perror_msg("getsockname");
402 for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) {
403 pmap_unset(sep->se_rpcprog, n);
404 if (!pmap_set(sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port)))
405 bb_perror_msg("%s %s: pmap_set(%u,%u,%u,%u)",
406 sep->se_service, sep->se_proto,
407 sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port));
411 static void unregister_rpc(servtab_t *sep)
415 for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) {
416 if (!pmap_unset(sep->se_rpcprog, n))
417 bb_perror_msg("pmap_unset(%u,%u)", sep->se_rpcprog, n);
420 #endif /* FEATURE_INETD_RPC */
422 static void bump_nofile(void)
424 enum { FD_CHUNK = 32 };
427 /* Never fails under Linux (except if you pass it bad arguments) */
428 getrlimit(RLIMIT_NOFILE, &rl);
429 rl.rlim_cur = MIN(rl.rlim_max, rl.rlim_cur + FD_CHUNK);
430 rl.rlim_cur = MIN(FD_SETSIZE, rl.rlim_cur + FD_CHUNK);
431 if (rl.rlim_cur <= rlim_ofile_cur) {
432 bb_error_msg("can't extend file limit, max = %d",
437 if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
438 bb_perror_msg("setrlimit");
442 rlim_ofile_cur = rl.rlim_cur;
445 static void remove_fd_from_set(int fd)
448 FD_CLR(fd, &allsock);
453 static void add_fd_to_set(int fd)
456 FD_SET(fd, &allsock);
457 if (maxsock >= 0 && fd > maxsock) {
458 prev_maxsock = maxsock = fd;
459 if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
465 static void recalculate_maxsock(void)
468 while (fd <= prev_maxsock) {
469 if (FD_ISSET(fd, &allsock))
473 prev_maxsock = maxsock;
474 if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
478 static void prepare_socket_fd(servtab_t *sep)
482 fd = socket(sep->se_family, sep->se_socktype, 0);
484 bb_perror_msg("socket");
487 setsockopt_reuseaddr(fd);
489 #if ENABLE_FEATURE_INETD_RPC
490 if (is_rpc_service(sep)) {
493 /* zero out the port for all RPC services; let bind()
495 set_nport(sep->se_lsa, 0);
497 /* for RPC services, attempt to use a reserved port
498 * if they are going to be running as root. */
499 if (real_uid == 0 && sep->se_family == AF_INET
500 && (pwd = getpwnam(sep->se_user)) != NULL
503 r = bindresvport(fd, &sep->se_lsa->u.sin);
505 r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len);
508 int saveerrno = errno;
509 /* update lsa with port# */
510 getsockname(fd, &sep->se_lsa->u.sa, &sep->se_lsa->len);
516 if (sep->se_family == AF_UNIX) {
517 struct sockaddr_un *sun;
518 sun = (struct sockaddr_un*)&(sep->se_lsa->u.sa);
519 unlink(sun->sun_path);
521 r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len);
524 bb_perror_msg("%s/%s: bind",
525 sep->se_service, sep->se_proto);
530 if (sep->se_socktype == SOCK_STREAM)
531 listen(fd, global_queuelen);
537 static int reopen_config_file(void)
539 free(default_local_hostname);
540 default_local_hostname = xstrdup("*");
544 fconfig = fopen_or_warn(config_filename, "r");
545 return (fconfig != NULL);
548 static void close_config_file(void)
556 static char *next_line(void)
558 if (fgets(line, LINE_SIZE, fconfig) == NULL)
561 *strchrnul(line, '\n') = '\0';
565 static char *next_word(char **cpp)
573 while (*cp == ' ' || *cp == '\t')
576 int c = getc(fconfig);
578 if (c == ' ' || c == '\t') {
587 while (*cp && *cp != ' ' && *cp != '\t')
596 static void free_servtab_strings(servtab_t *cp)
600 free(cp->se_local_hostname);
601 free(cp->se_service);
605 free(cp->se_lsa); /* not a string in fact */
606 free(cp->se_program);
607 for (i = 0; i < MAXARGV; i++)
608 free(cp->se_argv[i]);
611 static servtab_t *new_servtab(void)
613 servtab_t *newtab = xzalloc(sizeof(servtab_t));
614 newtab->se_fd = -1; /* paranoia */
618 static servtab_t *dup_servtab(servtab_t *sep)
623 newtab = new_servtab();
624 *newtab = *sep; /* struct copy */
625 /* deep-copying strings */
626 newtab->se_service = xstrdup(newtab->se_service);
627 newtab->se_proto = xstrdup(newtab->se_proto);
628 newtab->se_user = xstrdup(newtab->se_user);
629 newtab->se_group = xstrdup(newtab->se_group);
630 newtab->se_program = xstrdup(newtab->se_program);
631 for (argc = 0; argc <= MAXARGV; argc++)
632 newtab->se_argv[argc] = xstrdup(newtab->se_argv[argc]);
633 /* NB: se_fd, se_hostaddr and se_next are always
634 * overwrittend by callers, so we don't bother resetting them
635 * to NULL/0/-1 etc */
640 /* gcc generates much more code if this is inlined */
641 static NOINLINE servtab_t *parse_one_line(void)
651 while ((cp = next_line()) && *cp == '#')
652 continue; /* skip comment lines */
658 arg = next_word(&cp);
659 if (arg == NULL) /* a blank line. */
662 /* [host:]service socktype proto wait user[:group] prog [args] */
663 /* Check for "host:...." line */
664 hostdelim = strrchr(arg, ':');
667 sep->se_local_hostname = xstrdup(arg);
670 arg = next_word(&cp);
672 /* Line has just "host:", change the
673 * default host for the following lines. */
674 free(default_local_hostname);
675 default_local_hostname = sep->se_local_hostname;
680 sep->se_local_hostname = xstrdup(default_local_hostname);
682 /* service socktype proto wait user[:group] prog [args] */
683 sep->se_service = xstrdup(arg);
684 /* socktype proto wait user[:group] prog [args] */
685 arg = next_word(&cp);
688 bb_error_msg("parse error on line %u, line is ignored",
690 free_servtab_strings(sep);
691 /* Just "goto more" can make sep to carry over e.g.
692 * "rpc"-ness (by having se_rpcver_lo != 0).
693 * We will be more paranoid: */
698 static int8_t SOCK_xxx[] ALIGN1 = {
700 SOCK_STREAM, SOCK_DGRAM, SOCK_RDM,
701 SOCK_SEQPACKET, SOCK_RAW
703 sep->se_socktype = SOCK_xxx[1 + index_in_strings(
704 "stream""\0" "dgram""\0" "rdm""\0"
705 "seqpacket""\0" "raw""\0"
709 /* {unix,[rpc/]{tcp,udp}[6]} wait user[:group] prog [args] */
710 sep->se_proto = arg = xstrdup(next_word(&cp));
713 if (strcmp(arg, "unix") == 0) {
714 sep->se_family = AF_UNIX;
717 sep->se_family = AF_INET;
718 six = last_char_is(arg, '6');
720 #if ENABLE_FEATURE_IPV6
722 sep->se_family = AF_INET6;
724 bb_error_msg("%s: no support for IPv6", sep->se_proto);
728 if (strncmp(arg, "rpc/", 4) == 0) {
729 #if ENABLE_FEATURE_INETD_RPC
732 p = strchr(sep->se_service, '/');
734 bb_error_msg("no rpc version: '%s'", sep->se_service);
738 n = bb_strtou(p, &p, 10);
741 bb_error_msg("bad rpc version");
744 sep->se_rpcver_lo = sep->se_rpcver_hi = n;
747 n = bb_strtou(p, &p, 10);
748 if (n > INT_MAX || n < sep->se_rpcver_lo)
750 sep->se_rpcver_hi = n;
755 bb_error_msg("no support for rpc services");
759 /* we don't really need getprotobyname()! */
760 if (strcmp(arg, "tcp") == 0)
761 sep->se_proto_no = IPPROTO_TCP; /* = 6 */
762 if (strcmp(arg, "udp") == 0)
763 sep->se_proto_no = IPPROTO_UDP; /* = 17 */
766 if (!sep->se_proto_no) /* not tcp/udp?? */
770 /* [no]wait[.max] user[:group] prog [args] */
771 arg = next_word(&cp);
774 sep->se_max = max_concurrency;
775 p = strchr(arg, '.');
778 sep->se_max = bb_strtou(p, NULL, 10);
782 sep->se_wait = (arg[0] != 'n' || arg[1] != 'o');
783 if (!sep->se_wait) /* "no" seen */
785 if (strcmp(arg, "wait") != 0)
788 /* user[:group] prog [args] */
789 sep->se_user = xstrdup(next_word(&cp));
790 if (sep->se_user == NULL)
792 arg = strchr(sep->se_user, '.');
794 arg = strchr(sep->se_user, ':');
797 sep->se_group = xstrdup(arg);
801 sep->se_program = xstrdup(next_word(&cp));
802 if (sep->se_program == NULL)
804 #ifdef INETD_BUILTINS_ENABLED
805 if (strcmp(sep->se_program, "internal") == 0
806 && strlen(sep->se_service) <= 7
807 && (sep->se_socktype == SOCK_STREAM
808 || sep->se_socktype == SOCK_DGRAM)
811 for (i = 0; i < ARRAY_SIZE(builtins); i++)
812 if (strncmp(builtins[i].bi_service7, sep->se_service, 7) == 0)
814 bb_error_msg("unknown internal service %s", sep->se_service);
817 sep->se_builtin = &builtins[i];
818 /* stream builtins must be "nowait", dgram must be "wait" */
819 if (sep->se_wait != (sep->se_socktype == SOCK_DGRAM))
824 while ((arg = next_word(&cp)) != NULL && argc < MAXARGV)
825 sep->se_argv[argc++] = xstrdup(arg);
827 /* catch mixups. "<service> stream udp ..." == wtf */
828 if (sep->se_socktype == SOCK_STREAM) {
829 if (sep->se_proto_no == IPPROTO_UDP)
832 if (sep->se_socktype == SOCK_DGRAM) {
833 if (sep->se_proto_no == IPPROTO_TCP)
835 /* "udp nowait" is a small fork bomb :) */
840 /* check if the hostname specifier is a comma separated list
841 * of hostnames. we'll make new entries for each address. */
842 while ((hostdelim = strrchr(sep->se_local_hostname, ',')) != NULL) {
843 nsep = dup_servtab(sep);
844 /* NUL terminate the hostname field of the existing entry,
845 * and make a dup for the new entry. */
847 nsep->se_local_hostname = xstrdup(hostdelim);
848 nsep->se_next = sep->se_next;
852 /* was doing it here: */
853 /* DNS resolution, create copies for each IP address */
854 /* IPv6-ization destroyed it :( */
859 static servtab_t *insert_in_servlist(servtab_t *cp)
865 *sep = *cp; /* struct copy */
867 #if ENABLE_FEATURE_INETD_RPC
868 sep->se_rpcprog = -1;
870 block_CHLD_HUP_ALRM(&omask);
871 sep->se_next = serv_list;
873 unblock_sigs(&omask);
877 static int same_serv_addr_proto(servtab_t *old, servtab_t *new)
879 if (strcmp(old->se_local_hostname, new->se_local_hostname) != 0)
881 if (strcmp(old->se_service, new->se_service) != 0)
883 if (strcmp(old->se_proto, new->se_proto) != 0)
888 static void reread_config_file(int sig ATTRIBUTE_UNUSED)
890 servtab_t *sep, *cp, **sepp;
891 len_and_sockaddr *lsa;
896 if (!reopen_config_file())
898 for (sep = serv_list; sep; sep = sep->se_next)
905 cp = parse_one_line();
909 for (sep = serv_list; sep; sep = sep->se_next)
910 if (same_serv_addr_proto(sep, cp))
912 /* not an "equal" servtab */
913 sep = insert_in_servlist(cp);
919 block_CHLD_HUP_ALRM(&omask);
920 #if ENABLE_FEATURE_INETD_RPC
921 if (is_rpc_service(sep))
923 sep->se_rpcver_lo = cp->se_rpcver_lo;
924 sep->se_rpcver_hi = cp->se_rpcver_hi;
926 if (cp->se_wait == 0) {
927 /* New config says "nowait". If old one
928 * was "wait", we currently may be waiting
929 * for a child (and not accepting connects).
930 * Stop waiting, start listening again.
931 * (if it's not true, this op is harmless) */
932 add_fd_to_set(sep->se_fd);
934 sep->se_wait = cp->se_wait;
935 sep->se_max = cp->se_max;
936 /* string fields need more love - we don't want to leak them */
937 #define SWAP(type, a, b) do { type c = (type)a; a = (type)b; b = (type)c; } while (0)
938 SWAP(char*, sep->se_user, cp->se_user);
939 SWAP(char*, sep->se_group, cp->se_group);
940 SWAP(char*, sep->se_program, cp->se_program);
941 for (i = 0; i < MAXARGV; i++)
942 SWAP(char*, sep->se_argv[i], cp->se_argv[i]);
944 unblock_sigs(&omask);
945 free_servtab_strings(cp);
948 /* cp->string_fields are consumed by insert_in_servlist()
949 * or freed at this point, cp itself is not yet freed. */
952 /* create new len_and_sockaddr */
953 switch (sep->se_family) {
954 struct sockaddr_un *sun;
956 lsa = xzalloc_lsa(AF_UNIX);
957 sun = (struct sockaddr_un*)&lsa->u.sa;
958 safe_strncpy(sun->sun_path, sep->se_service, sizeof(sun->sun_path));
961 default: /* case AF_INET, case AF_INET6 */
962 n = bb_strtou(sep->se_service, NULL, 10);
963 #if ENABLE_FEATURE_INETD_RPC
964 if (is_rpc_service(sep)) {
966 if (errno) { /* se_service is not numeric */
967 struct rpcent *rp = getrpcbyname(sep->se_service);
969 bb_error_msg("%s: unknown rpc service", sep->se_service);
972 sep->se_rpcprog = rp->r_number;
974 if (sep->se_fd == -1)
975 prepare_socket_fd(sep);
976 if (sep->se_fd != -1)
981 /* what port to listen on? */
983 if (errno || n > 0xffff) { /* se_service is not numeric */
986 /* can result only in "tcp" or "udp": */
987 safe_strncpy(protoname, sep->se_proto, 4);
988 sp = getservbyname(sep->se_service, protoname);
990 bb_error_msg("%s/%s: unknown service",
991 sep->se_service, sep->se_proto);
996 if (LONE_CHAR(sep->se_local_hostname, '*')) {
997 lsa = xzalloc_lsa(sep->se_family);
998 set_nport(lsa, port);
1000 lsa = host_and_af2sockaddr(sep->se_local_hostname,
1001 ntohs(port), sep->se_family);
1003 bb_error_msg("%s/%s: unknown host '%s'",
1004 sep->se_service, sep->se_proto,
1005 sep->se_local_hostname);
1010 } /* end of "switch (sep->se_family)" */
1012 /* did lsa change? Then close/open */
1013 if (sep->se_lsa == NULL
1014 || lsa->len != sep->se_lsa->len
1015 || memcmp(&lsa->u.sa, &sep->se_lsa->u.sa, lsa->len) != 0
1017 remove_fd_from_set(sep->se_fd);
1018 maybe_close(sep->se_fd);
1025 if (sep->se_fd == -1)
1026 prepare_socket_fd(sep);
1031 } /* end of "while (1) parse lines" */
1032 close_config_file();
1034 /* Purge anything not looked at above - these are stale entries,
1035 * new config file doesnt have them. */
1036 block_CHLD_HUP_ALRM(&omask);
1038 while ((sep = *sepp)) {
1039 if (sep->se_checked) {
1040 sepp = &sep->se_next;
1043 *sepp = sep->se_next;
1044 remove_fd_from_set(sep->se_fd);
1045 maybe_close(sep->se_fd);
1046 #if ENABLE_FEATURE_INETD_RPC
1047 if (is_rpc_service(sep))
1048 unregister_rpc(sep);
1050 if (sep->se_family == AF_UNIX)
1051 unlink(sep->se_service);
1052 free_servtab_strings(sep);
1055 unblock_sigs(&omask);
1058 static void reap_child(int sig ATTRIBUTE_UNUSED)
1063 int save_errno = errno;
1066 pid = wait_any_nohang(&status);
1069 for (sep = serv_list; sep; sep = sep->se_next)
1070 if (sep->se_wait == pid) {
1071 /* One of our "wait" services */
1072 if (WIFEXITED(status) && WEXITSTATUS(status))
1073 bb_error_msg("%s: exit status 0x%x",
1074 sep->se_program, WEXITSTATUS(status));
1075 else if (WIFSIGNALED(status))
1076 bb_error_msg("%s: exit signal 0x%x",
1077 sep->se_program, WTERMSIG(status));
1079 add_fd_to_set(sep->se_fd);
1085 static void retry_network_setup(int sig ATTRIBUTE_UNUSED)
1090 for (sep = serv_list; sep; sep = sep->se_next) {
1091 if (sep->se_fd == -1) {
1092 prepare_socket_fd(sep);
1093 #if ENABLE_FEATURE_INETD_RPC
1094 if (sep->se_fd != -1 && is_rpc_service(sep))
1101 static void clean_up_and_exit(int sig ATTRIBUTE_UNUSED)
1105 /* XXX signal race walking sep list */
1106 for (sep = serv_list; sep; sep = sep->se_next) {
1107 if (sep->se_fd == -1)
1110 switch (sep->se_family) {
1112 unlink(sep->se_service);
1114 default: /* case AF_INET, AF_INET6 */
1115 #if ENABLE_FEATURE_INETD_RPC
1116 if (sep->se_wait == 1 && is_rpc_service(sep))
1117 unregister_rpc(sep); /* XXX signal race */
1121 if (ENABLE_FEATURE_CLEAN_UP)
1124 remove_pidfile(_PATH_INETDPID);
1128 int inetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1129 int inetd_main(int argc, char **argv)
1131 struct sigaction sa, saved_pipe_handler;
1132 servtab_t *sep, *sep2;
1134 struct group *grp = grp; /* for compiler */
1141 real_uid = getuid();
1142 if (real_uid != 0) /* run by non-root user */
1143 config_filename = NULL;
1145 opt_complementary = "R+:q+"; /* -q N, -R N */
1146 opt = getopt32(argv, "R:feq:", &max_concurrency, &global_queuelen);
1150 config_filename = argv[0];
1151 if (config_filename == NULL)
1152 bb_error_msg_and_die("non-root must specify config file");
1154 bb_daemonize_or_rexec(0, argv - optind);
1156 bb_sanitize_stdio();
1158 openlog(applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
1159 logmode = LOGMODE_SYSLOG;
1162 if (real_uid == 0) {
1163 /* run by root, ensure groups vector gets trashed */
1164 gid_t gid = getgid();
1168 write_pidfile(_PATH_INETDPID);
1170 /* never fails under Linux (except if you pass it bad arguments) */
1171 getrlimit(RLIMIT_NOFILE, &rlim_ofile);
1172 rlim_ofile_cur = rlim_ofile.rlim_cur;
1173 if (rlim_ofile_cur == RLIM_INFINITY) /* ! */
1174 rlim_ofile_cur = OPEN_MAX;
1176 memset(&sa, 0, sizeof(sa));
1177 /*sigemptyset(&sa.sa_mask); - memset did it */
1178 sigaddset(&sa.sa_mask, SIGALRM);
1179 sigaddset(&sa.sa_mask, SIGCHLD);
1180 sigaddset(&sa.sa_mask, SIGHUP);
1181 sa.sa_handler = retry_network_setup;
1182 sigaction(SIGALRM, &sa, NULL);
1183 sa.sa_handler = reread_config_file;
1184 sigaction(SIGHUP, &sa, NULL);
1185 sa.sa_handler = reap_child;
1186 sigaction(SIGCHLD, &sa, NULL);
1187 sa.sa_handler = clean_up_and_exit;
1188 sigaction(SIGTERM, &sa, NULL);
1189 sa.sa_handler = clean_up_and_exit;
1190 sigaction(SIGINT, &sa, NULL);
1191 sa.sa_handler = SIG_IGN;
1192 sigaction(SIGPIPE, &sa, &saved_pipe_handler);
1194 reread_config_file(SIGHUP); /* load config from file */
1198 int ctrl, accepted_fd;
1202 recalculate_maxsock();
1204 readable = allsock; /* struct copy */
1205 /* if there are no fds to wait on, we will block
1206 * until signal wakes us up */
1207 ready_fd_cnt = select(maxsock + 1, &readable, NULL, NULL, NULL);
1208 if (ready_fd_cnt < 0) {
1209 if (errno != EINTR) {
1210 bb_perror_msg("select");
1216 for (sep = serv_list; ready_fd_cnt && sep; sep = sep->se_next) {
1217 if (sep->se_fd == -1 || !FD_ISSET(sep->se_fd, &readable))
1223 if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
1224 ctrl = accepted_fd = accept(sep->se_fd, NULL, NULL);
1227 bb_perror_msg("accept (for %s)", sep->se_service);
1232 block_CHLD_HUP_ALRM(&omask);
1234 #ifdef INETD_BUILTINS_ENABLED
1235 /* do we need to fork? */
1236 if (sep->se_builtin == NULL
1237 || (sep->se_socktype == SOCK_STREAM
1238 && sep->se_builtin->bi_fork))
1241 if (sep->se_max != 0) {
1242 if (++sep->se_count == 1)
1243 sep->se_time = monotonic_sec();
1244 else if (sep->se_count >= sep->se_max) {
1245 unsigned now = monotonic_sec();
1246 /* did we accumulate se_max connects too quickly? */
1247 if (now - sep->se_time <= CNT_INTERVAL) {
1248 bb_error_msg("%s/%s: too many connections, pausing",
1249 sep->se_service, sep->se_proto);
1250 remove_fd_from_set(sep->se_fd);
1254 rearm_alarm(); /* will revive it in RETRYTIME sec */
1255 unblock_sigs(&omask);
1256 maybe_close(accepted_fd);
1257 continue; /* -> check next fd in fd set */
1262 /* on NOMMU, streamed chargen
1263 * builtin wouldn't work, but it is
1264 * not allowed on NOMMU (ifdefed out) */
1265 #ifdef INETD_BUILTINS_ENABLED
1266 if (BB_MMU && sep->se_builtin)
1272 if (pid < 0) { /* fork error */
1273 bb_perror_msg("fork");
1275 unblock_sigs(&omask);
1276 maybe_close(accepted_fd);
1277 continue; /* -> check next fd in fd set */
1280 pid--; /* -1: "we did fork and we are child" */
1282 /* if pid == 0 here, we never forked */
1284 if (pid > 0) { /* parent */
1287 remove_fd_from_set(sep->se_fd);
1288 /* we passed listening socket to child,
1289 * will wait for child to terminate */
1291 unblock_sigs(&omask);
1292 maybe_close(accepted_fd);
1293 continue; /* -> check next fd in fd set */
1296 /* we are either child or didn't fork at all */
1297 #ifdef INETD_BUILTINS_ENABLED
1298 if (sep->se_builtin) {
1299 if (pid) { /* "pid" is -1: we did fork */
1300 close(sep->se_fd); /* listening socket */
1301 logmode = 0; /* make xwrite etc silent */
1303 unblock_sigs(&omask);
1304 if (sep->se_socktype == SOCK_STREAM)
1305 sep->se_builtin->bi_stream_fn(ctrl, sep);
1307 sep->se_builtin->bi_dgram_fn(ctrl, sep);
1308 if (pid) /* we did fork */
1310 maybe_close(accepted_fd);
1311 continue; /* -> check next fd in fd set */
1317 /* This does not work.
1318 * Actually, it _almost_ works. The idea behind it is: child
1319 * can peek at (already received and buffered by kernel) UDP packet,
1320 * and perform connect() on the socket so that it is linked only
1321 * to this peer. But this also affects parent, because descriptors
1322 * are shared after fork() a-la dup(). When parent returns to
1323 * select(), it will see this descriptor attached to the peer (!)
1324 * and likely still readable, will act on it and mess things up
1325 * (can create many copies of same child, etc).
1326 * If child will create new socket instead, then bind() and
1327 * connect() it to peer's address, descriptor aliasing problem
1328 * is solved, but first packet cannot be "transferred" to the new
1329 * socket. It is not a problem if child can account for this,
1330 * but our child will exec - and exec'ed program does not know
1331 * about this "lost packet" problem! Pity... */
1332 /* "nowait" udp[6]. Hmmm... */
1334 && sep->se_socktype == SOCK_DGRAM
1335 && sep->se_family != AF_UNIX
1337 len_and_sockaddr *lsa = xzalloc_lsa(sep->se_family);
1338 /* peek at the packet and remember peer addr */
1339 int r = recvfrom(ctrl, NULL, 0, MSG_PEEK|MSG_DONTWAIT,
1340 &lsa->u.sa, &lsa->len);
1342 /* make this socket "connected" to peer addr:
1343 * only packets from this peer will be recv'ed,
1344 * and bare write()/send() will work on it */
1345 connect(ctrl, &lsa->u.sa, lsa->len);
1349 /* prepare env and exec program */
1350 pwd = getpwnam(sep->se_user);
1352 bb_error_msg("%s: no such user", sep->se_user);
1355 if (sep->se_group && (grp = getgrnam(sep->se_group)) == NULL) {
1356 bb_error_msg("%s: no such group", sep->se_group);
1359 if (real_uid != 0 && real_uid != pwd->pw_uid) {
1360 /* a user running private inetd */
1361 bb_error_msg("non-root must run services as himself");
1366 pwd->pw_gid = grp->gr_gid;
1367 xsetgid(pwd->pw_gid);
1368 initgroups(pwd->pw_name, pwd->pw_gid);
1369 xsetuid(pwd->pw_uid);
1370 } else if (sep->se_group) {
1371 xsetgid(grp->gr_gid);
1372 setgroups(1, &grp->gr_gid);
1374 if (rlim_ofile.rlim_cur != rlim_ofile_cur)
1375 if (setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0)
1376 bb_perror_msg("setrlimit");
1381 /* NB: among others, this loop closes listening socket
1382 * for nowait stream children */
1383 for (sep2 = serv_list; sep2; sep2 = sep2->se_next)
1384 maybe_close(sep2->se_fd);
1385 sigaction(SIGPIPE, &saved_pipe_handler, NULL);
1386 unblock_sigs(&omask);
1387 BB_EXECVP(sep->se_program, sep->se_argv);
1388 bb_perror_msg("exec %s", sep->se_program);
1390 /* eat packet in udp case */
1391 if (sep->se_socktype != SOCK_STREAM)
1392 recv(0, line, LINE_SIZE, MSG_DONTWAIT);
1394 } /* for (sep = servtab...) */
1399 * Internet services provided internally by inetd:
1401 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
1402 /* Echo service -- echo data back. */
1404 static void echo_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
1408 ssize_t sz = safe_read(s, line, LINE_SIZE);
1411 xwrite(s, line, sz);
1414 static const char *const args[] = { "cat", NULL };
1415 /* no error messages */
1416 xmove_fd(xopen("/dev/null", O_WRONLY), STDERR_FILENO);
1417 BB_EXECVP("cat", (char**)args);
1421 static void echo_dg(int s, servtab_t *sep)
1423 enum { BUFSIZE = 12*1024 }; /* for jumbo sized packets! :) */
1424 char *buf = xmalloc(BUFSIZE); /* too big for stack */
1426 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1428 lsa->len = sep->se_lsa->len;
1429 /* dgram builtins are non-forking - DONT BLOCK! */
1430 sz = recvfrom(s, buf, BUFSIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len);
1432 sendto(s, buf, sz, 0, &lsa->u.sa, lsa->len);
1435 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_ECHO */
1438 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
1439 /* Discard service -- ignore data. MMU arches only. */
1441 static void discard_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
1444 while (safe_read(s, line, LINE_SIZE) > 0)
1447 static const char *const args[] = { "dd", "of=/dev/null", NULL };
1448 /* no error messages */
1449 xmove_fd(xopen("/dev/null", O_WRONLY), STDERR_FILENO);
1450 BB_EXECVP("dd", (char**)args);
1455 static void discard_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
1457 /* dgram builtins are non-forking - DONT BLOCK! */
1458 recv(s, line, LINE_SIZE, MSG_DONTWAIT);
1460 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */
1463 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
1465 static void init_ring(void)
1470 for (i = 0; i <= 128; ++i)
1474 /* Character generator. MMU arches only. */
1476 static void chargen_stream(int s, servtab_t *sep)
1480 char text[LINESIZ + 2];
1487 text[LINESIZ] = '\r';
1488 text[LINESIZ + 1] = '\n';
1491 len = end_ring - rs;
1493 memmove(text, rs, LINESIZ);
1495 memmove(text, rs, len);
1496 memmove(text + len, ring, LINESIZ - len);
1498 if (++rs == end_ring)
1500 xwrite(s, text, sizeof(text));
1504 static void chargen_dg(int s, servtab_t *sep)
1507 char text[LINESIZ + 2];
1508 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1510 /* Eat UDP packet which started it all */
1511 /* dgram builtins are non-forking - DONT BLOCK! */
1512 lsa->len = sep->se_lsa->len;
1513 if (recvfrom(s, text, sizeof(text), MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1521 len = end_ring - ring_pos;
1523 memmove(text, ring_pos, LINESIZ);
1525 memmove(text, ring_pos, len);
1526 memmove(text + len, ring, LINESIZ - len);
1528 if (++ring_pos == end_ring)
1530 text[LINESIZ] = '\r';
1531 text[LINESIZ + 1] = '\n';
1532 sendto(s, text, sizeof(text), 0, &lsa->u.sa, lsa->len);
1534 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */
1537 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
1539 * Return a machine readable date and time, in the form of the
1540 * number of seconds since midnight, Jan 1, 1900. Since gettimeofday
1541 * returns the number of seconds since midnight, Jan 1, 1970,
1542 * we must add 2208988800 seconds to this figure to make up for
1543 * some seventy years Bell Labs was asleep.
1545 static uint32_t machtime(void)
1549 gettimeofday(&tv, NULL);
1550 return htonl((uint32_t)(tv.tv_sec + 2208988800));
1553 static void machtime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
1557 result = machtime();
1558 full_write(s, &result, sizeof(result));
1560 static void machtime_dg(int s, servtab_t *sep)
1563 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1565 lsa->len = sep->se_lsa->len;
1566 if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1569 result = machtime();
1570 sendto(s, &result, sizeof(result), 0, &lsa->u.sa, lsa->len);
1572 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_TIME */
1575 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
1576 /* Return human-readable time of day */
1578 static void daytime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
1583 fdprintf(s, "%.24s\r\n", ctime(&t));
1585 static void daytime_dg(int s, servtab_t *sep)
1588 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1590 lsa->len = sep->se_lsa->len;
1591 if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1595 sprintf(line, "%.24s\r\n", ctime(&t));
1596 sendto(s, line, strlen(line), 0, &lsa->u.sa, lsa->len);
1598 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */