package/network/services/hostapd/src/src/ap/ubus.c

   1 /*
   2  * hostapd / ubus support
   3  * Copyright (c) 2013, Felix Fietkau <nbd@nbd.name>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include "utils/common.h"
  11 #include "utils/eloop.h"
  12 #include "utils/wpabuf.h"
  13 #include "common/ieee802_11_defs.h"
  14 #include "hostapd.h"
  15 #include "neighbor_db.h"
  16 #include "wps_hostapd.h"
  17 #include "sta_info.h"
  18 #include "ubus.h"
  19 #include "ap_drv_ops.h"
  20 #include "beacon.h"
  21 #include "rrm.h"
  22 #include "wnm_ap.h"
  23 #include "taxonomy.h"
  24
  25 static struct ubus_context *ctx;
  26 static struct blob_buf b;
  27 static int ctx_ref;
  28
  29 static inline struct hapd_interfaces *get_hapd_interfaces_from_object(struct ubus_object *obj)
  30 {
  31         return container_of(obj, struct hapd_interfaces, ubus);
  32 }
  33
  34 static inline struct hostapd_data *get_hapd_from_object(struct ubus_object *obj)
  35 {
  36         return container_of(obj, struct hostapd_data, ubus.obj);
  37 }
  38
  39 struct ubus_banned_client {
  40         struct avl_node avl;
  41         u8 addr[ETH_ALEN];
  42 };
  43
  44 static void ubus_receive(int sock, void *eloop_ctx, void *sock_ctx)
  45 {
  46         struct ubus_context *ctx = eloop_ctx;
  47         ubus_handle_event(ctx);
  48 }
  49
  50 static void ubus_reconnect_timeout(void *eloop_data, void *user_ctx)
  51 {
  52         if (ubus_reconnect(ctx, NULL)) {
  53                 eloop_register_timeout(1, 0, ubus_reconnect_timeout, ctx, NULL);
  54                 return;
  55         }
  56
  57         eloop_register_read_sock(ctx->sock.fd, ubus_receive, ctx, NULL);
  58 }
  59
  60 static void hostapd_ubus_connection_lost(struct ubus_context *ctx)
  61 {
  62         eloop_unregister_read_sock(ctx->sock.fd);
  63         eloop_register_timeout(1, 0, ubus_reconnect_timeout, ctx, NULL);
  64 }
  65
  66 static bool hostapd_ubus_init(void)
  67 {
  68         if (ctx)
  69                 return true;
  70
  71         ctx = ubus_connect(NULL);
  72         if (!ctx)
  73                 return false;
  74
  75         ctx->connection_lost = hostapd_ubus_connection_lost;
  76         eloop_register_read_sock(ctx->sock.fd, ubus_receive, ctx, NULL);
  77         return true;
  78 }
  79
  80 static void hostapd_ubus_ref_inc(void)
  81 {
  82         ctx_ref++;
  83 }
  84
  85 static void hostapd_ubus_ref_dec(void)
  86 {
  87         ctx_ref--;
  88         if (!ctx)
  89                 return;
  90
  91         if (ctx_ref)
  92                 return;
  93
  94         eloop_unregister_read_sock(ctx->sock.fd);
  95         ubus_free(ctx);
  96         ctx = NULL;
  97 }
  98
  99 void hostapd_ubus_add_iface(struct hostapd_iface *iface)
 100 {
 101         if (!hostapd_ubus_init())
 102                 return;
 103 }
 104
 105 void hostapd_ubus_free_iface(struct hostapd_iface *iface)
 106 {
 107         if (!ctx)
 108                 return;
 109 }
 110
 111 static void hostapd_send_ubus_event(char *bssname, char *event)
 112 {
 113         char *name;
 114
 115         if (!ctx)
 116                 return;
 117
 118         if (asprintf(&name, "hostapd.%s.%s", bssname, event) < 0)
 119                 return;
 120
 121         blob_buf_init(&b, 0);
 122         ubus_send_event(ctx, name, b.head);
 123         free(name);
 124 }
 125
 126 static void hostapd_send_procd_event(char *bssname, char *event)
 127 {
 128         char *name, *s;
 129         uint32_t id;
 130         void *v;
 131
 132         if (!ctx || ubus_lookup_id(ctx, "service", &id))
 133                 return;
 134
 135         if (asprintf(&name, "hostapd.%s.%s", bssname, event) < 0)
 136                 return;
 137
 138         blob_buf_init(&b, 0);
 139
 140         s = blobmsg_alloc_string_buffer(&b, "type", strlen(name) + 1);
 141         sprintf(s, "%s", name);
 142         blobmsg_add_string_buffer(&b);
 143
 144         v = blobmsg_open_table(&b, "data");
 145         blobmsg_close_table(&b, v);
 146
 147         ubus_invoke(ctx, id, "event", b.head, NULL, NULL, 1000);
 148
 149         free(name);
 150 }
 151
 152 static void hostapd_send_shared_event(char *bssname, char *event)
 153 {
 154         hostapd_send_procd_event(bssname, event);
 155         hostapd_send_ubus_event(bssname, event);
 156 }
 157
 158 static void
 159 hostapd_bss_del_ban(void *eloop_data, void *user_ctx)
 160 {
 161         struct ubus_banned_client *ban = eloop_data;
 162         struct hostapd_data *hapd = user_ctx;
 163
 164         avl_delete(&hapd->ubus.banned, &ban->avl);
 165         free(ban);
 166 }
 167
 168 static void
 169 hostapd_bss_ban_client(struct hostapd_data *hapd, u8 *addr, int time)
 170 {
 171         struct ubus_banned_client *ban;
 172
 173         if (time < 0)
 174                 time = 0;
 175
 176         ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
 177         if (!ban) {
 178                 if (!time)
 179                         return;
 180
 181                 ban = os_zalloc(sizeof(*ban));
 182                 memcpy(ban->addr, addr, sizeof(ban->addr));
 183                 ban->avl.key = ban->addr;
 184                 avl_insert(&hapd->ubus.banned, &ban->avl);
 185         } else {
 186                 eloop_cancel_timeout(hostapd_bss_del_ban, ban, hapd);
 187                 if (!time) {
 188                         hostapd_bss_del_ban(ban, hapd);
 189                         return;
 190                 }
 191         }
 192
 193         eloop_register_timeout(0, time * 1000, hostapd_bss_del_ban, ban, hapd);
 194 }
 195
 196 static int
 197 hostapd_bss_reload(struct ubus_context *ctx, struct ubus_object *obj,
 198                    struct ubus_request_data *req, const char *method,
 199                    struct blob_attr *msg)
 200 {
 201         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 202         int ret = hostapd_reload_config(hapd->iface, 1);
 203
 204         hostapd_send_shared_event(hapd->conf->iface, "reload");
 205         return ret;
 206 }
 207
 208 static int
 209 hostapd_bss_get_clients(struct ubus_context *ctx, struct ubus_object *obj,
 210                         struct ubus_request_data *req, const char *method,
 211                         struct blob_attr *msg)
 212 {
 213         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 214         struct sta_info *sta;
 215         void *list, *c;
 216         char mac_buf[20];
 217         static const struct {
 218                 const char *name;
 219                 uint32_t flag;
 220         } sta_flags[] = {
 221                 { "auth", WLAN_STA_AUTH },
 222                 { "assoc", WLAN_STA_ASSOC },
 223                 { "authorized", WLAN_STA_AUTHORIZED },
 224                 { "preauth", WLAN_STA_PREAUTH },
 225                 { "wds", WLAN_STA_WDS },
 226                 { "wmm", WLAN_STA_WMM },
 227                 { "ht", WLAN_STA_HT },
 228                 { "vht", WLAN_STA_VHT },
 229                 { "wps", WLAN_STA_WPS },
 230                 { "mfp", WLAN_STA_MFP },
 231         };
 232
 233         blob_buf_init(&b, 0);
 234         blobmsg_add_u32(&b, "freq", hapd->iface->freq);
 235         list = blobmsg_open_table(&b, "clients");
 236         for (sta = hapd->sta_list; sta; sta = sta->next) {
 237                 void *r;
 238                 int i;
 239
 240                 sprintf(mac_buf, MACSTR, MAC2STR(sta->addr));
 241                 c = blobmsg_open_table(&b, mac_buf);
 242                 for (i = 0; i < ARRAY_SIZE(sta_flags); i++)
 243                         blobmsg_add_u8(&b, sta_flags[i].name,
 244                                        !!(sta->flags & sta_flags[i].flag));
 245
 246                 r = blobmsg_open_array(&b, "rrm");
 247                 for (i = 0; i < ARRAY_SIZE(sta->rrm_enabled_capa); i++)
 248                         blobmsg_add_u32(&b, "", sta->rrm_enabled_capa[i]);
 249                 blobmsg_close_array(&b, r);
 250                 blobmsg_add_u32(&b, "aid", sta->aid);
 251 #ifdef CONFIG_TAXONOMY
 252                 r = blobmsg_alloc_string_buffer(&b, "signature", 1024);
 253                 if (retrieve_sta_taxonomy(hapd, sta, r, 1024) > 0)
 254                         blobmsg_add_string_buffer(&b);
 255 #endif
 256                 blobmsg_close_table(&b, c);
 257         }
 258         blobmsg_close_array(&b, list);
 259         ubus_send_reply(ctx, req, b.head);
 260
 261         return 0;
 262 }
 263
 264 static int
 265 hostapd_bss_get_features(struct ubus_context *ctx, struct ubus_object *obj,
 266                         struct ubus_request_data *req, const char *method,
 267                         struct blob_attr *msg)
 268 {
 269         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 270
 271         blob_buf_init(&b, 0);
 272         blobmsg_add_u8(&b, "ht_supported", ht_supported(hapd->iface->hw_features));
 273         blobmsg_add_u8(&b, "vht_supported", vht_supported(hapd->iface->hw_features));
 274         ubus_send_reply(ctx, req, b.head);
 275
 276         return 0;
 277 }
 278
 279 enum {
 280         NOTIFY_RESPONSE,
 281         __NOTIFY_MAX
 282 };
 283
 284 static const struct blobmsg_policy notify_policy[__NOTIFY_MAX] = {
 285         [NOTIFY_RESPONSE] = { "notify_response", BLOBMSG_TYPE_INT32 },
 286 };
 287
 288 static int
 289 hostapd_notify_response(struct ubus_context *ctx, struct ubus_object *obj,
 290                         struct ubus_request_data *req, const char *method,
 291                         struct blob_attr *msg)
 292 {
 293         struct blob_attr *tb[__NOTIFY_MAX];
 294         struct hostapd_data *hapd = get_hapd_from_object(obj);
 295         struct wpabuf *elems;
 296         const char *pos;
 297         size_t len;
 298
 299         blobmsg_parse(notify_policy, __NOTIFY_MAX, tb,
 300                       blob_data(msg), blob_len(msg));
 301
 302         if (!tb[NOTIFY_RESPONSE])
 303                 return UBUS_STATUS_INVALID_ARGUMENT;
 304
 305         hapd->ubus.notify_response = blobmsg_get_u32(tb[NOTIFY_RESPONSE]);
 306
 307         return UBUS_STATUS_OK;
 308 }
 309
 310 enum {
 311         DEL_CLIENT_ADDR,
 312         DEL_CLIENT_REASON,
 313         DEL_CLIENT_DEAUTH,
 314         DEL_CLIENT_BAN_TIME,
 315         __DEL_CLIENT_MAX
 316 };
 317
 318 static const struct blobmsg_policy del_policy[__DEL_CLIENT_MAX] = {
 319         [DEL_CLIENT_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
 320         [DEL_CLIENT_REASON] = { "reason", BLOBMSG_TYPE_INT32 },
 321         [DEL_CLIENT_DEAUTH] = { "deauth", BLOBMSG_TYPE_INT8 },
 322         [DEL_CLIENT_BAN_TIME] = { "ban_time", BLOBMSG_TYPE_INT32 },
 323 };
 324
 325 static int
 326 hostapd_bss_del_client(struct ubus_context *ctx, struct ubus_object *obj,
 327                         struct ubus_request_data *req, const char *method,
 328                         struct blob_attr *msg)
 329 {
 330         struct blob_attr *tb[__DEL_CLIENT_MAX];
 331         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 332         struct sta_info *sta;
 333         bool deauth = false;
 334         int reason;
 335         u8 addr[ETH_ALEN];
 336
 337         blobmsg_parse(del_policy, __DEL_CLIENT_MAX, tb, blob_data(msg), blob_len(msg));
 338
 339         if (!tb[DEL_CLIENT_ADDR])
 340                 return UBUS_STATUS_INVALID_ARGUMENT;
 341
 342         if (hwaddr_aton(blobmsg_data(tb[DEL_CLIENT_ADDR]), addr))
 343                 return UBUS_STATUS_INVALID_ARGUMENT;
 344
 345         if (tb[DEL_CLIENT_REASON])
 346                 reason = blobmsg_get_u32(tb[DEL_CLIENT_REASON]);
 347
 348         if (tb[DEL_CLIENT_DEAUTH])
 349                 deauth = blobmsg_get_bool(tb[DEL_CLIENT_DEAUTH]);
 350
 351         sta = ap_get_sta(hapd, addr);
 352         if (sta) {
 353                 if (deauth) {
 354                         hostapd_drv_sta_deauth(hapd, addr, reason);
 355                         ap_sta_deauthenticate(hapd, sta, reason);
 356                 } else {
 357                         hostapd_drv_sta_disassoc(hapd, addr, reason);
 358                         ap_sta_disassociate(hapd, sta, reason);
 359                 }
 360         }
 361
 362         if (tb[DEL_CLIENT_BAN_TIME])
 363                 hostapd_bss_ban_client(hapd, addr, blobmsg_get_u32(tb[DEL_CLIENT_BAN_TIME]));
 364
 365         return 0;
 366 }
 367
 368 static void
 369 blobmsg_add_macaddr(struct blob_buf *buf, const char *name, const u8 *addr)
 370 {
 371         char *s;
 372
 373         s = blobmsg_alloc_string_buffer(buf, name, 20);
 374         sprintf(s, MACSTR, MAC2STR(addr));
 375         blobmsg_add_string_buffer(buf);
 376 }
 377
 378 static int
 379 hostapd_bss_list_bans(struct ubus_context *ctx, struct ubus_object *obj,
 380                       struct ubus_request_data *req, const char *method,
 381                       struct blob_attr *msg)
 382 {
 383         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 384         struct ubus_banned_client *ban;
 385         void *c;
 386
 387         blob_buf_init(&b, 0);
 388         c = blobmsg_open_array(&b, "clients");
 389         avl_for_each_element(&hapd->ubus.banned, ban, avl)
 390                 blobmsg_add_macaddr(&b, NULL, ban->addr);
 391         blobmsg_close_array(&b, c);
 392         ubus_send_reply(ctx, req, b.head);
 393
 394         return 0;
 395 }
 396
 397 static int
 398 hostapd_bss_wps_start(struct ubus_context *ctx, struct ubus_object *obj,
 399                         struct ubus_request_data *req, const char *method,
 400                         struct blob_attr *msg)
 401 {
 402         int rc;
 403         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 404
 405         rc = hostapd_wps_button_pushed(hapd, NULL);
 406
 407         if (rc != 0)
 408                 return UBUS_STATUS_NOT_SUPPORTED;
 409
 410         return 0;
 411 }
 412
 413 static int
 414 hostapd_bss_wps_cancel(struct ubus_context *ctx, struct ubus_object *obj,
 415                         struct ubus_request_data *req, const char *method,
 416                         struct blob_attr *msg)
 417 {
 418         int rc;
 419         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 420
 421         rc = hostapd_wps_cancel(hapd);
 422
 423         if (rc != 0)
 424                 return UBUS_STATUS_NOT_SUPPORTED;
 425
 426         return 0;
 427 }
 428
 429 static int
 430 hostapd_bss_update_beacon(struct ubus_context *ctx, struct ubus_object *obj,
 431                         struct ubus_request_data *req, const char *method,
 432                         struct blob_attr *msg)
 433 {
 434         int rc;
 435         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 436
 437         rc = ieee802_11_set_beacon(hapd);
 438
 439         if (rc != 0)
 440                 return UBUS_STATUS_NOT_SUPPORTED;
 441
 442         return 0;
 443 }
 444
 445 enum {
 446         CONFIG_IFACE,
 447         CONFIG_FILE,
 448         __CONFIG_MAX
 449 };
 450
 451 static const struct blobmsg_policy config_add_policy[__CONFIG_MAX] = {
 452         [CONFIG_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
 453         [CONFIG_FILE] = { "config", BLOBMSG_TYPE_STRING },
 454 };
 455
 456 static int
 457 hostapd_config_add(struct ubus_context *ctx, struct ubus_object *obj,
 458                    struct ubus_request_data *req, const char *method,
 459                    struct blob_attr *msg)
 460 {
 461         struct blob_attr *tb[__CONFIG_MAX];
 462         struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
 463         char buf[128];
 464
 465         blobmsg_parse(config_add_policy, __CONFIG_MAX, tb, blob_data(msg), blob_len(msg));
 466
 467         if (!tb[CONFIG_FILE] || !tb[CONFIG_IFACE])
 468                 return UBUS_STATUS_INVALID_ARGUMENT;
 469
 470         snprintf(buf, sizeof(buf), "bss_config=%s:%s",
 471                 blobmsg_get_string(tb[CONFIG_IFACE]),
 472                 blobmsg_get_string(tb[CONFIG_FILE]));
 473
 474         if (hostapd_add_iface(interfaces, buf))
 475                 return UBUS_STATUS_INVALID_ARGUMENT;
 476
 477         return UBUS_STATUS_OK;
 478 }
 479
 480 enum {
 481         CONFIG_REM_IFACE,
 482         __CONFIG_REM_MAX
 483 };
 484
 485 static const struct blobmsg_policy config_remove_policy[__CONFIG_REM_MAX] = {
 486         [CONFIG_REM_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
 487 };
 488
 489 static int
 490 hostapd_config_remove(struct ubus_context *ctx, struct ubus_object *obj,
 491                       struct ubus_request_data *req, const char *method,
 492                       struct blob_attr *msg)
 493 {
 494         struct blob_attr *tb[__CONFIG_REM_MAX];
 495         struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
 496         char buf[128];
 497
 498         blobmsg_parse(config_remove_policy, __CONFIG_REM_MAX, tb, blob_data(msg), blob_len(msg));
 499
 500         if (!tb[CONFIG_REM_IFACE])
 501                 return UBUS_STATUS_INVALID_ARGUMENT;
 502
 503         if (hostapd_remove_iface(interfaces, blobmsg_get_string(tb[CONFIG_REM_IFACE])))
 504                 return UBUS_STATUS_INVALID_ARGUMENT;
 505
 506         return UBUS_STATUS_OK;
 507 }
 508
 509 enum {
 510         CSA_FREQ,
 511         CSA_BCN_COUNT,
 512         CSA_CENTER_FREQ1,
 513         CSA_CENTER_FREQ2,
 514         CSA_BANDWIDTH,
 515         CSA_SEC_CHANNEL_OFFSET,
 516         CSA_HT,
 517         CSA_VHT,
 518         CSA_BLOCK_TX,
 519         __CSA_MAX
 520 };
 521
 522 static const struct blobmsg_policy csa_policy[__CSA_MAX] = {
 523         [CSA_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
 524         [CSA_BCN_COUNT] = { "bcn_count", BLOBMSG_TYPE_INT32 },
 525         [CSA_CENTER_FREQ1] = { "center_freq1", BLOBMSG_TYPE_INT32 },
 526         [CSA_CENTER_FREQ2] = { "center_freq2", BLOBMSG_TYPE_INT32 },
 527         [CSA_BANDWIDTH] = { "bandwidth", BLOBMSG_TYPE_INT32 },
 528         [CSA_SEC_CHANNEL_OFFSET] = { "sec_channel_offset", BLOBMSG_TYPE_INT32 },
 529         [CSA_HT] = { "ht", BLOBMSG_TYPE_BOOL },
 530         [CSA_VHT] = { "vht", BLOBMSG_TYPE_BOOL },
 531         [CSA_BLOCK_TX] = { "block_tx", BLOBMSG_TYPE_BOOL },
 532 };
 533
 534 #ifdef NEED_AP_MLME
 535 static int
 536 hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
 537                     struct ubus_request_data *req, const char *method,
 538                     struct blob_attr *msg)
 539 {
 540         struct blob_attr *tb[__CSA_MAX];
 541         struct hostapd_data *hapd = get_hapd_from_object(obj);
 542         struct csa_settings css;
 543
 544         blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
 545
 546         if (!tb[CSA_FREQ])
 547                 return UBUS_STATUS_INVALID_ARGUMENT;
 548
 549         memset(&css, 0, sizeof(css));
 550         css.freq_params.freq = blobmsg_get_u32(tb[CSA_FREQ]);
 551
 552 #define SET_CSA_SETTING(name, field, type) \
 553         do { \
 554                 if (tb[name]) \
 555                         css.field = blobmsg_get_ ## type(tb[name]); \
 556         } while(0)
 557
 558         SET_CSA_SETTING(CSA_BCN_COUNT, cs_count, u32);
 559         SET_CSA_SETTING(CSA_CENTER_FREQ1, freq_params.center_freq1, u32);
 560         SET_CSA_SETTING(CSA_CENTER_FREQ2, freq_params.center_freq2, u32);
 561         SET_CSA_SETTING(CSA_BANDWIDTH, freq_params.bandwidth, u32);
 562         SET_CSA_SETTING(CSA_SEC_CHANNEL_OFFSET, freq_params.sec_channel_offset, u32);
 563         SET_CSA_SETTING(CSA_HT, freq_params.ht_enabled, bool);
 564         SET_CSA_SETTING(CSA_VHT, freq_params.vht_enabled, bool);
 565         SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
 566
 567
 568         if (hostapd_switch_channel(hapd, &css) != 0)
 569                 return UBUS_STATUS_NOT_SUPPORTED;
 570         return UBUS_STATUS_OK;
 571 #undef SET_CSA_SETTING
 572 }
 573 #endif
 574
 575 enum {
 576         VENDOR_ELEMENTS,
 577         __VENDOR_ELEMENTS_MAX
 578 };
 579
 580 static const struct blobmsg_policy ve_policy[__VENDOR_ELEMENTS_MAX] = {
 581         /* vendor elements are provided as hex-string */
 582         [VENDOR_ELEMENTS] = { "vendor_elements", BLOBMSG_TYPE_STRING },
 583 };
 584
 585 static int
 586 hostapd_vendor_elements(struct ubus_context *ctx, struct ubus_object *obj,
 587                         struct ubus_request_data *req, const char *method,
 588                         struct blob_attr *msg)
 589 {
 590         struct blob_attr *tb[__VENDOR_ELEMENTS_MAX];
 591         struct hostapd_data *hapd = get_hapd_from_object(obj);
 592         struct hostapd_bss_config *bss = hapd->conf;
 593         struct wpabuf *elems;
 594         const char *pos;
 595         size_t len;
 596
 597         blobmsg_parse(ve_policy, __VENDOR_ELEMENTS_MAX, tb,
 598                       blob_data(msg), blob_len(msg));
 599
 600         if (!tb[VENDOR_ELEMENTS])
 601                 return UBUS_STATUS_INVALID_ARGUMENT;
 602
 603         pos = blobmsg_data(tb[VENDOR_ELEMENTS]);
 604         len = os_strlen(pos);
 605         if (len & 0x01)
 606                         return UBUS_STATUS_INVALID_ARGUMENT;
 607
 608         len /= 2;
 609         if (len == 0) {
 610                 wpabuf_free(bss->vendor_elements);
 611                 bss->vendor_elements = NULL;
 612                 return 0;
 613         }
 614
 615         elems = wpabuf_alloc(len);
 616         if (elems == NULL)
 617                 return 1;
 618
 619         if (hexstr2bin(pos, wpabuf_put(elems, len), len)) {
 620                 wpabuf_free(elems);
 621                 return UBUS_STATUS_INVALID_ARGUMENT;
 622         }
 623
 624         wpabuf_free(bss->vendor_elements);
 625         bss->vendor_elements = elems;
 626
 627         /* update beacons if vendor elements were set successfully */
 628         if (ieee802_11_update_beacons(hapd->iface) != 0)
 629                 return UBUS_STATUS_NOT_SUPPORTED;
 630         return UBUS_STATUS_OK;
 631 }
 632
 633 static void
 634 hostapd_rrm_print_nr(struct hostapd_neighbor_entry *nr)
 635 {
 636         const u8 *data;
 637         char *str;
 638         int len;
 639
 640         blobmsg_printf(&b, "", MACSTR, MAC2STR(nr->bssid));
 641
 642         str = blobmsg_alloc_string_buffer(&b, "", nr->ssid.ssid_len + 1);
 643         memcpy(str, nr->ssid.ssid, nr->ssid.ssid_len);
 644         str[nr->ssid.ssid_len] = 0;
 645         blobmsg_add_string_buffer(&b);
 646
 647         len = wpabuf_len(nr->nr);
 648         str = blobmsg_alloc_string_buffer(&b, "", 2 * len + 1);
 649         wpa_snprintf_hex(str, 2 * len + 1, wpabuf_head_u8(nr->nr), len);
 650         blobmsg_add_string_buffer(&b);
 651 }
 652
 653 enum {
 654         BSS_MGMT_EN_NEIGHBOR,
 655         BSS_MGMT_EN_BEACON,
 656 #ifdef CONFIG_WNM_AP
 657         BSS_MGMT_EN_BSS_TRANSITION,
 658 #endif
 659         __BSS_MGMT_EN_MAX
 660 };
 661
 662 static bool
 663 __hostapd_bss_mgmt_enable_f(struct hostapd_data *hapd, int flag)
 664 {
 665         struct hostapd_bss_config *bss = hapd->conf;
 666         uint32_t flags;
 667
 668         switch (flag) {
 669         case BSS_MGMT_EN_NEIGHBOR:
 670                 if (bss->radio_measurements[0] &
 671                     WLAN_RRM_CAPS_NEIGHBOR_REPORT)
 672                         return false;
 673
 674                 bss->radio_measurements[0] |=
 675                         WLAN_RRM_CAPS_NEIGHBOR_REPORT;
 676                 hostapd_neighbor_set_own_report(hapd);
 677                 return true;
 678         case BSS_MGMT_EN_BEACON:
 679                 flags = WLAN_RRM_CAPS_BEACON_REPORT_PASSIVE |
 680                         WLAN_RRM_CAPS_BEACON_REPORT_ACTIVE |
 681                         WLAN_RRM_CAPS_BEACON_REPORT_TABLE;
 682
 683                 if (bss->radio_measurements[0] & flags == flags)
 684                         return false;
 685
 686                 bss->radio_measurements[0] |= (u8) flags;
 687                 return true;
 688 #ifdef CONFIG_WNM_AP
 689         case BSS_MGMT_EN_BSS_TRANSITION:
 690                 if (bss->bss_transition)
 691                         return false;
 692
 693                 bss->bss_transition = 1;
 694                 return true;
 695 #endif
 696         }
 697 }
 698
 699 static void
 700 __hostapd_bss_mgmt_enable(struct hostapd_data *hapd, uint32_t flags)
 701 {
 702         bool update = false;
 703         int i;
 704
 705         for (i = 0; i < __BSS_MGMT_EN_MAX; i++) {
 706                 if (!(flags & (1 << i)))
 707                         continue;
 708
 709                 update |= __hostapd_bss_mgmt_enable_f(hapd, i);
 710         }
 711
 712         if (update)
 713                 ieee802_11_update_beacons(hapd->iface);
 714 }
 715
 716
 717 static const struct blobmsg_policy bss_mgmt_enable_policy[__BSS_MGMT_EN_MAX] = {
 718         [BSS_MGMT_EN_NEIGHBOR] = { "neighbor_report", BLOBMSG_TYPE_BOOL },
 719         [BSS_MGMT_EN_BEACON] = { "beacon_report", BLOBMSG_TYPE_BOOL },
 720 #ifdef CONFIG_WNM_AP
 721         [BSS_MGMT_EN_BSS_TRANSITION] = { "bss_transition", BLOBMSG_TYPE_BOOL },
 722 #endif
 723 };
 724
 725 static int
 726 hostapd_bss_mgmt_enable(struct ubus_context *ctx, struct ubus_object *obj,
 727                    struct ubus_request_data *req, const char *method,
 728                    struct blob_attr *msg)
 729
 730 {
 731         struct hostapd_data *hapd = get_hapd_from_object(obj);
 732         struct blob_attr *tb[__BSS_MGMT_EN_MAX];
 733         struct blob_attr *cur;
 734         uint32_t flags = 0;
 735         int i;
 736         bool neigh = false, beacon = false;
 737
 738         blobmsg_parse(bss_mgmt_enable_policy, __BSS_MGMT_EN_MAX, tb, blob_data(msg), blob_len(msg));
 739
 740         for (i = 0; i < ARRAY_SIZE(tb); i++) {
 741                 if (!tb[i] || !blobmsg_get_bool(tb[i]))
 742                         continue;
 743
 744                 flags |= (1 << i);
 745         }
 746
 747         __hostapd_bss_mgmt_enable(hapd, flags);
 748 }
 749
 750
 751 static void
 752 hostapd_rrm_nr_enable(struct hostapd_data *hapd)
 753 {
 754         __hostapd_bss_mgmt_enable(hapd, 1 << BSS_MGMT_EN_NEIGHBOR);
 755 }
 756
 757 static int
 758 hostapd_rrm_nr_get_own(struct ubus_context *ctx, struct ubus_object *obj,
 759                        struct ubus_request_data *req, const char *method,
 760                        struct blob_attr *msg)
 761 {
 762         struct hostapd_data *hapd = get_hapd_from_object(obj);
 763         struct hostapd_neighbor_entry *nr;
 764         void *c;
 765
 766         hostapd_rrm_nr_enable(hapd);
 767
 768         nr = hostapd_neighbor_get(hapd, hapd->own_addr, NULL);
 769         if (!nr)
 770                 return UBUS_STATUS_NOT_FOUND;
 771
 772         blob_buf_init(&b, 0);
 773
 774         c = blobmsg_open_array(&b, "value");
 775         hostapd_rrm_print_nr(nr);
 776         blobmsg_close_array(&b, c);
 777
 778         ubus_send_reply(ctx, req, b.head);
 779
 780         return 0;
 781 }
 782
 783 static int
 784 hostapd_rrm_nr_list(struct ubus_context *ctx, struct ubus_object *obj,
 785                     struct ubus_request_data *req, const char *method,
 786                     struct blob_attr *msg)
 787 {
 788         struct hostapd_data *hapd = get_hapd_from_object(obj);
 789         struct hostapd_neighbor_entry *nr;
 790         void *c;
 791
 792         hostapd_rrm_nr_enable(hapd);
 793         blob_buf_init(&b, 0);
 794
 795         c = blobmsg_open_array(&b, "list");
 796         dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
 797                 void *cur;
 798
 799                 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
 800                         continue;
 801
 802                 cur = blobmsg_open_array(&b, NULL);
 803                 hostapd_rrm_print_nr(nr);
 804                 blobmsg_close_array(&b, cur);
 805         }
 806         blobmsg_close_array(&b, c);
 807
 808         ubus_send_reply(ctx, req, b.head);
 809
 810         return 0;
 811 }
 812
 813 enum {
 814         NR_SET_LIST,
 815         __NR_SET_LIST_MAX
 816 };
 817
 818 static const struct blobmsg_policy nr_set_policy[__NR_SET_LIST_MAX] = {
 819         [NR_SET_LIST] = { "list", BLOBMSG_TYPE_ARRAY },
 820 };
 821
 822
 823 static void
 824 hostapd_rrm_nr_clear(struct hostapd_data *hapd)
 825 {
 826         struct hostapd_neighbor_entry *nr;
 827
 828 restart:
 829         dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
 830                 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
 831                         continue;
 832
 833                 hostapd_neighbor_remove(hapd, nr->bssid, &nr->ssid);
 834                 goto restart;
 835         }
 836 }
 837
 838 static int
 839 hostapd_rrm_nr_set(struct ubus_context *ctx, struct ubus_object *obj,
 840                    struct ubus_request_data *req, const char *method,
 841                    struct blob_attr *msg)
 842 {
 843         static const struct blobmsg_policy nr_e_policy[] = {
 844                 { .type = BLOBMSG_TYPE_STRING },
 845                 { .type = BLOBMSG_TYPE_STRING },
 846                 { .type = BLOBMSG_TYPE_STRING },
 847         };
 848         struct hostapd_data *hapd = get_hapd_from_object(obj);
 849         struct blob_attr *tb_l[__NR_SET_LIST_MAX];
 850         struct blob_attr *tb[ARRAY_SIZE(nr_e_policy)];
 851         struct blob_attr *cur;
 852         int rem;
 853
 854         hostapd_rrm_nr_enable(hapd);
 855
 856         blobmsg_parse(nr_set_policy, __NR_SET_LIST_MAX, tb_l, blob_data(msg), blob_len(msg));
 857         if (!tb_l[NR_SET_LIST])
 858                 return UBUS_STATUS_INVALID_ARGUMENT;
 859
 860         hostapd_rrm_nr_clear(hapd);
 861         blobmsg_for_each_attr(cur, tb_l[NR_SET_LIST], rem) {
 862                 struct wpa_ssid_value ssid;
 863                 struct wpabuf *data;
 864                 u8 bssid[ETH_ALEN];
 865                 char *s;
 866
 867                 blobmsg_parse_array(nr_e_policy, ARRAY_SIZE(nr_e_policy), tb, blobmsg_data(cur), blobmsg_data_len(cur));
 868                 if (!tb[0] || !tb[1] || !tb[2])
 869                         goto invalid;
 870
 871                 s = blobmsg_get_string(tb[0]);
 872                 if (hwaddr_aton(s, bssid))
 873                         goto invalid;
 874
 875                 s = blobmsg_get_string(tb[1]);
 876                 ssid.ssid_len = strlen(s);
 877                 if (ssid.ssid_len > sizeof(ssid.ssid))
 878                         goto invalid;
 879
 880                 memcpy(&ssid, s, ssid.ssid_len);
 881                 data = wpabuf_parse_bin(blobmsg_get_string(tb[2]));
 882                 if (!data)
 883                         goto invalid;
 884
 885                 hostapd_neighbor_set(hapd, bssid, &ssid, data, NULL, NULL, 0);
 886                 wpabuf_free(data);
 887                 continue;
 888
 889 invalid:
 890                 return UBUS_STATUS_INVALID_ARGUMENT;
 891         }
 892
 893         return 0;
 894 }
 895
 896 enum {
 897         BEACON_REQ_ADDR,
 898         BEACON_REQ_MODE,
 899         BEACON_REQ_OP_CLASS,
 900         BEACON_REQ_CHANNEL,
 901         BEACON_REQ_DURATION,
 902         BEACON_REQ_BSSID,
 903         BEACON_REQ_SSID,
 904         __BEACON_REQ_MAX,
 905 };
 906
 907 static const struct blobmsg_policy beacon_req_policy[__BEACON_REQ_MAX] = {
 908         [BEACON_REQ_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
 909         [BEACON_REQ_OP_CLASS] { "op_class", BLOBMSG_TYPE_INT32 },
 910         [BEACON_REQ_CHANNEL] { "channel", BLOBMSG_TYPE_INT32 },
 911         [BEACON_REQ_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
 912         [BEACON_REQ_MODE] { "mode", BLOBMSG_TYPE_INT32 },
 913         [BEACON_REQ_BSSID] { "bssid", BLOBMSG_TYPE_STRING },
 914         [BEACON_REQ_SSID] { "ssid", BLOBMSG_TYPE_STRING },
 915 };
 916
 917 static int
 918 hostapd_rrm_beacon_req(struct ubus_context *ctx, struct ubus_object *obj,
 919                        struct ubus_request_data *ureq, const char *method,
 920                        struct blob_attr *msg)
 921 {
 922         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
 923         struct blob_attr *tb[__BEACON_REQ_MAX];
 924         struct blob_attr *cur;
 925         struct wpabuf *req;
 926         u8 bssid[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 927         u8 addr[ETH_ALEN];
 928         int mode, rem, ret;
 929         int buf_len = 13;
 930
 931         blobmsg_parse(beacon_req_policy, __BEACON_REQ_MAX, tb, blob_data(msg), blob_len(msg));
 932
 933         if (!tb[BEACON_REQ_ADDR] || !tb[BEACON_REQ_MODE] || !tb[BEACON_REQ_DURATION] ||
 934             !tb[BEACON_REQ_OP_CLASS] || !tb[BEACON_REQ_CHANNEL])
 935                 return UBUS_STATUS_INVALID_ARGUMENT;
 936
 937         if (tb[BEACON_REQ_SSID])
 938                 buf_len += blobmsg_data_len(tb[BEACON_REQ_SSID]) + 2 - 1;
 939
 940         mode = blobmsg_get_u32(tb[BEACON_REQ_MODE]);
 941         if (hwaddr_aton(blobmsg_data(tb[BEACON_REQ_ADDR]), addr))
 942                 return UBUS_STATUS_INVALID_ARGUMENT;
 943
 944         if (tb[BEACON_REQ_BSSID] &&
 945             hwaddr_aton(blobmsg_data(tb[BEACON_REQ_BSSID]), bssid))
 946                 return UBUS_STATUS_INVALID_ARGUMENT;
 947
 948         req = wpabuf_alloc(buf_len);
 949         if (!req)
 950                 return UBUS_STATUS_UNKNOWN_ERROR;
 951
 952         /* 1: regulatory class */
 953         wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_OP_CLASS]));
 954
 955         /* 2: channel number */
 956         wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_CHANNEL]));
 957
 958         /* 3-4: randomization interval */
 959         wpabuf_put_le16(req, 0);
 960
 961         /* 5-6: duration */
 962         wpabuf_put_le16(req, blobmsg_get_u32(tb[BEACON_REQ_DURATION]));
 963
 964         /* 7: mode */
 965         wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_MODE]));
 966
 967         /* 8-13: BSSID */
 968         wpabuf_put_data(req, bssid, ETH_ALEN);
 969
 970         if ((cur = tb[BEACON_REQ_SSID]) != NULL) {
 971                 wpabuf_put_u8(req, WLAN_EID_SSID);
 972                 wpabuf_put_u8(req, blobmsg_data_len(cur) - 1);
 973                 wpabuf_put_data(req, blobmsg_data(cur), blobmsg_data_len(cur) - 1);
 974         }
 975
 976         ret = hostapd_send_beacon_req(hapd, addr, 0, req);
 977         if (ret < 0)
 978                 return -ret;
 979
 980         return 0;
 981 }
 982
 983
 984 #ifdef CONFIG_WNM_AP
 985 enum {
 986         WNM_DISASSOC_ADDR,
 987         WNM_DISASSOC_DURATION,
 988         WNM_DISASSOC_NEIGHBORS,
 989         WNM_DISASSOC_ABRIDGED,
 990         __WNM_DISASSOC_MAX,
 991 };
 992
 993 static const struct blobmsg_policy wnm_disassoc_policy[__WNM_DISASSOC_MAX] = {
 994         [WNM_DISASSOC_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
 995         [WNM_DISASSOC_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
 996         [WNM_DISASSOC_NEIGHBORS] { "neighbors", BLOBMSG_TYPE_ARRAY },
 997         [WNM_DISASSOC_ABRIDGED] { "abridged", BLOBMSG_TYPE_BOOL },
 998 };
 999
1000 static int
1001 hostapd_wnm_disassoc_imminent(struct ubus_context *ctx, struct ubus_object *obj,
1002                               struct ubus_request_data *ureq, const char *method,
1003                               struct blob_attr *msg)
1004 {
1005         struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1006         struct blob_attr *tb[__WNM_DISASSOC_MAX];
1007         struct blob_attr *cur;
1008         struct sta_info *sta;
1009         int duration = 10;
1010         int rem;
1011         int nr_len = 0;
1012         u8 *nr = NULL;
1013         u8 req_mode = WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
1014         u8 addr[ETH_ALEN];
1015
1016         blobmsg_parse(wnm_disassoc_policy, __WNM_DISASSOC_MAX, tb, blob_data(msg), blob_len(msg));
1017
1018         if (!tb[WNM_DISASSOC_ADDR])
1019                 return UBUS_STATUS_INVALID_ARGUMENT;
1020
1021         if (hwaddr_aton(blobmsg_data(tb[WNM_DISASSOC_ADDR]), addr))
1022                 return UBUS_STATUS_INVALID_ARGUMENT;
1023
1024         if ((cur = tb[WNM_DISASSOC_DURATION]) != NULL)
1025                 duration = blobmsg_get_u32(cur);
1026
1027         sta = ap_get_sta(hapd, addr);
1028         if (!sta)
1029                 return UBUS_STATUS_NOT_FOUND;
1030
1031         if (tb[WNM_DISASSOC_NEIGHBORS]) {
1032                 u8 *nr_cur;
1033
1034                 if (blobmsg_check_array(tb[WNM_DISASSOC_NEIGHBORS],
1035                                         BLOBMSG_TYPE_STRING) < 0)
1036                         return UBUS_STATUS_INVALID_ARGUMENT;
1037
1038                 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1039                         int len = strlen(blobmsg_get_string(cur));
1040
1041                         if (len % 2)
1042                                 return UBUS_STATUS_INVALID_ARGUMENT;
1043
1044                         nr_len += (len / 2) + 2;
1045                 }
1046
1047                 if (nr_len) {
1048                         nr = os_zalloc(nr_len);
1049                         if (!nr)
1050                                 return UBUS_STATUS_UNKNOWN_ERROR;
1051                 }
1052
1053                 nr_cur = nr;
1054                 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1055                         int len = strlen(blobmsg_get_string(cur)) / 2;
1056
1057                         *nr_cur++ = WLAN_EID_NEIGHBOR_REPORT;
1058                         *nr_cur++ = (u8) len;
1059                         if (hexstr2bin(blobmsg_data(cur), nr_cur, len)) {
1060                                 free(nr);
1061                                 return UBUS_STATUS_INVALID_ARGUMENT;
1062                         }
1063
1064                         nr_cur += len;
1065                 }
1066         }
1067
1068         if (nr)
1069                 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
1070
1071         if (tb[WNM_DISASSOC_ABRIDGED] && blobmsg_get_bool(tb[WNM_DISASSOC_ABRIDGED]))
1072                 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
1073
1074         if (wnm_send_bss_tm_req(hapd, sta, req_mode, duration, 0, NULL,
1075                                 NULL, nr, nr_len, NULL, 0))
1076                 return UBUS_STATUS_UNKNOWN_ERROR;
1077
1078         return 0;
1079 }
1080 #endif
1081
1082 static const struct ubus_method bss_methods[] = {
1083         UBUS_METHOD_NOARG("reload", hostapd_bss_reload),
1084         UBUS_METHOD_NOARG("get_clients", hostapd_bss_get_clients),
1085         UBUS_METHOD("del_client", hostapd_bss_del_client, del_policy),
1086         UBUS_METHOD_NOARG("list_bans", hostapd_bss_list_bans),
1087         UBUS_METHOD_NOARG("wps_start", hostapd_bss_wps_start),
1088         UBUS_METHOD_NOARG("wps_cancel", hostapd_bss_wps_cancel),
1089         UBUS_METHOD_NOARG("update_beacon", hostapd_bss_update_beacon),
1090         UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features),
1091 #ifdef NEED_AP_MLME
1092         UBUS_METHOD("switch_chan", hostapd_switch_chan, csa_policy),
1093 #endif
1094         UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements, ve_policy),
1095         UBUS_METHOD("notify_response", hostapd_notify_response, notify_policy),
1096         UBUS_METHOD("bss_mgmt_enable", hostapd_bss_mgmt_enable, bss_mgmt_enable_policy),
1097         UBUS_METHOD_NOARG("rrm_nr_get_own", hostapd_rrm_nr_get_own),
1098         UBUS_METHOD_NOARG("rrm_nr_list", hostapd_rrm_nr_list),
1099         UBUS_METHOD("rrm_nr_set", hostapd_rrm_nr_set, nr_set_policy),
1100         UBUS_METHOD("rrm_beacon_req", hostapd_rrm_beacon_req, beacon_req_policy),
1101 #ifdef CONFIG_WNM_AP
1102         UBUS_METHOD("wnm_disassoc_imminent", hostapd_wnm_disassoc_imminent, wnm_disassoc_policy),
1103 #endif
1104 };
1105
1106 static struct ubus_object_type bss_object_type =
1107         UBUS_OBJECT_TYPE("hostapd_bss", bss_methods);
1108
1109 static int avl_compare_macaddr(const void *k1, const void *k2, void *ptr)
1110 {
1111         return memcmp(k1, k2, ETH_ALEN);
1112 }
1113
1114 void hostapd_ubus_add_bss(struct hostapd_data *hapd)
1115 {
1116         struct ubus_object *obj = &hapd->ubus.obj;
1117         char *name;
1118         int ret;
1119
1120 #ifdef CONFIG_MESH
1121         if (hapd->conf->mesh & MESH_ENABLED)
1122                 return;
1123 #endif
1124
1125         if (!hostapd_ubus_init())
1126                 return;
1127
1128         if (asprintf(&name, "hostapd.%s", hapd->conf->iface) < 0)
1129                 return;
1130
1131         avl_init(&hapd->ubus.banned, avl_compare_macaddr, false, NULL);
1132         obj->name = name;
1133         obj->type = &bss_object_type;
1134         obj->methods = bss_object_type.methods;
1135         obj->n_methods = bss_object_type.n_methods;
1136         ret = ubus_add_object(ctx, obj);
1137         hostapd_ubus_ref_inc();
1138
1139         hostapd_send_shared_event(hapd->conf->iface, "add");
1140 }
1141
1142 void hostapd_ubus_free_bss(struct hostapd_data *hapd)
1143 {
1144         struct ubus_object *obj = &hapd->ubus.obj;
1145         char *name = (char *) obj->name;
1146
1147         if (!ctx)
1148                 return;
1149
1150         hostapd_send_shared_event(hapd->conf->iface, "remove");
1151
1152         if (obj->id) {
1153                 ubus_remove_object(ctx, obj);
1154                 hostapd_ubus_ref_dec();
1155         }
1156
1157         free(name);
1158 }
1159
1160 static const struct ubus_method daemon_methods[] = {
1161         UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
1162         UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
1163 };
1164
1165 static struct ubus_object_type daemon_object_type =
1166         UBUS_OBJECT_TYPE("hostapd", daemon_methods);
1167
1168 void hostapd_ubus_add(struct hapd_interfaces *interfaces)
1169 {
1170         struct ubus_object *obj = &interfaces->ubus;
1171         int ret;
1172
1173         if (!hostapd_ubus_init())
1174                 return;
1175
1176         obj->name = strdup("hostapd");
1177
1178         obj->type = &daemon_object_type;
1179         obj->methods = daemon_object_type.methods;
1180         obj->n_methods = daemon_object_type.n_methods;
1181         ret = ubus_add_object(ctx, obj);
1182         hostapd_ubus_ref_inc();
1183 }
1184
1185 void hostapd_ubus_free(struct hapd_interfaces *interfaces)
1186 {
1187         struct ubus_object *obj = &interfaces->ubus;
1188         char *name = (char *) obj->name;
1189
1190         if (!ctx)
1191                 return;
1192
1193         if (obj->id) {
1194                 ubus_remove_object(ctx, obj);
1195                 hostapd_ubus_ref_dec();
1196         }
1197
1198         free(name);
1199 }
1200
1201 struct ubus_event_req {
1202         struct ubus_notify_request nreq;
1203         int resp;
1204 };
1205
1206 static void
1207 ubus_event_cb(struct ubus_notify_request *req, int idx, int ret)
1208 {
1209         struct ubus_event_req *ureq = container_of(req, struct ubus_event_req, nreq);
1210
1211         ureq->resp = ret;
1212 }
1213
1214 int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
1215 {
1216         struct ubus_banned_client *ban;
1217         const char *types[HOSTAPD_UBUS_TYPE_MAX] = {
1218                 [HOSTAPD_UBUS_PROBE_REQ] = "probe",
1219                 [HOSTAPD_UBUS_AUTH_REQ] = "auth",
1220                 [HOSTAPD_UBUS_ASSOC_REQ] = "assoc",
1221         };
1222         const char *type = "mgmt";
1223         struct ubus_event_req ureq = {};
1224         const u8 *addr;
1225
1226         if (req->mgmt_frame)
1227                 addr = req->mgmt_frame->sa;
1228         else
1229                 addr = req->addr;
1230
1231         ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
1232         if (ban)
1233                 return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
1234
1235         if (!hapd->ubus.obj.has_subscribers)
1236                 return WLAN_STATUS_SUCCESS;
1237
1238         if (req->type < ARRAY_SIZE(types))
1239                 type = types[req->type];
1240
1241         blob_buf_init(&b, 0);
1242         blobmsg_add_macaddr(&b, "address", addr);
1243         if (req->mgmt_frame)
1244                 blobmsg_add_macaddr(&b, "target", req->mgmt_frame->da);
1245         if (req->ssi_signal)
1246                 blobmsg_add_u32(&b, "signal", req->ssi_signal);
1247         blobmsg_add_u32(&b, "freq", hapd->iface->freq);
1248
1249         if (req->elems) {
1250                 if(req->elems->ht_capabilities)
1251                 {
1252                         struct ieee80211_ht_capabilities *ht_capabilities;
1253                         void *ht_cap, *ht_cap_mcs_set, *mcs_set;
1254
1255
1256                         ht_capabilities = (struct ieee80211_ht_capabilities*) req->elems->ht_capabilities;
1257                         ht_cap = blobmsg_open_table(&b, "ht_capabilities");
1258                         blobmsg_add_u16(&b, "ht_capabilities_info", ht_capabilities->ht_capabilities_info);
1259                         ht_cap_mcs_set = blobmsg_open_table(&b, "supported_mcs_set");
1260                         blobmsg_add_u16(&b, "a_mpdu_params", ht_capabilities->a_mpdu_params);
1261                         blobmsg_add_u16(&b, "ht_extended_capabilities", ht_capabilities->ht_extended_capabilities);
1262                         blobmsg_add_u32(&b, "tx_bf_capability_info", ht_capabilities->tx_bf_capability_info);
1263                         blobmsg_add_u16(&b, "asel_capabilities", ht_capabilities->asel_capabilities);
1264                         mcs_set = blobmsg_open_array(&b, "supported_mcs_set");
1265                         for (int i = 0; i < 16; i++) {
1266                                 blobmsg_add_u16(&b, NULL, (u16) ht_capabilities->supported_mcs_set[i]);
1267                         }
1268                         blobmsg_close_array(&b, mcs_set);
1269                         blobmsg_close_table(&b, ht_cap_mcs_set);
1270                         blobmsg_close_table(&b, ht_cap);
1271                 }
1272                 if(req->elems->vht_capabilities)
1273                 {
1274                         struct ieee80211_vht_capabilities *vht_capabilities;
1275                         void *vht_cap, *vht_cap_mcs_set;
1276
1277                         vht_capabilities = (struct ieee80211_vht_capabilities*) req->elems->vht_capabilities;
1278                         vht_cap = blobmsg_open_table(&b, "vht_capabilities");
1279                         blobmsg_add_u32(&b, "vht_capabilities_info", vht_capabilities->vht_capabilities_info);
1280                         vht_cap_mcs_set = blobmsg_open_table(&b, "vht_supported_mcs_set");
1281                         blobmsg_add_u16(&b, "rx_map", vht_capabilities->vht_supported_mcs_set.rx_map);
1282                         blobmsg_add_u16(&b, "rx_highest", vht_capabilities->vht_supported_mcs_set.rx_highest);
1283                         blobmsg_add_u16(&b, "tx_map", vht_capabilities->vht_supported_mcs_set.tx_map);
1284                         blobmsg_add_u16(&b, "tx_highest", vht_capabilities->vht_supported_mcs_set.tx_highest);
1285                         blobmsg_close_table(&b, vht_cap_mcs_set);
1286                         blobmsg_close_table(&b, vht_cap);
1287                 }
1288         }
1289
1290         if (!hapd->ubus.notify_response) {
1291                 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1292                 return WLAN_STATUS_SUCCESS;
1293         }
1294
1295         if (ubus_notify_async(ctx, &hapd->ubus.obj, type, b.head, &ureq.nreq))
1296                 return WLAN_STATUS_SUCCESS;
1297
1298         ureq.nreq.status_cb = ubus_event_cb;
1299         ubus_complete_request(ctx, &ureq.nreq.req, 100);
1300
1301         if (ureq.resp)
1302                 return ureq.resp;
1303
1304         return WLAN_STATUS_SUCCESS;
1305 }
1306
1307 void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *addr)
1308 {
1309         if (!hapd->ubus.obj.has_subscribers)
1310                 return;
1311
1312         if (!addr)
1313                 return;
1314
1315         blob_buf_init(&b, 0);
1316         blobmsg_add_macaddr(&b, "address", addr);
1317
1318         ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1319 }
1320
1321 void hostapd_ubus_notify_beacon_report(
1322         struct hostapd_data *hapd, const u8 *addr, u8 token, u8 rep_mode,
1323         struct rrm_measurement_beacon_report *rep, size_t len)
1324 {
1325         if (!hapd->ubus.obj.has_subscribers)
1326                 return;
1327
1328         if (!addr || !rep)
1329                 return;
1330
1331         blob_buf_init(&b, 0);
1332         blobmsg_add_macaddr(&b, "address", addr);
1333         blobmsg_add_u16(&b, "op-class", rep->op_class);
1334         blobmsg_add_u16(&b, "channel", rep->channel);
1335         blobmsg_add_u64(&b, "start-time", rep->start_time);
1336         blobmsg_add_u16(&b, "duration", rep->duration);
1337         blobmsg_add_u16(&b, "report-info", rep->report_info);
1338         blobmsg_add_u16(&b, "rcpi", rep->rcpi);
1339         blobmsg_add_u16(&b, "rsni", rep->rsni);
1340         blobmsg_add_macaddr(&b, "bssid", rep->bssid);
1341         blobmsg_add_u16(&b, "antenna-id", rep->antenna_id);
1342         blobmsg_add_u16(&b, "parent-tsf", rep->parent_tsf);
1343
1344         ubus_notify(ctx, &hapd->ubus.obj, "beacon-report", b.head, -1);
1345 }