zoo_service_loader.c @ 513

Last change on this file since 513 was 513, checked in by david, 9 years ago
Fix syntax
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 117.6 KB

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	}
41	#include "ulinet.h"
42	#include <libintl.h>
43	#include <locale.h>
44	#include <string.h>
45	#include "service.h"
46	#include "service_internal.h"
47	#ifdef USE_PYTHON
48	#include "service_internal_python.h"
49	#endif
50	#ifdef USE_JAVA
51	#include "service_internal_java.h"
52	#endif
53	#ifdef USE_PHP
54	#include "service_internal_php.h"
55	#endif
56	#ifdef USE_JS
57	#include "service_internal_js.h"
58	#endif
59	#ifdef USE_RUBY
60	#include "service_internal_ruby.h"
61	#endif
62	#ifdef USE_PERL
63	#include "service_internal_perl.h"
64	#endif
65	#include <dirent.h>
66	#include <signal.h>
67	#include <unistd.h>
68	#ifndef WIN32
69	#include <dlfcn.h>
70	#include <libgen.h>
71	#else
72	#include <windows.h>
73	#include <direct.h>
74	#include <sys/types.h>
75	#include <sys/stat.h>
76	#include <unistd.h>
77	#define pid_t int;
78	#endif
79	#include <fcntl.h>
80	#include <time.h>
81	#include <stdarg.h>
82	#ifdef WIN32
83	extern "C"
84	{
85	__declspec (dllexport) char strcasestr (char const a, char const *b)
86	#ifndef USE_MS
87	{
88	char *x = zStrdup (a);
89	char *y = zStrdup (b);
90
91	x = _strlwr (x);
92	y = _strlwr (y);
93	char *pos = strstr (x, y);
94	char ret = pos == NULL ? NULL : (char ) (a + (pos - x));
95	free (x);
96	free (y);
97	return ret;
98	};
99	#else
100	;
101	#endif
102	}
103	#endif
104	#define _(String) dgettext ("zoo-kernel",String)
105	#define __(String) dgettext ("zoo-service",String)
106	extern int getServiceFromFile (maps , const char , service **);
107
108	int
109	readServiceFile (maps * conf, char file, service * service, char *name)
110	{
111	int t = getServiceFromFile (conf, file, service);
112	#ifdef YAML
113	if (t < 0)
114	{
115	t = getServiceFromYAML (conf, file, service, name);
116	}
117	#endif
118	return t;
119	}
120
121	void
122	translateChar (char *str, char toReplace, char toReplaceBy)
123	{
124	int i = 0, len = strlen (str);
125	for (i = 0; i < len; i++)
126	{
127	if (str[i] == toReplace)
128	str[i] = toReplaceBy;
129	}
130	}
131
132	/**
133	* Create (or append to) an array valued maps
134	* value = "["",""]"
135	*/
136	int
137	appendMapsToMaps (maps * m, maps * mo, maps * mi, elements * elem)
138	{
139	maps *tmpMaps = getMaps (mo, mi->name);
140	map *tmap = getMapType (tmpMaps->content);
141	elements *el = getElements (elem, mi->name);
142	int hasEl = 1;
143	if (el == NULL)
144	hasEl = -1;
145	if (tmap == NULL)
146	{
147	if (hasEl > 0)
148	tmap = getMapType (el->defaults->content);
149	}
150
151	map *testMap = NULL;
152	if (hasEl > 0)
153	{
154	testMap = getMap (el->content, "maxOccurs");
155	}
156	else
157	{
158	testMap = createMap ("maxOccurs", "unbounded");
159	}
160
161	if (testMap != NULL)
162	{
163	if (strncasecmp (testMap->value, "unbounded", 9) != 0
164	&& atoi (testMap->value) > 1)
165	{
166	if (addMapsArrayToMaps (&mo, mi, tmap->name) < 0)
167	{
168	char emsg[1024];
169	sprintf (emsg,
170	_
171	("You set maximum occurences for <%s> as %i but you tried to use it more than the limit you set. Please correct your ZCFG file or your request."),
172	mi->name, atoi (testMap->value));
173	errorException (m, emsg, "InternalError", NULL);
174	return -1;
175	}
176	}
177	else
178	{
179	if (strncasecmp (testMap->value, "unbounded", 9) == 0)
180	{
181	if (hasEl < 0)
182	{
183	freeMap (&testMap);
184	free (testMap);
185	}
186	if (addMapsArrayToMaps (&mo, mi, tmap->name) < 0)
187	{
188	char emsg[1024];
189	map *tmpMap = getMap (mi->content, "length");
190	sprintf (emsg,
191	_
192	("ZOO-Kernel was unable to load your data for %s position %s."),
193	mi->name, tmpMap->value);
194	errorException (m, emsg, "InternalError", NULL);
195	return -1;
196	}
197	}
198	else
199	{
200	char emsg[1024];
201	sprintf (emsg,
202	_
203	("You set maximum occurences for <%s> to one but you tried to use it more than once. Please correct your ZCFG file or your request."),
204	mi->name);
205	errorException (m, emsg, "InternalError", NULL);
206	return -1;
207	}
208	}
209	}
210	return 0;
211	}
212
213	int
214	recursReaddirF (maps * m, xmlNodePtr n, char conf_dir, char prefix,
215	int saved_stdout, int level, void (func) (maps *,
216	xmlNodePtr,
217	service *))
218	{
219	struct dirent *dp;
220	int scount = 0;
221
222	if (conf_dir == NULL)
223	return 1;
224	DIR *dirp = opendir (conf_dir);
225	if (dirp == NULL)
226	{
227	if (level > 0)
228	return 1;
229	else
230	return -1;
231	}
232	char tmp1[25];
233	sprintf (tmp1, "sprefix_%d", level);
234	char levels[17];
235	sprintf (levels, "%d", level);
236	setMapInMaps (m, "lenv", "level", levels);
237	while ((dp = readdir (dirp)) != NULL)
238	if ((dp->d_type == DT_DIR \|\| dp->d_type == DT_LNK)
239	&& dp->d_name[0] != '.' && strstr (dp->d_name, ".") == NULL)
240	{
241
242	char *tmp =
243	(char *)
244	malloc ((strlen (conf_dir) + strlen (dp->d_name) +
245	2) * sizeof (char));
246	sprintf (tmp, "%s/%s", conf_dir, dp->d_name);
247
248	if (prefix != NULL)
249	{
250	prefix = NULL;
251	}
252	prefix = (char ) malloc ((strlen (dp->d_name) + 2) sizeof (char));
253	sprintf (prefix, "%s.", dp->d_name);
254
255	// map* tmpMap=getMapFromMaps(m,"lenv",tmp1);
256
257	int res;
258	if (prefix != NULL)
259	{
260	setMapInMaps (m, "lenv", tmp1, prefix);
261	char levels1[17];
262	sprintf (levels1, "%d", level + 1);
263	setMapInMaps (m, "lenv", "level", levels1);
264	res =
265	recursReaddirF (m, n, tmp, prefix, saved_stdout,
266	level + 1, func);
267	sprintf (levels1, "%d", level);
268	setMapInMaps (m, "lenv", "level", levels1);
269	free (prefix);
270	prefix = NULL;
271	}
272	else
273	res = -1;
274	free (tmp);
275	if (res < 0)
276	{
277	return res;
278	}
279	}
280	else
281	{
282	if (dp->d_name[0] != '.' && strstr (dp->d_name, ".zcfg") != 0)
283	{
284	int t;
285	char tmps1[1024];
286	memset (tmps1, 0, 1024);
287	snprintf (tmps1, 1024, "%s/%s", conf_dir, dp->d_name);
288	service s1 = (service ) malloc (SERVICE_SIZE);
289	if (s1 == NULL)
290	{
291	dup2 (saved_stdout, fileno (stdout));
292	errorException (m, _("Unable to allocate memory."),
293	"InternalError", NULL);
294	return -1;
295	}
296	#ifdef DEBUG
297	fprintf (stderr,
298	"#################\n%s\n#################\n", tmps1);
299	#endif
300	t = readServiceFile (m, tmps1, &s1, dp->d_name);
301
302	if (t < 0)
303	{
304	map *tmp00 = getMapFromMaps (m, "lenv", "message");
305	char tmp01[1024];
306	if (tmp00 != NULL)
307	sprintf (tmp01,
308	_
309	("Unable to parse the ZCFG file: %s (%s)"),
310	dp->d_name, tmp00->value);
311	else
312	sprintf (tmp01,
313	_
314	("Unable to parse the ZCFG file: %s."),
315	dp->d_name);
316	dup2 (saved_stdout, fileno (stdout));
317	errorException (m, tmp01, "InternalError", NULL);
318	freeMaps (&m);
319	free (m);
320	return -1;
321	}
322	#ifdef DEBUG
323	dumpService (s1);
324	fflush (stdout);
325	fflush (stderr);
326	#endif
327	func (m, n, s1);
328	freeService (&s1);
329	free (s1);
330	scount++;
331	}
332	}
333	(void) closedir (dirp);
334	return 1;
335	}
336
337	xmlXPathObjectPtr
338	extractFromDoc (xmlDocPtr doc, const char *search)
339	{
340	xmlXPathContextPtr xpathCtx;
341	xmlXPathObjectPtr xpathObj;
342	xpathCtx = xmlXPathNewContext (doc);
343	xpathObj = xmlXPathEvalExpression (BAD_CAST search, xpathCtx);
344	xmlXPathFreeContext (xpathCtx);
345	return xpathObj;
346	}
347
348	void
349	donothing (int sig)
350	{
351	#ifdef DEBUG
352	fprintf (stderr, "Signal %d after the ZOO-Kernel returned result !\n", sig);
353	#endif
354	exit (0);
355	}
356
357	void
358	sig_handler (int sig)
359	{
360	char tmp[100];
361	const char *ssig;
362	switch (sig)
363	{
364	case SIGSEGV:
365	ssig = "SIGSEGV";
366	break;
367	case SIGTERM:
368	ssig = "SIGTERM";
369	break;
370	case SIGINT:
371	ssig = "SIGINT";
372	break;
373	case SIGILL:
374	ssig = "SIGILL";
375	break;
376	case SIGFPE:
377	ssig = "SIGFPE";
378	break;
379	case SIGABRT:
380	ssig = "SIGABRT";
381	break;
382	default:
383	ssig = "UNKNOWN";
384	break;
385	}
386	sprintf (tmp,
387	_
388	("ZOO Kernel failed to process your request receiving signal %d = %s"),
389	sig, ssig);
390	errorException (NULL, tmp, "InternalError", NULL);
391	#ifdef DEBUG
392	fprintf (stderr, "Not this time!\n");
393	#endif
394	exit (0);
395	}
396
397	void
398	loadServiceAndRun (maps ** myMap, service * s1, map * request_inputs,
399	maps inputs, maps ioutputs, int *eres)
400	{
401	char tmps1[1024];
402	char ntmp[1024];
403	maps m = myMap;
404	maps request_output_real_format = ioutputs;
405	maps request_input_real_format = inputs;
406	/**
407	* Extract serviceType to know what kind of service should be loaded
408	*/
409	map *r_inputs = NULL;
410	#ifndef WIN32
411	getcwd (ntmp, 1024);
412	#else
413	_getcwd (ntmp, 1024);
414	#endif
415	r_inputs = getMap (s1->content, "serviceType");
416	#ifdef DEBUG
417	fprintf (stderr, "LOAD A %s SERVICE PROVIDER \n", r_inputs->value);
418	fflush (stderr);
419	#endif
420	if (strlen (r_inputs->value) == 1
421	&& strncasecmp (r_inputs->value, "C", 1) == 0)
422	{
423	r_inputs = getMap (request_inputs, "metapath");
424	if (r_inputs != NULL)
425	sprintf (tmps1, "%s/%s", ntmp, r_inputs->value);
426	else
427	sprintf (tmps1, "%s/", ntmp);
428	char *altPath = zStrdup (tmps1);
429	r_inputs = getMap (s1->content, "ServiceProvider");
430	sprintf (tmps1, "%s/%s", altPath, r_inputs->value);
431	free (altPath);
432	#ifdef DEBUG
433	fprintf (stderr, "Trying to load %s\n", tmps1);
434	#endif
435	#ifdef WIN32
436	HINSTANCE so =
437	LoadLibraryEx (tmps1, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
438	#else
439	void *so = dlopen (tmps1, RTLD_LAZY);
440	#endif
441	#ifdef WIN32
442	DWORD errstr;
443	errstr = GetLastError ();
444	#else
445	char *errstr;
446	errstr = dlerror ();
447	#endif
448	#ifdef DEBUG
449	fprintf (stderr, "%s loaded (%d) \n", tmps1, errstr);
450	#endif
451	if (so != NULL)
452	{
453	#ifdef DEBUG
454	fprintf (stderr, "Library loaded %s \n", errstr);
455	fprintf (stderr, "Service Shared Object = %s\n", r_inputs->value);
456	#endif
457	r_inputs = getMap (s1->content, "serviceType");
458	#ifdef DEBUG
459	dumpMap (r_inputs);
460	fprintf (stderr, "%s\n", r_inputs->value);
461	fflush (stderr);
462	#endif
463	if (strncasecmp (r_inputs->value, "C-FORTRAN", 9) == 0)
464	{
465	r_inputs = getMap (request_inputs, "Identifier");
466	char fname[1024];
467	sprintf (fname, "%s_", r_inputs->value);
468	#ifdef DEBUG
469	fprintf (stderr, "Try to load function %s\n", fname);
470	#endif
471	#ifdef WIN32
472	typedef int (CALLBACK * execute_t) (char *, char *,
473	char ***);
474	execute_t execute = (execute_t) GetProcAddress (so, fname);
475	#else
476	typedef int (execute_t) (char , char , char **);
477	execute_t execute = (execute_t) dlsym (so, fname);
478	#endif
479	#ifdef DEBUG
480	#ifdef WIN32
481	errstr = GetLastError ();
482	#else
483	errstr = dlerror ();
484	#endif
485	fprintf (stderr, "Function loaded %s\n", errstr);
486	#endif
487
488	char main_conf[10][30][1024];
489	char inputs[10][30][1024];
490	char outputs[10][30][1024];
491	for (int i = 0; i < 10; i++)
492	{
493	for (int j = 0; j < 30; j++)
494	{
495	memset (main_conf[i][j], 0, 1024);
496	memset (inputs[i][j], 0, 1024);
497	memset (outputs[i][j], 0, 1024);
498	}
499	}
500	mapsToCharXXX (m, (char ***) main_conf);
501	mapsToCharXXX (request_input_real_format, (char ***) inputs);
502	mapsToCharXXX (request_output_real_format, (char ***) outputs);
503	*eres =
504	execute ((char ***) &main_conf[0],
505	(char *) &inputs[0], (char *) &outputs[0]);
506	#ifdef DEBUG
507	fprintf (stderr, "Function run successfully \n");
508	#endif
509	charxxxToMaps ((char ***) &outputs[0],
510	&request_output_real_format);
511	}
512	else
513	{
514	#ifdef DEBUG
515	#ifdef WIN32
516	errstr = GetLastError ();
517	fprintf (stderr,
518	"Function %s failed to load because of %d\n",
519	r_inputs->value, errstr);
520	#endif
521	#endif
522	r_inputs = getMapFromMaps (m, "lenv", "Identifier");
523	#ifdef DEBUG
524	fprintf (stderr, "Try to load function %s\n", r_inputs->value);
525	#endif
526	typedef int (execute_t) (maps , maps , maps *);
527	#ifdef WIN32
528	execute_t execute =
529	(execute_t) GetProcAddress (so, r_inputs->value);
530	#else
531	execute_t execute = (execute_t) dlsym (so, r_inputs->value);
532	#endif
533
534	if (execute == NULL)
535	{
536	#ifdef WIN32
537	errstr = GetLastError ();
538	#else
539	errstr = dlerror ();
540	#endif
541	char *tmpMsg =
542	(char *) malloc (2048 + strlen (r_inputs->value));
543	sprintf (tmpMsg,
544	_
545	("Error occured while running the %s function: %s"),
546	r_inputs->value, errstr);
547	errorException (m, tmpMsg, "InternalError", NULL);
548	free (tmpMsg);
549	#ifdef DEBUG
550	fprintf (stderr, "Function %s error %s\n",
551	r_inputs->value, errstr);
552	#endif
553	*eres = -1;
554	return;
555	}
556	#ifdef DEBUG
557	#ifdef WIN32
558	errstr = GetLastError ();
559	#else
560	errstr = dlerror ();
561	#endif
562	fprintf (stderr, "Function loaded %s\n", errstr);
563	#endif
564
565	#ifdef DEBUG
566	fprintf (stderr, "Now run the function \n");
567	fflush (stderr);
568	#endif
569	*eres =
570	execute (&m, &request_input_real_format,
571	&request_output_real_format);
572	#ifdef DEBUG
573	fprintf (stderr, "Function loaded and returned %d\n", eres);
574	fflush (stderr);
575	#endif
576	}
577	#ifdef WIN32
578	*ioutputs = dupMaps (&request_output_real_format);
579	FreeLibrary (so);
580	#else
581	dlclose (so);
582	#endif
583	}
584	else
585	{
586	/**
587	* Unable to load the specified shared library
588	*/
589	char tmps[1024];
590	#ifdef WIN32
591	DWORD errstr = GetLastError ();
592	#else
593	char *errstr = dlerror ();
594	#endif
595	sprintf (tmps, _("C Library can't be loaded %s"), errstr);
596	map *tmps1 = createMap ("text", tmps);
597	printExceptionReportResponse (m, tmps1);
598	*eres = -1;
599	freeMap (&tmps1);
600	free (tmps1);
601	}
602	}
603	else
604	#ifdef USE_PYTHON
605	if (strncasecmp (r_inputs->value, "PYTHON", 6) == 0)
606	{
607	*eres =
608	zoo_python_support (&m, request_inputs, s1,
609	&request_input_real_format,
610	&request_output_real_format);
611	}
612	else
613	#endif
614
615	#ifdef USE_JAVA
616	if (strncasecmp (r_inputs->value, "JAVA", 4) == 0)
617	{
618	*eres =
619	zoo_java_support (&m, request_inputs, s1,
620	&request_input_real_format,
621	&request_output_real_format);
622	}
623	else
624	#endif
625
626	#ifdef USE_PHP
627	if (strncasecmp (r_inputs->value, "PHP", 3) == 0)
628	{
629	*eres =
630	zoo_php_support (&m, request_inputs, s1,
631	&request_input_real_format,
632	&request_output_real_format);
633	}
634	else
635	#endif
636
637
638	#ifdef USE_PERL
639	if (strncasecmp (r_inputs->value, "PERL", 4) == 0)
640	{
641	*eres =
642	zoo_perl_support (&m, request_inputs, s1,
643	&request_input_real_format,
644	&request_output_real_format);
645	}
646	else
647	#endif
648
649	#ifdef USE_JS
650	if (strncasecmp (r_inputs->value, "JS", 2) == 0)
651	{
652	*eres =
653	zoo_js_support (&m, request_inputs, s1,
654	&request_input_real_format,
655	&request_output_real_format);
656	}
657	else
658	#endif
659
660	#ifdef USE_RUBY
661	if (strncasecmp (r_inputs->value, "Ruby", 4) == 0)
662	{
663	*eres =
664	zoo_ruby_support (&m, request_inputs, s1,
665	&request_input_real_format,
666	&request_output_real_format);
667	}
668	else
669	#endif
670
671	{
672	char tmpv[1024];
673	sprintf (tmpv,
674	_
675	("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),
676	r_inputs->value);
677	map *tmps = createMap ("text", tmpv);
678	printExceptionReportResponse (m, tmps);
679	*eres = -1;
680	}
681	*myMap = m;
682	*ioutputs = request_output_real_format;
683	}
684
685
686	#ifdef WIN32
687	/**
688	* createProcess function: create a new process after setting some env variables
689	*/
690	void
691	createProcess (maps * m, map * request_inputs, service * s1, char *opts,
692	int cpid, maps * inputs, maps * outputs)
693	{
694	STARTUPINFO si;
695	PROCESS_INFORMATION pi;
696	ZeroMemory (&si, sizeof (si));
697	si.cb = sizeof (si);
698	ZeroMemory (&pi, sizeof (pi));
699	char tmp = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
700	char tmpq = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
701	map *req = getMap (request_inputs, "request");
702	map *id = getMap (request_inputs, "identifier");
703	map *di = getMap (request_inputs, "DataInputs");
704
705	char *dataInputsKVP = getMapsAsKVP (inputs, cgiContentLength, 0);
706	char *dataOutputsKVP = getMapsAsKVP (outputs, cgiContentLength, 1);
707	#ifdef DEBUG
708	fprintf (stderr, "DATAINPUTSKVP %s\n", dataInputsKVP);
709	fprintf (stderr, "DATAOUTPUTSKVP %s\n", dataOutputsKVP);
710	#endif
711	map *sid = getMapFromMaps (m, "lenv", "sid");
712	map *r_inputs = getMapFromMaps (m, "main", "tmpPath");
713	map *r_inputs1 = getMap (request_inputs, "metapath");
714	int hasIn = -1;
715	if (r_inputs1 == NULL)
716	{
717	r_inputs1 = createMap ("metapath", "");
718	hasIn = 1;
719	}
720	map *r_inputs2 = getMap (request_inputs, "ResponseDocument");
721	if (r_inputs2 == NULL)
722	r_inputs2 = getMap (request_inputs, "RawDataOutput");
723	map *tmpPath = getMapFromMaps (m, "lenv", "cwd");
724
725	map *tmpReq = getMap (request_inputs, "xrequest");
726	if (r_inputs2 != NULL)
727	{
728	sprintf (tmp,
729	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",
730	r_inputs1->value, req->value, id->value, dataInputsKVP,
731	r_inputs2->name, dataOutputsKVP, sid->value);
732	sprintf (tmpq,
733	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",
734	r_inputs1->value, req->value, id->value, dataInputsKVP,
735	r_inputs2->name, dataOutputsKVP);
736	}
737	else
738	{
739	sprintf (tmp,
740	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",
741	r_inputs1->value, req->value, id->value, dataInputsKVP,
742	sid->value);
743	sprintf (tmpq,
744	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",
745	r_inputs1->value, req->value, id->value, dataInputsKVP,
746	sid->value);
747	}
748
749	if (hasIn > 0)
750	{
751	freeMap (&r_inputs1);
752	free (r_inputs1);
753	}
754	char *tmp1 = zStrdup (tmp);
755	sprintf (tmp, "\"zoo_loader.cgi\" %s \"%s\"", tmp1, sid->value);
756
757	free (dataInputsKVP);
758	free (dataOutputsKVP);
759	#ifdef DEBUG
760	fprintf (stderr, "REQUEST IS : %s \n", tmp);
761	#endif
762	SetEnvironmentVariable ("CGISID", TEXT (sid->value));
763	SetEnvironmentVariable ("QUERY_STRING", TEXT (tmpq));
764	char clen[1000];
765	sprintf (clen, "%d", strlen (tmpq));
766	SetEnvironmentVariable ("CONTENT_LENGTH", TEXT (clen));
767
768	if (!CreateProcess (NULL, // No module name (use command line)
769	TEXT (tmp), // Command line
770	NULL, // Process handle not inheritable
771	NULL, // Thread handle not inheritable
772	FALSE, // Set handle inheritance to FALSE
773	CREATE_NO_WINDOW, // Apache won't wait until
774	// the end
775	NULL, // Use parent's environment block
776	NULL, // Use parent's starting directory
777	&si, // Pointer to STARTUPINFO struct
778	&pi) // Pointer to PROCESS_INFORMATION struct
779	)
780	{
781	#ifdef DEBUG
782	fprintf (stderr, "CreateProcess failed (%d).\n", GetLastError ());
783	#endif
784	return;
785	}
786	else
787	{
788	#ifdef DEBUG
789	fprintf (stderr, "CreateProcess successfull (%d).\n\n\n\n",
790	GetLastError ());
791	#endif
792	}
793	CloseHandle (pi.hProcess);
794	CloseHandle (pi.hThread);
795	#ifdef DEBUG
796	fprintf (stderr, "CreateProcess finished !\n");
797	#endif
798	}
799	#endif
800
801	int
802	runRequest (map ** inputs)
803	{
804
805	#ifndef USE_GDB
806	(void) signal (SIGSEGV, sig_handler);
807	(void) signal (SIGTERM, sig_handler);
808	(void) signal (SIGINT, sig_handler);
809	(void) signal (SIGILL, sig_handler);
810	(void) signal (SIGFPE, sig_handler);
811	(void) signal (SIGABRT, sig_handler);
812	#endif
813
814	map *r_inputs = NULL;
815	map request_inputs = inputs;
816	maps *m = NULL;
817	char *REQUEST = NULL;
818	/**
819	* Parsing service specfic configuration file
820	*/
821	m = (maps *) malloc (MAPS_SIZE);
822	if (m == NULL)
823	{
824	return errorException (m, _("Unable to allocate memory."),
825	"InternalError", NULL);
826	}
827	char ntmp[1024];
828	#ifndef WIN32
829	getcwd (ntmp, 1024);
830	#else
831	_getcwd (ntmp, 1024);
832	#endif
833	r_inputs = getMapOrFill (&request_inputs, "metapath", "");
834
835
836	char conf_file[10240];
837	snprintf (conf_file, 10240, "%s/%s/main.cfg", ntmp, r_inputs->value);
838	if (conf_read (conf_file, m) == 2)
839	{
840	errorException (NULL, _("Unable to load the main.cfg file."),
841	"InternalError", NULL);
842	free (m);
843	return 1;
844	}
845	#ifdef DEBUG
846	fprintf (stderr, "***** BEGIN MAPS\n");
847	dumpMaps (m);
848	fprintf (stderr, "***** END MAPS\n");
849	#endif
850
851	map *getPath = getMapFromMaps (m, "main", "gettextPath");
852	if (getPath != NULL)
853	{
854	bindtextdomain ("zoo-kernel", getPath->value);
855	bindtextdomain ("zoo-services", getPath->value);
856	}
857	else
858	{
859	bindtextdomain ("zoo-kernel", "/usr/share/locale/");
860	bindtextdomain ("zoo-services", "/usr/share/locale/");
861	}
862
863
864	/**
865	* Manage our own error log file (usefull to separate standard apache debug
866	* messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
867	* headers messages returned by the CGI due to wrong redirection of stderr)
868	*/
869	FILE *fstde = NULL;
870	map *fstdem = getMapFromMaps (m, "main", "logPath");
871	if (fstdem != NULL)
872	fstde = freopen (fstdem->value, "a+", stderr);
873
874	r_inputs = getMap (request_inputs, "language");
875	if (r_inputs == NULL)
876	r_inputs = getMapFromMaps (m, "main", "language");
877	if (r_inputs != NULL)
878	{
879	if (isValidLang (m, r_inputs->value) < 0)
880	{
881	char tmp[1024];
882	sprintf (tmp,
883	_
884	("The value %s is not supported for the <language> parameter"),
885	r_inputs->value);
886	errorException (m, tmp, "InvalidParameterValue", "language");
887	freeMaps (&m);
888	free (m);
889	free (REQUEST);
890	return 1;
891
892	}
893	char *tmp = zStrdup (r_inputs->value);
894	setMapInMaps (m, "main", "language", tmp);
895	#ifdef DEB
896	char tmp2[12];
897	sprintf (tmp2, "%s.utf-8", tmp);
898	translateChar (tmp2, '-', '_');
899	setlocale (LC_ALL, tmp2);
900	#else
901	translateChar (tmp, '-', '_');
902	setlocale (LC_ALL, tmp);
903	#endif
904	#ifndef WIN32
905	setenv ("LC_ALL", tmp, 1);
906	#else
907	char tmp1[12];
908	sprintf (tmp1, "LC_ALL=%s", tmp);
909	putenv (tmp1);
910	#endif
911	free (tmp);
912	}
913	else
914	{
915	setlocale (LC_ALL, "en_US");
916	#ifndef WIN32
917	setenv ("LC_ALL", "en_US", 1);
918	#else
919	char tmp1[12];
920	sprintf (tmp1, "LC_ALL=en_US");
921	putenv (tmp1);
922	#endif
923	setMapInMaps (m, "main", "language", "en-US");
924	}
925	setlocale (LC_NUMERIC, "en_US");
926	bind_textdomain_codeset ("zoo-kernel", "UTF-8");
927	textdomain ("zoo-kernel");
928	bind_textdomain_codeset ("zoo-services", "UTF-8");
929	textdomain ("zoo-services");
930
931	map *lsoap = getMap (request_inputs, "soap");
932	if (lsoap != NULL && strcasecmp (lsoap->value, "true") == 0)
933	setMapInMaps (m, "main", "isSoap", "true");
934	else
935	setMapInMaps (m, "main", "isSoap", "false");
936
937	if (strlen (cgiServerName) > 0)
938	{
939	char tmpUrl[1024];
940	if (strncmp (cgiServerPort, "80", 2) == 0)
941	{
942	sprintf (tmpUrl, "http://%s%s", cgiServerName, cgiScriptName);
943	}
944	else
945	{
946	sprintf (tmpUrl, "http://%s:%s%s", cgiServerName,
947	cgiServerPort, cgiScriptName);
948	}
949	#ifdef DEBUG
950	fprintf (stderr, "* %s *\n", tmpUrl);
951	#endif
952	setMapInMaps (m, "main", "serverAddress", tmpUrl);
953	}
954
955	/**
956	* Check for minimum inputs
957	*/
958	r_inputs = getMap (request_inputs, "Request");
959	if (request_inputs == NULL \|\| r_inputs == NULL)
960	{
961	errorException (m, _("Parameter <request> was not specified"),
962	"MissingParameterValue", "request");
963	if (count (request_inputs) == 1)
964	{
965	freeMap (&request_inputs);
966	free (request_inputs);
967	}
968	freeMaps (&m);
969	free (m);
970	return 1;
971	}
972	else
973	{
974	REQUEST = zStrdup (r_inputs->value);
975	if (strncasecmp (r_inputs->value, "GetCapabilities", 15) != 0
976	&& strncasecmp (r_inputs->value, "DescribeProcess", 15) != 0
977	&& strncasecmp (r_inputs->value, "Execute", 7) != 0)
978	{
979	errorException (m,
980	_
981	("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
982	"OperationNotSupported", r_inputs->value);
983	freeMaps (&m);
984	free (m);
985	free (REQUEST);
986	return 1;
987	}
988	}
989	r_inputs = NULL;
990	r_inputs = getMap (request_inputs, "Service");
991	if (r_inputs == NULLMAP)
992	{
993	errorException (m, _("Parameter <service> was not specified"),
994	"MissingParameterValue", "service");
995	freeMaps (&m);
996	free (m);
997	free (REQUEST);
998	return 1;
999	}
1000	else
1001	{
1002	if (strcasecmp (r_inputs->value, "WPS") != 0)
1003	{
1004	errorException (m,
1005	_
1006	("Unenderstood <service> value, WPS is the only acceptable value."),
1007	"InvalidParameterValue", "service");
1008	freeMaps (&m);
1009	free (m);
1010	free (REQUEST);
1011	return 1;
1012	}
1013	}
1014	if (strncasecmp (REQUEST, "GetCapabilities", 15) != 0)
1015	{
1016	r_inputs = getMap (request_inputs, "Version");
1017	if (r_inputs == NULL)
1018	{
1019	errorException (m, _("Parameter <version> was not specified"),
1020	"MissingParameterValue", "version");
1021	freeMaps (&m);
1022	free (m);
1023	free (REQUEST);
1024	return 1;
1025	}
1026	else
1027	{
1028	if (strcasecmp (r_inputs->value, "1.0.0") != 0)
1029	{
1030	errorException (m,
1031	_
1032	("Unenderstood <version> value, 1.0.0 is the only acceptable value."),
1033	"InvalidParameterValue", "service");
1034	freeMaps (&m);
1035	free (m);
1036	free (REQUEST);
1037	return 1;
1038	}
1039	}
1040	}
1041	else
1042	{
1043	r_inputs = getMap (request_inputs, "AcceptVersions");
1044	if (r_inputs != NULL)
1045	{
1046	if (strncmp (r_inputs->value, "1.0.0", 5) != 0)
1047	{
1048	errorException (m,
1049	_
1050	("Unenderstood <AcceptVersions> value, 1.0.0 is the only acceptable value."),
1051	"VersionNegotiationFailed", NULL);
1052	freeMaps (&m);
1053	free (m);
1054	free (REQUEST);
1055	return 1;
1056	}
1057	}
1058	}
1059
1060	r_inputs = getMap (request_inputs, "serviceprovider");
1061	if (r_inputs == NULL)
1062	{
1063	addToMap (request_inputs, "serviceprovider", "");
1064	}
1065
1066	maps *request_output_real_format = NULL;
1067	map *tmpm = getMapFromMaps (m, "main", "serverAddress");
1068	if (tmpm != NULL)
1069	SERVICE_URL = zStrdup (tmpm->value);
1070	else
1071	SERVICE_URL = zStrdup (DEFAULT_SERVICE_URL);
1072
1073	service *s1;
1074	int scount = 0;
1075	#ifdef DEBUG
1076	dumpMap (r_inputs);
1077	#endif
1078	char conf_dir[1024];
1079	int t;
1080	char tmps1[1024];
1081
1082	r_inputs = NULL;
1083	r_inputs = getMap (request_inputs, "metapath");
1084	if (r_inputs != NULL)
1085	snprintf (conf_dir, 1024, "%s/%s", ntmp, r_inputs->value);
1086	else
1087	snprintf (conf_dir, 1024, "%s", ntmp);
1088
1089	if (strncasecmp (REQUEST, "GetCapabilities", 15) == 0)
1090	{
1091	#ifdef DEBUG
1092	dumpMap (r_inputs);
1093	#endif
1094	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1095	r_inputs = NULL;
1096	r_inputs = getMap (request_inputs, "ServiceProvider");
1097	xmlNodePtr n;
1098	if (r_inputs != NULL)
1099	n = printGetCapabilitiesHeader (doc, r_inputs->value, m);
1100	else
1101	n = printGetCapabilitiesHeader (doc, "", m);
1102	/**
1103	* Here we need to close stdout to ensure that not supported chars
1104	* has been found in the zcfg and then printed on stdout
1105	*/
1106	int saved_stdout = dup (fileno (stdout));
1107	dup2 (fileno (stderr), fileno (stdout));
1108
1109	/**
1110	if (int res =
1111	recursReaddirF (m, n, conf_dir, NULL, saved_stdout, 0,
1112	printGetCapabilitiesForProcess) < 0)
1113	{
1114	freeMaps (&m);
1115	free (m);
1116	free (REQUEST);
1117	free (SERVICE_URL);
1118	fflush (stdout);
1119	return res;
1120	}
1121	**/
1122	XML_CapabilitiesAllProcess (m, n);
1123	dup2 (saved_stdout, fileno (stdout));
1124	printDocument (m, doc, getpid ());
1125	freeMaps (&m);
1126	free (m);
1127	free (REQUEST);
1128	free (SERVICE_URL);
1129	fflush (stdout);
1130	return 0;
1131	}
1132	else
1133	{
1134	r_inputs = getMap (request_inputs, "Identifier");
1135	if (r_inputs == NULL
1136	\|\| strlen (r_inputs->name) == 0 \|\| strlen (r_inputs->value) == 0)
1137	{
1138	errorException (m,
1139	_("Mandatory <identifier> was not specified"),
1140	"MissingParameterValue", "identifier");
1141	freeMaps (&m);
1142	free (m);
1143	free (REQUEST);
1144	free (SERVICE_URL);
1145	return 0;
1146	}
1147
1148	struct dirent *dp;
1149	DIR *dirp = opendir (conf_dir);
1150	if (dirp == NULL)
1151	{
1152	errorException (m,
1153	_("The specified path path doesn't exist."),
1154	"InvalidParameterValue", conf_dir);
1155	freeMaps (&m);
1156	free (m);
1157	free (REQUEST);
1158	free (SERVICE_URL);
1159	return 0;
1160	}
1161	if (strncasecmp (REQUEST, "DescribeProcess", 15) == 0)
1162	{
1163	/**
1164	* Loop over Identifier list
1165	*/
1166	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1167	r_inputs = NULL;
1168	r_inputs = getMap (request_inputs, "ServiceProvider");
1169
1170	xmlNodePtr n;
1171	if (r_inputs != NULL)
1172	n = printDescribeProcessHeader (doc, r_inputs->value, m);
1173	else
1174	n = printDescribeProcessHeader (doc, "", m);
1175
1176	r_inputs = getMap (request_inputs, "Identifier");
1177
1178	char *orig = zStrdup (r_inputs->value);
1179
1180
1181	int saved_stdout = dup (fileno (stdout));
1182	dup2 (fileno (stderr), fileno (stdout));
1183	XML_Describe_Process (m, n, orig);
1184	closedir (dirp);
1185	fflush (stdout);
1186	dup2 (saved_stdout, fileno (stdout));
1187	free (orig);
1188	printDocument (m, doc, getpid ());
1189	freeMaps (&m);
1190	free (m);
1191	free (REQUEST);
1192	free (SERVICE_URL);
1193	fflush (stdout);
1194	return 0;
1195
1196	}
1197	else if (strncasecmp (REQUEST, "Execute", strlen (REQUEST)) != 0)
1198	{
1199	errorException (m,
1200	_
1201	("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
1202	"InvalidParameterValue", "request");
1203	#ifdef DEBUG
1204	fprintf (stderr, "No request found %s", REQUEST);
1205	#endif
1206	closedir (dirp);
1207	freeMaps (&m);
1208	free (m);
1209	free (REQUEST);
1210	free (SERVICE_URL);
1211	fflush (stdout);
1212	return 0;
1213	}
1214	closedir (dirp);
1215	}
1216
1217	s1 = NULL;
1218	s1 = (service *) malloc (SERVICE_SIZE);
1219	if (s1 == NULL)
1220	{
1221	freeMaps (&m);
1222	free (m);
1223	free (REQUEST);
1224	free (SERVICE_URL);
1225	return errorException (m, _("Unable to allocate memory."),
1226	"InternalError", NULL);
1227	}
1228	r_inputs = getMap (request_inputs, "MetaPath");
1229	if (r_inputs != NULL)
1230	snprintf (tmps1, 1024, "%s/%s", ntmp, r_inputs->value);
1231	else
1232	snprintf (tmps1, 1024, "%s/", ntmp);
1233	r_inputs = getMap (request_inputs, "Identifier");
1234	char *ttmp = zStrdup (tmps1);
1235	snprintf (tmps1, 1024, "%s/%s.zcfg", ttmp, r_inputs->value);
1236	free (ttmp);
1237	#ifdef DEBUG
1238	fprintf (stderr, "Trying to load %s\n", tmps1);
1239	#endif
1240	if (strstr (r_inputs->value, ".") != NULL)
1241	{
1242	char *identifier = zStrdup (r_inputs->value);
1243	parseIdentifier (m, conf_dir, identifier, tmps1);
1244	map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
1245	if (tmpMap != NULL)
1246	addToMap (request_inputs, "metapath", tmpMap->value);
1247	free (identifier);
1248	}
1249	else
1250	setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
1251	int saved_stdout = dup (fileno (stdout));
1252	dup2 (fileno (stderr), fileno (stdout));
1253	t = readServiceFile (m, tmps1, &s1, r_inputs->value);
1254	fflush (stdout);
1255	dup2 (saved_stdout, fileno (stdout));
1256	if (t < 0)
1257	{
1258	char tmpMsg = (char ) malloc (2048 + strlen (r_inputs->value));
1259	sprintf (tmpMsg,
1260	_
1261	("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),
1262	r_inputs->value);
1263	errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
1264	free (tmpMsg);
1265	free (s1);
1266	freeMaps (&m);
1267	free (m);
1268	free (REQUEST);
1269	free (SERVICE_URL);
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 ("missingIndetifier");
1788	tmpmaps->content =
1789	createMap ((char ) cur2->name, (char ) val);
1790	tmpmaps->next = NULL;
1791	}
1792	else
1793	{
1794	if (tmpmaps->content != NULL)
1795	addToMap (tmpmaps->content,
1796	(char ) cur2->name, (char ) val);
1797	else
1798	tmpmaps->content =
1799	createMap ((char ) cur2->name, (char ) val);
1800	}
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 @ 513

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links