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 #include "wireless.h" 28 #include "ubus.h" 29 30 static struct list_head devtypes = LIST_HEAD_INIT(devtypes); 31 static struct avl_tree devices; 32 static struct blob_buf b; 33 34 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = { 35 [DEV_ATTR_TYPE] = { .name = "type", .type = BLOBMSG_TYPE_STRING }, 36 [DEV_ATTR_MTU] = { .name = "mtu", .type = BLOBMSG_TYPE_INT32 }, 37 [DEV_ATTR_MTU6] = { .name = "mtu6", .type = BLOBMSG_TYPE_INT32 }, 38 [DEV_ATTR_MACADDR] = { .name = "macaddr", .type = BLOBMSG_TYPE_STRING }, 39 [DEV_ATTR_TXQUEUELEN] = { .name = "txqueuelen", .type = BLOBMSG_TYPE_INT32 }, 40 [DEV_ATTR_ENABLED] = { .name = "enabled", .type = BLOBMSG_TYPE_BOOL }, 41 [DEV_ATTR_IPV6] = { .name = "ipv6", .type = BLOBMSG_TYPE_BOOL }, 42 [DEV_ATTR_IP6SEGMENTROUTING] = { .name = "ip6segmentrouting", .type = BLOBMSG_TYPE_BOOL }, 43 [DEV_ATTR_PROMISC] = { .name = "promisc", .type = BLOBMSG_TYPE_BOOL }, 44 [DEV_ATTR_RPFILTER] = { .name = "rpfilter", .type = BLOBMSG_TYPE_STRING }, 45 [DEV_ATTR_ACCEPTLOCAL] = { .name = "acceptlocal", .type = BLOBMSG_TYPE_BOOL }, 46 [DEV_ATTR_IGMPVERSION] = { .name = "igmpversion", .type = BLOBMSG_TYPE_INT32 }, 47 [DEV_ATTR_MLDVERSION] = { .name = "mldversion", .type = BLOBMSG_TYPE_INT32 }, 48 [DEV_ATTR_NEIGHREACHABLETIME] = { .name = "neighreachabletime", .type = BLOBMSG_TYPE_INT32 }, 49 [DEV_ATTR_NEIGHGCSTALETIME] = { .name = "neighgcstaletime", .type = BLOBMSG_TYPE_INT32 }, 50 [DEV_ATTR_DADTRANSMITS] = { .name = "dadtransmits", .type = BLOBMSG_TYPE_INT32 }, 51 [DEV_ATTR_MULTICAST_TO_UNICAST] = { .name = "multicast_to_unicast", .type = BLOBMSG_TYPE_BOOL }, 52 [DEV_ATTR_MULTICAST_ROUTER] = { .name = "multicast_router", .type = BLOBMSG_TYPE_INT32 }, 53 [DEV_ATTR_MULTICAST_FAST_LEAVE] = { .name = "multicast_fast_leave", . type = BLOBMSG_TYPE_BOOL }, 54 [DEV_ATTR_MULTICAST] = { .name ="multicast", .type = BLOBMSG_TYPE_BOOL }, 55 [DEV_ATTR_LEARNING] = { .name ="learning", .type = BLOBMSG_TYPE_BOOL }, 56 [DEV_ATTR_UNICAST_FLOOD] = { .name ="unicast_flood", .type = BLOBMSG_TYPE_BOOL }, 57 [DEV_ATTR_SENDREDIRECTS] = { .name = "sendredirects", .type = BLOBMSG_TYPE_BOOL }, 58 [DEV_ATTR_NEIGHLOCKTIME] = { .name = "neighlocktime", .type = BLOBMSG_TYPE_INT32 }, 59 [DEV_ATTR_ISOLATE] = { .name = "isolate", .type = BLOBMSG_TYPE_BOOL }, 60 [DEV_ATTR_DROP_V4_UNICAST_IN_L2_MULTICAST] = { .name = "drop_v4_unicast_in_l2_multicast", .type = BLOBMSG_TYPE_BOOL }, 61 [DEV_ATTR_DROP_V6_UNICAST_IN_L2_MULTICAST] = { .name = "drop_v6_unicast_in_l2_multicast", .type = BLOBMSG_TYPE_BOOL }, 62 [DEV_ATTR_DROP_GRATUITOUS_ARP] = { .name = "drop_gratuitous_arp", .type = BLOBMSG_TYPE_BOOL }, 63 [DEV_ATTR_DROP_UNSOLICITED_NA] = { .name = "drop_unsolicited_na", .type = BLOBMSG_TYPE_BOOL }, 64 [DEV_ATTR_ARP_ACCEPT] = { .name = "arp_accept", .type = BLOBMSG_TYPE_BOOL }, 65 [DEV_ATTR_AUTH] = { .name = "auth", .type = BLOBMSG_TYPE_BOOL }, 66 [DEV_ATTR_AUTH_VLAN] = { .name = "auth_vlan", BLOBMSG_TYPE_ARRAY }, 67 [DEV_ATTR_SPEED] = { .name = "speed", .type = BLOBMSG_TYPE_INT32 }, 68 [DEV_ATTR_DUPLEX] = { .name = "duplex", .type = BLOBMSG_TYPE_BOOL }, 69 [DEV_ATTR_VLAN] = { .name = "vlan", .type = BLOBMSG_TYPE_ARRAY }, 70 [DEV_ATTR_PAUSE] = { .name = "pause", .type = BLOBMSG_TYPE_BOOL }, 71 [DEV_ATTR_ASYM_PAUSE] = { .name = "asym_pause", .type = BLOBMSG_TYPE_BOOL }, 72 [DEV_ATTR_RXPAUSE] = { .name = "rxpause", .type = BLOBMSG_TYPE_BOOL }, 73 [DEV_ATTR_TXPAUSE] = { .name = "txpause", .type = BLOBMSG_TYPE_BOOL }, 74 [DEV_ATTR_AUTONEG] = { .name = "autoneg", .type = BLOBMSG_TYPE_BOOL }, 75 [DEV_ATTR_GRO] = { .name = "gro", .type = BLOBMSG_TYPE_BOOL }, 76 [DEV_ATTR_MASTER] = { .name = "conduit", .type = BLOBMSG_TYPE_STRING }, 77 [DEV_ATTR_EEE] = { .name = "eee", .type = BLOBMSG_TYPE_BOOL }, 78 }; 79 80 const struct uci_blob_param_list device_attr_list = { 81 .n_params = __DEV_ATTR_MAX, 82 .params = dev_attrs, 83 }; 84 85 static int __devlock = 0; 86 87 int device_type_add(struct device_type *devtype) 88 { 89 if (device_type_get(devtype->name)) { 90 netifd_log_message(L_WARNING, "Device handler '%s' already exists\n", 91 devtype->name); 92 return 1; 93 } 94 95 netifd_log_message(L_NOTICE, "Added device handler type: %s\n", 96 devtype->name); 97 98 list_add(&devtype->list, &devtypes); 99 return 0; 100 } 101 102 struct device_type * 103 device_type_get(const char *tname) 104 { 105 struct device_type *cur; 106 107 list_for_each_entry(cur, &devtypes, list) 108 if (!strcmp(cur->name, tname)) 109 return cur; 110 111 return NULL; 112 } 113 114 static int device_vlan_len(struct kvlist *kv, const void *data) 115 { 116 return sizeof(unsigned int); 117 } 118 119 void device_vlan_update(bool done) 120 { 121 struct device *dev; 122 123 avl_for_each_element(&devices, dev, avl) { 124 if (!dev->vlans.update) 125 continue; 126 127 if (!done) { 128 if (dev->vlan_aliases.get_len) 129 kvlist_free(&dev->vlan_aliases); 130 else 131 kvlist_init(&dev->vlan_aliases, device_vlan_len); 132 vlist_update(&dev->vlans); 133 } else { 134 vlist_flush(&dev->vlans); 135 136 if (dev->type->vlan_update) 137 dev->type->vlan_update(dev); 138 } 139 } 140 } 141 142 void device_stp_init(void) 143 { 144 struct device *dev; 145 146 avl_for_each_element(&devices, dev, avl) { 147 if (!dev->type->stp_init) 148 continue; 149 150 dev->type->stp_init(dev); 151 } 152 } 153 154 static int set_device_state(struct device *dev, bool state) 155 { 156 if (state) { 157 /* Get ifindex for all devices being enabled so a valid */ 158 /* ifindex is in place avoiding possible race conditions */ 159 device_set_ifindex(dev, system_if_resolve(dev)); 160 if (!dev->ifindex) 161 return -1; 162 163 system_if_get_settings(dev, &dev->orig_settings); 164 /* Only keep orig settings based on what needs to be set */ 165 dev->orig_settings.valid_flags = dev->orig_settings.flags; 166 dev->orig_settings.flags &= dev->settings.flags; 167 system_if_apply_settings(dev, &dev->settings, dev->settings.flags); 168 169 system_if_up(dev); 170 171 system_if_apply_settings_after_up(dev, &dev->settings); 172 } else { 173 system_if_down(dev); 174 system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags); 175 176 /* Restore any settings present in UCI which may have 177 * failed to apply so that they will be re-attempted 178 * the next time the device is brought up */ 179 dev->settings.flags |= dev->settings.valid_flags; 180 } 181 182 return 0; 183 } 184 185 static int 186 simple_device_set_state(struct device *dev, bool state) 187 { 188 struct device *pdev; 189 int ret = 0; 190 191 pdev = dev->parent.dev; 192 if (state && !pdev) { 193 pdev = system_if_get_parent(dev); 194 if (pdev) 195 device_add_user(&dev->parent, pdev); 196 } 197 198 if (pdev) { 199 if (state) 200 ret = device_claim(&dev->parent); 201 else 202 device_release(&dev->parent); 203 204 if (ret < 0) 205 return ret; 206 } 207 return set_device_state(dev, state); 208 } 209 210 static struct device * 211 simple_device_create(const char *name, struct device_type *devtype, 212 struct blob_attr *attr) 213 { 214 struct blob_attr *tb[__DEV_ATTR_MAX]; 215 struct device *dev = NULL; 216 217 /* device type is unused for simple devices */ 218 devtype = NULL; 219 220 blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr)); 221 dev = device_get(name, true); 222 if (!dev) 223 return NULL; 224 225 dev->set_state = simple_device_set_state; 226 device_init_settings(dev, tb); 227 228 return dev; 229 } 230 231 static void simple_device_free(struct device *dev) 232 { 233 if (dev->parent.dev) 234 device_remove_user(&dev->parent); 235 free(dev); 236 } 237 238 struct device_type simple_device_type = { 239 .name = "Network device", 240 .config_params = &device_attr_list, 241 242 .create = simple_device_create, 243 .check_state = system_if_check, 244 .free = simple_device_free, 245 }; 246 247 void 248 device_merge_settings(struct device *dev, struct device_settings *n) 249 { 250 struct device_settings *os = &dev->orig_settings; 251 struct device_settings *s = &dev->settings; 252 253 memset(n, 0, sizeof(*n)); 254 n->mtu = s->flags & DEV_OPT_MTU ? s->mtu : os->mtu; 255 n->mtu6 = s->flags & DEV_OPT_MTU6 ? s->mtu6 : os->mtu6; 256 n->txqueuelen = s->flags & DEV_OPT_TXQUEUELEN ? 257 s->txqueuelen : os->txqueuelen; 258 memcpy(n->macaddr, 259 (s->flags & (DEV_OPT_MACADDR|DEV_OPT_DEFAULT_MACADDR) ? s->macaddr : os->macaddr), 260 sizeof(n->macaddr)); 261 n->ipv6 = s->flags & DEV_OPT_IPV6 ? s->ipv6 : os->ipv6; 262 n->ip6segmentrouting = s->flags & DEV_OPT_IP6SEGMENTROUTING ? s->ip6segmentrouting : os->ip6segmentrouting; 263 n->promisc = s->flags & DEV_OPT_PROMISC ? s->promisc : os->promisc; 264 n->rpfilter = s->flags & DEV_OPT_RPFILTER ? s->rpfilter : os->rpfilter; 265 n->acceptlocal = s->flags & DEV_OPT_ACCEPTLOCAL ? s->acceptlocal : os->acceptlocal; 266 n->igmpversion = s->flags & DEV_OPT_IGMPVERSION ? s->igmpversion : os->igmpversion; 267 n->mldversion = s->flags & DEV_OPT_MLDVERSION ? s->mldversion : os->mldversion; 268 n->neigh4reachabletime = s->flags & DEV_OPT_NEIGHREACHABLETIME ? 269 s->neigh4reachabletime : os->neigh4reachabletime; 270 n->neigh6reachabletime = s->flags & DEV_OPT_NEIGHREACHABLETIME ? 271 s->neigh6reachabletime : os->neigh6reachabletime; 272 n->neigh4gcstaletime = s->flags & DEV_OPT_NEIGHGCSTALETIME ? 273 s->neigh4gcstaletime : os->neigh4gcstaletime; 274 n->neigh6gcstaletime = s->flags & DEV_OPT_NEIGHGCSTALETIME ? 275 s->neigh6gcstaletime : os->neigh6gcstaletime; 276 n->neigh4locktime = s->flags & DEV_OPT_NEIGHLOCKTIME ? 277 s->neigh4locktime : os->neigh4locktime; 278 n->dadtransmits = s->flags & DEV_OPT_DADTRANSMITS ? 279 s->dadtransmits : os->dadtransmits; 280 n->multicast = s->flags & DEV_OPT_MULTICAST ? 281 s->multicast : os->multicast; 282 n->multicast_to_unicast = s->multicast_to_unicast; 283 n->multicast_router = s->multicast_router; 284 n->multicast_fast_leave = s->multicast_fast_leave; 285 n->learning = s->learning; 286 n->unicast_flood = s->unicast_flood; 287 n->sendredirects = s->flags & DEV_OPT_SENDREDIRECTS ? 288 s->sendredirects : os->sendredirects; 289 n->drop_v4_unicast_in_l2_multicast = s->flags & DEV_OPT_DROP_V4_UNICAST_IN_L2_MULTICAST ? 290 s->drop_v4_unicast_in_l2_multicast : os->drop_v4_unicast_in_l2_multicast; 291 n->drop_v6_unicast_in_l2_multicast = s->flags & DEV_OPT_DROP_V6_UNICAST_IN_L2_MULTICAST ? 292 s->drop_v6_unicast_in_l2_multicast : os->drop_v6_unicast_in_l2_multicast; 293 n->drop_gratuitous_arp = s->flags & DEV_OPT_DROP_GRATUITOUS_ARP ? 294 s->drop_gratuitous_arp : os->drop_gratuitous_arp; 295 n->drop_unsolicited_na = s->flags & DEV_OPT_DROP_UNSOLICITED_NA ? 296 s->drop_unsolicited_na : os->drop_unsolicited_na; 297 n->arp_accept = s->flags & DEV_OPT_ARP_ACCEPT ? 298 s->arp_accept : os->arp_accept; 299 n->auth = s->flags & DEV_OPT_AUTH ? s->auth : os->auth; 300 n->speed = s->flags & DEV_OPT_SPEED ? s->speed : os->speed; 301 n->duplex = s->flags & DEV_OPT_DUPLEX ? s->duplex : os->duplex; 302 n->pause = s->flags & DEV_OPT_PAUSE ? s->pause : os->pause; 303 n->asym_pause = s->flags & DEV_OPT_ASYM_PAUSE ? s->asym_pause : os->asym_pause; 304 n->rxpause = s->flags & DEV_OPT_RXPAUSE ? s->rxpause : os->rxpause; 305 n->txpause = s->flags & DEV_OPT_TXPAUSE ? s->txpause : os->txpause; 306 n->autoneg = s->flags & DEV_OPT_AUTONEG ? s->autoneg : os->autoneg; 307 n->gro = s->flags & DEV_OPT_GRO ? s->gro : os->gro; 308 n->eee = s->flags & DEV_OPT_EEE ? s->eee : os->eee; 309 n->master_ifindex = s->flags & DEV_OPT_MASTER ? s->master_ifindex : os->master_ifindex; 310 n->flags = s->flags | os->flags | os->valid_flags; 311 } 312 313 static bool device_fill_vlan_range(struct device_vlan_range *r, const char *val) 314 { 315 unsigned long cur_start, cur_end; 316 char *sep; 317 318 cur_start = strtoul(val, &sep, 0); 319 cur_end = cur_start; 320 321 if (*sep == '-') 322 cur_end = strtoul(sep + 1, &sep, 0); 323 if (*sep || cur_end < cur_start) 324 return false; 325 326 r->start = cur_start; 327 r->end = cur_end; 328 329 return true; 330 } 331 332 static void 333 device_set_extra_vlans(struct device *dev, struct blob_attr *data) 334 { 335 struct blob_attr *cur; 336 int n_vlans; 337 size_t rem; 338 339 dev->n_extra_vlan = 0; 340 if (!data) 341 return; 342 343 n_vlans = blobmsg_check_array(data, BLOBMSG_TYPE_STRING); 344 if (n_vlans < 1) 345 return; 346 347 dev->extra_vlan = realloc(dev->extra_vlan, n_vlans * sizeof(*dev->extra_vlan)); 348 blobmsg_for_each_attr(cur, data, rem) 349 if (device_fill_vlan_range(&dev->extra_vlan[dev->n_extra_vlan], 350 blobmsg_get_string(cur))) 351 dev->n_extra_vlan++; 352 } 353 354 void 355 device_init_settings(struct device *dev, struct blob_attr **tb) 356 { 357 struct device_settings *s = &dev->settings; 358 struct blob_attr *cur; 359 struct ether_addr *ea; 360 bool disabled = false; 361 362 if (dev->wireless) 363 s->flags &= DEV_OPT_ISOLATE; 364 else 365 s->flags = 0; 366 if ((cur = tb[DEV_ATTR_ENABLED])) 367 disabled = !blobmsg_get_bool(cur); 368 369 if ((cur = tb[DEV_ATTR_MTU]) && blobmsg_get_u32(cur) >= 68) { 370 s->mtu = blobmsg_get_u32(cur); 371 s->flags |= DEV_OPT_MTU; 372 } 373 374 if ((cur = tb[DEV_ATTR_MTU6]) && blobmsg_get_u32(cur) >= 1280) { 375 s->mtu6 = blobmsg_get_u32(cur); 376 s->flags |= DEV_OPT_MTU6; 377 } 378 379 if ((cur = tb[DEV_ATTR_TXQUEUELEN])) { 380 s->txqueuelen = blobmsg_get_u32(cur); 381 s->flags |= DEV_OPT_TXQUEUELEN; 382 } 383 384 if ((cur = tb[DEV_ATTR_MACADDR])) { 385 ea = ether_aton(blobmsg_data(cur)); 386 if (ea) { 387 memcpy(s->macaddr, ea, 6); 388 s->flags |= DEV_OPT_MACADDR; 389 } 390 } 391 392 if ((cur = tb[DEV_ATTR_IPV6])) { 393 s->ipv6 = blobmsg_get_bool(cur); 394 s->flags |= DEV_OPT_IPV6; 395 } 396 397 if ((cur = tb[DEV_ATTR_IP6SEGMENTROUTING])) { 398 s->ip6segmentrouting = blobmsg_get_bool(cur); 399 s->flags |= DEV_OPT_IP6SEGMENTROUTING; 400 } 401 402 if ((cur = tb[DEV_ATTR_PROMISC])) { 403 s->promisc = blobmsg_get_bool(cur); 404 s->flags |= DEV_OPT_PROMISC; 405 } 406 407 if ((cur = tb[DEV_ATTR_RPFILTER])) { 408 if (system_resolve_rpfilter(blobmsg_data(cur), &s->rpfilter)) 409 s->flags |= DEV_OPT_RPFILTER; 410 else 411 D(DEVICE, "Failed to resolve rpfilter: %s", (char *) blobmsg_data(cur)); 412 } 413 414 if ((cur = tb[DEV_ATTR_ACCEPTLOCAL])) { 415 s->acceptlocal = blobmsg_get_bool(cur); 416 s->flags |= DEV_OPT_ACCEPTLOCAL; 417 } 418 419 if ((cur = tb[DEV_ATTR_IGMPVERSION])) { 420 s->igmpversion = blobmsg_get_u32(cur); 421 if (s->igmpversion >= 1 && s->igmpversion <= 3) 422 s->flags |= DEV_OPT_IGMPVERSION; 423 else 424 D(DEVICE, "Failed to resolve igmpversion: %d", blobmsg_get_u32(cur)); 425 } 426 427 if ((cur = tb[DEV_ATTR_MLDVERSION])) { 428 s->mldversion = blobmsg_get_u32(cur); 429 if (s->mldversion >= 1 && s->mldversion <= 2) 430 s->flags |= DEV_OPT_MLDVERSION; 431 else 432 D(DEVICE, "Failed to resolve mldversion: %d", blobmsg_get_u32(cur)); 433 } 434 435 if ((cur = tb[DEV_ATTR_NEIGHREACHABLETIME])) { 436 s->neigh6reachabletime = s->neigh4reachabletime = blobmsg_get_u32(cur); 437 s->flags |= DEV_OPT_NEIGHREACHABLETIME; 438 } 439 440 if ((cur = tb[DEV_ATTR_NEIGHGCSTALETIME])) { 441 s->neigh6gcstaletime = s->neigh4gcstaletime = blobmsg_get_u32(cur); 442 s->flags |= DEV_OPT_NEIGHGCSTALETIME; 443 } 444 445 if ((cur = tb[DEV_ATTR_NEIGHLOCKTIME])) { 446 s->neigh4locktime = blobmsg_get_u32(cur); 447 s->flags |= DEV_OPT_NEIGHLOCKTIME; 448 } 449 450 if ((cur = tb[DEV_ATTR_DADTRANSMITS])) { 451 s->dadtransmits = blobmsg_get_u32(cur); 452 s->flags |= DEV_OPT_DADTRANSMITS; 453 } 454 455 if ((cur = tb[DEV_ATTR_MULTICAST_TO_UNICAST])) { 456 s->multicast_to_unicast = blobmsg_get_bool(cur); 457 s->flags |= DEV_OPT_MULTICAST_TO_UNICAST; 458 } 459 460 if ((cur = tb[DEV_ATTR_MULTICAST_ROUTER])) { 461 s->multicast_router = blobmsg_get_u32(cur); 462 if (s->multicast_router <= 2) 463 s->flags |= DEV_OPT_MULTICAST_ROUTER; 464 else 465 D(DEVICE, "Invalid value: %d - (Use 0: never, 1: learn, 2: always)", blobmsg_get_u32(cur)); 466 } 467 468 if ((cur = tb[DEV_ATTR_MULTICAST_FAST_LEAVE])) { 469 s->multicast_fast_leave = blobmsg_get_bool(cur); 470 s->flags |= DEV_OPT_MULTICAST_FAST_LEAVE; 471 } 472 473 if ((cur = tb[DEV_ATTR_MULTICAST])) { 474 s->multicast = blobmsg_get_bool(cur); 475 s->flags |= DEV_OPT_MULTICAST; 476 } 477 478 if ((cur = tb[DEV_ATTR_LEARNING])) { 479 s->learning = blobmsg_get_bool(cur); 480 s->flags |= DEV_OPT_LEARNING; 481 } 482 483 if ((cur = tb[DEV_ATTR_UNICAST_FLOOD])) { 484 s->unicast_flood = blobmsg_get_bool(cur); 485 s->flags |= DEV_OPT_UNICAST_FLOOD; 486 } 487 488 if ((cur = tb[DEV_ATTR_SENDREDIRECTS])) { 489 s->sendredirects = blobmsg_get_bool(cur); 490 s->flags |= DEV_OPT_SENDREDIRECTS; 491 } 492 493 if ((cur = tb[DEV_ATTR_ISOLATE])) { 494 s->isolate = blobmsg_get_bool(cur); 495 s->flags |= DEV_OPT_ISOLATE; 496 } 497 498 if ((cur = tb[DEV_ATTR_DROP_V4_UNICAST_IN_L2_MULTICAST])) { 499 s->drop_v4_unicast_in_l2_multicast = blobmsg_get_bool(cur); 500 s->flags |= DEV_OPT_DROP_V4_UNICAST_IN_L2_MULTICAST; 501 } 502 503 if ((cur = tb[DEV_ATTR_DROP_V6_UNICAST_IN_L2_MULTICAST])) { 504 s->drop_v6_unicast_in_l2_multicast = blobmsg_get_bool(cur); 505 s->flags |= DEV_OPT_DROP_V6_UNICAST_IN_L2_MULTICAST; 506 } 507 508 if ((cur = tb[DEV_ATTR_DROP_GRATUITOUS_ARP])) { 509 s->drop_gratuitous_arp = blobmsg_get_bool(cur); 510 s->flags |= DEV_OPT_DROP_GRATUITOUS_ARP; 511 } 512 513 if ((cur = tb[DEV_ATTR_DROP_UNSOLICITED_NA])) { 514 s->drop_unsolicited_na = blobmsg_get_bool(cur); 515 s->flags |= DEV_OPT_DROP_UNSOLICITED_NA; 516 } 517 518 if ((cur = tb[DEV_ATTR_ARP_ACCEPT])) { 519 s->arp_accept = blobmsg_get_bool(cur); 520 s->flags |= DEV_OPT_ARP_ACCEPT; 521 } 522 523 if ((cur = tb[DEV_ATTR_AUTH])) { 524 s->auth = blobmsg_get_bool(cur); 525 s->flags |= DEV_OPT_AUTH; 526 } 527 528 if ((cur = tb[DEV_ATTR_SPEED])) { 529 s->speed = blobmsg_get_u32(cur); 530 s->flags |= DEV_OPT_SPEED; 531 } 532 533 if ((cur = tb[DEV_ATTR_DUPLEX])) { 534 s->duplex = blobmsg_get_bool(cur); 535 s->flags |= DEV_OPT_DUPLEX; 536 } 537 538 if ((cur = tb[DEV_ATTR_PAUSE])) { 539 s->pause = blobmsg_get_bool(cur); 540 s->flags |= DEV_OPT_PAUSE; 541 } 542 543 if ((cur = tb[DEV_ATTR_ASYM_PAUSE])) { 544 s->asym_pause = blobmsg_get_bool(cur); 545 s->flags |= DEV_OPT_ASYM_PAUSE; 546 } 547 548 if ((cur = tb[DEV_ATTR_RXPAUSE])) { 549 s->rxpause = blobmsg_get_bool(cur); 550 s->flags |= DEV_OPT_RXPAUSE; 551 } 552 553 if ((cur = tb[DEV_ATTR_TXPAUSE])) { 554 s->txpause = blobmsg_get_bool(cur); 555 s->flags |= DEV_OPT_TXPAUSE; 556 } 557 558 if ((cur = tb[DEV_ATTR_AUTONEG])) { 559 s->autoneg = blobmsg_get_bool(cur); 560 s->flags |= DEV_OPT_AUTONEG; 561 } 562 563 if ((cur = tb[DEV_ATTR_GRO])) { 564 s->gro = blobmsg_get_bool(cur); 565 s->flags |= DEV_OPT_GRO; 566 } 567 568 if ((cur = tb[DEV_ATTR_MASTER])) { 569 char *ifname = blobmsg_get_string(cur); 570 s->master_ifindex = if_nametoindex(ifname); 571 s->flags |= DEV_OPT_MASTER; 572 } 573 574 if ((cur = tb[DEV_ATTR_EEE])) { 575 s->eee = blobmsg_get_bool(cur); 576 s->flags |= DEV_OPT_EEE; 577 } 578 579 /* Remember the settings present in UCI */ 580 s->valid_flags = s->flags; 581 582 cur = tb[DEV_ATTR_AUTH_VLAN]; 583 free(dev->config_auth_vlans); 584 dev->config_auth_vlans = cur ? blob_memdup(cur) : NULL; 585 586 device_set_extra_vlans(dev, tb[DEV_ATTR_VLAN]); 587 device_set_disabled(dev, disabled); 588 } 589 590 static void __init dev_init(void) 591 { 592 avl_init(&devices, avl_strcmp, true, NULL); 593 } 594 595 static int device_release_cb(void *ctx, struct safe_list *list) 596 { 597 struct device_user *dep = container_of(list, struct device_user, list); 598 599 if (!dep->dev || !dep->claimed) 600 return 0; 601 602 device_release(dep); 603 return 0; 604 } 605 606 static int device_broadcast_cb(void *ctx, struct safe_list *list) 607 { 608 struct device_user *dep = container_of(list, struct device_user, list); 609 int *ev = ctx; 610 611 /* device might have been removed by an earlier callback */ 612 if (!dep->dev) 613 return 0; 614 615 if (dep->cb) 616 dep->cb(dep, *ev); 617 return 0; 618 } 619 620 void device_broadcast_event(struct device *dev, enum device_event ev) 621 { 622 static const char * const event_names[] = { 623 [DEV_EVENT_ADD] = "add", 624 [DEV_EVENT_REMOVE] = "remove", 625 [DEV_EVENT_UP] = "up", 626 [DEV_EVENT_DOWN] = "down", 627 [DEV_EVENT_AUTH_UP] = "auth_up", 628 [DEV_EVENT_LINK_UP] = "link_up", 629 [DEV_EVENT_LINK_DOWN] = "link_down", 630 [DEV_EVENT_TOPO_CHANGE] = "topo_change", 631 }; 632 int dev_ev = ev; 633 634 safe_list_for_each(&dev->aliases, device_broadcast_cb, &dev_ev); 635 safe_list_for_each(&dev->users, device_broadcast_cb, &dev_ev); 636 637 if (ev >= ARRAY_SIZE(event_names) || !event_names[ev] || !dev->ifname[0]) 638 return; 639 640 blob_buf_init(&b, 0); 641 blobmsg_add_string(&b, "name", dev->ifname); 642 blobmsg_add_u8(&b, "auth_status", dev->auth_status); 643 blobmsg_add_u8(&b, "present", dev->present); 644 blobmsg_add_u8(&b, "active", dev->active); 645 blobmsg_add_u8(&b, "link_active", dev->link_active); 646 netifd_ubus_device_notify(event_names[ev], b.head, -1); 647 } 648 649 static void 650 device_fill_default_settings(struct device *dev) 651 { 652 struct device_settings *s = &dev->settings; 653 struct ether_addr *ea; 654 const char *master; 655 int ret; 656 657 if (!(s->flags & DEV_OPT_MACADDR)) { 658 ea = config_get_default_macaddr(dev->ifname); 659 if (ea) { 660 memcpy(s->macaddr, ea, 6); 661 s->flags |= DEV_OPT_DEFAULT_MACADDR; 662 } 663 } 664 665 if (!(s->flags & DEV_OPT_GRO)) { 666 ret = config_get_default_gro(dev->ifname); 667 if (ret >= 0) { 668 s->gro = ret; 669 s->flags |= DEV_OPT_GRO; 670 } 671 } 672 673 if (!(s->flags & DEV_OPT_MASTER)) { 674 master = config_get_default_conduit(dev->ifname); 675 if (master) { 676 s->master_ifindex = if_nametoindex(master); 677 s->flags |= DEV_OPT_MASTER; 678 } 679 } 680 } 681 682 int device_claim(struct device_user *dep) 683 { 684 struct device *dev = dep->dev; 685 int ret = 0; 686 687 if (dep->claimed) 688 return 0; 689 690 if (!dev) 691 return -1; 692 693 dep->claimed = true; 694 D(DEVICE, "Claim %s %s, new active count: %d", dev->type->name, dev->ifname, dev->active + 1); 695 if (++dev->active != 1) 696 return 0; 697 698 device_broadcast_event(dev, DEV_EVENT_SETUP); 699 device_fill_default_settings(dev); 700 if (dev->external) { 701 /* Get ifindex for external claimed devices so a valid */ 702 /* ifindex is in place avoiding possible race conditions */ 703 device_set_ifindex(dev, system_if_resolve(dev)); 704 if (!dev->ifindex) 705 ret = -1; 706 707 system_if_get_settings(dev, &dev->orig_settings); 708 } else 709 ret = dev->set_state(dev, true); 710 711 if (ret == 0) 712 device_broadcast_event(dev, DEV_EVENT_UP); 713 else { 714 D(DEVICE, "claim %s %s failed: %d", dev->type->name, dev->ifname, ret); 715 dev->active = 0; 716 dep->claimed = false; 717 } 718 719 return ret; 720 } 721 722 void device_release(struct device_user *dep) 723 { 724 struct device *dev = dep->dev; 725 726 if (!dep->claimed) 727 return; 728 729 dep->claimed = false; 730 dev->active--; 731 D(DEVICE, "Release %s %s, new active count: %d", dev->type->name, dev->ifname, dev->active); 732 assert(dev->active >= 0); 733 734 if (dev->active) 735 return; 736 737 device_broadcast_event(dev, DEV_EVENT_TEARDOWN); 738 if (!dev->external) 739 dev->set_state(dev, false); 740 741 if (dev->active) 742 return; 743 744 device_broadcast_event(dev, DEV_EVENT_DOWN); 745 } 746 747 int device_check_state(struct device *dev) 748 { 749 if (!dev->type->check_state) 750 return simple_device_type.check_state(dev); 751 752 return dev->type->check_state(dev); 753 } 754 755 int device_init_virtual(struct device *dev, struct device_type *type, const char *name) 756 { 757 assert(dev); 758 assert(type); 759 760 D(DEVICE, "Initialize device '%s'", name ? name : ""); 761 INIT_SAFE_LIST(&dev->users); 762 INIT_SAFE_LIST(&dev->aliases); 763 dev->type = type; 764 765 if (name) { 766 int ret; 767 768 ret = device_set_ifname(dev, name); 769 if (ret < 0) { 770 netifd_log_message(L_WARNING, "Failed to initalize device '%s'\n", name); 771 return ret; 772 } 773 } 774 775 if (!dev->set_state) 776 dev->set_state = set_device_state; 777 778 return 0; 779 } 780 781 int device_init(struct device *dev, struct device_type *type, const char *ifname) 782 { 783 int ret; 784 785 ret = device_init_virtual(dev, type, ifname); 786 if (ret < 0) 787 return ret; 788 789 dev->avl.key = dev->ifname; 790 791 ret = avl_insert(&devices, &dev->avl); 792 if (ret < 0) 793 return ret; 794 795 system_if_clear_state(dev); 796 797 return 0; 798 } 799 800 static struct device * 801 device_create_default(const char *name, bool external) 802 { 803 struct device *dev; 804 805 if (!external && system_if_force_external(name)) 806 return NULL; 807 808 D(DEVICE, "Create simple device '%s'", name); 809 dev = calloc(1, sizeof(*dev)); 810 if (!dev) 811 return NULL; 812 813 dev->external = external; 814 dev->set_state = simple_device_set_state; 815 816 if (device_init(dev, &simple_device_type, name) < 0) { 817 device_cleanup(dev); 818 free(dev); 819 return NULL; 820 } 821 822 dev->default_config = true; 823 if (external) 824 system_if_apply_settings(dev, &dev->settings, dev->settings.flags); 825 826 device_check_state(dev); 827 828 return dev; 829 } 830 831 struct device * 832 device_find(const char *name) 833 { 834 struct device *dev; 835 836 return avl_find_element(&devices, name, dev, avl); 837 } 838 839 struct device * 840 __device_get(const char *name, int create, bool check_vlan) 841 { 842 struct device *dev; 843 844 dev = avl_find_element(&devices, name, dev, avl); 845 846 if (!dev && check_vlan && strchr(name, '.')) 847 return get_vlan_device_chain(name, create); 848 849 if (name[0] == '@') 850 return device_alias_get(name + 1); 851 852 if (dev) { 853 if (create > 1 && !dev->external) { 854 system_if_apply_settings(dev, &dev->settings, dev->settings.flags); 855 dev->external = true; 856 device_set_present(dev, true); 857 } 858 return dev; 859 } 860 861 if (!create) 862 return NULL; 863 864 return device_create_default(name, create > 1); 865 } 866 867 static void 868 device_delete(struct device *dev) 869 { 870 if (!dev->avl.key) 871 return; 872 873 D(DEVICE, "Delete device '%s' from list", dev->ifname); 874 avl_delete(&devices, &dev->avl); 875 dev->avl.key = NULL; 876 } 877 878 static int device_cleanup_cb(void *ctx, struct safe_list *list) 879 { 880 struct device_user *dep = container_of(list, struct device_user, list); 881 if (dep->cb) 882 dep->cb(dep, DEV_EVENT_REMOVE); 883 884 device_release(dep); 885 return 0; 886 } 887 888 void device_cleanup(struct device *dev) 889 { 890 D(DEVICE, "Clean up device '%s'", dev->ifname); 891 safe_list_for_each(&dev->users, device_cleanup_cb, NULL); 892 safe_list_for_each(&dev->aliases, device_cleanup_cb, NULL); 893 device_delete(dev); 894 } 895 896 static void __device_set_present(struct device *dev, bool state, bool force) 897 { 898 if (dev->present == state && !force) 899 return; 900 901 dev->present = state; 902 device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE); 903 } 904 905 void 906 device_refresh_present(struct device *dev) 907 { 908 bool state = dev->sys_present; 909 910 if (dev->disabled || dev->deferred) 911 state = false; 912 913 __device_set_present(dev, state, false); 914 } 915 916 void 917 device_set_auth_status(struct device *dev, bool value, struct blob_attr *vlans) 918 { 919 if (!value) 920 vlans = NULL; 921 else if (!blob_attr_equal(vlans, dev->auth_vlans)) 922 device_set_auth_status(dev, false, NULL); 923 924 free(dev->auth_vlans); 925 dev->auth_vlans = vlans ? blob_memdup(vlans) : NULL; 926 927 if (dev->auth_status == value) 928 return; 929 930 dev->auth_status = value; 931 if (!dev->present) 932 return; 933 934 if (dev->auth_status) { 935 device_broadcast_event(dev, DEV_EVENT_AUTH_UP); 936 return; 937 } 938 939 device_broadcast_event(dev, DEV_EVENT_LINK_DOWN); 940 if (!dev->link_active) 941 return; 942 943 device_broadcast_event(dev, DEV_EVENT_LINK_UP); 944 } 945 946 void device_set_present(struct device *dev, bool state) 947 { 948 if (dev->sys_present == state) 949 return; 950 951 D(DEVICE, "%s '%s' %s present", dev->type->name, dev->ifname, state ? "is now" : "is no longer" ); 952 dev->sys_present = state; 953 if (!state) 954 __device_set_present(dev, state, true); 955 else 956 device_refresh_present(dev); 957 if (!state) 958 safe_list_for_each(&dev->users, device_release_cb, NULL); 959 } 960 961 void device_set_link(struct device *dev, bool state) 962 { 963 if (dev->link_active == state) 964 return; 965 966 netifd_log_message(L_NOTICE, "%s '%s' link is %s\n", dev->type->name, dev->ifname, state ? "up" : "down" ); 967 968 dev->link_active = state; 969 if (!state) 970 dev->auth_status = false; 971 device_broadcast_event(dev, state ? DEV_EVENT_LINK_UP : DEV_EVENT_LINK_DOWN); 972 } 973 974 void device_set_ifindex(struct device *dev, int ifindex) 975 { 976 if (dev->ifindex == ifindex) 977 return; 978 979 dev->ifindex = ifindex; 980 device_broadcast_event(dev, DEV_EVENT_UPDATE_IFINDEX); 981 } 982 983 int device_set_ifname(struct device *dev, const char *name) 984 { 985 int ret = 0; 986 987 if (!strcmp(dev->ifname, name)) 988 return 0; 989 990 if (strlen(name) > sizeof(dev->ifname) - 1) { 991 netifd_log_message(L_WARNING, "Cannot set device name: '%s' is longer than max size %zd\n", 992 name, sizeof(dev->ifname) - 1); 993 return -1; 994 } 995 996 if (dev->avl.key) 997 avl_delete(&devices, &dev->avl); 998 999 strcpy(dev->ifname, name); 1000 1001 if (dev->avl.key) 1002 ret = avl_insert(&devices, &dev->avl); 1003 1004 if (ret == 0) 1005 device_broadcast_event(dev, DEV_EVENT_UPDATE_IFNAME); 1006 1007 return ret; 1008 } 1009 1010 static int device_refcount(struct device *dev) 1011 { 1012 struct list_head *list; 1013 int count = 0; 1014 1015 list_for_each(list, &dev->users.list) 1016 count++; 1017 1018 list_for_each(list, &dev->aliases.list) 1019 count++; 1020 1021 return count; 1022 } 1023 1024 static void 1025 __device_add_user(struct device_user *dep, struct device *dev) 1026 { 1027 struct safe_list *head; 1028 1029 dep->dev = dev; 1030 1031 if (dep->alias) 1032 head = &dev->aliases; 1033 else 1034 head = &dev->users; 1035 1036 safe_list_add(&dep->list, head); 1037 D(DEVICE, "Add user for device '%s', refcount=%d", dev->ifname, device_refcount(dev)); 1038 1039 if (dep->cb && dev->present) { 1040 dep->cb(dep, DEV_EVENT_ADD); 1041 if (dev->active) 1042 dep->cb(dep, DEV_EVENT_UP); 1043 1044 if (dev->link_active) 1045 dep->cb(dep, DEV_EVENT_LINK_UP); 1046 } 1047 } 1048 1049 void device_add_user(struct device_user *dep, struct device *dev) 1050 { 1051 if (dep->dev == dev) 1052 return; 1053 1054 if (dep->dev) 1055 device_remove_user(dep); 1056 1057 if (!dev) 1058 return; 1059 1060 __device_add_user(dep, dev); 1061 } 1062 1063 static void 1064 device_free(struct device *dev) 1065 { 1066 __devlock++; 1067 free(dev->auth_vlans); 1068 free(dev->config); 1069 device_cleanup(dev); 1070 free(dev->config_auth_vlans); 1071 free(dev->extra_vlan); 1072 dev->type->free(dev); 1073 __devlock--; 1074 } 1075 1076 static void 1077 __device_free_unused(struct uloop_timeout *timeout) 1078 { 1079 struct device *dev, *tmp; 1080 1081 avl_for_each_element_safe(&devices, dev, avl, tmp) { 1082 if (!safe_list_empty(&dev->users) || 1083 !safe_list_empty(&dev->aliases) || 1084 dev->current_config) 1085 continue; 1086 1087 device_free(dev); 1088 } 1089 } 1090 1091 void device_free_unused(void) 1092 { 1093 static struct uloop_timeout free_timer = { 1094 .cb = __device_free_unused, 1095 }; 1096 1097 uloop_timeout_set(&free_timer, 1); 1098 } 1099 1100 void device_remove_user(struct device_user *dep) 1101 { 1102 struct device *dev = dep->dev; 1103 1104 if (!dep->dev) 1105 return; 1106 1107 dep->hotplug = false; 1108 if (dep->claimed) 1109 device_release(dep); 1110 1111 safe_list_del(&dep->list); 1112 dep->dev = NULL; 1113 D(DEVICE, "Remove user for device '%s', refcount=%d", dev->ifname, device_refcount(dev)); 1114 device_free_unused(); 1115 } 1116 1117 void 1118 device_init_pending(void) 1119 { 1120 struct device *dev, *tmp; 1121 1122 avl_for_each_element_safe(&devices, dev, avl, tmp) { 1123 if (!dev->config_pending) 1124 continue; 1125 1126 dev->type->config_init(dev); 1127 dev->config_pending = false; 1128 device_check_state(dev); 1129 } 1130 } 1131 1132 bool 1133 device_check_ip6segmentrouting(void) 1134 { 1135 struct device *dev; 1136 bool ip6segmentrouting = false; 1137 1138 avl_for_each_element(&devices, dev, avl) 1139 ip6segmentrouting |= dev->settings.ip6segmentrouting; 1140 1141 return ip6segmentrouting; 1142 } 1143 1144 static enum dev_change_type 1145 device_set_config(struct device *dev, struct device_type *type, 1146 struct blob_attr *attr) 1147 { 1148 struct blob_attr *tb[__DEV_ATTR_MAX]; 1149 const struct uci_blob_param_list *cfg = type->config_params; 1150 1151 if (type != dev->type) 1152 return DEV_CONFIG_RECREATE; 1153 1154 if (dev->type->reload) 1155 return dev->type->reload(dev, attr); 1156 1157 if (uci_blob_check_equal(dev->config, attr, cfg)) 1158 return DEV_CONFIG_NO_CHANGE; 1159 1160 if (cfg == &device_attr_list) { 1161 memset(tb, 0, sizeof(tb)); 1162 1163 if (attr) 1164 blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, 1165 blob_data(attr), blob_len(attr)); 1166 1167 device_init_settings(dev, tb); 1168 return DEV_CONFIG_RESTART; 1169 } else 1170 return DEV_CONFIG_RECREATE; 1171 } 1172 1173 enum dev_change_type 1174 device_apply_config(struct device *dev, struct device_type *type, 1175 struct blob_attr *config) 1176 { 1177 enum dev_change_type change; 1178 1179 change = device_set_config(dev, type, config); 1180 if (dev->external) { 1181 system_if_apply_settings(dev, &dev->settings, dev->settings.flags); 1182 change = DEV_CONFIG_APPLIED; 1183 } 1184 1185 switch (change) { 1186 case DEV_CONFIG_RESTART: 1187 case DEV_CONFIG_APPLIED: 1188 D(DEVICE, "Device '%s': config applied", dev->ifname); 1189 config = blob_memdup(config); 1190 free(dev->config); 1191 dev->config = config; 1192 if (change == DEV_CONFIG_RESTART && dev->present) { 1193 int ret = 0; 1194 1195 device_set_present(dev, false); 1196 if (dev->active && !dev->external) { 1197 ret = dev->set_state(dev, false); 1198 if (!ret) 1199 ret = dev->set_state(dev, true); 1200 } 1201 if (!ret) 1202 device_set_present(dev, true); 1203 } 1204 break; 1205 case DEV_CONFIG_NO_CHANGE: 1206 D(DEVICE, "Device '%s': no configuration change", dev->ifname); 1207 break; 1208 case DEV_CONFIG_RECREATE: 1209 break; 1210 } 1211 1212 return change; 1213 } 1214 1215 static void 1216 device_replace(struct device *dev, struct device *odev) 1217 { 1218 struct device_user *dep; 1219 1220 __devlock++; 1221 if (odev->present) 1222 device_set_present(odev, false); 1223 1224 while (!list_empty(&odev->users.list)) { 1225 dep = list_first_entry(&odev->users.list, struct device_user, list.list); 1226 device_release(dep); 1227 if (!dep->dev) 1228 continue; 1229 1230 safe_list_del(&dep->list); 1231 __device_add_user(dep, dev); 1232 } 1233 __devlock--; 1234 1235 device_free(odev); 1236 } 1237 1238 void 1239 device_reset_config(void) 1240 { 1241 struct device *dev; 1242 1243 avl_for_each_element(&devices, dev, avl) 1244 dev->current_config = false; 1245 } 1246 1247 void 1248 device_reset_old(void) 1249 { 1250 struct device *dev, *tmp, *ndev; 1251 1252 avl_for_each_element_safe(&devices, dev, avl, tmp) { 1253 if (dev->current_config || dev->default_config) 1254 continue; 1255 1256 if (dev->type != &simple_device_type) 1257 continue; 1258 1259 ndev = device_create_default(dev->ifname, dev->external); 1260 if (!ndev) 1261 continue; 1262 1263 device_replace(ndev, dev); 1264 } 1265 } 1266 1267 struct device * 1268 device_create(const char *name, struct device_type *type, 1269 struct blob_attr *config) 1270 { 1271 struct device *odev = NULL, *dev; 1272 enum dev_change_type change; 1273 1274 odev = device_find(name); 1275 if (odev) { 1276 odev->current_config = true; 1277 change = device_apply_config(odev, type, config); 1278 switch (change) { 1279 case DEV_CONFIG_RECREATE: 1280 D(DEVICE, "Device '%s': recreate device", odev->ifname); 1281 device_delete(odev); 1282 break; 1283 default: 1284 return odev; 1285 } 1286 } else 1287 D(DEVICE, "Create new device '%s' (%s)", name, type->name); 1288 1289 config = blob_memdup(config); 1290 if (!config) 1291 return NULL; 1292 1293 dev = type->create(name, type, config); 1294 if (!dev) 1295 return NULL; 1296 1297 dev->current_config = true; 1298 dev->config = config; 1299 if (odev) 1300 device_replace(dev, odev); 1301 1302 if (!config_init && dev->config_pending) { 1303 type->config_init(dev); 1304 dev->config_pending = false; 1305 } 1306 1307 device_check_state(dev); 1308 1309 return dev; 1310 } 1311 1312 void 1313 device_dump_status(struct blob_buf *b, struct device *dev) 1314 { 1315 struct device_settings st; 1316 void *c, *s; 1317 1318 if (!dev) { 1319 avl_for_each_element(&devices, dev, avl) { 1320 if (!dev->present) 1321 continue; 1322 c = blobmsg_open_table(b, dev->ifname); 1323 device_dump_status(b, dev); 1324 blobmsg_close_table(b, c); 1325 } 1326 1327 return; 1328 } 1329 1330 blobmsg_add_u8(b, "external", dev->external); 1331 blobmsg_add_u8(b, "present", dev->present); 1332 blobmsg_add_string(b, "type", dev->type->name); 1333 1334 if (!dev->present) 1335 return; 1336 1337 blobmsg_add_u8(b, "up", !!dev->active); 1338 blobmsg_add_u8(b, "carrier", !!dev->link_active); 1339 blobmsg_add_u8(b, "auth_status", !!dev->auth_status); 1340 1341 if (dev->type->dump_info) 1342 dev->type->dump_info(dev, b); 1343 else 1344 system_if_dump_info(dev, b); 1345 1346 if (dev->active) { 1347 device_merge_settings(dev, &st); 1348 if (st.flags & DEV_OPT_MASTER) { 1349 char buf[64], *devname; 1350 1351 devname = if_indextoname(st.master_ifindex, buf); 1352 if (devname) 1353 blobmsg_add_string(b, "conduit", devname); 1354 } 1355 if (st.flags & DEV_OPT_MTU) 1356 blobmsg_add_u32(b, "mtu", st.mtu); 1357 if (st.flags & DEV_OPT_MTU6) 1358 blobmsg_add_u32(b, "mtu6", st.mtu6); 1359 if (st.flags & DEV_OPT_MACADDR) 1360 blobmsg_add_string(b, "macaddr", format_macaddr(st.macaddr)); 1361 if (st.flags & DEV_OPT_TXQUEUELEN) 1362 blobmsg_add_u32(b, "txqueuelen", st.txqueuelen); 1363 if (st.flags & DEV_OPT_IPV6) 1364 blobmsg_add_u8(b, "ipv6", st.ipv6); 1365 if (st.flags & DEV_OPT_IP6SEGMENTROUTING) 1366 blobmsg_add_u8(b, "ip6segmentrouting", st.ip6segmentrouting); 1367 if (st.flags & DEV_OPT_PROMISC) 1368 blobmsg_add_u8(b, "promisc", st.promisc); 1369 if (st.flags & DEV_OPT_RPFILTER) 1370 blobmsg_add_u32(b, "rpfilter", st.rpfilter); 1371 if (st.flags & DEV_OPT_ACCEPTLOCAL) 1372 blobmsg_add_u8(b, "acceptlocal", st.acceptlocal); 1373 if (st.flags & DEV_OPT_IGMPVERSION) 1374 blobmsg_add_u32(b, "igmpversion", st.igmpversion); 1375 if (st.flags & DEV_OPT_MLDVERSION) 1376 blobmsg_add_u32(b, "mldversion", st.mldversion); 1377 if (st.flags & DEV_OPT_NEIGHREACHABLETIME) { 1378 blobmsg_add_u32(b, "neigh4reachabletime", st.neigh4reachabletime); 1379 blobmsg_add_u32(b, "neigh6reachabletime", st.neigh6reachabletime); 1380 } 1381 if (st.flags & DEV_OPT_NEIGHGCSTALETIME) { 1382 blobmsg_add_u32(b, "neigh4gcstaletime", st.neigh4gcstaletime); 1383 blobmsg_add_u32(b, "neigh6gcstaletime", st.neigh6gcstaletime); 1384 } 1385 if (st.flags & DEV_OPT_NEIGHLOCKTIME) 1386 blobmsg_add_u32(b, "neigh4locktime", st.neigh4locktime); 1387 if (st.flags & DEV_OPT_DADTRANSMITS) 1388 blobmsg_add_u32(b, "dadtransmits", st.dadtransmits); 1389 if (st.flags & DEV_OPT_MULTICAST_TO_UNICAST) 1390 blobmsg_add_u8(b, "multicast_to_unicast", st.multicast_to_unicast); 1391 if (st.flags & DEV_OPT_MULTICAST_ROUTER) 1392 blobmsg_add_u32(b, "multicast_router", st.multicast_router); 1393 if (st.flags & DEV_OPT_MULTICAST_FAST_LEAVE) 1394 blobmsg_add_u8(b, "multicast_fast_leave", st.multicast_fast_leave); 1395 if (st.flags & DEV_OPT_MULTICAST) 1396 blobmsg_add_u8(b, "multicast", st.multicast); 1397 if (st.flags & DEV_OPT_LEARNING) 1398 blobmsg_add_u8(b, "learning", st.learning); 1399 if (st.flags & DEV_OPT_UNICAST_FLOOD) 1400 blobmsg_add_u8(b, "unicast_flood", st.unicast_flood); 1401 if (st.flags & DEV_OPT_SENDREDIRECTS) 1402 blobmsg_add_u8(b, "sendredirects", st.sendredirects); 1403 if (st.flags & DEV_OPT_DROP_V4_UNICAST_IN_L2_MULTICAST) 1404 blobmsg_add_u8(b, "drop_v4_unicast_in_l2_multicast", st.drop_v4_unicast_in_l2_multicast); 1405 if (st.flags & DEV_OPT_DROP_V6_UNICAST_IN_L2_MULTICAST) 1406 blobmsg_add_u8(b, "drop_v6_unicast_in_l2_multicast", st.drop_v6_unicast_in_l2_multicast); 1407 if (st.flags & DEV_OPT_DROP_GRATUITOUS_ARP) 1408 blobmsg_add_u8(b, "drop_gratuitous_arp", st.drop_gratuitous_arp); 1409 if (st.flags & DEV_OPT_DROP_UNSOLICITED_NA) 1410 blobmsg_add_u8(b, "drop_unsolicited_na", st.drop_unsolicited_na); 1411 if (st.flags & DEV_OPT_ARP_ACCEPT) 1412 blobmsg_add_u8(b, "arp_accept", st.arp_accept); 1413 if (st.flags & DEV_OPT_AUTH) 1414 blobmsg_add_u8(b, "auth", st.auth); 1415 if (st.flags & DEV_OPT_GRO) 1416 blobmsg_add_u8(b, "gro", st.gro); 1417 if (st.flags & DEV_OPT_EEE) 1418 blobmsg_add_u8(b, "eee", st.eee); 1419 } 1420 1421 s = blobmsg_open_table(b, "statistics"); 1422 if (dev->type->dump_stats) 1423 dev->type->dump_stats(dev, b); 1424 else 1425 system_if_dump_stats(dev, b); 1426 blobmsg_close_table(b, s); 1427 } 1428 1429 static void __init simple_device_type_init(void) 1430 { 1431 device_type_add(&simple_device_type); 1432 } 1433 1434 void device_hotplug_event(const char *name, bool add) 1435 { 1436 struct device *dev; 1437 1438 wireless_device_hotplug_event(name, add); 1439 1440 dev = device_find(name); 1441 if (!dev || dev->type != &simple_device_type) 1442 return; 1443 1444 device_set_present(dev, add); 1445 } 1446
This page was automatically generated by LXR 0.3.1. • OpenWrt