#include "sysinfo.h"
#include "platform.h"
#include "device-handler.h"
+#include "paths.h"
#define HWADDR_SIZE 6
#define PIDFILE_BASE (LOCAL_STATE_DIR "/petitboot/")
struct list_item list;
struct process *udhcpc_process;
+ struct process *udhcpc6_process;
struct discover_device *dev;
+ bool ready;
};
struct network {
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,
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);
}
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",
"-f",
"-O", "pxeconffile",
"-O", "pxepathprefix",
+ "-O", "reboottime",
+ "-p", pidfile,
+ "-i", interface->name,
+ "-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", id, /* [11,12] - dhcp client identifier */
+ "-x", idv6, /* [15,16] - dhcp client identifier */
NULL,
};
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;
}
interface->hwaddr,
sizeof(interface->hwaddr)),
config->static_config.address);
+ device_handler_start_requery_timeout(network->handler,
+ interface->dev, -1);
}
return;
} else if (config->method == CONFIG_METHOD_STATIC) {
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;
case IFLA_IFNAME:
strncpy(ifname, data, IFNAMSIZ);
+ ifname[IFNAMSIZ - 1] = '\0';
have_ifname = true;
break;
interface->ifindex = info->ifi_index;
interface->state = IFSTATE_NEW;
memcpy(interface->hwaddr, ifaddr, sizeof(interface->hwaddr));
- strncpy(interface->name, ifname, sizeof(interface->name) - 1);
+ 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) - 1);
+ strncpy(interface->name, ifname, sizeof(interface->name));
talloc_free(interface->dev->device->id);
interface->dev->device->id =
talloc_strdup(interface->dev->device, ifname);
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);
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;
projects / petitboot / blobdiff