local_node.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License.
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  14  *
  15  *   Copyright (C) 2020 embedd.ch
  16  *   Copyright (C) 2020 Felix Fietkau <nbd@nbd.name>
  17  *   Copyright (C) 2020 John Crispin <john@phrozen.org>
  18  */
  19
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <net/ethernet.h>
  23 #ifdef linux
  24 #include <netinet/ether.h>
  25 #endif
  26 #include <net/if.h>
  27 #include <stdlib.h>
  28
  29 #include <libubox/avl-cmp.h>
  30 #include <libubox/blobmsg_json.h>
  31 #include "usteer.h"
  32 #include "node.h"
  33
  34 AVL_TREE(local_nodes, avl_strcmp, false, NULL);
  35 static struct blob_buf b;
  36 static char *node_up_script;
  37
  38 static void
  39 usteer_local_node_state_reset(struct usteer_local_node *ln)
  40 {
  41         if (ln->req_state == REQ_IDLE)
  42                 return;
  43
  44         ubus_abort_request(ubus_ctx, &ln->req);
  45         uloop_timeout_cancel(&ln->req_timer);
  46         ln->req_state = REQ_IDLE;
  47 }
  48
  49 static void
  50 usteer_free_node(struct ubus_context *ctx, struct usteer_local_node *ln)
  51 {
  52         struct usteer_node_handler *h;
  53
  54         list_for_each_entry(h, &node_handlers, list) {
  55                 if (!h->free_node)
  56                         continue;
  57                 h->free_node(&ln->node);
  58         }
  59
  60         usteer_local_node_state_reset(ln);
  61         usteer_sta_node_cleanup(&ln->node);
  62         uloop_timeout_cancel(&ln->update);
  63         avl_delete(&local_nodes, &ln->node.avl);
  64         ubus_unregister_subscriber(ctx, &ln->ev);
  65         kvlist_free(&ln->node_info);
  66         free(ln);
  67 }
  68
  69 static void
  70 usteer_handle_remove(struct ubus_context *ctx, struct ubus_subscriber *s,
  71                     uint32_t id)
  72 {
  73         struct usteer_local_node *ln = container_of(s, struct usteer_local_node, ev);
  74
  75         usteer_free_node(ctx, ln);
  76 }
  77
  78 static int
  79 usteer_handle_event(struct ubus_context *ctx, struct ubus_object *obj,
  80                    struct ubus_request_data *req, const char *method,
  81                    struct blob_attr *msg)
  82 {
  83         enum {
  84                 EVENT_ADDR,
  85                 EVENT_SIGNAL,
  86                 EVENT_TARGET,
  87                 EVENT_FREQ,
  88                 __EVENT_MAX
  89         };
  90         struct blobmsg_policy policy[__EVENT_MAX] = {
  91                 [EVENT_ADDR] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
  92                 [EVENT_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 },
  93                 [EVENT_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
  94                 [EVENT_FREQ] = { .name = "freq", .type = BLOBMSG_TYPE_INT32 },
  95         };
  96         enum usteer_event_type ev_type = __EVENT_TYPE_MAX;
  97         struct blob_attr *tb[__EVENT_MAX];
  98         struct usteer_local_node *ln;
  99         struct usteer_node *node;
 100         int signal = NO_SIGNAL;
 101         int freq = 0;
 102         const char *addr_str;
 103         const uint8_t *addr;
 104         int i;
 105         bool ret;
 106
 107         usteer_update_time();
 108
 109         for (i = 0; i < ARRAY_SIZE(event_types); i++) {
 110                 if (strcmp(method, event_types[i]) != 0)
 111                         continue;
 112
 113                 ev_type = i;
 114                 break;
 115         }
 116
 117         ln = container_of(obj, struct usteer_local_node, ev.obj);
 118         node = &ln->node;
 119         blobmsg_parse(policy, __EVENT_MAX, tb, blob_data(msg), blob_len(msg));
 120         if (!tb[EVENT_ADDR] || !tb[EVENT_FREQ])
 121                 return UBUS_STATUS_INVALID_ARGUMENT;
 122
 123         if (tb[EVENT_SIGNAL])
 124                 signal = (int32_t) blobmsg_get_u32(tb[EVENT_SIGNAL]);
 125
 126         if (tb[EVENT_FREQ])
 127                 freq = blobmsg_get_u32(tb[EVENT_FREQ]);
 128
 129         addr_str = blobmsg_data(tb[EVENT_ADDR]);
 130         addr = (uint8_t *) ether_aton(addr_str);
 131         if (!addr)
 132                 return UBUS_STATUS_INVALID_ARGUMENT;
 133
 134         ret = usteer_handle_sta_event(node, addr, ev_type, freq, signal);
 135
 136         MSG(DEBUG, "received %s event from %s, signal=%d, freq=%d, handled:%s\n",
 137             method, addr_str, signal, freq, ret ? "true" : "false");
 138
 139         return ret ? 0 : 17 /* WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA */;
 140 }
 141
 142 static void
 143 usteer_local_node_assoc_update(struct sta_info *si, struct blob_attr *data)
 144 {
 145         enum {
 146                 MSG_ASSOC,
 147                 __MSG_MAX,
 148         };
 149         static struct blobmsg_policy policy[__MSG_MAX] = {
 150                 [MSG_ASSOC] = { "assoc", BLOBMSG_TYPE_BOOL },
 151         };
 152         struct blob_attr *tb[__MSG_MAX];
 153         struct usteer_remote_node *rn;
 154         struct sta_info *remote_si;
 155
 156         blobmsg_parse(policy, __MSG_MAX, tb, blobmsg_data(data), blobmsg_data_len(data));
 157         if (tb[MSG_ASSOC] && blobmsg_get_u8(tb[MSG_ASSOC])) {
 158                 if (si->connected == STA_NOT_CONNECTED) {
 159                         /* New connection. Check if STA roamed. */
 160                         for_each_remote_node(rn) {
 161                                 remote_si = usteer_sta_info_get(si->sta, &rn->node, NULL);
 162                                 if (!remote_si)
 163                                         continue;
 164
 165                                 if (current_time - remote_si->last_connected < config.roam_process_timeout) {
 166                                         rn->node.roam_events.source++;
 167                                         /* Don't abort looking for roam sources here.
 168                                          * The client might have roamed via another node
 169                                          * within the roam-timeout.
 170                                          */
 171                                 }
 172                         }
 173                 }
 174                 si->connected = STA_CONNECTED;
 175         }
 176
 177         if (si->node->freq < 4000)
 178                 si->sta->seen_2ghz = 1;
 179         else
 180                 si->sta->seen_5ghz = 1;
 181 }
 182
 183 static void
 184 usteer_local_node_update_sta_rrm(const uint8_t *addr, struct blob_attr *client_attr)
 185 {
 186         static const struct blobmsg_policy rrm_policy = {
 187                 .name = "rrm",
 188                 .type = BLOBMSG_TYPE_ARRAY,
 189         };
 190         struct blob_attr *sta_blob = NULL;
 191         struct sta *sta;
 192
 193         if (!addr)
 194                 return;
 195
 196         /* Don't create the STA */
 197         sta = usteer_sta_get(addr, false);
 198         if (!sta)
 199                 return;
 200
 201         blobmsg_parse(&rrm_policy, 1, &sta_blob, blobmsg_data(client_attr), blobmsg_data_len(client_attr));
 202         if (!sta_blob)
 203                 return;
 204
 205         sta->rrm = blobmsg_get_u32(blobmsg_data(sta_blob));
 206 }
 207
 208 static void
 209 usteer_local_node_set_assoc(struct usteer_local_node *ln, struct blob_attr *cl)
 210 {
 211         struct usteer_node *node = &ln->node;
 212         struct usteer_node_handler *h;
 213         struct blob_attr *cur;
 214         struct sta_info *si;
 215         struct sta *sta;
 216         int n_assoc = 0;
 217         int rem;
 218
 219         usteer_update_time();
 220
 221         list_for_each_entry(si, &node->sta_info, node_list) {
 222                 if (si->connected)
 223                         si->connected = STA_DISCONNECTED;
 224         }
 225
 226         blobmsg_for_each_attr(cur, cl, rem) {
 227                 uint8_t *addr = (uint8_t *) ether_aton(blobmsg_name(cur));
 228                 bool create;
 229
 230                 if (!addr)
 231                         continue;
 232
 233                 sta = usteer_sta_get(addr, true);
 234                 si = usteer_sta_info_get(sta, node, &create);
 235                 list_for_each_entry(h, &node_handlers, list) {
 236                         if (!h->update_sta)
 237                                 continue;
 238
 239                         h->update_sta(node, si);
 240                 }
 241                 usteer_local_node_assoc_update(si, cur);
 242                 if (si->connected == STA_CONNECTED) {
 243                         si->last_connected = current_time;
 244                         n_assoc++;
 245                 }
 246
 247                 /* Read RRM information */
 248                 usteer_local_node_update_sta_rrm(addr, cur);
 249         }
 250
 251         node->n_assoc = n_assoc;
 252
 253         list_for_each_entry(si, &node->sta_info, node_list) {
 254                 if (si->connected != STA_DISCONNECTED)
 255                         continue;
 256
 257                 si->connected = STA_NOT_CONNECTED;
 258                 usteer_sta_info_update_timeout(si, config.local_sta_timeout);
 259                 MSG(VERBOSE, "station "MAC_ADDR_FMT" disconnected from node %s\n",
 260                         MAC_ADDR_DATA(si->sta->addr), usteer_node_name(node));
 261         }
 262 }
 263
 264 static void
 265 usteer_local_node_list_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 266 {
 267         enum {
 268                 MSG_FREQ,
 269                 MSG_CLIENTS,
 270                 __MSG_MAX,
 271         };
 272         static struct blobmsg_policy policy[__MSG_MAX] = {
 273                 [MSG_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 274                 [MSG_CLIENTS] = { "clients", BLOBMSG_TYPE_TABLE },
 275         };
 276         struct blob_attr *tb[__MSG_MAX];
 277         struct usteer_local_node *ln;
 278         struct usteer_node *node;
 279
 280         ln = container_of(req, struct usteer_local_node, req);
 281         node = &ln->node;
 282
 283         blobmsg_parse(policy, __MSG_MAX, tb, blob_data(msg), blob_len(msg));
 284         if (!tb[MSG_FREQ] || !tb[MSG_CLIENTS])
 285                 return;
 286
 287         node->freq = blobmsg_get_u32(tb[MSG_FREQ]);
 288         usteer_local_node_set_assoc(ln, tb[MSG_CLIENTS]);
 289 }
 290
 291 static void
 292 usteer_local_node_rrm_nr_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 293 {
 294         static const struct blobmsg_policy policy = {
 295                 "value", BLOBMSG_TYPE_ARRAY
 296         };
 297         struct usteer_local_node *ln;
 298         struct blob_attr *tb;
 299
 300         ln = container_of(req, struct usteer_local_node, req);
 301
 302         blobmsg_parse(&policy, 1, &tb, blob_data(msg), blob_len(msg));
 303         if (!tb)
 304                 return;
 305
 306         usteer_node_set_blob(&ln->node.rrm_nr, tb);
 307 }
 308
 309 static void
 310 usteer_local_node_req_cb(struct ubus_request *req, int ret)
 311 {
 312         struct usteer_local_node *ln;
 313
 314         ln = container_of(req, struct usteer_local_node, req);
 315         uloop_timeout_set(&ln->req_timer, 1);
 316 }
 317
 318 static bool
 319 usteer_add_rrm_data(struct usteer_local_node *ln, struct usteer_node *node)
 320 {
 321         if (node == &ln->node)
 322                 return false;
 323
 324         if (!node->rrm_nr)
 325                 return false;
 326
 327         /* Remote node only adds same SSID. Required for local-node. */
 328         if (strcmp(ln->node.ssid, node->ssid) != 0)
 329                 return false;
 330
 331         blobmsg_add_field(&b, BLOBMSG_TYPE_ARRAY, "",
 332                           blobmsg_data(node->rrm_nr),
 333                           blobmsg_data_len(node->rrm_nr));
 334
 335         return true;
 336 }
 337
 338 static void
 339 usteer_local_node_prepare_rrm_set(struct usteer_local_node *ln)
 340 {
 341         struct usteer_node *node, *last_remote_neighbor = NULL;
 342         int i = 0;
 343         void *c;
 344
 345         c = blobmsg_open_array(&b, "list");
 346         for_each_local_node(node) {
 347                 if (i >= config.max_neighbor_reports)
 348                         break;
 349                 if (usteer_add_rrm_data(ln, node))
 350                         i++;
 351         }
 352
 353         while (i < config.max_neighbor_reports) {
 354                 node = usteer_node_get_next_neighbor(&ln->node, last_remote_neighbor);
 355                 if (!node) {
 356                         /* No more nodes available */
 357                         break;
 358                 }
 359
 360                 last_remote_neighbor = node;
 361                 if (usteer_add_rrm_data(ln, node))
 362                         i++;
 363         }
 364
 365         blobmsg_close_array(&b, c);
 366 }
 367
 368 static void
 369 usteer_local_node_state_next(struct uloop_timeout *timeout)
 370 {
 371         struct usteer_local_node *ln;
 372
 373         ln = container_of(timeout, struct usteer_local_node, req_timer);
 374
 375         ln->req_state++;
 376         if (ln->req_state >= __REQ_MAX) {
 377                 ln->req_state = REQ_IDLE;
 378                 return;
 379         }
 380
 381         blob_buf_init(&b, 0);
 382         switch (ln->req_state) {
 383         case REQ_CLIENTS:
 384                 ubus_invoke_async(ubus_ctx, ln->obj_id, "get_clients", b.head, &ln->req);
 385                 ln->req.data_cb = usteer_local_node_list_cb;
 386                 break;
 387         case REQ_RRM_SET_LIST:
 388                 usteer_local_node_prepare_rrm_set(ln);
 389                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_set", b.head, &ln->req);
 390                 ln->req.data_cb = NULL;
 391                 break;
 392         case REQ_RRM_GET_OWN:
 393                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_get_own", b.head, &ln->req);
 394                 ln->req.data_cb = usteer_local_node_rrm_nr_cb;
 395                 break;
 396         default:
 397                 break;
 398         }
 399         ln->req.complete_cb = usteer_local_node_req_cb;
 400         ubus_complete_request_async(ubus_ctx, &ln->req);
 401 }
 402
 403 static void
 404 usteer_local_node_update(struct uloop_timeout *timeout)
 405 {
 406         struct usteer_local_node *ln;
 407         struct usteer_node_handler *h;
 408         struct usteer_node *node;
 409
 410         ln = container_of(timeout, struct usteer_local_node, update);
 411         node = &ln->node;
 412
 413         list_for_each_entry(h, &node_handlers, list) {
 414                 if (!h->update_node)
 415                         continue;
 416
 417                 h->update_node(node);
 418         }
 419
 420         usteer_local_node_state_reset(ln);
 421         uloop_timeout_set(&ln->req_timer, 1);
 422         usteer_local_node_kick(ln);
 423         uloop_timeout_set(timeout, config.local_sta_update);
 424 }
 425
 426 static struct usteer_local_node *
 427 usteer_get_node(struct ubus_context *ctx, const char *name)
 428 {
 429         struct usteer_local_node *ln;
 430         struct usteer_node *node;
 431         char *str;
 432
 433         ln = avl_find_element(&local_nodes, name, ln, node.avl);
 434         if (ln)
 435                 return ln;
 436
 437         ln = calloc_a(sizeof(*ln), &str, strlen(name) + 1);
 438         node = &ln->node;
 439         node->type = NODE_TYPE_LOCAL;
 440         node->created = current_time;
 441         node->avl.key = strcpy(str, name);
 442         ln->ev.remove_cb = usteer_handle_remove;
 443         ln->ev.cb = usteer_handle_event;
 444         ln->update.cb = usteer_local_node_update;
 445         ln->req_timer.cb = usteer_local_node_state_next;
 446         ubus_register_subscriber(ctx, &ln->ev);
 447         avl_insert(&local_nodes, &node->avl);
 448         kvlist_init(&ln->node_info, kvlist_blob_len);
 449         INIT_LIST_HEAD(&node->sta_info);
 450
 451         return ln;
 452 }
 453
 454 static void
 455 usteer_node_run_update_script(struct usteer_node *node)
 456 {
 457         struct usteer_local_node *ln = container_of(node, struct usteer_local_node, node);
 458         char *val;
 459
 460         if (!node_up_script)
 461                 return;
 462
 463         val = alloca(strlen(node_up_script) + strlen(ln->iface) + 8);
 464         sprintf(val, "%s '%s'", node_up_script, ln->iface);
 465         if (system(val))
 466                 MSG(INFO, "failed to execute %s\n", val);
 467 }
 468
 469 static void
 470 usteer_check_node_enabled(struct usteer_local_node *ln)
 471 {
 472         bool ssid_disabled = config.ssid_list;
 473         struct blob_attr *cur;
 474         int rem;
 475
 476         blobmsg_for_each_attr(cur, config.ssid_list, rem) {
 477                 if (strcmp(blobmsg_get_string(cur), ln->node.ssid) != 0)
 478                         continue;
 479
 480                 ssid_disabled = false;
 481                 break;
 482         }
 483
 484         if (ln->node.disabled == ssid_disabled)
 485                 return;
 486
 487         ln->node.disabled = ssid_disabled;
 488
 489         if (ssid_disabled) {
 490                 MSG(INFO, "Disconnecting from local node %s\n", usteer_node_name(&ln->node));
 491                 usteer_local_node_state_reset(ln);
 492                 usteer_sta_node_cleanup(&ln->node);
 493                 uloop_timeout_cancel(&ln->update);
 494                 ubus_unsubscribe(ubus_ctx, &ln->ev, ln->obj_id);
 495                 return;
 496         }
 497
 498         MSG(INFO, "Connecting to local node %s\n", usteer_node_name(&ln->node));
 499         ubus_subscribe(ubus_ctx, &ln->ev, ln->obj_id);
 500         uloop_timeout_set(&ln->update, 1);
 501         usteer_node_run_update_script(&ln->node);
 502 }
 503
 504 static void
 505 usteer_register_node(struct ubus_context *ctx, const char *name, uint32_t id)
 506 {
 507         struct usteer_local_node *ln;
 508         struct usteer_node_handler *h;
 509         const char *iface;
 510         int offset = sizeof("hostapd.") - 1;
 511
 512         iface = name + offset;
 513         if (strncmp(name, "hostapd.", iface - name) != 0)
 514                 return;
 515
 516         MSG(INFO, "Creating local node %s\n", name);
 517         ln = usteer_get_node(ctx, name);
 518         ln->obj_id = id;
 519         ln->iface = usteer_node_name(&ln->node) + offset;
 520         ln->ifindex = if_nametoindex(ln->iface);
 521
 522         blob_buf_init(&b, 0);
 523         blobmsg_add_u32(&b, "notify_response", 1);
 524         ubus_invoke(ctx, id, "notify_response", b.head, NULL, NULL, 1000);
 525
 526         blob_buf_init(&b, 0);
 527         blobmsg_add_u8(&b, "neighbor_report", 1);
 528         blobmsg_add_u8(&b, "beacon_report", 1);
 529         blobmsg_add_u8(&b, "bss_transition", 1);
 530         ubus_invoke(ctx, id, "bss_mgmt_enable", b.head, NULL, NULL, 1000);
 531
 532         list_for_each_entry(h, &node_handlers, list) {
 533                 if (!h->init_node)
 534                         continue;
 535
 536                 h->init_node(&ln->node);
 537         }
 538
 539         ln->node.disabled = true;
 540         usteer_check_node_enabled(ln);
 541 }
 542
 543 static void
 544 usteer_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev,
 545                     const char *type, struct blob_attr *msg)
 546 {
 547         static const struct blobmsg_policy policy[2] = {
 548                 { .name = "id", .type = BLOBMSG_TYPE_INT32 },
 549                 { .name = "path", .type = BLOBMSG_TYPE_STRING },
 550         };
 551         struct blob_attr *tb[2];
 552         const char *path;
 553
 554         blobmsg_parse(policy, 2, tb, blob_data(msg), blob_len(msg));
 555
 556         if (!tb[0] || !tb[1])
 557                 return;
 558
 559         path = blobmsg_data(tb[1]);
 560         usteer_register_node(ctx, path, blobmsg_get_u32(tb[0]));
 561 }
 562
 563 static void
 564 usteer_register_events(struct ubus_context *ctx)
 565 {
 566         static struct ubus_event_handler handler = {
 567             .cb = usteer_event_handler
 568         };
 569
 570         ubus_register_event_handler(ctx, &handler, "ubus.object.add");
 571 }
 572
 573 static void
 574 node_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
 575 {
 576         usteer_register_node(ctx, obj->path, obj->id);
 577 }
 578
 579 void config_set_node_up_script(struct blob_attr *data)
 580 {
 581         const char *val;
 582         struct usteer_node *node;
 583
 584         if (!data)
 585                 return;
 586
 587         val = blobmsg_get_string(data);
 588         if (node_up_script && !strcmp(val, node_up_script))
 589                 return;
 590
 591         free(node_up_script);
 592
 593         if (!strlen(val)) {
 594                 node_up_script = NULL;
 595                 return;
 596         }
 597
 598         node_up_script = strdup(val);
 599
 600         for_each_local_node(node)
 601                 usteer_node_run_update_script(node);
 602 }
 603
 604 void config_get_node_up_script(struct blob_buf *buf)
 605 {
 606         if (!node_up_script)
 607                 return;
 608
 609         blobmsg_add_string(buf, "node_up_script", node_up_script);
 610 }
 611
 612 void config_set_ssid_list(struct blob_attr *data)
 613 {
 614         struct usteer_local_node *ln;
 615
 616         free(config.ssid_list);
 617
 618         if (data && blobmsg_len(data))
 619                 config.ssid_list = blob_memdup(data);
 620         else
 621                 config.ssid_list = NULL;
 622
 623         avl_for_each_element(&local_nodes, ln, node.avl)
 624                 usteer_check_node_enabled(ln);
 625 }
 626
 627 void config_get_ssid_list(struct blob_buf *buf)
 628 {
 629         if (config.ssid_list)
 630                 blobmsg_add_blob(buf, config.ssid_list);
 631 }
 632
 633 void
 634 usteer_local_nodes_init(struct ubus_context *ctx)
 635 {
 636         usteer_register_events(ctx);
 637         ubus_lookup(ctx, "hostapd.*", node_list_cb, NULL);
 638 }