1 #ifndef _LINUX_STRING_H_ 2 #define _LINUX_STRING_H_ 3 4 5 #include <linux/compiler.h> /* for inline */ 6 #include <linux/types.h> /* for size_t */ 7 #include <linux/stddef.h> /* for NULL */ 8 #include <stdarg.h> 9 #include <uapi/linux/string.h> 10 11 extern char *strndup_user(const char __user *, long); 12 extern void *memdup_user(const void __user *, size_t); 13 extern void *memdup_user_nul(const void __user *, size_t); 14 15 /* 16 * Include machine specific inline routines 17 */ 18 #include <asm/string.h> 19 20 #ifndef __HAVE_ARCH_STRCPY 21 extern char * strcpy(char *,const char *); 22 #endif 23 #ifndef __HAVE_ARCH_STRNCPY 24 extern char * strncpy(char *,const char *, __kernel_size_t); 25 #endif 26 #ifndef __HAVE_ARCH_STRLCPY 27 size_t strlcpy(char *, const char *, size_t); 28 #endif 29 #ifndef __HAVE_ARCH_STRSCPY 30 ssize_t __must_check strscpy(char *, const char *, size_t); 31 #endif 32 #ifndef __HAVE_ARCH_STRCAT 33 extern char * strcat(char *, const char *); 34 #endif 35 #ifndef __HAVE_ARCH_STRNCAT 36 extern char * strncat(char *, const char *, __kernel_size_t); 37 #endif 38 #ifndef __HAVE_ARCH_STRLCAT 39 extern size_t strlcat(char *, const char *, __kernel_size_t); 40 #endif 41 #ifndef __HAVE_ARCH_STRCMP 42 extern int strcmp(const char *,const char *); 43 #endif 44 #ifndef __HAVE_ARCH_STRNCMP 45 extern int strncmp(const char *,const char *,__kernel_size_t); 46 #endif 47 #ifndef __HAVE_ARCH_STRCASECMP 48 extern int strcasecmp(const char *s1, const char *s2); 49 #endif 50 #ifndef __HAVE_ARCH_STRNCASECMP 51 extern int strncasecmp(const char *s1, const char *s2, size_t n); 52 #endif 53 #ifndef __HAVE_ARCH_STRCHR 54 extern char * strchr(const char *,int); 55 #endif 56 #ifndef __HAVE_ARCH_STRCHRNUL 57 extern char * strchrnul(const char *,int); 58 #endif 59 #ifndef __HAVE_ARCH_STRNCHR 60 extern char * strnchr(const char *, size_t, int); 61 #endif 62 #ifndef __HAVE_ARCH_STRRCHR 63 extern char * strrchr(const char *,int); 64 #endif 65 extern char * __must_check skip_spaces(const char *); 66 67 extern char *strim(char *); 68 69 static inline __must_check char *strstrip(char *str) 70 { 71 return strim(str); 72 } 73 74 #ifndef __HAVE_ARCH_STRSTR 75 extern char * strstr(const char *, const char *); 76 #endif 77 #ifndef __HAVE_ARCH_STRNSTR 78 extern char * strnstr(const char *, const char *, size_t); 79 #endif 80 #ifndef __HAVE_ARCH_STRLEN 81 extern __kernel_size_t strlen(const char *); 82 #endif 83 #ifndef __HAVE_ARCH_STRNLEN 84 extern __kernel_size_t strnlen(const char *,__kernel_size_t); 85 #endif 86 #ifndef __HAVE_ARCH_STRPBRK 87 extern char * strpbrk(const char *,const char *); 88 #endif 89 #ifndef __HAVE_ARCH_STRSEP 90 extern char * strsep(char **,const char *); 91 #endif 92 #ifndef __HAVE_ARCH_STRSPN 93 extern __kernel_size_t strspn(const char *,const char *); 94 #endif 95 #ifndef __HAVE_ARCH_STRCSPN 96 extern __kernel_size_t strcspn(const char *,const char *); 97 #endif 98 99 #ifndef __HAVE_ARCH_MEMSET 100 extern void * memset(void *,int,__kernel_size_t); 101 #endif 102 103 #ifndef __HAVE_ARCH_MEMSET16 104 extern void *memset16(uint16_t *, uint16_t, __kernel_size_t); 105 #endif 106 107 #ifndef __HAVE_ARCH_MEMSET32 108 extern void *memset32(uint32_t *, uint32_t, __kernel_size_t); 109 #endif 110 111 #ifndef __HAVE_ARCH_MEMSET64 112 extern void *memset64(uint64_t *, uint64_t, __kernel_size_t); 113 #endif 114 115 static inline void *memset_l(unsigned long *p, unsigned long v, 116 __kernel_size_t n) 117 { 118 if (BITS_PER_LONG == 32) 119 return memset32((uint32_t *)p, v, n); 120 else 121 return memset64((uint64_t *)p, v, n); 122 } 123 124 static inline void *memset_p(void **p, void *v, __kernel_size_t n) 125 { 126 if (BITS_PER_LONG == 32) 127 return memset32((uint32_t *)p, (uintptr_t)v, n); 128 else 129 return memset64((uint64_t *)p, (uintptr_t)v, n); 130 } 131 132 #ifndef __HAVE_ARCH_MEMCPY 133 extern void * memcpy(void *,const void *,__kernel_size_t); 134 #endif 135 #ifndef __HAVE_ARCH_MEMMOVE 136 extern void * memmove(void *,const void *,__kernel_size_t); 137 #endif 138 #ifndef __HAVE_ARCH_MEMSCAN 139 extern void * memscan(void *,int,__kernel_size_t); 140 #endif 141 #ifndef __HAVE_ARCH_MEMCMP 142 extern int memcmp(const void *,const void *,__kernel_size_t); 143 #endif 144 #ifndef __HAVE_ARCH_MEMCHR 145 extern void * memchr(const void *,int,__kernel_size_t); 146 #endif 147 #ifndef __HAVE_ARCH_MEMCPY_MCSAFE 148 static inline __must_check int memcpy_mcsafe(void *dst, const void *src, 149 size_t cnt) 150 { 151 memcpy(dst, src, cnt); 152 return 0; 153 } 154 #endif 155 #ifndef __HAVE_ARCH_MEMCPY_FLUSHCACHE 156 static inline void memcpy_flushcache(void *dst, const void *src, size_t cnt) 157 { 158 memcpy(dst, src, cnt); 159 } 160 #endif 161 void *memchr_inv(const void *s, int c, size_t n); 162 char *strreplace(char *s, char old, char new); 163 164 extern void kfree_const(const void *x); 165 166 extern char *kstrdup(const char *s, gfp_t gfp) __malloc; 167 extern const char *kstrdup_const(const char *s, gfp_t gfp); 168 extern char *kstrndup(const char *s, size_t len, gfp_t gfp); 169 extern void *kmemdup(const void *src, size_t len, gfp_t gfp); 170 extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp); 171 172 extern char **argv_split(gfp_t gfp, const char *str, int *argcp); 173 extern void argv_free(char **argv); 174 175 extern bool sysfs_streq(const char *s1, const char *s2); 176 extern int kstrtobool(const char *s, bool *res); 177 static inline int strtobool(const char *s, bool *res) 178 { 179 return kstrtobool(s, res); 180 } 181 182 int match_string(const char * const *array, size_t n, const char *string); 183 int __sysfs_match_string(const char * const *array, size_t n, const char *s); 184 185 /** 186 * sysfs_match_string - matches given string in an array 187 * @_a: array of strings 188 * @_s: string to match with 189 * 190 * Helper for __sysfs_match_string(). Calculates the size of @a automatically. 191 */ 192 #define sysfs_match_string(_a, _s) __sysfs_match_string(_a, ARRAY_SIZE(_a), _s) 193 194 #ifdef CONFIG_BINARY_PRINTF 195 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args); 196 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf); 197 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4); 198 #endif 199 200 extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, 201 const void *from, size_t available); 202 203 /** 204 * strstarts - does @str start with @prefix? 205 * @str: string to examine 206 * @prefix: prefix to look for. 207 */ 208 static inline bool strstarts(const char *str, const char *prefix) 209 { 210 return strncmp(str, prefix, strlen(prefix)) == 0; 211 } 212 213 size_t memweight(const void *ptr, size_t bytes); 214 void memzero_explicit(void *s, size_t count); 215 216 /** 217 * kbasename - return the last part of a pathname. 218 * 219 * @path: path to extract the filename from. 220 */ 221 static inline const char *kbasename(const char *path) 222 { 223 const char *tail = strrchr(path, '/'); 224 return tail ? tail + 1 : path; 225 } 226 227 #define __FORTIFY_INLINE extern __always_inline __attribute__((gnu_inline)) 228 #define __RENAME(x) __asm__(#x) 229 230 void fortify_panic(const char *name) __noreturn __cold; 231 void __read_overflow(void) __compiletime_error("detected read beyond size of object passed as 1st parameter"); 232 void __read_overflow2(void) __compiletime_error("detected read beyond size of object passed as 2nd parameter"); 233 void __read_overflow3(void) __compiletime_error("detected read beyond size of object passed as 3rd parameter"); 234 void __write_overflow(void) __compiletime_error("detected write beyond size of object passed as 1st parameter"); 235 236 #if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE) 237 __FORTIFY_INLINE char *strncpy(char *p, const char *q, __kernel_size_t size) 238 { 239 size_t p_size = __builtin_object_size(p, 0); 240 if (__builtin_constant_p(size) && p_size < size) 241 __write_overflow(); 242 if (p_size < size) 243 fortify_panic(__func__); 244 return __builtin_strncpy(p, q, size); 245 } 246 247 __FORTIFY_INLINE char *strcat(char *p, const char *q) 248 { 249 size_t p_size = __builtin_object_size(p, 0); 250 if (p_size == (size_t)-1) 251 return __builtin_strcat(p, q); 252 if (strlcat(p, q, p_size) >= p_size) 253 fortify_panic(__func__); 254 return p; 255 } 256 257 __FORTIFY_INLINE __kernel_size_t strlen(const char *p) 258 { 259 __kernel_size_t ret; 260 size_t p_size = __builtin_object_size(p, 0); 261 if (p_size == (size_t)-1) 262 return __builtin_strlen(p); 263 ret = strnlen(p, p_size); 264 if (p_size <= ret) 265 fortify_panic(__func__); 266 return ret; 267 } 268 269 extern __kernel_size_t __real_strnlen(const char *, __kernel_size_t) __RENAME(strnlen); 270 __FORTIFY_INLINE __kernel_size_t strnlen(const char *p, __kernel_size_t maxlen) 271 { 272 size_t p_size = __builtin_object_size(p, 0); 273 __kernel_size_t ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size); 274 if (p_size <= ret && maxlen != ret) 275 fortify_panic(__func__); 276 return ret; 277 } 278 279 /* defined after fortified strlen to reuse it */ 280 extern size_t __real_strlcpy(char *, const char *, size_t) __RENAME(strlcpy); 281 __FORTIFY_INLINE size_t strlcpy(char *p, const char *q, size_t size) 282 { 283 size_t ret; 284 size_t p_size = __builtin_object_size(p, 0); 285 size_t q_size = __builtin_object_size(q, 0); 286 if (p_size == (size_t)-1 && q_size == (size_t)-1) 287 return __real_strlcpy(p, q, size); 288 ret = strlen(q); 289 if (size) { 290 size_t len = (ret >= size) ? size - 1 : ret; 291 if (__builtin_constant_p(len) && len >= p_size) 292 __write_overflow(); 293 if (len >= p_size) 294 fortify_panic(__func__); 295 __builtin_memcpy(p, q, len); 296 p[len] = '\0'; 297 } 298 return ret; 299 } 300 301 /* defined after fortified strlen and strnlen to reuse them */ 302 __FORTIFY_INLINE char *strncat(char *p, const char *q, __kernel_size_t count) 303 { 304 size_t p_len, copy_len; 305 size_t p_size = __builtin_object_size(p, 0); 306 size_t q_size = __builtin_object_size(q, 0); 307 if (p_size == (size_t)-1 && q_size == (size_t)-1) 308 return __builtin_strncat(p, q, count); 309 p_len = strlen(p); 310 copy_len = strnlen(q, count); 311 if (p_size < p_len + copy_len + 1) 312 fortify_panic(__func__); 313 __builtin_memcpy(p + p_len, q, copy_len); 314 p[p_len + copy_len] = '\0'; 315 return p; 316 } 317 318 __FORTIFY_INLINE void *memset(void *p, int c, __kernel_size_t size) 319 { 320 size_t p_size = __builtin_object_size(p, 0); 321 if (__builtin_constant_p(size) && p_size < size) 322 __write_overflow(); 323 if (p_size < size) 324 fortify_panic(__func__); 325 return __builtin_memset(p, c, size); 326 } 327 328 __FORTIFY_INLINE void *memcpy(void *p, const void *q, __kernel_size_t size) 329 { 330 size_t p_size = __builtin_object_size(p, 0); 331 size_t q_size = __builtin_object_size(q, 0); 332 if (__builtin_constant_p(size)) { 333 if (p_size < size) 334 __write_overflow(); 335 if (q_size < size) 336 __read_overflow2(); 337 } 338 if (p_size < size || q_size < size) 339 fortify_panic(__func__); 340 return __builtin_memcpy(p, q, size); 341 } 342 343 __FORTIFY_INLINE void *memmove(void *p, const void *q, __kernel_size_t size) 344 { 345 size_t p_size = __builtin_object_size(p, 0); 346 size_t q_size = __builtin_object_size(q, 0); 347 if (__builtin_constant_p(size)) { 348 if (p_size < size) 349 __write_overflow(); 350 if (q_size < size) 351 __read_overflow2(); 352 } 353 if (p_size < size || q_size < size) 354 fortify_panic(__func__); 355 return __builtin_memmove(p, q, size); 356 } 357 358 extern void *__real_memscan(void *, int, __kernel_size_t) __RENAME(memscan); 359 __FORTIFY_INLINE void *memscan(void *p, int c, __kernel_size_t size) 360 { 361 size_t p_size = __builtin_object_size(p, 0); 362 if (__builtin_constant_p(size) && p_size < size) 363 __read_overflow(); 364 if (p_size < size) 365 fortify_panic(__func__); 366 return __real_memscan(p, c, size); 367 } 368 369 __FORTIFY_INLINE int memcmp(const void *p, const void *q, __kernel_size_t size) 370 { 371 size_t p_size = __builtin_object_size(p, 0); 372 size_t q_size = __builtin_object_size(q, 0); 373 if (__builtin_constant_p(size)) { 374 if (p_size < size) 375 __read_overflow(); 376 if (q_size < size) 377 __read_overflow2(); 378 } 379 if (p_size < size || q_size < size) 380 fortify_panic(__func__); 381 return __builtin_memcmp(p, q, size); 382 } 383 384 __FORTIFY_INLINE void *memchr(const void *p, int c, __kernel_size_t size) 385 { 386 size_t p_size = __builtin_object_size(p, 0); 387 if (__builtin_constant_p(size) && p_size < size) 388 __read_overflow(); 389 if (p_size < size) 390 fortify_panic(__func__); 391 return __builtin_memchr(p, c, size); 392 } 393 394 void *__real_memchr_inv(const void *s, int c, size_t n) __RENAME(memchr_inv); 395 __FORTIFY_INLINE void *memchr_inv(const void *p, int c, size_t size) 396 { 397 size_t p_size = __builtin_object_size(p, 0); 398 if (__builtin_constant_p(size) && p_size < size) 399 __read_overflow(); 400 if (p_size < size) 401 fortify_panic(__func__); 402 return __real_memchr_inv(p, c, size); 403 } 404 405 extern void *__real_kmemdup(const void *src, size_t len, gfp_t gfp) __RENAME(kmemdup); 406 __FORTIFY_INLINE void *kmemdup(const void *p, size_t size, gfp_t gfp) 407 { 408 size_t p_size = __builtin_object_size(p, 0); 409 if (__builtin_constant_p(size) && p_size < size) 410 __read_overflow(); 411 if (p_size < size) 412 fortify_panic(__func__); 413 return __real_kmemdup(p, size, gfp); 414 } 415 416 /* defined after fortified strlen and memcpy to reuse them */ 417 __FORTIFY_INLINE char *strcpy(char *p, const char *q) 418 { 419 size_t p_size = __builtin_object_size(p, 0); 420 size_t q_size = __builtin_object_size(q, 0); 421 if (p_size == (size_t)-1 && q_size == (size_t)-1) 422 return __builtin_strcpy(p, q); 423 memcpy(p, q, strlen(q) + 1); 424 return p; 425 } 426 427 #endif 428 429 /** 430 * memcpy_and_pad - Copy one buffer to another with padding 431 * @dest: Where to copy to 432 * @dest_len: The destination buffer size 433 * @src: Where to copy from 434 * @count: The number of bytes to copy 435 * @pad: Character to use for padding if space is left in destination. 436 */ 437 static inline void memcpy_and_pad(void *dest, size_t dest_len, 438 const void *src, size_t count, int pad) 439 { 440 if (dest_len > count) { 441 memcpy(dest, src, count); 442 memset(dest + count, pad, dest_len - count); 443 } else 444 memcpy(dest, src, dest_len); 445 } 446 447 #endif /* _LINUX_STRING_H_ */ 448