lib/test-string_helpers.c

   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, units, exp_result)            \
 331         do {                                                                   \
 332                 BUILD_BUG_ON(sizeof(exp_result) >= string_get_size_maxbuf);    \
 333                 __test_string_get_size((size), (blk_size), (units),            \
 334                                        (exp_result));                          \
 335         } while (0)
 336
 337
 338 static __init void __test_string_get_size(const u64 size, const u64 blk_size,
 339                                           const enum string_size_units units,
 340                                           const char *exp_result)
 341 {
 342         char buf[string_get_size_maxbuf];
 343
 344         string_get_size(size, blk_size, units, buf, sizeof(buf));
 345         if (!memcmp(buf, exp_result, strlen(exp_result) + 1))
 346                 return;
 347
 348         buf[sizeof(buf) - 1] = '\0';
 349         pr_warn("Test 'test_string_get_size_one' failed!\n");
 350         pr_warn("string_get_size(size = %llu, blk_size = %llu, units = %d\n",
 351                 size, blk_size, units);
 352         pr_warn("expected: '%s', got '%s'\n", exp_result, buf);
 353 }
 354
 355 static __init void test_string_get_size(void)
 356 {
 357         test_string_get_size_one(16384, 512, STRING_UNITS_2, "8.00 MiB");
 358         test_string_get_size_one(8192, 4096, STRING_UNITS_10, "32.7 MB");
 359         test_string_get_size_one(1, 512, STRING_UNITS_10, "512 B");
 360 }
 361
 362 static int __init test_string_helpers_init(void)
 363 {
 364         unsigned int i;
 365
 366         pr_info("Running tests...\n");
 367         for (i = 0; i < UNESCAPE_ANY + 1; i++)
 368                 test_string_unescape("unescape", i, false);
 369         test_string_unescape("unescape inplace",
 370                              get_random_int() % (UNESCAPE_ANY + 1), true);
 371
 372         /* Without dictionary */
 373         for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
 374                 test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0);
 375
 376         /* With dictionary */
 377         for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
 378                 test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1);
 379
 380         /* Test string_get_size() */
 381         test_string_get_size();
 382
 383         return -EINVAL;
 384 }
 385 module_init(test_string_helpers_init);
 386 MODULE_LICENSE("Dual BSD/GPL");