core: use string instead of compound literal

fixes compilation when memcpy is defined as a function-like macro at
the cost of one more byte used for the unused zero terminator.

closes #578

.gitignore

@@ -1,4 +1,5 @@
 proxychains4
+proxychains4-daemon
 *.bz2
 *.xz
 *.o

Makefile

@@ -11,25 +11,31 @@ bindir = $(exec_prefix)/bin
 prefix = /usr/local/
 includedir = $(prefix)/include
 libdir = $(prefix)/lib
-sysconfdir=$(prefix)/etc
+sysconfdir = $(prefix)/etc
+zshcompletiondir = $(prefix)/share/zsh/site-functions
 
-SRCS = $(sort $(wildcard src/*.c))
+OBJS = src/common.o src/main.o
-OBJS = $(SRCS:.c=.o)
+
-LOBJS = src/nameinfo.o src/version.o \
+DOBJS = src/daemon/hsearch.o \
+        src/daemon/sblist.o src/daemon/sblist_delete.o \
+        src/daemon/daemon.o src/daemon/udpserver.o
+
+LOBJS = src/version.o \
         src/core.o src/common.o src/libproxychains.o \
-        src/allocator_thread.o src/ip_type.o \
+        src/allocator_thread.o src/rdns.o \
         src/hostsreader.o src/hash.o src/debug.o
 
+
 GENH = src/version.h
 
 CFLAGS  += -Wall -O0 -g -std=c99 -D_GNU_SOURCE -pipe
 NO_AS_NEEDED = -Wl,--no-as-needed
-LIBDL   = -ldl
+LDFLAGS = -fPIC $(NO_AS_NEEDED) $(LIBDL) $(PTHREAD)
-LDFLAGS = -fPIC $(NO_AS_NEEDED) $(LIBDL) -lpthread
 INC     = 
 PIC     = -fPIC
 AR      = $(CROSS_COMPILE)ar
 RANLIB  = $(CROSS_COMPILE)ranlib
+SOCKET_LIBS =
 
 LDSO_SUFFIX = so
 LD_SET_SONAME = -Wl,-soname=
@@ -40,8 +46,10 @@ LDSO_PATHNAME = libproxychains4.$(LDSO_SUFFIX)
 SHARED_LIBS = $(LDSO_PATHNAME)
 ALL_LIBS = $(SHARED_LIBS)
 PXCHAINS = proxychains4
-ALL_TOOLS = $(PXCHAINS)
+PXCHAINS_D = proxychains4-daemon
+ALL_TOOLS = $(PXCHAINS) $(PXCHAINS_D)
 ALL_CONFIGS = src/proxychains.conf
+ZSH_COMPLETION = completions/zsh/_proxychains4
 
 -include config.mak
 
@@ -62,14 +70,18 @@ $(DESTDIR)$(libdir)/%: %
 $(DESTDIR)$(sysconfdir)/%: src/%
 	$(INSTALL) -D -m 644 $< $@
 
+$(DESTDIR)$(zshcompletiondir)/%: completions/zsh/%
+	$(INSTALL) -D -m 644 $< $@
+
 install-libs: $(ALL_LIBS:%=$(DESTDIR)$(libdir)/%)
 install-tools: $(ALL_TOOLS:%=$(DESTDIR)$(bindir)/%)
 install-config: $(ALL_CONFIGS:src/%=$(DESTDIR)$(sysconfdir)/%)
+install-zsh-completion: $(ZSH_COMPLETION:completions/zsh/%=$(DESTDIR)$(zshcompletiondir)/%)
 
 clean:
 	rm -f $(ALL_LIBS)
 	rm -f $(ALL_TOOLS)
-	rm -f $(OBJS)
+	rm -f $(OBJS) $(LOBJS) $(DOBJS)
 	rm -f $(GENH)
 
 src/version.h: $(wildcard VERSION .git)
@@ -81,11 +93,14 @@ src/version.o: src/version.h
 	$(CC) $(CPPFLAGS) $(CFLAGS) $(CFLAGS_MAIN) $(INC) $(PIC) -c -o $@ $<
 
 $(LDSO_PATHNAME): $(LOBJS)
-	$(CC) $(LDFLAGS) $(LD_SET_SONAME)$(LDSO_PATHNAME) $(USER_LDFLAGS) \
+	$(CC) $(LDFLAGS) $(FAT_LDFLAGS) $(LD_SET_SONAME)$(LDSO_PATHNAME) \
-		-shared -o $@ $(LOBJS)
+		$(USER_LDFLAGS) -shared -o $@ $^ $(SOCKET_LIBS)
 
-$(ALL_TOOLS): $(OBJS)
+$(PXCHAINS): $(OBJS)
-	$(CC) src/main.o src/common.o $(USER_LDFLAGS) -o $(PXCHAINS)
+	$(CC) $^ $(FAT_BIN_LDFLAGS) $(USER_LDFLAGS) $(LIBDL) -o $@
+
+$(PXCHAINS_D): $(DOBJS)
+	$(CC) $^ $(FAT_BIN_LDFLAGS) $(USER_LDFLAGS) -o $@
 
 
-.PHONY: all clean install install-config install-libs install-tools
+.PHONY: all clean install install-config install-libs install-tools install-zsh-completion

README

@@ -1,4 +1,4 @@
-ProxyChains-NG ver 4.12 README
+ProxyChains-NG ver 4.17 README
 =============================
 
   ProxyChains is a UNIX program, that hooks network-related libc functions
@@ -16,7 +16,7 @@ ProxyChains-NG ver 4.12 README
   If your program doesn't work with proxychains, consider using an
   iptables based solution instead; this is much more robust.
 
-  Supported Platforms: Linux, BSD, Mac.
+  Supported Platforms: Linux, BSD, Mac, Haiku.
 
 
 *********** ATTENTION ***********
@@ -52,6 +52,50 @@ ProxyChains-NG ver 4.12 README
 
 Changelog:
 ----------
+Version 4.17
+- add hook for close_range function, fixing newer versions of openssh
+- fat-binary-m1 option for mac
+- fix DNS error handling in proxy_dns_old
+- simplify init code
+- fix openbsd preloading
+- fix double-close in multithreaded apps
+- various improvements to configure script
+
+Version 4.16
+- fix regression in configure script linker flag detection
+- remove 10 year old workaround for wrong glibc getnameinfo signature
+- support for new DYLD hooking method for OSX Monterey
+- netbsd compilation fix
+- support IPv6 localnets
+- more user-friendly error message when execvp fails
+- proxy_getaddrinfo(): fill in ai_socktype if requested
+
+Version 4.15
+- fix configure script for buggy binutils version
+- initialize rand_seed with nano-second granularity
+- add support for numeric ipv6 in getaddrinfo
+- fix bug in getaddrinfo when node is null and !passive
+- add dnat feature
+- add raw proxy type
+- add haiku support
+- add proxy_dns_old to emulate proxychains 3.1 behaviour
+- add new proxy_dns_daemon feature (experimental)
+- various other fixes
+
+Version 4.14
+- allow alternative proto://user:pass@ip:port syntax for proxylist
+- fix endless loop in round robin mode when all proxies are down (#147)
+- fix compilation on android (#265)
+- fix fd leak in forked processes (#273)
+- skip connection attempt to nullrouted ips
+- allow hostnames for proxylist under specific circumstances
+
+Version 4.13
+- fix robustness of DNS lookup thread and a segfault
+- fix socks5 user/pass auth on non-conforming servers
+- fix memory leak
+- add support for Solaris
+
 Version 4.12
 - fix several build issues
   - for MAC
@@ -222,7 +266,7 @@ Known Problems:
 
 Community:
 ----------
-#proxychains on irc.freenode.net
+#proxychains on irc.libera.chat
 
 Donations:
 ----------

VERSION

@@ -1 +1 @@
-4.12
+4.17

completions/zsh/_proxychains4

@@ -0,0 +1,8 @@
+#compdef proxychains4
+
+_arguments \
+  '(- : *)--help[More help in README file]' \
+  '-q[makes proxychains quiet - this overrides the config setting]' \
+  '-f[allows one to manually specify a configfile to use]: :_files' \
+  '(-)1: :{_command_names -e}' \
+  '*:: :_normal'

configure

@@ -4,6 +4,7 @@ prefix=/usr/local
 OUR_CPPFLAGS=
 
 # Get a temporary filename
+fail() { printf "%s\n" "$1" >&2 ; exit 1 ; }
 i=0
 set -C
 while : ; do i=$(($i+1))
@@ -14,38 +15,33 @@ done
 set +C
 trap 'rm "$tmpc"' EXIT INT QUIT TERM HUP
 
-ismac() {
-	uname -s | grep Darwin >/dev/null
-}
-
-isx86_64() {
-	uname -m | grep -i X86_64 >/dev/null
-}
-
-isbsd() {
-	uname -s | grep BSD >/dev/null
-}
-
-isopenbsd() {
-	uname -s | grep OpenBSD >/dev/null
-}
-
 check_compile() {
 	printf "checking %s ... " "$1"
 	printf "$3" > "$tmpc"
 	local res=0
-	$CC $OUR_CPPFLAGS $CPPFLAGS $2 $CFLAGS -c "$tmpc" -o /dev/null >/dev/null 2>&1 \
+	$CC $OUR_CPPFLAGS $CPPFLAGS $2 $CFLAGS "$tmpc" -o "$tmpc".out >/dev/null 2>&1 \
 	|| res=1
 	test x$res = x0 && \
 	{ printf "yes\n" ; test x"$2" = x || OUR_CPPFLAGS="$OUR_CPPFLAGS $2" ; } \
 	|| printf "no\n"
+	rm -f "$tmpc".out
 	return $res
 }
 
+get_define() {
+	$CC $OUR_CPPFLAGS $CPPFLAGS $CFLAGS -dM -E - </dev/null | grep "$1"
+}
+
+get_define_stripped() {
+	local output=$(get_define "$1")
+	test "$?" = 0 || return 1
+	printf "%s\n" "$output" | sed 's/^.* .* //'
+}
+
 check_define() {
 	printf "checking whether \$CC defines %s ... " "$1"
 	local res=1
-	$CC $OUR_CPPFLAGS $CPPFLAGS $CFLAGS -dM -E - </dev/null | grep "$1" >/dev/null && res=0
+	get_define "$1" >/dev/null && res=0
 	test x$res = x0 && printf "yes\n" || printf "no\n"
 	return $res
 }
@@ -62,6 +58,22 @@ check_compile_run() {
 	return $res
 }
 
+check_link_silent() {
+	printf "$2" > "$tmpc"
+	local res=0
+	$CC $OUR_CPPFLAGS $CPPFLAGS $1 $CFLAGS "$tmpc" -o "$tmpc".out  >/dev/null 2>&1 || res=1
+	rm -f "$tmpc".out
+	return $res
+}
+
+check_link() {
+	printf "checking %s ... " "$1"
+	local res=0
+	check_link_silent "$2" "$3" || res=1
+	test x$res = x0 && printf "yes\n" || printf "no\n"
+	return $res
+}
+
 usage() {
 	echo "supported arguments"
 	echo "--prefix=/path            default: $prefix"
@@ -72,8 +84,12 @@ usage() {
 	echo "--sysconfdir=/path        default: $prefix/etc"
 	echo "--ignore-cve              default: no"
 	echo "	if set to yes ignores CVE-2015-3887 and makes it possible"
-	echo "	to preload from current dir (insecure)"
+	echo "	to preload from current dir (possibly insecure, but handy)"
-	ismac && isx86_64 && echo "--fat-binary : build for both i386 and x86_64 architectures on 64-bit Macs"
+	echo "--fat-binary : build for both i386 and x86_64 architectures on 64-bit Macs"
+	echo "--fat-binary-m1 : build for both arm64e and x86_64 architectures on M1 Macs"
+	echo "--fat-binary-m2 : build for arm64, arm64e and x86_64 architectures on M2+ Macs"
+	echo "--hookmethod=dlsym|dyld   hook method for osx. default: auto"
+	echo "  if OSX >= 12 is detected, dyld method will be used if auto."
 	echo "--help : show this text"
 	exit 1
 }
@@ -86,7 +102,11 @@ spliteq() {
 }
 
 fat_binary=
+fat_binary_m1=
+fat_binary_m2=
 ignore_cve=no
+hookmethod=auto
+
 parsearg() {
 	case "$1" in
 	--prefix=*) prefix=`spliteq $1`;;
@@ -97,7 +117,10 @@ parsearg() {
 	--sysconfdir=*) sysconfdir=`spliteq $1`;;
 	--ignore-cve) ignore_cve=1;;
 	--ignore-cve=*) ignore_cve=`spliteq $1`;;
+	--hookmethod=*) hookmethod=`spliteq $1`;;
 	--fat-binary) fat_binary=1;;
+	--fat-binary-m1) fat_binary_m1=1;;
+	--fat-binary-m2) fat_binary_m2=1;;
 	--help) usage;;
 	esac
 }
@@ -133,20 +156,81 @@ if [ -z "$CC" ] ; then
 	CC=cc
 fi
 
-check_compile 'whether netinet/in.h defines s6_addr16' "" \
+echo > config.mak
-'#include <netinet/in.h>\nint main(int a, char**c){struct in6_addr x={.s6_addr32[0]=a};return x.s6_addr16[0]; }' \
+
-|| {
+bsd_detected=false
-check_compile 'whether netinet/in.h defines __u6_addr.__u6_addr16' \
+isbsd() {
-'-Ds6_addr16=__u6_addr.__u6_addr16 -Ds6_addr32=__u6_addr.__u6_addr32' \
+	$bsd_detected
-'#include <netinet/in.h>\nint main(int a, char**c){struct in6_addr x={.s6_addr32[0]=a};return x.s6_addr16[0]; }'
+}
+mac_detected=false
+ismac() {
+	$mac_detected
+}
+mac_64=false
+ismac64() {
+	$mac_64
+}
+solaris_detected=false
+issolaris() {
+	$solaris_detected
+}
+haiku_detected=false
+ishaiku() {
+	$haiku_detected
 }
 
-check_define __OpenBSD__ && \
+check_compile 'whether C compiler works' '' 'int main() {return 0;}' || fail 'error: install a C compiler and library'
+check_compile 'whether libc headers are complete' '' '#include <netdb.h>\nint main() {return 0;}' || fail 'error: necessary libc headers are not installed'
+check_compile 'whether C compiler understands -Wno-unknown-pragmas' '-Wno-unknown-pragmas' 'int main() {return 0;}'
+
+if ! check_compile 'whether getnameinfo() servlen argument is POSIX compliant (socklen_t)' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=socklen_t -DGN_FLAGS_T=int" \
+'#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, int);int main() {\nreturn 0;}' ; then
+ # GLIBC < 2.14
+ if ! check_compile 'whether getnameinfo() flags argument is unsigned' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=socklen_t -DGN_FLAGS_T=unsigned" \
+  '#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, unsigned);int main() {\nreturn 0;}' ; then
+  if ! check_compile 'whether getnameinfo() servlen argument is size_t' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=size_t -DGN_FLAGS_T=int" \
+   '#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, size_t, int);int main() {\nreturn 0;}' ; then
+   # OpenBSD & FreeBSD
+   if ! check_compile 'whether getnameinfo() servlen and nodelen argument is size_t' "-DGN_NODELEN_T=size_t -DGN_SERVLEN_T=size_t -DGN_FLAGS_T=int" \
+    '#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int);int main() {\nreturn 0;}' ; then
+     fail "failed to detect getnameinfo signature"
+   fi
+  fi
+ fi
+fi
+
+check_compile 'whether we have GNU-style getservbyname_r()' "-DHAVE_GNU_GETSERVBYNAME_R" \
+'#define _GNU_SOURCE\n#include <netdb.h>\nint main() {\nstruct servent *se = 0;struct servent se_buf;char buf[1024];\ngetservbyname_r("foo", (void*) 0, &se_buf, buf, sizeof(buf), &se);\nreturn 0;}'
+
+check_compile 'whether we have pipe2() and O_CLOEXEC' "-DHAVE_PIPE2" \
+'#define _GNU_SOURCE\n#include <fcntl.h>\n#include <unistd.h>\nint main() {\nint pipefd[2];\npipe2(pipefd, O_CLOEXEC);\nreturn 0;}'
+
+check_compile 'whether we have SOCK_CLOEXEC' "-DHAVE_SOCK_CLOEXEC" \
+'#define _GNU_SOURCE\n#include <sys/socket.h>\nint main() {\nreturn socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);}'
+
+check_compile 'whether we have clock_gettime' "-DHAVE_CLOCK_GETTIME" \
+'#define _GNU_SOURCE\n#include <time.h>\nint main() {\nstruct timespec now;clock_gettime(CLOCK_REALTIME, &now);\nreturn now.tv_sec ^ now.tv_nsec;}'
+
+check_define __APPLE__ && {
+	mac_detected=true
+	check_define __x86_64__ && mac_64=true
+	if test "$hookmethod" = auto ; then
+		osver=$(get_define_stripped __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ 2>/dev/null)
+		test "$osver" -gt $((120000 - 1)) && hookmethod=dyld
+	fi
+}
+check_define __FreeBSD__ && bsd_detected=true
+check_define __OpenBSD__ && {
+bsd_detected=true
+echo "CFLAGS+=-DIS_OPENBSD">>config.mak
 check_compile_run 'whether OpenBSDs fclose() (illegally) calls close()' \
 '#include <stdio.h>\n#include<stdlib.h>\nint close(int x){exit(0);}int main(){fclose(stdin);return 1;}' && \
 OUR_CPPFLAGS="$OUR_CPPFLAGS -DBROKEN_FCLOSE"
+}
+check_define __sun && check_define __SVR4 && solaris_detected=true
+check_define __HAIKU__ && haiku_detected=true
 
-echo "CC=$CC">config.mak
+echo "CC=$CC">>config.mak
 [ -z "$CPPFLAGS" ] || echo "CPPFLAGS=$CPPFLAGS">>config.mak
 [ -z "$CFLAGS" ] || echo "USER_CFLAGS=$CFLAGS">>config.mak
 [ -z "$LDFLAGS" ] || echo "USER_LDFLAGS=$LDFLAGS">>config.mak
@@ -158,22 +242,75 @@ echo includedir=$includedir>>config.mak
 echo sysconfdir=$sysconfdir>>config.mak
 [ "$ignore_cve" = "no" ] && echo "CPPFLAGS+= -DSUPER_SECURE">>config.mak
 [ -z "$OUR_CPPFLAGS" ] || echo "CPPFLAGS+= $OUR_CPPFLAGS" >>config.mak
+
+check_link "whether we can use -Wl,--no-as-needed" "-Wl,--no-as-needed" \
+"int main() { return 0; }" || echo NO_AS_NEEDED= >> config.mak
+
+LD_SONAME_FLAG=
+printf "checking what's the option to use in linker to set library name ... "
+for o in --soname -h -soname -install_name; do
+	check_link_silent "-shared -Wl,$o,libconftest.so" "void test_func(int a) {}" && LD_SONAME_FLAG=$o && break
+done
+if [ -z "$LD_SONAME_FLAG" ]; then
+	printf '\ncannot find an option to set library name\n'
+	exit 1
+fi
+echo "$LD_SONAME_FLAG"
+echo "LD_SET_SONAME = -Wl,$LD_SONAME_FLAG," >> config.mak
+
+if check_link "checking whether we can use -ldl" "-ldl" \
+"int main(){return 0;}" ; then
+echo "LIBDL = -ldl" >> config.mak
+fi
+
+if check_link "checking whether we can use -lpthread" "-lpthread" \
+"int main(){return 0;}" ; then
+echo "PTHREAD = -lpthread" >> config.mak
+else
+check_link "checking whether we can use -pthread" "-pthread" \
+"int main(){return 0;}" || fail "no pthread support detected"
+echo "PTHREAD = -pthread" >> config.mak
+fi
+
 make_cmd=make
 if ismac ; then
-	echo NO_AS_NEEDED=>>config.mak
 	echo LDSO_SUFFIX=dylib>>config.mak
 	echo MAC_CFLAGS+=-DIS_MAC=1>>config.mak
-	if isx86_64 && [ "$fat_binary" = 1 ] ; then
+	if test "$hookmethod" = dyld ; then
-		echo "Configuring a fat binary for i386 and x86_64"
+		echo "using Monterey style DYLD hooking"
-		echo MAC_CFLAGS+=-arch i386 -arch x86_64>>config.mak
+		echo "CFLAGS+=-DMONTEREY_HOOKING">>config.mak
-		echo LDFLAGS+=-arch i386 -arch x86_64>>config.mak
+	fi
+	if ismac64 && [ "$fat_binary" = 1 ] ; then
+		echo "Configuring a fat binary for i386 and x86_64"
+		echo "MAC_CFLAGS+=-arch i386 -arch x86_64">>config.mak
+		echo "FAT_LDFLAGS=-arch i386 -arch x86_64">>config.mak
+		echo "FAT_BIN_LDFLAGS=-arch i386 -arch x86_64">>config.mak
+	fi
+	if [ "$fat_binary_m1" = 1 ] ; then
+		echo "Configuring a fat binary for arm64[e] and x86_64"
+		echo "MAC_CFLAGS+=-arch arm64 -arch arm64e -arch x86_64">>config.mak
+		echo "FAT_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
+		echo "FAT_BIN_LDFLAGS=-arch arm64 -arch x86_64">>config.mak
+	fi
+	if [ "$fat_binary_m2" = 1 ] ; then
+		echo "Configuring a fat binary for arm64[e] and x86_64"
+		echo "MAC_CFLAGS+=-arch arm64 -arch arm64e -arch x86_64">>config.mak
+		echo "FAT_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
+		echo "FAT_BIN_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
 	fi
-	echo LD_SET_SONAME=-Wl,-install_name,>>config.mak
 elif isbsd ; then
 	echo LIBDL=>>config.mak
 	echo "CFLAGS+=-DIS_BSD">>config.mak
-	isopenbsd && echo "CFLAGS+=-DIS_OPENBSD">>config.mak
 	make_cmd=gmake
+elif issolaris; then
+	echo "CFLAGS+=-DIS_SOLARIS -D__EXTENSIONS__" >> config.mak
+	echo "SOCKET_LIBS=-lsocket -lnsl" >> config.mak
+elif ishaiku ; then
+	echo LIBDL=>>config.mak
+	echo "CFLAGS+=-DIS_HAIKU" >> config.mak
 fi
 
 echo "Done, now run $make_cmd && $make_cmd install"
+if [ "$fat_binary_m2" = 1 ] ; then
+echo "Don't forget to run csrutil disable and sudo nvram boot-args=-arm64e_preview_abi"
+fi

src/allocator_thread.c

@@ -1,3 +1,8 @@
+#undef _GNU_SOURCE
+#define _GNU_SOURCE
+#undef _POSIX_C_SOURCE
+#define _DARWIN_C_SOURCE
+#include <limits.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -9,11 +14,13 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <errno.h>
+#include <sys/mman.h>
 #include "allocator_thread.h"
 #include "debug.h"
 #include "ip_type.h"
 #include "mutex.h"
 #include "hash.h"
+#include "remotedns.h"
 
 /* stuff for our internal translation table */
 
@@ -34,9 +41,8 @@ static void *dumpstring(char* s, size_t len) {
 	return p;
 }
 
-pthread_mutex_t internal_ips_lock;
+static pthread_mutex_t *internal_ips_lock;
-internal_ip_lookup_table *internal_ips = NULL;
+static internal_ip_lookup_table *internal_ips;
-internal_ip_lookup_table internal_ips_buf;
 
 uint32_t index_from_internal_ip(ip_type4 internalip) {
 	PFUNC();
@@ -61,7 +67,7 @@ ip_type4 make_internal_ip(uint32_t index) {
 	ip_type4 ret;
 	index++; // so we can start at .0.0.1
 	if(index > 0xFFFFFF)
-		return ip_type_invalid.addr.v4;
+		return IPT4_INVALID;
 	ret.octet[0] = remote_dns_subnet & 0xFF;
 	ret.octet[1] = (index & 0xFF0000) >> 16;
 	ret.octet[2] = (index & 0xFF00) >> 8;
@@ -99,7 +105,7 @@ static ip_type4 ip_from_internal_list(char* name, size_t len) {
 	}
 
 	res = make_internal_ip(internal_ips->counter);
-	if(res.as_int == ip_type_invalid.addr.v4.as_int)
+	if(res.as_int == IPT4_INVALID.as_int)
 		goto err_plus_unlock;
 
 	string_hash_tuple tmp = { 0 };
@@ -112,7 +118,7 @@ static ip_type4 ip_from_internal_list(char* name, size_t len) {
 	internal_ips->list[internal_ips->counter] = new_mem;
 	internal_ips->list[internal_ips->counter]->hash = hash;
 
-	new_mem = dumpstring((char*) name, len + 1);
+	new_mem = dumpstring((char*) name, len);
 
 	if(!new_mem) {
 		internal_ips->list[internal_ips->counter] = 0;
@@ -128,30 +134,18 @@ static ip_type4 ip_from_internal_list(char* name, size_t len) {
 	err_plus_unlock:
 
 	PDEBUG("return err\n");
-	return ip_type_invalid.addr.v4;
+	return IPT4_INVALID;
 }
 
 /* stuff for communication with the allocator thread */
 
-enum at_msgtype {
-	ATM_GETIP,
-	ATM_GETNAME,
-	ATM_EXIT,
-};
-
 enum at_direction {
 	ATD_SERVER = 0,
 	ATD_CLIENT,
 	ATD_MAX,
 };
 
-struct at_msghdr {
-	enum at_msgtype msgtype;
-	size_t datalen;
-};
-
 static pthread_t allocator_thread;
-static pthread_attr_t allocator_thread_attr;
 int req_pipefd[2];
 int resp_pipefd[2];
 
@@ -176,25 +170,62 @@ static int wait_data(int readfd) {
 	return 1;
 }
 
-static int sendmessage(enum at_direction dir, struct at_msghdr *hdr, void* data) {
+static int trywrite(int fd, void* buf, size_t bytes) {
-	static int* destfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[1], [ATD_CLIENT] = &resp_pipefd[1] };
+	ssize_t ret;
-	int ret = write(*destfd[dir], hdr, sizeof *hdr) == sizeof *hdr;
+	unsigned char *out = buf;
-	if(ret && hdr->datalen) {
+again:
-		assert(hdr->datalen <= MSG_LEN_MAX);
+	ret = write(fd, out, bytes);
-		ret = write(*destfd[dir], data, hdr->datalen) == hdr->datalen;
+	switch(ret) {
+		case -1:
+			if(errno == EINTR) goto again;
+		case  0:
+			return 0;
+		default:
+			if(ret == bytes || !bytes) return 1;
+			out += ret;
+			bytes -= ret;
+			goto again;
 	}
+}
+
+static int sendmessage(enum at_direction dir, struct at_msg *msg) {
+	static int* destfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[1], [ATD_CLIENT] = &resp_pipefd[1] };
+	assert(msg->h.datalen <= MSG_LEN_MAX);
+	int ret = trywrite(*destfd[dir], msg, sizeof (msg->h)+msg->h.datalen);
+	assert(msg->h.datalen <= MSG_LEN_MAX);
 	return ret;
 }
 
-static int getmessage(enum at_direction dir, struct at_msghdr *hdr, void* data) {
+static int tryread(int fd, void* buf, size_t bytes) {
+	ssize_t ret;
+	unsigned char *out = buf;
+again:
+	ret = read(fd, out, bytes);
+	switch(ret) {
+		case -1:
+			if(errno == EINTR) goto again;
+		case  0:
+			return 0;
+		default:
+			if(ret == bytes || !bytes) return 1;
+			out += ret;
+			bytes -= ret;
+			goto again;
+	}
+}
+static int readmsg(int fd, struct at_msg *msg) {
+	int ret = tryread(fd, msg, sizeof(msg->h));
+	if(ret != 1) return ret;
+	return tryread(fd, &msg->m, msg->h.datalen);
+}
+
+static int getmessage(enum at_direction dir, struct at_msg *msg) {
 	static int* readfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[0], [ATD_CLIENT] = &resp_pipefd[0] };
-	int ret;
+	ssize_t ret;
 	if((ret = wait_data(*readfd[dir]))) {
-		ret = read(*readfd[dir], hdr, sizeof *hdr) == sizeof(*hdr);
+		if(!readmsg(*readfd[dir], msg))
-		assert(hdr->datalen <= MSG_LEN_MAX);
+			return 0;
-		if(ret && hdr->datalen) {
+		assert(msg->h.datalen <= MSG_LEN_MAX);
-			ret = read(*readfd[dir], data, hdr->datalen) == hdr->datalen;
-		}
 	}
 	return ret;
 }
@@ -202,26 +233,24 @@ static int getmessage(enum at_direction dir, struct at_msghdr *hdr, void* data)
 static void* threadfunc(void* x) {
 	(void) x;
 	int ret;
-	struct at_msghdr msg;
+	struct at_msg msg;
-	union { 
+	while((ret = getmessage(ATD_SERVER, &msg))) {
-		char host[MSG_LEN_MAX];
+		switch(msg.h.msgtype) {
-		ip_type4 ip;
-	} readbuf;
-	while((ret = getmessage(ATD_SERVER, &msg, &readbuf))) {
-		switch(msg.msgtype) {
 			case ATM_GETIP:
 				/* client wants an ip for a DNS name. iterate our list and check if we have an existing entry.
 					* if not, create a new one. */
-				readbuf.ip = ip_from_internal_list(readbuf.host, msg.datalen - 1);
+				msg.m.ip = ip_from_internal_list(msg.m.host, msg.h.datalen);
-				msg.datalen = sizeof(ip_type4);
+				msg.h.datalen = sizeof(ip_type4);
 				break;
 			case ATM_GETNAME: {
-				char *host = string_from_internal_ip(readbuf.ip);
+				char *host = string_from_internal_ip(msg.m.ip);
 				if(host) {
 					size_t l = strlen(host);
-					assert(l < MSG_LEN_MAX);
+					assert(l+1 < MSG_LEN_MAX);
-					memcpy(readbuf.host, host, l + 1);
+					memcpy(msg.m.host, host, l + 1);
-					msg.datalen = l + 1;
+					msg.h.datalen = l + 1;
+				} else {
+					msg.h.datalen = 0;
 				}
 				break;
 			}
@@ -230,7 +259,7 @@ static void* threadfunc(void* x) {
 			default:
 				abort();
 		}
-		ret = sendmessage(ATD_CLIENT, &msg, &readbuf);
+		ret = sendmessage(ATD_CLIENT, &msg);
 	}
 	return 0;
 }
@@ -239,51 +268,83 @@ static void* threadfunc(void* x) {
 
 ip_type4 at_get_ip_for_host(char* host, size_t len) {
 	ip_type4 readbuf;
-	MUTEX_LOCK(&internal_ips_lock);
+	MUTEX_LOCK(internal_ips_lock);
 	if(len > MSG_LEN_MAX) goto inv;
-	struct at_msghdr msg = {.msgtype = ATM_GETIP, .datalen = len + 1 };
+	struct at_msg msg = {.h.msgtype = ATM_GETIP, .h.datalen = len + 1 };
-	if(sendmessage(ATD_SERVER, &msg, host) &&
+	memcpy(msg.m.host, host, len+1);
-	   getmessage(ATD_CLIENT, &msg, &readbuf));
+	if(sendmessage(ATD_SERVER, &msg) &&
+	   getmessage(ATD_CLIENT, &msg)) readbuf = msg.m.ip;
 	else {
 		inv:
-		readbuf = ip_type_invalid.addr.v4;
+		readbuf = IPT4_INVALID;
 	}
-	MUTEX_UNLOCK(&internal_ips_lock);
+	assert(msg.h.msgtype == ATM_GETIP);
+	MUTEX_UNLOCK(internal_ips_lock);
 	return readbuf;
 }
 
 size_t at_get_host_for_ip(ip_type4 ip, char* readbuf) {
-	struct at_msghdr msg = {.msgtype = ATM_GETNAME, .datalen = sizeof(ip_type4) };
+	struct at_msg msg = {.h.msgtype = ATM_GETNAME, .h.datalen = sizeof(ip_type4), .m.ip = ip };
 	size_t res = 0;
-	MUTEX_LOCK(&internal_ips_lock);
+	MUTEX_LOCK(internal_ips_lock);
-	if(sendmessage(ATD_SERVER, &msg, &ip) && getmessage(ATD_CLIENT, &msg, readbuf)) {
+	if(sendmessage(ATD_SERVER, &msg) && getmessage(ATD_CLIENT, &msg)) {
-		if((ptrdiff_t) msg.datalen <= 0) res = 0;
+		if((int16_t) msg.h.datalen <= 0) res = 0;
-		else res = msg.datalen - 1;
+		else {
+			memcpy(readbuf, msg.m.host, msg.h.datalen);
+			res = msg.h.datalen - 1;
+		}
 	}
-	MUTEX_UNLOCK(&internal_ips_lock);
+	assert(msg.h.msgtype == ATM_GETNAME);
+	MUTEX_UNLOCK(internal_ips_lock);
 	return res;
 }
 
 
 static void initpipe(int* fds) {
-	if(pipe(fds) == -1) {
+	int retval;
+
+#ifdef HAVE_PIPE2
+	retval = pipe2(fds, O_CLOEXEC);
+#else
+	retval = pipe(fds);
+	if(retval == 0) {
+		fcntl(fds[0], F_SETFD, FD_CLOEXEC);
+		fcntl(fds[1], F_SETFD, FD_CLOEXEC);
+	}
+#endif
+	if(retval == -1) {
 		perror("pipe");
 		exit(1);
 	}
 }
 
+#ifndef MAX
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+#endif
+
+#if !defined(PTHREAD_STACK_MIN) || defined(__APPLE__)
+/* MAC says its min is 8KB, but then crashes in our face. thx hunkOLard */
+#define PTHREAD_STACK_MIN 64*1024
+#endif
+
 /* initialize with pointers to shared memory. these will
  * be used to place responses and arguments */
 void at_init(void) {
 	PFUNC();
-	MUTEX_INIT(&internal_ips_lock);
+	void *shm = mmap(0, 4096, PROT_WRITE|PROT_READ, MAP_ANON|MAP_SHARED, -1, 0);
-	internal_ips = &internal_ips_buf;
+	assert(shm);
+	internal_ips_lock = shm;
+	internal_ips = (void*)((char*)shm + 2048);
+
+	MUTEX_INIT(internal_ips_lock);
 	memset(internal_ips, 0, sizeof *internal_ips);
 	initpipe(req_pipefd);
 	initpipe(resp_pipefd);
+	pthread_attr_t allocator_thread_attr;
 	pthread_attr_init(&allocator_thread_attr);
-	pthread_attr_setstacksize(&allocator_thread_attr, 16 * 1024);
+	pthread_attr_setstacksize(&allocator_thread_attr, MAX(16 * 1024, PTHREAD_STACK_MIN));
 	pthread_create(&allocator_thread, &allocator_thread_attr, threadfunc, 0);
+	pthread_attr_destroy(&allocator_thread_attr);
 }
 
 void at_close(void) {
@@ -295,6 +356,5 @@ void at_close(void) {
 	close(req_pipefd[1]);
 	close(resp_pipefd[0]);
 	close(resp_pipefd[1]);
-	pthread_attr_destroy(&allocator_thread_attr);
+	MUTEX_DESTROY(internal_ips_lock);
-	MUTEX_DESTROY(&internal_ips_lock);
 }

src/allocator_thread.h

@@ -4,8 +4,6 @@
 #include <unistd.h>
 #include "ip_type.h"
 
-#define MSG_LEN_MAX 256
-
 extern int req_pipefd[2];
 extern int resp_pipefd[2];
 

src/common.c

@@ -23,6 +23,33 @@ const char *proxy_state_strmap[] = {
     "busy",
 };
 
+/* isnumericipv4() taken from libulz */
+int pc_isnumericipv4(const char* ipstring) {
+	size_t x = 0, n = 0, d = 0;
+	int wasdot = 0;
+	while(1) {
+		switch(ipstring[x]) {
+			case 0: goto done;
+			case '.':
+				if(!n || wasdot) return 0;
+				d++;
+				wasdot = 1;
+				break;
+			case '0': case '1': case '2': case '3': case '4':
+			case '5': case '6': case '7': case '8': case '9':
+				n++;
+				wasdot = 0;
+				break;
+			default:
+				return 0;
+		}
+		x++;
+	}
+	done:
+	if(d == 3 && n >= 4 && n <= 12) return 1;
+	return 0;
+}
+
 // stolen from libulz (C) rofl0r
 void pc_stringfromipv4(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes) {
 	unsigned char *p;
@@ -79,6 +106,13 @@ char *get_config_path(char* default_path, char* pbuf, size_t bufsize) {
 	if(check_path(path))
 		goto have;
     
+    // priority 3b: ~/config/settings/proxychains.conf (for haiku)
+	path = getenv("HOME");
+	snprintf(pbuf, bufsize, "%s/config/settings/%s", path, PROXYCHAINS_CONF_FILE);
+	path = pbuf;
+	if(check_path(path))
+		goto have;
+
 	// priority 4: $SYSCONFDIR/proxychains.conf
 	path = SYSCONFDIR "/" PROXYCHAINS_CONF_FILE;
 	if(check_path(path))

src/common.h

@@ -17,6 +17,7 @@ extern const char *proxy_state_strmap[];
 
 char *get_config_path(char* default_path, char* pbuf, size_t bufsize);
 void pc_stringfromipv4(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes);
+int pc_isnumericipv4(const char* ipstring);
 
 //RcB: DEP "common.c"
 #endif

src/core.c

@@ -37,7 +37,8 @@
 
 #include "core.h"
 #include "common.h"
-#include "allocator_thread.h"
+#include "rdns.h"
+#include "mutex.h"
 
 extern int tcp_read_time_out;
 extern int tcp_connect_time_out;
@@ -106,7 +107,7 @@ static void encode_base_64(char *src, char *dest, int max_len) {
 }
 
 void proxychains_write_log(char *str, ...) {
-	char buff[1024*20];
+	char buff[1024*4];
 	va_list arglist;
 	if(!proxychains_quiet_mode) {
 		va_start(arglist, str);
@@ -187,6 +188,7 @@ static int timed_connect(int sock, const struct sockaddr *addr, socklen_t len) {
 
 
 #define INVALID_INDEX 0xFFFFFFFFU
+#define BUFF_SIZE 1024  // used to read responses from proxies.
 static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, char *user, char *pass) {
 	char *dns_name = NULL;
 	char hostnamebuf[MSG_LEN_MAX];
@@ -198,8 +200,8 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
 	// the range 224-255.* is reserved, and it won't go outside (unless the app does some other stuff with
 	// the results returned from gethostbyname et al.)
 	// the hardcoded number 224 can now be changed using the config option remote_dns_subnet to i.e. 127
-	if(!ip.is_v6 && ip.addr.v4.octet[0] == remote_dns_subnet) {
+	if(!ip.is_v6 && proxychains_resolver >= DNSLF_RDNS_START && ip.addr.v4.octet[0] == remote_dns_subnet) {
-		dns_len = at_get_host_for_ip(ip.addr.v4, hostnamebuf);
+		dns_len = rdns_get_host_for_ip(ip.addr.v4, hostnamebuf);
 		if(!dns_len) goto err;
 		else dns_name = hostnamebuf;
 	}
@@ -220,6 +222,10 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
 	int v6 = ip.is_v6;
 	
 	switch (pt) {
+		case RAW_TYPE: {
+			return SUCCESS;
+		}
+		break;
 		case HTTP_TYPE:{
 			if(!dns_len) {
 				if(!inet_ntop(v6?AF_INET6:AF_INET,ip.addr.v6,ip_buf,sizeof ip_buf)) {
@@ -350,12 +356,15 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
 
 				if(2 != read_n_bytes(sock, in, 2))
 					goto err;
-				if(in[0] != 1 || in[1] != 0) {
+	/* according to RFC 1929 the version field for the user/pass auth sub-
-					if(in[0] != 1)
+	   negotiation should be 1, which is kinda counter-intuitive, so there
-						goto err;
+	   are some socks5 proxies that return 5 instead. other programs like
-					else
+	   curl work fine when the version is 5, so let's do the same and accept
-						return BLOCKED;
+	   either of them. */
-				}
+				if(!(in[0] == 5 || in[0] == 1))
+					goto err;
+				if(in[1] != 0)
+					return BLOCKED;
 			}
 			int buff_iter = 0;
 			buff[buff_iter++] = 5;	// version
@@ -453,8 +462,10 @@ static int start_chain(int *fd, proxy_data * pd, char *begin_mark) {
 	error1:
 	proxychains_write_log(TP " timeout\n");
 	error:
-	if(*fd != -1)
+	if(*fd != -1) {
 		close(*fd);
+		*fd = -1;
+	}
 	return SOCKET_ERROR;
 }
 
@@ -511,47 +522,50 @@ static unsigned int calc_alive(proxy_data * pd, unsigned int proxy_count) {
 }
 
 
-static int chain_step(int ns, proxy_data * pfrom, proxy_data * pto) {
+static int chain_step(int *ns, proxy_data * pfrom, proxy_data * pto) {
 	int retcode = -1;
-	char *hostname;
+	char *hostname, *errmsg = 0;
 	char hostname_buf[MSG_LEN_MAX];
 	char ip_buf[INET6_ADDRSTRLEN];
 	int v6 = pto->ip.is_v6;
 
 	PFUNC();
 
-	if(!v6 && pto->ip.addr.v4.octet[0] == remote_dns_subnet) {
+	if(!v6 && proxychains_resolver >= DNSLF_RDNS_START && pto->ip.addr.v4.octet[0] == remote_dns_subnet) {
-		if(!at_get_host_for_ip(pto->ip.addr.v4, hostname_buf)) goto usenumericip;
+		if(!rdns_get_host_for_ip(pto->ip.addr.v4, hostname_buf)) goto usenumericip;
 		else hostname = hostname_buf;
 	} else {
 	usenumericip:
 		if(!inet_ntop(v6?AF_INET6:AF_INET,pto->ip.addr.v6,ip_buf,sizeof ip_buf)) {
 			pto->ps = DOWN_STATE;
-			proxychains_write_log("<--ip conversion error!\n");
+			errmsg = "<--ip conversion error!\n";
-			close(ns);
+			retcode = SOCKET_ERROR;
-			return SOCKET_ERROR;
+			goto err;
 		}
 		hostname = ip_buf;
 	}
 
 	proxychains_write_log(TP " %s:%d ", hostname, htons(pto->port));
-	retcode = tunnel_to(ns, pto->ip, pto->port, pfrom->pt, pfrom->user, pfrom->pass);
+	retcode = tunnel_to(*ns, pto->ip, pto->port, pfrom->pt, pfrom->user, pfrom->pass);
 	switch (retcode) {
 		case SUCCESS:
 			pto->ps = BUSY_STATE;
 			break;
 		case BLOCKED:
 			pto->ps = BLOCKED_STATE;
-			proxychains_write_log("<--denied\n");
+			errmsg = "<--denied\n";
-			close(ns);
+			goto err;
-			break;
 		case SOCKET_ERROR:
 			pto->ps = DOWN_STATE;
-			proxychains_write_log("<--socket error or timeout!\n");
+			errmsg = "<--socket error or timeout!\n";
-			close(ns);
+			goto err;
-			break;
 	}
 	return retcode;
+err:
+	if(errmsg) proxychains_write_log(errmsg);
+	if(*ns != -1) close(*ns);
+	*ns = -1;
+	return retcode;
 }
 
 int connect_proxy_chain(int sock, ip_type target_ip,
@@ -564,8 +578,8 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 	unsigned int offset = 0;
 	unsigned int alive_count = 0;
 	unsigned int curr_len = 0;
-	unsigned int curr_pos = 0;
 	unsigned int looped = 0; // went back to start of list in RR mode
+	unsigned int rr_loop_max = 14;
 
 	p3 = &p4;
 
@@ -587,7 +601,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 				p2 = select_proxy(FIFOLY, pd, proxy_count, &offset);
 				if(!p2)
 					break;
-				if(SUCCESS != chain_step(ns, p1, p2)) {
+				if(SUCCESS != chain_step(&ns, p1, p2)) {
 					PDEBUG("GOTO AGAIN 1\n");
 					goto again;
 				}
@@ -596,29 +610,33 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			//proxychains_write_log(TP);
 			p3->ip = target_ip;
 			p3->port = target_port;
-			if(SUCCESS != chain_step(ns, p1, p3))
+			if(SUCCESS != chain_step(&ns, p1, p3))
 				goto error;
 			break;
 
 		case ROUND_ROBIN_TYPE:
 			alive_count = calc_alive(pd, proxy_count);
-			curr_pos = offset = proxychains_proxy_offset;
+			offset = proxychains_proxy_offset;
 			if(alive_count < max_chain)
 				goto error_more;
-                        PDEBUG("1:rr_offset = %d, curr_pos = %d\n", offset, curr_pos);
+			PDEBUG("1:rr_offset = %d\n", offset);
 			/* Check from current RR offset til end */
 			for (;rc != SUCCESS;) {
 				if (!(p1 = select_proxy(FIFOLY, pd, proxy_count, &offset))) {
 					/* We've reached the end of the list, go to the start */
  					offset = 0;
 					looped++;
-					continue;
+					if (looped > rr_loop_max) {
-				} else if (looped && rc > 0 && offset >= curr_pos) {
+						proxychains_proxy_offset = 0;
- 					PDEBUG("GOTO MORE PROXIES 0\n");
+						goto error_more;
-					/* We've gone back to the start and now past our starting position */
+					} else {
-					proxychains_proxy_offset = 0;
+						PDEBUG("rr_type all proxies down, release all\n");
- 					goto error_more;
+						release_all(pd, proxy_count);
- 				}
+						/* Each loop we wait 10ms more */
+						usleep(10000 * looped);
+						continue;
+					}
+				}
  				PDEBUG("2:rr_offset = %d\n", offset);
  				rc=start_chain(&ns, p1, RRT);
 			}
@@ -630,7 +648,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 					/* Try from the beginning to where we started */
 					offset = 0;
 					continue;
-				} else if(SUCCESS != chain_step(ns, p1, p2)) {
+				} else if(SUCCESS != chain_step(&ns, p1, p2)) {
 					PDEBUG("GOTO AGAIN 1\n");
 					goto again;
 				} else
@@ -642,7 +660,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			p3->port = target_port;
 			proxychains_proxy_offset = offset+1;
 			PDEBUG("pd_offset = %d, curr_len = %d\n", proxychains_proxy_offset, curr_len);
-			if(SUCCESS != chain_step(ns, p1, p3))
+			if(SUCCESS != chain_step(&ns, p1, p3))
 				goto error;
 			break;
 
@@ -660,7 +678,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			while(offset < proxy_count) {
 				if(!(p2 = select_proxy(FIFOLY, pd, proxy_count, &offset)))
 					break;
-				if(SUCCESS != chain_step(ns, p1, p2)) {
+				if(SUCCESS != chain_step(&ns, p1, p2)) {
 					PDEBUG("chain_step failed\n");
 					goto error_strict;
 				}
@@ -669,7 +687,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			//proxychains_write_log(TP);
 			p3->ip = target_ip;
 			p3->port = target_port;
-			if(SUCCESS != chain_step(ns, p1, p3))
+			if(SUCCESS != chain_step(&ns, p1, p3))
 				goto error;
 			break;
 
@@ -685,7 +703,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			while(++curr_len < max_chain) {
 				if(!(p2 = select_proxy(RANDOMLY, pd, proxy_count, &offset)))
 					goto error_more;
-				if(SUCCESS != chain_step(ns, p1, p2)) {
+				if(SUCCESS != chain_step(&ns, p1, p2)) {
 					PDEBUG("GOTO AGAIN 2\n");
 					goto again;
 				}
@@ -694,7 +712,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 			//proxychains_write_log(TP);
 			p3->ip = target_ip;
 			p3->port = target_port;
-			if(SUCCESS != chain_step(ns, p1, p3))
+			if(SUCCESS != chain_step(&ns, p1, p3))
 				goto error;
 
 	}
@@ -721,10 +739,13 @@ int connect_proxy_chain(int sock, ip_type target_ip,
 	return -1;
 }
 
+static pthread_mutex_t servbyname_lock;
 void core_initialize(void) {
+	MUTEX_INIT(&servbyname_lock);
 }
 
 void core_unload(void) {
+	MUTEX_DESTROY(&servbyname_lock);
 }
 
 static void gethostbyname_data_setstring(struct gethostbyname_data* data, char* name) {
@@ -733,6 +754,102 @@ static void gethostbyname_data_setstring(struct gethostbyname_data* data, char*
 }
 
 extern ip_type4 hostsreader_get_numeric_ip_for_name(const char* name);
+struct hostent* proxy_gethostbyname_old(const char *name)
+{
+	static struct hostent hostent_space;
+	static in_addr_t resolved_addr;
+	static char* resolved_addr_p;
+	static char addr_name[256];
+
+	int pipe_fd[2];
+	char buff[256];
+	in_addr_t addr;
+	pid_t pid;
+	int status, ret;
+	size_t l;
+	struct hostent* hp;
+
+	hostent_space.h_addr_list = &resolved_addr_p;
+	*hostent_space.h_addr_list = (char*)&resolved_addr;
+	resolved_addr = 0;
+
+	if(pc_isnumericipv4(name)) {
+		strcpy(buff, name);
+		goto got_buff;
+	}
+
+	gethostname(buff,sizeof(buff));
+	if(!strcmp(buff,name))
+		goto got_buff;
+
+	memset(buff, 0, sizeof(buff));
+
+	// TODO: this works only once, so cache it  ...
+	// 	 later
+	while ((hp=gethostent()))
+		if (!strcmp(hp->h_name,name))
+			return hp;
+#ifdef HAVE_PIPE2
+	ret = pipe2(pipe_fd, O_CLOEXEC);
+#else
+	ret = pipe(pipe_fd);
+	if(ret == 0) {
+		fcntl(pipe_fd[0], F_SETFD, FD_CLOEXEC);
+		fcntl(pipe_fd[1], F_SETFD, FD_CLOEXEC);
+	}
+#endif
+
+	if(ret)
+		goto err;
+	pid = fork();
+	switch(pid) {
+
+		case 0: // child
+			proxychains_write_log("|DNS-request| %s \n", name);
+			close(pipe_fd[0]);
+			dup2(pipe_fd[1],1);
+			close(pipe_fd[1]);
+
+		//	putenv("LD_PRELOAD=");
+			execlp("proxyresolv","proxyresolv",name,NULL);
+			perror("can't exec proxyresolv");
+			exit(2);
+
+		case -1: //error
+			close(pipe_fd[0]);
+			close(pipe_fd[1]);
+			perror("can't fork");
+			goto err;
+
+		default:
+			close(pipe_fd[1]);
+			waitpid(pid, &status, 0);
+			buff[0] = 0;
+			read(pipe_fd[0],&buff,sizeof(buff));
+			close(pipe_fd[0]);
+got_buff:
+			l = strlen(buff);
+			if (!l) goto err_dns;
+			if (buff[l-1] == '\n') buff[l-1] = 0;
+			addr = inet_addr(buff);
+			if (addr == (in_addr_t) (-1))
+				goto err_dns;
+			memcpy(*(hostent_space.h_addr_list),
+						&addr ,sizeof(struct in_addr));
+			hostent_space.h_name = addr_name;
+			snprintf(addr_name, sizeof addr_name, "%s", buff);
+			hostent_space.h_length = sizeof (in_addr_t);
+			hostent_space.h_addrtype = AF_INET;
+	}
+	proxychains_write_log("|DNS-response| %s is %s\n",
+			name, inet_ntoa(*(struct in_addr*)&addr));
+	return &hostent_space;
+err_dns:
+	proxychains_write_log("|DNS-response|: %s lookup error\n", name);
+err:
+	return NULL;
+}
+
 struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data* data) {
 	PFUNC();
 	char buff[256];
@@ -748,24 +865,29 @@ struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data*
 	data->hostent_space.h_addrtype = AF_INET;
 	data->hostent_space.h_length = sizeof(in_addr_t);
 
+	if(pc_isnumericipv4(name)) {
+		data->resolved_addr = inet_addr(name);
+		goto retname;
+	}
+
 	gethostname(buff, sizeof(buff));
 
 	if(!strcmp(buff, name)) {
 		data->resolved_addr = inet_addr(buff);
 		if(data->resolved_addr == (in_addr_t) (-1))
-			data->resolved_addr = (in_addr_t) (ip_type_localhost.addr.v4.as_int);
+			data->resolved_addr = (in_addr_t) (IPT4_LOCALHOST.as_int);
 		goto retname;
 	}
 
 	// this iterates over the "known hosts" db, usually /etc/hosts
 	ip_type4 hdb_res = hostsreader_get_numeric_ip_for_name(name);
-	if(hdb_res.as_int != ip_type_invalid.addr.v4.as_int) {
+	if(hdb_res.as_int != IPT4_INVALID.as_int) {
 		data->resolved_addr = hdb_res.as_int;
 		goto retname;
 	}
 	
-	data->resolved_addr = at_get_ip_for_host((char*) name, strlen(name)).as_int;
+	data->resolved_addr = rdns_get_ip_for_host((char*) name, strlen(name)).as_int;
-	if(data->resolved_addr == (in_addr_t) ip_type_invalid.addr.v4.as_int) return NULL;
+	if(data->resolved_addr == (in_addr_t) IPT4_INVALID.as_int) return NULL;
 
 	retname:
 
@@ -778,7 +900,7 @@ struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data*
 
 struct addrinfo_data {
 	struct addrinfo addrinfo_space;
-	struct sockaddr sockaddr_space;
+	struct sockaddr_storage sockaddr_space;
 	char addr_name[256];
 };
 
@@ -787,18 +909,17 @@ void proxy_freeaddrinfo(struct addrinfo *res) {
 	free(res);
 }
 
-#if defined(IS_MAC) || defined(IS_OPENBSD)
+static int mygetservbyname_r(const char* name, const char* proto, struct servent* result_buf,
-#ifdef IS_OPENBSD /* OpenBSD has its own incompatible getservbyname_r */
-#define getservbyname_r mygetservbyname_r
-#endif
-/* getservbyname on mac is using thread local storage, so we dont need mutex 
-   TODO: check if the same applies to OpenBSD */
-static int getservbyname_r(const char* name, const char* proto, struct servent* result_buf, 
 			   char* buf, size_t buflen, struct servent** result) {
 	PFUNC();
+#ifdef HAVE_GNU_GETSERVBYNAME_R
+	PDEBUG("using host getservbyname_r\n");
+	return getservbyname_r(name, proto, result_buf, buf, buflen, result);
+#endif
 	struct servent *res;
 	int ret;
 	(void) buf; (void) buflen;
+	MUTEX_LOCK(&servbyname_lock);
 	res = getservbyname(name, proto);
 	if(res) {
 		*result_buf = *res;
@@ -808,9 +929,36 @@ static int getservbyname_r(const char* name, const char* proto, struct servent*
 		*result = NULL;
 		ret = ENOENT;
 	}
+	MUTEX_UNLOCK(&servbyname_lock);
+	return ret;
+}
+
+static int looks_like_numeric_ipv6(const char *node)
+{
+	if(!strchr(node, ':')) return 0;
+	const char* p= node;
+	while(1) switch(*(p++)) {
+		case 0: return 1;
+		case ':': case '.':
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+			break;
+		default: return 0;
+	}
+}
+
+static int my_inet_aton(const char *node, struct addrinfo_data* space)
+{
+	int ret;
+	((struct sockaddr_in *) &space->sockaddr_space)->sin_family = AF_INET;
+	ret = inet_aton(node, &((struct sockaddr_in *) &space->sockaddr_space)->sin_addr);
+	if(ret || !looks_like_numeric_ipv6(node)) return ret;
+	ret = inet_pton(AF_INET6, node, &((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_addr);
+	if(ret) ((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_family = AF_INET6;
 	return ret;
 }
-#endif
 
 int proxy_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
 	struct gethostbyname_data ghdata;
@@ -820,56 +968,69 @@ int proxy_getaddrinfo(const char *node, const char *service, const struct addrin
 	struct servent se_buf;
 	struct addrinfo *p;
 	char buf[1024];
-	int port;
+	int port, af = AF_INET;
-	PFUNC();
+
+	PDEBUG("proxy_getaddrinfo node:%s service: %s, flags: %d\n",
+		node?node:"",service?service:"",hints?(int)hints->ai_flags:0);
 
-//      printf("proxy_getaddrinfo node %s service %s\n",node,service);
 	space = calloc(1, sizeof(struct addrinfo_data));
-	if(!space) goto err1;
+	if(!space) return EAI_MEMORY;
 
-	if(node && !inet_aton(node, &((struct sockaddr_in *) &space->sockaddr_space)->sin_addr)) {
+	if(node && !my_inet_aton(node, space)) {
 		/* some folks (nmap) use getaddrinfo() with AI_NUMERICHOST to check whether a string
 		   containing a numeric ip was passed. we must return failure in that case. */
-		if(hints && (hints->ai_flags & AI_NUMERICHOST)) return EAI_NONAME;
+		if(hints && (hints->ai_flags & AI_NUMERICHOST)) {
-		hp = proxy_gethostbyname(node, &ghdata);
+err_nn:
+			free(space);
+			return EAI_NONAME;
+		}
+		if(proxychains_resolver == DNSLF_FORKEXEC)
+			hp = proxy_gethostbyname_old(node);
+		else
+			hp = proxy_gethostbyname(node, &ghdata);
+
 		if(hp)
 			memcpy(&((struct sockaddr_in *) &space->sockaddr_space)->sin_addr,
 			       *(hp->h_addr_list), sizeof(in_addr_t));
 		else
-			goto err2;
+			goto err_nn;
+	} else if(node) {
+		af = ((struct sockaddr_in *) &space->sockaddr_space)->sin_family;
+	} else if(!node && !(hints->ai_flags & AI_PASSIVE)) {
+		af = ((struct sockaddr_in *) &space->sockaddr_space)->sin_family = AF_INET;
+		memcpy(&((struct sockaddr_in *) &space->sockaddr_space)->sin_addr,
+		       "\177\0\0\1", 4);
 	}
-	if(service) getservbyname_r(service, NULL, &se_buf, buf, sizeof(buf), &se);
+	if(service) mygetservbyname_r(service, NULL, &se_buf, buf, sizeof(buf), &se);
 
 	port = se ? se->s_port : htons(atoi(service ? service : "0"));
-	((struct sockaddr_in *) &space->sockaddr_space)->sin_port = port;
+	if(af == AF_INET)
+		((struct sockaddr_in *) &space->sockaddr_space)->sin_port = port;
+	else
+		((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_port = port;
 
 	*res = p = &space->addrinfo_space;
 	assert((size_t)p == (size_t) space);
 
-	p->ai_addr = &space->sockaddr_space;
+	p->ai_addr = (void*) &space->sockaddr_space;
 	if(node)
 		snprintf(space->addr_name, sizeof(space->addr_name), "%s", node);
 	p->ai_canonname = space->addr_name;
 	p->ai_next = NULL;
-	p->ai_family = space->sockaddr_space.sa_family = AF_INET;
+	p->ai_family = space->sockaddr_space.ss_family = af;
-	p->ai_addrlen = sizeof(space->sockaddr_space);
+	p->ai_addrlen = af == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
 
 	if(hints) {
 		p->ai_socktype = hints->ai_socktype;
 		p->ai_flags = hints->ai_flags;
 		p->ai_protocol = hints->ai_protocol;
+		if(!p->ai_socktype && p->ai_protocol == IPPROTO_TCP)
+			p->ai_socktype = SOCK_STREAM;
 	} else {
 #ifndef AI_V4MAPPED
 #define AI_V4MAPPED 0
 #endif
 		p->ai_flags = (AI_V4MAPPED | AI_ADDRCONFIG);
 	}
-
-	goto out;
-	err2:
-	free(space);
-	err1:
-	return 1;
-	out:
 	return 0;
 }

src/core.h

@@ -23,8 +23,8 @@
 
 #ifndef __CORE_HEADER
 #define __CORE_HEADER
-#define BUFF_SIZE 8*1024  // used to read responses from proxies.
 #define     MAX_LOCALNET 64
+#define     MAX_DNAT 64
 
 #include "ip_type.h"
 
@@ -41,7 +41,8 @@ typedef enum {
 typedef enum {
 	HTTP_TYPE,
 	SOCKS4_TYPE,
-	SOCKS5_TYPE
+	SOCKS5_TYPE,
+	RAW_TYPE
 } proxy_type;
 
 typedef enum {
@@ -64,10 +65,25 @@ typedef enum {
 } select_type;
 
 typedef struct {
-	struct in_addr in_addr, netmask;
+	sa_family_t family;
 	unsigned short port;
+	union {
+		struct {
+			struct in_addr in_addr;
+			struct in_addr in_mask;
+		};
+		struct {
+			struct in6_addr in6_addr;
+			unsigned char in6_prefix;
+		};
+	};
 } localaddr_arg;
 
+typedef struct {
+	struct in_addr orig_dst, new_dst;
+	unsigned short orig_port, new_port;
+} dnat_arg;
+
 typedef struct {
 	ip_type ip;
 	unsigned short port;
@@ -84,16 +100,17 @@ int connect_proxy_chain (int sock, ip_type target_ip, unsigned short target_port
 void proxychains_write_log(char *str, ...);
 
 typedef int (*close_t)(int);
+typedef int (*close_range_t)(unsigned, unsigned, int);
 typedef int (*connect_t)(int, const struct sockaddr *, socklen_t);
 typedef struct hostent* (*gethostbyname_t)(const char *);
-typedef int (*freeaddrinfo_t)(struct addrinfo *);
+typedef void (*freeaddrinfo_t)(struct addrinfo *);
 typedef struct hostent *(*gethostbyaddr_t) (const void *, socklen_t, int);
 
 typedef int (*getaddrinfo_t)(const char *, const char *, const struct addrinfo *, 
 			     struct addrinfo **);
 
 typedef int (*getnameinfo_t) (const struct sockaddr *, socklen_t, char *, 
-			      socklen_t, char *, socklen_t, int);
+			      GN_NODELEN_T, char *, GN_SERVLEN_T, GN_FLAGS_T);
 
 typedef ssize_t (*sendto_t) (int sockfd, const void *buf, size_t len, int flags,
 			     const struct sockaddr *dest_addr, socklen_t addrlen);
@@ -111,10 +128,11 @@ struct gethostbyname_data {
 	struct hostent hostent_space;
 	in_addr_t resolved_addr;
 	char *resolved_addr_p[2];
-	char addr_name[1024 * 8];
+	char addr_name[256];
 };
 
 struct hostent* proxy_gethostbyname(const char *name, struct gethostbyname_data *data);
+struct hostent* proxy_gethostbyname_old(const char *name);
 
 int proxy_getaddrinfo(const char *node, const char *service, 
 		      const struct addrinfo *hints, struct addrinfo **res);

src/daemon/daemon.c

@@ -0,0 +1,231 @@
+/*
+   proxychains-ng DNS daemon
+
+   Copyright (C) 2020 rofl0r.
+
+*/
+
+#define _GNU_SOURCE
+#include <unistd.h>
+#define _POSIX_C_SOURCE 200809L
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/select.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <limits.h>
+#include "udpserver.h"
+#include "sblist.h"
+#include "hsearch.h"
+#include "../remotedns.h"
+#include "../ip_type.h"
+
+#ifndef MAX
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+#endif
+
+static struct htab *ip_lookup_table;
+static sblist *hostnames;
+static unsigned remote_subnet;
+static const struct server* server;
+
+#ifndef CONFIG_LOG
+#define CONFIG_LOG 1
+#endif
+#if CONFIG_LOG
+/* we log to stderr because it's not using line buffering, i.e. malloc which would need
+   locking when called from different threads. for the same reason we use dprintf,
+   which writes directly to an fd. */
+#define dolog(...) dprintf(2, __VA_ARGS__)
+#else
+static void dolog(const char* fmt, ...) { }
+#endif
+
+static char* my_inet_ntoa(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes) {
+	unsigned char *p;
+	char *o = outbuf_16_bytes;
+	unsigned char n;
+	for(p = ip_buf_4_bytes; p < ip_buf_4_bytes + 4; p++) {
+		n = *p;
+		if(*p >= 100) {
+			if(*p >= 200)
+				*(o++) = '2';
+			else
+				*(o++) = '1';
+			n %= 100;
+		}
+		if(*p >= 10) {
+			*(o++) = (n / 10) + '0';
+			n %= 10;
+		}
+		*(o++) = n + '0';
+		*(o++) = '.';
+	}
+	o[-1] = 0;
+	return outbuf_16_bytes;
+}
+
+
+/* buf needs to be long enough for an ipv6 addr, i.e. INET6_ADDRSTRLEN + 1 */
+static char* ipstr(union sockaddr_union *su, char* buf) {
+	int af = SOCKADDR_UNION_AF(su);
+	void *ipdata = SOCKADDR_UNION_ADDRESS(su);
+	inet_ntop(af, ipdata, buf, INET6_ADDRSTRLEN+1);
+	char portbuf[7];
+	snprintf(portbuf, sizeof portbuf, ":%u", (unsigned) ntohs(SOCKADDR_UNION_PORT(su)));
+	strcat(buf, portbuf);
+	return buf;
+}
+
+static int usage(char *a0) {
+	dprintf(2,
+		"Proxychains-NG remote dns daemon\n"
+		"--------------------------------\n"
+		"usage: %s -i listenip -p port -r remotesubnet\n"
+		"all arguments are optional.\n"
+		"by default listenip is 127.0.0.1, port 1053 and remotesubnet 224.\n\n", a0
+	);
+	return 1;
+}
+
+unsigned index_from_ip(ip_type4 internalip) {
+	ip_type4 tmp = internalip;
+	uint32_t ret;
+	ret = tmp.octet[3] + (tmp.octet[2] << 8) + (tmp.octet[1] << 16);
+	ret -= 1;
+	return ret;
+}
+
+char *host_from_ip(ip_type4 internalip) {
+	char *res = NULL;
+	unsigned index = index_from_ip(internalip);
+	if(index < sblist_getsize(hostnames)) {
+		char **tmp = sblist_get(hostnames, index);
+		if(tmp && *tmp) res = *tmp;
+	}
+	return res;
+}
+
+ip_type4 get_ip_from_index(unsigned index) {
+	ip_type4 ret;
+	index++; // so we can start at .0.0.1
+	if(index > 0xFFFFFF)
+		return IPT4_INVALID;
+	ret.octet[0] = remote_subnet & 0xFF;
+	ret.octet[1] = (index & 0xFF0000) >> 16;
+	ret.octet[2] = (index & 0xFF00) >> 8;
+	ret.octet[3] = index & 0xFF;
+	return ret;
+}
+
+ip_type4 get_ip(char* hn) {
+	htab_value *v = htab_find(ip_lookup_table, hn);
+	if(v) return get_ip_from_index(v->n);
+	char *n = strdup(hn);
+	if(!n) return IPT4_INVALID;
+	if(!sblist_add(hostnames, &n)) {
+	o_out:;
+		free(n);
+		return IPT4_INVALID;
+	}
+	if(!htab_insert(ip_lookup_table, n, HTV_N(sblist_getsize(hostnames)-1))) {
+		sblist_delete(hostnames, sblist_getsize(hostnames)-1);
+		goto o_out;
+	}
+	return get_ip_from_index(sblist_getsize(hostnames)-1);
+}
+
+int main(int argc, char** argv) {
+	int ch;
+	const char *listenip = "127.0.0.1";
+	unsigned port = 1053;
+	remote_subnet = 224;
+	while((ch = getopt(argc, argv, ":r:i:p:")) != -1) {
+		switch(ch) {
+			case 'r':
+				remote_subnet = atoi(optarg);
+				break;
+			case 'i':
+				listenip = optarg;
+				break;
+			case 'p':
+				port = atoi(optarg);
+				break;
+			case ':':
+				dprintf(2, "error: option -%c requires an operand\n", optopt);
+				/* fall through */
+			case '?':
+				return usage(argv[0]);
+		}
+	}
+	signal(SIGPIPE, SIG_IGN);
+	struct server s;
+	if(server_setup(&s, listenip, port)) {
+		perror("server_setup");
+		return 1;
+	}
+	server = &s;
+
+	ip_lookup_table = htab_create(64);
+	hostnames = sblist_new(sizeof(char*), 64);
+
+	while(1) {
+		struct client c;
+		char ipstr_buf[INET6_ADDRSTRLEN+6+1];
+		char ip4str_buf[16];
+		struct at_msg msg, out;
+		size_t msgl = sizeof(msg);
+		int failed = 0;
+
+#define FAIL() do { failed=1; goto sendresp; } while(0)
+
+		if(server_waitclient(&s, &c, &msg, &msgl)) continue;
+		msg.h.datalen = ntohs(msg.h.datalen);
+		if(msgl != sizeof(msg.h)+msg.h.datalen) {
+			dolog("%s: invalid datalen\n", ipstr(&c.addr, ipstr_buf));
+			FAIL();
+		}
+
+		out.h.msgtype = msg.h.msgtype;
+		if(msg.h.msgtype == ATM_GETIP) {
+			if(!memchr(msg.m.host, 0, msg.h.datalen)) {
+				dolog("%s: nul terminator missing\n", ipstr(&c.addr, ipstr_buf));
+				FAIL();
+			}
+			out.h.datalen = sizeof(ip_type4);
+			out.m.ip = get_ip(msg.m.host);
+			failed = !memcmp(&out.m.ip, &IPT4_INVALID, 4);
+			dolog("%s requested ip for %s (%s)\n", ipstr(&c.addr, ipstr_buf),
+			      msg.m.host, failed?"FAIL":my_inet_ntoa((void*)&out.m.ip, ip4str_buf));
+			if(failed) FAIL();
+		} else if (msg.h.msgtype == ATM_GETNAME) {
+			if(msg.h.datalen != 4) {
+				dolog("%s: invalid len for getname request\n", ipstr(&c.addr, ipstr_buf));
+				FAIL();
+			}
+			char *hn = host_from_ip(msg.m.ip);
+			if(hn) {
+				size_t l = strlen(hn);
+				memcpy(out.m.host, hn, l+1);
+				out.h.datalen = l+1;
+			}
+			dolog("%s requested name for %s (%s)\n", ipstr(&c.addr, ipstr_buf),
+			      my_inet_ntoa((void*) &msg.m.ip, ip4str_buf), hn?hn:"FAIL");
+			if(!hn) FAIL();
+		} else {
+			dolog("%s: unknown request %u\n", ipstr(&c.addr, ipstr_buf),
+			      (unsigned) msg.h.msgtype);
+		}
+	sendresp:;
+		if(failed) {
+			out.h.msgtype = ATM_FAIL;
+			out.h.datalen = 0;
+		}
+		unsigned short dlen = out.h.datalen;
+		out.h.datalen = htons(dlen);
+		sendto(server->fd, &out, sizeof(out.h)+dlen, 0, (void*) &c.addr, SOCKADDR_UNION_LENGTH(&c.addr));
+	}
+}

src/daemon/hsearch.c

@@ -0,0 +1,188 @@
+/*
+musl license, hsearch.c originally written by Szabolcs Nagy
+
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include "hsearch.h"
+
+/*
+open addressing hash table with 2^n table size
+quadratic probing is used in case of hash collision
+tab indices and hash are size_t
+after resize fails with ENOMEM the state of tab is still usable
+*/
+
+typedef struct htab_entry {
+	char *key;
+	htab_value data;
+} htab_entry;
+
+struct elem {
+	htab_entry item;
+	size_t hash;
+};
+
+struct htab {
+	struct elem *elems;
+	size_t mask;
+	size_t used;
+};
+
+#define MINSIZE 8
+#define MAXSIZE ((size_t)-1/2 + 1)
+
+static size_t keyhash(char *k)
+{
+	unsigned char *p = (void *)k;
+	size_t h = 0;
+
+	while (*p)
+		h = 31*h + *p++;
+	return h;
+}
+
+static int resize(struct htab *htab, size_t nel)
+{
+	size_t newsize;
+	size_t i, j;
+	struct elem *e, *newe;
+	struct elem *oldtab = htab->elems;
+	struct elem *oldend = htab->elems + htab->mask + 1;
+
+	if (nel > MAXSIZE)
+		nel = MAXSIZE;
+	for (newsize = MINSIZE; newsize < nel; newsize *= 2);
+	htab->elems = calloc(newsize, sizeof *htab->elems);
+	if (!htab->elems) {
+		htab->elems = oldtab;
+		return 0;
+	}
+	htab->mask = newsize - 1;
+	if (!oldtab)
+		return 1;
+	for (e = oldtab; e < oldend; e++)
+		if (e->item.key) {
+			for (i=e->hash,j=1; ; i+=j++) {
+				newe = htab->elems + (i & htab->mask);
+				if (!newe->item.key)
+					break;
+			}
+			*newe = *e;
+		}
+	free(oldtab);
+	return 1;
+}
+
+static struct elem *lookup(struct htab *htab, char *key, size_t hash)
+{
+	size_t i, j;
+	struct elem *e;
+
+	for (i=hash,j=1; ; i+=j++) {
+		e = htab->elems + (i & htab->mask);
+		if (!e->item.key ||
+		    (e->hash==hash && strcmp(e->item.key, key)==0))
+			break;
+	}
+	return e;
+}
+
+struct htab *htab_create(size_t nel)
+{
+	struct htab *r = calloc(1, sizeof *r);
+	if(r && !resize(r, nel)) {
+		free(r);
+		r = 0;
+	}
+	return r;
+}
+
+void htab_destroy(struct htab *htab)
+{
+	free(htab->elems);
+	free(htab);
+}
+
+static htab_entry *htab_find_item(struct htab *htab, char* key)
+{
+	size_t hash = keyhash(key);
+	struct elem *e = lookup(htab, key, hash);
+
+	if (e->item.key) {
+		return &e->item;
+	}
+	return 0;
+}
+
+htab_value* htab_find(struct htab *htab, char* key)
+{
+	htab_entry *i = htab_find_item(htab, key);
+	if(i) return &i->data;
+	return 0;
+}
+
+int htab_delete(struct htab *htab, char* key)
+{
+	htab_entry *i = htab_find_item(htab, key);
+	if(!i) return 0;
+	i->key = 0;
+	return 1;
+}
+
+int htab_insert(struct htab *htab, char* key, htab_value value)
+{
+	size_t hash = keyhash(key);
+	struct elem *e = lookup(htab, key, hash);
+	if(e->item.key) {
+		/* it's not allowed to overwrite existing data */
+		return 0;
+	}
+
+	e->item.key = key;
+	e->item.data = value;
+	e->hash = hash;
+	if (++htab->used > htab->mask - htab->mask/4) {
+		if (!resize(htab, 2*htab->used)) {
+			htab->used--;
+			e->item.key = 0;
+			return 0;
+		}
+	}
+	return 1;
+}
+
+size_t htab_next(struct htab *htab, size_t iterator, char** key, htab_value **v)
+{
+	size_t i;
+	for(i=iterator;i<htab->mask+1;++i) {
+		struct elem *e = htab->elems + i;
+		if(e->item.key) {
+			*key = e->item.key;
+			*v = &e->item.data;
+			return i+1;
+		}
+	}
+	return 0;
+}

src/daemon/hsearch.h

@@ -0,0 +1,21 @@
+#ifndef HSEARCH_H
+#define HSEARCH_H
+
+#include <stdlib.h>
+
+typedef union htab_value {
+	void *p;
+	size_t n;
+} htab_value;
+
+#define HTV_N(N) (htab_value) {.n = N}
+#define HTV_P(P) (htab_value) {.p = P}
+
+struct htab * htab_create(size_t);
+void htab_destroy(struct htab *);
+htab_value* htab_find(struct htab *, char* key);
+int htab_insert(struct htab *, char*, htab_value);
+int htab_delete(struct htab *htab, char* key);
+size_t htab_next(struct htab *, size_t iterator, char** key, htab_value **v);
+
+#endif

src/daemon/sblist.c

@@ -0,0 +1,73 @@
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#include "sblist.h"
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#define MY_PAGE_SIZE 4096
+
+sblist* sblist_new(size_t itemsize, size_t blockitems) {
+	sblist* ret = (sblist*) malloc(sizeof(sblist));
+	sblist_init(ret, itemsize, blockitems);
+	return ret;
+}
+
+static void sblist_clear(sblist* l) {
+	l->items = NULL;
+	l->capa = 0;
+	l->count = 0;
+}
+
+void sblist_init(sblist* l, size_t itemsize, size_t blockitems) {
+	if(l) {
+		l->blockitems = blockitems ? blockitems : MY_PAGE_SIZE / itemsize;
+		l->itemsize = itemsize;
+		sblist_clear(l);
+	}
+}
+
+void sblist_free_items(sblist* l) {
+	if(l) {
+		if(l->items) free(l->items);
+		sblist_clear(l);
+	}
+}
+
+void sblist_free(sblist* l) {
+	if(l) {
+		sblist_free_items(l);
+		free(l);
+	}
+}
+
+char* sblist_item_from_index(sblist* l, size_t idx) {
+	return l->items + (idx * l->itemsize);
+}
+
+void* sblist_get(sblist* l, size_t item) {
+	if(item < l->count) return (void*) sblist_item_from_index(l, item);
+	return NULL;
+}
+
+int sblist_set(sblist* l, void* item, size_t pos) {
+	if(pos >= l->count) return 0;
+	memcpy(sblist_item_from_index(l, pos), item, l->itemsize);
+	return 1;
+}
+
+int sblist_grow_if_needed(sblist* l) {
+	char* temp;
+	if(l->count == l->capa) {
+		temp = realloc(l->items, (l->capa + l->blockitems) * l->itemsize);
+		if(!temp) return 0;
+		l->capa += l->blockitems;
+		l->items = temp;
+	}
+	return 1;
+}
+
+int sblist_add(sblist* l, void* item) {
+	if(!sblist_grow_if_needed(l)) return 0;
+	l->count++;
+	return sblist_set(l, item, l->count - 1);
+}

src/daemon/sblist.h

@@ -0,0 +1,92 @@
+#ifndef SBLIST_H
+#define SBLIST_H
+
+/* this file is part of libulz, as of commit 8ab361a27743aaf025323ee43b8b8876dc054fdd
+   modified for direct inclusion in microsocks. */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+/*
+ * simple buffer list.
+ * 
+ * this thing here is basically a generic dynamic array
+ * will realloc after every blockitems inserts
+ * can store items of any size.
+ * 
+ * so think of it as a by-value list, as opposed to a typical by-ref list.
+ * you typically use it by having some struct on the stack, and pass a pointer
+ * to sblist_add, which will copy the contents into its internal memory.
+ * 
+ */
+
+typedef struct {
+	size_t itemsize;
+	size_t blockitems;
+	size_t count;
+	size_t capa;
+	char* items;
+} sblist;
+
+#define sblist_getsize(X) ((X)->count)
+#define sblist_get_count(X) ((X)->count)
+#define sblist_empty(X) ((X)->count == 0)
+
+// for dynamic style
+sblist* sblist_new(size_t itemsize, size_t blockitems);
+void sblist_free(sblist* l);
+
+//for static style
+void sblist_init(sblist* l, size_t itemsize, size_t blockitems);
+void sblist_free_items(sblist* l);
+
+// accessors
+void* sblist_get(sblist* l, size_t item);
+// returns 1 on success, 0 on OOM
+int sblist_add(sblist* l, void* item);
+int sblist_set(sblist* l, void* item, size_t pos);
+void sblist_delete(sblist* l, size_t item);
+char* sblist_item_from_index(sblist* l, size_t idx);
+int sblist_grow_if_needed(sblist* l);
+int sblist_insert(sblist* l, void* item, size_t pos);
+/* same as sblist_add, but returns list index of new item, or -1 */
+size_t sblist_addi(sblist* l, void* item);
+void sblist_sort(sblist *l, int (*compar)(const void *, const void *));
+/* insert element into presorted list, returns listindex of new entry or -1*/
+size_t sblist_insert_sorted(sblist* l, void* o, int (*compar)(const void *, const void *));
+
+#ifndef __COUNTER__
+#define __COUNTER__ __LINE__
+#endif
+
+#define __sblist_concat_impl( x, y ) x##y
+#define __sblist_macro_concat( x, y ) __sblist_concat_impl( x, y )
+#define __sblist_iterator_name __sblist_macro_concat(sblist_iterator, __COUNTER__)
+
+// use with custom iterator variable
+#define sblist_iter_counter(LIST, ITER, PTR) \
+	for(size_t ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < sblist_getsize(LIST); ITER++)
+
+// use with custom iterator variable, which is predeclared
+#define sblist_iter_counter2(LIST, ITER, PTR) \
+	for(ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < sblist_getsize(LIST); ITER++)
+
+// use with custom iterator variable, which is predeclared and signed
+// useful for a loop which can delete items from the list, and then decrease the iterator var.
+#define sblist_iter_counter2s(LIST, ITER, PTR) \
+	for(ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < (ssize_t) sblist_getsize(LIST); ITER++)
+
+
+// uses "magic" iterator variable
+#define sblist_iter(LIST, PTR) sblist_iter_counter(LIST, __sblist_iterator_name, PTR)
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma RcB2 DEP "sblist.c" "sblist_delete.c"
+
+#endif

src/daemon/sblist_delete.c

@@ -0,0 +1,9 @@
+#include "sblist.h"
+#include <string.h>
+
+void sblist_delete(sblist* l, size_t item) {
+	if (l->count && item < l->count) {
+		memmove(sblist_item_from_index(l, item), sblist_item_from_index(l, item + 1), (sblist_getsize(l) - (item + 1)) * l->itemsize);
+		l->count--;
+	}
+}

src/daemon/udpclient.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "../remotedns.h"
+#include "../ip_type.h"
+
+int main() {
+	int fd;
+	int port = 1053;
+	char srvn[] = "127.0.0.1";
+	struct sockaddr_in srva = {.sin_family = AF_INET, .sin_port = htons(port)};
+	inet_pton(AF_INET, srvn, &srva.sin_addr);
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	char namebuf[260];
+	while(fgets(namebuf, sizeof namebuf, stdin)) {
+		size_t l = strlen(namebuf);
+		if(namebuf[l-1] == '\n') {
+			l--;
+			namebuf[l] = 0;
+		}
+		struct at_msg msg = {0};
+		unsigned msglen;
+		if(isdigit(namebuf[0])) {
+			msglen = 4;
+			msg.h.msgtype = ATM_GETNAME;
+			inet_aton(namebuf, (void*) &msg.m.ip);
+		} else {
+			msglen = l+1;
+			msg.h.msgtype = ATM_GETIP;
+			memcpy(msg.m.host, namebuf, msglen);
+		}
+		msg.h.datalen = htons(msglen);
+		sendto(fd, &msg, sizeof(msg.h)+msglen, 0, (void*)&srva, sizeof(srva));
+		char rcvbuf[512];
+		recvfrom(fd, rcvbuf, sizeof rcvbuf, 0, (void*)0, (void*)0);
+	}
+}

src/daemon/udpserver.c

@@ -0,0 +1,65 @@
+#include "udpserver.h"
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int resolve(const char *host, unsigned short port, struct addrinfo** addr) {
+	struct addrinfo hints = {
+		.ai_family = AF_UNSPEC,
+		.ai_socktype = SOCK_STREAM,
+		.ai_flags = AI_PASSIVE,
+	};
+	char port_buf[8];
+	snprintf(port_buf, sizeof port_buf, "%u", port);
+	return getaddrinfo(host, port_buf, &hints, addr);
+}
+
+int resolve_sa(const char *host, unsigned short port, union sockaddr_union *res) {
+	struct addrinfo *ainfo = 0;
+	int ret;
+	SOCKADDR_UNION_AF(res) = AF_UNSPEC;
+	if((ret = resolve(host, port, &ainfo))) return ret;
+	memcpy(res, ainfo->ai_addr, ainfo->ai_addrlen);
+	freeaddrinfo(ainfo);
+	return 0;
+}
+
+int bindtoip(int fd, union sockaddr_union *bindaddr) {
+	socklen_t sz = SOCKADDR_UNION_LENGTH(bindaddr);
+	if(sz)
+		return bind(fd, (struct sockaddr*) bindaddr, sz);
+	return 0;
+}
+
+int server_waitclient(struct server *server, struct client* client, void* buf, size_t *buflen) {
+	socklen_t clen = sizeof client->addr;
+	ssize_t ret = recvfrom(server->fd, buf, *buflen, 0, (void*)&client->addr, &clen);
+	if(ret >= 0) {
+		*buflen = ret;
+		return 0;
+	}
+	return ret;
+}
+
+int server_setup(struct server *server, const char* listenip, unsigned short port) {
+	struct addrinfo *ainfo = 0;
+	if(resolve(listenip, port, &ainfo)) return -1;
+	struct addrinfo* p;
+	int listenfd = -1;
+	for(p = ainfo; p; p = p->ai_next) {
+		if((listenfd = socket(p->ai_family, SOCK_DGRAM, 0)) < 0)
+			continue;
+		int yes = 1;
+		setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
+		if(bind(listenfd, p->ai_addr, p->ai_addrlen) < 0) {
+			close(listenfd);
+			listenfd = -1;
+			continue;
+		}
+		break;
+	}
+	freeaddrinfo(ainfo);
+	if(listenfd < 0) return -2;
+	server->fd = listenfd;
+	return 0;
+}

src/daemon/udpserver.h

@@ -0,0 +1,48 @@
+#ifndef SERVER_H
+#define SERVER_H
+
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+
+#pragma RcB2 DEP "udpserver.c"
+
+union sockaddr_union {
+	struct sockaddr_in  v4;
+	struct sockaddr_in6 v6;
+};
+
+#define SOCKADDR_UNION_AF(PTR) (PTR)->v4.sin_family
+
+#define SOCKADDR_UNION_LENGTH(PTR) ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET  ) ? sizeof((PTR)->v4) : ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? sizeof((PTR)->v6) : 0 ) )
+
+#define SOCKADDR_UNION_ADDRESS(PTR) ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET  ) ? (void*) &(PTR)->v4.sin_addr  : ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? (void*) &(PTR)->v6.sin6_addr : (void*) 0 ) )
+
+#define SOCKADDR_UNION_PORT(PTR) ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET  ) ? (PTR)->v4.sin_port  : ( \
+	( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? (PTR)->v6.sin6_port : 0 ) )
+
+struct client {
+	union sockaddr_union addr;
+};
+
+struct server {
+	int fd;
+};
+
+int resolve(const char *host, unsigned short port, struct addrinfo** addr);
+int resolve_sa(const char *host, unsigned short port, union sockaddr_union *res);
+int bindtoip(int fd, union sockaddr_union *bindaddr);
+
+int server_waitclient(struct server *server, struct client* client, void* buf, size_t *buflen);
+int server_setup(struct server *server, const char* listenip, unsigned short port);
+
+#endif
+

src/debug.c

@@ -5,7 +5,7 @@
 # include "debug.h"
 #include <arpa/inet.h>
 
-void DUMP_PROXY_CHAIN(proxy_data *pchain, unsigned int count) {
+void dump_proxy_chain(proxy_data *pchain, unsigned int count) {
 	char ip_buf[INET6_ADDRSTRLEN];
 	for (; count; pchain++, count--) {
 		if(!inet_ntop(pchain->ip.is_v6?AF_INET6:AF_INET,pchain->ip.addr.v6,ip_buf,sizeof ip_buf)) {

src/debug.h

@@ -1,22 +1,24 @@
 #ifndef DEBUG_H
 #define DEBUG_H
 
-#ifdef DEBUG
 # include <stdio.h>
+
+#ifdef DEBUG
 # define PSTDERR(fmt, args...) do { dprintf(2,fmt, ## args); } while(0)
-# define PDEBUG(fmt, args...) PSTDERR("DEBUG:"fmt, ## args)
+# define PDEBUG(fmt, args...) PSTDERR("DEBUG:pid[%d]:" fmt, getpid(), ## args)
 # define DEBUGDECL(args...) args
-
+# define DUMP_PROXY_CHAIN(A, B) dump_proxy_chain(A, B)
-# include "core.h"
-void DUMP_PROXY_CHAIN(proxy_data *pchain, unsigned int count);
-
 #else
 # define PDEBUG(fmt, args...) do {} while (0)
 # define DEBUGDECL(args...)
 # define DUMP_PROXY_CHAIN(args...) do {} while (0)
 #endif
 
-# define PFUNC() do { PDEBUG("pid[%d]:%s\n", getpid(), __FUNCTION__); } while(0)
+# define PFUNC() do { PDEBUG("%s()\n", __FUNCTION__); } while(0)
+
+#include "core.h"
+void dump_proxy_chain(proxy_data *pchain, unsigned int count);
+
 
 #endif
 

src/hostsreader.c

@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#include "common.h"
 
 /*
    simple reader for /etc/hosts
@@ -24,7 +25,6 @@ void hostsreader_close(struct hostsreader *ctx) {
 	fclose(ctx->f);
 }
 
-static int isnumericipv4(const char* ipstring);
 int hostsreader_get(struct hostsreader *ctx, char* buf, size_t bufsize) {
 	while(1) {
 		if(!fgets(buf, bufsize, ctx->f)) return 0;
@@ -51,7 +51,7 @@ int hostsreader_get(struct hostsreader *ctx, char* buf, size_t bufsize) {
 		}
 		if(!l || !*p) continue;
 		*p = 0;
-		if(isnumericipv4(ctx->ip)) return 1;
+		if(pc_isnumericipv4(ctx->ip)) return 1;
 	}
 }
 
@@ -82,7 +82,7 @@ ip_type4 hostsreader_get_numeric_ip_for_name(const char* name) {
 		ip_type4 res;
 		memcpy(res.octet, &c.s_addr, 4);
 		return res;
-	} else return ip_type_invalid.addr.v4;
+	} else return IPT4_INVALID;
 }
 
 #ifdef HOSTSREADER_TEST
@@ -94,30 +94,3 @@ int main(int a, char**b) {
 	printf("%s\n", ret ? ret : "null");
 }
 #endif
-
-/* isnumericipv4() taken from libulz */
-static int isnumericipv4(const char* ipstring) {
-	size_t x = 0, n = 0, d = 0;
-	int wasdot = 0;
-	while(1) {
-		switch(ipstring[x]) {
-			case 0: goto done;
-			case '.':
-				if(!n || wasdot) return 0;
-				d++;
-				wasdot = 1;
-				break;
-			case '0': case '1': case '2': case '3': case '4':
-			case '5': case '6': case '7': case '8': case '9':
-				n++;
-				wasdot = 0;
-				break;
-			default:
-				return 0;
-		}
-		x++;
-	}
-	done:
-	if(d == 3 && n >= 4 && n <= 12) return 1;
-	return 0;
-}

src/ip_type.c

@@ -1,5 +0,0 @@
-#include "ip_type.h"
-
-const ip_type ip_type_invalid = { .addr.v4.as_int = -1 };
-const ip_type ip_type_localhost = { .addr.v4.octet = {127, 0, 0, 1} };
-

src/ip_type.h

@@ -16,8 +16,10 @@ typedef struct {
 	char is_v6;
 } ip_type;
 
-extern const ip_type ip_type_invalid;
+#define IPT4_INT(X) (ip_type4){.as_int = (X)}
-extern const ip_type ip_type_localhost;
+#define IPT4_INVALID IPT4_INT(-1)
+
+#define IPT4_BYTES(A,B,C,D) (ip_type4){.octet = {(A), (B), (C), (D)} }
+#define IPT4_LOCALHOST IPT4_BYTES(127,0,0,1)
 
-//RcB: DEP "ip_type.c"
 #endif

src/libproxychains.c

@@ -22,6 +22,8 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
+#include <ctype.h>
 #include <errno.h>
 #include <assert.h>
 #include <netdb.h>
@@ -37,7 +39,9 @@
 
 #include "core.h"
 #include "common.h"
+#include "rdns.h"
 
+#undef 		satosin
 #define     satosin(x)      ((struct sockaddr_in *) &(x))
 #define     SOCKADDR(x)     (satosin(x)->sin_addr.s_addr)
 #define     SOCKADDR_2(x)     (satosin(x)->sin_addr)
@@ -45,7 +49,14 @@
 #define     SOCKFAMILY(x)     (satosin(x)->sin_family)
 #define     MAX_CHAIN 512
 
+#ifdef IS_SOLARIS
+#undef connect
+int __xnet_connect(int sock, const struct sockaddr *addr, unsigned int len);
+connect_t true___xnet_connect;
+#endif
+
 close_t true_close;
+close_range_t true_close_range;
 connect_t true_connect;
 gethostbyname_t true_gethostbyname;
 getaddrinfo_t true_getaddrinfo;
@@ -63,24 +74,27 @@ unsigned int proxychains_proxy_offset = 0;
 int proxychains_got_chain_data = 0;
 unsigned int proxychains_max_chain = 1;
 int proxychains_quiet_mode = 0;
-int proxychains_resolver = 0;
+enum dns_lookup_flavor proxychains_resolver = DNSLF_LIBC;
 localaddr_arg localnet_addr[MAX_LOCALNET];
 size_t num_localnet_addr = 0;
+dnat_arg dnats[MAX_DNAT];
+size_t num_dnats = 0;
 unsigned int remote_dns_subnet = 224;
 
 pthread_once_t init_once = PTHREAD_ONCE_INIT;
 
 static int init_l = 0;
 
-static inline void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_type * ct);
+static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_type * ct);
-
-static void* load_sym(char* symname, void* proxyfunc) {
 
+static void* load_sym(char* symname, void* proxyfunc, int is_mandatory) {
 	void *funcptr = dlsym(RTLD_NEXT, symname);
 
-	if(!funcptr) {
+	if(is_mandatory && !funcptr) {
 		fprintf(stderr, "Cannot load symbol '%s' %s\n", symname, dlerror());
 		exit(1);
+	} else if (!funcptr) {
+		return funcptr;
 	} else {
 		PDEBUG("loaded symbol '%s'" " real addr %p  wrapped addr %p\n", symname, funcptr, proxyfunc);
 	}
@@ -91,44 +105,59 @@ static void* load_sym(char* symname, void* proxyfunc) {
 	return funcptr;
 }
 
-#define INIT() init_lib_wrapper(__FUNCTION__)
-
-#define SETUP_SYM(X) do { if (! true_ ## X ) true_ ## X = load_sym( # X, X ); } while(0)
-
 #include "allocator_thread.h"
 
 const char *proxychains_get_version(void);
 
-static void setup_hooks(void) {
+static void setup_hooks(void);
-	SETUP_SYM(connect);
-	SETUP_SYM(sendto);
-	SETUP_SYM(gethostbyname);
-	SETUP_SYM(getaddrinfo);
-	SETUP_SYM(freeaddrinfo);
-	SETUP_SYM(gethostbyaddr);
-	SETUP_SYM(getnameinfo);
-	SETUP_SYM(close);
-}
 
+typedef struct {
+	unsigned int first, last, flags;
+} close_range_args_t;
+
+/* If there is some `close` or `close_range` system call before do_init, 
+   we buffer it, and actually execute them in do_init. */
 static int close_fds[16];
 static int close_fds_cnt = 0;
+static close_range_args_t close_range_buffer[16];
+static int close_range_buffer_cnt = 0;
+
+static unsigned get_rand_seed(void) {
+#ifdef HAVE_CLOCK_GETTIME
+	struct timespec now;
+	clock_gettime(CLOCK_REALTIME, &now);
+	return now.tv_sec ^ now.tv_nsec;
+#else
+	return time(NULL);
+#endif
+}
 
 static void do_init(void) {
-	srand(time(NULL));
+	char *env;
-	core_initialize();
-	at_init();
 
-	/* read the config file */
+	srand(get_rand_seed());
-	get_chain_data(proxychains_pd, &proxychains_proxy_count, &proxychains_ct);
+	core_initialize();
-	DUMP_PROXY_CHAIN(proxychains_pd, proxychains_proxy_count);
+
+	env = getenv(PROXYCHAINS_QUIET_MODE_ENV_VAR);
+	if(env && *env == '1')
+		proxychains_quiet_mode = 1;
 
 	proxychains_write_log(LOG_PREFIX "DLL init: proxychains-ng %s\n", proxychains_get_version());
 
 	setup_hooks();
 
-	while(close_fds_cnt) true_close(close_fds[--close_fds_cnt]);
+	/* read the config file */
+	get_chain_data(proxychains_pd, &proxychains_proxy_count, &proxychains_ct);
+	DUMP_PROXY_CHAIN(proxychains_pd, proxychains_proxy_count);
 
+	while(close_fds_cnt) true_close(close_fds[--close_fds_cnt]);
+	while(close_range_buffer_cnt) {
+		int i = --close_range_buffer_cnt;
+		true_close_range(close_range_buffer[i].first, close_range_buffer[i].last, close_range_buffer[i].flags);
+	}
 	init_l = 1;
+
+	rdns_init(proxychains_resolver);
 }
 
 static void init_lib_wrapper(const char* caller) {
@@ -144,43 +173,157 @@ static void init_lib_wrapper(const char* caller) {
  * lazily, which has the disadvantage that there's a potential
  * race condition if 2 threads call it before init_l is set
  * and PTHREAD support was disabled */
-#if __GNUC__ > 2
+#if __GNUC__+0 > 2
 __attribute__((constructor))
 static void gcc_init(void) {
-	INIT();
+	init_lib_wrapper(__FUNCTION__);
 }
+#define INIT() do {} while(0)
+#else
+#define INIT() init_lib_wrapper(__FUNCTION__)
 #endif
 
+
+typedef enum {
+	RS_PT_NONE = 0,
+	RS_PT_SOCKS4,
+	RS_PT_SOCKS5,
+	RS_PT_HTTP
+} rs_proxyType;
+
+/*
+  proxy_from_string() taken from rocksock network I/O library (C) rofl0r
+  valid inputs:
+	socks5://user:password@proxy.domain.com:port
+	socks5://proxy.domain.com:port
+	socks4://proxy.domain.com:port
+	http://user:password@proxy.domain.com:port
+	http://proxy.domain.com:port
+
+	supplying port number is obligatory.
+	user:pass@ part is optional for http and socks5.
+	however, user:pass authentication is currently not implemented for http proxies.
+  return 1 on success, 0 on error.
+*/
+static int proxy_from_string(const char *proxystring,
+	char *type_buf,
+	char* host_buf,
+	int *port_n,
+	char *user_buf,
+	char* pass_buf)
+{
+	const char* p;
+	rs_proxyType proxytype;
+
+	size_t next_token = 6, ul = 0, pl = 0, hl;
+	if(!proxystring[0] || !proxystring[1] || !proxystring[2] || !proxystring[3] || !proxystring[4] || !proxystring[5]) goto inv_string;
+	if(*proxystring == 's') {
+		switch(proxystring[5]) {
+			case '5': proxytype = RS_PT_SOCKS5; break;
+			case '4': proxytype = RS_PT_SOCKS4; break;
+			default: goto inv_string;
+		}
+	} else if(*proxystring == 'h') {
+		proxytype = RS_PT_HTTP;
+		next_token = 4;
+	} else goto inv_string;
+	if(
+	   proxystring[next_token++] != ':' ||
+	   proxystring[next_token++] != '/' ||
+	   proxystring[next_token++] != '/') goto inv_string;
+	const char *at = strrchr(proxystring+next_token, '@');
+	if(at) {
+		if(proxytype == RS_PT_SOCKS4)
+			return 0;
+		p = strchr(proxystring+next_token, ':');
+		if(!p || p >= at) goto inv_string;
+		const char *u = proxystring+next_token;
+		ul = p-u;
+		p++;
+		pl = at-p;
+		if(proxytype == RS_PT_SOCKS5 && (ul > 255 || pl > 255))
+			return 0;
+		memcpy(user_buf, u, ul);
+		user_buf[ul]=0;
+		memcpy(pass_buf, p, pl);
+		pass_buf[pl]=0;
+		next_token += 2+ul+pl;
+	} else {
+		user_buf[0]=0;
+		pass_buf[0]=0;
+	}
+	const char* h = proxystring+next_token;
+	p = strchr(h, ':');
+	if(!p) goto inv_string;
+	hl = p-h;
+	if(hl > 255)
+		return 0;
+	memcpy(host_buf, h, hl);
+	host_buf[hl]=0;
+	*port_n = atoi(p+1);
+	switch(proxytype) {
+		case RS_PT_SOCKS4:
+			strcpy(type_buf, "socks4");
+			break;
+		case RS_PT_SOCKS5:
+			strcpy(type_buf, "socks5");
+			break;
+		case RS_PT_HTTP:
+			strcpy(type_buf, "http");
+			break;
+		default:
+			return 0;
+	}
+	return 1;
+inv_string:
+	return 0;
+}
+
+static const char* bool_str(int bool_val) {
+	if(bool_val) return "true";
+	return "false";
+}
+
+#define STR_STARTSWITH(P, LIT) (!strncmp(P, LIT, sizeof(LIT)-1))
 /* get configuration from config file */
 static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_type * ct) {
 	int count = 0, port_n = 0, list = 0;
-	char buff[1024], type[1024], host[1024], user[1024];
+	char buf[1024], type[1024], host[1024], user[1024];
-	char *env;
+	char *buff, *env, *p;
-	char local_in_addr_port[32];
+	char local_addr_port[64], local_addr[64], local_netmask[32];
-	char local_in_addr[32], local_in_port[32], local_netmask[32];
+	char dnat_orig_addr_port[32], dnat_new_addr_port[32];
+	char dnat_orig_addr[32], dnat_orig_port[32], dnat_new_addr[32], dnat_new_port[32];
+	char rdnsd_addr[32], rdnsd_port[8];
 	FILE *file = NULL;
 
 	if(proxychains_got_chain_data)
 		return;
 
+	PFUNC();
+
 	//Some defaults
 	tcp_read_time_out = 4 * 1000;
 	tcp_connect_time_out = 10 * 1000;
 	*ct = DYNAMIC_TYPE;
 
-	env = get_config_path(getenv(PROXYCHAINS_CONF_FILE_ENV_VAR), buff, sizeof(buff));
+	env = get_config_path(getenv(PROXYCHAINS_CONF_FILE_ENV_VAR), buf, sizeof(buf));
 	if( ( file = fopen(env, "r") ) == NULL )
 	{
 	        perror("couldnt read configuration file");
         	exit(1);
 	}
 
-	env = getenv(PROXYCHAINS_QUIET_MODE_ENV_VAR);
+	while(fgets(buf, sizeof(buf), file)) {
-	if(env && *env == '1')
+		buff = buf;
-		proxychains_quiet_mode = 1;
+		/* remove leading whitespace */
-
+		while(isspace(*buff)) buff++;
-	while(fgets(buff, sizeof(buff), file)) {
+		/* remove trailing '\n' */
-		if(buff[0] != '\n' && buff[strspn(buff, " ")] != '#') {
+		if((p = strrchr(buff, '\n'))) *p = 0;
+		p = buff + strlen(buff)-1;
+		/* remove trailing whitespace */
+		while(p >= buff && isspace(*p)) *(p--) = 0;
+		if(!*buff || *buff == '#') continue; /* skip empty lines and comments */
+		if(1) {
 			/* proxylist has to come last */
 			if(list) {
 				if(count >= MAX_CHAIN)
@@ -193,9 +336,11 @@ static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_typ
 
 				int ret = sscanf(buff, "%s %s %d %s %s", type, host, &port_n, pd[count].user, pd[count].pass);
 				if(ret < 3 || ret == EOF) {
-					inv:
+					if(!proxy_from_string(buff, type, host, &port_n, pd[count].user, pd[count].pass)) {
-					fprintf(stderr, "error: invalid item in proxylist section: %s", buff);
+						inv:
-					exit(1);
+						fprintf(stderr, "error: invalid item in proxylist section: %s", buff);
+						exit(1);
+					}
 				}
 
 				memset(&pd[count].ip, 0, sizeof(pd[count].ip));
@@ -203,12 +348,27 @@ static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_typ
 				pd[count].port = htons((unsigned short) port_n);
 				ip_type* host_ip = &pd[count].ip;
 				if(1 != inet_pton(host_ip->is_v6 ? AF_INET6 : AF_INET, host, host_ip->addr.v6)) {
-					fprintf(stderr, "proxy %s has invalid value or is not numeric\n", host);
+					if(*ct == STRICT_TYPE && proxychains_resolver >= DNSLF_RDNS_START && count > 0) {
-					exit(1);
+						/* we can allow dns hostnames for all but the first proxy in the list if chaintype is strict, as remote lookup can be done */
+						rdns_init(proxychains_resolver);
+						ip_type4 internal_ip = rdns_get_ip_for_host(host, strlen(host));
+						pd[count].ip.is_v6 = 0;
+						host_ip->addr.v4 = internal_ip;
+						if(internal_ip.as_int == IPT4_INVALID.as_int)
+							goto inv_host;
+					} else {
+inv_host:
+						fprintf(stderr, "proxy %s has invalid value or is not numeric\n", host);
+						fprintf(stderr, "non-numeric ips are only allowed under the following circumstances:\n");
+						fprintf(stderr, "chaintype == strict (%s), proxy is not first in list (%s), proxy_dns active (%s)\n\n", bool_str(*ct == STRICT_TYPE), bool_str(count > 0), rdns_resolver_string(proxychains_resolver));
+						exit(1);
+					}
 				}
 
 				if(!strcmp(type, "http")) {
 					pd[count].pt = HTTP_TYPE;
+				} else if(!strcmp(type, "raw")) {
+					pd[count].pt = RAW_TYPE;
 				} else if(!strcmp(type, "socks4")) {
 					pd[count].pt = SOCKS4_TYPE;
 				} else if(!strcmp(type, "socks5")) {
@@ -219,69 +379,103 @@ static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_typ
 				if(port_n)
 					count++;
 			} else {
-				if(strstr(buff, "[ProxyList]")) {
+				if(!strcmp(buff, "[ProxyList]")) {
 					list = 1;
-				} else if(strstr(buff, "random_chain")) {
+				} else if(!strcmp(buff, "random_chain")) {
 					*ct = RANDOM_TYPE;
-				} else if(strstr(buff, "strict_chain")) {
+				} else if(!strcmp(buff, "strict_chain")) {
 					*ct = STRICT_TYPE;
-				} else if(strstr(buff, "dynamic_chain")) {
+				} else if(!strcmp(buff, "dynamic_chain")) {
 					*ct = DYNAMIC_TYPE;
-				} else if(strstr(buff, "round_robin_chain")) {
+				} else if(!strcmp(buff, "round_robin_chain")) {
 					*ct = ROUND_ROBIN_TYPE;
-				} else if(strstr(buff, "tcp_read_time_out")) {
+				} else if(STR_STARTSWITH(buff, "tcp_read_time_out")) {
 					sscanf(buff, "%s %d", user, &tcp_read_time_out);
-				} else if(strstr(buff, "tcp_connect_time_out")) {
+				} else if(STR_STARTSWITH(buff, "tcp_connect_time_out")) {
 					sscanf(buff, "%s %d", user, &tcp_connect_time_out);
-				} else if(strstr(buff, "remote_dns_subnet")) {
+				} else if(STR_STARTSWITH(buff, "remote_dns_subnet")) {
 					sscanf(buff, "%s %u", user, &remote_dns_subnet);
 					if(remote_dns_subnet >= 256) {
 						fprintf(stderr,
 							"remote_dns_subnet: invalid value. requires a number between 0 and 255.\n");
 						exit(1);
 					}
-				} else if(strstr(buff, "localnet")) {
+				} else if(STR_STARTSWITH(buff, "localnet")) {
-					if(sscanf(buff, "%s %21[^/]/%15s", user, local_in_addr_port, local_netmask) < 3) {
+					char colon, extra, right_bracket[2];
+					unsigned short local_port = 0, local_prefix;
+					int local_family, n, valid;
+					if(sscanf(buff, "%s %53[^/]/%15s%c", user, local_addr_port, local_netmask, &extra) != 3) {
 						fprintf(stderr, "localnet format error");
 						exit(1);
 					}
-					/* clean previously used buffer */
+					p = strchr(local_addr_port, ':');
-					memset(local_in_port, 0, sizeof(local_in_port) / sizeof(local_in_port[0]));
+					if(!p || p == strrchr(local_addr_port, ':')) {
-
+						local_family = AF_INET;
-					if(sscanf(local_in_addr_port, "%15[^:]:%5s", local_in_addr, local_in_port) < 2) {
+						n = sscanf(local_addr_port, "%15[^:]%c%5hu%c", local_addr, &colon, &local_port, &extra);
-						PDEBUG("added localnet: netaddr=%s, netmask=%s\n",
+						valid = n == 1 || (n == 3 && colon == ':');
-						       local_in_addr, local_netmask);
+					} else if(local_addr_port[0] == '[') {
+						local_family = AF_INET6;
+						n = sscanf(local_addr_port, "[%45[^][]%1[]]%c%5hu%c", local_addr, right_bracket, &colon, &local_port, &extra);
+						valid = n == 2 || (n == 4 && colon == ':');
 					} else {
-						PDEBUG("added localnet: netaddr=%s, port=%s, netmask=%s\n",
+						local_family = AF_INET6;
-						       local_in_addr, local_in_port, local_netmask);
+						valid = sscanf(local_addr_port, "%45[^][]%c", local_addr, &extra) == 1;
+					}
+					if(!valid) {
+						fprintf(stderr, "localnet address or port error\n");
+						exit(1);
+					}
+					if(local_port) {
+						PDEBUG("added localnet: netaddr=%s, port=%u, netmask=%s\n",
+						       local_addr, local_port, local_netmask);
+					} else {
+						PDEBUG("added localnet: netaddr=%s, netmask=%s\n",
+						       local_addr, local_netmask);
 					}
 					if(num_localnet_addr < MAX_LOCALNET) {
-						int error;
+						localnet_addr[num_localnet_addr].family = local_family;
-						error =
+						localnet_addr[num_localnet_addr].port = local_port;
-						    inet_pton(AF_INET, local_in_addr,
+						valid = 0;
-							      &localnet_addr[num_localnet_addr].in_addr);
+						if (local_family == AF_INET) {
-						if(error <= 0) {
+							valid =
+							    inet_pton(local_family, local_addr,
+							              &localnet_addr[num_localnet_addr].in_addr) > 0;
+						} else if(local_family == AF_INET6) {
+							valid =
+							    inet_pton(local_family, local_addr,
+							              &localnet_addr[num_localnet_addr].in6_addr) > 0;
+						}
+						if(!valid) {
 							fprintf(stderr, "localnet address error\n");
 							exit(1);
 						}
-						error =
+						if(local_family == AF_INET && strchr(local_netmask, '.')) {
-						    inet_pton(AF_INET, local_netmask,
+							valid =
-							      &localnet_addr[num_localnet_addr].netmask);
+							    inet_pton(local_family, local_netmask,
-						if(error <= 0) {
+							              &localnet_addr[num_localnet_addr].in_mask) > 0;
+						} else {
+							valid = sscanf(local_netmask, "%hu%c", &local_prefix, &extra) == 1;
+							if (valid) {
+								if(local_family == AF_INET && local_prefix <= 32) {
+									localnet_addr[num_localnet_addr].in_mask.s_addr =
+										htonl(0xFFFFFFFFu << (32u - local_prefix));
+								} else if(local_family == AF_INET6 && local_prefix <= 128) {
+									localnet_addr[num_localnet_addr].in6_prefix =
+										local_prefix;
+								} else {
+									valid = 0;
+								}
+							}
+						}
+						if(!valid) {
 							fprintf(stderr, "localnet netmask error\n");
 							exit(1);
 						}
-						if(local_in_port[0]) {
-							localnet_addr[num_localnet_addr].port =
-							    (short) atoi(local_in_port);
-						} else {
-							localnet_addr[num_localnet_addr].port = 0;
-						}
 						++num_localnet_addr;
 					} else {
 						fprintf(stderr, "# of localnet exceed %d.\n", MAX_LOCALNET);
 					}
-				} else if(strstr(buff, "chain_len")) {
+				} else if(STR_STARTSWITH(buff, "chain_len")) {
 					char *pc;
 					int len;
 					pc = strchr(buff, '=');
@@ -291,10 +485,77 @@ static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_typ
 					}
 					len = atoi(++pc);
 					proxychains_max_chain = (len ? len : 1);
-				} else if(strstr(buff, "quiet_mode")) {
+				} else if(!strcmp(buff, "quiet_mode")) {
 					proxychains_quiet_mode = 1;
-				} else if(strstr(buff, "proxy_dns")) {
+				} else if(!strcmp(buff, "proxy_dns_old")) {
-					proxychains_resolver = 1;
+					proxychains_resolver = DNSLF_FORKEXEC;
+				} else if(!strcmp(buff, "proxy_dns")) {
+					proxychains_resolver = DNSLF_RDNS_THREAD;
+				} else if(STR_STARTSWITH(buff, "proxy_dns_daemon")) {
+					struct sockaddr_in rdns_server_buffer;
+
+					if(sscanf(buff, "%s %15[^:]:%5s", user, rdnsd_addr, rdnsd_port) < 3) {
+						fprintf(stderr, "proxy_dns_daemon format error\n");
+						exit(1);
+					}
+					rdns_server_buffer.sin_family = AF_INET;
+					int error = inet_pton(AF_INET, rdnsd_addr, &rdns_server_buffer.sin_addr);
+					if(error <= 0) {
+						fprintf(stderr, "bogus proxy_dns_daemon address\n");
+						exit(1);
+					}
+					rdns_server_buffer.sin_port = htons(atoi(rdnsd_port));
+					proxychains_resolver = DNSLF_RDNS_DAEMON;
+					rdns_set_daemon(&rdns_server_buffer);
+				} else if(STR_STARTSWITH(buff, "dnat")) {
+					if(sscanf(buff, "%s %21[^ ] %21s\n", user, dnat_orig_addr_port, dnat_new_addr_port) < 3) {
+						fprintf(stderr, "dnat format error");
+						exit(1);
+					}
+					/* clean previously used buffer */
+					memset(dnat_orig_port, 0, sizeof(dnat_orig_port) / sizeof(dnat_orig_port[0]));
+					memset(dnat_new_port, 0, sizeof(dnat_new_port) / sizeof(dnat_new_port[0]));
+
+					(void)sscanf(dnat_orig_addr_port, "%15[^:]:%5s", dnat_orig_addr, dnat_orig_port);
+					(void)sscanf(dnat_new_addr_port, "%15[^:]:%5s", dnat_new_addr, dnat_new_port);
+
+					if(num_dnats < MAX_DNAT) {
+						int error;
+						error =
+						    inet_pton(AF_INET, dnat_orig_addr,
+							      &dnats[num_dnats].orig_dst);
+						if(error <= 0) {
+							fprintf(stderr, "dnat original destination address error\n");
+							exit(1);
+						}
+
+						error =
+						    inet_pton(AF_INET, dnat_new_addr,
+							      &dnats[num_dnats].new_dst);
+						if(error <= 0) {
+							fprintf(stderr, "dnat effective destination address error\n");
+							exit(1);
+						}
+
+						if(dnat_orig_port[0]) {
+							dnats[num_dnats].orig_port =
+							    (short) atoi(dnat_orig_port);
+						} else {
+							dnats[num_dnats].orig_port = 0;
+						}
+
+						if(dnat_new_port[0]) {
+							dnats[num_dnats].new_port =
+							    (short) atoi(dnat_new_port);
+						} else {
+							dnats[num_dnats].new_port = 0;
+						}
+
+						PDEBUG("added dnat: orig-dst=%s orig-port=%d new-dst=%s new-port=%d\n", dnat_orig_addr, dnats[num_dnats].orig_port, dnat_new_addr, dnats[num_dnats].new_port);
+						++num_dnats;
+					} else {
+						fprintf(stderr, "# of dnat exceed %d.\n", MAX_DNAT);
+					}
 				}
 			}
 		}
@@ -308,17 +569,27 @@ static void get_chain_data(proxy_data * pd, unsigned int *proxy_count, chain_typ
 	}
 	*proxy_count = count;
 	proxychains_got_chain_data = 1;
+	PDEBUG("proxy_dns: %s\n", rdns_resolver_string(proxychains_resolver));
 }
 
 /*******  HOOK FUNCTIONS  *******/
 
-int close(int fd) {
+#define EXPAND( args...) args
+#ifdef MONTEREY_HOOKING
+#define HOOKFUNC(R, N, args...) R pxcng_ ## N ( EXPAND(args) )
+#else
+#define HOOKFUNC(R, N, args...) R N ( EXPAND(args) )
+#endif
+
+HOOKFUNC(int, close, int fd) {
 	if(!init_l) {
 		if(close_fds_cnt>=(sizeof close_fds/sizeof close_fds[0])) goto err;
 		close_fds[close_fds_cnt++] = fd;
 		errno = 0;
 		return 0;
 	}
+	if(proxychains_resolver != DNSLF_RDNS_THREAD) return true_close(fd);
+
 	/* prevent rude programs (like ssh) from closing our pipes */
 	if(fd != req_pipefd[0]  && fd != req_pipefd[1] &&
 	   fd != resp_pipefd[0] && fd != resp_pipefd[1]) {
@@ -329,10 +600,73 @@ int close(int fd) {
 	return -1;
 }
 static int is_v4inv6(const struct in6_addr *a) {
-	return a->s6_addr32[0] == 0 && a->s6_addr32[1] == 0 &&
+	return !memcmp(a->s6_addr, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
-	       a->s6_addr16[4] == 0 && a->s6_addr16[5] == 0xffff;
 }
-int connect(int sock, const struct sockaddr *addr, unsigned int len) {
+
+static void intsort(int *a, int n) {
+	int i, j, s;
+	for(i=0; i<n; ++i)
+		for(j=i+1; j<n; ++j)
+			if(a[j] < a[i]) {
+				s = a[i];
+				a[i] = a[j];
+				a[j] = s;
+			}
+}
+
+/* Warning: Linux manual says the third arg is `unsigned int`, but unistd.h says `int`. */
+HOOKFUNC(int, close_range, unsigned first, unsigned last, int flags) {
+	if(true_close_range == NULL) {
+		fprintf(stderr, "Calling close_range, but this platform does not provide this system call. ");
+		return -1;
+	}
+	if(!init_l) {
+		/* push back to cache, and delay the execution. */
+		if(close_range_buffer_cnt >= (sizeof close_range_buffer / sizeof close_range_buffer[0])) {
+			errno = ENOMEM;
+			return -1;
+		}
+		int i = close_range_buffer_cnt++;
+		close_range_buffer[i].first = first;
+		close_range_buffer[i].last = last;
+		close_range_buffer[i].flags = flags;
+		return errno = 0;
+	}
+	if(proxychains_resolver != DNSLF_RDNS_THREAD) return true_close_range(first, last, flags);
+
+	/* prevent rude programs (like ssh) from closing our pipes */
+	int res = 0, uerrno = 0, i;
+	int protected_fds[] = {req_pipefd[0], req_pipefd[1], resp_pipefd[0], resp_pipefd[1]};
+	intsort(protected_fds, 4);
+	/* We are skipping protected_fds while calling true_close_range()
+	 * If protected_fds cut the range into some sub-ranges, we close sub-ranges BEFORE cut point in the loop. 
+	 * [first, cut1-1] , [cut1+1, cut2-1] , [cut2+1, cut3-1]
+	 * Finally, we delete the remaining sub-range, outside the loop. [cut3+1, tail]
+	 */
+	int next_fd_to_close = first;
+	for(i = 0; i < 4; ++i) {
+		if(protected_fds[i] < first || protected_fds[i] > last)
+			continue;
+		int prev = (i == 0 || protected_fds[i-1] < first) ? first : protected_fds[i-1]+1;
+		if(prev != protected_fds[i]) {
+			if(-1 == true_close_range(prev, protected_fds[i]-1, flags)) {
+				res = -1;
+				uerrno = errno;
+			}
+		}
+		next_fd_to_close = protected_fds[i]+1;
+	}
+	if(next_fd_to_close <= last) {
+		if(-1 == true_close_range(next_fd_to_close, last, flags)) {
+			res = -1;
+			uerrno = errno;
+		}
+	}
+	errno = uerrno;
+	return res;
+}
+
+HOOKFUNC(int, connect, int sock, const struct sockaddr *addr, unsigned int len) {
 	INIT();
 	PFUNC();
 
@@ -343,6 +677,7 @@ int connect(int sock, const struct sockaddr *addr, unsigned int len) {
 
 	struct in_addr *p_addr_in;
 	struct in6_addr *p_addr_in6;
+	dnat_arg *dnat = NULL;
 	unsigned short port;
 	size_t i;
 	int remote_dns_connect = 0;
@@ -360,10 +695,14 @@ int connect(int sock, const struct sockaddr *addr, unsigned int len) {
 	           : ntohs(((struct sockaddr_in6 *) addr)->sin6_port);
 	struct in_addr v4inv6;
 	if(v6 && is_v4inv6(p_addr_in6)) {
-		memcpy(&v4inv6.s_addr, &p_addr_in6->s6_addr32[3], 4);
+		memcpy(&v4inv6.s_addr, &p_addr_in6->s6_addr[12], 4);
 		v6 = dest_ip.is_v6 = 0;
 		p_addr_in = &v4inv6;
 	}
+	if(!v6 && !memcmp(p_addr_in, "\0\0\0\0", 4)) {
+		errno = ECONNREFUSED;
+		return -1;
+	}
 
 //      PDEBUG("localnet: %s; ", inet_ntop(AF_INET,&in_addr_localnet, str, sizeof(str)));
 //      PDEBUG("netmask: %s; " , inet_ntop(AF_INET, &in_addr_netmask, str, sizeof(str)));
@@ -373,14 +712,41 @@ int connect(int sock, const struct sockaddr *addr, unsigned int len) {
 	// check if connect called from proxydns
         remote_dns_connect = !v6 && (ntohl(p_addr_in->s_addr) >> 24 == remote_dns_subnet);
 
-	if (!v6) for(i = 0; i < num_localnet_addr && !remote_dns_connect; i++) {
+	// more specific first
-		if((localnet_addr[i].in_addr.s_addr & localnet_addr[i].netmask.s_addr)
+	if (!v6) for(i = 0; i < num_dnats && !remote_dns_connect && !dnat; i++)
-		   == (p_addr_in->s_addr & localnet_addr[i].netmask.s_addr)) {
+		if(dnats[i].orig_dst.s_addr == p_addr_in->s_addr)
-			if(!localnet_addr[i].port || localnet_addr[i].port == port) {
+			if(dnats[i].orig_port && (dnats[i].orig_port == port))
-				PDEBUG("accessing localnet using true_connect\n");
+				dnat = &dnats[i];
-				return true_connect(sock, addr, len);
+
-			}
+	if (!v6) for(i = 0; i < num_dnats && !remote_dns_connect && !dnat; i++)
+		if(dnats[i].orig_dst.s_addr == p_addr_in->s_addr)
+			if(!dnats[i].orig_port)
+				dnat = &dnats[i];
+
+	if (dnat) {
+		p_addr_in = &dnat->new_dst;
+		if (dnat->new_port)
+			port = dnat->new_port;
+	}
+
+	for(i = 0; i < num_localnet_addr && !remote_dns_connect; i++) {
+		if (localnet_addr[i].port && localnet_addr[i].port != port)
+			continue;
+		if (localnet_addr[i].family != (v6 ? AF_INET6 : AF_INET))
+			continue;
+		if (v6) {
+			size_t prefix_bytes = localnet_addr[i].in6_prefix / CHAR_BIT;
+			size_t prefix_bits = localnet_addr[i].in6_prefix % CHAR_BIT;
+			if (prefix_bytes && memcmp(p_addr_in6->s6_addr, localnet_addr[i].in6_addr.s6_addr, prefix_bytes) != 0)
+				continue;
+			if (prefix_bits && (p_addr_in6->s6_addr[prefix_bytes] ^ localnet_addr[i].in6_addr.s6_addr[prefix_bytes]) >> (CHAR_BIT - prefix_bits))
+				continue;
+		} else {
+			if((p_addr_in->s_addr ^ localnet_addr[i].in_addr.s_addr) & localnet_addr[i].in_mask.s_addr)
+				continue;
 		}
+		PDEBUG("accessing localnet using true_connect\n");
+		return true_connect(sock, addr, len);
 	}
 
 	flags = fcntl(sock, F_GETFL, 0);
@@ -400,47 +766,55 @@ int connect(int sock, const struct sockaddr *addr, unsigned int len) {
 	return ret;
 }
 
+#ifdef IS_SOLARIS
+HOOKFUNC(int, __xnet_connect, int sock, const struct sockaddr *addr, unsigned int len)
+	return connect(sock, addr, len);
+}
+#endif
+
 static struct gethostbyname_data ghbndata;
-struct hostent *gethostbyname(const char *name) {
+HOOKFUNC(struct hostent*, gethostbyname, const char *name) {
 	INIT();
 	PDEBUG("gethostbyname: %s\n", name);
 
-	if(proxychains_resolver)
+	if(proxychains_resolver == DNSLF_FORKEXEC)
-		return proxy_gethostbyname(name, &ghbndata);
+		return proxy_gethostbyname_old(name);
-	else
+	else if(proxychains_resolver == DNSLF_LIBC)
 		return true_gethostbyname(name);
+	else
+		return proxy_gethostbyname(name, &ghbndata);
 
 	return NULL;
 }
 
-int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
+HOOKFUNC(int, getaddrinfo, const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
 	INIT();
 	PDEBUG("getaddrinfo: %s %s\n", node ? node : "null", service ? service : "null");
 
-	if(proxychains_resolver)
+	if(proxychains_resolver != DNSLF_LIBC)
 		return proxy_getaddrinfo(node, service, hints, res);
 	else
 		return true_getaddrinfo(node, service, hints, res);
 }
 
-void freeaddrinfo(struct addrinfo *res) {
+HOOKFUNC(void, freeaddrinfo, struct addrinfo *res) {
 	INIT();
 	PDEBUG("freeaddrinfo %p \n", (void *) res);
 
-	if(!proxychains_resolver)
+	if(proxychains_resolver == DNSLF_LIBC)
 		true_freeaddrinfo(res);
 	else
 		proxy_freeaddrinfo(res);
 }
 
-int pc_getnameinfo(const struct sockaddr *sa, socklen_t salen,
+HOOKFUNC(int, getnameinfo, const struct sockaddr *sa, socklen_t salen,
-	           char *host, socklen_t hostlen, char *serv,
+	           char *host, GN_NODELEN_T hostlen, char *serv,
-	           socklen_t servlen, int flags)
+	           GN_SERVLEN_T servlen, GN_FLAGS_T flags)
 {
 	INIT();
 	PFUNC();
 
-	if(!proxychains_resolver) {
+	if(proxychains_resolver == DNSLF_LIBC) {
 		return true_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
 	} else {
 		if(!salen || !(SOCKFAMILY(*sa) == AF_INET || SOCKFAMILY(*sa) == AF_INET6))
@@ -455,7 +829,7 @@ int pc_getnameinfo(const struct sockaddr *sa, socklen_t salen,
 			unsigned scopeid = 0;
 			if(v6) {
 				if(is_v4inv6(&((struct sockaddr_in6*)sa)->sin6_addr)) {
-					memcpy(v4inv6buf, &((struct sockaddr_in6*)sa)->sin6_addr.s6_addr32[3], 4);
+					memcpy(v4inv6buf, &((struct sockaddr_in6*)sa)->sin6_addr.s6_addr[12], 4);
 					ip = v4inv6buf;
 					v6 = 0;
 				} else
@@ -477,7 +851,7 @@ int pc_getnameinfo(const struct sockaddr *sa, socklen_t salen,
 	return 0;
 }
 
-struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type) {
+HOOKFUNC(struct hostent*, gethostbyaddr, const void *addr, socklen_t len, int type) {
 	INIT();
 	PDEBUG("TODO: proper gethostbyaddr hook\n");
 
@@ -487,7 +861,7 @@ struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type) {
 	static char *aliases[1];
 	static struct hostent he;
 
-	if(!proxychains_resolver)
+	if(proxychains_resolver == DNSLF_LIBC)
 		return true_gethostbyaddr(addr, len, type);
 	else {
 
@@ -513,7 +887,7 @@ struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type) {
 #   define MSG_FASTOPEN 0x20000000
 #endif
 
-ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
+HOOKFUNC(ssize_t, sendto, int sockfd, const void *buf, size_t len, int flags,
 	       const struct sockaddr *dest_addr, socklen_t addrlen) {
 	INIT();
 	PFUNC();
@@ -527,3 +901,45 @@ ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
 	}
 	return true_sendto(sockfd, buf, len, flags, dest_addr, addrlen);
 }
+
+#ifdef MONTEREY_HOOKING
+#define SETUP_SYM(X) do { if (! true_ ## X ) true_ ## X = &X; } while(0)
+#define SETUP_SYM_OPTIONAL(X)
+#else
+#define SETUP_SYM_IMPL(X, IS_MANDATORY) do { if (! true_ ## X ) true_ ## X = load_sym( # X, X, IS_MANDATORY ); } while(0)
+#define SETUP_SYM(X) SETUP_SYM_IMPL(X, 1)
+#define SETUP_SYM_OPTIONAL(X) SETUP_SYM_IMPL(X, 0)
+#endif
+
+static void setup_hooks(void) {
+	SETUP_SYM(connect);
+	SETUP_SYM(sendto);
+	SETUP_SYM(gethostbyname);
+	SETUP_SYM(getaddrinfo);
+	SETUP_SYM(freeaddrinfo);
+	SETUP_SYM(gethostbyaddr);
+	SETUP_SYM(getnameinfo);
+#ifdef IS_SOLARIS
+	SETUP_SYM(__xnet_connect);
+#endif
+	SETUP_SYM(close);
+	SETUP_SYM_OPTIONAL(close_range);
+}
+
+#ifdef MONTEREY_HOOKING
+
+#define DYLD_INTERPOSE(_replacement,_replacee) \
+   __attribute__((used)) static struct{ const void* replacement; const void* replacee; } _interpose_##_replacee \
+   __attribute__((section ("__DATA,__interpose"))) = { (const void*)(unsigned long)&_replacement, (const void*)(unsigned long)&_replacee };
+#define DYLD_HOOK(F) DYLD_INTERPOSE(pxcng_ ## F, F)
+
+DYLD_HOOK(connect);
+DYLD_HOOK(sendto);
+DYLD_HOOK(gethostbyname);
+DYLD_HOOK(getaddrinfo);
+DYLD_HOOK(freeaddrinfo);
+DYLD_HOOK(gethostbyaddr);
+DYLD_HOOK(getnameinfo);
+DYLD_HOOK(close);
+
+#endif

src/main.c

@@ -7,10 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-#undef _POSIX_C_SOURCE
+#define _DEFAULT_SOURCE
-#define _POSIX_C_SOURCE 200809L
-#undef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 700
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
@@ -19,6 +16,11 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
+#ifdef IS_MAC
+#define _DARWIN_C_SOURCE
+#endif
+#include <dlfcn.h>
+
 #include "common.h"
 
 static int usage(char **argv) {
@@ -49,7 +51,7 @@ static void set_own_dir(const char *argv0) {
 	size_t l = strlen(argv0);
 	while(l && argv0[l - 1] != '/')
 		l--;
-	if(l == 0)
+	if(l == 0 || l >= sizeof(own_dir))
 #ifdef SUPER_SECURE
 		memcpy(own_dir, "/dev/null/", 11);
 #else
@@ -72,6 +74,9 @@ int main(int argc, char *argv[]) {
 	size_t i;
 	const char *prefix = NULL;
 
+	if(argc == 2 && !strcmp(argv[1], "--help"))
+		return usage(argv);
+
 	for(i = 0; i < MAX_COMMANDLINE_FLAGS; i++) {
 		if(start_argv < argc && argv[start_argv][0] == '-') {
 			if(argv[start_argv][1] == 'q') {
@@ -108,7 +113,9 @@ int main(int argc, char *argv[]) {
 
 	// search DLL
 
-	set_own_dir(argv[0]);
+	Dl_info dli;
+	dladdr(own_dir, &dli);
+	set_own_dir(dli.dli_fname);
 
 	i = 0;
 
@@ -128,16 +135,20 @@ int main(int argc, char *argv[]) {
 	if(!quiet)
 		fprintf(stderr, LOG_PREFIX "preloading %s/%s\n", prefix, dll_name);
 
+#if defined(IS_MAC) || defined(IS_OPENBSD)
+#define LD_PRELOAD_SEP ":"
+#else
+/* Dynlinkers for Linux and most BSDs seem to support space
+   as LD_PRELOAD separator, with colon added only recently.
+   We use the old syntax for maximum compat */
+#define LD_PRELOAD_SEP " "
+#endif
+
 #ifdef IS_MAC
 	putenv("DYLD_FORCE_FLAT_NAMESPACE=1");
 #define LD_PRELOAD_ENV "DYLD_INSERT_LIBRARIES"
-#define LD_PRELOAD_SEP ":"
 #else
 #define LD_PRELOAD_ENV "LD_PRELOAD"
-/* all historic implementations of BSD and linux dynlinkers seem to support
-   space as LD_PRELOAD separator, with colon added only recently.
-   we use the old syntax for maximum compat */
-#define LD_PRELOAD_SEP " "
 #endif
 	char *old_val = getenv(LD_PRELOAD_ENV);
 	snprintf(buf, sizeof(buf), LD_PRELOAD_ENV "=%s/%s%s%s",
@@ -147,7 +158,8 @@ int main(int argc, char *argv[]) {
 	         old_val ? old_val : "");
 	putenv(buf);
 	execvp(argv[start_argv], &argv[start_argv]);
-	perror("proxychains can't load process....");
+	fprintf(stderr, "proxychains: can't load process '%s'.", argv[start_argv]);
+	perror(" (hint: it's probably a typo)");
 
 	return EXIT_FAILURE;
 }

src/nameinfo.c

@@ -1,13 +0,0 @@
-#include <sys/socket.h>
-
-extern int pc_getnameinfo(const void *sa, socklen_t salen, 
-                   char *host, socklen_t hostlen, char *serv, 
-                   socklen_t servlen, int flags);
-
-
-int getnameinfo(const void *sa, socklen_t salen, 
-                   char *host, socklen_t hostlen, char *serv, 
-                   socklen_t servlen, int flags) {
-	return pc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
-}
-

src/proxychains.conf

@@ -48,9 +48,33 @@ strict_chain
 # Quiet mode (no output from library)
 #quiet_mode
 
-# Proxy DNS requests - no leak for DNS data
+## Proxy DNS requests - no leak for DNS data
+# (disable all of the 3 items below to not proxy your DNS requests)
+
+# method 1. this uses the proxychains4 style method to do remote dns:
+# a thread is spawned that serves DNS requests and hands down an ip
+# assigned from an internal list (via remote_dns_subnet).
+# this is the easiest (setup-wise) and fastest method, however on
+# systems with buggy libcs and very complex software like webbrowsers
+# this might not work and/or cause crashes.
 proxy_dns
 
+# method 2. use the old proxyresolv script to proxy DNS requests
+# in proxychains 3.1 style. requires `proxyresolv` in $PATH
+# plus a dynamically linked `dig` binary.
+# this is a lot slower than `proxy_dns`, doesn't support .onion URLs,
+# but might be more compatible with complex software like webbrowsers.
+#proxy_dns_old
+
+# method 3. use proxychains4-daemon process to serve remote DNS requests.
+# this is similar to the threaded `proxy_dns` method, however it requires
+# that proxychains4-daemon is already running on the specified address.
+# on the plus side it doesn't do malloc/threads so it should be quite
+# compatible with complex, async-unsafe software.
+# note that if you don't start proxychains4-daemon before using this,
+# the process will simply hang.
+#proxy_dns_daemon 127.0.0.1:1053
+
 # set the class A subnet number to use for the internal remote DNS mapping
 # we use the reserved 224.x.x.x range by default,
 # if the proxified app does a DNS request, we will return an IP from that range.
@@ -70,6 +94,9 @@ tcp_connect_time_out 8000
 
 ### Examples for localnet exclusion
 ## localnet ranges will *not* use a proxy to connect.
+## note that localnet works only when plain IP addresses are passed to the app,
+## the hostname resolves via /etc/hosts, or proxy_dns is disabled or proxy_dns_old used.
+
 ## Exclude connections to 192.168.1.0/24 with port 80
 # localnet 192.168.1.0:80/255.255.255.0
 
@@ -78,18 +105,36 @@ tcp_connect_time_out 8000
 
 ## Exclude connections to ANYwhere with port 80
 # localnet 0.0.0.0:80/0.0.0.0
+# localnet [::]:80/0
 
-## RFC5735 Loopback address range
+## RFC6890 Loopback address range
 ## if you enable this, you have to make sure remote_dns_subnet is not 127
 ## you'll need to enable it if you want to use an application that 
 ## connects to localhost.
 # localnet 127.0.0.0/255.0.0.0
+# localnet ::1/128
 
 ## RFC1918 Private Address Ranges
 # localnet 10.0.0.0/255.0.0.0
 # localnet 172.16.0.0/255.240.0.0
 # localnet 192.168.0.0/255.255.0.0
 
+### Examples for dnat
+## Trying to proxy connections to destinations which are dnatted,
+## will result in proxying connections to the new given destinations.
+## Whenever I connect to 1.1.1.1 on port 1234 actually connect to 1.1.1.2 on port 443
+# dnat 1.1.1.1:1234  1.1.1.2:443
+
+## Whenever I connect to 1.1.1.1 on port 443 actually connect to 1.1.1.2 on port 443
+## (no need to write :443 again)
+# dnat 1.1.1.2:443  1.1.1.2
+
+## No matter what port I connect to on 1.1.1.1 port actually connect to 1.1.1.2 on port 443
+# dnat 1.1.1.1  1.1.1.2:443
+
+## Always, instead of connecting to 1.1.1.1, connect to 1.1.1.2
+# dnat 1.1.1.1  1.1.1.2
+
 # ProxyList format
 #       type  ip  port [user pass]
 #       (values separated by 'tab' or 'blank')
@@ -105,7 +150,8 @@ tcp_connect_time_out 8000
 #	        http	192.168.39.93	8080	
 #		
 #
-#       proxy types: http, socks4, socks5
+#       proxy types: http, socks4, socks5, raw
+#         * raw: The traffic is simply forwarded to the proxy without modification.
 #        ( auth types supported: "basic"-http  "user/pass"-socks )
 #
 [ProxyList]

src/proxyresolv

@@ -1,10 +1,8 @@
 #!/bin/sh
-# This is a legacy script that uses "dig" to do DNS lookups via TCP.
+# This is a legacy script that uses "dig" or "drill" to do DNS lookups via TCP.
-# it is not actively maintained since proxychains no longer depends
-# on it. i leave it here as a bonus.
 
 # DNS server used to resolve names
-DNS_SERVER=8.8.8.8
+test -z "$DNS_SERVER" && DNS_SERVER=8.8.8.8
 
 
 if [ $# = 0 ] ; then
@@ -14,5 +12,12 @@ if [ $# = 0 ] ; then
 fi
 
 
-export LD_PRELOAD=libproxychains4.so
+test -z $LD_PRELOAD && export LD_PRELOAD=libproxychains4.so
-dig $1 @$DNS_SERVER +tcp | awk '/A.?[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
+
+if type dig 1>/dev/null 2>&1 ; then
+dig       $1 @$DNS_SERVER +tcp | awk '/A.?[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
+elif type drill 1>/dev/null 2>&1 ; then
+drill -t4 $1 @$DNS_SERVER      | awk '/A.+[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
+else
+echo "error: neither dig nor drill found" >&2
+fi

src/rdns.c

@@ -0,0 +1,99 @@
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rdns.h"
+#include "allocator_thread.h"
+#include "remotedns.h"
+
+#ifndef HAVE_SOCK_CLOEXEC
+#define SOCK_CLOEXEC 0
+#endif
+
+//static enum dns_lookup_flavor dns_flavor;
+#define dns_flavor rdns_get_flavor()
+
+static struct sockaddr_in rdns_server;
+
+size_t rdns_daemon_get_host_for_ip(ip_type4 ip, char* readbuf) {
+	struct at_msg msg = {
+		.h.msgtype = ATM_GETNAME,
+		.h.datalen = htons(4),
+		.m.ip = ip,
+	};
+	int fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
+	sendto(fd, &msg, sizeof(msg.h)+4, 0, (void*)&rdns_server, sizeof(rdns_server));
+	recvfrom(fd, &msg, sizeof msg, 0, (void*)0, (void*)0);
+	close(fd);
+	msg.h.datalen = ntohs(msg.h.datalen);
+	if(!msg.h.datalen || msg.h.datalen > 256) return 0;
+	memcpy(readbuf, msg.m.host, msg.h.datalen);
+	return msg.h.datalen - 1;
+}
+
+static ip_type4 rdns_daemon_get_ip_for_host(char* host, size_t len) {
+	struct at_msg msg = {
+		.h.msgtype = ATM_GETIP,
+	};
+	if(len >= 256) return IPT4_INT(-1);
+	memcpy(msg.m.host, host, len+1);
+	msg.h.datalen = htons(len+1);
+	int fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
+	sendto(fd, &msg, sizeof(msg.h)+len+1, 0, (void*)&rdns_server, sizeof(rdns_server));
+	recvfrom(fd, &msg, sizeof msg, 0, (void*)0, (void*)0);
+	close(fd);
+	if(ntohs(msg.h.datalen) != 4) return IPT4_INT(-1);
+	return msg.m.ip;
+}
+
+const char *rdns_resolver_string(enum dns_lookup_flavor flavor) {
+	static const char tab[][7] = {
+		[DNSLF_LIBC] = "off",
+		[DNSLF_FORKEXEC] = "old",
+		[DNSLF_RDNS_THREAD] = "thread",
+		[DNSLF_RDNS_DAEMON] = "daemon",
+	};
+	return tab[flavor];
+}
+
+void rdns_init(enum dns_lookup_flavor flavor) {
+	static int init_done = 0;
+	if(!init_done) switch(flavor) {
+		case DNSLF_RDNS_THREAD:
+			at_init();
+			break;
+		case DNSLF_RDNS_DAEMON:
+		default:
+			break;
+	}
+	init_done = 1;
+}
+
+void rdns_set_daemon(struct sockaddr_in* addr) {
+	rdns_server = *addr;
+}
+
+#if 0
+enum dns_lookup_flavor rdns_get_flavor(void) {
+	return dns_flavor;
+}
+#endif
+
+size_t rdns_get_host_for_ip(ip_type4 ip, char* readbuf) {
+	switch(dns_flavor) {
+		case DNSLF_RDNS_THREAD: return at_get_host_for_ip(ip, readbuf);
+		case DNSLF_RDNS_DAEMON: return rdns_daemon_get_host_for_ip(ip, readbuf);
+		default:
+			abort();
+	}
+}
+
+ip_type4 rdns_get_ip_for_host(char* host, size_t len) {
+	switch(dns_flavor) {
+		case DNSLF_RDNS_THREAD: return at_get_ip_for_host(host, len);
+		case DNSLF_RDNS_DAEMON: return rdns_daemon_get_ip_for_host(host, len);
+		default:
+			abort();
+	}
+}
+

src/rdns.h

@@ -0,0 +1,28 @@
+#ifndef RDNS_H
+#define RDNS_H
+
+#include <unistd.h>
+#include <netinet/in.h>
+#include "ip_type.h"
+#include "remotedns.h"
+
+enum dns_lookup_flavor {
+	DNSLF_LIBC = 0,
+	DNSLF_FORKEXEC,
+
+	DNSLF_RDNS_START,
+	DNSLF_RDNS_THREAD = DNSLF_RDNS_START,
+	DNSLF_RDNS_DAEMON,
+};
+
+void rdns_init(enum dns_lookup_flavor flavor);
+void rdns_set_daemon(struct sockaddr_in* addr);
+const char *rdns_resolver_string(enum dns_lookup_flavor flavor);
+size_t rdns_get_host_for_ip(ip_type4 ip, char* readbuf);
+ip_type4 rdns_get_ip_for_host(char* host, size_t len);
+
+//enum dns_lookup_flavor rdns_get_flavor(void);
+#define rdns_get_flavor() proxychains_resolver
+extern enum dns_lookup_flavor proxychains_resolver;
+
+#endif

src/remotedns.h

@@ -0,0 +1,31 @@
+#ifndef REMOTEDNS_H
+#define REMOTEDNS_H
+
+#include <unistd.h>
+#include "ip_type.h"
+
+#define MSG_LEN_MAX 256
+
+enum at_msgtype {
+	ATM_GETIP = 0,
+	ATM_GETNAME,
+	ATM_FAIL,
+	ATM_EXIT,
+};
+
+struct at_msghdr {
+	unsigned char msgtype; /* at_msgtype */
+	char reserved;
+	unsigned short datalen;
+};
+
+struct at_msg {
+	struct at_msghdr h;
+	union {
+		char host[260];
+		ip_type4 ip;
+	} m;
+};
+
+#endif
+

tests/test_getaddrinfo.c

@@ -3,18 +3,20 @@
 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
+#include <assert.h>
+#include <string.h>
 
 #ifndef   NI_MAXHOST
 #define   NI_MAXHOST 1025
 #endif
 
-int main(void) {
+static int doit(const char* host, const char* service) {
 	struct addrinfo *result;
 	struct addrinfo *res;
 	int error;
 
 	/* resolve the domain name into a list of addresses */
-	error = getaddrinfo("www.example.com", NULL, NULL, &result);
+	error = getaddrinfo(host, service, NULL, &result);
 	if (error != 0)
 	{
 		fprintf(stderr, "error in getaddrinfo: %s\n", gai_strerror(error));
@@ -32,10 +34,53 @@ int main(void) {
 		fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(error));
 		continue;
 		}
-		if (*hostname != '\0')
+		int port = 0;
-		printf("hostname: %s\n", hostname);
+		if(res->ai_family == AF_INET) port = ((struct sockaddr_in*)res->ai_addr)->sin_port;
+		else if(res->ai_family == AF_INET6) port = ((struct sockaddr_in6*)res->ai_addr)->sin6_port;
+		port = ntohs(port);
+		printf("hostname: %s, port: %d\n", hostname, port);
 	}
 
 	freeaddrinfo(result);
 	return EXIT_SUCCESS;
 }
+
+/* reproduce use of getaddrinfo as used by nmap 7.91's canonicalize_address */
+int canonicalize_address(struct sockaddr_storage *ss, struct sockaddr_storage *output) {
+	char canonical_ip_string[NI_MAXHOST];
+	struct addrinfo *ai;
+	int rc;
+	/* Convert address to string. */
+	rc = getnameinfo((struct sockaddr *) ss, sizeof(*ss),
+		canonical_ip_string, sizeof(canonical_ip_string), NULL, 0, NI_NUMERICHOST);
+	assert(rc == 0);
+	struct addrinfo hints = {
+		.ai_family = ss->ss_family,
+		.ai_socktype = SOCK_DGRAM,
+		.ai_flags = AI_NUMERICHOST,
+	};
+	rc = getaddrinfo(canonical_ip_string, NULL, &hints, &ai);
+	if (rc != 0 || ai == NULL)
+		return -1;
+	assert(ai->ai_addrlen > 0 && ai->ai_addrlen <= (int) sizeof(*output));
+	memcpy(output, ai->ai_addr, ai->ai_addrlen);
+	freeaddrinfo(ai);
+	return 0;
+}
+
+int main(void) {
+	int ret;
+	ret = doit("www.example.com", NULL);
+	ret = doit("www.example.com", "80");
+	struct sockaddr_storage o, ss = {.ss_family = PF_INET};
+	struct sockaddr_in *v4 = &ss;
+	struct sockaddr_in6 *v6 = &ss;
+	memcpy(&v4->sin_addr, "\x7f\0\0\1", 4);
+	ret = canonicalize_address(&ss, &o);
+	assert (ret == 0);
+	ss.ss_family = PF_INET6;
+	memcpy(&v6->sin6_addr, "\0\0\0\0" "\0\0\0\0" "\0\0\0\0""\0\0\0\1", 16);
+	ret = canonicalize_address(&ss, &o);
+	assert (ret == 0);
+	return ret;
+}

tests/test_gethostbyname.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <netdb.h>
+#include "../src/common.c"
+
+void printhostent(struct hostent *hp) {
+	char ipbuf[16];
+	pc_stringfromipv4(hp->h_addr_list[0], ipbuf);
+	printf("alias: %p, len: %d, name: %s, addrlist: %p, addrtype: %d, ip: %s\n", 
+		hp->h_aliases, 
+		hp->h_length,
+		hp->h_name,
+		hp->h_addr_list,
+		hp->h_addrtype,
+		ipbuf
+	);
+}
+int main(int argc, char**argv) {
+	struct hostent* ret;
+	if(argc == 1) return 1;
+	ret = gethostbyname(argv[1]);
+	if(ret) printhostent(ret);
+	return 0;
+}

tests/test_gethostent.c

@@ -1,6 +1,6 @@
 #include <netdb.h>
 #include <stdio.h>
-#include "../src/common.h"
+#include "../src/common.c"
 
 void printhostent(struct hostent *hp) {
 	char ipbuf[16];

tests/test_getnameinfo.c

@@ -123,5 +123,17 @@ int main() {
 
 	ASSERT(ret == 0);
 
+	b.sin6_port = 0;
+	b.sin6_scope_id = 0;
+	memcpy(&b.sin6_addr,"\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\1", 16);
+
+	if ((ret = getnameinfo((void*)sb, sizeof b, hbuf, sizeof(hbuf), NULL,
+	    0, NI_NUMERICHOST)) == 0)
+		printf("host=%s\n", hbuf);
+	else
+		printf("%s\n", gai_strerror(ret));
+
+	ASSERT(ret == 0);
+
 	return 0;
 }