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         char *buf;
 239         void *a;
 240         int buflen = 128;
 241         int af;
 242
 243         vlist_for_each_element(&ip->addr, addr, node) {
 244                 if ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4)
 245                         af = AF_INET;
 246                 else
 247                         af = AF_INET6;
 248
 249                 a = blobmsg_open_table(&b, NULL);
 250
 251                 buf = blobmsg_alloc_string_buffer(&b, "address", buflen);
 252                 inet_ntop(af, &addr->addr, buf, buflen);
 253                 blobmsg_add_string_buffer(&b);
 254
 255                 blobmsg_add_u32(&b, "mask", addr->mask);
 256
 257                 blobmsg_close_table(&b, a);
 258         }
 259 }
 260
 261 static void
 262 interface_ip_dump_route_list(struct interface_ip_settings *ip)
 263 {
 264         struct device_route *route;
 265         static char *buf;
 266         int buflen = 128;
 267         void *r;
 268         int af;
 269
 270         vlist_for_each_element(&ip->route, route, node) {
 271                 if ((route->flags & DEVADDR_FAMILY) == DEVADDR_INET4)
 272                         af = AF_INET;
 273                 else
 274                         af = AF_INET6;
 275
 276                 r = blobmsg_open_table(&b, NULL);
 277
 278                 buf = blobmsg_alloc_string_buffer(&b, "target", buflen);
 279                 inet_ntop(af, &route->addr, buf, buflen);
 280                 blobmsg_add_string_buffer(&b);
 281
 282                 blobmsg_add_u32(&b, "mask", route->mask);
 283
 284                 buf = blobmsg_alloc_string_buffer(&b, "nexthop", buflen);
 285                 inet_ntop(af, &route->nexthop, buf, buflen);
 286                 blobmsg_add_string_buffer(&b);
 287
 288                 blobmsg_close_table(&b, r);
 289         }
 290 }
 291
 292 static int
 293 netifd_handle_status(struct ubus_context *ctx, struct ubus_object *obj,
 294                      struct ubus_request_data *req, const char *method,
 295                      struct blob_attr *msg)
 296 {
 297         struct interface *iface;
 298         struct interface_data *data;
 299         struct device *dev;
 300         void *a;
 301
 302         iface = container_of(obj, struct interface, ubus);
 303
 304         blob_buf_init(&b, 0);
 305         blobmsg_add_u8(&b, "up", iface->state == IFS_UP);
 306         blobmsg_add_u8(&b, "pending", iface->state == IFS_SETUP);
 307         blobmsg_add_u8(&b, "available", iface->available);
 308         blobmsg_add_u8(&b, "autostart", iface->autostart);
 309
 310         if (iface->state == IFS_UP) {
 311                 time_t cur = system_get_rtime();
 312                 blobmsg_add_u32(&b, "uptime", cur - iface->start_time);
 313                 blobmsg_add_string(&b, "l3_device", iface->l3_dev.dev->ifname);
 314         }
 315
 316         dev = iface->main_dev.dev;
 317         if (dev && !(iface->proto_handler->flags & PROTO_FLAG_NODEV))
 318                 blobmsg_add_string(&b, "device", dev->ifname);
 319
 320         if (iface->state == IFS_UP) {
 321                 a = blobmsg_open_array(&b, "address");
 322                 interface_ip_dump_address_list(&iface->config_ip);
 323                 interface_ip_dump_address_list(&iface->proto_ip);
 324                 blobmsg_close_array(&b, a);
 325                 a = blobmsg_open_array(&b, "route");
 326                 interface_ip_dump_route_list(&iface->config_ip);
 327                 interface_ip_dump_route_list(&iface->proto_ip);
 328                 blobmsg_close_array(&b, a);
 329         }
 330
 331         a = blobmsg_open_table(&b, "data");
 332         avl_for_each_element(&iface->data, data, node)
 333                 blob_put(&b, blob_id(data->data), blob_data(data->data), blob_len(data->data));
 334
 335         blobmsg_close_table(&b, a);
 336
 337         if (!list_is_empty(&iface->errors))
 338                 netifd_add_interface_errors(&b, iface);
 339
 340         ubus_send_reply(ctx, req, b.head);
 341
 342         return 0;
 343 }
 344
 345 static int
 346 netifd_iface_handle_device(struct ubus_context *ctx, struct ubus_object *obj,
 347                            struct ubus_request_data *req, const char *method,
 348                            struct blob_attr *msg)
 349 {
 350         struct blob_attr *tb[__DEV_MAX];
 351         struct interface *iface;
 352         struct device *dev;
 353         bool add = !strncmp(method, "add", 3);
 354         int ret;
 355
 356         iface = container_of(obj, struct interface, ubus);
 357
 358         blobmsg_parse(dev_policy, __DEV_MAX, tb, blob_data(msg), blob_len(msg));
 359
 360         if (!tb[DEV_NAME])
 361                 return UBUS_STATUS_INVALID_ARGUMENT;
 362
 363         device_lock();
 364
 365         dev = device_get(blobmsg_data(tb[DEV_NAME]), add ? 2 : 0);
 366         if (add && !dev)
 367                 return UBUS_STATUS_NOT_FOUND;
 368
 369         if (add)
 370                 return interface_add_link(iface, dev);
 371         else
 372                 return interface_remove_link(iface, dev);
 373
 374         device_unlock();
 375
 376         return ret;
 377 }
 378
 379
 380 static int
 381 netifd_iface_notify_proto(struct ubus_context *ctx, struct ubus_object *obj,
 382                           struct ubus_request_data *req, const char *method,
 383                           struct blob_attr *msg)
 384 {
 385         struct interface *iface;
 386
 387         iface = container_of(obj, struct interface, ubus);
 388
 389         if (!iface->proto || !iface->proto->notify)
 390                 return UBUS_STATUS_NOT_SUPPORTED;
 391
 392         return iface->proto->notify(iface->proto, msg);
 393 }
 394
 395 static void
 396 netifd_iface_do_remove(struct uloop_timeout *timeout)
 397 {
 398         struct interface *iface;
 399
 400         iface = container_of(timeout, struct interface, remove_timer);
 401         vlist_delete(&interfaces, &iface->node);
 402 }
 403
 404 static int
 405 netifd_iface_remove(struct ubus_context *ctx, struct ubus_object *obj,
 406                     struct ubus_request_data *req, const char *method,
 407                     struct blob_attr *msg)
 408 {
 409         struct interface *iface;
 410
 411         iface = container_of(obj, struct interface, ubus);
 412         if (iface->remove_timer.cb)
 413                 return UBUS_STATUS_INVALID_ARGUMENT;
 414
 415         iface->remove_timer.cb = netifd_iface_do_remove;
 416         uloop_timeout_set(&iface->remove_timer, 100);
 417         return 0;
 418 }
 419
 420 static int
 421 netifd_handle_iface_prepare(struct ubus_context *ctx, struct ubus_object *obj,
 422                             struct ubus_request_data *req, const char *method,
 423                             struct blob_attr *msg)
 424 {
 425         struct interface *iface;
 426         struct device *dev;
 427         const struct device_hotplug_ops *ops;
 428
 429         iface = container_of(obj, struct interface, ubus);
 430         dev = iface->main_dev.dev;
 431         if (!dev)
 432                 return 0;
 433
 434         ops = dev->hotplug_ops;
 435         if (!ops)
 436                 return 0;
 437
 438         return ops->prepare(dev);
 439 }
 440
 441 static int
 442 netifd_handle_set_data(struct ubus_context *ctx, struct ubus_object *obj,
 443                        struct ubus_request_data *req, const char *method,
 444                        struct blob_attr *msg)
 445 {
 446         struct interface *iface;
 447         struct blob_attr *cur;
 448         int rem, ret;
 449
 450         iface = container_of(obj, struct interface, ubus);
 451
 452         blob_for_each_attr(cur, msg, rem) {
 453                 ret = interface_add_data(iface, cur);
 454                 if (ret)
 455                         return ret;
 456         }
 457
 458         return 0;
 459 }
 460
 461 static struct ubus_method iface_object_methods[] = {
 462         { .name = "up", .handler = netifd_handle_up },
 463         { .name = "down", .handler = netifd_handle_down },
 464         { .name = "status", .handler = netifd_handle_status },
 465         { .name = "prepare", .handler = netifd_handle_iface_prepare },
 466         UBUS_METHOD("add_device", netifd_iface_handle_device, dev_policy ),
 467         UBUS_METHOD("remove_device", netifd_iface_handle_device, dev_policy ),
 468         { .name = "notify_proto", .handler = netifd_iface_notify_proto },
 469         { .name = "remove", .handler = netifd_iface_remove },
 470         { .name = "set_data", .handler = netifd_handle_set_data },
 471 };
 472
 473 static struct ubus_object_type iface_object_type =
 474         UBUS_OBJECT_TYPE("netifd_iface", iface_object_methods);
 475
 476
 477 void
 478 netifd_ubus_interface_event(struct interface *iface, bool up)
 479 {
 480         blob_buf_init(&b, 0);
 481         blobmsg_add_string(&b, "action", up ? "ifup" : "ifdown");
 482         blobmsg_add_string(&b, "interface", iface->name);
 483         ubus_send_event(ctx, "network.interface", b.head);
 484 }
 485
 486 void
 487 netifd_ubus_add_interface(struct interface *iface)
 488 {
 489         struct ubus_object *obj = &iface->ubus;
 490         char *name = NULL;
 491
 492         asprintf(&name, "%s.interface.%s", main_object.name, iface->name);
 493         if (!name)
 494                 return;
 495
 496         obj->name = name;
 497         obj->type = &iface_object_type;
 498         obj->methods = iface_object_methods;
 499         obj->n_methods = ARRAY_SIZE(iface_object_methods);
 500         if (ubus_add_object(ctx, &iface->ubus)) {
 501                 DPRINTF("failed to publish ubus object for interface '%s'\n", iface->name);
 502                 free(name);
 503                 obj->name = NULL;
 504         }
 505 }
 506
 507 void
 508 netifd_ubus_remove_interface(struct interface *iface)
 509 {
 510         if (!iface->ubus.name)
 511                 return;
 512
 513         ubus_remove_object(ctx, &iface->ubus);
 514         free((void *) iface->ubus.name);
 515 }