Commit | Line | Data |
---|---|---|
730eeb17 JB |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* | |
3 | * KUnit tests for element fragmentation | |
4 | * | |
8ade3356 | 5 | * Copyright (C) 2023-2024 Intel Corporation |
730eeb17 JB |
6 | */ |
7 | #include <linux/ieee80211.h> | |
8 | #include <net/cfg80211.h> | |
9 | #include <kunit/test.h> | |
10 | ||
11 | static void defragment_0(struct kunit *test) | |
12 | { | |
13 | ssize_t ret; | |
14 | static const u8 input[] = { | |
15 | [0] = WLAN_EID_EXTENSION, | |
16 | [1] = 254, | |
17 | [2] = WLAN_EID_EXT_EHT_MULTI_LINK, | |
18 | [27] = 27, | |
19 | [123] = 123, | |
20 | [254 + 2] = WLAN_EID_FRAGMENT, | |
21 | [254 + 3] = 7, | |
22 | [254 + 3 + 7] = 0, /* for size */ | |
23 | }; | |
24 | u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL); | |
25 | ||
26 | KUNIT_ASSERT_NOT_NULL(test, data); | |
27 | ||
28 | ret = cfg80211_defragment_element((void *)input, | |
29 | input, sizeof(input), | |
8ade3356 JB |
30 | NULL, 0, |
31 | WLAN_EID_FRAGMENT); | |
32 | KUNIT_EXPECT_EQ(test, ret, 253); | |
33 | ret = cfg80211_defragment_element((void *)input, | |
34 | input, sizeof(input), | |
35 | data, ret, | |
730eeb17 JB |
36 | WLAN_EID_FRAGMENT); |
37 | KUNIT_EXPECT_EQ(test, ret, 253); | |
38 | KUNIT_EXPECT_MEMEQ(test, data, input + 3, 253); | |
39 | } | |
40 | ||
41 | static void defragment_1(struct kunit *test) | |
42 | { | |
43 | ssize_t ret; | |
44 | static const u8 input[] = { | |
45 | [0] = WLAN_EID_EXTENSION, | |
46 | [1] = 255, | |
47 | [2] = WLAN_EID_EXT_EHT_MULTI_LINK, | |
48 | [27] = 27, | |
49 | [123] = 123, | |
50 | [255 + 2] = WLAN_EID_FRAGMENT, | |
51 | [255 + 3] = 7, | |
52 | [255 + 3 + 1] = 0xaa, | |
53 | [255 + 3 + 8] = WLAN_EID_FRAGMENT, /* not used */ | |
54 | [255 + 3 + 9] = 1, | |
55 | [255 + 3 + 10] = 0, /* for size */ | |
56 | }; | |
57 | u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL); | |
58 | const struct element *elem; | |
59 | int count = 0; | |
60 | ||
61 | KUNIT_ASSERT_NOT_NULL(test, data); | |
62 | ||
63 | for_each_element(elem, input, sizeof(input)) | |
64 | count++; | |
65 | ||
66 | /* check the elements are right */ | |
67 | KUNIT_ASSERT_EQ(test, count, 3); | |
68 | ||
69 | ret = cfg80211_defragment_element((void *)input, | |
70 | input, sizeof(input), | |
8ade3356 JB |
71 | NULL, 0, |
72 | WLAN_EID_FRAGMENT); | |
73 | KUNIT_EXPECT_EQ(test, ret, 254 + 7); | |
74 | ret = cfg80211_defragment_element((void *)input, | |
75 | input, sizeof(input), | |
76 | data, ret, | |
730eeb17 JB |
77 | WLAN_EID_FRAGMENT); |
78 | /* this means the last fragment was not used */ | |
79 | KUNIT_EXPECT_EQ(test, ret, 254 + 7); | |
80 | KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254); | |
81 | KUNIT_EXPECT_MEMEQ(test, data + 254, input + 255 + 4, 7); | |
82 | } | |
83 | ||
84 | static void defragment_2(struct kunit *test) | |
85 | { | |
86 | ssize_t ret; | |
87 | static const u8 input[] = { | |
88 | [0] = WLAN_EID_EXTENSION, | |
89 | [1] = 255, | |
90 | [2] = WLAN_EID_EXT_EHT_MULTI_LINK, | |
91 | [27] = 27, | |
92 | [123] = 123, | |
93 | ||
94 | [257 + 0] = WLAN_EID_FRAGMENT, | |
95 | [257 + 1] = 255, | |
96 | [257 + 20] = 0xaa, | |
97 | ||
98 | [2 * 257 + 0] = WLAN_EID_FRAGMENT, | |
99 | [2 * 257 + 1] = 1, | |
100 | [2 * 257 + 2] = 0xcc, | |
101 | [2 * 257 + 3] = WLAN_EID_FRAGMENT, /* not used */ | |
102 | [2 * 257 + 4] = 1, | |
103 | [2 * 257 + 5] = 0, /* for size */ | |
104 | }; | |
105 | u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL); | |
106 | const struct element *elem; | |
107 | int count = 0; | |
108 | ||
109 | KUNIT_ASSERT_NOT_NULL(test, data); | |
110 | ||
111 | for_each_element(elem, input, sizeof(input)) | |
112 | count++; | |
113 | ||
114 | /* check the elements are right */ | |
115 | KUNIT_ASSERT_EQ(test, count, 4); | |
116 | ||
117 | ret = cfg80211_defragment_element((void *)input, | |
118 | input, sizeof(input), | |
8ade3356 | 119 | NULL, 0, |
730eeb17 JB |
120 | WLAN_EID_FRAGMENT); |
121 | /* this means the last fragment was not used */ | |
122 | KUNIT_EXPECT_EQ(test, ret, 254 + 255 + 1); | |
8ade3356 JB |
123 | ret = cfg80211_defragment_element((void *)input, |
124 | input, sizeof(input), | |
125 | data, ret, | |
126 | WLAN_EID_FRAGMENT); | |
127 | KUNIT_EXPECT_EQ(test, ret, 254 + 255 + 1); | |
730eeb17 JB |
128 | KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254); |
129 | KUNIT_EXPECT_MEMEQ(test, data + 254, input + 257 + 2, 255); | |
130 | KUNIT_EXPECT_MEMEQ(test, data + 254 + 255, input + 2 * 257 + 2, 1); | |
131 | } | |
132 | ||
133 | static void defragment_at_end(struct kunit *test) | |
134 | { | |
135 | ssize_t ret; | |
136 | static const u8 input[] = { | |
137 | [0] = WLAN_EID_EXTENSION, | |
138 | [1] = 255, | |
139 | [2] = WLAN_EID_EXT_EHT_MULTI_LINK, | |
140 | [27] = 27, | |
141 | [123] = 123, | |
142 | [255 + 2] = WLAN_EID_FRAGMENT, | |
143 | [255 + 3] = 7, | |
144 | [255 + 3 + 7] = 0, /* for size */ | |
145 | }; | |
146 | u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL); | |
147 | ||
148 | KUNIT_ASSERT_NOT_NULL(test, data); | |
149 | ||
150 | ret = cfg80211_defragment_element((void *)input, | |
151 | input, sizeof(input), | |
8ade3356 JB |
152 | NULL, 0, |
153 | WLAN_EID_FRAGMENT); | |
154 | KUNIT_EXPECT_EQ(test, ret, 254 + 7); | |
155 | ret = cfg80211_defragment_element((void *)input, | |
156 | input, sizeof(input), | |
157 | data, ret, | |
730eeb17 JB |
158 | WLAN_EID_FRAGMENT); |
159 | KUNIT_EXPECT_EQ(test, ret, 254 + 7); | |
160 | KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254); | |
161 | KUNIT_EXPECT_MEMEQ(test, data + 254, input + 255 + 4, 7); | |
162 | } | |
163 | ||
164 | static struct kunit_case element_fragmentation_test_cases[] = { | |
165 | KUNIT_CASE(defragment_0), | |
166 | KUNIT_CASE(defragment_1), | |
167 | KUNIT_CASE(defragment_2), | |
168 | KUNIT_CASE(defragment_at_end), | |
169 | {} | |
170 | }; | |
171 | ||
172 | static struct kunit_suite element_fragmentation = { | |
173 | .name = "cfg80211-element-defragmentation", | |
174 | .test_cases = element_fragmentation_test_cases, | |
175 | }; | |
176 | ||
177 | kunit_test_suite(element_fragmentation); |