X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=config.c;h=8472d44f0ff9c9dcaa9e4d59699a45921cca8265;hp=7ba687517618016b72fc13e17687d05ba7e06461;hb=b8f0ce8319a43d629c8de86df6951892b7e8d813;hpb=4ed89555c4b5e748ed407f7694b5c9b32eea2e54 diff --git a/config.c b/config.c index 7ba6875..8472d44 100644 --- a/config.c +++ b/config.c @@ -2,14 +2,19 @@ #include #include +#include + #include "netifd.h" #include "interface.h" +#include "interface-ip.h" +#include "proto.h" +#include "config.h" -struct uci_context *uci_ctx; -static struct uci_package *uci_network; bool config_init = false; -static struct blob_buf b; +static struct uci_context *uci_ctx; +static struct uci_package *uci_network; +static struct blob_buf b; static void uci_attr_to_blob(struct blob_buf *b, const char *str, const char *name, enum blobmsg_type type) @@ -72,7 +77,7 @@ static void uci_array_to_blob(struct blob_buf *b, struct uci_option *o, static void __uci_to_blob(struct blob_buf *b, struct uci_section *s, const struct config_param_list *p) { - const struct blobmsg_policy *attr; + const struct blobmsg_policy *attr = NULL; struct uci_element *e; struct uci_option *o; void *array; @@ -127,8 +132,8 @@ config_parse_bridge_interface(struct uci_section *s) blobmsg_add_string(&b, "name", name); uci_to_blob(&b, s, bridge_device_type.config_params); - if (!bridge_device_type.create(b.head)) { - DPRINTF("Failed to create bridge for interface '%s'\n", s->e.name); + if (!device_create(name, &bridge_device_type, b.head)) { + D(INTERFACE, "Failed to create bridge for interface '%s'\n", s->e.name); return -EINVAL; } @@ -140,8 +145,10 @@ config_parse_bridge_interface(struct uci_section *s) static void config_parse_interface(struct uci_section *s) { + struct interface *iface; const char *type; - DPRINTF("Create interface '%s'\n", s->e.name); + struct blob_attr *config; + struct device *dev; blob_buf_init(&b, 0); @@ -151,10 +158,57 @@ config_parse_interface(struct uci_section *s) return; uci_to_blob(&b, s, &interface_attr_list); - interface_alloc(s->e.name, s, b.head); + iface = calloc(1, sizeof(*iface)); + if (!iface) + return; + + interface_init(iface, s->e.name, b.head); + + if (iface->proto_handler && iface->proto_handler->config_params) + uci_to_blob(&b, s, iface->proto_handler->config_params); + + config = malloc(blob_pad_len(b.head)); + if (!config) { + free(iface); + return; + } + + memcpy(config, b.head, blob_pad_len(b.head)); + interface_add(iface, config); + + /* + * need to look up the interface name again, in case of config update, + * the pointer will have changed + */ + iface = vlist_find(&interfaces, s->e.name, iface, node); + if (!iface) + return; + + dev = iface->main_dev.dev; + if (!dev || !dev->default_config) + return; + + blob_buf_init(&b, 0); + uci_to_blob(&b, s, dev->type->config_params); + if (blob_len(b.head) == 0) + return; + + device_set_config(dev, dev->type, b.head); } -void +static void +config_parse_route(struct uci_section *s, bool v6) +{ + void *route; + + blob_buf_init(&b, 0); + route = blobmsg_open_array(&b, "route"); + uci_to_blob(&b, s, &route_attr_list); + blobmsg_close_array(&b, route); + interface_ip_add_route(NULL, blob_data(b.head), v6); +} + +static void config_init_devices(void) { struct uci_element *e; @@ -162,56 +216,198 @@ config_init_devices(void) uci_foreach_element(&uci_network->sections, e) { struct uci_section *s = uci_to_section(e); const struct device_type *devtype; - const char *type; + const char *type, *name; if (strcmp(s->type, "device") != 0) continue; - blob_buf_init(&b, 0); + name = uci_lookup_option_string(uci_ctx, s, "name"); + if (!name) + continue; + type = uci_lookup_option_string(uci_ctx, s, "type"); if (type && !strcmp(type, "bridge")) devtype = &bridge_device_type; else devtype = &simple_device_type; + blob_buf_init(&b, 0); uci_to_blob(&b, s, devtype->config_params); - devtype->create(b.head); + device_create(name, devtype, b.head); } } -void -config_init_interfaces(const char *name) +bool +config_diff(struct blob_attr **tb1, struct blob_attr **tb2, + const struct config_param_list *config, unsigned long *diff) +{ + bool ret = false; + int i; + + for (i = 0; i < config->n_params; i++) { + if (!tb1[i] && !tb2[i]) + continue; + + if (!!tb1[i] != !!tb2[i]) + goto mark; + + if (blob_len(tb1[i]) != blob_len(tb2[i])) + goto mark; + + if (memcmp(tb1[i], tb2[i], blob_raw_len(tb1[i])) != 0) + goto mark; + + continue; + +mark: + ret = true; + if (diff) + set_bit(diff, i); + else + return ret; + } + + return ret; +} + + +static bool +__config_check_equal(struct blob_attr *c1, struct blob_attr *c2, + const struct config_param_list *config) +{ + struct blob_attr **tb1, **tb2; + + if (!!c1 ^ !!c2) + return false; + + if (!c1 && !c2) + return true; + + tb1 = alloca(config->n_params * sizeof(struct blob_attr *)); + blobmsg_parse(config->params, config->n_params, tb1, + blob_data(c1), blob_len(c1)); + + tb2 = alloca(config->n_params * sizeof(struct blob_attr *)); + blobmsg_parse(config->params, config->n_params, tb2, + blob_data(c2), blob_len(c2)); + + return !config_diff(tb1, tb2, config, NULL); +} + +bool +config_check_equal(struct blob_attr *c1, struct blob_attr *c2, + const struct config_param_list *config) +{ + int i; + + if (!__config_check_equal(c1, c2, config)) + return false; + + for (i = 0; i < config->n_next; i++) { + if (!__config_check_equal(c1, c2, config->next[i])) + return false; + } + + return true; +} + +struct blob_attr * +config_memdup(struct blob_attr *attr) +{ + struct blob_attr *ret; + int size = blob_pad_len(attr); + + ret = malloc(size); + if (!ret) + return NULL; + + memcpy(ret, attr, size); + return ret; +} + +static struct uci_package * +config_init_package(const char *config) { - struct uci_context *ctx; + struct uci_context *ctx = uci_ctx; struct uci_package *p = NULL; + + if (!ctx) { + ctx = uci_alloc_context(); + uci_ctx = ctx; + +#ifdef DUMMY_MODE + uci_set_confdir(ctx, "./config"); + uci_set_savedir(ctx, "./tmp"); +#endif + } else { + p = uci_lookup_package(ctx, config); + if (p) + uci_unload(ctx, p); + } + + if (uci_load(ctx, config, &p)) + return NULL; + + return p; +} + +static void +config_init_interfaces(void) +{ + struct uci_element *e; + + uci_foreach_element(&uci_network->sections, e) { + struct uci_section *s = uci_to_section(e); + + if (!strcmp(s->type, "interface")) + config_parse_interface(s); + } +} + +static void +config_init_routes(void) +{ + struct interface *iface; struct uci_element *e; - ctx = uci_alloc_context(); - uci_ctx = ctx; + vlist_for_each_element(&interfaces, iface, node) + interface_ip_update_start(&iface->config_ip); + + uci_foreach_element(&uci_network->sections, e) { + struct uci_section *s = uci_to_section(e); + + if (!strcmp(s->type, "route")) + config_parse_route(s, false); + else if (!strcmp(s->type, "route6")) + config_parse_route(s, true); + } - uci_set_confdir(ctx, "./config"); + vlist_for_each_element(&interfaces, iface, node) + interface_ip_update_complete(&iface->config_ip); +} - if (uci_load(ctx, "network", &p)) { +void +config_init_all(void) +{ + uci_network = config_init_package("network"); + if (!uci_network) { fprintf(stderr, "Failed to load network config\n"); return; } - uci_network = p; config_init = true; + device_lock(); + device_reset_config(); config_init_devices(); + config_init_interfaces(); + config_init_routes(); - uci_foreach_element(&p->sections, e) { - struct uci_section *s = uci_to_section(e); - - if (name && strcmp(s->e.name, name) != 0) - continue; - - if (!strcmp(s->type, "interface")) - config_parse_interface(s); - } - device_free_all(); config_init = false; + device_unlock(); + device_reset_old(); + device_init_pending(); + device_free_unused(NULL); interface_start_pending(); }