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