Ignore:
Timestamp:
Jan 7, 2006 6:44:25 PM (18 years ago)
Author:
bennylp
Message:

Added test functions for UAC transaction

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjsip/src/pjsip/sip_transport_loop.c

    r107 r109  
    2828 
    2929 
    30 #define FAIL_IMMEDIATE  1 
    31 #define FAIL_CALLBACK   2 
    32  
    3330#define ADDR_LOOP       "128.0.0.1" 
    3431#define ADDR_LOOP_DGRAM "129.0.0.1" 
     
    6259    pj_bool_t                discard; 
    6360    int                      fail_mode; 
    64     unsigned                 delay; 
     61    unsigned                 recv_delay; 
     62    unsigned                 send_delay; 
    6563    struct recv_list         recv_list; 
    6664    struct send_list         send_list; 
     
    10199    /* When do we need to "deliver" this packet. */ 
    102100    pj_gettimeofday(&pkt->rdata.pkt_info.timestamp); 
    103     pkt->rdata.pkt_info.timestamp.msec += loop->delay; 
     101    pkt->rdata.pkt_info.timestamp.msec += loop->recv_delay; 
    104102    pj_time_val_normalize(&pkt->rdata.pkt_info.timestamp); 
    105103 
     
    131129 
    132130    pj_gettimeofday(&sent_status->sent_time); 
    133     sent_status->sent_time.msec += loop->delay; 
     131    sent_status->sent_time.msec += loop->send_delay; 
    134132    pj_time_val_normalize(&sent_status->sent_time); 
    135133 
     
    161159 
    162160 
    163     /* Need to send failure immediately? */ 
    164     if (loop->fail_mode == FAIL_IMMEDIATE) { 
    165         return PJ_STATUS_FROM_OS(OSERR_ECONNRESET); 
    166  
    167     /* Need to send failure later? */ 
    168     } else if (loop->fail_mode == FAIL_CALLBACK) { 
    169  
    170         add_notification(loop, tdata, -PJ_STATUS_FROM_OS(OSERR_ECONNRESET),  
    171                          token, cb); 
    172  
    173         return PJ_EPENDING; 
     161    /* Need to send failure? */ 
     162    if (loop->fail_mode) { 
     163        if (loop->send_delay == 0) { 
     164            return PJ_STATUS_FROM_OS(OSERR_ECONNRESET); 
     165        } else { 
     166            add_notification(loop, tdata, -PJ_STATUS_FROM_OS(OSERR_ECONNRESET), 
     167                             token, cb); 
     168 
     169            return PJ_EPENDING; 
     170        } 
    174171    } 
    175172 
     
    184181 
    185182    /* If delay is not configured, deliver this packet now! */ 
    186     if (loop->delay == 0) { 
     183    if (loop->recv_delay == 0) { 
    187184        pj_ssize_t size_eaten; 
    188185 
     
    193190        pjsip_endpt_release_pool(loop->base.endpt,  
    194191                                 recv_pkt->rdata.tp_info.pool); 
    195         return PJ_SUCCESS; 
    196192 
    197193    } else { 
    198194        /* Otherwise if delay is configured, add the "packet" to the  
    199          * receive list to be processed by worker thread, and add 
    200          * pending notification for calling the callback. 
     195         * receive list to be processed by worker thread. 
    201196         */ 
    202         add_notification(loop, tdata, tdata->buf.cur - tdata->buf.start,  
    203                          token, cb); 
    204  
    205197        pj_lock_acquire(loop->base.lock); 
    206198        pj_list_push_back(&loop->recv_list, recv_pkt); 
    207199        pj_lock_release(loop->base.lock); 
     200    } 
     201 
     202    if (loop->send_delay != 0) { 
     203        add_notification(loop, tdata, tdata->buf.cur - tdata->buf.start, 
     204                         token, cb); 
    208205        return PJ_EPENDING; 
     206    } else { 
     207        return PJ_SUCCESS; 
    209208    } 
    210209} 
     
    224223    pj_thread_destroy(loop->thread); 
    225224 
     225    /* Clear pending send notifications. */ 
     226    while (!pj_list_empty(&loop->send_list)) { 
     227        struct send_list *node = loop->send_list.next; 
     228        /* Notify callback. */ 
     229        if (node->callback) { 
     230            (*node->callback)(&loop->base, node->token, -PJSIP_ESHUTDOWN); 
     231        } 
     232        pj_list_erase(node); 
     233        pjsip_tx_data_dec_ref(node->tdata); 
     234    } 
     235 
     236    /* Clear "incoming" packets in the queue. */ 
     237    while (!pj_list_empty(&loop->recv_list)) { 
     238        struct recv_list *node = loop->recv_list.next; 
     239        pj_list_erase(node); 
     240        pjsip_endpt_release_pool(loop->base.endpt, 
     241                                 node->rdata.tp_info.pool); 
     242    } 
     243 
     244    /* Self destruct.. heheh.. */ 
    226245    pj_lock_destroy(loop->base.lock); 
    227246    pj_atomic_destroy(loop->base.ref_cnt); 
     
    239258        pj_time_val now; 
    240259 
    241         pj_thread_sleep(10); 
     260        pj_thread_sleep(1); 
    242261        pj_gettimeofday(&now); 
    243262 
     
    321340        goto on_error; 
    322341    loop->base.key.type = PJSIP_TRANSPORT_LOOP_DGRAM; 
    323     loop->base.key.rem_addr.sa_family = PJ_AF_INET; 
     342    //loop->base.key.rem_addr.sa_family = PJ_AF_INET; 
    324343    loop->base.type_name = "LOOP-DGRAM"; 
    325344    loop->base.info = "LOOP-DGRAM"; 
     
    357376     */ 
    358377 
    359     *transport = &loop->base; 
     378    if (transport) 
     379        *transport = &loop->base; 
     380 
    360381    return PJ_SUCCESS; 
    361382 
     
    406427 
    407428 
    408 PJ_DEF(pj_status_t) pjsip_loop_set_delay( pjsip_transport *tp, 
    409                                           unsigned delay, 
    410                                           unsigned *prev_value) 
     429PJ_DEF(pj_status_t) pjsip_loop_set_recv_delay( pjsip_transport *tp, 
     430                                               unsigned delay, 
     431                                               unsigned *prev_value) 
    411432{ 
    412433    struct loop_transport *loop = (struct loop_transport*)tp; 
     
    416437 
    417438    if (prev_value) 
    418         *prev_value = loop->delay; 
    419     loop->delay = delay; 
    420  
    421     return PJ_SUCCESS; 
    422 } 
    423  
     439        *prev_value = loop->recv_delay; 
     440    loop->recv_delay = delay; 
     441 
     442    return PJ_SUCCESS; 
     443} 
     444 
     445PJ_DEF(pj_status_t) pjsip_loop_set_send_callback_delay( pjsip_transport *tp, 
     446                                                        unsigned delay, 
     447                                                        unsigned *prev_value) 
     448{ 
     449    struct loop_transport *loop = (struct loop_transport*)tp; 
     450 
     451    PJ_ASSERT_RETURN(tp && (tp->key.type == PJSIP_TRANSPORT_LOOP || 
     452                     tp->key.type == PJSIP_TRANSPORT_LOOP_DGRAM), PJ_EINVAL); 
     453 
     454    if (prev_value) 
     455        *prev_value = loop->send_delay; 
     456    loop->send_delay = delay; 
     457 
     458    return PJ_SUCCESS; 
     459} 
     460 
     461PJ_DEF(pj_status_t) pjsip_loop_set_delay( pjsip_transport *tp, unsigned delay ) 
     462{ 
     463    struct loop_transport *loop = (struct loop_transport*)tp; 
     464 
     465    PJ_ASSERT_RETURN(tp && (tp->key.type == PJSIP_TRANSPORT_LOOP || 
     466                     tp->key.type == PJSIP_TRANSPORT_LOOP_DGRAM), PJ_EINVAL); 
     467 
     468    loop->recv_delay = delay; 
     469    loop->send_delay = delay; 
     470 
     471    return PJ_SUCCESS; 
     472} 
     473 
Note: See TracChangeset for help on using the changeset viewer.