1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Helpers for formatting and printing strings 4 * 5 * Copyright 31 August 2008 James Bottomley 6 * Copyright (C) 2013, Intel Corporation 7 */ 8 #include <linux/bug.h> 9 #include <linux/kernel.h> 10 #include <linux/math64.h> 11 #include <linux/export.h> 12 #include <linux/ctype.h> 13 #include <linux/errno.h> 14 #include <linux/fs.h> 15 #include <linux/limits.h> 16 #include <linux/mm.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/string_helpers.h> 20 21 /** 22 * string_get_size - get the size in the specified units 23 * @size: The size to be converted in blocks 24 * @blk_size: Size of the block (use 1 for size in bytes) 25 * @units: units to use (powers of 1000 or 1024) 26 * @buf: buffer to format to 27 * @len: length of buffer 28 * 29 * This function returns a string formatted to 3 significant figures 30 * giving the size in the required units. @buf should have room for 31 * at least 9 bytes and will always be zero terminated. 32 * 33 */ 34 void string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 35 char *buf, int len) 36 { 37 static const char *const units_10[] = { 38 "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" 39 }; 40 static const char *const units_2[] = { 41 "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB" 42 }; 43 static const char *const *const units_str[] = { 44 [STRING_UNITS_10] = units_10, 45 [STRING_UNITS_2] = units_2, 46 }; 47 static const unsigned int divisor[] = { 48 [STRING_UNITS_10] = 1000, 49 [STRING_UNITS_2] = 1024, 50 }; 51 static const unsigned int rounding[] = { 500, 50, 5 }; 52 int i = 0, j; 53 u32 remainder = 0, sf_cap; 54 char tmp[8]; 55 const char *unit; 56 57 tmp[0] = '\0'; 58 59 if (blk_size == 0) 60 size = 0; 61 if (size == 0) 62 goto out; 63 64 /* This is Napier's algorithm. Reduce the original block size to 65 * 66 * coefficient * divisor[units]^i 67 * 68 * we do the reduction so both coefficients are just under 32 bits so 69 * that multiplying them together won't overflow 64 bits and we keep 70 * as much precision as possible in the numbers. 71 * 72 * Note: it's safe to throw away the remainders here because all the 73 * precision is in the coefficients. 74 */ 75 while (blk_size >> 32) { 76 do_div(blk_size, divisor[units]); 77 i++; 78 } 79 80 while (size >> 32) { 81 do_div(size, divisor[units]); 82 i++; 83 } 84 85 /* now perform the actual multiplication keeping i as the sum of the 86 * two logarithms */ 87 size *= blk_size; 88 89 /* and logarithmically reduce it until it's just under the divisor */ 90 while (size >= divisor[units]) { 91 remainder = do_div(size, divisor[units]); 92 i++; 93 } 94 95 /* work out in j how many digits of precision we need from the 96 * remainder */ 97 sf_cap = size; 98 for (j = 0; sf_cap*10 < 1000; j++) 99 sf_cap *= 10; 100 101 if (units == STRING_UNITS_2) { 102 /* express the remainder as a decimal. It's currently the 103 * numerator of a fraction whose denominator is 104 * divisor[units], which is 1 << 10 for STRING_UNITS_2 */ 105 remainder *= 1000; 106 remainder >>= 10; 107 } 108 109 /* add a 5 to the digit below what will be printed to ensure 110 * an arithmetical round up and carry it through to size */ 111 remainder += rounding[j]; 112 if (remainder >= 1000) { 113 remainder -= 1000; 114 size += 1; 115 } 116 117 if (j) { 118 snprintf(tmp, sizeof(tmp), ".%03u", remainder); 119 tmp[j+1] = '\0'; 120 } 121 122 out: 123 if (i >= ARRAY_SIZE(units_2)) 124 unit = "UNK"; 125 else 126 unit = units_str[units][i]; 127 128 snprintf(buf, len, "%u%s %s", (u32)size, 129 tmp, unit); 130 } 131 EXPORT_SYMBOL(string_get_size); 132 133 static bool unescape_space(char **src, char **dst) 134 { 135 char *p = *dst, *q = *src; 136 137 switch (*q) { 138 case 'n': 139 *p = '\n'; 140 break; 141 case 'r': 142 *p = '\r'; 143 break; 144 case 't': 145 *p = '\t'; 146 break; 147 case 'v': 148 *p = '\v'; 149 break; 150 case 'f': 151 *p = '\f'; 152 break; 153 default: 154 return false; 155 } 156 *dst += 1; 157 *src += 1; 158 return true; 159 } 160 161 static bool unescape_octal(char **src, char **dst) 162 { 163 char *p = *dst, *q = *src; 164 u8 num; 165 166 if (isodigit(*q) == 0) 167 return false; 168 169 num = (*q++) & 7; 170 while (num < 32 && isodigit(*q) && (q - *src < 3)) { 171 num <<= 3; 172 num += (*q++) & 7; 173 } 174 *p = num; 175 *dst += 1; 176 *src = q; 177 return true; 178 } 179 180 static bool unescape_hex(char **src, char **dst) 181 { 182 char *p = *dst, *q = *src; 183 int digit; 184 u8 num; 185 186 if (*q++ != 'x') 187 return false; 188 189 num = digit = hex_to_bin(*q++); 190 if (digit < 0) 191 return false; 192 193 digit = hex_to_bin(*q); 194 if (digit >= 0) { 195 q++; 196 num = (num << 4) | digit; 197 } 198 *p = num; 199 *dst += 1; 200 *src = q; 201 return true; 202 } 203 204 static bool unescape_special(char **src, char **dst) 205 { 206 char *p = *dst, *q = *src; 207 208 switch (*q) { 209 case '\"': 210 *p = '\"'; 211 break; 212 case '\\': 213 *p = '\\'; 214 break; 215 case 'a': 216 *p = '\a'; 217 break; 218 case 'e': 219 *p = '\e'; 220 break; 221 default: 222 return false; 223 } 224 *dst += 1; 225 *src += 1; 226 return true; 227 } 228 229 /** 230 * string_unescape - unquote characters in the given string 231 * @src: source buffer (escaped) 232 * @dst: destination buffer (unescaped) 233 * @size: size of the destination buffer (0 to unlimit) 234 * @flags: combination of the flags. 235 * 236 * Description: 237 * The function unquotes characters in the given string. 238 * 239 * Because the size of the output will be the same as or less than the size of 240 * the input, the transformation may be performed in place. 241 * 242 * Caller must provide valid source and destination pointers. Be aware that 243 * destination buffer will always be NULL-terminated. Source string must be 244 * NULL-terminated as well. The supported flags are:: 245 * 246 * UNESCAPE_SPACE: 247 * '\f' - form feed 248 * '\n' - new line 249 * '\r' - carriage return 250 * '\t' - horizontal tab 251 * '\v' - vertical tab 252 * UNESCAPE_OCTAL: 253 * '\NNN' - byte with octal value NNN (1 to 3 digits) 254 * UNESCAPE_HEX: 255 * '\xHH' - byte with hexadecimal value HH (1 to 2 digits) 256 * UNESCAPE_SPECIAL: 257 * '\"' - double quote 258 * '\\' - backslash 259 * '\a' - alert (BEL) 260 * '\e' - escape 261 * UNESCAPE_ANY: 262 * all previous together 263 * 264 * Return: 265 * The amount of the characters processed to the destination buffer excluding 266 * trailing '\0' is returned. 267 */ 268 int string_unescape(char *src, char *dst, size_t size, unsigned int flags) 269 { 270 char *out = dst; 271 272 while (*src && --size) { 273 if (src[0] == '\\' && src[1] != '\0' && size > 1) { 274 src++; 275 size--; 276 277 if (flags & UNESCAPE_SPACE && 278 unescape_space(&src, &out)) 279 continue; 280 281 if (flags & UNESCAPE_OCTAL && 282 unescape_octal(&src, &out)) 283 continue; 284 285 if (flags & UNESCAPE_HEX && 286 unescape_hex(&src, &out)) 287 continue; 288 289 if (flags & UNESCAPE_SPECIAL && 290 unescape_special(&src, &out)) 291 continue; 292 293 *out++ = '\\'; 294 } 295 *out++ = *src++; 296 } 297 *out = '\0'; 298 299 return out - dst; 300 } 301 EXPORT_SYMBOL(string_unescape); 302 303 static bool escape_passthrough(unsigned char c, char **dst, char *end) 304 { 305 char *out = *dst; 306 307 if (out < end) 308 *out = c; 309 *dst = out + 1; 310 return true; 311 } 312 313 static bool escape_space(unsigned char c, char **dst, char *end) 314 { 315 char *out = *dst; 316 unsigned char to; 317 318 switch (c) { 319 case '\n': 320 to = 'n'; 321 break; 322 case '\r': 323 to = 'r'; 324 break; 325 case '\t': 326 to = 't'; 327 break; 328 case '\v': 329 to = 'v'; 330 break; 331 case '\f': 332 to = 'f'; 333 break; 334 default: 335 return false; 336 } 337 338 if (out < end) 339 *out = '\\'; 340 ++out; 341 if (out < end) 342 *out = to; 343 ++out; 344 345 *dst = out; 346 return true; 347 } 348 349 static bool escape_special(unsigned char c, char **dst, char *end) 350 { 351 char *out = *dst; 352 unsigned char to; 353 354 switch (c) { 355 case '\\': 356 to = '\\'; 357 break; 358 case '\a': 359 to = 'a'; 360 break; 361 case '\e': 362 to = 'e'; 363 break; 364 default: 365 return false; 366 } 367 368 if (out < end) 369 *out = '\\'; 370 ++out; 371 if (out < end) 372 *out = to; 373 ++out; 374 375 *dst = out; 376 return true; 377 } 378 379 static bool escape_null(unsigned char c, char **dst, char *end) 380 { 381 char *out = *dst; 382 383 if (c) 384 return false; 385 386 if (out < end) 387 *out = '\\'; 388 ++out; 389 if (out < end) 390 *out = '0'; 391 ++out; 392 393 *dst = out; 394 return true; 395 } 396 397 static bool escape_octal(unsigned char c, char **dst, char *end) 398 { 399 char *out = *dst; 400 401 if (out < end) 402 *out = '\\'; 403 ++out; 404 if (out < end) 405 *out = ((c >> 6) & 0x07) + '0'; 406 ++out; 407 if (out < end) 408 *out = ((c >> 3) & 0x07) + '0'; 409 ++out; 410 if (out < end) 411 *out = ((c >> 0) & 0x07) + '0'; 412 ++out; 413 414 *dst = out; 415 return true; 416 } 417 418 static bool escape_hex(unsigned char c, char **dst, char *end) 419 { 420 char *out = *dst; 421 422 if (out < end) 423 *out = '\\'; 424 ++out; 425 if (out < end) 426 *out = 'x'; 427 ++out; 428 if (out < end) 429 *out = hex_asc_hi(c); 430 ++out; 431 if (out < end) 432 *out = hex_asc_lo(c); 433 ++out; 434 435 *dst = out; 436 return true; 437 } 438 439 /** 440 * string_escape_mem - quote characters in the given memory buffer 441 * @src: source buffer (unescaped) 442 * @isz: source buffer size 443 * @dst: destination buffer (escaped) 444 * @osz: destination buffer size 445 * @flags: combination of the flags 446 * @only: NULL-terminated string containing characters used to limit 447 * the selected escape class. If characters are included in @only 448 * that would not normally be escaped by the classes selected 449 * in @flags, they will be copied to @dst unescaped. 450 * 451 * Description: 452 * The process of escaping byte buffer includes several parts. They are applied 453 * in the following sequence. 454 * 455 * 1. The character is matched to the printable class, if asked, and in 456 * case of match it passes through to the output. 457 * 2. The character is not matched to the one from @only string and thus 458 * must go as-is to the output. 459 * 3. The character is checked if it falls into the class given by @flags. 460 * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any 461 * character. Note that they actually can't go together, otherwise 462 * %ESCAPE_HEX will be ignored. 463 * 464 * Caller must provide valid source and destination pointers. Be aware that 465 * destination buffer will not be NULL-terminated, thus caller have to append 466 * it if needs. The supported flags are:: 467 * 468 * %ESCAPE_SPACE: (special white space, not space itself) 469 * '\f' - form feed 470 * '\n' - new line 471 * '\r' - carriage return 472 * '\t' - horizontal tab 473 * '\v' - vertical tab 474 * %ESCAPE_SPECIAL: 475 * '\\' - backslash 476 * '\a' - alert (BEL) 477 * '\e' - escape 478 * %ESCAPE_NULL: 479 * '\0' - null 480 * %ESCAPE_OCTAL: 481 * '\NNN' - byte with octal value NNN (3 digits) 482 * %ESCAPE_ANY: 483 * all previous together 484 * %ESCAPE_NP: 485 * escape only non-printable characters (checked by isprint) 486 * %ESCAPE_ANY_NP: 487 * all previous together 488 * %ESCAPE_HEX: 489 * '\xHH' - byte with hexadecimal value HH (2 digits) 490 * 491 * Return: 492 * The total size of the escaped output that would be generated for 493 * the given input and flags. To check whether the output was 494 * truncated, compare the return value to osz. There is room left in 495 * dst for a '\0' terminator if and only if ret < osz. 496 */ 497 int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, 498 unsigned int flags, const char *only) 499 { 500 char *p = dst; 501 char *end = p + osz; 502 bool is_dict = only && *only; 503 504 while (isz--) { 505 unsigned char c = *src++; 506 507 /* 508 * Apply rules in the following sequence: 509 * - the character is printable, when @flags has 510 * %ESCAPE_NP bit set 511 * - the @only string is supplied and does not contain a 512 * character under question 513 * - the character doesn't fall into a class of symbols 514 * defined by given @flags 515 * In these cases we just pass through a character to the 516 * output buffer. 517 */ 518 if ((flags & ESCAPE_NP && isprint(c)) || 519 (is_dict && !strchr(only, c))) { 520 /* do nothing */ 521 } else { 522 if (flags & ESCAPE_SPACE && escape_space(c, &p, end)) 523 continue; 524 525 if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end)) 526 continue; 527 528 if (flags & ESCAPE_NULL && escape_null(c, &p, end)) 529 continue; 530 531 /* ESCAPE_OCTAL and ESCAPE_HEX always go last */ 532 if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end)) 533 continue; 534 535 if (flags & ESCAPE_HEX && escape_hex(c, &p, end)) 536 continue; 537 } 538 539 escape_passthrough(c, &p, end); 540 } 541 542 return p - dst; 543 } 544 EXPORT_SYMBOL(string_escape_mem); 545 546 int string_escape_mem_ascii(const char *src, size_t isz, char *dst, 547 size_t osz) 548 { 549 char *p = dst; 550 char *end = p + osz; 551 552 while (isz--) { 553 unsigned char c = *src++; 554 555 if (!isprint(c) || !isascii(c) || c == '"' || c == '\\') 556 escape_hex(c, &p, end); 557 else 558 escape_passthrough(c, &p, end); 559 } 560 561 return p - dst; 562 } 563 EXPORT_SYMBOL(string_escape_mem_ascii); 564 565 /* 566 * Return an allocated string that has been escaped of special characters 567 * and double quotes, making it safe to log in quotes. 568 */ 569 char *kstrdup_quotable(const char *src, gfp_t gfp) 570 { 571 size_t slen, dlen; 572 char *dst; 573 const int flags = ESCAPE_HEX; 574 const char esc[] = "\f\n\r\t\v\a\e\\\""; 575 576 if (!src) 577 return NULL; 578 slen = strlen(src); 579 580 dlen = string_escape_mem(src, slen, NULL, 0, flags, esc); 581 dst = kmalloc(dlen + 1, gfp); 582 if (!dst) 583 return NULL; 584 585 WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen); 586 dst[dlen] = '\0'; 587 588 return dst; 589 } 590 EXPORT_SYMBOL_GPL(kstrdup_quotable); 591 592 /* 593 * Returns allocated NULL-terminated string containing process 594 * command line, with inter-argument NULLs replaced with spaces, 595 * and other special characters escaped. 596 */ 597 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp) 598 { 599 char *buffer, *quoted; 600 int i, res; 601 602 buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); 603 if (!buffer) 604 return NULL; 605 606 res = get_cmdline(task, buffer, PAGE_SIZE - 1); 607 buffer[res] = '\0'; 608 609 /* Collapse trailing NULLs, leave res pointing to last non-NULL. */ 610 while (--res >= 0 && buffer[res] == '\0') 611 ; 612 613 /* Replace inter-argument NULLs. */ 614 for (i = 0; i <= res; i++) 615 if (buffer[i] == '\0') 616 buffer[i] = ' '; 617 618 /* Make sure result is printable. */ 619 quoted = kstrdup_quotable(buffer, gfp); 620 kfree(buffer); 621 return quoted; 622 } 623 EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline); 624 625 /* 626 * Returns allocated NULL-terminated string containing pathname, 627 * with special characters escaped, able to be safely logged. If 628 * there is an error, the leading character will be "<". 629 */ 630 char *kstrdup_quotable_file(struct file *file, gfp_t gfp) 631 { 632 char *temp, *pathname; 633 634 if (!file) 635 return kstrdup("<unknown>", gfp); 636 637 /* We add 11 spaces for ' (deleted)' to be appended */ 638 temp = kmalloc(PATH_MAX + 11, GFP_KERNEL); 639 if (!temp) 640 return kstrdup("<no_memory>", gfp); 641 642 pathname = file_path(file, temp, PATH_MAX + 11); 643 if (IS_ERR(pathname)) 644 pathname = kstrdup("<too_long>", gfp); 645 else 646 pathname = kstrdup_quotable(pathname, gfp); 647 648 kfree(temp); 649 return pathname; 650 } 651 EXPORT_SYMBOL_GPL(kstrdup_quotable_file); 652