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:

Zusammengehörigkeiten von 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 ()
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
	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 void	processClientMessage (AbstractMessage *pTcpMessage)
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 ()

Geschützte Attribute
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

Private Methoden
	Server (const Server &rT)
void	init ()
Server &	operator= (const Server &)

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

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 }

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.

Copyright

© 2010 Helmut Jakoby

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]	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.

~Server()

virtual tcp::Server::~Server ( )

virtual

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

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]

pTcpMessage

Die 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.

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]	pParent	Server oder Unterklasse.
[in]	Socket	Socket des neuen Clients.
[in]	iDataSize	Die Packetgröße.

Rückgabe

Der ServerReceiverTransmitter bzw. in den Unterklassen benötigter abgeleiteter Typ.

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]

Socket

Der 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::ErrorNException

Bei 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]

pNewServerReceiverTransmitter

Der Client ist in diesem Objekt.

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]

pTcpMessage

Die zu verarbeitende Nachricht vom Client.

Erneute Implementation in MyTestServer.

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]

Socket

Der Socket, welcher geschlossen werden soll.

Rückgabe

Eine Rückgabe < 0 zeigt einen Fehler an.

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]

pTcpMessage

Das 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]	ClientSocket	Socket des Zielclients.
[in]	pszRawMsg	Zeiger auf die zu sendenden Daten.
[in]	uiRawMsgSize	Die Größe der zu sendenden Daten.
[in]	uiMessageID	Es kann eine MessageID übergeben werden.
[in]	iActionCode	Es kann ein ActionCode übergeben werden.
[in]	rstrInfo	Es 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]

bValid

Wenn 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:

• TcpServer.h