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_local_node_pending_bss_tm_free(struct usteer_local_node *ln)
  51 {
  52         struct usteer_bss_tm_query *query, *tmp;
  53
  54         list_for_each_entry_safe(query, tmp, &ln->bss_tm_queries, list) {
  55                 list_del(&query->list);
  56                 free(query);
  57         }
  58 }
  59
  60 static void
  61 usteer_free_node(struct ubus_context *ctx, struct usteer_local_node *ln)
  62 {
  63         struct usteer_node_handler *h;
  64
  65         list_for_each_entry(h, &node_handlers, list) {
  66                 if (!h->free_node)
  67                         continue;
  68                 h->free_node(&ln->node);
  69         }
  70
  71         usteer_local_node_pending_bss_tm_free(ln);
  72         usteer_local_node_state_reset(ln);
  73         usteer_sta_node_cleanup(&ln->node);
  74         usteer_measurement_report_node_cleanup(&ln->node);
  75         uloop_timeout_cancel(&ln->update);
  76         uloop_timeout_cancel(&ln->bss_tm_queries_timeout);
  77         avl_delete(&local_nodes, &ln->node.avl);
  78         ubus_unregister_subscriber(ctx, &ln->ev);
  79         kvlist_free(&ln->node_info);
  80         free(ln);
  81 }
  82
  83 struct usteer_local_node *usteer_local_node_by_bssid(uint8_t *bssid) {
  84         struct usteer_local_node *ln;
  85         struct usteer_node *n;
  86
  87         for_each_local_node(n) {
  88                 ln = container_of(n, struct usteer_local_node, node);
  89                 if (!memcmp(n->bssid, bssid, 6))
  90                         return ln;
  91         }
  92
  93         return NULL;
  94 }
  95
  96 static void
  97 usteer_handle_remove(struct ubus_context *ctx, struct ubus_subscriber *s,
  98                     uint32_t id)
  99 {
 100         struct usteer_local_node *ln = container_of(s, struct usteer_local_node, ev);
 101
 102         usteer_free_node(ctx, ln);
 103 }
 104
 105 static int
 106 usteer_handle_bss_tm_query(struct usteer_local_node *ln, struct blob_attr *msg)
 107 {
 108         enum {
 109                 BSS_TM_QUERY_ADDRESS,
 110                 BSS_TM_QUERY_DIALOG_TOKEN,
 111                 BSS_TM_QUERY_CANDIDATE_LIST,
 112                 __BSS_TM_QUERY_MAX
 113         };
 114         struct blobmsg_policy policy[__BSS_TM_QUERY_MAX] = {
 115                 [BSS_TM_QUERY_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 116                 [BSS_TM_QUERY_DIALOG_TOKEN] = { .name = "dialog-token", .type = BLOBMSG_TYPE_INT8 },
 117                 [BSS_TM_QUERY_CANDIDATE_LIST] = { .name = "candidate-list", .type = BLOBMSG_TYPE_STRING },
 118         };
 119         struct blob_attr *tb[__BSS_TM_QUERY_MAX];
 120         struct usteer_bss_tm_query *query;
 121         uint8_t *sta_addr;
 122
 123         blobmsg_parse(policy, __BSS_TM_QUERY_MAX, tb, blob_data(msg), blob_len(msg));
 124
 125         if (!tb[BSS_TM_QUERY_ADDRESS] || !tb[BSS_TM_QUERY_DIALOG_TOKEN])
 126                 return 0;
 127
 128         query = calloc(1, sizeof(*query));
 129         if (!query)
 130                 return 0;
 131
 132         query->dialog_token = blobmsg_get_u8(tb[BSS_TM_QUERY_DIALOG_TOKEN]);
 133
 134         sta_addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BSS_TM_QUERY_ADDRESS]));
 135         if (!sta_addr)
 136                 return 0;
 137
 138         memcpy(query->sta_addr, sta_addr, 6);
 139
 140         list_add(&query->list, &ln->bss_tm_queries);
 141         uloop_timeout_set(&ln->bss_tm_queries_timeout, 1);
 142
 143         return 1;
 144 }
 145
 146 static int
 147 usteer_handle_bss_tm_response(struct usteer_local_node *ln, struct blob_attr *msg)
 148 {
 149         enum {
 150                 BSS_TM_RESPONSE_ADDRESS,
 151                 BSS_TM_RESPONSE_STATUS_CODE,
 152                 __BSS_TM_RESPONSE_MAX
 153         };
 154         struct blobmsg_policy policy[__BSS_TM_RESPONSE_MAX] = {
 155                 [BSS_TM_RESPONSE_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 156                 [BSS_TM_RESPONSE_STATUS_CODE] = { .name = "status-code", .type = BLOBMSG_TYPE_INT8 },
 157         };
 158         struct blob_attr *tb[__BSS_TM_RESPONSE_MAX];
 159         struct sta_info *si;
 160         struct sta *sta;
 161         uint8_t *sta_addr;
 162
 163         blobmsg_parse(policy, __BSS_TM_RESPONSE_MAX, tb, blob_data(msg), blob_len(msg));
 164
 165         if (!tb[BSS_TM_RESPONSE_ADDRESS] || !tb[BSS_TM_RESPONSE_STATUS_CODE])
 166                 return 0;
 167
 168         sta_addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BSS_TM_RESPONSE_ADDRESS]));
 169         if (!sta_addr)
 170                 return 0;
 171
 172         sta = usteer_sta_get(sta_addr, false);
 173         if (!sta)
 174                 return 0;
 175
 176         si = usteer_sta_info_get(sta, &ln->node, false);
 177         if (!si)
 178                 return 0;
 179
 180         si->bss_transition_response.status_code = blobmsg_get_u8(tb[BSS_TM_RESPONSE_STATUS_CODE]);
 181         si->bss_transition_response.timestamp = current_time;
 182
 183         return 0;
 184 }
 185
 186 static int
 187 usteer_local_node_handle_beacon_report(struct usteer_local_node *ln, struct blob_attr *msg)
 188 {
 189         enum {
 190                 BR_ADDRESS,
 191                 BR_BSSID,
 192                 BR_RCPI,
 193                 BR_RSNI,
 194                 __BR_MAX
 195         };
 196         struct blobmsg_policy policy[__BR_MAX] = {
 197                 [BR_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 198                 [BR_BSSID] = { .name = "bssid", .type = BLOBMSG_TYPE_STRING },
 199                 [BR_RCPI] = { .name = "rcpi", .type = BLOBMSG_TYPE_INT16 },
 200                 [BR_RSNI] = { .name = "rsni", .type = BLOBMSG_TYPE_INT16 },
 201         };
 202         struct blob_attr *tb[__BR_MAX];
 203
 204         struct usteer_beacon_report br;
 205         struct usteer_node *node;
 206         uint8_t *addr;
 207         struct sta *sta;
 208
 209         blobmsg_parse(policy, __BR_MAX, tb, blob_data(msg), blob_len(msg));
 210         if (!tb[BR_ADDRESS] || !tb[BR_BSSID] || !tb[BR_RCPI] || !tb[BR_RSNI])
 211                 return 0;
 212
 213         addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BR_ADDRESS]));
 214         if (!addr)
 215                 return 0;
 216
 217         sta = usteer_sta_get(addr, false);
 218         if (!sta)
 219                 return 0;
 220
 221         addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BR_BSSID]));
 222         if (!addr)
 223                 return 0;
 224
 225         node = usteer_node_by_bssid(addr);
 226         if (!node)
 227                 return 0;
 228
 229         br.rcpi = (uint8_t)blobmsg_get_u16(tb[BR_RCPI]);
 230         br.rsni = (uint8_t)blobmsg_get_u16(tb[BR_RSNI]);
 231
 232         usteer_measurement_report_add_beacon_report(sta, node, &br, current_time);
 233         return 0;
 234 }
 235
 236 static int
 237 usteer_handle_event(struct ubus_context *ctx, struct ubus_object *obj,
 238                    struct ubus_request_data *req, const char *method,
 239                    struct blob_attr *msg)
 240 {
 241         enum {
 242                 EVENT_ADDR,
 243                 EVENT_SIGNAL,
 244                 EVENT_TARGET,
 245                 EVENT_FREQ,
 246                 __EVENT_MAX
 247         };
 248         struct blobmsg_policy policy[__EVENT_MAX] = {
 249                 [EVENT_ADDR] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 250                 [EVENT_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 },
 251                 [EVENT_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
 252                 [EVENT_FREQ] = { .name = "freq", .type = BLOBMSG_TYPE_INT32 },
 253         };
 254         enum usteer_event_type ev_type = __EVENT_TYPE_MAX;
 255         struct blob_attr *tb[__EVENT_MAX];
 256         struct usteer_local_node *ln;
 257         struct usteer_node *node;
 258         int signal = NO_SIGNAL;
 259         int freq = 0;
 260         const char *addr_str;
 261         const uint8_t *addr;
 262         int i;
 263         bool ret;
 264
 265         usteer_update_time();
 266
 267         ln = container_of(obj, struct usteer_local_node, ev.obj);
 268
 269         if(!strcmp(method, "bss-transition-query")) {
 270                 return usteer_handle_bss_tm_query(ln, msg);
 271         } else if(!strcmp(method, "bss-transition-response")) {
 272                 return usteer_handle_bss_tm_response(ln, msg);
 273         } else if(!strcmp(method, "beacon-report")) {
 274                 return usteer_local_node_handle_beacon_report(ln, msg);
 275         }
 276
 277         for (i = 0; i < ARRAY_SIZE(event_types); i++) {
 278                 if (strcmp(method, event_types[i]) != 0)
 279                         continue;
 280
 281                 ev_type = i;
 282                 break;
 283         }
 284
 285         ln = container_of(obj, struct usteer_local_node, ev.obj);
 286         node = &ln->node;
 287         blobmsg_parse(policy, __EVENT_MAX, tb, blob_data(msg), blob_len(msg));
 288         if (!tb[EVENT_ADDR] || !tb[EVENT_FREQ])
 289                 return UBUS_STATUS_INVALID_ARGUMENT;
 290
 291         if (tb[EVENT_SIGNAL])
 292                 signal = (int32_t) blobmsg_get_u32(tb[EVENT_SIGNAL]);
 293
 294         if (tb[EVENT_FREQ])
 295                 freq = blobmsg_get_u32(tb[EVENT_FREQ]);
 296
 297         addr_str = blobmsg_data(tb[EVENT_ADDR]);
 298         addr = (uint8_t *) ether_aton(addr_str);
 299         if (!addr)
 300                 return UBUS_STATUS_INVALID_ARGUMENT;
 301
 302         ret = usteer_handle_sta_event(node, addr, ev_type, freq, signal);
 303
 304         MSG(DEBUG, "received %s event from %s, signal=%d, freq=%d, handled:%s\n",
 305             method, addr_str, signal, freq, ret ? "true" : "false");
 306
 307         return ret ? 0 : 17 /* WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA */;
 308 }
 309
 310 static void
 311 usteer_local_node_assoc_update(struct sta_info *si, struct blob_attr *data)
 312 {
 313         enum {
 314                 MSG_ASSOC,
 315                 __MSG_MAX,
 316         };
 317         static struct blobmsg_policy policy[__MSG_MAX] = {
 318                 [MSG_ASSOC] = { "assoc", BLOBMSG_TYPE_BOOL },
 319         };
 320         struct blob_attr *tb[__MSG_MAX];
 321         struct usteer_remote_node *rn;
 322         struct sta_info *remote_si;
 323
 324         blobmsg_parse(policy, __MSG_MAX, tb, blobmsg_data(data), blobmsg_data_len(data));
 325         if (tb[MSG_ASSOC] && blobmsg_get_u8(tb[MSG_ASSOC])) {
 326                 if (si->connected == STA_NOT_CONNECTED) {
 327                         /* New connection. Check if STA roamed. */
 328                         for_each_remote_node(rn) {
 329                                 remote_si = usteer_sta_info_get(si->sta, &rn->node, NULL);
 330                                 if (!remote_si)
 331                                         continue;
 332
 333                                 if (current_time - remote_si->last_connected < config.roam_process_timeout) {
 334                                         rn->node.roam_events.source++;
 335                                         /* Don't abort looking for roam sources here.
 336                                          * The client might have roamed via another node
 337                                          * within the roam-timeout.
 338                                          */
 339                                 }
 340                         }
 341                 }
 342                 si->connected = STA_CONNECTED;
 343         }
 344 }
 345
 346 static void
 347 usteer_local_node_update_sta_rrm(const uint8_t *addr, struct blob_attr *client_attr)
 348 {
 349         static const struct blobmsg_policy rrm_policy = {
 350                 .name = "rrm",
 351                 .type = BLOBMSG_TYPE_ARRAY,
 352         };
 353         struct blob_attr *sta_blob = NULL;
 354         struct sta *sta;
 355
 356         if (!addr)
 357                 return;
 358
 359         /* Don't create the STA */
 360         sta = usteer_sta_get(addr, false);
 361         if (!sta)
 362                 return;
 363
 364         blobmsg_parse(&rrm_policy, 1, &sta_blob, blobmsg_data(client_attr), blobmsg_data_len(client_attr));
 365         if (!sta_blob)
 366                 return;
 367
 368         sta->rrm = blobmsg_get_u32(blobmsg_data(sta_blob));
 369 }
 370
 371 static void
 372 usteer_local_node_set_assoc(struct usteer_local_node *ln, struct blob_attr *cl)
 373 {
 374         struct usteer_node *node = &ln->node;
 375         struct usteer_node_handler *h;
 376         struct blob_attr *cur;
 377         struct sta_info *si;
 378         struct sta *sta;
 379         int n_assoc = 0;
 380         int rem;
 381
 382         usteer_update_time();
 383
 384         list_for_each_entry(si, &node->sta_info, node_list) {
 385                 if (si->connected)
 386                         si->connected = STA_DISCONNECTED;
 387         }
 388
 389         blobmsg_for_each_attr(cur, cl, rem) {
 390                 uint8_t *addr = (uint8_t *) ether_aton(blobmsg_name(cur));
 391                 bool create;
 392
 393                 if (!addr)
 394                         continue;
 395
 396                 sta = usteer_sta_get(addr, true);
 397                 si = usteer_sta_info_get(sta, node, &create);
 398                 list_for_each_entry(h, &node_handlers, list) {
 399                         if (!h->update_sta)
 400                                 continue;
 401
 402                         h->update_sta(node, si);
 403                 }
 404                 usteer_local_node_assoc_update(si, cur);
 405                 if (si->connected == STA_CONNECTED) {
 406                         si->last_connected = current_time;
 407                         n_assoc++;
 408                 }
 409
 410                 /* Read RRM information */
 411                 usteer_local_node_update_sta_rrm(addr, cur);
 412         }
 413
 414         node->n_assoc = n_assoc;
 415
 416         list_for_each_entry(si, &node->sta_info, node_list) {
 417                 if (si->connected != STA_DISCONNECTED)
 418                         continue;
 419
 420                 usteer_sta_disconnected(si);
 421                 MSG(VERBOSE, "station "MAC_ADDR_FMT" disconnected from node %s\n",
 422                         MAC_ADDR_DATA(si->sta->addr), usteer_node_name(node));
 423         }
 424 }
 425
 426 static void
 427 usteer_local_node_list_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 428 {
 429         enum {
 430                 MSG_FREQ,
 431                 MSG_CLIENTS,
 432                 __MSG_MAX,
 433         };
 434         static struct blobmsg_policy policy[__MSG_MAX] = {
 435                 [MSG_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 436                 [MSG_CLIENTS] = { "clients", BLOBMSG_TYPE_TABLE },
 437         };
 438         struct blob_attr *tb[__MSG_MAX];
 439         struct usteer_local_node *ln;
 440         struct usteer_node *node;
 441
 442         ln = container_of(req, struct usteer_local_node, req);
 443         node = &ln->node;
 444
 445         blobmsg_parse(policy, __MSG_MAX, tb, blob_data(msg), blob_len(msg));
 446         if (!tb[MSG_FREQ] || !tb[MSG_CLIENTS])
 447                 return;
 448
 449         node->freq = blobmsg_get_u32(tb[MSG_FREQ]);
 450         usteer_local_node_set_assoc(ln, tb[MSG_CLIENTS]);
 451 }
 452
 453 static void
 454 usteer_local_node_status_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 455 {
 456         enum {
 457                 MSG_FREQ,
 458                 MSG_CHANNEL,
 459                 MSG_OP_CLASS,
 460                 __MSG_MAX,
 461         };
 462         static struct blobmsg_policy policy[__MSG_MAX] = {
 463                 [MSG_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 464                 [MSG_CHANNEL] = { "channel", BLOBMSG_TYPE_INT32 },
 465                 [MSG_OP_CLASS] = { "op_class", BLOBMSG_TYPE_INT32 },
 466         };
 467         struct blob_attr *tb[__MSG_MAX];
 468         struct usteer_local_node *ln;
 469         struct usteer_node *node;
 470
 471         ln = container_of(req, struct usteer_local_node, req);
 472         node = &ln->node;
 473
 474         blobmsg_parse(policy, __MSG_MAX, tb, blob_data(msg), blob_len(msg));
 475         if (tb[MSG_FREQ])
 476                 node->freq = blobmsg_get_u32(tb[MSG_FREQ]);
 477         if (tb[MSG_CHANNEL])
 478                 node->channel = blobmsg_get_u32(tb[MSG_CHANNEL]);
 479         if (tb[MSG_OP_CLASS])
 480                 node->op_class = blobmsg_get_u32(tb[MSG_OP_CLASS]);
 481 }
 482
 483 static void
 484 usteer_local_node_rrm_nr_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 485 {
 486         static const struct blobmsg_policy policy = {
 487                 "value", BLOBMSG_TYPE_ARRAY
 488         };
 489         struct usteer_local_node *ln;
 490         struct blob_attr *tb;
 491
 492         ln = container_of(req, struct usteer_local_node, req);
 493
 494         blobmsg_parse(&policy, 1, &tb, blob_data(msg), blob_len(msg));
 495         if (!tb)
 496                 return;
 497
 498         usteer_node_set_blob(&ln->node.rrm_nr, tb);
 499 }
 500
 501 static void
 502 usteer_local_node_req_cb(struct ubus_request *req, int ret)
 503 {
 504         struct usteer_local_node *ln;
 505
 506         ln = container_of(req, struct usteer_local_node, req);
 507         uloop_timeout_set(&ln->req_timer, 1);
 508 }
 509
 510 static bool
 511 usteer_add_rrm_data(struct usteer_local_node *ln, struct usteer_node *node)
 512 {
 513         if (node == &ln->node)
 514                 return false;
 515
 516         if (!node->rrm_nr)
 517                 return false;
 518
 519         /* Remote node only adds same SSID. Required for local-node. */
 520         if (strcmp(ln->node.ssid, node->ssid) != 0)
 521                 return false;
 522
 523         blobmsg_add_field(&b, BLOBMSG_TYPE_ARRAY, "",
 524                           blobmsg_data(node->rrm_nr),
 525                           blobmsg_data_len(node->rrm_nr));
 526
 527         return true;
 528 }
 529
 530 static void
 531 usteer_local_node_prepare_rrm_set(struct usteer_local_node *ln)
 532 {
 533         struct usteer_node *node, *last_remote_neighbor = NULL;
 534         int i = 0;
 535         void *c;
 536
 537         c = blobmsg_open_array(&b, "list");
 538         for_each_local_node(node) {
 539                 if (i >= config.max_neighbor_reports)
 540                         break;
 541                 if (usteer_add_rrm_data(ln, node))
 542                         i++;
 543         }
 544
 545         while (i < config.max_neighbor_reports) {
 546                 node = usteer_node_get_next_neighbor(&ln->node, last_remote_neighbor);
 547                 if (!node) {
 548                         /* No more nodes available */
 549                         break;
 550                 }
 551
 552                 last_remote_neighbor = node;
 553                 if (usteer_add_rrm_data(ln, node))
 554                         i++;
 555         }
 556
 557         blobmsg_close_array(&b, c);
 558 }
 559
 560 static void
 561 usteer_local_node_state_next(struct uloop_timeout *timeout)
 562 {
 563         struct usteer_local_node *ln;
 564
 565         ln = container_of(timeout, struct usteer_local_node, req_timer);
 566
 567         ln->req_state++;
 568         if (ln->req_state >= __REQ_MAX) {
 569                 ln->req_state = REQ_IDLE;
 570                 return;
 571         }
 572
 573         blob_buf_init(&b, 0);
 574         switch (ln->req_state) {
 575         case REQ_CLIENTS:
 576                 ubus_invoke_async(ubus_ctx, ln->obj_id, "get_clients", b.head, &ln->req);
 577                 ln->req.data_cb = usteer_local_node_list_cb;
 578                 break;
 579         case REQ_STATUS:
 580                 ubus_invoke_async(ubus_ctx, ln->obj_id, "get_status", b.head, &ln->req);
 581                 ln->req.data_cb = usteer_local_node_status_cb;
 582                 break;
 583         case REQ_RRM_SET_LIST:
 584                 usteer_local_node_prepare_rrm_set(ln);
 585                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_set", b.head, &ln->req);
 586                 ln->req.data_cb = NULL;
 587                 break;
 588         case REQ_RRM_GET_OWN:
 589                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_get_own", b.head, &ln->req);
 590                 ln->req.data_cb = usteer_local_node_rrm_nr_cb;
 591                 break;
 592         default:
 593                 break;
 594         }
 595         ln->req.complete_cb = usteer_local_node_req_cb;
 596         ubus_complete_request_async(ubus_ctx, &ln->req);
 597 }
 598
 599 static void
 600 usteer_local_node_update(struct uloop_timeout *timeout)
 601 {
 602         struct usteer_local_node *ln;
 603         struct usteer_node_handler *h;
 604         struct usteer_node *node;
 605
 606         ln = container_of(timeout, struct usteer_local_node, update);
 607         node = &ln->node;
 608
 609         list_for_each_entry(h, &node_handlers, list) {
 610                 if (!h->update_node)
 611                         continue;
 612
 613                 h->update_node(node);
 614         }
 615
 616         usteer_local_node_state_reset(ln);
 617         uloop_timeout_set(&ln->req_timer, 1);
 618         usteer_local_node_kick(ln);
 619         uloop_timeout_set(timeout, config.local_sta_update);
 620 }
 621
 622 static void
 623 usteer_local_node_process_bss_tm_queries(struct uloop_timeout *timeout)
 624 {
 625         struct usteer_bss_tm_query *query, *tmp;
 626         struct usteer_local_node *ln;
 627         struct usteer_node *node;
 628         struct sta_info *si;
 629         struct sta *sta;
 630
 631         uint8_t validity_period = 100; /* ~ 10 seconds */
 632
 633         ln = container_of(timeout, struct usteer_local_node, bss_tm_queries_timeout);
 634         node = &ln->node;
 635
 636         list_for_each_entry_safe(query, tmp, &ln->bss_tm_queries, list) {
 637                 sta = usteer_sta_get(query->sta_addr, false);
 638                 if (!sta)
 639                         continue;
 640
 641                 si = usteer_sta_info_get(sta, node, false);
 642                 if (!si)
 643                         continue;
 644
 645                 usteer_ubus_bss_transition_request(si, query->dialog_token, false, false, validity_period);
 646         }
 647
 648         /* Free pending queries we can not handle */
 649         usteer_local_node_pending_bss_tm_free(ln);
 650 }
 651
 652 static struct usteer_local_node *
 653 usteer_get_node(struct ubus_context *ctx, const char *name)
 654 {
 655         struct usteer_local_node *ln;
 656         struct usteer_node *node;
 657         char *str;
 658
 659         ln = avl_find_element(&local_nodes, name, ln, node.avl);
 660         if (ln)
 661                 return ln;
 662
 663         ln = calloc_a(sizeof(*ln), &str, strlen(name) + 1);
 664         node = &ln->node;
 665         node->type = NODE_TYPE_LOCAL;
 666         node->created = current_time;
 667         node->avl.key = strcpy(str, name);
 668         ln->ev.remove_cb = usteer_handle_remove;
 669         ln->ev.cb = usteer_handle_event;
 670         ln->update.cb = usteer_local_node_update;
 671         ln->req_timer.cb = usteer_local_node_state_next;
 672         ubus_register_subscriber(ctx, &ln->ev);
 673         avl_insert(&local_nodes, &node->avl);
 674         kvlist_init(&ln->node_info, kvlist_blob_len);
 675         INIT_LIST_HEAD(&node->sta_info);
 676         INIT_LIST_HEAD(&node->measurements);
 677
 678         ln->bss_tm_queries_timeout.cb = usteer_local_node_process_bss_tm_queries;
 679         INIT_LIST_HEAD(&ln->bss_tm_queries);
 680         return ln;
 681 }
 682
 683 static void
 684 usteer_node_run_update_script(struct usteer_node *node)
 685 {
 686         struct usteer_local_node *ln = container_of(node, struct usteer_local_node, node);
 687         char *val;
 688
 689         if (!node_up_script)
 690                 return;
 691
 692         val = alloca(strlen(node_up_script) + strlen(ln->iface) + 8);
 693         sprintf(val, "%s '%s'", node_up_script, ln->iface);
 694         if (system(val))
 695                 MSG(INFO, "failed to execute %s\n", val);
 696 }
 697
 698 static void
 699 usteer_check_node_enabled(struct usteer_local_node *ln)
 700 {
 701         bool ssid_disabled = config.ssid_list;
 702         struct blob_attr *cur;
 703         int rem;
 704
 705         blobmsg_for_each_attr(cur, config.ssid_list, rem) {
 706                 if (strcmp(blobmsg_get_string(cur), ln->node.ssid) != 0)
 707                         continue;
 708
 709                 ssid_disabled = false;
 710                 break;
 711         }
 712
 713         if (ln->node.disabled == ssid_disabled)
 714                 return;
 715
 716         ln->node.disabled = ssid_disabled;
 717
 718         if (ssid_disabled) {
 719                 MSG(INFO, "Disconnecting from local node %s\n", usteer_node_name(&ln->node));
 720                 usteer_local_node_state_reset(ln);
 721                 usteer_sta_node_cleanup(&ln->node);
 722                 usteer_measurement_report_node_cleanup(&ln->node);
 723                 uloop_timeout_cancel(&ln->update);
 724                 ubus_unsubscribe(ubus_ctx, &ln->ev, ln->obj_id);
 725                 return;
 726         }
 727
 728         MSG(INFO, "Connecting to local node %s\n", usteer_node_name(&ln->node));
 729         ubus_subscribe(ubus_ctx, &ln->ev, ln->obj_id);
 730         uloop_timeout_set(&ln->update, 1);
 731         usteer_node_run_update_script(&ln->node);
 732 }
 733
 734 static void
 735 usteer_register_node(struct ubus_context *ctx, const char *name, uint32_t id)
 736 {
 737         struct usteer_local_node *ln;
 738         struct usteer_node_handler *h;
 739         const char *iface;
 740         int offset = sizeof("hostapd.") - 1;
 741
 742         iface = name + offset;
 743         if (strncmp(name, "hostapd.", iface - name) != 0)
 744                 return;
 745
 746         MSG(INFO, "Creating local node %s\n", name);
 747         ln = usteer_get_node(ctx, name);
 748         ln->obj_id = id;
 749         ln->iface = usteer_node_name(&ln->node) + offset;
 750         ln->ifindex = if_nametoindex(ln->iface);
 751
 752         blob_buf_init(&b, 0);
 753         blobmsg_add_u32(&b, "notify_response", 1);
 754         ubus_invoke(ctx, id, "notify_response", b.head, NULL, NULL, 1000);
 755
 756         blob_buf_init(&b, 0);
 757         blobmsg_add_u8(&b, "neighbor_report", 1);
 758         blobmsg_add_u8(&b, "beacon_report", 1);
 759         blobmsg_add_u8(&b, "bss_transition", 1);
 760         ubus_invoke(ctx, id, "bss_mgmt_enable", b.head, NULL, NULL, 1000);
 761
 762         list_for_each_entry(h, &node_handlers, list) {
 763                 if (!h->init_node)
 764                         continue;
 765
 766                 h->init_node(&ln->node);
 767         }
 768
 769         ln->node.disabled = true;
 770         usteer_check_node_enabled(ln);
 771 }
 772
 773 static void
 774 usteer_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev,
 775                     const char *type, struct blob_attr *msg)
 776 {
 777         static const struct blobmsg_policy policy[2] = {
 778                 { .name = "id", .type = BLOBMSG_TYPE_INT32 },
 779                 { .name = "path", .type = BLOBMSG_TYPE_STRING },
 780         };
 781         struct blob_attr *tb[2];
 782         const char *path;
 783
 784         blobmsg_parse(policy, 2, tb, blob_data(msg), blob_len(msg));
 785
 786         if (!tb[0] || !tb[1])
 787                 return;
 788
 789         path = blobmsg_data(tb[1]);
 790         usteer_register_node(ctx, path, blobmsg_get_u32(tb[0]));
 791 }
 792
 793 static void
 794 usteer_register_events(struct ubus_context *ctx)
 795 {
 796         static struct ubus_event_handler handler = {
 797             .cb = usteer_event_handler
 798         };
 799
 800         ubus_register_event_handler(ctx, &handler, "ubus.object.add");
 801 }
 802
 803 static void
 804 node_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
 805 {
 806         usteer_register_node(ctx, obj->path, obj->id);
 807 }
 808
 809 void config_set_node_up_script(struct blob_attr *data)
 810 {
 811         const char *val;
 812         struct usteer_node *node;
 813
 814         if (!data)
 815                 return;
 816
 817         val = blobmsg_get_string(data);
 818         if (node_up_script && !strcmp(val, node_up_script))
 819                 return;
 820
 821         free(node_up_script);
 822
 823         if (!strlen(val)) {
 824                 node_up_script = NULL;
 825                 return;
 826         }
 827
 828         node_up_script = strdup(val);
 829
 830         for_each_local_node(node)
 831                 usteer_node_run_update_script(node);
 832 }
 833
 834 void config_get_node_up_script(struct blob_buf *buf)
 835 {
 836         if (!node_up_script)
 837                 return;
 838
 839         blobmsg_add_string(buf, "node_up_script", node_up_script);
 840 }
 841
 842 void config_set_ssid_list(struct blob_attr *data)
 843 {
 844         struct usteer_local_node *ln;
 845
 846         free(config.ssid_list);
 847
 848         if (data && blobmsg_len(data))
 849                 config.ssid_list = blob_memdup(data);
 850         else
 851                 config.ssid_list = NULL;
 852
 853         avl_for_each_element(&local_nodes, ln, node.avl)
 854                 usteer_check_node_enabled(ln);
 855 }
 856
 857 void config_get_ssid_list(struct blob_buf *buf)
 858 {
 859         if (config.ssid_list)
 860                 blobmsg_add_blob(buf, config.ssid_list);
 861 }
 862
 863 void
 864 usteer_local_nodes_init(struct ubus_context *ctx)
 865 {
 866         usteer_register_events(ctx);
 867         ubus_lookup(ctx, "hostapd.*", node_list_cb, NULL);
 868 }