From owner-svn-ports-head@freebsd.org Wed Oct 9 14:33:38 2019 Return-Path: Delivered-To: svn-ports-head@mailman.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mailman.nyi.freebsd.org (Postfix) with ESMTP id A5B6414D9D2; Wed, 9 Oct 2019 14:33:38 +0000 (UTC) (envelope-from madpilot@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) server-signature RSA-PSS (4096 bits) client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "Let's Encrypt Authority X3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 46pGtB4gjDz4WCV; Wed, 9 Oct 2019 14:33:38 +0000 (UTC) (envelope-from madpilot@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 83EA019E56; Wed, 9 Oct 2019 14:33:38 +0000 (UTC) (envelope-from madpilot@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id x99EXcJE002243; Wed, 9 Oct 2019 14:33:38 GMT (envelope-from madpilot@FreeBSD.org) Received: (from madpilot@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id x99EXb9j002238; Wed, 9 Oct 2019 14:33:37 GMT (envelope-from madpilot@FreeBSD.org) Message-Id: <201910091433.x99EXb9j002238@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: madpilot set sender to madpilot@FreeBSD.org using -f From: Guido Falsi Date: Wed, 9 Oct 2019 14:33:37 +0000 (UTC) To: ports-committers@freebsd.org, svn-ports-all@freebsd.org, svn-ports-head@freebsd.org Subject: svn commit: r514163 - in head/net/pjsip: . files X-SVN-Group: ports-head X-SVN-Commit-Author: madpilot X-SVN-Commit-Paths: in head/net/pjsip: . files X-SVN-Commit-Revision: 514163 X-SVN-Commit-Repository: ports MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-ports-head@freebsd.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: SVN commit messages for the ports tree for head List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 09 Oct 2019 14:33:38 -0000 Author: madpilot Date: Wed Oct 9 14:33:37 2019 New Revision: 514163 URL: https://svnweb.freebsd.org/changeset/ports/514163 Log: Import patches from asterisk project. MFH: 2019Q4 Added: head/net/pjsip/files/patch-0030 (contents, props changed) head/net/pjsip/files/patch-0031 (contents, props changed) head/net/pjsip/files/patch-0032 (contents, props changed) head/net/pjsip/files/patch-0033 (contents, props changed) Modified: head/net/pjsip/Makefile Modified: head/net/pjsip/Makefile ============================================================================== --- head/net/pjsip/Makefile Wed Oct 9 14:32:26 2019 (r514162) +++ head/net/pjsip/Makefile Wed Oct 9 14:33:37 2019 (r514163) @@ -2,7 +2,7 @@ PORTNAME= pjsip PORTVERSION= 2.9 -PORTREVISION= 1 +PORTREVISION= 2 CATEGORIES= net MASTER_SITES= http://www.pjsip.org/release/${PORTVERSION}/ DISTNAME= pjproject-${DISTVERSION} Added: head/net/pjsip/files/patch-0030 ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/net/pjsip/files/patch-0030 Wed Oct 9 14:33:37 2019 (r514163) @@ -0,0 +1,60 @@ +From 8d0652d4a02c7b8da58b1b98421cfda57056184d Mon Sep 17 00:00:00 2001 +From: George Joseph +Date: Tue, 24 Sep 2019 06:41:16 -0600 +Subject: [PATCH 30/33] Revert "Misc (re #2147): Fixed warnings in SSL socket: + redefinition of typedef 'pj_ssl_sock_t' and unused 'get_pem'." + +This reverts commit 688a9b0de685328f62b2df86304b44c21e4460ae. +--- + pjlib/src/pj/ssl_sock_imp_common.h | 4 ++-- + pjlib/src/pj/ssl_sock_ossl.c | 5 +---- + 2 files changed, 3 insertions(+), 6 deletions(-) + +diff --git a/pjlib/src/pj/ssl_sock_imp_common.h b/pjlib/src/pj/ssl_sock_imp_common.h +index 09f259ef7..4edbb3b82 100644 +--- pjlib/src/pj/ssl_sock_imp_common.h ++++ pjlib/src/pj/ssl_sock_imp_common.h +@@ -93,7 +93,7 @@ typedef struct circ_buf_t { + /* + * Secure socket structure definition. + */ +-struct pj_ssl_sock_t ++typedef struct pj_ssl_sock_t + { + pj_pool_t *pool; + pj_ssl_sock_t *parent; +@@ -139,7 +139,7 @@ struct pj_ssl_sock_t + + circ_buf_t circ_buf_output; + pj_lock_t *circ_buf_output_mutex; +-}; ++} pj_ssl_sock_t; + + + /* +diff --git a/pjlib/src/pj/ssl_sock_ossl.c b/pjlib/src/pj/ssl_sock_ossl.c +index b4ac5c15f..debb105b1 100644 +--- pjlib/src/pj/ssl_sock_ossl.c ++++ pjlib/src/pj/ssl_sock_ossl.c +@@ -37,6 +37,7 @@ + #if defined(PJ_HAS_SSL_SOCK) && PJ_HAS_SSL_SOCK != 0 && \ + (PJ_SSL_SOCK_IMP == PJ_SSL_SOCK_IMP_OPENSSL) + ++#include "ssl_sock_imp_common.h" + #include "ssl_sock_imp_common.c" + + #define THIS_FILE "ssl_sock_ossl.c" +@@ -1575,10 +1576,6 @@ static void ssl_update_remote_cert_chain_info(pj_pool_t *pool, + { + int i; + +- /* For now, get_pem has to be PJ_TRUE */ +- pj_assert(get_pem); +- PJ_UNUSED_ARG(get_pem); +- + ci->raw_chain.cert_raw = (pj_str_t *)pj_pool_calloc(pool, + sk_X509_num(chain), + sizeof(pj_str_t)); +-- +2.21.0 + Added: head/net/pjsip/files/patch-0031 ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/net/pjsip/files/patch-0031 Wed Oct 9 14:33:37 2019 (r514163) @@ -0,0 +1,84 @@ +From 616a13933f33a6d74f84d85b5bfb858279a09e2d Mon Sep 17 00:00:00 2001 +From: George Joseph +Date: Tue, 24 Sep 2019 06:42:04 -0600 +Subject: [PATCH 31/33] Revert "Fixed #2204: Add OpenSSL remote certificate + chain info" + +This reverts commit f71d60c866c4572a7c8398fe982416771fc6a7f5. +--- + pjlib/src/pj/ssl_sock_ossl.c | 45 ------------------------------------ + 1 file changed, 45 deletions(-) + +diff --git a/pjlib/src/pj/ssl_sock_ossl.c b/pjlib/src/pj/ssl_sock_ossl.c +index debb105b1..109c5c1e2 100644 +--- pjlib/src/pj/ssl_sock_ossl.c ++++ pjlib/src/pj/ssl_sock_ossl.c +@@ -1566,41 +1566,6 @@ static void get_cert_info(pj_pool_t *pool, pj_ssl_cert_info *ci, X509 *x, + } + } + +-/* Update remote certificates chain info. This function should be +- * called after handshake or renegotiation successfully completed. +- */ +-static void ssl_update_remote_cert_chain_info(pj_pool_t *pool, +- pj_ssl_cert_info *ci, +- STACK_OF(X509) *chain, +- pj_bool_t get_pem) +-{ +- int i; +- +- ci->raw_chain.cert_raw = (pj_str_t *)pj_pool_calloc(pool, +- sk_X509_num(chain), +- sizeof(pj_str_t)); +- ci->raw_chain.cnt = sk_X509_num(chain); +- +- for (i = 0; i < sk_X509_num(chain); i++) { +- BIO *bio; +- BUF_MEM *ptr; +- X509 *x = sk_X509_value(chain, i); +- +- bio = BIO_new(BIO_s_mem()); +- +- if (!PEM_write_bio_X509(bio, x)) { +- PJ_LOG(3, (THIS_FILE, "Error retrieving raw certificate info")); +- ci->raw_chain.cert_raw[i].ptr = NULL; +- ci->raw_chain.cert_raw[i].slen = 0; +- } else { +- BIO_write(bio, "\0", 1); +- BIO_get_mem_ptr(bio, &ptr); +- pj_strdup2(pool, &ci->raw_chain.cert_raw[i], ptr->data ); +- } +- +- BIO_free(bio); +- } +-} + + /* Update local & remote certificates info. This function should be + * called after handshake or renegotiation successfully completed. +@@ -1609,7 +1574,6 @@ static void ssl_update_certs_info(pj_ssl_sock_t *ssock) + { + ossl_sock_t *ossock = (ossl_sock_t *)ssock; + X509 *x; +- STACK_OF(X509) *chain; + + pj_assert(ssock->ssl_state == SSL_STATE_ESTABLISHED); + +@@ -1631,15 +1595,6 @@ static void ssl_update_certs_info(pj_ssl_sock_t *ssock) + } else { + pj_bzero(&ssock->remote_cert_info, sizeof(pj_ssl_cert_info)); + } +- +- chain = SSL_get_peer_cert_chain(ossock->ossl_ssl); +- if (chain) { +- ssl_update_remote_cert_chain_info(ssock->pool, +- &ssock->remote_cert_info, +- chain, PJ_TRUE); +- } else { +- ssock->remote_cert_info.raw_chain.cnt = 0; +- } + } + + +-- +2.21.0 + Added: head/net/pjsip/files/patch-0032 ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/net/pjsip/files/patch-0032 Wed Oct 9 14:33:37 2019 (r514163) @@ -0,0 +1,64 @@ +From 17cd744e19cd332a219a512770fa6e18453044ba Mon Sep 17 00:00:00 2001 +From: George Joseph +Date: Tue, 24 Sep 2019 06:45:25 -0600 +Subject: [PATCH 32/33] Revert "Re #2147 (misc): Fix failed pjsip-test + (transport_loop_test) caused by r6002." + +This reverts commit 342148f5bcf3a6b0029ce834b8567c2cd691b15b. +--- + pjsip/src/pjsip/sip_transport.c | 12 +++++------- + pjsip/src/pjsip/sip_transport_loop.c | 2 +- + pjsip/src/test/transport_loop_test.c | 1 - + 3 files changed, 6 insertions(+), 9 deletions(-) + +diff --git a/pjsip/src/pjsip/sip_transport.c b/pjsip/src/pjsip/sip_transport.c +index 65ac823d4..d63823a98 100644 +--- pjsip/src/pjsip/sip_transport.c ++++ pjsip/src/pjsip/sip_transport.c +@@ -1222,13 +1222,11 @@ PJ_DEF(pj_status_t) pjsip_transport_register( pjsip_tpmgr *mgr, + + pj_lock_release(mgr->lock); + +- TRACE_((THIS_FILE, "Transport %s registered: type=%s, remote=%s:%d", +- tp->obj_name, +- pjsip_transport_get_type_name(tp->key.type), +- pj_sockaddr_has_addr(&tp->key.rem_addr)? +- addr_string(&tp->key.rem_addr):"", +- pj_sockaddr_has_addr(&tp->key.rem_addr)? +- pj_sockaddr_get_port(&tp->key.rem_addr):0)); ++ TRACE_((THIS_FILE,"Transport %s registered: type=%s, remote=%s:%d", ++ tp->obj_name, ++ pjsip_transport_get_type_name(tp->key.type), ++ addr_string(&tp->key.rem_addr), ++ pj_sockaddr_get_port(&tp->key.rem_addr))); + + return PJ_SUCCESS; + } +diff --git a/pjsip/src/pjsip/sip_transport_loop.c b/pjsip/src/pjsip/sip_transport_loop.c +index 37e20e69b..24e1a5f69 100644 +--- pjsip/src/pjsip/sip_transport_loop.c ++++ pjsip/src/pjsip/sip_transport_loop.c +@@ -376,7 +376,7 @@ PJ_DEF(pj_status_t) pjsip_loop_start( pjsip_endpoint *endpt, + if (status != PJ_SUCCESS) + goto on_error; + loop->base.key.type = PJSIP_TRANSPORT_LOOP_DGRAM; +- //loop->base.key.rem_addr.addr.sa_family = pj_AF_INET(); ++ loop->base.key.rem_addr.addr.sa_family = pj_AF_INET(); + loop->base.type_name = "LOOP-DGRAM"; + loop->base.info = "LOOP-DGRAM"; + loop->base.flag = PJSIP_TRANSPORT_DATAGRAM; +diff --git a/pjsip/src/test/transport_loop_test.c b/pjsip/src/test/transport_loop_test.c +index 5f2f03904..efa2ea116 100644 +--- pjsip/src/test/transport_loop_test.c ++++ pjsip/src/test/transport_loop_test.c +@@ -36,7 +36,6 @@ static int datagram_loop_test() + + PJ_LOG(3,(THIS_FILE, "testing datagram loop transport")); + +- pj_sockaddr_in_init(&addr, NULL, 0); + /* Test acquire transport. */ + status = pjsip_endpt_acquire_transport( endpt, PJSIP_TRANSPORT_LOOP_DGRAM, + &addr, sizeof(addr), NULL, &loop); +-- +2.21.0 + Added: head/net/pjsip/files/patch-0033 ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/net/pjsip/files/patch-0033 Wed Oct 9 14:33:37 2019 (r514163) @@ -0,0 +1,1094 @@ +From a720f3ffd538d3baef6f8daf78d9d320a4a5c0a0 Mon Sep 17 00:00:00 2001 +From: George Joseph +Date: Tue, 24 Sep 2019 06:45:59 -0600 +Subject: [PATCH 33/33] Revert "Close #1019: Support for multiple listeners." + +This reverts commit 142dd0e96edad15b6b9554636043b5255d5d8adf. +--- + pjsip/include/pjsip/sip_config.h | 10 +- + pjsip/src/pjsip/sip_transport.c | 318 ++++++++++----------------- + pjsip/src/pjsip/sip_transport_loop.c | 2 +- + pjsip/src/test/test.c | 3 - + pjsip/src/test/transport_tcp_test.c | 193 ++++------------ + pjsip/src/test/transport_udp_test.c | 148 +++++-------- + 6 files changed, 215 insertions(+), 459 deletions(-) + +diff --git a/pjsip/include/pjsip/sip_config.h b/pjsip/include/pjsip/sip_config.h +index 585aa722c..904df24e1 100644 +--- pjsip/include/pjsip/sip_config.h ++++ pjsip/include/pjsip/sip_config.h +@@ -433,7 +433,7 @@ PJ_INLINE(pjsip_cfg_t*) pjsip_cfg(void) + * This option can also be controlled at run-time by the + * \a accept_multiple_sdp_answers setting in pjsip_cfg_t. + * +- * Default is PJ_TRUE. ++ * Default is PJ_FALSE. + */ + #ifndef PJSIP_ACCEPT_MULTIPLE_SDP_ANSWERS + # define PJSIP_ACCEPT_MULTIPLE_SDP_ANSWERS PJ_TRUE +@@ -692,7 +692,7 @@ PJ_INLINE(pjsip_cfg_t*) pjsip_cfg(void) + * will be used as the default value for the "reuse_addr" field in the + * pjsip_tcp_transport_cfg structure. + * +- * Default is 0 on Windows and 1 on non-Windows. ++ * Default is FALSE on Windows and TRUE on non-Windows. + * + * @see PJSIP_TLS_TRANSPORT_REUSEADDR + */ +@@ -718,7 +718,7 @@ PJ_INLINE(pjsip_cfg_t*) pjsip_cfg(void) + * pj_getipinterface()/pj_gethostip(), but the address will not be + * able to accept connections. + * +- * Default is 0 (listener will be created). ++ * Default is FALSE (listener will be created). + */ + #ifndef PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER + # define PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER 0 +@@ -738,7 +738,7 @@ PJ_INLINE(pjsip_cfg_t*) pjsip_cfg(void) + * pj_getipinterface()/pj_gethostip(), but the address will not be + * able to accept connections. + * +- * Default is 0 (listener will be created). ++ * Default is FALSE (listener will be created). + */ + #ifndef PJSIP_TLS_TRANSPORT_DONT_CREATE_LISTENER + # define PJSIP_TLS_TRANSPORT_DONT_CREATE_LISTENER 0 +@@ -881,7 +881,7 @@ PJ_INLINE(pjsip_cfg_t*) pjsip_cfg(void) + /** + * Specify whether TLS listener should use SO_REUSEADDR option. + * +- * Default is 0 on Windows and 1 on non-Windows. ++ * Default is FALSE on Windows and TRUE on non-Windows. + * + * @see PJSIP_TCP_TRANSPORT_REUSEADDR + */ +diff --git a/pjsip/src/pjsip/sip_transport.c b/pjsip/src/pjsip/sip_transport.c +index d63823a98..54e8be380 100644 +--- pjsip/src/pjsip/sip_transport.c ++++ pjsip/src/pjsip/sip_transport.c +@@ -54,25 +54,6 @@ static const char *addr_string(const pj_sockaddr_t *addr) + # define TRACE_(x) + #endif + +-/* Specify the initial size of the transport manager's pool. */ +-#ifndef TPMGR_POOL_INIT_SIZE +-# define TPMGR_POOL_INIT_SIZE 64 +-#endif +- +-/* Specify the increment size of the transport manager's pool. */ +-#ifndef TPMGR_POOL_INC_SIZE +- #define TPMGR_POOL_INC_SIZE 64 +-#endif +- +-/* Specify transport entry allocation count. When registering a new transport, +- * a new entry will be picked from a free list. This setting will determine +- * the size of the free list size. If all entry is used, then the same number +- * of entry will be allocated. +- */ +-#ifndef PJSIP_TRANSPORT_ENTRY_ALLOC_CNT +-# define PJSIP_TRANSPORT_ENTRY_ALLOC_CNT 16 +-#endif +- + /* Prototype. */ + static pj_status_t mod_on_tx_msg(pjsip_tx_data *tdata); + +@@ -100,7 +81,6 @@ static pjsip_module mod_msg_print = + typedef struct transport + { + PJ_DECL_LIST_MEMBER(struct transport); +- pj_hash_entry_buf tp_buf; + pjsip_transport *tp; + } transport; + +@@ -113,7 +93,6 @@ struct pjsip_tpmgr + pj_lock_t *lock; + pjsip_endpoint *endpt; + pjsip_tpfactory factory_list; +- pj_pool_t *pool; + #if defined(PJ_DEBUG) && PJ_DEBUG!=0 + pj_atomic_t *tdata_counter; + #endif +@@ -126,9 +105,12 @@ struct pjsip_tpmgr + * is destroyed. + */ + pjsip_tx_data tdata_list; +- +- /* List of free transport entry. */ +- transport tp_entry_freelist; ++ ++ /* List of transports which are NOT stored in the hash table, so ++ * that it can be properly cleaned up when transport manager ++ * is destroyed. ++ */ ++ transport tp_list; + }; + + +@@ -1042,18 +1024,18 @@ static pj_bool_t is_transport_valid(pjsip_transport *tp, pjsip_tpmgr *tpmgr, + const pjsip_transport_key *key, + int key_len) + { +- transport *tp_entry; ++ transport *tp_iter; + +- tp_entry = (transport *)pj_hash_get(tpmgr->table, key, key_len, NULL); +- if (tp_entry != NULL) { ++ if (pj_hash_get(tpmgr->table, key, key_len, NULL) == (void*)tp) { ++ return PJ_TRUE; ++ } + +- transport *tp_iter = tp_entry; +- do { +- if (tp_iter->tp == tp) { +- return PJ_TRUE; +- } +- tp_iter = tp_iter->next; +- } while (tp_iter != tp_entry); ++ tp_iter = tpmgr->tp_list.next; ++ while (tp_iter != &tpmgr->tp_list) { ++ if (tp_iter->tp == tp) { ++ return PJ_TRUE; ++ } ++ tp_iter = tp_iter->next; + } + + return PJ_FALSE; +@@ -1153,9 +1135,8 @@ PJ_DEF(pj_status_t) pjsip_transport_dec_ref( pjsip_transport *tp ) + } + + /* Dec ref transport group lock, if any */ +- if (tp->grp_lock) { ++ if (tp->grp_lock) + pj_grp_lock_dec_ref(tp->grp_lock); +- } + + return PJ_SUCCESS; + } +@@ -1169,8 +1150,7 @@ PJ_DEF(pj_status_t) pjsip_transport_register( pjsip_tpmgr *mgr, + { + int key_len; + pj_uint32_t hval; +- transport *tp_ref = NULL; +- transport *tp_add = NULL; ++ void *entry; + + /* Init. */ + tp->tpmgr = mgr; +@@ -1178,43 +1158,31 @@ PJ_DEF(pj_status_t) pjsip_transport_register( pjsip_tpmgr *mgr, + tp->idle_timer.user_data = tp; + tp->idle_timer.cb = &transport_idle_callback; + +- /* ++ /* + * Register to hash table (see Trac ticket #42). + */ + key_len = sizeof(tp->key.type) + tp->addr_len; + pj_lock_acquire(mgr->lock); + ++ /* If entry already occupied, unregister previous entry */ + hval = 0; +- tp_ref = (transport *)pj_hash_get(mgr->table, &tp->key, key_len, &hval); +- +- /* Get an empty entry from the freelist. */ +- if (pj_list_empty(&mgr->tp_entry_freelist)) { +- unsigned i = 0; +- +- TRACE_((THIS_FILE, "Transport list is full, allocate new entry")); +- /* Allocate new entry for the freelist. */ +- for (; i < PJSIP_TRANSPORT_ENTRY_ALLOC_CNT; ++i) { +- tp_add = PJ_POOL_ZALLOC_T(mgr->pool, transport); +- if (!tp_add) +- return PJ_ENOMEM; +- pj_list_init(tp_add); +- pj_list_push_back(&mgr->tp_entry_freelist, tp_add); +- } ++ entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval); ++ if (entry != NULL) { ++ transport *tp_ref; ++ ++ tp_ref = PJ_POOL_ZALLOC_T(((pjsip_transport *)entry)->pool, transport); ++ ++ /* ++ * Add transport to the list before removing it from the hash table. ++ * See ticket #1774 for more details. ++ */ ++ tp_ref->tp = (pjsip_transport *)entry; ++ pj_list_push_back(&mgr->tp_list, tp_ref); ++ pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL); + } +- tp_add = mgr->tp_entry_freelist.next; +- tp_add->tp = tp; +- pj_list_erase(tp_add); + +- if (tp_ref) { +- /* There'a already a transport list from the hash table. Add the +- * new transport to the list. +- */ +- pj_list_push_back(tp_ref, tp_add); +- } else { +- /* Transport list not found, add it to the hash table. */ +- pj_hash_set_np(mgr->table, &tp->key, key_len, hval, tp_add->tp_buf, +- tp_add); +- } ++ /* Register new entry */ ++ pj_hash_set(tp->pool, mgr->table, &tp->key, key_len, hval, tp); + + /* Add ref transport group lock, if any */ + if (tp->grp_lock) +@@ -1261,46 +1229,26 @@ static pj_status_t destroy_transport( pjsip_tpmgr *mgr, + key_len = sizeof(tp->key.type) + tp->addr_len; + hval = 0; + entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval); +- if (entry) { +- transport *tp_ref = (transport *)entry; +- transport *tp_iter = tp_ref; +- /* Search the matching entry from the transport list. */ +- do { +- if (tp_iter->tp == tp) { +- transport *tp_next = tp_iter->next; +- +- /* Update hash table : +- * - transport list only contain single element, or +- * - the entry is the first element of the transport list. +- */ +- if (tp_iter == tp_ref) { +- pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, +- NULL); +- +- if (tp_ref->next != tp_ref) { +- /* The transport list has multiple entry. */ +- pj_hash_set_np(mgr->table, &tp_next->tp->key, key_len, +- hval, tp_next->tp_buf, tp_next); +- } +- } +- +- pj_list_erase(tp_iter); +- /* Put back to the transport freelist. */ +- pj_list_push_back(&mgr->tp_entry_freelist, tp_iter); +- +- break; +- } +- tp_iter = tp_iter->next; +- } while (tp_iter != tp_ref); ++ if (entry == (void*)tp) { ++ pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL); ++ } else { ++ /* If not found in hash table, remove from the tranport list. */ ++ transport *tp_iter = mgr->tp_list.next; ++ while (tp_iter != &mgr->tp_list) { ++ if (tp_iter->tp == tp) { ++ pj_list_erase(tp_iter); ++ break; ++ } ++ tp_iter = tp_iter->next; ++ } + } + + pj_lock_release(mgr->lock); + pj_lock_release(tp->lock); + + /* Dec ref transport group lock, if any */ +- if (tp->grp_lock) { ++ if (tp->grp_lock) + pj_grp_lock_dec_ref(tp->grp_lock); +- } + + /* Destroy. */ + return tp->destroy(tp); +@@ -1414,9 +1362,13 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_register_tpfactory( pjsip_tpmgr *mgr, + + pj_lock_acquire(mgr->lock); + +- /* Check that no same factory has been registered. */ ++ /* Check that no factory with the same type has been registered. */ + status = PJ_SUCCESS; + for (p=mgr->factory_list.next; p!=&mgr->factory_list; p=p->next) { ++ if (p->type == tpf->type) { ++ status = PJSIP_ETYPEEXISTS; ++ break; ++ } + if (p == tpf) { + status = PJ_EEXISTS; + break; +@@ -1491,8 +1443,6 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_create( pj_pool_t *pool, + { + pjsip_tpmgr *mgr; + pj_status_t status; +- unsigned i = 0; +- pj_pool_t *mgr_pool; + + PJ_ASSERT_RETURN(pool && endpt && rx_cb && p_mgr, PJ_EINVAL); + +@@ -1502,42 +1452,24 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_create( pj_pool_t *pool, + return status; + + /* Create and initialize transport manager. */ +- mgr_pool = pjsip_endpt_create_pool(endpt, "tpmgr", +- TPMGR_POOL_INIT_SIZE, +- TPMGR_POOL_INC_SIZE); +- mgr = PJ_POOL_ZALLOC_T(mgr_pool, pjsip_tpmgr); ++ mgr = PJ_POOL_ZALLOC_T(pool, pjsip_tpmgr); + mgr->endpt = endpt; + mgr->on_rx_msg = rx_cb; + mgr->on_tx_msg = tx_cb; +- mgr->pool = mgr_pool; +- +- if (!mgr->pool) +- return PJ_ENOMEM; +- + pj_list_init(&mgr->factory_list); + pj_list_init(&mgr->tdata_list); +- pj_list_init(&mgr->tp_entry_freelist); ++ pj_list_init(&mgr->tp_list); + +- mgr->table = pj_hash_create(mgr->pool, PJSIP_TPMGR_HTABLE_SIZE); ++ mgr->table = pj_hash_create(pool, PJSIP_TPMGR_HTABLE_SIZE); + if (!mgr->table) + return PJ_ENOMEM; + +- status = pj_lock_create_recursive_mutex(mgr->pool, "tmgr%p", &mgr->lock); ++ status = pj_lock_create_recursive_mutex(pool, "tmgr%p", &mgr->lock); + if (status != PJ_SUCCESS) + return status; + +- for (; i < PJSIP_TRANSPORT_ENTRY_ALLOC_CNT; ++i) { +- transport *tp_add = NULL; +- +- tp_add = PJ_POOL_ZALLOC_T(mgr->pool, transport); +- if (!tp_add) +- return PJ_ENOMEM; +- pj_list_init(tp_add); +- pj_list_push_back(&mgr->tp_entry_freelist, tp_add); +- } +- + #if defined(PJ_DEBUG) && PJ_DEBUG!=0 +- status = pj_atomic_create(mgr->pool, 0, &mgr->tdata_counter); ++ status = pj_atomic_create(pool, 0, &mgr->tdata_counter); + if (status != PJ_SUCCESS) { + pj_lock_destroy(mgr->lock); + return status; +@@ -1765,16 +1697,15 @@ PJ_DEF(unsigned) pjsip_tpmgr_get_transport_count(pjsip_tpmgr *mgr) + pj_hash_iterator_t itr_val; + pj_hash_iterator_t *itr; + int nr_of_transports = 0; +- ++ + pj_lock_acquire(mgr->lock); +- ++ + itr = pj_hash_first(mgr->table, &itr_val); + while (itr) { +- transport *tp_entry = (transport *)pj_hash_this(mgr->table, itr); +- nr_of_transports += pj_list_size(tp_entry); ++ nr_of_transports++; + itr = pj_hash_next(mgr->table, itr); + } +- ++ + pj_lock_release(mgr->lock); + + return nr_of_transports; +@@ -1791,7 +1722,7 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_destroy( pjsip_tpmgr *mgr ) + pj_hash_iterator_t *itr; + pjsip_tpfactory *factory; + pjsip_endpoint *endpt = mgr->endpt; +- ++ + PJ_LOG(5, (THIS_FILE, "Destroying transport manager")); + + pj_lock_acquire(mgr->lock); +@@ -1799,21 +1730,39 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_destroy( pjsip_tpmgr *mgr ) + /* + * Destroy all transports in the hash table. + */ +- for (itr = pj_hash_first(mgr->table, &itr_val); itr; +- itr = pj_hash_first(mgr->table, &itr_val)) +- { +- transport *tp_ref; +- tp_ref = pj_hash_this(mgr->table, itr); +- destroy_transport(mgr, tp_ref->tp); ++ itr = pj_hash_first(mgr->table, &itr_val); ++ while (itr != NULL) { ++ pj_hash_iterator_t *next; ++ pjsip_transport *transport; ++ ++ transport = (pjsip_transport*) pj_hash_this(mgr->table, itr); ++ ++ next = pj_hash_next(mgr->table, itr); ++ ++ destroy_transport(mgr, transport); ++ ++ itr = next; + } + ++ /* ++ * Destroy transports in the list. ++ */ ++ if (!pj_list_empty(&mgr->tp_list)) { ++ transport *tp_iter = mgr->tp_list.next; ++ while (tp_iter != &mgr->tp_list) { ++ transport *next = tp_iter->next; ++ destroy_transport(mgr, tp_iter->tp); ++ tp_iter = next; ++ } ++ } ++ + /* + * Destroy all factories/listeners. + */ + factory = mgr->factory_list.next; + while (factory != &mgr->factory_list) { + pjsip_tpfactory *next = factory->next; +- ++ + factory->destroy(factory); + + factory = next; +@@ -1857,10 +1806,6 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_destroy( pjsip_tpmgr *mgr ) + pjsip_endpt_unregister_module(endpt, &mod_msg_print); + } + +- if (mgr->pool) { +- pjsip_endpt_release_pool( mgr->endpt, mgr->pool ); +- } +- + return PJ_SUCCESS; + } + +@@ -2221,9 +2166,7 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr, + */ + pjsip_transport_key key; + int key_len; +- pjsip_transport *tp_ref = NULL; +- transport *tp_entry = NULL; +- ++ pjsip_transport *transport = NULL; + + /* If listener is specified, verify that the listener type matches + * the destination type. +@@ -2244,28 +2187,11 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr, + key.type = type; + pj_memcpy(&key.rem_addr, remote, addr_len); + +- tp_entry = (transport *)pj_hash_get(mgr->table, &key, key_len, +- NULL); +- if (tp_entry) { +- if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER) { +- transport *tp_iter = tp_entry; +- do { +- if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER && +- sel->u.listener && +- tp_iter->tp->factory == sel->u.listener) +- { +- tp_ref = tp_iter->tp; +- break; +- } +- tp_iter = tp_iter->next; +- } while (tp_iter != tp_entry); +- } else { +- tp_ref = tp_entry->tp; +- } +- } ++ transport = (pjsip_transport*) ++ pj_hash_get(mgr->table, &key, key_len, NULL); + } + +- if (tp_ref == NULL && ++ if (transport == NULL && + (!sel || sel->disable_connection_reuse == PJ_FALSE)) + { + unsigned flag = pjsip_transport_get_flag_from_type(type); +@@ -2280,11 +2206,8 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr, + + pj_bzero(addr, addr_len); + key_len = sizeof(key.type) + addr_len; +- tp_entry = (transport *) pj_hash_get(mgr->table, &key, +- key_len, NULL); +- if (tp_entry) { +- tp_ref = tp_entry->tp; +- } ++ transport = (pjsip_transport*) ++ pj_hash_get(mgr->table, &key, key_len, NULL); + } + /* For datagram transports, try lookup with zero address. + */ +@@ -2296,34 +2219,31 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr, + addr->addr.sa_family = remote_addr->addr.sa_family; + + key_len = sizeof(key.type) + addr_len; +- tp_entry = (transport *) pj_hash_get(mgr->table, &key, +- key_len, NULL); +- if (tp_entry) { +- tp_ref = tp_entry->tp; +- } ++ transport = (pjsip_transport*) ++ pj_hash_get(mgr->table, &key, key_len, NULL); + } + } + + /* If transport is found and listener is specified, verify listener */ + else if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER && +- sel->u.listener && tp_ref->factory != sel->u.listener) ++ sel->u.listener && transport->factory != sel->u.listener) + { +- tp_ref = NULL; ++ transport = NULL; + /* This will cause a new transport to be created which will be a + * 'duplicate' of the existing transport (same type & remote addr, + * but different factory). + */ + } + +- if (tp_ref!=NULL && !tp_ref->is_shutdown) { ++ if (transport!=NULL && !transport->is_shutdown) { + /* + * Transport found! + */ +- pjsip_transport_add_ref(tp_ref); ++ pjsip_transport_add_ref(transport); + pj_lock_release(mgr->lock); +- *tp = tp_ref; ++ *tp = transport; + +- TRACE_((THIS_FILE, "Transport %s acquired", tp_ref->obj_name)); ++ TRACE_((THIS_FILE, "Transport %s acquired", transport->obj_name)); + return PJ_SUCCESS; + } + +@@ -2385,15 +2305,15 @@ PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr, + /* Request factory to create transport. */ + if (factory->create_transport2) { + status = factory->create_transport2(factory, mgr, mgr->endpt, +- (const pj_sockaddr*) remote, ++ (const pj_sockaddr*) remote, + addr_len, tdata, tp); + } else { + status = factory->create_transport(factory, mgr, mgr->endpt, +- (const pj_sockaddr*) remote, ++ (const pj_sockaddr*) remote, + addr_len, tp); + } + if (status == PJ_SUCCESS) { +- PJ_ASSERT_ON_FAIL(tp!=NULL, ++ PJ_ASSERT_ON_FAIL(tp!=NULL, + {pj_lock_release(mgr->lock); return PJ_EBUG;}); + pjsip_transport_add_ref(*tp); + (*tp)->factory = factory; +@@ -2436,25 +2356,15 @@ PJ_DEF(void) pjsip_tpmgr_dump_transports(pjsip_tpmgr *mgr) + PJ_LOG(3, (THIS_FILE, " Dumping transports:")); + + do { +- transport *tp_entry = (transport *) pj_hash_this(mgr->table, itr); +- if (tp_entry) { +- transport *tp_iter = tp_entry; +- +- do { +- pjsip_transport *tp_ref = tp_iter->tp; +- +- PJ_LOG(3, (THIS_FILE, " %s %s%s%s%s(refcnt=%d%s)", +- tp_ref->obj_name, +- tp_ref->info, +- (tp_ref->factory)?" listener[":"", +- (tp_ref->factory)?tp_ref->factory->obj_name:"", +- (tp_ref->factory)?"]":"", +- pj_atomic_get(tp_ref->ref_cnt), +- (tp_ref->idle_timer.id ? " [idle]" : ""))); +- +- tp_iter = tp_iter->next; +- } while (tp_iter != tp_entry); +- } ++ pjsip_transport *t = (pjsip_transport*) ++ pj_hash_this(mgr->table, itr); ++ ++ PJ_LOG(3, (THIS_FILE, " %s %s (refcnt=%d%s)", ++ t->obj_name, ++ t->info, ++ pj_atomic_get(t->ref_cnt), ++ (t->idle_timer.id ? " [idle]" : ""))); ++ + itr = pj_hash_next(mgr->table, itr); + } while (itr); + } +diff --git a/pjsip/src/pjsip/sip_transport_loop.c b/pjsip/src/pjsip/sip_transport_loop.c +index 24e1a5f69..5cbe26a97 100644 +--- pjsip/src/pjsip/sip_transport_loop.c ++++ pjsip/src/pjsip/sip_transport_loop.c +@@ -376,7 +376,7 @@ PJ_DEF(pj_status_t) pjsip_loop_start( pjsip_endpoint *endpt, + if (status != PJ_SUCCESS) + goto on_error; + loop->base.key.type = PJSIP_TRANSPORT_LOOP_DGRAM; +- loop->base.key.rem_addr.addr.sa_family = pj_AF_INET(); ++ //loop->base.key.rem_addr.sa_family = pj_AF_INET(); + loop->base.type_name = "LOOP-DGRAM"; + loop->base.info = "LOOP-DGRAM"; + loop->base.flag = PJSIP_TRANSPORT_DATAGRAM; +diff --git a/pjsip/src/test/test.c b/pjsip/src/test/test.c +index 3898d45ff..0361e6178 100644 +--- pjsip/src/test/test.c ++++ pjsip/src/test/test.c +@@ -379,9 +379,6 @@ int test_main(void) + on_return: + flush_events(500); + +- /* Show additional info on the log. e.g: not released memory pool. */ +- pj_log_set_level(4); +- + /* Dumping memory pool usage */ + PJ_LOG(3,(THIS_FILE, "Peak memory size=%u MB", + caching_pool.peak_used_size / 1000000)); +diff --git a/pjsip/src/test/transport_tcp_test.c b/pjsip/src/test/transport_tcp_test.c +index b10455664..3ff5f8ff4 100644 +--- pjsip/src/test/transport_tcp_test.c ++++ pjsip/src/test/transport_tcp_test.c +@@ -29,154 +29,64 @@ + * TCP transport test. + */ + #if PJ_HAS_TCP +- +-static pj_status_t multi_listener_test(pjsip_tpfactory *factory[], +- unsigned num_factory, +- pjsip_transport *tp[], +- unsigned *num_tp) ++int transport_tcp_test(void) + { +- pj_status_t status; +- unsigned i = 0; +- pj_str_t s; ++ enum { SEND_RECV_LOOP = 8 }; ++ pjsip_tpfactory *tpfactory; + pjsip_transport *tcp; +- pjsip_tpfactory *tpfactory = NULL; + pj_sockaddr_in rem_addr; +- pjsip_tpselector tp_sel; +- unsigned ntp = 0; +- +- for (;iaddr_name.host, + (pj_uint16_t)tpfactory->addr_name.port); + if (status != PJ_SUCCESS) { + app_perror(" Error: possibly invalid TCP address name", status); +- return -11; ++ return -14; + } + +- /* Acquire transport without selector. */ +- status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_TCP, +- &rem_addr, sizeof(rem_addr), +- NULL, &tcp); +- if (status != PJ_SUCCESS || tcp == NULL) { +- app_perror(" Error: unable to acquire TCP transport", status); +- return -12; +- } +- tp[ntp++] = tcp; ++ pj_ansi_sprintf(url, "sip:alice@%s:%d;transport=tcp", ++ pj_inet_ntop2(pj_AF_INET(), &rem_addr.sin_addr, addr, ++ sizeof(addr)), ++ pj_ntohs(rem_addr.sin_port)); + +- /* After pjsip_endpt_acquire_transport, TCP transport must have +- * reference counter 1. +- */ +- if (pj_atomic_get(tcp->ref_cnt) != 1) +- return -13; + +- /* Acquire with the same remote address, should return the same tp. */ +- status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_TCP, ++ /* Acquire one TCP transport. */ ++ status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_TCP, + &rem_addr, sizeof(rem_addr), + NULL, &tcp); + if (status != PJ_SUCCESS || tcp == NULL) { + app_perror(" Error: unable to acquire TCP transport", status); +- return -14; +- } +- +- /* Should return existing transport. */ +- if (tp[ntp-1] != tcp) { +- return -15; ++ return -17; + } + +- /* Using the same TCP transport, it must have reference counter 2. ++ /* After pjsip_endpt_acquire_transport, TCP transport must have ++ * reference counter 1. + */ +- if (pj_atomic_get(tcp->ref_cnt) != 2) +- return -16; +- +- /* Decrease the reference. */ +- pjsip_transport_dec_ref(tcp); ++ if (pj_atomic_get(tcp->ref_cnt) != 1) ++ return -20; + + /* Test basic transport attributes */ + status = generic_transport_test(tcp); + if (status != PJ_SUCCESS) + return status; + ++ + /* Check again that reference counter is 1. */ + if (pj_atomic_get(tcp->ref_cnt) != 1) +- return -17; +- +- /* Acquire transport test with selector. */ +- pj_bzero(&tp_sel, sizeof(tp_sel)); +- tp_sel.type = PJSIP_TPSELECTOR_LISTENER; +- tp_sel.u.listener = factory[num_factory/2]; +- pj_sockaddr_in_init(&rem_addr, pj_cstr(&s, "1.1.1.1"), 80); +- status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_TCP, +- &rem_addr, sizeof(rem_addr), +- &tp_sel, &tcp); +- if (status != PJ_SUCCESS) { +- app_perror(" Error: unable to acquire TCP transport", status); +- return -18; +- } +- *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***