recv

Nul bytes har ikke nogen speciel betydning i socket communication.

Det kan det ikke have da man skal kunne sende binære data med
nul bytes i.

Du bliver nødt til at bygge funktionaliteten ind i din
applikation d.v.s. at du send'er data+nul byte og recv'er
bytes og parser dem indtil nul byte.

Her er noget af det kode jeg lavet....

int numbytes;
char buf[100];

if( (numbytes = recv( new_fd, buf, 100, 0)) == -1 ) {
perror( "recv" );
exit( 1 );
}

buf[ numbytes ] = '\0';
printf( "Received: %s\n", buf );

Jeg har brugt Beej simple client/server http://www.ecst.csuchico.edu/~beej/guide/net/bgnet.pdf som udgangspunkt til client server strukturen. Men så vidt jeg kan se så er det C, men jeg har tilføjet nogle ting til min egen kode og compilet det med g++ (jeg kører en linux-box)

Bemærk at de fleste applikationer bruger <CR><LF> til at adskille
data med og ikke <NUL>.

Var det ikke bedre at blive ved med at modtage indtil der ikke kommer mere ?
Altså noget ala:

while(recv(remote_socket, (char *)buffer, packet_size, 0))  != 0)
{
  printf("%s\n", buffer);
}

Du kan sådan set godt bruge nulterminering til at signalere slut, men du skal sørge for at inkludere nullet i den byte-strøm du sender :

void SendData( char *mesg ) // mesg er nultermineret
{
  // ved at lægge en til længden sikrer du dig at nullet også bliver sendt
  send(sock, mesg, strlen(mesg) + 1, 0);
}

void Recv()
{
  char *buf;
  int size = 10;
  int recvLen = 0;
  buf = malloc(size);
  while( !recvLen && buf[recvLen] )
  {
      if(size-recvLen < 10) buf = realloc( buf, size + 10 );
      recvLen += recv(sock, buf+recvLen, size-recvLen, 0);
  }
}

Sku ha' været et svar :-)

Du kan ikke regne med at hvis du send'er 3 klumper, så
recv'er du også 3 klumper.

Derfor er du nødt til at parse igennem det du recv'er.

Tak arne... Det var det som var løsningen... Havde ikke lige tænkt på den sådan...

Arne kom dog først med et svar... Men du får også lidt sloth

Soreno>
Det kan man ikke lige, man resikere at der er nogle pakker i transit, således at man hopper ud af løkken uden at have fået al det data der er sendt

Du bad om noget kode - det fik du ikke fra arnev, eller har jeg misset noget  :-(

Sorry, men jeg nåede at indfører det i min egen kode inden jeg havde opdateret på siden igen, selvom svarene kom hurtigt... plus arne løsning passede perfekt ind i min egen kode....

kom nu... jeg gav dig også 5 skånepoint...

hsloth >>
Fra dokumentationen for recv:
"If no incoming data is available at the socket, the recv() call waits for data to arrive unless the socket is non-blocking."

Så må det da være ok at bruge "sålænge recv ikke returnerer 0" (forudsat er der bruges en blocking TCP socket..) ?

søren>

Det at recv blocker garanterer at der er nået et aller andet antal
bytes frem inden recv returnerer.

Det garanterer ikke, at alle bytes er nået frem inden recv
returnerer.

Med tilpas små data-mængder så vil alle data nok være nået
frem i praksis.

Men man bør alligevel lave sin kode så den er forberedt på
esktreme situationer.

Ok, så har jeg forstået det korrekt - det var bare den pastede kode som ikke var optimal.

Soreno + arne_v>
Hvis du i din kode bruger en blocking socket vil du hænge i din while løkke indtil socketen bliver lukket, fra den anden ende - dette får recv til at returnere en negativ værdi - som din while betingelse vil fange, din kode vil derfor udskrive den sidst modtagne bid 2 gange.

Det er selvfølgelig også en finesse.

Men hvad med din løkke ?

arne_v >
Min løkke forudsætter at man bruger en non-blocking socket.
Derudover er der (mindst) en fejl i Recv() - skulle have været :

void Recv()
{
  char *buf;
  int size = 10;
  int recvLen = 0;
  buf = malloc(size);
  while( !recvLen && buf[recvLen] )
  {
      if(size-recvLen < 10)
      {
buf = realloc( buf, size + 10 );
      recvLen += recv(sock, buf+recvLen, size-recvLen, 0);
  }
}

arne_v - fortsat>
Pokkers - koden smuttede ind inden jeg var færdig med at editere :
void Recv()
{
  char *buf;
  int size = 10;
  int recvLen = 0;
  buf = malloc(size);
  while( !recvLen && buf[recvLen] )
  {
      if(size-recvLen < 10)
      {
        size += 10;
        buf = realloc( buf, size );
      }
      recvLen += recv(sock, buf+recvLen, size-recvLen, 0);
  }
}

Min pointe var at det ikke var løkken men recv/send der var
"the issue".

PS: Jeg tror iævrigt stadigvæk der er problemer med din løkke !
    Vil testet !recvLen ikke returnerer false ligeså snart der
    er læst noget ?

arne_v>
Så har jeg vist misset din pointe : "Men hvad med din løkke ?"

Det var bare et lille hip til at du var så meget efter sørens løkke.

arne_v>
Jeg var ikke "efter" soreno's løsning - jeg synes bare han skulle have hele historien om blocking og non-blocking sockets

OK. blocking versus non-blocking er særdeles relevant.

Thanx