Attachment #162043 for bug #183457




#!/bin/bash

typeset -i test_num=0 # increments w/each test_define
typeset test_msg	# prefix: "test nr#"  for msgs
typeset test_name	# test name given	
typeset test_sanename	# test name with all whitespace (and alike) replaced by '_'

TEST_CLEANUP=":"

say () {
	echo "$@" >&3
}
err () {
	echo "$@" >&4
}
debug () {
	echo "$@" >&4
}
test_define() {
	test_name="$*"
	test_sanename="$(echo -n $test_name| tr -c '[A-Za-z0-9._]' _ )"
	test_num=test_num+1
	test_msg="test $test_num"
	test_bg_cleanup 
}
test_expect_success () {
	local msg="$1" 
	test $# -ge 2 || { err "usage error: test_expect_failure msg cmd args ..."; return 1; }
	say -n "$test_msg: -- $msg (expecting success) "
	shift
	(eval "$@" 4>&1) && { say -e "\n$test_msg: OK %%% $test_sanename" ;  return 0 ; }
	say -e "\n$test_msg: FAILED %%% $test_sanename" 
	return 1
}

test_expect_failure () {
	local msg="$1" 
	test $# -ge 2 || { err "usage error: test_expect_failure msg cmd args ...";  return 1;}
	say -n "$test_msg: -- $msg (expecting failure) "
	shift
	(eval "$@") && { say -e "\n$test_msg: FAILED %%% $test_sanename" >&3 ;  return 0 ; }
	say -e "\n$test_msg: OK %%% $test_sanename"
	return 1
}

test_bg_egrep() {
	local nsecs="$1"
	local txt="$2"
	local ret
	shift 2
	test_expect_success "$test_name" \
		"set -m ; $@ &> $t/out-$test_sanename &
		s=1;
		for i in \$(seq 1 $nsecs);do 
			say -n '.'
			kill -0 %1 || { egrep failed $t/out-$test_sanename >&4; break; }
			o=\$(egrep \"$txt\" $t/out-$test_sanename ) && { debug \$o; s=0; break; }
			sleep 1;
		done;
		kill %1
		wait
		exit \$s
		" 2>/dev/null 4>$t/err
	ret=$?
	test $ret -eq 0 && return 0
	say "$test_msg: see: $t/out-$test_sanename*" 
	return $ret
}
# run command in *current* shell ignoring stderr, evals args passed
quiet2() {
	#backup fd=2
	exec 250>&2
	exec 2>/dev/null
	eval "$@"
	#close auxfd
	exec 2>&250
	exec 250>&-
}
test_bg_prev(){ local out=$t/out-$test_sanename-prev; $@ >& $out & }
test_bg_cleanup() { quiet2 "$TEST_CLEANUP;${@:-:};kill % 2>/dev/null;wait" ;}
test_set_cleanup () { TEST_CLEANUP="${*:-:}" ;}

t=/tmp
exec 3>&1
exec 4>&2

#=========

ln -sf $PWD/openvpn $t/openvpn-test
export OPENVPN=$t/openvpn-test

test_set_cleanup "killall $OPENVPN"

trap 'test_bg_cleanup;exit' 0 2 15

test_define "UDP6 loopback"
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp6-0-loopback-self.sh

test_define "UDP6 loopback byname"
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp6-0-loopback-byname.sh

test_define "TCP6 loopback"
test_bg_prev ../jjo-tests/run-tcp6-0-loopback-server.sh
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp6-0-loopback-client.sh

test_define "TCP6 loopback byname"
test_bg_prev ../jjo-tests/run-tcp6-0-loopback-server-byname.sh
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp6-0-loopback-client-byname.sh

test_define "UDP4 loopback"
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp4-0-loopback-self.sh

test_define "TCP4 loopback"
test_bg_prev ../jjo-tests/run-tcp4-0-loopback-server.sh 
test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp4-0-loopback-client.sh

Line 0 Link Here

(-)a/jjo-tests/qemu-ifup-2.jjo.sh (+12 lines)
	1	#!/bin/sh -x
	2	#sudo sh -c "/sbin/ifconfig $1 hw ether 00:00:00:00:00:01; /sbin/ifconfig $1 192.168.254.1"
	3	export PATH=/sbin:/usr/sbin:$PATH
	4	NUM=2
	5	DEV=qemutun$NUM
	6	sudo sh -x <<EOF
	7	ip li set $1 name $DEV
	8	ip li set $DEV address 00:00:00:00:00:01
	9	ip li set $DEV up
	10	ip ad add 192.168.254.1 dev $DEV
	11	ip ro add 192.168.254.$NUM dev $DEV
	12	EOF

Line 0 Link Here

(-)a/jjo-tests/qemu-ifup-3.jjo.sh (+12 lines)
	1	#!/bin/sh -x
	2	#sudo sh -c "/sbin/ifconfig $1 hw ether 00:00:00:00:00:01; /sbin/ifconfig $1 192.168.254.1"
	3	export PATH=/sbin:/usr/sbin:$PATH
	4	NUM=3
	5	DEV=qemutun$NUM
	6	sudo sh -x <<EOF
	7	ip li set $1 name $DEV
	8	ip li set $DEV address 00:00:00:00:00:01
	9	ip li set $DEV up
	10	ip ad add 192.168.254.1 dev $DEV
	11	ip ro add 192.168.254.$NUM dev $DEV
	12	EOF

Line 0 Link Here

(-)a/jjo-tests/run-afunix-0-loop.sh (+4 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	rm -fv /tmp/o.s
	4	${OPENVPN} --proto unix-dgram --local /tmp/o.s --remote /tmp/o.s --dev tun --ifconfig 1.1.1.1 1.1.1.2 --secret ../openvpn.key $*

Line 0 Link Here

(-)a/jjo-tests/run-afunix-1-o1.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --proto unix-dgram --local /tmp/o1.s --remote /tmp/o2.s --dev tun --ifconfig 1.1.1.1 1.1.1.2 --secret ../openvpn.key $*

Line 0 Link Here

(-)a/jjo-tests/run-afunix-1-o2.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --proto unix-dgram --local /tmp/o2.s --remote /tmp/o1.s --dev tun --ifconfig 1.1.1.2 1.1.1.1 --secret ../openvpn.key $*

Line 0 Link Here

(-)a/jjo-tests/run-oxg-1.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev tun --proto udp --remote localhost --lport 5020 --rport 1194 --secret ../openvpn.key --ifconfig 1.1.1.1 1.1.1.2 "$@"

Line 0 Link Here

(-)a/jjo-tests/run-oxg-2.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev tun --proto udp --remote localhost --lport 5020 --rport 1194 --secret ../openvpn.key --ifconfig 1.1.1.2 1.1.1.1 "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp4-0-loopback-client.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp-client --remote localhost --rport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp4-0-loopback-server.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp-server --remote localhost --lport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp6-0-loopback-client-byname.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp6-client --remote ip6-localhost --rport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp6-0-loopback-client.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp6-client --remote ::1 --rport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp6-0-loopback-server-byname.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp6-server --local ip6-localhost --lport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-tcp6-0-loopback-server.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${OPENVPN} --dev null --proto tcp6-server --local :: --lport 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-udp4-0-loopback-self.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --dev null --proto udp --remote localhost --port 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-udp4-1-qemu-guest.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --dev tun --proto udp --remote 10.0.2.2 --port 5011 --secret ../openvpn.key --ifconfig 1.1.1.253 1.1.1.1

Line 0 Link Here

(-)a/jjo-tests/run-udp4-1-qemu-host.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --dev tun --proto udp --float --port 5011 --secret ../openvpn.key --ifconfig 1.1.1.1 1.1.1.253

Line 0 Link Here

(-)a/jjo-tests/run-udp4-2-MH.sh (+4 lines)
	1	#!/bin/sh -x
	2	#pass --local ADDR --remote ADDR
	3	: ${OPENVPN:=./openvpn}
	4	${GDB} ${OPENVPN} --dev tun --proto udp --port 5011 --secret ../openvpn.key --ifconfig-noexec "$@"

Line 0 Link Here

(-)a/jjo-tests/run-udp6-0-loopback-byname.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --dev null --proto udp6 --remote ip6-localhost --port 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-udp6-0-loopback-self.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --dev null --proto udp6 --remote ::1 --port 5011 --secret ../openvpn.key "$@"

Line 0 Link Here

(-)a/jjo-tests/run-udp6-1-carpediem.sh (+4 lines)
	1	#!/bin/sh -x
	2	REM6="fe80::2e0:7dff:fee3:ef17"
	3	: ${OPENVPN:=./openvpn}
	4	${GDB} ${OPENVPN} --dev tun --proto udp6 --remote "$REM6" --port 5010 --secret ../openvpn.key --ifconfig 1.1.1.253 1.1.1.1

Line 0 Link Here

(-)a/jjo-tests/run-udp6-1-cx.sh (+3 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	${GDB} ${OPENVPN} --verb 5 --dev tun --proto udp6 --port 5010 --secret /home/jjo/src/juanjo/openvpn.key --float --ifconfig 1.1.1.1 1.1.1.253

Line 0 Link Here

(-)a/jjo-tests/run-udp6-2-qemu-guest.sh (+8 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	case "$1" in
	4	--freebsd) shift;set -- ed0 "$@";;
	5	--openbsd) shift;set -- ne3 --dev tun0 "$@";;
	6	esac
	7	DEV=${1:?missing devname};shift
	8	${GDB} ${OPENVPN} --dev tun --proto udp6 --remote fe80::200:ff:fe00:1%$DEV --port 5010 --secret ../openvpn.key "$@" --ifconfig 1.1.1.253 1.1.1.1

Line 0 Link Here

(-)a/jjo-tests/run-udp6-2-qemu-host.sh (+4 lines)
	1	#!/bin/sh -x
	2	: ${OPENVPN:=./openvpn}
	3	DEV=${1:?missing devname};shift
	4	${GDB} ${OPENVPN} --dev tun --proto udp6 --remote fe80::5054:ff:fe12:3456%$DEV --port 5010 --secret ../openvpn.key --ifconfig 1.1.1.1 1.1.1.253 "$@"




  return ret;
}

void buf_puts(struct buffer *buf, const char *str)
{
  uint8_t *ptr = BEND (buf);
  int cap = buf_forward_capacity (buf);
  if (cap > 0)
    {
      strncpynt ((char *)ptr,str, cap);
      *(buf->data + buf->capacity - 1) = 0; /* windows vsnprintf needs this */
      buf->len += (int) strlen ((char *)ptr);
    }
}
 

/*
 * This is necessary due to certain buggy implementations of snprintf,
 * that don't guarantee null termination for size > 0.

Lines 135-140 [MULTIHOME="$enableval"], Link Here

(-)a/configure.ac (+16 lines)
135	[MULTIHOME="yes"]	135	[MULTIHOME="yes"]
136	)	136	)
137		137
		138	AC_ARG_ENABLE(ipv6,
		139	[ --disable-ipv6 Disable UDP/IPv6 support],
		140	[PF_INET6="$enableval"],
		141	[PF_INET6="yes"]
		142	)
		143
138	AC_ARG_ENABLE(port-share,	144	AC_ARG_ENABLE(port-share,
139	[ --disable-port-share Disable TCP server port-share support (--port-share)],	145	[ --disable-port-share Disable TCP server port-share support (--port-share)],
140	[PORT_SHARE="$enableval"],	146	[PORT_SHARE="$enableval"],
Lines 524-529 LDFLAGS="$LDFLAGS -Wl,--fatal-warnings" Link Here
524	AC_CHECK_FUNC(epoll_create, AC_DEFINE(HAVE_EPOLL_CREATE, 1, [epoll_create function is defined]))	530	AC_CHECK_FUNC(epoll_create, AC_DEFINE(HAVE_EPOLL_CREATE, 1, [epoll_create function is defined]))
525	LDFLAGS="$OLDLDFLAGS"	531	LDFLAGS="$OLDLDFLAGS"
526		532
		533	dnl ipv6 support
		534	if test "$PF_INET6" = "yes"; then
		535	AC_CHECKING([for struct sockaddr_in6 for IPv6 support])
		536	AC_CHECK_TYPE(
		537	[struct sockaddr_in6],
		538	[AC_DEFINE(USE_PF_INET6, 1, [struct sockaddr_in6 is needed for IPv6 peer support])],
		539	[],
		540	[#include "syshead.h"])
		541	fi
		542
527	dnl	543	dnl
528	dnl check for valgrind tool	544	dnl check for valgrind tool
529	dnl	545	dnl

Lines 884-890 #ifdef ENABLE_MANAGEMENT Link Here

(-)a/init.c (-15 / +18 lines)
884	const char *detail = "SUCCESS";	884	const char *detail = "SUCCESS";
885	if (c->c1.tuntap)	885	if (c->c1.tuntap)
886	tun_local = c->c1.tuntap->local;	886	tun_local = c->c1.tuntap->local;
887	tun_remote = htonl (c->c1.link_socket_addr.actual.dest.sa.sin_addr.s_addr);	887	tun_remote = htonl (c->c1.link_socket_addr.actual.dest.addr.in4.sin_addr.s_addr);
888	if (flags & ISC_ERRORS)	888	if (flags & ISC_ERRORS)
889	detail = "ERROR";	889	detail = "ERROR";
890	management_set_state (management,	890	management_set_state (management,
Lines 1289-1295 do_deferred_options (struct context *c, Link Here
1289	#ifdef ENABLE_OCC	1289	#ifdef ENABLE_OCC
1290	if (found & OPT_P_EXPLICIT_NOTIFY)	1290	if (found & OPT_P_EXPLICIT_NOTIFY)
1291	{	1291	{
1292	if (c->options.ce.proto != PROTO_UDPv4 && c->options.explicit_exit_notification)	1292	if (!proto_is_udp(c->options.ce.proto) && c->options.explicit_exit_notification)
1293	{	1293	{
1294	msg (D_PUSH, "OPTIONS IMPORT: --explicit-exit-notify can only be used with --proto udp");	1294	msg (D_PUSH, "OPTIONS IMPORT: --explicit-exit-notify can only be used with --proto udp");
1295	c->options.explicit_exit_notification = 0;	1295	c->options.explicit_exit_notification = 0;
Lines 1384-1395 #endif Link Here
1384	switch (c->options.ce.proto)	1384	switch (c->options.ce.proto)
1385	{	1385	{
1386	case PROTO_UDPv4:	1386	case PROTO_UDPv4:
		1387	#ifdef USE_PF_INET6
		1388	case PROTO_UDPv6:
		1389	#endif
1387	if (proxy)	1390	if (proxy)
1388	sec = c->options.ce.connect_retry_seconds;	1391	sec = c->options.ce.connect_retry_seconds;
1389	break;	1392	break;
		1393	#ifdef USE_PF_INET6
		1394	case PROTO_TCPv6_SERVER:
		1395	#endif
1390	case PROTO_TCPv4_SERVER:	1396	case PROTO_TCPv4_SERVER:
1391	sec = 1;	1397	sec = 1;
1392	break;	1398	break;
		1399	#ifdef USE_PF_INET6
		1400	case PROTO_TCPv6_CLIENT:
		1401	#endif
1393	case PROTO_TCPv4_CLIENT:	1402	case PROTO_TCPv4_CLIENT:
1394	sec = c->options.ce.connect_retry_seconds;	1403	sec = c->options.ce.connect_retry_seconds;
1395	break;	1404	break;
Lines 2504-2510 do_setup_fast_io (struct context *c) Link Here
2504	#ifdef WIN32	2513	#ifdef WIN32
2505	msg (M_INFO, "NOTE: --fast-io is disabled since we are running on Windows");	2514	msg (M_INFO, "NOTE: --fast-io is disabled since we are running on Windows");
2506	#else	2515	#else
2507	if (c->options.ce.proto != PROTO_UDPv4)	2516	if (!proto_is_udp(c->options.ce.proto))
2508	msg (M_INFO, "NOTE: --fast-io is disabled since we are not using UDP");	2517	msg (M_INFO, "NOTE: --fast-io is disabled since we are not using UDP");
2509	else	2518	else
2510	{	2519	{
Lines 2764-2770 init_instance (struct context *c, const Link Here
2764	/* link_socket_mode allows CM_CHILD_TCP	2773	/* link_socket_mode allows CM_CHILD_TCP
2765	instances to inherit acceptable fds	2774	instances to inherit acceptable fds
2766	from a top-level parent */	2775	from a top-level parent */
		2776	#ifdef USE_PF_INET6
		2777	if (c->options.ce.proto == PROTO_TCPv4_SERVER \|\| c->options.ce.proto == PROTO_TCPv6_SERVER)
		2778	#else
2767	if (c->options.ce.proto == PROTO_TCPv4_SERVER)	2779	if (c->options.ce.proto == PROTO_TCPv4_SERVER)
		2780	#endif
2768	{	2781	{
2769	if (c->mode == CM_TOP)	2782	if (c->mode == CM_TOP)
2770	link_socket_mode = LS_MODE_TCP_LISTEN;	2783	link_socket_mode = LS_MODE_TCP_LISTEN;
Lines 3047-3063 inherit_context_child (struct context *d Link Here
3047	{	3060	{
3048	CLEAR (*dest);	3061	CLEAR (*dest);
3049		3062
3050	switch (src->options.ce.proto)	3063	dest->mode = proto_is_dgram(src->options.ce.proto)? CM_CHILD_UDP : CM_CHILD_TCP;
3051	{
3052	case PROTO_UDPv4:
3053	dest->mode = CM_CHILD_UDP;
3054	break;
3055	case PROTO_TCPv4_SERVER:
3056	dest->mode = CM_CHILD_TCP;
3057	break;
3058	default:
3059	ASSERT (0);
3060	}
3061		3064
3062	dest->gc = gc_new ();	3065	dest->gc = gc_new ();
3063		3066
Lines 3163-3169 Link Here
3163	dest->c2.es_owned = false;	3166	dest->c2.es_owned = false;
3164	dest->c2.event_set = NULL;	3167	dest->c2.event_set = NULL;
3165	if (src->options.ce.proto == PROTO_UDPv4)	3168	if (proto_is_dgram(src->options.ce.proto))
3166	do_event_set_init (dest, false);	3169	do_event_set_init (dest, false);
3167	}	3170	}




      /*
       * Initialize socket address
       */
      ms->local.addr.in4.sin_family = AF_INET;
      ms->local.addr.in4.sin_addr.s_addr = 0;
      ms->local.addr.in4.sin_port = htons (port);

      /*
       * Run management over tunnel, or

	}
      else
	{
	  ms->local.addr.in4.sin_addr.s_addr = getaddr
	    (GETADDR_RESOLVE|GETADDR_WARN_ON_SIGNAL|GETADDR_FATAL, addr, 0, NULL, NULL);
	}
      

      && man->connection.state == MS_INITIAL)
    {
      /* listen on our local TUN/TAP IP address */
      man->settings.local.addr.in4.sin_addr.s_addr = htonl (tun_local_ip);
      man_connection_init (man);
    }





				      const struct openvpn_sockaddr *osaddr,
				      bool use_port)
{
  switch (osaddr->addr.sa.sa_family) 
  {
    case AF_INET:
    {
      if (use_port)
	{
	  addr->type = MR_ADDR_IPV4 | MR_WITH_PORT;
	  addr->netbits = 0;
	  addr->len = 6;
	  memcpy (addr->addr, &osaddr->addr.in4.sin_addr.s_addr, 4);
	  memcpy (addr->addr + 4, &osaddr->addr.in4.sin_port, 2);
	}
      else
	{
	  addr->type = MR_ADDR_IPV4;
	  addr->netbits = 0;
	  addr->len = 4;
	  memcpy (addr->addr, &osaddr->addr.in4.sin_addr.s_addr, 4);
	}
      return true;
    }
#ifdef USE_PF_INET6
    case AF_INET6:
      if (use_port)
	{
	  addr->type = MR_ADDR_IPV6 | MR_WITH_PORT;
	  addr->netbits = 0;
	  addr->len = 18;
	  memcpy (addr->addr, &osaddr->addr.in6.sin6_addr, 16);
	  memcpy (addr->addr + 16, &osaddr->addr.in6.sin6_port, 2);
	}
      else
	{
	  addr->type = MR_ADDR_IPV6;
	  addr->netbits = 0;
	  addr->len = 16;
	  memcpy (addr->addr, &osaddr->addr.in6.sin6_addr, 16);
	}
      return true;
#endif
  }
  return false;
}


	  }
	  break;
	case MR_ADDR_IPV6:
#ifdef USE_PF_INET6
          {
	    struct buffer buf;
	    struct sockaddr_in6 sin6;
	    int port;
	    char buf6[INET6_ADDRSTRLEN] = "";
	    memset(&sin6, 0, sizeof sin6);
	    sin6.sin6_family = AF_INET6;
	    buf_set_read (&buf, maddr.addr, maddr.len);
            if (buf_read(&buf, &sin6.sin6_addr, sizeof (sin6.sin6_addr)))
            {
              if (getnameinfo((struct sockaddr *)&sin6, sizeof (struct sockaddr_in6),
                                      buf6, sizeof (buf6), NULL, 0, NI_NUMERICHOST) != 0)
                {
                  buf_printf (&out, "MR_ADDR_IPV6 getnameinfo() err");
                  break;
		}
              buf_puts (&out, buf6);
	      if (maddr.type & MR_WITH_NETBITS)
	        buf_printf (&out, "/%d", maddr.netbits);
              if (maddr.type & MR_WITH_PORT)
                {
                  port = buf_read_u16 (&buf);
                  if (port >= 0)
                    buf_printf (&out, ":%d", port);
                }
	    }
          }
#else /* old pre IPV6 1-line code: */
	  buf_printf (&out, "IPV6"); 
#endif
	  break;
	default:
	  buf_printf (&out, "UNKNOWN"); 

Lines 153-158 multi_tcp_instance_specific_init (struct Link Here

(-)a/mtcp.c (+1 lines)
153	ASSERT (mi->context.c2.link_socket);	153	ASSERT (mi->context.c2.link_socket);
154	ASSERT (mi->context.c2.link_socket->info.lsa);	154	ASSERT (mi->context.c2.link_socket->info.lsa);
155	ASSERT (mi->context.c2.link_socket->mode == LS_MODE_TCP_ACCEPT_FROM);	155	ASSERT (mi->context.c2.link_socket->mode == LS_MODE_TCP_ACCEPT_FROM);
		156	ASSERT (mi->context.c2.link_socket->info.lsa->actual.dest.addr.sa.sa_family == AF_INET);
156	if (!mroute_extract_openvpn_sockaddr (&mi->real, &mi->context.c2.link_socket->info.lsa->actual.dest, true))	157	if (!mroute_extract_openvpn_sockaddr (&mi->real, &mi->context.c2.link_socket->info.lsa->actual.dest, true))
157	{	158	{
158	msg (D_MULTI_ERRORS, "MULTI TCP: TCP client address is undefined");	159	msg (D_MULTI_ERRORS, "MULTI TCP: TCP client address is undefined");




  struct mroute_addr addr;

  CLEAR (remote_si);
  remote_si.addr.in4.sin_family = AF_INET;
  remote_si.addr.in4.sin_addr.s_addr = htonl (a);
  ASSERT (mroute_extract_openvpn_sockaddr (&addr, &remote_si, false));

  if (netbits >= 0)

  int count = 0;

  CLEAR (saddr);
  saddr.addr.in4.sin_family = AF_INET;
  saddr.addr.in4.sin_addr.s_addr = htonl (addr);
  saddr.addr.in4.sin_port = htons (port);
  if (mroute_extract_openvpn_sockaddr (&maddr, &saddr, true))
    {
      hash_iterator_init (m->iter, &hi, true);

{
  ASSERT (top->options.mode == MODE_SERVER);

  if (proto_is_dgram(top->options.ce.proto))
    tunnel_server_udp(top);
  else
    tunnel_server_tcp(top);
  case PROTO_TCPv4_SERVER:
    tunnel_server_tcp (top);
    break;
  default:
    ASSERT (0);
  }
}


#else
static void dummy(void) {}
#endif /* P2MP_SERVER */

Lines 369-375 process_received_occ_msg (struct context Link Here

(-)a/occ.c (-1 / +1 lines)
369	c->c2.max_send_size_remote,	369	c->c2.max_send_size_remote,
370	c->c2.max_recv_size_local);	370	c->c2.max_recv_size_local);
371	if (!c->options.fragment	371	if (!c->options.fragment
372	&& c->options.ce.proto == PROTO_UDPv4	372	&& (proto_is_dgram(c->options.ce.proto))
373	&& c->c2.max_send_size_local > TUN_MTU_MIN	373	&& c->c2.max_send_size_local > TUN_MTU_MIN
374	&& (c->c2.max_recv_size_remote < c->c2.max_send_size_local	374	&& (c->c2.max_recv_size_remote < c->c2.max_send_size_local
375	\|\| c->c2.max_recv_size_local < c->c2.max_send_size_remote))	375	\|\| c->c2.max_recv_size_local < c->c2.max_send_size_remote))

Lines 332-340 sock_addr_set (struct openvpn_sockaddr * Link Here

(-)a/ps.c (-3 / +3 lines)
332	const int port)	332	const int port)
333	{	333	{
334	CLEAR (*osaddr);	334	CLEAR (*osaddr);
335	osaddr->sa.sin_family = AF_INET;	335	osaddr->addr.in4.sin_family = AF_INET;
336	osaddr->sa.sin_addr.s_addr = htonl (addr);	336	osaddr->addr.in4.sin_addr.s_addr = htonl (addr);
337	osaddr->sa.sin_port = htons (port);	337	osaddr->addr.in4.sin_port = htons (port);
338	}	338	}
339		339
340	static inline void	340	static inline void

Lines 70-76 #define ntohps(x) ntohs(x) Link Here

(-)a/socket.h (-31 / +202 lines)
70	struct openvpn_sockaddr	70	struct openvpn_sockaddr
71	{	71	{
72	/int dummy;/ /* add offset to force a bug if sa not explicitly dereferenced */	72	/int dummy;/ /* add offset to force a bug if sa not explicitly dereferenced */
73	struct sockaddr_in sa;	73	union {
		74	struct sockaddr sa;
		75	struct sockaddr_in in4;
		76	#ifdef USE_PF_INET6
		77	struct sockaddr_in6 in6;
		78	#endif
		79	} addr;
74	};	80	};
75		81
76	/* actual address of remote, based on source address of received packets */	82	/* actual address of remote, based on source address of received packets */
Lines 79-85 { Link Here
79	/int dummy;/ /* add offset to force a bug if dest not explicitly dereferenced */	85	/int dummy;/ /* add offset to force a bug if dest not explicitly dereferenced */
80	struct openvpn_sockaddr dest;	86	struct openvpn_sockaddr dest;
81	#if ENABLE_IP_PKTINFO	87	#if ENABLE_IP_PKTINFO
82	struct in_pktinfo pi;	88	union {
		89	struct in_pktinfo in4;
		90	#ifdef USE_PF_INET6
		91	struct in6_pktinfo in6;
		92	#endif
		93	} pi;
83	#endif	94	#endif
84	};	95	};
85		96
Lines 403-408 socket_descriptor_t create_socket_tcp (v Link Here
403	socket_descriptor_t socket_do_accept (socket_descriptor_t sd,	414	socket_descriptor_t socket_do_accept (socket_descriptor_t sd,
404	struct link_socket_actual *act,	415	struct link_socket_actual *act,
405	const bool nowait);	416	const bool nowait);
		417	/*
		418	* proto related
		419	*/
		420	bool proto_is_net(int proto);
		421	bool proto_is_dgram(int proto);
		422	bool proto_is_udp(int proto);
		423	bool proto_is_tcp(int proto);
		424
406		425
407	/*	426	/*
408	* DNS resolution	427	* DNS resolution
Lines 428-450 in_addr_t getaddr (unsigned int flags, Link Here
428	* Transport protocol naming and other details.	447	* Transport protocol naming and other details.
429	*/	448	*/
430		449
431	#define PROTO_UDPv4 0	450	#if 0 /* PRE UDPv6/TCPv6 code */
432	#define PROTO_TCPv4_SERVER 1	451	#define PROTO_NONE 0 /* catch for uninitialized */
433	#define PROTO_TCPv4_CLIENT 2	452	#define PROTO_UDPv4 1
434	#define PROTO_TCPv4 3	453	#define PROTO_TCPv4_SERVER 2
435	#define PROTO_N 4	454	#define PROTO_TCPv4_CLIENT 3
		455	#define PROTO_TCPv4 4
		456	#define PROTO_UDPv6 5
		457	#define PROTO_TCPv6_SERVER 6
		458	#define PROTO_TCPv6_CLIENT 7
		459	#define PROTO_TCPv6 8
		460	#define PROTO_N 9
		461	#endif /* if 0 */
		462
		463	/*
		464	* Use enum's instead of #define to allow for easier
		465	* optional proto support
		466	*/
		467	enum proto_num {
		468	PROTO_NONE, /* catch for uninitialized */
		469	PROTO_UDPv4,
		470	PROTO_TCPv4_SERVER,
		471	PROTO_TCPv4_CLIENT,
		472	PROTO_TCPv4,
		473	PROTO_UDPv6,
		474	PROTO_TCPv6_SERVER,
		475	PROTO_TCPv6_CLIENT,
		476	PROTO_TCPv6,
		477	PROTO_N
		478	};
436		479
437	int ascii2proto (const char* proto_name);	480	int ascii2proto (const char* proto_name);
438	const char *proto2ascii (int proto, bool display_form);	481	const char *proto2ascii (int proto, bool display_form);
439	const char proto2ascii_all (struct gc_arena gc);	482	const char proto2ascii_all (struct gc_arena gc);
440	int proto_remote (int proto, bool remote);	483	int proto_remote (int proto, bool remote);
		484	const char *addr_family_name(int af);
441		485
442	/*	486	/*
443	* Overhead added to packets by various protocols.	487	* Overhead added to packets by various protocols.
444	*/	488	*/
445	#define IPv4_UDP_HEADER_SIZE 28	489	#define IPv4_UDP_HEADER_SIZE 28
446	#define IPv4_TCP_HEADER_SIZE 40	490	#define IPv4_TCP_HEADER_SIZE 40
447	#define IPv6_UDP_HEADER_SIZE 40	491	#define IPv6_UDP_HEADER_SIZE 48
		492	#define IPv6_TCP_HEADER_SIZE 60
448		493
449	extern const int proto_overhead[];	494	extern const int proto_overhead[];
450		495
Lines 468-474 legal_ipv4_port (int port) Link Here
468	static inline bool	513	static inline bool
469	link_socket_proto_connection_oriented (int proto)	514	link_socket_proto_connection_oriented (int proto)
470	{	515	{
471	return proto == PROTO_TCPv4_SERVER \|\| proto == PROTO_TCPv4_CLIENT;	516	return !proto_is_dgram(proto);
472	}	517	}
473		518
474	static inline bool	519	static inline bool
Lines 483-489 link_socket_connection_oriented (const s Link Here
483	static inline bool	528	static inline bool
484	addr_defined (const struct openvpn_sockaddr *addr)	529	addr_defined (const struct openvpn_sockaddr *addr)
485	{	530	{
486	return addr->sa.sin_addr.s_addr != 0;	531	if (!addr) return 0;
		532	switch (addr->addr.sa.sa_family) {
		533	case AF_INET: return addr->addr.in4.sin_addr.s_addr != 0;
		534	#ifdef USE_PF_INET6
		535	case AF_INET6: return !IN6_IS_ADDR_UNSPECIFIED(&addr->addr.in6.sin6_addr);
		536	#endif
		537	default: return 0;
		538	}
		539	}
		540	static inline bool
		541	addr_defined_ipi (const struct link_socket_actual *lsa)
		542	{
		543	#if ENABLE_IP_PKTINFO
		544	if (!lsa) return 0;
		545	switch (lsa->dest.addr.sa.sa_family) {
		546	case AF_INET: return lsa->pi.in4.ipi_spec_dst.s_addr != 0;
		547	#ifdef USE_PF_INET6
		548	case AF_INET6: return !IN6_IS_ADDR_UNSPECIFIED(&lsa->pi.in6.ipi6_addr);
		549	#endif
		550	default: return 0;
		551	}
		552	#else
		553	ASSERT(0);
		554	#endif
487	}	555	}
488		556
489	static inline bool	557	static inline bool
Lines 495-514 link_socket_actual_defined (const struct Link Here
495	static inline bool	563	static inline bool
496	addr_match (const struct openvpn_sockaddr a1, const struct openvpn_sockaddr a2)	564	addr_match (const struct openvpn_sockaddr a1, const struct openvpn_sockaddr a2)
497	{	565	{
498	return a1->sa.sin_addr.s_addr == a2->sa.sin_addr.s_addr;	566	switch(a1->addr.sa.sa_family) {
		567	case AF_INET:
		568	return a1->addr.in4.sin_addr.s_addr == a2->addr.in4.sin_addr.s_addr;
		569	#ifdef USE_PF_INET6
		570	case AF_INET6:
		571	return IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &a2->addr.in6.sin6_addr);
		572	#endif
		573	}
		574	ASSERT(0);
		575	return false;
499	}	576	}
500		577
501	static inline in_addr_t	578	static inline in_addr_t
502	addr_host (const struct openvpn_sockaddr *s)	579	addr_host (const struct openvpn_sockaddr *addr)
503	{	580	{
504	return ntohl (s->sa.sin_addr.s_addr);	581	/*
		582	* "public" addr returned is checked against ifconfig for
		583	* possible clash: non sense for now given
		584	* that we do ifconfig only IPv4
		585	*/
		586	#if defined(USE_PF_INET6)
		587	if(addr->addr.sa.sa_family != AF_INET)
		588	return 0;
		589	#else
		590	ASSERT(addr->addr.sa.sa_family == AF_INET);
		591	#endif
		592	return ntohl (addr->addr.in4.sin_addr.s_addr);
505	}	593	}
506		594
507	static inline bool	595	static inline bool
508	addr_port_match (const struct openvpn_sockaddr a1, const struct openvpn_sockaddr a2)	596	addr_port_match (const struct openvpn_sockaddr a1, const struct openvpn_sockaddr a2)
509	{	597	{
510	return a1->sa.sin_addr.s_addr == a2->sa.sin_addr.s_addr	598	switch(a1->addr.sa.sa_family) {
511	&& a1->sa.sin_port == a2->sa.sin_port;	599	case AF_INET:
		600	return a1->addr.in4.sin_addr.s_addr == a2->addr.in4.sin_addr.s_addr
		601	&& a1->addr.in4.sin_port == a2->addr.in4.sin_port;
		602	#ifdef USE_PF_INET6
		603	case AF_INET6:
		604	return IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &a2->addr.in6.sin6_addr)
		605	&& a1->addr.in6.sin6_port == a2->addr.in6.sin6_port;
		606	#endif
		607	}
		608	ASSERT(0);
		609	return false;
512	}	610	}
513		611
514	static inline bool	612	static inline bool
Lines 521-526 addr_match_proto (const struct openvpn_s Link Here
521	: addr_port_match (a1, a2);	619	: addr_port_match (a1, a2);
522	}	620	}
523		621
		622	static inline void
		623	addr_zero_host(struct openvpn_sockaddr *addr)
		624	{
		625	switch(addr->addr.sa.sa_family) {
		626	case AF_INET:
		627	addr->addr.in4.sin_addr.s_addr = 0;
		628	break;
		629	#ifdef USE_PF_INET6
		630	case AF_INET6:
		631	memset(&addr->addr.in6.sin6_addr, 0, sizeof (struct in6_addr));
		632	break;
		633	#endif
		634	}
		635	}
		636
		637	static inline void
		638	addr_copy_sa(struct openvpn_sockaddr dst, const struct openvpn_sockaddr src)
		639	{
		640	dst->addr = src->addr;
		641	}
		642
		643	static inline void
		644	addr_copy_host(struct openvpn_sockaddr dst, const struct openvpn_sockaddr src)
		645	{
		646	switch(src->addr.sa.sa_family) {
		647	case AF_INET:
		648	dst->addr.in4.sin_addr.s_addr = src->addr.in4.sin_addr.s_addr;
		649	break;
		650	#ifdef USE_PF_INET6
		651	case AF_INET6:
		652	dst->addr.in6.sin6_addr = src->addr.in6.sin6_addr;
		653	break;
		654	#endif
		655	}
		656	}
		657
		658	static inline bool
		659	addr_inet4or6(struct sockaddr *addr)
		660	{
		661	return addr->sa_family == AF_INET \|\| addr->sa_family == AF_INET6;
		662	}
		663
		664	int addr_guess_family(int proto, const char *name);
		665	static inline int
		666	af_addr_size(sa_family_t af)
		667	{
		668	#if defined(USE_PF_INET6) \|\| defined (USE_PF_UNIX)
		669	switch(af) {
		670	case AF_INET: return sizeof (struct sockaddr_in);
		671	#ifdef USE_PF_UNIX
		672	case AF_UNIX: return sizeof (struct sockaddr_un);
		673	#endif
		674	#ifdef USE_PF_INET6
		675	case AF_INET6: return sizeof (struct sockaddr_in6);
		676	#endif
		677	default:
		678	#if 0
		679	/* could be called from socket_do_accept() with empty addr */
		680	msg (M_ERR, "Bad address family: %d\n", addr->sa_family);
		681	ASSERT(0);
		682	#endif
		683	return 0;
		684	}
		685	#else /* only AF_INET */
686	return sizeof(struct sockaddr_in);
687	#endif
688	}
689
524	static inline bool	690	static inline bool
525	link_socket_actual_match (const struct link_socket_actual a1, const struct link_socket_actual a2)	691	link_socket_actual_match (const struct link_socket_actual a1, const struct link_socket_actual a2)
526	{	692	{
Lines 577-590 link_socket_verify_incoming_addr (struct Link Here
577	{	743	{
578	if (buf->len > 0)	744	if (buf->len > 0)
579	{	745	{
580	if (from_addr->dest.sa.sin_family != AF_INET)	746	switch (from_addr->dest.addr.sa.sa_family) {
581	return false;	747	#ifdef USE_PF_INET6
582	if (!link_socket_actual_defined (from_addr))	748	case AF_INET6:
583	return false;	749	#endif
584	if (info->remote_float \|\| !addr_defined (&info->lsa->remote))	750	case AF_INET:
585	return true;	751	if (!link_socket_actual_defined (from_addr))
586	if (addr_match_proto (&from_addr->dest, &info->lsa->remote, info->proto))	752	return false;
587	return true;	753	if (info->remote_float \|\| !addr_defined (&info->lsa->remote))
		754	return true;
		755	if (addr_match_proto (&from_addr->dest, &info->lsa->remote, info->proto))
		756	return true;
		757	}
588	}	758	}
589	return false;	759	return false;
590	}	760	}
Lines 690-696 link_socket_read (struct link_socket *so Link Here
690	int maxsize,	860	int maxsize,
691	struct link_socket_actual *from)	861	struct link_socket_actual *from)
692	{	862	{
693	if (sock->info.proto == PROTO_UDPv4)	863	if (proto_is_udp(sock->info.proto)) /* unified UDPv4 and UDPv6 */
694	{	864	{
695	int res;	865	int res;
696		866
Lines 701-710 #else Link Here
701	#endif	871	#endif
702	return res;	872	return res;
703	}	873	}
704	else if (sock->info.proto == PROTO_TCPv4_SERVER \|\| sock->info.proto == PROTO_TCPv4_CLIENT)	874	else if (proto_is_tcp(sock->info.proto)) /* unified TCPv4 and TCPv6 */
705	{	875	{
706	/* from address was returned by accept */	876	/* from address was returned by accept */
707	from->dest.sa = sock->info.lsa->actual.dest.sa;	877	addr_copy_sa(&from->dest, &sock->info.lsa->actual.dest);
708	return link_socket_read_tcp (sock, buf);	878	return link_socket_read_tcp (sock, buf);
709	}	879	}
710	else	880	else
Lines 759-771 #if ENABLE_IP_PKTINFO Link Here
759	struct buffer *buf,	929	struct buffer *buf,
760	struct link_socket_actual *to);	930	struct link_socket_actual *to);
761		931
762	if (sock->sockflags & SF_USE_IP_PKTINFO)	932	if (proto_is_udp(sock->info.proto) && (sock->sockflags & SF_USE_IP_PKTINFO)
		933	&& addr_defined_ipi(to))
763	return link_socket_write_udp_posix_sendmsg (sock, buf, to);	934	return link_socket_write_udp_posix_sendmsg (sock, buf, to);
764	else	935	else
765	#endif	936	#endif
766	return sendto (sock->sd, BPTR (buf), BLEN (buf), 0,	937	return sendto (sock->sd, BPTR (buf), BLEN (buf), 0,
767	(struct sockaddr *) &to->dest.sa,	938	(struct sockaddr *) &to->dest.addr.sa,
768	(socklen_t) sizeof (to->dest.sa));	939	(socklen_t) af_addr_size(to->dest.addr.sa.sa_family));
769	}	940	}
770		941
771	static inline int	942	static inline int
Lines 796-806 link_socket_write (struct link_socket *s Link Here
796	struct buffer *buf,	967	struct buffer *buf,
797	struct link_socket_actual *to)	968	struct link_socket_actual *to)
798	{	969	{
799	if (sock->info.proto == PROTO_UDPv4)	970	if (proto_is_udp(sock->info.proto)) /* unified UDPv4 and UDPv6 */
800	{	971	{
801	return link_socket_write_udp (sock, buf, to);	972	return link_socket_write_udp (sock, buf, to);
802	}	973	}
803	else if (sock->info.proto == PROTO_TCPv4_SERVER \|\| sock->info.proto == PROTO_TCPv4_CLIENT)	974	else if (proto_is_tcp(sock->info.proto)) /* unified TCPv4 and TCPv6 */
804	{	975	{
805	return link_socket_write_tcp (sock, buf, to);	976	return link_socket_write_tcp (sock, buf, to);
806	}	977	}





  if (addr != NULL)
    {
      addr->addr.in4.sin_family = AF_INET;
      addr->addr.in4.sin_addr.s_addr = htonl (INADDR_ANY);
      addr->addr.in4.sin_port = htons (0);
    }

  while (len < 4 + alen + 2)

  /* ATYP == 1 (IP V4 address) */
  if (atyp == '\x01' && addr != NULL)
    {
      memcpy (&addr->addr.in4.sin_addr, buf + 4, sizeof (addr->addr.in4.sin_addr));
      memcpy (&addr->addr.in4.sin_port, buf + 8, sizeof (addr->addr.in4.sin_port));
    }



  if (atyp != 1)		/* ATYP == 1 (IP V4) */
    goto error;

  buf_read (buf, &from->dest.addr.in4.sin_addr, sizeof (from->dest.addr.in4.sin_addr));
  buf_read (buf, &from->dest.addr.in4.sin_port, sizeof (from->dest.addr.in4.sin_port));

  return;


  buf_write_u16 (&head, 0);	/* RSV = 0 */
  buf_write_u8 (&head, 0);	/* FRAG = 0 */
  buf_write_u8 (&head, '\x01'); /* ATYP = 1 (IP V4) */
  buf_write (&head, &to->dest.addr.in4.sin_addr, sizeof (to->dest.addr.in4.sin_addr));
  buf_write (&head, &to->dest.addr.in4.sin_port, sizeof (to->dest.addr.in4.sin_port));

  return 10;
}




#include "memdbg.h"

const int proto_overhead[] = { /* indexed by PROTO_x */
  0,
  IPv4_UDP_HEADER_SIZE, /* IPv4 */
  IPv4_TCP_HEADER_SIZE,
  IPv4_TCP_HEADER_SIZE,
#ifdef USE_PF_INET6
  IPv6_UDP_HEADER_SIZE, /* IPv6 */
  IPv6_TCP_HEADER_SIZE,
  IPv6_TCP_HEADER_SIZE,
  IPv6_TCP_HEADER_SIZE,
#endif
};

/*

	       struct openvpn_sockaddr *addr,
	       bool *changed)
{
  switch(addr->addr.sa.sa_family) {
    case AF_INET:
      if (host && addr)
      {
	const in_addr_t new_addr = getaddr (
	    GETADDR_RESOLVE|GETADDR_UPDATE_MANAGEMENT_STATE,
	    host,
	    1,
	    NULL,
	    NULL);
	if (new_addr && addr->addr.in4.sin_addr.s_addr != new_addr)
	{
	  addr->addr.in4.sin_addr.s_addr = new_addr;
	  *changed = true;
	}
      }
      break;
#ifdef USE_PF_INET6
    case AF_INET6: /* jjoFIXME: should adapt getaddr() for AF_INET6 */
      if (host && addr)
      {
	struct addrinfo hints , *ai;
	int err;
	memset(&hints, 0, sizeof hints);
	hints.ai_flags=AI_PASSIVE;
	hints.ai_family=AF_INET6;
	if ((err=getaddrinfo(host, NULL, &hints, &ai))==0)
	{
	  struct sockaddr_in6 *sin6=(struct sockaddr_in6*)ai->ai_addr;
	  if (IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, &addr->addr.in6.sin6_addr))
	  {
	    int port=addr->addr.in6.sin6_port; /* backup current port for easier copy, restore later */
	    addr->addr.in6=*sin6; /* ipv6 requires also eg. sin6_scope_id => easy to full copy*/
	    addr->addr.in6.sin6_port=port;
	  }
	  freeaddrinfo(ai);
	}
      }
      break;
#endif
    default:
    	ASSERT(0);
  }
}

static int

  return sd;
}

#ifdef USE_PF_INET6
static socket_descriptor_t
create_socket_udp6 (const unsigned int flags)
{
  socket_descriptor_t sd;

  if ((sd = socket (PF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0)
    msg (M_SOCKERR, "UDP: Cannot create UDP6 socket");
#if ENABLE_IP_PKTINFO
  else if (flags & SF_USE_IP_PKTINFO)
    {
      int pad = 1;
      setsockopt (sd, IPPROTO_IPV6, IPV6_PKTINFO, (void*)&pad, sizeof(pad));
    }
#endif
  return sd;
}

static socket_descriptor_t
create_socket_tcp6 (void)
{
  socket_descriptor_t sd;

  if ((sd = socket (PF_INET6, SOCK_STREAM, IPPROTO_TCP)) < 0)
    msg (M_SOCKERR, "Cannot create TCP6 socket");

  /* set SO_REUSEADDR on socket */
  {
    int on = 1;
    if (setsockopt (sd, SOL_SOCKET, SO_REUSEADDR,
		    (void *) &on, sizeof (on)) < 0)
      msg (M_SOCKERR, "TCP: Cannot setsockopt SO_REUSEADDR on TCP6 socket");
  }

  return sd;
}

#endif
static void
create_socket (struct link_socket *sock)
{

    {
      sock->sd = create_socket_tcp ();
    }
#ifdef USE_PF_INET6
  else if (sock->info.proto == PROTO_TCPv6_SERVER
	   || sock->info.proto == PROTO_TCPv6_CLIENT)
    {
      sock->sd = create_socket_tcp6 ();
    }
  else if (sock->info.proto == PROTO_UDPv6)
    {
      sock->sd = create_socket_udp6 (sock->sockflags);
    }
#endif
  else
    {
      ASSERT (0);

		  struct link_socket_actual *act,
		  const bool nowait)
{
  /* af_addr_size WILL return 0 in this case if AFs other than AF_INET
   * are compiled because act is empty here.
   * could use getsockname() to support later remote_len check
   */
  socklen_t remote_len_af = af_addr_size(act->dest.addr.sa.sa_family);
  socklen_t remote_len = sizeof(act->dest.addr);
  socket_descriptor_t new_sd = SOCKET_UNDEFINED;

  CLEAR (*act);

#ifdef HAVE_GETPEERNAME
  if (nowait)
    {
      new_sd = getpeername (sd, &act->dest.addr.sa, &remote_len);

      if (!socket_defined (new_sd))
	msg (D_LINK_ERRORS | M_ERRNO_SOCK, "TCP: getpeername() failed");

#endif
  else
    {
      new_sd = accept (sd, &act->dest.addr.sa, &remote_len);
    }

#if 0 /* For debugging only, test the effect of accept() failures */

    {
      msg (D_LINK_ERRORS | M_ERRNO_SOCK, "TCP: accept(%d) failed", sd);
    }
  /* only valid if we have remote_len_af!=0 */
  else if (remote_len_af && remote_len != remote_len_af)
    {
      msg (D_LINK_ERRORS, "TCP: Received strange incoming connection with unknown address length=%d", remote_len);
      openvpn_close_socket (new_sd);

{
  struct gc_arena gc = gc_new ();

  if (bind (sd, &local->addr.sa, af_addr_size(local->addr.sa.sa_family)))
    {
      const int errnum = openvpn_errno_socket ();
      msg (M_FATAL, "%s: Socket bind failed on local address %s: %s",


#ifdef CONNECT_NONBLOCK
  set_nonblock (sd);
  status = connect (sd, &remote->addr.sa, af_addr_size(remote->addr.sa.sa_family));
  if (status)
    status = openvpn_errno_socket ();
  if (status == EINPROGRESS)

      if (*signal_received)
	goto done;

      switch(remote->addr.sa.sa_family) {
        case AF_INET:
          *sd = create_socket_tcp ();
          if (bind_local)
            socket_bind (*sd, local, "TCP Client");
          update_remote (remote_dynamic, remote, remote_changed);
          break;
  #ifdef USE_PF_INET6
        case AF_INET6:
          *sd = create_socket_tcp6 ();
          if (bind_local)
            socket_bind (*sd, local, "TCP6 Client");
          update_remote (remote_dynamic, remote, remote_changed);
          break;
  #endif
        default:
          msg(M_FATAL, "Only TCP is supported for connection oriented, sa_family=%d",
              remote->addr.sa.sa_family);
     }
  }

  msg (M_INFO, "TCP connection established with %s",
       print_sockaddr (remote, &gc));

  done:
    gc_free (&gc);
}

/* For stream protocols, allocate a buffer to build up packet.


  /* resolve local address if undefined */
  if (!addr_defined (&sock->info.lsa->local))
  {
    /* may return AF_{INET|INET6} guessed from local_host */
    switch(addr_guess_family(sock->info.proto, sock->local_host)) {
      case AF_INET:
	sock->info.lsa->local.addr.in4.sin_family = AF_INET;
	sock->info.lsa->local.addr.in4.sin_addr.s_addr =
	  (sock->local_host ? getaddr (GETADDR_RESOLVE | GETADDR_WARN_ON_SIGNAL | GETADDR_FATAL,
				       sock->local_host,
				       0,
				       NULL,
				       NULL)
	   : htonl (INADDR_ANY));
	sock->info.lsa->local.addr.in4.sin_port = htons (sock->local_port);
	break;
#ifdef USE_PF_INET6
      case AF_INET6:
	{
	  struct addrinfo hints , *ai;
	  int err;
	  memset(&hints, 0, sizeof hints);
	  hints.ai_flags=AI_PASSIVE;
	  hints.ai_family=AF_INET6;
	  /* if no local_host provided, ask for IN6ADDR_ANY ... */
	  if ((err=getaddrinfo(sock->local_host? sock->local_host : "::", 
		  NULL, &hints, &ai))==0) {
	    sock->info.lsa->local.addr.in6 = *((struct sockaddr_in6*)(ai->ai_addr));
	    freeaddrinfo(ai);
	  } else {
	    msg (M_FATAL, "getaddrinfo() failed for local \"%s\": %s",
		sock->local_host,
		gai_strerror(err));
	  }
	  sock->info.lsa->local.addr.in6.sin6_port = htons (sock->local_port);
	}
	break;
#endif
    }
  }
  
  /* bind to local address/port */
  if (sock->bind_local)

    {
      /* resolve remote address if undefined */
      if (!addr_defined (&sock->info.lsa->remote))
      {
        switch(addr_guess_family(sock->info.proto, sock->remote_host))
        {
        case AF_INET:
          sock->info.lsa->remote.addr.in4.sin_family = AF_INET;
          sock->info.lsa->remote.addr.in4.sin_addr.s_addr = 0;

	  if (sock->remote_host)
          {
            unsigned int flags = GETADDR_RESOLVE|GETADDR_UPDATE_MANAGEMENT_STATE;
            int retry = 0;
            bool status = false;

            if (sock->connection_profiles_defined && sock->resolve_retry_seconds == RESOLV_RETRY_INFINITE)
              {
                if (phase == 2)
                  flags |= (GETADDR_TRY_ONCE | GETADDR_FATAL);
                retry = 0;
              }
              else if (phase == 1)
                {
                  if (sock->resolve_retry_seconds)
                    {
                      retry = 0;
                    }
		  else
		    {
		      flags |= (GETADDR_FATAL | GETADDR_MENTION_RESOLVE_RETRY);
		      retry = 0;
		    }
		}
	      else if (phase == 2)
		{
		  if (sock->resolve_retry_seconds)
		    {
		      flags |= GETADDR_FATAL;
		      retry = sock->resolve_retry_seconds;
		    }
		  else
                    {
	               flags |= (GETADDR_FATAL | GETADDR_MENTION_RESOLVE_RETRY);
	               retry = 0;
	            }
	          }
	          else if (phase == 2)
	          {
	            if (sock->resolve_retry_seconds)
	            {
	              flags |= GETADDR_FATAL;
	              retry = sock->resolve_retry_seconds;
	            }
	            else
	            {
	              ASSERT (0);
	            }
	          }
	          else
	          {
	            ASSERT (0);
	          }

	          sock->info.lsa->remote.addr.in4.sin_addr.s_addr = getaddr (
	              flags,
	              sock->remote_host,
	              retry,
	              &status,
	              signal_received);
	
	          dmsg (D_SOCKET_DEBUG, "RESOLVE_REMOTE flags=0x%04x phase=%d rrs=%d sig=%d status=%d",
	              flags,
	              phase,
	              retry,
	              signal_received ? *signal_received : -1,
	              status);

	          if (signal_received)
	          {
	            if (*signal_received)
	              goto done;
	          }
	          if (!status)
	          {
		    if (signal_received)
		      *signal_received = SIGUSR1;
		    goto done;
		  }
	        }
		{
		  if (signal_received)
		    *signal_received = SIGUSR1;
		  goto done;
		}
	    }

          sock->info.lsa->remote.addr.in4.sin_port = htons (sock->remote_port);
          break;
  
  #ifdef USE_PF_INET6
        case AF_INET6: /* jjoFIXME: ipv6 signal logic */
          {
            struct addrinfo hints , *ai;
            int err;
            memset(&hints, 0, sizeof hints);
            hints.ai_flags=0;
            hints.ai_family=AF_INET6;
            if ((err=getaddrinfo(sock->remote_host? sock->remote_host : "::" , NULL, &hints, &ai))==0) {
              sock->info.lsa->remote.addr.in6 = *((struct sockaddr_in6*)(ai->ai_addr));
              freeaddrinfo(ai);
            } else {
              msg (M_FATAL, "getaddrinfo() failed for remote \"%s\": %s",
                  sock->remote_host,
                  gai_strerror(err));
            }
            sock->info.lsa->remote.addr.in6.sin6_port = htons (sock->remote_port);
          }
          break;
  #endif
        }
      }
      /* should we re-use previous active remote address? */
      if (link_socket_actual_defined (&sock->info.lsa->actual))
      {
        msg (M_INFO, "TCP/UDP: Preserving recently used remote address: %s",
          print_link_socket_actual (&sock->info.lsa->actual, &gc));
        if (remote_dynamic)
        *remote_dynamic = NULL;
      }
      else
      {
        CLEAR (sock->info.lsa->actual);
        sock->info.lsa->actual.dest = sock->info.lsa->remote;
      }

      /* remember that we finished */
      sock->did_resolve_remote = true;
    }

  done:
   gc_free (&gc);
}

struct link_socket *

	goto done;

      /* TCP client/server */
      if (sock->info.proto == PROTO_TCPv4_SERVER
#ifdef USE_PF_INET6
	||sock->info.proto == PROTO_TCPv6_SERVER
#endif
	)
	{
	  switch (sock->mode)
	    {

	      ASSERT (0);
	    }
	}
      else if (sock->info.proto == PROTO_TCPv4_CLIENT
#ifdef USE_PF_INET6
	||sock->info.proto == PROTO_TCPv6_CLIENT
#endif
	)
	{

#ifdef GENERAL_PROXY_SUPPORT

	  sock->remote_port = sock->proxy_dest_port;
	  sock->did_resolve_remote = false;

	  addr_zero_host(&sock->info.lsa->actual.dest);
	  addr_zero_host(&sock->info.lsa->remote);

	  resolve_remote (sock, 1, NULL, signal_received);


      if (remote_changed)
	{
	  msg (M_INFO, "TCP/UDP: Dynamic remote address changed during TCP connection establishment");
	  addr_copy_host(&sock->info.lsa->remote, &sock->info.lsa->actual.dest);
	}
    }


{
  struct gc_arena gc = gc_new ();

  switch(from_addr->dest.addr.sa.sa_family)
  {
    case AF_INET:
#ifdef USE_PF_INET6
    case AF_INET6:
#endif
      msg (D_LINK_ERRORS,
	  "TCP/UDP: Incoming packet rejected from %s[%d], expected peer address: %s (allow this incoming source address/port by removing --remote or adding --float)",
	  print_link_socket_actual (from_addr, &gc),
	  (int)from_addr->dest.addr.sa.sa_family,
	  print_sockaddr (&info->lsa->remote, &gc));
      break;
  }
  buf->len = 0;

  gc_free (&gc);
}


{
  const struct link_socket_addr *lsa = info->lsa;

/* 
 * This logic supports "redirect-gateway" semantic, which 
 * makes sense only for PF_INET routes over PF_INET endpoints
 *
 * Maybe in the future consider PF_INET6 endpoints also ...
 * by now just ignore it
 *
 */
#if defined ( USE_PF_INET6 )
  if(lsa->actual.dest.addr.sa.sa_family != AF_INET)
	  return 0;
#else
  ASSERT(lsa->actual.dest.addr.sa.sa_family == AF_INET);
#endif

  if (link_socket_actual_defined (&lsa->actual))
    return ntohl (lsa->actual.dest.addr.in4.sin_addr.s_addr);
  else if (addr_defined (&lsa->remote))
    return ntohl (lsa->remote.addr.in4.sin_addr.s_addr);
  else
    return 0;
}

		   const unsigned int flags,
		   struct gc_arena *gc)
{
   struct buffer out;
   bool addr_is_defined;
   if (!addr) {
     return "[NULL]";
   }
   addr_is_defined =  addr_defined (addr);
   switch(addr->addr.sa.sa_family) {
     case AF_INET:
       {
       const int port= ntohs (addr->addr.in4.sin_port);
       out = alloc_buf_gc (128, gc);
       buf_puts (&out, "[AF_INET]");
       mutex_lock_static (L_INET_NTOA);
       buf_puts (&out, (addr_is_defined ? inet_ntoa (addr->addr.in4.sin_addr) : "[undef]"));
       mutex_unlock_static (L_INET_NTOA);

       if (((flags & PS_SHOW_PORT) || (addr_is_defined && (flags & PS_SHOW_PORT_IF_DEFINED)))
          && port)
       {
         if (separator)
	   buf_printf (&out, "%s", separator);

	 buf_printf (&out, "%d", port);
       }
       }
       break;
 #ifdef USE_PF_INET6
     case AF_INET6:
       {
       const int port= ntohs (addr->addr.in6.sin6_port);
       char buf[INET6_ADDRSTRLEN] = "[undef]";
       out = alloc_buf_gc (128, gc);
       buf_puts (&out, "[AF_INET6]");
       if (addr_is_defined)
       {
         getnameinfo(&addr->addr.sa, sizeof (struct sockaddr_in6),
             buf, sizeof (buf), NULL, 0, NI_NUMERICHOST);
         buf_puts (&out, buf);
       }
       if (((flags & PS_SHOW_PORT) || (addr_is_defined && (flags & PS_SHOW_PORT_IF_DEFINED)))
           && port)
       {
         if (separator)
           buf_puts (&out, separator);

         buf_printf (&out, "%d", port);
       }
       }
       break;
 #endif
   }
    return BSTR (&out);
}

const char *

      struct buffer out = alloc_buf_gc (128, gc);
      buf_printf (&out, "%s", print_sockaddr_ex (&act->dest, separator, flags, gc));
#if ENABLE_IP_PKTINFO
      if ((flags & PS_SHOW_PKTINFO) && addr_defined_ipi(act))
	{
	  switch(act->dest.addr.sa.sa_family)
	  {
	case AF_INET:
	  {
	  struct openvpn_sockaddr sa;
	  CLEAR (sa);
	  sa.addr.in4.sin_addr = act->pi.in4.ipi_spec_dst;
	  buf_printf (&out, " (via %s)", print_sockaddr_ex (&sa, separator, 0, gc));
	  }
	  break;
#ifdef USE_PF_INET6
	case AF_INET6:
	  {
	    struct sockaddr_in6 sin6;
	    char buf[INET6_ADDRSTRLEN] = "[undef]";
	    memset(&sin6, 0, sizeof sin6);
	    sin6.sin6_family = AF_INET6;
	    sin6.sin6_addr = act->pi.in6.ipi6_addr;
	    {
	      if (getnameinfo((struct sockaddr *)&sin6, sizeof (struct sockaddr_in6),
		    buf, sizeof (buf), NULL, 0, NI_NUMERICHOST) == 0)
		buf_printf (&out, " (via %s)", buf);
	      else
		buf_printf (&out, " (via [getnameinfo() err])");
	    }
	  }
	  break;
#endif
	  }

	}
#endif
      return BSTR (&out);

setenv_sockaddr (struct env_set *es, const char *name_prefix, const struct openvpn_sockaddr *addr, const bool flags)
{
  char name_buf[256];
  char buf[128];

  switch(addr->addr.sa.sa_family) {
    case AF_INET:
      if (flags & SA_IP_PORT)
	openvpn_snprintf (name_buf, sizeof (name_buf), "%s_ip", name_prefix);
      else
	openvpn_snprintf (name_buf, sizeof (name_buf), "%s", name_prefix);

      mutex_lock_static (L_INET_NTOA);
      setenv_str (es, name_buf, inet_ntoa (addr->addr.in4.sin_addr));
      mutex_unlock_static (L_INET_NTOA);

      if ((flags & SA_IP_PORT) && addr->addr.in4.sin_port)
      {
	openvpn_snprintf (name_buf, sizeof (name_buf), "%s_port", name_prefix);
	setenv_int (es, name_buf, ntohs (addr->addr.in4.sin_port));
      }
      break;
#ifdef USE_PF_INET6
    case AF_INET6:
      openvpn_snprintf (name_buf, sizeof (name_buf), "%s_ip6", name_prefix);
      getnameinfo(&addr->addr.sa, sizeof (struct sockaddr_in6),
	  buf, sizeof(buf), NULL, 0, NI_NUMERICHOST);
      setenv_str (es, name_buf, buf);

  if ((flags & SA_IP_PORT) && addr->sa.sin_port)
    {
      openvpn_snprintf (name_buf, sizeof (name_buf), "%s_port", name_prefix);
      setenv_int (es, name_buf, ntohs (addr->addr.in6.sin6_port));
      break;
#endif
  }
}

void

    {
      struct openvpn_sockaddr si;
      CLEAR (si);
      si.addr.in4.sin_family = AF_INET;
      si.addr.in4.sin_addr.s_addr = htonl (addr);
      setenv_sockaddr (es, name_prefix, &si, flags);
    }
}

struct proto_names {
  const char *short_form;
  const char *display_form;
  bool	is_dgram;
  bool	is_net;
  sa_family_t proto_af;
};

/* Indexed by PROTO_x */
static const struct proto_names proto_names[PROTO_N] = {
  {"proto-uninitialized",        "proto-NONE",0,0, AF_UNSPEC},
  {"udp",        "UDPv4",1,1, AF_INET},
  {"tcp-server", "TCPv4_SERVER",0,1, AF_INET},
  {"tcp-client", "TCPv4_CLIENT",0,1, AF_INET},
  {"tcp",        "TCPv4",0,1, AF_INET},
#ifdef USE_PF_INET6
  {"udp6"       ,"UDPv6",1,1, AF_INET6},
  {"tcp6-server","TCPv6_SERVER",0,1, AF_INET6},
  {"tcp6-client","TCPv6_CLIENT",0,1, AF_INET6},
  {"tcp6"       ,"TCPv6",0,1, AF_INET6},
#endif
};

bool
proto_is_net(int proto)
{
  if (proto < 0 || proto >= PROTO_N)
    ASSERT(0);
  return proto_names[proto].is_net;
}
bool
proto_is_dgram(int proto)
{
  if (proto < 0 || proto >= PROTO_N)
    ASSERT(0);
  return proto_names[proto].is_dgram;
}
bool
proto_is_udp(int proto)
{
  if (proto < 0 || proto >= PROTO_N)
    ASSERT(0);
  return proto_names[proto].is_dgram&&proto_names[proto].is_net;
}
bool
proto_is_tcp(int proto)
{
  if (proto < 0 || proto >= PROTO_N)
    ASSERT(0);
  return (!proto_names[proto].is_dgram)&&proto_names[proto].is_net;
}

sa_family_t 
proto_sa_family(int proto)
{
  if (proto < 0 || proto >= PROTO_N)
    ASSERT(0);
  return proto_names[proto].proto_af;
}

int
ascii2proto (const char* proto_name)
{

  return BSTR (&out);
}

int
addr_guess_family(int proto, const char *name) 
{
  sa_family_t ret;
  if (proto) {
    return proto_sa_family(proto);	/* already stamped */
  } 
#ifdef USE_PF_UNIX
  else if (name && name[0] == '/') {
    return AF_UNIX;
  }
#endif
#ifdef USE_PF_INET6
  else {
    struct addrinfo hints , *ai;
    int err;
    memset(&hints, 0, sizeof hints);
    hints.ai_flags=AI_NUMERICHOST;
    if ((err=getaddrinfo(name, NULL, &hints, &ai))==0) {
      ret=ai->ai_family;
      freeaddrinfo(ai);
      return ret;
    }
  }
#endif
  return AF_INET;	/* default */
}
const char *
addr_family_name (int af) 
{
  switch (af) {
    case AF_INET: return "AF_INET";
    case AF_INET6: return "AF_INET6";
#ifdef USE_PF_UNIX
    case AF_UNIX: return "AF_UNIX";
#endif
  }
  return "AF_UNSPEC";
}

/*
 * Given a local proto, return local proto
 * if !remote, or compatible remote proto

  ASSERT (proto >= 0 && proto < PROTO_N);
  if (remote)
    {
      switch (proto)
      {
	case PROTO_TCPv4_SERVER: return PROTO_TCPv4_CLIENT;
	case PROTO_TCPv4_CLIENT: return PROTO_TCPv4_SERVER;
#ifdef USE_PF_INET6
	case PROTO_TCPv6_SERVER: return PROTO_TCPv6_CLIENT;
	case PROTO_TCPv6_CLIENT: return PROTO_TCPv6_SERVER;
#endif
      }
    }
  return proto;
}

#if ENABLE_IP_PKTINFO

#pragma pack(1) /* needed to keep structure size consistent for 32 vs. 64-bit architectures */
struct openvpn_in4_pktinfo
{
  struct cmsghdr cmsghdr;
  struct in_pktinfo pi;
};
#ifdef USE_PF_INET6
struct openvpn_in6_pktinfo
{
  struct cmsghdr cmsghdr;
  struct in6_pktinfo pi6;
};
#endif

union openvpn_pktinfo {
      struct openvpn_in4_pktinfo cmsgpi;
#ifdef USE_PF_INET6
      struct openvpn_in6_pktinfo cmsgpi6;
#endif
};
#pragma pack()


				    struct link_socket_actual *from)
{
  struct iovec iov;
  union openvpn_pktinfo opi;
  struct msghdr mesg;
  socklen_t fromlen = sizeof (from->dest.addr);

  iov.iov_base = BPTR (buf);
  iov.iov_len = maxsize;
  mesg.msg_iov = &iov;
  mesg.msg_iovlen = 1;
  mesg.msg_name = &from->dest.addr;
  mesg.msg_namelen = fromlen;
  mesg.msg_control = &opi;
  mesg.msg_controllen = sizeof (opi);

	  && cmsg->cmsg_len >= sizeof (opi))
	{
	  struct in_pktinfo *pkti = (struct in_pktinfo *) CMSG_DATA (cmsg);
	  from->pi.in4.ipi_ifindex = pkti->ipi_ifindex;
	  from->pi.in4.ipi_spec_dst = pkti->ipi_spec_dst;
	}
#ifdef USE_PF_INET6
      else if (cmsg != NULL
	  && CMSG_NXTHDR (&mesg, cmsg) == NULL
	  && cmsg->cmsg_level == IPPROTO_IPV6 
	  && cmsg->cmsg_type == IPV6_PKTINFO
	  && cmsg->cmsg_len >= sizeof (struct openvpn_in6_pktinfo))
	{
	  struct in6_pktinfo *pkti6 = (struct in6_pktinfo *) CMSG_DATA (cmsg);
	  from->pi.in6.ipi6_ifindex = pkti6->ipi6_ifindex;
	  from->pi.in6.ipi6_addr = pkti6->ipi6_addr;
	}
#endif
    }
  return fromlen;
}

			    int maxsize,
			    struct link_socket_actual *from)
{
  socklen_t fromlen = sizeof (from->dest.addr);
  socklen_t expectedlen = af_addr_size(proto_sa_family(sock->info.proto));
  addr_zero_host(&from->dest);
  ASSERT (buf_safe (buf, maxsize));
#if ENABLE_IP_PKTINFO
  /* Both PROTO_UDPv4 and PROTO_UDPv6 */
  if (proto_is_udp(sock->info.proto) && sock->sockflags & SF_USE_IP_PKTINFO)
    fromlen = link_socket_read_udp_posix_recvmsg (sock, buf, maxsize, from);
  else
#endif
    buf->len = recvfrom (sock->sd, BPTR (buf), maxsize, 0,
			 &from->dest.addr.sa, &fromlen);
  if (buf->len >= 0 && expectedlen && fromlen != expectedlen)
    bad_address_length (fromlen, expectedlen);
  return buf->len;
}


  struct iovec iov;
  struct msghdr mesg;
  struct cmsghdr *cmsg;
  struct in_pktinfo *pkti;
  struct openvpn_pktinfo opi;

  iov.iov_base = BPTR (buf);
  iov.iov_len = BLEN (buf);
  mesg.msg_iov = &iov;
  mesg.msg_iovlen = 1;
  switch (sock->info.lsa->remote.addr.sa.sa_family)
  {
    case AF_INET: {
	  struct openvpn_in4_pktinfo opi;
	  struct in_pktinfo *pkti;
	  mesg.msg_name = &to->dest.addr.sa;
	  mesg.msg_namelen = sizeof (struct sockaddr_in);
	  mesg.msg_control = &opi;
	  mesg.msg_controllen = sizeof (opi);
	  mesg.msg_flags = 0;
	  cmsg = CMSG_FIRSTHDR (&mesg);
	  cmsg->cmsg_len = sizeof (opi);
	  cmsg->cmsg_level = SOL_IP;
	  cmsg->cmsg_type = IP_PKTINFO;
	  pkti = (struct in_pktinfo *) CMSG_DATA (cmsg);
	  pkti->ipi_ifindex = to->pi.in4.ipi_ifindex;
	  pkti->ipi_spec_dst = to->pi.in4.ipi_spec_dst;
	  pkti->ipi_addr.s_addr = 0;
	  break;
    }
#ifdef USE_PF_INET6
    case AF_INET6: {
	  struct openvpn_in6_pktinfo opi6;
	  struct in6_pktinfo *pkti6;
	  mesg.msg_name = &to->dest.addr.sa;
	  mesg.msg_namelen = sizeof (struct sockaddr_in6);
	  mesg.msg_control = &opi6;
	  mesg.msg_controllen = sizeof (opi6);
	  mesg.msg_flags = 0;
	  cmsg = CMSG_FIRSTHDR (&mesg);
	  cmsg->cmsg_len = sizeof (opi6);
	  cmsg->cmsg_level = IPPROTO_IPV6;
	  cmsg->cmsg_type = IPV6_PKTINFO;
	  pkti6 = (struct in6_pktinfo *) CMSG_DATA (cmsg);
	  pkti6->ipi6_ifindex = to->pi.in6.ipi6_ifindex;
	  pkti6->ipi6_addr = to->pi.in6.ipi6_addr;
	  break;
    }
#endif
    default: ASSERT(0);
  }
  return sendmsg (sock->sd, &mesg, 0);
}


	{
	  /* set destination address for UDP writes */
	  sock->writes.addr_defined = true;
	  sock->writes.addr = to->dest.addr.in4;
	  sock->writes.addrlen = sizeof (sock->writes.addr);

	  status = WSASendTo(

	{
	  if (io->addrlen != sizeof (io->addr))
	    bad_address_length (io->addrlen, sizeof (io->addr));
	  from->dest.addr.sa = io->addr;
	}
      else
	CLEAR (from->dest.addr.sa);
    }
  
  if (buf)

Lines 73-78 Link Here

(-)a/options.c (-15 / +35 lines)
73	#ifdef ENABLE_PKCS11	73	#ifdef ENABLE_PKCS11
74	" [PKCS11]"	74	" [PKCS11]"
75	#endif	75	#endif
		76	#ifdef ENABLE_IP_PKTINFO
		77	" [MH]"
		78	#endif
		79	#ifdef USE_PF_INET6
		80	" [PF_INET6]"
		81	#endif
76	" built on " __DATE__	82	" built on " __DATE__
77	;	83	;
78		84
Lines 93-98 Link Here
93	"--mode m : Major mode, m = 'p2p' (default, point-to-point) or 'server'.\n"	99	"--mode m : Major mode, m = 'p2p' (default, point-to-point) or 'server'.\n"
94	"--proto p : Use protocol p for communicating with peer.\n"	100	"--proto p : Use protocol p for communicating with peer.\n"
95	" p = udp (default), tcp-server, or tcp-client\n"	101	" p = udp (default), tcp-server, or tcp-client\n"
		102	#ifdef USE_PF_INET6
		103	" p = udp6, tcp6-server, or tcp6-client (IPv6)\n"
		104	#endif
96	"--connect-retry n : For --proto tcp-client, number of seconds to wait\n"	105	"--connect-retry n : For --proto tcp-client, number of seconds to wait\n"
97	" between connection retries (default=%d).\n"	106	" between connection retries (default=%d).\n"
98	"--connect-timeout n : For --proto tcp-client, connection timeout (in seconds).\n"	107	"--connect-timeout n : For --proto tcp-client, connection timeout (in seconds).\n"
Lines 1488-1497 Link Here
1488	* Sanity check on TCP mode options	1497	* Sanity check on TCP mode options
1489	*/	1498	*/
1490		1499
1491	if (ce->connect_retry_defined && ce->proto != PROTO_TCPv4_CLIENT)	1500	if (ce->connect_retry_defined && ce->proto != PROTO_TCPv4_CLIENT && ce->proto != PROTO_TCPv6_CLIENT)
1492	msg (M_USAGE, "--connect-retry doesn't make sense unless also used with --proto tcp-client");	1501	msg (M_USAGE, "--connect-retry doesn't make sense unless also used with --proto tcp-client");
1493		1502
1494	if (ce->connect_timeout_defined && ce->proto != PROTO_TCPv4_CLIENT)	1503	if (ce->connect_timeout_defined && ce->proto != PROTO_TCPv4_CLIENT && ce->proto != PROTO_TCPv6_CLIENT)
1495	msg (M_USAGE, "--connect-timeout doesn't make sense unless also used with --proto tcp-client");	1504	msg (M_USAGE, "--connect-timeout doesn't make sense unless also used with --proto tcp-client");
1496		1505
1497	/*	1506	/*
Lines 1501-1507 Link Here
1501	msg (M_USAGE, "only one of --tun-mtu or --link-mtu may be defined (note that --ifconfig implies --link-mtu %d)", LINK_MTU_DEFAULT);	1510	msg (M_USAGE, "only one of --tun-mtu or --link-mtu may be defined (note that --ifconfig implies --link-mtu %d)", LINK_MTU_DEFAULT);
1502		1511
1503	#ifdef ENABLE_OCC	1512	#ifdef ENABLE_OCC
1504	if (ce->proto != PROTO_UDPv4 && options->mtu_test)	1513	if (!proto_is_udp(ce->proto) && options->mtu_test)
1505	msg (M_USAGE, "--mtu-test only makes sense with --proto udp");	1514	msg (M_USAGE, "--mtu-test only makes sense with --proto udp");
1506	#endif	1515	#endif
1507		1516
Lines 1514-1520 Link Here
1514	* Sanity check on --local, --remote, and --ifconfig	1523	* Sanity check on --local, --remote, and --ifconfig
1515	*/	1524	*/
1516		1525
1517	if (string_defined_equal (ce->local, ce->remote)	1526
		1527	if (proto_is_net(ce->proto)
		1528	&& string_defined_equal (ce->local, ce->remote)
1518	&& ce->local_port == ce->remote_port)	1529	&& ce->local_port == ce->remote_port)
1519	msg (M_USAGE, "--remote and --local addresses are the same");	1530	msg (M_USAGE, "--remote and --local addresses are the same");
1520		1531
Lines 1575-1590 Link Here
1575	*/	1586	*/
1576		1587
1577	#ifdef ENABLE_FRAGMENT	1588	#ifdef ENABLE_FRAGMENT
1578	if (ce->proto != PROTO_UDPv4 && options->fragment)	1589	if (!proto_is_udp(ce->proto) && options->fragment)
1579	msg (M_USAGE, "--fragment can only be used with --proto udp");	1590	msg (M_USAGE, "--fragment can only be used with --proto udp");
1580	#endif	1591	#endif
1581		1592
1582	#ifdef ENABLE_OCC	1593	#ifdef ENABLE_OCC
1583	if (ce->proto != PROTO_UDPv4 && options->explicit_exit_notification)	1594	if (!proto_is_udp(ce->proto) && options->explicit_exit_notification)
1584	msg (M_USAGE, "--explicit-exit-notify can only be used with --proto udp");	1595	msg (M_USAGE, "--explicit-exit-notify can only be used with --proto udp");
1585	#endif	1596	#endif
1586		1597
1587	if (!ce->remote && ce->proto == PROTO_TCPv4_CLIENT)	1598	if (!ce->remote && (ce->proto == PROTO_TCPv4_CLIENT\|\|ce->proto == PROTO_TCPv6_CLIENT))
1588	msg (M_USAGE, "--remote MUST be used in TCP Client mode");	1599	msg (M_USAGE, "--remote MUST be used in TCP Client mode");
1589		1600
1590	#ifdef ENABLE_HTTP_PROXY	1601	#ifdef ENABLE_HTTP_PROXY
Lines 1602-1608 Link Here
1602	msg (M_USAGE, "--socks-proxy can not be used in TCP Server mode");	1613	msg (M_USAGE, "--socks-proxy can not be used in TCP Server mode");
1603	#endif	1614	#endif
1604		1615
1605	if (ce->proto == PROTO_TCPv4_SERVER && connection_list_defined (options))	1616	if ((ce->proto == PROTO_TCPv4_SERVER\|\|ce->proto == PROTO_TCPv6_SERVER)
		1617	&& connection_list_defined (options))
1606	msg (M_USAGE, "TCP server mode allows at most one --remote address");	1618	msg (M_USAGE, "TCP server mode allows at most one --remote address");
1607		1619
1608	#if P2MP_SERVER	1620	#if P2MP_SERVER
Lines 1616-1622 Link Here
1616	msg (M_USAGE, "--mode server only works with --dev tun or --dev tap");	1628	msg (M_USAGE, "--mode server only works with --dev tun or --dev tap");
1617	if (options->pull)	1629	if (options->pull)
1618	msg (M_USAGE, "--pull cannot be used with --mode server");	1630	msg (M_USAGE, "--pull cannot be used with --mode server");
1619	if (!(ce->proto == PROTO_UDPv4 \|\| ce->proto == PROTO_TCPv4_SERVER))	1631	if (!(proto_is_udp(ce->proto) \|\| ce->proto == PROTO_TCPv4_SERVER \|\| ce->proto == PROTO_TCPv6_SERVER))
1620	msg (M_USAGE, "--mode server currently only supports --proto udp or --proto tcp-server");	1632	msg (M_USAGE, "--mode server currently only supports --proto udp or --proto tcp-server");
1621	#if PORT_SHARE	1633	#if PORT_SHARE
1622	if ((options->port_share_host \|\| options->port_share_port) && ce->proto != PROTO_TCPv4_SERVER)	1634	if ((options->port_share_host \|\| options->port_share_port) && ce->proto != PROTO_TCPv4_SERVER)
Lines 1648-1656 Link Here
1648	msg (M_USAGE, "--inetd cannot be used with --mode server");	1660	msg (M_USAGE, "--inetd cannot be used with --mode server");
1649	if (options->ipchange)	1661	if (options->ipchange)
1650	msg (M_USAGE, "--ipchange cannot be used with --mode server (use --client-connect instead)");	1662	msg (M_USAGE, "--ipchange cannot be used with --mode server (use --client-connect instead)");
1651	if (!(ce->proto == PROTO_UDPv4 \|\| ce->proto == PROTO_TCPv4_SERVER))	1663	if (!(proto_is_dgram(ce->proto) \|\| ce->proto == PROTO_TCPv4_SERVER \|\| ce->proto == PROTO_TCPv6_SERVER ))
1652	msg (M_USAGE, "--mode server currently only supports --proto udp or --proto tcp-server");	1664	msg (M_USAGE, "--mode server currently only supports --proto udp or --proto tcp-server (also udp6/tcp6)");
1653	if (ce->proto != PROTO_UDPv4 && (options->cf_max \|\| options->cf_per))	1665	if (!proto_is_udp(ce->proto) && (options->cf_max \|\| options->cf_per))
1654	msg (M_USAGE, "--connect-freq only works with --mode server --proto udp. Try --max-clients instead.");	1666	msg (M_USAGE, "--connect-freq only works with --mode server --proto udp. Try --max-clients instead.");
1655	if (!(dev == DEV_TYPE_TAP \|\| (dev == DEV_TYPE_TUN && options->topology == TOP_SUBNET)) && options->ifconfig_pool_netmask)	1667	if (!(dev == DEV_TYPE_TAP \|\| (dev == DEV_TYPE_TUN && options->topology == TOP_SUBNET)) && options->ifconfig_pool_netmask)
1656	msg (M_USAGE, "The third parameter to --ifconfig-pool (netmask) is only valid in --dev tap mode");	1668	msg (M_USAGE, "The third parameter to --ifconfig-pool (netmask) is only valid in --dev tap mode");
Lines 1730-1736 Link Here
1730	/*	1742	/*
1731	* Check consistency of replay options	1743	* Check consistency of replay options
1732	*/	1744	*/
1733	if ((ce->proto != PROTO_UDPv4)	1745	if ((!proto_is_udp(ce->proto))
1734	&& (options->replay_window != defaults.replay_window	1746	&& (options->replay_window != defaults.replay_window
1735	\|\| options->replay_time != defaults.replay_time))	1747	\|\| options->replay_time != defaults.replay_time))
1736	msg (M_USAGE, "--replay-window only makes sense with --proto udp");	1748	msg (M_USAGE, "--replay-window only makes sense with --proto udp");
Lines 1892-1897 Link Here
1892	{	1904	{
1893	if (ce->proto == PROTO_TCPv4)	1905	if (ce->proto == PROTO_TCPv4)
1894	ce->proto = PROTO_TCPv4_SERVER;	1906	ce->proto = PROTO_TCPv4_SERVER;
		1907	#ifdef USE_PF_INET6
		1908	else if (ce->proto == PROTO_TCPv6)
		1909	ce->proto = PROTO_TCPv6_SERVER;
		1910	#endif
1895	}	1911	}
1896	#endif	1912	#endif
1897	#if P2MP	1913	#if P2MP
Lines 1899-1908 Link Here
1899	{	1915	{
1900	if (ce->proto == PROTO_TCPv4)	1916	if (ce->proto == PROTO_TCPv4)
1901	ce->proto = PROTO_TCPv4_CLIENT;	1917	ce->proto = PROTO_TCPv4_CLIENT;
1902	}	1918	#ifdef USE_PF_INET6
		1919	else if (ce->proto == PROTO_TCPv6)
		1920	ce->proto = PROTO_TCPv6_CLIENT;
		1921	#endif
		1922	}
1903	#endif	1923	#endif
1904		1924
1905	if (ce->proto == PROTO_TCPv4_CLIENT && !ce->local && !ce->local_port_defined && !ce->bind_defined)	1925	if ((ce->proto == PROTO_TCPv4_CLIENT\|\|ce->proto == PROTO_TCPv6_CLIENT) && !ce->local && !ce->local_port_defined && !ce->bind_defined)
1906	ce->bind_local = false;	1926	ce->bind_local = false;
1907		1927
1908	#ifdef ENABLE_SOCKS	1928	#ifdef ENABLE_SOCKS

Return to bug 183457

Lines 215-220 } Link Here

(-)a/buffer.c (+13 lines)
215	return ret;	215	return ret;
216	}	216	}
217		217
		218	void buf_puts(struct buffer buf, const char str)
		219	{
		220	uint8_t *ptr = BEND (buf);
		221	int cap = buf_forward_capacity (buf);
		222	if (cap > 0)
		223	{
		224	strncpynt ((char *)ptr,str, cap);
		225	(buf->data + buf->capacity - 1) = 0; / windows vsnprintf needs this */
		226	buf->len += (int) strlen ((char *)ptr);
		227	}
		228	}
		229
		230
218	/*	231	/*
219	* This is necessary due to certain buggy implementations of snprintf,	232	* This is necessary due to certain buggy implementations of snprintf,
220	* that don't guarantee null termination for size > 0.	233	* that don't guarantee null termination for size > 0.

Lines 1669-1677 man_settings_init (struct man_settings * Link Here

(-)a/manage.c (-5 / +5 lines)
1669	/*	1669	/*
1670	* Initialize socket address	1670	* Initialize socket address
1671	*/	1671	*/
1672	ms->local.sa.sin_family = AF_INET;	1672	ms->local.addr.in4.sin_family = AF_INET;
1673	ms->local.sa.sin_addr.s_addr = 0;	1673	ms->local.addr.in4.sin_addr.s_addr = 0;
1674	ms->local.sa.sin_port = htons (port);	1674	ms->local.addr.in4.sin_port = htons (port);
1675		1675
1676	/*	1676	/*
1677	* Run management over tunnel, or	1677	* Run management over tunnel, or
Lines 1683-1689 man_settings_init (struct man_settings * Link Here
1683	}	1683	}
1684	else	1684	else
1685	{	1685	{
1686	ms->local.sa.sin_addr.s_addr = getaddr	1686	ms->local.addr.in4.sin_addr.s_addr = getaddr
1687	(GETADDR_RESOLVE\|GETADDR_WARN_ON_SIGNAL\|GETADDR_FATAL, addr, 0, NULL, NULL);	1687	(GETADDR_RESOLVE\|GETADDR_WARN_ON_SIGNAL\|GETADDR_FATAL, addr, 0, NULL, NULL);
1688	}	1688	}
1689		1689
Lines 2022-2028 management_post_tunnel_open (struct mana Link Here
2022	&& man->connection.state == MS_INITIAL)	2022	&& man->connection.state == MS_INITIAL)
2023	{	2023	{
2024	/* listen on our local TUN/TAP IP address */	2024	/* listen on our local TUN/TAP IP address */
2025	man->settings.local.sa.sin_addr.s_addr = htonl (tun_local_ip);	2025	man->settings.local.addr.in4.sin_addr.s_addr = htonl (tun_local_ip);
2026	man_connection_init (man);	2026	man_connection_init (man);
2027	}	2027	}
2028		2028

Lines 1053-1060 multi_learn_in_addr_t (struct multi_cont Link Here

(-)a/multi.c (-15 / +10 lines)
1053	struct mroute_addr addr;	1053	struct mroute_addr addr;
1054		1054
1055	CLEAR (remote_si);	1055	CLEAR (remote_si);
1056	remote_si.sa.sin_family = AF_INET;	1056	remote_si.addr.in4.sin_family = AF_INET;
1057	remote_si.sa.sin_addr.s_addr = htonl (a);	1057	remote_si.addr.in4.sin_addr.s_addr = htonl (a);
1058	ASSERT (mroute_extract_openvpn_sockaddr (&addr, &remote_si, false));	1058	ASSERT (mroute_extract_openvpn_sockaddr (&addr, &remote_si, false));
1059		1059
1060	if (netbits >= 0)	1060	if (netbits >= 0)
Lines 2464-2472 management_callback_kill_by_addr (void * Link Here
2464	int count = 0;	2464	int count = 0;
2465		2465
2466	CLEAR (saddr);	2466	CLEAR (saddr);
2467	saddr.sa.sin_family = AF_INET;	2467	saddr.addr.in4.sin_family = AF_INET;
2468	saddr.sa.sin_addr.s_addr = htonl (addr);	2468	saddr.addr.in4.sin_addr.s_addr = htonl (addr);
2469	saddr.sa.sin_port = htons (port);	2469	saddr.addr.in4.sin_port = htons (port);
2470	if (mroute_extract_openvpn_sockaddr (&maddr, &saddr, true))	2470	if (mroute_extract_openvpn_sockaddr (&maddr, &saddr, true))
2471	{	2471	{
2472	hash_iterator_init (m->iter, &hi, true);	2472	hash_iterator_init (m->iter, &hi, true);
Lines 2614-2631 tunnel_server (struct context *top) Link Here
2614	{	2614	{
2615	ASSERT (top->options.mode == MODE_SERVER);	2615	ASSERT (top->options.mode == MODE_SERVER);
2616		2616
2617	switch (top->options.ce.proto) {	2617	if (proto_is_dgram(top->options.ce.proto))
2618	case PROTO_UDPv4:	2618	tunnel_server_udp(top);
2619	tunnel_server_udp (top);	2619	else
2620	break;	2620	tunnel_server_tcp(top);
2621	case PROTO_TCPv4_SERVER:
2622	tunnel_server_tcp (top);
2623	break;
2624	default:
2625	ASSERT (0);
2626	}
2627	}	2621	}
2628		2622
		2623
2629	#else	2624	#else
2630	static void dummy(void) {}	2625	static void dummy(void) {}
2631	#endif /* P2MP_SERVER */	2626	#endif /* P2MP_SERVER */

Line 0 Link Here

(-)a/jjo-tests/libtest.sh (+115 lines)
		1	#!/bin/bash
		2
		3	typeset -i test_num=0 # increments w/each test_define
		4	typeset test_msg # prefix: "test nr#" for msgs
		5	typeset test_name # test name given
		6	typeset test_sanename # test name with all whitespace (and alike) replaced by '_'
		7
		8	TEST_CLEANUP=":"
		9
		10	say () {
		11	echo "$@" >&3
		12	}
		13	err () {
		14	echo "$@" >&4
		15	}
		16	debug () {
		17	echo "$@" >&4
		18	}
		19	test_define() {
		20	test_name="$*"
		21	test_sanename="$(echo -n $test_name\| tr -c '[A-Za-z0-9._]' _ )"
		22	test_num=test_num+1
		23	test_msg="test $test_num"
		24	test_bg_cleanup
		25	}
		26	test_expect_success () {
		27	local msg="$1"
		28	test $# -ge 2 \|\| { err "usage error: test_expect_failure msg cmd args ..."; return 1; }
		29	say -n "$test_msg: -- $msg (expecting success) "
		30	shift
		31	(eval "$@" 4>&1) && { say -e "\n$test_msg: OK %%% $test_sanename" ; return 0 ; }
		32	say -e "\n$test_msg: FAILED %%% $test_sanename"
		33	return 1
		34	}
		35
		36	test_expect_failure () {
		37	local msg="$1"
		38	test $# -ge 2 \|\| { err "usage error: test_expect_failure msg cmd args ..."; return 1;}
		39	say -n "$test_msg: -- $msg (expecting failure) "
		40	shift
		41	(eval "$@") && { say -e "\n$test_msg: FAILED %%% $test_sanename" >&3 ; return 0 ; }
		42	say -e "\n$test_msg: OK %%% $test_sanename"
		43	return 1
		44	}
		45
		46	test_bg_egrep() {
		47	local nsecs="$1"
		48	local txt="$2"
		49	local ret
		50	shift 2
		51	test_expect_success "$test_name" \
		52	"set -m ; $@ &> $t/out-$test_sanename &
		53	s=1;
		54	for i in \$(seq 1 $nsecs);do
		55	say -n '.'
		56	kill -0 %1 \|\| { egrep failed $t/out-$test_sanename >&4; break; }
		57	o=\$(egrep \"$txt\" $t/out-$test_sanename ) && { debug \$o; s=0; break; }
		58	sleep 1;
		59	done;
		60	kill %1
		61	wait
		62	exit \$s
		63	" 2>/dev/null 4>$t/err
		64	ret=$?
65	test $ret -eq 0 && return 0
66	say "$test_msg: see: $t/out-$test_sanename*"
67	return $ret
68	}
69	# run command in current shell ignoring stderr, evals args passed
70	quiet2() {
71	#backup fd=2
72	exec 250>&2
73	exec 2>/dev/null
74	eval "$@"
75	#close auxfd
76	exec 2>&250
77	exec 250>&-
78	}
79	test_bg_prev(){ local out=$t/out-$test_sanename-prev; $@ >& $out & }
80	test_bg_cleanup() { quiet2 "$TEST_CLEANUP;${@:-:};kill % 2>/dev/null;wait" ;}
81	test_set_cleanup () { TEST_CLEANUP="${*:-:}" ;}
82
83	t=/tmp
84	exec 3>&1
85	exec 4>&2
86
87	#=========
88
89	ln -sf $PWD/openvpn $t/openvpn-test
90	export OPENVPN=$t/openvpn-test
91
92	test_set_cleanup "killall $OPENVPN"
93
94	trap 'test_bg_cleanup;exit' 0 2 15
95
96	test_define "UDP6 loopback"
97	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp6-0-loopback-self.sh
98
99	test_define "UDP6 loopback byname"
100	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp6-0-loopback-byname.sh
101
102	test_define "TCP6 loopback"
103	test_bg_prev ../jjo-tests/run-tcp6-0-loopback-server.sh
104	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp6-0-loopback-client.sh
105
106	test_define "TCP6 loopback byname"
107	test_bg_prev ../jjo-tests/run-tcp6-0-loopback-server-byname.sh
108	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp6-0-loopback-client-byname.sh
109
110	test_define "UDP4 loopback"
111	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-udp4-0-loopback-self.sh
112
113	test_define "TCP4 loopback"
114	test_bg_prev ../jjo-tests/run-tcp4-0-loopback-server.sh
115	test_bg_egrep 30 "Initialization Sequence Completed" ../jjo-tests/run-tcp4-0-loopback-client.sh

Lines 226-250 bool mroute_extract_openvpn_sockaddr (st Link Here

(-)a/mroute.c (-4 / +56 lines)
226	const struct openvpn_sockaddr *osaddr,	226	const struct openvpn_sockaddr *osaddr,
227	bool use_port)	227	bool use_port)
228	{	228	{
229	if (osaddr->sa.sin_family == AF_INET)	229	switch (osaddr->addr.sa.sa_family)
		230	{
		231	case AF_INET:
230	{	232	{
231	if (use_port)	233	if (use_port)
232	{	234	{
233	addr->type = MR_ADDR_IPV4 \| MR_WITH_PORT;	235	addr->type = MR_ADDR_IPV4 \| MR_WITH_PORT;
234	addr->netbits = 0;	236	addr->netbits = 0;
235	addr->len = 6;	237	addr->len = 6;
236	memcpy (addr->addr, &osaddr->sa.sin_addr.s_addr, 4);	238	memcpy (addr->addr, &osaddr->addr.in4.sin_addr.s_addr, 4);
237	memcpy (addr->addr + 4, &osaddr->sa.sin_port, 2);	239	memcpy (addr->addr + 4, &osaddr->addr.in4.sin_port, 2);
238	}	240	}
239	else	241	else
240	{	242	{
241	addr->type = MR_ADDR_IPV4;	243	addr->type = MR_ADDR_IPV4;
242	addr->netbits = 0;	244	addr->netbits = 0;
243	addr->len = 4;	245	addr->len = 4;
244	memcpy (addr->addr, &osaddr->sa.sin_addr.s_addr, 4);	246	memcpy (addr->addr, &osaddr->addr.in4.sin_addr.s_addr, 4);
245	}	247	}
246	return true;	248	return true;
247	}	249	}
		250	#ifdef USE_PF_INET6
		251	case AF_INET6:
		252	if (use_port)
		253	{
		254	addr->type = MR_ADDR_IPV6 \| MR_WITH_PORT;
		255	addr->netbits = 0;
		256	addr->len = 18;
		257	memcpy (addr->addr, &osaddr->addr.in6.sin6_addr, 16);
		258	memcpy (addr->addr + 16, &osaddr->addr.in6.sin6_port, 2);
		259	}
		260	else
		261	{
		262	addr->type = MR_ADDR_IPV6;
		263	addr->netbits = 0;
		264	addr->len = 16;
		265	memcpy (addr->addr, &osaddr->addr.in6.sin6_addr, 16);
		266	}
		267	return true;
		268	#endif
		269	}
248	return false;	270	return false;
249	}	271	}
250		272
Lines 337-343 mroute_addr_print (const struct mroute_a Link Here
337	}	359	}
338	break;	360	break;
339	case MR_ADDR_IPV6:	361	case MR_ADDR_IPV6:
		362	#ifdef USE_PF_INET6
		363	{
		364	struct buffer buf;
		365	struct sockaddr_in6 sin6;
		366	int port;
		367	char buf6[INET6_ADDRSTRLEN] = "";
		368	memset(&sin6, 0, sizeof sin6);
		369	sin6.sin6_family = AF_INET6;
		370	buf_set_read (&buf, maddr.addr, maddr.len);
		371	if (buf_read(&buf, &sin6.sin6_addr, sizeof (sin6.sin6_addr)))
		372	{
		373	if (getnameinfo((struct sockaddr *)&sin6, sizeof (struct sockaddr_in6),
		374	buf6, sizeof (buf6), NULL, 0, NI_NUMERICHOST) != 0)
		375	{
		376	buf_printf (&out, "MR_ADDR_IPV6 getnameinfo() err");
		377	break;
		378	}
		379	buf_puts (&out, buf6);
		380	if (maddr.type & MR_WITH_NETBITS)
		381	buf_printf (&out, "/%d", maddr.netbits);
		382	if (maddr.type & MR_WITH_PORT)
		383	{
		384	port = buf_read_u16 (&buf);
		385	if (port >= 0)
		386	buf_printf (&out, ":%d", port);
		387	}
		388	}
		389	}
		390	#else /* old pre IPV6 1-line code: */
340	buf_printf (&out, "IPV6");	391	buf_printf (&out, "IPV6");
		392	#endif
341	break;	393	break;
342	default:	394	default:
343	buf_printf (&out, "UNKNOWN");	395	buf_printf (&out, "UNKNOWN");

Lines 174-182 recv_socks_reply (socket_descriptor_t sd Link Here

(-)a/socks.c (-9 / +9 lines)
174		174
175	if (addr != NULL)	175	if (addr != NULL)
176	{	176	{
177	addr->sa.sin_family = AF_INET;	177	addr->addr.in4.sin_family = AF_INET;
178	addr->sa.sin_addr.s_addr = htonl (INADDR_ANY);	178	addr->addr.in4.sin_addr.s_addr = htonl (INADDR_ANY);
179	addr->sa.sin_port = htons (0);	179	addr->addr.in4.sin_port = htons (0);
180	}	180	}
181		181
182	while (len < 4 + alen + 2)	182	while (len < 4 + alen + 2)
Lines 263-270 recv_socks_reply (socket_descriptor_t sd Link Here
263	/* ATYP == 1 (IP V4 address) */	263	/* ATYP == 1 (IP V4 address) */
264	if (atyp == '\x01' && addr != NULL)	264	if (atyp == '\x01' && addr != NULL)
265	{	265	{
266	memcpy (&addr->sa.sin_addr, buf + 4, sizeof (addr->sa.sin_addr));	266	memcpy (&addr->addr.in4.sin_addr, buf + 4, sizeof (addr->addr.in4.sin_addr));
267	memcpy (&addr->sa.sin_port, buf + 8, sizeof (addr->sa.sin_port));	267	memcpy (&addr->addr.in4.sin_port, buf + 8, sizeof (addr->addr.in4.sin_port));
268	}	268	}
269		269
270		270
Lines 382-389 socks_process_incoming_udp (struct buffe Link Here
382	if (atyp != 1) /* ATYP == 1 (IP V4) */	382	if (atyp != 1) /* ATYP == 1 (IP V4) */
383	goto error;	383	goto error;
384		384
385	buf_read (buf, &from->dest.sa.sin_addr, sizeof (from->dest.sa.sin_addr));	385	buf_read (buf, &from->dest.addr.in4.sin_addr, sizeof (from->dest.addr.in4.sin_addr));
386	buf_read (buf, &from->dest.sa.sin_port, sizeof (from->dest.sa.sin_port));	386	buf_read (buf, &from->dest.addr.in4.sin_port, sizeof (from->dest.addr.in4.sin_port));
387		387
388	return;	388	return;
389		389
Lines 415-422 socks_process_outgoing_udp (struct buffe Link Here
415	buf_write_u16 (&head, 0); /* RSV = 0 */	415	buf_write_u16 (&head, 0); /* RSV = 0 */
416	buf_write_u8 (&head, 0); /* FRAG = 0 */	416	buf_write_u8 (&head, 0); /* FRAG = 0 */
417	buf_write_u8 (&head, '\x01'); /* ATYP = 1 (IP V4) */	417	buf_write_u8 (&head, '\x01'); /* ATYP = 1 (IP V4) */
418	buf_write (&head, &to->dest.sa.sin_addr, sizeof (to->dest.sa.sin_addr));	418	buf_write (&head, &to->dest.addr.in4.sin_addr, sizeof (to->dest.addr.in4.sin_addr));
419	buf_write (&head, &to->dest.sa.sin_port, sizeof (to->dest.sa.sin_port));	419	buf_write (&head, &to->dest.addr.in4.sin_port, sizeof (to->dest.addr.in4.sin_port));
420		420
421	return 10;	421	return 10;
422	}	422	}