/*

  * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

  * Copyright (C) 2008  Red Hat, Inc

  * Copyright (C) 2009, 2011, 2012, 2014, 2016  J. Ali Harlow <ali@juiblex.co.uk>

  *

  * 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.

  *

  * 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.

  *

  * You should have received a copy of the GNU General Public License along

  * with this program; if not, write to the Free Software Foundation, Inc.,

  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */

 #include "config.h"

 #include <limits.h>

 #include <string.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <stdint.h>

 #include <errno.h>

 #include <unistd.h>

 #ifndef MSWIN_API

 #include <sys/utsname.h>

 #endif

 #include <assert.h>

 #include "razor.h"

 #include "types/types.h"

 #include "razor-internal.h"

 /* Required by gnulib on non-libc platforms */

 char *program_name = "librazor";

 void *

 zalloc(size_t size)

 {

 	void *p;

 	p = malloc(size);

 	memset(p, 0, size);

 	return p;

 }

 struct qsort_context {

 	size_t size;

 	razor_compare_with_data_func_t compare;

 	void *data;

 };

 static void

 qsort_swap(void *p1, void *p2, size_t size)

 {

 	char buffer[size];

 	if (p1 != p2) {

 		memcpy(buffer, p1, size);

 		memcpy(p1, p2, size);

 		memcpy(p2, buffer, size);

 	}

 }

 static void

 __qsort_with_data(void *base, size_t nelem, uint32_t *map,

 		  struct qsort_context *ctx)

 {

 	void *p, *start, *end, *pivot;

 	uint32_t *mp, *mstart, *mend, tmp;

 	int left, right, result;

 	size_t size = ctx->size;

 	p = base;

 	start = base;

 	end = base + nelem * size;

 	mp = map;

 	mstart = map;

 	mend = map + nelem;

 	pivot = base + (rand() % nelem) * size;

 	while (p < end) {

 		result = ctx->compare(p, pivot, ctx->data);

 		if (result < 0) {

 			qsort_swap(p, start, size);

 			tmp = *mp;

 			*mp = *mstart;

 			*mstart = tmp;

 			if (start == pivot)

 				pivot = p;

 			start += size;

 			mstart++;

 			p += size;

 			mp++;

 		} else if (result == 0) {

 			p += size;

 			mp++;

 		} else {

  			end -= size;

 			mend--;

 			qsort_swap(p, end, size);

 			tmp = *mp;

 			*mp = *mend;

 			*mend = tmp;

 			if (end == pivot)

 				pivot = p;

 		}

 	}

 	left = (start - base) / size;

 	right = (base + nelem * size - end) / size;

 	if (left > 1)

 		__qsort_with_data(base, left, map, ctx);

 	if (right > 1)

 		__qsort_with_data(end, right, mend, ctx);

 }

 uint32_t *

 razor_qsort_with_data(void *base, size_t nelem, size_t size,

 		      razor_compare_with_data_func_t compare, void *data)

 {

 	struct qsort_context ctx;

 	uint32_t *map;

 	int i;

 	if (nelem == 0)

 		return NULL;

 	ctx.size = size;

 	ctx.compare = compare;

 	ctx.data = data;

 	map = malloc(nelem * sizeof (uint32_t));

 	for (i = 0; i < nelem; i++)

 		map[i] = i;

 	__qsort_with_data(base, nelem, map, &ctx);

 	return map;

 }

 void environment_init(struct environment *env)

 {

 	env->is_set = 0;

 	array_init(&env->string_pool);

 	array_init(&env->vars);

 }

 void environment_add_variable(struct environment *env,

 			      const char *variable, const char *value)

 {

 	char *s;

 	uint32_t *r;

 	assert(!env->is_set);

 	s = array_add(&env->string_pool,

 		      strlen(variable) + strlen(value) + 2);

 	sprintf(s, "%s=%s", variable, value);

 	r = array_add(&env->vars, sizeof *r);

 	*r = s - (char *)env->string_pool.data;

 }

 void environment_set(struct environment *env)

 {

 	int i, count;

 	char *s;

 #ifndef WIN32

 	char *t;

 #endif

         uint32_t *r;

 	if (!env->is_set) {

 		count = env->vars.size / sizeof(uint32_t);

 		r = (uint32_t *)env->vars.data;

 		for (i = 0; i < count; i++) {

 			s = env->string_pool.data + *r++;

 #ifdef WIN32

 			putenv(s);

 #else

 			t = strchr(s, '=');

 			*t = '\0';

 			setenv(s, t + 1, 1);

 			*t = '=';

 #endif

 		}

 		env->is_set = 1;

 	}

 }

 void environment_unset(struct environment *env)

 {

 	int i, count;

 	char c, *s, *t;

         uint32_t *r;

 	if (env->is_set) {

 		count = env->vars.size / sizeof(uint32_t);

 		r = (uint32_t *)env->vars.data;

 		for (i = 0; i < count; i++) {

 			s = env->string_pool.data + *r++;

 			t = strchr(s, '=');

 #ifdef WIN32

 			t++;

 			c = *t;

 			*t = '\0';

 			putenv(s);

 			*t = c;

 #else

 			c = *t;

 			*t = '\0';

 			unsetenv(s);

 			*t = c;

 #endif

 		}

 		env->is_set = 0;

 	}

 }

 void environment_release(struct environment *env)

 {

 	environment_unset(env);

 	array_release(&env->string_pool);

 	array_release(&env->vars);

 }

 RAZOR_EXPORT char *razor_concat(const char *s, ...)

 {

 	va_list args;

 	const char *string;

 	char *concat;

 	size_t n, len;

 	va_start(args, s);

 	len = strlen(s);

 	while((string = va_arg(args, const char *)))

 		len += strlen(string);

 	va_end(args);

 	concat = malloc(len + 1);

 	if (!concat)

 		return NULL;

 	va_start(args, s);

 	len = strlen(s);

 	memcpy(concat, s, len);

 	n = len;

 	while((string = va_arg(args, const char *))) {

 		len = strlen(string);

 		memcpy(concat + n, string, len);

 		n += len;

 	}

 	va_end(args);

 	concat[n] = '\0';

 	return concat;

 }

 RAZOR_EXPORT char *

 razor_resolve_relative_uri(const char *base_uri, const char *relative_uri,

 			   struct razor_error **error)

 {

 	char *result;

 	struct razor_uri ru, base, ref;

 	if (razor_uri_parse_uri(&base, base_uri, 1, error))

 		return NULL;

 	if (razor_uri_parse_relative_ref(&ref, relative_uri, error)) {

 		razor_uri_destroy(&base);

 		return NULL;

 	}

 	razor_uri_resolve(&ru, &base, &ref);

 	razor_uri_destroy(&base);

 	razor_uri_destroy(&ref);

 	result = razor_uri_recompose(&ru);

 	razor_uri_destroy(&ru);

 	return result;

 }

 RAZOR_EXPORT const char *razor_system_arch(void)

 {

 #ifdef MSWIN_API

 	SYSTEM_INFO si;

 	GetNativeSystemInfo(&si);

 	switch(si.wProcessorArchitecture)

 	{

 		case PROCESSOR_ARCHITECTURE_INTEL:

 			return "i686";

 		case PROCESSOR_ARCHITECTURE_AMD64:

 			return "x86_64";

 		default:

 			return NULL;

 	}

 #else

 	static struct utsname un;

 	if (uname(&un))

 		return NULL;

 	else

 		return un.machine;

 #endif

 }

 #ifdef MSWIN_API

 char *razor_utf16_to_utf8(const wchar_t *utf16, int len)

 {

 	int n;

 	char *utf8;

 	if (len == 0)

 		return strdup("");

 	n = WideCharToMultiByte(CP_UTF8, 0, utf16, len, NULL, 0, NULL, NULL);

 	if (len > 0)

 		n++;

 	utf8 = malloc(n);

 	(void)WideCharToMultiByte(CP_UTF8, 0, utf16, len, utf8, n, NULL, NULL);

 	if (len > 0)

 		utf8[n - 1] = 0;

 	return utf8;

 }

 wchar_t *razor_utf8_to_utf16(const char *utf8, int len)

 {

 	int n;

 	wchar_t *utf16;

 	if (len == 0) {

 		utf16 = calloc(1, sizeof(wchar_t));

 		return utf16;

 	}

 	n = MultiByteToWideChar(CP_UTF8, 0, utf8, len, NULL, 0);

 	if (len > 0)

 		n++;

 	utf16 = malloc(n * sizeof(wchar_t));

 	(void)MultiByteToWideChar(CP_UTF8, 0, utf8, len, utf16, n);

 	if (len > 0)

 		utf16[n - 1] = 0;

 	return utf16;

 }

 #endif	/* MSWIN_API */

 /*

  * Returns an absolute path (ie., not relative to the current directory on the

  * default, or any other, disk). Note that the absolute path may still have

  * "." or ".." path segments present (ie., this is not equivalent to realpath).

  */

 char *razor_abspath(const char *path)

 {

 #ifdef MSWIN_API

 	int n;

 	wchar_t *wpath, *wabspath;

 	char *abspath;

 	wpath = razor_utf8_to_utf16(path, -1);

 	n = GetFullPathNameW(wpath, 0, NULL, NULL);

 	if (!n) {

 		free(wpath);

 		return NULL;

 	}

 	wabspath = malloc(n * sizeof(sizeof(wchar_t)));

 	if (!GetFullPathNameW(wpath, n, wabspath, NULL)) {

 		free(wabspath);

 		free(wpath);

 		return NULL;

 	}

 	free(wpath);

 	abspath = razor_utf16_to_utf8(wabspath, n - 1);

 	free(wabspath);

 	return abspath;

 #else	/* MSWIN_API */

 	int pathlen, len;

 	char *cwd, *abspath;

 	if (*path == '/')

 		abspath = strdup(path);

 	else {

 		pathlen = strlen(path);

 		for (len = 32;; len *= 2) {

 			abspath = malloc(pathlen + 1 + len);

 			if (getcwd(abspath, len))

 				break;

 			if (errno != ERANGE) {

 				free(abspath);

 				return NULL;

 			}

 			free(abspath);

 		}

 		len = strlen(abspath);

 		if (abspath[len - 1] != '/')

 			abspath[len++] = '/';

 		memcpy(abspath + len, path, pathlen + 1);

 		abspath = realloc(abspath, len + pathlen + 1);

 	}

 	return abspath;

 #endif

 }