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