system-linux.c

   1 #define _GNU_SOURCE
   2
   3 #include <sys/socket.h>
   4 #include <sys/ioctl.h>
   5 #include <sys/stat.h>
   6 #include <sys/syscall.h>
   7
   8 #include <linux/rtnetlink.h>
   9 #include <linux/sockios.h>
  10 #include <linux/if_vlan.h>
  11 #include <linux/if_bridge.h>
  12 #include <linux/ethtool.h>
  13 #include <net/if_arp.h>
  14
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <fcntl.h>
  18 #include <glob.h>
  19 #include <time.h>
  20
  21 #include <netlink/msg.h>
  22 #include <netlink/attr.h>
  23 #include <netlink/socket.h>
  24 #include <libubox/uloop.h>
  25
  26 #include "netifd.h"
  27 #include "device.h"
  28 #include "system.h"
  29
  30 struct event_socket {
  31         struct uloop_fd uloop;
  32         struct nl_sock *sock;
  33         struct nl_cb *cb;
  34 };
  35
  36 static int sock_ioctl = -1;
  37 static struct nl_sock *sock_rtnl = NULL;
  38
  39 static int cb_rtnl_event(struct nl_msg *msg, void *arg);
  40 static void handle_hotplug_event(struct uloop_fd *u, unsigned int events);
  41
  42 static void
  43 handler_nl_event(struct uloop_fd *u, unsigned int events)
  44 {
  45         struct event_socket *ev = container_of(u, struct event_socket, uloop);
  46         nl_recvmsgs(ev->sock, ev->cb);
  47 }
  48
  49 static struct nl_sock *
  50 create_socket(int protocol, int groups)
  51 {
  52         struct nl_sock *sock;
  53
  54         sock = nl_socket_alloc();
  55         if (!sock)
  56                 return NULL;
  57
  58         if (groups)
  59                 nl_join_groups(sock, groups);
  60
  61         if (nl_connect(sock, protocol))
  62                 return NULL;
  63
  64         return sock;
  65 }
  66
  67 static bool
  68 create_raw_event_socket(struct event_socket *ev, int protocol, int groups,
  69                         uloop_fd_handler cb)
  70 {
  71         ev->sock = create_socket(protocol, groups);
  72         if (!ev->sock)
  73                 return false;
  74
  75         ev->uloop.fd = nl_socket_get_fd(ev->sock);
  76         ev->uloop.cb = cb;
  77         uloop_fd_add(&ev->uloop, ULOOP_READ | ULOOP_EDGE_TRIGGER);
  78         return true;
  79 }
  80
  81 static bool
  82 create_event_socket(struct event_socket *ev, int protocol,
  83                     int (*cb)(struct nl_msg *msg, void *arg))
  84 {
  85         // Prepare socket for link events
  86         ev->cb = nl_cb_alloc(NL_CB_DEFAULT);
  87         if (!ev->cb)
  88                 return false;
  89
  90         nl_cb_set(ev->cb, NL_CB_VALID, NL_CB_CUSTOM, cb, NULL);
  91
  92         return create_raw_event_socket(ev, protocol, 0, handler_nl_event);
  93 }
  94
  95 int system_init(void)
  96 {
  97         static struct event_socket rtnl_event;
  98         static struct event_socket hotplug_event;
  99
 100         sock_ioctl = socket(AF_LOCAL, SOCK_DGRAM, 0);
 101         fcntl(sock_ioctl, F_SETFD, fcntl(sock_ioctl, F_GETFD) | FD_CLOEXEC);
 102
 103         // Prepare socket for routing / address control
 104         sock_rtnl = create_socket(NETLINK_ROUTE, 0);
 105         if (!sock_rtnl)
 106                 return -1;
 107
 108         if (!create_event_socket(&rtnl_event, NETLINK_ROUTE, cb_rtnl_event))
 109                 return -1;
 110
 111         if (!create_raw_event_socket(&hotplug_event, NETLINK_KOBJECT_UEVENT, 1,
 112                                      handle_hotplug_event))
 113                 return -1;
 114
 115         // Receive network link events form kernel
 116         nl_socket_add_membership(rtnl_event.sock, RTNLGRP_LINK);
 117
 118         return 0;
 119 }
 120
 121 static void system_set_sysctl(const char *path, const char *val)
 122 {
 123         int fd;
 124
 125         fd = open(path, O_WRONLY);
 126         if (fd < 0)
 127                 return;
 128
 129         write(fd, val, strlen(val));
 130         close(fd);
 131 }
 132
 133 static void system_set_dev_sysctl(const char *path, const char *device, const char *val)
 134 {
 135         static char buf[256];
 136
 137         snprintf(buf, sizeof(buf), path, val);
 138         system_set_sysctl(buf, val);
 139 }
 140
 141 static void system_set_disable_ipv6(struct device *dev, const char *val)
 142 {
 143         system_set_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6", dev->ifname, val);
 144 }
 145
 146 // Evaluate netlink messages
 147 static int cb_rtnl_event(struct nl_msg *msg, void *arg)
 148 {
 149         struct nlmsghdr *nh = nlmsg_hdr(msg);
 150         struct ifinfomsg *ifi = NLMSG_DATA(nh);
 151         struct nlattr *nla[__IFLA_MAX];
 152
 153         if (nh->nlmsg_type != RTM_DELLINK && nh->nlmsg_type != RTM_NEWLINK)
 154                 goto out;
 155
 156         nlmsg_parse(nh, sizeof(*ifi), nla, __IFLA_MAX - 1, NULL);
 157         if (!nla[IFLA_IFNAME])
 158                 goto out;
 159
 160         struct device *dev = device_get(RTA_DATA(nla[IFLA_IFNAME]), false);
 161         if (!dev)
 162                 goto out;
 163
 164         dev->ifindex = ifi->ifi_index;
 165         /* TODO: parse link status */
 166
 167 out:
 168         return 0;
 169 }
 170
 171 static void
 172 handle_hotplug_msg(char *data, int size)
 173 {
 174         const char *subsystem = NULL, *interface = NULL;
 175         char *cur, *end, *sep;
 176         struct device *dev;
 177         int skip;
 178         bool add;
 179
 180         if (!strncmp(data, "add@", 4))
 181                 add = true;
 182         else if (!strncmp(data, "remove@", 7))
 183                 add = false;
 184         else
 185                 return;
 186
 187         skip = strlen(data) + 1;
 188         end = data + size;
 189
 190         for (cur = data + skip; cur < end; cur += skip) {
 191                 skip = strlen(cur) + 1;
 192
 193                 sep = strchr(cur, '=');
 194                 if (!sep)
 195                         continue;
 196
 197                 *sep = 0;
 198                 if (!strcmp(cur, "INTERFACE"))
 199                         interface = sep + 1;
 200                 else if (!strcmp(cur, "SUBSYSTEM")) {
 201                         subsystem = sep + 1;
 202                         if (strcmp(subsystem, "net") != 0)
 203                                 return;
 204                 }
 205                 if (subsystem && interface)
 206                         goto found;
 207         }
 208         return;
 209
 210 found:
 211         dev = device_get(interface, false);
 212         if (!dev)
 213                 return;
 214
 215         if (dev->type != &simple_device_type)
 216                 return;
 217
 218         device_set_present(dev, add);
 219 }
 220
 221 static void
 222 handle_hotplug_event(struct uloop_fd *u, unsigned int events)
 223 {
 224         struct event_socket *ev = container_of(u, struct event_socket, uloop);
 225         struct sockaddr_nl nla;
 226         unsigned char *buf = NULL;
 227         int size;
 228
 229         while ((size = nl_recv(ev->sock, &nla, &buf, NULL)) > 0) {
 230                 if (nla.nl_pid == 0)
 231                         handle_hotplug_msg((char *) buf, size);
 232
 233                 free(buf);
 234         }
 235 }
 236
 237 static int system_rtnl_call(struct nl_msg *msg)
 238 {
 239         int s = -(nl_send_auto_complete(sock_rtnl, msg)
 240                         || nl_wait_for_ack(sock_rtnl));
 241         nlmsg_free(msg);
 242         return s;
 243 }
 244
 245 int system_bridge_delbr(struct device *bridge)
 246 {
 247         return ioctl(sock_ioctl, SIOCBRDELBR, bridge->ifname);
 248 }
 249
 250 static int system_bridge_if(const char *bridge, struct device *dev, int cmd, void *data)
 251 {
 252         struct ifreq ifr;
 253         if (dev)
 254                 ifr.ifr_ifindex = dev->ifindex;
 255         else
 256                 ifr.ifr_data = data;
 257         strncpy(ifr.ifr_name, bridge, sizeof(ifr.ifr_name));
 258         return ioctl(sock_ioctl, cmd, &ifr);
 259 }
 260
 261 int system_bridge_addif(struct device *bridge, struct device *dev)
 262 {
 263         system_set_disable_ipv6(dev, "1");
 264         return system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
 265 }
 266
 267 int system_bridge_delif(struct device *bridge, struct device *dev)
 268 {
 269         system_set_disable_ipv6(dev, "0");
 270         return system_bridge_if(bridge->ifname, dev, SIOCBRDELIF, NULL);
 271 }
 272
 273 static bool system_is_bridge(const char *name, char *buf, int buflen)
 274 {
 275         struct stat st;
 276
 277         snprintf(buf, buflen, "/sys/devices/virtual/net/%s/bridge", name);
 278         if (stat(buf, &st) < 0)
 279                 return false;
 280
 281         return true;
 282 }
 283
 284 static char *system_get_bridge(const char *name, char *buf, int buflen)
 285 {
 286         char *path;
 287         ssize_t len;
 288         glob_t gl;
 289
 290         snprintf(buf, buflen, "/sys/devices/virtual/net/*/brif/%s/bridge", name);
 291         if (glob(buf, GLOB_NOSORT, NULL, &gl) < 0)
 292                 return NULL;
 293
 294         if (gl.gl_pathc == 0)
 295                 return NULL;
 296
 297         len = readlink(gl.gl_pathv[0], buf, buflen);
 298         if (len < 0)
 299                 return NULL;
 300
 301         buf[len] = 0;
 302         path = strrchr(buf, '/');
 303         if (!path)
 304                 return NULL;
 305
 306         return path + 1;
 307 }
 308
 309 static int system_if_resolve(struct device *dev)
 310 {
 311         struct ifreq ifr;
 312         strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
 313         if (!ioctl(sock_ioctl, SIOCGIFINDEX, &ifr))
 314                 return ifr.ifr_ifindex;
 315         else
 316                 return 0;
 317 }
 318
 319 static int system_if_flags(const char *ifname, unsigned add, unsigned rem)
 320 {
 321         struct ifreq ifr;
 322         strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 323         ioctl(sock_ioctl, SIOCGIFFLAGS, &ifr);
 324         ifr.ifr_flags |= add;
 325         ifr.ifr_flags &= ~rem;
 326         return ioctl(sock_ioctl, SIOCSIFFLAGS, &ifr);
 327 }
 328
 329 struct clear_data {
 330         struct nl_msg *msg;
 331         struct device *dev;
 332         int type;
 333         int size;
 334         int af;
 335 };
 336
 337
 338 static bool check_ifaddr(struct nlmsghdr *hdr, int ifindex)
 339 {
 340         struct ifaddrmsg *ifa = NLMSG_DATA(hdr);
 341
 342         return ifa->ifa_index == ifindex;
 343 }
 344
 345 static bool check_route(struct nlmsghdr *hdr, int ifindex)
 346 {
 347         struct nlattr *tb[__RTA_MAX];
 348
 349         nlmsg_parse(hdr, sizeof(struct rtmsg), tb, __RTA_MAX - 1, NULL);
 350         if (!tb[RTA_OIF])
 351                 return false;
 352
 353         return *(int *)RTA_DATA(tb[RTA_OIF]) == ifindex;
 354 }
 355
 356 static int cb_clear_event(struct nl_msg *msg, void *arg)
 357 {
 358         struct clear_data *clr = arg;
 359         struct nlmsghdr *hdr = nlmsg_hdr(msg);
 360         bool (*cb)(struct nlmsghdr *, int ifindex);
 361         int type;
 362
 363         switch(clr->type) {
 364         case RTM_GETADDR:
 365                 type = RTM_DELADDR;
 366                 if (hdr->nlmsg_type != RTM_NEWADDR)
 367                         return NL_SKIP;
 368
 369                 cb = check_ifaddr;
 370                 break;
 371         case RTM_GETROUTE:
 372                 type = RTM_DELROUTE;
 373                 if (hdr->nlmsg_type != RTM_NEWROUTE)
 374                         return NL_SKIP;
 375
 376                 cb = check_route;
 377                 break;
 378         default:
 379                 return NL_SKIP;
 380         }
 381
 382         if (!cb(hdr, clr->dev->ifindex))
 383                 return NL_SKIP;
 384
 385         D(SYSTEM, "Remove %s from device %s\n",
 386           type == RTM_DELADDR ? "an address" : "a route",
 387           clr->dev->ifname);
 388         memcpy(nlmsg_hdr(clr->msg), hdr, hdr->nlmsg_len);
 389         hdr = nlmsg_hdr(clr->msg);
 390         hdr->nlmsg_type = type;
 391         hdr->nlmsg_flags = NLM_F_REQUEST;
 392
 393         if (!nl_send_auto_complete(sock_rtnl, clr->msg))
 394                 nl_wait_for_ack(sock_rtnl);
 395
 396         return NL_SKIP;
 397 }
 398
 399 static int
 400 cb_finish_event(struct nl_msg *msg, void *arg)
 401 {
 402         int *pending = arg;
 403         *pending = 0;
 404         return NL_STOP;
 405 }
 406
 407 static int
 408 error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
 409 {
 410         int *pending = arg;
 411         *pending = err->error;
 412         return NL_STOP;
 413 }
 414
 415 static void
 416 system_if_clear_entries(struct device *dev, int type, int af)
 417 {
 418         struct clear_data clr;
 419         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
 420         struct rtmsg rtm = {
 421                 .rtm_family = af,
 422                 .rtm_flags = RTM_F_CLONED,
 423         };
 424         int flags = NLM_F_DUMP;
 425         int pending = 1;
 426
 427         clr.af = af;
 428         clr.dev = dev;
 429         clr.type = type;
 430         switch (type) {
 431         case RTM_GETADDR:
 432                 clr.size = sizeof(struct rtgenmsg);
 433                 break;
 434         case RTM_GETROUTE:
 435                 clr.size = sizeof(struct rtmsg);
 436                 break;
 437         default:
 438                 return;
 439         }
 440
 441         if (!cb)
 442                 return;
 443
 444         clr.msg = nlmsg_alloc_simple(type, flags);
 445         if (!clr.msg)
 446                 goto out;
 447
 448         nlmsg_append(clr.msg, &rtm, clr.size, 0);
 449         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_clear_event, &clr);
 450         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_finish_event, &pending);
 451         nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &pending);
 452
 453         nl_send_auto_complete(sock_rtnl, clr.msg);
 454         while (pending > 0)
 455                 nl_recvmsgs(sock_rtnl, cb);
 456
 457         nlmsg_free(clr.msg);
 458 out:
 459         nl_cb_put(cb);
 460 }
 461
 462 /*
 463  * Clear bridge (membership) state and bring down device
 464  */
 465 void system_if_clear_state(struct device *dev)
 466 {
 467         static char buf[256];
 468         char *bridge;
 469
 470         if (dev->external)
 471                 return;
 472
 473         dev->ifindex = system_if_resolve(dev);
 474         if (!dev->ifindex)
 475                 return;
 476
 477         system_if_flags(dev->ifname, 0, IFF_UP);
 478
 479         if (system_is_bridge(dev->ifname, buf, sizeof(buf))) {
 480                 D(SYSTEM, "Delete existing bridge named '%s'\n", dev->ifname);
 481                 system_bridge_delbr(dev);
 482                 return;
 483         }
 484
 485         bridge = system_get_bridge(dev->ifname, buf, sizeof(buf));
 486         if (bridge) {
 487                 D(SYSTEM, "Remove device '%s' from bridge '%s'\n", dev->ifname, bridge);
 488                 system_bridge_if(bridge, dev, SIOCBRDELIF, NULL);
 489         }
 490
 491         system_if_clear_entries(dev, RTM_GETROUTE, AF_INET);
 492         system_if_clear_entries(dev, RTM_GETADDR, AF_INET);
 493         system_if_clear_entries(dev, RTM_GETROUTE, AF_INET6);
 494         system_if_clear_entries(dev, RTM_GETADDR, AF_INET6);
 495         system_set_disable_ipv6(dev, "0");
 496 }
 497
 498 static inline unsigned long
 499 sec_to_jiffies(int val)
 500 {
 501         return (unsigned long) val * 100;
 502 }
 503
 504 int system_bridge_addbr(struct device *bridge, struct bridge_config *cfg)
 505 {
 506         unsigned long args[4] = {};
 507
 508         if (ioctl(sock_ioctl, SIOCBRADDBR, bridge->ifname) < 0)
 509                 return -1;
 510
 511         args[0] = BRCTL_SET_BRIDGE_STP_STATE;
 512         args[1] = !!cfg->stp;
 513         system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
 514
 515         args[0] = BRCTL_SET_BRIDGE_FORWARD_DELAY;
 516         args[1] = sec_to_jiffies(cfg->forward_delay);
 517         system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
 518
 519         system_set_dev_sysctl("/sys/devices/virtual/net/%s/bridge/multicast_snooping",
 520                 bridge->ifname, cfg->igmp_snoop ? "1" : "0");
 521
 522         if (cfg->flags & BRIDGE_OPT_AGEING_TIME) {
 523                 args[0] = BRCTL_SET_AGEING_TIME;
 524                 args[1] = sec_to_jiffies(cfg->ageing_time);
 525                 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
 526         }
 527
 528         if (cfg->flags & BRIDGE_OPT_HELLO_TIME) {
 529                 args[0] = BRCTL_SET_BRIDGE_HELLO_TIME;
 530                 args[1] = sec_to_jiffies(cfg->hello_time);
 531                 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
 532         }
 533
 534         if (cfg->flags & BRIDGE_OPT_MAX_AGE) {
 535                 args[0] = BRCTL_SET_BRIDGE_MAX_AGE;
 536                 args[1] = sec_to_jiffies(cfg->max_age);
 537                 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
 538         }
 539
 540         return 0;
 541 }
 542
 543 static int system_vlan(struct device *dev, int id)
 544 {
 545         struct vlan_ioctl_args ifr = {
 546                 .cmd = SET_VLAN_NAME_TYPE_CMD,
 547                 .u.name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD,
 548         };
 549
 550         ioctl(sock_ioctl, SIOCSIFVLAN, &ifr);
 551
 552         if (id < 0) {
 553                 ifr.cmd = DEL_VLAN_CMD;
 554                 ifr.u.VID = 0;
 555         } else {
 556                 ifr.cmd = ADD_VLAN_CMD;
 557                 ifr.u.VID = id;
 558         }
 559         strncpy(ifr.device1, dev->ifname, sizeof(ifr.device1));
 560         return ioctl(sock_ioctl, SIOCSIFVLAN, &ifr);
 561 }
 562
 563 int system_vlan_add(struct device *dev, int id)
 564 {
 565         return system_vlan(dev, id);
 566 }
 567
 568 int system_vlan_del(struct device *dev)
 569 {
 570         return system_vlan(dev, -1);
 571 }
 572
 573 static void
 574 system_if_get_settings(struct device *dev, struct device_settings *s)
 575 {
 576         struct ifreq ifr;
 577
 578         memset(&ifr, 0, sizeof(ifr));
 579         strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
 580
 581         if (ioctl(sock_ioctl, SIOCGIFMTU, &ifr) == 0) {
 582                 s->mtu = ifr.ifr_mtu;
 583                 s->flags |= DEV_OPT_MTU;
 584         }
 585
 586         if (ioctl(sock_ioctl, SIOCGIFTXQLEN, &ifr) == 0) {
 587                 s->txqueuelen = ifr.ifr_qlen;
 588                 s->flags |= DEV_OPT_TXQUEUELEN;
 589         }
 590
 591         if (ioctl(sock_ioctl, SIOCGIFHWADDR, &ifr) == 0) {
 592                 memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
 593                 s->flags |= DEV_OPT_MACADDR;
 594         }
 595 }
 596
 597 static void
 598 system_if_apply_settings(struct device *dev, struct device_settings *s)
 599 {
 600         struct ifreq ifr;
 601
 602         memset(&ifr, 0, sizeof(ifr));
 603         strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
 604         if (s->flags & DEV_OPT_MTU) {
 605                 ifr.ifr_mtu = s->mtu;
 606                 if (ioctl(sock_ioctl, SIOCSIFMTU, &ifr) < 0)
 607                         s->flags &= ~DEV_OPT_MTU;
 608         }
 609         if (s->flags & DEV_OPT_TXQUEUELEN) {
 610                 ifr.ifr_qlen = s->txqueuelen;
 611                 if (ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr) < 0)
 612                         s->flags &= ~DEV_OPT_TXQUEUELEN;
 613         }
 614         if (s->flags & DEV_OPT_MACADDR) {
 615                 ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
 616                 memcpy(&ifr.ifr_hwaddr.sa_data, s->macaddr, sizeof(s->macaddr));
 617                 if (ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr) < 0)
 618                         s->flags &= ~DEV_OPT_MACADDR;
 619         }
 620 }
 621
 622 int system_if_up(struct device *dev)
 623 {
 624         system_if_get_settings(dev, &dev->orig_settings);
 625         system_if_apply_settings(dev, &dev->settings);
 626         dev->ifindex = system_if_resolve(dev);
 627         return system_if_flags(dev->ifname, IFF_UP, 0);
 628 }
 629
 630 int system_if_down(struct device *dev)
 631 {
 632         int ret = system_if_flags(dev->ifname, 0, IFF_UP);
 633         dev->orig_settings.flags &= dev->settings.flags;
 634         system_if_apply_settings(dev, &dev->orig_settings);
 635         return ret;
 636 }
 637
 638 int system_if_check(struct device *dev)
 639 {
 640         device_set_present(dev, (system_if_resolve(dev) > 0));
 641         return 0;
 642 }
 643
 644 struct device *
 645 system_if_get_parent(struct device *dev)
 646 {
 647         char buf[64], *devname;
 648         int ifindex, iflink, len;
 649         FILE *f;
 650
 651         snprintf(buf, sizeof(buf), "/sys/class/net/%s/iflink", dev->ifname);
 652         f = fopen(buf, "r");
 653         if (!f)
 654                 return NULL;
 655
 656         len = fread(buf, 1, sizeof(buf) - 1, f);
 657         fclose(f);
 658
 659         if (len <= 0)
 660                 return NULL;
 661
 662         buf[len] = 0;
 663         iflink = strtoul(buf, NULL, 0);
 664         ifindex = system_if_resolve(dev);
 665         if (!iflink || iflink == ifindex)
 666                 return NULL;
 667
 668         devname = if_indextoname(iflink, buf);
 669         if (!devname)
 670                 return NULL;
 671
 672         return device_get(devname, true);
 673 }
 674
 675 static bool
 676 read_string_file(int dir_fd, const char *file, char *buf, int len)
 677 {
 678         bool ret = false;
 679         char *c;
 680         int fd;
 681
 682         fd = openat(dir_fd, file, O_RDONLY);
 683         if (fd < 0)
 684                 return false;
 685
 686 retry:
 687         len = read(fd, buf, len - 1);
 688         if (len < 0) {
 689                 if (errno == EINTR)
 690                         goto retry;
 691         } else if (len > 0) {
 692                         buf[len] = 0;
 693
 694                         c = strchr(buf, '\n');
 695                         if (c)
 696                                 *c = 0;
 697
 698                         ret = true;
 699         }
 700
 701         close(fd);
 702
 703         return ret;
 704 }
 705
 706 static bool
 707 read_int_file(int dir_fd, const char *file, int *val)
 708 {
 709         char buf[64];
 710         bool ret = false;
 711
 712         ret = read_string_file(dir_fd, file, buf, sizeof(buf));
 713         if (ret)
 714                 *val = strtoul(buf, NULL, 0);
 715
 716         return ret;
 717 }
 718
 719 /* Assume advertised flags == supported flags */
 720 static const struct {
 721         uint32_t mask;
 722         const char *name;
 723 } ethtool_link_modes[] = {
 724         { ADVERTISED_10baseT_Half, "10H" },
 725         { ADVERTISED_10baseT_Full, "10F" },
 726         { ADVERTISED_100baseT_Half, "100H" },
 727         { ADVERTISED_100baseT_Full, "100F" },
 728         { ADVERTISED_1000baseT_Half, "1000H" },
 729         { ADVERTISED_1000baseT_Full, "1000F" },
 730 };
 731
 732 static void system_add_link_modes(struct blob_buf *b, __u32 mask)
 733 {
 734         int i;
 735         for (i = 0; i < ARRAY_SIZE(ethtool_link_modes); i++) {
 736                 if (mask & ethtool_link_modes[i].mask)
 737                         blobmsg_add_string(b, NULL, ethtool_link_modes[i].name);
 738         }
 739 }
 740
 741 int
 742 system_if_dump_info(struct device *dev, struct blob_buf *b)
 743 {
 744         struct ethtool_cmd ecmd;
 745         struct ifreq ifr;
 746         char buf[64], *s;
 747         void *c;
 748         int dir_fd, val = 0;
 749
 750         snprintf(buf, sizeof(buf), "/sys/class/net/%s", dev->ifname);
 751         dir_fd = open(buf, O_DIRECTORY);
 752
 753         if (read_int_file(dir_fd, "carrier", &val))
 754                 blobmsg_add_u8(b, "link", !!val);
 755
 756         memset(&ecmd, 0, sizeof(ecmd));
 757         memset(&ifr, 0, sizeof(ifr));
 758         strcpy(ifr.ifr_name, dev->ifname);
 759         ifr.ifr_data = (caddr_t) &ecmd;
 760         ecmd.cmd = ETHTOOL_GSET;
 761
 762         if (ioctl(sock_ioctl, SIOCETHTOOL, &ifr) == 0) {
 763                 c = blobmsg_open_array(b, "link-advertising");
 764                 system_add_link_modes(b, ecmd.advertising);
 765                 blobmsg_close_array(b, c);
 766
 767                 c = blobmsg_open_array(b, "link-supported");
 768                 system_add_link_modes(b, ecmd.supported);
 769                 blobmsg_close_array(b, c);
 770
 771                 s = blobmsg_alloc_string_buffer(b, "speed", 8);
 772                 snprintf(s, 8, "%d%c", ethtool_cmd_speed(&ecmd),
 773                         ecmd.duplex == DUPLEX_HALF ? 'H' : 'F');
 774                 blobmsg_add_string_buffer(b);
 775         }
 776
 777         close(dir_fd);
 778         return 0;
 779 }
 780
 781 int
 782 system_if_dump_stats(struct device *dev, struct blob_buf *b)
 783 {
 784         const char *const counters[] = {
 785                 "collisions",     "rx_frame_errors",   "tx_compressed",
 786                 "multicast",      "rx_length_errors",  "tx_dropped",
 787                 "rx_bytes",       "rx_missed_errors",  "tx_errors",
 788                 "rx_compressed",  "rx_over_errors",    "tx_fifo_errors",
 789                 "rx_crc_errors",  "rx_packets",        "tx_heartbeat_errors",
 790                 "rx_dropped",     "tx_aborted_errors", "tx_packets",
 791                 "rx_errors",      "tx_bytes",          "tx_window_errors",
 792                 "rx_fifo_errors", "tx_carrier_errors",
 793         };
 794         char buf[64];
 795         int stats_dir;
 796         int i, val = 0;
 797
 798         snprintf(buf, sizeof(buf), "/sys/class/net/%s/statistics", dev->ifname);
 799         stats_dir = open(buf, O_DIRECTORY);
 800         if (stats_dir < 0)
 801                 return -1;
 802
 803         for (i = 0; i < ARRAY_SIZE(counters); i++)
 804                 if (read_int_file(stats_dir, counters[i], &val))
 805                         blobmsg_add_u32(b, counters[i], val);
 806
 807         close(stats_dir);
 808         return 0;
 809 }
 810
 811 static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 812 {
 813         bool v4 = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4);
 814         int alen = v4 ? 4 : 16;
 815         struct ifaddrmsg ifa = {
 816                 .ifa_family = (alen == 4) ? AF_INET : AF_INET6,
 817                 .ifa_prefixlen = addr->mask,
 818                 .ifa_index = dev->ifindex,
 819         };
 820
 821         struct nl_msg *msg;
 822
 823         msg = nlmsg_alloc_simple(cmd, 0);
 824         if (!msg)
 825                 return -1;
 826
 827         nlmsg_append(msg, &ifa, sizeof(ifa), 0);
 828         nla_put(msg, IFA_LOCAL, alen, &addr->addr);
 829         if (v4)
 830                 nla_put_u32(msg, IFA_BROADCAST, addr->broadcast);
 831
 832         return system_rtnl_call(msg);
 833 }
 834
 835 int system_add_address(struct device *dev, struct device_addr *addr)
 836 {
 837         return system_addr(dev, addr, RTM_NEWADDR);
 838 }
 839
 840 int system_del_address(struct device *dev, struct device_addr *addr)
 841 {
 842         return system_addr(dev, addr, RTM_DELADDR);
 843 }
 844
 845 static int system_rt(struct device *dev, struct device_route *route, int cmd)
 846 {
 847         int alen = ((route->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
 848         bool have_gw;
 849         unsigned int flags = 0;
 850         int ifindex = dev->ifindex;
 851
 852         if (alen == 4)
 853                 have_gw = !!route->nexthop.in.s_addr;
 854         else
 855                 have_gw = route->nexthop.in6.s6_addr32[0] ||
 856                         route->nexthop.in6.s6_addr32[1] ||
 857                         route->nexthop.in6.s6_addr32[2] ||
 858                         route->nexthop.in6.s6_addr32[3];
 859
 860         unsigned char scope = (cmd == RTM_DELROUTE) ? RT_SCOPE_NOWHERE :
 861                         (have_gw) ? RT_SCOPE_UNIVERSE : RT_SCOPE_LINK;
 862
 863         struct rtmsg rtm = {
 864                 .rtm_family = (alen == 4) ? AF_INET : AF_INET6,
 865                 .rtm_dst_len = route->mask,
 866                 .rtm_table = RT_TABLE_MAIN,
 867                 .rtm_protocol = RTPROT_BOOT,
 868                 .rtm_scope = scope,
 869                 .rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
 870         };
 871         struct nl_msg *msg;
 872
 873         if (cmd == RTM_NEWROUTE)
 874                 flags |= NLM_F_CREATE | NLM_F_REPLACE;
 875
 876         msg = nlmsg_alloc_simple(cmd, flags);
 877         if (!msg)
 878                 return -1;
 879
 880         nlmsg_append(msg, &rtm, sizeof(rtm), 0);
 881
 882         if (route->mask)
 883                 nla_put(msg, RTA_DST, alen, &route->addr);
 884
 885         if (route->metric >= 0)
 886                 nla_put_u32(msg, RTA_PRIORITY, route->metric);
 887
 888         if (have_gw)
 889                 nla_put(msg, RTA_GATEWAY, alen, &route->nexthop);
 890
 891         if (route->flags & DEVADDR_DEVICE)
 892                 nla_put_u32(msg, RTA_OIF, ifindex);
 893
 894         return system_rtnl_call(msg);
 895 }
 896
 897 int system_add_route(struct device *dev, struct device_route *route)
 898 {
 899         return system_rt(dev, route, RTM_NEWROUTE);
 900 }
 901
 902 int system_del_route(struct device *dev, struct device_route *route)
 903 {
 904         return system_rt(dev, route, RTM_DELROUTE);
 905 }
 906
 907 int system_flush_routes(void)
 908 {
 909         const char *names[] = {
 910                 "/proc/sys/net/ipv4/route/flush",
 911                 "/proc/sys/net/ipv6/route/flush"
 912         };
 913         int fd, i;
 914
 915         for (i = 0; i < ARRAY_SIZE(names); i++) {
 916                 fd = open(names[i], O_WRONLY);
 917                 if (fd < 0)
 918                         continue;
 919
 920                 write(fd, "-1", 2);
 921                 close(fd);
 922         }
 923         return 0;
 924 }
 925
 926 time_t system_get_rtime(void)
 927 {
 928         struct timespec ts;
 929         struct timeval tv;
 930
 931         if (syscall(__NR_clock_gettime, CLOCK_MONOTONIC, &ts) == 0)
 932                 return ts.tv_sec;
 933
 934         if (gettimeofday(&tv, NULL) == 0)
 935                 return tv.tv_sec;
 936
 937         return 0;
 938 }