ubus.c

   1 #define _GNU_SOURCE
   2
   3 #include <arpa/inet.h>
   4 #include <string.h>
   5 #include <stdio.h>
   6
   7 #include "netifd.h"
   8 #include "interface.h"
   9 #include "proto.h"
  10 #include "ubus.h"
  11 #include "system.h"
  12
  13 static struct ubus_context *ctx = NULL;
  14 static struct blob_buf b;
  15 static struct netifd_fd ubus_fd;
  16
  17 /* global object */
  18
  19 static int
  20 netifd_handle_restart(struct ubus_context *ctx, struct ubus_object *obj,
  21                       struct ubus_request_data *req, const char *method,
  22                       struct blob_attr *msg)
  23 {
  24         netifd_restart();
  25         return 0;
  26 }
  27
  28 static int
  29 netifd_handle_reload(struct ubus_context *ctx, struct ubus_object *obj,
  30                       struct ubus_request_data *req, const char *method,
  31                       struct blob_attr *msg)
  32 {
  33         netifd_reload();
  34         return 0;
  35 }
  36
  37 static struct ubus_method main_object_methods[] = {
  38         { .name = "restart", .handler = netifd_handle_restart },
  39         { .name = "reload", .handler = netifd_handle_reload },
  40 };
  41
  42 static struct ubus_object_type main_object_type =
  43         UBUS_OBJECT_TYPE("netifd", main_object_methods);
  44
  45 static struct ubus_object main_object = {
  46         .name = "network",
  47         .type = &main_object_type,
  48         .methods = main_object_methods,
  49         .n_methods = ARRAY_SIZE(main_object_methods),
  50 };
  51
  52 enum {
  53         DEV_NAME,
  54         __DEV_MAX,
  55 };
  56
  57 static const struct blobmsg_policy dev_policy[__DEV_MAX] = {
  58         [DEV_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
  59 };
  60
  61 static int
  62 netifd_dev_status(struct ubus_context *ctx, struct ubus_object *obj,
  63                   struct ubus_request_data *req, const char *method,
  64                   struct blob_attr *msg)
  65 {
  66         struct device *dev = NULL;
  67         struct blob_attr *tb[__DEV_MAX];
  68
  69         blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
  70
  71         if (tb[DEV_NAME]) {
  72                 dev = device_get(blobmsg_data(tb[DEV_NAME]), false);
  73                 if (!dev)
  74                         return UBUS_STATUS_INVALID_ARGUMENT;
  75         }
  76
  77         blob_buf_init(&b, 0);
  78         device_dump_status(&b, dev);
  79         ubus_send_reply(ctx, req, b.head);
  80
  81         return 0;
  82 }
  83
  84 enum {
  85         ALIAS_ATTR_ALIAS,
  86         ALIAS_ATTR_DEV,
  87         __ALIAS_ATTR_MAX,
  88 };
  89
  90 static const struct blobmsg_policy alias_attrs[__ALIAS_ATTR_MAX] = {
  91         [ALIAS_ATTR_ALIAS] = { "alias", BLOBMSG_TYPE_ARRAY },
  92         [ALIAS_ATTR_DEV] = { "device", BLOBMSG_TYPE_STRING },
  93 };
  94
  95 static int
  96 netifd_handle_alias(struct ubus_context *ctx, struct ubus_object *obj,
  97                     struct ubus_request_data *req, const char *method,
  98                     struct blob_attr *msg)
  99 {
 100         struct device *dev = NULL;
 101         struct blob_attr *tb[__ALIAS_ATTR_MAX];
 102         struct blob_attr *cur;
 103         int rem;
 104
 105         blobmsg_parse(alias_attrs, __ALIAS_ATTR_MAX, tb, blob_data(msg), blob_len(msg));
 106
 107         if (!tb[ALIAS_ATTR_ALIAS])
 108                 return UBUS_STATUS_INVALID_ARGUMENT;
 109
 110         if ((cur = tb[ALIAS_ATTR_DEV]) != NULL) {
 111                 dev = device_get(blobmsg_data(cur), true);
 112                 if (!dev)
 113                         return UBUS_STATUS_NOT_FOUND;
 114         }
 115
 116         blobmsg_for_each_attr(cur, tb[ALIAS_ATTR_ALIAS], rem) {
 117                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 118                         goto error;
 119
 120                 if (!blobmsg_check_attr(cur, NULL))
 121                         goto error;
 122
 123                 alias_notify_device(blobmsg_data(cur), dev);
 124         }
 125         return 0;
 126
 127 error:
 128         device_free_unused(dev);
 129         return UBUS_STATUS_INVALID_ARGUMENT;
 130 }
 131
 132 static struct ubus_method dev_object_methods[] = {
 133         UBUS_METHOD("status", netifd_dev_status, dev_policy),
 134         UBUS_METHOD("set_alias", netifd_handle_alias, alias_attrs),
 135 };
 136
 137 static struct ubus_object_type dev_object_type =
 138         UBUS_OBJECT_TYPE("device", dev_object_methods);
 139
 140 static struct ubus_object dev_object = {
 141         .name = "network.device",
 142         .type = &dev_object_type,
 143         .methods = dev_object_methods,
 144         .n_methods = ARRAY_SIZE(dev_object_methods),
 145 };
 146
 147 int
 148 netifd_ubus_init(const char *path)
 149 {
 150         int ret;
 151
 152         ctx = ubus_connect(path);
 153         if (!ctx)
 154                 return -EIO;
 155
 156         DPRINTF("connected as %08x\n", ctx->local_id);
 157         uloop_init();
 158         ubus_add_uloop(ctx);
 159         ubus_fd.fd = ctx->sock.fd;
 160         netifd_fd_add(&ubus_fd);
 161
 162         ret = ubus_add_object(ctx, &main_object);
 163         if (ret)
 164                 goto out;
 165
 166         ret = ubus_add_object(ctx, &dev_object);
 167
 168 out:
 169         if (ret != 0)
 170                 fprintf(stderr, "Failed to publish object: %s\n", ubus_strerror(ret));
 171         return ret;
 172 }
 173
 174 void
 175 netifd_ubus_done(void)
 176 {
 177         ubus_free(ctx);
 178 }
 179
 180
 181 /* per-interface object */
 182
 183 static int
 184 netifd_handle_up(struct ubus_context *ctx, struct ubus_object *obj,
 185                  struct ubus_request_data *req, const char *method,
 186                  struct blob_attr *msg)
 187 {
 188         struct interface *iface;
 189
 190         iface = container_of(obj, struct interface, ubus);
 191         interface_set_up(iface);
 192
 193         return 0;
 194 }
 195
 196 static int
 197 netifd_handle_down(struct ubus_context *ctx, struct ubus_object *obj,
 198                    struct ubus_request_data *req, const char *method,
 199                    struct blob_attr *msg)
 200 {
 201         struct interface *iface;
 202
 203         iface = container_of(obj, struct interface, ubus);
 204         interface_set_down(iface);
 205
 206         return 0;
 207 }
 208
 209 static void
 210 netifd_add_interface_errors(struct blob_buf *b, struct interface *iface)
 211 {
 212         struct interface_error *error;
 213         void *e, *e2, *e3;
 214         int i;
 215
 216         e = blobmsg_open_array(b, "errors");
 217         list_for_each_entry(error, &iface->errors, list) {
 218                 e2 = blobmsg_open_table(b, NULL);
 219
 220                 blobmsg_add_string(b, "subsystem", error->subsystem);
 221                 blobmsg_add_string(b, "code", error->code);
 222                 if (error->data[0]) {
 223                         e3 = blobmsg_open_array(b, "data");
 224                         for (i = 0; error->data[i]; i++)
 225                                 blobmsg_add_string(b, NULL, error->data[i]);
 226                         blobmsg_close_array(b, e3);
 227                 }
 228
 229                 blobmsg_close_table(b, e2);
 230         }
 231         blobmsg_close_array(b, e);
 232 }
 233
 234 static void
 235 interface_ip_dump_address_list(struct interface_ip_settings *ip)
 236 {
 237         struct device_addr *addr;
 238         static char *buf;
 239         int buflen = 128;
 240         int af;
 241
 242         vlist_for_each_element(&ip->addr, addr, node) {
 243                 if ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4)
 244                         af = AF_INET;
 245                 else
 246                         af = AF_INET6;
 247
 248                 buf = blobmsg_alloc_string_buffer(&b, NULL, buflen);
 249                 inet_ntop(af, &addr->addr, buf, buflen - 5);
 250                 buf += strlen(buf);
 251                 sprintf(buf, "/%d", addr->mask);
 252                 blobmsg_add_string_buffer(&b);
 253         }
 254 }
 255
 256 static int
 257 netifd_handle_status(struct ubus_context *ctx, struct ubus_object *obj,
 258                      struct ubus_request_data *req, const char *method,
 259                      struct blob_attr *msg)
 260 {
 261         struct interface *iface;
 262         struct device *dev;
 263         void *a;
 264
 265         iface = container_of(obj, struct interface, ubus);
 266
 267         blob_buf_init(&b, 0);
 268         blobmsg_add_u8(&b, "up", iface->state == IFS_UP);
 269         blobmsg_add_u8(&b, "pending", iface->state == IFS_SETUP);
 270         blobmsg_add_u8(&b, "available", iface->available);
 271         blobmsg_add_u8(&b, "autostart", iface->autostart);
 272
 273         if (iface->state == IFS_UP) {
 274                 time_t cur = system_get_rtime();
 275                 blobmsg_add_u32(&b, "uptime", cur - iface->start_time);
 276                 blobmsg_add_string(&b, "l3_device", iface->l3_dev->dev->ifname);
 277         }
 278
 279         dev = iface->main_dev.dev;
 280         if (dev && !(iface->proto_handler->flags & PROTO_FLAG_NODEV))
 281                 blobmsg_add_string(&b, "device", dev->ifname);
 282
 283         if (iface->state == IFS_UP) {
 284                 a = blobmsg_open_array(&b, "address");
 285                 interface_ip_dump_address_list(&iface->config_ip);
 286                 interface_ip_dump_address_list(&iface->proto_ip);
 287                 blobmsg_close_array(&b, a);
 288         }
 289
 290         if (!list_is_empty(&iface->errors))
 291                 netifd_add_interface_errors(&b, iface);
 292
 293         ubus_send_reply(ctx, req, b.head);
 294
 295         return 0;
 296 }
 297
 298 static int
 299 netifd_iface_handle_device(struct ubus_context *ctx, struct ubus_object *obj,
 300                            struct ubus_request_data *req, const char *method,
 301                            struct blob_attr *msg)
 302 {
 303         struct blob_attr *tb[__DEV_MAX];
 304         struct interface *iface;
 305         struct device *dev;
 306         bool add = !strncmp(method, "add", 3);
 307         int ret;
 308
 309         iface = container_of(obj, struct interface, ubus);
 310
 311         blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
 312
 313         if (!tb[DEV_NAME])
 314                 return UBUS_STATUS_INVALID_ARGUMENT;
 315
 316         device_lock();
 317
 318         dev = device_get(blobmsg_data(tb[DEV_NAME]), add ? 2 : 0);
 319         if (add && !dev)
 320                 return UBUS_STATUS_NOT_FOUND;
 321
 322         if (add)
 323                 return interface_add_link(iface, dev);
 324         else
 325                 return interface_remove_link(iface, dev);
 326
 327         device_unlock();
 328
 329         return ret;
 330 }
 331
 332
 333 static int
 334 netifd_iface_notify_proto(struct ubus_context *ctx, struct ubus_object *obj,
 335                           struct ubus_request_data *req, const char *method,
 336                           struct blob_attr *msg)
 337 {
 338         struct interface *iface;
 339
 340         iface = container_of(obj, struct interface, ubus);
 341
 342         if (!iface->proto || !iface->proto->notify)
 343                 return UBUS_STATUS_NOT_SUPPORTED;
 344
 345         return iface->proto->notify(iface->proto, msg);
 346 }
 347
 348 static void
 349 netifd_iface_do_remove(struct uloop_timeout *timeout)
 350 {
 351         struct interface *iface;
 352
 353         iface = container_of(timeout, struct interface, remove_timer);
 354         vlist_delete(&interfaces, &iface->node);
 355 }
 356
 357 static int
 358 netifd_iface_remove(struct ubus_context *ctx, struct ubus_object *obj,
 359                     struct ubus_request_data *req, const char *method,
 360                     struct blob_attr *msg)
 361 {
 362         struct interface *iface;
 363
 364         iface = container_of(obj, struct interface, ubus);
 365         if (iface->remove_timer.cb)
 366                 return UBUS_STATUS_INVALID_ARGUMENT;
 367
 368         iface->remove_timer.cb = netifd_iface_do_remove;
 369         uloop_timeout_set(&iface->remove_timer, 100);
 370         return 0;
 371 }
 372
 373 static int
 374 netifd_handle_iface_prepare(struct ubus_context *ctx, struct ubus_object *obj,
 375                             struct ubus_request_data *req, const char *method,
 376                             struct blob_attr *msg)
 377 {
 378         struct interface *iface;
 379         struct device *dev;
 380         const struct device_hotplug_ops *ops;
 381
 382         iface = container_of(obj, struct interface, ubus);
 383         dev = iface->main_dev.dev;
 384         if (!dev)
 385                 return 0;
 386
 387         ops = dev->hotplug_ops;
 388         if (!ops)
 389                 return 0;
 390
 391         return ops->prepare(dev);
 392 }
 393
 394 static struct ubus_method iface_object_methods[] = {
 395         { .name = "up", .handler = netifd_handle_up },
 396         { .name = "down", .handler = netifd_handle_down },
 397         { .name = "status", .handler = netifd_handle_status },
 398         { .name = "prepare", .handler = netifd_handle_iface_prepare },
 399         UBUS_METHOD("add_device", netifd_iface_handle_device, dev_policy ),
 400         UBUS_METHOD("remove_device", netifd_iface_handle_device, dev_policy ),
 401         { .name = "notify_proto", .handler = netifd_iface_notify_proto },
 402         { .name = "remove", .handler = netifd_iface_remove }
 403 };
 404
 405 static struct ubus_object_type iface_object_type =
 406         UBUS_OBJECT_TYPE("netifd_iface", iface_object_methods);
 407
 408
 409 void
 410 netifd_ubus_interface_event(struct interface *iface, bool up)
 411 {
 412         blob_buf_init(&b, 0);
 413         blobmsg_add_string(&b, "action", up ? "ifup" : "ifdown");
 414         blobmsg_add_string(&b, "interface", iface->name);
 415         ubus_send_event(ctx, "network.interface", b.head);
 416 }
 417
 418 void
 419 netifd_ubus_add_interface(struct interface *iface)
 420 {
 421         struct ubus_object *obj = &iface->ubus;
 422         char *name = NULL;
 423
 424         asprintf(&name, "%s.interface.%s", main_object.name, iface->name);
 425         if (!name)
 426                 return;
 427
 428         obj->name = name;
 429         obj->type = &iface_object_type;
 430         obj->methods = iface_object_methods;
 431         obj->n_methods = ARRAY_SIZE(iface_object_methods);
 432         if (ubus_add_object(ctx, &iface->ubus)) {
 433                 DPRINTF("failed to publish ubus object for interface '%s'\n", iface->name);
 434                 free(name);
 435                 obj->name = NULL;
 436         }
 437 }
 438
 439 void
 440 netifd_ubus_remove_interface(struct interface *iface)
 441 {
 442         if (!iface->ubus.name)
 443                 return;
 444
 445         ubus_remove_object(ctx, &iface->ubus);
 446         free((void *) iface->ubus.name);
 447 }