Detailed Description

The TCPConnection class represents a Transmission Control Protocol (TCP) connection.

Usage

• Create a socket with OpenSocket().
• Connect to either:
  • remote (listening) port by ConnectTo(), or
  • open a listening port by calling Listen(), then wait for incoming connections by calling WaitForIncomingConnection().
• Read or send data with Read() or Send().
• Call ShutDown() to gracefully shut down the connection.
• Close the socket with CloseSocket().
• Must use try/catch around calls to TCPConnection class as methods will throw TCPException.

Example

This example uses seprate thread to communicate via TCPConnection. The drawback with the code is that WaitForIncomingConnection() and Read() will block infinetly if no connection is made, so it is not possible to stop the thread in a good way. Using CloseSocket() from another thread is not a good solution as it tends to crash (at least on some OS's).

Note: All (int) return values are 0 if successful, nonzero otherwise.

The example header file tcpconnectionthread.h looks like this:

#include <OSAPI/Process/OSAPIThread.h>
#include <OSAPI/Network/TCPConnection.h>

class TCPConnectionThread : public OSAPIThread
{
    void Main() override;
    void ProcessSending();

    TCPConnection m_tcpConnection;
    IpAddress     m_remoteIp;
    IpAddress     m_ipLocal;
};

See also OSAPIThread

Receiving TCP data using blocking sockets in thread's main method

In tcpconnectionthread.cpp file

#include "tcpconnectionthread.h"

// Implementation of the main thread function inherited from OSAPIThread.
void TCPConnectionThread::Main()
{
  // Simplest example:
  try
  {
    CDPMessage("%s started....\\n", OSAPIThread::Name());
    // initialiser TCP her...

    m_ipLocal = (unsigned int)INADDR_ANY;
    m_ipLocal.SetPort(5444);
    m_ipLocal.SetSubnetMask( "255.255.255.0" );

    TCPConnection tcpListen;
    tcpListen.OpenSocket();         // Preferably use OpenSocket() and Listen outside while loop
    tcpListen.Listen(m_ipLocal);    // if not required to reinitialize for each block received

    const int bufferSize = 256;
    char buffer[bufferSize];

    // This code will wait for an incoming connection,
    // and receive up to bufferSize-1 bytes of data
    while(!Stopped())
    {
      TCPConnection tcpIncoming;    // This object will receive the incoming connection
      try
      {
        tcpListen.WaitForIncomingConnection(tcpIncoming);
        while (tcpIncoming.IsConnected() && !Stopped())
        {
          int length = bufferSize-1;
          tcpIncoming.Read(buffer, length);
          CDPMessage("%s: Received the following data:%.*s\\n", OSAPIThread::Name(), length, buffer);
        } // end while
      }
      catch (TCPException& except)
      {
        // NOTE: To prevent the thread from exiting if the remote side closes the connection,
        //       exceptions must be caught somewhere inside the while (!Stopped()) loop.
        CDPMessage("%s::Main(): Exception: %s\\n", OSAPIThread::Name(), except.GetMessage());
      }

      try
      {
        tcpIncoming.ShutDown();
      }
      catch (...)
      {
        // Shouldn't care too much about this
      }
      tcpIncoming.CloseSocket();
    } // end while (!Stopped())

    CDPMessage("%s stopped....\\n",OSAPIThread::Name());

    tcpListen.ShutDown();
    tcpListen.CloseSocket();
  }
  catch (TCPException& except)
  {
    CDPMessage("%s::Main(): TCPException: %s\\n", OSAPIThread::Name(), except.GetMessage());
  }
  catch(...)
  {
    CDPMessage("MyTCPReceiver: Critical exception In Main() function caught. Check code.\\n");
  }
}

Sending TCP data using a non-blocking socket

void TCPConnectionThread::ProcessSending()
{
    if (!m_tcpConnection.IsSocketWriteReady(0))
    {
        try
        {
            // This should preferably be done in Configure() and filled with data from xml file:
            m_remoteIp = "127.0.0.1";
            m_remoteIp.SetSubnetMask("255.255.255.0");
            m_remoteIp.SetPort(5444);

            // Should probably check if connect is already in progress, but this is a simle example...
            m_tcpConnection.OpenSocket();
            m_tcpConnection.SetBlockingMode(false);   // Important if sending from a periodic function to prevent Send() from blocking
            m_tcpConnection.ConnectTo( (unsigned int)INADDR_ANY, m_remoteIp);
        }
        catch (TCPException& except)
        {
            // Print debug message if debug level for this component >= 3. This message
            // will probably be printet every run when destination is not available.
            if (DebugLevel(DEBUGLEVEL_EXTENDED+1))
              CDPMessage("%s: Exception during send, Code 0x%08x: %s\n", OSAPIThread::Name(), except.GetErrorCode(), except.GetMessage());
        }
    }

    const int bufferSize = 10;
    static char data[bufferSize];
    static char todaysCharacter = 'a';
    todaysCharacter = 'a' + ((++todaysCharacter-'a')% 26);
    for (int i=0; i<bufferSize-1; i++)
        data[i] = todaysCharacter;   // Fill buffer with changing data
    data[9] = 0;

    int length = bufferSize;
    if (m_tcpConnection.IsSocketWriteReady(0))
    {
        try
        {
            m_tcpConnection.Send(data, length);
            if (length != bufferSize)
            CDPMessage("%s: Hmmm...Not all data was sent...\n", OSAPIThread::Name());
        }
        catch (TCPException& except)
        {
            // Only print message if Debug>=2 for this component
            if (DebugLevel(DEBUGLEVEL_EXTENDED))
            CDPMessage("%s: Exception during send: %s\n", OSAPIThread::Name(), except.GetMessage());
        }
    }
}