system-linux.c

   1 #include <sys/socket.h>
   2 #include <sys/ioctl.h>
   3
   4 #include <linux/rtnetlink.h>
   5 #include <linux/sockios.h>
   6 #include <linux/if_vlan.h>
   7
   8 #include <string.h>
   9 #include <fcntl.h>
  10
  11 #include <netlink/msg.h>
  12 #include <netlink/attr.h>
  13 #include <netlink/socket.h>
  14 #include <libubox/uloop.h>
  15
  16 #include "netifd.h"
  17 #include "device.h"
  18 #include "system.h"
  19
  20 static int sock_ioctl = -1;
  21 static struct nl_sock *sock_rtnl = NULL;
  22 static struct nl_sock *sock_rtnl_event = NULL;
  23
  24 static void handler_rtnl_event(struct uloop_fd *u, unsigned int events);
  25 static int cb_rtnl_event(struct nl_msg *msg, void *arg);
  26 static struct uloop_fd rtnl_event = {.cb = handler_rtnl_event};
  27 static struct nl_cb *nl_cb_rtnl_event;
  28
  29 int system_init(void)
  30 {
  31         sock_ioctl = socket(AF_LOCAL, SOCK_DGRAM, 0);
  32         fcntl(sock_ioctl, F_SETFD, fcntl(sock_ioctl, F_GETFD) | FD_CLOEXEC);
  33
  34         // Prepare socket for routing / address control
  35         sock_rtnl = nl_socket_alloc();
  36         if (!sock_rtnl)
  37                 return -1;
  38
  39         if (nl_connect(sock_rtnl, NETLINK_ROUTE))
  40                 goto error_free_sock;
  41
  42         // Prepare socket for link events
  43         nl_cb_rtnl_event = nl_cb_alloc(NL_CB_DEFAULT);
  44         if (!nl_cb_rtnl_event)
  45                 goto error_free_sock;
  46
  47         nl_cb_set(nl_cb_rtnl_event, NL_CB_VALID, NL_CB_CUSTOM,
  48                   cb_rtnl_event, NULL);
  49
  50         sock_rtnl_event = nl_socket_alloc();
  51         if (!sock_rtnl_event)
  52                 goto error_free_cb;
  53
  54         if (nl_connect(sock_rtnl_event, NETLINK_ROUTE))
  55                 goto error_free_event;
  56
  57         // Receive network link events form kernel
  58         nl_socket_add_membership(sock_rtnl_event, RTNLGRP_LINK);
  59
  60         rtnl_event.fd = nl_socket_get_fd(sock_rtnl_event);
  61         uloop_fd_add(&rtnl_event, ULOOP_READ | ULOOP_EDGE_TRIGGER);
  62
  63         return -(sock_ioctl < 0 || !sock_rtnl);
  64
  65 error_free_event:
  66         nl_socket_free(sock_rtnl_event);
  67         sock_rtnl_event = NULL;
  68 error_free_cb:
  69         nl_cb_put(nl_cb_rtnl_event);
  70         nl_cb_rtnl_event = NULL;
  71 error_free_sock:
  72         nl_socket_free(sock_rtnl);
  73         sock_rtnl = NULL;
  74         return -1;
  75 }
  76
  77 // If socket is ready for reading parse netlink events
  78 static void handler_rtnl_event(struct uloop_fd *u, unsigned int events)
  79 {
  80         nl_recvmsgs(sock_rtnl_event, nl_cb_rtnl_event);
  81 }
  82
  83 // Evaluate netlink messages
  84 static int cb_rtnl_event(struct nl_msg *msg, void *arg)
  85 {
  86         struct nlmsghdr *nh = nlmsg_hdr(msg);
  87         struct ifinfomsg *ifi = NLMSG_DATA(nh);
  88         struct nlattr *nla[__IFLA_MAX];
  89
  90         if (nh->nlmsg_type != RTM_DELLINK && nh->nlmsg_type != RTM_NEWLINK)
  91                 goto out;
  92
  93         nlmsg_parse(nh, sizeof(*ifi), nla, __IFLA_MAX - 1, NULL);
  94         if (!nla[IFLA_IFNAME])
  95                 goto out;
  96
  97         struct device *dev = device_get(RTA_DATA(nla[IFLA_IFNAME]), false);
  98         if (!dev)
  99                 goto out;
 100
 101         dev->ifindex = ifi->ifi_index;
 102         device_set_present(dev, (nh->nlmsg_type == RTM_NEWLINK));
 103
 104 out:
 105         return 0;
 106 }
 107
 108 static int system_rtnl_call(struct nl_msg *msg)
 109 {
 110         int s = -(nl_send_auto_complete(sock_rtnl, msg)
 111                         || nl_wait_for_ack(sock_rtnl));
 112         nlmsg_free(msg);
 113         return s;
 114 }
 115
 116 int system_bridge_addbr(struct device *bridge)
 117 {
 118         return ioctl(sock_ioctl, SIOCBRADDBR, bridge->ifname);
 119 }
 120
 121 int system_bridge_delbr(struct device *bridge)
 122 {
 123         return ioctl(sock_ioctl, SIOCBRDELBR, bridge->ifname);
 124 }
 125
 126 static int system_bridge_if(struct device *bridge, struct device *dev, int cmd)
 127 {
 128         struct ifreq ifr;
 129         ifr.ifr_ifindex = dev->ifindex;
 130         strncpy(ifr.ifr_name, bridge->ifname, sizeof(ifr.ifr_name));
 131         return ioctl(sock_ioctl, cmd, &ifr);
 132 }
 133
 134 int system_bridge_addif(struct device *bridge, struct device *dev)
 135 {
 136         return system_bridge_if(bridge, dev, SIOCBRADDIF);
 137 }
 138
 139 int system_bridge_delif(struct device *bridge, struct device *dev)
 140 {
 141         return system_bridge_if(bridge, dev, SIOCBRDELIF);
 142 }
 143
 144 static int system_vlan(struct device *dev, int id)
 145 {
 146         struct vlan_ioctl_args ifr = {
 147                 .cmd = (id == 0) ? DEL_VLAN_CMD : ADD_VLAN_CMD,
 148                 .u = {.VID = id},
 149         };
 150         strncpy(ifr.device1, dev->ifname, sizeof(ifr.device1));
 151         return ioctl(sock_ioctl, SIOCSIFVLAN, &ifr);
 152 }
 153
 154 int system_vlan_add(struct device *dev, int id)
 155 {
 156         return system_vlan(dev, id);
 157 }
 158
 159 int system_vlan_del(struct device *dev)
 160 {
 161         return system_vlan(dev, 0);
 162 }
 163
 164 static int system_if_flags(struct device *dev, unsigned add, unsigned rem)
 165 {
 166         struct ifreq ifr;
 167         strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
 168         ioctl(sock_ioctl, SIOCGIFFLAGS, &ifr);
 169         ifr.ifr_flags |= add;
 170         ifr.ifr_flags &= ~rem;
 171         return ioctl(sock_ioctl, SIOCSIFFLAGS, &ifr);
 172 }
 173
 174 static int system_if_resolve(struct device *dev)
 175 {
 176         struct ifreq ifr;
 177         strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
 178         if (!ioctl(sock_ioctl, SIOCGIFINDEX, &ifr))
 179                 return ifr.ifr_ifindex;
 180         else
 181                 return 0;
 182 }
 183
 184 int system_if_up(struct device *dev)
 185 {
 186         dev->ifindex = system_if_resolve(dev);
 187         return system_if_flags(dev, IFF_UP, 0);
 188 }
 189
 190 int system_if_down(struct device *dev)
 191 {
 192         return system_if_flags(dev, 0, IFF_UP);
 193 }
 194
 195 int system_if_check(struct device *dev)
 196 {
 197         device_set_present(dev, (system_if_resolve(dev) >= 0));
 198         return 0;
 199 }
 200
 201 static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 202 {
 203         int alen = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
 204         struct ifaddrmsg ifa = {
 205                 .ifa_family = (alen == 4) ? AF_INET : AF_INET6,
 206                 .ifa_prefixlen = addr->mask,
 207                 .ifa_index = dev->ifindex,
 208         };
 209
 210         struct nl_msg *msg = nlmsg_alloc_simple(cmd, 0);
 211         if (!msg)
 212                 return -1;
 213
 214         nlmsg_append(msg, &ifa, sizeof(ifa), 0);
 215         nla_put(msg, IFA_LOCAL, alen, &addr->addr);
 216         return system_rtnl_call(msg);
 217 }
 218
 219 int system_add_address(struct device *dev, struct device_addr *addr)
 220 {
 221         return system_addr(dev, addr, RTM_NEWADDR);
 222 }
 223
 224 int system_del_address(struct device *dev, struct device_addr *addr)
 225 {
 226         return system_addr(dev, addr, RTM_DELADDR);
 227 }
 228
 229 static int system_rt(struct device *dev, struct device_route *route, int cmd)
 230 {
 231         int alen = ((route->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
 232         bool have_gw;
 233
 234         if (alen == 4)
 235                 have_gw = !!route->nexthop.in.s_addr;
 236         else
 237                 have_gw = route->nexthop.in6.s6_addr32[0] ||
 238                         route->nexthop.in6.s6_addr32[1] ||
 239                         route->nexthop.in6.s6_addr32[2] ||
 240                         route->nexthop.in6.s6_addr32[3];
 241
 242         unsigned char scope = (cmd == RTM_DELROUTE) ? RT_SCOPE_NOWHERE :
 243                         (have_gw) ? RT_SCOPE_UNIVERSE : RT_SCOPE_LINK;
 244
 245         struct rtmsg rtm = {
 246                 .rtm_family = (alen == 4) ? AF_INET : AF_INET6,
 247                 .rtm_dst_len = route->mask,
 248                 .rtm_table = RT_TABLE_MAIN,
 249                 .rtm_protocol = RTPROT_BOOT,
 250                 .rtm_scope = scope,
 251                 .rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
 252         };
 253
 254         struct nl_msg *msg = nlmsg_alloc_simple(cmd, 0);
 255         if (!msg)
 256                 return -1;
 257
 258         nlmsg_append(msg, &rtm, sizeof(rtm), 0);
 259
 260         if (route->mask)
 261                 nla_put(msg, RTA_DST, alen, &route->addr);
 262
 263         if (have_gw)
 264                 nla_put(msg, RTA_GATEWAY, alen, &route->nexthop);
 265
 266         if (route->flags & DEVADDR_DEVICE)
 267                 nla_put_u32(msg, RTA_OIF, dev->ifindex);
 268
 269         return system_rtnl_call(msg);
 270 }
 271
 272 int system_add_route(struct device *dev, struct device_route *route)
 273 {
 274         return system_rt(dev, route, RTM_NEWROUTE);
 275 }
 276
 277 int system_del_route(struct device *dev, struct device_route *route)
 278 {
 279         return system_rt(dev, route, RTM_DELROUTE);
 280 }