Ignore:
Timestamp:
May 23, 2019 5:21:59 PM (5 years ago)
Author:
riza
Message:

Close #1019: Support for multiple listeners.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjsip/src/pjsip/sip_transport.c

    r5984 r6002  
    5555#endif 
    5656 
     57/* Specify the initial size of the transport manager's pool. */ 
     58#ifndef  TPMGR_POOL_INIT_SIZE 
     59#   define TPMGR_POOL_INIT_SIZE 64 
     60#endif 
     61 
     62/* Specify the increment size of the transport manager's pool. */ 
     63#ifndef TPMGR_POOL_INC_SIZE 
     64    #define TPMGR_POOL_INC_SIZE 64 
     65#endif 
     66 
     67/* Specify transport entry allocation count. When registering a new transport, 
     68 * a new entry will be picked from a free list. This setting will determine 
     69 * the size of the free list size. If all entry is used, then the same number 
     70 * of entry will be allocated. 
     71 */ 
     72#ifndef PJSIP_TRANSPORT_ENTRY_ALLOC_CNT 
     73#   define PJSIP_TRANSPORT_ENTRY_ALLOC_CNT  16 
     74#endif 
     75 
    5776/* Prototype. */ 
    5877static pj_status_t mod_on_tx_msg(pjsip_tx_data *tdata); 
    … …  
    82101{ 
    83102    PJ_DECL_LIST_MEMBER(struct transport); 
     103    pj_hash_entry_buf tp_buf; 
    84104    pjsip_transport *tp; 
    85105} transport; 
    … …  
    94114    pjsip_endpoint  *endpt; 
    95115    pjsip_tpfactory  factory_list; 
     116    pj_pool_t       *pool; 
    96117#if defined(PJ_DEBUG) && PJ_DEBUG!=0 
    97118    pj_atomic_t     *tdata_counter; 
    … …  
    106127     */ 
    107128    pjsip_tx_data    tdata_list; 
    108      
    109     /* List of transports which are NOT stored in the hash table, so 
    110      * that it can be properly cleaned up when transport manager 
    111      * is destroyed. 
    112      */ 
    113     transport        tp_list; 
     129 
     130    /* List of free transport entry. */ 
     131    transport        tp_entry_freelist; 
    114132}; 
    115133 
    … …  
    10251043                                    int key_len) 
    10261044{ 
    1027     transport *tp_iter; 
    1028  
    1029     if (pj_hash_get(tpmgr->table, key, key_len, NULL) == (void*)tp) { 
    1030         return PJ_TRUE; 
    1031     } 
    1032  
    1033     tp_iter = tpmgr->tp_list.next; 
    1034     while (tp_iter != &tpmgr->tp_list) { 
    1035         if (tp_iter->tp == tp) { 
    1036             return PJ_TRUE; 
    1037         } 
    1038         tp_iter = tp_iter->next; 
     1045    transport *tp_entry; 
     1046 
     1047    tp_entry = (transport *)pj_hash_get(tpmgr->table, key, key_len, NULL); 
     1048    if (tp_entry != NULL) { 
     1049 
     1050        transport *tp_iter = tp_entry; 
     1051        do { 
     1052            if (tp_iter->tp == tp) { 
     1053                return PJ_TRUE; 
     1054            } 
     1055            tp_iter = tp_iter->next; 
     1056        } while (tp_iter != tp_entry); 
    10391057    } 
    10401058 
    … …  
    11361154 
    11371155    /* Dec ref transport group lock, if any */ 
    1138     if (tp->grp_lock) 
     1156    if (tp->grp_lock) { 
    11391157        pj_grp_lock_dec_ref(tp->grp_lock); 
     1158    } 
    11401159 
    11411160    return PJ_SUCCESS; 
    … …  
    11511170    int key_len; 
    11521171    pj_uint32_t hval; 
    1153     void *entry; 
     1172    transport *tp_ref = NULL; 
     1173    transport *tp_add = NULL; 
    11541174 
    11551175    /* Init. */ 
    … …  
    11591179    tp->idle_timer.cb = &transport_idle_callback; 
    11601180 
    1161     /*  
     1181    /* 
    11621182     * Register to hash table (see Trac ticket #42). 
    11631183     */ 
    … …  
    11651185    pj_lock_acquire(mgr->lock); 
    11661186 
    1167     /* If entry already occupied, unregister previous entry */ 
    11681187    hval = 0; 
    1169     entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval); 
    1170     if (entry != NULL) { 
    1171         transport *tp_ref; 
    1172          
    1173         tp_ref = PJ_POOL_ZALLOC_T(((pjsip_transport *)entry)->pool, transport); 
    1174          
    1175         /* 
    1176          * Add transport to the list before removing it from the hash table. 
    1177          * See ticket #1774 for more details. 
    1178          */ 
    1179         tp_ref->tp = (pjsip_transport *)entry; 
    1180         pj_list_push_back(&mgr->tp_list, tp_ref); 
    1181         pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL); 
    1182     } 
    1183  
    1184     /* Register new entry */ 
    1185     pj_hash_set(tp->pool, mgr->table, &tp->key, key_len, hval, tp); 
     1188    tp_ref = (transport *)pj_hash_get(mgr->table, &tp->key, key_len, &hval); 
     1189 
     1190    /* Get an empty entry from the freelist. */ 
     1191    if (pj_list_empty(&mgr->tp_entry_freelist)) { 
     1192        unsigned i = 0; 
     1193 
     1194        TRACE_((THIS_FILE, "Transport list is full, allocate new entry")); 
     1195        /* Allocate new entry for the freelist. */ 
     1196        for (; i < PJSIP_TRANSPORT_ENTRY_ALLOC_CNT; ++i) { 
     1197            tp_add = PJ_POOL_ZALLOC_T(mgr->pool, transport); 
     1198            if (!tp_add) 
     1199                return PJ_ENOMEM; 
     1200            pj_list_init(tp_add); 
     1201            pj_list_push_back(&mgr->tp_entry_freelist, tp_add); 
     1202        } 
     1203    } 
     1204    tp_add = mgr->tp_entry_freelist.next; 
     1205    tp_add->tp = tp; 
     1206    pj_list_erase(tp_add); 
     1207 
     1208    if (tp_ref) { 
     1209        /* There'a already a transport list from the hash table. Add the  
     1210         * new transport to the list. 
     1211         */ 
     1212        pj_list_push_back(tp_ref, tp_add); 
     1213    } else { 
     1214        /* Transport list not found, add it to the hash table. */ 
     1215        pj_hash_set_np(mgr->table, &tp->key, key_len, hval, tp_add->tp_buf, 
     1216                       tp_add); 
     1217    } 
    11861218 
    11871219    /* Add ref transport group lock, if any */ 
    … …  
    12301262    hval = 0; 
    12311263    entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval); 
    1232     if (entry == (void*)tp) { 
    1233         pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL); 
    1234     } else { 
    1235         /* If not found in hash table, remove from the tranport list. */ 
    1236         transport *tp_iter = mgr->tp_list.next; 
    1237         while (tp_iter != &mgr->tp_list) { 
    1238             if (tp_iter->tp == tp) { 
    1239                 pj_list_erase(tp_iter); 
    1240                 break; 
    1241             } 
    1242             tp_iter = tp_iter->next; 
    1243         } 
     1264    if (entry) { 
     1265        transport *tp_ref = (transport *)entry; 
     1266        transport *tp_iter = tp_ref; 
     1267        /* Search the matching entry from the transport list. */ 
     1268        do { 
     1269            if (tp_iter->tp == tp) { 
     1270                transport *tp_next = tp_iter->next; 
     1271 
     1272                /* Update hash table : 
     1273                 * - transport list only contain single element, or 
     1274                 * - the entry is the first element of the transport list. 
     1275                 */ 
     1276                if (tp_iter == tp_ref) { 
     1277                    pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, 
     1278                                NULL); 
     1279 
     1280                    if (tp_ref->next != tp_ref) { 
     1281                        /* The transport list has multiple entry. */ 
     1282                        pj_hash_set_np(mgr->table, &tp_next->tp->key, key_len, 
     1283                                       hval, tp_next->tp_buf, tp_next); 
     1284                    } 
     1285                } 
     1286 
     1287                pj_list_erase(tp_iter); 
     1288                /* Put back to the transport freelist. */ 
     1289                pj_list_push_back(&mgr->tp_entry_freelist, tp_iter); 
     1290 
     1291                break; 
     1292            } 
     1293            tp_iter = tp_iter->next; 
     1294        } while (tp_iter != tp_ref); 
    12441295    } 
    12451296 
    … …  
    12481299 
    12491300    /* Dec ref transport group lock, if any */ 
    1250     if (tp->grp_lock) 
     1301    if (tp->grp_lock) { 
    12511302        pj_grp_lock_dec_ref(tp->grp_lock); 
     1303    } 
    12521304 
    12531305    /* Destroy. */ 
    … …  
    13631415    pj_lock_acquire(mgr->lock); 
    13641416 
    1365     /* Check that no factory with the same type has been registered. */ 
     1417    /* Check that no same factory has been registered. */ 
    13661418    status = PJ_SUCCESS; 
    13671419    for (p=mgr->factory_list.next; p!=&mgr->factory_list; p=p->next) { 
    1368         if (p->type == tpf->type) { 
    1369             status = PJSIP_ETYPEEXISTS; 
    1370             break; 
    1371         } 
    13721420        if (p == tpf) { 
    13731421            status = PJ_EEXISTS; 
    … …  
    14441492    pjsip_tpmgr *mgr; 
    14451493    pj_status_t status; 
     1494    unsigned i = 0; 
     1495    pj_pool_t *mgr_pool; 
    14461496 
    14471497    PJ_ASSERT_RETURN(pool && endpt && rx_cb && p_mgr, PJ_EINVAL); 
    … …  
    14531503 
    14541504    /* Create and initialize transport manager. */ 
    1455     mgr = PJ_POOL_ZALLOC_T(pool, pjsip_tpmgr); 
     1505    mgr_pool = pjsip_endpt_create_pool(endpt, "tpmgr", 
     1506                                       TPMGR_POOL_INIT_SIZE, 
     1507                                       TPMGR_POOL_INC_SIZE); 
     1508    mgr = PJ_POOL_ZALLOC_T(mgr_pool, pjsip_tpmgr); 
    14561509    mgr->endpt = endpt; 
    14571510    mgr->on_rx_msg = rx_cb; 
    14581511    mgr->on_tx_msg = tx_cb; 
     1512    mgr->pool = mgr_pool; 
     1513 
     1514    if (!mgr->pool) 
     1515        return PJ_ENOMEM; 
     1516 
    14591517    pj_list_init(&mgr->factory_list); 
    14601518    pj_list_init(&mgr->tdata_list); 
    1461     pj_list_init(&mgr->tp_list); 
    1462  
    1463     mgr->table = pj_hash_create(pool, PJSIP_TPMGR_HTABLE_SIZE); 
     1519    pj_list_init(&mgr->tp_entry_freelist); 
     1520 
     1521    mgr->table = pj_hash_create(mgr->pool, PJSIP_TPMGR_HTABLE_SIZE); 
    14641522    if (!mgr->table) 
    14651523        return PJ_ENOMEM; 
    14661524 
    1467     status = pj_lock_create_recursive_mutex(pool, "tmgr%p", &mgr->lock); 
     1525    status = pj_lock_create_recursive_mutex(mgr->pool, "tmgr%p", &mgr->lock); 
    14681526    if (status != PJ_SUCCESS) 
    14691527        return status; 
    14701528 
     1529    for (; i < PJSIP_TRANSPORT_ENTRY_ALLOC_CNT; ++i) { 
     1530        transport *tp_add = NULL; 
     1531 
     1532        tp_add = PJ_POOL_ZALLOC_T(mgr->pool, transport); 
     1533        if (!tp_add) 
     1534            return PJ_ENOMEM; 
     1535        pj_list_init(tp_add); 
     1536        pj_list_push_back(&mgr->tp_entry_freelist, tp_add); 
     1537    } 
     1538 
    14711539#if defined(PJ_DEBUG) && PJ_DEBUG!=0 
    1472     status = pj_atomic_create(pool, 0, &mgr->tdata_counter); 
     1540    status = pj_atomic_create(mgr->pool, 0, &mgr->tdata_counter); 
    14731541    if (status != PJ_SUCCESS) { 
    14741542        pj_lock_destroy(mgr->lock); 
    … …  
    16981766    pj_hash_iterator_t *itr; 
    16991767    int nr_of_transports = 0; 
    1700      
     1768 
    17011769    pj_lock_acquire(mgr->lock); 
    1702      
     1770 
    17031771    itr = pj_hash_first(mgr->table, &itr_val); 
    17041772    while (itr) { 
    1705         nr_of_transports++; 
     1773        transport *tp_entry = (transport *)pj_hash_this(mgr->table, itr); 
     1774        nr_of_transports += pj_list_size(tp_entry); 
    17061775        itr = pj_hash_next(mgr->table, itr); 
    17071776    } 
    1708      
     1777 
    17091778    pj_lock_release(mgr->lock); 
    17101779 
    … …  
    17231792    pjsip_tpfactory *factory; 
    17241793    pjsip_endpoint *endpt = mgr->endpt; 
    1725      
     1794 
    17261795    PJ_LOG(5, (THIS_FILE, "Destroying transport manager")); 
    17271796 
    … …  
    17311800     * Destroy all transports in the hash table. 
    17321801     */ 
    1733     itr = pj_hash_first(mgr->table, &itr_val); 
    1734     while (itr != NULL) { 
    1735         pj_hash_iterator_t *next; 
    1736         pjsip_transport *transport; 
    1737          
    1738         transport = (pjsip_transport*) pj_hash_this(mgr->table, itr); 
    1739  
    1740         next = pj_hash_next(mgr->table, itr); 
    1741  
    1742         destroy_transport(mgr, transport); 
    1743  
    1744         itr = next; 
    1745     } 
    1746  
    1747     /* 
    1748      * Destroy transports in the list. 
    1749      */ 
    1750     if (!pj_list_empty(&mgr->tp_list)) { 
    1751         transport *tp_iter = mgr->tp_list.next; 
    1752         while (tp_iter != &mgr->tp_list) { 
    1753             transport *next = tp_iter->next; 
    1754             destroy_transport(mgr, tp_iter->tp); 
    1755             tp_iter = next; 
    1756         } 
    1757     } 
    1758      
     1802    for (itr = pj_hash_first(mgr->table, &itr_val); itr; 
     1803         itr = pj_hash_first(mgr->table, &itr_val)) 
     1804    { 
     1805        transport *tp_ref; 
     1806        tp_ref = pj_hash_this(mgr->table, itr); 
     1807        destroy_transport(mgr, tp_ref->tp); 
     1808    } 
     1809 
    17591810    /* 
    17601811     * Destroy all factories/listeners. 
    … …  
    17631814    while (factory != &mgr->factory_list) { 
    17641815        pjsip_tpfactory *next = factory->next; 
    1765          
     1816 
    17661817        factory->destroy(factory); 
    17671818 
    … …  
    18051856    if (mod_msg_print.id != -1) { 
    18061857        pjsip_endpt_unregister_module(endpt, &mod_msg_print); 
     1858    } 
     1859 
     1860    if (mgr->pool) { 
     1861        pjsip_endpt_release_pool( mgr->endpt, mgr->pool ); 
    18071862    } 
    18081863 
    … …  
    21672222        pjsip_transport_key key; 
    21682223        int key_len; 
    2169         pjsip_transport *transport = NULL; 
     2224        pjsip_transport *tp_ref = NULL; 
     2225        transport *tp_entry = NULL; 
     2226 
    21702227 
    21712228        /* If listener is specified, verify that the listener type matches 
    … …  
    21882245            pj_memcpy(&key.rem_addr, remote, addr_len); 
    21892246 
    2190             transport = (pjsip_transport*) 
    2191                         pj_hash_get(mgr->table, &key, key_len, NULL); 
    2192         } 
    2193  
    2194         if (transport == NULL && 
     2247            tp_entry = (transport *)pj_hash_get(mgr->table, &key, key_len, 
     2248                                                NULL); 
     2249            if (tp_entry) { 
     2250                if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER) { 
     2251                    transport *tp_iter = tp_entry; 
     2252                    do { 
     2253                        if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER && 
     2254                            sel->u.listener && 
     2255                            tp_iter->tp->factory == sel->u.listener) 
     2256                        { 
     2257                            tp_ref = tp_iter->tp; 
     2258                            break; 
     2259                        } 
     2260                        tp_iter = tp_iter->next; 
     2261                    } while (tp_iter != tp_entry); 
     2262                } else { 
     2263                    tp_ref = tp_entry->tp; 
     2264                } 
     2265            } 
     2266        } 
     2267 
     2268        if (tp_ref == NULL && 
    21952269            (!sel || sel->disable_connection_reuse == PJ_FALSE)) 
    21962270        { 
    … …  
    22072281                pj_bzero(addr, addr_len); 
    22082282                key_len = sizeof(key.type) + addr_len; 
    2209                 transport = (pjsip_transport*)  
    2210                             pj_hash_get(mgr->table, &key, key_len, NULL); 
     2283                tp_entry = (transport *) pj_hash_get(mgr->table, &key, 
     2284                                                     key_len, NULL); 
     2285                if (tp_entry) { 
     2286                    tp_ref = tp_entry->tp; 
     2287                } 
    22112288            } 
    22122289            /* For datagram transports, try lookup with zero address. 
    … …  
    22202297 
    22212298                key_len = sizeof(key.type) + addr_len; 
    2222                 transport = (pjsip_transport*) 
    2223                             pj_hash_get(mgr->table, &key, key_len, NULL); 
     2299                tp_entry = (transport *) pj_hash_get(mgr->table, &key, 
     2300                                                     key_len, NULL); 
     2301                if (tp_entry) { 
     2302                    tp_ref = tp_entry->tp; 
     2303                } 
    22242304            } 
    22252305        } 
    … …  
    22272307        /* If transport is found and listener is specified, verify listener */ 
    22282308        else if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER && 
    2229                  sel->u.listener && transport->factory != sel->u.listener) 
     2309                 sel->u.listener && tp_ref->factory != sel->u.listener) 
    22302310        { 
    2231             transport = NULL; 
     2311            tp_ref = NULL; 
    22322312            /* This will cause a new transport to be created which will be a 
    22332313             * 'duplicate' of the existing transport (same type & remote addr, 
    … …  
    22362316        } 
    22372317 
    2238         if (transport!=NULL && !transport->is_shutdown) { 
     2318        if (tp_ref!=NULL && !tp_ref->is_shutdown) { 
    22392319            /* 
    22402320             * Transport found! 
    22412321             */ 
    2242             pjsip_transport_add_ref(transport); 
     2322            pjsip_transport_add_ref(tp_ref); 
    22432323            pj_lock_release(mgr->lock); 
    2244             *tp = transport; 
    2245  
    2246             TRACE_((THIS_FILE, "Transport %s acquired", transport->obj_name)); 
     2324            *tp = tp_ref; 
     2325 
     2326            TRACE_((THIS_FILE, "Transport %s acquired", tp_ref->obj_name)); 
    22472327            return PJ_SUCCESS; 
    22482328        } 
    … …  
    23062386    if (factory->create_transport2) { 
    23072387        status = factory->create_transport2(factory, mgr, mgr->endpt, 
    2308                                             (const pj_sockaddr*) remote,  
     2388                                            (const pj_sockaddr*) remote, 
    23092389                                            addr_len, tdata, tp); 
    23102390    } else { 
    23112391        status = factory->create_transport(factory, mgr, mgr->endpt, 
    2312                                            (const pj_sockaddr*) remote,  
     2392                                           (const pj_sockaddr*) remote, 
    23132393                                           addr_len, tp); 
    23142394    } 
    23152395    if (status == PJ_SUCCESS) { 
    2316         PJ_ASSERT_ON_FAIL(tp!=NULL,  
     2396        PJ_ASSERT_ON_FAIL(tp!=NULL, 
    23172397            {pj_lock_release(mgr->lock); return PJ_EBUG;}); 
    23182398        pjsip_transport_add_ref(*tp); 
    … …  
    23572437 
    23582438        do { 
    2359             pjsip_transport *t = (pjsip_transport*)  
    2360                                  pj_hash_this(mgr->table, itr); 
    2361  
    2362             PJ_LOG(3, (THIS_FILE, "  %s %s (refcnt=%d%s)",  
    2363                        t->obj_name, 
    2364                        t->info, 
    2365                        pj_atomic_get(t->ref_cnt), 
    2366                        (t->idle_timer.id ? " [idle]" : ""))); 
    2367  
     2439            transport *tp_entry = (transport *) pj_hash_this(mgr->table, itr); 
     2440            if (tp_entry) { 
     2441                transport *tp_iter = tp_entry; 
     2442 
     2443                do { 
     2444                    pjsip_transport *tp_ref = tp_iter->tp; 
     2445 
     2446                    PJ_LOG(3, (THIS_FILE, "  %s %s%s%s%s(refcnt=%d%s)", 
     2447                               tp_ref->obj_name, 
     2448                               tp_ref->info, 
     2449                               (tp_ref->factory)?" listener[":"", 
     2450                               (tp_ref->factory)?tp_ref->factory->obj_name:"", 
     2451                               (tp_ref->factory)?"]":"", 
     2452                               pj_atomic_get(tp_ref->ref_cnt), 
     2453                               (tp_ref->idle_timer.id ? " [idle]" : ""))); 
     2454 
     2455                    tp_iter = tp_iter->next; 
     2456                } while (tp_iter != tp_entry); 
     2457            } 
    23682458            itr = pj_hash_next(mgr->table, itr); 
    23692459        } while (itr); 
Note: See TracChangeset for help on using the changeset viewer.