fix a compile error on non-linux systems
[project/netifd.git] / device.c
1 #include <string.h>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <assert.h>
5
6 #include <sys/types.h>
7 #include <sys/socket.h>
8 #include <net/ethernet.h>
9
10 #ifdef linux
11 #include <netinet/ether.h>
12 #endif
13
14 #include "netifd.h"
15 #include "system.h"
16 #include "config.h"
17
18 static struct avl_tree devices;
19
20 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = {
21         [DEV_ATTR_TYPE] = { "type", BLOBMSG_TYPE_STRING },
22         [DEV_ATTR_NAME] = { "name", BLOBMSG_TYPE_STRING },
23         [DEV_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
24         [DEV_ATTR_MTU] = { "mtu", BLOBMSG_TYPE_INT32 },
25         [DEV_ATTR_MACADDR] = { "macaddr", BLOBMSG_TYPE_STRING },
26         [DEV_ATTR_TXQUEUELEN] = { "txqueuelen", BLOBMSG_TYPE_INT32 },
27 };
28
29 const struct config_param_list device_attr_list = {
30         .n_params = __DEV_ATTR_MAX,
31         .params = dev_attrs,
32 };
33
34 static struct device *
35 simple_device_create(struct blob_attr *attr)
36 {
37         struct blob_attr *tb[__DEV_ATTR_MAX];
38         struct device *dev = NULL;
39         const char *name;
40
41         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
42         if (!tb[DEV_ATTR_NAME])
43                 return NULL;
44
45         name = blobmsg_data(tb[DEV_ATTR_NAME]);
46         if (!name)
47                 return NULL;
48
49         dev = device_get(name, true);
50         if (!dev)
51                 return NULL;
52
53         device_init_settings(dev, tb);
54
55         return dev;
56 }
57
58 static void simple_device_free(struct device *dev)
59 {
60         device_cleanup(dev);
61         free(dev);
62 }
63
64 const struct device_type simple_device_type = {
65         .name = "Network device",
66         .config_params = &device_attr_list,
67
68         .create = simple_device_create,
69         .check_state = system_if_check,
70         .free = simple_device_free,
71 };
72
73 void
74 device_init_settings(struct device *dev, struct blob_attr **tb)
75 {
76         struct blob_attr *cur;
77         struct ether_addr *ea;
78
79         dev->flags = 0;
80
81         if ((cur = tb[DEV_ATTR_MTU])) {
82                 dev->mtu = blobmsg_get_u32(cur);
83                 dev->flags |= DEV_OPT_MTU;
84         }
85
86         if ((cur = tb[DEV_ATTR_TXQUEUELEN])) {
87                 dev->txqueuelen = blobmsg_get_u32(cur);
88                 dev->flags |= DEV_OPT_TXQUEUELEN;
89         }
90
91         if ((cur = tb[DEV_ATTR_MACADDR])) {
92                 ea = ether_aton(blob_data(cur));
93                 if (ea) {
94                         memcpy(dev->macaddr, ea, sizeof(dev->macaddr));
95                         dev->flags |= DEV_OPT_MACADDR;
96                 }
97         }
98 }
99
100 static void __init dev_init(void)
101 {
102         avl_init(&devices, avl_strcmp, false, NULL);
103 }
104
105 static void device_broadcast_event(struct device *dev, enum device_event ev)
106 {
107         struct device_user *dep, *tmp;
108
109         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
110                 if (!dep->cb)
111                         continue;
112
113                 dep->cb(dep, ev);
114         }
115 }
116
117 static int set_device_state(struct device *dev, bool state)
118 {
119         if (state)
120                 system_if_up(dev);
121         else
122                 system_if_down(dev);
123
124         return 0;
125 }
126
127 int device_claim(struct device_user *dep)
128 {
129         struct device *dev = dep->dev;
130         int ret;
131
132         if (dep->claimed)
133                 return 0;
134
135         dep->claimed = true;
136         DPRINTF("claim device %s, new refcount: %d\n", dev->ifname, dev->active + 1);
137         if (++dev->active != 1)
138                 return 0;
139
140         device_broadcast_event(dev, DEV_EVENT_SETUP);
141         ret = dev->set_state(dev, true);
142         if (ret == 0)
143                 device_broadcast_event(dev, DEV_EVENT_UP);
144         else
145                 dev->active = 0;
146
147         return ret;
148 }
149
150 void device_release(struct device_user *dep)
151 {
152         struct device *dev = dep->dev;
153
154         if (!dep->claimed)
155                 return;
156
157         dep->claimed = false;
158         dev->active--;
159         DPRINTF("release device %s, new refcount: %d\n", dev->ifname, dev->active);
160         assert(dev->active >= 0);
161
162         if (dev->active)
163                 return;
164
165         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
166         dev->set_state(dev, false);
167         device_broadcast_event(dev, DEV_EVENT_DOWN);
168 }
169
170 int check_device_state(struct device *dev)
171 {
172         if (!dev->type->check_state)
173                 return 0;
174
175         return dev->type->check_state(dev);
176 }
177
178 void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
179 {
180         assert(dev);
181         assert(type);
182
183         if (name)
184                 strncpy(dev->ifname, name, IFNAMSIZ);
185
186         DPRINTF("Initialize device '%s'\n", dev->ifname);
187         INIT_LIST_HEAD(&dev->users);
188         dev->type = type;
189 }
190
191 int device_init(struct device *dev, const struct device_type *type, const char *ifname)
192 {
193         int ret;
194
195         device_init_virtual(dev, type, ifname);
196
197         if (!dev->set_state)
198                 dev->set_state = set_device_state;
199
200         dev->avl.key = dev->ifname;
201
202         ret = avl_insert(&devices, &dev->avl);
203         if (ret < 0)
204                 return ret;
205
206         check_device_state(dev);
207
208         return 0;
209 }
210
211 struct device *device_get(const char *name, bool create)
212 {
213         struct device *dev;
214
215         if (strchr(name, '.'))
216                 return get_vlan_device_chain(name, create);
217
218         dev = avl_find_element(&devices, name, dev, avl);
219         if (dev)
220                 return dev;
221
222         if (!create)
223                 return NULL;
224
225         dev = calloc(1, sizeof(*dev));
226         device_init(dev, &simple_device_type, name);
227
228         return dev;
229 }
230
231 void device_cleanup(struct device *dev)
232 {
233         struct device_user *dep, *tmp;
234
235         DPRINTF("Clean up device '%s'\n", dev->ifname);
236         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
237                 if (!dep->cb)
238                         continue;
239
240                 dep->cb(dep, DEV_EVENT_REMOVE);
241         }
242
243         if (dev->avl.key)
244                 avl_delete(&devices, &dev->avl);
245 }
246
247 void device_set_present(struct device *dev, bool state)
248 {
249         if (dev->present == state)
250                 return;
251
252         DPRINTF("Device '%s' %s present\n", dev->ifname, state ? "is now" : "is no longer" );
253         dev->present = state;
254         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
255 }
256
257 void device_add_user(struct device_user *dep, struct device *dev)
258 {
259         dep->dev = dev;
260         list_add_tail(&dep->list, &dev->users);
261         if (dep->cb && dev->present) {
262                 dep->cb(dep, DEV_EVENT_ADD);
263                 if (dev->active)
264                         dep->cb(dep, DEV_EVENT_UP);
265         }
266 }
267
268 static void
269 __device_free_unused(struct device *dev)
270 {
271         if (!list_empty(&dev->users))
272                 return;
273
274         device_free(dev);
275 }
276
277 void device_remove_user(struct device_user *dep)
278 {
279         struct device *dev = dep->dev;
280
281         if (dep->claimed)
282                 device_release(dep);
283
284         list_del(&dep->list);
285         dep->dev = NULL;
286         __device_free_unused(dev);
287 }
288
289 void
290 device_free_unused(struct device *dev)
291 {
292         struct device *tmp;
293
294         if (dev)
295                 return __device_free_unused(dev);
296
297         avl_for_each_element_safe(&devices, dev, avl, tmp)
298                 __device_free_unused(dev);
299 }