#define BUFFER_SIZE 4096

Dazu muss man ja eine Schleife benutzen. Wie genau schaut diese aus?

Danke.

Dann mach es eben so, dass es nicht abstürzt.

Und wie?

Edit: Die Senderoutine steht unten richtig.

Schau mal hier. Ist aus dem WINAPI-Forum und sollte funktionieren.

Edit: Die Senderoutine steht unten richtig.

Ich habe die beiden Routinen übernommen. Meine Frage war aber, wie eine Sendeschleife aussehen muss, falls die Datei größer als der Puffer ist... Und wie teile ich recv() am besten mit, wir groß die zu schickende Datei ist?
(Ein send() vorweg?)

Danke.

Ich habe die beiden Routinen übernommen. Meine Frage war aber, wie eine Sendeschleife aussehen muss, falls die Datei größer als der Puffer ist... Und wie teile ich recv() am besten mit, wir groß die zu schickende Datei ist?
(Ein send() vorweg?)

1. Was für ein Puffer beim Senden?
2. Indem du die Größe vorwegschickst.

EDIT:
So geht man damit um, dass send nicht alles auf einmal sendet:

bool send_all(int s, const char *data, size_t size)
{
	size_t sent = 0;

	while (sent < size)
	{
		const int rc = send(s, data + sent, size - sent);
		if (rc > 0)
		{
			sent += rc;
		}
		else
		{
			return false;
		}
	}

	return true;
}

Ich benutze immer

#define BUF_SIZ 4096

als Puffergröße für recv() und für send(). Ist da vlt. schon der Fehler? Ich habe gelesen, dass Sockets eine bestimmte Puffergröße nicht mehr "vertragen". Wenn die zu übertragende Datei also z.B. 2 GB groß ist.

Danke.

Wenn die zu übertragende Datei also z.B. 2 GB groß ist.

4096 Bytes < 2 GB. Und zwar deutlich.

//siehe einige Posts weiter oben für send_all

bool send_file(int s, const char *data, size_t size)
{
	return
		send_all(s, reinterpret_cast<const char *>(&size), sizeof(size)) &&
		send_all(s, data, size);
}

bool receive_all(int s, char *data, size_t size)
{
	size_t received = 0;
	while (received < size)
	{
		const int rc = recv(s, data + received, size - received);
		if (rc >= 0)
		{
			received += rc;
		}
		else
		{
			return false;
		}
	}

	return true;
}

bool receive_file(int s, std::vector<char> &data)
{
	size_t fileLength;
	if (!receive_all(s, reinterpret_cast<char *>(&fileLength), sizeof(fileLength)))
	{
		return false;
	}

	if (fileLength == 0)
		return true;

	data.resize(fileLength);
	return receive_all(s, &data[0], data.size());
}

Du kannst doch per ReadFile immer bspw. 4096 Bytes lesen und an die Send-Methode übergeben.
ReadFile verrät dir geschickterweise auch noch, wie viele Bytes tatsächlich eingelesen wurden.

Ich benutze dafür fstream. Daher war mir das nicht bekannt.

Es hat geklappt.