1 /*
2 * Operating classes
3 * Copyright(c) 2015 Intel Deutschland GmbH
4 * Contact Information:
5 * Intel Linux Wireless <ilw@linux.intel.com>
6 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
7 *
8 * This software may be distributed under the terms of the BSD license.
9 * See README for more details.
10 */
11
12 #include "utils/includes.h"
13
14 #include "utils/common.h"
15 #include "common/ieee802_11_common.h"
16 #include "wpa_supplicant_i.h"
17 #include "bss.h"
18
19
allow_channel(struct hostapd_hw_modes * mode,u8 op_class,u8 chan,unsigned int * flags)20 static enum chan_allowed allow_channel(struct hostapd_hw_modes *mode,
21 u8 op_class, u8 chan,
22 unsigned int *flags)
23 {
24 int i;
25 bool is_6ghz = is_6ghz_op_class(op_class);
26
27 for (i = 0; i < mode->num_channels; i++) {
28 bool chan_is_6ghz;
29
30 chan_is_6ghz = is_6ghz_freq(mode->channels[i].freq);
31 if (is_6ghz == chan_is_6ghz && mode->channels[i].chan == chan)
32 break;
33 }
34
35 if (i == mode->num_channels ||
36 (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED))
37 return NOT_ALLOWED;
38
39 if (flags)
40 *flags = mode->channels[i].flag;
41
42 if (mode->channels[i].flag & HOSTAPD_CHAN_NO_IR)
43 return NO_IR;
44
45 return ALLOWED;
46 }
47
48
get_center_80mhz(struct hostapd_hw_modes * mode,u8 channel,const u8 * center_channels,size_t num_chan)49 static int get_center_80mhz(struct hostapd_hw_modes *mode, u8 channel,
50 const u8 *center_channels, size_t num_chan)
51 {
52 size_t i;
53
54 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
55 return 0;
56
57 for (i = 0; i < num_chan; i++) {
58 /*
59 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48),
60 * so the center channel is 6 channels away from the start/end.
61 */
62 if (channel >= center_channels[i] - 6 &&
63 channel <= center_channels[i] + 6)
64 return center_channels[i];
65 }
66
67 return 0;
68 }
69
70
verify_80mhz(struct hostapd_hw_modes * mode,u8 op_class,u8 channel)71 static enum chan_allowed verify_80mhz(struct hostapd_hw_modes *mode,
72 u8 op_class, u8 channel)
73 {
74 u8 center_chan;
75 unsigned int i;
76 unsigned int no_ir = 0;
77 const u8 *center_channels;
78 size_t num_chan;
79 const u8 center_channels_5ghz[] = { 42, 58, 106, 122, 138, 155, 171 };
80 const u8 center_channels_6ghz[] = { 7, 23, 39, 55, 71, 87, 103, 119,
81 135, 151, 167, 183, 199, 215 };
82
83 if (is_6ghz_op_class(op_class)) {
84 center_channels = center_channels_6ghz;
85 num_chan = ARRAY_SIZE(center_channels_6ghz);
86 } else {
87 center_channels = center_channels_5ghz;
88 num_chan = ARRAY_SIZE(center_channels_5ghz);
89 }
90
91 center_chan = get_center_80mhz(mode, channel, center_channels,
92 num_chan);
93 if (!center_chan)
94 return NOT_ALLOWED;
95
96 /* check all the channels are available */
97 for (i = 0; i < 4; i++) {
98 unsigned int flags;
99 u8 adj_chan = center_chan - 6 + i * 4;
100
101 if (allow_channel(mode, op_class, adj_chan, &flags) ==
102 NOT_ALLOWED)
103 return NOT_ALLOWED;
104
105 if (!(flags & HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL))
106 return NOT_ALLOWED;
107
108 if (flags & HOSTAPD_CHAN_NO_IR)
109 no_ir = 1;
110 }
111
112 if (no_ir)
113 return NO_IR;
114
115 return ALLOWED;
116 }
117
118
get_center_160mhz(struct hostapd_hw_modes * mode,u8 channel,const u8 * center_channels,size_t num_chan)119 static int get_center_160mhz(struct hostapd_hw_modes *mode, u8 channel,
120 const u8 *center_channels, size_t num_chan)
121 {
122 unsigned int i;
123
124 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
125 return 0;
126
127 for (i = 0; i < num_chan; i++) {
128 /*
129 * In 160 MHz, the bandwidth "spans" 28 channels (e.g., 36-64),
130 * so the center channel is 14 channels away from the start/end.
131 */
132 if (channel >= center_channels[i] - 14 &&
133 channel <= center_channels[i] + 14)
134 return center_channels[i];
135 }
136
137 return 0;
138 }
139
140
verify_160mhz(struct hostapd_hw_modes * mode,u8 op_class,u8 channel)141 static enum chan_allowed verify_160mhz(struct hostapd_hw_modes *mode,
142 u8 op_class, u8 channel)
143 {
144 u8 center_chan;
145 unsigned int i;
146 unsigned int no_ir = 0;
147 const u8 *center_channels;
148 size_t num_chan;
149 const u8 center_channels_5ghz[] = { 50, 114, 163 };
150 const u8 center_channels_6ghz[] = { 15, 47, 79, 111, 143, 175, 207 };
151
152 if (is_6ghz_op_class(op_class)) {
153 center_channels = center_channels_6ghz;
154 num_chan = ARRAY_SIZE(center_channels_6ghz);
155 } else {
156 center_channels = center_channels_5ghz;
157 num_chan = ARRAY_SIZE(center_channels_5ghz);
158 }
159
160 center_chan = get_center_160mhz(mode, channel, center_channels,
161 num_chan);
162 if (!center_chan)
163 return NOT_ALLOWED;
164
165 /* Check all the channels are available */
166 for (i = 0; i < 8; i++) {
167 unsigned int flags;
168 u8 adj_chan = center_chan - 14 + i * 4;
169
170 if (allow_channel(mode, op_class, adj_chan, &flags) ==
171 NOT_ALLOWED)
172 return NOT_ALLOWED;
173
174 if (!(flags & HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL) ||
175 !(flags & HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL))
176 return NOT_ALLOWED;
177
178 if (flags & HOSTAPD_CHAN_NO_IR)
179 no_ir = 1;
180 }
181
182 if (no_ir)
183 return NO_IR;
184
185 return ALLOWED;
186 }
187
188
get_center_320mhz(struct hostapd_hw_modes * mode,u8 channel,const u8 * center_channels,size_t num_chan)189 static int get_center_320mhz(struct hostapd_hw_modes *mode, u8 channel,
190 const u8 *center_channels, size_t num_chan)
191 {
192 unsigned int i;
193
194 if (mode->mode != HOSTAPD_MODE_IEEE80211A || !mode->is_6ghz)
195 return 0;
196
197 for (i = 0; i < num_chan; i++) {
198 /*
199 * In 320 MHz, the bandwidth "spans" 60 channels (e.g., 65-125),
200 * so the center channel is 30 channels away from the start/end.
201 */
202 if (channel >= center_channels[i] - 30 &&
203 channel <= center_channels[i] + 30)
204 return center_channels[i];
205 }
206
207 return 0;
208 }
209
210
verify_320mhz(struct hostapd_hw_modes * mode,u8 op_class,u8 channel)211 static enum chan_allowed verify_320mhz(struct hostapd_hw_modes *mode,
212 u8 op_class, u8 channel)
213 {
214 u8 center_chan;
215 unsigned int i;
216 bool no_ir = false;
217 const u8 *center_channels;
218 size_t num_chan;
219 const u8 center_channels_6ghz[] = { 31, 63, 95, 127, 159, 191 };
220
221 center_channels = center_channels_6ghz;
222 num_chan = ARRAY_SIZE(center_channels_6ghz);
223
224 center_chan = get_center_320mhz(mode, channel, center_channels,
225 num_chan);
226 if (!center_chan)
227 return NOT_ALLOWED;
228
229 /* Check all the channels are available */
230 for (i = 0; i < 16; i++) {
231 unsigned int flags;
232 u8 adj_chan = center_chan - 30 + i * 4;
233
234 if (allow_channel(mode, op_class, adj_chan, &flags) ==
235 NOT_ALLOWED)
236 return NOT_ALLOWED;
237
238 if (!(flags & HOSTAPD_CHAN_EHT_320MHZ_SUBCHANNEL))
239 return NOT_ALLOWED;
240
241 if (flags & HOSTAPD_CHAN_NO_IR)
242 no_ir = true;
243 }
244
245 if (no_ir)
246 return NO_IR;
247
248 return ALLOWED;
249 }
250
251
verify_channel(struct hostapd_hw_modes * mode,u8 op_class,u8 channel,u8 bw)252 enum chan_allowed verify_channel(struct hostapd_hw_modes *mode, u8 op_class,
253 u8 channel, u8 bw)
254 {
255 unsigned int flag = 0;
256 enum chan_allowed res, res2;
257
258 res2 = res = allow_channel(mode, op_class, channel, &flag);
259 if (bw == BW40MINUS || (bw == BW40 && (((channel - 1) / 4) % 2))) {
260 if (!(flag & HOSTAPD_CHAN_HT40MINUS))
261 return NOT_ALLOWED;
262 res2 = allow_channel(mode, op_class, channel - 4, NULL);
263 } else if (bw == BW40PLUS) {
264 if (!(flag & HOSTAPD_CHAN_HT40PLUS))
265 return NOT_ALLOWED;
266 res2 = allow_channel(mode, op_class, channel + 4, NULL);
267 } else if (is_6ghz_op_class(op_class) && bw == BW40) {
268 if (get_6ghz_sec_channel(channel) < 0)
269 res2 = allow_channel(mode, op_class, channel - 4, NULL);
270 else
271 res2 = allow_channel(mode, op_class, channel + 4, NULL);
272 } else if (bw == BW80) {
273 /*
274 * channel is a center channel and as such, not necessarily a
275 * valid 20 MHz channels. Override earlier allow_channel()
276 * result and use only the 80 MHz specific version.
277 */
278 res2 = res = verify_80mhz(mode, op_class, channel);
279 } else if (bw == BW160) {
280 /*
281 * channel is a center channel and as such, not necessarily a
282 * valid 20 MHz channels. Override earlier allow_channel()
283 * result and use only the 160 MHz specific version.
284 */
285 res2 = res = verify_160mhz(mode, op_class, channel);
286 } else if (bw == BW80P80) {
287 /*
288 * channel is a center channel and as such, not necessarily a
289 * valid 20 MHz channels. Override earlier allow_channel()
290 * result and use only the 80 MHz specific version.
291 */
292 res2 = res = verify_80mhz(mode, op_class, channel);
293 } else if (bw == BW320) {
294 /*
295 * channel is a center channel and as such, not necessarily a
296 * valid 20 MHz channels. Override earlier allow_channel()
297 * result and use only the 320 MHz specific version.
298 */
299 res2= res = verify_320mhz(mode, op_class, channel);
300 }
301
302 if (res == NOT_ALLOWED || res2 == NOT_ALLOWED)
303 return NOT_ALLOWED;
304
305 if (res == NO_IR || res2 == NO_IR)
306 return NO_IR;
307
308 return ALLOWED;
309 }
310
311
wpas_op_class_supported(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid,const struct oper_class_map * op_class)312 static int wpas_op_class_supported(struct wpa_supplicant *wpa_s,
313 struct wpa_ssid *ssid,
314 const struct oper_class_map *op_class)
315 {
316 int chan;
317 size_t i;
318 struct hostapd_hw_modes *mode;
319 int found;
320 int z;
321 int freq2 = 0;
322 int freq5 = 0;
323 bool freq6 = false;
324
325 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, op_class->mode,
326 is_6ghz_op_class(op_class->op_class));
327 if (!mode)
328 return 0;
329
330 /* If we are configured to disable certain things, take that into
331 * account here. */
332 if (ssid && ssid->freq_list && ssid->freq_list[0]) {
333 for (z = 0; ; z++) {
334 int f = ssid->freq_list[z];
335
336 if (f == 0)
337 break; /* end of list */
338 if (is_6ghz_freq(f))
339 freq6 = true;
340 else if (f > 4000 && f < 6000)
341 freq5 = 1;
342 else if (f > 2400 && f < 2500)
343 freq2 = 1;
344 }
345 } else {
346 /* No frequencies specified, can use anything hardware supports.
347 */
348 freq2 = freq5 = 1;
349 freq6 = true;
350 }
351
352 if (is_6ghz_op_class(op_class->op_class) && !freq6)
353 return 0;
354 if (op_class->op_class >= 115 && op_class->op_class <= 130 && !freq5)
355 return 0;
356 if (op_class->op_class >= 81 && op_class->op_class <= 84 && !freq2)
357 return 0;
358
359 #ifdef CONFIG_HT_OVERRIDES
360 if (ssid && ssid->disable_ht) {
361 switch (op_class->op_class) {
362 case 83:
363 case 84:
364 case 104:
365 case 105:
366 case 116:
367 case 117:
368 case 119:
369 case 120:
370 case 122:
371 case 123:
372 case 126:
373 case 127:
374 case 128:
375 case 129:
376 case 130:
377 /* Disable >= 40 MHz channels if HT is disabled */
378 return 0;
379 }
380 }
381 #endif /* CONFIG_HT_OVERRIDES */
382
383 #ifdef CONFIG_VHT_OVERRIDES
384 if (ssid && ssid->disable_vht) {
385 if (op_class->op_class >= 128 && op_class->op_class <= 130) {
386 /* Disable >= 80 MHz channels if VHT is disabled */
387 return 0;
388 }
389 }
390 #endif /* CONFIG_VHT_OVERRIDES */
391
392 if (op_class->op_class == 128) {
393 u8 channels[] = { 42, 58, 106, 122, 138, 155, 171 };
394
395 for (i = 0; i < ARRAY_SIZE(channels); i++) {
396 if (verify_channel(mode, op_class->op_class,
397 channels[i], op_class->bw) !=
398 NOT_ALLOWED)
399 return 1;
400 }
401
402 return 0;
403 }
404
405 if (op_class->op_class == 129) {
406 /* Check if either 160 MHz channels is allowed */
407 return verify_channel(mode, op_class->op_class, 50,
408 op_class->bw) != NOT_ALLOWED ||
409 verify_channel(mode, op_class->op_class, 114,
410 op_class->bw) != NOT_ALLOWED ||
411 verify_channel(mode, op_class->op_class, 163,
412 op_class->bw) != NOT_ALLOWED;
413 }
414
415 if (op_class->op_class == 130) {
416 /* Need at least two non-contiguous 80 MHz segments */
417 found = 0;
418
419 if (verify_channel(mode, op_class->op_class, 42,
420 op_class->bw) != NOT_ALLOWED ||
421 verify_channel(mode, op_class->op_class, 58,
422 op_class->bw) != NOT_ALLOWED)
423 found++;
424 if (verify_channel(mode, op_class->op_class, 106,
425 op_class->bw) != NOT_ALLOWED ||
426 verify_channel(mode, op_class->op_class, 122,
427 op_class->bw) != NOT_ALLOWED ||
428 verify_channel(mode, op_class->op_class, 138,
429 op_class->bw) != NOT_ALLOWED ||
430 verify_channel(mode, op_class->op_class, 155,
431 op_class->bw) != NOT_ALLOWED ||
432 verify_channel(mode, op_class->op_class, 171,
433 op_class->bw) != NOT_ALLOWED)
434 found++;
435 if (verify_channel(mode, op_class->op_class, 106,
436 op_class->bw) != NOT_ALLOWED &&
437 verify_channel(mode, op_class->op_class, 138,
438 op_class->bw) != NOT_ALLOWED)
439 found++;
440 if (verify_channel(mode, op_class->op_class, 122,
441 op_class->bw) != NOT_ALLOWED &&
442 verify_channel(mode, op_class->op_class, 155,
443 op_class->bw) != NOT_ALLOWED)
444 found++;
445 if (verify_channel(mode, op_class->op_class, 138,
446 op_class->bw) != NOT_ALLOWED &&
447 verify_channel(mode, op_class->op_class, 171,
448 op_class->bw) != NOT_ALLOWED)
449 found++;
450
451 if (found >= 2)
452 return 1;
453
454 return 0;
455 }
456
457 if (op_class->op_class == 135) {
458 /* Need at least two 80 MHz segments which do not fall under the
459 * same 160 MHz segment to support 80+80 in 6 GHz.
460 */
461 int first_seg = 0;
462 int curr_seg = 0;
463
464 for (chan = op_class->min_chan; chan <= op_class->max_chan;
465 chan += op_class->inc) {
466 curr_seg++;
467 if (verify_channel(mode, op_class->op_class, chan,
468 op_class->bw) != NOT_ALLOWED) {
469 if (!first_seg) {
470 first_seg = curr_seg;
471 continue;
472 }
473
474 /* Supported if at least two non-consecutive 80
475 * MHz segments allowed.
476 */
477 if ((curr_seg - first_seg) > 1)
478 return 1;
479
480 /* Supported even if the 80 MHz segments are
481 * consecutive when they do not fall under the
482 * same 160 MHz segment.
483 */
484 if ((first_seg % 2) == 0)
485 return 1;
486 }
487 }
488
489 return 0;
490 }
491
492 found = 0;
493 for (chan = op_class->min_chan; chan <= op_class->max_chan;
494 chan += op_class->inc) {
495 if (verify_channel(mode, op_class->op_class, chan,
496 op_class->bw) != NOT_ALLOWED) {
497 found = 1;
498 break;
499 }
500 }
501
502 return found;
503 }
504
505
wpas_sta_secondary_channel_offset(struct wpa_bss * bss,u8 * current,u8 * channel)506 static int wpas_sta_secondary_channel_offset(struct wpa_bss *bss, u8 *current,
507 u8 *channel)
508 {
509
510 const u8 *ies;
511 u8 phy_type;
512 size_t ies_len;
513
514 if (!bss)
515 return -1;
516 ies = wpa_bss_ie_ptr(bss);
517 ies_len = bss->ie_len ? bss->ie_len : bss->beacon_ie_len;
518 return wpas_get_op_chan_phy(bss->freq, ies, ies_len, current,
519 channel, &phy_type);
520 }
521
522
wpas_supp_op_class_ie(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid,struct wpa_bss * bss,u8 * pos,size_t len)523 size_t wpas_supp_op_class_ie(struct wpa_supplicant *wpa_s,
524 struct wpa_ssid *ssid,
525 struct wpa_bss *bss, u8 *pos, size_t len)
526 {
527 struct wpabuf *buf;
528 u8 op, current, chan;
529 u8 *ie_len;
530 size_t res;
531 bool op128 = false, op130 = false, op133 = false, op135 = false;
532
533 /*
534 * Determine the current operating class correct mode based on
535 * advertised BSS capabilities, if available. Fall back to a less
536 * accurate guess based on frequency if the needed IEs are not available
537 * or used.
538 */
539 if (wpas_sta_secondary_channel_offset(bss, ¤t, &chan) < 0 &&
540 ieee80211_freq_to_channel_ext(bss->freq, 0,
541 CONF_OPER_CHWIDTH_USE_HT, ¤t,
542 &chan) == NUM_HOSTAPD_MODES)
543 return 0;
544
545 /*
546 * Need 3 bytes for EID, length, and current operating class, plus
547 * 1 byte for every other supported operating class.
548 */
549 buf = wpabuf_alloc(global_op_class_size + 3);
550 if (!buf)
551 return 0;
552
553 wpabuf_put_u8(buf, WLAN_EID_SUPPORTED_OPERATING_CLASSES);
554 /* Will set the length later, putting a placeholder */
555 ie_len = wpabuf_put(buf, 1);
556 wpabuf_put_u8(buf, current);
557
558 for (op = 0; global_op_class[op].op_class; op++) {
559 bool supp;
560 u8 op_class = global_op_class[op].op_class;
561
562 supp = wpas_op_class_supported(wpa_s, ssid,
563 &global_op_class[op]);
564 if (!supp)
565 continue;
566 switch (op_class) {
567 case 128:
568 op128 = true;
569 break;
570 case 130:
571 op130 = true;
572 break;
573 case 133:
574 op133 = true;
575 break;
576 case 135:
577 op135 = true;
578 break;
579 }
580 if (is_80plus_op_class(op_class))
581 continue;
582
583 /* Add a 1-octet operating class to the Operating Class field */
584 wpabuf_put_u8(buf, global_op_class[op].op_class);
585 }
586
587 /* Add the 2-octet operating classes (i.e., 80+80 MHz cases), if any */
588 if ((op128 && op130) || (op133 && op135)) {
589 /* Operating Class Duple Sequence field */
590
591 /* Zero Delimiter */
592 wpabuf_put_u8(buf, 0);
593
594 /* Operating Class Duple List */
595 if (op128 && op130) {
596 wpabuf_put_u8(buf, 130);
597 wpabuf_put_u8(buf, 128);
598 }
599 if (op133 && op135) {
600 wpabuf_put_u8(buf, 135);
601 wpabuf_put_u8(buf, 133);
602 }
603 }
604
605 *ie_len = wpabuf_len(buf) - 2;
606 if (*ie_len < 2) {
607 wpa_printf(MSG_DEBUG,
608 "No supported operating classes IE to add");
609 res = 0;
610 } else if (wpabuf_len(buf) > len) {
611 wpa_printf(MSG_ERROR,
612 "Supported operating classes IE exceeds maximum buffer length");
613 res = 0;
614 } else {
615 os_memcpy(pos, wpabuf_head(buf), wpabuf_len(buf));
616 res = wpabuf_len(buf);
617 wpa_hexdump_buf(MSG_DEBUG,
618 "Added supported operating classes IE", buf);
619 }
620
621 wpabuf_free(buf);
622 return res;
623 }
624
625
wpas_supp_op_classes(struct wpa_supplicant * wpa_s)626 int * wpas_supp_op_classes(struct wpa_supplicant *wpa_s)
627 {
628 int op;
629 unsigned int pos, max_num = 0;
630 int *classes;
631
632 for (op = 0; global_op_class[op].op_class; op++)
633 max_num++;
634 classes = os_zalloc((max_num + 1) * sizeof(int));
635 if (!classes)
636 return NULL;
637
638 for (op = 0, pos = 0; global_op_class[op].op_class; op++) {
639 if (wpas_op_class_supported(wpa_s, NULL, &global_op_class[op]))
640 classes[pos++] = global_op_class[op].op_class;
641 }
642
643 return classes;
644 }
645