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