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.
135 /* Despite of above doc saying that dgram services must use "wait",
136 * "udp nowait" servers are implemented in busyboxed inetd.
137 * IPv6 addresses are also implemented. However, they may look ugly -
138 * ":::service..." means "address '::' (IPv6 wildcard addr)":"service"...
139 * You have to put "tcp6"/"udp6" in protocol field to select IPv6.
142 /* Here's the scoop concerning the user[:group] feature:
143 * 1) group is not specified:
144 * a) user = root: NO setuid() or setgid() is done
145 * b) other: initgroups(name, primary group)
146 * setgid(primary group as found in passwd)
148 * 2) group is specified:
149 * a) user = root: setgid(specified group)
152 * b) other: initgroups(name, specified group)
153 * setgid(specified group)
157 //usage:#define inetd_trivial_usage
158 //usage: "[-fe] [-q N] [-R N] [CONFFILE]"
159 //usage:#define inetd_full_usage "\n\n"
160 //usage: "Listen for network connections and launch programs\n"
161 //usage: "\n -f Run in foreground"
162 //usage: "\n -e Log to stderr"
163 //usage: "\n -q N Socket listen queue (default: 128)"
164 //usage: "\n -R N Pause services after N connects/min"
165 //usage: "\n (default: 0 - disabled)"
172 #if ENABLE_FEATURE_INETD_RPC
174 #include <rpc/pmap_clnt.h>
178 /* stream version of chargen is forking but not execing,
179 * can't do that (easily) on NOMMU */
180 #undef ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
181 #define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN 0
184 #define _PATH_INETDPID "/var/run/inetd.pid"
186 #define CNT_INTERVAL 60 /* servers in CNT_INTERVAL sec. */
187 #define RETRYTIME 60 /* retry after bind or server fail */
189 // TODO: explain, or get rid of setrlimit games
191 #ifndef RLIMIT_NOFILE
192 #define RLIMIT_NOFILE RLIMIT_OFILE
199 /* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
202 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD \
203 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO \
204 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN \
205 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME \
206 || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
207 # define INETD_BUILTINS_ENABLED
210 typedef struct servtab_t {
211 /* The most frequently referenced one: */
212 int se_fd; /* open descriptor */
213 /* NB: 'biggest fields last' saves on code size (~250 bytes) */
214 /* [addr:]service socktype proto wait user[:group] prog [args] */
215 char *se_local_hostname; /* addr to listen on */
216 char *se_service; /* "80" or "www" or "mount/2[-3]" */
217 /* socktype is in se_socktype */ /* "stream" "dgram" "raw" "rdm" "seqpacket" */
218 char *se_proto; /* "unix" or "[rpc/]tcp[6]" */
219 #if ENABLE_FEATURE_INETD_RPC
220 int se_rpcprog; /* rpc program number */
221 int se_rpcver_lo; /* rpc program lowest version */
222 int se_rpcver_hi; /* rpc program highest version */
223 #define is_rpc_service(sep) ((sep)->se_rpcver_lo != 0)
225 #define is_rpc_service(sep) 0
227 pid_t se_wait; /* 0:"nowait", 1:"wait", >1:"wait" */
228 /* and waiting for this pid */
229 socktype_t se_socktype; /* SOCK_STREAM/DGRAM/RDM/... */
230 family_t se_family; /* AF_UNIX/INET[6] */
231 /* se_proto_no is used by RPC code only... hmm */
232 smallint se_proto_no; /* IPPROTO_TCP/UDP, n/a for AF_UNIX */
233 smallint se_checked; /* looked at during merge */
234 unsigned se_max; /* allowed instances per minute */
235 unsigned se_count; /* number started since se_time */
236 unsigned se_time; /* when we started counting */
237 char *se_user; /* user name to run as */
238 char *se_group; /* group name to run as, can be NULL */
239 #ifdef INETD_BUILTINS_ENABLED
240 const struct builtin *se_builtin; /* if built-in, description */
242 struct servtab_t *se_next;
243 len_and_sockaddr *se_lsa;
244 char *se_program; /* server program */
246 char *se_argv[MAXARGV + 1]; /* program arguments */
249 #ifdef INETD_BUILTINS_ENABLED
250 /* Echo received data */
251 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
252 static void FAST_FUNC echo_stream(int, servtab_t *);
253 static void FAST_FUNC echo_dg(int, servtab_t *);
255 /* Internet /dev/null */
256 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
257 static void FAST_FUNC discard_stream(int, servtab_t *);
258 static void FAST_FUNC discard_dg(int, servtab_t *);
260 /* Return 32 bit time since 1900 */
261 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
262 static void FAST_FUNC machtime_stream(int, servtab_t *);
263 static void FAST_FUNC machtime_dg(int, servtab_t *);
265 /* Return human-readable time */
266 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
267 static void FAST_FUNC daytime_stream(int, servtab_t *);
268 static void FAST_FUNC daytime_dg(int, servtab_t *);
270 /* Familiar character generator */
271 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
272 static void FAST_FUNC chargen_stream(int, servtab_t *);
273 static void FAST_FUNC chargen_dg(int, servtab_t *);
277 /* NB: not necessarily NUL terminated */
278 char bi_service7[7]; /* internally provided service name */
279 uint8_t bi_fork; /* 1 if stream fn should run in child */
280 void (*bi_stream_fn)(int, servtab_t *) FAST_FUNC;
281 void (*bi_dgram_fn)(int, servtab_t *) FAST_FUNC;
284 static const struct builtin builtins[] = {
285 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
286 { "echo", 1, echo_stream, echo_dg },
288 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
289 { "discard", 1, discard_stream, discard_dg },
291 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
292 { "chargen", 1, chargen_stream, chargen_dg },
294 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
295 { "time", 0, machtime_stream, machtime_dg },
297 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
298 { "daytime", 0, daytime_stream, daytime_dg },
301 #endif /* INETD_BUILTINS_ENABLED */
304 rlim_t rlim_ofile_cur;
305 struct rlimit rlim_ofile;
306 servtab_t *serv_list;
308 int maxsock; /* max fd# in allsock, -1: unknown */
309 /* whenever maxsock grows, prev_maxsock is set to new maxsock,
310 * but if maxsock is set to -1, prev_maxsock is not changed */
312 unsigned max_concurrency;
313 smallint alarm_armed;
314 uid_t real_uid; /* user ID who ran us */
315 const char *config_filename;
317 char *default_local_hostname;
318 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
324 /* Used in next_line(), and as scratch read buffer */
325 char line[256]; /* _at least_ 256, see LINE_SIZE */
327 #define G (*(struct globals*)&bb_common_bufsiz1)
328 enum { LINE_SIZE = COMMON_BUFSIZE - offsetof(struct globals, line) };
329 struct BUG_G_too_big {
330 char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
332 #define rlim_ofile_cur (G.rlim_ofile_cur )
333 #define rlim_ofile (G.rlim_ofile )
334 #define serv_list (G.serv_list )
335 #define global_queuelen (G.global_queuelen)
336 #define maxsock (G.maxsock )
337 #define prev_maxsock (G.prev_maxsock )
338 #define max_concurrency (G.max_concurrency)
339 #define alarm_armed (G.alarm_armed )
340 #define real_uid (G.real_uid )
341 #define config_filename (G.config_filename)
342 #define parser (G.parser )
343 #define default_local_hostname (G.default_local_hostname)
344 #define first_ps_byte (G.first_ps_byte )
345 #define last_ps_byte (G.last_ps_byte )
346 #define end_ring (G.end_ring )
347 #define ring_pos (G.ring_pos )
348 #define ring (G.ring )
349 #define allsock (G.allsock )
350 #define line (G.line )
351 #define INIT_G() do { \
352 rlim_ofile_cur = OPEN_MAX; \
353 global_queuelen = 128; \
354 config_filename = "/etc/inetd.conf"; \
357 static void maybe_close(int fd)
363 // TODO: move to libbb?
364 static len_and_sockaddr *xzalloc_lsa(int family)
366 len_and_sockaddr *lsa;
369 sz = sizeof(struct sockaddr_in);
370 if (family == AF_UNIX)
371 sz = sizeof(struct sockaddr_un);
372 #if ENABLE_FEATURE_IPV6
373 if (family == AF_INET6)
374 sz = sizeof(struct sockaddr_in6);
376 lsa = xzalloc(LSA_LEN_SIZE + sz);
378 lsa->u.sa.sa_family = family;
382 static void rearm_alarm(void)
390 static void block_CHLD_HUP_ALRM(sigset_t *m)
393 sigaddset(m, SIGCHLD);
394 sigaddset(m, SIGHUP);
395 sigaddset(m, SIGALRM);
396 sigprocmask(SIG_BLOCK, m, m); /* old sigmask is stored in m */
399 static void restore_sigmask(sigset_t *m)
401 sigprocmask(SIG_SETMASK, m, NULL);
404 #if ENABLE_FEATURE_INETD_RPC
405 static void register_rpc(servtab_t *sep)
408 struct sockaddr_in ir_sin;
411 size = sizeof(ir_sin);
412 if (getsockname(sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) {
413 bb_perror_msg("getsockname");
417 for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) {
418 pmap_unset(sep->se_rpcprog, n);
419 if (!pmap_set(sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port)))
420 bb_perror_msg("%s %s: pmap_set(%u,%u,%u,%u)",
421 sep->se_service, sep->se_proto,
422 sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port));
426 static void unregister_rpc(servtab_t *sep)
430 for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) {
431 if (!pmap_unset(sep->se_rpcprog, n))
432 bb_perror_msg("pmap_unset(%u,%u)", sep->se_rpcprog, n);
435 #endif /* FEATURE_INETD_RPC */
437 static void bump_nofile(void)
439 enum { FD_CHUNK = 32 };
442 /* Never fails under Linux (except if you pass it bad arguments) */
443 getrlimit(RLIMIT_NOFILE, &rl);
444 rl.rlim_cur = MIN(rl.rlim_max, rl.rlim_cur + FD_CHUNK);
445 rl.rlim_cur = MIN(FD_SETSIZE, rl.rlim_cur + FD_CHUNK);
446 if (rl.rlim_cur <= rlim_ofile_cur) {
447 bb_error_msg("can't extend file limit, max = %d",
452 if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
453 bb_perror_msg("setrlimit");
457 rlim_ofile_cur = rl.rlim_cur;
460 static void remove_fd_from_set(int fd)
463 FD_CLR(fd, &allsock);
468 static void add_fd_to_set(int fd)
471 FD_SET(fd, &allsock);
472 if (maxsock >= 0 && fd > maxsock) {
473 prev_maxsock = maxsock = fd;
474 if ((rlim_t)fd > rlim_ofile_cur - FD_MARGIN)
480 static void recalculate_maxsock(void)
484 /* We may have no services, in this case maxsock should still be >= 0
485 * (code elsewhere is not happy with maxsock == -1) */
487 while (fd <= prev_maxsock) {
488 if (FD_ISSET(fd, &allsock))
492 prev_maxsock = maxsock;
493 if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
497 static void prepare_socket_fd(servtab_t *sep)
501 fd = socket(sep->se_family, sep->se_socktype, 0);
503 bb_perror_msg("socket");
506 setsockopt_reuseaddr(fd);
508 #if ENABLE_FEATURE_INETD_RPC
509 if (is_rpc_service(sep)) {
512 /* zero out the port for all RPC services; let bind()
514 set_nport(&sep->se_lsa->u.sa, 0);
516 /* for RPC services, attempt to use a reserved port
517 * if they are going to be running as root. */
518 if (real_uid == 0 && sep->se_family == AF_INET
519 && (pwd = getpwnam(sep->se_user)) != NULL
522 r = bindresvport(fd, &sep->se_lsa->u.sin);
524 r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len);
527 int saveerrno = errno;
528 /* update lsa with port# */
529 getsockname(fd, &sep->se_lsa->u.sa, &sep->se_lsa->len);
535 if (sep->se_family == AF_UNIX) {
536 struct sockaddr_un *sun;
537 sun = (struct sockaddr_un*)&(sep->se_lsa->u.sa);
538 unlink(sun->sun_path);
540 r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len);
543 bb_perror_msg("%s/%s: bind",
544 sep->se_service, sep->se_proto);
549 if (sep->se_socktype == SOCK_STREAM)
550 listen(fd, global_queuelen);
556 static int reopen_config_file(void)
558 free(default_local_hostname);
559 default_local_hostname = xstrdup("*");
561 config_close(parser);
562 parser = config_open(config_filename);
563 return (parser != NULL);
566 static void close_config_file(void)
569 config_close(parser);
574 static void free_servtab_strings(servtab_t *cp)
578 free(cp->se_local_hostname);
579 free(cp->se_service);
583 free(cp->se_lsa); /* not a string in fact */
584 free(cp->se_program);
585 for (i = 0; i < MAXARGV; i++)
586 free(cp->se_argv[i]);
589 static servtab_t *new_servtab(void)
591 servtab_t *newtab = xzalloc(sizeof(servtab_t));
592 newtab->se_fd = -1; /* paranoia */
596 static servtab_t *dup_servtab(servtab_t *sep)
601 newtab = new_servtab();
602 *newtab = *sep; /* struct copy */
603 /* deep-copying strings */
604 newtab->se_service = xstrdup(newtab->se_service);
605 newtab->se_proto = xstrdup(newtab->se_proto);
606 newtab->se_user = xstrdup(newtab->se_user);
607 newtab->se_group = xstrdup(newtab->se_group);
608 newtab->se_program = xstrdup(newtab->se_program);
609 for (argc = 0; argc <= MAXARGV; argc++)
610 newtab->se_argv[argc] = xstrdup(newtab->se_argv[argc]);
611 /* NB: se_fd, se_hostaddr and se_next are always
612 * overwrittend by callers, so we don't bother resetting them
613 * to NULL/0/-1 etc */
618 /* gcc generates much more code if this is inlined */
619 static servtab_t *parse_one_line(void)
622 char *token[6+MAXARGV];
630 argc = config_read(parser, token, 6+MAXARGV, 1, "# \t", PARSE_NORMAL);
636 /* [host:]service socktype proto wait user[:group] prog [args] */
637 /* Check for "host:...." line */
639 hostdelim = strrchr(arg, ':');
642 sep->se_local_hostname = xstrdup(arg);
644 if (*arg == '\0' && argc == 1) {
645 /* Line has just "host:", change the
646 * default host for the following lines. */
647 free(default_local_hostname);
648 default_local_hostname = sep->se_local_hostname;
652 sep->se_local_hostname = xstrdup(default_local_hostname);
654 /* service socktype proto wait user[:group] prog [args] */
655 sep->se_service = xstrdup(arg);
657 /* socktype proto wait user[:group] prog [args] */
660 bb_error_msg("parse error on line %u, line is ignored",
662 free_servtab_strings(sep);
663 /* Just "goto more" can make sep to carry over e.g.
664 * "rpc"-ness (by having se_rpcver_lo != 0).
665 * We will be more paranoid: */
671 static const int8_t SOCK_xxx[] ALIGN1 = {
673 SOCK_STREAM, SOCK_DGRAM, SOCK_RDM,
674 SOCK_SEQPACKET, SOCK_RAW
676 sep->se_socktype = SOCK_xxx[1 + index_in_strings(
677 "stream""\0" "dgram""\0" "rdm""\0"
678 "seqpacket""\0" "raw""\0"
682 /* {unix,[rpc/]{tcp,udp}[6]} wait user[:group] prog [args] */
683 sep->se_proto = arg = xstrdup(token[2]);
684 if (strcmp(arg, "unix") == 0) {
685 sep->se_family = AF_UNIX;
688 sep->se_family = AF_INET;
689 six = last_char_is(arg, '6');
691 #if ENABLE_FEATURE_IPV6
693 sep->se_family = AF_INET6;
695 bb_error_msg("%s: no support for IPv6", sep->se_proto);
699 if (strncmp(arg, "rpc/", 4) == 0) {
700 #if ENABLE_FEATURE_INETD_RPC
703 p = strchr(sep->se_service, '/');
705 bb_error_msg("no rpc version: '%s'", sep->se_service);
709 n = bb_strtou(p, &p, 10);
712 bb_error_msg("bad rpc version");
715 sep->se_rpcver_lo = sep->se_rpcver_hi = n;
718 n = bb_strtou(p, &p, 10);
719 if (n > INT_MAX || (int)n < sep->se_rpcver_lo)
721 sep->se_rpcver_hi = n;
726 bb_error_msg("no support for rpc services");
730 /* we don't really need getprotobyname()! */
731 if (strcmp(arg, "tcp") == 0)
732 sep->se_proto_no = IPPROTO_TCP; /* = 6 */
733 if (strcmp(arg, "udp") == 0)
734 sep->se_proto_no = IPPROTO_UDP; /* = 17 */
737 if (!sep->se_proto_no) /* not tcp/udp?? */
741 /* [no]wait[.max] user[:group] prog [args] */
743 sep->se_max = max_concurrency;
744 p = strchr(arg, '.');
747 sep->se_max = bb_strtou(p, NULL, 10);
751 sep->se_wait = (arg[0] != 'n' || arg[1] != 'o');
752 if (!sep->se_wait) /* "no" seen */
754 if (strcmp(arg, "wait") != 0)
757 /* user[:group] prog [args] */
758 sep->se_user = xstrdup(token[4]);
759 arg = strchr(sep->se_user, '.');
761 arg = strchr(sep->se_user, ':');
764 sep->se_group = xstrdup(arg);
768 sep->se_program = xstrdup(token[5]);
769 #ifdef INETD_BUILTINS_ENABLED
770 if (strcmp(sep->se_program, "internal") == 0
771 && strlen(sep->se_service) <= 7
772 && (sep->se_socktype == SOCK_STREAM
773 || sep->se_socktype == SOCK_DGRAM)
776 for (i = 0; i < ARRAY_SIZE(builtins); i++)
777 if (strncmp(builtins[i].bi_service7, sep->se_service, 7) == 0)
779 bb_error_msg("unknown internal service %s", sep->se_service);
782 sep->se_builtin = &builtins[i];
783 /* stream builtins must be "nowait", dgram must be "wait" */
784 if (sep->se_wait != (sep->se_socktype == SOCK_DGRAM))
789 while ((arg = token[6+argc]) != NULL && argc < MAXARGV)
790 sep->se_argv[argc++] = xstrdup(arg);
791 /* Some inetd.conf files have no argv's, not even argv[0].
793 * (Technically, programs can be execed with argv[0] = NULL,
794 * but many programs do not like that at all) */
796 sep->se_argv[0] = xstrdup(sep->se_program);
798 /* catch mixups. "<service> stream udp ..." == wtf */
799 if (sep->se_socktype == SOCK_STREAM) {
800 if (sep->se_proto_no == IPPROTO_UDP)
803 if (sep->se_socktype == SOCK_DGRAM) {
804 if (sep->se_proto_no == IPPROTO_TCP)
809 // "ENTRY[%s][%s][%s][%d][%d][%d][%d][%d][%s][%s][%s]",
810 // sep->se_local_hostname, sep->se_service, sep->se_proto, sep->se_wait, sep->se_proto_no,
811 // sep->se_max, sep->se_count, sep->se_time, sep->se_user, sep->se_group, sep->se_program);
813 /* check if the hostname specifier is a comma separated list
814 * of hostnames. we'll make new entries for each address. */
815 while ((hostdelim = strrchr(sep->se_local_hostname, ',')) != NULL) {
816 nsep = dup_servtab(sep);
817 /* NUL terminate the hostname field of the existing entry,
818 * and make a dup for the new entry. */
820 nsep->se_local_hostname = xstrdup(hostdelim);
821 nsep->se_next = sep->se_next;
825 /* was doing it here: */
826 /* DNS resolution, create copies for each IP address */
827 /* IPv6-ization destroyed it :( */
832 static servtab_t *insert_in_servlist(servtab_t *cp)
838 *sep = *cp; /* struct copy */
840 #if ENABLE_FEATURE_INETD_RPC
841 sep->se_rpcprog = -1;
843 block_CHLD_HUP_ALRM(&omask);
844 sep->se_next = serv_list;
846 restore_sigmask(&omask);
850 static int same_serv_addr_proto(servtab_t *old, servtab_t *new)
852 if (strcmp(old->se_local_hostname, new->se_local_hostname) != 0)
854 if (strcmp(old->se_service, new->se_service) != 0)
856 if (strcmp(old->se_proto, new->se_proto) != 0)
861 static void reread_config_file(int sig UNUSED_PARAM)
863 servtab_t *sep, *cp, **sepp;
864 len_and_sockaddr *lsa;
868 int save_errno = errno;
870 if (!reopen_config_file())
872 for (sep = serv_list; sep; sep = sep->se_next)
879 cp = parse_one_line();
883 for (sep = serv_list; sep; sep = sep->se_next)
884 if (same_serv_addr_proto(sep, cp))
886 /* not an "equal" servtab */
887 sep = insert_in_servlist(cp);
893 block_CHLD_HUP_ALRM(&omask);
894 #if ENABLE_FEATURE_INETD_RPC
895 if (is_rpc_service(sep))
897 sep->se_rpcver_lo = cp->se_rpcver_lo;
898 sep->se_rpcver_hi = cp->se_rpcver_hi;
900 if (cp->se_wait == 0) {
901 /* New config says "nowait". If old one
902 * was "wait", we currently may be waiting
903 * for a child (and not accepting connects).
904 * Stop waiting, start listening again.
905 * (if it's not true, this op is harmless) */
906 add_fd_to_set(sep->se_fd);
908 sep->se_wait = cp->se_wait;
909 sep->se_max = cp->se_max;
910 /* string fields need more love - we don't want to leak them */
911 #define SWAP(type, a, b) do { type c = (type)a; a = (type)b; b = (type)c; } while (0)
912 SWAP(char*, sep->se_user, cp->se_user);
913 SWAP(char*, sep->se_group, cp->se_group);
914 SWAP(char*, sep->se_program, cp->se_program);
915 for (i = 0; i < MAXARGV; i++)
916 SWAP(char*, sep->se_argv[i], cp->se_argv[i]);
918 restore_sigmask(&omask);
919 free_servtab_strings(cp);
922 /* cp->string_fields are consumed by insert_in_servlist()
923 * or freed at this point, cp itself is not yet freed. */
926 /* create new len_and_sockaddr */
927 switch (sep->se_family) {
928 struct sockaddr_un *sun;
930 lsa = xzalloc_lsa(AF_UNIX);
931 sun = (struct sockaddr_un*)&lsa->u.sa;
932 safe_strncpy(sun->sun_path, sep->se_service, sizeof(sun->sun_path));
935 default: /* case AF_INET, case AF_INET6 */
936 n = bb_strtou(sep->se_service, NULL, 10);
937 #if ENABLE_FEATURE_INETD_RPC
938 if (is_rpc_service(sep)) {
940 if (errno) { /* se_service is not numeric */
941 struct rpcent *rp = getrpcbyname(sep->se_service);
943 bb_error_msg("%s: unknown rpc service", sep->se_service);
946 sep->se_rpcprog = rp->r_number;
948 if (sep->se_fd == -1)
949 prepare_socket_fd(sep);
950 if (sep->se_fd != -1)
955 /* what port to listen on? */
957 if (errno || n > 0xffff) { /* se_service is not numeric */
960 /* can result only in "tcp" or "udp": */
961 safe_strncpy(protoname, sep->se_proto, 4);
962 sp = getservbyname(sep->se_service, protoname);
964 bb_error_msg("%s/%s: unknown service",
965 sep->se_service, sep->se_proto);
970 if (LONE_CHAR(sep->se_local_hostname, '*')) {
971 lsa = xzalloc_lsa(sep->se_family);
972 set_nport(&lsa->u.sa, port);
974 lsa = host_and_af2sockaddr(sep->se_local_hostname,
975 ntohs(port), sep->se_family);
977 bb_error_msg("%s/%s: unknown host '%s'",
978 sep->se_service, sep->se_proto,
979 sep->se_local_hostname);
984 } /* end of "switch (sep->se_family)" */
986 /* did lsa change? Then close/open */
987 if (sep->se_lsa == NULL
988 || lsa->len != sep->se_lsa->len
989 || memcmp(&lsa->u.sa, &sep->se_lsa->u.sa, lsa->len) != 0
991 remove_fd_from_set(sep->se_fd);
992 maybe_close(sep->se_fd);
999 if (sep->se_fd == -1)
1000 prepare_socket_fd(sep);
1005 } /* end of "while (1) parse lines" */
1006 close_config_file();
1008 /* Purge anything not looked at above - these are stale entries,
1009 * new config file doesnt have them. */
1010 block_CHLD_HUP_ALRM(&omask);
1012 while ((sep = *sepp)) {
1013 if (sep->se_checked) {
1014 sepp = &sep->se_next;
1017 *sepp = sep->se_next;
1018 remove_fd_from_set(sep->se_fd);
1019 maybe_close(sep->se_fd);
1020 #if ENABLE_FEATURE_INETD_RPC
1021 if (is_rpc_service(sep))
1022 unregister_rpc(sep);
1024 if (sep->se_family == AF_UNIX)
1025 unlink(sep->se_service);
1026 free_servtab_strings(sep);
1029 restore_sigmask(&omask);
1034 static void reap_child(int sig UNUSED_PARAM)
1039 int save_errno = errno;
1042 pid = wait_any_nohang(&status);
1045 for (sep = serv_list; sep; sep = sep->se_next) {
1046 if (sep->se_wait != pid)
1048 /* One of our "wait" services */
1049 if (WIFEXITED(status) && WEXITSTATUS(status))
1050 bb_error_msg("%s: exit status %u",
1051 sep->se_program, WEXITSTATUS(status));
1052 else if (WIFSIGNALED(status))
1053 bb_error_msg("%s: exit signal %u",
1054 sep->se_program, WTERMSIG(status));
1056 add_fd_to_set(sep->se_fd);
1063 static void retry_network_setup(int sig UNUSED_PARAM)
1065 int save_errno = errno;
1069 for (sep = serv_list; sep; sep = sep->se_next) {
1070 if (sep->se_fd == -1) {
1071 prepare_socket_fd(sep);
1072 #if ENABLE_FEATURE_INETD_RPC
1073 if (sep->se_fd != -1 && is_rpc_service(sep))
1081 static void clean_up_and_exit(int sig UNUSED_PARAM)
1085 /* XXX signal race walking sep list */
1086 for (sep = serv_list; sep; sep = sep->se_next) {
1087 if (sep->se_fd == -1)
1090 switch (sep->se_family) {
1092 unlink(sep->se_service);
1094 default: /* case AF_INET, AF_INET6 */
1095 #if ENABLE_FEATURE_INETD_RPC
1096 if (sep->se_wait == 1 && is_rpc_service(sep))
1097 unregister_rpc(sep); /* XXX signal race */
1101 if (ENABLE_FEATURE_CLEAN_UP)
1104 remove_pidfile(_PATH_INETDPID);
1108 int inetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1109 int inetd_main(int argc UNUSED_PARAM, char **argv)
1111 struct sigaction sa, saved_pipe_handler;
1112 servtab_t *sep, *sep2;
1114 struct group *grp = grp; /* for compiler */
1121 real_uid = getuid();
1122 if (real_uid != 0) /* run by non-root user */
1123 config_filename = NULL;
1125 opt_complementary = "R+:q+"; /* -q N, -R N */
1126 opt = getopt32(argv, "R:feq:", &max_concurrency, &global_queuelen);
1130 config_filename = argv[0];
1131 if (config_filename == NULL)
1132 bb_error_msg_and_die("non-root must specify config file");
1134 bb_daemonize_or_rexec(0, argv - optind);
1136 bb_sanitize_stdio();
1138 /* LOG_NDELAY: connect to syslog daemon NOW.
1139 * Otherwise, we may open syslog socket
1140 * in vforked child, making opened fds and syslog()
1141 * internal state inconsistent.
1142 * This was observed to leak file descriptors. */
1143 openlog(applet_name, LOG_PID | LOG_NDELAY, LOG_DAEMON);
1144 logmode = LOGMODE_SYSLOG;
1147 if (real_uid == 0) {
1148 /* run by root, ensure groups vector gets trashed */
1149 gid_t gid = getgid();
1153 write_pidfile(_PATH_INETDPID);
1155 /* never fails under Linux (except if you pass it bad arguments) */
1156 getrlimit(RLIMIT_NOFILE, &rlim_ofile);
1157 rlim_ofile_cur = rlim_ofile.rlim_cur;
1158 if (rlim_ofile_cur == RLIM_INFINITY) /* ! */
1159 rlim_ofile_cur = OPEN_MAX;
1161 memset(&sa, 0, sizeof(sa));
1162 /*sigemptyset(&sa.sa_mask); - memset did it */
1163 sigaddset(&sa.sa_mask, SIGALRM);
1164 sigaddset(&sa.sa_mask, SIGCHLD);
1165 sigaddset(&sa.sa_mask, SIGHUP);
1166 //FIXME: explain why no SA_RESTART
1167 //FIXME: retry_network_setup is unsafe to run in signal handler (many reasons)!
1168 sa.sa_handler = retry_network_setup;
1169 sigaction_set(SIGALRM, &sa);
1170 //FIXME: reread_config_file is unsafe to run in signal handler(many reasons)!
1171 sa.sa_handler = reread_config_file;
1172 sigaction_set(SIGHUP, &sa);
1173 //FIXME: reap_child is unsafe to run in signal handler (uses stdio)!
1174 sa.sa_handler = reap_child;
1175 sigaction_set(SIGCHLD, &sa);
1176 //FIXME: clean_up_and_exit is unsafe to run in signal handler (uses stdio)!
1177 sa.sa_handler = clean_up_and_exit;
1178 sigaction_set(SIGTERM, &sa);
1179 sa.sa_handler = clean_up_and_exit;
1180 sigaction_set(SIGINT, &sa);
1181 sa.sa_handler = SIG_IGN;
1182 sigaction(SIGPIPE, &sa, &saved_pipe_handler);
1184 reread_config_file(SIGHUP); /* load config from file */
1188 int ctrl, accepted_fd, new_udp_fd;
1192 recalculate_maxsock();
1194 readable = allsock; /* struct copy */
1195 /* if there are no fds to wait on, we will block
1196 * until signal wakes us up (maxsock == 0, but readable
1197 * never contains fds 0 and 1...) */
1198 ready_fd_cnt = select(maxsock + 1, &readable, NULL, NULL, NULL);
1199 if (ready_fd_cnt < 0) {
1200 if (errno != EINTR) {
1201 bb_perror_msg("select");
1207 for (sep = serv_list; ready_fd_cnt && sep; sep = sep->se_next) {
1208 if (sep->se_fd == -1 || !FD_ISSET(sep->se_fd, &readable))
1215 if (!sep->se_wait) {
1216 if (sep->se_socktype == SOCK_STREAM) {
1217 ctrl = accepted_fd = accept(sep->se_fd, NULL, NULL);
1220 bb_perror_msg("accept (for %s)", sep->se_service);
1225 if (sep->se_socktype == SOCK_DGRAM
1226 && sep->se_family != AF_UNIX
1228 /* How udp "nowait" works:
1229 * child peeks at (received and buffered by kernel) UDP packet,
1230 * performs connect() on the socket so that it is linked only
1231 * to this peer. But this also affects parent, because descriptors
1232 * are shared after fork() a-la dup(). When parent performs
1233 * select(), it will see this descriptor connected to the peer (!)
1234 * and still readable, will act on it and mess things up
1235 * (can create many copies of same child, etc).
1236 * Parent must create and use new socket instead. */
1237 new_udp_fd = socket(sep->se_family, SOCK_DGRAM, 0);
1238 if (new_udp_fd < 0) { /* error: eat packet, forget about it */
1240 recv(sep->se_fd, line, LINE_SIZE, MSG_DONTWAIT);
1243 setsockopt_reuseaddr(new_udp_fd);
1244 /* TODO: better do bind after vfork in parent,
1245 * so that we don't have two wildcard bound sockets
1246 * even for a brief moment? */
1247 if (bind(new_udp_fd, &sep->se_lsa->u.sa, sep->se_lsa->len) < 0) {
1254 block_CHLD_HUP_ALRM(&omask);
1256 #ifdef INETD_BUILTINS_ENABLED
1257 /* do we need to fork? */
1258 if (sep->se_builtin == NULL
1259 || (sep->se_socktype == SOCK_STREAM
1260 && sep->se_builtin->bi_fork))
1263 if (sep->se_max != 0) {
1264 if (++sep->se_count == 1)
1265 sep->se_time = monotonic_sec();
1266 else if (sep->se_count >= sep->se_max) {
1267 unsigned now = monotonic_sec();
1268 /* did we accumulate se_max connects too quickly? */
1269 if (now - sep->se_time <= CNT_INTERVAL) {
1270 bb_error_msg("%s/%s: too many connections, pausing",
1271 sep->se_service, sep->se_proto);
1272 remove_fd_from_set(sep->se_fd);
1276 rearm_alarm(); /* will revive it in RETRYTIME sec */
1277 restore_sigmask(&omask);
1278 maybe_close(accepted_fd);
1279 continue; /* -> check next fd in fd set */
1284 /* on NOMMU, streamed chargen
1285 * builtin wouldn't work, but it is
1286 * not allowed on NOMMU (ifdefed out) */
1287 #ifdef INETD_BUILTINS_ENABLED
1288 if (BB_MMU && sep->se_builtin)
1294 if (pid < 0) { /* fork error */
1295 bb_perror_msg("vfork"+1);
1297 restore_sigmask(&omask);
1298 maybe_close(accepted_fd);
1299 continue; /* -> check next fd in fd set */
1302 pid--; /* -1: "we did fork and we are child" */
1304 /* if pid == 0 here, we never forked */
1306 if (pid > 0) { /* parent */
1308 /* tcp wait: we passed listening socket to child,
1309 * will wait for child to terminate */
1311 remove_fd_from_set(sep->se_fd);
1313 if (new_udp_fd >= 0) {
1314 /* udp nowait: child connected the socket,
1315 * we created and will use new, unconnected one */
1316 xmove_fd(new_udp_fd, sep->se_fd);
1318 restore_sigmask(&omask);
1319 maybe_close(accepted_fd);
1320 continue; /* -> check next fd in fd set */
1323 /* we are either child or didn't vfork at all */
1324 #ifdef INETD_BUILTINS_ENABLED
1325 if (sep->se_builtin) {
1326 if (pid) { /* "pid" is -1: we did vfork */
1327 close(sep->se_fd); /* listening socket */
1328 logmode = LOGMODE_NONE; /* make xwrite etc silent */
1330 restore_sigmask(&omask);
1331 if (sep->se_socktype == SOCK_STREAM)
1332 sep->se_builtin->bi_stream_fn(ctrl, sep);
1334 sep->se_builtin->bi_dgram_fn(ctrl, sep);
1335 if (pid) /* we did vfork */
1336 _exit(EXIT_FAILURE);
1337 maybe_close(accepted_fd);
1338 continue; /* -> check next fd in fd set */
1344 if (new_udp_fd >= 0) {
1345 len_and_sockaddr *lsa = xzalloc_lsa(sep->se_family);
1346 /* peek at the packet and remember peer addr */
1347 int r = recvfrom(ctrl, NULL, 0, MSG_PEEK|MSG_DONTWAIT,
1348 &lsa->u.sa, &lsa->len);
1351 /* make this socket "connected" to peer addr:
1352 * only packets from this peer will be recv'ed,
1353 * and bare write()/send() will work on it */
1354 connect(ctrl, &lsa->u.sa, lsa->len);
1357 /* prepare env and exec program */
1358 pwd = getpwnam(sep->se_user);
1360 bb_error_msg("%s: no such %s", sep->se_user, "user");
1363 if (sep->se_group && (grp = getgrnam(sep->se_group)) == NULL) {
1364 bb_error_msg("%s: no such %s", sep->se_group, "group");
1367 if (real_uid != 0 && real_uid != pwd->pw_uid) {
1368 /* a user running private inetd */
1369 bb_error_msg("non-root must run services as himself");
1374 pwd->pw_gid = grp->gr_gid;
1375 /* initgroups, setgid, setuid: */
1376 change_identity(pwd);
1377 } else if (sep->se_group) {
1378 xsetgid(grp->gr_gid);
1379 setgroups(1, &grp->gr_gid);
1381 if (rlim_ofile.rlim_cur != rlim_ofile_cur)
1382 if (setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0)
1383 bb_perror_msg("setrlimit");
1385 /* closelog(); - WRONG. we are after vfork,
1386 * this may confuse syslog() internal state.
1387 * Let's hope libc sets syslog fd to CLOEXEC...
1389 xmove_fd(ctrl, STDIN_FILENO);
1390 xdup2(STDIN_FILENO, STDOUT_FILENO);
1391 /* manpages of inetd I managed to find either say
1392 * that stderr is also redirected to the network,
1393 * or do not talk about redirection at all (!) */
1394 if (!sep->se_wait) /* only for usual "tcp nowait" */
1395 xdup2(STDIN_FILENO, STDERR_FILENO);
1396 /* NB: among others, this loop closes listening sockets
1397 * for nowait stream children */
1398 for (sep2 = serv_list; sep2; sep2 = sep2->se_next)
1399 if (sep2->se_fd != ctrl)
1400 maybe_close(sep2->se_fd);
1401 sigaction_set(SIGPIPE, &saved_pipe_handler);
1402 restore_sigmask(&omask);
1403 BB_EXECVP(sep->se_program, sep->se_argv);
1404 bb_perror_msg("can't execute '%s'", sep->se_program);
1406 /* eat packet in udp case */
1407 if (sep->se_socktype != SOCK_STREAM)
1408 recv(0, line, LINE_SIZE, MSG_DONTWAIT);
1409 _exit(EXIT_FAILURE);
1410 } /* for (sep = servtab...) */
1415 static const char *const cat_args[] = { "cat", NULL };
1419 * Internet services provided internally by inetd:
1421 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
1422 /* Echo service -- echo data back. */
1424 static void FAST_FUNC echo_stream(int s, servtab_t *sep UNUSED_PARAM)
1428 ssize_t sz = safe_read(s, line, LINE_SIZE);
1431 xwrite(s, line, sz);
1434 /* We are after vfork here! */
1435 /* move network socket to stdin/stdout */
1436 xmove_fd(s, STDIN_FILENO);
1437 xdup2(STDIN_FILENO, STDOUT_FILENO);
1438 /* no error messages please... */
1439 close(STDERR_FILENO);
1440 xopen(bb_dev_null, O_WRONLY);
1441 BB_EXECVP("cat", (char**)cat_args);
1442 /* on failure we return to main, which does exit(EXIT_FAILURE) */
1445 static void FAST_FUNC echo_dg(int s, servtab_t *sep)
1447 enum { BUFSIZE = 12*1024 }; /* for jumbo sized packets! :) */
1448 char *buf = xmalloc(BUFSIZE); /* too big for stack */
1450 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1452 lsa->len = sep->se_lsa->len;
1453 /* dgram builtins are non-forking - DONT BLOCK! */
1454 sz = recvfrom(s, buf, BUFSIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len);
1456 sendto(s, buf, sz, 0, &lsa->u.sa, lsa->len);
1459 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_ECHO */
1462 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
1463 /* Discard service -- ignore data. */
1465 static void FAST_FUNC discard_stream(int s, servtab_t *sep UNUSED_PARAM)
1468 while (safe_read(s, line, LINE_SIZE) > 0)
1471 /* We are after vfork here! */
1472 /* move network socket to stdin */
1473 xmove_fd(s, STDIN_FILENO);
1474 /* discard output */
1475 close(STDOUT_FILENO);
1476 xopen(bb_dev_null, O_WRONLY);
1477 /* no error messages please... */
1478 xdup2(STDOUT_FILENO, STDERR_FILENO);
1479 BB_EXECVP("cat", (char**)cat_args);
1480 /* on failure we return to main, which does exit(EXIT_FAILURE) */
1484 static void FAST_FUNC discard_dg(int s, servtab_t *sep UNUSED_PARAM)
1486 /* dgram builtins are non-forking - DONT BLOCK! */
1487 recv(s, line, LINE_SIZE, MSG_DONTWAIT);
1489 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */
1492 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
1494 static void init_ring(void)
1499 for (i = ' '; i < 127; i++)
1502 /* Character generator. MMU arches only. */
1504 static void FAST_FUNC chargen_stream(int s, servtab_t *sep UNUSED_PARAM)
1508 char text[LINESIZ + 2];
1515 text[LINESIZ] = '\r';
1516 text[LINESIZ + 1] = '\n';
1519 len = end_ring - rs;
1521 memmove(text, rs, LINESIZ);
1523 memmove(text, rs, len);
1524 memmove(text + len, ring, LINESIZ - len);
1526 if (++rs == end_ring)
1528 xwrite(s, text, sizeof(text));
1532 static void FAST_FUNC chargen_dg(int s, servtab_t *sep)
1535 char text[LINESIZ + 2];
1536 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1538 /* Eat UDP packet which started it all */
1539 /* dgram builtins are non-forking - DONT BLOCK! */
1540 lsa->len = sep->se_lsa->len;
1541 if (recvfrom(s, text, sizeof(text), MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1549 len = end_ring - ring_pos;
1551 memmove(text, ring_pos, LINESIZ);
1553 memmove(text, ring_pos, len);
1554 memmove(text + len, ring, LINESIZ - len);
1556 if (++ring_pos == end_ring)
1558 text[LINESIZ] = '\r';
1559 text[LINESIZ + 1] = '\n';
1560 sendto(s, text, sizeof(text), 0, &lsa->u.sa, lsa->len);
1562 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */
1565 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
1567 * Return a machine readable date and time, in the form of the
1568 * number of seconds since midnight, Jan 1, 1900. Since gettimeofday
1569 * returns the number of seconds since midnight, Jan 1, 1970,
1570 * we must add 2208988800 seconds to this figure to make up for
1571 * some seventy years Bell Labs was asleep.
1573 static uint32_t machtime(void)
1577 gettimeofday(&tv, NULL);
1578 return htonl((uint32_t)(tv.tv_sec + 2208988800));
1581 static void FAST_FUNC machtime_stream(int s, servtab_t *sep UNUSED_PARAM)
1585 result = machtime();
1586 full_write(s, &result, sizeof(result));
1588 static void FAST_FUNC machtime_dg(int s, servtab_t *sep)
1591 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1593 lsa->len = sep->se_lsa->len;
1594 if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1597 result = machtime();
1598 sendto(s, &result, sizeof(result), 0, &lsa->u.sa, lsa->len);
1600 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_TIME */
1603 #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
1604 /* Return human-readable time of day */
1606 static void FAST_FUNC daytime_stream(int s, servtab_t *sep UNUSED_PARAM)
1611 fdprintf(s, "%.24s\r\n", ctime(&t));
1613 static void FAST_FUNC daytime_dg(int s, servtab_t *sep)
1616 len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len);
1618 lsa->len = sep->se_lsa->len;
1619 if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0)
1623 sprintf(line, "%.24s\r\n", ctime(&t));
1624 sendto(s, line, strlen(line), 0, &lsa->u.sa, lsa->len);
1626 #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */