Warning: Can't use blame annotator:
svn blame failed on trunk/zoo-project/zoo-kernel/zoo_service_loader.c: 200029 - Couldn't perform atomic initialization

zoo_service_loader.c @ 560

Last change on this file since 560 was 557, checked in by knut, 10 years ago
Fix to ensure that only configuration files whose name ends with .zcfg are read (e.g. avoid reading ServiceName?.zcfg~).
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 124.7 KB

Rev	Line
	1	/**
	2	* Author : Gérald FENOY
	3	*
	4	* Copyright 2008-2013 GeoLabs SARL. All rights reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25
	26
	27	extern "C" int yylex ();
	28	extern "C" int crlex ();
	29
	30	#ifdef USE_OTB
	31	#include "service_internal_otb.h"
	32	#else
	33	#define length(x) (sizeof(x) / sizeof(x[0]))
	34	#endif
	35
	36	#include "cgic.h"
	37
	38	extern "C"
	39	{
	40	#include <libxml/tree.h>
	41	#include <libxml/xmlmemory.h>
	42	#include <libxml/parser.h>
	43	#include <libxml/xpath.h>
	44	#include <libxml/xpathInternals.h>
	45	}
	46
	47	#include "ulinet.h"
	48
	49	#include <libintl.h>
	50	#include <locale.h>
	51	#include <string.h>
	52
	53	#include "service.h"
	54
	55	#include "service_internal.h"
	56
	57	#ifdef USE_PYTHON
	58	#include "service_internal_python.h"
	59	#endif
	60
	61	#ifdef USE_JAVA
	62	#include "service_internal_java.h"
	63	#endif
	64
	65	#ifdef USE_PHP
	66	#include "service_internal_php.h"
	67	#endif
	68
	69	#ifdef USE_JS
	70	#include "service_internal_js.h"
	71	#endif
	72
	73	#ifdef USE_RUBY
	74	#include "service_internal_ruby.h"
	75	#endif
	76
	77	#ifdef USE_PERL
	78	#include "service_internal_perl.h"
	79	#endif
	80
	81	#include <dirent.h>
	82	#include <signal.h>
	83	#include <unistd.h>
	84	#ifndef WIN32
	85	#include <dlfcn.h>
	86	#include <libgen.h>
	87	#else
	88	#include <windows.h>
	89	#include <direct.h>
	90	#include <sys/types.h>
	91	#include <sys/stat.h>
	92	#include <unistd.h>
	93	#define pid_t int;
	94	#endif
	95	#include <fcntl.h>
	96	#include <time.h>
	97	#include <stdarg.h>
	98
	99	#ifdef WIN32
	100	extern "C"
	101	{
	102	__declspec (dllexport) char strcasestr (char const a, char const *b)
	103	#ifndef USE_MS
	104	{
	105	char *x = zStrdup (a);
	106	char *y = zStrdup (b);
	107
	108	x = _strlwr (x);
	109	y = _strlwr (y);
	110	char *pos = strstr (x, y);
	111	char ret = pos == NULL ? NULL : (char ) (a + (pos - x));
	112	free (x);
	113	free (y);
	114	return ret;
	115	};
	116	#else
	117	;
	118	#endif
	119	}
	120	#endif
	121
	122	#define _(String) dgettext ("zoo-kernel",String)
	123	#define __(String) dgettext ("zoo-service",String)
	124
	125	extern int getServiceFromFile (maps , const char , service **);
	126
	127	int
	128	readServiceFile (maps * conf, char file, service * service, char *name)
	129	{
	130	int t = getServiceFromFile (conf, file, service);
	131	#ifdef YAML
	132	if (t < 0)
	133	{
	134	t = getServiceFromYAML (conf, file, service, name);
	135	}
	136	#endif
	137	return t;
	138	}
	139
	140	void
	141	translateChar (char *str, char toReplace, char toReplaceBy)
	142	{
	143	int i = 0, len = strlen (str);
	144	for (i = 0; i < len; i++)
	145	{
	146	if (str[i] == toReplace)
	147	str[i] = toReplaceBy;
	148	}
	149	}
	150
	151	/**
	152	* Create (or append to) an array valued maps
	153	* value = "["",""]"
	154	*/
	155	int
	156	appendMapsToMaps (maps * m, maps * mo, maps * mi, elements * elem)
	157	{
	158	maps *tmpMaps = getMaps (mo, mi->name);
	159	map *tmap = getMapType (tmpMaps->content);
	160	elements *el = getElements (elem, mi->name);
	161	int hasEl = 1;
	162	if (el == NULL)
	163	hasEl = -1;
	164	if (tmap == NULL)
	165	{
	166	if (hasEl > 0)
	167	tmap = getMapType (el->defaults->content);
	168	}
	169
	170	map *testMap = NULL;
	171	if (hasEl > 0)
	172	{
	173	testMap = getMap (el->content, "maxOccurs");
	174	}
	175	else
	176	{
	177	testMap = createMap ("maxOccurs", "unbounded");
	178	}
	179
	180	if (testMap != NULL)
	181	{
	182	if (strncasecmp (testMap->value, "unbounded", 9) != 0
	183	&& atoi (testMap->value) > 1)
	184	{
	185	addMapsArrayToMaps (&mo, mi, tmap->name);
	186	map* nb=getMapFromMaps(mo,mi->name,"length");
	187	if (nb!=NULL && atoi(nb->value)>atoi(testMap->value))
	188	{
	189	char emsg[1024];
	190	sprintf (emsg,
	191	_("You set maximum occurences for <%s> as %i but you tried to use it more than the limit you set. Please correct your ZCFG file or your request."),
	192	mi->name, atoi (testMap->value));
	193	errorException (m, emsg, "InternalError", NULL);
	194	return -1;
	195	}
	196	}
	197	else
	198	{
	199	if (strncasecmp (testMap->value, "unbounded", 9) == 0)
	200	{
	201	if (hasEl < 0)
	202	{
	203	freeMap (&testMap);
	204	free (testMap);
	205	}
	206	if (addMapsArrayToMaps (&mo, mi, tmap->name) < 0)
	207	{
	208	char emsg[1024];
	209	map *tmpMap = getMap (mi->content, "length");
	210	sprintf (emsg,
	211	_
	212	("ZOO-Kernel was unable to load your data for %s position %s."),
	213	mi->name, tmpMap->value);
	214	errorException (m, emsg, "InternalError", NULL);
	215	return -1;
	216	}
	217	}
	218	else
	219	{
	220	char emsg[1024];
	221	sprintf (emsg,
	222	_
	223	("You set maximum occurences for <%s> to one but you tried to use it more than once. Please correct your ZCFG file or your request."),
	224	mi->name);
	225	errorException (m, emsg, "InternalError", NULL);
	226	return -1;
	227	}
	228	}
	229	}
	230	return 0;
	231	}
	232
	233	int
	234	recursReaddirF (maps * m, xmlNodePtr n, char conf_dir, char prefix,
	235	int saved_stdout, int level, void (func) (maps *, xmlNodePtr,
	236	service *))
	237	{
	238	struct dirent *dp;
	239	int scount = 0;
	240
	241	if (conf_dir == NULL)
	242	return 1;
	243	DIR *dirp = opendir (conf_dir);
	244	if (dirp == NULL)
	245	{
	246	if (level > 0)
	247	return 1;
	248	else
	249	return -1;
	250	}
	251	char tmp1[25];
	252	sprintf (tmp1, "sprefix_%d", level);
	253	char levels[17];
	254	sprintf (levels, "%d", level);
	255	setMapInMaps (m, "lenv", "level", levels);
	256	while ((dp = readdir (dirp)) != NULL)
	257	if ((dp->d_type == DT_DIR \|\| dp->d_type == DT_LNK) && dp->d_name[0] != '.'
	258	&& strstr (dp->d_name, ".") == NULL)
	259	{
	260
	261	char *tmp =
	262	(char ) malloc ((strlen (conf_dir) + strlen (dp->d_name) + 2)
	263	sizeof (char));
	264	sprintf (tmp, "%s/%s", conf_dir, dp->d_name);
	265
	266	if (prefix != NULL)
	267	{
	268	prefix = NULL;
	269	}
	270	prefix = (char ) malloc ((strlen (dp->d_name) + 2) sizeof (char));
	271	sprintf (prefix, "%s.", dp->d_name);
	272
	273	//map* tmpMap=getMapFromMaps(m,"lenv",tmp1);
	274
	275	int res;
	276	if (prefix != NULL)
	277	{
	278	setMapInMaps (m, "lenv", tmp1, prefix);
	279	char levels1[17];
	280	sprintf (levels1, "%d", level + 1);
	281	setMapInMaps (m, "lenv", "level", levels1);
	282	res =
	283	recursReaddirF (m, n, tmp, prefix, saved_stdout, level + 1,
	284	func);
	285	sprintf (levels1, "%d", level);
	286	setMapInMaps (m, "lenv", "level", levels1);
	287	free (prefix);
	288	prefix = NULL;
	289	}
	290	else
	291	res = -1;
	292	free (tmp);
	293	if (res < 0)
	294	{
	295	return res;
	296	}
	297	}
	298	else
	299	{
	300	char* extn = strstr(dp->d_name, ".zcfg");
	301	if(dp->d_name[0] != '.' && extn != NULL && strlen(extn) == 5)
	302	{
	303	int t;
	304	char tmps1[1024];
	305	memset (tmps1, 0, 1024);
	306	snprintf (tmps1, 1024, "%s/%s", conf_dir, dp->d_name);
	307	service s1 = (service ) malloc (SERVICE_SIZE);
	308	if (s1 == NULL)
	309	{
	310	dup2 (saved_stdout, fileno (stdout));
	311	errorException (m, _("Unable to allocate memory."),
	312	"InternalError", NULL);
	313	return -1;
	314	}
	315	#ifdef DEBUG
	316	fprintf (stderr, "#################\n%s\n#################\n",
	317	tmps1);
	318	#endif
	319	char *tmpsn = zStrdup (dp->d_name);
	320	tmpsn[strlen (tmpsn) - 5] = 0;
	321	t = readServiceFile (m, tmps1, &s1, tmpsn);
	322	free (tmpsn);
	323	if (t < 0)
	324	{
	325	map *tmp00 = getMapFromMaps (m, "lenv", "message");
	326	char tmp01[1024];
	327	if (tmp00 != NULL)
	328	sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"),
	329	dp->d_name, tmp00->value);
	330	else
	331	sprintf (tmp01, _("Unable to parse the ZCFG file: %s."),
	332	dp->d_name);
	333	dup2 (saved_stdout, fileno (stdout));
	334	errorException (m, tmp01, "InternalError", NULL);
	335	return -1;
	336	}
	337	#ifdef DEBUG
	338	dumpService (s1);
	339	fflush (stdout);
	340	fflush (stderr);
	341	#endif
	342	func (m, n, s1);
	343	freeService (&s1);
	344	free (s1);
	345	scount++;
	346	}
	347	}
	348	(void) closedir (dirp);
	349	return 1;
	350	}
	351
	352	xmlXPathObjectPtr
	353	extractFromDoc (xmlDocPtr doc, const char *search)
	354	{
	355	xmlXPathContextPtr xpathCtx;
	356	xmlXPathObjectPtr xpathObj;
	357	xpathCtx = xmlXPathNewContext (doc);
	358	xpathObj = xmlXPathEvalExpression (BAD_CAST search, xpathCtx);
	359	xmlXPathFreeContext (xpathCtx);
	360	return xpathObj;
	361	}
	362
	363	void
	364	donothing (int sig)
	365	{
	366	#ifdef DEBUG
	367	fprintf (stderr, "Signal %d after the ZOO-Kernel returned result !\n", sig);
	368	#endif
	369	exit (0);
	370	}
	371
	372	void
	373	sig_handler (int sig)
	374	{
	375	char tmp[100];
	376	const char *ssig;
	377	switch (sig)
	378	{
	379	case SIGSEGV:
	380	ssig = "SIGSEGV";
	381	break;
	382	case SIGTERM:
	383	ssig = "SIGTERM";
	384	break;
	385	case SIGINT:
	386	ssig = "SIGINT";
	387	break;
	388	case SIGILL:
	389	ssig = "SIGILL";
	390	break;
	391	case SIGFPE:
	392	ssig = "SIGFPE";
	393	break;
	394	case SIGABRT:
	395	ssig = "SIGABRT";
	396	break;
	397	default:
	398	ssig = "UNKNOWN";
	399	break;
	400	}
	401	sprintf (tmp,
	402	_
	403	("ZOO Kernel failed to process your request receiving signal %d = %s"),
	404	sig, ssig);
	405	errorException (NULL, tmp, "InternalError", NULL);
	406	#ifdef DEBUG
	407	fprintf (stderr, "Not this time!\n");
	408	#endif
	409	exit (0);
	410	}
	411
	412	void
	413	loadServiceAndRun (maps ** myMap, service * s1, map * request_inputs,
	414	maps inputs, maps ioutputs, int *eres)
	415	{
	416	char tmps1[1024];
	417	char ntmp[1024];
	418	maps m = myMap;
	419	maps request_output_real_format = ioutputs;
	420	maps request_input_real_format = inputs;
	421	/**
	422	* Extract serviceType to know what kind of service should be loaded
	423	*/
	424	map *r_inputs = NULL;
	425	#ifndef WIN32
	426	getcwd (ntmp, 1024);
	427	#else
	428	_getcwd (ntmp, 1024);
	429	#endif
	430	r_inputs = getMap (s1->content, "serviceType");
	431	#ifdef DEBUG
	432	fprintf (stderr, "LOAD A %s SERVICE PROVIDER \n", r_inputs->value);
	433	fflush (stderr);
	434	#endif
	435	if (strlen (r_inputs->value) == 1
	436	&& strncasecmp (r_inputs->value, "C", 1) == 0)
	437	{
	438	r_inputs = getMap (request_inputs, "metapath");
	439	if (r_inputs != NULL)
	440	sprintf (tmps1, "%s/%s", ntmp, r_inputs->value);
	441	else
	442	sprintf (tmps1, "%s/", ntmp);
	443	char *altPath = zStrdup (tmps1);
	444	r_inputs = getMap (s1->content, "ServiceProvider");
	445	sprintf (tmps1, "%s/%s", altPath, r_inputs->value);
	446	free (altPath);
	447	#ifdef DEBUG
	448	fprintf (stderr, "Trying to load %s\n", tmps1);
	449	#endif
	450	#ifdef WIN32
	451	HINSTANCE so =
	452	LoadLibraryEx (tmps1, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	453	#else
	454	void *so = dlopen (tmps1, RTLD_LAZY);
	455	#endif
	456	#ifdef WIN32
	457	DWORD errstr;
	458	errstr = GetLastError ();
	459	#else
	460	char *errstr;
	461	errstr = dlerror ();
	462	#endif
	463	#ifdef DEBUG
	464	fprintf (stderr, "%s loaded (%d) \n", tmps1, errstr);
	465	#endif
	466	if (so != NULL)
	467	{
	468	#ifdef DEBUG
	469	fprintf (stderr, "Library loaded %s \n", errstr);
	470	fprintf (stderr, "Service Shared Object = %s\n", r_inputs->value);
	471	#endif
	472	r_inputs = getMap (s1->content, "serviceType");
	473	#ifdef DEBUG
	474	dumpMap (r_inputs);
	475	fprintf (stderr, "%s\n", r_inputs->value);
	476	fflush (stderr);
	477	#endif
	478	if (strncasecmp (r_inputs->value, "C-FORTRAN", 9) == 0)
	479	{
	480	r_inputs = getMap (request_inputs, "Identifier");
	481	char fname[1024];
	482	sprintf (fname, "%s_", r_inputs->value);
	483	#ifdef DEBUG
	484	fprintf (stderr, "Try to load function %s\n", fname);
	485	#endif
	486	#ifdef WIN32
	487	typedef int (CALLBACK * execute_t) (char *, char *,
	488	char ***);
	489	execute_t execute = (execute_t) GetProcAddress (so, fname);
	490	#else
	491	typedef int (execute_t) (char , char , char **);
	492	execute_t execute = (execute_t) dlsym (so, fname);
	493	#endif
	494	#ifdef DEBUG
	495	#ifdef WIN32
	496	errstr = GetLastError ();
	497	#else
	498	errstr = dlerror ();
	499	#endif
	500	fprintf (stderr, "Function loaded %s\n", errstr);
	501	#endif
	502
	503	char main_conf[10][30][1024];
	504	char inputs[10][30][1024];
	505	char outputs[10][30][1024];
	506	for (int i = 0; i < 10; i++)
	507	{
	508	for (int j = 0; j < 30; j++)
	509	{
	510	memset (main_conf[i][j], 0, 1024);
	511	memset (inputs[i][j], 0, 1024);
	512	memset (outputs[i][j], 0, 1024);
	513	}
	514	}
	515	mapsToCharXXX (m, (char ***) main_conf);
	516	mapsToCharXXX (request_input_real_format, (char ***) inputs);
	517	mapsToCharXXX (request_output_real_format, (char ***) outputs);
	518	*eres =
	519	execute ((char *) &main_conf[0], (char *) &inputs[0],
	520	(char ***) &outputs[0]);
	521	#ifdef DEBUG
	522	fprintf (stderr, "Function run successfully \n");
	523	#endif
	524	charxxxToMaps ((char ***) &outputs[0],
	525	&request_output_real_format);
	526	}
	527	else
	528	{
	529	#ifdef DEBUG
	530	#ifdef WIN32
	531	errstr = GetLastError ();
	532	fprintf (stderr, "Function %s failed to load because of %d\n",
	533	r_inputs->value, errstr);
	534	#endif
	535	#endif
	536	r_inputs = getMapFromMaps (m, "lenv", "Identifier");
	537	#ifdef DEBUG
	538	fprintf (stderr, "Try to load function %s\n", r_inputs->value);
	539	#endif
	540	typedef int (execute_t) (maps , maps , maps *);
	541	#ifdef WIN32
	542	execute_t execute =
	543	(execute_t) GetProcAddress (so, r_inputs->value);
	544	#else
	545	execute_t execute = (execute_t) dlsym (so, r_inputs->value);
	546	#endif
	547
	548	if (execute == NULL)
	549	{
	550	#ifdef WIN32
	551	errstr = GetLastError ();
	552	#else
	553	errstr = dlerror ();
	554	#endif
	555	char *tmpMsg =
	556	(char *) malloc (2048 + strlen (r_inputs->value));
	557	sprintf (tmpMsg,
	558	_
	559	("Error occured while running the %s function: %s"),
	560	r_inputs->value, errstr);
	561	errorException (m, tmpMsg, "InternalError", NULL);
	562	free (tmpMsg);
	563	#ifdef DEBUG
	564	fprintf (stderr, "Function %s error %s\n", r_inputs->value,
	565	errstr);
	566	#endif
	567	*eres = -1;
	568	return;
	569	}
	570
	571	#ifdef DEBUG
	572	#ifdef WIN32
	573	errstr = GetLastError ();
	574	#else
	575	errstr = dlerror ();
	576	#endif
	577	fprintf (stderr, "Function loaded %s\n", errstr);
	578	#endif
	579
	580	#ifdef DEBUG
	581	fprintf (stderr, "Now run the function \n");
	582	fflush (stderr);
	583	#endif
	584	*eres =
	585	execute (&m, &request_input_real_format,
	586	&request_output_real_format);
	587	#ifdef DEBUG
	588	fprintf (stderr, "Function loaded and returned %d\n", eres);
	589	fflush (stderr);
	590	#endif
	591	}
	592	#ifdef WIN32
	593	*ioutputs = dupMaps (&request_output_real_format);
	594	FreeLibrary (so);
	595	#else
	596	dlclose (so);
	597	#endif
	598	}
	599	else
	600	{
	601	/**
	602	* Unable to load the specified shared library
	603	*/
	604	char tmps[1024];
	605	#ifdef WIN32
	606	DWORD errstr = GetLastError ();
	607	#else
	608	char *errstr = dlerror ();
	609	#endif
	610	sprintf (tmps, _("C Library can't be loaded %s"), errstr);
	611	map *tmps1 = createMap ("text", tmps);
	612	printExceptionReportResponse (m, tmps1);
	613	*eres = -1;
	614	freeMap (&tmps1);
	615	free (tmps1);
	616	}
	617	}
	618	else
	619
	620	#ifdef USE_OTB
	621	if (strncasecmp (r_inputs->value, "OTB", 6) == 0)
	622	{
	623	*eres =
	624	zoo_otb_support (&m, request_inputs, s1,
	625	&request_input_real_format,
	626	&request_output_real_format);
	627	}
	628	else
	629	#endif
	630
	631	#ifdef USE_PYTHON
	632	if (strncasecmp (r_inputs->value, "PYTHON", 6) == 0)
	633	{
	634	*eres =
	635	zoo_python_support (&m, request_inputs, s1,
	636	&request_input_real_format,
	637	&request_output_real_format);
	638	}
	639	else
	640	#endif
	641
	642	#ifdef USE_JAVA
	643	if (strncasecmp (r_inputs->value, "JAVA", 4) == 0)
	644	{
	645	*eres =
	646	zoo_java_support (&m, request_inputs, s1, &request_input_real_format,
	647	&request_output_real_format);
	648	}
	649	else
	650	#endif
	651
	652	#ifdef USE_PHP
	653	if (strncasecmp (r_inputs->value, "PHP", 3) == 0)
	654	{
	655	*eres =
	656	zoo_php_support (&m, request_inputs, s1, &request_input_real_format,
	657	&request_output_real_format);
	658	}
	659	else
	660	#endif
	661
	662
	663	#ifdef USE_PERL
	664	if (strncasecmp (r_inputs->value, "PERL", 4) == 0)
	665	{
	666	*eres =
	667	zoo_perl_support (&m, request_inputs, s1, &request_input_real_format,
	668	&request_output_real_format);
	669	}
	670	else
	671	#endif
	672
	673	#ifdef USE_JS
	674	if (strncasecmp (r_inputs->value, "JS", 2) == 0)
	675	{
	676	*eres =
	677	zoo_js_support (&m, request_inputs, s1, &request_input_real_format,
	678	&request_output_real_format);
	679	}
	680	else
	681	#endif
	682
	683	#ifdef USE_RUBY
	684	if (strncasecmp (r_inputs->value, "Ruby", 4) == 0)
	685	{
	686	*eres =
	687	zoo_ruby_support (&m, request_inputs, s1, &request_input_real_format,
	688	&request_output_real_format);
	689	}
	690	else
	691	#endif
	692
	693	{
	694	char tmpv[1024];
	695	sprintf (tmpv,
	696	_
	697	("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),
	698	r_inputs->value);
	699	map *tmps = createMap ("text", tmpv);
	700	printExceptionReportResponse (m, tmps);
	701	*eres = -1;
	702	}
	703	*myMap = m;
	704	*ioutputs = request_output_real_format;
	705	}
	706
	707
	708	#ifdef WIN32
	709	/**
	710	* createProcess function: create a new process after setting some env variables
	711	*/
	712	void
	713	createProcess (maps * m, map * request_inputs, service * s1, char *opts,
	714	int cpid, maps * inputs, maps * outputs)
	715	{
	716	STARTUPINFO si;
	717	PROCESS_INFORMATION pi;
	718	ZeroMemory (&si, sizeof (si));
	719	si.cb = sizeof (si);
	720	ZeroMemory (&pi, sizeof (pi));
	721	char tmp = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
	722	char tmpq = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
	723	map *req = getMap (request_inputs, "request");
	724	map *id = getMap (request_inputs, "identifier");
	725	map *di = getMap (request_inputs, "DataInputs");
	726
	727	char *dataInputsKVP = getMapsAsKVP (inputs, cgiContentLength, 0);
	728	char *dataOutputsKVP = getMapsAsKVP (outputs, cgiContentLength, 1);
	729	#ifdef DEBUG
	730	fprintf (stderr, "DATAINPUTSKVP %s\n", dataInputsKVP);
	731	fprintf (stderr, "DATAOUTPUTSKVP %s\n", dataOutputsKVP);
	732	#endif
	733	map *sid = getMapFromMaps (m, "lenv", "sid");
	734	map *r_inputs = getMapFromMaps (m, "main", "tmpPath");
	735	map *r_inputs1 = getMap (request_inputs, "metapath");
	736	int hasIn = -1;
	737	if (r_inputs1 == NULL)
	738	{
	739	r_inputs1 = createMap ("metapath", "");
	740	hasIn = 1;
	741	}
	742	map *r_inputs2 = getMap (request_inputs, "ResponseDocument");
	743	if (r_inputs2 == NULL)
	744	r_inputs2 = getMap (request_inputs, "RawDataOutput");
	745	map *tmpPath = getMapFromMaps (m, "lenv", "cwd");
	746
	747	map *tmpReq = getMap (request_inputs, "xrequest");
	748	if (r_inputs2 != NULL)
	749	{
	750	sprintf (tmp,
	751	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",
	752	r_inputs1->value, req->value, id->value, dataInputsKVP,
	753	r_inputs2->name, dataOutputsKVP, sid->value);
	754	sprintf (tmpq,
	755	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",
	756	r_inputs1->value, req->value, id->value, dataInputsKVP,
	757	r_inputs2->name, dataOutputsKVP);
	758	}
	759	else
	760	{
	761	sprintf (tmp,
	762	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",
	763	r_inputs1->value, req->value, id->value, dataInputsKVP,
	764	sid->value);
	765	sprintf (tmpq,
	766	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",
	767	r_inputs1->value, req->value, id->value, dataInputsKVP,
	768	sid->value);
	769	}
	770
	771	if (hasIn > 0)
	772	{
	773	freeMap (&r_inputs1);
	774	free (r_inputs1);
	775	}
	776	char *tmp1 = zStrdup (tmp);
	777	sprintf (tmp, "\"zoo_loader.cgi\" %s \"%s\"", tmp1, sid->value);
	778
	779	free (dataInputsKVP);
	780	free (dataOutputsKVP);
	781	#ifdef DEBUG
	782	fprintf (stderr, "REQUEST IS : %s \n", tmp);
	783	#endif
	784
	785	map* usid = getMapFromMaps (m, "lenv", "usid");
	786	if (usid != NULL && usid->value != NULL) {
	787	SetEnvironmentVariable("USID", TEXT (usid->value));
	788	}
	789
	790	SetEnvironmentVariable ("CGISID", TEXT (sid->value));
	791	SetEnvironmentVariable ("QUERY_STRING", TEXT (tmpq));
	792	char clen[1000];
	793	sprintf (clen, "%d", strlen (tmpq));
	794	SetEnvironmentVariable ("CONTENT_LENGTH", TEXT (clen));
	795
	796	if (!CreateProcess (NULL, // No module name (use command line)
	797	TEXT (tmp), // Command line
	798	NULL, // Process handle not inheritable
	799	NULL, // Thread handle not inheritable
	800	FALSE, // Set handle inheritance to FALSE
	801	CREATE_NO_WINDOW, // Apache won't wait until the end
	802	NULL, // Use parent's environment block
	803	NULL, // Use parent's starting directory
	804	&si, // Pointer to STARTUPINFO struct
	805	&pi) // Pointer to PROCESS_INFORMATION struct
	806	)
	807	{
	808	#ifdef DEBUG
	809	fprintf (stderr, "CreateProcess failed (%d).\n", GetLastError ());
	810	#endif
	811	return;
	812	}
	813	else
	814	{
	815	#ifdef DEBUG
	816	fprintf (stderr, "CreateProcess successfull (%d).\n\n\n\n",
	817	GetLastError ());
	818	#endif
	819	}
	820	CloseHandle (pi.hProcess);
	821	CloseHandle (pi.hThread);
	822	#ifdef DEBUG
	823	fprintf (stderr, "CreateProcess finished !\n");
	824	#endif
	825	}
	826	#endif
	827
	828	int
	829	runRequest (map ** inputs)
	830	{
	831
	832	#ifndef USE_GDB
	833	#ifndef WIN32
	834	signal (SIGCHLD, SIG_IGN);
	835	#endif
	836	signal (SIGSEGV, sig_handler);
	837	signal (SIGTERM, sig_handler);
	838	signal (SIGINT, sig_handler);
	839	signal (SIGILL, sig_handler);
	840	signal (SIGFPE, sig_handler);
	841	signal (SIGABRT, sig_handler);
	842	#endif
	843
	844	map *r_inputs = NULL;
	845	map request_inputs = inputs;
	846	maps *m = NULL;
	847	char *REQUEST = NULL;
	848	/**
	849	* Parsing service specfic configuration file
	850	*/
	851	m = (maps *) malloc (MAPS_SIZE);
	852	if (m == NULL)
	853	{
	854	return errorException (m, _("Unable to allocate memory."),
	855	"InternalError", NULL);
	856	}
	857	char ntmp[1024];
	858	#ifndef WIN32
	859	getcwd (ntmp, 1024);
	860	#else
	861	_getcwd (ntmp, 1024);
	862	#endif
	863	r_inputs = getMapOrFill (&request_inputs, "metapath", "");
	864
	865
	866	char conf_file[10240];
	867	snprintf (conf_file, 10240, "%s/%s/main.cfg", ntmp, r_inputs->value);
	868	if (conf_read (conf_file, m) == 2)
	869	{
	870	errorException (NULL, _("Unable to load the main.cfg file."),
	871	"InternalError", NULL);
	872	free (m);
	873	return 1;
	874	}
	875	#ifdef DEBUG
	876	fprintf (stderr, "***** BEGIN MAPS\n");
	877	dumpMaps (m);
	878	fprintf (stderr, "***** END MAPS\n");
	879	#endif
	880
	881	map *getPath = getMapFromMaps (m, "main", "gettextPath");
	882	if (getPath != NULL)
	883	{
	884	bindtextdomain ("zoo-kernel", getPath->value);
	885	bindtextdomain ("zoo-services", getPath->value);
	886	}
	887	else
	888	{
	889	bindtextdomain ("zoo-kernel", "/usr/share/locale/");
	890	bindtextdomain ("zoo-services", "/usr/share/locale/");
	891	}
	892
	893
	894	/**
	895	* Manage our own error log file (usefull to separate standard apache debug
	896	* messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
	897	* headers messages returned by the CGI due to wrong redirection of stderr)
	898	*/
	899	FILE *fstde = NULL;
	900	map *fstdem = getMapFromMaps (m, "main", "logPath");
	901	if (fstdem != NULL)
	902	fstde = freopen (fstdem->value, "a+", stderr);
	903
	904	r_inputs = getMap (request_inputs, "language");
	905	if (r_inputs == NULL)
	906	r_inputs = getMapFromMaps (m, "main", "language");
	907	if (r_inputs != NULL)
	908	{
	909	if (isValidLang (m, r_inputs->value) < 0)
	910	{
	911	char tmp[1024];
	912	sprintf (tmp,
	913	_
	914	("The value %s is not supported for the <language> parameter"),
	915	r_inputs->value);
	916	errorException (m, tmp, "InvalidParameterValue", "language");
	917	freeMaps (&m);
	918	free (m);
	919	free (REQUEST);
	920	return 1;
	921
	922	}
	923	char *tmp = zStrdup (r_inputs->value);
	924	setMapInMaps (m, "main", "language", tmp);
	925	#ifdef DEB
	926	char tmp2[12];
	927	sprintf (tmp2, "%s.utf-8", tmp);
	928	translateChar (tmp2, '-', '_');
	929	setlocale (LC_ALL, tmp2);
	930	#else
	931	translateChar (tmp, '-', '_');
	932	setlocale (LC_ALL, tmp);
	933	#endif
	934	#ifndef WIN32
	935	setenv ("LC_ALL", tmp, 1);
	936	#else
	937	char tmp1[12];
	938	sprintf (tmp1, "LC_ALL=%s", tmp);
	939	putenv (tmp1);
	940	#endif
	941	free (tmp);
	942	}
	943	else
	944	{
	945	setlocale (LC_ALL, "en_US");
	946	#ifndef WIN32
	947	setenv ("LC_ALL", "en_US", 1);
	948	#else
	949	char tmp1[12];
	950	sprintf (tmp1, "LC_ALL=en_US");
	951	putenv (tmp1);
	952	#endif
	953	setMapInMaps (m, "main", "language", "en-US");
	954	}
	955	setlocale (LC_NUMERIC, "en_US");
	956	bind_textdomain_codeset ("zoo-kernel", "UTF-8");
	957	textdomain ("zoo-kernel");
	958	bind_textdomain_codeset ("zoo-services", "UTF-8");
	959	textdomain ("zoo-services");
	960
	961	map *lsoap = getMap (request_inputs, "soap");
	962	if (lsoap != NULL && strcasecmp (lsoap->value, "true") == 0)
	963	setMapInMaps (m, "main", "isSoap", "true");
	964	else
	965	setMapInMaps (m, "main", "isSoap", "false");
	966
	967	if (strlen (cgiServerName) > 0)
	968	{
	969	char tmpUrl[1024];
	970	if (strncmp (cgiServerPort, "80", 2) == 0)
	971	{
	972	sprintf (tmpUrl, "http://%s%s", cgiServerName, cgiScriptName);
	973	}
	974	else
	975	{
	976	sprintf (tmpUrl, "http://%s:%s%s", cgiServerName, cgiServerPort,
	977	cgiScriptName);
	978	}
	979	#ifdef DEBUG
	980	fprintf (stderr, "* %s *\n", tmpUrl);
	981	#endif
	982	setMapInMaps (m, "main", "serverAddress", tmpUrl);
	983	}
	984
	985	/**
	986	* Check for minimum inputs
	987	*/
	988	r_inputs = getMap (request_inputs, "Request");
	989	if (request_inputs == NULL \|\| r_inputs == NULL)
	990	{
	991	errorException (m, _("Parameter <request> was not specified"),
	992	"MissingParameterValue", "request");
	993	if (count (request_inputs) == 1)
	994	{
	995	freeMap (&request_inputs);
	996	free (request_inputs);
	997	}
	998	freeMaps (&m);
	999	free (m);
	1000	return 1;
	1001	}
	1002	else
	1003	{
	1004	REQUEST = zStrdup (r_inputs->value);
	1005	if (strncasecmp (r_inputs->value, "GetCapabilities", 15) != 0
	1006	&& strncasecmp (r_inputs->value, "DescribeProcess", 15) != 0
	1007	&& strncasecmp (r_inputs->value, "Execute", 7) != 0)
	1008	{
	1009	errorException (m,
	1010	_
	1011	("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
	1012	"OperationNotSupported", r_inputs->value);
	1013	freeMaps (&m);
	1014	free (m);
	1015	free (REQUEST);
	1016	return 1;
	1017	}
	1018	}
	1019	r_inputs = NULL;
	1020	r_inputs = getMap (request_inputs, "Service");
	1021	if (r_inputs == NULLMAP)
	1022	{
	1023	errorException (m, _("Parameter <service> was not specified"),
	1024	"MissingParameterValue", "service");
	1025	freeMaps (&m);
	1026	free (m);
	1027	free (REQUEST);
	1028	return 1;
	1029	}
	1030	else
	1031	{
	1032	if (strcasecmp (r_inputs->value, "WPS") != 0)
	1033	{
	1034	errorException (m,
	1035	_
	1036	("Unenderstood <service> value, WPS is the only acceptable value."),
	1037	"InvalidParameterValue", "service");
	1038	freeMaps (&m);
	1039	free (m);
	1040	free (REQUEST);
	1041	return 1;
	1042	}
	1043	}
	1044	if (strncasecmp (REQUEST, "GetCapabilities", 15) != 0)
	1045	{
	1046	r_inputs = getMap (request_inputs, "Version");
	1047	if (r_inputs == NULL)
	1048	{
	1049	errorException (m, _("Parameter <version> was not specified"),
	1050	"MissingParameterValue", "version");
	1051	freeMaps (&m);
	1052	free (m);
	1053	free (REQUEST);
	1054	return 1;
	1055	}
	1056	else
	1057	{
	1058	if (strcasecmp (r_inputs->value, "1.0.0") != 0)
	1059	{
	1060	errorException (m,
	1061	_
	1062	("Unenderstood <version> value, 1.0.0 is the only acceptable value."),
	1063	"InvalidParameterValue", "service");
	1064	freeMaps (&m);
	1065	free (m);
	1066	free (REQUEST);
	1067	return 1;
	1068	}
	1069	}
	1070	}
	1071	else
	1072	{
	1073	r_inputs = getMap (request_inputs, "AcceptVersions");
	1074	if (r_inputs != NULL)
	1075	{
	1076	if (strncmp (r_inputs->value, "1.0.0", 5) != 0)
	1077	{
	1078	errorException (m,
	1079	_
	1080	("Unenderstood <AcceptVersions> value, 1.0.0 is the only acceptable value."),
	1081	"VersionNegotiationFailed", NULL);
	1082	freeMaps (&m);
	1083	free (m);
	1084	free (REQUEST);
	1085	return 1;
	1086	}
	1087	}
	1088	}
	1089
	1090	r_inputs = getMap (request_inputs, "serviceprovider");
	1091	if (r_inputs == NULL)
	1092	{
	1093	addToMap (request_inputs, "serviceprovider", "");
	1094	}
	1095
	1096	maps *request_output_real_format = NULL;
	1097	map *tmpm = getMapFromMaps (m, "main", "serverAddress");
	1098	if (tmpm != NULL)
	1099	SERVICE_URL = zStrdup (tmpm->value);
	1100	else
	1101	SERVICE_URL = zStrdup (DEFAULT_SERVICE_URL);
	1102
	1103	service *s1;
	1104	int scount = 0;
	1105	#ifdef DEBUG
	1106	dumpMap (r_inputs);
	1107	#endif
	1108	char conf_dir[1024];
	1109	int t;
	1110	char tmps1[1024];
	1111
	1112	r_inputs = NULL;
	1113	r_inputs = getMap (request_inputs, "metapath");
	1114	if (r_inputs != NULL)
	1115	snprintf (conf_dir, 1024, "%s/%s", ntmp, r_inputs->value);
	1116	else
	1117	snprintf (conf_dir, 1024, "%s", ntmp);
	1118
	1119	if (strncasecmp (REQUEST, "GetCapabilities", 15) == 0)
	1120	{
	1121	#ifdef DEBUG
	1122	dumpMap (r_inputs);
	1123	#endif
	1124	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
	1125	r_inputs = NULL;
	1126	r_inputs = getMap (request_inputs, "ServiceProvider");
	1127	xmlNodePtr n;
	1128	if (r_inputs != NULL)
	1129	n = printGetCapabilitiesHeader (doc, r_inputs->value, m);
	1130	else
	1131	n = printGetCapabilitiesHeader (doc, "", m);
	1132	/**
	1133	* Here we need to close stdout to ensure that not supported chars
	1134	* has been found in the zcfg and then printed on stdout
	1135	*/
	1136	int saved_stdout = dup (fileno (stdout));
	1137	dup2 (fileno (stderr), fileno (stdout));
	1138	if (int res =
	1139	recursReaddirF (m, n, conf_dir, NULL, saved_stdout, 0,
	1140	printGetCapabilitiesForProcess) < 0)
	1141	{
	1142	freeMaps (&m);
	1143	free (m);
	1144	free (REQUEST);
	1145	free (SERVICE_URL);
	1146	fflush (stdout);
	1147	return res;
	1148	}
	1149	dup2 (saved_stdout, fileno (stdout));
	1150	printDocument (m, doc, getpid ());
	1151	freeMaps (&m);
	1152	free (m);
	1153	free (REQUEST);
	1154	free (SERVICE_URL);
	1155	fflush (stdout);
	1156	return 0;
	1157	}
	1158	else
	1159	{
	1160	r_inputs = getMap (request_inputs, "Identifier");
	1161	if (r_inputs == NULL
	1162	\|\| strlen (r_inputs->name) == 0 \|\| strlen (r_inputs->value) == 0)
	1163	{
	1164	errorException (m, _("Mandatory <identifier> was not specified"),
	1165	"MissingParameterValue", "identifier");
	1166	freeMaps (&m);
	1167	free (m);
	1168	free (REQUEST);
	1169	free (SERVICE_URL);
	1170	return 0;
	1171	}
	1172
	1173	struct dirent *dp;
	1174	DIR *dirp = opendir (conf_dir);
	1175	if (dirp == NULL)
	1176	{
	1177	errorException (m, _("The specified path path doesn't exist."),
	1178	"InvalidParameterValue", conf_dir);
	1179	freeMaps (&m);
	1180	free (m);
	1181	free (REQUEST);
	1182	free (SERVICE_URL);
	1183	return 0;
	1184	}
	1185	if (strncasecmp (REQUEST, "DescribeProcess", 15) == 0)
	1186	{
	1187	/**
	1188	* Loop over Identifier list
	1189	*/
	1190	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
	1191	r_inputs = NULL;
	1192	r_inputs = getMap (request_inputs, "ServiceProvider");
	1193
	1194	xmlNodePtr n;
	1195	if (r_inputs != NULL)
	1196	n = printDescribeProcessHeader (doc, r_inputs->value, m);
	1197	else
	1198	n = printDescribeProcessHeader (doc, "", m);
	1199
	1200	r_inputs = getMap (request_inputs, "Identifier");
	1201
	1202	char *orig = zStrdup (r_inputs->value);
	1203
	1204	int saved_stdout = dup (fileno (stdout));
	1205	dup2 (fileno (stderr), fileno (stdout));
	1206	if (strcasecmp ("all", orig) == 0)
	1207	{
	1208	if (int res =
	1209	recursReaddirF (m, n, conf_dir, NULL, saved_stdout, 0,
	1210	printDescribeProcessForProcess) < 0)
	1211	return res;
	1212	}
	1213	else
	1214	{
	1215	char *saveptr;
	1216	char *tmps = strtok_r (orig, ",", &saveptr);
	1217
	1218	char buff[256];
	1219	char buff1[1024];
	1220	while (tmps != NULL)
	1221	{
	1222	int hasVal = -1;
	1223	char *corig = zStrdup (tmps);
	1224	if (strstr (corig, ".") != NULL)
	1225	{
	1226
	1227	parseIdentifier (m, conf_dir, corig, buff1);
	1228	map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
	1229	if (tmpMap != NULL)
	1230	addToMap (request_inputs, "metapath", tmpMap->value);
	1231	map *tmpMapI = getMapFromMaps (m, "lenv", "Identifier");
	1232
	1233	s1 = (service *) malloc (SERVICE_SIZE);
	1234	t = readServiceFile (m, buff1, &s1, tmpMapI->value);
	1235	if (t < 0)
	1236	{
	1237	map *tmp00 = getMapFromMaps (m, "lenv", "message");
	1238	char tmp01[1024];
	1239	if (tmp00 != NULL)
	1240	sprintf (tmp01,
	1241	_
	1242	("Unable to parse the ZCFG file for the following ZOO-Service: %s. Message: %s"),
	1243	tmps, tmp00->value);
	1244	else
	1245	sprintf (tmp01,
	1246	_
	1247	("Unable to parse the ZCFG file for the following ZOO-Service: %s."),
	1248	tmps);
	1249	dup2 (saved_stdout, fileno (stdout));
	1250	errorException (m, tmp01, "InvalidParameterValue",
	1251	"identifier");
	1252	freeMaps (&m);
	1253	free (m);
	1254	free (REQUEST);
	1255	free (corig);
	1256	free (orig);
	1257	free (SERVICE_URL);
	1258	free (s1);
	1259	closedir (dirp);
	1260	xmlFreeDoc (doc);
	1261	xmlCleanupParser ();
	1262	zooXmlCleanupNs ();
	1263	return 1;
	1264	}
	1265	#ifdef DEBUG
	1266	dumpService (s1);
	1267	#endif
	1268	printDescribeProcessForProcess (m, n, s1);
	1269	freeService (&s1);
	1270	free (s1);
	1271	s1 = NULL;
	1272	scount++;
	1273	hasVal = 1;
	1274	setMapInMaps (m, "lenv", "level", "0");
	1275	}
	1276	else
	1277	{
	1278	memset (buff, 0, 256);
	1279	snprintf (buff, 256, "%s.zcfg", corig);
	1280	memset (buff1, 0, 1024);
	1281	#ifdef DEBUG
	1282	printf ("\n#######%s\n########\n", buff);
	1283	#endif
	1284	while ((dp = readdir (dirp)) != NULL)
	1285	{
	1286	if (strcasecmp (dp->d_name, buff) == 0)
	1287	{
	1288	memset (buff1, 0, 1024);
	1289	snprintf (buff1, 1024, "%s/%s", conf_dir,
	1290	dp->d_name);
	1291	s1 = (service *) malloc (SERVICE_SIZE);
	1292	if (s1 == NULL)
	1293	{
	1294	dup2 (saved_stdout, fileno (stdout));
	1295	return errorException (m,
	1296	_
	1297	("Unable to allocate memory."),
	1298	"InternalError",
	1299	NULL);
	1300	}
	1301	#ifdef DEBUG
	1302	printf
	1303	("#################\n(%s) %s\n#################\n",
	1304	r_inputs->value, buff1);
	1305	#endif
	1306	char *tmp0 = zStrdup (dp->d_name);
	1307	tmp0[strlen (tmp0) - 5] = 0;
	1308	t = readServiceFile (m, buff1, &s1, tmp0);
	1309	free (tmp0);
	1310	if (t < 0)
	1311	{
	1312	map *tmp00 =
	1313	getMapFromMaps (m, "lenv", "message");
	1314	char tmp01[1024];
	1315	if (tmp00 != NULL)
	1316	sprintf (tmp01,
	1317	_
	1318	("Unable to parse the ZCFG file: %s (%s)"),
	1319	dp->d_name, tmp00->value);
	1320	else
	1321	sprintf (tmp01,
	1322	_
	1323	("Unable to parse the ZCFG file: %s."),
	1324	dp->d_name);
	1325	dup2 (saved_stdout, fileno (stdout));
	1326	errorException (m, tmp01, "InternalError",
	1327	NULL);
	1328	freeMaps (&m);
	1329	free (m);
	1330	free (orig);
	1331	free (REQUEST);
	1332	closedir (dirp);
	1333	xmlFreeDoc (doc);
	1334	xmlCleanupParser ();
	1335	zooXmlCleanupNs ();
	1336	return 1;
	1337	}
	1338	#ifdef DEBUG
	1339	dumpService (s1);
	1340	#endif
	1341	printDescribeProcessForProcess (m, n, s1);
	1342	freeService (&s1);
	1343	free (s1);
	1344	s1 = NULL;
	1345	scount++;
	1346	hasVal = 1;
	1347	}
	1348	}
	1349	}
	1350	if (hasVal < 0)
	1351	{
	1352	map *tmp00 = getMapFromMaps (m, "lenv", "message");
	1353	char tmp01[1024];
	1354	if (tmp00 != NULL)
	1355	sprintf (tmp01,
	1356	_("Unable to parse the ZCFG file: %s (%s)"),
	1357	buff, tmp00->value);
	1358	else
	1359	sprintf (tmp01,
	1360	_("Unable to parse the ZCFG file: %s."),
	1361	buff);
	1362	dup2 (saved_stdout, fileno (stdout));
	1363	errorException (m, tmp01, "InvalidParameterValue",
	1364	"Identifier");
	1365	freeMaps (&m);
	1366	free (m);
	1367	free (orig);
	1368	free (REQUEST);
	1369	closedir (dirp);
	1370	xmlFreeDoc (doc);
	1371	xmlCleanupParser ();
	1372	zooXmlCleanupNs ();
	1373	return 1;
	1374	}
	1375	rewinddir (dirp);
	1376	tmps = strtok_r (NULL, ",", &saveptr);
	1377	if (corig != NULL)
	1378	free (corig);
	1379	}
	1380	}
	1381	closedir (dirp);
	1382	fflush (stdout);
	1383	dup2 (saved_stdout, fileno (stdout));
	1384	free (orig);
	1385	printDocument (m, doc, getpid ());
	1386	freeMaps (&m);
	1387	free (m);
	1388	free (REQUEST);
	1389	free (SERVICE_URL);
	1390	fflush (stdout);
	1391	return 0;
	1392	}
	1393	else if (strncasecmp (REQUEST, "Execute", strlen (REQUEST)) != 0)
	1394	{
	1395	errorException (m,
	1396	_
	1397	("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
	1398	"InvalidParameterValue", "request");
	1399	#ifdef DEBUG
	1400	fprintf (stderr, "No request found %s", REQUEST);
	1401	#endif
	1402	closedir (dirp);
	1403	freeMaps (&m);
	1404	free (m);
	1405	free (REQUEST);
	1406	free (SERVICE_URL);
	1407	fflush (stdout);
	1408	return 0;
	1409	}
	1410	closedir (dirp);
	1411	}
	1412
	1413	s1 = NULL;
	1414	s1 = (service *) malloc (SERVICE_SIZE);
	1415	if (s1 == NULL)
	1416	{
	1417	freeMaps (&m);
	1418	free (m);
	1419	free (REQUEST);
	1420	free (SERVICE_URL);
	1421	return errorException (m, _("Unable to allocate memory."),
	1422	"InternalError", NULL);
	1423	}
	1424	r_inputs = getMap (request_inputs, "MetaPath");
	1425	if (r_inputs != NULL)
	1426	snprintf (tmps1, 1024, "%s/%s", ntmp, r_inputs->value);
	1427	else
	1428	snprintf (tmps1, 1024, "%s/", ntmp);
	1429	r_inputs = getMap (request_inputs, "Identifier");
	1430	char *ttmp = zStrdup (tmps1);
	1431	snprintf (tmps1, 1024, "%s/%s.zcfg", ttmp, r_inputs->value);
	1432	free (ttmp);
	1433	#ifdef DEBUG
	1434	fprintf (stderr, "Trying to load %s\n", tmps1);
	1435	#endif
	1436	if (strstr (r_inputs->value, ".") != NULL)
	1437	{
	1438	char *identifier = zStrdup (r_inputs->value);
	1439	parseIdentifier (m, conf_dir, identifier, tmps1);
	1440	map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
	1441	if (tmpMap != NULL)
	1442	addToMap (request_inputs, "metapath", tmpMap->value);
	1443	free (identifier);
	1444	}
	1445	else
	1446	{
	1447	setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
	1448	setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
	1449	}
	1450
	1451	r_inputs = getMapFromMaps (m, "lenv", "Identifier");
	1452	int saved_stdout = dup (fileno (stdout));
	1453	dup2 (fileno (stderr), fileno (stdout));
	1454	t = readServiceFile (m, tmps1, &s1, r_inputs->value);
	1455	fflush (stdout);
	1456	dup2 (saved_stdout, fileno (stdout));
	1457	if (t < 0)
	1458	{
	1459	char tmpMsg = (char ) malloc (2048 + strlen (r_inputs->value));
	1460	sprintf (tmpMsg,
	1461	_
	1462	("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),
	1463	r_inputs->value);
	1464	errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
	1465	free (tmpMsg);
	1466	free (s1);
	1467	freeMaps (&m);
	1468	free (m);
	1469	free (REQUEST);
	1470	free (SERVICE_URL);
	1471	return 0;
	1472	}
	1473	close (saved_stdout);
	1474
	1475	#ifdef DEBUG
	1476	dumpService (s1);
	1477	#endif
	1478	int j;
	1479
	1480
	1481	/**
	1482	* Create the input and output maps data structure
	1483	*/
	1484	int i = 0;
	1485	HINTERNET hInternet;
	1486	HINTERNET res;
	1487	hInternet = InternetOpen (
	1488	#ifndef WIN32
	1489	(LPCTSTR)
	1490	#endif
	1491	"ZooWPSClient\0",
	1492	INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
	1493
	1494	#ifndef WIN32
	1495	if (!CHECK_INET_HANDLE (hInternet))
	1496	fprintf (stderr, "WARNING : hInternet handle failed to initialize");
	1497	#endif
	1498	maps *request_input_real_format = NULL;
	1499	maps *tmpmaps = request_input_real_format;
	1500	map *postRequest = NULL;
	1501	postRequest = getMap (request_inputs, "xrequest");
	1502	if (postRequest == NULLMAP)
	1503	{
	1504	/**
	1505	* Parsing outputs provided as KVP
	1506	*/
	1507	r_inputs = NULL;
	1508	#ifdef DEBUG
	1509	fprintf (stderr, "OUTPUT Parsing ... \n");
	1510	#endif
	1511	r_inputs = getMap (request_inputs, "ResponseDocument");
	1512	if (r_inputs == NULL)
	1513	r_inputs = getMap (request_inputs, "RawDataOutput");
	1514
	1515	#ifdef DEBUG
	1516	fprintf (stderr, "OUTPUT Parsing ... \n");
	1517	#endif
	1518	if (r_inputs != NULL)
	1519	{
	1520	#ifdef DEBUG
	1521	fprintf (stderr, "OUTPUT Parsing start now ... \n");
	1522	#endif
	1523	char cursor_output[10240];
	1524	char *cotmp = zStrdup (r_inputs->value);
	1525	snprintf (cursor_output, 10240, "%s", cotmp);
	1526	free (cotmp);
	1527	j = 0;
	1528
	1529	/**
	1530	* Put each Output into the outputs_as_text array
	1531	*/
	1532	char *pToken;
	1533	maps *tmp_output = NULL;
	1534	#ifdef DEBUG
	1535	fprintf (stderr, "OUTPUT [%s]\n", cursor_output);
	1536	#endif
	1537	pToken = strtok (cursor_output, ";");
	1538	char outputs_as_text = (char ) malloc (128 * sizeof (char *));
	1539	if (outputs_as_text == NULL)
	1540	{
	1541	return errorException (m, _("Unable to allocate memory"),
	1542	"InternalError", NULL);
	1543	}
	1544	i = 0;
	1545	while (pToken != NULL)
	1546	{
	1547	#ifdef DEBUG
	1548	fprintf (stderr, "*%s*\n", pToken);
	1549	fflush (stderr);
	1550	fprintf (stderr, "*%s*\n", pToken);
	1551	#endif
	1552	outputs_as_text[i] =
	1553	(char ) malloc ((strlen (pToken) + 1) sizeof (char));
	1554	if (outputs_as_text[i] == NULL)
	1555	{
	1556	return errorException (m, _("Unable to allocate memory"),
	1557	"InternalError", NULL);
	1558	}
	1559	snprintf (outputs_as_text[i], strlen (pToken) + 1, "%s",
	1560	pToken);
	1561	pToken = strtok (NULL, ";");
	1562	i++;
	1563	}
	1564	for (j = 0; j < i; j++)
	1565	{
	1566	char *tmp = zStrdup (outputs_as_text[j]);
	1567	free (outputs_as_text[j]);
	1568	char *tmpc;
	1569	tmpc = strtok (tmp, "@");
	1570	int k = 0;
	1571	while (tmpc != NULL)
	1572	{
	1573	if (k == 0)
	1574	{
	1575	if (tmp_output == NULL)
	1576	{
	1577	tmp_output = (maps *) malloc (MAPS_SIZE);
	1578	if (tmp_output == NULL)
	1579	{
	1580	return errorException (m,
	1581	_
	1582	("Unable to allocate memory."),
	1583	"InternalError", NULL);
	1584	}
	1585	tmp_output->name = zStrdup (tmpc);
	1586	tmp_output->content = NULL;
	1587	tmp_output->next = NULL;
	1588	}
	1589	}
	1590	else
	1591	{
	1592	char *tmpv = strstr (tmpc, "=");
	1593	char tmpn[256];
	1594	memset (tmpn, 0, 256);
	1595	strncpy (tmpn, tmpc,
	1596	(strlen (tmpc) -
	1597	strlen (tmpv)) * sizeof (char));
	1598	tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
	1599	#ifdef DEBUG
	1600	fprintf (stderr, "OUTPUT DEF [%s]=[%s]\n", tmpn,
	1601	tmpv + 1);
	1602	#endif
	1603	if (tmp_output->content == NULL)
	1604	{
	1605	tmp_output->content = createMap (tmpn, tmpv + 1);
	1606	tmp_output->content->next = NULL;
	1607	}
	1608	else
	1609	addToMap (tmp_output->content, tmpn, tmpv + 1);
	1610	}
	1611	k++;
	1612	#ifdef DEBUG
	1613	fprintf (stderr, "*%s*\n", tmpc);
	1614	#endif
	1615	tmpc = strtok (NULL, "@");
	1616	}
	1617	if (request_output_real_format == NULL)
	1618	request_output_real_format = dupMaps (&tmp_output);
	1619	else
	1620	addMapsToMaps (&request_output_real_format, tmp_output);
	1621	freeMaps (&tmp_output);
	1622	free (tmp_output);
	1623	tmp_output = NULL;
	1624	#ifdef DEBUG
	1625	dumpMaps (tmp_output);
	1626	fflush (stderr);
	1627	#endif
	1628	free (tmp);
	1629	}
	1630	free (outputs_as_text);
	1631	}
	1632
	1633
	1634	/**
	1635	* Parsing inputs provided as KVP
	1636	*/
	1637	r_inputs = getMap (request_inputs, "DataInputs");
	1638	#ifdef DEBUG
	1639	fprintf (stderr, "DATA INPUTS [%s]\n", r_inputs->value);
	1640	#endif
	1641	char cursor_input[40960];
	1642	if (r_inputs != NULL)
	1643	snprintf (cursor_input, 40960, "%s", r_inputs->value);
	1644	else
	1645	{
	1646	errorException (m, _("Parameter <DataInputs> was not specified"),
	1647	"MissingParameterValue", "DataInputs");
	1648	freeMaps (&m);
	1649	free (m);
	1650	free (REQUEST);
	1651	free (SERVICE_URL);
	1652	InternetCloseHandle (&hInternet);
	1653	freeService (&s1);
	1654	free (s1);
	1655	return 0;
	1656	}
	1657	j = 0;
	1658
	1659	/**
	1660	* Put each DataInputs into the inputs_as_text array
	1661	*/
	1662	char *tmp1 = zStrdup (cursor_input);
	1663	char *pToken;
	1664	pToken = strtok (cursor_input, ";");
	1665	if (pToken != NULL && strncasecmp (pToken, tmp1, strlen (tmp1)) == 0)
	1666	{
	1667	char *tmp2 = url_decode (tmp1);
	1668	snprintf (cursor_input, (strlen (tmp2) + 1) * sizeof (char), "%s",
	1669	tmp2);
	1670	free (tmp2);
	1671	pToken = strtok (cursor_input, ";");
	1672	}
	1673	free (tmp1);
	1674
	1675	char inputs_as_text = (char ) malloc (100 * sizeof (char *));
	1676	if (inputs_as_text == NULL)
	1677	{
	1678	return errorException (m, _("Unable to allocate memory."),
	1679	"InternalError", NULL);
	1680	}
	1681	i = 0;
	1682	while (pToken != NULL)
	1683	{
	1684	#ifdef DEBUG
	1685	fprintf (stderr, "*%s*\n", pToken);
	1686	#endif
	1687	fflush (stderr);
	1688	#ifdef DEBUG
	1689	fprintf (stderr, "*%s*\n", pToken);
	1690	#endif
	1691	inputs_as_text[i] =
	1692	(char ) malloc ((strlen (pToken) + 1) sizeof (char));
	1693	snprintf (inputs_as_text[i], strlen (pToken) + 1, "%s", pToken);
	1694	if (inputs_as_text[i] == NULL)
	1695	{
	1696	return errorException (m, _("Unable to allocate memory."),
	1697	"InternalError", NULL);
	1698	}
	1699	pToken = strtok (NULL, ";");
	1700	i++;
	1701	}
	1702
	1703	for (j = 0; j < i; j++)
	1704	{
	1705	char *tmp = zStrdup (inputs_as_text[j]);
	1706	free (inputs_as_text[j]);
	1707	char *tmpc;
	1708	tmpc = strtok (tmp, "@");
	1709	while (tmpc != NULL)
	1710	{
	1711	#ifdef DEBUG
	1712	fprintf (stderr, "*\n%s**\n", tmpc);
	1713	#endif
	1714	char *tmpv = strstr (tmpc, "=");
	1715	char tmpn[256];
	1716	memset (tmpn, 0, 256);
	1717	if (tmpv != NULL)
	1718	{
	1719	strncpy (tmpn, tmpc,
	1720	(strlen (tmpc) - strlen (tmpv)) * sizeof (char));
	1721	tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
	1722	}
	1723	else
	1724	{
	1725	strncpy (tmpn, tmpc, strlen (tmpc) * sizeof (char));
	1726	tmpn[strlen (tmpc)] = 0;
	1727	}
	1728	#ifdef DEBUG
	1729	fprintf (stderr, "*\n* %s = %s ***\n", tmpn, tmpv + 1);
	1730	#endif
	1731	if (tmpmaps == NULL)
	1732	{
	1733	tmpmaps = (maps *) malloc (MAPS_SIZE);
	1734	if (tmpmaps == NULL)
	1735	{
	1736	return errorException (m,
	1737	_("Unable to allocate memory."),
	1738	"InternalError", NULL);
	1739	}
	1740	tmpmaps->name = zStrdup (tmpn);
	1741	if (tmpv != NULL)
	1742	{
	1743	char *tmpvf = url_decode (tmpv + 1);
	1744	tmpmaps->content = createMap ("value", tmpvf);
	1745	free (tmpvf);
	1746	}
	1747	else
	1748	tmpmaps->content = createMap ("value", "Reference");
	1749	tmpmaps->next = NULL;
	1750	}
	1751	tmpc = strtok (NULL, "@");
	1752	while (tmpc != NULL)
	1753	{
	1754	#ifdef DEBUG
	1755	fprintf (stderr, "* KVP NON URL-ENCODED \n%s**\n",
	1756	tmpc);
	1757	#endif
	1758	char *tmpv1 = strstr (tmpc, "=");
	1759	#ifdef DEBUG
	1760	fprintf (stderr, "* VALUE NON URL-ENCODED \n%s**\n",
	1761	tmpv1 + 1);
	1762	#endif
	1763	char tmpn1[1024];
	1764	memset (tmpn1, 0, 1024);
	1765	if (tmpv1 != NULL)
	1766	{
	1767	strncpy (tmpn1, tmpc, strlen (tmpc) - strlen (tmpv1));
	1768	tmpn1[strlen (tmpc) - strlen (tmpv1)] = 0;
	1769	addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
	1770	}
	1771	else
	1772	{
	1773	strncpy (tmpn1, tmpc, strlen (tmpc));
	1774	tmpn1[strlen (tmpc)] = 0;
	1775	map *lmap = getLastMap (tmpmaps->content);
	1776	char *tmpValue =
	1777	(char ) malloc ((strlen (tmpv) + strlen (tmpc) + 1)
	1778	sizeof (char));
	1779	sprintf (tmpValue, "%s@%s", tmpv + 1, tmpc);
	1780	free (lmap->value);
	1781	lmap->value = zStrdup (tmpValue);
	1782	free (tmpValue);
	1783	tmpc = strtok (NULL, "@");
	1784	continue;
	1785	}
	1786	#ifdef DEBUG
	1787	fprintf (stderr, "* NAME NON URL-ENCODED \n%s**\n",
	1788	tmpn1);
	1789	fprintf (stderr, "* VALUE NON URL-ENCODED \n%s**\n",
	1790	tmpv1 + 1);
	1791	#endif
	1792	if (strcmp (tmpn1, "xlink:href") != 0)
	1793	addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
	1794	else if (tmpv1 != NULL)
	1795	{
	1796	char *tmpx2 = url_decode (tmpv1 + 1);
	1797	if (strncasecmp (tmpx2, "http://", 7) != 0 &&
	1798	strncasecmp (tmpx2, "ftp://", 6) != 0 &&
	1799	strncasecmp (tmpx2, "https://", 8) != 0)
	1800	{
	1801	char emsg[1024];
	1802	sprintf (emsg,
	1803	_
	1804	("Unable to find a valid protocol to download the remote file %s"),
	1805	tmpv1 + 1);
	1806	errorException (m, emsg, "InternalError", NULL);
	1807	freeMaps (&m);
	1808	free (m);
	1809	free (REQUEST);
	1810	free (SERVICE_URL);
	1811	InternetCloseHandle (&hInternet);
	1812	freeService (&s1);
	1813	free (s1);
	1814	return 0;
	1815	}
	1816	#ifdef DEBUG
	1817	fprintf (stderr,
	1818	"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",
	1819	tmpv1 + 1);
	1820	#endif
	1821	addToMap (tmpmaps->content, tmpn1, tmpx2);
	1822	#ifndef WIN32
	1823	if (CHECK_INET_HANDLE (hInternet))
	1824	#endif
	1825	{
	1826	if (loadRemoteFile
	1827	(&m, &tmpmaps->content, &hInternet, tmpx2) < 0)
	1828	{
	1829	freeMaps (&m);
	1830	free (m);
	1831	free (REQUEST);
	1832	free (SERVICE_URL);
	1833	InternetCloseHandle (&hInternet);
	1834	freeService (&s1);
	1835	free (s1);
	1836	return 0;
	1837	}
	1838	}
	1839	free (tmpx2);
	1840	addToMap (tmpmaps->content, "Reference", tmpv1 + 1);
	1841	}
	1842	tmpc = strtok (NULL, "@");
	1843	}
	1844	#ifdef DEBUG
	1845	dumpMaps (tmpmaps);
	1846	fflush (stderr);
	1847	#endif
	1848	if (request_input_real_format == NULL)
	1849	request_input_real_format = dupMaps (&tmpmaps);
	1850	else
	1851	{
	1852	maps *testPresence =
	1853	getMaps (request_input_real_format, tmpmaps->name);
	1854	if (testPresence != NULL)
	1855	{
	1856	elements *elem =
	1857	getElements (s1->inputs, tmpmaps->name);
	1858	if (elem != NULL)
	1859	{
	1860	if (appendMapsToMaps
	1861	(m, request_input_real_format, tmpmaps,
	1862	elem) < 0)
	1863	{
	1864	freeMaps (&m);
	1865	free (m);
	1866	free (REQUEST);
	1867	free (SERVICE_URL);
	1868	InternetCloseHandle (&hInternet);
	1869	freeService (&s1);
	1870	free (s1);
	1871	return 0;
	1872	}
	1873	}
	1874	}
	1875	else
	1876	addMapsToMaps (&request_input_real_format, tmpmaps);
	1877	}
	1878	freeMaps (&tmpmaps);
	1879	free (tmpmaps);
	1880	tmpmaps = NULL;
	1881	free (tmp);
	1882	}
	1883	}
	1884	free (inputs_as_text);
	1885	}
	1886	else
	1887	{
	1888	/**
	1889	* Parse XML request
	1890	*/
	1891	xmlInitParser ();
	1892	#ifdef DEBUG
	1893	fflush (stderr);
	1894	fprintf (stderr, "BEFORE %s\n", postRequest->value);
	1895	fflush (stderr);
	1896	#endif
	1897	xmlDocPtr doc = xmlParseMemory (postRequest->value, cgiContentLength);
	1898	#ifdef DEBUG
	1899	fprintf (stderr, "AFTER\n");
	1900	fflush (stderr);
	1901	#endif
	1902	/**
	1903	* Parse every Input in DataInputs node.
	1904	*/
	1905	xmlXPathObjectPtr tmpsptr =
	1906	extractFromDoc (doc, "///*[local-name()='Input']");
	1907	xmlNodeSet *tmps = tmpsptr->nodesetval;
	1908	#ifdef DEBUG
	1909	fprintf (stderr, "***%d***\n", tmps->nodeNr);
	1910	#endif
	1911	for (int k = 0; k < tmps->nodeNr; k++)
	1912	{
	1913	maps *tmpmaps = NULL;
	1914	xmlNodePtr cur = tmps->nodeTab[k];
	1915	if (tmps->nodeTab[k]->type == XML_ELEMENT_NODE)
	1916	{
	1917	/**
	1918	* A specific Input node.
	1919	*/
	1920	#ifdef DEBUG
	1921	fprintf (stderr, "= element 0 node \"%s\"\n", cur->name);
	1922	#endif
	1923	xmlNodePtr cur2 = cur->children;
	1924	while (cur2 != NULL)
	1925	{
	1926	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	1927	cur2 = cur2->next;
	1928	if (cur2 == NULL)
	1929	break;
	1930	/**
	1931	* Indentifier
	1932	*/
	1933	if (xmlStrncasecmp
	1934	(cur2->name, BAD_CAST "Identifier",
	1935	xmlStrlen (cur2->name)) == 0)
	1936	{
	1937	xmlChar *val =
	1938	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
	1939	if (tmpmaps == NULL)
	1940	{
	1941	tmpmaps = (maps *) malloc (MAPS_SIZE);
	1942	if (tmpmaps == NULL)
	1943	{
	1944	return errorException (m,
	1945	_
	1946	("Unable to allocate memory."),
	1947	"InternalError", NULL);
	1948	}
	1949	tmpmaps->name = zStrdup ((char *) val);
	1950	tmpmaps->content = NULL;
	1951	tmpmaps->next = NULL;
	1952	}
	1953	xmlFree (val);
	1954	}
	1955	/**
	1956	* Title, Asbtract
	1957	*/
	1958	if (xmlStrncasecmp
	1959	(cur2->name, BAD_CAST "Title",
	1960	xmlStrlen (cur2->name)) == 0
	1961	\|\| xmlStrncasecmp (cur2->name, BAD_CAST "Abstract",
	1962	xmlStrlen (cur2->name)) == 0)
	1963	{
	1964	xmlChar *val =
	1965	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
	1966	if (tmpmaps == NULL)
	1967	{
	1968	tmpmaps = (maps *) malloc (MAPS_SIZE);
	1969	if (tmpmaps == NULL)
	1970	{
	1971	return errorException (m,
	1972	_
	1973	("Unable to allocate memory."),
	1974	"InternalError", NULL);
	1975	}
	1976	tmpmaps->name = zStrdup ("missingIndetifier");
	1977	tmpmaps->content =
	1978	createMap ((char ) cur2->name, (char ) val);
	1979	tmpmaps->next = NULL;
	1980	}
	1981	else
	1982	{
	1983	if (tmpmaps->content != NULL)
	1984	addToMap (tmpmaps->content,
	1985	(char ) cur2->name, (char ) val);
	1986	else
	1987	tmpmaps->content =
	1988	createMap ((char ) cur2->name, (char ) val);
	1989	}
	1990	#ifdef DEBUG
	1991	dumpMaps (tmpmaps);
	1992	#endif
	1993	xmlFree (val);
	1994	}
	1995	/**
	1996	* InputDataFormChoice (Reference or Data ?)
	1997	*/
	1998	if (xmlStrcasecmp (cur2->name, BAD_CAST "Reference") == 0)
	1999	{
	2000	/**
	2001	* Get every attribute from a Reference node
	2002	* mimeType, encoding, schema, href, method
	2003	* Header and Body gesture should be added here
	2004	*/
	2005	#ifdef DEBUG
	2006	fprintf (stderr, "REFERENCE\n");
	2007	#endif
	2008	const char *refs[5] =
	2009	{ "mimeType", "encoding", "schema", "method",
	2010	"href"
	2011	};
	2012	for (int l = 0; l < 5; l++)
	2013	{
	2014	#ifdef DEBUG
	2015	fprintf (stderr, "* %s *", refs[l]);
	2016	#endif
	2017	xmlChar *val = xmlGetProp (cur2, BAD_CAST refs[l]);
	2018	if (val != NULL && xmlStrlen (val) > 0)
	2019	{
	2020	if (tmpmaps->content != NULL)
	2021	addToMap (tmpmaps->content, refs[l],
	2022	(char *) val);
	2023	else
	2024	tmpmaps->content =
	2025	createMap (refs[l], (char *) val);
	2026	map *ltmp = getMap (tmpmaps->content, "method");
	2027	if (l == 4)
	2028	{
	2029	if (!
	2030	(ltmp != NULL
	2031	&& strncmp (ltmp->value, "POST",
	2032	4) == 0)
	2033	&& CHECK_INET_HANDLE (hInternet))
	2034	{
	2035	if (loadRemoteFile
	2036	(&m, &tmpmaps->content, &hInternet,
	2037	(char *) val) != 0)
	2038	{
	2039	freeMaps (&m);
	2040	free (m);
	2041	free (REQUEST);
	2042	free (SERVICE_URL);
	2043	InternetCloseHandle (&hInternet);
	2044	freeService (&s1);
	2045	free (s1);
	2046	return 0;
	2047	}
	2048	}
	2049	}
	2050	}
	2051	#ifdef DEBUG
	2052	fprintf (stderr, "%s\n", val);
	2053	#endif
	2054	xmlFree (val);
	2055	}
	2056	#ifdef POST_DEBUG
	2057	fprintf (stderr,
	2058	"Parse Header and Body from Reference \n");
	2059	#endif
	2060	xmlNodePtr cur3 = cur2->children;
	2061	/* HINTERNET hInternetP;
	2062	hInternetP=InternetOpen(
	2063	#ifndef WIN32
	2064	(LPCTSTR)
	2065	#endif
	2066	"ZooWPSClient\0",
	2067	INTERNET_OPEN_TYPE_PRECONFIG,
	2068	NULL,NULL, 0); */
	2069	//hInternet.ihandle[hInternet.nb].header=NULL;
	2070	while (cur3 != NULL)
	2071	{
	2072	while (cur3 != NULL
	2073	&& cur3->type != XML_ELEMENT_NODE)
	2074	cur3 = cur3->next;
	2075	if (cur3 == NULL)
	2076	break;
	2077	if (xmlStrcasecmp (cur3->name, BAD_CAST "Header") ==
	2078	0)
	2079	{
	2080	const char *ha[2];
	2081	ha[0] = "key";
	2082	ha[1] = "value";
	2083	int hai;
	2084	char *has;
	2085	char *key;
	2086	for (hai = 0; hai < 2; hai++)
	2087	{
	2088	xmlChar *val =
	2089	xmlGetProp (cur3, BAD_CAST ha[hai]);
	2090	#ifdef POST_DEBUG
	2091	fprintf (stderr, "%s = %s\n", ha[hai],
	2092	(char *) val);
	2093	#endif
	2094	if (hai == 0)
	2095	{
	2096	key = zStrdup ((char *) val);
	2097	}
	2098	else
	2099	{
	2100	has =
	2101	(char *)
	2102	malloc ((4 + xmlStrlen (val) +
	2103	strlen (key)) *
	2104	sizeof (char));
	2105	if (has == NULL)
	2106	{
	2107	return errorException (m,
	2108	_
	2109	("Unable to allocate memory."),
	2110	"InternalError",
	2111	NULL);
	2112	}
	2113	snprintf (has,
	2114	(3 + xmlStrlen (val) +
	2115	strlen (key)), "%s: %s", key,
	2116	(char *) val);
	2117	free (key);
	2118	#ifdef POST_DEBUG
	2119	fprintf (stderr, "%s\n", has);
	2120	#endif
	2121	}
	2122	xmlFree (val);
	2123	}
	2124	hInternet.ihandle[hInternet.nb].header =
	2125	curl_slist_append (hInternet.ihandle
	2126	[hInternet.nb].header,
	2127	has);
	2128	if (has != NULL)
	2129	free (has);
	2130	}
	2131	else
	2132	{
	2133	#ifdef POST_DEBUG
	2134	fprintf (stderr,
	2135	"Try to fetch the body part of the request ...\n");
	2136	#endif
	2137	if (xmlStrcasecmp (cur3->name, BAD_CAST "Body")
	2138	== 0)
	2139	{
	2140	#ifdef POST_DEBUG
	2141	fprintf (stderr, "Body part found !!!\n",
	2142	(char *) cur3->content);
	2143	#endif
	2144	char *tmp =
	2145	(char *) malloc (cgiContentLength +
	2146	1 * sizeof (char));
	2147	memset (tmp, 0, cgiContentLength);
	2148	xmlNodePtr cur4 = cur3->children;
	2149	while (cur4 != NULL)
	2150	{
	2151	while (cur4->type != XML_ELEMENT_NODE)
	2152	cur4 = cur4->next;
	2153	xmlDocPtr bdoc =
	2154	xmlNewDoc (BAD_CAST "1.0");
	2155	bdoc->encoding =
	2156	xmlCharStrdup ("UTF-8");
	2157	xmlDocSetRootElement (bdoc, cur4);
	2158	xmlChar *btmps;
	2159	int bsize;
	2160	xmlDocDumpMemory (bdoc, &btmps, &bsize);
	2161	#ifdef POST_DEBUG
	2162	fprintf (stderr,
	2163	"Body part found !!! %s %s\n",
	2164	tmp, (char *) btmps);
	2165	#endif
	2166	if (btmps != NULL)
	2167	sprintf (tmp, "%s", (char *) btmps);
	2168	xmlFree (btmps);
	2169	cur4 = cur4->next;
	2170	xmlFreeDoc (bdoc);
	2171	}
	2172	map *btmp =
	2173	getMap (tmpmaps->content, "href");
	2174	if (btmp != NULL)
	2175	{
	2176	#ifdef POST_DEBUG
	2177	fprintf (stderr, "%s %s\n", btmp->value,
	2178	tmp);
	2179	curl_easy_setopt (hInternet.handle,
	2180	CURLOPT_VERBOSE, 1);
	2181	#endif
	2182	hInternet.
	2183	waitingRequests[hInternet.nb] =
	2184	strdup (tmp);
	2185	InternetOpenUrl (&hInternet,
	2186	btmp->value,
	2187	hInternet.waitingRequests
	2188	[hInternet.nb],
	2189	strlen
	2190	(hInternet.waitingRequests
	2191	[hInternet.nb]),
	2192	INTERNET_FLAG_NO_CACHE_WRITE,
	2193	0);
	2194	}
	2195	free (tmp);
	2196	}
	2197	else
	2198	if (xmlStrcasecmp
	2199	(cur3->name,
	2200	BAD_CAST "BodyReference") == 0)
	2201	{
	2202	xmlChar *val =
	2203	xmlGetProp (cur3, BAD_CAST "href");
	2204	HINTERNET bInternet, res1;
	2205	bInternet = InternetOpen (
	2206	#ifndef WIN32
	2207	(LPCTSTR)
	2208	#endif
	2209	"ZooWPSClient\0",
	2210	INTERNET_OPEN_TYPE_PRECONFIG,
	2211	NULL, NULL, 0);
	2212	if (!CHECK_INET_HANDLE (hInternet))
	2213	fprintf (stderr,
	2214	"WARNING : hInternet handle failed to initialize");
	2215	#ifdef POST_DEBUG
	2216	curl_easy_setopt (bInternet.handle,
	2217	CURLOPT_VERBOSE, 1);
	2218	#endif
	2219	bInternet.waitingRequests[0] =
	2220	strdup ((char *) val);
	2221	res1 =
	2222	InternetOpenUrl (&bInternet,
	2223	bInternet.waitingRequests
	2224	[0], NULL, 0,
	2225	INTERNET_FLAG_NO_CACHE_WRITE,
	2226	0);
	2227	processDownloads (&bInternet);
	2228	char *tmp =
	2229	(char *)
	2230	malloc ((bInternet.ihandle[0].nDataLen +
	2231	1) * sizeof (char));
	2232	if (tmp == NULL)
	2233	{
	2234	return errorException (m,
	2235	_
	2236	("Unable to allocate memory."),
	2237	"InternalError",
	2238	NULL);
	2239	}
	2240	size_t bRead;
	2241	InternetReadFile (bInternet.ihandle[0],
	2242	(LPVOID) tmp,
	2243	bInternet.
	2244	ihandle[0].nDataLen,
	2245	&bRead);
	2246	tmp[bInternet.ihandle[0].nDataLen] = 0;
	2247	InternetCloseHandle (&bInternet);
	2248	map *btmp =
	2249	getMap (tmpmaps->content, "href");
	2250	if (btmp != NULL)
	2251	{
	2252	#ifdef POST_DEBUG
	2253	fprintf (stderr, "%s %s\n", btmp->value,
	2254	tmp);
	2255	#endif
	2256	hInternet.
	2257	waitingRequests[hInternet.nb] =
	2258	strdup (tmp);
	2259	res =
	2260	InternetOpenUrl (&hInternet,
	2261	btmp->value,
	2262	hInternet.waitingRequests
	2263	[hInternet.nb],
	2264	strlen
	2265	(hInternet.waitingRequests
	2266	[hInternet.nb]),
	2267	INTERNET_FLAG_NO_CACHE_WRITE,
	2268	0);
	2269	}
	2270	free (tmp);
	2271	}
	2272	}
	2273	cur3 = cur3->next;
	2274	}
	2275	#ifdef POST_DEBUG
	2276	fprintf (stderr,
	2277	"Header and Body was parsed from Reference \n");
	2278	#endif
	2279	#ifdef DEBUG
	2280	dumpMap (tmpmaps->content);
	2281	fprintf (stderr, "= element 2 node \"%s\" = (%s)\n",
	2282	cur2->name, cur2->content);
	2283	#endif
	2284	}
	2285	else if (xmlStrcasecmp (cur2->name, BAD_CAST "Data") == 0)
	2286	{
	2287	#ifdef DEBUG
	2288	fprintf (stderr, "DATA\n");
	2289	#endif
	2290	xmlNodePtr cur4 = cur2->children;
	2291	while (cur4 != NULL)
	2292	{
	2293	while (cur4 != NULL
	2294	&& cur4->type != XML_ELEMENT_NODE)
	2295	cur4 = cur4->next;
	2296	if (cur4 == NULL)
	2297	break;
	2298	if (xmlStrcasecmp
	2299	(cur4->name, BAD_CAST "LiteralData") == 0)
	2300	{
	2301	/**
	2302	* Get every attribute from a LiteralData node
	2303	* dataType , uom
	2304	*/
	2305	char *list[2];
	2306	list[0] = zStrdup ("dataType");
	2307	list[1] = zStrdup ("uom");
	2308	for (int l = 0; l < 2; l++)
	2309	{
	2310	#ifdef DEBUG
	2311	fprintf (stderr, "* LiteralData %s *",
	2312	list[l]);
	2313	#endif
	2314	xmlChar *val =
	2315	xmlGetProp (cur4, BAD_CAST list[l]);
	2316	if (val != NULL
	2317	&& strlen ((char *) val) > 0)
	2318	{
	2319	if (tmpmaps->content != NULL)
	2320	addToMap (tmpmaps->content, list[l],
	2321	(char *) val);
	2322	else
	2323	tmpmaps->content =
	2324	createMap (list[l], (char *) val);
	2325	#ifdef DEBUG
	2326	fprintf (stderr, "%s\n", val);
	2327	#endif
	2328	}
	2329	xmlFree (val);
	2330	free (list[l]);
	2331	}
	2332	}
	2333	else
	2334	if (xmlStrcasecmp
	2335	(cur4->name, BAD_CAST "ComplexData") == 0)
	2336	{
	2337	/**
	2338	* Get every attribute from a Reference node
	2339	* mimeType, encoding, schema
	2340	*/
	2341	const char *coms[3] =
	2342	{ "mimeType", "encoding", "schema" };
	2343	for (int l = 0; l < 3; l++)
	2344	{
	2345	#ifdef DEBUG
	2346	fprintf (stderr, "* ComplexData %s *\n",
	2347	coms[l]);
	2348	#endif
	2349	xmlChar *val =
	2350	xmlGetProp (cur4, BAD_CAST coms[l]);
	2351	if (val != NULL
	2352	&& strlen ((char *) val) > 0)
	2353	{
	2354	if (tmpmaps->content != NULL)
	2355	addToMap (tmpmaps->content, coms[l],
	2356	(char *) val);
	2357	else
	2358	tmpmaps->content =
	2359	createMap (coms[l], (char *) val);
	2360	#ifdef DEBUG
	2361	fprintf (stderr, "%s\n", val);
	2362	#endif
	2363	}
	2364	xmlFree (val);
	2365	}
	2366	}
	2367
	2368	map *test = getMap (tmpmaps->content, "encoding");
	2369	if (test == NULL)
	2370	{
	2371	if (tmpmaps->content != NULL)
	2372	addToMap (tmpmaps->content, "encoding",
	2373	"utf-8");
	2374	else
	2375	tmpmaps->content =
	2376	createMap ("encoding", "utf-8");
	2377	test = getMap (tmpmaps->content, "encoding");
	2378	}
	2379
	2380	if (strcasecmp (test->value, "base64") != 0)
	2381	{
	2382	xmlChar *mv = xmlNodeListGetString (doc,
	2383	cur4->
	2384	xmlChildrenNode,
	2385	1);
	2386	map *ltmp =
	2387	getMap (tmpmaps->content, "mimeType");
	2388	if (mv == NULL
	2389	\|\|
	2390	(xmlStrcasecmp
	2391	(cur4->name, BAD_CAST "ComplexData") == 0
	2392	&& (ltmp == NULL
	2393	\|\| strncasecmp (ltmp->value,
	2394	"text/xml", 8) == 0)))
	2395	{
	2396	xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
	2397	int buffersize;
	2398	xmlNodePtr cur5 = cur4->children;
	2399	while (cur5 != NULL
	2400	&& cur5->type != XML_ELEMENT_NODE
	2401	&& cur5->type !=
	2402	XML_CDATA_SECTION_NODE)
	2403	cur5 = cur5->next;
	2404	if (cur5 != NULL
	2405	&& cur5->type != XML_CDATA_SECTION_NODE)
	2406	{
	2407	xmlDocSetRootElement (doc1, cur5);
	2408	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	2409	&buffersize,
	2410	"utf-8", 1);
	2411	char size[1024];
	2412	sprintf (size, "%d", buffersize);
	2413	addToMap (tmpmaps->content, "size",
	2414	size);
	2415	xmlFreeDoc (doc1);
	2416	}
	2417	}
	2418	if (mv != NULL)
	2419	{
	2420	addToMap (tmpmaps->content, "value",
	2421	(char *) mv);
	2422	xmlFree (mv);
	2423	}
	2424	}
	2425	else
	2426	{
	2427	xmlChar *tmp = xmlNodeListGetRawString (doc,
	2428	cur4->xmlChildrenNode,
	2429	0);
	2430	addToMap (tmpmaps->content, "value",
	2431	(char *) tmp);
	2432	map *tmpv = getMap (tmpmaps->content, "value");
	2433	char *res = NULL;
	2434	char *curs = tmpv->value;
	2435	for (int i = 0; i <= strlen (tmpv->value) / 64;
	2436	i++)
	2437	{
	2438	if (res == NULL)
	2439	res =
	2440	(char ) malloc (67 sizeof (char));
	2441	else
	2442	res =
	2443	(char *) realloc (res,
	2444	(((i + 1) * 65) +
	2445	i) * sizeof (char));
	2446	int csize = i * 65;
	2447	strncpy (res + csize, curs, 64);
	2448	if (i == xmlStrlen (tmp) / 64)
	2449	strcat (res, "\n\0");
	2450	else
	2451	{
	2452	strncpy (res + (((i + 1) * 64) + i),
	2453	"\n\0", 2);
	2454	curs += 64;
	2455	}
	2456	}
	2457	free (tmpv->value);
	2458	tmpv->value = zStrdup (res);
	2459	free (res);
	2460	xmlFree (tmp);
	2461	}
	2462	cur4 = cur4->next;
	2463	}
	2464	}
	2465	#ifdef DEBUG
	2466	fprintf (stderr, "cur2 next \n");
	2467	fflush (stderr);
	2468	#endif
	2469	cur2 = cur2->next;
	2470	}
	2471	#ifdef DEBUG
	2472	fprintf (stderr, "ADD MAPS TO REQUEST MAPS !\n");
	2473	fflush (stderr);
	2474	#endif
	2475
	2476	{
	2477	maps *testPresence =
	2478	getMaps (request_input_real_format, tmpmaps->name);
	2479	if (testPresence != NULL)
	2480	{
	2481	elements *elem = getElements (s1->inputs, tmpmaps->name);
	2482	if (elem != NULL)
	2483	{
	2484	if (appendMapsToMaps
	2485	(m, request_input_real_format, tmpmaps, elem) < 0)
	2486	{
	2487	freeMaps (&m);
	2488	free (m);
	2489	free (REQUEST);
	2490	free (SERVICE_URL);
	2491	InternetCloseHandle (&hInternet);
	2492	freeService (&s1);
	2493	free (s1);
	2494	return 0;
	2495	}
	2496	}
	2497	}
	2498	else
	2499	addMapsToMaps (&request_input_real_format, tmpmaps);
	2500	}
	2501
	2502	#ifdef DEBUG
	2503	fprintf (stderr, "****TMPMAPS***\n");
	2504	dumpMaps (tmpmaps);
	2505	fprintf (stderr, "****REQUESTMAPS***\n");
	2506	dumpMaps (request_input_real_format);
	2507	#endif
	2508	freeMaps (&tmpmaps);
	2509	free (tmpmaps);
	2510	tmpmaps = NULL;
	2511	}
	2512	#ifdef DEBUG
	2513	dumpMaps (tmpmaps);
	2514	#endif
	2515	}
	2516	#ifdef DEBUG
	2517	fprintf (stderr, "Search for response document node\n");
	2518	#endif
	2519	xmlXPathFreeObject (tmpsptr);
	2520
	2521	tmpsptr =
	2522	extractFromDoc (doc, "///*[local-name()='ResponseDocument']");
	2523	bool asRaw = false;
	2524	tmps = tmpsptr->nodesetval;
	2525	if (tmps->nodeNr == 0)
	2526	{
	2527	xmlXPathFreeObject (tmpsptr);
	2528	tmpsptr =
	2529	extractFromDoc (doc, "///*[local-name()='RawDataOutput']");
	2530	tmps = tmpsptr->nodesetval;
	2531	asRaw = true;
	2532	}
	2533	#ifdef DEBUG
	2534	fprintf (stderr, "***%d***\n", tmps->nodeNr);
	2535	#endif
	2536	if (asRaw == true)
	2537	{
	2538	addToMap (request_inputs, "RawDataOutput", "");
	2539	xmlNodePtr cur0 = tmps->nodeTab[0];
	2540	if (cur0->type == XML_ELEMENT_NODE)
	2541	{
	2542
	2543	maps tmpmaps = (maps ) malloc (MAPS_SIZE);
	2544	if (tmpmaps == NULL)
	2545	{
	2546	return errorException (m, _("Unable to allocate memory."),
	2547	"InternalError", NULL);
	2548	}
	2549	tmpmaps->name = zStrdup ("unknownIdentifier");
	2550	tmpmaps->content = NULL;
	2551	tmpmaps->next = NULL;
	2552
	2553	/**
	2554	* Get every attribute from a RawDataOutput node
	2555	* mimeType, encoding, schema, uom
	2556	*/
	2557	const char *outs[4] =
	2558	{ "mimeType", "encoding", "schema", "uom" };
	2559	for (int l = 0; l < 4; l++)
	2560	{
	2561	#ifdef DEBUG
	2562	fprintf (stderr, "* %s *\t", outs[l]);
	2563	#endif
	2564	xmlChar *val = xmlGetProp (cur0, BAD_CAST outs[l]);
	2565	if (val != NULL)
	2566	{
	2567	if (strlen ((char *) val) > 0)
	2568	{
	2569	if (tmpmaps->content != NULL)
	2570	addToMap (tmpmaps->content, outs[l],
	2571	(char *) val);
	2572	else
	2573	tmpmaps->content =
	2574	createMap (outs[l], (char *) val);
	2575	}
	2576	xmlFree (val);
	2577	}
	2578	}
	2579	xmlNodePtr cur2 = cur0->children;
	2580	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	2581	cur2 = cur2->next;
	2582	int cur1cnt = 0;
	2583	while (cur2 != NULL)
	2584	{
	2585	if (xmlStrncasecmp
	2586	(cur2->name, BAD_CAST "Identifier",
	2587	xmlStrlen (cur2->name)) == 0)
	2588	{
	2589	xmlChar *val =
	2590	xmlNodeListGetString (NULL, cur2->xmlChildrenNode, 1);
	2591	free (tmpmaps->name);
	2592	tmpmaps->name = zStrdup ((char *) val);
	2593	xmlFree (val);
	2594	}
	2595	cur2 = cur2->next;
	2596	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	2597	cur2 = cur2->next;
	2598	}
	2599	if (request_output_real_format == NULL)
	2600	request_output_real_format = dupMaps (&tmpmaps);
	2601	else
	2602	addMapsToMaps (&request_output_real_format, tmpmaps);
	2603	if (tmpmaps != NULL)
	2604	{
	2605	freeMaps (&tmpmaps);
	2606	free (tmpmaps);
	2607	tmpmaps = NULL;
	2608	}
	2609	}
	2610	}
	2611	else
	2612	for (int k = 0; k < tmps->nodeNr; k++)
	2613	{
	2614	//else
	2615	addToMap (request_inputs, "ResponseDocument", "");
	2616	maps *tmpmaps = NULL;
	2617	xmlNodePtr cur = tmps->nodeTab[k];
	2618	if (cur->type == XML_ELEMENT_NODE)
	2619	{
	2620	/**
	2621	* A specific responseDocument node.
	2622	*/
	2623	if (tmpmaps == NULL)
	2624	{
	2625	tmpmaps = (maps *) malloc (MAPS_SIZE);
	2626	if (tmpmaps == NULL)
	2627	{
	2628	return errorException (m,
	2629	_
	2630	("Unable to allocate memory."),
	2631	"InternalError", NULL);
	2632	}
	2633	tmpmaps->name = zStrdup ("unknownIdentifier");
	2634	tmpmaps->content = NULL;
	2635	tmpmaps->next = NULL;
	2636	}
	2637	/**
	2638	* Get every attribute: storeExecuteResponse, lineage, status
	2639	*/
	2640	const char *ress[3] =
	2641	{ "storeExecuteResponse", "lineage", "status" };
	2642	xmlChar *val;
	2643	for (int l = 0; l < 3; l++)
	2644	{
	2645	#ifdef DEBUG
	2646	fprintf (stderr, "* %s *\t", ress[l]);
	2647	#endif
	2648	val = xmlGetProp (cur, BAD_CAST ress[l]);
	2649	if (val != NULL && strlen ((char *) val) > 0)
	2650	{
	2651	if (tmpmaps->content != NULL)
	2652	addToMap (tmpmaps->content, ress[l], (char *) val);
	2653	else
	2654	tmpmaps->content =
	2655	createMap (ress[l], (char *) val);
	2656	addToMap (request_inputs, ress[l], (char *) val);
	2657	}
	2658	#ifdef DEBUG
	2659	fprintf (stderr, "%s\n", val);
	2660	#endif
	2661	xmlFree (val);
	2662	}
	2663	xmlNodePtr cur1 = cur->children;
	2664	while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
	2665	cur1 = cur1->next;
	2666	int cur1cnt = 0;
	2667	while (cur1)
	2668	{
	2669	/**
	2670	* Indentifier
	2671	*/
	2672	if (xmlStrncasecmp
	2673	(cur1->name, BAD_CAST "Identifier",
	2674	xmlStrlen (cur1->name)) == 0)
	2675	{
	2676	xmlChar *val =
	2677	xmlNodeListGetString (doc, cur1->xmlChildrenNode,
	2678	1);
	2679	if (tmpmaps == NULL)
	2680	{
	2681	tmpmaps = (maps *) malloc (MAPS_SIZE);
	2682	if (tmpmaps == NULL)
	2683	{
	2684	return errorException (m,
	2685	_
	2686	("Unable to allocate memory."),
	2687	"InternalError", NULL);
	2688	}
	2689	tmpmaps->name = zStrdup ((char *) val);
	2690	tmpmaps->content = NULL;
	2691	tmpmaps->next = NULL;
	2692	}
	2693	else
	2694	{
	2695	free (tmpmaps->name);
	2696	tmpmaps->name = zStrdup ((char *) val);
	2697	}
	2698	if (asRaw == true)
	2699	addToMap (request_inputs, "RawDataOutput",
	2700	(char *) val);
	2701	else
	2702	{
	2703	if (cur1cnt == 0)
	2704	addToMap (request_inputs, "ResponseDocument",
	2705	(char *) val);
	2706	else
	2707	{
	2708	map *tt =
	2709	getMap (request_inputs, "ResponseDocument");
	2710	char *tmp = zStrdup (tt->value);
	2711	free (tt->value);
	2712	tt->value =
	2713	(char *)
	2714	malloc ((strlen (tmp) +
	2715	strlen ((char *) val) +
	2716	1) * sizeof (char));
	2717	sprintf (tt->value, "%s;%s", tmp,
	2718	(char *) val);
	2719	free (tmp);
	2720	}
	2721	}
	2722	cur1cnt += 1;
	2723	xmlFree (val);
	2724	}
	2725	/**
	2726	* Title, Asbtract
	2727	*/
	2728	else
	2729	if (xmlStrncasecmp
	2730	(cur1->name, BAD_CAST "Title",
	2731	xmlStrlen (cur1->name)) == 0
	2732	\|\| xmlStrncasecmp (cur1->name, BAD_CAST "Abstract",
	2733	xmlStrlen (cur1->name)) == 0)
	2734	{
	2735	xmlChar *val =
	2736	xmlNodeListGetString (doc, cur1->xmlChildrenNode,
	2737	1);
	2738	if (tmpmaps == NULL)
	2739	{
	2740	tmpmaps = (maps *) malloc (MAPS_SIZE);
	2741	if (tmpmaps == NULL)
	2742	{
	2743	return errorException (m,
	2744	_
	2745	("Unable to allocate memory."),
	2746	"InternalError", NULL);
	2747	}
	2748	tmpmaps->name = zStrdup ("missingIndetifier");
	2749	tmpmaps->content =
	2750	createMap ((char ) cur1->name, (char ) val);
	2751	tmpmaps->next = NULL;
	2752	}
	2753	else
	2754	{
	2755	if (tmpmaps->content != NULL)
	2756	addToMap (tmpmaps->content, (char *) cur1->name,
	2757	(char *) val);
	2758	else
	2759	tmpmaps->content =
	2760	createMap ((char ) cur1->name, (char ) val);
	2761	}
	2762	xmlFree (val);
	2763	}
	2764	else
	2765	if (xmlStrncasecmp
	2766	(cur1->name, BAD_CAST "Output",
	2767	xmlStrlen (cur1->name)) == 0)
	2768	{
	2769	/**
	2770	* Get every attribute from a Output node
	2771	* mimeType, encoding, schema, uom, asReference
	2772	*/
	2773	const char *outs[5] =
	2774	{ "mimeType", "encoding", "schema", "uom",
	2775	"asReference"
	2776	};
	2777	for (int l = 0; l < 5; l++)
	2778	{
	2779	#ifdef DEBUG
	2780	fprintf (stderr, "* %s *\t", outs[l]);
	2781	#endif
	2782	xmlChar *val =
	2783	xmlGetProp (cur1, BAD_CAST outs[l]);
	2784	if (val != NULL && strlen ((char *) val) > 0)
	2785	{
	2786	if (tmpmaps->content != NULL)
	2787	addToMap (tmpmaps->content, outs[l],
	2788	(char *) val);
	2789	else
	2790	tmpmaps->content =
	2791	createMap (outs[l], (char *) val);
	2792	}
	2793	#ifdef DEBUG
	2794	fprintf (stderr, "%s\n", val);
	2795	#endif
	2796	xmlFree (val);
	2797	}
	2798	xmlNodePtr cur2 = cur1->children;
	2799	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	2800	cur2 = cur2->next;
	2801	while (cur2)
	2802	{
	2803	/**
	2804	* Indentifier
	2805	*/
	2806	if (xmlStrncasecmp
	2807	(cur2->name, BAD_CAST "Identifier",
	2808	xmlStrlen (cur2->name)) == 0)
	2809	{
	2810	xmlChar *val = xmlNodeListGetString (doc,
	2811	cur2->
	2812	xmlChildrenNode,
	2813	1);
	2814	if (tmpmaps == NULL)
	2815	{
	2816	tmpmaps = (maps *) malloc (MAPS_SIZE);
	2817	if (tmpmaps == NULL)
	2818	{
	2819	return errorException (m,
	2820	_
	2821	("Unable to allocate memory."),
	2822	"InternalError",
	2823	NULL);
	2824	}
	2825	tmpmaps->name = zStrdup ((char *) val);
	2826	tmpmaps->content = NULL;
	2827	tmpmaps->next = NULL;
	2828	}
	2829	else
	2830	{
	2831	if (tmpmaps->name != NULL)
	2832	free (tmpmaps->name);
	2833	tmpmaps->name = zStrdup ((char *) val);;
	2834	}
	2835	xmlFree (val);
	2836	}
	2837	/**
	2838	* Title, Asbtract
	2839	*/
	2840	else
	2841	if (xmlStrncasecmp
	2842	(cur2->name, BAD_CAST "Title",
	2843	xmlStrlen (cur2->name)) == 0
	2844	\|\| xmlStrncasecmp (cur2->name,
	2845	BAD_CAST "Abstract",
	2846	xmlStrlen (cur2->name))
	2847	== 0)
	2848	{
	2849	xmlChar *val = xmlNodeListGetString (doc,
	2850	cur2->
	2851	xmlChildrenNode,
	2852	1);
	2853	if (tmpmaps == NULL)
	2854	{
	2855	tmpmaps = (maps *) malloc (MAPS_SIZE);
	2856	if (tmpmaps == NULL)
	2857	{
	2858	return errorException (m,
	2859	_
	2860	("Unable to allocate memory."),
	2861	"InternalError",
	2862	NULL);
	2863	}
	2864	tmpmaps->name =
	2865	zStrdup ("missingIndetifier");
	2866	tmpmaps->content =
	2867	createMap ((char *) cur2->name,
	2868	(char *) val);
	2869	tmpmaps->next = NULL;
	2870	}
	2871	else
	2872	{
	2873	if (tmpmaps->content != NULL)
	2874	addToMap (tmpmaps->content,
	2875	(char *) cur2->name,
	2876	(char *) val);
	2877	else
	2878	tmpmaps->content =
	2879	createMap ((char *) cur2->name,
	2880	(char *) val);
	2881	}
	2882	xmlFree (val);
	2883	}
	2884	cur2 = cur2->next;
	2885	while (cur2 != NULL
	2886	&& cur2->type != XML_ELEMENT_NODE)
	2887	cur2 = cur2->next;
	2888	}
	2889	}
	2890	cur1 = cur1->next;
	2891	while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
	2892	cur1 = cur1->next;
	2893	}
	2894	}
	2895	if (request_output_real_format == NULL)
	2896	request_output_real_format = dupMaps (&tmpmaps);
	2897	else
	2898	addMapsToMaps (&request_output_real_format, tmpmaps);
	2899	if (tmpmaps != NULL)
	2900	{
	2901	freeMaps (&tmpmaps);
	2902	free (tmpmaps);
	2903	tmpmaps = NULL;
	2904	}
	2905	}
	2906	xmlXPathFreeObject (tmpsptr);
	2907	xmlFreeDoc (doc);
	2908	xmlCleanupParser ();
	2909	}
	2910
	2911	runHttpRequests (&m, &request_input_real_format, &hInternet);
	2912
	2913	// if(CHECK_INET_HANDLE(hInternet))
	2914	InternetCloseHandle (&hInternet);
	2915
	2916	#ifdef DEBUG
	2917	fprintf (stderr, "\n%d\n", __LINE__);
	2918	fflush (stderr);
	2919	dumpMaps (request_input_real_format);
	2920	dumpMaps (request_output_real_format);
	2921	dumpMap (request_inputs);
	2922	fprintf (stderr, "\n%d\n", __LINE__);
	2923	fflush (stderr);
	2924	#endif
	2925
	2926	/**
	2927	* Ensure that each requested arguments are present in the request
	2928	* DataInputs and ResponseDocument / RawDataOutput
	2929	*/
	2930	char *dfv = addDefaultValues (&request_input_real_format, s1->inputs, m, 0);
	2931	maps *ptr = request_input_real_format;
	2932	while (ptr != NULL)
	2933	{
	2934	map *tmp0 = getMap (ptr->content, "size");
	2935	map *tmp1 = getMap (ptr->content, "maximumMegabytes");
	2936	if (tmp1 != NULL && tmp0 != NULL)
	2937	{
	2938	float i = atof (tmp0->value) / 1048576.0;
	2939	if (i >= atoi (tmp1->value))
	2940	{
	2941	char tmps[1024];
	2942	map *tmpe = createMap ("code", "FileSizeExceeded");
	2943	snprintf (tmps, 1024,
	2944	_
	2945	("The <%s> parameter has a limited size (%sMB) defined in ZOO ServicesProvider configuration file but the reference you provided exceed this limitation (%fMB), please correct your query or the ZOO Configuration file."),
	2946	ptr->name, tmp1->value, i);
	2947	addToMap (tmpe, "locator", ptr->name);
	2948	addToMap (tmpe, "text", tmps);
	2949	printExceptionReportResponse (m, tmpe);
	2950	freeService (&s1);
	2951	free (s1);
	2952	freeMap (&tmpe);
	2953	free (tmpe);
	2954	freeMaps (&m);
	2955	free (m);
	2956	free (REQUEST);
	2957	free (SERVICE_URL);
	2958	freeMaps (&request_input_real_format);
	2959	free (request_input_real_format);
	2960	freeMaps (&request_output_real_format);
	2961	free (request_output_real_format);
	2962	freeMaps (&tmpmaps);
	2963	free (tmpmaps);
	2964	return 1;
	2965	}
	2966	}
	2967	ptr = ptr->next;
	2968	}
	2969
	2970	char *dfv1 =
	2971	addDefaultValues (&request_output_real_format, s1->outputs, m, 1);
	2972	if (strcmp (dfv1, "") != 0 \|\| strcmp (dfv, "") != 0)
	2973	{
	2974	char tmps[1024];
	2975	map *tmpe = createMap ("code", "MissingParameterValue");
	2976	if (strcmp (dfv, "") != 0)
	2977	{
	2978	snprintf (tmps, 1024,
	2979	_
	2980	("The <%s> argument was not specified in DataInputs but defined as requested in ZOO ServicesProvider configuration file, please correct your query or the ZOO Configuration file."),
	2981	dfv);
	2982	addToMap (tmpe, "locator", dfv);
	2983	}
	2984	else if (strcmp (dfv1, "") != 0)
	2985	{
	2986	snprintf (tmps, 1024,
	2987	_
	2988	("The <%s> argument was specified as Output identifier but not defined in the ZOO Configuration File. Please, correct your query or the ZOO Configuration File."),
	2989	dfv1);
	2990	addToMap (tmpe, "locator", dfv1);
	2991	}
	2992	addToMap (tmpe, "text", tmps);
	2993	printExceptionReportResponse (m, tmpe);
	2994	freeService (&s1);
	2995	free (s1);
	2996	freeMap (&tmpe);
	2997	free (tmpe);
	2998	freeMaps (&m);
	2999	free (m);
	3000	free (REQUEST);
	3001	free (SERVICE_URL);
	3002	freeMaps (&request_input_real_format);
	3003	free (request_input_real_format);
	3004	freeMaps (&request_output_real_format);
	3005	free (request_output_real_format);
	3006	freeMaps (&tmpmaps);
	3007	free (tmpmaps);
	3008	return 1;
	3009	}
	3010	maps *tmpReqI = request_input_real_format;
	3011	while (tmpReqI != NULL)
	3012	{
	3013	char name[1024];
	3014	if (getMap (tmpReqI->content, "isFile") != NULL)
	3015	{
	3016	if (cgiFormFileName (tmpReqI->name, name, sizeof (name)) ==
	3017	cgiFormSuccess)
	3018	{
	3019	int BufferLen = 1024;
	3020	cgiFilePtr file;
	3021	int targetFile;
	3022	char storageNameOnServer[2048];
	3023	char fileNameOnServer[64];
	3024	char contentType[1024];
	3025	char buffer[1024];
	3026	char *tmpStr = NULL;
	3027	int size;
	3028	int got, t;
	3029	map *path = getMapFromMaps (m, "main", "tmpPath");
	3030	cgiFormFileSize (tmpReqI->name, &size);
	3031	cgiFormFileContentType (tmpReqI->name, contentType,
	3032	sizeof (contentType));
	3033	if (cgiFormFileOpen (tmpReqI->name, &file) == cgiFormSuccess)
	3034	{
	3035	t = -1;
	3036	while (1)
	3037	{
	3038	tmpStr = strstr (name + t + 1, "\\");
	3039	if (NULL == tmpStr)
	3040	tmpStr = strstr (name + t + 1, "/");
	3041	if (NULL != tmpStr)
	3042	t = (int) (tmpStr - name);
	3043	else
	3044	break;
	3045	}
	3046	strcpy (fileNameOnServer, name + t + 1);
	3047
	3048	sprintf (storageNameOnServer, "%s/%s", path->value,
	3049	fileNameOnServer);
	3050	#ifdef DEBUG
	3051	fprintf (stderr, "Name on server %s\n",
	3052	storageNameOnServer);
	3053	fprintf (stderr, "fileNameOnServer: %s\n",
	3054	fileNameOnServer);
	3055	#endif
	3056	targetFile =
	3057	open (storageNameOnServer, O_RDWR \| O_CREAT \| O_TRUNC,
	3058	S_IRWXU \| S_IRGRP \| S_IROTH);
	3059	if (targetFile < 0)
	3060	{
	3061	#ifdef DEBUG
	3062	fprintf (stderr, "could not create the new file,%s\n",
	3063	fileNameOnServer);
	3064	#endif
	3065	}
	3066	else
	3067	{
	3068	while (cgiFormFileRead (file, buffer, BufferLen, &got)
	3069	== cgiFormSuccess)
	3070	{
	3071	if (got > 0)
	3072	write (targetFile, buffer, got);
	3073	}
	3074	}
	3075	addToMap (tmpReqI->content, "lref", storageNameOnServer);
	3076	cgiFormFileClose (file);
	3077	close (targetFile);
	3078	#ifdef DEBUG
	3079	fprintf (stderr, "File \"%s\" has been uploaded",
	3080	fileNameOnServer);
	3081	#endif
	3082	}
	3083	}
	3084	}
	3085	tmpReqI = tmpReqI->next;
	3086	}
	3087
	3088	ensureDecodedBase64 (&request_input_real_format);
	3089
	3090	#ifdef DEBUG
	3091	fprintf (stderr, "REQUEST_INPUTS\n");
	3092	dumpMaps (request_input_real_format);
	3093	fprintf (stderr, "REQUEST_OUTPUTS\n");
	3094	dumpMaps (request_output_real_format);
	3095	#endif
	3096
	3097	maps *curs = getMaps (m, "env");
	3098	if (curs != NULL)
	3099	{
	3100	map *mapcs = curs->content;
	3101	while (mapcs != NULLMAP)
	3102	{
	3103	#ifndef WIN32
	3104	setenv (mapcs->name, mapcs->value, 1);
	3105	#else
	3106	#ifdef DEBUG
	3107	fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
	3108	mapcs->value);
	3109	#endif
	3110	if (mapcs->value[strlen (mapcs->value) - 2] == '\r')
	3111	{
	3112	#ifdef DEBUG
	3113	fprintf (stderr, "[ZOO: Env var finish with \r]\n");
	3114	#endif
	3115	mapcs->value[strlen (mapcs->value) - 1] = 0;
	3116	}
	3117	#ifdef DEBUG
	3118	if (SetEnvironmentVariable (mapcs->name, mapcs->value) == 0)
	3119	{
	3120	fflush (stderr);
	3121	fprintf (stderr, "setting variable... %s\n", "OK");
	3122	}
	3123	else
	3124	{
	3125	fflush (stderr);
	3126	fprintf (stderr, "setting variable... %s\n", "OK");
	3127	}
	3128	#else
	3129
	3130
	3131	SetEnvironmentVariable (mapcs->name, mapcs->value);
	3132	#endif
	3133	char *toto =
	3134	(char *)
	3135	malloc ((strlen (mapcs->name) + strlen (mapcs->value) +
	3136	2) * sizeof (char));
	3137	sprintf (toto, "%s=%s", mapcs->name, mapcs->value);
	3138	putenv (toto);
	3139	#ifdef DEBUG
	3140	fflush (stderr);
	3141	#endif
	3142	#endif
	3143	#ifdef DEBUG
	3144	fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
	3145	mapcs->value);
	3146	fflush (stderr);
	3147	#endif
	3148	mapcs = mapcs->next;
	3149	}
	3150	}
	3151
	3152	#ifdef DEBUG
	3153	dumpMap (request_inputs);
	3154	#endif
	3155
	3156	/**
	3157	* Need to check if we need to fork to load a status enabled
	3158	*/
	3159	r_inputs = NULL;
	3160	map *store = getMap (request_inputs, "storeExecuteResponse");
	3161	map *status = getMap (request_inputs, "status");
	3162	/**
	3163	* 05-007r7 WPS 1.0.0 page 57 :
	3164	* 'If status="true" and storeExecuteResponse is "false" then the service
	3165	* shall raise an exception.'
	3166	*/
	3167	if (status != NULL && strcmp (status->value, "true") == 0 &&
	3168	store != NULL && strcmp (store->value, "false") == 0)
	3169	{
	3170	errorException (m,
	3171	_
	3172	("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."),
	3173	"InvalidParameterValue", "storeExecuteResponse");
	3174	freeService (&s1);
	3175	free (s1);
	3176	freeMaps (&m);
	3177	free (m);
	3178
	3179	freeMaps (&request_input_real_format);
	3180	free (request_input_real_format);
	3181
	3182	freeMaps (&request_output_real_format);
	3183	free (request_output_real_format);
	3184
	3185	free (REQUEST);
	3186	free (SERVICE_URL);
	3187	return 1;
	3188	}
	3189	r_inputs = getMap (request_inputs, "storeExecuteResponse");
	3190	int eres = SERVICE_STARTED;
	3191	int cpid = getpid ();
	3192
	3193	/**
	3194	* Initialize the specific [lenv] section which contains runtime variables:
	3195	*
	3196	* - usid : it is an unique identification number
	3197	* - sid : it is the process idenfitication number (OS)
	3198	* - status : value between 0 and 100 to express the completude of
	3199	* the operations of the running service
	3200	* - message : is a string where you can store error messages, in case
	3201	* service is failing, or o provide details on the ongoing operation.
	3202	* - cwd : is the current working directory
	3203	* - soap : is a boolean value, true if the request was contained in a SOAP
	3204	* Envelop
	3205	* - sessid : string storing the session identifier (only when cookie is
	3206	* used)
	3207	* - cgiSid : only defined on Window platforms (for being able to identify
	3208	* the created process)
	3209	*
	3210	*/
	3211	maps _tmpMaps = (maps ) malloc (MAPS_SIZE);
	3212	_tmpMaps->name = zStrdup ("lenv");
	3213	char tmpBuff[100];
	3214	semid lid = getShmLockId (NULL, 1);
	3215	lockShm (lid);
	3216	struct ztimeval tp;
	3217	if (zGettimeofday (&tp, NULL) == 0)
	3218	sprintf (tmpBuff, "%i", (cpid + ((int) tp.tv_sec + (int) tp.tv_usec)));
	3219	else
	3220	sprintf (tmpBuff, "%i", (cpid + (int) time (NULL)));
	3221	unlockShm (lid);
	3222	removeShmLock (NULL, 1);
	3223	_tmpMaps->content = createMap ("usid", tmpBuff);
	3224	_tmpMaps->next = NULL;
	3225	sprintf (tmpBuff, "%i", cpid);
	3226	addToMap (_tmpMaps->content, "sid", tmpBuff);
	3227	addToMap (_tmpMaps->content, "status", "0");
	3228	addToMap (_tmpMaps->content, "cwd", ntmp);
	3229	addToMap (_tmpMaps->content, "message", _("No message provided"));
	3230	map *ltmp = getMap (request_inputs, "soap");
	3231	if (ltmp != NULL)
	3232	addToMap (_tmpMaps->content, "soap", ltmp->value);
	3233	else
	3234	addToMap (_tmpMaps->content, "soap", "false");
	3235	if (cgiCookie != NULL && strlen (cgiCookie) > 0)
	3236	{
	3237	int hasValidCookie = -1;
	3238	char *tcook = zStrdup (cgiCookie);
	3239	char *tmp = NULL;
	3240	map *testing = getMapFromMaps (m, "main", "cookiePrefix");
	3241	if (testing == NULL)
	3242	{
	3243	tmp = zStrdup ("ID=");
	3244	}
	3245	else
	3246	{
	3247	tmp =
	3248	(char ) malloc ((strlen (testing->value) + 2) sizeof (char));
	3249	sprintf (tmp, "%s=", testing->value);
	3250	}
	3251	if (strstr (cgiCookie, ";") != NULL)
	3252	{
	3253	char token, saveptr;
	3254	token = strtok_r (cgiCookie, ";", &saveptr);
	3255	while (token != NULL)
	3256	{
	3257	if (strcasestr (token, tmp) != NULL)
	3258	{
	3259	if (tcook != NULL)
	3260	free (tcook);
	3261	tcook = zStrdup (token);
	3262	hasValidCookie = 1;
	3263	}
	3264	token = strtok_r (NULL, ";", &saveptr);
	3265	}
	3266	}
	3267	else
	3268	{
	3269	if (strstr (cgiCookie, "=") != NULL
	3270	&& strcasestr (cgiCookie, tmp) != NULL)
	3271	{
	3272	tcook = zStrdup (cgiCookie);
	3273	hasValidCookie = 1;
	3274	}
	3275	if (tmp != NULL)
	3276	{
	3277	free (tmp);
	3278	}
	3279	}
	3280	if (hasValidCookie > 0)
	3281	{
	3282	addToMap (_tmpMaps->content, "sessid", strstr (tcook, "=") + 1);
	3283	char session_file_path[1024];
	3284	map *tmpPath = getMapFromMaps (m, "main", "sessPath");
	3285	if (tmpPath == NULL)
	3286	tmpPath = getMapFromMaps (m, "main", "tmpPath");
	3287	char *tmp1 = strtok (tcook, ";");
	3288	if (tmp1 != NULL)
	3289	sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
	3290	strstr (tmp1, "=") + 1);
	3291	else
	3292	sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
	3293	strstr (cgiCookie, "=") + 1);
	3294	free (tcook);
	3295	maps tmpSess = (maps ) malloc (MAPS_SIZE);
	3296	struct stat file_status;
	3297	int istat = stat (session_file_path, &file_status);
	3298	if (istat == 0 && file_status.st_size > 0)
	3299	{
	3300	conf_read (session_file_path, tmpSess);
	3301	addMapsToMaps (&m, tmpSess);
	3302	freeMaps (&tmpSess);
	3303	free (tmpSess);
	3304	}
	3305	}
	3306	}
	3307	addMapsToMaps (&m, _tmpMaps);
	3308	freeMaps (&_tmpMaps);
	3309	free (_tmpMaps);
	3310
	3311	#ifdef DEBUG
	3312	dumpMap (request_inputs);
	3313	#endif
	3314	#ifdef WIN32
	3315	char *cgiSidL = NULL;
	3316	if (getenv ("CGISID") != NULL)
	3317	addToMap (request_inputs, "cgiSid", getenv ("CGISID"));
	3318
	3319	char* usidp;
	3320	if ( (usidp = getenv("USID")) != NULL ) {
	3321	setMapInMaps (m, "lenv", "usid", usidp);
	3322	}
	3323
	3324	map *test1 = getMap (request_inputs, "cgiSid");
	3325	if (test1 != NULL)
	3326	{
	3327	cgiSid = test1->value;
	3328	addToMap (request_inputs, "storeExecuteResponse", "true");
	3329	addToMap (request_inputs, "status", "true");
	3330	setMapInMaps (m, "lenv", "sid", test1->value);
	3331	status = getMap (request_inputs, "status");
	3332	}
	3333	#endif
	3334	char fbkp, fbkp1;
	3335	FILE f0, f1;
	3336	if (status != NULL)
	3337	if (strcasecmp (status->value, "false") == 0)
	3338	status = NULLMAP;
	3339	if (status == NULLMAP)
	3340	{
	3341	loadServiceAndRun (&m, s1, request_inputs, &request_input_real_format,
	3342	&request_output_real_format, &eres);
	3343	}
	3344	else
	3345	{
	3346	int pid;
	3347	#ifdef DEBUG
	3348	fprintf (stderr, "\nPID : %d\n", cpid);
	3349	#endif
	3350
	3351	#ifndef WIN32
	3352	pid = fork ();
	3353	#else
	3354	if (cgiSid == NULL)
	3355	{
	3356	createProcess (m, request_inputs, s1, NULL, cpid,
	3357	request_input_real_format,
	3358	request_output_real_format);
	3359	pid = cpid;
	3360	}
	3361	else
	3362	{
	3363	pid = 0;
	3364	cpid = atoi (cgiSid);
	3365	}
	3366	#endif
	3367	if (pid > 0)
	3368	{
	3369	/**
	3370	* dady :
	3371	* set status to SERVICE_ACCEPTED
	3372	*/
	3373	#ifdef DEBUG
	3374	fprintf (stderr, "father pid continue (origin %d) %d ...\n", cpid,
	3375	getpid ());
	3376	#endif
	3377	eres = SERVICE_ACCEPTED;
	3378	}
	3379	else if (pid == 0)
	3380	{
	3381	/**
	3382	* son : have to close the stdout, stdin and stderr to let the parent
	3383	* process answer to http client.
	3384	*/
	3385	#ifndef WIN32
	3386	zSleep (1);
	3387	#endif
	3388	r_inputs = getMapFromMaps (m, "lenv", "usid");
	3389	int cpid = atoi (r_inputs->value);
	3390	r_inputs = getMapFromMaps (m, "main", "tmpPath");
	3391	map *r_inputs1 = getMap (s1->content, "ServiceProvider");
	3392	fbkp =
	3393	(char *)
	3394	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
	3395	1024) * sizeof (char));
	3396	sprintf (fbkp, "%s/%s_%d.xml", r_inputs->value, r_inputs1->value,
	3397	cpid);
	3398	char *flog =
	3399	(char *)
	3400	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
	3401	1024) * sizeof (char));
	3402	sprintf (flog, "%s/%s_%d_error.log", r_inputs->value,
	3403	r_inputs1->value, cpid);
	3404	#ifdef DEBUG
	3405	fprintf (stderr, "RUN IN BACKGROUND MODE \n");
	3406	fprintf (stderr, "son pid continue (origin %d) %d ...\n", cpid,
	3407	getpid ());
	3408	fprintf (stderr, "\nFILE TO STORE DATA %s\n", r_inputs->value);
	3409	#endif
	3410	freopen (flog, "w+", stderr);
	3411	semid lid = getShmLockId (m, 1);
	3412	fflush (stderr);
	3413	if (lid < 0)
	3414	{
	3415	fprintf (stderr, "ERROR %s %d\n", __FILE__, __LINE__);
	3416	fflush (stderr);
	3417	return -1;
	3418	}
	3419	else
	3420	{
	3421	if (lockShm (lid) < 0)
	3422	{
	3423	fprintf (stderr, "ERROR %s %d\n", __FILE__, __LINE__);
	3424	fflush (stderr);
	3425	return -1;
	3426	}
	3427	fflush (stderr);
	3428	}
	3429	f0 = freopen (fbkp, "w+", stdout);
	3430	rewind (stdout);
	3431	#ifndef WIN32
	3432	fclose (stdin);
	3433	#endif
	3434	free (flog);
	3435	/**
	3436	* set status to SERVICE_STARTED and flush stdout to ensure full
	3437	* content was outputed (the file used to store the ResponseDocument).
	3438	* The rewind stdout to restart writing from the bgining of the file,
	3439	* this way the data will be updated at the end of the process run.
	3440	*/
	3441	printProcessResponse (m, request_inputs, cpid, s1, r_inputs1->value,
	3442	SERVICE_STARTED, request_input_real_format,
	3443	request_output_real_format);
	3444	fflush (stdout);
	3445	unlockShm (lid);
	3446	fflush (stderr);
	3447	fbkp1 =
	3448	(char *)
	3449	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
	3450	1024) * sizeof (char));
	3451	sprintf (fbkp1, "%s/%s_final_%d.xml", r_inputs->value,
	3452	r_inputs1->value, cpid);
	3453	f1 = freopen (fbkp1, "w+", stdout);
	3454	loadServiceAndRun (&m, s1, request_inputs,
	3455	&request_input_real_format,
	3456	&request_output_real_format, &eres);
	3457	}
	3458	else
	3459	{
	3460	/**
	3461	* error server don't accept the process need to output a valid
	3462	* error response here !!!
	3463	*/
	3464	eres = -1;
	3465	errorException (m, _("Unable to run the child process properly"),
	3466	"InternalError", NULL);
	3467	}
	3468	}
	3469
	3470	#ifdef DEBUG
	3471	dumpMaps (request_output_real_format);
	3472	#endif
	3473	if (eres != -1)
	3474	outputResponse (s1, request_input_real_format,
	3475	request_output_real_format, request_inputs,
	3476	cpid, m, eres);
	3477	fflush (stdout);
	3478	/**
	3479	* Ensure that if error occurs when freeing memory, no signal will return
	3480	* an ExceptionReport document as the result was already returned to the
	3481	* client.
	3482	*/
	3483	#ifndef USE_GDB
	3484	signal (SIGSEGV, donothing);
	3485	signal (SIGTERM, donothing);
	3486	signal (SIGINT, donothing);
	3487	signal (SIGILL, donothing);
	3488	signal (SIGFPE, donothing);
	3489	signal (SIGABRT, donothing);
	3490	#endif
	3491	if (((int) getpid ()) != cpid \|\| cgiSid != NULL)
	3492	{
	3493	fclose (stdout);
	3494	fclose (stderr);
	3495	/**
	3496	* Dump back the final file fbkp1 to fbkp
	3497	*/
	3498	fclose (f0);
	3499	fclose (f1);
	3500	FILE *f2 = fopen (fbkp1, "rb");
	3501	semid lid = getShmLockId (m, 1);
	3502	if (lid < 0)
	3503	return -1;
	3504	lockShm (lid);
	3505	FILE *f3 = fopen (fbkp, "wb+");
	3506	free (fbkp);
	3507	fseek (f2, 0, SEEK_END);
	3508	long flen = ftell (f2);
	3509	fseek (f2, 0, SEEK_SET);
	3510	char tmps1 = (char ) malloc ((flen + 1) * sizeof (char));
	3511	fread (tmps1, flen, 1, f2);
	3512	fwrite (tmps1, 1, flen, f3);
	3513	fclose (f2);
	3514	fclose (f3);
	3515	unlockShm (lid);
	3516	unlink (fbkp1);
	3517	free (fbkp1);
	3518	free (tmps1);
	3519	unhandleStatus (m);
	3520	}
	3521
	3522	freeService (&s1);
	3523	free (s1);
	3524	freeMaps (&m);
	3525	free (m);
	3526
	3527	freeMaps (&request_input_real_format);
	3528	free (request_input_real_format);
	3529
	3530	freeMaps (&request_output_real_format);
	3531	free (request_output_real_format);
	3532
	3533	free (REQUEST);
	3534	free (SERVICE_URL);
	3535	#ifdef DEBUG
	3536	fprintf (stderr, "Processed response \n");
	3537	fflush (stdout);
	3538	fflush (stderr);
	3539	#endif
	3540
	3541	if (((int) getpid ()) != cpid \|\| cgiSid != NULL)
	3542	{
	3543	exit (0);
	3544	}
	3545
	3546	return 0;
	3547	}

Note: See TracBrowser for help on using the repository browser.

Open WPS platform

source: trunk/zoo-project/zoo-kernel/zoo_service_loader.c @ 560

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links