TCPIPCommReceive.cpp

//*****************************************************************************
// project   : ANALYTICA Class Library
// part      : Communication class for simple TCP/IP
// file name : TCPIPCommReceive.h
// version   : $Id: TCPIPCommReceive.cpp,v 1.7 2001/07/17 06:55:14 AxelSchmidt Exp $
// author    : Udo Weber
// platform  : MS VC++ 6.0
//
//-----------------------------------------------------------------------------
// Description:
// =============
// implementation of the class CTCPIPComm to encapsulate simple TCP/IP
// communications
// Part : Receiving of messages
//
//-----------------------------------------------------------------------------
// Revisionhistory:
// $Log: TCPIPCommReceive.cpp,v $
// Revision 1.7  2001/07/17 06:55:14  AxelSchmidt
// class destructor hangs if Thead is not already started
//
// Revision 1.6  2001/07/09 14:53:19  IngoFroehlich
// Destruction modified
//
// Revision 1.5  2001/07/06 05:40:25  AxelSchmidt
// File-Header geändert
//
// Revision 1.4  2001/07/05 16:17:58  IngoFroehlich
// receive now always byte-wise form socket
//
// 20.07.1998 UWe  Some bug fixes
// 20.04.1998 UWe  first version
//*****************************************************************************

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

#include "TCPIPCommReceive.h"

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



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


//******************************************************************************
// Methods of class 'CTCPIPCommReceive'
//******************************************************************************

// Static attributes and operations


//------------------------------------------------------------------------------
// Description:
//   Constructs the class CTCPIPCommConnect and creates a thread for the connection
//   establishment
//
// Input:
//   MaxRecvBufferLen   :  Maximum length for receiving messages
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPCommReceive::CTCPIPCommReceive( const long  MaxRecvBufferLen )
{
    m_pRecvBuffer             = NULL;
    m_ThreadHandle            = NULL;
    m_hEventTerminate         = NULL;
    m_hEventTerminateFinished = NULL;
    m_hEventStartReceiving    = NULL;

    // if no Bufferlen is specified, the InitializeClass function has to be called by the derived class
   if ( MaxRecvBufferLen > 0 )
   {
      InitializeClass( MaxRecvBufferLen );
   }
}

//------------------------------------------------------------------------------
// Description:
//   Initializes the basic class object, can bei called by the derived class, if
//   the constructed with parameter -1.
//
// Input:
//   MaxRecvBufferLen   :  Maximum length for receiving messages
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommReceive::InitializeClass( const long MaxRecvBufferLen )
{
   if ( m_pRecvBuffer != NULL )
   {
      return;  // Initialization already done, ignore call
   }

   m_Terminating      = false;
   m_MaxRecvBufferLen = MaxRecvBufferLen;
   m_pRecvBuffer      = new char[m_MaxRecvBufferLen];


   // Create the Semaphore(s) for the child (receive) 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_hEventStartReceiving    = CreateEvent( NULL,               // Security Attributes
                                            FALSE,              // Automatic Reset
                                            FALSE,              // Initial to non signaled
                                            NULL );             // Name of Semaphore

   // Create the receive thread
   m_ThreadHandle = CreateThread( NULL,                         // Security Attributes
                                  0,                            // Default Stack size
                                  (LPTHREAD_START_ROUTINE)RecvThread, // 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: ----
//
//------------------------------------------------------------------------------
CTCPIPCommReceive::~CTCPIPCommReceive()
{
    m_Terminating = TRUE;

    // Stop the receive 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_hEventStartReceiving );

    m_Terminating = FALSE;

    delete [] m_pRecvBuffer;
}


//------------------------------------------------------------------------------
// Description:
//   Performs the general initialization of the class parameters
//
// Input:
//    Socket           : The socket handle to be used for the communication
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommReceive::Initialize( const SOCKET       Socket )
{
   // Save some parameters
   m_Socket = Socket;
}


//------------------------------------------------------------------------------
// Description:
//   Start the "real" receiving part of this thread
//
// Input:  ----
//
// Output: ----
//
// Return:
//    TRUE if function call was successful
//
//------------------------------------------------------------------------------
bool CTCPIPCommReceive::StartReceiving( void )
{
    // Indicate the receive thread to start receiving data
   if ( ! SetEvent( m_hEventStartReceiving ) )
   {
      m_LastSocketError = GetLastError();
      return false;
   }

   return true;
}




//------------------------------------------------------------------------------
// Description:
//   Thread starting routine
//
// Input:
//    pClass           : Pointer to the local class
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommReceive::RecvThread( CTCPIPCommReceive  *pClass )
{
   long     DataLen = 0 ;
   long     RecvBytes;
   HANDLE   Events[2];


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


   // Loop until thread should be terminated
   // 1. Wait for the command to start receiving or to terminate thread
   // 2. Loop until connection lost or thread should be terminated
   // 2.1. Receive always 1 Byte
   // 2.2. Call Receive
   // 2.3. goto 2.1
   // 3. Call DisInd
   // goto 1.
   for ( ; ; )
   {
      // Wait for the Request to start receiving data
      // WaitForMultipleObjects returns 0 for Events[0] = pClass->hEventStartReceiving_
      if ( WaitForMultipleObjects( 2, Events, FALSE, INFINITE ) != 0 )
         break;

      // Receiving data from the socket interface
      for ( ; ; )
      {
         // Read now the "real" data of the message
         char *pData            = (char *)pClass->m_pRecvBuffer;

         // read only 1 Byte 
         RecvBytes = recv( pClass->m_Socket,
                            pData,
                            1,
                            0 );

         // if errors during receiption --> break loop --> disconnect connection
         if ( RecvBytes == SOCKET_ERROR || RecvBytes == 0 ) // ASc, 05.07.2001, 0 = Socket Connection closed
         {
            break;
         }
         // signal the receiption of data to the user
         // IFr, 09.07.01, do not call virtual func when destructed
         if ( pClass->Terminating() )  
         {
            break;
         }
         pClass->Receive( pClass->m_pRecvBuffer, 1 );

      }
      if ( ! pClass->Terminating() )
      {
         pClass->RecvDisInd();
      }
   }

   SetEvent( pClass->m_hEventTerminateFinished );
}

---