ich programmiere gerade einen TCP Datei-Server und -Klienten.
Das Prinzip funktioniert ganz einfach:

Klient stellt Verbindung her
Server sendet Eintrag (Dateiname + Größe)
Klient vergleicht Dateigröße
Klient fordert Datei an, falls Dateigrößen unterschiedlich

Das Senden der Datei funktioniert so:
Klient fordert Paket an (bis jetzt 512 Byte)
Server sendet Paket

klappt alles wunderbar, so lange die Dateien nicht groß sind. (<100KB)

Nur leider habe ich auch vor größere Dateien (damit meine ich max. 3MB)
zu versenden.
Wenn ich weiterhin dieses Prinzip verwende, würde es ewig dauern eine Datei runterzuladen.
Beispiel 80KB:
80 * 1024 / 512 = 160 Anfragen
1 Anfrage: 50ms
=8000ms
Somit würde ich schon für eine 80kB Datei 8 Sekunden nur fürs Anfordern des nächsten Paketes verbraten.
Ich hab übrigens 512 Byte gewählt, weil ich auf http://www.win-tux.de/c_028_007.htm#...002D231F022193 gelesen hatte, dass 512 Byte (richtig, ich hab mich verlesen , es sollen KB sein) die richtige Puffergröße wäre.

Hab es dann auf 512KB vergrößert, was zur Folge hat, dass das Programm während dem Übertragen unregelmäßig die Verbindung abbricht.
Das macht es immer, wenn ich eine Größe über 1024 Byte wähle.

Damit hab ich 2 Fragen:
1. Was ist die optimale Puffergröße?
2. Welches Prinzip sollte ich beim Senden der Datei verwenden?

Danke fürs lesen, hoffe ihr könnt mir bei dem Problem helfen

ohne code kann ich nicht viel sagen, aber wenn ich größer als 1024 höre denke ich gleich an die maximale Paketgröße (1500 Byte abzüglich TCP/UDP-Header)

int LoadMap(const char * saveto, const char * mapname, long filesize)
{
	//char saveto[MAX_PATH_LEN] = "";
	//memcpy(saveto, sapath, MAX_PATH_LEN);
	//strncat(saveto, mapname, MAX_PATH_LEN);
	FILE *datei = fopen(saveto, "wb");

	if (datei == NULL)
		cout << "Kann Datei " << saveto << " nicht speichern.\n";
	else
	{
		char msg[128] = "file ";
		strncat(msg, (const char*)mapname + 1, sizeof(msg));
		if (send(sock, msg, strlen(msg) + 1, 0) == -1)
			cout << "Konnte Initialisierung von Dateitransfer nicht senden: " << WSAGetLastError() << '\n';
		else
			cout << "Beginne Dateitransfer von Datei " << mapname << ".\n";
		int rstate = 0; char rdata[BUF_LEN] = "";

		while (!sshutdown)
		{
			if ((rstate = recv(sock, (char*)&rdata, sizeof(rdata), 0)) == -1)
			{
				cout << "Fehler beim Erhalten von Daten: " << WSAGetLastError() << '\n';
				break;
			}
			if (rstate == 0)
			{
				cout << "Der Server hat die Verbindung während dem Laden beendet.\n";
				break;
			}
			fwrite(rdata, 1, rstate, datei);
			send(sock, "#\0", 2, 0);
			filesize -= rstate;
			//cout << filesize << '\n';
			if (filesize == 0)
			{
				//cout << rdata << '\n';
				cout << "Datei erfolgreich geladen.\n";
				//cout << rstate << '\n';
				break;
			}
			else if (rstate != sizeof(rdata))
			{
				cout << rstate << ' ' << sizeof(rdata) << '\n';
				cout << "Fehler: unerwartetes Dateiende.\n";
				break;
			}
			//send(sock, "#\0", 2, 0);
		}
		fclose(datei);
		//send(sock, "#\0", 2, 0);
	}
	return 0;
}

Diese Funktion ist für die Kommunkiation zuständig:

bool GetMapData()
{
	int rstate = 0; char rdata[BUF_LEN] = "";

	//memcpy(rdata, "req", 3);
	//rdata = "req";
	//send(sock, rdata, 1, 3);
	if (send(sock, "req", 3, 0) != -1)
		cout << "Fordere Versionsinfo an.\n";
	else
		cout << "Kann Versionsinfo nicht anfordern: " << WSAGetLastError() << '\n';

	while (!sshutdown)
	{
		if ((rstate = recv(sock, (char*)&rdata, sizeof(rdata), 0)) == -1)
		{
			cout << "Fehler beim Erhalten von Daten: " << WSAGetLastError() << '\n';
			return false;
		}
		if (rstate == 0)
		{
			cout << "Der Server hat die Verbindung beendet.\n";
			return true;
		}
		rdata[rstate] = 0;
		if (server_cmd(rdata) == 0)
		{
			cout << "Antwort (" << rdata << ") unbekannt, beende Verbindung\n";
			//cout << rstate << '\n';
			closesocket(sock);
			return false;
		}
	}
	return true;
}

Hier werden die Server Nachrichten ausgewertet:

int server_cmd(const char * cmd)
{
	if (strncmp(cmd, "/msg ", 5) == 0)
	{
		cout << "Nachricht:\n";
		cout << (cmd + 5) << '\n';
		return 1;
	}
	if (strncmp(cmd, "map", 3) == 0)
	{
		char mappath[MAX_PATH_LEN] = "";
		char complpath[MAX_PATH_LEN] = "";
		memcpy(complpath, sapath, MAX_PATH_LEN);
		char fsize[20] = "";
		getstrspc2(cmd, 1, "  ", mappath, sizeof(mappath));
		cout << "Dateiinformationen erhalten: " << mappath << '\n';
		//cout << cmd << '\n';
		strncat(complpath, mappath, MAX_PATH_LEN);
		getstrspc2(cmd, 2, " \0", fsize, sizeof(fsize));
		if (fsize[0] == 0)
			send(sock, "/msg Fehler: Dateigrӧe invalid.\0", 33, 0);
		else
		{
			bool bsend = false;
			long lsize_new = atol(fsize);
			long lsize = 0;
			FILE * datei = fopen(complpath, "rb");
			if (datei == NULL)
			{
				//cout << "Datei " << complpath << "existiert nicht.\n";
				char fpath[MAX_PATH_LEN] = "";
				getpath(complpath, fpath, MAX_PATH_LEN);
				if (_access(fpath, 0) != 0)
				{
					cout << "Pfad existiert nicht.\n";
					return false;
				}
				else
					LoadMap(complpath, mappath, lsize_new);	
			}
			else
			{
				fseek(datei, 0, SEEK_END);
				lsize = ftell(datei);				
				fclose(datei);
				cout << "Vergleiche DateigrӇen: " << lsize << " " << lsize_new << '\n';
				if (lsize != lsize_new)
				{
					LoadMap(complpath, mappath, lsize_new);
				}
				else
				{
					cout << "Datei ist auf dem neustem Stand, fordere n„chsten Eintrag an.\n";
					if (send(sock, "/next\0", 6, 0) == -1)
						cout << "Fehler: Konnte Antwort nicht senden.\n";
				}
			}
		}
		return 1;
	}
	return 0;
}

Die Server Funktion, die fürs Datei senden zuständig ist:

void SendFile(const char * filename)
{
	int sendc = 0;
	char sdata[BUF_LEN] = "";
	FILE * datei = fopen(filename, "rb");
	if (datei == NULL)
	{
		char msg[50] = "/msg Fehler: Konnte angeforderte Datei ";
		strncat(msg, filename, sizeof(msg));
		strncat(msg, " nicht finden.", sizeof(msg));
		cout << (char *)msg + 5 << '\n';
		send(sock2, msg, strlen(msg), 0);
	}
	else
	{
		while(!sshutdown && (sendc = fread(sdata, 1, sizeof(sdata), datei)) != 0)
		{
			//cout << sendc << '\n';
			//sdata[sendc] = 0;
			if (send(sock2, (const char*)&sdata, sendc, 0) == -1)
			{
				cout << "Fehler beim Senden der Nachricht: " << WSAGetLastError() << '\n';
				break;
			}
			recv(sock2, sdata, 2, 0);
		}
		fclose(datei);
		//if (send(sock2, /*(const char*)-1*/"\0", 1, 0) != -1)
			cout << "Dateiübertragung beendet.\n";
		//_getch();
		/*else
			cout << "Fehler: Konnte Dateiende nicht senden.\n";*/
	}
}

Ich werde das Prinzip überarbeiten

Werds so versuchen:

Klient frägt nach Datenblock

Server schickt 2 Blöcke

Klient frägt nach dem nächsten Block, wenn der erste eingetroffen ist.

Mach es entweder ganz ohne Blöcke, oder mit variabler Blockgrösse. Wobei der Client dann im Normalfall immer die ganze Datei auf einmal anfordert -- es sei denn z.B. die Verbindung wurde unterbrochen, der Client hat schon die ersten N Bytes, und will nurmehr den Rest anfordern.
Das ist "der übliche Weg". Alles andere halte ich für ziemlich unnötigen und sinnlosen Overhead.

Falls du meinst das wäre aus irgendeinem Grund schlecht, wäre ich interessiert diesen Grund zu erfahren

Wie wird die vorgeschlagene Methode denn realisiert?

Entferne mal aus der SendFile()-Funktion den Aufruf "recv(sock2, sdata, 2, 0);". Wofür hast du den denn gedacht?

Trenne dein Programm so auf, daß es genau 1 Empfangsschleife und 1 Sendefunktion gibt.

P.S: Deine interne Blockgröße ist eigentlich fast egal, da mittels TCP/IP sowieso blockweise übertragen wird (diese sollte - wenn überhaupt - auf die Festplattenzugriffe optimiert sein).

Das

else if (rstate != sizeof(rdata))
{
    cout << rstate << ' ' << sizeof(rdata) << '\n';
    cout << "Fehler: unerwartetes Dateiende.\n";
    break;
}

hab ich natürlich auch entfernt, da nicht 512 Bytes empfangen werden, sondern was halt reinkommt.

Hab noch ein sleep nach der Schleife reingehaun damit sich die Daten der Datei mit der nächsten Nachricht nicht vermischen.

Hatte das Prinzip irgendwie nicht verstanden, aber jetzt tu ichs, danke für die Hilfe!

Hab noch ein sleep reingehaun damit sich die Daten der Datei mit der nächsten Nachricht nicht vermischen.

WTF?

Hab noch ein sleep reingehaun damit sich die Daten der Datei mit der nächsten Nachricht nicht vermischen.

OMG

Ich geh mal davon aus, dass ihr den Beitrag missverstanden habt.

Das sleep ist hinter der Schleife, wo soll es auch sonst sein?
Das Ding läuft übrigens auf Linux.

Anders würde die nächste Nachricht, sprich der nächste Dateieintrag noch in die Datei geschrieben werden. Man könnte es natürlich auch ohne sleep realisieren, indem man vor dem Schreiben einfach abfrägt, wieviel Daten überhaupt noch benötigt werden. Den Überschuss könnte man an die Funktion servercmd schicken.

SPAMT nicht rum, wenn ihr was konstruktives beizutragen habt, tut es, oder lasst es sein.

Ich geh mal davon aus, dass ihr den Beitrag missverstanden habt.

Geh aus wovon du willst.

Das sleep ist hinter der Schleife, wo soll es auch sonst sein?
Das Ding läuft übrigens auf Linux.

Anders würde die nächste Nachricht, sprich der nächste Dateieintrag noch in die Datei geschrieben werden. Man könnte es natürlich auch ohne sleep realisieren, indem man vor dem Schreiben einfach abfrägt, wieviel Daten überhaupt noch benötigt werden. Den Überschuss könnte man an die Funktion servercmd schicken.

Ich hab das schon richtig verstanden, du bist nicht der erste der diesen Fehler macht. Und ich programmiere mit Sockets, im gegensatz zu dir, nicht erst seit ein paar Tagen.

sleep() als Lösung für solche Probleme ist grundsätzlich ein Fehler. Bei Sockets kann es z.B. passieren, dass entweder der Empfänger, oder die Netzwerk-Leitung, so langsam ist, dass beim Empfänger trotz des sleep() alles auf einmal ankommt. D.h. es würde erst nicht funktionieren. Zu testen ist sowas natürlich schwer, da man solche worst-case Situationen schwer absichtlich herbeiführen kann. Im Betrieb wird es sich aber früher oder später ergeben.

Die korrekte Lösung ist auf der Empfänger-Seite selbst mitzuzählen, und dann recv nur soviel als Puffergrösse zu übergeben, wie man maximal empfangen will. Dadurch muss man auch nichts an irgendwelche anderen Funktionen weitergeben, da die weiteren Daten noch im Socket-Puffer stehen bleiben.

Und ob das ganze unter Windows, Linux oder sonstwas läuft, ist vollkommen egal. Keine Ahnung wie du darauf kommst es könnte einen Unterschied machen.

sleep war eigtl. nur als Zwischenlösung gedacht. (soweit ich weiß reagiert das linux sleep anders als das windows Sleep, was in dem Fall aber keine Rolle spielt)

Das Problem mit der langsamen Leitung ist hier sehr unrealistisch, da eine gute Netzwerkleistung für das Nutzen des Dienstes Vorraussetzung ist.

Und ob das ganze unter Windows, Linux oder sonstwas läuft, ist vollkommen egal. Keine Ahnung wie du darauf kommst es könnte einen Unterschied machen.

In dem Fall ist es egal, aber ich kann ja nicht duch ein "WTF" mir denken, welches Problem du meinst.

Die korrekte Lösung ist auf der Empfänger-Seite selbst mitzuzählen, und dann recv nur soviel als Puffergrösse zu übergeben

Alles klar, werd das so machen, danke

Das Problem mit der langsamen Leitung ist hier sehr unrealistisch, da eine gute Netzwerkleistung für das Nutzen des Dienstes Vorraussetzung ist

OMG ^^

Dann schreibt nicht sowas sinnloses wie OMG oder WTF, was soll ich mir da denken?

Gut dann schreib ich das nächste mal garnix. Mir kanns ja egal sein was du zusammenprogrammierst.

Das Problem mit der langsamen Leitung ist hier sehr unrealistisch, da eine gute Netzwerkleistung für das Nutzen des Dienstes Vorraussetzung ist.

Heute, zum Beispiel, ist anscheinend in Paris ein zentraler Server ausgestiegen, wodurch gewisse Teile des Netzes nur verlangsamt erreichbar wurde. Das Problem war zwar innert Minuten behoben, doch das Netz war langsamer, gewisse Webseiten konnte ich sogar gar nicht mehr erreichen.

Wenn du also sowas voraussetzt, dann schliesst du jeden Internetnutzer aus
Und wenn du nun sagst, dass dein Programm nur in einem privaten oder geschäftlichen Netzwerk läuft, dann kann ich dir sagen, dass es dort genausogut zu Verzögerungen oder Staus kommen kann. Mag mich da an ein paar Berichte von meinem Vater aus der Novartis erinnern.

Verlasse dich nie auf das Netzwerk.

Grüssli

Ich weiß schon, was du meinst.

Stimmt schon.

Kommt es zu diesem Problem, passiert auch nix, dann lädt derjenige sich das nochmal. Es geht auch nix kaputt dadurch
Sollte die Verbindung wirklich so schlecht sein, kann man die Dateien sowieso nicht nutzen, da es Dateien sind, die man fürs Spielen für ein Multiplayer Spiel braucht (Der Gameserver befindet sich auf dem selben Server)

Da es sowieso nur eine schnelle Lösung war und ich das Programm wie beschrieben umbaue, spielt das eh keine Rolle mehr.

@unskilled:
Leute! Wenn ich schreibe, dass das Vorraussetzung ist, dann stimmt das auch und eure kindischen Kommentare könnt ihr euch sonst wohin stecken.
Wie hoch ist das durschnittliche Alter hier?

@hustbaer:
Du widersprichst dir selber:
Zuerst schreibst du "WTF", womit ich überhaupt nichts anfangen kann.
Dann schreibst du mir wirklich hilfreiche Tipps, wofür ich dir dankbar bin.
Und jetzt beschwerst du dich, dass ich mit deinem Kommentar nix anfangen kann?
Also entweder willst du mir helfen oder nicht Oo

Hier sollte mal ein Moderator die ganzen sinnlosen Kommentare löschen...

Kommt es zu diesem Problem, passiert auch nix, dann lädt derjenige sich das nochmal. Es geht auch nix kaputt dadurch

Ja, wenn das ein Programmierer so festlegt und ich dessen Programm verwende, dann bekomme ich manchmal eine Mordlust. Der User wird dir dafür jedenfalls sicher nicht danken und der Wertung deines Programmes würde es auch nicht gut tun. Und Imagepflege, bzw. Marketing, ist sehr wichtig bei der Vermarktung

Cypog schrieb:

Da es sowieso nur eine schnelle Lösung war und ich das Programm wie beschrieben umbaue, spielt das eh keine Rolle mehr.

Naja, doch. Wir haben hier oft Leute, welche den Tipps brav folgen, Code umschreiben, verbessern usw. usf., im Endeffekt aber gar nicht verstanden haben, wieso das alles besser ist. Wir wollen hier schliesslich einen Lerneffekt erzielen

Und das mit den etwas seltsamen Kommentaren, nimm es einfach ein bisschen lockerer. Die meisten sind nicht böse gemeint und wenn sie es sind, dann ist meistens der Autor etwas unterblichtet und behinderten Leuten sollte man ja mit Rücksicht begegnen.
Aber hier liest man manchmal so viel seltsames Zeug, gerade auch so ein aktives Mitglied wie hustbaer oder unskilled, dass einem zum Teil wirklich nur noch ein WTF in den Sinn kommt. Da braucht man dann Zeit, um seine Gedanken wieder zu sammeln

Grüssli

Du unterstellst auch wiederholt dass andere die dir antworten nix verstehen und kindisch sind und wahrscheinlich noch in die Windeln pissen. Damit macht man sich keine Freunde.

Was das "WTF?" sollte? Ganz einfach: für mich hat das so geklungen, als ob du das für eine gute Lösung halten würdest. Und das kann ich nur mit einem "WTF?" quittieren, da es eine denkbar dumme und kurzsichtige Lösung ist.

Wenn ich schreibe, dass das Vorraussetzung ist, dann stimmt das auch und eure kindischen Kommentare könnt ihr euch sonst wohin stecken.

Genau sowas meine ich. Nicht freundlich, und noch dazu grober Unfug.

Um es in deinen Worten zu sagen: wenn ich dir sage, dass das falsch ist, und daneben gehen kann, dann kannst du das ruhig glauben. Ein Programm welches auf ein bestimmtes Timing angewiesen ist, um korrekt zu funktionieren, ist kein Programm, sondern ein Scheisshaufen.

OMG
WTF
DER THREADERSTELLER IST EIN FOLLIDEOT
selten sowas dummes gelest

Soll ich mich etwa für solche Kommentare bedanken?

Für mich ist das Thema seit einer Seite abgeschlossen, aber irgendwer, und damit mein ich nicht Dravere, muss wohl immer seinen Senf dazu geben.

Oja, ich hab lediglich geschrieben, dass mein Beitrag missverstanden wurde und nicht behauptet, dass das deine Schuld war, vielmehr war es meine, weil ich mich nicht deutlich ausgedrückt hab, also brauchst du dich doch gar nicht beschweren oder angegriffen fühlen ;), tut mir leid wenns so rüberkam

Für mich ist das Thema seit einer Seite abgeschlossen

dann mach ich doch mal zu.
jetzt kriege ich zwar haue, aber die kriege ich eh regelmäßig, ob ich was anstelle oder nicht.