3. socket: binare datei senden - beschleunigen

socket: binare datei senden - beschleunigen

  • B

    hmm nehmen wir mal an die datei ist größer als 1024 😃

    also wenn cih zum senden dies hier benutze:

    send(s, buf, in_file.gcount());

    kommt ein fehler beim kompilieren:

    Borland C++ 5.5.1 for Win32 Copyright (c) 1993, 2000 Borland
tc.cpp:
Error E2193 tc.cpp 93: Too few parameters in call to '__stdcall send(unsigned in
t,const char *,int,int)' in function main()
*** 1 errors in Compile ***

    und wie müsste ich es dann mit recv annehmen?
    bei recv(sock,buf,1024,0); kann es ja sein das weniger als 1024 kommen,
    wie müsste ich das denn dann machen?

    0
  • ?

    du hast da einen parameter vergessen, deshalb hast du einen error
    schau dir mal das an:

    send:

    int send (  SOCKET s, const char FAR * buf, int len, int flags );

    -s: Socket über den wir die Daten senden wollen
    -buf: Pointer auf einen Buffer in dem die zu sendenden Daten enthalten sind
    -len: Wieviele Bytes von buf gesendet werden sollen
    -flags: Brauchen wir nicht

    Rückgabewert: Anzahl der gesendeten Bytes oder SOCKET_ERROR bei einem Fehler.

    recv:

    int recv (  SOCKET s, char FAR* buf, int len, int flags );

    -s: Socket über den wir Daten empfangen wollen
    -buf: Pointer zu einem Buffer in dem die empfangenen Daten gespeichert werden sollen
    -len: Grösse des Buffers (oder wieviele Daten im Buffer gespeichert werden sollen)
    -flags: benötigen wir nicht

    Rückgabewert: Anzahl der empfangenen Bytes, 0 falls die Verbindung vom Partner getrennt wurde oder SOCKET_ERROR bei einem Fehler.

    0
  • ?
     

    long rc;

rc=recv(s,buf,1024,0);

    Hier werden maximal 1024 Zeichen empfangen, es können auch weniger empfangen werden, bei recv dient der dritte Parameter nur dazu die grösse des Buffers im zweiten Parameter anzugeben. Wieviele Zeichen wirklich empfangen wurden sieht man im Rückgabewert (in diesem Falle rc)!!

    also dann schaust du einfach: wie viele zeichen sind in rc, würd ich mal sagn!!
    oder was meint ihr?

    cu

    0
  • B

    wow 🙂 ok also bis jetzt klappt alles super!

    aber was muss ich noch tun wenn die datei die gesendet werden soll
    kleiner als 1024b ist? wenn ich so (nicht binar) eine txt-datei
    mit dem inhalt "hallo dies ist ein test" versenden will, steht
    nacher das hier drin:

    hallo dies ist ein test û Æ2@ @û *{ Xû '·@ ôtA ìú     *{ Xû     ¼wA °þ ù¦@ ¨0{ ¨0{ °þ *{ 46@ *{ |û ­H@ ÀtA X){ œ({ ÌtA µ7@ ÌtA     ˜û '·@ œwA @û  ü ô2@  ü ¨û '·@ ütA pû     û *{         Ìû Æ2@  ü *{ 8ü '·@ >èw¸  
   Ðû pèw¸  ø«A     çÝ0     “      ÿÿÿÿÿÿÿ       ,   <1{ ü  (@ ,   ø«A $ü <1{ ø«A hü šý@ §A     0   X){ <1{ _é@    ,1{     ¨0{ ­A ý '·@ $bA <ü        È){     xü ÉA  { X){ (ý Ù¡@    X){ ¨0{ ¨0{ ,   <1{ ¤ü  (@ ,   ø«A Äü <1{ ø«A ý šý@ §A     0   ,1{ <1{ _é@ &1{ ¨0{  ý     LC_M ý øü ´&@ ,1{ ý Ñ@ ,1{ ý 4@ ,1{ ý D@ ,1{ ,ý ?¢@ ,1{ [   ¨ý È–@  ý    ¨0{ ¨†A °þ     7  ÆŒw    Z   z   lý @    Ìý '·@  ‹A <ý    |({ °þzZ    '·@ ÀŠA xý X){ „ý    ,1{ øý  ¬@ ¨0{ °þ °þ ¨0{ |({ (þ     (þ '·@ T‘A ¸ý         8      øý y3@     Xþ Ù«@ °þ ¨0{ ¨†A <þ Vg@ |({ Pþ '·@ āA þ    '·@ ‘A     °þ lþ Vg@ |({ €þ '·@ āA Hþ    |({        àþ @    ½A ¼þ '·@ ôaA pþ     |({        ¨þ ÜQ@ ¨0{ äþ ¸Q@ àþ     ‹A ½A ÿ '·@ zA

    ich schreibe mit "out_file.write(buf,sizeof(buf));" wieder in die datei,
    habs mit out_file.write(buf,rc); versucht, beim binaren senden einer mp3
    klappt es, aber bei unbinaren senden der txt steht nacher nichts in der txt!

    0
  • B

    hmm ok, ich würde dann überprüfen ob die datei kleiner als 1024
    ist, und wenn dann würde ich buf so groß machen wie die datei ist.

    wenn ich die dateigröße in der int x gespeichert habe wie kann
    ich buf dann als größe x übergeben?

    int x=28;
char buf[x];

    klappt leider nciht 😕

    0
  • ?

    senden:

    ich würds so machen:

    [/cpp]
    char buf[1024];

    ifstream in_file("c:\\lol.mp3", ios::in | ios::binary);

    while(!in_file.eof())
    {
    in_file.read(buf, sizeof(buf));
    send(sock, buf, stream.gcount(), 0); // Mit infile.gcount() bekommt man raus, wieviel gelesen wurde zb.: kleiner als 1024, dieser parameter sagt ja wieviel zeichen vom buffer gesendet werden sollen!!!
    }

    in_file.close();
    [cpp]

    poste dann mal den fertigen code für senden u empfangen...

    cu

    0
  • B

    hmm ok - darf recv denn dann trotzdem so aussehen:

    rc=recv(connectedSocket,buf,1024,0);

    und auf 1024 warten?

    dann schreibe ich es mit

    out_file.write(buf,sizeof(buf));

    wieder in die datei

    mit

    send(s, buf, in_file.gcount(),0);

    sende ich

    und mit

    in_file.read(buf, sizeof(buf));

    lese ich aus der datei.

    aber es wird trotzdem mehr in die datei geschrieben als in_file.gcount()

    p.s: also in_file.gcount() ist in meinem fall genau 28, wenn ich aber

    in_file.read(buf, 28);

    anstatt

    in_file.read(buf, sizeof(buf));

    benutze ist die neue txt datei lehr 😕

    0
  • ?

    i würd das so machen in etwa...
    is so ein grobentwurf....bitte @all um comments!!!

    cu

    typedef struct NETFILEHEADER
{
    unsigned long FileSize;
    char pFileName[256];
};

//////////////// Senden ///////////////////////

char buf[1024]; 

// du solltest zuerst die dateigrösse zum client schicken...
// am besten du machst eine structur aus dateinamen und dateigrösse und schickst das zum client!

// Dateigrösse bestimmen:
NETFILEHEADER FileHeader;
in_file.seekg (0, ios::end);
FileSize = in_file.tellg();
in_file.seekg (0, ios::beg);

// NetfileHeader setzten
FileHeader.FileSize = FileSize;

// Dateinamen bestimmen u dann in structur....musst selber probieren
// dann den Fileheader zuerst an den client senden...u dann die datei...

// Datei senden
while(FileSize >= 1024)
{
  in_file.read(buf, sizeof(buf));
  send(sock, buf, stream.gcount(), 0);   
  FileSize -= 1024;
}

// Ist Filesize kleiner als 1024
if(FileSize)
{
  in_file.read(buf, FileSize);
  send(sock, buffer, stream.gcount(), 0);
}

/////////////// Empfangen /////////////////////

NETFILEHEADER FileHeader;
char *FileHeader1 = new(char[sizeof(Netfileheader)];
unsigned long AlreadyReceived = 0 
unsigned long rc = 0;
long FileSize;

//Fileheader empfangen....
do 
{ 
   rc = recv(client, Fileheader1, sizeof(NETFILEHEADER), 0); 
   AlreadyReceived += rc; 
   memcopy(FileHeader1, Netfileheader, rc);

}while(AlreadyReceived<sizeof(NETFILEHEADER));

FileSize = FileHeader.FileSize;

// Dann öffnest du die datei 
ofstream out_file (FileHeader.pFileName,ofstream::binary);

// In Datei schreiben
while(FileSize > 0)
{
   rc = recv(client, buffer, 1024, 0);
   out_file.write(buf,sizeof(buf));

   FileSize -= rc;
}

//Datei schließen usw....
    0
  • ?

    was sagst dazu?

    0
  • ?

    ich würd sagen ein kriterium ist auch noch das maximum segment size! -> so gross sollte dann das paket sein das gesendet wird....
    bei dsl liegt der glaubi zwischen 1430 - 1450!!
    stimmt das??

    mfg surf

    0
  • ?

    Was spricht eigentlich dagegen das Paket so groß wie die Datei zu machen und einfach alles auf einmal zu senden. Oder ist die Paketgröße begrenzt?

    0
  • C

    @surf: Ja, da dieser Wert der systemgegebene Maximalwert ist, wäre es damit wohl optimal, denke ich.

    @Gast: Was ist bei ner 2-GB-Datei? 😉 Der Sendepuffer hat halt auch nur ne bestimmte Größe.

    0
  • ?

    Passt sich der Puffer nicht an?
    Wenn nicht, gibts keine Funktion mit der man die Größe rausbekommt und
    dann nimmt man einfach die.

    0
  • B

    Cocaine schrieb:

    @surf: Ja, da dieser Wert der systemgegebene Maximalwert ist, wäre es damit wohl optimal, denke ich.

    1. fuer ISDN, Kabelmodem usw. aber nicht
    2. von diser Segmentgroesse muss immer noch das abgezogen werden, das TCP/IP (und PPP gar auch noch? 😕 ) an Headern fuer sich selbst verbraet!

    0
  • V

    Cocaine schrieb:

    @surf: Ja, da dieser Wert der systemgegebene Maximalwert ist, wäre es damit wohl optimal, denke ich.

    @Gast: Was ist bei ner 2-GB-Datei? 😉 Der Sendepuffer hat halt auch nur ne bestimmte Größe.

    Vor allem muss die Datei erst einmal gelesen werden.

    mfg
    v R

    0
  • B

    sorry ich war im urlaub 😕 deswegen rufe ich diesen post
    erst jetzt nochmal auf...

    also ich habe noch folgendes problem. so "kopiere" ich die datei:

    #include <iostream> 
#include <string> 
#include <fstream> 

using namespace std; 

int main() 
{ 

char buf[1024]; 

  ifstream in_file("c:\\lol.mp3", ios::in | ios::binary);
  ofstream out_file("c:\\lol2.mp3", ios::out | ios::binary); 
  while(!in_file.eof()) 
  { 
in_file.read(buf, sizeof(buf));
out_file.write(buf, in_file.gcount());  
  }
in_file.close();
out_file.close();
}

    mit

    send(s, buf, in_file.gcount(),0);

    sende ich dann das ausgelesene rüber und mit

    rc=recv(connectedSocket,buf,1024,0);
    if(rc==0)
    {
     exit(1);
    }
    if(rc==SOCKET_ERROR)
    {
     exit(1);
    }
    buf[rc]='\0';

    empfange ich es. dann schreibe ich es wieder mit

    out_file.write(buf, rc);

    in eine date. nun ist die neu erstellte datei wenn ich es nicht über sockets
    mache sondern nur mit dem beispiel oben genauso groß wie das original (1.313).
    wenn ich es aber so über sockets mache und wieder reinschreibe nur (1.312) - die mp3 läuft aber trotzdem.

    ist das schlimm und woran kann das liegen?

    0
  • N

    Verzeih mir meine Frage, aber warum nutzt du kein MSG_PEEK?

    0
  • B

    was würde MSG_PEEK denn genau machen wenn ich es mit recv benutzen
    würde?

    bei google habe ich leider nichts gefunden!

    0
  • N

    Value Meaning
    MSG_PEEK Peek at the incoming data. The data is copied into the buffer but is not removed from the input queue. The function then returns the number of bytes currently pending to receive.

    0
  • ?

    hi!
    kennst jemand bei mirc die einstellung: packet size beim senden einer datei?

    cu

    0
Anmelden zum Antworten