Vielen Dank im vorrau*s!
Maxime

Der Code:

//EMPFÄNGER

//Die Buffergröße
char buffer[256];

while (strcmp(buffer, "") == 0)
{
	rc=recv(s,buffer,256,0);
	buffer[rc]='\0';
}

Sleep(5000);		
int FileSize = atoi(buffer);

//Die eigentliche Datei empfangen

	char fbuf[sizeof (FileSize)];
	rc=recv(s,fbuf,256,0);
	fbuf[rc]='\0';

	HANDLE sendfile; DWORD BytesWritten = 0;
	sendfile = CreateFile("text.txt", GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, NULL, NULL);
	WriteFile(sendfile, fbuf, FileSize, &BytesWritten, NULL);

	CloseHandle(sendfile);

//SENDER
	HANDLE file;
	char * buffer;
	int FileSize = 0;
	DWORD BytesRead = 0;

	file = CreateFile("text.txt", GENERIC_READ, NULL, NULL, OPEN_EXISTING, NULL, NULL);
	FileSize = GetFileSize(file, NULL);
	buffer = new char[FileSize];
	ReadFile(file, (void*)buffer, FileSize, &BytesRead, NULL);

	char sFileSize[sizeof(FileSize)];
	sprintf(sFileSize2, "%d\0", FileSize);

	send(connectedSocket, sFileSize2, FileSize, 0);
	Sleep(250);
	send(connectedSocket, buffer, FileSize, 0);

	CloseHandle(file);

//Sender:
sprintf(FileSize2, "%d\0", FileSize);
MessageBox(NULL, FileSize2, NULL, NULL);
//Dateigröße wird korrekt angezeigt

Empfänger:
while (strcmp(buffer, "") == 0)
{
rc=recv(s,buffer,256,0);
buffer[rc]='\0';
}

Sleep(5000);
MessageBox(NULL, buffer, NULL, NULL);
//Es sind noch nicht einmal Zahlen zu erkennen

Klappt es denn, wenn du normalen Text versuchst zu versenden?

Klar! Wenn ich die FileSize ja selber bestimme, wir die Datei vollständig übertragen.

Das mit den 0-Zeichen wusste ich gar nicht - könntest du mir da mal ein paar Alternativen geben?

Danke

send(connectedSocket, FileSize2, sizeof(FileSize), 0);

heißen müssen - und nicht

send(connectedSocket, FileSize2, FileSize, 0);

dein buffer ist 256 byte gross, so gibt du es auch an
mit rc erhälst du die bytes, die tasächlich gesendet wurden.

mein vorschlag, sende ein stream beginnend mit der der anzahl deiner zu senden datei gefolgt mit dem eigendlichen inhalt.

wenn du die ersten bytes empfängst, z.b size_t == 4 byte weißt du wie gross deine zu empfangende datei ist.

den buffer würde ich mit 1024 bytes festlegen

char* rbuf=NULL;
size_t pos, n;

char fbuf[1024]; 
rc=recv(s,fbuf,1024,0); 
if (rbuf==NULL)
{
  // vorausgesetzt rc>=4 !!
  memcpy(&n, fbuf, sizeof(size_t));
  rbuf=new char[n];
  rc -=sizeof(size_t);
  fbuf +=sizeof(size_t);
}
memcpy(rbuf, fbuf, rc);
pos=rc;

while (n != pos)
{
  rc=recv(s,fbuf,1024,0);
  memcpy(rbuf, fbuf, rc);
  n +=rc;
}

so in der richtung würde ich es realisieren

hat sich ja erledigt

Vielen Dank für die ganzen Antworten!

mein vorschlag, sende ein stream beginnend mit der der grösse (z.b in size_t) zu senden datei gefolgt mit dem eigendlichen inhalt.

wenn du mindestens die ersten 4 bytes (siehe (z.b in size_t)) empfangen hast, weißt du an hand der im stream gesendeten bytes, wie gross deine datei ist.

rc=recv(s,fbuf,1024,0);
// rc enthält die tatsächlich und in deb buffer geschriebenen bytes

Kann ich den Codeteil denn komplett in mein Projekt übernehmen (oder muss ich doch noch etwas verändern)?

PS: Wie kann ich denn dann mit den neuen Variablen "CreateFile" aufrufen?
PPS: Kann ich Dateigröße und Dateiinhalt komplett in einem Stream versenden?
(oder muss ich da noch ein Trennzeichen setzen?)

Sorry für die vielen Fragen bin noch ein Newbie

sollte eine gute anleitung sein http://www.c-worker.ch

das natürlich auch http://zotteljedi.de/doc/socket-tipps.html

Das mit den Sockets verstehe ich ja schon alles

ganz "grass gesehen"

struct IO
{
  int  b1;
  UINT b2;
  char s[255];
};
IO   io;
BYTE x[1024];
memcpy(x, &io, sizeof(IO));   //sende x;

//empfänger
BYTE y[1024];                 //empfange y
IO   out;

memcpy(&out, y, sizeof(IO));

9Halloduda

Dem Empfänger müsste ich also "sagen", dass das 1. Zeichen die Dateigröße beinhaltet. Daraufhin liest er die nächsten Zeichen und speichert sie in eine Datei.

Aber die zu sendende Datei ist ja nicht immer gleich groß! Mal 33KB, mal 55KB...
Woher soll der Empfänger dann wissen, bis wohin der empfangene Stream die Dateigröße beinhaltet - und ab wo der eigentliche Dateiinhalt beginnt?

Das geht (meiner Meinung nach) nur mit Trennzeichen
oder liege ich da falsch?

//stream
struct STREAM
{
  size_t nlen;
  char*  str;
};

STREAM st;

st.str=/*zeiger auf deine dateiinhalt*/
st.nlen=strlen(st.str);               //oder anders

//dein strem hat nun die gesamte länge st.nlen+sizeof(size_t)
//abstrakt gesehen

BYTE buf[1024]; 

size_t pos=0; BYTE* b=buf;

memcpy(b, &st.nlen, sizeof(size_t));
b +=sizeof(size_t);

while (pos != st.nlen)
{
  size_t n=1024-(b-buf);
  memcpy(b, str+pos, n);
  // send 1024 bytes
  pos +=n; b=buf;
}

es gibt natürlich noch viele andere wege, z.b ohne buffer
man muss aufpassen du kannst nur int=INT_MAX zeichen auf einmal senden

der empfänger sieht vom prinzip gleich aus

BYTE buf[1024]; size_t pos=0;
bool blen=false; 
STREAM st={0,0};

while (blen && pos != st.nlen)
{
  int n=recv(0, (char*)buf, 1024, 0);
  if (n == SOCKET_ERROR) break;
  char* b=buf;
  if (!blen)
  {
    // etwas übertrieben man hoft ja auf min 4 byte
    int len= pos+n >= sizeof(size_t)? sizeof(size_t)-pos:n;
    memcpy(&st.nlen+pos, buf, len);
    pos +=len;
    blen= pos != sizeof(size_t);
    if (!blen) continue; 
    // jetzt beginnt das char*
    n -=len; b +=len;
    pos=0;
  }
  if (n)
  {
    //in b mit n bytes steht deine teil (stream) datei
    //den du jetzt mit einem offset von pos wieder in deine 
    //datei schreiben kannst

    pos +=n;
  }
}

was besseres viel mir jetzt auch nicht ein

Habe leider noch nicht so viel Ahnung von "memcpy" und "size_t"

Vielen, vielen Dank im voraus!
(Diesmal ohne Rächtschraibfähla )

bei http://zotteljedi.de/doc/socket-tipps.html kannst du dir den kompl. source eines ftp-socket runterladen, das ist doch das was du suchst.

fertige lösungen wirst du von keinen hier bekommen.

Es ist doch praktisch möglich, die Datei und die Dateigröße getrennt mit einem | in einem Stream an den Server zu senden.

Um die Datei und die Dateigröße jeweils in einem String abzuspeichern, kann ich doch dann eine "selbstgeschriebene" explode - Funktion benutzen:

std::string explode(char trennzeichen, std::string str, int part)
                   {
                     std::string output;
                      if (part == 0) // Wenn der erste Part gesucht wird
                                     // müssen viele komplizuierte schritte nicht gemacht werden
                         {
                              string::size_type pos1 = str.find_first_of(trennzeichen);
                              output = str.substr(0,pos1);
                         }
                         else
                         {
                             /* Als erstes muss die Anzahl der Trennzeichen in dem
                                zu Teilendem String festgestellt werden, dies geschieht in
                                einer Schleife, und wenn die Anzahl (int i) mit (int) part (-1)
                                übereinstimmt wird die Postition ausfindig gemacht.
                             */
                             int s_lengh = strlen(str.c_str());
                             int match_c = 0;

                             for (int i=0;i<s_lengh;i++)
                                 {

                                   if (str[i] == trennzeichen)
                                      {
                                       match_c++;
                                        if (match_c == part)
                                           {
                                             std::string str_2 = str.substr(i+1, 1000);
                                             string::size_type pos2 = str_2.find_first_of(trennzeichen);
                                             output = str_2.substr(0,pos2);
                                           }
                                      }
                                 }
                         }
                     return output;
                   }

... oder nicht?

//receiver
	while (ret != SOCKET_ERROR)
	{
		ret = recv (*connectedSocket, Buffer,(2*sizeof(int)),NULL);

		if(ret == (2*sizeof(int)))
		{
			memcpy(&iCommandNr,Buffer,sizeof(int));
			memcpy(&iRecBufferSize,&Buffer[sizeof(int)],sizeof(int));
			cRecBuffer = new char[iRecBufferSize];

			if(0 != iRecBufferSize)
				recv (*connectedSocket, cRecBuffer,iRecBufferSize,NULL);

			wsprintf(port,"%d",*connectedSocket);
			iPos = m_This->m_listL.InsertItem(0,port);
			m_This->SetLVMStructureL(iPos,1,cPlayerName);
			m_This->SetFunctionName(iCommandNr,iPos);

			m_This->cManagerServer.SendBuffer(iCommandNr,iRecBufferSize,cRecBuffer,&cSendBuffer,port);

			delete [] cRecBuffer;
			char * SendeBuffer;
			char indicator = -1;
			SendeBuffer = new char [((2*sizeof(int))+iRecBufferSize)+1];
			memcpy(SendeBuffer,&iCommandNr,sizeof(int));
			memcpy(&SendeBuffer[sizeof(int)],&iRecBufferSize,sizeof(int));
			memcpy(&SendeBuffer[(2*sizeof(int))],cSendBuffer,iRecBufferSize);
			memcpy(&SendeBuffer[(2*sizeof(int))+iRecBufferSize],&indicator,1);

			send(*connectedSocket,SendeBuffer,(2*sizeof(int)), NULL);

			int iSendData = 0;
			int icount = 0;
			int i = 0;
			int ISize = iRecBufferSize+1;
			bool bFirst = true;
			do
			{
				if(1024 < (iRecBufferSize-icount))
					iSendData = 1024;
				else
					iSendData = ISize-icount;
				char szData = 1;
				do
				{
					i = send(*connectedSocket,&SendeBuffer[(2*sizeof(int))+icount],iSendData, NULL);
					ret = recv (*connectedSocket, Buffer,1,NULL);
					if(ret != -1)
						memcpy(&szData,Buffer,1);
				}while(szData == 1 && ret != SOCKET_ERROR && ret != 0);

				if(bFirst && i != 0)
				{
					bFirst = false;
					icount--;
				}
				icount += i;
				if(i == 0)
					icount--;
			}
			while(icount != iRecBufferSize && ret != SOCKET_ERROR && ret != 0);
			delete [] SendeBuffer;
			delete [] cSendBuffer;
			if(FSetClientName == iCommandNr)
			{
				CString ctmp;
				ctmp = m_This->cManagerServer.GetClientName(port);
				strcpy(cPlayerName,ctmp.GetBuff(ctmp.GetLength()));
				ctmp.ReleaseBuffer();
			}
			continue;
		}

		if (ret == 0 || ret == SOCKET_ERROR)
		{
		}
	}

//Sender
DLLEXPORT virtual void Send(int ifunctionNo,int &ISize,char *cSendBuffer,char **cRecBuffer)
	{
		char * TransmitBuffer;

		TransmitBuffer = new char[(2*sizeof(int)+ISize)];

		memcpy(TransmitBuffer,&ifunctionNo,sizeof(int));
		memcpy(&TransmitBuffer[sizeof(int)],&ISize,sizeof(int));
		memcpy(&TransmitBuffer[(2*sizeof(int))],cSendBuffer,ISize);

		if(0 > send(ssocket, TransmitBuffer,((2*sizeof(int))+ISize),NULL))
		{
			bConnected = false;	
		}
		else
		{
			char sbuffer[8];

			recv (ssocket,sbuffer,(2*sizeof(int)), NULL);

			memcpy(&ifunctionNo,sbuffer,sizeof(int));
			memcpy(&ISize,&sbuffer[sizeof(int)],sizeof(int));
			ISize++;

			if(0 < ISize)
			{

				*cRecBuffer = new char[ISize];
				char indicator = -1;
				char *ptemp ;
				int i = 0;
				int icount = 0;
				int iReaddata = 0;
				int iSendData = 0;
				bool bFirst = true;

				memset(*cRecBuffer,0,ISize);

				char *tmp = new char [ISize];
				do
				{
					indicator = -1;
					if(1024 < (ISize-icount))
						iReaddata = 1024;
					else
					{
						if( 0 == icount)
							iReaddata = ISize-icount;
						else
							iReaddata = ISize-icount;
					}
					char *crecievebuffer = new char[iReaddata];
					memset(crecievebuffer,0,iReaddata);
					i = recv(ssocket,crecievebuffer,iReaddata,NULL);
					if(i == -1)
					{
						indicator = 1;
						i = WSAGetLastError();
						i = 0;
					}
					while(-1 == send(ssocket, &indicator,1,NULL));
					memcpy(&tmp[icount],crecievebuffer,i);

					if(bFirst && i != 0)
					{
						bFirst = false;
						icount--;
					}
					icount +=i;
					if(i == 0)
						icount--;
					ptemp = tmp;
					delete [] crecievebuffer;

				}while(ptemp[icount] != -1);
				memcpy(*cRecBuffer,tmp,ISize);
				delete [] tmp;
			}
		}
		delete [] TransmitBuffer;
	};

So mache ich es in einem TCP Server von mir

edit: sfds