tcpsocket.cxx

一个SIP协议栈

        }

        if (rc < 0 )
        {
            MHTRACE(9,"Exiting because of select error");
            SOCKET_EXCEPTION("Error in Select",errno);
        }
    }
    MHTRACE(9,"Timeout exception");
    SOCKET_TIMEOUT;
}
//------------------------------------------------------------------------------
//
//
void TCPSocket::send(const void * cpBuf, int iBufLen, int iFlag=0)
{
    IN("TCPSocket::send(const void * ,int,int)");
    CriticalSection CrtSec(&m_xMutex);
    if(m_bConnected)
    {
        while(1)
        {
            try
            {
                waitForOutputAvail();
                break;
            }
            catch(WaitingStopped)
            {
                m_bStopReceived=true;
                continue;
            }
        }
        
        if(::send(m_ihSocket,cpBuf,iBufLen,iFlag)==-1)
        {
            signal(SIGPIPE, SIG_IGN);
            SOCKET_EXCEPTION("Socket sending error ",errno);
        }
        
        if(m_bStopReceived)
        {
            m_bStopReceived=false;    
            stopWaiting();
        }
        
    }
    else
    {
        SOCKET_EXCEPTION("Sending to unconnected socket",0);
    }
};
//------------------------------------------------------------------------------
//
//
void TCPSocket::recv(void * cpBuf, int iBufLen, int iFlag=0)
{
    IN("TCPSocket::recv(void *, int , int)");
    CriticalSection CrtSec(&m_xMutex);
    int iNTotalRecv=0,Res=0;
    if(m_bConnected)
    {   
        while (iNTotalRecv<iBufLen)
        {
            try
            {
                waitForInput(); 
            }
            catch (WaitingStopped)
            {
                m_bStopReceived=true;
                continue;
            }
            
            if((Res=::recv(m_ihSocket,(char *)cpBuf+iNTotalRecv,iBufLen-iNTotalRecv,iFlag))==-1)
            {
                SOCKET_EXCEPTION("Socket reading Error",errno);
            }
            MHTRACE(9,"Res="<<Res);

            if (Res==0)
            {
                SOCKET_EXCEPTION("Error reading socket",errno);
            }
            iNTotalRecv+=Res;
            
        }
        
        if(m_bStopReceived)
        {
            m_bStopReceived=false;    
            stopWaiting();
        }
    }
    else
    {
        SOCKET_EXCEPTION("Receiving from unconnected socket",0);
    }
};



int TCPSocket::recvAll(void * cpBuf, int iBufLen, int iFlag=0)
{
    IN("TCPSocket::recv(void *, int , int)");
    CriticalSection CrtSec(&m_xMutex);
    int Res=0;
    if(m_bConnected)
    {   
        while(true)
        {
            try
            {
                waitForInput(); 
                break;
            }
            catch (WaitingStopped)
            {
                m_bStopReceived=true;
                continue;
            }
        }

        if((Res=::recv(m_ihSocket,(char *)cpBuf, iBufLen, iFlag))==-1)
        {
            SOCKET_EXCEPTION("Socket reading Error",errno);
        }
        MHTRACE(9,"Res="<<Res);

        if (Res==0)
        {
            SOCKET_EXCEPTION("Error reading socket",errno);
        }
        
        if(m_bStopReceived)
        {
            m_bStopReceived=false;    
            stopWaiting();
        }
    }
    else
    {
        SOCKET_EXCEPTION("Receiving from unconnected socket",0);
    }
    return Res;
};



//------------------------------------------------------------------------------
//
//
void TCPSocket::printOn(ostream & xStr)
{
    IN ("TCPSocket::printOn(ostream & )");
    CriticalSection CrtSec(&m_xMutex);
    xStr << " Socket handler: " << m_ihSocket       << endl;  // Socket Descriptor
    xStr << " Domain        : " << m_iDomain        << endl;
    xStr << " Type          : " << m_iType          << endl;
    xStr << " Protocol      : " << m_iProtocol      << endl;
    xStr << " Timer         : " << m_iTimer         << endl;
    xStr << " Connected     : " << m_bConnected     << endl;
    xStr << " StopReceived  : " << m_bStopReceived  << endl;
    if (m_iTimer)
    {
        xStr << " Time leave    : " << GetTimer() << endl;  
    }
    xStr << " *  - - IPAddress - -  * " << endl;
    xStr << m_xInetAddr << endl;  
    
}
//------------------------------------------------------------------------------
//
//
TCPSocket::~TCPSocket ()
{
    CriticalSection CrtSec(&m_xMutex);
    ::shutdown(m_ihSocket,2);
    ::close(m_ihSocket);
    ::close(m_xPipeChan[0]);
    ::close(m_xPipeChan[1]);
};

//------------------------------------------------------------------------------
//
//
void TCPSocket::SetTimer(TimeInterval Time)
{
    IN ("SetTimer(TimeInterval)");
    MHTRACE(9,"this="<<this);
    CriticalSection CrtSec(&m_xMutex);
    struct tms xTime;
    clock_t iClocks=times(&xTime);
    m_xInitTime.tv_sec=iClocks/CLK_TCK;
    m_xInitTime.tv_usec=(iClocks%CLK_TCK)*(1000000/CLK_TCK);
    m_iTimer=Time;
    MHTRACE(9,
        "Timer initiated on " << Time <<" msec" );

    MHTRACE(9,
        "Current time is (sec) "  << setprecision(12) << (double)m_xInitTime.tv_sec+(double)(m_xInitTime.tv_usec)/1000000);
}
//------------------------------------------------------------------------------
//
//
TimeInterval TCPSocket::GetTimer(void)
{
    IN ("GetTimer()");  
    struct timeval time;
    struct tms xTime;
    if (!m_iTimer) return 0;
    clock_t iClocks=times(&xTime);
    time.tv_sec=iClocks/CLK_TCK;
    time.tv_usec=(iClocks%CLK_TCK)*(1000000/CLK_TCK);
    TimeInterval 
        diff= ((TimeInterval)time.tv_sec-(TimeInterval)m_xInitTime.tv_sec)*1000+
        ((TimeInterval)time.tv_usec-(TimeInterval)m_xInitTime.tv_usec)/1000;
    MHTRACE(9,"Timer value " << m_iTimer-diff);
    return m_iTimer-diff;
}
//------------------------------------------------------------------------------
//
//
void TCPSocket::ClearTimer()
{
    IN ("ClearTimer()");
    m_iTimer=0;
    
}
//------------------------------------------------------------------------------
//
//
bool TCPSocket::isTimerValid()
{
    IN("TCPSocket::isTimerValid()");
    if(m_iTimer && GetTimer()<=0) 
    {
        return false;
    }
    if (m_iTimer)
    {
        TimeInterval tim=GetTimer(); // Do not optimize( for Correct Trace!!! )
        MHTRACE(9,"Timer value " << tim);
    }
    else
    {
        MHTRACE(9,"Timer was not set");
    }
    return true;
}

//------------------------------------------------------------------------------
//
//

bool TCPSocket::isInputAvail()
{
    IN("TCPSocket::isInputAvail()");
    CriticalSection CrtSec(&m_xMutex);
    struct timeval timeRec;
    fd_set  select_set;
    
    if (m_iTimer && GetTimer()<=0)
    {
        SOCKET_TIMEOUT;
    };
    
    timeRec.tv_sec = 0;       
    timeRec.tv_usec= 0; 
    FD_ZERO( &select_set );
    FD_SET( m_ihSocket, &select_set );
    int rc = select(FD_SETSIZE, &select_set, 0, 0, &timeRec );
    if (rc > 0 && FD_ISSET(m_ihSocket, &select_set)) 
    {
        MHTRACE(9,"Returning true");
        return true;
    }
    if (rc < 0 ) 
    {
        SOCKET_EXCEPTION("Error in Select",errno);
    }
    
    MHTRACE(9,"Returning false");
    return false;
};

void TCPSocket::cancel()
{
    write(m_xPipeChan[1],"c",1);
};

void TCPSocket::stopWaiting()
{
    write(m_xPipeChan[1],"s",1);
};