1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_STRING_H_
3#define _LINUX_STRING_H_
4
5#include <linux/args.h>
6#include <linux/array_size.h>
7#include <linux/compiler.h>	/* for inline */
8#include <linux/types.h>	/* for size_t */
9#include <linux/stddef.h>	/* for NULL */
10#include <linux/err.h>		/* for ERR_PTR() */
11#include <linux/errno.h>	/* for E2BIG */
12#include <linux/overflow.h>	/* for check_mul_overflow() */
13#include <linux/stdarg.h>
14#include <uapi/linux/string.h>
15
16extern char *strndup_user(const char __user *, long);
17extern void *memdup_user(const void __user *, size_t);
18extern void *vmemdup_user(const void __user *, size_t);
19extern void *memdup_user_nul(const void __user *, size_t);
20
21/**
22 * memdup_array_user - duplicate array from user space
23 * @src: source address in user space
24 * @n: number of array members to copy
25 * @size: size of one array member
26 *
27 * Return: an ERR_PTR() on failure. Result is physically
28 * contiguous, to be freed by kfree().
29 */
30static inline void *memdup_array_user(const void __user *src, size_t n, size_t size)
31{
32	size_t nbytes;
33
34	if (check_mul_overflow(n, size, &nbytes))
35		return ERR_PTR(-EOVERFLOW);
36
37	return memdup_user(src, nbytes);
38}
39
40/**
41 * vmemdup_array_user - duplicate array from user space
42 * @src: source address in user space
43 * @n: number of array members to copy
44 * @size: size of one array member
45 *
46 * Return: an ERR_PTR() on failure. Result may be not
47 * physically contiguous. Use kvfree() to free.
48 */
49static inline void *vmemdup_array_user(const void __user *src, size_t n, size_t size)
50{
51	size_t nbytes;
52
53	if (check_mul_overflow(n, size, &nbytes))
54		return ERR_PTR(-EOVERFLOW);
55
56	return vmemdup_user(src, nbytes);
57}
58
59/*
60 * Include machine specific inline routines
61 */
62#include <asm/string.h>
63
64#ifndef __HAVE_ARCH_STRCPY
65extern char * strcpy(char *,const char *);
66#endif
67#ifndef __HAVE_ARCH_STRNCPY
68extern char * strncpy(char *,const char *, __kernel_size_t);
69#endif
70ssize_t sized_strscpy(char *, const char *, size_t);
71
72/*
73 * The 2 argument style can only be used when dst is an array with a
74 * known size.
75 */
76#define __strscpy0(dst, src, ...)	\
77	sized_strscpy(dst, src, sizeof(dst) + __must_be_array(dst))
78#define __strscpy1(dst, src, size)	sized_strscpy(dst, src, size)
79
80#define __strscpy_pad0(dst, src, ...)	\
81	sized_strscpy_pad(dst, src, sizeof(dst) + __must_be_array(dst))
82#define __strscpy_pad1(dst, src, size)	sized_strscpy_pad(dst, src, size)
83
84/**
85 * strscpy - Copy a C-string into a sized buffer
86 * @dst: Where to copy the string to
87 * @src: Where to copy the string from
88 * @...: Size of destination buffer (optional)
89 *
90 * Copy the source string @src, or as much of it as fits, into the
91 * destination @dst buffer. The behavior is undefined if the string
92 * buffers overlap. The destination @dst buffer is always NUL terminated,
93 * unless it's zero-sized.
94 *
95 * The size argument @... is only required when @dst is not an array, or
96 * when the copy needs to be smaller than sizeof(@dst).
97 *
98 * Preferred to strncpy() since it always returns a valid string, and
99 * doesn't unnecessarily force the tail of the destination buffer to be
100 * zero padded. If padding is desired please use strscpy_pad().
101 *
102 * Returns the number of characters copied in @dst (not including the
103 * trailing %NUL) or -E2BIG if @size is 0 or the copy from @src was
104 * truncated.
105 */
106#define strscpy(dst, src, ...)	\
107	CONCATENATE(__strscpy, COUNT_ARGS(__VA_ARGS__))(dst, src, __VA_ARGS__)
108
109#define sized_strscpy_pad(dest, src, count)	({			\
110	char *__dst = (dest);						\
111	const char *__src = (src);					\
112	const size_t __count = (count);					\
113	ssize_t __wrote;						\
114									\
115	__wrote = sized_strscpy(__dst, __src, __count);			\
116	if (__wrote >= 0 && __wrote < __count)				\
117		memset(__dst + __wrote + 1, 0, __count - __wrote - 1);	\
118	__wrote;							\
119})
120
121/**
122 * strscpy_pad() - Copy a C-string into a sized buffer
123 * @dst: Where to copy the string to
124 * @src: Where to copy the string from
125 * @...: Size of destination buffer
126 *
127 * Copy the string, or as much of it as fits, into the dest buffer. The
128 * behavior is undefined if the string buffers overlap. The destination
129 * buffer is always %NUL terminated, unless it's zero-sized.
130 *
131 * If the source string is shorter than the destination buffer, the
132 * remaining bytes in the buffer will be filled with %NUL bytes.
133 *
134 * For full explanation of why you may want to consider using the
135 * 'strscpy' functions please see the function docstring for strscpy().
136 *
137 * Returns:
138 * * The number of characters copied (not including the trailing %NULs)
139 * * -E2BIG if count is 0 or @src was truncated.
140 */
141#define strscpy_pad(dst, src, ...)	\
142	CONCATENATE(__strscpy_pad, COUNT_ARGS(__VA_ARGS__))(dst, src, __VA_ARGS__)
143
144#ifndef __HAVE_ARCH_STRCAT
145extern char * strcat(char *, const char *);
146#endif
147#ifndef __HAVE_ARCH_STRNCAT
148extern char * strncat(char *, const char *, __kernel_size_t);
149#endif
150#ifndef __HAVE_ARCH_STRLCAT
151extern size_t strlcat(char *, const char *, __kernel_size_t);
152#endif
153#ifndef __HAVE_ARCH_STRCMP
154extern int strcmp(const char *,const char *);
155#endif
156#ifndef __HAVE_ARCH_STRNCMP
157extern int strncmp(const char *,const char *,__kernel_size_t);
158#endif
159#ifndef __HAVE_ARCH_STRCASECMP
160extern int strcasecmp(const char *s1, const char *s2);
161#endif
162#ifndef __HAVE_ARCH_STRNCASECMP
163extern int strncasecmp(const char *s1, const char *s2, size_t n);
164#endif
165#ifndef __HAVE_ARCH_STRCHR
166extern char * strchr(const char *,int);
167#endif
168#ifndef __HAVE_ARCH_STRCHRNUL
169extern char * strchrnul(const char *,int);
170#endif
171extern char * strnchrnul(const char *, size_t, int);
172#ifndef __HAVE_ARCH_STRNCHR
173extern char * strnchr(const char *, size_t, int);
174#endif
175#ifndef __HAVE_ARCH_STRRCHR
176extern char * strrchr(const char *,int);
177#endif
178extern char * __must_check skip_spaces(const char *);
179
180extern char *strim(char *);
181
182static inline __must_check char *strstrip(char *str)
183{
184	return strim(str);
185}
186
187#ifndef __HAVE_ARCH_STRSTR
188extern char * strstr(const char *, const char *);
189#endif
190#ifndef __HAVE_ARCH_STRNSTR
191extern char * strnstr(const char *, const char *, size_t);
192#endif
193#ifndef __HAVE_ARCH_STRLEN
194extern __kernel_size_t strlen(const char *);
195#endif
196#ifndef __HAVE_ARCH_STRNLEN
197extern __kernel_size_t strnlen(const char *,__kernel_size_t);
198#endif
199#ifndef __HAVE_ARCH_STRPBRK
200extern char * strpbrk(const char *,const char *);
201#endif
202#ifndef __HAVE_ARCH_STRSEP
203extern char * strsep(char **,const char *);
204#endif
205#ifndef __HAVE_ARCH_STRSPN
206extern __kernel_size_t strspn(const char *,const char *);
207#endif
208#ifndef __HAVE_ARCH_STRCSPN
209extern __kernel_size_t strcspn(const char *,const char *);
210#endif
211
212#ifndef __HAVE_ARCH_MEMSET
213extern void * memset(void *,int,__kernel_size_t);
214#endif
215
216#ifndef __HAVE_ARCH_MEMSET16
217extern void *memset16(uint16_t *, uint16_t, __kernel_size_t);
218#endif
219
220#ifndef __HAVE_ARCH_MEMSET32
221extern void *memset32(uint32_t *, uint32_t, __kernel_size_t);
222#endif
223
224#ifndef __HAVE_ARCH_MEMSET64
225extern void *memset64(uint64_t *, uint64_t, __kernel_size_t);
226#endif
227
228static inline void *memset_l(unsigned long *p, unsigned long v,
229		__kernel_size_t n)
230{
231	if (BITS_PER_LONG == 32)
232		return memset32((uint32_t *)p, v, n);
233	else
234		return memset64((uint64_t *)p, v, n);
235}
236
237static inline void *memset_p(void **p, void *v, __kernel_size_t n)
238{
239	if (BITS_PER_LONG == 32)
240		return memset32((uint32_t *)p, (uintptr_t)v, n);
241	else
242		return memset64((uint64_t *)p, (uintptr_t)v, n);
243}
244
245extern void **__memcat_p(void **a, void **b);
246#define memcat_p(a, b) ({					\
247	BUILD_BUG_ON_MSG(!__same_type(*(a), *(b)),		\
248			 "type mismatch in memcat_p()");	\
249	(typeof(*a) *)__memcat_p((void **)(a), (void **)(b));	\
250})
251
252#ifndef __HAVE_ARCH_MEMCPY
253extern void * memcpy(void *,const void *,__kernel_size_t);
254#endif
255#ifndef __HAVE_ARCH_MEMMOVE
256extern void * memmove(void *,const void *,__kernel_size_t);
257#endif
258#ifndef __HAVE_ARCH_MEMSCAN
259extern void * memscan(void *,int,__kernel_size_t);
260#endif
261#ifndef __HAVE_ARCH_MEMCMP
262extern int memcmp(const void *,const void *,__kernel_size_t);
263#endif
264#ifndef __HAVE_ARCH_BCMP
265extern int bcmp(const void *,const void *,__kernel_size_t);
266#endif
267#ifndef __HAVE_ARCH_MEMCHR
268extern void * memchr(const void *,int,__kernel_size_t);
269#endif
270#ifndef __HAVE_ARCH_MEMCPY_FLUSHCACHE
271static inline void memcpy_flushcache(void *dst, const void *src, size_t cnt)
272{
273	memcpy(dst, src, cnt);
274}
275#endif
276
277void *memchr_inv(const void *s, int c, size_t n);
278char *strreplace(char *str, char old, char new);
279
280extern void kfree_const(const void *x);
281
282extern char *kstrdup(const char *s, gfp_t gfp) __malloc;
283extern const char *kstrdup_const(const char *s, gfp_t gfp);
284extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
285extern void *kmemdup(const void *src, size_t len, gfp_t gfp) __realloc_size(2);
286extern void *kvmemdup(const void *src, size_t len, gfp_t gfp) __realloc_size(2);
287extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
288extern void *kmemdup_array(const void *src, size_t element_size, size_t count, gfp_t gfp);
289
290/* lib/argv_split.c */
291extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
292extern void argv_free(char **argv);
293
294/* lib/cmdline.c */
295extern int get_option(char **str, int *pint);
296extern char *get_options(const char *str, int nints, int *ints);
297extern unsigned long long memparse(const char *ptr, char **retptr);
298extern bool parse_option_str(const char *str, const char *option);
299extern char *next_arg(char *args, char **param, char **val);
300
301extern bool sysfs_streq(const char *s1, const char *s2);
302int match_string(const char * const *array, size_t n, const char *string);
303int __sysfs_match_string(const char * const *array, size_t n, const char *s);
304
305/**
306 * sysfs_match_string - matches given string in an array
307 * @_a: array of strings
308 * @_s: string to match with
309 *
310 * Helper for __sysfs_match_string(). Calculates the size of @a automatically.
311 */
312#define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a), _s)
313
314#ifdef CONFIG_BINARY_PRINTF
315int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
316int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
317int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
318#endif
319
320extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
321				       const void *from, size_t available);
322
323int ptr_to_hashval(const void *ptr, unsigned long *hashval_out);
324
325/**
326 * strstarts - does @str start with @prefix?
327 * @str: string to examine
328 * @prefix: prefix to look for.
329 */
330static inline bool strstarts(const char *str, const char *prefix)
331{
332	return strncmp(str, prefix, strlen(prefix)) == 0;
333}
334
335size_t memweight(const void *ptr, size_t bytes);
336
337/**
338 * memzero_explicit - Fill a region of memory (e.g. sensitive
339 *		      keying data) with 0s.
340 * @s: Pointer to the start of the area.
341 * @count: The size of the area.
342 *
343 * Note: usually using memset() is just fine (!), but in cases
344 * where clearing out _local_ data at the end of a scope is
345 * necessary, memzero_explicit() should be used instead in
346 * order to prevent the compiler from optimising away zeroing.
347 *
348 * memzero_explicit() doesn't need an arch-specific version as
349 * it just invokes the one of memset() implicitly.
350 */
351static inline void memzero_explicit(void *s, size_t count)
352{
353	memset(s, 0, count);
354	barrier_data(s);
355}
356
357/**
358 * kbasename - return the last part of a pathname.
359 *
360 * @path: path to extract the filename from.
361 */
362static inline const char *kbasename(const char *path)
363{
364	const char *tail = strrchr(path, '/');
365	return tail ? tail + 1 : path;
366}
367
368#if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE)
369#include <linux/fortify-string.h>
370#endif
371#ifndef unsafe_memcpy
372#define unsafe_memcpy(dst, src, bytes, justification)		\
373	memcpy(dst, src, bytes)
374#endif
375
376void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count,
377		    int pad);
378
379/**
380 * strtomem_pad - Copy NUL-terminated string to non-NUL-terminated buffer
381 *
382 * @dest: Pointer of destination character array (marked as __nonstring)
383 * @src: Pointer to NUL-terminated string
384 * @pad: Padding character to fill any remaining bytes of @dest after copy
385 *
386 * This is a replacement for strncpy() uses where the destination is not
387 * a NUL-terminated string, but with bounds checking on the source size, and
388 * an explicit padding character. If padding is not required, use strtomem().
389 *
390 * Note that the size of @dest is not an argument, as the length of @dest
391 * must be discoverable by the compiler.
392 */
393#define strtomem_pad(dest, src, pad)	do {				\
394	const size_t _dest_len = __builtin_object_size(dest, 1);	\
395	const size_t _src_len = __builtin_object_size(src, 1);		\
396									\
397	BUILD_BUG_ON(!__builtin_constant_p(_dest_len) ||		\
398		     _dest_len == (size_t)-1);				\
399	memcpy_and_pad(dest, _dest_len, src,				\
400		       strnlen(src, min(_src_len, _dest_len)), pad);	\
401} while (0)
402
403/**
404 * strtomem - Copy NUL-terminated string to non-NUL-terminated buffer
405 *
406 * @dest: Pointer of destination character array (marked as __nonstring)
407 * @src: Pointer to NUL-terminated string
408 *
409 * This is a replacement for strncpy() uses where the destination is not
410 * a NUL-terminated string, but with bounds checking on the source size, and
411 * without trailing padding. If padding is required, use strtomem_pad().
412 *
413 * Note that the size of @dest is not an argument, as the length of @dest
414 * must be discoverable by the compiler.
415 */
416#define strtomem(dest, src)	do {					\
417	const size_t _dest_len = __builtin_object_size(dest, 1);	\
418	const size_t _src_len = __builtin_object_size(src, 1);		\
419									\
420	BUILD_BUG_ON(!__builtin_constant_p(_dest_len) ||		\
421		     _dest_len == (size_t)-1);				\
422	memcpy(dest, src, strnlen(src, min(_src_len, _dest_len)));	\
423} while (0)
424
425/**
426 * memset_after - Set a value after a struct member to the end of a struct
427 *
428 * @obj: Address of target struct instance
429 * @v: Byte value to repeatedly write
430 * @member: after which struct member to start writing bytes
431 *
432 * This is good for clearing padding following the given member.
433 */
434#define memset_after(obj, v, member)					\
435({									\
436	u8 *__ptr = (u8 *)(obj);					\
437	typeof(v) __val = (v);						\
438	memset(__ptr + offsetofend(typeof(*(obj)), member), __val,	\
439	       sizeof(*(obj)) - offsetofend(typeof(*(obj)), member));	\
440})
441
442/**
443 * memset_startat - Set a value starting at a member to the end of a struct
444 *
445 * @obj: Address of target struct instance
446 * @v: Byte value to repeatedly write
447 * @member: struct member to start writing at
448 *
449 * Note that if there is padding between the prior member and the target
450 * member, memset_after() should be used to clear the prior padding.
451 */
452#define memset_startat(obj, v, member)					\
453({									\
454	u8 *__ptr = (u8 *)(obj);					\
455	typeof(v) __val = (v);						\
456	memset(__ptr + offsetof(typeof(*(obj)), member), __val,		\
457	       sizeof(*(obj)) - offsetof(typeof(*(obj)), member));	\
458})
459
460/**
461 * str_has_prefix - Test if a string has a given prefix
462 * @str: The string to test
463 * @prefix: The string to see if @str starts with
464 *
465 * A common way to test a prefix of a string is to do:
466 *  strncmp(str, prefix, sizeof(prefix) - 1)
467 *
468 * But this can lead to bugs due to typos, or if prefix is a pointer
469 * and not a constant. Instead use str_has_prefix().
470 *
471 * Returns:
472 * * strlen(@prefix) if @str starts with @prefix
473 * * 0 if @str does not start with @prefix
474 */
475static __always_inline size_t str_has_prefix(const char *str, const char *prefix)
476{
477	size_t len = strlen(prefix);
478	return strncmp(str, prefix, len) == 0 ? len : 0;
479}
480
481#endif /* _LINUX_STRING_H_ */
482