main/musl: upgrade to git snapshot of 2014-06-02

and remove the unneeded crosstool subpkg (applied only to uclibc)

2 files changed, 3464 insertions, 9 deletions

diff --git a/main/musl/0001-v1.1.1-to-76f440cf.patch b/main/musl/0001-v1.1.1-to-76f440cf.patch
new file mode 100644
index 0000000000..e4025585ef
--- /dev/null
+++ b/main/musl/0001-v1.1.1-to-76f440cf.patch
@@ -0,0 +1,3459 @@
+diff --git a/arch/arm/bits/syscall.h b/arch/arm/bits/syscall.h
+index dc54bde..0b6ea7d 100644
+--- a/arch/arm/bits/syscall.h
++++ b/arch/arm/bits/syscall.h
+@@ -333,6 +333,8 @@
+ #define __NR_process_vm_writev	377
+ #define __NR_kcmp		378
+ #define __NR_finit_module	379
++#define __NR_sched_setattr	380
++#define __NR_sched_getattr	381
+ 
+ 
+ /* Repeated with SYS_ prefix */
+@@ -672,3 +674,5 @@
+ #define SYS_process_vm_writev	377
+ #define SYS_kcmp		378
+ #define SYS_finit_module	379
++#define SYS_sched_setattr	380
++#define SYS_sched_getattr	381
+diff --git a/arch/i386/bits/syscall.h b/arch/i386/bits/syscall.h
+index 2af242b..7e48791 100644
+--- a/arch/i386/bits/syscall.h
++++ b/arch/i386/bits/syscall.h
+@@ -349,6 +349,8 @@
+ #define __NR_process_vm_writev	348
+ #define __NR_kcmp		349
+ #define __NR_finit_module	350
++#define __NR_sched_setattr	351
++#define __NR_sched_getattr	352
+ 
+ 
+ /* Repeated with SYS_ prefix */
+@@ -704,3 +706,5 @@
+ #define SYS_process_vm_writev	348
+ #define SYS_kcmp		349
+ #define SYS_finit_module	350
++#define SYS_sched_setattr	351
++#define SYS_sched_getattr	352
+diff --git a/arch/microblaze/bits/syscall.h b/arch/microblaze/bits/syscall.h
+index 712d47a..b8b1d2e 100644
+--- a/arch/microblaze/bits/syscall.h
++++ b/arch/microblaze/bits/syscall.h
+@@ -375,6 +375,8 @@
+ #define __NR_process_vm_writev 378
+ #define __NR_kcmp 379
+ #define __NR_finit_module 380
++#define __NR_sched_setattr 381
++#define __NR_sched_getattr 382
+ 
+ /* Repeated with SYS_ prefix */
+ 
+@@ -756,3 +758,5 @@
+ #define SYS_process_vm_writev 378
+ #define SYS_kcmp 379
+ #define SYS_finit_module 380
++#define SYS_sched_setattr 381
++#define SYS_sched_getattr 382
+diff --git a/arch/mips/bits/syscall.h b/arch/mips/bits/syscall.h
+index 574d603..f3d30d0 100644
+--- a/arch/mips/bits/syscall.h
++++ b/arch/mips/bits/syscall.h
+@@ -346,6 +346,8 @@
+ #define __NR_process_vm_writev       4346
+ #define __NR_kcmp                    4347
+ #define __NR_finit_module            4348
++#define __NR_sched_setattr           4349
++#define __NR_sched_getattr           4350
+ 
+ 
+ /* Repeated with SYS_ prefix */
+@@ -697,3 +699,5 @@
+ #define SYS_process_vm_writev       4346
+ #define SYS_kcmp                    4347
+ #define SYS_finit_module            4348
++#define SYS_sched_setattr           4349
++#define SYS_sched_getattr           4350
+diff --git a/arch/mips/syscall_arch.h b/arch/mips/syscall_arch.h
+index c52976e..e62c339 100644
+--- a/arch/mips/syscall_arch.h
++++ b/arch/mips/syscall_arch.h
+@@ -5,6 +5,8 @@
+ 
+ long (__syscall)(long, ...);
+ 
++#define SYSCALL_RLIM_INFINITY (-1UL/2)
++
+ #ifndef __clang__
+ 
+ #define __asm_syscall(...) do { \
+diff --git a/arch/powerpc/bits/syscall.h b/arch/powerpc/bits/syscall.h
+index 385860b..16f0abe 100644
+--- a/arch/powerpc/bits/syscall.h
++++ b/arch/powerpc/bits/syscall.h
+@@ -368,6 +368,8 @@
+ #define __NR_process_vm_writev     352
+ #define __NR_finit_module          353
+ #define __NR_kcmp                  354
++#define __NR_sched_setattr         355
++#define __NR_sched_getattr         356
+ 
+ /*
+  * repeated with SYS prefix
+@@ -742,3 +744,5 @@
+ #define SYS_process_vm_writev     352
+ #define SYS_finit_module          353
+ #define SYS_kcmp                  354
++#define SYS_sched_setattr         355
++#define SYS_sched_getattr         356
+diff --git a/arch/x32/bits/syscall.h b/arch/x32/bits/syscall.h
+index 95e2d2f..1c245e7 100644
+--- a/arch/x32/bits/syscall.h
++++ b/arch/x32/bits/syscall.h
+@@ -271,6 +271,9 @@
+ #define __NR_getcpu (__X32_SYSCALL_BIT + 309)
+ #define __NR_kcmp (__X32_SYSCALL_BIT + 312)
+ #define __NR_finit_module (__X32_SYSCALL_BIT + 313)
++#define __NR_sched_setattr (__X32_SYSCALL_BIT + 314)
++#define __NR_sched_getattr (__X32_SYSCALL_BIT + 315)
++
+ #define __NR_rt_sigaction (__X32_SYSCALL_BIT + 512)
+ #define __NR_rt_sigreturn (__X32_SYSCALL_BIT + 513)
+ #define __NR_ioctl (__X32_SYSCALL_BIT + 514)
+@@ -591,6 +594,9 @@
+ #define SYS_getcpu __NR_getcpu
+ #define SYS_kcmp __NR_kcmp
+ #define SYS_finit_module __NR_finit_module
++#define SYS_sched_setattr __NR_sched_setattr
++#define SYS_sched_getattr __NR_sched_getattr
++
+ #define SYS_rt_sigaction __NR_rt_sigaction
+ #define SYS_rt_sigreturn __NR_rt_sigreturn
+ #define SYS_ioctl __NR_ioctl
+diff --git a/arch/x86_64/bits/syscall.h b/arch/x86_64/bits/syscall.h
+index 5eb9b83..7bcb711 100644
+--- a/arch/x86_64/bits/syscall.h
++++ b/arch/x86_64/bits/syscall.h
+@@ -312,6 +312,8 @@
+ #define __NR_process_vm_writev			311
+ #define __NR_kcmp				312
+ #define __NR_finit_module			313
++#define __NR_sched_setattr			314
++#define __NR_sched_getattr			315
+ 
+ #undef __NR_fstatat
+ #undef __NR_pread
+@@ -641,6 +643,8 @@
+ #define SYS_process_vm_writev			311
+ #define SYS_kcmp				312
+ #define SYS_finit_module			313
++#define SYS_sched_setattr			314
++#define SYS_sched_getattr			315
+ 
+ #undef SYS_fstatat
+ #undef SYS_pread
+diff --git a/include/netinet/in.h b/include/netinet/in.h
+index ee6e19f..89188c7 100644
+--- a/include/netinet/in.h
++++ b/include/netinet/in.h
+@@ -198,6 +198,7 @@ uint16_t ntohs(uint16_t);
+ #define IP_ORIGDSTADDR     20
+ #define IP_RECVORIGDSTADDR IP_ORIGDSTADDR
+ #define IP_MINTTL          21
++#define IP_NODEFRAG        22
+ #define IP_MULTICAST_IF    32
+ #define IP_MULTICAST_TTL   33
+ #define IP_MULTICAST_LOOP  34
+@@ -218,6 +219,7 @@ uint16_t ntohs(uint16_t);
+ #define IP_PMTUDISC_DO     2
+ #define IP_PMTUDISC_PROBE  3
+ #define IP_PMTUDISC_INTERFACE 4
++#define IP_PMTUDISC_OMIT   5
+ 
+ #define IP_DEFAULT_MULTICAST_TTL        1
+ #define IP_DEFAULT_MULTICAST_LOOP       1
+@@ -351,9 +353,17 @@ struct ip6_mtuinfo
+ #define IPV6_RTHDR              57
+ #define IPV6_RECVDSTOPTS        58
+ #define IPV6_DSTOPTS            59
+-
++#define IPV6_RECVPATHMTU        60
++#define IPV6_PATHMTU            61
++#define IPV6_DONTFRAG           62
+ #define IPV6_RECVTCLASS         66
+ #define IPV6_TCLASS             67
++#define IPV6_ADDR_PREFERENCES   72
++#define IPV6_MINHOPCOUNT        73
++#define IPV6_ORIGDSTADDR        74
++#define IPV6_RECVORIGDSTADDR    IPV6_ORIGDSTADDR
++#define IPV6_TRANSPARENT        75
++#define IPV6_UNICAST_IF         76
+ 
+ #define IPV6_ADD_MEMBERSHIP     IPV6_JOIN_GROUP
+ #define IPV6_DROP_MEMBERSHIP    IPV6_LEAVE_GROUP
+@@ -364,6 +374,16 @@ struct ip6_mtuinfo
+ #define IPV6_PMTUDISC_WANT      1
+ #define IPV6_PMTUDISC_DO        2
+ #define IPV6_PMTUDISC_PROBE     3
++#define IPV6_PMTUDISC_INTERFACE 4
++#define IPV6_PMTUDISC_OMIT      5
++
++#define IPV6_PREFER_SRC_TMP            0x0001
++#define IPV6_PREFER_SRC_PUBLIC         0x0002
++#define IPV6_PREFER_SRC_PUBTMP_DEFAULT 0x0100
++#define IPV6_PREFER_SRC_COA            0x0004
++#define IPV6_PREFER_SRC_HOME           0x0400
++#define IPV6_PREFER_SRC_CGA            0x0008
++#define IPV6_PREFER_SRC_NONCGA         0x0800
+ 
+ #define IPV6_RTHDR_LOOSE        0
+ #define IPV6_RTHDR_STRICT       1
+diff --git a/include/sched.h b/include/sched.h
+index 105dac9..4394b64 100644
+--- a/include/sched.h
++++ b/include/sched.h
+@@ -38,6 +38,7 @@ int     sched_yield(void);
+ #define SCHED_RR 2
+ #define SCHED_BATCH 3
+ #define SCHED_IDLE 5
++#define SCHED_DEADLINE 6
+ #define SCHED_RESET_ON_FORK 0x40000000
+ 
+ #ifdef _GNU_SOURCE
+diff --git a/include/signal.h b/include/signal.h
+index 3fb21b2..c36e4d5 100644
+--- a/include/signal.h
++++ b/include/signal.h
+@@ -89,19 +89,24 @@ typedef struct {
+ 	union {
+ 		char __pad[128 - 2*sizeof(int) - sizeof(long)];
+ 		struct {
+-			pid_t si_pid;
+-			uid_t si_uid;
+-			union sigval si_sigval;
+-		} __rt;
+-		struct {
+-			unsigned int si_timer1, si_timer2;
+-		} __timer;
+-		struct {
+-			pid_t si_pid;
+-			uid_t si_uid;
+-			int si_status;
+-			clock_t si_utime, si_stime;
+-		} __sigchld;
++			union {
++				struct {
++					pid_t si_pid;
++					uid_t si_uid;
++				} __piduid;
++				struct {
++					int si_timerid;
++					int si_overrun;
++				} __timer;
++			} __first;
++			union {
++				union sigval si_value;
++				struct {
++					int si_status;
++					clock_t si_utime, si_stime;
++				} __sigchld;
++			} __second;
++		} __si_common;
+ 		struct {
+ 			void *si_addr;
+ 			short si_addr_lsb;
+@@ -117,20 +122,20 @@ typedef struct {
+ 		} __sigsys;
+ 	} __si_fields;
+ } siginfo_t;
+-#define si_pid     __si_fields.__sigchld.si_pid
+-#define si_uid     __si_fields.__sigchld.si_uid
+-#define si_status  __si_fields.__sigchld.si_status
+-#define si_utime   __si_fields.__sigchld.si_utime
+-#define si_stime   __si_fields.__sigchld.si_stime
+-#define si_value   __si_fields.__rt.si_sigval
++#define si_pid     __si_fields.__si_common.__first.__piduid.si_pid
++#define si_uid     __si_fields.__si_common.__first.__piduid.si_uid
++#define si_status  __si_fields.__si_common.__second.__sigchld.si_status
++#define si_utime   __si_fields.__si_common.__second.__sigchld.si_utime
++#define si_stime   __si_fields.__si_common.__second.__sigchld.si_stime
++#define si_value   __si_fields.__si_common.__second.si_value
+ #define si_addr    __si_fields.__sigfault.si_addr
+ #define si_addr_lsb __si_fields.__sigfault.si_addr_lsb
+ #define si_band    __si_fields.__sigpoll.si_band
+ #define si_fd      __si_fields.__sigpoll.si_fd
+-#define si_timer1  __si_fields.__timer.si_timer1
+-#define si_timer2  __si_fields.__timer.si_timer2
+-#define si_ptr     __si_fields.__rt.si_sigval.sival_ptr
+-#define si_int     __si_fields.__rt.si_sigval.sival_int
++#define si_timerid __si_fields.__si_common.__first.__timer.si_timerid
++#define si_overrun __si_fields.__si_common.__first.__timer.si_overrun
++#define si_ptr     si_value.sival_ptr
++#define si_int     si_value.sival_int
+ #define si_call_addr __si_fields.__sigsys.si_call_addr
+ #define si_syscall __si_fields.__sigsys.si_syscall
+ #define si_arch    __si_fields.__sigsys.si_arch
+diff --git a/include/sys/socket.h b/include/sys/socket.h
+index 8e8c9e9..d752791 100644
+--- a/include/sys/socket.h
++++ b/include/sys/socket.h
+@@ -203,6 +203,7 @@ struct linger
+ #define SO_SELECT_ERR_QUEUE     45
+ #define SO_BUSY_POLL            46
+ #define SO_MAX_PACING_RATE      47
++#define SO_BPF_EXTENSIONS       48
+ 
+ #ifndef SOL_SOCKET
+ #define SOL_SOCKET      1
+diff --git a/include/sys/types.h b/include/sys/types.h
+index 27170f6..f00db03 100644
+--- a/include/sys/types.h
++++ b/include/sys/types.h
+@@ -20,11 +20,6 @@ extern "C" {
+ #define __NEED_timer_t
+ #define __NEED_clockid_t
+ 
+-#define __NEED_int8_t
+-#define __NEED_int16_t
+-#define __NEED_int32_t
+-#define __NEED_int64_t
+-
+ #define __NEED_blkcnt_t
+ #define __NEED_fsblkcnt_t
+ #define __NEED_fsfilcnt_t
+@@ -49,19 +44,22 @@ extern "C" {
+ #define __NEED_pthread_key_t
+ #define __NEED_pthread_once_t
+ #define __NEED_useconds_t
+-#define __NEED_u_int64_t
+ 
+ #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
++#define __NEED_int8_t
++#define __NEED_int16_t
++#define __NEED_int32_t
++#define __NEED_int64_t
++#define __NEED_u_int64_t
+ #define __NEED_register_t
+ #endif
+ 
+ #include <bits/alltypes.h>
+ 
++#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+ typedef unsigned char u_int8_t;
+ typedef unsigned short u_int16_t;
+ typedef unsigned u_int32_t;
+-
+-#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+ typedef char *caddr_t;
+ typedef unsigned char u_char;
+ typedef unsigned short u_short, ushort;
+@@ -87,5 +85,3 @@ typedef unsigned long long u_quad_t;
+ }
+ #endif
+ #endif
+-
+-
+diff --git a/src/env/__libc_start_main.c b/src/env/__libc_start_main.c
+index 3498afb..c10a3f3 100644
+--- a/src/env/__libc_start_main.c
++++ b/src/env/__libc_start_main.c
+@@ -1,6 +1,7 @@
+ #include <elf.h>
+ #include <poll.h>
+ #include <fcntl.h>
++#include <signal.h>
+ #include "syscall.h"
+ #include "atomic.h"
+ #include "libc.h"
+@@ -48,9 +49,13 @@ void __init_libc(char **envp, char *pn)
+ 		&& !aux[AT_SECURE]) return;
+ 
+ 	struct pollfd pfd[3] = { {.fd=0}, {.fd=1}, {.fd=2} };
++#ifdef SYS_poll
+ 	__syscall(SYS_poll, pfd, 3, 0);
++#else
++	__syscall(SYS_ppoll, pfd, 3, &(struct timespec){0}, 0, _NSIG/8);
++#endif
+ 	for (i=0; i<3; i++) if (pfd[i].revents&POLLNVAL)
+-		if (__syscall(SYS_open, "/dev/null", O_RDWR|O_LARGEFILE)<0)
++		if (__sys_open("/dev/null", O_RDWR)<0)
+ 			a_crash();
+ 	libc.secure = 1;
+ }
+diff --git a/src/exit/exit.c b/src/exit/exit.c
+index 353f50b..695bdc0 100644
+--- a/src/exit/exit.c
++++ b/src/exit/exit.c
+@@ -1,8 +1,6 @@
+ #include <stdlib.h>
+ #include <stdint.h>
+ #include "libc.h"
+-#include "atomic.h"
+-#include "syscall.h"
+ 
+ static void dummy()
+ {
+@@ -21,11 +19,6 @@ extern void (*const __fini_array_end)() __attribute__((weak));
+ 
+ _Noreturn void exit(int code)
+ {
+-	static int lock;
+-
+-	/* If more than one thread calls exit, hang until _Exit ends it all */
+-	while (a_swap(&lock, 1)) __syscall(SYS_pause);
+-
+ 	__funcs_on_exit();
+ 
+ #ifndef SHARED
+diff --git a/src/exit/quick_exit.c b/src/exit/quick_exit.c
+index 1175d80..ada9134 100644
+--- a/src/exit/quick_exit.c
++++ b/src/exit/quick_exit.c
+@@ -1,6 +1,4 @@
+ #include <stdlib.h>
+-#include "syscall.h"
+-#include "atomic.h"
+ #include "libc.h"
+ 
+ static void dummy() { }
+@@ -8,8 +6,6 @@ weak_alias(dummy, __funcs_on_quick_exit);
+ 
+ _Noreturn void quick_exit(int code)
+ {
+-	static int lock;
+-	while (a_swap(&lock, 1)) __syscall(SYS_pause);
+ 	__funcs_on_quick_exit();
+ 	_Exit(code);
+ }
+diff --git a/src/fcntl/open.c b/src/fcntl/open.c
+index be44208..0594ed7 100644
+--- a/src/fcntl/open.c
++++ b/src/fcntl/open.c
+@@ -10,7 +10,7 @@ int open(const char *filename, int flags, ...)
+ 	va_start(ap, flags);
+ 	mode = va_arg(ap, mode_t);
+ 	va_end(ap);
+-	return syscall_cp(SYS_open, filename, flags|O_LARGEFILE, mode);
++	return sys_open_cp(filename, flags, mode);
+ }
+ 
+ LFS64(open);
+diff --git a/src/internal/syscall.h b/src/internal/syscall.h
+index 914b0d1..0a2840a 100644
+--- a/src/internal/syscall.h
++++ b/src/internal/syscall.h
+@@ -4,6 +4,10 @@
+ #include <sys/syscall.h>
+ #include "syscall_arch.h"
+ 
++#ifndef SYSCALL_RLIM_INFINITY
++#define SYSCALL_RLIM_INFINITY (~0ULL)
++#endif
++
+ #ifndef __scc
+ #define __scc(X) ((long) (X))
+ typedef long syscall_arg_t;
+@@ -122,14 +126,26 @@ long __syscall_ret(unsigned long), __syscall(syscall_arg_t, ...),
+ 
+ #ifdef SYS_stat64
+ #undef SYS_stat
+-#undef SYS_fstat
+-#undef SYS_lstat
+-#undef SYS_statfs
+-#undef SYS_fstatfs
+ #define SYS_stat SYS_stat64
++#endif
++
++#ifdef SYS_fstat64
++#undef SYS_fstat
+ #define SYS_fstat SYS_fstat64
++#endif
++
++#ifdef SYS_lstat64
++#undef SYS_lstat
+ #define SYS_lstat SYS_lstat64
++#endif
++
++#ifdef SYS_statfs64
++#undef SYS_statfs
+ #define SYS_statfs SYS_statfs64
++#endif
++
++#ifdef SYS_fstatfs64
++#undef SYS_fstatfs
+ #define SYS_fstatfs SYS_fstatfs64
+ #endif
+ 
+@@ -163,6 +179,9 @@ long __syscall_ret(unsigned long), __syscall(syscall_arg_t, ...),
+ #define SYS_fadvise SYS_fadvise64_64
+ #endif
+ 
++#ifdef SYS_sendfile64
++#undef SYS_sendfile
++#define SYS_sendfile SYS_sendfile64
+ #endif
+ 
+ /* socketcall calls */
+@@ -187,3 +206,23 @@ long __syscall_ret(unsigned long), __syscall(syscall_arg_t, ...),
+ #define __SC_accept4     18
+ #define __SC_recvmmsg    19
+ #define __SC_sendmmsg    20
++
++#ifdef SYS_open
++#define __sys_open2(x,pn,fl) __syscall2(SYS_open, pn, (fl)|O_LARGEFILE)
++#define __sys_open3(x,pn,fl,mo) __syscall3(SYS_open, pn, (fl)|O_LARGEFILE, mo)
++#define __sys_open_cp2(x,pn,fl) __syscall_cp2(SYS_open, pn, (fl)|O_LARGEFILE)
++#define __sys_open_cp3(x,pn,fl,mo) __syscall_cp3(SYS_open, pn, (fl)|O_LARGEFILE, mo)
++#else
++#define __sys_open2(x,pn,fl) __syscall3(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE)
++#define __sys_open3(x,pn,fl,mo) __syscall4(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
++#define __sys_open_cp2(x,pn,fl) __syscall_cp3(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE)
++#define __sys_open_cp3(x,pn,fl,mo) __syscall_cp4(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
++#endif
++
++#define __sys_open(...) __SYSCALL_DISP(__sys_open,,__VA_ARGS__)
++#define sys_open(...) __syscall_ret(__sys_open(__VA_ARGS__))
++
++#define __sys_open_cp(...) __SYSCALL_DISP(__sys_open_cp,,__VA_ARGS__)
++#define sys_open_cp(...) __syscall_ret(__sys_open_cp(__VA_ARGS__))
++
++#endif
+diff --git a/src/linux/epoll.c b/src/linux/epoll.c
+index 030786d..deff5b1 100644
+--- a/src/linux/epoll.c
++++ b/src/linux/epoll.c
+@@ -1,15 +1,20 @@
+ #include <sys/epoll.h>
+ #include <signal.h>
++#include <errno.h>
+ #include "syscall.h"
+ 
+ int epoll_create(int size)
+ {
+-	return syscall(SYS_epoll_create, size);
++	return epoll_create1(0);
+ }
+ 
+ int epoll_create1(int flags)
+ {
+-	return syscall(SYS_epoll_create1, flags);
++	int r = __syscall(SYS_epoll_create1, flags);
++#ifdef SYS_epoll_create
++	if (r==-ENOSYS && !flags) r = __syscall(SYS_epoll_create, 1);
++#endif
++	return __syscall_ret(r);
+ }
+ 
+ int epoll_ctl(int fd, int op, int fd2, struct epoll_event *ev)
+@@ -19,10 +24,14 @@ int epoll_ctl(int fd, int op, int fd2, struct epoll_event *ev)
+ 
+ int epoll_pwait(int fd, struct epoll_event *ev, int cnt, int to, const sigset_t *sigs)
+ {
+-	return syscall(SYS_epoll_pwait, fd, ev, cnt, to, sigs, _NSIG/8);
++	int r = __syscall(SYS_epoll_pwait, fd, ev, cnt, to, sigs, _NSIG/8);
++#ifdef SYS_epoll_wait
++	if (r==-ENOSYS && !sigs) r = __syscall(SYS_epoll_wait, fd, ev, cnt, to);
++#endif
++	return __syscall_ret(r);
+ }
+ 
+ int epoll_wait(int fd, struct epoll_event *ev, int cnt, int to)
+ {
+-	return syscall(SYS_epoll_wait, fd, ev, cnt, to);
++	return epoll_pwait(fd, ev, cnt, to, 0);
+ }
+diff --git a/src/linux/eventfd.c b/src/linux/eventfd.c
+index 5306648..68e489c 100644
+--- a/src/linux/eventfd.c
++++ b/src/linux/eventfd.c
+@@ -1,10 +1,15 @@
+ #include <sys/eventfd.h>
+ #include <unistd.h>
++#include <errno.h>
+ #include "syscall.h"
+ 
+ int eventfd(unsigned int count, int flags)
+ {
+-	return syscall(flags ? SYS_eventfd2 : SYS_eventfd, count, flags);
++	int r = __syscall(SYS_eventfd2, count, flags);
++#ifdef SYS_eventfd
++	if (r==-ENOSYS && !flags) r = __syscall(SYS_eventfd, count);
++#endif
++	return __syscall_ret(r);
+ }
+ 
+ int eventfd_read(int fd, eventfd_t *value)
+diff --git a/src/linux/inotify.c b/src/linux/inotify.c
+index a417c89..df5e48b 100644
+--- a/src/linux/inotify.c
++++ b/src/linux/inotify.c
+@@ -1,13 +1,18 @@
+ #include <sys/inotify.h>
++#include <errno.h>
+ #include "syscall.h"
+ 
+ int inotify_init()
+ {
+-	return syscall(SYS_inotify_init);
++	return inotify_init1(0);
+ }
+ int inotify_init1(int flags)
+ {
+-	return syscall(SYS_inotify_init1, flags);
++	int r = __syscall(SYS_inotify_init1, flags);
++#ifdef SYS_inotify_init
++	if (r==-ENOSYS && !flags) r = __syscall(SYS_inotify_init);
++#endif
++	return __syscall_ret(r);
+ }
+ 
+ int inotify_add_watch(int fd, const char *pathname, uint32_t mask)
+diff --git a/src/linux/prlimit.c b/src/linux/prlimit.c
+index d1639cc..0fe28e1 100644
+--- a/src/linux/prlimit.c
++++ b/src/linux/prlimit.c
+@@ -3,9 +3,24 @@
+ #include "syscall.h"
+ #include "libc.h"
+ 
++#define FIX(x) do{ if ((x)>=SYSCALL_RLIM_INFINITY) (x)=RLIM_INFINITY; }while(0)
++
+ int prlimit(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit)
+ {
+-	return syscall(SYS_prlimit64, pid, resource, new_limit, old_limit);
++	struct rlimit tmp;
++	int r;
++	if (new_limit && SYSCALL_RLIM_INFINITY != RLIM_INFINITY) {
++		tmp = *new_limit;
++		FIX(tmp.rlim_cur);
++		FIX(tmp.rlim_max);
++		new_limit = &tmp;
++	}
++	r = syscall(SYS_prlimit64, pid, resource, new_limit, old_limit);
++	if (!r && old_limit && SYSCALL_RLIM_INFINITY != RLIM_INFINITY) {
++		FIX(old_limit->rlim_cur);
++		FIX(old_limit->rlim_max);
++	}
++	return r;
+ }
+ 
+ #undef prlimit64
+diff --git a/src/linux/signalfd.c b/src/linux/signalfd.c
+index da6bced..4bf4332 100644
+--- a/src/linux/signalfd.c
++++ b/src/linux/signalfd.c
+@@ -7,6 +7,7 @@
+ int signalfd(int fd, const sigset_t *sigs, int flags)
+ {
+ 	int ret = __syscall(SYS_signalfd4, fd, sigs, _NSIG/8, flags);
++#ifdef SYS_signalfd
+ 	if (ret != -ENOSYS) return __syscall_ret(ret);
+ 	ret = __syscall(SYS_signalfd, fd, sigs, _NSIG/8);
+ 	if (ret >= 0) {
+@@ -15,5 +16,6 @@ int signalfd(int fd, const sigset_t *sigs, int flags)
+ 		if (flags & SFD_NONBLOCK)
+ 			__syscall(SYS_fcntl, ret, F_SETFL, O_NONBLOCK);
+ 	}
++#endif
+ 	return __syscall_ret(ret);
+ }
+diff --git a/src/linux/utimes.c b/src/linux/utimes.c
+index 70c0695..b814c88 100644
+--- a/src/linux/utimes.c
++++ b/src/linux/utimes.c
+@@ -1,7 +1,10 @@
+ #include <sys/time.h>
++#include "fcntl.h"
+ #include "syscall.h"
+ 
++int __futimesat(int, const char *, const struct timeval [2]);
++
+ int utimes(const char *path, const struct timeval times[2])
+ {
+-	return syscall(SYS_utimes, path, times);
++	return __futimesat(AT_FDCWD, path, times);
+ }
+diff --git a/src/misc/getrlimit.c b/src/misc/getrlimit.c
+index b7bbd06..b073677 100644
+--- a/src/misc/getrlimit.c
++++ b/src/misc/getrlimit.c
+@@ -3,16 +3,24 @@
+ #include "syscall.h"
+ #include "libc.h"
+ 
++#define FIX(x) do{ if ((x)>=SYSCALL_RLIM_INFINITY) (x)=RLIM_INFINITY; }while(0)
++
+ int getrlimit(int resource, struct rlimit *rlim)
+ {
+ 	unsigned long k_rlim[2];
+ 	int ret = syscall(SYS_prlimit64, 0, resource, 0, rlim);
++	if (!ret) {
++		FIX(rlim->rlim_cur);
++		FIX(rlim->rlim_max);
++	}
+ 	if (!ret || errno != ENOSYS)
+ 		return ret;
+ 	if (syscall(SYS_getrlimit, resource, k_rlim) < 0)
+ 		return -1;
+ 	rlim->rlim_cur = k_rlim[0] == -1UL ? RLIM_INFINITY : k_rlim[0];
+ 	rlim->rlim_max = k_rlim[1] == -1UL ? RLIM_INFINITY : k_rlim[1];
++	FIX(rlim->rlim_cur);
++	FIX(rlim->rlim_max);
+ 	return 0;
+ }
+ 
+diff --git a/src/misc/realpath.c b/src/misc/realpath.c
+index 4cc7e7d..88c849c 100644
+--- a/src/misc/realpath.c
++++ b/src/misc/realpath.c
+@@ -22,7 +22,7 @@ char *realpath(const char *restrict filename, char *restrict resolved)
+ 		return 0;
+ 	}
+ 
+-	fd = syscall(SYS_open, filename, O_PATH|O_NONBLOCK|O_CLOEXEC|O_LARGEFILE);
++	fd = sys_open(filename, O_PATH|O_NONBLOCK|O_CLOEXEC);
+ 	if (fd < 0) return 0;
+ 	__procfdname(buf, fd);
+ 
+diff --git a/src/misc/setrlimit.c b/src/misc/setrlimit.c
+index ddc13e9..8a1b8cc 100644
+--- a/src/misc/setrlimit.c
++++ b/src/misc/setrlimit.c
+@@ -4,14 +4,22 @@
+ #include "libc.h"
+ 
+ #define MIN(a, b) ((a)<(b) ? (a) : (b))
++#define FIX(x) do{ if ((x)>=SYSCALL_RLIM_INFINITY) (x)=RLIM_INFINITY; }while(0)
+ 
+ int __setrlimit(int resource, const struct rlimit *rlim)
+ {
+ 	unsigned long k_rlim[2];
++	struct rlimit tmp;
++	if (SYSCALL_RLIM_INFINITY != RLIM_INFINITY) {
++		tmp = *rlim;
++		FIX(tmp.rlim_cur);
++		FIX(tmp.rlim_max);
++		rlim = &tmp;
++	}
+ 	int ret = __syscall(SYS_prlimit64, 0, resource, rlim, 0);
+ 	if (ret != -ENOSYS) return ret;
+-	k_rlim[0] = MIN(rlim->rlim_cur, -1UL);
+-	k_rlim[1] = MIN(rlim->rlim_max, -1UL);
++	k_rlim[0] = MIN(rlim->rlim_cur, MIN(-1UL, SYSCALL_RLIM_INFINITY));
++	k_rlim[1] = MIN(rlim->rlim_max, MIN(-1UL, SYSCALL_RLIM_INFINITY));
+ 	return __syscall(SYS_setrlimit, resource, k_rlim);
+ }
+ 
+diff --git a/src/network/__dns.c b/src/network/__dns.c
+deleted file mode 100644
+index 97d8031..0000000
+--- a/src/network/__dns.c
++++ /dev/null
+@@ -1,282 +0,0 @@
+-#include <stdint.h>
+-#include <netdb.h>
+-#include <stdio.h>
+-#include <fcntl.h>
+-#include <limits.h>
+-#include <string.h>
+-#include <sys/socket.h>
+-#include <poll.h>
+-#include <netinet/in.h>
+-#include <time.h>
+-#include <ctype.h>
+-#include <unistd.h>
+-#include <pthread.h>
+-#include <errno.h>
+-#include "__dns.h"
+-#include "stdio_impl.h"
+-
+-#define TIMEOUT 5
+-#define RETRY 1000
+-#define PACKET_MAX 512
+-#define PTR_MAX (64 + sizeof ".in-addr.arpa")
+-
+-static void cleanup(void *p)
+-{
+-	close((intptr_t)p);
+-}
+-
+-int __dns_doqueries(unsigned char *dest, const char *name, int *rr, int rrcnt)
+-{
+-	time_t t0 = time(0);
+-	int fd;
+-	FILE *f, _f;
+-	unsigned char _buf[256];
+-	char line[64], *s, *z;
+-	union {
+-		struct sockaddr_in sin;
+-		struct sockaddr_in6 sin6;
+-	} sa = {0}, ns[3] = {{0}};
+-	socklen_t sl = sizeof sa.sin;
+-	int nns = 0;
+-	int family = AF_INET;
+-	unsigned char q[280] = "", *r = dest;
+-	int ql;
+-	int rlen;
+-	int got = 0, failed = 0;
+-	int errcode = EAI_AGAIN;
+-	int i, j;
+-	struct timespec ts;
+-	struct pollfd pfd;
+-	int id;
+-	int cs;
+-
+-	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+-
+-	/* Construct query template - RR and ID will be filled later */
+-	if (strlen(name)-1 >= 254U) return EAI_NONAME;
+-	q[2] = q[5] = 1;
+-	strcpy((char *)q+13, name);
+-	for (i=13; q[i]; i=j+1) {
+-		for (j=i; q[j] && q[j] != '.'; j++);
+-		if (j-i-1u > 62u) return EAI_NONAME;
+-		q[i-1] = j-i;
+-	}
+-	q[i+3] = 1;
+-	ql = i+4;
+-
+-	/* Make a reasonably unpredictable id */
+-	clock_gettime(CLOCK_REALTIME, &ts);
+-	id = ts.tv_nsec + ts.tv_nsec/65536UL & 0xffff;
+-
+-	/* Get nameservers from resolv.conf, fallback to localhost */
+-	f = __fopen_rb_ca("/etc/resolv.conf", &_f, _buf, sizeof _buf);
+-	if (f) for (nns=0; nns<3 && fgets(line, sizeof line, f); ) {
+-		if (strncmp(line, "nameserver", 10) || !isspace(line[10]))
+-			continue;
+-		for (s=line+11; isspace(*s); s++);
+-		for (z=s; *z && !isspace(*z); z++);
+-		*z=0;
+-		if (__ipparse(ns+nns, AF_UNSPEC, s) < 0) continue;
+-		ns[nns].sin.sin_port = htons(53);
+-		if (ns[nns++].sin.sin_family == AF_INET6) {
+-			family = AF_INET6;
+-			sl = sizeof sa.sin6;
+-		}
+-	}
+-	if (f) __fclose_ca(f);
+-	if (!nns) {
+-		ns[0].sin.sin_family = family = AF_INET;
+-		ns[0].sin.sin_port = htons(53);
+-		ns[0].sin.sin_addr.s_addr = htonl(0x7f000001);
+-		nns=1;
+-		sl = sizeof sa.sin;
+-	}
+-
+-	/* Get local address and open/bind a socket */
+-	sa.sin.sin_family = family;
+-	fd = socket(family, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
+-
+-	/* Handle case where system lacks IPv6 support */
+-	if (fd < 0 && errno == EAFNOSUPPORT) {
+-		if (family != AF_INET6) return EAI_SYSTEM;
+-		fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
+-		family = AF_INET;
+-	}
+-	if (fd < 0) return EAI_SYSTEM;
+-
+-	/* Convert any IPv4 addresses in a mixed environment to v4-mapped */
+-	if (family == AF_INET6) {
+-		setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){0}, sizeof 0);
+-		for (i=0; i<nns; i++) {
+-			if (ns[i].sin.sin_family != AF_INET) continue;
+-			memcpy(ns[i].sin6.sin6_addr.s6_addr+12,
+-				&ns[i].sin.sin_addr, 4);
+-			memcpy(ns[i].sin6.sin6_addr.s6_addr,
+-				"\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
+-			ns[i].sin6.sin6_family = AF_INET6;
+-			ns[i].sin6.sin6_flowinfo = 0;
+-			ns[i].sin6.sin6_scope_id = 0;
+-		}
+-	}
+-
+-	pthread_cleanup_push(cleanup, (void *)(intptr_t)fd);
+-	pthread_setcancelstate(cs, 0);
+-
+-	if (bind(fd, (void *)&sa, sl) < 0) {
+-		errcode = EAI_SYSTEM;
+-		goto out;
+-	}
+-
+-	pfd.fd = fd;
+-	pfd.events = POLLIN;
+-
+-	/* Loop until we timeout; break early on success */
+-	for (; time(0)-t0 < TIMEOUT; ) {
+-
+-		/* Query all configured namservers in parallel */
+-		for (i=0; i<rrcnt; i++) if (rr[i]) for (j=0; j<nns; j++) {
+-			q[0] = id+i >> 8;
+-			q[1] = id+i;
+-			q[ql-3] = rr[i];
+-			sendto(fd, q, ql, MSG_NOSIGNAL, (void *)&ns[j], sl);
+-		}
+-
+-		/* Wait for a response, or until time to retry */
+-		if (poll(&pfd, 1, RETRY) <= 0) continue;
+-
+-		/* Process any and all replies */
+-		while (got+failed < rrcnt && (rlen = recvfrom(fd, r, 512, 0,
+-			(void *)&sa, (socklen_t[1]){sl})) >= 2)
+-		{
+-			/* Ignore replies from addresses we didn't send to */
+-			for (i=0; i<nns; i++) if (!memcmp(ns+i, &sa, sl)) break;
+-			if (i==nns) continue;
+-
+-			/* Compute index of the query from id */
+-			i = r[0]*256+r[1] - id & 0xffff;
+-			if ((unsigned)i >= rrcnt || !rr[i]) continue;
+-
+-			/* Interpret the result code */
+-			switch (r[3] & 15) {
+-			case 0:
+-				got++;
+-				break;
+-			case 3:
+-				if (1) errcode = EAI_NONAME; else
+-			default:
+-				errcode = EAI_FAIL;
+-				failed++;
+-			}
+-
+-			/* Mark this record as answered */
+-			rr[i] = 0;
+-			r += 512;
+-		}
+-
+-		/* Check to see if we have answers to all queries */
+-		if (got+failed == rrcnt) break;
+-	}
+-out:
+-	pthread_cleanup_pop(1);
+-
+-	/* Return the number of results, or an error code if none */
+-	if (got) return got;
+-	return errcode;
+-}
+-
+-static void mkptr4(char *s, const unsigned char *ip)
+-{
+-	sprintf(s, "%d.%d.%d.%d.in-addr.arpa",
+-		ip[3], ip[2], ip[1], ip[0]);
+-}
+-
+-static void mkptr6(char *s, const unsigned char *ip)
+-{
+-	static const char xdigits[] = "0123456789abcdef";
+-	int i;
+-	for (i=15; i>=0; i--) {
+-		*s++ = xdigits[ip[i]&15]; *s++ = '.';
+-		*s++ = xdigits[ip[i]>>4]; *s++ = '.';
+-	}
+-	strcpy(s, "ip6.arpa");
+-}
+-
+-int __dns_query(unsigned char *r, const void *a, int family, int ptr)
+-{
+-	char buf[PTR_MAX];
+-	int rr[2], rrcnt = 1;
+-
+-	if (ptr) {
+-		if (family == AF_INET6) mkptr6(buf, a);
+-		else mkptr4(buf, a);
+-		rr[0] = RR_PTR;
+-		a = buf;
+-	} else if (family == AF_INET6) {
+-		rr[0] = RR_AAAA;
+-	} else {
+-		rr[0] = RR_A;
+-		if (family != AF_INET) rr[rrcnt++] = RR_AAAA;
+-	}
+-
+-	return __dns_doqueries(r, a, rr, rrcnt);
+-}
+-
+-int __dn_expand(const unsigned char *, const unsigned char *, const unsigned char *, char *, int);
+-
+-int __dns_get_rr(void *dest, size_t stride, size_t maxlen, size_t limit, const unsigned char *r, int rr, int dec)
+-{
+-	int qdcount, ancount;
+-	const unsigned char *p;
+-	char tmp[256];
+-	int found = 0;
+-	int len;
+-
+-	if ((r[3]&15)) return 0;
+-	p = r+12;
+-	qdcount = r[4]*256 + r[5];
+-	ancount = r[6]*256 + r[7];
+-	if (qdcount+ancount > 64) return -1;
+-	while (qdcount--) {
+-		while (p-r < 512 && *p-1U < 127) p++;
+-		if (*p>193 || (*p==193 && p[1]>254) || p>r+506)
+-			return -1;
+-		p += 5 + !!*p;
+-	}
+-	while (ancount--) {
+-		while (p-r < 512 && *p-1U < 127) p++;
+-		if (*p>193 || (*p==193 && p[1]>254) || p>r+506)
+-			return -1;
+-		p += 1 + !!*p;
+-		len = p[8]*256 + p[9];
+-		if (p+len > r+512) return -1;
+-		if (p[1]==rr && len <= maxlen) {
+-			if (dec && __dn_expand(r, r+512, p+10, tmp, sizeof tmp)<0)
+-				return -1;
+-			if (dest && limit) {
+-				if (dec) strcpy(dest, tmp);
+-				else memcpy(dest, p+10, len);
+-				dest = (char *)dest + stride;
+-				limit--;
+-			}
+-			found++;
+-		}
+-		p += 10 + len;
+-	}
+-	return found;
+-}
+-
+-int __dns_count_addrs(const unsigned char *r, int cnt)
+-{
+-	int found=0, res, i;
+-	static const int p[2][2] = { { 4, RR_A }, { 16, RR_AAAA } };
+-
+-	while (cnt--) {
+-		for (i=0; i<2; i++) {
+-			res = __dns_get_rr(0, 0, p[i][0], -1, r, p[i][1], 0);
+-			if (res < 0) return res;
+-			found += res;
+-		}
+-		r += 512;
+-	}
+-	return found;
+-}
+diff --git a/src/network/__dns.h b/src/network/__dns.h
+deleted file mode 100644
+index 9a3f740..0000000
+--- a/src/network/__dns.h
++++ /dev/null
+@@ -1,14 +0,0 @@
+-#include <stddef.h>
+-
+-#define RR_A 1
+-#define RR_CNAME 5
+-#define RR_PTR 12
+-#define RR_AAAA 28
+-
+-int __dns_count_addrs(const unsigned char *, int);
+-int __dns_get_rr(void *, size_t, size_t, size_t, const unsigned char *, int, int);
+-
+-int __dns_query(unsigned char *, const void *, int, int);
+-int __ipparse(void *, int, const char *);
+-
+-int __dns_doqueries(unsigned char *, const char *, int *, int);
+diff --git a/src/network/__ipparse.c b/src/network/__ipparse.c
+deleted file mode 100644
+index 79f3b8c..0000000
+--- a/src/network/__ipparse.c
++++ /dev/null
+@@ -1,51 +0,0 @@
+-#include <stdlib.h>
+-#include <ctype.h>
+-#include <sys/socket.h>
+-#include <netinet/in.h>
+-#include <arpa/inet.h>
+-#include "__dns.h"
+-
+-int __ipparse(void *dest, int family, const char *s0)
+-{
+-	const char *s = s0;
+-	unsigned char *d = dest;
+-	unsigned long a[16] = { 0 };
+-	char *z;
+-	int i;
+-
+-	if (family == AF_INET6) goto not_v4;
+-
+-	for (i=0; i<4; i++) {
+-		a[i] = strtoul(s, &z, 0);
+-		if (z==s || (*z && *z != '.') || !isdigit(*s)) {
+-			if (family == AF_INET) return -1;
+-			goto not_v4;
+-		}
+-		if (!*z) break;
+-		s=z+1;
+-	}
+-	if (i==4) return -1;
+-	switch (i) {
+-	case 0:
+-		a[1] = a[0] & 0xffffff;
+-		a[0] >>= 24;
+-	case 1:
+-		a[2] = a[1] & 0xffff;
+-		a[1] >>= 16;
+-	case 2:
+-		a[3] = a[2] & 0xff;
+-		a[2] >>= 8;
+-	}
+-	((struct sockaddr_in *)d)->sin_family = AF_INET;
+-	d = (void *)&((struct sockaddr_in *)d)->sin_addr;
+-	for (i=0; i<4; i++) {
+-		if (a[i] > 255) return -1;
+-		d[i] = a[i];
+-	}
+-	return 0;
+-
+-not_v4:
+-	s = s0;
+-	((struct sockaddr_in6 *)d)->sin6_family = AF_INET6;
+-	return inet_pton(AF_INET6, s, (void *)&((struct sockaddr_in6 *)d)->sin6_addr) <= 0 ? -1 : 0;
+-}
+diff --git a/src/network/dns_parse.c b/src/network/dns_parse.c
+new file mode 100644
+index 0000000..aa0d39f
+--- /dev/null
++++ b/src/network/dns_parse.c
+@@ -0,0 +1,31 @@
++#include <string.h>
++
++int __dns_parse(const unsigned char *r, int rlen, int (*callback)(void *, int, const void *, int, const void *), void *ctx)
++{
++	int qdcount, ancount;
++	const unsigned char *p;
++	int len;
++
++	if ((r[3]&15)) return 0;
++	p = r+12;
++	qdcount = r[4]*256 + r[5];
++	ancount = r[6]*256 + r[7];
++	if (qdcount+ancount > 64) return -1;
++	while (qdcount--) {
++		while (p-r < rlen && *p-1U < 127) p++;
++		if (*p>193 || (*p==193 && p[1]>254) || p>r+506)
++			return -1;
++		p += 5 + !!*p;
++	}
++	while (ancount--) {
++		while (p-r < rlen && *p-1U < 127) p++;
++		if (*p>193 || (*p==193 && p[1]>254) || p>r+506)
++			return -1;
++		p += 1 + !!*p;
++		len = p[8]*256 + p[9];
++		if (p+len > r+rlen) return -1;
++		if (callback(ctx, p[1], p+10, len, r) < 0) return -1;
++		p += 10 + len;
++	}
++	return 0;
++}
+diff --git a/src/network/getaddrinfo.c b/src/network/getaddrinfo.c
+index 5d45be7..70b6cfd 100644
+--- a/src/network/getaddrinfo.c
++++ b/src/network/getaddrinfo.c
+@@ -1,249 +1,115 @@
+ #include <stdlib.h>
+-#include <stdio.h>
+-#include <netdb.h>
+-#include <netinet/in.h>
+ #include <sys/socket.h>
+-#include <unistd.h>
++#include <netinet/in.h>
++#include <netdb.h>
+ #include <string.h>
+-#include <ctype.h>
+-#include "__dns.h"
+-#include "stdio_impl.h"
+-
+-static int is_valid(const char *host)
+-{
+-	const unsigned char *s;
+-	if (strlen(host)-1 > 254 || mbstowcs(0, host, 0) > 255) return 0;
+-	for (s=(void *)host; *s>=0x80 || *s=='.' || *s=='-' || isalnum(*s); s++);
+-	return !*s;
+-}
+-
+-#if 0
+-static int have_af(int family)
+-{
+-	struct sockaddr_in6 sin6 = { .sin6_family = family };
+-	socklen_t sl = family == AF_INET
+-		? sizeof(struct sockaddr_in)
+-		: sizeof(struct sockaddr_in6);
+-	int sock = socket(family, SOCK_STREAM, 0);
+-	int have = !bind(sock, (void *)&sin6, sl);
+-	close(sock);
+-	return have;
+-}
+-#endif
+-
+-union sa {
+-	struct sockaddr_in sin;
+-	struct sockaddr_in6 sin6;
+-};
+-
+-struct aibuf {
+-	struct addrinfo ai;
+-	union sa sa;
+-};
+-
+-/* Extra slots needed for storing canonical name */
+-#define EXTRA ((256+sizeof(struct aibuf)-1)/sizeof(struct aibuf))
++#include "lookup.h"
+ 
+ int getaddrinfo(const char *restrict host, const char *restrict serv, const struct addrinfo *restrict hint, struct addrinfo **restrict res)
+ {
+-	int flags = hint ? hint->ai_flags : 0;
+-	int family = hint ? hint->ai_family : AF_UNSPEC;
+-	int type = hint ? hint->ai_socktype : 0;
+-	int proto = hint ? hint->ai_protocol : 0;
+-	unsigned long port = 0;
+-	struct aibuf *buf;
+-	union sa sa = {{0}};
+-	unsigned char reply[1024];
+-	int i, j;
+-	char line[512];
+-	FILE *f, _f;
+-	unsigned char _buf[1024];
+-	char *z;
+-	int result;
+-	int cnt;
+-
+-	if (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC)
+-		return EAI_FAMILY;
+-
+-	if (host && strlen(host)>255) return EAI_NONAME;
+-	if (serv && strlen(serv)>32) return EAI_SERVICE;
+-
+-	if (type && !proto)
+-		proto = type==SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP;
+-	if (!type && proto)
+-		type = proto==IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
+-
+-	if (serv) {
+-		if (!*serv) return EAI_SERVICE;
+-		port = strtoul(serv, &z, 10);
+-		if (*z) {
+-			size_t servlen = strlen(serv);
+-			char *end = line;
+-
+-			if (flags & AI_NUMERICSERV) return EAI_SERVICE;
++	struct service ports[MAXSERVS];
++	struct address addrs[MAXADDRS];
++	char canon[256], *outcanon;
++	int nservs, naddrs, nais, canon_len, i, j, k;
++	int family = AF_UNSPEC, flags = 0, proto = 0;
++	struct aibuf {
++		struct addrinfo ai;
++		union sa {
++			struct sockaddr_in sin;
++			struct sockaddr_in6 sin6;
++		} sa;
++	} *out;
++
++	if (hint) {
++		family = hint->ai_family;
++		flags = hint->ai_flags;
++		proto = hint->ai_protocol;
++
++		const int mask = AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST |
++			AI_V4MAPPED | AI_ALL | AI_ADDRCONFIG | AI_NUMERICSERV;
++		if ((flags & mask) != flags)
++			return EAI_BADFLAGS;
++
++		switch (family) {
++		case AF_INET:
++		case AF_INET6:
++		case AF_UNSPEC:
++			break;
++		default:
++			return EAI_FAMILY;
++		}
+ 
+-			f = __fopen_rb_ca("/etc/services", &_f, _buf, sizeof _buf);
+-			if (!f) return EAI_SERVICE;
+-			while (fgets(line, sizeof line, f)) {
+-				if (strncmp(line, serv, servlen) || !isspace(line[servlen]))
+-					continue;
+-				port = strtoul(line+servlen, &end, 10);
+-				if (strncmp(end, proto==IPPROTO_UDP ? "/udp" : "/tcp", 4))
+-					continue;
++		switch (hint->ai_socktype) {
++		case SOCK_STREAM:
++			switch (proto) {
++			case 0:
++				proto = IPPROTO_TCP;
++			case IPPROTO_TCP:
+ 				break;
++			default:
++				return EAI_SERVICE;
+ 			}
+-			__fclose_ca(f);
+-			if (feof(f)) return EAI_SERVICE;
+-		}
+-		if (port > 65535) return EAI_SERVICE;
+-		port = htons(port);
+-	}
+-
+-	if (!host) {
+-		if (family == AF_UNSPEC) {
+-			cnt = 2; family = AF_INET;
+-		} else {
+-			cnt = 1;
+-		}
+-		buf = calloc(sizeof *buf, cnt);
+-		if (!buf) return EAI_MEMORY;
+-		for (i=0; i<cnt; i++) {
+-			if (i) family = AF_INET6;
+-			buf[i].ai.ai_protocol = proto;
+-			buf[i].ai.ai_socktype = type;
+-			buf[i].ai.ai_addr = (void *)&buf[i].sa;
+-			buf[i].ai.ai_addrlen = family==AF_INET6
+-				? sizeof sa.sin6 : sizeof sa.sin;
+-			buf[i].ai.ai_family = family;
+-			buf[i].sa.sin.sin_family = family;
+-			buf[i].sa.sin.sin_port = port;
+-			if (i+1<cnt) buf[i].ai.ai_next = &buf[i+1].ai;
+-			if (!(flags & AI_PASSIVE)) {
+-				if (family == AF_INET) {
+-					0[(uint8_t*)&buf[i].sa.sin.sin_addr.s_addr]=127;
+-					3[(uint8_t*)&buf[i].sa.sin.sin_addr.s_addr]=1;
+-				} else buf[i].sa.sin6.sin6_addr.s6_addr[15] = 1;
++			break;
++		case SOCK_DGRAM:
++			switch (proto) {
++			case 0:
++				proto = IPPROTO_UDP;
++			case IPPROTO_UDP:
++				break;
++			default:
++				return EAI_SERVICE;
+ 			}
++		case 0:
++			break;
++		default:
++			return EAI_SOCKTYPE;
+ 		}
+-		*res = &buf->ai;
+-		return 0;
+-	}
+-
+-	if (!*host) return EAI_NONAME;
+-
+-	/* Try as a numeric address */
+-	if (__ipparse(&sa, family, host) >= 0) {
+-		buf = calloc(sizeof *buf, 1+EXTRA);
+-		if (!buf) return EAI_MEMORY;
+-		family = sa.sin.sin_family;
+-		buf->ai.ai_protocol = proto;
+-		buf->ai.ai_socktype = type;
+-		buf->ai.ai_addr = (void *)&buf->sa;
+-		buf->ai.ai_addrlen = family==AF_INET6 ? sizeof sa.sin6 : sizeof sa.sin;
+-		buf->ai.ai_family = family;
+-		buf->ai.ai_canonname = (char *)host;
+-		buf->sa = sa;
+-		buf->sa.sin.sin_port = port;
+-		*res = &buf->ai;
+-		return 0;
+ 	}
+ 
+-	if (flags & AI_NUMERICHOST) return EAI_NONAME;
++	nservs = __lookup_serv(ports, serv, proto, flags);
++	if (nservs < 0) return nservs;
+ 
+-	f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
+-	if (f) while (fgets(line, sizeof line, f)) {
+-		char *p;
+-		size_t l = strlen(host);
++	naddrs = __lookup_name(addrs, canon, host, family, flags);
++	if (naddrs < 0) return naddrs;
+ 
+-		if ((p=strchr(line, '#'))) *p++='\n', *p=0;
+-		for(p=line+1; (p=strstr(p, host)) &&
+-			(!isspace(p[-1]) || !isspace(p[l])); p++);
+-		if (!p) continue;
+-		__fclose_ca(f);
+-
+-		/* Isolate IP address to parse */
+-		for (p=line; *p && !isspace(*p); p++);
+-		*p++ = 0;
+-		if (__ipparse(&sa, family, line) < 0) return EAI_NONAME;
+-
+-		/* Allocate and fill result buffer */
+-		buf = calloc(sizeof *buf, 1+EXTRA);
+-		if (!buf) return EAI_MEMORY;
+-		family = sa.sin.sin_family;
+-		buf->ai.ai_protocol = proto;
+-		buf->ai.ai_socktype = type;
+-		buf->ai.ai_addr = (void *)&buf->sa;
+-		buf->ai.ai_addrlen = family==AF_INET6 ? sizeof sa.sin6 : sizeof sa.sin;
+-		buf->ai.ai_family = family;
+-		buf->sa = sa;
+-		buf->sa.sin.sin_port = port;
+-
+-		/* Extract first name as canonical name */
+-		for (; *p && isspace(*p); p++);
+-		buf->ai.ai_canonname = (void *)(buf+1);
+-		snprintf(buf->ai.ai_canonname, 256, "%s", p);
+-		for (p=buf->ai.ai_canonname; *p && !isspace(*p); p++);
+-		*p = 0;
+-		if (!is_valid(buf->ai.ai_canonname))
+-			buf->ai.ai_canonname = 0;
+-
+-		*res = &buf->ai;
+-		return 0;
+-	}
+-	if (f) __fclose_ca(f);
++	nais = nservs * naddrs;
++	canon_len = strlen(canon);
++	out = calloc(1, nais * sizeof(*out) + canon_len + 1);
++	if (!out) return EAI_MEMORY;
+ 
+-#if 0
+-	f = __fopen_rb_ca("/etc/resolv.conf", &_f, _buf, sizeof _buf);
+-	if (f) while (fgets(line, sizeof line, f)) {
+-		if (!isspace(line[10]) || (strncmp(line, "search", 6)
+-			&& strncmp(line, "domain", 6))) continue;
++	if (canon_len) {
++		outcanon = (void *)&out[nais];
++		memcpy(outcanon, canon, canon_len+1);
++	} else {
++		outcanon = 0;
+ 	}
+-	if (f) __fclose_ca(f);
+-#endif
+ 
+-	/* Perform one or more DNS queries for host */
+-	memset(reply, 0, sizeof reply);
+-	result = __dns_query(reply, host, family, 0);
+-	if (result < 0) return result;
+-
+-	cnt = __dns_count_addrs(reply, result);
+-	if (cnt <= 0) return EAI_NONAME;
+-
+-	buf = calloc(sizeof *buf, cnt+EXTRA);
+-	if (!buf) return EAI_MEMORY;
+-
+-	i = 0;
+-	if (family != AF_INET6) {
+-		j = __dns_get_rr(&buf[i].sa.sin.sin_addr, sizeof *buf, 4, cnt-i, reply, RR_A, 0);
+-		while (j--) buf[i++].sa.sin.sin_family = AF_INET;
+-	}
+-	if (family != AF_INET) {
+-		j = __dns_get_rr(&buf[i].sa.sin6.sin6_addr, sizeof *buf, 16, cnt-i, reply, RR_AAAA, 0);
+-		while (j--) buf[i++].sa.sin.sin_family = AF_INET6;
+-	}
+-	if (result>1) {
+-		j = __dns_get_rr(&buf[i].sa.sin.sin_addr, sizeof *buf, 4, cnt-i, reply+512, RR_A, 0);
+-		while (j--) buf[i++].sa.sin.sin_family = AF_INET;
+-		j = __dns_get_rr(&buf[i].sa.sin6.sin6_addr, sizeof *buf, 16, cnt-i, reply+512, RR_AAAA, 0);
+-		while (j--) buf[i++].sa.sin.sin_family = AF_INET6;
+-	}
+-
+-	if (__dns_get_rr((void *)&buf[cnt], 0, 256, 1, reply, RR_CNAME, 1) <= 0)
+-		strcpy((void *)&buf[cnt], host);
+-
+-	for (i=0; i<cnt; i++) {
+-		buf[i].ai.ai_protocol = proto;
+-		buf[i].ai.ai_socktype = type;
+-		buf[i].ai.ai_addr = (void *)&buf[i].sa;
+-		buf[i].ai.ai_addrlen = buf[i].sa.sin.sin_family==AF_INET6
+-			? sizeof sa.sin6 : sizeof sa.sin;
+-		buf[i].ai.ai_family = buf[i].sa.sin.sin_family;
+-		buf[i].sa.sin.sin_port = port;
+-		buf[i].ai.ai_next = &buf[i+1].ai;
+-		buf[i].ai.ai_canonname = (void *)&buf[cnt];
++	for (k=i=0; i<naddrs; i++) for (j=0; j<nservs; j++, k++) {
++		out[k].ai = (struct addrinfo){
++			.ai_family = addrs[i].family,
++			.ai_socktype = ports[j].proto == IPPROTO_TCP
++				? SOCK_STREAM : SOCK_DGRAM,
++			.ai_protocol = ports[j].proto,
++			.ai_addrlen = addrs[i].family == AF_INET
++				? sizeof(struct sockaddr_in)
++				: sizeof(struct sockaddr_in6),
++			.ai_addr = (void *)&out[k].sa,
++			.ai_canonname = outcanon,
++			.ai_next = &out[k+1].ai };
++		switch (addrs[i].family) {
++		case AF_INET:
++			out[k].sa.sin.sin_family = AF_INET;
++			out[k].sa.sin.sin_port = htons(ports[j].port);
++			memcpy(&out[k].sa.sin.sin_addr, &addrs[i].addr, 4);
++			break;
++		case AF_INET6:
++			out[k].sa.sin6.sin6_family = AF_INET6;
++			out[k].sa.sin6.sin6_port = htons(ports[j].port);
++			memcpy(&out[k].sa.sin6.sin6_addr, &addrs[i].addr, 16);
++			break;			
++		}
+ 	}
+-	buf[cnt-1].ai.ai_next = 0;
+-	*res = &buf->ai;
+-
++	out[nais-1].ai.ai_next = 0;
++	*res = &out->ai;
+ 	return 0;
+ }
+diff --git a/src/network/gethostbyname2_r.c b/src/network/gethostbyname2_r.c
+index 27eb080..aa8b0a9 100644
+--- a/src/network/gethostbyname2_r.c
++++ b/src/network/gethostbyname2_r.c
+@@ -6,41 +6,31 @@
+ #include <netinet/in.h>
+ #include <errno.h>
+ #include <stdint.h>
++#include "lookup.h"
+ 
+ int gethostbyname2_r(const char *name, int af,
+ 	struct hostent *h, char *buf, size_t buflen,
+ 	struct hostent **res, int *err)
+ {
+-	struct addrinfo hint = {
+-		.ai_family = af==AF_INET6 ? af : AF_INET,
+-		.ai_flags = AI_CANONNAME
+-	};
+-	struct addrinfo *ai, *p;
+-	int i;
+-	size_t need;
+-	const char *canon;
++	struct address addrs[MAXADDRS];
++	char canon[256];
++	int i, cnt;
++	size_t align, need;
+ 
+-	af = hint.ai_family;
+-
+-	/* Align buffer */
+-	i = (uintptr_t)buf & sizeof(char *)-1;
+-	if (i) {
+-		if (buflen < sizeof(char *)-i) return ERANGE;
+-		buf += sizeof(char *)-i;
+-		buflen -= sizeof(char *)-i;
+-	}
+-
+-	switch (getaddrinfo(name, 0, &hint, &ai)) {
++	cnt = __lookup_name(addrs, canon, name, af, AI_CANONNAME);
++	if (cnt<0) switch (cnt) {
+ 	case EAI_NONAME:
+ 		*err = HOST_NOT_FOUND;
+-		return errno;
++		return ENOENT;
+ 	case EAI_AGAIN:
+ 		*err = TRY_AGAIN;
+-		return errno;
++		return EAGAIN;
+ 	default:
++	case EAI_FAIL:
++		*err = NO_RECOVERY;
++		return EBADMSG;
+ 	case EAI_MEMORY:
+ 	case EAI_SYSTEM:
+-	case EAI_FAIL:
+ 		*err = NO_RECOVERY;
+ 		return errno;
+ 	case 0:
+@@ -50,22 +40,22 @@ int gethostbyname2_r(const char *name, int af,
+ 	h->h_addrtype = af;
+ 	h->h_length = af==AF_INET6 ? 16 : 4;
+ 
+-	canon = ai->ai_canonname ? ai->ai_canonname : name;
++	/* Align buffer */
++	align = -(uintptr_t)buf & sizeof(char *)-1;
++
+ 	need = 4*sizeof(char *);
+-	for (i=0, p=ai; p; i++, p=p->ai_next)
+-		need += sizeof(char *) + h->h_length;
++	need += (cnt + 1) * (sizeof(char *) + h->h_length);
+ 	need += strlen(name)+1;
+ 	need += strlen(canon)+1;
++	need += align;
+ 
+-	if (need > buflen) {
+-		freeaddrinfo(ai);
+-		return ERANGE;
+-	}
++	if (need > buflen) return ERANGE;
+ 
++	buf += align;
+ 	h->h_aliases = (void *)buf;
+ 	buf += 3*sizeof(char *);
+ 	h->h_addr_list = (void *)buf;
+-	buf += (i+1)*sizeof(char *);
++	buf += (cnt+1)*sizeof(char *);
+ 
+ 	h->h_name = h->h_aliases[0] = buf;
+ 	strcpy(h->h_name, canon);
+@@ -79,16 +69,13 @@ int gethostbyname2_r(const char *name, int af,
+ 
+ 	h->h_aliases[2] = 0;
+ 
+-	for (i=0, p=ai; p; i++, p=p->ai_next) {
++	for (i=0; i<cnt; i++) {
+ 		h->h_addr_list[i] = (void *)buf;
+ 		buf += h->h_length;
+-		memcpy(h->h_addr_list[i],
+-			&((struct sockaddr_in *)p->ai_addr)->sin_addr,
+-			h->h_length);
++		memcpy(h->h_addr_list[i], addrs[i].addr, h->h_length);
+ 	}
+ 	h->h_addr_list[i] = 0;
+ 
+ 	*res = h;
+-	freeaddrinfo(ai);
+ 	return 0;
+ }
+diff --git a/src/network/getnameinfo.c b/src/network/getnameinfo.c
+index 33f89a3..dfcf6ed 100644
+--- a/src/network/getnameinfo.c
++++ b/src/network/getnameinfo.c
+@@ -5,15 +5,50 @@
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <arpa/inet.h>
+-#include "__dns.h"
++
++int __dns_parse(const unsigned char *, int, int (*)(void *, int, const void *, int, const void *), void *);
++int __dn_expand(const unsigned char *, const unsigned char *, const unsigned char *, char *, int);
++int __res_mkquery(int, const char *, int, int, const unsigned char *, int, const unsigned char*, unsigned char *, int);
++int __res_send(const unsigned char *, int, unsigned char *, int);
++
++#define PTR_MAX (64 + sizeof ".in-addr.arpa")
++#define RR_PTR 12
++
++static void mkptr4(char *s, const unsigned char *ip)
++{
++	sprintf(s, "%d.%d.%d.%d.in-addr.arpa",
++		ip[3], ip[2], ip[1], ip[0]);
++}
++
++static void mkptr6(char *s, const unsigned char *ip)
++{
++	static const char xdigits[] = "0123456789abcdef";
++	int i;
++	for (i=15; i>=0; i--) {
++		*s++ = xdigits[ip[i]&15]; *s++ = '.';
++		*s++ = xdigits[ip[i]>>4]; *s++ = '.';
++	}
++	strcpy(s, "ip6.arpa");
++}
++
++static int dns_parse_callback(void *c, int rr, const void *data, int len, const void *packet)
++{
++	char tmp[256];
++	if (rr != RR_PTR) return 0;
++	if (__dn_expand(packet, (const unsigned char *)packet + 512,
++	    data, tmp, sizeof tmp) > 0)
++		strcpy(c, tmp);
++	return 0;
++	
++}
+ 
+ int getnameinfo(const struct sockaddr *restrict sa, socklen_t sl,
+ 	char *restrict node, socklen_t nodelen,
+ 	char *restrict serv, socklen_t servlen,
+ 	int flags)
+ {
++	char ptr[PTR_MAX];
+ 	char buf[256];
+-	unsigned char reply[512];
+ 	int af = sa->sa_family;
+ 	unsigned char *a;
+ 
+@@ -21,20 +56,32 @@ int getnameinfo(const struct sockaddr *restrict sa, socklen_t sl,
+ 	case AF_INET:
+ 		a = (void *)&((struct sockaddr_in *)sa)->sin_addr;
+ 		if (sl != sizeof(struct sockaddr_in)) return EAI_FAMILY;
++		mkptr4(ptr, a);
+ 		break;
+ 	case AF_INET6:
+ 		a = (void *)&((struct sockaddr_in6 *)sa)->sin6_addr;
+ 		if (sl != sizeof(struct sockaddr_in6)) return EAI_FAMILY;
++		if (memcmp(a, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12))
++			mkptr6(ptr, a);
++		else
++			mkptr4(ptr, a+12);
+ 		break;
+ 	default:
+ 		return EAI_FAMILY;
+ 	}
+ 
+ 	if (node && nodelen) {
+-		if ((flags & NI_NUMERICHOST)
+-			|| __dns_query(reply, a, af, 1) <= 0
+-			|| __dns_get_rr(buf, 0, 256, 1, reply, RR_PTR, 1) <= 0)
+-		{
++		buf[0] = 0;
++		if (!(flags & NI_NUMERICHOST)) {
++			unsigned char query[18+PTR_MAX], reply[512];
++			int qlen = __res_mkquery(0, ptr, 1, RR_PTR,
++				0, 0, 0, query, sizeof query);
++			int rlen = __res_send(query, qlen, reply, sizeof reply);
++			buf[0] = 0;
++			if (rlen > 0)
++				__dns_parse(reply, rlen, dns_parse_callback, buf);
++		}
++		if (!*buf) {
+ 			if (flags & NI_NAMEREQD) return EAI_NONAME;
+ 			inet_ntop(af, a, buf, sizeof buf);
+ 		}
+diff --git a/src/network/getservbyname.c b/src/network/getservbyname.c
+index 0b00ce1..dd30376 100644
+--- a/src/network/getservbyname.c
++++ b/src/network/getservbyname.c
+@@ -4,7 +4,7 @@
+ struct servent *getservbyname(const char *name, const char *prots)
+ {
+ 	static struct servent se;
+-	static long buf[32/sizeof(long)];
++	static char *buf[2];
+ 	struct servent *res;
+ 	if (getservbyname_r(name, prots, &se, (void *)buf, sizeof buf, &res))
+ 		return 0;
+diff --git a/src/network/getservbyname_r.c b/src/network/getservbyname_r.c
+index 811c174..8cdf622 100644
+--- a/src/network/getservbyname_r.c
++++ b/src/network/getservbyname_r.c
+@@ -5,49 +5,43 @@
+ #include <inttypes.h>
+ #include <errno.h>
+ #include <string.h>
++#include "lookup.h"
++
++#define ALIGN (sizeof(struct { char a; char *b; }) - sizeof(char *))
+ 
+ int getservbyname_r(const char *name, const char *prots,
+ 	struct servent *se, char *buf, size_t buflen, struct servent **res)
+ {
+-	struct addrinfo *ai, hint = { .ai_family = AF_INET };
+-	int i;
+-
+-	if (!prots) {
+-		int r = getservbyname_r(name, "tcp", se, buf, buflen, res);
+-		if (r) r = getservbyname_r(name, "udp", se, buf, buflen, res);
+-		return r;
+-	}
++	struct service servs[MAXSERVS];
++	int cnt, proto, align;
+ 
+ 	/* Align buffer */
+-	i = (uintptr_t)buf & sizeof(char *)-1;
+-	if (!i) i = sizeof(char *);
+-	if (buflen < 3*sizeof(char *)-i)
++	align = -(uintptr_t)buf & ALIGN-1;
++	if (buflen < 2*sizeof(char *)+align)
+ 		return ERANGE;
+-	buf += sizeof(char *)-i;
+-	buflen -= sizeof(char *)-i;
++	buf += align;
+ 
+-	if (!strcmp(prots, "tcp")) hint.ai_protocol = IPPROTO_TCP;
+-	else if (!strcmp(prots, "udp")) hint.ai_protocol = IPPROTO_UDP;
++	if (!prots) proto = 0;
++	else if (!strcmp(prots, "tcp")) proto = IPPROTO_TCP;
++	else if (!strcmp(prots, "udp")) proto = IPPROTO_UDP;
+ 	else return EINVAL;
+ 
+-	switch (getaddrinfo(0, name, &hint, &ai)) {
++	cnt = __lookup_serv(servs, name, proto, 0);
++	if (cnt<0) switch (cnt) {
+ 	case EAI_MEMORY:
+ 	case EAI_SYSTEM:
+ 		return ENOMEM;
+ 	default:
+ 		return ENOENT;
+-	case 0:
+-		break;
+ 	}
+ 
+ 	se->s_name = (char *)name;
+ 	se->s_aliases = (void *)buf;
+ 	se->s_aliases[0] = se->s_name;
+ 	se->s_aliases[1] = 0;
+-	se->s_port = ((struct sockaddr_in *)ai->ai_addr)->sin_port;
+-	se->s_proto = (char *)prots;
++	se->s_port = htons(servs[0].port);
++	se->s_proto = servs[0].proto == IPPROTO_TCP ? "tcp" : "udp";
+ 
+-	freeaddrinfo(ai);
+ 	*res = se;
+ 	return 0;
+ }
+diff --git a/src/network/inet_addr.c b/src/network/inet_addr.c
+index ea0a8f7..10b21f2 100644
+--- a/src/network/inet_addr.c
++++ b/src/network/inet_addr.c
+@@ -1,11 +1,12 @@
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <arpa/inet.h>
+-#include "__dns.h"
++
++int __inet_aton(const char *, struct in_addr *);
+ 
+ in_addr_t inet_addr(const char *p)
+ {
+-	struct sockaddr_in sin;
+-	if (__ipparse(&sin, AF_INET, p) < 0) return -1;
+-	return sin.sin_addr.s_addr;
++	struct in_addr a;
++	if (!__inet_aton(p, &a)) return -1;
++	return a.s_addr;
+ }
+diff --git a/src/network/inet_aton.c b/src/network/inet_aton.c
+new file mode 100644
+index 0000000..0f9a45f
+--- /dev/null
++++ b/src/network/inet_aton.c
+@@ -0,0 +1,41 @@
++#include <ctype.h>
++#include <sys/socket.h>
++#include <netinet/in.h>
++#include <arpa/inet.h>
++#include "libc.h"
++
++int __inet_aton(const char *s0, struct in_addr *dest)
++{
++	const char *s = s0;
++	unsigned char *d = (void *)dest;
++	unsigned long a[4] = { 0 };
++	char *z;
++	int i;
++
++	for (i=0; i<4; i++) {
++		a[i] = strtoul(s, &z, 0);
++		if (z==s || (*z && *z != '.') || !isdigit(*s))
++			return 0;
++		if (!*z) break;
++		s=z+1;
++	}
++	if (i==4) return 0;
++	switch (i) {
++	case 0:
++		a[1] = a[0] & 0xffffff;
++		a[0] >>= 24;
++	case 1:
++		a[2] = a[1] & 0xffff;
++		a[1] >>= 16;
++	case 2:
++		a[3] = a[2] & 0xff;
++		a[2] >>= 8;
++	}
++	for (i=0; i<4; i++) {
++		if (a[i] > 255) return 0;
++		d[i] = a[i];
++	}
++	return 1;
++}
++
++weak_alias(__inet_aton, inet_aton);
+diff --git a/src/network/inet_legacy.c b/src/network/inet_legacy.c
+index de5b75c..621b47b 100644
+--- a/src/network/inet_legacy.c
++++ b/src/network/inet_legacy.c
+@@ -1,21 +1,12 @@
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <arpa/inet.h>
+-#include "__dns.h"
+ 
+ in_addr_t inet_network(const char *p)
+ {
+ 	return ntohl(inet_addr(p));
+ }
+ 
+-int inet_aton(const char *cp, struct in_addr *inp)
+-{
+-	struct sockaddr_in sin;
+-	if (__ipparse(&sin, AF_INET, cp) < 0) return 0;
+-	*inp = sin.sin_addr;
+-	return 1;
+-}
+-
+ struct in_addr inet_makeaddr(in_addr_t n, in_addr_t h)
+ {
+ 	if (n < 256) h |= n<<24;
+diff --git a/src/network/lookup.h b/src/network/lookup.h
+new file mode 100644
+index 0000000..82c969e
+--- /dev/null
++++ b/src/network/lookup.h
+@@ -0,0 +1,26 @@
++#ifndef LOOKUP_H
++#define LOOKUP_H
++
++#include <stdint.h>
++
++struct address {
++	int family;
++	unsigned scopeid;
++	uint8_t addr[16];
++};
++
++struct service {
++	uint16_t port;
++	char proto;
++};
++
++/* The limit of 48 results is a non-sharp bound on the number of addresses
++ * that can fit in one 512-byte DNS packet full of v4 results and a second
++ * packet full of v6 results. Due to headers, the actual limit is lower. */
++#define MAXADDRS 48
++#define MAXSERVS 2
++
++int __lookup_serv(struct service buf[static MAXSERVS], const char *name, int proto, int flags);
++int __lookup_name(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family, int flags);
++
++#endif
+diff --git a/src/network/lookup_name.c b/src/network/lookup_name.c
+new file mode 100644
+index 0000000..8d41627
+--- /dev/null
++++ b/src/network/lookup_name.c
+@@ -0,0 +1,210 @@
++#include <sys/socket.h>
++#include <netinet/in.h>
++#include <netdb.h>
++#include <arpa/inet.h>
++#include <ctype.h>
++#include <stdlib.h>
++#include <string.h>
++#include <fcntl.h>
++#include "lookup.h"
++#include "stdio_impl.h"
++#include "syscall.h"
++
++static int is_valid_hostname(const char *host)
++{
++	const unsigned char *s;
++	if (strnlen(host, 256)-1 > 254 || mbstowcs(0, host, 0) > 255) return 0;
++	for (s=(void *)host; *s>=0x80 || *s=='.' || *s=='-' || isalnum(*s); s++);
++	return !*s;
++}
++
++static int name_from_null(struct address buf[static 2], const char *name, int family, int flags)
++{
++	int cnt = 0;
++	if (name) return 0;
++	if (flags & AI_PASSIVE) {
++		if (family != AF_INET6)
++			buf[cnt++] = (struct address){ .family = AF_INET };
++		if (family != AF_INET)
++			buf[cnt++] = (struct address){ .family = AF_INET6 };
++	} else {
++		if (family != AF_INET6)
++			buf[cnt++] = (struct address){ .family = AF_INET, .addr = { 127,0,0,1 } };
++		if (family != AF_INET)
++			buf[cnt++] = (struct address){ .family = AF_INET6, .addr = { [15] = 1 } };
++	}
++	return cnt;
++}
++
++int __inet_aton(const char *, struct in_addr *);
++
++static int name_from_numeric(struct address buf[static 1], const char *name, int family)
++{
++	struct in_addr a4;
++	struct in6_addr a6;
++	if (family != AF_INET6 && __inet_aton(name, &a4)>0) {
++		memcpy(&buf[0].addr, &a4, sizeof a4);
++		buf[0].family = AF_INET;
++		return 1;
++	}
++	if (family != AF_INET && inet_pton(AF_INET6, name, &a6)>0) {
++		memcpy(&buf[0].addr, &a6, sizeof a6);
++		buf[0].family = AF_INET6;
++		return 1;
++	}
++	return 0;
++}
++
++static int name_from_hosts(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family)
++{
++	char line[512];
++	size_t l = strlen(name);
++	int cnt = 0;
++	unsigned char _buf[1032];
++	FILE _f, *f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
++	if (!f) return 0;
++	while (fgets(line, sizeof line, f) && cnt < MAXADDRS) {
++		char *p, *z;
++
++		if ((p=strchr(line, '#'))) *p++='\n', *p=0;
++		for(p=line+1; (p=strstr(p, name)) &&
++			(!isspace(p[-1]) || !isspace(p[l])); p++);
++		if (!p) continue;
++
++		/* Isolate IP address to parse */
++		for (p=line; *p && !isspace(*p); p++);
++		*p++ = 0;
++		if (name_from_numeric(buf+cnt, line, family))
++			cnt++;
++
++		/* Extract first name as canonical name */
++		for (; *p && isspace(*p); p++);
++		for (z=p; *z && !isspace(*z); z++);
++		*z = 0;
++		if (is_valid_hostname(p)) memcpy(canon, p, z-p+1);
++	}
++	__fclose_ca(f);
++	return cnt;
++}
++
++struct dpc_ctx {
++	struct address *addrs;
++	char *canon;
++	int cnt;
++};
++
++int __dns_parse(const unsigned char *, int, int (*)(void *, int, const void *, int, const void *), void *);
++int __dn_expand(const unsigned char *, const unsigned char *, const unsigned char *, char *, int);
++int __res_mkquery(int, const char *, int, int, const unsigned char *, int, const unsigned char*, unsigned char *, int);
++int __res_msend(int, const unsigned char *const *, const int *, unsigned char *const *, int *, int);
++
++#define RR_A 1
++#define RR_CNAME 5
++#define RR_AAAA 28
++
++static int dns_parse_callback(void *c, int rr, const void *data, int len, const void *packet)
++{
++	char tmp[256];
++	struct dpc_ctx *ctx = c;
++	switch (rr) {
++	case RR_A:
++		if (len != 4) return -1;
++		ctx->addrs[ctx->cnt].family = AF_INET;
++		memcpy(ctx->addrs[ctx->cnt++].addr, data, 4);
++		break;
++	case RR_AAAA:
++		if (len != 16) return -1;
++		ctx->addrs[ctx->cnt].family = AF_INET6;
++		memcpy(ctx->addrs[ctx->cnt++].addr, data, 16);
++		break;
++	case RR_CNAME:
++		if (__dn_expand(packet, (const unsigned char *)packet + 512,
++		    data, tmp, sizeof tmp) > 0 && is_valid_hostname(tmp))
++			strcpy(ctx->canon, tmp);
++		break;
++	}
++	return 0;
++}
++
++static int name_from_dns(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family)
++{
++	unsigned char qbuf[2][280], abuf[2][512];
++	const unsigned char *qp[2] = { qbuf[0], qbuf[1] };
++	unsigned char *ap[2] = { abuf[0], abuf[1] };
++	int qlens[2], alens[2];
++	int i, nq = 0;
++	struct dpc_ctx ctx = { .addrs = buf, .canon = canon };
++
++	if (family != AF_INET6) {
++		qlens[nq] = __res_mkquery(0, name, 1, RR_A, 0, 0, 0,
++			qbuf[nq], sizeof *qbuf);
++		nq++;
++	}
++	if (family != AF_INET) {
++		qlens[nq] = __res_mkquery(0, name, 1, RR_AAAA, 0, 0, 0,
++			qbuf[nq], sizeof *qbuf);
++		nq++;
++	}
++
++	if (__res_msend(nq, qp, qlens, ap, alens, sizeof *abuf) < 0) return EAI_SYSTEM;
++
++	for (i=0; i<nq; i++)
++		__dns_parse(abuf[i], alens[i], dns_parse_callback, &ctx);
++
++	return ctx.cnt;
++}
++
++int __lookup_name(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family, int flags)
++{
++	int cnt = 0, i, j;
++
++	*canon = 0;
++	if (name) {
++		size_t l;
++		if ((l = strnlen(name, 256))-1 > 254)
++			return EAI_NONAME;
++		memcpy(canon, name, l+1);
++	}
++
++	/* Procedurally, a request for v6 addresses with the v4-mapped
++	 * flag set is like a request for unspecified family, followed
++	 * by filtering of the results. */
++	if (flags & AI_V4MAPPED) {
++		if (family == AF_INET6) family = AF_UNSPEC;
++		else flags -= AI_V4MAPPED;
++	}
++
++	/* Try each backend until there's at least one result. */
++	cnt = name_from_null(buf, name, family, flags);
++	if (cnt<=0) cnt = name_from_numeric(buf, name, family);
++	if (cnt<=0 && !(flags & AI_NUMERICHOST)) {
++		cnt = name_from_hosts(buf, canon, name, family);
++		if (cnt<=0) cnt = name_from_dns(buf, canon, name, family);
++	}
++	if (cnt<=0) return cnt ? cnt : EAI_NONAME;
++
++	/* Filter/transform results for v4-mapped lookup, if requested. */
++	if (flags & AI_V4MAPPED) {
++		if (!(flags & AI_ALL)) {
++			/* If any v6 results exist, remove v4 results. */
++			for (i=0; i<cnt && buf[i].family != AF_INET6; i++);
++			if (i<cnt) {
++				for (j=0; i<cnt; i++) {
++					if (buf[i].family == AF_INET6)
++						buf[j++] = buf[i];
++				}
++				cnt = i = j;
++			}
++		}
++		/* Translate any remaining v4 results to v6 */
++		for (i=0; i<cnt; i++) {
++			if (buf[i].family != AF_INET) continue;
++			memcpy(buf[i].addr+12, buf[i].addr, 4);
++			memcpy(buf[i].addr, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
++			buf[i].scopeid = 0;
++			buf[i].family = AF_INET6;
++		}
++	}
++
++	return cnt;
++}
+diff --git a/src/network/lookup_serv.c b/src/network/lookup_serv.c
+new file mode 100644
+index 0000000..bf4cba0
+--- /dev/null
++++ b/src/network/lookup_serv.c
+@@ -0,0 +1,72 @@
++#include <sys/socket.h>
++#include <netinet/in.h>
++#include <netdb.h>
++#include <ctype.h>
++#include <string.h>
++#include <fcntl.h>
++#include "lookup.h"
++#include "stdio_impl.h"
++
++int __lookup_serv(struct service buf[static MAXSERVS], const char *name, int proto, int flags)
++{
++	char line[128];
++	int cnt = 0;
++	char *p, *z = "";
++	unsigned long port = 0;
++
++	if (name) {
++		if (!*name) return EAI_SERVICE;
++		port = strtoul(name, &z, 10);
++	}
++	if (!*z) {
++		if (port > 65535) return EAI_SERVICE;
++		if (proto != IPPROTO_UDP) {
++			buf[cnt].port = port;
++			buf[cnt++].proto = IPPROTO_TCP;
++		}
++		if (proto != IPPROTO_TCP) {
++			buf[cnt].port = port;
++			buf[cnt++].proto = IPPROTO_UDP;
++		}
++		return cnt;
++	}
++
++	if (flags & AI_NUMERICSERV) return EAI_SERVICE;
++
++	size_t l = strlen(name);
++
++	unsigned char _buf[1032];
++	FILE _f, *f = __fopen_rb_ca("/etc/services", &_f, _buf, sizeof _buf);
++	if (!f) return EAI_SERVICE;
++
++	while (fgets(line, sizeof line, f) && cnt < MAXSERVS) {
++		if ((p=strchr(line, '#'))) *p++='\n', *p=0;
++
++		/* Find service name */
++		for(p=line; (p=strstr(p, name)); p++) {
++			if (p>line && !isspace(p[-1])) continue;
++			if (p[l] && !isspace(p[l])) continue;
++			break;
++		}
++		if (!p) continue;
++
++		/* Skip past canonical name at beginning of line */
++		for (p=line; *p && !isspace(*p); p++);
++		if (!p) continue;
++
++		port = strtoul(p, &z, 10);
++		if (port > 65535 || z==p) continue;
++		if (!strncmp(z, "/udp", 4)) {
++			if (proto == IPPROTO_TCP) continue;
++			buf[cnt].port = port;
++			buf[cnt++].proto = IPPROTO_UDP;
++		}
++		if (!strncmp(z, "/tcp", 4)) {
++			if (proto == IPPROTO_UDP) continue;
++			buf[cnt].port = port;
++			buf[cnt++].proto = IPPROTO_TCP;
++		}
++	}
++	__fclose_ca(f);
++	return cnt > 0 ? cnt : EAI_SERVICE;
++}
+diff --git a/src/network/proto.c b/src/network/proto.c
+index 3d0f584..1b51e15 100644
+--- a/src/network/proto.c
++++ b/src/network/proto.c
+@@ -14,7 +14,11 @@ static const unsigned char protos[][8] = {
+ 	"\021udp",
+ 	"\026idp",
+ 	"\051ipv6",
++	"\057gre",
++	"\062esp",
++	"\063ah",
+ 	"\072icmpv6",
++	"\136ipip",
+ 	"\377raw",
+ 	"\0\0"
+ };
+diff --git a/src/network/res_init.c b/src/network/res_init.c
+index cbd5b15..5dba9df 100644
+--- a/src/network/res_init.c
++++ b/src/network/res_init.c
+@@ -1,3 +1,5 @@
++#include <resolv.h>
++
+ int res_init()
+ {
+ 	return 0;
+diff --git a/src/network/res_mkquery.c b/src/network/res_mkquery.c
+new file mode 100644
+index 0000000..f7e4e9c
+--- /dev/null
++++ b/src/network/res_mkquery.c
+@@ -0,0 +1,41 @@
++#include <resolv.h>
++#include <string.h>
++#include <time.h>
++#include "libc.h"
++
++int __res_mkquery(int op, const char *dname, int class, int type,
++	const unsigned char *data, int datalen,
++	const unsigned char *newrr, unsigned char *buf, int buflen)
++{
++	int id, i, j;
++	unsigned char q[280];
++	struct timespec ts;
++	size_t l = strnlen(dname, 256);
++
++	if (l-1>=254 || buflen<18+l || op>15u || class>255u || type>255u)
++		return -1;
++
++	/* Construct query template - ID will be filled later */
++	memset(q, 0, 18+l);
++	q[2] = op*8 + 1;
++	q[5] = 1;
++	memcpy((char *)q+13, dname, l);
++	for (i=13; q[i]; i=j+1) {
++		for (j=i; q[j] && q[j] != '.'; j++);
++		if (j-i-1u > 62u) return -1;
++		q[i-1] = j-i;
++	}
++	q[i+1] = type;
++	q[i+3] = class;
++
++	/* Make a reasonably unpredictable id */
++	clock_gettime(CLOCK_REALTIME, &ts);
++	id = ts.tv_nsec + ts.tv_nsec/65536UL & 0xffff;
++	q[0] = id/256;
++	q[1] = id;
++
++	memcpy(buf, q, 18+l);
++	return 18+l;
++}
++
++weak_alias(__res_mkquery, res_mkquery);
+diff --git a/src/network/res_msend.c b/src/network/res_msend.c
+new file mode 100644
+index 0000000..a5b7793
+--- /dev/null
++++ b/src/network/res_msend.c
+@@ -0,0 +1,185 @@
++#include <sys/socket.h>
++#include <netinet/in.h>
++#include <netdb.h>
++#include <arpa/inet.h>
++#include <stdint.h>
++#include <string.h>
++#include <poll.h>
++#include <time.h>
++#include <ctype.h>
++#include <unistd.h>
++#include <errno.h>
++#include <pthread.h>
++#include "stdio_impl.h"
++#include "syscall.h"
++
++static void cleanup(void *p)
++{
++	__syscall(SYS_close, (intptr_t)p);
++}
++
++static unsigned long mtime()
++{
++	struct timespec ts;
++	clock_gettime(CLOCK_REALTIME, &ts);
++	return (unsigned long)ts.tv_sec * 1000
++		+ ts.tv_nsec / 1000000;
++}
++
++int __res_msend(int nqueries, const unsigned char *const *queries,
++	const int *qlens, unsigned char *const *answers, int *alens, int asize)
++{
++	int fd;
++	FILE *f, _f;
++	unsigned char _buf[256];
++	char line[64], *s, *z;
++	int timeout = 5000, attempts = 2, retry_interval;
++	union {
++		struct sockaddr_in sin;
++		struct sockaddr_in6 sin6;
++	} sa = {0}, ns[3] = {{0}};
++	socklen_t sl = sizeof sa.sin;
++	int nns = 0;
++	int family = AF_INET;
++	int rlen;
++	int next;
++	int i, j;
++	int cs;
++	struct pollfd pfd;
++	unsigned long t0, t1, t2;
++
++	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
++
++	/* Get nameservers from resolv.conf, fallback to localhost */
++	f = __fopen_rb_ca("/etc/resolv.conf", &_f, _buf, sizeof _buf);
++	if (f) for (nns=0; nns<3 && fgets(line, sizeof line, f); ) {
++		if (!strncmp(line, "options", 7) && isspace(line[7])) {
++			unsigned long x;
++			char *p, *z;
++			p = strstr(line, "timeout:");
++			if (p && isdigit(p[8])) {
++				p += 8;
++				x = strtoul(p, &z, 10);
++				if (z != p) timeout = x < 30 ? x*1000 : 30000;
++			}
++			p = strstr(line, "attempts:");
++			if (p && isdigit(p[9])) {
++				p += 9;
++				x = strtoul(p, &z, 10);
++				if (z != p) attempts = x < 10 ? x : 10;
++				if (!attempts) attempts = 1;
++			}
++		}
++		if (strncmp(line, "nameserver", 10) || !isspace(line[10]))
++			continue;
++		for (s=line+11; isspace(*s); s++);
++		for (z=s; *z && !isspace(*z); z++);
++		*z=0;
++
++		if (inet_pton(AF_INET, s, &ns[nns].sin.sin_addr)>0) {
++			ns[nns].sin.sin_port = htons(53);
++			ns[nns++].sin.sin_family = AF_INET;
++		} else if (inet_pton(AF_INET6, s, &ns[nns].sin6.sin6_addr)>0) {
++			sl = sizeof sa.sin6;
++			ns[nns].sin6.sin6_port = htons(53);
++			ns[nns++].sin6.sin6_family = family = AF_INET6;
++		}
++	}
++	if (f) __fclose_ca(f);
++	if (!nns) {
++		ns[0].sin.sin_family = AF_INET;
++		ns[0].sin.sin_port = htons(53);
++		ns[0].sin.sin_addr.s_addr = htonl(0x7f000001);
++		nns=1;
++	}
++
++	/* Get local address and open/bind a socket */
++	sa.sin.sin_family = family;
++	fd = socket(family, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
++
++	/* Handle case where system lacks IPv6 support */
++	if (fd < 0 && family == AF_INET6 && errno == EAFNOSUPPORT) {
++		fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
++		family = AF_INET;
++	}
++	if (fd < 0 || bind(fd, (void *)&sa, sl) < 0) return -1;
++
++	/* Past this point, there are no errors. Each individual query will
++	 * yield either no reply (indicated by zero length) or an answer
++	 * packet which is up to the caller to interpret. */
++
++	pthread_cleanup_push(cleanup, (void *)(intptr_t)fd);
++	pthread_setcancelstate(cs, 0);
++
++	/* Convert any IPv4 addresses in a mixed environment to v4-mapped */
++	if (family == AF_INET6) {
++		setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){0}, sizeof 0);
++		for (i=0; i<nns; i++) {
++			if (ns[i].sin.sin_family != AF_INET) continue;
++			memcpy(ns[i].sin6.sin6_addr.s6_addr+12,
++				&ns[i].sin.sin_addr, 4);
++			memcpy(ns[i].sin6.sin6_addr.s6_addr,
++				"\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
++			ns[i].sin6.sin6_family = AF_INET6;
++			ns[i].sin6.sin6_flowinfo = 0;
++			ns[i].sin6.sin6_scope_id = 0;
++		}
++	}
++
++	memset(alens, 0, sizeof *alens * nqueries);
++
++	pfd.fd = fd;
++	pfd.events = POLLIN;
++	retry_interval = timeout / attempts;
++	next = 0;
++	t0 = t2 = mtime();
++	t1 = t2 - retry_interval;
++
++	for (; t2-t0 < timeout; t2=mtime()) {
++		if (t2-t1 >= retry_interval) {
++			/* Query all configured namservers in parallel */
++			for (i=0; i<nqueries; i++)
++				if (!alens[i])
++					for (j=0; j<nns; j++)
++						sendto(fd, queries[i],
++							qlens[i], MSG_NOSIGNAL,
++							(void *)&ns[j], sl);
++			t1 = t2;
++		}
++
++		/* Wait for a response, or until time to retry */
++		if (poll(&pfd, 1, t1+retry_interval-t2) <= 0) continue;
++
++		while ((rlen = recvfrom(fd, answers[next], asize, 0,
++		  (void *)&sa, (socklen_t[1]){sl})) >= 0) {
++
++			/* Ignore non-identifiable packets (no query id) */
++			if (rlen < 2) continue;
++
++			/* Ignore replies from addresses we didn't send to */
++			for (i=0; i<nns && memcmp(ns+i, &sa, sl); i++);
++			if (i==nns) continue;
++
++			/* Find which query this answer goes with, if any */
++			for (i=next; i<nqueries && (
++				answers[next][0] != queries[i][0] ||
++				answers[next][1] != queries[i][1] ); i++);
++			if (i==nqueries) continue;
++			if (alens[i]) continue;
++
++			/* Store answer in the right slot, or update next
++			 * available temp slot if it's already in place. */
++			alens[i] = rlen;
++			if (i == next)
++				for (; next<nqueries && alens[next]; next++);
++			else
++				memcpy(answers[i], answers[next], rlen);
++
++			if (next == nqueries) goto out;
++		}
++	}
++out:
++	pthread_cleanup_pop(1);
++
++	return 0;
++}
+diff --git a/src/network/res_query.c b/src/network/res_query.c
+index 3847da3..2b4e4bb 100644
+--- a/src/network/res_query.c
++++ b/src/network/res_query.c
+@@ -1,25 +1,17 @@
+-#define _GNU_SOURCE
+ #include <resolv.h>
+ #include <netdb.h>
+-#include "__dns.h"
+ #include "libc.h"
+ 
+-int res_query(const char *name, int class, int type, unsigned char *dest, int len)
++int __res_mkquery(int, const char *, int, int, const unsigned char *, int, const unsigned char*, unsigned char *, int);
++int __res_send(const unsigned char *, int, unsigned char *, int);
++
++int __res_query(const char *name, int class, int type, unsigned char *dest, int len)
+ {
+-	if (class != 1 || len < 512)
+-		return -1;
+-	switch(__dns_doqueries(dest, name, &type, 1)) {
+-	case EAI_NONAME:
+-		h_errno = HOST_NOT_FOUND;
+-		return -1;
+-	case EAI_AGAIN:
+-		h_errno = TRY_AGAIN;
+-		return -1;
+-	case EAI_FAIL:
+-		h_errno = NO_RECOVERY;
+-		return -1;
+-	}
+-	return 512;
++	unsigned char q[280];
++	int ql = __res_mkquery(0, name, class, type, 0, 0, 0, q, sizeof q);
++	if (ql < 0) return ql;
++	return __res_send(q, ql, dest, len);
+ }
+ 
+-weak_alias(res_query, res_search);
++weak_alias(__res_query, res_query);
++weak_alias(__res_query, res_search);
+diff --git a/src/network/res_querydomain.c b/src/network/res_querydomain.c
+new file mode 100644
+index 0000000..c746dbe
+--- /dev/null
++++ b/src/network/res_querydomain.c
+@@ -0,0 +1,14 @@
++#include <resolv.h>
++#include <string.h>
++
++int res_querydomain(const char *name, const char *domain, int class, int type, unsigned char *dest, int len)
++{
++	char tmp[256];
++	size_t nl = strnlen(name, 256);
++	size_t dl = strnlen(domain, 256);
++	if (nl+dl+1 > 255) return -1;
++	memcpy(tmp, name, nl);
++	tmp[nl] = '.';
++	memcpy(tmp+nl+1, domain, dl+1);
++	return res_query(tmp, class, type, dest, len);
++}
+diff --git a/src/network/res_send.c b/src/network/res_send.c
+new file mode 100644
+index 0000000..19cfe0f
+--- /dev/null
++++ b/src/network/res_send.c
+@@ -0,0 +1,12 @@
++#include <resolv.h>
++#include "libc.h"
++
++int __res_msend(int, const unsigned char *const *, const int *, unsigned char *const *, int *, int);
++
++int __res_send(const unsigned char *msg, int msglen, unsigned char *answer, int anslen)
++{
++	int r = __res_msend(1, &msg, &msglen, &answer, &anslen, anslen);
++	return r<0 ? r : anslen;
++}
++
++weak_alias(__res_send, res_send);
+diff --git a/src/process/fork.c b/src/process/fork.c
+index 864c7d7..f8cf21e 100644
+--- a/src/process/fork.c
++++ b/src/process/fork.c
+@@ -1,5 +1,6 @@
+ #include <unistd.h>
+ #include <string.h>
++#include <signal.h>
+ #include "syscall.h"
+ #include "libc.h"
+ #include "pthread_impl.h"
+@@ -16,7 +17,11 @@ pid_t fork(void)
+ 	sigset_t set;
+ 	__fork_handler(-1);
+ 	__block_all_sigs(&set);
++#ifdef SYS_fork
+ 	ret = syscall(SYS_fork);
++#else
++	ret = syscall(SYS_clone, SIGCHLD, 0);
++#endif
+ 	if (libc.has_thread_pointer && !ret) {
+ 		pthread_t self = __pthread_self();
+ 		self->tid = self->pid = __syscall(SYS_getpid);
+diff --git a/src/process/posix_spawn.c b/src/process/posix_spawn.c
+index f675a13..08928b0 100644
+--- a/src/process/posix_spawn.c
++++ b/src/process/posix_spawn.c
+@@ -22,6 +22,20 @@ struct args {
+ 
+ void __get_handler_set(sigset_t *);
+ 
++static int __sys_dup2(int old, int new)
++{
++#ifdef SYS_dup2
++	return __syscall(SYS_dup2, old, new);
++#else
++	if (old==new) {
++		int r = __syscall(SYS_fcntl, old, F_GETFD);
++		return r<0 ? r : old;
++	} else {
++		return __syscall(SYS_dup3, old, new, 0);
++	}
++#endif
++}
++
+ static int child(void *args_vp)
+ {
+ 	int i, ret;
+@@ -92,15 +106,14 @@ static int child(void *args_vp)
+ 					goto fail;
+ 				break;
+ 			case FDOP_DUP2:
+-				if ((ret=__syscall(SYS_dup2, op->srcfd, op->fd))<0)
++				if ((ret=__sys_dup2(op->srcfd, op->fd))<0)
+ 					goto fail;
+ 				break;
+ 			case FDOP_OPEN:
+-				fd = __syscall(SYS_open, op->path,
+-					op->oflag | O_LARGEFILE, op->mode);
++				fd = __sys_open(op->path, op->oflag, op->mode);
+ 				if ((ret=fd) < 0) goto fail;
+ 				if (fd != op->fd) {
+-					if ((ret=__syscall(SYS_dup2, fd, op->fd))<0)
++					if ((ret=__sys_dup2(fd, op->fd))<0)
+ 						goto fail;
+ 					__syscall(SYS_close, fd);
+ 				}
+diff --git a/src/process/vfork.c b/src/process/vfork.c
+index fc4adb4..ac95465 100644
+--- a/src/process/vfork.c
++++ b/src/process/vfork.c
+@@ -1,12 +1,17 @@
+ #define _GNU_SOURCE
+ #include <unistd.h>
++#include <signal.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ pid_t __vfork(void)
+ {
+ 	/* vfork syscall cannot be made from C code */
++#ifdef SYS_fork
+ 	return syscall(SYS_fork);
++#else
++	return syscall(SYS_clone, SIGCHLD, 0);
++#endif
+ }
+ 
+ weak_alias(__vfork, vfork);
+diff --git a/src/select/poll.c b/src/select/poll.c
+index f1e73e8..9e0bcbd 100644
+--- a/src/select/poll.c
++++ b/src/select/poll.c
+@@ -1,8 +1,16 @@
+ #include <poll.h>
++#include <time.h>
++#include <signal.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int poll(struct pollfd *fds, nfds_t n, int timeout)
+ {
++#ifdef SYS_poll
+ 	return syscall_cp(SYS_poll, fds, n, timeout);
++#else
++	return syscall_cp(SYS_ppoll, fds, n, timeout>=0 ?
++		&((struct timespec){ .tv_sec = timeout/1000,
++		.tv_nsec = timeout%1000*1000000 }) : 0, 0, _NSIG/8);
++#endif
+ }
+diff --git a/src/select/pselect.c b/src/select/pselect.c
+index a19e153..4e2d7b0 100644
+--- a/src/select/pselect.c
++++ b/src/select/pselect.c
+@@ -1,11 +1,12 @@
+ #include <sys/select.h>
+ #include <signal.h>
++#include <stdint.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int pselect(int n, fd_set *restrict rfds, fd_set *restrict wfds, fd_set *restrict efds, const struct timespec *restrict ts, const sigset_t *restrict mask)
+ {
+-	long data[2] = { (long)mask, _NSIG/8 };
++	syscall_arg_t data[2] = { (uintptr_t)mask, _NSIG/8 };
+ 	struct timespec ts_tmp;
+ 	if (ts) ts_tmp = *ts;
+ 	return syscall_cp(SYS_pselect6, n, rfds, wfds, efds, ts ? &ts_tmp : 0, data);
+diff --git a/src/select/select.c b/src/select/select.c
+index f93597b..7b5f6dc 100644
+--- a/src/select/select.c
++++ b/src/select/select.c
+@@ -1,8 +1,26 @@
+ #include <sys/select.h>
++#include <signal.h>
++#include <stdint.h>
++#include <errno.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int select(int n, fd_set *restrict rfds, fd_set *restrict wfds, fd_set *restrict efds, struct timeval *restrict tv)
+ {
++#ifdef SYS_select
+ 	return syscall_cp(SYS_select, n, rfds, wfds, efds, tv);
++#else
++	syscall_arg_t data[2] = { 0, _NSIG/8 };
++	struct timespec ts;
++	if (tv) {
++		if (tv->tv_sec < 0 || tv->tv_usec < 0)
++			return __syscall_ret(-EINVAL);
++		time_t extra_secs = tv->tv_usec / 1000000;
++		ts.tv_nsec = tv->tv_usec % 1000000 * 1000;
++		const time_t max_time = (1ULL<<8*sizeof(time_t)-1)-1;
++		ts.tv_sec = extra_secs > max_time - tv->tv_sec ?
++			max_time : tv->tv_sec + extra_secs;
++	}
++	return syscall_cp(SYS_pselect6, n, rfds, wfds, efds, tv ? &ts : 0, data);
++#endif
+ }
+diff --git a/src/stat/chmod.c b/src/stat/chmod.c
+index beb66e5..d4f53c5 100644
+--- a/src/stat/chmod.c
++++ b/src/stat/chmod.c
+@@ -1,7 +1,12 @@
+ #include <sys/stat.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int chmod(const char *path, mode_t mode)
+ {
++#ifdef SYS_chmod
+ 	return syscall(SYS_chmod, path, mode);
++#else
++	return syscall(SYS_fchmodat, AT_FDCWD, path, mode);
++#endif
+ }
+diff --git a/src/stat/fchmod.c b/src/stat/fchmod.c
+index 6d28141..93e1b64 100644
+--- a/src/stat/fchmod.c
++++ b/src/stat/fchmod.c
+@@ -13,5 +13,9 @@ int fchmod(int fd, mode_t mode)
+ 
+ 	char buf[15+3*sizeof(int)];
+ 	__procfdname(buf, fd);
++#ifdef SYS_chmod
+ 	return syscall(SYS_chmod, buf, mode);
++#else
++	return syscall(SYS_fchmodat, AT_FDCWD, buf, mode);
++#endif
+ }
+diff --git a/src/stat/fchmodat.c b/src/stat/fchmodat.c
+index 12e7ff0..afa6d44 100644
+--- a/src/stat/fchmodat.c
++++ b/src/stat/fchmodat.c
+@@ -28,8 +28,9 @@ int fchmodat(int fd, const char *path, mode_t mode, int flag)
+ 	}
+ 
+ 	__procfdname(proc, fd2);
+-	if (!(ret = __syscall(SYS_stat, proc, &st)) && !S_ISLNK(st.st_mode))
+-		ret = __syscall(SYS_chmod, proc, mode);
++	ret = __syscall(SYS_fstatat, AT_FDCWD, proc, &st, 0);
++	if (!ret && !S_ISLNK(st.st_mode))
++		ret = __syscall(SYS_fchmodat, AT_FDCWD, proc, mode);
+ 
+ 	__syscall(SYS_close, fd2);
+ 	return __syscall_ret(ret);
+diff --git a/src/stat/fstat.c b/src/stat/fstat.c
+index b561176..a928986 100644
+--- a/src/stat/fstat.c
++++ b/src/stat/fstat.c
+@@ -14,7 +14,11 @@ int fstat(int fd, struct stat *st)
+ 
+ 	char buf[15+3*sizeof(int)];
+ 	__procfdname(buf, fd);
++#ifdef SYS_stat
+ 	return syscall(SYS_stat, buf, st);
++#else
++	return syscall(SYS_fstatat, AT_FDCWD, buf, st);
++#endif
+ }
+ 
+ LFS64(fstat);
+diff --git a/src/stat/futimesat.c b/src/stat/futimesat.c
+index dbefc84..b4eea1d 100644
+--- a/src/stat/futimesat.c
++++ b/src/stat/futimesat.c
+@@ -1,10 +1,23 @@
+ #define _GNU_SOURCE
+ #include <sys/time.h>
++#include <sys/stat.h>
++#include <errno.h>
+ #include "syscall.h"
++#include "libc.h"
+ 
+-#ifdef SYS_futimesat
+-int futimesat(int dirfd, const char *pathname, const struct timeval times[2])
++int __futimesat(int dirfd, const char *pathname, const struct timeval times[2])
+ {
+-	return syscall(SYS_futimesat, dirfd, pathname, times);
++	struct timespec ts[2];
++	if (times) {
++		int i;
++		for (i=0; i<2; i++) {
++			if (times[i].tv_usec >= 1000000ULL)
++				return __syscall_ret(-EINVAL);
++			ts[i].tv_sec = times[i].tv_sec;
++			ts[i].tv_nsec = times[i].tv_usec * 1000;
++		}
++	}
++	return utimensat(dirfd, pathname, times ? ts : 0, 0);
+ }
+-#endif
++
++weak_alias(__futimesat, futimesat);
+diff --git a/src/stat/lstat.c b/src/stat/lstat.c
+index 8f60358..5e8b84f 100644
+--- a/src/stat/lstat.c
++++ b/src/stat/lstat.c
+@@ -1,10 +1,15 @@
+ #include <sys/stat.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int lstat(const char *restrict path, struct stat *restrict buf)
+ {
++#ifdef SYS_lstat
+ 	return syscall(SYS_lstat, path, buf);
++#else
++	return syscall(SYS_fstatat, AT_FDCWD, path, buf, AT_SYMLINK_NOFOLLOW);
++#endif
+ }
+ 
+ LFS64(lstat);
+diff --git a/src/stat/mkdir.c b/src/stat/mkdir.c
+index 770e1cc..32625b7 100644
+--- a/src/stat/mkdir.c
++++ b/src/stat/mkdir.c
+@@ -1,7 +1,12 @@
+ #include <sys/stat.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int mkdir(const char *path, mode_t mode)
+ {
++#ifdef SYS_mkdir
+ 	return syscall(SYS_mkdir, path, mode);
++#else
++	return syscall(SYS_mkdirat, AT_FDCWD, path, mode);
++#endif
+ }
+diff --git a/src/stat/mknod.c b/src/stat/mknod.c
+index c319657..beebd84 100644
+--- a/src/stat/mknod.c
++++ b/src/stat/mknod.c
+@@ -1,7 +1,12 @@
+ #include <sys/stat.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int mknod(const char *path, mode_t mode, dev_t dev)
+ {
++#ifdef SYS_mknod
+ 	return syscall(SYS_mknod, path, mode, dev);
++#else
++	return syscall(SYS_mknodat, AT_FDCWD, path, mode, dev);
++#endif
+ }
+diff --git a/src/stat/stat.c b/src/stat/stat.c
+index c6de716..b4433a0 100644
+--- a/src/stat/stat.c
++++ b/src/stat/stat.c
+@@ -1,10 +1,15 @@
+ #include <sys/stat.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int stat(const char *restrict path, struct stat *restrict buf)
+ {
++#ifdef SYS_stat
+ 	return syscall(SYS_stat, path, buf);
++#else
++	return syscall(SYS_fstatat, AT_FDCWD, path, buf, 0);
++#endif
+ }
+ 
+ LFS64(stat);
+diff --git a/src/stat/utimensat.c b/src/stat/utimensat.c
+index 929698b..159c8be 100644
+--- a/src/stat/utimensat.c
++++ b/src/stat/utimensat.c
+@@ -1,7 +1,37 @@
+ #include <sys/stat.h>
++#include <sys/time.h>
++#include <fcntl.h>
++#include <errno.h>
+ #include "syscall.h"
+ 
+ int utimensat(int fd, const char *path, const struct timespec times[2], int flags)
+ {
+-	return syscall(SYS_utimensat, fd, path, times, flags);
++	int r = __syscall(SYS_utimensat, fd, path, times, flags);
++#ifdef SYS_futimesat
++	if (r != -ENOSYS || flags) return __syscall_ret(r);
++	struct timeval *tv = 0, tmp[2];
++	if (times) {
++		int i;
++		tv = tmp;
++		for (i=0; i<2; i++) {
++			if (times[i].tv_nsec >= 1000000000ULL) {
++				if (times[i].tv_nsec == UTIME_NOW &&
++				    times[1-i].tv_nsec == UTIME_NOW) {
++					tv = 0;
++					break;
++				}
++				if (times[i].tv_nsec == UTIME_OMIT)
++					return __syscall_ret(-ENOSYS);
++				return __syscall_ret(-EINVAL);
++			}
++			tmp[i].tv_sec = times[i].tv_sec;
++			tmp[i].tv_usec = times[i].tv_nsec / 1000;
++		}
++	}
++
++	r = __syscall(SYS_futimesat, fd, path, tv);
++	if (r != -ENOSYS || fd != AT_FDCWD) return __syscall_ret(r);
++	r = __syscall(SYS_utimes, path, tv);
++#endif
++	return __syscall_ret(r);
+ }
+diff --git a/src/stdio/__fopen_rb_ca.c b/src/stdio/__fopen_rb_ca.c
+index 9202c8c..b72c630 100644
+--- a/src/stdio/__fopen_rb_ca.c
++++ b/src/stdio/__fopen_rb_ca.c
+@@ -6,7 +6,7 @@ FILE *__fopen_rb_ca(const char *filename, FILE *f, unsigned char *buf, size_t le
+ {
+ 	memset(f, 0, sizeof *f);
+ 
+-	f->fd = syscall(SYS_open, filename, O_RDONLY|O_LARGEFILE|O_CLOEXEC, 0);
++	f->fd = sys_open(filename, O_RDONLY|O_CLOEXEC);
+ 	if (f->fd < 0) return 0;
+ 
+ 	f->flags = F_NOWR | F_PERM;
+diff --git a/src/stdio/fopen.c b/src/stdio/fopen.c
+index da17ce8..3d97cfa 100644
+--- a/src/stdio/fopen.c
++++ b/src/stdio/fopen.c
+@@ -18,7 +18,7 @@ FILE *fopen(const char *restrict filename, const char *restrict mode)
+ 	/* Compute the flags to pass to open() */
+ 	flags = __fmodeflags(mode);
+ 
+-	fd = syscall_cp(SYS_open, filename, flags|O_LARGEFILE, 0666);
++	fd = sys_open_cp(filename, flags, 0666);
+ 	if (fd < 0) return 0;
+ 
+ 	f = __fdopen(fd, mode);
+diff --git a/src/stdio/remove.c b/src/stdio/remove.c
+index e147ba2..942e301 100644
+--- a/src/stdio/remove.c
++++ b/src/stdio/remove.c
+@@ -1,9 +1,19 @@
+ #include <stdio.h>
+ #include <errno.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int remove(const char *path)
+ {
+-	int r = syscall(SYS_unlink, path);
+-	return (r && errno == EISDIR) ? syscall(SYS_rmdir, path) : r;
++#ifdef SYS_unlink
++	int r = __syscall(SYS_unlink, path);
++#else
++	int r = __syscall(SYS_unlinkat, AT_FDCWD, path, 0);
++#endif
++#ifdef SYS_rmdir
++	if (r==-EISDIR) r = __syscall(SYS_rmdir, path);
++#else
++	if (r==-EISDIR) r = __syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
++#endif
++	return __syscall_ret(r);
+ }
+diff --git a/src/stdio/rename.c b/src/stdio/rename.c
+index 97f1453..04c90c0 100644
+--- a/src/stdio/rename.c
++++ b/src/stdio/rename.c
+@@ -1,7 +1,12 @@
+ #include <stdio.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int rename(const char *old, const char *new)
+ {
++#ifdef SYS_rename
+ 	return syscall(SYS_rename, old, new);
++#else
++	return syscall(SYS_renameat, AT_FDCWD, old, AT_FDCWD, new);
++#endif
+ }
+diff --git a/src/stdio/tempnam.c b/src/stdio/tempnam.c
+index f73ca9f..45a5f26 100644
+--- a/src/stdio/tempnam.c
++++ b/src/stdio/tempnam.c
+@@ -1,42 +1,48 @@
+ #include <stdio.h>
++#include <fcntl.h>
++#include <errno.h>
++#include <sys/stat.h>
++#include <limits.h>
+ #include <string.h>
+-#include <stdlib.h>
+-#include <stdint.h>
+-#include <unistd.h>
+-#include <time.h>
+-#include "libc.h"
+-#include "atomic.h"
++#include "syscall.h"
+ 
+ #define MAXTRIES 100
+ 
++char *__randname(char *);
++
+ char *tempnam(const char *dir, const char *pfx)
+ {
+-	static int index;
+-	char *s;
+-	struct timespec ts;
+-	int pid = getpid();
+-	size_t l;
+-	int n;
+-	int try=0;
++	char s[PATH_MAX];
++	size_t l, dl, pl;
++	int try;
++	int r;
+ 
+ 	if (!dir) dir = P_tmpdir;
+ 	if (!pfx) pfx = "temp";
+ 
+-	if (access(dir, R_OK|W_OK|X_OK) != 0)
+-		return NULL;
+-
+-	l = strlen(dir) + 1 + strlen(pfx) + 3*(sizeof(int)*3+2) + 1;
+-	s = malloc(l);
+-	if (!s) return s;
++	dl = strlen(dir);
++	pl = strlen(pfx);
++	l = dl + 1 + pl + 1 + 6;
+ 
+-	do {
+-		clock_gettime(CLOCK_REALTIME, &ts);
+-		n = ts.tv_nsec ^ (uintptr_t)&s ^ (uintptr_t)s;
+-		snprintf(s, l, "%s/%s-%d-%d-%x", dir, pfx, pid, a_fetch_add(&index, 1), n);
+-	} while (!access(s, F_OK) && try++<MAXTRIES);
+-	if (try>=MAXTRIES) {
+-		free(s);
++	if (l >= PATH_MAX) {
++		errno = ENAMETOOLONG;
+ 		return 0;
+ 	}
+-	return s;
++
++	memcpy(s, dir, dl);
++	s[dl] = '/';
++	memcpy(s+dl+1, pfx, pl);
++	s[dl+1+pl] = '_';
++
++	for (try=0; try<MAXTRIES; try++) {
++		__randname(s+l-6);
++#ifdef SYS_lstat
++		r = __syscall(SYS_lstat, s, &(struct stat){0});
++#else
++		r = __syscall(SYS_fstatat, AT_FDCWD, s,
++			&(struct stat){0}, AT_SYMLINK_NOFOLLOW);
++#endif
++		if (r == -ENOENT) return strdup(s);
++	}
++	return 0;
+ }
+diff --git a/src/stdio/tmpfile.c b/src/stdio/tmpfile.c
+index 926d660..a7d0000 100644
+--- a/src/stdio/tmpfile.c
++++ b/src/stdio/tmpfile.c
+@@ -1,23 +1,27 @@
+ #include <stdio.h>
+ #include <fcntl.h>
+-#include <unistd.h>
+ #include "stdio_impl.h"
+ 
+ #define MAXTRIES 100
+ 
++char *__randname(char *);
++
+ FILE *tmpfile(void)
+ {
+-	char buf[L_tmpnam], *s;
++	char s[] = "/tmp/tmpfile_XXXXXX";
+ 	int fd;
+ 	FILE *f;
+ 	int try;
+ 	for (try=0; try<MAXTRIES; try++) {
+-		s = tmpnam(buf);
+-		if (!s) return 0;
+-		fd = syscall(SYS_open, s, O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600);
++		__randname(s+13);
++		fd = sys_open(s, O_RDWR|O_CREAT|O_EXCL, 0600);
+ 		if (fd >= 0) {
+ 			f = __fdopen(fd, "w+");
++#ifdef SYS_unlink
+ 			__syscall(SYS_unlink, s);
++#else
++			__syscall(SYS_unlinkat, AT_FDCWD, s, 0);
++#endif
+ 			return f;
+ 		}
+ 	}
+diff --git a/src/stdio/tmpnam.c b/src/stdio/tmpnam.c
+index 2bd72b3..449eb9b 100644
+--- a/src/stdio/tmpnam.c
++++ b/src/stdio/tmpnam.c
+@@ -1,31 +1,29 @@
+ #include <stdio.h>
+-#include <stdlib.h>
+-#include <stdint.h>
+-#include <unistd.h>
+-#include <time.h>
+-#include "libc.h"
++#include <fcntl.h>
++#include <errno.h>
++#include <sys/stat.h>
++#include <string.h>
+ #include "syscall.h"
+-#include "atomic.h"
+ 
+ #define MAXTRIES 100
+ 
+-char *tmpnam(char *s)
+-{
+-	static int index;
+-	static char s2[L_tmpnam];
+-	struct timespec ts;
+-	int try = 0;
+-	unsigned n;
+-
+-	if (!s) s = s2;
++char *__randname(char *);
+ 
+-	if (__syscall(SYS_access, P_tmpdir, R_OK|W_OK|X_OK) != 0)
+-		return NULL;
+-
+-	do {
+-		__syscall(SYS_clock_gettime, CLOCK_REALTIME, &ts, 0);
+-		n = ts.tv_nsec ^ (uintptr_t)&s ^ (uintptr_t)s;
+-		snprintf(s, L_tmpnam, "/tmp/t%x-%x", a_fetch_add(&index, 1), n);
+-	} while (!__syscall(SYS_access, s, F_OK) && try++<MAXTRIES);
+-	return try>=MAXTRIES ? 0 : s;
++char *tmpnam(char *buf)
++{
++	static char internal[L_tmpnam];
++	char s[] = "/tmp/tmpnam_XXXXXX";
++	int try;
++	int r;
++	for (try=0; try<MAXTRIES; try++) {
++		__randname(s+12);
++#ifdef SYS_lstat
++		r = __syscall(SYS_lstat, s, &(struct stat){0});
++#else
++		r = __syscall(SYS_fstatat, AT_FDCWD, s,
++			&(struct stat){0}, AT_SYMLINK_NOFOLLOW);
++#endif
++		if (r == -ENOENT) return strcpy(buf ? buf : internal, s);
++	}
++	return 0;
+ }
+diff --git a/src/stdio/vfprintf.c b/src/stdio/vfprintf.c
+index f6e7f38..ea25772 100644
+--- a/src/stdio/vfprintf.c
++++ b/src/stdio/vfprintf.c
+@@ -13,8 +13,6 @@
+ 
+ #define MAX(a,b) ((a)>(b) ? (a) : (b))
+ #define MIN(a,b) ((a)<(b) ? (a) : (b))
+-#define CONCAT2(x,y) x ## y
+-#define CONCAT(x,y) CONCAT2(x,y)
+ 
+ /* Convenient bit representation for modifier flags, which all fall
+  * within 31 codepoints of the space character. */
+@@ -343,7 +341,7 @@ static int fmt_fp(FILE *f, long double y, int w, int p, int fl, int t)
+ 		x = *d % i;
+ 		/* Are there any significant digits past j? */
+ 		if (x || d+1!=z) {
+-			long double round = CONCAT(0x1p,LDBL_MANT_DIG);
++			long double round = 2/LDBL_EPSILON;
+ 			long double small;
+ 			if (*d/i & 1) round += 2;
+ 			if (x<i/2) small=0x0.8p0;
+diff --git a/src/time/__map_file.c b/src/time/__map_file.c
+index 84ae839..d06a581 100644
+--- a/src/time/__map_file.c
++++ b/src/time/__map_file.c
+@@ -9,8 +9,7 @@ const char unsigned *__map_file(const char *pathname, size_t *size)
+ {
+ 	struct stat st;
+ 	const unsigned char *map = MAP_FAILED;
+-	int flags = O_RDONLY|O_LARGEFILE|O_CLOEXEC|O_NONBLOCK;
+-	int fd = __syscall(SYS_open, pathname, flags);
++	int fd = __sys_open(pathname, O_RDONLY|O_CLOEXEC|O_NONBLOCK);
+ 	if (fd < 0) return 0;
+ 	if (!__syscall(SYS_fstat, fd, &st))
+ 		map = __mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+diff --git a/src/time/utime.c b/src/time/utime.c
+index b2b5741..e7592b2 100644
+--- a/src/time/utime.c
++++ b/src/time/utime.c
+@@ -1,14 +1,11 @@
+ #include <utime.h>
+-#include <sys/time.h>
+-#include "syscall.h"
++#include <sys/stat.h>
++#include <time.h>
++#include <fcntl.h>
+ 
+ int utime(const char *path, const struct utimbuf *times)
+ {
+-	if (times) {
+-		struct timeval tv[2] = {
+-			{ .tv_sec = times->actime },
+-			{ .tv_sec = times->modtime } };
+-		return syscall(SYS_utimes, path, tv);
+-	}
+-	return syscall(SYS_utimes, path, 0);
++	return utimensat(AT_FDCWD, path, times ? ((struct timespec [2]){
++		{ .tv_sec = times->actime }, { .tv_sec = times->modtime }})
++		: 0, 0);
+ }
+diff --git a/src/unistd/access.c b/src/unistd/access.c
+index e7ce73a..d6eed68 100644
+--- a/src/unistd/access.c
++++ b/src/unistd/access.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int access(const char *filename, int amode)
+ {
++#ifdef SYS_access
+ 	return syscall(SYS_access, filename, amode);
++#else
++	return syscall(SYS_faccessat, AT_FDCWD, filename, amode, 0);
++#endif
+ }
+diff --git a/src/unistd/chown.c b/src/unistd/chown.c
+index 95f6f61..14b0325 100644
+--- a/src/unistd/chown.c
++++ b/src/unistd/chown.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int chown(const char *path, uid_t uid, gid_t gid)
+ {
++#ifdef SYS_chown
+ 	return syscall(SYS_chown, path, uid, gid);
++#else
++	return syscall(SYS_fchownat, AT_FDCWD, path, uid, gid, 0);
++#endif
+ }
+diff --git a/src/unistd/dup2.c b/src/unistd/dup2.c
+index 87a0d44..8f43c6d 100644
+--- a/src/unistd/dup2.c
++++ b/src/unistd/dup2.c
+@@ -1,10 +1,20 @@
+ #include <unistd.h>
+ #include <errno.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int dup2(int old, int new)
+ {
+ 	int r;
++#ifdef SYS_dup2
+ 	while ((r=__syscall(SYS_dup2, old, new))==-EBUSY);
++#else
++	if (old==new) {
++		r = __syscall(SYS_fcntl, old, F_GETFD);
++		if (r >= 0) return old;
++	} else {
++		while ((r=__syscall(SYS_dup3, old, new, 0))==-EBUSY);
++	}
++#endif
+ 	return __syscall_ret(r);
+ }
+diff --git a/src/unistd/dup3.c b/src/unistd/dup3.c
+index 1f7134b..0eb6caf 100644
+--- a/src/unistd/dup3.c
++++ b/src/unistd/dup3.c
+@@ -8,6 +8,7 @@
+ int __dup3(int old, int new, int flags)
+ {
+ 	int r;
++#ifdef SYS_dup2
+ 	if (old==new) return __syscall_ret(-EINVAL);
+ 	if (flags & O_CLOEXEC) {
+ 		while ((r=__syscall(SYS_dup3, old, new, flags))==-EBUSY);
+@@ -15,6 +16,9 @@ int __dup3(int old, int new, int flags)
+ 	}
+ 	while ((r=__syscall(SYS_dup2, old, new))==-EBUSY);
+ 	if (flags & O_CLOEXEC) __syscall(SYS_fcntl, new, F_SETFD, FD_CLOEXEC);
++#else
++	while ((r=__syscall(SYS_dup3, old, new, flags))==-EBUSY);
++#endif
+ 	return __syscall_ret(r);
+ }
+ 
+diff --git a/src/unistd/fchown.c b/src/unistd/fchown.c
+index 36633b0..0345984 100644
+--- a/src/unistd/fchown.c
++++ b/src/unistd/fchown.c
+@@ -13,5 +13,10 @@ int fchown(int fd, uid_t uid, gid_t gid)
+ 
+ 	char buf[15+3*sizeof(int)];
+ 	__procfdname(buf, fd);
++#ifdef SYS_chown
+ 	return syscall(SYS_chown, buf, uid, gid);
++#else
++	return syscall(SYS_fchownat, AT_FDCWD, buf, uid, gid);
++#endif
++
+ }
+diff --git a/src/unistd/getpgrp.c b/src/unistd/getpgrp.c
+index 433f42e..90e9bb0 100644
+--- a/src/unistd/getpgrp.c
++++ b/src/unistd/getpgrp.c
+@@ -3,5 +3,5 @@
+ 
+ pid_t getpgrp(void)
+ {
+-	return __syscall(SYS_getpgrp);
++	return __syscall(SYS_getpgid, 0);
+ }
+diff --git a/src/unistd/lchown.c b/src/unistd/lchown.c
+index de871ae..ccd5ee0 100644
+--- a/src/unistd/lchown.c
++++ b/src/unistd/lchown.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int lchown(const char *path, uid_t uid, gid_t gid)
+ {
++#ifdef SYS_lchown
+ 	return syscall(SYS_lchown, path, uid, gid);
++#else
++	return syscall(SYS_fchownat, AT_FDCWD, path, uid, gid, AT_SYMLINK_NOFOLLOW);
++#endif
+ }
+diff --git a/src/unistd/link.c b/src/unistd/link.c
+index 20193f2..feec18e 100644
+--- a/src/unistd/link.c
++++ b/src/unistd/link.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int link(const char *existing, const char *new)
+ {
++#ifdef SYS_link
+ 	return syscall(SYS_link, existing, new);
++#else
++	return syscall(SYS_linkat, AT_FDCWD, existing, AT_FDCWD, new, 0);
++#endif
+ }
+diff --git a/src/unistd/pause.c b/src/unistd/pause.c
+index f7ed17d..56eb171 100644
+--- a/src/unistd/pause.c
++++ b/src/unistd/pause.c
+@@ -1,8 +1,13 @@
+ #include <unistd.h>
++#include <signal.h>
+ #include "syscall.h"
+ #include "libc.h"
+ 
+ int pause(void)
+ {
++#ifdef SYS_pause
+ 	return syscall_cp(SYS_pause);
++#else
++	return syscall_cp(SYS_ppoll, 0, 0, 0, 0);
++#endif
+ }
+diff --git a/src/unistd/pipe.c b/src/unistd/pipe.c
+index 36c6f13..d07b8d2 100644
+--- a/src/unistd/pipe.c
++++ b/src/unistd/pipe.c
+@@ -3,5 +3,9 @@
+ 
+ int pipe(int fd[2])
+ {
++#ifdef SYS_pipe
+ 	return syscall(SYS_pipe, fd);
++#else
++	return syscall(SYS_pipe2, fd, 0);
++#endif
+ }
+diff --git a/src/unistd/readlink.c b/src/unistd/readlink.c
+index ec291e3..a152d52 100644
+--- a/src/unistd/readlink.c
++++ b/src/unistd/readlink.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize)
+ {
++#ifdef SYS_readlink
+ 	return syscall(SYS_readlink, path, buf, bufsize);
++#else
++	return syscall(SYS_readlinkat, AT_FDCWD, path, buf, bufsize);
++#endif
+ }
+diff --git a/src/unistd/rmdir.c b/src/unistd/rmdir.c
+index dfe1605..6825ffc 100644
+--- a/src/unistd/rmdir.c
++++ b/src/unistd/rmdir.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int rmdir(const char *path)
+ {
++#ifdef SYS_rmdir
+ 	return syscall(SYS_rmdir, path);
++#else
++	return syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
++#endif
+ }
+diff --git a/src/unistd/symlink.c b/src/unistd/symlink.c
+index 5902d45..0973d78 100644
+--- a/src/unistd/symlink.c
++++ b/src/unistd/symlink.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int symlink(const char *existing, const char *new)
+ {
++#ifdef SYS_symlink
+ 	return syscall(SYS_symlink, existing, new);
++#else
++	return syscall(SYS_symlinkat, existing, AT_FDCWD, new);
++#endif
+ }
+diff --git a/src/unistd/unlink.c b/src/unistd/unlink.c
+index bdb37be..c40c28d 100644
+--- a/src/unistd/unlink.c
++++ b/src/unistd/unlink.c
+@@ -1,7 +1,12 @@
+ #include <unistd.h>
++#include <fcntl.h>
+ #include "syscall.h"
+ 
+ int unlink(const char *path)
+ {
++#ifdef SYS_unlink
+ 	return syscall(SYS_unlink, path);
++#else
++	return syscall(SYS_unlinkat, AT_FDCWD, path, 0);
++#endif
+ }
diff --git a/main/musl/APKBUILD b/main/musl/APKBUILD
index 3855104852..f44f100d7c 100644
--- a/main/musl/APKBUILD
+++ b/main/musl/APKBUILD
@@ -2,7 +2,7 @@
 # Maintainer: Timo Teräs <timo.teras@iki.fi>
 pkgname=musl
 pkgver=1.1.1
-pkgrel=0
+pkgrel=1
 pkgdesc="the musl c library (libc) implementation"
 url="http://www.musl-libc.org/"
 arch="all"
@@ -12,8 +12,8 @@ depends_dev="!uclibc-dev"
 makedepends="$depends_dev"
 install=""
 subpackages="$pkgname-dev $pkgname-utils"
-[ "${CTARGET#*musl}" = "$CTARGET" ] && subpackages="$subpackages musl-gcc:crosstool"
 source="http://www.musl-libc.org/releases/musl-$pkgver.tar.gz
+	0001-v1.1.1-to-76f440cf.patch
 	1001-add-basic-dns-record-parsing-functions.patch
 	1002-reimplement-if_nameindex-and-getifaddrs-using-netlin.patch
 	1003-implement-y-and-C-specifiers-in-strptime.patch
@@ -118,14 +118,8 @@ utils() {
 	install -D -m755 "$srcdir"/ldconfig "$subpkgdir"/sbin
 }
 
-crosstool() {
-	mkdir -p "$subpkgdir"/usr/bin "$subpkgdir"/usr/lib
-	mv "$pkgdir"/usr/bin/musl-gcc "$subpkgdir"/usr/bin
-	mv "$pkgdir"/usr/lib/musl-gcc.specs "$subpkgdir"/usr/lib
-	find "$pkgdir" -type d -delete 2>/dev/null
-}
-
 md5sums="dbc08d311148e095016d9bbf6c7ffda6  musl-1.1.1.tar.gz
+d4a40fe1656115b2956065ab48e0b372  0001-v1.1.1-to-76f440cf.patch
 a3810683ef61ac27e2f6ec9801280c81  1001-add-basic-dns-record-parsing-functions.patch
 83c3bd2a50b1de5ef948704d3f4e0583  1002-reimplement-if_nameindex-and-getifaddrs-using-netlin.patch
 fc3feec4104a4b25781df92dd96b9eec  1003-implement-y-and-C-specifiers-in-strptime.patch
@@ -137,6 +131,7 @@ cb82d21fed17a116b44b830adba71c5a  getconf.c
 2b941c4251cac44988a4abfc50e21267  getent.c
 45f92f8d59cf84d765de698a9578dbf4  iconv.c"
 sha256sums="9dd75d6512e44d5a13254e246db56c90365894b05bab2b1127e44a31e4fd7c36  musl-1.1.1.tar.gz
+40f241a8aa59621d8a9e6a616df27c38e0a622243bf7346cc98ec1c37454e92a  0001-v1.1.1-to-76f440cf.patch
 758390768b1bc4159d56908ca332b9640cd0552ed3b4b2b8d4a6d499c54c11a1  1001-add-basic-dns-record-parsing-functions.patch
 1c25880095e869b827f02997e864fdf4bf157a4e923e52d97dbd05e657aedb70  1002-reimplement-if_nameindex-and-getifaddrs-using-netlin.patch
 c22338bc33e8c0c22b280c392b37a0903e13562e671f5ebade09ed5b1d33e2ae  1003-implement-y-and-C-specifiers-in-strptime.patch
@@ -148,6 +143,7 @@ d9b644ec20bc33e81a7c52b9fcf7973d835923a69faf50f03db45534b811bd96  getopt_long.c
 68373a55e89ce85c562d941ccf588337d6cc6c9c17689d695f65cd7607134bbe  getent.c
 f79a2930a2e5bb0624321589edf8b889d1e9b603e01e6b7ae214616605b3fdd7  iconv.c"
 sha512sums="5182deb80a35c8a4009d71098c95a16e5ab9bd03186443917652f0c521d2980183e203256493a69e8230b6a0c4848ca8e44de9e8c851a511cd37d0d41f91b14f  musl-1.1.1.tar.gz
+30906a5f7a01ff05693e5a2e72f6c7e75ff7939c28a32b9e777d14d59412bb9df603a09aa8dd693e9a0b70525474a62f7bc657425032a3a5f4b339667e6f62ec  0001-v1.1.1-to-76f440cf.patch
 dad965258daf69371b844f76bfe5a914b0eca0ca76f3fc340b8fd7acf598b5f87bbe6d68b1f43ed0293ee0ed3bfd85d5173ccc169aa6265646248d5b8a906708  1001-add-basic-dns-record-parsing-functions.patch
 72cf33738d2cf31f6ec02312bc494d754c17470b519172bb8bd7e2e29ac3b119023088a2b3fbc0dbc2fddd0078ccbae62096106cae361f8c31d6a9950043af25  1002-reimplement-if_nameindex-and-getifaddrs-using-netlin.patch
 48082d2348de40bc6b455266c5552a62e1e75f926e69116c61c8a3cb35fefdff136dc771bf25ee7d43c959834921221112ed7afcc45fcadbcf07562510786916  1003-implement-y-and-C-specifiers-in-strptime.patch