system-dummy: add system_if_apply_settings_after_up
[project/netifd.git] / device.h
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 #ifndef __NETIFD_DEVICE_H
15 #define __NETIFD_DEVICE_H
16
17 #include <libubox/avl.h>
18 #include <libubox/safe_list.h>
19 #include <libubox/kvlist.h>
20 #include <netinet/in.h>
21
22 struct device;
23 struct device_type;
24 struct device_user;
25 struct device_hotplug_ops;
26 struct bridge_vlan;
27 struct interface;
28
29 typedef int (*device_state_cb)(struct device *, bool up);
30
31 enum {
32 DEV_ATTR_TYPE,
33 DEV_ATTR_MTU,
34 DEV_ATTR_MTU6,
35 DEV_ATTR_MACADDR,
36 DEV_ATTR_TXQUEUELEN,
37 DEV_ATTR_ENABLED,
38 DEV_ATTR_IPV6,
39 DEV_ATTR_PROMISC,
40 DEV_ATTR_RPFILTER,
41 DEV_ATTR_ACCEPTLOCAL,
42 DEV_ATTR_IGMPVERSION,
43 DEV_ATTR_MLDVERSION,
44 DEV_ATTR_NEIGHREACHABLETIME,
45 DEV_ATTR_DADTRANSMITS,
46 DEV_ATTR_MULTICAST_TO_UNICAST,
47 DEV_ATTR_MULTICAST_ROUTER,
48 DEV_ATTR_MULTICAST_FAST_LEAVE,
49 DEV_ATTR_MULTICAST,
50 DEV_ATTR_LEARNING,
51 DEV_ATTR_UNICAST_FLOOD,
52 DEV_ATTR_NEIGHGCSTALETIME,
53 DEV_ATTR_SENDREDIRECTS,
54 DEV_ATTR_NEIGHLOCKTIME,
55 DEV_ATTR_ISOLATE,
56 DEV_ATTR_IP6SEGMENTROUTING,
57 DEV_ATTR_DROP_V4_UNICAST_IN_L2_MULTICAST,
58 DEV_ATTR_DROP_V6_UNICAST_IN_L2_MULTICAST,
59 DEV_ATTR_DROP_GRATUITOUS_ARP,
60 DEV_ATTR_DROP_UNSOLICITED_NA,
61 DEV_ATTR_ARP_ACCEPT,
62 DEV_ATTR_AUTH,
63 DEV_ATTR_AUTH_VLAN,
64 DEV_ATTR_SPEED,
65 DEV_ATTR_DUPLEX,
66 DEV_ATTR_VLAN,
67 DEV_ATTR_PAUSE,
68 DEV_ATTR_ASYM_PAUSE,
69 DEV_ATTR_RXPAUSE,
70 DEV_ATTR_TXPAUSE,
71 DEV_ATTR_AUTONEG,
72 DEV_ATTR_GRO,
73 DEV_ATTR_MASTER,
74 DEV_ATTR_EEE,
75 __DEV_ATTR_MAX,
76 };
77
78 enum dev_change_type {
79 DEV_CONFIG_NO_CHANGE,
80 DEV_CONFIG_APPLIED,
81 DEV_CONFIG_RESTART,
82 DEV_CONFIG_RECREATE,
83 };
84
85 struct device_type {
86 struct list_head list;
87 const char *name;
88
89 bool bridge_capability;
90 const char *name_prefix;
91
92 const struct uci_blob_param_list *config_params;
93
94 struct device *(*create)(const char *name, struct device_type *devtype,
95 struct blob_attr *attr);
96 void (*config_init)(struct device *);
97 enum dev_change_type (*reload)(struct device *, struct blob_attr *);
98 void (*vlan_update)(struct device *);
99 void (*dump_info)(struct device *, struct blob_buf *buf);
100 void (*dump_stats)(struct device *, struct blob_buf *buf);
101 int (*check_state)(struct device *);
102 void (*stp_init)(struct device *);
103 void (*free)(struct device *);
104 };
105
106 enum {
107 DEV_OPT_MTU = (1ULL << 0),
108 DEV_OPT_MACADDR = (1ULL << 1),
109 DEV_OPT_TXQUEUELEN = (1ULL << 2),
110 DEV_OPT_IPV6 = (1ULL << 3),
111 DEV_OPT_PROMISC = (1ULL << 4),
112 DEV_OPT_RPFILTER = (1ULL << 5),
113 DEV_OPT_ACCEPTLOCAL = (1ULL << 6),
114 DEV_OPT_IGMPVERSION = (1ULL << 7),
115 DEV_OPT_MLDVERSION = (1ULL << 8),
116 DEV_OPT_NEIGHREACHABLETIME = (1ULL << 9),
117 DEV_OPT_DEFAULT_MACADDR = (1ULL << 10),
118 DEV_OPT_AUTH = (1ULL << 11),
119 DEV_OPT_MTU6 = (1ULL << 12),
120 DEV_OPT_DADTRANSMITS = (1ULL << 13),
121 DEV_OPT_MULTICAST_TO_UNICAST = (1ULL << 14),
122 DEV_OPT_MULTICAST_ROUTER = (1ULL << 15),
123 DEV_OPT_MULTICAST = (1ULL << 16),
124 DEV_OPT_LEARNING = (1ULL << 17),
125 DEV_OPT_UNICAST_FLOOD = (1ULL << 18),
126 DEV_OPT_NEIGHGCSTALETIME = (1ULL << 19),
127 DEV_OPT_MULTICAST_FAST_LEAVE = (1ULL << 20),
128 DEV_OPT_SENDREDIRECTS = (1ULL << 21),
129 DEV_OPT_NEIGHLOCKTIME = (1ULL << 22),
130 DEV_OPT_ISOLATE = (1ULL << 23),
131 DEV_OPT_IP6SEGMENTROUTING = (1ULL << 24),
132 DEV_OPT_DROP_V4_UNICAST_IN_L2_MULTICAST = (1ULL << 25),
133 DEV_OPT_DROP_V6_UNICAST_IN_L2_MULTICAST = (1ULL << 26),
134 DEV_OPT_DROP_GRATUITOUS_ARP = (1ULL << 27),
135 DEV_OPT_DROP_UNSOLICITED_NA = (1ULL << 28),
136 DEV_OPT_ARP_ACCEPT = (1ULL << 29),
137 DEV_OPT_SPEED = (1ULL << 30),
138 DEV_OPT_DUPLEX = (1ULL << 31),
139 DEV_OPT_PAUSE = (1ULL << 32),
140 DEV_OPT_ASYM_PAUSE = (1ULL << 33),
141 DEV_OPT_RXPAUSE = (1ULL << 34),
142 DEV_OPT_TXPAUSE = (1ULL << 35),
143 DEV_OPT_AUTONEG = (1ULL << 36),
144 DEV_OPT_GRO = (1ULL << 37),
145 DEV_OPT_MASTER = (1ULL << 38),
146 DEV_OPT_EEE = (1ULL << 39),
147 };
148
149 /* events broadcasted to all users of a device */
150 enum device_event {
151 DEV_EVENT_ADD,
152 DEV_EVENT_REMOVE,
153
154 DEV_EVENT_UPDATE_IFNAME,
155 DEV_EVENT_UPDATE_IFINDEX,
156
157 DEV_EVENT_SETUP,
158 DEV_EVENT_TEARDOWN,
159 DEV_EVENT_UP,
160 DEV_EVENT_DOWN,
161
162 DEV_EVENT_AUTH_UP,
163 DEV_EVENT_LINK_UP,
164 DEV_EVENT_LINK_DOWN,
165
166 /* Topology changed (i.e. bridge member added) */
167 DEV_EVENT_TOPO_CHANGE,
168
169 __DEV_EVENT_MAX
170 };
171
172 /*
173 * device dependency with callbacks
174 */
175 struct device_user {
176 struct safe_list list;
177
178 bool claimed;
179 bool hotplug;
180 bool alias;
181
182 uint8_t ev_idx[__DEV_EVENT_MAX];
183
184 struct device *dev;
185 void (*cb)(struct device_user *, enum device_event);
186 };
187
188 struct device_settings {
189 uint64_t flags;
190 uint64_t valid_flags;
191 unsigned int mtu;
192 unsigned int mtu6;
193 unsigned int txqueuelen;
194 uint8_t macaddr[6];
195 bool ipv6;
196 bool promisc;
197 unsigned int rpfilter;
198 bool acceptlocal;
199 unsigned int igmpversion;
200 unsigned int mldversion;
201 unsigned int neigh4reachabletime;
202 unsigned int neigh6reachabletime;
203 unsigned int neigh4gcstaletime;
204 unsigned int neigh6gcstaletime;
205 int neigh4locktime;
206 unsigned int dadtransmits;
207 bool multicast_to_unicast;
208 unsigned int multicast_router;
209 bool multicast_fast_leave;
210 bool multicast;
211 bool learning;
212 bool unicast_flood;
213 bool sendredirects;
214 bool ip6segmentrouting;
215 bool isolate;
216 bool drop_v4_unicast_in_l2_multicast;
217 bool drop_v6_unicast_in_l2_multicast;
218 bool drop_gratuitous_arp;
219 bool drop_unsolicited_na;
220 bool arp_accept;
221 bool auth;
222 unsigned int speed;
223 bool duplex;
224 bool pause;
225 bool asym_pause;
226 bool rxpause;
227 bool txpause;
228 bool autoneg;
229 bool gro;
230 int master_ifindex;
231 bool eee;
232 };
233
234 struct device_vlan_range {
235 uint16_t start, end;
236 };
237
238 /*
239 * link layer device. typically represents a linux network device.
240 * can be used to support VLANs as well
241 */
242 struct device {
243 struct device_type *type;
244
245 struct avl_node avl;
246 struct safe_list users;
247 struct safe_list aliases;
248
249 struct vlist_tree vlans;
250 struct kvlist vlan_aliases;
251 struct blob_attr *config_auth_vlans;
252 struct blob_attr *auth_vlans;
253
254 char ifname[IFNAMSIZ];
255 int ifindex;
256
257 struct blob_attr *config;
258 bool config_pending;
259 bool sys_present;
260 /* DEV_EVENT_ADD */
261 bool present;
262 /* DEV_EVENT_UP */
263 int active;
264 /* DEV_EVENT_LINK_UP */
265 bool link_active;
266 bool auth_status;
267
268 bool external;
269 bool disabled;
270 bool deferred;
271 bool hidden;
272
273 bool current_config;
274 bool iface_config;
275 bool default_config;
276 bool wireless;
277 bool wireless_ap;
278 bool wireless_proxyarp;
279 bool wireless_isolate;
280 bool bpdu_filter;
281
282 struct interface *config_iface;
283 struct device_vlan_range *extra_vlan;
284 int n_extra_vlan;
285
286 /* set interface up or down */
287 device_state_cb set_state;
288
289 const struct device_hotplug_ops *hotplug_ops;
290
291 struct device_user parent;
292
293 struct device_settings orig_settings;
294 struct device_settings settings;
295 };
296
297 struct device_hotplug_ops {
298 int (*prepare)(struct device *dev, struct device **bridge_dev);
299 int (*add)(struct device *main, struct device *member, struct blob_attr *vlan);
300 int (*del)(struct device *main, struct device *member, struct blob_attr *vlan);
301 };
302
303 enum bridge_vlan_flags {
304 BRVLAN_F_SELF = (1 << 0),
305 BRVLAN_F_PVID = (1 << 1),
306 BRVLAN_F_UNTAGGED = (1 << 2),
307 };
308
309 struct bridge_vlan_port {
310 const char *ifname;
311 uint16_t flags;
312 int8_t check;
313 };
314
315 struct bridge_vlan_hotplug_port {
316 struct list_head list;
317 struct bridge_vlan_port port;
318 };
319
320 struct bridge_vlan {
321 struct vlist_node node;
322
323 struct bridge_vlan_port *ports;
324 int n_ports;
325
326 struct list_head hotplug_ports;
327
328 uint16_t vid;
329 bool local;
330 bool pending;
331 };
332
333 extern const struct uci_blob_param_list device_attr_list;
334 extern struct device_type simple_device_type;
335 extern struct device_type tunnel_device_type;
336
337 void device_vlan_update(bool done);
338 void device_stp_init(void);
339
340 int device_type_add(struct device_type *devtype);
341 struct device_type *device_type_get(const char *tname);
342 struct device *device_create(const char *name, struct device_type *type,
343 struct blob_attr *config);
344 void device_merge_settings(struct device *dev, struct device_settings *n);
345 void device_init_settings(struct device *dev, struct blob_attr **tb);
346 void device_init_pending(void);
347
348 enum dev_change_type
349 device_apply_config(struct device *dev, struct device_type *type,
350 struct blob_attr *config);
351
352 void device_reset_config(void);
353 void device_reset_old(void);
354
355 int device_init_virtual(struct device *dev, struct device_type *type, const char *name);
356 int device_init(struct device *dev, struct device_type *type, const char *ifname);
357 void device_cleanup(struct device *dev);
358 struct device *device_find(const char *name);
359
360 struct device *__device_get(const char *name, int create, bool check_vlan);
361 static inline struct device *device_get(const char *name, int create)
362 {
363 return __device_get(name, create, true);
364 }
365
366 void device_add_user(struct device_user *dep, struct device *dev);
367 void device_remove_user(struct device_user *dep);
368 const char *device_event_name(enum device_event ev);
369 void __device_broadcast_event(struct device *dev, enum device_event ev);
370 #define device_broadcast_event(dev, ev) do { \
371 struct device *__ev_dev = (dev); \
372 D(DEVICE, "%s: event (%s)", \
373 (__ev_dev && __ev_dev->ifname[0] ? __ev_dev->ifname : "(none)"), \
374 device_event_name(ev)); \
375 __device_broadcast_event(__ev_dev, ev); \
376 } while (0)
377
378 void _device_set_present(struct device *dev, bool state);
379 #define device_set_present(dev, state) do { \
380 struct device *__ev_dev = (dev); \
381 bool __ev_state = state; \
382 D(DEVICE, "%s: set present=%d", \
383 (__ev_dev && __ev_dev->ifname[0] ? __ev_dev->ifname : "(none)"), \
384 __ev_state); \
385 _device_set_present(__ev_dev, __ev_state); \
386 } while (0)
387
388 void device_set_link(struct device *dev, bool state);
389 void device_set_ifindex(struct device *dev, int ifindex);
390 int device_set_ifname(struct device *dev, const char *name);
391 void device_refresh_present(struct device *dev);
392 int device_claim(struct device_user *dep);
393 void device_release(struct device_user *dep);
394 int device_check_state(struct device *dev);
395 void device_dump_status(struct blob_buf *b, struct device *dev);
396
397 void device_free_unused(void);
398
399 struct device *get_vlan_device_chain(const char *ifname, int create);
400 void alias_notify_device(const char *name, struct device *dev);
401 struct device *device_alias_get(const char *name);
402
403 void device_set_auth_status(struct device *dev, bool value, struct blob_attr *vlans);
404
405 static inline void
406 device_set_deferred(struct device *dev, bool value)
407 {
408 dev->deferred = value;
409 device_refresh_present(dev);
410 }
411
412 static inline void
413 device_set_disabled(struct device *dev, bool value)
414 {
415 dev->disabled = value;
416 device_refresh_present(dev);
417 }
418
419 static inline bool
420 device_link_active(struct device *dev)
421 {
422 if (dev->settings.auth && !dev->auth_status)
423 return false;
424
425 return dev->link_active;
426 }
427
428 bool device_check_ip6segmentrouting(void);
429 void device_hotplug_event(const char *name, bool add);
430
431 #endif