zoo_service_loader.c @ 550

Last change on this file since 550 was 550, checked in by djay, 9 years ago
Add otb2zcfg and OTB applications support without observer by now. Fix issue with maxOccurs and multiple downloaded value for the same input.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 124.3 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links