SampleSocketPort.cpp

#include "SampleSocketPort.h"

SampleSocketPort::SampleSocketPort(SocketService *pService, TCPSocket & tcpSocket) :
SocketPort(pService, tcpSocket)
{
    tpport_t port;
    InetHostAddress ia = getPeer( & port );
    cerr << "connecting from " << ia.getHostname() << ":" << port << endl;

    // Set up non-blocking reads
    setCompletion( false );

    //1.9.3 THIS LINE DOES NOT SEEM TO BE REQUIRED ANYMORE!
    //This sorts out a bug which prevents connections after a disconnect
    //setDetectOutput(true);

    m_bOpen = true;
    m_bDoDisconnect = false;
    m_bTimedOut = false;
    m_bReceptionStarted = false;
    m_nLastBytesAvail = 0;
    m_pBuf = new char[MAX_RXBUF];
}


SampleSocketPort::~SampleSocketPort()
{
    endSocket();
    delete [] m_pBuf;
}

void SampleSocketPort::pending(void)
{
//cerr << "Pending called " << endl;
    if(!m_bOpen)
        return;

    // Read all available bytes into our buffer
    int nBytesAvail = peek(m_pBuf, MAX_RXBUF);
//cerr << "Pending .. " << nBytesAvail << endl;

    if(!m_bReceptionStarted)
    {   //Start the receive timer
        ResetReadTimeout(MAX_RXTIMEOUT);    //Got 'n' seconds to get all the data else we timeout
        m_bReceptionStarted = true;
    }
    else {
        if(m_bTimedOut) //The receive timer has expired...this is a timeout condition
        {
            ResetReadTimeout(MAX_RXTIMEOUT); //Clear the timeout flag
            m_nLastBytesAvail = 0;      //Reset the flags
            m_bReceptionStarted = false;
            OnRxTimeout();  //Do whatever 'we' do for a timeout (probably a flush or disconnect)...
            return;
        }
    }

    if(m_nLastBytesAvail == nBytesAvail)    //Check if any more data has been received since last time
    {                                       //No point in parsing unless this has changed!
        //Maybe yield in here!
        //Thread::yield();
        if(nBytesAvail == 0)        //If we have been called with 0 bytes available (twice now)
        {                           //a disconnection has occurred
            if(!m_bDoDisconnect) {
                CloseSocket();  //Force the close
            }
        }
        return;
    }

    //Depending on your application you may want to attempt to process the extra data
    //(or change your MAX_RXBUF).
    //
    //Here I just flush the whole lot, because I assume a 'legal' client wont send more than
    //we can receive....maybe someone is trying to flood / overrun us!
    if(nBytesAvail > MAX_RXBUF) {
        cerr << "TCP/IP overflow..." << endl;
        FlushRxData();
        m_nLastBytesAvail = 0;
        m_bReceptionStarted = false;
        return;
    }
    m_nLastBytesAvail = nBytesAvail;

    //In this loop you may parse the received data to determine whether a whole
    //'packet' has arrived. What you do in here depends on what data you are sending.
    //Here we will just look for a /r/n terminator sequence.
    for(int i=0; i < nBytesAvail; i++) {

/***************************SHOULD BE CUSTOMISED*******************/

        if(m_pBuf[i] == '\r') {
            if(i+1 < nBytesAvail) {
                if(m_pBuf[i+1] == '\n')
                {   //Terminator sequence found

                    /**************************************************************/
                    // COMPULSORY ... Clear the flag and count..
                    // do this when you have received a good packet
                    m_nLastBytesAvail = 0;
                    m_bReceptionStarted = false;
                    /**************************************************************/

                    // Now receive the data into a buffer and call our receive function
                    int nLen = i+2;
                    char *pszRxData = new char[nLen+1]; //Allow space for terminator
                    receive(pszRxData, nLen);       //Receive the data
                    pszRxData[nLen] = '\0';     //Terminate it
                    OnDataReceived(pszRxData, nLen);
                    delete [] pszRxData;
                    return;
                }
            }
        }
/***************************END CUSTOMISATION*******************/

    }
}

void SampleSocketPort::disconnect(void)
{
    if(m_bOpen) {
        m_bDoDisconnect = true;
        CloseSocket();
    }
}

void SampleSocketPort::expired(void)
{
    if(m_bDoDisconnect && m_bOpen) {
        CloseSocket();
    }
    else if(m_bOpen && m_bReceptionStarted) {
        //Timer must have expired because the rx data has not all been received
        m_bTimedOut = true;
    }
}


bool SampleSocketPort::CloseSocket(void)
{
    if(m_bOpen && m_bDoDisconnect)
    {                                   //This is where the disconnection really occurs
        m_bOpen = false;                //If m_bDoDisconnect == true we know this has been called
        OnConnectionClosed();           //through the timer, so 'delete this' is safe!
        delete this;
    }
    else if(m_bOpen) {
        m_bDoDisconnect = true;         //Just set the timer and the flag so we can
        setTimer(DISCONNECT_MS);        //disconnect safely, in DISCONNECT_MS
    }
    return(true);
}

ssize_t SampleSocketPort::DoSend(void *buf, size_t len)
{
    //If we are disconnecting, just pretend all the bytes were sent
    if(m_bDoDisconnect)
        return((ssize_t)len);

    ssize_t nSent = send(buf, len);
    while(!isPending(Socket::pendingOutput, 0)) //Wait for output to complete
    {
        if(m_bDoDisconnect || !m_bOpen) {
            //If we are disconnecting, just pretend all the bytes were sent
            return((ssize_t)len);
        }
        //I like to yield whenever waiting for things...
        //this is optional and may not suit your implementation!
        Thread::yield();
    }
    return(nSent);
}

bool SampleSocketPort::WriteData(const char *szTxData, const size_t nByteCount)
{
    //First calculate how many bytes we are to send
    ssize_t nLen = nByteCount;

    if(nLen == -1)
        nLen = (ssize_t)strlen(szTxData);

    size_t nBytesToSend = nLen;

    while(m_bOpen && nLen) {
        nLen -= DoSend((void *)&(szTxData[nBytesToSend - nLen]), nLen);
    }

//  If we are sending a terminator.....uncomment the following lines
//  char chTerminator = '\n';
//  while(DoSend((void *)&chTerminator, 1) != 1);

    return(true);
}

#define WITH_EXAMPLE

#ifdef WITH_EXAMPLE


/************ THE FOLLOWING CODE DEMONSTRATES THE USE OF THE ABOVE CLASS ********************
 ****
 ****   To test it, compile with:
 ****
 ****   g++ SampleSocketPort.cpp -lccgnu -lpthread -ldl -oSampleSocketPort -ggdb -I/usr/local/include/cc++/
 ****   Run the program.
 ****
 ****   From another terminal telnet to port 3999 of the server
 ****
 ****       'telnet localhost 3999'
 ****
 ****   Anything you type should be sent back to you in reverse!
 ****
 ****   To test the corrupt data detection, send a control code (like ^D),
 ****   if the terminating charcters are not detected within the specified time
 ****   the receive timeout will occur.
 ****
 ****/


//define the following to include the example classes and functions

int g_nOpenPorts = 0;           //Dirty global to allow us to quit simply

class ReverserPort : public SampleSocketPort
{
public:
    ReverserPort(SocketService *pService, TCPSocket & tcpSocket) :
            SampleSocketPort(pService, tcpSocket) {
        g_nOpenPorts++;
    }
    virtual ~ReverserPort() {
        g_nOpenPorts--;
    }
    virtual void OnConnectionClosed(void)
    { cerr << "Connection Closed!" << endl; }

    virtual void OnDataReceived(char *pszData, unsigned int nByteCount) {
        //Reverse the data and send it back

        size_t nLen = strlen(pszData);
        char *szToSend = new char[nLen+1];

        //No need to reverse the \r\n or \0
        size_t nIndex = nLen-3;

        size_t i;
        for(i=0; i < nLen - 2; i++) {
            szToSend[i] = pszData[nIndex - i];
        }
        szToSend[i++] = '\r';
        szToSend[i++] = '\n';
        szToSend[nLen] = '\0';

        WriteData(szToSend, nLen);
        delete [] szToSend;
    }

};

class ReverserServer : public SampleSocketServiceServer
{
public:
    ReverserServer(InetHostAddress & machine, int port) :
    TCPSocket(machine, port), Thread(), SampleSocketServiceServer(machine, port) {}

    virtual ~ReverserServer() {}

    virtual SocketPort *CreateSocketPort(SocketService *pService, TCPSocket & Socket) {
        return(new ReverserPort(pService, Socket));
    }
};


int main(void)
{
    InetHostAddress LocalHost;
    LocalHost = htonl(INADDR_ANY);
    ReverserServer *Server = NULL;
    try {
        Server = new ReverserServer(LocalHost, 3999);
        Server->StartServer();
    }
    catch(...) {
        cerr << "Failed to start server" << endl;
        return(false);
    }
    cerr << "Waiting for connections...type \"quit\" to exit." << endl;

    char cmd[255];

    cin.getline(cmd, 255);


    while(strcmp(cmd, "quit") != 0) {
        cin.getline(cmd, 255);
    }

    Server->StopServer();
    delete Server;
    return 0;
}

#endif  //WITH_EXAMPLE