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
37 extern void* memccpy(void* __restrict, const void* __restrict, int, size_t);
38 extern void* memchr(const void *, int, size_t) __purefunc;
39 extern void* memrchr(const void *, int, size_t) __purefunc;
40 extern int memcmp(const void *, const void *, size_t) __purefunc;
41 extern void* memcpy(void* __restrict, const void* __restrict, size_t);
42 extern void* memmove(void *, const void *, size_t);
43 extern void* memset(void *, int, size_t);
44 extern void* memmem(const void *, size_t, const void *, size_t) __purefunc;
45 extern void memswap(void *, void *, size_t);
46
47 extern char* index(const char *, int) __purefunc;
48 extern char* strchr(const char *, int) __purefunc;
49 extern char* strrchr(const char *, int) __purefunc;
50
51 extern size_t strlen(const char *) __purefunc;
52 extern size_t __strlen_chk(const char *, size_t);
53 extern int strcmp(const char *, const char *) __purefunc;
54 extern char* strcpy(char* __restrict, const char* __restrict);
55 extern char* strcat(char* __restrict, const char* __restrict);
56
57 extern int strcasecmp(const char *, const char *) __purefunc;
58 extern int strncasecmp(const char *, const char *, size_t) __purefunc;
59 extern char* strdup(const char *);
60
61 extern char* strstr(const char *, const char *) __purefunc;
62 extern char* strcasestr(const char *haystack, const char *needle) __purefunc;
63 extern char* strtok(char* __restrict, const char* __restrict);
64 extern char* strtok_r(char* __restrict, const char* __restrict, char** __restrict);
65
66 extern char* strerror(int);
67 extern int strerror_r(int errnum, char *buf, size_t n);
68
69 extern size_t strnlen(const char *, size_t) __purefunc;
70 extern char* strncat(char* __restrict, const char* __restrict, size_t);
71 extern char* strndup(const char *, size_t);
72 extern int strncmp(const char *, const char *, size_t) __purefunc;
73 extern char* strncpy(char* __restrict, const char* __restrict, size_t);
74
75 extern size_t strlcat(char* __restrict, const char* __restrict, size_t);
76 extern size_t strlcpy(char* __restrict, const char* __restrict, size_t);
77
78 extern size_t strcspn(const char *, const char *) __purefunc;
79 extern char* strpbrk(const char *, const char *) __purefunc;
80 extern char* strsep(char** __restrict, const char* __restrict);
81 extern size_t strspn(const char *, const char *);
82
83 extern char* strsignal(int sig);
84
85 extern int strcoll(const char *, const char *) __purefunc;
86 extern size_t strxfrm(char* __restrict, const char* __restrict, size_t);
87
88 #if defined(__BIONIC_FORTIFY)
89
90 __errordecl(__memcpy_dest_size_error, "memcpy called with size bigger than destination");
91 __errordecl(__memcpy_src_size_error, "memcpy called with size bigger than source");
92
93 __BIONIC_FORTIFY_INLINE
memcpy(void * __restrict dest,const void * __restrict src,size_t copy_amount)94 void* memcpy(void* __restrict dest, const void* __restrict src, size_t copy_amount) {
95 char *d = (char *) dest;
96 const char *s = (const char *) src;
97 size_t s_len = __builtin_object_size(s, 0);
98 size_t d_len = __builtin_object_size(d, 0);
99
100 if (__builtin_constant_p(copy_amount) && (copy_amount > d_len)) {
101 __memcpy_dest_size_error();
102 }
103
104 if (__builtin_constant_p(copy_amount) && (copy_amount > s_len)) {
105 __memcpy_src_size_error();
106 }
107
108 return __builtin___memcpy_chk(dest, src, copy_amount, d_len);
109 }
110
111 __BIONIC_FORTIFY_INLINE
memmove(void * dest,const void * src,size_t len)112 void* memmove(void *dest, const void *src, size_t len) {
113 return __builtin___memmove_chk(dest, src, len, __builtin_object_size (dest, 0));
114 }
115
116 __BIONIC_FORTIFY_INLINE
strcpy(char * __restrict dest,const char * __restrict src)117 char* strcpy(char* __restrict dest, const char* __restrict src) {
118 return __builtin___strcpy_chk(dest, src, __bos(dest));
119 }
120
121 __errordecl(__strncpy_error, "strncpy called with size bigger than buffer");
122
123 __BIONIC_FORTIFY_INLINE
strncpy(char * __restrict dest,const char * __restrict src,size_t n)124 char* strncpy(char* __restrict dest, const char* __restrict src, size_t n) {
125 size_t bos = __bos(dest);
126 if (__builtin_constant_p(n) && (n > bos)) {
127 __strncpy_error();
128 }
129 return __builtin___strncpy_chk(dest, src, n, bos);
130 }
131
132 __BIONIC_FORTIFY_INLINE
strcat(char * __restrict dest,const char * __restrict src)133 char* strcat(char* __restrict dest, const char* __restrict src) {
134 return __builtin___strcat_chk(dest, src, __bos(dest));
135 }
136
137 __BIONIC_FORTIFY_INLINE
strncat(char * __restrict dest,const char * __restrict src,size_t n)138 char *strncat(char* __restrict dest, const char* __restrict src, size_t n) {
139 return __builtin___strncat_chk(dest, src, n, __bos(dest));
140 }
141
142 __BIONIC_FORTIFY_INLINE
memset(void * s,int c,size_t n)143 void* memset(void *s, int c, size_t n) {
144 return __builtin___memset_chk(s, c, n, __builtin_object_size (s, 0));
145 }
146
147 extern size_t __strlcpy_real(char* __restrict, const char* __restrict, size_t)
148 __asm__(__USER_LABEL_PREFIX__ "strlcpy");
149 __errordecl(__strlcpy_error, "strlcpy called with size bigger than buffer");
150 extern size_t __strlcpy_chk(char *, const char *, size_t, size_t);
151
152 __BIONIC_FORTIFY_INLINE
strlcpy(char * __restrict dest,const char * __restrict src,size_t size)153 size_t strlcpy(char* __restrict dest, const char* __restrict src, size_t size) {
154 size_t bos = __bos(dest);
155
156 #if !defined(__clang__)
157 // Compiler doesn't know destination size. Don't call __strlcpy_chk
158 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) {
159 return __strlcpy_real(dest, src, size);
160 }
161
162 // Compiler can prove, at compile time, that the passed in size
163 // is always <= the actual object size. Don't call __strlcpy_chk
164 if (__builtin_constant_p(size) && (size <= bos)) {
165 return __strlcpy_real(dest, src, size);
166 }
167
168 // Compiler can prove, at compile time, that the passed in size
169 // is always > the actual object size. Force a compiler error.
170 if (__builtin_constant_p(size) && (size > bos)) {
171 __strlcpy_error();
172 }
173 #endif /* !defined(__clang__) */
174
175 return __strlcpy_chk(dest, src, size, bos);
176 }
177
178 extern size_t __strlcat_real(char* __restrict, const char* __restrict, size_t)
179 __asm__(__USER_LABEL_PREFIX__ "strlcat");
180 __errordecl(__strlcat_error, "strlcat called with size bigger than buffer");
181 extern size_t __strlcat_chk(char* __restrict, const char* __restrict, size_t, size_t);
182
183
184 __BIONIC_FORTIFY_INLINE
strlcat(char * __restrict dest,const char * __restrict src,size_t size)185 size_t strlcat(char* __restrict dest, const char* __restrict src, size_t size) {
186 size_t bos = __bos(dest);
187
188 #if !defined(__clang__)
189 // Compiler doesn't know destination size. Don't call __strlcat_chk
190 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) {
191 return __strlcat_real(dest, src, size);
192 }
193
194 // Compiler can prove, at compile time, that the passed in size
195 // is always <= the actual object size. Don't call __strlcat_chk
196 if (__builtin_constant_p(size) && (size <= bos)) {
197 return __strlcat_real(dest, src, size);
198 }
199
200 // Compiler can prove, at compile time, that the passed in size
201 // is always > the actual object size. Force a compiler error.
202 if (__builtin_constant_p(size) && (size > bos)) {
203 __strlcat_error();
204 }
205 #endif /* !defined(__clang__) */
206
207 return __strlcat_chk(dest, src, size, bos);
208 }
209
210 __BIONIC_FORTIFY_INLINE
strlen(const char * s)211 size_t strlen(const char *s) {
212 size_t bos = __bos(s);
213
214 #if !defined(__clang__)
215 // Compiler doesn't know destination size. Don't call __strlen_chk
216 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) {
217 return __builtin_strlen(s);
218 }
219
220 size_t slen = __builtin_strlen(s);
221 if (__builtin_constant_p(slen)) {
222 return slen;
223 }
224 #endif /* !defined(__clang__) */
225
226 return __strlen_chk(s, bos);
227 }
228
229 extern char* __strchr_chk(const char *, int, size_t);
230
231 __BIONIC_FORTIFY_INLINE
strchr(const char * s,int c)232 char* strchr(const char *s, int c) {
233 size_t bos = __bos(s);
234
235 #if !defined(__clang__)
236 // Compiler doesn't know destination size. Don't call __strchr_chk
237 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) {
238 return __builtin_strchr(s, c);
239 }
240
241 size_t slen = __builtin_strlen(s);
242 if (__builtin_constant_p(slen) && (slen < bos)) {
243 return __builtin_strchr(s, c);
244 }
245 #endif /* !defined(__clang__) */
246
247 return __strchr_chk(s, c, bos);
248 }
249
250 extern char* __strrchr_chk(const char *, int, size_t);
251
252 __BIONIC_FORTIFY_INLINE
strrchr(const char * s,int c)253 char* strrchr(const char *s, int c) {
254 size_t bos = __bos(s);
255
256 #if !defined(__clang__)
257 // Compiler doesn't know destination size. Don't call __strrchr_chk
258 if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) {
259 return __builtin_strrchr(s, c);
260 }
261
262 size_t slen = __builtin_strlen(s);
263 if (__builtin_constant_p(slen) && (slen < bos)) {
264 return __builtin_strrchr(s, c);
265 }
266 #endif /* !defined(__clang__) */
267
268 return __strrchr_chk(s, c, bos);
269 }
270
271
272 #endif /* defined(__BIONIC_FORTIFY) */
273
274 __END_DECLS
275
276 #endif /* _STRING_H_ */
277