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 (bitwise OR): 235 * %UNESCAPE_SPACE: 236 * '\f' - form feed 237 * '\n' - new line 238 * '\r' - carriage return 239 * '\t' - horizontal tab 240 * '\v' - vertical tab 241 * %UNESCAPE_OCTAL: 242 * '\NNN' - byte with octal value NNN (1 to 3 digits) 243 * %UNESCAPE_HEX: 244 * '\xHH' - byte with hexadecimal value HH (1 to 2 digits) 245 * %UNESCAPE_SPECIAL: 246 * '\"' - double quote 247 * '\\' - backslash 248 * '\a' - alert (BEL) 249 * '\e' - escape 250 * %UNESCAPE_ANY: 251 * all previous together 252 * 253 * Description: 254 * The function unquotes characters in the given string. 255 * 256 * Because the size of the output will be the same as or less than the size of 257 * the input, the transformation may be performed in place. 258 * 259 * Caller must provide valid source and destination pointers. Be aware that 260 * destination buffer will always be NULL-terminated. Source string must be 261 * NULL-terminated as well. 262 * 263 * Return: 264 * The amount of the characters processed to the destination buffer excluding 265 * trailing '\0' is returned. 266 */ 267 int string_unescape(char *src, char *dst, size_t size, unsigned int flags) 268 { 269 char *out = dst; 270 271 while (*src && --size) { 272 if (src[0] == '\\' && src[1] != '\0' && size > 1) { 273 src++; 274 size--; 275 276 if (flags & UNESCAPE_SPACE && 277 unescape_space(&src, &out)) 278 continue; 279 280 if (flags & UNESCAPE_OCTAL && 281 unescape_octal(&src, &out)) 282 continue; 283 284 if (flags & UNESCAPE_HEX && 285 unescape_hex(&src, &out)) 286 continue; 287 288 if (flags & UNESCAPE_SPECIAL && 289 unescape_special(&src, &out)) 290 continue; 291 292 *out++ = '\\'; 293 } 294 *out++ = *src++; 295 } 296 *out = '\0'; 297 298 return out - dst; 299 } 300 EXPORT_SYMBOL(string_unescape); 301 302 static bool escape_passthrough(unsigned char c, char **dst, char *end) 303 { 304 char *out = *dst; 305 306 if (out < end) 307 *out = c; 308 *dst = out + 1; 309 return true; 310 } 311 312 static bool escape_space(unsigned char c, char **dst, char *end) 313 { 314 char *out = *dst; 315 unsigned char to; 316 317 switch (c) { 318 case '\n': 319 to = 'n'; 320 break; 321 case '\r': 322 to = 'r'; 323 break; 324 case '\t': 325 to = 't'; 326 break; 327 case '\v': 328 to = 'v'; 329 break; 330 case '\f': 331 to = 'f'; 332 break; 333 default: 334 return false; 335 } 336 337 if (out < end) 338 *out = '\\'; 339 ++out; 340 if (out < end) 341 *out = to; 342 ++out; 343 344 *dst = out; 345 return true; 346 } 347 348 static bool escape_special(unsigned char c, char **dst, char *end) 349 { 350 char *out = *dst; 351 unsigned char to; 352 353 switch (c) { 354 case '\\': 355 to = '\\'; 356 break; 357 case '\a': 358 to = 'a'; 359 break; 360 case '\e': 361 to = 'e'; 362 break; 363 default: 364 return false; 365 } 366 367 if (out < end) 368 *out = '\\'; 369 ++out; 370 if (out < end) 371 *out = to; 372 ++out; 373 374 *dst = out; 375 return true; 376 } 377 378 static bool escape_null(unsigned char c, char **dst, char *end) 379 { 380 char *out = *dst; 381 382 if (c) 383 return false; 384 385 if (out < end) 386 *out = '\\'; 387 ++out; 388 if (out < end) 389 *out = '0'; 390 ++out; 391 392 *dst = out; 393 return true; 394 } 395 396 static bool escape_octal(unsigned char c, char **dst, char *end) 397 { 398 char *out = *dst; 399 400 if (out < end) 401 *out = '\\'; 402 ++out; 403 if (out < end) 404 *out = ((c >> 6) & 0x07) + '0'; 405 ++out; 406 if (out < end) 407 *out = ((c >> 3) & 0x07) + '0'; 408 ++out; 409 if (out < end) 410 *out = ((c >> 0) & 0x07) + '0'; 411 ++out; 412 413 *dst = out; 414 return true; 415 } 416 417 static bool escape_hex(unsigned char c, char **dst, char *end) 418 { 419 char *out = *dst; 420 421 if (out < end) 422 *out = '\\'; 423 ++out; 424 if (out < end) 425 *out = 'x'; 426 ++out; 427 if (out < end) 428 *out = hex_asc_hi(c); 429 ++out; 430 if (out < end) 431 *out = hex_asc_lo(c); 432 ++out; 433 434 *dst = out; 435 return true; 436 } 437 438 /** 439 * string_escape_mem - quote characters in the given memory buffer 440 * @src: source buffer (unescaped) 441 * @isz: source buffer size 442 * @dst: destination buffer (escaped) 443 * @osz: destination buffer size 444 * @flags: combination of the flags (bitwise OR): 445 * %ESCAPE_SPACE: (special white space, not space itself) 446 * '\f' - form feed 447 * '\n' - new line 448 * '\r' - carriage return 449 * '\t' - horizontal tab 450 * '\v' - vertical tab 451 * %ESCAPE_SPECIAL: 452 * '\\' - backslash 453 * '\a' - alert (BEL) 454 * '\e' - escape 455 * %ESCAPE_NULL: 456 * '\0' - null 457 * %ESCAPE_OCTAL: 458 * '\NNN' - byte with octal value NNN (3 digits) 459 * %ESCAPE_ANY: 460 * all previous together 461 * %ESCAPE_NP: 462 * escape only non-printable characters (checked by isprint) 463 * %ESCAPE_ANY_NP: 464 * all previous together 465 * %ESCAPE_HEX: 466 * '\xHH' - byte with hexadecimal value HH (2 digits) 467 * @only: NULL-terminated string containing characters used to limit 468 * the selected escape class. If characters are included in @only 469 * that would not normally be escaped by the classes selected 470 * in @flags, they will be copied to @dst unescaped. 471 * 472 * Description: 473 * The process of escaping byte buffer includes several parts. They are applied 474 * in the following sequence. 475 * 1. The character is matched to the printable class, if asked, and in 476 * case of match it passes through to the output. 477 * 2. The character is not matched to the one from @only string and thus 478 * must go as-is to the output. 479 * 3. The character is checked if it falls into the class given by @flags. 480 * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any 481 * character. Note that they actually can't go together, otherwise 482 * %ESCAPE_HEX will be ignored. 483 * 484 * Caller must provide valid source and destination pointers. Be aware that 485 * destination buffer will not be NULL-terminated, thus caller have to append 486 * it if needs. 487 * 488 * Return: 489 * The total size of the escaped output that would be generated for 490 * the given input and flags. To check whether the output was 491 * truncated, compare the return value to osz. There is room left in 492 * dst for a '\0' terminator if and only if ret < osz. 493 */ 494 int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, 495 unsigned int flags, const char *only) 496 { 497 char *p = dst; 498 char *end = p + osz; 499 bool is_dict = only && *only; 500 501 while (isz--) { 502 unsigned char c = *src++; 503 504 /* 505 * Apply rules in the following sequence: 506 * - the character is printable, when @flags has 507 * %ESCAPE_NP bit set 508 * - the @only string is supplied and does not contain a 509 * character under question 510 * - the character doesn't fall into a class of symbols 511 * defined by given @flags 512 * In these cases we just pass through a character to the 513 * output buffer. 514 */ 515 if ((flags & ESCAPE_NP && isprint(c)) || 516 (is_dict && !strchr(only, c))) { 517 /* do nothing */ 518 } else { 519 if (flags & ESCAPE_SPACE && escape_space(c, &p, end)) 520 continue; 521 522 if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end)) 523 continue; 524 525 if (flags & ESCAPE_NULL && escape_null(c, &p, end)) 526 continue; 527 528 /* ESCAPE_OCTAL and ESCAPE_HEX always go last */ 529 if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end)) 530 continue; 531 532 if (flags & ESCAPE_HEX && escape_hex(c, &p, end)) 533 continue; 534 } 535 536 escape_passthrough(c, &p, end); 537 } 538 539 return p - dst; 540 } 541 EXPORT_SYMBOL(string_escape_mem); 542 543 int string_escape_mem_ascii(const char *src, size_t isz, char *dst, 544 size_t osz) 545 { 546 char *p = dst; 547 char *end = p + osz; 548 549 while (isz--) { 550 unsigned char c = *src++; 551 552 if (!isprint(c) || !isascii(c) || c == '"' || c == '\\') 553 escape_hex(c, &p, end); 554 else 555 escape_passthrough(c, &p, end); 556 } 557 558 return p - dst; 559 } 560 EXPORT_SYMBOL(string_escape_mem_ascii); 561 562 /* 563 * Return an allocated string that has been escaped of special characters 564 * and double quotes, making it safe to log in quotes. 565 */ 566 char *kstrdup_quotable(const char *src, gfp_t gfp) 567 { 568 size_t slen, dlen; 569 char *dst; 570 const int flags = ESCAPE_HEX; 571 const char esc[] = "\f\n\r\t\v\a\e\\\""; 572 573 if (!src) 574 return NULL; 575 slen = strlen(src); 576 577 dlen = string_escape_mem(src, slen, NULL, 0, flags, esc); 578 dst = kmalloc(dlen + 1, gfp); 579 if (!dst) 580 return NULL; 581 582 WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen); 583 dst[dlen] = '\0'; 584 585 return dst; 586 } 587 EXPORT_SYMBOL_GPL(kstrdup_quotable); 588 589 /* 590 * Returns allocated NULL-terminated string containing process 591 * command line, with inter-argument NULLs replaced with spaces, 592 * and other special characters escaped. 593 */ 594 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp) 595 { 596 char *buffer, *quoted; 597 int i, res; 598 599 buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); 600 if (!buffer) 601 return NULL; 602 603 res = get_cmdline(task, buffer, PAGE_SIZE - 1); 604 buffer[res] = '\0'; 605 606 /* Collapse trailing NULLs, leave res pointing to last non-NULL. */ 607 while (--res >= 0 && buffer[res] == '\0') 608 ; 609 610 /* Replace inter-argument NULLs. */ 611 for (i = 0; i <= res; i++) 612 if (buffer[i] == '\0') 613 buffer[i] = ' '; 614 615 /* Make sure result is printable. */ 616 quoted = kstrdup_quotable(buffer, gfp); 617 kfree(buffer); 618 return quoted; 619 } 620 EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline); 621 622 /* 623 * Returns allocated NULL-terminated string containing pathname, 624 * with special characters escaped, able to be safely logged. If 625 * there is an error, the leading character will be "<". 626 */ 627 char *kstrdup_quotable_file(struct file *file, gfp_t gfp) 628 { 629 char *temp, *pathname; 630 631 if (!file) 632 return kstrdup("<unknown>", gfp); 633 634 /* We add 11 spaces for ' (deleted)' to be appended */ 635 temp = kmalloc(PATH_MAX + 11, GFP_KERNEL); 636 if (!temp) 637 return kstrdup("<no_memory>", gfp); 638 639 pathname = file_path(file, temp, PATH_MAX + 11); 640 if (IS_ERR(pathname)) 641 pathname = kstrdup("<too_long>", gfp); 642 else 643 pathname = kstrdup_quotable(pathname, gfp); 644 645 kfree(temp); 646 return pathname; 647 } 648 EXPORT_SYMBOL_GPL(kstrdup_quotable_file); 649