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