| /* vi: set sw=4 ts=4: */ |
| /* |
| * ifplugd for busybox, based on ifplugd 0.28 (written by Lennart Poettering). |
| * |
| * Copyright (C) 2009 Maksym Kryzhanovskyy <xmaks@email.cz> |
| * |
| * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
| */ |
| |
| //usage:#define ifplugd_trivial_usage |
| //usage: "[OPTIONS]" |
| //usage:#define ifplugd_full_usage "\n\n" |
| //usage: "Network interface plug detection daemon\n" |
| //usage: "\n -n Don't daemonize" |
| //usage: "\n -s Don't log to syslog" |
| //usage: "\n -i IFACE Interface" |
| //usage: "\n -f/-F Treat link detection error as link down/link up" |
| //usage: "\n (otherwise exit on error)" |
| //usage: "\n -a Don't up interface at each link probe" |
| //usage: "\n -M Monitor creation/destruction of interface" |
| //usage: "\n (otherwise it must exist)" |
| //usage: "\n -r PROG Script to run" |
| //usage: "\n -x ARG Extra argument for script" |
| //usage: "\n -I Don't exit on nonzero exit code from script" |
| //usage: "\n -p Don't run \"up\" script on startup" |
| //usage: "\n -q Don't run \"down\" script on exit" |
| //usage: "\n -l Always run script on startup" |
| //usage: "\n -t SECS Poll time in seconds" |
| //usage: "\n -u SECS Delay before running script after link up" |
| //usage: "\n -d SECS Delay after link down" |
| //usage: "\n -m MODE API mode (mii, priv, ethtool, wlan, iff, auto)" |
| //usage: "\n -k Kill running daemon" |
| |
| #include "libbb.h" |
| |
| #include "fix_u32.h" |
| #include <linux/if.h> |
| #include <linux/mii.h> |
| #include <linux/ethtool.h> |
| #ifdef HAVE_NET_ETHERNET_H |
| # include <net/ethernet.h> |
| #endif |
| #include <linux/netlink.h> |
| #include <linux/rtnetlink.h> |
| #include <linux/sockios.h> |
| #include <syslog.h> |
| |
| #define __user |
| #include <linux/wireless.h> |
| |
| /* |
| From initial port to busybox, removed most of the redundancy by |
| converting implementation of a polymorphic interface to the strict |
| functional style. The main role is run a script when link state |
| changed, other activities like audio signal or detailed reports |
| are on the script itself. |
| |
| One questionable point of the design is netlink usage: |
| |
| We have 1 second timeout by default to poll the link status, |
| it is short enough so that there are no real benefits in |
| using netlink to get "instantaneous" interface creation/deletion |
| notifications. We can check for interface existence by just |
| doing some fast ioctl using its name. |
| |
| Netlink code then can be just dropped (1k or more?) |
| */ |
| |
| |
| #define IFPLUGD_ENV_PREVIOUS "IFPLUGD_PREVIOUS" |
| #define IFPLUGD_ENV_CURRENT "IFPLUGD_CURRENT" |
| |
| enum { |
| FLAG_NO_AUTO = 1 << 0, // -a, Do not enable interface automatically |
| FLAG_NO_DAEMON = 1 << 1, // -n, Do not daemonize |
| FLAG_NO_SYSLOG = 1 << 2, // -s, Do not use syslog, use stderr instead |
| FLAG_IGNORE_FAIL = 1 << 3, // -f, Ignore detection failure, retry instead (failure is treated as DOWN) |
| FLAG_IGNORE_FAIL_POSITIVE = 1 << 4, // -F, Ignore detection failure, retry instead (failure is treated as UP) |
| FLAG_IFACE = 1 << 5, // -i, Specify ethernet interface |
| FLAG_RUN = 1 << 6, // -r, Specify program to execute |
| FLAG_IGNORE_RETVAL = 1 << 7, // -I, Don't exit on nonzero return value of program executed |
| FLAG_POLL_TIME = 1 << 8, // -t, Specify poll time in seconds |
| FLAG_DELAY_UP = 1 << 9, // -u, Specify delay for configuring interface |
| FLAG_DELAY_DOWN = 1 << 10, // -d, Specify delay for deconfiguring interface |
| FLAG_API_MODE = 1 << 11, // -m, Force API mode (mii, priv, ethtool, wlan, auto) |
| FLAG_NO_STARTUP = 1 << 12, // -p, Don't run script on daemon startup |
| FLAG_NO_SHUTDOWN = 1 << 13, // -q, Don't run script on daemon quit |
| FLAG_INITIAL_DOWN = 1 << 14, // -l, Run "down" script on startup if no cable is detected |
| FLAG_EXTRA_ARG = 1 << 15, // -x, Specify an extra argument for action script |
| FLAG_MONITOR = 1 << 16, // -M, Use interface monitoring |
| #if ENABLE_FEATURE_PIDFILE |
| FLAG_KILL = 1 << 17, // -k, Kill a running daemon |
| #endif |
| }; |
| #if ENABLE_FEATURE_PIDFILE |
| # define OPTION_STR "+ansfFi:r:It:u:d:m:pqlx:Mk" |
| #else |
| # define OPTION_STR "+ansfFi:r:It:u:d:m:pqlx:M" |
| #endif |
| |
| enum { // interface status |
| IFSTATUS_ERR = -1, |
| IFSTATUS_DOWN = 0, |
| IFSTATUS_UP = 1, |
| }; |
| |
| enum { // constant fds |
| ioctl_fd = 3, |
| netlink_fd = 4, |
| }; |
| |
| struct globals { |
| smallint iface_last_status; |
| smallint iface_prev_status; |
| smallint iface_exists; |
| smallint api_method_num; |
| |
| /* Used in getopt32, must have sizeof == sizeof(int) */ |
| unsigned poll_time; |
| unsigned delay_up; |
| unsigned delay_down; |
| |
| const char *iface; |
| const char *api_mode; |
| const char *script_name; |
| const char *extra_arg; |
| }; |
| #define G (*ptr_to_globals) |
| #define INIT_G() do { \ |
| SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ |
| G.iface_last_status = -1; \ |
| G.iface_exists = 1; \ |
| G.poll_time = 1; \ |
| G.delay_down = 5; \ |
| G.iface = "eth0"; \ |
| G.api_mode = "a"; \ |
| G.script_name = "/etc/ifplugd/ifplugd.action"; \ |
| } while (0) |
| |
| |
| /* Utility routines */ |
| |
| static void set_ifreq_to_ifname(struct ifreq *ifreq) |
| { |
| memset(ifreq, 0, sizeof(struct ifreq)); |
| strncpy_IFNAMSIZ(ifreq->ifr_name, G.iface); |
| } |
| |
| static int network_ioctl(int request, void* data, const char *errmsg) |
| { |
| int r = ioctl(ioctl_fd, request, data); |
| if (r < 0 && errmsg) |
| bb_perror_msg("%s failed", errmsg); |
| return r; |
| } |
| |
| /* Link detection routines and table */ |
| |
| static smallint detect_link_mii(void) |
| { |
| /* char buffer instead of bona-fide struct avoids aliasing warning */ |
| char buf[sizeof(struct ifreq)]; |
| struct ifreq *const ifreq = (void *)buf; |
| |
| struct mii_ioctl_data *mii = (void *)&ifreq->ifr_data; |
| |
| set_ifreq_to_ifname(ifreq); |
| |
| if (network_ioctl(SIOCGMIIPHY, ifreq, "SIOCGMIIPHY") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| mii->reg_num = 1; |
| |
| if (network_ioctl(SIOCGMIIREG, ifreq, "SIOCGMIIREG") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| return (mii->val_out & 0x0004) ? IFSTATUS_UP : IFSTATUS_DOWN; |
| } |
| |
| static smallint detect_link_priv(void) |
| { |
| /* char buffer instead of bona-fide struct avoids aliasing warning */ |
| char buf[sizeof(struct ifreq)]; |
| struct ifreq *const ifreq = (void *)buf; |
| |
| struct mii_ioctl_data *mii = (void *)&ifreq->ifr_data; |
| |
| set_ifreq_to_ifname(ifreq); |
| |
| if (network_ioctl(SIOCDEVPRIVATE, ifreq, "SIOCDEVPRIVATE") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| mii->reg_num = 1; |
| |
| if (network_ioctl(SIOCDEVPRIVATE+1, ifreq, "SIOCDEVPRIVATE+1") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| return (mii->val_out & 0x0004) ? IFSTATUS_UP : IFSTATUS_DOWN; |
| } |
| |
| static smallint detect_link_ethtool(void) |
| { |
| struct ifreq ifreq; |
| struct ethtool_value edata; |
| |
| set_ifreq_to_ifname(&ifreq); |
| |
| edata.cmd = ETHTOOL_GLINK; |
| ifreq.ifr_data = (void*) &edata; |
| |
| if (network_ioctl(SIOCETHTOOL, &ifreq, "ETHTOOL_GLINK") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| return edata.data ? IFSTATUS_UP : IFSTATUS_DOWN; |
| } |
| |
| static smallint detect_link_iff(void) |
| { |
| struct ifreq ifreq; |
| |
| set_ifreq_to_ifname(&ifreq); |
| |
| if (network_ioctl(SIOCGIFFLAGS, &ifreq, "SIOCGIFFLAGS") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| /* If IFF_UP is not set (interface is down), IFF_RUNNING is never set |
| * regardless of link status. Simply continue to report last status - |
| * no point in reporting spurious link downs if interface is disabled |
| * by admin. When/if it will be brought up, |
| * we'll report real link status. |
| */ |
| if (!(ifreq.ifr_flags & IFF_UP) && G.iface_last_status != IFSTATUS_ERR) |
| return G.iface_last_status; |
| |
| return (ifreq.ifr_flags & IFF_RUNNING) ? IFSTATUS_UP : IFSTATUS_DOWN; |
| } |
| |
| static smallint detect_link_wlan(void) |
| { |
| int i; |
| struct iwreq iwrequest; |
| uint8_t mac[ETH_ALEN]; |
| |
| memset(&iwrequest, 0, sizeof(iwrequest)); |
| strncpy_IFNAMSIZ(iwrequest.ifr_ifrn.ifrn_name, G.iface); |
| |
| if (network_ioctl(SIOCGIWAP, &iwrequest, "SIOCGIWAP") < 0) { |
| return IFSTATUS_ERR; |
| } |
| |
| memcpy(mac, &iwrequest.u.ap_addr.sa_data, ETH_ALEN); |
| |
| if (mac[0] == 0xFF || mac[0] == 0x44 || mac[0] == 0x00) { |
| for (i = 1; i < ETH_ALEN; ++i) { |
| if (mac[i] != mac[0]) |
| return IFSTATUS_UP; |
| } |
| return IFSTATUS_DOWN; |
| } |
| |
| return IFSTATUS_UP; |
| } |
| |
| enum { // api mode |
| API_ETHTOOL, // 'e' |
| API_MII, // 'm' |
| API_PRIVATE, // 'p' |
| API_WLAN, // 'w' |
| API_IFF, // 'i' |
| API_AUTO, // 'a' |
| }; |
| |
| static const char api_modes[] ALIGN1 = "empwia"; |
| |
| static const struct { |
| const char *name; |
| smallint (*func)(void); |
| } method_table[] = { |
| { "SIOCETHTOOL" , &detect_link_ethtool }, |
| { "SIOCGMIIPHY" , &detect_link_mii }, |
| { "SIOCDEVPRIVATE" , &detect_link_priv }, |
| { "wireless extension", &detect_link_wlan }, |
| { "IFF_RUNNING" , &detect_link_iff }, |
| }; |
| |
| |
| |
| static const char *strstatus(int status) |
| { |
| if (status == IFSTATUS_ERR) |
| return "error"; |
| return "down\0up" + (status * 5); |
| } |
| |
| static int run_script(const char *action) |
| { |
| char *env_PREVIOUS, *env_CURRENT; |
| char *argv[5]; |
| int r; |
| |
| bb_error_msg("executing '%s %s %s'", G.script_name, G.iface, action); |
| |
| argv[0] = (char*) G.script_name; |
| argv[1] = (char*) G.iface; |
| argv[2] = (char*) action; |
| argv[3] = (char*) G.extra_arg; |
| argv[4] = NULL; |
| |
| env_PREVIOUS = xasprintf("%s=%s", IFPLUGD_ENV_PREVIOUS, strstatus(G.iface_prev_status)); |
| putenv(env_PREVIOUS); |
| env_CURRENT = xasprintf("%s=%s", IFPLUGD_ENV_CURRENT, strstatus(G.iface_last_status)); |
| putenv(env_CURRENT); |
| |
| /* r < 0 - can't exec, 0 <= r < 0x180 - exited, >=0x180 - killed by sig (r-0x180) */ |
| r = spawn_and_wait(argv); |
| |
| unsetenv(IFPLUGD_ENV_PREVIOUS); |
| unsetenv(IFPLUGD_ENV_CURRENT); |
| free(env_PREVIOUS); |
| free(env_CURRENT); |
| |
| bb_error_msg("exit code: %d", r & 0xff); |
| return (option_mask32 & FLAG_IGNORE_RETVAL) ? 0 : r; |
| } |
| |
| static void up_iface(void) |
| { |
| struct ifreq ifrequest; |
| |
| if (!G.iface_exists) |
| return; |
| |
| set_ifreq_to_ifname(&ifrequest); |
| if (network_ioctl(SIOCGIFFLAGS, &ifrequest, "getting interface flags") < 0) { |
| G.iface_exists = 0; |
| return; |
| } |
| |
| if (!(ifrequest.ifr_flags & IFF_UP)) { |
| ifrequest.ifr_flags |= IFF_UP; |
| /* Let user know we mess up with interface */ |
| bb_error_msg("upping interface"); |
| if (network_ioctl(SIOCSIFFLAGS, &ifrequest, "setting interface flags") < 0) |
| xfunc_die(); |
| } |
| |
| #if 0 /* why do we mess with IP addr? It's not our business */ |
| if (network_ioctl(SIOCGIFADDR, &ifrequest, "can't get interface address") < 0) { |
| } else if (ifrequest.ifr_addr.sa_family != AF_INET) { |
| bb_perror_msg("the interface is not IP-based"); |
| } else { |
| ((struct sockaddr_in*)(&ifrequest.ifr_addr))->sin_addr.s_addr = INADDR_ANY; |
| network_ioctl(SIOCSIFADDR, &ifrequest, "can't set interface address"); |
| } |
| network_ioctl(SIOCGIFFLAGS, &ifrequest, "can't get interface flags"); |
| #endif |
| } |
| |
| static void maybe_up_new_iface(void) |
| { |
| if (!(option_mask32 & FLAG_NO_AUTO)) |
| up_iface(); |
| |
| #if 0 /* bloat */ |
| struct ifreq ifrequest; |
| struct ethtool_drvinfo driver_info; |
| |
| set_ifreq_to_ifname(&ifrequest); |
| driver_info.cmd = ETHTOOL_GDRVINFO; |
| ifrequest.ifr_data = &driver_info; |
| if (network_ioctl(SIOCETHTOOL, &ifrequest, NULL) == 0) { |
| char buf[sizeof("/xx:xx:xx:xx:xx:xx")]; |
| |
| /* Get MAC */ |
| buf[0] = '\0'; |
| set_ifreq_to_ifname(&ifrequest); |
| if (network_ioctl(SIOCGIFHWADDR, &ifrequest, NULL) == 0) { |
| sprintf(buf, "/%02X:%02X:%02X:%02X:%02X:%02X", |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[0]), |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[1]), |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[2]), |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[3]), |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[4]), |
| (uint8_t)(ifrequest.ifr_hwaddr.sa_data[5])); |
| } |
| |
| bb_error_msg("using interface %s%s with driver<%s> (version: %s)", |
| G.iface, buf, driver_info.driver, driver_info.version); |
| } |
| #endif |
| if (G.api_mode[0] == 'a') |
| G.api_method_num = API_AUTO; |
| } |
| |
| static smallint detect_link(void) |
| { |
| smallint status; |
| |
| if (!G.iface_exists) |
| return (option_mask32 & FLAG_MONITOR) ? IFSTATUS_DOWN : IFSTATUS_ERR; |
| |
| /* Some drivers can't detect link status when the interface is down. |
| * I imagine detect_link_iff() is the most vulnerable. |
| * That's why -a "noauto" in an option, not a hardwired behavior. |
| */ |
| if (!(option_mask32 & FLAG_NO_AUTO)) |
| up_iface(); |
| |
| if (G.api_method_num == API_AUTO) { |
| int i; |
| smallint sv_logmode; |
| |
| sv_logmode = logmode; |
| for (i = 0; i < ARRAY_SIZE(method_table); i++) { |
| logmode = LOGMODE_NONE; |
| status = method_table[i].func(); |
| logmode = sv_logmode; |
| if (status != IFSTATUS_ERR) { |
| G.api_method_num = i; |
| bb_error_msg("using %s detection mode", method_table[i].name); |
| break; |
| } |
| } |
| } else { |
| status = method_table[G.api_method_num].func(); |
| } |
| |
| if (status == IFSTATUS_ERR) { |
| if (option_mask32 & FLAG_IGNORE_FAIL) |
| status = IFSTATUS_DOWN; |
| else if (option_mask32 & FLAG_IGNORE_FAIL_POSITIVE) |
| status = IFSTATUS_UP; |
| else if (G.api_mode[0] == 'a') |
| bb_error_msg("can't detect link status"); |
| } |
| |
| if (status != G.iface_last_status) { |
| G.iface_prev_status = G.iface_last_status; |
| G.iface_last_status = status; |
| } |
| |
| return status; |
| } |
| |
| static NOINLINE int check_existence_through_netlink(void) |
| { |
| int iface_len; |
| /* Buffer was 1K, but on linux-3.9.9 it was reported to be too small. |
| * netlink.h: "limit to 8K to avoid MSG_TRUNC when PAGE_SIZE is very large". |
| * Note: on error returns (-1) we exit, no need to free replybuf. |
| */ |
| enum { BUF_SIZE = 8 * 1024 }; |
| char *replybuf = xmalloc(BUF_SIZE); |
| |
| iface_len = strlen(G.iface); |
| while (1) { |
| struct nlmsghdr *mhdr; |
| ssize_t bytes; |
| |
| bytes = recv(netlink_fd, replybuf, BUF_SIZE, MSG_DONTWAIT); |
| if (bytes < 0) { |
| if (errno == EAGAIN) |
| goto ret; |
| if (errno == EINTR) |
| continue; |
| bb_perror_msg("netlink: recv"); |
| return -1; |
| } |
| |
| mhdr = (struct nlmsghdr*)replybuf; |
| while (bytes > 0) { |
| if (!NLMSG_OK(mhdr, bytes)) { |
| bb_error_msg("netlink packet too small or truncated"); |
| return -1; |
| } |
| |
| if (mhdr->nlmsg_type == RTM_NEWLINK || mhdr->nlmsg_type == RTM_DELLINK) { |
| struct rtattr *attr; |
| int attr_len; |
| |
| if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) { |
| bb_error_msg("netlink packet too small or truncated"); |
| return -1; |
| } |
| |
| attr = IFLA_RTA(NLMSG_DATA(mhdr)); |
| attr_len = IFLA_PAYLOAD(mhdr); |
| |
| while (RTA_OK(attr, attr_len)) { |
| if (attr->rta_type == IFLA_IFNAME) { |
| int len = RTA_PAYLOAD(attr); |
| if (len > IFNAMSIZ) |
| len = IFNAMSIZ; |
| if (iface_len <= len |
| && strncmp(G.iface, RTA_DATA(attr), len) == 0 |
| ) { |
| G.iface_exists = (mhdr->nlmsg_type == RTM_NEWLINK); |
| } |
| } |
| attr = RTA_NEXT(attr, attr_len); |
| } |
| } |
| |
| mhdr = NLMSG_NEXT(mhdr, bytes); |
| } |
| } |
| |
| ret: |
| free(replybuf); |
| return G.iface_exists; |
| } |
| |
| #if ENABLE_FEATURE_PIDFILE |
| static NOINLINE pid_t read_pid(const char *filename) |
| { |
| int len; |
| char buf[128]; |
| |
| len = open_read_close(filename, buf, 127); |
| if (len > 0) { |
| buf[len] = '\0'; |
| /* returns ULONG_MAX on error => -1 */ |
| return bb_strtoul(buf, NULL, 10); |
| } |
| return 0; |
| } |
| #endif |
| |
| int ifplugd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
| int ifplugd_main(int argc UNUSED_PARAM, char **argv) |
| { |
| int iface_status; |
| int delay_time; |
| const char *iface_status_str; |
| struct pollfd netlink_pollfd[1]; |
| unsigned opts; |
| const char *api_mode_found; |
| #if ENABLE_FEATURE_PIDFILE |
| char *pidfile_name; |
| pid_t pid_from_pidfile; |
| #endif |
| |
| INIT_G(); |
| |
| opt_complementary = "t+:u+:d+"; |
| opts = getopt32(argv, OPTION_STR, |
| &G.iface, &G.script_name, &G.poll_time, &G.delay_up, |
| &G.delay_down, &G.api_mode, &G.extra_arg); |
| G.poll_time *= 1000; |
| |
| applet_name = xasprintf("ifplugd(%s)", G.iface); |
| |
| #if ENABLE_FEATURE_PIDFILE |
| pidfile_name = xasprintf(CONFIG_PID_FILE_PATH "/ifplugd.%s.pid", G.iface); |
| pid_from_pidfile = read_pid(pidfile_name); |
| |
| if (opts & FLAG_KILL) { |
| if (pid_from_pidfile > 0) |
| /* Upstream tool use SIGINT for -k */ |
| kill(pid_from_pidfile, SIGINT); |
| return EXIT_SUCCESS; |
| } |
| |
| if (pid_from_pidfile > 0 && kill(pid_from_pidfile, 0) == 0) |
| bb_error_msg_and_die("daemon already running"); |
| #endif |
| |
| api_mode_found = strchr(api_modes, G.api_mode[0]); |
| if (!api_mode_found) |
| bb_error_msg_and_die("unknown API mode '%s'", G.api_mode); |
| G.api_method_num = api_mode_found - api_modes; |
| |
| if (!(opts & FLAG_NO_DAEMON)) |
| bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv); |
| |
| xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), ioctl_fd); |
| if (opts & FLAG_MONITOR) { |
| struct sockaddr_nl addr; |
| int fd = xsocket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); |
| |
| memset(&addr, 0, sizeof(addr)); |
| addr.nl_family = AF_NETLINK; |
| addr.nl_groups = RTMGRP_LINK; |
| addr.nl_pid = getpid(); |
| |
| xbind(fd, (struct sockaddr*)&addr, sizeof(addr)); |
| xmove_fd(fd, netlink_fd); |
| } |
| |
| write_pidfile(pidfile_name); |
| |
| /* this can't be moved before socket creation */ |
| if (!(opts & FLAG_NO_SYSLOG)) { |
| openlog(applet_name, 0, LOG_DAEMON); |
| logmode |= LOGMODE_SYSLOG; |
| } |
| |
| bb_signals(0 |
| | (1 << SIGINT ) |
| | (1 << SIGTERM) |
| | (1 << SIGQUIT) |
| | (1 << SIGHUP ) /* why we ignore it? */ |
| /* | (1 << SIGCHLD) - run_script does not use it anymore */ |
| , record_signo); |
| |
| bb_error_msg("started: %s", bb_banner); |
| |
| if (opts & FLAG_MONITOR) { |
| struct ifreq ifrequest; |
| set_ifreq_to_ifname(&ifrequest); |
| G.iface_exists = (network_ioctl(SIOCGIFINDEX, &ifrequest, NULL) == 0); |
| } |
| |
| if (G.iface_exists) |
| maybe_up_new_iface(); |
| |
| iface_status = detect_link(); |
| if (iface_status == IFSTATUS_ERR) |
| goto exiting; |
| iface_status_str = strstatus(iface_status); |
| |
| if (opts & FLAG_MONITOR) { |
| bb_error_msg("interface %s", |
| G.iface_exists ? "exists" |
| : "doesn't exist, waiting"); |
| } |
| /* else we assume it always exists, but don't mislead user |
| * by potentially lying that it really exists */ |
| |
| if (G.iface_exists) { |
| bb_error_msg("link is %s", iface_status_str); |
| } |
| |
| if ((!(opts & FLAG_NO_STARTUP) |
| && iface_status == IFSTATUS_UP |
| ) |
| || (opts & FLAG_INITIAL_DOWN) |
| ) { |
| if (run_script(iface_status_str) != 0) |
| goto exiting; |
| } |
| |
| /* Main loop */ |
| netlink_pollfd[0].fd = netlink_fd; |
| netlink_pollfd[0].events = POLLIN; |
| delay_time = 0; |
| while (1) { |
| int iface_status_old; |
| int iface_exists_old; |
| |
| switch (bb_got_signal) { |
| case SIGINT: |
| case SIGTERM: |
| bb_got_signal = 0; |
| goto cleanup; |
| case SIGQUIT: |
| bb_got_signal = 0; |
| goto exiting; |
| default: |
| bb_got_signal = 0; |
| break; |
| } |
| |
| if (poll(netlink_pollfd, |
| (opts & FLAG_MONITOR) ? 1 : 0, |
| G.poll_time |
| ) < 0 |
| ) { |
| if (errno == EINTR) |
| continue; |
| bb_perror_msg("poll"); |
| goto exiting; |
| } |
| |
| iface_status_old = iface_status; |
| iface_exists_old = G.iface_exists; |
| |
| if ((opts & FLAG_MONITOR) |
| && (netlink_pollfd[0].revents & POLLIN) |
| ) { |
| G.iface_exists = check_existence_through_netlink(); |
| if (G.iface_exists < 0) /* error */ |
| goto exiting; |
| if (iface_exists_old != G.iface_exists) { |
| bb_error_msg("interface %sappeared", |
| G.iface_exists ? "" : "dis"); |
| if (G.iface_exists) |
| maybe_up_new_iface(); |
| } |
| } |
| |
| /* note: if !G.iface_exists, returns DOWN */ |
| iface_status = detect_link(); |
| if (iface_status == IFSTATUS_ERR) { |
| if (!(opts & FLAG_MONITOR)) |
| goto exiting; |
| iface_status = IFSTATUS_DOWN; |
| } |
| iface_status_str = strstatus(iface_status); |
| |
| if (iface_status_old != iface_status) { |
| bb_error_msg("link is %s", iface_status_str); |
| |
| if (delay_time) { |
| /* link restored its old status before |
| * we run script. don't run the script: */ |
| delay_time = 0; |
| } else { |
| delay_time = monotonic_sec(); |
| if (iface_status == IFSTATUS_UP) |
| delay_time += G.delay_up; |
| if (iface_status == IFSTATUS_DOWN) |
| delay_time += G.delay_down; |
| if (delay_time == 0) |
| delay_time++; |
| } |
| } |
| |
| if (delay_time && (int)(monotonic_sec() - delay_time) >= 0) { |
| delay_time = 0; |
| if (run_script(iface_status_str) != 0) |
| goto exiting; |
| } |
| } /* while (1) */ |
| |
| cleanup: |
| if (!(opts & FLAG_NO_SHUTDOWN) |
| && (iface_status == IFSTATUS_UP |
| || (iface_status == IFSTATUS_DOWN && delay_time) |
| ) |
| ) { |
| setenv(IFPLUGD_ENV_PREVIOUS, strstatus(iface_status), 1); |
| setenv(IFPLUGD_ENV_CURRENT, strstatus(-1), 1); |
| run_script("down\0up"); /* reusing string */ |
| } |
| |
| exiting: |
| remove_pidfile(pidfile_name); |
| bb_error_msg_and_die("exiting"); |
| } |