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