zoo_service_loader.c @ 599

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links