Linux Audio

Check our new training course

Loading...
v5.14.15
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 *  linux/lib/string.c
   4 *
   5 *  Copyright (C) 1991, 1992  Linus Torvalds
   6 */
   7
   8/*
   9 * stupid library routines.. The optimized versions should generally be found
  10 * as inline code in <asm-xx/string.h>
 
 
  11 *
  12 * These are buggy as well..
  13 *
  14 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
  15 * -  Added strsep() which will replace strtok() soon (because strsep() is
  16 *    reentrant and should be faster). Use only strsep() in new code, please.
  17 *
  18 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>,
  19 *                    Matthew Hawkins <matt@mh.dropbear.id.au>
  20 * -  Kissed strtok() goodbye
  21 */
  22
  23#include <linux/types.h>
  24#include <linux/string.h>
  25#include <linux/ctype.h>
  26#include <linux/kernel.h>
  27#include <linux/export.h>
  28#include <linux/bug.h>
 
  29#include <linux/errno.h>
  30#include <linux/slab.h>
 
 
 
 
  31
  32#include <asm/byteorder.h>
  33#include <asm/word-at-a-time.h>
  34#include <asm/page.h>
 
 
 
  35
  36#ifndef __HAVE_ARCH_STRNCASECMP
  37/**
  38 * strncasecmp - Case insensitive, length-limited string comparison
  39 * @s1: One string
  40 * @s2: The other string
  41 * @len: the maximum number of characters to compare
  42 */
  43int strncasecmp(const char *s1, const char *s2, size_t len)
  44{
  45	/* Yes, Virginia, it had better be unsigned */
  46	unsigned char c1, c2;
  47
  48	if (!len)
  49		return 0;
  50
  51	do {
  52		c1 = *s1++;
  53		c2 = *s2++;
  54		if (!c1 || !c2)
  55			break;
  56		if (c1 == c2)
  57			continue;
  58		c1 = tolower(c1);
  59		c2 = tolower(c2);
  60		if (c1 != c2)
  61			break;
  62	} while (--len);
  63	return (int)c1 - (int)c2;
  64}
  65EXPORT_SYMBOL(strncasecmp);
  66#endif
  67
  68#ifndef __HAVE_ARCH_STRCASECMP
  69int strcasecmp(const char *s1, const char *s2)
  70{
  71	int c1, c2;
  72
  73	do {
  74		c1 = tolower(*s1++);
  75		c2 = tolower(*s2++);
  76	} while (c1 == c2 && c1 != 0);
  77	return c1 - c2;
  78}
  79EXPORT_SYMBOL(strcasecmp);
  80#endif
  81
  82#ifndef __HAVE_ARCH_STRCPY
  83/**
  84 * strcpy - Copy a %NUL terminated string
  85 * @dest: Where to copy the string to
  86 * @src: Where to copy the string from
  87 */
  88char *strcpy(char *dest, const char *src)
  89{
  90	char *tmp = dest;
  91
  92	while ((*dest++ = *src++) != '\0')
  93		/* nothing */;
  94	return tmp;
  95}
  96EXPORT_SYMBOL(strcpy);
  97#endif
  98
  99#ifndef __HAVE_ARCH_STRNCPY
 100/**
 101 * strncpy - Copy a length-limited, C-string
 102 * @dest: Where to copy the string to
 103 * @src: Where to copy the string from
 104 * @count: The maximum number of bytes to copy
 105 *
 106 * The result is not %NUL-terminated if the source exceeds
 107 * @count bytes.
 108 *
 109 * In the case where the length of @src is less than  that  of
 110 * count, the remainder of @dest will be padded with %NUL.
 111 *
 112 */
 113char *strncpy(char *dest, const char *src, size_t count)
 114{
 115	char *tmp = dest;
 116
 117	while (count) {
 118		if ((*tmp = *src) != 0)
 119			src++;
 120		tmp++;
 121		count--;
 122	}
 123	return dest;
 124}
 125EXPORT_SYMBOL(strncpy);
 126#endif
 127
 128#ifndef __HAVE_ARCH_STRLCPY
 129/**
 130 * strlcpy - Copy a C-string into a sized buffer
 131 * @dest: Where to copy the string to
 132 * @src: Where to copy the string from
 133 * @size: size of destination buffer
 134 *
 135 * Compatible with ``*BSD``: the result is always a valid
 136 * NUL-terminated string that fits in the buffer (unless,
 137 * of course, the buffer size is zero). It does not pad
 138 * out the result like strncpy() does.
 139 */
 140size_t strlcpy(char *dest, const char *src, size_t size)
 141{
 142	size_t ret = strlen(src);
 143
 144	if (size) {
 145		size_t len = (ret >= size) ? size - 1 : ret;
 146		memcpy(dest, src, len);
 147		dest[len] = '\0';
 148	}
 149	return ret;
 150}
 151EXPORT_SYMBOL(strlcpy);
 152#endif
 153
 154#ifndef __HAVE_ARCH_STRSCPY
 155/**
 156 * strscpy - Copy a C-string into a sized buffer
 157 * @dest: Where to copy the string to
 158 * @src: Where to copy the string from
 159 * @count: Size of destination buffer
 160 *
 161 * Copy the string, or as much of it as fits, into the dest buffer.  The
 162 * behavior is undefined if the string buffers overlap.  The destination
 163 * buffer is always NUL terminated, unless it's zero-sized.
 164 *
 165 * Preferred to strlcpy() since the API doesn't require reading memory
 166 * from the src string beyond the specified "count" bytes, and since
 167 * the return value is easier to error-check than strlcpy()'s.
 168 * In addition, the implementation is robust to the string changing out
 169 * from underneath it, unlike the current strlcpy() implementation.
 170 *
 171 * Preferred to strncpy() since it always returns a valid string, and
 172 * doesn't unnecessarily force the tail of the destination buffer to be
 173 * zeroed.  If zeroing is desired please use strscpy_pad().
 174 *
 175 * Returns:
 176 * * The number of characters copied (not including the trailing %NUL)
 177 * * -E2BIG if count is 0 or @src was truncated.
 178 */
 179ssize_t strscpy(char *dest, const char *src, size_t count)
 180{
 181	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 182	size_t max = count;
 183	long res = 0;
 184
 185	if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
 186		return -E2BIG;
 187
 188#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 189	/*
 190	 * If src is unaligned, don't cross a page boundary,
 191	 * since we don't know if the next page is mapped.
 192	 */
 193	if ((long)src & (sizeof(long) - 1)) {
 194		size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
 195		if (limit < max)
 196			max = limit;
 197	}
 198#else
 199	/* If src or dest is unaligned, don't do word-at-a-time. */
 200	if (((long) dest | (long) src) & (sizeof(long) - 1))
 201		max = 0;
 202#endif
 203
 
 
 
 
 
 
 
 
 204	while (max >= sizeof(unsigned long)) {
 205		unsigned long c, data;
 206
 207		c = read_word_at_a_time(src+res);
 208		if (has_zero(c, &data, &constants)) {
 209			data = prep_zero_mask(c, data, &constants);
 210			data = create_zero_mask(data);
 211			*(unsigned long *)(dest+res) = c & zero_bytemask(data);
 212			return res + find_zero(data);
 213		}
 
 
 
 
 
 
 214		*(unsigned long *)(dest+res) = c;
 215		res += sizeof(unsigned long);
 216		count -= sizeof(unsigned long);
 217		max -= sizeof(unsigned long);
 218	}
 219
 220	while (count) {
 221		char c;
 222
 223		c = src[res];
 224		dest[res] = c;
 225		if (!c)
 226			return res;
 227		res++;
 228		count--;
 229	}
 230
 231	/* Hit buffer length without finding a NUL; force NUL-termination. */
 232	if (res)
 233		dest[res-1] = '\0';
 234
 235	return -E2BIG;
 
 236}
 237EXPORT_SYMBOL(strscpy);
 238#endif
 239
 240/**
 241 * strscpy_pad() - Copy a C-string into a sized buffer
 242 * @dest: Where to copy the string to
 243 * @src: Where to copy the string from
 244 * @count: Size of destination buffer
 245 *
 246 * Copy the string, or as much of it as fits, into the dest buffer.  The
 247 * behavior is undefined if the string buffers overlap.  The destination
 248 * buffer is always %NUL terminated, unless it's zero-sized.
 249 *
 250 * If the source string is shorter than the destination buffer, zeros
 251 * the tail of the destination buffer.
 252 *
 253 * For full explanation of why you may want to consider using the
 254 * 'strscpy' functions please see the function docstring for strscpy().
 255 *
 256 * Returns:
 257 * * The number of characters copied (not including the trailing %NUL)
 258 * * -E2BIG if count is 0 or @src was truncated.
 259 */
 260ssize_t strscpy_pad(char *dest, const char *src, size_t count)
 261{
 262	ssize_t written;
 263
 264	written = strscpy(dest, src, count);
 265	if (written < 0 || written == count - 1)
 266		return written;
 267
 268	memset(dest + written + 1, 0, count - written - 1);
 269
 270	return written;
 271}
 272EXPORT_SYMBOL(strscpy_pad);
 273
 274/**
 275 * stpcpy - copy a string from src to dest returning a pointer to the new end
 276 *          of dest, including src's %NUL-terminator. May overrun dest.
 277 * @dest: pointer to end of string being copied into. Must be large enough
 278 *        to receive copy.
 279 * @src: pointer to the beginning of string being copied from. Must not overlap
 280 *       dest.
 281 *
 282 * stpcpy differs from strcpy in a key way: the return value is a pointer
 283 * to the new %NUL-terminating character in @dest. (For strcpy, the return
 284 * value is a pointer to the start of @dest). This interface is considered
 285 * unsafe as it doesn't perform bounds checking of the inputs. As such it's
 286 * not recommended for usage. Instead, its definition is provided in case
 287 * the compiler lowers other libcalls to stpcpy.
 288 */
 289char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
 290char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
 291{
 292	while ((*dest++ = *src++) != '\0')
 293		/* nothing */;
 294	return --dest;
 295}
 296EXPORT_SYMBOL(stpcpy);
 297
 298#ifndef __HAVE_ARCH_STRCAT
 299/**
 300 * strcat - Append one %NUL-terminated string to another
 301 * @dest: The string to be appended to
 302 * @src: The string to append to it
 303 */
 304char *strcat(char *dest, const char *src)
 305{
 306	char *tmp = dest;
 307
 308	while (*dest)
 309		dest++;
 310	while ((*dest++ = *src++) != '\0')
 311		;
 312	return tmp;
 313}
 314EXPORT_SYMBOL(strcat);
 315#endif
 316
 317#ifndef __HAVE_ARCH_STRNCAT
 318/**
 319 * strncat - Append a length-limited, C-string to another
 320 * @dest: The string to be appended to
 321 * @src: The string to append to it
 322 * @count: The maximum numbers of bytes to copy
 323 *
 324 * Note that in contrast to strncpy(), strncat() ensures the result is
 325 * terminated.
 326 */
 327char *strncat(char *dest, const char *src, size_t count)
 328{
 329	char *tmp = dest;
 330
 331	if (count) {
 332		while (*dest)
 333			dest++;
 334		while ((*dest++ = *src++) != 0) {
 335			if (--count == 0) {
 336				*dest = '\0';
 337				break;
 338			}
 339		}
 340	}
 341	return tmp;
 342}
 343EXPORT_SYMBOL(strncat);
 344#endif
 345
 346#ifndef __HAVE_ARCH_STRLCAT
 347/**
 348 * strlcat - Append a length-limited, C-string to another
 349 * @dest: The string to be appended to
 350 * @src: The string to append to it
 351 * @count: The size of the destination buffer.
 352 */
 353size_t strlcat(char *dest, const char *src, size_t count)
 354{
 355	size_t dsize = strlen(dest);
 356	size_t len = strlen(src);
 357	size_t res = dsize + len;
 358
 359	/* This would be a bug */
 360	BUG_ON(dsize >= count);
 361
 362	dest += dsize;
 363	count -= dsize;
 364	if (len >= count)
 365		len = count-1;
 366	memcpy(dest, src, len);
 367	dest[len] = 0;
 368	return res;
 369}
 370EXPORT_SYMBOL(strlcat);
 371#endif
 372
 373#ifndef __HAVE_ARCH_STRCMP
 374/**
 375 * strcmp - Compare two strings
 376 * @cs: One string
 377 * @ct: Another string
 378 */
 379int strcmp(const char *cs, const char *ct)
 380{
 381	unsigned char c1, c2;
 382
 383	while (1) {
 384		c1 = *cs++;
 385		c2 = *ct++;
 386		if (c1 != c2)
 387			return c1 < c2 ? -1 : 1;
 388		if (!c1)
 389			break;
 390	}
 391	return 0;
 392}
 393EXPORT_SYMBOL(strcmp);
 394#endif
 395
 396#ifndef __HAVE_ARCH_STRNCMP
 397/**
 398 * strncmp - Compare two length-limited strings
 399 * @cs: One string
 400 * @ct: Another string
 401 * @count: The maximum number of bytes to compare
 402 */
 403int strncmp(const char *cs, const char *ct, size_t count)
 404{
 405	unsigned char c1, c2;
 406
 407	while (count) {
 408		c1 = *cs++;
 409		c2 = *ct++;
 410		if (c1 != c2)
 411			return c1 < c2 ? -1 : 1;
 412		if (!c1)
 413			break;
 414		count--;
 415	}
 416	return 0;
 417}
 418EXPORT_SYMBOL(strncmp);
 419#endif
 420
 421#ifndef __HAVE_ARCH_STRCHR
 422/**
 423 * strchr - Find the first occurrence of a character in a string
 424 * @s: The string to be searched
 425 * @c: The character to search for
 426 *
 427 * Note that the %NUL-terminator is considered part of the string, and can
 428 * be searched for.
 429 */
 430char *strchr(const char *s, int c)
 431{
 432	for (; *s != (char)c; ++s)
 433		if (*s == '\0')
 434			return NULL;
 435	return (char *)s;
 436}
 437EXPORT_SYMBOL(strchr);
 438#endif
 439
 440#ifndef __HAVE_ARCH_STRCHRNUL
 441/**
 442 * strchrnul - Find and return a character in a string, or end of string
 443 * @s: The string to be searched
 444 * @c: The character to search for
 445 *
 446 * Returns pointer to first occurrence of 'c' in s. If c is not found, then
 447 * return a pointer to the null byte at the end of s.
 448 */
 449char *strchrnul(const char *s, int c)
 450{
 451	while (*s && *s != (char)c)
 452		s++;
 453	return (char *)s;
 454}
 455EXPORT_SYMBOL(strchrnul);
 456#endif
 457
 458/**
 459 * strnchrnul - Find and return a character in a length limited string,
 460 * or end of string
 461 * @s: The string to be searched
 462 * @count: The number of characters to be searched
 463 * @c: The character to search for
 464 *
 465 * Returns pointer to the first occurrence of 'c' in s. If c is not found,
 466 * then return a pointer to the last character of the string.
 467 */
 468char *strnchrnul(const char *s, size_t count, int c)
 469{
 470	while (count-- && *s && *s != (char)c)
 471		s++;
 472	return (char *)s;
 473}
 474
 475#ifndef __HAVE_ARCH_STRRCHR
 476/**
 477 * strrchr - Find the last occurrence of a character in a string
 478 * @s: The string to be searched
 479 * @c: The character to search for
 480 */
 481char *strrchr(const char *s, int c)
 482{
 483	const char *last = NULL;
 484	do {
 485		if (*s == (char)c)
 486			last = s;
 487	} while (*s++);
 488	return (char *)last;
 489}
 490EXPORT_SYMBOL(strrchr);
 491#endif
 492
 493#ifndef __HAVE_ARCH_STRNCHR
 494/**
 495 * strnchr - Find a character in a length limited string
 496 * @s: The string to be searched
 497 * @count: The number of characters to be searched
 498 * @c: The character to search for
 499 *
 500 * Note that the %NUL-terminator is considered part of the string, and can
 501 * be searched for.
 502 */
 503char *strnchr(const char *s, size_t count, int c)
 504{
 505	while (count--) {
 506		if (*s == (char)c)
 507			return (char *)s;
 508		if (*s++ == '\0')
 509			break;
 510	}
 511	return NULL;
 512}
 513EXPORT_SYMBOL(strnchr);
 514#endif
 515
 516/**
 517 * skip_spaces - Removes leading whitespace from @str.
 518 * @str: The string to be stripped.
 519 *
 520 * Returns a pointer to the first non-whitespace character in @str.
 521 */
 522char *skip_spaces(const char *str)
 523{
 524	while (isspace(*str))
 525		++str;
 526	return (char *)str;
 527}
 528EXPORT_SYMBOL(skip_spaces);
 529
 530/**
 531 * strim - Removes leading and trailing whitespace from @s.
 532 * @s: The string to be stripped.
 533 *
 534 * Note that the first trailing whitespace is replaced with a %NUL-terminator
 535 * in the given string @s. Returns a pointer to the first non-whitespace
 536 * character in @s.
 537 */
 538char *strim(char *s)
 539{
 540	size_t size;
 541	char *end;
 542
 543	size = strlen(s);
 544	if (!size)
 545		return s;
 546
 547	end = s + size - 1;
 548	while (end >= s && isspace(*end))
 549		end--;
 550	*(end + 1) = '\0';
 551
 552	return skip_spaces(s);
 553}
 554EXPORT_SYMBOL(strim);
 555
 556#ifndef __HAVE_ARCH_STRLEN
 557/**
 558 * strlen - Find the length of a string
 559 * @s: The string to be sized
 560 */
 561size_t strlen(const char *s)
 562{
 563	const char *sc;
 564
 565	for (sc = s; *sc != '\0'; ++sc)
 566		/* nothing */;
 567	return sc - s;
 568}
 569EXPORT_SYMBOL(strlen);
 570#endif
 571
 572#ifndef __HAVE_ARCH_STRNLEN
 573/**
 574 * strnlen - Find the length of a length-limited string
 575 * @s: The string to be sized
 576 * @count: The maximum number of bytes to search
 577 */
 578size_t strnlen(const char *s, size_t count)
 579{
 580	const char *sc;
 581
 582	for (sc = s; count-- && *sc != '\0'; ++sc)
 583		/* nothing */;
 584	return sc - s;
 585}
 586EXPORT_SYMBOL(strnlen);
 587#endif
 588
 589#ifndef __HAVE_ARCH_STRSPN
 590/**
 591 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
 592 * @s: The string to be searched
 593 * @accept: The string to search for
 594 */
 595size_t strspn(const char *s, const char *accept)
 596{
 597	const char *p;
 598	const char *a;
 599	size_t count = 0;
 600
 601	for (p = s; *p != '\0'; ++p) {
 602		for (a = accept; *a != '\0'; ++a) {
 603			if (*p == *a)
 604				break;
 605		}
 606		if (*a == '\0')
 607			return count;
 608		++count;
 609	}
 610	return count;
 611}
 612
 613EXPORT_SYMBOL(strspn);
 614#endif
 615
 616#ifndef __HAVE_ARCH_STRCSPN
 617/**
 618 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
 619 * @s: The string to be searched
 620 * @reject: The string to avoid
 621 */
 622size_t strcspn(const char *s, const char *reject)
 623{
 624	const char *p;
 625	const char *r;
 626	size_t count = 0;
 627
 628	for (p = s; *p != '\0'; ++p) {
 629		for (r = reject; *r != '\0'; ++r) {
 630			if (*p == *r)
 631				return count;
 632		}
 633		++count;
 634	}
 635	return count;
 636}
 637EXPORT_SYMBOL(strcspn);
 638#endif
 639
 640#ifndef __HAVE_ARCH_STRPBRK
 641/**
 642 * strpbrk - Find the first occurrence of a set of characters
 643 * @cs: The string to be searched
 644 * @ct: The characters to search for
 645 */
 646char *strpbrk(const char *cs, const char *ct)
 647{
 648	const char *sc1, *sc2;
 649
 650	for (sc1 = cs; *sc1 != '\0'; ++sc1) {
 651		for (sc2 = ct; *sc2 != '\0'; ++sc2) {
 652			if (*sc1 == *sc2)
 653				return (char *)sc1;
 654		}
 655	}
 656	return NULL;
 657}
 658EXPORT_SYMBOL(strpbrk);
 659#endif
 660
 661#ifndef __HAVE_ARCH_STRSEP
 662/**
 663 * strsep - Split a string into tokens
 664 * @s: The string to be searched
 665 * @ct: The characters to search for
 666 *
 667 * strsep() updates @s to point after the token, ready for the next call.
 668 *
 669 * It returns empty tokens, too, behaving exactly like the libc function
 670 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
 671 * Same semantics, slimmer shape. ;)
 672 */
 673char *strsep(char **s, const char *ct)
 674{
 675	char *sbegin = *s;
 676	char *end;
 677
 678	if (sbegin == NULL)
 679		return NULL;
 680
 681	end = strpbrk(sbegin, ct);
 682	if (end)
 683		*end++ = '\0';
 684	*s = end;
 685	return sbegin;
 686}
 687EXPORT_SYMBOL(strsep);
 688#endif
 689
 690/**
 691 * sysfs_streq - return true if strings are equal, modulo trailing newline
 692 * @s1: one string
 693 * @s2: another string
 694 *
 695 * This routine returns true iff two strings are equal, treating both
 696 * NUL and newline-then-NUL as equivalent string terminations.  It's
 697 * geared for use with sysfs input strings, which generally terminate
 698 * with newlines but are compared against values without newlines.
 699 */
 700bool sysfs_streq(const char *s1, const char *s2)
 701{
 702	while (*s1 && *s1 == *s2) {
 703		s1++;
 704		s2++;
 705	}
 706
 707	if (*s1 == *s2)
 708		return true;
 709	if (!*s1 && *s2 == '\n' && !s2[1])
 710		return true;
 711	if (*s1 == '\n' && !s1[1] && !*s2)
 712		return true;
 713	return false;
 714}
 715EXPORT_SYMBOL(sysfs_streq);
 716
 717/**
 718 * match_string - matches given string in an array
 719 * @array:	array of strings
 720 * @n:		number of strings in the array or -1 for NULL terminated arrays
 721 * @string:	string to match with
 722 *
 723 * This routine will look for a string in an array of strings up to the
 724 * n-th element in the array or until the first NULL element.
 725 *
 726 * Historically the value of -1 for @n, was used to search in arrays that
 727 * are NULL terminated. However, the function does not make a distinction
 728 * when finishing the search: either @n elements have been compared OR
 729 * the first NULL element was found.
 730 *
 731 * Return:
 732 * index of a @string in the @array if matches, or %-EINVAL otherwise.
 733 */
 734int match_string(const char * const *array, size_t n, const char *string)
 735{
 736	int index;
 737	const char *item;
 738
 739	for (index = 0; index < n; index++) {
 740		item = array[index];
 741		if (!item)
 742			break;
 743		if (!strcmp(item, string))
 744			return index;
 745	}
 746
 747	return -EINVAL;
 748}
 749EXPORT_SYMBOL(match_string);
 750
 751/**
 752 * __sysfs_match_string - matches given string in an array
 753 * @array: array of strings
 754 * @n: number of strings in the array or -1 for NULL terminated arrays
 755 * @str: string to match with
 756 *
 757 * Returns index of @str in the @array or -EINVAL, just like match_string().
 758 * Uses sysfs_streq instead of strcmp for matching.
 759 *
 760 * This routine will look for a string in an array of strings up to the
 761 * n-th element in the array or until the first NULL element.
 762 *
 763 * Historically the value of -1 for @n, was used to search in arrays that
 764 * are NULL terminated. However, the function does not make a distinction
 765 * when finishing the search: either @n elements have been compared OR
 766 * the first NULL element was found.
 767 */
 768int __sysfs_match_string(const char * const *array, size_t n, const char *str)
 769{
 770	const char *item;
 771	int index;
 772
 773	for (index = 0; index < n; index++) {
 774		item = array[index];
 775		if (!item)
 776			break;
 777		if (sysfs_streq(item, str))
 778			return index;
 779	}
 780
 781	return -EINVAL;
 782}
 783EXPORT_SYMBOL(__sysfs_match_string);
 784
 785#ifndef __HAVE_ARCH_MEMSET
 786/**
 787 * memset - Fill a region of memory with the given value
 788 * @s: Pointer to the start of the area.
 789 * @c: The byte to fill the area with
 790 * @count: The size of the area.
 791 *
 792 * Do not use memset() to access IO space, use memset_io() instead.
 793 */
 794void *memset(void *s, int c, size_t count)
 795{
 796	char *xs = s;
 797
 798	while (count--)
 799		*xs++ = c;
 800	return s;
 801}
 802EXPORT_SYMBOL(memset);
 803#endif
 804
 805#ifndef __HAVE_ARCH_MEMSET16
 806/**
 807 * memset16() - Fill a memory area with a uint16_t
 808 * @s: Pointer to the start of the area.
 809 * @v: The value to fill the area with
 810 * @count: The number of values to store
 811 *
 812 * Differs from memset() in that it fills with a uint16_t instead
 813 * of a byte.  Remember that @count is the number of uint16_ts to
 814 * store, not the number of bytes.
 815 */
 816void *memset16(uint16_t *s, uint16_t v, size_t count)
 817{
 818	uint16_t *xs = s;
 819
 820	while (count--)
 821		*xs++ = v;
 822	return s;
 823}
 824EXPORT_SYMBOL(memset16);
 825#endif
 826
 827#ifndef __HAVE_ARCH_MEMSET32
 828/**
 829 * memset32() - Fill a memory area with a uint32_t
 830 * @s: Pointer to the start of the area.
 831 * @v: The value to fill the area with
 832 * @count: The number of values to store
 833 *
 834 * Differs from memset() in that it fills with a uint32_t instead
 835 * of a byte.  Remember that @count is the number of uint32_ts to
 836 * store, not the number of bytes.
 837 */
 838void *memset32(uint32_t *s, uint32_t v, size_t count)
 839{
 840	uint32_t *xs = s;
 841
 842	while (count--)
 843		*xs++ = v;
 844	return s;
 845}
 846EXPORT_SYMBOL(memset32);
 847#endif
 848
 849#ifndef __HAVE_ARCH_MEMSET64
 850/**
 851 * memset64() - Fill a memory area with a uint64_t
 852 * @s: Pointer to the start of the area.
 853 * @v: The value to fill the area with
 854 * @count: The number of values to store
 855 *
 856 * Differs from memset() in that it fills with a uint64_t instead
 857 * of a byte.  Remember that @count is the number of uint64_ts to
 858 * store, not the number of bytes.
 859 */
 860void *memset64(uint64_t *s, uint64_t v, size_t count)
 861{
 862	uint64_t *xs = s;
 863
 864	while (count--)
 865		*xs++ = v;
 866	return s;
 867}
 868EXPORT_SYMBOL(memset64);
 869#endif
 870
 871#ifndef __HAVE_ARCH_MEMCPY
 872/**
 873 * memcpy - Copy one area of memory to another
 874 * @dest: Where to copy to
 875 * @src: Where to copy from
 876 * @count: The size of the area.
 877 *
 878 * You should not use this function to access IO space, use memcpy_toio()
 879 * or memcpy_fromio() instead.
 880 */
 881void *memcpy(void *dest, const void *src, size_t count)
 882{
 883	char *tmp = dest;
 884	const char *s = src;
 885
 886	while (count--)
 887		*tmp++ = *s++;
 888	return dest;
 889}
 890EXPORT_SYMBOL(memcpy);
 891#endif
 892
 893#ifndef __HAVE_ARCH_MEMMOVE
 894/**
 895 * memmove - Copy one area of memory to another
 896 * @dest: Where to copy to
 897 * @src: Where to copy from
 898 * @count: The size of the area.
 899 *
 900 * Unlike memcpy(), memmove() copes with overlapping areas.
 901 */
 902void *memmove(void *dest, const void *src, size_t count)
 903{
 904	char *tmp;
 905	const char *s;
 906
 907	if (dest <= src) {
 908		tmp = dest;
 909		s = src;
 910		while (count--)
 911			*tmp++ = *s++;
 912	} else {
 913		tmp = dest;
 914		tmp += count;
 915		s = src;
 916		s += count;
 917		while (count--)
 918			*--tmp = *--s;
 919	}
 920	return dest;
 921}
 922EXPORT_SYMBOL(memmove);
 923#endif
 924
 925#ifndef __HAVE_ARCH_MEMCMP
 926/**
 927 * memcmp - Compare two areas of memory
 928 * @cs: One area of memory
 929 * @ct: Another area of memory
 930 * @count: The size of the area.
 931 */
 932#undef memcmp
 933__visible int memcmp(const void *cs, const void *ct, size_t count)
 934{
 935	const unsigned char *su1, *su2;
 936	int res = 0;
 937
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 938	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 939		if ((res = *su1 - *su2) != 0)
 940			break;
 941	return res;
 942}
 943EXPORT_SYMBOL(memcmp);
 944#endif
 945
 946#ifndef __HAVE_ARCH_BCMP
 947/**
 948 * bcmp - returns 0 if and only if the buffers have identical contents.
 949 * @a: pointer to first buffer.
 950 * @b: pointer to second buffer.
 951 * @len: size of buffers.
 952 *
 953 * The sign or magnitude of a non-zero return value has no particular
 954 * meaning, and architectures may implement their own more efficient bcmp(). So
 955 * while this particular implementation is a simple (tail) call to memcmp, do
 956 * not rely on anything but whether the return value is zero or non-zero.
 957 */
 958int bcmp(const void *a, const void *b, size_t len)
 959{
 960	return memcmp(a, b, len);
 961}
 962EXPORT_SYMBOL(bcmp);
 963#endif
 964
 965#ifndef __HAVE_ARCH_MEMSCAN
 966/**
 967 * memscan - Find a character in an area of memory.
 968 * @addr: The memory area
 969 * @c: The byte to search for
 970 * @size: The size of the area.
 971 *
 972 * returns the address of the first occurrence of @c, or 1 byte past
 973 * the area if @c is not found
 974 */
 975void *memscan(void *addr, int c, size_t size)
 976{
 977	unsigned char *p = addr;
 978
 979	while (size) {
 980		if (*p == (unsigned char)c)
 981			return (void *)p;
 982		p++;
 983		size--;
 984	}
 985  	return (void *)p;
 986}
 987EXPORT_SYMBOL(memscan);
 988#endif
 989
 990#ifndef __HAVE_ARCH_STRSTR
 991/**
 992 * strstr - Find the first substring in a %NUL terminated string
 993 * @s1: The string to be searched
 994 * @s2: The string to search for
 995 */
 996char *strstr(const char *s1, const char *s2)
 997{
 998	size_t l1, l2;
 999
1000	l2 = strlen(s2);
1001	if (!l2)
1002		return (char *)s1;
1003	l1 = strlen(s1);
1004	while (l1 >= l2) {
1005		l1--;
1006		if (!memcmp(s1, s2, l2))
1007			return (char *)s1;
1008		s1++;
1009	}
1010	return NULL;
1011}
1012EXPORT_SYMBOL(strstr);
1013#endif
1014
1015#ifndef __HAVE_ARCH_STRNSTR
1016/**
1017 * strnstr - Find the first substring in a length-limited string
1018 * @s1: The string to be searched
1019 * @s2: The string to search for
1020 * @len: the maximum number of characters to search
1021 */
1022char *strnstr(const char *s1, const char *s2, size_t len)
1023{
1024	size_t l2;
1025
1026	l2 = strlen(s2);
1027	if (!l2)
1028		return (char *)s1;
1029	while (len >= l2) {
1030		len--;
1031		if (!memcmp(s1, s2, l2))
1032			return (char *)s1;
1033		s1++;
1034	}
1035	return NULL;
1036}
1037EXPORT_SYMBOL(strnstr);
1038#endif
1039
1040#ifndef __HAVE_ARCH_MEMCHR
1041/**
1042 * memchr - Find a character in an area of memory.
1043 * @s: The memory area
1044 * @c: The byte to search for
1045 * @n: The size of the area.
1046 *
1047 * returns the address of the first occurrence of @c, or %NULL
1048 * if @c is not found
1049 */
1050void *memchr(const void *s, int c, size_t n)
1051{
1052	const unsigned char *p = s;
1053	while (n-- != 0) {
1054        	if ((unsigned char)c == *p++) {
1055			return (void *)(p - 1);
1056		}
1057	}
1058	return NULL;
1059}
1060EXPORT_SYMBOL(memchr);
1061#endif
1062
1063static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1064{
1065	while (bytes) {
1066		if (*start != value)
1067			return (void *)start;
1068		start++;
1069		bytes--;
1070	}
1071	return NULL;
1072}
1073
1074/**
1075 * memchr_inv - Find an unmatching character in an area of memory.
1076 * @start: The memory area
1077 * @c: Find a character other than c
1078 * @bytes: The size of the area.
1079 *
1080 * returns the address of the first character other than @c, or %NULL
1081 * if the whole buffer contains just @c.
1082 */
1083void *memchr_inv(const void *start, int c, size_t bytes)
1084{
1085	u8 value = c;
1086	u64 value64;
1087	unsigned int words, prefix;
1088
1089	if (bytes <= 16)
1090		return check_bytes8(start, value, bytes);
1091
1092	value64 = value;
1093#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
1094	value64 *= 0x0101010101010101ULL;
1095#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
1096	value64 *= 0x01010101;
1097	value64 |= value64 << 32;
1098#else
1099	value64 |= value64 << 8;
1100	value64 |= value64 << 16;
1101	value64 |= value64 << 32;
1102#endif
1103
1104	prefix = (unsigned long)start % 8;
1105	if (prefix) {
1106		u8 *r;
1107
1108		prefix = 8 - prefix;
1109		r = check_bytes8(start, value, prefix);
1110		if (r)
1111			return r;
1112		start += prefix;
1113		bytes -= prefix;
1114	}
1115
1116	words = bytes / 8;
1117
1118	while (words) {
1119		if (*(u64 *)start != value64)
1120			return check_bytes8(start, value, 8);
1121		start += 8;
1122		words--;
1123	}
1124
1125	return check_bytes8(start, value, bytes % 8);
1126}
1127EXPORT_SYMBOL(memchr_inv);
1128
1129/**
1130 * strreplace - Replace all occurrences of character in string.
1131 * @s: The string to operate on.
1132 * @old: The character being replaced.
1133 * @new: The character @old is replaced with.
1134 *
1135 * Returns pointer to the nul byte at the end of @s.
1136 */
1137char *strreplace(char *s, char old, char new)
1138{
1139	for (; *s; ++s)
1140		if (*s == old)
1141			*s = new;
1142	return s;
1143}
1144EXPORT_SYMBOL(strreplace);
1145
1146void fortify_panic(const char *name)
1147{
1148	pr_emerg("detected buffer overflow in %s\n", name);
1149	BUG();
1150}
1151EXPORT_SYMBOL(fortify_panic);
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *  linux/lib/string.c
  4 *
  5 *  Copyright (C) 1991, 1992  Linus Torvalds
  6 */
  7
  8/*
  9 * This file should be used only for "library" routines that may have
 10 * alternative implementations on specific architectures (generally
 11 * found in <asm-xx/string.h>), or get overloaded by FORTIFY_SOURCE.
 12 * (Specifically, this file is built with __NO_FORTIFY.)
 13 *
 14 * Other helper functions should live in string_helpers.c.
 
 
 
 
 
 
 
 
 15 */
 16
 17#define __NO_FORTIFY
 18#include <linux/bits.h>
 
 
 
 19#include <linux/bug.h>
 20#include <linux/ctype.h>
 21#include <linux/errno.h>
 22#include <linux/limits.h>
 23#include <linux/linkage.h>
 24#include <linux/stddef.h>
 25#include <linux/string.h>
 26#include <linux/types.h>
 27
 
 
 28#include <asm/page.h>
 29#include <asm/rwonce.h>
 30#include <linux/unaligned.h>
 31#include <asm/word-at-a-time.h>
 32
 33#ifndef __HAVE_ARCH_STRNCASECMP
 34/**
 35 * strncasecmp - Case insensitive, length-limited string comparison
 36 * @s1: One string
 37 * @s2: The other string
 38 * @len: the maximum number of characters to compare
 39 */
 40int strncasecmp(const char *s1, const char *s2, size_t len)
 41{
 42	/* Yes, Virginia, it had better be unsigned */
 43	unsigned char c1, c2;
 44
 45	if (!len)
 46		return 0;
 47
 48	do {
 49		c1 = *s1++;
 50		c2 = *s2++;
 51		if (!c1 || !c2)
 52			break;
 53		if (c1 == c2)
 54			continue;
 55		c1 = tolower(c1);
 56		c2 = tolower(c2);
 57		if (c1 != c2)
 58			break;
 59	} while (--len);
 60	return (int)c1 - (int)c2;
 61}
 62EXPORT_SYMBOL(strncasecmp);
 63#endif
 64
 65#ifndef __HAVE_ARCH_STRCASECMP
 66int strcasecmp(const char *s1, const char *s2)
 67{
 68	int c1, c2;
 69
 70	do {
 71		c1 = tolower(*s1++);
 72		c2 = tolower(*s2++);
 73	} while (c1 == c2 && c1 != 0);
 74	return c1 - c2;
 75}
 76EXPORT_SYMBOL(strcasecmp);
 77#endif
 78
 79#ifndef __HAVE_ARCH_STRCPY
 
 
 
 
 
 80char *strcpy(char *dest, const char *src)
 81{
 82	char *tmp = dest;
 83
 84	while ((*dest++ = *src++) != '\0')
 85		/* nothing */;
 86	return tmp;
 87}
 88EXPORT_SYMBOL(strcpy);
 89#endif
 90
 91#ifndef __HAVE_ARCH_STRNCPY
 
 
 
 
 
 
 
 
 
 
 
 
 
 92char *strncpy(char *dest, const char *src, size_t count)
 93{
 94	char *tmp = dest;
 95
 96	while (count) {
 97		if ((*tmp = *src) != 0)
 98			src++;
 99		tmp++;
100		count--;
101	}
102	return dest;
103}
104EXPORT_SYMBOL(strncpy);
105#endif
106
107#ifdef __BIG_ENDIAN
108# define ALLBUTLAST_BYTE_MASK (~255ul)
109#else
110# define ALLBUTLAST_BYTE_MASK (~0ul >> 8)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
111#endif
112
113ssize_t sized_strscpy(char *dest, const char *src, size_t count)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
114{
115	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
116	size_t max = count;
117	long res = 0;
118
119	if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
120		return -E2BIG;
121
122#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
123	/*
124	 * If src is unaligned, don't cross a page boundary,
125	 * since we don't know if the next page is mapped.
126	 */
127	if ((long)src & (sizeof(long) - 1)) {
128		size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
129		if (limit < max)
130			max = limit;
131	}
132#else
133	/* If src or dest is unaligned, don't do word-at-a-time. */
134	if (((long) dest | (long) src) & (sizeof(long) - 1))
135		max = 0;
136#endif
137
138	/*
139	 * read_word_at_a_time() below may read uninitialized bytes after the
140	 * trailing zero and use them in comparisons. Disable this optimization
141	 * under KMSAN to prevent false positive reports.
142	 */
143	if (IS_ENABLED(CONFIG_KMSAN))
144		max = 0;
145
146	while (max >= sizeof(unsigned long)) {
147		unsigned long c, data;
148
149		c = read_word_at_a_time(src+res);
150		if (has_zero(c, &data, &constants)) {
151			data = prep_zero_mask(c, data, &constants);
152			data = create_zero_mask(data);
153			*(unsigned long *)(dest+res) = c & zero_bytemask(data);
154			return res + find_zero(data);
155		}
156		count -= sizeof(unsigned long);
157		if (unlikely(!count)) {
158			c &= ALLBUTLAST_BYTE_MASK;
159			*(unsigned long *)(dest+res) = c;
160			return -E2BIG;
161		}
162		*(unsigned long *)(dest+res) = c;
163		res += sizeof(unsigned long);
 
164		max -= sizeof(unsigned long);
165	}
166
167	while (count > 1) {
168		char c;
169
170		c = src[res];
171		dest[res] = c;
172		if (!c)
173			return res;
174		res++;
175		count--;
176	}
177
178	/* Force NUL-termination. */
179	dest[res] = '\0';
 
180
181	/* Return E2BIG if the source didn't stop */
182	return src[res] ? -E2BIG : res;
183}
184EXPORT_SYMBOL(sized_strscpy);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
185
186/**
187 * stpcpy - copy a string from src to dest returning a pointer to the new end
188 *          of dest, including src's %NUL-terminator. May overrun dest.
189 * @dest: pointer to end of string being copied into. Must be large enough
190 *        to receive copy.
191 * @src: pointer to the beginning of string being copied from. Must not overlap
192 *       dest.
193 *
194 * stpcpy differs from strcpy in a key way: the return value is a pointer
195 * to the new %NUL-terminating character in @dest. (For strcpy, the return
196 * value is a pointer to the start of @dest). This interface is considered
197 * unsafe as it doesn't perform bounds checking of the inputs. As such it's
198 * not recommended for usage. Instead, its definition is provided in case
199 * the compiler lowers other libcalls to stpcpy.
200 */
201char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
202char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
203{
204	while ((*dest++ = *src++) != '\0')
205		/* nothing */;
206	return --dest;
207}
208EXPORT_SYMBOL(stpcpy);
209
210#ifndef __HAVE_ARCH_STRCAT
 
 
 
 
 
211char *strcat(char *dest, const char *src)
212{
213	char *tmp = dest;
214
215	while (*dest)
216		dest++;
217	while ((*dest++ = *src++) != '\0')
218		;
219	return tmp;
220}
221EXPORT_SYMBOL(strcat);
222#endif
223
224#ifndef __HAVE_ARCH_STRNCAT
 
 
 
 
 
 
 
 
 
225char *strncat(char *dest, const char *src, size_t count)
226{
227	char *tmp = dest;
228
229	if (count) {
230		while (*dest)
231			dest++;
232		while ((*dest++ = *src++) != 0) {
233			if (--count == 0) {
234				*dest = '\0';
235				break;
236			}
237		}
238	}
239	return tmp;
240}
241EXPORT_SYMBOL(strncat);
242#endif
243
244#ifndef __HAVE_ARCH_STRLCAT
 
 
 
 
 
 
245size_t strlcat(char *dest, const char *src, size_t count)
246{
247	size_t dsize = strlen(dest);
248	size_t len = strlen(src);
249	size_t res = dsize + len;
250
251	/* This would be a bug */
252	BUG_ON(dsize >= count);
253
254	dest += dsize;
255	count -= dsize;
256	if (len >= count)
257		len = count-1;
258	__builtin_memcpy(dest, src, len);
259	dest[len] = 0;
260	return res;
261}
262EXPORT_SYMBOL(strlcat);
263#endif
264
265#ifndef __HAVE_ARCH_STRCMP
266/**
267 * strcmp - Compare two strings
268 * @cs: One string
269 * @ct: Another string
270 */
271int strcmp(const char *cs, const char *ct)
272{
273	unsigned char c1, c2;
274
275	while (1) {
276		c1 = *cs++;
277		c2 = *ct++;
278		if (c1 != c2)
279			return c1 < c2 ? -1 : 1;
280		if (!c1)
281			break;
282	}
283	return 0;
284}
285EXPORT_SYMBOL(strcmp);
286#endif
287
288#ifndef __HAVE_ARCH_STRNCMP
289/**
290 * strncmp - Compare two length-limited strings
291 * @cs: One string
292 * @ct: Another string
293 * @count: The maximum number of bytes to compare
294 */
295int strncmp(const char *cs, const char *ct, size_t count)
296{
297	unsigned char c1, c2;
298
299	while (count) {
300		c1 = *cs++;
301		c2 = *ct++;
302		if (c1 != c2)
303			return c1 < c2 ? -1 : 1;
304		if (!c1)
305			break;
306		count--;
307	}
308	return 0;
309}
310EXPORT_SYMBOL(strncmp);
311#endif
312
313#ifndef __HAVE_ARCH_STRCHR
314/**
315 * strchr - Find the first occurrence of a character in a string
316 * @s: The string to be searched
317 * @c: The character to search for
318 *
319 * Note that the %NUL-terminator is considered part of the string, and can
320 * be searched for.
321 */
322char *strchr(const char *s, int c)
323{
324	for (; *s != (char)c; ++s)
325		if (*s == '\0')
326			return NULL;
327	return (char *)s;
328}
329EXPORT_SYMBOL(strchr);
330#endif
331
332#ifndef __HAVE_ARCH_STRCHRNUL
333/**
334 * strchrnul - Find and return a character in a string, or end of string
335 * @s: The string to be searched
336 * @c: The character to search for
337 *
338 * Returns pointer to first occurrence of 'c' in s. If c is not found, then
339 * return a pointer to the null byte at the end of s.
340 */
341char *strchrnul(const char *s, int c)
342{
343	while (*s && *s != (char)c)
344		s++;
345	return (char *)s;
346}
347EXPORT_SYMBOL(strchrnul);
348#endif
349
350/**
351 * strnchrnul - Find and return a character in a length limited string,
352 * or end of string
353 * @s: The string to be searched
354 * @count: The number of characters to be searched
355 * @c: The character to search for
356 *
357 * Returns pointer to the first occurrence of 'c' in s. If c is not found,
358 * then return a pointer to the last character of the string.
359 */
360char *strnchrnul(const char *s, size_t count, int c)
361{
362	while (count-- && *s && *s != (char)c)
363		s++;
364	return (char *)s;
365}
366
367#ifndef __HAVE_ARCH_STRRCHR
368/**
369 * strrchr - Find the last occurrence of a character in a string
370 * @s: The string to be searched
371 * @c: The character to search for
372 */
373char *strrchr(const char *s, int c)
374{
375	const char *last = NULL;
376	do {
377		if (*s == (char)c)
378			last = s;
379	} while (*s++);
380	return (char *)last;
381}
382EXPORT_SYMBOL(strrchr);
383#endif
384
385#ifndef __HAVE_ARCH_STRNCHR
386/**
387 * strnchr - Find a character in a length limited string
388 * @s: The string to be searched
389 * @count: The number of characters to be searched
390 * @c: The character to search for
391 *
392 * Note that the %NUL-terminator is considered part of the string, and can
393 * be searched for.
394 */
395char *strnchr(const char *s, size_t count, int c)
396{
397	while (count--) {
398		if (*s == (char)c)
399			return (char *)s;
400		if (*s++ == '\0')
401			break;
402	}
403	return NULL;
404}
405EXPORT_SYMBOL(strnchr);
406#endif
407
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
408#ifndef __HAVE_ARCH_STRLEN
 
 
 
 
409size_t strlen(const char *s)
410{
411	const char *sc;
412
413	for (sc = s; *sc != '\0'; ++sc)
414		/* nothing */;
415	return sc - s;
416}
417EXPORT_SYMBOL(strlen);
418#endif
419
420#ifndef __HAVE_ARCH_STRNLEN
 
 
 
 
 
421size_t strnlen(const char *s, size_t count)
422{
423	const char *sc;
424
425	for (sc = s; count-- && *sc != '\0'; ++sc)
426		/* nothing */;
427	return sc - s;
428}
429EXPORT_SYMBOL(strnlen);
430#endif
431
432#ifndef __HAVE_ARCH_STRSPN
433/**
434 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
435 * @s: The string to be searched
436 * @accept: The string to search for
437 */
438size_t strspn(const char *s, const char *accept)
439{
440	const char *p;
 
 
441
442	for (p = s; *p != '\0'; ++p) {
443		if (!strchr(accept, *p))
444			break;
 
 
 
 
 
445	}
446	return p - s;
447}
 
448EXPORT_SYMBOL(strspn);
449#endif
450
451#ifndef __HAVE_ARCH_STRCSPN
452/**
453 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
454 * @s: The string to be searched
455 * @reject: The string to avoid
456 */
457size_t strcspn(const char *s, const char *reject)
458{
459	const char *p;
 
 
460
461	for (p = s; *p != '\0'; ++p) {
462		if (strchr(reject, *p))
463			break;
 
 
 
464	}
465	return p - s;
466}
467EXPORT_SYMBOL(strcspn);
468#endif
469
470#ifndef __HAVE_ARCH_STRPBRK
471/**
472 * strpbrk - Find the first occurrence of a set of characters
473 * @cs: The string to be searched
474 * @ct: The characters to search for
475 */
476char *strpbrk(const char *cs, const char *ct)
477{
478	const char *sc;
479
480	for (sc = cs; *sc != '\0'; ++sc) {
481		if (strchr(ct, *sc))
482			return (char *)sc;
 
 
483	}
484	return NULL;
485}
486EXPORT_SYMBOL(strpbrk);
487#endif
488
489#ifndef __HAVE_ARCH_STRSEP
490/**
491 * strsep - Split a string into tokens
492 * @s: The string to be searched
493 * @ct: The characters to search for
494 *
495 * strsep() updates @s to point after the token, ready for the next call.
496 *
497 * It returns empty tokens, too, behaving exactly like the libc function
498 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
499 * Same semantics, slimmer shape. ;)
500 */
501char *strsep(char **s, const char *ct)
502{
503	char *sbegin = *s;
504	char *end;
505
506	if (sbegin == NULL)
507		return NULL;
508
509	end = strpbrk(sbegin, ct);
510	if (end)
511		*end++ = '\0';
512	*s = end;
513	return sbegin;
514}
515EXPORT_SYMBOL(strsep);
516#endif
517
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
518#ifndef __HAVE_ARCH_MEMSET
519/**
520 * memset - Fill a region of memory with the given value
521 * @s: Pointer to the start of the area.
522 * @c: The byte to fill the area with
523 * @count: The size of the area.
524 *
525 * Do not use memset() to access IO space, use memset_io() instead.
526 */
527void *memset(void *s, int c, size_t count)
528{
529	char *xs = s;
530
531	while (count--)
532		*xs++ = c;
533	return s;
534}
535EXPORT_SYMBOL(memset);
536#endif
537
538#ifndef __HAVE_ARCH_MEMSET16
539/**
540 * memset16() - Fill a memory area with a uint16_t
541 * @s: Pointer to the start of the area.
542 * @v: The value to fill the area with
543 * @count: The number of values to store
544 *
545 * Differs from memset() in that it fills with a uint16_t instead
546 * of a byte.  Remember that @count is the number of uint16_ts to
547 * store, not the number of bytes.
548 */
549void *memset16(uint16_t *s, uint16_t v, size_t count)
550{
551	uint16_t *xs = s;
552
553	while (count--)
554		*xs++ = v;
555	return s;
556}
557EXPORT_SYMBOL(memset16);
558#endif
559
560#ifndef __HAVE_ARCH_MEMSET32
561/**
562 * memset32() - Fill a memory area with a uint32_t
563 * @s: Pointer to the start of the area.
564 * @v: The value to fill the area with
565 * @count: The number of values to store
566 *
567 * Differs from memset() in that it fills with a uint32_t instead
568 * of a byte.  Remember that @count is the number of uint32_ts to
569 * store, not the number of bytes.
570 */
571void *memset32(uint32_t *s, uint32_t v, size_t count)
572{
573	uint32_t *xs = s;
574
575	while (count--)
576		*xs++ = v;
577	return s;
578}
579EXPORT_SYMBOL(memset32);
580#endif
581
582#ifndef __HAVE_ARCH_MEMSET64
583/**
584 * memset64() - Fill a memory area with a uint64_t
585 * @s: Pointer to the start of the area.
586 * @v: The value to fill the area with
587 * @count: The number of values to store
588 *
589 * Differs from memset() in that it fills with a uint64_t instead
590 * of a byte.  Remember that @count is the number of uint64_ts to
591 * store, not the number of bytes.
592 */
593void *memset64(uint64_t *s, uint64_t v, size_t count)
594{
595	uint64_t *xs = s;
596
597	while (count--)
598		*xs++ = v;
599	return s;
600}
601EXPORT_SYMBOL(memset64);
602#endif
603
604#ifndef __HAVE_ARCH_MEMCPY
605/**
606 * memcpy - Copy one area of memory to another
607 * @dest: Where to copy to
608 * @src: Where to copy from
609 * @count: The size of the area.
610 *
611 * You should not use this function to access IO space, use memcpy_toio()
612 * or memcpy_fromio() instead.
613 */
614void *memcpy(void *dest, const void *src, size_t count)
615{
616	char *tmp = dest;
617	const char *s = src;
618
619	while (count--)
620		*tmp++ = *s++;
621	return dest;
622}
623EXPORT_SYMBOL(memcpy);
624#endif
625
626#ifndef __HAVE_ARCH_MEMMOVE
627/**
628 * memmove - Copy one area of memory to another
629 * @dest: Where to copy to
630 * @src: Where to copy from
631 * @count: The size of the area.
632 *
633 * Unlike memcpy(), memmove() copes with overlapping areas.
634 */
635void *memmove(void *dest, const void *src, size_t count)
636{
637	char *tmp;
638	const char *s;
639
640	if (dest <= src) {
641		tmp = dest;
642		s = src;
643		while (count--)
644			*tmp++ = *s++;
645	} else {
646		tmp = dest;
647		tmp += count;
648		s = src;
649		s += count;
650		while (count--)
651			*--tmp = *--s;
652	}
653	return dest;
654}
655EXPORT_SYMBOL(memmove);
656#endif
657
658#ifndef __HAVE_ARCH_MEMCMP
659/**
660 * memcmp - Compare two areas of memory
661 * @cs: One area of memory
662 * @ct: Another area of memory
663 * @count: The size of the area.
664 */
665#undef memcmp
666__visible int memcmp(const void *cs, const void *ct, size_t count)
667{
668	const unsigned char *su1, *su2;
669	int res = 0;
670
671#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
672	if (count >= sizeof(unsigned long)) {
673		const unsigned long *u1 = cs;
674		const unsigned long *u2 = ct;
675		do {
676			if (get_unaligned(u1) != get_unaligned(u2))
677				break;
678			u1++;
679			u2++;
680			count -= sizeof(unsigned long);
681		} while (count >= sizeof(unsigned long));
682		cs = u1;
683		ct = u2;
684	}
685#endif
686	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
687		if ((res = *su1 - *su2) != 0)
688			break;
689	return res;
690}
691EXPORT_SYMBOL(memcmp);
692#endif
693
694#ifndef __HAVE_ARCH_BCMP
695/**
696 * bcmp - returns 0 if and only if the buffers have identical contents.
697 * @a: pointer to first buffer.
698 * @b: pointer to second buffer.
699 * @len: size of buffers.
700 *
701 * The sign or magnitude of a non-zero return value has no particular
702 * meaning, and architectures may implement their own more efficient bcmp(). So
703 * while this particular implementation is a simple (tail) call to memcmp, do
704 * not rely on anything but whether the return value is zero or non-zero.
705 */
706int bcmp(const void *a, const void *b, size_t len)
707{
708	return memcmp(a, b, len);
709}
710EXPORT_SYMBOL(bcmp);
711#endif
712
713#ifndef __HAVE_ARCH_MEMSCAN
714/**
715 * memscan - Find a character in an area of memory.
716 * @addr: The memory area
717 * @c: The byte to search for
718 * @size: The size of the area.
719 *
720 * returns the address of the first occurrence of @c, or 1 byte past
721 * the area if @c is not found
722 */
723void *memscan(void *addr, int c, size_t size)
724{
725	unsigned char *p = addr;
726
727	while (size) {
728		if (*p == (unsigned char)c)
729			return (void *)p;
730		p++;
731		size--;
732	}
733  	return (void *)p;
734}
735EXPORT_SYMBOL(memscan);
736#endif
737
738#ifndef __HAVE_ARCH_STRSTR
739/**
740 * strstr - Find the first substring in a %NUL terminated string
741 * @s1: The string to be searched
742 * @s2: The string to search for
743 */
744char *strstr(const char *s1, const char *s2)
745{
746	size_t l1, l2;
747
748	l2 = strlen(s2);
749	if (!l2)
750		return (char *)s1;
751	l1 = strlen(s1);
752	while (l1 >= l2) {
753		l1--;
754		if (!memcmp(s1, s2, l2))
755			return (char *)s1;
756		s1++;
757	}
758	return NULL;
759}
760EXPORT_SYMBOL(strstr);
761#endif
762
763#ifndef __HAVE_ARCH_STRNSTR
764/**
765 * strnstr - Find the first substring in a length-limited string
766 * @s1: The string to be searched
767 * @s2: The string to search for
768 * @len: the maximum number of characters to search
769 */
770char *strnstr(const char *s1, const char *s2, size_t len)
771{
772	size_t l2;
773
774	l2 = strlen(s2);
775	if (!l2)
776		return (char *)s1;
777	while (len >= l2) {
778		len--;
779		if (!memcmp(s1, s2, l2))
780			return (char *)s1;
781		s1++;
782	}
783	return NULL;
784}
785EXPORT_SYMBOL(strnstr);
786#endif
787
788#ifndef __HAVE_ARCH_MEMCHR
789/**
790 * memchr - Find a character in an area of memory.
791 * @s: The memory area
792 * @c: The byte to search for
793 * @n: The size of the area.
794 *
795 * returns the address of the first occurrence of @c, or %NULL
796 * if @c is not found
797 */
798void *memchr(const void *s, int c, size_t n)
799{
800	const unsigned char *p = s;
801	while (n-- != 0) {
802        	if ((unsigned char)c == *p++) {
803			return (void *)(p - 1);
804		}
805	}
806	return NULL;
807}
808EXPORT_SYMBOL(memchr);
809#endif
810
811static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
812{
813	while (bytes) {
814		if (*start != value)
815			return (void *)start;
816		start++;
817		bytes--;
818	}
819	return NULL;
820}
821
822/**
823 * memchr_inv - Find an unmatching character in an area of memory.
824 * @start: The memory area
825 * @c: Find a character other than c
826 * @bytes: The size of the area.
827 *
828 * returns the address of the first character other than @c, or %NULL
829 * if the whole buffer contains just @c.
830 */
831void *memchr_inv(const void *start, int c, size_t bytes)
832{
833	u8 value = c;
834	u64 value64;
835	unsigned int words, prefix;
836
837	if (bytes <= 16)
838		return check_bytes8(start, value, bytes);
839
840	value64 = value;
841#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
842	value64 *= 0x0101010101010101ULL;
843#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
844	value64 *= 0x01010101;
845	value64 |= value64 << 32;
846#else
847	value64 |= value64 << 8;
848	value64 |= value64 << 16;
849	value64 |= value64 << 32;
850#endif
851
852	prefix = (unsigned long)start % 8;
853	if (prefix) {
854		u8 *r;
855
856		prefix = 8 - prefix;
857		r = check_bytes8(start, value, prefix);
858		if (r)
859			return r;
860		start += prefix;
861		bytes -= prefix;
862	}
863
864	words = bytes / 8;
865
866	while (words) {
867		if (*(u64 *)start != value64)
868			return check_bytes8(start, value, 8);
869		start += 8;
870		words--;
871	}
872
873	return check_bytes8(start, value, bytes % 8);
874}
875EXPORT_SYMBOL(memchr_inv);