device.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 #include <string.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <assert.h>
  18
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <net/ethernet.h>
  22
  23 #ifdef linux
  24 #include <netinet/ether.h>
  25 #endif
  26
  27 #include "netifd.h"
  28 #include "system.h"
  29 #include "config.h"
  30
  31 static struct avl_tree devices;
  32
  33 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = {
  34         [DEV_ATTR_TYPE] = { .name = "type", .type = BLOBMSG_TYPE_STRING },
  35         [DEV_ATTR_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_ARRAY },
  36         [DEV_ATTR_MTU] = { .name = "mtu", .type = BLOBMSG_TYPE_INT32 },
  37         [DEV_ATTR_MACADDR] = { .name = "macaddr", .type = BLOBMSG_TYPE_STRING },
  38         [DEV_ATTR_TXQUEUELEN] = { .name = "txqueuelen", .type = BLOBMSG_TYPE_INT32 },
  39         [DEV_ATTR_ENABLED] = { .name = "enabled", .type = BLOBMSG_TYPE_BOOL },
  40         [DEV_ATTR_IPV6] = { .name = "ipv6", .type = BLOBMSG_TYPE_BOOL },
  41         [DEV_ATTR_PROMISC] = { .name = "promisc", .type = BLOBMSG_TYPE_BOOL },
  42         [DEV_ATTR_RPFILTER] = { .name = "rpfilter", .type = BLOBMSG_TYPE_STRING },
  43         [DEV_ATTR_ACCEPTLOCAL] = { .name = "acceptlocal", .type = BLOBMSG_TYPE_BOOL },
  44         [DEV_ATTR_IGMPVERSION] = { .name = "igmpversion", .type = BLOBMSG_TYPE_INT32 },
  45         [DEV_ATTR_MLDVERSION] = { .name = "mldversion", .type = BLOBMSG_TYPE_INT32 },
  46 };
  47
  48 const struct uci_blob_param_list device_attr_list = {
  49         .n_params = __DEV_ATTR_MAX,
  50         .params = dev_attrs,
  51 };
  52
  53 static int __devlock = 0;
  54
  55 void device_lock(void)
  56 {
  57         __devlock++;
  58 }
  59
  60 void device_unlock(void)
  61 {
  62         __devlock--;
  63         if (!__devlock)
  64                 device_free_unused(NULL);
  65 }
  66
  67 static int set_device_state(struct device *dev, bool state)
  68 {
  69         if (state) {
  70                 /* Set ifindex for all devices being enabled so a valid  */
  71                 /* ifindex is in place avoiding possible race conditions */
  72                 device_set_ifindex(dev, system_if_resolve(dev));
  73                 if (!dev->ifindex)
  74                         return -1;
  75         }
  76
  77         if (dev->external)
  78                 return 0;
  79
  80         if (state)
  81                 system_if_up(dev);
  82         else
  83                 system_if_down(dev);
  84
  85         return 0;
  86 }
  87
  88 static int
  89 simple_device_set_state(struct device *dev, bool state)
  90 {
  91         struct device *pdev;
  92         int ret = 0;
  93
  94         pdev = dev->parent.dev;
  95         if (state && !pdev) {
  96                 pdev = system_if_get_parent(dev);
  97                 if (pdev)
  98                         device_add_user(&dev->parent, pdev);
  99         }
 100
 101         if (pdev) {
 102                 if (state)
 103                         ret = device_claim(&dev->parent);
 104                 else
 105                         device_release(&dev->parent);
 106
 107                 if (ret < 0)
 108                         return ret;
 109         }
 110         return set_device_state(dev, state);
 111 }
 112
 113 static struct device *
 114 simple_device_create(const char *name, struct blob_attr *attr)
 115 {
 116         struct blob_attr *tb[__DEV_ATTR_MAX];
 117         struct device *dev = NULL;
 118
 119         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
 120         dev = device_get(name, true);
 121         if (!dev)
 122                 return NULL;
 123
 124         dev->set_state = simple_device_set_state;
 125         device_init_settings(dev, tb);
 126
 127         return dev;
 128 }
 129
 130 static void simple_device_free(struct device *dev)
 131 {
 132         if (dev->parent.dev)
 133                 device_remove_user(&dev->parent);
 134         free(dev);
 135 }
 136
 137 const struct device_type simple_device_type = {
 138         .name = "Network device",
 139         .config_params = &device_attr_list,
 140
 141         .create = simple_device_create,
 142         .check_state = system_if_check,
 143         .free = simple_device_free,
 144 };
 145
 146 static void
 147 device_merge_settings(struct device *dev, struct device_settings *n)
 148 {
 149         struct device_settings *os = &dev->orig_settings;
 150         struct device_settings *s = &dev->settings;
 151
 152         memset(n, 0, sizeof(*n));
 153         n->mtu = s->flags & DEV_OPT_MTU ? s->mtu : os->mtu;
 154         n->txqueuelen = s->flags & DEV_OPT_TXQUEUELEN ?
 155                 s->txqueuelen : os->txqueuelen;
 156         memcpy(n->macaddr,
 157                 (s->flags & DEV_OPT_MACADDR ? s->macaddr : os->macaddr),
 158                 sizeof(n->macaddr));
 159         n->ipv6 = s->flags & DEV_OPT_IPV6 ? s->ipv6 : os->ipv6;
 160         n->promisc = s->flags & DEV_OPT_PROMISC ? s->promisc : os->promisc;
 161         n->rpfilter = s->flags & DEV_OPT_RPFILTER ? s->rpfilter : os->rpfilter;
 162         n->acceptlocal = s->flags & DEV_OPT_ACCEPTLOCAL ? s->acceptlocal : os->acceptlocal;
 163         n->igmpversion = s->flags & DEV_OPT_IGMPVERSION ? s->igmpversion : os->igmpversion;
 164         n->mldversion = s->flags & DEV_OPT_MLDVERSION ? s->mldversion : os->mldversion;
 165         n->flags = s->flags | os->flags;
 166 }
 167
 168 void
 169 device_init_settings(struct device *dev, struct blob_attr **tb)
 170 {
 171         struct device_settings *s = &dev->settings;
 172         struct blob_attr *cur;
 173         struct ether_addr *ea;
 174         bool disabled = false;
 175
 176         s->flags = 0;
 177         if ((cur = tb[DEV_ATTR_ENABLED]))
 178                 disabled = !blobmsg_get_bool(cur);
 179
 180         if ((cur = tb[DEV_ATTR_MTU])) {
 181                 s->mtu = blobmsg_get_u32(cur);
 182                 s->flags |= DEV_OPT_MTU;
 183         }
 184
 185         if ((cur = tb[DEV_ATTR_TXQUEUELEN])) {
 186                 s->txqueuelen = blobmsg_get_u32(cur);
 187                 s->flags |= DEV_OPT_TXQUEUELEN;
 188         }
 189
 190         if ((cur = tb[DEV_ATTR_MACADDR])) {
 191                 ea = ether_aton(blobmsg_data(cur));
 192                 if (ea) {
 193                         memcpy(s->macaddr, ea, 6);
 194                         s->flags |= DEV_OPT_MACADDR;
 195                 }
 196         }
 197
 198         if ((cur = tb[DEV_ATTR_IPV6])) {
 199                 s->ipv6 = blobmsg_get_bool(cur);
 200                 s->flags |= DEV_OPT_IPV6;
 201         }
 202
 203         if ((cur = tb[DEV_ATTR_PROMISC])) {
 204                 s->promisc = blobmsg_get_bool(cur);
 205                 s->flags |= DEV_OPT_PROMISC;
 206         }
 207
 208         if ((cur = tb[DEV_ATTR_RPFILTER])) {
 209                 if (system_resolve_rpfilter(blobmsg_data(cur), &s->rpfilter))
 210                         s->flags |= DEV_OPT_RPFILTER;
 211                 else
 212                         DPRINTF("Failed to resolve rpfilter: %s\n", (char *) blobmsg_data(cur));
 213         }
 214
 215         if ((cur = tb[DEV_ATTR_ACCEPTLOCAL])) {
 216                 s->acceptlocal = blobmsg_get_bool(cur);
 217                 s->flags |= DEV_OPT_ACCEPTLOCAL;
 218         }
 219
 220         if ((cur = tb[DEV_ATTR_IGMPVERSION])) {
 221                 s->igmpversion = blobmsg_get_u32(cur);
 222                 if (s->igmpversion >= 1 && s->igmpversion <= 3)
 223                         s->flags |= DEV_OPT_IGMPVERSION;
 224                 else
 225                         DPRINTF("Failed to resolve igmpversion: %d\n", blobmsg_get_u32(cur));
 226         }
 227
 228         if ((cur = tb[DEV_ATTR_MLDVERSION])) {
 229                 s->mldversion = blobmsg_get_u32(cur);
 230                 if (s->mldversion >= 1 && s->mldversion <= 2)
 231                         s->flags |= DEV_OPT_MLDVERSION;
 232                 else
 233                         DPRINTF("Failed to resolve mldversion: %d\n", blobmsg_get_u32(cur));
 234         }
 235
 236         device_set_disabled(dev, disabled);
 237 }
 238
 239 static void __init dev_init(void)
 240 {
 241         avl_init(&devices, avl_strcmp, true, NULL);
 242 }
 243
 244 static int device_broadcast_cb(void *ctx, struct safe_list *list)
 245 {
 246         struct device_user *dep = container_of(list, struct device_user, list);
 247         int *ev = ctx;
 248
 249         /* device might have been removed by an earlier callback */
 250         if (!dep->dev)
 251                 return 0;
 252
 253         if (dep->cb)
 254                 dep->cb(dep, *ev);
 255         return 0;
 256 }
 257
 258 void device_broadcast_event(struct device *dev, enum device_event ev)
 259 {
 260         int dev_ev = ev;
 261
 262         safe_list_for_each(&dev->aliases, device_broadcast_cb, &dev_ev);
 263         safe_list_for_each(&dev->users, device_broadcast_cb, &dev_ev);
 264 }
 265
 266 int device_claim(struct device_user *dep)
 267 {
 268         struct device *dev = dep->dev;
 269         int ret;
 270
 271         if (dep->claimed)
 272                 return 0;
 273
 274         dep->claimed = true;
 275         D(DEVICE, "Claim %s %s, new active count: %d\n", dev->type->name, dev->ifname, dev->active + 1);
 276         if (++dev->active != 1)
 277                 return 0;
 278
 279         device_broadcast_event(dev, DEV_EVENT_SETUP);
 280         ret = dev->set_state(dev, true);
 281         if (ret == 0)
 282                 device_broadcast_event(dev, DEV_EVENT_UP);
 283         else {
 284                 D(DEVICE, "claim %s %s failed: %d\n", dev->type->name, dev->ifname, ret);
 285                 dev->active = 0;
 286                 dep->claimed = false;
 287         }
 288
 289         return ret;
 290 }
 291
 292 void device_release(struct device_user *dep)
 293 {
 294         struct device *dev = dep->dev;
 295
 296         if (!dep->claimed)
 297                 return;
 298
 299         dep->claimed = false;
 300         dev->active--;
 301         D(DEVICE, "Release %s %s, new active count: %d\n", dev->type->name, dev->ifname, dev->active);
 302         assert(dev->active >= 0);
 303
 304         if (dev->active)
 305                 return;
 306
 307         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
 308         if (!dev->external)
 309                 dev->set_state(dev, false);
 310         device_broadcast_event(dev, DEV_EVENT_DOWN);
 311 }
 312
 313 int device_check_state(struct device *dev)
 314 {
 315         if (!dev->type->check_state)
 316                 return simple_device_type.check_state(dev);
 317
 318         return dev->type->check_state(dev);
 319 }
 320
 321 void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
 322 {
 323         assert(dev);
 324         assert(type);
 325
 326         if (name)
 327                 strncpy(dev->ifname, name, IFNAMSIZ);
 328
 329         D(DEVICE, "Initialize device '%s'\n", dev->ifname);
 330         INIT_SAFE_LIST(&dev->users);
 331         INIT_SAFE_LIST(&dev->aliases);
 332         dev->type = type;
 333
 334         if (!dev->set_state)
 335                 dev->set_state = set_device_state;
 336 }
 337
 338 int device_init(struct device *dev, const struct device_type *type, const char *ifname)
 339 {
 340         int ret;
 341
 342         device_init_virtual(dev, type, ifname);
 343
 344         dev->avl.key = dev->ifname;
 345
 346         ret = avl_insert(&devices, &dev->avl);
 347         if (ret < 0)
 348                 return ret;
 349
 350         system_if_clear_state(dev);
 351         device_check_state(dev);
 352
 353         return 0;
 354 }
 355
 356 static struct device *
 357 device_create_default(const char *name, bool external)
 358 {
 359         struct device *dev;
 360
 361         if (!external && system_if_force_external(name))
 362                 return NULL;
 363
 364         D(DEVICE, "Create simple device '%s'\n", name);
 365         dev = calloc(1, sizeof(*dev));
 366         dev->external = external;
 367         dev->set_state = simple_device_set_state;
 368         device_init(dev, &simple_device_type, name);
 369         dev->default_config = true;
 370         return dev;
 371 }
 372
 373 struct device *
 374 device_get(const char *name, int create)
 375 {
 376         struct device *dev;
 377
 378         if (strchr(name, '.'))
 379                 return get_vlan_device_chain(name, create);
 380
 381         if (name[0] == '@')
 382                 return device_alias_get(name + 1);
 383
 384         dev = avl_find_element(&devices, name, dev, avl);
 385         if (dev) {
 386                 if (create > 1 && !dev->external) {
 387                         dev->external = true;
 388                         device_set_present(dev, true);
 389                 }
 390                 return dev;
 391         }
 392
 393         if (!create)
 394                 return NULL;
 395
 396         return device_create_default(name, create > 1);
 397 }
 398
 399 static void
 400 device_delete(struct device *dev)
 401 {
 402         if (!dev->avl.key)
 403                 return;
 404
 405         D(DEVICE, "Delete device '%s' from list\n", dev->ifname);
 406         avl_delete(&devices, &dev->avl);
 407         dev->avl.key = NULL;
 408 }
 409
 410 static int device_cleanup_cb(void *ctx, struct safe_list *list)
 411 {
 412         struct device_user *dep = container_of(list, struct device_user, list);
 413         if (dep->cb)
 414                 dep->cb(dep, DEV_EVENT_REMOVE);
 415
 416         device_release(dep);
 417         return 0;
 418 }
 419
 420 void device_cleanup(struct device *dev)
 421 {
 422         D(DEVICE, "Clean up device '%s'\n", dev->ifname);
 423         safe_list_for_each(&dev->users, device_cleanup_cb, NULL);
 424         safe_list_for_each(&dev->aliases, device_cleanup_cb, NULL);
 425         device_delete(dev);
 426 }
 427
 428 static void __device_set_present(struct device *dev, bool state)
 429 {
 430         if (dev->present == state)
 431                 return;
 432
 433         dev->present = state;
 434         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
 435 }
 436
 437 void
 438 device_refresh_present(struct device *dev)
 439 {
 440         bool state = dev->sys_present;
 441
 442         if (dev->disabled || dev->deferred)
 443                 state = false;
 444
 445         __device_set_present(dev, state);
 446 }
 447
 448 void device_set_present(struct device *dev, bool state)
 449 {
 450         if (dev->sys_present == state)
 451                 return;
 452
 453         D(DEVICE, "%s '%s' %s present\n", dev->type->name, dev->ifname, state ? "is now" : "is no longer" );
 454         dev->sys_present = state;
 455         device_refresh_present(dev);
 456 }
 457
 458 void device_set_link(struct device *dev, bool state)
 459 {
 460         if (dev->link_active == state)
 461                 return;
 462
 463         netifd_log_message(L_NOTICE, "%s '%s' link is %s\n", dev->type->name, dev->ifname, state ? "up" : "down" );
 464
 465         dev->link_active = state;
 466         device_broadcast_event(dev, state ? DEV_EVENT_LINK_UP : DEV_EVENT_LINK_DOWN);
 467 }
 468
 469 void device_set_ifindex(struct device *dev, int ifindex)
 470 {
 471         if (dev->ifindex == ifindex)
 472                 return;
 473
 474         dev->ifindex = ifindex;
 475         device_broadcast_event(dev, DEV_EVENT_UPDATE_IFINDEX);
 476 }
 477
 478 static int device_refcount(struct device *dev)
 479 {
 480         struct list_head *list;
 481         int count = 0;
 482
 483         list_for_each(list, &dev->users.list)
 484                 count++;
 485
 486         list_for_each(list, &dev->aliases.list)
 487                 count++;
 488
 489         return count;
 490 }
 491
 492 void device_add_user(struct device_user *dep, struct device *dev)
 493 {
 494         struct safe_list *head;
 495
 496         if (dep->dev == dev)
 497                 return;
 498
 499         if (dep->dev)
 500                 device_remove_user(dep);
 501
 502         if (!dev)
 503                 return;
 504
 505         dep->dev = dev;
 506
 507         if (dep->alias)
 508                 head = &dev->aliases;
 509         else
 510                 head = &dev->users;
 511
 512         safe_list_add(&dep->list, head);
 513         D(DEVICE, "Add user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
 514
 515         if (dep->cb && dev->present) {
 516                 dep->cb(dep, DEV_EVENT_ADD);
 517                 if (dev->active)
 518                         dep->cb(dep, DEV_EVENT_UP);
 519
 520                 if (dev->link_active)
 521                         dep->cb(dep, DEV_EVENT_LINK_UP);
 522         }
 523 }
 524
 525 void
 526 device_free(struct device *dev)
 527 {
 528         __devlock++;
 529         free(dev->config);
 530         device_cleanup(dev);
 531         dev->type->free(dev);
 532         __devlock--;
 533 }
 534
 535 static void
 536 __device_free_unused(struct device *dev)
 537 {
 538         if (!safe_list_empty(&dev->users) ||
 539                 !safe_list_empty(&dev->aliases) ||
 540             dev->current_config || __devlock)
 541                 return;
 542
 543         device_free(dev);
 544 }
 545
 546 void device_remove_user(struct device_user *dep)
 547 {
 548         struct device *dev = dep->dev;
 549
 550         if (!dep->dev)
 551                 return;
 552
 553         dep->hotplug = false;
 554         if (dep->claimed)
 555                 device_release(dep);
 556
 557         safe_list_del(&dep->list);
 558         dep->dev = NULL;
 559         D(DEVICE, "Remove user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
 560         __device_free_unused(dev);
 561 }
 562
 563 void
 564 device_free_unused(struct device *dev)
 565 {
 566         struct device *tmp;
 567
 568         if (dev)
 569                 return __device_free_unused(dev);
 570
 571         avl_for_each_element_safe(&devices, dev, avl, tmp)
 572                 __device_free_unused(dev);
 573 }
 574
 575 void
 576 device_init_pending(void)
 577 {
 578         struct device *dev, *tmp;
 579
 580         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 581                 if (!dev->config_pending)
 582                         continue;
 583
 584                 dev->type->config_init(dev);
 585                 dev->config_pending = false;
 586         }
 587 }
 588
 589 enum dev_change_type
 590 device_set_config(struct device *dev, const struct device_type *type,
 591                   struct blob_attr *attr)
 592 {
 593         struct blob_attr *tb[__DEV_ATTR_MAX];
 594         const struct uci_blob_param_list *cfg = type->config_params;
 595
 596         if (type != dev->type)
 597                 return DEV_CONFIG_RECREATE;
 598
 599         if (dev->type->reload)
 600                 return dev->type->reload(dev, attr);
 601
 602         if (uci_blob_check_equal(dev->config, attr, cfg))
 603                 return DEV_CONFIG_NO_CHANGE;
 604
 605         if (cfg == &device_attr_list) {
 606                 memset(tb, 0, sizeof(tb));
 607
 608                 if (attr)
 609                         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
 610                                 blob_data(attr), blob_len(attr));
 611
 612                 device_init_settings(dev, tb);
 613                 return DEV_CONFIG_RESTART;
 614         } else
 615                 return DEV_CONFIG_RECREATE;
 616 }
 617
 618 enum dev_change_type
 619 device_apply_config(struct device *dev, const struct device_type *type,
 620                     struct blob_attr *config)
 621 {
 622         enum dev_change_type change;
 623
 624         change = device_set_config(dev, type, config);
 625         if (dev->external) {
 626                 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
 627                 change = DEV_CONFIG_APPLIED;
 628         }
 629
 630         switch (change) {
 631                 case DEV_CONFIG_RESTART:
 632                 case DEV_CONFIG_APPLIED:
 633                         D(DEVICE, "Device '%s': config applied\n", dev->ifname);
 634                         free(dev->config);
 635                         dev->config = config;
 636                         if (change == DEV_CONFIG_RESTART && dev->present) {
 637                                 device_set_present(dev, false);
 638                                 device_set_present(dev, true);
 639                         }
 640                         break;
 641                 case DEV_CONFIG_NO_CHANGE:
 642                         D(DEVICE, "Device '%s': no configuration change\n", dev->ifname);
 643                         free(config);
 644                         break;
 645                 case DEV_CONFIG_RECREATE:
 646                         break;
 647         }
 648
 649         return change;
 650 }
 651
 652 static void
 653 device_replace(struct device *dev, struct device *odev)
 654 {
 655         struct device_user *dep, *tmp;
 656         bool present = odev->present;
 657
 658         if (present)
 659                 device_set_present(odev, false);
 660
 661         list_for_each_entry_safe(dep, tmp, &odev->users.list, list.list) {
 662                 device_release(dep);
 663                 safe_list_del(&dep->list);
 664                 safe_list_add(&dep->list, &dev->users);
 665                 dep->dev = dev;
 666         }
 667         device_free(odev);
 668
 669         if (present)
 670                 device_set_present(dev, true);
 671 }
 672
 673 void
 674 device_reset_config(void)
 675 {
 676         struct device *dev;
 677
 678         avl_for_each_element(&devices, dev, avl)
 679                 dev->current_config = false;
 680 }
 681
 682 void
 683 device_reset_old(void)
 684 {
 685         struct device *dev, *tmp, *ndev;
 686
 687         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 688                 if (dev->current_config || dev->default_config)
 689                         continue;
 690
 691                 if (dev->type != &simple_device_type)
 692                         continue;
 693
 694                 ndev = device_create_default(dev->ifname, dev->external);
 695                 device_replace(ndev, dev);
 696         }
 697 }
 698
 699 struct device *
 700 device_create(const char *name, const struct device_type *type,
 701               struct blob_attr *config)
 702 {
 703         struct device *odev = NULL, *dev;
 704         enum dev_change_type change;
 705
 706         config = blob_memdup(config);
 707         if (!config)
 708                 return NULL;
 709
 710         odev = device_get(name, false);
 711         if (odev) {
 712                 odev->current_config = true;
 713                 change = device_apply_config(odev, type, config);
 714                 switch (change) {
 715                 case DEV_CONFIG_RECREATE:
 716                         D(DEVICE, "Device '%s': recreate device\n", odev->ifname);
 717                         device_delete(odev);
 718                         break;
 719                 default:
 720                         return odev;
 721                 }
 722         } else
 723                 D(DEVICE, "Create new device '%s' (%s)\n", name, type->name);
 724
 725         dev = type->create(name, config);
 726         if (!dev)
 727                 return NULL;
 728
 729         dev->current_config = true;
 730         dev->config = config;
 731         if (odev)
 732                 device_replace(dev, odev);
 733
 734         if (!config_init && dev->config_pending)
 735                 type->config_init(dev);
 736
 737         return dev;
 738 }
 739
 740 void
 741 device_dump_status(struct blob_buf *b, struct device *dev)
 742 {
 743         struct device_settings st;
 744         void *c, *s;
 745
 746         if (!dev) {
 747                 avl_for_each_element(&devices, dev, avl) {
 748                         if (!dev->present)
 749                                 continue;
 750                         c = blobmsg_open_table(b, dev->ifname);
 751                         device_dump_status(b, dev);
 752                         blobmsg_close_table(b, c);
 753                 }
 754
 755                 return;
 756         }
 757
 758         blobmsg_add_u8(b, "external", dev->external);
 759         blobmsg_add_u8(b, "present", dev->present);
 760         blobmsg_add_string(b, "type", dev->type->name);
 761
 762         if (!dev->present)
 763                 return;
 764
 765         blobmsg_add_u8(b, "up", !!dev->active);
 766         blobmsg_add_u8(b, "carrier", !!dev->link_active);
 767
 768         if (dev->type->dump_info)
 769                 dev->type->dump_info(dev, b);
 770         else
 771                 system_if_dump_info(dev, b);
 772
 773         if (dev->active) {
 774                 device_merge_settings(dev, &st);
 775                 if (st.flags & DEV_OPT_MTU)
 776                         blobmsg_add_u32(b, "mtu", st.mtu);
 777                 if (st.flags & DEV_OPT_MACADDR)
 778                         blobmsg_add_string(b, "macaddr", format_macaddr(st.macaddr));
 779                 if (st.flags & DEV_OPT_TXQUEUELEN)
 780                         blobmsg_add_u32(b, "txqueuelen", st.txqueuelen);
 781                 if (st.flags & DEV_OPT_IPV6)
 782                         blobmsg_add_u8(b, "ipv6", st.ipv6);
 783                 if (st.flags & DEV_OPT_PROMISC)
 784                         blobmsg_add_u8(b, "promisc", st.promisc);
 785                 if (st.flags & DEV_OPT_RPFILTER)
 786                         blobmsg_add_u32(b, "rpfilter", st.rpfilter);
 787                 if (st.flags & DEV_OPT_ACCEPTLOCAL)
 788                         blobmsg_add_u8(b, "acceptlocal", st.acceptlocal);
 789                 if (st.flags & DEV_OPT_IGMPVERSION)
 790                         blobmsg_add_u32(b, "igmpversion", st.igmpversion);
 791                 if (st.flags & DEV_OPT_MLDVERSION)
 792                         blobmsg_add_u32(b, "mldversion", st.mldversion);
 793         }
 794
 795         s = blobmsg_open_table(b, "statistics");
 796         if (dev->type->dump_stats)
 797                 dev->type->dump_stats(dev, b);
 798         else
 799                 system_if_dump_stats(dev, b);
 800         blobmsg_close_table(b, s);
 801 }