]> Git Repo - linux.git/blob - net/wireless/tests/fragmentation.c
ASoC: SOF: Intel: don't ignore IOC interrupts for non-audio transfers
[linux.git] / net / wireless / tests / fragmentation.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * KUnit tests for element fragmentation
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
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),
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,
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),
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,
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),
119                                           NULL, 0,
120                                           WLAN_EID_FRAGMENT);
121         /* this means the last fragment was not used */
122         KUNIT_EXPECT_EQ(test, ret, 254 + 255 + 1);
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);
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),
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,
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);
This page took 0.042187 seconds and 4 git commands to generate.