Ignore:
Timestamp:
Jan 1, 2014, 12:47:38 AM (7 years ago)
Author:
Bruno Cornec
Message:
  • Update mindi-busybox to 1.21.1
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/3.2/mindi-busybox/networking/inetd.c

    r2725 r3232  
    155155 */
    156156
     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
    157167#include <syslog.h>
     168#include <sys/resource.h> /* setrlimit */
     169#include <sys/socket.h> /* un.h may need this */
    158170#include <sys/un.h>
    159171
     
    161173
    162174#if ENABLE_FEATURE_INETD_RPC
    163 #include <rpc/rpc.h>
    164 #include <rpc/pmap_clnt.h>
     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>
    165180#endif
    166181
     
    171186#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN 0
    172187#endif
    173 
    174 #define _PATH_INETDPID  "/var/run/inetd.pid"
    175188
    176189#define CNT_INTERVAL    60      /* servers in CNT_INTERVAL sec. */
     
    345358} while (0)
    346359
     360#if 1
     361# define dbg(...) ((void)0)
     362#else
     363# define dbg(...) \
     364do { \
     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
    347374static void maybe_close(int fd)
    348375{
    349     if (fd >= 0)
     376    if (fd >= 0) {
    350377        close(fd);
     378        dbg("closed fd:%d\n", fd);
     379    }
    351380}
    352381
     
    452481    if (fd >= 0) {
    453482        FD_CLR(fd, &allsock);
     483        dbg("stopped listening on fd:%d\n", fd);
    454484        maxsock = -1;
     485        dbg("maxsock:%d\n", maxsock);
    455486    }
    456487}
     
    460491    if (fd >= 0) {
    461492        FD_SET(fd, &allsock);
     493        dbg("started listening on fd:%d\n", fd);
    462494        if (maxsock >= 0 && fd > maxsock) {
    463495            prev_maxsock = maxsock = fd;
     496            dbg("maxsock:%d\n", maxsock);
    464497            if ((rlim_t)fd > rlim_ofile_cur - FD_MARGIN)
    465498                bump_nofile();
     
    480513        fd++;
    481514    }
     515    dbg("recalculated maxsock:%d\n", maxsock);
    482516    prev_maxsock = maxsock;
    483517    if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
     
    502536        /* zero out the port for all RPC services; let bind()
    503537         * find one. */
    504         set_nport(sep->se_lsa, 0);
     538        set_nport(&sep->se_lsa->u.sa, 0);
    505539
    506540        /* for RPC services, attempt to use a reserved port
     
    537571        return;
    538572    }
    539     if (sep->se_socktype == SOCK_STREAM)
     573
     574    if (sep->se_socktype == SOCK_STREAM) {
    540575        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    }
    541580
    542581    add_fd_to_set(fd);
     
    960999            if (LONE_CHAR(sep->se_local_hostname, '*')) {
    9611000                lsa = xzalloc_lsa(sep->se_family);
    962                 set_nport(lsa, port);
     1001                set_nport(&lsa->u.sa, port);
    9631002            } else {
    9641003                lsa = host_and_af2sockaddr(sep->se_local_hostname,
     
    10001039    block_CHLD_HUP_ALRM(&omask);
    10011040    sepp = &serv_list;
    1002     while ((sep = *sepp)) {
     1041    while ((sep = *sepp) != NULL) {
    10031042        if (sep->se_checked) {
    10041043            sepp = &sep->se_next;
     
    10921131            close(sep->se_fd);
    10931132    }
    1094     remove_pidfile(_PATH_INETDPID);
     1133    remove_pidfile(CONFIG_PID_FILE_PATH "/inetd.pid");
    10951134    exit(EXIT_SUCCESS);
    10961135}
     
    11411180    }
    11421181
    1143     write_pidfile(_PATH_INETDPID);
     1182    write_pidfile(CONFIG_PID_FILE_PATH "/inetd.pid");
    11441183
    11451184    /* never fails under Linux (except if you pass it bad arguments) */
     
    11541193    sigaddset(&sa.sa_mask, SIGCHLD);
    11551194    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)!
    11561197    sa.sa_handler = retry_network_setup;
    11571198    sigaction_set(SIGALRM, &sa);
     1199//FIXME: reread_config_file is unsafe to run in signal handler(many reasons)!
    11581200    sa.sa_handler = reread_config_file;
    11591201    sigaction_set(SIGHUP, &sa);
     1202//FIXME: reap_child is unsafe to run in signal handler (uses stdio)!
    11601203    sa.sa_handler = reap_child;
    11611204    sigaction_set(SIGCHLD, &sa);
     1205//FIXME: clean_up_and_exit is unsafe to run in signal handler (uses stdio)!
    11621206    sa.sa_handler = clean_up_and_exit;
    11631207    sigaction_set(SIGTERM, &sa);
     
    11891233            continue;
    11901234        }
     1235        dbg("ready_fd_cnt:%d\n", ready_fd_cnt);
    11911236
    11921237        for (sep = serv_list; ready_fd_cnt && sep; sep = sep->se_next) {
     
    11941239                continue;
    11951240
     1241            dbg("ready fd:%d\n", sep->se_fd);
    11961242            ready_fd_cnt--;
    11971243            ctrl = sep->se_fd;
     
    12011247                if (sep->se_socktype == SOCK_STREAM) {
    12021248                    ctrl = accepted_fd = accept(sep->se_fd, NULL, NULL);
     1249                    dbg("accepted_fd:%d\n", accepted_fd);
    12031250                    if (ctrl < 0) {
    12041251                        if (errno != EINTR)
     
    12211268 * Parent must create and use new socket instead. */
    12221269                    new_udp_fd = socket(sep->se_family, SOCK_DGRAM, 0);
     1270                    dbg("new_udp_fd:%d\n", new_udp_fd);
    12231271                    if (new_udp_fd < 0) { /* error: eat packet, forget about it */
    12241272 udp_err:
     
    12271275                    }
    12281276                    setsockopt_reuseaddr(new_udp_fd);
    1229                     /* TODO: better do bind after vfork in parent,
     1277                    /* TODO: better do bind after fork in parent,
    12301278                     * so that we don't have two wildcard bound sockets
    12311279                     * even for a brief moment? */
    12321280                    if (bind(new_udp_fd, &sep->se_lsa->u.sa, sep->se_lsa->len) < 0) {
     1281                        dbg("bind(new_udp_fd) failed\n");
    12331282                        close(new_udp_fd);
    12341283                        goto udp_err;
    12351284                    }
     1285                    dbg("bind(new_udp_fd) succeeded\n");
    12361286                }
    12371287            }
     
    12611311                            rearm_alarm(); /* will revive it in RETRYTIME sec */
    12621312                            restore_sigmask(&omask);
     1313                            maybe_close(new_udp_fd);
    12631314                            maybe_close(accepted_fd);
    12641315                            continue; /* -> check next fd in fd set */
     
    12811332                    sleep(1);
    12821333                    restore_sigmask(&omask);
     1334                    maybe_close(new_udp_fd);
    12831335                    maybe_close(accepted_fd);
    12841336                    continue; /* -> check next fd in fd set */
     
    12871339                    pid--; /* -1: "we did fork and we are child" */
    12881340            }
    1289             /* if pid == 0 here, we never forked */
     1341            /* if pid == 0 here, we didn't fork */
    12901342
    12911343            if (pid > 0) { /* parent */
    12921344                if (sep->se_wait) {
    1293                     /* tcp wait: we passed listening socket to child,
     1345                    /* wait: we passed socket to child,
    12941346                     * will wait for child to terminate */
    12951347                    sep->se_wait = pid;
     
    13001352                     * we created and will use new, unconnected one */
    13011353                    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);
    13021355                }
    13031356                restore_sigmask(&omask);
     
    13061359            }
    13071360
    1308             /* we are either child or didn't vfork at all */
     1361            /* we are either child or didn't fork at all */
    13091362#ifdef INETD_BUILTINS_ENABLED
    13101363            if (sep->se_builtin) {
    1311                 if (pid) { /* "pid" is -1: we did vfork */
     1364                if (pid) { /* "pid" is -1: we did fork */
    13121365                    close(sep->se_fd); /* listening socket */
     1366                    dbg("closed sep->se_fd:%d\n", sep->se_fd);
    13131367                    logmode = LOGMODE_NONE; /* make xwrite etc silent */
    13141368                }
     
    13181372                else
    13191373                    sep->se_builtin->bi_dgram_fn(ctrl, sep);
    1320                 if (pid) /* we did vfork */
     1374                if (pid) /* we did fork */
    13211375                    _exit(EXIT_FAILURE);
    13221376                maybe_close(accepted_fd);
     
    13281382            /* "nowait" udp */
    13291383            if (new_udp_fd >= 0) {
    1330                 len_and_sockaddr *lsa = xzalloc_lsa(sep->se_family);
     1384                len_and_sockaddr *lsa;
     1385                int r;
     1386
     1387                close(new_udp_fd);
     1388                dbg("closed new_udp_fd:%d\n", new_udp_fd);
     1389                lsa = xzalloc_lsa(sep->se_family);
    13311390                /* peek at the packet and remember peer addr */
    1332                 int r = recvfrom(ctrl, NULL, 0, MSG_PEEK|MSG_DONTWAIT,
     1391                r = recvfrom(ctrl, NULL, 0, MSG_PEEK|MSG_DONTWAIT,
    13331392                    &lsa->u.sa, &lsa->len);
    13341393                if (r < 0)
     
    13381397                 * and bare write()/send() will work on it */
    13391398                connect(ctrl, &lsa->u.sa, lsa->len);
     1399                dbg("connected ctrl:%d to remote peer\n", ctrl);
    13401400                free(lsa);
    13411401            }
     
    13551415                goto do_exit1;
    13561416            }
    1357             if (pwd->pw_uid) {
     1417            if (pwd->pw_uid != 0) {
    13581418                if (sep->se_group)
    13591419                    pwd->pw_gid = grp->gr_gid;
     
    13741434            xmove_fd(ctrl, STDIN_FILENO);
    13751435            xdup2(STDIN_FILENO, STDOUT_FILENO);
     1436            dbg("moved ctrl:%d to fd 0,1[,2]\n", ctrl);
    13761437            /* manpages of inetd I managed to find either say
    13771438             * that stderr is also redirected to the network,
     
    13861447            sigaction_set(SIGPIPE, &saved_pipe_handler);
    13871448            restore_sigmask(&omask);
     1449            dbg("execing:'%s'\n", sep->se_program);
    13881450            BB_EXECVP(sep->se_program, sep->se_argv);
    13891451            bb_perror_msg("can't execute '%s'", sep->se_program);
Note: See TracChangeset for help on using the changeset viewer.