Keep socket open in C

Question

I think this may be a simple solution I'm just over thinking. I'm writing an extremely basic chat program where the client and server takes turns sending a message. Right now I have it where it sends a message back and forth only once and the client closes the socket. The program doesn't have to have sockets open simultaneously, just as long as it can switch back and forth like a swing, rather than a real chat program where the it can take multiple inputs from both sides all at once.

Will a while loop in the client keep it open and what are the conditions of the while loop?

I've tried several different conditions and none of them worked... it just makes it hang. I've also tried commenting out some of the close() functions in the server code, but that didn't work either.

I also have a small issue of the received input printing gibberish, but I think it's because it's printing the memory addresses of the string array when there's nothing in it... I just can't remember how to shorten it. Lol.

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 PORT "3490"  // The port users will be connecting to

#define BACKLOG 10   // How many pending connections queue will hold

char input[20];
char *pointer;

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(void)
{
    int sockfd, new_fd;  // Listen on sock_fd, new connection on new_fd
    struct addrinfo hints, *servinfo, *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;

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE; // use my IP

    if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 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 = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                             p->ai_protocol)) == -1) {
            perror("server: 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(servinfo); // 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");

    sin_size = sizeof their_addr;

    while((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) > 0) {  // Main accept() loop

        if (new_fd == -1) {
            perror("accept");
            continue;
        }

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

        if (!fork()) { // this is the child process
            close(sockfd); // child doesn't need the listener

            char input[20];
            char *pointer;
            printf("Type in an server's input: ");
            scanf("%s", input);
            pointer = input;  //Will need to clean this up to be more effcient... later

            if (send(new_fd, pointer, strlen(input), 0) == -1) //Need to change the length to
                                                               //the actual length of the
                                                               //input... later.

                perror("send");
            close(new_fd);
            exit(0);
        }

        char Cinput[20];
        if ((recv(new_fd, Cinput, strlen(Cinput), 0)) == 0) { //NEW LINE ADDED HERE
            printf("No more messages");
        }

        if ((recv(new_fd, Cinput, strlen(Cinput), 0)) == -1) {
                perror("recv");
                exit(1);
        }

        printf("Server: received '%s'\n",Cinput);

        close(new_fd);  // Parent doesn't need this
    }
    return 0;
}

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 PORT "3490" // The port client will be connecting to

#define MAXDATASIZE 100 // 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];
    struct addrinfo hints, *servinfo, *p;
    /*
        This is what is in the struct

        struct addrinfo {
            int ai_flags; // AI_PASSIVE, AI_CANONNAME, etc.
            int ai_family; // AF_INET, AF_INET6, AF_UNSPEC
            int ai_socktype; // SOCK_STREAM, SOCK_DGRAM
            int ai_protocol; // Use 0 for "any"
            size_t ai_addrlen; // Size of ai_addr in bytes
            struct sockaddr *ai_addr; // struct sockaddr_in or _in6
            char *ai_canonname; // Full canonical hostname
            struct addrinfo *ai_next; // Linked list, next node
        };

        getaddrinfo() will return a pointer to this
    */
    int rv;
    char s[INET6_ADDRSTRLEN];

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

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

    if ((rv = getaddrinfo(argv[1], 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

    while(1)//NEW LINE ADDEDthis is getting the client to repeat asking for the input, but doesn't send it.
    {
        if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == 0) { //NEW LINE ADDED
               printf("Shutdown");
        }

        if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
            perror("recv");
            exit(1);
        }

        buf[numbytes] = '\0';

        printf("client: received '%s'\n",buf);

        char Cinput[20];
        char *pointer;
        printf("Type in an client's input: ");
        scanf("%s", Cinput);
        pointer = Cinput;
        if (send(sockfd, pointer, strlen(Cinput), 0) == -1)
        {
            perror("send");
            close(sockfd);
            exit(0);
        }
    }

    close(sockfd); //As soon as the client receives a message, it closes the socket.
    //We probably need a while loop in here in order to keep the socket open,
    //but what are the parameters for the while loop?
    return 0;
}

Answer 1

The following pseudocode will ensure that the same client and server can infinitely send messages to each other until one of them hangs up:

Client:

1. Create the socket.
2. connect to it.
3. recv data.
4. If recv returns 0, it means the other end has performed an orderly shutdown. Go to step 7.
5. send response.
6. Go to step 3.
7. Stop.

Server:

1. Create the socket.
2. bind the socket to an address.
3. Mark the socket as listening.
4. accept a connection.
5. If accepted connection is invalid, go to step 4.
6. send data.
7. recv response.
8. If recv returns 0, it means the other end has performed an orderly shutdown. Go to step 4 to accept a new connection.
9. Go to step 6.