projects / openwrt / staging / mkresin.git / blob
? search:


3066765e67de50ff0bbd85233939d33e9161c79e
[openwrt/staging/mkresin.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 #include "airtime_policy.h"
25
26 static struct ubus_context *ctx;
27 static struct blob_buf b;
28 static int ctx_ref;
29
30 static inline struct hapd_interfaces *get_hapd_interfaces_from_object(struct ubus_object *obj)
31 {
32 return container_of(obj, struct hapd_interfaces, ubus);
33 }
34
35 static inline struct hostapd_data *get_hapd_from_object(struct ubus_object *obj)
36 {
37 return container_of(obj, struct hostapd_data, ubus.obj);
38 }
39
40 struct ubus_banned_client {
41 struct avl_node avl;
42 u8 addr[ETH_ALEN];
43 };
44
45 static void ubus_receive(int sock, void *eloop_ctx, void *sock_ctx)
46 {
47 struct ubus_context *ctx = eloop_ctx;
48 ubus_handle_event(ctx);
49 }
50
51 static void ubus_reconnect_timeout(void *eloop_data, void *user_ctx)
52 {
53 if (ubus_reconnect(ctx, NULL)) {
54 eloop_register_timeout(1, 0, ubus_reconnect_timeout, ctx, NULL);
55 return;
56 }
57
58 eloop_register_read_sock(ctx->sock.fd, ubus_receive, ctx, NULL);
59 }
60
61 static void hostapd_ubus_connection_lost(struct ubus_context *ctx)
62 {
63 eloop_unregister_read_sock(ctx->sock.fd);
64 eloop_register_timeout(1, 0, ubus_reconnect_timeout, ctx, NULL);
65 }
66
67 static bool hostapd_ubus_init(void)
68 {
69 if (ctx)
70 return true;
71
72 ctx = ubus_connect(NULL);
73 if (!ctx)
74 return false;
75
76 ctx->connection_lost = hostapd_ubus_connection_lost;
77 eloop_register_read_sock(ctx->sock.fd, ubus_receive, ctx, NULL);
78 return true;
79 }
80
81 static void hostapd_ubus_ref_inc(void)
82 {
83 ctx_ref++;
84 }
85
86 static void hostapd_ubus_ref_dec(void)
87 {
88 ctx_ref--;
89 if (!ctx)
90 return;
91
92 if (ctx_ref)
93 return;
94
95 eloop_unregister_read_sock(ctx->sock.fd);
96 ubus_free(ctx);
97 ctx = NULL;
98 }
99
100 void hostapd_ubus_add_iface(struct hostapd_iface *iface)
101 {
102 if (!hostapd_ubus_init())
103 return;
104 }
105
106 void hostapd_ubus_free_iface(struct hostapd_iface *iface)
107 {
108 if (!ctx)
109 return;
110 }
111
112 static void hostapd_notify_ubus(struct ubus_object *obj, char *bssname, char *event)
113 {
114 char *event_type;
115
116 if (!ctx || !obj)
117 return;
118
119 if (asprintf(&event_type, "bss.%s", event) < 0)
120 return;
121
122 blob_buf_init(&b, 0);
123 blobmsg_add_string(&b, "name", bssname);
124 ubus_notify(ctx, obj, event_type, b.head, -1);
125 free(event_type);
126 }
127
128 static void hostapd_send_procd_event(char *bssname, char *event)
129 {
130 char *name, *s;
131 uint32_t id;
132 void *v;
133
134 if (!ctx || ubus_lookup_id(ctx, "service", &id))
135 return;
136
137 if (asprintf(&name, "hostapd.%s.%s", bssname, event) < 0)
138 return;
139
140 blob_buf_init(&b, 0);
141
142 s = blobmsg_alloc_string_buffer(&b, "type", strlen(name) + 1);
143 sprintf(s, "%s", name);
144 blobmsg_add_string_buffer(&b);
145
146 v = blobmsg_open_table(&b, "data");
147 blobmsg_close_table(&b, v);
148
149 ubus_invoke(ctx, id, "event", b.head, NULL, NULL, 1000);
150
151 free(name);
152 }
153
154 static void hostapd_send_shared_event(struct ubus_object *obj, char *bssname, char *event)
155 {
156 hostapd_send_procd_event(bssname, event);
157 hostapd_notify_ubus(obj, bssname, event);
158 }
159
160 static void
161 hostapd_bss_del_ban(void *eloop_data, void *user_ctx)
162 {
163 struct ubus_banned_client *ban = eloop_data;
164 struct hostapd_data *hapd = user_ctx;
165
166 avl_delete(&hapd->ubus.banned, &ban->avl);
167 free(ban);
168 }
169
170 static void
171 hostapd_bss_ban_client(struct hostapd_data *hapd, u8 *addr, int time)
172 {
173 struct ubus_banned_client *ban;
174
175 if (time < 0)
176 time = 0;
177
178 ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
179 if (!ban) {
180 if (!time)
181 return;
182
183 ban = os_zalloc(sizeof(*ban));
184 memcpy(ban->addr, addr, sizeof(ban->addr));
185 ban->avl.key = ban->addr;
186 avl_insert(&hapd->ubus.banned, &ban->avl);
187 } else {
188 eloop_cancel_timeout(hostapd_bss_del_ban, ban, hapd);
189 if (!time) {
190 hostapd_bss_del_ban(ban, hapd);
191 return;
192 }
193 }
194
195 eloop_register_timeout(0, time * 1000, hostapd_bss_del_ban, ban, hapd);
196 }
197
198 static int
199 hostapd_bss_reload(struct ubus_context *ctx, struct ubus_object *obj,
200 struct ubus_request_data *req, const char *method,
201 struct blob_attr *msg)
202 {
203 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
204 int ret = hostapd_reload_config(hapd->iface, 1);
205
206 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "reload");
207 return ret;
208 }
209
210
211 static void
212 hostapd_parse_vht_map_blobmsg(uint16_t map)
213 {
214 char label[4];
215 int16_t val;
216 int i;
217
218 for (i = 0; i < 8; i++) {
219 snprintf(label, 4, "%dss", i + 1);
220
221 val = (map & (BIT(1) | BIT(0))) + 7;
222 blobmsg_add_u16(&b, label, val == 10 ? -1 : val);
223 map = map >> 2;
224 }
225 }
226
227 static void
228 hostapd_parse_vht_capab_blobmsg(struct ieee80211_vht_capabilities *vhtc)
229 {
230 void *supported_mcs;
231 void *map;
232 int i;
233
234 static const struct {
235 const char *name;
236 uint32_t flag;
237 } vht_capas[] = {
238 { "su_beamformee", VHT_CAP_SU_BEAMFORMEE_CAPABLE },
239 { "mu_beamformee", VHT_CAP_MU_BEAMFORMEE_CAPABLE },
240 };
241
242 for (i = 0; i < ARRAY_SIZE(vht_capas); i++)
243 blobmsg_add_u8(&b, vht_capas[i].name,
244 !!(vhtc->vht_capabilities_info & vht_capas[i].flag));
245
246 supported_mcs = blobmsg_open_table(&b, "mcs_map");
247
248 /* RX map */
249 map = blobmsg_open_table(&b, "rx");
250 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc->vht_supported_mcs_set.rx_map));
251 blobmsg_close_table(&b, map);
252
253 /* TX map */
254 map = blobmsg_open_table(&b, "tx");
255 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc->vht_supported_mcs_set.tx_map));
256 blobmsg_close_table(&b, map);
257
258 blobmsg_close_table(&b, supported_mcs);
259 }
260
261 static void
262 hostapd_parse_capab_blobmsg(struct sta_info *sta)
263 {
264 void *r, *v;
265
266 v = blobmsg_open_table(&b, "capabilities");
267
268 if (sta->vht_capabilities) {
269 r = blobmsg_open_table(&b, "vht");
270 hostapd_parse_vht_capab_blobmsg(sta->vht_capabilities);
271 blobmsg_close_table(&b, r);
272 }
273
274 /* ToDo: Add HT / HE capability parsing */
275
276 blobmsg_close_table(&b, v);
277 }
278
279 static int
280 hostapd_bss_get_clients(struct ubus_context *ctx, struct ubus_object *obj,
281 struct ubus_request_data *req, const char *method,
282 struct blob_attr *msg)
283 {
284 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
285 struct hostap_sta_driver_data sta_driver_data;
286 struct sta_info *sta;
287 void *list, *c;
288 char mac_buf[20];
289 static const struct {
290 const char *name;
291 uint32_t flag;
292 } sta_flags[] = {
293 { "auth", WLAN_STA_AUTH },
294 { "assoc", WLAN_STA_ASSOC },
295 { "authorized", WLAN_STA_AUTHORIZED },
296 { "preauth", WLAN_STA_PREAUTH },
297 { "wds", WLAN_STA_WDS },
298 { "wmm", WLAN_STA_WMM },
299 { "ht", WLAN_STA_HT },
300 { "vht", WLAN_STA_VHT },
301 { "he", WLAN_STA_HE },
302 { "wps", WLAN_STA_WPS },
303 { "mfp", WLAN_STA_MFP },
304 };
305
306 blob_buf_init(&b, 0);
307 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
308 list = blobmsg_open_table(&b, "clients");
309 for (sta = hapd->sta_list; sta; sta = sta->next) {
310 void *r;
311 int i;
312
313 sprintf(mac_buf, MACSTR, MAC2STR(sta->addr));
314 c = blobmsg_open_table(&b, mac_buf);
315 for (i = 0; i < ARRAY_SIZE(sta_flags); i++)
316 blobmsg_add_u8(&b, sta_flags[i].name,
317 !!(sta->flags & sta_flags[i].flag));
318
319 r = blobmsg_open_array(&b, "rrm");
320 for (i = 0; i < ARRAY_SIZE(sta->rrm_enabled_capa); i++)
321 blobmsg_add_u32(&b, "", sta->rrm_enabled_capa[i]);
322 blobmsg_close_array(&b, r);
323 blobmsg_add_u32(&b, "aid", sta->aid);
324 #ifdef CONFIG_TAXONOMY
325 r = blobmsg_alloc_string_buffer(&b, "signature", 1024);
326 if (retrieve_sta_taxonomy(hapd, sta, r, 1024) > 0)
327 blobmsg_add_string_buffer(&b);
328 #endif
329
330 /* Driver information */
331 if (hostapd_drv_read_sta_data(hapd, &sta_driver_data, sta->addr) >= 0) {
332 r = blobmsg_open_table(&b, "bytes");
333 blobmsg_add_u64(&b, "rx", sta_driver_data.rx_bytes);
334 blobmsg_add_u64(&b, "tx", sta_driver_data.tx_bytes);
335 blobmsg_close_table(&b, r);
336 r = blobmsg_open_table(&b, "airtime");
337 blobmsg_add_u64(&b, "rx", sta_driver_data.rx_airtime);
338 blobmsg_add_u64(&b, "tx", sta_driver_data.tx_airtime);
339 blobmsg_close_table(&b, r);
340 r = blobmsg_open_table(&b, "packets");
341 blobmsg_add_u32(&b, "rx", sta_driver_data.rx_packets);
342 blobmsg_add_u32(&b, "tx", sta_driver_data.tx_packets);
343 blobmsg_close_table(&b, r);
344 r = blobmsg_open_table(&b, "rate");
345 /* Rate in kbits */
346 blobmsg_add_u32(&b, "rx", sta_driver_data.current_rx_rate * 100);
347 blobmsg_add_u32(&b, "tx", sta_driver_data.current_tx_rate * 100);
348 blobmsg_close_table(&b, r);
349 blobmsg_add_u32(&b, "signal", sta_driver_data.signal);
350 }
351
352 hostapd_parse_capab_blobmsg(sta);
353
354 blobmsg_close_table(&b, c);
355 }
356 blobmsg_close_array(&b, list);
357 ubus_send_reply(ctx, req, b.head);
358
359 return 0;
360 }
361
362 static int
363 hostapd_bss_get_features(struct ubus_context *ctx, struct ubus_object *obj,
364 struct ubus_request_data *req, const char *method,
365 struct blob_attr *msg)
366 {
367 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
368
369 blob_buf_init(&b, 0);
370 blobmsg_add_u8(&b, "ht_supported", ht_supported(hapd->iface->hw_features));
371 blobmsg_add_u8(&b, "vht_supported", vht_supported(hapd->iface->hw_features));
372 ubus_send_reply(ctx, req, b.head);
373
374 return 0;
375 }
376
377 /* Imported from iw/util.c
378 * https://git.kernel.org/pub/scm/linux/kernel/git/jberg/iw.git/tree/util.c?id=4b25ae3537af48dbf9d0abf94132e5ba01b32c18#n200
379 */
380 int ieee80211_frequency_to_channel(int freq)
381 {
382 /* see 802.11-2007 17.3.8.3.2 and Annex J */
383 if (freq == 2484)
384 return 14;
385 /* see 802.11ax D6.1 27.3.23.2 and Annex E */
386 else if (freq == 5935)
387 return 2;
388 else if (freq < 2484)
389 return (freq - 2407) / 5;
390 else if (freq >= 4910 && freq <= 4980)
391 return (freq - 4000) / 5;
392 else if (freq < 5950)
393 return (freq - 5000) / 5;
394 else if (freq <= 45000) /* DMG band lower limit */
395 /* see 802.11ax D6.1 27.3.23.2 */
396 return (freq - 5950) / 5;
397 else if (freq >= 58320 && freq <= 70200)
398 return (freq - 56160) / 2160;
399 else
400 return 0;
401 }
402
403 static int
404 hostapd_bss_get_status(struct ubus_context *ctx, struct ubus_object *obj,
405 struct ubus_request_data *req, const char *method,
406 struct blob_attr *msg)
407 {
408 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
409 void *airtime_table, *dfs_table, *rrm_table, *wnm_table;
410 struct os_reltime now;
411 char ssid[SSID_MAX_LEN + 1];
412 char phy_name[17];
413 size_t ssid_len = SSID_MAX_LEN;
414
415 if (hapd->conf->ssid.ssid_len < SSID_MAX_LEN)
416 ssid_len = hapd->conf->ssid.ssid_len;
417
418 blob_buf_init(&b, 0);
419 blobmsg_add_string(&b, "status", hostapd_state_text(hapd->iface->state));
420 blobmsg_printf(&b, "bssid", MACSTR, MAC2STR(hapd->conf->bssid));
421
422 memset(ssid, 0, SSID_MAX_LEN + 1);
423 memcpy(ssid, hapd->conf->ssid.ssid, ssid_len);
424 blobmsg_add_string(&b, "ssid", ssid);
425
426 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
427 blobmsg_add_u32(&b, "channel", ieee80211_frequency_to_channel(hapd->iface->freq));
428 blobmsg_add_u32(&b, "beacon_interval", hapd->iconf->beacon_int);
429
430 snprintf(phy_name, 17, "%s", hapd->iface->phy);
431 blobmsg_add_string(&b, "phy", phy_name);
432
433 /* RRM */
434 rrm_table = blobmsg_open_table(&b, "rrm");
435 blobmsg_add_u64(&b, "neighbor_report_tx", hapd->iface->openwrt_stats.rrm.neighbor_report_tx);
436 blobmsg_close_table(&b, rrm_table);
437
438 /* WNM */
439 wnm_table = blobmsg_open_table(&b, "wnm");
440 blobmsg_add_u64(&b, "bss_transition_query_rx", hapd->iface->openwrt_stats.wnm.bss_transition_query_rx);
441 blobmsg_add_u64(&b, "bss_transition_request_tx", hapd->iface->openwrt_stats.wnm.bss_transition_request_tx);
442 blobmsg_add_u64(&b, "bss_transition_response_rx", hapd->iface->openwrt_stats.wnm.bss_transition_response_rx);
443 blobmsg_close_table(&b, rrm_table);
444
445 /* Airtime */
446 airtime_table = blobmsg_open_table(&b, "airtime");
447 blobmsg_add_u64(&b, "time", hapd->iface->last_channel_time);
448 blobmsg_add_u64(&b, "time_busy", hapd->iface->last_channel_time_busy);
449 blobmsg_add_u16(&b, "utilization", hapd->iface->channel_utilization);
450 blobmsg_close_table(&b, airtime_table);
451
452 /* DFS */
453 dfs_table = blobmsg_open_table(&b, "dfs");
454 blobmsg_add_u32(&b, "cac_seconds", hapd->iface->dfs_cac_ms / 1000);
455 blobmsg_add_u8(&b, "cac_active", !!(hapd->iface->cac_started));
456 os_reltime_age(&hapd->iface->dfs_cac_start, &now);
457 blobmsg_add_u32(&b, "cac_seconds_left",
458 hapd->iface->cac_started ? hapd->iface->dfs_cac_ms / 1000 - now.sec : 0);
459 blobmsg_close_table(&b, dfs_table);
460
461 ubus_send_reply(ctx, req, b.head);
462
463 return 0;
464 }
465
466 enum {
467 NOTIFY_RESPONSE,
468 __NOTIFY_MAX
469 };
470
471 static const struct blobmsg_policy notify_policy[__NOTIFY_MAX] = {
472 [NOTIFY_RESPONSE] = { "notify_response", BLOBMSG_TYPE_INT32 },
473 };
474
475 static int
476 hostapd_notify_response(struct ubus_context *ctx, struct ubus_object *obj,
477 struct ubus_request_data *req, const char *method,
478 struct blob_attr *msg)
479 {
480 struct blob_attr *tb[__NOTIFY_MAX];
481 struct hostapd_data *hapd = get_hapd_from_object(obj);
482 struct wpabuf *elems;
483 const char *pos;
484 size_t len;
485
486 blobmsg_parse(notify_policy, __NOTIFY_MAX, tb,
487 blob_data(msg), blob_len(msg));
488
489 if (!tb[NOTIFY_RESPONSE])
490 return UBUS_STATUS_INVALID_ARGUMENT;
491
492 hapd->ubus.notify_response = blobmsg_get_u32(tb[NOTIFY_RESPONSE]);
493
494 return UBUS_STATUS_OK;
495 }
496
497 enum {
498 DEL_CLIENT_ADDR,
499 DEL_CLIENT_REASON,
500 DEL_CLIENT_DEAUTH,
501 DEL_CLIENT_BAN_TIME,
502 __DEL_CLIENT_MAX
503 };
504
505 static const struct blobmsg_policy del_policy[__DEL_CLIENT_MAX] = {
506 [DEL_CLIENT_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
507 [DEL_CLIENT_REASON] = { "reason", BLOBMSG_TYPE_INT32 },
508 [DEL_CLIENT_DEAUTH] = { "deauth", BLOBMSG_TYPE_INT8 },
509 [DEL_CLIENT_BAN_TIME] = { "ban_time", BLOBMSG_TYPE_INT32 },
510 };
511
512 static int
513 hostapd_bss_del_client(struct ubus_context *ctx, struct ubus_object *obj,
514 struct ubus_request_data *req, const char *method,
515 struct blob_attr *msg)
516 {
517 struct blob_attr *tb[__DEL_CLIENT_MAX];
518 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
519 struct sta_info *sta;
520 bool deauth = false;
521 int reason;
522 u8 addr[ETH_ALEN];
523
524 blobmsg_parse(del_policy, __DEL_CLIENT_MAX, tb, blob_data(msg), blob_len(msg));
525
526 if (!tb[DEL_CLIENT_ADDR])
527 return UBUS_STATUS_INVALID_ARGUMENT;
528
529 if (hwaddr_aton(blobmsg_data(tb[DEL_CLIENT_ADDR]), addr))
530 return UBUS_STATUS_INVALID_ARGUMENT;
531
532 if (tb[DEL_CLIENT_REASON])
533 reason = blobmsg_get_u32(tb[DEL_CLIENT_REASON]);
534
535 if (tb[DEL_CLIENT_DEAUTH])
536 deauth = blobmsg_get_bool(tb[DEL_CLIENT_DEAUTH]);
537
538 sta = ap_get_sta(hapd, addr);
539 if (sta) {
540 if (deauth) {
541 hostapd_drv_sta_deauth(hapd, addr, reason);
542 ap_sta_deauthenticate(hapd, sta, reason);
543 } else {
544 hostapd_drv_sta_disassoc(hapd, addr, reason);
545 ap_sta_disassociate(hapd, sta, reason);
546 }
547 }
548
549 if (tb[DEL_CLIENT_BAN_TIME])
550 hostapd_bss_ban_client(hapd, addr, blobmsg_get_u32(tb[DEL_CLIENT_BAN_TIME]));
551
552 return 0;
553 }
554
555 static void
556 blobmsg_add_macaddr(struct blob_buf *buf, const char *name, const u8 *addr)
557 {
558 char *s;
559
560 s = blobmsg_alloc_string_buffer(buf, name, 20);
561 sprintf(s, MACSTR, MAC2STR(addr));
562 blobmsg_add_string_buffer(buf);
563 }
564
565 static int
566 hostapd_bss_list_bans(struct ubus_context *ctx, struct ubus_object *obj,
567 struct ubus_request_data *req, const char *method,
568 struct blob_attr *msg)
569 {
570 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
571 struct ubus_banned_client *ban;
572 void *c;
573
574 blob_buf_init(&b, 0);
575 c = blobmsg_open_array(&b, "clients");
576 avl_for_each_element(&hapd->ubus.banned, ban, avl)
577 blobmsg_add_macaddr(&b, NULL, ban->addr);
578 blobmsg_close_array(&b, c);
579 ubus_send_reply(ctx, req, b.head);
580
581 return 0;
582 }
583
584 #ifdef CONFIG_WPS
585 static int
586 hostapd_bss_wps_start(struct ubus_context *ctx, struct ubus_object *obj,
587 struct ubus_request_data *req, const char *method,
588 struct blob_attr *msg)
589 {
590 int rc;
591 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
592
593 rc = hostapd_wps_button_pushed(hapd, NULL);
594
595 if (rc != 0)
596 return UBUS_STATUS_NOT_SUPPORTED;
597
598 return 0;
599 }
600
601
602 static const char * pbc_status_enum_str(enum pbc_status status)
603 {
604 switch (status) {
605 case WPS_PBC_STATUS_DISABLE:
606 return "Disabled";
607 case WPS_PBC_STATUS_ACTIVE:
608 return "Active";
609 case WPS_PBC_STATUS_TIMEOUT:
610 return "Timed-out";
611 case WPS_PBC_STATUS_OVERLAP:
612 return "Overlap";
613 default:
614 return "Unknown";
615 }
616 }
617
618 static int
619 hostapd_bss_wps_status(struct ubus_context *ctx, struct ubus_object *obj,
620 struct ubus_request_data *req, const char *method,
621 struct blob_attr *msg)
622 {
623 int rc;
624 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
625
626 blob_buf_init(&b, 0);
627
628 blobmsg_add_string(&b, "pbc_status", pbc_status_enum_str(hapd->wps_stats.pbc_status));
629 blobmsg_add_string(&b, "last_wps_result",
630 (hapd->wps_stats.status == WPS_STATUS_SUCCESS ?
631 "Success":
632 (hapd->wps_stats.status == WPS_STATUS_FAILURE ?
633 "Failed" : "None")));
634
635 /* If status == Failure - Add possible Reasons */
636 if(hapd->wps_stats.status == WPS_STATUS_FAILURE &&
637 hapd->wps_stats.failure_reason > 0)
638 blobmsg_add_string(&b, "reason", wps_ei_str(hapd->wps_stats.failure_reason));
639
640 if (hapd->wps_stats.status)
641 blobmsg_printf(&b, "peer_address", MACSTR, MAC2STR(hapd->wps_stats.peer_addr));
642
643 ubus_send_reply(ctx, req, b.head);
644
645 return 0;
646 }
647
648 static int
649 hostapd_bss_wps_cancel(struct ubus_context *ctx, struct ubus_object *obj,
650 struct ubus_request_data *req, const char *method,
651 struct blob_attr *msg)
652 {
653 int rc;
654 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
655
656 rc = hostapd_wps_cancel(hapd);
657
658 if (rc != 0)
659 return UBUS_STATUS_NOT_SUPPORTED;
660
661 return 0;
662 }
663 #endif /* CONFIG_WPS */
664
665 static int
666 hostapd_bss_update_beacon(struct ubus_context *ctx, struct ubus_object *obj,
667 struct ubus_request_data *req, const char *method,
668 struct blob_attr *msg)
669 {
670 int rc;
671 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
672
673 rc = ieee802_11_set_beacon(hapd);
674
675 if (rc != 0)
676 return UBUS_STATUS_NOT_SUPPORTED;
677
678 return 0;
679 }
680
681 enum {
682 CONFIG_IFACE,
683 CONFIG_FILE,
684 __CONFIG_MAX
685 };
686
687 static const struct blobmsg_policy config_add_policy[__CONFIG_MAX] = {
688 [CONFIG_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
689 [CONFIG_FILE] = { "config", BLOBMSG_TYPE_STRING },
690 };
691
692 static int
693 hostapd_config_add(struct ubus_context *ctx, struct ubus_object *obj,
694 struct ubus_request_data *req, const char *method,
695 struct blob_attr *msg)
696 {
697 struct blob_attr *tb[__CONFIG_MAX];
698 struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
699 char buf[128];
700
701 blobmsg_parse(config_add_policy, __CONFIG_MAX, tb, blob_data(msg), blob_len(msg));
702
703 if (!tb[CONFIG_FILE] || !tb[CONFIG_IFACE])
704 return UBUS_STATUS_INVALID_ARGUMENT;
705
706 snprintf(buf, sizeof(buf), "bss_config=%s:%s",
707 blobmsg_get_string(tb[CONFIG_IFACE]),
708 blobmsg_get_string(tb[CONFIG_FILE]));
709
710 if (hostapd_add_iface(interfaces, buf))
711 return UBUS_STATUS_INVALID_ARGUMENT;
712
713 blob_buf_init(&b, 0);
714 blobmsg_add_u32(&b, "pid", getpid());
715 ubus_send_reply(ctx, req, b.head);
716
717 return UBUS_STATUS_OK;
718 }
719
720 enum {
721 CONFIG_REM_IFACE,
722 __CONFIG_REM_MAX
723 };
724
725 static const struct blobmsg_policy config_remove_policy[__CONFIG_REM_MAX] = {
726 [CONFIG_REM_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
727 };
728
729 static int
730 hostapd_config_remove(struct ubus_context *ctx, struct ubus_object *obj,
731 struct ubus_request_data *req, const char *method,
732 struct blob_attr *msg)
733 {
734 struct blob_attr *tb[__CONFIG_REM_MAX];
735 struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
736 char buf[128];
737
738 blobmsg_parse(config_remove_policy, __CONFIG_REM_MAX, tb, blob_data(msg), blob_len(msg));
739
740 if (!tb[CONFIG_REM_IFACE])
741 return UBUS_STATUS_INVALID_ARGUMENT;
742
743 if (hostapd_remove_iface(interfaces, blobmsg_get_string(tb[CONFIG_REM_IFACE])))
744 return UBUS_STATUS_INVALID_ARGUMENT;
745
746 return UBUS_STATUS_OK;
747 }
748
749 enum {
750 CSA_FREQ,
751 CSA_BCN_COUNT,
752 CSA_CENTER_FREQ1,
753 CSA_CENTER_FREQ2,
754 CSA_BANDWIDTH,
755 CSA_SEC_CHANNEL_OFFSET,
756 CSA_HT,
757 CSA_VHT,
758 CSA_HE,
759 CSA_BLOCK_TX,
760 CSA_FORCE,
761 __CSA_MAX
762 };
763
764 static const struct blobmsg_policy csa_policy[__CSA_MAX] = {
765 [CSA_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
766 [CSA_BCN_COUNT] = { "bcn_count", BLOBMSG_TYPE_INT32 },
767 [CSA_CENTER_FREQ1] = { "center_freq1", BLOBMSG_TYPE_INT32 },
768 [CSA_CENTER_FREQ2] = { "center_freq2", BLOBMSG_TYPE_INT32 },
769 [CSA_BANDWIDTH] = { "bandwidth", BLOBMSG_TYPE_INT32 },
770 [CSA_SEC_CHANNEL_OFFSET] = { "sec_channel_offset", BLOBMSG_TYPE_INT32 },
771 [CSA_HT] = { "ht", BLOBMSG_TYPE_BOOL },
772 [CSA_VHT] = { "vht", BLOBMSG_TYPE_BOOL },
773 [CSA_HE] = { "he", BLOBMSG_TYPE_BOOL },
774 [CSA_BLOCK_TX] = { "block_tx", BLOBMSG_TYPE_BOOL },
775 [CSA_FORCE] = { "force", BLOBMSG_TYPE_BOOL },
776 };
777
778
779 static void switch_chan_fallback_cb(void *eloop_data, void *user_ctx)
780 {
781 struct hostapd_iface *iface = eloop_data;
782 struct hostapd_freq_params *freq_params = user_ctx;
783
784 hostapd_switch_channel_fallback(iface, freq_params);
785 }
786
787 #ifdef NEED_AP_MLME
788 static int
789 hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
790 struct ubus_request_data *req, const char *method,
791 struct blob_attr *msg)
792 {
793 struct blob_attr *tb[__CSA_MAX];
794 struct hostapd_data *hapd = get_hapd_from_object(obj);
795 struct hostapd_config *iconf = hapd->iface->conf;
796 struct hostapd_freq_params *freq_params;
797 struct csa_settings css = {
798 .freq_params = {
799 .ht_enabled = iconf->ieee80211n,
800 .vht_enabled = iconf->ieee80211ac,
801 .he_enabled = iconf->ieee80211ax,
802 .sec_channel_offset = iconf->secondary_channel,
803 }
804 };
805 int ret = UBUS_STATUS_OK;
806 int i;
807
808 blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
809
810 if (!tb[CSA_FREQ])
811 return UBUS_STATUS_INVALID_ARGUMENT;
812
813 switch (iconf->vht_oper_chwidth) {
814 case CHANWIDTH_USE_HT:
815 if (iconf->secondary_channel)
816 css.freq_params.bandwidth = 40;
817 else
818 css.freq_params.bandwidth = 20;
819 break;
820 case CHANWIDTH_160MHZ:
821 css.freq_params.bandwidth = 160;
822 break;
823 default:
824 css.freq_params.bandwidth = 80;
825 break;
826 }
827
828 css.freq_params.freq = blobmsg_get_u32(tb[CSA_FREQ]);
829
830 #define SET_CSA_SETTING(name, field, type) \
831 do { \
832 if (tb[name]) \
833 css.field = blobmsg_get_ ## type(tb[name]); \
834 } while(0)
835
836 SET_CSA_SETTING(CSA_BCN_COUNT, cs_count, u32);
837 SET_CSA_SETTING(CSA_CENTER_FREQ1, freq_params.center_freq1, u32);
838 SET_CSA_SETTING(CSA_CENTER_FREQ2, freq_params.center_freq2, u32);
839 SET_CSA_SETTING(CSA_BANDWIDTH, freq_params.bandwidth, u32);
840 SET_CSA_SETTING(CSA_SEC_CHANNEL_OFFSET, freq_params.sec_channel_offset, u32);
841 SET_CSA_SETTING(CSA_HT, freq_params.ht_enabled, bool);
842 SET_CSA_SETTING(CSA_VHT, freq_params.vht_enabled, bool);
843 SET_CSA_SETTING(CSA_HE, freq_params.he_enabled, bool);
844 SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
845
846 for (i = 0; i < hapd->iface->num_bss; i++) {
847 struct hostapd_data *bss = hapd->iface->bss[i];
848
849 if (hostapd_switch_channel(bss, &css) != 0)
850 ret = UBUS_STATUS_NOT_SUPPORTED;
851 }
852
853 if (!ret || !tb[CSA_FORCE] || !blobmsg_get_bool(tb[CSA_FORCE]))
854 return ret;
855
856 freq_params = malloc(sizeof(*freq_params));
857 memcpy(freq_params, &css.freq_params, sizeof(*freq_params));
858 eloop_register_timeout(0, 1, switch_chan_fallback_cb,
859 hapd->iface, freq_params);
860
861 return 0;
862 #undef SET_CSA_SETTING
863 }
864 #endif
865
866 enum {
867 VENDOR_ELEMENTS,
868 __VENDOR_ELEMENTS_MAX
869 };
870
871 static const struct blobmsg_policy ve_policy[__VENDOR_ELEMENTS_MAX] = {
872 /* vendor elements are provided as hex-string */
873 [VENDOR_ELEMENTS] = { "vendor_elements", BLOBMSG_TYPE_STRING },
874 };
875
876 static int
877 hostapd_vendor_elements(struct ubus_context *ctx, struct ubus_object *obj,
878 struct ubus_request_data *req, const char *method,
879 struct blob_attr *msg)
880 {
881 struct blob_attr *tb[__VENDOR_ELEMENTS_MAX];
882 struct hostapd_data *hapd = get_hapd_from_object(obj);
883 struct hostapd_bss_config *bss = hapd->conf;
884 struct wpabuf *elems;
885 const char *pos;
886 size_t len;
887
888 blobmsg_parse(ve_policy, __VENDOR_ELEMENTS_MAX, tb,
889 blob_data(msg), blob_len(msg));
890
891 if (!tb[VENDOR_ELEMENTS])
892 return UBUS_STATUS_INVALID_ARGUMENT;
893
894 pos = blobmsg_data(tb[VENDOR_ELEMENTS]);
895 len = os_strlen(pos);
896 if (len & 0x01)
897 return UBUS_STATUS_INVALID_ARGUMENT;
898
899 len /= 2;
900 if (len == 0) {
901 wpabuf_free(bss->vendor_elements);
902 bss->vendor_elements = NULL;
903 return 0;
904 }
905
906 elems = wpabuf_alloc(len);
907 if (elems == NULL)
908 return 1;
909
910 if (hexstr2bin(pos, wpabuf_put(elems, len), len)) {
911 wpabuf_free(elems);
912 return UBUS_STATUS_INVALID_ARGUMENT;
913 }
914
915 wpabuf_free(bss->vendor_elements);
916 bss->vendor_elements = elems;
917
918 /* update beacons if vendor elements were set successfully */
919 if (ieee802_11_update_beacons(hapd->iface) != 0)
920 return UBUS_STATUS_NOT_SUPPORTED;
921 return UBUS_STATUS_OK;
922 }
923
924 static void
925 hostapd_rrm_print_nr(struct hostapd_neighbor_entry *nr)
926 {
927 const u8 *data;
928 char *str;
929 int len;
930
931 blobmsg_printf(&b, "", MACSTR, MAC2STR(nr->bssid));
932
933 str = blobmsg_alloc_string_buffer(&b, "", nr->ssid.ssid_len + 1);
934 memcpy(str, nr->ssid.ssid, nr->ssid.ssid_len);
935 str[nr->ssid.ssid_len] = 0;
936 blobmsg_add_string_buffer(&b);
937
938 len = wpabuf_len(nr->nr);
939 str = blobmsg_alloc_string_buffer(&b, "", 2 * len + 1);
940 wpa_snprintf_hex(str, 2 * len + 1, wpabuf_head_u8(nr->nr), len);
941 blobmsg_add_string_buffer(&b);
942 }
943
944 enum {
945 BSS_MGMT_EN_NEIGHBOR,
946 BSS_MGMT_EN_BEACON,
947 #ifdef CONFIG_WNM_AP
948 BSS_MGMT_EN_BSS_TRANSITION,
949 #endif
950 __BSS_MGMT_EN_MAX
951 };
952
953 static bool
954 __hostapd_bss_mgmt_enable_f(struct hostapd_data *hapd, int flag)
955 {
956 struct hostapd_bss_config *bss = hapd->conf;
957 uint32_t flags;
958
959 switch (flag) {
960 case BSS_MGMT_EN_NEIGHBOR:
961 if (bss->radio_measurements[0] &
962 WLAN_RRM_CAPS_NEIGHBOR_REPORT)
963 return false;
964
965 bss->radio_measurements[0] |=
966 WLAN_RRM_CAPS_NEIGHBOR_REPORT;
967 hostapd_neighbor_set_own_report(hapd);
968 return true;
969 case BSS_MGMT_EN_BEACON:
970 flags = WLAN_RRM_CAPS_BEACON_REPORT_PASSIVE |
971 WLAN_RRM_CAPS_BEACON_REPORT_ACTIVE |
972 WLAN_RRM_CAPS_BEACON_REPORT_TABLE;
973
974 if (bss->radio_measurements[0] & flags == flags)
975 return false;
976
977 bss->radio_measurements[0] |= (u8) flags;
978 return true;
979 #ifdef CONFIG_WNM_AP
980 case BSS_MGMT_EN_BSS_TRANSITION:
981 if (bss->bss_transition)
982 return false;
983
984 bss->bss_transition = 1;
985 return true;
986 #endif
987 }
988 }
989
990 static void
991 __hostapd_bss_mgmt_enable(struct hostapd_data *hapd, uint32_t flags)
992 {
993 bool update = false;
994 int i;
995
996 for (i = 0; i < __BSS_MGMT_EN_MAX; i++) {
997 if (!(flags & (1 << i)))
998 continue;
999
1000 update |= __hostapd_bss_mgmt_enable_f(hapd, i);
1001 }
1002
1003 if (update)
1004 ieee802_11_update_beacons(hapd->iface);
1005 }
1006
1007
1008 static const struct blobmsg_policy bss_mgmt_enable_policy[__BSS_MGMT_EN_MAX] = {
1009 [BSS_MGMT_EN_NEIGHBOR] = { "neighbor_report", BLOBMSG_TYPE_BOOL },
1010 [BSS_MGMT_EN_BEACON] = { "beacon_report", BLOBMSG_TYPE_BOOL },
1011 #ifdef CONFIG_WNM_AP
1012 [BSS_MGMT_EN_BSS_TRANSITION] = { "bss_transition", BLOBMSG_TYPE_BOOL },
1013 #endif
1014 };
1015
1016 static int
1017 hostapd_bss_mgmt_enable(struct ubus_context *ctx, struct ubus_object *obj,
1018 struct ubus_request_data *req, const char *method,
1019 struct blob_attr *msg)
1020
1021 {
1022 struct hostapd_data *hapd = get_hapd_from_object(obj);
1023 struct blob_attr *tb[__BSS_MGMT_EN_MAX];
1024 struct blob_attr *cur;
1025 uint32_t flags = 0;
1026 int i;
1027 bool neigh = false, beacon = false;
1028
1029 blobmsg_parse(bss_mgmt_enable_policy, __BSS_MGMT_EN_MAX, tb, blob_data(msg), blob_len(msg));
1030
1031 for (i = 0; i < ARRAY_SIZE(tb); i++) {
1032 if (!tb[i] || !blobmsg_get_bool(tb[i]))
1033 continue;
1034
1035 flags |= (1 << i);
1036 }
1037
1038 __hostapd_bss_mgmt_enable(hapd, flags);
1039 }
1040
1041
1042 static void
1043 hostapd_rrm_nr_enable(struct hostapd_data *hapd)
1044 {
1045 __hostapd_bss_mgmt_enable(hapd, 1 << BSS_MGMT_EN_NEIGHBOR);
1046 }
1047
1048 static int
1049 hostapd_rrm_nr_get_own(struct ubus_context *ctx, struct ubus_object *obj,
1050 struct ubus_request_data *req, const char *method,
1051 struct blob_attr *msg)
1052 {
1053 struct hostapd_data *hapd = get_hapd_from_object(obj);
1054 struct hostapd_neighbor_entry *nr;
1055 void *c;
1056
1057 hostapd_rrm_nr_enable(hapd);
1058
1059 nr = hostapd_neighbor_get(hapd, hapd->own_addr, NULL);
1060 if (!nr)
1061 return UBUS_STATUS_NOT_FOUND;
1062
1063 blob_buf_init(&b, 0);
1064
1065 c = blobmsg_open_array(&b, "value");
1066 hostapd_rrm_print_nr(nr);
1067 blobmsg_close_array(&b, c);
1068
1069 ubus_send_reply(ctx, req, b.head);
1070
1071 return 0;
1072 }
1073
1074 static int
1075 hostapd_rrm_nr_list(struct ubus_context *ctx, struct ubus_object *obj,
1076 struct ubus_request_data *req, const char *method,
1077 struct blob_attr *msg)
1078 {
1079 struct hostapd_data *hapd = get_hapd_from_object(obj);
1080 struct hostapd_neighbor_entry *nr;
1081 void *c;
1082
1083 hostapd_rrm_nr_enable(hapd);
1084 blob_buf_init(&b, 0);
1085
1086 c = blobmsg_open_array(&b, "list");
1087 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
1088 void *cur;
1089
1090 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
1091 continue;
1092
1093 cur = blobmsg_open_array(&b, NULL);
1094 hostapd_rrm_print_nr(nr);
1095 blobmsg_close_array(&b, cur);
1096 }
1097 blobmsg_close_array(&b, c);
1098
1099 ubus_send_reply(ctx, req, b.head);
1100
1101 return 0;
1102 }
1103
1104 enum {
1105 NR_SET_LIST,
1106 __NR_SET_LIST_MAX
1107 };
1108
1109 static const struct blobmsg_policy nr_set_policy[__NR_SET_LIST_MAX] = {
1110 [NR_SET_LIST] = { "list", BLOBMSG_TYPE_ARRAY },
1111 };
1112
1113
1114 static void
1115 hostapd_rrm_nr_clear(struct hostapd_data *hapd)
1116 {
1117 struct hostapd_neighbor_entry *nr;
1118
1119 restart:
1120 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
1121 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
1122 continue;
1123
1124 hostapd_neighbor_remove(hapd, nr->bssid, &nr->ssid);
1125 goto restart;
1126 }
1127 }
1128
1129 static int
1130 hostapd_rrm_nr_set(struct ubus_context *ctx, struct ubus_object *obj,
1131 struct ubus_request_data *req, const char *method,
1132 struct blob_attr *msg)
1133 {
1134 static const struct blobmsg_policy nr_e_policy[] = {
1135 { .type = BLOBMSG_TYPE_STRING },
1136 { .type = BLOBMSG_TYPE_STRING },
1137 { .type = BLOBMSG_TYPE_STRING },
1138 };
1139 struct hostapd_data *hapd = get_hapd_from_object(obj);
1140 struct blob_attr *tb_l[__NR_SET_LIST_MAX];
1141 struct blob_attr *tb[ARRAY_SIZE(nr_e_policy)];
1142 struct blob_attr *cur;
1143 int rem;
1144
1145 hostapd_rrm_nr_enable(hapd);
1146
1147 blobmsg_parse(nr_set_policy, __NR_SET_LIST_MAX, tb_l, blob_data(msg), blob_len(msg));
1148 if (!tb_l[NR_SET_LIST])
1149 return UBUS_STATUS_INVALID_ARGUMENT;
1150
1151 hostapd_rrm_nr_clear(hapd);
1152 blobmsg_for_each_attr(cur, tb_l[NR_SET_LIST], rem) {
1153 struct wpa_ssid_value ssid;
1154 struct wpabuf *data;
1155 u8 bssid[ETH_ALEN];
1156 char *s, *nr_s;
1157
1158 blobmsg_parse_array(nr_e_policy, ARRAY_SIZE(nr_e_policy), tb, blobmsg_data(cur), blobmsg_data_len(cur));
1159 if (!tb[0] || !tb[1] || !tb[2])
1160 goto invalid;
1161
1162 /* Neighbor Report binary */
1163 nr_s = blobmsg_get_string(tb[2]);
1164 data = wpabuf_parse_bin(nr_s);
1165 if (!data)
1166 goto invalid;
1167
1168 /* BSSID */
1169 s = blobmsg_get_string(tb[0]);
1170 if (strlen(s) == 0) {
1171 /* Copy BSSID from neighbor report */
1172 if (hwaddr_compact_aton(nr_s, bssid))
1173 goto invalid;
1174 } else if (hwaddr_aton(s, bssid)) {
1175 goto invalid;
1176 }
1177
1178 /* SSID */
1179 s = blobmsg_get_string(tb[1]);
1180 if (strlen(s) == 0) {
1181 /* Copy SSID from hostapd BSS conf */
1182 memcpy(&ssid, &hapd->conf->ssid, sizeof(ssid));
1183 } else {
1184 ssid.ssid_len = strlen(s);
1185 if (ssid.ssid_len > sizeof(ssid.ssid))
1186 goto invalid;
1187
1188 memcpy(&ssid, s, ssid.ssid_len);
1189 }
1190
1191 hostapd_neighbor_set(hapd, bssid, &ssid, data, NULL, NULL, 0);
1192 wpabuf_free(data);
1193 continue;
1194
1195 invalid:
1196 return UBUS_STATUS_INVALID_ARGUMENT;
1197 }
1198
1199 return 0;
1200 }
1201
1202 enum {
1203 BEACON_REQ_ADDR,
1204 BEACON_REQ_MODE,
1205 BEACON_REQ_OP_CLASS,
1206 BEACON_REQ_CHANNEL,
1207 BEACON_REQ_DURATION,
1208 BEACON_REQ_BSSID,
1209 BEACON_REQ_SSID,
1210 __BEACON_REQ_MAX,
1211 };
1212
1213 static const struct blobmsg_policy beacon_req_policy[__BEACON_REQ_MAX] = {
1214 [BEACON_REQ_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1215 [BEACON_REQ_OP_CLASS] { "op_class", BLOBMSG_TYPE_INT32 },
1216 [BEACON_REQ_CHANNEL] { "channel", BLOBMSG_TYPE_INT32 },
1217 [BEACON_REQ_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1218 [BEACON_REQ_MODE] { "mode", BLOBMSG_TYPE_INT32 },
1219 [BEACON_REQ_BSSID] { "bssid", BLOBMSG_TYPE_STRING },
1220 [BEACON_REQ_SSID] { "ssid", BLOBMSG_TYPE_STRING },
1221 };
1222
1223 static int
1224 hostapd_rrm_beacon_req(struct ubus_context *ctx, struct ubus_object *obj,
1225 struct ubus_request_data *ureq, const char *method,
1226 struct blob_attr *msg)
1227 {
1228 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1229 struct blob_attr *tb[__BEACON_REQ_MAX];
1230 struct blob_attr *cur;
1231 struct wpabuf *req;
1232 u8 bssid[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1233 u8 addr[ETH_ALEN];
1234 int mode, rem, ret;
1235 int buf_len = 13;
1236
1237 blobmsg_parse(beacon_req_policy, __BEACON_REQ_MAX, tb, blob_data(msg), blob_len(msg));
1238
1239 if (!tb[BEACON_REQ_ADDR] || !tb[BEACON_REQ_MODE] || !tb[BEACON_REQ_DURATION] ||
1240 !tb[BEACON_REQ_OP_CLASS] || !tb[BEACON_REQ_CHANNEL])
1241 return UBUS_STATUS_INVALID_ARGUMENT;
1242
1243 if (tb[BEACON_REQ_SSID])
1244 buf_len += blobmsg_data_len(tb[BEACON_REQ_SSID]) + 2 - 1;
1245
1246 mode = blobmsg_get_u32(tb[BEACON_REQ_MODE]);
1247 if (hwaddr_aton(blobmsg_data(tb[BEACON_REQ_ADDR]), addr))
1248 return UBUS_STATUS_INVALID_ARGUMENT;
1249
1250 if (tb[BEACON_REQ_BSSID] &&
1251 hwaddr_aton(blobmsg_data(tb[BEACON_REQ_BSSID]), bssid))
1252 return UBUS_STATUS_INVALID_ARGUMENT;
1253
1254 req = wpabuf_alloc(buf_len);
1255 if (!req)
1256 return UBUS_STATUS_UNKNOWN_ERROR;
1257
1258 /* 1: regulatory class */
1259 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_OP_CLASS]));
1260
1261 /* 2: channel number */
1262 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_CHANNEL]));
1263
1264 /* 3-4: randomization interval */
1265 wpabuf_put_le16(req, 0);
1266
1267 /* 5-6: duration */
1268 wpabuf_put_le16(req, blobmsg_get_u32(tb[BEACON_REQ_DURATION]));
1269
1270 /* 7: mode */
1271 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_MODE]));
1272
1273 /* 8-13: BSSID */
1274 wpabuf_put_data(req, bssid, ETH_ALEN);
1275
1276 if ((cur = tb[BEACON_REQ_SSID]) != NULL) {
1277 wpabuf_put_u8(req, WLAN_EID_SSID);
1278 wpabuf_put_u8(req, blobmsg_data_len(cur) - 1);
1279 wpabuf_put_data(req, blobmsg_data(cur), blobmsg_data_len(cur) - 1);
1280 }
1281
1282 ret = hostapd_send_beacon_req(hapd, addr, 0, req);
1283 if (ret < 0)
1284 return -ret;
1285
1286 return 0;
1287 }
1288
1289
1290 #ifdef CONFIG_WNM_AP
1291
1292 static int
1293 hostapd_bss_tr_send(struct hostapd_data *hapd, u8 *addr, bool disassoc_imminent, bool abridged,
1294 u16 disassoc_timer, u8 validity_period, struct blob_attr *neighbors)
1295 {
1296 struct blob_attr *cur;
1297 struct sta_info *sta;
1298 int nr_len = 0;
1299 int rem;
1300 u8 *nr = NULL;
1301 u8 req_mode = 0;
1302
1303 sta = ap_get_sta(hapd, addr);
1304 if (!sta)
1305 return UBUS_STATUS_NOT_FOUND;
1306
1307 if (neighbors) {
1308 u8 *nr_cur;
1309
1310 if (blobmsg_check_array(neighbors,
1311 BLOBMSG_TYPE_STRING) < 0)
1312 return UBUS_STATUS_INVALID_ARGUMENT;
1313
1314 blobmsg_for_each_attr(cur, neighbors, rem) {
1315 int len = strlen(blobmsg_get_string(cur));
1316
1317 if (len % 2)
1318 return UBUS_STATUS_INVALID_ARGUMENT;
1319
1320 nr_len += (len / 2) + 2;
1321 }
1322
1323 if (nr_len) {
1324 nr = os_zalloc(nr_len);
1325 if (!nr)
1326 return UBUS_STATUS_UNKNOWN_ERROR;
1327 }
1328
1329 nr_cur = nr;
1330 blobmsg_for_each_attr(cur, neighbors, rem) {
1331 int len = strlen(blobmsg_get_string(cur)) / 2;
1332
1333 *nr_cur++ = WLAN_EID_NEIGHBOR_REPORT;
1334 *nr_cur++ = (u8) len;
1335 if (hexstr2bin(blobmsg_data(cur), nr_cur, len)) {
1336 free(nr);
1337 return UBUS_STATUS_INVALID_ARGUMENT;
1338 }
1339
1340 nr_cur += len;
1341 }
1342 }
1343
1344 if (nr)
1345 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
1346
1347 if (abridged)
1348 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
1349
1350 if (disassoc_imminent)
1351 req_mode |= WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
1352
1353 if (wnm_send_bss_tm_req(hapd, sta, req_mode, disassoc_timer, validity_period, NULL,
1354 NULL, nr, nr_len, NULL, 0))
1355 return UBUS_STATUS_UNKNOWN_ERROR;
1356
1357 return 0;
1358 }
1359
1360 enum {
1361 BSS_TR_ADDR,
1362 BSS_TR_DA_IMMINENT,
1363 BSS_TR_DA_TIMER,
1364 BSS_TR_VALID_PERIOD,
1365 BSS_TR_NEIGHBORS,
1366 BSS_TR_ABRIDGED,
1367 __BSS_TR_DISASSOC_MAX
1368 };
1369
1370 static const struct blobmsg_policy bss_tr_policy[__BSS_TR_DISASSOC_MAX] = {
1371 [BSS_TR_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1372 [BSS_TR_DA_IMMINENT] = { "disassociation_imminent", BLOBMSG_TYPE_BOOL },
1373 [BSS_TR_DA_TIMER] = { "disassociation_timer", BLOBMSG_TYPE_INT32 },
1374 [BSS_TR_VALID_PERIOD] = { "validity_period", BLOBMSG_TYPE_INT32 },
1375 [BSS_TR_NEIGHBORS] = { "neighbors", BLOBMSG_TYPE_ARRAY },
1376 [BSS_TR_ABRIDGED] = { "abridged", BLOBMSG_TYPE_BOOL },
1377 };
1378
1379 static int
1380 hostapd_bss_transition_request(struct ubus_context *ctx, struct ubus_object *obj,
1381 struct ubus_request_data *ureq, const char *method,
1382 struct blob_attr *msg)
1383 {
1384 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1385 struct blob_attr *tb[__BSS_TR_DISASSOC_MAX];
1386 struct sta_info *sta;
1387 u32 da_timer = 0;
1388 u32 valid_period = 0;
1389 u8 addr[ETH_ALEN];
1390 bool abridged;
1391 bool da_imminent;
1392
1393 blobmsg_parse(bss_tr_policy, __BSS_TR_DISASSOC_MAX, tb, blob_data(msg), blob_len(msg));
1394
1395 if (!tb[BSS_TR_ADDR])
1396 return UBUS_STATUS_INVALID_ARGUMENT;
1397
1398 if (hwaddr_aton(blobmsg_data(tb[BSS_TR_ADDR]), addr))
1399 return UBUS_STATUS_INVALID_ARGUMENT;
1400
1401 if (tb[BSS_TR_DA_TIMER])
1402 da_timer = blobmsg_get_u32(tb[BSS_TR_DA_TIMER]);
1403
1404 if (tb[BSS_TR_VALID_PERIOD])
1405 valid_period = blobmsg_get_u32(tb[BSS_TR_VALID_PERIOD]);
1406
1407 da_imminent = !!(tb[BSS_TR_DA_IMMINENT] && blobmsg_get_bool(tb[BSS_TR_DA_IMMINENT]));
1408 abridged = !!(tb[BSS_TR_ABRIDGED] && blobmsg_get_bool(tb[BSS_TR_ABRIDGED]));
1409
1410 return hostapd_bss_tr_send(hapd, addr, da_imminent, abridged, da_timer, valid_period,
1411 tb[BSS_TR_NEIGHBORS]);
1412 }
1413
1414 enum {
1415 WNM_DISASSOC_ADDR,
1416 WNM_DISASSOC_DURATION,
1417 WNM_DISASSOC_NEIGHBORS,
1418 WNM_DISASSOC_ABRIDGED,
1419 __WNM_DISASSOC_MAX,
1420 };
1421
1422 static const struct blobmsg_policy wnm_disassoc_policy[__WNM_DISASSOC_MAX] = {
1423 [WNM_DISASSOC_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1424 [WNM_DISASSOC_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1425 [WNM_DISASSOC_NEIGHBORS] { "neighbors", BLOBMSG_TYPE_ARRAY },
1426 [WNM_DISASSOC_ABRIDGED] { "abridged", BLOBMSG_TYPE_BOOL },
1427 };
1428
1429 static int
1430 hostapd_wnm_disassoc_imminent(struct ubus_context *ctx, struct ubus_object *obj,
1431 struct ubus_request_data *ureq, const char *method,
1432 struct blob_attr *msg)
1433 {
1434 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1435 struct blob_attr *tb[__WNM_DISASSOC_MAX];
1436 struct sta_info *sta;
1437 int duration = 10;
1438 u8 addr[ETH_ALEN];
1439 bool abridged;
1440
1441 blobmsg_parse(wnm_disassoc_policy, __WNM_DISASSOC_MAX, tb, blob_data(msg), blob_len(msg));
1442
1443 if (!tb[WNM_DISASSOC_ADDR])
1444 return UBUS_STATUS_INVALID_ARGUMENT;
1445
1446 if (hwaddr_aton(blobmsg_data(tb[WNM_DISASSOC_ADDR]), addr))
1447 return UBUS_STATUS_INVALID_ARGUMENT;
1448
1449 if (tb[WNM_DISASSOC_DURATION])
1450 duration = blobmsg_get_u32(tb[WNM_DISASSOC_DURATION]);
1451
1452 abridged = !!(tb[WNM_DISASSOC_ABRIDGED] && blobmsg_get_bool(tb[WNM_DISASSOC_ABRIDGED]));
1453
1454 return hostapd_bss_tr_send(hapd, addr, true, abridged, duration, duration,
1455 tb[WNM_DISASSOC_NEIGHBORS]);
1456 }
1457 #endif
1458
1459 #ifdef CONFIG_AIRTIME_POLICY
1460 enum {
1461 UPDATE_AIRTIME_STA,
1462 UPDATE_AIRTIME_WEIGHT,
1463 __UPDATE_AIRTIME_MAX,
1464 };
1465
1466
1467 static const struct blobmsg_policy airtime_policy[__UPDATE_AIRTIME_MAX] = {
1468 [UPDATE_AIRTIME_STA] = { "sta", BLOBMSG_TYPE_STRING },
1469 [UPDATE_AIRTIME_WEIGHT] = { "weight", BLOBMSG_TYPE_INT32 },
1470 };
1471
1472 static int
1473 hostapd_bss_update_airtime(struct ubus_context *ctx, struct ubus_object *obj,
1474 struct ubus_request_data *ureq, const char *method,
1475 struct blob_attr *msg)
1476 {
1477 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1478 struct blob_attr *tb[__UPDATE_AIRTIME_MAX];
1479 struct sta_info *sta = NULL;
1480 u8 addr[ETH_ALEN];
1481 int weight;
1482
1483 blobmsg_parse(airtime_policy, __UPDATE_AIRTIME_MAX, tb, blob_data(msg), blob_len(msg));
1484
1485 if (!tb[UPDATE_AIRTIME_WEIGHT])
1486 return UBUS_STATUS_INVALID_ARGUMENT;
1487
1488 weight = blobmsg_get_u32(tb[UPDATE_AIRTIME_WEIGHT]);
1489
1490 if (!tb[UPDATE_AIRTIME_STA]) {
1491 if (!weight)
1492 return UBUS_STATUS_INVALID_ARGUMENT;
1493
1494 hapd->conf->airtime_weight = weight;
1495 return 0;
1496 }
1497
1498 if (hwaddr_aton(blobmsg_data(tb[UPDATE_AIRTIME_STA]), addr))
1499 return UBUS_STATUS_INVALID_ARGUMENT;
1500
1501 sta = ap_get_sta(hapd, addr);
1502 if (!sta)
1503 return UBUS_STATUS_NOT_FOUND;
1504
1505 sta->dyn_airtime_weight = weight;
1506 airtime_policy_new_sta(hapd, sta);
1507
1508 return 0;
1509 }
1510 #endif
1511
1512
1513 static const struct ubus_method bss_methods[] = {
1514 UBUS_METHOD_NOARG("reload", hostapd_bss_reload),
1515 UBUS_METHOD_NOARG("get_clients", hostapd_bss_get_clients),
1516 UBUS_METHOD_NOARG("get_status", hostapd_bss_get_status),
1517 UBUS_METHOD("del_client", hostapd_bss_del_client, del_policy),
1518 #ifdef CONFIG_AIRTIME_POLICY
1519 UBUS_METHOD("update_airtime", hostapd_bss_update_airtime, airtime_policy),
1520 #endif
1521 UBUS_METHOD_NOARG("list_bans", hostapd_bss_list_bans),
1522 #ifdef CONFIG_WPS
1523 UBUS_METHOD_NOARG("wps_start", hostapd_bss_wps_start),
1524 UBUS_METHOD_NOARG("wps_status", hostapd_bss_wps_status),
1525 UBUS_METHOD_NOARG("wps_cancel", hostapd_bss_wps_cancel),
1526 #endif
1527 UBUS_METHOD_NOARG("update_beacon", hostapd_bss_update_beacon),
1528 UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features),
1529 #ifdef NEED_AP_MLME
1530 UBUS_METHOD("switch_chan", hostapd_switch_chan, csa_policy),
1531 #endif
1532 UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements, ve_policy),
1533 UBUS_METHOD("notify_response", hostapd_notify_response, notify_policy),
1534 UBUS_METHOD("bss_mgmt_enable", hostapd_bss_mgmt_enable, bss_mgmt_enable_policy),
1535 UBUS_METHOD_NOARG("rrm_nr_get_own", hostapd_rrm_nr_get_own),
1536 UBUS_METHOD_NOARG("rrm_nr_list", hostapd_rrm_nr_list),
1537 UBUS_METHOD("rrm_nr_set", hostapd_rrm_nr_set, nr_set_policy),
1538 UBUS_METHOD("rrm_beacon_req", hostapd_rrm_beacon_req, beacon_req_policy),
1539 #ifdef CONFIG_WNM_AP
1540 UBUS_METHOD("wnm_disassoc_imminent", hostapd_wnm_disassoc_imminent, wnm_disassoc_policy),
1541 UBUS_METHOD("bss_transition_request", hostapd_bss_transition_request, bss_tr_policy),
1542 #endif
1543 };
1544
1545 static struct ubus_object_type bss_object_type =
1546 UBUS_OBJECT_TYPE("hostapd_bss", bss_methods);
1547
1548 static int avl_compare_macaddr(const void *k1, const void *k2, void *ptr)
1549 {
1550 return memcmp(k1, k2, ETH_ALEN);
1551 }
1552
1553 void hostapd_ubus_add_bss(struct hostapd_data *hapd)
1554 {
1555 struct ubus_object *obj = &hapd->ubus.obj;
1556 char *name;
1557 int ret;
1558
1559 #ifdef CONFIG_MESH
1560 if (hapd->conf->mesh & MESH_ENABLED)
1561 return;
1562 #endif
1563
1564 if (!hostapd_ubus_init())
1565 return;
1566
1567 if (asprintf(&name, "hostapd.%s", hapd->conf->iface) < 0)
1568 return;
1569
1570 avl_init(&hapd->ubus.banned, avl_compare_macaddr, false, NULL);
1571 obj->name = name;
1572 obj->type = &bss_object_type;
1573 obj->methods = bss_object_type.methods;
1574 obj->n_methods = bss_object_type.n_methods;
1575 ret = ubus_add_object(ctx, obj);
1576 hostapd_ubus_ref_inc();
1577
1578 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "add");
1579 }
1580
1581 void hostapd_ubus_free_bss(struct hostapd_data *hapd)
1582 {
1583 struct ubus_object *obj = &hapd->ubus.obj;
1584 char *name = (char *) obj->name;
1585
1586 #ifdef CONFIG_MESH
1587 if (hapd->conf->mesh & MESH_ENABLED)
1588 return;
1589 #endif
1590
1591 if (!ctx)
1592 return;
1593
1594 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "remove");
1595
1596 if (obj->id) {
1597 ubus_remove_object(ctx, obj);
1598 hostapd_ubus_ref_dec();
1599 }
1600
1601 free(name);
1602 }
1603
1604 static void
1605 hostapd_ubus_vlan_action(struct hostapd_data *hapd, struct hostapd_vlan *vlan,
1606 const char *action)
1607 {
1608 struct vlan_description *desc = &vlan->vlan_desc;
1609 void *c;
1610 int i;
1611
1612 if (!hapd->ubus.obj.has_subscribers)
1613 return;
1614
1615 blob_buf_init(&b, 0);
1616 blobmsg_add_string(&b, "ifname", vlan->ifname);
1617 blobmsg_add_string(&b, "bridge", vlan->bridge);
1618 blobmsg_add_u32(&b, "vlan_id", vlan->vlan_id);
1619
1620 if (desc->notempty) {
1621 blobmsg_add_u32(&b, "untagged", desc->untagged);
1622 c = blobmsg_open_array(&b, "tagged");
1623 for (i = 0; i < ARRAY_SIZE(desc->tagged) && desc->tagged[i]; i++)
1624 blobmsg_add_u32(&b, "", desc->tagged[i]);
1625 blobmsg_close_array(&b, c);
1626 }
1627
1628 ubus_notify(ctx, &hapd->ubus.obj, action, b.head, -1);
1629 }
1630
1631 void hostapd_ubus_add_vlan(struct hostapd_data *hapd, struct hostapd_vlan *vlan)
1632 {
1633 hostapd_ubus_vlan_action(hapd, vlan, "vlan_add");
1634 }
1635
1636 void hostapd_ubus_remove_vlan(struct hostapd_data *hapd, struct hostapd_vlan *vlan)
1637 {
1638 hostapd_ubus_vlan_action(hapd, vlan, "vlan_remove");
1639 }
1640
1641 static const struct ubus_method daemon_methods[] = {
1642 UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
1643 UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
1644 };
1645
1646 static struct ubus_object_type daemon_object_type =
1647 UBUS_OBJECT_TYPE("hostapd", daemon_methods);
1648
1649 void hostapd_ubus_add(struct hapd_interfaces *interfaces)
1650 {
1651 struct ubus_object *obj = &interfaces->ubus;
1652 int ret;
1653
1654 if (!hostapd_ubus_init())
1655 return;
1656
1657 obj->name = strdup("hostapd");
1658
1659 obj->type = &daemon_object_type;
1660 obj->methods = daemon_object_type.methods;
1661 obj->n_methods = daemon_object_type.n_methods;
1662 ret = ubus_add_object(ctx, obj);
1663 hostapd_ubus_ref_inc();
1664 }
1665
1666 void hostapd_ubus_free(struct hapd_interfaces *interfaces)
1667 {
1668 struct ubus_object *obj = &interfaces->ubus;
1669 char *name = (char *) obj->name;
1670
1671 if (!ctx)
1672 return;
1673
1674 if (obj->id) {
1675 ubus_remove_object(ctx, obj);
1676 hostapd_ubus_ref_dec();
1677 }
1678
1679 free(name);
1680 }
1681
1682 struct ubus_event_req {
1683 struct ubus_notify_request nreq;
1684 int resp;
1685 };
1686
1687 static void
1688 ubus_event_cb(struct ubus_notify_request *req, int idx, int ret)
1689 {
1690 struct ubus_event_req *ureq = container_of(req, struct ubus_event_req, nreq);
1691
1692 ureq->resp = ret;
1693 }
1694
1695 int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
1696 {
1697 struct ubus_banned_client *ban;
1698 const char *types[HOSTAPD_UBUS_TYPE_MAX] = {
1699 [HOSTAPD_UBUS_PROBE_REQ] = "probe",
1700 [HOSTAPD_UBUS_AUTH_REQ] = "auth",
1701 [HOSTAPD_UBUS_ASSOC_REQ] = "assoc",
1702 };
1703 const char *type = "mgmt";
1704 struct ubus_event_req ureq = {};
1705 const u8 *addr;
1706
1707 if (req->mgmt_frame)
1708 addr = req->mgmt_frame->sa;
1709 else
1710 addr = req->addr;
1711
1712 ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
1713 if (ban)
1714 return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
1715
1716 if (!hapd->ubus.obj.has_subscribers)
1717 return WLAN_STATUS_SUCCESS;
1718
1719 if (req->type < ARRAY_SIZE(types))
1720 type = types[req->type];
1721
1722 blob_buf_init(&b, 0);
1723 blobmsg_add_macaddr(&b, "address", addr);
1724 if (req->mgmt_frame)
1725 blobmsg_add_macaddr(&b, "target", req->mgmt_frame->da);
1726 if (req->ssi_signal)
1727 blobmsg_add_u32(&b, "signal", req->ssi_signal);
1728 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
1729
1730 if (req->elems) {
1731 if(req->elems->ht_capabilities)
1732 {
1733 struct ieee80211_ht_capabilities *ht_capabilities;
1734 void *ht_cap, *ht_cap_mcs_set, *mcs_set;
1735
1736
1737 ht_capabilities = (struct ieee80211_ht_capabilities*) req->elems->ht_capabilities;
1738 ht_cap = blobmsg_open_table(&b, "ht_capabilities");
1739 blobmsg_add_u16(&b, "ht_capabilities_info", ht_capabilities->ht_capabilities_info);
1740 ht_cap_mcs_set = blobmsg_open_table(&b, "supported_mcs_set");
1741 blobmsg_add_u16(&b, "a_mpdu_params", ht_capabilities->a_mpdu_params);
1742 blobmsg_add_u16(&b, "ht_extended_capabilities", ht_capabilities->ht_extended_capabilities);
1743 blobmsg_add_u32(&b, "tx_bf_capability_info", ht_capabilities->tx_bf_capability_info);
1744 blobmsg_add_u16(&b, "asel_capabilities", ht_capabilities->asel_capabilities);
1745 mcs_set = blobmsg_open_array(&b, "supported_mcs_set");
1746 for (int i = 0; i < 16; i++) {
1747 blobmsg_add_u16(&b, NULL, (u16) ht_capabilities->supported_mcs_set[i]);
1748 }
1749 blobmsg_close_array(&b, mcs_set);
1750 blobmsg_close_table(&b, ht_cap_mcs_set);
1751 blobmsg_close_table(&b, ht_cap);
1752 }
1753 if(req->elems->vht_capabilities)
1754 {
1755 struct ieee80211_vht_capabilities *vht_capabilities;
1756 void *vht_cap, *vht_cap_mcs_set;
1757
1758 vht_capabilities = (struct ieee80211_vht_capabilities*) req->elems->vht_capabilities;
1759 vht_cap = blobmsg_open_table(&b, "vht_capabilities");
1760 blobmsg_add_u32(&b, "vht_capabilities_info", vht_capabilities->vht_capabilities_info);
1761 vht_cap_mcs_set = blobmsg_open_table(&b, "vht_supported_mcs_set");
1762 blobmsg_add_u16(&b, "rx_map", vht_capabilities->vht_supported_mcs_set.rx_map);
1763 blobmsg_add_u16(&b, "rx_highest", vht_capabilities->vht_supported_mcs_set.rx_highest);
1764 blobmsg_add_u16(&b, "tx_map", vht_capabilities->vht_supported_mcs_set.tx_map);
1765 blobmsg_add_u16(&b, "tx_highest", vht_capabilities->vht_supported_mcs_set.tx_highest);
1766 blobmsg_close_table(&b, vht_cap_mcs_set);
1767 blobmsg_close_table(&b, vht_cap);
1768 }
1769 }
1770
1771 if (!hapd->ubus.notify_response) {
1772 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1773 return WLAN_STATUS_SUCCESS;
1774 }
1775
1776 if (ubus_notify_async(ctx, &hapd->ubus.obj, type, b.head, &ureq.nreq))
1777 return WLAN_STATUS_SUCCESS;
1778
1779 ureq.nreq.status_cb = ubus_event_cb;
1780 ubus_complete_request(ctx, &ureq.nreq.req, 100);
1781
1782 if (ureq.resp)
1783 return ureq.resp;
1784
1785 return WLAN_STATUS_SUCCESS;
1786 }
1787
1788 void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *addr)
1789 {
1790 if (!hapd->ubus.obj.has_subscribers)
1791 return;
1792
1793 if (!addr)
1794 return;
1795
1796 blob_buf_init(&b, 0);
1797 blobmsg_add_macaddr(&b, "address", addr);
1798
1799 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1800 }
1801
1802 void hostapd_ubus_notify_beacon_report(
1803 struct hostapd_data *hapd, const u8 *addr, u8 token, u8 rep_mode,
1804 struct rrm_measurement_beacon_report *rep, size_t len)
1805 {
1806 if (!hapd->ubus.obj.has_subscribers)
1807 return;
1808
1809 if (!addr || !rep)
1810 return;
1811
1812 blob_buf_init(&b, 0);
1813 blobmsg_add_macaddr(&b, "address", addr);
1814 blobmsg_add_u16(&b, "op-class", rep->op_class);
1815 blobmsg_add_u16(&b, "channel", rep->channel);
1816 blobmsg_add_u64(&b, "start-time", rep->start_time);
1817 blobmsg_add_u16(&b, "duration", rep->duration);
1818 blobmsg_add_u16(&b, "report-info", rep->report_info);
1819 blobmsg_add_u16(&b, "rcpi", rep->rcpi);
1820 blobmsg_add_u16(&b, "rsni", rep->rsni);
1821 blobmsg_add_macaddr(&b, "bssid", rep->bssid);
1822 blobmsg_add_u16(&b, "antenna-id", rep->antenna_id);
1823 blobmsg_add_u16(&b, "parent-tsf", rep->parent_tsf);
1824
1825 ubus_notify(ctx, &hapd->ubus.obj, "beacon-report", b.head, -1);
1826 }
1827
1828 void hostapd_ubus_notify_radar_detected(struct hostapd_iface *iface, int frequency,
1829 int chan_width, int cf1, int cf2)
1830 {
1831 struct hostapd_data *hapd;
1832 int i;
1833
1834 blob_buf_init(&b, 0);
1835 blobmsg_add_u16(&b, "frequency", frequency);
1836 blobmsg_add_u16(&b, "width", chan_width);
1837 blobmsg_add_u16(&b, "center1", cf1);
1838 blobmsg_add_u16(&b, "center2", cf2);
1839
1840 for (i = 0; i < iface->num_bss; i++) {
1841 hapd = iface->bss[i];
1842 ubus_notify(ctx, &hapd->ubus.obj, "radar-detected", b.head, -1);
1843 }
1844 }
1845
1846 void hostapd_ubus_notify_bss_transition_response(
1847 struct hostapd_data *hapd, const u8 *addr, u8 dialog_token, u8 status_code,
1848 u8 bss_termination_delay, const u8 *target_bssid,
1849 const u8 *candidate_list, u16 candidate_list_len)
1850 {
1851 #ifdef CONFIG_WNM_AP
1852 char *cl_str;
1853 u16 i;
1854
1855 if (!hapd->ubus.obj.has_subscribers)
1856 return;
1857
1858 if (!addr)
1859 return;
1860
1861 blob_buf_init(&b, 0);
1862 blobmsg_add_macaddr(&b, "address", addr);
1863 blobmsg_add_u8(&b, "dialog-token", dialog_token);
1864 blobmsg_add_u8(&b, "status-code", status_code);
1865 blobmsg_add_u8(&b, "bss-termination-delay", bss_termination_delay);
1866 if (target_bssid)
1867 blobmsg_add_macaddr(&b, "target-bssid", target_bssid);
1868 if (candidate_list_len > 0) {
1869 cl_str = blobmsg_alloc_string_buffer(&b, "candidate-list", candidate_list_len * 2 + 1);
1870 for (i = 0; i < candidate_list_len; i++)
1871 snprintf(&cl_str[i*2], 3, "%02X", candidate_list[i]);
1872 blobmsg_add_string_buffer(&b);
1873 }
1874
1875 ubus_notify(ctx, &hapd->ubus.obj, "bss-transition-response", b.head, -1);
1876 #endif
1877 }
Staging tree of Mathias Kresin