GlobalObjects
Lade ...
Suche ...
Keine Treffer
tcp::Server Klassenreferenz

Eine einfache TCP-Serverklasse, welche ihr KnowHow in den abgeleiteten Klassen lernen soll. Mehr ...

#include <TcpServer.h>

Klassendiagramm für tcp::Server:

Klassen

class  ServerReceiverTransmitter
 Tuple von Socket-Receiver und -Transmitter für den Server. Mehr ...
 

Öffentliche Methoden

 Server (unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, unsigned int uiDataSize, unsigned long ulMaxClients, int iSecTimeOut)
 
virtual ~Server ()
 
int acceptClientMessage (AbstractMessage *pTcpMessage)
 
virtual void cancel () override
 
- Ö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 getDataSize () const
 
SOCKET getMainSocket () const
 
unsigned int getPortNum () const
 
virtual void setDataSize (unsigned int uiDataSize)
 
void setTimeOutSec (int iSecTimeOut)
 
int TimeOutSec ()
 
- Öffentliche Methoden geerbt von eut::RepeatingThread
 RepeatingThread ()
 
virtual ~RepeatingThread ()
 
virtual void finishBreak ()
 
int getBreakCounter ()
 
bool isInExclusiveAccess () const
 
void setExclusiveAccess ()
 
void signalInput ()
 
virtual int start ()
 
RepeatingThread::STATUS status () const
 
virtual void takeABreak ()
 
bool testCancel ()
 
void unsetExclusiveAccess ()
 
void waitForInput ()
 

Geschützte Methoden

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

Geschützte Attribute

std::map< SOCKET, ServerReceiverTransmitter *, std::less< SOCKET > > m_ClientMap
 
ServerAcceptReceiverm_pAcceptReceiver
 
- Geschützte Attribute geerbt von tcp::TcpMain
int m_iAdressFamily
 
int m_iProtocol
 
int m_iSecTimeOut
 
int m_iSocketType
 
SOCKET m_MainSocket
 
unsigned int m_uiDataSize
 
unsigned int m_uiServerPort
 

Private Methoden

 Server (const Server &rT)
 
void init ()
 
Serveroperator= (const Server &)
 

Private Attribute

std::queue< AbstractMessage * > m_MsgQueue
 
unsigned long m_ulMaxClients
 

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  ORDER { eUNDEFINED , eDO_WORK , eEXIT }
 
enum  STATUS {
  eAT_THE_START , eWORKING , ePAUSING , eENDING ,
  eCOMPLETED
}
 
- Öffentliche Attribute geerbt von eut::RepeatingThread
std::string m_strDebugInfo
 

Ausführliche Beschreibung

Eine einfache TCP-Serverklasse, welche ihr KnowHow in den abgeleiteten Klassen lernen soll.

Server ist ein Thread, welcher erlaubt, dass sich Client's mit ihm Verbinden.

Server haben als Oberklassen-Attribute den Port, die Datengröße welche versendet wird, die Adressfamilie, den Sockettyp, den Protokoltyp und einen MainSocket (hier AcceptSocket).

Zusätzlich sind hier als Attribute ein ServerAcceptReceiver, welcher die Neuanfragen als Thread bearbeitet, eine MsgQueue, welche die einzelnen Messages der einzelnen ClientSockets aufnimmt, ein Counter welcher die maximale Anzahl Clients beinhaltet und eine ClientMap mit den einzelnen ServerReceiverTransmitter-Objekten.

Für jeden angenommenen Client wird ein Objekt der eingebetteten Klasse ServerReceiverTransmitter instanziiert, welche einen Transmitter und einen Receiver besitzt und in die ClientMap abgelegt. Transmitter und Receiver sind jeweils auch Threads.

Start des Servers:

Bei der instanziierung mit Übergabe von Port, Adressfamilie, Sockettyp, Protokol, Datengröße und maximale Clientanzahl wird der eigene Thread und der ServerAcceptReceiver initialisiert (mit dem aufrufenden Server als Elternobjekt und dem MainSocket ) und ebenfalls als Thread gestartet. Dieser blockiert immer solang, bis sich ein Client anmeldet.

Neuer Client will sich verbinden:

Wenn sich ein Client beim ServerAcceptReceiver anmeldet, wird eine neue ServerAcceptMessage instanziiert (mit dem neuen SOCKET des Clients als Parameter) und an den Server über Server::acceptClientMessage(AbstractMessage *) weitergegeben.

In Server::acceptClientMessage(AbstractMessage *) wird die übergebene ServerAcceptMessage in die MsgQueue angehängt. Beim abarbeiten der MsgQueue in Server::work() wird die ServerAcceptMessage gefunden.

Wenn die maximale Clientanzahl überschritten ist, wird dieses dem Client mitgeteilt und der Clientsocket geschlossen.

Wenn der Clientsocket nicht geschlossen, wird ein ServerReceiverTransmitter über eine virtuale Methode Server::generateNewServerReceiverTransmitter (...) instanziiert. Übergeben wird der Server als Elternobjekt für den noch zu instanziiernden ServerReceiver, der neue Socket und die Datengröße. Es werden für den ServerReceiverTransmitter ein Transmitter (der sendet Daten an den neuen Client) und ein ServerReceiver (der empfängt Daten des neuen Client) instanziiert. Es ist möglich einen abgeleiteten ServerReceiverTransmitter mit abgeleiteten Transmitter bzw. ServerReceiver zu etablieren.

Der neue ServerReceiverTransmitter wird in die ClientMap eingefügt.

Jetzt wird noch die Server-Methode Server::processClientMessage(AbstractMessage *) aufgerufen, in welcher in Unterklassen eine weitere Bearbeitung vorgenommen werden kann. Hier wird u.a. die ServerAcceptMessage aus dem Speicher entfernt.

Für weitere Messages des Clients ist jetzt der neue ServerReceiverTransmitter bzw. dessen ServerReceiver in der ClientMap zuständig.

Daten vom Client verarbeiten:

Der ServerReceiver wartet in seiner Threadmethode ServerReceiver::work() auf Messages des verbundenen Clients. Wenn der Client sendet (Abbruch oder Daten), wird vom ServerReceiver eine neue ServerMessage über die Methode ServerReceiver::generateNewTcpMessage (...) instanziiert (kann in Unterklassen überschrieben werden, um abgeleitete MessageTypen zu liefern) und über Methode ServerReceiver::acceptMessage(AbstractMessage *) an den Parent-Server Server::acceptClientMessage(AbstractMessage *) weitergegeben.

In Unterklassen kann ein abgeleitete ServerReceiver die Bearbeitung in der überschriebenen ServerReceiver::acceptMessage(AbstractMessage *) übernehmen und/oder der abgeleitete Server in der überschriebenen Server::acceptClientMessage(AbstractMessage *).

In der Methode Server::acceptClientMessage(AbstractMessage *) wird die übergebene ServerMessage in die MsgQueue angehängt. Beim abarbeiten der MsgQueue wird die ServerMessage gefunden und an Server::processClientMessage(AbstractMessage *) weitergegeben. Wenn der Client die Verbindung unterbrochen hat, wird die Nachricht modifiziert und der Client über Server::removeClient(SOCKET Socket) entfernt).

In Server::processClientMessage(AbstractMessage *) kann wie erwähnt in Unterklassen eine spezielle Bearbeitung vorgeneommen werden; hier wird nur die ServerAcceptMessage aus dem Speicher entfernt.

Senden an den Client:

Muss in Unterklassen von Server bzw. Unterklassen von ServerReceiverTransmitter oder sonstwie ausgearbeitet werden. Zumindest haben alle Klassen Zugriff auf den Socket.

Beenden vom Server:

Es wird zuerst der Server-Thread angehalten, dann der ServerAcceptReceiver aus dem Speicher entfernt. Zuletzt werden alle ServerReceiver aus der ClientMap und dem Speicher entfernt.

Autor
Helmut Jakoby

Beschreibung der Konstruktoren und Destruktoren

◆ Server() [1/5]

tcp::Server::Server ( )
protected

Dieser Konstruktor steht niccht zur Verfügung.

◆ Server() [2/5]

tcp::Server::Server ( unsigned int ,
int ,
int ,
int ,
int  )
protected

Dieser Konstruktor steht niccht zur Verfügung.

◆ Server() [3/5]

tcp::Server::Server ( unsigned int ,
int ,
int ,
int ,
unsigned int ,
int  )
protected

Dieser Konstruktor steht niccht zur Verfügung.

◆ Server() [4/5]

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

Dieser Konstruktor startet den Server.

Parameter
[in]uiPortDer Port des Servers.
[in]iAdressFamilyDie Socket-AdressFamily um einen Socket zu instanziieren (i.d.R. AF_INET).
[in]iSocketTypeDer Socket-Typ (i.d.R. SOCK_STREAM).
[in]iProtocolDas Socket-Protokol (i.d.R. 0).
[in]uiDataSizeDie Paketgröße.
[in]ulMaxClientsDie maximale Anzahl von Clients, die sich verbinden dürfen.
[in]iSecTimeOutDie Zeit bis ein Warten auf eine Verbindung bzw. warten auf Daten abgebrochen wird.
Ausnahmebehandlung
eut::ErrorNExceptionBei einem Fehler wird eine Exception geworfen.

◆ ~Server()

virtual tcp::Server::~Server ( )
virtual

Destruktor. Es wird aufgeräumt (AcceptReceiver und MsgQueue).

Erneute Implementation in glo::Server.

◆ Server() [5/5]

tcp::Server::Server ( const Server & rT)
private

Der Copy-Konstruktor steht nicht zur Verfügung.

Dokumentation der Elementfunktionen

◆ acceptClientMessage()

int tcp::Server::acceptClientMessage ( AbstractMessage * pTcpMessage)

Es wird die übergebene Message vom Client über den ServerAcceptReceiver oder ServerReceiver in die MsgQueue eingefügt und somit verarbeitet.

Parameter
[in]pTcpMessageDie erhaltene Nachricht vom Client.
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

◆ cancel()

virtual void tcp::Server::cancel ( )
overridevirtual

Wenn der Thread beendet wirde, wird diese virtuale Methode aufgerufen. Hier wird die MsgQueue aufgeräumt.

Zu beachten
Diese Methode gibt es nur, wenn nicht mit POSIX-Threads kompiliert (defined (__PTHREADS)).

Erneute Implementation von eut::RepeatingThread.

Erneute Implementation in glo::Server.

◆ clearClientMap()

void tcp::Server::clearClientMap ( )
protected

Entfernt alle ServerReceiverTransmitter aus seiner Liste der Clients und aus dem Speicher.

◆ generateNewServerReceiverTransmitter()

virtual Server::ServerReceiverTransmitter * tcp::Server::generateNewServerReceiverTransmitter ( Server * pParent,
SOCKET Socket,
unsigned int iDataSize ) const
protectedvirtual

Liefert hier einen ServerReceiverTransmitter; kann in Unterklassen überschrieben werden um einen abgeleiteten Typ liefern. Wird in work() aufgerufen, wenn ein neuer Client hinzukommt.

Parameter
[in]pParentServer oder Unterklasse.
[in]SocketSocket des neuen Clients.
[in]iDataSizeDie Packetgröße.
Rückgabe
Der ServerReceiverTransmitter bzw. in den Unterklassen benötigter abgeleiteter Typ.

Erneute Implementation in glo::Server.

◆ getClient()

Server::ServerReceiverTransmitter * tcp::Server::getClient ( SOCKET Socket)
protected

Sucht den mit Parameter 'Socket' korrespondierenden ServerReceiverTransmitter in seine Liste der Clients und liefert einen Zeiger auf diesen, wenn vorhanden.

Parameter
[in]SocketDer Socket des gesuchten ServerReceiverTransmitter.
Rückgabe
Wenn != 0, dann der gefundene ServerReceiverTransmitter.
Achtung
Das gelieferte Objekt lebt nur so lange wie das liefernde Objekt und darf NICHT von der aufrufenden Instanz aus dem Speicher entfernt werden.

◆ getMaxClients()

unsigned long tcp::Server::getMaxClients ( ) const
protected

Liefert die Anzahl der maximal zulässigen Clientverbindungen.

Rückgabe
Die maximal zulässige Anzahl der Clientverbindungen.

◆ init()

void tcp::Server::init ( )
private

Initialisiert den Socket und instanziiert einen ServerAcceptReceiver. Die eigenen Attribute müssen sinnvolle Werte haben.

Ausnahmebehandlung
eut::ErrorNExceptionBei einem Fehler wird eine Exception geworfen.

◆ insertNewClient()

virtual void tcp::Server::insertNewClient ( Server::ServerReceiverTransmitter * pNewServerReceiverTransmitter)
protectedvirtual

Fügt neuen Client als 'ServerReceiverTransmitter' in seine Liste der Clients ein. Diese Methode ist virtual, damit in Unterklasse darauf reagieren werden kann; z.B. irgendwem mitteilen, dass ein neuer Client da ist.

Parameter
[in]pNewServerReceiverTransmitterDer Client ist in diesem Objekt.

Erneute Implementation in glo::Server.

◆ operator=()

Server & tcp::Server::operator= ( const Server & )
private

Der Zuweisungsoperator steht nicht zur Verfügung.

◆ processClientMessage()

virtual void tcp::Server::processClientMessage ( AbstractMessage * pTcpMessage)
protectedvirtual

Soll in Unterklassen die Nachricht vom Client verarbeiten. In den überschriebenen Methoden mus immer diese Methode aufgerufen werden, weil hier u.a. die übergebene Message aus dem Speicher entfernt wird.

Parameter
[in]pTcpMessageDie zu verarbeitende Nachricht vom Client.

Erneute Implementation in glo::Server.

◆ removeClient()

virtual int tcp::Server::removeClient ( SOCKET Socket)
protectedvirtual

Sucht den mit Parameter 'Socket' korrespondierenden ServerReceiverTransmitter in seine Liste der Clients und entfernt diesen daraus und aus dem Speicher.

Parameter
[in]SocketDer Socket, welcher geschlossen werden soll.
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

Erneute Implementation in glo::Server.

◆ send() [1/2]

virtual int tcp::Server::send ( Message * pTcpMessage)
overrideprotectedvirtual

Sendet übergebene Message über seinen Transmitter an den Client (ersichlich aus der ServerMessage).

Parameter
[in]pTcpMessageDas zu sendende Nachrichtenpacket, muss eine ServerMessage sein.
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.
Achtung
Die übergebene Message darf von der aufrufenden Instanz nicht aus dem Speicher entfernt werden! Da die Message zur Weiterverarbeitung an den Transmitter gegeben wird, und dieser entscheidet wann gesendet wird. Darum wird dieser auch die Message aus dem Speicher entfernen.

Implementiert tcp::TcpMain.

◆ send() [2/2]

virtual int tcp::Server::send ( SOCKET ClientSocket,
char * pszRawMsg,
unsigned int uiRawMsgSize,
unsigned int uiMessageID = 0,
int iActionCode = 0,
const std::string & rstrInfo = "" )
protectedvirtual

Sendet übergebene Daten über seinen Transmitter an den Client. Es wird ein Header generiert.

Parameter
[in]ClientSocketSocket des Zielclients.
[in]pszRawMsgZeiger auf die zu sendenden Daten.
[in]uiRawMsgSizeDie Größe der zu sendenden Daten.
[in]uiMessageIDEs kann eine MessageID übergeben werden.
[in]iActionCodeEs kann ein ActionCode übergeben werden.
[in]rstrInfoEs kann eine freie Info übergeben werden.
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.
Achtung
Es werden die Daten in pszRawMsg intern aus dem Speicher entfernt; die aufrufende Instanz darf die zu sendenden Daten nicht mehr verwenden oder aus dem Speicher entfernen.

◆ setClientMapReceiverValid()

void tcp::Server::setClientMapReceiverValid ( bool bValid)
protected

Setzt bei allen ServerReceiverTransmitter aus seiner Liste der Clients das Valid-Flag.

Parameter
[in]bValidWenn false -> kein Empfang mehr!

◆ work()

virtual void tcp::Server::work ( )
overrideprotectedvirtual

Arbeit des Threads. Es werden neue Clients 'aufgenommen' bzw. abgelehnt wenn die max. Anzahl erreicht. Es werden Nachrichten von Clients abgearbeitet.

Implementiert eut::RepeatingThread.

Dokumentation der Datenelemente

◆ m_ClientMap

std::map< SOCKET, ServerReceiverTransmitter *, std::less< SOCKET > > tcp::Server::m_ClientMap
protected

Alle angenommenen Clients im Server::ServerReceiverTransmitter.

◆ m_MsgQueue

std::queue<AbstractMessage *> tcp::Server::m_MsgQueue
private

Die Queue mit den empfangenen Daten vom Client.

◆ m_pAcceptReceiver

ServerAcceptReceiver* tcp::Server::m_pAcceptReceiver
protected

Der AcceptReceiver nimmt neue Clients an.

◆ m_ulMaxClients

unsigned long tcp::Server::m_ulMaxClients
private

Die maximle Anzahl der anzunehmenden Clients. Wird die Anzahl überschritten, werden keine Clients mehr angenommen.


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