zoo_service_loader.c @ 587

Last change on this file since 587 was 587, checked in by knut, 9 years ago
Implemented asynchronous HTTP POST Execute requests on Windows platform (via caching). Fixed bug that caused only the last output variable in a HTTP POST Execute request to be returned. Modified the addToCache function so that the path of the cached file can be retrieved. Changed the parsing of KVPs in zoo_loader.c so that keys with missing values (e.g. "metapath=") are assigned the empty string instead of NULL (avoids segmentation fault in some situations). Added conditional definition of ZEND_DEBUG in service_internal_php.c. Deallocation of memory in function createProcess. In zoo_loader.c, applied url_decode to CGI form string (WIN32 only, but should check if this should apply to other platforms as well).
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 121.2 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links