File content as of revision 76:9f5f99dd895a:

#include "call_manager.h"

VZ_call * __find_Call__( Vector * v_call, int ext ){
    VZ_call * call = NULL;
    for( register int i = 0; i < v_call->size(); i++ ){
        call = ( VZ_call * )v_call->get_element( i );
        if( call->get_cb_ext() == ext ) return( call );
    }
    return( NULL );
}

/* remove calls por timeout */
void call_manager( Vector * v_call, Vector * v_cb, uint8_t * data, uint8_t * write_buffer, Timeslice * ts ){
    for( register int i = 0; i < v_call->size(); i++ ){
        VZ_call * call = ( VZ_call * )v_call->get_element( i );
        if( call->is_timetofinish() ){
            v_call->remove_element( i );
            Call_Box * cb = __find_CB__( v_cb, call->get_cb_ext() );
            if( cb ){ 
                cb->status = cb_idle;
                ts->return_timeslice( cb->get_timeslice() );
                cb->set_timeslice( 0x00 );
                data[ __TIMESLICE_PLACE__ ] = 0x00;
                cb->set_msg_id( ( ( cb->get_msg_id() ) + 1 ) & ( BIT7 ^ 0xff ) );
                send2callboxes( __build_cb_package__( cb->get_ext(), cb->get_port(), __CB_BYE__, 
                    ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                cb->send_bye();
                set_status( cb->sip->status, sip_idle );
                cb->re_start_timer();
            }
            delete( call );    
        }
    }    
}

void invite_handler( Vector * v_call, Vector * v_cb, Timeslice * ts, Call_Box * cb ){
    uint8_t data[ __CB_BUFFER_SIZE__ ];
    uint8_t write_buffer[ __CB_BUFFER_SIZE__ ];
    
    int ext = 0x00;
    int port = 0x00;

    bool should_return = true;
    
    if( cb != NULL ){
        ext = cb->get_ext();
        port = cb->get_port();
        set_status( cb->status, cb_trying );
        if( debug_invite ) debug_msg("Request invite cbx status :: %d", cb->status );
    }else{
        should_return = true;
        for( register uint8_t i = 0; i < v_cb->size(); i++ ){
            Call_Box * inner_cb = ( Call_Box * )v_cb->get_element( i );
            if( inner_cb -> get_status() != cb_idle ){
                should_return = false;
                cb = inner_cb;
                break;
            }
        }
        if( should_return ) return;
    }
        
    for( register uint8_t i = 0; i < v_cb->size(); i++ ){
        cb = ( Call_Box * )v_cb->get_element( i );
        
        if( cb -> get_status() == cb_idle ) continue;
        
        VZ_call * call = NULL;

        switch( cb->status ){            
            case cb_ringing : {
                call = cb->invite();
            
                if( call != NULL ){
                    if( __find_Call__( v_call, call->get_cb_ext() ) == NULL ) v_call -> add( call );
                    
                    //if( ( cb->get_sip_status() == sip_trying ) || ( cb->get_sip_status() == sip_ringing ) );
                    
                    if( cb->get_sip_status() == sip_on_call ){
                    //if( debug_main ) debug_msg(" -- %d on %d -- ", cb->get_ext(), data[ __TIMESLICE_PLACE__ ] );
                    
                    /* isso quer dizer que o invite foi aceito, tenho que aceitar ele mais pra baixp*/
                        send2callboxes( __build_cb_package__( ext, port, __INVITE__, ( char * )data, 
                            cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                        
                        if( debug_invite ) debug_msg( "-- ringing -- accepting call request --" );
                    }
                }else{
                    if( cb->get_sip_status() == sip_denied ) set_status( cb->status , cb_denied );
                }
            }break;
            case cb_trying : {
                data[ 0 ] |= BIT7;
                cb->set_msg_id( data[ 0 ] );
                cb->set_timeslice( ts->get_timeslice() );
                // No protocolo VZ, timeslice == 0x00 significa que nao temos mais ts
                if( cb->get_timeslice() == 0x00 ){
                    set_status(cb->status,cb_idle);
                    data[ __TIMESLICE_PLACE__ ] = 0x00;
                    send2callboxes( __build_cb_package__( ext, port, __INVITE__, 
                        ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                    set_status( cb->sip->status, sip_idle );
                    if( debug_invite ) debug_msg( "-- Trying -- without TS -- %s ", write_buffer );
                }else{
                    data[ __TIMESLICE_PLACE__ ] = cb->get_timeslice();
                    
                    set_status( cb->status, cb_ringing );
                    
                    /* Isso diz pro CBx o Timeslice que ele vai usar e deixa o Cbx na espera da resposta do Asterisk */
                    send2callboxes( __build_cb_package__( ext, port, __INVITE__, 
                        ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                    
                    if( debug_invite ) debug_msg(" -- %d on TS::%d -- ", cb->get_ext(), data[ __TIMESLICE_PLACE__ ] );
                     
                    cb->set_msg_id( ( ( cb->get_msg_id() ) + 1 ) & ( BIT7 ^ 0xff ) );
                }
            }break;                    
            case cb_busy : {
                set_status( cb->status, cb_idle );
                ts->return_timeslice( cb->get_timeslice() );
                cb->set_timeslice( 0x00 );
                data[ __TIMESLICE_PLACE__ ] = 0x00;
                if( debug_invite ) debug_msg(" -- %d on %d -- ", cb->get_ext(), data[ __TIMESLICE_PLACE__ ] );
                
                send2callboxes( __build_cb_package__( ext, port, __CB_BYE__, 
                    ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                
                if( debug_invite ) debug_msg( "-- Trying -- denying call request << Busy Here >> --" );
                
                for( register uint8_t i = 0; i < v_call->size(); i++ ){
                    VZ_call * call = ( VZ_call * )v_call->get_element( i );
                    if( call->get_cb_ext() == cb->get_ext() ){ 
                        v_call->remove_element( i );
                        delete( call );
                        break;
                    }
                }
        
                cb->send_bye();
                set_status( cb->sip->status, sip_idle );
                cb->re_start_timer();
            }break;
            case cb_denied : {
                set_status( cb->status, cb_idle );
                ts->return_timeslice( cb->get_timeslice() );
                cb->set_timeslice( 0x00 );
                data[ __TIMESLICE_PLACE__ ] = 0x00;
                if( debug_invite ) debug_msg(" -- %d on %d -- ", cb->get_ext(), data[ __TIMESLICE_PLACE__ ] );
                
                send2callboxes( __build_cb_package__( ext, port, __CB_BYE__, 
                    ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
                    
                for( register uint8_t i = 0; i < v_call->size(); i++ ){
                    VZ_call * call = ( VZ_call * )v_call->get_element( i );
                    if( call->get_cb_ext() == cb->get_ext() ){ 
                        v_call->remove_element( i );
                        delete( call );
                        break;
                    }
                }
                
                if( debug_invite ) debug_msg( "-- Trying -- denying call request --" );
                set_status( cb->sip->status, sip_idle );
            }break;
        }
    }
}