blob: aebb9178b30722e9c2b4db64b13239323f1cc3b7
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 */ |
7 | /* |
8 | * Copyright (c) 1983,1991 The Regents of the University of California. |
9 | * All rights reserved. |
10 | * |
11 | * Redistribution and use in source and binary forms, with or without |
12 | * modification, are permitted provided that the following conditions |
13 | * are met: |
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. |
26 | * |
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 |
37 | * SUCH DAMAGE. |
38 | */ |
39 | |
40 | /* Inetd - Internet super-server |
41 | * |
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 |
48 | * and port. |
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 |
52 | * using recvfrom. |
53 | * |
54 | * Inetd uses a configuration file which is read at startup |
55 | * and, possibly, at some later time in response to a hangup signal. |
56 | * The configuration file is "free format" with fields given in the |
57 | * order shown below. Continuation lines for an entry must begin with |
58 | * a space or tab. All fields must be present in each entry. |
59 | * |
60 | * service_name must be in /etc/services |
61 | * socket_type stream/dgram/raw/rdm/seqpacket |
62 | * protocol must be in /etc/protocols |
63 | * (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) |
68 | * |
69 | * For RPC services |
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) |
77 | * |
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. |
82 | * |
83 | * A line can also consist of just |
84 | * hostaddress: |
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 |
90 | * *: |
91 | * is implicitly in effect at the beginning of the file. |
92 | * |
93 | * The hostaddress specifier may (and often will) contain dots; |
94 | * the service name must not. |
95 | * |
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. |
101 | * |
102 | * Comment lines are indicated by a '#' in column 1. |
103 | */ |
104 | |
105 | /* inetd rules for passing file descriptors to children |
106 | * (http://www.freebsd.org/cgi/man.cgi?query=inetd): |
107 | * |
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. |
124 | * |
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. |
133 | */ |
134 | |
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. |
140 | */ |
141 | |
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) |
147 | * setuid() |
148 | * 2) group is specified: |
149 | * a) user = root: setgid(specified group) |
150 | * NO initgroups() |
151 | * NO setuid() |
152 | * b) other: initgroups(name, specified group) |
153 | * setgid(specified group) |
154 | * setuid() |
155 | */ |
156 | |
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)" |
166 | |
167 | #include <syslog.h> |
168 | #include <sys/resource.h> /* setrlimit */ |
169 | #include <sys/socket.h> /* un.h may need this */ |
170 | #include <sys/un.h> |
171 | |
172 | #include "libbb.h" |
173 | |
174 | #if ENABLE_FEATURE_INETD_RPC |
175 | # if defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_RPC__) |
176 | # error "You need to build uClibc with UCLIBC_HAS_RPC for NFS support" |
177 | # endif |
178 | # include <rpc/rpc.h> |
179 | # include <rpc/pmap_clnt.h> |
180 | #endif |
181 | |
182 | #if !BB_MMU |
183 | /* stream version of chargen is forking but not execing, |
184 | * can't do that (easily) on NOMMU */ |
185 | #undef ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN |
186 | #define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN 0 |
187 | #endif |
188 | |
189 | #define CNT_INTERVAL 60 /* servers in CNT_INTERVAL sec. */ |
190 | #define RETRYTIME 60 /* retry after bind or server fail */ |
191 | |
192 | // TODO: explain, or get rid of setrlimit games |
193 | |
194 | #ifndef RLIMIT_NOFILE |
195 | #define RLIMIT_NOFILE RLIMIT_OFILE |
196 | #endif |
197 | |
198 | #ifndef OPEN_MAX |
199 | #define OPEN_MAX 64 |
200 | #endif |
201 | |
202 | /* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */ |
203 | #define FD_MARGIN 8 |
204 | |
205 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD \ |
206 | || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO \ |
207 | || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN \ |
208 | || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME \ |
209 | || ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME |
210 | # define INETD_BUILTINS_ENABLED |
211 | #endif |
212 | |
213 | typedef struct servtab_t { |
214 | /* The most frequently referenced one: */ |
215 | int se_fd; /* open descriptor */ |
216 | /* NB: 'biggest fields last' saves on code size (~250 bytes) */ |
217 | /* [addr:]service socktype proto wait user[:group] prog [args] */ |
218 | char *se_local_hostname; /* addr to listen on */ |
219 | char *se_service; /* "80" or "www" or "mount/2[-3]" */ |
220 | /* socktype is in se_socktype */ /* "stream" "dgram" "raw" "rdm" "seqpacket" */ |
221 | char *se_proto; /* "unix" or "[rpc/]tcp[6]" */ |
222 | #if ENABLE_FEATURE_INETD_RPC |
223 | int se_rpcprog; /* rpc program number */ |
224 | int se_rpcver_lo; /* rpc program lowest version */ |
225 | int se_rpcver_hi; /* rpc program highest version */ |
226 | #define is_rpc_service(sep) ((sep)->se_rpcver_lo != 0) |
227 | #else |
228 | #define is_rpc_service(sep) 0 |
229 | #endif |
230 | pid_t se_wait; /* 0:"nowait", 1:"wait", >1:"wait" */ |
231 | /* and waiting for this pid */ |
232 | socktype_t se_socktype; /* SOCK_STREAM/DGRAM/RDM/... */ |
233 | family_t se_family; /* AF_UNIX/INET[6] */ |
234 | /* se_proto_no is used by RPC code only... hmm */ |
235 | smallint se_proto_no; /* IPPROTO_TCP/UDP, n/a for AF_UNIX */ |
236 | smallint se_checked; /* looked at during merge */ |
237 | unsigned se_max; /* allowed instances per minute */ |
238 | unsigned se_count; /* number started since se_time */ |
239 | unsigned se_time; /* when we started counting */ |
240 | char *se_user; /* user name to run as */ |
241 | char *se_group; /* group name to run as, can be NULL */ |
242 | #ifdef INETD_BUILTINS_ENABLED |
243 | const struct builtin *se_builtin; /* if built-in, description */ |
244 | #endif |
245 | struct servtab_t *se_next; |
246 | len_and_sockaddr *se_lsa; |
247 | char *se_program; /* server program */ |
248 | #define MAXARGV 20 |
249 | char *se_argv[MAXARGV + 1]; /* program arguments */ |
250 | } servtab_t; |
251 | |
252 | #ifdef INETD_BUILTINS_ENABLED |
253 | /* Echo received data */ |
254 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO |
255 | static void FAST_FUNC echo_stream(int, servtab_t *); |
256 | static void FAST_FUNC echo_dg(int, servtab_t *); |
257 | #endif |
258 | /* Internet /dev/null */ |
259 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD |
260 | static void FAST_FUNC discard_stream(int, servtab_t *); |
261 | static void FAST_FUNC discard_dg(int, servtab_t *); |
262 | #endif |
263 | /* Return 32 bit time since 1900 */ |
264 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME |
265 | static void FAST_FUNC machtime_stream(int, servtab_t *); |
266 | static void FAST_FUNC machtime_dg(int, servtab_t *); |
267 | #endif |
268 | /* Return human-readable time */ |
269 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME |
270 | static void FAST_FUNC daytime_stream(int, servtab_t *); |
271 | static void FAST_FUNC daytime_dg(int, servtab_t *); |
272 | #endif |
273 | /* Familiar character generator */ |
274 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN |
275 | static void FAST_FUNC chargen_stream(int, servtab_t *); |
276 | static void FAST_FUNC chargen_dg(int, servtab_t *); |
277 | #endif |
278 | |
279 | struct builtin { |
280 | /* NB: not necessarily NUL terminated */ |
281 | char bi_service7[7]; /* internally provided service name */ |
282 | uint8_t bi_fork; /* 1 if stream fn should run in child */ |
283 | void (*bi_stream_fn)(int, servtab_t *) FAST_FUNC; |
284 | void (*bi_dgram_fn)(int, servtab_t *) FAST_FUNC; |
285 | }; |
286 | |
287 | static const struct builtin builtins[] = { |
288 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO |
289 | { "echo", 1, echo_stream, echo_dg }, |
290 | #endif |
291 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD |
292 | { "discard", 1, discard_stream, discard_dg }, |
293 | #endif |
294 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN |
295 | { "chargen", 1, chargen_stream, chargen_dg }, |
296 | #endif |
297 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME |
298 | { "time", 0, machtime_stream, machtime_dg }, |
299 | #endif |
300 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME |
301 | { "daytime", 0, daytime_stream, daytime_dg }, |
302 | #endif |
303 | }; |
304 | #endif /* INETD_BUILTINS_ENABLED */ |
305 | |
306 | struct globals { |
307 | rlim_t rlim_ofile_cur; |
308 | struct rlimit rlim_ofile; |
309 | servtab_t *serv_list; |
310 | int global_queuelen; |
311 | int maxsock; /* max fd# in allsock, -1: unknown */ |
312 | /* whenever maxsock grows, prev_maxsock is set to new maxsock, |
313 | * but if maxsock is set to -1, prev_maxsock is not changed */ |
314 | int prev_maxsock; |
315 | unsigned max_concurrency; |
316 | smallint alarm_armed; |
317 | uid_t real_uid; /* user ID who ran us */ |
318 | const char *config_filename; |
319 | parser_t *parser; |
320 | char *default_local_hostname; |
321 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN |
322 | char *end_ring; |
323 | char *ring_pos; |
324 | char ring[128]; |
325 | #endif |
326 | fd_set allsock; |
327 | /* Used in next_line(), and as scratch read buffer */ |
328 | char line[256]; /* _at least_ 256, see LINE_SIZE */ |
329 | } FIX_ALIASING; |
330 | #define G (*(struct globals*)&bb_common_bufsiz1) |
331 | enum { LINE_SIZE = COMMON_BUFSIZE - offsetof(struct globals, line) }; |
332 | struct BUG_G_too_big { |
333 | char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1]; |
334 | }; |
335 | #define rlim_ofile_cur (G.rlim_ofile_cur ) |
336 | #define rlim_ofile (G.rlim_ofile ) |
337 | #define serv_list (G.serv_list ) |
338 | #define global_queuelen (G.global_queuelen) |
339 | #define maxsock (G.maxsock ) |
340 | #define prev_maxsock (G.prev_maxsock ) |
341 | #define max_concurrency (G.max_concurrency) |
342 | #define alarm_armed (G.alarm_armed ) |
343 | #define real_uid (G.real_uid ) |
344 | #define config_filename (G.config_filename) |
345 | #define parser (G.parser ) |
346 | #define default_local_hostname (G.default_local_hostname) |
347 | #define first_ps_byte (G.first_ps_byte ) |
348 | #define last_ps_byte (G.last_ps_byte ) |
349 | #define end_ring (G.end_ring ) |
350 | #define ring_pos (G.ring_pos ) |
351 | #define ring (G.ring ) |
352 | #define allsock (G.allsock ) |
353 | #define line (G.line ) |
354 | #define INIT_G() do { \ |
355 | rlim_ofile_cur = OPEN_MAX; \ |
356 | global_queuelen = 128; \ |
357 | config_filename = "/etc/inetd.conf"; \ |
358 | } while (0) |
359 | |
360 | #if 1 |
361 | # define dbg(...) ((void)0) |
362 | #else |
363 | # define dbg(...) \ |
364 | do { \ |
365 | int dbg_fd = open("inetd_debug.log", O_WRONLY | O_CREAT | O_APPEND, 0666); \ |
366 | if (dbg_fd >= 0) { \ |
367 | fdprintf(dbg_fd, "%d: ", getpid()); \ |
368 | fdprintf(dbg_fd, __VA_ARGS__); \ |
369 | close(dbg_fd); \ |
370 | } \ |
371 | } while (0) |
372 | #endif |
373 | |
374 | static void maybe_close(int fd) |
375 | { |
376 | if (fd >= 0) { |
377 | close(fd); |
378 | dbg("closed fd:%d\n", fd); |
379 | } |
380 | } |
381 | |
382 | // TODO: move to libbb? |
383 | static len_and_sockaddr *xzalloc_lsa(int family) |
384 | { |
385 | len_and_sockaddr *lsa; |
386 | int sz; |
387 | |
388 | sz = sizeof(struct sockaddr_in); |
389 | if (family == AF_UNIX) |
390 | sz = sizeof(struct sockaddr_un); |
391 | #if ENABLE_FEATURE_IPV6 |
392 | if (family == AF_INET6) |
393 | sz = sizeof(struct sockaddr_in6); |
394 | #endif |
395 | lsa = xzalloc(LSA_LEN_SIZE + sz); |
396 | lsa->len = sz; |
397 | lsa->u.sa.sa_family = family; |
398 | return lsa; |
399 | } |
400 | |
401 | static void rearm_alarm(void) |
402 | { |
403 | if (!alarm_armed) { |
404 | alarm_armed = 1; |
405 | alarm(RETRYTIME); |
406 | } |
407 | } |
408 | |
409 | static void block_CHLD_HUP_ALRM(sigset_t *m) |
410 | { |
411 | sigemptyset(m); |
412 | sigaddset(m, SIGCHLD); |
413 | sigaddset(m, SIGHUP); |
414 | sigaddset(m, SIGALRM); |
415 | sigprocmask(SIG_BLOCK, m, m); /* old sigmask is stored in m */ |
416 | } |
417 | |
418 | static void restore_sigmask(sigset_t *m) |
419 | { |
420 | sigprocmask(SIG_SETMASK, m, NULL); |
421 | } |
422 | |
423 | #if ENABLE_FEATURE_INETD_RPC |
424 | static void register_rpc(servtab_t *sep) |
425 | { |
426 | int n; |
427 | struct sockaddr_in ir_sin; |
428 | socklen_t size; |
429 | |
430 | size = sizeof(ir_sin); |
431 | if (getsockname(sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) { |
432 | bb_perror_msg("getsockname"); |
433 | return; |
434 | } |
435 | |
436 | for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) { |
437 | pmap_unset(sep->se_rpcprog, n); |
438 | if (!pmap_set(sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port))) |
439 | bb_perror_msg("%s %s: pmap_set(%u,%u,%u,%u)", |
440 | sep->se_service, sep->se_proto, |
441 | sep->se_rpcprog, n, sep->se_proto_no, ntohs(ir_sin.sin_port)); |
442 | } |
443 | } |
444 | |
445 | static void unregister_rpc(servtab_t *sep) |
446 | { |
447 | int n; |
448 | |
449 | for (n = sep->se_rpcver_lo; n <= sep->se_rpcver_hi; n++) { |
450 | if (!pmap_unset(sep->se_rpcprog, n)) |
451 | bb_perror_msg("pmap_unset(%u,%u)", sep->se_rpcprog, n); |
452 | } |
453 | } |
454 | #endif /* FEATURE_INETD_RPC */ |
455 | |
456 | static void bump_nofile(void) |
457 | { |
458 | enum { FD_CHUNK = 32 }; |
459 | struct rlimit rl; |
460 | |
461 | /* Never fails under Linux (except if you pass it bad arguments) */ |
462 | getrlimit(RLIMIT_NOFILE, &rl); |
463 | rl.rlim_cur = MIN(rl.rlim_max, rl.rlim_cur + FD_CHUNK); |
464 | rl.rlim_cur = MIN(FD_SETSIZE, rl.rlim_cur + FD_CHUNK); |
465 | if (rl.rlim_cur <= rlim_ofile_cur) { |
466 | bb_error_msg("can't extend file limit, max = %d", |
467 | (int) rl.rlim_cur); |
468 | return; |
469 | } |
470 | |
471 | if (setrlimit(RLIMIT_NOFILE, &rl) < 0) { |
472 | bb_perror_msg("setrlimit"); |
473 | return; |
474 | } |
475 | |
476 | rlim_ofile_cur = rl.rlim_cur; |
477 | } |
478 | |
479 | static void remove_fd_from_set(int fd) |
480 | { |
481 | if (fd >= 0) { |
482 | FD_CLR(fd, &allsock); |
483 | dbg("stopped listening on fd:%d\n", fd); |
484 | maxsock = -1; |
485 | dbg("maxsock:%d\n", maxsock); |
486 | } |
487 | } |
488 | |
489 | static void add_fd_to_set(int fd) |
490 | { |
491 | if (fd >= 0) { |
492 | FD_SET(fd, &allsock); |
493 | dbg("started listening on fd:%d\n", fd); |
494 | if (maxsock >= 0 && fd > maxsock) { |
495 | prev_maxsock = maxsock = fd; |
496 | dbg("maxsock:%d\n", maxsock); |
497 | if ((rlim_t)fd > rlim_ofile_cur - FD_MARGIN) |
498 | bump_nofile(); |
499 | } |
500 | } |
501 | } |
502 | |
503 | static void recalculate_maxsock(void) |
504 | { |
505 | int fd = 0; |
506 | |
507 | /* We may have no services, in this case maxsock should still be >= 0 |
508 | * (code elsewhere is not happy with maxsock == -1) */ |
509 | maxsock = 0; |
510 | while (fd <= prev_maxsock) { |
511 | if (FD_ISSET(fd, &allsock)) |
512 | maxsock = fd; |
513 | fd++; |
514 | } |
515 | dbg("recalculated maxsock:%d\n", maxsock); |
516 | prev_maxsock = maxsock; |
517 | if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN) |
518 | bump_nofile(); |
519 | } |
520 | |
521 | static void prepare_socket_fd(servtab_t *sep) |
522 | { |
523 | int r, fd; |
524 | |
525 | fd = socket(sep->se_family, sep->se_socktype, 0); |
526 | if (fd < 0) { |
527 | bb_perror_msg("socket"); |
528 | return; |
529 | } |
530 | setsockopt_reuseaddr(fd); |
531 | |
532 | #if ENABLE_FEATURE_INETD_RPC |
533 | if (is_rpc_service(sep)) { |
534 | struct passwd *pwd; |
535 | |
536 | /* zero out the port for all RPC services; let bind() |
537 | * find one. */ |
538 | set_nport(&sep->se_lsa->u.sa, 0); |
539 | |
540 | /* for RPC services, attempt to use a reserved port |
541 | * if they are going to be running as root. */ |
542 | if (real_uid == 0 && sep->se_family == AF_INET |
543 | && (pwd = getpwnam(sep->se_user)) != NULL |
544 | && pwd->pw_uid == 0 |
545 | ) { |
546 | r = bindresvport(fd, &sep->se_lsa->u.sin); |
547 | } else { |
548 | r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len); |
549 | } |
550 | if (r == 0) { |
551 | int saveerrno = errno; |
552 | /* update lsa with port# */ |
553 | getsockname(fd, &sep->se_lsa->u.sa, &sep->se_lsa->len); |
554 | errno = saveerrno; |
555 | } |
556 | } else |
557 | #endif |
558 | { |
559 | if (sep->se_family == AF_UNIX) { |
560 | struct sockaddr_un *sun; |
561 | sun = (struct sockaddr_un*)&(sep->se_lsa->u.sa); |
562 | unlink(sun->sun_path); |
563 | } |
564 | r = bind(fd, &sep->se_lsa->u.sa, sep->se_lsa->len); |
565 | } |
566 | if (r < 0) { |
567 | bb_perror_msg("%s/%s: bind", |
568 | sep->se_service, sep->se_proto); |
569 | close(fd); |
570 | rearm_alarm(); |
571 | return; |
572 | } |
573 | |
574 | if (sep->se_socktype == SOCK_STREAM) { |
575 | listen(fd, global_queuelen); |
576 | dbg("new sep->se_fd:%d (stream)\n", fd); |
577 | } else { |
578 | dbg("new sep->se_fd:%d (!stream)\n", fd); |
579 | } |
580 | |
581 | add_fd_to_set(fd); |
582 | sep->se_fd = fd; |
583 | } |
584 | |
585 | static int reopen_config_file(void) |
586 | { |
587 | free(default_local_hostname); |
588 | default_local_hostname = xstrdup("*"); |
589 | if (parser != NULL) |
590 | config_close(parser); |
591 | parser = config_open(config_filename); |
592 | return (parser != NULL); |
593 | } |
594 | |
595 | static void close_config_file(void) |
596 | { |
597 | if (parser) { |
598 | config_close(parser); |
599 | parser = NULL; |
600 | } |
601 | } |
602 | |
603 | static void free_servtab_strings(servtab_t *cp) |
604 | { |
605 | int i; |
606 | |
607 | free(cp->se_local_hostname); |
608 | free(cp->se_service); |
609 | free(cp->se_proto); |
610 | free(cp->se_user); |
611 | free(cp->se_group); |
612 | free(cp->se_lsa); /* not a string in fact */ |
613 | free(cp->se_program); |
614 | for (i = 0; i < MAXARGV; i++) |
615 | free(cp->se_argv[i]); |
616 | } |
617 | |
618 | static servtab_t *new_servtab(void) |
619 | { |
620 | servtab_t *newtab = xzalloc(sizeof(servtab_t)); |
621 | newtab->se_fd = -1; /* paranoia */ |
622 | return newtab; |
623 | } |
624 | |
625 | static servtab_t *dup_servtab(servtab_t *sep) |
626 | { |
627 | servtab_t *newtab; |
628 | int argc; |
629 | |
630 | newtab = new_servtab(); |
631 | *newtab = *sep; /* struct copy */ |
632 | /* deep-copying strings */ |
633 | newtab->se_service = xstrdup(newtab->se_service); |
634 | newtab->se_proto = xstrdup(newtab->se_proto); |
635 | newtab->se_user = xstrdup(newtab->se_user); |
636 | newtab->se_group = xstrdup(newtab->se_group); |
637 | newtab->se_program = xstrdup(newtab->se_program); |
638 | for (argc = 0; argc <= MAXARGV; argc++) |
639 | newtab->se_argv[argc] = xstrdup(newtab->se_argv[argc]); |
640 | /* NB: se_fd, se_hostaddr and se_next are always |
641 | * overwrittend by callers, so we don't bother resetting them |
642 | * to NULL/0/-1 etc */ |
643 | |
644 | return newtab; |
645 | } |
646 | |
647 | /* gcc generates much more code if this is inlined */ |
648 | static servtab_t *parse_one_line(void) |
649 | { |
650 | int argc; |
651 | char *token[6+MAXARGV]; |
652 | char *p, *arg; |
653 | char *hostdelim; |
654 | servtab_t *sep; |
655 | servtab_t *nsep; |
656 | new: |
657 | sep = new_servtab(); |
658 | more: |
659 | argc = config_read(parser, token, 6+MAXARGV, 1, "# \t", PARSE_NORMAL); |
660 | if (!argc) { |
661 | free(sep); |
662 | return NULL; |
663 | } |
664 | |
665 | /* [host:]service socktype proto wait user[:group] prog [args] */ |
666 | /* Check for "host:...." line */ |
667 | arg = token[0]; |
668 | hostdelim = strrchr(arg, ':'); |
669 | if (hostdelim) { |
670 | *hostdelim = '\0'; |
671 | sep->se_local_hostname = xstrdup(arg); |
672 | arg = hostdelim + 1; |
673 | if (*arg == '\0' && argc == 1) { |
674 | /* Line has just "host:", change the |
675 | * default host for the following lines. */ |
676 | free(default_local_hostname); |
677 | default_local_hostname = sep->se_local_hostname; |
678 | goto more; |
679 | } |
680 | } else |
681 | sep->se_local_hostname = xstrdup(default_local_hostname); |
682 | |
683 | /* service socktype proto wait user[:group] prog [args] */ |
684 | sep->se_service = xstrdup(arg); |
685 | |
686 | /* socktype proto wait user[:group] prog [args] */ |
687 | if (argc < 6) { |
688 | parse_err: |
689 | bb_error_msg("parse error on line %u, line is ignored", |
690 | parser->lineno); |
691 | free_servtab_strings(sep); |
692 | /* Just "goto more" can make sep to carry over e.g. |
693 | * "rpc"-ness (by having se_rpcver_lo != 0). |
694 | * We will be more paranoid: */ |
695 | free(sep); |
696 | goto new; |
697 | } |
698 | |
699 | { |
700 | static const int8_t SOCK_xxx[] ALIGN1 = { |
701 | -1, |
702 | SOCK_STREAM, SOCK_DGRAM, SOCK_RDM, |
703 | SOCK_SEQPACKET, SOCK_RAW |
704 | }; |
705 | sep->se_socktype = SOCK_xxx[1 + index_in_strings( |
706 | "stream""\0" "dgram""\0" "rdm""\0" |
707 | "seqpacket""\0" "raw""\0" |
708 | , token[1])]; |
709 | } |
710 | |
711 | /* {unix,[rpc/]{tcp,udp}[6]} wait user[:group] prog [args] */ |
712 | sep->se_proto = arg = xstrdup(token[2]); |
713 | if (strcmp(arg, "unix") == 0) { |
714 | sep->se_family = AF_UNIX; |
715 | } else { |
716 | char *six; |
717 | sep->se_family = AF_INET; |
718 | six = last_char_is(arg, '6'); |
719 | if (six) { |
720 | #if ENABLE_FEATURE_IPV6 |
721 | *six = '\0'; |
722 | sep->se_family = AF_INET6; |
723 | #else |
724 | bb_error_msg("%s: no support for IPv6", sep->se_proto); |
725 | goto parse_err; |
726 | #endif |
727 | } |
728 | if (strncmp(arg, "rpc/", 4) == 0) { |
729 | #if ENABLE_FEATURE_INETD_RPC |
730 | unsigned n; |
731 | arg += 4; |
732 | p = strchr(sep->se_service, '/'); |
733 | if (p == NULL) { |
734 | bb_error_msg("no rpc version: '%s'", sep->se_service); |
735 | goto parse_err; |
736 | } |
737 | *p++ = '\0'; |
738 | n = bb_strtou(p, &p, 10); |
739 | if (n > INT_MAX) { |
740 | bad_ver_spec: |
741 | bb_error_msg("bad rpc version"); |
742 | goto parse_err; |
743 | } |
744 | sep->se_rpcver_lo = sep->se_rpcver_hi = n; |
745 | if (*p == '-') { |
746 | p++; |
747 | n = bb_strtou(p, &p, 10); |
748 | if (n > INT_MAX || (int)n < sep->se_rpcver_lo) |
749 | goto bad_ver_spec; |
750 | sep->se_rpcver_hi = n; |
751 | } |
752 | if (*p != '\0') |
753 | goto bad_ver_spec; |
754 | #else |
755 | bb_error_msg("no support for rpc services"); |
756 | goto parse_err; |
757 | #endif |
758 | } |
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 */ |
764 | if (six) |
765 | *six = '6'; |
766 | if (!sep->se_proto_no) /* not tcp/udp?? */ |
767 | goto parse_err; |
768 | } |
769 | |
770 | /* [no]wait[.max] user[:group] prog [args] */ |
771 | arg = token[3]; |
772 | sep->se_max = max_concurrency; |
773 | p = strchr(arg, '.'); |
774 | if (p) { |
775 | *p++ = '\0'; |
776 | sep->se_max = bb_strtou(p, NULL, 10); |
777 | if (errno) |
778 | goto parse_err; |
779 | } |
780 | sep->se_wait = (arg[0] != 'n' || arg[1] != 'o'); |
781 | if (!sep->se_wait) /* "no" seen */ |
782 | arg += 2; |
783 | if (strcmp(arg, "wait") != 0) |
784 | goto parse_err; |
785 | |
786 | /* user[:group] prog [args] */ |
787 | sep->se_user = xstrdup(token[4]); |
788 | arg = strchr(sep->se_user, '.'); |
789 | if (arg == NULL) |
790 | arg = strchr(sep->se_user, ':'); |
791 | if (arg) { |
792 | *arg++ = '\0'; |
793 | sep->se_group = xstrdup(arg); |
794 | } |
795 | |
796 | /* prog [args] */ |
797 | sep->se_program = xstrdup(token[5]); |
798 | #ifdef INETD_BUILTINS_ENABLED |
799 | if (strcmp(sep->se_program, "internal") == 0 |
800 | && strlen(sep->se_service) <= 7 |
801 | && (sep->se_socktype == SOCK_STREAM |
802 | || sep->se_socktype == SOCK_DGRAM) |
803 | ) { |
804 | unsigned i; |
805 | for (i = 0; i < ARRAY_SIZE(builtins); i++) |
806 | if (strncmp(builtins[i].bi_service7, sep->se_service, 7) == 0) |
807 | goto found_bi; |
808 | bb_error_msg("unknown internal service %s", sep->se_service); |
809 | goto parse_err; |
810 | found_bi: |
811 | sep->se_builtin = &builtins[i]; |
812 | /* stream builtins must be "nowait", dgram must be "wait" */ |
813 | if (sep->se_wait != (sep->se_socktype == SOCK_DGRAM)) |
814 | goto parse_err; |
815 | } |
816 | #endif |
817 | argc = 0; |
818 | while ((arg = token[6+argc]) != NULL && argc < MAXARGV) |
819 | sep->se_argv[argc++] = xstrdup(arg); |
820 | /* Some inetd.conf files have no argv's, not even argv[0]. |
821 | * Fix them up. |
822 | * (Technically, programs can be execed with argv[0] = NULL, |
823 | * but many programs do not like that at all) */ |
824 | if (argc == 0) |
825 | sep->se_argv[0] = xstrdup(sep->se_program); |
826 | |
827 | /* catch mixups. "<service> stream udp ..." == wtf */ |
828 | if (sep->se_socktype == SOCK_STREAM) { |
829 | if (sep->se_proto_no == IPPROTO_UDP) |
830 | goto parse_err; |
831 | } |
832 | if (sep->se_socktype == SOCK_DGRAM) { |
833 | if (sep->se_proto_no == IPPROTO_TCP) |
834 | goto parse_err; |
835 | } |
836 | |
837 | // bb_info_msg( |
838 | // "ENTRY[%s][%s][%s][%d][%d][%d][%d][%d][%s][%s][%s]", |
839 | // sep->se_local_hostname, sep->se_service, sep->se_proto, sep->se_wait, sep->se_proto_no, |
840 | // sep->se_max, sep->se_count, sep->se_time, sep->se_user, sep->se_group, sep->se_program); |
841 | |
842 | /* check if the hostname specifier is a comma separated list |
843 | * of hostnames. we'll make new entries for each address. */ |
844 | while ((hostdelim = strrchr(sep->se_local_hostname, ',')) != NULL) { |
845 | nsep = dup_servtab(sep); |
846 | /* NUL terminate the hostname field of the existing entry, |
847 | * and make a dup for the new entry. */ |
848 | *hostdelim++ = '\0'; |
849 | nsep->se_local_hostname = xstrdup(hostdelim); |
850 | nsep->se_next = sep->se_next; |
851 | sep->se_next = nsep; |
852 | } |
853 | |
854 | /* was doing it here: */ |
855 | /* DNS resolution, create copies for each IP address */ |
856 | /* IPv6-ization destroyed it :( */ |
857 | |
858 | return sep; |
859 | } |
860 | |
861 | static servtab_t *insert_in_servlist(servtab_t *cp) |
862 | { |
863 | servtab_t *sep; |
864 | sigset_t omask; |
865 | |
866 | sep = new_servtab(); |
867 | *sep = *cp; /* struct copy */ |
868 | sep->se_fd = -1; |
869 | #if ENABLE_FEATURE_INETD_RPC |
870 | sep->se_rpcprog = -1; |
871 | #endif |
872 | block_CHLD_HUP_ALRM(&omask); |
873 | sep->se_next = serv_list; |
874 | serv_list = sep; |
875 | restore_sigmask(&omask); |
876 | return sep; |
877 | } |
878 | |
879 | static int same_serv_addr_proto(servtab_t *old, servtab_t *new) |
880 | { |
881 | if (strcmp(old->se_local_hostname, new->se_local_hostname) != 0) |
882 | return 0; |
883 | if (strcmp(old->se_service, new->se_service) != 0) |
884 | return 0; |
885 | if (strcmp(old->se_proto, new->se_proto) != 0) |
886 | return 0; |
887 | return 1; |
888 | } |
889 | |
890 | static void reread_config_file(int sig UNUSED_PARAM) |
891 | { |
892 | servtab_t *sep, *cp, **sepp; |
893 | len_and_sockaddr *lsa; |
894 | sigset_t omask; |
895 | unsigned n; |
896 | uint16_t port; |
897 | int save_errno = errno; |
898 | |
899 | if (!reopen_config_file()) |
900 | goto ret; |
901 | for (sep = serv_list; sep; sep = sep->se_next) |
902 | sep->se_checked = 0; |
903 | |
904 | goto first_line; |
905 | while (1) { |
906 | if (cp == NULL) { |
907 | first_line: |
908 | cp = parse_one_line(); |
909 | if (cp == NULL) |
910 | break; |
911 | } |
912 | for (sep = serv_list; sep; sep = sep->se_next) |
913 | if (same_serv_addr_proto(sep, cp)) |
914 | goto equal_servtab; |
915 | /* not an "equal" servtab */ |
916 | sep = insert_in_servlist(cp); |
917 | goto after_check; |
918 | equal_servtab: |
919 | { |
920 | int i; |
921 | |
922 | block_CHLD_HUP_ALRM(&omask); |
923 | #if ENABLE_FEATURE_INETD_RPC |
924 | if (is_rpc_service(sep)) |
925 | unregister_rpc(sep); |
926 | sep->se_rpcver_lo = cp->se_rpcver_lo; |
927 | sep->se_rpcver_hi = cp->se_rpcver_hi; |
928 | #endif |
929 | if (cp->se_wait == 0) { |
930 | /* New config says "nowait". If old one |
931 | * was "wait", we currently may be waiting |
932 | * for a child (and not accepting connects). |
933 | * Stop waiting, start listening again. |
934 | * (if it's not true, this op is harmless) */ |
935 | add_fd_to_set(sep->se_fd); |
936 | } |
937 | sep->se_wait = cp->se_wait; |
938 | sep->se_max = cp->se_max; |
939 | /* string fields need more love - we don't want to leak them */ |
940 | #define SWAP(type, a, b) do { type c = (type)a; a = (type)b; b = (type)c; } while (0) |
941 | SWAP(char*, sep->se_user, cp->se_user); |
942 | SWAP(char*, sep->se_group, cp->se_group); |
943 | SWAP(char*, sep->se_program, cp->se_program); |
944 | for (i = 0; i < MAXARGV; i++) |
945 | SWAP(char*, sep->se_argv[i], cp->se_argv[i]); |
946 | #undef SWAP |
947 | restore_sigmask(&omask); |
948 | free_servtab_strings(cp); |
949 | } |
950 | after_check: |
951 | /* cp->string_fields are consumed by insert_in_servlist() |
952 | * or freed at this point, cp itself is not yet freed. */ |
953 | sep->se_checked = 1; |
954 | |
955 | /* create new len_and_sockaddr */ |
956 | switch (sep->se_family) { |
957 | struct sockaddr_un *sun; |
958 | case AF_UNIX: |
959 | lsa = xzalloc_lsa(AF_UNIX); |
960 | sun = (struct sockaddr_un*)&lsa->u.sa; |
961 | safe_strncpy(sun->sun_path, sep->se_service, sizeof(sun->sun_path)); |
962 | break; |
963 | |
964 | default: /* case AF_INET, case AF_INET6 */ |
965 | n = bb_strtou(sep->se_service, NULL, 10); |
966 | #if ENABLE_FEATURE_INETD_RPC |
967 | if (is_rpc_service(sep)) { |
968 | sep->se_rpcprog = n; |
969 | if (errno) { /* se_service is not numeric */ |
970 | struct rpcent *rp = getrpcbyname(sep->se_service); |
971 | if (rp == NULL) { |
972 | bb_error_msg("%s: unknown rpc service", sep->se_service); |
973 | goto next_cp; |
974 | } |
975 | sep->se_rpcprog = rp->r_number; |
976 | } |
977 | if (sep->se_fd == -1) |
978 | prepare_socket_fd(sep); |
979 | if (sep->se_fd != -1) |
980 | register_rpc(sep); |
981 | goto next_cp; |
982 | } |
983 | #endif |
984 | /* what port to listen on? */ |
985 | port = htons(n); |
986 | if (errno || n > 0xffff) { /* se_service is not numeric */ |
987 | char protoname[4]; |
988 | struct servent *sp; |
989 | /* can result only in "tcp" or "udp": */ |
990 | safe_strncpy(protoname, sep->se_proto, 4); |
991 | sp = getservbyname(sep->se_service, protoname); |
992 | if (sp == NULL) { |
993 | bb_error_msg("%s/%s: unknown service", |
994 | sep->se_service, sep->se_proto); |
995 | goto next_cp; |
996 | } |
997 | port = sp->s_port; |
998 | } |
999 | if (LONE_CHAR(sep->se_local_hostname, '*')) { |
1000 | lsa = xzalloc_lsa(sep->se_family); |
1001 | set_nport(&lsa->u.sa, port); |
1002 | } else { |
1003 | lsa = host_and_af2sockaddr(sep->se_local_hostname, |
1004 | ntohs(port), sep->se_family); |
1005 | if (!lsa) { |
1006 | bb_error_msg("%s/%s: unknown host '%s'", |
1007 | sep->se_service, sep->se_proto, |
1008 | sep->se_local_hostname); |
1009 | goto next_cp; |
1010 | } |
1011 | } |
1012 | break; |
1013 | } /* end of "switch (sep->se_family)" */ |
1014 | |
1015 | /* did lsa change? Then close/open */ |
1016 | if (sep->se_lsa == NULL |
1017 | || lsa->len != sep->se_lsa->len |
1018 | || memcmp(&lsa->u.sa, &sep->se_lsa->u.sa, lsa->len) != 0 |
1019 | ) { |
1020 | remove_fd_from_set(sep->se_fd); |
1021 | maybe_close(sep->se_fd); |
1022 | free(sep->se_lsa); |
1023 | sep->se_lsa = lsa; |
1024 | sep->se_fd = -1; |
1025 | } else { |
1026 | free(lsa); |
1027 | } |
1028 | if (sep->se_fd == -1) |
1029 | prepare_socket_fd(sep); |
1030 | next_cp: |
1031 | sep = cp->se_next; |
1032 | free(cp); |
1033 | cp = sep; |
1034 | } /* end of "while (1) parse lines" */ |
1035 | close_config_file(); |
1036 | |
1037 | /* Purge anything not looked at above - these are stale entries, |
1038 | * new config file doesnt have them. */ |
1039 | block_CHLD_HUP_ALRM(&omask); |
1040 | sepp = &serv_list; |
1041 | while ((sep = *sepp) != NULL) { |
1042 | if (sep->se_checked) { |
1043 | sepp = &sep->se_next; |
1044 | continue; |
1045 | } |
1046 | *sepp = sep->se_next; |
1047 | remove_fd_from_set(sep->se_fd); |
1048 | maybe_close(sep->se_fd); |
1049 | #if ENABLE_FEATURE_INETD_RPC |
1050 | if (is_rpc_service(sep)) |
1051 | unregister_rpc(sep); |
1052 | #endif |
1053 | if (sep->se_family == AF_UNIX) |
1054 | unlink(sep->se_service); |
1055 | free_servtab_strings(sep); |
1056 | free(sep); |
1057 | } |
1058 | restore_sigmask(&omask); |
1059 | ret: |
1060 | errno = save_errno; |
1061 | } |
1062 | |
1063 | static void reap_child(int sig UNUSED_PARAM) |
1064 | { |
1065 | pid_t pid; |
1066 | int status; |
1067 | servtab_t *sep; |
1068 | int save_errno = errno; |
1069 | |
1070 | for (;;) { |
1071 | pid = wait_any_nohang(&status); |
1072 | if (pid <= 0) |
1073 | break; |
1074 | for (sep = serv_list; sep; sep = sep->se_next) { |
1075 | if (sep->se_wait != pid) |
1076 | continue; |
1077 | /* One of our "wait" services */ |
1078 | if (WIFEXITED(status) && WEXITSTATUS(status)) |
1079 | bb_error_msg("%s: exit status %u", |
1080 | sep->se_program, WEXITSTATUS(status)); |
1081 | else if (WIFSIGNALED(status)) |
1082 | bb_error_msg("%s: exit signal %u", |
1083 | sep->se_program, WTERMSIG(status)); |
1084 | sep->se_wait = 1; |
1085 | add_fd_to_set(sep->se_fd); |
1086 | break; |
1087 | } |
1088 | } |
1089 | errno = save_errno; |
1090 | } |
1091 | |
1092 | static void retry_network_setup(int sig UNUSED_PARAM) |
1093 | { |
1094 | int save_errno = errno; |
1095 | servtab_t *sep; |
1096 | |
1097 | alarm_armed = 0; |
1098 | for (sep = serv_list; sep; sep = sep->se_next) { |
1099 | if (sep->se_fd == -1) { |
1100 | prepare_socket_fd(sep); |
1101 | #if ENABLE_FEATURE_INETD_RPC |
1102 | if (sep->se_fd != -1 && is_rpc_service(sep)) |
1103 | register_rpc(sep); |
1104 | #endif |
1105 | } |
1106 | } |
1107 | errno = save_errno; |
1108 | } |
1109 | |
1110 | static void clean_up_and_exit(int sig UNUSED_PARAM) |
1111 | { |
1112 | servtab_t *sep; |
1113 | |
1114 | /* XXX signal race walking sep list */ |
1115 | for (sep = serv_list; sep; sep = sep->se_next) { |
1116 | if (sep->se_fd == -1) |
1117 | continue; |
1118 | |
1119 | switch (sep->se_family) { |
1120 | case AF_UNIX: |
1121 | unlink(sep->se_service); |
1122 | break; |
1123 | default: /* case AF_INET, AF_INET6 */ |
1124 | #if ENABLE_FEATURE_INETD_RPC |
1125 | if (sep->se_wait == 1 && is_rpc_service(sep)) |
1126 | unregister_rpc(sep); /* XXX signal race */ |
1127 | #endif |
1128 | break; |
1129 | } |
1130 | if (ENABLE_FEATURE_CLEAN_UP) |
1131 | close(sep->se_fd); |
1132 | } |
1133 | remove_pidfile(CONFIG_PID_FILE_PATH "/inetd.pid"); |
1134 | exit(EXIT_SUCCESS); |
1135 | } |
1136 | |
1137 | int inetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
1138 | int inetd_main(int argc UNUSED_PARAM, char **argv) |
1139 | { |
1140 | struct sigaction sa, saved_pipe_handler; |
1141 | servtab_t *sep, *sep2; |
1142 | struct passwd *pwd; |
1143 | struct group *grp = NULL; /* for compiler */ |
1144 | int opt; |
1145 | pid_t pid; |
1146 | sigset_t omask; |
1147 | |
1148 | INIT_G(); |
1149 | |
1150 | real_uid = getuid(); |
1151 | if (real_uid != 0) /* run by non-root user */ |
1152 | config_filename = NULL; |
1153 | |
1154 | opt_complementary = "R+:q+"; /* -q N, -R N */ |
1155 | opt = getopt32(argv, "R:feq:", &max_concurrency, &global_queuelen); |
1156 | argv += optind; |
1157 | //argc -= optind; |
1158 | if (argv[0]) |
1159 | config_filename = argv[0]; |
1160 | if (config_filename == NULL) |
1161 | bb_error_msg_and_die("non-root must specify config file"); |
1162 | if (!(opt & 2)) |
1163 | bb_daemonize_or_rexec(0, argv - optind); |
1164 | else |
1165 | bb_sanitize_stdio(); |
1166 | if (!(opt & 4)) { |
1167 | /* LOG_NDELAY: connect to syslog daemon NOW. |
1168 | * Otherwise, we may open syslog socket |
1169 | * in vforked child, making opened fds and syslog() |
1170 | * internal state inconsistent. |
1171 | * This was observed to leak file descriptors. */ |
1172 | openlog(applet_name, LOG_PID | LOG_NDELAY, LOG_DAEMON); |
1173 | logmode = LOGMODE_SYSLOG; |
1174 | } |
1175 | |
1176 | if (real_uid == 0) { |
1177 | /* run by root, ensure groups vector gets trashed */ |
1178 | gid_t gid = getgid(); |
1179 | setgroups(1, &gid); |
1180 | } |
1181 | |
1182 | write_pidfile(CONFIG_PID_FILE_PATH "/inetd.pid"); |
1183 | |
1184 | /* never fails under Linux (except if you pass it bad arguments) */ |
1185 | getrlimit(RLIMIT_NOFILE, &rlim_ofile); |
1186 | rlim_ofile_cur = rlim_ofile.rlim_cur; |
1187 | if (rlim_ofile_cur == RLIM_INFINITY) /* ! */ |
1188 | rlim_ofile_cur = OPEN_MAX; |
1189 | |
1190 | memset(&sa, 0, sizeof(sa)); |
1191 | /*sigemptyset(&sa.sa_mask); - memset did it */ |
1192 | sigaddset(&sa.sa_mask, SIGALRM); |
1193 | sigaddset(&sa.sa_mask, SIGCHLD); |
1194 | sigaddset(&sa.sa_mask, SIGHUP); |
1195 | //FIXME: explain why no SA_RESTART |
1196 | //FIXME: retry_network_setup is unsafe to run in signal handler (many reasons)! |
1197 | sa.sa_handler = retry_network_setup; |
1198 | sigaction_set(SIGALRM, &sa); |
1199 | //FIXME: reread_config_file is unsafe to run in signal handler(many reasons)! |
1200 | sa.sa_handler = reread_config_file; |
1201 | sigaction_set(SIGHUP, &sa); |
1202 | //FIXME: reap_child is unsafe to run in signal handler (uses stdio)! |
1203 | sa.sa_handler = reap_child; |
1204 | sigaction_set(SIGCHLD, &sa); |
1205 | //FIXME: clean_up_and_exit is unsafe to run in signal handler (uses stdio)! |
1206 | sa.sa_handler = clean_up_and_exit; |
1207 | sigaction_set(SIGTERM, &sa); |
1208 | sa.sa_handler = clean_up_and_exit; |
1209 | sigaction_set(SIGINT, &sa); |
1210 | sa.sa_handler = SIG_IGN; |
1211 | sigaction(SIGPIPE, &sa, &saved_pipe_handler); |
1212 | |
1213 | reread_config_file(SIGHUP); /* load config from file */ |
1214 | |
1215 | for (;;) { |
1216 | int ready_fd_cnt; |
1217 | int ctrl, accepted_fd, new_udp_fd; |
1218 | fd_set readable; |
1219 | |
1220 | if (maxsock < 0) |
1221 | recalculate_maxsock(); |
1222 | |
1223 | readable = allsock; /* struct copy */ |
1224 | /* if there are no fds to wait on, we will block |
1225 | * until signal wakes us up (maxsock == 0, but readable |
1226 | * never contains fds 0 and 1...) */ |
1227 | ready_fd_cnt = select(maxsock + 1, &readable, NULL, NULL, NULL); |
1228 | if (ready_fd_cnt < 0) { |
1229 | if (errno != EINTR) { |
1230 | bb_perror_msg("select"); |
1231 | sleep(1); |
1232 | } |
1233 | continue; |
1234 | } |
1235 | dbg("ready_fd_cnt:%d\n", ready_fd_cnt); |
1236 | |
1237 | for (sep = serv_list; ready_fd_cnt && sep; sep = sep->se_next) { |
1238 | if (sep->se_fd == -1 || !FD_ISSET(sep->se_fd, &readable)) |
1239 | continue; |
1240 | |
1241 | dbg("ready fd:%d\n", sep->se_fd); |
1242 | ready_fd_cnt--; |
1243 | ctrl = sep->se_fd; |
1244 | accepted_fd = -1; |
1245 | new_udp_fd = -1; |
1246 | if (!sep->se_wait) { |
1247 | if (sep->se_socktype == SOCK_STREAM) { |
1248 | ctrl = accepted_fd = accept(sep->se_fd, NULL, NULL); |
1249 | dbg("accepted_fd:%d\n", accepted_fd); |
1250 | if (ctrl < 0) { |
1251 | if (errno != EINTR) |
1252 | bb_perror_msg("accept (for %s)", sep->se_service); |
1253 | continue; |
1254 | } |
1255 | } |
1256 | /* "nowait" udp */ |
1257 | if (sep->se_socktype == SOCK_DGRAM |
1258 | && sep->se_family != AF_UNIX |
1259 | ) { |
1260 | /* How udp "nowait" works: |
1261 | * child peeks at (received and buffered by kernel) UDP packet, |
1262 | * performs connect() on the socket so that it is linked only |
1263 | * to this peer. But this also affects parent, because descriptors |
1264 | * are shared after fork() a-la dup(). When parent performs |
1265 | * select(), it will see this descriptor connected to the peer (!) |
1266 | * and still readable, will act on it and mess things up |
1267 | * (can create many copies of same child, etc). |
1268 | * Parent must create and use new socket instead. */ |
1269 | new_udp_fd = socket(sep->se_family, SOCK_DGRAM, 0); |
1270 | dbg("new_udp_fd:%d\n", new_udp_fd); |
1271 | if (new_udp_fd < 0) { /* error: eat packet, forget about it */ |
1272 | udp_err: |
1273 | recv(sep->se_fd, line, LINE_SIZE, MSG_DONTWAIT); |
1274 | continue; |
1275 | } |
1276 | setsockopt_reuseaddr(new_udp_fd); |
1277 | /* TODO: better do bind after fork in parent, |
1278 | * so that we don't have two wildcard bound sockets |
1279 | * even for a brief moment? */ |
1280 | if (bind(new_udp_fd, &sep->se_lsa->u.sa, sep->se_lsa->len) < 0) { |
1281 | dbg("bind(new_udp_fd) failed\n"); |
1282 | close(new_udp_fd); |
1283 | goto udp_err; |
1284 | } |
1285 | dbg("bind(new_udp_fd) succeeded\n"); |
1286 | } |
1287 | } |
1288 | |
1289 | block_CHLD_HUP_ALRM(&omask); |
1290 | pid = 0; |
1291 | #ifdef INETD_BUILTINS_ENABLED |
1292 | /* do we need to fork? */ |
1293 | if (sep->se_builtin == NULL |
1294 | || (sep->se_socktype == SOCK_STREAM |
1295 | && sep->se_builtin->bi_fork)) |
1296 | #endif |
1297 | { |
1298 | if (sep->se_max != 0) { |
1299 | if (++sep->se_count == 1) |
1300 | sep->se_time = monotonic_sec(); |
1301 | else if (sep->se_count >= sep->se_max) { |
1302 | unsigned now = monotonic_sec(); |
1303 | /* did we accumulate se_max connects too quickly? */ |
1304 | if (now - sep->se_time <= CNT_INTERVAL) { |
1305 | bb_error_msg("%s/%s: too many connections, pausing", |
1306 | sep->se_service, sep->se_proto); |
1307 | remove_fd_from_set(sep->se_fd); |
1308 | close(sep->se_fd); |
1309 | sep->se_fd = -1; |
1310 | sep->se_count = 0; |
1311 | rearm_alarm(); /* will revive it in RETRYTIME sec */ |
1312 | restore_sigmask(&omask); |
1313 | maybe_close(new_udp_fd); |
1314 | maybe_close(accepted_fd); |
1315 | continue; /* -> check next fd in fd set */ |
1316 | } |
1317 | sep->se_count = 0; |
1318 | } |
1319 | } |
1320 | /* on NOMMU, streamed chargen |
1321 | * builtin wouldn't work, but it is |
1322 | * not allowed on NOMMU (ifdefed out) */ |
1323 | #ifdef INETD_BUILTINS_ENABLED |
1324 | if (BB_MMU && sep->se_builtin) |
1325 | pid = fork(); |
1326 | else |
1327 | #endif |
1328 | pid = vfork(); |
1329 | |
1330 | if (pid < 0) { /* fork error */ |
1331 | bb_perror_msg("%s", "vfork"+1); |
1332 | sleep(1); |
1333 | restore_sigmask(&omask); |
1334 | maybe_close(new_udp_fd); |
1335 | maybe_close(accepted_fd); |
1336 | continue; /* -> check next fd in fd set */ |
1337 | } |
1338 | if (pid == 0) |
1339 | pid--; /* -1: "we did fork and we are child" */ |
1340 | } |
1341 | /* if pid == 0 here, we didn't fork */ |
1342 | |
1343 | if (pid > 0) { /* parent */ |
1344 | if (sep->se_wait) { |
1345 | /* wait: we passed socket to child, |
1346 | * will wait for child to terminate */ |
1347 | sep->se_wait = pid; |
1348 | remove_fd_from_set(sep->se_fd); |
1349 | } |
1350 | if (new_udp_fd >= 0) { |
1351 | /* udp nowait: child connected the socket, |
1352 | * we created and will use new, unconnected one */ |
1353 | xmove_fd(new_udp_fd, sep->se_fd); |
1354 | dbg("moved new_udp_fd:%d to sep->se_fd:%d\n", new_udp_fd, sep->se_fd); |
1355 | } |
1356 | restore_sigmask(&omask); |
1357 | maybe_close(accepted_fd); |
1358 | continue; /* -> check next fd in fd set */ |
1359 | } |
1360 | |
1361 | /* we are either child or didn't fork at all */ |
1362 | #ifdef INETD_BUILTINS_ENABLED |
1363 | if (sep->se_builtin) { |
1364 | if (pid) { /* "pid" is -1: we did fork */ |
1365 | close(sep->se_fd); /* listening socket */ |
1366 | dbg("closed sep->se_fd:%d\n", sep->se_fd); |
1367 | logmode = LOGMODE_NONE; /* make xwrite etc silent */ |
1368 | } |
1369 | restore_sigmask(&omask); |
1370 | if (sep->se_socktype == SOCK_STREAM) |
1371 | sep->se_builtin->bi_stream_fn(ctrl, sep); |
1372 | else |
1373 | sep->se_builtin->bi_dgram_fn(ctrl, sep); |
1374 | if (pid) /* we did fork */ |
1375 | _exit(EXIT_FAILURE); |
1376 | maybe_close(accepted_fd); |
1377 | continue; /* -> check next fd in fd set */ |
1378 | } |
1379 | #endif |
1380 | /* child */ |
1381 | setsid(); |
1382 | /* "nowait" udp */ |
1383 | if (new_udp_fd >= 0) { |
1384 | len_and_sockaddr *lsa; |
1385 | int r; |
1386 | |
1387 | close(new_udp_fd); |
1388 | lsa = xzalloc_lsa(sep->se_family); |
1389 | /* peek at the packet and remember peer addr */ |
1390 | r = recvfrom(ctrl, NULL, 0, MSG_PEEK|MSG_DONTWAIT, |
1391 | &lsa->u.sa, &lsa->len); |
1392 | if (r < 0) |
1393 | goto do_exit1; |
1394 | /* make this socket "connected" to peer addr: |
1395 | * only packets from this peer will be recv'ed, |
1396 | * and bare write()/send() will work on it */ |
1397 | connect(ctrl, &lsa->u.sa, lsa->len); |
1398 | dbg("connected ctrl:%d to remote peer\n", ctrl); |
1399 | free(lsa); |
1400 | } |
1401 | /* prepare env and exec program */ |
1402 | pwd = getpwnam(sep->se_user); |
1403 | if (pwd == NULL) { |
1404 | bb_error_msg("%s: no such %s", sep->se_user, "user"); |
1405 | goto do_exit1; |
1406 | } |
1407 | if (sep->se_group && (grp = getgrnam(sep->se_group)) == NULL) { |
1408 | bb_error_msg("%s: no such %s", sep->se_group, "group"); |
1409 | goto do_exit1; |
1410 | } |
1411 | if (real_uid != 0 && real_uid != pwd->pw_uid) { |
1412 | /* a user running private inetd */ |
1413 | bb_error_msg("non-root must run services as himself"); |
1414 | goto do_exit1; |
1415 | } |
1416 | if (pwd->pw_uid != 0) { |
1417 | if (sep->se_group) |
1418 | pwd->pw_gid = grp->gr_gid; |
1419 | /* initgroups, setgid, setuid: */ |
1420 | change_identity(pwd); |
1421 | } else if (sep->se_group) { |
1422 | xsetgid(grp->gr_gid); |
1423 | setgroups(1, &grp->gr_gid); |
1424 | } |
1425 | if (rlim_ofile.rlim_cur != rlim_ofile_cur) |
1426 | if (setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0) |
1427 | bb_perror_msg("setrlimit"); |
1428 | |
1429 | /* closelog(); - WRONG. we are after vfork, |
1430 | * this may confuse syslog() internal state. |
1431 | * Let's hope libc sets syslog fd to CLOEXEC... |
1432 | */ |
1433 | xmove_fd(ctrl, STDIN_FILENO); |
1434 | xdup2(STDIN_FILENO, STDOUT_FILENO); |
1435 | dbg("moved ctrl:%d to fd 0,1[,2]\n", ctrl); |
1436 | /* manpages of inetd I managed to find either say |
1437 | * that stderr is also redirected to the network, |
1438 | * or do not talk about redirection at all (!) */ |
1439 | if (!sep->se_wait) /* only for usual "tcp nowait" */ |
1440 | xdup2(STDIN_FILENO, STDERR_FILENO); |
1441 | /* NB: among others, this loop closes listening sockets |
1442 | * for nowait stream children */ |
1443 | for (sep2 = serv_list; sep2; sep2 = sep2->se_next) |
1444 | if (sep2->se_fd != ctrl) |
1445 | maybe_close(sep2->se_fd); |
1446 | sigaction_set(SIGPIPE, &saved_pipe_handler); |
1447 | restore_sigmask(&omask); |
1448 | dbg("execing:'%s'\n", sep->se_program); |
1449 | BB_EXECVP(sep->se_program, sep->se_argv); |
1450 | bb_perror_msg("can't execute '%s'", sep->se_program); |
1451 | do_exit1: |
1452 | /* eat packet in udp case */ |
1453 | if (sep->se_socktype != SOCK_STREAM) |
1454 | recv(0, line, LINE_SIZE, MSG_DONTWAIT); |
1455 | _exit(EXIT_FAILURE); |
1456 | } /* for (sep = servtab...) */ |
1457 | } /* for (;;) */ |
1458 | } |
1459 | |
1460 | #if !BB_MMU |
1461 | static const char *const cat_args[] = { "cat", NULL }; |
1462 | #endif |
1463 | |
1464 | /* |
1465 | * Internet services provided internally by inetd: |
1466 | */ |
1467 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO |
1468 | /* Echo service -- echo data back. */ |
1469 | /* ARGSUSED */ |
1470 | static void FAST_FUNC echo_stream(int s, servtab_t *sep UNUSED_PARAM) |
1471 | { |
1472 | #if BB_MMU |
1473 | while (1) { |
1474 | ssize_t sz = safe_read(s, line, LINE_SIZE); |
1475 | if (sz <= 0) |
1476 | break; |
1477 | xwrite(s, line, sz); |
1478 | } |
1479 | #else |
1480 | /* We are after vfork here! */ |
1481 | /* move network socket to stdin/stdout */ |
1482 | xmove_fd(s, STDIN_FILENO); |
1483 | xdup2(STDIN_FILENO, STDOUT_FILENO); |
1484 | /* no error messages please... */ |
1485 | close(STDERR_FILENO); |
1486 | xopen(bb_dev_null, O_WRONLY); |
1487 | BB_EXECVP("cat", (char**)cat_args); |
1488 | /* on failure we return to main, which does exit(EXIT_FAILURE) */ |
1489 | #endif |
1490 | } |
1491 | static void FAST_FUNC echo_dg(int s, servtab_t *sep) |
1492 | { |
1493 | enum { BUFSIZE = 12*1024 }; /* for jumbo sized packets! :) */ |
1494 | char *buf = xmalloc(BUFSIZE); /* too big for stack */ |
1495 | int sz; |
1496 | len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len); |
1497 | |
1498 | lsa->len = sep->se_lsa->len; |
1499 | /* dgram builtins are non-forking - DONT BLOCK! */ |
1500 | sz = recvfrom(s, buf, BUFSIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len); |
1501 | if (sz > 0) |
1502 | sendto(s, buf, sz, 0, &lsa->u.sa, lsa->len); |
1503 | free(buf); |
1504 | } |
1505 | #endif /* FEATURE_INETD_SUPPORT_BUILTIN_ECHO */ |
1506 | |
1507 | |
1508 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD |
1509 | /* Discard service -- ignore data. */ |
1510 | /* ARGSUSED */ |
1511 | static void FAST_FUNC discard_stream(int s, servtab_t *sep UNUSED_PARAM) |
1512 | { |
1513 | #if BB_MMU |
1514 | while (safe_read(s, line, LINE_SIZE) > 0) |
1515 | continue; |
1516 | #else |
1517 | /* We are after vfork here! */ |
1518 | /* move network socket to stdin */ |
1519 | xmove_fd(s, STDIN_FILENO); |
1520 | /* discard output */ |
1521 | close(STDOUT_FILENO); |
1522 | xopen(bb_dev_null, O_WRONLY); |
1523 | /* no error messages please... */ |
1524 | xdup2(STDOUT_FILENO, STDERR_FILENO); |
1525 | BB_EXECVP("cat", (char**)cat_args); |
1526 | /* on failure we return to main, which does exit(EXIT_FAILURE) */ |
1527 | #endif |
1528 | } |
1529 | /* ARGSUSED */ |
1530 | static void FAST_FUNC discard_dg(int s, servtab_t *sep UNUSED_PARAM) |
1531 | { |
1532 | /* dgram builtins are non-forking - DONT BLOCK! */ |
1533 | recv(s, line, LINE_SIZE, MSG_DONTWAIT); |
1534 | } |
1535 | #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */ |
1536 | |
1537 | |
1538 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN |
1539 | #define LINESIZ 72 |
1540 | static void init_ring(void) |
1541 | { |
1542 | int i; |
1543 | |
1544 | end_ring = ring; |
1545 | for (i = ' '; i < 127; i++) |
1546 | *end_ring++ = i; |
1547 | } |
1548 | /* Character generator. MMU arches only. */ |
1549 | /* ARGSUSED */ |
1550 | static void FAST_FUNC chargen_stream(int s, servtab_t *sep UNUSED_PARAM) |
1551 | { |
1552 | char *rs; |
1553 | int len; |
1554 | char text[LINESIZ + 2]; |
1555 | |
1556 | if (!end_ring) { |
1557 | init_ring(); |
1558 | rs = ring; |
1559 | } |
1560 | |
1561 | text[LINESIZ] = '\r'; |
1562 | text[LINESIZ + 1] = '\n'; |
1563 | rs = ring; |
1564 | for (;;) { |
1565 | len = end_ring - rs; |
1566 | if (len >= LINESIZ) |
1567 | memmove(text, rs, LINESIZ); |
1568 | else { |
1569 | memmove(text, rs, len); |
1570 | memmove(text + len, ring, LINESIZ - len); |
1571 | } |
1572 | if (++rs == end_ring) |
1573 | rs = ring; |
1574 | xwrite(s, text, sizeof(text)); |
1575 | } |
1576 | } |
1577 | /* ARGSUSED */ |
1578 | static void FAST_FUNC chargen_dg(int s, servtab_t *sep) |
1579 | { |
1580 | int len; |
1581 | char text[LINESIZ + 2]; |
1582 | len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len); |
1583 | |
1584 | /* Eat UDP packet which started it all */ |
1585 | /* dgram builtins are non-forking - DONT BLOCK! */ |
1586 | lsa->len = sep->se_lsa->len; |
1587 | if (recvfrom(s, text, sizeof(text), MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0) |
1588 | return; |
1589 | |
1590 | if (!end_ring) { |
1591 | init_ring(); |
1592 | ring_pos = ring; |
1593 | } |
1594 | |
1595 | len = end_ring - ring_pos; |
1596 | if (len >= LINESIZ) |
1597 | memmove(text, ring_pos, LINESIZ); |
1598 | else { |
1599 | memmove(text, ring_pos, len); |
1600 | memmove(text + len, ring, LINESIZ - len); |
1601 | } |
1602 | if (++ring_pos == end_ring) |
1603 | ring_pos = ring; |
1604 | text[LINESIZ] = '\r'; |
1605 | text[LINESIZ + 1] = '\n'; |
1606 | sendto(s, text, sizeof(text), 0, &lsa->u.sa, lsa->len); |
1607 | } |
1608 | #endif /* FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */ |
1609 | |
1610 | |
1611 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME |
1612 | /* |
1613 | * Return a machine readable date and time, in the form of the |
1614 | * number of seconds since midnight, Jan 1, 1900. Since gettimeofday |
1615 | * returns the number of seconds since midnight, Jan 1, 1970, |
1616 | * we must add 2208988800 seconds to this figure to make up for |
1617 | * some seventy years Bell Labs was asleep. |
1618 | */ |
1619 | static uint32_t machtime(void) |
1620 | { |
1621 | struct timeval tv; |
1622 | |
1623 | gettimeofday(&tv, NULL); |
1624 | return htonl((uint32_t)(tv.tv_sec + 2208988800UL)); |
1625 | } |
1626 | /* ARGSUSED */ |
1627 | static void FAST_FUNC machtime_stream(int s, servtab_t *sep UNUSED_PARAM) |
1628 | { |
1629 | uint32_t result; |
1630 | |
1631 | result = machtime(); |
1632 | full_write(s, &result, sizeof(result)); |
1633 | } |
1634 | static void FAST_FUNC machtime_dg(int s, servtab_t *sep) |
1635 | { |
1636 | uint32_t result; |
1637 | len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len); |
1638 | |
1639 | lsa->len = sep->se_lsa->len; |
1640 | if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0) |
1641 | return; |
1642 | |
1643 | result = machtime(); |
1644 | sendto(s, &result, sizeof(result), 0, &lsa->u.sa, lsa->len); |
1645 | } |
1646 | #endif /* FEATURE_INETD_SUPPORT_BUILTIN_TIME */ |
1647 | |
1648 | |
1649 | #if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME |
1650 | /* Return human-readable time of day */ |
1651 | /* ARGSUSED */ |
1652 | static void FAST_FUNC daytime_stream(int s, servtab_t *sep UNUSED_PARAM) |
1653 | { |
1654 | time_t t; |
1655 | |
1656 | t = time(NULL); |
1657 | fdprintf(s, "%.24s\r\n", ctime(&t)); |
1658 | } |
1659 | static void FAST_FUNC daytime_dg(int s, servtab_t *sep) |
1660 | { |
1661 | time_t t; |
1662 | len_and_sockaddr *lsa = alloca(LSA_LEN_SIZE + sep->se_lsa->len); |
1663 | |
1664 | lsa->len = sep->se_lsa->len; |
1665 | if (recvfrom(s, line, LINE_SIZE, MSG_DONTWAIT, &lsa->u.sa, &lsa->len) < 0) |
1666 | return; |
1667 | |
1668 | t = time(NULL); |
1669 | sprintf(line, "%.24s\r\n", ctime(&t)); |
1670 | sendto(s, line, strlen(line), 0, &lsa->u.sa, lsa->len); |
1671 | } |
1672 | #endif /* FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */ |
1673 |