lib/system: Add vgscan, vgchange utilities
[petitboot] / discover / network.c
index 87075fcf91925666ed2b8c13757d13dff45b59fc..5035b7ce0895cfe0f2a3c12992ca0d1d57c06f24 100644 (file)
@@ -8,20 +8,22 @@
 #include <linux/if.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
+#include <i18n/i18n.h>
 
 #include <log/log.h>
 #include <list/list.h>
+#include <file/file.h>
 #include <types/types.h>
 #include <talloc/talloc.h>
 #include <waiter/waiter.h>
-#include <pb-config/pb-config.h>
 #include <process/process.h>
 #include <system/system.h>
 
-#include "file.h"
 #include "network.h"
 #include "sysinfo.h"
+#include "platform.h"
 #include "device-handler.h"
+#include "paths.h"
 
 #define HWADDR_SIZE    6
 #define PIDFILE_BASE   (LOCAL_STATE_DIR "/petitboot/")
@@ -65,11 +67,30 @@ struct network {
        bool                    dry_run;
 };
 
+static char *mac_bytes_to_string(void *ctx, uint8_t *addr, int len)
+{
+       const int l = strlen("xx:");
+       char *buf;
+       int i;
+
+       if (len <= 0)
+               return talloc_strdup(ctx, "");
+
+       buf = talloc_array(ctx, char, (len * l) + 1);
+
+       for (i = 0; i < len; i++)
+               sprintf(buf + (l * i), "%02x:", addr[i]);
+
+       *(buf + (l * len) - 1) = '\0';
+
+       return buf;
+}
+
 static const struct interface_config *find_config_by_hwaddr(
                uint8_t *hwaddr)
 {
        const struct config *config;
-       int i;
+       unsigned int i;
 
        config = config_get();
        if (!config)
@@ -97,6 +118,50 @@ static struct interface *find_interface_by_ifindex(struct network *network,
        return NULL;
 }
 
+static struct interface *find_interface_by_name(struct network *network,
+               const char *name)
+{
+       struct interface *interface;
+
+       list_for_each_entry(&network->interfaces, interface, list)
+               if (!strcmp(interface->name, name))
+                       return interface;
+
+       return NULL;
+}
+
+static struct interface *find_interface_by_uuid(struct network *network,
+               const char *uuid)
+{
+       struct interface *interface;
+       char *mac;
+
+       list_for_each_entry(&network->interfaces, interface, list) {
+               mac = mac_bytes_to_string(interface, interface->hwaddr,
+                                       sizeof(interface->hwaddr));
+               if (!strcmp(mac, uuid)) {
+                       talloc_free(mac);
+                       return interface;
+               }
+               talloc_free(mac);
+       }
+
+       return NULL;
+}
+
+uint8_t *find_mac_by_name(void *ctx, struct network *network,
+               const char *name)
+{
+       struct interface *interface;
+
+       interface = find_interface_by_name(network, name);
+       if (!interface)
+               return NULL;
+
+       return talloc_memdup(ctx, &interface->hwaddr,
+                            sizeof(uint8_t) * HWADDR_SIZE);
+}
+
 static int network_init_netlink(struct network *network)
 {
        struct sockaddr_nl addr;
@@ -150,24 +215,57 @@ static int network_send_link_query(struct network *network)
        return 0;
 }
 
-static void add_interface(struct network *network,
+static void create_interface_dev(struct network *network,
                struct interface *interface)
 {
-       list_add(&network->interfaces, &interface->list);
-       interface->dev = discover_device_create(network->handler,
-                                       interface->name);
+       char *uuid = mac_bytes_to_string(interface, interface->hwaddr,
+                                               sizeof(interface->hwaddr));
+
+       interface->dev = discover_device_create(network->handler, uuid,
+                                               interface->name);
        interface->dev->device->type = DEVICE_TYPE_NETWORK;
        device_handler_add_device(network->handler, interface->dev);
+       talloc_free(uuid);
 }
 
 static void remove_interface(struct network *network,
                struct interface *interface)
 {
-       device_handler_remove(network->handler, interface->dev);
+       if (interface->dev)
+               device_handler_remove(network->handler, interface->dev);
        list_remove(&interface->list);
        talloc_free(interface);
 }
 
+void network_register_device(struct network *network,
+               struct discover_device *dev)
+{
+       struct interface *iface;
+
+       if (dev->uuid)
+               iface = find_interface_by_uuid(network, dev->uuid);
+       else
+               iface = find_interface_by_name(network, dev->label);
+       if (!iface)
+               return;
+
+       iface->dev = dev;
+       dev->uuid = mac_bytes_to_string(iface->dev, iface->hwaddr,
+                       sizeof(iface->hwaddr));
+}
+
+void network_unregister_device(struct network *network,
+               struct discover_device *dev)
+{
+       struct interface *iface;
+
+       iface = find_interface_by_uuid(network, dev->uuid);
+       if (!iface)
+               return;
+
+       iface->dev = NULL;
+}
+
 static int interface_change(struct interface *interface, bool up)
 {
        const char *statestr = up ? "up" : "down";
@@ -181,6 +279,15 @@ static int interface_change(struct interface *interface, bool up)
                process_release(interface->udhcpc_process);
        }
 
+       if (!up) {
+               rc = process_run_simple(interface, pb_system_apps.ip,
+                               "address", "flush", "dev", interface->name,
+                               NULL);
+               if (rc)
+                       pb_log("failed to flush addresses from interface %s\n",
+                               interface->name);
+       }
+
        rc = process_run_simple(interface, pb_system_apps.ip,
                        "link", "set", interface->name, statestr, NULL);
        if (rc) {
@@ -210,22 +317,37 @@ static void udhcpc_process_exit(struct process *process)
        process_release(process);
 }
 
-static void configure_interface_dhcp(struct interface *interface)
+static void configure_interface_dhcp(struct network *network,
+               struct interface *interface)
 {
+       const struct platform *platform;
+       char pidfile[256], id[10];
        struct process *process;
-       char pidfile[256];
        int rc;
        const char *argv[] = {
                pb_system_apps.udhcpc,
                "-R",
-               "-n",
+               "-f",
+               "-O", "pxeconffile",
+               "-O", "pxepathprefix",
                "-p", pidfile,
                "-i", interface->name,
+               "-x", id, /* [11,12] - dhcp client identifier */
                NULL,
        };
+
+       device_handler_status_dev_info(network->handler, interface->dev,
+                       _("Configuring with DHCP"));
+
        snprintf(pidfile, sizeof(pidfile), "%s/udhcpc-%s.pid",
                        PIDFILE_BASE, interface->name);
 
+       platform = platform_get();
+       if (platform && platform->dhcp_arch_id != 0xffff)
+               snprintf(id, sizeof(id), "0x5d:%04x", platform->dhcp_arch_id);
+       else
+               argv[11] = NULL;
+
        process = process_create(interface);
 
        process->path = pb_system_apps.udhcpc;
@@ -243,11 +365,16 @@ static void configure_interface_dhcp(struct interface *interface)
        return;
 }
 
-static void configure_interface_static(struct interface *interface,
+static void configure_interface_static(struct network *network,
+               struct interface *interface,
                const struct interface_config *config)
 {
        int rc;
 
+       device_handler_status_dev_info(network->handler, interface->dev,
+                       _("Configuring with static address (ip: %s)"),
+                       config->static_config.address);
+
        rc = process_run_simple(interface, pb_system_apps.ip,
                        "address", "add", config->static_config.address,
                        "dev", interface->name, NULL);
@@ -260,6 +387,10 @@ static void configure_interface_static(struct interface *interface,
                return;
        }
 
+       system_info_set_interface_address(sizeof(interface->hwaddr),
+                               interface->hwaddr,
+                               config->static_config.address);
+
        /* we need the interface up before we can route through it */
        rc = interface_up(interface);
        if (rc)
@@ -277,6 +408,16 @@ static void configure_interface_static(struct interface *interface,
                                interface->name);
        }
 
+       if (config->static_config.url) {
+               pb_log("config URL %s\n", config->static_config.url);
+               device_handler_process_url(network->handler,
+                               config->static_config.url,
+                               mac_bytes_to_string(interface->dev,
+                                               interface->hwaddr,
+                                               sizeof(interface->hwaddr)),
+                               config->static_config.address);
+       }
+
        return;
 }
 
@@ -294,8 +435,11 @@ static void configure_interface(struct network *network,
                        interface->state = IFSTATE_NEW;
                else if (!link)
                        interface->state = IFSTATE_UP_WAITING_LINK;
-               else
+               else {
+                       pb_debug("network: skipping configured interface %s\n",
+                                       interface->name);
                        return;
+               }
        }
 
        /* always up the lookback, no other handling required */
@@ -342,17 +486,21 @@ static void configure_interface(struct network *network,
        pb_log("network: configuring interface %s\n", interface->name);
 
        if (!config || config->method == CONFIG_METHOD_DHCP) {
-               configure_interface_dhcp(interface);
+               configure_interface_dhcp(network, interface);
 
        } else if (config->method == CONFIG_METHOD_STATIC) {
-               configure_interface_static(interface, config);
+               configure_interface_static(network, interface, config);
+               /* Nothing left to do for static interfaces */
+               pending_network_jobs_start();
        }
+
+       interface->state = IFSTATE_CONFIGURED;
 }
 
 static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg)
 {
        bool have_ifaddr, have_ifname;
-       struct interface *interface;
+       struct interface *interface, *tmp;
        struct ifinfomsg *info;
        struct rtattr *attr;
        unsigned int mtu;
@@ -406,6 +554,9 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg)
                return 0;
        }
 
+       /* ignore the default tun device in some environments */
+       if (strncmp(ifname, "tun", strlen("tun")) == 0)
+               return 0;
 
        interface = find_interface_by_ifindex(network, info->ifi_index);
        if (!interface) {
@@ -414,15 +565,39 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg)
                interface->state = IFSTATE_NEW;
                memcpy(interface->hwaddr, ifaddr, sizeof(interface->hwaddr));
                strncpy(interface->name, ifname, sizeof(interface->name) - 1);
-               add_interface(network, interface);
 
-               /* tell the sysinfo code about this interface */
-               if (strcmp(interface->name, "lo"))
-                       system_info_register_interface(
-                                       sizeof(interface->hwaddr),
-                                       interface->hwaddr, interface->name);
+               list_for_each_entry(&network->interfaces, tmp, list)
+                       if (memcmp(interface->hwaddr, tmp->hwaddr,
+                                  sizeof(interface->hwaddr)) == 0) {
+                               pb_log("%s: %s has duplicate MAC address, ignoring\n",
+                                      __func__, interface->name);
+                               talloc_free(interface);
+                               return -1;
+                       }
+
+               list_add(&network->interfaces, &interface->list);
+               create_interface_dev(network, interface);
        }
 
+       /* A repeated RTM_NEWLINK can represent an interface name change */
+       if (strncmp(interface->name, ifname, IFNAMSIZ)) {
+               pb_debug("ifname update: %s -> %s\n", interface->name, ifname);
+               strncpy(interface->name, ifname, sizeof(interface->name) - 1);
+               talloc_free(interface->dev->device->id);
+               interface->dev->device->id =
+                       talloc_strdup(interface->dev->device, ifname);
+       }
+
+       /* notify the sysinfo code about changes to this interface */
+       if (strcmp(interface->name, "lo"))
+               system_info_register_interface(
+                               sizeof(interface->hwaddr),
+                               interface->hwaddr, interface->name,
+                               info->ifi_flags & IFF_LOWER_UP);
+
+       if (!interface->dev)
+               create_interface_dev(network, interface);
+
        configure_interface(network, interface,
                        info->ifi_flags & IFF_UP,
                        info->ifi_flags & IFF_LOWER_UP);
@@ -484,7 +659,8 @@ retry:
 static void network_init_dns(struct network *network)
 {
        const struct config *config;
-       int i, rc, len;
+       unsigned int i;
+       int rc, len;
        bool modified;
        char *buf;
 
@@ -520,7 +696,7 @@ static void network_init_dns(struct network *network)
                buf = talloc_realloc(network, buf, char, len + dns_conf_len + 1);
                memcpy(buf + len, dns_conf, dns_conf_len);
                len += dns_conf_len;
-               buf[len - 1] = '\0';
+               buf[len] = '\0';
                modified = true;
 
                talloc_free(dns_conf);
@@ -545,8 +721,8 @@ struct network *network_init(struct device_handler *handler,
        network = talloc(handler, struct network);
        list_init(&network->interfaces);
        network->handler = handler;
-       network->manual_config = false;
        network->dry_run = dry_run;
+       network->manual_config = config_get()->network.n_interfaces != 0;
 
        network_init_dns(network);
 
@@ -571,7 +747,6 @@ err:
        return NULL;
 }
 
-
 int network_shutdown(struct network *network)
 {
        struct interface *interface;
@@ -579,8 +754,13 @@ int network_shutdown(struct network *network)
        if (network->waiter)
                waiter_remove(network->waiter);
 
-       list_for_each_entry(&network->interfaces, interface, list)
+       list_for_each_entry(&network->interfaces, interface, list) {
+               if (interface->state == IFSTATE_IGNORED)
+                       continue;
+               if (!strcmp(interface->name, "lo"))
+                       continue;
                interface_down(interface);
+       }
 
        close(network->netlink_sd);
        talloc_free(network);