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

Sender Klassenreferenz

Sender zerlegt und verschickt Textfiles. Mehr...

#include <Sender.h>


Öffentliche Datenelemente

 Sender (int iPort)
void run (void)

Private Datenelemente

RNPRESULT MessageHandler (void *pvoidPacket, WORD wSize)

Private, statische Datenelemente

RNPRESULT StaticMessageHandler (void *pvoidUserContext, void *pvoidPacket, WORD wSize)

Private Attribute

int m_iPort
 Port, das für die Verbindung genutzt wird. Mehr...


Ausführliche Beschreibung

Sender zerlegt und verschickt Textfiles.

Sender verbindet sich zu einer IP und schickt dann ein (zerstückeltes) Textfile an den Receiver.


Beschreibung der Konstruktoren und Destruktoren

Sender::Sender int    iPort
 

Konstruktor, hinterlegt den Port

00025 {
00026     m_iPort=iPort;
00027 }


Dokumentation der Elementfunktionen

RNPRESULT Sender::MessageHandler void *    pvoidPacket,
WORD    wSize
[private]
 

Empfängt und verarbeitet die Nachrichten. Dafür wird zunächst der Nachrichtentyp anhand von MessageGeneric::m_Type erkannt, und dann der void* entsprechend gecasted.

00242 {
00243     MessageGeneric* pmsgTmp= (MessageGeneric*)pvoidPacket;
00244 /*
00245     switch (pmsgTmp->m_Type)
00246     {
00247     default:
00248         return RNP_BUFFER_RETURNED;
00249     }
00250 */
00251     return RNP_BUFFER_RETURNED;
00252 }

void Sender::run void   
 

Fragt den Users nach einer IP und baut eine Verbindung auf. Der User kann nun Textfiles verschicken.

00036 {
00037     RNPRESULT rnprTmp;
00038     char pcEingabe[1024];
00039 
00040     // IP erfragen
00041     printf("IP >");
00042     gets(pcEingabe);
00043 
00044     // RNPacket initialisieren
00045     RNPacket rnpSend;
00046 
00047     if(rnpSend.initMessageCallBack(this,StaticMessageHandler) == RNP_OK)
00048     {
00049         printf("MessageHandler inited.\n");
00050     }
00051     else
00052     {
00053         return;
00054     }
00055 
00056     // Verbindung aufbauen
00057     printf("Trying to connect...");
00058     
00059     do
00060     {
00061         rnprTmp=rnpSend.socketConnect(pcEingabe,m_iPort);
00062         
00063         if (kbhit())
00064         {
00065             printf("\nUser aborted.\n");
00066             getch();
00067             return;
00068         }
00069         
00070         Sleep(100);
00071         printf(".");
00072     } while (rnprTmp == RNP_SOCKET_NOT_CONNECTED);
00073     
00074     printf("\n");
00075 
00076     // Testen ob Verbindung erfolgreich
00077     if (rnprTmp != RNP_OK)
00078     {
00079         printf("Error occured.\n");
00080         return;
00081     }
00082     
00083     printf("Connected to %s.\n",pcEingabe);
00084 
00085     DWORD dwPacketNr=0;
00086     int iCharCount;
00087 
00088     // In Schleife nach Filenamen fragen
00089     while(true)
00090     {
00091         printf("File >");
00092 
00093         gets(pcEingabe);
00094 
00095         // Bei leerer Eingabe beenden
00096         if (pcEingabe[0]==0)
00097         {
00098             break;
00099         }
00100 
00101         // File öffnen
00102         FILE* pfileIn=fopen(pcEingabe,"r");
00103         iCharCount=0;
00104 
00105         // Erfolgreich geöffnet ?
00106         if (pfileIn==NULL)
00107         {
00108             printf("File does not exist! Sending input itself.\n");
00109         }
00110         else
00111         {
00112             printf("Sending file...\n");
00113         }
00114 
00115         // Packet erstellen
00116         MessageCharFragment msgcfTmp;
00117         msgcfTmp.m_Type=MSGID_CHARFRAGMENT;
00118         msgcfTmp.m_dwNextPacketNr=c_dwFirstCharFragment;
00119 
00120         int iBuf;
00121 
00122         // Packete in einer Schleife erstellen
00123         do 
00124         {
00125             // dieses Packet bekommt Nummer, die das Vorhergehende als Nachfolger hatte (klar, oder? ;)
00126             msgcfTmp.m_dwPacketNr=msgcfTmp.m_dwNextPacketNr;
00127 
00128             int iCount;
00129 
00130             // Charbuffer lesen aus File oder Eingabe
00131             for (iCount=0; iCount<c_dwSizeCharFragment; iCount++)
00132             {
00133                 if (pfileIn!=NULL)
00134                 {
00135                     iBuf=fgetc(pfileIn);
00136                 }
00137                 else
00138                 {
00139                     iBuf=pcEingabe[iCharCount];
00140 
00141                     if (iBuf==0)
00142                     {
00143                         iBuf=EOF;
00144                     }
00145                     else
00146                     {
00147                         iCharCount++;
00148                     }
00149                 }
00150                 
00151                 msgcfTmp.m_cBuffer[iCount]=(char)iBuf;
00152 
00153                 // am Ende nur noch Nullen anhängen
00154                 if (iBuf==EOF)
00155                 {
00156                     msgcfTmp.m_cBuffer[iCount]=0;
00157                 }
00158             }
00159 
00160             // Packetnummer weiterzählen
00161             if (iBuf==EOF)
00162             {
00163                 msgcfTmp.m_dwNextPacketNr=c_dwLastCharFragment;
00164             }
00165             else
00166             {
00167                 msgcfTmp.m_dwNextPacketNr=dwPacketNr;
00168                 dwPacketNr++;
00169             }
00170 
00171             // Senden, falls möglich
00172             do
00173             {
00174                 rnprTmp=rnpSend.sendMessage((void*)&msgcfTmp,sizeof(msgcfTmp));
00175 
00176                 // bei Tastedruck abbrechen
00177                 if (kbhit())
00178                 {
00179                     break;
00180                 }
00181 
00182             } while (rnprTmp==RNP_SOCKET_NOT_WRITEABLE);
00183             
00184             //Verbindungsabbruch
00185             if (rnprTmp != RNP_OK)
00186             {
00187                 printf("Connection closed...\n");
00188                 return;
00189             }
00190 
00191             //User hat gedrückt
00192             if (kbhit())
00193             {
00194                 printf("\nUser aborted.\n");
00195                 getch();
00196                 return;
00197             }           
00198 
00199         } while (iBuf!=EOF);
00200 
00201         // Alle Pakete erfolgreich versendet! (evtl. File schliessen)
00202         printf("All Packets send.\n");
00203         if (pfileIn != NULL)
00204             fclose(pfileIn);
00205     }
00206     
00207     // Socket schliessen
00208     if(rnpSend.socketClose() == RNP_OK)
00209     {
00210         printf("Socket closed.\n");
00211     }
00212     else
00213     {
00214         printf("Error occured while closing Socket.\n");
00215     }
00216     
00217 }

RNPRESULT Sender::StaticMessageHandler void *    pvoidUserContext,
void *    pvoidPacket,
WORD    wSize
[static, private]
 

Ruft den eigentlichen (nicht static definierten) MessageHandler auf.

00228 {
00229     Sender* pThisObject = (Sender*) pvoidUserContext;
00230 
00231     return pThisObject->MessageHandler(pvoidPacket,wSize);
00232 }


Dokumentation der Datenelemente

int Sender::m_iPort [private]
 

Port, das für die Verbindung genutzt wird.


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