TCPIPCommSend.cpp

//*****************************************************************************
// project   : ANALYTICA Class Library
// part      : Communication class for simple TCP/IP
// file name : TCPIPCommSend.h
// version   : $Id: TCPIPCommSend.cpp,v 1.4 2001/07/17 06:55:23 AxelSchmidt Exp $
// author    : Udo Weber
// platform  : MS VC++ 6.0
//
//-----------------------------------------------------------------------------
// Description:
// =============
// implementation of the class CTCPIPComm to encapsulate simple TCP/IP
// communications
// Part : Sending of messages
//
//-----------------------------------------------------------------------------
// Revisionhistory:
// $Log: TCPIPCommSend.cpp,v $
// Revision 1.4  2001/07/17 06:55:23  AxelSchmidt
// class destructor hangs if Thead is not already started
//
// Revision 1.3  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 "TCPIPCommSend.h"


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



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


//******************************************************************************
// Methods of class 'CTCPIPCommSend'
//******************************************************************************

// Static attributes and operations


//------------------------------------------------------------------------------
// Description:
//   Constructs the class CTCPIPCommSend and creates a thread for sending
//   of messages
//
// Input:
//   MaxSendBufferLen   :  Maximum length for sending messages
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
CTCPIPCommSend::CTCPIPCommSend( const long  MaxSendBufferLen )
{
   m_pSendBuffer             = NULL;
   m_hWritePipe              = NULL;
   m_hReadPipe               = NULL;
   m_hEventTerminateFinished = NULL;
   m_ThreadHandle            = NULL;

   if ( MaxSendBufferLen > 0 )
   {
      InitializeClass( MaxSendBufferLen );
   }
}

void CTCPIPCommSend::InitializeClass( const long MaxSendBufferLen )
{
   if ( m_pSendBuffer != NULL )
   {
      // Initialization already done, ignore call
      return;
   }

   m_Terminating      = false;
   m_MaxSendBufferLen = MaxSendBufferLen;
   m_pSendBuffer      = new char[m_MaxSendBufferLen];
   m_SendCnt          = 0;


   CreatePipe( &m_hReadPipe,                     // Read Pipe Handle
               &m_hWritePipe,                    // Write Pipe Handle
               NULL,                             // Security Attributes
               0 );                              // Default Size

   m_hEventTerminateFinished = 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)SendThread, // Thread function
                                  this,                         // Pointer to this class
                                  0,                            // Thread starts immediatly
                                  &m_ThreadID );                // Returns the Thread ID

}

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

   // Terminate the thread indirect
   CloseHandle( m_hWritePipe );
   CloseHandle( m_hReadPipe );

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

      CloseHandle( m_ThreadHandle );
   }

   delete [] m_pSendBuffer;
}



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


//------------------------------------------------------------------------------
// Description:
//   Sends the given data to the Send thread
//
// Input:
//   pData     : Pointer to the data to be transmitted
//   DataLen   : Length of the data to be transmitted
//
// Output: ----
//
// Return:
//    TRUE if function call was successful
//
//------------------------------------------------------------------------------
bool CTCPIPCommSend::Send( const void   *pData,
                           const long   DataLen )
{
   DWORD       BytesWritten;
   //long        BytesToSend;


   // Send data to the send thread
   // Prepend first the length of the message

   // printf( "S%d.%d-", ++m_SendCnt, DataLen ); !!!!!!!!!!!!!
/*
   BytesToSend = DataLen + sizeof( DataLen );

   char   *pBuffer = new char[ BytesToSend ];

   *(long *)pBuffer = DataLen;
   memcpy( pBuffer + sizeof( DataLen ), pData, DataLen );
*/
/******
         // Send the data to the socket interface
         if ( send( m_Socket,
                    (const char *)pBuffer,
                    BytesToSend,
                    0 ) == SOCKET_ERROR )
         {
            m_LastSocketError = WSAGetLastError();
            if ( ! Terminating() )
            {
               SendDisInd();
            }
         }
*****/

/****/

   // Send the data via pipe to the send thread
   if ( ! WriteFile( m_hWritePipe, pData, DataLen, &BytesWritten, NULL ) )
   {
      m_LastSocketError = GetLastError();

//      delete [] pBuffer;
      return false;
   }
/****/

//   delete [] pBuffer;

   return true;

}




//------------------------------------------------------------------------------
// Description:
//   Thread starting routine
//
// Input:
//    pClass           : Pointer to the local class
//
// Output: ----
//
// Return: ----
//
//------------------------------------------------------------------------------
void CTCPIPCommSend::SendThread( CTCPIPCommSend  *pClass )
{
   DWORD       BytesToSend;
   char        *pData;


   // Loop until thread should be terminated
   // 1. Listen to the pipe and wait for messages to be sent
   // 2. Transmit the message calling the socket function send
   // goto 1.
   for ( ; ; )
   {
      // Wait for the Request to establish/await the connection
      if ( ! ReadFile( pClass->m_hReadPipe,
                       pClass->m_pSendBuffer,
                       pClass->m_MaxSendBufferLen,
                       &BytesToSend,
                       NULL ) )
      {
         break;      // Failes if the pipe is closed (during terminating procedure)
      }
      
      pData = (char *)pClass->m_pSendBuffer;
      
      // ASc, 05.07.2001, For non-blocking socket, all data is sent (!!!! I hope so)

      // Send the data to the socket interface
      if ( send( pClass->m_Socket,
                 (const char *)pData,
                 BytesToSend,
                 0 ) == SOCKET_ERROR )
      {
         pClass->m_LastSocketError = WSAGetLastError();
         if ( ! pClass->Terminating() )
         {
            pClass->SendDisInd();
         }
      }
   }

   SetEvent( pClass->m_hEventTerminateFinished );
}

---