Hauptseite   Klassenhierarchie   Datenstrukturen   Auflistung der Dateien   Datenstruktur-Elemente   Datei-Elemente  

RNSocket Klassenreferenz

Kapsel für WinSock. Mehr...

#include <RNSocket.h>


Öffentliche Datenelemente

 RNSocket (void)
 ~RNSocket (void)
bool create (int iAdressFamily=AF_INET, int iType=SOCK_STREAM, int iProtocol=IPPROTO_IP)
bool close (void)
bool shutdown (int iFlags)
bool connect (char *pcDestName, int iPort, int iAddressFamily=AF_INET)
bool bind (char *pcDestName, int iPort)
bool listen (int iBackLog=SOMAXCONN)
bool accept (RNSocket &socketNew)
bool receive (void *pvoidData, int *piLength, int iFlags=0)
bool send (void *pvoidData, int *piLength, int iFlags=0)
bool isReadable (bool &bReadable, int iMilliSeconds)
bool isWriteable (bool &bWriteable, int iMilliSeconds)

Öffentliche, statische Datenelemente

bool init (int iMajorVersion=1, int iMinorVersion=1)
bool cleanUp (void)

Private Attribute

SOCKET m_Socket
 Socket - Handle. Mehr...

sockaddr_in m_addrLocal
 Adresse dieses Sockets. Mehr...

sockaddr_in m_addrTarget
 Adresse des Ziel-Sockets. Mehr...


Statische private Attribute

WSAData m_wsaData
 Socket Version. Mehr...

bool m_bSocketInitialized = false
 gibt an, um WinSockets initialisiert sind. Mehr...


Ausführliche Beschreibung

Kapsel für WinSock.

Die Klasse RNSocket beitet eine Klasse zur Kapselung von WinSock. Sie enthält Methoden um Verbindungen herzustellen und Daten zu senden und zu empfangen. Die Klasse gibt jeweils bool Werte zurück, die den Erfolg der Methoden angeben. Bei einem false ist die Methode gescheitert, und der entsprechende Fehlercode kann über WSAGetLastError ausgelesen werden.


Beschreibung der Konstruktoren und Destruktoren

RNSocket::RNSocket void   
 

Konstruktor

00028 {
00029     m_Socket                = INVALID_SOCKET;
00030 
00031     ZeroMemory(&m_addrLocal, sizeof(m_addrLocal));
00032     ZeroMemory(&m_addrTarget, sizeof(m_addrTarget));
00033 }

RNSocket::~RNSocket void   
 

Destruktor

00041 {
00042     close();
00043 }


Dokumentation der Elementfunktionen

bool RNSocket::accept RNSocket &    socketNew
 

Akzeptiert eine Verbindung, ab sofort können über den neuen Socket Daten ausgetauscht werden.

00277 {
00278     int iAddrTargetLength = sizeof(socketNew.m_addrTarget);
00279 
00280     // anfragende Verbindung akzeptieren
00281     socketNew.m_Socket = ::accept(  m_Socket, 
00282                                     (struct sockaddr*) &socketNew.m_addrTarget, 
00283                                     &iAddrTargetLength);
00284 
00285     if(socketNew.m_Socket == INVALID_SOCKET)
00286     {
00287         return false;
00288     }
00289 
00290     return true;
00291 }

bool RNSocket::bind char *    pcDestName,
int    iPort
 

Bindet den Socket an den angegebenem Namen (IP) und Port.

00222 {
00223     int iResult;
00224 
00225     // Spezification unseres Socket bestimmen
00226     if(pcDestName == NULL)
00227     {
00228         m_addrLocal.sin_addr.s_addr = htonl(INADDR_ANY);
00229     }
00230     else
00231     {
00232         m_addrLocal.sin_addr.s_addr = inet_addr(pcDestName);
00233     }
00234 
00235     m_addrLocal.sin_port = htons((WORD)iPort);
00236 
00237 
00238     iResult = ::bind(   m_Socket, 
00239                         (struct sockaddr*) &m_addrLocal, 
00240                         sizeof(m_addrLocal));
00241     
00242     if(iResult == SOCKET_ERROR)
00243     {
00244         return false;
00245     }
00246 
00247     return true;
00248 }

bool RNSocket::cleanUp void    [static]
 

Entlädt die Winsock dll mit Hilfe von WSACleanup.

00085 {
00086     HRESULT hResult;
00087 
00088     // sind die Sockets ueberhaupt noch initialisiert ?!
00089     if(!m_bSocketInitialized)
00090     {
00091         return false;
00092     }
00093 
00094     hResult = WSACleanup();
00095 
00096     if (hResult == SOCKET_ERROR)
00097     {
00098         return false;
00099     }
00100 
00101     m_bSocketInitialized = false;
00102 
00103     // erfolgreich aufgeräumt!
00104     return true;
00105 }

bool RNSocket::close void   
 

Schliesst den Socket.

00155 {
00156     int iResult;
00157 
00158     iResult = closesocket(m_Socket);
00159 
00160     if(iResult == SOCKET_ERROR)
00161     {
00162         return false;
00163     }
00164 
00165     m_Socket=INVALID_SOCKET;
00166 
00167     return true;
00168 }

bool RNSocket::connect char *    pcDestName,
int    iPort,
int    iAddressFamily = AF_INET
 

Öffnet eine Verbindung zur angegebenen IP-Adresse und Port.

00195 {
00196     int iResult;
00197 
00198     // Ziel bestimmen
00199     m_addrTarget.sin_family     = iAddressFamily;
00200     m_addrTarget.sin_port           = htons((WORD)iPort);
00201     m_addrTarget.sin_addr.s_addr    = inet_addr(pcDestName);
00202         
00203     // und verbinden
00204     iResult = ::connect(m_Socket, 
00205                         (struct sockaddr *) &m_addrTarget,
00206                         sizeof(m_addrTarget));
00207 
00208     if (iResult == SOCKET_ERROR)
00209     {
00210         return false;
00211     }
00212 
00213     return true;
00214 }

bool RNSocket::create int    iAdressFamily = AF_INET,
int    iType = SOCK_STREAM,
int    iProtocol = IPPROTO_IP
 

Erstellt den Socket mit den entsprechenden Parametern.

00115 {
00116     if (m_Socket != INVALID_SOCKET)
00117     {
00118         close();
00119     }
00120         
00121     m_Socket = socket(  iAdressFamily,
00122                         iType,
00123                         iProtocol);
00124 
00125     if (m_Socket == INVALID_SOCKET)
00126     {
00127         return false;
00128     }
00129 
00130     //wird später für bind gebraucht
00131     m_addrLocal.sin_family=iAdressFamily;
00132 
00133     
00134     BOOL bYes=TRUE;
00135 
00136     if ( setsockopt(    m_Socket, 
00137                         SOL_SOCKET, 
00138                         SO_REUSEADDR, 
00139                         (char*)&bYes, 
00140                         sizeof(bYes)) == SOCKET_ERROR) 
00141     {
00142         return false;
00143     }
00144     
00145 
00146     return true;
00147 }

bool RNSocket::init int    iMajorVersion = 1,
int    iMinorVersion = 1
[static]
 

Initialisiert die Sockets mit der angegebenen Vesion. (Lädt die Windows dll)

00051 {
00052     //Version erzeugen
00053     WORD wVersionReg = MAKEWORD((WORD)iMajorVersion, (WORD)iMinorVersion);
00054 
00055     if(m_bSocketInitialized)
00056     {
00057         // schon initialisiert? 
00058         return false;
00059     }
00060 
00061     if (WSAStartup(wVersionReg, &m_wsaData) != 0)
00062     {
00063         m_bSocketInitialized=false;
00064         return false;
00065     }
00066 
00067     if (    LOBYTE( m_wsaData.wVersion ) != iMajorVersion ||
00068             HIBYTE( m_wsaData.wVersion ) != iMinorVersion )
00069     {
00070         WSACleanup();
00071         m_bSocketInitialized=false;
00072         return false; 
00073     }
00074  
00075     m_bSocketInitialized=true;
00076     return true;
00077 }

bool RNSocket::isReadable bool &    bReadable,
int    iMilliSeconds
 

Überprüft ob der Socket "readable" ist.

00353 {
00354     int iResult;
00355 
00356     fd_set fdSet;
00357     
00358     FD_ZERO(&fdSet);
00359     FD_SET(m_Socket, &fdSet);
00360 
00361     timeval tvTimeOut;
00362 
00363     tvTimeOut.tv_sec=iMilliSeconds/1000;
00364     tvTimeOut.tv_usec=(iMilliSeconds%1000)*1000;
00365 
00366     iResult = ::select(0, &fdSet, NULL, NULL, &tvTimeOut);
00367 
00368     // Fehler
00369     if(iResult == SOCKET_ERROR)
00370     {
00371         // konnte status nicht ermitteln
00372         bReadable = false;
00373 
00374         return false;
00375     }
00376     
00377     // Timeout
00378     if(iResult == 0)
00379     {
00380         bReadable = false;
00381         
00382         return true;
00383     }
00384 
00385     // hat geklappt - der socket ist in lesbarem zustand
00386     bReadable = true;
00387 
00388     return true;    
00389 }

bool RNSocket::isWriteable bool &    bWriteable,
int    iMilliSeconds
 

Überprüft ob der Socket "writeable" ist.

00398 {
00399     int iResult;
00400 
00401     fd_set fdSet;
00402     
00403     FD_ZERO(&fdSet);
00404     FD_SET(m_Socket, &fdSet);
00405 
00406     timeval tvTimeOut;
00407 
00408     tvTimeOut.tv_sec=iMilliSeconds/1000;
00409     tvTimeOut.tv_sec=(iMilliSeconds%1000)*1000;
00410 
00411     iResult = ::select(0, NULL, &fdSet, NULL, &tvTimeOut);
00412 
00413     // Fehler
00414     if(iResult == SOCKET_ERROR)
00415     {
00416         // konnte status nicht ermitteln        
00417         bWriteable = false;
00418 
00419         return false;
00420     }
00421     
00422     // Timeout
00423     if(iResult == 0)
00424     {
00425         bWriteable = false;
00426 
00427         return true;
00428     }
00429 
00430     // hat geklappt - der socket ist in schreibbarem zustand
00431     bWriteable = true;
00432 
00433     return true;
00434 }

bool RNSocket::listen int    iBackLog = SOMAXCONN
 

Veranlasst das Lauschen an einem Socket, der vorher ge"bind"et wurde. iBackLog gibt an wie Connection Requests gequeued werden.

00257 {
00258     int iResult;
00259 
00260     iResult = ::listen(m_Socket, iBackLog);
00261 
00262     if( iResult == SOCKET_ERROR)
00263     {
00264         return false;
00265     }
00266 
00267     return true;
00268 }

bool RNSocket::receive void *    pvoidData,
int *    piLength,
int    iFlags = 0
 

Empfängt Daten auf dem Socket, es werden maximal piLength Daten empfangen. Sind es weniger, wird piLength entsprechend verändert.

00300 {
00301     int iDataReceived;
00302 
00303     iDataReceived=recv(m_Socket, (char*)pvoidData, *piLength, iFlags);
00304 
00305     if (iDataReceived==SOCKET_ERROR)
00306         return false;
00307 
00308     *piLength=iDataReceived;
00309 
00310     return true;
00311 }

bool RNSocket::send void *    pvoidData,
int *    piLength,
int    iFlags = 0
 

Sendet die Daten aus dem Buffer. Es wird versucht alle Daten zu senden, und nur bei einem Fehler wird abgebrochen.

00320 {
00321     int iSendTotal = 0; // how many bytes we’ve sent
00322     int iBytesLeft = *piLength; // how many we have left to send
00323     int iBytesSend;
00324 
00325     while (iSendTotal < *piLength)
00326     {
00327         iBytesSend = ::send(m_Socket, 
00328                             ((char*)(pvoidData))+iSendTotal, 
00329                             iBytesLeft, 
00330                             iFlags);
00331         if (iBytesSend == SOCKET_ERROR )
00332         {
00333             *piLength = iSendTotal;
00334             return false;
00335         }
00336 
00337         iSendTotal += iBytesSend;
00338         iBytesLeft -= iBytesSend;
00339     }
00340 
00341     *piLength = iSendTotal;
00342 
00343     return true;
00344 }

bool RNSocket::shutdown int    iFlags
 

Ruft shutdown() für den Socket mit den gewünschten Parametern auf.

00176 {
00177     int iResult;
00178 
00179     iResult = ::shutdown(m_Socket, iFlags);
00180     
00181     if(iResult == SOCKET_ERROR)
00182     {
00183         return false;
00184     }
00185 
00186     return true;
00187 }


Dokumentation der Datenelemente

sockaddr_in RNSocket::m_addrLocal [private]
 

Adresse dieses Sockets.

sockaddr_in RNSocket::m_addrTarget [private]
 

Adresse des Ziel-Sockets.

bool RNSocket::m_bSocketInitialized = false [static, private]
 

gibt an, um WinSockets initialisiert sind.

SOCKET RNSocket::m_Socket [private]
 

Socket - Handle.

WSADATA RNSocket::m_wsaData [static, private]
 

Socket Version.


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien:
Erzeugt am Thu Apr 4 19:23:31 2002 für Rechnernetze-Aufgabe1 von doxygen1.2.13.1 geschrieben von Dimitri van Heesch, © 1997-2001