#include <stdint.h>
#include <string.h>
#include <stdlib.h>
+#include <errno.h>
#include <sys/socket.h>
#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 "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/")
+#define INITIAL_BUFSIZE 4096
#define for_each_nlmsg(buf, nlmsg, len) \
for (nlmsg = (struct nlmsghdr *)buf; \
} state;
struct list_item list;
+ struct process *udhcpc_process;
+ struct discover_device *dev;
};
struct network {
- struct list interfaces;
- struct waiter *waiter;
- int netlink_sd;
- bool manual_config;
- bool dry_run;
+ struct list interfaces;
+ struct device_handler *handler;
+ struct waiter *waiter;
+ int netlink_sd;
+ void *netlink_buf;
+ unsigned int netlink_buf_size;
+ bool manual_config;
+ bool dry_run;
};
-static const struct network_config *find_config_by_hwaddr(
+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)
return NULL;
- for (i = 0; i < config->n_network_configs; i++) {
- struct network_config *netconf = config->network_configs[i];
+ for (i = 0; i < config->network.n_interfaces; i++) {
+ struct interface_config *ifconf = config->network.interfaces[i];
- if (!memcmp(netconf->hwaddr, hwaddr, HWADDR_SIZE))
- return netconf;
+ if (!memcmp(ifconf->hwaddr, hwaddr, HWADDR_SIZE))
+ return ifconf;
}
return NULL;
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;
return -1;
}
+ network->netlink_buf_size = INITIAL_BUFSIZE;
+ network->netlink_buf = talloc_array(network, char,
+ network->netlink_buf_size);
+
return 0;
}
return 0;
}
-static int interface_change(struct network *network,
- struct interface *interface,
- bool up)
+static void create_interface_dev(struct network *network,
+ struct interface *interface)
+{
+ 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)
+{
+ 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)
{
- int rc;
const char *statestr = up ? "up" : "down";
- const char *argv[] = {
- pb_system_apps.ip,
- "link",
- "set",
- interface->name,
- statestr,
- NULL,
- };
+ int rc;
- rc = pb_run_cmd(argv, 1, network->dry_run);
+ if (!up && interface->udhcpc_process) {
+ /* we don't care about the callback from here */
+ interface->udhcpc_process->exit_cb = NULL;
+ interface->udhcpc_process->data = NULL;
+ process_stop_async(interface->udhcpc_process);
+ 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) {
pb_log("failed to bring interface %s %s\n", interface->name,
statestr);
return 0;
}
-static int interface_up(struct network *network,
- struct interface *interface)
+static int interface_up(struct interface *interface)
{
- return interface_change(network, interface, true);
+ return interface_change(interface, true);
}
-static int interface_down(struct network *network,
- struct interface *interface)
+static int interface_down(struct interface *interface)
+{
+ return interface_change(interface, false);
+}
+
+static void udhcpc_process_exit(struct process *process)
{
- return interface_change(network, interface, false);
+ 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;
+ process_release(process);
}
static void configure_interface_dhcp(struct network *network,
struct interface *interface)
{
- char pidfile[256];
+ const struct platform *platform;
+ char pidfile[256], id[10];
+ struct process *process;
+ 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);
- pb_run_cmd(argv, 0, network->dry_run);
+ 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;
+ process->argv = argv;
+ process->exit_cb = udhcpc_process_exit;
+ process->data = interface;
+
+ rc = process_run_async(process);
+
+ if (rc)
+ process_release(process);
+ else
+ interface->udhcpc_process = process;
+
return;
}
static void configure_interface_static(struct network *network,
struct interface *interface,
- const struct network_config *config)
+ const struct interface_config *config)
{
- const char *addr_argv[] = {
- pb_system_apps.ip,
- "address",
- "add",
- config->static_config.address,
- "dev",
- interface->name,
- NULL,
- };
- const char *route_argv[] = {
- pb_system_apps.ip,
- "route",
- "add",
- "default",
- "via",
- config->static_config.gateway,
- NULL,
- };
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);
+
- rc = pb_run_cmd(addr_argv, 1, network->dry_run);
if (rc) {
pb_log("failed to add address %s to interface %s\n",
config->static_config.address,
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(network, interface);
+ rc = interface_up(interface);
if (rc)
return;
if (config->static_config.gateway)
- rc = pb_run_cmd(route_argv, 1, network->dry_run);
+ rc = process_run_simple(interface, pb_system_apps.ip,
+ "route", "add", "default",
+ "via", config->static_config.gateway,
+ NULL);
if (rc) {
pb_log("failed to add default route %s on interface %s\n",
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;
}
static void configure_interface(struct network *network,
struct interface *interface, bool up, bool link)
{
- const struct network_config *config = NULL;
+ const struct interface_config *config = NULL;
if (interface->state == IFSTATE_IGNORED)
return;
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 */
if (!strcmp(interface->name, "lo")) {
if (interface->state == IFSTATE_NEW)
- interface_up(network, interface);
+ interface_up(interface);
interface->state = IFSTATE_CONFIGURED;
return;
}
/* new interface? bring up to the point so we can detect a link */
if (interface->state == IFSTATE_NEW) {
if (!up) {
- interface_up(network, interface);
+ interface_up(interface);
pb_log("network: bringing up interface %s\n",
interface->name);
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;
}
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];
int attrlen, type;
info = NLMSG_DATA(nlmsg);
have_ifaddr = have_ifname = false;
+ mtu = 1;
attrlen = nlmsg->nlmsg_len - sizeof(*info);
strncpy(ifname, data, IFNAMSIZ);
have_ifname = true;
break;
+
+ case IFLA_MTU:
+ mtu = *(unsigned int *)data;
+ break;
}
}
if (!have_ifaddr || !have_ifname)
return -1;
- if (type == RTM_DELLINK) {
+ if (type == RTM_DELLINK || mtu == 0) {
interface = find_interface_by_ifindex(network, info->ifi_index);
if (!interface)
return 0;
pb_log("network: interface %s removed\n", interface->name);
- list_remove(&interface->list);
- talloc_free(interface);
+ remove_interface(network, interface);
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) {
interface->state = IFSTATE_NEW;
memcpy(interface->hwaddr, ifaddr, sizeof(interface->hwaddr));
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 -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);
{
struct network *network = arg;
struct nlmsghdr *nlmsg;
+ struct msghdr msg;
+ struct iovec iov;
unsigned int len;
- char buf[4096];
- int rc;
+ int rc, flags;
+
+ memset(&msg, 0, sizeof(msg));
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+
+ flags = MSG_PEEK;
+
+retry:
+ iov.iov_len = network->netlink_buf_size;
+ iov.iov_base = network->netlink_buf;
+
+ rc = recvmsg(network->netlink_sd, &msg, flags);
- rc = recv(network->netlink_sd, buf, sizeof(buf), 0);
if (rc < 0) {
- perror("netlink recv");
+ perror("netlink recv header");
return -1;
}
len = rc;
- for_each_nlmsg(buf, nlmsg, len)
+ /* if the netlink message was larger than our buffer, realloc
+ * before reading again */
+ if (len > network->netlink_buf_size || msg.msg_flags & MSG_TRUNC) {
+ network->netlink_buf_size *= 2;
+ network->netlink_buf = talloc_realloc(network,
+ network->netlink_buf,
+ char *,
+ network->netlink_buf_size);
+ goto retry;
+ }
+
+ /* otherwise, we're good to read the entire message without PEEK */
+ if (flags == MSG_PEEK) {
+ flags = 0;
+ goto retry;
+ }
+
+ for_each_nlmsg(network->netlink_buf, nlmsg, len)
network_handle_nlmsg(network, nlmsg);
return 0;
}
-struct network *network_init(void *ctx, struct waitset *waitset, bool dry_run)
+static void network_init_dns(struct network *network)
+{
+ const struct config *config;
+ unsigned int i;
+ int rc, len;
+ bool modified;
+ char *buf;
+
+ if (network->dry_run)
+ return;
+
+ config = config_get();
+ if (!config || !config->network.n_dns_servers)
+ return;
+
+ rc = read_file(network, "/etc/resolv.conf", &buf, &len);
+
+ if (rc) {
+ buf = talloc_strdup(network, "");
+ len = 0;
+ }
+
+ modified = false;
+
+ for (i = 0; i < config->network.n_dns_servers; i++) {
+ int dns_conf_len;
+ char *dns_conf;
+
+ dns_conf = talloc_asprintf(network, "nameserver %s\n",
+ config->network.dns_servers[i]);
+
+ if (strstr(buf, dns_conf)) {
+ talloc_free(dns_conf);
+ continue;
+ }
+
+ dns_conf_len = strlen(dns_conf);
+ 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] = '\0';
+ modified = true;
+
+ talloc_free(dns_conf);
+ }
+
+ if (modified) {
+ rc = replace_file("/etc/resolv.conf", buf, len);
+ if (rc)
+ pb_log("error replacing resolv.conf: %s\n",
+ strerror(errno));
+ }
+
+ talloc_free(buf);
+}
+
+struct network *network_init(struct device_handler *handler,
+ struct waitset *waitset, bool dry_run)
{
struct network *network;
int rc;
- network = talloc(ctx, struct network);
+ network = talloc(handler, struct network);
list_init(&network->interfaces);
- network->manual_config = false;
+ network->handler = handler;
network->dry_run = dry_run;
+ network->manual_config = config_get()->network.n_interfaces != 0;
+
+ network_init_dns(network);
rc = network_init_netlink(network);
if (rc)
return NULL;
}
-
int network_shutdown(struct network *network)
{
struct interface *interface;
if (network->waiter)
waiter_remove(network->waiter);
- list_for_each_entry(&network->interfaces, interface, list)
- interface_down(network, interface);
+ 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);
projects / petitboot / blobdiff