#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>


int main(int argc, char *argv[]) {
    char *hostname = "www.cnn.com";
    char *port = "80";

    int idle = 60;
    int count = 6;
    int interval = 10;

    int sock;

    struct addrinfo hints, *ai0, *ai;

    int opt;
    socklen_t optsize;

    int r;


    for (argc = 1; argv[argc] != NULL; argc ++) {
        if (strcmp(argv[argc], "--idle") == 0) {
            argc ++;
            idle = atoi(argv[argc]);

        } else if (strcmp(argv[argc], "--count") == 0) {
            argc ++;
            count = atoi(argv[argc]);

        } else if (strcmp(argv[argc], "--interval") == 0) {
            argc ++;
            interval = atoi(argv[argc]);

        } else {
            printf("usage: %s [--idle X] [--count X] [--interval X]\n", argv[0]);
            exit(1);
        }
    }
 

    //
    // connect
    //

    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    if (getaddrinfo(hostname, port, &hints, &ai)) {
        printf("can't find %s: %s", hostname, gai_strerror(r));
        exit(1);
    }

    for (ai0 = ai; ai; ai = ai->ai_next) {
        sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
        if (sock < 0) {
            continue;
        }
        if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0) {
            close(sock);
            sock = -1;
            continue;
        }
        break;
    }

    if (sock < 0) {
        printf("cannot connect to %s:%s\n", hostname, port);
        exit(1);
    }


    // 
    // set the socket options
    //

    opt = 1;
    r = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt));
    if (r < 0) {
        printf("error enabling keepalive: %s\n", strerror(errno));
    }


    r = setsockopt(sock, ai->ai_protocol, TCP_KEEPIDLE, &idle, sizeof(idle));
    if (r < 0) {
        printf("error setting keepalive idle time to %d: %s\n", idle, strerror(errno));
    }
    opt = -1;
    optsize = sizeof(opt);
    r = getsockopt(sock, ai->ai_protocol, TCP_KEEPIDLE, &opt, &optsize);
    if (r < 0) {
        printf("error getting keepalive idle time: %s\n", strerror(errno));
    } else {
        printf("keepalive idle time: %d\n", opt);
    }


    r = setsockopt(sock, ai->ai_protocol, TCP_KEEPCNT, &count, sizeof(count));
    if (r < 0) {
        printf("error setting keepalive probe count to %d: %s\n", count, strerror(errno));
    }
    opt = -1;
    optsize = sizeof(opt);
    r = getsockopt(sock, ai->ai_protocol, TCP_KEEPCNT, &opt, &optsize);
    if (r < 0) {
        printf("error getting keepalive probe count: %s\n", strerror(errno));
    } else {
        printf("keepalive probe count: %d\n", opt);
    }


    r = setsockopt(sock, ai->ai_protocol, TCP_KEEPINTVL, &interval, sizeof(interval));
    if (r < 0) {
        printf("error setting keepalive probe interval to %d: %s\n", interval, strerror(errno));
    }
    opt = -1;
    optsize = sizeof(opt);
    r = getsockopt(sock, ai->ai_protocol, TCP_KEEPINTVL, &opt, &optsize);
    if (r < 0) {
        printf("error getting keepalive probe interval: %s\n", strerror(errno));
    } else {
        printf("keepalive probe interval: %d\n", opt);
    }


    while (1) {
        pause();
    }

    return 0;
}