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 *, const void *, 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 *, const void *, 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* rindex(const char *, int) __purefunc;
49 extern char* strchr(const char *, int) __purefunc;
50 extern char* strrchr(const char *, int) __purefunc;
51
52 extern size_t strlen(const char *) __purefunc;
53 extern int strcmp(const char *, const char *) __purefunc;
54 extern char* strcpy(char *, const char *);
55 extern char* strcat(char *, const char *);
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 *, const char *);
64 extern char* strtok_r(char *, const char *, char**);
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 *, const char *, 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 *, const char *, size_t);
74
75 extern size_t strlcat(char *, const char *, size_t);
76 extern size_t strlcpy(char *, const char *, 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 **, const char *);
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 *, const char *, size_t);
87
88 #if defined(__BIONIC_FORTIFY_INLINE)
89
90 extern void __memcpy_dest_size_error()
91 __attribute__((__error__("memcpy called with size bigger than destination")));
92 extern void __memcpy_src_size_error()
93 __attribute__((__error__("memcpy called with size bigger than source")));
94 extern void __memcpy_overlap_error()
95 __attribute__((__error__("memcpy called with overlapping regions")));
96
97 __BIONIC_FORTIFY_INLINE
memcpy(void * dest,const void * src,size_t copy_amount)98 void *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
memmove(void * dest,const void * src,size_t len)121 void *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
strcpy(char * dest,const char * src)126 char *strcpy(char *dest, const char *src) {
127 return __builtin___strcpy_chk(dest, src, __builtin_object_size (dest, 0));
128 }
129
130 __BIONIC_FORTIFY_INLINE
strncpy(char * dest,const char * src,size_t n)131 char *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
strcat(char * dest,const char * src)136 char *strcat(char *dest, const char *src) {
137 return __builtin___strcat_chk(dest, src, __builtin_object_size (dest, 0));
138 }
139
140 __BIONIC_FORTIFY_INLINE
strncat(char * dest,const char * src,size_t n)141 char *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
memset(void * s,int c,size_t n)146 void *memset (void *s, int c, size_t n) {
147 return __builtin___memset_chk(s, c, n, __builtin_object_size (s, 0));
148 }
149
150 extern size_t __strlcpy_real(char *, const char *, size_t)
151 __asm__(__USER_LABEL_PREFIX__ "strlcpy");
152 extern void __strlcpy_error()
153 __attribute__((__error__("strlcpy called with size bigger than buffer")));
154 extern size_t __strlcpy_chk(char *, const char *, size_t, size_t);
155
156 __BIONIC_FORTIFY_INLINE
strlcpy(char * dest,const char * src,size_t size)157 size_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
180 extern size_t __strlcat_real(char *, const char *, size_t)
181 __asm__(__USER_LABEL_PREFIX__ "strlcat");
182 extern void __strlcat_error()
183 __attribute__((__error__("strlcat called with size bigger than buffer")));
184 extern size_t __strlcat_chk(char *, const char *, size_t, size_t);
185
186
187 __BIONIC_FORTIFY_INLINE
strlcat(char * dest,const char * src,size_t size)188 size_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");
213 extern size_t __strlen_chk(const char *, size_t);
214
215 __BIONIC_FORTIFY_INLINE
strlen(const char * s)216 size_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