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