zoo_service_loader.c @ 557

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

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links