Thread: how receive the large data using recv function in c++?

i developed client server program using c++,so i want to receive more than 1000000 bytes , my client message is terminated with "!" ,so i use loop in my server side but my server always wait for client data even client sent all data to the server ,this my server side recv() code.

Code:

 do
     {

        iByteCount = recv(GetSocketId(), buffer,MAXRECV,0);

                if ( iByteCount > 0 )
                {
                    printf("Bytes received: %d\n",iByteCount);
                     strcat(buf,buffer);
                }
                else if ( iByteCount == 0 )
                {
                       if(strlen(buf)>0)
                       {
                           //do process with received data
                       }
                       else
                      printf("receive failed");
                       break;
                }
                else
                    printf("recv failed: ");
                    break;

            } while(iByteCount > 0);
}

Of course. Unless the socket is set non-block, recv() is a blocking call. Your condition is while(iByteCount > 0), but as long as the client stays connected and there are no errors, that will never happen*. This loop will just read everything the client sends, then keep waiting for more.

You need to process the data as you receive it. That could mean just checking each chunk for ! until you find it then breaking out of the loop.

* On linux, 0 will only happen if the client has disconnected, ie, the socket is defunct.

The send and recv code should look something like this

Code:

// send
char buff[10000];
size_t len = strlen(buff);
char *p = buff;
ssize_t n;
while ( len > 0 && (n=send(sock,p,len,0)) > 0 ) {
  p += n;
  len =- (size_t)n;
}
if ( len > 0 || n < 0 ) {
  // oops, something went wrong
}


// recv
char buff[10000];
size_t len = sizeof(buff);
char *p = buff;
ssize_t n;
while ( len > 0 && (n=recv(sock,p,len,0)) > 0 ) {
  p += n;
  len =- (size_t)n;
}
if ( len > 0 || n < 0 ) {
  // oops, something went wrong
}

Note that BOTH ends use the return result to determine how much data was transferred, and then uses that result to update a buffer pointer and adjust the amount of data remaining.

Originally Posted by MK27

Of course. Unless the socket is set non-block, recv() is a blocking call. Your condition is while(iByteCount > 0), but as long as the client stays connected and there are no errors, that will never happen

By "that will never happen" I meant the condition will never be untrue, lol, sorry for putting that badly.

Originally Posted by mahi

ya.,thanks it's working fine .
but there is another problem when sent/recv all data the loop will execute once and check (n & len value ) in this case that will be in -ve value after sent/ recv all data , so control goes to failed statement ,so how can i ?

This is a little confusing too, but it does not really matter exactly what you are trying to ask because no matter what:

- the ONLY way you can "identify whether all data are sent" is to check the return value of send() until the appropriate number of bytes have been sent, as in Salem's example.

- the ONLY way you can "identify whether all data are received" is to check the data. If the length of the data is predicable, you can do that by by checking the bytes received, the same way you do with send(); if the length of the data is not predictable, then you need to use some kind of protocol. Eg, you can use an "end of data" marker such as the ! you mentioned. Another way is to make the first four bytes an integer indicating the length of the remaining data, read that into a uint32_t, then read that many remaining bytes into your buffer.

Other than that, there is no magical way for the receiver to know if it has received everything that was sent, which is why networking always involves protocols (in fact, layers of them; there is information transmitted under the hood your UDP socket, using the UDP protocol, which is why it is a UDP socket, but that information is of no use to you and thus inaccessible). Obviously enough: the only communication between the sender and receiver is what happens over the socket. That's all the information you have at your disposal.

Well one common way is to send the size of the data in advance of the data.

For example, you could send a string reading
"Sending 5 bytes of data\n"

The receiver would read a line upto the first \n, then parse out 5 and then it would know how much data to expect.

The sender would then send "hello", and the receiver would then receive 5 bytes of "hello" and conclude that the transmission was complete.