X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=networking%2Fisrv_identd.c;h=a41405c333ad1dec6972eb63db2d853f2b535b72;hb=1f56e51ca1d96b70635eb1b9df1d1ab0edd98a72;hp=b9481f8d3ea6c2d184acc07efb6587e63c4bdf2f;hpb=7a431b3715299854fb423ec00d5fafc0e2c7f07b;p=oweals%2Fbusybox.git diff --git a/networking/isrv_identd.c b/networking/isrv_identd.c index b9481f8d3..a41405c33 100644 --- a/networking/isrv_identd.c +++ b/networking/isrv_identd.c @@ -2,47 +2,47 @@ /* * Fake identd server. * - * Copyright (C) 2007 Denis Vlasenko + * Copyright (C) 2007 Denys Vlasenko * - * Licensed under GPL version 2, see file LICENSE in this tarball for details. + * Licensed under GPLv2, see file LICENSE in this source tree. */ +//usage:#define fakeidentd_trivial_usage +//usage: "[-fiw] [-b ADDR] [STRING]" +//usage:#define fakeidentd_full_usage "\n\n" +//usage: "Provide fake ident (auth) service\n" +//usage: "\n -f Run in foreground" +//usage: "\n -i Inetd mode" +//usage: "\n -w Inetd 'wait' mode" +//usage: "\n -b ADDR Bind to specified address" +//usage: "\n STRING Ident answer string (default: nobody)" + +#include "libbb.h" #include -#include "busybox.h" #include "isrv.h" enum { TIMEOUT = 20 }; -/* Why use alarm(TIMEOUT-1)? - * isrv's internal select() will run with timeout=TIMEOUT. - * If nothing happens during TIMEOUT-1 seconds (no accept/read), - * then ALL sessions timed out by now. Instead of closing them one-by-one - * (isrv calls do_timeout for each 'stale' session), - * SIGALRM triggered by alarm(TIMEOUT-1) will kill us, terminating them all. - */ - typedef struct identd_buf_t { int pos; int fd_flag; char buf[64 - 2*sizeof(int)]; } identd_buf_t; -static const char *bogouser = "nobody"; +#define bogouser bb_common_bufsiz1 static int new_peer(isrv_state_t *state, int fd) { int peer; identd_buf_t *buf = xzalloc(sizeof(*buf)); - alarm(TIMEOUT - 1); - peer = isrv_register_peer(state, buf); if (peer < 0) return 0; /* failure */ if (isrv_register_fd(state, peer, fd) < 0) return peer; /* failure, unregister peer */ - buf->fd_flag = fcntl(fd, F_GETFL, 0) | O_NONBLOCK; + buf->fd_flag = fcntl(fd, F_GETFL) | O_NONBLOCK; isrv_want_rd(state, fd); return 0; } @@ -51,13 +51,13 @@ static int do_rd(int fd, void **paramp) { identd_buf_t *buf = *paramp; char *cur, *p; + int retval = 0; /* session is ok (so far) */ int sz; - alarm(TIMEOUT - 1); - cur = buf->buf + buf->pos; - fcntl(fd, F_SETFL, buf->fd_flag | O_NONBLOCK); + if (buf->fd_flag & O_NONBLOCK) + fcntl(fd, F_SETFL, buf->fd_flag); sz = safe_read(fd, cur, sizeof(buf->buf) - buf->pos); if (sz < 0) { @@ -71,21 +71,22 @@ static int do_rd(int fd, void **paramp) p = strpbrk(cur, "\r\n"); if (p) *p = '\0'; - if (p || !sz || buf->pos == sizeof(buf->buf)) { - /* fd is still in nonblocking mode - we never block here */ - fdprintf(fd, "%s : USERID : UNIX : %s\r\n", buf->buf, bogouser); - goto term; - } - ok: - fcntl(fd, F_SETFL, buf->fd_flag & ~O_NONBLOCK); - return 0; + if (!p && sz && buf->pos <= (int)sizeof(buf->buf)) + goto ok; + /* Terminate session. If we are in server mode, then + * fd is still in nonblocking mode - we never block here */ + if (fd == 0) fd++; /* inetd mode? then write to fd 1 */ + fdprintf(fd, "%s : USERID : UNIX : %s\r\n", buf->buf, bogouser); term: - fcntl(fd, F_SETFL, buf->fd_flag & ~O_NONBLOCK); free(buf); - return 1; + retval = 1; /* terminate */ + ok: + if (buf->fd_flag & O_NONBLOCK) + fcntl(fd, F_SETFL, buf->fd_flag & ~O_NONBLOCK); + return retval; } -static int do_timeout(void **paramp) +static int do_timeout(void **paramp UNUSED_PARAM) { return 1; /* terminate session */ } @@ -93,18 +94,22 @@ static int do_timeout(void **paramp) static void inetd_mode(void) { identd_buf_t *buf = xzalloc(sizeof(*buf)); + /* buf->pos = 0; - xzalloc did it */ /* We do NOT want nonblocking I/O here! */ - buf->fd_flag = fcntl(0, F_GETFL, 0); - while (do_rd(0, (void*)&buf) == 0) /* repeat */; + /* buf->fd_flag = 0; - xzalloc did it */ + do + alarm(TIMEOUT); + while (do_rd(0, (void*)&buf) == 0); } -int fakeidentd_main(int argc, char **argv) +int fakeidentd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int fakeidentd_main(int argc UNUSED_PARAM, char **argv) { enum { OPT_foreground = 0x1, OPT_inetd = 0x2, OPT_inetdwait = 0x4, - OPT_nodeamon = 0x7, + OPT_fiw = 0x7, OPT_bindaddr = 0x8, }; @@ -112,14 +117,22 @@ int fakeidentd_main(int argc, char **argv) unsigned opt; int fd; - opt = getopt32(argc, argv, "fiwb:", &bind_address); - if (optind < argc) - bogouser = argv[optind]; - - /* Daemonize if no -f or -i or -w */ - bb_sanitize_stdio(!(opt & OPT_nodeamon)); - if (!(opt & OPT_nodeamon)) { - openlog(applet_name, 0, LOG_DAEMON); + opt = getopt32(argv, "fiwb:", &bind_address); + strcpy(bogouser, "nobody"); + if (argv[optind]) + strncpy(bogouser, argv[optind], sizeof(bogouser)); + + /* Daemonize if no -f and no -i and no -w */ + if (!(opt & OPT_fiw)) + bb_daemonize_or_rexec(0, argv); + + /* Where to log in inetd modes? "Classic" inetd + * probably has its stderr /dev/null'ed (we need log to syslog?), + * but daemontools-like utilities usually expect that children + * log to stderr. I like daemontools more. Go their way. + * (Or maybe we need yet another option "log to syslog") */ + if (!(opt & OPT_fiw) /* || (opt & OPT_syslog) */) { + openlog(applet_name, LOG_PID, LOG_DAEMON); logmode = LOGMODE_SYSLOG; } @@ -131,14 +144,14 @@ int fakeidentd_main(int argc, char **argv) /* Ignore closed connections when writing */ signal(SIGPIPE, SIG_IGN); - if (opt & OPT_inetdwait) { - fd = 0; - } else { + fd = 0; + if (!(opt & OPT_inetdwait)) { fd = create_and_bind_stream_or_die(bind_address, bb_lookup_port("identd", "tcp", 113)); xlisten(fd, 5); } - isrv_run(fd, new_peer, do_rd, NULL, do_timeout, TIMEOUT, 1); + isrv_run(fd, new_peer, do_rd, /*do_wr:*/ NULL, do_timeout, + TIMEOUT, (opt & OPT_inetdwait) ? TIMEOUT : 0); return 0; }