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 @ 553

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links