int Filesize;
rc = recv(cs,buf,11,0);
if(buf[0]=='2' && buf[1]=='.' &&  buf[2]=='3' || buf[2]=='4')
{

		buf[0]='0';

			rc = send(cs,buf,10,0);
			return 0;
}
else
{
buf[0]=1;
rc = send(cs,buf,3,0);

rc = recv(cs,buf,11,0);
if(buf[0]=1)
{
	Filesize=sizeof(update);
	 buf[0]=Filesize;

	rc = send(cs,buf,200,0);
	char buf2[sizeof(update)];
	update.get(buf2,sizeof(update));
	rc = recv(cs,buf,200,0);
	cout<<buf<<"\n\n";

	cin.get();
	Sleep(2000);
	while(Filesize>0)
	{
		rc = send(cs,buf2,sizeof(update),0);
	Filesize=Filesize-1;
	}
	update.close();

}
else
{
}

Client:

//darüber version überprüfung
else if (test[0]='1')
{
	buf[0]='1';
		rc = send(s,buf,10,0);

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

	Filesize=(int) buf;

char *buf2;
buf2=new char(100000);

cout<<"Warte auf daten!\n\n";
 rc = send(s,buf2,20,0);

 int fz=Filesize;
 cout<<"Zu übertragende Bytes: "<<fz<<"\n";

while(deux>0)
{
    cout<<"\rÜbertragen: "<<Filesize;
	rc = recv( s, buf2, fz, 0 );

Filesize=Filesize-1;
}
update << buf2;
cout<<"\n\nFertig\n";
cin.get();

delete buf2;
update.close();
}

Ich will ein Textfile kopieren.Zuerst lese ich mit dem Server
die grösse aus sende diese dem Client.
danach wird beim senden die grösse immer um eins verringert.
Eigentlich steht in der Datei nur ein "hallo wie gehts?".
Irgend wie sendet der Server nicht und irgendwie empfängt
der client was aber irgendwie nicht weil im Textfile vom
Client nichts steht.Das schließe ich daraus das er Filesize rechnet
obwohl der server nichts tut.Weil eigentlich
hält das programm bei send oder recv bis es ausgeführt wurde an.
Beim Clienten ist es nicht so.Un beim Server stimmt
es irgendwie auch nicht.Ich sende ja die File größe an den Clienten der
hat dann die zahl 2292240(halt die grösse).Beim server aber ist sie
nur *mal* 510 oder 540 usw groß es ändert sich immer.
Und wenn der Client runter gezählt hat und aus ist da
hat er plötzlich gerechnet und hat am ende 100.
Was mach ich falsch?

char *buf2;
buf2=new char(1024);//ist das in den() bit,byte..?

So eine Frage neben bei weil ich ja das ganz selber machen will also nichst
von irgendjemand rauskopieren schauen was passiert...Jetzt meine Frage ich
lesen mit GetFileSize die größe aus in ein DWORD.Datei=10.8 MB groß reicht
DWORD?Und wenn ja Wie kriege ich diese werte in ein char um diese
per send zu senden und in einen intiger um mein char die richtige größe
reservieren kann.
Und das hier weiß hab ich leider vergessen:

char *buf2;
buf2=new char(1024);//ist das in den() bit,byte..?

char  cBufToSend[1024];
HANDLE hFile;
DWORD dwFileSize;

hFile = GreateFile( bla, bla bla, sorry bin zu faul);

dwFileSize = GetFileSize(hFile, 0);

_snprintf(cBufToSend, sizeof(cBufToSend), "%d", dwFileSize);

send( sock, cBufToSend, lstrlen(cBufToSend), 0);

Server empfängt String und prepariert es:

DWORD dwFileSize;
recv( sock, cBufToRecv, sizeof(cBufToRecv), 0);

dwFileSize = atof(cBufToRecv);

so hätte ich es gemacht,

danach kannst du die Datei Byteweise in cBufToSend einlesen mod:"rb" (bis EOF erkannt wird) und per Socket versenden.
Der Server empfängt dann den Buffer und schreibt es in vorher mit CreateFile erstellte Datei rein.

Also du muss ein Protokol entwickeln:
z.B.

char buf[1024];
dann sieht der Transfer so aus
->[ part1$$$FileSize$$$FileName.exe$$00000000 binäre data 0000000000000\] ->\[ part2$$000000000000000000 binäre data 00000000000000000000000000000]
...
->[ partX$$000000000000000000 binäre data 0000000000000000$$EndOfFile]

wobei $$$ ein Trenner ist.

Dein Empfänger muss dann solange die Daten empfangen und in Datei schreiben bis er im String EndOfFile findet. Hoffe du verstehst mich, mein Deutsch ist noch zimlich schlecht

Stefan311 schrieb:

char *buf2;
buf2=new char(1024);//ist das in den() bit,byte..?

Na was denkst du was das "char" wohl ist??? Bit??? Byte??? oder DWORD???
Dein Pointer(buf2) zeigt nun auf ein 1024 BYTES große Bereich im Speicher

im moment hab ich das so:

while(FileSize>0)
{
cout<<"\rÜbertragen: "<<FileSize;
rc = send();
FileSize=FileSize - rc;
}

Ist das so richtig?
Ps:Hab gerade festgestellt das die datei die der Client speichert größer ist
als die Ausgangsdatei. Was ist falsch?

Also ich stünde auch vor langer Zeit vor dem Problem ein Datei über Winsock zu versenden und ich habe es so gemacht:

Beachte dass das ein einfacher Beispiel ist und evtl. noch verbessert werden kann

//Sender (Client) Diese Teil versendet ein Datei
#include <stdio.h>
#include <winsock2.h>

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

int main(void)
{
	SOCKET s;
	SOCKADDR_IN addr;
	FILE *file;
	char buf[1024];
	int num;

	char ip[]    = "127.0.0.1";	// Ziel-IP
	int port     = 123;		// Port
	char datei[] = "C:\\file.exe";// Datei zum versenden

	printf("\n");

//-----------------------------------------------------------
	// Winsock initialisieren 	 
	if( startWinsock() != 0 )
	{
		printf("Fehler: Winsock kann nicht initialisiert werden\n\n");
		return 1; 
	}

//-----------------------------------------------------------------
	// Socket erstellen 
	s = socket(AF_INET,SOCK_STREAM,0);
	if( s == INVALID_SOCKET )
	{
		printf("Fehler: Socket kann nicht erstellt werden\n\n");
		return 1; 
	}

//-----------------------------------------------------------
	// Verbinden mit Zielhost 
	memset(&addr, 0, sizeof(SOCKADDR_IN));	 
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);			
	addr.sin_addr.s_addr = inet_addr(ip);	

	if( connect(s, (SOCKADDR*)&addr, sizeof(SOCKADDR)) == SOCKET_ERROR )
	{
		printf("Fehler: Verbindung mit %s kann nicht hergestellt werden\n\n", ip);
		return 1; 
	}
	printf("Verbunden mit %s\n", ip);

------------------------------------------------------------------
	// Datei versenden 
	if( (file = fopen(datei, "rb")) == NULL )
	{
		printf("Fehler: Datei %s kann nicht geoffnet werden\n\n", datei);
		return 1; 
	}

	printf("Sende Datei... ");
	while( !feof(file) )
	{
		num = 0;
		num = fread(buf, sizeof(char), sizeof(buf), file);
		num = send(s, buf, num, 0);
		if( num == SOCKET_ERROR )
		{
			printf("\nFehler: Fehler beim senden aufgetreten\n\n");
			return 1; 
		}
		printf(".");  
	}
	printf("\nDatei erfolgreich versendet!\n\n");

	fclose(file);
	closesocket(s);
	WSACleanup();

	return 0;
}

//Empfänger (Server) empfängt ein Datei	
#include <stdio.h>
#include <winsock2.h>

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

int main(int argc, int *argv[])
{
	SOCKET acceptSocket, s;
	SOCKADDR_IN addr;
	FILE *file;
	char buf[1024];
	int num;

	char datei[] = "C:\\newfile.exe";			// Datei path
	int port = 123;							// Port

	printf("\n");

//-----------------------------------------------------------
	// Winsock initialisieren 
	if( startWinsock() != 0 )
	{
		printf("Fehler: Winsock kann nicht initialisiert werden\n\n");
		return 1; 
	}

//-----------------------------------------------------------------
	// Socket erstellen 
	acceptSocket = socket(AF_INET,SOCK_STREAM,0);
	if(acceptSocket == INVALID_SOCKET)
	{
		printf("Fehler: Socket kann nicht erstellt werden\n\n");
		return 1; 
	}

//--------------------------------------------------------
	// Socket an das Port binden 
	memset(&addr,0,sizeof(SOCKADDR_IN));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = ADDR_ANY;

	if( bind(acceptSocket, (SOCKADDR*)&addr, sizeof(SOCKADDR_IN)) == SOCKET_ERROR )
	{ 
		printf("Fehler: Socket kann an das port nicht gebunden werden\n\n");
		return 1;
	}

//------------------------------------------------------------
	// Auf Verbindung warten 
	if( listen(acceptSocket,10) == SOCKET_ERROR )
	{
		printf("Fehler: listen()\n\n");
		return 1; 
	}
	printf("Warte auf Verbindung...\n");

//-----------------------------------------------------------
	// Verbindung akzeptieren 
	s = accept(acceptSocket,NULL,NULL);
	if(s == INVALID_SOCKET)
	{
		printf("Fehler: accept()\n\n");
		return 1;
	}
	printf("Verbindung akzeptiert\n");

//------------------------------------------------------------------
	// Datei empfangen 
	if( (file = fopen(datei, "wb")) == NULL )
	{
		printf("Datei %s koennte zum schreiben nicht geoffnet werden\n\n", datei);
		return 1; 
	}
	printf("Datei %s zum schreiben geoffnet\n", datei);

	printf("\nEmpfange Datei...\nBitte warten... ");
	while( (num = recv(s, buf, sizeof(buf), 0)) > 0 )
	{
		fwrite(buf, sizeof(char), num, file);
		printf("."); 
	}
	printf("\nDatei empfangen!\n\n");
	fclose(file);
	closesocket(s);
	WSACleanup();
	return 0;
}

Wie du das mit dem FileName etc hinkriegst siehe oben

Übrigens, ein 10 MB grosse Datei zu versenden wird schon eine gewiesse Zeit in Anspruch nehmen, auch bei DSL.

Versuch es erst mit kleineren Dateien, wenn du sicher bist, dass alles 100% funktioniert dann kannst du es auch an deinem 10 MB Datei ausüben.

Vieleicht machst du was falsch?
Sender erwartet eine "file.exe" Datei auf Laufwerk C:\ zum versenden.
Emfänger schreibt dann emfangene Datei in C:\newfile.exe.

Warum es bei dir nicht geht weiss ich nicht, aber ich vermutte das du eine
Konsolenanwendung versendet hast, und die startet mann auch normalerweise
aus Konsole/Eingabeaufforderung aus. Am sonsten passiert das wovon du erzählt
hast --> "Flimmert kurz auf und sofort wieder aus".

Grüß

nun in der Konsole öffne steht da Programm zu groß für arbeitsspeicher.
Das komische die datei beim server kann ich noch starten(Bei mir ist Server Sender
und Client empfänger) nur die gedownloadete datei will nicht.Lieder hingegen
klappen.

Vergleiche mal die Größen von beiden Dateien...
Da leuft was schief bei dir, ich kann hier nur eins sagen:
Poste mal den Code dann sehen wir was du falsch machst

Bei mir ist Server Sender
und Client empfänger)

Im Grunde ist es egal nachdem Verbindung aufgebaut ist

#include <windows.h> 
#include <process.h>
#include <winsock2.h> 
#include <iostream>
#include <stdio.h> 
#include <stdlib.h>
#include <conio.h>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
using namespace std;
void warte(void *ch);
int startWinsock(void); 
int a=0;
int i;
int b=0;

int end=0;
 long rc;
 SOCKET cs; 
 char ausgabe1[300];
int main() 
{ 

char test[300];

  SOCKET acceptSocket; 
FILE *file; 
    char buf[1024]; 
    int num; 
  SOCKADDR_IN addr; 

  // Winsock starten 
char datei[] = "update/upms.exe";
  rc=startWinsock(); 

  if(rc!=0) 

  { 

    printf("Fehler: startWinsock, fehler code: %d\n",rc); 

    return 1; 

  } 

  else 

  { 

    printf("Winsock gestartet!\n"); 

  } 

  // Socket erstellen 

  acceptSocket=socket(AF_INET,SOCK_STREAM,0); 

  if(acceptSocket==INVALID_SOCKET) 

  { 

    printf("Fehler: Der Socket konnte nicht erstellt werden, fehler code: %d\n",WSAGetLastError()); 

    return 1; 

  } 

  else 

  { 

    printf("Socket erstellt!\n"); 

  } 

	a=1;
memset(&addr,0,sizeof(SOCKADDR_IN)); 

addr.sin_family=AF_INET; 

addr.sin_port=htons(81); 

addr.sin_addr.s_addr=ADDR_ANY; 

rc=bind(acceptSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR_IN)); 
listen:
if(rc==SOCKET_ERROR) 

{ 

  printf("Fehler: bind, fehler code: %d\n",WSAGetLastError()); 

  return 1; 

} 

else 

{ 

  printf("Socket an port 81 gebunden\n"); 

} 

rc=listen(acceptSocket,10); 

if(rc==SOCKET_ERROR) 

{ 

  printf("Fehler: listen, fehler code: %d\n",WSAGetLastError()); 

  return 1; 

} 

else 

{ 

  printf("acceptSocket ist im listen Modus....\n");  

} 

cs=accept(acceptSocket,NULL,NULL);

if(cs==INVALID_SOCKET) 

{ 
b=1;
  printf("Fehler: accept, fehler code: %d\n",WSAGetLastError()); 

  return 1; 

} 

else 

{ 

  printf("Neue Verbindung wurde akzeptiert!\n"); 

} 

if(rc==SOCKET_ERROR) 
{
	cout<<"Fehler: Sende port reagiert nicht!";

}

rc = recv(cs,buf,8,0);
if(buf[0]=='2' && buf[1]=='.' && buf[2]=='5' )
{
	buf[0]='0';
		rc = send(cs,buf,3,0);
		cout<<"\nBitte neu starten update Fertig!";
		cin.get();
		return 0;
}
else
{

buf[0]='1';
		rc = send(cs,buf,3,0);

}

char *buf2;
	buf2=new char(1024);

if( (file = fopen(datei, "rb")) == NULL ) 
    { 
        printf("Fehler: Datei %s kann nicht geoffnet werden\n\n", datei); 
        return 1; 
    } 

 printf("Sende Datei... "); 
    while( !feof(file) ) 
    { 
        num = 0; 
        num = fread(buf, sizeof(char), sizeof(buf), file); 
        num = send(cs, buf, num, 0); 
        if( num == SOCKET_ERROR ) 
        { 
            printf("\nFehler: Fehler beim senden aufgetreten\n\n"); 
            return 1; 
        } 
        printf(".");   
    } 
    printf("\nDatei erfolgreich versendet!\n\n"); 

    fclose(file); 
    closesocket(cs); 
    WSACleanup(); 

    cout<<"\nBitte neu starten update Fertig!";
cin.get();
return 0; 
}

int startWinsock(void) 

{ 

  WSADATA wsa; 

  return WSAStartup(MAKEWORD(2,0),&wsa); 

}

Client:

#include "headers\magicaklass.h"
using namespace std;

int update()
{

//Prototypen

int startWinsock(void);
 long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr);

  char ausgabe1[300];
 	int b=0;
int end=0;
  	long rc;
SOCKET s; 
  SOCKADDR_IN addr; 

long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr);
  char buf[200];
  char test[255];
  char hostname1[200];	

/*hostname1[0]='1';
hostname1[1]='2';
hostname1[2]='7';
hostname1[3]='.';
hostname1[4]='0';
hostname1[5]='.';
hostname1[6]='0';
hostname1[7]='.';
hostname1[8]='1';*/
//hostname1[9]='i';
//hostname1[10]='l';
/*hostname1[11]='a';
hostname1[12]='s';
hostname1[13]='.';
hostname1[14]='d';
hostname1[15]='y';
hostname1[16]='n';
hostname1[17]='d';
hostname1[18]='n';
hostname1[19]='s';
hostname1[20]='.';
hostname1[21]='o';
hostname1[22]='r';
hostname1[23]='g';*/

gets(hostname1);
gets(hostname1);

 rc=startWinsock(); 
  if(rc!=0)

  {

    printf("Fehler: Update kann nicht ausgeführt werden.\nstartWinsock, fehler code: %d\n",rc);

    return 1;

  }

  s=socket(AF_INET,SOCK_STREAM,0); 

if(s==INVALID_SOCKET) 

{ 

  printf("Fehler: Update kann nich ausgeführt werden.\nSocketfehler code: %d\n",WSAGetLastError()); 

  return 1; 

} 

   // we use the overloaded <<

 memset(&addr,0,sizeof(SOCKADDR_IN)); // zuerst alles auf 0 setzten  

addr.sin_family=AF_INET; 

addr.sin_port=htons(81); // wir verwenden mal port 12345 

  rc=getAddrFromString(hostname1,&addr);
 rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR));

if(rc==SOCKET_ERROR)  
  {    printf("Fehler keine Verbindung zum Host!");   
  cin.get();
  cin.get();
   Hauptmenue(); 
   }

buf[0]='2';
buf[1]='.';
buf[2]='5';
rc = send(s,buf,5,0);
rc = recv(s,buf,7,0);
if(buf[0]=='0')
{
	cout<<"\nSie haben bereits die neueste Version.\n";
	Hauptmenue();
}

	char datei[] = "upms.exe";            // Datei path 
 int num; 
				char buf2[1024];
FILE *file; 
file = fopen(datei, "wb");
    printf("Datei %s zum schreiben geoffnet\n", datei); 
cin.get();

    printf("\nEmpfange Datei...\nBitte warten... "); 
    while( (num = recv(s, buf, sizeof(buf), 0)) > 0 ) 
    { 
        fwrite(buf, sizeof(char), num, file); 
        printf("."); 
    } 
    printf("\nDatei empfangen!\n\n"); 
    fclose(file); 
    closesocket(s); 
    WSACleanup(); 

cout<<"\nDas Programm wird jetzt ausgeschaltet.F"<<(char)129<<"hren sie bitte upsm.exe aus.\n";
Sleep(3000);

return 0;

} 

int startWinsock(void) 

{ 

  WSADATA wsa; 

  return WSAStartup(MAKEWORD(2,0),&wsa); 

}
    long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr)

{

  long rc;

  unsigned long ip;

  HOSTENT* he;
  // Parameter prüfen 

  if(hostnameOrIp==NULL || addr==NULL)

    return SOCKET_ERROR;
  // eine IP in hostnameOrIp ? 

  ip=inet_addr(hostnameOrIp);
  // bei einem fehler liefert inet_addr den Rückgabewert INADDR_NONE 

  if(ip!=INADDR_NONE)

  {

    addr->sin_addr.s_addr=ip;

    return 0;

  }

  else

  {

    //Hostname in hostnameOrIp auflösen 

    he=gethostbyname(hostnameOrIp);

    if(he==NULL)

    {

      return SOCKET_ERROR;

    }

    else

    {

      //die 4 Bytes der IP von he nach addr kopieren 

      memcpy(&(addr->sin_addr),he->h_addr_list[0],4);

    }

    return 0;

  }

}

Stefan ich gebe dir ein Rat, lösche alles und fange von vorne an.

--------------------------------------------------------------------------
Falsch:
rc = send(s,buf,5,0);
rc = recv(s,buf,7,0);
Richtig:
rc = send(s, buf, strlen(buf), 0);
rc = recv(s, buf, sizeof(buf), 0);
____________________________________________________________________________

gets(hostname1); wieso gleich zwei mal?
gets(hostname1);
___________________________________________________________________________

/hostname1[0]='1';
hostname1[1]='2';
hostname1[2]='7';
hostname1[3]='.';
hostname1[4]='0';
hostname1[5]='.';
hostname1[6]='0';
hostname1[7]='.';
hostname1[8]='1';/
//hostname1[9]='i';
//hostname1[10]='l';
/hostname1[11]='a';
hostname1[12]='s';
hostname1[13]='.';
hostname1[14]='d';
hostname1[15]='y';
hostname1[16]='n';
hostname1[17]='d';
hostname1[18]='n';
hostname1[19]='s';
hostname1[20]='.';
hostname1[21]='o';
hostname1[22]='r';
hostname1[23]='g';/

Was ist das?????? dafür gibt es strcpy();
_______________________________________________________________________

int update()
{

//Prototypen

int startWinsock(void);
long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr);

char ausgabe1[300];
int b=0;
int end=0;
long rc;
SOCKET s;
SOCKADDR_IN addr;

Prototypen inerhalb einer Funktion ??? hmmm
______________________________________________________________________________

Falsch
char datei[] = "update/upms.exe";
Richtig
char datei[] = "C:\\blabla\\update\\upms.exe";

__________________________________________________________________

Falsch
char *buf2;
buf2=new char(1024); // <<<<<<<<<<<<<<<<<<<<<<

Richtig
char *buf2;
buf2 = new char[1024];

An freigabe denken "delete"
_____________________________________________________________________

Und das sind noch lange nicht alle Fehler
Also schau nochmal den Beispiel von oben, und besser
kompiliere die beiden und starte sie dann.
Ich wundere mich dass da überhaupt was funktioniert hat.