TCPIPCommConnect.cpp

//*****************************************************************************
// project   : ANALYTICA Class Library
// part      : Communication class for simple TCP/IP
// file name : TCPIPCommConnect.h
// version   : $Revision: 1.9 $
// author    : Udo Weber
// platform  : MS VC++ 6.0
//
//-----------------------------------------------------------------------------
// Description:
// =============
// implementation of the class CTCPIPComm to encapsulate simple TCP/IP
// communications
// Part : Connection establishment
//
//-----------------------------------------------------------------------------
// Revisionhistory:
// $Log: TCPIPCommConnect.cpp,v $
// Revision 1.9  2003/02/06 14:16:52  UdoWeber
// - Funktion Über/Untertoleranz hinzugefügt
// - Fehler beim Beenden der Anwendung (TCPIPComm::DisInd beim terminieren)
// - Berechnungsfehler bei Konvertierung mm/mV beseitigt
//
// Revision 1.8  2002/02/22 16:26:37  IngoFroehlich
// fixed: Problem beim Beenden der Threads
//
// Revision 1.7  2001/08/23 11:21:34  AxelSchmidt
// neue Funktion ConvToInAddr(
//
// Revision 1.6  2001/07/18 15:58:58  AxelSchmidt
// Bug beseitigt, Connect-Thrad wird bei er Erzeugung der TCP-IP-Klasse nicht gestartet
//
// Revision 1.5  2001/07/17 06:55:05  AxelSchmidt
// class destructor hangs if Thead is not already started
//
// Revision 1.4  2001/07/12 14:35:59  AxelSchmidt
// virtuelle Basis-Klasse CTraceObject hinzugefügt
//
// 20.07.1998 UWe  Some bug fixes
// 20.04.1998 UWe  first version
//*****************************************************************************

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

#include "TCPIPCommConnect.h"


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



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


//******************************************************************************
// Methods of class 'CTCPIPCommConnect'
//******************************************************************************

// Static attributes and operations


//------------------------------------------------------------------------------
// Description:
//   Constructs the class CTCPIPCommConnect and creates a thread for the connection
//   establishment
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPCommConnect::CTCPIPCommConnect( void )
{
   m_Terminating    = false;
   m_Socket         = INVALID_SOCKET;
   m_PassiveSocket  = INVALID_SOCKET;
   m_ThreadHandle   = NULL;          //ASc, 17.07.2001

   // Create the Semaphore for the child (connect) thread
   m_hEventTerminate         = CreateEvent( NULL,               // Security Attributes
                                            FALSE,              // Automatic Reset
                                            FALSE,              // Initial to non signaled
                                            NULL );             // Name of Semaphore
   m_hEventTerminateFinished = CreateEvent( NULL,               // Security Attributes
                                            FALSE,              // Automatic Reset
                                            FALSE,              // Initial to non signaled
                                            NULL );             // Name of Semaphore
   m_hEventConnecting        = CreateEvent( NULL,               // Security Attributes
                                            FALSE,              // Automatic Reset
                                            FALSE,              // Initial to non signaled
                                            NULL );             // Name of Semaphore

   // Create the connect thread
   m_ThreadHandle = CreateThread( NULL,                         // Security Attributes
                                  0,                            // Default Stack size
                                  (LPTHREAD_START_ROUTINE)ConnectThread, // Thread function
                                  this,                         // Pointer to this class
                                  0,                            // Thread starts immediatly
                                  &m_ThreadID );                // Returns the Thread ID
}


//------------------------------------------------------------------------------
// Description:
//   Destructs the CTCPIPCommConnect class
//
// Input:  ----
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPCommConnect::~CTCPIPCommConnect()
{
    m_Terminating    = TRUE;

    DisconnectRequest();

    // Stop the connect thread
    SetEvent( m_hEventTerminate );

    // wait until connect thread has terminated
    if ( m_ThreadHandle  != NULL )   //ASc, 17.07.2001, wait, if Thread is started
    {
      WaitForSingleObject( m_hEventTerminateFinished, INFINITE );

      CloseHandle( m_ThreadHandle );
    }
    CloseHandle( m_hEventTerminate );
    CloseHandle( m_hEventTerminateFinished );
    CloseHandle( m_hEventConnecting );
}


//------------------------------------------------------------------------------
// Description:
//   Performs the general initialization of the class parameters
//
// Input:
//    TCPport          : TCP port number to be used for the connection
//    pIPAddress       : C string in the form "139.20.29.32" or Name which can be
//                       resolved. If NULL the address of local machin will be used
//    PassiveConnection: True if awaiting a connection from the partner
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommConnect::Initialize( const short        TCPport,
                                    const char         *pIPAddress,
                                    const bool         PassiveConnection )
{
   BOOL     ReUseAddr = TRUE;

   // Save some parameters
   m_PassiveConnection = PassiveConnection;
   m_RemoteAddr        = ConvTCPAddrToSocketAddr( TCPport, pIPAddress );

   if ( PassiveConnection )
   {
      /* ASc, Disabled, why create a second socket ??
      m_PassiveSocket = socket( AF_INET, SOCK_STREAM, 0 );

      if ( setsockopt( m_PassiveSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&ReUseAddr,
                       sizeof( ReUseAddr ) ) == SOCKET_ERROR )
      {
         m_LastSocketError = WSAGetLastError();
         printf( "Error setsockopt : %d\n", m_LastSocketError );
         return;
      }

      if ( bind( m_PassiveSocket, (PSOCKADDR) &m_RemoteAddr,
                 sizeof( m_RemoteAddr ) ) == SOCKET_ERROR )
      {
         m_LastSocketError = WSAGetLastError();
         printf( "Error bind : %d\n", m_LastSocketError );
         return;
      }

      if ( listen( m_PassiveSocket, SOMAXCONN ) == SOCKET_ERROR )
      {
         m_LastSocketError = WSAGetLastError();
         printf( "Error listen : %d\n", m_LastSocketError );
         return;
      }
      */
   }
}


struct in_addr CTCPIPCommConnect::ConvToInAddr( unsigned long nIPAddress ) const
{
   struct in_addr sAddr;
   sAddr.S_un.S_addr = nIPAddress;
   return sAddr;
}
//------------------------------------------------------------------------------
// Description:
//   Generate the SOCKADDR_IN out of the Port and the IP Address
//
// Input:
//    TCPport          : TCP port number to be used for the connection
//    pIPAddress       : C string in the form "139.20.29.32" or Name which can be
//                       resolved. If NULL the address of local machin will be used
//
// Output: ----
//
// Return:
//    TCP/IP address in socket format
//
//------------------------------------------------------------------------------
SOCKADDR_IN CTCPIPCommConnect::ConvTCPAddrToSocketAddr( const short TCPport,
                                                        const char  *pIPAddr )
{
   IN_ADDR         IPAddress;
   SOCKADDR_IN     SocketAddr;

   if ( pIPAddr == NULL )
   {
      // get address of local machine
      struct  hostent     *host;
      char                hostname[128];

      gethostname( hostname, sizeof( hostname ) );
      host = gethostbyname( hostname );
      memcpy( &IPAddress.s_addr, host->h_addr_list[0], host->h_length );
   }
   else
   {
      struct hostent   *pAddr = NULL;
      
      if ( ! isdigit( pIPAddr[0] ) )
         pAddr = gethostbyname( pIPAddr );

      if ( pAddr == NULL )
         IPAddress.s_addr = inet_addr( pIPAddr );
      else
         IPAddress.s_addr = *((unsigned long *)(pAddr->h_addr_list[0]));

   }

   memset( &SocketAddr, 0, sizeof( SocketAddr ) );

   SocketAddr.sin_family = AF_INET;
   SocketAddr.sin_port   = htons( TCPport );
   SocketAddr.sin_addr   = IPAddress;

   return SocketAddr;
}



//------------------------------------------------------------------------------
// Description:
//   Try to establish the connection to the specified communication partner
//
// Input:
//    PassiveSocket  : The socket to be used for passive connections
//
// Output: ----
//
// Return:  TRUE if function succeeded
//
//------------------------------------------------------------------------------
bool CTCPIPCommConnect::ConnectRequest( SOCKET    PassiveSocket )
{
   //Original Code : 
   m_PassiveSocket = PassiveSocket;

   // Signal the connect thread to establish/await the connection
   if ( ! SetEvent( m_hEventConnecting ) )
   {
     m_LastSocketError = GetLastError();
     return false;
   }

   return true;
}


//------------------------------------------------------------------------------
// Description:
//   Close the connection to the communication partner
//
// Input:  ----
//
// Output: ----
//
// Return:  TRUE if function succeeded
//
//------------------------------------------------------------------------------
bool CTCPIPCommConnect::DisconnectRequest( void )
{
    if ( m_Socket != INVALID_SOCKET )
    {
       closesocket( m_Socket );
    }

    m_Socket = INVALID_SOCKET;
    return false;
}


//------------------------------------------------------------------------------
// Description:
//   Awaits the connection from the communication partner (passive connection)
//
// Input:  ----
//
// Output: ----
//
// Return: TRUE if function succeeded
//
//------------------------------------------------------------------------------
bool CTCPIPCommConnect::AwaitConnection( void )
{
   // Hier ist noch ein Hund begraben. Manchmal bleibt er hier stehen
   // => kann keine Verbindung herstellen.
   if ( ( m_Socket = accept( m_PassiveSocket, NULL, NULL ) ) == INVALID_SOCKET )
   {
      m_LastSocketError = WSAGetLastError();
      return false;
   }

   return true;
}


//------------------------------------------------------------------------------
// Description:
//   Establishes the connection to the communication partner (active connection)
//
// Input:  ----
//
// Output: ----
//
// Return: TRUE if function succeeded
//
//------------------------------------------------------------------------------
bool CTCPIPCommConnect::EstablishConnection( void )
{
   if ( ( m_Socket = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
   {
      m_LastSocketError = WSAGetLastError();
      return FALSE;
   }

   if ( connect( m_Socket,
                 (PSOCKADDR) & m_RemoteAddr,
                 sizeof( m_RemoteAddr ) ) == SOCKET_ERROR )
   {
      m_LastSocketError = WSAGetLastError();
      return FALSE;
   }

   return TRUE;
}


//------------------------------------------------------------------------------
// Description:
//   Thread starting routine
//
// Input:
//    pClass           : Pointer to the local class
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommConnect::ConnectThread( CTCPIPCommConnect  *pClass )
{
   char        ConnectionEstablished;
   HANDLE      Events[2];

   Events[ 0 ] = pClass->m_hEventConnecting;
   Events[ 1 ] = pClass->m_hEventTerminate;

   // Loop until thread should be terminated
   // 1. Wait for the command to establish/await the connection or to terminate thread
   // 2. Establish/await the connection
   // 3. Call ConInd or DisInd
   // goto 1.
   for ( ; ; )
   {
      // Wait for the Request to establish/await the connection
      // WaitForMultipleObjects returns 0 for Events[0] = pClass->hEventConnecting
      if ( WaitForMultipleObjects( 2, Events, FALSE, INFINITE ) != 0 )
      {
         break;      // Terminate connect thread
      }
      if ( pClass->m_PassiveConnection )
         ConnectionEstablished = pClass->AwaitConnection();
      else
         ConnectionEstablished = pClass->EstablishConnection();
      
      // if connection established indicate state to user
      if ( ConnectionEstablished )
      {
         // Set the Keep Alive Flag in order to observe permanent the connection state
         BOOL  KeepAlive    = TRUE;
         BOOL  DisableNagle = TRUE;
         int   SendBuffer   = 1200;
         int   RecvBuffer   = 1200;
/*
         int   OptLen;

         OptLen = sizeof( DisableNagle );
         if ( getsockopt( pClass->m_Socket, IPPROTO_TCP, TCP_NODELAY, (char *)&DisableNagle, &OptLen ) )
            pClass->m_LastSocketError = WSAGetLastError();

         printf( "Nagle Algorithm activated : %s\n", DisableNagle ? "NO" : "YES" );
         DisableNagle = TRUE;
*/
         if ( setsockopt( pClass->m_Socket, SOL_SOCKET, SO_KEEPALIVE,
                          (char *)&KeepAlive, sizeof( KeepAlive ) ) )
            pClass->m_LastSocketError = WSAGetLastError();
/*
         if ( setsockopt( pClass->m_Socket, IPPROTO_TCP, TCP_NODELAY, (char *)&DisableNagle, sizeof( DisableNagle ) ) )
            pClass->m_LastSocketError = WSAGetLastError();

         if ( setsockopt( pClass->m_Socket, SOL_SOCKET, SO_SNDBUF, (char *)&SendBuffer, sizeof( SendBuffer ) ) )
            pClass->m_LastSocketError = WSAGetLastError();


         OptLen = sizeof( DisableNagle );
         if ( getsockopt( pClass->m_Socket, IPPROTO_TCP, TCP_NODELAY, (char *)&DisableNagle, &OptLen ) )
            pClass->m_LastSocketError = WSAGetLastError();

         printf( "Nagle Algorithm activated : %s\n", DisableNagle ? "NO" : "YES" );
*/

         /*
         if ( setsockopt( pClass->m_Socket, SOL_SOCKET, SO_RCVBUF, (char *)&RecvBuffer, sizeof( RecvBuffer ) ) )
            pClass->m_LastSocketError = WSAGetLastError();
         */

         // Retrieve the IP Address of the communication partner for later use
         struct sockaddr_in     RemName;
         int                    RemNameLen = sizeof( RemName );

         if ( getpeername( pClass->m_Socket, (sockaddr *)&RemName, &RemNameLen ) )
            pClass->m_LastSocketError = WSAGetLastError();
         pClass->m_RemoteIPAddr = RemName.sin_addr.s_addr;
   
         /*
         printf( "Connection established : %d.%d.%d.%d. pClass = %08X\n",
                 HIBYTE( HIWORD( pClass->m_RemoteIPAddr ) ),
                 LOBYTE( HIWORD( pClass->m_RemoteIPAddr ) ),
                 HIBYTE( LOWORD( pClass->m_RemoteIPAddr ) ),
                 LOBYTE( LOWORD( pClass->m_RemoteIPAddr ) ),
                 pClass ); 
         */

         // Signal connect indication to user
         if ( ! pClass->Terminating() ) //ASC, 12.09.2001, added
            pClass->ConInd();
      }
      else
         if ( ! pClass->Terminating() )
            pClass->DisInd();
   }
   SetEvent( pClass->m_hEventTerminateFinished );
}

---