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
  22 #include <libubox/list.h>
  23
  24 #include "netifd.h"
  25 #include "system.h"
  26 #include "config.h"
  27
  28 static struct list_head devtypes = LIST_HEAD_INIT(devtypes);
  29 static struct avl_tree devices;
  30
  31 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = {
  32         [DEV_ATTR_TYPE] = { .name = "type", .type = BLOBMSG_TYPE_STRING },
  33         [DEV_ATTR_MTU] = { .name = "mtu", .type = BLOBMSG_TYPE_INT32 },
  34         [DEV_ATTR_MTU6] = { .name = "mtu6", .type = BLOBMSG_TYPE_INT32 },
  35         [DEV_ATTR_MACADDR] = { .name = "macaddr", .type = BLOBMSG_TYPE_STRING },
  36         [DEV_ATTR_TXQUEUELEN] = { .name = "txqueuelen", .type = BLOBMSG_TYPE_INT32 },
  37         [DEV_ATTR_ENABLED] = { .name = "enabled", .type = BLOBMSG_TYPE_BOOL },
  38         [DEV_ATTR_IPV6] = { .name = "ipv6", .type = BLOBMSG_TYPE_BOOL },
  39         [DEV_ATTR_IP6SEGMENTROUTING] = { .name = "ip6segmentrouting", .type = BLOBMSG_TYPE_BOOL },
  40         [DEV_ATTR_PROMISC] = { .name = "promisc", .type = BLOBMSG_TYPE_BOOL },
  41         [DEV_ATTR_RPFILTER] = { .name = "rpfilter", .type = BLOBMSG_TYPE_STRING },
  42         [DEV_ATTR_ACCEPTLOCAL] = { .name = "acceptlocal", .type = BLOBMSG_TYPE_BOOL },
  43         [DEV_ATTR_IGMPVERSION] = { .name = "igmpversion", .type = BLOBMSG_TYPE_INT32 },
  44         [DEV_ATTR_MLDVERSION] = { .name = "mldversion", .type = BLOBMSG_TYPE_INT32 },
  45         [DEV_ATTR_NEIGHREACHABLETIME] = { .name = "neighreachabletime", .type = BLOBMSG_TYPE_INT32 },
  46         [DEV_ATTR_NEIGHGCSTALETIME] = { .name = "neighgcstaletime", .type = BLOBMSG_TYPE_INT32 },
  47         [DEV_ATTR_DADTRANSMITS] = { .name = "dadtransmits", .type = BLOBMSG_TYPE_INT32 },
  48         [DEV_ATTR_MULTICAST_TO_UNICAST] = { .name = "multicast_to_unicast", .type = BLOBMSG_TYPE_BOOL },
  49         [DEV_ATTR_MULTICAST_ROUTER] = { .name = "multicast_router", .type = BLOBMSG_TYPE_INT32 },
  50         [DEV_ATTR_MULTICAST_FAST_LEAVE] = { .name = "multicast_fast_leave", . type = BLOBMSG_TYPE_BOOL },
  51         [DEV_ATTR_MULTICAST] = { .name ="multicast", .type = BLOBMSG_TYPE_BOOL },
  52         [DEV_ATTR_LEARNING] = { .name ="learning", .type = BLOBMSG_TYPE_BOOL },
  53         [DEV_ATTR_UNICAST_FLOOD] = { .name ="unicast_flood", .type = BLOBMSG_TYPE_BOOL },
  54         [DEV_ATTR_SENDREDIRECTS] = { .name = "sendredirects", .type = BLOBMSG_TYPE_BOOL },
  55         [DEV_ATTR_NEIGHLOCKTIME] = { .name = "neighlocktime", .type = BLOBMSG_TYPE_INT32 },
  56         [DEV_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL },
  57 };
  58
  59 const struct uci_blob_param_list device_attr_list = {
  60         .n_params = __DEV_ATTR_MAX,
  61         .params = dev_attrs,
  62 };
  63
  64 static int __devlock = 0;
  65
  66 int device_type_add(struct device_type *devtype)
  67 {
  68         if (device_type_get(devtype->name)) {
  69                 netifd_log_message(L_WARNING, "Device handler '%s' already exists\n",
  70                                    devtype->name);
  71                 return 1;
  72         }
  73
  74         netifd_log_message(L_NOTICE, "Added device handler type: %s\n",
  75                 devtype->name);
  76
  77         list_add(&devtype->list, &devtypes);
  78         return 0;
  79 }
  80
  81 struct device_type *
  82 device_type_get(const char *tname)
  83 {
  84         struct device_type *cur;
  85
  86         list_for_each_entry(cur, &devtypes, list)
  87                 if (!strcmp(cur->name, tname))
  88                         return cur;
  89
  90         return NULL;
  91 }
  92
  93 void device_lock(void)
  94 {
  95         __devlock++;
  96 }
  97
  98 void device_unlock(void)
  99 {
 100         __devlock--;
 101         if (!__devlock)
 102                 device_free_unused(NULL);
 103 }
 104
 105 static int device_vlan_len(struct kvlist *kv, const void *data)
 106 {
 107         return sizeof(unsigned int);
 108 }
 109
 110 void device_vlan_update(bool done)
 111 {
 112         struct device *dev;
 113
 114         avl_for_each_element(&devices, dev, avl) {
 115                 if (!dev->vlans.update)
 116                         continue;
 117
 118                 if (!done) {
 119                         if (dev->vlan_aliases.get_len)
 120                                 kvlist_free(&dev->vlan_aliases);
 121                         else
 122                                 kvlist_init(&dev->vlan_aliases, device_vlan_len);
 123                         vlist_update(&dev->vlans);
 124                 } else {
 125                         vlist_flush(&dev->vlans);
 126                 }
 127         }
 128 }
 129
 130 static int set_device_state(struct device *dev, bool state)
 131 {
 132         if (state) {
 133                 /* Get ifindex for all devices being enabled so a valid  */
 134                 /* ifindex is in place avoiding possible race conditions */
 135                 device_set_ifindex(dev, system_if_resolve(dev));
 136                 if (!dev->ifindex)
 137                         return -1;
 138
 139                 system_if_get_settings(dev, &dev->orig_settings);
 140                 /* Only keep orig settings based on what needs to be set */
 141                 dev->orig_settings.valid_flags = dev->orig_settings.flags;
 142                 dev->orig_settings.flags &= dev->settings.flags;
 143                 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
 144
 145                 system_if_up(dev);
 146         } else {
 147                 system_if_down(dev);
 148                 system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags);
 149         }
 150
 151         return 0;
 152 }
 153
 154 static int
 155 simple_device_set_state(struct device *dev, bool state)
 156 {
 157         struct device *pdev;
 158         int ret = 0;
 159
 160         pdev = dev->parent.dev;
 161         if (state && !pdev) {
 162                 pdev = system_if_get_parent(dev);
 163                 if (pdev)
 164                         device_add_user(&dev->parent, pdev);
 165         }
 166
 167         if (pdev) {
 168                 if (state)
 169                         ret = device_claim(&dev->parent);
 170                 else
 171                         device_release(&dev->parent);
 172
 173                 if (ret < 0)
 174                         return ret;
 175         }
 176         return set_device_state(dev, state);
 177 }
 178
 179 static struct device *
 180 simple_device_create(const char *name, struct device_type *devtype,
 181                      struct blob_attr *attr)
 182 {
 183         struct blob_attr *tb[__DEV_ATTR_MAX];
 184         struct device *dev = NULL;
 185
 186         /* device type is unused for simple devices */
 187         devtype = NULL;
 188
 189         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
 190         dev = device_get(name, true);
 191         if (!dev)
 192                 return NULL;
 193
 194         dev->set_state = simple_device_set_state;
 195         device_init_settings(dev, tb);
 196
 197         return dev;
 198 }
 199
 200 static void simple_device_free(struct device *dev)
 201 {
 202         if (dev->parent.dev)
 203                 device_remove_user(&dev->parent);
 204         free(dev);
 205 }
 206
 207 struct device_type simple_device_type = {
 208         .name = "Network device",
 209         .config_params = &device_attr_list,
 210
 211         .create = simple_device_create,
 212         .check_state = system_if_check,
 213         .free = simple_device_free,
 214 };
 215
 216 void
 217 device_merge_settings(struct device *dev, struct device_settings *n)
 218 {
 219         struct device_settings *os = &dev->orig_settings;
 220         struct device_settings *s = &dev->settings;
 221
 222         memset(n, 0, sizeof(*n));
 223         n->mtu = s->flags & DEV_OPT_MTU ? s->mtu : os->mtu;
 224         n->mtu6 = s->flags & DEV_OPT_MTU6 ? s->mtu6 : os->mtu6;
 225         n->txqueuelen = s->flags & DEV_OPT_TXQUEUELEN ?
 226                 s->txqueuelen : os->txqueuelen;
 227         memcpy(n->macaddr,
 228                 (s->flags & (DEV_OPT_MACADDR|DEV_OPT_DEFAULT_MACADDR) ? s->macaddr : os->macaddr),
 229                 sizeof(n->macaddr));
 230         n->ipv6 = s->flags & DEV_OPT_IPV6 ? s->ipv6 : os->ipv6;
 231         n->ip6segmentrouting = s->flags & DEV_OPT_IP6SEGMENTROUTING ? s->ip6segmentrouting : os->ip6segmentrouting;
 232         n->promisc = s->flags & DEV_OPT_PROMISC ? s->promisc : os->promisc;
 233         n->rpfilter = s->flags & DEV_OPT_RPFILTER ? s->rpfilter : os->rpfilter;
 234         n->acceptlocal = s->flags & DEV_OPT_ACCEPTLOCAL ? s->acceptlocal : os->acceptlocal;
 235         n->igmpversion = s->flags & DEV_OPT_IGMPVERSION ? s->igmpversion : os->igmpversion;
 236         n->mldversion = s->flags & DEV_OPT_MLDVERSION ? s->mldversion : os->mldversion;
 237         n->neigh4reachabletime = s->flags & DEV_OPT_NEIGHREACHABLETIME ?
 238                 s->neigh4reachabletime : os->neigh4reachabletime;
 239         n->neigh6reachabletime = s->flags & DEV_OPT_NEIGHREACHABLETIME ?
 240                 s->neigh6reachabletime : os->neigh6reachabletime;
 241         n->neigh4gcstaletime = s->flags & DEV_OPT_NEIGHGCSTALETIME ?
 242                 s->neigh4gcstaletime : os->neigh4gcstaletime;
 243         n->neigh6gcstaletime = s->flags & DEV_OPT_NEIGHGCSTALETIME ?
 244                 s->neigh6gcstaletime : os->neigh6gcstaletime;
 245         n->neigh4locktime = s->flags & DEV_OPT_NEIGHLOCKTIME ?
 246                 s->neigh4locktime : os->neigh4locktime;
 247         n->dadtransmits = s->flags & DEV_OPT_DADTRANSMITS ?
 248                 s->dadtransmits : os->dadtransmits;
 249         n->multicast = s->flags & DEV_OPT_MULTICAST ?
 250                 s->multicast : os->multicast;
 251         n->multicast_to_unicast = s->multicast_to_unicast;
 252         n->multicast_router = s->multicast_router;
 253         n->multicast_fast_leave = s->multicast_fast_leave;
 254         n->learning = s->learning;
 255         n->unicast_flood = s->unicast_flood;
 256         n->sendredirects = s->flags & DEV_OPT_SENDREDIRECTS ?
 257                 s->sendredirects : os->sendredirects;
 258         n->flags = s->flags | os->flags | os->valid_flags;
 259 }
 260
 261 void
 262 device_init_settings(struct device *dev, struct blob_attr **tb)
 263 {
 264         struct device_settings *s = &dev->settings;
 265         struct blob_attr *cur;
 266         struct ether_addr *ea;
 267         bool disabled = false;
 268
 269         s->flags = 0;
 270         if ((cur = tb[DEV_ATTR_ENABLED]))
 271                 disabled = !blobmsg_get_bool(cur);
 272
 273         if ((cur = tb[DEV_ATTR_MTU]) && blobmsg_get_u32(cur) >= 68) {
 274                 s->mtu = blobmsg_get_u32(cur);
 275                 s->flags |= DEV_OPT_MTU;
 276         }
 277
 278         if ((cur = tb[DEV_ATTR_MTU6]) && blobmsg_get_u32(cur) >= 1280) {
 279                 s->mtu6 = blobmsg_get_u32(cur);
 280                 s->flags |= DEV_OPT_MTU6;
 281         }
 282
 283         if ((cur = tb[DEV_ATTR_TXQUEUELEN])) {
 284                 s->txqueuelen = blobmsg_get_u32(cur);
 285                 s->flags |= DEV_OPT_TXQUEUELEN;
 286         }
 287
 288         if ((cur = tb[DEV_ATTR_MACADDR])) {
 289                 ea = ether_aton(blobmsg_data(cur));
 290                 if (ea) {
 291                         memcpy(s->macaddr, ea, 6);
 292                         s->flags |= DEV_OPT_MACADDR;
 293                 }
 294         }
 295
 296         if ((cur = tb[DEV_ATTR_IPV6])) {
 297                 s->ipv6 = blobmsg_get_bool(cur);
 298                 s->flags |= DEV_OPT_IPV6;
 299         }
 300
 301         if ((cur = tb[DEV_ATTR_IP6SEGMENTROUTING])) {
 302                 s->ip6segmentrouting = blobmsg_get_bool(cur);
 303                 s->flags |= DEV_OPT_IP6SEGMENTROUTING;
 304         }
 305
 306         if ((cur = tb[DEV_ATTR_PROMISC])) {
 307                 s->promisc = blobmsg_get_bool(cur);
 308                 s->flags |= DEV_OPT_PROMISC;
 309         }
 310
 311         if ((cur = tb[DEV_ATTR_RPFILTER])) {
 312                 if (system_resolve_rpfilter(blobmsg_data(cur), &s->rpfilter))
 313                         s->flags |= DEV_OPT_RPFILTER;
 314                 else
 315                         DPRINTF("Failed to resolve rpfilter: %s\n", (char *) blobmsg_data(cur));
 316         }
 317
 318         if ((cur = tb[DEV_ATTR_ACCEPTLOCAL])) {
 319                 s->acceptlocal = blobmsg_get_bool(cur);
 320                 s->flags |= DEV_OPT_ACCEPTLOCAL;
 321         }
 322
 323         if ((cur = tb[DEV_ATTR_IGMPVERSION])) {
 324                 s->igmpversion = blobmsg_get_u32(cur);
 325                 if (s->igmpversion >= 1 && s->igmpversion <= 3)
 326                         s->flags |= DEV_OPT_IGMPVERSION;
 327                 else
 328                         DPRINTF("Failed to resolve igmpversion: %d\n", blobmsg_get_u32(cur));
 329         }
 330
 331         if ((cur = tb[DEV_ATTR_MLDVERSION])) {
 332                 s->mldversion = blobmsg_get_u32(cur);
 333                 if (s->mldversion >= 1 && s->mldversion <= 2)
 334                         s->flags |= DEV_OPT_MLDVERSION;
 335                 else
 336                         DPRINTF("Failed to resolve mldversion: %d\n", blobmsg_get_u32(cur));
 337         }
 338
 339         if ((cur = tb[DEV_ATTR_NEIGHREACHABLETIME])) {
 340                 s->neigh6reachabletime = s->neigh4reachabletime = blobmsg_get_u32(cur);
 341                 s->flags |= DEV_OPT_NEIGHREACHABLETIME;
 342         }
 343
 344         if ((cur = tb[DEV_ATTR_NEIGHGCSTALETIME])) {
 345                 s->neigh6gcstaletime = s->neigh4gcstaletime = blobmsg_get_u32(cur);
 346                 s->flags |= DEV_OPT_NEIGHGCSTALETIME;
 347         }
 348
 349         if ((cur = tb[DEV_ATTR_NEIGHLOCKTIME])) {
 350                 s->neigh4locktime = blobmsg_get_u32(cur);
 351                 s->flags |= DEV_OPT_NEIGHLOCKTIME;
 352         }
 353
 354         if ((cur = tb[DEV_ATTR_DADTRANSMITS])) {
 355                 s->dadtransmits = blobmsg_get_u32(cur);
 356                 s->flags |= DEV_OPT_DADTRANSMITS;
 357         }
 358
 359         if ((cur = tb[DEV_ATTR_MULTICAST_TO_UNICAST])) {
 360                 s->multicast_to_unicast = blobmsg_get_bool(cur);
 361                 s->flags |= DEV_OPT_MULTICAST_TO_UNICAST;
 362         }
 363
 364         if ((cur = tb[DEV_ATTR_MULTICAST_ROUTER])) {
 365                 s->multicast_router = blobmsg_get_u32(cur);
 366                 if (s->multicast_router <= 2)
 367                         s->flags |= DEV_OPT_MULTICAST_ROUTER;
 368                 else
 369                         DPRINTF("Invalid value: %d - (Use 0: never, 1: learn, 2: always)\n", blobmsg_get_u32(cur));
 370         }
 371
 372         if ((cur = tb[DEV_ATTR_MULTICAST_FAST_LEAVE])) {
 373                 s->multicast_fast_leave = blobmsg_get_bool(cur);
 374                 s->flags |= DEV_OPT_MULTICAST_FAST_LEAVE;
 375         }
 376
 377         if ((cur = tb[DEV_ATTR_MULTICAST])) {
 378                 s->multicast = blobmsg_get_bool(cur);
 379                 s->flags |= DEV_OPT_MULTICAST;
 380         }
 381
 382         if ((cur = tb[DEV_ATTR_LEARNING])) {
 383                 s->learning = blobmsg_get_bool(cur);
 384                 s->flags |= DEV_OPT_LEARNING;
 385         }
 386
 387         if ((cur = tb[DEV_ATTR_UNICAST_FLOOD])) {
 388                 s->unicast_flood = blobmsg_get_bool(cur);
 389                 s->flags |= DEV_OPT_UNICAST_FLOOD;
 390         }
 391
 392         if ((cur = tb[DEV_ATTR_SENDREDIRECTS])) {
 393                 s->sendredirects = blobmsg_get_bool(cur);
 394                 s->flags |= DEV_OPT_SENDREDIRECTS;
 395         }
 396
 397         if ((cur = tb[DEV_ATTR_ISOLATE])) {
 398                 s->isolate = blobmsg_get_bool(cur);
 399                 s->flags |= DEV_OPT_ISOLATE;
 400         }
 401
 402         device_set_disabled(dev, disabled);
 403 }
 404
 405 static void __init dev_init(void)
 406 {
 407         avl_init(&devices, avl_strcmp, true, NULL);
 408 }
 409
 410 static int device_broadcast_cb(void *ctx, struct safe_list *list)
 411 {
 412         struct device_user *dep = container_of(list, struct device_user, list);
 413         int *ev = ctx;
 414
 415         /* device might have been removed by an earlier callback */
 416         if (!dep->dev)
 417                 return 0;
 418
 419         if (dep->cb)
 420                 dep->cb(dep, *ev);
 421         return 0;
 422 }
 423
 424 void device_broadcast_event(struct device *dev, enum device_event ev)
 425 {
 426         int dev_ev = ev;
 427
 428         safe_list_for_each(&dev->aliases, device_broadcast_cb, &dev_ev);
 429         safe_list_for_each(&dev->users, device_broadcast_cb, &dev_ev);
 430 }
 431
 432 static void
 433 device_fill_default_settings(struct device *dev)
 434 {
 435         struct device_settings *s = &dev->settings;
 436         struct ether_addr *ea;
 437
 438         if (!(s->flags & DEV_OPT_MACADDR)) {
 439                 ea = config_get_default_macaddr(dev->ifname);
 440                 if (ea) {
 441                         memcpy(s->macaddr, ea, 6);
 442                         s->flags |= DEV_OPT_DEFAULT_MACADDR;
 443                 }
 444         }
 445 }
 446
 447 int device_claim(struct device_user *dep)
 448 {
 449         struct device *dev = dep->dev;
 450         int ret = 0;
 451
 452         if (dep->claimed)
 453                 return 0;
 454
 455         if (!dev)
 456                 return -1;
 457
 458         dep->claimed = true;
 459         D(DEVICE, "Claim %s %s, new active count: %d\n", dev->type->name, dev->ifname, dev->active + 1);
 460         if (++dev->active != 1)
 461                 return 0;
 462
 463         device_broadcast_event(dev, DEV_EVENT_SETUP);
 464         device_fill_default_settings(dev);
 465         if (dev->external) {
 466                 /* Get ifindex for external claimed devices so a valid   */
 467                 /* ifindex is in place avoiding possible race conditions */
 468                 device_set_ifindex(dev, system_if_resolve(dev));
 469                 if (!dev->ifindex)
 470                         ret = -1;
 471
 472                 system_if_get_settings(dev, &dev->orig_settings);
 473         } else
 474                 ret = dev->set_state(dev, true);
 475
 476         if (ret == 0)
 477                 device_broadcast_event(dev, DEV_EVENT_UP);
 478         else {
 479                 D(DEVICE, "claim %s %s failed: %d\n", dev->type->name, dev->ifname, ret);
 480                 dev->active = 0;
 481                 dep->claimed = false;
 482         }
 483
 484         return ret;
 485 }
 486
 487 void device_release(struct device_user *dep)
 488 {
 489         struct device *dev = dep->dev;
 490
 491         if (!dep->claimed)
 492                 return;
 493
 494         dep->claimed = false;
 495         dev->active--;
 496         D(DEVICE, "Release %s %s, new active count: %d\n", dev->type->name, dev->ifname, dev->active);
 497         assert(dev->active >= 0);
 498
 499         if (dev->active)
 500                 return;
 501
 502         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
 503         if (!dev->external)
 504                 dev->set_state(dev, false);
 505
 506         if (dev->active)
 507                 return;
 508
 509         device_broadcast_event(dev, DEV_EVENT_DOWN);
 510 }
 511
 512 int device_check_state(struct device *dev)
 513 {
 514         if (!dev->type->check_state)
 515                 return simple_device_type.check_state(dev);
 516
 517         return dev->type->check_state(dev);
 518 }
 519
 520 int device_init_virtual(struct device *dev, struct device_type *type, const char *name)
 521 {
 522         assert(dev);
 523         assert(type);
 524
 525         D(DEVICE, "Initialize device '%s'\n", name ? name : "");
 526         INIT_SAFE_LIST(&dev->users);
 527         INIT_SAFE_LIST(&dev->aliases);
 528         dev->type = type;
 529
 530         if (name) {
 531                 int ret;
 532
 533                 ret = device_set_ifname(dev, name);
 534                 if (ret < 0)
 535                         return ret;
 536         }
 537
 538         if (!dev->set_state)
 539                 dev->set_state = set_device_state;
 540
 541         return 0;
 542 }
 543
 544 int device_init(struct device *dev, struct device_type *type, const char *ifname)
 545 {
 546         int ret;
 547
 548         ret = device_init_virtual(dev, type, ifname);
 549         if (ret < 0)
 550                 return ret;
 551
 552         dev->avl.key = dev->ifname;
 553
 554         ret = avl_insert(&devices, &dev->avl);
 555         if (ret < 0)
 556                 return ret;
 557
 558         system_if_clear_state(dev);
 559
 560         return 0;
 561 }
 562
 563 static struct device *
 564 device_create_default(const char *name, bool external)
 565 {
 566         struct device *dev;
 567
 568         if (!external && system_if_force_external(name))
 569                 return NULL;
 570
 571         D(DEVICE, "Create simple device '%s'\n", name);
 572         dev = calloc(1, sizeof(*dev));
 573         if (!dev)
 574                 return NULL;
 575
 576         dev->external = external;
 577         dev->set_state = simple_device_set_state;
 578
 579         if (device_init(dev, &simple_device_type, name) < 0) {
 580                 device_cleanup(dev);
 581                 free(dev);
 582                 return NULL;
 583         }
 584
 585         dev->default_config = true;
 586         if (external)
 587                 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
 588
 589         device_check_state(dev);
 590
 591         return dev;
 592 }
 593
 594 struct device *
 595 device_find(const char *name)
 596 {
 597         struct device *dev;
 598
 599         return avl_find_element(&devices, name, dev, avl);
 600 }
 601
 602 struct device *
 603 device_get(const char *name, int create)
 604 {
 605         struct device *dev;
 606
 607         dev = avl_find_element(&devices, name, dev, avl);
 608
 609         if (!dev && strchr(name, '.'))
 610                 return get_vlan_device_chain(name, create);
 611
 612         if (name[0] == '@')
 613                 return device_alias_get(name + 1);
 614
 615         if (dev) {
 616                 if (create > 1 && !dev->external) {
 617                         system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
 618                         dev->external = true;
 619                         device_set_present(dev, true);
 620                 }
 621                 return dev;
 622         }
 623
 624         if (!create)
 625                 return NULL;
 626
 627         return device_create_default(name, create > 1);
 628 }
 629
 630 static void
 631 device_delete(struct device *dev)
 632 {
 633         if (!dev->avl.key)
 634                 return;
 635
 636         D(DEVICE, "Delete device '%s' from list\n", dev->ifname);
 637         avl_delete(&devices, &dev->avl);
 638         dev->avl.key = NULL;
 639 }
 640
 641 static int device_cleanup_cb(void *ctx, struct safe_list *list)
 642 {
 643         struct device_user *dep = container_of(list, struct device_user, list);
 644         if (dep->cb)
 645                 dep->cb(dep, DEV_EVENT_REMOVE);
 646
 647         device_release(dep);
 648         return 0;
 649 }
 650
 651 void device_cleanup(struct device *dev)
 652 {
 653         D(DEVICE, "Clean up device '%s'\n", dev->ifname);
 654         safe_list_for_each(&dev->users, device_cleanup_cb, NULL);
 655         safe_list_for_each(&dev->aliases, device_cleanup_cb, NULL);
 656         device_delete(dev);
 657 }
 658
 659 static void __device_set_present(struct device *dev, bool state)
 660 {
 661         if (dev->present == state)
 662                 return;
 663
 664         dev->present = state;
 665         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
 666 }
 667
 668 void
 669 device_refresh_present(struct device *dev)
 670 {
 671         bool state = dev->sys_present;
 672
 673         if (dev->disabled || dev->deferred)
 674                 state = false;
 675
 676         __device_set_present(dev, state);
 677 }
 678
 679 void device_set_present(struct device *dev, bool state)
 680 {
 681         if (dev->sys_present == state)
 682                 return;
 683
 684         D(DEVICE, "%s '%s' %s present\n", dev->type->name, dev->ifname, state ? "is now" : "is no longer" );
 685         dev->sys_present = state;
 686         device_refresh_present(dev);
 687 }
 688
 689 void device_set_link(struct device *dev, bool state)
 690 {
 691         if (dev->link_active == state)
 692                 return;
 693
 694         netifd_log_message(L_NOTICE, "%s '%s' link is %s\n", dev->type->name, dev->ifname, state ? "up" : "down" );
 695
 696         dev->link_active = state;
 697         device_broadcast_event(dev, state ? DEV_EVENT_LINK_UP : DEV_EVENT_LINK_DOWN);
 698 }
 699
 700 void device_set_ifindex(struct device *dev, int ifindex)
 701 {
 702         if (dev->ifindex == ifindex)
 703                 return;
 704
 705         dev->ifindex = ifindex;
 706         device_broadcast_event(dev, DEV_EVENT_UPDATE_IFINDEX);
 707 }
 708
 709 int device_set_ifname(struct device *dev, const char *name)
 710 {
 711         int ret = 0;
 712
 713         if (!strcmp(dev->ifname, name))
 714                 return 0;
 715
 716         if (strlen(name) > sizeof(dev->ifname) - 1)
 717                 return -1;
 718
 719         if (dev->avl.key)
 720                 avl_delete(&devices, &dev->avl);
 721
 722         strcpy(dev->ifname, name);
 723
 724         if (dev->avl.key)
 725                 ret = avl_insert(&devices, &dev->avl);
 726
 727         if (ret == 0)
 728                 device_broadcast_event(dev, DEV_EVENT_UPDATE_IFNAME);
 729
 730         return ret;
 731 }
 732
 733 static int device_refcount(struct device *dev)
 734 {
 735         struct list_head *list;
 736         int count = 0;
 737
 738         list_for_each(list, &dev->users.list)
 739                 count++;
 740
 741         list_for_each(list, &dev->aliases.list)
 742                 count++;
 743
 744         return count;
 745 }
 746
 747 static void
 748 __device_add_user(struct device_user *dep, struct device *dev)
 749 {
 750         struct safe_list *head;
 751
 752         dep->dev = dev;
 753
 754         if (dep->alias)
 755                 head = &dev->aliases;
 756         else
 757                 head = &dev->users;
 758
 759         safe_list_add(&dep->list, head);
 760         D(DEVICE, "Add user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
 761
 762         if (dep->cb && dev->present) {
 763                 dep->cb(dep, DEV_EVENT_ADD);
 764                 if (dev->active)
 765                         dep->cb(dep, DEV_EVENT_UP);
 766
 767                 if (dev->link_active)
 768                         dep->cb(dep, DEV_EVENT_LINK_UP);
 769         }
 770 }
 771
 772 void device_add_user(struct device_user *dep, struct device *dev)
 773 {
 774         if (dep->dev == dev)
 775                 return;
 776
 777         if (dep->dev)
 778                 device_remove_user(dep);
 779
 780         if (!dev)
 781                 return;
 782
 783         __device_add_user(dep, dev);
 784 }
 785
 786 static void
 787 device_free(struct device *dev)
 788 {
 789         __devlock++;
 790         free(dev->config);
 791         device_cleanup(dev);
 792         dev->type->free(dev);
 793         __devlock--;
 794 }
 795
 796 static void
 797 __device_free_unused(struct device *dev)
 798 {
 799         if (!safe_list_empty(&dev->users) ||
 800                 !safe_list_empty(&dev->aliases) ||
 801             dev->current_config || __devlock)
 802                 return;
 803
 804         device_free(dev);
 805 }
 806
 807 void device_remove_user(struct device_user *dep)
 808 {
 809         struct device *dev = dep->dev;
 810
 811         if (!dep->dev)
 812                 return;
 813
 814         dep->hotplug = false;
 815         if (dep->claimed)
 816                 device_release(dep);
 817
 818         safe_list_del(&dep->list);
 819         dep->dev = NULL;
 820         D(DEVICE, "Remove user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
 821         __device_free_unused(dev);
 822 }
 823
 824 void
 825 device_free_unused(struct device *dev)
 826 {
 827         struct device *tmp;
 828
 829         if (dev)
 830                 return __device_free_unused(dev);
 831
 832         avl_for_each_element_safe(&devices, dev, avl, tmp)
 833                 __device_free_unused(dev);
 834 }
 835
 836 void
 837 device_init_pending(void)
 838 {
 839         struct device *dev, *tmp;
 840
 841         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 842                 if (!dev->config_pending)
 843                         continue;
 844
 845                 dev->type->config_init(dev);
 846                 dev->config_pending = false;
 847                 device_check_state(dev);
 848         }
 849 }
 850
 851 bool
 852 device_check_ip6segmentrouting(void)
 853 {
 854         struct device *dev;
 855         bool ip6segmentrouting = false;
 856
 857         avl_for_each_element(&devices, dev, avl)
 858                 ip6segmentrouting |= dev->settings.ip6segmentrouting;
 859
 860         return ip6segmentrouting;
 861 }
 862
 863 static enum dev_change_type
 864 device_set_config(struct device *dev, struct device_type *type,
 865                   struct blob_attr *attr)
 866 {
 867         struct blob_attr *tb[__DEV_ATTR_MAX];
 868         const struct uci_blob_param_list *cfg = type->config_params;
 869
 870         if (type != dev->type)
 871                 return DEV_CONFIG_RECREATE;
 872
 873         if (dev->type->reload)
 874                 return dev->type->reload(dev, attr);
 875
 876         if (uci_blob_check_equal(dev->config, attr, cfg))
 877                 return DEV_CONFIG_NO_CHANGE;
 878
 879         if (cfg == &device_attr_list) {
 880                 memset(tb, 0, sizeof(tb));
 881
 882                 if (attr)
 883                         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
 884                                 blob_data(attr), blob_len(attr));
 885
 886                 device_init_settings(dev, tb);
 887                 return DEV_CONFIG_RESTART;
 888         } else
 889                 return DEV_CONFIG_RECREATE;
 890 }
 891
 892 enum dev_change_type
 893 device_apply_config(struct device *dev, struct device_type *type,
 894                     struct blob_attr *config)
 895 {
 896         enum dev_change_type change;
 897
 898         change = device_set_config(dev, type, config);
 899         if (dev->external) {
 900                 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
 901                 change = DEV_CONFIG_APPLIED;
 902         }
 903
 904         switch (change) {
 905                 case DEV_CONFIG_RESTART:
 906                 case DEV_CONFIG_APPLIED:
 907                         D(DEVICE, "Device '%s': config applied\n", dev->ifname);
 908                         config = blob_memdup(config);
 909                         free(dev->config);
 910                         dev->config = config;
 911                         if (change == DEV_CONFIG_RESTART && dev->present) {
 912                                 int ret = 0;
 913
 914                                 device_set_present(dev, false);
 915                                 if (dev->active && !dev->external) {
 916                                         ret = dev->set_state(dev, false);
 917                                         if (!ret)
 918                                                 ret = dev->set_state(dev, true);
 919                                 }
 920                                 if (!ret)
 921                                         device_set_present(dev, true);
 922                         }
 923                         break;
 924                 case DEV_CONFIG_NO_CHANGE:
 925                         D(DEVICE, "Device '%s': no configuration change\n", dev->ifname);
 926                         break;
 927                 case DEV_CONFIG_RECREATE:
 928                         break;
 929         }
 930
 931         return change;
 932 }
 933
 934 static void
 935 device_replace(struct device *dev, struct device *odev)
 936 {
 937         struct device_user *dep, *tmp;
 938
 939         __devlock++;
 940         if (odev->present)
 941                 device_set_present(odev, false);
 942
 943         list_for_each_entry_safe(dep, tmp, &odev->users.list, list.list) {
 944                 device_release(dep);
 945                 safe_list_del(&dep->list);
 946                 __device_add_user(dep, dev);
 947         }
 948         __devlock--;
 949
 950         device_free(odev);
 951 }
 952
 953 void
 954 device_reset_config(void)
 955 {
 956         struct device *dev;
 957
 958         avl_for_each_element(&devices, dev, avl)
 959                 dev->current_config = false;
 960 }
 961
 962 void
 963 device_reset_old(void)
 964 {
 965         struct device *dev, *tmp, *ndev;
 966
 967         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 968                 if (dev->current_config || dev->default_config)
 969                         continue;
 970
 971                 if (dev->type != &simple_device_type)
 972                         continue;
 973
 974                 ndev = device_create_default(dev->ifname, dev->external);
 975                 if (!ndev)
 976                         continue;
 977
 978                 device_replace(ndev, dev);
 979         }
 980 }
 981
 982 struct device *
 983 device_create(const char *name, struct device_type *type,
 984               struct blob_attr *config)
 985 {
 986         struct device *odev = NULL, *dev;
 987         enum dev_change_type change;
 988
 989         odev = device_find(name);
 990         if (odev) {
 991                 odev->current_config = true;
 992                 change = device_apply_config(odev, type, config);
 993                 switch (change) {
 994                 case DEV_CONFIG_RECREATE:
 995                         D(DEVICE, "Device '%s': recreate device\n", odev->ifname);
 996                         device_delete(odev);
 997                         break;
 998                 default:
 999                         return odev;
1000                 }
1001         } else
1002                 D(DEVICE, "Create new device '%s' (%s)\n", name, type->name);
1003
1004         config = blob_memdup(config);
1005         if (!config)
1006                 return NULL;
1007
1008         dev = type->create(name, type, config);
1009         if (!dev)
1010                 return NULL;
1011
1012         dev->current_config = true;
1013         dev->config = config;
1014         if (odev)
1015                 device_replace(dev, odev);
1016
1017         if (!config_init && dev->config_pending) {
1018                 type->config_init(dev);
1019                 dev->config_pending = false;
1020         }
1021
1022         device_check_state(dev);
1023
1024         return dev;
1025 }
1026
1027 void
1028 device_dump_status(struct blob_buf *b, struct device *dev)
1029 {
1030         struct device_settings st;
1031         void *c, *s;
1032
1033         if (!dev) {
1034                 avl_for_each_element(&devices, dev, avl) {
1035                         if (!dev->present)
1036                                 continue;
1037                         c = blobmsg_open_table(b, dev->ifname);
1038                         device_dump_status(b, dev);
1039                         blobmsg_close_table(b, c);
1040                 }
1041
1042                 return;
1043         }
1044
1045         blobmsg_add_u8(b, "external", dev->external);
1046         blobmsg_add_u8(b, "present", dev->present);
1047         blobmsg_add_string(b, "type", dev->type->name);
1048
1049         if (!dev->present)
1050                 return;
1051
1052         blobmsg_add_u8(b, "up", !!dev->active);
1053         blobmsg_add_u8(b, "carrier", !!dev->link_active);
1054
1055         if (dev->type->dump_info)
1056                 dev->type->dump_info(dev, b);
1057         else
1058                 system_if_dump_info(dev, b);
1059
1060         if (dev->active) {
1061                 device_merge_settings(dev, &st);
1062                 if (st.flags & DEV_OPT_MTU)
1063                         blobmsg_add_u32(b, "mtu", st.mtu);
1064                 if (st.flags & DEV_OPT_MTU6)
1065                         blobmsg_add_u32(b, "mtu6", st.mtu6);
1066                 if (st.flags & DEV_OPT_MACADDR)
1067                         blobmsg_add_string(b, "macaddr", format_macaddr(st.macaddr));
1068                 if (st.flags & DEV_OPT_TXQUEUELEN)
1069                         blobmsg_add_u32(b, "txqueuelen", st.txqueuelen);
1070                 if (st.flags & DEV_OPT_IPV6)
1071                         blobmsg_add_u8(b, "ipv6", st.ipv6);
1072                 if (st.flags & DEV_OPT_IP6SEGMENTROUTING)
1073                         blobmsg_add_u8(b, "ip6segmentrouting", st.ip6segmentrouting);
1074                 if (st.flags & DEV_OPT_PROMISC)
1075                         blobmsg_add_u8(b, "promisc", st.promisc);
1076                 if (st.flags & DEV_OPT_RPFILTER)
1077                         blobmsg_add_u32(b, "rpfilter", st.rpfilter);
1078                 if (st.flags & DEV_OPT_ACCEPTLOCAL)
1079                         blobmsg_add_u8(b, "acceptlocal", st.acceptlocal);
1080                 if (st.flags & DEV_OPT_IGMPVERSION)
1081                         blobmsg_add_u32(b, "igmpversion", st.igmpversion);
1082                 if (st.flags & DEV_OPT_MLDVERSION)
1083                         blobmsg_add_u32(b, "mldversion", st.mldversion);
1084                 if (st.flags & DEV_OPT_NEIGHREACHABLETIME) {
1085                         blobmsg_add_u32(b, "neigh4reachabletime", st.neigh4reachabletime);
1086                         blobmsg_add_u32(b, "neigh6reachabletime", st.neigh6reachabletime);
1087                 }
1088                 if (st.flags & DEV_OPT_NEIGHGCSTALETIME) {
1089                         blobmsg_add_u32(b, "neigh4gcstaletime", st.neigh4gcstaletime);
1090                         blobmsg_add_u32(b, "neigh6gcstaletime", st.neigh6gcstaletime);
1091                 }
1092                 if (st.flags & DEV_OPT_NEIGHLOCKTIME)
1093                         blobmsg_add_u32(b, "neigh4locktime", st.neigh4locktime);
1094                 if (st.flags & DEV_OPT_DADTRANSMITS)
1095                         blobmsg_add_u32(b, "dadtransmits", st.dadtransmits);
1096                 if (st.flags & DEV_OPT_MULTICAST_TO_UNICAST)
1097                         blobmsg_add_u8(b, "multicast_to_unicast", st.multicast_to_unicast);
1098                 if (st.flags & DEV_OPT_MULTICAST_ROUTER)
1099                         blobmsg_add_u32(b, "multicast_router", st.multicast_router);
1100                 if (st.flags & DEV_OPT_MULTICAST_FAST_LEAVE)
1101                         blobmsg_add_u8(b, "multicast_fast_leave", st.multicast_fast_leave);
1102                 if (st.flags & DEV_OPT_MULTICAST)
1103                         blobmsg_add_u8(b, "multicast", st.multicast);
1104                 if (st.flags & DEV_OPT_LEARNING)
1105                         blobmsg_add_u8(b, "learning", st.learning);
1106                 if (st.flags & DEV_OPT_UNICAST_FLOOD)
1107                         blobmsg_add_u8(b, "unicast_flood", st.unicast_flood);
1108                 if (st.flags & DEV_OPT_SENDREDIRECTS)
1109                         blobmsg_add_u8(b, "sendredirects", st.sendredirects);
1110         }
1111
1112         s = blobmsg_open_table(b, "statistics");
1113         if (dev->type->dump_stats)
1114                 dev->type->dump_stats(dev, b);
1115         else
1116                 system_if_dump_stats(dev, b);
1117         blobmsg_close_table(b, s);
1118 }
1119
1120 static void __init simple_device_type_init(void)
1121 {
1122         device_type_add(&simple_device_type);
1123 }