string_helpers.c

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