blob: a1cdcfcc42d06db93e81928f022d4c70b82959be [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/lib/string.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * stupid library routines.. The optimized versions should generally be found
9 * as inline code in <asm-xx/string.h>
10 *
11 * These are buggy as well..
12 *
13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
14 * - Added strsep() which will replace strtok() soon (because strsep() is
15 * reentrant and should be faster). Use only strsep() in new code, please.
16 *
17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>,
18 * Matthew Hawkins <matt@mh.dropbear.id.au>
19 * - Kissed strtok() goodbye
20 */
21
22#include <linux/types.h>
23#include <linux/string.h>
24#include <linux/ctype.h>
25#include <linux/module.h>
26
27#ifndef __HAVE_ARCH_STRNICMP
28/**
29 * strnicmp - Case insensitive, length-limited string comparison
30 * @s1: One string
31 * @s2: The other string
32 * @len: the maximum number of characters to compare
33 */
34int strnicmp(const char *s1, const char *s2, size_t len)
35{
36 /* Yes, Virginia, it had better be unsigned */
37 unsigned char c1, c2;
38
Jesper Juhl850b9242005-10-30 15:02:13 -080039 c1 = c2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 if (len) {
41 do {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -080042 c1 = *s1;
43 c2 = *s2;
44 s1++;
45 s2++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 if (!c1)
47 break;
48 if (!c2)
49 break;
50 if (c1 == c2)
51 continue;
52 c1 = tolower(c1);
53 c2 = tolower(c2);
54 if (c1 != c2)
55 break;
56 } while (--len);
57 }
58 return (int)c1 - (int)c2;
59}
Linus Torvalds1da177e2005-04-16 15:20:36 -070060EXPORT_SYMBOL(strnicmp);
61#endif
62
David S. Millerded220b2007-03-29 01:18:42 -070063#ifndef __HAVE_ARCH_STRCASECMP
64int strcasecmp(const char *s1, const char *s2)
65{
66 int c1, c2;
67
68 do {
69 c1 = tolower(*s1++);
70 c2 = tolower(*s2++);
71 } while (c1 == c2 && c1 != 0);
72 return c1 - c2;
73}
74EXPORT_SYMBOL(strcasecmp);
75#endif
76
77#ifndef __HAVE_ARCH_STRNCASECMP
78int strncasecmp(const char *s1, const char *s2, size_t n)
79{
80 int c1, c2;
81
82 do {
83 c1 = tolower(*s1++);
84 c2 = tolower(*s2++);
85 } while ((--n > 0) && c1 == c2 && c1 != 0);
86 return c1 - c2;
87}
88EXPORT_SYMBOL(strncasecmp);
89#endif
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091#ifndef __HAVE_ARCH_STRCPY
92/**
93 * strcpy - Copy a %NUL terminated string
94 * @dest: Where to copy the string to
95 * @src: Where to copy the string from
96 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -070097#undef strcpy
Jesper Juhl51a0f0f2005-10-30 15:02:11 -080098char *strcpy(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
100 char *tmp = dest;
101
102 while ((*dest++ = *src++) != '\0')
103 /* nothing */;
104 return tmp;
105}
106EXPORT_SYMBOL(strcpy);
107#endif
108
109#ifndef __HAVE_ARCH_STRNCPY
110/**
111 * strncpy - Copy a length-limited, %NUL-terminated string
112 * @dest: Where to copy the string to
113 * @src: Where to copy the string from
114 * @count: The maximum number of bytes to copy
115 *
116 * The result is not %NUL-terminated if the source exceeds
117 * @count bytes.
walter harms25279522005-05-05 16:16:20 -0700118 *
119 * In the case where the length of @src is less than that of
120 * count, the remainder of @dest will be padded with %NUL.
121 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800123char *strncpy(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
125 char *tmp = dest;
126
127 while (count) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800128 if ((*tmp = *src) != 0)
129 src++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 tmp++;
131 count--;
132 }
133 return dest;
134}
135EXPORT_SYMBOL(strncpy);
136#endif
137
138#ifndef __HAVE_ARCH_STRLCPY
139/**
140 * strlcpy - Copy a %NUL terminated string into a sized buffer
141 * @dest: Where to copy the string to
142 * @src: Where to copy the string from
143 * @size: size of destination buffer
144 *
145 * Compatible with *BSD: the result is always a valid
146 * NUL-terminated string that fits in the buffer (unless,
147 * of course, the buffer size is zero). It does not pad
148 * out the result like strncpy() does.
149 */
150size_t strlcpy(char *dest, const char *src, size_t size)
151{
152 size_t ret = strlen(src);
153
154 if (size) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800155 size_t len = (ret >= size) ? size - 1 : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 memcpy(dest, src, len);
157 dest[len] = '\0';
158 }
159 return ret;
160}
161EXPORT_SYMBOL(strlcpy);
162#endif
163
164#ifndef __HAVE_ARCH_STRCAT
165/**
166 * strcat - Append one %NUL-terminated string to another
167 * @dest: The string to be appended to
168 * @src: The string to append to it
169 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700170#undef strcat
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800171char *strcat(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
173 char *tmp = dest;
174
175 while (*dest)
176 dest++;
177 while ((*dest++ = *src++) != '\0')
178 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 return tmp;
180}
181EXPORT_SYMBOL(strcat);
182#endif
183
184#ifndef __HAVE_ARCH_STRNCAT
185/**
186 * strncat - Append a length-limited, %NUL-terminated string to another
187 * @dest: The string to be appended to
188 * @src: The string to append to it
189 * @count: The maximum numbers of bytes to copy
190 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800191 * Note that in contrast to strncpy(), strncat() ensures the result is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 * terminated.
193 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800194char *strncat(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
196 char *tmp = dest;
197
198 if (count) {
199 while (*dest)
200 dest++;
201 while ((*dest++ = *src++) != 0) {
202 if (--count == 0) {
203 *dest = '\0';
204 break;
205 }
206 }
207 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 return tmp;
209}
210EXPORT_SYMBOL(strncat);
211#endif
212
213#ifndef __HAVE_ARCH_STRLCAT
214/**
215 * strlcat - Append a length-limited, %NUL-terminated string to another
216 * @dest: The string to be appended to
217 * @src: The string to append to it
218 * @count: The size of the destination buffer.
219 */
220size_t strlcat(char *dest, const char *src, size_t count)
221{
222 size_t dsize = strlen(dest);
223 size_t len = strlen(src);
224 size_t res = dsize + len;
225
226 /* This would be a bug */
227 BUG_ON(dsize >= count);
228
229 dest += dsize;
230 count -= dsize;
231 if (len >= count)
232 len = count-1;
233 memcpy(dest, src, len);
234 dest[len] = 0;
235 return res;
236}
237EXPORT_SYMBOL(strlcat);
238#endif
239
240#ifndef __HAVE_ARCH_STRCMP
241/**
242 * strcmp - Compare two strings
243 * @cs: One string
244 * @ct: Another string
245 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700246#undef strcmp
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800247int strcmp(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100249 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 while (1) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100252 c1 = *cs++;
253 c2 = *ct++;
254 if (c1 != c2)
255 return c1 < c2 ? -1 : 1;
256 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 break;
258 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100259 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261EXPORT_SYMBOL(strcmp);
262#endif
263
264#ifndef __HAVE_ARCH_STRNCMP
265/**
266 * strncmp - Compare two length-limited strings
267 * @cs: One string
268 * @ct: Another string
269 * @count: The maximum number of bytes to compare
270 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800271int strncmp(const char *cs, const char *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100273 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 while (count) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100276 c1 = *cs++;
277 c2 = *ct++;
278 if (c1 != c2)
279 return c1 < c2 ? -1 : 1;
280 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 break;
282 count--;
283 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100284 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286EXPORT_SYMBOL(strncmp);
287#endif
288
289#ifndef __HAVE_ARCH_STRCHR
290/**
291 * strchr - Find the first occurrence of a character in a string
292 * @s: The string to be searched
293 * @c: The character to search for
294 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800295char *strchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800297 for (; *s != (char)c; ++s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 if (*s == '\0')
299 return NULL;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800300 return (char *)s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302EXPORT_SYMBOL(strchr);
303#endif
304
305#ifndef __HAVE_ARCH_STRRCHR
306/**
307 * strrchr - Find the last occurrence of a character in a string
308 * @s: The string to be searched
309 * @c: The character to search for
310 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800311char *strrchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 const char *p = s + strlen(s);
314 do {
315 if (*p == (char)c)
316 return (char *)p;
317 } while (--p >= s);
318 return NULL;
319}
320EXPORT_SYMBOL(strrchr);
321#endif
322
323#ifndef __HAVE_ARCH_STRNCHR
324/**
325 * strnchr - Find a character in a length limited string
326 * @s: The string to be searched
327 * @count: The number of characters to be searched
328 * @c: The character to search for
329 */
330char *strnchr(const char *s, size_t count, int c)
331{
332 for (; count-- && *s != '\0'; ++s)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800333 if (*s == (char)c)
334 return (char *)s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return NULL;
336}
337EXPORT_SYMBOL(strnchr);
338#endif
339
Pekka Enberg481fad42006-06-23 02:05:44 -0700340/**
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800341 * skip_spaces - Removes leading whitespace from @str.
342 * @str: The string to be stripped.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800343 *
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800344 * Returns a pointer to the first non-whitespace character in @str.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800345 */
346char *skip_spaces(const char *str)
347{
348 while (isspace(*str))
349 ++str;
350 return (char *)str;
351}
352EXPORT_SYMBOL(skip_spaces);
353
354/**
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800355 * strim - Removes leading and trailing whitespace from @s.
Pekka Enberg481fad42006-06-23 02:05:44 -0700356 * @s: The string to be stripped.
357 *
358 * Note that the first trailing whitespace is replaced with a %NUL-terminator
359 * in the given string @s. Returns a pointer to the first non-whitespace
360 * character in @s.
361 */
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800362char *strim(char *s)
Pekka Enberg481fad42006-06-23 02:05:44 -0700363{
364 size_t size;
365 char *end;
366
André Goddard Rosa84c95c92009-12-14 18:01:04 -0800367 s = skip_spaces(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700368 size = strlen(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700369 if (!size)
370 return s;
371
372 end = s + size - 1;
Michael Holzheu6e6d9fa2006-10-28 10:38:47 -0700373 while (end >= s && isspace(*end))
Pekka Enberg481fad42006-06-23 02:05:44 -0700374 end--;
375 *(end + 1) = '\0';
376
André Goddard Rosa84c95c92009-12-14 18:01:04 -0800377 return s;
Pekka Enberg481fad42006-06-23 02:05:44 -0700378}
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800379EXPORT_SYMBOL(strim);
Pekka Enberg481fad42006-06-23 02:05:44 -0700380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381#ifndef __HAVE_ARCH_STRLEN
382/**
383 * strlen - Find the length of a string
384 * @s: The string to be sized
385 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800386size_t strlen(const char *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 const char *sc;
389
390 for (sc = s; *sc != '\0'; ++sc)
391 /* nothing */;
392 return sc - s;
393}
394EXPORT_SYMBOL(strlen);
395#endif
396
397#ifndef __HAVE_ARCH_STRNLEN
398/**
399 * strnlen - Find the length of a length-limited string
400 * @s: The string to be sized
401 * @count: The maximum number of bytes to search
402 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800403size_t strnlen(const char *s, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
405 const char *sc;
406
407 for (sc = s; count-- && *sc != '\0'; ++sc)
408 /* nothing */;
409 return sc - s;
410}
411EXPORT_SYMBOL(strnlen);
412#endif
413
414#ifndef __HAVE_ARCH_STRSPN
415/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800416 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 * @s: The string to be searched
418 * @accept: The string to search for
419 */
420size_t strspn(const char *s, const char *accept)
421{
422 const char *p;
423 const char *a;
424 size_t count = 0;
425
426 for (p = s; *p != '\0'; ++p) {
427 for (a = accept; *a != '\0'; ++a) {
428 if (*p == *a)
429 break;
430 }
431 if (*a == '\0')
432 return count;
433 ++count;
434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return count;
436}
437
438EXPORT_SYMBOL(strspn);
439#endif
440
Kyle McMartin8833d322006-04-10 22:53:57 -0700441#ifndef __HAVE_ARCH_STRCSPN
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800443 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 * @s: The string to be searched
445 * @reject: The string to avoid
446 */
447size_t strcspn(const char *s, const char *reject)
448{
449 const char *p;
450 const char *r;
451 size_t count = 0;
452
453 for (p = s; *p != '\0'; ++p) {
454 for (r = reject; *r != '\0'; ++r) {
455 if (*p == *r)
456 return count;
457 }
458 ++count;
459 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 return count;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800461}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462EXPORT_SYMBOL(strcspn);
Kyle McMartin8833d322006-04-10 22:53:57 -0700463#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465#ifndef __HAVE_ARCH_STRPBRK
466/**
467 * strpbrk - Find the first occurrence of a set of characters
468 * @cs: The string to be searched
469 * @ct: The characters to search for
470 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800471char *strpbrk(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800473 const char *sc1, *sc2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800475 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
476 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 if (*sc1 == *sc2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800478 return (char *)sc1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
480 }
481 return NULL;
482}
Kyle McMartin894b5772006-04-10 22:53:56 -0700483EXPORT_SYMBOL(strpbrk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484#endif
485
486#ifndef __HAVE_ARCH_STRSEP
487/**
488 * strsep - Split a string into tokens
489 * @s: The string to be searched
490 * @ct: The characters to search for
491 *
492 * strsep() updates @s to point after the token, ready for the next call.
493 *
494 * It returns empty tokens, too, behaving exactly like the libc function
495 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
496 * Same semantics, slimmer shape. ;)
497 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800498char *strsep(char **s, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800500 char *sbegin = *s;
501 char *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 if (sbegin == NULL)
504 return NULL;
505
506 end = strpbrk(sbegin, ct);
507 if (end)
508 *end++ = '\0';
509 *s = end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return sbegin;
511}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512EXPORT_SYMBOL(strsep);
513#endif
514
David Brownell34990cf2008-05-01 04:34:42 -0700515/**
516 * sysfs_streq - return true if strings are equal, modulo trailing newline
517 * @s1: one string
518 * @s2: another string
519 *
520 * This routine returns true iff two strings are equal, treating both
521 * NUL and newline-then-NUL as equivalent string terminations. It's
522 * geared for use with sysfs input strings, which generally terminate
523 * with newlines but are compared against values without newlines.
524 */
525bool sysfs_streq(const char *s1, const char *s2)
526{
527 while (*s1 && *s1 == *s2) {
528 s1++;
529 s2++;
530 }
531
532 if (*s1 == *s2)
533 return true;
534 if (!*s1 && *s2 == '\n' && !s2[1])
535 return true;
536 if (*s1 == '\n' && !s1[1] && !*s2)
537 return true;
538 return false;
539}
540EXPORT_SYMBOL(sysfs_streq);
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542#ifndef __HAVE_ARCH_MEMSET
543/**
544 * memset - Fill a region of memory with the given value
545 * @s: Pointer to the start of the area.
546 * @c: The byte to fill the area with
547 * @count: The size of the area.
548 *
549 * Do not use memset() to access IO space, use memset_io() instead.
550 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800551void *memset(void *s, int c, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552{
Jesper Juhl850b9242005-10-30 15:02:13 -0800553 char *xs = s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 while (count--)
556 *xs++ = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return s;
558}
559EXPORT_SYMBOL(memset);
560#endif
561
562#ifndef __HAVE_ARCH_MEMCPY
563/**
564 * memcpy - Copy one area of memory to another
565 * @dest: Where to copy to
566 * @src: Where to copy from
567 * @count: The size of the area.
568 *
569 * You should not use this function to access IO space, use memcpy_toio()
570 * or memcpy_fromio() instead.
571 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800572void *memcpy(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573{
Jesper Juhl850b9242005-10-30 15:02:13 -0800574 char *tmp = dest;
Jan-Benedict Glaw4c416ab2006-04-10 22:54:09 -0700575 const char *s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
577 while (count--)
578 *tmp++ = *s++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return dest;
580}
581EXPORT_SYMBOL(memcpy);
582#endif
583
584#ifndef __HAVE_ARCH_MEMMOVE
585/**
586 * memmove - Copy one area of memory to another
587 * @dest: Where to copy to
588 * @src: Where to copy from
589 * @count: The size of the area.
590 *
591 * Unlike memcpy(), memmove() copes with overlapping areas.
592 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800593void *memmove(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Paul Jackson82da2c32005-10-30 15:03:19 -0800595 char *tmp;
596 const char *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 if (dest <= src) {
Jesper Juhl850b9242005-10-30 15:02:13 -0800599 tmp = dest;
600 s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 while (count--)
602 *tmp++ = *s++;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800603 } else {
Jesper Juhl850b9242005-10-30 15:02:13 -0800604 tmp = dest;
605 tmp += count;
606 s = src;
607 s += count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 while (count--)
609 *--tmp = *--s;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800610 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 return dest;
612}
613EXPORT_SYMBOL(memmove);
614#endif
615
616#ifndef __HAVE_ARCH_MEMCMP
617/**
618 * memcmp - Compare two areas of memory
619 * @cs: One area of memory
620 * @ct: Another area of memory
621 * @count: The size of the area.
622 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700623#undef memcmp
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800624int memcmp(const void *cs, const void *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 const unsigned char *su1, *su2;
627 int res = 0;
628
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800629 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 if ((res = *su1 - *su2) != 0)
631 break;
632 return res;
633}
634EXPORT_SYMBOL(memcmp);
635#endif
636
637#ifndef __HAVE_ARCH_MEMSCAN
638/**
639 * memscan - Find a character in an area of memory.
640 * @addr: The memory area
641 * @c: The byte to search for
642 * @size: The size of the area.
643 *
644 * returns the address of the first occurrence of @c, or 1 byte past
645 * the area if @c is not found
646 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800647void *memscan(void *addr, int c, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
Jesper Juhl850b9242005-10-30 15:02:13 -0800649 unsigned char *p = addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 while (size) {
652 if (*p == c)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800653 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 p++;
655 size--;
656 }
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800657 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659EXPORT_SYMBOL(memscan);
660#endif
661
662#ifndef __HAVE_ARCH_STRSTR
663/**
664 * strstr - Find the first substring in a %NUL terminated string
665 * @s1: The string to be searched
666 * @s2: The string to search for
667 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800668char *strstr(const char *s1, const char *s2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Li Zefand5f1fb52010-01-14 10:53:55 +0800670 size_t l1, l2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672 l2 = strlen(s2);
673 if (!l2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800674 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 l1 = strlen(s1);
676 while (l1 >= l2) {
677 l1--;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800678 if (!memcmp(s1, s2, l2))
679 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 s1++;
681 }
682 return NULL;
683}
684EXPORT_SYMBOL(strstr);
685#endif
686
Li Zefand5f1fb52010-01-14 10:53:55 +0800687#ifndef __HAVE_ARCH_STRNSTR
688/**
689 * strnstr - Find the first substring in a length-limited string
690 * @s1: The string to be searched
691 * @s2: The string to search for
692 * @len: the maximum number of characters to search
693 */
694char *strnstr(const char *s1, const char *s2, size_t len)
695{
696 size_t l1 = len, l2;
697
698 l2 = strlen(s2);
699 if (!l2)
700 return (char *)s1;
701 while (l1 >= l2) {
702 l1--;
703 if (!memcmp(s1, s2, l2))
704 return (char *)s1;
705 s1++;
706 }
707 return NULL;
708}
709EXPORT_SYMBOL(strnstr);
710#endif
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712#ifndef __HAVE_ARCH_MEMCHR
713/**
714 * memchr - Find a character in an area of memory.
715 * @s: The memory area
716 * @c: The byte to search for
717 * @n: The size of the area.
718 *
719 * returns the address of the first occurrence of @c, or %NULL
720 * if @c is not found
721 */
722void *memchr(const void *s, int c, size_t n)
723{
724 const unsigned char *p = s;
725 while (n-- != 0) {
726 if ((unsigned char)c == *p++) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800727 return (void *)(p - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 }
729 }
730 return NULL;
731}
732EXPORT_SYMBOL(memchr);
733#endif