zoo_service_loader.c @ 822

Last change on this file since 822 was 822, checked in by djay, 7 years ago
Commit the minimal requirements for remote HPC support
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 69.7 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	extern "C" int yylex ();
26	extern "C" int crlex ();
27
28	#ifdef META_DB
29	#include "ogrsf_frmts.h"
30	#if GDAL_VERSION_MAJOR >= 2
31	#include <gdal_priv.h>
32	#endif
33	#endif
34
35	#ifdef USE_OTB
36	#include "service_internal_otb.h"
37	#endif
38
39	#ifdef USE_HPC
40	#include "service_internal_hpc.h"
41	#endif
42
43	#include "cgic.h"
44
45	#include <libxml/tree.h>
46	#include <libxml/xmlmemory.h>
47	#include <libxml/parser.h>
48	#include <libxml/xpath.h>
49	#include <libxml/xpathInternals.h>
50
51	#include "ulinet.h"
52
53	#include <libintl.h>
54	#include <locale.h>
55	#include <string.h>
56
57	#include "service.h"
58
59	#include "service_internal.h"
60	#include "server_internal.h"
61	#include "response_print.h"
62	#include "request_parser.h"
63	#include "sqlapi.h"
64	#ifdef WIN32
65	#include "caching.h"
66	#endif
67
68	#ifdef META_DB
69	#include "meta_sql.h"
70	#endif
71
72	#ifdef USE_PYTHON
73	#include "service_internal_python.h"
74	#endif
75
76	#ifdef USE_SAGA
77	#include "service_internal_saga.h"
78	#endif
79
80	#ifdef USE_JAVA
81	#include "service_internal_java.h"
82	#endif
83
84	#ifdef USE_PHP
85	#include "service_internal_php.h"
86	#endif
87
88	#ifdef USE_JS
89	#include "service_internal_js.h"
90	#endif
91
92	#ifdef USE_RUBY
93	#include "service_internal_ruby.h"
94	#endif
95
96	#ifdef USE_PERL
97	#include "service_internal_perl.h"
98	#endif
99
100	#ifdef USE_MONO
101	#include "service_internal_mono.h"
102	#endif
103
104	#include <dirent.h>
105	#include <signal.h>
106	#include <unistd.h>
107	#ifndef WIN32
108	#include <dlfcn.h>
109	#include <libgen.h>
110	#else
111	#include <windows.h>
112	#include <direct.h>
113	#include <sys/types.h>
114	#include <sys/stat.h>
115	#include <unistd.h>
116	#define pid_t int;
117	#endif
118	#include <fcntl.h>
119	#include <time.h>
120	#include <stdarg.h>
121
122	#ifndef WIN32
123	extern char **environ;
124	#endif
125
126
127	#ifdef WIN32
128	extern "C"
129	{
130	__declspec (dllexport) char strcasestr (char const a, char const *b)
131	#ifndef USE_MS
132	{
133	char *x = zStrdup (a);
134	char *y = zStrdup (b);
135
136	x = _strlwr (x);
137	y = _strlwr (y);
138	char *pos = strstr (x, y);
139	char ret = pos == NULL ? NULL : (char ) (a + (pos - x));
140	free (x);
141	free (y);
142	return ret;
143	};
144	#else
145	;
146	#endif
147	}
148	#endif
149
150	/**
151	* Translation function for zoo-kernel
152	*/
153	#define _(String) dgettext ("zoo-kernel",String)
154	/**
155	* Translation function for zoo-service
156	*/
157	#define __(String) dgettext ("zoo-service",String)
158
159	#ifdef WIN32
160	#ifndef PROGRAMNAME
161	#define PROGRAMNAME "zoo_loader.cgi"
162	#endif
163	#endif
164
165
166	/**
167	* Replace a char by another one in a string
168	*
169	* @param str the string to update
170	* @param toReplace the char to replace
171	* @param toReplaceBy the char that will be used
172	*/
173	void
174	translateChar (char *str, char toReplace, char toReplaceBy)
175	{
176	int i = 0, len = strlen (str);
177	for (i = 0; i < len; i++)
178	{
179	if (str[i] == toReplace)
180	str[i] = toReplaceBy;
181	}
182	}
183
184	/**
185	* Dump back the final file fbkp1 to fbkp
186	*
187	* @param m the conf maps containing the main.cfg settings
188	* @param fbkp the string corresponding to the name of the file
189	* @param fbkp1 the string corresponding to the name of the file
190	*/
191	int dumpBackFinalFile(maps* m,char* fbkp,char* fbkp1)
192	{
193	FILE *f2 = fopen (fbkp1, "rb");
194	#ifndef RELY_ON_DB
195	semid lid = getShmLockId (m, 1);
196	if (lid < 0)
197	return -1;
198	lockShm (lid);
199	#endif
200	FILE *f3 = fopen (fbkp, "wb+");
201	free (fbkp);
202	fseek (f2, 0, SEEK_END);
203	long flen = ftell (f2);
204	fseek (f2, 0, SEEK_SET);
205	char tmps1 = (char ) malloc ((flen + 1) * sizeof (char));
206	fread (tmps1, flen, 1, f2);
207	#ifdef WIN32
208	char *pchr=strrchr(tmps1,'>');
209	flen=strlen(tmps1)-strlen(pchr)+1;
210	tmps1[flen]=0;
211	#endif
212	fwrite (tmps1, 1, flen, f3);
213	fclose (f2);
214	fclose (f3);
215	return 1;
216	}
217
218	/**
219	* Recursivelly parse zcfg starting from the ZOO-Kernel cwd.
220	* Call the func function given in arguments after parsing the ZCFG file.
221	*
222	* @param m the conf maps containing the main.cfg settings
223	* @param r the registry containing profiles hierarchy
224	* @param n the root XML Node to add the sub-elements
225	* @param conf_dir the location of the main.cfg file (basically cwd)
226	* @param prefix the current prefix if any, or NULL
227	* @param saved_stdout the saved stdout identifier
228	* @param level the current level (number of sub-directories to reach the
229	* current path)
230	* @param func a pointer to a function having 4 parameters
231	* (registry, maps, xmlNodePtr and service*).
232	* @see inheritance, readServiceFile
233	*/
234	int
235	recursReaddirF ( maps * m, registry r, xmlNodePtr n, char conf_dir,
236	char *prefix, int saved_stdout, int level,
237	void (func) (registry , maps , xmlNodePtr, service *) )
238	{
239	struct dirent *dp;
240	int scount = 0;
241
242	if (conf_dir == NULL)
243	return 1;
244	DIR *dirp = opendir (conf_dir);
245	if (dirp == NULL)
246	{
247	if (level > 0)
248	return 1;
249	else
250	return -1;
251	}
252	char tmp1[25];
253	sprintf (tmp1, "sprefix_%d", level);
254	char levels[17];
255	sprintf (levels, "%d", level);
256	setMapInMaps (m, "lenv", "level", levels);
257	while ((dp = readdir (dirp)) != NULL)
258	if ((dp->d_type == DT_DIR \|\| dp->d_type == DT_LNK) && dp->d_name[0] != '.'
259	&& strstr (dp->d_name, ".") == NULL)
260	{
261
262	char *tmp =
263	(char ) malloc ((strlen (conf_dir) + strlen (dp->d_name) + 2)
264	sizeof (char));
265	sprintf (tmp, "%s/%s", conf_dir, dp->d_name);
266
267	if (prefix != NULL)
268	{
269	prefix = NULL;
270	}
271	prefix = (char ) malloc ((strlen (dp->d_name) + 2) sizeof (char));
272	sprintf (prefix, "%s.", dp->d_name);
273
274	//map* tmpMap=getMapFromMaps(m,"lenv",tmp1);
275
276	int res;
277	if (prefix != NULL)
278	{
279	setMapInMaps (m, "lenv", tmp1, prefix);
280	char levels1[17];
281	sprintf (levels1, "%d", level + 1);
282	setMapInMaps (m, "lenv", "level", levels1);
283	res =
284	recursReaddirF (m, r, n, tmp, prefix, saved_stdout, level + 1,
285	func);
286	sprintf (levels1, "%d", level);
287	setMapInMaps (m, "lenv", "level", levels1);
288	free (prefix);
289	prefix = NULL;
290	}
291	else
292	res = -1;
293	free (tmp);
294	if (res < 0)
295	{
296	return res;
297	}
298	}
299	else
300	{
301	char* extn = strstr(dp->d_name, ".zcfg");
302	if(dp->d_name[0] != '.' && extn != NULL && strlen(extn) == 5)
303	{
304	int t;
305	char tmps1[1024];
306	memset (tmps1, 0, 1024);
307	snprintf (tmps1, 1024, "%s/%s", conf_dir, dp->d_name);
308
309	char *tmpsn = zStrdup (dp->d_name);
310	tmpsn[strlen (tmpsn) - 5] = 0;
311
312	map* import = getMapFromMaps (m, IMPORTSERVICE, tmpsn);
313	if (import == NULL \|\| import->value == NULL \|\| zoo_path_compare(tmps1, import->value) != 0 ) { // service is not in [include] block
314	service s1 = (service ) malloc (SERVICE_SIZE);
315	if (s1 == NULL)
316	{
317	dup2 (saved_stdout, fileno (stdout));
318	errorException (m, _("Unable to allocate memory"),
319	"InternalError", NULL);
320	return -1;
321	}
322	#ifndef DEBUG
323	fprintf (stderr, "#################\n%s\n#################\n",
324	tmps1);
325	#endif
326	t = readServiceFile (m, tmps1, &s1, tmpsn);
327	free (tmpsn);
328	if (t < 0)
329	{
330	map *tmp00 = getMapFromMaps (m, "lenv", "message");
331	char tmp01[1024];
332	if (tmp00 != NULL)
333	sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"),
334	dp->d_name, tmp00->value);
335	else
336	sprintf (tmp01, _("Unable to parse the ZCFG file: %s."),
337	dp->d_name);
338	dup2 (saved_stdout, fileno (stdout));
339	errorException (m, tmp01, "InternalError", NULL);
340	return -1;
341	}
342	#ifdef DEBUG
343	dumpService (s1);
344	fflush (stdout);
345	fflush (stderr);
346	#endif
347	inheritance(r,&s1);
348	func (r, m, n, s1);
349	freeService (&s1);
350	free (s1);
351	scount++;
352	}
353	}
354	}
355	(void) closedir (dirp);
356	return 1;
357	}
358
359	/**
360	* Signal handling function which simply call exit(0).
361	*
362	* @param sig the signal number
363	*/
364	void
365	donothing (int sig)
366	{
367	#ifdef DEBUG
368	fprintf (stderr, "Signal %d after the ZOO-Kernel returned result!\n", sig);
369	#endif
370	exit (0);
371	}
372
373	/**
374	* Signal handling function which create an ExceptionReport node containing the
375	* information message corresponding to the signal number.
376	*
377	* @param sig the signal number
378	*/
379	void
380	sig_handler (int sig)
381	{
382	char tmp[100];
383	const char *ssig;
384	switch (sig)
385	{
386	case SIGSEGV:
387	ssig = "SIGSEGV";
388	break;
389	case SIGTERM:
390	ssig = "SIGTERM";
391	break;
392	case SIGINT:
393	ssig = "SIGINT";
394	break;
395	case SIGILL:
396	ssig = "SIGILL";
397	break;
398	case SIGFPE:
399	ssig = "SIGFPE";
400	break;
401	case SIGABRT:
402	ssig = "SIGABRT";
403	break;
404	default:
405	ssig = "UNKNOWN";
406	break;
407	}
408	sprintf (tmp,
409	_
410	("ZOO Kernel failed to process your request, receiving signal %d = %s"),
411	sig, ssig);
412	errorException (NULL, tmp, "InternalError", NULL);
413	#ifdef DEBUG
414	fprintf (stderr, "Not this time!\n");
415	#endif
416	exit (0);
417	}
418
419	/**
420	* Load a service provider and run the service function.
421	*
422	* @param myMap the conf maps containing the main.cfg settings
423	* @param s1 the service structure
424	* @param request_inputs map storing all the request parameters
425	* @param inputs the inputs maps
426	* @param ioutputs the outputs maps
427	* @param eres the result returned by the service execution
428	*/
429	void
430	loadServiceAndRun (maps ** myMap, service * s1, map * request_inputs,
431	maps inputs, maps ioutputs, int *eres)
432	{
433	char tmps1[1024];
434	char ntmp[1024];
435	maps m = myMap;
436	maps request_output_real_format = ioutputs;
437	maps request_input_real_format = inputs;
438	/**
439	* Extract serviceType to know what kind of service should be loaded
440	*/
441	map *r_inputs = NULL;
442	map* cwdMap=getMapFromMaps(m,"main","servicePath");
443	if(cwdMap!=NULL){
444	sprintf(ntmp,"%s",cwdMap->value);
445	}else{
446	#ifndef WIN32
447	getcwd (ntmp, 1024);
448	#else
449	_getcwd (ntmp, 1024);
450	#endif
451	}
452	r_inputs = getMap (s1->content, "serviceType");
453	#ifdef DEBUG
454	fprintf (stderr, "LOAD A %s SERVICE PROVIDER \n", r_inputs->value);
455	fflush (stderr);
456	#endif
457
458	map* libp = getMapFromMaps(m, "main", "libPath");
459
460	if (strlen (r_inputs->value) == 1
461	&& strncasecmp (r_inputs->value, "C", 1) == 0)
462	{
463	if (libp != NULL && libp->value != NULL) {
464	r_inputs = getMap (s1->content, "ServiceProvider");
465	sprintf (tmps1, "%s/%s", libp->value, r_inputs->value);
466	}
467	else {
468	r_inputs = getMap (request_inputs, "metapath");
469	if (r_inputs != NULL)
470	sprintf (tmps1, "%s/%s", ntmp, r_inputs->value);
471	else
472	sprintf (tmps1, "%s/", ntmp);
473
474	char *altPath = zStrdup (tmps1);
475	r_inputs = getMap (s1->content, "ServiceProvider");
476	sprintf (tmps1, "%s/%s", altPath, r_inputs->value);
477	free (altPath);
478	}
479	#ifdef DEBUG
480	fprintf (stderr, "Trying to load %s\n", tmps1);
481	#endif
482	#ifdef WIN32
483	HINSTANCE so =
484	LoadLibraryEx (tmps1, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
485	#else
486	void *so = dlopen (tmps1, RTLD_LAZY);
487	#endif
488	#ifdef WIN32
489	char* errstr = getLastErrorMessage();
490	#else
491	char *errstr;
492	errstr = dlerror ();
493	#endif
494	#ifdef DEBUG
495	fprintf (stderr, "%s loaded (%s) \n", tmps1, errstr);
496	#endif
497	if (so != NULL)
498	{
499	#ifdef DEBUG
500	fprintf (stderr, "Library loaded %s \n", errstr);
501	fprintf (stderr, "Service Shared Object = %s\n", r_inputs->value);
502	#endif
503	r_inputs = getMap (s1->content, "serviceType");
504	#ifdef DEBUG
505	dumpMap (r_inputs);
506	fprintf (stderr, "%s\n", r_inputs->value);
507	fflush (stderr);
508	#endif
509	if (strncasecmp (r_inputs->value, "C-FORTRAN", 9) == 0)
510	{
511	r_inputs = getMap (request_inputs, "Identifier");
512	char fname[1024];
513	sprintf (fname, "%s_", r_inputs->value);
514	#ifdef DEBUG
515	fprintf (stderr, "Try to load function %s\n", fname);
516	#endif
517	#ifdef WIN32
518	typedef int (CALLBACK * execute_t) (char *, char *,
519	char ***);
520	execute_t execute = (execute_t) GetProcAddress (so, fname);
521	#else
522	typedef int (execute_t) (char , char , char **);
523	execute_t execute = (execute_t) dlsym (so, fname);
524	#endif
525	#ifdef DEBUG
526	#ifdef WIN32
527	errstr = getLastErrorMessage();
528	#else
529	errstr = dlerror ();
530	#endif
531	fprintf (stderr, "Function loaded %s\n", errstr);
532	#endif
533
534	char main_conf[10][30][1024];
535	char inputs[10][30][1024];
536	char outputs[10][30][1024];
537	for (int i = 0; i < 10; i++)
538	{
539	for (int j = 0; j < 30; j++)
540	{
541	memset (main_conf[i][j], 0, 1024);
542	memset (inputs[i][j], 0, 1024);
543	memset (outputs[i][j], 0, 1024);
544	}
545	}
546	mapsToCharXXX (m, (char ***) main_conf);
547	mapsToCharXXX (request_input_real_format, (char ***) inputs);
548	mapsToCharXXX (request_output_real_format, (char ***) outputs);
549	*eres =
550	execute ((char *) &main_conf[0], (char *) &inputs[0],
551	(char ***) &outputs[0]);
552	#ifdef DEBUG
553	fprintf (stderr, "Function run successfully \n");
554	#endif
555	charxxxToMaps ((char ***) &outputs[0],
556	&request_output_real_format);
557	}
558	else
559	{
560	#ifdef DEBUG
561	#ifdef WIN32
562	errstr = getLastErrorMessage();
563	fprintf (stderr, "Function %s failed to load because of %s\n",
564	r_inputs->value, errstr);
565	#endif
566	#endif
567	r_inputs = getMapFromMaps (m, "lenv", "Identifier");
568	#ifdef DEBUG
569	fprintf (stderr, "Try to load function %s\n", r_inputs->value);
570	#endif
571	typedef int (execute_t) (maps , maps , maps *);
572	#ifdef WIN32
573	execute_t execute =
574	(execute_t) GetProcAddress (so, r_inputs->value);
575	#else
576	execute_t execute = (execute_t) dlsym (so, r_inputs->value);
577	#endif
578
579	if (execute == NULL)
580	{
581	#ifdef WIN32
582	errstr = getLastErrorMessage();
583	#else
584	errstr = dlerror ();
585	#endif
586	char *tmpMsg =
587	(char *) malloc (2048 + strlen (r_inputs->value));
588	sprintf (tmpMsg,
589	_
590	("Error occurred while running the %s function: %s"),
591	r_inputs->value, errstr);
592	errorException (m, tmpMsg, "InternalError", NULL);
593	free (tmpMsg);
594	#ifdef DEBUG
595	fprintf (stderr, "Function %s error %s\n", r_inputs->value,
596	errstr);
597	#endif
598	*eres = -1;
599	return;
600	}
601
602	#ifdef DEBUG
603	#ifdef WIN32
604	errstr = getLastErrorMessage();
605	#else
606	errstr = dlerror ();
607	#endif
608	fprintf (stderr, "Function loaded %s\n", errstr);
609	#endif
610
611	#ifdef DEBUG
612	fprintf (stderr, "Now run the function \n");
613	fflush (stderr);
614	#endif
615	*eres =
616	execute (&m, &request_input_real_format,
617	&request_output_real_format);
618	#ifdef DEBUG
619	fprintf (stderr, "Function loaded and returned %d\n", eres);
620	fflush (stderr);
621	#endif
622	}
623	#ifdef WIN32
624	*ioutputs = dupMaps (&request_output_real_format);
625	FreeLibrary (so);
626	#else
627	dlclose (so);
628	#endif
629	}
630	else
631	{
632	/**
633	* Unable to load the specified shared library
634	*/
635	char tmps[1024];
636	#ifdef WIN32
637	errstr = getLastErrorMessage();
638	#else
639	errstr = dlerror ();
640	#endif
641	sprintf (tmps, _("Unable to load C Library %s"), errstr);
642	errorException(m,tmps,"InternalError",NULL);
643	*eres = -1;
644	}
645	}
646	else
647
648	#ifdef USE_HPC
649	if (strncasecmp (r_inputs->value, "HPC", 3) == 0)
650	{
651	*eres =
652	zoo_hpc_support (&m, request_inputs, s1,
653	&request_input_real_format,
654	&request_output_real_format);
655	}
656	else
657	#endif
658
659	#ifdef USE_SAGA
660	if (strncasecmp (r_inputs->value, "SAGA", 4) == 0)
661	{
662	*eres =
663	zoo_saga_support (&m, request_inputs, s1,
664	&request_input_real_format,
665	&request_output_real_format);
666	}
667	else
668	#endif
669
670	#ifdef USE_OTB
671	if (strncasecmp (r_inputs->value, "OTB", 3) == 0)
672	{
673	*eres =
674	zoo_otb_support (&m, request_inputs, s1,
675	&request_input_real_format,
676	&request_output_real_format);
677	}
678	else
679	#endif
680	#ifdef USE_PYTHON
681	if (strncasecmp (r_inputs->value, "PYTHON", 6) == 0)
682	{
683	*eres =
684	zoo_python_support (&m, request_inputs, s1,
685	&request_input_real_format,
686	&request_output_real_format);
687	}
688	else
689	#endif
690
691	#ifdef USE_JAVA
692	if (strncasecmp (r_inputs->value, "JAVA", 4) == 0)
693	{
694	*eres =
695	zoo_java_support (&m, request_inputs, s1, &request_input_real_format,
696	&request_output_real_format);
697	}
698	else
699	#endif
700
701	#ifdef USE_PHP
702	if (strncasecmp (r_inputs->value, "PHP", 3) == 0)
703	{
704	*eres =
705	zoo_php_support (&m, request_inputs, s1, &request_input_real_format,
706	&request_output_real_format);
707	}
708	else
709	#endif
710
711
712	#ifdef USE_PERL
713	if (strncasecmp (r_inputs->value, "PERL", 4) == 0)
714	{
715	*eres =
716	zoo_perl_support (&m, request_inputs, s1, &request_input_real_format,
717	&request_output_real_format);
718	}
719	else
720	#endif
721
722	#ifdef USE_JS
723	if (strncasecmp (r_inputs->value, "JS", 2) == 0)
724	{
725	*eres =
726	zoo_js_support (&m, request_inputs, s1, &request_input_real_format,
727	&request_output_real_format);
728	}
729	else
730	#endif
731
732	#ifdef USE_RUBY
733	if (strncasecmp (r_inputs->value, "Ruby", 4) == 0)
734	{
735	*eres =
736	zoo_ruby_support (&m, request_inputs, s1, &request_input_real_format,
737	&request_output_real_format);
738	}
739	else
740	#endif
741
742	#ifdef USE_MONO
743	if (strncasecmp (r_inputs->value, "Mono", 4) == 0)
744	{
745	*eres =
746	zoo_mono_support (&m, request_inputs, s1, &request_input_real_format,
747	&request_output_real_format);
748	}
749	else
750	#endif
751
752	{
753	char tmpv[1024];
754	sprintf (tmpv,
755	_
756	("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),
757	r_inputs->value);
758	errorException (m, tmpv, "InternalError", NULL);
759	*eres = -1;
760	}
761	*myMap = m;
762	*ioutputs = request_output_real_format;
763	}
764
765
766	#ifdef WIN32
767	/**
768	* createProcess function: create a new process after setting some env variables
769	*/
770	void
771	createProcess (maps * m, map * request_inputs, service * s1, char *opts,
772	int cpid, maps * inputs, maps * outputs)
773	{
774	STARTUPINFO si;
775	PROCESS_INFORMATION pi;
776	ZeroMemory (&si, sizeof (si));
777	si.cb = sizeof (si);
778	ZeroMemory (&pi, sizeof (pi));
779	char tmp = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
780	char tmpq = (char ) malloc ((1024 + cgiContentLength) * sizeof (char));
781	map *req = getMap (request_inputs, "request");
782	map *id = getMap (request_inputs, "identifier");
783	map *di = getMap (request_inputs, "DataInputs");
784
785	// The required size for the dataInputsKVP and dataOutputsKVP buffers
786	// may exceed cgiContentLength, hence a 2 kb extension. However, a
787	// better solution would be to have getMapsAsKVP() determine the required
788	// buffer size before allocating memory.
789	char *dataInputsKVP = getMapsAsKVP (inputs, cgiContentLength + 2048, 0);
790	char *dataOutputsKVP = getMapsAsKVP (outputs, cgiContentLength + 2048, 1);
791	#ifdef DEBUG
792	fprintf (stderr, "DATAINPUTSKVP %s\n", dataInputsKVP);
793	fprintf (stderr, "DATAOUTPUTSKVP %s\n", dataOutputsKVP);
794	#endif
795	map *sid = getMapFromMaps (m, "lenv", "osid");
796	map *usid = getMapFromMaps (m, "lenv", "usid");
797	map *r_inputs = getMapFromMaps (m, "main", "tmpPath");
798	map *r_inputs1 = getMap (request_inputs, "metapath");
799
800	int hasIn = -1;
801	if (r_inputs1 == NULL)
802	{
803	r_inputs1 = createMap ("metapath", "");
804	hasIn = 1;
805	}
806	map *r_inputs2 = getMap (request_inputs, "ResponseDocument");
807	if (r_inputs2 == NULL)
808	r_inputs2 = getMap (request_inputs, "RawDataOutput");
809	map *tmpPath = getMapFromMaps (m, "lenv", "cwd");
810
811	map *tmpReq = getMap (request_inputs, "xrequest");
812
813	if(r_inputs2 != NULL && tmpReq != NULL) {
814	const char key[] = "rfile=";
815	char* kvp = (char) malloc((FILENAME_MAX + strlen(key))sizeof(char));
816	char* filepath = kvp + strlen(key);
817	strncpy(kvp, key, strlen(key));
818	addToCache(m, tmpReq->value, tmpReq->value, "text/xml", strlen(tmpReq->value),
819	filepath, FILENAME_MAX);
820	if (filepath == NULL) {
821	errorException( m, _("Unable to cache HTTP POST Execute request."), "InternalError", NULL);
822	return;
823	}
824	sprintf(tmp,"\"metapath=%s&%s&cgiSid=%s&usid=%s\"",
825	r_inputs1->value,kvp,sid->value,usid->value);
826	sprintf(tmpq,"metapath=%s&%s",
827	r_inputs1->value,kvp);
828	free(kvp);
829	}
830	else if (r_inputs2 != NULL)
831	{
832	sprintf (tmp,
833	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s&usid=%s\"",
834	r_inputs1->value, req->value, id->value, dataInputsKVP,
835	r_inputs2->name, dataOutputsKVP, sid->value, usid->value);
836	sprintf (tmpq,
837	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",
838	r_inputs1->value, req->value, id->value, dataInputsKVP,
839	r_inputs2->name, dataOutputsKVP);
840	}
841	else
842	{
843	sprintf (tmp,
844	"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s&usid=%s\"",
845	r_inputs1->value, req->value, id->value, dataInputsKVP,
846	sid->value, usid->value);
847	sprintf (tmpq,
848	"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",
849	r_inputs1->value, req->value, id->value, dataInputsKVP,
850	sid->value);
851	}
852
853	if (hasIn > 0)
854	{
855	freeMap (&r_inputs1);
856	free (r_inputs1);
857	}
858	char *tmp1 = zStrdup (tmp);
859	sprintf (tmp, "\"%s\" %s \"%s\"", PROGRAMNAME, tmp1, sid->value);
860	free (dataInputsKVP);
861	free (dataOutputsKVP);
862	#ifdef DEBUG
863	fprintf (stderr, "REQUEST IS : %s \n", tmp);
864	#endif
865
866	usid = getMapFromMaps (m, "lenv", "usid");
867	if (usid != NULL && usid->value != NULL) {
868	SetEnvironmentVariable("USID", TEXT (usid->value));
869	}
870	SetEnvironmentVariable ("CGISID", TEXT (sid->value));
871	SetEnvironmentVariable ("QUERY_STRING", TEXT (tmpq));
872	// knut: Prevent REQUEST_METHOD=POST in background process call to cgic:main
873	// (process hangs when reading cgiIn):
874	SetEnvironmentVariable("REQUEST_METHOD", "GET");
875	SetEnvironmentVariable("CONTENT_TYPE", "text/plain");
876
877	char clen[1000];
878	sprintf (clen, "%d", strlen (tmpq));
879	SetEnvironmentVariable ("CONTENT_LENGTH", TEXT (clen));
880
881	// ref. https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863%28v=vs.85%29.aspx
882	if (!CreateProcess (NULL, // No module name (use command line)
883	TEXT (tmp), // Command line
884	NULL, // Process handle not inheritable
885	NULL, // Thread handle not inheritable
886	FALSE, // Set handle inheritance to FALSE
887	CREATE_NO_WINDOW, // Apache won't wait until the end
888	NULL, // Use parent's environment block
889	NULL, // Use parent's starting directory
890	&si, // Pointer to STARTUPINFO struct
891	&pi) // Pointer to PROCESS_INFORMATION struct
892	)
893	{
894	#ifdef DEBUG
895	fprintf (stderr, "CreateProcess failed (%d).\n", GetLastError ());
896	#endif
897	if (tmp != NULL) {
898	free(tmp);
899	}
900	if (tmpq != NULL) {
901	free(tmpq);
902	}
903	return;
904	}
905	else
906	{
907	#ifdef DEBUG
908	fprintf (stderr, "CreateProcess successful (%d).\n\n\n\n",
909	GetLastError ());
910	#endif
911	}
912	CloseHandle (pi.hProcess);
913	CloseHandle (pi.hThread);
914
915	if (tmp != NULL) {
916	free(tmp);
917	}
918	if (tmpq != NULL) {
919	free(tmpq);
920	}
921
922	#ifdef DEBUG
923	fprintf (stderr, "CreateProcess finished !\n");
924	#endif
925	}
926	#endif
927
928	/**
929	* Process the request.
930	*
931	* @param inputs the request parameters map
932	* @return 0 on sucess, other value on failure
933	* @see conf_read,recursReaddirF
934	*/
935	int
936	runRequest (map ** inputs)
937	{
938
939	#ifndef USE_GDB
940	#ifndef WIN32
941	signal (SIGCHLD, SIG_IGN);
942	#endif
943	signal (SIGSEGV, sig_handler);
944	signal (SIGTERM, sig_handler);
945	signal (SIGINT, sig_handler);
946	signal (SIGILL, sig_handler);
947	signal (SIGFPE, sig_handler);
948	signal (SIGABRT, sig_handler);
949	#endif
950
951	map *r_inputs = NULL;
952	map request_inputs = inputs;
953	#ifdef IGNORE_METAPATH
954	addToMap(request_inputs, "metapath", "");
955	#endif
956	maps *m = NULL;
957	char *REQUEST = NULL;
958	/**
959	* Parsing service specfic configuration file
960	*/
961	m = (maps *) malloc (MAPS_SIZE);
962	if (m == NULL)
963	{
964	return errorException (NULL, _("Unable to allocate memory"),
965	"InternalError", NULL);
966	}
967	m->child=NULL;
968	char ntmp[1024];
969	#ifndef ETC_DIR
970	#ifndef WIN32
971	getcwd (ntmp, 1024);
972	#else
973	_getcwd (ntmp, 1024);
974	#endif
975	#else
976	sprintf(ntmp,"%s",ETC_DIR);
977	#endif
978	r_inputs = getMapOrFill (&request_inputs, "metapath", "");
979
980	char conf_file[10240];
981	snprintf (conf_file, 10240, "%s/%s/main.cfg", ntmp, r_inputs->value);
982	#ifdef ETC_DIR
983	#ifndef WIN32
984	getcwd (ntmp, 1024);
985	#else
986	_getcwd (ntmp, 1024);
987	#endif
988	#endif
989
990	if (conf_read (conf_file, m) == 2)
991	{
992	errorException (NULL, _("Unable to load the main.cfg file."),
993	"InternalError", NULL);
994	free (m);
995	return 1;
996	}
997	#ifdef DEBUG
998	fprintf (stderr, "***** BEGIN MAPS\n");
999	dumpMaps (m);
1000	fprintf (stderr, "***** END MAPS\n");
1001	#endif
1002
1003	map *getPath = getMapFromMaps (m, "main", "gettextPath");
1004	if (getPath != NULL)
1005	{
1006	bindtextdomain ("zoo-kernel", getPath->value);
1007	bindtextdomain ("zoo-services", getPath->value);
1008	}
1009	else
1010	{
1011	bindtextdomain ("zoo-kernel", LOCALEDIR);
1012	bindtextdomain ("zoo-services", LOCALEDIR);
1013	}
1014
1015	/**
1016	* Manage our own error log file (usefull to separate standard apache debug
1017	* messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
1018	* headers messages returned by the CGI due to wrong redirection of stderr)
1019	*/
1020	FILE *fstde = NULL;
1021	map *fstdem = getMapFromMaps (m, "main", "logPath");
1022	if (fstdem != NULL)
1023	fstde = freopen (fstdem->value, "a+", stderr);
1024
1025	r_inputs = getMap (request_inputs, "language");
1026	if (r_inputs == NULL)
1027	r_inputs = getMap (request_inputs, "AcceptLanguages");
1028	if (r_inputs == NULL)
1029	r_inputs = getMapFromMaps (m, "main", "language");
1030	if (r_inputs != NULL)
1031	{
1032	if (isValidLang (m, r_inputs->value) < 0)
1033	{
1034	char tmp[1024];
1035	sprintf (tmp,
1036	_
1037	("The value %s is not supported for the <language> parameter"),
1038	r_inputs->value);
1039	errorException (m, tmp, "InvalidParameterValue", "language");
1040	freeMaps (&m);
1041	free (m);
1042	free (REQUEST);
1043	return 1;
1044
1045	}
1046	char *tmp = zStrdup (r_inputs->value);
1047	setMapInMaps (m, "main", "language", tmp);
1048	#ifdef DEB
1049	char tmp2[12];
1050	sprintf (tmp2, "%s.utf-8", tmp);
1051	translateChar (tmp2, '-', '_');
1052	setlocale (LC_ALL, tmp2);
1053	#else
1054	translateChar (tmp, '-', '_');
1055	setlocale (LC_ALL, tmp);
1056	#endif
1057	#ifndef WIN32
1058	setenv ("LC_ALL", tmp, 1);
1059	#else
1060	char tmp1[13];
1061	sprintf (tmp1, "LC_ALL=%s", tmp);
1062	putenv (tmp1);
1063	#endif
1064	free (tmp);
1065	}
1066	else
1067	{
1068	setlocale (LC_ALL, "en_US");
1069	#ifndef WIN32
1070	setenv ("LC_ALL", "en_US", 1);
1071	#else
1072	char tmp1[13];
1073	sprintf (tmp1, "LC_ALL=en_US");
1074	putenv (tmp1);
1075	#endif
1076	setMapInMaps (m, "main", "language", "en-US");
1077	}
1078	setlocale (LC_NUMERIC, "C");
1079	#ifndef WIN32
1080	setenv ("LC_NUMERIC", "C", 1);
1081	#else
1082	char tmp1[17];
1083	sprintf (tmp1, "LC_NUMERIC=C");
1084	putenv (tmp1);
1085	#endif
1086	bind_textdomain_codeset ("zoo-kernel", "UTF-8");
1087	textdomain ("zoo-kernel");
1088	bind_textdomain_codeset ("zoo-services", "UTF-8");
1089	textdomain ("zoo-services");
1090
1091	map *lsoap = getMap (request_inputs, "soap");
1092	if (lsoap != NULL && strcasecmp (lsoap->value, "true") == 0)
1093	setMapInMaps (m, "main", "isSoap", "true");
1094	else
1095	setMapInMaps (m, "main", "isSoap", "false");
1096
1097	if(strlen(cgiServerName)>0)
1098	{
1099	char tmpUrl[1024];
1100
1101	if ( getenv("HTTPS") != NULL && strncmp(getenv("HTTPS"), "on", 2) == 0 ) {
1102	// Knut: check if non-empty instead of "on"?
1103	if ( strncmp(cgiServerPort, "443", 3) == 0 ) {
1104	sprintf(tmpUrl, "https://%s%s", cgiServerName, cgiScriptName);
1105	}
1106	else {
1107	sprintf(tmpUrl, "https://%s:%s%s", cgiServerName, cgiServerPort, cgiScriptName);
1108	}
1109	}
1110	else {
1111	if ( strncmp(cgiServerPort, "80", 2) == 0 ) {
1112	sprintf(tmpUrl, "http://%s%s", cgiServerName, cgiScriptName);
1113	}
1114	else {
1115	sprintf(tmpUrl, "http://%s:%s%s", cgiServerName, cgiServerPort, cgiScriptName);
1116	}
1117	}
1118	#ifdef DEBUG
1119	fprintf(stderr,"* %s *\n",tmpUrl);
1120	#endif
1121	setMapInMaps(m,"main","serverAddress",tmpUrl);
1122	}
1123
1124	// CORS Support
1125	if(strncasecmp(cgiRequestMethod,"OPTIONS",7)==0){
1126	map* cors=getMapFromMaps(m,"main","cors");
1127	if(cors!=NULL && strncasecmp(cors->value,"true",4)==0){
1128	char *encoding=getEncoding(m);
1129	printHeaders(m);
1130	printf("Content-Type: text/plain; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1131	printf(_("CORS is enabled.\r\n"));
1132	freeMaps (&m);
1133	free (m);
1134	fflush (stdout);
1135	return 3;
1136	}
1137	}
1138
1139	//Check for minimum inputs
1140	map* version=getMap(request_inputs,"version");
1141	if(version==NULL)
1142	version=getMapFromMaps(m,"main","version");
1143	setMapInMaps(m,"main","rversion",version->value);
1144	int vid=getVersionId(version->value);
1145	if(vid<0)
1146	vid=0;
1147	map* err=NULL;
1148	const char vvr=(const char)requests[vid];
1149	checkValidValue(request_inputs,&err,"request",vvr,1);
1150	const char *vvs[]={
1151	"WPS",
1152	NULL
1153	};
1154	if(err!=NULL){
1155	checkValidValue(request_inputs,&err,"service",(const char**)vvs,1);
1156	printExceptionReportResponse (m, err);
1157	freeMap(&err);
1158	free(err);
1159	if (count (request_inputs) == 1)
1160	{
1161	freeMap (&request_inputs);
1162	free (request_inputs);
1163	}
1164	freeMaps (&m);
1165	free (m);
1166	return 1;
1167	}
1168	checkValidValue(request_inputs,&err,"service",(const char**)vvs,1);
1169
1170	const char *vvv[]={
1171	"1.0.0",
1172	"2.0.0",
1173	NULL
1174	};
1175	r_inputs = getMap (request_inputs, "Request");
1176	REQUEST = zStrdup (r_inputs->value);
1177	int reqId=-1;
1178	if (strncasecmp (REQUEST, "GetCapabilities", 15) != 0){
1179	checkValidValue(request_inputs,&err,"version",(const char**)vvv,1);
1180	int j=0;
1181	for(j=0;j<nbSupportedRequests;j++){
1182	if(requests[vid][j]!=NULL && requests[vid][j+1]!=NULL){
1183	if(j<nbReqIdentifier && strncasecmp(REQUEST,requests[vid][j+1],strlen(REQUEST))==0){
1184	checkValidValue(request_inputs,&err,"identifier",NULL,1);
1185	reqId=j+1;
1186	break;
1187	}
1188	else
1189	if(j>=nbReqIdentifier && j<nbReqIdentifier+nbReqJob &&
1190	strncasecmp(REQUEST,requests[vid][j+1],strlen(REQUEST))==0){
1191	checkValidValue(request_inputs,&err,"jobid",NULL,1);
1192	reqId=j+1;
1193	break;
1194	}
1195	}else
1196	break;
1197	}
1198	}else{
1199	checkValidValue(request_inputs,&err,"AcceptVersions",(const char**)vvv,-1);
1200	map* version1=getMap(request_inputs,"AcceptVersions");
1201	if(version1!=NULL){
1202	if(strstr(version1->value,schemas[1][0])!=NULL)
1203	addToMap(request_inputs,"version",schemas[1][0]);
1204	else
1205	addToMap(request_inputs,"version",version1->value);
1206	version=getMap(request_inputs,"version");
1207	setMapInMaps(m,"main","rversion",version->value);
1208	vid=getVersionId(version->value);
1209	}
1210	}
1211	if(err!=NULL){
1212	printExceptionReportResponse (m, err);
1213	freeMap(&err);
1214	free(err);
1215	if (count (request_inputs) == 1)
1216	{
1217	freeMap (&request_inputs);
1218	free (request_inputs);
1219	}
1220	free(REQUEST);
1221	freeMaps (&m);
1222	free (m);
1223	return 1;
1224	}
1225
1226	r_inputs = getMap (request_inputs, "serviceprovider");
1227	if (r_inputs == NULL)
1228	{
1229	addToMap (request_inputs, "serviceprovider", "");
1230	}
1231
1232	maps *request_output_real_format = NULL;
1233	map *tmpm = getMapFromMaps (m, "main", "serverAddress");
1234	if (tmpm != NULL)
1235	SERVICE_URL = zStrdup (tmpm->value);
1236	else
1237	SERVICE_URL = zStrdup (DEFAULT_SERVICE_URL);
1238
1239
1240
1241	service *s1;
1242	int scount = 0;
1243	#ifdef DEBUG
1244	dumpMap (r_inputs);
1245	#endif
1246	char conf_dir[1024];
1247	int t;
1248	char tmps1[1024];
1249
1250	r_inputs = NULL;
1251	r_inputs = getMap (request_inputs, "metapath");
1252	map* cwdMap0=getMapFromMaps(m,"main","servicePath");
1253	if (r_inputs != NULL)
1254	if(cwdMap0!=NULL)
1255	snprintf (conf_dir, 1024, "%s/%s", cwdMap0->value, r_inputs->value);
1256	else
1257	snprintf (conf_dir, 1024, "%s/%s", ntmp, r_inputs->value);
1258	else
1259	if(cwdMap0!=NULL)
1260	snprintf (conf_dir, 1024, "%s", cwdMap0->value);
1261	else
1262	snprintf (conf_dir, 1024, "%s", ntmp);
1263	map* reg = getMapFromMaps (m, "main", "registry");
1264	registry* zooRegistry=NULL;
1265	if(reg!=NULL){
1266	int saved_stdout = dup (fileno (stdout));
1267	dup2 (fileno (stderr), fileno (stdout));
1268	if(createRegistry (m,&zooRegistry,reg->value)<0){
1269	map *message=getMapFromMaps(m,"lenv","message");
1270	map *type=getMapFromMaps(m,"lenv","type");
1271	dup2 (saved_stdout, fileno (stdout));
1272	errorException (m, message->value,
1273	type->value, NULL);
1274	return 0;
1275	}
1276	dup2 (saved_stdout, fileno (stdout));
1277	close(saved_stdout);
1278	}
1279
1280	if (strncasecmp (REQUEST, "GetCapabilities", 15) == 0)
1281	{
1282	#ifdef DEBUG
1283	dumpMap (r_inputs);
1284	#endif
1285	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1286	xmlNodePtr n=printGetCapabilitiesHeader(doc,m,(version!=NULL?version->value:"1.0.0"));
1287	/**
1288	* Here we need to close stdout to ensure that unsupported chars
1289	* has been found in the zcfg and then printed on stdout
1290	*/
1291	int saved_stdout = dup (fileno (stdout));
1292	dup2 (fileno (stderr), fileno (stdout));
1293
1294	maps* imports = getMaps(m, IMPORTSERVICE);
1295	if (imports != NULL) {
1296	map* zcfg = imports->content;
1297
1298	while (zcfg != NULL) {
1299	if (zcfg->value != NULL) {
1300	service* svc = (service*) malloc(SERVICE_SIZE);
1301	if (svc == NULL \|\| readServiceFile(m, zcfg->value, &svc, zcfg->name) < 0) {
1302	// pass over silently
1303	zcfg = zcfg->next;
1304	continue;
1305	}
1306	inheritance(zooRegistry, &svc);
1307	printGetCapabilitiesForProcess(zooRegistry, m, n, svc);
1308	freeService(&svc);
1309	free(svc);
1310	}
1311	zcfg = zcfg->next;
1312	}
1313	}
1314
1315	if (int res =
1316	recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
1317	printGetCapabilitiesForProcess) < 0)
1318	{
1319	freeMaps (&m);
1320	free (m);
1321	if(zooRegistry!=NULL){
1322	freeRegistry(&zooRegistry);
1323	free(zooRegistry);
1324	}
1325	free (REQUEST);
1326	free (SERVICE_URL);
1327	fflush (stdout);
1328	return res;
1329	}
1330	fflush (stdout);
1331	dup2 (saved_stdout, fileno (stdout));
1332	#ifdef META_DB
1333	fetchServicesFromDb(zooRegistry,m,n,printGetCapabilitiesForProcess);
1334	#endif
1335	printDocument (m, doc, getpid ());
1336	freeMaps (&m);
1337	free (m);
1338	if(zooRegistry!=NULL){
1339	freeRegistry(&zooRegistry);
1340	free(zooRegistry);
1341	}
1342	free (REQUEST);
1343	free (SERVICE_URL);
1344	fflush (stdout);
1345	return 0;
1346	}
1347	else
1348	{
1349	r_inputs = getMap (request_inputs, "JobId");
1350	if(reqId>nbReqIdentifier){
1351	if (strncasecmp (REQUEST, "GetStatus", strlen(REQUEST)) == 0 \|\|
1352	strncasecmp (REQUEST, "GetResult", strlen(REQUEST)) == 0){
1353	runGetStatus(m,r_inputs->value,REQUEST);
1354	freeMaps (&m);
1355	free (m);
1356	if(zooRegistry!=NULL){
1357	freeRegistry(&zooRegistry);
1358	free(zooRegistry);
1359	}
1360	free (REQUEST);
1361	free (SERVICE_URL);
1362	return 0;
1363	}
1364	else
1365	if (strncasecmp (REQUEST, "Dismiss", strlen(REQUEST)) == 0){
1366	runDismiss(m,r_inputs->value);
1367	freeMaps (&m);
1368	free (m);
1369	if(zooRegistry!=NULL){
1370	freeRegistry(&zooRegistry);
1371	free(zooRegistry);
1372	}
1373	free (REQUEST);
1374	free (SERVICE_URL);
1375	return 0;
1376
1377	}
1378	return 0;
1379	}
1380	if(reqId<=nbReqIdentifier){
1381	r_inputs = getMap (request_inputs, "Identifier");
1382
1383	struct dirent *dp;
1384	DIR *dirp = opendir (conf_dir);
1385	if (dirp == NULL)
1386	{
1387	errorException (m, _("The specified path does not exist."),
1388	"InternalError", NULL);
1389	freeMaps (&m);
1390	free (m);
1391	if(zooRegistry!=NULL){
1392	freeRegistry(&zooRegistry);
1393	free(zooRegistry);
1394	}
1395	free (REQUEST);
1396	free (SERVICE_URL);
1397	return 0;
1398	}
1399	if (strncasecmp (REQUEST, "DescribeProcess", 15) == 0)
1400	{
1401	/**
1402	* Loop over Identifier list
1403	*/
1404	xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1405	r_inputs = NULL;
1406	r_inputs = getMap (request_inputs, "version");
1407	xmlNodePtr n = printWPSHeader(doc,m,"DescribeProcess",
1408	root_nodes[vid][1],(version!=NULL?version->value:"1.0.0"),1);
1409
1410	r_inputs = getMap (request_inputs, "Identifier");
1411
1412	char *orig = zStrdup (r_inputs->value);
1413
1414	int saved_stdout = dup (fileno (stdout));
1415	dup2 (fileno (stderr), fileno (stdout));
1416	if (strcasecmp ("all", orig) == 0)
1417	{
1418	maps* imports = getMaps(m, IMPORTSERVICE);
1419	if (imports != NULL) {
1420	map* zcfg = imports->content;
1421
1422	while (zcfg != NULL) {
1423	if (zcfg->value != NULL) {
1424	service* svc = (service*) malloc(SERVICE_SIZE);
1425	if (svc == NULL \|\| readServiceFile(m, zcfg->value, &svc, zcfg->name) < 0) {
1426	// pass over silently
1427	zcfg = zcfg->next;
1428	continue;
1429	}
1430	inheritance(zooRegistry, &svc);
1431	printDescribeProcessForProcess(zooRegistry, m, n, svc);
1432	freeService(&svc);
1433	free(svc);
1434	}
1435	zcfg = zcfg->next;
1436	}
1437	}
1438
1439	if (int res =
1440	recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
1441	printDescribeProcessForProcess) < 0)
1442	return res;
1443	#ifdef META_DB
1444	fetchServicesFromDb(zooRegistry,m,n,printDescribeProcessForProcess);
1445	#endif
1446
1447	}
1448	else
1449	{
1450	char *saveptr;
1451	char *tmps = strtok_r (orig, ",", &saveptr);
1452
1453	char buff[256];
1454	char buff1[1024];
1455	while (tmps != NULL)
1456	{
1457	int hasVal = -1;
1458	char *corig = zStrdup (tmps);
1459	map* import = getMapFromMaps (m, IMPORTSERVICE, corig);
1460	if (import != NULL && import->value != NULL)
1461	{
1462	#ifdef META_DB
1463	service* s2=extractServiceFromDb(m,import->name);
1464	fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
1465	fflush(stderr);
1466	if(s2==NULL){
1467	#endif
1468	s1 = (service *) malloc (SERVICE_SIZE);
1469	t = readServiceFile (m, import->value, &s1, import->name);
1470
1471	if (t < 0) // failure reading zcfg
1472	{
1473	map *tmp00 = getMapFromMaps (m, "lenv", "message");
1474	char tmp01[1024];
1475	if (tmp00 != NULL)
1476	sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"), import->value, tmp00->value);
1477	else
1478	sprintf (tmp01, _("Unable to parse the ZCFG file: %s."), import->value);
1479
1480	dup2 (saved_stdout, fileno (stdout));
1481	errorException (m, tmp01, "InternalError", NULL);
1482
1483	freeMaps (&m);
1484	free (m);
1485
1486	if(zooRegistry!=NULL){
1487	freeRegistry(&zooRegistry);
1488	free(zooRegistry);
1489	}
1490	free (orig);
1491	free (REQUEST);
1492	closedir (dirp);
1493	xmlFreeDoc (doc);
1494	xmlCleanupParser ();
1495	zooXmlCleanupNs ();
1496
1497	return 1;
1498	}
1499	#ifdef DEBUG
1500	dumpService (s1);
1501	#endif
1502
1503	inheritance(zooRegistry,&s1);
1504	printDescribeProcessForProcess (zooRegistry,m, n, s1);
1505	freeService (&s1);
1506	free (s1);
1507	s1 = NULL;
1508	scount++;
1509	hasVal = 1;
1510	#ifdef META_DB
1511	}
1512	#endif
1513	}
1514	else if (strstr (corig, ".") != NULL)
1515	{
1516
1517	parseIdentifier (m, conf_dir, corig, buff1);
1518	map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
1519	if (tmpMap != NULL)
1520	addToMap (request_inputs, "metapath", tmpMap->value);
1521	map *tmpMapI = getMapFromMaps (m, "lenv", "Identifier");
1522
1523	#ifdef META_DB
1524	service* s2=extractServiceFromDb(m,tmpMapI->name);
1525	fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
1526	fflush(stderr);
1527	if(s2==NULL){
1528	#endif
1529	s1 = (service *) malloc (SERVICE_SIZE);
1530	t = readServiceFile (m, buff1, &s1, tmpMapI->value);
1531	if (t < 0)
1532	{
1533	map *tmp00 = getMapFromMaps (m, "lenv", "message");
1534	char tmp01[1024];
1535	if (tmp00 != NULL)
1536	sprintf (tmp01,
1537	_
1538	("Unable to parse the ZCFG file for the following ZOO-Service: %s. Message: %s"),
1539	tmps, tmp00->value);
1540	else
1541	sprintf (tmp01,
1542	_
1543	("Unable to parse the ZCFG file for the following ZOO-Service: %s."),
1544	tmps);
1545	dup2 (saved_stdout, fileno (stdout));
1546	errorException (m, tmp01, "InvalidParameterValue",
1547	"identifier");
1548	freeMaps (&m);
1549	free (m);
1550	if(zooRegistry!=NULL){
1551	freeRegistry(&zooRegistry);
1552	free(zooRegistry);
1553	}
1554	free (REQUEST);
1555	free (corig);
1556	free (orig);
1557	free (SERVICE_URL);
1558	free (s1);
1559	closedir (dirp);
1560	xmlFreeDoc (doc);
1561	xmlCleanupParser ();
1562	zooXmlCleanupNs ();
1563	return 1;
1564	}
1565	#ifdef DEBUG
1566	dumpService (s1);
1567	#endif
1568	inheritance(zooRegistry,&s1);
1569	printDescribeProcessForProcess (zooRegistry,m, n, s1);
1570	freeService (&s1);
1571	free (s1);
1572	s1 = NULL;
1573	scount++;
1574	hasVal = 1;
1575	setMapInMaps (m, "lenv", "level", "0");
1576	#ifdef META_DB
1577	}
1578	#endif
1579	}
1580	else
1581	{
1582	fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
1583	fflush(stderr);
1584	#ifdef META_DB
1585	_init_sql(m,"metadb");
1586	service* s2=extractServiceFromDb(m,corig);
1587	if(s2!=NULL){
1588	fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
1589	fflush(stderr);
1590	inheritance(zooRegistry,&s2);
1591	printDescribeProcessForProcess (zooRegistry,m, n, s2);
1592	freeService (&s2);
1593	free (s2);
1594	s2 = NULL;
1595	hasVal = 1;
1596	}else /TOTO/{
1597	#endif
1598	memset (buff, 0, 256);
1599	snprintf (buff, 256, "%s.zcfg", corig);
1600	memset (buff1, 0, 1024);
1601	#ifdef DEBUG
1602	printf ("\n#######%s\n########\n", buff);
1603	#endif
1604	while ((dp = readdir (dirp)) != NULL)
1605	{
1606	if (strcasecmp (dp->d_name, buff) == 0)
1607	{
1608	memset (buff1, 0, 1024);
1609	snprintf (buff1, 1024, "%s/%s", conf_dir,
1610	dp->d_name);
1611	s1 = (service *) malloc (SERVICE_SIZE);
1612	if (s1 == NULL)
1613	{
1614	dup2 (saved_stdout, fileno (stdout));
1615	return errorException (m,
1616	_
1617	("Unable to allocate memory"),
1618	"InternalError",
1619	NULL);
1620	}
1621	#ifdef DEBUG_SERVICE_CONF
1622	fprintf
1623	(stderr,"#################\n(%s) %s\n#################\n",
1624	r_inputs->value, buff1);
1625	#endif
1626	char *tmp0 = zStrdup (dp->d_name);
1627	tmp0[strlen (tmp0) - 5] = 0;
1628	t = readServiceFile (m, buff1, &s1, tmp0);
1629	free (tmp0);
1630	if (t < 0)
1631	{
1632	map *tmp00 =
1633	getMapFromMaps (m, "lenv", "message");
1634	char tmp01[1024];
1635	if (tmp00 != NULL)
1636	sprintf (tmp01,
1637	_
1638	("Unable to parse the ZCFG file: %s (%s)"),
1639	dp->d_name, tmp00->value);
1640	else
1641	sprintf (tmp01,
1642	_
1643	("Unable to parse the ZCFG file: %s."),
1644	dp->d_name);
1645	dup2 (saved_stdout, fileno (stdout));
1646	errorException (m, tmp01, "InternalError",
1647	NULL);
1648	freeMaps (&m);
1649	free (m);
1650	if(zooRegistry!=NULL){
1651	freeRegistry(&zooRegistry);
1652	free(zooRegistry);
1653	}
1654	free (orig);
1655	free (REQUEST);
1656	closedir (dirp);
1657	xmlFreeDoc (doc);
1658	xmlCleanupParser ();
1659	zooXmlCleanupNs ();
1660	return 1;
1661	}
1662	#ifdef DEBUG
1663	dumpService (s1);
1664	#endif
1665	inheritance(zooRegistry,&s1);
1666	printDescribeProcessForProcess (zooRegistry,m, n, s1);
1667	freeService (&s1);
1668	free (s1);
1669	s1 = NULL;
1670	scount++;
1671	hasVal = 1;
1672	}
1673	}
1674	#ifdef META_DB
1675	}
1676	#endif
1677	}
1678	if (hasVal < 0)
1679	{
1680	map *tmp00 = getMapFromMaps (m, "lenv", "message");
1681	char tmp01[1024];
1682	if (tmp00 != NULL)
1683	sprintf (tmp01,
1684	_("Unable to parse the ZCFG file: %s (%s)"),
1685	buff, tmp00->value);
1686	else
1687	sprintf (tmp01,
1688	_("Unable to parse the ZCFG file: %s."),
1689	buff);
1690	dup2 (saved_stdout, fileno (stdout));
1691	errorException (m, tmp01, "InvalidParameterValue",
1692	"Identifier");
1693	freeMaps (&m);
1694	free (m);
1695	if(zooRegistry!=NULL){
1696	freeRegistry(&zooRegistry);
1697	free(zooRegistry);
1698	}
1699	free (orig);
1700	free (REQUEST);
1701	closedir (dirp);
1702	xmlFreeDoc (doc);
1703	xmlCleanupParser ();
1704	zooXmlCleanupNs ();
1705	return 1;
1706	}
1707	rewinddir (dirp);
1708	tmps = strtok_r (NULL, ",", &saveptr);
1709	if (corig != NULL)
1710	free (corig);
1711	}
1712	}
1713	closedir (dirp);
1714	fflush (stdout);
1715	dup2 (saved_stdout, fileno (stdout));
1716	free (orig);
1717	printDocument (m, doc, getpid ());
1718	freeMaps (&m);
1719	free (m);
1720	if(zooRegistry!=NULL){
1721	freeRegistry(&zooRegistry);
1722	free(zooRegistry);
1723	}
1724	free (REQUEST);
1725	free (SERVICE_URL);
1726	fflush (stdout);
1727	return 0;
1728	}
1729	else if (strncasecmp (REQUEST, "Execute", strlen (REQUEST)) != 0)
1730	{
1731	map* version=getMapFromMaps(m,"main","rversion");
1732	int vid=getVersionId(version->value);
1733	int len = 0;
1734	int j = 0;
1735	for(j=0;j<nbSupportedRequests;j++){
1736	if(requests[vid][j]!=NULL)
1737	len+=strlen(requests[vid][j])+2;
1738	else{
1739	len+=4;
1740	break;
1741	}
1742	}
1743	char tmpStr=(char)malloc(len*sizeof(char));
1744	int it=0;
1745	for(j=0;j<nbSupportedRequests;j++){
1746	if(requests[vid][j]!=NULL){
1747	if(it==0){
1748	sprintf(tmpStr,"%s",requests[vid][j]);
1749	it++;
1750	}else{
1751	char *tmpS=zStrdup(tmpStr);
1752	if(j+1<nbSupportedRequests && requests[vid][j+1]==NULL){
1753	sprintf(tmpStr,"%s and %s",tmpS,requests[vid][j]);
1754	}else{
1755	sprintf(tmpStr,"%s, %s",tmpS,requests[vid][j]);
1756
1757	}
1758	free(tmpS);
1759	}
1760	}
1761	else{
1762	len+=4;
1763	break;
1764	}
1765	}
1766	char* message=(char)malloc((61+len)sizeof(char));
1767	sprintf(message,"The <request> value was not recognized. Allowed values are %s.",tmpStr);
1768	errorException (m,_(message),"InvalidParameterValue", "request");
1769	#ifdef DEBUG
1770	fprintf (stderr, "No request found %s", REQUEST);
1771	#endif
1772	closedir (dirp);
1773	freeMaps (&m);
1774	free (m);
1775	if(zooRegistry!=NULL){
1776	freeRegistry(&zooRegistry);
1777	free(zooRegistry);
1778	}
1779	free (REQUEST);
1780	free (SERVICE_URL);
1781	fflush (stdout);
1782	return 0;
1783	}
1784	closedir (dirp);
1785	}
1786	}
1787
1788	map *postRequest = NULL;
1789	postRequest = getMap (request_inputs, "xrequest");
1790
1791	if(vid==1 && postRequest==NULL){
1792	errorException (m,_("Unable to run Execute request using the GET HTTP method"),"InvalidParameterValue", "request");
1793	freeMaps (&m);
1794	free (m);
1795	if(zooRegistry!=NULL){
1796	freeRegistry(&zooRegistry);
1797	free(zooRegistry);
1798	}
1799	free (REQUEST);
1800	free (SERVICE_URL);
1801	fflush (stdout);
1802	return 0;
1803	}
1804	s1 = NULL;
1805	s1 = (service *) malloc (SERVICE_SIZE);
1806	if (s1 == NULL)
1807	{
1808	freeMaps (&m);
1809	free (m);
1810	if(zooRegistry!=NULL){
1811	freeRegistry(&zooRegistry);
1812	free(zooRegistry);
1813	}
1814	free (REQUEST);
1815	free (SERVICE_URL);
1816	return errorException (m, _("Unable to allocate memory"),
1817	"InternalError", NULL);
1818	}
1819
1820	r_inputs = getMap (request_inputs, "Identifier");
1821
1822	map* import = getMapFromMaps (m, IMPORTSERVICE, r_inputs->value);
1823	if (import != NULL && import->value != NULL) {
1824	strncpy(tmps1, import->value, 1024);
1825	setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
1826	setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
1827	}
1828	else {
1829	snprintf (tmps1, 1024, "%s/%s.zcfg", conf_dir, r_inputs->value);
1830	#ifdef DEBUG
1831	fprintf (stderr, "Trying to load %s\n", tmps1);
1832	#endif
1833	if (strstr (r_inputs->value, ".") != NULL)
1834	{
1835	char *identifier = zStrdup (r_inputs->value);
1836	parseIdentifier (m, conf_dir, identifier, tmps1);
1837	map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
1838	if (tmpMap != NULL)
1839	addToMap (request_inputs, "metapath", tmpMap->value);
1840	free (identifier);
1841	}
1842	else
1843	{
1844	setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
1845	setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
1846	}
1847	}
1848
1849	r_inputs = getMapFromMaps (m, "lenv", "Identifier");
1850	int saved_stdout = dup (fileno (stdout));
1851	dup2 (fileno (stderr), fileno (stdout));
1852	t = readServiceFile (m, tmps1, &s1, r_inputs->value);
1853	inheritance(zooRegistry,&s1);
1854	if(zooRegistry!=NULL){
1855	freeRegistry(&zooRegistry);
1856	free(zooRegistry);
1857	}
1858	fflush (stdout);
1859	dup2 (saved_stdout, fileno (stdout));
1860	if (t < 0)
1861	{
1862	char tmpMsg = (char ) malloc (2048 + strlen (r_inputs->value));
1863	sprintf (tmpMsg,
1864	_
1865	("The value for <identifier> seems to be wrong (%s). Please specify one of the processes in the list returned by a GetCapabilities request."),
1866	r_inputs->value);
1867	errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
1868	free (tmpMsg);
1869	free (s1);
1870	freeMaps (&m);
1871	free (m);
1872	free (REQUEST);
1873	free (SERVICE_URL);
1874	return 0;
1875	}
1876	close (saved_stdout);
1877
1878	#ifdef DEBUG
1879	dumpService (s1);
1880	#endif
1881	int j;
1882
1883
1884	/**
1885	* Create the input and output maps data structure
1886	*/
1887	int i = 0;
1888	HINTERNET hInternet;
1889	HINTERNET res;
1890	hInternet = InternetOpen (
1891	#ifndef WIN32
1892	(LPCTSTR)
1893	#endif
1894	"ZooWPSClient\0",
1895	INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1896
1897	#ifndef WIN32
1898	if (!CHECK_INET_HANDLE (hInternet))
1899	fprintf (stderr, "WARNING : hInternet handle failed to initialize");
1900	#endif
1901	maps *request_input_real_format = NULL;
1902	maps *tmpmaps = request_input_real_format;
1903
1904	if(parseRequest(&m,&request_inputs,s1,&request_input_real_format,&request_output_real_format,&hInternet)<0){
1905	freeMaps (&m);
1906	free (m);
1907	free (REQUEST);
1908	free (SERVICE_URL);
1909	InternetCloseHandle (&hInternet);
1910	freeService (&s1);
1911	free (s1);
1912	return 0;
1913	}
1914
1915	// Define each env variable in runing environment
1916	maps *curs = getMaps (m, "env");
1917	if (curs != NULL)
1918	{
1919	map *mapcs = curs->content;
1920	while (mapcs != NULLMAP)
1921	{
1922	#ifndef WIN32
1923	setenv (mapcs->name, mapcs->value, 1);
1924	#ifdef DEBUG
1925	fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
1926	mapcs->value);
1927	#endif
1928	#else
1929	if (mapcs->value[strlen (mapcs->value) - 2] == '\r')
1930	{
1931	#ifdef DEBUG
1932	fprintf (stderr, "[ZOO: Env var finish with \r]\n");
1933	#endif
1934	mapcs->value[strlen (mapcs->value) - 1] = 0;
1935	}
1936	#ifdef DEBUG
1937	if (SetEnvironmentVariable (mapcs->name, mapcs->value) == 0)
1938	{
1939	fflush (stderr);
1940	fprintf (stderr, "setting variable... %s\n", "OK");
1941	}
1942	else
1943	{
1944	fflush (stderr);
1945	fprintf (stderr, "setting variable... %s\n", "OK");
1946	}
1947	#else
1948	SetEnvironmentVariable (mapcs->name, mapcs->value);
1949	#endif
1950	char *toto =
1951	(char *)
1952	malloc ((strlen (mapcs->name) + strlen (mapcs->value) +
1953	2) * sizeof (char));
1954	sprintf (toto, "%s=%s", mapcs->name, mapcs->value);
1955	putenv (toto);
1956	#ifdef DEBUG
1957	fflush (stderr);
1958	#endif
1959	#endif
1960	#ifdef DEBUG
1961	fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
1962	mapcs->value);
1963	fflush (stderr);
1964	#endif
1965	mapcs = mapcs->next;
1966	}
1967	}
1968
1969	#ifdef DEBUG
1970	dumpMap (request_inputs);
1971	#endif
1972
1973	map *status = getMap (request_inputs, "status");
1974	if(vid==0){
1975	// Need to check if we need to fork to load a status enabled
1976	r_inputs = NULL;
1977	map *store = getMap (request_inputs, "storeExecuteResponse");
1978	/**
1979	* 05-007r7 WPS 1.0.0 page 57 :
1980	* 'If status="true" and storeExecuteResponse is "false" then the service
1981	* shall raise an exception.'
1982	*/
1983	if (status != NULL && strcmp (status->value, "true") == 0 &&
1984	store != NULL && strcmp (store->value, "false") == 0)
1985	{
1986	errorException (m,
1987	_
1988	("The status parameter cannot be set to true if storeExecuteResponse is set to false. Please modify your request parameters."),
1989	"InvalidParameterValue", "storeExecuteResponse");
1990	freeService (&s1);
1991	free (s1);
1992	freeMaps (&m);
1993	free (m);
1994
1995	freeMaps (&request_input_real_format);
1996	free (request_input_real_format);
1997
1998	freeMaps (&request_output_real_format);
1999	free (request_output_real_format);
2000
2001	free (REQUEST);
2002	free (SERVICE_URL);
2003	return 1;
2004	}
2005	r_inputs = getMap (request_inputs, "storeExecuteResponse");
2006	}else{
2007	// Define status depending on the WPS 2.0.0 mode attribute
2008	status = getMap (request_inputs, "mode");
2009	map* mode=getMap(s1->content,"mode");
2010	if(strcasecmp(status->value,"async")==0){
2011	if(mode!=NULL && strcasecmp(mode->value,"async")==0)
2012	addToMap(request_inputs,"status","true");
2013	else{
2014	if(mode!=NULL){
2015	// see ref. http://docs.opengeospatial.org/is/14-065/14-065.html#61
2016	errorException (m,_("The process does not permit the desired execution mode."),"NoSuchMode", mode->value);
2017	fflush (stdout);
2018	freeMaps (&m);
2019	free (m);
2020	if(zooRegistry!=NULL){
2021	freeRegistry(&zooRegistry);
2022	free(zooRegistry);
2023	}
2024	freeMaps (&request_input_real_format);
2025	free (request_input_real_format);
2026	freeMaps (&request_output_real_format);
2027	free (request_output_real_format);
2028	free (REQUEST);
2029	free (SERVICE_URL);
2030	return 0;
2031	}else
2032	addToMap(request_inputs,"status","true");
2033	}
2034	}
2035	else{
2036	if(strcasecmp(status->value,"auto")==0){
2037	if(mode!=NULL){
2038	if(strcasecmp(mode->value,"async")==0)
2039	addToMap(request_inputs,"status","false");
2040	else
2041	addToMap(request_inputs,"status","true");
2042	}
2043	else
2044	addToMap(request_inputs,"status","false");
2045	}else
2046	addToMap(request_inputs,"status","false");
2047	}
2048	status = getMap (request_inputs, "status");
2049	}
2050
2051	int eres = SERVICE_STARTED;
2052	int cpid = getpid ();
2053
2054	/**
2055	* Initialize the specific [lenv] section which contains runtime variables:
2056	*
2057	* - usid : it is an universally unique identifier
2058	* - osid : it is an idenfitication number
2059	* - sid : it is the process idenfitication number (OS)
2060	* - uusid : it is an universally unique identifier
2061	* - status : value between 0 and 100 to express the completude of
2062	* the operations of the running service
2063	* - message : is a string where you can store error messages, in case
2064	* service is failing, or o provide details on the ongoing operation.
2065	* - cwd : the current working directory or servicePath if defined
2066	* - soap : is a boolean value, true if the request was contained in a SOAP
2067	* Envelop
2068	* - sessid : string storing the session identifier (only when cookie is
2069	* used)
2070	* - cgiSid : only defined on Window platforms (for being able to identify
2071	* the created process)
2072	*
2073	*/
2074	maps *_tmpMaps = createMaps("lenv");
2075	char tmpBuff[100];
2076	struct ztimeval tp;
2077	if (zGettimeofday (&tp, NULL) == 0)
2078	sprintf (tmpBuff, "%i", (cpid + ((int) tp.tv_sec + (int) tp.tv_usec)));
2079	else
2080	sprintf (tmpBuff, "%i", (cpid + (int) time (NULL)));
2081	_tmpMaps->content = createMap ("osid", tmpBuff);
2082	sprintf (tmpBuff, "%i", cpid);
2083	addToMap (_tmpMaps->content, "sid", tmpBuff);
2084	char* tmpUuid=get_uuid();
2085	addToMap (_tmpMaps->content, "uusid", tmpUuid);
2086	addToMap (_tmpMaps->content, "usid", tmpUuid);
2087	free(tmpUuid);
2088	addToMap (_tmpMaps->content, "status", "0");
2089	if(cwdMap0!=NULL){
2090	addToMap (_tmpMaps->content, "cwd", cwdMap0->value);
2091	addToMap (_tmpMaps->content, "rcwd", ntmp);
2092	}
2093	else
2094	addToMap (_tmpMaps->content, "cwd", ntmp);
2095	addToMap (_tmpMaps->content, "message", _("No message provided"));
2096	map *ltmp = getMap (request_inputs, "soap");
2097	if (ltmp != NULL)
2098	addToMap (_tmpMaps->content, "soap", ltmp->value);
2099	else
2100	addToMap (_tmpMaps->content, "soap", "false");
2101
2102	// Parse the session file and add it to the main maps
2103	if (cgiCookie != NULL && strlen (cgiCookie) > 0)
2104	{
2105	int hasValidCookie = -1;
2106	char *tcook = zStrdup (cgiCookie);
2107	char *tmp = NULL;
2108	map *testing = getMapFromMaps (m, "main", "cookiePrefix");
2109	if (testing == NULL)
2110	{
2111	tmp = zStrdup ("ID=");
2112	}
2113	else
2114	{
2115	tmp =
2116	(char ) malloc ((strlen (testing->value) + 2) sizeof (char));
2117	sprintf (tmp, "%s=", testing->value);
2118	}
2119	if (strstr (cgiCookie, ";") != NULL)
2120	{
2121	char token, saveptr;
2122	token = strtok_r (cgiCookie, ";", &saveptr);
2123	while (token != NULL)
2124	{
2125	if (strcasestr (token, tmp) != NULL)
2126	{
2127	if (tcook != NULL)
2128	free (tcook);
2129	tcook = zStrdup (token);
2130	hasValidCookie = 1;
2131	}
2132	token = strtok_r (NULL, ";", &saveptr);
2133	}
2134	}
2135	else
2136	{
2137	if (strstr (cgiCookie, "=") != NULL
2138	&& strcasestr (cgiCookie, tmp) != NULL)
2139	{
2140	tcook = zStrdup (cgiCookie);
2141	hasValidCookie = 1;
2142	}
2143	if (tmp != NULL)
2144	{
2145	free (tmp);
2146	}
2147	}
2148	if (hasValidCookie > 0)
2149	{
2150	addToMap (_tmpMaps->content, "sessid", strstr (tcook, "=") + 1);
2151	char session_file_path[1024];
2152	map *tmpPath = getMapFromMaps (m, "main", "sessPath");
2153	if (tmpPath == NULL)
2154	tmpPath = getMapFromMaps (m, "main", "tmpPath");
2155	char *tmp1 = strtok (tcook, ";");
2156	if (tmp1 != NULL)
2157	sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
2158	strstr (tmp1, "=") + 1);
2159	else
2160	sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
2161	strstr (cgiCookie, "=") + 1);
2162	free (tcook);
2163	maps tmpSess = (maps ) malloc (MAPS_SIZE);
2164	tmpSess->child=NULL;
2165	struct stat file_status;
2166	int istat = stat (session_file_path, &file_status);
2167	if (istat == 0 && file_status.st_size > 0)
2168	{
2169	conf_read (session_file_path, tmpSess);
2170	addMapsToMaps (&m, tmpSess);
2171	freeMaps (&tmpSess);
2172	}
2173	free (tmpSess);
2174	}
2175	}
2176	addMapsToMaps (&m, _tmpMaps);
2177	freeMaps (&_tmpMaps);
2178	free (_tmpMaps);
2179	maps* bmap=NULL;
2180	#ifdef DEBUG
2181	dumpMap (request_inputs);
2182	#endif
2183	int ei = 1;
2184	char *s =
2185	#ifdef WIN32
2186	GetEnvironmentStrings();
2187	#else
2188	*environ;
2189	#endif
2190	_tmpMaps = createMaps("renv");
2191	for (; s; ei++) {
2192	char* tmpName=zStrdup(s);
2193	char* tmpValue=strstr(s,"=")+1;
2194	tmpName[strlen(tmpName)-strlen(tmpValue)-1]=0;
2195	if(_tmpMaps->content == NULL)
2196	_tmpMaps->content = createMap (tmpName,tmpValue);
2197	else
2198	addToMap (_tmpMaps->content,tmpName,tmpValue);
2199	free(tmpName);
2200	s = *(environ+ei);
2201	}
2202	addMapsToMaps (&m, _tmpMaps);
2203	freeMaps (&_tmpMaps);
2204	free (_tmpMaps);
2205
2206	#ifdef WIN32
2207	char *cgiSidL = NULL;
2208	if (getenv ("CGISID") != NULL)
2209	addToMap (request_inputs, "cgiSid", getenv ("CGISID"));
2210
2211	char* usidp;
2212	if ( (usidp = getenv("USID")) != NULL ) {
2213	setMapInMaps (m, "lenv", "usid", usidp);
2214	}
2215
2216	map *test1 = getMap (request_inputs, "cgiSid");
2217	if (test1 != NULL){
2218	cgiSid = zStrdup(test1->value);
2219	addToMap (request_inputs, "storeExecuteResponse", "true");
2220	addToMap (request_inputs, "status", "true");
2221	setMapInMaps (m, "lenv", "osid", test1->value);
2222	status = getMap (request_inputs, "status");
2223	}
2224	test1 = getMap (request_inputs, "usid");
2225	if (test1 != NULL){
2226	setMapInMaps (m, "lenv", "usid", test1->value);
2227	setMapInMaps (m, "lenv", "uusid", test1->value);
2228	}
2229	#endif
2230
2231	char fbkp, fbkpid, fbkpres, fbkp1, *flog;
2232	FILE f0, f1;
2233	if (status != NULL)
2234	if (strcasecmp (status->value, "false") == 0)
2235	status = NULLMAP;
2236	if (status == NULLMAP)
2237	{
2238	if(validateRequest(&m,s1,request_inputs, &request_input_real_format,&request_output_real_format,&hInternet)<0){
2239	freeService (&s1);
2240	free (s1);
2241	freeMaps (&m);
2242	free (m);
2243	free (REQUEST);
2244	free (SERVICE_URL);
2245	freeMaps (&request_input_real_format);
2246	free (request_input_real_format);
2247	freeMaps (&request_output_real_format);
2248	free (request_output_real_format);
2249	freeMaps (&tmpmaps);
2250	free (tmpmaps);
2251	return -1;
2252	}
2253	loadServiceAndRun (&m, s1, request_inputs, &request_input_real_format,
2254	&request_output_real_format, &eres);
2255	}
2256	else
2257	{
2258	int pid;
2259	#ifdef DEBUG
2260	fprintf (stderr, "\nPID : %d\n", cpid);
2261	#endif
2262
2263	#ifndef WIN32
2264	pid = fork ();
2265	#else
2266	if (cgiSid == NULL)
2267	{
2268	createProcess (m, request_inputs, s1, NULL, cpid,
2269	request_input_real_format,
2270	request_output_real_format);
2271	pid = cpid;
2272	}
2273	else
2274	{
2275	pid = 0;
2276	cpid = atoi (cgiSid);
2277	updateStatus(m,0,_("Initializing"));
2278	}
2279	#endif
2280	if (pid > 0)
2281	{
2282	/**
2283	* dady :
2284	* set status to SERVICE_ACCEPTED
2285	*/
2286	#ifdef DEBUG
2287	fprintf (stderr, "father pid continue (origin %d) %d ...\n", cpid,
2288	getpid ());
2289	#endif
2290	eres = SERVICE_ACCEPTED;
2291	}
2292	else if (pid == 0)
2293	{
2294	/**
2295	* son : have to close the stdout, stdin and stderr to let the parent
2296	* process answer to http client.
2297	*/
2298	map* usid = getMapFromMaps (m, "lenv", "uusid");
2299	map* tmpm = getMapFromMaps (m, "lenv", "osid");
2300	int cpid = atoi (tmpm->value);
2301	r_inputs = getMapFromMaps (m, "main", "tmpPath");
2302	map* r_inputs1 = createMap("ServiceName", s1->name);
2303
2304	// Create the filename for the result file (.res)
2305	fbkpres =
2306	(char *)
2307	malloc ((strlen (r_inputs->value) +
2308	strlen (usid->value) + 7) * sizeof (char));
2309	sprintf (fbkpres, "%s/%s.res", r_inputs->value, usid->value);
2310	bmap = createMaps("status");
2311	bmap->content=createMap("usid",usid->value);
2312	addToMap(bmap->content,"sid",tmpm->value);
2313	addIntToMap(bmap->content,"pid",getpid());
2314
2315	// Create PID file referencing the OS process identifier
2316	fbkpid =
2317	(char *)
2318	malloc ((strlen (r_inputs->value) +
2319	strlen (usid->value) + 7) * sizeof (char));
2320	sprintf (fbkpid, "%s/%s.pid", r_inputs->value, usid->value);
2321	setMapInMaps (m, "lenv", "file.pid", fbkpid);
2322
2323	f0 = freopen (fbkpid, "w+",stdout);
2324	printf("%d",getpid());
2325	fflush(stdout);
2326
2327	// Create SID file referencing the semaphore name
2328	fbkp =
2329	(char *)
2330	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
2331	strlen (usid->value) + 7) * sizeof (char));
2332	sprintf (fbkp, "%s/%s.sid", r_inputs->value, usid->value);
2333	setMapInMaps (m, "lenv", "file.sid", fbkp);
2334	FILE* f2 = freopen (fbkp, "w+",stdout);
2335	printf("%s",tmpm->value);
2336	fflush(f2);
2337	free(fbkp);
2338
2339	fbkp =
2340	(char *)
2341	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
2342	strlen (usid->value) + 7) * sizeof (char));
2343	sprintf (fbkp, "%s/%s_%s.xml", r_inputs->value, r_inputs1->value,
2344	usid->value);
2345	setMapInMaps (m, "lenv", "file.responseInit", fbkp);
2346	flog =
2347	(char *)
2348	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
2349	strlen (usid->value) + 13) * sizeof (char));
2350	sprintf (flog, "%s/%s_%s_error.log", r_inputs->value,
2351	r_inputs1->value, usid->value);
2352	setMapInMaps (m, "lenv", "file.log", flog);
2353	#ifdef DEBUG
2354	fprintf (stderr, "RUN IN BACKGROUND MODE \n");
2355	fprintf (stderr, "son pid continue (origin %d) %d ...\n", cpid,
2356	getpid ());
2357	fprintf (stderr, "\nFILE TO STORE DATA %s\n", r_inputs->value);
2358	#endif
2359	freopen (flog, "w+", stderr);
2360	fflush (stderr);
2361	f0 = freopen (fbkp, "w+", stdout);
2362	rewind (stdout);
2363	#ifndef WIN32
2364	fclose (stdin);
2365	#endif
2366	#ifdef RELY_ON_DB
2367	init_sql(m);
2368	recordServiceStatus(m);
2369	#endif
2370	if(vid==0){
2371	/**
2372	* set status to SERVICE_STARTED and flush stdout to ensure full
2373	* content was outputed (the file used to store the ResponseDocument).
2374	* The rewind stdout to restart writing from the bgining of the file,
2375	* this way the data will be updated at the end of the process run.
2376	*/
2377	printProcessResponse (m, request_inputs, cpid, s1, r_inputs1->value,
2378	SERVICE_STARTED, request_input_real_format,
2379	request_output_real_format);
2380	fflush (stdout);
2381	#ifdef RELY_ON_DB
2382	recordResponse(m,fbkp);
2383	#endif
2384	}
2385
2386	fflush (stderr);
2387
2388	fbkp1 =
2389	(char *)
2390	malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
2391	strlen (usid->value) + 13) * sizeof (char));
2392	sprintf (fbkp1, "%s/%s_final_%s.xml", r_inputs->value,
2393	r_inputs1->value, usid->value);
2394	setMapInMaps (m, "lenv", "file.responseFinal", fbkp1);
2395
2396	f1 = freopen (fbkp1, "w+", stdout);
2397
2398	if(validateRequest(&m,s1,request_inputs, &request_input_real_format,&request_output_real_format,&hInternet)<0){
2399	freeService (&s1);
2400	free (s1);
2401	fclose (f0);
2402	fclose (f1);
2403	if(dumpBackFinalFile(m,fbkp,fbkp1)<0)
2404	return -1;
2405	unlink (fbkpid);
2406	unhandleStatus (m);
2407	freeMaps (&m);
2408	free (m);
2409	free (REQUEST);
2410	free (SERVICE_URL);
2411	freeMaps (&request_input_real_format);
2412	free (request_input_real_format);
2413	freeMaps (&request_output_real_format);
2414	free (request_output_real_format);
2415	freeMaps (&tmpmaps);
2416	free (tmpmaps);
2417	fflush (stdout);
2418	fflush (stderr);
2419	return -1;
2420	}
2421	loadServiceAndRun (&m, s1, request_inputs,
2422	&request_input_real_format,
2423	&request_output_real_format, &eres);
2424	}
2425	else
2426	{
2427	/**
2428	* error server don't accept the process need to output a valid
2429	* error response here !!!
2430	*/
2431	eres = -1;
2432	errorException (m, _("Unable to run the child process properly"),
2433	"InternalError", NULL);
2434	}
2435	}
2436
2437	//#ifdef DEBUG
2438	dumpMaps (request_output_real_format);
2439	//#endif
2440	//sleep(120);
2441	if (eres != -1)
2442	outputResponse (s1, request_input_real_format,
2443	request_output_real_format, request_inputs,
2444	cpid, m, eres);
2445	fflush (stdout);
2446
2447	/**
2448	* Ensure that if error occurs when freeing memory, no signal will return
2449	* an ExceptionReport document as the result was already returned to the
2450	* client.
2451	*/
2452	#ifndef USE_GDB
2453	signal (SIGSEGV, donothing);
2454	signal (SIGTERM, donothing);
2455	signal (SIGINT, donothing);
2456	signal (SIGILL, donothing);
2457	signal (SIGFPE, donothing);
2458	signal (SIGABRT, donothing);
2459	#endif
2460
2461	if (((int) getpid ()) != cpid \|\| cgiSid != NULL)
2462	{
2463	fclose (stdout);
2464	fclose (stderr);
2465
2466	fclose (f0);
2467	fclose (f1);
2468
2469	if(dumpBackFinalFile(m,fbkp,fbkp1)<0)
2470	return -1;
2471	unlink (fbkpid);
2472	switch(eres){
2473	default:
2474	case SERVICE_FAILED:
2475	setMapInMaps(bmap,"status","status",wpsStatus[1]);
2476	setMapInMaps(m,"lenv","fstate",wpsStatus[1]);
2477	break;
2478	case SERVICE_SUCCEEDED:
2479	setMapInMaps(bmap,"status","status",wpsStatus[0]);
2480	setMapInMaps(m,"lenv","fstate",wpsStatus[0]);
2481	break;
2482	}
2483	#ifndef RELY_ON_DB
2484	dumpMapsToFile(bmap,fbkpres,1);
2485	removeShmLock (m, 1);
2486	#else
2487	recordResponse(m,fbkp1);
2488	#endif
2489	freeMaps(&bmap);
2490	free(bmap);
2491	unlink (fbkp1);
2492	unlink (flog);
2493	unhandleStatus (m);
2494	free(fbkpid);
2495	free(fbkpres);
2496	free (flog);
2497	free (fbkp1);
2498	// free (tmps1); // tmps1 is stack memory and should not be freed
2499	if(cgiSid!=NULL)
2500	free(cgiSid);
2501	}
2502
2503	freeService (&s1);
2504	free (s1);
2505	freeMaps (&m);
2506	free (m);
2507
2508	freeMaps (&request_input_real_format);
2509	free (request_input_real_format);
2510
2511	freeMaps (&request_output_real_format);
2512	free (request_output_real_format);
2513
2514	free (REQUEST);
2515	free (SERVICE_URL);
2516	#ifdef DEBUG
2517	fprintf (stderr, "Processed response \n");
2518	fflush (stdout);
2519	fflush (stderr);
2520	#endif
2521
2522	if (((int) getpid ()) != cpid \|\| cgiSid != NULL)
2523	{
2524	exit (0);
2525	}
2526
2527	return 0;
2528	}

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

Open WPS platform

source: branches/prototype-v0/zoo-project/zoo-kernel/zoo_service_loader.c @ 822

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links