utils: fix existing node check when keep_old/no_delete is enabled
[project/netifd.git] / ubus.c
1 #include <string.h>
2
3 #include "netifd.h"
4 #include "interface.h"
5 #include "proto.h"
6 #include "ubus.h"
7
8 static struct ubus_context *ctx = NULL;
9 static struct blob_buf b;
10
11 /* global object */
12
13 enum {
14         DEV_NAME,
15         DEV_FORCE,
16         __DEV_MAX,
17         __DEV_MAX_NOFORCE = __DEV_MAX - 1,
18 };
19
20 static const struct blobmsg_policy dev_policy[__DEV_MAX] = {
21         [DEV_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
22         [DEV_FORCE] = { .name = "force", .type = BLOBMSG_TYPE_INT8 },
23 };
24
25 static int
26 netifd_handle_device(struct ubus_context *ctx, struct ubus_object *obj,
27                      struct ubus_request_data *req, const char *method,
28                      struct blob_attr *msg)
29 {
30         struct device *dev;
31         struct blob_attr *tb[__DEV_MAX];
32         bool add = !strncmp(method, "add", 3);
33
34         blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
35
36         if (!tb[DEV_NAME])
37                 return UBUS_STATUS_INVALID_ARGUMENT;
38
39         dev = device_get(blobmsg_data(tb[DEV_NAME]), false);
40         if (!dev)
41                 return UBUS_STATUS_NOT_FOUND;
42
43         if (!add || (tb[DEV_FORCE] && blobmsg_get_u8(tb[DEV_FORCE])))
44                 device_set_present(dev, add);
45         else
46                 check_device_state(dev);
47
48         return 0;
49 }
50
51 static int
52 netifd_handle_restart(struct ubus_context *ctx, struct ubus_object *obj,
53                       struct ubus_request_data *req, const char *method,
54                       struct blob_attr *msg)
55 {
56         netifd_restart();
57         return 0;
58 }
59
60 static struct ubus_method main_object_methods[] = {
61         UBUS_METHOD("add_device", netifd_handle_device, dev_policy),
62         UBUS_METHOD("remove_device", netifd_handle_device, dev_policy),
63         { .name = "restart", .handler = netifd_handle_restart },
64 };
65
66 static struct ubus_object_type main_object_type =
67         UBUS_OBJECT_TYPE("netifd", main_object_methods);
68
69 static struct ubus_object main_object = {
70         .name = "network.interface",
71         .type = &main_object_type,
72         .methods = main_object_methods,
73         .n_methods = ARRAY_SIZE(main_object_methods),
74 };
75
76 int
77 netifd_ubus_init(const char *path)
78 {
79         int ret;
80
81         ctx = ubus_connect(path);
82         if (!ctx)
83                 return -EIO;
84
85         DPRINTF("connected as %08x\n", ctx->local_id);
86         uloop_init();
87         ubus_add_uloop(ctx);
88
89         ret = ubus_add_object(ctx, &main_object);
90         if (ret != 0)
91                 fprintf(stderr, "Failed to publish object: %s\n", ubus_strerror(ret));
92
93         return 0;
94 }
95
96 void
97 netifd_ubus_done(void)
98 {
99         ubus_free(ctx);
100 }
101
102
103 /* per-interface object */
104
105 static int
106 netifd_handle_up(struct ubus_context *ctx, struct ubus_object *obj,
107                  struct ubus_request_data *req, const char *method,
108                  struct blob_attr *msg)
109 {
110         struct interface *iface;
111
112         iface = container_of(obj, struct interface, ubus);
113         interface_set_up(iface);
114
115         return 0;
116 }
117
118 static int
119 netifd_handle_down(struct ubus_context *ctx, struct ubus_object *obj,
120                    struct ubus_request_data *req, const char *method,
121                    struct blob_attr *msg)
122 {
123         struct interface *iface;
124
125         iface = container_of(obj, struct interface, ubus);
126         interface_set_down(iface);
127
128         return 0;
129 }
130
131 static void
132 netifd_add_interface_errors(struct blob_buf *b, struct interface *iface)
133 {
134         struct interface_error *error;
135         void *e, *e2, *e3;
136         int i;
137
138         e = blobmsg_open_array(b, "errors");
139         list_for_each_entry(error, &iface->errors, list) {
140                 e2 = blobmsg_open_table(b, NULL);
141
142                 blobmsg_add_string(b, "subsystem", error->subsystem);
143                 blobmsg_add_string(b, "code", error->code);
144                 if (error->data[0]) {
145                         e3 = blobmsg_open_array(b, "data");
146                         for (i = 0; error->data[i]; i++)
147                                 blobmsg_add_string(b, NULL, error->data[i]);
148                         blobmsg_close_array(b, e3);
149                 }
150
151                 blobmsg_close_table(b, e2);
152         }
153         blobmsg_close_array(b, e);
154 }
155
156 static int
157 netifd_handle_status(struct ubus_context *ctx, struct ubus_object *obj,
158                      struct ubus_request_data *req, const char *method,
159                      struct blob_attr *msg)
160 {
161         struct interface *iface;
162
163         iface = container_of(obj, struct interface, ubus);
164
165         blob_buf_init(&b, 0);
166         blobmsg_add_u8(&b, "up", iface->state == IFS_UP);
167         blobmsg_add_u8(&b, "pending", iface->state == IFS_SETUP);
168         blobmsg_add_u8(&b, "available", iface->available);
169         blobmsg_add_u8(&b, "autostart", iface->autostart);
170         if (iface->main_dev.dev) {
171                 struct device *dev = iface->main_dev.dev;
172                 const char *field;
173                 void *devinfo;
174
175                 /* use a different field for virtual devices */
176                 if (dev->avl.key)
177                         field = "device";
178                 else
179                         field = "link";
180
181                 devinfo = blobmsg_open_table(&b, field);
182                 blobmsg_add_string(&b, "name", dev->ifname);
183
184                 if (dev->type->dump_status)
185                         dev->type->dump_status(dev, &b);
186
187                 blobmsg_close_table(&b, devinfo);
188         }
189
190         if (!list_is_empty(&iface->errors))
191                 netifd_add_interface_errors(&b, iface);
192
193         ubus_send_reply(ctx, req, b.head);
194
195         return 0;
196 }
197
198 static int
199 netifd_iface_handle_device(struct ubus_context *ctx, struct ubus_object *obj,
200                            struct ubus_request_data *req, const char *method,
201                            struct blob_attr *msg)
202 {
203         struct interface *iface;
204         struct device *dev, *main_dev;
205         struct blob_attr *tb[__DEV_MAX];
206         bool add = !strncmp(method, "add", 3);
207         int ret;
208
209         iface = container_of(obj, struct interface, ubus);
210
211         blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
212
213         if (!tb[DEV_NAME])
214                 return UBUS_STATUS_INVALID_ARGUMENT;
215
216         main_dev = iface->main_dev.dev;
217         if (!main_dev)
218                 return UBUS_STATUS_NOT_FOUND;
219
220         if (!main_dev->hotplug_ops)
221                 return UBUS_STATUS_NOT_SUPPORTED;
222
223         dev = device_get(blobmsg_data(tb[DEV_NAME]), add);
224         if (!dev)
225                 return UBUS_STATUS_NOT_FOUND;
226
227         if (main_dev != dev) {
228                 if (add)
229                         ret = main_dev->hotplug_ops->add(main_dev, dev);
230                 else
231                         ret = main_dev->hotplug_ops->del(main_dev, dev);
232                 if (ret)
233                         ret = UBUS_STATUS_UNKNOWN_ERROR;
234         } else {
235                 ret = UBUS_STATUS_INVALID_ARGUMENT;
236         }
237
238         if (add)
239                 device_free_unused(dev);
240
241         return ret;
242 }
243
244
245 static int
246 netifd_iface_notify_proto(struct ubus_context *ctx, struct ubus_object *obj,
247                           struct ubus_request_data *req, const char *method,
248                           struct blob_attr *msg)
249 {
250         struct interface *iface;
251
252         iface = container_of(obj, struct interface, ubus);
253
254         if (!iface->proto || !iface->proto->notify)
255                 return UBUS_STATUS_NOT_SUPPORTED;
256
257         return iface->proto->notify(iface->proto, msg);
258 }
259
260 static void
261 netifd_iface_do_remove(struct uloop_timeout *timeout)
262 {
263         struct interface *iface;
264
265         iface = container_of(timeout, struct interface, remove_timer);
266         vlist_delete(&interfaces, &iface->node);
267 }
268
269 static int
270 netifd_iface_remove(struct ubus_context *ctx, struct ubus_object *obj,
271                     struct ubus_request_data *req, const char *method,
272                     struct blob_attr *msg)
273 {
274         struct interface *iface;
275
276         iface = container_of(obj, struct interface, ubus);
277         if (iface->remove_timer.cb)
278                 return UBUS_STATUS_INVALID_ARGUMENT;
279
280         iface->remove_timer.cb = netifd_iface_do_remove;
281         uloop_timeout_set(&iface->remove_timer, 100);
282         return 0;
283 }
284
285 static struct ubus_method iface_object_methods[] = {
286         { .name = "up", .handler = netifd_handle_up },
287         { .name = "down", .handler = netifd_handle_down },
288         { .name = "status", .handler = netifd_handle_status },
289         { .name = "add_device", .handler = netifd_iface_handle_device,
290           .policy = dev_policy, .n_policy = __DEV_MAX_NOFORCE },
291         { .name = "remove_device", .handler = netifd_iface_handle_device,
292           .policy = dev_policy, .n_policy = __DEV_MAX_NOFORCE },
293         { .name = "notify_proto", .handler = netifd_iface_notify_proto },
294         { .name = "remove", .handler = netifd_iface_remove }
295 };
296
297 static struct ubus_object_type iface_object_type =
298         UBUS_OBJECT_TYPE("netifd_iface", iface_object_methods);
299
300
301 void
302 netifd_ubus_add_interface(struct interface *iface)
303 {
304         struct ubus_object *obj = &iface->ubus;
305         char *name;
306
307         name = malloc(strlen(main_object.name) + strlen(iface->name) + 2);
308         if (!name)
309                 return;
310
311         sprintf(name, "%s.%s", main_object.name, iface->name);
312         obj->name = name;
313         obj->type = &iface_object_type;
314         obj->methods = iface_object_methods;
315         obj->n_methods = ARRAY_SIZE(iface_object_methods);
316         if (ubus_add_object(ctx, &iface->ubus)) {
317                 DPRINTF("failed to publish ubus object for interface '%s'\n", iface->name);
318                 free(name);
319                 obj->name = NULL;
320         }
321 }
322
323 void
324 netifd_ubus_remove_interface(struct interface *iface)
325 {
326         if (!iface->ubus.name)
327                 return;
328
329         ubus_remove_object(ctx, &iface->ubus);
330         free((void *) iface->ubus.name);
331 }