/*

* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdarg.h>

#include "talon_process.h"

#include "sema.h"

#include "buffer.h"

#include "../config.h"

/* The output semaphore. */

sbs_semaphore talon_sem;

#define TALON_ATTEMPT_STRMAX 32

#define RECIPETAG_STRMAX 2048

#define STATUS_STRMAX 120

#define TALONDELIMITER '|'

#define VARNAMEMAX 100

#define VARVALMAX 1024

#include "log.h"

#ifdef HAS_MSVCRT

/* Make all output handling binary */

unsigned int _CRT_fmode = _O_BINARY;

#endif

double getseconds(void)

{

	struct timeval tp;

	gettimeofday(&tp, NULL);

	return (double)tp.tv_sec + ((double)tp.tv_usec)/1000000.0L;

}

void talon_setenv(char name[], char val[])

{

#if defined(HAS_GETENVIRONMENTVARIABLE)

	SetEnvironmentVariableA(name,val); 

#elif defined(HAS_GETENV)

	setenv(name,val, 1);

#else

#	error "Need a function for setting environment variables"

#endif

}

#define TALON_MAXENV 4096

char * talon_getenv(char name[])

{

#if defined(HAS_SETENV)

	char *val = getenv(name);

	char *dest = NULL;

	if (val)

	{

		dest = malloc(strlen(val) + 1);

		if (dest)

		{

			strcpy(dest,val);

		}

	}

	return dest;

#elif defined(HAS_SETENVIRONMENTVARIABLE)

	char *val = malloc(TALON_MAXENV);

	if (0 != GetEnvironmentVariableA(name,val,TALON_MAXENV-1))

		return val;

	else

		return NULL;

#else

#	error "Need a function for setting environment variables"

#endif

}

void prependattributes(buffer *b, char *attributes)

{

	char recipetag[RECIPETAG_STRMAX];

	char *rt;

	char envvarname[VARNAMEMAX];

	char *att;

        strcpy(recipetag, "<recipe ");

	rt = recipetag + 8;

	att = attributes;

	while (*att != '\0' && rt < &recipetag[RECIPETAG_STRMAX-1])

	{

		if ( *att == '$' )

		{

			int e;

			char *v;

			/* insert the value of an environent variable */

			att++;

			e = 0;	

			do {

				envvarname[e++] = *att;

				att++;

			} while ( e < (VARNAMEMAX-1) && (isalnum(*att) || *att == '_'));

			envvarname[e] = '\0';

/* DEBUG(("envvarname: %s\n", envvarname)); */

			v = talon_getenv(envvarname);

			if (v)

			{

				/* DEBUG(("     value: %s\n", v)); */

				char *oldv=v;

				while (*v != '\0' && rt < &recipetag[RECIPETAG_STRMAX-1])

				{

					*rt = *v;

					rt++; v++;

				}

				free(oldv);

			}

		} else {

			*rt = *att;

			rt++; att++;

		}

	}

	char *finish = ">\n<![CDATA[\n";

	while (*finish != '\0' && rt < &recipetag[RECIPETAG_STRMAX-1])

	{

		*rt = *finish;

		*rt++; finish++;

	}

	*rt = '\0';

        buffer_prepend(b, recipetag, strlen(recipetag));

}

/* read a recipe string from a temporary file.

 *

 * We only expect to do this for very long command lines on

 * Windows. So allocate the maximum size for CreateProcess on

 * Win32 (32768 bytes) and error if the file is longer than that. 

 *

 */

char *read_recipe_from_file(const char *filename)

{

	FILE *fp = fopen(filename, "r");

	if (!fp)

	{

		error("talon: error: could not read '%s'\n", filename);

		return NULL;

	}

	int max_length = 32768;

	char *recipe = (char*)malloc(max_length);

	if (!recipe)

	{

		error("talon: error: could not allocate memory to read '%s'\n", filename);

		return NULL;

	}

	int position = 0;

	/* read the file one character at a time */

	int c;

	while ((c = getc(fp)) != EOF)

	{

		switch (c)

		{

			case '\r':

			case '\n':

				/* ignore newlines */

				break;

			case '"':

				/* double quotes have to be escaped so they aren't lost later */

				if (position < max_length)

					recipe[position++] = '\\';

				if (position < max_length)

					recipe[position++] = c;

				break;

			default:

				if (position < max_length)

					recipe[position++] = c;

				break;

		}

	}

	fclose(fp);

	/* add a terminating \0 */

	if (position < max_length)

		recipe[position] = '\0';

	else

	{

		error("talon: error: command longer than 32768 in '%s'\n", filename);

		return NULL;

	}

	return recipe;

}

int main(int argc, char *argv[])

{

	/* find the argument to -c then strip the talon related front section */

	char *recipe = NULL;

	int talon_returncode = 0;

#ifdef HAS_GETCOMMANDLINE

	char *commandline= GetCommandLine();

	DEBUG(("talon: commandline: %s\n", commandline));

	/*

	 * The command line should be either,

	 * talon -c "some shell commands"

	 * or

	 * talon shell_script_file

	 *

	 * talon could be an absolute path and may have a .exe extension.

	 */

	recipe = strstr(commandline, "-c");

	if (recipe)

	{

		/* there was a -c so extract the quoted commands */

		while (*recipe != '"' && *recipe != '\0')

			recipe++;

		if (*recipe != '"')    /* we found -c but no following quote */

		{

			error("talon: error: unquoted recipe in shell call '%s'\n", commandline);

			return 1;

		}

		recipe++;

		int recipelen = strlen(recipe);

		if (recipelen > 0 && recipe[recipelen - 1] == '"')

			recipe[recipelen - 1] = '\0'; /* remove trailing quote */

	}

	else

	{

		/* there was no -c so extract the argument as a filename */

		recipe = strstr(commandline, "talon");

		if (recipe)

		{

			/* find the first space */

			while (!isspace(*recipe) && *recipe != '\0')

				recipe++;

			/* skip past the spaces */

			while (isspace(*recipe))

				recipe++;

			recipe = read_recipe_from_file(recipe);

			if (!recipe)

			{

			    error("talon: error: bad script file in shell call '%s'\n", commandline);

				return 1;

			}

		}

		else

		{

			error("talon: error: no 'talon' in shell call '%s'\n", commandline);

			return 1;

		}

	}

#else

	/*

	 * The command line should be either,

	 * talon -c "some shell commands"

	 * or

	 * talon shell_script_file

	 *

	 * talon could be an absolute path and may have a .exe extension.

	 */

	switch (argc)

	{

		case 2:

			recipe = read_recipe_from_file(argv[1]);

			break;

		case 3:

			if (strcmp("-c", argv[1]) != 0)

			{

				error("talon: error: %s\n", "usage is 'talon -c command' or 'talon script_filename'");

				return 1;

			}

			recipe = argv[2];

			break;

		default:

			error("talon: error: %s\n", "usage is 'talon -c command' or 'talon script_filename'");

			return 1;

	}

#endif

	/* did we get a recipe at all? */

	if (!recipe)

	{

		error("talon: error: %s", "no recipe supplied to the shell.\n");

		return 1;

	}

	/* remove any leading white space on the recipe */

	while (isspace(*recipe))

		recipe++;

	/* turn debugging on? */

	char *debugstr=talon_getenv("TALON_DEBUG");

	if (debugstr)

	{

		loglevel=LOGDEBUG;

		free(debugstr); debugstr=NULL;

	}

	DEBUG(("talon: recipe: %s\n", recipe));

	char varname[VARNAMEMAX];

	char varval[VARVALMAX];

	int dotagging = 0; 

	int force_descramble_off = 0;

	char  *rp = recipe;

	if (*rp == TALONDELIMITER) {

		dotagging = 1; 

		/* there are some talon-specific settings 

		 * in the command which must be stripped */

		rp++;

		char *out = varname;

		char *stopout = varname + VARNAMEMAX - 1;

		DEBUG(("talon: parameters found\n"));

		while (*rp != '\0')

		{

			switch (*rp) {

				case  '=':

					*out = '\0';

					DEBUG(("talon: varname: %s\n",varname));

					out = varval;

					stopout = varval + VARVALMAX - 1;

					break;

				case ';':

					*out = '\0';

					DEBUG(("talon: varval: %s\n",varval));

					talon_setenv(varname, varval);

					out = varname;

					stopout = varname + VARNAMEMAX - 1;

					break;

				default:	

					*out = *rp;

					if (out < stopout)

						out++;

					break;

			}

			if (*rp == TALONDELIMITER)

			{

				rp++;

				break;

			}

			rp++;

		}

	} else {

		/* This is probably a $(shell) statement 

 		 * in make so no descrambling needed and 

 		 * tags are definitely not wanted as they 

 		 * would corrupt the expected output*/

		force_descramble_off = 1; 

	}

	/* Now take settings from the environment (having potentially modified it) */	

	if (talon_getenv("TALON_DEBUG"))

		loglevel=LOGDEBUG;

	int enverrors = 0;

	char *shell = talon_getenv("TALON_SHELL");

	if (!shell)

	{

		error("error: %s", "TALON_SHELL not set in environment\n");

		enverrors++;	

	}

	int timeout = -1;

	char *timeout_str = talon_getenv("TALON_TIMEOUT");

	if (timeout_str)

	{

		timeout = atoi(timeout_str);

		free(timeout_str); timeout_str = NULL;

	}

	char *buildid = talon_getenv("TALON_BUILDID");

	if (!buildid)

	{

		error("error: %s", "TALON_BUILDID not set in environment\n");

		enverrors++;	

	}

	char *attributes = talon_getenv("TALON_RECIPEATTRIBUTES");

	if (!attributes)

	{

		error("error: %s", "TALON_RECIPEATTRIBUTES not set in environment\n");

		enverrors++;

	}

	int max_retries = 0;

	char *retries_str = talon_getenv("TALON_RETRIES");

	if (retries_str)

	{

		max_retries = atoi(retries_str);

		free(retries_str); retries_str = NULL;

	}	

	int descramble = 0;

	if (! force_descramble_off )

	{

		char *descramblestr = talon_getenv("TALON_DESCRAMBLE");

		if (descramblestr)

		{

			if (*descramblestr == '0')

				descramble = 0;

			else

				descramble = 1;

			free(descramblestr); descramblestr = NULL;

		}

	}

	/* Talon can look in a flags variable to alter it's behaviour */

	int force_success = 0;

	char *flags_str = talon_getenv("TALON_FLAGS");

	if (flags_str)

	{

		int c;

		for (c=0; flags_str[c] !=0; c++)

			flags_str[c] = tolower(flags_str[c]);

		if (strstr(flags_str, "forcesuccess"))

			force_success = 1;

		/* don't put <recipe> or <CDATA<[[ tags around the output. e.g. if it's XML already*/

		if (strstr(flags_str, "rawoutput"))

		{

			dotagging = 0;

		}

		free(flags_str); flags_str = NULL;

	}	

	/* Talon subprocesses need to have the "correct" shell variable set. */

	talon_setenv("SHELL", shell); 

	/* we have allowed some errors to build up so that the user

	 * can see all of them before we stop and force the user 

	 * to fix them

	 */

	if (enverrors)

	{

		return 1;

	}

	/* Run the recipe repeatedly until the retry count expires or

	 * it succeeds.