C echo server, doesnt work well after echoing a sentence - c

Question

while testing this code i figured out this echo server work well for one word.if try to echo a sentence server also echo it but after that it echo inputs with previous echoed sentence last word. i cleared buffers using memset but still get same problem. cannot understand where is the problem.
server code
#include<stdio.h>
#include<string.h> //strlen
#include<sys/socket.h>
#include<arpa/inet.h> //inet_addr
#include<unistd.h> //write
int main(int argc , char *argv[])
{
int socket_desc , client_sock , c , read_size;
struct sockaddr_in server , client;
char client_message[2000];
//Create socket
socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
puts("Socket created");
//Prepare the sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 8888 );
//Bind
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
//print the error message
perror("bind failed. Error");
return 1;
}
puts("bind done");
//Listen
listen(socket_desc , 3);
//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
//accept connection from an incoming client
client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
if (client_sock < 0)
{
perror("accept failed");
return 1;
}
puts("Connection accepted");
//Receive a message from client
memset(client_message, 0, sizeof(client_message));
while( (read_size = recv(client_sock , client_message , 2000 , 0)) > 0 )
{
//Send the message back to client
write(client_sock , client_message , strlen(client_message));
memset(client_message, 0, sizeof(client_message));
}
if(read_size == 0)
{
puts("Client disconnected");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}
return 0;
}
client code :
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<arpa/inet.h>
int main(int argc , char *argv[])
{
int sock;
struct sockaddr_in server;
char message[1000] , server_reply[2000];
//Create socket
sock = socket(AF_INET , SOCK_STREAM , 0);
if (sock == -1)
{
printf("Could not create socket");
}
puts("Socket created");
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 8888 );
//Connect to remote server
if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0)
{
perror("connect failed. Error");
return 1;
}
puts("Connected\n");
//keep communicating with server
while(1)
{
printf("Enter message : ");
//scanf("%s" , message);
fgets(message, sizeof(message), stdin);
//Send some data
if( send(sock , message , strlen(message) , 0) < 0)
{
puts("Send failed");
return 1;
}
//Receive a reply from the server
if( recv(sock , server_reply , 2000 , 0) < 0)
{
puts("recv failed");
break;
}
puts("Server reply :");
puts(server_reply);
memset(message, 0, sizeof(message));
memset(server_reply, 0, sizeof(server_reply));
}
close(sock);
return 0;
}
Sample outputs
Enter message : sample
Server reply :
sample
Enter message : sample test
Server reply :
sample test
Enter message : gamer
Server reply :
gamer
test
Enter message : pro
Server reply :
pro
r
test

Answer 1

Your problem is this line:
write(client_sock , client_message , strlen(client_message));
Your client does not send a \0 terminator. So if you first send a long string, then a short one then the short one will overwrite just the beginning. Change that to:
write(client_sock , client_message , read_size); // send exactly as much as you got
And on the client side print only as much as was received:
ssize_t answer_size;
if((answer_size = recv(sock , server_reply , sizeof(server_reply) , 0)) < 0)
{
puts("recv failed");
break;
}
printf("Server reply :\n%.*s\n", answer_size, server_reply);
Also please keep in mind that for implementation specific reasons you may or not get everything that was sent with the first recv and it is recommended to run it in a while loop (with nonblocking mode if nessesary). Same goes for send.

Answer 2

The send() and receive() functions are both blocking and will only return when the socket closes or a full buffer is processed. Your client code defines message[1000], while your server code waits for a client_message[2000] array before responding.
Unless you want to end up using select() or asynchronous I/O to recover the actual network-level messages you will need to either prefix the message with a length that allows you to limit the reads to the actual data, or to use a terminator and then process the incoming data character by character. OF these the most straight-forward is to include an explicit message length early into the stream at the start of each exchange.
The incorrect responses are because you reuse the sending buffer without clearing it. If you include a memset(message, 0, 1000) at the beginning of the while() you will avoid the problem.
The underlying problem is that your client will always send the entire buffer even if only a few characters contain data of value. The effect of this on your application will depend on the network speed, message frequency, number of parties in the landscape and host capacity to tolerate the inefficiency.