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

Sender.cpp

gehe zur Dokumentation dieser Datei
00001 /***********************************************************************************/
00002 /** \file               Sender.cpp
00003 **  \brief              Implementation zur Klasse Sender
00004 *************************************************************************************
00005 **  Autor:              Christian Roesch
00006 **
00007 **  Erstelldatum:       04.04.2002
00008 **  letzte Aenderung:   04.04.2002
00009 *************************************************************************************
00010 **  Diese Klasse ist für das Zerschneiden und Verschicken der Nachrichten zuständig.
00011 ************************************************************************************/
00012 
00013 
00014 // includes
00015 #include "Sender.h"
00016 
00017 // Methoden-Definitionen
00018 
00019 /************************************************************************************
00020 **  Methode:            Sender::Sender
00021 ************************************************************************************/
00022 /** Konstruktor, hinterlegt den Port
00023 ************************************************************************************/
00024 Sender::Sender( int iPort)
00025 {
00026     m_iPort=iPort;
00027 }
00028 
00029 /************************************************************************************
00030 **  Methode:            Sender::run
00031 ************************************************************************************/
00032 /** Fragt den Users nach einer IP, baut eine Verbindung auf. Der User kann nun
00033 *** Textfiles verschicken.
00034 ************************************************************************************/
00035 void Sender::run(void)
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 leere 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 }
00218 
00219 /************************************************************************************
00220 **  Methode:            Sender::StaticMessageHandler
00221 ************************************************************************************/
00222 /** Ruft den eigentlichen (nicht static definierten) MessageHandler auf.
00223 ***
00224 ************************************************************************************/
00225 RNPRESULT Sender::StaticMessageHandler(     void* pvoidUserContext, 
00226                                             void* pvoidPacket, 
00227                                             WORD wSize)
00228 {
00229     Sender* pThisObject = (Sender*) pvoidUserContext;
00230 
00231     return pThisObject->MessageHandler(pvoidPacket,wSize);
00232 }
00233 
00234 /************************************************************************************
00235 **  Methode:            Sender::MessageHandler
00236 ************************************************************************************/
00237 /** Empfängt und verarbeitet die Nachrichten. Dafür wird zunächst der Nachrichtentyp
00238 *** anhand von MessageGeneric::m_Type erkannt, und dann der void* entsprechend
00239 *** gecasted.
00240 ************************************************************************************/
00241 RNPRESULT Sender::MessageHandler(void* pvoidPacket, WORD wSize)
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 }
00253 
00254 /************************************************************************************
00255 **  Ende der Datei:     Sender.cpp
00256 ************************************************************************************/

Erzeugt am Thu Apr 4 17:13:57 2002 für Rechnernetze-Aufgabe1 von doxygen1.2.13.1 geschrieben von Dimitri van Heesch, © 1997-2001