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


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