busybox/networking/ifplugd.c

/* 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 tarball for details.
 */
#include "libbb.h"

#include "fix_u32.h"
#include <linux/if.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <net/ethernet.h>
#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 { // api mode
	API_AUTO	= 'a',
	API_ETHTOOL	= 'e',
	API_MII		= 'm',
	API_PRIVATE	= 'p',
	API_WLAN	= 'w',
	API_IFF		= 'i',
};

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;

	/* 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;

	smallint (*detect_link_func)(void);
	smallint (*cached_detect_link_func)(void);
};
#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)


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 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;
}

static void set_ifreq_to_ifname(struct ifreq *ifreq)
{
	memset(ifreq, 0, sizeof(struct ifreq));
	strncpy_IFNAMSIZ(ifreq->ifr_name, G.iface);
}

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

	G.cached_detect_link_func = NULL;
}

static smallint detect_link_mii(void)
{
	struct ifreq ifreq;
	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)
{
	struct ifreq ifreq;
	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;
}

static smallint detect_link_auto(void)
{
	static const struct {
		const char *name;
		smallint (*func)(void);
	} method[] = {
		{ "SIOCETHTOOL"       , &detect_link_ethtool },
		{ "SIOCGMIIPHY"       , &detect_link_mii     },
		{ "SIOCDEVPRIVATE"    , &detect_link_priv    },
		{ "wireless extension", &detect_link_wlan    },
		{ "IFF_RUNNING"       , &detect_link_iff     },
	};
	int i;
	smallint iface_status;
	smallint sv_logmode;

	if (G.cached_detect_link_func) {
		iface_status = G.cached_detect_link_func();
		if (iface_status != IFSTATUS_ERR)
			return iface_status;
	}

	sv_logmode = logmode;
	for (i = 0; i < ARRAY_SIZE(method); i++) {
		logmode = LOGMODE_NONE;
		iface_status = method[i].func();
		logmode = sv_logmode;
		if (iface_status != IFSTATUS_ERR) {
			G.cached_detect_link_func = method[i].func;
			bb_error_msg("using %s detection mode", method[i].name);
			break;
		}
	}
	return iface_status;
}

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();

	status = G.detect_link_func();
	if (status == IFSTATUS_ERR) {
		if (option_mask32 & FLAG_IGNORE_FAIL)
			status = IFSTATUS_DOWN;
		if (option_mask32 & FLAG_IGNORE_FAIL_POSITIVE)
			status = IFSTATUS_UP;
	}

	if (status == IFSTATUS_ERR
	 && G.detect_link_func == detect_link_auto
	) {
		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;
	char replybuf[1024];

	iface_len = strlen(G.iface);
	while (1) {
		struct nlmsghdr *mhdr;
		ssize_t bytes;

		bytes = recv(netlink_fd, &replybuf, sizeof(replybuf), MSG_DONTWAIT);
		if (bytes < 0) {
			if (errno == EAGAIN)
				return G.iface_exists;
			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);
		}
	}

	return G.iface_exists;
}

static NOINLINE int netlink_open(void)
{
	int fd;
	struct sockaddr_nl addr;

	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));

	return fd;
}

#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;
#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(_PATH_VARRUN"ifplugd.%s.pid", G.iface);
	pid_from_pidfile = read_pid(pidfile_name);

	if (opts & FLAG_KILL) {
		if (pid_from_pidfile > 0)
			kill(pid_from_pidfile, SIGQUIT);
		return EXIT_SUCCESS;
	}

	if (pid_from_pidfile > 0 && kill(pid_from_pidfile, 0) == 0)
		bb_error_msg_and_die("daemon already running");
#endif

	switch (G.api_mode[0]) {
	case API_AUTO:
		G.detect_link_func = detect_link_auto;
		break;
	case API_ETHTOOL:
		G.detect_link_func = detect_link_ethtool;
		break;
	case API_MII:
		G.detect_link_func = detect_link_mii;
		break;
	case API_PRIVATE:
		G.detect_link_func = detect_link_priv;
		break;
	case API_WLAN:
		G.detect_link_func = detect_link_wlan;
		break;
	case API_IFF:
		G.detect_link_func = detect_link_iff;
		break;
	default:
		bb_error_msg_and_die("unknown API mode '%s'", G.api_mode);
	}

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