Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #ifndef _LINUX_STRING_H_
3 : #define _LINUX_STRING_H_
4 :
5 :
6 : #include <linux/compiler.h> /* for inline */
7 : #include <linux/types.h> /* for size_t */
8 : #include <linux/stddef.h> /* for NULL */
9 : #include <linux/errno.h> /* for E2BIG */
10 : #include <stdarg.h>
11 : #include <uapi/linux/string.h>
12 :
13 : extern char *strndup_user(const char __user *, long);
14 : extern void *memdup_user(const void __user *, size_t);
15 : extern void *vmemdup_user(const void __user *, size_t);
16 : extern void *memdup_user_nul(const void __user *, size_t);
17 :
18 : /*
19 : * Include machine specific inline routines
20 : */
21 : #include <asm/string.h>
22 :
23 : #ifndef __HAVE_ARCH_STRCPY
24 : extern char * strcpy(char *,const char *);
25 : #endif
26 : #ifndef __HAVE_ARCH_STRNCPY
27 : extern char * strncpy(char *,const char *, __kernel_size_t);
28 : #endif
29 : #ifndef __HAVE_ARCH_STRLCPY
30 : size_t strlcpy(char *, const char *, size_t);
31 : #endif
32 : #ifndef __HAVE_ARCH_STRSCPY
33 : ssize_t strscpy(char *, const char *, size_t);
34 : #endif
35 :
36 : /* Wraps calls to strscpy()/memset(), no arch specific code required */
37 : ssize_t strscpy_pad(char *dest, const char *src, size_t count);
38 :
39 : #ifndef __HAVE_ARCH_STRCAT
40 : extern char * strcat(char *, const char *);
41 : #endif
42 : #ifndef __HAVE_ARCH_STRNCAT
43 : extern char * strncat(char *, const char *, __kernel_size_t);
44 : #endif
45 : #ifndef __HAVE_ARCH_STRLCAT
46 : extern size_t strlcat(char *, const char *, __kernel_size_t);
47 : #endif
48 : #ifndef __HAVE_ARCH_STRCMP
49 : extern int strcmp(const char *,const char *);
50 : #endif
51 : #ifndef __HAVE_ARCH_STRNCMP
52 : extern int strncmp(const char *,const char *,__kernel_size_t);
53 : #endif
54 : #ifndef __HAVE_ARCH_STRCASECMP
55 : extern int strcasecmp(const char *s1, const char *s2);
56 : #endif
57 : #ifndef __HAVE_ARCH_STRNCASECMP
58 : extern int strncasecmp(const char *s1, const char *s2, size_t n);
59 : #endif
60 : #ifndef __HAVE_ARCH_STRCHR
61 : extern char * strchr(const char *,int);
62 : #endif
63 : #ifndef __HAVE_ARCH_STRCHRNUL
64 : extern char * strchrnul(const char *,int);
65 : #endif
66 : extern char * strnchrnul(const char *, size_t, int);
67 : #ifndef __HAVE_ARCH_STRNCHR
68 : extern char * strnchr(const char *, size_t, int);
69 : #endif
70 : #ifndef __HAVE_ARCH_STRRCHR
71 : extern char * strrchr(const char *,int);
72 : #endif
73 : extern char * __must_check skip_spaces(const char *);
74 :
75 : extern char *strim(char *);
76 :
77 215 : static inline __must_check char *strstrip(char *str)
78 : {
79 215 : return strim(str);
80 : }
81 :
82 : #ifndef __HAVE_ARCH_STRSTR
83 : extern char * strstr(const char *, const char *);
84 : #endif
85 : #ifndef __HAVE_ARCH_STRNSTR
86 : extern char * strnstr(const char *, const char *, size_t);
87 : #endif
88 : #ifndef __HAVE_ARCH_STRLEN
89 : extern __kernel_size_t strlen(const char *);
90 : #endif
91 : #ifndef __HAVE_ARCH_STRNLEN
92 : extern __kernel_size_t strnlen(const char *,__kernel_size_t);
93 : #endif
94 : #ifndef __HAVE_ARCH_STRPBRK
95 : extern char * strpbrk(const char *,const char *);
96 : #endif
97 : #ifndef __HAVE_ARCH_STRSEP
98 : extern char * strsep(char **,const char *);
99 : #endif
100 : #ifndef __HAVE_ARCH_STRSPN
101 : extern __kernel_size_t strspn(const char *,const char *);
102 : #endif
103 : #ifndef __HAVE_ARCH_STRCSPN
104 : extern __kernel_size_t strcspn(const char *,const char *);
105 : #endif
106 :
107 : #ifndef __HAVE_ARCH_MEMSET
108 : extern void * memset(void *,int,__kernel_size_t);
109 : #endif
110 :
111 : #ifndef __HAVE_ARCH_MEMSET16
112 : extern void *memset16(uint16_t *, uint16_t, __kernel_size_t);
113 : #endif
114 :
115 : #ifndef __HAVE_ARCH_MEMSET32
116 : extern void *memset32(uint32_t *, uint32_t, __kernel_size_t);
117 : #endif
118 :
119 : #ifndef __HAVE_ARCH_MEMSET64
120 : extern void *memset64(uint64_t *, uint64_t, __kernel_size_t);
121 : #endif
122 :
123 : static inline void *memset_l(unsigned long *p, unsigned long v,
124 : __kernel_size_t n)
125 : {
126 : if (BITS_PER_LONG == 32)
127 : return memset32((uint32_t *)p, v, n);
128 : else
129 : return memset64((uint64_t *)p, v, n);
130 : }
131 :
132 : static inline void *memset_p(void **p, void *v, __kernel_size_t n)
133 : {
134 : if (BITS_PER_LONG == 32)
135 : return memset32((uint32_t *)p, (uintptr_t)v, n);
136 : else
137 : return memset64((uint64_t *)p, (uintptr_t)v, n);
138 : }
139 :
140 : extern void **__memcat_p(void **a, void **b);
141 : #define memcat_p(a, b) ({ \
142 : BUILD_BUG_ON_MSG(!__same_type(*(a), *(b)), \
143 : "type mismatch in memcat_p()"); \
144 : (typeof(*a) *)__memcat_p((void **)(a), (void **)(b)); \
145 : })
146 :
147 : #ifndef __HAVE_ARCH_MEMCPY
148 : extern void * memcpy(void *,const void *,__kernel_size_t);
149 : #endif
150 : #ifndef __HAVE_ARCH_MEMMOVE
151 : extern void * memmove(void *,const void *,__kernel_size_t);
152 : #endif
153 : #ifndef __HAVE_ARCH_MEMSCAN
154 : extern void * memscan(void *,int,__kernel_size_t);
155 : #endif
156 : #ifndef __HAVE_ARCH_MEMCMP
157 : extern int memcmp(const void *,const void *,__kernel_size_t);
158 : #endif
159 : #ifndef __HAVE_ARCH_BCMP
160 : extern int bcmp(const void *,const void *,__kernel_size_t);
161 : #endif
162 : #ifndef __HAVE_ARCH_MEMCHR
163 : extern void * memchr(const void *,int,__kernel_size_t);
164 : #endif
165 : #ifndef __HAVE_ARCH_MEMCPY_FLUSHCACHE
166 : static inline void memcpy_flushcache(void *dst, const void *src, size_t cnt)
167 : {
168 : memcpy(dst, src, cnt);
169 : }
170 : #endif
171 :
172 : void *memchr_inv(const void *s, int c, size_t n);
173 : char *strreplace(char *s, char old, char new);
174 :
175 : extern void kfree_const(const void *x);
176 :
177 : extern char *kstrdup(const char *s, gfp_t gfp) __malloc;
178 : extern const char *kstrdup_const(const char *s, gfp_t gfp);
179 : extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
180 : extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
181 : extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
182 :
183 : extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
184 : extern void argv_free(char **argv);
185 :
186 : extern bool sysfs_streq(const char *s1, const char *s2);
187 : extern int kstrtobool(const char *s, bool *res);
188 0 : static inline int strtobool(const char *s, bool *res)
189 : {
190 0 : return kstrtobool(s, res);
191 : }
192 :
193 : int match_string(const char * const *array, size_t n, const char *string);
194 : int __sysfs_match_string(const char * const *array, size_t n, const char *s);
195 :
196 : /**
197 : * sysfs_match_string - matches given string in an array
198 : * @_a: array of strings
199 : * @_s: string to match with
200 : *
201 : * Helper for __sysfs_match_string(). Calculates the size of @a automatically.
202 : */
203 : #define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a), _s)
204 :
205 : #ifdef CONFIG_BINARY_PRINTF
206 : int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
207 : int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
208 : int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
209 : #endif
210 :
211 : extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
212 : const void *from, size_t available);
213 :
214 : int ptr_to_hashval(const void *ptr, unsigned long *hashval_out);
215 :
216 : /**
217 : * strstarts - does @str start with @prefix?
218 : * @str: string to examine
219 : * @prefix: prefix to look for.
220 : */
221 : static inline bool strstarts(const char *str, const char *prefix)
222 : {
223 : return strncmp(str, prefix, strlen(prefix)) == 0;
224 : }
225 :
226 : size_t memweight(const void *ptr, size_t bytes);
227 :
228 : /**
229 : * memzero_explicit - Fill a region of memory (e.g. sensitive
230 : * keying data) with 0s.
231 : * @s: Pointer to the start of the area.
232 : * @count: The size of the area.
233 : *
234 : * Note: usually using memset() is just fine (!), but in cases
235 : * where clearing out _local_ data at the end of a scope is
236 : * necessary, memzero_explicit() should be used instead in
237 : * order to prevent the compiler from optimising away zeroing.
238 : *
239 : * memzero_explicit() doesn't need an arch-specific version as
240 : * it just invokes the one of memset() implicitly.
241 : */
242 1591 : static inline void memzero_explicit(void *s, size_t count)
243 : {
244 1591 : memset(s, 0, count);
245 1586 : barrier_data(s);
246 1 : }
247 :
248 : /**
249 : * kbasename - return the last part of a pathname.
250 : *
251 : * @path: path to extract the filename from.
252 : */
253 1976 : static inline const char *kbasename(const char *path)
254 : {
255 1976 : const char *tail = strrchr(path, '/');
256 1976 : return tail ? tail + 1 : path;
257 : }
258 :
259 : #define __FORTIFY_INLINE extern __always_inline __attribute__((gnu_inline))
260 : #define __RENAME(x) __asm__(#x)
261 :
262 : void fortify_panic(const char *name) __noreturn __cold;
263 : void __read_overflow(void) __compiletime_error("detected read beyond size of object passed as 1st parameter");
264 : void __read_overflow2(void) __compiletime_error("detected read beyond size of object passed as 2nd parameter");
265 : void __read_overflow3(void) __compiletime_error("detected read beyond size of object passed as 3rd parameter");
266 : void __write_overflow(void) __compiletime_error("detected write beyond size of object passed as 1st parameter");
267 :
268 : #if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE)
269 : #include <linux/fortify-string.h>
270 : #endif
271 :
272 : /**
273 : * memcpy_and_pad - Copy one buffer to another with padding
274 : * @dest: Where to copy to
275 : * @dest_len: The destination buffer size
276 : * @src: Where to copy from
277 : * @count: The number of bytes to copy
278 : * @pad: Character to use for padding if space is left in destination.
279 : */
280 : static inline void memcpy_and_pad(void *dest, size_t dest_len,
281 : const void *src, size_t count, int pad)
282 : {
283 : if (dest_len > count) {
284 : memcpy(dest, src, count);
285 : memset(dest + count, pad, dest_len - count);
286 : } else
287 : memcpy(dest, src, dest_len);
288 : }
289 :
290 : /**
291 : * str_has_prefix - Test if a string has a given prefix
292 : * @str: The string to test
293 : * @prefix: The string to see if @str starts with
294 : *
295 : * A common way to test a prefix of a string is to do:
296 : * strncmp(str, prefix, sizeof(prefix) - 1)
297 : *
298 : * But this can lead to bugs due to typos, or if prefix is a pointer
299 : * and not a constant. Instead use str_has_prefix().
300 : *
301 : * Returns:
302 : * * strlen(@prefix) if @str starts with @prefix
303 : * * 0 if @str does not start with @prefix
304 : */
305 0 : static __always_inline size_t str_has_prefix(const char *str, const char *prefix)
306 : {
307 0 : size_t len = strlen(prefix);
308 0 : return strncmp(str, prefix, len) == 0 ? len : 0;
309 : }
310 :
311 : #endif /* _LINUX_STRING_H_ */
|
