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