/*
 * Copyright (c) 2010-2011, Red Hat, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND RED HAT, INC. DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RED HAT, INC. BE LIABLE
 * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * Author: Jan Friesse <jfriesse@redhat.com>
 */

#include <sys/types.h>

#include <sys/time.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <err.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#ifdef __CYGWIN__
#include <windows.h>
#endif

#include "logging.h"
#include "util.h"

/*
 * Function prototypes
 */
#ifdef __CYGWIN__
static int	util_cygwin_gettimeofday(struct timeval *tv, struct timezone *tz);
#endif

static void	util_gen_id(char *id, size_t len, const struct ai_item *ai_item,
    const struct sockaddr_storage *sas);

static void	util_gen_id_add_sas(char *id, size_t len, size_t *pos,
    const struct sockaddr_storage *sas);

/*
 * Functions implementation
 */

#ifdef __CYGWIN__
/*
 * cygwin version of gettimeofday but with microseconds precision. Uses windows Performance
 * Counters to achieve precision if possible, otherwise cygwin gettimeofday implementation
 * is used.
 * Return 0 on success, otherwise -1.
 */
int
util_cygwin_gettimeofday(struct timeval *tv, struct timezone *tz)
{
	/* Frequency of performance counter */
	static LARGE_INTEGER freq;
	/* Offset of starting pc */
	static LARGE_INTEGER perf_count_offset;
	/* Actual pc */
	static LARGE_INTEGER perf_count;
	/* Microsenconds base time */
	static uint64_t us_base = 0;
	/* Function was not called yet */
	static int initialized = 0;
	/* If not used pf, fallback to gettimeofday implementation */
	static BOOL use_pf = 0;
	/* Tmp timeval */
	struct timeval tv2;
	/* Diff between offset pc and actual pc */
	int64_t perf_diff;
	/* Actual time in microseconds */
	uint64_t us;
	/* Time in microseconds returned by gettimeofday */
	uint64_t us_ref;

	if (!initialized) {
		initialized = 1;
		use_pf = QueryPerformanceFrequency(&freq);
		if (use_pf) {
			QueryPerformanceCounter(&perf_count_offset);
			gettimeofday(&tv2, tz);
			us_base = tv2.tv_sec * (uint64_t)1000000 + tv2.tv_usec;
		}
	}

	if (use_pf) {
		QueryPerformanceCounter(&perf_count);
	} else {
		return (gettimeofday(tv, tz));
	}

	perf_diff = perf_count.QuadPart - perf_count_offset.QuadPart;
	us = ((double)perf_diff / (double)freq.QuadPart) * 1000000.0 + us_base;

	gettimeofday(&tv2, tz);
	us_ref = tv2.tv_sec * (uint64_t)1000000 + tv2.tv_usec;

	if (util_u64_absdiff(us, us_ref) > (uint64_t)1000000) {
		us_base = us = us_ref;
		perf_count_offset.QuadPart = perf_count.QuadPart;
	}

	tv->tv_sec = us / (uint64_t)1000000;
	tv->tv_usec = us % (uint64_t)1000000;

	return (0);
}
#endif /* __CYGWIN__ */

/*
 * Returns absolute value of n
 */
double
util_fabs(double n)
{

	return (n < 0 ? -n : n);
}

/*
 * generate random ID from current pid, random data from random(3) and optionally addresses ai_item
 * and sas. ID is stored in id with maximum length len.
 */
static void
util_gen_id(char *id, size_t len, const struct ai_item *ai_item,
    const struct sockaddr_storage *sas)
{
	pid_t pid;
	size_t pos;

	/*
	 * First fill item with some random data
	 */
	for (pos = 0; pos < len; pos++) {
#if defined(__FreeBSD__) || defined(__OPENBSD__)
		id[pos] = (unsigned char)arc4random_uniform(UCHAR_MAX);
#else
		id[pos] = (unsigned char)random();
#endif
	}

	pos = 0;

	if (pos + sizeof(pid) < len) {
		/*
		 * Add PID
		 */
		pid = getpid();
		memcpy(id, &pid, sizeof(pid));

		pos += sizeof(pid);
	}

	/*
	 * Add sas from ai_item
	 */
	if (ai_item != NULL) {
		util_gen_id_add_sas(id, len, &pos, &ai_item->sas);
	}

	if (sas != NULL) {
		util_gen_id_add_sas(id, len, &pos, sas);
	}
}

/*
 * Add IP address from sas to id with length len to position pos. Also adjust pos to position after
 * added item.
 */
static void
util_gen_id_add_sas(char *id, size_t len, size_t *pos, const struct sockaddr_storage *sas)
{
	void *addr_pointer;
	size_t addr_len;

	switch (sas->ss_family) {
	case AF_INET:
		addr_pointer = &(((struct sockaddr_in *)sas)->sin_addr.s_addr);
		addr_len = sizeof(struct in_addr);
		break;
	case AF_INET6:
		addr_pointer = &(((struct sockaddr_in6 *)sas)->sin6_addr.s6_addr);
		addr_len = sizeof(struct in6_addr);
		break;
	default:
		DEBUG_PRINTF("Unknown ss family %d", sas->ss_family);
		errx(1, "Unknown ss family %d", sas->ss_family);
	}

	if (*pos + addr_len < len) {
		memcpy(id + *pos, addr_pointer, addr_len);
		*pos += addr_len;
	}
}

/*
 * Generate client id. Client id has length CLIENTID_LEN and takes only local address.
 */
void
util_gen_cid(char *client_id, const struct ai_item *local_addr)
{
	util_gen_id(client_id, CLIENTID_LEN, local_addr, NULL);

	DEBUG2_HEXDUMP("generated CID: ", client_id, CLIENTID_LEN);
}

/*
 * Generate session id. Session id has length SESSIONID_LEN and takes local and remote addresses.
 */
void
util_gen_sid(char *session_id)
{
	util_gen_id(session_id, SESSIONID_LEN, NULL, NULL);

	DEBUG2_HEXDUMP("generated SESID: ", session_id, SESSIONID_LEN);
}

/*
 * Return current time stamp saved in timeval structure.
 */
struct timeval
util_get_time(void)
{
	struct timeval tv;

#ifdef __CYGWIN__
	util_cygwin_gettimeofday(&tv, NULL);
#else
	gettimeofday(&tv, NULL);
#endif

	return (tv);
}

/*
 * Initialize random number generator.
 */
void
util_random_init(const struct sockaddr_storage *local_addr)
{
	unsigned int seed;
	unsigned int i;

	seed = time(NULL) + getpid();

	for (i = 0; i < af_sas_len(local_addr); i++) {
		seed += ((uint8_t *)local_addr)[i];
	}

	srandom(seed);
}

/*
 * Returns abs(t1 - t2) in miliseconds.
 */
uint64_t
util_time_absdiff(struct timeval t1, struct timeval t2)
{
	uint64_t u64t1, u64t2, tmp;

	u64t1 = t1.tv_usec / 1000 + t1.tv_sec * 1000;
	u64t2 = t2.tv_usec / 1000 + t2.tv_sec * 1000;

	if (u64t2 > u64t1) {
		tmp = u64t1;
		u64t1 = u64t2;
		u64t2 = tmp;
	}

	return (u64t1 - u64t2);
}

/*
 * Return abs value of (t2 - t1) in ms double precission.
 */
double
util_time_double_absdiff(struct timeval t1, struct timeval t2)
{
	return (util_time_double_absdiff_us(t1, t2) / 1000.0);
}

/*
 * Return abs value of (t2 - t1) in ns (nano seconds) double precission.
 */
double
util_time_double_absdiff_ns(struct timeval t1, struct timeval t2)
{
	return (util_time_double_absdiff_us(t1, t2) * 1000.0);
}

/*
 * Return abs value of (t2 - t1) in us (micro seconds) double precission.
 */
double
util_time_double_absdiff_us(struct timeval t1, struct timeval t2)
{
	double dt1, dt2, tmp;

	dt1 = t1.tv_usec + t1.tv_sec * UTIL_NSINMS;
	dt2 = t2.tv_usec + t2.tv_sec * UTIL_NSINMS;

	if (dt2 > dt1) {
		tmp = dt1;
		dt1 = dt2;
		dt2 = tmp;
	}

	return (dt1 - dt2);
}

/*
 * Return standard deviation based on m2 value and number of items n. Value is rounded to 0.001.
 */
double
util_ov_std_dev(double m2, uint64_t n)
{
	return (util_u64sqrt((uint64_t)util_ov_variance(m2, n)));
}

/*
 * On-line algorithm for compute variance.
 * Based on Donald E. Knuth (1998). The Art of Computer Programming, volume 2: p. 232.
 * function updats mean and m2. x is new value and n is absolute number of all items.
 */
void
util_ov_update(double *mean, double *m2, double x, uint64_t n)
{
	double delta;

	delta = x - *mean;
	*mean = *mean + delta / n;
	*m2 = *m2 + delta * (x - *mean);
}

/*
 * Return variance based on m2 value and number of items n.
 */
double
util_ov_variance(double m2, uint64_t n)
{
	return ((n > 1) ? (m2 / (n - 1)) : 0.0);
}

/*
 * Return number of miliseconds from timeval structure
 */
uint64_t
util_tv_to_ms(struct timeval t1)
{
	uint64_t u64;

	u64 = t1.tv_usec / 1000 + t1.tv_sec * 1000;

	return (u64);
}

/*
 * Return absolute difference between two unsigned 64-bit integers
 */
uint64_t
util_u64_absdiff(uint64_t u1, uint64_t u2)
{
	uint64_t tmpu;

	if (u1 > u2) {
		tmpu = u1;
		u1 = u2;
		u2 = tmpu;
	}

	return (u2 - u1);
}

/*
 * Return sqrt of 64bit unsigned int n
 */
uint32_t
util_u64sqrt(uint64_t n)
{
	double x, x2;

	if (n == 0) {
		return (0);
	}

	x = n;

	while (util_fabs((x2 = (x + n / x) / 2) - x) >= 0.5) {
		x = x2;
	}

	return ((uint32_t)x2);
}