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

RNPacket Klassenreferenz

RNPacket sendet und empfängt Pakete. Mehr...

#include <RNPacket.h>


Öffentliche Datenelemente

 RNPacket (void)
 ~RNPacket (void)
RNPRESULT initMessageCallBack (void *pvoidUserContext, const PMESSAGECALLBACK pmcFoo)
RNPRESULT sendMessage (void *pvoidData, WORD wBufferSize)
RNPRESULT recvMessage (void)
RNPRESULT socketConnect (char *pcDestName, int iPort, int iAdressFamily=AF_INET, int iType=SOCK_STREAM, int iProtocol=IPPROTO_IP)
RNPRESULT socketAccept (RNSocket *psocketListener)
RNPRESULT socketClose (void)

Private Attribute

RNSocket m_RNSSocket
 Der Socket über den gesendet oder empfangen wird. Mehr...

bool m_bInitialized
 gibt an ob Objekt bereits initialisiert wurde. Mehr...

PMESSAGECALLBACK m_pmcCallBack
 Funktionspointer auf den Messagehandler CallBack. Mehr...

void * m_pvoidUserContext
 Der User Kontext, der bei initialize übergeben wurde. Mehr...

char m_pcBuffer [c_iMaxPacketLength]
 Buffer für teilweise empfangene Nachrichten. Mehr...

int m_iBufferUsage
 Anzahl der Bytes, die noch im Buffer sind. Mehr...

Ausführliche Beschreibung

RNPacket sendet und empfängt Pakete.

RNPacket kümmert sich darum, das beim Senden automatisch die Längeninformation dem Paket hinzugefügt wird und diese beim Empfangen wieder entfernt wird.

Beschreibung der Konstruktoren und Destruktoren

RNPacket::RNPacket (  void    ) 
 

Konstruktor 

00027 {
00028     m_bInitialized=false;
00029     m_pmcCallBack=NULL;
00030     m_pvoidUserContext=NULL;
00031 
00032     m_iBufferUsage=0;
00033 }

RNPacket::~RNPacket (  void    ) 
 

Destruktor 

00042 {
00043     socketClose();
00044 }

Dokumentation der Elementfunktionen

RNPRESULT RNPacket::initMessageCallBack (  void *    pvoidUserContext,
const PMESSAGECALLBACK    pmcFoo
) 
 

RNPRESULT RNPacket::recvMessage (  void    ) 
 

Versucht Daten vom angegebenen Socket zu empfangen, wenn ein Packet empfangen werden kann, wird dieses der MessageCallBack übergeben. 

00079 {
00080     if (m_bInitialized == false)
00081     {
00082         return RNP_ERROR_NOT_INITIALIZED;
00083     }
00084 
00085     bool bReadable;
00086 
00087     if (!m_RNSSocket.isReadable(bReadable,0))
00088     {
00089         return RNP_ERROR_SOCKET;
00090     }
00091 
00092     if (!bReadable)
00093     {
00094         return RNP_SOCKET_NOT_READABLE;
00095     }
00096 
00097     WORD wLength;
00098 
00099     if (m_iBufferUsage<c_iMaxPacketLength)
00100     {
00101         int iBytesReceived=c_iMaxPacketLength-m_iBufferUsage;
00102 
00103         if(!m_RNSSocket.receive(    m_pcBuffer+m_iBufferUsage,
00104                                     &iBytesReceived))
00105         {
00106             return RNP_SOCKET_NOT_CONNECTED;
00107         }
00108 
00109         m_iBufferUsage=+iBytesReceived;
00110 
00111         if (iBytesReceived==0)
00112         {
00113             return RNP_SOCKET_NOT_CONNECTED;
00114         }
00115     }
00116 
00117     while (true)
00118     {
00119         if (m_iBufferUsage<2)
00120         {
00121             // noch nichtmal die 2 Header Bytes sind da...
00122             return RNP_OK;
00123         }
00124         
00125         wLength=*(WORD*)m_pcBuffer;
00126         
00127         if (m_iBufferUsage<2+wLength)
00128         {
00129             // kein komplettes Paket da
00130             return RNP_OK;
00131         }
00132         
00133         // Speicher für gesamtes Paket besorgen und abholen
00134         void* pvoidData= new char[wLength];
00135         
00136         // Speicher holen fehlgeschlagen?!
00137         if (pvoidData==NULL)
00138         {
00139             return RNP_ERROR_UNDEFINED; // sollte _nie_ vorkommen
00140         }
00141         
00142         // Paket in den Speicher kopieren
00143         memcpy(pvoidData,(void*)((char*)m_pcBuffer+2),wLength);
00144         
00145         // Bufferlänge anpassem
00146         m_iBufferUsage-=(wLength+2);
00147         
00148         if (m_iBufferUsage>0)
00149         {
00150             // ein Teil des nächsten Pakets ist schon da
00151             memmove((void*)m_pcBuffer,(void*)(m_pcBuffer+(wLength+2)),m_iBufferUsage);
00152         }
00153         
00154         // den Buffer an den MessageHandler schicken
00155         RNPRESULT rnpTmp;
00156         
00157         rnpTmp=m_pmcCallBack(m_pvoidUserContext,pvoidData, wLength);
00158         
00159         if (rnpTmp == RNP_BUFFER_RETURNED)
00160         {
00161             delete pvoidData;
00162         }
00163     }
00164 
00165     //  return RNP_OK;
00166 }

RNPRESULT RNPacket::sendMessage (  void *    pvoidData,
WORD    wBufferSize
) 
 

Verschickt ein Paket mit der entsprechenden Grösse über den Socket. Wird nicht alles gesendet ist davon auszugehen, das die Verbindung unterbrochen ist, da ein Paket kaputt ist. 

00176 {
00177     if (pvoidData == NULL)
00178     {
00179         return RNP_ERROR_INVALID_PARAM;
00180     }
00181     
00182     if (wBufferSize == 0)
00183     {
00184         return RNP_ERROR_INVALID_PARAM;
00185     }
00186     
00187     if (m_bInitialized == false)
00188     {
00189         return RNP_ERROR_NOT_INITIALIZED;
00190     }
00191 
00192     bool bWriteable;
00193 
00194     if (!m_RNSSocket.isWriteable(bWriteable,0))
00195     {
00196         return RNP_ERROR_SOCKET;
00197     }
00198 
00199     if (!bWriteable)
00200     {
00201         return RNP_SOCKET_NOT_WRITEABLE;
00202     }
00203 
00204     //Packet und Längeninfo zusammenpacken
00205     int iLength=2+wBufferSize; 
00206 
00207     char* pcBuffer= new char[iLength];
00208 
00209     *((WORD*)pcBuffer)=wBufferSize;
00210 
00211     memcpy((void*)(pcBuffer+2),pvoidData,wBufferSize);
00212 
00213     if (!m_RNSSocket.send(pcBuffer, &iLength))
00214     {
00215         return RNP_ERROR_SOCKET;
00216     }
00217 
00218     return RNP_OK;
00219 }

RNPRESULT RNPacket::socketAccept (  RNSocket *    psocketListener ) 
 

Die Methode akzeptiert eine eingehende Verbinding, die am Listener registriert wird. 

00258 {
00259     if (m_bInitialized == false)
00260     {
00261         return RNP_ERROR_NOT_INITIALIZED;
00262     }
00263     
00264     bool bReadable;
00265 
00266     if(!psocketListener->isReadable(bReadable,100))
00267     {
00268         return RNP_ERROR_SOCKET;
00269     }
00270 
00271     if (!bReadable)
00272     {
00273         return RNP_SOCKET_NOT_CONNECTED;
00274     }
00275 
00276     if(!psocketListener->accept(m_RNSSocket))
00277     {
00278         return RNP_SOCKET_NOT_CONNECTED;
00279     }
00280 
00281     return RNP_OK;
00282 }

RNPRESULT RNPacket::socketClose (  void    ) 
 

Schliesst den Socket. 

00291 {
00292     if (m_bInitialized == false)
00293     {
00294         return RNP_ERROR_NOT_INITIALIZED;
00295     }
00296 
00297     if(!m_RNSSocket.close())
00298     {
00299         return RNP_ERROR_SOCKET;
00300     }
00301 
00302     return RNP_OK;
00303 }

RNPRESULT RNPacket::socketConnect (  char *    pcDestName,
int    iPort,
int    iAdressFamily = AF_INET,
int    iType = SOCK_STREAM,
int    iProtocol = IPPROTO_IP
) 
 

Versucht eine Verbindung zur angegebenen Adresse aufzubauen. 

00232 {
00233     if (m_bInitialized == false)
00234     {
00235         return RNP_ERROR_NOT_INITIALIZED;
00236     }
00237 
00238     if(!m_RNSSocket.create(iAdressFamily, iType, iProtocol))
00239     {
00240         return RNP_ERROR_SOCKET;
00241     }
00242 
00243     if(!m_RNSSocket.connect(pcDestName, iPort, iAdressFamily))
00244     {
00245         return RNP_SOCKET_NOT_CONNECTED;
00246     }
00247 
00248     return RNP_OK;
00249 }

Dokumentation der Datenelemente

bool RNPacket::m_bInitialized [private]
 

gibt an ob Objekt bereits initialisiert wurde.

int RNPacket::m_iBufferUsage [private]
 

Anzahl der Bytes, die noch im Buffer sind.

char RNPacket::m_pcBuffer[c_iMaxPacketLength] [private]
 

Buffer für teilweise empfangene Nachrichten.

PMESSAGECALLBACK RNPacket::m_pmcCallBack [private]
 

Funktionspointer auf den Messagehandler CallBack.

void* RNPacket::m_pvoidUserContext [private]
 

Der User Kontext, der bei initialize übergeben wurde.

RNSocket RNPacket::m_RNSSocket [private]
 

Der Socket über den gesendet oder empfangen wird.

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