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