1/* -*- linux-c -*- ------------------------------------------------------- *
2 *
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright 2007 rPath, Inc. - All Rights Reserved
5 *
6 * This file is part of the Linux kernel, and is made available under
7 * the terms of the GNU General Public License version 2.
8 *
9 * ----------------------------------------------------------------------- */
10
11/*
12 * Very basic string functions
13 */
14
15#include <linux/types.h>
16#include <linux/compiler.h>
17#include <linux/errno.h>
18#include <linux/limits.h>
19#include <asm/asm.h>
20#include "ctype.h"
21#include "string.h"
22
23#define KSTRTOX_OVERFLOW (1U << 31)
24
25/*
26 * Undef these macros so that the functions that we provide
27 * here will have the correct names regardless of how string.h
28 * may have chosen to #define them.
29 */
30#undef memcpy
31#undef memset
32#undef memcmp
33
34int memcmp(const void *s1, const void *s2, size_t len)
35{
36 bool diff;
37 asm("repe; cmpsb" CC_SET(nz)
38 : CC_OUT(nz) (diff), "+D" (s1), "+S" (s2), "+c" (len));
39 return diff;
40}
41
42int strcmp(const char *str1, const char *str2)
43{
44 const unsigned char *s1 = (const unsigned char *)str1;
45 const unsigned char *s2 = (const unsigned char *)str2;
46 int delta = 0;
47
48 while (*s1 || *s2) {
49 delta = *s1 - *s2;
50 if (delta)
51 return delta;
52 s1++;
53 s2++;
54 }
55 return 0;
56}
57
58int strncmp(const char *cs, const char *ct, size_t count)
59{
60 unsigned char c1, c2;
61
62 while (count) {
63 c1 = *cs++;
64 c2 = *ct++;
65 if (c1 != c2)
66 return c1 < c2 ? -1 : 1;
67 if (!c1)
68 break;
69 count--;
70 }
71 return 0;
72}
73
74size_t strnlen(const char *s, size_t maxlen)
75{
76 const char *es = s;
77 while (*es && maxlen) {
78 es++;
79 maxlen--;
80 }
81
82 return (es - s);
83}
84
85unsigned int atou(const char *s)
86{
87 unsigned int i = 0;
88 while (isdigit(*s))
89 i = i * 10 + (*s++ - '0');
90 return i;
91}
92
93/* Works only for digits and letters, but small and fast */
94#define TOLOWER(x) ((x) | 0x20)
95
96static unsigned int simple_guess_base(const char *cp)
97{
98 if (cp[0] == '0') {
99 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
100 return 16;
101 else
102 return 8;
103 } else {
104 return 10;
105 }
106}
107
108/**
109 * simple_strtoull - convert a string to an unsigned long long
110 * @cp: The start of the string
111 * @endp: A pointer to the end of the parsed string will be placed here
112 * @base: The number base to use
113 */
114
115unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
116{
117 unsigned long long result = 0;
118
119 if (!base)
120 base = simple_guess_base(cp);
121
122 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
123 cp += 2;
124
125 while (isxdigit(*cp)) {
126 unsigned int value;
127
128 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
129 if (value >= base)
130 break;
131 result = result * base + value;
132 cp++;
133 }
134 if (endp)
135 *endp = (char *)cp;
136
137 return result;
138}
139
140long simple_strtol(const char *cp, char **endp, unsigned int base)
141{
142 if (*cp == '-')
143 return -simple_strtoull(cp + 1, endp, base);
144
145 return simple_strtoull(cp, endp, base);
146}
147
148/**
149 * strlen - Find the length of a string
150 * @s: The string to be sized
151 */
152size_t strlen(const char *s)
153{
154 const char *sc;
155
156 for (sc = s; *sc != '\0'; ++sc)
157 /* nothing */;
158 return sc - s;
159}
160
161/**
162 * strstr - Find the first substring in a %NUL terminated string
163 * @s1: The string to be searched
164 * @s2: The string to search for
165 */
166char *strstr(const char *s1, const char *s2)
167{
168 size_t l1, l2;
169
170 l2 = strlen(s2);
171 if (!l2)
172 return (char *)s1;
173 l1 = strlen(s1);
174 while (l1 >= l2) {
175 l1--;
176 if (!memcmp(s1, s2, l2))
177 return (char *)s1;
178 s1++;
179 }
180 return NULL;
181}
182
183/**
184 * strchr - Find the first occurrence of the character c in the string s.
185 * @s: the string to be searched
186 * @c: the character to search for
187 */
188char *strchr(const char *s, int c)
189{
190 while (*s != (char)c)
191 if (*s++ == '\0')
192 return NULL;
193 return (char *)s;
194}
195
196static inline u64 __div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
197{
198 union {
199 u64 v64;
200 u32 v32[2];
201 } d = { dividend };
202 u32 upper;
203
204 upper = d.v32[1];
205 d.v32[1] = 0;
206 if (upper >= divisor) {
207 d.v32[1] = upper / divisor;
208 upper %= divisor;
209 }
210 asm ("divl %2" : "=a" (d.v32[0]), "=d" (*remainder) :
211 "rm" (divisor), "0" (d.v32[0]), "1" (upper));
212 return d.v64;
213}
214
215static inline u64 __div_u64(u64 dividend, u32 divisor)
216{
217 u32 remainder;
218
219 return __div_u64_rem(dividend, divisor, &remainder);
220}
221
222static inline char _tolower(const char c)
223{
224 return c | 0x20;
225}
226
227static const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
228{
229 if (*base == 0) {
230 if (s[0] == '0') {
231 if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
232 *base = 16;
233 else
234 *base = 8;
235 } else
236 *base = 10;
237 }
238 if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
239 s += 2;
240 return s;
241}
242
243/*
244 * Convert non-negative integer string representation in explicitly given radix
245 * to an integer.
246 * Return number of characters consumed maybe or-ed with overflow bit.
247 * If overflow occurs, result integer (incorrect) is still returned.
248 *
249 * Don't you dare use this function.
250 */
251static unsigned int _parse_integer(const char *s,
252 unsigned int base,
253 unsigned long long *p)
254{
255 unsigned long long res;
256 unsigned int rv;
257
258 res = 0;
259 rv = 0;
260 while (1) {
261 unsigned int c = *s;
262 unsigned int lc = c | 0x20; /* don't tolower() this line */
263 unsigned int val;
264
265 if ('0' <= c && c <= '9')
266 val = c - '0';
267 else if ('a' <= lc && lc <= 'f')
268 val = lc - 'a' + 10;
269 else
270 break;
271
272 if (val >= base)
273 break;
274 /*
275 * Check for overflow only if we are within range of
276 * it in the max base we support (16)
277 */
278 if (unlikely(res & (~0ull << 60))) {
279 if (res > __div_u64(ULLONG_MAX - val, base))
280 rv |= KSTRTOX_OVERFLOW;
281 }
282 res = res * base + val;
283 rv++;
284 s++;
285 }
286 *p = res;
287 return rv;
288}
289
290static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
291{
292 unsigned long long _res;
293 unsigned int rv;
294
295 s = _parse_integer_fixup_radix(s, &base);
296 rv = _parse_integer(s, base, &_res);
297 if (rv & KSTRTOX_OVERFLOW)
298 return -ERANGE;
299 if (rv == 0)
300 return -EINVAL;
301 s += rv;
302 if (*s == '\n')
303 s++;
304 if (*s)
305 return -EINVAL;
306 *res = _res;
307 return 0;
308}
309
310/**
311 * kstrtoull - convert a string to an unsigned long long
312 * @s: The start of the string. The string must be null-terminated, and may also
313 * include a single newline before its terminating null. The first character
314 * may also be a plus sign, but not a minus sign.
315 * @base: The number base to use. The maximum supported base is 16. If base is
316 * given as 0, then the base of the string is automatically detected with the
317 * conventional semantics - If it begins with 0x the number will be parsed as a
318 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
319 * parsed as an octal number. Otherwise it will be parsed as a decimal.
320 * @res: Where to write the result of the conversion on success.
321 *
322 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
323 * Used as a replacement for the obsolete simple_strtoull. Return code must
324 * be checked.
325 */
326int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
327{
328 if (s[0] == '+')
329 s++;
330 return _kstrtoull(s, base, res);
331}
332