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