projects / project / netifd.git / blob
? search:


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