zoo_service_loader.c @ 554

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links