MyTestServer Klassenreferenz

Eine Beispielklasse für einen einfachen Server abgeleitet von Server. Mehr ...

#include <MyTestServer.h>

Klassendiagramm für MyTestServer:

Zusammengehörigkeiten von MyTestServer:

Öffentliche Methoden
	MyTestServer (unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, unsigned int uiDataSize, unsigned long ulMaxClients, int iSecTimeOut)
virtual	~MyTestServer ()
virtual void	processClientMessage (tcp::AbstractMessage *pTcpMessage)
int	sendToAllClients (std::string strMsg)
Öffentliche Methoden geerbt von tcp::Server
	Server (unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, unsigned int uiDataSize, unsigned long ulMaxClients, int iSecTimeOut)
virtual	~Server ()
virtual void	cancel () override
int	acceptClientMessage (AbstractMessage *pTcpMessage)
Öffentliche Methoden geerbt von tcp::TcpMain
	TcpMain (unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, int iSecTimeOut)
	TcpMain (unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, unsigned int uiDataSize, int iSecTimeOut)
virtual	~TcpMain ()
unsigned int	getPortNum () const
virtual void	setDataSize (unsigned int uiDataSize)
unsigned int	getDataSize () const
SOCKET	getMainSocket () const
void	setTimeOutSec (int iSecTimeOut)
int	TimeOutSec ()
Öffentliche Methoden geerbt von eut::RepeatingThread
	RepeatingThread ()
virtual	~RepeatingThread ()
virtual int	start ()
bool	testCancel ()
RepeatingThread::STATUS	status () const
bool	isInExclusiveAccess () const
void	setExclusiveAccess ()
void	unsetExclusiveAccess ()
int	getBreakCounter ()
virtual void	takeABreak ()
virtual void	finishBreak ()
void	waitForInput ()
void	signalInput ()

Geschützte Methoden
	MyTestServer ()
	MyTestServer (unsigned int, int, int, int, int)
	MyTestServer (unsigned int, int, int, int, unsigned int, int)
virtual void	insertNewClient (Server::ServerReceiverTransmitter *pNewServerReceiverTransmitter)
Geschützte Methoden geerbt von tcp::Server
	Server ()
	Server (unsigned int, int, int, int, int)
	Server (unsigned int, int, int, int, unsigned int, int)
virtual void	work () override
virtual void	insertNewClient (Server::ServerReceiverTransmitter *pNewServerReceiverTransmitter)
Server::ServerReceiverTransmitter *	getClient (SOCKET Socket)
virtual int	removeClient (SOCKET Socket)
virtual Server::ServerReceiverTransmitter *	generateNewServerReceiverTransmitter (Server *pParent, SOCKET Socket, unsigned int iDataSize) const
void	setClientMapReceiverValid (bool bValid)
void	clearClientMap ()
unsigned long	getMaxClients () const
virtual int	send (SOCKET ClientSocket, char *pszRawMsg, unsigned int uiRawMsgSize, unsigned int uiMessageID=0, int iActionCode=0, const std::string &rstrInfo="")
virtual int	send (Message *pTcpMessage) override
Geschützte Methoden geerbt von tcp::TcpMain
	TcpMain ()
void	setWSACleanup () const
int	startWinsock () const
Geschützte Methoden geerbt von eut::RepeatingThread
void	threadWork ()
void	setStatus (STATUS eStatus)
STATUS	getStatus ()
void	toOrder (ORDER eOrder)
ORDER	getOrder ()

Private Methoden
	MyTestServer (const MyTestServer &)
MyTestServer &	operator= (const MyTestServer &)

Weitere Geerbte Elemente
Öffentliche Typen geerbt von eut::RepeatingThread
enum	EuTHREADERROR { EuTHREAD_ERR_NO_THREAD = -10301 , EuTHREAD_ERR_THREAD_ALREADY_WORKING = -10302 , EuTHREAD_ERR_THREAD_BREAK_COUNT_LESS_THAN_ZERO = -10303 , EuTHREAD_ERR_UNKNOWN = -10400 }
	Fehlerbereich = -10301 bis -10400 Mehr ...
enum	STATUS {   eAT_THE_START , eWORKING , ePAUSING , eENDING ,   eCOMPLETED }
enum	ORDER { eUNDEFINED , eDO_WORK , eEXIT }
Geschützte Attribute geerbt von tcp::Server
ServerAcceptReceiver *	m_pAcceptReceiver
std::map< SOCKET, ServerReceiverTransmitter *, std::less< SOCKET > >	m_ClientMap
Geschützte Attribute geerbt von tcp::TcpMain
int	m_iSecTimeOut
unsigned int	m_uiServerPort
unsigned int	m_uiDataSize
int	m_iAdressFamily
int	m_iSocketType
int	m_iProtocol
SOCKET	m_MainSocket

Ausführliche Beschreibung

Eine Beispielklasse für einen einfachen Server abgeleitet von Server.

Es werden Nachrichten von angeschlossenen Clients ausgegeben. Zusätzlich kann MyTestServer Nachrichten an alle Clients versenden.

Implementierung von MyTestServer: MyTestServer.cpp

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#include "MyTestServer.h"
#include <iostream>
//-----------------------------------------------------------------------------
#define SUPER Server
//-----------------------------------------------------------------------------
MyTestServer::MyTestServer()
: SUPER()
{
}
//-----------------------------------------------------------------------------
MyTestServer::MyTestServer( unsigned int uiPort,
                            int iAdressFamily,
                            int iSocketType,
                            int iProtocol,
                            int iSecTimeOut )
: SUPER( uiPort, iAdressFamily, iSocketType, iProtocol, iSecTimeOut )
{
}
//-----------------------------------------------------------------------------
MyTestServer::MyTestServer( unsigned int uiPort,
                            int iAdressFamily,
                            int iSocketType,
                            int iProtocol,
                            unsigned int uiDataSize,
                            int iSecTimeOut )
: SUPER( uiPort, iAdressFamily, iSocketType, iProtocol, uiDataSize, iSecTimeOut )
{
}
//-----------------------------------------------------------------------------
MyTestServer::MyTestServer( unsigned int uiPort,
                            int iAdressFamily,
                            int iSocketType,
                            int iProtocol,
                            unsigned int uiDataSize,
                            unsigned long ulMaxClients,
                            int iSecTimeOut )
: SUPER( uiPort, iAdressFamily, iSocketType, iProtocol, uiDataSize, ulMaxClients, iSecTimeOut )
{
}
//-----------------------------------------------------------------------------
MyTestServer::~MyTestServer()
{
}
//-----------------------------------------------------------------------------
void MyTestServer::processClientMessage( tcp::AbstractMessage * pTcpMessage )
{
  tcp::Message             * t_pTcpMessage = dynamic_cast<tcp::Message*>( pTcpMessage );
  tcp::ServerMessage       * t_pTcpServerMessage = dynamic_cast<tcp::ServerMessage*>( pTcpMessage );
  tcp::ServerAcceptMessage * t_pTcpServerAcceptMessage = dynamic_cast<tcp::ServerAcceptMessage*>( pTcpMessage );
  
  if ( t_pTcpServerMessage )
  {
    if ( t_pTcpServerMessage->getActionCode() < 0 )
    {
      std::cout << "server get error-msg from client[" <<  t_pTcpServerMessage->getSocket() <<"] with code [" << t_pTcpServerMessage->getActionCode() << "]" << std::endl;
    }
    else
    {
      std::cout << "server get client-msg from client[" << t_pTcpServerMessage->getSocket() << "] with code [" << t_pTcpServerMessage->getActionCode() << "]";
      if ( t_pTcpServerMessage->getRawMsgSize() )
      {
        std::cout << " - " << t_pTcpServerMessage->getRawMsgPt();
      }
      std::cout << std::endl;
    }
  }
  else if ( t_pTcpServerAcceptMessage )
  {
    std::cout << "new client:" << t_pTcpServerAcceptMessage->getSocket() << std::endl;
  }
  else if ( t_pTcpMessage )
  {
    std::cout << "Err! No message!" << std::endl;
  }
  if ( pTcpMessage ) SUPER::processClientMessage( pTcpMessage );
}
//-----------------------------------------------------------------------------
int MyTestServer::sendToAllClients( std::string strMsg )
{
  int                                                         t_iErr = 0;
  std::map< SOCKET, ServerReceiverTransmitter * >::iterator   m_ClientMapIterator;
  char                                                      * t_pchBuffer = 0;
  tcp::Message                                              * t_pTcpMessage = 0;
  
  if ( m_ClientMap.size() > 0 )
  {
    for ( m_ClientMapIterator = m_ClientMap.begin();
          m_ClientMapIterator != m_ClientMap.end();
          m_ClientMapIterator++ )
    {
      t_pchBuffer = new char[ strlen( strMsg.c_str() ) + 1 ];
      strcpy(t_pchBuffer, strMsg.c_str());
      t_pchBuffer[ strlen( strMsg.c_str() ) ] = '\x00';
      t_pTcpMessage = new tcp::Message( t_pchBuffer, strlen( strMsg.c_str() ) + 1, 0, 0, "" );
      // int acceptOrder( Message * pTcpMessage  );
      t_iErr = (*m_ClientMapIterator).second->send( t_pTcpMessage );
    }
  }
  return t_iErr;
}
//-----------------------------------------------------------------------------
void MyTestServer::insertNewClient( Server::ServerReceiverTransmitter * pNewServerReceiverTransmitter )
{
  int              t_iErr(0);
  std::string      t_sIPAdress;
  unsigned int    t_uiPort(0);
  
  SUPER::insertNewClient( pNewServerReceiverTransmitter );
  t_iErr = pNewServerReceiverTransmitter->getPeerName( t_sIPAdress, t_uiPort );
  std::cout << "new client ip:" << t_sIPAdress << " port:" << t_uiPort << " err:" << t_iErr << std::endl;
 
}
//-----------------------------------------------------------------------------
#undef SUPER
//-----------------------------------------------------------------------------

Die Klasse MyTestServer kann folgendermassen ausprobiert werden:

ServerMain.cpp

#ifdef _MSC_VER
  #ifdef _DEBUG
    // detect Memory-Leaks
    #include <crtdbg.h>
    #define _CRTDBG_MAP_ALLOC
  #endif
#endif
#ifdef _DEBUG_MEMORY_SPY
  #include <MliForMain.h>
#endif
#include "MyTestServer.h"
#include <EuException.h>
#include <iostream>
#if defined(_MSC_VER) || defined(__MINGW32__)
  #include <conio.h>
#elif defined(__GNUC__)
  #include <unistd.h>
  #include <termios.h>
  #include <stdio.h>
  #include <string.h>
  //---------------------------------------------------------------------------
  int _getche()
  {
    char            ch = 0;
    struct termios  tOld;
 
    fflush( stdout );
    if ( tcgetattr( 0, & tOld ) < 0 )
    {
      perror("tcgetattr");
    }
    tOld.c_lflag &= ~ICANON;
    tOld.c_lflag &= ~ECHO;
    tOld.c_cc[VMIN] = 1;
    tOld.c_cc[VTIME] = 0;
    if ( tcsetattr( 0, TCSANOW, & tOld ) < 0 )
    {
      perror("tcsetattr ICANON");
    }
    if ( read( 0, & ch, 1 ) < 0 )
    {
      perror("read");
    }
    tOld.c_lflag |= ICANON;
    tOld.c_lflag |= ECHO;
    if ( tcsetattr( 0, TCSADRAIN, & tOld ) < 0 )
    {
      perror("tcsetattr ~ICANON");
    }
    return ch;
  }
  //---------------------------------------------------------------------------
  int _kbhit( void )
  {
    static  int     ch = 0,
                    fd = 0;
    struct termios  tNew,
                    tOld;
 
    tcgetattr( fd, & tOld );
    memcpy( & tNew, & tOld, sizeof( tNew ) );
    tNew.c_lflag = tNew.c_lflag & ( ! ICANON );
    tNew.c_cc[VMIN] = 0;
    tNew.c_cc[VTIME] = 1;
    tcsetattr( fd, TCSANOW, & tOld );
    if ( ch != -1 ) ungetc( ch, stdin );
    return ( ( ch != -1 ) ? 1 : 0 );
  }
  //---------------------------------------------------------------------------
#endif
//-----------------------------------------------------------------------------
 
int main(int argc, char *argv[])
{
  #ifdef _MSC_VER
    #ifdef _DEBUG
      // Display the memory leaks if any are present...
      _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
      // Next line with the memory address from "{ } ({56} normal block at 0x00D01C78, 10 bytes long.)".
      //_crtBreakAlloc = 1149;
    #endif
  #endif
  #ifdef _DEBUG_MEMORY_SPY
    MemSpy::activateMemoryMonitoring();
  #endif
 
  MyTestServer  * t_pServer(0);
  int             t_iErr = 0;
  std::string     t_sServerOutput;
  char            t_Key;
  unsigned long   t_ulMaxClients = 2;
 
  try
  {
    // Server starten
    t_pServer = new MyTestServer( 12345, PF_INET, SOCK_STREAM, 0, 150, t_ulMaxClients, 5 );
  }
  catch( eut::ErrorNException ERR )
  {
    std::cout << "new MyTestServer Err: " << ERR.error() << std::endl;
    std::cout << "press key";
    t_Key = _getche();
    return ERR.error();
  }
  std::cout << "Server started -> max clients="<< t_ulMaxClients << std::endl;
  do
  {
    std::cout << "Input for all clients or 'q' for exit:" << std::endl;
    std::cin >> t_sServerOutput;
    t_iErr = t_pServer->sendToAllClients( t_sServerOutput );
  } while ( ! t_iErr && t_sServerOutput != "q" );
  t_pServer->cancel();
  delete t_pServer;
  #ifdef _DEBUG_MEMORY_SPY
    // Display memory leaks
    MemSpy::finishMemoryMonitoring( MemSpy::OUTPUT_TRACE | MemSpy::OUTPUT_CONSOLE );
  #endif
  std::cout << "press key";
  t_Key = _getche();
  return t_iErr;
}

Copyright

© 2010 Helmut Jakoby

Autor

Helmut Jakoby

Beschreibung der Konstruktoren und Destruktoren

MyTestServer() [1/5]

MyTestServer::MyTestServer ( )

protected

Dieser Konstruktor steht niccht zur Verfügung.

MyTestServer() [2/5]

MyTestServer::MyTestServer ( unsigned int , int , int , int , int  )

protected

Dieser Konstruktor steht niccht zur Verfügung.

MyTestServer() [3/5]

MyTestServer::MyTestServer ( unsigned int , int , int , int , unsigned int , int  )

protected

Dieser Konstruktor steht niccht zur Verfügung.

MyTestServer() [4/5]

MyTestServer::MyTestServer	(	unsigned int	uiPort,
		int	iAdressFamily,
		int	iSocketType,
		int	iProtocol,
		unsigned int	uiDataSize,
		unsigned long	ulMaxClients,
		int	iSecTimeOut )

Der Konstruktor startet den Server.

Parameter

[in]	uiPort	Der Port des Servers.
[in]	iAdressFamily	Die Socket-AdressFamily um einen Socket zu instanziieren (i.d.R. AF_INET ).
[in]	iSocketType	Der Socket-Typ (i.d.R. SOCK_STREAM ).
[in]	iProtocol	Das Socket-Protokol (i.d.R. 0).
[in]	uiDataSize	Die Paketgröße.
[in]	ulMaxClients	Die maximale Anzahl von Clients, die sich verbinden dürfen.
[in]	iSecTimeOut	Die Zeit bis ein Warten auf eine Verbindung bzw. warten auf Daten abgebrochen wird.

Ausnahmebehandlung

eut::ErrorNException

Bei einem Fehler wird eine Exception geworfen.

~MyTestServer()

virtual MyTestServer::~MyTestServer ( )

virtual

Destruktor.

MyTestServer() [5/5]

MyTestServer::MyTestServer ( const MyTestServer & )

private

Der Copy-Konstruktor steht nicht zur Verfügung.

Dokumentation der Elementfunktionen

insertNewClient()

virtual void MyTestServer::insertNewClient ( Server::ServerReceiverTransmitter * pNewServerReceiverTransmitter )

protectedvirtual

Fügt einen neuen Client als 'ServerReceiverTransmitter' in seine m_ClientMap ein. Zeigt nach selbigen Aufruf in Oberklasse den Client hier über std::cout an.

Parameter

[in]

pNewServerReceiverTransmitter

Der Client ist in diesem Objekt.

operator=()

MyTestServer & MyTestServer::operator= ( const MyTestServer & )

private

Der Zuweisungsoperator steht nicht zur Verfügung.

processClientMessage()

virtual void MyTestServer::processClientMessage ( tcp::AbstractMessage * pTcpMessage )

virtual

Gibt eine Nachricht von einem verbundenen Client über std::cout aus.

Parameter

[in]

pTcpMessage

Die zu verarbeitende Nachricht vom Server.

Erneute Implementation von tcp::Server.

sendToAllClients()

int MyTestServer::sendToAllClients

(

std::string

strMsg

)

Sendet an alle verbundenen Clients eine Text-Nchricht.

Parameter

[in]

strMsg

Die zu versendende Nachricht.

Rückgabe

Eine Rückgabe < 0 zeigt einen Fehler an.

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• MyTestServer.h