Re #1933: Update pjnath-test for IPv6 support.

git-svn-id: http://svn.pjsip.org/repos/pjproject/trunk@5350 74dad513-b988-da41-8d7b-12977e46ad98

8 files changed, 470 insertions, 196 deletions

diff --git a/pjnath/src/pjnath-test/ice_test.c b/pjnath/src/pjnath-test/ice_test.c
index 4317cc7a..dfd7b84d 100644
--- a/pjnath/src/pjnath-test/ice_test.c
+++ b/pjnath/src/pjnath-test/ice_test.c
@@ -39,12 +39,14 @@ enum
 {
     WRONG_TURN	= 1,
     DEL_ON_ERR	= 2,
+    CLIENT_IPV4	= 4,
+    CLIENT_IPV6	= 8
 };
 
-
 /* Test results */
 struct test_result
 {
+    pj_status_t start_status;	/* start ice successful?	*/	
     pj_status_t	init_status;	/* init successful?		*/
     pj_status_t	nego_status;	/* negotiation successful?	*/
     unsigned	rx_cnt[4];	/* Number of data received	*/
@@ -101,7 +103,8 @@ struct test_sess
 
     struct sess_param	*param;
 
-    test_server		*server;
+    test_server		*server1;   /* Test server for IPv4.	*/
+    test_server		*server2;   /* Test server for IPv6.	*/
 
     pj_thread_t		*worker_threads[MAX_THREADS];
 
@@ -121,23 +124,89 @@ static void ice_on_ice_complete(pj_ice_strans *ice_st,
 			        pj_status_t status);
 static void destroy_sess(struct test_sess *sess, unsigned wait_msec);
 
+static void set_stun_turn_cfg(struct ice_ept *ept, 
+				     pj_ice_strans_cfg *ice_cfg, 
+				     char *serverip,
+				     pj_bool_t use_ipv6) 
+{        
+    if (ept->cfg.enable_stun & YES) {
+	unsigned stun_idx = ice_cfg->stun_tp_cnt++;
+	pj_ice_strans_stun_cfg_default(&ice_cfg->stun_tp[stun_idx]);
+
+	if ((ept->cfg.enable_stun & SRV) == SRV) {
+	    ice_cfg->stun_tp[stun_idx].server = pj_str(SRV_DOMAIN);
+	} else {
+	    ice_cfg->stun_tp[stun_idx].server = pj_str(serverip);
+	}
+	ice_cfg->stun_tp[stun_idx].port = STUN_SERVER_PORT;
+
+	ice_cfg->stun_tp[stun_idx].af = GET_AF(use_ipv6);
+    }
+    ice_cfg->stun.af = GET_AF(use_ipv6);
+    if (ept->cfg.enable_host == 0) {	
+	ice_cfg->stun.max_host_cands = 0;
+    } else {
+	//ice_cfg.stun.no_host_cands = PJ_FALSE;	
+	ice_cfg->stun.loop_addr = PJ_TRUE;
+    }
+
+    if (ept->cfg.enable_turn & YES) {
+	unsigned turn_idx = ice_cfg->turn_tp_cnt++;	
+	pj_ice_strans_turn_cfg_default(&ice_cfg->turn_tp[turn_idx]);
+
+	if ((ept->cfg.enable_turn & SRV) == SRV) {
+	    ice_cfg->turn_tp[turn_idx].server = pj_str(SRV_DOMAIN);
+	} else {
+	    ice_cfg->turn_tp[turn_idx].server = pj_str(serverip);
+	}
+	ice_cfg->turn_tp[turn_idx].port = TURN_SERVER_PORT;
+	ice_cfg->turn_tp[turn_idx].conn_type = PJ_TURN_TP_UDP;
+	ice_cfg->turn_tp[turn_idx].auth_cred.type = PJ_STUN_AUTH_CRED_STATIC;
+	ice_cfg->turn_tp[turn_idx].auth_cred.data.static_cred.realm =
+	    pj_str(SRV_DOMAIN);
+	if (ept->cfg.client_flag & WRONG_TURN)
+	    ice_cfg->turn_tp[turn_idx].auth_cred.data.static_cred.username =
+	    pj_str("xxx");
+	else
+	    ice_cfg->turn_tp[turn_idx].auth_cred.data.static_cred.username =
+	    pj_str(TURN_USERNAME);
+
+	ice_cfg->turn_tp[turn_idx].auth_cred.data.static_cred.data_type =
+	    PJ_STUN_PASSWD_PLAIN;
+	ice_cfg->turn_tp[turn_idx].auth_cred.data.static_cred.data =
+	    pj_str(TURN_PASSWD);
+	
+	ice_cfg->turn_tp[turn_idx].af = GET_AF(use_ipv6);
+    }    
+}
+
 /* Create ICE stream transport */
 static int create_ice_strans(struct test_sess *test_sess,
-			     struct ice_ept *ept,
+			     struct ice_ept *ept,			     
 			     pj_ice_strans **p_ice)
 {
     pj_ice_strans *ice;
     pj_ice_strans_cb ice_cb;
     pj_ice_strans_cfg ice_cfg;
     pj_sockaddr hostip;
-    char serverip[PJ_INET6_ADDRSTRLEN];
+    char serveripv4[PJ_INET6_ADDRSTRLEN];
+    char serveripv6[PJ_INET6_ADDRSTRLEN];
     pj_status_t status;
+    unsigned flag = (ept->cfg.client_flag)?ept->cfg.client_flag:CLIENT_IPV4;
 
     status = pj_gethostip(pj_AF_INET(), &hostip);
     if (status != PJ_SUCCESS)
 	return -1030;
 
-    pj_sockaddr_print(&hostip, serverip, sizeof(serverip), 0);
+    pj_sockaddr_print(&hostip, serveripv4, sizeof(serveripv4), 0);
+
+    if (flag & CLIENT_IPV6) {
+	status = pj_gethostip(pj_AF_INET6(), &hostip);    
+	if (status != PJ_SUCCESS)
+	    return -1031;
+
+	pj_sockaddr_print(&hostip, serveripv6, sizeof(serveripv6), 0);
+    }
 
     /* Init callback structure */
     pj_bzero(&ice_cb, sizeof(ice_cb));
@@ -150,39 +219,12 @@ static int create_ice_strans(struct test_sess *test_sess,
     if ((ept->cfg.enable_stun & SRV)==SRV || (ept->cfg.enable_turn & SRV)==SRV)
 	ice_cfg.resolver = test_sess->resolver;
 
-    if (ept->cfg.enable_stun & YES) {
-	if ((ept->cfg.enable_stun & SRV) == SRV) {
-	    ice_cfg.stun.server = pj_str(SRV_DOMAIN);
-	} else {
-	    ice_cfg.stun.server = pj_str(serverip);
-	}
-	ice_cfg.stun.port = STUN_SERVER_PORT;
+    if (flag & CLIENT_IPV4) {
+	set_stun_turn_cfg(ept, &ice_cfg, serveripv4, PJ_FALSE);
     }
 
-    if (ept->cfg.enable_host == 0) {
-	ice_cfg.stun.max_host_cands = 0;
-    } else {
-	//ice_cfg.stun.no_host_cands = PJ_FALSE;
-	ice_cfg.stun.loop_addr = PJ_TRUE;
-    }
-
-
-    if (ept->cfg.enable_turn & YES) {
-	if ((ept->cfg.enable_turn & SRV) == SRV) {
-	    ice_cfg.turn.server = pj_str(SRV_DOMAIN);
-	} else {
-	    ice_cfg.turn.server = pj_str(serverip);
-	}
-	ice_cfg.turn.port = TURN_SERVER_PORT;
-	ice_cfg.turn.conn_type = PJ_TURN_TP_UDP;
-	ice_cfg.turn.auth_cred.type = PJ_STUN_AUTH_CRED_STATIC;
-	ice_cfg.turn.auth_cred.data.static_cred.realm = pj_str(SRV_DOMAIN);
-	if (ept->cfg.client_flag & WRONG_TURN)
-	    ice_cfg.turn.auth_cred.data.static_cred.username = pj_str("xxx");
-	else
-	    ice_cfg.turn.auth_cred.data.static_cred.username = pj_str(TURN_USERNAME);
-	ice_cfg.turn.auth_cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
-	ice_cfg.turn.auth_cred.data.static_cred.data = pj_str(TURN_PASSWD);
+    if (flag & CLIENT_IPV6) {
+	set_stun_turn_cfg(ept, &ice_cfg, serveripv6, PJ_TRUE);
     }
 
     /* Create ICE stream transport */
@@ -215,7 +257,7 @@ static int create_sess(pj_stun_config *stun_cfg,
     pj_str_t ns_ip;
     pj_uint16_t ns_port;
     unsigned flags;
-    pj_status_t status;
+    pj_status_t status = PJ_SUCCESS;
 
     /* Create session structure */
     pool = pj_pool_create(mem, "testsess", 512, 512, NULL);
@@ -232,31 +274,53 @@ static int create_sess(pj_stun_config *stun_cfg,
 
     /* Create server */
     flags = server_flag;
-    status = create_test_server(stun_cfg, flags, SRV_DOMAIN, &sess->server);
+    if (flags & SERVER_IPV4) {
+	status = create_test_server(stun_cfg, (flags & ~SERVER_IPV6), 
+				    SRV_DOMAIN, &sess->server1);
+    }
+
+    if ((status == PJ_SUCCESS) && (flags & SERVER_IPV6)) {
+	status = create_test_server(stun_cfg, (flags & ~SERVER_IPV4), 
+				    SRV_DOMAIN, &sess->server2);
+    }
+
     if (status != PJ_SUCCESS) {
 	app_perror(INDENT "error: create_test_server()", status);
 	destroy_sess(sess, 500);
 	return -10;
     }
-    sess->server->turn_respond_allocate =
-	sess->server->turn_respond_refresh = PJ_TRUE;
+    if (flags & SERVER_IPV4) {
+	sess->server1->turn_respond_allocate =
+	    sess->server1->turn_respond_refresh = PJ_TRUE;
+    }
 
-    /* Create resolver */
-    status = pj_dns_resolver_create(mem, NULL, 0, stun_cfg->timer_heap,
-				    stun_cfg->ioqueue, &sess->resolver);
-    if (status != PJ_SUCCESS) {
-	app_perror(INDENT "error: pj_dns_resolver_create()", status);
-	destroy_sess(sess, 500);
-	return -20;
+    if (flags & SERVER_IPV6) {
+	sess->server2->turn_respond_allocate =
+	    sess->server2->turn_respond_refresh = PJ_TRUE;
     }
 
-    ns_ip = pj_str("127.0.0.1");
-    ns_port = (pj_uint16_t)DNS_SERVER_PORT;
-    status = pj_dns_resolver_set_ns(sess->resolver, 1, &ns_ip, &ns_port);
-    if (status != PJ_SUCCESS) {
-	app_perror( INDENT "error: pj_dns_resolver_set_ns()", status);
-	destroy_sess(sess, 500);
-	return -21;
+    /* Create resolver */
+    if ((sess->callee.cfg.enable_stun & SRV)==SRV || 
+	(sess->callee.cfg.enable_turn & SRV)==SRV ||
+	(sess->caller.cfg.enable_stun & SRV)==SRV || 
+	(sess->caller.cfg.enable_turn & SRV)==SRV) 
+    {
+	status = pj_dns_resolver_create(mem, NULL, 0, stun_cfg->timer_heap,
+					stun_cfg->ioqueue, &sess->resolver);
+	if (status != PJ_SUCCESS) {
+	    app_perror(INDENT "error: pj_dns_resolver_create()", status);
+	    destroy_sess(sess, 500);
+	    return -20;
+	}
+
+	ns_ip =  (flags & SERVER_IPV6)?pj_str("::1"):pj_str("127.0.0.1");
+	ns_port = (pj_uint16_t)DNS_SERVER_PORT;
+	status = pj_dns_resolver_set_ns(sess->resolver, 1, &ns_ip, &ns_port);
+	if (status != PJ_SUCCESS) {
+	    app_perror(INDENT "error: pj_dns_resolver_set_ns()", status);
+	    destroy_sess(sess, 500);
+	    return -21;
+	}
     }
 
     /* Create caller ICE stream transport */
@@ -305,9 +369,14 @@ static void destroy_sess(struct test_sess *sess, unsigned wait_msec)
 	sess->resolver = NULL;
     }
 
-    if (sess->server) {
-	destroy_test_server(sess->server);
-	sess->server = NULL;
+    if (sess->server1) {
+	destroy_test_server(sess->server1);
+	sess->server1 = NULL;
+    }
+
+    if (sess->server2) {
+	destroy_test_server(sess->server2);
+	sess->server2 = NULL;
     }
 
     if (sess->pool) {
@@ -384,12 +453,13 @@ static pj_status_t start_ice(struct ice_ept *ept, const struct ice_ept *remote)
 
     status = pj_ice_strans_start_ice(ept->ice, &remote->ufrag, &remote->pass,
 				     rcand_cnt, rcand);
-    if (status != PJ_SUCCESS) {
+
+    if (status != ept->cfg.expected.start_status) {
 	app_perror(INDENT "err: pj_ice_strans_start_ice()", status);
 	return status;
     }
 
-    return PJ_SUCCESS;
+    return status;
 }
 
 
@@ -498,12 +568,25 @@ static int perform_test2(const char *title,
     struct test_sess *sess;
     unsigned i;
     int rc;
+    char add_title1[16];
+    char add_title2[16];
+    pj_bool_t client_mix_test = ((callee_cfg->client_flag &
+				 (CLIENT_IPV4+CLIENT_IPV6)) !=
+				 (caller_cfg->client_flag &
+				 (CLIENT_IPV4+CLIENT_IPV6)));
 
-    PJ_LOG(3,(THIS_FILE, INDENT "%s", title));
+    sprintf(add_title1, "%s%s%s", (server_flag & SERVER_IPV4)?"IPv4":"", 
+	    ((server_flag & SERVER_IPV4)&&(server_flag & SERVER_IPV6))?"+":"",
+	    (server_flag & SERVER_IPV6)?"IPv6":"");
+    
+    sprintf(add_title2, "%s", client_mix_test?"Mix test":"");
+
+    PJ_LOG(3,(THIS_FILE, INDENT "%s (%s) %s", title, add_title1, add_title2));
 
     capture_pjlib_state(stun_cfg, &pjlib_state);
 
-    rc = create_sess(stun_cfg, server_flag, caller_cfg, callee_cfg, test_param, &sess);
+    rc = create_sess(stun_cfg, server_flag, caller_cfg, callee_cfg, test_param,
+		     &sess);
     if (rc != 0)
 	return rc;
 
@@ -557,16 +640,18 @@ static int perform_test2(const char *title,
     /* Start ICE on callee */
     rc = start_ice(&sess->callee, &sess->caller);
     if (rc != PJ_SUCCESS) {
-	destroy_sess(sess, 500);
-	return -120;
+	int retval = (rc == sess->callee.cfg.expected.start_status)?0:-120;
+	destroy_sess(sess, 500);	
+	return retval;
     }
     /* Wait for callee's answer_delay */
     poll_events(stun_cfg, sess->callee.cfg.answer_delay, PJ_FALSE);
     /* Start ICE on caller */
     rc = start_ice(&sess->caller, &sess->callee);
     if (rc != PJ_SUCCESS) {
+	int retval = (rc == sess->caller.cfg.expected.start_status)?0:-130;
 	destroy_sess(sess, 500);
-	return -130;
+	return retval;
     }
 
     for (i=0; i<sess->param->worker_cnt; ++i) {
@@ -663,6 +748,23 @@ on_return:
     return rc;
 }
 
+static void set_client_server_flag(unsigned server_flag,
+				   unsigned caller_flag,
+				   unsigned callee_flag,
+				   unsigned *res_server_flag,
+				   unsigned *res_caller_flag,
+				   unsigned *res_callee_flag)
+{
+    enum {
+	RST_CLT_FLAG = CLIENT_IPV4+CLIENT_IPV6,
+	RST_SRV_FLAG = SERVER_IPV4+SERVER_IPV6
+    };
+
+    *res_server_flag = (*res_server_flag & ~RST_SRV_FLAG) | server_flag;
+    *res_caller_flag = (*res_caller_flag & ~RST_CLT_FLAG) | caller_flag;
+    *res_callee_flag = (*res_callee_flag & ~RST_CLT_FLAG) | callee_flag;
+}
+
 static int perform_test(const char *title,
                         pj_stun_config *stun_cfg,
                         unsigned server_flag,
@@ -670,10 +772,67 @@ static int perform_test(const char *title,
                         struct test_cfg *callee_cfg)
 {
     struct sess_param test_param;
+    int rc;
+    int expected_caller_start_ice = caller_cfg->expected.start_status;
+    int expected_callee_start_ice = callee_cfg->expected.start_status;
+
+    set_client_server_flag(SERVER_IPV4, CLIENT_IPV4, CLIENT_IPV4,
+			   &server_flag, &caller_cfg->client_flag, 
+			   &callee_cfg->client_flag);
+
 
     pj_bzero(&test_param, sizeof(test_param));
-    return perform_test2(title, stun_cfg, server_flag, caller_cfg,
-                         callee_cfg, &test_param);
+
+    rc = perform_test2(title, stun_cfg, server_flag, caller_cfg,
+		       callee_cfg, &test_param);
+
+#if USE_IPV6
+    /* Test for IPV6. */
+    if (rc == PJ_SUCCESS) {
+	pj_bzero(&test_param, sizeof(test_param));
+	set_client_server_flag(SERVER_IPV6, CLIENT_IPV6, CLIENT_IPV6,
+			       &server_flag, &caller_cfg->client_flag,
+			       &callee_cfg->client_flag);
+
+	rc = perform_test2(title, stun_cfg, server_flag, caller_cfg,
+			   callee_cfg, &test_param);
+    }
+
+    /* Test for IPV4+IPV6. */
+    if (rc == PJ_SUCCESS) {
+	pj_bzero(&test_param, sizeof(test_param));
+	set_client_server_flag(SERVER_IPV4+SERVER_IPV6, 
+			       CLIENT_IPV4+CLIENT_IPV6,
+			       CLIENT_IPV4+CLIENT_IPV6, 
+			       &server_flag,
+			       &caller_cfg->client_flag, 
+			       &callee_cfg->client_flag);
+
+	rc = perform_test2(title, stun_cfg, server_flag, caller_cfg,
+			   callee_cfg, &test_param);
+    }
+
+    /* Test controller(IPV4) vs controlled(IPV6). */
+    if (rc == PJ_SUCCESS) {
+	pj_bzero(&test_param, sizeof(test_param));
+	set_client_server_flag(SERVER_IPV4+SERVER_IPV6, 
+			       CLIENT_IPV4,
+			       CLIENT_IPV6, 
+			       &server_flag,
+			       &caller_cfg->client_flag, 
+			       &callee_cfg->client_flag);
+	caller_cfg->expected.start_status = PJ_ENOTFOUND;
+	callee_cfg->expected.start_status = PJ_ENOTFOUND;
+
+	rc = perform_test2(title, stun_cfg, server_flag, caller_cfg,
+			   callee_cfg, &test_param);
+    }
+
+#endif
+    callee_cfg->expected.start_status = expected_callee_start_ice;
+    caller_cfg->expected.start_status = expected_caller_start_ice;
+
+    return rc;
 }
 
 #define ROLE1	PJ_ICE_SESS_ROLE_CONTROLLED
@@ -695,39 +854,39 @@ int ice_test(void)
 	/*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
 	{
 	    "hosts candidates only",
-	    0xFFFF,
-	    {ROLE1, 1,	    YES,    NO,	    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	    YES,    NO,	    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	    YES,    NO,	    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	    YES,    NO,	    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
 	{
 	    "host and srflxes",
-	    0xFFFF,
-	    {ROLE1, 1,	    YES,    YES,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	    YES,    YES,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	    YES,    YES,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	    YES,    YES,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
 	{
 	    "host vs relay",
-	    0xFFFF,
-	    {ROLE1, 1,	    YES,    NO,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	    NO,     NO,    YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	    YES,    NO,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	    NO,     NO,    YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
 	{
 	    "relay vs host",
-	    0xFFFF,
-	    {ROLE1, 1,	    NO,	    NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	   YES,     NO,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	    NO,	    NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	   YES,     NO,    NO,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
 	{
 	    "relay vs relay",
-	    0xFFFF,
-	    {ROLE1, 1,	    NO,	    NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	    NO,     NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	    NO,	    NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	    NO,     NO,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
 	{
 	    "all candidates",
-	    0xFFFF,
-	    {ROLE1, 1,	   YES,	   YES,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2, 1,	   YES,    YES,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    0x1FFF,
+	    {ROLE1, 1,	   YES,	   YES,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2, 1,	   YES,    YES,   YES,	    NO,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	},
     };
 
@@ -745,8 +904,8 @@ int ice_test(void)
 	    "Basic with host candidates",
 	    0x0,
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	1,	YES,     NO,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2,	1,	YES,     NO,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    {ROLE1,	1,	YES,     NO,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2,	1,	YES,     NO,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -770,8 +929,8 @@ int ice_test(void)
 	    "Basic with srflx candidates",
 	    0xFFFF,
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	1,	YES,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2,	1,	YES,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    {ROLE1,	1,	YES,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2,	1,	YES,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -796,8 +955,8 @@ int ice_test(void)
 	    "Basic with relay candidates",
 	    0xFFFF,
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	1,	 NO,     NO,	  YES,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	    {ROLE2,	1,	 NO,     NO,	  YES,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	    {ROLE1,	1,	 NO,     NO,	  YES,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	    {ROLE2,	1,	 NO,     NO,	  YES,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -822,8 +981,8 @@ int ice_test(void)
 	    "STUN resolution failure",
 	    0x0,
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	2,	 NO,    YES,	    NO,	    0,	    0,	    0,	    0, {PJNATH_ESTUNTIMEDOUT, -1}},
-	    {ROLE2,	2,	 NO,    YES,	    NO,	    0,	    0,	    0,	    0, {PJNATH_ESTUNTIMEDOUT, -1}}
+	    {ROLE1,	2,	 NO,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJNATH_ESTUNTIMEDOUT, -1}},
+	    {ROLE2,	2,	 NO,    YES,	    NO,	    0,	    0,	    0,	    0, {PJ_SUCCESS, PJNATH_ESTUNTIMEDOUT, -1}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -848,8 +1007,8 @@ int ice_test(void)
 	    "TURN allocation failure",
 	    0xFFFF,
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	2,	 NO,    NO,	YES, WRONG_TURN,    0,	    0,	    0, {PJ_STATUS_FROM_STUN_CODE(401), -1}},
-	    {ROLE2,	2,	 NO,    NO,	YES, WRONG_TURN,    0,	    0,	    0, {PJ_STATUS_FROM_STUN_CODE(401), -1}}
+	    {ROLE1,	2,	 NO,    NO,	YES, WRONG_TURN,    0,	    0,	    0, {PJ_SUCCESS, PJ_STATUS_FROM_STUN_CODE(401), -1}},
+	    {ROLE2,	2,	 NO,    NO,	YES, WRONG_TURN,    0,	    0,	    0, {PJ_SUCCESS, PJ_STATUS_FROM_STUN_CODE(401), -1}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -875,8 +1034,8 @@ int ice_test(void)
 	    "STUN failure, testing TURN deallocation",
 	    0xFFFF & (~(CREATE_STUN_SERVER)),
 	    /*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	    {ROLE1,	1,	 YES,    YES,	YES,	0,    0,	    0,	    0, {PJNATH_ESTUNTIMEDOUT, -1}},
-	    {ROLE2,	1,	 YES,    YES,	YES,	0,    0,	    0,	    0, {PJNATH_ESTUNTIMEDOUT, -1}}
+	    {ROLE1,	1,	 YES,    YES,	YES,	0,    0,	    0,	    0, {PJ_SUCCESS, PJNATH_ESTUNTIMEDOUT, -1}},
+	    {ROLE2,	1,	 YES,    YES,	YES,	0,    0,	    0,	    0, {PJ_SUCCESS, PJNATH_ESTUNTIMEDOUT, -1}}
 	};
 
 	rc = perform_test(cfg.title, &stun_cfg, cfg.server_flag,
@@ -969,10 +1128,10 @@ int ice_one_conc_test(pj_stun_config *stun_cfg, int err_quit)
     } cfg =
     {
 	"Concurrency test",
-	0xFFFF,
+	0x1FFF,
 	/*  Role    comp#   host?   stun?   turn?   flag?  ans_del snd_del des_del */
-	{ROLE1,	1,	YES,     YES,	    YES,    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}},
-	{ROLE2,	1,	YES,     YES,	    YES,    0,	    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS}}
+	{ROLE1,	1,	YES,     YES,	    YES,    CLIENT_IPV4,    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}},
+	{ROLE2,	1,	YES,     YES,	    YES,    CLIENT_IPV4,    0,	    0,	    0, {PJ_SUCCESS, PJ_SUCCESS, PJ_SUCCESS}}
     };
     struct sess_param test_param;
     int rc;
diff --git a/pjnath/src/pjnath-test/server.c b/pjnath/src/pjnath-test/server.c
index 7491d9da..99bacba1 100644
--- a/pjnath/src/pjnath-test/server.c
+++ b/pjnath/src/pjnath-test/server.c
@@ -53,10 +53,11 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
     pj_sockaddr hostip;
     char strbuf[100];
     pj_status_t status;
+    pj_bool_t use_ipv6 = flags & SERVER_IPV6;
 
     PJ_ASSERT_RETURN(stun_cfg && domain && p_test_srv, PJ_EINVAL);
 
-    status = pj_gethostip(pj_AF_INET(), &hostip);
+    status = pj_gethostip(GET_AF(use_ipv6), &hostip);
     if (status != PJ_SUCCESS)
 	return status;
 
@@ -74,7 +75,7 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 
     if (flags & CREATE_DNS_SERVER) {
 	status = pj_dns_server_create(mem, test_srv->stun_cfg->ioqueue,
-				      pj_AF_INET(), DNS_SERVER_PORT,
+				      GET_AF(use_ipv6), DNS_SERVER_PORT,
 				      0, &test_srv->dns_server);
 	if (status != PJ_SUCCESS) {
 	    destroy_test_server(test_srv);
@@ -85,11 +86,17 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	if (flags & CREATE_A_RECORD_FOR_DOMAIN) {
 	    pj_dns_parsed_rr rr;
 	    pj_str_t res_name;
-	    pj_in_addr ip_addr;
 
 	    pj_strdup2(pool, &res_name, domain);
-	    ip_addr = hostip.ipv4.sin_addr;
-	    pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, &ip_addr);
+
+	    if (use_ipv6) {
+		pj_dns_init_aaaa_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				    &hostip.ipv6.sin6_addr);
+	    } else {		
+		pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				 &hostip.ipv4.sin_addr);
+	    }
+	    
 	    pj_dns_server_add_rec(test_srv->dns_server, 1, &rr);
 	}
 
@@ -102,7 +109,8 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	pj_bzero(&stun_sock_cb, sizeof(stun_sock_cb));
 	stun_sock_cb.on_data_recvfrom = &stun_on_data_recvfrom;
 
-	pj_sockaddr_in_init(&bound_addr.ipv4, NULL, STUN_SERVER_PORT);
+	pj_sockaddr_init(GET_AF(use_ipv6), &bound_addr, 
+			 NULL, STUN_SERVER_PORT);
 
 	status = pj_activesock_create_udp(pool, &bound_addr, NULL, 
 					  test_srv->stun_cfg->ioqueue,
@@ -123,7 +131,6 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	if (test_srv->dns_server && (flags & CREATE_STUN_SERVER_DNS_SRV)) {
 	    pj_str_t res_name, target;
 	    pj_dns_parsed_rr rr;
-	    pj_in_addr ip_addr;
 
 	    /* Add DNS entries:
 	     *  _stun._udp.domain 60 IN SRV 0 0 PORT stun.domain.
@@ -140,8 +147,13 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	    pj_dns_server_add_rec(test_srv->dns_server, 1, &rr);
 
 	    res_name = target;
-	    ip_addr = hostip.ipv4.sin_addr;
-	    pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, &ip_addr);
+	    if (use_ipv6) {		
+		pj_dns_init_aaaa_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				    &hostip.ipv6.sin6_addr);
+	    } else {		
+		pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				 &hostip.ipv4.sin_addr);
+	    }
 	    pj_dns_server_add_rec(test_srv->dns_server, 1, &rr);
 	}
 
@@ -154,7 +166,7 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	pj_bzero(&turn_sock_cb, sizeof(turn_sock_cb));
 	turn_sock_cb.on_data_recvfrom = &turn_on_data_recvfrom;
 
-	pj_sockaddr_in_init(&bound_addr.ipv4, NULL, TURN_SERVER_PORT);
+	pj_sockaddr_init(GET_AF(use_ipv6), &bound_addr, NULL, TURN_SERVER_PORT);
 
 	status = pj_activesock_create_udp(pool, &bound_addr, NULL, 
 					  test_srv->stun_cfg->ioqueue,
@@ -175,7 +187,6 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	if (test_srv->dns_server && (flags & CREATE_TURN_SERVER_DNS_SRV)) {
 	    pj_str_t res_name, target;
 	    pj_dns_parsed_rr rr;
-	    pj_in_addr ip_addr;
 
 	    /* Add DNS entries:
 	     *  _turn._udp.domain 60 IN SRV 0 0 PORT turn.domain.
@@ -192,8 +203,14 @@ pj_status_t create_test_server(pj_stun_config *stun_cfg,
 	    pj_dns_server_add_rec(test_srv->dns_server, 1, &rr);
 
 	    res_name = target;
-	    ip_addr = hostip.ipv4.sin_addr;
-	    pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, &ip_addr);
+	    
+	    if (use_ipv6) {		
+		pj_dns_init_aaaa_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				    &hostip.ipv6.sin6_addr);
+	    } else {		
+		pj_dns_init_a_rr(&rr, &res_name, PJ_DNS_CLASS_IN, 60, 
+				 &hostip.ipv4.sin_addr);
+	    }
 	    pj_dns_server_add_rec(test_srv->dns_server, 1, &rr);
 	}
     }
@@ -344,6 +361,7 @@ static pj_bool_t turn_on_data_recvfrom(pj_activesock_t *asock,
     char client_info[PJ_INET6_ADDRSTRLEN+10];
     unsigned i;
     pj_ssize_t len;
+    pj_bool_t use_ipv6 = PJ_FALSE;
 
     if (status != PJ_SUCCESS)
 	return PJ_TRUE;
@@ -351,6 +369,7 @@ static pj_bool_t turn_on_data_recvfrom(pj_activesock_t *asock,
     pj_sockaddr_print(src_addr, client_info, sizeof(client_info), 3);
 
     test_srv = (test_server*) pj_activesock_get_user_data(asock);
+    use_ipv6 = test_srv->flags & SERVER_IPV6;
     pool = pj_pool_create(test_srv->stun_cfg->pf, NULL, 512, 512, NULL);
 
     /* Find the client */
@@ -480,9 +499,9 @@ static pj_bool_t turn_on_data_recvfrom(pj_activesock_t *asock,
 
 	alloc->pool = pj_pool_create(test_srv->stun_cfg->pf, "alloc", 512, 512, NULL);
 
-	/* Create relay socket */
-	pj_sockaddr_in_init(&alloc->alloc_addr.ipv4, NULL, 0);
-	pj_gethostip(pj_AF_INET(), &alloc->alloc_addr);
+	/* Create relay socket */	
+	pj_sockaddr_init(GET_AF(use_ipv6), &alloc->alloc_addr, NULL, 0);
+	pj_gethostip(GET_AF(use_ipv6), &alloc->alloc_addr);
 
 	status = pj_activesock_create_udp(alloc->pool, &alloc->alloc_addr, NULL, 
 					  test_srv->stun_cfg->ioqueue,
@@ -697,6 +716,8 @@ static pj_bool_t alloc_on_data_recvfrom(pj_activesock_t *asock,
     pj_ssize_t sent;
     unsigned i;
 
+    PJ_UNUSED_ARG(addr_len);
+
     if (status != PJ_SUCCESS)
 	return PJ_TRUE;
 
@@ -707,10 +728,7 @@ static pj_bool_t alloc_on_data_recvfrom(pj_activesock_t *asock,
 
     /* Check that this peer has a permission */
     for (i=0; i<alloc->perm_cnt; ++i) {
-	if (pj_sockaddr_get_len(&alloc->perm[i]) == (unsigned)addr_len &&
-	    pj_memcmp(pj_sockaddr_get_addr(&alloc->perm[i]),
-		      pj_sockaddr_get_addr(src_addr),
-		      addr_len) == 0)
+	if (pj_sockaddr_cmp(&alloc->perm[i], src_addr) == 0)
 	{
 	    break;
 	}
diff --git a/pjnath/src/pjnath-test/server.h b/pjnath/src/pjnath-test/server.h
index 4ac61e9d..458e1c44 100644
--- a/pjnath/src/pjnath-test/server.h
+++ b/pjnath/src/pjnath-test/server.h
@@ -39,12 +39,14 @@ enum test_server_flags
     CREATE_DNS_SERVER		= (1 << 0),
     CREATE_A_RECORD_FOR_DOMAIN	= (1 << 1),
 
-    CREATE_STUN_SERVER		= (1 << 5),
-    CREATE_STUN_SERVER_DNS_SRV	= (1 << 6),
+    CREATE_STUN_SERVER		= (1 << 4),
+    CREATE_STUN_SERVER_DNS_SRV	= (1 << 5),
 
-    CREATE_TURN_SERVER		= (1 << 10),
-    CREATE_TURN_SERVER_DNS_SRV	= (1 << 11),
+    CREATE_TURN_SERVER		= (1 << 8),
+    CREATE_TURN_SERVER_DNS_SRV	= (1 << 9),
 
+    SERVER_IPV4			= (1 << 12),
+    SERVER_IPV6			= (1 << 13)
 };
 
 typedef struct test_server test_server;
diff --git a/pjnath/src/pjnath-test/sess_auth.c b/pjnath/src/pjnath-test/sess_auth.c
index 4093c1bb..626ac07a 100644
--- a/pjnath/src/pjnath-test/sess_auth.c
+++ b/pjnath/src/pjnath-test/sess_auth.c
@@ -229,7 +229,8 @@ static void destroy_server(void)
 
 /* Instantiate standard server */
 static int create_std_server(pj_stun_auth_type auth_type,
-			     pj_bool_t responding)
+			     pj_bool_t responding,
+			     pj_bool_t use_ipv6)
 {
     pj_pool_t *pool;
     pj_stun_session_cb sess_cb;
@@ -266,14 +267,14 @@ static int create_std_server(pj_stun_auth_type auth_type,
     }
 
     /* Create socket */
-    status = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &server->sock);
+    status = pj_sock_socket(GET_AF(use_ipv6), pj_SOCK_DGRAM(), 0, &server->sock);
     if (status != PJ_SUCCESS) {
 	destroy_server();
 	return -30;
     }
 
     /* Bind */
-    pj_sockaddr_in_init(&server->addr.ipv4, NULL, 0);
+    pj_sockaddr_init(GET_AF(use_ipv6), &server->addr, NULL, 0);
     status = pj_sock_bind(server->sock, &server->addr, pj_sockaddr_get_len(&server->addr));
     if (status != PJ_SUCCESS) {
 	destroy_server();
@@ -289,7 +290,7 @@ static int create_std_server(pj_stun_auth_type auth_type,
 	    return -43;
 	}
 
-	status = pj_gethostip(pj_AF_INET(), &addr);
+	status = pj_gethostip(GET_AF(use_ipv6), &addr);
 	if (status != PJ_SUCCESS) {
 	    destroy_server();
 	    return -45;
@@ -452,7 +453,7 @@ static int run_client_test(const char *title,
 			   const char *nonce,
 			   const char *password,
 			   pj_bool_t dummy_mi,
-
+			   pj_bool_t use_ipv6,
 			   pj_bool_t expected_error,
 			   pj_status_t expected_code,
 			   const char *expected_realm,
@@ -465,9 +466,10 @@ static int run_client_test(const char *title,
     pj_stun_auth_cred cred;
     pj_stun_tx_data *tdata;
     pj_status_t status;
+    pj_sockaddr addr;
     int rc = 0;
     
-    PJ_LOG(3,(THIS_FILE, "   %s test", title));
+    PJ_LOG(3,(THIS_FILE, "   %s test (%s)", title, use_ipv6?"IPv6":"IPv4"));
 
     /* Create client */
     pool = pj_pool_create(mem, "client", 1000, 1000, NULL);
@@ -493,14 +495,15 @@ static int run_client_test(const char *title,
     }
 
     /* Create client socket */
-    status = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &client->sock);
+    status = pj_sock_socket(GET_AF(use_ipv6), pj_SOCK_DGRAM(), 0, &client->sock);
     if (status != PJ_SUCCESS) {
 	destroy_client_server();
 	return -210;
     }
 
     /* Bind client socket */
-    status = pj_sock_bind_in(client->sock, 0, 0);
+    pj_sockaddr_init(GET_AF(use_ipv6), &addr, NULL, 0);
+    status = pj_sock_bind(client->sock, &addr, pj_sockaddr_get_len(&addr));
     if (status != PJ_SUCCESS) {
 	destroy_client_server();
 	return -220;
@@ -528,7 +531,7 @@ static int run_client_test(const char *title,
     }
 
     /* Create the server */
-    status = create_std_server(server_auth_type, server_responding);
+    status = create_std_server(server_auth_type, server_responding, use_ipv6);
     if (status != 0) {
 	destroy_client_server();
 	return status;
@@ -680,6 +683,26 @@ static int run_client_test(const char *title,
 
 done:
     destroy_client_server();
+
+    /* If IPv6 is enabled, test again for IPv4. */
+    if ((rc == 0) && use_ipv6) {
+	rc = run_client_test(title,
+			     server_responding,
+			     server_auth_type,
+			     client_auth_type,
+			     realm,
+			     username,
+			     nonce,
+			     password,
+			     dummy_mi,
+			     0,
+			     expected_error,
+			     expected_code,
+			     expected_realm,
+			     expected_nonce,
+			     more_check);
+    }
+
     return rc;
 }
 
@@ -778,6 +801,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 NULL,		    // password
 			 PJ_FALSE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJNATH_ESTUNTIMEDOUT,// expected code
 			 NULL,		    // expected realm
@@ -808,6 +832,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 NULL,		    // password
 			 PJ_FALSE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(400),// expected code
 			 NULL,		    // expected realm
@@ -832,6 +857,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 "anotherpass",	    // password
 			 PJ_FALSE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401),// expected code
 			 NULL,		    // expected realm
@@ -860,6 +886,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 "anotherpass",	    // password
 			 PJ_FALSE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401),// expected code
 			 NULL,		    // expected realm
@@ -882,6 +909,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 NULL,		    // password
 			 PJ_TRUE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(400),	    // expected code
 			 NULL,		    // expected realm
@@ -902,6 +930,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 PASSWORD,	    // password
 			 PJ_FALSE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_FALSE,	    // expected error
 			 PJ_SUCCESS,	    // expected code
 			 NULL,		    // expected realm
@@ -928,6 +957,7 @@ int sess_auth_test(void)
 			 NULL,		    // nonce
 			 PASSWORD,	    // password
 			 PJ_TRUE,	    // dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401),	    // expected code
 			 NULL,		    // expected realm
@@ -961,6 +991,7 @@ int sess_auth_test(void)
 			 NULL,		    // client nonce
 			 NULL,		    // client password
 			 PJ_FALSE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401), // expected code
 			 REALM,		    // expected realm
@@ -987,6 +1018,7 @@ int sess_auth_test(void)
 			 NONCE,		    // client nonce
 			 PASSWORD,	    // client password
 			 PJ_TRUE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(400), // expected code
 			 NULL,		    // expected realm
@@ -1007,6 +1039,7 @@ int sess_auth_test(void)
 			 NONCE,		    // client nonce
 			 PASSWORD,	    // client password
 			 PJ_TRUE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(400), // expected code
 			 NULL,		    // expected realm
@@ -1027,6 +1060,7 @@ int sess_auth_test(void)
 			 NULL,		    // client nonce
 			 PASSWORD,	    // client password
 			 PJ_TRUE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(400), // expected code
 			 NULL,		    // expected realm
@@ -1063,6 +1097,7 @@ int sess_auth_test(void)
 			 "a nonce",	    // client nonce
 			 "somepassword",    // client password
 			 PJ_FALSE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401), // expected code
 			 REALM,		    // expected realm
@@ -1083,6 +1118,7 @@ int sess_auth_test(void)
 			 "anothernonce",    // client nonce
 			 PASSWORD,	    // client password
 			 PJ_FALSE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_FALSE,	    // expected error
 			 0,		    // expected code
 			 NULL,		    // expected realm
@@ -1113,6 +1149,7 @@ int sess_auth_test(void)
 			 NONCE,		    // client nonce
 			 PASSWORD,	    // client password
 			 PJ_FALSE,	    // client dummy MI
+			 USE_IPV6,	    // use IPv6
 			 PJ_TRUE,	    // expected error
 			 PJ_STATUS_FROM_STUN_CODE(401), // expected code
 			 REALM,		    // expected realm
diff --git a/pjnath/src/pjnath-test/stun_sock_test.c b/pjnath/src/pjnath-test/stun_sock_test.c
index 3b090400..fff4fad2 100644
--- a/pjnath/src/pjnath-test/stun_sock_test.c
+++ b/pjnath/src/pjnath-test/stun_sock_test.c
@@ -89,15 +89,21 @@ static pj_bool_t srv_on_data_recvfrom(pj_activesock_t *asock,
 
 	/* Add MAPPED-ADDRESS or XOR-MAPPED-ADDRESS (or don't add) */
 	if (srv->flag & WITH_MAPPED) {
-	    pj_sockaddr_in addr;
+	    pj_sockaddr addr;
+	    pj_bool_t use_ipv6 = (srv->addr.addr.sa_family == pj_AF_INET6());
+	    
+	    pj_sockaddr_init(GET_AF(use_ipv6), &addr, &srv->ip_to_send, 
+			     srv->port_to_send);
 
-	    pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send);
 	    pj_stun_msg_add_sockaddr_attr(pool, res_msg, PJ_STUN_ATTR_MAPPED_ADDR,
 					  PJ_FALSE, &addr, sizeof(addr));
 	} else if (srv->flag & WITH_XOR_MAPPED) {
-	    pj_sockaddr_in addr;
+	    pj_sockaddr addr;
+	    pj_bool_t use_ipv6 = (srv->addr.addr.sa_family == pj_AF_INET6());
+	    
+	    pj_sockaddr_init(GET_AF(use_ipv6), &addr, &srv->ip_to_send, 
+			     srv->port_to_send);
 
-	    pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send);
 	    pj_stun_msg_add_sockaddr_attr(pool, res_msg, 
 					  PJ_STUN_ATTR_XOR_MAPPED_ADDR,
 					  PJ_TRUE, &addr, sizeof(addr));
@@ -133,6 +139,7 @@ static pj_bool_t srv_on_data_recvfrom(pj_activesock_t *asock,
 static pj_status_t create_server(pj_pool_t *pool,
 				 pj_ioqueue_t *ioqueue,
 				 unsigned flag,
+				 pj_bool_t use_ipv6,
 				 struct stun_srv **p_srv)
 {
     struct stun_srv *srv;
@@ -141,10 +148,10 @@ static pj_status_t create_server(pj_pool_t *pool,
 
     srv = PJ_POOL_ZALLOC_T(pool, struct stun_srv);
     srv->flag = flag;
-    srv->ip_to_send = pj_str("1.1.1.1");
+    srv->ip_to_send = (use_ipv6)?pj_str("2002:101:101::"):pj_str("1.1.1.1");
     srv->port_to_send = 1000;
 
-    status = pj_sockaddr_in_init(&srv->addr.ipv4, NULL, 0);
+    status = pj_sockaddr_init(GET_AF(use_ipv6), &srv->addr, NULL, 0);
     if (status != PJ_SUCCESS)
 	return status;
 
@@ -230,7 +237,8 @@ static pj_bool_t stun_sock_on_rx_data(pj_stun_sock *stun_sock,
 
 static pj_status_t create_client(pj_stun_config *cfg,
 				 struct stun_client **p_client,
-				 pj_bool_t destroy_on_err)
+				 pj_bool_t destroy_on_err,
+				 pj_bool_t use_ipv6)
 {
     pj_pool_t *pool;
     struct stun_client *client;
@@ -247,8 +255,8 @@ static pj_status_t create_client(pj_stun_config *cfg,
     pj_bzero(&cb, sizeof(cb));
     cb.on_status = &stun_sock_on_status;
     cb.on_rx_data = &stun_sock_on_rx_data;
-    status = pj_stun_sock_create(cfg, NULL, pj_AF_INET(), &cb,
-				 &sock_cfg, client, &client->sock);
+    status = pj_stun_sock_create(cfg, NULL, GET_AF(use_ipv6), &cb, &sock_cfg, 
+				 client, &client->sock);
     if (status != PJ_SUCCESS) {
 	app_perror("   pj_stun_sock_create()", status);
 	pj_pool_release(pool);
@@ -292,7 +300,8 @@ static void handle_events(pj_stun_config *cfg, unsigned msec_delay)
 /*
  * Timeout test: scenario when no response is received from server
  */
-static int timeout_test(pj_stun_config *cfg, pj_bool_t destroy_on_err)
+static int timeout_test(pj_stun_config *cfg, pj_bool_t destroy_on_err, 
+			pj_bool_t use_ipv6)
 {
     struct stun_srv *srv;
     struct stun_client *client;
@@ -301,21 +310,23 @@ static int timeout_test(pj_stun_config *cfg, pj_bool_t destroy_on_err)
     int i, ret = 0;
     pj_status_t status;
 
-    PJ_LOG(3,(THIS_FILE, "  timeout test [%d]", destroy_on_err));
+    PJ_LOG(3,(THIS_FILE, "  timeout test [%d] - (%s)", destroy_on_err, 
+	   (use_ipv6)?"IPv6":"IPv4"));
 
-    status =  create_client(cfg, &client, destroy_on_err);
+    status =  create_client(cfg, &client, destroy_on_err, use_ipv6);
     if (status != PJ_SUCCESS)
 	return -10;
 
-    status = create_server(client->pool, cfg->ioqueue, 0, &srv);
+    status = create_server(client->pool, cfg->ioqueue, 0, use_ipv6, &srv);
     if (status != PJ_SUCCESS) {
 	destroy_client(client);
 	return -20;
     }
 
-    srv_addr = pj_str("127.0.0.1");
+    srv_addr = (use_ipv6)?pj_str("::1"):pj_str("127.0.0.1");
+
     status = pj_stun_sock_start(client->sock, &srv_addr, 
-				pj_ntohs(srv->addr.ipv4.sin_port), NULL);
+				pj_sockaddr_get_port(&srv->addr), NULL);
     if (status != PJ_SUCCESS) {
 	destroy_server(srv);
 	destroy_client(client);
@@ -361,6 +372,10 @@ on_return:
     destroy_client(client);
     for (i=0; i<7; ++i)
 	handle_events(cfg, 100);
+
+    if ((ret == 0) && use_ipv6)
+	ret = timeout_test(cfg, destroy_on_err, 0);
+
     return ret;
 }
 
@@ -369,7 +384,8 @@ on_return:
  * Invalid response scenario: when server returns no MAPPED-ADDRESS or
  * XOR-MAPPED-ADDRESS attribute.
  */
-static int missing_attr_test(pj_stun_config *cfg, pj_bool_t destroy_on_err)
+static int missing_attr_test(pj_stun_config *cfg, pj_bool_t destroy_on_err, 
+			     pj_bool_t use_ipv6)
 {
     struct stun_srv *srv;
     struct stun_client *client;
@@ -378,21 +394,23 @@ static int missing_attr_test(pj_stun_config *cfg, pj_bool_t destroy_on_err)
     int i, ret = 0;
     pj_status_t status;
 
-    PJ_LOG(3,(THIS_FILE, "  missing attribute test [%d]", destroy_on_err));
+    PJ_LOG(3,(THIS_FILE, "  missing attribute test [%d] - (%s)", 
+	   destroy_on_err, (use_ipv6)?"IPv6":"IPv4"));
 
-    status =  create_client(cfg, &client, destroy_on_err);
+    status =  create_client(cfg, &client, destroy_on_err, use_ipv6);
     if (status != PJ_SUCCESS)
 	return -110;
 
-    status = create_server(client->pool, cfg->ioqueue, RESPOND_STUN, &srv);
+    status = create_server(client->pool, cfg->ioqueue, RESPOND_STUN, use_ipv6, 
+			   &srv);
     if (status != PJ_SUCCESS) {
 	destroy_client(client);
 	return -120;
     }
+    srv_addr = (use_ipv6)?pj_str("::1"):pj_str("127.0.0.1");
 
-    srv_addr = pj_str("127.0.0.1");
     status = pj_stun_sock_start(client->sock, &srv_addr, 
-				pj_ntohs(srv->addr.ipv4.sin_port), NULL);
+				pj_sockaddr_get_port(&srv->addr), NULL);				
     if (status != PJ_SUCCESS) {
 	destroy_server(srv);
 	destroy_client(client);
@@ -430,30 +448,36 @@ on_return:
     destroy_client(client);
     for (i=0; i<7; ++i)
 	handle_events(cfg, 100);
+
+    if ((ret == 0) && use_ipv6)
+	ret = missing_attr_test(cfg, destroy_on_err, 0);
+
     return ret;
 }
 
 /*
  * Keep-alive test.
  */
-static int keep_alive_test(pj_stun_config *cfg)
+static int keep_alive_test(pj_stun_config *cfg, pj_bool_t use_ipv6)
 {
     struct stun_srv *srv;
     struct stun_client *client;
-    pj_sockaddr_in mapped_addr;
+    pj_sockaddr mapped_addr;
     pj_stun_sock_info info;
     pj_str_t srv_addr;
     pj_time_val timeout, t;
     int i, ret = 0;
     pj_status_t status;
 
-    PJ_LOG(3,(THIS_FILE, "  normal operation"));
+    PJ_LOG(3,(THIS_FILE, "  normal operation - (%s)", 
+	   (use_ipv6)?"IPv6":"IPv4"));
 
-    status =  create_client(cfg, &client, PJ_TRUE);
+    status =  create_client(cfg, &client, PJ_TRUE, use_ipv6);
     if (status != PJ_SUCCESS)
 	return -310;
 
-    status = create_server(client->pool, cfg->ioqueue, RESPOND_STUN|WITH_XOR_MAPPED, &srv);
+    status = create_server(client->pool, cfg->ioqueue, RESPOND_STUN|WITH_XOR_MAPPED, 
+			   use_ipv6, &srv);
     if (status != PJ_SUCCESS) {
 	destroy_client(client);
 	return -320;
@@ -463,9 +487,11 @@ static int keep_alive_test(pj_stun_config *cfg)
      * Part 1: initial Binding resolution.
      */
     PJ_LOG(3,(THIS_FILE, "    initial Binding request"));
-    srv_addr = pj_str("127.0.0.1");
+
+    srv_addr = (use_ipv6)?pj_str("::1"):pj_str("127.0.0.1");
+
     status = pj_stun_sock_start(client->sock, &srv_addr, 
-				pj_ntohs(srv->addr.ipv4.sin_port), NULL);
+				pj_sockaddr_get_port(&srv->addr), NULL);
     if (status != PJ_SUCCESS) {
 	destroy_server(srv);
 	destroy_client(client);
@@ -521,7 +547,8 @@ static int keep_alive_test(pj_stun_config *cfg)
 	goto on_return;
     }
     /* verify the mapped address */
-    pj_sockaddr_in_init(&mapped_addr, &srv->ip_to_send, srv->port_to_send);
+    pj_sockaddr_init(GET_AF(use_ipv6), &mapped_addr, 
+		     &srv->ip_to_send, srv->port_to_send);
     if (pj_sockaddr_cmp(&info.mapped_addr, &mapped_addr) != 0) {
 	PJ_LOG(3,(THIS_FILE, "    error: mapped address mismatched"));
 	ret = -383;
@@ -658,7 +685,7 @@ static int keep_alive_test(pj_stun_config *cfg)
     srv->flag = RESPOND_STUN | WITH_XOR_MAPPED;
 
     /* Change mapped address in the response */
-    srv->ip_to_send = pj_str("2.2.2.2");
+    srv->ip_to_send = (use_ipv6)?pj_str("2002:202:202::"):pj_str("2.2.2.2");    
     srv->port_to_send++;
 
     /* Reset server */
@@ -729,7 +756,8 @@ static int keep_alive_test(pj_stun_config *cfg)
 	goto on_return;
     }
     /* verify the mapped address */
-    pj_sockaddr_in_init(&mapped_addr, &srv->ip_to_send, srv->port_to_send);
+    pj_sockaddr_init(GET_AF(use_ipv6), &mapped_addr, 
+		     &srv->ip_to_send, srv->port_to_send);
     if (pj_sockaddr_cmp(&info.mapped_addr, &mapped_addr) != 0) {
 	PJ_LOG(3,(THIS_FILE, "    error: mapped address mismatched"));
 	ret = -520;
@@ -797,6 +825,10 @@ on_return:
     destroy_client(client);
     for (i=0; i<7; ++i)
 	handle_events(cfg, 100);
+
+    if ((ret == 0) && use_ipv6)
+	ret = keep_alive_test(cfg, 0);
+
     return ret;
 }
 
@@ -837,13 +869,13 @@ int stun_sock_test(void)
     
     pj_stun_config_init(&stun_cfg, mem, 0, ioqueue, timer_heap);
 
-    DO_TEST(timeout_test(&stun_cfg, PJ_FALSE));
-    DO_TEST(timeout_test(&stun_cfg, PJ_TRUE));
+    DO_TEST(timeout_test(&stun_cfg, PJ_FALSE, USE_IPV6));
+    DO_TEST(timeout_test(&stun_cfg, PJ_TRUE, USE_IPV6));
 
-    DO_TEST(missing_attr_test(&stun_cfg, PJ_FALSE));
-    DO_TEST(missing_attr_test(&stun_cfg, PJ_TRUE));
+    DO_TEST(missing_attr_test(&stun_cfg, PJ_FALSE, USE_IPV6));
+    DO_TEST(missing_attr_test(&stun_cfg, PJ_TRUE, USE_IPV6));
 
-    DO_TEST(keep_alive_test(&stun_cfg));
+    DO_TEST(keep_alive_test(&stun_cfg, USE_IPV6));
 
 on_return:
     if (timer_heap) pj_timer_heap_destroy(timer_heap);
diff --git a/pjnath/src/pjnath-test/test.h b/pjnath/src/pjnath-test/test.h
index 6a57bc0c..71d82315 100644
--- a/pjnath/src/pjnath-test/test.h
+++ b/pjnath/src/pjnath-test/test.h
@@ -27,6 +27,14 @@
 #define INCLUDE_TURN_SOCK_TEST	    1
 #define INCLUDE_CONCUR_TEST    	    1
 
+#define GET_AF(use_ipv6) (use_ipv6?pj_AF_INET6():pj_AF_INET())
+
+#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6
+#   define USE_IPV6	1
+#else
+#   define USE_IPV6	0
+#endif
+
 int stun_test(void);
 int sess_auth_test(void);
 int stun_sock_test(void);
diff --git a/pjnath/src/pjnath-test/turn_sock_test.c b/pjnath/src/pjnath-test/turn_sock_test.c
index c58ca264..cb97c466 100644
--- a/pjnath/src/pjnath-test/turn_sock_test.c
+++ b/pjnath/src/pjnath-test/turn_sock_test.c
@@ -102,6 +102,7 @@ static int create_test_session(pj_stun_config  *stun_cfg,
     pj_turn_alloc_param alloc_param;
     pj_stun_auth_cred cred;
     pj_status_t status;
+    pj_bool_t use_ipv6 = cfg->srv.flags & SERVER_IPV6;
 
     /* Create client */
     pool = pj_pool_create(mem, "turnclient", 512, 512, NULL);
@@ -113,16 +114,21 @@ static int create_test_session(pj_stun_config  *stun_cfg,
     pj_bzero(&turn_sock_cb, sizeof(turn_sock_cb));
     turn_sock_cb.on_rx_data = &turn_on_rx_data;
     turn_sock_cb.on_state = &turn_on_state;
-    status = pj_turn_sock_create(sess->stun_cfg, pj_AF_INET(), PJ_TURN_TP_UDP,
-				 &turn_sock_cb, 0, sess, &sess->turn_sock);
+    status = pj_turn_sock_create(sess->stun_cfg,
+				 GET_AF(use_ipv6),
+				 PJ_TURN_TP_UDP, 
+				 &turn_sock_cb, 
+				 0, 
+				 sess, 
+				 &sess->turn_sock);
     if (status != PJ_SUCCESS) {
 	destroy_session(sess);
 	return -20;
     }
 
     /* Create test server */
-    status = create_test_server(sess->stun_cfg, cfg->srv.flags,
-				SRV_DOMAIN, &sess->test_srv);
+    status = create_test_server(sess->stun_cfg, cfg->srv.flags, SRV_DOMAIN, 
+				&sess->test_srv);
     if (status != PJ_SUCCESS) {
 	destroy_session(sess);
 	return -30;
@@ -139,7 +145,7 @@ static int create_test_session(pj_stun_config  *stun_cfg,
 	return -40;
 
     } else {
-	pj_str_t dns_srv = pj_str("127.0.0.1");
+	pj_str_t dns_srv = use_ipv6?pj_str("::1") : pj_str("127.0.0.1");
 	pj_uint16_t dns_srv_port = (pj_uint16_t) DNS_SERVER_PORT;
 	status = pj_dns_resolver_set_ns(sess->resolver, 1, &dns_srv, &dns_srv_port);
 
@@ -170,7 +176,7 @@ static int create_test_session(pj_stun_config  *stun_cfg,
 
     } else {
 	/* Explicitly specify server address */
-	pj_str_t host = pj_str("127.0.0.1");
+	pj_str_t host = use_ipv6?pj_str("::1") : pj_str("127.0.0.1");
 	status = pj_turn_sock_alloc(sess->turn_sock, &host, TURN_SERVER_PORT,
 				    NULL, &cred, &alloc_param);
 
@@ -250,13 +256,21 @@ static void turn_on_state(pj_turn_sock *turn_sock,
 
 /////////////////////////////////////////////////////////////////////
 
-static int state_progression_test(pj_stun_config  *stun_cfg)
+static void set_server_flag(struct test_session_cfg *test_cfg, 
+			    pj_bool_t use_ipv6)
+{
+    test_cfg->srv.flags &= ~(SERVER_IPV4+SERVER_IPV6);
+    test_cfg->srv.flags |= (use_ipv6)?SERVER_IPV6:SERVER_IPV4;
+}
+
+static int state_progression_test(pj_stun_config  *stun_cfg, 
+				  pj_bool_t use_ipv6)
 {
     struct test_session_cfg test_cfg = 
     {
-	{   /* Client cfg */
-	    /* DNS SRV */   /* Destroy on state */
-	    PJ_TRUE,	    0xFFFF
+	{   /* Client cfg */			
+	    PJ_TRUE,	    /* DNS SRV */       
+	    0xFFFF	    /* Destroy on state */
 	},
 	{   /* Server cfg */
 	    0xFFFFFFFF,	    /* flags */
@@ -266,10 +280,11 @@ static int state_progression_test(pj_stun_config  *stun_cfg)
     };
     struct test_session *sess;
     unsigned i;
-    int rc;
-
-    PJ_LOG(3,("", "  state progression tests"));
+    int rc = 0;
 
+    PJ_LOG(3,("", "  state progression tests - (%s)",use_ipv6?"IPv6":"IPv4"));
+    
+    set_server_flag(&test_cfg, use_ipv6);
     for (i=0; i<=1; ++i) {
 	enum { TIMEOUT = 60 };
 	pjlib_state pjlib_state;
@@ -372,7 +387,10 @@ static int state_progression_test(pj_stun_config  *stun_cfg)
 	}
     }
 
-    return 0;
+    if (use_ipv6)
+	rc = state_progression_test(stun_cfg, 0);
+
+    return rc;
 }
 
 
@@ -380,13 +398,14 @@ static int state_progression_test(pj_stun_config  *stun_cfg)
 
 static int destroy_test(pj_stun_config  *stun_cfg,
 			pj_bool_t with_dns_srv,
-			pj_bool_t in_callback)
+			pj_bool_t in_callback,
+			pj_bool_t use_ipv6)
 {
     struct test_session_cfg test_cfg = 
     {
-	{   /* Client cfg */
-	    /* DNS SRV */   /* Destroy on state */
-	    PJ_TRUE,	    0xFFFF
+	{   /* Client cfg */	    
+	    PJ_TRUE,	    /* DNS SRV */   
+	    0xFFFF	    /* Destroy on state */
 	},
 	{   /* Server cfg */
 	    0xFFFFFFFF,	    /* flags */
@@ -404,6 +423,7 @@ static int destroy_test(pj_stun_config  *stun_cfg,
 		  ));
 
     test_cfg.client.enable_dns_srv = with_dns_srv;
+    set_server_flag(&test_cfg, use_ipv6);    
 
     for (target_state=PJ_TURN_STATE_RESOLVING; target_state<=PJ_TURN_STATE_READY; ++target_state) {
 	enum { TIMEOUT = 60 };
@@ -495,14 +515,14 @@ int turn_sock_test(void)
 	return -2;
     }
 
-    rc = state_progression_test(&stun_cfg);
+    rc = state_progression_test(&stun_cfg, USE_IPV6);
     if (rc != 0) 
 	goto on_return;
 
     for (i=0; i<=1; ++i) {
 	int j;
 	for (j=0; j<=1; ++j) {
-	    rc = destroy_test(&stun_cfg, i, j);
+	    rc = destroy_test(&stun_cfg, i, j, USE_IPV6);
 	    if (rc != 0)
 		goto on_return;
 	}
diff --git a/pjnath/src/pjnath/stun_msg_dump.c b/pjnath/src/pjnath/stun_msg_dump.c
index 29f37c54..f38e2750 100644
--- a/pjnath/src/pjnath/stun_msg_dump.c
+++ b/pjnath/src/pjnath/stun_msg_dump.c
@@ -88,19 +88,17 @@ static int print_attr(char *buffer, unsigned length,
 	{
 	    char addr[PJ_INET6_ADDRSTRLEN];
 	    const pj_stun_sockaddr_attr *attr;
+	    pj_uint16_t af;
 
 	    attr = (const pj_stun_sockaddr_attr*)ahdr;
+	    af = attr->sockaddr.addr.sa_family;
 
-	    if (attr->sockaddr.addr.sa_family == pj_AF_INET()) {
+	    if ((af == pj_AF_INET()) || (af == pj_AF_INET6())) {
 		len = pj_ansi_snprintf(p, end-p,
-				       ", IPv4 addr=%s:%d\n",
+				       ", %s addr=%s\n",
+				       (af == pj_AF_INET())?"IPv4":"IPv6",
 				       pj_sockaddr_print(&attr->sockaddr,
-				           		 addr, sizeof(addr),0),
-				       pj_sockaddr_get_port(&attr->sockaddr));
-
-	    } else if (attr->sockaddr.addr.sa_family == pj_AF_INET6()) {
-		len = pj_ansi_snprintf(p, end-p,
-				       ", IPv6 addr present\n");
+				           		addr, sizeof(addr),3));
 	    } else {
 		len = pj_ansi_snprintf(p, end-p,
 				       ", INVALID ADDRESS FAMILY!\n");