Line data Source code
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/device.h>
14 : #include <linux/errno.h>
15 : #include <linux/fs.h>
16 : #include <linux/limits.h>
17 : #include <linux/mm.h>
18 : #include <linux/slab.h>
19 : #include <linux/string.h>
20 : #include <linux/string_helpers.h>
21 :
22 : /**
23 : * string_get_size - get the size in the specified units
24 : * @size: The size to be converted in blocks
25 : * @blk_size: Size of the block (use 1 for size in bytes)
26 : * @units: units to use (powers of 1000 or 1024)
27 : * @buf: buffer to format to
28 : * @len: length of buffer
29 : *
30 : * This function returns a string formatted to 3 significant figures
31 : * giving the size in the required units. @buf should have room for
32 : * at least 9 bytes and will always be zero terminated.
33 : *
34 : */
35 0 : void string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
36 : char *buf, int len)
37 : {
38 : static const char *const units_10[] = {
39 : "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
40 : };
41 : static const char *const units_2[] = {
42 : "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"
43 : };
44 : static const char *const *const units_str[] = {
45 : [STRING_UNITS_10] = units_10,
46 : [STRING_UNITS_2] = units_2,
47 : };
48 : static const unsigned int divisor[] = {
49 : [STRING_UNITS_10] = 1000,
50 : [STRING_UNITS_2] = 1024,
51 : };
52 : static const unsigned int rounding[] = { 500, 50, 5 };
53 0 : int i = 0, j;
54 0 : u32 remainder = 0, sf_cap;
55 : char tmp[8];
56 : const char *unit;
57 :
58 0 : tmp[0] = '\0';
59 :
60 0 : if (blk_size == 0)
61 0 : size = 0;
62 0 : if (size == 0)
63 : goto out;
64 :
65 : /* This is Napier's algorithm. Reduce the original block size to
66 : *
67 : * coefficient * divisor[units]^i
68 : *
69 : * we do the reduction so both coefficients are just under 32 bits so
70 : * that multiplying them together won't overflow 64 bits and we keep
71 : * as much precision as possible in the numbers.
72 : *
73 : * Note: it's safe to throw away the remainders here because all the
74 : * precision is in the coefficients.
75 : */
76 0 : while (blk_size >> 32) {
77 0 : do_div(blk_size, divisor[units]);
78 0 : i++;
79 : }
80 :
81 0 : while (size >> 32) {
82 0 : do_div(size, divisor[units]);
83 0 : i++;
84 : }
85 :
86 : /* now perform the actual multiplication keeping i as the sum of the
87 : * two logarithms */
88 0 : size *= blk_size;
89 :
90 : /* and logarithmically reduce it until it's just under the divisor */
91 0 : while (size >= divisor[units]) {
92 0 : remainder = do_div(size, divisor[units]);
93 0 : i++;
94 : }
95 :
96 : /* work out in j how many digits of precision we need from the
97 : * remainder */
98 0 : sf_cap = size;
99 0 : for (j = 0; sf_cap*10 < 1000; j++)
100 0 : sf_cap *= 10;
101 :
102 0 : if (units == STRING_UNITS_2) {
103 : /* express the remainder as a decimal. It's currently the
104 : * numerator of a fraction whose denominator is
105 : * divisor[units], which is 1 << 10 for STRING_UNITS_2 */
106 0 : remainder *= 1000;
107 0 : remainder >>= 10;
108 : }
109 :
110 : /* add a 5 to the digit below what will be printed to ensure
111 : * an arithmetical round up and carry it through to size */
112 0 : remainder += rounding[j];
113 0 : if (remainder >= 1000) {
114 0 : remainder -= 1000;
115 0 : size += 1;
116 : }
117 :
118 0 : if (j) {
119 0 : snprintf(tmp, sizeof(tmp), ".%03u", remainder);
120 0 : tmp[j+1] = '\0';
121 : }
122 :
123 : out:
124 0 : if (i >= ARRAY_SIZE(units_2))
125 : unit = "UNK";
126 : else
127 0 : unit = units_str[units][i];
128 :
129 0 : snprintf(buf, len, "%u%s %s", (u32)size,
130 : tmp, unit);
131 0 : }
132 : EXPORT_SYMBOL(string_get_size);
133 :
134 : /**
135 : * parse_int_array_user - Split string into a sequence of integers
136 : * @from: The user space buffer to read from
137 : * @count: The maximum number of bytes to read
138 : * @array: Returned pointer to sequence of integers
139 : *
140 : * On success @array is allocated and initialized with a sequence of
141 : * integers extracted from the @from plus an additional element that
142 : * begins the sequence and specifies the integers count.
143 : *
144 : * Caller takes responsibility for freeing @array when it is no longer
145 : * needed.
146 : */
147 0 : int parse_int_array_user(const char __user *from, size_t count, int **array)
148 : {
149 : int *ints, nints;
150 : char *buf;
151 0 : int ret = 0;
152 :
153 0 : buf = memdup_user_nul(from, count);
154 0 : if (IS_ERR(buf))
155 0 : return PTR_ERR(buf);
156 :
157 0 : get_options(buf, 0, &nints);
158 0 : if (!nints) {
159 : ret = -ENOENT;
160 : goto free_buf;
161 : }
162 :
163 0 : ints = kcalloc(nints + 1, sizeof(*ints), GFP_KERNEL);
164 0 : if (!ints) {
165 : ret = -ENOMEM;
166 : goto free_buf;
167 : }
168 :
169 0 : get_options(buf, nints + 1, ints);
170 0 : *array = ints;
171 :
172 : free_buf:
173 0 : kfree(buf);
174 0 : return ret;
175 : }
176 : EXPORT_SYMBOL(parse_int_array_user);
177 :
178 0 : static bool unescape_space(char **src, char **dst)
179 : {
180 0 : char *p = *dst, *q = *src;
181 :
182 0 : switch (*q) {
183 : case 'n':
184 0 : *p = '\n';
185 0 : break;
186 : case 'r':
187 0 : *p = '\r';
188 0 : break;
189 : case 't':
190 0 : *p = '\t';
191 0 : break;
192 : case 'v':
193 0 : *p = '\v';
194 0 : break;
195 : case 'f':
196 0 : *p = '\f';
197 0 : break;
198 : default:
199 : return false;
200 : }
201 0 : *dst += 1;
202 0 : *src += 1;
203 0 : return true;
204 : }
205 :
206 0 : static bool unescape_octal(char **src, char **dst)
207 : {
208 0 : char *p = *dst, *q = *src;
209 : u8 num;
210 :
211 0 : if (isodigit(*q) == 0)
212 : return false;
213 :
214 0 : num = (*q++) & 7;
215 0 : while (num < 32 && isodigit(*q) && (q - *src < 3)) {
216 0 : num <<= 3;
217 0 : num += (*q++) & 7;
218 : }
219 0 : *p = num;
220 0 : *dst += 1;
221 0 : *src = q;
222 0 : return true;
223 : }
224 :
225 0 : static bool unescape_hex(char **src, char **dst)
226 : {
227 0 : char *p = *dst, *q = *src;
228 : int digit;
229 : u8 num;
230 :
231 0 : if (*q++ != 'x')
232 : return false;
233 :
234 0 : num = digit = hex_to_bin(*q++);
235 0 : if (digit < 0)
236 : return false;
237 :
238 0 : digit = hex_to_bin(*q);
239 0 : if (digit >= 0) {
240 0 : q++;
241 0 : num = (num << 4) | digit;
242 : }
243 0 : *p = num;
244 0 : *dst += 1;
245 0 : *src = q;
246 0 : return true;
247 : }
248 :
249 0 : static bool unescape_special(char **src, char **dst)
250 : {
251 0 : char *p = *dst, *q = *src;
252 :
253 0 : switch (*q) {
254 : case '\"':
255 0 : *p = '\"';
256 0 : break;
257 : case '\\':
258 0 : *p = '\\';
259 0 : break;
260 : case 'a':
261 0 : *p = '\a';
262 0 : break;
263 : case 'e':
264 0 : *p = '\e';
265 0 : break;
266 : default:
267 : return false;
268 : }
269 0 : *dst += 1;
270 0 : *src += 1;
271 0 : return true;
272 : }
273 :
274 : /**
275 : * string_unescape - unquote characters in the given string
276 : * @src: source buffer (escaped)
277 : * @dst: destination buffer (unescaped)
278 : * @size: size of the destination buffer (0 to unlimit)
279 : * @flags: combination of the flags.
280 : *
281 : * Description:
282 : * The function unquotes characters in the given string.
283 : *
284 : * Because the size of the output will be the same as or less than the size of
285 : * the input, the transformation may be performed in place.
286 : *
287 : * Caller must provide valid source and destination pointers. Be aware that
288 : * destination buffer will always be NULL-terminated. Source string must be
289 : * NULL-terminated as well. The supported flags are::
290 : *
291 : * UNESCAPE_SPACE:
292 : * '\f' - form feed
293 : * '\n' - new line
294 : * '\r' - carriage return
295 : * '\t' - horizontal tab
296 : * '\v' - vertical tab
297 : * UNESCAPE_OCTAL:
298 : * '\NNN' - byte with octal value NNN (1 to 3 digits)
299 : * UNESCAPE_HEX:
300 : * '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
301 : * UNESCAPE_SPECIAL:
302 : * '\"' - double quote
303 : * '\\' - backslash
304 : * '\a' - alert (BEL)
305 : * '\e' - escape
306 : * UNESCAPE_ANY:
307 : * all previous together
308 : *
309 : * Return:
310 : * The amount of the characters processed to the destination buffer excluding
311 : * trailing '\0' is returned.
312 : */
313 0 : int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
314 : {
315 0 : char *out = dst;
316 :
317 0 : while (*src && --size) {
318 0 : if (src[0] == '\\' && src[1] != '\0' && size > 1) {
319 0 : src++;
320 0 : size--;
321 :
322 0 : if (flags & UNESCAPE_SPACE &&
323 0 : unescape_space(&src, &out))
324 0 : continue;
325 :
326 0 : if (flags & UNESCAPE_OCTAL &&
327 0 : unescape_octal(&src, &out))
328 0 : continue;
329 :
330 0 : if (flags & UNESCAPE_HEX &&
331 0 : unescape_hex(&src, &out))
332 0 : continue;
333 :
334 0 : if (flags & UNESCAPE_SPECIAL &&
335 0 : unescape_special(&src, &out))
336 0 : continue;
337 :
338 0 : *out++ = '\\';
339 : }
340 0 : *out++ = *src++;
341 : }
342 0 : *out = '\0';
343 :
344 0 : return out - dst;
345 : }
346 : EXPORT_SYMBOL(string_unescape);
347 :
348 : static bool escape_passthrough(unsigned char c, char **dst, char *end)
349 : {
350 0 : char *out = *dst;
351 :
352 0 : if (out < end)
353 0 : *out = c;
354 0 : *dst = out + 1;
355 : return true;
356 : }
357 :
358 0 : static bool escape_space(unsigned char c, char **dst, char *end)
359 : {
360 0 : char *out = *dst;
361 : unsigned char to;
362 :
363 0 : switch (c) {
364 : case '\n':
365 : to = 'n';
366 : break;
367 : case '\r':
368 0 : to = 'r';
369 0 : break;
370 : case '\t':
371 0 : to = 't';
372 0 : break;
373 : case '\v':
374 0 : to = 'v';
375 0 : break;
376 : case '\f':
377 0 : to = 'f';
378 0 : break;
379 : default:
380 : return false;
381 : }
382 :
383 0 : if (out < end)
384 0 : *out = '\\';
385 0 : ++out;
386 0 : if (out < end)
387 0 : *out = to;
388 0 : ++out;
389 :
390 0 : *dst = out;
391 0 : return true;
392 : }
393 :
394 : static bool escape_special(unsigned char c, char **dst, char *end)
395 : {
396 0 : char *out = *dst;
397 : unsigned char to;
398 :
399 0 : switch (c) {
400 : case '\\':
401 : to = '\\';
402 : break;
403 : case '\a':
404 0 : to = 'a';
405 : break;
406 : case '\e':
407 0 : to = 'e';
408 : break;
409 : case '"':
410 0 : to = '"';
411 : break;
412 : default:
413 : return false;
414 : }
415 :
416 0 : if (out < end)
417 0 : *out = '\\';
418 0 : ++out;
419 0 : if (out < end)
420 0 : *out = to;
421 0 : ++out;
422 :
423 0 : *dst = out;
424 : return true;
425 : }
426 :
427 : static bool escape_null(unsigned char c, char **dst, char *end)
428 : {
429 0 : char *out = *dst;
430 :
431 0 : if (c)
432 : return false;
433 :
434 0 : if (out < end)
435 0 : *out = '\\';
436 0 : ++out;
437 0 : if (out < end)
438 0 : *out = '0';
439 0 : ++out;
440 :
441 0 : *dst = out;
442 : return true;
443 : }
444 :
445 0 : static bool escape_octal(unsigned char c, char **dst, char *end)
446 : {
447 0 : char *out = *dst;
448 :
449 0 : if (out < end)
450 0 : *out = '\\';
451 0 : ++out;
452 0 : if (out < end)
453 0 : *out = ((c >> 6) & 0x07) + '0';
454 0 : ++out;
455 0 : if (out < end)
456 0 : *out = ((c >> 3) & 0x07) + '0';
457 0 : ++out;
458 0 : if (out < end)
459 0 : *out = ((c >> 0) & 0x07) + '0';
460 0 : ++out;
461 :
462 0 : *dst = out;
463 0 : return true;
464 : }
465 :
466 : static bool escape_hex(unsigned char c, char **dst, char *end)
467 : {
468 0 : char *out = *dst;
469 :
470 0 : if (out < end)
471 0 : *out = '\\';
472 0 : ++out;
473 0 : if (out < end)
474 0 : *out = 'x';
475 0 : ++out;
476 0 : if (out < end)
477 0 : *out = hex_asc_hi(c);
478 0 : ++out;
479 0 : if (out < end)
480 0 : *out = hex_asc_lo(c);
481 0 : ++out;
482 :
483 0 : *dst = out;
484 : return true;
485 : }
486 :
487 : /**
488 : * string_escape_mem - quote characters in the given memory buffer
489 : * @src: source buffer (unescaped)
490 : * @isz: source buffer size
491 : * @dst: destination buffer (escaped)
492 : * @osz: destination buffer size
493 : * @flags: combination of the flags
494 : * @only: NULL-terminated string containing characters used to limit
495 : * the selected escape class. If characters are included in @only
496 : * that would not normally be escaped by the classes selected
497 : * in @flags, they will be copied to @dst unescaped.
498 : *
499 : * Description:
500 : * The process of escaping byte buffer includes several parts. They are applied
501 : * in the following sequence.
502 : *
503 : * 1. The character is not matched to the one from @only string and thus
504 : * must go as-is to the output.
505 : * 2. The character is matched to the printable and ASCII classes, if asked,
506 : * and in case of match it passes through to the output.
507 : * 3. The character is matched to the printable or ASCII class, if asked,
508 : * and in case of match it passes through to the output.
509 : * 4. The character is checked if it falls into the class given by @flags.
510 : * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
511 : * character. Note that they actually can't go together, otherwise
512 : * %ESCAPE_HEX will be ignored.
513 : *
514 : * Caller must provide valid source and destination pointers. Be aware that
515 : * destination buffer will not be NULL-terminated, thus caller have to append
516 : * it if needs. The supported flags are::
517 : *
518 : * %ESCAPE_SPACE: (special white space, not space itself)
519 : * '\f' - form feed
520 : * '\n' - new line
521 : * '\r' - carriage return
522 : * '\t' - horizontal tab
523 : * '\v' - vertical tab
524 : * %ESCAPE_SPECIAL:
525 : * '\"' - double quote
526 : * '\\' - backslash
527 : * '\a' - alert (BEL)
528 : * '\e' - escape
529 : * %ESCAPE_NULL:
530 : * '\0' - null
531 : * %ESCAPE_OCTAL:
532 : * '\NNN' - byte with octal value NNN (3 digits)
533 : * %ESCAPE_ANY:
534 : * all previous together
535 : * %ESCAPE_NP:
536 : * escape only non-printable characters, checked by isprint()
537 : * %ESCAPE_ANY_NP:
538 : * all previous together
539 : * %ESCAPE_HEX:
540 : * '\xHH' - byte with hexadecimal value HH (2 digits)
541 : * %ESCAPE_NA:
542 : * escape only non-ascii characters, checked by isascii()
543 : * %ESCAPE_NAP:
544 : * escape only non-printable or non-ascii characters
545 : * %ESCAPE_APPEND:
546 : * append characters from @only to be escaped by the given classes
547 : *
548 : * %ESCAPE_APPEND would help to pass additional characters to the escaped, when
549 : * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided.
550 : *
551 : * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the
552 : * higher priority than the rest of the flags (%ESCAPE_NAP is the highest).
553 : * It doesn't make much sense to use either of them without %ESCAPE_OCTAL
554 : * or %ESCAPE_HEX, because they cover most of the other character classes.
555 : * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to
556 : * the above.
557 : *
558 : * Return:
559 : * The total size of the escaped output that would be generated for
560 : * the given input and flags. To check whether the output was
561 : * truncated, compare the return value to osz. There is room left in
562 : * dst for a '\0' terminator if and only if ret < osz.
563 : */
564 0 : int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
565 : unsigned int flags, const char *only)
566 : {
567 0 : char *p = dst;
568 0 : char *end = p + osz;
569 0 : bool is_dict = only && *only;
570 0 : bool is_append = flags & ESCAPE_APPEND;
571 :
572 0 : while (isz--) {
573 0 : unsigned char c = *src++;
574 0 : bool in_dict = is_dict && strchr(only, c);
575 :
576 : /*
577 : * Apply rules in the following sequence:
578 : * - the @only string is supplied and does not contain a
579 : * character under question
580 : * - the character is printable and ASCII, when @flags has
581 : * %ESCAPE_NAP bit set
582 : * - the character is printable, when @flags has
583 : * %ESCAPE_NP bit set
584 : * - the character is ASCII, when @flags has
585 : * %ESCAPE_NA bit set
586 : * - the character doesn't fall into a class of symbols
587 : * defined by given @flags
588 : * In these cases we just pass through a character to the
589 : * output buffer.
590 : *
591 : * When %ESCAPE_APPEND is passed, the characters from @only
592 : * have been excluded from the %ESCAPE_NAP, %ESCAPE_NP, and
593 : * %ESCAPE_NA cases.
594 : */
595 0 : if (!(is_append || in_dict) && is_dict &&
596 0 : escape_passthrough(c, &p, end))
597 0 : continue;
598 :
599 0 : if (!(is_append && in_dict) && isascii(c) && isprint(c) &&
600 0 : flags & ESCAPE_NAP && escape_passthrough(c, &p, end))
601 0 : continue;
602 :
603 0 : if (!(is_append && in_dict) && isprint(c) &&
604 0 : flags & ESCAPE_NP && escape_passthrough(c, &p, end))
605 0 : continue;
606 :
607 0 : if (!(is_append && in_dict) && isascii(c) &&
608 0 : flags & ESCAPE_NA && escape_passthrough(c, &p, end))
609 0 : continue;
610 :
611 0 : if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
612 0 : continue;
613 :
614 0 : if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
615 0 : continue;
616 :
617 0 : if (flags & ESCAPE_NULL && escape_null(c, &p, end))
618 0 : continue;
619 :
620 : /* ESCAPE_OCTAL and ESCAPE_HEX always go last */
621 0 : if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
622 0 : continue;
623 :
624 0 : if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
625 0 : continue;
626 :
627 : escape_passthrough(c, &p, end);
628 : }
629 :
630 0 : return p - dst;
631 : }
632 : EXPORT_SYMBOL(string_escape_mem);
633 :
634 : /*
635 : * Return an allocated string that has been escaped of special characters
636 : * and double quotes, making it safe to log in quotes.
637 : */
638 0 : char *kstrdup_quotable(const char *src, gfp_t gfp)
639 : {
640 : size_t slen, dlen;
641 : char *dst;
642 0 : const int flags = ESCAPE_HEX;
643 0 : const char esc[] = "\f\n\r\t\v\a\e\\\"";
644 :
645 0 : if (!src)
646 : return NULL;
647 0 : slen = strlen(src);
648 :
649 0 : dlen = string_escape_mem(src, slen, NULL, 0, flags, esc);
650 0 : dst = kmalloc(dlen + 1, gfp);
651 0 : if (!dst)
652 : return NULL;
653 :
654 0 : WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen);
655 0 : dst[dlen] = '\0';
656 :
657 0 : return dst;
658 : }
659 : EXPORT_SYMBOL_GPL(kstrdup_quotable);
660 :
661 : /*
662 : * Returns allocated NULL-terminated string containing process
663 : * command line, with inter-argument NULLs replaced with spaces,
664 : * and other special characters escaped.
665 : */
666 0 : char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp)
667 : {
668 : char *buffer, *quoted;
669 : int i, res;
670 :
671 0 : buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
672 0 : if (!buffer)
673 : return NULL;
674 :
675 0 : res = get_cmdline(task, buffer, PAGE_SIZE - 1);
676 0 : buffer[res] = '\0';
677 :
678 : /* Collapse trailing NULLs, leave res pointing to last non-NULL. */
679 0 : while (--res >= 0 && buffer[res] == '\0')
680 : ;
681 :
682 : /* Replace inter-argument NULLs. */
683 0 : for (i = 0; i <= res; i++)
684 0 : if (buffer[i] == '\0')
685 0 : buffer[i] = ' ';
686 :
687 : /* Make sure result is printable. */
688 0 : quoted = kstrdup_quotable(buffer, gfp);
689 0 : kfree(buffer);
690 0 : return quoted;
691 : }
692 : EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline);
693 :
694 : /*
695 : * Returns allocated NULL-terminated string containing pathname,
696 : * with special characters escaped, able to be safely logged. If
697 : * there is an error, the leading character will be "<".
698 : */
699 0 : char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
700 : {
701 : char *temp, *pathname;
702 :
703 0 : if (!file)
704 0 : return kstrdup("<unknown>", gfp);
705 :
706 : /* We add 11 spaces for ' (deleted)' to be appended */
707 0 : temp = kmalloc(PATH_MAX + 11, GFP_KERNEL);
708 0 : if (!temp)
709 0 : return kstrdup("<no_memory>", gfp);
710 :
711 0 : pathname = file_path(file, temp, PATH_MAX + 11);
712 0 : if (IS_ERR(pathname))
713 0 : pathname = kstrdup("<too_long>", gfp);
714 : else
715 0 : pathname = kstrdup_quotable(pathname, gfp);
716 :
717 0 : kfree(temp);
718 0 : return pathname;
719 : }
720 : EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
721 :
722 : /**
723 : * kasprintf_strarray - allocate and fill array of sequential strings
724 : * @gfp: flags for the slab allocator
725 : * @prefix: prefix to be used
726 : * @n: amount of lines to be allocated and filled
727 : *
728 : * Allocates and fills @n strings using pattern "%s-%zu", where prefix
729 : * is provided by caller. The caller is responsible to free them with
730 : * kfree_strarray() after use.
731 : *
732 : * Returns array of strings or NULL when memory can't be allocated.
733 : */
734 0 : char **kasprintf_strarray(gfp_t gfp, const char *prefix, size_t n)
735 : {
736 : char **names;
737 : size_t i;
738 :
739 0 : names = kcalloc(n + 1, sizeof(char *), gfp);
740 0 : if (!names)
741 : return NULL;
742 :
743 0 : for (i = 0; i < n; i++) {
744 0 : names[i] = kasprintf(gfp, "%s-%zu", prefix, i);
745 0 : if (!names[i]) {
746 0 : kfree_strarray(names, i);
747 0 : return NULL;
748 : }
749 : }
750 :
751 : return names;
752 : }
753 : EXPORT_SYMBOL_GPL(kasprintf_strarray);
754 :
755 : /**
756 : * kfree_strarray - free a number of dynamically allocated strings contained
757 : * in an array and the array itself
758 : *
759 : * @array: Dynamically allocated array of strings to free.
760 : * @n: Number of strings (starting from the beginning of the array) to free.
761 : *
762 : * Passing a non-NULL @array and @n == 0 as well as NULL @array are valid
763 : * use-cases. If @array is NULL, the function does nothing.
764 : */
765 0 : void kfree_strarray(char **array, size_t n)
766 : {
767 : unsigned int i;
768 :
769 0 : if (!array)
770 : return;
771 :
772 0 : for (i = 0; i < n; i++)
773 0 : kfree(array[i]);
774 0 : kfree(array);
775 : }
776 : EXPORT_SYMBOL_GPL(kfree_strarray);
777 :
778 : struct strarray {
779 : char **array;
780 : size_t n;
781 : };
782 :
783 0 : static void devm_kfree_strarray(struct device *dev, void *res)
784 : {
785 0 : struct strarray *array = res;
786 :
787 0 : kfree_strarray(array->array, array->n);
788 0 : }
789 :
790 0 : char **devm_kasprintf_strarray(struct device *dev, const char *prefix, size_t n)
791 : {
792 : struct strarray *ptr;
793 :
794 0 : ptr = devres_alloc(devm_kfree_strarray, sizeof(*ptr), GFP_KERNEL);
795 0 : if (!ptr)
796 : return ERR_PTR(-ENOMEM);
797 :
798 0 : ptr->array = kasprintf_strarray(GFP_KERNEL, prefix, n);
799 0 : if (!ptr->array) {
800 0 : devres_free(ptr);
801 0 : return ERR_PTR(-ENOMEM);
802 : }
803 :
804 0 : ptr->n = n;
805 0 : devres_add(dev, ptr);
806 :
807 0 : return ptr->array;
808 : }
809 : EXPORT_SYMBOL_GPL(devm_kasprintf_strarray);
810 :
811 : /**
812 : * strscpy_pad() - Copy a C-string into a sized buffer
813 : * @dest: Where to copy the string to
814 : * @src: Where to copy the string from
815 : * @count: Size of destination buffer
816 : *
817 : * Copy the string, or as much of it as fits, into the dest buffer. The
818 : * behavior is undefined if the string buffers overlap. The destination
819 : * buffer is always %NUL terminated, unless it's zero-sized.
820 : *
821 : * If the source string is shorter than the destination buffer, zeros
822 : * the tail of the destination buffer.
823 : *
824 : * For full explanation of why you may want to consider using the
825 : * 'strscpy' functions please see the function docstring for strscpy().
826 : *
827 : * Returns:
828 : * * The number of characters copied (not including the trailing %NUL)
829 : * * -E2BIG if count is 0 or @src was truncated.
830 : */
831 369 : ssize_t strscpy_pad(char *dest, const char *src, size_t count)
832 : {
833 : ssize_t written;
834 :
835 369 : written = strscpy(dest, src, count);
836 369 : if (written < 0 || written == count - 1)
837 : return written;
838 :
839 418 : memset(dest + written + 1, 0, count - written - 1);
840 :
841 209 : return written;
842 : }
843 : EXPORT_SYMBOL(strscpy_pad);
844 :
845 : /**
846 : * skip_spaces - Removes leading whitespace from @str.
847 : * @str: The string to be stripped.
848 : *
849 : * Returns a pointer to the first non-whitespace character in @str.
850 : */
851 70 : char *skip_spaces(const char *str)
852 : {
853 140 : while (isspace(*str))
854 0 : ++str;
855 70 : return (char *)str;
856 : }
857 : EXPORT_SYMBOL(skip_spaces);
858 :
859 : /**
860 : * strim - Removes leading and trailing whitespace from @s.
861 : * @s: The string to be stripped.
862 : *
863 : * Note that the first trailing whitespace is replaced with a %NUL-terminator
864 : * in the given string @s. Returns a pointer to the first non-whitespace
865 : * character in @s.
866 : */
867 0 : char *strim(char *s)
868 : {
869 : size_t size;
870 : char *end;
871 :
872 0 : size = strlen(s);
873 0 : if (!size)
874 : return s;
875 :
876 0 : end = s + size - 1;
877 0 : while (end >= s && isspace(*end))
878 0 : end--;
879 0 : *(end + 1) = '\0';
880 :
881 : return skip_spaces(s);
882 : }
883 : EXPORT_SYMBOL(strim);
884 :
885 : /**
886 : * sysfs_streq - return true if strings are equal, modulo trailing newline
887 : * @s1: one string
888 : * @s2: another string
889 : *
890 : * This routine returns true iff two strings are equal, treating both
891 : * NUL and newline-then-NUL as equivalent string terminations. It's
892 : * geared for use with sysfs input strings, which generally terminate
893 : * with newlines but are compared against values without newlines.
894 : */
895 0 : bool sysfs_streq(const char *s1, const char *s2)
896 : {
897 0 : while (*s1 && *s1 == *s2) {
898 0 : s1++;
899 0 : s2++;
900 : }
901 :
902 0 : if (*s1 == *s2)
903 : return true;
904 0 : if (!*s1 && *s2 == '\n' && !s2[1])
905 : return true;
906 0 : if (*s1 == '\n' && !s1[1] && !*s2)
907 : return true;
908 0 : return false;
909 : }
910 : EXPORT_SYMBOL(sysfs_streq);
911 :
912 : /**
913 : * match_string - matches given string in an array
914 : * @array: array of strings
915 : * @n: number of strings in the array or -1 for NULL terminated arrays
916 : * @string: string to match with
917 : *
918 : * This routine will look for a string in an array of strings up to the
919 : * n-th element in the array or until the first NULL element.
920 : *
921 : * Historically the value of -1 for @n, was used to search in arrays that
922 : * are NULL terminated. However, the function does not make a distinction
923 : * when finishing the search: either @n elements have been compared OR
924 : * the first NULL element was found.
925 : *
926 : * Return:
927 : * index of a @string in the @array if matches, or %-EINVAL otherwise.
928 : */
929 0 : int match_string(const char * const *array, size_t n, const char *string)
930 : {
931 : int index;
932 : const char *item;
933 :
934 0 : for (index = 0; index < n; index++) {
935 0 : item = array[index];
936 0 : if (!item)
937 : break;
938 0 : if (!strcmp(item, string))
939 : return index;
940 : }
941 :
942 : return -EINVAL;
943 : }
944 : EXPORT_SYMBOL(match_string);
945 :
946 : /**
947 : * __sysfs_match_string - matches given string in an array
948 : * @array: array of strings
949 : * @n: number of strings in the array or -1 for NULL terminated arrays
950 : * @str: string to match with
951 : *
952 : * Returns index of @str in the @array or -EINVAL, just like match_string().
953 : * Uses sysfs_streq instead of strcmp for matching.
954 : *
955 : * This routine will look for a string in an array of strings up to the
956 : * n-th element in the array or until the first NULL element.
957 : *
958 : * Historically the value of -1 for @n, was used to search in arrays that
959 : * are NULL terminated. However, the function does not make a distinction
960 : * when finishing the search: either @n elements have been compared OR
961 : * the first NULL element was found.
962 : */
963 0 : int __sysfs_match_string(const char * const *array, size_t n, const char *str)
964 : {
965 : const char *item;
966 : int index;
967 :
968 0 : for (index = 0; index < n; index++) {
969 0 : item = array[index];
970 0 : if (!item)
971 : break;
972 0 : if (sysfs_streq(item, str))
973 : return index;
974 : }
975 :
976 : return -EINVAL;
977 : }
978 : EXPORT_SYMBOL(__sysfs_match_string);
979 :
980 : /**
981 : * strreplace - Replace all occurrences of character in string.
982 : * @str: The string to operate on.
983 : * @old: The character being replaced.
984 : * @new: The character @old is replaced with.
985 : *
986 : * Replaces the each @old character with a @new one in the given string @str.
987 : *
988 : * Return: pointer to the string @str itself.
989 : */
990 0 : char *strreplace(char *str, char old, char new)
991 : {
992 0 : char *s = str;
993 :
994 0 : for (; *s; ++s)
995 0 : if (*s == old)
996 0 : *s = new;
997 0 : return str;
998 : }
999 : EXPORT_SYMBOL(strreplace);
1000 :
1001 : /**
1002 : * memcpy_and_pad - Copy one buffer to another with padding
1003 : * @dest: Where to copy to
1004 : * @dest_len: The destination buffer size
1005 : * @src: Where to copy from
1006 : * @count: The number of bytes to copy
1007 : * @pad: Character to use for padding if space is left in destination.
1008 : */
1009 0 : void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count,
1010 : int pad)
1011 : {
1012 0 : if (dest_len > count) {
1013 0 : memcpy(dest, src, count);
1014 0 : memset(dest + count, pad, dest_len - count);
1015 : } else {
1016 0 : memcpy(dest, src, dest_len);
1017 : }
1018 0 : }
1019 : EXPORT_SYMBOL(memcpy_and_pad);
1020 :
1021 : #ifdef CONFIG_FORTIFY_SOURCE
1022 : /* These are placeholders for fortify compile-time warnings. */
1023 0 : void __read_overflow2_field(size_t avail, size_t wanted) { }
1024 : EXPORT_SYMBOL(__read_overflow2_field);
1025 0 : void __write_overflow_field(size_t avail, size_t wanted) { }
1026 : EXPORT_SYMBOL(__write_overflow_field);
1027 :
1028 0 : void fortify_panic(const char *name)
1029 : {
1030 0 : pr_emerg("detected buffer overflow in %s\n", name);
1031 0 : BUG();
1032 : }
1033 : EXPORT_SYMBOL(fortify_panic);
1034 : #endif /* CONFIG_FORTIFY_SOURCE */
|
