1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
/*
* netifd - network interface daemon
* Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __NETIFD_DEVICE_H
#define __NETIFD_DEVICE_H
#include <libubox/avl.h>
#include <libubox/safe_list.h>
#include <netinet/in.h>
struct device;
struct device_user;
struct device_hotplug_ops;
struct interface;
typedef int (*device_state_cb)(struct device *, bool up);
enum {
DEV_ATTR_TYPE,
DEV_ATTR_MTU,
DEV_ATTR_MTU6,
DEV_ATTR_MACADDR,
DEV_ATTR_TXQUEUELEN,
DEV_ATTR_ENABLED,
DEV_ATTR_IPV6,
DEV_ATTR_PROMISC,
DEV_ATTR_RPFILTER,
DEV_ATTR_ACCEPTLOCAL,
DEV_ATTR_IGMPVERSION,
DEV_ATTR_MLDVERSION,
DEV_ATTR_NEIGHREACHABLETIME,
DEV_ATTR_RPS,
DEV_ATTR_XPS,
DEV_ATTR_DADTRANSMITS,
DEV_ATTR_MULTICAST_TO_UNICAST,
DEV_ATTR_MULTICAST_ROUTER,
__DEV_ATTR_MAX,
};
enum dev_change_type {
DEV_CONFIG_NO_CHANGE,
DEV_CONFIG_APPLIED,
DEV_CONFIG_RESTART,
DEV_CONFIG_RECREATE,
};
struct device_type {
struct list_head list;
const char *name;
bool keep_link_status;
const struct uci_blob_param_list *config_params;
struct device *(*create)(const char *name, struct blob_attr *attr);
void (*config_init)(struct device *);
enum dev_change_type (*reload)(struct device *, struct blob_attr *);
void (*dump_info)(struct device *, struct blob_buf *buf);
void (*dump_stats)(struct device *, struct blob_buf *buf);
int (*check_state)(struct device *);
void (*free)(struct device *);
};
enum {
DEV_OPT_MTU = (1 << 0),
DEV_OPT_MACADDR = (1 << 1),
DEV_OPT_TXQUEUELEN = (1 << 2),
DEV_OPT_IPV6 = (1 << 3),
DEV_OPT_PROMISC = (1 << 4),
DEV_OPT_RPFILTER = (1 << 5),
DEV_OPT_ACCEPTLOCAL = (1 << 6),
DEV_OPT_IGMPVERSION = (1 << 7),
DEV_OPT_MLDVERSION = (1 << 8),
DEV_OPT_NEIGHREACHABLETIME = (1 << 9),
DEV_OPT_RPS = (1 << 10),
DEV_OPT_XPS = (1 << 11),
DEV_OPT_MTU6 = (1 << 12),
DEV_OPT_DADTRANSMITS = (1 << 13),
DEV_OPT_MULTICAST_TO_UNICAST = (1 << 14),
DEV_OPT_MULTICAST_ROUTER = (1 << 15),
};
/* events broadcasted to all users of a device */
enum device_event {
DEV_EVENT_ADD,
DEV_EVENT_REMOVE,
DEV_EVENT_UPDATE_IFNAME,
DEV_EVENT_UPDATE_IFINDEX,
DEV_EVENT_SETUP,
DEV_EVENT_TEARDOWN,
DEV_EVENT_UP,
DEV_EVENT_DOWN,
DEV_EVENT_LINK_UP,
DEV_EVENT_LINK_DOWN,
/* Topology changed (i.e. bridge member added) */
DEV_EVENT_TOPO_CHANGE,
__DEV_EVENT_MAX
};
/*
* device dependency with callbacks
*/
struct device_user {
struct safe_list list;
bool claimed;
bool hotplug;
bool alias;
uint8_t ev_idx[__DEV_EVENT_MAX];
struct device *dev;
void (*cb)(struct device_user *, enum device_event);
};
struct device_settings {
unsigned int flags;
unsigned int mtu;
unsigned int mtu6;
unsigned int txqueuelen;
uint8_t macaddr[6];
bool ipv6;
bool promisc;
unsigned int rpfilter;
bool acceptlocal;
unsigned int igmpversion;
unsigned int mldversion;
unsigned int neigh4reachabletime;
unsigned int neigh6reachabletime;
bool rps;
bool xps;
unsigned int dadtransmits;
bool multicast_to_unicast;
unsigned int multicast_router;
};
/*
* link layer device. typically represents a linux network device.
* can be used to support VLANs as well
*/
struct device {
const struct device_type *type;
struct avl_node avl;
struct safe_list users;
struct safe_list aliases;
char ifname[IFNAMSIZ + 1];
int ifindex;
struct blob_attr *config;
bool config_pending;
bool sys_present;
/* DEV_EVENT_ADD */
bool present;
/* DEV_EVENT_UP */
int active;
/* DEV_EVENT_LINK_UP */
bool link_active;
bool external;
bool disabled;
bool deferred;
bool hidden;
bool current_config;
bool iface_config;
bool default_config;
bool wireless;
bool wireless_isolate;
struct interface *config_iface;
/* set interface up or down */
device_state_cb set_state;
const struct device_hotplug_ops *hotplug_ops;
struct device_user parent;
struct device_settings orig_settings;
struct device_settings settings;
};
struct device_hotplug_ops {
int (*prepare)(struct device *dev);
int (*add)(struct device *main, struct device *member);
int (*del)(struct device *main, struct device *member);
};
extern const struct uci_blob_param_list device_attr_list;
extern const struct device_type simple_device_type;
extern const struct device_type bridge_device_type;
extern const struct device_type tunnel_device_type;
extern const struct device_type macvlan_device_type;
extern const struct device_type vlandev_device_type;
void device_lock(void);
void device_unlock(void);
struct device *device_create(const char *name, const struct device_type *type,
struct blob_attr *config);
void device_init_settings(struct device *dev, struct blob_attr **tb);
void device_init_pending(void);
enum dev_change_type
device_apply_config(struct device *dev, const struct device_type *type,
struct blob_attr *config);
void device_reset_config(void);
void device_reset_old(void);
void device_set_default_ps(bool state);
void device_init_virtual(struct device *dev, const struct device_type *type, const char *name);
int device_init(struct device *iface, const struct device_type *type, const char *ifname);
void device_cleanup(struct device *iface);
struct device *device_get(const char *name, int create);
void device_add_user(struct device_user *dep, struct device *iface);
void device_remove_user(struct device_user *dep);
void device_broadcast_event(struct device *dev, enum device_event ev);
void device_set_present(struct device *dev, bool state);
void device_set_link(struct device *dev, bool state);
void device_set_ifindex(struct device *dev, int ifindex);
void device_refresh_present(struct device *dev);
int device_claim(struct device_user *dep);
void device_release(struct device_user *dep);
int device_check_state(struct device *dev);
void device_dump_status(struct blob_buf *b, struct device *dev);
void device_free(struct device *dev);
void device_free_unused(struct device *dev);
struct device *get_vlan_device_chain(const char *ifname, bool create);
void alias_notify_device(const char *name, struct device *dev);
struct device *device_alias_get(const char *name);
static inline void
device_set_deferred(struct device *dev, bool value)
{
dev->deferred = value;
device_refresh_present(dev);
}
static inline void
device_set_disabled(struct device *dev, bool value)
{
dev->disabled = value;
device_refresh_present(dev);
}
#endif
|
