blob: a467e617eeb08cde480b7e5e2b65ffa208d2243c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_STRING_H_
2#define _LINUX_STRING_H_
3
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5#include <linux/compiler.h> /* for inline */
6#include <linux/types.h> /* for size_t */
7#include <linux/stddef.h> /* for NULL */
Lai Jiangshan4370aa42009-03-06 17:21:46 +01008#include <stdarg.h>
David Howells607ca462012-10-13 10:46:48 +01009#include <uapi/linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Davi Arnaut96840aa2006-03-24 03:18:42 -080011extern char *strndup_user(const char __user *, long);
Li Zefan610a77e2009-03-31 15:23:16 -070012extern void *memdup_user(const void __user *, size_t);
Al Viroe9d408e2015-12-24 00:06:05 -050013extern void *memdup_user_nul(const void __user *, size_t);
Davi Arnaut96840aa2006-03-24 03:18:42 -080014
Linus Torvalds1da177e2005-04-16 15:20:36 -070015/*
16 * Include machine specific inline routines
17 */
18#include <asm/string.h>
19
20#ifndef __HAVE_ARCH_STRCPY
21extern char * strcpy(char *,const char *);
22#endif
23#ifndef __HAVE_ARCH_STRNCPY
24extern char * strncpy(char *,const char *, __kernel_size_t);
25#endif
26#ifndef __HAVE_ARCH_STRLCPY
27size_t strlcpy(char *, const char *, size_t);
28#endif
Chris Metcalf30035e42015-04-29 12:52:04 -040029#ifndef __HAVE_ARCH_STRSCPY
30ssize_t __must_check strscpy(char *, const char *, size_t);
31#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#ifndef __HAVE_ARCH_STRCAT
33extern char * strcat(char *, const char *);
34#endif
35#ifndef __HAVE_ARCH_STRNCAT
36extern char * strncat(char *, const char *, __kernel_size_t);
37#endif
38#ifndef __HAVE_ARCH_STRLCAT
39extern size_t strlcat(char *, const char *, __kernel_size_t);
40#endif
41#ifndef __HAVE_ARCH_STRCMP
42extern int strcmp(const char *,const char *);
43#endif
44#ifndef __HAVE_ARCH_STRNCMP
45extern int strncmp(const char *,const char *,__kernel_size_t);
46#endif
David S. Millerded220b2007-03-29 01:18:42 -070047#ifndef __HAVE_ARCH_STRCASECMP
48extern int strcasecmp(const char *s1, const char *s2);
49#endif
50#ifndef __HAVE_ARCH_STRNCASECMP
51extern int strncasecmp(const char *s1, const char *s2, size_t n);
52#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#ifndef __HAVE_ARCH_STRCHR
54extern char * strchr(const char *,int);
55#endif
Grant Likely11d200e2014-03-14 17:00:14 +000056#ifndef __HAVE_ARCH_STRCHRNUL
57extern char * strchrnul(const char *,int);
58#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#ifndef __HAVE_ARCH_STRNCHR
60extern char * strnchr(const char *, size_t, int);
61#endif
62#ifndef __HAVE_ARCH_STRRCHR
63extern char * strrchr(const char *,int);
64#endif
André Goddard Rosaf6533982009-12-14 18:01:04 -080065extern char * __must_check skip_spaces(const char *);
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -080066
67extern char *strim(char *);
68
69static inline __must_check char *strstrip(char *str)
70{
71 return strim(str);
72}
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#ifndef __HAVE_ARCH_STRSTR
Li Zefand5f1fb52010-01-14 10:53:55 +080075extern char * strstr(const char *, const char *);
76#endif
77#ifndef __HAVE_ARCH_STRNSTR
78extern char * strnstr(const char *, const char *, size_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#endif
80#ifndef __HAVE_ARCH_STRLEN
81extern __kernel_size_t strlen(const char *);
82#endif
83#ifndef __HAVE_ARCH_STRNLEN
84extern __kernel_size_t strnlen(const char *,__kernel_size_t);
85#endif
Kyle McMartin8833d322006-04-10 22:53:57 -070086#ifndef __HAVE_ARCH_STRPBRK
87extern char * strpbrk(const char *,const char *);
88#endif
89#ifndef __HAVE_ARCH_STRSEP
90extern char * strsep(char **,const char *);
91#endif
92#ifndef __HAVE_ARCH_STRSPN
93extern __kernel_size_t strspn(const char *,const char *);
94#endif
95#ifndef __HAVE_ARCH_STRCSPN
96extern __kernel_size_t strcspn(const char *,const char *);
97#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99#ifndef __HAVE_ARCH_MEMSET
100extern void * memset(void *,int,__kernel_size_t);
101#endif
102#ifndef __HAVE_ARCH_MEMCPY
103extern void * memcpy(void *,const void *,__kernel_size_t);
104#endif
105#ifndef __HAVE_ARCH_MEMMOVE
106extern void * memmove(void *,const void *,__kernel_size_t);
107#endif
108#ifndef __HAVE_ARCH_MEMSCAN
109extern void * memscan(void *,int,__kernel_size_t);
110#endif
111#ifndef __HAVE_ARCH_MEMCMP
112extern int memcmp(const void *,const void *,__kernel_size_t);
113#endif
114#ifndef __HAVE_ARCH_MEMCHR
115extern void * memchr(const void *,int,__kernel_size_t);
116#endif
Dan Williams6abccd12017-01-13 14:14:23 -0800117#ifndef __HAVE_ARCH_MEMCPY_MCSAFE
118static inline __must_check int memcpy_mcsafe(void *dst, const void *src,
119 size_t cnt)
120{
121 memcpy(dst, src, cnt);
122 return 0;
123}
124#endif
Dan Williams0aed55a2017-05-29 12:22:50 -0700125#ifndef __HAVE_ARCH_MEMCPY_FLUSHCACHE
126static inline void memcpy_flushcache(void *dst, const void *src, size_t cnt)
127{
128 memcpy(dst, src, cnt);
129}
130#endif
Akinobu Mita798248202011-10-31 17:08:07 -0700131void *memchr_inv(const void *s, int c, size_t n);
Rasmus Villemoes94df2902015-06-25 15:02:22 -0700132char *strreplace(char *s, char old, char new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Andrzej Hajdaa4bb1e42015-02-13 14:36:24 -0800134extern void kfree_const(const void *x);
135
Rasmus Villemoes48a27052016-05-19 17:10:55 -0700136extern char *kstrdup(const char *s, gfp_t gfp) __malloc;
Andrzej Hajdaa4bb1e42015-02-13 14:36:24 -0800137extern const char *kstrdup_const(const char *s, gfp_t gfp);
Jeremy Fitzhardinge1e66df32007-07-17 18:37:02 -0700138extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
Alexey Dobriyan1a2f67b2006-09-30 23:27:20 -0700139extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
David Howellsf3515742017-07-04 17:25:02 +0100140extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
Paulo Marques543537b2005-06-23 00:09:02 -0700141
Jeremy Fitzhardinged84d1cc2007-07-17 18:37:02 -0700142extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
143extern void argv_free(char **argv);
144
David Brownell34990cf2008-05-01 04:34:42 -0700145extern bool sysfs_streq(const char *s1, const char *s2);
Kees Cookef951592016-03-17 14:22:50 -0700146extern int kstrtobool(const char *s, bool *res);
147static inline int strtobool(const char *s, bool *res)
148{
149 return kstrtobool(s, res);
150}
David Brownell34990cf2008-05-01 04:34:42 -0700151
Andy Shevchenko56b06082016-03-17 14:22:14 -0700152int match_string(const char * const *array, size_t n, const char *string);
Heikki Krogeruse1fe7b62017-03-21 13:56:46 +0200153int __sysfs_match_string(const char * const *array, size_t n, const char *s);
154
155/**
156 * sysfs_match_string - matches given string in an array
157 * @_a: array of strings
158 * @_s: string to match with
159 *
160 * Helper for __sysfs_match_string(). Calculates the size of @a automatically.
161 */
162#define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a), _s)
Andy Shevchenko56b06082016-03-17 14:22:14 -0700163
Lai Jiangshan4370aa42009-03-06 17:21:46 +0100164#ifdef CONFIG_BINARY_PRINTF
165int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
166int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
167int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
168#endif
169
Akinobu Mitae108526e2008-07-23 21:26:44 -0700170extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
Daniel Borkmannd4c5efd2014-08-26 23:16:35 -0400171 const void *from, size_t available);
Akinobu Mitae108526e2008-07-23 21:26:44 -0700172
Rusty Russell66f92cf2009-03-31 13:05:36 -0600173/**
174 * strstarts - does @str start with @prefix?
175 * @str: string to examine
176 * @prefix: prefix to look for.
177 */
178static inline bool strstarts(const char *str, const char *prefix)
179{
180 return strncmp(str, prefix, strlen(prefix)) == 0;
181}
Akinobu Mita639b9e32012-07-30 14:40:55 -0700182
Daniel Borkmannd4c5efd2014-08-26 23:16:35 -0400183size_t memweight(const void *ptr, size_t bytes);
184void memzero_explicit(void *s, size_t count);
Akinobu Mita639b9e32012-07-30 14:40:55 -0700185
Andy Shevchenkob18888a2012-12-17 16:01:18 -0800186/**
187 * kbasename - return the last part of a pathname.
188 *
189 * @path: path to extract the filename from.
190 */
191static inline const char *kbasename(const char *path)
192{
193 const char *tail = strrchr(path, '/');
194 return tail ? tail + 1 : path;
195}
196
Daniel Micay6974f0c2017-07-12 14:36:10 -0700197#define __FORTIFY_INLINE extern __always_inline __attribute__((gnu_inline))
198#define __RENAME(x) __asm__(#x)
199
200void fortify_panic(const char *name) __noreturn __cold;
201void __read_overflow(void) __compiletime_error("detected read beyond size of object passed as 1st parameter");
202void __read_overflow2(void) __compiletime_error("detected read beyond size of object passed as 2nd parameter");
203void __write_overflow(void) __compiletime_error("detected write beyond size of object passed as 1st parameter");
204
205#if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE)
Daniel Micay6974f0c2017-07-12 14:36:10 -0700206__FORTIFY_INLINE char *strncpy(char *p, const char *q, __kernel_size_t size)
207{
208 size_t p_size = __builtin_object_size(p, 0);
209 if (__builtin_constant_p(size) && p_size < size)
210 __write_overflow();
211 if (p_size < size)
212 fortify_panic(__func__);
213 return __builtin_strncpy(p, q, size);
214}
215
216__FORTIFY_INLINE char *strcat(char *p, const char *q)
217{
218 size_t p_size = __builtin_object_size(p, 0);
219 if (p_size == (size_t)-1)
220 return __builtin_strcat(p, q);
221 if (strlcat(p, q, p_size) >= p_size)
222 fortify_panic(__func__);
223 return p;
224}
225
226__FORTIFY_INLINE __kernel_size_t strlen(const char *p)
227{
228 __kernel_size_t ret;
229 size_t p_size = __builtin_object_size(p, 0);
230 if (p_size == (size_t)-1)
231 return __builtin_strlen(p);
232 ret = strnlen(p, p_size);
233 if (p_size <= ret)
234 fortify_panic(__func__);
235 return ret;
236}
237
238extern __kernel_size_t __real_strnlen(const char *, __kernel_size_t) __RENAME(strnlen);
239__FORTIFY_INLINE __kernel_size_t strnlen(const char *p, __kernel_size_t maxlen)
240{
241 size_t p_size = __builtin_object_size(p, 0);
242 __kernel_size_t ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
243 if (p_size <= ret && maxlen != ret)
244 fortify_panic(__func__);
245 return ret;
246}
247
248/* defined after fortified strlen to reuse it */
249extern size_t __real_strlcpy(char *, const char *, size_t) __RENAME(strlcpy);
250__FORTIFY_INLINE size_t strlcpy(char *p, const char *q, size_t size)
251{
252 size_t ret;
253 size_t p_size = __builtin_object_size(p, 0);
254 size_t q_size = __builtin_object_size(q, 0);
255 if (p_size == (size_t)-1 && q_size == (size_t)-1)
256 return __real_strlcpy(p, q, size);
257 ret = strlen(q);
258 if (size) {
259 size_t len = (ret >= size) ? size - 1 : ret;
260 if (__builtin_constant_p(len) && len >= p_size)
261 __write_overflow();
262 if (len >= p_size)
263 fortify_panic(__func__);
264 __builtin_memcpy(p, q, len);
265 p[len] = '\0';
266 }
267 return ret;
268}
269
270/* defined after fortified strlen and strnlen to reuse them */
271__FORTIFY_INLINE char *strncat(char *p, const char *q, __kernel_size_t count)
272{
273 size_t p_len, copy_len;
274 size_t p_size = __builtin_object_size(p, 0);
275 size_t q_size = __builtin_object_size(q, 0);
276 if (p_size == (size_t)-1 && q_size == (size_t)-1)
277 return __builtin_strncat(p, q, count);
278 p_len = strlen(p);
279 copy_len = strnlen(q, count);
280 if (p_size < p_len + copy_len + 1)
281 fortify_panic(__func__);
282 __builtin_memcpy(p + p_len, q, copy_len);
283 p[p_len + copy_len] = '\0';
284 return p;
285}
286
287__FORTIFY_INLINE void *memset(void *p, int c, __kernel_size_t size)
288{
289 size_t p_size = __builtin_object_size(p, 0);
290 if (__builtin_constant_p(size) && p_size < size)
291 __write_overflow();
292 if (p_size < size)
293 fortify_panic(__func__);
294 return __builtin_memset(p, c, size);
295}
296
297__FORTIFY_INLINE void *memcpy(void *p, const void *q, __kernel_size_t size)
298{
299 size_t p_size = __builtin_object_size(p, 0);
300 size_t q_size = __builtin_object_size(q, 0);
301 if (__builtin_constant_p(size)) {
302 if (p_size < size)
303 __write_overflow();
304 if (q_size < size)
305 __read_overflow2();
306 }
307 if (p_size < size || q_size < size)
308 fortify_panic(__func__);
309 return __builtin_memcpy(p, q, size);
310}
311
312__FORTIFY_INLINE void *memmove(void *p, const void *q, __kernel_size_t size)
313{
314 size_t p_size = __builtin_object_size(p, 0);
315 size_t q_size = __builtin_object_size(q, 0);
316 if (__builtin_constant_p(size)) {
317 if (p_size < size)
318 __write_overflow();
319 if (q_size < size)
320 __read_overflow2();
321 }
322 if (p_size < size || q_size < size)
323 fortify_panic(__func__);
324 return __builtin_memmove(p, q, size);
325}
326
327extern void *__real_memscan(void *, int, __kernel_size_t) __RENAME(memscan);
328__FORTIFY_INLINE void *memscan(void *p, int c, __kernel_size_t size)
329{
330 size_t p_size = __builtin_object_size(p, 0);
331 if (__builtin_constant_p(size) && p_size < size)
332 __read_overflow();
333 if (p_size < size)
334 fortify_panic(__func__);
335 return __real_memscan(p, c, size);
336}
337
338__FORTIFY_INLINE int memcmp(const void *p, const void *q, __kernel_size_t size)
339{
340 size_t p_size = __builtin_object_size(p, 0);
341 size_t q_size = __builtin_object_size(q, 0);
342 if (__builtin_constant_p(size)) {
343 if (p_size < size)
344 __read_overflow();
345 if (q_size < size)
346 __read_overflow2();
347 }
348 if (p_size < size || q_size < size)
349 fortify_panic(__func__);
350 return __builtin_memcmp(p, q, size);
351}
352
353__FORTIFY_INLINE void *memchr(const void *p, int c, __kernel_size_t size)
354{
355 size_t p_size = __builtin_object_size(p, 0);
356 if (__builtin_constant_p(size) && p_size < size)
357 __read_overflow();
358 if (p_size < size)
359 fortify_panic(__func__);
360 return __builtin_memchr(p, c, size);
361}
362
363void *__real_memchr_inv(const void *s, int c, size_t n) __RENAME(memchr_inv);
364__FORTIFY_INLINE void *memchr_inv(const void *p, int c, size_t size)
365{
366 size_t p_size = __builtin_object_size(p, 0);
367 if (__builtin_constant_p(size) && p_size < size)
368 __read_overflow();
369 if (p_size < size)
370 fortify_panic(__func__);
371 return __real_memchr_inv(p, c, size);
372}
373
374extern void *__real_kmemdup(const void *src, size_t len, gfp_t gfp) __RENAME(kmemdup);
375__FORTIFY_INLINE void *kmemdup(const void *p, size_t size, gfp_t gfp)
376{
377 size_t p_size = __builtin_object_size(p, 0);
378 if (__builtin_constant_p(size) && p_size < size)
379 __read_overflow();
380 if (p_size < size)
381 fortify_panic(__func__);
382 return __real_kmemdup(p, size, gfp);
383}
Daniel Micay077d2ba2017-07-14 17:28:12 -0400384
385/* defined after fortified strlen and memcpy to reuse them */
386__FORTIFY_INLINE char *strcpy(char *p, const char *q)
387{
388 size_t p_size = __builtin_object_size(p, 0);
389 size_t q_size = __builtin_object_size(q, 0);
390 if (p_size == (size_t)-1 && q_size == (size_t)-1)
391 return __builtin_strcpy(p, q);
392 memcpy(p, q, strlen(q) + 1);
393 return p;
394}
395
Daniel Micay6974f0c2017-07-12 14:36:10 -0700396#endif
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398#endif /* _LINUX_STRING_H_ */