busybox/networking/ifplugd.c
<<
>>
Prefs
   1/* vi: set sw=4 ts=4: */
   2/*
   3 * ifplugd for busybox, based on ifplugd 0.28 (written by Lennart Poettering).
   4 *
   5 * Copyright (C) 2009 Maksym Kryzhanovskyy <xmaks@email.cz>
   6 *
   7 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8 */
   9//config:config IFPLUGD
  10//config:       bool "ifplugd (9.9 kb)"
  11//config:       default y
  12//config:       select PLATFORM_LINUX
  13//config:       help
  14//config:       Network interface plug detection daemon.
  15
  16//applet:IF_IFPLUGD(APPLET(ifplugd, BB_DIR_USR_SBIN, BB_SUID_DROP))
  17
  18//kbuild:lib-$(CONFIG_IFPLUGD) += ifplugd.o
  19
  20//usage:#define ifplugd_trivial_usage
  21//usage:       "[OPTIONS]"
  22//usage:#define ifplugd_full_usage "\n\n"
  23//usage:       "Network interface plug detection daemon\n"
  24//usage:     "\n        -n              Don't daemonize"
  25//usage:     "\n        -s              Don't log to syslog"
  26//usage:     "\n        -i IFACE        Interface"
  27//usage:     "\n        -f/-F           Treat link detection error as link down/link up"
  28//usage:     "\n                        (otherwise exit on error)"
  29//usage:     "\n        -a              Don't up interface at each link probe"
  30//usage:     "\n        -M              Monitor creation/destruction of interface"
  31//usage:     "\n                        (otherwise it must exist)"
  32//usage:     "\n        -r PROG         Script to run"
  33//usage:     "\n        -x ARG          Extra argument for script"
  34//usage:     "\n        -I              Don't exit on nonzero exit code from script"
  35//usage:     "\n        -p              Don't run \"up\" script on startup"
  36//usage:     "\n        -q              Don't run \"down\" script on exit"
  37//usage:     "\n        -l              Always run script on startup"
  38//usage:     "\n        -t SECS         Poll time in seconds"
  39//usage:     "\n        -u SECS         Delay before running script after link up"
  40//usage:     "\n        -d SECS         Delay after link down"
  41//usage:     "\n        -m MODE         API mode (mii, priv, ethtool, wlan, iff, auto)"
  42//usage:     "\n        -k              Kill running daemon"
  43
  44#include "libbb.h"
  45
  46#include "fix_u32.h"
  47#include <linux/if.h>
  48#include <linux/mii.h>
  49#include <linux/ethtool.h>
  50#ifdef HAVE_NET_ETHERNET_H
  51/* musl breakage:
  52 * In file included from /usr/include/net/ethernet.h:10,
  53 *                  from networking/ifplugd.c:41:
  54 * /usr/include/netinet/if_ether.h:96: error: redefinition of 'struct ethhdr'
  55 *
  56 * Build succeeds without it on musl. Commented it out.
  57 * If on your system you need it, consider removing <linux/ethtool.h>
  58 * and copy-pasting its definitions here (<linux/ethtool.h> is what pulls in
  59 * conflicting definition of struct ethhdr on musl).
  60 */
  61/* # include <net/ethernet.h> */
  62#endif
  63#include <linux/netlink.h>
  64#include <linux/rtnetlink.h>
  65#include <linux/sockios.h>
  66#include <syslog.h>
  67
  68#define __user
  69#include <linux/wireless.h>
  70
  71#ifndef ETH_ALEN
  72# define ETH_ALEN  6
  73#endif
  74
  75/*
  76From initial port to busybox, removed most of the redundancy by
  77converting implementation of a polymorphic interface to the strict
  78functional style. The main role is run a script when link state
  79changed, other activities like audio signal or detailed reports
  80are on the script itself.
  81
  82One questionable point of the design is netlink usage:
  83
  84We have 1 second timeout by default to poll the link status,
  85it is short enough so that there are no real benefits in
  86using netlink to get "instantaneous" interface creation/deletion
  87notifications. We can check for interface existence by just
  88doing some fast ioctl using its name.
  89
  90Netlink code then can be just dropped (1k or more?)
  91*/
  92
  93
  94#define IFPLUGD_ENV_PREVIOUS "IFPLUGD_PREVIOUS"
  95#define IFPLUGD_ENV_CURRENT "IFPLUGD_CURRENT"
  96
  97enum {
  98        FLAG_NO_AUTO                    = 1 <<  0, // -a, Do not enable interface automatically
  99        FLAG_NO_DAEMON                  = 1 <<  1, // -n, Do not daemonize
 100        FLAG_NO_SYSLOG                  = 1 <<  2, // -s, Do not use syslog, use stderr instead
 101        FLAG_IGNORE_FAIL                = 1 <<  3, // -f, Ignore detection failure, retry instead (failure is treated as DOWN)
 102        FLAG_IGNORE_FAIL_POSITIVE       = 1 <<  4, // -F, Ignore detection failure, retry instead (failure is treated as UP)
 103        FLAG_IFACE                      = 1 <<  5, // -i, Specify ethernet interface
 104        FLAG_RUN                        = 1 <<  6, // -r, Specify program to execute
 105        FLAG_IGNORE_RETVAL              = 1 <<  7, // -I, Don't exit on nonzero return value of program executed
 106        FLAG_POLL_TIME                  = 1 <<  8, // -t, Specify poll time in seconds
 107        FLAG_DELAY_UP                   = 1 <<  9, // -u, Specify delay for configuring interface
 108        FLAG_DELAY_DOWN                 = 1 << 10, // -d, Specify delay for deconfiguring interface
 109        FLAG_API_MODE                   = 1 << 11, // -m, Force API mode (mii, priv, ethtool, wlan, auto)
 110        FLAG_NO_STARTUP                 = 1 << 12, // -p, Don't run script on daemon startup
 111        FLAG_NO_SHUTDOWN                = 1 << 13, // -q, Don't run script on daemon quit
 112        FLAG_INITIAL_DOWN               = 1 << 14, // -l, Run "down" script on startup if no cable is detected
 113        FLAG_EXTRA_ARG                  = 1 << 15, // -x, Specify an extra argument for action script
 114        FLAG_MONITOR                    = 1 << 16, // -M, Use interface monitoring
 115#if ENABLE_FEATURE_PIDFILE
 116        FLAG_KILL                       = 1 << 17, // -k, Kill a running daemon
 117#endif
 118};
 119#if ENABLE_FEATURE_PIDFILE
 120# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:Mk"
 121#else
 122# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:M"
 123#endif
 124
 125enum { // interface status
 126        IFSTATUS_ERR = -1,
 127        IFSTATUS_DOWN = 0,
 128        IFSTATUS_UP = 1,
 129};
 130
 131enum { // constant fds
 132        ioctl_fd = 3,
 133        netlink_fd = 4,
 134};
 135
 136struct globals {
 137        smallint iface_last_status;
 138        smallint iface_prev_status;
 139        smallint iface_exists;
 140        smallint api_method_num;
 141
 142        /* Used in getopt32, must have sizeof == sizeof(int) */
 143        unsigned poll_time;
 144        unsigned delay_up;
 145        unsigned delay_down;
 146
 147        const char *iface;
 148        const char *api_mode;
 149        const char *script_name;
 150        const char *extra_arg;
 151};
 152#define G (*ptr_to_globals)
 153#define INIT_G() do { \
 154        SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 155        G.iface_last_status = -1; \
 156        G.iface_exists   = 1; \
 157        G.poll_time      = 1; \
 158        G.delay_down     = 5; \
 159        G.iface          = "eth0"; \
 160        G.api_mode       = "a"; \
 161        G.script_name    = "/etc/ifplugd/ifplugd.action"; \
 162} while (0)
 163
 164
 165/* Utility routines */
 166
 167static void set_ifreq_to_ifname(struct ifreq *ifreq)
 168{
 169        memset(ifreq, 0, sizeof(struct ifreq));
 170        strncpy_IFNAMSIZ(ifreq->ifr_name, G.iface);
 171}
 172
 173static int network_ioctl(int request, void* data, const char *errmsg)
 174{
 175        int r = ioctl(ioctl_fd, request, data);
 176        if (r < 0 && errmsg)
 177                bb_perror_msg("%s failed", errmsg);
 178        return r;
 179}
 180
 181/* Link detection routines and table */
 182
 183static smallint detect_link_mii(void)
 184{
 185        /* char buffer instead of bona-fide struct avoids aliasing warning */
 186        char buf[sizeof(struct ifreq)];
 187        struct ifreq *const ifreq = (void *)buf;
 188
 189        struct mii_ioctl_data *mii = (void *)&ifreq->ifr_data;
 190
 191        set_ifreq_to_ifname(ifreq);
 192
 193        if (network_ioctl(SIOCGMIIPHY, ifreq, "SIOCGMIIPHY") < 0) {
 194                return IFSTATUS_ERR;
 195        }
 196
 197        mii->reg_num = 1;
 198
 199        if (network_ioctl(SIOCGMIIREG, ifreq, "SIOCGMIIREG") < 0) {
 200                return IFSTATUS_ERR;
 201        }
 202
 203        return (mii->val_out & 0x0004) ? IFSTATUS_UP : IFSTATUS_DOWN;
 204}
 205
 206static smallint detect_link_priv(void)
 207{
 208        /* char buffer instead of bona-fide struct avoids aliasing warning */
 209        char buf[sizeof(struct ifreq)];
 210        struct ifreq *const ifreq = (void *)buf;
 211
 212        struct mii_ioctl_data *mii = (void *)&ifreq->ifr_data;
 213
 214        set_ifreq_to_ifname(ifreq);
 215
 216        if (network_ioctl(SIOCDEVPRIVATE, ifreq, "SIOCDEVPRIVATE") < 0) {
 217                return IFSTATUS_ERR;
 218        }
 219
 220        mii->reg_num = 1;
 221
 222        if (network_ioctl(SIOCDEVPRIVATE+1, ifreq, "SIOCDEVPRIVATE+1") < 0) {
 223                return IFSTATUS_ERR;
 224        }
 225
 226        return (mii->val_out & 0x0004) ? IFSTATUS_UP : IFSTATUS_DOWN;
 227}
 228
 229static smallint detect_link_ethtool(void)
 230{
 231        struct ifreq ifreq;
 232        struct ethtool_value edata;
 233
 234        set_ifreq_to_ifname(&ifreq);
 235
 236        edata.cmd = ETHTOOL_GLINK;
 237        ifreq.ifr_data = (void*) &edata;
 238
 239        if (network_ioctl(SIOCETHTOOL, &ifreq, "ETHTOOL_GLINK") < 0) {
 240                return IFSTATUS_ERR;
 241        }
 242
 243        return edata.data ? IFSTATUS_UP : IFSTATUS_DOWN;
 244}
 245
 246static smallint detect_link_iff(void)
 247{
 248        struct ifreq ifreq;
 249
 250        set_ifreq_to_ifname(&ifreq);
 251
 252        if (network_ioctl(SIOCGIFFLAGS, &ifreq, "SIOCGIFFLAGS") < 0) {
 253                return IFSTATUS_ERR;
 254        }
 255
 256        /* If IFF_UP is not set (interface is down), IFF_RUNNING is never set
 257         * regardless of link status. Simply continue to report last status -
 258         * no point in reporting spurious link downs if interface is disabled
 259         * by admin. When/if it will be brought up,
 260         * we'll report real link status.
 261         */
 262        if (!(ifreq.ifr_flags & IFF_UP) && G.iface_last_status != IFSTATUS_ERR)
 263                return G.iface_last_status;
 264
 265        return (ifreq.ifr_flags & IFF_RUNNING) ? IFSTATUS_UP : IFSTATUS_DOWN;
 266}
 267
 268static smallint detect_link_wlan(void)
 269{
 270        int i;
 271        struct iwreq iwrequest;
 272        uint8_t mac[ETH_ALEN];
 273
 274        memset(&iwrequest, 0, sizeof(iwrequest));
 275        strncpy_IFNAMSIZ(iwrequest.ifr_ifrn.ifrn_name, G.iface);
 276
 277        if (network_ioctl(SIOCGIWAP, &iwrequest, "SIOCGIWAP") < 0) {
 278                return IFSTATUS_ERR;
 279        }
 280
 281        memcpy(mac, &iwrequest.u.ap_addr.sa_data, ETH_ALEN);
 282
 283        if (mac[0] == 0xFF || mac[0] == 0x44 || mac[0] == 0x00) {
 284                for (i = 1; i < ETH_ALEN; ++i) {
 285                        if (mac[i] != mac[0])
 286                                return IFSTATUS_UP;
 287                }
 288                return IFSTATUS_DOWN;
 289        }
 290
 291        return IFSTATUS_UP;
 292}
 293
 294enum { // api mode
 295        API_ETHTOOL, // 'e'
 296        API_MII,     // 'm'
 297        API_PRIVATE, // 'p'
 298        API_WLAN,    // 'w'
 299        API_IFF,     // 'i'
 300        API_AUTO,    // 'a'
 301};
 302
 303static const char api_modes[] ALIGN1 = "empwia";
 304
 305static const struct {
 306        const char *name;
 307        smallint (*func)(void);
 308} method_table[] = {
 309        { "SIOCETHTOOL"       , &detect_link_ethtool },
 310        { "SIOCGMIIPHY"       , &detect_link_mii     },
 311        { "SIOCDEVPRIVATE"    , &detect_link_priv    },
 312        { "wireless extension", &detect_link_wlan    },
 313        { "IFF_RUNNING"       , &detect_link_iff     },
 314};
 315
 316static const char *strstatus(int status)
 317{
 318        if (status == IFSTATUS_ERR)
 319                return "error";
 320        return "down\0up" + (status * 5);
 321}
 322
 323static int run_script(const char *action)
 324{
 325        char *env_PREVIOUS, *env_CURRENT;
 326        char *argv[5];
 327        int r;
 328
 329        bb_error_msg("executing '%s %s %s'", G.script_name, G.iface, action);
 330
 331        argv[0] = (char*) G.script_name;
 332        argv[1] = (char*) G.iface;
 333        argv[2] = (char*) action;
 334        argv[3] = (char*) G.extra_arg;
 335        argv[4] = NULL;
 336
 337        env_PREVIOUS = xasprintf("%s=%s", IFPLUGD_ENV_PREVIOUS, strstatus(G.iface_prev_status));
 338        putenv(env_PREVIOUS);
 339        env_CURRENT = xasprintf("%s=%s", IFPLUGD_ENV_CURRENT, strstatus(G.iface_last_status));
 340        putenv(env_CURRENT);
 341
 342        /* r < 0 - can't exec, 0 <= r < 0x180 - exited, >=0x180 - killed by sig (r-0x180) */
 343        r = spawn_and_wait(argv);
 344
 345        bb_unsetenv_and_free(env_PREVIOUS);
 346        bb_unsetenv_and_free(env_CURRENT);
 347
 348        bb_error_msg("exit code: %d", r & 0xff);
 349        return (option_mask32 & FLAG_IGNORE_RETVAL) ? 0 : r;
 350}
 351
 352static void up_iface(void)
 353{
 354        struct ifreq ifrequest;
 355
 356        if (!G.iface_exists)
 357                return;
 358
 359        set_ifreq_to_ifname(&ifrequest);
 360        if (network_ioctl(SIOCGIFFLAGS, &ifrequest, "getting interface flags") < 0) {
 361                G.iface_exists = 0;
 362                return;
 363        }
 364
 365        if (!(ifrequest.ifr_flags & IFF_UP)) {
 366                ifrequest.ifr_flags |= IFF_UP;
 367                /* Let user know we mess up with interface */
 368                bb_error_msg("upping interface");
 369                if (network_ioctl(SIOCSIFFLAGS, &ifrequest, "setting interface flags") < 0) {
 370                        if (errno != ENODEV && errno != EADDRNOTAVAIL)
 371                                xfunc_die();
 372                        G.iface_exists = 0;
 373                        return;
 374                }
 375        }
 376
 377#if 0 /* why do we mess with IP addr? It's not our business */
 378        if (network_ioctl(SIOCGIFADDR, &ifrequest, "can't get interface address") < 0) {
 379        } else if (ifrequest.ifr_addr.sa_family != AF_INET) {
 380                bb_perror_msg("the interface is not IP-based");
 381        } else {
 382                ((struct sockaddr_in*)(&ifrequest.ifr_addr))->sin_addr.s_addr = INADDR_ANY;
 383                network_ioctl(SIOCSIFADDR, &ifrequest, "can't set interface address");
 384        }
 385        network_ioctl(SIOCGIFFLAGS, &ifrequest, "can't get interface flags");
 386#endif
 387}
 388
 389static void maybe_up_new_iface(void)
 390{
 391        if (!(option_mask32 & FLAG_NO_AUTO))
 392                up_iface();
 393
 394#if 0 /* bloat */
 395        struct ifreq ifrequest;
 396        struct ethtool_drvinfo driver_info;
 397
 398        set_ifreq_to_ifname(&ifrequest);
 399        driver_info.cmd = ETHTOOL_GDRVINFO;
 400        ifrequest.ifr_data = &driver_info;
 401        if (network_ioctl(SIOCETHTOOL, &ifrequest, NULL) == 0) {
 402                char buf[sizeof("/xx:xx:xx:xx:xx:xx")];
 403
 404                /* Get MAC */
 405                buf[0] = '\0';
 406                set_ifreq_to_ifname(&ifrequest);
 407                if (network_ioctl(SIOCGIFHWADDR, &ifrequest, NULL) == 0) {
 408                        sprintf(buf, "/%02X:%02X:%02X:%02X:%02X:%02X",
 409                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[0]),
 410                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[1]),
 411                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[2]),
 412                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[3]),
 413                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[4]),
 414                                (uint8_t)(ifrequest.ifr_hwaddr.sa_data[5]));
 415                }
 416
 417                bb_error_msg("using interface %s%s with driver<%s> (version: %s)",
 418                        G.iface, buf, driver_info.driver, driver_info.version);
 419        }
 420#endif
 421        if (G.api_mode[0] == 'a')
 422                G.api_method_num = API_AUTO;
 423}
 424
 425static smallint detect_link(void)
 426{
 427        smallint status;
 428
 429        if (!G.iface_exists)
 430                return (option_mask32 & FLAG_MONITOR) ? IFSTATUS_DOWN : IFSTATUS_ERR;
 431
 432        /* Some drivers can't detect link status when the interface is down.
 433         * I imagine detect_link_iff() is the most vulnerable.
 434         * That's why -a "noauto" in an option, not a hardwired behavior.
 435         */
 436        if (!(option_mask32 & FLAG_NO_AUTO))
 437                up_iface();
 438
 439        if (G.api_method_num == API_AUTO) {
 440                int i;
 441                smallint sv_logmode;
 442
 443                sv_logmode = logmode;
 444                for (i = 0; i < ARRAY_SIZE(method_table); i++) {
 445                        logmode = LOGMODE_NONE;
 446                        status = method_table[i].func();
 447                        logmode = sv_logmode;
 448                        if (status != IFSTATUS_ERR) {
 449                                G.api_method_num = i;
 450                                bb_error_msg("using %s detection mode", method_table[i].name);
 451                                break;
 452                        }
 453                }
 454        } else {
 455                status = method_table[G.api_method_num].func();
 456        }
 457
 458        if (status == IFSTATUS_ERR) {
 459                if (option_mask32 & FLAG_IGNORE_FAIL)
 460                        status = IFSTATUS_DOWN;
 461                else if (option_mask32 & FLAG_IGNORE_FAIL_POSITIVE)
 462                        status = IFSTATUS_UP;
 463                else if (G.api_mode[0] == 'a')
 464                        bb_error_msg("can't detect link status");
 465        }
 466
 467        if (status != G.iface_last_status) {
 468                G.iface_prev_status = G.iface_last_status;
 469                G.iface_last_status = status;
 470        }
 471
 472        return status;
 473}
 474
 475static NOINLINE int check_existence_through_netlink(void)
 476{
 477        int iface_len;
 478        /* Buffer was 1K, but on linux-3.9.9 it was reported to be too small.
 479         * netlink.h: "limit to 8K to avoid MSG_TRUNC when PAGE_SIZE is very large".
 480         * Note: on error returns (-1) we exit, no need to free replybuf.
 481         */
 482        enum { BUF_SIZE = 8 * 1024 };
 483        char *replybuf = xmalloc(BUF_SIZE);
 484
 485        iface_len = strlen(G.iface);
 486        while (1) {
 487                struct nlmsghdr *mhdr;
 488                ssize_t bytes;
 489
 490                bytes = recv(netlink_fd, replybuf, BUF_SIZE, MSG_DONTWAIT);
 491                if (bytes < 0) {
 492                        if (errno == EAGAIN)
 493                                goto ret;
 494                        if (errno == EINTR)
 495                                continue;
 496                        bb_perror_msg("netlink: recv");
 497                        return -1;
 498                }
 499
 500                mhdr = (struct nlmsghdr*)replybuf;
 501                while (bytes > 0) {
 502                        if (!NLMSG_OK(mhdr, bytes)) {
 503                                bb_error_msg("netlink packet too small or truncated");
 504                                return -1;
 505                        }
 506
 507                        if (mhdr->nlmsg_type == RTM_NEWLINK || mhdr->nlmsg_type == RTM_DELLINK) {
 508                                struct rtattr *attr;
 509                                int attr_len;
 510
 511                                if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) {
 512                                        bb_error_msg("netlink packet too small or truncated");
 513                                        return -1;
 514                                }
 515
 516                                attr = IFLA_RTA(NLMSG_DATA(mhdr));
 517                                attr_len = IFLA_PAYLOAD(mhdr);
 518
 519                                while (RTA_OK(attr, attr_len)) {
 520                                        if (attr->rta_type == IFLA_IFNAME) {
 521                                                int len = RTA_PAYLOAD(attr);
 522                                                if (len > IFNAMSIZ)
 523                                                        len = IFNAMSIZ;
 524                                                if (iface_len <= len
 525                                                 && strncmp(G.iface, RTA_DATA(attr), len) == 0
 526                                                ) {
 527                                                        G.iface_exists = (mhdr->nlmsg_type == RTM_NEWLINK);
 528                                                }
 529                                        }
 530                                        attr = RTA_NEXT(attr, attr_len);
 531                                }
 532                        }
 533
 534                        mhdr = NLMSG_NEXT(mhdr, bytes);
 535                }
 536        }
 537
 538 ret:
 539        free(replybuf);
 540        return G.iface_exists;
 541}
 542
 543#if ENABLE_FEATURE_PIDFILE
 544static NOINLINE pid_t read_pid(const char *filename)
 545{
 546        int len;
 547        char buf[128];
 548
 549        len = open_read_close(filename, buf, 127);
 550        if (len > 0) {
 551                buf[len] = '\0';
 552                /* returns ULONG_MAX on error => -1 */
 553                return bb_strtoul(buf, NULL, 10);
 554        }
 555        return 0;
 556}
 557#endif
 558
 559int ifplugd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 560int ifplugd_main(int argc UNUSED_PARAM, char **argv)
 561{
 562        int iface_status;
 563        int delay_time;
 564        const char *iface_status_str;
 565        struct pollfd netlink_pollfd[1];
 566        unsigned opts;
 567        const char *api_mode_found;
 568#if ENABLE_FEATURE_PIDFILE
 569        char *pidfile_name;
 570        pid_t pid_from_pidfile;
 571#endif
 572
 573        INIT_G();
 574
 575        opts = getopt32(argv, OPTION_STR,
 576                &G.iface, &G.script_name, &G.poll_time, &G.delay_up,
 577                &G.delay_down, &G.api_mode, &G.extra_arg);
 578        G.poll_time *= 1000;
 579
 580        applet_name = xasprintf("ifplugd(%s)", G.iface);
 581
 582#if ENABLE_FEATURE_PIDFILE
 583        pidfile_name = xasprintf(CONFIG_PID_FILE_PATH "/ifplugd.%s.pid", G.iface);
 584        pid_from_pidfile = read_pid(pidfile_name);
 585
 586        if (opts & FLAG_KILL) {
 587                if (pid_from_pidfile > 0)
 588                        /* Upstream tool use SIGINT for -k */
 589                        kill(pid_from_pidfile, SIGINT);
 590                return EXIT_SUCCESS;
 591        }
 592
 593        if (pid_from_pidfile > 0 && kill(pid_from_pidfile, 0) == 0)
 594                bb_error_msg_and_die("daemon already running");
 595#endif
 596
 597        api_mode_found = strchr(api_modes, G.api_mode[0]);
 598        if (!api_mode_found)
 599                bb_error_msg_and_die("unknown API mode '%s'", G.api_mode);
 600        G.api_method_num = api_mode_found - api_modes;
 601
 602        if (!(opts & FLAG_NO_DAEMON))
 603                bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
 604
 605        xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), ioctl_fd);
 606        if (opts & FLAG_MONITOR) {
 607                struct sockaddr_nl addr;
 608                int fd = xsocket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
 609
 610                memset(&addr, 0, sizeof(addr));
 611                addr.nl_family = AF_NETLINK;
 612                addr.nl_groups = RTMGRP_LINK;
 613                addr.nl_pid = getpid();
 614
 615                xbind(fd, (struct sockaddr*)&addr, sizeof(addr));
 616                xmove_fd(fd, netlink_fd);
 617        }
 618
 619        write_pidfile(pidfile_name);
 620
 621        /* this can't be moved before socket creation */
 622        if (!(opts & FLAG_NO_SYSLOG)) {
 623                openlog(applet_name, 0, LOG_DAEMON);
 624                logmode |= LOGMODE_SYSLOG;
 625        }
 626
 627        bb_signals(0
 628                | (1 << SIGINT )
 629                | (1 << SIGTERM)
 630                | (1 << SIGQUIT)
 631                | (1 << SIGHUP ) /* why we ignore it? */
 632                /* | (1 << SIGCHLD) - run_script does not use it anymore */
 633                , record_signo);
 634
 635        bb_error_msg("started: %s", bb_banner);
 636
 637        if (opts & FLAG_MONITOR) {
 638                struct ifreq ifrequest;
 639                set_ifreq_to_ifname(&ifrequest);
 640                G.iface_exists = (network_ioctl(SIOCGIFINDEX, &ifrequest, NULL) == 0);
 641        }
 642
 643        if (G.iface_exists)
 644                maybe_up_new_iface();
 645
 646        iface_status = detect_link();
 647        if (iface_status == IFSTATUS_ERR)
 648                goto exiting;
 649        iface_status_str = strstatus(iface_status);
 650
 651        if (opts & FLAG_MONITOR) {
 652                bb_error_msg("interface %s",
 653                        G.iface_exists ? "exists"
 654                        : "doesn't exist, waiting");
 655        }
 656        /* else we assume it always exists, but don't mislead user
 657         * by potentially lying that it really exists */
 658
 659        if (G.iface_exists) {
 660                bb_error_msg("link is %s", iface_status_str);
 661        }
 662
 663        if ((!(opts & FLAG_NO_STARTUP)
 664             && iface_status == IFSTATUS_UP
 665            )
 666         || (opts & FLAG_INITIAL_DOWN)
 667        ) {
 668                if (run_script(iface_status_str) != 0)
 669                        goto exiting;
 670        }
 671
 672        /* Main loop */
 673        netlink_pollfd[0].fd = netlink_fd;
 674        netlink_pollfd[0].events = POLLIN;
 675        delay_time = 0;
 676        while (1) {
 677                int iface_status_old;
 678
 679                switch (bb_got_signal) {
 680                case SIGINT:
 681                case SIGTERM:
 682                        bb_got_signal = 0;
 683                        goto cleanup;
 684                case SIGQUIT:
 685                        bb_got_signal = 0;
 686                        goto exiting;
 687                default:
 688                        bb_got_signal = 0;
 689                /* do not clear bb_got_signal if already 0, this can lose signals */
 690                case 0:
 691                        break;
 692                }
 693
 694                if (poll(netlink_pollfd,
 695                                (opts & FLAG_MONITOR) ? 1 : 0,
 696                                G.poll_time
 697                        ) < 0
 698                ) {
 699                        if (errno == EINTR)
 700                                continue;
 701                        bb_perror_msg("poll");
 702                        goto exiting;
 703                }
 704
 705                if ((opts & FLAG_MONITOR)
 706                 && (netlink_pollfd[0].revents & POLLIN)
 707                ) {
 708                        int iface_exists_old;
 709
 710                        iface_exists_old = G.iface_exists;
 711                        G.iface_exists = check_existence_through_netlink();
 712                        if (G.iface_exists < 0) /* error */
 713                                goto exiting;
 714                        if (iface_exists_old != G.iface_exists) {
 715                                bb_error_msg("interface %sappeared",
 716                                                G.iface_exists ? "" : "dis");
 717                                if (G.iface_exists)
 718                                        maybe_up_new_iface();
 719                        }
 720                }
 721
 722                /* note: if !G.iface_exists, returns DOWN */
 723                iface_status_old = iface_status;
 724                iface_status = detect_link();
 725                if (iface_status == IFSTATUS_ERR) {
 726                        if (!(opts & FLAG_MONITOR))
 727                                goto exiting;
 728                        iface_status = IFSTATUS_DOWN;
 729                }
 730                iface_status_str = strstatus(iface_status);
 731
 732                if (iface_status_old != iface_status) {
 733                        bb_error_msg("link is %s", iface_status_str);
 734
 735                        if (delay_time) {
 736                                /* link restored its old status before
 737                                 * we ran script. don't run the script: */
 738                                delay_time = 0;
 739                        } else {
 740                                delay_time = monotonic_sec();
 741                                if (iface_status == IFSTATUS_UP)
 742                                        delay_time += G.delay_up;
 743                                if (iface_status == IFSTATUS_DOWN)
 744                                        delay_time += G.delay_down;
 745#if 0  /* if you are back in 1970... */
 746                                if (delay_time == 0) {
 747                                        sleep(1);
 748                                        delay_time = 1;
 749                                }
 750#endif
 751                        }
 752                }
 753
 754                if (delay_time && (int)(monotonic_sec() - delay_time) >= 0) {
 755                        if (run_script(iface_status_str) != 0)
 756                                goto exiting;
 757                        delay_time = 0;
 758                }
 759        } /* while (1) */
 760
 761 cleanup:
 762        if (!(opts & FLAG_NO_SHUTDOWN)
 763         && (iface_status == IFSTATUS_UP
 764             || (iface_status == IFSTATUS_DOWN && delay_time)
 765            )
 766        ) {
 767                setenv(IFPLUGD_ENV_PREVIOUS, strstatus(iface_status), 1);
 768                setenv(IFPLUGD_ENV_CURRENT, strstatus(-1), 1);
 769                run_script("down\0up"); /* reusing string */
 770        }
 771
 772 exiting:
 773        remove_pidfile(pidfile_name);
 774        bb_error_msg_and_die("exiting");
 775}
 776