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