zoo_service_loader.c @ 531

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links