interface: Fix triggering of interface update event
[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 <netinet/in.h>
20
21 struct device;
22 struct device_type;
23 struct device_user;
24 struct device_hotplug_ops;
25 struct interface;
26
27 typedef int (*device_state_cb)(struct device *, bool up);
28
29 enum {
30         DEV_ATTR_TYPE,
31         DEV_ATTR_MTU,
32         DEV_ATTR_MTU6,
33         DEV_ATTR_MACADDR,
34         DEV_ATTR_TXQUEUELEN,
35         DEV_ATTR_ENABLED,
36         DEV_ATTR_IPV6,
37         DEV_ATTR_PROMISC,
38         DEV_ATTR_RPFILTER,
39         DEV_ATTR_ACCEPTLOCAL,
40         DEV_ATTR_IGMPVERSION,
41         DEV_ATTR_MLDVERSION,
42         DEV_ATTR_NEIGHREACHABLETIME,
43         DEV_ATTR_RPS,
44         DEV_ATTR_XPS,
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_MAX,
54 };
55
56 enum dev_change_type {
57         DEV_CONFIG_NO_CHANGE,
58         DEV_CONFIG_APPLIED,
59         DEV_CONFIG_RESTART,
60         DEV_CONFIG_RECREATE,
61 };
62
63 struct device_type {
64         struct list_head list;
65         const char *name;
66
67         bool bridge_capability;
68         const char *name_prefix;
69
70         const struct uci_blob_param_list *config_params;
71
72         struct device *(*create)(const char *name, struct device_type *devtype,
73                 struct blob_attr *attr);
74         void (*config_init)(struct device *);
75         enum dev_change_type (*reload)(struct device *, struct blob_attr *);
76         void (*dump_info)(struct device *, struct blob_buf *buf);
77         void (*dump_stats)(struct device *, struct blob_buf *buf);
78         int (*check_state)(struct device *);
79         void (*free)(struct device *);
80 };
81
82 enum {
83         DEV_OPT_MTU                     = (1 << 0),
84         DEV_OPT_MACADDR                 = (1 << 1),
85         DEV_OPT_TXQUEUELEN              = (1 << 2),
86         DEV_OPT_IPV6                    = (1 << 3),
87         DEV_OPT_PROMISC                 = (1 << 4),
88         DEV_OPT_RPFILTER                = (1 << 5),
89         DEV_OPT_ACCEPTLOCAL             = (1 << 6),
90         DEV_OPT_IGMPVERSION             = (1 << 7),
91         DEV_OPT_MLDVERSION              = (1 << 8),
92         DEV_OPT_NEIGHREACHABLETIME      = (1 << 9),
93         DEV_OPT_RPS                     = (1 << 10),
94         DEV_OPT_XPS                     = (1 << 11),
95         DEV_OPT_MTU6                    = (1 << 12),
96         DEV_OPT_DADTRANSMITS            = (1 << 13),
97         DEV_OPT_MULTICAST_TO_UNICAST    = (1 << 14),
98         DEV_OPT_MULTICAST_ROUTER        = (1 << 15),
99         DEV_OPT_MULTICAST               = (1 << 16),
100         DEV_OPT_LEARNING                = (1 << 17),
101         DEV_OPT_UNICAST_FLOOD           = (1 << 18),
102         DEV_OPT_NEIGHGCSTALETIME        = (1 << 19),
103         DEV_OPT_MULTICAST_FAST_LEAVE    = (1 << 20),
104 };
105
106 /* events broadcasted to all users of a device */
107 enum device_event {
108         DEV_EVENT_ADD,
109         DEV_EVENT_REMOVE,
110
111         DEV_EVENT_UPDATE_IFNAME,
112         DEV_EVENT_UPDATE_IFINDEX,
113
114         DEV_EVENT_SETUP,
115         DEV_EVENT_TEARDOWN,
116         DEV_EVENT_UP,
117         DEV_EVENT_DOWN,
118
119         DEV_EVENT_LINK_UP,
120         DEV_EVENT_LINK_DOWN,
121
122         /* Topology changed (i.e. bridge member added) */
123         DEV_EVENT_TOPO_CHANGE,
124
125         __DEV_EVENT_MAX
126 };
127
128 /*
129  * device dependency with callbacks
130  */
131 struct device_user {
132         struct safe_list list;
133
134         bool claimed;
135         bool hotplug;
136         bool alias;
137
138         uint8_t ev_idx[__DEV_EVENT_MAX];
139
140         struct device *dev;
141         void (*cb)(struct device_user *, enum device_event);
142 };
143
144 struct device_settings {
145         unsigned int flags;
146         unsigned int valid_flags;
147         unsigned int mtu;
148         unsigned int mtu6;
149         unsigned int txqueuelen;
150         uint8_t macaddr[6];
151         bool ipv6;
152         bool promisc;
153         unsigned int rpfilter;
154         bool acceptlocal;
155         unsigned int igmpversion;
156         unsigned int mldversion;
157         unsigned int neigh4reachabletime;
158         unsigned int neigh6reachabletime;
159         unsigned int neigh4gcstaletime;
160         unsigned int neigh6gcstaletime;
161         bool rps;
162         bool xps;
163         unsigned int dadtransmits;
164         bool multicast_to_unicast;
165         unsigned int multicast_router;
166         bool multicast_fast_leave;
167         bool multicast;
168         bool learning;
169         bool unicast_flood;
170 };
171
172 /*
173  * link layer device. typically represents a linux network device.
174  * can be used to support VLANs as well
175  */
176 struct device {
177         struct device_type *type;
178
179         struct avl_node avl;
180         struct safe_list users;
181         struct safe_list aliases;
182
183         char ifname[IFNAMSIZ + 1];
184         int ifindex;
185
186         struct blob_attr *config;
187         bool config_pending;
188         bool sys_present;
189         /* DEV_EVENT_ADD */
190         bool present;
191         /* DEV_EVENT_UP */
192         int active;
193         /* DEV_EVENT_LINK_UP */
194         bool link_active;
195
196         bool external;
197         bool disabled;
198         bool deferred;
199         bool hidden;
200
201         bool current_config;
202         bool iface_config;
203         bool default_config;
204         bool wireless;
205         bool wireless_ap;
206         bool wireless_isolate;
207
208         struct interface *config_iface;
209
210         /* set interface up or down */
211         device_state_cb set_state;
212
213         const struct device_hotplug_ops *hotplug_ops;
214
215         struct device_user parent;
216
217         struct device_settings orig_settings;
218         struct device_settings settings;
219 };
220
221 struct device_hotplug_ops {
222         int (*prepare)(struct device *dev);
223         int (*add)(struct device *main, struct device *member);
224         int (*del)(struct device *main, struct device *member);
225 };
226
227 extern const struct uci_blob_param_list device_attr_list;
228 extern struct device_type simple_device_type;
229 extern struct device_type tunnel_device_type;
230
231 void device_lock(void);
232 void device_unlock(void);
233
234 int device_type_add(struct device_type *devtype);
235 struct device_type *device_type_get(const char *tname);
236 struct device *device_create(const char *name, struct device_type *type,
237                              struct blob_attr *config);
238 void device_init_settings(struct device *dev, struct blob_attr **tb);
239 void device_init_pending(void);
240
241 enum dev_change_type
242 device_apply_config(struct device *dev, struct device_type *type,
243                     struct blob_attr *config);
244
245 void device_reset_config(void);
246 void device_reset_old(void);
247 void device_set_default_ps(bool state);
248
249 void device_init_virtual(struct device *dev, struct device_type *type, const char *name);
250 int device_init(struct device *iface, struct device_type *type, const char *ifname);
251 void device_cleanup(struct device *dev);
252 struct device *device_find(const char *name);
253 struct device *device_get(const char *name, int create);
254 void device_add_user(struct device_user *dep, struct device *iface);
255 void device_remove_user(struct device_user *dep);
256 void device_broadcast_event(struct device *dev, enum device_event ev);
257
258 void device_set_present(struct device *dev, bool state);
259 void device_set_link(struct device *dev, bool state);
260 void device_set_ifindex(struct device *dev, int ifindex);
261 int device_set_ifname(struct device *dev, const char *name);
262 void device_refresh_present(struct device *dev);
263 int device_claim(struct device_user *dep);
264 void device_release(struct device_user *dep);
265 int device_check_state(struct device *dev);
266 void device_dump_status(struct blob_buf *b, struct device *dev);
267
268 void device_free(struct device *dev);
269 void device_free_unused(struct device *dev);
270
271 struct device *get_vlan_device_chain(const char *ifname, bool create);
272 void alias_notify_device(const char *name, struct device *dev);
273 struct device *device_alias_get(const char *name);
274
275 static inline void
276 device_set_deferred(struct device *dev, bool value)
277 {
278         dev->deferred = value;
279         device_refresh_present(dev);
280 }
281
282 static inline void
283 device_set_disabled(struct device *dev, bool value)
284 {
285         dev->disabled = value;
286         device_refresh_present(dev);
287 }
288
289 #endif