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