interface-ip.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <unistd.h>
   5
   6 #include <arpa/inet.h>
   7
   8 #include "netifd.h"
   9 #include "device.h"
  10 #include "interface.h"
  11 #include "interface-ip.h"
  12 #include "proto.h"
  13 #include "ubus.h"
  14 #include "system.h"
  15
  16 static int
  17 addr_cmp(const void *k1, const void *k2, void *ptr)
  18 {
  19         return memcmp(k1, k2, sizeof(struct device_addr) -
  20                       offsetof(struct device_addr, mask));
  21 }
  22
  23 static int
  24 route_cmp(const void *k1, const void *k2, void *ptr)
  25 {
  26         return memcmp(k1, k2, sizeof(struct device_route) -
  27                       offsetof(struct device_route, mask));
  28 }
  29
  30 static void
  31 interface_update_proto_addr(struct vlist_tree *tree,
  32                             struct vlist_node *node_new,
  33                             struct vlist_node *node_old)
  34 {
  35         struct interface_ip_settings *ip;
  36         struct interface *iface;
  37         struct device *dev;
  38         struct device_addr *addr;
  39
  40         ip = container_of(tree, struct interface_ip_settings, addr);
  41         iface = ip->iface;
  42         dev = iface->l3_dev->dev;
  43
  44         if (node_old) {
  45                 addr = container_of(node_old, struct device_addr, node);
  46                 if (!(addr->flags & DEVADDR_EXTERNAL))
  47                         system_del_address(dev, addr);
  48                 free(addr);
  49         }
  50
  51         if (node_new) {
  52                 addr = container_of(node_new, struct device_addr, node);
  53                 if (!(addr->flags & DEVADDR_EXTERNAL))
  54                         system_add_address(dev, addr);
  55         }
  56 }
  57
  58 static void
  59 interface_update_proto_route(struct vlist_tree *tree,
  60                              struct vlist_node *node_new,
  61                              struct vlist_node *node_old)
  62 {
  63         struct interface_ip_settings *ip;
  64         struct interface *iface;
  65         struct device *dev;
  66         struct device_route *route;
  67
  68         ip = container_of(tree, struct interface_ip_settings, route);
  69         iface = ip->iface;
  70         dev = iface->l3_dev->dev;
  71
  72         if (node_old) {
  73                 route = container_of(node_old, struct device_route, node);
  74                 if (!(route->flags & DEVADDR_EXTERNAL))
  75                         system_del_route(dev, route);
  76                 free(route);
  77         }
  78
  79         if (node_new) {
  80                 route = container_of(node_new, struct device_route, node);
  81                 if (!(route->flags & DEVADDR_EXTERNAL))
  82                         system_add_route(dev, route);
  83         }
  84 }
  85
  86 void
  87 interface_add_dns_server(struct interface_ip_settings *ip, const char *str)
  88 {
  89         struct dns_server *s;
  90
  91         s = calloc(1, sizeof(*s));
  92         s->af = AF_INET;
  93         if (inet_pton(s->af, str, &s->addr.in))
  94                 goto add;
  95
  96         s->af = AF_INET6;
  97         if (inet_pton(s->af, str, &s->addr.in))
  98                 goto add;
  99
 100         free(s);
 101         return;
 102
 103 add:
 104         D(INTERFACE, "Add IPv%c DNS server: %s\n",
 105           s->af == AF_INET6 ? '6' : '4', str);
 106         list_add_tail(&s->list, &ip->dns_servers);
 107 }
 108
 109 void
 110 interface_add_dns_server_list(struct interface_ip_settings *ip, struct blob_attr *list)
 111 {
 112         struct blob_attr *cur;
 113         int rem;
 114
 115         blobmsg_for_each_attr(cur, list, rem) {
 116                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 117                         continue;
 118
 119                 if (!blobmsg_check_attr(cur, NULL))
 120                         continue;
 121
 122                 interface_add_dns_server(ip, blobmsg_data(cur));
 123         }
 124 }
 125
 126 void
 127 interface_add_dns_search_domain(struct interface_ip_settings *ip, const char *str)
 128 {
 129         struct dns_search_domain *s;
 130         int len = strlen(str);
 131
 132         s = calloc(1, sizeof(*s) + len + 1);
 133         if (!s)
 134                 return;
 135
 136         D(INTERFACE, "Add DNS search domain: %s\n", str);
 137         memcpy(s->name, str, len);
 138         list_add_tail(&s->list, &ip->dns_search);
 139 }
 140
 141 void
 142 interface_add_dns_search_list(struct interface_ip_settings *ip, struct blob_attr *list)
 143 {
 144         struct blob_attr *cur;
 145         int rem;
 146
 147         blobmsg_for_each_attr(cur, list, rem) {
 148                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 149                         continue;
 150
 151                 if (!blobmsg_check_attr(cur, NULL))
 152                         continue;
 153
 154                 interface_add_dns_server(ip, blobmsg_data(cur));
 155         }
 156 }
 157
 158 static void
 159 interface_clear_dns_servers(struct interface_ip_settings *ip)
 160 {
 161         struct dns_server *s, *tmp;
 162
 163         list_for_each_entry_safe(s, tmp, &ip->dns_servers, list) {
 164                 list_del(&s->list);
 165                 free(s);
 166         }
 167 }
 168
 169 static void
 170 interface_clear_dns_search(struct interface_ip_settings *ip)
 171 {
 172         struct dns_search_domain *s, *tmp;
 173
 174         list_for_each_entry_safe(s, tmp, &ip->dns_search, list) {
 175                 list_del(&s->list);
 176                 free(s);
 177         }
 178 }
 179
 180 void
 181 interface_write_resolv_conf(void)
 182 {
 183         struct interface *iface;
 184         struct dns_server *s;
 185         struct dns_search_domain *d;
 186         char *path = alloca(strlen(resolv_conf) + 5);
 187         const char *str;
 188         char buf[32];
 189         FILE *f;
 190
 191         sprintf(path, "%s.tmp", resolv_conf);
 192         unlink(path);
 193         f = fopen(path, "w");
 194         if (!f) {
 195                 D(INTERFACE, "Failed to open %s for writing\n", path);
 196                 return;
 197         }
 198
 199         vlist_for_each_element(&interfaces, iface, node) {
 200                 if (iface->state != IFS_UP)
 201                         continue;
 202
 203                 if (list_empty(&iface->proto_ip.dns_search) &&
 204                     list_empty(&iface->proto_ip.dns_servers))
 205                         continue;
 206
 207                 fprintf(f, "# Interface %s\n", iface->name);
 208                 list_for_each_entry(s, &iface->proto_ip.dns_servers, list) {
 209                         str = inet_ntop(s->af, &s->addr, buf, sizeof(buf));
 210                         if (!str)
 211                                 continue;
 212
 213                         fprintf(f, "nameserver %s\n", str);
 214                 }
 215
 216                 list_for_each_entry(d, &iface->proto_ip.dns_search, list) {
 217                         fprintf(f, "search %s\n", d->name);
 218                 }
 219         }
 220         fclose(f);
 221         if (rename(path, resolv_conf) < 0) {
 222                 D(INTERFACE, "Failed to replace %s\n", resolv_conf);
 223                 unlink(path);
 224         }
 225 }
 226
 227 void
 228 interface_ip_update_start(struct interface_ip_settings *ip)
 229 {
 230         interface_clear_dns_servers(ip);
 231         interface_clear_dns_search(ip);
 232         vlist_update(&ip->route);
 233         vlist_update(&ip->addr);
 234 }
 235
 236 void
 237 interface_ip_update_complete(struct interface_ip_settings *ip)
 238 {
 239         vlist_flush(&ip->route);
 240         vlist_flush(&ip->addr);
 241 }
 242
 243 void
 244 interface_ip_flush(struct interface_ip_settings *ip)
 245 {
 246         interface_clear_dns_servers(ip);
 247         interface_clear_dns_search(ip);
 248         vlist_flush_all(&ip->route);
 249         vlist_flush_all(&ip->addr);
 250 }
 251
 252 void
 253 interface_ip_init(struct interface_ip_settings *ip, struct interface *iface)
 254 {
 255         ip->iface = iface;
 256         INIT_LIST_HEAD(&ip->dns_search);
 257         INIT_LIST_HEAD(&ip->dns_servers);
 258         vlist_init(&ip->route, route_cmp, interface_update_proto_route,
 259                    struct device_route, node, mask);
 260         vlist_init(&ip->addr, addr_cmp, interface_update_proto_addr,
 261                    struct device_addr, node, mask);
 262 }