/*

 * Soft:        Perform a GET query to a remote HTTP/HTTPS server.

 *              Set a timer to compute global remote server response

 *              time.

 *

 * Part:        Main entry point.

 *

 * Authors:     Alexandre Cassen, <acassen@linux-vs.org>

 *

 *              This program is distributed in the hope that it will be useful,

 *              but WITHOUT ANY WARRANTY; without even the implied warranty of

 *              MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 *              See the GNU General Public License for more details.

 *

 *              This program is free software; you can redistribute it and/or

 *              modify it under the terms of the GNU General Public License

 *              as published by the Free Software Foundation; either version

 *              2 of the License, or (at your option) any later version.

 *

 * Copyright (C) 2001-2017 Alexandre Cassen, <acassen@gmail.com>

 */

#include "config.h"

/* system includes */

#include <sys/stat.h>

#include <sys/wait.h>

#include <stdio.h>

#include <sys/socket.h>

#include <arpa/inet.h>

/* keepalived includes */

#include "utils.h"

#include "signals.h"

/* genhash includes */

#include "include/main.h"

/* global var */

REQ *req = NULL;

int exit_code;

/* Terminate handler */

static void

sigend(__attribute__((unused)) void *v, __attribute__((unused)) int sig)

{

	/* register the terminate thread */

	thread_add_terminate_event(master);

}

/* Initialize signal handler */

static void

signal_init(void)

{

	signal_set(SIGHUP, sigend, NULL);

	signal_set(SIGINT, sigend, NULL);

	signal_set(SIGTERM, sigend, NULL);

	signal_ignore(SIGPIPE);

}

/* Usage function */

static void

usage(const char *prog)

{

	enum feat_hashes i;

	fprintf(stderr, VERSION_STRING);

	fprintf(stderr,

		"Usage:\n"

		"  %1$s -s server-address -p port -u url\n"

		"  %1$s -S -s server-address -p port -u url\n"

		"  %1$s -h\n" "  %1$s -r\n\n", prog);

	fprintf(stderr,

		"Commands:\n"

		"Either long or short options are allowed.\n"

		"  %1$s --use-ssl         -S       Use SSL connection to remote server.\n"

#ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_

		"  %1$s --use-sni         -I       Use SNI during SSL handshake (uses virtualhost setting; see -V).\n"

#endif

		"  %1$s --server          -s       Use the specified remote server address.\n"

		"  %1$s --port            -p       Use the specified remote server port.\n"

		"  %1$s --url             -u       Use the specified remote server url.\n"

		"  %1$s --use-virtualhost -V       Use the specified virtualhost in GET query.\n"

		"  %1$s --hash            -H       Use the specified hash algorithm.\n"

		"  %1$s --verbose         -v       Use verbose mode output.\n"

		"  %1$s --help            -h       Display this short inlined help screen.\n"

		"  %1$s --release         -r       Display the release number.\n"

		"  %1$s --fwmark          -m       Use the specified FW mark.\n",

		prog);

	fprintf(stderr, "\nSupported hash algorithms:\n");

	for (i = hash_first; i < hash_guard; i++)

		fprintf(stderr, "  %s%s\n",

			hashes[i].id, i == hash_default ? " (default)": "");

}

/* Command line parser */

static int

parse_cmdline(int argc, char **argv, REQ * req_obj)

{

	int c;

	enum feat_hashes i;

	struct addrinfo hint, *res = NULL;

	int ret;

	void *ptr;

	char *endptr;

	long port_num;

	memset(&hint, '\0', sizeof hint);

	hint.ai_family = PF_UNSPEC;

	hint.ai_flags = AI_NUMERICHOST;

	struct option long_options[] = {

		{"release",		no_argument,       0, 'r'},

		{"help",		no_argument,       0, 'h'},

		{"verbose",		no_argument,       0, 'v'},

		{"use-ssl",		no_argument,       0, 'S'},

#ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_

		{"use-sni",		no_argument,       0, 'I'},

#endif

		{"server",		required_argument, 0, 's'},

		{"hash",		required_argument, 0, 'H'},

		{"use-virtualhost",	required_argument, 0, 'V'},

		{"port",		required_argument, 0, 'p'},

		{"url",			required_argument, 0, 'u'},

		{"fwmark",		required_argument, 0, 'm'},

		{0, 0, 0, 0}

	};

	/* Parse the command line arguments */

	while ((c = getopt_long (argc, argv, "rhvSs:H:V:p:u:m:"

#ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_

							       "I"

#endif

				  , long_options, NULL)) != EOF) {

		switch (c) {

		case 'r':

			fprintf(stderr, VERSION_STRING);

			break;

		case 'h':

			usage(argv[0]);

			break;

		case 'v':

			req_obj->verbose = 1;

			break;

		case 'S':

			req_obj->ssl = 1;

			break;

#ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_

		case 'I':

			req_obj->sni = 1;

			break;

#endif

		case 's':

			if ((ret = getaddrinfo(optarg, NULL, &hint, &res)) != 0){

				fprintf(stderr, "server should be an IP, not %s\n", optarg);

				return CMD_LINE_ERROR;

			} else {

				if(res->ai_family == AF_INET) {

					req_obj->dst = res;

					ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;

					inet_ntop (res->ai_family, ptr, req_obj->ipaddress, INET_ADDRSTRLEN);

				} else if (res->ai_family == AF_INET6) {

					req_obj->dst = res;

					ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;

					inet_ntop (res->ai_family, ptr, req_obj->ipaddress, INET6_ADDRSTRLEN);

				} else {

					fprintf(stderr, "server should be an IP, not %s\n", optarg);

					return CMD_LINE_ERROR;

				}

			}

			break;

		case 'H':

			for (i = hash_first; i < hash_guard; i++)

				if (!strcasecmp(optarg, hashes[i].id)) {

					req_obj->hash = i;

					break;

				}

			if (i == hash_guard) {

				fprintf(stderr, "unknown hash algorithm: %s\n", optarg);

				return CMD_LINE_ERROR;

			}

			break;

		case 'V':

			req_obj->vhost = optarg;

			break;

		case 'p':

			port_num = strtol(optarg, &endptr, 10);

			if (*endptr || port_num <= 0 || port_num > 65535) {

				fprintf(stderr, "invalid port number '%s'\n", optarg);

				return CMD_LINE_ERROR;

			}

			req_obj->addr_port = htons(port_num);

			break;

		case 'u':

			req_obj->url = optarg;

			break;

		case 'm':

#ifdef _WITH_SO_MARK_

			req_obj->mark = (unsigned)strtoul(optarg + strspn(optarg, " \t"), &endptr, 10);

			if (*endptr || optarg[strspn(optarg, " \t")] == '-') {

				fprintf(stderr, "invalid fwmark '%s'\n", optarg);

				return CMD_LINE_ERROR;

			}

#else

			fprintf(stderr, "genhash built without fwmark support\n");

			return CMD_LINE_ERROR;

#endif

			break;

		default:

			usage(argv[0]);

			return CMD_LINE_ERROR;

		}

	}

	/* check unexpected arguments */

	if (optind < argc) {

		fprintf(stderr, "Unexpected argument(s): ");

		while (optind < argc)

			printf("%s ", argv[optind++]);

		printf("\n");

		return CMD_LINE_ERROR;

	}

	return CMD_LINE_SUCCESS;

}

int

main(int argc, char **argv)

{

	char *url_default = "/";

#ifdef _MEM_CHECK_

	mem_log_init("Genhash", "Genhash process");

	enable_mem_log_termination();

#endif

	/* Allocate the room */

	req = (REQ *) MALLOC(sizeof (REQ));

	/* Preset (potentially) non-zero defaults */

	req->hash = hash_default;

	/* Command line parser */

	if (!parse_cmdline(argc, argv, req)) {

		FREE(req);

		exit(1);

	}

	/* Check minimum configuration need */

	if (!req->dst && !req->addr_port && !req->url) {

		freeaddrinfo(req->dst);

		FREE(req);

		exit(1);

	}

	if(!req->url)

		req->url = url_default;

	/* Init the reference timer */

	req->ref_time = timer_long(timer_now());

	DBG("Reference timer = %lu\n", req->ref_time);

	/* Init SSL context */

	init_ssl();

	/* Create the master thread */

	master = thread_make_master();

	/* Signal handling initialization  */

	signal_init();

	/* Register the GET request */

	init_sock();

	/*

	 * Processing the master thread queues,

	 * return and execute one ready thread.

	 * Run until error, used for debuging only.

	 * Note that not calling launch_thread_scheduler()

	 * does not activate SIGCHLD handling, however,

	 * this is no issue here.

	 */

	process_threads(master);

	/* Finalize output informations */

	if (req->verbose)

		printf("Global response time for [%s] =%lu\n",

			    req->url, req->response_time - req->ref_time);

	/* exit cleanly */

	thread_destroy_master(master);

	SSL_CTX_free(req->ctx);

	free_sock(sock);

	freeaddrinfo(req->dst);

	FREE(req);

	exit(exit_code);

}