diff options
| author | The Android Open Source Project <initial-contribution@android.com> | 2009-02-19 10:57:29 -0800 |
|---|---|---|
| committer | The Android Open Source Project <initial-contribution@android.com> | 2009-02-19 10:57:29 -0800 |
| commit | 6f04a0f4c72acff80dad04828cb69ef67fa609d1 (patch) | |
| tree | 915db7d93cb742f72b5d3819e69f48cb29c40a15 | |
| parent | 2489551343aa89fc539f369f7689c941b78c08d1 (diff) | |
| download | bionic-6f04a0f4c72acff80dad04828cb69ef67fa609d1.zip bionic-6f04a0f4c72acff80dad04828cb69ef67fa609d1.tar.gz bionic-6f04a0f4c72acff80dad04828cb69ef67fa609d1.tar.bz2 | |
auto import from //branches/cupcake/...@132276
29 files changed, 1571 insertions, 822 deletions
diff --git a/libc/SYSCALLS.TXT b/libc/SYSCALLS.TXT index 0445fc9..1ef06d2 100644 --- a/libc/SYSCALLS.TXT +++ b/libc/SYSCALLS.TXT @@ -216,22 +216,6 @@ int sched_get_priority_max(int policy) 159 int sched_get_priority_min(int policy) 160 int sched_rr_get_interval(pid_t pid, struct timespec *interval) 161 -# system-V inter-process communication -# TODO: implement x86 stubs for these functions when needed (when ?) -# -int semctl(int semid, int semnum, int cmd, ...) 300,-1 -int semget(key_t key, int nsems, int semflg) 299,-1 -int semop(int semid, struct sembuf* sops, size_t nsops) 298,-1 -void* shmat(int shmid, const void* shmaddr, int shmflg) 305,-1 -int shmctl(int shmid, int cmd, struct shmid_ds* buf) 308,-1 -int shmdt(const void* shmaddr) 306,-1 -int shmget(key_t key, size_t size, int shmflg) 307,-1 -int msgctl(int msqid, int cmd, struct msqid_ds *buf) 304,-1 -int msgget(key_t key, int msgflg) 303,-1 -int msgrcv(int msqid, void* msgp, size_t msgsz, long int msgtyp, int msgflg) 302,-1 -int msgsnd(int msqid, const void* msgp, size_t msgsz, int msgflg) 301,-1 - - # other int uname(struct utsname *) 122 pid_t __wait4:wait4(pid_t pid, int *status, int options, struct rusage *rusage) 114 diff --git a/libc/arch-arm/syscalls.mk b/libc/arch-arm/syscalls.mk index a140a59..706cb0c 100644 --- a/libc/arch-arm/syscalls.mk +++ b/libc/arch-arm/syscalls.mk @@ -150,17 +150,6 @@ syscall_src += arch-arm/syscalls/sched_getparam.S syscall_src += arch-arm/syscalls/sched_get_priority_max.S syscall_src += arch-arm/syscalls/sched_get_priority_min.S syscall_src += arch-arm/syscalls/sched_rr_get_interval.S -syscall_src += arch-arm/syscalls/semctl.S -syscall_src += arch-arm/syscalls/semget.S -syscall_src += arch-arm/syscalls/semop.S -syscall_src += arch-arm/syscalls/shmat.S -syscall_src += arch-arm/syscalls/shmctl.S -syscall_src += arch-arm/syscalls/shmdt.S -syscall_src += arch-arm/syscalls/shmget.S -syscall_src += arch-arm/syscalls/msgctl.S -syscall_src += arch-arm/syscalls/msgget.S -syscall_src += arch-arm/syscalls/msgrcv.S -syscall_src += arch-arm/syscalls/msgsnd.S syscall_src += arch-arm/syscalls/uname.S syscall_src += arch-arm/syscalls/__wait4.S syscall_src += arch-arm/syscalls/umask.S diff --git a/libc/arch-arm/syscalls/msgctl.S b/libc/arch-arm/syscalls/msgctl.S deleted file mode 100644 index 5c0bbf5..0000000 --- a/libc/arch-arm/syscalls/msgctl.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type msgctl, #function - .globl msgctl - .align 4 - .fnstart - -msgctl: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_msgctl - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/msgget.S b/libc/arch-arm/syscalls/msgget.S deleted file mode 100644 index ac16440..0000000 --- a/libc/arch-arm/syscalls/msgget.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type msgget, #function - .globl msgget - .align 4 - .fnstart - -msgget: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_msgget - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/msgrcv.S b/libc/arch-arm/syscalls/msgrcv.S deleted file mode 100644 index 8db4125..0000000 --- a/libc/arch-arm/syscalls/msgrcv.S +++ /dev/null @@ -1,21 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type msgrcv, #function - .globl msgrcv - .align 4 - .fnstart - -msgrcv: - mov ip, sp - .save {r4, r5, r6, r7} - stmfd sp!, {r4, r5, r6, r7} - ldmfd ip, {r4, r5, r6} - ldr r7, =__NR_msgrcv - swi #0 - ldmfd sp!, {r4, r5, r6, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/msgsnd.S b/libc/arch-arm/syscalls/msgsnd.S deleted file mode 100644 index 02c92ec..0000000 --- a/libc/arch-arm/syscalls/msgsnd.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type msgsnd, #function - .globl msgsnd - .align 4 - .fnstart - -msgsnd: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_msgsnd - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/semctl.S b/libc/arch-arm/syscalls/semctl.S deleted file mode 100644 index a50e4dc..0000000 --- a/libc/arch-arm/syscalls/semctl.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type semctl, #function - .globl semctl - .align 4 - .fnstart - -semctl: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_semctl - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/semget.S b/libc/arch-arm/syscalls/semget.S deleted file mode 100644 index aaabd37..0000000 --- a/libc/arch-arm/syscalls/semget.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type semget, #function - .globl semget - .align 4 - .fnstart - -semget: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_semget - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/semop.S b/libc/arch-arm/syscalls/semop.S deleted file mode 100644 index 20ef68b..0000000 --- a/libc/arch-arm/syscalls/semop.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type semop, #function - .globl semop - .align 4 - .fnstart - -semop: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_semop - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/shmat.S b/libc/arch-arm/syscalls/shmat.S deleted file mode 100644 index 8b63bf0..0000000 --- a/libc/arch-arm/syscalls/shmat.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type shmat, #function - .globl shmat - .align 4 - .fnstart - -shmat: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_shmat - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/shmctl.S b/libc/arch-arm/syscalls/shmctl.S deleted file mode 100644 index a29caa6..0000000 --- a/libc/arch-arm/syscalls/shmctl.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type shmctl, #function - .globl shmctl - .align 4 - .fnstart - -shmctl: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_shmctl - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/shmdt.S b/libc/arch-arm/syscalls/shmdt.S deleted file mode 100644 index bee707e..0000000 --- a/libc/arch-arm/syscalls/shmdt.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type shmdt, #function - .globl shmdt - .align 4 - .fnstart - -shmdt: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_shmdt - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/arch-arm/syscalls/shmget.S b/libc/arch-arm/syscalls/shmget.S deleted file mode 100644 index be30704..0000000 --- a/libc/arch-arm/syscalls/shmget.S +++ /dev/null @@ -1,19 +0,0 @@ -/* autogenerated by gensyscalls.py */ -#include <sys/linux-syscalls.h> - - .text - .type shmget, #function - .globl shmget - .align 4 - .fnstart - -shmget: - .save {r4, r7} - stmfd sp!, {r4, r7} - ldr r7, =__NR_shmget - swi #0 - ldmfd sp!, {r4, r7} - movs r0, r0 - bxpl lr - b __set_syscall_errno - .fnend diff --git a/libc/bionic/malloc_leak.c b/libc/bionic/malloc_leak.c index 5ddc913..a0aa2ae 100644 --- a/libc/bionic/malloc_leak.c +++ b/libc/bionic/malloc_leak.c @@ -58,6 +58,8 @@ #define SIZE_FLAG_ZYGOTE_CHILD (1<<31) #define SIZE_FLAG_MASK (SIZE_FLAG_ZYGOTE_CHILD) +#define MAX_SIZE_T (~(size_t)0) + /* * In a VM process, this is set to 1 after fork()ing out of zygote. */ @@ -608,8 +610,16 @@ void chk_free(void* mem) void* chk_calloc(size_t n_elements, size_t elem_size) { - size_t size = n_elements * elem_size; - void* ptr = chk_malloc(size); + size_t size; + void* ptr; + + /* Fail on overflow - just to be safe even though this code runs only + * within the debugging C library, not the production one */ + if (n_elements && MAX_SIZE_T / n_elements < elem_size) { + return NULL; + } + size = n_elements * elem_size; + ptr = chk_malloc(size); if (ptr != NULL) { memset(ptr, 0, size); } @@ -763,8 +773,16 @@ void leak_free(void* mem) void* leak_calloc(size_t n_elements, size_t elem_size) { - size_t size = n_elements * elem_size; - void* ptr = leak_malloc(size); + size_t size; + void* ptr; + + /* Fail on overflow - just to be safe even though this code runs only + * within the debugging C library, not the production one */ + if (n_elements && MAX_SIZE_T / n_elements < elem_size) { + return NULL; + } + size = n_elements * elem_size; + ptr = leak_malloc(size); if (ptr != NULL) { memset(ptr, 0, size); } diff --git a/libc/bionic/pthread-timers.c b/libc/bionic/pthread-timers.c index b8f7488..818b47d 100644 --- a/libc/bionic/pthread-timers.c +++ b/libc/bionic/pthread-timers.c @@ -469,7 +469,7 @@ timer_settime( timer_t id, } if ( __likely(!TIMER_ID_IS_WRAPPED(id)) ) { - return __timer_gettime( id, ospec ); + return __timer_settime( id, flags, spec, ospec ); } else { thr_timer_t* timer = thr_timer_from_id(id); struct timespec expires, now; @@ -560,11 +560,11 @@ timer_thread_start( void* _arg ) if (timespec_cmp( &expires, &now ) > 0) { /* cool, there was no overrun, so compute the - * relative timeout as 'now - expires', then wait + * relative timeout as 'expires - now', then wait */ int ret; - struct timespec diff = now; - timespec_sub( &diff, &expires ); + struct timespec diff = expires; + timespec_sub( &diff, &now ); ret = __pthread_cond_timedwait_relative( &timer->cond, &timer->mutex, &diff); diff --git a/libc/docs/OVERVIEW.TXT b/libc/docs/OVERVIEW.TXT index 4d40df6..4c153b1 100644 --- a/libc/docs/OVERVIEW.TXT +++ b/libc/docs/OVERVIEW.TXT @@ -7,89 +7,93 @@ Core Philosophy: The core idea behind Bionic's design is: KEEP IT REALLY SIMPLE. - This implies that the C library should only provide lightweight wrappers around kernel - facilities and not try to be too smart to deal with edge cases. + This implies that the C library should only provide lightweight wrappers + around kernel facilities and not try to be too smart to deal with edge cases. - The name "Bionic" comes from the fact that it is part-BSD and part-Linux: its source - code consists in a mix of BSD C library pieces with custom Linux-specific bits used - to deal with threads, processes, signals and a few others things. + The name "Bionic" comes from the fact that it is part-BSD and part-Linux: + its source code consists in a mix of BSD C library pieces with custom + Linux-specific bits used to deal with threads, processes, signals and a few + others things. - All original BSD pieces carry the BSD copyright disclaimer. Bionic-specific bits - carry the Android Open Source Project copyright disclaimer. And everything is released - under the BSD license. + All original BSD pieces carry the BSD copyright disclaimer. Bionic-specific + bits carry the Android Open Source Project copyright disclaimer. And + everything is released under the BSD license. Architectures: - Bionic currently supports the ARM and x86 instruction sets. In theory, it should be - possible to support more, but this may require a little work (e.g. adding system - call IDs to SYSCALLS.TXT, described below, or modifying the dynamic linker). + Bionic currently supports the ARM and x86 instruction sets. In theory, it + should be possible to support more, but this may require a little work (e.g. + adding system call IDs to SYSCALLS.TXT, described below, or modifying the + dynamic linker). - The ARM-specific code is under arch-arm/ and the x86-specific one is under arch-x86/ + The ARM-specific code is under arch-arm/ and the x86-specific one is under + arch-x86/ - Note that the x86 version is only meant to run on an x86 Android device. We make - absolutely no claim that you could build and use Bionic on a stock x86 Linux - distribution (though that would be cool, so patches are welcomed :-)) + Note that the x86 version is only meant to run on an x86 Android device. We + make absolutely no claim that you could build and use Bionic on a stock x86 + Linux distribution (though that would be cool, so patches are welcomed :-)) Syscall stubs: Each system call function is implemented by a tiny assembler source fragment - (called a "syscall stub"), which is generated automatically by tools/gensyscalls.py - which reads the SYSCALLS.TXT file for input. + (called a "syscall stub"), which is generated automatically by + tools/gensyscalls.py which reads the SYSCALLS.TXT file for input. SYSCALLS.TXT contains the list of all syscall stubs to generate, along with - the corresponding syscall numeric identifier (which may differ between ARM and x86), - and its signature + the corresponding syscall numeric identifier (which may differ between ARM + and x86), and its signature - If you modify this file, you may want to use tools/checksyscalls.py which checks - its content against official Linux kernel header files, and will report errors when - invalid syscall ids are used. + If you modify this file, you may want to use tools/checksyscalls.py which + checks its content against official Linux kernel header files, and will + report errors when invalid syscall ids are used. - Sometimes, the C library function is really a wrapper that calls the corresponding - syscall with another name. For example, the exit() function is provided by the C - library and calls the _exit() syscall stub. + Sometimes, the C library function is really a wrapper that calls the + corresponding syscall with another name. For example, the exit() function + is provided by the C library and calls the _exit() syscall stub. See SYSCALLS.TXT for documentation and details. time_t: - time_t is 32-bit as defined by the kernel on 32-bit CPUs. A 64-bit version would - be preferrable to avoid the Y2038 bug, but the kernel maintainers consider that - this is not needed at the moment. + time_t is 32-bit as defined by the kernel on 32-bit CPUs. A 64-bit version + would be preferrable to avoid the Y2038 bug, but the kernel maintainers + consider that this is not needed at the moment. - Instead, Bionic provides a <time64.h> header that defines a time64_t type, and - related functions like mktime64(), localtime64(), etc... + Instead, Bionic provides a <time64.h> header that defines a time64_t type, + and related functions like mktime64(), localtime64(), etc... Timezone management: - The name of the current timezone is taken from the TZ environment variable, if defined. - Otherwise, the system property named 'persist.sys.timezone' is checked instead. + The name of the current timezone is taken from the TZ environment variable, + if defined. Otherwise, the system property named 'persist.sys.timezone' is + checked instead. The zoneinfo timezone database and index files are located under directory - /system/usr/share/zoneinfo, instead of the more Posix path of /usr/share/zoneinfo + /system/usr/share/zoneinfo, instead of the more Posix-compliant path of + /usr/share/zoneinfo off_t: - For similar reasons, off_t is 32-bit. We define loff_t as the 64-bit variant due - to BSD inheritance, but off64_t should be available as a typedef to ease porting of - current Linux-specific code. - + For similar reasons, off_t is 32-bit. We define loff_t as the 64-bit variant + due to BSD inheritance, but off64_t should be available as a typedef to ease + porting of current Linux-specific code. Linux kernel headers: - Bionic comes with its own set of "clean" Linux kernel headers to allow user-space - code to use kernel-specific declarations (e.g. IOCTLs, structure declarations, - constants, etc...). They are located in: + Bionic comes with its own set of "clean" Linux kernel headers to allow + user-space code to use kernel-specific declarations (e.g. IOCTLs, structure + declarations, constants, etc...). They are located in: ./kernel/common, ./kernel/arch-arm ./kernel/arch-x86 - These headers have been generated by a tool (kernel/tools/update-all.py) to only - include the public definitions from the original Linux kernel headers. + These headers have been generated by a tool (kernel/tools/update-all.py) to + only include the public definitions from the original Linux kernel headers. If you want to know why and how this is done, read kernel/README.TXT to get all the (gory) details. @@ -97,21 +101,23 @@ Linux kernel headers: PThread implementation: - Bionic's C library comes with its own pthread implementation bundled in. This is - different from other historical C libraries which: + Bionic's C library comes with its own pthread implementation bundled in. + This is different from other historical C libraries which: - place it in an external library (-lpthread) - play linker tricks with weak symbols at dynamic link time - The support for real-time features (a.k.a. -lrt) is also bundled in the C library. + The support for real-time features (a.k.a. -lrt) is also bundled in the + C library. - The implementation is based on futexes and strives to provide *very* short code paths - for common operations. Notable features are the following: + The implementation is based on futexes and strives to provide *very* short + code paths for common operations. Notable features are the following: - pthread_mutex_t, pthread_cond_t are only 4 bytes each. - - Normal, recursive and error-check mutexes are supported, and the code path - is heavily optimized for the normal case, which is used most of the time. + - Normal, recursive and error-check mutexes are supported, and the code + path is heavily optimized for the normal case, which is used most of + the time. - Process-shared mutexes and condition variables are not supported. Their implementation requires far more complexity and was absolutely @@ -123,8 +129,9 @@ PThread implementation: paths slightly slower though). - There is currently no support for read/write locks, priority-ceiling in - mutexes and other more advanced features. Again, the main idea being that - this was not needed for Android at all but could be added in the future. + mutexes and other more advanced features. Again, the main idea being + that this was not needed for Android at all but could be added in the + future. pthread_cancel(): @@ -134,13 +141,13 @@ pthread_cancel(): Consider that: - A proper implementation must insert pthread cancellation checks in a lot - of different places of the C library. And conformance is very difficult to - test properly. + of different places of the C library. And conformance is very difficult + to test properly. - - A proper implementation must also clean up resources, like releasing memory, - or unlocking mutexes, properly if the cancellation happens in a complex - function (e.g. inside gethostbyname() or fprintf() + complex formatting - rules). This tends to slow down the path of many functions. + - A proper implementation must also clean up resources, like releasing + memory, or unlocking mutexes, properly if the cancellation happens in a + complex function (e.g. inside gethostbyname() or fprintf() + complex + formatting rules). This tends to slow down the path of many functions. - pthread cancellation cannot stop all threads: e.g. it can't do anything against an infinite loop @@ -151,18 +158,20 @@ pthread_cancel(): All of this is contrary to the Bionic design goals. If your code depends on thread cancellation, please consider alternatives. - Note however that Bionic does implement pthread_cleanup_push() and pthread_cleanup_pop(), - which can be used to handle cleanups that happen when a thread voluntarily exits - through pthread_exit() or returning from its main function. + Note however that Bionic does implement pthread_cleanup_push() and + pthread_cleanup_pop(), which can be used to handle cleanups that happen when + a thread voluntarily exits through pthread_exit() or returning from its + main function. pthread_once(): Do not call fork() within a callback provided to pthread_once(). Doing this - may result in a deadlock in the child process the next time it calls pthread_once(). + may result in a deadlock in the child process the next time it calls + pthread_once(). - Also, you can't throw a C++ Exception from the callback (see C++ Exception Support - below). + Also, you can't throw a C++ Exception from the callback (see C++ Exception + Support below). The current implementation of pthread_once() lacks the necessary support of multi-core-safe double-checked-locking (read and write barriers). @@ -170,27 +179,27 @@ pthread_once(): Thread-specific data - The thread-specific storage only provides for a bit less than 64 pthread_key_t - objects to each process. The implementation provides 64 real slots but also - uses about 5 of them (exact number may depend on implementation) for its - own use (e.g. two slots are pre-allocated by the C library to speed-up the - Android OpenGL sub-system). + The thread-specific storage only provides for a bit less than 64 + pthread_key_t objects to each process. The implementation provides 64 real + slots but also uses about 5 of them (exact number may depend on + implementation) for its own use (e.g. two slots are pre-allocated by the C + library to speed-up the Android OpenGL sub-system). Note that Posix mandates a minimum of 128 slots, but we do not claim to be Posix-compliant. - Except for the main thread, the TLS area is stored at the top of the stack. See - comments in bionic/libc/bionic/pthread.c for details. + Except for the main thread, the TLS area is stored at the top of the stack. + See comments in bionic/libc/bionic/pthread.c for details. - At the moment, thread-local storage defined through the __thread compiler keyword - is not supported by the Bionic C library and dynamic linker. + At the moment, thread-local storage defined through the __thread compiler + keyword is not supported by the Bionic C library and dynamic linker. Multi-core support At the moment, Bionic does not provide or use read/write memory barriers. - This means that using it on certain multi-core systems might not be supported, - depending on its exact CPU architecture. + This means that using it on certain multi-core systems might not be + supported, depending on its exact CPU architecture. Android-specific features: @@ -201,67 +210,69 @@ Android-specific features: Android provides a simple shared value/key space to all processes on the system. It stores a liberal number of 'properties', each of them being a - simple size-limited string that can be associated to a size-limited string - value. + simple size-limited string that can be associated to a size-limited + string value. - The header <sys/system_properties.h> can be used to read system properties - and also defines the maximum size of keys and values. + The header <sys/system_properties.h> can be used to read system + properties and also defines the maximum size of keys and values. - Android-specific user/group management: - There is no /etc/passwd or /etc/groups in Android. By design, it is meant to - be used by a single handset user. On the other hand, Android uses the Linux - user/group management features extensively to secure process permissions, - like access to various filesystem directories. + There is no /etc/passwd or /etc/groups in Android. By design, it is + meant to be used by a single handset user. On the other hand, Android + uses the Linux user/group management features extensively to secure + process permissions, like access to various filesystem directories. - In the Android scheme, each installed application gets its own uid_t/gid_t - starting from 10000; lower numerical ids are reserved for system daemons. + In the Android scheme, each installed application gets its own + uid_t/gid_t starting from 10000; lower numerical ids are reserved for + system daemons. - getpwnam() recognizes some hard-coded subsystems names (e.g. "radio") and - will translate them to their low-user-id values. It also recognizes "app_1234" - as the synthetic name of the application that was installed with uid 10000 + 1234, - which is 11234. getgrnam() works similarly + getpwnam() recognizes some hard-coded subsystems names (e.g. "radio") + and will translate them to their low-user-id values. It also recognizes + "app_1234" as the synthetic name of the application that was installed + with uid 10000 + 1234, which is 11234. getgrnam() works similarly - getgrouplist() will always return a single group for any user name, which is - the one passed as an input parameter. + getgrouplist() will always return a single group for any user name, + which is the one passed as an input parameter. - getgrgid() will similarly only return a structure that contains a single-element - members list, corresponding to the user with the same numerical value than the - group. + getgrgid() will similarly only return a structure that contains a + single-element members list, corresponding to the user with the same + numerical value than the group. See bionic/libc/bionic/stubs.c for more details. - getservent() - There is no /etc/services on Android. Instead the C library embeds a constant - list of services in its executable, which is parsed on demand by the various - functions that depend on it. See bionic/libc/netbsd/net/getservent.c and + There is no /etc/services on Android. Instead the C library embeds a + constant list of services in its executable, which is parsed on demand + by the various functions that depend on it. See + bionic/libc/netbsd/net/getservent.c and bionic/libc/netbsd/net/services.h - The list of services defined internally might change liberally in the future. - This feature is mostly historically and is very rarely used. + The list of services defined internally might change liberally in the + future. This feature is mostly historically and is very rarely used. - The getservent() returns thread-local data. getservbyport() and getservbyname() - are also implemented in a similar fashion. + The getservent() returns thread-local data. getservbyport() and + getservbyname() are also implemented in a similar fashion. - getprotoent() - There is no /etc/protocol on Android. Bionic does not currently implement - getprotoent() and related functions. If we add it, it will likely be done - in a way similar to getservent() + There is no /etc/protocol on Android. Bionic does not currently + implement getprotoent() and related functions. If added, it will + likely be done in a way similar to getservent() DNS resolver: - Bionic uses a NetBSD-derived resolver library which has been modified in the following - ways: + Bionic uses a NetBSD-derived resolver library which has been modified in + the following ways: - don't implement the name-server-switch feature (a.k.a. <nsswitch.h>) - read /system/etc/resolv.conf instead of /etc/resolv.conf - read the list of servers from system properties. the code looks for - 'net.dns1', 'net.dns2', etc.. Each property should contain the IP address - of a DNS server. + 'net.dns1', 'net.dns2', etc.. Each property should contain the IP + address of a DNS server. these properties are set/modified by other parts of the Android system (e.g. the dhcpd daemon). @@ -278,9 +289,9 @@ DNS resolver: - get rid of *many* unfortunate thread-safety issues in the original code - Bionic does *not* expose implementation details of its DNS resolver; the content - of <arpa/nameser.h> is intentionally blank. The resolver implementation might - change completely in the future. + Bionic does *not* expose implementation details of its DNS resolver; the + content of <arpa/nameser.h> is intentionally blank. The resolver + implementation might change completely in the future. PThread Real-Time Timers: @@ -294,8 +305,8 @@ PThread Real-Time Timers: timers with compatible properties are used. This means that if your code uses a lot of SIGEV_THREAD timers, your program - may consume a lot of memory. However, if your program needs many of these timers, - it'd better handle timeout events directly instead. + may consume a lot of memory. However, if your program needs many of these + timers, it'd better handle timeout events directly instead. Other timers (e.g. SIGEV_SIGNAL) are handled by the kernel and use much less system resources. @@ -303,58 +314,71 @@ PThread Real-Time Timers: Binary Compatibility: - Bionic is *not* in any way binary-compatible with the GNU C Library, ucLibc or any - known Linux C library. This means several things: + Bionic is *not* in any way binary-compatible with the GNU C Library, ucLibc + or any known Linux C library. This means several things: + + - You cannot expect to build something against the GNU C Library headers and + have it dynamically link properly to Bionic later. - - You cannot expect to build something against the GNU C Library headers and have - it dynamically link properly to Bionic later. + - You should *really* use the Android toolchain to build your program against + Bionic. The toolchain deals with many important details that are crucial + to get something working properly. - - You should *really* use the Android toolchain to build your program against Bionic. - The toolchain deals with many important details that are crucial to get something - working properly. + Failure to do so will usually result in the inability to run or link your + program, or even runtime crashes. Several random web pages on the Internet + describe how you can succesfully write a "hello-world" program with the + ARM GNU toolchain. These examples usually work by chance, if anything else, + and you should not follow these instructions unless you want to waste a lot + of your time in the process. - Failure to do so will usually result in the inability to run or link your program, - or even runtime crashes. Several random web pages on the Internet describe how you - can succesfully write a "hello-world" program with the ARM GNU toolchain. These - examples usually work by chance, if anything else, and you should not follow these - instructions unless you want to waste a lot of your time in the process. + Note however that you *can* generate a binary that is built against the + GNU C Library headers and then statically linked to it. The corresponding + executable should be able to run (if it doesn't use dlopen()/dlsym()) - Note however that you *can* generate a binary that is built against the GNU C Library - headers and then statically linked to it. The corresponding executable should be able - to run (if it doesn't use dlopen()/dlsym()) Dynamic Linker: - Bionic comes with its own dynamic linker (just like ld.so on Linux really comes from - GLibc). This linker does not support all the relocations generated by other GCC ARM - toolchains. + Bionic comes with its own dynamic linker (just like ld.so on Linux really + comes from GLibc). This linker does not support all the relocations + generated by other GCC ARM toolchains. + C++ Exceptions Support: - At the moment, Bionic doesn't support C++ exceptions, what this really means is the - following: + At the moment, Bionic doesn't support C++ exceptions, what this really means + is the following: - If pthread_once() is called with a C++ callback that throws an exception, - then the C library will keep the corresponding pthread_once_t mutex locked. - Any further call to pthread_once() will result in a deadlock. + then the C library will keep the corresponding pthread_once_t mutex + locked. Any further call to pthread_once() will result in a deadlock. - A proper implementation should be able to register a C++ exception cleanup - handler before the callback to properly unlock the pthread_once_t. Unfortunately - this requires tricky assembly code that is highly dependent on the compiler. + A proper implementation should be able to register a C++ exception + cleanup handler before the callback to properly unlock the + pthread_once_t. Unfortunately this requires tricky assembly code that + is highly dependent on the compiler. This feature is not planned to be supported anytime soon. - - The same problem may arise if you throw an exception within a callback called - from the C library. Fortunately, these cases are very rare in the real-world, - but any callback you provide to the C library should *not* throw an exception. + - The same problem may arise if you throw an exception within a callback + called from the C library. Fortunately, these cases are very rare in the + real-world, but any callback you provide to the C library should *not* + throw an exception. + + - Bionic lacks a few support functions to have exception support work + properly. + +System V IPCs: - - Bionic lacks a few support functions to have exception support work properly. + Bionic intentionally does not provide support for System-V IPCs mechanisms, + like the ones provided by semget(), shmget(), msgget(). The reason for this + is to avoid denial-of-service. For a detailed rationale about this, please + read the file docs/SYSV-IPCS.TXT. Include Paths: - The Android build system should automatically provide the necessary include paths - required to build against the C library headers. However, if you want to do that - yourself, you will need to add: + The Android build system should automatically provide the necessary include + paths required to build against the C library headers. However, if you want + to do that yourself, you will need to add: libc/arch-$ARCH/include libc/include diff --git a/libc/docs/SYSV-IPC.TXT b/libc/docs/SYSV-IPC.TXT new file mode 100644 index 0000000..5a3eef0 --- /dev/null +++ b/libc/docs/SYSV-IPC.TXT @@ -0,0 +1,103 @@ +Android does not support System V IPCs, i.e. the facilities provided by the +following standard Posix headers: + + <sys/sem.h> /* SysV semaphores */ + <sys/shm.h> /* SysV shared memory segments */ + <sys/msg.h> /* SysV message queues */ + <sys/ipc.h> /* General IPC definitions */ + +The reason for this is due to the fact that, by design, they lead to global +kernel resource leakage. + +For example, there is no way to automatically release a SysV semaphore +allocated in the kernel when: + +- a buggy or malicious process exits +- a non-buggy and non-malicious process crashes or is explicitely killed. + +Killing processes automatically to make room for new ones is an +important part of Android's application lifecycle implementation. This means +that, even assuming only non-buggy and non-malicious code, it is very likely +that over time, the kernel global tables used to implement SysV IPCs will fill +up. + +At that point, strange failures are likely to occur and prevent programs that +use them to run properly until the next reboot of the system. + +And we can't ignore potential malicious applications. As a proof of concept +here is a simple exploit that you can run on a standard Linux box today: + +--------------- cut here ------------------------ +#include <sys/sem.h> +#include <sys/wait.h> +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> + +#define NUM_SEMAPHORES 32 +#define MAX_FAILS 10 + +int main(void) +{ + int counter = 0; + int fails = 0; + + if (counter == IPC_PRIVATE) + counter++; + + printf( "%d (NUM_SEMAPHORES=%d)\n", counter, NUM_SEMAPHORES); + + for (;;) { + int ret = fork(); + int status; + + if (ret < 0) { + perror("fork:"); + break; + } + if (ret == 0) { + /* in the child */ + ret = semget( (key_t)counter, NUM_SEMAPHORES, IPC_CREAT ); + if (ret < 0) { + return errno; + } + return 0; + } + else { + /* in the parent */ + ret = wait(&status); + if (ret < 0) { + perror("waitpid:"); + break; + } + if (status != 0) { + status = WEXITSTATUS(status); + fprintf(stderr, "child %d FAIL at counter=%d: %d\n", ret, + counter, status); + if (++fails >= MAX_FAILS) + break; + } + } + + counter++; + if ((counter % 1000) == 0) { + printf("%d\n", counter); + } + if (counter == IPC_PRIVATE) + counter++; + } + return 0; +} +--------------- cut here ------------------------ + +If you run it on a typical Linux distribution today, you'll discover that it +will quickly fill up the kernel's table of unique key_t values, and that +strange things will happen in some parts of the system, but not all. + +(You can use the "ipcs -u" command to get a summary describing the kernel + tables and their allocations) + +For example, in our experience, anything program launched after that that +calls strerror() will simply crash. The USB sub-system starts spoutting weird +errors to the system console, etc... diff --git a/libc/include/sys/linux-syscalls.h b/libc/include/sys/linux-syscalls.h index bed00ce..7772f1e 100644 --- a/libc/include/sys/linux-syscalls.h +++ b/libc/include/sys/linux-syscalls.h @@ -170,17 +170,6 @@ #define __NR_getsockopt (__NR_SYSCALL_BASE + 295) #define __NR_sendmsg (__NR_SYSCALL_BASE + 296) #define __NR_recvmsg (__NR_SYSCALL_BASE + 297) -#define __NR_semctl (__NR_SYSCALL_BASE + 300) -#define __NR_semget (__NR_SYSCALL_BASE + 299) -#define __NR_semop (__NR_SYSCALL_BASE + 298) -#define __NR_shmat (__NR_SYSCALL_BASE + 305) -#define __NR_shmctl (__NR_SYSCALL_BASE + 308) -#define __NR_shmdt (__NR_SYSCALL_BASE + 306) -#define __NR_shmget (__NR_SYSCALL_BASE + 307) -#define __NR_msgctl (__NR_SYSCALL_BASE + 304) -#define __NR_msgget (__NR_SYSCALL_BASE + 303) -#define __NR_msgrcv (__NR_SYSCALL_BASE + 302) -#define __NR_msgsnd (__NR_SYSCALL_BASE + 301) #define __NR_epoll_create (__NR_SYSCALL_BASE + 250) #define __NR_epoll_ctl (__NR_SYSCALL_BASE + 251) #define __NR_epoll_wait (__NR_SYSCALL_BASE + 252) diff --git a/libc/include/sys/linux-unistd.h b/libc/include/sys/linux-unistd.h index 8539c7b..789271e 100644 --- a/libc/include/sys/linux-unistd.h +++ b/libc/include/sys/linux-unistd.h @@ -179,17 +179,6 @@ int sched_getparam (pid_t pid, struct sched_param *param); int sched_get_priority_max (int policy); int sched_get_priority_min (int policy); int sched_rr_get_interval (pid_t pid, struct timespec *interval); -int semctl (int semid, int semnum, int cmd, ...); -int semget (key_t key, int nsems, int semflg); -int semop (int semid, struct sembuf* sops, size_t nsops); -void* shmat (int shmid, const void* shmaddr, int shmflg); -int shmctl (int shmid, int cmd, struct shmid_ds* buf); -int shmdt (const void* shmaddr); -int shmget (key_t key, size_t size, int shmflg); -int msgctl (int msqid, int cmd, struct msqid_ds *buf); -int msgget (key_t key, int msgflg); -int msgrcv (int msqid, void* msgp, size_t msgsz, long int msgtyp, int msgflg); -int msgsnd (int msqid, const void* msgp, size_t msgsz, int msgflg); int uname (struct utsname *); pid_t __wait4 (pid_t pid, int *status, int options, struct rusage *rusage); mode_t umask (mode_t); diff --git a/libc/include/sys/msg.h b/libc/include/sys/msg.h deleted file mode 100644 index dd1b527..0000000 --- a/libc/include/sys/msg.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT - * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ -#ifndef _SYS_MSG_H -#define _SYS_MSG_H - -#include <sys/ipc.h> -#include <linux/msg.h> - -__BEGIN_DECLS - -extern int msgctl(int msqid, int cmd, struct msqid_ds *buf); -extern int msgget(key_t key, int msgflg); -extern int msgrcv(int msqid, void* msgp, size_t msgsz, long int msgtyp, int msgflg); -extern int msgsnd(int msqid, const void* msgp, size_t msgsz, int msgflg); - -__END_DECLS - -#endif /* _SYS_MSG_H */ diff --git a/libc/include/sys/shm.h b/libc/include/sys/shm.h deleted file mode 100644 index 495d33e..0000000 --- a/libc/include/sys/shm.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT - * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ -#ifndef _SYS_SHM_H -#define _SYS_SHM_H - -#include <sys/ipc.h> -#include <linux/shm.h> - -__BEGIN_DECLS - -extern void* shmat(int shmid, const void* shmaddr, int shmflg); -extern int shmctl(int shmid, int cmd, struct shmid_ds* buf); -extern int shmdt(const void* shmaddr); -extern int shmget(key_t key, size_t size, int shmflg); - -__END_DECLS - -#endif /* _SYS_SHM_H */ diff --git a/libc/kernel/common/linux/msm_audio.h b/libc/kernel/common/linux/msm_audio.h index 58dc6f3..9ac58aa 100644 --- a/libc/kernel/common/linux/msm_audio.h +++ b/libc/kernel/common/linux/msm_audio.h @@ -29,6 +29,10 @@ #define AUDIO_SET_EQ _IOW(AUDIO_IOCTL_MAGIC, 8, unsigned) #define AUDIO_SET_RX_IIR _IOW(AUDIO_IOCTL_MAGIC, 9, unsigned) #define AUDIO_SET_VOLUME _IOW(AUDIO_IOCTL_MAGIC, 10, unsigned) +#define AUDIO_ENABLE_AUDPRE _IOW(AUDIO_IOCTL_MAGIC, 11, unsigned) +#define AUDIO_SET_AGC _IOW(AUDIO_IOCTL_MAGIC, 12, unsigned) +#define AUDIO_SET_NS _IOW(AUDIO_IOCTL_MAGIC, 13, unsigned) +#define AUDIO_SET_TX_IIR _IOW(AUDIO_IOCTL_MAGIC, 14, unsigned) struct msm_audio_config { uint32_t buffer_size; diff --git a/libc/netbsd/gethnamaddr.c b/libc/netbsd/gethnamaddr.c index e6f919e..1c219b2 100644 --- a/libc/netbsd/gethnamaddr.c +++ b/libc/netbsd/gethnamaddr.c @@ -626,37 +626,12 @@ gethostbyname_internal(const char *name, int af, res_state res) break; } -#ifdef ANDROID_CHANGES - cache = __get_res_cache(); - if (cache != NULL) { - hp = _resolv_cache_lookup( cache, name, af ); - if (hp == _RESOLV_HOSTENT_NONE) { - h_errno = HOST_NOT_FOUND; - return NULL; - } - if (hp != NULL) { - h_errno = NETDB_SUCCESS; - return hp; - } - } -#endif - hp = NULL; h_errno = NETDB_INTERNAL; if (nsdispatch(&hp, dtab, NSDB_HOSTS, "gethostbyname", default_dns_files, name, strlen(name), af) != NS_SUCCESS) { -#ifdef ANDROID_CHANGES - /* cache negative DNS entry */ - if (h_errno == HOST_NOT_FOUND && cache != NULL) - _resolv_cache_add( cache, name, af, _RESOLV_HOSTENT_NONE ); -#endif return NULL; } -#ifdef ANDROID_CHANGES - if (cache != NULL) { - _resolv_cache_add( cache, name, af, hp ); - } -#endif h_errno = NETDB_SUCCESS; return hp; } diff --git a/libc/netbsd/resolv/res_cache.c b/libc/netbsd/resolv/res_cache.c index 210dfdd..2c912de 100644 --- a/libc/netbsd/resolv/res_cache.c +++ b/libc/netbsd/resolv/res_cache.c @@ -28,30 +28,104 @@ #include "resolv_cache.h" #include <stdlib.h> +#include <string.h> #include <time.h> #include "pthread.h" -/* this code implements a small DNS resolver cache for all gethostbyname* functions +/* This code implements a small and *simple* DNS resolver cache. * - * the cache is shared between all threads of the current process, but the result of - * a succesful lookup is always copied to a thread-local variable to honor the persistence - * rules of the gethostbyname*() APIs. + * It is only used to cache DNS answers for a maximum of CONFIG_SECONDS seconds + * in order to reduce DNS traffic. It is not supposed to be a full DNS cache, + * since we plan to implement that in the future in a dedicated process running + * on the system. + * + * Note that its design is kept simple very intentionally, i.e.: + * + * - it takes raw DNS query packet data as input, and returns raw DNS + * answer packet data as output + * + * (this means that two similar queries that encode the DNS name + * differently will be treated distinctly). + * + * - the TTLs of answer RRs are ignored. our DNS resolver library does not use + * them anyway, but it means that records with a TTL smaller than + * CONFIG_SECONDS will be kept in the cache anyway. + * + * this is bad, but we absolutely want to avoid parsing the answer packets + * (and should be solved by the later full DNS cache process). + * + * - the implementation is just a (query-data) => (answer-data) hash table + * with a trivial least-recently-used expiration policy. + * + * Doing this keeps the code simple and avoids to deal with a lot of things + * that a full DNS cache is expected to do. + * + * The API is also very simple: + * + * - the client calls _resolv_cache_get() to obtain a handle to the cache. + * this will initialize the cache on first usage. the result can be NULL + * if the cache is disabled. + * + * - the client calls _resolv_cache_lookup() before performing a query + * + * if the function returns RESOLV_CACHE_FOUND, a copy of the answer data + * has been copied into the client-provided answer buffer. + * + * if the function returns RESOLV_CACHE_NOTFOUND, the client should perform + * a request normally, *then* call _resolv_cache_add() to add the received + * answer to the cache. + * + * if the function returns RESOLV_CACHE_UNSUPPORTED, the client should + * perform a request normally, and *not* call _resolv_cache_add() + * + * note that RESOLV_CACHE_UNSUPPORTED is also returned if the answer buffer + * is too short to accomodate the cached result. + * + * - when network settings change, the cache must be flushed since the list + * of DNS servers probably changed. this is done by calling + * _resolv_cache_reset() + * + * the parameter to this function must be an ever-increasing generation + * number corresponding to the current network settings state. + * + * This is done because several threads could detect the same network + * settings change (but at different times) and will all end up calling the + * same function. Comparing with the last used generation number ensures + * that the cache is only flushed once per network change. */ -/* the name of an environment variable that will be checked the first time this code is called - * if its value is "0", then the resolver cache is disabled. +/* the name of an environment variable that will be checked the first time + * this code is called if its value is "0", then the resolver cache is + * disabled. */ #define CONFIG_ENV "BIONIC_DNSCACHE" -/* entries older than CONFIG_SECONDS seconds are always discarded. otherwise we could keep - * stale addresses in the cache and be oblivious to DNS server changes +/* entries older than CONFIG_SECONDS seconds are always discarded. */ #define CONFIG_SECONDS (60*10) /* 10 minutes */ -/* maximum number of entries kept in the cache. be frugal, this is the C library - * this MUST BE A POWER OF 2 +/* maximum number of entries kept in the cache. This value has been + * determined by browsing through various sites and counting the number + * of corresponding requests. Keep in mind that our framework is currently + * performing two requests per name lookup (one for IPv4, the other for IPv6) + * + * www.google.com 4 + * www.ysearch.com 6 + * www.amazon.com 8 + * www.nytimes.com 22 + * www.espn.com 28 + * www.msn.com 28 + * www.lemonde.fr 35 + * + * (determined in 2009-2-17 from Paris, France, results may vary depending + * on location) + * + * most high-level websites use lots of media/ad servers with different names + * but these are generally reused when browsing through the site. + * + * As such, a valud of 64 should be relatively conformtable at the moment. */ -#define CONFIG_MAX_ENTRIES 128 +#define CONFIG_MAX_ENTRIES 64 /****************************************************************************/ /****************************************************************************/ @@ -61,42 +135,204 @@ /****************************************************************************/ /****************************************************************************/ -#define DEBUG 0 +/* set to 1 to debug cache operations */ +#define DEBUG 0 + +/* set to 1 to debug query data */ +#define DEBUG_DATA 0 #if DEBUG -#include <fcntl.h> -#include <errno.h> -#include <stdarg.h> +# include <logd.h> +# define XLOG(...) \ + __libc_android_log_print(ANDROID_LOG_DEBUG,"libc",__VA_ARGS__) + #include <stdio.h> -static void -xlog( const char* fmt, ... ) +#include <stdarg.h> + +/** BOUNDED BUFFER FORMATTING + **/ + +/* technical note: + * + * the following debugging routines are used to append data to a bounded + * buffer they take two parameters that are: + * + * - p : a pointer to the current cursor position in the buffer + * this value is initially set to the buffer's address. + * + * - end : the address of the buffer's limit, i.e. of the first byte + * after the buffer. this address should never be touched. + * + * IMPORTANT: it is assumed that end > buffer_address, i.e. + * that the buffer is at least one byte. + * + * the _bprint_() functions return the new value of 'p' after the data + * has been appended, and also ensure the following: + * + * - the returned value will never be strictly greater than 'end' + * + * - a return value equal to 'end' means that truncation occured + * (in which case, end[-1] will be set to 0) + * + * - after returning from a _bprint_() function, the content of the buffer + * is always 0-terminated, even in the event of truncation. + * + * these conventions allow you to call _bprint_ functions multiple times and + * only check for truncation at the end of the sequence, as in: + * + * char buff[1000], *p = buff, *end = p + sizeof(buff); + * + * p = _bprint_c(p, end, '"'); + * p = _bprint_s(p, end, my_string); + * p = _bprint_c(p, end, '"'); + * + * if (p >= end) { + * // buffer was too small + * } + * + * printf( "%s", buff ); + */ + +/* add a char to a bounded buffer */ +static char* +_bprint_c( char* p, char* end, int c ) +{ + if (p < end) { + if (p+1 == end) + *p++ = 0; + else { + *p++ = (char) c; + *p = 0; + } + } + return p; +} + +/* add a sequence of bytes to a bounded buffer */ +static char* +_bprint_b( char* p, char* end, const char* buf, int len ) +{ + int avail = end - p; + + if (avail <= 0 || len <= 0) + return p; + + if (avail > len) + avail = len; + + memcpy( p, buf, avail ); + p += avail; + + if (p < end) + p[0] = 0; + else + end[-1] = 0; + + return p; +} + +/* add a string to a bounded buffer */ +static char* +_bprint_s( char* p, char* end, const char* str ) { - static int fd = -2; - int ret; + return _bprint_b(p, end, str, strlen(str)); +} + +/* add a formatted string to a bounded buffer */ +static char* +_bprint( char* p, char* end, const char* format, ... ) +{ + int avail, n; + va_list args; + + avail = end - p; + + if (avail <= 0) + return p; + + va_start(args, format); + n = snprintf( p, avail, format, args); + va_end(args); + + /* certain C libraries return -1 in case of truncation */ + if (n < 0 || n > avail) + n = avail; - if (fd == -2) { - do { - fd = open( "/data/dns.log", O_CREAT | O_APPEND | O_WRONLY, 0666 ); - } while (fd < 0 && errno == EINTR); + p += n; + /* certain C libraries do not zero-terminate in case of truncation */ + if (p == end) + p[-1] = 0; + + return p; +} + +/* add a hex value to a bounded buffer, up to 8 digits */ +static char* +_bprint_hex( char* p, char* end, unsigned value, int numDigits ) +{ + char text[sizeof(unsigned)*2]; + int nn = 0; + + while (numDigits-- > 0) { + text[nn++] = "0123456789abcdef"[(value >> (numDigits*4)) & 15]; } + return _bprint_b(p, end, text, nn); +} + +/* add the hexadecimal dump of some memory area to a bounded buffer */ +static char* +_bprint_hexdump( char* p, char* end, const uint8_t* data, int datalen ) +{ + int lineSize = 16; + + while (datalen > 0) { + int avail = datalen; + int nn; + + if (avail > lineSize) + avail = lineSize; + + for (nn = 0; nn < avail; nn++) { + if (nn > 0) + p = _bprint_c(p, end, ' '); + p = _bprint_hex(p, end, data[nn], 2); + } + for ( ; nn < lineSize; nn++ ) { + p = _bprint_s(p, end, " "); + } + p = _bprint_s(p, end, " "); - if (fd >= 0) { - char temp[128]; - va_list args; - va_start(args, fmt); - vsnprintf( temp, sizeof(temp), fmt, args); - va_end(args); + for (nn = 0; nn < avail; nn++) { + int c = data[nn]; - do { - ret = write( fd, temp, strlen(temp) ); - } while (ret == -1 && errno == EINTR); + if (c < 32 || c > 127) + c = '.'; + + p = _bprint_c(p, end, c); + } + p = _bprint_c(p, end, '\n'); + + data += avail; + datalen -= avail; } + return p; } -#define XLOG(...) xlog(__VA_ARGS__) -#else -#define XLOG(...) ((void)0) -#endif +/* dump the content of a query of packet to the log */ +static void +XLOG_BYTES( const void* base, int len ) +{ + char buff[1024]; + char* p = buff, *end = p + sizeof(buff); + + p = _bprint_hexdump(p, end, base, len); + XLOG("%s",buff); +} + +#else /* !DEBUG */ +# define XLOG(...) ((void)0) +# define XLOG_BYTES(a,b) ((void)0) +#endif static time_t _time_now( void ) @@ -107,96 +343,625 @@ _time_now( void ) return tv.tv_sec; } -/****************************************************************************/ -/****************************************************************************/ -/***** *****/ -/***** *****/ -/***** *****/ -/****************************************************************************/ -/****************************************************************************/ +/* reminder: the general format of a DNS packet is the following: + * + * HEADER (12 bytes) + * QUESTION (variable) + * ANSWER (variable) + * AUTHORITY (variable) + * ADDITIONNAL (variable) + * + * the HEADER is made of: + * + * ID : 16 : 16-bit unique query identification field + * + * QR : 1 : set to 0 for queries, and 1 for responses + * Opcode : 4 : set to 0 for queries + * AA : 1 : set to 0 for queries + * TC : 1 : truncation flag, will be set to 0 in queries + * RD : 1 : recursion desired + * + * RA : 1 : recursion available (0 in queries) + * Z : 3 : three reserved zero bits + * RCODE : 4 : response code (always 0=NOERROR in queries) + * + * QDCount: 16 : question count + * ANCount: 16 : Answer count (0 in queries) + * NSCount: 16: Authority Record count (0 in queries) + * ARCount: 16: Additionnal Record count (0 in queries) + * + * the QUESTION is made of QDCount Question Record (QRs) + * the ANSWER is made of ANCount RRs + * the AUTHORITY is made of NSCount RRs + * the ADDITIONNAL is made of ARCount RRs + * + * Each Question Record (QR) is made of: + * + * QNAME : variable : Query DNS NAME + * TYPE : 16 : type of query (A=1, PTR=12, MX=15, AAAA=28, ALL=255) + * CLASS : 16 : class of query (IN=1) + * + * Each Resource Record (RR) is made of: + * + * NAME : variable : DNS NAME + * TYPE : 16 : type of query (A=1, PTR=12, MX=15, AAAA=28, ALL=255) + * CLASS : 16 : class of query (IN=1) + * TTL : 32 : seconds to cache this RR (0=none) + * RDLENGTH: 16 : size of RDDATA in bytes + * RDDATA : variable : RR data (depends on TYPE) + * + * Each QNAME contains a domain name encoded as a sequence of 'labels' + * terminated by a zero. Each label has the following format: + * + * LEN : 8 : lenght of label (MUST be < 64) + * NAME : 8*LEN : label length (must exclude dots) + * + * A value of 0 in the encoding is interpreted as the 'root' domain and + * terminates the encoding. So 'www.android.com' will be encoded as: + * + * <3>www<7>android<3>com<0> + * + * Where <n> represents the byte with value 'n' + * + * Each NAME reflects the QNAME of the question, but has a slightly more + * complex encoding in order to provide message compression. This is achieved + * by using a 2-byte pointer, with format: + * + * TYPE : 2 : 0b11 to indicate a pointer, 0b01 and 0b10 are reserved + * OFFSET : 14 : offset to another part of the DNS packet + * + * The offset is relative to the start of the DNS packet and must point + * A pointer terminates the encoding. + * + * The NAME can be encoded in one of the following formats: + * + * - a sequence of simple labels terminated by 0 (like QNAMEs) + * - a single pointer + * - a sequence of simple labels terminated by a pointer + * + * A pointer shall always point to either a pointer of a sequence of + * labels (which can themselves be terminated by either a 0 or a pointer) + * + * The expanded length of a given domain name should not exceed 255 bytes. + * + * NOTE: we don't parse the answer packets, so don't need to deal with NAME + * records, only QNAMEs. + */ + +#define DNS_HEADER_SIZE 12 + +#define DNS_TYPE_A "\00\01" /* big-endian decimal 1 */ +#define DNS_TYPE_PTR "\00\014" /* big-endian decimal 12 */ +#define DNS_TYPE_MX "\00\017" /* big-endian decimal 15 */ +#define DNS_TYPE_AAAA "\00\034" /* big-endian decimal 28 */ +#define DNS_TYPE_ALL "\00\0377" /* big-endian decimal 255 */ + +#define DNS_CLASS_IN "\00\01" /* big-endian decimal 1 */ + +typedef struct { + const uint8_t* base; + const uint8_t* end; + const uint8_t* cursor; +} DnsPacket; + +static void +_dnsPacket_init( DnsPacket* packet, const uint8_t* buff, int bufflen ) +{ + packet->base = buff; + packet->end = buff + bufflen; + packet->cursor = buff; +} + +static void +_dnsPacket_rewind( DnsPacket* packet ) +{ + packet->cursor = packet->base; +} + +static void +_dnsPacket_skip( DnsPacket* packet, int count ) +{ + const uint8_t* p = packet->cursor + count; + + if (p > packet->end) + p = packet->end; + + packet->cursor = p; +} -/* used to define the content of _RESOLV_HOSTENT_NONE +static int +_dnsPacket_readInt16( DnsPacket* packet ) +{ + const uint8_t* p = packet->cursor; + + if (p+2 > packet->end) + return -1; + + packet->cursor = p+2; + return (p[0]<< 8) | p[1]; +} + +/** QUERY CHECKING + **/ + +/* check bytes in a dns packet. returns 1 on success, 0 on failure. + * the cursor is only advanced in the case of success */ -const struct hostent _resolv_hostent_none_cst = { - NULL, - NULL, - AF_INET, - 4, - NULL -}; +static int +_dnsPacket_checkBytes( DnsPacket* packet, int numBytes, const void* bytes ) +{ + const uint8_t* p = packet->cursor; + + if (p + numBytes > packet->end) + return 0; + + if (memcmp(p, bytes, numBytes) != 0) + return 0; + + packet->cursor = p + numBytes; + return 1; +} -struct hostent* -_resolv_hostent_copy( struct hostent* hp ) +/* parse and skip a given QNAME stored in a query packet, + * from the current cursor position. returns 1 on success, + * or 0 for malformed data. + */ +static int +_dnsPacket_checkQName( DnsPacket* packet ) { - struct hostent* dst; - int nn, len; - char* p; - int num_aliases = 0, num_addresses = 0; + const uint8_t* p = packet->cursor; + const uint8_t* end = packet->end; - if (hp == NULL) - return NULL; + for (;;) { + int c; - if (hp == _RESOLV_HOSTENT_NONE) - return hp; + if (p >= end) + break; - len = sizeof(*hp); - len += strlen(hp->h_name) + 1; + c = *p++; - if (hp->h_aliases != NULL) { - for (nn = 0; hp->h_aliases[nn] != NULL; nn++) - len += sizeof(char*) + strlen(hp->h_aliases[nn]) + 1; - num_aliases = nn; + if (c == 0) { + packet->cursor = p; + return 1; + } + + /* we don't expect label compression in QNAMEs */ + if (c >= 64) + break; + + p += c; + /* we rely on the bound check at the start + * of the loop here */ } - len += sizeof(char*); + /* malformed data */ + XLOG("malformed QNAME"); + return 0; +} - for (nn = 0; hp->h_addr_list[nn] != NULL; nn++) { - len += sizeof(char*) + hp->h_length; +/* parse and skip a given QR stored in a packet. + * returns 1 on success, and 0 on failure + */ +static int +_dnsPacket_checkQR( DnsPacket* packet ) +{ + int len; + + if (!_dnsPacket_checkQName(packet)) + return 0; + + /* TYPE must be one of the things we support */ + if (!_dnsPacket_checkBytes(packet, 2, DNS_TYPE_A) && + !_dnsPacket_checkBytes(packet, 2, DNS_TYPE_PTR) && + !_dnsPacket_checkBytes(packet, 2, DNS_TYPE_MX) && + !_dnsPacket_checkBytes(packet, 2, DNS_TYPE_AAAA) && + !_dnsPacket_checkBytes(packet, 2, DNS_TYPE_ALL)) + { + XLOG("unsupported TYPE"); + return 0; + } + /* CLASS must be IN */ + if (!_dnsPacket_checkBytes(packet, 2, DNS_CLASS_IN)) { + XLOG("unsupported CLASS"); + return 0; } - num_addresses = nn; - len += sizeof(char*); - dst = malloc( len ); - if (dst == NULL) - return NULL; + return 1; +} - dst->h_aliases = (char**)(dst + 1); - dst->h_addr_list = dst->h_aliases + num_aliases + 1; - dst->h_length = hp->h_length; - dst->h_addrtype = hp->h_addrtype; +/* check the header of a DNS Query packet, return 1 if it is one + * type of query we can cache, or 0 otherwise + */ +static int +_dnsPacket_checkQuery( DnsPacket* packet ) +{ + const uint8_t* p = packet->base; + int qdCount, anCount, dnCount, arCount; + + if (p + DNS_HEADER_SIZE > packet->end) { + XLOG("query packet too small"); + return 0; + } - p = (char*)(dst->h_addr_list + num_addresses + 1); + /* QR must be set to 0, opcode must be 0 and AA must be 0 */ + /* RA, Z, and RCODE must be 0 */ + if ((p[2] & 0xFC) != 0 || p[3] != 0) { + XLOG("query packet flags unsupported"); + return 0; + } - /* write the addresses first, to help with alignment issues */ - for (nn = 0; nn < num_addresses; nn++) { - dst->h_addr_list[nn] = p; - len = hp->h_length; - memcpy( p, hp->h_addr_list[nn], len ); - p += len; + /* Note that we ignore the TC and RD bits here for the + * following reasons: + * + * - there is no point for a query packet sent to a server + * to have the TC bit set, but the implementation might + * set the bit in the query buffer for its own needs + * between a _resolv_cache_lookup and a + * _resolv_cache_add. We should not freak out if this + * is the case. + * + * - we consider that the result from a RD=0 or a RD=1 + * query might be different, hence that the RD bit + * should be used to differentiate cached result. + * + * this implies that RD is checked when hashing or + * comparing query packets, but not TC + */ + + /* ANCOUNT, DNCOUNT and ARCOUNT must be 0 */ + qdCount = (p[4] << 8) | p[5]; + anCount = (p[6] << 8) | p[7]; + dnCount = (p[8] << 8) | p[9]; + arCount = (p[10]<< 8) | p[11]; + + if (anCount != 0 || dnCount != 0 || arCount != 0) { + XLOG("query packet contains non-query records"); + return 0; } - dst->h_addr_list[nn] = NULL; - for (nn = 0; nn < num_aliases; nn++) { - dst->h_aliases[nn] = p; - len = strlen(hp->h_aliases[nn]) + 1; - memcpy( p, hp->h_aliases[nn], len ); - p += len; + if (qdCount == 0) { + XLOG("query packet doesn't contain query record"); + return 0; } - dst->h_aliases[nn] = NULL; - dst->h_name = p; - len = strlen(hp->h_name) + 1; - memcpy(p, hp->h_name, len); - p += len; + /* Check QDCOUNT QRs */ + packet->cursor = p + DNS_HEADER_SIZE; + + for (;qdCount > 0; qdCount--) + if (!_dnsPacket_checkQR(packet)) + return 0; - return dst; + return 1; } +/** QUERY DEBUGGING + **/ +#if DEBUG +static char* +_dnsPacket_bprintQName(DnsPacket* packet, char* bp, char* bend) +{ + const uint8_t* p = packet->cursor; + const uint8_t* end = packet->end; + int first = 1; -void -_resolv_hostent_free( struct hostent* hp ) + for (;;) { + int c; + + if (p >= end) + break; + + c = *p++; + + if (c == 0) { + packet->cursor = p; + return bp; + } + + /* we don't expect label compression in QNAMEs */ + if (c >= 64) + break; + + if (first) + first = 0; + else + bp = _bprint_c(bp, bend, '.'); + + bp = _bprint_b(bp, bend, (const char*)p, c); + + p += c; + /* we rely on the bound check at the start + * of the loop here */ + } + /* malformed data */ + bp = _bprint_s(bp, bend, "<MALFORMED>"); + return bp; +} + +static char* +_dnsPacket_bprintQR(DnsPacket* packet, char* p, char* end) { - if (hp && hp != _RESOLV_HOSTENT_NONE) - free(hp); +#define QQ(x) { DNS_TYPE_##x, #x } + static const struct { + const char* typeBytes; + const char* typeString; + } qTypes[] = + { + QQ(A), QQ(PTR), QQ(MX), QQ(AAAA), QQ(ALL), + { NULL, NULL } + }; + int nn; + const char* typeString = NULL; + + /* dump QNAME */ + p = _dnsPacket_bprintQName(packet, p, end); + + /* dump TYPE */ + p = _bprint_s(p, end, " ("); + + for (nn = 0; qTypes[nn].typeBytes != NULL; nn++) { + if (_dnsPacket_checkBytes(packet, 2, qTypes[nn].typeBytes)) { + typeString = qTypes[nn].typeString; + break; + } + } + + if (typeString != NULL) + p = _bprint_s(p, end, typeString); + else { + int typeCode = _dnsPacket_readInt16(packet); + p = _bprint(p, end, "UNKNOWN-%d", typeCode); + } + + p = _bprint_c(p, end, ')'); + + /* skip CLASS */ + _dnsPacket_skip(packet, 2); + return p; +} + +/* this function assumes the packet has already been checked */ +static char* +_dnsPacket_bprintQuery( DnsPacket* packet, char* p, char* end ) +{ + int qdCount; + + if (packet->base[2] & 0x1) { + p = _bprint_s(p, end, "RECURSIVE "); + } + + _dnsPacket_skip(packet, 4); + qdCount = _dnsPacket_readInt16(packet); + _dnsPacket_skip(packet, 6); + + for ( ; qdCount > 0; qdCount-- ) { + p = _dnsPacket_bprintQR(packet, p, end); + } + return p; +} +#endif + + +/** QUERY HASHING SUPPORT + ** + ** THE FOLLOWING CODE ASSUMES THAT THE INPUT PACKET HAS ALREADY + ** BEEN SUCCESFULLY CHECKED. + **/ + +/* use 32-bit FNV hash function */ +#define FNV_MULT 16777619U +#define FNV_BASIS 2166136261U + +static unsigned +_dnsPacket_hashBytes( DnsPacket* packet, int numBytes, unsigned hash ) +{ + const uint8_t* p = packet->cursor; + const uint8_t* end = packet->end; + + while (numBytes > 0 && p < end) { + hash = hash*FNV_MULT ^ *p++; + } + packet->cursor = p; + return hash; +} + + +static unsigned +_dnsPacket_hashQName( DnsPacket* packet, unsigned hash ) +{ + const uint8_t* p = packet->cursor; + const uint8_t* end = packet->end; + + for (;;) { + int c; + + if (p >= end) { /* should not happen */ + XLOG("%s: INTERNAL_ERROR: read-overflow !!\n", __FUNCTION__); + break; + } + + c = *p++; + + if (c == 0) + break; + + if (c >= 64) { + XLOG("%s: INTERNAL_ERROR: malformed domain !!\n", __FUNCTION__); + break; + } + if (p + c >= end) { + XLOG("%s: INTERNAL_ERROR: simple label read-overflow !!\n", + __FUNCTION__); + break; + } + while (c > 0) { + hash = hash*FNV_MULT ^ *p++; + c -= 1; + } + } + packet->cursor = p; + return hash; +} + +static unsigned +_dnsPacket_hashQR( DnsPacket* packet, unsigned hash ) +{ + int len; + + hash = _dnsPacket_hashQName(packet, hash); + hash = _dnsPacket_hashBytes(packet, 4, hash); /* TYPE and CLASS */ + return hash; +} + +static unsigned +_dnsPacket_hashQuery( DnsPacket* packet ) +{ + unsigned hash = FNV_BASIS; + int count; + _dnsPacket_rewind(packet); + + /* we ignore the TC bit for reasons explained in + * _dnsPacket_checkQuery(). + * + * however we hash the RD bit to differentiate + * between answers for recursive and non-recursive + * queries. + */ + hash = hash*FNV_MULT ^ (packet->base[2] & 1); + + /* assume: other flags are 0 */ + _dnsPacket_skip(packet, 4); + + /* read QDCOUNT */ + count = _dnsPacket_readInt16(packet); + + /* assume: ANcount, NScount, ARcount are 0 */ + _dnsPacket_skip(packet, 6); + + /* hash QDCOUNT QRs */ + for ( ; count > 0; count-- ) + hash = _dnsPacket_hashQR(packet, hash); + + return hash; +} + + +/** QUERY COMPARISON + ** + ** THE FOLLOWING CODE ASSUMES THAT THE INPUT PACKETS HAVE ALREADY + ** BEEN SUCCESFULLY CHECKED. + **/ + +static int +_dnsPacket_isEqualDomainName( DnsPacket* pack1, DnsPacket* pack2 ) +{ + const uint8_t* p1 = pack1->cursor; + const uint8_t* end1 = pack1->end; + const uint8_t* p2 = pack2->cursor; + const uint8_t* end2 = pack2->end; + + for (;;) { + int c1, c2; + + if (p1 >= end1 || p2 >= end2) { + XLOG("%s: INTERNAL_ERROR: read-overflow !!\n", __FUNCTION__); + break; + } + c1 = *p1++; + c2 = *p2++; + if (c1 != c2) + break; + + if (c1 == 0) { + pack1->cursor = p1; + pack2->cursor = p2; + return 1; + } + if (c1 >= 64) { + XLOG("%s: INTERNAL_ERROR: malformed domain !!\n", __FUNCTION__); + break; + } + if ((p1+c1 > end1) || (p2+c1 > end2)) { + XLOG("%s: INTERNAL_ERROR: simple label read-overflow !!\n", + __FUNCTION__); + break; + } + if (memcmp(p1, p2, c1) != 0) + break; + p1 += c1; + p2 += c1; + /* we rely on the bound checks at the start of the loop */ + } + /* not the same, or one is malformed */ + XLOG("different DN"); + return 0; +} + +static int +_dnsPacket_isEqualBytes( DnsPacket* pack1, DnsPacket* pack2, int numBytes ) +{ + const uint8_t* p1 = pack1->cursor; + const uint8_t* p2 = pack2->cursor; + + if ( p1 + numBytes > pack1->end || p2 + numBytes > pack2->end ) + return 0; + + if ( memcmp(p1, p2, numBytes) != 0 ) + return 0; + + pack1->cursor += numBytes; + pack2->cursor += numBytes; + return 1; +} + +static int +_dnsPacket_isEqualQR( DnsPacket* pack1, DnsPacket* pack2 ) +{ + /* compare domain name encoding + TYPE + CLASS */ + if ( !_dnsPacket_isEqualDomainName(pack1, pack2) || + !_dnsPacket_isEqualBytes(pack1, pack2, 2+2) ) + return 0; + + return 1; +} + +static int +_dnsPacket_isEqualQuery( DnsPacket* pack1, DnsPacket* pack2 ) +{ + int count1, count2; + + /* compare the headers, ignore most fields */ + _dnsPacket_rewind(pack1); + _dnsPacket_rewind(pack2); + + /* compare RD, ignore TC, see comment in _dnsPacket_checkQuery */ + if ((pack1->base[2] & 1) != (pack2->base[2] & 1)) { + XLOG("different RD"); + return 0; + } + + /* assume: other flags are all 0 */ + _dnsPacket_skip(pack1, 4); + _dnsPacket_skip(pack2, 4); + + /* compare QDCOUNT */ + count1 = _dnsPacket_readInt16(pack1); + count2 = _dnsPacket_readInt16(pack2); + if (count1 != count2 || count1 < 0) { + XLOG("different QDCOUNT"); + return 0; + } + + /* assume: ANcount, NScount and ARcount are all 0 */ + _dnsPacket_skip(pack1, 6); + _dnsPacket_skip(pack2, 6); + + /* compare the QDCOUNT QRs */ + for ( ; count1 > 0; count1-- ) { + if (!_dnsPacket_isEqualQR(pack1, pack2)) { + XLOG("different QR"); + return 0; + } + } + return 1; } /****************************************************************************/ @@ -207,15 +972,23 @@ _resolv_hostent_free( struct hostent* hp ) /****************************************************************************/ /****************************************************************************/ +/* cache entry. for simplicity, 'hash' and 'hlink' are inlined in this + * structure though they are conceptually part of the hash table. + * + * similarly, mru_next and mru_prev are part of the global MRU list + */ typedef struct Entry { - unsigned int hash; - const char* name; - short af; - short index; + unsigned int hash; /* hash value */ + struct Entry* hlink; /* next in collision chain */ struct Entry* mru_prev; struct Entry* mru_next; - time_t when; - struct hostent* hp; + + const uint8_t* query; + int querylen; + const uint8_t* answer; + int answerlen; + time_t when; /* time_t when entry was added to table */ + int id; /* for debugging purpose */ } Entry; @@ -224,30 +997,10 @@ entry_free( Entry* e ) { /* everything is allocated in a single memory block */ if (e) { - _resolv_hostent_free(e->hp); free(e); } } -static void -entry_init_key( Entry* e, const char* name, int af ) -{ - unsigned h = 0; - const char* p = name; - - /* compute hash */ - p = name; - while (*p) { - h = h*33 + *p++; - } - h += af*17; - - e->hash = h; - e->name = name; - e->af = (short) af; -} - - static __inline__ void entry_mru_remove( Entry* e ) { @@ -267,46 +1020,75 @@ entry_mru_add( Entry* e, Entry* list ) first->mru_prev = e; } +/* compute the hash of a given entry, this is a hash of most + * data in the query (key) */ +static unsigned +entry_hash( const Entry* e ) +{ + DnsPacket pack[1]; + + _dnsPacket_init(pack, e->query, e->querylen); + return _dnsPacket_hashQuery(pack); +} +/* initialize an Entry as a search key, this also checks the input query packet + * returns 1 on success, or 0 in case of unsupported/malformed data */ +static int +entry_init_key( Entry* e, const void* query, int querylen ) +{ + DnsPacket pack[1]; + + memset(e, 0, sizeof(*e)); + + e->query = query; + e->querylen = querylen; + e->hash = entry_hash(e); + + _dnsPacket_init(pack, query, querylen); + + return _dnsPacket_checkQuery(pack); +} + +/* allocate a new entry as a cache node */ static Entry* -entry_alloc( const char* name, int af, int index, struct hostent* hp ) +entry_alloc( const Entry* init, const void* answer, int answerlen ) { Entry* e; - int num_aliases = 0; - int num_addresses = 0; - char** aliases; - char** addresses; + int size; - /* compute the length of the memory block that will contain everything */ - int len = sizeof(*e) + strlen(name)+1; - - e = malloc(len); + size = sizeof(*e) + init->querylen + answerlen; + e = calloc(size, 1); if (e == NULL) return e; - entry_init_key(e, name, af); + e->hash = init->hash; + e->query = (const uint8_t*)(e+1); + e->querylen = init->querylen; - e->mru_next = e->mru_prev = e; - e->index = (short) index; - e->when = _time_now(); - e->hp = _resolv_hostent_copy(hp); + memcpy( (char*)e->query, init->query, e->querylen ); - if (e->hp == NULL) { - free(e); - return NULL; - } + e->answer = e->query + e->querylen; + e->answerlen = answerlen; + + memcpy( (char*)e->answer, answer, e->answerlen ); + + e->when = _time_now(); - e->name = (char*)(e+1); - len = strlen(name)+1; - memcpy( (char*)e->name, name, len ); return e; } - -static __inline__ int +static int entry_equals( const Entry* e1, const Entry* e2 ) { - return e1->hash == e2->hash && e1->af == e2->af && !strcmp( e1->name, e2->name ); + DnsPacket pack1[1], pack2[1]; + + if (e1->querylen != e2->querylen) { + return 0; + } + _dnsPacket_init(pack1, e1->query, e1->querylen); + _dnsPacket_init(pack2, e2->query, e2->querylen); + + return _dnsPacket_isEqualQuery(pack1, pack2); } /****************************************************************************/ @@ -317,30 +1099,49 @@ entry_equals( const Entry* e1, const Entry* e2 ) /****************************************************************************/ /****************************************************************************/ +/* We use a simple hash table with external collision lists + * for simplicity, the hash-table fields 'hash' and 'hlink' are + * inlined in the Entry structure. + */ #define MAX_HASH_ENTRIES (2*CONFIG_MAX_ENTRIES) typedef struct resolv_cache { - int num_entries; - Entry mru_list; - pthread_mutex_t lock; - int disabled; - Entry* entries[ MAX_HASH_ENTRIES ]; /* hash-table of pointers to entries */ + int num_entries; + Entry mru_list; + pthread_mutex_t lock; + unsigned generation; + int last_id; + Entry* entries[ MAX_HASH_ENTRIES ]; } Cache; -void -_resolv_cache_destroy( struct resolv_cache* cache ) +#define HTABLE_VALID(x) ((x) != NULL && (x) != HTABLE_DELETED) + +static void +_cache_flush_locked( Cache* cache ) { - if (cache != NULL) { - int nn; - for (nn = 0; nn < MAX_HASH_ENTRIES; nn++) { - entry_free(cache->entries[nn]); + int nn; + time_t now = _time_now(); + + for (nn = 0; nn < MAX_HASH_ENTRIES; nn++) + { + Entry** pnode = &cache->entries[nn]; + + while (*pnode != NULL) { + Entry* node = *pnode; + *pnode = node->hlink; + entry_free(node); } - pthread_mutex_destroy(&cache->lock); - free(cache); } -} + cache->mru_list.mru_next = cache->mru_list.mru_prev = &cache->mru_list; + cache->num_entries = 0; + cache->last_id = 0; + + XLOG("*************************\n" + "*** DNS CACHE FLUSHED ***\n" + "*************************"); +} struct resolv_cache* _resolv_cache_create( void ) @@ -349,116 +1150,203 @@ _resolv_cache_create( void ) cache = calloc(sizeof(*cache), 1); if (cache) { - const char* env = getenv(CONFIG_ENV); - - if (env && atoi(env) == 0) - cache->disabled = 1; - + cache->generation = ~0U; pthread_mutex_init( &cache->lock, NULL ); cache->mru_list.mru_prev = cache->mru_list.mru_next = &cache->mru_list; - XLOG("%s: cache=%p %s\n", __FUNCTION__, cache, cache->disabled ? "disabled" : "enabled" ); + XLOG("%s: cache created\n", __FUNCTION__); } return cache; } -static int -_resolv_cache_find_index( Cache* cache, - const char* name, - int af ) +#if DEBUG +static void +_dump_query( const uint8_t* query, int querylen ) { - Entry key; - int nn, step, tries; + char temp[256], *p=temp, *end=p+sizeof(temp); + DnsPacket pack[1]; - entry_init_key( &key, name, af ); + _dnsPacket_init(pack, query, querylen); + p = _dnsPacket_bprintQuery(pack, p, end); + XLOG("QUERY: %s", temp); +} - tries = MAX_HASH_ENTRIES; - nn = key.hash % MAX_HASH_ENTRIES; - step = 5; +static void +_cache_dump_mru( Cache* cache ) +{ + char temp[512], *p=temp, *end=p+sizeof(temp); + Entry* e; - while (tries > 0) { - Entry* key2 = cache->entries[nn]; + p = _bprint(temp, end, "MRU LIST (%2d): ", cache->num_entries); + for (e = cache->mru_list.mru_next; e != &cache->mru_list; e = e->mru_next) + p = _bprint(p, end, " %d", e->id); - if (key2 == NULL) { - return -(nn + 1); - } + XLOG("%s", temp); +} +#endif - if (entry_equals( &key, key2 ) ) { - return nn; - } +#if DEBUG +# define XLOG_QUERY(q,len) _dump_query((q), (len)) +#else +# define XLOG_QUERY(q,len) ((void)0) +#endif + +/* This function tries to find a key within the hash table + * In case of success, it will return a *pointer* to the hashed key. + * In case of failure, it will return a *pointer* to NULL + * + * So, the caller must check '*result' to check for success/failure. + * + * The main idea is that the result can later be used directly in + * calls to _resolv_cache_add or _resolv_cache_remove as the 'lookup' + * parameter. This makes the code simpler and avoids re-searching + * for the key position in the htable. + * + * The result of a lookup_p is only valid until you alter the hash + * table. + */ +static Entry** +_cache_lookup_p( Cache* cache, + Entry* key ) +{ + int index = key->hash % MAX_HASH_ENTRIES; + Entry** pnode = &cache->entries[ key->hash % MAX_HASH_ENTRIES ]; + + while (*pnode != NULL) { + Entry* node = *pnode; + + if (node == NULL) + break; - nn = (nn + step) % MAX_HASH_ENTRIES; - tries -= 1; + if (node->hash == key->hash && entry_equals(node, key)) + break; + + pnode = &node->hlink; } - return -(MAX_HASH_ENTRIES+1); + return pnode; } +/* Add a new entry to the hash table. 'lookup' must be the + * result of an immediate previous failed _lookup_p() call + * (i.e. with *lookup == NULL), and 'e' is the pointer to the + * newly created entry + */ +static void +_cache_add_p( Cache* cache, + Entry** lookup, + Entry* e ) +{ + *lookup = e; + e->id = ++cache->last_id; + entry_mru_add(e, &cache->mru_list); + cache->num_entries += 1; + + XLOG("%s: entry %d added (count=%d)", __FUNCTION__, + e->id, cache->num_entries); +} +/* Remove an existing entry from the hash table, + * 'lookup' must be the result of an immediate previous + * and succesful _lookup_p() call. + */ static void -_resolv_cache_remove( struct resolv_cache* cache, - Entry* e ) +_cache_remove_p( Cache* cache, + Entry** lookup ) { - XLOG("%s: name='%s' af=%d\n", __FUNCTION__, e->name, e->af); - cache->entries[ e->index ] = NULL; /* remove from hash table */ - entry_mru_remove( e ); - entry_free( e ); + Entry* e = *lookup; + + XLOG("%s: entry %d removed (count=%d)", __FUNCTION__, + e->id, cache->num_entries-1); + + entry_mru_remove(e); + *lookup = e->hlink; + entry_free(e); cache->num_entries -= 1; } - -struct hostent* -_resolv_cache_lookup( struct resolv_cache* cache, - const char* name, - int af ) +/* Remove the oldest entry from the hash table. + */ +static void +_cache_remove_oldest( Cache* cache ) { - int index; - struct hostent* result = NULL; + Entry* oldest = cache->mru_list.mru_prev; + Entry** lookup = _cache_lookup_p(cache, oldest); - if (cache->disabled) - return NULL; + if (*lookup == NULL) { /* should not happen */ + XLOG("%s: OLDEST NOT IN HTABLE ?", __FUNCTION__); + return; + } + _cache_remove_p(cache, lookup); +} + +ResolvCacheStatus +_resolv_cache_lookup( struct resolv_cache* cache, + const void* query, + int querylen, + void* answer, + int answersize, + int *answerlen ) +{ + DnsPacket pack[1]; + Entry key[1]; + int index; + Entry** lookup; + Entry* e; + time_t now; + + ResolvCacheStatus result = RESOLV_CACHE_NOTFOUND; + + XLOG("%s: lookup", __FUNCTION__); + XLOG_QUERY(query, querylen); + + /* we don't cache malformed queries */ + if (!entry_init_key(key, query, querylen)) { + XLOG("%s: unsupported query", __FUNCTION__); + return RESOLV_CACHE_UNSUPPORTED; + } + /* lookup cache */ pthread_mutex_lock( &cache->lock ); - XLOG( "%s: cache=%p name='%s' af=%d ", __FUNCTION__, cache, name, af ); - index = _resolv_cache_find_index( cache, name, af ); - if (index >= 0) { - Entry* e = cache->entries[index]; - time_t now = _time_now(); - struct hostent** pht; + /* see the description of _lookup_p to understand this. + * the function always return a non-NULL pointer. + */ + lookup = _cache_lookup_p(cache, key); + e = *lookup; - /* ignore stale entries, they will be discarded in _resolv_cache_add */ - if ( (unsigned)(now - e->when) >= CONFIG_SECONDS ) { - XLOG( " OLD\n" ); - goto Exit; - } + if (e == NULL) { + XLOG( "NOT IN CACHE"); + goto Exit; + } - /* bump up this entry to the top of the MRU list */ - if (e != cache->mru_list.mru_next) { - entry_mru_remove( e ); - entry_mru_add( e, &cache->mru_list ); - } + now = _time_now(); - /* now copy the result into a thread-local variable */ - pht = __get_res_cache_hostent_p(); - if (pht == NULL) { - XLOG( " NOTLS\n" ); /* shouldn't happen */ - goto Exit; - } + /* remove stale entries here */ + if ( (unsigned)(now - e->when) >= CONFIG_SECONDS ) { + XLOG( " NOT IN CACHE (STALE ENTRY %p DISCARDED)", *lookup ); + _cache_remove_p(cache, lookup); + goto Exit; + } - if (pht[0]) { - _resolv_hostent_free( pht[0] ); /* clear previous value */ - pht[0] = NULL; - } - result = _resolv_hostent_copy( e->hp ); - if (result == NULL) { - XLOG( " NOMEM\n" ); /* bummer */ - goto Exit; - } - XLOG( " OK\n" ); - pht[0] = result; + *answerlen = e->answerlen; + if (e->answerlen > answersize) { + /* NOTE: we return UNSUPPORTED if the answer buffer is too short */ + result = RESOLV_CACHE_UNSUPPORTED; + XLOG(" ANSWER TOO LONG"); goto Exit; } - XLOG( " KO\n" ); + + memcpy( answer, e->answer, e->answerlen ); + + /* bump up this entry to the top of the MRU list */ + if (e != cache->mru_list.mru_next) { + entry_mru_remove( e ); + entry_mru_add( e, &cache->mru_list ); + } + + XLOG( "FOUND IN CACHE entry=%p", e ); + result = RESOLV_CACHE_FOUND; + Exit: pthread_mutex_unlock( &cache->lock ); return result; @@ -467,42 +1355,59 @@ Exit: void _resolv_cache_add( struct resolv_cache* cache, - const char* name, - int af, - struct hostent* hp ) + const void* query, + int querylen, + const void* answer, + int answerlen ) { + Entry key[1]; Entry* e; - int index; + Entry** lookup; - if (cache->disabled) + /* don't assume that the query has already been cached + */ + if (!entry_init_key( key, query, querylen )) { + XLOG( "%s: passed invalid query ?", __FUNCTION__); return; + } pthread_mutex_lock( &cache->lock ); - XLOG( "%s: cache=%p name='%s' af=%d\n", __FUNCTION__, cache, name, af); + XLOG( "%s: query:", __FUNCTION__ ); + XLOG_QUERY(query,querylen); +#if DEBUG_DATA + XLOG( "answer:"); + XLOG_BYTES(answer,answerlen); +#endif + + lookup = _cache_lookup_p(cache, key); + e = *lookup; - /* get rid of the oldest entry if needed */ - if (cache->num_entries >= CONFIG_MAX_ENTRIES) { - Entry* oldest = cache->mru_list.mru_prev; - _resolv_cache_remove( cache, oldest ); + if (e != NULL) { /* should not happen */ + XLOG("%s: ALREADY IN CACHE (%p) ? IGNORING ADD", + __FUNCTION__, e); + goto Exit; } - index = _resolv_cache_find_index( cache, name, af ); - if (index >= 0) { - /* discard stale entry */ - _resolv_cache_remove( cache, cache->entries[index] ); - } else { - index = -(index+1); - if (index >= MAX_HASH_ENTRIES) - goto Exit; /* should not happen */ + if (cache->num_entries >= CONFIG_MAX_ENTRIES) { + _cache_remove_oldest(cache); + /* need to lookup again */ + lookup = _cache_lookup_p(cache, key); + e = *lookup; + if (e != NULL) { + XLOG("%s: ALREADY IN CACHE (%p) ? IGNORING ADD", + __FUNCTION__, e); + goto Exit; + } } - e = entry_alloc( name, af, index, hp ); + e = entry_alloc( key, answer, answerlen ); if (e != NULL) { - entry_mru_add( e, &cache->mru_list ); - cache->entries[index] = e; - cache->num_entries += 1; + _cache_add_p(cache, lookup, e); } +#if DEBUG + _cache_dump_mru(cache); +#endif Exit: pthread_mutex_unlock( &cache->lock ); } @@ -521,6 +1426,13 @@ static pthread_once_t _res_cache_once; static void _res_cache_init( void ) { + const char* env = getenv(CONFIG_ENV); + + if (env && atoi(env) == 0) { + /* the cache is disabled */ + return; + } + _res_cache = _resolv_cache_create(); } @@ -531,3 +1443,19 @@ __get_res_cache( void ) pthread_once( &_res_cache_once, _res_cache_init ); return _res_cache; } + +void +_resolv_cache_reset( unsigned generation ) +{ + XLOG("%s: generation=%d", __FUNCTION__, generation); + + if (_res_cache == NULL) + return; + + pthread_mutex_lock( &_res_cache->lock ); + if (_res_cache->generation != generation) { + _cache_flush_locked(_res_cache); + _res_cache->generation = generation; + } + pthread_mutex_unlock( &_res_cache->lock ); +} diff --git a/libc/netbsd/resolv/res_send.c b/libc/netbsd/resolv/res_send.c index 24b740a..3aca760 100644 --- a/libc/netbsd/resolv/res_send.c +++ b/libc/netbsd/resolv/res_send.c @@ -81,6 +81,9 @@ __RCSID("$NetBSD: res_send.c,v 1.9 2006/01/24 17:41:25 christos Exp $"); #endif #endif /* LIBC_SCCS and not lint */ +/* set to 1 to use our small/simple/limited DNS cache */ +#define USE_RESOLV_CACHE 1 + /* * Send query to name server and wait for reply. */ @@ -111,6 +114,10 @@ __RCSID("$NetBSD: res_send.c,v 1.9 2006/01/24 17:41:25 christos Exp $"); #include <isc/eventlib.h> +#if USE_RESOLV_CACHE +# include <resolv_cache.h> +#endif + #ifndef DE_CONST #define DE_CONST(c,v) v = ((c) ? \ strchr((const void *)(c), *(const char *)(const void *)(c)) : NULL) @@ -344,12 +351,17 @@ res_queriesmatch(const u_char *buf1, const u_char *eom1, return (1); } + int res_nsend(res_state statp, const u_char *buf, int buflen, u_char *ans, int anssiz) { int gotsomewhere, terrno, try, v_circuit, resplen, ns, n; char abuf[NI_MAXHOST]; +#if USE_RESOLV_CACHE + struct resolv_cache* cache; + ResolvCacheStatus cache_status = RESOLV_CACHE_UNSUPPORTED; +#endif if (statp->nscount == 0) { errno = ESRCH; @@ -365,6 +377,20 @@ res_nsend(res_state statp, gotsomewhere = 0; terrno = ETIMEDOUT; +#if USE_RESOLV_CACHE + cache = __get_res_cache(); + if (cache != NULL) { + int anslen = 0; + cache_status = _resolv_cache_lookup( + cache, buf, buflen, + ans, anssiz, &anslen); + + if (cache_status == RESOLV_CACHE_FOUND) { + return anslen; + } + } +#endif + /* * If the ns_addr_list in the resolver context has changed, then * invalidate our cached copy and the associated timing data. @@ -534,6 +560,12 @@ res_nsend(res_state statp, (stdout, "%s", ""), ans, (resplen > anssiz) ? anssiz : resplen); +#if USE_RESOLV_CACHE + if (cache_status == RESOLV_CACHE_NOTFOUND) { + _resolv_cache_add(cache, buf, buflen, + ans, resplen); + } +#endif /* * If we have temporarily opened a virtual circuit, * or if we haven't been asked to keep a socket open, diff --git a/libc/netbsd/resolv/res_state.c b/libc/netbsd/resolv/res_state.c index 8f2851a..3a2301d 100644 --- a/libc/netbsd/resolv/res_state.c +++ b/libc/netbsd/resolv/res_state.c @@ -46,7 +46,6 @@ typedef struct { struct __res_state _nres[1]; unsigned _serial; struct prop_info* _pi; - struct hostent* _hostent; struct res_static _rstatic[1]; } _res_thread; @@ -66,9 +65,9 @@ _res_thread_alloc(void) if ( res_ninit( rt->_nres ) < 0 ) { free(rt); rt = NULL; + } else { + memset(rt->_rstatic, 0, sizeof rt->_rstatic); } - rt->_hostent = NULL; - memset(rt->_rstatic, 0, sizeof rt->_rstatic); } return rt; } @@ -93,7 +92,6 @@ _res_thread_free( void* _rt ) _res_thread* rt = _rt; _res_static_done(rt->_rstatic); - _resolv_hostent_free(rt->_hostent); res_ndestroy(rt->_nres); free(rt); } @@ -132,6 +130,7 @@ _res_thread_get(void) rt = NULL; pthread_setspecific( _res_key, rt ); } + _resolv_cache_reset(rt->_serial); return rt; } @@ -177,14 +176,6 @@ __res_put_state(res_state res) res=res; } -struct hostent** -__get_res_cache_hostent_p(void) -{ - _res_thread* rt = _res_thread_get(); - - return rt ? &rt->_hostent : NULL; -} - res_static __res_get_static(void) { diff --git a/libc/bionic/logd.h b/libc/private/logd.h index 671cb48..671cb48 100644 --- a/libc/bionic/logd.h +++ b/libc/private/logd.h diff --git a/libc/private/resolv_cache.h b/libc/private/resolv_cache.h index 8c25583..cd876fb 100644 --- a/libc/private/resolv_cache.h +++ b/libc/private/resolv_cache.h @@ -28,31 +28,39 @@ #ifndef _RESOLV_CACHE_H_ #define _RESOLV_CACHE_H_ -#include <netdb.h> - -const struct hostent _resolv_hostent_none; -#define _RESOLV_HOSTENT_NONE ((struct hostent*)&_resolv_hostent_none) - struct resolv_cache; /* forward */ -extern struct resolv_cache* __get_res_cache(void); -extern struct hostent** __get_res_cache_hostent_p(void); -extern struct resolv_cache* _resolv_cache_get( void ); - -extern struct resolv_cache* _resolv_cache_create( void ); +/* get cache instance, can be NULL if cache is disabled + * (e.g. through an environment variable) */ +extern struct resolv_cache* __get_res_cache(void); -extern void _resolv_cache_destroy( struct resolv_cache* cache ); +/* this gets called everytime we detect some changes in the DNS configuration + * and will flush the cache */ +extern void _resolv_cache_reset( unsigned generation ); -extern struct hostent* _resolv_cache_lookup( struct resolv_cache* cache, - const char* name, - int af ); +typedef enum { + RESOLV_CACHE_UNSUPPORTED, /* the cache can't handle that kind of queries */ + /* or the answer buffer is too small */ + RESOLV_CACHE_NOTFOUND, /* the cache doesn't know about this query */ + RESOLV_CACHE_FOUND /* the cache found the answer */ +} ResolvCacheStatus; -extern void _resolv_cache_add( struct resolv_cache* cache, - const char* name, - int af, - struct hostent* hp ); +extern ResolvCacheStatus +_resolv_cache_lookup( struct resolv_cache* cache, + const void* query, + int querylen, + void* answer, + int answersize, + int *answerlen ); -extern struct hostent* _resolv_hostent_copy( struct hostent* hp ); -extern void _resolv_hostent_free( struct hostent* hp ); +/* add a (query,answer) to the cache, only call if _resolv_cache_lookup + * did return RESOLV_CACHE_NOTFOUND + */ +extern void +_resolv_cache_add( struct resolv_cache* cache, + const void* query, + int querylen, + const void* answer, + int answerlen ); #endif /* _RESOLV_CACHE_H_ */ diff --git a/linker/linker.c b/linker/linker.c index 572f1d6..7b19835 100644 --- a/linker/linker.c +++ b/linker/linker.c @@ -1133,13 +1133,25 @@ static int reloc_library(soinfo *si, Elf32_Rel *rel, unsigned count) switch(type){ #if defined(ANDROID_ARM_LINKER) case R_ARM_JUMP_SLOT: + COUNT_RELOC(RELOC_ABSOLUTE); + MARK(rel->r_offset); + TRACE_TYPE(RELO, "%5d RELO JMP_SLOT %08x <- %08x %s\n", pid, + reloc, sym_addr, sym_name); + *((unsigned*)reloc) = sym_addr; + break; case R_ARM_GLOB_DAT: + COUNT_RELOC(RELOC_ABSOLUTE); + MARK(rel->r_offset); + TRACE_TYPE(RELO, "%5d RELO GLOB_DAT %08x <- %08x %s\n", pid, + reloc, sym_addr, sym_name); + *((unsigned*)reloc) = sym_addr; + break; case R_ARM_ABS32: COUNT_RELOC(RELOC_ABSOLUTE); MARK(rel->r_offset); TRACE_TYPE(RELO, "%5d RELO ABS %08x <- %08x %s\n", pid, reloc, sym_addr, sym_name); - *((unsigned*)reloc) = sym_addr; + *((unsigned*)reloc) += sym_addr; break; #elif defined(ANDROID_X86_LINKER) case R_386_JUMP_SLOT: @@ -1591,13 +1603,13 @@ static int link_image(soinfo *si, unsigned wr_offset) } #endif - /* If this is a SETUID programme, dup /dev/null to openned stdin, + /* If this is a SET?ID program, dup /dev/null to opened stdin, stdout and stderr to close a security hole described in: ftp://ftp.freebsd.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-02:23.stdio.asc */ - if (getuid() != geteuid()) + if (getuid() != geteuid() || getgid() != getegid()) nullify_closed_stdio (); call_constructors(si); notify_gdb_of_load(si); |