TCPIPComm.cpp

//*****************************************************************************
// project   : ANALYTICA Class Library
// part      : Communication class for simple TCP/IP
// file name : TCPIPComm.h
// version   : 1.2
// author    : Udo Weber
// platform  : MS VC++ 6.0
//
//-----------------------------------------------------------------------------
// Description:
// =============
// implementation of the class CTCPIPComm to encapsulate simple TCP/IP
// communications
// Contains the main part of the communication classes. Organizes the
// handling of the three lower classes CTCPIPCommConnect, CTCPIPCommRecv and
// CTCPIPCommSend.
//
//-----------------------------------------------------------------------------
// Revisionhistory:
// 03.07.2001 ASc  Deferred Initialization added
// 20.07.1998 UWe  Some bug fixes
// 20.04.1998 UWe  first version
//*****************************************************************************

//---- includes ---------------------------------------------------------------
#include "stdafx.h"

#include "TCPIPComm.h"


//---- defines/const ----------------------------------------------------------



//---- classes -----------------------------------------------------------------


//******************************************************************************
// Methods of class 'CTCPIPComm'
//******************************************************************************

// Static attributes and operations

int    CTCPIPComm::m_NumOfInstances = 0;
//SOCKET CTCPIPComm::m_PassiveSocket  = INVALID_SOCKET;
bool          CTCPIPComm::m_bArrayUsed[]     = { false, false };
SOCKADDR_IN   CTCPIPComm::m_ArrayRemoteAddr[]= { 0, 0 };
SOCKET        CTCPIPComm::m_ArrayPassiveSocket[]= { INVALID_SOCKET, INVALID_SOCKET };


//------------------------------------------------------------------------------
// Description:
//   Constructs the class CTCPIPComm and creates a new communication instance.
//   A new instance is necessary for every communication partner
//
// Input:
//   TCPport          : Port number to be used for the communication
//   pIPAddress       : NULL terminated string containing IP Address or Name of partner
//   PassiveConnection: true if awaiting the connection from the partner
//   MaxSendDataLen   : Maximum length for sending messages
//   MaxRecvDataLen   : Maximum length for receiving messages
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPComm::CTCPIPComm( const short TCPport,
                        const char  *pIPAddress,
                        const bool  PassiveConnection,
                        const long  MaxSendBufferLen,
                        const long  MaxRecvBufferLen )
                      : CTCPIPCommReceive( -1 ),
                        CTCPIPCommSend( -1 ),
                        CTCPIPCommConnect()
{
   m_bInitialized = false;
   m_bTerminating = false;
   Initialize( TCPport, pIPAddress, PassiveConnection, MaxSendBufferLen, MaxRecvBufferLen );
}

//------------------------------------------------------------------------------
// Description:
//   Constructs the class CTCPIPComm. The communication instance must bei created by a
//   call to the Initialize function (only available in a derived class)
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPComm::CTCPIPComm( void )
                      : CTCPIPCommReceive( -1 ),
                        CTCPIPCommSend( -1 ),
                        CTCPIPCommConnect()
{
   m_bInitialized = false;
}

//------------------------------------------------------------------------------
// Description:
//   Initialization-Routine for object construction.
//
// Input:
//   TCPport          : Port number to be used for the communication
//   pIPAddress       : NULL terminated string containing IP Address or Name of partner
//   PassiveConnection: true if awaiting the connection from the partner
//   MaxSendDataLen   : Maximum length for sending messages
//   MaxRecvDataLen   : Maximum length for receiving messages
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPComm::Initialize( const short  TCPport,
                             const char   *pIPAddress,
                             const bool   PassiveConnection,
                             const long   MaxSendDataLen,
                             const long   MaxRecvDataLen )
{
   bool        SocketFound;
   int         i;

   if ( m_bInitialized == true )
   {
      return;
   }
   
   m_bInitialized = true;
   
   // Initialize Receive and Send-classes
   CTCPIPCommReceive::InitializeClass( MaxRecvDataLen );
   CTCPIPCommSend::InitializeClass( MaxSendDataLen );

   m_LineConnected     = false;
   m_LastSocketError   = 0;
   m_PassiveConnection = PassiveConnection;
   m_PassiveSocket     = INVALID_SOCKET;

   if ( m_NumOfInstances++ == 0 )
   {
      // If the first instance of this class is created, the
      // socket for the passive connections (await function)
      // has to be created. PXROS does not support more than
      // one socket for the same TCP/IP address.
      WSADATA         WsaData;
      if ( WSAStartup( 0x0101, &WsaData ) == SOCKET_ERROR )
      {
         m_LastSocketError = GetLastError();
         return;
      }
   }

   if ( PassiveConnection )
   {

      m_RemoteAddr = ConvTCPAddrToSocketAddr( TCPport, pIPAddress );

      for ( i = 0, SocketFound = false; i < MAX_DIF_ADDR; i++ )
         if ( m_bArrayUsed[ i ] )
            if ( memcmp( &m_RemoteAddr, &m_ArrayRemoteAddr[ i ], sizeof( m_RemoteAddr ) ) == 0 )
            {
               SocketFound = true;
               break;
            }

      if ( SocketFound )
         m_PassiveSocket = m_ArrayPassiveSocket[ i ];
      else
      {
         for ( i = 0; i < MAX_DIF_ADDR; i++ )
            if ( ! m_bArrayUsed[ i ] )
            {
               m_PassiveSocket = socket( AF_INET, SOCK_STREAM, 0 );
               bind( m_PassiveSocket, (PSOCKADDR) &m_RemoteAddr, sizeof( m_RemoteAddr ) );
               listen( m_PassiveSocket, SOMAXCONN );
               m_ArrayPassiveSocket[i] = m_PassiveSocket;
               m_ArrayRemoteAddr[i]    = m_RemoteAddr;
               m_bArrayUsed[i]         = true;
               break;
            }
      }

   }

   // Initialize the Connect class
   CTCPIPCommConnect::Initialize( TCPport, pIPAddress, m_PassiveConnection );
}

//------------------------------------------------------------------------------
// Description:
//   Destructs the CTCPIPComm class
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPComm::~CTCPIPComm()
{
   m_bTerminating = true;

   if ( --m_NumOfInstances == 0 )
   {
      // Attention !!!
      // WSACleanup should be called after last instance of CTCPIPComm is deleted
      //WSACleanup();
   }

   // close the global passive socket --> All threads waiting in the "accept" call
   // will be released
   if ( m_PassiveSocket != INVALID_SOCKET )
   {
      SOCKET      TmpSocket = m_PassiveSocket;

      m_PassiveSocket = INVALID_SOCKET;
      closesocket( TmpSocket );

      if ( m_NumOfInstances > 0 )
      {
         // if other instances still exists create again the socket for the passive
         // connections.
         m_PassiveSocket = socket( AF_INET, SOCK_STREAM, 0 );
         bind( m_PassiveSocket, (PSOCKADDR) &m_RemoteAddr, sizeof( m_RemoteAddr ) );
         listen( m_PassiveSocket, SOMAXCONN );
      }
   }

   // signal the threads Receive/Send to terminate and wait for their termination
   CTCPIPCommReceive::Terminating( true );
   CTCPIPCommSend::Terminating( false );
}



//------------------------------------------------------------------------------
// Description:
//   Try to establish the connection to the communication partner
//
// Input:  ----
//
// Output: ----
//
// Return: true if function call successful
//         does not mean that the connection was connected --> ConnectIndication
//
//------------------------------------------------------------------------------
bool CTCPIPComm::ConnectRequest( void )
{
   return CTCPIPCommConnect::ConnectRequest( m_PassiveSocket );
}


//------------------------------------------------------------------------------
// Description:
//   Transmits the given data to the communication partner
//
// Input:
//   pData        : Pointer to the data to be sent
//   DataLen      : Length of the data
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
bool CTCPIPComm::Send( const void    *pData,
                       const long    DataLen )
{
   if ( ! IsConnected() )
      return FALSE;

   return CTCPIPCommSend::Send( pData, DataLen );
}


//------------------------------------------------------------------------------
// Description:
//   called from CTCPIPCommConnect in order to indicate the connect indication
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPComm::ConInd( void )
{
   m_LineConnected = TRUE;

   // Send to the Receive and Send Thread the Init command in order
   // to tell them the socket handle to be used.
   CTCPIPCommSend::Initialize( GetSocket() );
   CTCPIPCommReceive::Initialize( GetSocket() );

   // Signal to the user the connect indication
   ConnectIndication();

   // Signal to the receive thread that the receiving part can now be started
   // Attention: This has to be done after the "ConnectIndication" that the user
   //            is informed first of the connected line.
   CTCPIPCommReceive::StartReceiving();
}


//------------------------------------------------------------------------------
// Description:
//   called from CTCPIPCommConnect in order to indicate the disconnect indication
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPComm::DisInd( void )
{
   if ( m_LineConnected )
   {
      m_LineConnected = FALSE;

      CTCPIPCommConnect::DisconnectRequest();
   }


   if ( ! m_bTerminating )
   {
      // Inform "user" of this class always (to be able to try to connect again)
      DisconnectIndication();
   }
}

//------------------------------------------------------------------------------
// Description:
//   called by CTCPIPComRecv in order to indicate the disconnect indication
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPComm::RecvDisInd( void )
{
   DisInd();
}

//------------------------------------------------------------------------------
// Description:
//   called by CTCPIPComSend in order to indicate the disconnect indication
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPComm::SendDisInd( void )
{
   DisInd();
}

---