struct event_socket {
struct uloop_fd uloop;
struct nl_sock *sock;
+ int bufsize;
};
static int sock_ioctl = -1;
handler_nl_event(struct uloop_fd *u, unsigned int events)
{
struct event_socket *ev = container_of(u, struct event_socket, uloop);
- nl_recvmsgs_default(ev->sock);
+ int err;
+ socklen_t errlen = sizeof(err);
+
+ if (!u->error) {
+ nl_recvmsgs_default(ev->sock);
+ return;
+ }
+
+ if (getsockopt(u->fd, SOL_SOCKET, SO_ERROR, (void *)&err, &errlen))
+ goto abort;
+
+ switch(err) {
+ case ENOBUFS:
+ // Increase rx buffer size on netlink socket
+ ev->bufsize *= 2;
+ if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
+ goto abort;
+
+ // Request full dump since some info got dropped
+ struct rtgenmsg msg = { .rtgen_family = AF_UNSPEC };
+ nl_send_simple(ev->sock, RTM_GETLINK, NLM_F_DUMP, &msg, sizeof(msg));
+ break;
+
+ default:
+ goto abort;
+ }
+ u->error = false;
+ return;
+
+abort:
+ uloop_fd_delete(&ev->uloop);
+ return;
}
static struct nl_sock *
static bool
create_raw_event_socket(struct event_socket *ev, int protocol, int groups,
- uloop_fd_handler cb)
+ uloop_fd_handler cb, int flags)
{
ev->sock = create_socket(protocol, groups);
if (!ev->sock)
ev->uloop.fd = nl_socket_get_fd(ev->sock);
ev->uloop.cb = cb;
- if (uloop_fd_add(&ev->uloop, ULOOP_READ))
+ if (uloop_fd_add(&ev->uloop, ULOOP_READ|flags))
return false;
return true;
create_event_socket(struct event_socket *ev, int protocol,
int (*cb)(struct nl_msg *msg, void *arg))
{
- if (!create_raw_event_socket(ev, protocol, 0, handler_nl_event))
+ if (!create_raw_event_socket(ev, protocol, 0, handler_nl_event, ULOOP_ERROR_CB))
return false;
// Install the valid custom callback handler
nl_socket_disable_seq_check(ev->sock);
// Increase rx buffer size to 65K on event sockets
- if (nl_socket_set_buffer_size(ev->sock, 65535, 0))
+ ev->bufsize = 65535;
+ if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
return false;
return true;
return -1;
if (!create_raw_event_socket(&hotplug_event, NETLINK_KOBJECT_UEVENT, 1,
- handle_hotplug_event))
+ handle_hotplug_event, 0))
return -1;
// Receive network link events form kernel
if (fd < 0)
return;
- write(fd, val, strlen(val));
+ if (write(fd, val, strlen(val))) {}
close(fd);
}
system_set_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6", dev->ifname, val);
}
+static int system_get_sysctl(const char *path, char *buf, const size_t buf_sz)
+{
+ int fd = -1, ret = -1;
+
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ goto out;
+
+ ssize_t len = read(fd, buf, buf_sz - 1);
+ if (len < 0)
+ goto out;
+
+ ret = buf[len] = 0;
+
+out:
+ if (fd >= 0)
+ close(fd);
+
+ return ret;
+}
+
+static int
+system_get_dev_sysctl(const char *path, const char *device, char *buf, const size_t buf_sz)
+{
+ snprintf(dev_buf, sizeof(dev_buf), path, device);
+ return system_get_sysctl(dev_buf, buf, buf_sz);
+}
+
+static int system_get_disable_ipv6(struct device *dev, char *buf, const size_t buf_sz)
+{
+ return system_get_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6",
+ dev->ifname, buf, buf_sz);
+}
+
#ifndef IFF_LOWER_UP
#define IFF_LOWER_UP 0x10000
#endif
{
char *oldbr;
- system_set_disable_ipv6(dev, "1");
oldbr = system_get_bridge(dev->ifname, dev_buf, sizeof(dev_buf));
if (oldbr && !strcmp(oldbr, bridge->ifname))
return 0;
int system_bridge_delif(struct device *bridge, struct device *dev)
{
- system_set_disable_ipv6(dev, "0");
return system_bridge_if(bridge->ifname, dev, SIOCBRDELIF, NULL);
}
hdr->nlmsg_type = type;
hdr->nlmsg_flags = NLM_F_REQUEST;
- if (!nl_send_auto_complete(sock_rtnl, clr->msg))
- nl_wait_for_ack(sock_rtnl);
+ nl_socket_disable_auto_ack(sock_rtnl);
+ nl_send_auto_complete(sock_rtnl, clr->msg);
+ nl_socket_enable_auto_ack(sock_rtnl);
return NL_SKIP;
}
static char buf[256];
char *bridge;
- if (dev->external)
- return;
-
device_set_ifindex(dev, system_if_resolve(dev));
- if (!dev->ifindex)
+ if (dev->external || !dev->ifindex)
return;
system_if_flags(dev->ifname, 0, IFF_UP);
system_if_get_settings(struct device *dev, struct device_settings *s)
{
struct ifreq ifr;
+ char buf[10];
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
s->flags |= DEV_OPT_MACADDR;
}
+
+ if (!system_get_disable_ipv6(dev, buf, sizeof(buf))) {
+ s->ipv6 = !strtoul(buf, NULL, 0);
+ s->flags |= DEV_OPT_IPV6;
+ }
}
void
-system_if_apply_settings(struct device *dev, struct device_settings *s)
+system_if_apply_settings(struct device *dev, struct device_settings *s, unsigned int apply_mask)
{
struct ifreq ifr;
+ if (!apply_mask)
+ return;
+
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
- if (s->flags & DEV_OPT_MTU) {
+ if (s->flags & DEV_OPT_MTU & apply_mask) {
ifr.ifr_mtu = s->mtu;
if (ioctl(sock_ioctl, SIOCSIFMTU, &ifr) < 0)
s->flags &= ~DEV_OPT_MTU;
}
- if (s->flags & DEV_OPT_TXQUEUELEN) {
+ if (s->flags & DEV_OPT_TXQUEUELEN & apply_mask) {
ifr.ifr_qlen = s->txqueuelen;
if (ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr) < 0)
s->flags &= ~DEV_OPT_TXQUEUELEN;
}
- if ((s->flags & DEV_OPT_MACADDR) && !dev->external) {
+ if ((s->flags & DEV_OPT_MACADDR & apply_mask) && !dev->external) {
ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
memcpy(&ifr.ifr_hwaddr.sa_data, s->macaddr, sizeof(s->macaddr));
if (ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr) < 0)
s->flags &= ~DEV_OPT_MACADDR;
}
+ if (s->flags & DEV_OPT_IPV6 & apply_mask)
+ system_set_disable_ipv6(dev, s->ipv6 ? "0" : "1");
}
int system_if_up(struct device *dev)
{
system_if_get_settings(dev, &dev->orig_settings);
- system_if_apply_settings(dev, &dev->settings);
+ system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
device_set_ifindex(dev, system_if_resolve(dev));
return system_if_flags(dev->ifname, IFF_UP, 0);
}
{
int ret = system_if_flags(dev->ifname, 0, IFF_UP);
dev->orig_settings.flags &= dev->settings.flags;
- system_if_apply_settings(dev, &dev->orig_settings);
+ system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags);
return ret;
}
struct rtmsg rtm = {
.rtm_family = (alen == 4) ? AF_INET : AF_INET6,
.rtm_dst_len = route->mask,
+ .rtm_src_len = route->sourcemask,
.rtm_table = (table < 256) ? table : RT_TABLE_UNSPEC,
.rtm_protocol = (route->flags & DEVADDR_KERNEL) ? RTPROT_KERNEL : RTPROT_STATIC,
.rtm_scope = scope,
.rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
+ .rtm_flags = (route->flags & DEVROUTE_ONLINK) ? RTNH_F_ONLINK : 0,
};
struct nl_msg *msg;
if (route->mask)
nla_put(msg, RTA_DST, alen, &route->addr);
+ if (route->sourcemask)
+ nla_put(msg, RTA_SRC, alen, &route->source);
+
if (route->metric > 0)
nla_put_u32(msg, RTA_PRIORITY, route->metric);
if (table >= 256)
nla_put_u32(msg, RTA_TABLE, table);
+ if (route->flags & DEVROUTE_MTU) {
+ struct nlattr *metrics;
+
+ if (!(metrics = nla_nest_start(msg, RTA_METRICS)))
+ goto nla_put_failure;
+
+ nla_put_u32(msg, RTAX_MTU, route->mtu);
+
+ nla_nest_end(msg, metrics);
+ }
+
return system_rtnl_call(msg);
+
+nla_put_failure:
+ nlmsg_free(msg);
+ return -ENOMEM;
}
int system_add_route(struct device *dev, struct device_route *route)
if (fd < 0)
continue;
- write(fd, "-1", 2);
+ if (write(fd, "-1", 2)) {}
close(fd);
}
return 0;
}
#endif
} else if (!strcmp(str, "ipip6")) {
- struct ip6_tnl_parm p = {
- .link = link,
- .proto = IPPROTO_IPIP,
- .hop_limit = (ttl) ? ttl : 64,
- .encap_limit = 4,
- };
+ struct nl_msg *nlm = nlmsg_alloc_simple(RTM_NEWLINK,
+ NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE);
- if ((cur = tb[TUNNEL_ATTR_LOCAL]) &&
- inet_pton(AF_INET6, blobmsg_data(cur), &p.laddr) < 1)
- return -EINVAL;
+ struct ifinfomsg ifi = { .ifi_family = AF_UNSPEC };
+ nlmsg_append(nlm, &ifi, sizeof(ifi), 0);
+ nla_put_string(nlm, IFLA_IFNAME, name);
- if ((cur = tb[TUNNEL_ATTR_REMOTE]) &&
- inet_pton(AF_INET6, blobmsg_data(cur), &p.raddr) < 1)
- return -EINVAL;
+ if (link)
+ nla_put_u32(nlm, IFLA_LINK, link);
- strncpy(p.name, name, sizeof(p.name));
- if (tunnel_ioctl("ip6tnl0", SIOCADDTUNNEL, &p) < 0)
- return -1;
+ struct nlattr *linkinfo = nla_nest_start(nlm, IFLA_LINKINFO);
+ nla_put_string(nlm, IFLA_INFO_KIND, "ip6tnl");
+ struct nlattr *infodata = nla_nest_start(nlm, IFLA_INFO_DATA);
+
+ if (link)
+ nla_put_u32(nlm, IFLA_IPTUN_LINK, link);
+
+ nla_put_u8(nlm, IFLA_IPTUN_PROTO, IPPROTO_IPIP);
+ nla_put_u8(nlm, IFLA_IPTUN_TTL, (ttl) ? ttl : 64);
+ nla_put_u8(nlm, IFLA_IPTUN_ENCAP_LIMIT, 4);
+
+ struct in6_addr in6buf;
+ if ((cur = tb[TUNNEL_ATTR_LOCAL])) {
+ if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1)
+ return -EINVAL;
+ nla_put(nlm, IFLA_IPTUN_LOCAL, sizeof(in6buf), &in6buf);
+ }
+
+ if ((cur = tb[TUNNEL_ATTR_REMOTE])) {
+ if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1)
+ return -EINVAL;
+ nla_put(nlm, IFLA_IPTUN_REMOTE, sizeof(in6buf), &in6buf);
+ }
+
+#ifdef IFLA_IPTUN_FMR_MAX
+ if ((cur = tb[TUNNEL_ATTR_FMRS])) {
+ struct nlattr *fmrs = nla_nest_start(nlm, IFLA_IPTUN_FMRS);
+
+ struct blob_attr *fmr;
+ unsigned rem, fmrcnt = 0;
+ blobmsg_for_each_attr(fmr, cur, rem) {
+ if (blobmsg_type(fmr) != BLOBMSG_TYPE_STRING)
+ continue;
+
+ unsigned ip4len, ip6len, ealen, offset = 6;
+ char ip6buf[48];
+ char ip4buf[16];
+
+ if (sscanf(blobmsg_get_string(fmr), "%47[^/]/%u,%15[^/]/%u,%u,%u",
+ ip6buf, &ip6len, ip4buf, &ip4len, &ealen, &offset) < 5)
+ return -EINVAL;
+
+ struct in6_addr ip6prefix;
+ struct in_addr ip4prefix;
+ if (inet_pton(AF_INET6, ip6buf, &ip6prefix) != 1 ||
+ inet_pton(AF_INET, ip4buf, &ip4prefix) != 1)
+ return -EINVAL;
+
+ struct nlattr *rule = nla_nest_start(nlm, ++fmrcnt);
+
+ nla_put(nlm, IFLA_IPTUN_FMR_IP6_PREFIX, sizeof(ip6prefix), &ip6prefix);
+ nla_put(nlm, IFLA_IPTUN_FMR_IP4_PREFIX, sizeof(ip4prefix), &ip4prefix);
+ nla_put_u8(nlm, IFLA_IPTUN_FMR_IP6_PREFIX_LEN, ip6len);
+ nla_put_u8(nlm, IFLA_IPTUN_FMR_IP4_PREFIX_LEN, ip4len);
+ nla_put_u8(nlm, IFLA_IPTUN_FMR_EA_LEN, ealen);
+ nla_put_u8(nlm, IFLA_IPTUN_FMR_OFFSET, offset);
+
+ nla_nest_end(nlm, rule);
+ }
+
+ nla_nest_end(nlm, fmrs);
+ }
+#endif
+
+ nla_nest_end(nlm, infodata);
+ nla_nest_end(nlm, linkinfo);
+
+ return system_rtnl_call(nlm);
} else
return -EINVAL;
projects / project / netifd.git / blobdiff