projects / openwrt / staging / mkresin.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
hostapd: add ubus notifications for adding/removing vlan interfaces
[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
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 blob_buf_init(&b, 0);
662 blobmsg_add_u32(&b, "pid", getpid());
663 ubus_send_reply(ctx, req, b.head);
664
665 return UBUS_STATUS_OK;
666 }
667
668 enum {
669 CONFIG_REM_IFACE,
670 __CONFIG_REM_MAX
671 };
672
673 static const struct blobmsg_policy config_remove_policy[__CONFIG_REM_MAX] = {
674 [CONFIG_REM_IFACE] = { "iface", BLOBMSG_TYPE_STRING },
675 };
676
677 static int
678 hostapd_config_remove(struct ubus_context *ctx, struct ubus_object *obj,
679 struct ubus_request_data *req, const char *method,
680 struct blob_attr *msg)
681 {
682 struct blob_attr *tb[__CONFIG_REM_MAX];
683 struct hapd_interfaces *interfaces = get_hapd_interfaces_from_object(obj);
684 char buf[128];
685
686 blobmsg_parse(config_remove_policy, __CONFIG_REM_MAX, tb, blob_data(msg), blob_len(msg));
687
688 if (!tb[CONFIG_REM_IFACE])
689 return UBUS_STATUS_INVALID_ARGUMENT;
690
691 if (hostapd_remove_iface(interfaces, blobmsg_get_string(tb[CONFIG_REM_IFACE])))
692 return UBUS_STATUS_INVALID_ARGUMENT;
693
694 return UBUS_STATUS_OK;
695 }
696
697 enum {
698 CSA_FREQ,
699 CSA_BCN_COUNT,
700 CSA_CENTER_FREQ1,
701 CSA_CENTER_FREQ2,
702 CSA_BANDWIDTH,
703 CSA_SEC_CHANNEL_OFFSET,
704 CSA_HT,
705 CSA_VHT,
706 CSA_BLOCK_TX,
707 __CSA_MAX
708 };
709
710 static const struct blobmsg_policy csa_policy[__CSA_MAX] = {
711 [CSA_FREQ] = { "freq", BLOBMSG_TYPE_INT32 },
712 [CSA_BCN_COUNT] = { "bcn_count", BLOBMSG_TYPE_INT32 },
713 [CSA_CENTER_FREQ1] = { "center_freq1", BLOBMSG_TYPE_INT32 },
714 [CSA_CENTER_FREQ2] = { "center_freq2", BLOBMSG_TYPE_INT32 },
715 [CSA_BANDWIDTH] = { "bandwidth", BLOBMSG_TYPE_INT32 },
716 [CSA_SEC_CHANNEL_OFFSET] = { "sec_channel_offset", BLOBMSG_TYPE_INT32 },
717 [CSA_HT] = { "ht", BLOBMSG_TYPE_BOOL },
718 [CSA_VHT] = { "vht", BLOBMSG_TYPE_BOOL },
719 [CSA_BLOCK_TX] = { "block_tx", BLOBMSG_TYPE_BOOL },
720 };
721
722 #ifdef NEED_AP_MLME
723 static int
724 hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
725 struct ubus_request_data *req, const char *method,
726 struct blob_attr *msg)
727 {
728 struct blob_attr *tb[__CSA_MAX];
729 struct hostapd_data *hapd = get_hapd_from_object(obj);
730 struct csa_settings css;
731
732 blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
733
734 if (!tb[CSA_FREQ])
735 return UBUS_STATUS_INVALID_ARGUMENT;
736
737 memset(&css, 0, sizeof(css));
738 css.freq_params.freq = blobmsg_get_u32(tb[CSA_FREQ]);
739
740 #define SET_CSA_SETTING(name, field, type) \
741 do { \
742 if (tb[name]) \
743 css.field = blobmsg_get_ ## type(tb[name]); \
744 } while(0)
745
746 SET_CSA_SETTING(CSA_BCN_COUNT, cs_count, u32);
747 SET_CSA_SETTING(CSA_CENTER_FREQ1, freq_params.center_freq1, u32);
748 SET_CSA_SETTING(CSA_CENTER_FREQ2, freq_params.center_freq2, u32);
749 SET_CSA_SETTING(CSA_BANDWIDTH, freq_params.bandwidth, u32);
750 SET_CSA_SETTING(CSA_SEC_CHANNEL_OFFSET, freq_params.sec_channel_offset, u32);
751 SET_CSA_SETTING(CSA_HT, freq_params.ht_enabled, bool);
752 SET_CSA_SETTING(CSA_VHT, freq_params.vht_enabled, bool);
753 SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
754
755
756 if (hostapd_switch_channel(hapd, &css) != 0)
757 return UBUS_STATUS_NOT_SUPPORTED;
758 return UBUS_STATUS_OK;
759 #undef SET_CSA_SETTING
760 }
761 #endif
762
763 enum {
764 VENDOR_ELEMENTS,
765 __VENDOR_ELEMENTS_MAX
766 };
767
768 static const struct blobmsg_policy ve_policy[__VENDOR_ELEMENTS_MAX] = {
769 /* vendor elements are provided as hex-string */
770 [VENDOR_ELEMENTS] = { "vendor_elements", BLOBMSG_TYPE_STRING },
771 };
772
773 static int
774 hostapd_vendor_elements(struct ubus_context *ctx, struct ubus_object *obj,
775 struct ubus_request_data *req, const char *method,
776 struct blob_attr *msg)
777 {
778 struct blob_attr *tb[__VENDOR_ELEMENTS_MAX];
779 struct hostapd_data *hapd = get_hapd_from_object(obj);
780 struct hostapd_bss_config *bss = hapd->conf;
781 struct wpabuf *elems;
782 const char *pos;
783 size_t len;
784
785 blobmsg_parse(ve_policy, __VENDOR_ELEMENTS_MAX, tb,
786 blob_data(msg), blob_len(msg));
787
788 if (!tb[VENDOR_ELEMENTS])
789 return UBUS_STATUS_INVALID_ARGUMENT;
790
791 pos = blobmsg_data(tb[VENDOR_ELEMENTS]);
792 len = os_strlen(pos);
793 if (len & 0x01)
794 return UBUS_STATUS_INVALID_ARGUMENT;
795
796 len /= 2;
797 if (len == 0) {
798 wpabuf_free(bss->vendor_elements);
799 bss->vendor_elements = NULL;
800 return 0;
801 }
802
803 elems = wpabuf_alloc(len);
804 if (elems == NULL)
805 return 1;
806
807 if (hexstr2bin(pos, wpabuf_put(elems, len), len)) {
808 wpabuf_free(elems);
809 return UBUS_STATUS_INVALID_ARGUMENT;
810 }
811
812 wpabuf_free(bss->vendor_elements);
813 bss->vendor_elements = elems;
814
815 /* update beacons if vendor elements were set successfully */
816 if (ieee802_11_update_beacons(hapd->iface) != 0)
817 return UBUS_STATUS_NOT_SUPPORTED;
818 return UBUS_STATUS_OK;
819 }
820
821 static void
822 hostapd_rrm_print_nr(struct hostapd_neighbor_entry *nr)
823 {
824 const u8 *data;
825 char *str;
826 int len;
827
828 blobmsg_printf(&b, "", MACSTR, MAC2STR(nr->bssid));
829
830 str = blobmsg_alloc_string_buffer(&b, "", nr->ssid.ssid_len + 1);
831 memcpy(str, nr->ssid.ssid, nr->ssid.ssid_len);
832 str[nr->ssid.ssid_len] = 0;
833 blobmsg_add_string_buffer(&b);
834
835 len = wpabuf_len(nr->nr);
836 str = blobmsg_alloc_string_buffer(&b, "", 2 * len + 1);
837 wpa_snprintf_hex(str, 2 * len + 1, wpabuf_head_u8(nr->nr), len);
838 blobmsg_add_string_buffer(&b);
839 }
840
841 enum {
842 BSS_MGMT_EN_NEIGHBOR,
843 BSS_MGMT_EN_BEACON,
844 #ifdef CONFIG_WNM_AP
845 BSS_MGMT_EN_BSS_TRANSITION,
846 #endif
847 __BSS_MGMT_EN_MAX
848 };
849
850 static bool
851 __hostapd_bss_mgmt_enable_f(struct hostapd_data *hapd, int flag)
852 {
853 struct hostapd_bss_config *bss = hapd->conf;
854 uint32_t flags;
855
856 switch (flag) {
857 case BSS_MGMT_EN_NEIGHBOR:
858 if (bss->radio_measurements[0] &
859 WLAN_RRM_CAPS_NEIGHBOR_REPORT)
860 return false;
861
862 bss->radio_measurements[0] |=
863 WLAN_RRM_CAPS_NEIGHBOR_REPORT;
864 hostapd_neighbor_set_own_report(hapd);
865 return true;
866 case BSS_MGMT_EN_BEACON:
867 flags = WLAN_RRM_CAPS_BEACON_REPORT_PASSIVE |
868 WLAN_RRM_CAPS_BEACON_REPORT_ACTIVE |
869 WLAN_RRM_CAPS_BEACON_REPORT_TABLE;
870
871 if (bss->radio_measurements[0] & flags == flags)
872 return false;
873
874 bss->radio_measurements[0] |= (u8) flags;
875 return true;
876 #ifdef CONFIG_WNM_AP
877 case BSS_MGMT_EN_BSS_TRANSITION:
878 if (bss->bss_transition)
879 return false;
880
881 bss->bss_transition = 1;
882 return true;
883 #endif
884 }
885 }
886
887 static void
888 __hostapd_bss_mgmt_enable(struct hostapd_data *hapd, uint32_t flags)
889 {
890 bool update = false;
891 int i;
892
893 for (i = 0; i < __BSS_MGMT_EN_MAX; i++) {
894 if (!(flags & (1 << i)))
895 continue;
896
897 update |= __hostapd_bss_mgmt_enable_f(hapd, i);
898 }
899
900 if (update)
901 ieee802_11_update_beacons(hapd->iface);
902 }
903
904
905 static const struct blobmsg_policy bss_mgmt_enable_policy[__BSS_MGMT_EN_MAX] = {
906 [BSS_MGMT_EN_NEIGHBOR] = { "neighbor_report", BLOBMSG_TYPE_BOOL },
907 [BSS_MGMT_EN_BEACON] = { "beacon_report", BLOBMSG_TYPE_BOOL },
908 #ifdef CONFIG_WNM_AP
909 [BSS_MGMT_EN_BSS_TRANSITION] = { "bss_transition", BLOBMSG_TYPE_BOOL },
910 #endif
911 };
912
913 static int
914 hostapd_bss_mgmt_enable(struct ubus_context *ctx, struct ubus_object *obj,
915 struct ubus_request_data *req, const char *method,
916 struct blob_attr *msg)
917
918 {
919 struct hostapd_data *hapd = get_hapd_from_object(obj);
920 struct blob_attr *tb[__BSS_MGMT_EN_MAX];
921 struct blob_attr *cur;
922 uint32_t flags = 0;
923 int i;
924 bool neigh = false, beacon = false;
925
926 blobmsg_parse(bss_mgmt_enable_policy, __BSS_MGMT_EN_MAX, tb, blob_data(msg), blob_len(msg));
927
928 for (i = 0; i < ARRAY_SIZE(tb); i++) {
929 if (!tb[i] || !blobmsg_get_bool(tb[i]))
930 continue;
931
932 flags |= (1 << i);
933 }
934
935 __hostapd_bss_mgmt_enable(hapd, flags);
936 }
937
938
939 static void
940 hostapd_rrm_nr_enable(struct hostapd_data *hapd)
941 {
942 __hostapd_bss_mgmt_enable(hapd, 1 << BSS_MGMT_EN_NEIGHBOR);
943 }
944
945 static int
946 hostapd_rrm_nr_get_own(struct ubus_context *ctx, struct ubus_object *obj,
947 struct ubus_request_data *req, const char *method,
948 struct blob_attr *msg)
949 {
950 struct hostapd_data *hapd = get_hapd_from_object(obj);
951 struct hostapd_neighbor_entry *nr;
952 void *c;
953
954 hostapd_rrm_nr_enable(hapd);
955
956 nr = hostapd_neighbor_get(hapd, hapd->own_addr, NULL);
957 if (!nr)
958 return UBUS_STATUS_NOT_FOUND;
959
960 blob_buf_init(&b, 0);
961
962 c = blobmsg_open_array(&b, "value");
963 hostapd_rrm_print_nr(nr);
964 blobmsg_close_array(&b, c);
965
966 ubus_send_reply(ctx, req, b.head);
967
968 return 0;
969 }
970
971 static int
972 hostapd_rrm_nr_list(struct ubus_context *ctx, struct ubus_object *obj,
973 struct ubus_request_data *req, const char *method,
974 struct blob_attr *msg)
975 {
976 struct hostapd_data *hapd = get_hapd_from_object(obj);
977 struct hostapd_neighbor_entry *nr;
978 void *c;
979
980 hostapd_rrm_nr_enable(hapd);
981 blob_buf_init(&b, 0);
982
983 c = blobmsg_open_array(&b, "list");
984 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
985 void *cur;
986
987 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
988 continue;
989
990 cur = blobmsg_open_array(&b, NULL);
991 hostapd_rrm_print_nr(nr);
992 blobmsg_close_array(&b, cur);
993 }
994 blobmsg_close_array(&b, c);
995
996 ubus_send_reply(ctx, req, b.head);
997
998 return 0;
999 }
1000
1001 enum {
1002 NR_SET_LIST,
1003 __NR_SET_LIST_MAX
1004 };
1005
1006 static const struct blobmsg_policy nr_set_policy[__NR_SET_LIST_MAX] = {
1007 [NR_SET_LIST] = { "list", BLOBMSG_TYPE_ARRAY },
1008 };
1009
1010
1011 static void
1012 hostapd_rrm_nr_clear(struct hostapd_data *hapd)
1013 {
1014 struct hostapd_neighbor_entry *nr;
1015
1016 restart:
1017 dl_list_for_each(nr, &hapd->nr_db, struct hostapd_neighbor_entry, list) {
1018 if (!memcmp(nr->bssid, hapd->own_addr, ETH_ALEN))
1019 continue;
1020
1021 hostapd_neighbor_remove(hapd, nr->bssid, &nr->ssid);
1022 goto restart;
1023 }
1024 }
1025
1026 static int
1027 hostapd_rrm_nr_set(struct ubus_context *ctx, struct ubus_object *obj,
1028 struct ubus_request_data *req, const char *method,
1029 struct blob_attr *msg)
1030 {
1031 static const struct blobmsg_policy nr_e_policy[] = {
1032 { .type = BLOBMSG_TYPE_STRING },
1033 { .type = BLOBMSG_TYPE_STRING },
1034 { .type = BLOBMSG_TYPE_STRING },
1035 };
1036 struct hostapd_data *hapd = get_hapd_from_object(obj);
1037 struct blob_attr *tb_l[__NR_SET_LIST_MAX];
1038 struct blob_attr *tb[ARRAY_SIZE(nr_e_policy)];
1039 struct blob_attr *cur;
1040 int rem;
1041
1042 hostapd_rrm_nr_enable(hapd);
1043
1044 blobmsg_parse(nr_set_policy, __NR_SET_LIST_MAX, tb_l, blob_data(msg), blob_len(msg));
1045 if (!tb_l[NR_SET_LIST])
1046 return UBUS_STATUS_INVALID_ARGUMENT;
1047
1048 hostapd_rrm_nr_clear(hapd);
1049 blobmsg_for_each_attr(cur, tb_l[NR_SET_LIST], rem) {
1050 struct wpa_ssid_value ssid;
1051 struct wpabuf *data;
1052 u8 bssid[ETH_ALEN];
1053 char *s, *nr_s;
1054
1055 blobmsg_parse_array(nr_e_policy, ARRAY_SIZE(nr_e_policy), tb, blobmsg_data(cur), blobmsg_data_len(cur));
1056 if (!tb[0] || !tb[1] || !tb[2])
1057 goto invalid;
1058
1059 /* Neighbor Report binary */
1060 nr_s = blobmsg_get_string(tb[2]);
1061 data = wpabuf_parse_bin(nr_s);
1062 if (!data)
1063 goto invalid;
1064
1065 /* BSSID */
1066 s = blobmsg_get_string(tb[0]);
1067 if (strlen(s) == 0) {
1068 /* Copy BSSID from neighbor report */
1069 if (hwaddr_compact_aton(nr_s, bssid))
1070 goto invalid;
1071 } else if (hwaddr_aton(s, bssid)) {
1072 goto invalid;
1073 }
1074
1075 /* SSID */
1076 s = blobmsg_get_string(tb[1]);
1077 if (strlen(s) == 0) {
1078 /* Copy SSID from hostapd BSS conf */
1079 memcpy(&ssid, &hapd->conf->ssid, sizeof(ssid));
1080 } else {
1081 ssid.ssid_len = strlen(s);
1082 if (ssid.ssid_len > sizeof(ssid.ssid))
1083 goto invalid;
1084
1085 memcpy(&ssid, s, ssid.ssid_len);
1086 }
1087
1088 hostapd_neighbor_set(hapd, bssid, &ssid, data, NULL, NULL, 0);
1089 wpabuf_free(data);
1090 continue;
1091
1092 invalid:
1093 return UBUS_STATUS_INVALID_ARGUMENT;
1094 }
1095
1096 return 0;
1097 }
1098
1099 enum {
1100 BEACON_REQ_ADDR,
1101 BEACON_REQ_MODE,
1102 BEACON_REQ_OP_CLASS,
1103 BEACON_REQ_CHANNEL,
1104 BEACON_REQ_DURATION,
1105 BEACON_REQ_BSSID,
1106 BEACON_REQ_SSID,
1107 __BEACON_REQ_MAX,
1108 };
1109
1110 static const struct blobmsg_policy beacon_req_policy[__BEACON_REQ_MAX] = {
1111 [BEACON_REQ_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1112 [BEACON_REQ_OP_CLASS] { "op_class", BLOBMSG_TYPE_INT32 },
1113 [BEACON_REQ_CHANNEL] { "channel", BLOBMSG_TYPE_INT32 },
1114 [BEACON_REQ_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1115 [BEACON_REQ_MODE] { "mode", BLOBMSG_TYPE_INT32 },
1116 [BEACON_REQ_BSSID] { "bssid", BLOBMSG_TYPE_STRING },
1117 [BEACON_REQ_SSID] { "ssid", BLOBMSG_TYPE_STRING },
1118 };
1119
1120 static int
1121 hostapd_rrm_beacon_req(struct ubus_context *ctx, struct ubus_object *obj,
1122 struct ubus_request_data *ureq, const char *method,
1123 struct blob_attr *msg)
1124 {
1125 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1126 struct blob_attr *tb[__BEACON_REQ_MAX];
1127 struct blob_attr *cur;
1128 struct wpabuf *req;
1129 u8 bssid[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1130 u8 addr[ETH_ALEN];
1131 int mode, rem, ret;
1132 int buf_len = 13;
1133
1134 blobmsg_parse(beacon_req_policy, __BEACON_REQ_MAX, tb, blob_data(msg), blob_len(msg));
1135
1136 if (!tb[BEACON_REQ_ADDR] || !tb[BEACON_REQ_MODE] || !tb[BEACON_REQ_DURATION] ||
1137 !tb[BEACON_REQ_OP_CLASS] || !tb[BEACON_REQ_CHANNEL])
1138 return UBUS_STATUS_INVALID_ARGUMENT;
1139
1140 if (tb[BEACON_REQ_SSID])
1141 buf_len += blobmsg_data_len(tb[BEACON_REQ_SSID]) + 2 - 1;
1142
1143 mode = blobmsg_get_u32(tb[BEACON_REQ_MODE]);
1144 if (hwaddr_aton(blobmsg_data(tb[BEACON_REQ_ADDR]), addr))
1145 return UBUS_STATUS_INVALID_ARGUMENT;
1146
1147 if (tb[BEACON_REQ_BSSID] &&
1148 hwaddr_aton(blobmsg_data(tb[BEACON_REQ_BSSID]), bssid))
1149 return UBUS_STATUS_INVALID_ARGUMENT;
1150
1151 req = wpabuf_alloc(buf_len);
1152 if (!req)
1153 return UBUS_STATUS_UNKNOWN_ERROR;
1154
1155 /* 1: regulatory class */
1156 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_OP_CLASS]));
1157
1158 /* 2: channel number */
1159 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_CHANNEL]));
1160
1161 /* 3-4: randomization interval */
1162 wpabuf_put_le16(req, 0);
1163
1164 /* 5-6: duration */
1165 wpabuf_put_le16(req, blobmsg_get_u32(tb[BEACON_REQ_DURATION]));
1166
1167 /* 7: mode */
1168 wpabuf_put_u8(req, blobmsg_get_u32(tb[BEACON_REQ_MODE]));
1169
1170 /* 8-13: BSSID */
1171 wpabuf_put_data(req, bssid, ETH_ALEN);
1172
1173 if ((cur = tb[BEACON_REQ_SSID]) != NULL) {
1174 wpabuf_put_u8(req, WLAN_EID_SSID);
1175 wpabuf_put_u8(req, blobmsg_data_len(cur) - 1);
1176 wpabuf_put_data(req, blobmsg_data(cur), blobmsg_data_len(cur) - 1);
1177 }
1178
1179 ret = hostapd_send_beacon_req(hapd, addr, 0, req);
1180 if (ret < 0)
1181 return -ret;
1182
1183 return 0;
1184 }
1185
1186
1187 #ifdef CONFIG_WNM_AP
1188 enum {
1189 WNM_DISASSOC_ADDR,
1190 WNM_DISASSOC_DURATION,
1191 WNM_DISASSOC_NEIGHBORS,
1192 WNM_DISASSOC_ABRIDGED,
1193 __WNM_DISASSOC_MAX,
1194 };
1195
1196 static const struct blobmsg_policy wnm_disassoc_policy[__WNM_DISASSOC_MAX] = {
1197 [WNM_DISASSOC_ADDR] = { "addr", BLOBMSG_TYPE_STRING },
1198 [WNM_DISASSOC_DURATION] { "duration", BLOBMSG_TYPE_INT32 },
1199 [WNM_DISASSOC_NEIGHBORS] { "neighbors", BLOBMSG_TYPE_ARRAY },
1200 [WNM_DISASSOC_ABRIDGED] { "abridged", BLOBMSG_TYPE_BOOL },
1201 };
1202
1203 static int
1204 hostapd_wnm_disassoc_imminent(struct ubus_context *ctx, struct ubus_object *obj,
1205 struct ubus_request_data *ureq, const char *method,
1206 struct blob_attr *msg)
1207 {
1208 struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
1209 struct blob_attr *tb[__WNM_DISASSOC_MAX];
1210 struct blob_attr *cur;
1211 struct sta_info *sta;
1212 int duration = 10;
1213 int rem;
1214 int nr_len = 0;
1215 u8 *nr = NULL;
1216 u8 req_mode = WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
1217 u8 addr[ETH_ALEN];
1218
1219 blobmsg_parse(wnm_disassoc_policy, __WNM_DISASSOC_MAX, tb, blob_data(msg), blob_len(msg));
1220
1221 if (!tb[WNM_DISASSOC_ADDR])
1222 return UBUS_STATUS_INVALID_ARGUMENT;
1223
1224 if (hwaddr_aton(blobmsg_data(tb[WNM_DISASSOC_ADDR]), addr))
1225 return UBUS_STATUS_INVALID_ARGUMENT;
1226
1227 if ((cur = tb[WNM_DISASSOC_DURATION]) != NULL)
1228 duration = blobmsg_get_u32(cur);
1229
1230 sta = ap_get_sta(hapd, addr);
1231 if (!sta)
1232 return UBUS_STATUS_NOT_FOUND;
1233
1234 if (tb[WNM_DISASSOC_NEIGHBORS]) {
1235 u8 *nr_cur;
1236
1237 if (blobmsg_check_array(tb[WNM_DISASSOC_NEIGHBORS],
1238 BLOBMSG_TYPE_STRING) < 0)
1239 return UBUS_STATUS_INVALID_ARGUMENT;
1240
1241 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1242 int len = strlen(blobmsg_get_string(cur));
1243
1244 if (len % 2)
1245 return UBUS_STATUS_INVALID_ARGUMENT;
1246
1247 nr_len += (len / 2) + 2;
1248 }
1249
1250 if (nr_len) {
1251 nr = os_zalloc(nr_len);
1252 if (!nr)
1253 return UBUS_STATUS_UNKNOWN_ERROR;
1254 }
1255
1256 nr_cur = nr;
1257 blobmsg_for_each_attr(cur, tb[WNM_DISASSOC_NEIGHBORS], rem) {
1258 int len = strlen(blobmsg_get_string(cur)) / 2;
1259
1260 *nr_cur++ = WLAN_EID_NEIGHBOR_REPORT;
1261 *nr_cur++ = (u8) len;
1262 if (hexstr2bin(blobmsg_data(cur), nr_cur, len)) {
1263 free(nr);
1264 return UBUS_STATUS_INVALID_ARGUMENT;
1265 }
1266
1267 nr_cur += len;
1268 }
1269 }
1270
1271 if (nr)
1272 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
1273
1274 if (tb[WNM_DISASSOC_ABRIDGED] && blobmsg_get_bool(tb[WNM_DISASSOC_ABRIDGED]))
1275 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
1276
1277 if (wnm_send_bss_tm_req(hapd, sta, req_mode, duration, duration, NULL,
1278 NULL, nr, nr_len, NULL, 0))
1279 return UBUS_STATUS_UNKNOWN_ERROR;
1280
1281 return 0;
1282 }
1283 #endif
1284
1285 static const struct ubus_method bss_methods[] = {
1286 UBUS_METHOD_NOARG("reload", hostapd_bss_reload),
1287 UBUS_METHOD_NOARG("get_clients", hostapd_bss_get_clients),
1288 UBUS_METHOD_NOARG("get_status", hostapd_bss_get_status),
1289 UBUS_METHOD("del_client", hostapd_bss_del_client, del_policy),
1290 UBUS_METHOD_NOARG("list_bans", hostapd_bss_list_bans),
1291 #ifdef CONFIG_WPS
1292 UBUS_METHOD_NOARG("wps_start", hostapd_bss_wps_start),
1293 UBUS_METHOD_NOARG("wps_status", hostapd_bss_wps_status),
1294 UBUS_METHOD_NOARG("wps_cancel", hostapd_bss_wps_cancel),
1295 #endif
1296 UBUS_METHOD_NOARG("update_beacon", hostapd_bss_update_beacon),
1297 UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features),
1298 #ifdef NEED_AP_MLME
1299 UBUS_METHOD("switch_chan", hostapd_switch_chan, csa_policy),
1300 #endif
1301 UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements, ve_policy),
1302 UBUS_METHOD("notify_response", hostapd_notify_response, notify_policy),
1303 UBUS_METHOD("bss_mgmt_enable", hostapd_bss_mgmt_enable, bss_mgmt_enable_policy),
1304 UBUS_METHOD_NOARG("rrm_nr_get_own", hostapd_rrm_nr_get_own),
1305 UBUS_METHOD_NOARG("rrm_nr_list", hostapd_rrm_nr_list),
1306 UBUS_METHOD("rrm_nr_set", hostapd_rrm_nr_set, nr_set_policy),
1307 UBUS_METHOD("rrm_beacon_req", hostapd_rrm_beacon_req, beacon_req_policy),
1308 #ifdef CONFIG_WNM_AP
1309 UBUS_METHOD("wnm_disassoc_imminent", hostapd_wnm_disassoc_imminent, wnm_disassoc_policy),
1310 #endif
1311 };
1312
1313 static struct ubus_object_type bss_object_type =
1314 UBUS_OBJECT_TYPE("hostapd_bss", bss_methods);
1315
1316 static int avl_compare_macaddr(const void *k1, const void *k2, void *ptr)
1317 {
1318 return memcmp(k1, k2, ETH_ALEN);
1319 }
1320
1321 void hostapd_ubus_add_bss(struct hostapd_data *hapd)
1322 {
1323 struct ubus_object *obj = &hapd->ubus.obj;
1324 char *name;
1325 int ret;
1326
1327 #ifdef CONFIG_MESH
1328 if (hapd->conf->mesh & MESH_ENABLED)
1329 return;
1330 #endif
1331
1332 if (!hostapd_ubus_init())
1333 return;
1334
1335 if (asprintf(&name, "hostapd.%s", hapd->conf->iface) < 0)
1336 return;
1337
1338 avl_init(&hapd->ubus.banned, avl_compare_macaddr, false, NULL);
1339 obj->name = name;
1340 obj->type = &bss_object_type;
1341 obj->methods = bss_object_type.methods;
1342 obj->n_methods = bss_object_type.n_methods;
1343 ret = ubus_add_object(ctx, obj);
1344 hostapd_ubus_ref_inc();
1345
1346 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "add");
1347 }
1348
1349 void hostapd_ubus_free_bss(struct hostapd_data *hapd)
1350 {
1351 struct ubus_object *obj = &hapd->ubus.obj;
1352 char *name = (char *) obj->name;
1353
1354 if (!ctx)
1355 return;
1356
1357 hostapd_send_shared_event(&hapd->iface->interfaces->ubus, hapd->conf->iface, "remove");
1358
1359 if (obj->id) {
1360 ubus_remove_object(ctx, obj);
1361 hostapd_ubus_ref_dec();
1362 }
1363
1364 free(name);
1365 }
1366
1367 static void
1368 hostapd_ubus_vlan_action(struct hostapd_data *hapd, struct hostapd_vlan *vlan,
1369 const char *action)
1370 {
1371 struct vlan_description *desc = &vlan->vlan_desc;
1372 void *c;
1373 int i;
1374
1375 if (!hapd->ubus.obj.has_subscribers)
1376 return;
1377
1378 blob_buf_init(&b, 0);
1379 blobmsg_add_string(&b, "ifname", vlan->ifname);
1380 blobmsg_add_string(&b, "bridge", vlan->bridge);
1381 blobmsg_add_u32(&b, "vlan_id", vlan->vlan_id);
1382
1383 if (desc->notempty) {
1384 blobmsg_add_u32(&b, "untagged", desc->untagged);
1385 c = blobmsg_open_array(&b, "tagged");
1386 for (i = 0; i < ARRAY_SIZE(desc->tagged) && desc->tagged[i]; i++)
1387 blobmsg_add_u32(&b, "", desc->tagged[i]);
1388 blobmsg_close_array(&b, c);
1389 }
1390
1391 ubus_notify(ctx, &hapd->ubus.obj, action, b.head, -1);
1392 }
1393
1394 void hostapd_ubus_add_vlan(struct hostapd_data *hapd, struct hostapd_vlan *vlan)
1395 {
1396 hostapd_ubus_vlan_action(hapd, vlan, "vlan_add");
1397 }
1398
1399 void hostapd_ubus_remove_vlan(struct hostapd_data *hapd, struct hostapd_vlan *vlan)
1400 {
1401 hostapd_ubus_vlan_action(hapd, vlan, "vlan_remove");
1402 }
1403
1404 static const struct ubus_method daemon_methods[] = {
1405 UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
1406 UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
1407 };
1408
1409 static struct ubus_object_type daemon_object_type =
1410 UBUS_OBJECT_TYPE("hostapd", daemon_methods);
1411
1412 void hostapd_ubus_add(struct hapd_interfaces *interfaces)
1413 {
1414 struct ubus_object *obj = &interfaces->ubus;
1415 int ret;
1416
1417 if (!hostapd_ubus_init())
1418 return;
1419
1420 obj->name = strdup("hostapd");
1421
1422 obj->type = &daemon_object_type;
1423 obj->methods = daemon_object_type.methods;
1424 obj->n_methods = daemon_object_type.n_methods;
1425 ret = ubus_add_object(ctx, obj);
1426 hostapd_ubus_ref_inc();
1427 }
1428
1429 void hostapd_ubus_free(struct hapd_interfaces *interfaces)
1430 {
1431 struct ubus_object *obj = &interfaces->ubus;
1432 char *name = (char *) obj->name;
1433
1434 if (!ctx)
1435 return;
1436
1437 if (obj->id) {
1438 ubus_remove_object(ctx, obj);
1439 hostapd_ubus_ref_dec();
1440 }
1441
1442 free(name);
1443 }
1444
1445 struct ubus_event_req {
1446 struct ubus_notify_request nreq;
1447 int resp;
1448 };
1449
1450 static void
1451 ubus_event_cb(struct ubus_notify_request *req, int idx, int ret)
1452 {
1453 struct ubus_event_req *ureq = container_of(req, struct ubus_event_req, nreq);
1454
1455 ureq->resp = ret;
1456 }
1457
1458 int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
1459 {
1460 struct ubus_banned_client *ban;
1461 const char *types[HOSTAPD_UBUS_TYPE_MAX] = {
1462 [HOSTAPD_UBUS_PROBE_REQ] = "probe",
1463 [HOSTAPD_UBUS_AUTH_REQ] = "auth",
1464 [HOSTAPD_UBUS_ASSOC_REQ] = "assoc",
1465 };
1466 const char *type = "mgmt";
1467 struct ubus_event_req ureq = {};
1468 const u8 *addr;
1469
1470 if (req->mgmt_frame)
1471 addr = req->mgmt_frame->sa;
1472 else
1473 addr = req->addr;
1474
1475 ban = avl_find_element(&hapd->ubus.banned, addr, ban, avl);
1476 if (ban)
1477 return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
1478
1479 if (!hapd->ubus.obj.has_subscribers)
1480 return WLAN_STATUS_SUCCESS;
1481
1482 if (req->type < ARRAY_SIZE(types))
1483 type = types[req->type];
1484
1485 blob_buf_init(&b, 0);
1486 blobmsg_add_macaddr(&b, "address", addr);
1487 if (req->mgmt_frame)
1488 blobmsg_add_macaddr(&b, "target", req->mgmt_frame->da);
1489 if (req->ssi_signal)
1490 blobmsg_add_u32(&b, "signal", req->ssi_signal);
1491 blobmsg_add_u32(&b, "freq", hapd->iface->freq);
1492
1493 if (req->elems) {
1494 if(req->elems->ht_capabilities)
1495 {
1496 struct ieee80211_ht_capabilities *ht_capabilities;
1497 void *ht_cap, *ht_cap_mcs_set, *mcs_set;
1498
1499
1500 ht_capabilities = (struct ieee80211_ht_capabilities*) req->elems->ht_capabilities;
1501 ht_cap = blobmsg_open_table(&b, "ht_capabilities");
1502 blobmsg_add_u16(&b, "ht_capabilities_info", ht_capabilities->ht_capabilities_info);
1503 ht_cap_mcs_set = blobmsg_open_table(&b, "supported_mcs_set");
1504 blobmsg_add_u16(&b, "a_mpdu_params", ht_capabilities->a_mpdu_params);
1505 blobmsg_add_u16(&b, "ht_extended_capabilities", ht_capabilities->ht_extended_capabilities);
1506 blobmsg_add_u32(&b, "tx_bf_capability_info", ht_capabilities->tx_bf_capability_info);
1507 blobmsg_add_u16(&b, "asel_capabilities", ht_capabilities->asel_capabilities);
1508 mcs_set = blobmsg_open_array(&b, "supported_mcs_set");
1509 for (int i = 0; i < 16; i++) {
1510 blobmsg_add_u16(&b, NULL, (u16) ht_capabilities->supported_mcs_set[i]);
1511 }
1512 blobmsg_close_array(&b, mcs_set);
1513 blobmsg_close_table(&b, ht_cap_mcs_set);
1514 blobmsg_close_table(&b, ht_cap);
1515 }
1516 if(req->elems->vht_capabilities)
1517 {
1518 struct ieee80211_vht_capabilities *vht_capabilities;
1519 void *vht_cap, *vht_cap_mcs_set;
1520
1521 vht_capabilities = (struct ieee80211_vht_capabilities*) req->elems->vht_capabilities;
1522 vht_cap = blobmsg_open_table(&b, "vht_capabilities");
1523 blobmsg_add_u32(&b, "vht_capabilities_info", vht_capabilities->vht_capabilities_info);
1524 vht_cap_mcs_set = blobmsg_open_table(&b, "vht_supported_mcs_set");
1525 blobmsg_add_u16(&b, "rx_map", vht_capabilities->vht_supported_mcs_set.rx_map);
1526 blobmsg_add_u16(&b, "rx_highest", vht_capabilities->vht_supported_mcs_set.rx_highest);
1527 blobmsg_add_u16(&b, "tx_map", vht_capabilities->vht_supported_mcs_set.tx_map);
1528 blobmsg_add_u16(&b, "tx_highest", vht_capabilities->vht_supported_mcs_set.tx_highest);
1529 blobmsg_close_table(&b, vht_cap_mcs_set);
1530 blobmsg_close_table(&b, vht_cap);
1531 }
1532 }
1533
1534 if (!hapd->ubus.notify_response) {
1535 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1536 return WLAN_STATUS_SUCCESS;
1537 }
1538
1539 if (ubus_notify_async(ctx, &hapd->ubus.obj, type, b.head, &ureq.nreq))
1540 return WLAN_STATUS_SUCCESS;
1541
1542 ureq.nreq.status_cb = ubus_event_cb;
1543 ubus_complete_request(ctx, &ureq.nreq.req, 100);
1544
1545 if (ureq.resp)
1546 return ureq.resp;
1547
1548 return WLAN_STATUS_SUCCESS;
1549 }
1550
1551 void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *addr)
1552 {
1553 if (!hapd->ubus.obj.has_subscribers)
1554 return;
1555
1556 if (!addr)
1557 return;
1558
1559 blob_buf_init(&b, 0);
1560 blobmsg_add_macaddr(&b, "address", addr);
1561
1562 ubus_notify(ctx, &hapd->ubus.obj, type, b.head, -1);
1563 }
1564
1565 void hostapd_ubus_notify_beacon_report(
1566 struct hostapd_data *hapd, const u8 *addr, u8 token, u8 rep_mode,
1567 struct rrm_measurement_beacon_report *rep, size_t len)
1568 {
1569 if (!hapd->ubus.obj.has_subscribers)
1570 return;
1571
1572 if (!addr || !rep)
1573 return;
1574
1575 blob_buf_init(&b, 0);
1576 blobmsg_add_macaddr(&b, "address", addr);
1577 blobmsg_add_u16(&b, "op-class", rep->op_class);
1578 blobmsg_add_u16(&b, "channel", rep->channel);
1579 blobmsg_add_u64(&b, "start-time", rep->start_time);
1580 blobmsg_add_u16(&b, "duration", rep->duration);
1581 blobmsg_add_u16(&b, "report-info", rep->report_info);
1582 blobmsg_add_u16(&b, "rcpi", rep->rcpi);
1583 blobmsg_add_u16(&b, "rsni", rep->rsni);
1584 blobmsg_add_macaddr(&b, "bssid", rep->bssid);
1585 blobmsg_add_u16(&b, "antenna-id", rep->antenna_id);
1586 blobmsg_add_u16(&b, "parent-tsf", rep->parent_tsf);
1587
1588 ubus_notify(ctx, &hapd->ubus.obj, "beacon-report", b.head, -1);
1589 }
Staging tree of Mathias Kresin