zoo_service_loader.c @ 513

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

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

Open WPS platform

source: branches/PublicaMundi_David-devel/zoo-project/zoo-kernel/zoo_service_loader.c @ 513

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links