projects / openwrt / staging / stintel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
hostapd: set validity interval for BSS TMRA
[openwrt/staging/stintel.git] / 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_notify_ubus(struct ubus_object *obj, char *bssname, char *event)
112 {
113 char *event_type;
114
115 if (!ctx || !obj)
116 return;
117
118 if (asprintf(&event_type, "bss.%s", event) < 0)
119 return;
120
121 blob_buf_init(&b, 0);
122 blobmsg_add_string(&b, "name", bssname);
123 ubus_notify(ctx, obj, event_type, b.head, -1);
124 free(event_type);
125 }
126
127 static void hostapd_send_procd_event(char *bssname, char *event)
128 {
129 char *name, *s;
130 uint32_t id;
131 void *v;
132
133 if (!ctx || ubus_lookup_id(ctx, "service", &id))
134 return;
135
136 if (asprintf(&name, "hostapd.%s.%s", bssname, event) < 0)
137 return;
138
139 blob_buf_init(&b, 0);
140
141 s = blobmsg_alloc_string_buffer(&b, "type", strlen(name) + 1);
142 sprintf(s, "%s", name);
143 blobmsg_add_string_buffer(&b);
144
145 v = blobmsg_open_table(&b, "data");
146 blobmsg_close_table(&b, v);
147
148 ubus_invoke(ctx, id, "event", b.head, NULL, NULL, 1000);
149
150 free(name);
151 }
152
153 static void hostapd_send_shared_event(struct ubus_object *obj, char *bssname, char *event)
154 {
155 hostapd_send_procd_event(bssname, event);
156 hostapd_notify_ubus(obj, bssname, event);
157 }
158
159 static void
160 hostapd_bss_del_ban(void *eloop_data, void *user_ctx)
161 {
162 struct ubus_banned_client *ban = eloop_data;
163 struct hostapd_data *hapd = user_ctx;
164
165 avl_delete(&hapd->ubus.banned, &ban->avl);
166 free(ban);
167 }
168
169 static void
170 hostapd_bss_ban_client(struct hostapd_data *hapd, u8 *addr, int time)
171 {
172 struct ubus_banned_client *ban;
173
174 if (time < 0)
175 time = 0;
176
177 ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
178 if (!ban) {
179 if (!time)
180 return;
181
182 ban = os_zalloc(sizeof(*ban));
183 memcpy(ban->addr, addr, sizeof(ban->addr));
184 ban->avl.key = ban->addr;
185 avl_insert(&hapd->ubus.banned, &ban->avl);
186 } else {
187 eloop_cancel_timeout(hostapd_bss_del_ban, ban, hapd);
188 if (!time) {
189 hostapd_bss_del_ban(ban, hapd);
190 return;
191 }
192 }
193
194 eloop_register_timeout(0, time * 1000, hostapd_bss_del_ban, ban, hapd);
195 }
196
197 static int
198 hostapd_bss_reload(struct ubus_context *ctx, struct ubus_object *obj,
199 struct ubus_request_data *req, const char *method,
200 struct blob_attr *msg)
201 {
202 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
203 int ret = hostapd_reload_config(hapd->iface, 1);
204
205 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "reload");
206 return ret;
207 }
208
209
210 static void
211 hostapd_parse_vht_map_blobmsg(uint16_t map)
212 {
213 char label[4];
214 int16_t val;
215 int i;
216
217 for (i = 0; i < 8; i++) {
218 snprintf(label, 4, "%dss", i + 1);
219
220 val = (map & (BIT(1) | BIT(0))) + 7;
221 blobmsg_add_u16(&b, label, val == 10 ? -1 : val);
222 map = map >> 2;
223 }
224 }
225
226 static void
227 hostapd_parse_vht_capab_blobmsg(struct ieee80211_vht_capabilities *vhtc)
228 {
229 void *supported_mcs;
230 void *map;
231 int i;
232
233 static const struct {
234 const char *name;
235 uint32_t flag;
236 } vht_capas[] = {
237 { "su_beamformee", VHT_CAP_SU_BEAMFORMEE_CAPABLE },
238 { "mu_beamformee", VHT_CAP_MU_BEAMFORMEE_CAPABLE },
239 };
240
241 for (i = 0; i < ARRAY_SIZE(vht_capas); i++)
242 blobmsg_add_u8(&b, vht_capas[i].name,
243 !!(vhtc->vht_capabilities_info & vht_capas[i].flag));
244
245 supported_mcs = blobmsg_open_table(&b, "mcs_map");
246
247 /* RX map */
248 map = blobmsg_open_table(&b, "rx");
249 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc->vht_supported_mcs_set.rx_map));
250 blobmsg_close_table(&b, map);
251
252 /* TX map */
253 map = blobmsg_open_table(&b, "tx");
254 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc->vht_supported_mcs_set.tx_map));
255 blobmsg_close_table(&b, map);
256
257 blobmsg_close_table(&b, supported_mcs);
258 }
259
260 static void
261 hostapd_parse_capab_blobmsg(struct sta_info *sta)
262 {
263 void *r, *v;
264
265 v = blobmsg_open_table(&b, "capabilities");
266
267 if (sta->vht_capabilities) {
268 r = blobmsg_open_table(&b, "vht");
269 hostapd_parse_vht_capab_blobmsg(sta->vht_capabilities);
270 blobmsg_close_table(&b, r);
271 }
272
273 /* ToDo: Add HT / HE capability parsing */
274
275 blobmsg_close_table(&b, v);
276 }
277
278 static int
279 hostapd_bss_get_clients(struct ubus_context *ctx, struct ubus_object *obj,
280 struct ubus_request_data *req, const char *method,
281 struct blob_attr *msg)
282 {
283 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
284 struct hostap_sta_driver_data sta_driver_data;
285 struct sta_info *sta;
286 void *list, *c;
287 char mac_buf[20];
288 static const struct {
289 const char *name;
290 uint32_t flag;
291 } sta_flags[] = {
292 { "auth", WLAN_STA_AUTH },
293 { "assoc", WLAN_STA_ASSOC },
294 { "authorized", WLAN_STA_AUTHORIZED },
295 { "preauth", WLAN_STA_PREAUTH },
296 { "wds", WLAN_STA_WDS },
297 { "wmm", WLAN_STA_WMM },
298 { "ht", WLAN_STA_HT },
299 { "vht", WLAN_STA_VHT },
300 { "wps", WLAN_STA_WPS },
301 { "mfp", WLAN_STA_MFP },
302 };
303
304 blob_buf_init(&b, 0);
305 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
306 list = blobmsg_open_table(&b, "clients");
307 for (sta = hapd->sta_list; sta; sta = sta->next) {
308 void *r;
309 int i;
310
311 sprintf(mac_buf, MACSTR, MAC2STR(sta->addr));
312 c = blobmsg_open_table(&b, mac_buf);
313 for (i = 0; i < ARRAY_SIZE(sta_flags); i++)
314 blobmsg_add_u8(&b, sta_flags[i].name,
315 !!(sta->flags & sta_flags[i].flag));
316
317 r = blobmsg_open_array(&b, "rrm");
318 for (i = 0; i < ARRAY_SIZE(sta->rrm_enabled_capa); i++)
319 blobmsg_add_u32(&b, "", sta->rrm_enabled_capa[i]);
320 blobmsg_close_array(&b, r);
321 blobmsg_add_u32(&b, "aid", sta->aid);
322 #ifdef CONFIG_TAXONOMY
323 r = blobmsg_alloc_string_buffer(&b, "signature", 1024);
324 if (retrieve_sta_taxonomy(hapd, sta, r, 1024) > 0)
325 blobmsg_add_string_buffer(&b);
326 #endif
327
328 /* Driver information */
329 if (hostapd_drv_read_sta_data(hapd, &sta_driver_data, sta->addr) >= 0) {
330 r = blobmsg_open_table(&b, "bytes");
331 blobmsg_add_u64(&b, "rx", sta_driver_data.rx_bytes);
332 blobmsg_add_u64(&b, "tx", sta_driver_data.tx_bytes);
333 blobmsg_close_table(&b, r);
334 r = blobmsg_open_table(&b, "airtime");
335 blobmsg_add_u64(&b, "rx", sta_driver_data.rx_airtime);
336 blobmsg_add_u64(&b, "tx", sta_driver_data.tx_airtime);
337 blobmsg_close_table(&b, r);
338 r = blobmsg_open_table(&b, "packets");
339 blobmsg_add_u32(&b, "rx", sta_driver_data.rx_packets);
340 blobmsg_add_u32(&b, "tx", sta_driver_data.tx_packets);
341 blobmsg_close_table(&b, r);
342 r = blobmsg_open_table(&b, "rate");
343 /* Rate in kbits */
344 blobmsg_add_u32(&b, "rx", sta_driver_data.current_rx_rate * 100);
345 blobmsg_add_u32(&b, "tx", sta_driver_data.current_tx_rate * 100);
346 blobmsg_close_table(&b, r);
347 blobmsg_add_u32(&b, "signal", sta_driver_data.signal);
348 }
349
350 hostapd_parse_capab_blobmsg(sta);
351
352 blobmsg_close_table(&b, c);
353 }
354 blobmsg_close_array(&b, list);
355 ubus_send_reply(ctx, req, b.head);
356
357 return 0;
358 }
359
360 static int
361 hostapd_bss_get_features(struct ubus_context *ctx, struct ubus_object *obj,
362 struct ubus_request_data *req, const char *method,
363 struct blob_attr *msg)
364 {
365 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
366
367 blob_buf_init(&b, 0);
368 blobmsg_add_u8(&b, "ht_supported", ht_supported(hapd->iface->hw_features));
369 blobmsg_add_u8(&b, "vht_supported", vht_supported(hapd->iface->hw_features));
370 ubus_send_reply(ctx, req, b.head);
371
372 return 0;
373 }
374
375 static int
376 hostapd_bss_get_status(struct ubus_context *ctx, struct ubus_object *obj,
377 struct ubus_request_data *req, const char *method,
378 struct blob_attr *msg)
379 {
380 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
381 void *airtime_table, *dfs_table;
382 struct os_reltime now;
383 char phy_name[17];
384 char mac_buf[20];
385
386 blob_buf_init(&b, 0);
387 blobmsg_add_string(&b, "status", hostapd_state_text(hapd->iface->state));
388 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
389
390 snprintf(phy_name, 17, "%s", hapd->iface->phy);
391 blobmsg_add_string(&b, "phy", phy_name);
392
393 /* Airtime */
394 airtime_table = blobmsg_open_table(&b, "airtime");
395 blobmsg_add_u64(&b, "time", hapd->iface->last_channel_time);
396 blobmsg_add_u64(&b, "time_busy", hapd->iface->last_channel_time_busy);
397 blobmsg_add_u16(&b, "utilization", hapd->iface->channel_utilization);
398 blobmsg_close_table(&b, airtime_table);
399
400 /* DFS */
401 dfs_table = blobmsg_open_table(&b, "dfs");
402 blobmsg_add_u32(&b, "cac_seconds", hapd->iface->dfs_cac_ms / 1000);
403 blobmsg_add_u8(&b, "cac_active", !!(hapd->iface->cac_started));
404 os_reltime_age(&hapd->iface->dfs_cac_start, &now);
405 blobmsg_add_u32(&b, "cac_seconds_left",
406 hapd->iface->cac_started ? hapd->iface->dfs_cac_ms / 1000 - now.sec : 0);
407 blobmsg_close_table(&b, dfs_table);
408
409 ubus_send_reply(ctx, req, b.head);
410
411 return 0;
412 }
413
414 enum {
415 NOTIFY_RESPONSE,
416 __NOTIFY_MAX
417 };
418
419 static const struct blobmsg_policy notify_policy[__NOTIFY_MAX] = {
420 [NOTIFY_RESPONSE] = { "notify_response", BLOBMSG_TYPE_INT32 },
421 };
422
423 static int
424 hostapd_notify_response(struct ubus_context *ctx, struct ubus_object *obj,
425 struct ubus_request_data *req, const char *method,
426 struct blob_attr *msg)
427 {
428 struct blob_attr *tb[__NOTIFY_MAX];
429 struct hostapd_data *hapd = get_hapd_from_object(obj);
430 struct wpabuf *elems;
431 const char *pos;
432 size_t len;
433
434 blobmsg_parse(notify_policy, __NOTIFY_MAX, tb,
435 blob_data(msg), blob_len(msg));
436
437 if (!tb[NOTIFY_RESPONSE])
438 return UBUS_STATUS_INVALID_ARGUMENT;
439
440 hapd->ubus.notify_response = blobmsg_get_u32(tb[NOTIFY_RESPONSE]);
441
442 return UBUS_STATUS_OK;
443 }
444
445 enum {
446 DEL_CLIENT_ADDR,
447 DEL_CLIENT_REASON,
448 DEL_CLIENT_DEAUTH,
449 DEL_CLIENT_BAN_TIME,
450 __DEL_CLIENT_MAX
451 };
452
453 static const struct blobmsg_policy del_policy[__DEL_CLIENT_MAX] = {
454 [DEL_CLIENT_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
455 [DEL_CLIENT_REASON] = { "reason", BLOBMSG_TYPE_INT32 },
456 [DEL_CLIENT_DEAUTH] = { "deauth", BLOBMSG_TYPE_INT8 },
457 [DEL_CLIENT_BAN_TIME] = { "ban_time", BLOBMSG_TYPE_INT32 },
458 };
459
460 static int
461 hostapd_bss_del_client(struct ubus_context *ctx, struct ubus_object *obj,
462 struct ubus_request_data *req, const char *method,
463 struct blob_attr *msg)
464 {
465 struct blob_attr *tb[__DEL_CLIENT_MAX];
466 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
467 struct sta_info *sta;
468 bool deauth = false;
469 int reason;
470 u8 addr[ETH_ALEN];
471
472 blobmsg_parse(del_policy, __DEL_CLIENT_MAX, tb, blob_data(msg), blob_len(msg));
473
474 if (!tb[DEL_CLIENT_ADDR])
475 return UBUS_STATUS_INVALID_ARGUMENT;
476
477 if (hwaddr_aton(blobmsg_data(tb[DEL_CLIENT_ADDR]), addr))
478 return UBUS_STATUS_INVALID_ARGUMENT;
479
480 if (tb[DEL_CLIENT_REASON])
481 reason = blobmsg_get_u32(tb[DEL_CLIENT_REASON]);
482
483 if (tb[DEL_CLIENT_DEAUTH])
484 deauth = blobmsg_get_bool(tb[DEL_CLIENT_DEAUTH]);
485
486 sta = ap_get_sta(hapd, addr);
487 if (sta) {
488 if (deauth) {
489 hostapd_drv_sta_deauth(hapd, addr, reason);
490 ap_sta_deauthenticate(hapd, sta, reason);
491 } else {
492 hostapd_drv_sta_disassoc(hapd, addr, reason);
493 ap_sta_disassociate(hapd, sta, reason);
494 }
495 }
496
497 if (tb[DEL_CLIENT_BAN_TIME])
498 hostapd_bss_ban_client(hapd, addr, blobmsg_get_u32(tb[DEL_CLIENT_BAN_TIME]));
499
500 return 0;
501 }
502
503 static void
504 blobmsg_add_macaddr(struct blob_buf *buf, const char *name, const u8 *addr)
505 {
506 char *s;
507
508 s = blobmsg_alloc_string_buffer(buf, name, 20);
509 sprintf(s, MACSTR, MAC2STR(addr));
510 blobmsg_add_string_buffer(buf);
511 }
512
513 static int
514 hostapd_bss_list_bans(struct ubus_context *ctx, struct ubus_object *obj,
515 struct ubus_request_data *req, const char *method,
516 struct blob_attr *msg)
517 {
518 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
519 struct ubus_banned_client *ban;
520 void *c;
521
522 blob_buf_init(&b, 0);
523 c = blobmsg_open_array(&b, "clients");
524 avl_for_each_element(&hapd->ubus.banned, ban, avl)
525 blobmsg_add_macaddr(&b, NULL, ban->addr);
526 blobmsg_close_array(&b, c);
527 ubus_send_reply(ctx, req, b.head);
528
529 return 0;
530 }
531
532 #ifdef CONFIG_WPS
533 static int
534 hostapd_bss_wps_start(struct ubus_context *ctx, struct ubus_object *obj,
535 struct ubus_request_data *req, const char *method,
536 struct blob_attr *msg)
537 {
538 int rc;
539 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
540
541 rc = hostapd_wps_button_pushed(hapd, NULL);
542
543 if (rc != 0)
544 return UBUS_STATUS_NOT_SUPPORTED;
545
546 return 0;
547 }
548
549
550 static const char * pbc_status_enum_str(enum pbc_status status)
551 {
552 switch (status) {
553 case WPS_PBC_STATUS_DISABLE:
554 return "Disabled";
555 case WPS_PBC_STATUS_ACTIVE:
556 return "Active";
557 case WPS_PBC_STATUS_TIMEOUT:
558 return "Timed-out";
559 case WPS_PBC_STATUS_OVERLAP:
560 return "Overlap";
561 default:
562 return "Unknown";
563 }
564 }
565
566 static int
567 hostapd_bss_wps_status(struct ubus_context *ctx, struct ubus_object *obj,
568 struct ubus_request_data *req, const char *method,
569 struct blob_attr *msg)
570 {
571 int rc;
572 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
573
574 blob_buf_init(&b, 0);
575
576 blobmsg_add_string(&b, "pbc_status", pbc_status_enum_str(hapd->wps_stats.pbc_status));
577 blobmsg_add_string(&b, "last_wps_result",
578 (hapd->wps_stats.status == WPS_STATUS_SUCCESS ?
579 "Success":
580 (hapd->wps_stats.status == WPS_STATUS_FAILURE ?
581 "Failed" : "None")));
582
583 /* If status == Failure - Add possible Reasons */
584 if(hapd->wps_stats.status == WPS_STATUS_FAILURE &&
585 hapd->wps_stats.failure_reason > 0)
586 blobmsg_add_string(&b, "reason", wps_ei_str(hapd->wps_stats.failure_reason));
587
588 if (hapd->wps_stats.status)
589 blobmsg_printf(&b, "peer_address", MACSTR, MAC2STR(hapd->wps_stats.peer_addr));
590
591 ubus_send_reply(ctx, req, b.head);
592
593 return 0;
594 }
595
596 static int
597 hostapd_bss_wps_cancel(struct ubus_context *ctx, struct ubus_object *obj,
598 struct ubus_request_data *req, const char *method,
599 struct blob_attr *msg)
600 {
601 int rc;
602 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
603
604 rc = hostapd_wps_cancel(hapd);
605
606 if (rc != 0)
607 return UBUS_STATUS_NOT_SUPPORTED;
608
609 return 0;
610 }
611 #endif /* CONFIG_WPS */
612
613 static int
614 hostapd_bss_update_beacon(struct ubus_context *ctx, struct ubus_object *obj,
615 struct ubus_request_data *req, const char *method,
616 struct blob_attr *msg)
617 {
618 int rc;
619 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
620
621 rc = ieee802_11_set_beacon(hapd);
622
623 if (rc != 0)
624 return UBUS_STATUS_NOT_SUPPORTED;
625
626 return 0;
627 }
628
629 enum {
630 CONFIG_IFACE,
631 CONFIG_FILE,
632 __CONFIG_MAX
633 };
634
635 static const struct blobmsg_policy config_add_policy[__CONFIG_MAX] = {
636 [CONFIG_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
637 [CONFIG_FILE] = { "config", BLOBMSG_TYPE_STRING },
638 };
639
640 static int
641 hostapd_config_add(struct ubus_context *ctx, struct ubus_object *obj,
642 struct ubus_request_data *req, const char *method,
643 struct blob_attr *msg)
644 {
645 struct blob_attr *tb[__CONFIG_MAX];
646 struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
647 char buf[128];
648
649 blobmsg_parse(config_add_policy, __CONFIG_MAX, tb, blob_data(msg), blob_len(msg));
650
651 if (!tb[CONFIG_FILE] || !tb[CONFIG_IFACE])
652 return UBUS_STATUS_INVALID_ARGUMENT;
653
654 snprintf(buf, sizeof(buf), "bss_config=%s:%s",
655 blobmsg_get_string(tb[CONFIG_IFACE]),
656 blobmsg_get_string(tb[CONFIG_FILE]));
657
658 if (hostapd_add_iface(interfaces, buf))
659 return UBUS_STATUS_INVALID_ARGUMENT;
660
661 return UBUS_STATUS_OK;
662 }
663
664 enum {
665 CONFIG_REM_IFACE,
666 __CONFIG_REM_MAX
667 };
668
669 static const struct blobmsg_policy config_remove_policy[__CONFIG_REM_MAX] = {
670 [CONFIG_REM_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
671 };
672
673 static int
674 hostapd_config_remove(struct ubus_context *ctx, struct ubus_object *obj,
675 struct ubus_request_data *req, const char *method,
676 struct blob_attr *msg)
677 {
678 struct blob_attr *tb[__CONFIG_REM_MAX];
679 struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
680 char buf[128];
681
682 blobmsg_parse(config_remove_policy, __CONFIG_REM_MAX, tb, blob_data(msg), blob_len(msg));
683
684 if (!tb[CONFIG_REM_IFACE])
685 return UBUS_STATUS_INVALID_ARGUMENT;
686
687 if (hostapd_remove_iface(interfaces, blobmsg_get_string(tb[CONFIG_REM_IFACE])))
688 return UBUS_STATUS_INVALID_ARGUMENT;
689
690 return UBUS_STATUS_OK;
691 }
692
693 enum {
694 CSA_FREQ,
695 CSA_BCN_COUNT,
696 CSA_CENTER_FREQ1,
697 CSA_CENTER_FREQ2,
698 CSA_BANDWIDTH,
699 CSA_SEC_CHANNEL_OFFSET,
700 CSA_HT,
701 CSA_VHT,
702 CSA_BLOCK_TX,
703 __CSA_MAX
704 };
705
706 static const struct blobmsg_policy csa_policy[__CSA_MAX] = {
707 [CSA_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
708 [CSA_BCN_COUNT] = { "bcn_count", BLOBMSG_TYPE_INT32 },
709 [CSA_CENTER_FREQ1] = { "center_freq1", BLOBMSG_TYPE_INT32 },
710 [CSA_CENTER_FREQ2] = { "center_freq2", BLOBMSG_TYPE_INT32 },
711 [CSA_BANDWIDTH] = { "bandwidth", BLOBMSG_TYPE_INT32 },
712 [CSA_SEC_CHANNEL_OFFSET] = { "sec_channel_offset", BLOBMSG_TYPE_INT32 },
713 [CSA_HT] = { "ht", BLOBMSG_TYPE_BOOL },
714 [CSA_VHT] = { "vht", BLOBMSG_TYPE_BOOL },
715 [CSA_BLOCK_TX] = { "block_tx", BLOBMSG_TYPE_BOOL },
716 };
717
718 #ifdef NEED_AP_MLME
719 static int
720 hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
721 struct ubus_request_data *req, const char *method,
722 struct blob_attr *msg)
723 {
724 struct blob_attr *tb[__CSA_MAX];
725 struct hostapd_data *hapd = get_hapd_from_object(obj);
726 struct csa_settings css;
727
728 blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
729
730 if (!tb[CSA_FREQ])
731 return UBUS_STATUS_INVALID_ARGUMENT;
732
733 memset(&css, 0, sizeof(css));
734 css.freq_params.freq = blobmsg_get_u32(tb[CSA_FREQ]);
735
736 #define SET_CSA_SETTING(name, field, type) \
737 do { \
738 if (tb[name]) \
739 css.field = blobmsg_get_ ## type(tb[name]); \
740 } while(0)
741
742 SET_CSA_SETTING(CSA_BCN_COUNT, cs_count, u32);
743 SET_CSA_SETTING(CSA_CENTER_FREQ1, freq_params.center_freq1, u32);
744 SET_CSA_SETTING(CSA_CENTER_FREQ2, freq_params.center_freq2, u32);
745 SET_CSA_SETTING(CSA_BANDWIDTH, freq_params.bandwidth, u32);
746 SET_CSA_SETTING(CSA_SEC_CHANNEL_OFFSET, freq_params.sec_channel_offset, u32);
747 SET_CSA_SETTING(CSA_HT, freq_params.ht_enabled, bool);
748 SET_CSA_SETTING(CSA_VHT, freq_params.vht_enabled, bool);
749 SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
750
751
752 if (hostapd_switch_channel(hapd, &css) != 0)
753 return UBUS_STATUS_NOT_SUPPORTED;
754 return UBUS_STATUS_OK;
755 #undef SET_CSA_SETTING
756 }
757 #endif
758
759 enum {
760 VENDOR_ELEMENTS,
761 __VENDOR_ELEMENTS_MAX
762 };
763
764 static const struct blobmsg_policy ve_policy[__VENDOR_ELEMENTS_MAX] = {
765 /* vendor elements are provided as hex-string */
766 [VENDOR_ELEMENTS] = { "vendor_elements", BLOBMSG_TYPE_STRING },
767 };
768
769 static int
770 hostapd_vendor_elements(struct ubus_context *ctx, struct ubus_object *obj,
771 struct ubus_request_data *req, const char *method,
772 struct blob_attr *msg)
773 {
774 struct blob_attr *tb[__VENDOR_ELEMENTS_MAX];
775 struct hostapd_data *hapd = get_hapd_from_object(obj);
776 struct hostapd_bss_config *bss = hapd->conf;
777 struct wpabuf *elems;
778 const char *pos;
779 size_t len;
780
781 blobmsg_parse(ve_policy, __VENDOR_ELEMENTS_MAX, tb,
782 blob_data(msg), blob_len(msg));
783
784 if (!tb[VENDOR_ELEMENTS])
785 return UBUS_STATUS_INVALID_ARGUMENT;
786
787 pos = blobmsg_data(tb[VENDOR_ELEMENTS]);
788 len = os_strlen(pos);
789 if (len & 0x01)
790 return UBUS_STATUS_INVALID_ARGUMENT;
791
792 len /= 2;
793 if (len == 0) {
794 wpabuf_free(bss->vendor_elements);
795 bss->vendor_elements = NULL;
796 return 0;
797 }
798
799 elems = wpabuf_alloc(len);
800 if (elems == NULL)
801 return 1;
802
803 if (hexstr2bin(pos, wpabuf_put(elems, len), len)) {
804 wpabuf_free(elems);
805 return UBUS_STATUS_INVALID_ARGUMENT;
806 }
807
808 wpabuf_free(bss->vendor_elements);
809 bss->vendor_elements = elems;
810
811 /* update beacons if vendor elements were set successfully */
812 if (ieee802_11_update_beacons(hapd->iface) != 0)
813 return UBUS_STATUS_NOT_SUPPORTED;
814 return UBUS_STATUS_OK;
815 }
816
817 static void
818 hostapd_rrm_print_nr(struct hostapd_neighbor_entry *nr)
819 {
820 const u8 *data;
821 char *str;
822 int len;
823
824 blobmsg_printf(&b, "", MACSTR, MAC2STR(nr->bssid));
825
826 str = blobmsg_alloc_string_buffer(&b, "", nr->ssid.ssid_len + 1);
827 memcpy(str, nr->ssid.ssid, nr->ssid.ssid_len);
828 str[nr->ssid.ssid_len] = 0;
829 blobmsg_add_string_buffer(&b);
830
831 len = wpabuf_len(nr->nr);
832 str = blobmsg_alloc_string_buffer(&b, "", 2 * len + 1);
833 wpa_snprintf_hex(str, 2 * len + 1, wpabuf_head_u8(nr->nr), len);
834 blobmsg_add_string_buffer(&b);
835 }
836
837 enum {
838 BSS_MGMT_EN_NEIGHBOR,
839 BSS_MGMT_EN_BEACON,
840 #ifdef CONFIG_WNM_AP
841 BSS_MGMT_EN_BSS_TRANSITION,
842 #endif
843 __BSS_MGMT_EN_MAX
844 };
845
846 static bool
847 __hostapd_bss_mgmt_enable_f(struct hostapd_data *hapd, int flag)
848 {
849 struct hostapd_bss_config *bss = hapd->conf;
850 uint32_t flags;
851
852 switch (flag) {
853 case BSS_MGMT_EN_NEIGHBOR:
854 if (bss->radio_measurements[0] &
855 WLAN_RRM_CAPS_NEIGHBOR_REPORT)
856 return false;
857
858 bss->radio_measurements[0] |=
859 WLAN_RRM_CAPS_NEIGHBOR_REPORT;
860 hostapd_neighbor_set_own_report(hapd);
861 return true;
862 case BSS_MGMT_EN_BEACON:
863 flags = WLAN_RRM_CAPS_BEACON_REPORT_PASSIVE |
864 WLAN_RRM_CAPS_BEACON_REPORT_ACTIVE |
865 WLAN_RRM_CAPS_BEACON_REPORT_TABLE;
866
867 if (bss->radio_measurements[0] & flags == flags)
868 return false;
869
870 bss->radio_measurements[0] |= (u8) flags;
871 return true;
872 #ifdef CONFIG_WNM_AP
873 case BSS_MGMT_EN_BSS_TRANSITION:
874 if (bss->bss_transition)
875 return false;
876
877 bss->bss_transition = 1;
878 return true;
879 #endif
880 }
881 }
882
883 static void
884 __hostapd_bss_mgmt_enable(struct hostapd_data *hapd, uint32_t flags)
885 {
886 bool update = false;
887 int i;
888
889 for (i = 0; i < __BSS_MGMT_EN_MAX; i++) {
890 if (!(flags & (1 << i)))
891 continue;
892
893 update |= __hostapd_bss_mgmt_enable_f(hapd, i);
894 }
895
896 if (update)
897 ieee802_11_update_beacons(hapd->iface);
898 }
899
900
901 static const struct blobmsg_policy bss_mgmt_enable_policy[__BSS_MGMT_EN_MAX] = {
902 [BSS_MGMT_EN_NEIGHBOR] = { "neighbor_report", BLOBMSG_TYPE_BOOL },
903 [BSS_MGMT_EN_BEACON] = { "beacon_report", BLOBMSG_TYPE_BOOL },
904 #ifdef CONFIG_WNM_AP
905 [BSS_MGMT_EN_BSS_TRANSITION] = { "bss_transition", BLOBMSG_TYPE_BOOL },
906 #endif
907 };
908
909 static int
910 hostapd_bss_mgmt_enable(struct ubus_context *ctx, struct ubus_object *obj,
911 struct ubus_request_data *req, const char *method,
912 struct blob_attr *msg)
913
914 {
915 struct hostapd_data *hapd = get_hapd_from_object(obj);
916 struct blob_attr *tb[__BSS_MGMT_EN_MAX];
917 struct blob_attr *cur;
918 uint32_t flags = 0;
919 int i;
920 bool neigh = false, beacon = false;
921
922 blobmsg_parse(bss_mgmt_enable_policy, __BSS_MGMT_EN_MAX, tb, blob_data(msg), blob_len(msg));
923
924 for (i = 0; i < ARRAY_SIZE(tb); i++) {
925 if (!tb[i] || !blobmsg_get_bool(tb[i]))
926 continue;
927
928 flags |= (1 << i);
929 }
930
931 __hostapd_bss_mgmt_enable(hapd, flags);
932 }
933
934
935 static void
936 hostapd_rrm_nr_enable(struct hostapd_data *hapd)
937 {
938 __hostapd_bss_mgmt_enable(hapd, 1 << BSS_MGMT_EN_NEIGHBOR);
939 }
940
941 static int
942 hostapd_rrm_nr_get_own(struct ubus_context *ctx, struct ubus_object *obj,
943 struct ubus_request_data *req, const char *method,
944 struct blob_attr *msg)
945 {
946 struct hostapd_data *hapd = get_hapd_from_object(obj);
947 struct hostapd_neighbor_entry *nr;
948 void *c;
949
950 hostapd_rrm_nr_enable(hapd);
951
952 nr = hostapd_neighbor_get(hapd, hapd->own_addr, NULL);
953 if (!nr)
954 return UBUS_STATUS_NOT_FOUND;
955
956 blob_buf_init(&b, 0);
957
958 c = blobmsg_open_array(&b, "value");
959 hostapd_rrm_print_nr(nr);
960 blobmsg_close_array(&b, c);
961
962 ubus_send_reply(ctx, req, b.head);
963
964 return 0;
965 }
966
967 static int
968 hostapd_rrm_nr_list(struct ubus_context *ctx, struct ubus_object *obj,
969 struct ubus_request_data *req, const char *method,
970 struct blob_attr *msg)
971 {
972 struct hostapd_data *hapd = get_hapd_from_object(obj);
973 struct hostapd_neighbor_entry *nr;
974 void *c;
975
976 hostapd_rrm_nr_enable(hapd);
977 blob_buf_init(&b, 0);
978
979 c = blobmsg_open_array(&b, "list");
980 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
981 void *cur;
982
983 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
984 continue;
985
986 cur = blobmsg_open_array(&b, NULL);
987 hostapd_rrm_print_nr(nr);
988 blobmsg_close_array(&b, cur);
989 }
990 blobmsg_close_array(&b, c);
991
992 ubus_send_reply(ctx, req, b.head);
993
994 return 0;
995 }
996
997 enum {
998 NR_SET_LIST,
999 __NR_SET_LIST_MAX
1000 };
1001
1002 static const struct blobmsg_policy nr_set_policy[__NR_SET_LIST_MAX] = {
1003 [NR_SET_LIST] = { "list", BLOBMSG_TYPE_ARRAY },
1004 };
1005
1006
1007 static void
1008 hostapd_rrm_nr_clear(struct hostapd_data *hapd)
1009 {
1010 struct hostapd_neighbor_entry *nr;
1011
1012 restart:
1013 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
1014 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
1015 continue;
1016
1017 hostapd_neighbor_remove(hapd, nr->bssid, &nr->ssid);
1018 goto restart;
1019 }
1020 }
1021
1022 static int
1023 hostapd_rrm_nr_set(struct ubus_context *ctx, struct ubus_object *obj,
1024 struct ubus_request_data *req, const char *method,
1025 struct blob_attr *msg)
1026 {
1027 static const struct blobmsg_policy nr_e_policy[] = {
1028 { .type = BLOBMSG_TYPE_STRING },
1029 { .type = BLOBMSG_TYPE_STRING },
1030 { .type = BLOBMSG_TYPE_STRING },
1031 };
1032 struct hostapd_data *hapd = get_hapd_from_object(obj);
1033 struct blob_attr *tb_l[__NR_SET_LIST_MAX];
1034 struct blob_attr *tb[ARRAY_SIZE(nr_e_policy)];
1035 struct blob_attr *cur;
1036 int rem;
1037
1038 hostapd_rrm_nr_enable(hapd);
1039
1040 blobmsg_parse(nr_set_policy, __NR_SET_LIST_MAX, tb_l, blob_data(msg), blob_len(msg));
1041 if (!tb_l[NR_SET_LIST])
1042 return UBUS_STATUS_INVALID_ARGUMENT;
1043
1044 hostapd_rrm_nr_clear(hapd);
1045 blobmsg_for_each_attr(cur, tb_l[NR_SET_LIST], rem) {
1046 struct wpa_ssid_value ssid;
1047 struct wpabuf *data;
1048 u8 bssid[ETH_ALEN];
1049 char *s, *nr_s;
1050
1051 blobmsg_parse_array(nr_e_policy, ARRAY_SIZE(nr_e_policy), tb, blobmsg_data(cur), blobmsg_data_len(cur));
1052 if (!tb[0] || !tb[1] || !tb[2])
1053 goto invalid;
1054
1055 /* Neighbor Report binary */
1056 nr_s = blobmsg_get_string(tb[2]);
1057 data = wpabuf_parse_bin(nr_s);
1058 if (!data)
1059 goto invalid;
1060
1061 /* BSSID */
1062 s = blobmsg_get_string(tb[0]);
1063 if (strlen(s) == 0) {
1064 /* Copy BSSID from neighbor report */
1065 if (hwaddr_compact_aton(nr_s, bssid))
1066 goto invalid;
1067 } else if (hwaddr_aton(s, bssid)) {
1068 goto invalid;
1069 }
1070
1071 /* SSID */
1072 s = blobmsg_get_string(tb[1]);
1073 if (strlen(s) == 0) {
1074 /* Copy SSID from hostapd BSS conf */
1075 memcpy(&ssid, &hapd->conf->ssid, sizeof(ssid));
1076 } else {
1077 ssid.ssid_len = strlen(s);
1078 if (ssid.ssid_len > sizeof(ssid.ssid))
1079 goto invalid;
1080
1081 memcpy(&ssid, s, ssid.ssid_len);
1082 }
1083
1084 hostapd_neighbor_set(hapd, bssid, &ssid, data, NULL, NULL, 0);
1085 wpabuf_free(data);
1086 continue;
1087
1088 invalid:
1089 return UBUS_STATUS_INVALID_ARGUMENT;
1090 }
1091
1092 return 0;
1093 }
1094
1095 enum {
1096 BEACON_REQ_ADDR,
1097 BEACON_REQ_MODE,
1098 BEACON_REQ_OP_CLASS,
1099 BEACON_REQ_CHANNEL,
1100 BEACON_REQ_DURATION,
1101 BEACON_REQ_BSSID,
1102 BEACON_REQ_SSID,
1103 __BEACON_REQ_MAX,
1104 };
1105
1106 static const struct blobmsg_policy beacon_req_policy[__BEACON_REQ_MAX] = {
1107 [BEACON_REQ_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1108 [BEACON_REQ_OP_CLASS] { "op_class", BLOBMSG_TYPE_INT32 },
1109 [BEACON_REQ_CHANNEL] { "channel", BLOBMSG_TYPE_INT32 },
1110 [BEACON_REQ_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1111 [BEACON_REQ_MODE] { "mode", BLOBMSG_TYPE_INT32 },
1112 [BEACON_REQ_BSSID] { "bssid", BLOBMSG_TYPE_STRING },
1113 [BEACON_REQ_SSID] { "ssid", BLOBMSG_TYPE_STRING },
1114 };
1115
1116 static int
1117 hostapd_rrm_beacon_req(struct ubus_context *ctx, struct ubus_object *obj,
1118 struct ubus_request_data *ureq, const char *method,
1119 struct blob_attr *msg)
1120 {
1121 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1122 struct blob_attr *tb[__BEACON_REQ_MAX];
1123 struct blob_attr *cur;
1124 struct wpabuf *req;
1125 u8 bssid[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1126 u8 addr[ETH_ALEN];
1127 int mode, rem, ret;
1128 int buf_len = 13;
1129
1130 blobmsg_parse(beacon_req_policy, __BEACON_REQ_MAX, tb, blob_data(msg), blob_len(msg));
1131
1132 if (!tb[BEACON_REQ_ADDR] || !tb[BEACON_REQ_MODE] || !tb[BEACON_REQ_DURATION] ||
1133 !tb[BEACON_REQ_OP_CLASS] || !tb[BEACON_REQ_CHANNEL])
1134 return UBUS_STATUS_INVALID_ARGUMENT;
1135
1136 if (tb[BEACON_REQ_SSID])
1137 buf_len += blobmsg_data_len(tb[BEACON_REQ_SSID]) + 2 - 1;
1138
1139 mode = blobmsg_get_u32(tb[BEACON_REQ_MODE]);
1140 if (hwaddr_aton(blobmsg_data(tb[BEACON_REQ_ADDR]), addr))
1141 return UBUS_STATUS_INVALID_ARGUMENT;
1142
1143 if (tb[BEACON_REQ_BSSID] &&
1144 hwaddr_aton(blobmsg_data(tb[BEACON_REQ_BSSID]), bssid))
1145 return UBUS_STATUS_INVALID_ARGUMENT;
1146
1147 req = wpabuf_alloc(buf_len);
1148 if (!req)
1149 return UBUS_STATUS_UNKNOWN_ERROR;
1150
1151 /* 1: regulatory class */
1152 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_OP_CLASS]));
1153
1154 /* 2: channel number */
1155 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_CHANNEL]));
1156
1157 /* 3-4: randomization interval */
1158 wpabuf_put_le16(req, 0);
1159
1160 /* 5-6: duration */
1161 wpabuf_put_le16(req, blobmsg_get_u32(tb[BEACON_REQ_DURATION]));
1162
1163 /* 7: mode */
1164 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_MODE]));
1165
1166 /* 8-13: BSSID */
1167 wpabuf_put_data(req, bssid, ETH_ALEN);
1168
1169 if ((cur = tb[BEACON_REQ_SSID]) != NULL) {
1170 wpabuf_put_u8(req, WLAN_EID_SSID);
1171 wpabuf_put_u8(req, blobmsg_data_len(cur) - 1);
1172 wpabuf_put_data(req, blobmsg_data(cur), blobmsg_data_len(cur) - 1);
1173 }
1174
1175 ret = hostapd_send_beacon_req(hapd, addr, 0, req);
1176 if (ret < 0)
1177 return -ret;
1178
1179 return 0;
1180 }
1181
1182
1183 #ifdef CONFIG_WNM_AP
1184 enum {
1185 WNM_DISASSOC_ADDR,
1186 WNM_DISASSOC_DURATION,
1187 WNM_DISASSOC_NEIGHBORS,
1188 WNM_DISASSOC_ABRIDGED,
1189 __WNM_DISASSOC_MAX,
1190 };
1191
1192 static const struct blobmsg_policy wnm_disassoc_policy[__WNM_DISASSOC_MAX] = {
1193 [WNM_DISASSOC_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1194 [WNM_DISASSOC_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1195 [WNM_DISASSOC_NEIGHBORS] { "neighbors", BLOBMSG_TYPE_ARRAY },
1196 [WNM_DISASSOC_ABRIDGED] { "abridged", BLOBMSG_TYPE_BOOL },
1197 };
1198
1199 static int
1200 hostapd_wnm_disassoc_imminent(struct ubus_context *ctx, struct ubus_object *obj,
1201 struct ubus_request_data *ureq, const char *method,
1202 struct blob_attr *msg)
1203 {
1204 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1205 struct blob_attr *tb[__WNM_DISASSOC_MAX];
1206 struct blob_attr *cur;
1207 struct sta_info *sta;
1208 int duration = 10;
1209 int rem;
1210 int nr_len = 0;
1211 u8 *nr = NULL;
1212 u8 req_mode = WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
1213 u8 addr[ETH_ALEN];
1214
1215 blobmsg_parse(wnm_disassoc_policy, __WNM_DISASSOC_MAX, tb, blob_data(msg), blob_len(msg));
1216
1217 if (!tb[WNM_DISASSOC_ADDR])
1218 return UBUS_STATUS_INVALID_ARGUMENT;
1219
1220 if (hwaddr_aton(blobmsg_data(tb[WNM_DISASSOC_ADDR]), addr))
1221 return UBUS_STATUS_INVALID_ARGUMENT;
1222
1223 if ((cur = tb[WNM_DISASSOC_DURATION]) != NULL)
1224 duration = blobmsg_get_u32(cur);
1225
1226 sta = ap_get_sta(hapd, addr);
1227 if (!sta)
1228 return UBUS_STATUS_NOT_FOUND;
1229
1230 if (tb[WNM_DISASSOC_NEIGHBORS]) {
1231 u8 *nr_cur;
1232
1233 if (blobmsg_check_array(tb[WNM_DISASSOC_NEIGHBORS],
1234 BLOBMSG_TYPE_STRING) < 0)
1235 return UBUS_STATUS_INVALID_ARGUMENT;
1236
1237 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1238 int len = strlen(blobmsg_get_string(cur));
1239
1240 if (len % 2)
1241 return UBUS_STATUS_INVALID_ARGUMENT;
1242
1243 nr_len += (len / 2) + 2;
1244 }
1245
1246 if (nr_len) {
1247 nr = os_zalloc(nr_len);
1248 if (!nr)
1249 return UBUS_STATUS_UNKNOWN_ERROR;
1250 }
1251
1252 nr_cur = nr;
1253 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1254 int len = strlen(blobmsg_get_string(cur)) / 2;
1255
1256 *nr_cur++ = WLAN_EID_NEIGHBOR_REPORT;
1257 *nr_cur++ = (u8) len;
1258 if (hexstr2bin(blobmsg_data(cur), nr_cur, len)) {
1259 free(nr);
1260 return UBUS_STATUS_INVALID_ARGUMENT;
1261 }
1262
1263 nr_cur += len;
1264 }
1265 }
1266
1267 if (nr)
1268 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
1269
1270 if (tb[WNM_DISASSOC_ABRIDGED] && blobmsg_get_bool(tb[WNM_DISASSOC_ABRIDGED]))
1271 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
1272
1273 if (wnm_send_bss_tm_req(hapd, sta, req_mode, duration, duration, NULL,
1274 NULL, nr, nr_len, NULL, 0))
1275 return UBUS_STATUS_UNKNOWN_ERROR;
1276
1277 return 0;
1278 }
1279 #endif
1280
1281 static const struct ubus_method bss_methods[] = {
1282 UBUS_METHOD_NOARG("reload", hostapd_bss_reload),
1283 UBUS_METHOD_NOARG("get_clients", hostapd_bss_get_clients),
1284 UBUS_METHOD_NOARG("get_status", hostapd_bss_get_status),
1285 UBUS_METHOD("del_client", hostapd_bss_del_client, del_policy),
1286 UBUS_METHOD_NOARG("list_bans", hostapd_bss_list_bans),
1287 #ifdef CONFIG_WPS
1288 UBUS_METHOD_NOARG("wps_start", hostapd_bss_wps_start),
1289 UBUS_METHOD_NOARG("wps_status", hostapd_bss_wps_status),
1290 UBUS_METHOD_NOARG("wps_cancel", hostapd_bss_wps_cancel),
1291 #endif
1292 UBUS_METHOD_NOARG("update_beacon", hostapd_bss_update_beacon),
1293 UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features),
1294 #ifdef NEED_AP_MLME
1295 UBUS_METHOD("switch_chan", hostapd_switch_chan, csa_policy),
1296 #endif
1297 UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements, ve_policy),
1298 UBUS_METHOD("notify_response", hostapd_notify_response, notify_policy),
1299 UBUS_METHOD("bss_mgmt_enable", hostapd_bss_mgmt_enable, bss_mgmt_enable_policy),
1300 UBUS_METHOD_NOARG("rrm_nr_get_own", hostapd_rrm_nr_get_own),
1301 UBUS_METHOD_NOARG("rrm_nr_list", hostapd_rrm_nr_list),
1302 UBUS_METHOD("rrm_nr_set", hostapd_rrm_nr_set, nr_set_policy),
1303 UBUS_METHOD("rrm_beacon_req", hostapd_rrm_beacon_req, beacon_req_policy),
1304 #ifdef CONFIG_WNM_AP
1305 UBUS_METHOD("wnm_disassoc_imminent", hostapd_wnm_disassoc_imminent, wnm_disassoc_policy),
1306 #endif
1307 };
1308
1309 static struct ubus_object_type bss_object_type =
1310 UBUS_OBJECT_TYPE("hostapd_bss", bss_methods);
1311
1312 static int avl_compare_macaddr(const void *k1, const void *k2, void *ptr)
1313 {
1314 return memcmp(k1, k2, ETH_ALEN);
1315 }
1316
1317 void hostapd_ubus_add_bss(struct hostapd_data *hapd)
1318 {
1319 struct ubus_object *obj = &hapd->ubus.obj;
1320 char *name;
1321 int ret;
1322
1323 #ifdef CONFIG_MESH
1324 if (hapd->conf->mesh & MESH_ENABLED)
1325 return;
1326 #endif
1327
1328 if (!hostapd_ubus_init())
1329 return;
1330
1331 if (asprintf(&name, "hostapd.%s", hapd->conf->iface) < 0)
1332 return;
1333
1334 avl_init(&hapd->ubus.banned, avl_compare_macaddr, false, NULL);
1335 obj->name = name;
1336 obj->type = &bss_object_type;
1337 obj->methods = bss_object_type.methods;
1338 obj->n_methods = bss_object_type.n_methods;
1339 ret = ubus_add_object(ctx, obj);
1340 hostapd_ubus_ref_inc();
1341
1342 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "add");
1343 }
1344
1345 void hostapd_ubus_free_bss(struct hostapd_data *hapd)
1346 {
1347 struct ubus_object *obj = &hapd->ubus.obj;
1348 char *name = (char *) obj->name;
1349
1350 if (!ctx)
1351 return;
1352
1353 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "remove");
1354
1355 if (obj->id) {
1356 ubus_remove_object(ctx, obj);
1357 hostapd_ubus_ref_dec();
1358 }
1359
1360 free(name);
1361 }
1362
1363 static const struct ubus_method daemon_methods[] = {
1364 UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
1365 UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
1366 };
1367
1368 static struct ubus_object_type daemon_object_type =
1369 UBUS_OBJECT_TYPE("hostapd", daemon_methods);
1370
1371 void hostapd_ubus_add(struct hapd_interfaces *interfaces)
1372 {
1373 struct ubus_object *obj = &interfaces->ubus;
1374 int ret;
1375
1376 if (!hostapd_ubus_init())
1377 return;
1378
1379 obj->name = strdup("hostapd");
1380
1381 obj->type = &daemon_object_type;
1382 obj->methods = daemon_object_type.methods;
1383 obj->n_methods = daemon_object_type.n_methods;
1384 ret = ubus_add_object(ctx, obj);
1385 hostapd_ubus_ref_inc();
1386 }
1387
1388 void hostapd_ubus_free(struct hapd_interfaces *interfaces)
1389 {
1390 struct ubus_object *obj = &interfaces->ubus;
1391 char *name = (char *) obj->name;
1392
1393 if (!ctx)
1394 return;
1395
1396 if (obj->id) {
1397 ubus_remove_object(ctx, obj);
1398 hostapd_ubus_ref_dec();
1399 }
1400
1401 free(name);
1402 }
1403
1404 struct ubus_event_req {
1405 struct ubus_notify_request nreq;
1406 int resp;
1407 };
1408
1409 static void
1410 ubus_event_cb(struct ubus_notify_request *req, int idx, int ret)
1411 {
1412 struct ubus_event_req *ureq = container_of(req, struct ubus_event_req, nreq);
1413
1414 ureq->resp = ret;
1415 }
1416
1417 int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
1418 {
1419 struct ubus_banned_client *ban;
1420 const char *types[HOSTAPD_UBUS_TYPE_MAX] = {
1421 [HOSTAPD_UBUS_PROBE_REQ] = "probe",
1422 [HOSTAPD_UBUS_AUTH_REQ] = "auth",
1423 [HOSTAPD_UBUS_ASSOC_REQ] = "assoc",
1424 };
1425 const char *type = "mgmt";
1426 struct ubus_event_req ureq = {};
1427 const u8 *addr;
1428
1429 if (req->mgmt_frame)
1430 addr = req->mgmt_frame->sa;
1431 else
1432 addr = req->addr;
1433
1434 ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
1435 if (ban)
1436 return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
1437
1438 if (!hapd->ubus.obj.has_subscribers)
1439 return WLAN_STATUS_SUCCESS;
1440
1441 if (req->type < ARRAY_SIZE(types))
1442 type = types[req->type];
1443
1444 blob_buf_init(&b, 0);
1445 blobmsg_add_macaddr(&b, "address", addr);
1446 if (req->mgmt_frame)
1447 blobmsg_add_macaddr(&b, "target", req->mgmt_frame->da);
1448 if (req->ssi_signal)
1449 blobmsg_add_u32(&b, "signal", req->ssi_signal);
1450 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
1451
1452 if (req->elems) {
1453 if(req->elems->ht_capabilities)
1454 {
1455 struct ieee80211_ht_capabilities *ht_capabilities;
1456 void *ht_cap, *ht_cap_mcs_set, *mcs_set;
1457
1458
1459 ht_capabilities = (struct ieee80211_ht_capabilities*) req->elems->ht_capabilities;
1460 ht_cap = blobmsg_open_table(&b, "ht_capabilities");
1461 blobmsg_add_u16(&b, "ht_capabilities_info", ht_capabilities->ht_capabilities_info);
1462 ht_cap_mcs_set = blobmsg_open_table(&b, "supported_mcs_set");
1463 blobmsg_add_u16(&b, "a_mpdu_params", ht_capabilities->a_mpdu_params);
1464 blobmsg_add_u16(&b, "ht_extended_capabilities", ht_capabilities->ht_extended_capabilities);
1465 blobmsg_add_u32(&b, "tx_bf_capability_info", ht_capabilities->tx_bf_capability_info);
1466 blobmsg_add_u16(&b, "asel_capabilities", ht_capabilities->asel_capabilities);
1467 mcs_set = blobmsg_open_array(&b, "supported_mcs_set");
1468 for (int i = 0; i < 16; i++) {
1469 blobmsg_add_u16(&b, NULL, (u16) ht_capabilities->supported_mcs_set[i]);
1470 }
1471 blobmsg_close_array(&b, mcs_set);
1472 blobmsg_close_table(&b, ht_cap_mcs_set);
1473 blobmsg_close_table(&b, ht_cap);
1474 }
1475 if(req->elems->vht_capabilities)
1476 {
1477 struct ieee80211_vht_capabilities *vht_capabilities;
1478 void *vht_cap, *vht_cap_mcs_set;
1479
1480 vht_capabilities = (struct ieee80211_vht_capabilities*) req->elems->vht_capabilities;
1481 vht_cap = blobmsg_open_table(&b, "vht_capabilities");
1482 blobmsg_add_u32(&b, "vht_capabilities_info", vht_capabilities->vht_capabilities_info);
1483 vht_cap_mcs_set = blobmsg_open_table(&b, "vht_supported_mcs_set");
1484 blobmsg_add_u16(&b, "rx_map", vht_capabilities->vht_supported_mcs_set.rx_map);
1485 blobmsg_add_u16(&b, "rx_highest", vht_capabilities->vht_supported_mcs_set.rx_highest);
1486 blobmsg_add_u16(&b, "tx_map", vht_capabilities->vht_supported_mcs_set.tx_map);
1487 blobmsg_add_u16(&b, "tx_highest", vht_capabilities->vht_supported_mcs_set.tx_highest);
1488 blobmsg_close_table(&b, vht_cap_mcs_set);
1489 blobmsg_close_table(&b, vht_cap);
1490 }
1491 }
1492
1493 if (!hapd->ubus.notify_response) {
1494 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1495 return WLAN_STATUS_SUCCESS;
1496 }
1497
1498 if (ubus_notify_async(ctx, &hapd->ubus.obj, type, b.head, &ureq.nreq))
1499 return WLAN_STATUS_SUCCESS;
1500
1501 ureq.nreq.status_cb = ubus_event_cb;
1502 ubus_complete_request(ctx, &ureq.nreq.req, 100);
1503
1504 if (ureq.resp)
1505 return ureq.resp;
1506
1507 return WLAN_STATUS_SUCCESS;
1508 }
1509
1510 void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *addr)
1511 {
1512 if (!hapd->ubus.obj.has_subscribers)
1513 return;
1514
1515 if (!addr)
1516 return;
1517
1518 blob_buf_init(&b, 0);
1519 blobmsg_add_macaddr(&b, "address", addr);
1520
1521 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1522 }
1523
1524 void hostapd_ubus_notify_beacon_report(
1525 struct hostapd_data *hapd, const u8 *addr, u8 token, u8 rep_mode,
1526 struct rrm_measurement_beacon_report *rep, size_t len)
1527 {
1528 if (!hapd->ubus.obj.has_subscribers)
1529 return;
1530
1531 if (!addr || !rep)
1532 return;
1533
1534 blob_buf_init(&b, 0);
1535 blobmsg_add_macaddr(&b, "address", addr);
1536 blobmsg_add_u16(&b, "op-class", rep->op_class);
1537 blobmsg_add_u16(&b, "channel", rep->channel);
1538 blobmsg_add_u64(&b, "start-time", rep->start_time);
1539 blobmsg_add_u16(&b, "duration", rep->duration);
1540 blobmsg_add_u16(&b, "report-info", rep->report_info);
1541 blobmsg_add_u16(&b, "rcpi", rep->rcpi);
1542 blobmsg_add_u16(&b, "rsni", rep->rsni);
1543 blobmsg_add_macaddr(&b, "bssid", rep->bssid);
1544 blobmsg_add_u16(&b, "antenna-id", rep->antenna_id);
1545 blobmsg_add_u16(&b, "parent-tsf", rep->parent_tsf);
1546
1547 ubus_notify(ctx, &hapd->ubus.obj, "beacon-report", b.head, -1);
1548 }
Staging tree of Stijn Tintel