config.c

   1 /*
   2  * netifd - network interface daemon
   3  * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14 #define _GNU_SOURCE
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18
  19 #include <uci.h>
  20
  21 #include <libubox/blobmsg_json.h>
  22
  23 #include "netifd.h"
  24 #include "interface.h"
  25 #include "interface-ip.h"
  26 #include "iprule.h"
  27 #include "proto.h"
  28 #include "wireless.h"
  29 #include "config.h"
  30
  31 bool config_init = false;
  32
  33 static struct uci_context *uci_ctx;
  34 static struct uci_package *uci_network;
  35 static struct uci_package *uci_wireless;
  36 static struct blob_attr *board_netdevs;
  37 static struct blob_buf b;
  38
  39 static int
  40 config_section_idx(struct uci_section *s)
  41 {
  42         struct uci_element *e;
  43         int idx = 0;
  44
  45         uci_foreach_element(&uci_wireless->sections, e) {
  46                 struct uci_section *cur = uci_to_section(e);
  47
  48                 if (s == cur)
  49                         return idx;
  50
  51                 if (!strcmp(cur->type, s->type))
  52                         idx++;
  53         }
  54
  55         return -1;
  56 }
  57
  58 static bool
  59 config_bridge_has_vlans(const char *br_name)
  60 {
  61         struct uci_element *e;
  62
  63         uci_foreach_element(&uci_network->sections, e) {
  64                 struct uci_section *s = uci_to_section(e);
  65                 const char *name;
  66
  67                 if (strcmp(s->type, "bridge-vlan") != 0)
  68                         continue;
  69
  70                 name = uci_lookup_option_string(uci_ctx, s, "device");
  71                 if (!name)
  72                         continue;
  73
  74                 if (!strcmp(name, br_name))
  75                         return true;
  76         }
  77
  78         return false;
  79 }
  80
  81 static void
  82 config_fixup_bridge_var(struct uci_section *s, const char *name, const char *val)
  83 {
  84         struct uci_ptr ptr = {
  85                 .p = s->package,
  86                 .s = s,
  87                 .option = name,
  88                 .value = val,
  89         };
  90
  91         uci_lookup_ptr(uci_ctx, &ptr, NULL, false);
  92         if (ptr.o)
  93                 return;
  94
  95         uci_set(uci_ctx, &ptr);
  96 }
  97
  98 /**
  99  * config_fixup_bridge_ports - translate deprecated configs
 100  *
 101  * Old configs used "ifname" option for specifying bridge ports. For backward
 102  * compatibility translate it into the new "ports" option.
 103  */
 104 static void config_fixup_bridge_ports(struct uci_section *s)
 105 {
 106         struct uci_ptr ptr = {
 107                 .p = s->package,
 108                 .s = s,
 109                 .option = "ifname",
 110         };
 111
 112         if (uci_lookup_option(uci_ctx, s, "ports"))
 113                 return;
 114
 115         uci_lookup_ptr(uci_ctx, &ptr, NULL, false);
 116         if (!ptr.o)
 117                 return;
 118
 119         ptr.value = "ports";
 120         uci_rename(uci_ctx, &ptr);
 121 }
 122
 123 static void
 124 config_fixup_bridge_vlan_filtering(struct uci_section *s, const char *name)
 125 {
 126         bool has_vlans = config_bridge_has_vlans(name);
 127
 128         config_fixup_bridge_var(s, "__has_vlans", has_vlans ? "1" : "0");
 129
 130         if (!has_vlans)
 131                 return;
 132
 133         config_fixup_bridge_var(s, "vlan_filtering", "1");
 134 }
 135
 136 static int
 137 config_parse_bridge_interface(struct uci_section *s, struct device_type *devtype)
 138 {
 139         char *name;
 140
 141         name = alloca(strlen(s->e.name) + strlen(devtype->name_prefix) + 2);
 142         sprintf(name, "%s-%s", devtype->name_prefix, s->e.name);
 143         blobmsg_add_string(&b, "name", name);
 144
 145         config_fixup_bridge_ports(s);
 146         config_fixup_bridge_vlan_filtering(s, name);
 147         uci_to_blob(&b, s, devtype->config_params);
 148         if (!device_create(name, devtype, b.head)) {
 149                 D(INTERFACE, "Failed to create '%s' device for interface '%s'",
 150                         devtype->name, s->e.name);
 151         }
 152
 153         blob_buf_init(&b, 0);
 154         blobmsg_add_string(&b, "ifname", name);
 155         return 0;
 156 }
 157
 158 static void
 159 config_parse_interface(struct uci_section *s, bool alias)
 160 {
 161         struct interface *iface;
 162         const char *type = NULL, *disabled;
 163         struct blob_attr *config;
 164         bool bridge = false;
 165         struct device_type *devtype = NULL;
 166
 167         disabled = uci_lookup_option_string(uci_ctx, s, "disabled");
 168         if (disabled && !strcmp(disabled, "1"))
 169                 return;
 170
 171         blob_buf_init(&b, 0);
 172
 173         if (!alias)
 174                 type = uci_lookup_option_string(uci_ctx, s, "type");
 175
 176         if (type)
 177                 devtype = device_type_get(type);
 178
 179         if (devtype && devtype->bridge_capability) {
 180                 if (config_parse_bridge_interface(s, devtype))
 181                         return;
 182
 183                 bridge = true;
 184         }
 185
 186         uci_to_blob(&b, s, &interface_attr_list);
 187
 188         iface = interface_alloc(s->e.name, b.head, false);
 189         if (!iface)
 190                 return;
 191
 192         if (iface->proto_handler && iface->proto_handler->config_params)
 193                 uci_to_blob(&b, s, iface->proto_handler->config_params);
 194
 195         if (!bridge && uci_to_blob(&b, s, simple_device_type.config_params))
 196                 iface->device_config = true;
 197
 198         config = blob_memdup(b.head);
 199         if (!config)
 200                 goto error;
 201
 202         if (alias) {
 203                 if (!interface_add_alias(iface, config))
 204                         goto error_free_config;
 205         } else {
 206                 if (!interface_add(iface, config))
 207                         goto error_free_config;
 208         }
 209         return;
 210
 211 error_free_config:
 212         free(config);
 213 error:
 214         free(iface);
 215 }
 216
 217 static void
 218 config_parse_route(struct uci_section *s, bool v6)
 219 {
 220         void *route;
 221
 222         blob_buf_init(&b, 0);
 223         route = blobmsg_open_array(&b, "route");
 224         uci_to_blob(&b, s, &route_attr_list);
 225         blobmsg_close_array(&b, route);
 226         interface_ip_add_route(NULL, blob_data(b.head), v6);
 227 }
 228
 229 static void
 230 config_parse_neighbor(struct uci_section *s, bool v6)
 231 {
 232         void *neighbor;
 233         blob_buf_init(&b,0);
 234         neighbor = blobmsg_open_array(&b, "neighbor");
 235         uci_to_blob(&b,s, &neighbor_attr_list);
 236         blobmsg_close_array(&b, neighbor);
 237         interface_ip_add_neighbor(NULL, blob_data(b.head), v6);
 238 }
 239
 240 static void
 241 config_parse_rule(struct uci_section *s, bool v6)
 242 {
 243         void *rule;
 244
 245         blob_buf_init(&b, 0);
 246         rule = blobmsg_open_array(&b, "rule");
 247         uci_to_blob(&b, s, &rule_attr_list);
 248         blobmsg_close_array(&b, rule);
 249         iprule_add(blob_data(b.head), v6);
 250 }
 251
 252 static void
 253 config_init_devices(bool bridge)
 254 {
 255         struct uci_element *e;
 256
 257         uci_foreach_element(&uci_network->sections, e) {
 258                 const struct uci_blob_param_list *params = NULL;
 259                 struct uci_section *s = uci_to_section(e);
 260                 struct device_type *devtype = NULL;
 261                 struct device *dev;
 262                 const char *type, *name;
 263
 264                 if (strcmp(s->type, "device") != 0)
 265                         continue;
 266
 267                 name = uci_lookup_option_string(uci_ctx, s, "name");
 268                 if (!name)
 269                         continue;
 270
 271                 type = uci_lookup_option_string(uci_ctx, s, "type");
 272                 if (type)
 273                         devtype = device_type_get(type);
 274
 275                 if (bridge != (devtype && devtype->bridge_capability))
 276                         continue;
 277
 278                 if (devtype)
 279                         params = devtype->config_params;
 280                 if (!params)
 281                         params = simple_device_type.config_params;
 282
 283                 if (devtype && devtype->bridge_capability) {
 284                         config_fixup_bridge_ports(s);
 285                         config_fixup_bridge_vlan_filtering(s, name);
 286                 }
 287
 288                 blob_buf_init(&b, 0);
 289                 uci_to_blob(&b, s, params);
 290                 if (devtype) {
 291                         dev = device_create(name, devtype, b.head);
 292                         if (!dev)
 293                                 continue;
 294                 } else {
 295                         dev = device_get(name, 1);
 296                         if (!dev)
 297                                 continue;
 298
 299                         dev->current_config = true;
 300                         device_apply_config(dev, dev->type, b.head);
 301                 }
 302                 dev->default_config = false;
 303         }
 304 }
 305
 306 static void
 307 config_parse_vlan(struct device *dev, struct uci_section *s)
 308 {
 309         enum {
 310                 BRVLAN_ATTR_VID,
 311                 BRVLAN_ATTR_LOCAL,
 312                 BRVLAN_ATTR_PORTS,
 313                 BRVLAN_ATTR_ALIAS,
 314                 __BRVLAN_ATTR_MAX,
 315         };
 316         static const struct blobmsg_policy vlan_attrs[__BRVLAN_ATTR_MAX] = {
 317                 [BRVLAN_ATTR_VID] = { "vlan", BLOBMSG_TYPE_INT32 },
 318                 [BRVLAN_ATTR_LOCAL] = { "local", BLOBMSG_TYPE_BOOL },
 319                 [BRVLAN_ATTR_PORTS] = { "ports", BLOBMSG_TYPE_ARRAY },
 320                 [BRVLAN_ATTR_ALIAS] = { "alias", BLOBMSG_TYPE_ARRAY },
 321         };
 322         static const struct uci_blob_param_info vlan_attr_info[__BRVLAN_ATTR_MAX] = {
 323                 [BRVLAN_ATTR_PORTS] = { .type = BLOBMSG_TYPE_STRING },
 324                 [BRVLAN_ATTR_ALIAS] = { .type = BLOBMSG_TYPE_STRING },
 325         };
 326         static const struct uci_blob_param_list vlan_attr_list = {
 327                 .n_params = __BRVLAN_ATTR_MAX,
 328                 .params = vlan_attrs,
 329                 .info = vlan_attr_info,
 330         };
 331         struct blob_attr *tb[__BRVLAN_ATTR_MAX];
 332         struct blob_attr *cur;
 333         struct bridge_vlan_port *port;
 334         struct bridge_vlan *vlan;
 335         unsigned int vid;
 336         const char *val;
 337         char *name_buf;
 338         int name_len = 0;
 339         int n_ports = 0;
 340         size_t rem;
 341
 342         val = uci_lookup_option_string(uci_ctx, s, "vlan");
 343         if (!val)
 344                 return;
 345
 346         blob_buf_init(&b, 0);
 347         uci_to_blob(&b, s, &vlan_attr_list);
 348         blobmsg_parse(vlan_attrs, __BRVLAN_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
 349
 350         if (!tb[BRVLAN_ATTR_VID])
 351                 return;
 352
 353         vid = blobmsg_get_u32(tb[BRVLAN_ATTR_VID]);
 354         if (!vid || vid > 4095)
 355                 return;
 356
 357         blobmsg_for_each_attr(cur, tb[BRVLAN_ATTR_PORTS], rem) {
 358                 name_len += strlen(blobmsg_get_string(cur)) + 1;
 359                 n_ports++;
 360         }
 361
 362         vlan = calloc(1, sizeof(*vlan) + n_ports * sizeof(*port) + name_len);
 363         if (!vlan)
 364                 return;
 365
 366         vlan->vid = vid;
 367         vlan->local = true;
 368         if (tb[BRVLAN_ATTR_LOCAL])
 369                 vlan->local = blobmsg_get_bool(tb[BRVLAN_ATTR_LOCAL]);
 370
 371         vlan->n_ports = n_ports;
 372         vlan->ports = port = (struct bridge_vlan_port *)&vlan[1];
 373         INIT_LIST_HEAD(&vlan->hotplug_ports);
 374         name_buf = (char *)&port[n_ports];
 375
 376         blobmsg_for_each_attr(cur, tb[BRVLAN_ATTR_PORTS], rem) {
 377                 char *sep;
 378
 379                 port->ifname = name_buf;
 380                 port->flags = BRVLAN_F_UNTAGGED;
 381                 strcpy(name_buf, blobmsg_get_string(cur));
 382
 383                 sep = strchr(name_buf, ':');
 384                 if (sep) {
 385                         for (*sep = 0, sep++; *sep; sep++)
 386                                 switch (*sep) {
 387                                 case '*':
 388                                         port->flags |= BRVLAN_F_PVID;
 389                                         break;
 390                                 case 't':
 391                                         port->flags &= ~BRVLAN_F_UNTAGGED;
 392                                         break;
 393                                 }
 394                 }
 395
 396                 name_buf += strlen(name_buf) + 1;
 397                 port++;
 398         }
 399
 400         blobmsg_for_each_attr(cur, tb[BRVLAN_ATTR_ALIAS], rem)
 401                 kvlist_set(&dev->vlan_aliases, blobmsg_get_string(cur), &vid);
 402
 403         vlist_add(&dev->vlans, &vlan->node, &vlan->vid);
 404 }
 405
 406
 407 static void
 408 config_init_vlans(void)
 409 {
 410         struct uci_element *e;
 411         struct device *dev;
 412
 413         device_vlan_update(false);
 414         uci_foreach_element(&uci_network->sections, e) {
 415                 struct uci_section *s = uci_to_section(e);
 416                 const char *name;
 417
 418                 if (strcmp(s->type, "bridge-vlan") != 0)
 419                         continue;
 420
 421                 name = uci_lookup_option_string(uci_ctx, s, "device");
 422                 if (!name)
 423                         continue;
 424
 425                 dev = device_get(name, 0);
 426                 if (!dev || !dev->vlans.update)
 427                         continue;
 428
 429                 config_parse_vlan(dev, s);
 430         }
 431         device_vlan_update(true);
 432 }
 433
 434 static struct uci_package *
 435 config_init_package(const char *config)
 436 {
 437         struct uci_context *ctx = uci_ctx;
 438         struct uci_package *p = NULL;
 439
 440         if (!ctx) {
 441                 ctx = uci_alloc_context();
 442                 uci_ctx = ctx;
 443
 444                 ctx->flags &= ~UCI_FLAG_STRICT;
 445                 if (config_path)
 446                         uci_set_confdir(ctx, config_path);
 447
 448 #ifdef DUMMY_MODE
 449                 uci_set_savedir(ctx, "./tmp");
 450 #endif
 451         } else {
 452                 p = uci_lookup_package(ctx, config);
 453                 if (p)
 454                         uci_unload(ctx, p);
 455         }
 456
 457         if (uci_load(ctx, config, &p))
 458                 return NULL;
 459
 460         return p;
 461 }
 462
 463 static void
 464 config_init_interfaces(void)
 465 {
 466         struct uci_element *e;
 467
 468         uci_foreach_element(&uci_network->sections, e) {
 469                 struct uci_section *s = uci_to_section(e);
 470
 471                 if (!strcmp(s->type, "interface"))
 472                         config_parse_interface(s, false);
 473         }
 474
 475         uci_foreach_element(&uci_network->sections, e) {
 476                 struct uci_section *s = uci_to_section(e);
 477
 478                 if (!strcmp(s->type, "alias"))
 479                         config_parse_interface(s, true);
 480         }
 481 }
 482
 483 static void
 484 config_init_ip(void)
 485 {
 486         struct interface *iface;
 487         struct uci_element *e;
 488
 489         vlist_for_each_element(&interfaces, iface, node)
 490                 interface_ip_update_start(&iface->config_ip);
 491
 492         uci_foreach_element(&uci_network->sections, e) {
 493                 struct uci_section *s = uci_to_section(e);
 494
 495                 if (!strcmp(s->type, "route"))
 496                         config_parse_route(s, false);
 497                 else if (!strcmp(s->type, "route6"))
 498                         config_parse_route(s, true);
 499                 if (!strcmp(s->type, "neighbor"))
 500                         config_parse_neighbor(s, false);
 501                 else if (!strcmp(s->type, "neighbor6"))
 502                         config_parse_neighbor(s, true);
 503         }
 504
 505         vlist_for_each_element(&interfaces, iface, node)
 506                 interface_ip_update_complete(&iface->config_ip);
 507 }
 508
 509 static void
 510 config_init_rules(void)
 511 {
 512         struct uci_element *e;
 513
 514         iprule_update_start();
 515
 516         uci_foreach_element(&uci_network->sections, e) {
 517                 struct uci_section *s = uci_to_section(e);
 518
 519                 if (!strcmp(s->type, "rule"))
 520                         config_parse_rule(s, false);
 521                 else if (!strcmp(s->type, "rule6"))
 522                         config_parse_rule(s, true);
 523         }
 524
 525         iprule_update_complete();
 526 }
 527
 528 static void
 529 config_init_globals(void)
 530 {
 531         struct uci_section *globals = uci_lookup_section(
 532                         uci_ctx, uci_network, "globals");
 533         if (!globals)
 534                 return;
 535
 536         const char *ula_prefix = uci_lookup_option_string(
 537                         uci_ctx, globals, "ula_prefix");
 538         interface_ip_set_ula_prefix(ula_prefix);
 539 }
 540
 541 static void
 542 config_parse_wireless_device(struct uci_section *s)
 543 {
 544         struct wireless_driver *drv;
 545         const char *driver_name;
 546
 547         driver_name = uci_lookup_option_string(uci_ctx, s, "type");
 548         if (!driver_name)
 549                 return;
 550
 551         drv = avl_find_element(&wireless_drivers, driver_name, drv, node);
 552         if (!drv)
 553                 return;
 554
 555         blob_buf_init(&b, 0);
 556         uci_to_blob(&b, s, drv->device.config);
 557         wireless_device_create(drv, s->e.name, b.head);
 558 }
 559
 560 static void
 561 config_parse_wireless_vlan(struct wireless_interface *vif, struct uci_section *s)
 562 {
 563         char *name;
 564
 565         name = alloca(strlen(s->type) + 16);
 566         sprintf(name, "@%s[%d]", s->type, config_section_idx(s));
 567
 568         blob_buf_init(&b, 0);
 569         uci_to_blob(&b, s, vif->wdev->drv->vlan.config);
 570         wireless_vlan_create(vif, b.head, s->anonymous ? name : s->e.name);
 571 }
 572
 573 static void
 574 config_parse_wireless_station(struct wireless_interface *vif, struct uci_section *s)
 575 {
 576         char *name;
 577
 578         name = alloca(strlen(s->type) + 16);
 579         sprintf(name, "@%s[%d]", s->type, config_section_idx(s));
 580
 581         blob_buf_init(&b, 0);
 582         uci_to_blob(&b, s, vif->wdev->drv->station.config);
 583         wireless_station_create(vif, b.head, s->anonymous ? name : s->e.name);
 584 }
 585
 586 static void
 587 config_parse_wireless_interface(struct wireless_device *wdev, struct uci_section *s)
 588 {
 589         struct wireless_interface *vif;
 590         struct uci_element *f;
 591         char *name;
 592
 593         name = alloca(strlen(s->type) + 16);
 594         sprintf(name, "@%s[%d]", s->type, config_section_idx(s));
 595
 596         blob_buf_init(&b, 0);
 597         uci_to_blob(&b, s, wdev->drv->interface.config);
 598         vif = wireless_interface_create(wdev, b.head, s->anonymous ? name : s->e.name);
 599         if (!vif)
 600                 return;
 601
 602         vif->vlan_idx = vif->sta_idx = 0;
 603         vlist_update(&vif->vlans);
 604         vlist_update(&vif->stations);
 605
 606         if (s->anonymous)
 607                 goto out;
 608
 609         uci_foreach_element(&uci_wireless->sections, f) {
 610                 struct uci_section *cur = uci_to_section(f);
 611                 const char *vif_name;
 612
 613                 if (strcmp(cur->type, "wifi-vlan") != 0)
 614                         continue;
 615
 616                 vif_name = uci_lookup_option_string(uci_ctx, cur, "iface");
 617                 if (vif_name && strcmp(s->e.name, vif_name))
 618                         continue;
 619                 config_parse_wireless_vlan(vif, cur);
 620         }
 621
 622         uci_foreach_element(&uci_wireless->sections, f) {
 623                 struct uci_section *cur = uci_to_section(f);
 624                 const char *vif_name;
 625
 626                 if (strcmp(cur->type, "wifi-station") != 0)
 627                         continue;
 628
 629                 vif_name = uci_lookup_option_string(uci_ctx, cur, "iface");
 630                 if (vif_name && strcmp(s->e.name, vif_name))
 631                         continue;
 632                 config_parse_wireless_station(vif, cur);
 633         }
 634
 635 out:
 636         vlist_flush(&vif->vlans);
 637         vlist_flush(&vif->stations);
 638 }
 639
 640 static void
 641 config_init_wireless(void)
 642 {
 643         struct wireless_device *wdev;
 644         struct uci_element *e;
 645         const char *dev_name;
 646
 647         if (!uci_wireless) {
 648                 D(WIRELESS, "No wireless configuration found");
 649                 return;
 650         }
 651
 652         vlist_update(&wireless_devices);
 653
 654         uci_foreach_element(&uci_wireless->sections, e) {
 655                 struct uci_section *s = uci_to_section(e);
 656                 if (strcmp(s->type, "wifi-device") != 0)
 657                         continue;
 658
 659                 config_parse_wireless_device(s);
 660         }
 661
 662         vlist_flush(&wireless_devices);
 663
 664         vlist_for_each_element(&wireless_devices, wdev, node) {
 665                 wdev->vif_idx = 0;
 666                 vlist_update(&wdev->interfaces);
 667         }
 668
 669         uci_foreach_element(&uci_wireless->sections, e) {
 670                 struct uci_section *s = uci_to_section(e);
 671
 672                 if (strcmp(s->type, "wifi-iface") != 0)
 673                         continue;
 674
 675                 dev_name = uci_lookup_option_string(uci_ctx, s, "device");
 676                 if (!dev_name)
 677                         continue;
 678
 679                 wdev = vlist_find(&wireless_devices, dev_name, wdev, node);
 680                 if (!wdev) {
 681                         D(WIRELESS, "device %s not found!", dev_name);
 682                         continue;
 683                 }
 684
 685                 config_parse_wireless_interface(wdev, s);
 686         }
 687
 688         vlist_for_each_element(&wireless_devices, wdev, node)
 689                 vlist_flush(&wdev->interfaces);
 690 }
 691
 692
 693 static struct blob_attr *
 694 config_find_blobmsg_attr(struct blob_attr *attr, const char *name, int type)
 695 {
 696         struct blobmsg_policy policy = { .name = name, .type = type };
 697         struct blob_attr *cur;
 698
 699         blobmsg_parse(&policy, 1, &cur, blobmsg_data(attr), blobmsg_len(attr));
 700
 701         return cur;
 702 }
 703
 704 struct ether_addr *config_get_default_macaddr(const char *ifname)
 705 {
 706         struct blob_attr *cur;
 707
 708         if (!board_netdevs)
 709                 return NULL;
 710
 711         cur = config_find_blobmsg_attr(board_netdevs, ifname, BLOBMSG_TYPE_TABLE);
 712         if (!cur)
 713                 return NULL;
 714
 715         cur = config_find_blobmsg_attr(cur, "macaddr", BLOBMSG_TYPE_STRING);
 716         if (!cur)
 717                 return NULL;
 718
 719         return ether_aton(blobmsg_get_string(cur));
 720 }
 721
 722 int config_get_default_gro(const char *ifname)
 723 {
 724         struct blob_attr *cur;
 725
 726         if (!board_netdevs)
 727                 return -1;
 728
 729         cur = config_find_blobmsg_attr(board_netdevs, ifname, BLOBMSG_TYPE_TABLE);
 730         if (!cur)
 731                 return -1;
 732
 733         cur = config_find_blobmsg_attr(cur, "gro", BLOBMSG_TYPE_BOOL);
 734         if (!cur)
 735                 return -1;
 736
 737         return blobmsg_get_bool(cur);
 738 }
 739
 740 const char *config_get_default_conduit(const char *ifname)
 741 {
 742         struct blob_attr *cur;
 743
 744         if (!board_netdevs)
 745                 return NULL;
 746
 747         cur = config_find_blobmsg_attr(board_netdevs, ifname, BLOBMSG_TYPE_TABLE);
 748         if (!cur)
 749                 return NULL;
 750
 751         cur = config_find_blobmsg_attr(cur, "conduit", BLOBMSG_TYPE_STRING);
 752         if (!cur)
 753                 return NULL;
 754
 755         return blobmsg_get_string(cur);
 756 }
 757
 758 static void
 759 config_init_board(void)
 760 {
 761         struct blob_attr *cur;
 762
 763         blob_buf_init(&b, 0);
 764
 765         if (!blobmsg_add_json_from_file(&b, DEFAULT_BOARD_JSON))
 766                 return;
 767
 768         free(board_netdevs);
 769         board_netdevs = NULL;
 770
 771         cur = config_find_blobmsg_attr(b.head, "network_device",
 772                                        BLOBMSG_TYPE_TABLE);
 773         if (!cur)
 774                 return;
 775
 776         board_netdevs = blob_memdup(cur);
 777 }
 778
 779 int
 780 config_init_all(void)
 781 {
 782         int ret = 0;
 783         char *err;
 784
 785         uci_network = config_init_package("network");
 786         if (!uci_network) {
 787                 uci_get_errorstr(uci_ctx, &err, NULL);
 788                 netifd_log_message(L_CRIT, "Failed to load network config (%s)\n", err);
 789                 free(err);
 790                 return -1;
 791         }
 792
 793         uci_wireless = config_init_package("wireless");
 794         if (!uci_wireless && uci_ctx->err != UCI_ERR_NOTFOUND) {
 795                 uci_get_errorstr(uci_ctx, &err, NULL);
 796                 netifd_log_message(L_CRIT, "Failed to load wireless config (%s)\n", err);
 797                 free(err);
 798                 ret = -1;
 799         }
 800
 801         config_init_board();
 802
 803         vlist_update(&interfaces);
 804         config_init = true;
 805
 806         device_reset_config();
 807         config_init_devices(true);
 808         config_init_vlans();
 809         config_init_devices(false);
 810         config_init_interfaces();
 811         config_init_ip();
 812         config_init_rules();
 813         config_init_globals();
 814         config_init_wireless();
 815
 816         config_init = false;
 817
 818         device_reset_old();
 819         device_init_pending();
 820         vlist_flush(&interfaces);
 821         interface_refresh_assignments(false);
 822         interface_start_pending();
 823         wireless_start_pending(0);
 824
 825         return ret;
 826 }