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         if (si->bss_transition_response.status_code) {
 184                 /* Cancel imminent kick in case BSS transition was rejected */
 185                 si->kick_time = 0;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int
 192 usteer_local_node_handle_beacon_report(struct usteer_local_node *ln, struct blob_attr *msg)
 193 {
 194         enum {
 195                 BR_ADDRESS,
 196                 BR_BSSID,
 197                 BR_RCPI,
 198                 BR_RSNI,
 199                 __BR_MAX
 200         };
 201         struct blobmsg_policy policy[__BR_MAX] = {
 202                 [BR_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 203                 [BR_BSSID] = { .name = "bssid", .type = BLOBMSG_TYPE_STRING },
 204                 [BR_RCPI] = { .name = "rcpi", .type = BLOBMSG_TYPE_INT16 },
 205                 [BR_RSNI] = { .name = "rsni", .type = BLOBMSG_TYPE_INT16 },
 206         };
 207         struct blob_attr *tb[__BR_MAX];
 208         struct usteer_node *node;
 209         uint8_t *addr;
 210         struct sta *sta;
 211
 212         blobmsg_parse(policy, __BR_MAX, tb, blob_data(msg), blob_len(msg));
 213         if (!tb[BR_ADDRESS] || !tb[BR_BSSID] || !tb[BR_RCPI] || !tb[BR_RSNI])
 214                 return 0;
 215
 216         addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BR_ADDRESS]));
 217         if (!addr)
 218                 return 0;
 219
 220         sta = usteer_sta_get(addr, false);
 221         if (!sta)
 222                 return 0;
 223
 224         addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[BR_BSSID]));
 225         if (!addr)
 226                 return 0;
 227
 228         node = usteer_node_by_bssid(addr);
 229         if (!node)
 230                 return 0;
 231
 232         usteer_measurement_report_add(sta, node,
 233                                       (uint8_t)blobmsg_get_u16(tb[BR_RCPI]),
 234                                       (uint8_t)blobmsg_get_u16(tb[BR_RSNI]),
 235                                       current_time);
 236         return 0;
 237 }
 238
 239 static int
 240 usteer_local_node_handle_link_measurement_report(struct usteer_local_node *ln, struct blob_attr *msg)
 241 {
 242         enum {
 243                 LMR_ADDRESS,
 244                 LMR_RCPI,
 245                 LMR_RSNI,
 246                 __LMR_MAX
 247         };
 248         struct blobmsg_policy policy[__LMR_MAX] = {
 249                 [LMR_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 250                 [LMR_RCPI] = { .name = "rcpi", .type = BLOBMSG_TYPE_INT16 },
 251                 [LMR_RSNI] = { .name = "rsni", .type = BLOBMSG_TYPE_INT16 },
 252         };
 253         struct blob_attr *tb[__LMR_MAX];
 254         uint8_t *addr;
 255         struct sta *sta;
 256
 257         blobmsg_parse(policy, __LMR_MAX, tb, blob_data(msg), blob_len(msg));
 258         if (!tb[LMR_ADDRESS] || !tb[LMR_RCPI] || !tb[LMR_RSNI])
 259                 return 0;
 260
 261         addr = (uint8_t *) ether_aton(blobmsg_get_string(tb[LMR_ADDRESS]));
 262         if (!addr)
 263                 return 0;
 264
 265         sta = usteer_sta_get(addr, false);
 266         if (!sta)
 267                 return 0;
 268
 269         usteer_measurement_report_add(sta, &ln->node,
 270                                       (uint8_t)blobmsg_get_u16(tb[LMR_RCPI]),
 271                                       (uint8_t)blobmsg_get_u16(tb[LMR_RSNI]),
 272                                       current_time);
 273         return 0;
 274 }
 275
 276 static int
 277 usteer_handle_event(struct ubus_context *ctx, struct ubus_object *obj,
 278                    struct ubus_request_data *req, const char *method,
 279                    struct blob_attr *msg)
 280 {
 281         enum {
 282                 EVENT_ADDR,
 283                 EVENT_SIGNAL,
 284                 EVENT_TARGET,
 285                 EVENT_FREQ,
 286                 __EVENT_MAX
 287         };
 288         struct blobmsg_policy policy[__EVENT_MAX] = {
 289                 [EVENT_ADDR] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
 290                 [EVENT_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 },
 291                 [EVENT_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
 292                 [EVENT_FREQ] = { .name = "freq", .type = BLOBMSG_TYPE_INT32 },
 293         };
 294         enum usteer_event_type ev_type = __EVENT_TYPE_MAX;
 295         struct blob_attr *tb[__EVENT_MAX];
 296         struct usteer_local_node *ln;
 297         struct usteer_node *node;
 298         int signal = NO_SIGNAL;
 299         int freq = 0;
 300         const char *addr_str;
 301         const uint8_t *addr;
 302         int i;
 303         bool ret;
 304
 305         usteer_update_time();
 306
 307         ln = container_of(obj, struct usteer_local_node, ev.obj);
 308
 309         if(!strcmp(method, "bss-transition-query")) {
 310                 return usteer_handle_bss_tm_query(ln, msg);
 311         } else if(!strcmp(method, "bss-transition-response")) {
 312                 return usteer_handle_bss_tm_response(ln, msg);
 313         } else if(!strcmp(method, "beacon-report")) {
 314                 return usteer_local_node_handle_beacon_report(ln, msg);
 315         } else if(!strcmp(method, "link-measurement-report")) {
 316                 return usteer_local_node_handle_link_measurement_report(ln, msg);
 317         }
 318
 319         for (i = 0; i < ARRAY_SIZE(event_types); i++) {
 320                 if (strcmp(method, event_types[i]) != 0)
 321                         continue;
 322
 323                 ev_type = i;
 324                 break;
 325         }
 326
 327         ln = container_of(obj, struct usteer_local_node, ev.obj);
 328         node = &ln->node;
 329         blobmsg_parse(policy, __EVENT_MAX, tb, blob_data(msg), blob_len(msg));
 330         if (!tb[EVENT_ADDR] || !tb[EVENT_FREQ])
 331                 return UBUS_STATUS_INVALID_ARGUMENT;
 332
 333         if (tb[EVENT_SIGNAL])
 334                 signal = (int32_t) blobmsg_get_u32(tb[EVENT_SIGNAL]);
 335
 336         if (tb[EVENT_FREQ])
 337                 freq = blobmsg_get_u32(tb[EVENT_FREQ]);
 338
 339         addr_str = blobmsg_data(tb[EVENT_ADDR]);
 340         addr = (uint8_t *) ether_aton(addr_str);
 341         if (!addr)
 342                 return UBUS_STATUS_INVALID_ARGUMENT;
 343
 344         ret = usteer_handle_sta_event(node, addr, ev_type, freq, signal);
 345
 346         MSG(DEBUG, "received %s event from %s, signal=%d, freq=%d, handled:%s\n",
 347             method, addr_str, signal, freq, ret ? "true" : "false");
 348
 349         return ret ? 0 : 17 /* WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA */;
 350 }
 351
 352 static void
 353 usteer_local_node_assoc_update(struct sta_info *si, struct blob_attr *data)
 354 {
 355         enum {
 356                 MSG_ASSOC,
 357                 __MSG_MAX,
 358         };
 359         static struct blobmsg_policy policy[__MSG_MAX] = {
 360                 [MSG_ASSOC] = { "assoc", BLOBMSG_TYPE_BOOL },
 361         };
 362         struct blob_attr *tb[__MSG_MAX];
 363         struct usteer_remote_node *rn;
 364         struct sta_info *remote_si;
 365
 366         blobmsg_parse(policy, __MSG_MAX, tb, blobmsg_data(data), blobmsg_data_len(data));
 367         if (tb[MSG_ASSOC] && blobmsg_get_u8(tb[MSG_ASSOC])) {
 368                 if (si->connected == STA_NOT_CONNECTED) {
 369                         /* New connection. Check if STA roamed. */
 370                         for_each_remote_node(rn) {
 371                                 remote_si = usteer_sta_info_get(si->sta, &rn->node, NULL);
 372                                 if (!remote_si)
 373                                         continue;
 374
 375                                 if (current_time - remote_si->last_connected < config.roam_process_timeout) {
 376                                         rn->node.roam_events.source++;
 377                                         /* Don't abort looking for roam sources here.
 378                                          * The client might have roamed via another node
 379                                          * within the roam-timeout.
 380                                          */
 381                                 }
 382                         }
 383                 }
 384                 si->connected = STA_CONNECTED;
 385         }
 386 }
 387
 388 static void
 389 usteer_local_node_update_sta_rrm_wnm(struct sta_info *si, struct blob_attr *client_attr)
 390 {
 391         static const struct blobmsg_policy mbo_policy = {
 392                 .name = "mbo",
 393                 .type = BLOBMSG_TYPE_BOOL,
 394         };
 395         static const struct blobmsg_policy rrm_policy = {
 396                 .name = "rrm",
 397                 .type = BLOBMSG_TYPE_ARRAY,
 398         };
 399         static const struct blobmsg_policy ext_capa_policy = {
 400                 .name = "extended_capabilities",
 401                 .type = BLOBMSG_TYPE_ARRAY,
 402         };
 403         struct blob_attr *mbo_blob = NULL, *rrm_blob = NULL, *wnm_blob = NULL, *cur;
 404         int rem;
 405         int i = 0;
 406
 407         /* MBO */
 408         blobmsg_parse(&mbo_policy, 1, &mbo_blob, blobmsg_data(client_attr), blobmsg_data_len(client_attr));
 409
 410         if (mbo_blob)
 411                 si->mbo = blobmsg_get_u8(mbo_blob);
 412         else
 413                 si->mbo = false;
 414
 415         /* RRM */
 416         blobmsg_parse(&rrm_policy, 1, &rrm_blob, blobmsg_data(client_attr), blobmsg_data_len(client_attr));
 417         if (!rrm_blob)
 418                 return;
 419
 420         si->rrm = blobmsg_get_u32(blobmsg_data(rrm_blob));
 421
 422         /* Extended Capabilities / WNM */
 423         blobmsg_parse(&ext_capa_policy, 1, &wnm_blob, blobmsg_data(client_attr), blobmsg_data_len(client_attr));
 424         if (!wnm_blob)
 425                 return;
 426
 427         blobmsg_for_each_attr(cur, wnm_blob, rem) {
 428                 if (blobmsg_type(cur) != BLOBMSG_TYPE_INT32)
 429                         return;
 430
 431                 if (i == 2) {
 432                         if (blobmsg_get_u32(cur) & (1 << 3))
 433                                 si->bss_transition = true;
 434                 }
 435
 436                 i++;
 437         }
 438 }
 439
 440 static void
 441 usteer_local_node_set_assoc(struct usteer_local_node *ln, struct blob_attr *cl)
 442 {
 443         struct usteer_node *node = &ln->node;
 444         struct usteer_node_handler *h;
 445         struct blob_attr *cur;
 446         struct sta_info *si;
 447         struct sta *sta;
 448         int n_assoc = 0;
 449         int rem;
 450
 451         usteer_update_time();
 452
 453         list_for_each_entry(si, &node->sta_info, node_list) {
 454                 if (si->connected)
 455                         si->connected = STA_DISCONNECTED;
 456         }
 457
 458         blobmsg_for_each_attr(cur, cl, rem) {
 459                 uint8_t *addr = (uint8_t *) ether_aton(blobmsg_name(cur));
 460                 bool create;
 461
 462                 if (!addr)
 463                         continue;
 464
 465                 sta = usteer_sta_get(addr, true);
 466                 si = usteer_sta_info_get(sta, node, &create);
 467                 list_for_each_entry(h, &node_handlers, list) {
 468                         if (!h->update_sta)
 469                                 continue;
 470
 471                         h->update_sta(node, si);
 472                 }
 473                 usteer_local_node_assoc_update(si, cur);
 474                 if (si->connected == STA_CONNECTED) {
 475                         si->last_connected = current_time;
 476                         n_assoc++;
 477                 }
 478
 479                 /* Read RRM information */
 480                 usteer_local_node_update_sta_rrm_wnm(si, cur);
 481         }
 482
 483         node->n_assoc = n_assoc;
 484
 485         list_for_each_entry(si, &node->sta_info, node_list) {
 486                 if (si->connected != STA_DISCONNECTED)
 487                         continue;
 488
 489                 usteer_sta_disconnected(si);
 490                 MSG(VERBOSE, "station "MAC_ADDR_FMT" disconnected from node %s\n",
 491                         MAC_ADDR_DATA(si->sta->addr), usteer_node_name(node));
 492         }
 493 }
 494
 495 static void
 496 usteer_local_node_list_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 497 {
 498         enum {
 499                 MSG_FREQ,
 500                 MSG_CLIENTS,
 501                 __MSG_MAX,
 502         };
 503         static struct blobmsg_policy policy[__MSG_MAX] = {
 504                 [MSG_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 505                 [MSG_CLIENTS] = { "clients", BLOBMSG_TYPE_TABLE },
 506         };
 507         struct blob_attr *tb[__MSG_MAX];
 508         struct usteer_local_node *ln;
 509         struct usteer_node *node;
 510
 511         ln = container_of(req, struct usteer_local_node, req);
 512         node = &ln->node;
 513
 514         blobmsg_parse(policy, __MSG_MAX, tb, blob_data(msg), blob_len(msg));
 515         if (!tb[MSG_FREQ] || !tb[MSG_CLIENTS])
 516                 return;
 517
 518         node->freq = blobmsg_get_u32(tb[MSG_FREQ]);
 519         usteer_local_node_set_assoc(ln, tb[MSG_CLIENTS]);
 520 }
 521
 522 static void
 523 usteer_local_node_status_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 524 {
 525         enum {
 526                 MSG_FREQ,
 527                 MSG_CHANNEL,
 528                 MSG_OP_CLASS,
 529                 MSG_BEACON_INTERVAL,
 530                 __MSG_MAX,
 531         };
 532         static struct blobmsg_policy policy[__MSG_MAX] = {
 533                 [MSG_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 534                 [MSG_CHANNEL] = { "channel", BLOBMSG_TYPE_INT32 },
 535                 [MSG_OP_CLASS] = { "op_class", BLOBMSG_TYPE_INT32 },
 536                 [MSG_BEACON_INTERVAL] = { "beacon_interval", BLOBMSG_TYPE_INT32 },
 537         };
 538         struct blob_attr *tb[__MSG_MAX];
 539         struct usteer_local_node *ln;
 540         struct usteer_node *node;
 541
 542         ln = container_of(req, struct usteer_local_node, req);
 543         node = &ln->node;
 544
 545         blobmsg_parse(policy, __MSG_MAX, tb, blob_data(msg), blob_len(msg));
 546         if (tb[MSG_FREQ])
 547                 node->freq = blobmsg_get_u32(tb[MSG_FREQ]);
 548         if (tb[MSG_CHANNEL])
 549                 node->channel = blobmsg_get_u32(tb[MSG_CHANNEL]);
 550         if (tb[MSG_OP_CLASS])
 551                 node->op_class = blobmsg_get_u32(tb[MSG_OP_CLASS]);
 552
 553         /* Local-Node */
 554         if (tb[MSG_BEACON_INTERVAL])
 555                 ln->beacon_interval = blobmsg_get_u32(tb[MSG_BEACON_INTERVAL]);
 556 }
 557
 558 static void
 559 usteer_local_node_rrm_nr_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 560 {
 561         static const struct blobmsg_policy policy = {
 562                 "value", BLOBMSG_TYPE_ARRAY
 563         };
 564         struct usteer_local_node *ln;
 565         struct blob_attr *tb;
 566
 567         ln = container_of(req, struct usteer_local_node, req);
 568
 569         blobmsg_parse(&policy, 1, &tb, blob_data(msg), blob_len(msg));
 570         if (!tb)
 571                 return;
 572
 573         usteer_node_set_blob(&ln->node.rrm_nr, tb);
 574 }
 575
 576 static void
 577 usteer_local_node_req_cb(struct ubus_request *req, int ret)
 578 {
 579         struct usteer_local_node *ln;
 580
 581         ln = container_of(req, struct usteer_local_node, req);
 582         uloop_timeout_set(&ln->req_timer, 1);
 583 }
 584
 585 static bool
 586 usteer_add_rrm_data(struct usteer_local_node *ln, struct usteer_node *node)
 587 {
 588         if (node == &ln->node)
 589                 return false;
 590
 591         if (!node->rrm_nr)
 592                 return false;
 593
 594         /* Remote node only adds same SSID. Required for local-node. */
 595         if (strcmp(ln->node.ssid, node->ssid) != 0)
 596                 return false;
 597
 598         blobmsg_add_field(&b, BLOBMSG_TYPE_ARRAY, "",
 599                           blobmsg_data(node->rrm_nr),
 600                           blobmsg_data_len(node->rrm_nr));
 601
 602         return true;
 603 }
 604
 605 static void
 606 usteer_local_node_prepare_rrm_set(struct usteer_local_node *ln)
 607 {
 608         struct usteer_node *node, *last_remote_neighbor = NULL;
 609         int i = 0;
 610         void *c;
 611
 612         c = blobmsg_open_array(&b, "list");
 613         for_each_local_node(node) {
 614                 if (i >= config.max_neighbor_reports)
 615                         break;
 616                 if (usteer_add_rrm_data(ln, node))
 617                         i++;
 618         }
 619
 620         while (i < config.max_neighbor_reports) {
 621                 node = usteer_node_get_next_neighbor(&ln->node, last_remote_neighbor);
 622                 if (!node) {
 623                         /* No more nodes available */
 624                         break;
 625                 }
 626
 627                 last_remote_neighbor = node;
 628                 if (usteer_add_rrm_data(ln, node))
 629                         i++;
 630         }
 631
 632         blobmsg_close_array(&b, c);
 633 }
 634
 635 static void
 636 usteer_local_node_state_next(struct uloop_timeout *timeout)
 637 {
 638         struct usteer_local_node *ln;
 639
 640         ln = container_of(timeout, struct usteer_local_node, req_timer);
 641
 642         ln->req_state++;
 643         if (ln->req_state >= __REQ_MAX) {
 644                 ln->req_state = REQ_IDLE;
 645                 return;
 646         }
 647
 648         blob_buf_init(&b, 0);
 649         switch (ln->req_state) {
 650         case REQ_CLIENTS:
 651                 ubus_invoke_async(ubus_ctx, ln->obj_id, "get_clients", b.head, &ln->req);
 652                 ln->req.data_cb = usteer_local_node_list_cb;
 653                 break;
 654         case REQ_STATUS:
 655                 ubus_invoke_async(ubus_ctx, ln->obj_id, "get_status", b.head, &ln->req);
 656                 ln->req.data_cb = usteer_local_node_status_cb;
 657                 break;
 658         case REQ_RRM_SET_LIST:
 659                 usteer_local_node_prepare_rrm_set(ln);
 660                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_set", b.head, &ln->req);
 661                 ln->req.data_cb = NULL;
 662                 break;
 663         case REQ_RRM_GET_OWN:
 664                 ubus_invoke_async(ubus_ctx, ln->obj_id, "rrm_nr_get_own", b.head, &ln->req);
 665                 ln->req.data_cb = usteer_local_node_rrm_nr_cb;
 666                 break;
 667         default:
 668                 break;
 669         }
 670         ln->req.complete_cb = usteer_local_node_req_cb;
 671         ubus_complete_request_async(ubus_ctx, &ln->req);
 672 }
 673
 674 static void
 675 usteer_local_node_request_link_measurement(struct usteer_local_node *ln)
 676 {
 677         unsigned int min_count = DIV_ROUND_UP(config.link_measurement_interval, config.local_sta_update);
 678         struct usteer_node *node;
 679         struct sta_info *si;
 680
 681         node = &ln->node;
 682
 683         if (ln->link_measurement_tries < min_count) {
 684                 ln->link_measurement_tries++;
 685                 return;
 686         }
 687
 688         ln->link_measurement_tries = 0;
 689
 690         if (!config.link_measurement_interval)
 691                 return;
 692
 693         list_for_each_entry(si, &node->sta_info, node_list) {
 694                 if (si->connected != STA_CONNECTED)
 695                         continue;
 696
 697                 usteer_ubus_trigger_link_measurement(si);
 698         }
 699 }
 700
 701 static void
 702 usteer_local_node_update(struct uloop_timeout *timeout)
 703 {
 704         struct usteer_local_node *ln;
 705         struct usteer_node_handler *h;
 706         struct usteer_node *node;
 707
 708         ln = container_of(timeout, struct usteer_local_node, update);
 709         node = &ln->node;
 710
 711         list_for_each_entry(h, &node_handlers, list) {
 712                 if (!h->update_node)
 713                         continue;
 714
 715                 h->update_node(node);
 716         }
 717
 718         usteer_local_node_state_reset(ln);
 719         uloop_timeout_set(&ln->req_timer, 1);
 720         usteer_local_node_kick(ln);
 721         usteer_band_steering_perform_steer(ln);
 722         usteer_local_node_request_link_measurement(ln);
 723
 724         uloop_timeout_set(timeout, config.local_sta_update);
 725 }
 726
 727 static void
 728 usteer_local_node_process_bss_tm_queries(struct uloop_timeout *timeout)
 729 {
 730         struct usteer_bss_tm_query *query, *tmp;
 731         struct usteer_local_node *ln;
 732         struct usteer_node *node;
 733         struct sta_info *si;
 734         struct sta *sta;
 735         uint8_t validity_period;
 736
 737         ln = container_of(timeout, struct usteer_local_node, bss_tm_queries_timeout);
 738         node = &ln->node;
 739
 740         validity_period = 10000 / usteer_local_node_get_beacon_interval(ln); /* ~ 10 seconds */
 741
 742         list_for_each_entry_safe(query, tmp, &ln->bss_tm_queries, list) {
 743                 sta = usteer_sta_get(query->sta_addr, false);
 744                 if (!sta)
 745                         continue;
 746
 747                 si = usteer_sta_info_get(sta, node, false);
 748                 if (!si)
 749                         continue;
 750
 751                 usteer_ubus_bss_transition_request(si, query->dialog_token, false, false, validity_period, NULL);
 752         }
 753
 754         /* Free pending queries we can not handle */
 755         usteer_local_node_pending_bss_tm_free(ln);
 756 }
 757
 758 static struct usteer_local_node *
 759 usteer_get_node(struct ubus_context *ctx, const char *name)
 760 {
 761         struct usteer_local_node *ln;
 762         struct usteer_node *node;
 763         char *str;
 764
 765         ln = avl_find_element(&local_nodes, name, ln, node.avl);
 766         if (ln)
 767                 return ln;
 768
 769         ln = calloc_a(sizeof(*ln), &str, strlen(name) + 1);
 770         node = &ln->node;
 771         node->type = NODE_TYPE_LOCAL;
 772         node->created = current_time;
 773         node->avl.key = strcpy(str, name);
 774         ln->ev.remove_cb = usteer_handle_remove;
 775         ln->ev.cb = usteer_handle_event;
 776         ln->update.cb = usteer_local_node_update;
 777         ln->req_timer.cb = usteer_local_node_state_next;
 778         ubus_register_subscriber(ctx, &ln->ev);
 779         avl_insert(&local_nodes, &node->avl);
 780         kvlist_init(&ln->node_info, kvlist_blob_len);
 781         INIT_LIST_HEAD(&node->sta_info);
 782         INIT_LIST_HEAD(&node->measurements);
 783
 784         ln->bss_tm_queries_timeout.cb = usteer_local_node_process_bss_tm_queries;
 785         INIT_LIST_HEAD(&ln->bss_tm_queries);
 786         return ln;
 787 }
 788
 789 static void
 790 usteer_node_run_update_script(struct usteer_node *node)
 791 {
 792         struct usteer_local_node *ln = container_of(node, struct usteer_local_node, node);
 793         char *val;
 794
 795         if (!node_up_script)
 796                 return;
 797
 798         val = alloca(strlen(node_up_script) + strlen(ln->iface) + 8);
 799         sprintf(val, "%s '%s'", node_up_script, ln->iface);
 800         if (system(val))
 801                 MSG(INFO, "failed to execute %s\n", val);
 802 }
 803
 804 static void
 805 usteer_check_node_enabled(struct usteer_local_node *ln)
 806 {
 807         bool ssid_disabled = config.ssid_list;
 808         struct blob_attr *cur;
 809         int rem;
 810
 811         blobmsg_for_each_attr(cur, config.ssid_list, rem) {
 812                 if (strcmp(blobmsg_get_string(cur), ln->node.ssid) != 0)
 813                         continue;
 814
 815                 ssid_disabled = false;
 816                 break;
 817         }
 818
 819         if (ln->node.disabled == ssid_disabled)
 820                 return;
 821
 822         ln->node.disabled = ssid_disabled;
 823
 824         if (ssid_disabled) {
 825                 MSG(INFO, "Disconnecting from local node %s\n", usteer_node_name(&ln->node));
 826                 usteer_local_node_state_reset(ln);
 827                 usteer_sta_node_cleanup(&ln->node);
 828                 usteer_measurement_report_node_cleanup(&ln->node);
 829                 uloop_timeout_cancel(&ln->update);
 830                 ubus_unsubscribe(ubus_ctx, &ln->ev, ln->obj_id);
 831                 return;
 832         }
 833
 834         MSG(INFO, "Connecting to local node %s\n", usteer_node_name(&ln->node));
 835         ubus_subscribe(ubus_ctx, &ln->ev, ln->obj_id);
 836         uloop_timeout_set(&ln->update, 1);
 837         usteer_node_run_update_script(&ln->node);
 838 }
 839
 840 static void
 841 usteer_register_node(struct ubus_context *ctx, const char *name, uint32_t id)
 842 {
 843         struct usteer_local_node *ln;
 844         struct usteer_node_handler *h;
 845         const char *iface;
 846         int offset = sizeof("hostapd.") - 1;
 847
 848         iface = name + offset;
 849         if (strncmp(name, "hostapd.", iface - name) != 0)
 850                 return;
 851
 852         MSG(INFO, "Creating local node %s\n", name);
 853         ln = usteer_get_node(ctx, name);
 854         ln->obj_id = id;
 855         ln->iface = usteer_node_name(&ln->node) + offset;
 856         ln->ifindex = if_nametoindex(ln->iface);
 857
 858         blob_buf_init(&b, 0);
 859         blobmsg_add_u32(&b, "notify_response", 1);
 860         ubus_invoke(ctx, id, "notify_response", b.head, NULL, NULL, 1000);
 861
 862         blob_buf_init(&b, 0);
 863         blobmsg_add_u8(&b, "neighbor_report", 1);
 864         blobmsg_add_u8(&b, "link_measurement", 1);
 865         blobmsg_add_u8(&b, "beacon_report", 1);
 866         blobmsg_add_u8(&b, "bss_transition", 1);
 867         ubus_invoke(ctx, id, "bss_mgmt_enable", b.head, NULL, NULL, 1000);
 868
 869         list_for_each_entry(h, &node_handlers, list) {
 870                 if (!h->init_node)
 871                         continue;
 872
 873                 h->init_node(&ln->node);
 874         }
 875
 876         ln->node.disabled = true;
 877         usteer_check_node_enabled(ln);
 878 }
 879
 880 static void
 881 usteer_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev,
 882                     const char *type, struct blob_attr *msg)
 883 {
 884         static const struct blobmsg_policy policy[2] = {
 885                 { .name = "id", .type = BLOBMSG_TYPE_INT32 },
 886                 { .name = "path", .type = BLOBMSG_TYPE_STRING },
 887         };
 888         struct blob_attr *tb[2];
 889         const char *path;
 890
 891         blobmsg_parse(policy, 2, tb, blob_data(msg), blob_len(msg));
 892
 893         if (!tb[0] || !tb[1])
 894                 return;
 895
 896         path = blobmsg_data(tb[1]);
 897         usteer_register_node(ctx, path, blobmsg_get_u32(tb[0]));
 898 }
 899
 900 static void
 901 usteer_register_events(struct ubus_context *ctx)
 902 {
 903         static struct ubus_event_handler handler = {
 904             .cb = usteer_event_handler
 905         };
 906
 907         ubus_register_event_handler(ctx, &handler, "ubus.object.add");
 908 }
 909
 910 static void
 911 node_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
 912 {
 913         usteer_register_node(ctx, obj->path, obj->id);
 914 }
 915
 916 int
 917 usteer_local_node_get_beacon_interval(struct usteer_local_node *ln)
 918 {
 919         /* Check if beacon-interval is not available (pre-21.02+) */
 920         if (ln->beacon_interval < 1)
 921                 return 100;
 922
 923         return ln->beacon_interval;
 924 }
 925
 926 void config_set_node_up_script(struct blob_attr *data)
 927 {
 928         const char *val;
 929         struct usteer_node *node;
 930
 931         if (!data)
 932                 return;
 933
 934         val = blobmsg_get_string(data);
 935         if (node_up_script && !strcmp(val, node_up_script))
 936                 return;
 937
 938         free(node_up_script);
 939
 940         if (!strlen(val)) {
 941                 node_up_script = NULL;
 942                 return;
 943         }
 944
 945         node_up_script = strdup(val);
 946
 947         for_each_local_node(node)
 948                 usteer_node_run_update_script(node);
 949 }
 950
 951 void config_get_node_up_script(struct blob_buf *buf)
 952 {
 953         if (!node_up_script)
 954                 return;
 955
 956         blobmsg_add_string(buf, "node_up_script", node_up_script);
 957 }
 958
 959 void config_set_ssid_list(struct blob_attr *data)
 960 {
 961         struct usteer_local_node *ln;
 962
 963         free(config.ssid_list);
 964
 965         if (data && blobmsg_len(data))
 966                 config.ssid_list = blob_memdup(data);
 967         else
 968                 config.ssid_list = NULL;
 969
 970         avl_for_each_element(&local_nodes, ln, node.avl)
 971                 usteer_check_node_enabled(ln);
 972 }
 973
 974 void config_get_ssid_list(struct blob_buf *buf)
 975 {
 976         if (config.ssid_list)
 977                 blobmsg_add_blob(buf, config.ssid_list);
 978 }
 979
 980 void
 981 usteer_local_nodes_init(struct ubus_context *ctx)
 982 {
 983         usteer_register_events(ctx);
 984         ubus_lookup(ctx, "hostapd.*", node_list_cb, NULL);
 985 }