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