sipagent.cxx

一个SIP协议栈

#include "SIPAgent.h"



namespace msip
{
    //---------------------------------------------------------------------------------------
    Agent::Agent(int udp_port, int tcp_port)
    : ag_Receiver(udp_port, tcp_port)
    {
    }


    //---------------------------------------------------------------------------------------
    Agent::~Agent()
    {
        TransArray::iterator it;
        for(it = ag_Transmitters.begin(); it != ag_Transmitters.end(); ++it)
        {
            if(*it) delete *it;
        }
    }


    //---------------------------------------------------------------------------------------
    bool 
    Agent::poll(fd_set* fds)
    {
        TransArray::iterator it;
        for(it = ag_Transmitters.begin(); it != ag_Transmitters.end(); ++it)
        {
            if(*it) 
            {
                if((*it)->m_retrans.poll() == RetransmitManager::trTransmitIndicated)
                {
                    (*it)->m_trans.send((*it)->m_buffer);
                }
            }
        }
        return ag_Receiver.poll(fds);
    }




    //---------------------------------------------------------------------------------------
    TransmitID 
    Agent::connect(SendVia via, const std::string & addr, int port)
    {
        int i;
        for(i = 0; i < ag_Transmitters.size(); ++i)
        {
            if(ag_Transmitters[i] == 0) break;
        }
        if(i >= ag_Transmitters.size())
        {
            ag_Transmitters.push_back(0);
            i = ag_Transmitters.size() - 1;
        }
        ag_Transmitters[i] = new TransmitItem;
        ag_Transmitters[i]->m_trans.connect(via, addr, port);
        return TransmitID(i);
    }


    
    //---------------------------------------------------------------------------------------
    void 
    Agent::setTimeoutValues(TransmitID connection, long t1, long t2, double exp_val)
    {
        if(connection >= 0 && connection < ag_Transmitters.size())
        {
            if(ag_Transmitters[connection]) 
            {
                ag_Transmitters[connection]->m_retrans.setTimeoutValues(t1, t2, exp_val);
            }
        }
    }


    //---------------------------------------------------------------------------------------
    bool 
    Agent::send(TransmitID connection, /*const*/ Message& msg, bool retry_flag)
    {

        if(connection < 0 || connection >= ag_Transmitters.size()) return false;
        if(ag_Transmitters[connection] == 0) return false;

        ag_Transmitters[connection]->m_buffer = msg.encode();
        ag_Transmitters[connection]->m_retrans.start();
        ag_Transmitters[connection]->m_trans.send(ag_Transmitters[connection]->m_buffer);
        return true;
    }

    
    
    //---------------------------------------------------------------------------------------
    void 
    Agent::stopRetransmit(TransmitID connection)
    {
        if(connection >= 0 && connection < ag_Transmitters.size())
        {
            if(ag_Transmitters[connection]) 
            {
                ag_Transmitters[connection]->m_retrans.cancel();
            }
        }
    }

    
    
    //---------------------------------------------------------------------------------------
    bool 
    Agent::send(SendVia via, /*const*/ Message& msg, const std::string & addr, int port) const
    {

        Transmitter trans;

        if(trans.connect(via, addr, port))
        {
            trans.send(msg.encode());
            trans.close();
            return true;
        }
        return false;
    }



    //---------------------------------------------------------------------------------------
    bool 
    Agent::close(TransmitID connection)
    {
        if(connection >= 0 && connection < ag_Transmitters.size())
        {
            if(ag_Transmitters[connection]) 
            {
                delete ag_Transmitters[connection];
                ag_Transmitters[connection] = 0;
            }
        }
    }



    //---------------------------------------------------------------------------------------
    long 
    Agent::getMinimalTimeLeft(long min_time_left) const
    {
        if(notEmpty()) return 0l;

        long tm_left;
        TransArray::const_iterator it;
        for(it = ag_Transmitters.begin(); it != ag_Transmitters.end(); ++it)
        {
            if(*it)
            {
                tm_left = (*it)->m_retrans.getTimeLeft();
                if(tm_left < min_time_left) min_time_left = tm_left;
            }
        }
        return min_time_left;
    }



}