1 /*
2 * Driver interaction with Linux nl80211/cfg80211 - Capabilities
3 * Copyright (c) 2002-2015, Jouni Malinen <j@w1.fi>
4 * Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
5 * Copyright (c) 2009-2010, Atheros Communications
6 *
7 * This software may be distributed under the terms of the BSD license.
8 * See README for more details.
9 */
10
11 #include "includes.h"
12 #include <netlink/genl/genl.h>
13
14 #include "utils/common.h"
15 #include "common/ieee802_11_common.h"
16 #include "common/wpa_common.h"
17 #include "common/qca-vendor.h"
18 #include "common/qca-vendor-attr.h"
19 #include "common/brcm_vendor.h"
20 #include "driver_nl80211.h"
21
22
protocol_feature_handler(struct nl_msg * msg,void * arg)23 static int protocol_feature_handler(struct nl_msg *msg, void *arg)
24 {
25 u32 *feat = arg;
26 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
27 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
28
29 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
30 genlmsg_attrlen(gnlh, 0), NULL);
31
32 if (tb_msg[NL80211_ATTR_PROTOCOL_FEATURES])
33 *feat = nla_get_u32(tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]);
34
35 return NL_SKIP;
36 }
37
38
get_nl80211_protocol_features(struct wpa_driver_nl80211_data * drv)39 u32 get_nl80211_protocol_features(struct wpa_driver_nl80211_data *drv)
40 {
41 u32 feat = 0;
42 struct nl_msg *msg;
43
44 msg = nlmsg_alloc();
45 if (!msg)
46 return 0;
47
48 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_PROTOCOL_FEATURES)) {
49 nlmsg_free(msg);
50 return 0;
51 }
52
53 if (send_and_recv_resp(drv, msg, protocol_feature_handler, &feat) == 0)
54 return feat;
55
56 return 0;
57 }
58
59
60 struct wiphy_info_data {
61 struct wpa_driver_nl80211_data *drv;
62 struct wpa_driver_capa *capa;
63
64 unsigned int num_multichan_concurrent;
65
66 unsigned int error:1;
67 unsigned int device_ap_sme:1;
68 unsigned int poll_command_supported:1;
69 unsigned int data_tx_status:1;
70 unsigned int auth_supported:1;
71 unsigned int connect_supported:1;
72 unsigned int p2p_go_supported:1;
73 unsigned int p2p_client_supported:1;
74 unsigned int p2p_go_ctwindow_supported:1;
75 unsigned int p2p_concurrent:1;
76 unsigned int channel_switch_supported:1;
77 unsigned int set_qos_map_supported:1;
78 unsigned int have_low_prio_scan:1;
79 unsigned int wmm_ac_supported:1;
80 unsigned int mac_addr_rand_scan_supported:1;
81 unsigned int mac_addr_rand_sched_scan_supported:1;
82 unsigned int update_ft_ies_supported:1;
83 unsigned int has_key_mgmt:1;
84 unsigned int has_key_mgmt_iftype:1;
85 };
86
87
probe_resp_offload_support(int supp_protocols)88 static unsigned int probe_resp_offload_support(int supp_protocols)
89 {
90 unsigned int prot = 0;
91
92 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS)
93 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS;
94 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2)
95 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2;
96 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P)
97 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P;
98 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U)
99 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING;
100
101 return prot;
102 }
103
104
wiphy_info_supported_iftypes(struct wiphy_info_data * info,struct nlattr * tb)105 static void wiphy_info_supported_iftypes(struct wiphy_info_data *info,
106 struct nlattr *tb)
107 {
108 struct nlattr *nl_mode;
109 int i;
110
111 if (tb == NULL)
112 return;
113
114 nla_for_each_nested(nl_mode, tb, i) {
115 switch (nla_type(nl_mode)) {
116 case NL80211_IFTYPE_AP:
117 info->capa->flags |= WPA_DRIVER_FLAGS_AP;
118 break;
119 case NL80211_IFTYPE_MESH_POINT:
120 info->capa->flags |= WPA_DRIVER_FLAGS_MESH;
121 break;
122 case NL80211_IFTYPE_ADHOC:
123 info->capa->flags |= WPA_DRIVER_FLAGS_IBSS;
124 break;
125 case NL80211_IFTYPE_P2P_DEVICE:
126 info->capa->flags |=
127 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE;
128 break;
129 case NL80211_IFTYPE_P2P_GO:
130 info->p2p_go_supported = 1;
131 break;
132 case NL80211_IFTYPE_P2P_CLIENT:
133 info->p2p_client_supported = 1;
134 break;
135 }
136 }
137 }
138
139
wiphy_info_iface_comb_process(struct wiphy_info_data * info,struct nlattr * nl_combi)140 static int wiphy_info_iface_comb_process(struct wiphy_info_data *info,
141 struct nlattr *nl_combi)
142 {
143 struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB];
144 struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT];
145 struct nlattr *nl_limit, *nl_mode;
146 int err, rem_limit, rem_mode;
147 int combination_has_p2p = 0, combination_has_mgd = 0;
148 static struct nla_policy
149 iface_combination_policy[NUM_NL80211_IFACE_COMB] = {
150 [NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },
151 [NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },
152 [NL80211_IFACE_COMB_STA_AP_BI_MATCH] = { .type = NLA_FLAG },
153 [NL80211_IFACE_COMB_NUM_CHANNELS] = { .type = NLA_U32 },
154 [NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS] = { .type = NLA_U32 },
155 },
156 iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {
157 [NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },
158 [NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },
159 };
160
161 err = nla_parse_nested(tb_comb, MAX_NL80211_IFACE_COMB,
162 nl_combi, iface_combination_policy);
163 if (err || !tb_comb[NL80211_IFACE_COMB_LIMITS] ||
164 !tb_comb[NL80211_IFACE_COMB_MAXNUM] ||
165 !tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS])
166 return 0; /* broken combination */
167
168 if (tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS])
169 info->capa->flags |= WPA_DRIVER_FLAGS_RADAR;
170
171 nla_for_each_nested(nl_limit, tb_comb[NL80211_IFACE_COMB_LIMITS],
172 rem_limit) {
173 err = nla_parse_nested(tb_limit, MAX_NL80211_IFACE_LIMIT,
174 nl_limit, iface_limit_policy);
175 if (err || !tb_limit[NL80211_IFACE_LIMIT_TYPES])
176 return 0; /* broken combination */
177
178 nla_for_each_nested(nl_mode,
179 tb_limit[NL80211_IFACE_LIMIT_TYPES],
180 rem_mode) {
181 int ift = nla_type(nl_mode);
182 if (ift == NL80211_IFTYPE_P2P_GO ||
183 ift == NL80211_IFTYPE_P2P_CLIENT)
184 combination_has_p2p = 1;
185 if (ift == NL80211_IFTYPE_STATION)
186 combination_has_mgd = 1;
187 }
188 if (combination_has_p2p && combination_has_mgd)
189 break;
190 }
191
192 if (combination_has_p2p && combination_has_mgd) {
193 unsigned int num_channels =
194 nla_get_u32(tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]);
195
196 info->p2p_concurrent = 1;
197 if (info->num_multichan_concurrent < num_channels)
198 info->num_multichan_concurrent = num_channels;
199 }
200
201 return 0;
202 }
203
204
wiphy_info_iface_comb(struct wiphy_info_data * info,struct nlattr * tb)205 static void wiphy_info_iface_comb(struct wiphy_info_data *info,
206 struct nlattr *tb)
207 {
208 struct nlattr *nl_combi;
209 int rem_combi;
210
211 if (tb == NULL)
212 return;
213
214 nla_for_each_nested(nl_combi, tb, rem_combi) {
215 if (wiphy_info_iface_comb_process(info, nl_combi) > 0)
216 break;
217 }
218 }
219
220
wiphy_info_supp_cmds(struct wiphy_info_data * info,struct nlattr * tb)221 static void wiphy_info_supp_cmds(struct wiphy_info_data *info,
222 struct nlattr *tb)
223 {
224 struct nlattr *nl_cmd;
225 int i;
226
227 if (tb == NULL)
228 return;
229
230 nla_for_each_nested(nl_cmd, tb, i) {
231 switch (nla_get_u32(nl_cmd)) {
232 case NL80211_CMD_AUTHENTICATE:
233 info->auth_supported = 1;
234 break;
235 case NL80211_CMD_CONNECT:
236 info->connect_supported = 1;
237 break;
238 case NL80211_CMD_START_SCHED_SCAN:
239 info->capa->sched_scan_supported = 1;
240 break;
241 case NL80211_CMD_PROBE_CLIENT:
242 info->poll_command_supported = 1;
243 break;
244 case NL80211_CMD_CHANNEL_SWITCH:
245 info->channel_switch_supported = 1;
246 break;
247 case NL80211_CMD_SET_QOS_MAP:
248 info->set_qos_map_supported = 1;
249 break;
250 case NL80211_CMD_UPDATE_FT_IES:
251 info->update_ft_ies_supported = 1;
252 break;
253 }
254 }
255 }
256
257
get_akm_suites_info(struct nlattr * tb)258 static unsigned int get_akm_suites_info(struct nlattr *tb)
259 {
260 int i, num;
261 unsigned int key_mgmt = 0;
262 u32 *akms;
263
264 if (!tb)
265 return 0;
266
267 num = nla_len(tb) / sizeof(u32);
268 akms = nla_data(tb);
269 for (i = 0; i < num; i++) {
270 switch (akms[i]) {
271 case RSN_AUTH_KEY_MGMT_UNSPEC_802_1X:
272 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA |
273 WPA_DRIVER_CAPA_KEY_MGMT_WPA2;
274 break;
275 case RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X:
276 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
277 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
278 break;
279 case RSN_AUTH_KEY_MGMT_FT_802_1X:
280 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT;
281 break;
282 case RSN_AUTH_KEY_MGMT_FT_PSK:
283 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
284 break;
285 case RSN_AUTH_KEY_MGMT_802_1X_SHA256:
286 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_802_1X_SHA256;
287 break;
288 case RSN_AUTH_KEY_MGMT_PSK_SHA256:
289 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_PSK_SHA256;
290 break;
291 case RSN_AUTH_KEY_MGMT_TPK_HANDSHAKE:
292 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_TPK_HANDSHAKE;
293 break;
294 case RSN_AUTH_KEY_MGMT_FT_SAE:
295 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_SAE;
296 break;
297 case RSN_AUTH_KEY_MGMT_FT_SAE_EXT_KEY:
298 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_SAE_EXT_KEY;
299 break;
300 case RSN_AUTH_KEY_MGMT_FT_802_1X_SHA384:
301 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_802_1X_SHA384;
302 break;
303 case RSN_AUTH_KEY_MGMT_CCKM:
304 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_CCKM;
305 break;
306 case RSN_AUTH_KEY_MGMT_802_1X_SUITE_B:
307 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B;
308 break;
309 case RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192:
310 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192;
311 break;
312 case RSN_AUTH_KEY_MGMT_OWE:
313 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_OWE;
314 break;
315 case RSN_AUTH_KEY_MGMT_DPP:
316 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_DPP;
317 break;
318 case RSN_AUTH_KEY_MGMT_FILS_SHA256:
319 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256;
320 break;
321 case RSN_AUTH_KEY_MGMT_FILS_SHA384:
322 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384;
323 break;
324 case RSN_AUTH_KEY_MGMT_FT_FILS_SHA256:
325 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA256;
326 break;
327 case RSN_AUTH_KEY_MGMT_FT_FILS_SHA384:
328 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA384;
329 break;
330 case RSN_AUTH_KEY_MGMT_SAE:
331 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SAE;
332 break;
333 case RSN_AUTH_KEY_MGMT_SAE_EXT_KEY:
334 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SAE_EXT_KEY;
335 break;
336 }
337 }
338
339 return key_mgmt;
340 }
341
342
get_iface_akm_suites_info(struct wiphy_info_data * info,struct nlattr * nl_akms)343 static void get_iface_akm_suites_info(struct wiphy_info_data *info,
344 struct nlattr *nl_akms)
345 {
346 struct nlattr *tb[NL80211_IFTYPE_AKM_ATTR_MAX + 1];
347 struct nlattr *nl_iftype;
348 unsigned int key_mgmt;
349 int i;
350
351 if (!nl_akms)
352 return;
353
354 nla_parse(tb, NL80211_IFTYPE_AKM_ATTR_MAX,
355 nla_data(nl_akms), nla_len(nl_akms), NULL);
356
357 if (!tb[NL80211_IFTYPE_AKM_ATTR_IFTYPES] ||
358 !tb[NL80211_IFTYPE_AKM_ATTR_SUITES])
359 return;
360
361 info->has_key_mgmt_iftype = 1;
362 key_mgmt = get_akm_suites_info(tb[NL80211_IFTYPE_AKM_ATTR_SUITES]);
363
364 nla_for_each_nested(nl_iftype, tb[NL80211_IFTYPE_AKM_ATTR_IFTYPES], i) {
365 switch (nla_type(nl_iftype)) {
366 case NL80211_IFTYPE_ADHOC:
367 info->drv->capa.key_mgmt_iftype[WPA_IF_IBSS] = key_mgmt;
368 break;
369 case NL80211_IFTYPE_STATION:
370 info->drv->capa.key_mgmt_iftype[WPA_IF_STATION] =
371 key_mgmt;
372 break;
373 case NL80211_IFTYPE_AP:
374 info->drv->capa.key_mgmt_iftype[WPA_IF_AP_BSS] =
375 key_mgmt;
376 break;
377 case NL80211_IFTYPE_AP_VLAN:
378 info->drv->capa.key_mgmt_iftype[WPA_IF_AP_VLAN] =
379 key_mgmt;
380 break;
381 case NL80211_IFTYPE_MESH_POINT:
382 info->drv->capa.key_mgmt_iftype[WPA_IF_MESH] = key_mgmt;
383 break;
384 case NL80211_IFTYPE_P2P_CLIENT:
385 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_CLIENT] =
386 key_mgmt;
387 break;
388 case NL80211_IFTYPE_P2P_GO:
389 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_GO] =
390 key_mgmt;
391 break;
392 case NL80211_IFTYPE_P2P_DEVICE:
393 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_DEVICE] =
394 key_mgmt;
395 break;
396 case NL80211_IFTYPE_NAN:
397 info->drv->capa.key_mgmt_iftype[WPA_IF_NAN] = key_mgmt;
398 break;
399 }
400 wpa_printf(MSG_DEBUG, "nl80211: %s supported key_mgmt 0x%x",
401 nl80211_iftype_str(nla_type(nl_iftype)),
402 key_mgmt);
403 }
404 }
405
406
wiphy_info_iftype_akm_suites(struct wiphy_info_data * info,struct nlattr * tb)407 static void wiphy_info_iftype_akm_suites(struct wiphy_info_data *info,
408 struct nlattr *tb)
409 {
410 struct nlattr *nl_if;
411 int rem_if;
412
413 if (!tb)
414 return;
415
416 nla_for_each_nested(nl_if, tb, rem_if)
417 get_iface_akm_suites_info(info, nl_if);
418 }
419
420
wiphy_info_akm_suites(struct wiphy_info_data * info,struct nlattr * tb)421 static void wiphy_info_akm_suites(struct wiphy_info_data *info,
422 struct nlattr *tb)
423 {
424 if (!tb)
425 return;
426
427 info->has_key_mgmt = 1;
428 info->capa->key_mgmt = get_akm_suites_info(tb);
429 wpa_printf(MSG_DEBUG, "nl80211: wiphy supported key_mgmt 0x%x",
430 info->capa->key_mgmt);
431 }
432
433
wiphy_info_cipher_suites(struct wiphy_info_data * info,struct nlattr * tb)434 static void wiphy_info_cipher_suites(struct wiphy_info_data *info,
435 struct nlattr *tb)
436 {
437 int i, num;
438 u32 *ciphers;
439
440 if (tb == NULL)
441 return;
442
443 num = nla_len(tb) / sizeof(u32);
444 ciphers = nla_data(tb);
445 for (i = 0; i < num; i++) {
446 u32 c = ciphers[i];
447
448 wpa_printf(MSG_DEBUG, "nl80211: Supported cipher %02x-%02x-%02x:%d",
449 c >> 24, (c >> 16) & 0xff,
450 (c >> 8) & 0xff, c & 0xff);
451 switch (c) {
452 case RSN_CIPHER_SUITE_CCMP_256:
453 info->capa->enc |= WPA_DRIVER_CAPA_ENC_CCMP_256;
454 break;
455 case RSN_CIPHER_SUITE_GCMP_256:
456 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GCMP_256;
457 break;
458 case RSN_CIPHER_SUITE_CCMP:
459 info->capa->enc |= WPA_DRIVER_CAPA_ENC_CCMP;
460 break;
461 case RSN_CIPHER_SUITE_GCMP:
462 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GCMP;
463 break;
464 case RSN_CIPHER_SUITE_TKIP:
465 info->capa->enc |= WPA_DRIVER_CAPA_ENC_TKIP;
466 break;
467 case RSN_CIPHER_SUITE_WEP104:
468 info->capa->enc |= WPA_DRIVER_CAPA_ENC_WEP104;
469 break;
470 case RSN_CIPHER_SUITE_WEP40:
471 info->capa->enc |= WPA_DRIVER_CAPA_ENC_WEP40;
472 break;
473 case RSN_CIPHER_SUITE_AES_128_CMAC:
474 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP;
475 break;
476 case RSN_CIPHER_SUITE_BIP_GMAC_128:
477 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_GMAC_128;
478 break;
479 case RSN_CIPHER_SUITE_BIP_GMAC_256:
480 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_GMAC_256;
481 break;
482 case RSN_CIPHER_SUITE_BIP_CMAC_256:
483 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_CMAC_256;
484 break;
485 case RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED:
486 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GTK_NOT_USED;
487 break;
488 }
489 }
490 }
491
492
wiphy_info_max_roc(struct wpa_driver_capa * capa,struct nlattr * tb)493 static void wiphy_info_max_roc(struct wpa_driver_capa *capa,
494 struct nlattr *tb)
495 {
496 if (tb)
497 capa->max_remain_on_chan = nla_get_u32(tb);
498 }
499
500
wiphy_info_tdls(struct wpa_driver_capa * capa,struct nlattr * tdls,struct nlattr * ext_setup)501 static void wiphy_info_tdls(struct wpa_driver_capa *capa, struct nlattr *tdls,
502 struct nlattr *ext_setup)
503 {
504 if (tdls == NULL)
505 return;
506
507 wpa_printf(MSG_DEBUG, "nl80211: TDLS supported");
508 capa->flags |= WPA_DRIVER_FLAGS_TDLS_SUPPORT;
509
510 if (ext_setup) {
511 wpa_printf(MSG_DEBUG, "nl80211: TDLS external setup");
512 capa->flags |= WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP;
513 }
514 }
515
516
ext_feature_isset(const u8 * ext_features,int ext_features_len,enum nl80211_ext_feature_index ftidx)517 static int ext_feature_isset(const u8 *ext_features, int ext_features_len,
518 enum nl80211_ext_feature_index ftidx)
519 {
520 u8 ft_byte;
521
522 if ((int) ftidx / 8 >= ext_features_len)
523 return 0;
524
525 ft_byte = ext_features[ftidx / 8];
526 return (ft_byte & BIT(ftidx % 8)) != 0;
527 }
528
529
wiphy_info_ext_feature_flags(struct wiphy_info_data * info,struct nlattr * tb)530 static void wiphy_info_ext_feature_flags(struct wiphy_info_data *info,
531 struct nlattr *tb)
532 {
533 struct wpa_driver_capa *capa = info->capa;
534 u8 *ext_features;
535 int len;
536
537 if (tb == NULL)
538 return;
539
540 ext_features = nla_data(tb);
541 len = nla_len(tb);
542
543 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_VHT_IBSS))
544 capa->flags |= WPA_DRIVER_FLAGS_VHT_IBSS;
545
546 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_RRM))
547 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_RRM;
548
549 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_FILS_STA))
550 capa->flags |= WPA_DRIVER_FLAGS_SUPPORT_FILS;
551
552 if (ext_feature_isset(ext_features, len,
553 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
554 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_LEGACY;
555
556 if (ext_feature_isset(ext_features, len,
557 NL80211_EXT_FEATURE_BEACON_RATE_HT))
558 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_HT;
559
560 if (ext_feature_isset(ext_features, len,
561 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
562 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_VHT;
563
564 if (ext_feature_isset(ext_features, len,
565 NL80211_EXT_FEATURE_BEACON_RATE_HE))
566 capa->flags2 |= WPA_DRIVER_FLAGS2_BEACON_RATE_HE;
567
568 if (ext_feature_isset(ext_features, len,
569 NL80211_EXT_FEATURE_SET_SCAN_DWELL))
570 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_SET_SCAN_DWELL;
571
572 if (ext_feature_isset(ext_features, len,
573 NL80211_EXT_FEATURE_SCAN_START_TIME) &&
574 ext_feature_isset(ext_features, len,
575 NL80211_EXT_FEATURE_BSS_PARENT_TSF) &&
576 ext_feature_isset(ext_features, len,
577 NL80211_EXT_FEATURE_SET_SCAN_DWELL))
578 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT;
579 if (ext_feature_isset(ext_features, len,
580 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA))
581 capa->flags |= WPA_DRIVER_FLAGS_MGMT_TX_RANDOM_TA;
582 if (ext_feature_isset(ext_features, len,
583 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED))
584 capa->flags |= WPA_DRIVER_FLAGS_MGMT_TX_RANDOM_TA_CONNECTED;
585 if (ext_feature_isset(ext_features, len,
586 NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI))
587 capa->flags |= WPA_DRIVER_FLAGS_SCHED_SCAN_RELATIVE_RSSI;
588 if (ext_feature_isset(ext_features, len,
589 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD))
590 capa->flags |= WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD;
591
592 if (ext_feature_isset(ext_features, len,
593 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
594 capa->flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK;
595 if (ext_feature_isset(ext_features, len,
596 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
597 capa->flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X;
598
599 if (ext_feature_isset(ext_features, len,
600 NL80211_EXT_FEATURE_SAE_OFFLOAD))
601 capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA;
602
603 if (ext_feature_isset(ext_features, len,
604 NL80211_EXT_FEATURE_MFP_OPTIONAL))
605 capa->flags |= WPA_DRIVER_FLAGS_MFP_OPTIONAL;
606
607 if (ext_feature_isset(ext_features, len,
608 NL80211_EXT_FEATURE_DFS_OFFLOAD))
609 capa->flags |= WPA_DRIVER_FLAGS_DFS_OFFLOAD;
610
611 #ifdef CONFIG_MBO
612 if (ext_feature_isset(ext_features, len,
613 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) &&
614 ext_feature_isset(ext_features, len,
615 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) &&
616 ext_feature_isset(ext_features, len,
617 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) &&
618 ext_feature_isset(
619 ext_features, len,
620 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION))
621 capa->flags |= WPA_DRIVER_FLAGS_OCE_STA;
622 #endif /* CONFIG_MBO */
623
624 if (ext_feature_isset(ext_features, len,
625 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
626 capa->flags |= WPA_DRIVER_FLAGS_FTM_RESPONDER;
627
628 if (ext_feature_isset(ext_features, len,
629 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
630 capa->flags |= WPA_DRIVER_FLAGS_CONTROL_PORT;
631 if (ext_feature_isset(ext_features, len,
632 NL80211_EXT_FEATURE_CONTROL_PORT_NO_PREAUTH))
633 capa->flags2 |= WPA_DRIVER_FLAGS2_CONTROL_PORT_RX;
634 if (ext_feature_isset(
635 ext_features, len,
636 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_TX_STATUS))
637 capa->flags2 |= WPA_DRIVER_FLAGS2_CONTROL_PORT_TX_STATUS;
638
639 if (ext_feature_isset(ext_features, len,
640 NL80211_EXT_FEATURE_VLAN_OFFLOAD))
641 capa->flags |= WPA_DRIVER_FLAGS_VLAN_OFFLOAD;
642
643 if (ext_feature_isset(ext_features, len,
644 NL80211_EXT_FEATURE_CAN_REPLACE_PTK0))
645 capa->flags |= WPA_DRIVER_FLAGS_SAFE_PTK0_REKEYS;
646
647 if (ext_feature_isset(ext_features, len,
648 NL80211_EXT_FEATURE_BEACON_PROTECTION))
649 capa->flags |= WPA_DRIVER_FLAGS_BEACON_PROTECTION;
650
651 if (ext_feature_isset(ext_features, len,
652 NL80211_EXT_FEATURE_EXT_KEY_ID))
653 capa->flags |= WPA_DRIVER_FLAGS_EXTENDED_KEY_ID;
654
655 if (ext_feature_isset(ext_features, len,
656 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS))
657 info->drv->multicast_registrations = 1;
658
659 if (ext_feature_isset(ext_features, len,
660 NL80211_EXT_FEATURE_FILS_DISCOVERY))
661 info->drv->fils_discovery = 1;
662
663 if (ext_feature_isset(ext_features, len,
664 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP))
665 info->drv->unsol_bcast_probe_resp = 1;
666
667 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_PUNCT))
668 info->drv->puncturing = 1;
669
670 if (ext_feature_isset(ext_features, len,
671 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT))
672 capa->flags2 |= WPA_DRIVER_FLAGS2_BEACON_PROTECTION_CLIENT;
673
674 if (ext_feature_isset(ext_features, len,
675 NL80211_EXT_FEATURE_OPERATING_CHANNEL_VALIDATION))
676 capa->flags2 |= WPA_DRIVER_FLAGS2_OCV;
677
678 if (ext_feature_isset(ext_features, len,
679 NL80211_EXT_FEATURE_RADAR_BACKGROUND))
680 capa->flags2 |= WPA_DRIVER_FLAGS2_RADAR_BACKGROUND;
681
682 if (ext_feature_isset(ext_features, len,
683 NL80211_EXT_FEATURE_SECURE_LTF)) {
684 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_STA;
685 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_AP;
686 }
687
688 if (ext_feature_isset(ext_features, len,
689 NL80211_EXT_FEATURE_SECURE_RTT)) {
690 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_STA;
691 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_AP;
692 }
693
694 if (ext_feature_isset(
695 ext_features, len,
696 NL80211_EXT_FEATURE_PROT_RANGE_NEGO_AND_MEASURE)) {
697 capa->flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_STA;
698 capa->flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_AP;
699 }
700
701 if (ext_feature_isset(ext_features, len,
702 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
703 capa->flags2 |= WPA_DRIVER_FLAGS2_SCAN_MIN_PREQ;
704
705 if (ext_feature_isset(ext_features, len,
706 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK))
707 capa->flags2 |= WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK;
708
709 if (ext_feature_isset(ext_features, len,
710 NL80211_EXT_FEATURE_OWE_OFFLOAD))
711 capa->flags2 |= WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA;
712
713 if (ext_feature_isset(ext_features, len,
714 NL80211_EXT_FEATURE_OWE_OFFLOAD_AP))
715 capa->flags2 |= WPA_DRIVER_FLAGS2_OWE_OFFLOAD_AP;
716
717 if (ext_feature_isset(ext_features, len,
718 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP))
719 capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP;
720
721 if (ext_feature_isset(ext_features, len,
722 NL80211_EXT_FEATURE_SPP_AMSDU_SUPPORT))
723 capa->flags2 |= WPA_DRIVER_FLAGS2_SPP_AMSDU;
724 }
725
726
wiphy_info_feature_flags(struct wiphy_info_data * info,struct nlattr * tb)727 static void wiphy_info_feature_flags(struct wiphy_info_data *info,
728 struct nlattr *tb)
729 {
730 u32 flags;
731 struct wpa_driver_capa *capa = info->capa;
732
733 if (tb == NULL)
734 return;
735
736 flags = nla_get_u32(tb);
737
738 if (flags & NL80211_FEATURE_SK_TX_STATUS)
739 info->data_tx_status = 1;
740
741 if (flags & NL80211_FEATURE_INACTIVITY_TIMER)
742 capa->flags |= WPA_DRIVER_FLAGS_INACTIVITY_TIMER;
743
744 if (flags & NL80211_FEATURE_SAE)
745 capa->flags |= WPA_DRIVER_FLAGS_SAE;
746
747 if (flags & NL80211_FEATURE_NEED_OBSS_SCAN)
748 capa->flags |= WPA_DRIVER_FLAGS_OBSS_SCAN;
749
750 if (flags & NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)
751 capa->flags |= WPA_DRIVER_FLAGS_HT_2040_COEX;
752
753 if (flags & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) {
754 wpa_printf(MSG_DEBUG, "nl80211: TDLS channel switch");
755 capa->flags |= WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH;
756 }
757
758 if (flags & NL80211_FEATURE_P2P_GO_CTWIN)
759 info->p2p_go_ctwindow_supported = 1;
760
761 if (flags & NL80211_FEATURE_LOW_PRIORITY_SCAN)
762 info->have_low_prio_scan = 1;
763
764 if (flags & NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)
765 info->mac_addr_rand_scan_supported = 1;
766
767 if (flags & NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR)
768 info->mac_addr_rand_sched_scan_supported = 1;
769
770 if (flags & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
771 info->wmm_ac_supported = 1;
772
773 if (flags & NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES)
774 capa->rrm_flags |= WPA_DRIVER_FLAGS_DS_PARAM_SET_IE_IN_PROBES;
775
776 if (flags & NL80211_FEATURE_WFA_TPC_IE_IN_PROBES)
777 capa->rrm_flags |= WPA_DRIVER_FLAGS_WFA_TPC_IE_IN_PROBES;
778
779 if (flags & NL80211_FEATURE_QUIET)
780 capa->rrm_flags |= WPA_DRIVER_FLAGS_QUIET;
781
782 if (flags & NL80211_FEATURE_TX_POWER_INSERTION)
783 capa->rrm_flags |= WPA_DRIVER_FLAGS_TX_POWER_INSERTION;
784
785 if (flags & NL80211_FEATURE_HT_IBSS)
786 capa->flags |= WPA_DRIVER_FLAGS_HT_IBSS;
787
788 if (flags & NL80211_FEATURE_FULL_AP_CLIENT_STATE)
789 capa->flags |= WPA_DRIVER_FLAGS_FULL_AP_CLIENT_STATE;
790 }
791
792
wiphy_info_probe_resp_offload(struct wpa_driver_capa * capa,struct nlattr * tb)793 static void wiphy_info_probe_resp_offload(struct wpa_driver_capa *capa,
794 struct nlattr *tb)
795 {
796 u32 protocols;
797
798 if (tb == NULL)
799 return;
800
801 protocols = nla_get_u32(tb);
802 wpa_printf(MSG_DEBUG, "nl80211: Supports Probe Response offload in AP "
803 "mode");
804 capa->flags |= WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD;
805 capa->probe_resp_offloads = probe_resp_offload_support(protocols);
806 }
807
808
wiphy_info_wowlan_triggers(struct wpa_driver_capa * capa,struct nlattr * tb)809 static void wiphy_info_wowlan_triggers(struct wpa_driver_capa *capa,
810 struct nlattr *tb)
811 {
812 struct nlattr *triggers[MAX_NL80211_WOWLAN_TRIG + 1];
813
814 if (tb == NULL)
815 return;
816
817 if (nla_parse_nested(triggers, MAX_NL80211_WOWLAN_TRIG,
818 tb, NULL))
819 return;
820
821 if (triggers[NL80211_WOWLAN_TRIG_ANY])
822 capa->wowlan_triggers.any = 1;
823 if (triggers[NL80211_WOWLAN_TRIG_DISCONNECT])
824 capa->wowlan_triggers.disconnect = 1;
825 if (triggers[NL80211_WOWLAN_TRIG_MAGIC_PKT])
826 capa->wowlan_triggers.magic_pkt = 1;
827 if (triggers[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
828 capa->wowlan_triggers.gtk_rekey_failure = 1;
829 if (triggers[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
830 capa->wowlan_triggers.eap_identity_req = 1;
831 if (triggers[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
832 capa->wowlan_triggers.four_way_handshake = 1;
833 if (triggers[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
834 capa->wowlan_triggers.rfkill_release = 1;
835 }
836
837
wiphy_info_extended_capab(struct wpa_driver_nl80211_data * drv,struct nlattr * tb)838 static void wiphy_info_extended_capab(struct wpa_driver_nl80211_data *drv,
839 struct nlattr *tb)
840 {
841 int rem = 0, i;
842 struct nlattr *tb1[NL80211_ATTR_MAX + 1], *attr;
843
844 if (!tb || drv->num_iface_capa == NL80211_IFTYPE_MAX)
845 return;
846
847 nla_for_each_nested(attr, tb, rem) {
848 unsigned int len;
849 struct drv_nl80211_iface_capa *capa;
850
851 nla_parse(tb1, NL80211_ATTR_MAX, nla_data(attr),
852 nla_len(attr), NULL);
853
854 if (!tb1[NL80211_ATTR_IFTYPE] ||
855 !tb1[NL80211_ATTR_EXT_CAPA] ||
856 !tb1[NL80211_ATTR_EXT_CAPA_MASK])
857 continue;
858
859 capa = &drv->iface_capa[drv->num_iface_capa];
860 capa->iftype = nla_get_u32(tb1[NL80211_ATTR_IFTYPE]);
861 wpa_printf(MSG_DEBUG,
862 "nl80211: Driver-advertised extended capabilities for interface type %s",
863 nl80211_iftype_str(capa->iftype));
864
865 len = nla_len(tb1[NL80211_ATTR_EXT_CAPA]);
866 capa->ext_capa = os_memdup(nla_data(tb1[NL80211_ATTR_EXT_CAPA]),
867 len);
868 if (!capa->ext_capa)
869 goto err;
870
871 capa->ext_capa_len = len;
872 wpa_hexdump(MSG_DEBUG, "nl80211: Extended capabilities",
873 capa->ext_capa, capa->ext_capa_len);
874
875 len = nla_len(tb1[NL80211_ATTR_EXT_CAPA_MASK]);
876 capa->ext_capa_mask =
877 os_memdup(nla_data(tb1[NL80211_ATTR_EXT_CAPA_MASK]),
878 len);
879 if (!capa->ext_capa_mask)
880 goto err;
881
882 wpa_hexdump(MSG_DEBUG, "nl80211: Extended capabilities mask",
883 capa->ext_capa_mask, capa->ext_capa_len);
884
885 if (tb1[NL80211_ATTR_EML_CAPABILITY] &&
886 tb1[NL80211_ATTR_MLD_CAPA_AND_OPS]) {
887 capa->eml_capa =
888 nla_get_u16(tb1[NL80211_ATTR_EML_CAPABILITY]);
889 capa->mld_capa_and_ops =
890 nla_get_u16(tb1[NL80211_ATTR_MLD_CAPA_AND_OPS]);
891 }
892
893 wpa_printf(MSG_DEBUG,
894 "nl80211: EML Capability: 0x%x MLD Capability: 0x%x",
895 capa->eml_capa, capa->mld_capa_and_ops);
896
897 drv->num_iface_capa++;
898 if (drv->num_iface_capa == NL80211_IFTYPE_MAX)
899 break;
900 }
901
902 return;
903
904 err:
905 /* Cleanup allocated memory on error */
906 for (i = 0; i < NL80211_IFTYPE_MAX; i++) {
907 os_free(drv->iface_capa[i].ext_capa);
908 drv->iface_capa[i].ext_capa = NULL;
909 os_free(drv->iface_capa[i].ext_capa_mask);
910 drv->iface_capa[i].ext_capa_mask = NULL;
911 drv->iface_capa[i].ext_capa_len = 0;
912 }
913 drv->num_iface_capa = 0;
914 }
915
916
wiphy_info_mbssid(struct wpa_driver_capa * cap,struct nlattr * attr)917 static void wiphy_info_mbssid(struct wpa_driver_capa *cap, struct nlattr *attr)
918 {
919 struct nlattr *config[NL80211_MBSSID_CONFIG_ATTR_MAX + 1];
920
921 if (nla_parse_nested(config, NL80211_MBSSID_CONFIG_ATTR_MAX, attr,
922 NULL))
923 return;
924
925 if (!config[NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES])
926 return;
927
928 cap->mbssid_max_interfaces =
929 nla_get_u8(config[NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES]);
930
931 if (config[NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY])
932 cap->ema_max_periodicity =
933 nla_get_u8(config[NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY]);
934
935 wpa_printf(MSG_DEBUG,
936 "mbssid: max interfaces %u, max profile periodicity %u",
937 cap->mbssid_max_interfaces, cap->ema_max_periodicity);
938 }
939
940
wiphy_info_handler(struct nl_msg * msg,void * arg)941 static int wiphy_info_handler(struct nl_msg *msg, void *arg)
942 {
943 struct nlattr *tb[NL80211_ATTR_MAX + 1];
944 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
945 struct wiphy_info_data *info = arg;
946 struct wpa_driver_capa *capa = info->capa;
947 struct wpa_driver_nl80211_data *drv = info->drv;
948
949 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
950 genlmsg_attrlen(gnlh, 0), NULL);
951
952 if (tb[NL80211_ATTR_WIPHY])
953 drv->wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
954
955 if (tb[NL80211_ATTR_WIPHY_NAME])
956 os_strlcpy(drv->phyname,
957 nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]),
958 sizeof(drv->phyname));
959 if (tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
960 capa->max_scan_ssids =
961 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]);
962
963 if (tb[NL80211_ATTR_MAX_SCAN_IE_LEN])
964 capa->max_probe_req_ie_len =
965 nla_get_u16(tb[NL80211_ATTR_MAX_SCAN_IE_LEN]);
966
967 if (tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS])
968 capa->max_sched_scan_ssids =
969 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS]);
970
971 if (tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS] &&
972 tb[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL] &&
973 tb[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS]) {
974 capa->max_sched_scan_plans =
975 nla_get_u32(tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS]);
976
977 capa->max_sched_scan_plan_interval =
978 nla_get_u32(tb[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL]);
979
980 capa->max_sched_scan_plan_iterations =
981 nla_get_u32(tb[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS]);
982 }
983
984 if (tb[NL80211_ATTR_MAX_MATCH_SETS])
985 capa->max_match_sets =
986 nla_get_u8(tb[NL80211_ATTR_MAX_MATCH_SETS]);
987
988 if (tb[NL80211_ATTR_MAC_ACL_MAX])
989 capa->max_acl_mac_addrs =
990 nla_get_u32(tb[NL80211_ATTR_MAC_ACL_MAX]);
991
992 wiphy_info_supported_iftypes(info, tb[NL80211_ATTR_SUPPORTED_IFTYPES]);
993 wiphy_info_iface_comb(info, tb[NL80211_ATTR_INTERFACE_COMBINATIONS]);
994 wiphy_info_supp_cmds(info, tb[NL80211_ATTR_SUPPORTED_COMMANDS]);
995 wiphy_info_cipher_suites(info, tb[NL80211_ATTR_CIPHER_SUITES]);
996 wiphy_info_akm_suites(info, tb[NL80211_ATTR_AKM_SUITES]);
997 wiphy_info_iftype_akm_suites(info, tb[NL80211_ATTR_IFTYPE_AKM_SUITES]);
998
999 if (tb[NL80211_ATTR_OFFCHANNEL_TX_OK]) {
1000 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based "
1001 "off-channel TX");
1002 capa->flags |= WPA_DRIVER_FLAGS_OFFCHANNEL_TX;
1003 }
1004
1005 if (tb[NL80211_ATTR_ROAM_SUPPORT]) {
1006 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based roaming");
1007 capa->flags |= WPA_DRIVER_FLAGS_BSS_SELECTION;
1008 }
1009
1010 wiphy_info_max_roc(capa,
1011 tb[NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION]);
1012
1013 if (tb[NL80211_ATTR_SUPPORT_AP_UAPSD])
1014 capa->flags |= WPA_DRIVER_FLAGS_AP_UAPSD;
1015
1016 wiphy_info_tdls(capa, tb[NL80211_ATTR_TDLS_SUPPORT],
1017 tb[NL80211_ATTR_TDLS_EXTERNAL_SETUP]);
1018
1019 if (tb[NL80211_ATTR_DEVICE_AP_SME]) {
1020 u32 ap_sme_features_flags =
1021 nla_get_u32(tb[NL80211_ATTR_DEVICE_AP_SME]);
1022
1023 if (ap_sme_features_flags & NL80211_AP_SME_SA_QUERY_OFFLOAD)
1024 capa->flags2 |= WPA_DRIVER_FLAGS2_SA_QUERY_OFFLOAD_AP;
1025
1026 info->device_ap_sme = 1;
1027 }
1028
1029 wiphy_info_feature_flags(info, tb[NL80211_ATTR_FEATURE_FLAGS]);
1030 wiphy_info_ext_feature_flags(info, tb[NL80211_ATTR_EXT_FEATURES]);
1031 wiphy_info_probe_resp_offload(capa,
1032 tb[NL80211_ATTR_PROBE_RESP_OFFLOAD]);
1033
1034 if (tb[NL80211_ATTR_EXT_CAPA] && tb[NL80211_ATTR_EXT_CAPA_MASK] &&
1035 drv->extended_capa == NULL) {
1036 drv->extended_capa =
1037 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA]));
1038 if (drv->extended_capa) {
1039 os_memcpy(drv->extended_capa,
1040 nla_data(tb[NL80211_ATTR_EXT_CAPA]),
1041 nla_len(tb[NL80211_ATTR_EXT_CAPA]));
1042 drv->extended_capa_len =
1043 nla_len(tb[NL80211_ATTR_EXT_CAPA]);
1044 wpa_hexdump(MSG_DEBUG,
1045 "nl80211: Driver-advertised extended capabilities (default)",
1046 drv->extended_capa, drv->extended_capa_len);
1047 }
1048 drv->extended_capa_mask =
1049 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA_MASK]));
1050 if (drv->extended_capa_mask) {
1051 os_memcpy(drv->extended_capa_mask,
1052 nla_data(tb[NL80211_ATTR_EXT_CAPA_MASK]),
1053 nla_len(tb[NL80211_ATTR_EXT_CAPA_MASK]));
1054 wpa_hexdump(MSG_DEBUG,
1055 "nl80211: Driver-advertised extended capabilities mask (default)",
1056 drv->extended_capa_mask,
1057 drv->extended_capa_len);
1058 } else {
1059 os_free(drv->extended_capa);
1060 drv->extended_capa = NULL;
1061 drv->extended_capa_len = 0;
1062 }
1063 }
1064
1065 wiphy_info_extended_capab(drv, tb[NL80211_ATTR_IFTYPE_EXT_CAPA]);
1066
1067 if (tb[NL80211_ATTR_VENDOR_DATA]) {
1068 struct nlattr *nl;
1069 int rem;
1070
1071 nla_for_each_nested(nl, tb[NL80211_ATTR_VENDOR_DATA], rem) {
1072 struct nl80211_vendor_cmd_info *vinfo;
1073 if (nla_len(nl) != sizeof(*vinfo)) {
1074 wpa_printf(MSG_DEBUG, "nl80211: Unexpected vendor data info");
1075 continue;
1076 }
1077 vinfo = nla_data(nl);
1078 if (vinfo->vendor_id == OUI_QCA) {
1079 switch (vinfo->subcmd) {
1080 case QCA_NL80211_VENDOR_SUBCMD_TEST:
1081 drv->vendor_cmd_test_avail = 1;
1082 break;
1083 #ifdef CONFIG_DRIVER_NL80211_QCA
1084 case QCA_NL80211_VENDOR_SUBCMD_ROAMING:
1085 drv->roaming_vendor_cmd_avail = 1;
1086 break;
1087 case QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY:
1088 drv->dfs_vendor_cmd_avail = 1;
1089 break;
1090 case QCA_NL80211_VENDOR_SUBCMD_GET_FEATURES:
1091 drv->get_features_vendor_cmd_avail = 1;
1092 break;
1093 case QCA_NL80211_VENDOR_SUBCMD_GET_PREFERRED_FREQ_LIST:
1094 drv->get_pref_freq_list = 1;
1095 break;
1096 case QCA_NL80211_VENDOR_SUBCMD_SET_PROBABLE_OPER_CHANNEL:
1097 drv->set_prob_oper_freq = 1;
1098 break;
1099 case QCA_NL80211_VENDOR_SUBCMD_DO_ACS:
1100 drv->capa.flags |=
1101 WPA_DRIVER_FLAGS_ACS_OFFLOAD;
1102 drv->qca_do_acs = 1;
1103 break;
1104 case QCA_NL80211_VENDOR_SUBCMD_SETBAND:
1105 drv->setband_vendor_cmd_avail = 1;
1106 break;
1107 case QCA_NL80211_VENDOR_SUBCMD_TRIGGER_SCAN:
1108 drv->scan_vendor_cmd_avail = 1;
1109 break;
1110 case QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION:
1111 drv->set_wifi_conf_vendor_cmd_avail = 1;
1112 break;
1113 case QCA_NL80211_VENDOR_SUBCMD_FETCH_BSS_TRANSITION_STATUS:
1114 drv->fetch_bss_trans_status = 1;
1115 break;
1116 case QCA_NL80211_VENDOR_SUBCMD_ROAM:
1117 drv->roam_vendor_cmd_avail = 1;
1118 break;
1119 case QCA_NL80211_VENDOR_SUBCMD_ADD_STA_NODE:
1120 drv->add_sta_node_vendor_cmd_avail = 1;
1121 break;
1122 case QCA_NL80211_VENDOR_SUBCMD_GET_STA_INFO:
1123 drv->get_sta_info_vendor_cmd_avail = 1;
1124 break;
1125 case QCA_NL80211_VENDOR_SUBCMD_SECURE_RANGING_CONTEXT:
1126 drv->secure_ranging_ctx_vendor_cmd_avail = 1;
1127 break;
1128 case QCA_NL80211_VENDOR_SUBCMD_CONNECT_EXT:
1129 drv->connect_ext_vendor_cmd_avail = 1;
1130 break;
1131 #endif /* CONFIG_DRIVER_NL80211_QCA */
1132 }
1133 #ifdef CONFIG_DRIVER_NL80211_BRCM
1134 } else if (vinfo->vendor_id == OUI_BRCM) {
1135 switch (vinfo->subcmd) {
1136 case BRCM_VENDOR_SCMD_ACS:
1137 drv->capa.flags |=
1138 WPA_DRIVER_FLAGS_ACS_OFFLOAD;
1139 wpa_printf(MSG_DEBUG,
1140 "Enabled BRCM ACS");
1141 drv->brcm_do_acs = 1;
1142 break;
1143 }
1144 #endif /* CONFIG_DRIVER_NL80211_BRCM */
1145 }
1146
1147 wpa_printf(MSG_DEBUG, "nl80211: Supported vendor command: vendor_id=0x%x subcmd=%u",
1148 vinfo->vendor_id, vinfo->subcmd);
1149 }
1150 }
1151
1152 if (tb[NL80211_ATTR_VENDOR_EVENTS]) {
1153 struct nlattr *nl;
1154 int rem;
1155
1156 nla_for_each_nested(nl, tb[NL80211_ATTR_VENDOR_EVENTS], rem) {
1157 struct nl80211_vendor_cmd_info *vinfo;
1158 if (nla_len(nl) != sizeof(*vinfo)) {
1159 wpa_printf(MSG_DEBUG, "nl80211: Unexpected vendor data info");
1160 continue;
1161 }
1162 vinfo = nla_data(nl);
1163 wpa_printf(MSG_DEBUG, "nl80211: Supported vendor event: vendor_id=0x%x subcmd=%u",
1164 vinfo->vendor_id, vinfo->subcmd);
1165 }
1166 }
1167
1168 wiphy_info_wowlan_triggers(capa,
1169 tb[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED]);
1170
1171 if (tb[NL80211_ATTR_MAX_AP_ASSOC_STA])
1172 capa->max_stations =
1173 nla_get_u32(tb[NL80211_ATTR_MAX_AP_ASSOC_STA]);
1174
1175 if (tb[NL80211_ATTR_MAX_CSA_COUNTERS])
1176 capa->max_csa_counters =
1177 nla_get_u8(tb[NL80211_ATTR_MAX_CSA_COUNTERS]);
1178
1179 if (tb[NL80211_ATTR_WIPHY_SELF_MANAGED_REG])
1180 capa->flags |= WPA_DRIVER_FLAGS_SELF_MANAGED_REGULATORY;
1181
1182 if (tb[NL80211_ATTR_MAX_NUM_AKM_SUITES])
1183 capa->max_num_akms =
1184 nla_get_u16(tb[NL80211_ATTR_MAX_NUM_AKM_SUITES]);
1185
1186 if (tb[NL80211_ATTR_MBSSID_CONFIG])
1187 wiphy_info_mbssid(capa, tb[NL80211_ATTR_MBSSID_CONFIG]);
1188
1189 if (tb[NL80211_ATTR_MLO_SUPPORT])
1190 capa->flags2 |= WPA_DRIVER_FLAGS2_MLO;
1191
1192 return NL_SKIP;
1193 }
1194
1195
wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data * drv,struct wiphy_info_data * info)1196 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
1197 struct wiphy_info_data *info)
1198 {
1199 u32 feat;
1200 struct nl_msg *msg;
1201 int flags = 0;
1202
1203 os_memset(info, 0, sizeof(*info));
1204 info->capa = &drv->capa;
1205 info->drv = drv;
1206
1207 /* Default to large buffer of extra IE(s) to maintain previous behavior
1208 * if the driver does not support reporting an accurate limit. */
1209 info->capa->max_probe_req_ie_len = 1500;
1210
1211 feat = get_nl80211_protocol_features(drv);
1212 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
1213 flags = NLM_F_DUMP;
1214 msg = nl80211_cmd_msg(drv->first_bss, flags, NL80211_CMD_GET_WIPHY);
1215 if (!msg || nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
1216 nlmsg_free(msg);
1217 return -1;
1218 }
1219
1220 if (send_and_recv_resp(drv, msg, wiphy_info_handler, info))
1221 return -1;
1222
1223 if (info->auth_supported)
1224 drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
1225 else if (!info->connect_supported) {
1226 wpa_printf(MSG_INFO, "nl80211: Driver does not support "
1227 "authentication/association or connect commands");
1228 info->error = 1;
1229 }
1230
1231 if (info->p2p_go_supported && info->p2p_client_supported)
1232 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE;
1233 if (info->p2p_concurrent) {
1234 wpa_printf(MSG_DEBUG, "nl80211: Use separate P2P group "
1235 "interface (driver advertised support)");
1236 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
1237 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
1238 }
1239 if (info->num_multichan_concurrent > 1) {
1240 wpa_printf(MSG_DEBUG, "nl80211: Enable multi-channel "
1241 "concurrent (driver advertised support)");
1242 drv->capa.num_multichan_concurrent =
1243 info->num_multichan_concurrent;
1244 }
1245 if (drv->capa.flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
1246 wpa_printf(MSG_DEBUG, "nl80211: use P2P_DEVICE support");
1247
1248 /* default to 5000 since early versions of mac80211 don't set it */
1249 if (!drv->capa.max_remain_on_chan)
1250 drv->capa.max_remain_on_chan = 5000;
1251
1252 drv->capa.wmm_ac_supported = info->wmm_ac_supported;
1253
1254 drv->capa.mac_addr_rand_sched_scan_supported =
1255 info->mac_addr_rand_sched_scan_supported;
1256 drv->capa.mac_addr_rand_scan_supported =
1257 info->mac_addr_rand_scan_supported;
1258
1259 if (info->channel_switch_supported) {
1260 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_CSA;
1261 if (!drv->capa.max_csa_counters)
1262 drv->capa.max_csa_counters = 1;
1263 }
1264
1265 if (!drv->capa.max_sched_scan_plans) {
1266 drv->capa.max_sched_scan_plans = 1;
1267 drv->capa.max_sched_scan_plan_interval = UINT32_MAX;
1268 drv->capa.max_sched_scan_plan_iterations = 0;
1269 }
1270
1271 if (info->update_ft_ies_supported)
1272 drv->capa.flags |= WPA_DRIVER_FLAGS_UPDATE_FT_IES;
1273
1274 if (!drv->capa.max_num_akms)
1275 drv->capa.max_num_akms = NL80211_MAX_NR_AKM_SUITES;
1276
1277 return 0;
1278 }
1279
1280
1281 #ifdef CONFIG_DRIVER_NL80211_QCA
1282
dfs_info_handler(struct nl_msg * msg,void * arg)1283 static int dfs_info_handler(struct nl_msg *msg, void *arg)
1284 {
1285 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1286 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1287 int *dfs_capability_ptr = arg;
1288
1289 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1290 genlmsg_attrlen(gnlh, 0), NULL);
1291
1292 if (tb[NL80211_ATTR_VENDOR_DATA]) {
1293 struct nlattr *nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
1294 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
1295
1296 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
1297 nla_data(nl_vend), nla_len(nl_vend), NULL);
1298
1299 if (tb_vendor[QCA_WLAN_VENDOR_ATTR_DFS]) {
1300 u32 val;
1301 val = nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_DFS]);
1302 wpa_printf(MSG_DEBUG, "nl80211: DFS offload capability: %u",
1303 val);
1304 *dfs_capability_ptr = val;
1305 }
1306 }
1307
1308 return NL_SKIP;
1309 }
1310
1311
qca_nl80211_check_dfs_capa(struct wpa_driver_nl80211_data * drv)1312 static void qca_nl80211_check_dfs_capa(struct wpa_driver_nl80211_data *drv)
1313 {
1314 struct nl_msg *msg;
1315 int dfs_capability = 0;
1316 int ret;
1317
1318 if (!drv->dfs_vendor_cmd_avail)
1319 return;
1320
1321 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
1322 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
1323 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
1324 QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY)) {
1325 nlmsg_free(msg);
1326 return;
1327 }
1328
1329 ret = send_and_recv_resp(drv, msg, dfs_info_handler, &dfs_capability);
1330 if (!ret && dfs_capability)
1331 drv->capa.flags |= WPA_DRIVER_FLAGS_DFS_OFFLOAD;
1332 }
1333
1334
1335 struct features_info {
1336 u8 *flags;
1337 size_t flags_len;
1338 struct wpa_driver_capa *capa;
1339 };
1340
1341
features_info_handler(struct nl_msg * msg,void * arg)1342 static int features_info_handler(struct nl_msg *msg, void *arg)
1343 {
1344 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1345 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1346 struct features_info *info = arg;
1347 struct nlattr *nl_vend, *attr;
1348
1349 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1350 genlmsg_attrlen(gnlh, 0), NULL);
1351
1352 nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
1353 if (nl_vend) {
1354 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
1355
1356 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
1357 nla_data(nl_vend), nla_len(nl_vend), NULL);
1358
1359 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_FLAGS];
1360 if (attr) {
1361 int len = nla_len(attr);
1362 info->flags = os_malloc(len);
1363 if (info->flags != NULL) {
1364 os_memcpy(info->flags, nla_data(attr), len);
1365 info->flags_len = len;
1366 }
1367 }
1368 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_CONCURRENCY_CAPA];
1369 if (attr)
1370 info->capa->conc_capab = nla_get_u32(attr);
1371
1372 attr = tb_vendor[
1373 QCA_WLAN_VENDOR_ATTR_MAX_CONCURRENT_CHANNELS_2_4_BAND];
1374 if (attr)
1375 info->capa->max_conc_chan_2_4 = nla_get_u32(attr);
1376
1377 attr = tb_vendor[
1378 QCA_WLAN_VENDOR_ATTR_MAX_CONCURRENT_CHANNELS_5_0_BAND];
1379 if (attr)
1380 info->capa->max_conc_chan_5_0 = nla_get_u32(attr);
1381 }
1382
1383 return NL_SKIP;
1384 }
1385
1386
check_feature(enum qca_wlan_vendor_features feature,struct features_info * info)1387 static int check_feature(enum qca_wlan_vendor_features feature,
1388 struct features_info *info)
1389 {
1390 size_t idx = feature / 8;
1391
1392 return (idx < info->flags_len) &&
1393 (info->flags[idx] & BIT(feature % 8));
1394 }
1395
1396
qca_nl80211_get_features(struct wpa_driver_nl80211_data * drv)1397 static void qca_nl80211_get_features(struct wpa_driver_nl80211_data *drv)
1398 {
1399 struct nl_msg *msg;
1400 struct features_info info;
1401 int ret;
1402
1403 if (!drv->get_features_vendor_cmd_avail)
1404 return;
1405
1406 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
1407 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
1408 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
1409 QCA_NL80211_VENDOR_SUBCMD_GET_FEATURES)) {
1410 nlmsg_free(msg);
1411 return;
1412 }
1413
1414 os_memset(&info, 0, sizeof(info));
1415 info.capa = &drv->capa;
1416 ret = send_and_recv_resp(drv, msg, features_info_handler, &info);
1417 if (ret || !info.flags)
1418 return;
1419
1420 if (check_feature(QCA_WLAN_VENDOR_FEATURE_KEY_MGMT_OFFLOAD, &info))
1421 drv->capa.flags |= WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD;
1422
1423 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SUPPORT_HW_MODE_ANY, &info))
1424 drv->capa.flags |= WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY;
1425
1426 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OFFCHANNEL_SIMULTANEOUS,
1427 &info))
1428 drv->capa.flags |= WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS;
1429 if (check_feature(QCA_WLAN_VENDOR_FEATURE_P2P_LISTEN_OFFLOAD, &info))
1430 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD;
1431 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_STA, &info))
1432 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_STA;
1433 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_AP, &info))
1434 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_AP;
1435 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_STA_CFON, &info))
1436 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_STA_CFON;
1437 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_LTF_STA, &info))
1438 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_STA;
1439 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_LTF_AP, &info))
1440 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_AP;
1441 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_RTT_STA, &info))
1442 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_STA;
1443 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_RTT_AP, &info))
1444 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_AP;
1445 if (check_feature(
1446 QCA_WLAN_VENDOR_FEATURE_PROT_RANGE_NEGO_AND_MEASURE_STA,
1447 &info))
1448 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_STA;
1449 if (check_feature(
1450 QCA_WLAN_VENDOR_FEATURE_PROT_RANGE_NEGO_AND_MEASURE_AP,
1451 &info))
1452 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_AP;
1453 if (check_feature(QCA_WLAN_VENDOR_FEATURE_AP_ALLOWED_FREQ_LIST,
1454 &info))
1455 drv->qca_ap_allowed_freqs = 1;
1456 if (check_feature(QCA_WLAN_VENDOR_FEATURE_HT_VHT_TWT_RESPONDER, &info))
1457 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_HT_VHT_TWT_RESPONDER;
1458 if (check_feature(QCA_WLAN_VENDOR_FEATURE_RSN_OVERRIDE_STA, &info)) {
1459 wpa_printf(MSG_DEBUG,
1460 "The driver supports RSN overriding in STA mode");
1461 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_RSN_OVERRIDE_STA;
1462 }
1463 if (check_feature(QCA_WLAN_VENDOR_FEATURE_NAN_USD_OFFLOAD, &info))
1464 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_NAN_OFFLOAD;
1465
1466 if (!check_feature(QCA_WLAN_VENDOR_FEATURE_P2P_V2, &info))
1467 drv->capa.flags2 &= ~WPA_DRIVER_FLAGS2_P2P_FEATURE_V2;
1468
1469 if (!check_feature(QCA_WLAN_VENDOR_FEATURE_PCC_MODE, &info))
1470 drv->capa.flags2 &= ~WPA_DRIVER_FLAGS2_P2P_FEATURE_PCC_MODE;
1471
1472 os_free(info.flags);
1473 }
1474
1475 #endif /* CONFIG_DRIVER_NL80211_QCA */
1476
1477
wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data * drv)1478 int wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
1479 {
1480 struct wiphy_info_data info;
1481 int i;
1482
1483 if (wpa_driver_nl80211_get_info(drv, &info))
1484 return -1;
1485
1486 if (info.error)
1487 return -1;
1488
1489 drv->has_capability = 1;
1490 drv->has_driver_key_mgmt = info.has_key_mgmt | info.has_key_mgmt_iftype;
1491
1492 /* Fallback to hardcoded defaults if the driver does not advertise any
1493 * AKM capabilities. */
1494 if (!drv->has_driver_key_mgmt) {
1495 drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1496 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
1497 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
1498 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK |
1499 WPA_DRIVER_CAPA_KEY_MGMT_PSK_SHA256 |
1500 WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B |
1501 WPA_DRIVER_CAPA_KEY_MGMT_OWE |
1502 WPA_DRIVER_CAPA_KEY_MGMT_DPP;
1503
1504 if (drv->capa.enc & (WPA_DRIVER_CAPA_ENC_CCMP_256 |
1505 WPA_DRIVER_CAPA_ENC_GCMP_256))
1506 drv->capa.key_mgmt |=
1507 WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192;
1508
1509 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME)
1510 drv->capa.key_mgmt |=
1511 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256 |
1512 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384 |
1513 WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA256 |
1514 WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA384 |
1515 WPA_DRIVER_CAPA_KEY_MGMT_SAE_EXT_KEY |
1516 WPA_DRIVER_CAPA_KEY_MGMT_SAE;
1517 else if (drv->capa.flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD)
1518 drv->capa.key_mgmt |=
1519 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256 |
1520 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384;
1521 }
1522
1523 if (!info.has_key_mgmt_iftype) {
1524 /* If the driver does not advertize per interface AKM
1525 * capabilities, consider all interfaces to support default AKMs
1526 * in key_mgmt. */
1527 for (i = 0; i < WPA_IF_MAX; i++)
1528 drv->capa.key_mgmt_iftype[i] = drv->capa.key_mgmt;
1529 } else if (info.has_key_mgmt_iftype && !info.has_key_mgmt) {
1530 /* If the driver advertizes only per interface supported AKMs
1531 * but does not advertize per wiphy AKM capabilities, consider
1532 * the default key_mgmt as a mask of per interface supported
1533 * AKMs. */
1534 drv->capa.key_mgmt = 0;
1535 for (i = 0; i < WPA_IF_MAX; i++)
1536 drv->capa.key_mgmt |= drv->capa.key_mgmt_iftype[i];
1537 } else if (info.has_key_mgmt_iftype && info.has_key_mgmt) {
1538 /* If the driver advertizes AKM capabilities both per wiphy and
1539 * per interface, consider the interfaces for which per
1540 * interface AKM capabilities were not received to support the
1541 * default key_mgmt capabilities.
1542 */
1543 for (i = 0; i < WPA_IF_MAX; i++)
1544 if (!drv->capa.key_mgmt_iftype[i])
1545 drv->capa.key_mgmt_iftype[i] =
1546 drv->capa.key_mgmt;
1547 }
1548
1549 drv->capa.auth = WPA_DRIVER_AUTH_OPEN |
1550 WPA_DRIVER_AUTH_SHARED |
1551 WPA_DRIVER_AUTH_LEAP;
1552
1553 drv->capa.flags |= WPA_DRIVER_FLAGS_VALID_ERROR_CODES;
1554 drv->capa.flags |= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE;
1555 drv->capa.flags |= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
1556
1557 /*
1558 * As all cfg80211 drivers must support cases where the AP interface is
1559 * removed without the knowledge of wpa_supplicant/hostapd, e.g., in
1560 * case that the user space daemon has crashed, they must be able to
1561 * cleanup all stations and key entries in the AP tear down flow. Thus,
1562 * this flag can/should always be set for cfg80211 drivers.
1563 */
1564 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT;
1565
1566 if (!info.device_ap_sme) {
1567 drv->capa.flags |= WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS;
1568 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_AP_SME;
1569
1570 /*
1571 * No AP SME is currently assumed to also indicate no AP MLME
1572 * in the driver/firmware.
1573 */
1574 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_MLME;
1575 }
1576
1577 drv->device_ap_sme = info.device_ap_sme;
1578 drv->poll_command_supported = info.poll_command_supported;
1579 drv->data_tx_status = info.data_tx_status;
1580 drv->p2p_go_ctwindow_supported = info.p2p_go_ctwindow_supported;
1581 if (info.set_qos_map_supported)
1582 drv->capa.flags |= WPA_DRIVER_FLAGS_QOS_MAPPING;
1583 drv->have_low_prio_scan = info.have_low_prio_scan;
1584
1585 /*
1586 * If the driver doesn't support data TX status, we won't get TX
1587 * status for EAPOL frames.
1588 */
1589 if (!info.data_tx_status)
1590 drv->capa.flags &= ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
1591
1592 /* Enable P2P2 and PCC mode capabilities by default for the drivers
1593 * which can't explicitly indicate whether these capabilities are
1594 * supported. */
1595 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_P2P_FEATURE_V2;
1596 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_P2P_FEATURE_PCC_MODE;
1597
1598 #ifdef CONFIG_DRIVER_NL80211_QCA
1599 if (!(info.capa->flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD))
1600 qca_nl80211_check_dfs_capa(drv);
1601 qca_nl80211_get_features(drv);
1602
1603 /*
1604 * To enable offchannel simultaneous support in wpa_supplicant, the
1605 * underlying driver needs to support the same along with offchannel TX.
1606 * Offchannel TX support is needed since remain_on_channel and
1607 * action_tx use some common data structures and hence cannot be
1608 * scheduled simultaneously.
1609 */
1610 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX))
1611 drv->capa.flags &= ~WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS;
1612 #endif /* CONFIG_DRIVER_NL80211_QCA */
1613
1614 wpa_printf(MSG_DEBUG,
1615 "nl80211: key_mgmt=0x%x enc=0x%x auth=0x%x flags=0x%llx flags2=0x%llx rrm_flags=0x%x probe_resp_offloads=0x%x max_stations=%u max_remain_on_chan=%u max_scan_ssids=%d",
1616 drv->capa.key_mgmt, drv->capa.enc, drv->capa.auth,
1617 (unsigned long long) drv->capa.flags,
1618 (unsigned long long) drv->capa.flags2, drv->capa.rrm_flags,
1619 drv->capa.probe_resp_offloads, drv->capa.max_stations,
1620 drv->capa.max_remain_on_chan, drv->capa.max_scan_ssids);
1621 return 0;
1622 }
1623
1624
1625 struct phy_info_arg {
1626 u16 *num_modes;
1627 struct hostapd_hw_modes *modes;
1628 int last_mode, last_chan_idx;
1629 int failed;
1630 u8 dfs_domain;
1631 };
1632
phy_info_ht_capa(struct hostapd_hw_modes * mode,struct nlattr * capa,struct nlattr * ampdu_factor,struct nlattr * ampdu_density,struct nlattr * mcs_set)1633 static void phy_info_ht_capa(struct hostapd_hw_modes *mode, struct nlattr *capa,
1634 struct nlattr *ampdu_factor,
1635 struct nlattr *ampdu_density,
1636 struct nlattr *mcs_set)
1637 {
1638 if (capa)
1639 mode->ht_capab = nla_get_u16(capa);
1640
1641 if (ampdu_factor)
1642 mode->a_mpdu_params |= nla_get_u8(ampdu_factor) & 0x03;
1643
1644 if (ampdu_density)
1645 mode->a_mpdu_params |= nla_get_u8(ampdu_density) << 2;
1646
1647 if (mcs_set && nla_len(mcs_set) >= 16) {
1648 u8 *mcs;
1649 mcs = nla_data(mcs_set);
1650 os_memcpy(mode->mcs_set, mcs, 16);
1651 }
1652 }
1653
1654
phy_info_vht_capa(struct hostapd_hw_modes * mode,struct nlattr * capa,struct nlattr * mcs_set)1655 static void phy_info_vht_capa(struct hostapd_hw_modes *mode,
1656 struct nlattr *capa,
1657 struct nlattr *mcs_set)
1658 {
1659 if (capa)
1660 mode->vht_capab = nla_get_u32(capa);
1661
1662 if (mcs_set && nla_len(mcs_set) >= 8) {
1663 u8 *mcs;
1664 mcs = nla_data(mcs_set);
1665 os_memcpy(mode->vht_mcs_set, mcs, 8);
1666 }
1667 }
1668
1669
phy_info_edmg_capa(struct hostapd_hw_modes * mode,struct nlattr * bw_config,struct nlattr * channels)1670 static int phy_info_edmg_capa(struct hostapd_hw_modes *mode,
1671 struct nlattr *bw_config,
1672 struct nlattr *channels)
1673 {
1674 if (!bw_config || !channels)
1675 return NL_OK;
1676
1677 mode->edmg.bw_config = nla_get_u8(bw_config);
1678 mode->edmg.channels = nla_get_u8(channels);
1679
1680 if (!mode->edmg.channels || !mode->edmg.bw_config)
1681 return NL_STOP;
1682
1683 return NL_OK;
1684 }
1685
1686
cw2ecw(unsigned int cw)1687 static int cw2ecw(unsigned int cw)
1688 {
1689 int bit;
1690
1691 if (cw == 0)
1692 return 0;
1693
1694 for (bit = 1; cw != 1; bit++)
1695 cw >>= 1;
1696
1697 return bit;
1698 }
1699
1700
phy_info_freq(struct hostapd_hw_modes * mode,struct hostapd_channel_data * chan,struct nlattr * tb_freq[])1701 static void phy_info_freq(struct hostapd_hw_modes *mode,
1702 struct hostapd_channel_data *chan,
1703 struct nlattr *tb_freq[])
1704 {
1705 u8 channel;
1706
1707 os_memset(chan, 0, sizeof(*chan));
1708 chan->freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
1709 chan->flag = 0;
1710 chan->allowed_bw = ~0;
1711 chan->dfs_cac_ms = 0;
1712 if (ieee80211_freq_to_chan(chan->freq, &channel) != NUM_HOSTAPD_MODES)
1713 chan->chan = channel;
1714 else
1715 wpa_printf(MSG_DEBUG,
1716 "nl80211: No channel number found for frequency %u MHz",
1717 chan->freq);
1718
1719 if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED])
1720 chan->flag |= HOSTAPD_CHAN_DISABLED;
1721 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR])
1722 chan->flag |= HOSTAPD_CHAN_NO_IR;
1723 if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR])
1724 chan->flag |= HOSTAPD_CHAN_RADAR;
1725 if (tb_freq[NL80211_FREQUENCY_ATTR_INDOOR_ONLY])
1726 chan->flag |= HOSTAPD_CHAN_INDOOR_ONLY;
1727 if (tb_freq[NL80211_FREQUENCY_ATTR_GO_CONCURRENT])
1728 chan->flag |= HOSTAPD_CHAN_GO_CONCURRENT;
1729
1730 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_10MHZ])
1731 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_10;
1732 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_20MHZ])
1733 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_20;
1734 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_HT40_PLUS])
1735 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_40P;
1736 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_HT40_MINUS])
1737 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_40M;
1738 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_80MHZ])
1739 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_80;
1740 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_160MHZ])
1741 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_160;
1742 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_320MHZ])
1743 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_320;
1744
1745 if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]) {
1746 enum nl80211_dfs_state state =
1747 nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]);
1748
1749 switch (state) {
1750 case NL80211_DFS_USABLE:
1751 chan->flag |= HOSTAPD_CHAN_DFS_USABLE;
1752 break;
1753 case NL80211_DFS_AVAILABLE:
1754 chan->flag |= HOSTAPD_CHAN_DFS_AVAILABLE;
1755 break;
1756 case NL80211_DFS_UNAVAILABLE:
1757 chan->flag |= HOSTAPD_CHAN_DFS_UNAVAILABLE;
1758 break;
1759 }
1760 }
1761
1762 if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME]) {
1763 chan->dfs_cac_ms = nla_get_u32(
1764 tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME]);
1765 }
1766
1767 chan->wmm_rules_valid = 0;
1768 if (tb_freq[NL80211_FREQUENCY_ATTR_WMM]) {
1769 static struct nla_policy wmm_policy[NL80211_WMMR_MAX + 1] = {
1770 [NL80211_WMMR_CW_MIN] = { .type = NLA_U16 },
1771 [NL80211_WMMR_CW_MAX] = { .type = NLA_U16 },
1772 [NL80211_WMMR_AIFSN] = { .type = NLA_U8 },
1773 [NL80211_WMMR_TXOP] = { .type = NLA_U16 },
1774 };
1775 static const u8 wmm_map[4] = {
1776 [NL80211_AC_BE] = WMM_AC_BE,
1777 [NL80211_AC_BK] = WMM_AC_BK,
1778 [NL80211_AC_VI] = WMM_AC_VI,
1779 [NL80211_AC_VO] = WMM_AC_VO,
1780 };
1781 struct nlattr *nl_wmm;
1782 struct nlattr *tb_wmm[NL80211_WMMR_MAX + 1];
1783 int rem_wmm, ac, count = 0;
1784
1785 nla_for_each_nested(nl_wmm, tb_freq[NL80211_FREQUENCY_ATTR_WMM],
1786 rem_wmm) {
1787 if (nla_parse_nested(tb_wmm, NL80211_WMMR_MAX, nl_wmm,
1788 wmm_policy)) {
1789 wpa_printf(MSG_DEBUG,
1790 "nl80211: Failed to parse WMM rules attribute");
1791 return;
1792 }
1793 if (!tb_wmm[NL80211_WMMR_CW_MIN] ||
1794 !tb_wmm[NL80211_WMMR_CW_MAX] ||
1795 !tb_wmm[NL80211_WMMR_AIFSN] ||
1796 !tb_wmm[NL80211_WMMR_TXOP]) {
1797 wpa_printf(MSG_DEBUG,
1798 "nl80211: Channel is missing WMM rule attribute");
1799 return;
1800 }
1801 ac = nl_wmm->nla_type;
1802 if ((unsigned int) ac >= ARRAY_SIZE(wmm_map)) {
1803 wpa_printf(MSG_DEBUG,
1804 "nl80211: Invalid AC value %d", ac);
1805 return;
1806 }
1807
1808 ac = wmm_map[ac];
1809 chan->wmm_rules[ac].min_cwmin =
1810 cw2ecw(nla_get_u16(
1811 tb_wmm[NL80211_WMMR_CW_MIN]));
1812 chan->wmm_rules[ac].min_cwmax =
1813 cw2ecw(nla_get_u16(
1814 tb_wmm[NL80211_WMMR_CW_MAX]));
1815 chan->wmm_rules[ac].min_aifs =
1816 nla_get_u8(tb_wmm[NL80211_WMMR_AIFSN]);
1817 chan->wmm_rules[ac].max_txop =
1818 nla_get_u16(tb_wmm[NL80211_WMMR_TXOP]) / 32;
1819 count++;
1820 }
1821
1822 /* Set valid flag if all the AC rules are present */
1823 if (count == WMM_AC_NUM)
1824 chan->wmm_rules_valid = 1;
1825 }
1826 }
1827
1828
phy_info_freqs(struct phy_info_arg * phy_info,struct hostapd_hw_modes * mode,struct nlattr * tb)1829 static int phy_info_freqs(struct phy_info_arg *phy_info,
1830 struct hostapd_hw_modes *mode, struct nlattr *tb)
1831 {
1832 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1833 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
1834 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
1835 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
1836 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
1837 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
1838 [NL80211_FREQUENCY_ATTR_DFS_STATE] = { .type = NLA_U32 },
1839 [NL80211_FREQUENCY_ATTR_NO_10MHZ] = { .type = NLA_FLAG },
1840 [NL80211_FREQUENCY_ATTR_NO_20MHZ] = { .type = NLA_FLAG },
1841 [NL80211_FREQUENCY_ATTR_NO_HT40_PLUS] = { .type = NLA_FLAG },
1842 [NL80211_FREQUENCY_ATTR_NO_HT40_MINUS] = { .type = NLA_FLAG },
1843 [NL80211_FREQUENCY_ATTR_NO_80MHZ] = { .type = NLA_FLAG },
1844 [NL80211_FREQUENCY_ATTR_NO_160MHZ] = { .type = NLA_FLAG },
1845 [NL80211_FREQUENCY_ATTR_NO_320MHZ] = { .type = NLA_FLAG },
1846
1847 };
1848 int new_channels = 0;
1849 struct hostapd_channel_data *channel;
1850 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
1851 struct nlattr *nl_freq;
1852 int rem_freq, idx;
1853
1854 if (tb == NULL)
1855 return NL_OK;
1856
1857 nla_for_each_nested(nl_freq, tb, rem_freq) {
1858 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
1859 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
1860 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
1861 continue;
1862 new_channels++;
1863 }
1864
1865 channel = os_realloc_array(mode->channels,
1866 mode->num_channels + new_channels,
1867 sizeof(struct hostapd_channel_data));
1868 if (!channel)
1869 return NL_STOP;
1870
1871 mode->channels = channel;
1872 mode->num_channels += new_channels;
1873
1874 idx = phy_info->last_chan_idx;
1875
1876 nla_for_each_nested(nl_freq, tb, rem_freq) {
1877 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
1878 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
1879 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
1880 continue;
1881 phy_info_freq(mode, &mode->channels[idx], tb_freq);
1882 idx++;
1883 }
1884 phy_info->last_chan_idx = idx;
1885
1886 return NL_OK;
1887 }
1888
1889
phy_info_rates(struct hostapd_hw_modes * mode,struct nlattr * tb)1890 static int phy_info_rates(struct hostapd_hw_modes *mode, struct nlattr *tb)
1891 {
1892 static struct nla_policy rate_policy[NL80211_BITRATE_ATTR_MAX + 1] = {
1893 [NL80211_BITRATE_ATTR_RATE] = { .type = NLA_U32 },
1894 [NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE] =
1895 { .type = NLA_FLAG },
1896 };
1897 struct nlattr *tb_rate[NL80211_BITRATE_ATTR_MAX + 1];
1898 struct nlattr *nl_rate;
1899 int rem_rate, idx;
1900
1901 if (tb == NULL)
1902 return NL_OK;
1903
1904 nla_for_each_nested(nl_rate, tb, rem_rate) {
1905 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
1906 nla_data(nl_rate), nla_len(nl_rate),
1907 rate_policy);
1908 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
1909 continue;
1910 mode->num_rates++;
1911 }
1912
1913 mode->rates = os_calloc(mode->num_rates, sizeof(int));
1914 if (!mode->rates)
1915 return NL_STOP;
1916
1917 idx = 0;
1918
1919 nla_for_each_nested(nl_rate, tb, rem_rate) {
1920 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
1921 nla_data(nl_rate), nla_len(nl_rate),
1922 rate_policy);
1923 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
1924 continue;
1925 mode->rates[idx] = nla_get_u32(
1926 tb_rate[NL80211_BITRATE_ATTR_RATE]);
1927 idx++;
1928 }
1929
1930 return NL_OK;
1931 }
1932
1933
phy_info_iftype_copy(struct hostapd_hw_modes * mode,enum ieee80211_op_mode opmode,struct nlattr ** tb,struct nlattr ** tb_flags)1934 static void phy_info_iftype_copy(struct hostapd_hw_modes *mode,
1935 enum ieee80211_op_mode opmode,
1936 struct nlattr **tb, struct nlattr **tb_flags)
1937 {
1938 enum nl80211_iftype iftype;
1939 size_t len;
1940 struct he_capabilities *he_capab = &mode->he_capab[opmode];
1941 struct eht_capabilities *eht_capab = &mode->eht_capab[opmode];
1942
1943 switch (opmode) {
1944 case IEEE80211_MODE_INFRA:
1945 iftype = NL80211_IFTYPE_STATION;
1946 break;
1947 case IEEE80211_MODE_IBSS:
1948 iftype = NL80211_IFTYPE_ADHOC;
1949 break;
1950 case IEEE80211_MODE_AP:
1951 iftype = NL80211_IFTYPE_AP;
1952 break;
1953 case IEEE80211_MODE_MESH:
1954 iftype = NL80211_IFTYPE_MESH_POINT;
1955 break;
1956 default:
1957 return;
1958 }
1959
1960 if (!nla_get_flag(tb_flags[iftype]))
1961 return;
1962
1963 he_capab->he_supported = 1;
1964
1965 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]) {
1966 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]);
1967
1968 if (len > sizeof(he_capab->phy_cap))
1969 len = sizeof(he_capab->phy_cap);
1970 os_memcpy(he_capab->phy_cap,
1971 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]),
1972 len);
1973 }
1974
1975 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]) {
1976 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]);
1977
1978 if (len > sizeof(he_capab->mac_cap))
1979 len = sizeof(he_capab->mac_cap);
1980 os_memcpy(he_capab->mac_cap,
1981 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]),
1982 len);
1983 }
1984
1985 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]) {
1986 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]);
1987
1988 if (len > sizeof(he_capab->mcs))
1989 len = sizeof(he_capab->mcs);
1990 os_memcpy(he_capab->mcs,
1991 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]),
1992 len);
1993 }
1994
1995 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]) {
1996 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]);
1997
1998 if (len > sizeof(he_capab->ppet))
1999 len = sizeof(he_capab->ppet);
2000 os_memcpy(&he_capab->ppet,
2001 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]),
2002 len);
2003 }
2004
2005 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA])
2006 he_capab->he_6ghz_capa =
2007 nla_get_u16(tb[NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA]);
2008
2009 if (!tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC] ||
2010 !tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY])
2011 return;
2012
2013 eht_capab->eht_supported = true;
2014
2015 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC] &&
2016 nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC]) >= 2) {
2017 const u8 *pos;
2018
2019 pos = nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC]);
2020 eht_capab->mac_cap = WPA_GET_LE16(pos);
2021 }
2022
2023 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]) {
2024 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]);
2025 if (len > sizeof(eht_capab->phy_cap))
2026 len = sizeof(eht_capab->phy_cap);
2027 os_memcpy(eht_capab->phy_cap,
2028 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]),
2029 len);
2030 }
2031
2032 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]) {
2033 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]);
2034 if (len > sizeof(eht_capab->mcs))
2035 len = sizeof(eht_capab->mcs);
2036 os_memcpy(eht_capab->mcs,
2037 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]),
2038 len);
2039 }
2040
2041 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]) {
2042 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]);
2043 if (len > sizeof(eht_capab->ppet))
2044 len = sizeof(eht_capab->ppet);
2045 os_memcpy(&eht_capab->ppet,
2046 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]),
2047 len);
2048 }
2049 }
2050
2051
phy_info_iftype(struct hostapd_hw_modes * mode,struct nlattr * nl_iftype)2052 static int phy_info_iftype(struct hostapd_hw_modes *mode,
2053 struct nlattr *nl_iftype)
2054 {
2055 struct nlattr *tb[NL80211_BAND_IFTYPE_ATTR_MAX + 1];
2056 struct nlattr *tb_flags[NL80211_IFTYPE_MAX + 1];
2057 unsigned int i;
2058
2059 nla_parse(tb, NL80211_BAND_IFTYPE_ATTR_MAX,
2060 nla_data(nl_iftype), nla_len(nl_iftype), NULL);
2061
2062 if (!tb[NL80211_BAND_IFTYPE_ATTR_IFTYPES])
2063 return NL_STOP;
2064
2065 if (nla_parse_nested(tb_flags, NL80211_IFTYPE_MAX,
2066 tb[NL80211_BAND_IFTYPE_ATTR_IFTYPES], NULL))
2067 return NL_STOP;
2068
2069 for (i = 0; i < IEEE80211_MODE_NUM; i++)
2070 phy_info_iftype_copy(mode, i, tb, tb_flags);
2071
2072 return NL_OK;
2073 }
2074
2075
phy_info_band(struct phy_info_arg * phy_info,struct nlattr * nl_band)2076 static int phy_info_band(struct phy_info_arg *phy_info, struct nlattr *nl_band)
2077 {
2078 struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];
2079 struct hostapd_hw_modes *mode;
2080 int ret;
2081
2082 if (phy_info->last_mode != nl_band->nla_type) {
2083 mode = os_realloc_array(phy_info->modes,
2084 *phy_info->num_modes + 1,
2085 sizeof(*mode));
2086 if (!mode) {
2087 phy_info->failed = 1;
2088 return NL_STOP;
2089 }
2090 phy_info->modes = mode;
2091
2092 mode = &phy_info->modes[*(phy_info->num_modes)];
2093 os_memset(mode, 0, sizeof(*mode));
2094 mode->mode = NUM_HOSTAPD_MODES;
2095 mode->flags = HOSTAPD_MODE_FLAG_HT_INFO_KNOWN |
2096 HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN |
2097 HOSTAPD_MODE_FLAG_HE_INFO_KNOWN;
2098
2099 /*
2100 * Unsupported VHT MCS stream is defined as value 3, so the VHT
2101 * MCS RX/TX map must be initialized with 0xffff to mark all 8
2102 * possible streams as unsupported. This will be overridden if
2103 * driver advertises VHT support.
2104 */
2105 mode->vht_mcs_set[0] = 0xff;
2106 mode->vht_mcs_set[1] = 0xff;
2107 mode->vht_mcs_set[4] = 0xff;
2108 mode->vht_mcs_set[5] = 0xff;
2109
2110 *(phy_info->num_modes) += 1;
2111 phy_info->last_mode = nl_band->nla_type;
2112 phy_info->last_chan_idx = 0;
2113 } else
2114 mode = &phy_info->modes[*(phy_info->num_modes) - 1];
2115
2116 nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band),
2117 nla_len(nl_band), NULL);
2118
2119 phy_info_ht_capa(mode, tb_band[NL80211_BAND_ATTR_HT_CAPA],
2120 tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR],
2121 tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY],
2122 tb_band[NL80211_BAND_ATTR_HT_MCS_SET]);
2123 phy_info_vht_capa(mode, tb_band[NL80211_BAND_ATTR_VHT_CAPA],
2124 tb_band[NL80211_BAND_ATTR_VHT_MCS_SET]);
2125 ret = phy_info_edmg_capa(mode,
2126 tb_band[NL80211_BAND_ATTR_EDMG_BW_CONFIG],
2127 tb_band[NL80211_BAND_ATTR_EDMG_CHANNELS]);
2128 if (ret == NL_OK)
2129 ret = phy_info_freqs(phy_info, mode,
2130 tb_band[NL80211_BAND_ATTR_FREQS]);
2131 if (ret == NL_OK)
2132 ret = phy_info_rates(mode, tb_band[NL80211_BAND_ATTR_RATES]);
2133 if (ret != NL_OK) {
2134 phy_info->failed = 1;
2135 return ret;
2136 }
2137
2138 if (tb_band[NL80211_BAND_ATTR_IFTYPE_DATA]) {
2139 struct nlattr *nl_iftype;
2140 int rem_band;
2141
2142 nla_for_each_nested(nl_iftype,
2143 tb_band[NL80211_BAND_ATTR_IFTYPE_DATA],
2144 rem_band) {
2145 ret = phy_info_iftype(mode, nl_iftype);
2146 if (ret != NL_OK)
2147 return ret;
2148 }
2149 }
2150
2151 return NL_OK;
2152 }
2153
2154
phy_info_handler(struct nl_msg * msg,void * arg)2155 static int phy_info_handler(struct nl_msg *msg, void *arg)
2156 {
2157 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2158 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2159 struct phy_info_arg *phy_info = arg;
2160 struct nlattr *nl_band;
2161 int rem_band;
2162
2163 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2164 genlmsg_attrlen(gnlh, 0), NULL);
2165
2166 if (!tb_msg[NL80211_ATTR_WIPHY_BANDS])
2167 return NL_SKIP;
2168
2169 nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band)
2170 {
2171 int res = phy_info_band(phy_info, nl_band);
2172 if (res != NL_OK)
2173 return res;
2174 }
2175
2176 return NL_SKIP;
2177 }
2178
2179
2180 static struct hostapd_hw_modes *
wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes * modes,u16 * num_modes)2181 wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes *modes,
2182 u16 *num_modes)
2183 {
2184 u16 m;
2185 struct hostapd_hw_modes *mode11g = NULL, *nmodes, *mode;
2186 int i, mode11g_idx = -1;
2187
2188 /* heuristic to set up modes */
2189 for (m = 0; m < *num_modes; m++) {
2190 if (!modes[m].num_channels)
2191 continue;
2192
2193 modes[m].is_6ghz = false;
2194
2195 if (modes[m].channels[0].freq < 2000) {
2196 modes[m].num_channels = 0;
2197 continue;
2198 } else if (modes[m].channels[0].freq < 4000) {
2199 modes[m].mode = HOSTAPD_MODE_IEEE80211B;
2200 for (i = 0; i < modes[m].num_rates; i++) {
2201 if (modes[m].rates[i] > 200) {
2202 modes[m].mode = HOSTAPD_MODE_IEEE80211G;
2203 break;
2204 }
2205 }
2206 } else if (modes[m].channels[0].freq > 50000) {
2207 modes[m].mode = HOSTAPD_MODE_IEEE80211AD;
2208 } else if (is_6ghz_freq(modes[m].channels[0].freq)) {
2209 modes[m].mode = HOSTAPD_MODE_IEEE80211A;
2210 modes[m].is_6ghz = true;
2211 } else {
2212 modes[m].mode = HOSTAPD_MODE_IEEE80211A;
2213 }
2214 }
2215
2216 /* Remove unsupported bands */
2217 m = 0;
2218 while (m < *num_modes) {
2219 if (modes[m].mode == NUM_HOSTAPD_MODES) {
2220 wpa_printf(MSG_DEBUG,
2221 "nl80211: Remove unsupported mode");
2222 os_free(modes[m].channels);
2223 os_free(modes[m].rates);
2224 if (m + 1 < *num_modes)
2225 os_memmove(&modes[m], &modes[m + 1],
2226 sizeof(struct hostapd_hw_modes) *
2227 (*num_modes - (m + 1)));
2228 (*num_modes)--;
2229 continue;
2230 }
2231 m++;
2232 }
2233
2234 /* If only 802.11g mode is included, use it to construct matching
2235 * 802.11b mode data. */
2236
2237 for (m = 0; m < *num_modes; m++) {
2238 if (modes[m].mode == HOSTAPD_MODE_IEEE80211B)
2239 return modes; /* 802.11b already included */
2240 if (modes[m].mode == HOSTAPD_MODE_IEEE80211G)
2241 mode11g_idx = m;
2242 }
2243
2244 if (mode11g_idx < 0)
2245 return modes; /* 2.4 GHz band not supported at all */
2246
2247 nmodes = os_realloc_array(modes, *num_modes + 1, sizeof(*nmodes));
2248 if (nmodes == NULL)
2249 return modes; /* Could not add 802.11b mode */
2250
2251 mode = &nmodes[*num_modes];
2252 os_memset(mode, 0, sizeof(*mode));
2253 (*num_modes)++;
2254 modes = nmodes;
2255
2256 mode->mode = HOSTAPD_MODE_IEEE80211B;
2257
2258 mode11g = &modes[mode11g_idx];
2259 mode->num_channels = mode11g->num_channels;
2260 mode->channels = os_memdup(mode11g->channels,
2261 mode11g->num_channels *
2262 sizeof(struct hostapd_channel_data));
2263 if (mode->channels == NULL) {
2264 (*num_modes)--;
2265 return modes; /* Could not add 802.11b mode */
2266 }
2267
2268 mode->num_rates = 0;
2269 mode->rates = os_malloc(4 * sizeof(int));
2270 if (mode->rates == NULL) {
2271 os_free(mode->channels);
2272 (*num_modes)--;
2273 return modes; /* Could not add 802.11b mode */
2274 }
2275
2276 for (i = 0; i < mode11g->num_rates; i++) {
2277 if (mode11g->rates[i] != 10 && mode11g->rates[i] != 20 &&
2278 mode11g->rates[i] != 55 && mode11g->rates[i] != 110)
2279 continue;
2280 mode->rates[mode->num_rates] = mode11g->rates[i];
2281 mode->num_rates++;
2282 if (mode->num_rates == 4)
2283 break;
2284 }
2285
2286 if (mode->num_rates == 0) {
2287 os_free(mode->channels);
2288 os_free(mode->rates);
2289 (*num_modes)--;
2290 return modes; /* No 802.11b rates */
2291 }
2292
2293 wpa_printf(MSG_DEBUG, "nl80211: Added 802.11b mode based on 802.11g "
2294 "information");
2295
2296 return modes;
2297 }
2298
2299
nl80211_set_ht40_mode(struct hostapd_hw_modes * mode,int start,int end)2300 static void nl80211_set_ht40_mode(struct hostapd_hw_modes *mode, int start,
2301 int end)
2302 {
2303 int c;
2304
2305 for (c = 0; c < mode->num_channels; c++) {
2306 struct hostapd_channel_data *chan = &mode->channels[c];
2307 if (chan->freq - 10 >= start && chan->freq + 10 <= end)
2308 chan->flag |= HOSTAPD_CHAN_HT40;
2309 }
2310 }
2311
2312
nl80211_set_ht40_mode_sec(struct hostapd_hw_modes * mode,int start,int end)2313 static void nl80211_set_ht40_mode_sec(struct hostapd_hw_modes *mode, int start,
2314 int end)
2315 {
2316 int c;
2317
2318 for (c = 0; c < mode->num_channels; c++) {
2319 struct hostapd_channel_data *chan = &mode->channels[c];
2320 if (!(chan->flag & HOSTAPD_CHAN_HT40))
2321 continue;
2322 if (chan->freq - 30 >= start && chan->freq - 10 <= end)
2323 chan->flag |= HOSTAPD_CHAN_HT40MINUS;
2324 if (chan->freq + 10 >= start && chan->freq + 30 <= end)
2325 chan->flag |= HOSTAPD_CHAN_HT40PLUS;
2326 }
2327 }
2328
2329
nl80211_reg_rule_max_eirp(u32 start,u32 end,u32 max_eirp,struct phy_info_arg * results)2330 static void nl80211_reg_rule_max_eirp(u32 start, u32 end, u32 max_eirp,
2331 struct phy_info_arg *results)
2332 {
2333 u16 m;
2334
2335 for (m = 0; m < *results->num_modes; m++) {
2336 int c;
2337 struct hostapd_hw_modes *mode = &results->modes[m];
2338
2339 for (c = 0; c < mode->num_channels; c++) {
2340 struct hostapd_channel_data *chan = &mode->channels[c];
2341 if ((u32) chan->freq - 10 >= start &&
2342 (u32) chan->freq + 10 <= end)
2343 chan->max_tx_power = max_eirp;
2344 }
2345 }
2346 }
2347
2348
nl80211_reg_rule_ht40(u32 start,u32 end,struct phy_info_arg * results)2349 static void nl80211_reg_rule_ht40(u32 start, u32 end,
2350 struct phy_info_arg *results)
2351 {
2352 u16 m;
2353
2354 for (m = 0; m < *results->num_modes; m++) {
2355 if (!(results->modes[m].ht_capab &
2356 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2357 continue;
2358 nl80211_set_ht40_mode(&results->modes[m], start, end);
2359 }
2360 }
2361
2362
nl80211_reg_rule_sec(struct nlattr * tb[],struct phy_info_arg * results)2363 static void nl80211_reg_rule_sec(struct nlattr *tb[],
2364 struct phy_info_arg *results)
2365 {
2366 u32 start, end, max_bw;
2367 u16 m;
2368
2369 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2370 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
2371 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
2372 return;
2373
2374 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2375 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2376 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2377
2378 if (max_bw < 20)
2379 return;
2380
2381 for (m = 0; m < *results->num_modes; m++) {
2382 if (!(results->modes[m].ht_capab &
2383 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2384 continue;
2385 nl80211_set_ht40_mode_sec(&results->modes[m], start, end);
2386 }
2387 }
2388
2389
nl80211_set_vht_mode(struct hostapd_hw_modes * mode,int start,int end,int max_bw)2390 static void nl80211_set_vht_mode(struct hostapd_hw_modes *mode, int start,
2391 int end, int max_bw)
2392 {
2393 int c;
2394
2395 for (c = 0; c < mode->num_channels; c++) {
2396 struct hostapd_channel_data *chan = &mode->channels[c];
2397
2398 if (chan->freq - 10 < start || chan->freq + 10 > end)
2399 continue;
2400
2401 if (max_bw >= 80)
2402 chan->flag |= HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL;
2403
2404 if (max_bw >= 160)
2405 chan->flag |= HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL;
2406 }
2407 }
2408
2409
nl80211_reg_rule_vht(struct nlattr * tb[],struct phy_info_arg * results)2410 static void nl80211_reg_rule_vht(struct nlattr *tb[],
2411 struct phy_info_arg *results)
2412 {
2413 u32 start, end, max_bw;
2414 u16 m;
2415
2416 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2417 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
2418 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
2419 return;
2420
2421 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2422 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2423 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2424
2425 if (max_bw < 80)
2426 return;
2427
2428 for (m = 0; m < *results->num_modes; m++) {
2429 if (!(results->modes[m].ht_capab &
2430 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2431 continue;
2432 /* TODO: use a real VHT support indication */
2433 if (!results->modes[m].vht_capab)
2434 continue;
2435
2436 nl80211_set_vht_mode(&results->modes[m], start, end, max_bw);
2437 }
2438 }
2439
2440
nl80211_set_6ghz_mode(struct hostapd_hw_modes * mode,int start,int end,int max_bw)2441 static void nl80211_set_6ghz_mode(struct hostapd_hw_modes *mode, int start,
2442 int end, int max_bw)
2443 {
2444 int c;
2445
2446 for (c = 0; c < mode->num_channels; c++) {
2447 struct hostapd_channel_data *chan = &mode->channels[c];
2448
2449 if (chan->freq - 10 < start || chan->freq + 10 > end)
2450 continue;
2451
2452 if (max_bw >= 80)
2453 chan->flag |= HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL;
2454
2455 if (max_bw >= 160)
2456 chan->flag |= HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL;
2457
2458 if (max_bw >= 320)
2459 chan->flag |= HOSTAPD_CHAN_EHT_320MHZ_SUBCHANNEL;
2460 }
2461 }
2462
2463
nl80211_reg_rule_6ghz(struct nlattr * tb[],struct phy_info_arg * results)2464 static void nl80211_reg_rule_6ghz(struct nlattr *tb[],
2465 struct phy_info_arg *results)
2466 {
2467 u32 start, end, max_bw;
2468 u16 m;
2469
2470 if (!tb[NL80211_ATTR_FREQ_RANGE_START] ||
2471 !tb[NL80211_ATTR_FREQ_RANGE_END] ||
2472 !tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2473 return;
2474
2475 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2476 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2477 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2478
2479 if (max_bw < 80)
2480 return;
2481
2482 for (m = 0; m < *results->num_modes; m++) {
2483 if (results->modes[m].num_channels == 0 ||
2484 !is_6ghz_freq(results->modes[m].channels[0].freq))
2485 continue;
2486
2487 nl80211_set_6ghz_mode(&results->modes[m], start, end, max_bw);
2488 }
2489 }
2490
2491
nl80211_set_dfs_domain(enum nl80211_dfs_regions region,u8 * dfs_domain)2492 static void nl80211_set_dfs_domain(enum nl80211_dfs_regions region,
2493 u8 *dfs_domain)
2494 {
2495 if (region == NL80211_DFS_FCC)
2496 *dfs_domain = HOSTAPD_DFS_REGION_FCC;
2497 else if (region == NL80211_DFS_ETSI)
2498 *dfs_domain = HOSTAPD_DFS_REGION_ETSI;
2499 else if (region == NL80211_DFS_JP)
2500 *dfs_domain = HOSTAPD_DFS_REGION_JP;
2501 else
2502 *dfs_domain = 0;
2503 }
2504
2505
dfs_domain_name(enum nl80211_dfs_regions region)2506 static const char * dfs_domain_name(enum nl80211_dfs_regions region)
2507 {
2508 switch (region) {
2509 case NL80211_DFS_UNSET:
2510 return "DFS-UNSET";
2511 case NL80211_DFS_FCC:
2512 return "DFS-FCC";
2513 case NL80211_DFS_ETSI:
2514 return "DFS-ETSI";
2515 case NL80211_DFS_JP:
2516 return "DFS-JP";
2517 default:
2518 return "DFS-invalid";
2519 }
2520 }
2521
2522
nl80211_get_reg(struct nl_msg * msg,void * arg)2523 static int nl80211_get_reg(struct nl_msg *msg, void *arg)
2524 {
2525 struct phy_info_arg *results = arg;
2526 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2527 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2528 struct nlattr *nl_rule;
2529 struct nlattr *tb_rule[NL80211_FREQUENCY_ATTR_MAX + 1];
2530 int rem_rule;
2531 static struct nla_policy reg_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
2532 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2533 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2534 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2535 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2536 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2537 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2538 };
2539
2540 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2541 genlmsg_attrlen(gnlh, 0), NULL);
2542 if (!tb_msg[NL80211_ATTR_REG_ALPHA2] ||
2543 !tb_msg[NL80211_ATTR_REG_RULES]) {
2544 wpa_printf(MSG_DEBUG, "nl80211: No regulatory information "
2545 "available");
2546 return NL_SKIP;
2547 }
2548
2549 if (tb_msg[NL80211_ATTR_DFS_REGION]) {
2550 enum nl80211_dfs_regions dfs_domain;
2551 dfs_domain = nla_get_u8(tb_msg[NL80211_ATTR_DFS_REGION]);
2552 nl80211_set_dfs_domain(dfs_domain, &results->dfs_domain);
2553 wpa_printf(MSG_DEBUG, "nl80211: Regulatory information - country=%s (%s)",
2554 (char *) nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]),
2555 dfs_domain_name(dfs_domain));
2556 } else {
2557 wpa_printf(MSG_DEBUG, "nl80211: Regulatory information - country=%s",
2558 (char *) nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]));
2559 }
2560
2561 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2562 {
2563 u32 start, end, max_eirp = 0, max_bw = 0, flags = 0;
2564 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2565 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2566 if (tb_rule[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2567 tb_rule[NL80211_ATTR_FREQ_RANGE_END] == NULL)
2568 continue;
2569 start = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2570 end = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2571 if (tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2572 max_eirp = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP]) / 100;
2573 if (tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2574 max_bw = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2575 if (tb_rule[NL80211_ATTR_REG_RULE_FLAGS])
2576 flags = nla_get_u32(tb_rule[NL80211_ATTR_REG_RULE_FLAGS]);
2577
2578 wpa_printf(MSG_DEBUG, "nl80211: %u-%u @ %u MHz %u mBm%s%s%s%s%s%s%s%s",
2579 start, end, max_bw, max_eirp,
2580 flags & NL80211_RRF_NO_OFDM ? " (no OFDM)" : "",
2581 flags & NL80211_RRF_NO_CCK ? " (no CCK)" : "",
2582 flags & NL80211_RRF_NO_INDOOR ? " (no indoor)" : "",
2583 flags & NL80211_RRF_NO_OUTDOOR ? " (no outdoor)" :
2584 "",
2585 flags & NL80211_RRF_DFS ? " (DFS)" : "",
2586 flags & NL80211_RRF_PTP_ONLY ? " (PTP only)" : "",
2587 flags & NL80211_RRF_PTMP_ONLY ? " (PTMP only)" : "",
2588 flags & NL80211_RRF_NO_IR ? " (no IR)" : "");
2589 if (max_bw >= 40)
2590 nl80211_reg_rule_ht40(start, end, results);
2591 if (tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2592 nl80211_reg_rule_max_eirp(start, end, max_eirp,
2593 results);
2594 }
2595
2596 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2597 {
2598 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2599 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2600 nl80211_reg_rule_sec(tb_rule, results);
2601 }
2602
2603 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2604 {
2605 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2606 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2607 nl80211_reg_rule_vht(tb_rule, results);
2608 }
2609
2610 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2611 {
2612 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2613 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2614 nl80211_reg_rule_6ghz(tb_rule, results);
2615 }
2616
2617 return NL_SKIP;
2618 }
2619
2620
nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data * drv,struct phy_info_arg * results)2621 static int nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data *drv,
2622 struct phy_info_arg *results)
2623 {
2624 struct nl_msg *msg;
2625
2626 msg = nlmsg_alloc();
2627 if (!msg)
2628 return -ENOMEM;
2629
2630 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
2631 if (drv->capa.flags & WPA_DRIVER_FLAGS_SELF_MANAGED_REGULATORY) {
2632 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, drv->wiphy_idx)) {
2633 nlmsg_free(msg);
2634 return -1;
2635 }
2636 }
2637
2638 return send_and_recv_resp(drv, msg, nl80211_get_reg, results);
2639 }
2640
2641
modestr(enum hostapd_hw_mode mode)2642 static const char * modestr(enum hostapd_hw_mode mode)
2643 {
2644 switch (mode) {
2645 case HOSTAPD_MODE_IEEE80211B:
2646 return "802.11b";
2647 case HOSTAPD_MODE_IEEE80211G:
2648 return "802.11g";
2649 case HOSTAPD_MODE_IEEE80211A:
2650 return "802.11a";
2651 case HOSTAPD_MODE_IEEE80211AD:
2652 return "802.11ad";
2653 default:
2654 return "?";
2655 }
2656 }
2657
2658
nl80211_dump_chan_list(struct wpa_driver_nl80211_data * drv,struct hostapd_hw_modes * modes,u16 num_modes)2659 static void nl80211_dump_chan_list(struct wpa_driver_nl80211_data *drv,
2660 struct hostapd_hw_modes *modes,
2661 u16 num_modes)
2662 {
2663 int i;
2664
2665 if (!modes)
2666 return;
2667
2668 for (i = 0; i < num_modes; i++) {
2669 struct hostapd_hw_modes *mode = &modes[i];
2670 char str[1000];
2671 char *pos = str;
2672 char *end = pos + sizeof(str);
2673 int j, res;
2674
2675 for (j = 0; j < mode->num_channels; j++) {
2676 struct hostapd_channel_data *chan = &mode->channels[j];
2677
2678 if (is_6ghz_freq(chan->freq))
2679 drv->uses_6ghz = true;
2680 if (chan->freq >= 900 && chan->freq < 1000)
2681 drv->uses_s1g = true;
2682 res = os_snprintf(pos, end - pos, " %d%s%s%s",
2683 chan->freq,
2684 (chan->flag & HOSTAPD_CHAN_DISABLED) ?
2685 "[DISABLED]" : "",
2686 (chan->flag & HOSTAPD_CHAN_NO_IR) ?
2687 "[NO_IR]" : "",
2688 (chan->flag & HOSTAPD_CHAN_RADAR) ?
2689 "[RADAR]" : "");
2690 if (os_snprintf_error(end - pos, res))
2691 break;
2692 pos += res;
2693 }
2694
2695 *pos = '\0';
2696 wpa_printf(MSG_DEBUG, "nl80211: Mode IEEE %s:%s",
2697 modestr(mode->mode), str);
2698 }
2699 }
2700
2701
2702 struct hostapd_hw_modes *
nl80211_get_hw_feature_data(void * priv,u16 * num_modes,u16 * flags,u8 * dfs_domain)2703 nl80211_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags,
2704 u8 *dfs_domain)
2705 {
2706 u32 feat;
2707 struct i802_bss *bss = priv;
2708 struct wpa_driver_nl80211_data *drv = bss->drv;
2709 int nl_flags = 0;
2710 struct nl_msg *msg;
2711 struct phy_info_arg result = {
2712 .num_modes = num_modes,
2713 .modes = NULL,
2714 .last_mode = -1,
2715 .failed = 0,
2716 .dfs_domain = 0,
2717 };
2718
2719 *num_modes = 0;
2720 *flags = 0;
2721 *dfs_domain = 0;
2722
2723 feat = get_nl80211_protocol_features(drv);
2724 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
2725 nl_flags = NLM_F_DUMP;
2726 if (!(msg = nl80211_cmd_msg(bss, nl_flags, NL80211_CMD_GET_WIPHY)) ||
2727 nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
2728 nlmsg_free(msg);
2729 return NULL;
2730 }
2731
2732 if (send_and_recv_resp(drv, msg, phy_info_handler, &result) == 0) {
2733 struct hostapd_hw_modes *modes;
2734
2735 nl80211_set_regulatory_flags(drv, &result);
2736 if (result.failed) {
2737 int i;
2738
2739 for (i = 0; result.modes && i < *num_modes; i++) {
2740 os_free(result.modes[i].channels);
2741 os_free(result.modes[i].rates);
2742 }
2743 os_free(result.modes);
2744 *num_modes = 0;
2745 return NULL;
2746 }
2747
2748 *dfs_domain = result.dfs_domain;
2749
2750 modes = wpa_driver_nl80211_postprocess_modes(result.modes,
2751 num_modes);
2752 nl80211_dump_chan_list(drv, modes, *num_modes);
2753 return modes;
2754 }
2755
2756 return NULL;
2757 }
2758
2759
phy_multi_hw_info_parse(struct hostapd_multi_hw_info * hw_info,struct nlattr * radio_attr)2760 static int phy_multi_hw_info_parse(struct hostapd_multi_hw_info *hw_info,
2761 struct nlattr *radio_attr)
2762 {
2763 struct nlattr *tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_MAX + 1];
2764 int start_freq, end_freq;
2765
2766 switch (nla_type(radio_attr)) {
2767 case NL80211_WIPHY_RADIO_ATTR_INDEX:
2768 hw_info->hw_idx = nla_get_u32(radio_attr);
2769 return NL_OK;
2770 case NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE:
2771 if (nla_parse_nested(tb_freq, NL80211_WIPHY_RADIO_FREQ_ATTR_MAX,
2772 radio_attr, NULL) ||
2773 !tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_START] ||
2774 !tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_END])
2775 return NL_STOP;
2776
2777 start_freq = nla_get_u32(
2778 tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_START]);
2779 end_freq = nla_get_u32(
2780 tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_END]);
2781
2782 /* Convert to MHz and store */
2783 hw_info->start_freq = start_freq / 1000;
2784 hw_info->end_freq = end_freq / 1000;
2785 return NL_OK;
2786 default:
2787 return NL_OK;
2788 }
2789 }
2790
2791
2792 struct phy_multi_hw_info_arg {
2793 bool failed;
2794 unsigned int *num_multi_hws;
2795 struct hostapd_multi_hw_info *multi_hws;
2796 };
2797
2798
phy_multi_hw_info_handler(struct nl_msg * msg,void * arg)2799 static int phy_multi_hw_info_handler(struct nl_msg *msg, void *arg)
2800 {
2801 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2802 struct phy_multi_hw_info_arg *multi_hw_info = arg;
2803 struct hostapd_multi_hw_info *multi_hws, hw_info;
2804 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2805 struct nlattr *nl_hw, *radio_attr;
2806 int rem_hw, rem_radio_prop, res;
2807
2808 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2809 genlmsg_attrlen(gnlh, 0), NULL);
2810
2811 if (!tb_msg[NL80211_ATTR_WIPHY_RADIOS])
2812 return NL_SKIP;
2813
2814 *multi_hw_info->num_multi_hws = 0;
2815
2816 nla_for_each_nested(nl_hw, tb_msg[NL80211_ATTR_WIPHY_RADIOS], rem_hw) {
2817 os_memset(&hw_info, 0, sizeof(hw_info));
2818
2819 nla_for_each_nested(radio_attr, nl_hw, rem_radio_prop) {
2820 res = phy_multi_hw_info_parse(&hw_info, radio_attr);
2821 if (res != NL_OK)
2822 goto out;
2823 }
2824
2825 if (hw_info.start_freq == 0 || hw_info.end_freq == 0)
2826 goto out;
2827
2828 multi_hws = os_realloc_array(multi_hw_info->multi_hws,
2829 *multi_hw_info->num_multi_hws + 1,
2830 sizeof(*multi_hws));
2831 if (!multi_hws)
2832 goto out;
2833
2834 multi_hw_info->multi_hws = multi_hws;
2835 os_memcpy(&multi_hws[*(multi_hw_info->num_multi_hws)],
2836 &hw_info, sizeof(struct hostapd_multi_hw_info));
2837 *(multi_hw_info->num_multi_hws) += 1;
2838 }
2839
2840 return NL_OK;
2841 out:
2842 multi_hw_info->failed = true;
2843 return NL_STOP;
2844 }
2845
2846
2847 struct hostapd_multi_hw_info *
nl80211_get_multi_hw_info(struct i802_bss * bss,unsigned int * num_multi_hws)2848 nl80211_get_multi_hw_info(struct i802_bss *bss, unsigned int *num_multi_hws)
2849 {
2850 u32 feat;
2851 struct wpa_driver_nl80211_data *drv = bss->drv;
2852 int nl_flags = 0;
2853 struct nl_msg *msg;
2854 struct phy_multi_hw_info_arg result = {
2855 .failed = false,
2856 .num_multi_hws = num_multi_hws,
2857 .multi_hws = NULL,
2858 };
2859
2860 *num_multi_hws = 0;
2861
2862 if (!drv->has_capability || !(drv->capa.flags2 & WPA_DRIVER_FLAGS2_MLO))
2863 return NULL;
2864
2865 feat = get_nl80211_protocol_features(drv);
2866 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
2867 nl_flags = NLM_F_DUMP;
2868 if (!(msg = nl80211_cmd_msg(bss, nl_flags, NL80211_CMD_GET_WIPHY)) ||
2869 nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
2870 nlmsg_free(msg);
2871 return NULL;
2872 }
2873
2874 if (send_and_recv_resp(drv, msg, phy_multi_hw_info_handler,
2875 &result) == 0) {
2876 if (result.failed) {
2877 os_free(result.multi_hws);
2878 *num_multi_hws = 0;
2879 return NULL;
2880 }
2881
2882 return result.multi_hws;
2883 }
2884
2885 return NULL;
2886 }
2887