zoo_service_loader.c @ 908

Last change on this file since 908 was 889, checked in by knut, 6 years ago
Added some new logging functionality (function logMessage(), macros zooLog, zooLogMsg). Added utility functions setErrorMessage(), hasvalue(), and nonempty() in service.c. Added enum WPSException and arrays WPSExceptionText and WPSExceptionCode (see also function setErrorMessage). New conditional definition of type bool in service.c (to fix issue with bool). Null pointer check in function addToMap. Added missing return values and explicit type casts in some functions. Removed Windows-specific code in function dumpBackFinalFile (zoo_service_loader.c) that may cause error for async raw data output in formats other than XML.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 67.9 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links