CR/LF condition check in C

I am testing my TCP echo server, with Telnet, I can see that the client connects to the server and sends a charcter and in return the server returns a string to the client.

Now my problem is by using this recv() in a infinite loop I 开发者_StackOverflow中文版can only receive one character (even though the client tends to send a string).

This is how I am doing to receive the datagram from the client

TCP SERVER

while(1)
{
    socket = accept(server_socket, (struct sockaddr *)&client_address, (socklen_t)&client_length);

    recv(socket, recv_buffer, sizeof(recv_buffer), 0);
    printf("Received string from client is %s", recv_buffer);

    /*then I send my string to the client*/
    send(socket, send_buffer, sizeof(send_buffer), 0);
}

Here is my problem that my recv() routine reads only one character even though the client wants to send a whole string. Is there a way how I can make this recv() routine wait before it receives all the characters from the client and then send a response to the client.

Any suggestions would be appreciated

Regards

Well, you are doing something wrong. Look at the definition of recv:

int recv(int s, void *buf, size_t len, int flags); 

So it recieves len amount of bytes. You passed sizeof(recv_buffer) as the len parameter. Now I'm guessing recv_buffer is defined as a char*. Getting the sizeof of a pointer means that you get the amount of bytes necessary to store that pointer, instead of the memory it points to.

Do something like this instead:

const int buf_len = 100;
char recv_buffer[buf_len];

recv(socket, recv_buffer, buf_len, 0);
printf("Received string from client is %s", recv_buffer);   

You need to build up the string you are receiving yourself in a loop, using the return value of recv() to find how many bytes you actually got. TCP/IP does not guarantee that all the data sent with one call to send() can be received with one call to recv(). And you must examine the return value of every sockets function you call to check for actual lengths sent/received, and for errors.

Your code is a disaster (sorry for being blunt, but it is best to be straight).

recv() returns the number of bytes actually read. Not only that but it will not clear the previous contents of the buffer and it will fill up right to the the end of the buffer if there is data available. All this means that you cannot treat the content of the buffer as a null terminated string.

You need to do something like:

ssize_t bytesRead = 1;
char recv_buffer[SOME_SIZE];

while (bytesRead > 0)
{
    int bytesRead = recv(socket, recv_buffer, SOME_SIZE, 0);
    if (bytesRead > 0)
    {
        // do something with the bytes.  Note you cannot guarantee that the buffer contains a valid C string.
    }    
}
if (bytesRead == -1)
{
    // report error from errno
}
else
{
    // bytesRead == 0 have reached end of file (i.e. socket closed at other end)
}

There is no way to get recv to wait until the buffer is full before returning. It will wait until there are some bytes available and then return. The same applies to send by the way. You can't assume with one call to send that all of your bytes have actually been sent. You need to put send in a loop too:

ssize_t totalBytesWritten = 0;
ssize_t bytesWritten = 0;
while (bytesWritten >= 0 && totalBytesWritten < bytesToWrite)
{
    bytesWritten = send(socket, sendBuffer + totalBytesWritten, bytesToWrite - totalBytesWritten, 0);
    if (bytesWritten > 0)
    {
        totalBytesWritten += bytesWritten;
    }
}
if (bytesWritten == -1)
{
    // error
}