2 * hostapd / ubus support
3 * Copyright (c) 2013, Felix Fietkau <nbd@nbd.name>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
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 "common/hw_features_common.h"
16 #include "neighbor_db.h"
17 #include "wps_hostapd.h"
20 #include "ap_drv_ops.h"
25 #include "airtime_policy.h"
26 #include "hw_features.h"
28 static struct ubus_context
*ctx
;
29 static struct blob_buf b
;
32 static inline struct hapd_interfaces
*get_hapd_interfaces_from_object(struct ubus_object
*obj
)
34 return container_of(obj
, struct hapd_interfaces
, ubus
);
37 static inline struct hostapd_data
*get_hapd_from_object(struct ubus_object
*obj
)
39 return container_of(obj
, struct hostapd_data
, ubus
.obj
);
42 struct ubus_banned_client
{
47 static void ubus_reconnect_timeout(void *eloop_data
, void *user_ctx
)
49 if (ubus_reconnect(ctx
, NULL
)) {
50 eloop_register_timeout(1, 0, ubus_reconnect_timeout
, ctx
, NULL
);
57 static void hostapd_ubus_connection_lost(struct ubus_context
*ctx
)
59 uloop_fd_delete(&ctx
->sock
);
60 eloop_register_timeout(1, 0, ubus_reconnect_timeout
, ctx
, NULL
);
63 static bool hostapd_ubus_init(void)
69 ctx
= ubus_connect(NULL
);
73 ctx
->connection_lost
= hostapd_ubus_connection_lost
;
79 static void hostapd_ubus_ref_inc(void)
84 static void hostapd_ubus_ref_dec(void)
93 uloop_fd_delete(&ctx
->sock
);
98 void hostapd_ubus_add_iface(struct hostapd_iface
*iface
)
100 if (!hostapd_ubus_init())
104 void hostapd_ubus_free_iface(struct hostapd_iface
*iface
)
110 static void hostapd_notify_ubus(struct ubus_object
*obj
, char *bssname
, char *event
)
117 if (asprintf(&event_type
, "bss.%s", event
) < 0)
120 blob_buf_init(&b
, 0);
121 blobmsg_add_string(&b
, "name", bssname
);
122 ubus_notify(ctx
, obj
, event_type
, b
.head
, -1);
126 static void hostapd_send_procd_event(char *bssname
, char *event
)
132 if (!ctx
|| ubus_lookup_id(ctx
, "service", &id
))
135 if (asprintf(&name
, "hostapd.%s.%s", bssname
, event
) < 0)
138 blob_buf_init(&b
, 0);
140 s
= blobmsg_alloc_string_buffer(&b
, "type", strlen(name
) + 1);
141 sprintf(s
, "%s", name
);
142 blobmsg_add_string_buffer(&b
);
144 v
= blobmsg_open_table(&b
, "data");
145 blobmsg_close_table(&b
, v
);
147 ubus_invoke(ctx
, id
, "event", b
.head
, NULL
, NULL
, 1000);
152 static void hostapd_send_shared_event(struct ubus_object
*obj
, char *bssname
, char *event
)
154 hostapd_send_procd_event(bssname
, event
);
155 hostapd_notify_ubus(obj
, bssname
, event
);
159 hostapd_bss_del_ban(void *eloop_data
, void *user_ctx
)
161 struct ubus_banned_client
*ban
= eloop_data
;
162 struct hostapd_data
*hapd
= user_ctx
;
164 avl_delete(&hapd
->ubus
.banned
, &ban
->avl
);
169 hostapd_bss_ban_client(struct hostapd_data
*hapd
, u8
*addr
, int time
)
171 struct ubus_banned_client
*ban
;
176 ban
= avl_find_element(&hapd
->ubus
.banned
, addr
, ban
, avl
);
181 ban
= os_zalloc(sizeof(*ban
));
182 memcpy(ban
->addr
, addr
, sizeof(ban
->addr
));
183 ban
->avl
.key
= ban
->addr
;
184 avl_insert(&hapd
->ubus
.banned
, &ban
->avl
);
186 eloop_cancel_timeout(hostapd_bss_del_ban
, ban
, hapd
);
188 hostapd_bss_del_ban(ban
, hapd
);
193 eloop_register_timeout(0, time
* 1000, hostapd_bss_del_ban
, ban
, hapd
);
197 hostapd_bss_reload(struct ubus_context
*ctx
, struct ubus_object
*obj
,
198 struct ubus_request_data
*req
, const char *method
,
199 struct blob_attr
*msg
)
201 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
202 int ret
= hostapd_reload_config(hapd
->iface
, 1);
204 hostapd_send_shared_event(&hapd
->iface
->interfaces
->ubus
, hapd
->conf
->iface
, "reload");
210 hostapd_parse_vht_map_blobmsg(uint16_t map
)
216 for (i
= 0; i
< 8; i
++) {
217 snprintf(label
, 4, "%dss", i
+ 1);
219 val
= (map
& (BIT(1) | BIT(0))) + 7;
220 blobmsg_add_u16(&b
, label
, val
== 10 ? -1 : val
);
226 hostapd_parse_vht_capab_blobmsg(struct ieee80211_vht_capabilities
*vhtc
)
232 static const struct {
236 { "su_beamformee", VHT_CAP_SU_BEAMFORMEE_CAPABLE
},
237 { "mu_beamformee", VHT_CAP_MU_BEAMFORMEE_CAPABLE
},
240 for (i
= 0; i
< ARRAY_SIZE(vht_capas
); i
++)
241 blobmsg_add_u8(&b
, vht_capas
[i
].name
,
242 !!(vhtc
->vht_capabilities_info
& vht_capas
[i
].flag
));
244 supported_mcs
= blobmsg_open_table(&b
, "mcs_map");
247 map
= blobmsg_open_table(&b
, "rx");
248 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc
->vht_supported_mcs_set
.rx_map
));
249 blobmsg_close_table(&b
, map
);
252 map
= blobmsg_open_table(&b
, "tx");
253 hostapd_parse_vht_map_blobmsg(le_to_host16(vhtc
->vht_supported_mcs_set
.tx_map
));
254 blobmsg_close_table(&b
, map
);
256 blobmsg_close_table(&b
, supported_mcs
);
260 hostapd_parse_capab_blobmsg(struct sta_info
*sta
)
264 v
= blobmsg_open_table(&b
, "capabilities");
266 if (sta
->vht_capabilities
) {
267 r
= blobmsg_open_table(&b
, "vht");
268 hostapd_parse_vht_capab_blobmsg(sta
->vht_capabilities
);
269 blobmsg_close_table(&b
, r
);
272 /* ToDo: Add HT / HE capability parsing */
274 blobmsg_close_table(&b
, v
);
278 hostapd_bss_get_clients(struct ubus_context
*ctx
, struct ubus_object
*obj
,
279 struct ubus_request_data
*req
, const char *method
,
280 struct blob_attr
*msg
)
282 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
283 struct hostap_sta_driver_data sta_driver_data
;
284 struct sta_info
*sta
;
287 static const struct {
291 { "auth", WLAN_STA_AUTH
},
292 { "assoc", WLAN_STA_ASSOC
},
293 { "authorized", WLAN_STA_AUTHORIZED
},
294 { "preauth", WLAN_STA_PREAUTH
},
295 { "wds", WLAN_STA_WDS
},
296 { "wmm", WLAN_STA_WMM
},
297 { "ht", WLAN_STA_HT
},
298 { "vht", WLAN_STA_VHT
},
299 { "he", WLAN_STA_HE
},
300 { "wps", WLAN_STA_WPS
},
301 { "mfp", WLAN_STA_MFP
},
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
) {
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
));
318 blobmsg_add_u8(&b
, "mbo", !!(sta
->cell_capa
));
321 r
= blobmsg_open_array(&b
, "rrm");
322 for (i
= 0; i
< ARRAY_SIZE(sta
->rrm_enabled_capa
); i
++)
323 blobmsg_add_u32(&b
, "", sta
->rrm_enabled_capa
[i
]);
324 blobmsg_close_array(&b
, r
);
326 r
= blobmsg_open_array(&b
, "extended_capabilities");
327 /* Check if client advertises extended capabilities */
328 if (sta
->ext_capability
&& sta
->ext_capability
[0] > 0) {
329 for (i
= 0; i
< sta
->ext_capability
[0]; i
++) {
330 blobmsg_add_u32(&b
, "", sta
->ext_capability
[1 + i
]);
333 blobmsg_close_array(&b
, r
);
335 blobmsg_add_u32(&b
, "aid", sta
->aid
);
336 #ifdef CONFIG_TAXONOMY
337 r
= blobmsg_alloc_string_buffer(&b
, "signature", 1024);
338 if (retrieve_sta_taxonomy(hapd
, sta
, r
, 1024) > 0)
339 blobmsg_add_string_buffer(&b
);
342 /* Driver information */
343 if (hostapd_drv_read_sta_data(hapd
, &sta_driver_data
, sta
->addr
) >= 0) {
344 r
= blobmsg_open_table(&b
, "bytes");
345 blobmsg_add_u64(&b
, "rx", sta_driver_data
.rx_bytes
);
346 blobmsg_add_u64(&b
, "tx", sta_driver_data
.tx_bytes
);
347 blobmsg_close_table(&b
, r
);
348 r
= blobmsg_open_table(&b
, "airtime");
349 blobmsg_add_u64(&b
, "rx", sta_driver_data
.rx_airtime
);
350 blobmsg_add_u64(&b
, "tx", sta_driver_data
.tx_airtime
);
351 blobmsg_close_table(&b
, r
);
352 r
= blobmsg_open_table(&b
, "packets");
353 blobmsg_add_u32(&b
, "rx", sta_driver_data
.rx_packets
);
354 blobmsg_add_u32(&b
, "tx", sta_driver_data
.tx_packets
);
355 blobmsg_close_table(&b
, r
);
356 r
= blobmsg_open_table(&b
, "rate");
358 blobmsg_add_u32(&b
, "rx", sta_driver_data
.current_rx_rate
* 100);
359 blobmsg_add_u32(&b
, "tx", sta_driver_data
.current_tx_rate
* 100);
360 blobmsg_close_table(&b
, r
);
361 blobmsg_add_u32(&b
, "signal", sta_driver_data
.signal
);
364 hostapd_parse_capab_blobmsg(sta
);
366 blobmsg_close_table(&b
, c
);
368 blobmsg_close_array(&b
, list
);
369 ubus_send_reply(ctx
, req
, b
.head
);
375 hostapd_bss_get_features(struct ubus_context
*ctx
, struct ubus_object
*obj
,
376 struct ubus_request_data
*req
, const char *method
,
377 struct blob_attr
*msg
)
379 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
381 blob_buf_init(&b
, 0);
382 blobmsg_add_u8(&b
, "ht_supported", ht_supported(hapd
->iface
->hw_features
));
383 blobmsg_add_u8(&b
, "vht_supported", vht_supported(hapd
->iface
->hw_features
));
384 ubus_send_reply(ctx
, req
, b
.head
);
390 hostapd_bss_get_status(struct ubus_context
*ctx
, struct ubus_object
*obj
,
391 struct ubus_request_data
*req
, const char *method
,
392 struct blob_attr
*msg
)
394 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
395 void *airtime_table
, *dfs_table
, *rrm_table
, *wnm_table
;
396 struct os_reltime now
;
397 char ssid
[SSID_MAX_LEN
+ 1];
399 size_t ssid_len
= SSID_MAX_LEN
;
400 u8 channel
= 0, op_class
= 0;
402 if (hapd
->conf
->ssid
.ssid_len
< SSID_MAX_LEN
)
403 ssid_len
= hapd
->conf
->ssid
.ssid_len
;
405 ieee80211_freq_to_channel_ext(hapd
->iface
->freq
,
406 hapd
->iconf
->secondary_channel
,
407 hostapd_get_oper_chwidth(hapd
->iconf
),
408 &op_class
, &channel
);
410 blob_buf_init(&b
, 0);
411 blobmsg_add_string(&b
, "status", hostapd_state_text(hapd
->iface
->state
));
412 blobmsg_printf(&b
, "bssid", MACSTR
, MAC2STR(hapd
->conf
->bssid
));
414 memset(ssid
, 0, SSID_MAX_LEN
+ 1);
415 memcpy(ssid
, hapd
->conf
->ssid
.ssid
, ssid_len
);
416 blobmsg_add_string(&b
, "ssid", ssid
);
418 blobmsg_add_u32(&b
, "freq", hapd
->iface
->freq
);
419 blobmsg_add_u32(&b
, "channel", channel
);
420 blobmsg_add_u32(&b
, "op_class", op_class
);
421 blobmsg_add_u32(&b
, "beacon_interval", hapd
->iconf
->beacon_int
);
422 #ifdef CONFIG_IEEE80211AX
423 blobmsg_add_u32(&b
, "bss_color", hapd
->iface
->conf
->he_op
.he_bss_color_disabled
? -1 :
424 hapd
->iface
->conf
->he_op
.he_bss_color
);
426 blobmsg_add_u32(&b
, "bss_color", -1);
429 snprintf(phy_name
, 17, "%s", hapd
->iface
->phy
);
430 blobmsg_add_string(&b
, "phy", phy_name
);
433 rrm_table
= blobmsg_open_table(&b
, "rrm");
434 blobmsg_add_u64(&b
, "neighbor_report_tx", hapd
->openwrt_stats
.rrm
.neighbor_report_tx
);
435 blobmsg_close_table(&b
, rrm_table
);
438 wnm_table
= blobmsg_open_table(&b
, "wnm");
439 blobmsg_add_u64(&b
, "bss_transition_query_rx", hapd
->openwrt_stats
.wnm
.bss_transition_query_rx
);
440 blobmsg_add_u64(&b
, "bss_transition_request_tx", hapd
->openwrt_stats
.wnm
.bss_transition_request_tx
);
441 blobmsg_add_u64(&b
, "bss_transition_response_rx", hapd
->openwrt_stats
.wnm
.bss_transition_response_rx
);
442 blobmsg_close_table(&b
, wnm_table
);
445 airtime_table
= blobmsg_open_table(&b
, "airtime");
446 blobmsg_add_u64(&b
, "time", hapd
->iface
->last_channel_time
);
447 blobmsg_add_u64(&b
, "time_busy", hapd
->iface
->last_channel_time_busy
);
448 blobmsg_add_u16(&b
, "utilization", hapd
->iface
->channel_utilization
);
449 blobmsg_close_table(&b
, airtime_table
);
452 dfs_table
= blobmsg_open_table(&b
, "dfs");
453 blobmsg_add_u32(&b
, "cac_seconds", hapd
->iface
->dfs_cac_ms
/ 1000);
454 blobmsg_add_u8(&b
, "cac_active", !!(hapd
->iface
->cac_started
));
455 os_reltime_age(&hapd
->iface
->dfs_cac_start
, &now
);
456 blobmsg_add_u32(&b
, "cac_seconds_left",
457 hapd
->iface
->cac_started
? hapd
->iface
->dfs_cac_ms
/ 1000 - now
.sec
: 0);
458 blobmsg_close_table(&b
, dfs_table
);
460 ubus_send_reply(ctx
, req
, b
.head
);
470 static const struct blobmsg_policy notify_policy
[__NOTIFY_MAX
] = {
471 [NOTIFY_RESPONSE
] = { "notify_response", BLOBMSG_TYPE_INT32
},
475 hostapd_notify_response(struct ubus_context
*ctx
, struct ubus_object
*obj
,
476 struct ubus_request_data
*req
, const char *method
,
477 struct blob_attr
*msg
)
479 struct blob_attr
*tb
[__NOTIFY_MAX
];
480 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
481 struct wpabuf
*elems
;
485 blobmsg_parse(notify_policy
, __NOTIFY_MAX
, tb
,
486 blob_data(msg
), blob_len(msg
));
488 if (!tb
[NOTIFY_RESPONSE
])
489 return UBUS_STATUS_INVALID_ARGUMENT
;
491 hapd
->ubus
.notify_response
= blobmsg_get_u32(tb
[NOTIFY_RESPONSE
]);
493 return UBUS_STATUS_OK
;
504 static const struct blobmsg_policy del_policy
[__DEL_CLIENT_MAX
] = {
505 [DEL_CLIENT_ADDR
] = { "addr", BLOBMSG_TYPE_STRING
},
506 [DEL_CLIENT_REASON
] = { "reason", BLOBMSG_TYPE_INT32
},
507 [DEL_CLIENT_DEAUTH
] = { "deauth", BLOBMSG_TYPE_INT8
},
508 [DEL_CLIENT_BAN_TIME
] = { "ban_time", BLOBMSG_TYPE_INT32
},
512 hostapd_bss_del_client(struct ubus_context
*ctx
, struct ubus_object
*obj
,
513 struct ubus_request_data
*req
, const char *method
,
514 struct blob_attr
*msg
)
516 struct blob_attr
*tb
[__DEL_CLIENT_MAX
];
517 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
518 struct sta_info
*sta
;
523 blobmsg_parse(del_policy
, __DEL_CLIENT_MAX
, tb
, blob_data(msg
), blob_len(msg
));
525 if (!tb
[DEL_CLIENT_ADDR
])
526 return UBUS_STATUS_INVALID_ARGUMENT
;
528 if (hwaddr_aton(blobmsg_data(tb
[DEL_CLIENT_ADDR
]), addr
))
529 return UBUS_STATUS_INVALID_ARGUMENT
;
531 if (tb
[DEL_CLIENT_REASON
])
532 reason
= blobmsg_get_u32(tb
[DEL_CLIENT_REASON
]);
534 if (tb
[DEL_CLIENT_DEAUTH
])
535 deauth
= blobmsg_get_bool(tb
[DEL_CLIENT_DEAUTH
]);
537 sta
= ap_get_sta(hapd
, addr
);
540 hostapd_drv_sta_deauth(hapd
, addr
, reason
);
541 ap_sta_deauthenticate(hapd
, sta
, reason
);
543 hostapd_drv_sta_disassoc(hapd
, addr
, reason
);
544 ap_sta_disassociate(hapd
, sta
, reason
);
548 if (tb
[DEL_CLIENT_BAN_TIME
])
549 hostapd_bss_ban_client(hapd
, addr
, blobmsg_get_u32(tb
[DEL_CLIENT_BAN_TIME
]));
555 blobmsg_add_macaddr(struct blob_buf
*buf
, const char *name
, const u8
*addr
)
559 s
= blobmsg_alloc_string_buffer(buf
, name
, 20);
560 sprintf(s
, MACSTR
, MAC2STR(addr
));
561 blobmsg_add_string_buffer(buf
);
565 hostapd_bss_list_bans(struct ubus_context
*ctx
, struct ubus_object
*obj
,
566 struct ubus_request_data
*req
, const char *method
,
567 struct blob_attr
*msg
)
569 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
570 struct ubus_banned_client
*ban
;
573 blob_buf_init(&b
, 0);
574 c
= blobmsg_open_array(&b
, "clients");
575 avl_for_each_element(&hapd
->ubus
.banned
, ban
, avl
)
576 blobmsg_add_macaddr(&b
, NULL
, ban
->addr
);
577 blobmsg_close_array(&b
, c
);
578 ubus_send_reply(ctx
, req
, b
.head
);
585 hostapd_bss_wps_start(struct ubus_context
*ctx
, struct ubus_object
*obj
,
586 struct ubus_request_data
*req
, const char *method
,
587 struct blob_attr
*msg
)
590 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
592 rc
= hostapd_wps_button_pushed(hapd
, NULL
);
595 return UBUS_STATUS_NOT_SUPPORTED
;
601 static const char * pbc_status_enum_str(enum pbc_status status
)
604 case WPS_PBC_STATUS_DISABLE
:
606 case WPS_PBC_STATUS_ACTIVE
:
608 case WPS_PBC_STATUS_TIMEOUT
:
610 case WPS_PBC_STATUS_OVERLAP
:
618 hostapd_bss_wps_status(struct ubus_context
*ctx
, struct ubus_object
*obj
,
619 struct ubus_request_data
*req
, const char *method
,
620 struct blob_attr
*msg
)
623 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
625 blob_buf_init(&b
, 0);
627 blobmsg_add_string(&b
, "pbc_status", pbc_status_enum_str(hapd
->wps_stats
.pbc_status
));
628 blobmsg_add_string(&b
, "last_wps_result",
629 (hapd
->wps_stats
.status
== WPS_STATUS_SUCCESS
?
631 (hapd
->wps_stats
.status
== WPS_STATUS_FAILURE
?
632 "Failed" : "None")));
634 /* If status == Failure - Add possible Reasons */
635 if(hapd
->wps_stats
.status
== WPS_STATUS_FAILURE
&&
636 hapd
->wps_stats
.failure_reason
> 0)
637 blobmsg_add_string(&b
, "reason", wps_ei_str(hapd
->wps_stats
.failure_reason
));
639 if (hapd
->wps_stats
.status
)
640 blobmsg_printf(&b
, "peer_address", MACSTR
, MAC2STR(hapd
->wps_stats
.peer_addr
));
642 ubus_send_reply(ctx
, req
, b
.head
);
648 hostapd_bss_wps_cancel(struct ubus_context
*ctx
, struct ubus_object
*obj
,
649 struct ubus_request_data
*req
, const char *method
,
650 struct blob_attr
*msg
)
653 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
655 rc
= hostapd_wps_cancel(hapd
);
658 return UBUS_STATUS_NOT_SUPPORTED
;
662 #endif /* CONFIG_WPS */
665 hostapd_bss_update_beacon(struct ubus_context
*ctx
, struct ubus_object
*obj
,
666 struct ubus_request_data
*req
, const char *method
,
667 struct blob_attr
*msg
)
670 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
672 rc
= ieee802_11_set_beacon(hapd
);
675 return UBUS_STATUS_NOT_SUPPORTED
;
686 static const struct blobmsg_policy config_add_policy
[__CONFIG_MAX
] = {
687 [CONFIG_IFACE
] = { "iface", BLOBMSG_TYPE_STRING
},
688 [CONFIG_FILE
] = { "config", BLOBMSG_TYPE_STRING
},
692 hostapd_config_add(struct ubus_context
*ctx
, struct ubus_object
*obj
,
693 struct ubus_request_data
*req
, const char *method
,
694 struct blob_attr
*msg
)
696 struct blob_attr
*tb
[__CONFIG_MAX
];
697 struct hapd_interfaces
*interfaces
= get_hapd_interfaces_from_object(obj
);
700 blobmsg_parse(config_add_policy
, __CONFIG_MAX
, tb
, blob_data(msg
), blob_len(msg
));
702 if (!tb
[CONFIG_FILE
] || !tb
[CONFIG_IFACE
])
703 return UBUS_STATUS_INVALID_ARGUMENT
;
705 snprintf(buf
, sizeof(buf
), "bss_config=%s:%s",
706 blobmsg_get_string(tb
[CONFIG_IFACE
]),
707 blobmsg_get_string(tb
[CONFIG_FILE
]));
709 if (hostapd_add_iface(interfaces
, buf
))
710 return UBUS_STATUS_INVALID_ARGUMENT
;
712 blob_buf_init(&b
, 0);
713 blobmsg_add_u32(&b
, "pid", getpid());
714 ubus_send_reply(ctx
, req
, b
.head
);
716 return UBUS_STATUS_OK
;
724 static const struct blobmsg_policy config_remove_policy
[__CONFIG_REM_MAX
] = {
725 [CONFIG_REM_IFACE
] = { "iface", BLOBMSG_TYPE_STRING
},
729 hostapd_config_remove(struct ubus_context
*ctx
, struct ubus_object
*obj
,
730 struct ubus_request_data
*req
, const char *method
,
731 struct blob_attr
*msg
)
733 struct blob_attr
*tb
[__CONFIG_REM_MAX
];
734 struct hapd_interfaces
*interfaces
= get_hapd_interfaces_from_object(obj
);
737 blobmsg_parse(config_remove_policy
, __CONFIG_REM_MAX
, tb
, blob_data(msg
), blob_len(msg
));
739 if (!tb
[CONFIG_REM_IFACE
])
740 return UBUS_STATUS_INVALID_ARGUMENT
;
742 if (hostapd_remove_iface(interfaces
, blobmsg_get_string(tb
[CONFIG_REM_IFACE
])))
743 return UBUS_STATUS_INVALID_ARGUMENT
;
745 return UBUS_STATUS_OK
;
754 CSA_SEC_CHANNEL_OFFSET
,
763 static const struct blobmsg_policy csa_policy
[__CSA_MAX
] = {
764 [CSA_FREQ
] = { "freq", BLOBMSG_TYPE_INT32
},
765 [CSA_BCN_COUNT
] = { "bcn_count", BLOBMSG_TYPE_INT32
},
766 [CSA_CENTER_FREQ1
] = { "center_freq1", BLOBMSG_TYPE_INT32
},
767 [CSA_CENTER_FREQ2
] = { "center_freq2", BLOBMSG_TYPE_INT32
},
768 [CSA_BANDWIDTH
] = { "bandwidth", BLOBMSG_TYPE_INT32
},
769 [CSA_SEC_CHANNEL_OFFSET
] = { "sec_channel_offset", BLOBMSG_TYPE_INT32
},
770 [CSA_HT
] = { "ht", BLOBMSG_TYPE_BOOL
},
771 [CSA_VHT
] = { "vht", BLOBMSG_TYPE_BOOL
},
772 [CSA_HE
] = { "he", BLOBMSG_TYPE_BOOL
},
773 [CSA_BLOCK_TX
] = { "block_tx", BLOBMSG_TYPE_BOOL
},
774 [CSA_FORCE
] = { "force", BLOBMSG_TYPE_BOOL
},
778 static void switch_chan_fallback_cb(void *eloop_data
, void *user_ctx
)
780 struct hostapd_iface
*iface
= eloop_data
;
781 struct hostapd_freq_params
*freq_params
= user_ctx
;
783 hostapd_switch_channel_fallback(iface
, freq_params
);
788 hostapd_switch_chan(struct ubus_context
*ctx
, struct ubus_object
*obj
,
789 struct ubus_request_data
*req
, const char *method
,
790 struct blob_attr
*msg
)
792 struct blob_attr
*tb
[__CSA_MAX
];
793 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
794 struct hostapd_config
*iconf
= hapd
->iface
->conf
;
795 struct hostapd_freq_params
*freq_params
;
796 struct hostapd_hw_modes
*mode
= hapd
->iface
->current_mode
;
797 struct csa_settings css
= {
799 .ht_enabled
= iconf
->ieee80211n
,
800 .vht_enabled
= iconf
->ieee80211ac
,
801 .he_enabled
= iconf
->ieee80211ax
,
802 .sec_channel_offset
= iconf
->secondary_channel
,
805 u8 chwidth
= hostapd_get_oper_chwidth(iconf
);
806 u8 seg0
= 0, seg1
= 0;
807 int ret
= UBUS_STATUS_OK
;
810 blobmsg_parse(csa_policy
, __CSA_MAX
, tb
, blob_data(msg
), blob_len(msg
));
813 return UBUS_STATUS_INVALID_ARGUMENT
;
815 switch (iconf
->vht_oper_chwidth
) {
816 case CHANWIDTH_USE_HT
:
817 if (iconf
->secondary_channel
)
818 css
.freq_params
.bandwidth
= 40;
820 css
.freq_params
.bandwidth
= 20;
822 case CHANWIDTH_160MHZ
:
823 css
.freq_params
.bandwidth
= 160;
826 css
.freq_params
.bandwidth
= 80;
830 css
.freq_params
.freq
= blobmsg_get_u32(tb
[CSA_FREQ
]);
832 #define SET_CSA_SETTING(name, field, type) \
835 css.field = blobmsg_get_ ## type(tb[name]); \
838 SET_CSA_SETTING(CSA_BCN_COUNT
, cs_count
, u32
);
839 SET_CSA_SETTING(CSA_CENTER_FREQ1
, freq_params
.center_freq1
, u32
);
840 SET_CSA_SETTING(CSA_CENTER_FREQ2
, freq_params
.center_freq2
, u32
);
841 SET_CSA_SETTING(CSA_BANDWIDTH
, freq_params
.bandwidth
, u32
);
842 SET_CSA_SETTING(CSA_SEC_CHANNEL_OFFSET
, freq_params
.sec_channel_offset
, u32
);
843 SET_CSA_SETTING(CSA_HT
, freq_params
.ht_enabled
, bool);
844 SET_CSA_SETTING(CSA_VHT
, freq_params
.vht_enabled
, bool);
845 SET_CSA_SETTING(CSA_HE
, freq_params
.he_enabled
, bool);
846 SET_CSA_SETTING(CSA_BLOCK_TX
, block_tx
, bool);
848 css
.freq_params
.channel
= hostapd_hw_get_channel(hapd
, css
.freq_params
.freq
);
849 if (!css
.freq_params
.channel
)
850 return UBUS_STATUS_NOT_SUPPORTED
;
852 switch (css
.freq_params
.bandwidth
) {
854 chwidth
= CHANWIDTH_160MHZ
;
857 chwidth
= css
.freq_params
.center_freq2
? CHANWIDTH_80P80MHZ
: CHANWIDTH_80MHZ
;
860 chwidth
= CHANWIDTH_USE_HT
;
864 hostapd_set_freq_params(&css
.freq_params
, iconf
->hw_mode
,
865 css
.freq_params
.freq
,
866 css
.freq_params
.channel
, iconf
->enable_edmg
,
868 css
.freq_params
.ht_enabled
,
869 css
.freq_params
.vht_enabled
,
870 css
.freq_params
.he_enabled
,
871 css
.freq_params
.eht_enabled
,
872 css
.freq_params
.sec_channel_offset
,
875 mode
? &mode
->he_capab
[IEEE80211_MODE_AP
] :
877 mode
? &mode
->eht_capab
[IEEE80211_MODE_AP
] :
880 for (i
= 0; i
< hapd
->iface
->num_bss
; i
++) {
881 struct hostapd_data
*bss
= hapd
->iface
->bss
[i
];
883 if (hostapd_switch_channel(bss
, &css
) != 0)
884 ret
= UBUS_STATUS_NOT_SUPPORTED
;
887 if (!ret
|| !tb
[CSA_FORCE
] || !blobmsg_get_bool(tb
[CSA_FORCE
]))
890 freq_params
= malloc(sizeof(*freq_params
));
891 memcpy(freq_params
, &css
.freq_params
, sizeof(*freq_params
));
892 eloop_register_timeout(0, 1, switch_chan_fallback_cb
,
893 hapd
->iface
, freq_params
);
896 #undef SET_CSA_SETTING
902 __VENDOR_ELEMENTS_MAX
905 static const struct blobmsg_policy ve_policy
[__VENDOR_ELEMENTS_MAX
] = {
906 /* vendor elements are provided as hex-string */
907 [VENDOR_ELEMENTS
] = { "vendor_elements", BLOBMSG_TYPE_STRING
},
911 hostapd_vendor_elements(struct ubus_context
*ctx
, struct ubus_object
*obj
,
912 struct ubus_request_data
*req
, const char *method
,
913 struct blob_attr
*msg
)
915 struct blob_attr
*tb
[__VENDOR_ELEMENTS_MAX
];
916 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
917 struct hostapd_bss_config
*bss
= hapd
->conf
;
918 struct wpabuf
*elems
;
922 blobmsg_parse(ve_policy
, __VENDOR_ELEMENTS_MAX
, tb
,
923 blob_data(msg
), blob_len(msg
));
925 if (!tb
[VENDOR_ELEMENTS
])
926 return UBUS_STATUS_INVALID_ARGUMENT
;
928 pos
= blobmsg_data(tb
[VENDOR_ELEMENTS
]);
929 len
= os_strlen(pos
);
931 return UBUS_STATUS_INVALID_ARGUMENT
;
935 wpabuf_free(bss
->vendor_elements
);
936 bss
->vendor_elements
= NULL
;
940 elems
= wpabuf_alloc(len
);
944 if (hexstr2bin(pos
, wpabuf_put(elems
, len
), len
)) {
946 return UBUS_STATUS_INVALID_ARGUMENT
;
949 wpabuf_free(bss
->vendor_elements
);
950 bss
->vendor_elements
= elems
;
952 /* update beacons if vendor elements were set successfully */
953 if (ieee802_11_update_beacons(hapd
->iface
) != 0)
954 return UBUS_STATUS_NOT_SUPPORTED
;
955 return UBUS_STATUS_OK
;
959 hostapd_rrm_print_nr(struct hostapd_neighbor_entry
*nr
)
965 blobmsg_printf(&b
, "", MACSTR
, MAC2STR(nr
->bssid
));
967 str
= blobmsg_alloc_string_buffer(&b
, "", nr
->ssid
.ssid_len
+ 1);
968 memcpy(str
, nr
->ssid
.ssid
, nr
->ssid
.ssid_len
);
969 str
[nr
->ssid
.ssid_len
] = 0;
970 blobmsg_add_string_buffer(&b
);
972 len
= wpabuf_len(nr
->nr
);
973 str
= blobmsg_alloc_string_buffer(&b
, "", 2 * len
+ 1);
974 wpa_snprintf_hex(str
, 2 * len
+ 1, wpabuf_head_u8(nr
->nr
), len
);
975 blobmsg_add_string_buffer(&b
);
979 BSS_MGMT_EN_NEIGHBOR
,
981 BSS_MGMT_EN_LINK_MEASUREMENT
,
983 BSS_MGMT_EN_BSS_TRANSITION
,
989 __hostapd_bss_mgmt_enable_f(struct hostapd_data
*hapd
, int flag
)
991 struct hostapd_bss_config
*bss
= hapd
->conf
;
995 case BSS_MGMT_EN_NEIGHBOR
:
996 if (bss
->radio_measurements
[0] &
997 WLAN_RRM_CAPS_NEIGHBOR_REPORT
)
1000 bss
->radio_measurements
[0] |=
1001 WLAN_RRM_CAPS_NEIGHBOR_REPORT
;
1002 hostapd_neighbor_set_own_report(hapd
);
1004 case BSS_MGMT_EN_BEACON
:
1005 flags
= WLAN_RRM_CAPS_BEACON_REPORT_PASSIVE
|
1006 WLAN_RRM_CAPS_BEACON_REPORT_ACTIVE
|
1007 WLAN_RRM_CAPS_BEACON_REPORT_TABLE
;
1009 if (bss
->radio_measurements
[0] & flags
== flags
)
1012 bss
->radio_measurements
[0] |= (u8
) flags
;
1014 case BSS_MGMT_EN_LINK_MEASUREMENT
:
1015 flags
= WLAN_RRM_CAPS_LINK_MEASUREMENT
;
1017 if (bss
->radio_measurements
[0] & flags
== flags
)
1020 bss
->radio_measurements
[0] |= (u8
) flags
;
1022 #ifdef CONFIG_WNM_AP
1023 case BSS_MGMT_EN_BSS_TRANSITION
:
1024 if (bss
->bss_transition
)
1027 bss
->bss_transition
= 1;
1034 __hostapd_bss_mgmt_enable(struct hostapd_data
*hapd
, uint32_t flags
)
1036 bool update
= false;
1039 for (i
= 0; i
< __BSS_MGMT_EN_MAX
; i
++) {
1040 if (!(flags
& (1 << i
)))
1043 update
|= __hostapd_bss_mgmt_enable_f(hapd
, i
);
1047 ieee802_11_update_beacons(hapd
->iface
);
1051 static const struct blobmsg_policy bss_mgmt_enable_policy
[__BSS_MGMT_EN_MAX
] = {
1052 [BSS_MGMT_EN_NEIGHBOR
] = { "neighbor_report", BLOBMSG_TYPE_BOOL
},
1053 [BSS_MGMT_EN_BEACON
] = { "beacon_report", BLOBMSG_TYPE_BOOL
},
1054 [BSS_MGMT_EN_LINK_MEASUREMENT
] = { "link_measurement", BLOBMSG_TYPE_BOOL
},
1055 #ifdef CONFIG_WNM_AP
1056 [BSS_MGMT_EN_BSS_TRANSITION
] = { "bss_transition", BLOBMSG_TYPE_BOOL
},
1061 hostapd_bss_mgmt_enable(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1062 struct ubus_request_data
*req
, const char *method
,
1063 struct blob_attr
*msg
)
1066 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
1067 struct blob_attr
*tb
[__BSS_MGMT_EN_MAX
];
1068 struct blob_attr
*cur
;
1071 bool neigh
= false, beacon
= false;
1073 blobmsg_parse(bss_mgmt_enable_policy
, __BSS_MGMT_EN_MAX
, tb
, blob_data(msg
), blob_len(msg
));
1075 for (i
= 0; i
< ARRAY_SIZE(tb
); i
++) {
1076 if (!tb
[i
] || !blobmsg_get_bool(tb
[i
]))
1082 __hostapd_bss_mgmt_enable(hapd
, flags
);
1089 hostapd_rrm_nr_enable(struct hostapd_data
*hapd
)
1091 __hostapd_bss_mgmt_enable(hapd
, 1 << BSS_MGMT_EN_NEIGHBOR
);
1095 hostapd_rrm_nr_get_own(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1096 struct ubus_request_data
*req
, const char *method
,
1097 struct blob_attr
*msg
)
1099 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
1100 struct hostapd_neighbor_entry
*nr
;
1103 hostapd_rrm_nr_enable(hapd
);
1105 nr
= hostapd_neighbor_get(hapd
, hapd
->own_addr
, NULL
);
1107 return UBUS_STATUS_NOT_FOUND
;
1109 blob_buf_init(&b
, 0);
1111 c
= blobmsg_open_array(&b
, "value");
1112 hostapd_rrm_print_nr(nr
);
1113 blobmsg_close_array(&b
, c
);
1115 ubus_send_reply(ctx
, req
, b
.head
);
1121 hostapd_rrm_nr_list(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1122 struct ubus_request_data
*req
, const char *method
,
1123 struct blob_attr
*msg
)
1125 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
1126 struct hostapd_neighbor_entry
*nr
;
1129 hostapd_rrm_nr_enable(hapd
);
1130 blob_buf_init(&b
, 0);
1132 c
= blobmsg_open_array(&b
, "list");
1133 dl_list_for_each(nr
, &hapd
->nr_db
, struct hostapd_neighbor_entry
, list
) {
1136 if (!memcmp(nr
->bssid
, hapd
->own_addr
, ETH_ALEN
))
1139 cur
= blobmsg_open_array(&b
, NULL
);
1140 hostapd_rrm_print_nr(nr
);
1141 blobmsg_close_array(&b
, cur
);
1143 blobmsg_close_array(&b
, c
);
1145 ubus_send_reply(ctx
, req
, b
.head
);
1155 static const struct blobmsg_policy nr_set_policy
[__NR_SET_LIST_MAX
] = {
1156 [NR_SET_LIST
] = { "list", BLOBMSG_TYPE_ARRAY
},
1161 hostapd_rrm_nr_clear(struct hostapd_data
*hapd
)
1163 struct hostapd_neighbor_entry
*nr
;
1166 dl_list_for_each(nr
, &hapd
->nr_db
, struct hostapd_neighbor_entry
, list
) {
1167 if (!memcmp(nr
->bssid
, hapd
->own_addr
, ETH_ALEN
))
1170 hostapd_neighbor_remove(hapd
, nr
->bssid
, &nr
->ssid
);
1176 hostapd_rrm_nr_set(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1177 struct ubus_request_data
*req
, const char *method
,
1178 struct blob_attr
*msg
)
1180 static const struct blobmsg_policy nr_e_policy
[] = {
1181 { .type
= BLOBMSG_TYPE_STRING
},
1182 { .type
= BLOBMSG_TYPE_STRING
},
1183 { .type
= BLOBMSG_TYPE_STRING
},
1185 struct hostapd_data
*hapd
= get_hapd_from_object(obj
);
1186 struct blob_attr
*tb_l
[__NR_SET_LIST_MAX
];
1187 struct blob_attr
*tb
[ARRAY_SIZE(nr_e_policy
)];
1188 struct blob_attr
*cur
;
1191 hostapd_rrm_nr_enable(hapd
);
1193 blobmsg_parse(nr_set_policy
, __NR_SET_LIST_MAX
, tb_l
, blob_data(msg
), blob_len(msg
));
1194 if (!tb_l
[NR_SET_LIST
])
1195 return UBUS_STATUS_INVALID_ARGUMENT
;
1197 hostapd_rrm_nr_clear(hapd
);
1198 blobmsg_for_each_attr(cur
, tb_l
[NR_SET_LIST
], rem
) {
1199 struct wpa_ssid_value ssid
;
1200 struct wpabuf
*data
;
1204 blobmsg_parse_array(nr_e_policy
, ARRAY_SIZE(nr_e_policy
), tb
, blobmsg_data(cur
), blobmsg_data_len(cur
));
1205 if (!tb
[0] || !tb
[1] || !tb
[2])
1208 /* Neighbor Report binary */
1209 nr_s
= blobmsg_get_string(tb
[2]);
1210 data
= wpabuf_parse_bin(nr_s
);
1215 s
= blobmsg_get_string(tb
[0]);
1216 if (strlen(s
) == 0) {
1217 /* Copy BSSID from neighbor report */
1218 if (hwaddr_compact_aton(nr_s
, bssid
))
1220 } else if (hwaddr_aton(s
, bssid
)) {
1225 s
= blobmsg_get_string(tb
[1]);
1226 if (strlen(s
) == 0) {
1227 /* Copy SSID from hostapd BSS conf */
1228 memcpy(&ssid
, &hapd
->conf
->ssid
, sizeof(ssid
));
1230 ssid
.ssid_len
= strlen(s
);
1231 if (ssid
.ssid_len
> sizeof(ssid
.ssid
))
1234 memcpy(&ssid
, s
, ssid
.ssid_len
);
1237 hostapd_neighbor_set(hapd
, bssid
, &ssid
, data
, NULL
, NULL
, 0, 0);
1242 return UBUS_STATUS_INVALID_ARGUMENT
;
1251 BEACON_REQ_OP_CLASS
,
1253 BEACON_REQ_DURATION
,
1259 static const struct blobmsg_policy beacon_req_policy
[__BEACON_REQ_MAX
] = {
1260 [BEACON_REQ_ADDR
] = { "addr", BLOBMSG_TYPE_STRING
},
1261 [BEACON_REQ_OP_CLASS
] { "op_class", BLOBMSG_TYPE_INT32
},
1262 [BEACON_REQ_CHANNEL
] { "channel", BLOBMSG_TYPE_INT32
},
1263 [BEACON_REQ_DURATION
] { "duration", BLOBMSG_TYPE_INT32
},
1264 [BEACON_REQ_MODE
] { "mode", BLOBMSG_TYPE_INT32
},
1265 [BEACON_REQ_BSSID
] { "bssid", BLOBMSG_TYPE_STRING
},
1266 [BEACON_REQ_SSID
] { "ssid", BLOBMSG_TYPE_STRING
},
1270 hostapd_rrm_beacon_req(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1271 struct ubus_request_data
*ureq
, const char *method
,
1272 struct blob_attr
*msg
)
1274 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
1275 struct blob_attr
*tb
[__BEACON_REQ_MAX
];
1276 struct blob_attr
*cur
;
1278 u8 bssid
[ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1283 blobmsg_parse(beacon_req_policy
, __BEACON_REQ_MAX
, tb
, blob_data(msg
), blob_len(msg
));
1285 if (!tb
[BEACON_REQ_ADDR
] || !tb
[BEACON_REQ_MODE
] || !tb
[BEACON_REQ_DURATION
] ||
1286 !tb
[BEACON_REQ_OP_CLASS
] || !tb
[BEACON_REQ_CHANNEL
])
1287 return UBUS_STATUS_INVALID_ARGUMENT
;
1289 if (tb
[BEACON_REQ_SSID
])
1290 buf_len
+= blobmsg_data_len(tb
[BEACON_REQ_SSID
]) + 2 - 1;
1292 mode
= blobmsg_get_u32(tb
[BEACON_REQ_MODE
]);
1293 if (hwaddr_aton(blobmsg_data(tb
[BEACON_REQ_ADDR
]), addr
))
1294 return UBUS_STATUS_INVALID_ARGUMENT
;
1296 if (tb
[BEACON_REQ_BSSID
] &&
1297 hwaddr_aton(blobmsg_data(tb
[BEACON_REQ_BSSID
]), bssid
))
1298 return UBUS_STATUS_INVALID_ARGUMENT
;
1300 req
= wpabuf_alloc(buf_len
);
1302 return UBUS_STATUS_UNKNOWN_ERROR
;
1304 /* 1: regulatory class */
1305 wpabuf_put_u8(req
, blobmsg_get_u32(tb
[BEACON_REQ_OP_CLASS
]));
1307 /* 2: channel number */
1308 wpabuf_put_u8(req
, blobmsg_get_u32(tb
[BEACON_REQ_CHANNEL
]));
1310 /* 3-4: randomization interval */
1311 wpabuf_put_le16(req
, 0);
1314 wpabuf_put_le16(req
, blobmsg_get_u32(tb
[BEACON_REQ_DURATION
]));
1317 wpabuf_put_u8(req
, blobmsg_get_u32(tb
[BEACON_REQ_MODE
]));
1320 wpabuf_put_data(req
, bssid
, ETH_ALEN
);
1322 if ((cur
= tb
[BEACON_REQ_SSID
]) != NULL
) {
1323 wpabuf_put_u8(req
, WLAN_EID_SSID
);
1324 wpabuf_put_u8(req
, blobmsg_data_len(cur
) - 1);
1325 wpabuf_put_data(req
, blobmsg_data(cur
), blobmsg_data_len(cur
) - 1);
1328 ret
= hostapd_send_beacon_req(hapd
, addr
, 0, req
);
1337 LM_REQ_TX_POWER_USED
,
1338 LM_REQ_TX_POWER_MAX
,
1342 static const struct blobmsg_policy lm_req_policy
[__LM_REQ_MAX
] = {
1343 [LM_REQ_ADDR
] = { "addr", BLOBMSG_TYPE_STRING
},
1344 [LM_REQ_TX_POWER_USED
] = { "tx-power-used", BLOBMSG_TYPE_INT32
},
1345 [LM_REQ_TX_POWER_MAX
] = { "tx-power-max", BLOBMSG_TYPE_INT32
},
1349 hostapd_rrm_lm_req(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1350 struct ubus_request_data
*ureq
, const char *method
,
1351 struct blob_attr
*msg
)
1353 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
1354 struct blob_attr
*tb
[__LM_REQ_MAX
];
1358 int8_t txp_used
, txp_max
;
1363 blobmsg_parse(lm_req_policy
, __LM_REQ_MAX
, tb
, blob_data(msg
), blob_len(msg
));
1365 if (!tb
[LM_REQ_ADDR
])
1366 return UBUS_STATUS_INVALID_ARGUMENT
;
1368 if (tb
[LM_REQ_TX_POWER_USED
])
1369 txp_used
= (int8_t) blobmsg_get_u32(tb
[LM_REQ_TX_POWER_USED
]);
1371 if (tb
[LM_REQ_TX_POWER_MAX
])
1372 txp_max
= (int8_t) blobmsg_get_u32(tb
[LM_REQ_TX_POWER_MAX
]);
1374 if (hwaddr_aton(blobmsg_data(tb
[LM_REQ_ADDR
]), addr
))
1375 return UBUS_STATUS_INVALID_ARGUMENT
;
1377 buf
= wpabuf_alloc(5);
1379 return UBUS_STATUS_UNKNOWN_ERROR
;
1381 wpabuf_put_u8(buf
, WLAN_ACTION_RADIO_MEASUREMENT
);
1382 wpabuf_put_u8(buf
, WLAN_RRM_LINK_MEASUREMENT_REQUEST
);
1383 wpabuf_put_u8(buf
, 1);
1385 wpabuf_put_u8(buf
, txp_used
);
1387 wpabuf_put_u8(buf
, txp_max
);
1389 ret
= hostapd_drv_send_action(hapd
, hapd
->iface
->freq
, 0, addr
,
1390 wpabuf_head(buf
), wpabuf_len(buf
));
1400 void hostapd_ubus_handle_link_measurement(struct hostapd_data
*hapd
, const u8
*data
, size_t len
)
1402 const struct ieee80211_mgmt
*mgmt
= (const struct ieee80211_mgmt
*) data
;
1403 const u8
*pos
, *end
;
1407 token
= mgmt
->u
.action
.u
.rrm
.dialog_token
;
1408 pos
= mgmt
->u
.action
.u
.rrm
.variable
;
1413 if (!hapd
->ubus
.obj
.has_subscribers
)
1416 blob_buf_init(&b
, 0);
1417 blobmsg_add_macaddr(&b
, "address", mgmt
->sa
);
1418 blobmsg_add_u16(&b
, "dialog-token", token
);
1419 blobmsg_add_u16(&b
, "rx-antenna-id", pos
[4]);
1420 blobmsg_add_u16(&b
, "tx-antenna-id", pos
[5]);
1421 blobmsg_add_u16(&b
, "rcpi", pos
[6]);
1422 blobmsg_add_u16(&b
, "rsni", pos
[7]);
1424 ubus_notify(ctx
, &hapd
->ubus
.obj
, "link-measurement-report", b
.head
, -1);
1428 #ifdef CONFIG_WNM_AP
1431 hostapd_bss_tr_send(struct hostapd_data
*hapd
, u8
*addr
, bool disassoc_imminent
, bool abridged
,
1432 u16 disassoc_timer
, u8 validity_period
, u8 dialog_token
,
1433 struct blob_attr
*neighbors
, u8 mbo_reason
, u8 cell_pref
, u8 reassoc_delay
)
1435 struct blob_attr
*cur
;
1436 struct sta_info
*sta
;
1444 sta
= ap_get_sta(hapd
, addr
);
1446 return UBUS_STATUS_NOT_FOUND
;
1451 if (blobmsg_check_array(neighbors
,
1452 BLOBMSG_TYPE_STRING
) < 0)
1453 return UBUS_STATUS_INVALID_ARGUMENT
;
1455 blobmsg_for_each_attr(cur
, neighbors
, rem
) {
1456 int len
= strlen(blobmsg_get_string(cur
));
1459 return UBUS_STATUS_INVALID_ARGUMENT
;
1461 nr_len
+= (len
/ 2) + 2;
1465 nr
= os_zalloc(nr_len
);
1467 return UBUS_STATUS_UNKNOWN_ERROR
;
1471 blobmsg_for_each_attr(cur
, neighbors
, rem
) {
1472 int len
= strlen(blobmsg_get_string(cur
)) / 2;
1474 *nr_cur
++ = WLAN_EID_NEIGHBOR_REPORT
;
1475 *nr_cur
++ = (u8
) len
;
1476 if (hexstr2bin(blobmsg_data(cur
), nr_cur
, len
)) {
1478 return UBUS_STATUS_INVALID_ARGUMENT
;
1486 req_mode
|= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED
;
1489 req_mode
|= WNM_BSS_TM_REQ_ABRIDGED
;
1491 if (disassoc_imminent
)
1492 req_mode
|= WNM_BSS_TM_REQ_DISASSOC_IMMINENT
;
1497 if (mbo_reason
> MBO_TRANSITION_REASON_PREMIUM_AP
)
1498 return UBUS_STATUS_INVALID_ARGUMENT
;
1500 if (cell_pref
!= 0 && cell_pref
!= 1 && cell_pref
!= 255)
1501 return UBUS_STATUS_INVALID_ARGUMENT
;
1503 if (reassoc_delay
> 65535 || (reassoc_delay
&& !disassoc_imminent
))
1504 return UBUS_STATUS_INVALID_ARGUMENT
;
1506 *mbo_pos
++ = MBO_ATTR_ID_TRANSITION_REASON
;
1508 *mbo_pos
++ = mbo_reason
;
1509 *mbo_pos
++ = MBO_ATTR_ID_CELL_DATA_PREF
;
1511 *mbo_pos
++ = cell_pref
;
1513 if (reassoc_delay
) {
1514 *mbo_pos
++ = MBO_ATTR_ID_ASSOC_RETRY_DELAY
;
1516 WPA_PUT_LE16(mbo_pos
, reassoc_delay
);
1520 mbo_len
= mbo_pos
- mbo
;
1523 if (wnm_send_bss_tm_req(hapd
, sta
, req_mode
, disassoc_timer
, validity_period
, NULL
,
1524 dialog_token
, NULL
, nr
, nr_len
, mbo_len
? mbo
: NULL
, mbo_len
))
1525 return UBUS_STATUS_UNKNOWN_ERROR
;
1534 BSS_TR_VALID_PERIOD
,
1537 BSS_TR_DIALOG_TOKEN
,
1541 BSS_TR_REASSOC_DELAY
,
1543 __BSS_TR_DISASSOC_MAX
1546 static const struct blobmsg_policy bss_tr_policy
[__BSS_TR_DISASSOC_MAX
] = {
1547 [BSS_TR_ADDR
] = { "addr", BLOBMSG_TYPE_STRING
},
1548 [BSS_TR_DA_IMMINENT
] = { "disassociation_imminent", BLOBMSG_TYPE_BOOL
},
1549 [BSS_TR_DA_TIMER
] = { "disassociation_timer", BLOBMSG_TYPE_INT32
},
1550 [BSS_TR_VALID_PERIOD
] = { "validity_period", BLOBMSG_TYPE_INT32
},
1551 [BSS_TR_NEIGHBORS
] = { "neighbors", BLOBMSG_TYPE_ARRAY
},
1552 [BSS_TR_ABRIDGED
] = { "abridged", BLOBMSG_TYPE_BOOL
},
1553 [BSS_TR_DIALOG_TOKEN
] = { "dialog_token", BLOBMSG_TYPE_INT32
},
1555 [BSS_TR_MBO_REASON
] = { "mbo_reason", BLOBMSG_TYPE_INT32
},
1556 [BSS_TR_CELL_PREF
] = { "cell_pref", BLOBMSG_TYPE_INT32
},
1557 [BSS_TR_REASSOC_DELAY
] = { "reassoc_delay", BLOBMSG_TYPE_INT32
},
1562 hostapd_bss_transition_request(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1563 struct ubus_request_data
*ureq
, const char *method
,
1564 struct blob_attr
*msg
)
1566 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
1567 struct blob_attr
*tb
[__BSS_TR_DISASSOC_MAX
];
1568 struct sta_info
*sta
;
1570 u32 valid_period
= 0;
1572 u32 dialog_token
= 1;
1579 blobmsg_parse(bss_tr_policy
, __BSS_TR_DISASSOC_MAX
, tb
, blob_data(msg
), blob_len(msg
));
1581 if (!tb
[BSS_TR_ADDR
])
1582 return UBUS_STATUS_INVALID_ARGUMENT
;
1584 if (hwaddr_aton(blobmsg_data(tb
[BSS_TR_ADDR
]), addr
))
1585 return UBUS_STATUS_INVALID_ARGUMENT
;
1587 if (tb
[BSS_TR_DA_TIMER
])
1588 da_timer
= blobmsg_get_u32(tb
[BSS_TR_DA_TIMER
]);
1590 if (tb
[BSS_TR_VALID_PERIOD
])
1591 valid_period
= blobmsg_get_u32(tb
[BSS_TR_VALID_PERIOD
]);
1593 if (tb
[BSS_TR_DIALOG_TOKEN
])
1594 dialog_token
= blobmsg_get_u32(tb
[BSS_TR_DIALOG_TOKEN
]);
1596 da_imminent
= !!(tb
[BSS_TR_DA_IMMINENT
] && blobmsg_get_bool(tb
[BSS_TR_DA_IMMINENT
]));
1597 abridged
= !!(tb
[BSS_TR_ABRIDGED
] && blobmsg_get_bool(tb
[BSS_TR_ABRIDGED
]));
1600 if (tb
[BSS_TR_MBO_REASON
])
1601 mbo_reason
= blobmsg_get_u32(tb
[BSS_TR_MBO_REASON
]);
1603 if (tb
[BSS_TR_CELL_PREF
])
1604 cell_pref
= blobmsg_get_u32(tb
[BSS_TR_CELL_PREF
]);
1606 if (tb
[BSS_TR_REASSOC_DELAY
])
1607 reassoc_delay
= blobmsg_get_u32(tb
[BSS_TR_REASSOC_DELAY
]);
1610 return hostapd_bss_tr_send(hapd
, addr
, da_imminent
, abridged
, da_timer
, valid_period
,
1611 dialog_token
, tb
[BSS_TR_NEIGHBORS
], mbo_reason
, cell_pref
, reassoc_delay
);
1615 #ifdef CONFIG_AIRTIME_POLICY
1618 UPDATE_AIRTIME_WEIGHT
,
1619 __UPDATE_AIRTIME_MAX
,
1623 static const struct blobmsg_policy airtime_policy
[__UPDATE_AIRTIME_MAX
] = {
1624 [UPDATE_AIRTIME_STA
] = { "sta", BLOBMSG_TYPE_STRING
},
1625 [UPDATE_AIRTIME_WEIGHT
] = { "weight", BLOBMSG_TYPE_INT32
},
1629 hostapd_bss_update_airtime(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1630 struct ubus_request_data
*ureq
, const char *method
,
1631 struct blob_attr
*msg
)
1633 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
1634 struct blob_attr
*tb
[__UPDATE_AIRTIME_MAX
];
1635 struct sta_info
*sta
= NULL
;
1639 blobmsg_parse(airtime_policy
, __UPDATE_AIRTIME_MAX
, tb
, blob_data(msg
), blob_len(msg
));
1641 if (!tb
[UPDATE_AIRTIME_WEIGHT
])
1642 return UBUS_STATUS_INVALID_ARGUMENT
;
1644 weight
= blobmsg_get_u32(tb
[UPDATE_AIRTIME_WEIGHT
]);
1646 if (!tb
[UPDATE_AIRTIME_STA
]) {
1648 return UBUS_STATUS_INVALID_ARGUMENT
;
1650 hapd
->conf
->airtime_weight
= weight
;
1654 if (hwaddr_aton(blobmsg_data(tb
[UPDATE_AIRTIME_STA
]), addr
))
1655 return UBUS_STATUS_INVALID_ARGUMENT
;
1657 sta
= ap_get_sta(hapd
, addr
);
1659 return UBUS_STATUS_NOT_FOUND
;
1661 sta
->dyn_airtime_weight
= weight
;
1662 airtime_policy_new_sta(hapd
, sta
);
1668 #ifdef CONFIG_TAXONOMY
1669 static const struct blobmsg_policy addr_policy
[] = {
1670 { "address", BLOBMSG_TYPE_STRING
}
1674 hostapd_add_b64_data(const char *name
, const struct wpabuf
*buf
)
1681 str
= blobmsg_alloc_string_buffer(&b
, name
, B64_ENCODE_LEN(wpabuf_len(buf
)));
1682 b64_encode(wpabuf_head(buf
), wpabuf_len(buf
), str
, B64_ENCODE_LEN(wpabuf_len(buf
)));
1683 blobmsg_add_string_buffer(&b
);
1689 hostapd_bss_get_sta_ies(struct ubus_context
*ctx
, struct ubus_object
*obj
,
1690 struct ubus_request_data
*req
, const char *method
,
1691 struct blob_attr
*msg
)
1693 struct hostapd_data
*hapd
= container_of(obj
, struct hostapd_data
, ubus
.obj
);
1694 struct blob_attr
*tb
;
1695 struct sta_info
*sta
;
1698 blobmsg_parse(addr_policy
, 1, &tb
, blobmsg_data(msg
), blobmsg_len(msg
));
1700 if (!tb
|| hwaddr_aton(blobmsg_data(tb
), addr
))
1701 return UBUS_STATUS_INVALID_ARGUMENT
;
1703 sta
= ap_get_sta(hapd
, addr
);
1704 if (!sta
|| (!sta
->probe_ie_taxonomy
&& !sta
->assoc_ie_taxonomy
))
1705 return UBUS_STATUS_NOT_FOUND
;
1707 blob_buf_init(&b
, 0);
1708 hostapd_add_b64_data("probe_ie", sta
->probe_ie_taxonomy
);
1709 hostapd_add_b64_data("assoc_ie", sta
->assoc_ie_taxonomy
);
1710 ubus_send_reply(ctx
, req
, b
.head
);
1717 static const struct ubus_method bss_methods
[] = {
1718 UBUS_METHOD_NOARG("reload", hostapd_bss_reload
),
1719 UBUS_METHOD_NOARG("get_clients", hostapd_bss_get_clients
),
1720 #ifdef CONFIG_TAXONOMY
1721 UBUS_METHOD("get_sta_ies", hostapd_bss_get_sta_ies
, addr_policy
),
1723 UBUS_METHOD_NOARG("get_status", hostapd_bss_get_status
),
1724 UBUS_METHOD("del_client", hostapd_bss_del_client
, del_policy
),
1725 #ifdef CONFIG_AIRTIME_POLICY
1726 UBUS_METHOD("update_airtime", hostapd_bss_update_airtime
, airtime_policy
),
1728 UBUS_METHOD_NOARG("list_bans", hostapd_bss_list_bans
),
1730 UBUS_METHOD_NOARG("wps_start", hostapd_bss_wps_start
),
1731 UBUS_METHOD_NOARG("wps_status", hostapd_bss_wps_status
),
1732 UBUS_METHOD_NOARG("wps_cancel", hostapd_bss_wps_cancel
),
1734 UBUS_METHOD_NOARG("update_beacon", hostapd_bss_update_beacon
),
1735 UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features
),
1737 UBUS_METHOD("switch_chan", hostapd_switch_chan
, csa_policy
),
1739 UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements
, ve_policy
),
1740 UBUS_METHOD("notify_response", hostapd_notify_response
, notify_policy
),
1741 UBUS_METHOD("bss_mgmt_enable", hostapd_bss_mgmt_enable
, bss_mgmt_enable_policy
),
1742 UBUS_METHOD_NOARG("rrm_nr_get_own", hostapd_rrm_nr_get_own
),
1743 UBUS_METHOD_NOARG("rrm_nr_list", hostapd_rrm_nr_list
),
1744 UBUS_METHOD("rrm_nr_set", hostapd_rrm_nr_set
, nr_set_policy
),
1745 UBUS_METHOD("rrm_beacon_req", hostapd_rrm_beacon_req
, beacon_req_policy
),
1746 UBUS_METHOD("link_measurement_req", hostapd_rrm_lm_req
, lm_req_policy
),
1747 #ifdef CONFIG_WNM_AP
1748 UBUS_METHOD("bss_transition_request", hostapd_bss_transition_request
, bss_tr_policy
),
1752 static struct ubus_object_type bss_object_type
=
1753 UBUS_OBJECT_TYPE("hostapd_bss", bss_methods
);
1755 static int avl_compare_macaddr(const void *k1
, const void *k2
, void *ptr
)
1757 return memcmp(k1
, k2
, ETH_ALEN
);
1760 void hostapd_ubus_add_bss(struct hostapd_data
*hapd
)
1762 struct ubus_object
*obj
= &hapd
->ubus
.obj
;
1767 if (hapd
->conf
->mesh
& MESH_ENABLED
)
1771 if (!hostapd_ubus_init())
1774 if (asprintf(&name
, "hostapd.%s", hapd
->conf
->iface
) < 0)
1777 avl_init(&hapd
->ubus
.banned
, avl_compare_macaddr
, false, NULL
);
1779 obj
->type
= &bss_object_type
;
1780 obj
->methods
= bss_object_type
.methods
;
1781 obj
->n_methods
= bss_object_type
.n_methods
;
1782 ret
= ubus_add_object(ctx
, obj
);
1783 hostapd_ubus_ref_inc();
1785 hostapd_send_shared_event(&hapd
->iface
->interfaces
->ubus
, hapd
->conf
->iface
, "add");
1788 void hostapd_ubus_free_bss(struct hostapd_data
*hapd
)
1790 struct ubus_object
*obj
= &hapd
->ubus
.obj
;
1791 char *name
= (char *) obj
->name
;
1794 if (hapd
->conf
->mesh
& MESH_ENABLED
)
1801 hostapd_send_shared_event(&hapd
->iface
->interfaces
->ubus
, hapd
->conf
->iface
, "remove");
1804 ubus_remove_object(ctx
, obj
);
1805 hostapd_ubus_ref_dec();
1812 hostapd_ubus_vlan_action(struct hostapd_data
*hapd
, struct hostapd_vlan
*vlan
,
1815 struct vlan_description
*desc
= &vlan
->vlan_desc
;
1819 if (!hapd
->ubus
.obj
.has_subscribers
)
1822 blob_buf_init(&b
, 0);
1823 blobmsg_add_string(&b
, "ifname", vlan
->ifname
);
1824 blobmsg_add_string(&b
, "bridge", vlan
->bridge
);
1825 blobmsg_add_u32(&b
, "vlan_id", vlan
->vlan_id
);
1827 if (desc
->notempty
) {
1828 blobmsg_add_u32(&b
, "untagged", desc
->untagged
);
1829 c
= blobmsg_open_array(&b
, "tagged");
1830 for (i
= 0; i
< ARRAY_SIZE(desc
->tagged
) && desc
->tagged
[i
]; i
++)
1831 blobmsg_add_u32(&b
, "", desc
->tagged
[i
]);
1832 blobmsg_close_array(&b
, c
);
1835 ubus_notify(ctx
, &hapd
->ubus
.obj
, action
, b
.head
, -1);
1838 void hostapd_ubus_add_vlan(struct hostapd_data
*hapd
, struct hostapd_vlan
*vlan
)
1840 hostapd_ubus_vlan_action(hapd
, vlan
, "vlan_add");
1843 void hostapd_ubus_remove_vlan(struct hostapd_data
*hapd
, struct hostapd_vlan
*vlan
)
1845 hostapd_ubus_vlan_action(hapd
, vlan
, "vlan_remove");
1848 static const struct ubus_method daemon_methods
[] = {
1849 UBUS_METHOD("config_add", hostapd_config_add
, config_add_policy
),
1850 UBUS_METHOD("config_remove", hostapd_config_remove
, config_remove_policy
),
1853 static struct ubus_object_type daemon_object_type
=
1854 UBUS_OBJECT_TYPE("hostapd", daemon_methods
);
1856 void hostapd_ubus_add(struct hapd_interfaces
*interfaces
)
1858 struct ubus_object
*obj
= &interfaces
->ubus
;
1861 if (!hostapd_ubus_init())
1864 obj
->name
= strdup("hostapd");
1866 obj
->type
= &daemon_object_type
;
1867 obj
->methods
= daemon_object_type
.methods
;
1868 obj
->n_methods
= daemon_object_type
.n_methods
;
1869 ret
= ubus_add_object(ctx
, obj
);
1870 hostapd_ubus_ref_inc();
1873 void hostapd_ubus_free(struct hapd_interfaces
*interfaces
)
1875 struct ubus_object
*obj
= &interfaces
->ubus
;
1876 char *name
= (char *) obj
->name
;
1882 ubus_remove_object(ctx
, obj
);
1883 hostapd_ubus_ref_dec();
1889 struct ubus_event_req
{
1890 struct ubus_notify_request nreq
;
1895 ubus_event_cb(struct ubus_notify_request
*req
, int idx
, int ret
)
1897 struct ubus_event_req
*ureq
= container_of(req
, struct ubus_event_req
, nreq
);
1902 int hostapd_ubus_handle_event(struct hostapd_data
*hapd
, struct hostapd_ubus_request
*req
)
1904 struct ubus_banned_client
*ban
;
1905 const char *types
[HOSTAPD_UBUS_TYPE_MAX
] = {
1906 [HOSTAPD_UBUS_PROBE_REQ
] = "probe",
1907 [HOSTAPD_UBUS_AUTH_REQ
] = "auth",
1908 [HOSTAPD_UBUS_ASSOC_REQ
] = "assoc",
1910 const char *type
= "mgmt";
1911 struct ubus_event_req ureq
= {};
1914 if (req
->mgmt_frame
)
1915 addr
= req
->mgmt_frame
->sa
;
1919 ban
= avl_find_element(&hapd
->ubus
.banned
, addr
, ban
, avl
);
1921 return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA
;
1923 if (!hapd
->ubus
.obj
.has_subscribers
)
1924 return WLAN_STATUS_SUCCESS
;
1926 if (req
->type
< ARRAY_SIZE(types
))
1927 type
= types
[req
->type
];
1929 blob_buf_init(&b
, 0);
1930 blobmsg_add_macaddr(&b
, "address", addr
);
1931 if (req
->mgmt_frame
)
1932 blobmsg_add_macaddr(&b
, "target", req
->mgmt_frame
->da
);
1933 if (req
->ssi_signal
)
1934 blobmsg_add_u32(&b
, "signal", req
->ssi_signal
);
1935 blobmsg_add_u32(&b
, "freq", hapd
->iface
->freq
);
1938 if(req
->elems
->ht_capabilities
)
1940 struct ieee80211_ht_capabilities
*ht_capabilities
;
1941 void *ht_cap
, *ht_cap_mcs_set
, *mcs_set
;
1944 ht_capabilities
= (struct ieee80211_ht_capabilities
*) req
->elems
->ht_capabilities
;
1945 ht_cap
= blobmsg_open_table(&b
, "ht_capabilities");
1946 blobmsg_add_u16(&b
, "ht_capabilities_info", ht_capabilities
->ht_capabilities_info
);
1947 ht_cap_mcs_set
= blobmsg_open_table(&b
, "supported_mcs_set");
1948 blobmsg_add_u16(&b
, "a_mpdu_params", ht_capabilities
->a_mpdu_params
);
1949 blobmsg_add_u16(&b
, "ht_extended_capabilities", ht_capabilities
->ht_extended_capabilities
);
1950 blobmsg_add_u32(&b
, "tx_bf_capability_info", ht_capabilities
->tx_bf_capability_info
);
1951 blobmsg_add_u16(&b
, "asel_capabilities", ht_capabilities
->asel_capabilities
);
1952 mcs_set
= blobmsg_open_array(&b
, "supported_mcs_set");
1953 for (int i
= 0; i
< 16; i
++) {
1954 blobmsg_add_u16(&b
, NULL
, (u16
) ht_capabilities
->supported_mcs_set
[i
]);
1956 blobmsg_close_array(&b
, mcs_set
);
1957 blobmsg_close_table(&b
, ht_cap_mcs_set
);
1958 blobmsg_close_table(&b
, ht_cap
);
1960 if(req
->elems
->vht_capabilities
)
1962 struct ieee80211_vht_capabilities
*vht_capabilities
;
1963 void *vht_cap
, *vht_cap_mcs_set
;
1965 vht_capabilities
= (struct ieee80211_vht_capabilities
*) req
->elems
->vht_capabilities
;
1966 vht_cap
= blobmsg_open_table(&b
, "vht_capabilities");
1967 blobmsg_add_u32(&b
, "vht_capabilities_info", vht_capabilities
->vht_capabilities_info
);
1968 vht_cap_mcs_set
= blobmsg_open_table(&b
, "vht_supported_mcs_set");
1969 blobmsg_add_u16(&b
, "rx_map", vht_capabilities
->vht_supported_mcs_set
.rx_map
);
1970 blobmsg_add_u16(&b
, "rx_highest", vht_capabilities
->vht_supported_mcs_set
.rx_highest
);
1971 blobmsg_add_u16(&b
, "tx_map", vht_capabilities
->vht_supported_mcs_set
.tx_map
);
1972 blobmsg_add_u16(&b
, "tx_highest", vht_capabilities
->vht_supported_mcs_set
.tx_highest
);
1973 blobmsg_close_table(&b
, vht_cap_mcs_set
);
1974 blobmsg_close_table(&b
, vht_cap
);
1978 if (!hapd
->ubus
.notify_response
) {
1979 ubus_notify(ctx
, &hapd
->ubus
.obj
, type
, b
.head
, -1);
1980 return WLAN_STATUS_SUCCESS
;
1983 if (ubus_notify_async(ctx
, &hapd
->ubus
.obj
, type
, b
.head
, &ureq
.nreq
))
1984 return WLAN_STATUS_SUCCESS
;
1986 ureq
.nreq
.status_cb
= ubus_event_cb
;
1987 ubus_complete_request(ctx
, &ureq
.nreq
.req
, 100);
1992 return WLAN_STATUS_SUCCESS
;
1995 void hostapd_ubus_notify(struct hostapd_data
*hapd
, const char *type
, const u8
*addr
)
1997 if (!hapd
->ubus
.obj
.has_subscribers
)
2003 blob_buf_init(&b
, 0);
2004 blobmsg_add_macaddr(&b
, "address", addr
);
2006 ubus_notify(ctx
, &hapd
->ubus
.obj
, type
, b
.head
, -1);
2009 void hostapd_ubus_notify_authorized(struct hostapd_data
*hapd
, struct sta_info
*sta
,
2010 const char *auth_alg
)
2012 if (!hapd
->ubus
.obj
.has_subscribers
)
2015 blob_buf_init(&b
, 0);
2016 blobmsg_add_macaddr(&b
, "address", sta
->addr
);
2018 blobmsg_add_string(&b
, "auth-alg", auth_alg
);
2020 ubus_notify(ctx
, &hapd
->ubus
.obj
, "sta-authorized", b
.head
, -1);
2023 void hostapd_ubus_notify_beacon_report(
2024 struct hostapd_data
*hapd
, const u8
*addr
, u8 token
, u8 rep_mode
,
2025 struct rrm_measurement_beacon_report
*rep
, size_t len
)
2027 if (!hapd
->ubus
.obj
.has_subscribers
)
2033 blob_buf_init(&b
, 0);
2034 blobmsg_add_macaddr(&b
, "address", addr
);
2035 blobmsg_add_u16(&b
, "op-class", rep
->op_class
);
2036 blobmsg_add_u16(&b
, "channel", rep
->channel
);
2037 blobmsg_add_u64(&b
, "start-time", rep
->start_time
);
2038 blobmsg_add_u16(&b
, "duration", rep
->duration
);
2039 blobmsg_add_u16(&b
, "report-info", rep
->report_info
);
2040 blobmsg_add_u16(&b
, "rcpi", rep
->rcpi
);
2041 blobmsg_add_u16(&b
, "rsni", rep
->rsni
);
2042 blobmsg_add_macaddr(&b
, "bssid", rep
->bssid
);
2043 blobmsg_add_u16(&b
, "antenna-id", rep
->antenna_id
);
2044 blobmsg_add_u16(&b
, "parent-tsf", rep
->parent_tsf
);
2045 blobmsg_add_u16(&b
, "rep-mode", rep_mode
);
2047 ubus_notify(ctx
, &hapd
->ubus
.obj
, "beacon-report", b
.head
, -1);
2050 void hostapd_ubus_notify_radar_detected(struct hostapd_iface
*iface
, int frequency
,
2051 int chan_width
, int cf1
, int cf2
)
2053 struct hostapd_data
*hapd
;
2056 blob_buf_init(&b
, 0);
2057 blobmsg_add_u16(&b
, "frequency", frequency
);
2058 blobmsg_add_u16(&b
, "width", chan_width
);
2059 blobmsg_add_u16(&b
, "center1", cf1
);
2060 blobmsg_add_u16(&b
, "center2", cf2
);
2062 for (i
= 0; i
< iface
->num_bss
; i
++) {
2063 hapd
= iface
->bss
[i
];
2064 ubus_notify(ctx
, &hapd
->ubus
.obj
, "radar-detected", b
.head
, -1);
2068 #ifdef CONFIG_WNM_AP
2069 static void hostapd_ubus_notify_bss_transition_add_candidate_list(
2070 const u8
*candidate_list
, u16 candidate_list_len
)
2075 if (candidate_list_len
== 0)
2078 cl_str
= blobmsg_alloc_string_buffer(&b
, "candidate-list", candidate_list_len
* 2 + 1);
2079 for (i
= 0; i
< candidate_list_len
; i
++)
2080 snprintf(&cl_str
[i
*2], 3, "%02X", candidate_list
[i
]);
2081 blobmsg_add_string_buffer(&b
);
2086 void hostapd_ubus_notify_bss_transition_response(
2087 struct hostapd_data
*hapd
, const u8
*addr
, u8 dialog_token
, u8 status_code
,
2088 u8 bss_termination_delay
, const u8
*target_bssid
,
2089 const u8
*candidate_list
, u16 candidate_list_len
)
2091 #ifdef CONFIG_WNM_AP
2094 if (!hapd
->ubus
.obj
.has_subscribers
)
2100 blob_buf_init(&b
, 0);
2101 blobmsg_add_macaddr(&b
, "address", addr
);
2102 blobmsg_add_u8(&b
, "dialog-token", dialog_token
);
2103 blobmsg_add_u8(&b
, "status-code", status_code
);
2104 blobmsg_add_u8(&b
, "bss-termination-delay", bss_termination_delay
);
2106 blobmsg_add_macaddr(&b
, "target-bssid", target_bssid
);
2108 hostapd_ubus_notify_bss_transition_add_candidate_list(candidate_list
, candidate_list_len
);
2110 ubus_notify(ctx
, &hapd
->ubus
.obj
, "bss-transition-response", b
.head
, -1);
2114 int hostapd_ubus_notify_bss_transition_query(
2115 struct hostapd_data
*hapd
, const u8
*addr
, u8 dialog_token
, u8 reason
,
2116 const u8
*candidate_list
, u16 candidate_list_len
)
2118 #ifdef CONFIG_WNM_AP
2119 struct ubus_event_req ureq
= {};
2123 if (!hapd
->ubus
.obj
.has_subscribers
)
2129 blob_buf_init(&b
, 0);
2130 blobmsg_add_macaddr(&b
, "address", addr
);
2131 blobmsg_add_u8(&b
, "dialog-token", dialog_token
);
2132 blobmsg_add_u8(&b
, "reason", reason
);
2133 hostapd_ubus_notify_bss_transition_add_candidate_list(candidate_list
, candidate_list_len
);
2135 if (!hapd
->ubus
.notify_response
) {
2136 ubus_notify(ctx
, &hapd
->ubus
.obj
, "bss-transition-query", b
.head
, -1);
2140 if (ubus_notify_async(ctx
, &hapd
->ubus
.obj
, "bss-transition-query", b
.head
, &ureq
.nreq
))
2143 ureq
.nreq
.status_cb
= ubus_event_cb
;
2144 ubus_complete_request(ctx
, &ureq
.nreq
.req
, 100);