Host and client aren't able to communicate in my chat program, using select()

Question

I am attempting to write a simple chat program where one user can connect to a host. The two should be able to talk to each other (they might interrupt each other but that is ok). I am having difficulties with select(). Here is the code:

client.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define MAXDATASIZE 1024 // max number of bytes we can get at once 

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa) {
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*) sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*) sa)->sin6_addr);
}

int main(int argc, char *argv[]) {
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    char buffer[1024];
    char *buff;
    struct addrinfo hints, *servinfo, *p;
    int rv;
    char s[INET6_ADDRSTRLEN];
    char *port;

    int num;

    struct timeval tv;

    //select data
    fd_set rfds;
    fd_set wfds;
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);


    if (argc != 2) {
        fprintf(stderr, "usage: client port\n");
        exit(1);
    }

    port = argv[1];

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if ((rv = getaddrinfo("localhost", port, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // loop through all the results and connect to the first we can
    for (p = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                p->ai_protocol)) == -1) {
            perror("client: socket");
            continue;
        }

        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("client: connect");
            continue;
        }

        break;
    }

    if (p == NULL) {
        fprintf(stderr, "client: failed to connect\n");
        return 2;
    }

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *) p->ai_addr),
            s, sizeof s);
    printf("client: connecting to %s\n", s);

    freeaddrinfo(servinfo); // all done with this structure



    FD_SET(sockfd, &rfds);
    FD_SET(sockfd, &wfds);

    if (select(sockfd + 1, &rfds, &wfds, NULL, &tv) < 0) {
        perror("select");
        return -1;
    }

    if (FD_ISSET(sockfd, &wfds)) {
        while (1) {
            fgets(buffer, MAXDATASIZE - 1, stdin);
            if ((send(sockfd, buffer, strlen(buffer), 0)) == -1) {
                fprintf(stderr, "Failure Sending Message\n");
                close(sockfd);
                exit(1);
            } else {
                printf("Message being sent: %s\n", buffer);
                break;
            }
        }
    }

    if (FD_ISSET(sockfd, &rfds)) {
        while (1) {
            if ((num = recv(sockfd, buffer, 10240, 0)) == -1) {
                //fprintf(stderr,"Error in receiving message!!\n");
                perror("recv");
                exit(1);
            } else if (num == 0) {
                printf("Connection closed\n");
                return 0;
            }
            //  num = recv(client_fd, buffer, sizeof(buffer),0);
            buffer[num] = '\0';
            printf("Message received: %s\n", buffer);
            break;
        }
    }

    close(sockfd);

    return 0;
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>

#define BACKLOG 10   // how many pending connections queue will hold
#define MAXDATASIZE 100 // max number of bytes we can get at once 

void sigchld_handler(int s) {
    while (waitpid(-1, NULL, WNOHANG) > 0);
}

// get sockaddr, IPv4 or IPv6:

void *get_in_addr(struct sockaddr *sa) {
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*) sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*) sa)->sin6_addr);
}

int main(int argc, char *argv[]) {
    int sockfd; // set up socket
    int new_sockfd; //  new socket after connection
    struct addrinfo hints, *results, *p;
    struct sockaddr_storage their_addr; // connector's address information
    socklen_t sin_size;
    struct sigaction sa;
    int yes = 1;
    char s[INET6_ADDRSTRLEN];
    int rv;
    int i;

    struct timeval tv;

    int num;
    char buffer[10241];

    int nsock;

    char buf[MAXDATASIZE];

    int numbytes;
    char *port;

    //select data
    fd_set rfds;
    fd_set wfds;
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);

    /* validate command-line arguments */
    if (argc != 2) {
        fprintf(stderr, "Usage: %s port\n", argv[0]);
        exit(1);
    }

    tv.tv_sec = 100;
    tv.tv_usec = 0;

    /* only argument to port number (./sc [port])*/
    port = argv[1];

    bzero(&hints, sizeof (struct addrinfo));


    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE; // any IP

    if ((rv = getaddrinfo(NULL, port, &hints, &results)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // loop through all the results and bind to the first we can
    for (p = results; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                p->ai_protocol)) == -1) {
            perror("1: socket");
            continue;
        }

        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
                sizeof (int)) == -1) {
            perror("setsockopt");
            exit(1);
        }

        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }

        break;
    }

    if (p == NULL) {
        fprintf(stderr, "server: failed to bind\n");
        return 2;
    }


    freeaddrinfo(results); // all done with this structure

    if (listen(sockfd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

    printf("server: waiting for connections...\n");

    while (1) { // main accept() loop
        sin_size = sizeof their_addr;
        new_sockfd = accept(sockfd, (struct sockaddr *) &their_addr, &sin_size);
        if (new_sockfd == -1) {
            perror("accept");
            continue;
        }

        //get the clients info
        inet_ntop(their_addr.ss_family,
                get_in_addr((struct sockaddr *) &their_addr),
                s, sizeof s);
        printf("server: got connection from %s\n", s);


        FD_SET(new_sockfd, &rfds);
        FD_SET(new_sockfd, &wfds);

        if (select(new_sockfd + 1, &rfds, &wfds, NULL, &tv) < 0) {
            perror("select");
            return -1;
        }

        if (FD_ISSET(new_sockfd, &rfds))
            while (1) {
                if ((num = recv(new_sockfd, buffer, 10240, 0)) == -1) {
                    //fprintf(stderr,"Error in receiving message!!\n");
                    perror("recv");
                    exit(1);
                } else if (num == 0) {
                    printf("Connection closed\n");
                    return 0;
                }
                //  num = recv(client_fd, buffer, sizeof(buffer),0);
                buffer[num] = '\0';
                printf("Message received: %s\n", buffer);
                break;
            }


        if (FD_ISSET(new_sockfd, &wfds))
            while (1) {
                fgets(buffer, MAXDATASIZE - 1, stdin);
                if ((send(new_sockfd, buffer, strlen(buffer), 0)) == -1) {
                    fprintf(stderr, "Failure Sending Message\n");
                    close(new_sockfd);
                    exit(1);
                } else {
                    printf("Message being sent: %s\n", buffer);
                    break;
                }
            }

    } //Outer While

    close(new_sockfd); // parent doesn't need this
    return 0;
}

The host and client aren't able to communicate. Can anyone tell me where the issue is?

Answer 1

You need to call select() inside of the loops, not outside. Also, you have to reset the fd_set and timeval structs each time you call select().