kann recv jemals weniger daten empfangen als versendet?

z.b. ich sende 2 strings mit je 1000 zeichen direkt hintereinander.

//sizeof(buf) ist groß genug
bytes = recv(sender, buf, sizeof(buf), 0);

kann bytes jemals unter 1000 sein?

danke im voraus.

cppmember

Du musst selber durch eine Schleife etc. sicher stellen, dass alles ankommt.

wie sieht denn eine schleife, die auf netzwerkdaten von einem bestimmten client wartet, aus?

Mondmann schrieb:

Was ist in diesem FAlle buf?
Wenn buf ein zB. char[1000] buf ist und du schreibst sizeof(buf) ist das immer 1, da char 1 byte ist...

wirklich? hab ich nie bemerkt. ich verwende visual studio c++.

danke und mfg

cppmember

char buf[1000];

sizeof(buf) wirklich 1000 liefert.

Wenn du aber aber so etwas hast:

char* buf=new char[1000];

Dann würde sizeof(buf) 4 zurückgeben.

Das liegt daran, dass bei

char buf[1000];

sizeof(buf) wirklich 1000 liefert.

Wenn du aber aber so etwas hast:

char* buf=new char[1000];

Dann würde sizeof(buf) 4 zurückgeben.

c++ basics, das kenne ich.

Stimmt ich hab nen käse geschrieben.
Ich mach jetzt feierabend, ich checks heute eh nimmer:-)

des macht nix.

Zurück zum Thema:

Mein Code sieht ungefähr so aus:

while(1)
    {
        FD_ZERO(&fds);
        max = fill_set(&fds, &list);

        FD_SET(s, &fds);
        if (s > max)
            max = s;
        select(max + 1, &fds, NULL, NULL, NULL);
        if (FD_ISSET(s, &fds))
        {
			lz = add_client(&list);
            c = accept(s, (sockaddr *)&(lz->addr), &addrlen);
            lz->sock = c;
        } else {
            sender = get_sender(&fds);
            bytes = recv(sender, buf, sizeof(buf), 0);
//PROBLEM: hier soll sichergestellt werden dass daten von diesem "sender" komplett ankommen
		}
	}

Hat jemand ne Idee?
Oder muss ich auf select-Methode verzichten und für jeden Client einen Thread starten?

Dem flags argument gibste einfach MSG_WAITALL. fertig. (POSIX-konform)

@voidpointer: Windows ist nicht POSEX-konform.

Sicher? Es gibt AFAIK POSIX-konforme Compiler für Windoof... vllt könnte man MinGW probieren...

ein kleiner Wrap derart sollte es machen, getestet hab ich es noch nicht...

#ifdef __WIN32__
bool Client::recv(void * buf , size_t len ,  int flags)
{
        register size_t received = 0, next;
        do {
                next=(::recv(sock, (char*)buf+received, len-received, flags));
                received+=next;
        } while (received<len && next); // TODO ...
        return (bool)next;
}
#else
// ...
// POSIX IMPLEMENTATION
#endif // __WIN32__

Wie gesagt ich bin mir da nicht sicher und habs noch nicht getestet... evtl. muss noch nen select rein... Aber vllt hilft's dir ja

ich muss wohl beim senden eine Länge mitgeben und dann würde dein Code auch nützlich sein, es sei denn man kriegt den parameter "len" irgendwie vom system mit.

und zum schluss muss ich das gesamte system auf threads um stellen, select ist nicht geeignet, weil der server schliesslich in der warte-zeit andere clients bedienen soll.

ich wollte nicht mit threads arbeiten, weil thread-save ziemlich kompliziert sein würde

ich wollte nicht mit threads arbeiten, weil thread-save ziemlich kompliziert sein würde

Eigentlich musst du nur aufpassen, dass die Schnittstelle der Threads relativ klein bleibt und die halt absichern