Kernel
/
iwd
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git
3
0
Fork 0
Code Releases Activity
iwd/src/netconfig.c

1781 lines
45 KiB
C
Raw Blame History

/*
*
* Wireless daemon for Linux
*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <errno.h>
#include <arpa/inet.h>
#include <net/if_arp.h>
#include <netinet/if_ether.h>
#include <netinet/in.h>
#include <linux/rtnetlink.h>
#include <limits.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ell/ell.h>
#include "ell/useful.h"
#include "src/iwd.h"
#include "src/module.h"
#include "src/netdev.h"
#include "src/station.h"
#include "src/common.h"
#include "src/network.h"
#include "src/resolve.h"
#include "src/util.h"
#include "src/ie.h"
#include "src/netconfig.h"
#include "src/sysfs.h"
struct netconfig {
uint32_t ifindex;
struct l_dhcp_client *dhcp_client;
struct l_dhcp6_client *dhcp6_client;
uint8_t rtm_protocol;
uint8_t rtm_v6_protocol;
struct l_rtnl_address *v4_address;
struct l_rtnl_address *v6_address;
char **dns4_overrides;
char **dns6_overrides;
char **dns4_list;
char **dns6_list;
char *mdns;
struct ie_fils_ip_addr_response_info *fils_override;
char *v4_gateway_str;
char *v6_gateway_str;
char *v4_domain;
char **v6_domains;
const struct l_settings *active_settings;
netconfig_notify_func_t notify;
void *user_data;
struct resolve *resolve;
struct l_acd *acd;
uint32_t addr4_add_cmd_id;
uint32_t addr6_add_cmd_id;
uint32_t route4_add_gateway_cmd_id;
uint32_t route6_add_cmd_id;
};
static struct l_netlink *rtnl;
static struct l_queue *netconfig_list;
/*
* Routing priority offset, configurable in main.conf. The route with lower
* priority offset is preferred.
*/
static uint32_t ROUTE_PRIORITY_OFFSET;
static bool ipv6_enabled;
static void do_debug(const char *str, void *user_data)
{
const char *prefix = user_data;
l_info("%s%s", prefix, str);
}
static void netconfig_free_settings(struct netconfig *netconfig)
{
l_rtnl_address_free(netconfig->v4_address);
netconfig->v4_address = NULL;
l_rtnl_address_free(netconfig->v6_address);
netconfig->v6_address = NULL;
l_strfreev(netconfig->dns4_overrides);
netconfig->dns4_overrides = NULL;
l_strfreev(netconfig->dns6_overrides);
netconfig->dns6_overrides = NULL;
l_free(netconfig->mdns);
netconfig->mdns = NULL;
}
static void netconfig_free(void *data)
{
struct netconfig *netconfig = data;
l_dhcp_client_destroy(netconfig->dhcp_client);
l_dhcp6_client_destroy(netconfig->dhcp6_client);
l_free(netconfig);
}
static struct netconfig *netconfig_find(uint32_t ifindex)
{
const struct l_queue_entry *entry;
for (entry = l_queue_get_entries(netconfig_list); entry;
entry = entry->next) {
struct netconfig *netconfig = entry->data;
if (netconfig->ifindex != ifindex)
continue;
return netconfig;
}
return NULL;
}
static inline char *netconfig_ipv4_to_string(uint32_t addr)
{
struct in_addr in_addr = { .s_addr = addr };
char *addr_str = l_malloc(INET_ADDRSTRLEN);
if (L_WARN_ON(unlikely(!inet_ntop(AF_INET, &in_addr, addr_str,
INET_ADDRSTRLEN)))) {
l_free(addr_str);
return NULL;
}
return addr_str;
}
static inline char *netconfig_ipv6_to_string(const uint8_t *addr)
{
struct in6_addr in6_addr;
char *addr_str = l_malloc(INET6_ADDRSTRLEN);
memcpy(in6_addr.s6_addr, addr, 16);
if (L_WARN_ON(unlikely(!inet_ntop(AF_INET6, &in6_addr, addr_str,
INET6_ADDRSTRLEN)))) {
l_free(addr_str);
return NULL;
}
return addr_str;
}
static bool netconfig_use_fils_addr(struct netconfig *netconfig, int af)
{
if ((af == AF_INET ? netconfig->rtm_protocol :
netconfig->rtm_v6_protocol) != RTPROT_DHCP)
return false;
if (!netconfig->fils_override)
return false;
if (af == AF_INET)
return !!netconfig->fils_override->ipv4_addr;
return !l_memeqzero(netconfig->fils_override->ipv6_addr, 16);
}
static bool netconfig_use_fils_gateway(struct netconfig *netconfig, int af)
{
if ((af == AF_INET ? netconfig->rtm_protocol :
netconfig->rtm_v6_protocol) != RTPROT_DHCP)
return false;
if (!netconfig->fils_override)
return false;
if (af == AF_INET)
return !!netconfig->fils_override->ipv4_gateway;
return !l_memeqzero(netconfig->fils_override->ipv6_gateway, 16);
}
static char **netconfig_get_dns_list(struct netconfig *netconfig, int af,
const uint8_t **out_dns_mac)
{
const struct ie_fils_ip_addr_response_info *fils =
netconfig->fils_override;
if (af == AF_INET) {
const struct l_dhcp_lease *lease;
if (netconfig->dns4_overrides)
return l_strv_copy(netconfig->dns4_overrides);
if (netconfig->rtm_protocol != RTPROT_DHCP)
return NULL;
if (fils && fils->ipv4_dns) {
char **dns_list = l_new(char *, 2);
if (!l_memeqzero(fils->ipv4_dns_mac, 6) &&
out_dns_mac &&
util_ip_subnet_match(
fils->ipv4_prefix_len,
&fils->ipv4_addr,
&fils->ipv4_dns))
*out_dns_mac = fils->ipv4_dns_mac;
dns_list[0] = netconfig_ipv4_to_string(fils->ipv4_dns);
return dns_list;
}
lease = l_dhcp_client_get_lease(netconfig->dhcp_client);
if (!lease)
return NULL;
return l_dhcp_lease_get_dns(lease);
} else {
const struct l_dhcp6_lease *lease;
if (netconfig->dns6_overrides)
return l_strv_copy(netconfig->dns6_overrides);
if (netconfig->rtm_v6_protocol != RTPROT_DHCP)
return NULL;
if (fils && !l_memeqzero(fils->ipv6_dns, 16)) {
char **dns_list = l_new(char *, 2);
if (!l_memeqzero(fils->ipv6_dns_mac, 6) &&
out_dns_mac &&
util_ip_subnet_match(
fils->ipv6_prefix_len,
fils->ipv6_addr,
fils->ipv6_dns))
*out_dns_mac = fils->ipv6_dns_mac;
dns_list[0] = netconfig_ipv6_to_string(fils->ipv6_dns);
return dns_list;
}
lease = l_dhcp6_client_get_lease(netconfig->dhcp6_client);
if (!lease)
return NULL;
return l_dhcp6_lease_get_dns(lease);
}
}
static void netconfig_set_neighbor_entry_cb(int error,
uint16_t type, const void *data,
uint32_t len, void *user_data)
{
if (error)
l_error("l_rtnl_neighbor_set_hwaddr failed: %s (%i)",
strerror(-error), error);
}
static void netconfig_set_dns(struct netconfig *netconfig)
{
if (!netconfig->dns4_list && !netconfig->dns6_list)
return;
if (netconfig->dns4_list && netconfig->dns6_list) {
unsigned int n_entries4 = l_strv_length(netconfig->dns4_list);
unsigned int n_entries6 = l_strv_length(netconfig->dns6_list);
char **dns_list = l_malloc(sizeof(char *) *
(n_entries4 + n_entries6 + 1));
memcpy(dns_list, netconfig->dns4_list,
sizeof(char *) * n_entries4);
memcpy(dns_list + n_entries4, netconfig->dns6_list,
sizeof(char *) * (n_entries6 + 1));
resolve_set_dns(netconfig->resolve, dns_list);
l_free(dns_list);
return;
}
resolve_set_dns(netconfig->resolve,
netconfig->dns4_list ?: netconfig->dns6_list);
}
static bool netconfig_dns_list_update(struct netconfig *netconfig, uint8_t af)
{
const uint8_t *fils_dns_mac = NULL;
char ***dns_list_ptr = af == AF_INET ?
&netconfig->dns4_list : &netconfig->dns6_list;
char **new_dns_list = netconfig_get_dns_list(netconfig, af,
&fils_dns_mac);
if (l_strv_eq(*dns_list_ptr, new_dns_list)) {
l_strv_free(new_dns_list);
return false;
}
l_strv_free(*dns_list_ptr);
*dns_list_ptr = new_dns_list;
if (fils_dns_mac) {
const struct ie_fils_ip_addr_response_info *fils =
netconfig->fils_override;
const void *dns_ip = af == AF_INET ?
(const void *) &fils->ipv4_dns :
(const void *) &fils->ipv6_dns;
if (!l_rtnl_neighbor_set_hwaddr(rtnl, netconfig->ifindex, af,
dns_ip, fils_dns_mac, 6,
netconfig_set_neighbor_entry_cb,
NULL, NULL))
l_debug("l_rtnl_neighbor_set_hwaddr failed");
}
return true;
}
static void append_domain(char **domains, unsigned int *n_domains,
size_t max, char *domain)
{
unsigned int i;
if (*n_domains == max)
return;
for (i = 0; i < *n_domains; i++)
if (!strcmp(domains[i], domain))
return;
domains[*n_domains] = domain;
*n_domains += 1;
}
static void netconfig_set_domains(struct netconfig *netconfig)
{
char *domains[31];
unsigned int n_domains = 0;
char **p;
memset(domains, 0, sizeof(domains));
append_domain(domains, &n_domains,
L_ARRAY_SIZE(domains) - 1, netconfig->v4_domain);
for (p = netconfig->v6_domains; p && *p; p++)
append_domain(domains, &n_domains,
L_ARRAY_SIZE(domains) - 1, *p);
resolve_set_domains(netconfig->resolve, domains);
}
static bool netconfig_domains_update(struct netconfig *netconfig, uint8_t af)
{
bool changed = false;
if (af == AF_INET) {
/* Allow to override the DHCP domain name with setting entry. */
char *v4_domain = l_settings_get_string(
netconfig->active_settings,
"IPv4", "DomainName");
if (!v4_domain && netconfig->rtm_protocol == RTPROT_DHCP) {
const struct l_dhcp_lease *lease =
l_dhcp_client_get_lease(netconfig->dhcp_client);
if (lease)
v4_domain = l_dhcp_lease_get_domain_name(lease);
}
if (l_streq0(v4_domain, netconfig->v4_domain))
l_free(v4_domain);
else {
l_free(netconfig->v4_domain);
netconfig->v4_domain = v4_domain;
changed = true;
}
} else {
char **v6_domains = NULL;
if (netconfig->rtm_v6_protocol == RTPROT_DHCP) {
const struct l_dhcp6_lease *lease =
l_dhcp6_client_get_lease(
netconfig->dhcp6_client);
if (lease)
v6_domains = l_dhcp6_lease_get_domains(lease);
}
if (l_strv_eq(netconfig->v6_domains, v6_domains))
l_strv_free(v6_domains);
else {
l_strv_free(netconfig->v6_domains);
netconfig->v6_domains = v6_domains;
changed = true;
}
}
return changed;
}
static struct l_rtnl_address *netconfig_get_static4_address(
const struct l_settings *active_settings)
{
struct l_rtnl_address *ifaddr = NULL;
L_AUTO_FREE_VAR(char *, ip) = NULL;
L_AUTO_FREE_VAR(char *, netmask) = NULL;
struct in_addr in_addr;
L_AUTO_FREE_VAR(char *, broadcast) = NULL;
uint32_t prefix_len;
ip = l_settings_get_string(active_settings, "IPv4", "Address");
if (!ip)
return NULL;
netmask = l_settings_get_string(active_settings, "IPv4", "Netmask");
if (netmask) {
if (inet_pton(AF_INET, netmask, &in_addr) != 1) {
l_error("netconfig: Can't parse IPv4 Netmask");
return NULL;
}
prefix_len = __builtin_popcountl(in_addr.s_addr);
if (ntohl(in_addr.s_addr) !=
util_netmask_from_prefix(prefix_len)) {
l_error("netconfig: Invalid IPv4 Netmask");
return NULL;
}
} else
prefix_len = 24;
ifaddr = l_rtnl_address_new(ip, prefix_len);
if (!ifaddr) {
l_error("netconfig: Unable to parse IPv4.Address");
return NULL;
}
broadcast = l_settings_get_string(active_settings, "IPv4", "Broadcast");
if (broadcast && !l_rtnl_address_set_broadcast(ifaddr, broadcast)) {
l_error("netconfig: Unable to parse IPv4.Broadcast");
l_rtnl_address_free(ifaddr);
return NULL;
}
l_rtnl_address_set_noprefixroute(ifaddr, true);
return ifaddr;
}
static char *netconfig_ipv4_get_gateway(struct netconfig *netconfig,
const uint8_t **out_mac)
{
const struct l_dhcp_lease *lease;
char *gateway;
const struct ie_fils_ip_addr_response_info *fils =
netconfig->fils_override;
switch (netconfig->rtm_protocol) {
case RTPROT_STATIC:
gateway = l_settings_get_string(netconfig->active_settings,
"IPv4", "Gateway");
if (!gateway)
gateway = l_settings_get_string(
netconfig->active_settings,
"IPv4", "gateway");
return gateway;
case RTPROT_DHCP:
if (netconfig_use_fils_gateway(netconfig, AF_INET)) {
gateway = netconfig_ipv4_to_string(fils->ipv4_gateway);
if (gateway && out_mac &&
!l_memeqzero(fils->ipv4_gateway_mac, 6))
*out_mac = fils->ipv4_gateway_mac;
return gateway;
}
lease = l_dhcp_client_get_lease(netconfig->dhcp_client);
if (!lease)
return NULL;
return l_dhcp_lease_get_gateway(lease);
}
return NULL;
}
static struct l_rtnl_address *netconfig_get_static6_address(
const struct l_settings *active_settings)
{
L_AUTO_FREE_VAR(char *, ip);
char *p;
char *endp;
struct l_rtnl_address *ret;
uint32_t prefix_len = 128;
ip = l_settings_get_string(active_settings, "IPv6", "Address");
if (!ip)
return NULL;
p = strrchr(ip, '/');
if (!p)
goto no_prefix_len;
*p = '\0';
if (*++p == '\0')
goto no_prefix_len;
errno = 0;
prefix_len = strtoul(p, &endp, 10);
if (unlikely(*endp != '\0' || errno ||
!prefix_len || prefix_len > 128)) {
l_error("netconfig: Invalid prefix '%s' provided in network"
" configuration file", p);
return NULL;
}
no_prefix_len:
ret = l_rtnl_address_new(ip, prefix_len);
if (!ret)
l_error("netconfig: Invalid IPv6 address %s is "
"provided in network configuration file.", ip);
return ret;
}
static struct l_rtnl_route *netconfig_get_static6_gateway(
struct netconfig *netconfig,
char **out_str,
const uint8_t **out_mac)
{
L_AUTO_FREE_VAR(char *, gateway);
struct l_rtnl_route *ret;
const uint8_t *mac = NULL;
gateway = l_settings_get_string(netconfig->active_settings,
"IPv6", "Gateway");
if (!gateway && netconfig_use_fils_gateway(netconfig, AF_INET6)) {
gateway = netconfig_ipv6_to_string(
netconfig->fils_override->ipv6_gateway);
if (!l_memeqzero(netconfig->fils_override->ipv6_gateway_mac, 6))
mac = netconfig->fils_override->ipv6_gateway_mac;
} else if (!gateway)
return NULL;
ret = l_rtnl_route_new_gateway(gateway);
if (!ret) {
l_error("netconfig: Invalid IPv6 gateway address %s is "
"provided in network configuration file.",
gateway);
return ret;
}
l_rtnl_route_set_priority(ret, ROUTE_PRIORITY_OFFSET);
l_rtnl_route_set_protocol(ret, RTPROT_STATIC);
*out_str = l_steal_ptr(gateway);
*out_mac = mac;
return ret;
}
static struct l_rtnl_address *netconfig_get_dhcp4_address(
struct netconfig *netconfig)
{
const struct l_dhcp_lease *lease =
l_dhcp_client_get_lease(netconfig->dhcp_client);
L_AUTO_FREE_VAR(char *, ip) = NULL;
L_AUTO_FREE_VAR(char *, broadcast) = NULL;
uint32_t prefix_len;
struct l_rtnl_address *ret;
if (L_WARN_ON(!lease))
return NULL;
ip = l_dhcp_lease_get_address(lease);
broadcast = l_dhcp_lease_get_broadcast(lease);
prefix_len = l_dhcp_lease_get_prefix_length(lease);
if (!prefix_len)
prefix_len = 24;
ret = l_rtnl_address_new(ip, prefix_len);
if (!ret)
return ret;
if (broadcast)
l_rtnl_address_set_broadcast(ret, broadcast);
l_rtnl_address_set_noprefixroute(ret, true);
return ret;
}
static void netconfig_gateway_to_arp(struct netconfig *netconfig)
{
const struct l_dhcp_lease *lease;
_auto_(l_free) char *server_id = NULL;
_auto_(l_free) char *gw = NULL;
const uint8_t *server_mac;
struct in_addr in_gw;
/* Can only do this for DHCP in certain network setups */
if (netconfig->rtm_protocol != RTPROT_DHCP)
return;
lease = l_dhcp_client_get_lease(netconfig->dhcp_client);
if (!lease)
return;
server_id = l_dhcp_lease_get_server_id(lease);
gw = l_dhcp_lease_get_gateway(lease);
server_mac = l_dhcp_lease_get_server_mac(lease);
if (!gw || strcmp(server_id, gw) || !server_mac)
return;
l_debug("Gateway MAC is known, setting into ARP cache");
in_gw.s_addr = l_dhcp_lease_get_gateway_u32(lease);
if (!l_rtnl_neighbor_set_hwaddr(rtnl, netconfig->ifindex, AF_INET,
&in_gw, server_mac, ETH_ALEN,
netconfig_set_neighbor_entry_cb, NULL,
NULL))
l_debug("l_rtnl_neighbor_set_hwaddr failed");
}
static void netconfig_ifaddr_added(struct netconfig *netconfig,
const struct ifaddrmsg *ifa,
uint32_t len)
{
L_AUTO_FREE_VAR(char *, label) = NULL;
L_AUTO_FREE_VAR(char *, ip) = NULL;
L_AUTO_FREE_VAR(char *, broadcast) = NULL;
l_rtnl_ifaddr4_extract(ifa, len, &label, &ip, &broadcast);
l_debug("%s: ifaddr %s/%u broadcast %s", label,
ip, ifa->ifa_prefixlen, broadcast);
}
static void netconfig_ifaddr_deleted(struct netconfig *netconfig,
const struct ifaddrmsg *ifa,
uint32_t len)
{
L_AUTO_FREE_VAR(char *, ip);
l_rtnl_ifaddr4_extract(ifa, len, NULL, &ip, NULL);
l_debug("ifaddr %s/%u", ip, ifa->ifa_prefixlen);
}
static void netconfig_ifaddr_notify(uint16_t type, const void *data,
uint32_t len, void *user_data)
{
const struct ifaddrmsg *ifa = data;
struct netconfig *netconfig;
uint32_t bytes;
netconfig = netconfig_find(ifa->ifa_index);
if (!netconfig)
/* Ignore the interfaces which aren't managed by iwd. */
return;
bytes = len - NLMSG_ALIGN(sizeof(struct ifaddrmsg));
switch (type) {
case RTM_NEWADDR:
netconfig_ifaddr_added(netconfig, ifa, bytes);
break;
case RTM_DELADDR:
netconfig_ifaddr_deleted(netconfig, ifa, bytes);
break;
}
}
static void netconfig_ifaddr_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
if (error) {
l_error("netconfig: ifaddr command failure. "
"Error %d: %s", error, strerror(-error));
return;
}
if (type != RTM_NEWADDR)
return;
netconfig_ifaddr_notify(type, data, len, user_data);
}
static void netconfig_ifaddr_ipv6_added(struct netconfig *netconfig,
const struct ifaddrmsg *ifa,
uint32_t len)
{
struct in6_addr in6;
L_AUTO_FREE_VAR(char *, ip) = NULL;
if (ifa->ifa_flags & IFA_F_TENTATIVE)
return;
l_rtnl_ifaddr6_extract(ifa, len, &ip);
l_debug("ifindex %u: ifaddr %s/%u", netconfig->ifindex,
ip, ifa->ifa_prefixlen);
if (netconfig->rtm_v6_protocol != RTPROT_DHCP ||
netconfig_use_fils_addr(netconfig, AF_INET6))
return;
inet_pton(AF_INET6, ip, &in6);
if (!IN6_IS_ADDR_LINKLOCAL(&in6))
return;
l_dhcp6_client_set_link_local_address(netconfig->dhcp6_client, ip);
if (l_dhcp6_client_start(netconfig->dhcp6_client))
return;
l_error("netconfig: Failed to start DHCPv6 client for "
"interface %u", netconfig->ifindex);
}
static void netconfig_ifaddr_ipv6_deleted(struct netconfig *netconfig,
const struct ifaddrmsg *ifa,
uint32_t len)
{
L_AUTO_FREE_VAR(char *, ip);
l_rtnl_ifaddr6_extract(ifa, len, &ip);
l_debug("ifindex %u: ifaddr %s/%u", netconfig->ifindex,
ip, ifa->ifa_prefixlen);
}
static void netconfig_ifaddr_ipv6_notify(uint16_t type, const void *data,
uint32_t len, void *user_data)
{
const struct ifaddrmsg *ifa = data;
struct netconfig *netconfig;
uint32_t bytes;
netconfig = netconfig_find(ifa->ifa_index);
if (!netconfig)
/* Ignore the interfaces which aren't managed by iwd. */
return;
bytes = len - NLMSG_ALIGN(sizeof(struct ifaddrmsg));
switch (type) {
case RTM_NEWADDR:
netconfig_ifaddr_ipv6_added(netconfig, ifa, bytes);
break;
case RTM_DELADDR:
netconfig_ifaddr_ipv6_deleted(netconfig, ifa, bytes);
break;
}
}
static void netconfig_ifaddr_ipv6_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
if (error) {
l_error("netconfig: ifaddr IPv6 command failure. "
"Error %d: %s", error, strerror(-error));
return;
}
if (type != RTM_NEWADDR)
return;
netconfig_ifaddr_ipv6_notify(type, data, len, user_data);
}
static void netconfig_route_generic_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
if (error) {
l_error("netconfig: Failed to add route. Error %d: %s",
error, strerror(-error));
return;
}
}
static void netconfig_route_add_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
struct netconfig *netconfig = user_data;
netconfig->route4_add_gateway_cmd_id = 0;
if (error) {
l_error("netconfig: Failed to add route. Error %d: %s",
error, strerror(-error));
return;
}
if (!netconfig->notify)
return;
netconfig->notify(NETCONFIG_EVENT_CONNECTED, netconfig->user_data);
netconfig->notify = NULL;
}
static void netconfig_route6_add_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
struct netconfig *netconfig = user_data;
netconfig->route6_add_cmd_id = 0;
if (error) {
l_error("netconfig: Failed to add route. Error %d: %s",
error, strerror(-error));
return;
}
}
static bool netconfig_ipv4_subnet_route_install(struct netconfig *netconfig)
{
struct in_addr in_addr;
char ip[INET_ADDRSTRLEN];
char network[INET_ADDRSTRLEN];
unsigned int prefix_len =
l_rtnl_address_get_prefix_length(netconfig->v4_address);
if (!l_rtnl_address_get_address(netconfig->v4_address, ip) ||
inet_pton(AF_INET, ip, &in_addr) < 1)
return false;
in_addr.s_addr = in_addr.s_addr &
htonl(0xFFFFFFFFLU << (32 - prefix_len));
if (!inet_ntop(AF_INET, &in_addr, network, INET_ADDRSTRLEN))
return false;
if (!l_rtnl_route4_add_connected(rtnl, netconfig->ifindex,
prefix_len, network, ip,
netconfig->rtm_protocol,
netconfig_route_generic_cb,
netconfig, NULL)) {
l_error("netconfig: Failed to add subnet route.");
return false;
}
return true;
}
static bool netconfig_ipv4_gateway_route_install(struct netconfig *netconfig)
{
L_AUTO_FREE_VAR(char *, gateway) = NULL;
const uint8_t *gateway_mac = NULL;
struct in_addr in_addr;
char ip[INET_ADDRSTRLEN];
gateway = netconfig_ipv4_get_gateway(netconfig, &gateway_mac);
if (!gateway) {
l_debug("No gateway obtained from %s.",
netconfig->rtm_protocol == RTPROT_STATIC ?
"setting file" : "DHCPv4 lease");
if (netconfig->notify) {
netconfig->notify(NETCONFIG_EVENT_CONNECTED,
netconfig->user_data);
netconfig->notify = NULL;
}
return true;
}
if (!l_rtnl_address_get_address(netconfig->v4_address, ip) ||
inet_pton(AF_INET, ip, &in_addr) < 1)
return false;
netconfig->route4_add_gateway_cmd_id =
l_rtnl_route4_add_gateway(rtnl, netconfig->ifindex, gateway, ip,
ROUTE_PRIORITY_OFFSET,
netconfig->rtm_protocol,
netconfig_route_add_cmd_cb,
netconfig, NULL);
if (!netconfig->route4_add_gateway_cmd_id) {
l_error("netconfig: Failed to add route for: %s gateway.",
gateway);
return false;
}
/*
* Attempt to use the gateway MAC address received from the AP by
* writing the mapping directly into the netdev's ARP table so as
* to save one data frame roundtrip before first IP connections
* are established. This is very low-priority but print error
* messages just because they may indicate bigger problems.
*/
if (gateway_mac && !l_rtnl_neighbor_set_hwaddr(rtnl, netconfig->ifindex,
AF_INET,
&netconfig->fils_override->ipv4_gateway,
gateway_mac, 6,
netconfig_set_neighbor_entry_cb, NULL,
NULL))
l_debug("l_rtnl_neighbor_set_hwaddr failed");
return true;
}
static void netconfig_ipv4_ifaddr_add_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
struct netconfig *netconfig = user_data;
netconfig->addr4_add_cmd_id = 0;
if (error && error != -EEXIST) {
l_error("netconfig: Failed to add IP address. "
"Error %d: %s", error, strerror(-error));
return;
}
netconfig_gateway_to_arp(netconfig);
if (!netconfig_ipv4_subnet_route_install(netconfig) ||
!netconfig_ipv4_gateway_route_install(netconfig))
return;
netconfig_set_dns(netconfig);
netconfig_set_domains(netconfig);
}
static void netconfig_ipv6_ifaddr_add_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
struct netconfig *netconfig = user_data;
struct l_rtnl_route *gateway;
const uint8_t *gateway_mac;
netconfig->addr6_add_cmd_id = 0;
if (error && error != -EEXIST) {
l_error("netconfig: Failed to add IPv6 address. "
"Error %d: %s", error, strerror(-error));
return;
}
gateway = netconfig_get_static6_gateway(netconfig,
&netconfig->v6_gateway_str,
&gateway_mac);
if (gateway) {
netconfig->route6_add_cmd_id = l_rtnl_route_add(rtnl,
netconfig->ifindex,
gateway,
netconfig_route6_add_cb,
netconfig, NULL);
L_WARN_ON(unlikely(!netconfig->route6_add_cmd_id));
l_rtnl_route_free(gateway);
if (gateway_mac && !l_rtnl_neighbor_set_hwaddr(rtnl,
netconfig->ifindex, AF_INET6,
netconfig->fils_override->ipv6_gateway,
gateway_mac, 6,
netconfig_set_neighbor_entry_cb, NULL,
NULL))
l_debug("l_rtnl_neighbor_set_hwaddr failed");
}
netconfig_set_dns(netconfig);
netconfig_set_domains(netconfig);
}
static void netconfig_ifaddr_del_cmd_cb(int error, uint16_t type,
const void *data, uint32_t len,
void *user_data)
{
if (error == -ENODEV)
/* The device is unplugged, we are done. */
return;
if (!error)
/*
* The kernel removes all of the routes associated with the
* deleted IP on its own. There is no need to explicitly remove
* them.
*/
return;
l_error("netconfig: Failed to delete IP address. "
"Error %d: %s", error, strerror(-error));
}
static void netconfig_ipv4_dhcp_event_handler(struct l_dhcp_client *client,
enum l_dhcp_client_event event,
void *userdata)
{
struct netconfig *netconfig = userdata;
l_debug("DHCPv4 event %d", event);
switch (event) {
case L_DHCP_CLIENT_EVENT_IP_CHANGED:
L_WARN_ON(!l_rtnl_ifaddr_delete(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ifaddr_del_cmd_cb,
netconfig, NULL));
/* Fall through. */
case L_DHCP_CLIENT_EVENT_LEASE_OBTAINED:
{
char *gateway_str;
struct l_rtnl_address *address;
gateway_str = netconfig_ipv4_get_gateway(netconfig, NULL);
if (l_streq0(netconfig->v4_gateway_str, gateway_str))
l_free(gateway_str);
else {
l_free(netconfig->v4_gateway_str);
netconfig->v4_gateway_str = gateway_str;
}
address = netconfig_get_dhcp4_address(netconfig);
l_rtnl_address_free(netconfig->v4_address);
netconfig->v4_address = address;
if (!netconfig->v4_address) {
l_error("netconfig: Failed to obtain IP addresses from "
"DHCPv4 lease.");
return;
}
netconfig_dns_list_update(netconfig, AF_INET);
netconfig_domains_update(netconfig, AF_INET);
L_WARN_ON(!(netconfig->addr4_add_cmd_id =
l_rtnl_ifaddr_add(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ipv4_ifaddr_add_cmd_cb,
netconfig, NULL)));
break;
}
case L_DHCP_CLIENT_EVENT_LEASE_RENEWED:
break;
case L_DHCP_CLIENT_EVENT_LEASE_EXPIRED:
L_WARN_ON(!l_rtnl_ifaddr_delete(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ifaddr_del_cmd_cb,
netconfig, NULL));
l_rtnl_address_free(netconfig->v4_address);
netconfig->v4_address = NULL;
l_free(l_steal_ptr(netconfig->v4_gateway_str));
/* Fall through. */
case L_DHCP_CLIENT_EVENT_NO_LEASE:
/*
* The requested address is no longer available, try to restart
* the client.
*/
if (!l_dhcp_client_start(client))
l_error("netconfig: Failed to re-start DHCPv4 client "
"for interface %u", netconfig->ifindex);
break;
default:
l_error("netconfig: Received unsupported DHCPv4 event: %d",
event);
}
}
static void netconfig_dhcp6_event_handler(struct l_dhcp6_client *client,
enum l_dhcp6_client_event event,
void *userdata)
{
struct netconfig *netconfig = userdata;
switch (event) {
case L_DHCP6_CLIENT_EVENT_IP_CHANGED:
case L_DHCP6_CLIENT_EVENT_LEASE_OBTAINED:
case L_DHCP6_CLIENT_EVENT_LEASE_RENEWED:
{
const struct l_dhcp6_lease *lease =
l_dhcp6_client_get_lease(netconfig->dhcp6_client);
_auto_(l_free) char *addr_str =
l_dhcp6_lease_get_address(lease);
struct l_rtnl_address *address;
struct l_icmp6_client *icmp6 =
l_dhcp6_client_get_icmp6(netconfig->dhcp6_client);
const struct l_icmp6_router *router =
l_icmp6_client_get_router(icmp6);
char *gateway_str = l_icmp6_router_get_address(router);
if (l_streq0(netconfig->v6_gateway_str, gateway_str))
l_free(gateway_str);
else {
l_free(netconfig->v6_gateway_str);
netconfig->v6_gateway_str = gateway_str;
}
address = l_rtnl_address_new(addr_str,
l_dhcp6_lease_get_prefix_length(lease));
l_rtnl_address_free(netconfig->v6_address);
netconfig->v6_address = address;
netconfig_dns_list_update(netconfig, AF_INET6);
netconfig_domains_update(netconfig, AF_INET6);
netconfig_set_dns(netconfig);
netconfig_set_domains(netconfig);
break;
}
case L_DHCP6_CLIENT_EVENT_LEASE_EXPIRED:
l_debug("Lease for interface %u expired", netconfig->ifindex);
netconfig_dns_list_update(netconfig, AF_INET6);
netconfig_domains_update(netconfig, AF_INET6);
netconfig_set_dns(netconfig);
netconfig_set_domains(netconfig);
l_rtnl_address_free(netconfig->v6_address);
netconfig->v6_address = NULL;
l_free(l_steal_ptr(netconfig->v6_gateway_str));
/* Fall through */
case L_DHCP6_CLIENT_EVENT_NO_LEASE:
if (!l_dhcp6_client_start(netconfig->dhcp6_client))
l_error("netconfig: Failed to re-start DHCPv6 client "
"for interface %u", netconfig->ifindex);
break;
}
}
static void netconfig_remove_v4_address(struct netconfig *netconfig)
{
if (!netconfig->v4_address)
return;
L_WARN_ON(!l_rtnl_ifaddr_delete(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ifaddr_del_cmd_cb,
netconfig, NULL));
l_rtnl_address_free(netconfig->v4_address);
netconfig->v4_address = NULL;
}
static void netconfig_reset_v4(struct netconfig *netconfig)
{
if (netconfig->rtm_protocol) {
netconfig_remove_v4_address(netconfig);
l_strv_free(l_steal_ptr(netconfig->dns4_overrides));
l_strv_free(l_steal_ptr(netconfig->dns4_list));
l_dhcp_client_stop(netconfig->dhcp_client);
netconfig->rtm_protocol = 0;
l_acd_destroy(netconfig->acd);
netconfig->acd = NULL;
l_free(l_steal_ptr(netconfig->v4_gateway_str));
l_free(l_steal_ptr(netconfig->v4_domain));
}
}
static void netconfig_ipv4_acd_event(enum l_acd_event event, void *user_data)
{
struct netconfig *netconfig = user_data;
switch (event) {
case L_ACD_EVENT_AVAILABLE:
L_WARN_ON(!(netconfig->addr4_add_cmd_id =
l_rtnl_ifaddr_add(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ipv4_ifaddr_add_cmd_cb,
netconfig, NULL)));
return;
case L_ACD_EVENT_CONFLICT:
/*
* Conflict found, no IP was actually set so just free/unset
* anything we set prior to starting ACD.
*/
l_error("netconfig: statically configured address conflict!");
l_rtnl_address_free(netconfig->v4_address);
netconfig->v4_address = NULL;
netconfig->rtm_protocol = 0;
break;
case L_ACD_EVENT_LOST:
/*
* Set IP but lost it some time after. Full (IPv4) reset in this
* case.
*/
l_error("netconfig: statically configured address was lost");
netconfig_remove_v4_address(netconfig);
break;
}
}
static bool netconfig_ipv4_select_and_install(struct netconfig *netconfig)
{
struct netdev *netdev = netdev_find(netconfig->ifindex);
bool set_address = (netconfig->rtm_protocol == RTPROT_STATIC);
if (netconfig_use_fils_addr(netconfig, AF_INET)) {
L_AUTO_FREE_VAR(char *, addr_str) = netconfig_ipv4_to_string(
netconfig->fils_override->ipv4_addr);
uint8_t prefix_len = netconfig->fils_override->ipv4_prefix_len;
if (unlikely(!addr_str))
return false;
netconfig->v4_address = l_rtnl_address_new(addr_str,
prefix_len);
if (L_WARN_ON(!netconfig->v4_address))
return false;
l_rtnl_address_set_noprefixroute(netconfig->v4_address, true);
set_address = true;
/*
* TODO: If netconfig->fils_override->ipv4_lifetime is set,
* start a timeout to renew the address using FILS IP Address
* Assignment or perhaps just start the DHCP client at that
* time.
*/
}
if (set_address) {
char ip[INET6_ADDRSTRLEN];
if (L_WARN_ON(!netconfig->v4_address ||
!l_rtnl_address_get_address(
netconfig->v4_address,
ip)))
return false;
netconfig_dns_list_update(netconfig, AF_INET);
netconfig_domains_update(netconfig, AF_INET);
netconfig->acd = l_acd_new(netconfig->ifindex);
l_acd_set_event_handler(netconfig->acd,
netconfig_ipv4_acd_event, netconfig,
NULL);
if (getenv("IWD_ACD_DEBUG"))
l_acd_set_debug(netconfig->acd, do_debug,
"[ACD] ", NULL);
if (!l_acd_start(netconfig->acd, ip)) {
l_error("failed to start ACD, continuing anyways");
l_acd_destroy(netconfig->acd);
netconfig->acd = NULL;
L_WARN_ON(!(netconfig->addr4_add_cmd_id =
l_rtnl_ifaddr_add(rtnl, netconfig->ifindex,
netconfig->v4_address,
netconfig_ipv4_ifaddr_add_cmd_cb,
netconfig, NULL)));
}
return true;
}
l_dhcp_client_set_address(netconfig->dhcp_client, ARPHRD_ETHER,
netdev_get_address(netdev), ETH_ALEN);
if (l_dhcp_client_start(netconfig->dhcp_client))
return true;
l_error("netconfig: Failed to start DHCPv4 client for interface %u",
netconfig->ifindex);
return false;
}
static bool netconfig_ipv6_select_and_install(struct netconfig *netconfig)
{
struct netdev *netdev = netdev_find(netconfig->ifindex);
if (netconfig->rtm_v6_protocol == RTPROT_UNSPEC) {
l_debug("IPV6 configuration disabled");
return true;
}
sysfs_write_ipv6_setting(netdev_get_name(netdev), "disable_ipv6", "0");
if (netconfig_use_fils_addr(netconfig, AF_INET6)) {
uint8_t prefix_len = netconfig->fils_override->ipv6_prefix_len;
L_AUTO_FREE_VAR(char *, addr_str) = netconfig_ipv6_to_string(
netconfig->fils_override->ipv6_addr);
if (unlikely(!addr_str))
return false;
netconfig->v6_address = l_rtnl_address_new(addr_str,
prefix_len);
if (L_WARN_ON(unlikely(!netconfig->v6_address)))
return false;
l_rtnl_address_set_noprefixroute(netconfig->v6_address, true);
/*
* TODO: If netconfig->fils_override->ipv6_lifetime is set,
* start a timeout to renew the address using FILS IP Address
* Assignment or perhaps just start the DHCP client at that
* time.
*/
}
if (netconfig->v6_address) {
netconfig_dns_list_update(netconfig, AF_INET6);
L_WARN_ON(!(netconfig->addr6_add_cmd_id =
l_rtnl_ifaddr_add(rtnl, netconfig->ifindex,
netconfig->v6_address,
netconfig_ipv6_ifaddr_add_cmd_cb,
netconfig, NULL)));
return true;
}
/* DHCPv6 or RA, update MAC */
l_dhcp6_client_set_address(netconfig->dhcp6_client, ARPHRD_ETHER,
netdev_get_address(netdev), ETH_ALEN);
return true;
}
static int validate_dns_list(int family, char **dns_list)
{
unsigned int n_valid = 0;
struct in_addr in_addr;
struct in6_addr in6_addr;
char **p;
for (p = dns_list; *p; p++) {
int r;
if (family == AF_INET)
r = inet_pton(AF_INET, *p, &in_addr);
else if (family == AF_INET6)
r = inet_pton(AF_INET6, *p, &in6_addr);
else
r = -EAFNOSUPPORT;
if (r > 0) {
n_valid += 1;
continue;
}
l_error("netconfig: Invalid DNS address '%s'.", *p);
return -EINVAL;
}
return n_valid;
}
bool netconfig_load_settings(struct netconfig *netconfig,
const struct l_settings *active_settings)
{
_auto_(l_free) char *mdns = NULL;
bool send_hostname;
bool v6_enabled;
char hostname[HOST_NAME_MAX + 1];
_auto_(l_strv_free) char **dns4_overrides = NULL;
_auto_(l_strv_free) char **dns6_overrides = NULL;
_auto_(l_rtnl_address_free) struct l_rtnl_address *v4_address = NULL;
_auto_(l_rtnl_address_free) struct l_rtnl_address *v6_address = NULL;
dns4_overrides = l_settings_get_string_list(active_settings,
"IPv4", "DNS", ' ');
if (dns4_overrides) {
int r = validate_dns_list(AF_INET, dns4_overrides);
if (unlikely(r <= 0)) {
l_strfreev(dns4_overrides);
dns4_overrides = NULL;
if (r < 0)
return false;
}
if (r == 0)
l_error("netconfig: Empty IPv4.DNS entry, skipping...");
}
dns6_overrides = l_settings_get_string_list(active_settings,
"IPv6", "DNS", ' ');
if (dns6_overrides) {
int r = validate_dns_list(AF_INET6, dns6_overrides);
if (unlikely(r <= 0)) {
l_strfreev(dns6_overrides);
dns6_overrides = NULL;
if (r < 0)
return false;
}
if (r == 0)
l_error("netconfig: Empty IPv6.DNS entry, skipping...");
}
if (!l_settings_get_bool(active_settings,
"IPv4", "SendHostname", &send_hostname))
send_hostname = false;
if (send_hostname) {
if (gethostname(hostname, sizeof(hostname)) != 0) {
l_warn("netconfig: Unable to get hostname. "
"Error %d: %s", errno, strerror(errno));
send_hostname = false;
}
}
mdns = l_settings_get_string(active_settings,
"Network", "MulticastDNS");
if (l_settings_has_key(active_settings, "IPv4", "Address")) {
v4_address = netconfig_get_static4_address(active_settings);
if (unlikely(!v4_address)) {
l_error("netconfig: Can't parse IPv4 address");
return false;
}
}
if (!l_settings_get_bool(active_settings, "IPv6",
"Enabled", &v6_enabled))
v6_enabled = ipv6_enabled;
if (l_settings_has_key(active_settings, "IPv6", "Address")) {
v6_address = netconfig_get_static6_address(active_settings);
if (unlikely(!v6_address)) {
l_error("netconfig: Can't parse IPv6 address");
return false;
}
}
/* No more validation steps for now, commit new values */
netconfig->rtm_protocol = v4_address ? RTPROT_STATIC : RTPROT_DHCP;
if (!v6_enabled)
netconfig->rtm_v6_protocol = RTPROT_UNSPEC;
else if (v6_address)
netconfig->rtm_v6_protocol = RTPROT_STATIC;
else
netconfig->rtm_v6_protocol = RTPROT_DHCP;
if (send_hostname)
l_dhcp_client_set_hostname(netconfig->dhcp_client, hostname);
netconfig_free_settings(netconfig);
if (netconfig->rtm_protocol == RTPROT_STATIC)
netconfig->v4_address = l_steal_ptr(v4_address);
if (netconfig->rtm_v6_protocol == RTPROT_STATIC)
netconfig->v6_address = l_steal_ptr(v6_address);
netconfig->active_settings = active_settings;
netconfig->dns4_overrides = l_steal_ptr(dns4_overrides);
netconfig->dns6_overrides = l_steal_ptr(dns6_overrides);
netconfig->mdns = l_steal_ptr(mdns);
return true;
}
bool netconfig_configure(struct netconfig *netconfig,
netconfig_notify_func_t notify, void *user_data)
{
netconfig->notify = notify;
netconfig->user_data = user_data;
if (unlikely(!netconfig_ipv4_select_and_install(netconfig)))
return false;
if (unlikely(!netconfig_ipv6_select_and_install(netconfig)))
return false;
resolve_set_mdns(netconfig->resolve, netconfig->mdns);
return true;
}
bool netconfig_reconfigure(struct netconfig *netconfig, bool set_arp_gw)
{
/*
* Starting with kernel 4.20, ARP cache is flushed when the netdev
* detects NO CARRIER. This can result in unnecessarily long delays
* (about 1 second on some networks) due to ARP query response being
* lost or delayed. Try to force the gateway into the ARP cache
* to alleviate this
*/
if (set_arp_gw)
netconfig_gateway_to_arp(netconfig);
if (netconfig->rtm_protocol == RTPROT_DHCP) {
/* TODO l_dhcp_client sending a DHCP inform request */
}
if (netconfig->rtm_v6_protocol == RTPROT_DHCP) {
/* TODO l_dhcp_v6_client sending a DHCP inform request */
}
return true;
}
bool netconfig_reset(struct netconfig *netconfig)
{
struct netdev *netdev = netdev_find(netconfig->ifindex);
if (netconfig->route4_add_gateway_cmd_id) {
l_netlink_cancel(rtnl, netconfig->route4_add_gateway_cmd_id);
netconfig->route4_add_gateway_cmd_id = 0;
}
if (netconfig->route6_add_cmd_id) {
l_netlink_cancel(rtnl, netconfig->route6_add_cmd_id);
netconfig->route6_add_cmd_id = 0;
}
if (netconfig->addr4_add_cmd_id) {
l_netlink_cancel(rtnl, netconfig->addr4_add_cmd_id);
netconfig->addr4_add_cmd_id = 0;
}
if (netconfig->addr6_add_cmd_id) {
l_netlink_cancel(rtnl, netconfig->addr6_add_cmd_id);
netconfig->addr6_add_cmd_id = 0;
}
if (netconfig->rtm_protocol || netconfig->rtm_v6_protocol)
resolve_revert(netconfig->resolve);
netconfig_reset_v4(netconfig);
if (netconfig->rtm_v6_protocol) {
l_rtnl_address_free(netconfig->v6_address);
netconfig->v6_address = NULL;
l_strv_free(l_steal_ptr(netconfig->dns6_overrides));
l_strv_free(l_steal_ptr(netconfig->dns6_list));
l_dhcp6_client_stop(netconfig->dhcp6_client);
netconfig->rtm_v6_protocol = 0;
sysfs_write_ipv6_setting(netdev_get_name(netdev),
"disable_ipv6", "1");
l_free(l_steal_ptr(netconfig->v6_gateway_str));
l_strv_free(l_steal_ptr(netconfig->v6_domains));
}
l_free(l_steal_ptr(netconfig->fils_override));
return true;
}
char *netconfig_get_dhcp_server_ipv4(struct netconfig *netconfig)
{
const struct l_dhcp_lease *lease;
if (!netconfig->dhcp_client)
return NULL;
lease = l_dhcp_client_get_lease(netconfig->dhcp_client);
if (!lease)
return NULL;
return l_dhcp_lease_get_server_id(lease);
}
bool netconfig_get_fils_ip_req(struct netconfig *netconfig,
struct ie_fils_ip_addr_request_info *info)
{
/*
* Fill in the fields used for building the FILS IP Address Assigment
* IE during connection if we're configured to do automatic network
* configuration (usually DHCP). If we're configured with static
* values return false to mean the IE should not be sent.
*/
if (netconfig->rtm_protocol != RTPROT_DHCP &&
netconfig->rtm_v6_protocol != RTPROT_DHCP)
return false;
memset(info, 0, sizeof(*info));
info->ipv4 = (netconfig->rtm_protocol == RTPROT_DHCP);
info->ipv6 = (netconfig->rtm_v6_protocol == RTPROT_DHCP);
info->dns = (info->ipv4 && !netconfig->dns4_overrides) ||
(info->ipv6 && !netconfig->dns6_overrides);
return true;
}
void netconfig_handle_fils_ip_resp(struct netconfig *netconfig,
const struct ie_fils_ip_addr_response_info *info)
{
l_free(netconfig->fils_override);
netconfig->fils_override = l_memdup(info, sizeof(*info));
}
struct netconfig *netconfig_new(uint32_t ifindex)
{
struct netdev *netdev = netdev_find(ifindex);
struct netconfig *netconfig;
struct l_icmp6_client *icmp6;
const char *debug_level = NULL;
int dhcp_priority = L_LOG_INFO;
if (!netconfig_list)
return NULL;
l_debug("Starting netconfig for interface: %d", ifindex);
netconfig = netconfig_find(ifindex);
if (netconfig)
return netconfig;
netconfig = l_new(struct netconfig, 1);
netconfig->ifindex = ifindex;
netconfig->resolve = resolve_new(ifindex);
netconfig->dhcp_client = l_dhcp_client_new(ifindex);
l_dhcp_client_set_event_handler(netconfig->dhcp_client,
netconfig_ipv4_dhcp_event_handler,
netconfig, NULL);
debug_level = getenv("IWD_DHCP_DEBUG");
if (debug_level != NULL) {
if (!strcmp("debug", debug_level))
dhcp_priority = L_LOG_DEBUG;
else if (!strcmp("info", debug_level))
dhcp_priority = L_LOG_INFO;
else if (!strcmp("warn", debug_level))
dhcp_priority = L_LOG_WARNING;
else if (!strcmp("error", debug_level))
dhcp_priority = L_LOG_ERR;
else /* Default for backwards compatibility */
dhcp_priority = L_LOG_DEBUG;
}
l_dhcp_client_set_debug(netconfig->dhcp_client, do_debug,
"[DHCPv4] ", NULL, dhcp_priority);
netconfig->dhcp6_client = l_dhcp6_client_new(ifindex);
l_dhcp6_client_set_event_handler(netconfig->dhcp6_client,
netconfig_dhcp6_event_handler,
netconfig, NULL);
l_dhcp6_client_set_lla_randomized(netconfig->dhcp6_client, true);
l_dhcp6_client_set_nodelay(netconfig->dhcp6_client, true);
l_dhcp6_client_set_rtnl(netconfig->dhcp6_client, rtnl);
if (getenv("IWD_DHCP_DEBUG"))
l_dhcp6_client_set_debug(netconfig->dhcp6_client, do_debug,
"[DHCPv6] ", NULL);
icmp6 = l_dhcp6_client_get_icmp6(netconfig->dhcp6_client);
l_icmp6_client_set_rtnl(icmp6, rtnl);
l_icmp6_client_set_route_priority(icmp6, ROUTE_PRIORITY_OFFSET);
l_queue_push_tail(netconfig_list, netconfig);
sysfs_write_ipv6_setting(netdev_get_name(netdev), "accept_ra", "0");
sysfs_write_ipv6_setting(netdev_get_name(netdev), "disable_ipv6", "1");
return netconfig;
}
void netconfig_destroy(struct netconfig *netconfig)
{
if (!netconfig_list)
return;
l_debug("");
l_queue_remove(netconfig_list, netconfig);
netconfig_reset(netconfig);
resolve_free(netconfig->resolve);
netconfig_free(netconfig);
}
bool netconfig_enabled(void)
{
bool enabled;
return l_settings_get_bool(iwd_get_config(), "General",
"EnableNetworkConfiguration",
&enabled) && enabled;
}
static int netconfig_init(void)
{
uint32_t r;
if (netconfig_list)
return -EALREADY;
rtnl = iwd_get_rtnl();
r = l_netlink_register(rtnl, RTNLGRP_IPV4_IFADDR,
netconfig_ifaddr_notify, NULL, NULL);
if (!r) {
l_error("netconfig: Failed to register for RTNL link address"
" notifications.");
goto error;
}
r = l_rtnl_ifaddr4_dump(rtnl, netconfig_ifaddr_cmd_cb, NULL, NULL);
if (!r) {
l_error("netconfig: Failed to get addresses from RTNL link.");
goto error;
}
r = l_netlink_register(rtnl, RTNLGRP_IPV6_IFADDR,
netconfig_ifaddr_ipv6_notify, NULL, NULL);
if (!r) {
l_error("netconfig: Failed to register for RTNL link IPv6 "
"address notifications.");
goto error;
}
r = l_rtnl_ifaddr6_dump(rtnl, netconfig_ifaddr_ipv6_cmd_cb, NULL,
NULL);
if (!r) {
l_error("netconfig: Failed to get IPv6 addresses from RTNL"
" link.");
goto error;
}
if (!l_settings_get_uint(iwd_get_config(), "Network",
"RoutePriorityOffset",
&ROUTE_PRIORITY_OFFSET))
ROUTE_PRIORITY_OFFSET = 300;
if (!l_settings_get_bool(iwd_get_config(), "Network",
"EnableIPv6",
&ipv6_enabled))
ipv6_enabled = false;
netconfig_list = l_queue_new();
return 0;
error:
rtnl = NULL;
return r;
}
static void netconfig_exit(void)
{
if (!netconfig_list)
return;
rtnl = NULL;
l_queue_destroy(netconfig_list, netconfig_free);
}
IWD_MODULE(netconfig, netconfig_init, netconfig_exit)
View Git Blame Copy Permalink