/* This file is part of Netsukuku
 * (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
 *
 * This source code 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 source code 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.
 * Please refer to the GNU Public License for more details.
 *
 * You should have received a copy of the GNU Public License along with
 * this source code; if not, write to:
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * --
 * misc.c: some useful functions.
 */

#include "includes.h"
#include <dirent.h>
#include <sys/wait.h>

#include "common.h"

/*
 * xor_int
 * 
 * XORs all the bytes of the `i' integer by merging them in a single
 * byte. It returns the merged byte.
 */
char xor_int(int i)
{
        char c;

        c = (i & 0xff) ^ ((i & 0xff00)>>8) ^ ((i & 0xff0000)>>16) ^ ((i & 0xff000000)>>24);

        return c;
}


/*\
 *
 *  * * *  Swap functions  * * * *
 *
\*/


/*
 * swap_array: swaps the elements of the `src' array and stores the result in
 * `dst'. The `src' array has `nmemb'# elements and each of them is `nmemb_sz'
 * big.
 */
void swap_array(int nmemb, size_t nmemb_sz, void *src, void *dst)
{
	int i, total_sz;
	
	total_sz = nmemb*nmemb_sz;
	
	char buf[total_sz], *z;
	
	if(src == dst)
		z=buf;
	else
		z=dst;
	
	for(i=nmemb-1; i>=0; i--)
		memcpy(z+(nmemb_sz*(nmemb-i-1)), (char *)src+(nmemb_sz*i),
				nmemb_sz);
			
	if(src == dst)
		memcpy(dst, buf, total_sz);
}

/*
 * swap_ints: Swap integers.
 * It swaps the `x' array which has `nmemb' elements and stores the result it 
 * in `y'.
 */
void swap_ints(int nmemb, unsigned int *x, unsigned int *y) 
{
	swap_array(nmemb, sizeof(int), x, y);
}

void swap_shorts(int nmemb, unsigned short *x, unsigned short *y)
{
	swap_array(nmemb, sizeof(short), x, y);
}



/*
 * * * *  Random related functions  * * * *
 */

/* 
 * rand_range: It returns a random number x which is _min <= x <= _max
 */ 
int rand_range(int _min, int _max)
{
	return (rand()%(_max - _min + 1)) + _min;
}

/* 
 * xsrand
 *
 * It sets the random seed with a pseudo random number 
 */
void xsrand(void)
{
	FILE *fd;
	int seed;

	if((fd=fopen("/dev/urandom", "r"))) {
		fread(&seed, 4,1,fd);
		fclose(fd);
	} else
		seed=getpid() ^ time(0) ^ clock();

	srand(seed); 
}


/*
 * * * *  String functions  * * * *
 */

char *last_token(char *string, char tok)
{
	while(*string == tok)
		string++;
	return string;
}

/*
 * strip_char: Removes any occurrences of the character `char_to_strip' in the
 * string `string'.
 */
void strip_char(char *string, char char_to_strip)
{
	int i; 
	char *p;
	for(i=0; i<strlen(string); i++) {
		if(string[i]==char_to_strip) {
			p=last_token(&string[i], char_to_strip);
			strcpy(&string[i], p);
		}
	}
}



/*
 * * * *  Search functions  * * * *
 */

/*
 * split_string: splits the `str' strings at maximum in `max_substrings'#
 * substrings using as divisor the `div_str' string.
 * Each substring can be at maximum of `max_substring_sz' bytes.
 * The array of malloced substrings is returned and in `substrings' the number
 * of saved substrings is stored.
 * On error 0 is the return value.
 */
char **split_string(char *str, const char *div_str, int *substrings, 
		int max_substrings, int max_substring_sz)
{
	int i=0, strings=0, str_len=0, buf_len;
	char *buf, **splitted=0, *p;

	*substrings=0;
	
	str_len=strlen(str);

	buf=str-1;
	while((buf=strstr((const char *)buf+1, div_str)))
		strings++;
	if(!strings && !str_len)
		return 0;

	strings++;
	if(strings > max_substrings)
		strings=max_substrings;

	splitted=(char **)xmalloc(sizeof(char *)*strings);
	
	buf=str;
	for(i=0; i<strings; i++) {
		p=strstr((const char *)buf, div_str);
		if(p)
			*p=0;

		buf_len=strlen(buf);
		if(buf_len <= max_substring_sz && buf_len > 0)
			splitted[i]=xstrdup(buf);
		else {
			i--;
			strings--;
			buf=p+1;
		}

		if(!p) {
			i++;
			break;
		}
		buf=p+1;
	}
	
	if(i != strings)
		splitted=(char **)xrealloc(splitted, sizeof(char *)*i);

	*substrings=strings;
	return splitted;
}

/*
 * If `x' is present in the `ia' array, which has `nmemb' members, it returns
 * 1, otherwise 0.
 */
int find_int(int x, int *ia, int nmemb)
{
	int e;
	
	for(e=0; e<nmemb; e++)
		if(ia[e] == x)
			return 1;

	return 0;
}


/*
 *  *  *  *  Time functions  *  *  *  *
 */


/*
 * xtimer: It sleeps for `secs' seconds. 
 * `steps' tells to xtimer() how many "for" cycles it must run to sleep for
 * `secs' secons. At each cycle it updates `counter'.
 */
void xtimer(u_int secs, u_int steps, int *counter)
{
	static int i, ms_sleep;
	static int ms_step; /* how many ms it must sleep at every step */
	static int s_step;  /* seconds per step */
	static int mu_step; /* micro seconds per step */

	if(!steps)
		steps++;
	if(counter)
		*counter=0;
	ms_sleep=secs*1000;
	
	if(ms_sleep < secs) {
		/* We are waiting a LONG TIME, it's useless to have steps < of
		 * one second */
		ms_step=1000;
		steps=secs;
	} else {
		ms_step=ms_sleep/steps;
		
		if(!ms_step) {
			ms_step=1;
			steps=ms_sleep;
		}
	}

	s_step=ms_step/1000;
	mu_step=ms_step*1000;
	
	for(i=0; i<steps; i++) {
		if(ms_step >= 1000)
			sleep(s_step);
		else
			usleep(mu_step);
		if(counter)
			(*counter)++;
	}
}


/*
 *  *  *  *  File & Dir related functions  *  *  *  *
 */


/*
 * check_and_create_dir: tries to access in the specified `dir' directory and
 * if doesn't exist tries to create it.
 * On success it returns 0
 */
int check_and_create_dir(char *dir)
{
	DIR *d;
	
	/* Try to open the directory */
	d=opendir(dir);
	
	if(!d) {
		if(errno == ENOENT) {
			/* The directory doesn't exist, try to create it */
			if(mkdir(dir, S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
				error("Cannot create the %d directory: %s", dir,
						strerror(errno));
				return -1;
			}
		} else {
			error("Cannot access to the %s directory: %s", dir, 
					strerror(errno));
			return -1;
		}
	}
	
	closedir(d);
	return 0;
}

/* 
 * file_exist
 *
 * returns 1 if `filename' is a valid existing file.
 */
int file_exist(char *filename)
{
	FILE *fd;

	if(!(fd=fopen(filename, "r")))
		return !(errno == ENOENT);
	fclose(fd);

	return 1;
}

/*
 * exec_root_script: executes `script' with the given `argv', but checks first if the
 * script is:
 * 	- suid
 * 	- it isn't owned by root
 * 	- it isn't writable by others than root
 * If one of this conditions is true, the script won't be executed.
 * On success 0 is returned.
 */
int exec_root_script(char *script, char *argv)
{
	struct stat sh_stat;
	int ret;
	char command[strlen(script)+strlen(argv)+2];
	
	if(stat(script, &sh_stat)) {
		error("Couldn't stat %s: %s", strerror(errno));
		return -1;
	}

	if(sh_stat.st_uid != 0 || sh_stat.st_mode & S_ISUID ||
	    sh_stat.st_mode & S_ISGID || 
	    (sh_stat.st_gid != 0 && sh_stat.st_mode & S_IWGRP) ||
	    sh_stat.st_mode & S_IWOTH) {
		error("Please adjust the permissions of %s and be sure it "
			"hasn't been modified.\n"
			"  Use this command:\n"
			"  chmod 744 %s; chown root:root %s",
			script, script, script);
		return -1;
	}
	
	sprintf(command, "%s %s", script, argv);
	loginfo("Executing \"%s\"", command);
	
	ret=system(command);
	if(ret == -1) {
		error("Couldn't execute %s: %s", script, strerror(errno));
		return -1;
	}
	
	if(!WIFEXITED(ret) || (WIFEXITED(ret) && WEXITSTATUS(ret) != 0)) {
		error("\"%s\" didn't terminate correctly", command);
		return -1;
	}

	return 0;
}
	
	
/* This is the most important function */
void do_nothing(void)
{
	return;
}