+ if (ioctl(sock_ioctl, SIOCGIFHWADDR, &ifr) == 0) {
+ memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
+ s->flags |= DEV_OPT_MACADDR;
+ }
+
+ if (!system_get_disable_ipv6(dev, buf, sizeof(buf))) {
+ s->ipv6 = !strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_IPV6;
+ }
+
+ if (ioctl(sock_ioctl, SIOCGIFFLAGS, &ifr) == 0) {
+ s->promisc = ifr.ifr_flags & IFF_PROMISC;
+ s->flags |= DEV_OPT_PROMISC;
+ }
+
+ if (!system_get_rpfilter(dev, buf, sizeof(buf))) {
+ s->rpfilter = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_RPFILTER;
+ }
+
+ if (!system_get_acceptlocal(dev, buf, sizeof(buf))) {
+ s->acceptlocal = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_ACCEPTLOCAL;
+ }
+
+ if (!system_get_igmpversion(dev, buf, sizeof(buf))) {
+ s->igmpversion = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_IGMPVERSION;
+ }
+
+ if (!system_get_mldversion(dev, buf, sizeof(buf))) {
+ s->mldversion = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_MLDVERSION;
+ }
+
+ if (!system_get_neigh4reachabletime(dev, buf, sizeof(buf))) {
+ s->neigh4reachabletime = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_NEIGHREACHABLETIME;
+ }
+
+ if (!system_get_neigh6reachabletime(dev, buf, sizeof(buf))) {
+ s->neigh6reachabletime = strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_NEIGHREACHABLETIME;
+ }
+}
+
+static void
+system_if_set_rps_xps_val(const char *path, int val)
+{
+ char val_buf[8];
+ glob_t gl;
+ int i;
+
+ if (glob(path, 0, NULL, &gl))
+ return;
+
+ snprintf(val_buf, sizeof(val_buf), "%x", val);
+ for (i = 0; i < gl.gl_pathc; i++)
+ system_set_sysctl(gl.gl_pathv[i], val_buf);
+}
+
+static void
+system_if_apply_rps_xps(struct device *dev, struct device_settings *s)
+{
+ long n_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+ int val;
+
+ if (n_cpus < 2)
+ return;
+
+ val = (1 << n_cpus) - 1;
+ snprintf(dev_buf, sizeof(dev_buf), "/sys/class/net/%s/queues/*/rps_cpus", dev->ifname);
+ system_if_set_rps_xps_val(dev_buf, s->rps ? val : 0);
+
+ snprintf(dev_buf, sizeof(dev_buf), "/sys/class/net/%s/queues/*/xps_cpus", dev->ifname);
+ system_if_set_rps_xps_val(dev_buf, s->xps ? val : 0);
+}
+
+void
+system_if_apply_settings(struct device *dev, struct device_settings *s, unsigned int apply_mask)
+{
+ struct ifreq ifr;
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
+ if (s->flags & DEV_OPT_MTU & apply_mask) {
+ ifr.ifr_mtu = s->mtu;
+ if (ioctl(sock_ioctl, SIOCSIFMTU, &ifr) < 0)
+ s->flags &= ~DEV_OPT_MTU;
+ }
+ if (s->flags & DEV_OPT_TXQUEUELEN & apply_mask) {
+ ifr.ifr_qlen = s->txqueuelen;
+ if (ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr) < 0)
+ s->flags &= ~DEV_OPT_TXQUEUELEN;
+ }
+ if ((s->flags & DEV_OPT_MACADDR & apply_mask) && !dev->external) {
+ ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
+ memcpy(&ifr.ifr_hwaddr.sa_data, s->macaddr, sizeof(s->macaddr));
+ if (ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr) < 0)
+ s->flags &= ~DEV_OPT_MACADDR;
+ }
+ if (s->flags & DEV_OPT_IPV6 & apply_mask)
+ system_set_disable_ipv6(dev, s->ipv6 ? "0" : "1");
+ if (s->flags & DEV_OPT_PROMISC & apply_mask) {
+ if (system_if_flags(dev->ifname, s->promisc ? IFF_PROMISC : 0,
+ !s->promisc ? IFF_PROMISC : 0) < 0)
+ s->flags &= ~DEV_OPT_PROMISC;
+ }
+ if (s->flags & DEV_OPT_RPFILTER & apply_mask) {
+ char buf[2];
+
+ snprintf(buf, sizeof(buf), "%d", s->rpfilter);
+ system_set_rpfilter(dev, buf);
+ }
+ if (s->flags & DEV_OPT_ACCEPTLOCAL & apply_mask)
+ system_set_acceptlocal(dev, s->acceptlocal ? "1" : "0");
+ if (s->flags & DEV_OPT_IGMPVERSION & apply_mask) {
+ char buf[2];
+
+ snprintf(buf, sizeof(buf), "%d", s->igmpversion);
+ system_set_igmpversion(dev, buf);
+ }
+ if (s->flags & DEV_OPT_MLDVERSION & apply_mask) {
+ char buf[2];
+
+ snprintf(buf, sizeof(buf), "%d", s->mldversion);
+ system_set_mldversion(dev, buf);
+ }
+ if (s->flags & DEV_OPT_NEIGHREACHABLETIME & apply_mask) {
+ char buf[12];
+
+ snprintf(buf, sizeof(buf), "%d", s->neigh4reachabletime);
+ system_set_neigh4reachabletime(dev, buf);
+ snprintf(buf, sizeof(buf), "%d", s->neigh6reachabletime);
+ system_set_neigh6reachabletime(dev, buf);
+ }
+
+ system_if_apply_rps_xps(dev, s);
+}
+
+int system_if_up(struct device *dev)
+{
+ system_if_get_settings(dev, &dev->orig_settings);
+ /* Only keep orig settings based on what needs to be set */
+ dev->orig_settings.flags &= dev->settings.flags;
+ system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
+ return system_if_flags(dev->ifname, IFF_UP, 0);
+}
+
+int system_if_down(struct device *dev)
+{
+ int ret = system_if_flags(dev->ifname, 0, IFF_UP);
+ system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags);
+ return ret;
+}
+
+struct if_check_data {
+ struct device *dev;
+ int pending;
+ int ret;
+};
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+static int cb_if_check_valid(struct nl_msg *msg, void *arg)
+{
+ struct nlmsghdr *nh = nlmsg_hdr(msg);
+ struct ifinfomsg *ifi = NLMSG_DATA(nh);
+ struct if_check_data *chk = (struct if_check_data *)arg;
+
+ if (nh->nlmsg_type != RTM_NEWLINK)
+ return NL_SKIP;
+
+ device_set_present(chk->dev, ifi->ifi_index > 0 ? true : false);
+ device_set_link(chk->dev, ifi->ifi_flags & IFF_LOWER_UP ? true : false);
+
+ return NL_OK;
+}
+
+static int cb_if_check_ack(struct nl_msg *msg, void *arg)
+{
+ struct if_check_data *chk = (struct if_check_data *)arg;
+ chk->pending = 0;
+ return NL_STOP;
+}
+
+static int cb_if_check_error(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
+{
+ struct if_check_data *chk = (struct if_check_data *)arg;
+
+ device_set_present(chk->dev, false);
+ device_set_link(chk->dev, false);
+ chk->pending = err->error;
+
+ return NL_STOP;
+}
+
+int system_if_check(struct device *dev)
+{
+ struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
+ struct nl_msg *msg;
+ struct ifinfomsg ifi = {
+ .ifi_family = AF_UNSPEC,
+ .ifi_index = 0,
+ };
+ struct if_check_data chk = {
+ .dev = dev,
+ .pending = 1,
+ };
+ int ret = 1;
+
+ msg = nlmsg_alloc_simple(RTM_GETLINK, 0);
+ if (!msg || nlmsg_append(msg, &ifi, sizeof(ifi), 0) ||
+ nla_put_string(msg, IFLA_IFNAME, dev->ifname))
+ goto out;
+
+ nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_if_check_valid, &chk);
+ nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, cb_if_check_ack, &chk);
+ nl_cb_err(cb, NL_CB_CUSTOM, cb_if_check_error, &chk);
+
+ nl_send_auto_complete(sock_rtnl, msg);
+ while (chk.pending > 0)
+ nl_recvmsgs(sock_rtnl, cb);
+
+ nlmsg_free(msg);
+ ret = chk.pending;
+
+out:
+ nl_cb_put(cb);
+ return ret;
+}
+
+struct device *
+system_if_get_parent(struct device *dev)
+{
+ char buf[64], *devname;
+ int ifindex, iflink, len;
+ FILE *f;
+
+ snprintf(buf, sizeof(buf), "/sys/class/net/%s/iflink", dev->ifname);
+ f = fopen(buf, "r");
+ if (!f)
+ return NULL;
+
+ len = fread(buf, 1, sizeof(buf) - 1, f);
+ fclose(f);
+
+ if (len <= 0)
+ return NULL;
+
+ buf[len] = 0;
+ iflink = strtoul(buf, NULL, 0);
+ ifindex = system_if_resolve(dev);
+ if (!iflink || iflink == ifindex)
+ return NULL;
+
+ devname = if_indextoname(iflink, buf);
+ if (!devname)
+ return NULL;
+
+ return device_get(devname, true);
+}
+
+static bool
+read_string_file(int dir_fd, const char *file, char *buf, int len)
+{
+ bool ret = false;
+ char *c;
+ int fd;
+
+ fd = openat(dir_fd, file, O_RDONLY);
+ if (fd < 0)
+ return false;
+
+retry:
+ len = read(fd, buf, len - 1);
+ if (len < 0) {
+ if (errno == EINTR)
+ goto retry;
+ } else if (len > 0) {
+ buf[len] = 0;
+
+ c = strchr(buf, '\n');
+ if (c)
+ *c = 0;
+
+ ret = true;
+ }
+
+ close(fd);
+
+ return ret;
+}
+
+static bool
+read_uint64_file(int dir_fd, const char *file, uint64_t *val)
+{
+ char buf[64];
+ bool ret = false;
+
+ ret = read_string_file(dir_fd, file, buf, sizeof(buf));
+ if (ret)
+ *val = strtoull(buf, NULL, 0);
+
+ return ret;
+}
+
+/* Assume advertised flags == supported flags */
+static const struct {
+ uint32_t mask;
+ const char *name;
+} ethtool_link_modes[] = {
+ { ADVERTISED_10baseT_Half, "10H" },
+ { ADVERTISED_10baseT_Full, "10F" },
+ { ADVERTISED_100baseT_Half, "100H" },
+ { ADVERTISED_100baseT_Full, "100F" },
+ { ADVERTISED_1000baseT_Half, "1000H" },
+ { ADVERTISED_1000baseT_Full, "1000F" },
+};
+
+static void system_add_link_modes(struct blob_buf *b, __u32 mask)
+{
+ int i;
+ for (i = 0; i < ARRAY_SIZE(ethtool_link_modes); i++) {
+ if (mask & ethtool_link_modes[i].mask)
+ blobmsg_add_string(b, NULL, ethtool_link_modes[i].name);
+ }
+}
+
+bool
+system_if_force_external(const char *ifname)
+{
+ char buf[64];
+ struct stat s;
+
+ snprintf(buf, sizeof(buf), "/sys/class/net/%s/phy80211", ifname);
+ return stat(buf, &s) == 0;
+}
+
+int
+system_if_dump_info(struct device *dev, struct blob_buf *b)
+{
+ struct ethtool_cmd ecmd;
+ struct ifreq ifr;
+ char buf[64], *s;
+ void *c;
+ int dir_fd;
+
+ snprintf(buf, sizeof(buf), "/sys/class/net/%s", dev->ifname);
+ dir_fd = open(buf, O_DIRECTORY);
+
+ memset(&ecmd, 0, sizeof(ecmd));
+ memset(&ifr, 0, sizeof(ifr));
+ strcpy(ifr.ifr_name, dev->ifname);
+ ifr.ifr_data = (caddr_t) &ecmd;
+ ecmd.cmd = ETHTOOL_GSET;
+
+ if (ioctl(sock_ioctl, SIOCETHTOOL, &ifr) == 0) {
+ c = blobmsg_open_array(b, "link-advertising");
+ system_add_link_modes(b, ecmd.advertising);
+ blobmsg_close_array(b, c);
+
+ c = blobmsg_open_array(b, "link-supported");
+ system_add_link_modes(b, ecmd.supported);
+ blobmsg_close_array(b, c);
+
+ s = blobmsg_alloc_string_buffer(b, "speed", 8);
+ snprintf(s, 8, "%d%c", ethtool_cmd_speed(&ecmd),
+ ecmd.duplex == DUPLEX_HALF ? 'H' : 'F');
+ blobmsg_add_string_buffer(b);
+ }
+
+ close(dir_fd);
+ return 0;
+}
+
+int
+system_if_dump_stats(struct device *dev, struct blob_buf *b)
+{
+ const char *const counters[] = {
+ "collisions", "rx_frame_errors", "tx_compressed",
+ "multicast", "rx_length_errors", "tx_dropped",
+ "rx_bytes", "rx_missed_errors", "tx_errors",
+ "rx_compressed", "rx_over_errors", "tx_fifo_errors",
+ "rx_crc_errors", "rx_packets", "tx_heartbeat_errors",
+ "rx_dropped", "tx_aborted_errors", "tx_packets",
+ "rx_errors", "tx_bytes", "tx_window_errors",
+ "rx_fifo_errors", "tx_carrier_errors",
+ };
+ char buf[64];
+ int stats_dir;
+ int i;
+ uint64_t val = 0;
+
+ snprintf(buf, sizeof(buf), "/sys/class/net/%s/statistics", dev->ifname);
+ stats_dir = open(buf, O_DIRECTORY);
+ if (stats_dir < 0)
+ return -1;
+
+ for (i = 0; i < ARRAY_SIZE(counters); i++)
+ if (read_uint64_file(stats_dir, counters[i], &val))
+ blobmsg_add_u64(b, counters[i], val);
+
+ close(stats_dir);
+ return 0;
+}
+
+static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
+{
+ bool v4 = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4);
+ int alen = v4 ? 4 : 16;
+ unsigned int flags = 0;
+ struct ifaddrmsg ifa = {
+ .ifa_family = (alen == 4) ? AF_INET : AF_INET6,
+ .ifa_prefixlen = addr->mask,
+ .ifa_index = dev->ifindex,
+ };
+
+ struct nl_msg *msg;
+ if (cmd == RTM_NEWADDR)
+ flags |= NLM_F_CREATE | NLM_F_REPLACE;
+
+ msg = nlmsg_alloc_simple(cmd, flags);
+ if (!msg)