SOCKETS: Datei versenden über TCP

hustbaer

Wenns mit strcmp nicht geht dann steht eben nicht genau "Start" drinnen...

twitch

aber eigentlich hätte er doch genau das schicken sollen, oder etwa nicht?? beim ausgeben steht ja auch genau das drinne

CStoll

Vielleicht steht da ja auch "Start " in dem empfangenen String drin (Leerzeichen fallen bei der Ausgabe nicht besonders auf ;)).

twitch

könnt sein aber das ganze funktioniert irgendwie auch so nicht der will einfach nicht in die datei schreiben

twitch

Hallo mal wieder ich habe das ganze nun nach langer Zeit gelöst und wollte hier jetzt nur nochmal den Quellcode reinsetzen, falls wer das selbe Problem hat.

Client:

#include <windows.h>
#include <winsock2.h>
#include <stdio.h>
#include <iostream>
#include <fstream>

#define DMEGABYTE       2000000

using namespace std;
//Prototypen
int startWinsock(void);
int send_block(SOCKET s, const char* data, int size);
int recv_block(SOCKET s,char* data, int size);

int main()
{
  long rc;
  SOCKET s;
  SOCKADDR_IN addr;
  char buf[256];

  // Winsock starten
  rc=startWinsock();
  if(rc!=0)
  {
    printf("Fehler: startWinsock, fehler code: %d\n",rc);
    return 1;
  }

  // Socket erstellen
  s=socket(AF_INET,SOCK_STREAM,0);
  if(s==INVALID_SOCKET)
  {
    printf("Fehler: Der Socket konnte nicht erstellt werden, fehler code: %d\n",WSAGetLastError());
    return 1;
  }

  // Verbinden
  memset(&addr,0,sizeof(SOCKADDR_IN)); // zuerst alles auf 0 setzten
  addr.sin_family=AF_INET;
  addr.sin_port=htons(5432); // wir verwenden mal port 12345
  addr.sin_addr.s_addr=inet_addr("127.0.0.1");

  rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR));
  if(rc==SOCKET_ERROR)
  {
    printf("Fehler: connect gescheitert, fehler code: %d\n",WSAGetLastError());
    return 1;
  }

        fstream file("C:\\winnn.exe",fstream::in | fstream::out | fstream::binary);

        file.seekg(0,fstream::end); //Pointer auf das Dateiende setzen

        unsigned long int length = file.tellg(); //Auslesen wie weit Pointer vom Anfang weg ist
        unsigned long int remaining = 0;

        file.seekg(0); //Pointer wieder auf Anfang setzen wichtig!

        char scan[256];
        sprintf(scan,"%u",length);
        send(s,scan,strlen(scan),0);
        recv(s,buf,256,0);
        cout<<"Rueckerstattung empfangen!"<<scan<<" ---- "<<length<<endl;
        if(length >= DMEGABYTE)
        {
        char buffer[DMEGABYTE];
        for(unsigned long int i = 0;i<length;i=i+DMEGABYTE)
        {
                       file.seekg(i);
                       remaining = length - i;
                       if(remaining >= DMEGABYTE) 
                       {
                           char * buffer = new char[DMEGABYTE];
                           file.read(buffer,DMEGABYTE);
                           send_block(s,buffer,DMEGABYTE);
                           cout << "2MB Durchlauf" << endl;
                           delete buffer;
                           rc = recv(s, buf, 256, 0);
                       }
                       else
                       {
                           char * remain = new char[remaining];
                           file.read(remain,remaining);
                           send_block(s,remain,remaining);
                           cout << "Abschluss" << endl;
                           delete remain;
                       }
        }
        }
        else
        {
                      char buffer[length];
                      file.read(buffer,length);
                      send_block(s,buffer,length);
                      free (buffer);
        }
        cout<<"Senden Fertig!"<<endl;

        file.close();     

  closesocket(s);
  WSACleanup();
  system("PAUSE");
  return 0;
}

int startWinsock(void)
{
  WSADATA wsa;
  return WSAStartup(MAKEWORD(2,0),&wsa);
}

// für blocking stream sockets
int send_block(SOCKET s, const char* data, int size)
{
    if(size == 0)
        return 0;
    if(size < 0)
        return SOCKET_ERROR;

    int remaining = size;
    while(remaining > 0)
    {
        int rc = send(s, data, remaining, 0);
        assert(rc != 0); // rc == 0 sollte mit blocking stream sockets niemals vorkommen
        if((rc == 0) || (rc == SOCKET_ERROR))
            return SOCKET_ERROR;
        if(rc > remaining)
        {
            // huh???
            return SOCKET_ERROR;
        }
        data += rc;
        remaining -= rc;
    }
    return size;
}

int recv_block(SOCKET s,char* data, int size)
{
    if(size == 0)
        return 0;
    if(size < 0)
        return SOCKET_ERROR;

    int remaining = size;
    while(remaining > 0)
    {
        int rc = recv(s, data, remaining, 0);
        assert(rc != 0); // rc == 0 sollte mit blocking stream sockets niemals vorkommen
        if((rc == 0) || (rc == SOCKET_ERROR))
            return SOCKET_ERROR;
        if(rc > remaining)
        {
            // huh???
            return SOCKET_ERROR;
        }
        data += rc;
        remaining -= rc;
    }
    return size;
}

Der Server:

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <windows.h>
#include <winsock2.h>

#define  SERVER_PORT             5432
#define  RECV_BUF_MAXLEN         256
#define  SEND_BUF_MAXLEN         256
#define  DMEGABYTE               2000000

using namespace std;

long WinsockStartup();
int send_block(SOCKET s, const char* data, int size);
int recv_block(SOCKET s,char* data, int size);

int main()
{
  long   rc;

  SOCKET sockListen;
  SOCKET sockConnected;
  SOCKADDR_IN addr;
  int addrlen = sizeof(addr);

  char sendBuf[SEND_BUF_MAXLEN+1];
  char recvBuf[256+1];

  addr.sin_addr.s_addr = 0;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(SERVER_PORT);  // TCP-PORT!

    rc = WinsockStartup();
    sockListen=socket(AF_INET,SOCK_STREAM,0);
    rc = bind(sockListen, (SOCKADDR*)&addr, sizeof(addr));
    rc = listen(sockListen, 0);
    cout << "Waiting for a connection..." << endl;
    sockConnected=accept(sockListen, (SOCKADDR*)&addr, &addrlen);

    fstream file("C:\\Programme\\CopyWinnn3.exe",fstream::in | fstream::out | fstream::binary | fstream::trunc);
    rc = recv(sockConnected,recvBuf,256,0);
    recvBuf[rc] = '\0';

    unsigned long length = 0;
    unsigned long remaining = 0;
    sscanf(recvBuf,"%u",&length);

    cout<<length<<endl;
    send(sockConnected,"Moin",4,0);
    if(length >= DMEGABYTE)
        {
        char buffer[DMEGABYTE];
        for(unsigned long int i = 0;i<length;i=i+DMEGABYTE)
        {
                       file.seekg(i);
                       remaining = length - i;
                       if(remaining >= DMEGABYTE) 
                       {
                           char * buffer = new char[DMEGABYTE];                        
                           recv_block(sockConnected,buffer,DMEGABYTE);
                           file.write(buffer,DMEGABYTE);
                           cout << "2MB Durchlauf" << endl;
                           delete buffer;
                           send(sockConnected,"weiter",6,0);
                       }
                       else
                       {
                           char * remain = new char[remaining];                   
                           recv_block(sockConnected,remain,remaining);
                           file.write(remain,remaining);
                           cout << "Abschluss" << endl;
                           delete remain;
                       }
        }
        }
        else
        {
                      char buffer[length];
                      rc = recv_block(sockConnected,buffer,length);
                      file.write(buffer,length);
                      free (buffer);
        }

    file.close();
    cout<<"Fertig gesandt!"<<endl;
    system("PAUSE");
    return 0;
}

long WinsockStartup()
{
  long rc;

  WORD wVersionRequested;
  WSADATA wsaData;
  wVersionRequested = MAKEWORD(2, 1);

  rc = WSAStartup( wVersionRequested, &wsaData );
  return rc;
}

int send_block(SOCKET s, const char* data, int size)
{
    if(size == 0)
        return 0;
    if(size < 0)
        return SOCKET_ERROR;

    int remaining = size;
    while(remaining > 0)
    {
        int rc = send(s, data, remaining, 0);
        assert(rc != 0); // rc == 0 sollte mit blocking stream sockets niemals vorkommen
        if((rc == 0) || (rc == SOCKET_ERROR))
            return SOCKET_ERROR;
        if(rc > remaining)
        {
            // huh???
            return SOCKET_ERROR;
        }
        data += rc;
        remaining -= rc;
    }
    return size;
}

int recv_block(SOCKET s,char* data, int size)
{
    if(size == 0)
        return 0;
    if(size < 0)
        return SOCKET_ERROR;

    int remaining = size;
    while(remaining > 0)
    {
        int rc = recv(s, data, remaining, 0);
        //assert(rc != 0); // rc == 0 sollte mit blocking stream sockets niemals vorkommen
        if((rc == 0) || (rc == SOCKET_ERROR))
            return SOCKET_ERROR;
        if(rc > remaining)
        {
            // huh???
            return SOCKET_ERROR;
        }
        data += rc;
        remaining -= rc;
        cout<<"Size: "<<strlen(data)<<endl;
    }
    return size;
}

Viel Spaß damit

Da muss aber noch einiges verbessert werden!

z.B. ? Es funktioniert so wunderbar

Fehlerbehandlung? :p

twitch

Ich wollte ja nur mal zeigen wie es geht die Fehlerbehandlung kann man dann ja immer noch hinzufügen

Ceos

was für ne fehlerbehandlung ?
meinste ne fehlerkorrektur oder was?
das programm läuft doch nur solange kein error kommt und den rest machen die sockets