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


199622f1b0b8004ce91479316dbc4cc08f473179
[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 D(DEVICE, "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 D(DEVICE, "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 D(DEVICE, "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 D(DEVICE, "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, bool force)
884 {
885 if (dev->present == state && !force)
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, false);
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 if (!state)
941 __device_set_present(dev, state, true);
942 else
943 device_refresh_present(dev);
944 if (!state)
945 safe_list_for_each(&dev->users, device_release_cb, NULL);
946 }
947
948 void device_set_link(struct device *dev, bool state)
949 {
950 if (dev->link_active == state)
951 return;
952
953 netifd_log_message(L_NOTICE, "%s '%s' link is %s\n", dev->type->name, dev->ifname, state ? "up" : "down" );
954
955 dev->link_active = state;
956 if (!state)
957 dev->auth_status = false;
958 device_broadcast_event(dev, state ? DEV_EVENT_LINK_UP : DEV_EVENT_LINK_DOWN);
959 }
960
961 void device_set_ifindex(struct device *dev, int ifindex)
962 {
963 if (dev->ifindex == ifindex)
964 return;
965
966 dev->ifindex = ifindex;
967 device_broadcast_event(dev, DEV_EVENT_UPDATE_IFINDEX);
968 }
969
970 int device_set_ifname(struct device *dev, const char *name)
971 {
972 int ret = 0;
973
974 if (!strcmp(dev->ifname, name))
975 return 0;
976
977 if (strlen(name) > sizeof(dev->ifname) - 1)
978 return -1;
979
980 if (dev->avl.key)
981 avl_delete(&devices, &dev->avl);
982
983 strcpy(dev->ifname, name);
984
985 if (dev->avl.key)
986 ret = avl_insert(&devices, &dev->avl);
987
988 if (ret == 0)
989 device_broadcast_event(dev, DEV_EVENT_UPDATE_IFNAME);
990
991 return ret;
992 }
993
994 static int device_refcount(struct device *dev)
995 {
996 struct list_head *list;
997 int count = 0;
998
999 list_for_each(list, &dev->users.list)
1000 count++;
1001
1002 list_for_each(list, &dev->aliases.list)
1003 count++;
1004
1005 return count;
1006 }
1007
1008 static void
1009 __device_add_user(struct device_user *dep, struct device *dev)
1010 {
1011 struct safe_list *head;
1012
1013 dep->dev = dev;
1014
1015 if (dep->alias)
1016 head = &dev->aliases;
1017 else
1018 head = &dev->users;
1019
1020 safe_list_add(&dep->list, head);
1021 D(DEVICE, "Add user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
1022
1023 if (dep->cb && dev->present) {
1024 dep->cb(dep, DEV_EVENT_ADD);
1025 if (dev->active)
1026 dep->cb(dep, DEV_EVENT_UP);
1027
1028 if (dev->link_active)
1029 dep->cb(dep, DEV_EVENT_LINK_UP);
1030 }
1031 }
1032
1033 void device_add_user(struct device_user *dep, struct device *dev)
1034 {
1035 if (dep->dev == dev)
1036 return;
1037
1038 if (dep->dev)
1039 device_remove_user(dep);
1040
1041 if (!dev)
1042 return;
1043
1044 __device_add_user(dep, dev);
1045 }
1046
1047 static void
1048 device_free(struct device *dev)
1049 {
1050 __devlock++;
1051 free(dev->auth_vlans);
1052 free(dev->config);
1053 device_cleanup(dev);
1054 free(dev->config_auth_vlans);
1055 free(dev->extra_vlan);
1056 dev->type->free(dev);
1057 __devlock--;
1058 }
1059
1060 static void
1061 __device_free_unused(struct uloop_timeout *timeout)
1062 {
1063 struct device *dev, *tmp;
1064
1065 avl_for_each_element_safe(&devices, dev, avl, tmp) {
1066 if (!safe_list_empty(&dev->users) ||
1067 !safe_list_empty(&dev->aliases) ||
1068 dev->current_config)
1069 continue;
1070
1071 device_free(dev);
1072 }
1073 }
1074
1075 void device_free_unused(void)
1076 {
1077 static struct uloop_timeout free_timer = {
1078 .cb = __device_free_unused,
1079 };
1080
1081 uloop_timeout_set(&free_timer, 1);
1082 }
1083
1084 void device_remove_user(struct device_user *dep)
1085 {
1086 struct device *dev = dep->dev;
1087
1088 if (!dep->dev)
1089 return;
1090
1091 dep->hotplug = false;
1092 if (dep->claimed)
1093 device_release(dep);
1094
1095 safe_list_del(&dep->list);
1096 dep->dev = NULL;
1097 D(DEVICE, "Remove user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
1098 device_free_unused();
1099 }
1100
1101 void
1102 device_init_pending(void)
1103 {
1104 struct device *dev, *tmp;
1105
1106 avl_for_each_element_safe(&devices, dev, avl, tmp) {
1107 if (!dev->config_pending)
1108 continue;
1109
1110 dev->type->config_init(dev);
1111 dev->config_pending = false;
1112 device_check_state(dev);
1113 }
1114 }
1115
1116 bool
1117 device_check_ip6segmentrouting(void)
1118 {
1119 struct device *dev;
1120 bool ip6segmentrouting = false;
1121
1122 avl_for_each_element(&devices, dev, avl)
1123 ip6segmentrouting |= dev->settings.ip6segmentrouting;
1124
1125 return ip6segmentrouting;
1126 }
1127
1128 static enum dev_change_type
1129 device_set_config(struct device *dev, struct device_type *type,
1130 struct blob_attr *attr)
1131 {
1132 struct blob_attr *tb[__DEV_ATTR_MAX];
1133 const struct uci_blob_param_list *cfg = type->config_params;
1134
1135 if (type != dev->type)
1136 return DEV_CONFIG_RECREATE;
1137
1138 if (dev->type->reload)
1139 return dev->type->reload(dev, attr);
1140
1141 if (uci_blob_check_equal(dev->config, attr, cfg))
1142 return DEV_CONFIG_NO_CHANGE;
1143
1144 if (cfg == &device_attr_list) {
1145 memset(tb, 0, sizeof(tb));
1146
1147 if (attr)
1148 blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
1149 blob_data(attr), blob_len(attr));
1150
1151 device_init_settings(dev, tb);
1152 return DEV_CONFIG_RESTART;
1153 } else
1154 return DEV_CONFIG_RECREATE;
1155 }
1156
1157 enum dev_change_type
1158 device_apply_config(struct device *dev, struct device_type *type,
1159 struct blob_attr *config)
1160 {
1161 enum dev_change_type change;
1162
1163 change = device_set_config(dev, type, config);
1164 if (dev->external) {
1165 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
1166 change = DEV_CONFIG_APPLIED;
1167 }
1168
1169 switch (change) {
1170 case DEV_CONFIG_RESTART:
1171 case DEV_CONFIG_APPLIED:
1172 D(DEVICE, "Device '%s': config applied\n", dev->ifname);
1173 config = blob_memdup(config);
1174 free(dev->config);
1175 dev->config = config;
1176 if (change == DEV_CONFIG_RESTART && dev->present) {
1177 int ret = 0;
1178
1179 device_set_present(dev, false);
1180 if (dev->active && !dev->external) {
1181 ret = dev->set_state(dev, false);
1182 if (!ret)
1183 ret = dev->set_state(dev, true);
1184 }
1185 if (!ret)
1186 device_set_present(dev, true);
1187 }
1188 break;
1189 case DEV_CONFIG_NO_CHANGE:
1190 D(DEVICE, "Device '%s': no configuration change\n", dev->ifname);
1191 break;
1192 case DEV_CONFIG_RECREATE:
1193 break;
1194 }
1195
1196 return change;
1197 }
1198
1199 static void
1200 device_replace(struct device *dev, struct device *odev)
1201 {
1202 struct device_user *dep;
1203
1204 __devlock++;
1205 if (odev->present)
1206 device_set_present(odev, false);
1207
1208 while (!list_empty(&odev->users.list)) {
1209 dep = list_first_entry(&odev->users.list, struct device_user, list.list);
1210 device_release(dep);
1211 if (!dep->dev)
1212 continue;
1213
1214 safe_list_del(&dep->list);
1215 __device_add_user(dep, dev);
1216 }
1217 __devlock--;
1218
1219 device_free(odev);
1220 }
1221
1222 void
1223 device_reset_config(void)
1224 {
1225 struct device *dev;
1226
1227 avl_for_each_element(&devices, dev, avl)
1228 dev->current_config = false;
1229 }
1230
1231 void
1232 device_reset_old(void)
1233 {
1234 struct device *dev, *tmp, *ndev;
1235
1236 avl_for_each_element_safe(&devices, dev, avl, tmp) {
1237 if (dev->current_config || dev->default_config)
1238 continue;
1239
1240 if (dev->type != &simple_device_type)
1241 continue;
1242
1243 ndev = device_create_default(dev->ifname, dev->external);
1244 if (!ndev)
1245 continue;
1246
1247 device_replace(ndev, dev);
1248 }
1249 }
1250
1251 struct device *
1252 device_create(const char *name, struct device_type *type,
1253 struct blob_attr *config)
1254 {
1255 struct device *odev = NULL, *dev;
1256 enum dev_change_type change;
1257
1258 odev = device_find(name);
1259 if (odev) {
1260 odev->current_config = true;
1261 change = device_apply_config(odev, type, config);
1262 switch (change) {
1263 case DEV_CONFIG_RECREATE:
1264 D(DEVICE, "Device '%s': recreate device\n", odev->ifname);
1265 device_delete(odev);
1266 break;
1267 default:
1268 return odev;
1269 }
1270 } else
1271 D(DEVICE, "Create new device '%s' (%s)\n", name, type->name);
1272
1273 config = blob_memdup(config);
1274 if (!config)
1275 return NULL;
1276
1277 dev = type->create(name, type, config);
1278 if (!dev)
1279 return NULL;
1280
1281 dev->current_config = true;
1282 dev->config = config;
1283 if (odev)
1284 device_replace(dev, odev);
1285
1286 if (!config_init && dev->config_pending) {
1287 type->config_init(dev);
1288 dev->config_pending = false;
1289 }
1290
1291 device_check_state(dev);
1292
1293 return dev;
1294 }
1295
1296 void
1297 device_dump_status(struct blob_buf *b, struct device *dev)
1298 {
1299 struct device_settings st;
1300 void *c, *s;
1301
1302 if (!dev) {
1303 avl_for_each_element(&devices, dev, avl) {
1304 if (!dev->present)
1305 continue;
1306 c = blobmsg_open_table(b, dev->ifname);
1307 device_dump_status(b, dev);
1308 blobmsg_close_table(b, c);
1309 }
1310
1311 return;
1312 }
1313
1314 blobmsg_add_u8(b, "external", dev->external);
1315 blobmsg_add_u8(b, "present", dev->present);
1316 blobmsg_add_string(b, "type", dev->type->name);
1317
1318 if (!dev->present)
1319 return;
1320
1321 blobmsg_add_u8(b, "up", !!dev->active);
1322 blobmsg_add_u8(b, "carrier", !!dev->link_active);
1323 blobmsg_add_u8(b, "auth_status", !!dev->auth_status);
1324
1325 if (dev->type->dump_info)
1326 dev->type->dump_info(dev, b);
1327 else
1328 system_if_dump_info(dev, b);
1329
1330 if (dev->active) {
1331 device_merge_settings(dev, &st);
1332 if (st.flags & DEV_OPT_MASTER) {
1333 char buf[64], *devname;
1334
1335 devname = if_indextoname(st.master_ifindex, buf);
1336 if (devname)
1337 blobmsg_add_string(b, "conduit", devname);
1338 }
1339 if (st.flags & DEV_OPT_MTU)
1340 blobmsg_add_u32(b, "mtu", st.mtu);
1341 if (st.flags & DEV_OPT_MTU6)
1342 blobmsg_add_u32(b, "mtu6", st.mtu6);
1343 if (st.flags & DEV_OPT_MACADDR)
1344 blobmsg_add_string(b, "macaddr", format_macaddr(st.macaddr));
1345 if (st.flags & DEV_OPT_TXQUEUELEN)
1346 blobmsg_add_u32(b, "txqueuelen", st.txqueuelen);
1347 if (st.flags & DEV_OPT_IPV6)
1348 blobmsg_add_u8(b, "ipv6", st.ipv6);
1349 if (st.flags & DEV_OPT_IP6SEGMENTROUTING)
1350 blobmsg_add_u8(b, "ip6segmentrouting", st.ip6segmentrouting);
1351 if (st.flags & DEV_OPT_PROMISC)
1352 blobmsg_add_u8(b, "promisc", st.promisc);
1353 if (st.flags & DEV_OPT_RPFILTER)
1354 blobmsg_add_u32(b, "rpfilter", st.rpfilter);
1355 if (st.flags & DEV_OPT_ACCEPTLOCAL)
1356 blobmsg_add_u8(b, "acceptlocal", st.acceptlocal);
1357 if (st.flags & DEV_OPT_IGMPVERSION)
1358 blobmsg_add_u32(b, "igmpversion", st.igmpversion);
1359 if (st.flags & DEV_OPT_MLDVERSION)
1360 blobmsg_add_u32(b, "mldversion", st.mldversion);
1361 if (st.flags & DEV_OPT_NEIGHREACHABLETIME) {
1362 blobmsg_add_u32(b, "neigh4reachabletime", st.neigh4reachabletime);
1363 blobmsg_add_u32(b, "neigh6reachabletime", st.neigh6reachabletime);
1364 }
1365 if (st.flags & DEV_OPT_NEIGHGCSTALETIME) {
1366 blobmsg_add_u32(b, "neigh4gcstaletime", st.neigh4gcstaletime);
1367 blobmsg_add_u32(b, "neigh6gcstaletime", st.neigh6gcstaletime);
1368 }
1369 if (st.flags & DEV_OPT_NEIGHLOCKTIME)
1370 blobmsg_add_u32(b, "neigh4locktime", st.neigh4locktime);
1371 if (st.flags & DEV_OPT_DADTRANSMITS)
1372 blobmsg_add_u32(b, "dadtransmits", st.dadtransmits);
1373 if (st.flags & DEV_OPT_MULTICAST_TO_UNICAST)
1374 blobmsg_add_u8(b, "multicast_to_unicast", st.multicast_to_unicast);
1375 if (st.flags & DEV_OPT_MULTICAST_ROUTER)
1376 blobmsg_add_u32(b, "multicast_router", st.multicast_router);
1377 if (st.flags & DEV_OPT_MULTICAST_FAST_LEAVE)
1378 blobmsg_add_u8(b, "multicast_fast_leave", st.multicast_fast_leave);
1379 if (st.flags & DEV_OPT_MULTICAST)
1380 blobmsg_add_u8(b, "multicast", st.multicast);
1381 if (st.flags & DEV_OPT_LEARNING)
1382 blobmsg_add_u8(b, "learning", st.learning);
1383 if (st.flags & DEV_OPT_UNICAST_FLOOD)
1384 blobmsg_add_u8(b, "unicast_flood", st.unicast_flood);
1385 if (st.flags & DEV_OPT_SENDREDIRECTS)
1386 blobmsg_add_u8(b, "sendredirects", st.sendredirects);
1387 if (st.flags & DEV_OPT_DROP_V4_UNICAST_IN_L2_MULTICAST)
1388 blobmsg_add_u8(b, "drop_v4_unicast_in_l2_multicast", st.drop_v4_unicast_in_l2_multicast);
1389 if (st.flags & DEV_OPT_DROP_V6_UNICAST_IN_L2_MULTICAST)
1390 blobmsg_add_u8(b, "drop_v6_unicast_in_l2_multicast", st.drop_v6_unicast_in_l2_multicast);
1391 if (st.flags & DEV_OPT_DROP_GRATUITOUS_ARP)
1392 blobmsg_add_u8(b, "drop_gratuitous_arp", st.drop_gratuitous_arp);
1393 if (st.flags & DEV_OPT_DROP_UNSOLICITED_NA)
1394 blobmsg_add_u8(b, "drop_unsolicited_na", st.drop_unsolicited_na);
1395 if (st.flags & DEV_OPT_ARP_ACCEPT)
1396 blobmsg_add_u8(b, "arp_accept", st.arp_accept);
1397 if (st.flags & DEV_OPT_AUTH)
1398 blobmsg_add_u8(b, "auth", st.auth);
1399 if (st.flags & DEV_OPT_GRO)
1400 blobmsg_add_u8(b, "gro", st.gro);
1401 if (st.flags & DEV_OPT_EEE)
1402 blobmsg_add_u8(b, "eee", st.eee);
1403 }
1404
1405 s = blobmsg_open_table(b, "statistics");
1406 if (dev->type->dump_stats)
1407 dev->type->dump_stats(dev, b);
1408 else
1409 system_if_dump_stats(dev, b);
1410 blobmsg_close_table(b, s);
1411 }
1412
1413 static void __init simple_device_type_init(void)
1414 {
1415 device_type_add(&simple_device_type);
1416 }
1417
1418 void device_hotplug_event(const char *name, bool add)
1419 {
1420 struct device *dev;
1421
1422 wireless_device_hotplug_event(name, add);
1423
1424 dev = device_find(name);
1425 if (!dev || dev->type != &simple_device_type)
1426 return;
1427
1428 device_set_present(dev, add);
1429 }
OpenWrt Network interface configuration daemon