X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fnetwork.c;h=2057525e2fe690cf82ec5a012240f10515eb85b0;hp=ca4cc44acf1ba3d1334452b547326041c33f8b13;hb=f5fb1751ec92110669a039bb0de209bffe74538a;hpb=310de3ab00b77b09a897b93ed0272b82ebc4f73b diff --git a/discover/network.c b/discover/network.c index ca4cc44..2057525 100644 --- a/discover/network.c +++ b/discover/network.c @@ -8,20 +8,22 @@ #include #include #include +#include #include #include +#include #include #include #include #include #include -#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/") @@ -51,7 +53,9 @@ struct interface { struct list_item list; struct process *udhcpc_process; + struct process *udhcpc6_process; struct discover_device *dev; + bool ready; }; struct network { @@ -65,6 +69,25 @@ 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) { @@ -97,6 +120,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 +217,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"; @@ -180,6 +280,22 @@ static int interface_change(struct interface *interface, bool up) process_stop_async(interface->udhcpc_process); process_release(interface->udhcpc_process); } + if (!up && interface->udhcpc6_process) { + /* we don't care about the callback from here */ + interface->udhcpc6_process->exit_cb = NULL; + interface->udhcpc6_process->data = NULL; + process_stop_async(interface->udhcpc6_process); + process_release(interface->udhcpc6_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); @@ -204,61 +320,109 @@ static int interface_down(struct interface *interface) static void udhcpc_process_exit(struct process *process) { struct interface *interface = process->data; - pb_debug("udhcp client [pid %d] for interface %s exited, rc %d\n", - process->pid, interface->name, process->exit_status); - interface->udhcpc_process = NULL; + + if (process == interface->udhcpc_process) { + pb_debug("udhcpc client [pid %d] for interface %s exited, rc %d\n", + process->pid, interface->name, process->exit_status); + interface->udhcpc_process = NULL; + } else { + pb_debug("udhcpc6 client [pid %d] for interface %s exited, rc %d\n", + process->pid, interface->name, process->exit_status); + interface->udhcpc6_process = NULL; + } + 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], idv4[10], idv6[10]; + struct process *p_v4, *p_v6; int rc; - const char *argv[] = { + const char *argv_ipv4[] = { pb_system_apps.udhcpc, "-R", - "-n", + "-f", "-O", "pxeconffile", "-O", "pxepathprefix", + "-O", "reboottime", "-p", pidfile, "-i", interface->name, - "-x", id, /* [11,12] - dhcp client identifier */ + "-x", idv4, /* [11,12] - dhcp client identifier */ NULL, }; + const char *argv_ipv6[] = { + pb_system_apps.udhcpc6, + "-R", + "-f", + "-O", "bootfile_url", + "-O", "bootfile_param", + "-O", "pxeconffile", + "-O", "pxepathprefix", + "-p", pidfile, + "-i", interface->name, + "-x", idv6, /* [15,16] - 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; + if (platform && platform->dhcp_arch_id != 0xffff) { + snprintf(idv6, sizeof(idv6), "0x3d:%04x", + platform->dhcp_arch_id); + snprintf(idv4, sizeof(idv4), "0x5d:%04x", + platform->dhcp_arch_id); + } else { + argv_ipv4[11] = argv_ipv6[15] = NULL; + } - process = process_create(interface); + p_v4 = process_create(interface); + p_v4->path = pb_system_apps.udhcpc; + p_v4->argv = argv_ipv4; + p_v4->exit_cb = udhcpc_process_exit; + p_v4->data = interface; - process->path = pb_system_apps.udhcpc; - process->argv = argv; - process->exit_cb = udhcpc_process_exit; - process->data = interface; + pb_log("Running DHCPv4 client\n"); + rc = process_run_async(p_v4); + if (rc) + process_release(p_v4); + else + interface->udhcpc_process = p_v4; - rc = process_run_async(process); + pb_log("Running DHCPv6 client\n"); + p_v6 = process_create(interface); + p_v6->path = pb_system_apps.udhcpc6; + p_v6->argv = argv_ipv6; + p_v6->exit_cb = udhcpc_process_exit; + p_v6->data = interface; + rc = process_run_async(p_v6); if (rc) - process_release(process); + process_release(p_v6); else - interface->udhcpc_process = process; + interface->udhcpc6_process = p_v6; 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); @@ -271,6 +435,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) @@ -288,6 +456,18 @@ 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); + device_handler_start_requery_timeout(network->handler, + interface->dev, -1); + } + return; } @@ -305,8 +485,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 */ @@ -353,22 +536,69 @@ 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; +} + +void network_requery_device(struct network *network, + struct discover_device *dev) +{ + const struct interface_config *config; + struct interface *interface; + + interface = find_interface_by_uuid(network, dev->uuid); + if (!interface) + return; + + if (interface->udhcpc_process) { + interface->udhcpc_process->exit_cb = NULL; + interface->udhcpc_process->data = NULL; + process_stop_async(interface->udhcpc_process); + process_release(interface->udhcpc_process); + } + + config = find_config_by_hwaddr(interface->hwaddr); + + if (config && config->ignore) + return; + + if (!config || config->method == CONFIG_METHOD_DHCP) { + /* Restart DHCP. Once we acquire a lease, we'll re-start + * the requery timeout (based on any reboottime DHCP option) + */ + configure_interface_dhcp(network, interface); + + } else if (config->method == CONFIG_METHOD_STATIC && + config->static_config.url) { + /* Redownload statically-provided URL, and manually restart + * requery timeout */ + 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); + device_handler_start_requery_timeout(network->handler, + dev, -1); } } 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; uint8_t ifaddr[6]; - char ifname[IFNAMSIZ+1]; + char ifname[IFNAMSIZ]; int attrlen, type; @@ -396,6 +626,7 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg) case IFLA_IFNAME: strncpy(ifname, data, IFNAMSIZ); + ifname[IFNAMSIZ - 1] = '\0'; have_ifname = true; break; @@ -417,6 +648,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) { @@ -424,8 +658,28 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg) interface->ifindex = info->ifi_index; interface->state = IFSTATE_NEW; memcpy(interface->hwaddr, ifaddr, sizeof(interface->hwaddr)); - strncpy(interface->name, ifname, sizeof(interface->name) - 1); - add_interface(network, interface); + strncpy(interface->name, ifname, sizeof(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)); + 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 */ @@ -435,6 +689,14 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg) interface->hwaddr, interface->name, info->ifi_flags & IFF_LOWER_UP); + if (!interface->dev) + create_interface_dev(network, interface); + + if (!interface->ready && strncmp(interface->name, "lo", strlen("lo"))) { + pb_log("%s not marked ready yet\n", interface->name); + return 0; + } + configure_interface(network, interface, info->ifi_flags & IFF_UP, info->ifi_flags & IFF_LOWER_UP); @@ -442,6 +704,72 @@ static int network_handle_nlmsg(struct network *network, struct nlmsghdr *nlmsg) return 0; } +void network_mark_interface_ready(struct device_handler *handler, + int ifindex, const char *ifname, uint8_t *mac, int hwsize) +{ + struct network *network = device_handler_get_network(handler); + struct interface *interface, *tmp = NULL; + char *macstr; + + if (!network) { + pb_log("Network not ready - can not mark interface ready\n"); + return; + } + + if (hwsize != HWADDR_SIZE) + return; + + if (strncmp(ifname, "lo", strlen("lo")) == 0) + return; + + interface = find_interface_by_ifindex(network, ifindex); + if (!interface) { + pb_debug("Creating ready interface %d - %s\n", + ifindex, ifname); + interface = talloc_zero(network, struct interface); + interface->ifindex = ifindex; + interface->state = IFSTATE_NEW; + memcpy(interface->hwaddr, mac, HWADDR_SIZE); + strncpy(interface->name, ifname, sizeof(interface->name) - 1); + + 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; + } + + list_add(&network->interfaces, &interface->list); + create_interface_dev(network, interface); + } + + if (interface->ready) { + pb_log("%s already ready\n", interface->name); + return; + } + + if (strncmp(interface->name, ifname, strlen(ifname)) != 0) { + pb_debug("ifname update from udev: %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); + } + + if (memcmp(interface->hwaddr, mac, HWADDR_SIZE) != 0) { + macstr = mac_bytes_to_string(interface, mac, hwsize); + pb_log("Warning - new MAC for interface %d does not match: %s\n", + ifindex, macstr); + talloc_free(macstr); + } + + pb_log("Interface %s ready\n", ifname); + interface->ready = true; + configure_interface(network, interface, false, false); +} + static int network_netlink_process(void *arg) { struct network *network = arg;