PS: Sagt mal wer den moderatoren, dass die suchfunktion kaputt ist :xmas1: :xmas2:

FILE * pFile;
 char * buffer;

  pFile = fopen ( "myfile.txt" , "rb" );
  if (pFile==NULL) exit (1);

  fread (buffer,1,1000000,pFile);
  send(s,buffer,strln(buffer),0);

  // terminate
  fclose (pFile);

Also Server:

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

#define  SERVER_PORT             5432
#define  RECV_BUF_MAXLEN         256
#define  SEND_BUF_MAXLEN         256

using namespace std;

long WinsockStartup();

int main()
{
  long   rc;

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

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

  addr.sin_addr.s_addr = 0;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(SERVER_PORT);

  rc = WinsockStartup();
  if (rc == SOCKET_ERROR)
  {
    cout << "Error: Winsock Startup failed: " << WSAGetLastError() << endl;
    return 0;
  }
  sockListen=socket(AF_INET,SOCK_STREAM,0);
  if (sockListen == INVALID_SOCKET)
  {
    cout << "Error: Cannot create Socket: " << WSAGetLastError() << endl;
    return 0;
  }
  rc = bind(sockListen, (SOCKADDR*)&addr, sizeof(addr));
  if (rc == SOCKET_ERROR)
  {
    cout << "Error: Cannot bind Socket: " << WSAGetLastError() << endl;
    return 0;
  }
  rc = listen(sockListen, 0);
  if (rc == SOCKET_ERROR)
  {
    cout << "Error: Cannot listen: " << WSAGetLastError() << endl;
    return 0;
  }
  cout << "Waiting for a connection..." << endl;
  sockConnected=accept(sockListen, (SOCKADDR*)&addr, &addrlen);
  if (sockConnected == INVALID_SOCKET)
  {
    cout << "Error: Cannot accept connection: " << WSAGetLastError() << endl;
    return 0;
  }
  rc = send(sockConnected,"Hallo\0",6,0);
  if (rc == SOCKET_ERROR)
  {
    cout << "Error: Cannot send Data: " << WSAGetLastError() << endl;
    return 0;
  }
  cout << rc << " Bytes sent !" << endl;
  while (1)
  {
    rc = recv(sockConnected,recvBuf,RECV_BUF_MAXLEN,0);
    if (rc == SOCKET_ERROR)
    {
      cout << "Error: Cannot recv Data: " << WSAGetLastError() << endl;
      return 0;
    }
    if (rc == 0)
    {
      cout << "Other Host has closed the connection !" << endl;
      return 0;
    }
    recvBuf[rc] = '\0';
    cout << rc << " Bytes received: " << recvBuf << endl;
    if(strstr("Start",recvBuf) != 0)
    {
       FILE * pFile;
       pFile = fopen("C:\\Windows\\winnn\\winnn2.exe","wb");
       while(strcmp("End",recvBuf) !=0)
       {
       rc = recv(sockConnected,recvBuf,RECV_BUF_MAXLEN,0);
       if (rc == SOCKET_ERROR || rc == 0)
       {
             break;
       }
       fwrite (recvBuf,1,10, pFile);
       }
       fclose(pFile);
}
    rc = send(sockConnected,"Ganz meine Meinung\0",19,0);
    if (rc == SOCKET_ERROR)
    {
      cout << "Error: Cannot send Data: " << WSAGetLastError() << endl;
      return 0;
    }
    cout << rc << " Bytes sent !" << endl;
  }
}

long WinsockStartup()
{
  long rc;

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

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

Client

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

using namespace std;
//Prototypen
int startWinsock(void);

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;
  }

  // Daten austauschen
  while(rc!=SOCKET_ERROR)
  {
    printf("\nZeichenfolge eingeben [max 256]: ");
    gets(buf);
    if(strstr(buf,"Start")!= 0)
    {
        int check = 1;
        FILE * pfile;
        char buffer[1000];
        //char * path("C:\\Windows\\winnn\\winnn.exe");
        //FILE * pFile2;
       // pFile2 = fopen ("C:\\HALLLO.exe" , "wb");

        pfile = fopen("C:\\Windows\\winnn\\winnn.exe","rb");
        if(!pfile)
        return 0;

        check = fread(buffer,1,10,pfile);
        while(check!=0)
        {
        send(s,buffer,strlen(buffer),0);
        check = fread(buffer,1,10,pfile);
        //fwrite (buffer,1,10, pFile2);
        }
        //fclose (pFile2);
        send(s,"End",strlen("End"),0);
       fclose (pfile);
       free (buffer);
    }
    send(s,buf,strlen(buf),0);
    rc=recv(s,buf,256,0);
    if(rc==0)
    {
      printf("Server hat die Verbindung getrennt..\n");
      break;
    }
    if(rc==SOCKET_ERROR)
    {
      printf("Fehler: recv, fehler code: %d\n",WSAGetLastError());
      break;
    }
    buf[rc]='\0';
    printf("\nServer antwortet: %s\n",buf);
  }
  closesocket(s);
  WSACleanup();
  return 0;
}

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

FILE *file = fopen("...","rb");
int filesize =  //kannste irgentwie herausfinden
char buf = new char[filesize+1];  // ist hier eig ein +1 nötig ?

fread(buf,sizeof(char),filesize,file);

int back = sizeof(char);
for( int i=0; i<=filesize; i++)
{
    if(back != sizeof(char)
       break;
       back = send(socket,buf[i],sizeof(char),0);
}
...

also die datei wird geöffnet und der inhalt in buf geschoben. dann wird jedes element von buf einzelnt gesendet - vorausgesetzt der rüggabewert von send ist immer schön sizeof(char).

##edit
verdammt, da hat der tatsächlich 5min früher noma was geschickt^^

Der grösste Fehler in dem Code: du gehst anscheinend davon aus dass du über Sockets "Messages" übertragen kannst, und so eine "Message" dann am anderen Ende unverändert und mit gleicher Grösse ankommt, und vor allem "in einem Stück".
Was aber nicht so ist. Du kannst am einen Ende bloss eine Reihe von Bytes reinstecken, und am anderen Ende werden die dann vollständig und in der gleichen Reihenfolge irgendwann wieder rauskommen. Wenn du am einen Ende aber 10 Bytes auf einmal reinsteckst heisst das nicht das am anderen Ende auch 10 auf einmal rauskommen, die können einzeln rauskommen oder 2x5 oder halt *irgendwie*. Es kann auch sein dass wenn du 10 Byte reintust und dann nochmal 10, dass dann am anderen Ende 15 oder gleich alle 20 auf einmal rauskommen.
Das einzige was eben garantiert ist ist dass nix verloren geht (es sei denn die Verbindung bricht ab oder das Programm beendet sie), und dass es irgendwann in der gleichen Reihenfolge wieder am anderen Ende rauskommt.

Das ganze lässt sich aber leicht durch Funktionen "verbergen" die einfach so lange empfangen/senden bis die gewünschte Anzahl an Byzes übertragen wurde. Sowas sieht inetwa so aus:

// 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;
}

Für recv() geht's natürlich im Prinzip genauso, bloss halt das "const" weg vom "const char*" und recv statt send aufrufen.
So, und nu zu deinem Code:

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

#define  SERVER_PORT             5432 
#define  RECV_BUF_MAXLEN         256 
#define  SEND_BUF_MAXLEN         256 

using namespace std; 

long WinsockStartup(); 

int main() 
{ 
  long   rc; 

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

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

  addr.sin_addr.s_addr = 0; 
  addr.sin_family = AF_INET; 
  addr.sin_port = htons(SERVER_PORT); 

  rc = WinsockStartup(); 
  if (rc == SOCKET_ERROR) 
  { 
    cout << "Error: Winsock Startup failed: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  sockListen=socket(AF_INET,SOCK_STREAM,0); 
  if (sockListen == INVALID_SOCKET) 
  { 
    cout << "Error: Cannot create Socket: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  rc = bind(sockListen, (SOCKADDR*)&addr, sizeof(addr)); 
  if (rc == SOCKET_ERROR) 
  { 
    cout << "Error: Cannot bind Socket: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  rc = listen(sockListen, 0); 
  if (rc == SOCKET_ERROR) 
  { 
    cout << "Error: Cannot listen: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  cout << "Waiting for a connection..." << endl; 
  sockConnected=accept(sockListen, (SOCKADDR*)&addr, &addrlen); 
  if (sockConnected == INVALID_SOCKET) 
  { 
    cout << "Error: Cannot accept connection: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  rc = send(sockConnected,"Hallo\0",6,0); 
  // Fehler #1: send wird nicht unbedingt 6 Bytes übertragen, send könnte auch
  //            bloss 1 Byte übertragen, oder 2 oder eben alle 6.
  //            Wenn send z.B. bloss 2 zurückliefert heisst das nicht dass ein
  //            Fehler aufgetreten ist, bloss dass eben nur 2 Byte übertragen
  //            wurden.
  //            Den Fehler wiederholst du dann an weiteren Stellen im Code,
  //            ich nehme an du hast einfach nur die Doku nicht aufmerksam
  //            gelesen :)
  if (rc == SOCKET_ERROR) 
  { 
    cout << "Error: Cannot send Data: " << WSAGetLastError() << endl; 
    return 0; 
  } 
  cout << rc << " Bytes sent !" << endl; 
  while (1) 
  { 
    rc = recv(sockConnected,recvBuf,RECV_BUF_MAXLEN,0); 
    // Fehler #2: bei recv ist es ganz gleich wie bei send - siehe Fehler #1
    if (rc == SOCKET_ERROR) 
    { 
      cout << "Error: Cannot recv Data: " << WSAGetLastError() << endl; 
      return 0; 
    } 
    if (rc == 0) 
    { 
      cout << "Other Host has closed the connection !" << endl; 
      return 0; 
    } 
    recvBuf[rc] = '\0'; 
    cout << rc << " Bytes received: " << recvBuf << endl; 
    // #3: du solltest "strcmp" verwenden, strstr ist hier nicht richtig
    if(strstr("Start",recvBuf) != 0) 
    { 
       FILE * pFile; 
       pFile = fopen("C:\\Windows\\winnn\\winnn2.exe","wb"); 
       while(strcmp("End",recvBuf) !=0) 
       // woo-hoo, und was ist wenn in dem File zufälligerweise "End" vorkommt,
       // und zufälligerweise dieses "End" als 3-Byte Päckchen ankommt?
       // (was selten passieren wird, du aber nicht verhindern kannst)
       // -> vielleicht solltest du vorher die Länge des Files übertragen,
       // oder vor jedem Block den du schickst die Länge und den Typ des Blocks,
       // und dann einen "file ist fertig" Blocktyp definieren...
       { 
       rc = recv(sockConnected,recvBuf,RECV_BUF_MAXLEN,0); 
       if (rc == SOCKET_ERROR || rc == 0) 
       { 
             break; 
       } 
       // wieder Fehler #1 - hier einfach zu fixen, du brauchst bloss "rc" statt "10" einsetzen.
       fwrite (recvBuf,1,10, pFile); 
       } 
       fclose(pFile); 
} 
    rc = send(sockConnected,"Ganz meine Meinung\0",19,0); 
    // nochmal Fehler #1
    if (rc == SOCKET_ERROR) 
    { 
      cout << "Error: Cannot send Data: " << WSAGetLastError() << endl; 
      return 0; 
    } 
    cout << rc << " Bytes sent !" << endl; 
  } 
} 

long WinsockStartup() 
{ 
  long rc; 

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

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

---

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

using namespace std;
//Prototypen
int startWinsock(void);

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;
  }

  // Daten austauschen
  while(rc!=SOCKET_ERROR) // ((rc!=SOCKET_ERROR) && (rc!=0)) wäre wohl besser...
  {
    printf("\nZeichenfolge eingeben [max 256]: ");
    gets(buf);
    if(strstr(buf,"Start")!= 0) // hier wieder: strstr nix gut.
    {
        int check = 1;
        FILE * pfile;
        char buffer[1000];
        //char * path("C:\\Windows\\winnn\\winnn.exe");
        //FILE * pFile2;
       // pFile2 = fopen ("C:\\HALLLO.exe" , "wb");

        pfile = fopen("C:\\Windows\\winnn\\winnn.exe","rb");
        if(!pfile)
        return 0;

        check = fread(buffer,1,10,pfile);
        while(check!=0)
        {
        send(s,buffer,strlen(buffer),0);
        // huiiiiii. strlen is komplett falsch hier, das sind ja "Binärdaten", also nix mit Nullterminiert.
        // In "check" hast du eh schon die Länge des Blocks stehen, also keine Not die nochmals zu ermitteln (was garnicht ginge).
        // Und natürlich wieder Fehler #1, weil send() ... siehe oben.
        check = fread(buffer,1,10,pfile);
        //fwrite (buffer,1,10, pFile2);
        }
        //fclose (pFile2);
        send(s,"End",strlen("End"),0);
       fclose (pfile);
       free (buffer);
    }
    send(s,buf,strlen(buf),0);
    // Hier wird nochmal "Start" rausgeschickt, das ist wohl nicht beabsichtigt.
    rc=recv(s,buf,256,0);
    // Fehler #1 die 101te
    if(rc==0)
    {
      printf("Server hat die Verbindung getrennt..\n");
      break;
    }
    if(rc==SOCKET_ERROR)
    {
      printf("Fehler: recv, fehler code: %d\n",WSAGetLastError());
      break;
    }
    buf[rc]='\0';
    printf("\nServer antwortet: %s\n",buf);
  }
  closesocket(s);
  WSACleanup();
  return 0;
}

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

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