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

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

#include <TcpClient.h>

Klassendiagramm für tcp::Client:

Öffentliche Methoden

 Client (const std::string &rsHostname, unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, int iSecTimeOut)
 
 Client (const std::string &rsHostname, unsigned int uiPort, int iAdressFamily, int iSocketType, int iProtocol, unsigned int uiDataSize, int iSecTimeOut)
 
virtual ~Client ()
 
int acceptServerMessage (Message *pTcpServerMessage)
 
virtual void cancel () override
 
int connectServer ()
 
virtual int disconnectServer ()
 
std::string getHostName () const
 
int getPeerName (std::string &rsIPAdress, unsigned int &ruiPort) const
 
int getSocketAdrFromString (SOCKADDR_IN *Socketadress, const std::string &rsHostnameOrIp) const
 
ActionCode getWaitingServerMsgActionCode () const
 
bool isServerConnected () const
 
virtual int send (char *pszRawMsg, unsigned int uiRawMsgSize, unsigned int uiMessageID=0, int iActionCode=0, const std::string &rsInfo="")
 
virtual int send (Message *pTcpMessage) override
 
virtual void setDataSize (unsigned int uiDataSize) 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
 
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

 Client ()
 
 Client (unsigned int, int, int, int, int)
 
virtual ClientReceivergenerateNewReceiver ()
 
virtual TransmittergenerateNewTransmitter ()
 
virtual void processServerMessage (Message *pTcpMessage)
 
virtual int syncDataSize ()
 
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

ClientReceiverm_pReceiver
 
Transmitterm_pTransmitter
 
- 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

 Client (const Client &)
 
Clientoperator= (const Client &)
 

Private Attribute

ActionCode m_eToWaitingForServer
 
std::queue< Message * > m_MsgQueue
 
std::string m_sHostname
 
SOCKADDR_IN m_Socketadress
 

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-Clientklasse, welche ihr KnowHow in den abgeleiteten Klassen lernen soll.

Client läuft als Thread, welcher Verbindung zu einem Socket-Server aufnehmen kann.

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

Zusätzlich sind hier als Attribute ein ClientReceiver, welcher die Daten vom Server als Thread bearbeitet, ein Transmitter, welcher Daten an den Server sendet, die Socketadresse, der Hostname und eine MsgQueue, welche die einzelnen Messages des ClientReceiver aufnimmt.

Start des Clients:

Bei der instanziierung mit Übergabe von Hostname, Port, Adressfamilie, Sockettyp, Protokol und optional der Datengröße, wird zuerst einmal die Socketadresse anhand des übergebenen Hostnamen ermittelt und der eigene Thread gestartet.

Mit dem Server verbinden:

Es wird versucht, mit dem Server über die Client-Methode Client::connectServer() Kontakt aufzunehem. Wenn dieses gelingt, werden der ClientReceiver und Transmitter instanziiert und gestartet (auch diese sind Threads).

Der Client wartet in Client::work() auf Daten vom Server (lauscht blockierent).

Abbruch der Verbindung durch den Server:

Der Socket wird im ClientReceiver in ClientReceiver::work() freigegeben. Wenn Fehler < 0, dann ist die Verbindung abgebrochen.

Daten vom Server verarbeiten:

Es wird über ClientReceiver::generateNewTcpMessage (...) eine tcp::Message bzw. abgeleitete Message erstellt und an ClientReceiver::acceptMessage(AbstractMessage*) weitergegeben.
Diese Methode kann überschrieben werden; der ClientReceiver reicht die Message lediglich an seinen Parent (Client oder Unterklasse) Client::acceptServerMessage() weiter. Dort wird die Message in die MsgQueue des Clients eingefügt und in Client::work() weiterverarbeitet und an die Clientmethode Client::processServerMessage(Message *) weitergeleitet, welche hier anschließend die Message löscht; auch diese Methode kann überschrieben werden.

Senden an den Server:

Gesendet wird über Client::send (...) (kann in Unterklassen überschrieben werden) welche die Daten hier in eine tcp::Message packt und an Transmitter::acceptOrder (...) zum weiterverarbeiten übergibt, der diese Daten dann an den Server sendet.

Beenden der Verbindung zu Server:

Über Client::disconnectServer() wird die Verbindung zum Server abgebaut. Es werden der ClientReceiver und Transmitter entfernt. Ein erneutes connect ist möglich.

Siehe auch
MyTestClient
Autor
Helmut Jakoby

Beschreibung der Konstruktoren und Destruktoren

◆ Client() [1/5]

tcp::Client::Client ( )
protected

Dieser Konstruktor steht niccht zur Verfügung.

◆ Client() [2/5]

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

Dieser Konstruktor steht niccht zur Verfügung.

◆ Client() [3/5]

tcp::Client::Client ( const std::string & rsHostname,
unsigned int uiPort,
int iAdressFamily,
int iSocketType,
int iProtocol,
int iSecTimeOut )

Der Konstruktor startet den Client, ist aber noch nicht mit dem Server aus rsHostname verbunden.

Parameter
[in]rsHostnameDer Hostname oder IP-Adresse (z.B. "LOCALHOST" oder "192.168.2.102").
[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]iSecTimeOutDie Zeit bis ein Warten auf eine Verbindung bzw. warten auf Daten abgebrochen wird.
Ausnahmebehandlung
eut::ErrorNExceptionBei einem Fehler wird eine Exception geworfen.

◆ Client() [4/5]

tcp::Client::Client ( const std::string & rsHostname,
unsigned int uiPort,
int iAdressFamily,
int iSocketType,
int iProtocol,
unsigned int uiDataSize,
int iSecTimeOut )

Der Konstruktor startet den Client, ist aber noch nicht mit dem Server aus rsHostname verbunden.

Parameter
[in]rsHostnameDer Hostname oder IP-Adresse (z.B. "LOCALHOST" oder "192.168.2.102").
[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]iSecTimeOutDie Zeit bis ein Warten auf eine Verbindung bzw. warten auf Daten abgebrochen wird.
Ausnahmebehandlung
eut::ErrorNExceptionBei einem Fehler wird eine Exception geworfen.

◆ ~Client()

virtual tcp::Client::~Client ( )
virtual

Im Destruktor wird die Verbindung zum Server abgebrochen wenn noch nicht geschehen.

Erneute Implementation in glo::Client.

◆ Client() [5/5]

tcp::Client::Client ( const Client & )
private

Der Copy-Konstruktor steht nicht zur Verfügung.

Dokumentation der Elementfunktionen

◆ acceptServerMessage()

int tcp::Client::acceptServerMessage ( Message * pTcpServerMessage)

Es wird die übergebene Message, i.d.R. vom Server über den ClientReceiver in die MsgQueue eingefügt und somit verarbeitet.

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

◆ cancel()

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

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

Erneute Implementation von eut::RepeatingThread.

◆ connectServer()

int tcp::Client::connectServer ( )

Verbindet sich mit dem Server.

Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

◆ disconnectServer()

virtual int tcp::Client::disconnectServer ( )
virtual

Beendet die Verbindung mit dem Server.

Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

Erneute Implementation in glo::Client.

◆ generateNewReceiver()

virtual ClientReceiver * tcp::Client::generateNewReceiver ( )
protectedvirtual

Liefert hier einen ClientReceiver; kann in Unterklassen überschrieben werden um ggf. einen abgeleiteten Typ von ClientReceiver zu liefern.

Rückgabe
Zeiger auf den zu nutzenden Leser (dieser empfängt Daten von einem Server) für diesen Client
Achtung
Diese Methode wird intern genutzt und das auf dem Heap instanziierte Objekt auch intern wieder aus dem Speicher entfernt.

◆ generateNewTransmitter()

virtual Transmitter * tcp::Client::generateNewTransmitter ( )
protectedvirtual

Liefert hier einen Transmitter; kann in Unterklassen überschrieben werden um ggf. einen abgeleiteten Typ von Transmitter zu liefern.

Rückgabe
Zeiger auf den zu nutzenden Schreiber (dieser sendet Daten an einen Server) für diesen Client.
Achtung
Diese Methode wird intern genutzt und das auf dem Heap instanziierte Objekt auch intern wieder aus dem Speicher entfernt.

◆ getHostName()

std::string tcp::Client::getHostName ( ) const

Liefert den Hostname oder IP-Adresse (z.B. "LOCALHOST" oder "192.168.2.102") aus m_sHostname.

Rückgabe
s.o.

◆ getPeerName()

int tcp::Client::getPeerName ( std::string & rsIPAdress,
unsigned int & ruiPort ) const

Liefert die IP-Adresse und den Port.

Parameter
[in,out]rsIPAdressDie IP-Adresse (z.B. "192.168.2.102").
[in,out]ruiPortDer Port welcher angesprochen wird.
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

◆ getSocketAdrFromString()

int tcp::Client::getSocketAdrFromString ( SOCKADDR_IN * Socketadress,
const std::string & rsHostnameOrIp ) const

Liefert den Hostnamen als IP-Adresse.

Parameter
[in,out]SocketadressIn dieser Struktur wird die IP-Adresse geliefert.
[in]rsHostnameOrIpDer Hostname (z.B. "LOCALHOST").
Rückgabe
Eine Rückgabe < 0 zeigt einen Fehler an.

◆ getWaitingServerMsgActionCode()

ActionCode tcp::Client::getWaitingServerMsgActionCode ( ) const

Liefert den ActionCode der Message, auf die gewartet wird.

Rückgabe
s.o.

◆ isServerConnected()

bool tcp::Client::isServerConnected ( ) const

Gibt Auskunft, ob mit dem Server verbunden.

Rückgabe
Wenn true, dann besteht eine Verbindung.

◆ operator=()

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

Der Zuweisungsoperator steht nicht zur Verfügung.

◆ processServerMessage()

virtual void tcp::Client::processServerMessage ( Message * pTcpMessage)
protectedvirtual

Soll in Unterklassen die Nachricht vom Server 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 Server.

Erneute Implementation in glo::Client.

◆ send() [1/2]

virtual int tcp::Client::send ( char * pszRawMsg,
unsigned int uiRawMsgSize,
unsigned int uiMessageID = 0,
int iActionCode = 0,
const std::string & rsInfo = "" )
virtual

Sendet die übergebene Daten in einer Message über seinen Transmitter an den Server.

Parameter
[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]rsInfoEs 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.

◆ send() [2/2]

virtual int tcp::Client::send ( Message * pTcpMessage)
overridevirtual

Sendet übergebene Message über seinen Transmitter an den Server.

Parameter
[in]pTcpMessageDas zu sendende Nachrichtenpacket.
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.

◆ setDataSize()

virtual void tcp::Client::setDataSize ( unsigned int uiDataSize)
overridevirtual

Setzt die Paketgröße.

Parameter
[in]uiDataSizeDie Paketgröße.

Erneute Implementation von tcp::TcpMain.

◆ syncDataSize()

virtual int tcp::Client::syncDataSize ( )
protectedvirtual

Synchronisiert die Datengröße mit dem Server.

Rückgabe
Ein Rückgabewert < 0 zeigt einen Fehler an.

◆ work()

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

Arbeit des Threads. Es wird eine erhaltene Message an Methode Client::processServerMessage(Message * pTcpMessage) weitergereicht.

Implementiert eut::RepeatingThread.

Dokumentation der Datenelemente

◆ m_eToWaitingForServer

ActionCode tcp::Client::m_eToWaitingForServer
private

Wenn dieser Wert ungleich ACTION_UNDEF, wird in Client::work() jede Message, welche nicht diesen ActionCode hat, wieder in die MsgQueue angehängt. Somit wird in Client::work() auf die Message mit diesem ActionCode gewartet.

Wenn dann, in Client::work(), die Message mit dem diesem ActionCode eintrifft, wird m_eToWaitingForServer wieder auf ACTION_UNDEF gesetzt und die Message zur Weiterverarbeitung an Client::processServerMessage (...) weiter gereicht.

◆ m_MsgQueue

std::queue<Message *> tcp::Client::m_MsgQueue
private

Die Queue mit den empfangenen Daten vom Server.

◆ m_pReceiver

ClientReceiver* tcp::Client::m_pReceiver
protected

Der Leser empfängt Daten von einem Server für diesen Client.

Siehe auch
ClientReceiver

◆ m_pTransmitter

Transmitter* tcp::Client::m_pTransmitter
protected

Der Schreiber sendet Daten an einen Server für diesen Client.

Siehe auch
Transmitter

◆ m_sHostname

std::string tcp::Client::m_sHostname
private

Der Hostname oder IP-Adresse (z.B. "LOCALHOST" oder "192.168.2.102").

◆ m_Socketadress

SOCKADDR_IN tcp::Client::m_Socketadress
private

Die Adressstruktur.


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