3
0

inetd.c 52 KB

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