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