![]() | Patrick's Programming Library Version 6.4.21 - Dokumentation |
TCP-Socket-Klasse. Mehr ...
SSL-Verschlüsselung | |
Die nachfolgenden Befehle werden benötigt, wenn die Kommunikation zwischen Client und Server mit SSL verschlüsselt werden soll. Voraussetzung dafür ist, dass die PPL-Library mit OpenSSL-Unterstützung kompiliert wurde. | |
int | SSL_Write (const void *buffer, int size) |
Verschlüsselte Daten schreiben. Mehr ... | |
int | SSL_Read (void *buffer, int bytes) |
Verschlüsselte Daten lesen. Mehr ... | |
int | ConnectSSL (const char *host_and_port, CSSL *ssl=NULL) |
Verschlüsselte Verbindung aufbauen. Mehr ... | |
int | ConnectSSL (const char *host, int port, CSSL *ssl=NULL) |
Verschlüsselte Verbindung aufbauen. Mehr ... | |
int | SSL_Init (CSSL *ssl) |
Verwendung von OpenSSL initialisieren. Mehr ... | |
int | SSL_Shutdown () |
SSL für diese Klasse deinitialisieren. Mehr ... | |
int | SSL_Init_Client () |
Socket als SSL-Client vorbereiten. Mehr ... | |
int | SSL_Init_Server () |
Socket als SSL-Server vorbereiten. Mehr ... | |
int | SSL_Start () |
SSL-Kommunikation starten. Mehr ... | |
int | SSL_Stop () |
SSL-Kommunikation stoppen. Mehr ... | |
int | SSL_CheckCertificate (const char *hostname, bool AcceptSelfSignedCert=false) |
SSL-Zertifikat der Gegenstelle prüfen. Mehr ... | |
int | SSL_Accept () |
Auf eine TLS/SSL-Handshake warten. Mehr ... | |
int | SSL_WaitForAccept (int timeout=0) |
Auf eine TLS/SSL-Handshake warten. Mehr ... | |
void | SSL_Info () |
bool | SSL_IsEncrypted () const |
CString | SSL_GetCipherName () const |
CString | SSL_GetCipherVersion () const |
int | SSL_GetCipherBits () const |
Öffentliche Methoden | |
CTCPSocket () | |
Konstruktor der Klasse. Mehr ... | |
virtual | ~CTCPSocket () |
Destruktor der Klasse. Mehr ... | |
int | Bind (const char *ip, int port) |
Socket auf eine IP-Adresse und Port binden. Mehr ... | |
int | Connect (const char *host_and_port) |
Verbindung aufbauen. Mehr ... | |
int | Connect (const char *host, int port) |
Verbindung aufbauen. Mehr ... | |
int | Disconnect () |
Verbindung trennen. Mehr ... | |
void | DispatchErrno () |
Fehlercode des Betriebssystems in PPL-Fehler übersetzen. Mehr ... | |
int | GetBytesRead () |
Anzahl gelesender Bytes. Mehr ... | |
int | GetBytesWritten () |
Anzahl gesendeter Bytes. Mehr ... | |
int | GetDescriptor () |
Descriptor des Sockets auslesen. Mehr ... | |
const CString & | getHostname () const |
int | getPort () const |
int | IsConnected () |
Prüfen, ob eine Verbindung besteht. Mehr ... | |
int | IsListening () |
Prüfen, ob der Socket auf eingehende Verbindungen wartet. Mehr ... | |
int | IsReadable () |
Prüfen, ob Daten vom Socket gelesen werden können. Mehr ... | |
int | IsWriteable () |
Prüfen, ob Daten auf den Socket geschrieben werden können. Mehr ... | |
int | Listen (int timeout=100) |
Server starten und auf eingehende Verbindung warten. Mehr ... | |
int | Read (void *buffer, int bytes) |
Daten lesen. Mehr ... | |
int | Read (CString &buffer, int bytes) |
Daten in einen String einlesen. Mehr ... | |
int | Read (CString *buffer, int bytes) |
Daten in einen String einlesen. Mehr ... | |
int | Read (CBinary &buffer, int bytes) |
Daten in ein CBinary-Objekt einlesen. Mehr ... | |
char * | Read (int bytes) |
Daten lesen. Mehr ... | |
int | ReadOnce (void *buffer, int bytes) |
Daten lesen. Mehr ... | |
int | ReadOnce (CString &buffer, int bytes) |
Daten lesen. Mehr ... | |
int | ReadOnce (CString *buffer, int bytes) |
Daten lesen. Mehr ... | |
char * | ReadOnce (int bytes) |
Daten lesen. Mehr ... | |
virtual int | ReceiveConnect (CTCPSocket *socket, const char *host, int port) |
Eingehende Verbindung verarbeiten. Mehr ... | |
int | SetBlocking (bool value) |
Bei Lesezugriffen blockieren. Mehr ... | |
void | SetConnectTimeout (int seconds, int useconds) |
Timeout für Connect-Funktion definieren. Mehr ... | |
void | SetLogfile (CLog *log) |
Logfile definieren. Mehr ... | |
int | SetReadTimeout (int seconds, int useconds) |
Lese-Timeout festlegen. Mehr ... | |
void | SetSource (const char *host, int port=0) |
Quell-Interface und Port festlegen. Mehr ... | |
int | SetWriteTimeout (int seconds, int useconds) |
Schreib-Timeout festlegen. Mehr ... | |
int | Shutdown () |
Verbindung trennen. Mehr ... | |
int | SignalStopListen () |
TCP-Server signalisieren, dass er stoppen soll. Mehr ... | |
int | StopListen () |
TCP-Server anhalten. Mehr ... | |
int | WaitForIncomingData (int seconds, int useconds) |
Auf eingehende Daten warten. Mehr ... | |
int | WaitForMessage (CSocketMessage &msg, int timeout=0) |
Nachricht verschicken. Mehr ... | |
int | WaitForOutgoingData (int seconds, int useconds) |
Warten, bis der Socket beschreibbar ist. Mehr ... | |
int | WatchThread (CThread *thread) |
Überwachungsthread definieren. Mehr ... | |
int | Write (const CString &str) |
String schreiben. Mehr ... | |
int | Write (const CBinary &bin) |
Binäre Daten schreiben. Mehr ... | |
int | Write (const CString *str) |
String schreiben. Mehr ... | |
int | Write (const void *buffer, int bytes) |
Daten schreiben. Mehr ... | |
int | Write (CSocketMessage &msg) |
Nachricht verschicken. Mehr ... | |
int | WriteBuffer (const void *buffer, int bytes) |
Daten schreiben. Mehr ... | |
int | Writef (const char *fmt,...) |
Formatierten String schreiben. Mehr ... | |
Öffentliche, statische Methoden | |
static ppluint32 | Htonl (ppluint32 host) |
32-Bit-Wert von Host-Byteorder in Netzwerk-Byteorder wandeln Mehr ... | |
static ppluint16 | Htons (ppluint16 host) |
16-Bit-Wert von Host-Byteorder in Netzwerk-Byteorder wandeln Mehr ... | |
static ppluint32 | Ntohl (ppluint32 net) |
32-Bit-Wert von Host-Byteorder in Hostbyteorder wandeln Mehr ... | |
static ppluint16 | Ntohs (ppluint16 net) |
16-Bit-Wert von Netzwerk-Byteorder in Host-Byteorder wandeln Mehr ... | |
Private Attribute | |
int | BytesRead |
int | BytesWritten |
int | connect_timeout_sec |
int | connect_timeout_usec |
int | connected |
CString | HostName |
int | islisten |
CLog * | log |
CMutex | mutex |
int | PortNum |
void * | socket |
CString | SourceHost |
int | SourcePort |
void * | ssl |
CSSL * | sslclass |
void * | sslreference |
bool | stoplisten |
CThread * | thread |
Verwandte Funktionen | |
(Es handelt sich hierbei nicht um Elementfunktionen.) | |
static int | out_bind (const char *host, int port) |
Socket auf ausgehendes Interface legen. Mehr ... | |
static int | ppl_connect_nb (int sockfd, struct sockaddr *serv_addr, int addrlen, int sec, int usec) |
Non-Blocking-Connect. Mehr ... | |
int | SSL_Exit () |
OpenSSL-Schnittstelle deinitialisieren. Mehr ... | |
int | SSL_Init () |
OpenSSL-Schnittstelle initialisieren. Mehr ... | |
Socket-Klasse für TCP-Verbindungen.
ppl6::CTCPSocket::CTCPSocket | ( | ) |
|
virtual |
int ppl6::CTCPSocket::Bind | ( | const char * | host, |
int | port | ||
) |
host
die IP-Adresse festgelegt, auf die sich der Server binden soll und mit port
der TCP-Port. Es ist nicht möglich einen Socket auf mehrere Adressen zu binden.[in] | host | IP-Adresse, Hostname, "*" oder NULL. Bei Angabe von "*" oder NULL bindet sich der Socket auf alle Interfaces des Servers. |
[in] | port | Der gewünschte TCP-Port |
int ppl6::CTCPSocket::Connect | ( | const char * | host | ) |
Mit dieser Funktion wird eine Verbindung zur angegebenen Adresse aufgebaut.
host | Der Parameter "host" muss das Format "hostname:port" haben, wobei "hostname" auch eine IP-Adresse sein kann. Der Port kann entweder als Zahl oder als Servicename angegeben werden, z.B. "smtp" für Port 25. |
int ppl6::CTCPSocket::Connect | ( | const char * | host, |
int | port | ||
) |
[in] | host | Der Hostname oder die IP-Adresse des Zielrechners |
[in] | port | Der gewünschte Zielport |
int ppl6::CTCPSocket::ConnectSSL | ( | const char * | host, |
CSSL * | ssl = NULL |
||
) |
host
aufgebaut und dann die SSL-Verschlüsselung gestartet.[in] | host | Der Parameter "host" muss das Format "hostname:port" haben, wobei "hostname" auch eine IP-Adresse sein kann. Der Port kann entweder als Zahl oder als Servicename angegeben werden, z.B. "smtp" für Port 25. |
[in] | ssl | Optionaler Pointer auf ein CSSL-Objekt. Wird es nicht angegeben, erstellt die Klasse selbst eins mit Default-Parametern. Es ist flexibler, ein eigenes Objekt zu erstellen, da man damit auch beliebige zusätzliche Zertifikate laden oder bestimmte Verschlüsselungs-Algorithmen definieren kann. |
int ppl6::CTCPSocket::ConnectSSL | ( | const char * | host, |
int | port, | ||
CSSL * | ssl = NULL |
||
) |
host
aufgebaut und dann die SSL-Verschlüsselung gestartet.[in] | host | Der Hostname oder die IP-Adresse des Zielrechners |
[in] | port | Der gewünschte Zielport |
[in] | ssl | Optionaler Pointer auf ein CSSL-Objekt. Wird es nicht angegeben, erstellt die Klasse selbst eins mit Default-Parametern. Es ist flexibler, ein eigenes Objekt zu erstellen, da man damit auch beliebige zusätzliche Zertifikate laden oder bestimmte Verschlüsselungs-Algorithmen definieren kann. |
int ppl6::CTCPSocket::Disconnect | ( | ) |
void ppl6::CTCPSocket::DispatchErrno | ( | ) |
int ppl6::CTCPSocket::GetBytesRead | ( | ) |
int ppl6::CTCPSocket::GetBytesWritten | ( | ) |
int ppl6::CTCPSocket::GetDescriptor | ( | ) |
const CString & ppl6::CTCPSocket::getHostname | ( | ) | const |
int ppl6::CTCPSocket::getPort | ( | ) | const |
|
static |
[in] | host | 32-Bit-Wert in Systemspezifischer Byte-Reihenfolge |
host
in Netzwerk-Byteorder (Big Endian) zurück
|
static |
[in] | host | 16-Bit-Wert in Systemspezifischer Byte-Reihenfolge |
host
in Netzwerk-Byteorder (Big Endian) zurück int ppl6::CTCPSocket::IsConnected | ( | ) |
int ppl6::CTCPSocket::IsListening | ( | ) |
int ppl6::CTCPSocket::IsReadable | ( | ) |
int ppl6::CTCPSocket::IsWriteable | ( | ) |
int ppl6::CTCPSocket::Listen | ( | int | timeout = 100 | ) |
timeout
Millisekunden wird jedoch geprüft, ob die Funktion sich beenden soll. Dies wird durch Aufruf der Funktion CTCPSocket::SignalStopListen oder CTCPSocket::StopListen signalisiert.[in] | timeout | Intervall in Millisekunden, nachdem geprüpft werden soll, ob weiter auf eingehende Verbindungen gewartet werden soll. Je niedriger der Wert, desto schneller wird auf einen Stop-Befehl reagiert, jedoch steigt dadurch auch die CPU-Auslastung. Der Default ist 100 Millisekunden (1000 Millisekunden = 1 Sekunde). |
|
static |
[in] | net | 32-Bit-Wert in Netzwerk-Byteorder (Big Endian) |
net
in System-spezifischer Byte-Reihenfolge zurück
|
static |
[in] | net | 16-Bit-Wert in Netzwerk-Byteorder (Big Endian) |
net
in System-spezifischer Byte-Reihenfolge zurück int ppl6::CTCPSocket::Read | ( | void * | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den von der Anwendung angegebenen Puffer buffer
. Falls der Socket auf "non-blocking" eingestellt wurde und mit CTCPSocket::WatchThread ein Überwachungsthread angegeben wurde, prüft die Funktion regelmäßig, ob ein Stop signalisiert wurde.[in] | buffer | Speicherbereich, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::Read | ( | CString & | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den Buffer des Strings buffer
ein. Falls der Socket auf "blocking" eingestellt ist (=Default), wartet die Funktion, bis die gewünschte Anzahl Bytes eingegangen ist. Ist er auf "non-blocking" eingestellt, und es wurde mit CTCPSocket::WatchThread ein Überwachungsthread angegeben, prüft die Funktion regelmäßig, ob ein Stop signalisiert wurde.[out] | buffer | String, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::Read | ( | CString * | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den Buffer des Strings buffer
ein. Falls der Socket auf "blocking" eingestellt ist (=Default), wartet die Funktion, bis die gewünschte Anzahl Bytes eingegangen ist. Ist er auf "non-blocking" eingestellt, und es wurde mit CTCPSocket::WatchThread ein Überwachungsthread angegeben, prüft die Funktion regelmäßig, ob ein Stop signalisiert wurde.[out] | buffer | String, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::Read | ( | CBinary & | buffer, |
int | bytes | ||
) |
bytes
vom Socket in das CBinary-Objekt buffer
ein. Falls der Socket auf "blocking" eingestellt ist (=Default), wartet die Funktion, bis die gewünschte Anzahl Bytes eingegangen ist. Ist er auf "non-blocking" eingestellt, und es wurde mit CTCPSocket::WatchThread ein Überwachungsthread angegeben, prüft die Funktion regelmäßig, ob ein Stop signalisiert wurde.[out] | buffer | CBinary-Objekt, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
char * ppl6::CTCPSocket::Read | ( | int | bytes | ) |
bytes
vom Socket. Falls der Socket nicht auf Non-Blocking gestellt wurde, wartet die Funktion solange, bis mindestens bytes
Bytes eingegangen sind. [in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::ReadOnce | ( | void * | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den von der Anwendung angegebenen Puffer buffer
. Falls der Socket auf "blocking" eingestellt ist (=Default) wartet die Funktion solange, bis die ersten Daten eingegangen sind und liefert diese zurück. Ist der Socket auf "non blocking" eingestellt, kehrt die Funktion sofort zurück, wenn keine Daten zur Verfügung stehen. Die Anzahl tatsächlich gelesener Bytes kann mit der Funktion CTCPSocket::GetBytesRead ausgelesen werden.[in] | buffer | Speicherbereich, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::ReadOnce | ( | CString & | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den String buffer
. Falls der Socket auf "blocking" eingestellt ist (=Default) wartet die Funktion solange, bis die ersten Daten eingegangen sind und liefert diese zurück. Ist der Socket auf "non blocking" eingestellt, kehrt die Funktion sofort zurück, wenn keine Daten zur Verfügung stehen. Die Anzahl tatsächlich gelesener Bytes kann mit der Funktion CTCPSocket::GetBytesRead ausgelesen werden.[in] | buffer | String, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
int ppl6::CTCPSocket::ReadOnce | ( | CString * | buffer, |
int | bytes | ||
) |
bytes
vom Socket in den String buffer
. Falls der Socket auf "blocking" eingestellt ist (=Default) wartet die Funktion solange, bis die ersten Daten eingegangen sind und liefert diese zurück. Ist der Socket auf "non blocking" eingestellt, kehrt die Funktion sofort zurück, wenn keine Daten zur Verfügung stehen. Die Anzahl tatsächlich gelesener Bytes kann mit der Funktion CTCPSocket::GetBytesRead ausgelesen werden.[in] | buffer | String, in dem die gelesenen Daten abgelegt werden sollen. |
[in] | bytes | Anzahl zu lesender Bytes |
char * ppl6::CTCPSocket::ReadOnce | ( | int | bytes | ) |
bytes
vom Socket und gibt einen Pointer auf den Speicherbereich zurück. Falls der Socket auf "blocking" eingestellt ist (=Default) wartet die Funktion solange, bis die ersten Daten eingegangen sind und liefert diese zurück. Ist der Socket auf "non blocking" eingestellt, kehrt die Funktion sofort zurück, wenn keine Daten zur Verfügung stehen. Die Anzahl tatsächlich gelesener Bytes kann mit der Funktion CTCPSocket::GetBytesRead ausgelesen werden. [in] | bytes | Anzahl zu lesender Bytes |
|
virtual |
[in] | socket | Pointer auf eine neue Socket-Klasse, die die eingegangene Verbindung repräsentiert. Die Anwendung muss die Klasse nach Verbindungsende selbst mit "delete" löschen. |
[in] | host | Hostname oder IP der Gegenstelle |
[in] | port | TCP-Port der Gegenstelle |
int ppl6::CTCPSocket::SetBlocking | ( | bool | value | ) |
[in] | value | Der Wert "true" setzt den Socket in den Blocking-Modus, was auch der Default ist. Durch den Wert "false" wird er in den Non-Blocking-Modus gesetzt. |
void ppl6::CTCPSocket::SetConnectTimeout | ( | int | seconds, |
int | useconds | ||
) |
[in] | seconds | Anzahl Sekunden |
[in] | useconds | Anzahl Mikrosekunden (1000 Mikrosekunden=1 Millisekunde, 1000 Millisekunden = 1 Sekunde) |
void ppl6::CTCPSocket::SetLogfile | ( | CLog * | log | ) |
[in] | log | Pointer auf eine CLog-Klasse oder NULL, um das Logging zu deaktivieren |
int ppl6::CTCPSocket::SetReadTimeout | ( | int | seconds, |
int | useconds | ||
) |
Mit dieser Funktion kann ein Timeout für Lesezugriffe gesetzt werden. Normalerweise blockiert eine Leseoperation mit "Read" solange, bis die angeforderten Daten eingegangen sind (ausser der Socket wurde mit CTCPSocket::SetBlocking auf "Non-Blocking" gesetzt). Mit dieser Funktion kann jedoch ein beliebiger mikrosekunden genauer Timeout festgelegt werden. Der Timeout errechnet sich dabei aus seconds
+ useconds
.
seconds
und useconds
aufgerufen werden.[in] | seconds | Anzahl Sekunden |
[in] | useconds | Anzahl Mikrosekunden (1000000 Mikrosekunden = 1 Sekunde) |
void ppl6::CTCPSocket::SetSource | ( | const char * | host, |
int | port = 0 |
||
) |
[in] | host | Hostname oder IP-Adresse des Quellinterfaces. Wird NULL angegeben, wird nur der port beachtet |
[in] | port | Port-Nummer des Quellinterfaces. Wird 0 angegeben, wird nur der host beachtet |
host
oder port
definiert wurden, wird die Connect-Funktion fehlschlagen!int ppl6::CTCPSocket::SetWriteTimeout | ( | int | seconds, |
int | useconds | ||
) |
Mit dieser Funktion kann ein Timeout für Schreibzugriffe gesetzt werden. Normalerweise blockiert eine Schreiboperation mit "Write" solange, bis alle Daten gesendet wurden. Mit dieser Funktion kann jedoch ein beliebiger mikrosekunden genauer Timeout festgelegt werden. Der Timeout errechnet sich dabei aus seconds
+ useconds
.
seconds
und useconds
aufgerufen werden.[in] | seconds | Anzahl Sekunden |
[in] | useconds | Anzahl Mikrosekunden (1000000 Mikrosekunden = 1 Sekunde) |
int ppl6::CTCPSocket::Shutdown | ( | ) |
int ppl6::CTCPSocket::SignalStopListen | ( | ) |
int ppl6::CTCPSocket::SSL_Accept | ( | ) |
int ppl6::CTCPSocket::SSL_CheckCertificate | ( | const char * | hostname, |
bool | AcceptSelfSignedCert = false |
||
) |
[in] | hostname | Der erwartete Name des Zertifikats. Wird NULL übergeben, wird der Name des Zertifikats nicht überprüft |
[in] | AcceptSelfSignedCert | Wird hier "true" angegeben, werden auch selbst-signierte Zertifikate akzeptiert. |
int ppl6::CTCPSocket::SSL_GetCipherBits | ( | ) | const |
CString ppl6::CTCPSocket::SSL_GetCipherName | ( | ) | const |
CString ppl6::CTCPSocket::SSL_GetCipherVersion | ( | ) | const |
void ppl6::CTCPSocket::SSL_Info | ( | ) |
int ppl6::CTCPSocket::SSL_Init | ( | CSSL * | ssl | ) |
ssl
bekommt sie einen Pointer auf eine CSSL-Klasse. Diese muss ebenfalls vor Verwendung initialisiert worden sein.[in] | ssl | Pointer auf eine CSSL-Klasse |
int ppl6::CTCPSocket::SSL_Init_Client | ( | ) |
int ppl6::CTCPSocket::SSL_Init_Server | ( | ) |
bool ppl6::CTCPSocket::SSL_IsEncrypted | ( | ) | const |
|
private |
size
verschlüsselte Bytes von der Gegenstelle in den bereits allokierten Speicherbereich buffer
und entschlüsselt sie dabei.[in] | buffer | Bereits allokierter Speicherbereich, in den die gelesenen Daten geschrieben werden sollen |
[in] | size | Anzahl zu lesender Bytes. |
int ppl6::CTCPSocket::SSL_Shutdown | ( | ) |
int ppl6::CTCPSocket::SSL_Start | ( | ) |
int ppl6::CTCPSocket::SSL_Stop | ( | ) |
int ppl6::CTCPSocket::SSL_WaitForAccept | ( | int | timeout = 0 | ) |
timeout | Ein Timeout in Sekunden. Bei Angabe von 0, wartet die Funktion unbegenzt lange. |
|
private |
size
Bytes aus dem Speicherbereich buffer
verschlüsselt an die Gegenstelle.[in] | buffer | Beginn des zu sendenden Speicherbereichs |
[in] | size | Anzahl zu sendender Bytes. |
int ppl6::CTCPSocket::StopListen | ( | ) |
int ppl6::CTCPSocket::WaitForIncomingData | ( | int | seconds, |
int | useconds | ||
) |
seconds
und useconds
angegebene Zeitspanne. Falls seconds
und useconds
Null sind, und keine Daten bereitstehen, kehrt die Funktion sofort zurück. [in] | seconds | Anzahl Sekunden, die gewartet werden soll |
[in] | useconds | Anzahl Mikrosekunden, die gewartet werden soll |
int ppl6::CTCPSocket::WaitForMessage | ( | CSocketMessage & | msg, |
int | timeout = 0 |
||
) |
Mit der Klasse ppl6::CpplSocketMessage und den Funktionen CpplSocket::Write und CpplSocket::WaitForMessage lassen sich bequem Nachrichten per TCP austauschen.
Jedes Nachrichtenpaket besteht dabei aus einem Header und den Nutzdaten.
Die CRC-Summe wird über die ersten 16 Byte des Headers gebildet (siehe ppl6::crc32). Alle mehrbyteigen Werte müssen in Network-Byte-Order (Big Endian) angegeben werden.
int ppl6::CTCPSocket::WaitForOutgoingData | ( | int | seconds, |
int | useconds | ||
) |
seconds
und useconds
angegebene Zeitspanne. Falls seconds
und useconds
Null sind, und keine Daten gesendet werden können, kehrt die Funktion sofort zurück. [in] | seconds | Anzahl Sekunden, die gewartet werden soll |
[in] | useconds | Anzahl Mikrosekunden, die gewartet werden soll |
int ppl6::CTCPSocket::WatchThread | ( | CThread * | thread | ) |
[in] | thread | Pointer auf die zu überwachende Thread-Klasse |
int ppl6::CTCPSocket::Write | ( | const CString & | str | ) |
str
an die Gegenstelle gesendet.[in] | str | Referenz auf eine CString-Klasse |
int ppl6::CTCPSocket::Write | ( | const CBinary & | bin | ) |
bin
an die Gegenstelle gesendet.[in] | bin | Referenz auf eine CBinary-Klasse |
int ppl6::CTCPSocket::Write | ( | const CString * | str | ) |
str
an die Gegenstelle gesendet.[in] | str | Pointer auf eine CString-Klasse |
int ppl6::CTCPSocket::Write | ( | const void * | buffer, |
int | bytes | ||
) |
bytes
Bytes aus dem Speicherbereich buffer
an die Gegenstelle gesendet.[in] | buffer | Pointer auf die zu sendenden Daten |
[in] | bytes | Anzahl zu sendender Bytes |
int ppl6::CTCPSocket::Write | ( | CSocketMessage & | msg | ) |
Mit der Klasse ppl6::CpplSocketMessage und den Funktionen CpplSocket::Write und CpplSocket::WaitForMessage lassen sich bequem Nachrichten per TCP austauschen.
Jedes Nachrichtenpaket besteht dabei aus einem Header und den Nutzdaten.
Die CRC-Summe wird über die ersten 16 Byte des Headers gebildet (siehe ppl6::crc32). Alle mehrbyteigen Werte müssen in Network-Byte-Order (Big Endian) angegeben werden.
int ppl6::CTCPSocket::WriteBuffer | ( | const void * | buffer, |
int | bytes | ||
) |
bytes
Bytes aus dem Speicherbereich buffer
an die Gegenstelle gesendet.[in] | buffer | Pointer auf die zu sendenden Daten |
[in] | bytes | Anzahl zu sendender Bytes |
int ppl6::CTCPSocket::Writef | ( | const char * | fmt, |
... | |||
) |
fmt
und den zusätzlichen optionalen Parametern gebildet und dieser an die Gegenstelle gesendet.[in] | fmt | Formatierungsstring |
[in] | ... | Optionale Parameter für den Formatierungsstring |
|
related |
[in] | host | Hostname oder IP des lokalen Interfaces |
[in] | port | Port auf dem lokalen Interface |
|
related |
[in] | sockfd | File-ID des Sockets |
[in] | serv_addr | IP-Adressenstruktur mit der Ziel-IP un dem Ziel-Port |
[in] | addrlen | Die Länge der Adressenstruktur |
[in] | sec | Timeout in Sekunden |
[in] | usec | Timeout in Mikrosekunden. Der tatsächliche Timeout errechnet sich aus sec + usec |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |