hybris/common/hooks.c

   1 /*
   2  * Copyright (c) 2012 Carsten Munk <carsten.munk@gmail.com>
   3  * Copyright (c) 2012 Canonical Ltd
   4  * Copyright (c) 2013 Christophe Chapuis <chris.chapuis@gmail.com>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <hybris/internal/floating_point_abi.h>
  21
  22 #include "hooks_shm.h"
  23
  24 #define _GNU_SOURCE
  25 #include <stdio.h>
  26 #include <stdarg.h>
  27 #include <stdio_ext.h>
  28 #include <stddef.h>
  29 #include <stdlib.h>
  30 #include <malloc.h>
  31 #include <string.h>
  32 #include <strings.h>
  33 #include <dlfcn.h>
  34 #include <pthread.h>
  35 #include <signal.h>
  36 #include <errno.h>
  37 #include <dirent.h>
  38 #include <sys/types.h>
  39 #include <sys/xattr.h>
  40 #include <grp.h>
  41
  42 #include <sys/ipc.h>
  43 #include <sys/shm.h>
  44
  45 #include <netdb.h>
  46 #include <unistd.h>
  47 #include <syslog.h>
  48 #include <locale.h>
  49
  50 #include <hybris/properties/properties.h>
  51
  52 static locale_t hybris_locale;
  53 static int locale_inited = 0;
  54 /* TODO:
  55 *  - Check if the int arguments at attr_set/get match the ones at Android
  56 *  - Check how to deal with memory leaks (specially with static initializers)
  57 *  - Check for shared rwlock
  58 */
  59
  60 /* Base address to check for Android specifics */
  61 #define ANDROID_TOP_ADDR_VALUE_MUTEX  0xFFFF
  62 #define ANDROID_TOP_ADDR_VALUE_COND   0xFFFF
  63 #define ANDROID_TOP_ADDR_VALUE_RWLOCK 0xFFFF
  64
  65 #define ANDROID_MUTEX_SHARED_MASK      0x2000
  66 #define ANDROID_COND_SHARED_MASK       0x0001
  67 #define ANDROID_RWLOCKATTR_SHARED_MASK 0x0010
  68
  69 /* For the static initializer types */
  70 #define ANDROID_PTHREAD_MUTEX_INITIALIZER            0
  71 #define ANDROID_PTHREAD_RECURSIVE_MUTEX_INITIALIZER  0x4000
  72 #define ANDROID_PTHREAD_ERRORCHECK_MUTEX_INITIALIZER 0x8000
  73 #define ANDROID_PTHREAD_COND_INITIALIZER             0
  74 #define ANDROID_PTHREAD_RWLOCK_INITIALIZER           0
  75
  76 /* Debug */
  77 #include "logging.h"
  78 #define LOGD(message, ...) HYBRIS_DEBUG_LOG(HOOKS, message, ##__VA_ARGS__)
  79
  80 /* we have a value p:
  81  *  - if p <= ANDROID_TOP_ADDR_VALUE_MUTEX then it is an android mutex, not one we processed
  82  *  - if p > VMALLOC_END, then the pointer is not a result of malloc ==> it is an shm offset
  83  */
  84
  85 struct _hook {
  86     const char *name;
  87     void *func;
  88 };
  89
  90 /* Helpers */
  91 static int hybris_check_android_shared_mutex(unsigned int mutex_addr)
  92 {
  93     /* If not initialized or initialized by Android, it should contain a low
  94      * address, which is basically just the int values for Android's own
  95      * pthread_mutex_t */
  96     if ((mutex_addr <= ANDROID_TOP_ADDR_VALUE_MUTEX) &&
  97                     (mutex_addr & ANDROID_MUTEX_SHARED_MASK))
  98         return 1;
  99
 100     return 0;
 101 }
 102
 103 static int hybris_check_android_shared_cond(unsigned int cond_addr)
 104 {
 105     /* If not initialized or initialized by Android, it should contain a low
 106      * address, which is basically just the int values for Android's own
 107      * pthread_cond_t */
 108     if ((cond_addr <= ANDROID_TOP_ADDR_VALUE_COND) &&
 109                     (cond_addr & ANDROID_COND_SHARED_MASK))
 110         return 1;
 111
 112     return 0;
 113 }
 114
 115 static void hybris_set_mutex_attr(unsigned int android_value, pthread_mutexattr_t *attr)
 116 {
 117     /* Init already sets as PTHREAD_MUTEX_NORMAL */
 118     pthread_mutexattr_init(attr);
 119
 120     if (android_value & ANDROID_PTHREAD_RECURSIVE_MUTEX_INITIALIZER) {
 121         pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
 122     } else if (android_value & ANDROID_PTHREAD_ERRORCHECK_MUTEX_INITIALIZER) {
 123         pthread_mutexattr_settype(attr, PTHREAD_MUTEX_ERRORCHECK);
 124     }
 125 }
 126
 127 static pthread_mutex_t* hybris_alloc_init_mutex(unsigned int android_mutex)
 128 {
 129     pthread_mutex_t *realmutex = malloc(sizeof(pthread_mutex_t));
 130     pthread_mutexattr_t attr;
 131     hybris_set_mutex_attr(android_mutex, &attr);
 132     pthread_mutex_init(realmutex, &attr);
 133     return realmutex;
 134 }
 135
 136 static pthread_cond_t* hybris_alloc_init_cond(void)
 137 {
 138     pthread_cond_t *realcond = malloc(sizeof(pthread_cond_t));
 139     pthread_condattr_t attr;
 140     pthread_condattr_init(&attr);
 141     pthread_cond_init(realcond, &attr);
 142     return realcond;
 143 }
 144
 145 static pthread_rwlock_t* hybris_alloc_init_rwlock(void)
 146 {
 147     pthread_rwlock_t *realrwlock = malloc(sizeof(pthread_rwlock_t));
 148     pthread_rwlockattr_t attr;
 149     pthread_rwlockattr_init(&attr);
 150     pthread_rwlock_init(realrwlock, &attr);
 151     return realrwlock;
 152 }
 153
 154 /*
 155  * utils, such as malloc, memcpy
 156  *
 157  * Useful to handle hacks such as the one applied for Nvidia, and to
 158  * avoid crashes.
 159  *
 160  * */
 161
 162 static void *my_malloc(size_t size)
 163 {
 164     return malloc(size);
 165 }
 166
 167 static void *my_memcpy(void *dst, const void *src, size_t len)
 168 {
 169     if (src == NULL || dst == NULL)
 170         return NULL;
 171
 172     return memcpy(dst, src, len);
 173 }
 174
 175 static size_t my_strlen(const char *s)
 176 {
 177
 178     if (s == NULL)
 179         return -1;
 180
 181     return strlen(s);
 182 }
 183
 184 /*
 185  * Main pthread functions
 186  *
 187  * Custom implementations to workaround difference between Bionic and Glibc.
 188  * Our own pthread_create helps avoiding direct handling of TLS.
 189  *
 190  * */
 191
 192 static int my_pthread_create(pthread_t *thread, const pthread_attr_t *__attr,
 193                              void *(*start_routine)(void*), void *arg)
 194 {
 195     pthread_attr_t *realattr = NULL;
 196
 197     if (__attr != NULL)
 198         realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 199
 200     return pthread_create(thread, realattr, start_routine, arg);
 201 }
 202
 203 /*
 204  * pthread_attr_* functions
 205  *
 206  * Specific implementations to workaround the differences between at the
 207  * pthread_attr_t struct differences between Bionic and Glibc.
 208  *
 209  * */
 210
 211 static int my_pthread_attr_init(pthread_attr_t *__attr)
 212 {
 213     pthread_attr_t *realattr;
 214
 215     realattr = malloc(sizeof(pthread_attr_t));
 216     *((unsigned int *)__attr) = (unsigned int) realattr;
 217
 218     return pthread_attr_init(realattr);
 219 }
 220
 221 static int my_pthread_attr_destroy(pthread_attr_t *__attr)
 222 {
 223     int ret;
 224     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 225
 226     ret = pthread_attr_destroy(realattr);
 227     /* We need to release the memory allocated at my_pthread_attr_init
 228      * Possible side effects if destroy is called without our init */
 229     free(realattr);
 230
 231     return ret;
 232 }
 233
 234 static int my_pthread_attr_setdetachstate(pthread_attr_t *__attr, int state)
 235 {
 236     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 237     return pthread_attr_setdetachstate(realattr, state);
 238 }
 239
 240 static int my_pthread_attr_getdetachstate(pthread_attr_t const *__attr, int *state)
 241 {
 242     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 243     return pthread_attr_getdetachstate(realattr, state);
 244 }
 245
 246 static int my_pthread_attr_setschedpolicy(pthread_attr_t *__attr, int policy)
 247 {
 248     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 249     return pthread_attr_setschedpolicy(realattr, policy);
 250 }
 251
 252 static int my_pthread_attr_getschedpolicy(pthread_attr_t const *__attr, int *policy)
 253 {
 254     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 255     return pthread_attr_getschedpolicy(realattr, policy);
 256 }
 257
 258 static int my_pthread_attr_setschedparam(pthread_attr_t *__attr, struct sched_param const *param)
 259 {
 260     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 261     return pthread_attr_setschedparam(realattr, param);
 262 }
 263
 264 static int my_pthread_attr_getschedparam(pthread_attr_t const *__attr, struct sched_param *param)
 265 {
 266     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 267     return pthread_attr_getschedparam(realattr, param);
 268 }
 269
 270 static int my_pthread_attr_setstacksize(pthread_attr_t *__attr, size_t stack_size)
 271 {
 272     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 273     return pthread_attr_setstacksize(realattr, stack_size);
 274 }
 275
 276 static int my_pthread_attr_getstacksize(pthread_attr_t const *__attr, size_t *stack_size)
 277 {
 278     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 279     return pthread_attr_getstacksize(realattr, stack_size);
 280 }
 281
 282 static int my_pthread_attr_setstackaddr(pthread_attr_t *__attr, void *stack_addr)
 283 {
 284     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 285     return pthread_attr_setstackaddr(realattr, stack_addr);
 286 }
 287
 288 static int my_pthread_attr_getstackaddr(pthread_attr_t const *__attr, void **stack_addr)
 289 {
 290     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 291     return pthread_attr_getstackaddr(realattr, stack_addr);
 292 }
 293
 294 static int my_pthread_attr_setstack(pthread_attr_t *__attr, void *stack_base, size_t stack_size)
 295 {
 296     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 297     return pthread_attr_setstack(realattr, stack_base, stack_size);
 298 }
 299
 300 static int my_pthread_attr_getstack(pthread_attr_t const *__attr, void **stack_base, size_t *stack_size)
 301 {
 302     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 303     return pthread_attr_getstack(realattr, stack_base, stack_size);
 304 }
 305
 306 static int my_pthread_attr_setguardsize(pthread_attr_t *__attr, size_t guard_size)
 307 {
 308     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 309     return pthread_attr_setguardsize(realattr, guard_size);
 310 }
 311
 312 static int my_pthread_attr_getguardsize(pthread_attr_t const *__attr, size_t *guard_size)
 313 {
 314     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 315     return pthread_attr_getguardsize(realattr, guard_size);
 316 }
 317
 318 static int my_pthread_attr_setscope(pthread_attr_t *__attr, int scope)
 319 {
 320     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 321     return pthread_attr_setscope(realattr, scope);
 322 }
 323
 324 static int my_pthread_attr_getscope(pthread_attr_t const *__attr)
 325 {
 326     int scope;
 327     pthread_attr_t *realattr = (pthread_attr_t *) *(unsigned int *) __attr;
 328
 329     /* Android doesn't have the scope attribute because it always
 330      * returns PTHREAD_SCOPE_SYSTEM */
 331     pthread_attr_getscope(realattr, &scope);
 332
 333     return scope;
 334 }
 335
 336 static int my_pthread_getattr_np(pthread_t thid, pthread_attr_t *__attr)
 337 {
 338     pthread_attr_t *realattr;
 339
 340     realattr = malloc(sizeof(pthread_attr_t));
 341     *((unsigned int *)__attr) = (unsigned int) realattr;
 342
 343     return pthread_getattr_np(thid, realattr);
 344 }
 345
 346 /*
 347  * pthread_mutex* functions
 348  *
 349  * Specific implementations to workaround the differences between at the
 350  * pthread_mutex_t struct differences between Bionic and Glibc.
 351  *
 352  * */
 353
 354 static int my_pthread_mutex_init(pthread_mutex_t *__mutex,
 355                           __const pthread_mutexattr_t *__mutexattr)
 356 {
 357     pthread_mutex_t *realmutex = NULL;
 358
 359     int pshared = 0;
 360     if (__mutexattr)
 361         pthread_mutexattr_getpshared(__mutexattr, &pshared);
 362
 363     if (!pshared) {
 364         /* non shared, standard mutex: use malloc */
 365         realmutex = malloc(sizeof(pthread_mutex_t));
 366
 367         *((unsigned int *)__mutex) = (unsigned int) realmutex;
 368     }
 369     else {
 370         /* process-shared mutex: use the shared memory segment */
 371         hybris_shm_pointer_t handle = hybris_shm_alloc(sizeof(pthread_mutex_t));
 372
 373         *((hybris_shm_pointer_t *)__mutex) = handle;
 374
 375         if (handle)
 376             realmutex = (pthread_mutex_t *)hybris_get_shmpointer(handle);
 377     }
 378
 379     return pthread_mutex_init(realmutex, __mutexattr);
 380 }
 381
 382 static int my_pthread_mutex_destroy(pthread_mutex_t *__mutex)
 383 {
 384     int ret;
 385
 386     if (!__mutex)
 387         return EINVAL;
 388
 389     pthread_mutex_t *realmutex = (pthread_mutex_t *) *(unsigned int *) __mutex;
 390
 391     if (!realmutex)
 392         return EINVAL;
 393
 394     if (!hybris_is_pointer_in_shm((void*)realmutex)) {
 395         ret = pthread_mutex_destroy(realmutex);
 396         free(realmutex);
 397     }
 398     else {
 399         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)realmutex);
 400         ret = pthread_mutex_destroy(realmutex);
 401     }
 402
 403     *((unsigned int *)__mutex) = 0;
 404
 405     return ret;
 406 }
 407
 408 static int my_pthread_mutex_lock(pthread_mutex_t *__mutex)
 409 {
 410     if (!__mutex) {
 411         LOGD("Null mutex lock, not locking.");
 412         return 0;
 413     }
 414
 415     unsigned int value = (*(unsigned int *) __mutex);
 416     if (hybris_check_android_shared_mutex(value)) {
 417         LOGD("Shared mutex with Android, not locking.");
 418         return 0;
 419     }
 420
 421     pthread_mutex_t *realmutex = (pthread_mutex_t *) value;
 422     if (hybris_is_pointer_in_shm((void*)value))
 423         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 424
 425     if (value <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 426         realmutex = hybris_alloc_init_mutex(value);
 427         *((unsigned int *)__mutex) = (unsigned int) realmutex;
 428     }
 429
 430     return pthread_mutex_lock(realmutex);
 431 }
 432
 433 static int my_pthread_mutex_trylock(pthread_mutex_t *__mutex)
 434 {
 435     unsigned int value = (*(unsigned int *) __mutex);
 436
 437     if (hybris_check_android_shared_mutex(value)) {
 438         LOGD("Shared mutex with Android, not try locking.");
 439         return 0;
 440     }
 441
 442     pthread_mutex_t *realmutex = (pthread_mutex_t *) value;
 443     if (hybris_is_pointer_in_shm((void*)value))
 444         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 445
 446     if (value <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 447         realmutex = hybris_alloc_init_mutex(value);
 448         *((unsigned int *)__mutex) = (unsigned int) realmutex;
 449     }
 450
 451     return pthread_mutex_trylock(realmutex);
 452 }
 453
 454 static int my_pthread_mutex_unlock(pthread_mutex_t *__mutex)
 455 {
 456     if (!__mutex) {
 457         LOGD("Null mutex lock, not unlocking.");
 458         return 0;
 459     }
 460
 461     unsigned int value = (*(unsigned int *) __mutex);
 462     if (hybris_check_android_shared_mutex(value)) {
 463         LOGD("Shared mutex with Android, not unlocking.");
 464         return 0;
 465     }
 466
 467     if (value <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 468         LOGD("Trying to unlock a lock that's not locked/initialized"
 469                " by Hybris, not unlocking.");
 470         return 0;
 471     }
 472
 473     pthread_mutex_t *realmutex = (pthread_mutex_t *) value;
 474     if (hybris_is_pointer_in_shm((void*)value))
 475         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 476
 477     return pthread_mutex_unlock(realmutex);
 478 }
 479
 480 static int my_pthread_mutex_lock_timeout_np(pthread_mutex_t *__mutex, unsigned __msecs)
 481 {
 482     struct timespec tv;
 483     pthread_mutex_t *realmutex;
 484     unsigned int value = (*(unsigned int *) __mutex);
 485
 486     if (hybris_check_android_shared_mutex(value)) {
 487         LOGD("Shared mutex with Android, not lock timeout np.");
 488         return 0;
 489     }
 490
 491     realmutex = (pthread_mutex_t *) value;
 492
 493     if (value <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 494         realmutex = hybris_alloc_init_mutex(value);
 495         *((int *)__mutex) = (int) realmutex;
 496     }
 497
 498     /* TODO: Android uses CLOCK_MONOTONIC here but I am not sure which one to use */
 499     clock_gettime(CLOCK_REALTIME, &tv);
 500     tv.tv_sec += __msecs/1000;
 501     tv.tv_nsec += (__msecs % 1000) * 1000000;
 502     if (tv.tv_nsec >= 1000000000) {
 503       tv.tv_sec++;
 504       tv.tv_nsec -= 1000000000;
 505     }
 506
 507     return pthread_mutex_timedlock(realmutex, &tv);
 508 }
 509
 510 static int my_pthread_mutexattr_setpshared(pthread_mutexattr_t *__attr,
 511                                            int pshared)
 512 {
 513     return pthread_mutexattr_setpshared(__attr, pshared);
 514 }
 515
 516 /*
 517  * pthread_cond* functions
 518  *
 519  * Specific implementations to workaround the differences between at the
 520  * pthread_cond_t struct differences between Bionic and Glibc.
 521  *
 522  * */
 523
 524 static int my_pthread_cond_init(pthread_cond_t *cond,
 525                                 const pthread_condattr_t *attr)
 526 {
 527     pthread_cond_t *realcond = NULL;
 528
 529     int pshared = 0;
 530
 531     if (attr)
 532         pthread_condattr_getpshared(attr, &pshared);
 533
 534     if (!pshared) {
 535         /* non shared, standard cond: use malloc */
 536         realcond = malloc(sizeof(pthread_cond_t));
 537
 538         *((unsigned int *) cond) = (unsigned int) realcond;
 539     }
 540     else {
 541         /* process-shared condition: use the shared memory segment */
 542         hybris_shm_pointer_t handle = hybris_shm_alloc(sizeof(pthread_cond_t));
 543
 544         *((unsigned int *)cond) = (unsigned int) handle;
 545
 546         if (handle)
 547             realcond = (pthread_cond_t *)hybris_get_shmpointer(handle);
 548     }
 549
 550     return pthread_cond_init(realcond, attr);
 551 }
 552
 553 static int my_pthread_cond_destroy(pthread_cond_t *cond)
 554 {
 555     int ret;
 556     pthread_cond_t *realcond = (pthread_cond_t *) *(unsigned int *) cond;
 557
 558     if (!realcond) {
 559       return EINVAL;
 560     }
 561
 562     if (!hybris_is_pointer_in_shm((void*)realcond)) {
 563         ret = pthread_cond_destroy(realcond);
 564         free(realcond);
 565     }
 566     else {
 567         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)realcond);
 568         ret = pthread_cond_destroy(realcond);
 569     }
 570
 571     *((unsigned int *)cond) = 0;
 572
 573     return ret;
 574 }
 575
 576 static int my_pthread_cond_broadcast(pthread_cond_t *cond)
 577 {
 578     unsigned int value = (*(unsigned int *) cond);
 579     if (hybris_check_android_shared_cond(value)) {
 580         LOGD("shared condition with Android, not broadcasting.");
 581         return 0;
 582     }
 583
 584     pthread_cond_t *realcond = (pthread_cond_t *) value;
 585     if (hybris_is_pointer_in_shm((void*)value))
 586         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 587
 588     if (value <= ANDROID_TOP_ADDR_VALUE_COND) {
 589         realcond = hybris_alloc_init_cond();
 590         *((unsigned int *) cond) = (unsigned int) realcond;
 591     }
 592
 593     return pthread_cond_broadcast(realcond);
 594 }
 595
 596 static int my_pthread_cond_signal(pthread_cond_t *cond)
 597 {
 598     unsigned int value = (*(unsigned int *) cond);
 599
 600     if (hybris_check_android_shared_cond(value)) {
 601         LOGD("Shared condition with Android, not signaling.");
 602         return 0;
 603     }
 604
 605     pthread_cond_t *realcond = (pthread_cond_t *) value;
 606     if (hybris_is_pointer_in_shm((void*)value))
 607         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 608
 609     if (value <= ANDROID_TOP_ADDR_VALUE_COND) {
 610         realcond = hybris_alloc_init_cond();
 611         *((unsigned int *) cond) = (unsigned int) realcond;
 612     }
 613
 614     return pthread_cond_signal(realcond);
 615 }
 616
 617 static int my_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 618 {
 619     /* Both cond and mutex can be statically initialized, check for both */
 620     unsigned int cvalue = (*(unsigned int *) cond);
 621     unsigned int mvalue = (*(unsigned int *) mutex);
 622
 623     if (hybris_check_android_shared_cond(cvalue) ||
 624         hybris_check_android_shared_mutex(mvalue)) {
 625         LOGD("Shared condition/mutex with Android, not waiting.");
 626         return 0;
 627     }
 628
 629     pthread_cond_t *realcond = (pthread_cond_t *) cvalue;
 630     if (hybris_is_pointer_in_shm((void*)cvalue))
 631         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)cvalue);
 632
 633     if (cvalue <= ANDROID_TOP_ADDR_VALUE_COND) {
 634         realcond = hybris_alloc_init_cond();
 635         *((unsigned int *) cond) = (unsigned int) realcond;
 636     }
 637
 638     pthread_mutex_t *realmutex = (pthread_mutex_t *) mvalue;
 639     if (hybris_is_pointer_in_shm((void*)mvalue))
 640         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)mvalue);
 641
 642     if (mvalue <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 643         realmutex = hybris_alloc_init_mutex(mvalue);
 644         *((unsigned int *) mutex) = (unsigned int) realmutex;
 645     }
 646
 647     return pthread_cond_wait(realcond, realmutex);
 648 }
 649
 650 static int my_pthread_cond_timedwait(pthread_cond_t *cond,
 651                 pthread_mutex_t *mutex, const struct timespec *abstime)
 652 {
 653     /* Both cond and mutex can be statically initialized, check for both */
 654     unsigned int cvalue = (*(unsigned int *) cond);
 655     unsigned int mvalue = (*(unsigned int *) mutex);
 656
 657     if (hybris_check_android_shared_cond(cvalue) ||
 658          hybris_check_android_shared_mutex(mvalue)) {
 659         LOGD("Shared condition/mutex with Android, not waiting.");
 660         return 0;
 661     }
 662
 663     pthread_cond_t *realcond = (pthread_cond_t *) cvalue;
 664     if (hybris_is_pointer_in_shm((void*)cvalue))
 665         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)cvalue);
 666
 667     if (cvalue <= ANDROID_TOP_ADDR_VALUE_COND) {
 668         realcond = hybris_alloc_init_cond();
 669         *((unsigned int *) cond) = (unsigned int) realcond;
 670     }
 671
 672     pthread_mutex_t *realmutex = (pthread_mutex_t *) mvalue;
 673     if (hybris_is_pointer_in_shm((void*)mvalue))
 674         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)mvalue);
 675
 676     if (mvalue <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 677         realmutex = hybris_alloc_init_mutex(mvalue);
 678         *((unsigned int *) mutex) = (unsigned int) realmutex;
 679     }
 680
 681     return pthread_cond_timedwait(realcond, realmutex, abstime);
 682 }
 683
 684 static int my_pthread_cond_timedwait_relative_np(pthread_cond_t *cond,
 685                 pthread_mutex_t *mutex, const struct timespec *reltime)
 686 {
 687     /* Both cond and mutex can be statically initialized, check for both */
 688     unsigned int cvalue = (*(unsigned int *) cond);
 689     unsigned int mvalue = (*(unsigned int *) mutex);
 690
 691     if (hybris_check_android_shared_cond(cvalue) ||
 692          hybris_check_android_shared_mutex(mvalue)) {
 693         LOGD("Shared condition/mutex with Android, not waiting.");
 694         return 0;
 695     }
 696
 697     pthread_cond_t *realcond = (pthread_cond_t *) cvalue;
 698     if( hybris_is_pointer_in_shm((void*)cvalue) )
 699         realcond = (pthread_cond_t *)hybris_get_shmpointer((hybris_shm_pointer_t)cvalue);
 700
 701     if (cvalue <= ANDROID_TOP_ADDR_VALUE_COND) {
 702         realcond = hybris_alloc_init_cond();
 703         *((unsigned int *) cond) = (unsigned int) realcond;
 704     }
 705
 706     pthread_mutex_t *realmutex = (pthread_mutex_t *) mvalue;
 707     if (hybris_is_pointer_in_shm((void*)mvalue))
 708         realmutex = (pthread_mutex_t *)hybris_get_shmpointer((hybris_shm_pointer_t)mvalue);
 709
 710     if (mvalue <= ANDROID_TOP_ADDR_VALUE_MUTEX) {
 711         realmutex = hybris_alloc_init_mutex(mvalue);
 712         *((unsigned int *) mutex) = (unsigned int) realmutex;
 713     }
 714
 715     /* TODO: Android uses CLOCK_MONOTONIC here but I am not sure which one to use */
 716     struct timespec tv;
 717     clock_gettime(CLOCK_REALTIME, &tv);
 718     tv.tv_sec += reltime->tv_sec;
 719     tv.tv_nsec += reltime->tv_nsec;
 720     if (tv.tv_nsec >= 1000000000) {
 721       tv.tv_sec++;
 722       tv.tv_nsec -= 1000000000;
 723     }
 724     return pthread_cond_timedwait(realcond, realmutex, &tv);
 725 }
 726
 727 /*
 728  * pthread_rwlockattr_* functions
 729  *
 730  * Specific implementations to workaround the differences between at the
 731  * pthread_rwlockattr_t struct differences between Bionic and Glibc.
 732  *
 733  * */
 734
 735 static int my_pthread_rwlockattr_init(pthread_rwlockattr_t *__attr)
 736 {
 737     pthread_rwlockattr_t *realattr;
 738
 739     realattr = malloc(sizeof(pthread_rwlockattr_t));
 740     *((unsigned int *)__attr) = (unsigned int) realattr;
 741
 742     return pthread_rwlockattr_init(realattr);
 743 }
 744
 745 static int my_pthread_rwlockattr_destroy(pthread_rwlockattr_t *__attr)
 746 {
 747     int ret;
 748     pthread_rwlockattr_t *realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
 749
 750     ret = pthread_rwlockattr_destroy(realattr);
 751     free(realattr);
 752
 753     return ret;
 754 }
 755
 756 static int my_pthread_rwlockattr_setpshared(pthread_rwlockattr_t *__attr,
 757                                             int pshared)
 758 {
 759     pthread_rwlockattr_t *realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
 760     return pthread_rwlockattr_setpshared(realattr, pshared);
 761 }
 762
 763 static int my_pthread_rwlockattr_getpshared(pthread_rwlockattr_t *__attr,
 764                                             int *pshared)
 765 {
 766     pthread_rwlockattr_t *realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
 767     return pthread_rwlockattr_getpshared(realattr, pshared);
 768 }
 769
 770 /*
 771  * pthread_rwlock_* functions
 772  *
 773  * Specific implementations to workaround the differences between at the
 774  * pthread_rwlock_t struct differences between Bionic and Glibc.
 775  *
 776  * */
 777
 778 static int my_pthread_rwlock_init(pthread_rwlock_t *__rwlock,
 779                                   __const pthread_rwlockattr_t *__attr)
 780 {
 781     pthread_rwlock_t *realrwlock = NULL;
 782     pthread_rwlockattr_t *realattr = NULL;
 783     int pshared = 0;
 784
 785     if (__attr != NULL)
 786         realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
 787
 788     if (realattr)
 789         pthread_rwlockattr_getpshared(realattr, &pshared);
 790
 791     if (!pshared) {
 792         /* non shared, standard rwlock: use malloc */
 793         realrwlock = malloc(sizeof(pthread_rwlock_t));
 794
 795         *((unsigned int *) __rwlock) = (unsigned int) realrwlock;
 796     }
 797     else {
 798         /* process-shared condition: use the shared memory segment */
 799         hybris_shm_pointer_t handle = hybris_shm_alloc(sizeof(pthread_rwlock_t));
 800
 801         *((unsigned int *)__rwlock) = (unsigned int) handle;
 802
 803         if (handle)
 804             realrwlock = (pthread_rwlock_t *)hybris_get_shmpointer(handle);
 805     }
 806
 807     return pthread_rwlock_init(realrwlock, realattr);
 808 }
 809
 810 static int my_pthread_rwlock_destroy(pthread_rwlock_t *__rwlock)
 811 {
 812     int ret;
 813     pthread_rwlock_t *realrwlock = (pthread_rwlock_t *) *(unsigned int *) __rwlock;
 814
 815     if (!hybris_is_pointer_in_shm((void*)realrwlock)) {
 816         ret = pthread_rwlock_destroy(realrwlock);
 817         free(realrwlock);
 818     }
 819     else {
 820         ret = pthread_rwlock_destroy(realrwlock);
 821         realrwlock = (pthread_rwlock_t *)hybris_get_shmpointer((hybris_shm_pointer_t)realrwlock);
 822     }
 823
 824     return ret;
 825 }
 826
 827 static pthread_rwlock_t* hybris_set_realrwlock(pthread_rwlock_t *rwlock)
 828 {
 829     unsigned int value = (*(unsigned int *) rwlock);
 830     pthread_rwlock_t *realrwlock = (pthread_rwlock_t *) value;
 831     if (hybris_is_pointer_in_shm((void*)value))
 832         realrwlock = (pthread_rwlock_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 833
 834     if (realrwlock <= ANDROID_TOP_ADDR_VALUE_RWLOCK) {
 835         realrwlock = hybris_alloc_init_rwlock();
 836         *((unsigned int *)rwlock) = (unsigned int) realrwlock;
 837     }
 838     return realrwlock;
 839 }
 840
 841 static int my_pthread_rwlock_rdlock(pthread_rwlock_t *__rwlock)
 842 {
 843     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 844     return pthread_rwlock_rdlock(realrwlock);
 845 }
 846
 847 static int my_pthread_rwlock_tryrdlock(pthread_rwlock_t *__rwlock)
 848 {
 849     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 850     return pthread_rwlock_tryrdlock(realrwlock);
 851 }
 852
 853 static int my_pthread_rwlock_timedrdlock(pthread_rwlock_t *__rwlock,
 854                                          __const struct timespec *abs_timeout)
 855 {
 856     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 857     return pthread_rwlock_timedrdlock(realrwlock, abs_timeout);
 858 }
 859
 860 static int my_pthread_rwlock_wrlock(pthread_rwlock_t *__rwlock)
 861 {
 862     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 863     return pthread_rwlock_wrlock(realrwlock);
 864 }
 865
 866 static int my_pthread_rwlock_trywrlock(pthread_rwlock_t *__rwlock)
 867 {
 868     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 869     return pthread_rwlock_trywrlock(realrwlock);
 870 }
 871
 872 static int my_pthread_rwlock_timedwrlock(pthread_rwlock_t *__rwlock,
 873                                          __const struct timespec *abs_timeout)
 874 {
 875     pthread_rwlock_t *realrwlock = hybris_set_realrwlock(__rwlock);
 876     return pthread_rwlock_timedwrlock(realrwlock, abs_timeout);
 877 }
 878
 879 static int my_pthread_rwlock_unlock(pthread_rwlock_t *__rwlock)
 880 {
 881     unsigned int value = (*(unsigned int *) __rwlock);
 882     if (value <= ANDROID_TOP_ADDR_VALUE_RWLOCK) {
 883         LOGD("Trying to unlock a rwlock that's not locked/initialized"
 884                " by Hybris, not unlocking.");
 885         return 0;
 886     }
 887     pthread_rwlock_t *realrwlock = (pthread_rwlock_t *) value;
 888     if (hybris_is_pointer_in_shm((void*)value))
 889         realrwlock = (pthread_rwlock_t *)hybris_get_shmpointer((hybris_shm_pointer_t)value);
 890
 891     return pthread_rwlock_unlock(realrwlock);
 892 }
 893
 894
 895 static int my_set_errno(int oi_errno)
 896 {
 897     errno = oi_errno;
 898     return -1;
 899 }
 900
 901 /*
 902  * __isthreaded is used in bionic's stdio.h to choose between a fast internal implementation
 903  * and a more classic stdio function call.
 904  * For example:
 905  * #define  __sfeof(p)  (((p)->_flags & __SEOF) != 0)
 906  * #define  feof(p)     (!__isthreaded ? __sfeof(p) : (feof)(p))
 907  *
 908  * We see here that if __isthreaded is false, then it will use directly the bionic's FILE structure
 909  * instead of calling one of the hooked methods.
 910  * Therefore we need to set __isthreaded to true, even if we are not in a multi-threaded context.
 911  */
 912 static int __my_isthreaded = 1;
 913
 914 /*
 915  * redirection for bionic's __sF, which is defined as:
 916  *   FILE __sF[3];
 917  *   #define stdin  &__sF[0];
 918  *   #define stdout &__sF[1];
 919  *   #define stderr &__sF[2];
 920  *   So the goal here is to catch the call to file methods where the FILE* pointer
 921  *   is either stdin, stdout or stderr, and translate that pointer to a valid glibc
 922  *   pointer.
 923  *   Currently, only fputs is managed.
 924  */
 925 #define BIONIC_SIZEOF_FILE 84
 926 static char my_sF[3*BIONIC_SIZEOF_FILE] = {0};
 927 static FILE *_get_actual_fp(FILE *fp)
 928 {
 929     char *c_fp = (char*)fp;
 930     if (c_fp == &my_sF[0])
 931         return stdin;
 932     else if (c_fp == &my_sF[BIONIC_SIZEOF_FILE])
 933         return stdout;
 934     else if (c_fp == &my_sF[BIONIC_SIZEOF_FILE*2])
 935         return stderr;
 936
 937     return fp;
 938 }
 939
 940 static void my_clearerr(FILE *fp)
 941 {
 942     clearerr(_get_actual_fp(fp));
 943 }
 944
 945 static int my_fclose(FILE *fp)
 946 {
 947     return fclose(_get_actual_fp(fp));
 948 }
 949
 950 static int my_feof(FILE *fp)
 951 {
 952     return feof(_get_actual_fp(fp));
 953 }
 954
 955 static int my_ferror(FILE *fp)
 956 {
 957     return ferror(_get_actual_fp(fp));
 958 }
 959
 960 static int my_fflush(FILE *fp)
 961 {
 962     return fflush(_get_actual_fp(fp));
 963 }
 964
 965 static int my_fgetc(FILE *fp)
 966 {
 967     return fgetc(_get_actual_fp(fp));
 968 }
 969
 970 static int my_fgetpos(FILE *fp, fpos_t *pos)
 971 {
 972     return fgetpos(_get_actual_fp(fp), pos);
 973 }
 974
 975 static char* my_fgets(char *s, int n, FILE *fp)
 976 {
 977     return fgets(s, n, _get_actual_fp(fp));
 978 }
 979
 980 FP_ATTRIB static int my_fprintf(FILE *fp, const char *fmt, ...)
 981 {
 982     int ret = 0;
 983
 984     va_list args;
 985     va_start(args,fmt);
 986     ret = vfprintf(_get_actual_fp(fp), fmt, args);
 987     va_end(args);
 988
 989     return ret;
 990 }
 991
 992 static int my_fputc(int c, FILE *fp)
 993 {
 994     return fputc(c, _get_actual_fp(fp));
 995 }
 996
 997 static int my_fputs(const char *s, FILE *fp)
 998 {
 999     return fputs(s, _get_actual_fp(fp));
1000 }
1001
1002 static size_t my_fread(void *ptr, size_t size, size_t nmemb, FILE *fp)
1003 {
1004     return fread(ptr, size, nmemb, _get_actual_fp(fp));
1005 }
1006
1007 static FILE* my_freopen(const char *filename, const char *mode, FILE *fp)
1008 {
1009     return freopen(filename, mode, _get_actual_fp(fp));
1010 }
1011
1012 FP_ATTRIB static int my_fscanf(FILE *fp, const char *fmt, ...)
1013 {
1014     int ret = 0;
1015
1016     va_list args;
1017     va_start(args,fmt);
1018     ret = vfscanf(_get_actual_fp(fp), fmt, args);
1019     va_end(args);
1020
1021     return ret;
1022 }
1023
1024 static int my_fseek(FILE *fp, long offset, int whence)
1025 {
1026     return fseek(_get_actual_fp(fp), offset, whence);
1027 }
1028
1029 static int my_fseeko(FILE *fp, off_t offset, int whence)
1030 {
1031     return fseeko(_get_actual_fp(fp), offset, whence);
1032 }
1033
1034 static int my_fsetpos(FILE *fp, const fpos_t *pos)
1035 {
1036     return fsetpos(_get_actual_fp(fp), pos);
1037 }
1038
1039 static long my_ftell(FILE *fp)
1040 {
1041     return ftell(_get_actual_fp(fp));
1042 }
1043
1044 static off_t my_ftello(FILE *fp)
1045 {
1046     return ftello(_get_actual_fp(fp));
1047 }
1048
1049 static size_t my_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *fp)
1050 {
1051     return fwrite(ptr, size, nmemb, _get_actual_fp(fp));
1052 }
1053
1054 static int my_getc(FILE *fp)
1055 {
1056     return getc(_get_actual_fp(fp));
1057 }
1058
1059 static ssize_t my_getdelim(char ** lineptr, size_t *n, int delimiter, FILE * fp)
1060 {
1061     return getdelim(lineptr, n, delimiter, _get_actual_fp(fp));
1062 }
1063
1064 static ssize_t my_getline(char **lineptr, size_t *n, FILE *fp)
1065 {
1066     return getline(lineptr, n, _get_actual_fp(fp));
1067 }
1068
1069
1070 static int my_putc(int c, FILE *fp)
1071 {
1072     return putc(c, _get_actual_fp(fp));
1073 }
1074
1075 static void my_rewind(FILE *fp)
1076 {
1077     rewind(_get_actual_fp(fp));
1078 }
1079
1080 static void my_setbuf(FILE *fp, char *buf)
1081 {
1082     setbuf(_get_actual_fp(fp), buf);
1083 }
1084
1085 static int my_setvbuf(FILE *fp, char *buf, int mode, size_t size)
1086 {
1087     return setvbuf(_get_actual_fp(fp), buf, mode, size);
1088 }
1089
1090 static int my_ungetc(int c, FILE *fp)
1091 {
1092     return ungetc(c, _get_actual_fp(fp));
1093 }
1094
1095 static int my_vfprintf(FILE *fp, const char *fmt, va_list arg)
1096 {
1097     return vfprintf(_get_actual_fp(fp), fmt, arg);
1098 }
1099
1100
1101 static int my_vfscanf(FILE *fp, const char *fmt, va_list arg)
1102 {
1103     return vfscanf(_get_actual_fp(fp), fmt, arg);
1104 }
1105
1106 static int my_fileno(FILE *fp)
1107 {
1108     return fileno(_get_actual_fp(fp));
1109 }
1110
1111
1112 static int my_pclose(FILE *fp)
1113 {
1114     return pclose(_get_actual_fp(fp));
1115 }
1116
1117 static void my_flockfile(FILE *fp)
1118 {
1119     return flockfile(_get_actual_fp(fp));
1120 }
1121
1122 static int my_ftrylockfile(FILE *fp)
1123 {
1124     return ftrylockfile(_get_actual_fp(fp));
1125 }
1126
1127 static void my_funlockfile(FILE *fp)
1128 {
1129     return funlockfile(_get_actual_fp(fp));
1130 }
1131
1132
1133 static int my_getc_unlocked(FILE *fp)
1134 {
1135     return getc_unlocked(_get_actual_fp(fp));
1136 }
1137
1138 static int my_putc_unlocked(int c, FILE *fp)
1139 {
1140     return putc_unlocked(c, _get_actual_fp(fp));
1141 }
1142
1143 /* exists only on the BSD platform
1144 static char* my_fgetln(FILE *fp, size_t *len)
1145 {
1146     return fgetln(_get_actual_fp(fp), len);
1147 }
1148 */
1149 static int my_fpurge(FILE *fp)
1150 {
1151     __fpurge(_get_actual_fp(fp));
1152
1153     return 0;
1154 }
1155
1156 static int my_getw(FILE *fp)
1157 {
1158     return getw(_get_actual_fp(fp));
1159 }
1160
1161 static int my_putw(int w, FILE *fp)
1162 {
1163     return putw(w, _get_actual_fp(fp));
1164 }
1165
1166 static void my_setbuffer(FILE *fp, char *buf, int size)
1167 {
1168     setbuffer(_get_actual_fp(fp), buf, size);
1169 }
1170
1171 static int my_setlinebuf(FILE *fp)
1172 {
1173     setlinebuf(_get_actual_fp(fp));
1174
1175     return 0;
1176 }
1177
1178 long my_sysconf(int name)
1179 {
1180   /*
1181    * bionic has different values for the values below.
1182    * TODO: compare the values between glibc and bionic and complete the mapping
1183    */
1184   switch (name) {
1185   case 0x27:
1186     return sysconf(_SC_PAGESIZE);
1187   case 0x28:
1188     return sysconf(_SC_PAGE_SIZE);
1189   case 0x60:
1190     return sysconf(_SC_NPROCESSORS_CONF);
1191   case 0x61:
1192     return sysconf(_SC_NPROCESSORS_ONLN);
1193   default:
1194     break;
1195   }
1196
1197
1198   long rv = sysconf(name);
1199
1200 #ifdef DEBUG
1201   if (rv == -1) {
1202     printf("sysconf failed for %li\n", name);
1203     exit(-1);
1204   }
1205 #endif
1206
1207   return rv;
1208 }
1209
1210 FP_ATTRIB static double my_strtod(const char *nptr, char **endptr)
1211 {
1212         if (locale_inited == 0)
1213         {
1214                 hybris_locale = newlocale(LC_ALL_MASK, "C", 0);
1215                 locale_inited = 1;
1216         }
1217         return strtod_l(nptr, endptr, hybris_locale);
1218 }
1219
1220 extern int __cxa_atexit(void (*)(void*), void*, void*);
1221
1222 static struct _hook hooks[] = {
1223     {"property_get", property_get },
1224     {"property_set", property_set },
1225     {"getenv", getenv },
1226     {"printf", printf },
1227     {"malloc", my_malloc },
1228     {"free", free },
1229     {"calloc", calloc },
1230     {"cfree", cfree },
1231     {"realloc", realloc },
1232     {"memalign", memalign },
1233     {"valloc", valloc },
1234     {"pvalloc", pvalloc },
1235     {"fread", fread },
1236     {"getxattr", getxattr},
1237     /* string.h */
1238     {"memccpy",memccpy},
1239     {"memchr",memchr},
1240     {"memrchr",memrchr},
1241     {"memcmp",memcmp},
1242     {"memcpy",my_memcpy},
1243     {"memmove",memmove},
1244     {"memset",memset},
1245     {"memmem",memmem},
1246     //  {"memswap",memswap},
1247     {"index",index},
1248     {"rindex",rindex},
1249     {"strchr",strchr},
1250     {"strrchr",strrchr},
1251     {"strlen",my_strlen},
1252     {"strcmp",strcmp},
1253     {"strcpy",strcpy},
1254     {"strcat",strcat},
1255     {"strcasecmp",strcasecmp},
1256     {"strncasecmp",strncasecmp},
1257     {"strdup",strdup},
1258     {"strstr",strstr},
1259     {"strtok",strtok},
1260     {"strtok_r",strtok_r},
1261     {"strerror",strerror},
1262     {"strerror_r",strerror_r},
1263     {"strnlen",strnlen},
1264     {"strncat",strncat},
1265     {"strndup",strndup},
1266     {"strncmp",strncmp},
1267     {"strncpy",strncpy},
1268     {"strtod", my_strtod},
1269     //{"strlcat",strlcat},
1270     //{"strlcpy",strlcpy},
1271     {"strcspn",strcspn},
1272     {"strpbrk",strpbrk},
1273     {"strsep",strsep},
1274     {"strspn",strspn},
1275     {"strsignal",strsignal},
1276     {"getgrnam", getgrnam},
1277     {"strcoll",strcoll},
1278     {"strxfrm",strxfrm},
1279     /* strings.h */
1280     {"bcmp",bcmp},
1281     {"bcopy",bcopy},
1282     {"bzero",bzero},
1283     {"ffs",ffs},
1284     {"index",index},
1285     {"rindex",rindex},
1286     {"strcasecmp",strcasecmp},
1287     {"strncasecmp",strncasecmp},
1288     /* dirent.h */
1289     {"opendir", opendir},
1290     {"closedir", closedir},
1291     /* pthread.h */
1292     {"pthread_atfork", pthread_atfork},
1293     {"pthread_create", my_pthread_create},
1294     {"pthread_kill", pthread_kill},
1295     {"pthread_exit", pthread_exit},
1296     {"pthread_join", pthread_join},
1297     {"pthread_detach", pthread_detach},
1298     {"pthread_self", pthread_self},
1299     {"pthread_equal", pthread_equal},
1300     {"pthread_getschedparam", pthread_getschedparam},
1301     {"pthread_setschedparam", pthread_setschedparam},
1302     {"pthread_mutex_init", my_pthread_mutex_init},
1303     {"pthread_mutex_destroy", my_pthread_mutex_destroy},
1304     {"pthread_mutex_lock", my_pthread_mutex_lock},
1305     {"pthread_mutex_unlock", my_pthread_mutex_unlock},
1306     {"pthread_mutex_trylock", my_pthread_mutex_trylock},
1307     {"pthread_mutex_lock_timeout_np", my_pthread_mutex_lock_timeout_np},
1308     {"pthread_mutexattr_init", pthread_mutexattr_init},
1309     {"pthread_mutexattr_destroy", pthread_mutexattr_destroy},
1310     {"pthread_mutexattr_getttype", pthread_mutexattr_gettype},
1311     {"pthread_mutexattr_settype", pthread_mutexattr_settype},
1312     {"pthread_mutexattr_getpshared", pthread_mutexattr_getpshared},
1313     {"pthread_mutexattr_setpshared", my_pthread_mutexattr_setpshared},
1314     {"pthread_condattr_init", pthread_condattr_init},
1315     {"pthread_condattr_getpshared", pthread_condattr_getpshared},
1316     {"pthread_condattr_setpshared", pthread_condattr_setpshared},
1317     {"pthread_condattr_destroy", pthread_condattr_destroy},
1318     {"pthread_cond_init", my_pthread_cond_init},
1319     {"pthread_cond_destroy", my_pthread_cond_destroy},
1320     {"pthread_cond_broadcast", my_pthread_cond_broadcast},
1321     {"pthread_cond_signal", my_pthread_cond_signal},
1322     {"pthread_cond_wait", my_pthread_cond_wait},
1323     {"pthread_cond_timedwait", my_pthread_cond_timedwait},
1324     {"pthread_cond_timedwait_monotonic", my_pthread_cond_timedwait},
1325     {"pthread_cond_timedwait_monotonic_np", my_pthread_cond_timedwait},
1326     {"pthread_cond_timedwait_relative_np", my_pthread_cond_timedwait_relative_np},
1327     {"pthread_key_delete", pthread_key_delete},
1328     {"pthread_setname_np", pthread_setname_np},
1329     {"pthread_once", pthread_once},
1330     {"pthread_key_create", pthread_key_create},
1331     {"pthread_setspecific", pthread_setspecific},
1332     {"pthread_getspecific", pthread_getspecific},
1333     {"pthread_attr_init", my_pthread_attr_init},
1334     {"pthread_attr_destroy", my_pthread_attr_destroy},
1335     {"pthread_attr_setdetachstate", my_pthread_attr_setdetachstate},
1336     {"pthread_attr_getdetachstate", my_pthread_attr_getdetachstate},
1337     {"pthread_attr_setschedpolicy", my_pthread_attr_setschedpolicy},
1338     {"pthread_attr_getschedpolicy", my_pthread_attr_getschedpolicy},
1339     {"pthread_attr_setschedparam", my_pthread_attr_setschedparam},
1340     {"pthread_attr_getschedparam", my_pthread_attr_getschedparam},
1341     {"pthread_attr_setstacksize", my_pthread_attr_setstacksize},
1342     {"pthread_attr_getstacksize", my_pthread_attr_getstacksize},
1343     {"pthread_attr_setstackaddr", my_pthread_attr_setstackaddr},
1344     {"pthread_attr_getstackaddr", my_pthread_attr_getstackaddr},
1345     {"pthread_attr_setstack", my_pthread_attr_setstack},
1346     {"pthread_attr_getstack", my_pthread_attr_getstack},
1347     {"pthread_attr_setguardsize", my_pthread_attr_setguardsize},
1348     {"pthread_attr_getguardsize", my_pthread_attr_getguardsize},
1349     {"pthread_attr_setscope", my_pthread_attr_setscope},
1350     {"pthread_attr_setscope", my_pthread_attr_getscope},
1351     {"pthread_getattr_np", my_pthread_getattr_np},
1352     {"pthread_rwlockattr_init", my_pthread_rwlockattr_init},
1353     {"pthread_rwlockattr_destroy", my_pthread_rwlockattr_destroy},
1354     {"pthread_rwlockattr_setpshared", my_pthread_rwlockattr_setpshared},
1355     {"pthread_rwlockattr_getpshared", my_pthread_rwlockattr_getpshared},
1356     {"pthread_rwlock_init", my_pthread_rwlock_init},
1357     {"pthread_rwlock_destroy", my_pthread_rwlock_destroy},
1358     {"pthread_rwlock_unlock", my_pthread_rwlock_unlock},
1359     {"pthread_rwlock_wrlock", my_pthread_rwlock_wrlock},
1360     {"pthread_rwlock_rdlock", my_pthread_rwlock_rdlock},
1361     {"pthread_rwlock_tryrdlock", my_pthread_rwlock_tryrdlock},
1362     {"pthread_rwlock_trywrlock", my_pthread_rwlock_trywrlock},
1363     {"pthread_rwlock_timedrdlock", my_pthread_rwlock_timedrdlock},
1364     {"pthread_rwlock_timedwrlock", my_pthread_rwlock_timedwrlock},
1365     /* stdio.h */
1366     {"__isthreaded", &__my_isthreaded},
1367     {"__sF", &my_sF},
1368     {"fopen", fopen},
1369     {"fdopen", fdopen},
1370     {"popen", popen},
1371     {"puts", puts},
1372     {"sprintf", sprintf},
1373     {"asprintf", asprintf},
1374     {"vasprintf", vasprintf},
1375     {"snprintf", snprintf},
1376     {"vsprintf", vsprintf},
1377     {"vsnprintf", vsnprintf},
1378     {"clearerr", my_clearerr},
1379     {"fclose", my_fclose},
1380     {"feof", my_feof},
1381     {"ferror", my_ferror},
1382     {"fflush", my_fflush},
1383     {"fgetc", my_fgetc},
1384     {"fgetpos", my_fgetpos},
1385     {"fgets", my_fgets},
1386     {"fprintf", my_fprintf},
1387     {"fputc", my_fputc},
1388     {"fputs", my_fputs},
1389     {"fread", my_fread},
1390     {"freopen", my_freopen},
1391     {"fscanf", my_fscanf},
1392     {"fseek", my_fseek},
1393     {"fseeko", my_fseeko},
1394     {"fsetpos", my_fsetpos},
1395     {"ftell", my_ftell},
1396     {"ftello", my_ftello},
1397     {"fwrite", my_fwrite},
1398     {"getc", my_getc},
1399     {"getdelim", my_getdelim},
1400     {"getline", my_getline},
1401     {"putc", my_putc},
1402     {"rewind", my_rewind},
1403     {"setbuf", my_setbuf},
1404     {"setvbuf", my_setvbuf},
1405     {"ungetc", my_ungetc},
1406     {"vasprintf", vasprintf},
1407     {"vfprintf", my_vfprintf},
1408     {"vfscanf", my_vfscanf},
1409     {"fileno", my_fileno},
1410     {"pclose", my_pclose},
1411     {"flockfile", my_flockfile},
1412     {"ftrylockfile", my_ftrylockfile},
1413     {"funlockfile", my_funlockfile},
1414     {"getc_unlocked", my_getc_unlocked},
1415     {"putc_unlocked", my_putc_unlocked},
1416     //{"fgetln", my_fgetln},
1417     {"fpurge", my_fpurge},
1418     {"getw", my_getw},
1419     {"putw", my_putw},
1420     {"setbuffer", my_setbuffer},
1421     {"setlinebuf", my_setlinebuf},
1422     {"__errno", __errno_location},
1423     {"__set_errno", my_set_errno},
1424     /* net specifics, to avoid __res_get_state */
1425     {"getaddrinfo", getaddrinfo},
1426     {"gethostbyaddr", gethostbyaddr},
1427     {"gethostbyname", gethostbyname},
1428     {"gethostbyname2", gethostbyname2},
1429     {"gethostent", gethostent},
1430     {"strftime", strftime},
1431     {"sysconf", my_sysconf},
1432     {"sscanf", sscanf},
1433     {"scanf", scanf},
1434     {"vscanf", vscanf},
1435     {"vsscanf", vsscanf},
1436     {"openlog", openlog},
1437     {"syslog", syslog},
1438     {"closelog", closelog},
1439     {"vsyslog", vsyslog},
1440     {"timer_create", timer_create},
1441     {"timer_settime", timer_settime},
1442     {"timer_gettime", timer_gettime},
1443     {"timer_delete", timer_delete},
1444     {"timer_getoverrun", timer_getoverrun},
1445     {"abort", abort},
1446     {"writev", writev},
1447     /* unistd.h */
1448     {"access", access},
1449     /* grp.h */
1450     {"getgrgid", getgrgid},
1451     {"__cxa_atexit", __cxa_atexit},
1452     {NULL, NULL},
1453 };
1454
1455 void *get_hooked_symbol(char *sym)
1456 {
1457     struct _hook *ptr = &hooks[0];
1458     static int counter = -1;
1459
1460     while (ptr->name != NULL)
1461     {
1462         if (strcmp(sym, ptr->name) == 0){
1463             return ptr->func;
1464         }
1465         ptr++;
1466     }
1467     if (strstr(sym, "pthread") != NULL)
1468     {
1469         /* safe */
1470         if (strcmp(sym, "pthread_sigmask") == 0)
1471            return NULL;
1472         /* not safe */
1473         counter--;
1474         LOGD("%s %i\n", sym, counter);
1475         return (void *) counter;
1476     }
1477     return NULL;
1478 }
1479
1480 void android_linker_init()
1481 {
1482 }