Why tcp server receives one buffer if Client sends multiple buffer without sleep?

Question

My Client is sending to the server correctly if I send buffers after some interval. But if I send messages without interval server receives one buffer.For example if i send two buffers "message1" and "message2" and puts 1 second sleep between this two sending operation server receives 2 buffers and prints message1 "\\n" message2. But if I send these 2 buffers without sleep server gets 1 buffer and prints message1message2. I can't understand why it is happening.My server and client code are as follows.

server.c

            #include<stdio.h>
            #include<string.h>    //strlen
            #include<stdlib.h>    //strlen
            #include<sys/socket.h>
            #include<arpa/inet.h> //inet_addr
            #include<unistd.h>    //write

            #include<pthread.h> //for threading , link with lpthread

            void *connection_handler(void *);

            int main(int argc, char *argv[])
            {
                int socket_desc, new_socket, c, *new_sock;
                struct sockaddr_in server, client;
                char *message;

                //Create socket
                socket_desc = socket(AF_INET, SOCK_STREAM, 0);
                if (socket_desc == -1)
                {
                    printf("Could not create socket");
                }

                //Prepare the sockaddr_in structure
                server.sin_family = AF_INET;
                server.sin_addr.s_addr = INADDR_ANY;
                server.sin_port = htons(10240);

                //Bind
                if (bind(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
                {
                    puts("bind failed");
                    return 1;
                }
                puts("bind done");

                //Listen
                listen(socket_desc, 3);

                //Accept and incoming connection
                puts("Waiting for incoming connections...");
                c = sizeof(struct sockaddr_in);
                while ((new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)))
                {
                    puts("Connection accepted");

                    //Reply to the client
            //      message = "Hello Client , I have received your connection. And now I will assign a handler for you\n";
            //      write(new_socket, message, strlen(message));

                    pthread_t sniffer_thread;
                    new_sock = malloc(1);
                    *new_sock = new_socket;

                    if (pthread_create(&sniffer_thread, NULL, connection_handler, (void*)new_sock) < 0)
                    {
                        perror("could not create thread");
                        return 1;
                    }

                    //Now join the thread , so that we dont terminate before the thread
                    //pthread_join( sniffer_thread , NULL);
                    puts("Handler assigned");
                }

                if (new_socket<0)
                {
                    perror("accept failed");
                    return 1;
                }
                while (1);
                return 0;
            }



            void *connection_handler(void *socket_desc)
            {
                //Get the socket descriptor
                int sock = *(int*)socket_desc;
                int read_size;
                char *message, client_message[2000];

                //Send some messages to the client
            //  message = "Greetings! I am your connection handler\n";
            //  write(sock, message, strlen(message));
            // 
            //  message = "Now type something and i shall repeat what you type \n";
            //  write(sock, message, strlen(message));

                //Receive a message from client
                while ((read_size = recv(sock, client_message, 2000, 0)) > 0)
                {
                    puts(client_message);
                    //Send the message back to client
                    //write(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");
                }

                //Free the socket pointer
                free(socket_desc);

                return 0;
            }

client.c

            #include<stdio.h>
            #include<string.h>    //strlen
            #include<sys/socket.h>
            #include<arpa/inet.h> //inet_addr

            int main(int argc, char *argv[])
            {
                int socket_desc;
                struct sockaddr_in server;
                char *message, server_reply[2000];

                //Create socket
                socket_desc = socket(AF_INET, SOCK_STREAM, 0);
                if (socket_desc == -1)
                {
                    printf("Could not create socket");
                }

                server.sin_addr.s_addr = inet_addr("192.168.246.26");
                server.sin_family = AF_INET;
                server.sin_port = htons(10240);

                //Connect to remote server
                if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
                {
                    puts("connect error");
                    return 1;
                }

                puts("Connected\n");

                //Send some data
                message = "nayan";
                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "Mazhar vai";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "Sarwar vai";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "joy";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "sumon";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "rahim";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "karim";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }

                /*sleep(1);*/
                message = NULL;
                message = "jamal";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "kamal";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/ 
                message = NULL;
                message = "salam";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                //Receive a reply from the server
            //  if (recv(socket_desc, server_reply, 2000, 0) < 0)
            //  {
            //      puts("recv failed");
            //  }
            //  puts("Reply received\n");
            //  puts(server_reply);

                return 0;
            }

Answer 1

TCP is a streaming protocol (as indicated by the use of SOCK_STREAM ). That means there are no packet beginnings or ends, it's all just a single stream of bytes. It also means that a single receive call may read less than was sent using a single transmit call, or what was sent with multiple (including a trailing partial) transmit calls.

To handle it you need to come up with a higher-level protocol to put on top of TCP. It either needs to contain the length of the data being sent (in a fixed-length format), or you need to have some other way to know the beginning or at least the end of a message.