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