4b9e4f10958f733df1f661c8e8f5b087d4f8a16a
[petitboot] / discover / network.c
1
2 #include <stdbool.h>
3 #include <stdint.h>
4 #include <string.h>
5 #include <stdlib.h>
6 #include <errno.h>
7 #include <sys/socket.h>
8 #include <linux/if.h>
9 #include <linux/netlink.h>
10 #include <linux/rtnetlink.h>
11
12 #include <log/log.h>
13 #include <list/list.h>
14 #include <talloc/talloc.h>
15 #include <waiter/waiter.h>
16 #include <pb-config/pb-config.h>
17 #include <system/system.h>
18
19 #include "file.h"
20 #include "network.h"
21
22 #define HWADDR_SIZE     6
23 #define PIDFILE_BASE    (LOCAL_STATE_DIR "/petitboot/")
24
25 #define for_each_nlmsg(buf, nlmsg, len) \
26         for (nlmsg = (struct nlmsghdr *)buf; \
27                 NLMSG_OK(nlmsg, len) && nlmsg->nlmsg_type != NLMSG_DONE; \
28                 nlmsg = NLMSG_NEXT(nlmsg, len))
29
30 #define for_each_rta(buf, rta, attrlen) \
31         for (rta = (struct rtattr *)(buf); RTA_OK(rta, attrlen); \
32                         rta = RTA_NEXT(rta, attrlen))
33
34
35 struct interface {
36         int     ifindex;
37         char    name[IFNAMSIZ];
38         uint8_t hwaddr[HWADDR_SIZE];
39
40         enum {
41                 IFSTATE_NEW,
42                 IFSTATE_UP_WAITING_LINK,
43                 IFSTATE_CONFIGURED,
44                 IFSTATE_IGNORED,
45         } state;
46
47         struct list_item list;
48 };
49
50 struct network {
51         struct list     interfaces;
52         struct waiter   *waiter;
53         int             netlink_sd;
54         bool            manual_config;
55         bool            dry_run;
56 };
57
58 static const struct interface_config *find_config_by_hwaddr(
59                 uint8_t *hwaddr)
60 {
61         const struct config *config;
62         int i;
63
64         config = config_get();
65         if (!config)
66                 return NULL;
67
68         for (i = 0; i < config->network.n_interfaces; i++) {
69                 struct interface_config *ifconf = config->network.interfaces[i];
70
71                 if (!memcmp(ifconf->hwaddr, hwaddr, HWADDR_SIZE))
72                         return ifconf;
73         }
74
75         return NULL;
76 }
77
78 static struct interface *find_interface_by_ifindex(struct network *network,
79                 int ifindex)
80 {
81         struct interface *interface;
82
83         list_for_each_entry(&network->interfaces, interface, list)
84                 if (interface->ifindex == ifindex)
85                         return interface;
86
87         return NULL;
88 }
89
90 static int network_init_netlink(struct network *network)
91 {
92         struct sockaddr_nl addr;
93         int rc;
94
95         memset(&addr, 0, sizeof(addr));
96         addr.nl_family = AF_NETLINK;
97         addr.nl_groups = RTMGRP_LINK;
98
99         network->netlink_sd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
100         if (network->netlink_sd < 0) {
101                 perror("socket(AF_NETLINK)");
102                 return -1;
103         }
104
105         rc = bind(network->netlink_sd, (struct sockaddr *)&addr, sizeof(addr));
106         if (rc) {
107                 perror("bind(sockaddr_nl)");
108                 close(network->netlink_sd);
109                 return -1;
110         }
111
112         return 0;
113 }
114
115 static int network_send_link_query(struct network *network)
116 {
117         int rc;
118         struct {
119                 struct nlmsghdr nlmsg;
120                 struct rtgenmsg rtmsg;
121         } msg;
122
123         memset(&msg, 0, sizeof(msg));
124
125         msg.nlmsg.nlmsg_len = sizeof(msg);
126         msg.nlmsg.nlmsg_type = RTM_GETLINK;
127         msg.nlmsg.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
128         msg.nlmsg.nlmsg_seq = 0;
129         msg.nlmsg.nlmsg_pid = 0;
130         msg.rtmsg.rtgen_family = AF_UNSPEC;
131
132         rc = send(network->netlink_sd, &msg, sizeof(msg), MSG_NOSIGNAL);
133         if (rc != sizeof(msg))
134                 return -1;
135
136         return 0;
137 }
138
139 static int interface_change(struct network *network,
140                 struct interface *interface,
141                 bool up)
142 {
143         int rc;
144         const char *statestr = up ? "up" : "down";
145         const char *argv[] = {
146                 pb_system_apps.ip,
147                 "link",
148                 "set",
149                 interface->name,
150                 statestr,
151                 NULL,
152         };
153
154         rc = pb_run_cmd(argv, 1, network->dry_run);
155         if (rc) {
156                 pb_log("failed to bring interface %s %s\n", interface->name,
157                                 statestr);
158                 return -1;
159         }
160         return 0;
161 }
162
163 static int interface_up(struct network *network,
164                 struct interface *interface)
165 {
166         return interface_change(network, interface, true);
167 }
168
169 static int interface_down(struct network *network,
170                 struct interface *interface)
171 {
172         return interface_change(network, interface, false);
173 }
174
175 static void configure_interface_dhcp(struct network *network,
176                 struct interface *interface)
177 {
178         char pidfile[256];
179         const char *argv[] = {
180                 pb_system_apps.udhcpc,
181                 "-R",
182                 "-n",
183                 "-p", pidfile,
184                 "-i", interface->name,
185                 NULL,
186         };
187         snprintf(pidfile, sizeof(pidfile), "%s/udhcpc-%s.pid",
188                         PIDFILE_BASE, interface->name);
189
190         pb_run_cmd(argv, 0, network->dry_run);
191         return;
192 }
193
194 static void configure_interface_static(struct network *network,
195                 struct interface *interface,
196                 const struct interface_config *config)
197 {
198         const char *addr_argv[] = {
199                 pb_system_apps.ip,
200                 "address",
201                 "add",
202                 config->static_config.address,
203                 "dev",
204                 interface->name,
205                 NULL,
206         };
207         const char *route_argv[] = {
208                 pb_system_apps.ip,
209                 "route",
210                 "add",
211                 "default",
212                 "via",
213                 config->static_config.gateway,
214                 NULL,
215         };
216         int rc;
217
218
219         rc = pb_run_cmd(addr_argv, 1, network->dry_run);
220         if (rc) {
221                 pb_log("failed to add address %s to interface %s\n",
222                                 config->static_config.address,
223                                 interface->name);
224                 return;
225         }
226
227         /* we need the interface up before we can route through it */
228         rc = interface_up(network, interface);
229         if (rc)
230                 return;
231
232         if (config->static_config.gateway)
233                 rc = pb_run_cmd(route_argv, 1, network->dry_run);
234
235         if (rc) {
236                 pb_log("failed to add default route %s on interface %s\n",
237                                 config->static_config.gateway,
238                                 interface->name);
239         }
240
241         return;
242 }
243
244 static void configure_interface(struct network *network,
245                 struct interface *interface, bool up, bool link)
246 {
247         const struct interface_config *config = NULL;
248
249         if (interface->state == IFSTATE_IGNORED)
250                 return;
251
252         /* old interface? check that we're still up and running */
253         if (interface->state == IFSTATE_CONFIGURED) {
254                 if (!up)
255                         interface->state = IFSTATE_NEW;
256                 else if (!link)
257                         interface->state = IFSTATE_UP_WAITING_LINK;
258                 else
259                         return;
260         }
261
262         /* always up the lookback, no other handling required */
263         if (!strcmp(interface->name, "lo")) {
264                 if (interface->state == IFSTATE_NEW)
265                         interface_up(network, interface);
266                 interface->state = IFSTATE_CONFIGURED;
267                 return;
268         }
269
270         config = find_config_by_hwaddr(interface->hwaddr);
271         if (config && config->ignore) {
272                 pb_log("network: ignoring interface %s\n", interface->name);
273                 interface->state = IFSTATE_IGNORED;
274                 return;
275         }
276
277         /* if we're in manual config mode, we need an interface configuration */
278         if (network->manual_config && !config) {
279                 interface->state = IFSTATE_IGNORED;
280                 pb_log("network: skipping %s: manual config mode, "
281                                 "but no config for this interface\n",
282                                 interface->name);
283                 return;
284         }
285
286         /* new interface? bring up to the point so we can detect a link */
287         if (interface->state == IFSTATE_NEW) {
288                 if (!up) {
289                         interface_up(network, interface);
290                         pb_log("network: bringing up interface %s\n",
291                                         interface->name);
292                         return;
293
294                 } else if (!link) {
295                         interface->state = IFSTATE_UP_WAITING_LINK;
296                 }
297         }
298
299         /* no link? wait for a notification */
300         if (interface->state == IFSTATE_UP_WAITING_LINK && !link)
301                 return;
302
303         pb_log("network: configuring interface %s\n", interface->name);
304
305         if (!config || config->method == CONFIG_METHOD_DHCP) {
306                 configure_interface_dhcp(network, interface);
307
308         } else if (config->method == CONFIG_METHOD_STATIC) {
309                 configure_interface_static(network, interface, config);
310         }
311 }
312
313 static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg)
314 {
315         bool have_ifaddr, have_ifname;
316         struct interface *interface;
317         struct ifinfomsg *info;
318         struct rtattr *attr;
319         uint8_t ifaddr[6];
320         char ifname[IFNAMSIZ+1];
321         int attrlen, type;
322
323
324         /* we're only interested in NEWLINK messages */
325         type = nlmsg->nlmsg_type;
326         if (!(type == RTM_NEWLINK || type == RTM_DELLINK))
327                 return 0;
328
329         info = NLMSG_DATA(nlmsg);
330
331         have_ifaddr = have_ifname = false;
332
333         attrlen = nlmsg->nlmsg_len - sizeof(*info);
334
335         /* extract the interface name and hardware address attributes */
336         for_each_rta(info + 1, attr, attrlen) {
337                 void *data = RTA_DATA(attr);
338
339                 switch (attr->rta_type) {
340                 case IFLA_ADDRESS:
341                         memcpy(ifaddr, data, sizeof(ifaddr));
342                         have_ifaddr = true;
343                         break;
344
345                 case IFLA_IFNAME:
346                         strncpy(ifname, data, IFNAMSIZ);
347                         have_ifname = true;
348                         break;
349                 }
350         }
351
352         if (!have_ifaddr || !have_ifname)
353                 return -1;
354
355         if (type == RTM_DELLINK) {
356                 interface = find_interface_by_ifindex(network, info->ifi_index);
357                 if (!interface)
358                         return 0;
359                 pb_log("network: interface %s removed\n", interface->name);
360                 list_remove(&interface->list);
361                 talloc_free(interface);
362                 return 0;
363         }
364
365
366         interface = find_interface_by_ifindex(network, info->ifi_index);
367         if (!interface) {
368                 interface = talloc_zero(network, struct interface);
369                 interface->ifindex = info->ifi_index;
370                 interface->state = IFSTATE_NEW;
371                 memcpy(interface->hwaddr, ifaddr, sizeof(interface->hwaddr));
372                 strncpy(interface->name, ifname, sizeof(interface->name) - 1);
373         }
374
375         configure_interface(network, interface,
376                         info->ifi_flags & IFF_UP,
377                         info->ifi_flags & IFF_LOWER_UP);
378
379         return 0;
380 }
381
382 static int network_netlink_process(void *arg)
383 {
384         struct network *network = arg;
385         struct nlmsghdr *nlmsg;
386         unsigned int len;
387         char buf[4096];
388         int rc;
389
390         rc = recv(network->netlink_sd, buf, sizeof(buf), 0);
391         if (rc < 0) {
392                 perror("netlink recv");
393                 return -1;
394         }
395
396         len = rc;
397
398         for_each_nlmsg(buf, nlmsg, len)
399                 network_handle_nlmsg(network, nlmsg);
400
401         return 0;
402 }
403
404 static void network_init_dns(struct network *network)
405 {
406         const struct config *config;
407         int i, rc, len;
408         bool modified;
409         char *buf;
410
411         if (network->dry_run)
412                 return;
413
414         config = config_get();
415         if (!config || !config->network.n_dns_servers)
416                 return;
417
418         rc = read_file(network, "/etc/resolv.conf", &buf, &len);
419
420         if (rc) {
421                 buf = talloc_strdup(network, "");
422                 len = 0;
423         }
424
425         modified = false;
426
427         for (i = 0; i < config->network.n_dns_servers; i++) {
428                 int dns_conf_len;
429                 char *dns_conf;
430
431                 dns_conf = talloc_asprintf(network, "nameserver %s\n",
432                                 config->network.dns_servers[i]);
433
434                 if (strstr(buf, dns_conf)) {
435                         talloc_free(dns_conf);
436                         continue;
437                 }
438
439                 dns_conf_len = strlen(dns_conf);
440                 buf = talloc_realloc(network, buf, char, len + dns_conf_len);
441                 memcpy(buf + len, dns_conf, dns_conf_len);
442                 len += dns_conf_len;
443                 modified = true;
444
445                 talloc_free(dns_conf);
446         }
447
448         if (modified) {
449                 rc = replace_file("/etc/resolv.conf", buf, len);
450                 if (rc)
451                         pb_log("error replacing resolv.conf: %s\n",
452                                         strerror(errno));
453         }
454
455         talloc_free(buf);
456 }
457
458 struct network *network_init(void *ctx, struct waitset *waitset, bool dry_run)
459 {
460         struct network *network;
461         int rc;
462
463         network = talloc(ctx, struct network);
464         list_init(&network->interfaces);
465         network->manual_config = false;
466         network->dry_run = dry_run;
467
468         network_init_dns(network);
469
470         rc = network_init_netlink(network);
471         if (rc)
472                 goto err;
473
474         network->waiter = waiter_register_io(waitset, network->netlink_sd,
475                         WAIT_IN, network_netlink_process, network);
476
477         if (!network->waiter)
478                 goto err;
479
480         rc = network_send_link_query(network);
481         if (rc)
482                 goto err;
483
484         return network;
485
486 err:
487         network_shutdown(network);
488         return NULL;
489 }
490
491
492 int network_shutdown(struct network *network)
493 {
494         struct interface *interface;
495
496         if (network->waiter)
497                 waiter_remove(network->waiter);
498
499         list_for_each_entry(&network->interfaces, interface, list)
500                 interface_down(network, interface);
501
502         close(network->netlink_sd);
503         talloc_free(network);
504         return 0;
505 }