blob: 25b5cbfb7615bd63da19677c877b9e49c3f519e3
1 | /* |
2 | * Test cases for lib/string_helpers.c module. |
3 | */ |
4 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
5 | |
6 | #include <linux/init.h> |
7 | #include <linux/kernel.h> |
8 | #include <linux/slab.h> |
9 | #include <linux/module.h> |
10 | #include <linux/random.h> |
11 | #include <linux/string.h> |
12 | #include <linux/string_helpers.h> |
13 | |
14 | static __init bool test_string_check_buf(const char *name, unsigned int flags, |
15 | char *in, size_t p, |
16 | char *out_real, size_t q_real, |
17 | char *out_test, size_t q_test) |
18 | { |
19 | if (q_real == q_test && !memcmp(out_test, out_real, q_test)) |
20 | return true; |
21 | |
22 | pr_warn("Test '%s' failed: flags = %u\n", name, flags); |
23 | |
24 | print_hex_dump(KERN_WARNING, "Input: ", DUMP_PREFIX_NONE, 16, 1, |
25 | in, p, true); |
26 | print_hex_dump(KERN_WARNING, "Expected: ", DUMP_PREFIX_NONE, 16, 1, |
27 | out_test, q_test, true); |
28 | print_hex_dump(KERN_WARNING, "Got: ", DUMP_PREFIX_NONE, 16, 1, |
29 | out_real, q_real, true); |
30 | |
31 | return false; |
32 | } |
33 | |
34 | struct test_string { |
35 | const char *in; |
36 | const char *out; |
37 | unsigned int flags; |
38 | }; |
39 | |
40 | static const struct test_string strings[] __initconst = { |
41 | { |
42 | .in = "\\f\\ \\n\\r\\t\\v", |
43 | .out = "\f\\ \n\r\t\v", |
44 | .flags = UNESCAPE_SPACE, |
45 | }, |
46 | { |
47 | .in = "\\40\\1\\387\\0064\\05\\040\\8a\\110\\777", |
48 | .out = " \001\00387\0064\005 \\8aH?7", |
49 | .flags = UNESCAPE_OCTAL, |
50 | }, |
51 | { |
52 | .in = "\\xv\\xa\\x2c\\xD\\x6f2", |
53 | .out = "\\xv\n,\ro2", |
54 | .flags = UNESCAPE_HEX, |
55 | }, |
56 | { |
57 | .in = "\\h\\\\\\\"\\a\\e\\", |
58 | .out = "\\h\\\"\a\e\\", |
59 | .flags = UNESCAPE_SPECIAL, |
60 | }, |
61 | }; |
62 | |
63 | static void __init test_string_unescape(const char *name, unsigned int flags, |
64 | bool inplace) |
65 | { |
66 | int q_real = 256; |
67 | char *in = kmalloc(q_real, GFP_KERNEL); |
68 | char *out_test = kmalloc(q_real, GFP_KERNEL); |
69 | char *out_real = kmalloc(q_real, GFP_KERNEL); |
70 | int i, p = 0, q_test = 0; |
71 | |
72 | if (!in || !out_test || !out_real) |
73 | goto out; |
74 | |
75 | for (i = 0; i < ARRAY_SIZE(strings); i++) { |
76 | const char *s = strings[i].in; |
77 | int len = strlen(strings[i].in); |
78 | |
79 | /* Copy string to in buffer */ |
80 | memcpy(&in[p], s, len); |
81 | p += len; |
82 | |
83 | /* Copy expected result for given flags */ |
84 | if (flags & strings[i].flags) { |
85 | s = strings[i].out; |
86 | len = strlen(strings[i].out); |
87 | } |
88 | memcpy(&out_test[q_test], s, len); |
89 | q_test += len; |
90 | } |
91 | in[p++] = '\0'; |
92 | |
93 | /* Call string_unescape and compare result */ |
94 | if (inplace) { |
95 | memcpy(out_real, in, p); |
96 | if (flags == UNESCAPE_ANY) |
97 | q_real = string_unescape_any_inplace(out_real); |
98 | else |
99 | q_real = string_unescape_inplace(out_real, flags); |
100 | } else if (flags == UNESCAPE_ANY) { |
101 | q_real = string_unescape_any(in, out_real, q_real); |
102 | } else { |
103 | q_real = string_unescape(in, out_real, q_real, flags); |
104 | } |
105 | |
106 | test_string_check_buf(name, flags, in, p - 1, out_real, q_real, |
107 | out_test, q_test); |
108 | out: |
109 | kfree(out_real); |
110 | kfree(out_test); |
111 | kfree(in); |
112 | } |
113 | |
114 | struct test_string_1 { |
115 | const char *out; |
116 | unsigned int flags; |
117 | }; |
118 | |
119 | #define TEST_STRING_2_MAX_S1 32 |
120 | struct test_string_2 { |
121 | const char *in; |
122 | struct test_string_1 s1[TEST_STRING_2_MAX_S1]; |
123 | }; |
124 | |
125 | #define TEST_STRING_2_DICT_0 NULL |
126 | static const struct test_string_2 escape0[] __initconst = {{ |
127 | .in = "\f\\ \n\r\t\v", |
128 | .s1 = {{ |
129 | .out = "\\f\\ \\n\\r\\t\\v", |
130 | .flags = ESCAPE_SPACE, |
131 | },{ |
132 | .out = "\\f\\134\\040\\n\\r\\t\\v", |
133 | .flags = ESCAPE_SPACE | ESCAPE_OCTAL, |
134 | },{ |
135 | .out = "\\f\\x5c\\x20\\n\\r\\t\\v", |
136 | .flags = ESCAPE_SPACE | ESCAPE_HEX, |
137 | },{ |
138 | /* terminator */ |
139 | }}, |
140 | },{ |
141 | .in = "\\h\\\"\a\e\\", |
142 | .s1 = {{ |
143 | .out = "\\\\h\\\\\"\\a\\e\\\\", |
144 | .flags = ESCAPE_SPECIAL, |
145 | },{ |
146 | .out = "\\\\\\150\\\\\\042\\a\\e\\\\", |
147 | .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL, |
148 | },{ |
149 | .out = "\\\\\\x68\\\\\\x22\\a\\e\\\\", |
150 | .flags = ESCAPE_SPECIAL | ESCAPE_HEX, |
151 | },{ |
152 | /* terminator */ |
153 | }}, |
154 | },{ |
155 | .in = "\eb \\C\007\"\x90\r]", |
156 | .s1 = {{ |
157 | .out = "\eb \\C\007\"\x90\\r]", |
158 | .flags = ESCAPE_SPACE, |
159 | },{ |
160 | .out = "\\eb \\\\C\\a\"\x90\r]", |
161 | .flags = ESCAPE_SPECIAL, |
162 | },{ |
163 | .out = "\\eb \\\\C\\a\"\x90\\r]", |
164 | .flags = ESCAPE_SPACE | ESCAPE_SPECIAL, |
165 | },{ |
166 | .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\015\\135", |
167 | .flags = ESCAPE_OCTAL, |
168 | },{ |
169 | .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\r\\135", |
170 | .flags = ESCAPE_SPACE | ESCAPE_OCTAL, |
171 | },{ |
172 | .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\015\\135", |
173 | .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL, |
174 | },{ |
175 | .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\r\\135", |
176 | .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_OCTAL, |
177 | },{ |
178 | .out = "\eb \\C\007\"\x90\r]", |
179 | .flags = ESCAPE_NP, |
180 | },{ |
181 | .out = "\eb \\C\007\"\x90\\r]", |
182 | .flags = ESCAPE_SPACE | ESCAPE_NP, |
183 | },{ |
184 | .out = "\\eb \\C\\a\"\x90\r]", |
185 | .flags = ESCAPE_SPECIAL | ESCAPE_NP, |
186 | },{ |
187 | .out = "\\eb \\C\\a\"\x90\\r]", |
188 | .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NP, |
189 | },{ |
190 | .out = "\\033b \\C\\007\"\\220\\015]", |
191 | .flags = ESCAPE_OCTAL | ESCAPE_NP, |
192 | },{ |
193 | .out = "\\033b \\C\\007\"\\220\\r]", |
194 | .flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NP, |
195 | },{ |
196 | .out = "\\eb \\C\\a\"\\220\\r]", |
197 | .flags = ESCAPE_SPECIAL | ESCAPE_SPACE | ESCAPE_OCTAL | |
198 | ESCAPE_NP, |
199 | },{ |
200 | .out = "\\x1bb \\C\\x07\"\\x90\\x0d]", |
201 | .flags = ESCAPE_NP | ESCAPE_HEX, |
202 | },{ |
203 | /* terminator */ |
204 | }}, |
205 | },{ |
206 | /* terminator */ |
207 | }}; |
208 | |
209 | #define TEST_STRING_2_DICT_1 "b\\ \t\r" |
210 | static const struct test_string_2 escape1[] __initconst = {{ |
211 | .in = "\f\\ \n\r\t\v", |
212 | .s1 = {{ |
213 | .out = "\f\\134\\040\n\\015\\011\v", |
214 | .flags = ESCAPE_OCTAL, |
215 | },{ |
216 | .out = "\f\\x5c\\x20\n\\x0d\\x09\v", |
217 | .flags = ESCAPE_HEX, |
218 | },{ |
219 | /* terminator */ |
220 | }}, |
221 | },{ |
222 | .in = "\\h\\\"\a\e\\", |
223 | .s1 = {{ |
224 | .out = "\\134h\\134\"\a\e\\134", |
225 | .flags = ESCAPE_OCTAL, |
226 | },{ |
227 | /* terminator */ |
228 | }}, |
229 | },{ |
230 | .in = "\eb \\C\007\"\x90\r]", |
231 | .s1 = {{ |
232 | .out = "\e\\142\\040\\134C\007\"\x90\\015]", |
233 | .flags = ESCAPE_OCTAL, |
234 | },{ |
235 | /* terminator */ |
236 | }}, |
237 | },{ |
238 | /* terminator */ |
239 | }}; |
240 | |
241 | static __init const char *test_string_find_match(const struct test_string_2 *s2, |
242 | unsigned int flags) |
243 | { |
244 | const struct test_string_1 *s1 = s2->s1; |
245 | unsigned int i; |
246 | |
247 | if (!flags) |
248 | return s2->in; |
249 | |
250 | /* Test cases are NULL-aware */ |
251 | flags &= ~ESCAPE_NULL; |
252 | |
253 | /* ESCAPE_OCTAL has a higher priority */ |
254 | if (flags & ESCAPE_OCTAL) |
255 | flags &= ~ESCAPE_HEX; |
256 | |
257 | for (i = 0; i < TEST_STRING_2_MAX_S1 && s1->out; i++, s1++) |
258 | if (s1->flags == flags) |
259 | return s1->out; |
260 | return NULL; |
261 | } |
262 | |
263 | static __init void |
264 | test_string_escape_overflow(const char *in, int p, unsigned int flags, const char *esc, |
265 | int q_test, const char *name) |
266 | { |
267 | int q_real; |
268 | |
269 | q_real = string_escape_mem(in, p, NULL, 0, flags, esc); |
270 | if (q_real != q_test) |
271 | pr_warn("Test '%s' failed: flags = %u, osz = 0, expected %d, got %d\n", |
272 | name, flags, q_test, q_real); |
273 | } |
274 | |
275 | static __init void test_string_escape(const char *name, |
276 | const struct test_string_2 *s2, |
277 | unsigned int flags, const char *esc) |
278 | { |
279 | size_t out_size = 512; |
280 | char *out_test = kmalloc(out_size, GFP_KERNEL); |
281 | char *out_real = kmalloc(out_size, GFP_KERNEL); |
282 | char *in = kmalloc(256, GFP_KERNEL); |
283 | int p = 0, q_test = 0; |
284 | int q_real; |
285 | |
286 | if (!out_test || !out_real || !in) |
287 | goto out; |
288 | |
289 | for (; s2->in; s2++) { |
290 | const char *out; |
291 | int len; |
292 | |
293 | /* NULL injection */ |
294 | if (flags & ESCAPE_NULL) { |
295 | in[p++] = '\0'; |
296 | out_test[q_test++] = '\\'; |
297 | out_test[q_test++] = '0'; |
298 | } |
299 | |
300 | /* Don't try strings that have no output */ |
301 | out = test_string_find_match(s2, flags); |
302 | if (!out) |
303 | continue; |
304 | |
305 | /* Copy string to in buffer */ |
306 | len = strlen(s2->in); |
307 | memcpy(&in[p], s2->in, len); |
308 | p += len; |
309 | |
310 | /* Copy expected result for given flags */ |
311 | len = strlen(out); |
312 | memcpy(&out_test[q_test], out, len); |
313 | q_test += len; |
314 | } |
315 | |
316 | q_real = string_escape_mem(in, p, out_real, out_size, flags, esc); |
317 | |
318 | test_string_check_buf(name, flags, in, p, out_real, q_real, out_test, |
319 | q_test); |
320 | |
321 | test_string_escape_overflow(in, p, flags, esc, q_test, name); |
322 | |
323 | out: |
324 | kfree(in); |
325 | kfree(out_real); |
326 | kfree(out_test); |
327 | } |
328 | |
329 | #define string_get_size_maxbuf 16 |
330 | #define test_string_get_size_one(size, blk_size, exp_result10, exp_result2) \ |
331 | do { \ |
332 | BUILD_BUG_ON(sizeof(exp_result10) >= string_get_size_maxbuf); \ |
333 | BUILD_BUG_ON(sizeof(exp_result2) >= string_get_size_maxbuf); \ |
334 | __test_string_get_size((size), (blk_size), (exp_result10), \ |
335 | (exp_result2)); \ |
336 | } while (0) |
337 | |
338 | |
339 | static __init void test_string_get_size_check(const char *units, |
340 | const char *exp, |
341 | char *res, |
342 | const u64 size, |
343 | const u64 blk_size) |
344 | { |
345 | if (!memcmp(res, exp, strlen(exp) + 1)) |
346 | return; |
347 | |
348 | res[string_get_size_maxbuf - 1] = '\0'; |
349 | |
350 | pr_warn("Test 'test_string_get_size' failed!\n"); |
351 | pr_warn("string_get_size(size = %llu, blk_size = %llu, units = %s)\n", |
352 | size, blk_size, units); |
353 | pr_warn("expected: '%s', got '%s'\n", exp, res); |
354 | } |
355 | |
356 | static __init void __test_string_get_size(const u64 size, const u64 blk_size, |
357 | const char *exp_result10, |
358 | const char *exp_result2) |
359 | { |
360 | char buf10[string_get_size_maxbuf]; |
361 | char buf2[string_get_size_maxbuf]; |
362 | |
363 | string_get_size(size, blk_size, STRING_UNITS_10, buf10, sizeof(buf10)); |
364 | string_get_size(size, blk_size, STRING_UNITS_2, buf2, sizeof(buf2)); |
365 | |
366 | test_string_get_size_check("STRING_UNITS_10", exp_result10, buf10, |
367 | size, blk_size); |
368 | |
369 | test_string_get_size_check("STRING_UNITS_2", exp_result2, buf2, |
370 | size, blk_size); |
371 | } |
372 | |
373 | static __init void test_string_get_size(void) |
374 | { |
375 | /* small values */ |
376 | test_string_get_size_one(0, 512, "0 B", "0 B"); |
377 | test_string_get_size_one(1, 512, "512 B", "512 B"); |
378 | test_string_get_size_one(1100, 1, "1.10 kB", "1.07 KiB"); |
379 | |
380 | /* normal values */ |
381 | test_string_get_size_one(16384, 512, "8.39 MB", "8.00 MiB"); |
382 | test_string_get_size_one(500118192, 512, "256 GB", "238 GiB"); |
383 | test_string_get_size_one(8192, 4096, "33.6 MB", "32.0 MiB"); |
384 | |
385 | /* weird block sizes */ |
386 | test_string_get_size_one(3000, 1900, "5.70 MB", "5.44 MiB"); |
387 | |
388 | /* huge values */ |
389 | test_string_get_size_one(U64_MAX, 4096, "75.6 ZB", "64.0 ZiB"); |
390 | test_string_get_size_one(4096, U64_MAX, "75.6 ZB", "64.0 ZiB"); |
391 | } |
392 | |
393 | static int __init test_string_helpers_init(void) |
394 | { |
395 | unsigned int i; |
396 | |
397 | pr_info("Running tests...\n"); |
398 | for (i = 0; i < UNESCAPE_ANY + 1; i++) |
399 | test_string_unescape("unescape", i, false); |
400 | test_string_unescape("unescape inplace", |
401 | get_random_int() % (UNESCAPE_ANY + 1), true); |
402 | |
403 | /* Without dictionary */ |
404 | for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++) |
405 | test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0); |
406 | |
407 | /* With dictionary */ |
408 | for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++) |
409 | test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1); |
410 | |
411 | /* Test string_get_size() */ |
412 | test_string_get_size(); |
413 | |
414 | return -EINVAL; |
415 | } |
416 | module_init(test_string_helpers_init); |
417 | MODULE_LICENSE("Dual BSD/GPL"); |
418 |