projects/linux·blob master · refs

999 lines · 28.9 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * KUnit tests for inform_bss functions
4 *
5 * Copyright (C) 2023-2024 Intel Corporation
6 */
7#include <linux/ieee80211.h>
8#include <net/cfg80211.h>
9#include <kunit/test.h>
10#include <kunit/skbuff.h>
11#include "../core.h"
12#include "util.h"
13
14/* mac80211 helpers for element building */
15#include "../../mac80211/ieee80211_i.h"
16
17MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
18
19struct test_elem {
20 u8 id;
21 u8 len;
22 union {
23 u8 data[255];
24 struct {
25 u8 eid;
26 u8 edata[254];
27 };
28 };
29};
30
31static struct gen_new_ie_case {
32 const char *desc;
33 struct test_elem parent_ies[16];
34 struct test_elem child_ies[16];
35 struct test_elem result_ies[16];
36} gen_new_ie_cases[] = {
37 {
38 .desc = "ML not inherited",
39 .parent_ies = {
40 { .id = WLAN_EID_EXTENSION, .len = 255,
41 .eid = WLAN_EID_EXT_EHT_MULTI_LINK },
42 },
43 .child_ies = {
44 { .id = WLAN_EID_SSID, .len = 2 },
45 },
46 .result_ies = {
47 { .id = WLAN_EID_SSID, .len = 2 },
48 },
49 },
50 {
51 .desc = "fragments are ignored if previous len not 255",
52 .parent_ies = {
53 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 254, },
54 { .id = WLAN_EID_FRAGMENT, .len = 125, },
55 },
56 .child_ies = {
57 { .id = WLAN_EID_SSID, .len = 2 },
58 { .id = WLAN_EID_FRAGMENT, .len = 125, },
59 },
60 .result_ies = {
61 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 254, },
62 { .id = WLAN_EID_SSID, .len = 2 },
63 },
64 },
65 {
66 .desc = "fragments inherited",
67 .parent_ies = {
68 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
69 { .id = WLAN_EID_FRAGMENT, .len = 125, },
70 },
71 .child_ies = {
72 { .id = WLAN_EID_SSID, .len = 2 },
73 },
74 .result_ies = {
75 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
76 { .id = WLAN_EID_FRAGMENT, .len = 125, },
77 { .id = WLAN_EID_SSID, .len = 2 },
78 },
79 },
80 {
81 .desc = "fragments copied",
82 .parent_ies = {
83 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
84 { .id = WLAN_EID_FRAGMENT, .len = 125, },
85 },
86 .child_ies = {
87 { .id = WLAN_EID_SSID, .len = 2 },
88 },
89 .result_ies = {
90 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
91 { .id = WLAN_EID_FRAGMENT, .len = 125, },
92 { .id = WLAN_EID_SSID, .len = 2 },
93 },
94 },
95 {
96 .desc = "multiple elements inherit",
97 .parent_ies = {
98 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
99 { .id = WLAN_EID_FRAGMENT, .len = 125, },
100 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 123, },
101 },
102 .child_ies = {
103 { .id = WLAN_EID_SSID, .len = 2 },
104 },
105 .result_ies = {
106 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
107 { .id = WLAN_EID_FRAGMENT, .len = 125, },
108 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 123, },
109 { .id = WLAN_EID_SSID, .len = 2 },
110 },
111 },
112 {
113 .desc = "one child element overrides",
114 .parent_ies = {
115 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 255, },
116 { .id = WLAN_EID_FRAGMENT, .len = 125, },
117 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 123, },
118 },
119 .child_ies = {
120 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 127, },
121 { .id = WLAN_EID_SSID, .len = 2 },
122 },
123 .result_ies = {
124 { .id = WLAN_EID_REDUCED_NEIGHBOR_REPORT, .len = 127, },
125 { .id = WLAN_EID_SSID, .len = 2 },
126 },
127 },
128 {
129 .desc = "empty elements from parent",
130 .parent_ies = {
131 { .id = 0x1, .len = 0, },
132 { .id = WLAN_EID_EXTENSION, .len = 1, .eid = 0x10 },
133 },
134 .child_ies = {
135 },
136 .result_ies = {
137 { .id = 0x1, .len = 0, },
138 { .id = WLAN_EID_EXTENSION, .len = 1, .eid = 0x10 },
139 },
140 },
141 {
142 .desc = "empty elements from child",
143 .parent_ies = {
144 },
145 .child_ies = {
146 { .id = 0x1, .len = 0, },
147 { .id = WLAN_EID_EXTENSION, .len = 1, .eid = 0x10 },
148 },
149 .result_ies = {
150 { .id = 0x1, .len = 0, },
151 { .id = WLAN_EID_EXTENSION, .len = 1, .eid = 0x10 },
152 },
153 },
154 {
155 .desc = "invalid extended elements ignored",
156 .parent_ies = {
157 { .id = WLAN_EID_EXTENSION, .len = 0 },
158 },
159 .child_ies = {
160 { .id = WLAN_EID_EXTENSION, .len = 0 },
161 },
162 .result_ies = {
163 },
164 },
165 {
166 .desc = "multiple extended elements",
167 .parent_ies = {
168 { .id = WLAN_EID_EXTENSION, .len = 3,
169 .eid = WLAN_EID_EXT_HE_CAPABILITY },
170 { .id = WLAN_EID_EXTENSION, .len = 5,
171 .eid = WLAN_EID_EXT_ASSOC_DELAY_INFO },
172 { .id = WLAN_EID_EXTENSION, .len = 7,
173 .eid = WLAN_EID_EXT_HE_OPERATION },
174 { .id = WLAN_EID_EXTENSION, .len = 11,
175 .eid = WLAN_EID_EXT_FILS_REQ_PARAMS },
176 },
177 .child_ies = {
178 { .id = WLAN_EID_SSID, .len = 13 },
179 { .id = WLAN_EID_EXTENSION, .len = 17,
180 .eid = WLAN_EID_EXT_HE_CAPABILITY },
181 { .id = WLAN_EID_EXTENSION, .len = 11,
182 .eid = WLAN_EID_EXT_FILS_KEY_CONFIRM },
183 { .id = WLAN_EID_EXTENSION, .len = 19,
184 .eid = WLAN_EID_EXT_HE_OPERATION },
185 },
186 .result_ies = {
187 { .id = WLAN_EID_EXTENSION, .len = 17,
188 .eid = WLAN_EID_EXT_HE_CAPABILITY },
189 { .id = WLAN_EID_EXTENSION, .len = 5,
190 .eid = WLAN_EID_EXT_ASSOC_DELAY_INFO },
191 { .id = WLAN_EID_EXTENSION, .len = 19,
192 .eid = WLAN_EID_EXT_HE_OPERATION },
193 { .id = WLAN_EID_EXTENSION, .len = 11,
194 .eid = WLAN_EID_EXT_FILS_REQ_PARAMS },
195 { .id = WLAN_EID_SSID, .len = 13 },
196 { .id = WLAN_EID_EXTENSION, .len = 11,
197 .eid = WLAN_EID_EXT_FILS_KEY_CONFIRM },
198 },
199 },
200 {
201 .desc = "non-inherit element",
202 .parent_ies = {
203 { .id = 0x1, .len = 7, },
204 { .id = 0x2, .len = 11, },
205 { .id = 0x3, .len = 13, },
206 { .id = WLAN_EID_EXTENSION, .len = 17, .eid = 0x10 },
207 { .id = WLAN_EID_EXTENSION, .len = 19, .eid = 0x11 },
208 { .id = WLAN_EID_EXTENSION, .len = 23, .eid = 0x12 },
209 { .id = WLAN_EID_EXTENSION, .len = 29, .eid = 0x14 },
210 },
211 .child_ies = {
212 { .id = WLAN_EID_EXTENSION,
213 .eid = WLAN_EID_EXT_NON_INHERITANCE,
214 .len = 10,
215 .edata = { 0x3, 0x1, 0x2, 0x3,
216 0x4, 0x10, 0x11, 0x13, 0x14 } },
217 { .id = WLAN_EID_SSID, .len = 2 },
218 },
219 .result_ies = {
220 { .id = WLAN_EID_EXTENSION, .len = 23, .eid = 0x12 },
221 { .id = WLAN_EID_SSID, .len = 2 },
222 },
223 },
224};
225KUNIT_ARRAY_PARAM_DESC(gen_new_ie, gen_new_ie_cases, desc)
226
227static void test_gen_new_ie(struct kunit *test)
228{
229 const struct gen_new_ie_case *params = test->param_value;
230 struct sk_buff *parent = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
231 struct sk_buff *child = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
232 struct sk_buff *reference = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
233 u8 *out = kunit_kzalloc(test, IEEE80211_MAX_DATA_LEN, GFP_KERNEL);
234 size_t len;
235 int i;
236
237 KUNIT_ASSERT_NOT_NULL(test, parent);
238 KUNIT_ASSERT_NOT_NULL(test, child);
239 KUNIT_ASSERT_NOT_NULL(test, reference);
240 KUNIT_ASSERT_NOT_NULL(test, out);
241
242 for (i = 0; i < ARRAY_SIZE(params->parent_ies); i++) {
243 if (params->parent_ies[i].len != 0) {
244 skb_put_u8(parent, params->parent_ies[i].id);
245 skb_put_u8(parent, params->parent_ies[i].len);
246 skb_put_data(parent, params->parent_ies[i].data,
247 params->parent_ies[i].len);
248 }
249
250 if (params->child_ies[i].len != 0) {
251 skb_put_u8(child, params->child_ies[i].id);
252 skb_put_u8(child, params->child_ies[i].len);
253 skb_put_data(child, params->child_ies[i].data,
254 params->child_ies[i].len);
255 }
256
257 if (params->result_ies[i].len != 0) {
258 skb_put_u8(reference, params->result_ies[i].id);
259 skb_put_u8(reference, params->result_ies[i].len);
260 skb_put_data(reference, params->result_ies[i].data,
261 params->result_ies[i].len);
262 }
263 }
264
265 len = cfg80211_gen_new_ie(parent->data, parent->len,
266 child->data, child->len,
267 out, IEEE80211_MAX_DATA_LEN);
268 KUNIT_EXPECT_EQ(test, len, reference->len);
269 KUNIT_EXPECT_MEMEQ(test, out, reference->data, reference->len);
270 memset(out, 0, IEEE80211_MAX_DATA_LEN);
271
272 /* Exactly enough space */
273 len = cfg80211_gen_new_ie(parent->data, parent->len,
274 child->data, child->len,
275 out, reference->len);
276 KUNIT_EXPECT_EQ(test, len, reference->len);
277 KUNIT_EXPECT_MEMEQ(test, out, reference->data, reference->len);
278 memset(out, 0, IEEE80211_MAX_DATA_LEN);
279
280 /* Not enough space (or expected zero length) */
281 len = cfg80211_gen_new_ie(parent->data, parent->len,
282 child->data, child->len,
283 out, reference->len - 1);
284 KUNIT_EXPECT_EQ(test, len, 0);
285}
286
287static void test_gen_new_ie_malformed(struct kunit *test)
288{
289 struct sk_buff *malformed = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
290 u8 *out = kunit_kzalloc(test, IEEE80211_MAX_DATA_LEN, GFP_KERNEL);
291 size_t len;
292
293 KUNIT_ASSERT_NOT_NULL(test, malformed);
294 KUNIT_ASSERT_NOT_NULL(test, out);
295
296 skb_put_u8(malformed, WLAN_EID_SSID);
297 skb_put_u8(malformed, 3);
298 skb_put(malformed, 3);
299 skb_put_u8(malformed, WLAN_EID_REDUCED_NEIGHBOR_REPORT);
300 skb_put_u8(malformed, 10);
301 skb_put(malformed, 9);
302
303 len = cfg80211_gen_new_ie(malformed->data, malformed->len,
304 out, 0,
305 out, IEEE80211_MAX_DATA_LEN);
306 KUNIT_EXPECT_EQ(test, len, 5);
307
308 len = cfg80211_gen_new_ie(out, 0,
309 malformed->data, malformed->len,
310 out, IEEE80211_MAX_DATA_LEN);
311 KUNIT_EXPECT_EQ(test, len, 5);
312}
313
314struct inform_bss {
315 struct kunit *test;
316
317 int inform_bss_count;
318};
319
320static void inform_bss_inc_counter(struct wiphy *wiphy,
321 struct cfg80211_bss *bss,
322 const struct cfg80211_bss_ies *ies,
323 void *drv_data)
324{
325 struct inform_bss *ctx = t_wiphy_ctx(wiphy);
326
327 ctx->inform_bss_count++;
328
329 rcu_read_lock();
330 KUNIT_EXPECT_PTR_EQ(ctx->test, drv_data, ctx);
331 KUNIT_EXPECT_PTR_EQ(ctx->test, ies, rcu_dereference(bss->ies));
332 rcu_read_unlock();
333}
334
335static void test_inform_bss_ssid_only(struct kunit *test)
336{
337 struct inform_bss ctx = {
338 .test = test,
339 };
340 struct wiphy *wiphy = T_WIPHY(test, ctx);
341 struct t_wiphy_priv *w_priv = wiphy_priv(wiphy);
342 struct cfg80211_inform_bss inform_bss = {
343 .signal = 50,
344 .drv_data = &ctx,
345 };
346 const u8 bssid[ETH_ALEN] = { 0x10, 0x22, 0x33, 0x44, 0x55, 0x66 };
347 u64 tsf = 0x1000000000000000ULL;
348 int beacon_int = 100;
349 u16 capability = 0x1234;
350 static const u8 input[] = {
351 [0] = WLAN_EID_SSID,
352 [1] = 4,
353 [2] = 'T', 'E', 'S', 'T'
354 };
355 struct cfg80211_bss *bss, *other;
356 const struct cfg80211_bss_ies *ies;
357
358 w_priv->ops->inform_bss = inform_bss_inc_counter;
359
360 inform_bss.chan = ieee80211_get_channel_khz(wiphy, MHZ_TO_KHZ(2412));
361 KUNIT_ASSERT_NOT_NULL(test, inform_bss.chan);
362
363 bss = cfg80211_inform_bss_data(wiphy, &inform_bss,
364 CFG80211_BSS_FTYPE_PRESP, bssid, tsf,
365 capability, beacon_int,
366 input, sizeof(input),
367 GFP_KERNEL);
368 KUNIT_EXPECT_NOT_NULL(test, bss);
369 KUNIT_EXPECT_EQ(test, ctx.inform_bss_count, 1);
370
371 /* Check values in returned bss are correct */
372 KUNIT_EXPECT_EQ(test, bss->signal, inform_bss.signal);
373 KUNIT_EXPECT_EQ(test, bss->beacon_interval, beacon_int);
374 KUNIT_EXPECT_EQ(test, bss->capability, capability);
375 KUNIT_EXPECT_EQ(test, bss->bssid_index, 0);
376 KUNIT_EXPECT_PTR_EQ(test, bss->channel, inform_bss.chan);
377 KUNIT_EXPECT_MEMEQ(test, bssid, bss->bssid, sizeof(bssid));
378
379 /* Check the IEs have the expected value */
380 rcu_read_lock();
381 ies = rcu_dereference(bss->ies);
382 KUNIT_EXPECT_NOT_NULL(test, ies);
383 KUNIT_EXPECT_EQ(test, ies->tsf, tsf);
384 KUNIT_EXPECT_EQ(test, ies->len, sizeof(input));
385 KUNIT_EXPECT_MEMEQ(test, ies->data, input, sizeof(input));
386 rcu_read_unlock();
387
388 /* Check we can look up the BSS - by SSID */
389 other = cfg80211_get_bss(wiphy, NULL, NULL, "TEST", 4,
390 IEEE80211_BSS_TYPE_ANY,
391 IEEE80211_PRIVACY_ANY);
392 KUNIT_EXPECT_PTR_EQ(test, bss, other);
393 cfg80211_put_bss(wiphy, other);
394
395 /* Check we can look up the BSS - by BSSID */
396 other = cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
397 IEEE80211_BSS_TYPE_ANY,
398 IEEE80211_PRIVACY_ANY);
399 KUNIT_EXPECT_PTR_EQ(test, bss, other);
400 cfg80211_put_bss(wiphy, other);
401
402 cfg80211_put_bss(wiphy, bss);
403}
404
405static void test_get_bss_miss_reason(struct kunit *test)
406{
407 struct inform_bss ctx = {
408 .test = test,
409 };
410 struct wiphy *wiphy = T_WIPHY(test, ctx);
411 struct cfg80211_inform_bss inform_bss = {
412 .signal = 50,
413 .drv_data = &ctx,
414 };
415 const u8 bssid[ETH_ALEN] = { 0x10, 0x22, 0x33, 0x44, 0x55, 0x66 };
416 const u8 other_bssid[ETH_ALEN] = { 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 };
417 static const u8 ies[] = {
418 [0] = WLAN_EID_SSID,
419 [1] = 4,
420 [2] = 'T', 'E', 'S', 'T'
421 };
422 struct cfg80211_internal_bss *ibss;
423 struct netlink_ext_ack extack = {};
424 struct cfg80211_bss *bss, *bss2, *found;
425
426 inform_bss.chan = ieee80211_get_channel_khz(wiphy, MHZ_TO_KHZ(2412));
427 KUNIT_ASSERT_NOT_NULL(test, inform_bss.chan);
428
429 bss = cfg80211_inform_bss_data(wiphy, &inform_bss,
430 CFG80211_BSS_FTYPE_PRESP, bssid, 0,
431 0x1234, 100, ies, sizeof(ies),
432 GFP_KERNEL);
433 KUNIT_ASSERT_NOT_NULL(test, bss);
434 ibss = container_of(bss, struct cfg80211_internal_bss, pub);
435
436 /* Fresh usable entry: found, no message is set */
437 found = __cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
438 IEEE80211_BSS_TYPE_ANY,
439 IEEE80211_PRIVACY_ANY,
440 NL80211_BSS_USE_FOR_NORMAL, &extack);
441 KUNIT_ASSERT_PTR_EQ(test, found, bss);
442 KUNIT_EXPECT_NULL(test, extack._msg);
443 cfg80211_put_bss(wiphy, found);
444
445 /* No entry at all for this BSSID */
446 found = __cfg80211_get_bss(wiphy, NULL, other_bssid, NULL, 0,
447 IEEE80211_BSS_TYPE_ANY,
448 IEEE80211_PRIVACY_ANY,
449 NL80211_BSS_USE_FOR_NORMAL, &extack);
450 KUNIT_EXPECT_NULL(test, found);
451 KUNIT_EXPECT_STREQ(test, extack._msg, "BSS not found in scan results");
452
453 /* Fresh entry that is not usable for the requested use */
454 extack._msg = NULL;
455 bss->use_for = 0;
456 found = __cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
457 IEEE80211_BSS_TYPE_ANY,
458 IEEE80211_PRIVACY_ANY,
459 NL80211_BSS_USE_FOR_NORMAL, &extack);
460 KUNIT_EXPECT_NULL(test, found);
461 KUNIT_EXPECT_STREQ(test, extack._msg,
462 "BSS cannot be used for the requested operation");
463 bss->use_for = NL80211_BSS_USE_FOR_ALL;
464
465 /* Expired entry, > IEEE80211_SCAN_RESULT_EXPIRE (30s) old */
466 extack._msg = NULL;
467 ibss->ts = jiffies - 60 * HZ;
468 found = __cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
469 IEEE80211_BSS_TYPE_ANY,
470 IEEE80211_PRIVACY_ANY,
471 NL80211_BSS_USE_FOR_NORMAL, &extack);
472 KUNIT_EXPECT_NULL(test, found);
473 KUNIT_EXPECT_STREQ(test, extack._msg,
474 "BSS entry in scan results is expired");
475
476 /* An entry both expired and unusable reports expired */
477 extack._msg = NULL;
478 bss->use_for = 0;
479 found = __cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
480 IEEE80211_BSS_TYPE_ANY,
481 IEEE80211_PRIVACY_ANY,
482 NL80211_BSS_USE_FOR_NORMAL, &extack);
483 KUNIT_EXPECT_NULL(test, found);
484 KUNIT_EXPECT_STREQ(test, extack._msg,
485 "BSS entry in scan results is expired");
486 bss->use_for = NL80211_BSS_USE_FOR_ALL;
487
488 /* Expired but held entries are still usable, no message is set */
489 extack._msg = NULL;
490 atomic_set(&ibss->hold, 1);
491 found = __cfg80211_get_bss(wiphy, NULL, bssid, NULL, 0,
492 IEEE80211_BSS_TYPE_ANY,
493 IEEE80211_PRIVACY_ANY,
494 NL80211_BSS_USE_FOR_NORMAL, &extack);
495 KUNIT_ASSERT_PTR_EQ(test, found, bss);
496 KUNIT_EXPECT_NULL(test, extack._msg);
497 cfg80211_put_bss(wiphy, found);
498 atomic_set(&ibss->hold, 0);
499
500 /*
501 * With one matching entry expired and another current but
502 * unusable, both reasons are reported.
503 */
504 bss2 = cfg80211_inform_bss_data(wiphy, &inform_bss,
505 CFG80211_BSS_FTYPE_PRESP, other_bssid,
506 0, 0x1234, 100, ies, sizeof(ies),
507 GFP_KERNEL);
508 KUNIT_ASSERT_NOT_NULL(test, bss2);
509 bss2->use_for = 0;
510 extack._msg = NULL;
511 found = __cfg80211_get_bss(wiphy, NULL, NULL, "TEST", 4,
512 IEEE80211_BSS_TYPE_ANY,
513 IEEE80211_PRIVACY_ANY,
514 NL80211_BSS_USE_FOR_NORMAL, &extack);
515 KUNIT_EXPECT_NULL(test, found);
516 KUNIT_EXPECT_STREQ(test, extack._msg,
517 "BSS entries are expired or cannot be used for the requested operation");
518
519 cfg80211_put_bss(wiphy, bss2);
520 cfg80211_put_bss(wiphy, bss);
521}
522
523static struct inform_bss_ml_sta_case {
524 const char *desc;
525 int mld_id;
526 bool sta_prof_vendor_elems;
527 bool include_oper_class;
528 bool nstr;
529} inform_bss_ml_sta_cases[] = {
530 {
531 .desc = "zero_mld_id",
532 .mld_id = 0,
533 .sta_prof_vendor_elems = false,
534 }, {
535 .desc = "zero_mld_id_with_oper_class",
536 .mld_id = 0,
537 .sta_prof_vendor_elems = false,
538 .include_oper_class = true,
539 }, {
540 .desc = "mld_id_eq_1",
541 .mld_id = 1,
542 .sta_prof_vendor_elems = true,
543 }, {
544 .desc = "mld_id_eq_1_with_oper_class",
545 .mld_id = 1,
546 .sta_prof_vendor_elems = true,
547 .include_oper_class = true,
548 }, {
549 .desc = "nstr",
550 .mld_id = 0,
551 .nstr = true,
552 },
553};
554KUNIT_ARRAY_PARAM_DESC(inform_bss_ml_sta, inform_bss_ml_sta_cases, desc)
555
556static void test_inform_bss_ml_sta(struct kunit *test)
557{
558 const struct inform_bss_ml_sta_case *params = test->param_value;
559 struct inform_bss ctx = {
560 .test = test,
561 };
562 struct wiphy *wiphy = T_WIPHY(test, ctx);
563 struct t_wiphy_priv *w_priv = wiphy_priv(wiphy);
564 struct cfg80211_inform_bss inform_bss = {
565 .signal = 50,
566 .drv_data = &ctx,
567 };
568 struct cfg80211_bss *bss, *link_bss;
569 const struct cfg80211_bss_ies *ies;
570
571 /* sending station */
572 const u8 bssid[ETH_ALEN] = { 0x10, 0x22, 0x33, 0x44, 0x55, 0x66 };
573 u64 tsf = 0x1000000000000000ULL;
574 int beacon_int = 100;
575 u16 capability = 0x1234;
576
577 /* Building the frame *************************************************/
578 struct sk_buff *input = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
579 u8 *len_mle, *len_prof;
580 u8 link_id = 2;
581 struct {
582 struct ieee80211_neighbor_ap_info info;
583 struct ieee80211_tbtt_info_ge_11 ap;
584 } __packed rnr_normal = {
585 .info = {
586 .tbtt_info_hdr = u8_encode_bits(0, IEEE80211_AP_INFO_TBTT_HDR_COUNT),
587 .tbtt_info_len = sizeof(struct ieee80211_tbtt_info_ge_11),
588 .op_class = 81,
589 .channel = 11,
590 },
591 .ap = {
592 .tbtt_offset = 0xff,
593 .bssid = { 0x10, 0x22, 0x33, 0x44, 0x55, 0x67 },
594 .short_ssid = 0, /* unused */
595 .bss_params = 0,
596 .psd_20 = 0,
597 .mld_params.mld_id = params->mld_id,
598 .mld_params.params =
599 le16_encode_bits(link_id,
600 IEEE80211_RNR_MLD_PARAMS_LINK_ID),
601 }
602 };
603 struct {
604 struct ieee80211_neighbor_ap_info info;
605 struct ieee80211_rnr_mld_params mld_params;
606 } __packed rnr_nstr = {
607 .info = {
608 .tbtt_info_hdr =
609 u8_encode_bits(0, IEEE80211_AP_INFO_TBTT_HDR_COUNT) |
610 u8_encode_bits(IEEE80211_TBTT_INFO_TYPE_MLD,
611 IEEE80211_AP_INFO_TBTT_HDR_TYPE),
612 .tbtt_info_len = sizeof(struct ieee80211_rnr_mld_params),
613 .op_class = 81,
614 .channel = 11,
615 },
616 .mld_params = {
617 .mld_id = params->mld_id,
618 .params =
619 le16_encode_bits(link_id,
620 IEEE80211_RNR_MLD_PARAMS_LINK_ID),
621 }
622 };
623 size_t rnr_len = params->nstr ? sizeof(rnr_nstr) : sizeof(rnr_normal);
624 void *rnr = params->nstr ? (void *)&rnr_nstr : (void *)&rnr_normal;
625 struct {
626 __le16 control;
627 u8 var_len;
628 u8 mld_mac_addr[ETH_ALEN];
629 u8 link_id_info;
630 u8 params_change_count;
631 __le16 mld_caps_and_ops;
632 u8 mld_id;
633 __le16 ext_mld_caps_and_ops;
634 } __packed mle_basic_common_info = {
635 .control =
636 cpu_to_le16(IEEE80211_ML_CONTROL_TYPE_BASIC |
637 IEEE80211_MLC_BASIC_PRES_BSS_PARAM_CH_CNT |
638 IEEE80211_MLC_BASIC_PRES_LINK_ID |
639 (params->mld_id ? IEEE80211_MLC_BASIC_PRES_MLD_ID : 0) |
640 IEEE80211_MLC_BASIC_PRES_MLD_CAPA_OP),
641 .mld_id = params->mld_id,
642 .mld_caps_and_ops = cpu_to_le16(0x0102),
643 .ext_mld_caps_and_ops = cpu_to_le16(0x0304),
644 .var_len = sizeof(mle_basic_common_info) - 2 -
645 (params->mld_id ? 0 : 1),
646 .mld_mac_addr = { 0x10, 0x22, 0x33, 0x44, 0x55, 0x60 },
647 };
648 struct {
649 __le16 control;
650 u8 var_len;
651 u8 bssid[ETH_ALEN];
652 __le16 beacon_int;
653 __le64 tsf_offset;
654 __le16 capabilities; /* already part of payload */
655 } __packed sta_prof = {
656 .control =
657 cpu_to_le16(IEEE80211_MLE_STA_CONTROL_COMPLETE_PROFILE |
658 IEEE80211_MLE_STA_CONTROL_STA_MAC_ADDR_PRESENT |
659 IEEE80211_MLE_STA_CONTROL_BEACON_INT_PRESENT |
660 IEEE80211_MLE_STA_CONTROL_TSF_OFFS_PRESENT |
661 u16_encode_bits(link_id,
662 IEEE80211_MLE_STA_CONTROL_LINK_ID)),
663 .var_len = sizeof(sta_prof) - 2 - 2,
664 .bssid = { *rnr_normal.ap.bssid },
665 .beacon_int = cpu_to_le16(101),
666 .tsf_offset = cpu_to_le64(-123ll),
667 .capabilities = cpu_to_le16(0xdead),
668 };
669
670 KUNIT_ASSERT_NOT_NULL(test, input);
671
672 w_priv->ops->inform_bss = inform_bss_inc_counter;
673
674 inform_bss.chan = ieee80211_get_channel_khz(wiphy, MHZ_TO_KHZ(2412));
675 KUNIT_ASSERT_NOT_NULL(test, inform_bss.chan);
676
677 skb_put_u8(input, WLAN_EID_SSID);
678 skb_put_u8(input, 4);
679 skb_put_data(input, "TEST", 4);
680
681 if (params->include_oper_class) {
682 skb_put_u8(input, WLAN_EID_SUPPORTED_REGULATORY_CLASSES);
683 skb_put_u8(input, 1);
684 skb_put_u8(input, 81);
685 }
686
687 skb_put_u8(input, WLAN_EID_REDUCED_NEIGHBOR_REPORT);
688 skb_put_u8(input, rnr_len);
689 skb_put_data(input, rnr, rnr_len);
690
691 /* build a multi-link element */
692 skb_put_u8(input, WLAN_EID_EXTENSION);
693 len_mle = skb_put(input, 1);
694 skb_put_u8(input, WLAN_EID_EXT_EHT_MULTI_LINK);
695 skb_put_data(input, &mle_basic_common_info, sizeof(mle_basic_common_info));
696 if (!params->mld_id)
697 t_skb_remove_member(input, typeof(mle_basic_common_info), mld_id);
698 /* with a STA profile inside */
699 skb_put_u8(input, IEEE80211_MLE_SUBELEM_PER_STA_PROFILE);
700 len_prof = skb_put(input, 1);
701 skb_put_data(input, &sta_prof, sizeof(sta_prof));
702
703 if (params->sta_prof_vendor_elems) {
704 /* Put two (vendor) element into sta_prof */
705 skb_put_u8(input, WLAN_EID_VENDOR_SPECIFIC);
706 skb_put_u8(input, 160);
707 skb_put(input, 160);
708
709 skb_put_u8(input, WLAN_EID_VENDOR_SPECIFIC);
710 skb_put_u8(input, 165);
711 skb_put(input, 165);
712 }
713
714 /* fragment STA profile */
715 ieee80211_fragment_element(input, len_prof,
716 IEEE80211_MLE_SUBELEM_FRAGMENT);
717 /* fragment MLE */
718 ieee80211_fragment_element(input, len_mle, WLAN_EID_FRAGMENT);
719
720 /* Put a (vendor) element after the ML element */
721 skb_put_u8(input, WLAN_EID_VENDOR_SPECIFIC);
722 skb_put_u8(input, 155);
723 skb_put(input, 155);
724
725 /* Submit *************************************************************/
726 bss = cfg80211_inform_bss_data(wiphy, &inform_bss,
727 CFG80211_BSS_FTYPE_PRESP, bssid, tsf,
728 capability, beacon_int,
729 input->data, input->len,
730 GFP_KERNEL);
731 KUNIT_EXPECT_NOT_NULL(test, bss);
732 KUNIT_EXPECT_EQ(test, ctx.inform_bss_count, 2);
733
734 /* Check link_bss *****************************************************/
735 link_bss = __cfg80211_get_bss(wiphy, NULL, sta_prof.bssid, NULL, 0,
736 IEEE80211_BSS_TYPE_ANY,
737 IEEE80211_PRIVACY_ANY,
738 0, NULL);
739 KUNIT_ASSERT_NOT_NULL(test, link_bss);
740 KUNIT_EXPECT_EQ(test, link_bss->signal, 0);
741 KUNIT_EXPECT_EQ(test, link_bss->beacon_interval,
742 le16_to_cpu(sta_prof.beacon_int));
743 KUNIT_EXPECT_EQ(test, link_bss->capability,
744 le16_to_cpu(sta_prof.capabilities));
745 KUNIT_EXPECT_EQ(test, link_bss->bssid_index, 0);
746 KUNIT_EXPECT_PTR_EQ(test, link_bss->channel,
747 ieee80211_get_channel_khz(wiphy, MHZ_TO_KHZ(2462)));
748
749 /* Test wiphy does not set WIPHY_FLAG_SUPPORTS_NSTR_NONPRIMARY */
750 if (params->nstr) {
751 KUNIT_EXPECT_EQ(test, link_bss->use_for, 0);
752 KUNIT_EXPECT_EQ(test, link_bss->cannot_use_reasons,
753 NL80211_BSS_CANNOT_USE_NSTR_NONPRIMARY);
754 KUNIT_EXPECT_NULL(test,
755 cfg80211_get_bss(wiphy, NULL, sta_prof.bssid,
756 NULL, 0,
757 IEEE80211_BSS_TYPE_ANY,
758 IEEE80211_PRIVACY_ANY));
759 } else {
760 KUNIT_EXPECT_EQ(test, link_bss->use_for,
761 NL80211_BSS_USE_FOR_ALL);
762 KUNIT_EXPECT_EQ(test, link_bss->cannot_use_reasons, 0);
763 }
764
765 rcu_read_lock();
766 ies = rcu_dereference(link_bss->ies);
767 KUNIT_EXPECT_NOT_NULL(test, ies);
768 KUNIT_EXPECT_EQ(test, ies->tsf, tsf + le64_to_cpu(sta_prof.tsf_offset));
769 /* Resulting length should be:
770 * SSID (inherited) + RNR (inherited) + vendor element(s) +
771 * operating class (if requested) +
772 * generated RNR (if MLD ID == 0 and not NSTR) +
773 * MLE common info + MLE header and control
774 */
775 if (params->sta_prof_vendor_elems)
776 KUNIT_EXPECT_EQ(test, ies->len,
777 6 + 2 + rnr_len + 2 + 160 + 2 + 165 +
778 (params->include_oper_class ? 3 : 0) +
779 (!params->mld_id && !params->nstr ? 22 : 0) +
780 mle_basic_common_info.var_len + 5);
781 else
782 KUNIT_EXPECT_EQ(test, ies->len,
783 6 + 2 + rnr_len + 2 + 155 +
784 (params->include_oper_class ? 3 : 0) +
785 (!params->mld_id && !params->nstr ? 22 : 0) +
786 mle_basic_common_info.var_len + 5);
787 rcu_read_unlock();
788
789 cfg80211_put_bss(wiphy, bss);
790 cfg80211_put_bss(wiphy, link_bss);
791}
792
793static struct cfg80211_parse_colocated_ap_case {
794 const char *desc;
795 u8 op_class;
796 u8 channel;
797 struct ieee80211_neighbor_ap_info info;
798 union {
799 struct ieee80211_tbtt_info_ge_11 tbtt_long;
800 struct ieee80211_tbtt_info_7_8_9 tbtt_short;
801 };
802 bool add_junk;
803 bool same_ssid;
804 bool valid;
805} cfg80211_parse_colocated_ap_cases[] = {
806 {
807 .desc = "wrong_band",
808 .info.op_class = 81,
809 .info.channel = 11,
810 .tbtt_long = {
811 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
812 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
813 },
814 .valid = false,
815 },
816 {
817 .desc = "wrong_type",
818 /* IEEE80211_AP_INFO_TBTT_HDR_TYPE is in the least significant bits */
819 .info.tbtt_info_hdr = IEEE80211_TBTT_INFO_TYPE_MLD,
820 .tbtt_long = {
821 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
822 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
823 },
824 .valid = false,
825 },
826 {
827 .desc = "colocated_invalid_len_short",
828 .info.tbtt_info_len = 6,
829 .tbtt_short = {
830 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
831 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP |
832 IEEE80211_RNR_TBTT_PARAMS_SAME_SSID,
833 },
834 .valid = false,
835 },
836 {
837 .desc = "colocated_invalid_len_short_mld",
838 .info.tbtt_info_len = 10,
839 .tbtt_long = {
840 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
841 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
842 },
843 .valid = false,
844 },
845 {
846 .desc = "colocated_non_mld",
847 .info.tbtt_info_len = sizeof(struct ieee80211_tbtt_info_7_8_9),
848 .tbtt_short = {
849 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
850 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP |
851 IEEE80211_RNR_TBTT_PARAMS_SAME_SSID,
852 },
853 .same_ssid = true,
854 .valid = true,
855 },
856 {
857 .desc = "colocated_non_mld_invalid_bssid",
858 .info.tbtt_info_len = sizeof(struct ieee80211_tbtt_info_7_8_9),
859 .tbtt_short = {
860 .bssid = { 0xff, 0x11, 0x22, 0x33, 0x44, 0x55 },
861 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP |
862 IEEE80211_RNR_TBTT_PARAMS_SAME_SSID,
863 },
864 .same_ssid = true,
865 .valid = false,
866 },
867 {
868 .desc = "colocated_mld",
869 .tbtt_long = {
870 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
871 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
872 },
873 .valid = true,
874 },
875 {
876 .desc = "colocated_mld",
877 .tbtt_long = {
878 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
879 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
880 },
881 .add_junk = true,
882 .valid = false,
883 },
884 {
885 .desc = "colocated_disabled_mld",
886 .tbtt_long = {
887 .bssid = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 },
888 .bss_params = IEEE80211_RNR_TBTT_PARAMS_COLOC_AP,
889 .mld_params.params = cpu_to_le16(IEEE80211_RNR_MLD_PARAMS_DISABLED_LINK),
890 },
891 .valid = false,
892 },
893};
894KUNIT_ARRAY_PARAM_DESC(cfg80211_parse_colocated_ap, cfg80211_parse_colocated_ap_cases, desc)
895
896static void test_cfg80211_parse_colocated_ap(struct kunit *test)
897{
898 const struct cfg80211_parse_colocated_ap_case *params = test->param_value;
899 struct sk_buff *input = kunit_zalloc_skb(test, 1024, GFP_KERNEL);
900 struct cfg80211_bss_ies *ies;
901 struct ieee80211_neighbor_ap_info info;
902 LIST_HEAD(coloc_ap_list);
903 int count;
904
905 KUNIT_ASSERT_NOT_NULL(test, input);
906
907 info = params->info;
908
909 /* Reasonable values for a colocated AP */
910 if (!info.tbtt_info_len)
911 info.tbtt_info_len = sizeof(params->tbtt_long);
912 if (!info.op_class)
913 info.op_class = 131;
914 if (!info.channel)
915 info.channel = 33;
916 /* Zero is the correct default for .btt_info_hdr (one entry, TBTT type) */
917
918 skb_put_u8(input, WLAN_EID_SSID);
919 skb_put_u8(input, 4);
920 skb_put_data(input, "TEST", 4);
921
922 skb_put_u8(input, WLAN_EID_REDUCED_NEIGHBOR_REPORT);
923 skb_put_u8(input, sizeof(info) + info.tbtt_info_len + (params->add_junk ? 3 : 0));
924 skb_put_data(input, &info, sizeof(info));
925 skb_put_data(input, &params->tbtt_long, info.tbtt_info_len);
926
927 if (params->add_junk)
928 skb_put_data(input, "123", 3);
929
930 ies = kunit_kzalloc(test, struct_size(ies, data, input->len), GFP_KERNEL);
931 KUNIT_ASSERT_NOT_NULL(test, ies);
932
933 ies->len = input->len;
934 memcpy(ies->data, input->data, input->len);
935
936 count = cfg80211_parse_colocated_ap(ies, &coloc_ap_list);
937
938 KUNIT_EXPECT_EQ(test, count, params->valid);
939 KUNIT_EXPECT_EQ(test, list_count_nodes(&coloc_ap_list), params->valid);
940
941 if (params->valid && !list_empty(&coloc_ap_list)) {
942 struct cfg80211_colocated_ap *ap;
943
944 ap = list_first_entry(&coloc_ap_list, typeof(*ap), list);
945 if (info.tbtt_info_len <= sizeof(params->tbtt_short))
946 KUNIT_EXPECT_MEMEQ(test, ap->bssid, params->tbtt_short.bssid, ETH_ALEN);
947 else
948 KUNIT_EXPECT_MEMEQ(test, ap->bssid, params->tbtt_long.bssid, ETH_ALEN);
949
950 if (params->same_ssid) {
951 KUNIT_EXPECT_EQ(test, ap->ssid_len, 4);
952 KUNIT_EXPECT_MEMEQ(test, ap->ssid, "TEST", 4);
953 } else {
954 KUNIT_EXPECT_EQ(test, ap->ssid_len, 0);
955 }
956 }
957
958 cfg80211_free_coloc_ap_list(&coloc_ap_list);
959}
960
961static struct kunit_case gen_new_ie_test_cases[] = {
962 KUNIT_CASE_PARAM(test_gen_new_ie, gen_new_ie_gen_params),
963 KUNIT_CASE(test_gen_new_ie_malformed),
964 {}
965};
966
967static struct kunit_suite gen_new_ie = {
968 .name = "cfg80211-ie-generation",
969 .test_cases = gen_new_ie_test_cases,
970};
971
972kunit_test_suite(gen_new_ie);
973
974static struct kunit_case inform_bss_test_cases[] = {
975 KUNIT_CASE(test_inform_bss_ssid_only),
976 KUNIT_CASE(test_get_bss_miss_reason),
977 KUNIT_CASE_PARAM(test_inform_bss_ml_sta, inform_bss_ml_sta_gen_params),
978 {}
979};
980
981static struct kunit_suite inform_bss = {
982 .name = "cfg80211-inform-bss",
983 .test_cases = inform_bss_test_cases,
984};
985
986kunit_test_suite(inform_bss);
987
988static struct kunit_case scan_6ghz_cases[] = {
989 KUNIT_CASE_PARAM(test_cfg80211_parse_colocated_ap,
990 cfg80211_parse_colocated_ap_gen_params),
991 {}
992};
993
994static struct kunit_suite scan_6ghz = {
995 .name = "cfg80211-scan-6ghz",
996 .test_cases = scan_6ghz_cases,
997};
998
999kunit_test_suite(scan_6ghz);