ndk_cruft.cpp revision 7fb680bfda059746c9bb8939ffaed600eecc3a29 
1/*
2 * Copyright (C) 2013 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
29// This file perpetuates the mistakes of the past.
30
31#include <ctype.h>
32#include <dirent.h>
33#include <inttypes.h>
34#include <pthread.h>
35#include <signal.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <sys/resource.h>
40#include <sys/syscall.h>
41#include <sys/time.h>
42#include <sys/types.h>
43#include <sys/wait.h>
44#include <unistd.h>
45#include <wchar.h>
46
47#include "private/libc_logging.h"
48
49// The part is only for 32-bit targets.
50#if !defined(__LP64__)
51
52// These were accidentally declared in <unistd.h> because we stupidly used to inline
53// getpagesize() and __getpageshift(). Needed for backwards compatibility with old NDK apps.
54extern "C" {
55  unsigned int __page_size = PAGE_SIZE;
56  unsigned int __page_shift = 12;
57}
58
59// TODO: remove this backward compatibility hack (for jb-mr1 strace binaries).
60extern "C" pid_t __wait4(pid_t pid, int* status, int options, struct rusage* rusage) {
61  return wait4(pid, status, options, rusage);
62}
63
64// TODO: does anything still need this?
65extern "C" int __open() {
66  abort();
67}
68
69// TODO: does anything still need this?
70extern "C" void** __get_tls() {
71#include "private/__get_tls.h"
72  return __get_tls();
73}
74
75// This non-standard function was in our <string.h> for some reason.
76extern "C" void memswap(void* m1, void* m2, size_t n) {
77  char* p = reinterpret_cast<char*>(m1);
78  char* p_end = p + n;
79  char* q = reinterpret_cast<char*>(m2);
80  while (p < p_end) {
81    char tmp = *p;
82    *p = *q;
83    *q = tmp;
84    p++;
85    q++;
86  }
87}
88
89extern "C" int pthread_attr_setstackaddr(pthread_attr_t*, void*) {
90  // This was removed from POSIX.1-2008, and is not implemented on bionic.
91  // Needed for ABI compatibility with the NDK.
92  return ENOSYS;
93}
94
95extern "C" int pthread_attr_getstackaddr(const pthread_attr_t* attr, void** stack_addr) {
96  // This was removed from POSIX.1-2008.
97  // Needed for ABI compatibility with the NDK.
98  *stack_addr = (char*)attr->stack_base + attr->stack_size;
99  return 0;
100}
101
102// Non-standard cruft that should only ever have been in system/core/toolbox.
103extern "C" char* strtotimeval(const char* str, struct timeval* ts) {
104  char* s;
105  ts->tv_sec = strtoumax(str, &s, 10);
106
107  long fractional_seconds = 0;
108  if (*s == '.') {
109    s++;
110    int count = 0;
111
112    // Read up to 6 digits (microseconds).
113    while (*s && isdigit(*s)) {
114      if (++count < 7) {
115        fractional_seconds = fractional_seconds*10 + (*s - '0');
116      }
117      s++;
118    }
119
120    for (; count < 6; count++) {
121      fractional_seconds *= 10;
122    }
123  }
124
125  ts->tv_usec = fractional_seconds;
126  return s;
127}
128
129static inline int digitval(int ch) {
130  unsigned d;
131
132  d = (unsigned)(ch - '0');
133  if (d < 10) return (int)d;
134
135  d = (unsigned)(ch - 'a');
136  if (d < 6) return (int)(d+10);
137
138  d = (unsigned)(ch - 'A');
139  if (d < 6) return (int)(d+10);
140
141  return -1;
142}
143
144// This non-standard function was in our <inttypes.h> for some reason.
145extern "C" uintmax_t strntoumax(const char *nptr, char **endptr, int base, size_t n) {
146  const unsigned char*  p   = (const unsigned char *)nptr;
147  const unsigned char*  end = p + n;
148  int                   minus = 0;
149  uintmax_t             v = 0;
150  int                   d;
151
152  while (p < end && isspace(*p)) {
153    p++;
154  }
155
156  if (p < end) {
157    char c = p[0];
158    if (c == '-' || c == '+') {
159      minus = (c == '-');
160      p++;
161    }
162  }
163
164  if (base == 0) {
165    if (p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
166      p += 2;
167      base = 16;
168    } else if (p+1 < end && p[0] == '0') {
169      p   += 1;
170      base = 8;
171    } else {
172      base = 10;
173    }
174  } else if (base == 16) {
175    if (p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
176      p += 2;
177    }
178  }
179
180  while (p < end && (d = digitval(*p)) >= 0 && d < base) {
181    v = v*base + d;
182    p += 1;
183  }
184
185  if (endptr) {
186    *endptr = (char*) p;
187  }
188
189  return minus ? -v : v;
190}
191
192// This non-standard function was in our <inttypes.h> for some reason.
193extern "C" intmax_t strntoimax(const char* nptr, char** endptr, int base, size_t n) {
194  return (intmax_t) strntoumax(nptr, endptr, base, n);
195}
196
197// POSIX calls this dprintf, but LP32 Android had fdprintf instead.
198extern "C" int fdprintf(int fd, const char* fmt, ...) {
199  va_list ap;
200  va_start(ap, fmt);
201  int rc = vdprintf(fd, fmt, ap);
202  va_end(ap);
203  return rc;
204}
205
206// POSIX calls this vdprintf, but LP32 Android had fdprintf instead.
207extern "C" int vfdprintf(int fd, const char* fmt, va_list ap) {
208  return vdprintf(fd, fmt, ap);
209}
210
211#define __futex_wake __real_futex_wake
212#define __futex_wait __real_futex_wait
213#include "private/bionic_futex.h"
214#undef __futex_wake
215#undef __futex_wait
216
217// This used to be in <sys/atomics.h>.
218extern "C" int __futex_wake(volatile void* ftx, int count) {
219  return __real_futex_wake(ftx, count);
220}
221
222// This used to be in <sys/atomics.h>.
223extern "C" int __futex_wait(volatile void* ftx, int value, const struct timespec* timeout) {
224  return __real_futex_wait(ftx, value, timeout);
225}
226
227// Unity's libmono uses this.
228extern "C" int tkill(pid_t tid, int sig) {
229  return syscall(__NR_tkill, tid, sig);
230}
231
232// This was removed from POSIX 2008.
233extern "C" wchar_t* wcswcs(wchar_t* haystack, wchar_t* needle) {
234  return wcsstr(haystack, needle);
235}
236
237// This was removed from POSIX 2008.
238extern "C" sighandler_t bsd_signal(int signum, sighandler_t handler) {
239  return signal(signum, handler);
240}
241
242#if !defined(__i386__)
243// This was removed from POSIX 2008.
244#undef bcopy
245extern "C" void bcopy(const void* src, void* dst, size_t n) {
246  memcpy(dst, src, n);
247}
248#else
249// x86 has an assembler implementation.
250#endif
251
252// sysv_signal() was never in POSIX.
253extern sighandler_t _signal(int signum, sighandler_t handler, int flags);
254extern "C" sighandler_t sysv_signal(int signum, sighandler_t handler) {
255  return _signal(signum, handler, SA_RESETHAND);
256}
257
258// This is a system call that was never in POSIX. Use readdir(3) instead.
259extern "C" int __getdents64(unsigned int, dirent*, unsigned int);
260extern "C" int getdents(unsigned int fd, dirent* dirp, unsigned int count) {
261  return __getdents64(fd, dirp, count);
262}
263
264// This is a BSDism that we never implemented correctly. Used by Firefox.
265extern "C" int issetugid() {
266  return 0;
267}
268
269// This was removed from POSIX 2004.
270extern "C" pid_t wait3(int* status, int options, struct rusage* rusage) {
271  return wait4(-1, status, options, rusage);
272}
273
274// This was removed from POSIX 2004.
275extern "C" int getdtablesize() {
276  struct rlimit r;
277
278  if (getrlimit(RLIMIT_NOFILE, &r) < 0) {
279    return sysconf(_SC_OPEN_MAX);
280  }
281
282  return r.rlim_cur;
283}
284
285// Only used by ftime, which was removed from POSIX 2008.
286struct timeb {
287  time_t          time;
288  unsigned short  millitm;
289  short           timezone;
290  short           dstflag;
291};
292
293// This was removed from POSIX 2008.
294extern "C" int ftime(struct timeb* tb) {
295  struct timeval  tv;
296  struct timezone tz;
297
298  if (gettimeofday(&tv, &tz) < 0)
299    return -1;
300
301  tb->time    = tv.tv_sec;
302  tb->millitm = (tv.tv_usec + 500) / 1000;
303
304  if (tb->millitm == 1000) {
305    ++tb->time;
306    tb->millitm = 0;
307  }
308
309  tb->timezone = tz.tz_minuteswest;
310  tb->dstflag  = tz.tz_dsttime;
311
312  return 0;
313}
314
315// This was removed from POSIX 2008.
316extern "C" char* index(const char* str, int ch) {
317  return strchr(str, ch);
318}
319
320// This was removed from BSD.
321extern "C" void arc4random_stir(void) {
322  // The current implementation stirs itself as needed.
323}
324
325// This was removed from BSD.
326extern "C" void arc4random_addrandom(unsigned char*, int) {
327  // The current implementation adds randomness as needed.
328}
329
330// Old versions of the NDK did not export malloc_usable_size, but did
331// export dlmalloc_usable_size. We are moving away from dlmalloc in L
332// so make this call malloc_usable_size.
333extern "C" size_t dlmalloc_usable_size(void* ptr) {
334  return malloc_usable_size(ptr);
335}
336
337// In L we added a public pthread_gettid_np, but some apps were using the private API.
338extern "C" pid_t __pthread_gettid(pthread_t t) {
339  return pthread_gettid_np(t);
340}
341
342// Older versions of appportable used dlmalloc directly instead of malloc,
343// so export this compatibility shim that simply calls malloc.
344extern "C" void* dlmalloc(size_t size) {
345  return malloc(size);
346}
347
348#endif // !defined(__LP64__)
349
350// This is never implemented in bionic, only needed for ABI compatibility with the NDK.
351extern "C" char* getusershell() {
352  return NULL;
353}
354
355// This is never implemented in bionic, only needed for ABI compatibility with the NDK.
356extern "C" void setusershell() { }
357
358// This is never implemented in bionic, only needed for ABI compatibility with the NDK.
359extern "C" void endusershell() { }
360