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  */
string_get_size(u64 size,u64 blk_size,const enum string_size_units units,char * buf,int len)35 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 	int i = 0, j;
54 	u32 remainder = 0, sf_cap;
55 	char tmp[8];
56 	const char *unit;
57 
58 	tmp[0] = '\0';
59 
60 	if (blk_size == 0)
61 		size = 0;
62 	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 	while (blk_size >> 32) {
77 		do_div(blk_size, divisor[units]);
78 		i++;
79 	}
80 
81 	while (size >> 32) {
82 		do_div(size, divisor[units]);
83 		i++;
84 	}
85 
86 	/* now perform the actual multiplication keeping i as the sum of the
87 	 * two logarithms */
88 	size *= blk_size;
89 
90 	/* and logarithmically reduce it until it's just under the divisor */
91 	while (size >= divisor[units]) {
92 		remainder = do_div(size, divisor[units]);
93 		i++;
94 	}
95 
96 	/* work out in j how many digits of precision we need from the
97 	 * remainder */
98 	sf_cap = size;
99 	for (j = 0; sf_cap*10 < 1000; j++)
100 		sf_cap *= 10;
101 
102 	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 		remainder *= 1000;
107 		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 	remainder += rounding[j];
113 	if (remainder >= 1000) {
114 		remainder -= 1000;
115 		size += 1;
116 	}
117 
118 	if (j) {
119 		snprintf(tmp, sizeof(tmp), ".%03u", remainder);
120 		tmp[j+1] = '\0';
121 	}
122 
123  out:
124 	if (i >= ARRAY_SIZE(units_2))
125 		unit = "UNK";
126 	else
127 		unit = units_str[units][i];
128 
129 	snprintf(buf, len, "%u%s %s", (u32)size,
130 		 tmp, unit);
131 }
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  */
parse_int_array_user(const char __user * from,size_t count,int ** array)147 int parse_int_array_user(const char __user *from, size_t count, int **array)
148 {
149 	int *ints, nints;
150 	char *buf;
151 	int ret = 0;
152 
153 	buf = memdup_user_nul(from, count);
154 	if (IS_ERR(buf))
155 		return PTR_ERR(buf);
156 
157 	get_options(buf, 0, &nints);
158 	if (!nints) {
159 		ret = -ENOENT;
160 		goto free_buf;
161 	}
162 
163 	ints = kcalloc(nints + 1, sizeof(*ints), GFP_KERNEL);
164 	if (!ints) {
165 		ret = -ENOMEM;
166 		goto free_buf;
167 	}
168 
169 	get_options(buf, nints + 1, ints);
170 	*array = ints;
171 
172 free_buf:
173 	kfree(buf);
174 	return ret;
175 }
176 EXPORT_SYMBOL(parse_int_array_user);
177 
unescape_space(char ** src,char ** dst)178 static bool unescape_space(char **src, char **dst)
179 {
180 	char *p = *dst, *q = *src;
181 
182 	switch (*q) {
183 	case 'n':
184 		*p = '\n';
185 		break;
186 	case 'r':
187 		*p = '\r';
188 		break;
189 	case 't':
190 		*p = '\t';
191 		break;
192 	case 'v':
193 		*p = '\v';
194 		break;
195 	case 'f':
196 		*p = '\f';
197 		break;
198 	default:
199 		return false;
200 	}
201 	*dst += 1;
202 	*src += 1;
203 	return true;
204 }
205 
unescape_octal(char ** src,char ** dst)206 static bool unescape_octal(char **src, char **dst)
207 {
208 	char *p = *dst, *q = *src;
209 	u8 num;
210 
211 	if (isodigit(*q) == 0)
212 		return false;
213 
214 	num = (*q++) & 7;
215 	while (num < 32 && isodigit(*q) && (q - *src < 3)) {
216 		num <<= 3;
217 		num += (*q++) & 7;
218 	}
219 	*p = num;
220 	*dst += 1;
221 	*src = q;
222 	return true;
223 }
224 
unescape_hex(char ** src,char ** dst)225 static bool unescape_hex(char **src, char **dst)
226 {
227 	char *p = *dst, *q = *src;
228 	int digit;
229 	u8 num;
230 
231 	if (*q++ != 'x')
232 		return false;
233 
234 	num = digit = hex_to_bin(*q++);
235 	if (digit < 0)
236 		return false;
237 
238 	digit = hex_to_bin(*q);
239 	if (digit >= 0) {
240 		q++;
241 		num = (num << 4) | digit;
242 	}
243 	*p = num;
244 	*dst += 1;
245 	*src = q;
246 	return true;
247 }
248 
unescape_special(char ** src,char ** dst)249 static bool unescape_special(char **src, char **dst)
250 {
251 	char *p = *dst, *q = *src;
252 
253 	switch (*q) {
254 	case '\"':
255 		*p = '\"';
256 		break;
257 	case '\\':
258 		*p = '\\';
259 		break;
260 	case 'a':
261 		*p = '\a';
262 		break;
263 	case 'e':
264 		*p = '\e';
265 		break;
266 	default:
267 		return false;
268 	}
269 	*dst += 1;
270 	*src += 1;
271 	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  */
string_unescape(char * src,char * dst,size_t size,unsigned int flags)313 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
314 {
315 	char *out = dst;
316 
317 	while (*src && --size) {
318 		if (src[0] == '\\' && src[1] != '\0' && size > 1) {
319 			src++;
320 			size--;
321 
322 			if (flags & UNESCAPE_SPACE &&
323 					unescape_space(&src, &out))
324 				continue;
325 
326 			if (flags & UNESCAPE_OCTAL &&
327 					unescape_octal(&src, &out))
328 				continue;
329 
330 			if (flags & UNESCAPE_HEX &&
331 					unescape_hex(&src, &out))
332 				continue;
333 
334 			if (flags & UNESCAPE_SPECIAL &&
335 					unescape_special(&src, &out))
336 				continue;
337 
338 			*out++ = '\\';
339 		}
340 		*out++ = *src++;
341 	}
342 	*out = '\0';
343 
344 	return out - dst;
345 }
346 EXPORT_SYMBOL(string_unescape);
347 
escape_passthrough(unsigned char c,char ** dst,char * end)348 static bool escape_passthrough(unsigned char c, char **dst, char *end)
349 {
350 	char *out = *dst;
351 
352 	if (out < end)
353 		*out = c;
354 	*dst = out + 1;
355 	return true;
356 }
357 
escape_space(unsigned char c,char ** dst,char * end)358 static bool escape_space(unsigned char c, char **dst, char *end)
359 {
360 	char *out = *dst;
361 	unsigned char to;
362 
363 	switch (c) {
364 	case '\n':
365 		to = 'n';
366 		break;
367 	case '\r':
368 		to = 'r';
369 		break;
370 	case '\t':
371 		to = 't';
372 		break;
373 	case '\v':
374 		to = 'v';
375 		break;
376 	case '\f':
377 		to = 'f';
378 		break;
379 	default:
380 		return false;
381 	}
382 
383 	if (out < end)
384 		*out = '\\';
385 	++out;
386 	if (out < end)
387 		*out = to;
388 	++out;
389 
390 	*dst = out;
391 	return true;
392 }
393 
escape_special(unsigned char c,char ** dst,char * end)394 static bool escape_special(unsigned char c, char **dst, char *end)
395 {
396 	char *out = *dst;
397 	unsigned char to;
398 
399 	switch (c) {
400 	case '\\':
401 		to = '\\';
402 		break;
403 	case '\a':
404 		to = 'a';
405 		break;
406 	case '\e':
407 		to = 'e';
408 		break;
409 	case '"':
410 		to = '"';
411 		break;
412 	default:
413 		return false;
414 	}
415 
416 	if (out < end)
417 		*out = '\\';
418 	++out;
419 	if (out < end)
420 		*out = to;
421 	++out;
422 
423 	*dst = out;
424 	return true;
425 }
426 
escape_null(unsigned char c,char ** dst,char * end)427 static bool escape_null(unsigned char c, char **dst, char *end)
428 {
429 	char *out = *dst;
430 
431 	if (c)
432 		return false;
433 
434 	if (out < end)
435 		*out = '\\';
436 	++out;
437 	if (out < end)
438 		*out = '0';
439 	++out;
440 
441 	*dst = out;
442 	return true;
443 }
444 
escape_octal(unsigned char c,char ** dst,char * end)445 static bool escape_octal(unsigned char c, char **dst, char *end)
446 {
447 	char *out = *dst;
448 
449 	if (out < end)
450 		*out = '\\';
451 	++out;
452 	if (out < end)
453 		*out = ((c >> 6) & 0x07) + '0';
454 	++out;
455 	if (out < end)
456 		*out = ((c >> 3) & 0x07) + '0';
457 	++out;
458 	if (out < end)
459 		*out = ((c >> 0) & 0x07) + '0';
460 	++out;
461 
462 	*dst = out;
463 	return true;
464 }
465 
escape_hex(unsigned char c,char ** dst,char * end)466 static bool escape_hex(unsigned char c, char **dst, char *end)
467 {
468 	char *out = *dst;
469 
470 	if (out < end)
471 		*out = '\\';
472 	++out;
473 	if (out < end)
474 		*out = 'x';
475 	++out;
476 	if (out < end)
477 		*out = hex_asc_hi(c);
478 	++out;
479 	if (out < end)
480 		*out = hex_asc_lo(c);
481 	++out;
482 
483 	*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  */
string_escape_mem(const char * src,size_t isz,char * dst,size_t osz,unsigned int flags,const char * only)564 int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
565 		      unsigned int flags, const char *only)
566 {
567 	char *p = dst;
568 	char *end = p + osz;
569 	bool is_dict = only && *only;
570 	bool is_append = flags & ESCAPE_APPEND;
571 
572 	while (isz--) {
573 		unsigned char c = *src++;
574 		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 		if (!(is_append || in_dict) && is_dict &&
596 					  escape_passthrough(c, &p, end))
597 			continue;
598 
599 		if (!(is_append && in_dict) && isascii(c) && isprint(c) &&
600 		    flags & ESCAPE_NAP && escape_passthrough(c, &p, end))
601 			continue;
602 
603 		if (!(is_append && in_dict) && isprint(c) &&
604 		    flags & ESCAPE_NP && escape_passthrough(c, &p, end))
605 			continue;
606 
607 		if (!(is_append && in_dict) && isascii(c) &&
608 		    flags & ESCAPE_NA && escape_passthrough(c, &p, end))
609 			continue;
610 
611 		if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
612 			continue;
613 
614 		if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
615 			continue;
616 
617 		if (flags & ESCAPE_NULL && escape_null(c, &p, end))
618 			continue;
619 
620 		/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
621 		if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
622 			continue;
623 
624 		if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
625 			continue;
626 
627 		escape_passthrough(c, &p, end);
628 	}
629 
630 	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  */
kstrdup_quotable(const char * src,gfp_t gfp)638 char *kstrdup_quotable(const char *src, gfp_t gfp)
639 {
640 	size_t slen, dlen;
641 	char *dst;
642 	const int flags = ESCAPE_HEX;
643 	const char esc[] = "\f\n\r\t\v\a\e\\\"";
644 
645 	if (!src)
646 		return NULL;
647 	slen = strlen(src);
648 
649 	dlen = string_escape_mem(src, slen, NULL, 0, flags, esc);
650 	dst = kmalloc(dlen + 1, gfp);
651 	if (!dst)
652 		return NULL;
653 
654 	WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen);
655 	dst[dlen] = '\0';
656 
657 	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  */
kstrdup_quotable_cmdline(struct task_struct * task,gfp_t gfp)666 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp)
667 {
668 	char *buffer, *quoted;
669 	int i, res;
670 
671 	buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
672 	if (!buffer)
673 		return NULL;
674 
675 	res = get_cmdline(task, buffer, PAGE_SIZE - 1);
676 	buffer[res] = '\0';
677 
678 	/* Collapse trailing NULLs, leave res pointing to last non-NULL. */
679 	while (--res >= 0 && buffer[res] == '\0')
680 		;
681 
682 	/* Replace inter-argument NULLs. */
683 	for (i = 0; i <= res; i++)
684 		if (buffer[i] == '\0')
685 			buffer[i] = ' ';
686 
687 	/* Make sure result is printable. */
688 	quoted = kstrdup_quotable(buffer, gfp);
689 	kfree(buffer);
690 	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  */
kstrdup_quotable_file(struct file * file,gfp_t gfp)699 char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
700 {
701 	char *temp, *pathname;
702 
703 	if (!file)
704 		return kstrdup("<unknown>", gfp);
705 
706 	/* We add 11 spaces for ' (deleted)' to be appended */
707 	temp = kmalloc(PATH_MAX + 11, GFP_KERNEL);
708 	if (!temp)
709 		return kstrdup("<no_memory>", gfp);
710 
711 	pathname = file_path(file, temp, PATH_MAX + 11);
712 	if (IS_ERR(pathname))
713 		pathname = kstrdup("<too_long>", gfp);
714 	else
715 		pathname = kstrdup_quotable(pathname, gfp);
716 
717 	kfree(temp);
718 	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  */
kasprintf_strarray(gfp_t gfp,const char * prefix,size_t n)734 char **kasprintf_strarray(gfp_t gfp, const char *prefix, size_t n)
735 {
736 	char **names;
737 	size_t i;
738 
739 	names = kcalloc(n + 1, sizeof(char *), gfp);
740 	if (!names)
741 		return NULL;
742 
743 	for (i = 0; i < n; i++) {
744 		names[i] = kasprintf(gfp, "%s-%zu", prefix, i);
745 		if (!names[i]) {
746 			kfree_strarray(names, i);
747 			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  */
kfree_strarray(char ** array,size_t n)765 void kfree_strarray(char **array, size_t n)
766 {
767 	unsigned int i;
768 
769 	if (!array)
770 		return;
771 
772 	for (i = 0; i < n; i++)
773 		kfree(array[i]);
774 	kfree(array);
775 }
776 EXPORT_SYMBOL_GPL(kfree_strarray);
777 
778 struct strarray {
779 	char **array;
780 	size_t n;
781 };
782 
devm_kfree_strarray(struct device * dev,void * res)783 static void devm_kfree_strarray(struct device *dev, void *res)
784 {
785 	struct strarray *array = res;
786 
787 	kfree_strarray(array->array, array->n);
788 }
789 
devm_kasprintf_strarray(struct device * dev,const char * prefix,size_t n)790 char **devm_kasprintf_strarray(struct device *dev, const char *prefix, size_t n)
791 {
792 	struct strarray *ptr;
793 
794 	ptr = devres_alloc(devm_kfree_strarray, sizeof(*ptr), GFP_KERNEL);
795 	if (!ptr)
796 		return ERR_PTR(-ENOMEM);
797 
798 	ptr->array = kasprintf_strarray(GFP_KERNEL, prefix, n);
799 	if (!ptr->array) {
800 		devres_free(ptr);
801 		return ERR_PTR(-ENOMEM);
802 	}
803 
804 	ptr->n = n;
805 	devres_add(dev, ptr);
806 
807 	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  */
strscpy_pad(char * dest,const char * src,size_t count)831 ssize_t strscpy_pad(char *dest, const char *src, size_t count)
832 {
833 	ssize_t written;
834 
835 	written = strscpy(dest, src, count);
836 	if (written < 0 || written == count - 1)
837 		return written;
838 
839 	memset(dest + written + 1, 0, count - written - 1);
840 
841 	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  */
skip_spaces(const char * str)851 char *skip_spaces(const char *str)
852 {
853 	while (isspace(*str))
854 		++str;
855 	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  */
strim(char * s)867 char *strim(char *s)
868 {
869 	size_t size;
870 	char *end;
871 
872 	size = strlen(s);
873 	if (!size)
874 		return s;
875 
876 	end = s + size - 1;
877 	while (end >= s && isspace(*end))
878 		end--;
879 	*(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  */
sysfs_streq(const char * s1,const char * s2)895 bool sysfs_streq(const char *s1, const char *s2)
896 {
897 	while (*s1 && *s1 == *s2) {
898 		s1++;
899 		s2++;
900 	}
901 
902 	if (*s1 == *s2)
903 		return true;
904 	if (!*s1 && *s2 == '\n' && !s2[1])
905 		return true;
906 	if (*s1 == '\n' && !s1[1] && !*s2)
907 		return true;
908 	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  */
match_string(const char * const * array,size_t n,const char * string)929 int match_string(const char * const *array, size_t n, const char *string)
930 {
931 	int index;
932 	const char *item;
933 
934 	for (index = 0; index < n; index++) {
935 		item = array[index];
936 		if (!item)
937 			break;
938 		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  */
__sysfs_match_string(const char * const * array,size_t n,const char * str)963 int __sysfs_match_string(const char * const *array, size_t n, const char *str)
964 {
965 	const char *item;
966 	int index;
967 
968 	for (index = 0; index < n; index++) {
969 		item = array[index];
970 		if (!item)
971 			break;
972 		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  * @s: The string to operate on.
983  * @old: The character being replaced.
984  * @new: The character @old is replaced with.
985  *
986  * Returns pointer to the nul byte at the end of @s.
987  */
strreplace(char * s,char old,char new)988 char *strreplace(char *s, char old, char new)
989 {
990 	for (; *s; ++s)
991 		if (*s == old)
992 			*s = new;
993 	return s;
994 }
995 EXPORT_SYMBOL(strreplace);
996 
997 /**
998  * memcpy_and_pad - Copy one buffer to another with padding
999  * @dest: Where to copy to
1000  * @dest_len: The destination buffer size
1001  * @src: Where to copy from
1002  * @count: The number of bytes to copy
1003  * @pad: Character to use for padding if space is left in destination.
1004  */
memcpy_and_pad(void * dest,size_t dest_len,const void * src,size_t count,int pad)1005 void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count,
1006 		    int pad)
1007 {
1008 	if (dest_len > count) {
1009 		memcpy(dest, src, count);
1010 		memset(dest + count, pad,  dest_len - count);
1011 	} else {
1012 		memcpy(dest, src, dest_len);
1013 	}
1014 }
1015 EXPORT_SYMBOL(memcpy_and_pad);
1016 
1017 #ifdef CONFIG_FORTIFY_SOURCE
1018 /* These are placeholders for fortify compile-time warnings. */
__read_overflow2_field(size_t avail,size_t wanted)1019 void __read_overflow2_field(size_t avail, size_t wanted) { }
1020 EXPORT_SYMBOL(__read_overflow2_field);
__write_overflow_field(size_t avail,size_t wanted)1021 void __write_overflow_field(size_t avail, size_t wanted) { }
1022 EXPORT_SYMBOL(__write_overflow_field);
1023 
fortify_panic(const char * name)1024 void fortify_panic(const char *name)
1025 {
1026 	pr_emerg("detected buffer overflow in %s\n", name);
1027 	BUG();
1028 }
1029 EXPORT_SYMBOL(fortify_panic);
1030 #endif /* CONFIG_FORTIFY_SOURCE */
1031