1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28#ifndef _STRING_H_ 29#define _STRING_H_ 30 31#include <sys/cdefs.h> 32#include <stddef.h> 33#include <malloc.h> 34 35__BEGIN_DECLS 36 37extern void* memccpy(void *, const void *, int, size_t); 38extern void* memchr(const void *, int, size_t) __purefunc; 39extern void* memrchr(const void *, int, size_t) __purefunc; 40extern int memcmp(const void *, const void *, size_t) __purefunc; 41extern void* memcpy(void *, const void *, size_t); 42extern void* memmove(void *, const void *, size_t); 43extern void* memset(void *, int, size_t); 44extern void* memmem(const void *, size_t, const void *, size_t) __purefunc; 45extern void memswap(void *, void *, size_t); 46 47extern char* index(const char *, int) __purefunc; 48extern char* rindex(const char *, int) __purefunc; 49extern char* strchr(const char *, int) __purefunc; 50extern char* strrchr(const char *, int) __purefunc; 51 52extern size_t strlen(const char *) __purefunc; 53extern int strcmp(const char *, const char *) __purefunc; 54extern char* strcpy(char *, const char *); 55extern char* strcat(char *, const char *); 56 57extern int strcasecmp(const char *, const char *) __purefunc; 58extern int strncasecmp(const char *, const char *, size_t) __purefunc; 59extern char* strdup(const char *); 60 61extern char* strstr(const char *, const char *) __purefunc; 62extern char* strcasestr(const char *haystack, const char *needle) __purefunc; 63extern char* strtok(char *, const char *); 64extern char* strtok_r(char *, const char *, char**); 65 66extern char* strerror(int); 67extern int strerror_r(int errnum, char *buf, size_t n); 68 69extern size_t strnlen(const char *, size_t) __purefunc; 70extern char* strncat(char *, const char *, size_t); 71extern char* strndup(const char *, size_t); 72extern int strncmp(const char *, const char *, size_t) __purefunc; 73extern char* strncpy(char *, const char *, size_t); 74 75extern size_t strlcat(char *, const char *, size_t); 76extern size_t strlcpy(char *, const char *, size_t); 77 78extern size_t strcspn(const char *, const char *) __purefunc; 79extern char* strpbrk(const char *, const char *) __purefunc; 80extern char* strsep(char **, const char *); 81extern size_t strspn(const char *, const char *); 82 83extern char* strsignal(int sig); 84 85extern int strcoll(const char *, const char *) __purefunc; 86extern size_t strxfrm(char *, const char *, size_t); 87 88#if defined(__BIONIC_FORTIFY_INLINE) 89 90extern void __memcpy_dest_size_error() 91 __attribute__((__error__("memcpy called with size bigger than destination"))); 92extern void __memcpy_src_size_error() 93 __attribute__((__error__("memcpy called with size bigger than source"))); 94extern void __memcpy_overlap_error() 95 __attribute__((__error__("memcpy called with overlapping regions"))); 96 97__BIONIC_FORTIFY_INLINE 98void *memcpy (void *dest, const void *src, size_t copy_amount) { 99 char *d = (char *) dest; 100 const char *s = (const char *) src; 101 size_t s_len = __builtin_object_size(s, 0); 102 size_t d_len = __builtin_object_size(d, 0); 103 104 if (__builtin_constant_p(copy_amount) && (copy_amount > d_len)) { 105 __memcpy_dest_size_error(); 106 } 107 108 if (__builtin_constant_p(copy_amount) && (copy_amount > s_len)) { 109 __memcpy_src_size_error(); 110 } 111 112 if (__builtin_constant_p(d - s) && __builtin_constant_p(copy_amount) 113 && (((size_t)(d - s) < copy_amount) || ((size_t)(s - d) < copy_amount))) { 114 __memcpy_overlap_error(); 115 } 116 117 return __builtin___memcpy_chk(dest, src, copy_amount, d_len); 118} 119 120__BIONIC_FORTIFY_INLINE 121void *memmove (void *dest, const void *src, size_t len) { 122 return __builtin___memmove_chk(dest, src, len, __builtin_object_size (dest, 0)); 123} 124 125__BIONIC_FORTIFY_INLINE 126char *strcpy(char *dest, const char *src) { 127 return __builtin___strcpy_chk(dest, src, __builtin_object_size (dest, 0)); 128} 129 130__BIONIC_FORTIFY_INLINE 131char *strncpy(char *dest, const char *src, size_t n) { 132 return __builtin___strncpy_chk(dest, src, n, __builtin_object_size (dest, 0)); 133} 134 135__BIONIC_FORTIFY_INLINE 136char *strcat(char *dest, const char *src) { 137 return __builtin___strcat_chk(dest, src, __builtin_object_size (dest, 0)); 138} 139 140__BIONIC_FORTIFY_INLINE 141char *strncat(char *dest, const char *src, size_t n) { 142 return __builtin___strncat_chk(dest, src, n, __builtin_object_size (dest, 0)); 143} 144 145__BIONIC_FORTIFY_INLINE 146void *memset (void *s, int c, size_t n) { 147 return __builtin___memset_chk(s, c, n, __builtin_object_size (s, 0)); 148} 149 150extern size_t __strlcpy_real(char *, const char *, size_t) 151 __asm__(__USER_LABEL_PREFIX__ "strlcpy"); 152extern void __strlcpy_error() 153 __attribute__((__error__("strlcpy called with size bigger than buffer"))); 154extern size_t __strlcpy_chk(char *, const char *, size_t, size_t); 155 156__BIONIC_FORTIFY_INLINE 157size_t strlcpy(char *dest, const char *src, size_t size) { 158 size_t bos = __builtin_object_size(dest, 0); 159 160 // Compiler doesn't know destination size. Don't call __strlcpy_chk 161 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { 162 return __strlcpy_real(dest, src, size); 163 } 164 165 // Compiler can prove, at compile time, that the passed in size 166 // is always <= the actual object size. Don't call __strlcpy_chk 167 if (__builtin_constant_p(size) && (size <= bos)) { 168 return __strlcpy_real(dest, src, size); 169 } 170 171 // Compiler can prove, at compile time, that the passed in size 172 // is always > the actual object size. Force a compiler error. 173 if (__builtin_constant_p(size) && (size > bos)) { 174 __strlcpy_error(); 175 } 176 177 return __strlcpy_chk(dest, src, size, bos); 178} 179 180extern size_t __strlcat_real(char *, const char *, size_t) 181 __asm__(__USER_LABEL_PREFIX__ "strlcat"); 182extern void __strlcat_error() 183 __attribute__((__error__("strlcat called with size bigger than buffer"))); 184extern size_t __strlcat_chk(char *, const char *, size_t, size_t); 185 186 187__BIONIC_FORTIFY_INLINE 188size_t strlcat(char *dest, const char *src, size_t size) { 189 size_t bos = __builtin_object_size(dest, 0); 190 191 // Compiler doesn't know destination size. Don't call __strlcat_chk 192 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { 193 return __strlcat_real(dest, src, size); 194 } 195 196 // Compiler can prove, at compile time, that the passed in size 197 // is always <= the actual object size. Don't call __strlcat_chk 198 if (__builtin_constant_p(size) && (size <= bos)) { 199 return __strlcat_real(dest, src, size); 200 } 201 202 // Compiler can prove, at compile time, that the passed in size 203 // is always > the actual object size. Force a compiler error. 204 if (__builtin_constant_p(size) && (size > bos)) { 205 __strlcat_error(); 206 } 207 208 return __strlcat_chk(dest, src, size, bos); 209} 210 211__purefunc extern size_t __strlen_real(const char *) 212 __asm__(__USER_LABEL_PREFIX__ "strlen"); 213extern size_t __strlen_chk(const char *, size_t); 214 215__BIONIC_FORTIFY_INLINE 216size_t strlen(const char *s) { 217 size_t bos = __builtin_object_size(s, 0); 218 219 // Compiler doesn't know destination size. Don't call __strlen_chk 220 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { 221 return __strlen_real(s); 222 } 223 224 return __strlen_chk(s, bos); 225} 226 227#endif /* defined(__BIONIC_FORTIFY_INLINE) */ 228 229__END_DECLS 230 231#endif /* _STRING_H_ */ 232