hab folgendes problem , ich weiß nicht wie ich große daten übers netzwerk sende.
Ich hab die Daten in Pakete aufgeteiilt jedoch entsteht beim Senden eine Latenz die bei zunehmender Paketzahl fast zum Stillstand führt. Dies geschieht schon bei mehr als 8 Paketen der maximalen größe von 100 byte.

ich habe mal die sender und empfänger codes zusammengefasst und hofffe jemand kann helfen.
Senden Teil:

for(i=0;i<Container.count;i++)
          {
          socket_nummer = socket(AF_INET, SOCK_STREAM, 0);
          result = connect(socket_nummer, (struct sockaddr *)&adresse, laenge);
          if(result!= -1)
	     {
             send[3]=2; /* ist ein char[4] */
            /* Die ersten 4 Bytes leiten das senden von den nächsten 100 ein */
             write(socket_nummer, send, 4);
	     write(socket_nummer, objekt MitMax100Bytes,100 );
	     }
          close(socket_nummer);
          }

Empfänger Teil:

while (1)
     {
     fflush(stdout);
     client_socket = 
        accept(server_socket, (struct sockaddr *)&clientinfo, &laenge);
     read(client_socket,Data,4);

     switch( Data[3] )
     {
     case 0: ... break;
     case 1:... break;
     case 2:
     read(client_socket,getLineData,128);
     /* hier findet noch eine kleine initialisierung der empfangenen daten */
     /* und hier werden noch in einer for schleife die daten analysiert und      gezeichnet */
     close(client_socket);
     break;
     }/*Switch close */
   }/*While close */
}

Habe auch schon versucht die anzahl der zu sendenen Bytepakete mitzusenden und "connect(socket_nummer,..." nicht immer aufgerufen. Auf der Empfängerseite hab ich dann versucht dies in einer schleife mit read(...) zu empfangen was jedoch dazu geführt hat dass ich nur das erste paket bekommen habe.

hallo
Ich hab die Daten in Pakete aufgeteiilt jedoch entsteht beim Senden eine Latenz die bei zunehmender Paketzahl fast zum Stillstand führt. Dies geschieht schon bei mehr als 8 Paketen der maximalen größe von 100 byte.

Geschieht das auf der Sender oder Empfängerseite? Ich würde das aufsplitten der Paktete einfach den Verwendeten Protokollen überlassen (sofern dies das übernehmen). Wenn du eine TCP/IP Verbindung aufbaust, dann brauchst du dich nicht darum zu kümmern. Die Protokolle zerlegen die Daten, teilen diese auf meherere Pakete auf und setzen sie anschließend beim Empfänger wieder zusammen. Sprich: sende alles was du hast aufeinmal.

//////////////////////////////////////////////////////////
// Sender
const int groesse = 10000000000;
char daten[groesse];

FuelleDaten(daten, Paketgroesse); // füllt das Array mit irgendwas wichtigem

//...

socket_nummer = socket(AF_INET, SOCK_STREAM, 0);
result = connect(socket_nummer, (struct sockaddr *)&adresse, laenge);
if(result!= -1)
{
    int gesendeteBytes = send(socket_nummer, daten, groesse );   // alles "aufeinmal" weg
}

//////////////////////////////////////////////////////////
//Empfänger

// Socekterstellung spar ich mir hier 

const int groesse = 10000000000;
int empfangeneBytes = 0;
char daten[groesse];

do
{
    empfangeneBytes = recv(socket, daten, groess);

    SpeichereDatenWoanders(daten, empfangeneBytes);    

}while(empfangeneBytes != 0);

Danke erstmal für die Antwort. Hab das so wie du es beschreibst auch vorher genau so versucht was dazu führte dass das Paket verloren ging.. Hatte zuvor 40k Daten gesendet und es ging nicht, dabei hatte ich es genauso gemacht wie du es beschrieben hast. Hab dan was über ne maximale Paketgröße gelesen und wollte alles dann selber aufteilen.

Das Aufteilen der Pakete muss aber sowieso schon im Programm bleiben da die Pakete Teil des Programmimplementierung sind..

Habe gerade den " möglichen Fehler" woanders lokalisiert..
Und zwar hatte ich die Warteschleife auf 3 gesetzt

listen(server_socket, 3);

Wo ich die jetzt auf 8192 erweitert habe gibts diese sichtbare Latenz nicht mehr und ich habe schon getestet über 30 Pakete problemlos senden können. Denke beliebig viele werden dann auch gehen.
Meine Tests verlaufen zur Zeit nur über localhost mit einem Server und Klient Thread weswegen ich mir noch die übriggebliebene kleine Latenz erkläre.

Frage ich mich nun gerade ob dies nicht auch schon funktioniert hätte wo ich noch alles ( 40k Daten ) auf einmal senden wollte..

Das aufteilen der Daten passt so.