Line data Source code
1 : /*
2 : * IEEE 802.11 Common routines
3 : * Copyright (c) 2002-2015, Jouni Malinen <j@w1.fi>
4 : *
5 : * This software may be distributed under the terms of the BSD license.
6 : * See README for more details.
7 : */
8 :
9 : #include "includes.h"
10 :
11 : #include "common.h"
12 : #include "defs.h"
13 : #include "wpa_common.h"
14 : #include "qca-vendor.h"
15 : #include "ieee802_11_defs.h"
16 : #include "ieee802_11_common.h"
17 :
18 :
19 92977 : static int ieee802_11_parse_vendor_specific(const u8 *pos, size_t elen,
20 : struct ieee802_11_elems *elems,
21 : int show_errors)
22 : {
23 : unsigned int oui;
24 :
25 : /* first 3 bytes in vendor specific information element are the IEEE
26 : * OUI of the vendor. The following byte is used a vendor specific
27 : * sub-type. */
28 92977 : if (elen < 4) {
29 3 : if (show_errors) {
30 1 : wpa_printf(MSG_MSGDUMP, "short vendor specific "
31 : "information element ignored (len=%lu)",
32 : (unsigned long) elen);
33 : }
34 3 : return -1;
35 : }
36 :
37 92974 : oui = WPA_GET_BE24(pos);
38 92974 : switch (oui) {
39 : case OUI_MICROSOFT:
40 : /* Microsoft/Wi-Fi information elements are further typed and
41 : * subtyped */
42 63489 : switch (pos[3]) {
43 : case 1:
44 : /* Microsoft OUI (00:50:F2) with OUI Type 1:
45 : * real WPA information element */
46 469 : elems->wpa_ie = pos;
47 469 : elems->wpa_ie_len = elen;
48 469 : break;
49 : case WMM_OUI_TYPE:
50 : /* WMM information element */
51 43154 : if (elen < 5) {
52 1 : wpa_printf(MSG_MSGDUMP, "short WMM "
53 : "information element ignored "
54 : "(len=%lu)",
55 : (unsigned long) elen);
56 1 : return -1;
57 : }
58 43153 : switch (pos[4]) {
59 : case WMM_OUI_SUBTYPE_INFORMATION_ELEMENT:
60 : case WMM_OUI_SUBTYPE_PARAMETER_ELEMENT:
61 : /*
62 : * Share same pointer since only one of these
63 : * is used and they start with same data.
64 : * Length field can be used to distinguish the
65 : * IEs.
66 : */
67 43132 : elems->wmm = pos;
68 43132 : elems->wmm_len = elen;
69 43132 : break;
70 : case WMM_OUI_SUBTYPE_TSPEC_ELEMENT:
71 20 : elems->wmm_tspec = pos;
72 20 : elems->wmm_tspec_len = elen;
73 20 : break;
74 : default:
75 1 : wpa_printf(MSG_EXCESSIVE, "unknown WMM "
76 : "information element ignored "
77 : "(subtype=%d len=%lu)",
78 1 : pos[4], (unsigned long) elen);
79 1 : return -1;
80 : }
81 43152 : break;
82 : case 4:
83 : /* Wi-Fi Protected Setup (WPS) IE */
84 19865 : elems->wps_ie = pos;
85 19865 : elems->wps_ie_len = elen;
86 19865 : break;
87 : default:
88 1 : wpa_printf(MSG_EXCESSIVE, "Unknown Microsoft "
89 : "information element ignored "
90 : "(type=%d len=%lu)",
91 1 : pos[3], (unsigned long) elen);
92 1 : return -1;
93 : }
94 63486 : break;
95 :
96 : case OUI_WFA:
97 29402 : switch (pos[3]) {
98 : case P2P_OUI_TYPE:
99 : /* Wi-Fi Alliance - P2P IE */
100 17283 : elems->p2p = pos;
101 17283 : elems->p2p_len = elen;
102 17283 : break;
103 : case WFD_OUI_TYPE:
104 : /* Wi-Fi Alliance - WFD IE */
105 340 : elems->wfd = pos;
106 340 : elems->wfd_len = elen;
107 340 : break;
108 : case HS20_INDICATION_OUI_TYPE:
109 : /* Hotspot 2.0 */
110 4653 : elems->hs20 = pos;
111 4653 : elems->hs20_len = elen;
112 4653 : break;
113 : case HS20_OSEN_OUI_TYPE:
114 : /* Hotspot 2.0 OSEN */
115 15 : elems->osen = pos;
116 15 : elems->osen_len = elen;
117 15 : break;
118 : case MBO_OUI_TYPE:
119 : /* MBO-OCE */
120 7110 : elems->mbo = pos;
121 7110 : elems->mbo_len = elen;
122 7110 : break;
123 : default:
124 1 : wpa_printf(MSG_MSGDUMP, "Unknown WFA "
125 : "information element ignored "
126 : "(type=%d len=%lu)",
127 1 : pos[3], (unsigned long) elen);
128 1 : return -1;
129 : }
130 29401 : break;
131 :
132 : case OUI_BROADCOM:
133 13 : switch (pos[3]) {
134 : case VENDOR_HT_CAPAB_OUI_TYPE:
135 2 : elems->vendor_ht_cap = pos;
136 2 : elems->vendor_ht_cap_len = elen;
137 2 : break;
138 : case VENDOR_VHT_TYPE:
139 19 : if (elen > 4 &&
140 12 : (pos[4] == VENDOR_VHT_SUBTYPE ||
141 3 : pos[4] == VENDOR_VHT_SUBTYPE2)) {
142 9 : elems->vendor_vht = pos;
143 9 : elems->vendor_vht_len = elen;
144 : } else
145 1 : return -1;
146 9 : break;
147 : default:
148 1 : wpa_printf(MSG_EXCESSIVE, "Unknown Broadcom "
149 : "information element ignored "
150 : "(type=%d len=%lu)",
151 1 : pos[3], (unsigned long) elen);
152 1 : return -1;
153 : }
154 11 : break;
155 :
156 : case OUI_QCA:
157 4 : switch (pos[3]) {
158 : case QCA_VENDOR_ELEM_P2P_PREF_CHAN_LIST:
159 2 : elems->pref_freq_list = pos;
160 2 : elems->pref_freq_list_len = elen;
161 2 : break;
162 : default:
163 2 : wpa_printf(MSG_EXCESSIVE,
164 : "Unknown QCA information element ignored (type=%d len=%lu)",
165 2 : pos[3], (unsigned long) elen);
166 2 : return -1;
167 : }
168 2 : break;
169 :
170 : default:
171 198 : wpa_printf(MSG_EXCESSIVE, "unknown vendor specific "
172 : "information element ignored (vendor OUI "
173 : "%02x:%02x:%02x len=%lu)",
174 198 : pos[0], pos[1], pos[2], (unsigned long) elen);
175 66 : return -1;
176 : }
177 :
178 92900 : return 0;
179 : }
180 :
181 :
182 : /**
183 : * ieee802_11_parse_elems - Parse information elements in management frames
184 : * @start: Pointer to the start of IEs
185 : * @len: Length of IE buffer in octets
186 : * @elems: Data structure for parsed elements
187 : * @show_errors: Whether to show parsing errors in debug log
188 : * Returns: Parsing result
189 : */
190 61112 : ParseRes ieee802_11_parse_elems(const u8 *start, size_t len,
191 : struct ieee802_11_elems *elems,
192 : int show_errors)
193 : {
194 61112 : size_t left = len;
195 61112 : const u8 *pos = start;
196 61112 : int unknown = 0;
197 :
198 61112 : os_memset(elems, 0, sizeof(*elems));
199 :
200 641313 : while (left >= 2) {
201 : u8 id, elen;
202 :
203 519098 : id = *pos++;
204 519098 : elen = *pos++;
205 519098 : left -= 2;
206 :
207 519098 : if (elen > left) {
208 9 : if (show_errors) {
209 2 : wpa_printf(MSG_DEBUG, "IEEE 802.11 element "
210 : "parse failed (id=%d elen=%d "
211 : "left=%lu)",
212 : id, elen, (unsigned long) left);
213 2 : wpa_hexdump(MSG_MSGDUMP, "IEs", start, len);
214 : }
215 9 : return ParseFailed;
216 : }
217 :
218 519089 : switch (id) {
219 : case WLAN_EID_SSID:
220 36184 : if (elen > SSID_MAX_LEN) {
221 2 : wpa_printf(MSG_DEBUG,
222 : "Ignored too long SSID element (elen=%u)",
223 : elen);
224 2 : break;
225 : }
226 36182 : elems->ssid = pos;
227 36182 : elems->ssid_len = elen;
228 36182 : break;
229 : case WLAN_EID_SUPP_RATES:
230 55169 : elems->supp_rates = pos;
231 55169 : elems->supp_rates_len = elen;
232 55169 : break;
233 : case WLAN_EID_DS_PARAMS:
234 30212 : if (elen < 1)
235 1 : break;
236 30211 : elems->ds_params = pos;
237 30211 : break;
238 : case WLAN_EID_CF_PARAMS:
239 : case WLAN_EID_TIM:
240 11912 : break;
241 : case WLAN_EID_CHALLENGE:
242 1 : elems->challenge = pos;
243 1 : elems->challenge_len = elen;
244 1 : break;
245 : case WLAN_EID_ERP_INFO:
246 18602 : if (elen < 1)
247 1 : break;
248 18601 : elems->erp_info = pos;
249 18601 : break;
250 : case WLAN_EID_EXT_SUPP_RATES:
251 43600 : elems->ext_supp_rates = pos;
252 43600 : elems->ext_supp_rates_len = elen;
253 43600 : break;
254 : case WLAN_EID_VENDOR_SPECIFIC:
255 92977 : if (ieee802_11_parse_vendor_specific(pos, elen,
256 : elems,
257 : show_errors))
258 77 : unknown++;
259 92977 : break;
260 : case WLAN_EID_RSN:
261 21468 : elems->rsn_ie = pos;
262 21468 : elems->rsn_ie_len = elen;
263 21468 : break;
264 : case WLAN_EID_PWR_CAPABILITY:
265 5 : break;
266 : case WLAN_EID_SUPPORTED_CHANNELS:
267 1 : elems->supp_channels = pos;
268 1 : elems->supp_channels_len = elen;
269 1 : break;
270 : case WLAN_EID_MOBILITY_DOMAIN:
271 2904 : if (elen < sizeof(struct rsn_mdie))
272 1 : break;
273 2903 : elems->mdie = pos;
274 2903 : elems->mdie_len = elen;
275 2903 : break;
276 : case WLAN_EID_FAST_BSS_TRANSITION:
277 1573 : if (elen < sizeof(struct rsn_ftie))
278 1 : break;
279 1572 : elems->ftie = pos;
280 1572 : elems->ftie_len = elen;
281 1572 : break;
282 : case WLAN_EID_TIMEOUT_INTERVAL:
283 4 : if (elen != 5)
284 2 : break;
285 2 : elems->timeout_int = pos;
286 2 : break;
287 : case WLAN_EID_HT_CAP:
288 53869 : if (elen < sizeof(struct ieee80211_ht_capabilities))
289 1 : break;
290 53868 : elems->ht_capabilities = pos;
291 53868 : break;
292 : case WLAN_EID_HT_OPERATION:
293 38005 : if (elen < sizeof(struct ieee80211_ht_operation))
294 1 : break;
295 38004 : elems->ht_operation = pos;
296 38004 : break;
297 : case WLAN_EID_MESH_CONFIG:
298 424 : elems->mesh_config = pos;
299 424 : elems->mesh_config_len = elen;
300 424 : break;
301 : case WLAN_EID_MESH_ID:
302 7370 : elems->mesh_id = pos;
303 7370 : elems->mesh_id_len = elen;
304 7370 : break;
305 : case WLAN_EID_PEER_MGMT:
306 356 : elems->peer_mgmt = pos;
307 356 : elems->peer_mgmt_len = elen;
308 356 : break;
309 : case WLAN_EID_VHT_CAP:
310 556 : if (elen < sizeof(struct ieee80211_vht_capabilities))
311 1 : break;
312 555 : elems->vht_capabilities = pos;
313 555 : break;
314 : case WLAN_EID_VHT_OPERATION:
315 201 : if (elen < sizeof(struct ieee80211_vht_operation))
316 1 : break;
317 200 : elems->vht_operation = pos;
318 200 : break;
319 : case WLAN_EID_VHT_OPERATING_MODE_NOTIFICATION:
320 2 : if (elen != 1)
321 1 : break;
322 1 : elems->vht_opmode_notif = pos;
323 1 : break;
324 : case WLAN_EID_LINK_ID:
325 2 : if (elen < 18)
326 1 : break;
327 1 : elems->link_id = pos;
328 1 : break;
329 : case WLAN_EID_INTERWORKING:
330 4426 : elems->interworking = pos;
331 4426 : elems->interworking_len = elen;
332 4426 : break;
333 : case WLAN_EID_QOS_MAP_SET:
334 5 : if (elen < 16)
335 1 : break;
336 4 : elems->qos_map_set = pos;
337 4 : elems->qos_map_set_len = elen;
338 4 : break;
339 : case WLAN_EID_EXT_CAPAB:
340 54130 : elems->ext_capab = pos;
341 54130 : elems->ext_capab_len = elen;
342 54130 : break;
343 : case WLAN_EID_BSS_MAX_IDLE_PERIOD:
344 18727 : if (elen < 3)
345 1 : break;
346 18726 : elems->bss_max_idle_period = pos;
347 18726 : break;
348 : case WLAN_EID_SSID_LIST:
349 1 : elems->ssid_list = pos;
350 1 : elems->ssid_list_len = elen;
351 1 : break;
352 : case WLAN_EID_AMPE:
353 1 : elems->ampe = pos;
354 1 : elems->ampe_len = elen;
355 1 : break;
356 : case WLAN_EID_MIC:
357 194 : elems->mic = pos;
358 194 : elems->mic_len = elen;
359 : /* after mic everything is encrypted, so stop. */
360 194 : left = elen;
361 194 : break;
362 : case WLAN_EID_MULTI_BAND:
363 2729 : if (elems->mb_ies.nof_ies >= MAX_NOF_MB_IES_SUPPORTED) {
364 2 : wpa_printf(MSG_MSGDUMP,
365 : "IEEE 802.11 element parse ignored MB IE (id=%d elen=%d)",
366 : id, elen);
367 2 : break;
368 : }
369 :
370 2727 : elems->mb_ies.ies[elems->mb_ies.nof_ies].ie = pos;
371 2727 : elems->mb_ies.ies[elems->mb_ies.nof_ies].ie_len = elen;
372 2727 : elems->mb_ies.nof_ies++;
373 2727 : break;
374 : case WLAN_EID_SUPPORTED_OPERATING_CLASSES:
375 19185 : elems->supp_op_classes = pos;
376 19185 : elems->supp_op_classes_len = elen;
377 19185 : break;
378 : case WLAN_EID_RRM_ENABLED_CAPABILITIES:
379 16 : elems->rrm_enabled = pos;
380 16 : elems->rrm_enabled_len = elen;
381 16 : break;
382 : default:
383 4278 : unknown++;
384 4278 : if (!show_errors)
385 4262 : break;
386 16 : wpa_printf(MSG_MSGDUMP, "IEEE 802.11 element parse "
387 : "ignored unknown element (id=%d elen=%d)",
388 : id, elen);
389 16 : break;
390 : }
391 :
392 519089 : left -= elen;
393 519089 : pos += elen;
394 : }
395 :
396 61103 : if (left)
397 3 : return ParseFailed;
398 :
399 61100 : return unknown ? ParseUnknown : ParseOK;
400 : }
401 :
402 :
403 256 : int ieee802_11_ie_count(const u8 *ies, size_t ies_len)
404 : {
405 256 : int count = 0;
406 : const u8 *pos, *end;
407 :
408 256 : if (ies == NULL)
409 230 : return 0;
410 :
411 26 : pos = ies;
412 26 : end = ies + ies_len;
413 :
414 85 : while (end - pos >= 2) {
415 34 : if (2 + pos[1] > end - pos)
416 1 : break;
417 33 : count++;
418 33 : pos += 2 + pos[1];
419 : }
420 :
421 26 : return count;
422 : }
423 :
424 :
425 22778 : struct wpabuf * ieee802_11_vendor_ie_concat(const u8 *ies, size_t ies_len,
426 : u32 oui_type)
427 : {
428 : struct wpabuf *buf;
429 : const u8 *end, *pos, *ie;
430 :
431 22778 : pos = ies;
432 22778 : end = ies + ies_len;
433 22778 : ie = NULL;
434 :
435 200731 : while (end - pos > 1) {
436 170928 : if (2 + pos[1] > end - pos)
437 4 : return NULL;
438 209017 : if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
439 38093 : WPA_GET_BE32(&pos[2]) == oui_type) {
440 15749 : ie = pos;
441 15749 : break;
442 : }
443 155175 : pos += 2 + pos[1];
444 : }
445 :
446 22774 : if (ie == NULL)
447 7025 : return NULL; /* No specified vendor IE found */
448 :
449 15749 : buf = wpabuf_alloc(ies_len);
450 15749 : if (buf == NULL)
451 1 : return NULL;
452 :
453 : /*
454 : * There may be multiple vendor IEs in the message, so need to
455 : * concatenate their data fields.
456 : */
457 61397 : while (end - pos > 1) {
458 29901 : if (2 + pos[1] > end - pos)
459 0 : break;
460 56718 : if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
461 26817 : WPA_GET_BE32(&pos[2]) == oui_type)
462 15828 : wpabuf_put_data(buf, pos + 6, pos[1] - 4);
463 29901 : pos += 2 + pos[1];
464 : }
465 :
466 15748 : return buf;
467 : }
468 :
469 :
470 39728 : const u8 * get_hdr_bssid(const struct ieee80211_hdr *hdr, size_t len)
471 : {
472 : u16 fc, type, stype;
473 :
474 : /*
475 : * PS-Poll frames are 16 bytes. All other frames are
476 : * 24 bytes or longer.
477 : */
478 39728 : if (len < 16)
479 0 : return NULL;
480 :
481 39728 : fc = le_to_host16(hdr->frame_control);
482 39728 : type = WLAN_FC_GET_TYPE(fc);
483 39728 : stype = WLAN_FC_GET_STYPE(fc);
484 :
485 39728 : switch (type) {
486 : case WLAN_FC_TYPE_DATA:
487 1 : if (len < 24)
488 0 : return NULL;
489 1 : switch (fc & (WLAN_FC_FROMDS | WLAN_FC_TODS)) {
490 : case WLAN_FC_FROMDS | WLAN_FC_TODS:
491 : case WLAN_FC_TODS:
492 1 : return hdr->addr1;
493 : case WLAN_FC_FROMDS:
494 0 : return hdr->addr2;
495 : default:
496 0 : return NULL;
497 : }
498 : case WLAN_FC_TYPE_CTRL:
499 0 : if (stype != WLAN_FC_STYPE_PSPOLL)
500 0 : return NULL;
501 0 : return hdr->addr1;
502 : case WLAN_FC_TYPE_MGMT:
503 39727 : return hdr->addr3;
504 : default:
505 0 : return NULL;
506 : }
507 : }
508 :
509 :
510 42 : int hostapd_config_wmm_ac(struct hostapd_wmm_ac_params wmm_ac_params[],
511 : const char *name, const char *val)
512 : {
513 : int num, v;
514 : const char *pos;
515 : struct hostapd_wmm_ac_params *ac;
516 :
517 : /* skip 'wme_ac_' or 'wmm_ac_' prefix */
518 42 : pos = name + 7;
519 42 : if (os_strncmp(pos, "be_", 3) == 0) {
520 6 : num = 0;
521 6 : pos += 3;
522 36 : } else if (os_strncmp(pos, "bk_", 3) == 0) {
523 13 : num = 1;
524 13 : pos += 3;
525 23 : } else if (os_strncmp(pos, "vi_", 3) == 0) {
526 11 : num = 2;
527 11 : pos += 3;
528 12 : } else if (os_strncmp(pos, "vo_", 3) == 0) {
529 11 : num = 3;
530 11 : pos += 3;
531 : } else {
532 1 : wpa_printf(MSG_ERROR, "Unknown WMM name '%s'", pos);
533 1 : return -1;
534 : }
535 :
536 41 : ac = &wmm_ac_params[num];
537 :
538 41 : if (os_strcmp(pos, "aifs") == 0) {
539 6 : v = atoi(val);
540 6 : if (v < 1 || v > 255) {
541 2 : wpa_printf(MSG_ERROR, "Invalid AIFS value %d", v);
542 2 : return -1;
543 : }
544 4 : ac->aifs = v;
545 35 : } else if (os_strcmp(pos, "cwmin") == 0) {
546 6 : v = atoi(val);
547 6 : if (v < 0 || v > 15) {
548 2 : wpa_printf(MSG_ERROR, "Invalid cwMin value %d", v);
549 2 : return -1;
550 : }
551 4 : ac->cwmin = v;
552 29 : } else if (os_strcmp(pos, "cwmax") == 0) {
553 6 : v = atoi(val);
554 6 : if (v < 0 || v > 15) {
555 2 : wpa_printf(MSG_ERROR, "Invalid cwMax value %d", v);
556 2 : return -1;
557 : }
558 4 : ac->cwmax = v;
559 23 : } else if (os_strcmp(pos, "txop_limit") == 0) {
560 6 : v = atoi(val);
561 6 : if (v < 0 || v > 0xffff) {
562 2 : wpa_printf(MSG_ERROR, "Invalid txop value %d", v);
563 2 : return -1;
564 : }
565 4 : ac->txop_limit = v;
566 17 : } else if (os_strcmp(pos, "acm") == 0) {
567 16 : v = atoi(val);
568 16 : if (v < 0 || v > 1) {
569 2 : wpa_printf(MSG_ERROR, "Invalid acm value %d", v);
570 2 : return -1;
571 : }
572 14 : ac->admission_control_mandatory = v;
573 : } else {
574 1 : wpa_printf(MSG_ERROR, "Unknown wmm_ac_ field '%s'", pos);
575 1 : return -1;
576 : }
577 :
578 30 : return 0;
579 : }
580 :
581 :
582 686771 : enum hostapd_hw_mode ieee80211_freq_to_chan(int freq, u8 *channel)
583 : {
584 : u8 op_class;
585 :
586 686771 : return ieee80211_freq_to_channel_ext(freq, 0, VHT_CHANWIDTH_USE_HT,
587 : &op_class, channel);
588 : }
589 :
590 :
591 : /**
592 : * ieee80211_freq_to_channel_ext - Convert frequency into channel info
593 : * for HT40 and VHT. DFS channels are not covered.
594 : * @freq: Frequency (MHz) to convert
595 : * @sec_channel: 0 = non-HT40, 1 = sec. channel above, -1 = sec. channel below
596 : * @vht: VHT channel width (VHT_CHANWIDTH_*)
597 : * @op_class: Buffer for returning operating class
598 : * @channel: Buffer for returning channel number
599 : * Returns: hw_mode on success, NUM_HOSTAPD_MODES on failure
600 : */
601 707745 : enum hostapd_hw_mode ieee80211_freq_to_channel_ext(unsigned int freq,
602 : int sec_channel, int vht,
603 : u8 *op_class, u8 *channel)
604 : {
605 : u8 vht_opclass;
606 :
607 : /* TODO: more operating classes */
608 :
609 707745 : if (sec_channel > 1 || sec_channel < -1)
610 1 : return NUM_HOSTAPD_MODES;
611 :
612 707744 : if (freq >= 2412 && freq <= 2472) {
613 255168 : if ((freq - 2407) % 5)
614 3 : return NUM_HOSTAPD_MODES;
615 :
616 255165 : if (vht)
617 9 : return NUM_HOSTAPD_MODES;
618 :
619 : /* 2.407 GHz, channels 1..13 */
620 255156 : if (sec_channel == 1)
621 22 : *op_class = 83;
622 255134 : else if (sec_channel == -1)
623 23 : *op_class = 84;
624 : else
625 255111 : *op_class = 81;
626 :
627 255156 : *channel = (freq - 2407) / 5;
628 :
629 255156 : return HOSTAPD_MODE_IEEE80211G;
630 : }
631 :
632 452576 : if (freq == 2484) {
633 17969 : if (sec_channel || vht)
634 0 : return NUM_HOSTAPD_MODES;
635 :
636 17969 : *op_class = 82; /* channel 14 */
637 17969 : *channel = 14;
638 :
639 17969 : return HOSTAPD_MODE_IEEE80211B;
640 : }
641 :
642 434607 : if (freq >= 4900 && freq < 5000) {
643 2 : if ((freq - 4000) % 5)
644 1 : return NUM_HOSTAPD_MODES;
645 1 : *channel = (freq - 4000) / 5;
646 1 : *op_class = 0; /* TODO */
647 1 : return HOSTAPD_MODE_IEEE80211A;
648 : }
649 :
650 434605 : switch (vht) {
651 : case VHT_CHANWIDTH_80MHZ:
652 39 : vht_opclass = 128;
653 39 : break;
654 : case VHT_CHANWIDTH_160MHZ:
655 8 : vht_opclass = 129;
656 8 : break;
657 : case VHT_CHANWIDTH_80P80MHZ:
658 26 : vht_opclass = 130;
659 26 : break;
660 : default:
661 434532 : vht_opclass = 0;
662 434532 : break;
663 : }
664 :
665 : /* 5 GHz, channels 36..48 */
666 434605 : if (freq >= 5180 && freq <= 5240) {
667 73865 : if ((freq - 5000) % 5)
668 1 : return NUM_HOSTAPD_MODES;
669 :
670 73864 : if (vht_opclass)
671 60 : *op_class = vht_opclass;
672 73804 : else if (sec_channel == 1)
673 52 : *op_class = 116;
674 73752 : else if (sec_channel == -1)
675 8 : *op_class = 117;
676 : else
677 73744 : *op_class = 115;
678 :
679 73864 : *channel = (freq - 5000) / 5;
680 :
681 73864 : return HOSTAPD_MODE_IEEE80211A;
682 : }
683 :
684 : /* 5 GHz, channels 149..169 */
685 360740 : if (freq >= 5745 && freq <= 5845) {
686 89861 : if ((freq - 5000) % 5)
687 1 : return NUM_HOSTAPD_MODES;
688 :
689 89860 : if (vht_opclass)
690 7 : *op_class = vht_opclass;
691 89853 : else if (sec_channel == 1)
692 10 : *op_class = 126;
693 89843 : else if (sec_channel == -1)
694 2 : *op_class = 127;
695 89841 : else if (freq <= 5805)
696 71877 : *op_class = 124;
697 : else
698 17964 : *op_class = 125;
699 :
700 89860 : *channel = (freq - 5000) / 5;
701 :
702 89860 : return HOSTAPD_MODE_IEEE80211A;
703 : }
704 :
705 : /* 5 GHz, channels 100..140 */
706 270879 : if (freq >= 5000 && freq <= 5700) {
707 269429 : if ((freq - 5000) % 5)
708 1 : return NUM_HOSTAPD_MODES;
709 :
710 269428 : if (vht_opclass)
711 6 : *op_class = vht_opclass;
712 269422 : else if (sec_channel == 1)
713 3 : *op_class = 122;
714 269419 : else if (sec_channel == -1)
715 1 : *op_class = 123;
716 : else
717 269418 : *op_class = 121;
718 :
719 269428 : *channel = (freq - 5000) / 5;
720 :
721 269428 : return HOSTAPD_MODE_IEEE80211A;
722 : }
723 :
724 1450 : if (freq >= 5000 && freq < 5900) {
725 2 : if ((freq - 5000) % 5)
726 1 : return NUM_HOSTAPD_MODES;
727 1 : *channel = (freq - 5000) / 5;
728 1 : *op_class = 0; /* TODO */
729 1 : return HOSTAPD_MODE_IEEE80211A;
730 : }
731 :
732 : /* 56.16 GHz, channel 1..4 */
733 1448 : if (freq >= 56160 + 2160 * 1 && freq <= 56160 + 2160 * 4) {
734 900 : if (sec_channel || vht)
735 0 : return NUM_HOSTAPD_MODES;
736 :
737 900 : *channel = (freq - 56160) / 2160;
738 900 : *op_class = 180;
739 :
740 900 : return HOSTAPD_MODE_IEEE80211AD;
741 : }
742 :
743 548 : return NUM_HOSTAPD_MODES;
744 : }
745 :
746 :
747 : static const char *const us_op_class_cc[] = {
748 : "US", "CA", NULL
749 : };
750 :
751 : static const char *const eu_op_class_cc[] = {
752 : "AL", "AM", "AT", "AZ", "BA", "BE", "BG", "BY", "CH", "CY", "CZ", "DE",
753 : "DK", "EE", "EL", "ES", "FI", "FR", "GE", "HR", "HU", "IE", "IS", "IT",
754 : "LI", "LT", "LU", "LV", "MD", "ME", "MK", "MT", "NL", "NO", "PL", "PT",
755 : "RO", "RS", "RU", "SE", "SI", "SK", "TR", "UA", "UK", NULL
756 : };
757 :
758 : static const char *const jp_op_class_cc[] = {
759 : "JP", NULL
760 : };
761 :
762 : static const char *const cn_op_class_cc[] = {
763 : "CN", NULL
764 : };
765 :
766 :
767 414533 : static int country_match(const char *const cc[], const char *const country)
768 : {
769 : int i;
770 :
771 414533 : if (country == NULL)
772 414148 : return 0;
773 4351 : for (i = 0; cc[i]; i++) {
774 4041 : if (cc[i][0] == country[0] && cc[i][1] == country[1])
775 75 : return 1;
776 : }
777 :
778 310 : return 0;
779 : }
780 :
781 :
782 21 : static int ieee80211_chan_to_freq_us(u8 op_class, u8 chan)
783 : {
784 21 : switch (op_class) {
785 : case 12: /* channels 1..11 */
786 : case 32: /* channels 1..7; 40 MHz */
787 : case 33: /* channels 5..11; 40 MHz */
788 3 : if (chan < 1 || chan > 11)
789 2 : return -1;
790 1 : return 2407 + 5 * chan;
791 : case 1: /* channels 36,40,44,48 */
792 : case 2: /* channels 52,56,60,64; dfs */
793 : case 22: /* channels 36,44; 40 MHz */
794 : case 23: /* channels 52,60; 40 MHz */
795 : case 27: /* channels 40,48; 40 MHz */
796 : case 28: /* channels 56,64; 40 MHz */
797 3 : if (chan < 36 || chan > 64)
798 2 : return -1;
799 1 : return 5000 + 5 * chan;
800 : case 4: /* channels 100-144 */
801 : case 24: /* channels 100-140; 40 MHz */
802 3 : if (chan < 100 || chan > 144)
803 2 : return -1;
804 1 : return 5000 + 5 * chan;
805 : case 3: /* channels 149,153,157,161 */
806 : case 25: /* channels 149,157; 40 MHz */
807 : case 26: /* channels 149,157; 40 MHz */
808 : case 30: /* channels 153,161; 40 MHz */
809 : case 31: /* channels 153,161; 40 MHz */
810 3 : if (chan < 149 || chan > 161)
811 2 : return -1;
812 1 : return 5000 + 5 * chan;
813 : case 5: /* channels 149,153,157,161,165 */
814 3 : if (chan < 149 || chan > 165)
815 2 : return -1;
816 1 : return 5000 + 5 * chan;
817 : case 34: /* 60 GHz band, channels 1..3 */
818 3 : if (chan < 1 || chan > 3)
819 2 : return -1;
820 1 : return 56160 + 2160 * chan;
821 : }
822 3 : return -1;
823 : }
824 :
825 :
826 28 : static int ieee80211_chan_to_freq_eu(u8 op_class, u8 chan)
827 : {
828 28 : switch (op_class) {
829 : case 4: /* channels 1..13 */
830 : case 11: /* channels 1..9; 40 MHz */
831 : case 12: /* channels 5..13; 40 MHz */
832 3 : if (chan < 1 || chan > 13)
833 2 : return -1;
834 1 : return 2407 + 5 * chan;
835 : case 1: /* channels 36,40,44,48 */
836 : case 2: /* channels 52,56,60,64; dfs */
837 : case 5: /* channels 36,44; 40 MHz */
838 : case 6: /* channels 52,60; 40 MHz */
839 : case 8: /* channels 40,48; 40 MHz */
840 : case 9: /* channels 56,64; 40 MHz */
841 4 : if (chan < 36 || chan > 64)
842 2 : return -1;
843 2 : return 5000 + 5 * chan;
844 : case 3: /* channels 100-140 */
845 : case 7: /* channels 100-132; 40 MHz */
846 : case 10: /* channels 104-136; 40 MHz */
847 : case 16: /* channels 100-140 */
848 3 : if (chan < 100 || chan > 140)
849 2 : return -1;
850 1 : return 5000 + 5 * chan;
851 : case 17: /* channels 149,153,157,161,165,169 */
852 3 : if (chan < 149 || chan > 169)
853 2 : return -1;
854 1 : return 5000 + 5 * chan;
855 : case 18: /* 60 GHz band, channels 1..4 */
856 3 : if (chan < 1 || chan > 4)
857 2 : return -1;
858 1 : return 56160 + 2160 * chan;
859 : }
860 12 : return -1;
861 : }
862 :
863 :
864 15 : static int ieee80211_chan_to_freq_jp(u8 op_class, u8 chan)
865 : {
866 15 : switch (op_class) {
867 : case 30: /* channels 1..13 */
868 : case 56: /* channels 1..9; 40 MHz */
869 : case 57: /* channels 5..13; 40 MHz */
870 3 : if (chan < 1 || chan > 13)
871 2 : return -1;
872 1 : return 2407 + 5 * chan;
873 : case 31: /* channel 14 */
874 2 : if (chan != 14)
875 1 : return -1;
876 1 : return 2414 + 5 * chan;
877 : case 1: /* channels 34,38,42,46(old) or 36,40,44,48 */
878 : case 32: /* channels 52,56,60,64 */
879 : case 33: /* channels 52,56,60,64 */
880 : case 36: /* channels 36,44; 40 MHz */
881 : case 37: /* channels 52,60; 40 MHz */
882 : case 38: /* channels 52,60; 40 MHz */
883 : case 41: /* channels 40,48; 40 MHz */
884 : case 42: /* channels 56,64; 40 MHz */
885 : case 43: /* channels 56,64; 40 MHz */
886 3 : if (chan < 34 || chan > 64)
887 2 : return -1;
888 1 : return 5000 + 5 * chan;
889 : case 34: /* channels 100-140 */
890 : case 35: /* channels 100-140 */
891 : case 39: /* channels 100-132; 40 MHz */
892 : case 40: /* channels 100-132; 40 MHz */
893 : case 44: /* channels 104-136; 40 MHz */
894 : case 45: /* channels 104-136; 40 MHz */
895 : case 58: /* channels 100-140 */
896 3 : if (chan < 100 || chan > 140)
897 2 : return -1;
898 1 : return 5000 + 5 * chan;
899 : case 59: /* 60 GHz band, channels 1..4 */
900 3 : if (chan < 1 || chan > 3)
901 2 : return -1;
902 1 : return 56160 + 2160 * chan;
903 : }
904 1 : return -1;
905 : }
906 :
907 :
908 11 : static int ieee80211_chan_to_freq_cn(u8 op_class, u8 chan)
909 : {
910 11 : switch (op_class) {
911 : case 7: /* channels 1..13 */
912 : case 8: /* channels 1..9; 40 MHz */
913 : case 9: /* channels 5..13; 40 MHz */
914 3 : if (chan < 1 || chan > 13)
915 2 : return -1;
916 1 : return 2407 + 5 * chan;
917 : case 1: /* channels 36,40,44,48 */
918 : case 2: /* channels 52,56,60,64; dfs */
919 : case 4: /* channels 36,44; 40 MHz */
920 : case 5: /* channels 52,60; 40 MHz */
921 3 : if (chan < 36 || chan > 64)
922 2 : return -1;
923 1 : return 5000 + 5 * chan;
924 : case 3: /* channels 149,153,157,161,165 */
925 : case 6: /* channels 149,157; 40 MHz */
926 4 : if (chan < 149 || chan > 165)
927 2 : return -1;
928 2 : return 5000 + 5 * chan;
929 : }
930 1 : return -1;
931 : }
932 :
933 :
934 103621 : static int ieee80211_chan_to_freq_global(u8 op_class, u8 chan)
935 : {
936 : /* Table E-4 in IEEE Std 802.11-2012 - Global operating classes */
937 103621 : switch (op_class) {
938 : case 81:
939 : /* channels 1..13 */
940 101702 : if (chan < 1 || chan > 13)
941 4 : return -1;
942 101698 : return 2407 + 5 * chan;
943 : case 82:
944 : /* channel 14 */
945 3 : if (chan != 14)
946 1 : return -1;
947 2 : return 2414 + 5 * chan;
948 : case 83: /* channels 1..9; 40 MHz */
949 : case 84: /* channels 5..13; 40 MHz */
950 3 : if (chan < 1 || chan > 13)
951 2 : return -1;
952 1 : return 2407 + 5 * chan;
953 : case 115: /* channels 36,40,44,48; indoor only */
954 : case 116: /* channels 36,44; 40 MHz; indoor only */
955 : case 117: /* channels 40,48; 40 MHz; indoor only */
956 : case 118: /* channels 52,56,60,64; dfs */
957 : case 119: /* channels 52,60; 40 MHz; dfs */
958 : case 120: /* channels 56,64; 40 MHz; dfs */
959 511 : if (chan < 36 || chan > 64)
960 2 : return -1;
961 509 : return 5000 + 5 * chan;
962 : case 121: /* channels 100-140 */
963 : case 122: /* channels 100-142; 40 MHz */
964 : case 123: /* channels 104-136; 40 MHz */
965 3 : if (chan < 100 || chan > 140)
966 2 : return -1;
967 1 : return 5000 + 5 * chan;
968 : case 124: /* channels 149,153,157,161 */
969 : case 126: /* channels 149,157; 40 MHz */
970 : case 127: /* channels 153,161; 40 MHz */
971 530 : if (chan < 149 || chan > 161)
972 2 : return -1;
973 528 : return 5000 + 5 * chan;
974 : case 125: /* channels 149,153,157,161,165,169 */
975 323 : if (chan < 149 || chan > 169)
976 2 : return -1;
977 321 : return 5000 + 5 * chan;
978 : case 128: /* center freqs 42, 58, 106, 122, 138, 155; 80 MHz */
979 : case 130: /* center freqs 42, 58, 106, 122, 138, 155; 80 MHz */
980 495 : if (chan < 36 || chan > 161)
981 2 : return -1;
982 493 : return 5000 + 5 * chan;
983 : case 129: /* center freqs 50, 114; 160 MHz */
984 3 : if (chan < 50 || chan > 114)
985 2 : return -1;
986 1 : return 5000 + 5 * chan;
987 : case 180: /* 60 GHz band, channels 1..4 */
988 3 : if (chan < 1 || chan > 4)
989 2 : return -1;
990 1 : return 56160 + 2160 * chan;
991 : }
992 45 : return -1;
993 : }
994 :
995 : /**
996 : * ieee80211_chan_to_freq - Convert channel info to frequency
997 : * @country: Country code, if known; otherwise, global operating class is used
998 : * @op_class: Operating class
999 : * @chan: Channel number
1000 : * Returns: Frequency in MHz or -1 if the specified channel is unknown
1001 : */
1002 103642 : int ieee80211_chan_to_freq(const char *country, u8 op_class, u8 chan)
1003 : {
1004 : int freq;
1005 :
1006 103642 : if (country_match(us_op_class_cc, country)) {
1007 21 : freq = ieee80211_chan_to_freq_us(op_class, chan);
1008 21 : if (freq > 0)
1009 6 : return freq;
1010 : }
1011 :
1012 103636 : if (country_match(eu_op_class_cc, country)) {
1013 28 : freq = ieee80211_chan_to_freq_eu(op_class, chan);
1014 28 : if (freq > 0)
1015 6 : return freq;
1016 : }
1017 :
1018 103630 : if (country_match(jp_op_class_cc, country)) {
1019 15 : freq = ieee80211_chan_to_freq_jp(op_class, chan);
1020 15 : if (freq > 0)
1021 5 : return freq;
1022 : }
1023 :
1024 103625 : if (country_match(cn_op_class_cc, country)) {
1025 11 : freq = ieee80211_chan_to_freq_cn(op_class, chan);
1026 11 : if (freq > 0)
1027 4 : return freq;
1028 : }
1029 :
1030 103621 : return ieee80211_chan_to_freq_global(op_class, chan);
1031 : }
1032 :
1033 :
1034 907 : int ieee80211_is_dfs(int freq)
1035 : {
1036 : /* TODO: this could be more accurate to better cover all domains */
1037 907 : return (freq >= 5260 && freq <= 5320) || (freq >= 5500 && freq <= 5700);
1038 : }
1039 :
1040 :
1041 12060 : static int is_11b(u8 rate)
1042 : {
1043 12060 : return rate == 0x02 || rate == 0x04 || rate == 0x0b || rate == 0x16;
1044 : }
1045 :
1046 :
1047 1487 : int supp_rates_11b_only(struct ieee802_11_elems *elems)
1048 : {
1049 1487 : int num_11b = 0, num_others = 0;
1050 : int i;
1051 :
1052 1487 : if (elems->supp_rates == NULL && elems->ext_supp_rates == NULL)
1053 0 : return 0;
1054 :
1055 13383 : for (i = 0; elems->supp_rates && i < elems->supp_rates_len; i++) {
1056 11896 : if (is_11b(elems->supp_rates[i]))
1057 164 : num_11b++;
1058 : else
1059 11732 : num_others++;
1060 : }
1061 :
1062 3138 : for (i = 0; elems->ext_supp_rates && i < elems->ext_supp_rates_len;
1063 164 : i++) {
1064 164 : if (is_11b(elems->ext_supp_rates[i]))
1065 0 : num_11b++;
1066 : else
1067 164 : num_others++;
1068 : }
1069 :
1070 1487 : return num_11b > 0 && num_others == 0;
1071 : }
1072 :
1073 :
1074 131920 : const char * fc2str(u16 fc)
1075 : {
1076 131920 : u16 stype = WLAN_FC_GET_STYPE(fc);
1077 : #define C2S(x) case x: return #x;
1078 :
1079 131920 : switch (WLAN_FC_GET_TYPE(fc)) {
1080 : case WLAN_FC_TYPE_MGMT:
1081 131920 : switch (stype) {
1082 7072 : C2S(WLAN_FC_STYPE_ASSOC_REQ)
1083 4467 : C2S(WLAN_FC_STYPE_ASSOC_RESP)
1084 2953 : C2S(WLAN_FC_STYPE_REASSOC_REQ)
1085 339 : C2S(WLAN_FC_STYPE_REASSOC_RESP)
1086 9983 : C2S(WLAN_FC_STYPE_PROBE_REQ)
1087 5564 : C2S(WLAN_FC_STYPE_PROBE_RESP)
1088 0 : C2S(WLAN_FC_STYPE_BEACON)
1089 0 : C2S(WLAN_FC_STYPE_ATIM)
1090 2625 : C2S(WLAN_FC_STYPE_DISASSOC)
1091 13480 : C2S(WLAN_FC_STYPE_AUTH)
1092 12053 : C2S(WLAN_FC_STYPE_DEAUTH)
1093 73384 : C2S(WLAN_FC_STYPE_ACTION)
1094 : }
1095 0 : break;
1096 : case WLAN_FC_TYPE_CTRL:
1097 0 : switch (stype) {
1098 0 : C2S(WLAN_FC_STYPE_PSPOLL)
1099 0 : C2S(WLAN_FC_STYPE_RTS)
1100 0 : C2S(WLAN_FC_STYPE_CTS)
1101 0 : C2S(WLAN_FC_STYPE_ACK)
1102 0 : C2S(WLAN_FC_STYPE_CFEND)
1103 0 : C2S(WLAN_FC_STYPE_CFENDACK)
1104 : }
1105 0 : break;
1106 : case WLAN_FC_TYPE_DATA:
1107 0 : switch (stype) {
1108 0 : C2S(WLAN_FC_STYPE_DATA)
1109 0 : C2S(WLAN_FC_STYPE_DATA_CFACK)
1110 0 : C2S(WLAN_FC_STYPE_DATA_CFPOLL)
1111 0 : C2S(WLAN_FC_STYPE_DATA_CFACKPOLL)
1112 0 : C2S(WLAN_FC_STYPE_NULLFUNC)
1113 0 : C2S(WLAN_FC_STYPE_CFACK)
1114 0 : C2S(WLAN_FC_STYPE_CFPOLL)
1115 0 : C2S(WLAN_FC_STYPE_CFACKPOLL)
1116 0 : C2S(WLAN_FC_STYPE_QOS_DATA)
1117 0 : C2S(WLAN_FC_STYPE_QOS_DATA_CFACK)
1118 0 : C2S(WLAN_FC_STYPE_QOS_DATA_CFPOLL)
1119 0 : C2S(WLAN_FC_STYPE_QOS_DATA_CFACKPOLL)
1120 0 : C2S(WLAN_FC_STYPE_QOS_NULL)
1121 0 : C2S(WLAN_FC_STYPE_QOS_CFPOLL)
1122 0 : C2S(WLAN_FC_STYPE_QOS_CFACKPOLL)
1123 : }
1124 0 : break;
1125 : }
1126 0 : return "WLAN_FC_TYPE_UNKNOWN";
1127 : #undef C2S
1128 : }
1129 :
1130 :
1131 318 : int mb_ies_info_by_ies(struct mb_ies_info *info, const u8 *ies_buf,
1132 : size_t ies_len)
1133 : {
1134 318 : os_memset(info, 0, sizeof(*info));
1135 :
1136 1272 : while (ies_buf && ies_len >= 2 &&
1137 318 : info->nof_ies < MAX_NOF_MB_IES_SUPPORTED) {
1138 318 : size_t len = 2 + ies_buf[1];
1139 :
1140 318 : if (len > ies_len) {
1141 0 : wpa_hexdump(MSG_DEBUG, "Truncated IEs",
1142 : ies_buf, ies_len);
1143 0 : return -1;
1144 : }
1145 :
1146 318 : if (ies_buf[0] == WLAN_EID_MULTI_BAND) {
1147 318 : wpa_printf(MSG_DEBUG, "MB IE of %zu bytes found", len);
1148 318 : info->ies[info->nof_ies].ie = ies_buf + 2;
1149 318 : info->ies[info->nof_ies].ie_len = ies_buf[1];
1150 318 : info->nof_ies++;
1151 : }
1152 :
1153 318 : ies_len -= len;
1154 318 : ies_buf += len;
1155 : }
1156 :
1157 318 : return 0;
1158 : }
1159 :
1160 :
1161 809 : struct wpabuf * mb_ies_by_info(struct mb_ies_info *info)
1162 : {
1163 809 : struct wpabuf *mb_ies = NULL;
1164 :
1165 : WPA_ASSERT(info != NULL);
1166 :
1167 809 : if (info->nof_ies) {
1168 : u8 i;
1169 806 : size_t mb_ies_size = 0;
1170 :
1171 1738 : for (i = 0; i < info->nof_ies; i++)
1172 932 : mb_ies_size += 2 + info->ies[i].ie_len;
1173 :
1174 806 : mb_ies = wpabuf_alloc(mb_ies_size);
1175 806 : if (mb_ies) {
1176 1736 : for (i = 0; i < info->nof_ies; i++) {
1177 931 : wpabuf_put_u8(mb_ies, WLAN_EID_MULTI_BAND);
1178 931 : wpabuf_put_u8(mb_ies, info->ies[i].ie_len);
1179 1862 : wpabuf_put_data(mb_ies,
1180 931 : info->ies[i].ie,
1181 931 : info->ies[i].ie_len);
1182 : }
1183 : }
1184 : }
1185 :
1186 809 : return mb_ies;
1187 : }
1188 :
1189 :
1190 : const struct oper_class_map global_op_class[] = {
1191 : { HOSTAPD_MODE_IEEE80211G, 81, 1, 13, 1, BW20, P2P_SUPP },
1192 : { HOSTAPD_MODE_IEEE80211G, 82, 14, 14, 1, BW20, NO_P2P_SUPP },
1193 :
1194 : /* Do not enable HT40 on 2.4 GHz for P2P use for now */
1195 : { HOSTAPD_MODE_IEEE80211G, 83, 1, 9, 1, BW40PLUS, NO_P2P_SUPP },
1196 : { HOSTAPD_MODE_IEEE80211G, 84, 5, 13, 1, BW40MINUS, NO_P2P_SUPP },
1197 :
1198 : { HOSTAPD_MODE_IEEE80211A, 115, 36, 48, 4, BW20, P2P_SUPP },
1199 : { HOSTAPD_MODE_IEEE80211A, 116, 36, 44, 8, BW40PLUS, P2P_SUPP },
1200 : { HOSTAPD_MODE_IEEE80211A, 117, 40, 48, 8, BW40MINUS, P2P_SUPP },
1201 : { HOSTAPD_MODE_IEEE80211A, 118, 52, 64, 4, BW20, NO_P2P_SUPP },
1202 : { HOSTAPD_MODE_IEEE80211A, 119, 52, 60, 8, BW40PLUS, NO_P2P_SUPP },
1203 : { HOSTAPD_MODE_IEEE80211A, 120, 56, 64, 8, BW40MINUS, NO_P2P_SUPP },
1204 : { HOSTAPD_MODE_IEEE80211A, 121, 100, 140, 4, BW20, NO_P2P_SUPP },
1205 : { HOSTAPD_MODE_IEEE80211A, 122, 100, 132, 8, BW40PLUS, NO_P2P_SUPP },
1206 : { HOSTAPD_MODE_IEEE80211A, 123, 104, 136, 8, BW40MINUS, NO_P2P_SUPP },
1207 : { HOSTAPD_MODE_IEEE80211A, 124, 149, 161, 4, BW20, P2P_SUPP },
1208 : { HOSTAPD_MODE_IEEE80211A, 125, 149, 169, 4, BW20, P2P_SUPP },
1209 : { HOSTAPD_MODE_IEEE80211A, 126, 149, 157, 8, BW40PLUS, P2P_SUPP },
1210 : { HOSTAPD_MODE_IEEE80211A, 127, 153, 161, 8, BW40MINUS, P2P_SUPP },
1211 :
1212 : /*
1213 : * IEEE P802.11ac/D7.0 Table E-4 actually talks about channel center
1214 : * frequency index 42, 58, 106, 122, 138, 155 with channel spacing of
1215 : * 80 MHz, but currently use the following definition for simplicity
1216 : * (these center frequencies are not actual channels, which makes
1217 : * wpas_p2p_allow_channel() fail). wpas_p2p_verify_80mhz() should take
1218 : * care of removing invalid channels.
1219 : */
1220 : { HOSTAPD_MODE_IEEE80211A, 128, 36, 161, 4, BW80, P2P_SUPP },
1221 : { HOSTAPD_MODE_IEEE80211A, 129, 50, 114, 16, BW160, P2P_SUPP },
1222 : { HOSTAPD_MODE_IEEE80211A, 130, 36, 161, 4, BW80P80, P2P_SUPP },
1223 : { HOSTAPD_MODE_IEEE80211AD, 180, 1, 4, 1, BW2160, P2P_SUPP },
1224 : { -1, 0, 0, 0, 0, BW20, NO_P2P_SUPP }
1225 : };
1226 :
1227 :
1228 3 : static enum phy_type ieee80211_phy_type_by_freq(int freq)
1229 : {
1230 : enum hostapd_hw_mode hw_mode;
1231 : u8 channel;
1232 :
1233 3 : hw_mode = ieee80211_freq_to_chan(freq, &channel);
1234 :
1235 3 : switch (hw_mode) {
1236 : case HOSTAPD_MODE_IEEE80211A:
1237 1 : return PHY_TYPE_OFDM;
1238 : case HOSTAPD_MODE_IEEE80211B:
1239 0 : return PHY_TYPE_HRDSSS;
1240 : case HOSTAPD_MODE_IEEE80211G:
1241 2 : return PHY_TYPE_ERP;
1242 : case HOSTAPD_MODE_IEEE80211AD:
1243 0 : return PHY_TYPE_DMG;
1244 : default:
1245 0 : return PHY_TYPE_UNSPECIFIED;
1246 : };
1247 : }
1248 :
1249 :
1250 : /* ieee80211_get_phy_type - Derive the phy type by freq and bandwidth */
1251 28 : enum phy_type ieee80211_get_phy_type(int freq, int ht, int vht)
1252 : {
1253 28 : if (vht)
1254 1 : return PHY_TYPE_VHT;
1255 27 : if (ht)
1256 24 : return PHY_TYPE_HT;
1257 :
1258 3 : return ieee80211_phy_type_by_freq(freq);
1259 : }
1260 :
1261 :
1262 : size_t global_op_class_size = ARRAY_SIZE(global_op_class);
1263 :
1264 :
1265 : /**
1266 : * get_ie - Fetch a specified information element from IEs buffer
1267 : * @ies: Information elements buffer
1268 : * @len: Information elements buffer length
1269 : * @eid: Information element identifier (WLAN_EID_*)
1270 : * Returns: Pointer to the information element (id field) or %NULL if not found
1271 : *
1272 : * This function returns the first matching information element in the IEs
1273 : * buffer or %NULL in case the element is not found.
1274 : */
1275 110957 : const u8 * get_ie(const u8 *ies, size_t len, u8 eid)
1276 : {
1277 : const u8 *end;
1278 :
1279 110957 : if (!ies)
1280 0 : return NULL;
1281 :
1282 110957 : end = ies + len;
1283 :
1284 905176 : while (end - ies > 1) {
1285 754939 : if (2 + ies[1] > end - ies)
1286 13 : break;
1287 :
1288 754926 : if (ies[0] == eid)
1289 71664 : return ies;
1290 :
1291 683262 : ies += 2 + ies[1];
1292 : }
1293 :
1294 39293 : return NULL;
1295 : }
1296 :
1297 :
1298 153 : size_t mbo_add_ie(u8 *buf, size_t len, const u8 *attr, size_t attr_len)
1299 : {
1300 : /*
1301 : * MBO IE requires 6 bytes without the attributes: EID (1), length (1),
1302 : * OUI (3), OUI type (1).
1303 : */
1304 153 : if (len < 6 + attr_len) {
1305 0 : wpa_printf(MSG_DEBUG,
1306 : "MBO: Not enough room in buffer for MBO IE: buf len = %zu, attr_len = %zu",
1307 : len, attr_len);
1308 0 : return 0;
1309 : }
1310 :
1311 153 : *buf++ = WLAN_EID_VENDOR_SPECIFIC;
1312 153 : *buf++ = attr_len + 4;
1313 153 : WPA_PUT_BE24(buf, OUI_WFA);
1314 153 : buf += 3;
1315 153 : *buf++ = MBO_OUI_TYPE;
1316 153 : os_memcpy(buf, attr, attr_len);
1317 :
1318 153 : return 6 + attr_len;
1319 : }
|
