session.c

   1 /*
   2  * luci-rpcd - LuCI UBUS RPC server
   3  *
   4  *   Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
   5  *   Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 #include <libubox/avl-cmp.h>
  21 #include <libubox/utils.h>
  22 #include <libubus.h>
  23 #include <fnmatch.h>
  24
  25 #include "session.h"
  26
  27 static struct avl_tree sessions;
  28 static struct blob_buf buf;
  29
  30 static const struct blobmsg_policy new_policy = {
  31         .name = "timeout", .type = BLOBMSG_TYPE_INT32
  32 };
  33
  34 static const struct blobmsg_policy sid_policy = {
  35         .name = "sid", .type = BLOBMSG_TYPE_STRING
  36 };
  37
  38 enum {
  39         RPC_SS_SID,
  40         RPC_SS_VALUES,
  41         __RPC_SS_MAX,
  42 };
  43 static const struct blobmsg_policy set_policy[__RPC_SS_MAX] = {
  44         [RPC_SS_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING },
  45         [RPC_SS_VALUES] = { .name = "values", .type = BLOBMSG_TYPE_TABLE },
  46 };
  47
  48 enum {
  49         RPC_SG_SID,
  50         RPC_SG_KEYS,
  51         __RPC_SG_MAX,
  52 };
  53 static const struct blobmsg_policy get_policy[__RPC_SG_MAX] = {
  54         [RPC_SG_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING },
  55         [RPC_SG_KEYS] = { .name = "keys", .type = BLOBMSG_TYPE_ARRAY },
  56 };
  57
  58 enum {
  59         RPC_SA_SID,
  60         RPC_SA_OBJECTS,
  61         __RPC_SA_MAX,
  62 };
  63 static const struct blobmsg_policy acl_policy[__RPC_SA_MAX] = {
  64         [RPC_SA_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING },
  65         [RPC_SA_OBJECTS] = { .name = "objects", .type = BLOBMSG_TYPE_ARRAY },
  66 };
  67
  68 enum {
  69         RPC_SP_SID,
  70         RPC_SP_OBJECT,
  71         RPC_SP_FUNCTION,
  72         __RPC_SP_MAX,
  73 };
  74 static const struct blobmsg_policy perm_policy[__RPC_SP_MAX] = {
  75         [RPC_SP_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING },
  76         [RPC_SP_OBJECT] = { .name = "object", .type = BLOBMSG_TYPE_STRING },
  77         [RPC_SP_FUNCTION] = { .name = "function", .type = BLOBMSG_TYPE_STRING },
  78 };
  79
  80 /*
  81  * Keys in the AVL tree contain all pattern characters up to the first wildcard.
  82  * To look up entries, start with the last entry that has a key less than or
  83  * equal to the method name, then work backwards as long as the AVL key still
  84  * matches its counterpart in the object name
  85  */
  86 #define uh_foreach_matching_acl_prefix(_acl, _ses, _obj, _func)                 \
  87         for (_acl = avl_find_le_element(&(_ses)->acls, _obj, _acl, avl);        \
  88              _acl;                                                              \
  89              _acl = avl_is_first(&(ses)->acls, &(_acl)->avl) ? NULL :           \
  90                     avl_prev_element((_acl), avl))
  91
  92 #define uh_foreach_matching_acl(_acl, _ses, _obj, _func)                        \
  93         uh_foreach_matching_acl_prefix(_acl, _ses, _obj, _func)                 \
  94                 if (!strncmp((_acl)->object, _obj, (_acl)->sort_len) &&         \
  95                     !fnmatch((_acl)->object, (_obj), FNM_NOESCAPE) &&           \
  96                     !fnmatch((_acl)->function, (_func), FNM_NOESCAPE))
  97
  98 static void
  99 rpc_random(char *dest)
 100 {
 101         unsigned char buf[16] = { 0 };
 102         FILE *f;
 103         int i;
 104
 105         f = fopen("/dev/urandom", "r");
 106         if (!f)
 107                 return;
 108
 109         fread(buf, 1, sizeof(buf), f);
 110         fclose(f);
 111
 112         for (i = 0; i < sizeof(buf); i++)
 113                 sprintf(dest + (i<<1), "%02x", buf[i]);
 114 }
 115
 116 static void
 117 rpc_session_dump_data(struct rpc_session *ses, struct blob_buf *b)
 118 {
 119         struct rpc_session_data *d;
 120
 121         avl_for_each_element(&ses->data, d, avl) {
 122                 blobmsg_add_field(b, blobmsg_type(d->attr), blobmsg_name(d->attr),
 123                                   blobmsg_data(d->attr), blobmsg_data_len(d->attr));
 124         }
 125 }
 126
 127 static void
 128 rpc_session_dump_acls(struct rpc_session *ses, struct blob_buf *b)
 129 {
 130         struct rpc_session_acl *acl;
 131         const char *lastobj = NULL;
 132         void *c = NULL;
 133
 134         avl_for_each_element(&ses->acls, acl, avl) {
 135                 if (!lastobj || strcmp(acl->object, lastobj))
 136                 {
 137                         if (c) blobmsg_close_array(b, c);
 138                         c = blobmsg_open_array(b, acl->object);
 139                 }
 140
 141                 blobmsg_add_string(b, NULL, acl->function);
 142                 lastobj = acl->object;
 143         }
 144
 145         if (c) blobmsg_close_array(b, c);
 146 }
 147
 148 static void
 149 rpc_session_dump(struct rpc_session *ses,
 150                                          struct ubus_context *ctx,
 151                                          struct ubus_request_data *req)
 152 {
 153         void *c;
 154
 155         blob_buf_init(&buf, 0);
 156
 157         blobmsg_add_string(&buf, "sid", ses->id);
 158         blobmsg_add_u32(&buf, "timeout", ses->timeout);
 159         blobmsg_add_u32(&buf, "expires", uloop_timeout_remaining(&ses->t) / 1000);
 160
 161         c = blobmsg_open_table(&buf, "acls");
 162         rpc_session_dump_acls(ses, &buf);
 163         blobmsg_close_table(&buf, c);
 164
 165         c = blobmsg_open_table(&buf, "data");
 166         rpc_session_dump_data(ses, &buf);
 167         blobmsg_close_table(&buf, c);
 168
 169         ubus_send_reply(ctx, req, buf.head);
 170 }
 171
 172 static void
 173 rpc_touch_session(struct rpc_session *ses)
 174 {
 175         uloop_timeout_set(&ses->t, ses->timeout * 1000);
 176 }
 177
 178 static void
 179 rpc_session_destroy(struct rpc_session *ses)
 180 {
 181         struct rpc_session_acl *acl, *nacl;
 182         struct rpc_session_data *data, *ndata;
 183
 184         uloop_timeout_cancel(&ses->t);
 185         avl_remove_all_elements(&ses->acls, acl, avl, nacl)
 186                 free(acl);
 187
 188         avl_remove_all_elements(&ses->data, data, avl, ndata)
 189                 free(data);
 190
 191         avl_delete(&sessions, &ses->avl);
 192         free(ses);
 193 }
 194
 195 static void rpc_session_timeout(struct uloop_timeout *t)
 196 {
 197         struct rpc_session *ses;
 198
 199         ses = container_of(t, struct rpc_session, t);
 200         rpc_session_destroy(ses);
 201 }
 202
 203 static struct rpc_session *
 204 rpc_session_create(int timeout)
 205 {
 206         struct rpc_session *ses;
 207
 208         ses = calloc(1, sizeof(*ses));
 209         if (!ses)
 210                 return NULL;
 211
 212         ses->timeout  = timeout;
 213         ses->avl.key  = ses->id;
 214         rpc_random(ses->id);
 215
 216         avl_insert(&sessions, &ses->avl);
 217         avl_init(&ses->acls, avl_strcmp, true, NULL);
 218         avl_init(&ses->data, avl_strcmp, false, NULL);
 219
 220         ses->t.cb = rpc_session_timeout;
 221         rpc_touch_session(ses);
 222
 223         return ses;
 224 }
 225
 226 static struct rpc_session *
 227 rpc_session_get(const char *id)
 228 {
 229         struct rpc_session *ses;
 230
 231         ses = avl_find_element(&sessions, id, ses, avl);
 232         if (!ses)
 233                 return NULL;
 234
 235         rpc_touch_session(ses);
 236         return ses;
 237 }
 238
 239 static int
 240 rpc_handle_create(struct ubus_context *ctx, struct ubus_object *obj,
 241                   struct ubus_request_data *req, const char *method,
 242                   struct blob_attr *msg)
 243 {
 244         struct rpc_session *ses;
 245         struct blob_attr *tb;
 246         int timeout = RPC_DEFAULT_SESSION_TIMEOUT;
 247
 248         blobmsg_parse(&new_policy, 1, &tb, blob_data(msg), blob_len(msg));
 249         if (tb)
 250                 timeout = blobmsg_get_u32(tb);
 251
 252         ses = rpc_session_create(timeout);
 253         if (ses)
 254                 rpc_session_dump(ses, ctx, req);
 255
 256         return 0;
 257 }
 258
 259 static int
 260 rpc_handle_list(struct ubus_context *ctx, struct ubus_object *obj,
 261                 struct ubus_request_data *req, const char *method,
 262                 struct blob_attr *msg)
 263 {
 264         struct rpc_session *ses;
 265         struct blob_attr *tb;
 266
 267         blobmsg_parse(&sid_policy, 1, &tb, blob_data(msg), blob_len(msg));
 268
 269         if (!tb) {
 270                 avl_for_each_element(&sessions, ses, avl)
 271                         rpc_session_dump(ses, ctx, req);
 272                 return 0;
 273         }
 274
 275         ses = rpc_session_get(blobmsg_data(tb));
 276         if (!ses)
 277                 return UBUS_STATUS_NOT_FOUND;
 278
 279         rpc_session_dump(ses, ctx, req);
 280
 281         return 0;
 282 }
 283
 284 static int
 285 uh_id_len(const char *str)
 286 {
 287         return strcspn(str, "*?[");
 288 }
 289
 290 static int
 291 rpc_session_grant(struct rpc_session *ses, struct ubus_context *ctx,
 292                   const char *object, const char *function)
 293 {
 294         struct rpc_session_acl *acl;
 295         char *new_obj, *new_func, *new_id;
 296         int id_len;
 297
 298         if (!object || !function)
 299                 return UBUS_STATUS_INVALID_ARGUMENT;
 300
 301         uh_foreach_matching_acl_prefix(acl, ses, object, function) {
 302                 if (!strcmp(acl->object, object) &&
 303                     !strcmp(acl->function, function))
 304                         return 0;
 305         }
 306
 307         id_len = uh_id_len(object);
 308         acl = calloc_a(sizeof(*acl),
 309                 &new_obj, strlen(object) + 1,
 310                 &new_func, strlen(function) + 1,
 311                 &new_id, id_len + 1);
 312
 313         if (!acl)
 314                 return UBUS_STATUS_UNKNOWN_ERROR;
 315
 316         acl->object = strcpy(new_obj, object);
 317         acl->function = strcpy(new_func, function);
 318         acl->avl.key = strncpy(new_id, object, id_len);
 319         avl_insert(&ses->acls, &acl->avl);
 320
 321         return 0;
 322 }
 323
 324 static int
 325 rpc_session_revoke(struct rpc_session *ses, struct ubus_context *ctx,
 326                    const char *object, const char *function)
 327 {
 328         struct rpc_session_acl *acl, *next;
 329         int id_len;
 330         char *id;
 331
 332         if (!object && !function) {
 333                 avl_remove_all_elements(&ses->acls, acl, avl, next)
 334                         free(acl);
 335                 return 0;
 336         }
 337
 338         id_len = uh_id_len(object);
 339         id = alloca(id_len + 1);
 340         strncpy(id, object, id_len);
 341         id[id_len] = 0;
 342
 343         acl = avl_find_element(&ses->acls, id, acl, avl);
 344         while (acl) {
 345                 if (!avl_is_last(&ses->acls, &acl->avl))
 346                         next = avl_next_element(acl, avl);
 347                 else
 348                         next = NULL;
 349
 350                 if (strcmp(id, acl->avl.key) != 0)
 351                         break;
 352
 353                 if (!strcmp(acl->object, object) &&
 354                     !strcmp(acl->function, function)) {
 355                         avl_delete(&ses->acls, &acl->avl);
 356                         free(acl);
 357                 }
 358                 acl = next;
 359         }
 360
 361         return 0;
 362 }
 363
 364
 365 static int
 366 rpc_handle_acl(struct ubus_context *ctx, struct ubus_object *obj,
 367                struct ubus_request_data *req, const char *method,
 368                struct blob_attr *msg)
 369 {
 370         struct rpc_session *ses;
 371         struct blob_attr *tb[__RPC_SA_MAX];
 372         struct blob_attr *attr, *sattr;
 373         const char *object, *function;
 374         int rem1, rem2;
 375
 376         int (*cb)(struct rpc_session *ses, struct ubus_context *ctx,
 377                   const char *object, const char *function);
 378
 379         blobmsg_parse(acl_policy, __RPC_SA_MAX, tb, blob_data(msg), blob_len(msg));
 380
 381         if (!tb[RPC_SA_SID])
 382                 return UBUS_STATUS_INVALID_ARGUMENT;
 383
 384         ses = rpc_session_get(blobmsg_data(tb[RPC_SA_SID]));
 385         if (!ses)
 386                 return UBUS_STATUS_NOT_FOUND;
 387
 388         if (!strcmp(method, "grant"))
 389                 cb = rpc_session_grant;
 390         else
 391                 cb = rpc_session_revoke;
 392
 393         if (!tb[RPC_SA_OBJECTS])
 394                 return cb(ses, ctx, NULL, NULL);
 395
 396         blobmsg_for_each_attr(attr, tb[RPC_SA_OBJECTS], rem1) {
 397                 if (blob_id(attr) != BLOBMSG_TYPE_ARRAY)
 398                         continue;
 399
 400                 object = NULL;
 401                 function = NULL;
 402
 403                 blobmsg_for_each_attr(sattr, attr, rem2) {
 404                         if (blob_id(sattr) != BLOBMSG_TYPE_STRING)
 405                                 continue;
 406
 407                         if (!object)
 408                                 object = blobmsg_data(sattr);
 409                         else if (!function)
 410                                 function = blobmsg_data(sattr);
 411                         else
 412                                 break;
 413                 }
 414
 415                 if (object && function)
 416                         cb(ses, ctx, object, function);
 417         }
 418
 419         return 0;
 420 }
 421
 422 static bool
 423 rpc_session_acl_allowed(struct rpc_session *ses, const char *obj, const char *fun)
 424 {
 425         struct rpc_session_acl *acl;
 426
 427         uh_foreach_matching_acl(acl, ses, obj, fun)
 428                 return true;
 429
 430         return false;
 431 }
 432
 433 static int
 434 rpc_handle_access(struct ubus_context *ctx, struct ubus_object *obj,
 435                   struct ubus_request_data *req, const char *method,
 436                   struct blob_attr *msg)
 437 {
 438         struct rpc_session *ses;
 439         struct blob_attr *tb[__RPC_SP_MAX];
 440         bool allow;
 441
 442         blobmsg_parse(perm_policy, __RPC_SP_MAX, tb, blob_data(msg), blob_len(msg));
 443
 444         if (!tb[RPC_SP_SID] || !tb[RPC_SP_OBJECT] || !tb[RPC_SP_FUNCTION])
 445                 return UBUS_STATUS_INVALID_ARGUMENT;
 446
 447         ses = rpc_session_get(blobmsg_data(tb[RPC_SP_SID]));
 448         if (!ses)
 449                 return UBUS_STATUS_NOT_FOUND;
 450
 451         allow = rpc_session_acl_allowed(ses,
 452                                                                         blobmsg_data(tb[RPC_SP_OBJECT]),
 453                                                                         blobmsg_data(tb[RPC_SP_FUNCTION]));
 454
 455         blob_buf_init(&buf, 0);
 456         blobmsg_add_u8(&buf, "access", allow);
 457         ubus_send_reply(ctx, req, buf.head);
 458
 459         return 0;
 460 }
 461
 462 static int
 463 rpc_handle_set(struct ubus_context *ctx, struct ubus_object *obj,
 464                struct ubus_request_data *req, const char *method,
 465                struct blob_attr *msg)
 466 {
 467         struct rpc_session *ses;
 468         struct rpc_session_data *data;
 469         struct blob_attr *tb[__RPC_SA_MAX];
 470         struct blob_attr *attr;
 471         int rem;
 472
 473         blobmsg_parse(set_policy, __RPC_SS_MAX, tb, blob_data(msg), blob_len(msg));
 474
 475         if (!tb[RPC_SS_SID] || !tb[RPC_SS_VALUES])
 476                 return UBUS_STATUS_INVALID_ARGUMENT;
 477
 478         ses = rpc_session_get(blobmsg_data(tb[RPC_SS_SID]));
 479         if (!ses)
 480                 return UBUS_STATUS_NOT_FOUND;
 481
 482         blobmsg_for_each_attr(attr, tb[RPC_SS_VALUES], rem) {
 483                 if (!blobmsg_name(attr)[0])
 484                         continue;
 485
 486                 data = avl_find_element(&ses->data, blobmsg_name(attr), data, avl);
 487                 if (data) {
 488                         avl_delete(&ses->data, &data->avl);
 489                         free(data);
 490                 }
 491
 492                 data = calloc(1, sizeof(*data) + blob_pad_len(attr));
 493                 if (!data)
 494                         break;
 495
 496                 memcpy(data->attr, attr, blob_pad_len(attr));
 497                 data->avl.key = blobmsg_name(data->attr);
 498                 avl_insert(&ses->data, &data->avl);
 499         }
 500
 501         return 0;
 502 }
 503
 504 static int
 505 rpc_handle_get(struct ubus_context *ctx, struct ubus_object *obj,
 506                struct ubus_request_data *req, const char *method,
 507                struct blob_attr *msg)
 508 {
 509         struct rpc_session *ses;
 510         struct rpc_session_data *data;
 511         struct blob_attr *tb[__RPC_SA_MAX];
 512         struct blob_attr *attr;
 513         void *c;
 514         int rem;
 515
 516         blobmsg_parse(get_policy, __RPC_SG_MAX, tb, blob_data(msg), blob_len(msg));
 517
 518         if (!tb[RPC_SG_SID])
 519                 return UBUS_STATUS_INVALID_ARGUMENT;
 520
 521         ses = rpc_session_get(blobmsg_data(tb[RPC_SG_SID]));
 522         if (!ses)
 523                 return UBUS_STATUS_NOT_FOUND;
 524
 525         blob_buf_init(&buf, 0);
 526         c = blobmsg_open_table(&buf, "values");
 527
 528         if (tb[RPC_SG_KEYS])
 529                 blobmsg_for_each_attr(attr, tb[RPC_SG_KEYS], rem) {
 530                         if (blob_id(attr) != BLOBMSG_TYPE_STRING)
 531                                 continue;
 532
 533                         data = avl_find_element(&ses->data, blobmsg_data(attr), data, avl);
 534                         if (!data)
 535                                 continue;
 536
 537                         blobmsg_add_field(&buf, blobmsg_type(data->attr),
 538                                           blobmsg_name(data->attr),
 539                                           blobmsg_data(data->attr),
 540                                           blobmsg_data_len(data->attr));
 541                 }
 542         else
 543                 rpc_session_dump_data(ses, &buf);
 544
 545         blobmsg_close_table(&buf, c);
 546         ubus_send_reply(ctx, req, buf.head);
 547
 548         return 0;
 549 }
 550
 551 static int
 552 rpc_handle_unset(struct ubus_context *ctx, struct ubus_object *obj,
 553                  struct ubus_request_data *req, const char *method,
 554                  struct blob_attr *msg)
 555 {
 556         struct rpc_session *ses;
 557         struct rpc_session_data *data, *ndata;
 558         struct blob_attr *tb[__RPC_SA_MAX];
 559         struct blob_attr *attr;
 560         int rem;
 561
 562         blobmsg_parse(get_policy, __RPC_SG_MAX, tb, blob_data(msg), blob_len(msg));
 563
 564         if (!tb[RPC_SG_SID])
 565                 return UBUS_STATUS_INVALID_ARGUMENT;
 566
 567         ses = rpc_session_get(blobmsg_data(tb[RPC_SG_SID]));
 568         if (!ses)
 569                 return UBUS_STATUS_NOT_FOUND;
 570
 571         if (!tb[RPC_SG_KEYS]) {
 572                 avl_remove_all_elements(&ses->data, data, avl, ndata)
 573                         free(data);
 574                 return 0;
 575         }
 576
 577         blobmsg_for_each_attr(attr, tb[RPC_SG_KEYS], rem) {
 578                 if (blob_id(attr) != BLOBMSG_TYPE_STRING)
 579                         continue;
 580
 581                 data = avl_find_element(&ses->data, blobmsg_data(attr), data, avl);
 582                 if (!data)
 583                         continue;
 584
 585                 avl_delete(&ses->data, &data->avl);
 586                 free(data);
 587         }
 588
 589         return 0;
 590 }
 591
 592 static int
 593 rpc_handle_destroy(struct ubus_context *ctx, struct ubus_object *obj,
 594                    struct ubus_request_data *req, const char *method,
 595                    struct blob_attr *msg)
 596 {
 597         struct rpc_session *ses;
 598         struct blob_attr *tb;
 599
 600         blobmsg_parse(&sid_policy, 1, &tb, blob_data(msg), blob_len(msg));
 601
 602         if (!tb)
 603                 return UBUS_STATUS_INVALID_ARGUMENT;
 604
 605         ses = rpc_session_get(blobmsg_data(tb));
 606         if (!ses)
 607                 return UBUS_STATUS_NOT_FOUND;
 608
 609         rpc_session_destroy(ses);
 610
 611         return 0;
 612 }
 613
 614 int rpc_session_api_init(struct ubus_context *ctx)
 615 {
 616         static const struct ubus_method session_methods[] = {
 617                 UBUS_METHOD("create",  rpc_handle_create,  &new_policy),
 618                 UBUS_METHOD("list",    rpc_handle_list,    &sid_policy),
 619                 UBUS_METHOD("grant",   rpc_handle_acl,     acl_policy),
 620                 UBUS_METHOD("revoke",  rpc_handle_acl,     acl_policy),
 621                 UBUS_METHOD("access",  rpc_handle_access,  perm_policy),
 622                 UBUS_METHOD("set",     rpc_handle_set,     set_policy),
 623                 UBUS_METHOD("get",     rpc_handle_get,     get_policy),
 624                 UBUS_METHOD("unset",   rpc_handle_unset,   get_policy),
 625                 UBUS_METHOD("destroy", rpc_handle_destroy, &sid_policy),
 626         };
 627
 628         static struct ubus_object_type session_type =
 629                 UBUS_OBJECT_TYPE("luci-rpc-session", session_methods);
 630
 631         static struct ubus_object obj = {
 632                 .name = "session",
 633                 .type = &session_type,
 634                 .methods = session_methods,
 635                 .n_methods = ARRAY_SIZE(session_methods),
 636         };
 637
 638         avl_init(&sessions, avl_strcmp, false, NULL);
 639
 640         return ubus_add_object(ctx, &obj);
 641 }