Sending data from server to client socket programming

Question

I have just started learning socket programming.

Currently the server and the client are on the same workstation and everything seems to work. The server is running in c programming and my client is an android program. I managed to have a one way connection, sending data from client to server. I would like to send some string back to client.

Please advice me.

void *connection_handler(void *);

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

    //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( 7800 );

    //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 and incoming connection
    puts("Waiting for incoming connections...");
    c = sizeof(struct sockaddr_in);
    pthread_t thread_id;

    while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
    {
        puts("Connection accepted");

        if( pthread_create( &thread_id , NULL ,  connection_handler , (void*) &client_sock) < 0)

        {
            perror("could not create thread");
            return 1;
        }

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

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

    return 0;
}

/*
 * This will handle connection for each client
 * */
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 )
    {
        //end of string marker
        client_message[read_size] = '\0';

        printf("%s\n", client_message);

        //Send the message back to client
        write(sock , client_message , strlen(client_message));

        //clear the message buffer
        memset(client_message, 0, 2000);


    }

    if(read_size == 0)
    {
        //puts("Client disconnected");

        //fflush(stdout);
    }
    else if(read_size == -1)
    {
        perror("recv failed");
    }

    return 0;
}

I can see a few problems and potential problems in your code, but as long as only one client is connected at a time then there should not be any problems with the transmissions to or from the client. — Some programmer dude
– Some programmer dude, Commented Mar 19, 2018 at 13:50
@Someprogrammerdude is hinting at this: '(void*) &client_sock' - think about what heppens if multiple clients attempt connections 'simultaneously'.... — Martin James
– Martin James, Commented Mar 19, 2018 at 17:48
If all 2000 bytes are recv'd, this: 'client_message[read_size] = '\0';' will write out-of-bounds. — Martin James
– Martin James, Commented Mar 19, 2018 at 17:49
@MartinJames That's why I added the note about only one client at a time connecting. — Some programmer dude
– Some programmer dude, Commented Mar 19, 2018 at 17:50

Andrea Grillo · Accepted Answer · 2018-03-20 22:21:05Z

There are different ways to transmit data to another socket and it doesn't matter if it's either a server or a client.

write

As you did in your code, you can use the system call:

ssize_t write(int fd, const void *buf, size_t count);

It writes from the buf to the file related to the file descriptor fd. The return value will tell you if the message was sent correctly.

send, sendto, sendmsg

This is the second way you can send data to a socket. The only difference between write and send is the argument flags:

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

but if you set flag to 0, write and send will work in the same way. sendto and sendmsg are quite different from send because they have more arguments. You can get all information from man pages available online or in Linux.

http://man7.org/linux/man-pages/man2/send.2.html

ensc · Accepted Answer · 2018-03-20 22:51:57Z

while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )

is wrong; you probably want to check >= 0 or (even better) express this in another way.

The lone

write(sock , message , strlen(message));

is not good:

you should check the error code
it will be very difficult for the receiver to split the result.
write() will kill your program with SIGPIPE when the other end has been closed

I suggest something like

bool send_data(int fd, void const *data, size_t len) 
{
    while (len > 0) {
        ssize_t l = send(fd, data, len, MSG_NOSIGNAL);

        if (l > 0) {
            data += l;
            len -= l;
        } else if (l == 0) {
            fprintf(stderr, "this is ugly and can not happen...\n");
            break;
        } else if (errno == EINTR) {
            continue;
        } else {
            perror("send()");
            break;
        }
    }

    return len == 0;
}

and for string datatypes

bool send_string(int fd, char const *str)
{
    size_t l = strlen(str);
    uint32_t  l_be = htobe32(l);

    if ((uint32_t)(l) != l)
        return false;

    return (send_data(fd, &l_be, sizeof l_be) &&
            send_data(fd, str, l));
}

For receiving, you can implement recv_data() similarly to send_data() above. Depending on your memory allocation strategy, you can implement either

bool recv_string(int fd, char *str, size_t max_len, size_t *len)
{
    uint32_t  l_be;
    size_t l;

    if (!recv_data(fd, &l_be, sizeof l_be))
        return false;

    l = be32toh(l_be);
    if (l >= max_len)
        return false;

    if (!recv_data(fd, str, l))
        return false;

    str[l] = '\0';

    if (len)
        *len = l;

    return true;   
}

or write something which malloc() memory for the received data after reading the length.

Now, you can do on one side:

if (!send_string(fd, "foo") ||
    !send_string(fd, "bar") ||
    !recv_string(fd, resp, sizeof resp, NULL))
       error();

and on the other one

if (!recv_string(fd, req0, sizeof req0, NULL) ||
    !recv_string(fd, req1, sizeof req1, NULL) ||
    !send_string(fd, handle_request(req0, req1)))
        error();

Collectives™ on Stack Overflow

Sending data from server to client socket programming

2 Answers 2

write

send, sendto, sendmsg

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

write

send, sendto, sendmsg

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related