firewall-knocker/client/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 <fcntl.h>
#include <arpa/inet.h>

#include "config.h"

int
main(void)
{
    int sockfd;
    struct addrinfo hints;
    struct addrinfo *servinfo;
    struct addrinfo *p;
    int rv;
    int connected;

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

    // Get address info (AKA resolv hostname)
    if ((rv = getaddrinfo(SERVER_ADDRESS, PORT, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // Cycle OUTER
    while (1) {
        int con;

        // Here we assume that we are not connected.
        connected = 0;

        printf("Connecting...\n");

        // Create a socket
        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;
            }

            break;
        }

        // If p is NULL, we didn't succeed to create a socket. This
        // should never happen
        if (p == NULL) {
            fprintf(stderr, "client: failed to connect\n");

            return 2;
        }

        // Set the socket to non-blocking so we can control the timeout value
        fcntl(sockfd, F_SETFL, O_NONBLOCK);

        // Start the connection (it usually won't succeed yet)
        con = connect(sockfd, p->ai_addr, p->ai_addrlen);

        // If connect() returned an error saying the connection is in progress
        if ((con < 0) && (errno == EINPROGRESS)) {
            // Cycle INNER1
            while (1) {
                struct timeval tv;
                int t;
                fd_set master;

                // Create an empty descriptor set, and add our socket to it
                FD_ZERO(&master);
                FD_SET(sockfd, &master);

                // Set the timeout value to SENDING_FREQ seconds
                tv.tv_sec = SENDING_FREQ;
                tv.tv_usec = 0;

                // Run the select()
                t = select(sockfd + 1, NULL, &master, NULL, &tv);

                if ((t < 0) && (errno != EINTR)) {
                    // Some serious error happened, let's exit
                    perror("select");

                    exit(1);
                } else if (t < 0) {
                    // select() was interrupted, lets restart the INNER1 cycle
                    printf("select() interrupted, continue\n");

                    continue;
                } else if (t > 0) {
                    size_t lon;
                    int valopt;

                    lon = sizeof(int);
                    if (getsockopt(sockfd,
                                   SOL_SOCKET, SO_ERROR,
                                   (void*)(&valopt), &lon) < 0) {
                        fprintf(stderr,
                                "Error in getsockopt() %d - %s\n",
                                errno, strerror(errno));
                        connected = 0;
                        sleep(SENDING_FREQ);

                        break;
                    }
                    // Check the value returned...
                    if (valopt) {
                        fprintf(stderr,
                                "Error in delayed connection() %d - %s\n",
                                valopt, strerror(valopt));
                        connected = 0;
                        sleep(SENDING_FREQ);

                        break;
                    }

                    printf("Connected with select().\n");
                    connected = 1;

                    break;
                } else if (t == 0) {
                    // Connection timed out, let's break out from INNER1
                    printf("connect() timed out.\n");
                    connected = 0;
                    close(sockfd);

                    break;
                }
            }
        } else if (con < 0) {
            // connect() error. Wait SENDING_FREQ seconds and try
            // again (restarting the OUTER cycle)

            // XXX error handling?
            printf("connect() error, retry\n");
            sleep(SENDING_FREQ);
            connected = 0;

            continue;
        } else if (con == 0) {
            // We are now connected. Usually we won't get here, but in
            // the select() loop above instead
            printf("Connected without select().\n");
            connected = 1;
        }

        if (connected) {
            // If we are connected, let's jump in the INNER2 cycle
            while (1) {
                fd_set read_fds;
                int t;
                struct timeval tv;
                char buf[MAXDATASIZE];

                // Create and empty descriptor set and add our socket
                FD_ZERO(&read_fds);
                FD_SET(sockfd, &read_fds);

                // Set the timeout value to SENDING_FREQ seconds
                tv.tv_sec = SENDING_FREQ;
                tv.tv_usec = 0;

                // Let's run the select()
                t = select(sockfd + 1, &read_fds, NULL, NULL, &tv);

                if ((t < 0) && (errno != EINTR)) {
                    // select() ran into an error, this is bad. Let's exit
                    perror("select");

                    exit(1);
                } else if (t < 0) {
                    // select() interrupted, try again by restarting
                    // the INNER2 cycle
                    printf("select() interrupted\n");

                    continue;
                } else if (t > 0) {
                    // We got some data from the server
                    size_t len;

                    printf("Data from server.\n");

                    len = recv(sockfd, &buf, MAXDATASIZE, 0);

                    if (len <= 0) {
                        // If the received data length is at most 0,
                        // we are disconnected, so break out from
                        // INNER2
                        printf("Closing connection.\n");
                        connected = 0;
                        close(sockfd);

                        break;
                    }
                }

                // If we arrive here, select() ran into timeout, so we
                // should send some data to the server.
                printf("Sending data to server\n");
                send(sockfd, "!\n", 2, 0);
            }
        }
    }

    // This should never happen, but if so, let's clean up after ourselved
    freeaddrinfo(servinfo);

    close(sockfd);

    return 0;
}