Warning: Can't use blame annotator:
svn blame failed on trunk/zoo-kernel/zoo_service_loader.c: 200029 - Couldn't perform atomic initialization 20014 - Can't find a temporary directory: Internal error

zoo_service_loader.c @ 34

Last change on this file since 34 was 34, checked in by djay, 14 years ago
Make ZOO Kernel able to speak the natural language you teach him by using gettext tools for creating translation files. Add basic french translation .po files as current messages.po. Gettext Domains used are zoo-kernel and zoo-services.
File size: 48.3 KB

Rev	Line
	1	/**
	2	* Author : Gérald FENOY
	3	*
	4	* Copyright 2008-2009 GeoLabs SARL. All rights reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#define length(x) (sizeof(x) / sizeof(x[0]))
	26
	27	extern "C" int yylex();
	28	extern "C" int crlex();
	29
	30
	31	extern "C" {
	32	#include <libxml/tree.h>
	33	#include <libxml/xmlmemory.h>
	34	#include <libxml/parser.h>
	35	#include <libxml/xpath.h>
	36	#include <libxml/xpathInternals.h>
	37	}
	38
	39	#include "cgic.h"
	40	#include "ulinet.h"
	41
	42	#include <libintl.h>
	43	#include <locale.h>
	44	#include <string.h>
	45
	46	#include "service.h"
	47
	48	#include "service_internal.h"
	49
	50	#ifdef USE_PYTHON
	51	#include "service_internal_python.h"
	52	#endif
	53
	54	#ifdef USE_JAVA
	55	#include "service_internal_java.h"
	56	#endif
	57
	58	#ifdef USE_PHP
	59	#include "service_internal_php.h"
	60	#endif
	61
	62	#ifdef USE_JS
	63	#include "service_internal_js.h"
	64	#endif
	65
	66	#ifdef USE_PERL
	67	#include "service_internal_perl.h"
	68	#endif
	69
	70
	71
	72	#include <dirent.h>
	73	#include <signal.h>
	74	#include <unistd.h>
	75	#ifndef WIN32
	76	#include <dlfcn.h>
	77	#include <libgen.h>
	78	#else
	79	#include <windows.h>
	80	#include <direct.h>
	81	#endif
	82	#include <fcntl.h>
	83	#include <time.h>
	84	#include <stdarg.h>
	85
	86	#define _(String) dgettext ("zoo-kernel",String)
	87
	88
	89	void translateChar(char str,char toReplace,char toReplaceBy){
	90	int i=0,len=strlen(str);
	91	for(i=0;i<len;i++){
	92	if(str[i]==toReplace)
	93	str[i]=toReplaceBy;
	94	}
	95	}
	96
	97	xmlXPathObjectPtr extractFromDoc(xmlDocPtr doc,char* search){
	98	xmlXPathContextPtr xpathCtx;
	99	xmlXPathObjectPtr xpathObj;
	100	xpathCtx = xmlXPathNewContext(doc);
	101	xpathObj = xmlXPathEvalExpression(BAD_CAST search,xpathCtx);
	102	xmlXPathFreeContext(xpathCtx);
	103	return xpathObj;
	104	}
	105
	106	void sig_handler(int sig){
	107	char tmp[100];
	108	char *ssig;
	109	switch(sig){
	110	case SIGSEGV:
	111	ssig="SIGSEGV";
	112	break;
	113	case SIGTERM:
	114	ssig="SIGTERM";
	115	break;
	116	case SIGINT:
	117	ssig="SIGINT";
	118	break;
	119	case SIGILL:
	120	ssig="SIGILL";
	121	break;
	122	case SIGFPE:
	123	ssig="SIGFPE";
	124	break;
	125	case SIGABRT:
	126	ssig="SIGABRT";
	127	break;
	128	default:
	129	ssig="UNKNOWN";
	130	break;
	131	}
	132	sprintf(tmp,_("ZOO Kernel failed to process your request receiving signal %d = %s"),sig,ssig);
	133	errorException(NULL, tmp, "InternalError");
	134	#ifdef DEBUG
	135	fprintf(stderr,"Not this time!\n");
	136	#endif
	137	exit(0);
	138	}
	139
	140	void loadServiceAndRun(maps myMap,service s1,map* request_inputs,maps inputs,maps ioutputs,int* eres){
	141	char tmps1[1024];
	142	char ntmp[1024];
	143	maps m=myMap;
	144	maps request_output_real_format=ioutputs;
	145	maps request_input_real_format=inputs;
	146	/**
	147	* Extract serviceType to know what kind of service should be loaded
	148	*/
	149	map* r_inputs=NULL;
	150	#ifndef WIN32
	151	getcwd(ntmp,1024);
	152	#else
	153	_getcwd(ntmp,1024);
	154	#endif
	155	r_inputs=getMap(s1->content,"serviceType");
	156	#ifdef DEBUG
	157	fprintf(stderr,"LOAD A %s SERVICE PROVIDER \n",r_inputs->value);
	158	fflush(stderr);
	159	#endif
	160	if(strncasecmp(r_inputs->value,"C",1)==0){
	161	r_inputs=getMap(request_inputs,"metapath");
	162	if(r_inputs!=NULL)
	163	sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
	164	else
	165	sprintf(tmps1,"%s/",ntmp);
	166	char *altPath=strdup(tmps1);
	167	r_inputs=getMap(s1->content,"ServiceProvider");
	168	sprintf(tmps1,"%s/%s",altPath,r_inputs->value);
	169	free(altPath);
	170	#ifdef DEBUG
	171	fprintf(stderr,"Trying to load %s\n",tmps1);
	172	#endif
	173	#ifdef WIN32
	174	HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
	175	#else
	176	void* so = dlopen(tmps1, RTLD_LAZY);
	177	#endif
	178	#ifdef DEBUG
	179	#ifdef WIN32<
	180	DWORD errstr;
	181	errstr = GetLastError();
	182	fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
	183	#else
	184	char *errstr;
	185	errstr = dlerror();
	186	#endif
	187	#endif
	188
	189	if( so != NULL ) {
	190	#ifdef DEBUG
	191	fprintf(stderr,"Library loaded %s \n",errstr);
	192	fprintf(stderr,"Service Shared Object = %s\n",r_inputs->value);
	193	#endif
	194	r_inputs=getMap(s1->content,"serviceType");
	195	#ifdef DEBUG
	196	dumpMap(r_inputs);
	197	fprintf(stderr,"%s\n",r_inputs->value);
	198	fflush(stderr);
	199	#endif
	200	if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
	201	#ifdef WIN32
	202	//Strange return value needed here !
	203	return 1;
	204	#endif
	205	r_inputs=getMap(request_inputs,"Identifier");
	206	char fname[1024];
	207	sprintf(fname,"%s_",r_inputs->value);
	208	#ifdef DEBUG
	209	fprintf(stderr,"Try to load function %s\n",fname);
	210	#endif
	211	#ifdef WIN32
	212	typedef int (CALLBACK* execute_t)(char*,char,char**);
	213	execute_t execute=(execute_t)GetProcAddress(so,fname);
	214	#else
	215	typedef int (execute_t)(char,char,char**);
	216	execute_t execute=(execute_t)dlsym(so,fname);
	217	#endif
	218	#ifdef DEBUG
	219	#ifdef WIN32
	220	errstr = GetLastError();
	221	#else
	222	errstr = dlerror();
	223	#endif
	224	fprintf(stderr,"Function loaded %s\n",errstr);
	225	#endif
	226
	227	char main_conf[10][30][1024];
	228	char inputs[10][30][1024];
	229	char outputs[10][30][1024];
	230	for(int i=0;i<10;i++){
	231	for(int j=0;j<30;j++){
	232	memset(main_conf[i][j],0,1024);
	233	memset(inputs[i][j],0,1024);
	234	memset(outputs[i][j],0,1024);
	235	}
	236	}
	237	mapsToCharXXX(m,(char***)main_conf);
	238	mapsToCharXXX(request_input_real_format,(char***)inputs);
	239	mapsToCharXXX(request_output_real_format,(char***)outputs);
	240	eres=execute((char)&main_conf[0],(char)&inputs[0],(char**)&outputs[0]);
	241	#ifdef DEBUG
	242	fprintf(stderr,"Function run successfully \n");
	243	#endif
	244	charxxxToMaps((char***)&outputs[0],&request_output_real_format);
	245	}else{
	246	#ifdef DEBUG
	247	#ifdef WIN32
	248	errstr = GetLastError();
	249	fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
	250	#endif
	251	#endif
	252	r_inputs=getMap(request_inputs,"Identifier");
	253	#ifdef DEBUG
	254	fprintf(stderr,"Try to load function %s\n",r_inputs->value);
	255	#endif
	256	typedef int (execute_t)(maps,maps,maps*);
	257	#ifdef WIN32
	258	execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value);
	259	#else
	260	execute_t execute=(execute_t)dlsym(so,r_inputs->value);
	261	#endif
	262
	263	#ifdef DEBUG
	264	#ifdef WIN32
	265	errstr = GetLastError();
	266	#else
	267	errstr = dlerror();
	268	#endif
	269	fprintf(stderr,"Function loaded %s\n",errstr);
	270	#endif
	271
	272	#ifdef DEBUG
	273	fprintf(stderr,"Now run the function \n");
	274	fflush(stderr);
	275	#endif
	276	*eres=execute(&m,&request_input_real_format,&request_output_real_format);
	277	#ifdef DEBUG
	278	fprintf(stderr,"Function loaded and returned %d\n",eres);
	279	fflush(stderr);
	280	#endif
	281	}
	282	dlclose(so);
	283	} else {
	284	/**
	285	* Unable to load the specified shared library
	286	*/
	287	char tmps[1024];
	288	#ifdef WIN32
	289	DWORD errstr = GetLastError();
	290	#else
	291	char* errstr = dlerror();
	292	#endif
	293	sprintf(tmps,_("C Library can't be loaded %s \n"),errstr);
	294	map* tmps1=createMap("text",tmps);
	295	printExceptionReportResponse(m,tmps1);
	296	*eres=-1;
	297	}
	298	}
	299	else
	300	#ifdef USE_PYTHON
	301	if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
	302	*eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
	303	}
	304	else
	305	#endif
	306
	307	#ifdef USE_JAVA
	308	if(strncasecmp(r_inputs->value,"JAVA",4)==0){
	309	*eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
	310	}
	311	else
	312	#endif
	313
	314	#ifdef USE_PHP
	315	if(strncasecmp(r_inputs->value,"PHP",3)==0){
	316	*eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
	317	}
	318	else
	319	#endif
	320
	321
	322	#ifdef USE_PERL
	323	if(strncasecmp(r_inputs->value,"PERL",4)==0){
	324	*eres=zoo_perl_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
	325	}
	326	else
	327	#endif
	328
	329	#ifdef USE_JS
	330	if(strncasecmp(r_inputs->value,"JS",2)==0){
	331	*eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
	332	}
	333	else
	334	#endif
	335	{
	336	char tmpv[1024];
	337	sprintf(tmpv,_("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),r_inputs->value);
	338	map* tmps=createMap("text",tmpv);
	339	printExceptionReportResponse(m,tmps);
	340	*eres=-1;
	341	}
	342	*ioutputs=request_output_real_format;
	343	}
	344
	345	int runRequest(map* request_inputs)
	346	{
	347
	348	(void) signal(SIGSEGV,sig_handler);
	349	(void) signal(SIGTERM,sig_handler);
	350	(void) signal(SIGINT,sig_handler);
	351	(void) signal(SIGILL,sig_handler);
	352	(void) signal(SIGFPE,sig_handler);
	353	(void) signal(SIGABRT,sig_handler);
	354
	355	map* r_inputs=NULL,*tmps=NULL;
	356	maps* m=NULL;
	357	int argc=count(request_inputs);
	358
	359	char* REQUEST=NULL;
	360	/**
	361	* Parsing service specfic configuration file
	362	*/
	363	m=(maps*)calloc(1,MAPS_SIZE);
	364	if(m == NULL){
	365	return errorException(m, _("Unable to allocate memory."), "InternalError");
	366	}
	367	char ntmp[1024];
	368	#ifndef WIN32
	369	getcwd(ntmp,1024);
	370	#else
	371	_getcwd(ntmp,1024);
	372	#endif
	373	r_inputs=getMap(request_inputs,"metapath");
	374	if(r_inputs==NULL){
	375	if(request_inputs==NULL)
	376	request_inputs=createMap("metapath","");
	377	else
	378	addToMap(request_inputs,"metapath","");
	379	#ifdef DEBUG
	380	fprintf(stderr,"ADD METAPATH\n");
	381	dumpMap(request_inputs);
	382	#endif
	383	r_inputs=getMap(request_inputs,"metapath");
	384	}
	385	char conf_file[10240];
	386	snprintf(conf_file,10240,"%s/%s/main.cfg",ntmp,r_inputs->value);
	387	conf_read(conf_file,m);
	388	#ifdef DEBUG
	389	fprintf(stderr, "***** BEGIN MAPS\n");
	390	dumpMaps(m);
	391	fprintf(stderr, "***** END MAPS\n");
	392	#endif
	393
	394	bindtextdomain ("zoo-kernel","/usr/share/locale/");
	395	bindtextdomain ("zoo-services","/usr/share/locale/");
	396
	397	if((r_inputs=getMap(request_inputs,"language"))!=NULL){
	398	char *tmp=strdup(r_inputs->value);
	399	translateChar(tmp,'-','_');
	400	setlocale (LC_ALL, tmp);
	401	free(tmp);
	402	setMapInMaps(m,"main","language",r_inputs->value);
	403	}
	404	else{
	405	setlocale (LC_ALL, "en_US");
	406	setMapInMaps(m,"main","language","en-US");
	407	}
	408	setlocale (LC_NUMERIC, "en_US");
	409	bind_textdomain_codeset("zoo-kernel","UTF-8");
	410	textdomain("zoo-kernel");
	411	bind_textdomain_codeset("zoo-services","UTF-8");
	412	textdomain("zoo-services");
	413
	414
	415	/**
	416	* Check for minimum inputs
	417	*/
	418	r_inputs=getMap(request_inputs,"Request");
	419	if(request_inputs==NULL \|\| r_inputs==NULL){
	420	errorException(m, _("Parameter <request> was not specified"),"MissingParameterValue");
	421	freeMaps(&m);
	422	free(m);
	423	return 1;
	424	}
	425	else{
	426	REQUEST=strdup(r_inputs->value);
	427	if(strncasecmp(r_inputs->value,"GetCapabilities",15)!=0
	428	&& strncasecmp(r_inputs->value,"DescribeProcess",15)!=0
	429	&& strncasecmp(r_inputs->value,"Execute",7)!=0){
	430	errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
	431	freeMaps(&m);
	432	free(m);
	433	free(REQUEST);
	434	return 1;
	435	}
	436	}
	437	r_inputs=NULL;
	438	r_inputs=getMap(request_inputs,"Service");
	439	if(r_inputs==NULLMAP){
	440	errorException(m, _("Parameter <service> was not specified"),"MissingParameterValue");
	441	freeMaps(&m);
	442	free(m);
	443	free(REQUEST);
	444	return 1;
	445	}
	446	if(strncasecmp(REQUEST,"GetCapabilities",15)!=0){
	447	r_inputs=getMap(request_inputs,"Version");
	448	if(r_inputs==NULL){
	449	errorException(m, _("Parameter <version> was not specified"),"MissingParameterValue");
	450	freeMaps(&m);
	451	free(m);
	452	free(REQUEST);
	453	return 1;
	454	}
	455	}
	456
	457	r_inputs=getMap(request_inputs,"serviceprovider");
	458	if(r_inputs==NULL){
	459	addToMap(request_inputs,"serviceprovider","");
	460	}
	461
	462	map* outputs=NULL;
	463	maps* request_output_real_format=NULL;
	464	map* tmpm=getMapFromMaps(m,"main","serverAddress");
	465	if(tmpm!=NULL)
	466	SERVICE_URL=strdup(tmpm->value);
	467	else
	468	SERVICE_URL=DEFAULT_SERVICE_URL;
	469
	470	service* s[100];
	471	service* s1;
	472	int scount=0;
	473
	474	#ifdef DEBUG
	475	dumpMap(r_inputs);
	476	#endif
	477	char conf_dir[1024];
	478	int t;
	479	char tmps1[1024];
	480
	481	r_inputs=NULL;
	482	r_inputs=getMap(request_inputs,"metapath");
	483	if(r_inputs!=NULL)
	484	snprintf(conf_dir,1024,"%s/%s",ntmp,r_inputs->value);
	485	else
	486	snprintf(conf_dir,1024,"%s",ntmp);
	487
	488	if(strncasecmp(REQUEST,"GetCapabilities",15)==0){
	489	int i=0;
	490	struct dirent *dp;
	491	#ifdef DEBUG
	492	dumpMap(r_inputs);
	493	#endif
	494	DIR *dirp = opendir(conf_dir);
	495	if(dirp==NULL){
	496	return errorException(m, _("The specified path doesn't exist."),"InvalidParameterValue");
	497	}
	498	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
	499	r_inputs=NULL;
	500	r_inputs=getMap(request_inputs,"ServiceProvider");
	501	xmlNodePtr n;
	502	//dumpMap(request_inputs);
	503	if(r_inputs!=NULL)
	504	n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
	505	else
	506	n = printGetCapabilitiesHeader(doc,"",m);
	507	/**
	508	* Strange, here we need to close stdout to ensure that no uneeded
	509	* char will be printed (parser issue ?)
	510	*/
	511	int saved_stdout = dup(fileno(stdout));
	512	dup2(fileno(stderr),fileno(stdout));
	513	while ((dp = readdir(dirp)) != NULL)
	514	if(strstr(dp->d_name,".zcfg")!=0){
	515	memset(tmps1,0,1024);
	516	snprintf(tmps1,1024,"%s/%s",conf_dir,dp->d_name);
	517	s1=(service*)calloc(1,SERVICE_SIZE);
	518	if(s1 == NULL){
	519	return errorException(m, _("Unable to allocate memory."),"InternalError");
	520	}
	521	#ifdef DEBUG
	522	fprintf(stderr,"#################\n%s\n#################\n",tmps1);
	523	#endif
	524	t=getServiceFromFile(tmps1,&s1);
	525	#ifdef DEBUG
	526	dumpService(s1);
	527	fflush(stdout);
	528	fflush(stderr);
	529	#endif
	530	printGetCapabilitiesForProcess(m,n,s1);
	531	freeService(&s1);
	532	free(s1);
	533	scount++;
	534	}
	535	(void)closedir(dirp);
	536	fflush(stdout);
	537	dup2(saved_stdout,fileno(stdout));
	538	printDocument(m,doc,getpid());
	539	freeMaps(&m);
	540	free(m);
	541	free(REQUEST);
	542	free(SERVICE_URL);
	543	fflush(stdout);
	544	return 0;
	545	}
	546	else{
	547	r_inputs=getMap(request_inputs,"Identifier");
	548	if(r_inputs==NULL
	549	\|\| strlen(r_inputs->name)==0 \|\| strlen(r_inputs->value)==0){
	550	errorException(m, _("Mandatory <identifier> was not specified"),"MissingParameterValue");
	551	freeMaps(&m);
	552	free(m);
	553	free(REQUEST);
	554	free(SERVICE_URL);
	555	return 0;
	556	}
	557
	558	struct dirent *dp;
	559	DIR *dirp = opendir(conf_dir);
	560	if(dirp==NULL){
	561	errorException(m, _("The specified path path doesn't exist."),"InvalidParameterValue");
	562	freeMaps(&m);
	563	free(m);
	564	free(REQUEST);
	565	free(SERVICE_URL);
	566	return 0;
	567	}
	568	if(strncasecmp(REQUEST,"DescribeProcess",15)==0){
	569	/**
	570	* Loop over Identifier list
	571	*/
	572	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
	573	r_inputs=NULL;
	574	r_inputs=getMap(request_inputs,"ServiceProvider");
	575
	576	xmlNodePtr n;
	577	if(r_inputs!=NULL)
	578	n = printDescribeProcessHeader(doc,r_inputs->value,m);
	579	else
	580	n = printDescribeProcessHeader(doc,"",m);
	581
	582	r_inputs=getMap(request_inputs,"Identifier");
	583	char *tmps=strtok(r_inputs->value,",");
	584
	585	char buff[256];
	586	char buff1[1024];
	587	int i=0;
	588	int j=0;
	589	int end=-1;
	590	int saved_stdout = dup(fileno(stdout));
	591	dup2(fileno(stderr),fileno(stdout));
	592	while(tmps){
	593	memset(buff,0,256);
	594	snprintf(buff,256,"%s.zcfg",tmps);
	595	memset(buff1,0,1024);
	596	#ifdef DEBUG
	597	fprintf(stderr,"\n#######%s\n########\n",buff1);
	598	#endif
	599	while ((dp = readdir(dirp)) != NULL)
	600	if(strcmp(dp->d_name,buff)==0){
	601	memset(buff1,0,1024);
	602	snprintf(buff1,1024,"%s/%s",conf_dir,dp->d_name);
	603	//s1=(service)malloc(sizeof(service));
	604	s1=(service*)calloc(1,SERVICE_SIZE);
	605	if(s1 == NULL){
	606	return errorException(m, _("Unable to allocate memory."),"InternalError");
	607	}
	608	#ifdef DEBUG
	609	fprintf(stderr,"#################\n%s\n#################\n",buff1);
	610	#endif
	611	t=getServiceFromFile(buff1,&s1);
	612	#ifdef DEBUG
	613	dumpService(s1);
	614	#endif
	615	printDescribeProcessForProcess(m,n,s1,1);
	616	freeService(&s1);
	617	free(s1);
	618	scount++;
	619	}
	620	rewinddir(dirp);
	621	tmps=strtok(NULL,",");
	622	}
	623	closedir(dirp);
	624	fflush(stdout);
	625	dup2(saved_stdout,fileno(stdout));
	626	printDocument(m,doc,getpid());
	627	freeMaps(&m);
	628	free(m);
	629	free(REQUEST);
	630	free(SERVICE_URL);
	631	fflush(stdout);
	632	//xmlFree(n);
	633	#ifndef LINUX_FREE_ISSUE
	634	if(s1)
	635	free(s1);
	636	#endif
	637	return 0;
	638	}
	639	else
	640	if(strncasecmp(REQUEST,"Execute",strlen(REQUEST))!=0){
	641	errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
	642	#ifdef DEBUG
	643	fprintf(stderr,"No request found %s",REQUEST);
	644	#endif
	645	closedir(dirp);
	646	free(s);
	647	return 0;
	648	}
	649	closedir(dirp);
	650	}
	651
	652	s1=NULL;
	653	s1=(service*)calloc(1,SERVICE_SIZE);
	654	if(s1 == NULL){
	655	freeMaps(&m);
	656	free(m);
	657	free(REQUEST);
	658	free(SERVICE_URL);
	659	return errorException(m, _("Unable to allocate memory."),"InternalError");
	660	}
	661	r_inputs=getMap(request_inputs,"MetaPath");
	662	if(r_inputs!=NULL)
	663	snprintf(tmps1,1024,"%s/%s",ntmp,r_inputs->value);
	664	else
	665	snprintf(tmps1,1024,"%s/",ntmp);
	666	r_inputs=getMap(request_inputs,"Identifier");
	667	char *ttmp=strdup(tmps1);
	668	snprintf(tmps1,1024,"%s/%s.zcfg",ttmp,r_inputs->value);
	669	free(ttmp);
	670	#ifdef DEBUG
	671	fprintf(stderr,"Trying to load %s\n", tmps1);
	672	#endif
	673	int saved_stdout = dup(fileno(stdout));
	674	dup2(fileno(stderr),fileno(stdout));
	675	t=getServiceFromFile(tmps1,&s1);
	676	fflush(stdout);
	677	dup2(saved_stdout,fileno(stdout));
	678	if(t<0){
	679	char tmpMsg[2048+strlen(r_inputs->value)];
	680	sprintf(tmpMsg,_("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),r_inputs->value);
	681	errorException(m, tmpMsg, "InvalidParameterValue");
	682	freeService(&s1);
	683	free(s1);
	684	freeMaps(&m);
	685	free(m);
	686	free(REQUEST);
	687	free(SERVICE_URL);
	688	return 0;
	689	}
	690	close(saved_stdout);
	691
	692	#ifdef DEBUG
	693	dumpService(s1);
	694	#endif
	695	map* inputs=NULL;
	696	elements* c_inputs=s1->inputs;
	697	int j;
	698
	699	/**
	700	* Create the input maps data structure
	701	*/
	702	int i=0;
	703	HINTERNET hInternet;
	704	HINTERNET res;
	705	hInternet=InternetOpen(
	706	#ifndef WIN32
	707	(LPCTSTR)
	708	#endif
	709	"ZooWPSClient\0",
	710	INTERNET_OPEN_TYPE_PRECONFIG,
	711	NULL,NULL, 0);
	712
	713	#ifndef WIN32
	714	if(!CHECK_INET_HANDLE(hInternet))
	715	fprintf(stderr,"WARNING : hInternet handle failed to initialize");
	716	#endif
	717	maps* request_input_real_format=NULL;
	718	maps* tmpmaps = request_input_real_format;
	719	map* postRequest=NULL;
	720	postRequest=getMap(request_inputs,"xrequest");
	721	if(postRequest==NULLMAP){
	722	/**
	723	* Parsing outputs provided as KVP
	724	*/
	725	r_inputs=NULL;
	726	#ifdef DEBUG
	727	fprintf(stderr,"OUTPUT Parsing ... \n");
	728	#endif
	729	r_inputs=getMap(request_inputs,"ResponseDocument");
	730	if(r_inputs==NULL) r_inputs=getMap(request_inputs,"RawDataOutput");
	731
	732	#ifdef DEBUG
	733	fprintf(stderr,"OUTPUT Parsing ... \n");
	734	#endif
	735	if(r_inputs!=NULL){
	736	#ifdef DEBUG
	737	fprintf(stderr,"OUTPUT Parsing start now ... \n");
	738	#endif
	739	char current_output_as_string[10240];
	740	char cursor_output[10240];
	741	char *cotmp=strdup(r_inputs->value);
	742	snprintf(cursor_output,10240,"%s",cotmp);
	743	free(cotmp);
	744	j=0;
	745	map* request_kvp_outputs=NULL;
	746
	747	/**
	748	* Put each Output into the outputs_as_text array
	749	*/
	750	char * pToken;
	751	maps* tmp_output=NULL;
	752	#ifdef DEBUG
	753	fprintf(stderr,"OUTPUT [%s]\n",cursor_output);
	754	#endif
	755	pToken=strtok(cursor_output,";");
	756	char outputs_as_text=(char)calloc(128,sizeof(char*));
	757	if(outputs_as_text == NULL) {
	758	return errorException(m, _("Unable to allocate memory"), "InternalError");
	759	}
	760	i=0;
	761	while(pToken!=NULL){
	762	#ifdef DEBUG
	763	fprintf(stderr,"*%s*\n",pToken);
	764	fflush(stderr);
	765	fprintf(stderr,"*%s*\n",pToken);
	766	#endif
	767	outputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
	768	if(outputs_as_text[i] == NULL) {
	769	return errorException(m, _("Unable to allocate memory"), "InternalError");
	770	}
	771	snprintf(outputs_as_text[i],strlen(pToken)+1,"%s",pToken);
	772	pToken = strtok(NULL,";");
	773	i++;
	774	}
	775	for(j=0;j<i;j++){
	776	char *tmp=strdup(outputs_as_text[j]);
	777	free(outputs_as_text[j]);
	778	char *tmpc;
	779	tmpc=strtok(tmp,"@");
	780	int k=0;
	781	while(tmpc!=NULL){
	782	if(k==0){
	783	if(tmp_output==NULL){
	784	tmp_output=(maps*)calloc(1,MAPS_SIZE);
	785	if(tmp_output == NULL){
	786	return errorException(m, _("Unable to allocate memory."), "InternalError");
	787	}
	788	tmp_output->name=strdup(tmpc);
	789	tmp_output->content=NULL;
	790	tmp_output->next=NULL;
	791	}
	792	}
	793	else{
	794	char *tmpv=strstr(tmpc,"=");
	795	char tmpn[256];
	796	memset(tmpn,0,256);
	797	strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
	798	tmpn[strlen(tmpc)-strlen(tmpv)]=0;
	799	#ifdef DEBUG
	800	fprintf(stderr,"OUTPUT DEF [%s]=[%s]\n",tmpn,tmpv+1);
	801	#endif
	802	if(tmp_output->content==NULL){
	803	tmp_output->content=createMap(tmpn,tmpv+1);
	804	tmp_output->content->next=NULL;
	805	}
	806	else
	807	addToMap(tmp_output->content,tmpn,tmpv+1);
	808	}
	809	k++;
	810	#ifdef DEBUG
	811	fprintf(stderr,"*%s*\n",tmpc);
	812	#endif
	813	tmpc=strtok(NULL,"@");
	814	}
	815	if(request_output_real_format==NULL)
	816	request_output_real_format=dupMaps(&tmp_output);
	817	else
	818	addMapsToMaps(&request_output_real_format,tmp_output);
	819	freeMaps(&tmp_output);
	820	free(tmp_output);
	821	tmp_output=NULL;
	822	#ifdef DEBUG
	823	dumpMaps(tmp_output);
	824	fflush(stderr);
	825	#endif
	826	//tmp_output=tmp_output->next;
	827	free(tmp);
	828	}
	829	free(outputs_as_text);
	830	}
	831
	832
	833	/**
	834	* Parsing inputs provided as KVP
	835	*/
	836	r_inputs=getMap(request_inputs,"DataInputs");
	837	#ifdef DEBUG
	838	fprintf(stderr,"DATA INPUTS [%s]\n",r_inputs->value);
	839	#endif
	840	char current_input_as_string[40960];
	841	char cursor_input[40960];
	842	if(r_inputs!=NULL)
	843	snprintf(cursor_input,40960,"%s",r_inputs->value);
	844	else{
	845	errorException(m, _("Parameter <DataInputs> was not specified"),"MissingParameterValue");
	846	freeMaps(&m);
	847	free(m);
	848	free(REQUEST);
	849	free(SERVICE_URL);
	850	return 0;
	851	}
	852	j=0;
	853	map* request_kvp_inputs=NULL;
	854
	855	/**
	856	* Put each DataInputs into the inputs_as_text array
	857	*/
	858	char * pToken;
	859	pToken=strtok(cursor_input,";");
	860	char inputs_as_text=(char)calloc(100,sizeof(char*));
	861	if(inputs_as_text == NULL){
	862	return errorException(m, _("Unable to allocate memory."), "InternalError");
	863	}
	864	i=0;
	865	while(pToken!=NULL){
	866	#ifdef DEBUG
	867	fprintf(stderr,"*%s*\n",pToken);
	868	#endif
	869	fflush(stderr);
	870	#ifdef DEBUG
	871	fprintf(stderr,"*%s*\n",pToken);
	872	#endif
	873	inputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
	874	snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
	875	if(inputs_as_text[i] == NULL){
	876	return errorException(m, _("Unable to allocate memory."), "InternalError");
	877	}
	878	pToken = strtok(NULL,";");
	879	i++;
	880	}
	881
	882	for(j=0;j<i;j++){
	883	char *tmp=strdup(inputs_as_text[j]);
	884	free(inputs_as_text[j]);
	885	char *tmpc;
	886	tmpc=strtok(tmp,"@");
	887	while(tmpc!=NULL){
	888	#ifdef DEBUG
	889	fprintf(stderr,"*\n%s**\n",tmpc);
	890	#endif
	891	char *tmpv=strstr(tmpc,"=");
	892	char tmpn[256];
	893	memset(tmpn,0,256);
	894	strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
	895	tmpn[strlen(tmpc)-strlen(tmpv)]=0;
	896	int cnt=0;
	897	#ifdef DEBUG
	898	fprintf(stderr,"*\n* %s = %s ***\n",tmpn,tmpv+1);
	899	#endif
	900	if(tmpmaps==NULL){
	901	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	902	if(tmpmaps == NULL){
	903	return errorException(m, _("Unable to allocate memory."), "InternalError");
	904	}
	905	tmpmaps->name=strdup(tmpn);
	906	tmpmaps->content=createMap("value",tmpv+1);
	907	tmpmaps->next=NULL;
	908	}
	909	tmpc=strtok(NULL,"@");
	910	while(tmpc!=NULL){
	911	#ifdef DEBUG
	912	fprintf(stderr,"* KVP NON URL-ENCODED \n%s**\n",tmpc);
	913	#endif
	914	char *tmpv1=strstr(tmpc,"=");
	915	#ifdef DEBUG
	916	fprintf(stderr,"* VALUE NON URL-ENCODED \n%s**\n",tmpv1+1);
	917	#endif
	918	char tmpn1[1024];
	919	memset(tmpn1,0,1024);
	920	strncpy(tmpn1,tmpc,strlen(tmpc)-strlen(tmpv1));
	921	tmpn1[strlen(tmpc)-strlen(tmpv1)]=0;
	922	#ifdef DEBUG
	923	fprintf(stderr,"* NAME NON URL-ENCODED \n%s**\n",tmpn1);
	924	fprintf(stderr,"* VALUE NON URL-ENCODED \n%s**\n",tmpv1+1);
	925	#endif
	926	if(strcmp(tmpn1,"xlink:href")!=0)
	927	addToMap(tmpmaps->content,tmpn1,tmpv1+1);
	928	else{
	929	#ifdef DEBUG
	930	fprintf(stderr,"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",tmpv1+1);
	931	#endif
	932	#ifndef WIN32
	933	if(CHECK_INET_HANDLE(hInternet))
	934	#endif
	935	{
	936	res=InternetOpenUrl(hInternet,tmpv1+1,NULL,0,
	937	INTERNET_FLAG_NO_CACHE_WRITE,0);
	938	#ifdef DEBUG
	939	fprintf(stderr,"(%s) content-length : %d,,res.nDataAlloc %d \n",
	940	tmpv1+1,res.nDataAlloc,res.nDataLen);
	941	#endif
	942	char* tmpContent=(char*)calloc((res.nDataLen+1),sizeof(char));
	943	if(tmpContent == NULL){
	944	return errorException(m, _("Unable to allocate memory."), "InternalError");
	945	}
	946	size_t dwRead;
	947	InternetReadFile(res, (LPVOID)tmpContent,res.nDataLen, &dwRead);
	948	map* tmpMap=getMap(tmpmaps->content,"value");
	949	if(tmpMap!=NULL)
	950	tmpMap->value=strdup(tmpContent);
	951	free(tmpContent);
	952	}
	953	addToMap(tmpmaps->content,tmpn1,tmpv1+1);
	954	}
	955	tmpc=strtok(NULL,"@");
	956	}
	957	#ifdef DEBUG
	958	dumpMaps(tmpmaps);
	959	fflush(stderr);
	960	#endif
	961	if(request_input_real_format==NULL)
	962	request_input_real_format=dupMaps(&tmpmaps);
	963	else
	964	addMapsToMaps(&request_input_real_format,tmpmaps);
	965	/*freeMap(&tmpmaps->content);
	966	free(tmpmaps->content);
	967	tmpmaps->content=NULL;*/
	968	freeMaps(&tmpmaps);
	969	free(tmpmaps);
	970	//}
	971	tmpmaps=NULL;
	972	free(tmp);
	973	}
	974	}
	975	free(inputs_as_text);
	976	}
	977	else {
	978	/**
	979	* Parse XML request
	980	*/
	981	xmlInitParser();
	982	#ifdef DEBUG
	983	fflush(stderr);
	984	fprintf(stderr,"BEFORE %s\n",postRequest->value);
	985	fflush(stderr);
	986	#endif
	987	xmlDocPtr doc =
	988	xmlParseMemory(postRequest->value,cgiContentLength);
	989	#ifdef DEBUG
	990	fprintf(stderr,"AFTER\n");
	991	fflush(stderr);
	992	#endif
	993	xmlNodePtr cur = xmlDocGetRootElement(doc);
	994	/**
	995	* Parse every Input in DataInputs node.
	996	*/
	997	maps* tempMaps=NULL;
	998	xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"///*[local-name()='Input']");
	999	xmlNodeSet* tmps=tmpsptr->nodesetval;
	1000	#ifdef DEBUG
	1001	fprintf(stderr,"***%d***\n",tmps->nodeNr);
	1002	#endif
	1003	for(int k=0;k<tmps->nodeNr;k++){
	1004	maps *tmpmaps=NULL;
	1005	xmlNodePtr cur=tmps->nodeTab[k];
	1006	if(tmps->nodeTab[k]->type == XML_ELEMENT_NODE) {
	1007	/**
	1008	* A specific Input node.
	1009	*/
	1010	#ifdef DEBUG
	1011	fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
	1012	#endif
	1013	xmlNodePtr cur2=cur->children;
	1014	while(cur2!=NULL){
	1015	while(cur2!=NULL && cur2->type!=XML_ELEMENT_NODE)
	1016	cur2=cur2->next;
	1017	if(cur2==NULL)
	1018	break;
	1019	/**
	1020	* Indentifier
	1021	*/
	1022	if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
	1023	xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
	1024	if(tmpmaps==NULL){
	1025	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1026	if(tmpmaps == NULL){
	1027	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1028	}
	1029	tmpmaps->name=strdup((char*)val);
	1030	tmpmaps->content=NULL;
	1031	tmpmaps->next=NULL;
	1032	}
	1033	xmlFree(val);
	1034	}
	1035	/**
	1036	* Title, Asbtract
	1037	*/
	1038	if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 \|\|
	1039	xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
	1040	xmlChar *val=
	1041	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
	1042	if(tmpmaps==NULL){
	1043	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1044	if(tmpmaps == NULL){
	1045	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1046	}
	1047	tmpmaps->name="missingIndetifier";
	1048	tmpmaps->content=createMap((char)cur2->name,(char)val);
	1049	tmpmaps->next=NULL;
	1050	}
	1051	else{
	1052	if(tmpmaps->content!=NULL)
	1053	addToMap(tmpmaps->content,
	1054	(char)cur2->name,(char)val);
	1055	else
	1056	tmpmaps->content=
	1057	createMap((char)cur2->name,(char)val);
	1058	}
	1059	#ifdef DEBUG
	1060	dumpMaps(tmpmaps);
	1061	#endif
	1062	xmlFree(val);
	1063	}
	1064	/**
	1065	* InputDataFormChoice (Reference or Data ?)
	1066	*/
	1067	if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
	1068	/**
	1069	* Get every attribute from a Reference node
	1070	* mimeType, encoding, schema, href, method
	1071	* Header and Body gesture should be added here
	1072	*/
	1073	#ifdef DEBUG
	1074	fprintf(stderr,"REFERENCE\n");
	1075	#endif
	1076	map* referenceMap=NULL;
	1077	char *refs[5];
	1078	refs[0]="mimeType";
	1079	refs[1]="encoding";
	1080	refs[2]="schema";
	1081	refs[3]="method";
	1082	refs[4]="href";
	1083	char*url;
	1084	for(int l=0;l<5;l++){
	1085	#ifdef DEBUG
	1086	fprintf(stderr,"* %s *",refs[l]);
	1087	#endif
	1088	xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
	1089	if(val!=NULL && xmlStrlen(val)>0){
	1090	if(tmpmaps->content!=NULL)
	1091	addToMap(tmpmaps->content,refs[l],(char*)val);
	1092	else
	1093	tmpmaps->content=createMap(refs[l],(char*)val);
	1094	map* ltmp=getMap(tmpmaps->content,"method");
	1095	if(l==4){
	1096	if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
	1097	&& CHECK_INET_HANDLE(hInternet)){
	1098	res=InternetOpenUrl(hInternet,(char*)val,NULL,0,
	1099	INTERNET_FLAG_NO_CACHE_WRITE,0);
	1100	char* tmpContent=
	1101	(char*)calloc((res.nDataLen+1),sizeof(char));
	1102	if(tmpContent == NULL){
	1103	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1104	}
	1105	size_t dwRead;
	1106	InternetReadFile(res, (LPVOID)tmpContent,
	1107	res.nDataLen, &dwRead);
	1108	tmpContent[res.nDataLen]=0;
	1109	addToMap(tmpmaps->content,"value",tmpContent);
	1110	}
	1111	}
	1112	}
	1113	#ifdef DEBUG
	1114	fprintf(stderr,"%s\n",val);
	1115	#endif
	1116	xmlFree(val);
	1117	}
	1118	#ifdef POST_DEBUG
	1119	fprintf(stderr,"Parse Header and Body from Reference \n");
	1120	#endif
	1121	xmlNodePtr cur3=cur2->children;
	1122	hInternet.header=NULL;
	1123	while(cur3){
	1124	if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
	1125	xmlNodePtr cur4=cur3;
	1126	char *tmp=new char[cgiContentLength];
	1127	char *ha[2];
	1128	ha[0]="key";
	1129	ha[1]="value";
	1130	int hai;
	1131	char *has;
	1132	char *key;
	1133	for(hai=0;hai<2;hai++){
	1134	xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
	1135	#ifdef POST_DEBUG
	1136	fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
	1137	#endif
	1138	if(hai==0){
	1139	key=(char)calloc((1+strlen((char)val)),sizeof(char));
	1140	snprintf(key,1+strlen((char)val),"%s",(char)val);
	1141	}else{
	1142	has=(char)calloc((3+strlen((char)val)+strlen(key)),sizeof(char));
	1143	if(has == NULL){
	1144	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1145	}
	1146	snprintf(has,(3+strlen((char)val)+strlen(key)),"%s: %s",key,(char)val);
	1147	#ifdef POST_DEBUG
	1148	fprintf(stderr,"%s\n",has);
	1149	#endif
	1150	}
	1151	}
	1152	hInternet.header=curl_slist_append(hInternet.header, has);
	1153	//free(has);
	1154	}
	1155	else{
	1156	#ifdef POST_DEBUG
	1157	fprintf(stderr,"Try to fetch the body part of the request ...\n");
	1158	#endif
	1159	if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
	1160	#ifdef POST_DEBUG
	1161	fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
	1162	#endif
	1163	char *tmp=new char[cgiContentLength];
	1164	memset(tmp,0,cgiContentLength);
	1165	xmlNodePtr cur4=cur3->children;
	1166	while(cur4!=NULL){
	1167	xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
	1168	bdoc->encoding = xmlCharStrdup ("UTF-8");
	1169	xmlDocSetRootElement(bdoc,cur4);
	1170	xmlChar* btmps;
	1171	int bsize;
	1172	xmlDocDumpMemory(bdoc,&btmps,&bsize);
	1173	#ifdef POST_DEBUG
	1174	fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
	1175	#endif
	1176	if(btmps!=NULL)
	1177	sprintf(tmp,"%s",(char*)btmps);
	1178	xmlFreeDoc(bdoc);
	1179	cur4=cur4->next;
	1180	}
	1181	map *btmp=getMap(tmpmaps->content,"href");
	1182	if(btmp!=NULL){
	1183	#ifdef POST_DEBUG
	1184	fprintf(stderr,"%s %s\n",btmp->value,tmp);
	1185	curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
	1186	#endif
	1187	res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
	1188	INTERNET_FLAG_NO_CACHE_WRITE,0);
	1189	char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
	1190	if(tmpContent == NULL){
	1191	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1192	}
	1193	size_t dwRead;
	1194	InternetReadFile(res, (LPVOID)tmpContent,
	1195	res.nDataLen, &dwRead);
	1196	tmpContent[res.nDataLen]=0;
	1197	if(hInternet.header!=NULL)
	1198	curl_slist_free_all(hInternet.header);
	1199	addToMap(tmpmaps->content,"value",tmpContent);
	1200	#ifdef POST_DEBUG
	1201	fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
	1202	#endif
	1203	}
	1204	}
	1205	else
	1206	if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
	1207	xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
	1208	HINTERNET bInternet,res1;
	1209	bInternet=InternetOpen(
	1210	#ifndef WIN32
	1211	(LPCTSTR)
	1212	#endif
	1213	"ZooWPSClient\0",
	1214	INTERNET_OPEN_TYPE_PRECONFIG,
	1215	NULL,NULL, 0);
	1216	if(!CHECK_INET_HANDLE(bInternet))
	1217	fprintf(stderr,"WARNING : hInternet handle failed to initialize");
	1218	#ifdef POST_DEBUG
	1219	curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
	1220	#endif
	1221	res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
	1222	INTERNET_FLAG_NO_CACHE_WRITE,0);
	1223	char* tmp=
	1224	(char*)calloc((res1.nDataLen+1),sizeof(char));
	1225	if(tmp == NULL){
	1226	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1227	}
	1228	size_t bRead;
	1229	InternetReadFile(res1, (LPVOID)tmp,
	1230	res1.nDataLen, &bRead);
	1231	tmp[res1.nDataLen]=0;
	1232	InternetCloseHandle(bInternet);
	1233	map *btmp=getMap(tmpmaps->content,"href");
	1234	if(btmp!=NULL){
	1235	#ifdef POST_DEBUG
	1236	fprintf(stderr,"%s %s\n",btmp->value,tmp);
	1237	curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
	1238	#endif
	1239	res=InternetOpenUrl(hInternet,btmp->value,tmp,
	1240	strlen(tmp),
	1241	INTERNET_FLAG_NO_CACHE_WRITE,0);
	1242	char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
	1243	if(tmpContent == NULL){
	1244	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1245	}
	1246	size_t dwRead;
	1247	InternetReadFile(res, (LPVOID)tmpContent,
	1248	res.nDataLen, &dwRead);
	1249	tmpContent[res.nDataLen]=0;
	1250	if(hInternet.header!=NULL)
	1251	curl_slist_free_all(hInternet.header);
	1252	addToMap(tmpmaps->content,"value",tmpContent);
	1253	#ifdef POST_DEBUG
	1254	fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
	1255	#endif
	1256	}
	1257	}
	1258	}
	1259	cur3=cur3->next;
	1260	}
	1261	#ifdef POST_DEBUG
	1262	fprintf(stderr,"Header and Body was parsed from Reference \n");
	1263	#endif
	1264	#ifdef DEBUG
	1265	dumpMap(tmpmaps->content);
	1266	fprintf(stderr, "= element 2 node \"%s\" = (%s)\n",
	1267	cur2->name,cur2->content);
	1268	#endif
	1269	}
	1270	else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
	1271	#ifdef DEBUG
	1272	fprintf(stderr,"DATA\n");
	1273	#endif
	1274	xmlNodePtr cur4=cur2->children;
	1275	while(cur4!=NULL){
	1276	while(cur4!=NULL &&cur4->type!=XML_ELEMENT_NODE)
	1277	cur4=cur4->next;
	1278	if(cur4==NULL)
	1279	break;
	1280	if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
	1281	/**
	1282	* Get every attribute from a LiteralData node
	1283	* dataType , uom
	1284	*/
	1285	char *lits[2];
	1286	lits[0]="dataType";
	1287	lits[1]="uom";
	1288	for(int l=0;l<2;l++){
	1289	#ifdef DEBUG
	1290	fprintf(stderr,"* LiteralData %s *",lits[l]);
	1291	#endif
	1292	xmlChar *val=xmlGetProp(cur4,BAD_CAST lits[l]);
	1293	if(val!=NULL && strlen((char*)val)>0){
	1294	if(tmpmaps->content!=NULL)
	1295	addToMap(tmpmaps->content,lits[l],(char*)val);
	1296	else
	1297	tmpmaps->content=createMap(lits[l],(char*)val);
	1298	}
	1299	#ifdef DEBUG
	1300	fprintf(stderr,"%s\n",val);
	1301	#endif
	1302	xmlFree(val);
	1303	}
	1304	}
	1305	else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
	1306	/**
	1307	* Get every attribute from a Reference node
	1308	* mimeType, encoding, schema
	1309	*/
	1310	char *coms[3];
	1311	coms[0]="mimeType";
	1312	coms[1]="encoding";
	1313	coms[2]="schema";
	1314	for(int l=0;l<3;l++){
	1315	#ifdef DEBUG
	1316	fprintf(stderr,"* ComplexData %s *",coms[l]);
	1317	#endif
	1318	xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
	1319	if(val!=NULL && strlen((char*)val)>0){
	1320	if(tmpmaps->content!=NULL)
	1321	addToMap(tmpmaps->content,coms[l],(char*)val);
	1322	else
	1323	tmpmaps->content=createMap(coms[l],(char*)val);
	1324	}
	1325	#ifdef DEBUG
	1326	fprintf(stderr,"%s\n",val);
	1327	#endif
	1328	xmlFree(val);
	1329	}
	1330	}
	1331	xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
	1332	addToMap(tmpmaps->content,"value",(char*)mv);
	1333	xmlFree(mv);
	1334	cur4=cur4->next;
	1335	}
	1336	}
	1337	#ifdef DEBUG
	1338	fprintf(stderr,"cur2 next \n");
	1339	fflush(stderr);
	1340	#endif
	1341	cur2=cur2->next;
	1342	}
	1343	#ifdef DEBUG
	1344	fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
	1345	fflush(stderr);
	1346	#endif
	1347	addMapsToMaps(&request_input_real_format,tmpmaps);
	1348
	1349	#ifdef DEBUG
	1350	fprintf(stderr,"****TMPMAPS***\n");
	1351	dumpMaps(tmpmaps);
	1352	fprintf(stderr,"****REQUESTMAPS***\n");
	1353	dumpMaps(request_input_real_format);
	1354	#endif
	1355	freeMaps(&tmpmaps);
	1356	free(tmpmaps);
	1357	tmpmaps=NULL;
	1358	}
	1359	#ifdef DEBUG
	1360	dumpMaps(tmpmaps);
	1361	#endif
	1362	}
	1363	#ifdef DEBUG
	1364	fprintf(stderr,"Search for response document node\n");
	1365	#endif
	1366	xmlXPathFreeObject(tmpsptr);
	1367	//xmlFree(tmps);
	1368	tmpsptr=extractFromDoc(doc,"///*[local-name()='ResponseDocument']");
	1369	tmps=tmpsptr->nodesetval;
	1370	#ifdef DEBUG
	1371	fprintf(stderr,"***%d***\n",tmps->nodeNr);
	1372	#endif
	1373	for(int k=0;k<tmps->nodeNr;k++){
	1374	addToMap(request_inputs,"ResponseDocument","");
	1375	request_output_real_format;
	1376	maps *tmpmaps=NULL;
	1377	xmlNodePtr cur=tmps->nodeTab[k];
	1378	if(cur->type == XML_ELEMENT_NODE) {
	1379	/**
	1380	* A specific responseDocument node.
	1381	*/
	1382	if(tmpmaps==NULL){
	1383	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1384	if(tmpmaps == NULL){
	1385	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1386	}
	1387	tmpmaps->name="unknownIdentifier";
	1388	tmpmaps->next=NULL;
	1389	}
	1390	/**
	1391	* Get every attribute from a LiteralData node
	1392	* storeExecuteResponse, lineage, status
	1393	*/
	1394	char *ress[3];
	1395	ress[0]="storeExecuteResponse";
	1396	ress[1]="lineage";
	1397	ress[2]="status";
	1398	xmlChar *val;
	1399	for(int l=0;l<3;l++){
	1400	#ifdef DEBUG
	1401	fprintf(stderr,"* %s *\t",ress[l]);
	1402	#endif
	1403	val=xmlGetProp(cur,BAD_CAST ress[l]);
	1404	if(val!=NULL && strlen((char*)val)>0){
	1405	if(tmpmaps->content!=NULL)
	1406	addToMap(tmpmaps->content,ress[l],(char*)val);
	1407	else
	1408	tmpmaps->content=createMap(ress[l],(char*)val);
	1409	addToMap(request_inputs,ress[l],(char*)val);
	1410	}
	1411	#ifdef DEBUG
	1412	fprintf(stderr,"%s\n",val);
	1413	#endif
	1414	xmlFree(val);
	1415	}
	1416	xmlNodePtr cur1=cur->children;
	1417	while(cur1){
	1418	if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
	1419	/**
	1420	* Get every attribute from a Output node
	1421	* mimeType, encoding, schema, uom, asReference
	1422	*/
	1423	char *outs[5];
	1424	outs[0]="mimeType";
	1425	outs[1]="encoding";
	1426	outs[2]="schema";
	1427	outs[3]="uom";
	1428	outs[4]="asReference";
	1429	for(int l=0;l<5;l++){
	1430	#ifdef DEBUG
	1431	fprintf(stderr,"* %s *\t",outs[l]);
	1432	#endif
	1433	val=xmlGetProp(cur1,BAD_CAST outs[l]);
	1434	if(val!=NULL && strlen((char*)val)>0){
	1435	if(tmpmaps->content!=NULL)
	1436	addToMap(tmpmaps->content,outs[l],(char*)val);
	1437	else
	1438	tmpmaps->content=createMap(outs[l],(char*)val);
	1439	}
	1440	#ifdef DEBUG
	1441	fprintf(stderr,"%s\n",val);
	1442	#endif
	1443	xmlFree(val);
	1444	}
	1445
	1446	xmlNodePtr cur2=cur1->children;
	1447	while(cur2){
	1448	/**
	1449	* Indentifier
	1450	*/
	1451	if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
	1452	xmlChar *val=
	1453	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
	1454	if(tmpmaps==NULL){
	1455	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1456	if(tmpmaps == NULL){
	1457	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1458	}
	1459	tmpmaps->name=strdup((char*)val);
	1460	tmpmaps->content=NULL;
	1461	tmpmaps->next=NULL;
	1462	}
	1463	else
	1464	tmpmaps->name=strdup((char*)val);;
	1465	xmlFree(val);
	1466	}
	1467	/**
	1468	* Title, Asbtract
	1469	*/
	1470	if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 \|\|
	1471	xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
	1472	xmlChar *val=
	1473	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
	1474	if(tmpmaps==NULL){
	1475	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1476	if(tmpmaps == NULL){
	1477	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1478	}
	1479	tmpmaps->name="missingIndetifier";
	1480	tmpmaps->content=createMap((char)cur2->name,(char)val);
	1481	tmpmaps->next=NULL;
	1482	}
	1483	else{
	1484	if(tmpmaps->content!=NULL)
	1485	addToMap(tmpmaps->content,
	1486	(char)cur2->name,(char)val);
	1487	else
	1488	tmpmaps->content=
	1489	createMap((char)cur2->name,(char)val);
	1490	}
	1491	xmlFree(val);
	1492	}
	1493	cur2=cur2->next;
	1494	}
	1495	}
	1496	cur1=cur1->next;
	1497	}
	1498	}
	1499	//xmlFree(cur);
	1500	if(request_output_real_format==NULL)
	1501	request_output_real_format=tmpmaps;
	1502	else
	1503	addMapsToMaps(&request_output_real_format,tmpmaps);
	1504	#ifdef DEBUG
	1505	dumpMaps(tmpmaps);
	1506	#endif
	1507	}
	1508	xmlXPathFreeObject(tmpsptr);
	1509	//xmlFree(tmps);
	1510	tmpsptr=extractFromDoc(doc,"///*[local-name()='RawDataOutput']");
	1511	tmps=tmpsptr->nodesetval;
	1512	#ifdef DEBUG
	1513	fprintf(stderr,"***%d***\n",tmps->nodeNr);
	1514	#endif
	1515	for(int k=0;k<tmps->nodeNr;k++){
	1516	addToMap(request_inputs,"RawDataOutput","");
	1517	xmlNodePtr cur1=tmps->nodeTab[k];
	1518	xmlChar *val;
	1519	/**
	1520	* Get every attribute from a Output node
	1521	* mimeType, encoding, schema, uom, asReference
	1522	*/
	1523	char *outs[4];
	1524	outs[0]="mimeType";
	1525	outs[1]="encoding";
	1526	outs[2]="schema";
	1527	outs[3]="uom";
	1528	for(int l=0;l<4;l++){
	1529	#ifdef DEBUG
	1530	fprintf(stderr,"* %s *\t",outs[l]);
	1531	#endif
	1532	val=xmlGetProp(cur1,BAD_CAST outs[l]);
	1533	if(val!=NULL && strlen((char*)val)>0){
	1534	if(tmpmaps==NULL){
	1535	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1536	if(tmpmaps == NULL){
	1537	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1538	}
	1539	tmpmaps->name="unknownIdentifier";
	1540	tmpmaps->content=createMap(outs[l],(char*)val);
	1541	tmpmaps->next=NULL;
	1542	}
	1543	else
	1544	addToMap(tmpmaps->content,outs[l],(char*)val);
	1545	}
	1546	#ifdef DEBUG
	1547	fprintf(stderr,"%s\n",val);
	1548	#endif
	1549	xmlFree(val);
	1550	}
	1551
	1552	xmlNodePtr cur2=cur1->children;
	1553	while(cur2){
	1554	/**
	1555	* Indentifier
	1556	*/
	1557	if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
	1558	val=
	1559	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
	1560	if(tmpmaps==NULL){
	1561	tmpmaps=(maps*)calloc(1,MAPS_SIZE);
	1562	if(tmpmaps == NULL){
	1563	return errorException(m, _("Unable to allocate memory."), "InternalError");
	1564	}
	1565	tmpmaps->name=strdup((char*)val);
	1566	tmpmaps->content=NULL;
	1567	tmpmaps->next=NULL;
	1568	}
	1569	else
	1570	tmpmaps->name=strdup((char*)val);;
	1571	xmlFree(val);
	1572	}
	1573	cur2=cur2->next;
	1574	}
	1575	if(request_output_real_format==NULL)
	1576	request_output_real_format=tmpmaps;
	1577	else
	1578	addMapsToMaps(&request_output_real_format,tmpmaps);
	1579	#ifdef DEBUG
	1580	dumpMaps(tmpmaps);
	1581	#endif
	1582	}
	1583	xmlXPathFreeObject(tmpsptr);
	1584	//xmlFree(tmps);
	1585	xmlCleanupParser();
	1586	}
	1587
	1588	//if(CHECK_INET_HANDLE(hInternet))
	1589	InternetCloseHandle(hInternet);
	1590
	1591	#ifdef DEBUG
	1592	fprintf(stderr,"\n%i\n",i);
	1593	dumpMaps(request_input_real_format);
	1594	dumpMaps(request_output_real_format);
	1595	dumpMap(request_inputs);
	1596	#endif
	1597
	1598	/**
	1599	* Ensure that each requested arguments are present in the request
	1600	* DataInputs and ResponseDocument / RawDataOutput
	1601	*/
	1602	char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,"inputs");
	1603	if(strcmp(dfv,"")!=0){
	1604	char tmps[1024];
	1605	snprintf(tmps,1024,_("The <%s> argument was not specified in DataInputs but defined as requested in ZOO ServicesProvider configuration file, please correct your query or the ZOO Configuration file."),dfv);
	1606	map* tmpe=createMap("text",tmps);
	1607	addToMap(tmpe,"code","MissingParameterValue");
	1608	printExceptionReportResponse(m,tmpe);
	1609	freeMap(&tmpe);
	1610	free(tmpe);
	1611	freeMaps(&m);
	1612	free(m);
	1613	free(REQUEST);
	1614	freeMaps(&request_input_real_format);
	1615	free(request_input_real_format);
	1616	freeMaps(&request_output_real_format);
	1617	free(request_output_real_format);
	1618	freeMaps(&tmpmaps);
	1619	free(tmpmaps);
	1620	return 1;
	1621	}
	1622	addDefaultValues(&request_output_real_format,s1->outputs,m,"outputs");
	1623
	1624	#ifdef DEBUG
	1625	fprintf(stderr,"REQUEST_INPUTS\n");
	1626	dumpMaps(request_input_real_format);
	1627	fprintf(stderr,"REQUEST_OUTPUTS\n");
	1628	dumpMaps(request_output_real_format);
	1629	#endif
	1630
	1631	maps* curs=getMaps(m,"env");
	1632	if(curs!=NULL){
	1633	map* mapcs=curs->content;
	1634	while(mapcs!=NULLMAP){
	1635	#ifndef WIN32
	1636	setenv(mapcs->name,mapcs->value,1);
	1637	#else
	1638	#ifdef DEBUG
	1639	fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
	1640	#endif
	1641	if(mapcs->value[strlen(mapcs->value)-2]=='\r'){
	1642	#ifdef DEBUG
	1643	fprintf(stderr,"[ZOO: Env var finish with \r]\n");
	1644	#endif
	1645	mapcs->value[strlen(mapcs->value)-1]=0;
	1646	}
	1647	#ifdef DEBUG
	1648	fflush(stderr);
	1649	fprintf(stderr,"setting variable... %s\n",
	1650	#endif
	1651	SetEnvironmentVariable(mapcs->name,mapcs->value)
	1652	#ifdef DEBUG
	1653	? "OK" : "FAILED");
	1654	#else
	1655	;
	1656	#endif
	1657	#ifdef DEBUG
	1658	fflush(stderr);
	1659	#endif
	1660	#endif
	1661	#ifdef DEBUG
	1662	fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
	1663	fflush(stderr);
	1664	#endif
	1665	mapcs=mapcs->next;
	1666	}
	1667	}
	1668
	1669	#ifdef DEBUG
	1670	dumpMap(request_inputs);
	1671	#endif
	1672
	1673	/**
	1674	* Need to check if we need to fork to load a status enabled
	1675	*/
	1676	r_inputs=NULL;
	1677	r_inputs=getMap(request_inputs,"storeExecuteResponse");
	1678	int eres=SERVICE_STARTED;
	1679	int cpid=getpid();
	1680
	1681	maps _tmpMaps=(maps)malloc(MAPS_SIZE);
	1682	_tmpMaps->name=strdup("lenv");
	1683	char tmpBuff[100];
	1684	sprintf(tmpBuff,"%i",cpid);
	1685	_tmpMaps->content=createMap("sid",tmpBuff);
	1686	_tmpMaps->next=NULL;
	1687	addToMap(_tmpMaps->content,"status","0");
	1688	addMapsToMaps(&m,_tmpMaps);
	1689	freeMaps(&_tmpMaps);
	1690	free(_tmpMaps);
	1691
	1692	#ifdef DEBUG
	1693	dumpMap(request_inputs);
	1694	#endif
	1695
	1696	if(r_inputs!=NULL)
	1697	if(strcasecmp(r_inputs->value,"false")==0)
	1698	r_inputs=NULL;
	1699	if(r_inputs==NULLMAP){
	1700	loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
	1701	}
	1702	else{
	1703	pid_t pid;
	1704	#ifdef DEBUG
	1705	fprintf(stderr,"\nPID : %d\n",cpid);
	1706	#endif
	1707
	1708	#ifndef WIN32
	1709	pid = fork ();
	1710	#else
	1711	pid = 0;
	1712	#endif
	1713	if (pid > 0) {
	1714	/**
	1715	* dady :
	1716	* set status to SERVICE_ACCEPTED
	1717	*/
	1718	#ifdef DEBUG
	1719	fprintf(stderr,"father pid continue (origin %d) %d ...\n",cpid,getpid());
	1720	#endif
	1721	eres=SERVICE_ACCEPTED;
	1722	}else if (pid == 0) {
	1723	/**
	1724	* son : have to close the stdout, stdin and stderr to let the parent
	1725	* process answer to http client.
	1726	*/
	1727	r_inputs=getMapFromMaps(m,"main","tmpPath");
	1728	map* r_inputs1=getMap(s1->content,"ServiceProvider");
	1729	char* fbkp=(char)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)sizeof(char));
	1730	sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
	1731	char* flog=(char)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)sizeof(char));
	1732	sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
	1733	#ifdef DEBUG
	1734	fprintf(stderr,"RUN IN BACKGROUND MODE \n");
	1735	fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
	1736	fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
	1737	#endif
	1738	freopen(fbkp , "w+", stdout);
	1739	fclose(stdin);
	1740	freopen(flog,"w+",stderr);
	1741	free(fbkp);
	1742	free(flog);
	1743	/**
	1744	* set status to SERVICE_STARTED and flush stdout to ensure full
	1745	* content was outputed (the file used to store the ResponseDocument).
	1746	* The rewind stdout to restart writing from the bgining of the file,
	1747	* this way the data will be updated at the end of the process run.
	1748	*/
	1749	updateStatus(m);
	1750	printProcessResponse(m,request_inputs,cpid,
	1751	s1,r_inputs1->value,SERVICE_STARTED,
	1752	request_input_real_format,
	1753	request_output_real_format);
	1754	fflush(stdout);
	1755	rewind(stdout);
	1756
	1757	loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
	1758
	1759	} else {
	1760	/**
	1761	* error server don't accept the process need to output a valid
	1762	* error response here !!!
	1763	*/
	1764	eres=-1;
	1765	errorException(m, _("Unable to run the child process properly"), "InternalError");
	1766	}
	1767
	1768	}
	1769
	1770	#ifdef DEBUG
	1771	dumpMaps(request_output_real_format);
	1772	fprintf(stderr,"Function loaded and returned %d\n",eres);
	1773	fflush(stderr);
	1774	#endif
	1775	if(eres!=-1)
	1776	outputResponse(s1,request_input_real_format,
	1777	request_output_real_format,request_inputs,
	1778	cpid,m,eres);
	1779
	1780	if(((int)getpid())!=cpid){
	1781	fclose(stdout);
	1782	fclose(stderr);
	1783	unhandleStatus(m);
	1784	}
	1785
	1786	freeService(&s1);
	1787	free(s1);
	1788	freeMaps(&m);
	1789	free(m);
	1790
	1791	freeMaps(&request_input_real_format);
	1792	free(request_input_real_format);
	1793
	1794	/* The following is requested but get issue using with Python support :/ */
	1795	/* freeMaps(&request_output_real_format);
	1796	free(request_output_real_format);*/
	1797
	1798	free(REQUEST);
	1799	free(SERVICE_URL);
	1800	#ifdef DEBUG
	1801	fprintf(stderr,"Processed response \n");
	1802	fflush(stdout);
	1803	fflush(stderr);
	1804	#endif
	1805
	1806	return 0;
	1807	}

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

Open WPS platform

source: trunk/zoo-kernel/zoo_service_loader.c @ 34

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links