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