#include "networkd.h"

#include "net-util.h"

#include "path-util.h"

#include "conf-files.h"

#include "conf-parser.h"

#include "util.h"

static int network_load_one(Manager *manager, const char *filename) {

_cleanup_network_free_ Network *network = NULL;

_cleanup_fclose_ FILE *file = NULL;

Route *route;

Address *address;

int r;

assert(manager);

assert(filename);

file = fopen(filename, "re");

if (!file) {

if (errno == ENOENT)

return 0;

else

return errno;

}

network = new0(Network, 1);

if (!network)

return log_oom();

network->manager = manager;

LIST_HEAD_INIT(network->static_addresses);

LIST_HEAD_INIT(network->static_routes);

network->addresses_by_section = hashmap_new(uint64_hash_func, uint64_compare_func);

if (!network->addresses_by_section)

return log_oom();

network->routes_by_section = hashmap_new(uint64_hash_func, uint64_compare_func);

if (!network->routes_by_section)

return log_oom();

network->filename = strdup(filename);

if (!network->filename)

return log_oom();

network->dhcp_dns = true;

r = config_parse(NULL, filename, file, "Match\0Network\0Address\0Route\0DHCPv4\0", config_item_perf_lookup,

(void*) network_gperf_lookup, false, false, network);

if (r < 0) {

log_warning("Could not parse config file %s: %s", filename, strerror(-r));

return r;

}

LIST_PREPEND(networks, manager->networks, network);

LIST_FOREACH(static_routes, route, network->static_routes) {

if (!route->family) {

log_warning("Route section without Gateway field configured in %s. "

"Ignoring", filename);

return 0;

}

if (route->dst_family && route->family != route->dst_family) {

log_warning("Route section with conflicting Gateway and Destination address "

"family configured in %s. Ignoring", filename);

return 0;

}

}

LIST_FOREACH(static_addresses, address, network->static_addresses) {

if (!address->family) {

log_warning("Address section without Address field configured in %s. "

"Ignoring", filename);

return 0;

}

}

network = NULL;

return 0;

}

int network_load(Manager *manager) {

Network *network;

_cleanup_strv_free_ char **files = NULL;

char **f;

int r;

assert(manager);

while ((network = manager->networks))

network_free(network);

r = conf_files_list_strv(&files, ".network", NULL, network_dirs);

if (r < 0) {

log_error("Failed to enumerate network files: %s", strerror(-r));

return r;

}

STRV_FOREACH_BACKWARDS(f, files) {

r = network_load_one(manager, *f);

if (r < 0)

return r;

}

return 0;

}

void network_free(Network *network) {

Route *route;

Address *address;

if (!network)

return;

free(network->filename);

free(network->match_mac);

free(network->match_path);

free(network->match_driver);

free(network->match_type);

free(network->match_name);

free(network->description);

address_free(network->dns);

while ((route = network->static_routes))

route_free(route);

while ((address = network->static_addresses))

address_free(address);

hashmap_free(network->addresses_by_section);

hashmap_free(network->routes_by_section);

if (network->manager && network->manager->networks)

LIST_REMOVE(networks, network->manager->networks, network);

free(network);

}

int network_get(Manager *manager, struct udev_device *device, Network **ret) {

Network *network;

assert(manager);

assert(device);

assert(ret);

LIST_FOREACH(networks, network, manager->networks) {

if (net_match_config(network->match_mac, network->match_path,

network->match_driver, network->match_type,

network->match_name,

udev_device_get_sysattr_value(device, "address"),

udev_device_get_property_value(device, "ID_PATH"),

udev_device_get_driver(device),

udev_device_get_devtype(device),

udev_device_get_sysname(device))) {

log_debug("%s: found matching network '%s'",

udev_device_get_sysname(device),

network->filename);

*ret = network;

return 0;

}

}

*ret = NULL;

return -ENOENT;

}

int network_apply(Manager *manager, Network *network, Link *link) {

int r;

link->network = network;

r = link_configure(link);

if (r < 0)

return r;

if (network->dns) {

r = manager_update_resolv_conf(manager);

if (r < 0)

return r;

}

return 0;

}

int config_parse_bridge(const char *unit,

const char *filename,

unsigned line,

const char *section,

unsigned section_line,

const char *lvalue,

int ltype,

const char *rvalue,

void *data,

void *userdata) {

Network *network = userdata;

Bridge *bridge;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

r = bridge_get(network->manager, rvalue, &bridge);

if (r < 0) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"Bridge is invalid, ignoring assignment: %s", rvalue);

return 0;

}

network->bridge = bridge;

return 0;

}