zoo_service_loader.c @ 393

Last change on this file since 393 was 393, checked in by djay, 12 years ago
Remove temporary file created when running service in background. Make compilation of JAVA support works using XCode 4.4.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 64.6 KB

Line
1	/**
2	* Author : Gérald FENOY
3	*
4	* Copyright 2008-2013 GeoLabs SARL. All rights reserved.
5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a copy
7	* of this software and associated documentation files (the "Software"), to deal
8	* in the Software without restriction, including without limitation the rights
9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10	* copies of the Software, and to permit persons to whom the Software is
11	* furnished to do so, subject to the following conditions:
12	*
13	* The above copyright notice and this permission notice shall be included in
14	* all copies or substantial portions of the Software.
15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22	* THE SOFTWARE.
23	*/
24
25	#define length(x) (sizeof(x) / sizeof(x[0]))
26
27	extern "C" int yylex();
28	extern "C" int crlex();
29
30	#include "cgic.h"
31
32	extern "C" {
33	#include <libxml/tree.h>
34	#include <libxml/xmlmemory.h>
35	#include <libxml/parser.h>
36	#include <libxml/xpath.h>
37	#include <libxml/xpathInternals.h>
38	}
39
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	#include <dirent.h>
71	#include <signal.h>
72	#include <unistd.h>
73	#ifndef WIN32
74	#include <dlfcn.h>
75	#include <libgen.h>
76	#else
77	#include <windows.h>
78	#include <direct.h>
79	#include <sys/types.h>
80	#include <sys/stat.h>
81	#include <unistd.h>
82	#define pid_t int;
83	#endif
84	#include <fcntl.h>
85	#include <time.h>
86	#include <stdarg.h>
87
88	#ifdef WIN32
89	extern "C" {
90	__declspec(dllexport) char strcasestr(char const a, char const *b)
91	#ifndef USE_MS
92	{
93	char *x=_strdup(a);
94	char *y=_strdup(b);
95
96	x=_strlwr(x);
97	y=_strlwr(y);
98	char *pos = strstr(x, y);
99	char ret = pos == NULL ? NULL : (char )(a + (pos-x));
100	free(x);
101	free(y);
102	return ret;
103	};
104	#else
105	;
106	#endif
107	}
108	#endif
109
110	#define _(String) dgettext ("zoo-kernel",String)
111	#define __(String) dgettext ("zoo-service",String)
112
113
114	void translateChar(char* str,char toReplace,char toReplaceBy){
115	int i=0,len=strlen(str);
116	for(i=0;i<len;i++){
117	if(str[i]==toReplace)
118	str[i]=toReplaceBy;
119	}
120	}
121
122	/**
123	* Create (or append to) an array valued maps
124	* value = "["",""]"
125	*/
126	int appendMapsToMaps(maps* m,maps* mo,maps* mi,elements* elem){
127	maps* tmpMaps=getMaps(mo,mi->name);
128	map* tmap=getMapType(tmpMaps->content);
129	elements* el=getElements(elem,mi->name);
130	int hasEl=1;
131	if(el==NULL)
132	hasEl=-1;
133	if(tmap==NULL){
134	if(hasEl>0)
135	tmap=getMapType(el->defaults->content);
136	}
137
138	map* testMap=NULL;
139	if(hasEl>0){
140	testMap=getMap(el->content,"maxOccurs");
141	}else{
142	testMap=createMap("maxOccurs","unbounded");
143	}
144
145	if(testMap!=NULL){
146	if(strncasecmp(testMap->value,"unbounded",9)!=0 && atoi(testMap->value)>1){
147	if(addMapsArrayToMaps(&mo,mi,tmap->name)<0){
148	char emsg[1024];
149	sprintf(emsg,_("You set maximum occurences for <%s> as %i but you tried to use it more than the limit you set. Please correct your ZCFG file or your request."),mi->name,atoi(testMap->value));
150	errorException(m,emsg,"InternalError");
151	return -1;
152	}
153	}else{
154	if(strncasecmp(testMap->value,"unbounded",9)==0){
155	if(hasEl<0){
156	freeMap(&testMap);
157	free(testMap);
158	}
159	if(addMapsArrayToMaps(&mo,mi,tmap->name)<0){
160	char emsg[1024];
161	map* tmpMap=getMap(mi->content,"length");
162	sprintf(emsg,_("ZOO-Kernel was unable to load your data for %s position %s."),mi->name,tmpMap->value);
163	errorException(m,emsg,"InternalError");
164	return -1;
165	}
166	}
167	else{
168	char emsg[1024];
169	sprintf(emsg,_("You set maximum occurences for <%s> to one but you tried to use it more than once. Please correct your ZCFG file or your request."),mi->name);
170	errorException(m,emsg,"InternalError");
171	return -1;
172	}
173	}
174	}
175	return 0;
176	}
177
178	xmlXPathObjectPtr extractFromDoc(xmlDocPtr doc,const char* search){
179	xmlXPathContextPtr xpathCtx;
180	xmlXPathObjectPtr xpathObj;
181	xpathCtx = xmlXPathNewContext(doc);
182	xpathObj = xmlXPathEvalExpression(BAD_CAST search,xpathCtx);
183	xmlXPathFreeContext(xpathCtx);
184	return xpathObj;
185	}
186
187	void donothing(int sig){
188	fprintf(stderr,"Signal %d after the ZOO-Kernel returned result !\n",sig);
189	exit(0);
190	}
191
192	void sig_handler(int sig){
193	char tmp[100];
194	const char *ssig;
195	switch(sig){
196	case SIGSEGV:
197	ssig="SIGSEGV";
198	break;
199	case SIGTERM:
200	ssig="SIGTERM";
201	break;
202	case SIGINT:
203	ssig="SIGINT";
204	break;
205	case SIGILL:
206	ssig="SIGILL";
207	break;
208	case SIGFPE:
209	ssig="SIGFPE";
210	break;
211	case SIGABRT:
212	ssig="SIGABRT";
213	break;
214	default:
215	ssig="UNKNOWN";
216	break;
217	}
218	sprintf(tmp,_("ZOO Kernel failed to process your request receiving signal %d = %s"),sig,ssig);
219	errorException(NULL, tmp, "InternalError");
220	#ifdef DEBUG
221	fprintf(stderr,"Not this time!\n");
222	#endif
223	exit(0);
224	}
225
226	void loadServiceAndRun(maps *myMap,service s1,map* request_inputs,maps inputs,maps ioutputs,int* eres){
227	char tmps1[1024];
228	char ntmp[1024];
229	maps m=myMap;
230	maps request_output_real_format=ioutputs;
231	maps request_input_real_format=inputs;
232	/**
233	* Extract serviceType to know what kind of service should be loaded
234	*/
235	map* r_inputs=NULL;
236	#ifndef WIN32
237	char* pntmp=getcwd(ntmp,1024);
238	#else
239	_getcwd(ntmp,1024);
240	#endif
241	r_inputs=getMap(s1->content,"serviceType");
242	#ifdef DEBUG
243	fprintf(stderr,"LOAD A %s SERVICE PROVIDER \n",r_inputs->value);
244	fflush(stderr);
245	#endif
246	if(strlen(r_inputs->value)==1 && strncasecmp(r_inputs->value,"C",1)==0){
247	r_inputs=getMap(request_inputs,"metapath");
248	if(r_inputs!=NULL)
249	sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
250	else
251	sprintf(tmps1,"%s/",ntmp);
252	char *altPath=strdup(tmps1);
253	r_inputs=getMap(s1->content,"ServiceProvider");
254	sprintf(tmps1,"%s/%s",altPath,r_inputs->value);
255	free(altPath);
256	#ifdef DEBUG
257	fprintf(stderr,"Trying to load %s\n",tmps1);
258	#endif
259	#ifdef WIN32
260	HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
261	#else
262	void* so = dlopen(tmps1, RTLD_LAZY);
263	#endif
264	#ifdef DEBUG
265	#ifdef WIN32
266	DWORD errstr;
267	errstr = GetLastError();
268	fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
269	#else
270	char *errstr;
271	errstr = dlerror();
272	#endif
273	#endif
274	if( so != NULL ) {
275	#ifdef DEBUG
276	fprintf(stderr,"Library loaded %s \n",errstr);
277	fprintf(stderr,"Service Shared Object = %s\n",r_inputs->value);
278	#endif
279	r_inputs=getMap(s1->content,"serviceType");
280	#ifdef DEBUG
281	dumpMap(r_inputs);
282	fprintf(stderr,"%s\n",r_inputs->value);
283	fflush(stderr);
284	#endif
285	if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
286	r_inputs=getMap(request_inputs,"Identifier");
287	char fname[1024];
288	sprintf(fname,"%s_",r_inputs->value);
289	#ifdef DEBUG
290	fprintf(stderr,"Try to load function %s\n",fname);
291	#endif
292	#ifdef WIN32
293	typedef int (CALLBACK* execute_t)(char*,char,char**);
294	execute_t execute=(execute_t)GetProcAddress(so,fname);
295	#else
296	typedef int (execute_t)(char,char,char**);
297	execute_t execute=(execute_t)dlsym(so,fname);
298	#endif
299	#ifdef DEBUG
300	#ifdef WIN32
301	errstr = GetLastError();
302	#else
303	errstr = dlerror();
304	#endif
305	fprintf(stderr,"Function loaded %s\n",errstr);
306	#endif
307
308	char main_conf[10][30][1024];
309	char inputs[10][30][1024];
310	char outputs[10][30][1024];
311	for(int i=0;i<10;i++){
312	for(int j=0;j<30;j++){
313	memset(main_conf[i][j],0,1024);
314	memset(inputs[i][j],0,1024);
315	memset(outputs[i][j],0,1024);
316	}
317	}
318	mapsToCharXXX(m,(char***)main_conf);
319	mapsToCharXXX(request_input_real_format,(char***)inputs);
320	mapsToCharXXX(request_output_real_format,(char***)outputs);
321	eres=execute((char)&main_conf[0],(char)&inputs[0],(char**)&outputs[0]);
322	#ifdef DEBUG
323	fprintf(stderr,"Function run successfully \n");
324	#endif
325	charxxxToMaps((char***)&outputs[0],&request_output_real_format);
326	}else{
327	#ifdef DEBUG
328	#ifdef WIN32
329	errstr = GetLastError();
330	fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
331	#endif
332	#endif
333	r_inputs=getMap(request_inputs,"Identifier");
334	#ifdef DEBUG
335	fprintf(stderr,"Try to load function %s\n",r_inputs->value);
336	#endif
337	typedef int (execute_t)(maps,maps,maps*);
338	#ifdef WIN32
339	execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value);
340	#else
341	execute_t execute=(execute_t)dlsym(so,r_inputs->value);
342	#endif
343
344	#ifdef DEBUG
345	#ifdef WIN32
346	errstr = GetLastError();
347	#else
348	errstr = dlerror();
349	#endif
350	fprintf(stderr,"Function loaded %s\n",errstr);
351	#endif
352
353	#ifdef DEBUG
354	fprintf(stderr,"Now run the function \n");
355	fflush(stderr);
356	#endif
357	*eres=execute(&m,&request_input_real_format,&request_output_real_format);
358	#ifdef DEBUG
359	fprintf(stderr,"Function loaded and returned %d\n",eres);
360	fflush(stderr);
361	#endif
362	}
363	#ifdef WIN32
364	*ioutputs=dupMaps(&request_output_real_format);
365	FreeLibrary(so);
366	#else
367	dlclose(so);
368	#endif
369	} else {
370	/**
371	* Unable to load the specified shared library
372	*/
373	char tmps[1024];
374	#ifdef WIN32
375	DWORD errstr = GetLastError();
376	#else
377	char* errstr = dlerror();
378	#endif
379	sprintf(tmps,_("C Library can't be loaded %s"),errstr);
380	map* tmps1=createMap("text",tmps);
381	printExceptionReportResponse(m,tmps1);
382	*eres=-1;
383	}
384	}
385	else
386	#ifdef USE_PYTHON
387	if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
388	*eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
389	}
390	else
391	#endif
392
393	#ifdef USE_JAVA
394	if(strncasecmp(r_inputs->value,"JAVA",4)==0){
395	*eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
396	}
397	else
398	#endif
399
400	#ifdef USE_PHP
401	if(strncasecmp(r_inputs->value,"PHP",3)==0){
402	*eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
403	}
404	else
405	#endif
406
407
408	#ifdef USE_PERL
409	if(strncasecmp(r_inputs->value,"PERL",4)==0){
410	*eres=zoo_perl_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
411	}
412	else
413	#endif
414
415	#ifdef USE_JS
416	if(strncasecmp(r_inputs->value,"JS",2)==0){
417	*eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
418	}
419	else
420	#endif
421	{
422	char tmpv[1024];
423	sprintf(tmpv,_("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),r_inputs->value);
424	map* tmps=createMap("text",tmpv);
425	printExceptionReportResponse(m,tmps);
426	*eres=-1;
427	}
428	*myMap=m;
429	*ioutputs=request_output_real_format;
430	}
431
432
433	#ifdef WIN32
434	/**
435	* createProcess function: create a new process after setting some env variables
436	*/
437	void createProcess(maps* m,map* request_inputs,service* s1,char* opts,int cpid, maps* inputs,maps* outputs){
438	STARTUPINFO si;
439	PROCESS_INFORMATION pi;
440	ZeroMemory( &si, sizeof(si) );
441	si.cb = sizeof(si);
442	ZeroMemory( &pi, sizeof(pi) );
443	char tmp=(char )malloc((1024+cgiContentLength)*sizeof(char));
444	char tmpq=(char )malloc((1024+cgiContentLength)*sizeof(char));
445	map *req=getMap(request_inputs,"request");
446	map *id=getMap(request_inputs,"identifier");
447	map *di=getMap(request_inputs,"DataInputs");
448
449	char *dataInputsKVP=getMapsAsKVP(inputs,cgiContentLength,0);
450	char *dataOutputsKVP=getMapsAsKVP(outputs,cgiContentLength,1);
451	#ifdef DEBUG
452	fprintf(stderr,"DATAINPUTSKVP %s\n",dataInputsKVP);
453	fprintf(stderr,"DATAOUTPUTSKVP %s\n",dataOutputsKVP);
454	#endif
455	map *sid=getMapFromMaps(m,"lenv","sid");
456	map* r_inputs=getMapFromMaps(m,"main","tmpPath");
457	map* r_inputs1=getMap(request_inputs,"metapath");
458	int hasIn=-1;
459	if(r_inputs1==NULL){
460	r_inputs1=createMap("metapath","");
461	hasIn=1;
462	}
463	map* r_inputs2=getMap(s1->content,"ResponseDocument");
464	if(r_inputs2==NULL)
465	r_inputs2=getMap(s1->content,"RawDataOutput");
466	map *tmpPath=getMapFromMaps(m,"lenv","cwd");
467
468	if(r_inputs2!=NULL){
469	sprintf(tmp,"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",r_inputs1->value,req->value,id->value,dataInputsKVP,r_inputs2->name,r_inputs2->value,sid->value);
470	sprintf(tmpq,"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",r_inputs1->value,req->value,id->value,dataInputsKVP,r_inputs2->name,dataOutputsKVP);
471	}
472	else{
473	sprintf(tmp,"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",r_inputs1->value,req->value,id->value,dataInputsKVP,sid->value);
474	sprintf(tmpq,"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",r_inputs1->value,req->value,id->value,dataInputsKVP,sid->value);
475	}
476
477	if(hasIn>0){
478	freeMap(&r_inputs1);
479	free(r_inputs1);
480	}
481	char *tmp1=strdup(tmp);
482	sprintf(tmp,"zoo_loader.cgi %s \"%s\"",tmp1,sid->value);
483
484	free(dataInputsKVP);
485	free(dataOutputsKVP);
486	//printf("REQUEST IS : %s \n",tmp);
487	#ifdef DEBUG
488	fprintf(stderr,"REQUEST IS : %s \n",tmp);
489	#endif
490	SetEnvironmentVariable("CGISID",TEXT(sid->value));
491	SetEnvironmentVariable("QUERY_STRING",TEXT(tmpq));
492	char clen[1000];
493	sprintf(clen,"%d",strlen(tmpq));
494	SetEnvironmentVariable("CONTENT_LENGTH",TEXT(clen));
495
496	if( !CreateProcess( NULL, // No module name (use command line)
497	TEXT(tmp), // Command line
498	NULL, // Process handle not inheritable
499	NULL, // Thread handle not inheritable
500	FALSE, // Set handle inheritance to FALSE
501	CREATE_NO_WINDOW, // Apache won't wait until the end
502	NULL, // Use parent's environment block
503	NULL, // Use parent's starting directory
504	&si, // Pointer to STARTUPINFO struct
505	&pi ) // Pointer to PROCESS_INFORMATION struct
506	)
507	{
508	//printf("CreateProcess failed (%d).\n",GetLastError() );
509	#ifdef DEBUG
510	fprintf( stderr, "CreateProcess failed (%d).\n", GetLastError() );
511	#endif
512	return ;
513	}else{
514	//printf("CreateProcess successfull (%d).\n",GetLastError() );
515	#ifdef DEBUG
516	fprintf( stderr, "CreateProcess successfull (%d).\n\n\n\n", GetLastError() );
517	#endif
518	}
519	CloseHandle( pi.hProcess );
520	CloseHandle( pi.hThread );
521	//printf("CreateProcess finished !\n");
522	#ifdef DEBUG
523	fprintf(stderr,"CreateProcess finished !\n");
524	#endif
525	}
526	#endif
527
528	int runRequest(map* request_inputs)
529	{
530
531	#ifndef USE_GDB
532	(void) signal(SIGSEGV,sig_handler);
533	(void) signal(SIGTERM,sig_handler);
534	(void) signal(SIGINT,sig_handler);
535	(void) signal(SIGILL,sig_handler);
536	(void) signal(SIGFPE,sig_handler);
537	(void) signal(SIGABRT,sig_handler);
538	#endif
539
540	map* r_inputs=NULL;
541	maps* m=NULL;
542
543	char* REQUEST=NULL;
544	/**
545	* Parsing service specfic configuration file
546	*/
547	m=(maps*)malloc(MAPS_SIZE);
548	if(m == NULL){
549	return errorException(m, _("Unable to allocate memory."), "InternalError");
550	}
551	char ntmp[1024];
552	#ifndef WIN32
553	char *pntmp=getcwd(ntmp,1024);
554	#else
555	_getcwd(ntmp,1024);
556	#endif
557	r_inputs=getMapOrFill(request_inputs,"metapath","");
558
559
560	char conf_file[10240];
561	snprintf(conf_file,10240,"%s/%s/main.cfg",ntmp,r_inputs->value);
562	if(conf_read(conf_file,m)==2){
563	errorException(NULL, _("Unable to load the main.cfg file."),"InternalError");
564	free(m);
565	return 1;
566	}
567	#ifdef DEBUG
568	fprintf(stderr, "***** BEGIN MAPS\n");
569	dumpMaps(m);
570	fprintf(stderr, "***** END MAPS\n");
571	#endif
572
573	map *getPath=getMapFromMaps(m,"main","gettextPath");
574	if(getPath!=NULL){
575	bindtextdomain ("zoo-kernel",getPath->value);
576	bindtextdomain ("zoo-services",getPath->value);
577	}else{
578	bindtextdomain ("zoo-kernel","/usr/share/locale/");
579	bindtextdomain ("zoo-services","/usr/share/locale/");
580	}
581
582
583	/**
584	* Manage our own error log file (usefull to separate standard apache debug
585	* messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
586	* headers messages returned by the CGI due to wrong redirection of stderr)
587	*/
588	FILE * fstde=NULL;
589	map* fstdem=getMapFromMaps(m,"main","logPath");
590	if(fstdem!=NULL)
591	fstde = freopen(fstdem->value, "a+", stderr) ;
592
593	r_inputs=getMap(request_inputs,"language");
594	if(r_inputs==NULL)
595	r_inputs=getMapFromMaps(m,"main","language");
596	if(r_inputs!=NULL){
597	char *tmp=strdup(r_inputs->value);
598	setMapInMaps(m,"main","language",tmp);
599	translateChar(tmp,'-','_');
600	setlocale (LC_ALL, tmp);
601	#ifdef WIN32
602	char tmp1[12];
603	sprintf(tmp1,"LC_ALL=%s",tmp);
604	putenv(tmp1);
605	#endif
606	free(tmp);
607	}
608	else{
609	setlocale (LC_ALL, "en_US");
610	#ifdef WIN32
611	char tmp1[12];
612	sprintf(tmp1,"LC_ALL=en_US");
613	putenv(tmp1);
614	#endif
615	setMapInMaps(m,"main","language","en-US");
616	}
617	setlocale (LC_NUMERIC, "en_US");
618	bind_textdomain_codeset("zoo-kernel","UTF-8");
619	textdomain("zoo-kernel");
620	bind_textdomain_codeset("zoo-services","UTF-8");
621	textdomain("zoo-services");
622
623	map* lsoap=getMap(request_inputs,"soap");
624	if(lsoap!=NULL && strcasecmp(lsoap->value,"true")==0)
625	setMapInMaps(m,"main","isSoap","true");
626	else
627	setMapInMaps(m,"main","isSoap","false");
628
629
630	/**
631	* Check for minimum inputs
632	*/
633	r_inputs=getMap(request_inputs,"Request");
634	if(request_inputs==NULL \|\| r_inputs==NULL){
635	errorException(m, _("Parameter <request> was not specified"),"MissingParameterValue");
636	freeMaps(&m);
637	free(m);
638	freeMap(&request_inputs);
639	free(request_inputs);
640	return 1;
641	}
642	else{
643	REQUEST=strdup(r_inputs->value);
644	if(strncasecmp(r_inputs->value,"GetCapabilities",15)!=0
645	&& strncasecmp(r_inputs->value,"DescribeProcess",15)!=0
646	&& strncasecmp(r_inputs->value,"Execute",7)!=0){
647	errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
648	freeMaps(&m);
649	free(m);
650	free(REQUEST);
651	return 1;
652	}
653	}
654	r_inputs=NULL;
655	r_inputs=getMap(request_inputs,"Service");
656	if(r_inputs==NULLMAP){
657	errorException(m, _("Parameter <service> was not specified"),"MissingParameterValue");
658	freeMaps(&m);
659	free(m);
660	free(REQUEST);
661	return 1;
662	}
663	if(strncasecmp(REQUEST,"GetCapabilities",15)!=0){
664	r_inputs=getMap(request_inputs,"Version");
665	if(r_inputs==NULL){
666	errorException(m, _("Parameter <version> was not specified"),"MissingParameterValue");
667	freeMaps(&m);
668	free(m);
669	free(REQUEST);
670	return 1;
671	}
672	}
673
674	r_inputs=getMap(request_inputs,"serviceprovider");
675	if(r_inputs==NULL){
676	addToMap(request_inputs,"serviceprovider","");
677	}
678
679	maps* request_output_real_format=NULL;
680	map* tmpm=getMapFromMaps(m,"main","serverAddress");
681	if(tmpm!=NULL)
682	SERVICE_URL=strdup(tmpm->value);
683	else
684	SERVICE_URL=strdup(DEFAULT_SERVICE_URL);
685
686	service* s1;
687	int scount=0;
688	#ifdef DEBUG
689	dumpMap(r_inputs);
690	#endif
691	char conf_dir[1024];
692	int t;
693	char tmps1[1024];
694
695	r_inputs=NULL;
696	r_inputs=getMap(request_inputs,"metapath");
697	if(r_inputs!=NULL)
698	snprintf(conf_dir,1024,"%s/%s",ntmp,r_inputs->value);
699	else
700	snprintf(conf_dir,1024,"%s",ntmp);
701
702	if(strncasecmp(REQUEST,"GetCapabilities",15)==0){
703	struct dirent *dp;
704	#ifdef DEBUG
705	dumpMap(r_inputs);
706	#endif
707	DIR *dirp = opendir(conf_dir);
708	if(dirp==NULL){
709	return errorException(m, _("The specified path doesn't exist."),"InvalidParameterValue");
710	}
711	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
712	r_inputs=NULL;
713	r_inputs=getMap(request_inputs,"ServiceProvider");
714	xmlNodePtr n;
715	if(r_inputs!=NULL)
716	n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
717	else
718	n = printGetCapabilitiesHeader(doc,"",m);
719	/**
720	* Here we need to close stdout to ensure that not supported chars
721	* has been found in the zcfg and then printed on stdout
722	*/
723	int saved_stdout = dup(fileno(stdout));
724	dup2(fileno(stderr),fileno(stdout));
725	while ((dp = readdir(dirp)) != NULL)
726	if(strstr(dp->d_name,".zcfg")!=0){
727	memset(tmps1,0,1024);
728	snprintf(tmps1,1024,"%s/%s",conf_dir,dp->d_name);
729	s1=(service*)malloc(SERVICE_SIZE);
730	if(s1 == NULL){
731	return errorException(m, _("Unable to allocate memory."),"InternalError");
732	}
733	#ifdef DEBUG
734	fprintf(stderr,"#################\n%s\n#################\n",tmps1);
735	#endif
736	t=getServiceFromFile(tmps1,&s1);
737	#ifdef DEBUG
738	dumpService(s1);
739	fflush(stdout);
740	fflush(stderr);
741	#endif
742	printGetCapabilitiesForProcess(m,n,s1);
743	freeService(&s1);
744	free(s1);
745	scount++;
746	}
747	(void)closedir(dirp);
748	fflush(stdout);
749	dup2(saved_stdout,fileno(stdout));
750	printDocument(m,doc,getpid());
751	freeMaps(&m);
752	free(m);
753	free(REQUEST);
754	free(SERVICE_URL);
755	fflush(stdout);
756	return 0;
757	}
758	else{
759	r_inputs=getMap(request_inputs,"Identifier");
760	if(r_inputs==NULL
761	\|\| strlen(r_inputs->name)==0 \|\| strlen(r_inputs->value)==0){
762	errorException(m, _("Mandatory <identifier> was not specified"),"MissingParameterValue");
763	freeMaps(&m);
764	free(m);
765	free(REQUEST);
766	free(SERVICE_URL);
767	return 0;
768	}
769
770	struct dirent *dp;
771	DIR *dirp = opendir(conf_dir);
772	if(dirp==NULL){
773	errorException(m, _("The specified path path doesn't exist."),"InvalidParameterValue");
774	freeMaps(&m);
775	free(m);
776	free(REQUEST);
777	free(SERVICE_URL);
778	return 0;
779	}
780	if(strncasecmp(REQUEST,"DescribeProcess",15)==0){
781	/**
782	* Loop over Identifier list
783	*/
784	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
785	r_inputs=NULL;
786	r_inputs=getMap(request_inputs,"ServiceProvider");
787
788	xmlNodePtr n;
789	if(r_inputs!=NULL)
790	n = printDescribeProcessHeader(doc,r_inputs->value,m);
791	else
792	n = printDescribeProcessHeader(doc,"",m);
793
794	r_inputs=getMap(request_inputs,"Identifier");
795	char *tmps=strtok(r_inputs->value,",");
796
797	char buff[256];
798	char buff1[1024];
799	int saved_stdout = dup(fileno(stdout));
800	dup2(fileno(stderr),fileno(stdout));
801	while(tmps){
802	memset(buff,0,256);
803	snprintf(buff,256,"%s.zcfg",tmps);
804	memset(buff1,0,1024);
805	#ifdef DEBUG
806	printf("\n#######%s\n########\n",buff1);
807	#endif
808	while ((dp = readdir(dirp)) != NULL)
809	if((strcasecmp("all.zcfg",buff)==0 && strstr(dp->d_name,".zcfg")>0)
810	\|\| strcasecmp(dp->d_name,buff)==0){
811	memset(buff1,0,1024);
812	snprintf(buff1,1024,"%s/%s",conf_dir,dp->d_name);
813	s1=(service*)malloc(SERVICE_SIZE);
814	if(s1 == NULL){
815	dup2(saved_stdout,fileno(stdout));
816	return errorException(m, _("Unable to allocate memory."),"InternalError");
817	}
818	#ifdef DEBUG
819	printf("#################\n%s\n#################\n",buff1);
820	#endif
821	t=getServiceFromFile(buff1,&s1);
822	#ifdef DEBUG
823	dumpService(s1);
824	#endif
825	printDescribeProcessForProcess(m,n,s1,1);
826	freeService(&s1);
827	free(s1);
828	scount++;
829	}
830	rewinddir(dirp);
831	tmps=strtok(NULL,",");
832	}
833	closedir(dirp);
834	fflush(stdout);
835	dup2(saved_stdout,fileno(stdout));
836	printDocument(m,doc,getpid());
837	freeMaps(&m);
838	free(m);
839	free(REQUEST);
840	free(SERVICE_URL);
841	fflush(stdout);
842	return 0;
843	}
844	else
845	if(strncasecmp(REQUEST,"Execute",strlen(REQUEST))!=0){
846	errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
847	#ifdef DEBUG
848	fprintf(stderr,"No request found %s",REQUEST);
849	#endif
850	closedir(dirp);
851	freeMaps(&m);
852	free(m);
853	free(REQUEST);
854	free(SERVICE_URL);
855	fflush(stdout);
856	return 0;
857	}
858	closedir(dirp);
859	}
860
861	s1=NULL;
862	s1=(service*)malloc(SERVICE_SIZE);
863	if(s1 == NULL){
864	freeMaps(&m);
865	free(m);
866	free(REQUEST);
867	free(SERVICE_URL);
868	return errorException(m, _("Unable to allocate memory."),"InternalError");
869	}
870	r_inputs=getMap(request_inputs,"MetaPath");
871	if(r_inputs!=NULL)
872	snprintf(tmps1,1024,"%s/%s",ntmp,r_inputs->value);
873	else
874	snprintf(tmps1,1024,"%s/",ntmp);
875	r_inputs=getMap(request_inputs,"Identifier");
876	char *ttmp=strdup(tmps1);
877	snprintf(tmps1,1024,"%s/%s.zcfg",ttmp,r_inputs->value);
878	free(ttmp);
879	#ifdef DEBUG
880	fprintf(stderr,"Trying to load %s\n", tmps1);
881	#endif
882	int saved_stdout = dup(fileno(stdout));
883	dup2(fileno(stderr),fileno(stdout));
884	t=getServiceFromFile(tmps1,&s1);
885	fflush(stdout);
886	dup2(saved_stdout,fileno(stdout));
887	if(t<0){
888	char tmpMsg=(char)malloc(2048+strlen(r_inputs->value));
889
890	sprintf(tmpMsg,_("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),r_inputs->value);
891	errorException(m, tmpMsg, "InvalidParameterValue");
892	free(tmpMsg);
893	free(s1);
894	freeMaps(&m);
895	free(m);
896	free(REQUEST);
897	free(SERVICE_URL);
898	return 0;
899	}
900	close(saved_stdout);
901
902	#ifdef DEBUG
903	dumpService(s1);
904	#endif
905	int j;
906
907
908	/**
909	* Create the input and output maps data structure
910	*/
911	int i=0;
912	HINTERNET hInternet;
913	HINTERNET res;
914	hInternet=InternetOpen(
915	#ifndef WIN32
916	(LPCTSTR)
917	#endif
918	"ZooWPSClient\0",
919	INTERNET_OPEN_TYPE_PRECONFIG,
920	NULL,NULL, 0);
921
922	#ifndef WIN32
923	if(!CHECK_INET_HANDLE(hInternet))
924	fprintf(stderr,"WARNING : hInternet handle failed to initialize");
925	#endif
926	maps* request_input_real_format=NULL;
927	maps* tmpmaps = request_input_real_format;
928	map* postRequest=NULL;
929	postRequest=getMap(request_inputs,"xrequest");
930	if(postRequest==NULLMAP){
931	/**
932	* Parsing outputs provided as KVP
933	*/
934	r_inputs=NULL;
935	#ifdef DEBUG
936	fprintf(stderr,"OUTPUT Parsing ... \n");
937	#endif
938	r_inputs=getMap(request_inputs,"ResponseDocument");
939	if(r_inputs==NULL) r_inputs=getMap(request_inputs,"RawDataOutput");
940
941	#ifdef DEBUG
942	fprintf(stderr,"OUTPUT Parsing ... \n");
943	#endif
944	if(r_inputs!=NULL){
945	#ifdef DEBUG
946	fprintf(stderr,"OUTPUT Parsing start now ... \n");
947	#endif
948	char cursor_output[10240];
949	char *cotmp=strdup(r_inputs->value);
950	snprintf(cursor_output,10240,"%s",cotmp);
951	free(cotmp);
952	j=0;
953
954	/**
955	* Put each Output into the outputs_as_text array
956	*/
957	char * pToken;
958	maps* tmp_output=NULL;
959	#ifdef DEBUG
960	fprintf(stderr,"OUTPUT [%s]\n",cursor_output);
961	#endif
962	pToken=strtok(cursor_output,";");
963	char outputs_as_text=(char)malloc(128sizeof(char));
964	if(outputs_as_text == NULL) {
965	return errorException(m, _("Unable to allocate memory"), "InternalError");
966	}
967	i=0;
968	while(pToken!=NULL){
969	#ifdef DEBUG
970	fprintf(stderr,"*%s*\n",pToken);
971	fflush(stderr);
972	fprintf(stderr,"*%s*\n",pToken);
973	#endif
974	outputs_as_text[i]=(char)malloc((strlen(pToken)+1)sizeof(char));
975	if(outputs_as_text[i] == NULL) {
976	return errorException(m, _("Unable to allocate memory"), "InternalError");
977	}
978	snprintf(outputs_as_text[i],strlen(pToken)+1,"%s",pToken);
979	pToken = strtok(NULL,";");
980	i++;
981	}
982	for(j=0;j<i;j++){
983	char *tmp=strdup(outputs_as_text[j]);
984	free(outputs_as_text[j]);
985	char *tmpc;
986	tmpc=strtok(tmp,"@");
987	int k=0;
988	while(tmpc!=NULL){
989	if(k==0){
990	if(tmp_output==NULL){
991	tmp_output=(maps*)malloc(MAPS_SIZE);
992	if(tmp_output == NULL){
993	return errorException(m, _("Unable to allocate memory."), "InternalError");
994	}
995	tmp_output->name=strdup(tmpc);
996	tmp_output->content=NULL;
997	tmp_output->next=NULL;
998	}
999	}
1000	else{
1001	char *tmpv=strstr(tmpc,"=");
1002	char tmpn[256];
1003	memset(tmpn,0,256);
1004	strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
1005	tmpn[strlen(tmpc)-strlen(tmpv)]=0;
1006	#ifdef DEBUG
1007	fprintf(stderr,"OUTPUT DEF [%s]=[%s]\n",tmpn,tmpv+1);
1008	#endif
1009	if(tmp_output->content==NULL){
1010	tmp_output->content=createMap(tmpn,tmpv+1);
1011	tmp_output->content->next=NULL;
1012	}
1013	else
1014	addToMap(tmp_output->content,tmpn,tmpv+1);
1015	}
1016	k++;
1017	#ifdef DEBUG
1018	fprintf(stderr,"*%s*\n",tmpc);
1019	#endif
1020	tmpc=strtok(NULL,"@");
1021	}
1022	if(request_output_real_format==NULL)
1023	request_output_real_format=dupMaps(&tmp_output);
1024	else
1025	addMapsToMaps(&request_output_real_format,tmp_output);
1026	freeMaps(&tmp_output);
1027	free(tmp_output);
1028	tmp_output=NULL;
1029	#ifdef DEBUG
1030	dumpMaps(tmp_output);
1031	fflush(stderr);
1032	#endif
1033	free(tmp);
1034	}
1035	free(outputs_as_text);
1036	}
1037
1038
1039	/**
1040	* Parsing inputs provided as KVP
1041	*/
1042	r_inputs=getMap(request_inputs,"DataInputs");
1043	#ifdef DEBUG
1044	fprintf(stderr,"DATA INPUTS [%s]\n",r_inputs->value);
1045	#endif
1046	char cursor_input[40960];
1047	if(r_inputs!=NULL)
1048	snprintf(cursor_input,40960,"%s",r_inputs->value);
1049	else{
1050	errorException(m, _("Parameter <DataInputs> was not specified"),"MissingParameterValue");
1051	freeMaps(&m);
1052	free(m);
1053	free(REQUEST);
1054	free(SERVICE_URL);
1055	InternetCloseHandle(hInternet);
1056	freeService(&s1);
1057	free(s1);
1058	return 0;
1059	}
1060	j=0;
1061
1062	/**
1063	* Put each DataInputs into the inputs_as_text array
1064	*/
1065	char *tmp1=strdup(cursor_input);
1066	char * pToken;
1067	pToken=strtok(cursor_input,";");
1068	if(pToken!=NULL && strncasecmp(pToken,tmp1,strlen(tmp1))==0){
1069	char* tmp2=url_decode(tmp1);
1070	snprintf(cursor_input,(strlen(tmp2)+1)*sizeof(char),"%s",tmp2);
1071	free(tmp2);
1072	pToken=strtok(cursor_input,";");
1073	}
1074	free(tmp1);
1075
1076	char inputs_as_text=(char)malloc(100sizeof(char));
1077	if(inputs_as_text == NULL){
1078	return errorException(m, _("Unable to allocate memory."), "InternalError");
1079	}
1080	i=0;
1081	while(pToken!=NULL){
1082	#ifdef DEBUG
1083	fprintf(stderr,"*%s*\n",pToken);
1084	#endif
1085	fflush(stderr);
1086	#ifdef DEBUG
1087	fprintf(stderr,"*%s*\n",pToken);
1088	#endif
1089	inputs_as_text[i]=(char)malloc((strlen(pToken)+1)sizeof(char));
1090	snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
1091	if(inputs_as_text[i] == NULL){
1092	return errorException(m, _("Unable to allocate memory."), "InternalError");
1093	}
1094	pToken = strtok(NULL,";");
1095	i++;
1096	}
1097
1098	for(j=0;j<i;j++){
1099	char *tmp=strdup(inputs_as_text[j]);
1100	free(inputs_as_text[j]);
1101	char *tmpc;
1102	tmpc=strtok(tmp,"@");
1103	while(tmpc!=NULL){
1104	#ifdef DEBUG
1105	fprintf(stderr,"*\n%s**\n",tmpc);
1106	#endif
1107	char *tmpv=strstr(tmpc,"=");
1108	char tmpn[256];
1109	memset(tmpn,0,256);
1110	if(tmpv!=NULL){
1111	strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
1112	tmpn[strlen(tmpc)-strlen(tmpv)]=0;
1113	}
1114	else{
1115	strncpy(tmpn,tmpc,strlen(tmpc)*sizeof(char));
1116	tmpn[strlen(tmpc)]=0;
1117	}
1118	#ifdef DEBUG
1119	fprintf(stderr,"*\n* %s = %s ***\n",tmpn,tmpv+1);
1120	#endif
1121	if(tmpmaps==NULL){
1122	tmpmaps=(maps*)malloc(MAPS_SIZE);
1123	if(tmpmaps == NULL){
1124	return errorException(m, _("Unable to allocate memory."), "InternalError");
1125	}
1126	tmpmaps->name=strdup(tmpn);
1127	if(tmpv!=NULL){
1128	char *tmpvf=url_decode(tmpv+1);
1129	tmpmaps->content=createMap("value",tmpvf);
1130	free(tmpvf);
1131	}
1132	else
1133	tmpmaps->content=createMap("value","Reference");
1134	tmpmaps->next=NULL;
1135	}
1136	tmpc=strtok(NULL,"@");
1137	while(tmpc!=NULL){
1138	#ifdef DEBUG
1139	fprintf(stderr,"* KVP NON URL-ENCODED \n%s**\n",tmpc);
1140	#endif
1141	char *tmpv1=strstr(tmpc,"=");
1142	#ifdef DEBUG
1143	fprintf(stderr,"* VALUE NON URL-ENCODED \n%s**\n",tmpv1+1);
1144	#endif
1145	char tmpn1[1024];
1146	memset(tmpn1,0,1024);
1147	if(tmpv1!=NULL){
1148	strncpy(tmpn1,tmpc,strlen(tmpc)-strlen(tmpv1));
1149	tmpn1[strlen(tmpc)-strlen(tmpv1)]=0;
1150	addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1151	}
1152	else{
1153	strncpy(tmpn1,tmpc,strlen(tmpc));
1154	tmpn1[strlen(tmpc)]=0;
1155	map* lmap=getLastMap(tmpmaps->content);
1156	char tmpValue=(char)malloc((strlen(tmpv)+strlen(tmpc)+1)*sizeof(char));
1157	sprintf(tmpValue,"%s@%s",tmpv+1,tmpc);
1158	free(lmap->value);
1159	lmap->value=strdup(tmpValue);
1160	free(tmpValue);
1161	tmpc=strtok(NULL,"@");
1162	continue;
1163	}
1164	#ifdef DEBUG
1165	fprintf(stderr,"* NAME NON URL-ENCODED \n%s**\n",tmpn1);
1166	fprintf(stderr,"* VALUE NON URL-ENCODED \n%s**\n",tmpv1+1);
1167	#endif
1168	if(strcmp(tmpn1,"xlink:href")!=0)
1169	addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1170	else
1171	if(tmpv1!=NULL){
1172	char *tmpx2=url_decode(tmpv1+1);
1173	if(strncasecmp(tmpx2,"http://",7)!=0 &&
1174	strncasecmp(tmpx2,"ftp://",6)!=0){
1175	char emsg[1024];
1176	sprintf(emsg,_("Unable to find a valid protocol to download the remote file %s"),tmpv1+1);
1177	errorException(m,emsg,"InternalError");
1178	freeMaps(&m);
1179	free(m);
1180	free(REQUEST);
1181	free(SERVICE_URL);
1182	InternetCloseHandle(hInternet);
1183	freeService(&s1);
1184	free(s1);
1185	return 0;
1186	}
1187	#ifdef DEBUG
1188	fprintf(stderr,"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",tmpv1+1);
1189	#endif
1190	addToMap(tmpmaps->content,tmpn1,tmpx2);
1191
1192	#ifndef WIN32
1193	if(CHECK_INET_HANDLE(hInternet))
1194	#endif
1195	{
1196	if(loadRemoteFile(m,tmpmaps->content,hInternet,tmpx2)<0){
1197	freeMaps(&m);
1198	free(m);
1199	free(REQUEST);
1200	free(SERVICE_URL);
1201	InternetCloseHandle(hInternet);
1202	freeService(&s1);
1203	free(s1);
1204	return 0;
1205	}
1206	}
1207	free(tmpx2);
1208	addToMap(tmpmaps->content,"Reference",tmpv1+1);
1209	}
1210	tmpc=strtok(NULL,"@");
1211	}
1212	#ifdef DEBUG
1213	dumpMaps(tmpmaps);
1214	fflush(stderr);
1215	#endif
1216	if(request_input_real_format==NULL)
1217	request_input_real_format=dupMaps(&tmpmaps);
1218	else{
1219	maps* testPresence=getMaps(request_input_real_format,tmpmaps->name);
1220	if(testPresence!=NULL){
1221	elements* elem=getElements(s1->inputs,tmpmaps->name);
1222	if(elem!=NULL){
1223	if(appendMapsToMaps(m,request_input_real_format,tmpmaps,elem)<0){
1224	freeMaps(&m);
1225	free(m);
1226	free(REQUEST);
1227	free(SERVICE_URL);
1228	InternetCloseHandle(hInternet);
1229	freeService(&s1);
1230	free(s1);
1231	return 0;
1232	}
1233	}
1234	}
1235	else
1236	addMapsToMaps(&request_input_real_format,tmpmaps);
1237	}
1238	freeMaps(&tmpmaps);
1239	free(tmpmaps);
1240	tmpmaps=NULL;
1241	free(tmp);
1242	}
1243	}
1244	free(inputs_as_text);
1245	}
1246	else {
1247	/**
1248	* Parse XML request
1249	*/
1250	xmlInitParser();
1251	#ifdef DEBUG
1252	fflush(stderr);
1253	fprintf(stderr,"BEFORE %s\n",postRequest->value);
1254	fflush(stderr);
1255	#endif
1256	xmlDocPtr doc =
1257	xmlParseMemory(postRequest->value,cgiContentLength);
1258	#ifdef DEBUG
1259	fprintf(stderr,"AFTER\n");
1260	fflush(stderr);
1261	#endif
1262	/**
1263	* Parse every Input in DataInputs node.
1264	*/
1265	xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"///*[local-name()='Input']");
1266	xmlNodeSet* tmps=tmpsptr->nodesetval;
1267	#ifdef DEBUG
1268	fprintf(stderr,"***%d***\n",tmps->nodeNr);
1269	#endif
1270	for(int k=0;k<tmps->nodeNr;k++){
1271	maps *tmpmaps=NULL;
1272	xmlNodePtr cur=tmps->nodeTab[k];
1273	if(tmps->nodeTab[k]->type == XML_ELEMENT_NODE) {
1274	/**
1275	* A specific Input node.
1276	*/
1277	#ifdef DEBUG
1278	fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
1279	#endif
1280	xmlNodePtr cur2=cur->children;
1281	while(cur2!=NULL){
1282	while(cur2!=NULL && cur2->type!=XML_ELEMENT_NODE)
1283	cur2=cur2->next;
1284	if(cur2==NULL)
1285	break;
1286	/**
1287	* Indentifier
1288	*/
1289	if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1290	xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1291	if(tmpmaps==NULL){
1292	tmpmaps=(maps*)malloc(MAPS_SIZE);
1293	if(tmpmaps == NULL){
1294	return errorException(m, _("Unable to allocate memory."), "InternalError");
1295	}
1296	tmpmaps->name=strdup((char*)val);
1297	tmpmaps->content=NULL;
1298	tmpmaps->next=NULL;
1299	}
1300	xmlFree(val);
1301	}
1302	/**
1303	* Title, Asbtract
1304	*/
1305	if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 \|\|
1306	xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1307	xmlChar *val=
1308	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1309	if(tmpmaps==NULL){
1310	tmpmaps=(maps*)malloc(MAPS_SIZE);
1311	if(tmpmaps == NULL){
1312	return errorException(m, _("Unable to allocate memory."), "InternalError");
1313	}
1314	tmpmaps->name=strdup("missingIndetifier");
1315	tmpmaps->content=createMap((char)cur2->name,(char)val);
1316	tmpmaps->next=NULL;
1317	}
1318	else{
1319	if(tmpmaps->content!=NULL)
1320	addToMap(tmpmaps->content,
1321	(char)cur2->name,(char)val);
1322	else
1323	tmpmaps->content=
1324	createMap((char)cur2->name,(char)val);
1325	}
1326	#ifdef DEBUG
1327	dumpMaps(tmpmaps);
1328	#endif
1329	xmlFree(val);
1330	}
1331	/**
1332	* InputDataFormChoice (Reference or Data ?)
1333	*/
1334	if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
1335	/**
1336	* Get every attribute from a Reference node
1337	* mimeType, encoding, schema, href, method
1338	* Header and Body gesture should be added here
1339	*/
1340	#ifdef DEBUG
1341	fprintf(stderr,"REFERENCE\n");
1342	#endif
1343	const char *refs[5]={"mimeType","encoding","schema","method","href"};
1344	for(int l=0;l<5;l++){
1345	#ifdef DEBUG
1346	fprintf(stderr,"* %s *",refs[l]);
1347	#endif
1348	xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
1349	if(val!=NULL && xmlStrlen(val)>0){
1350	if(tmpmaps->content!=NULL)
1351	addToMap(tmpmaps->content,refs[l],(char*)val);
1352	else
1353	tmpmaps->content=createMap(refs[l],(char*)val);
1354	map* ltmp=getMap(tmpmaps->content,"method");
1355	if(l==4){
1356	if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
1357	&& CHECK_INET_HANDLE(hInternet)){
1358	if(loadRemoteFile(m,tmpmaps->content,hInternet,(char*)val)!=0){
1359	freeMaps(&m);
1360	free(m);
1361	free(REQUEST);
1362	free(SERVICE_URL);
1363	InternetCloseHandle(hInternet);
1364	freeService(&s1);
1365	free(s1);
1366	return 0;
1367	}
1368	}
1369	}
1370	}
1371	#ifdef DEBUG
1372	fprintf(stderr,"%s\n",val);
1373	#endif
1374	xmlFree(val);
1375	}
1376	#ifdef POST_DEBUG
1377	fprintf(stderr,"Parse Header and Body from Reference \n");
1378	#endif
1379	xmlNodePtr cur3=cur2->children;
1380	hInternet.header=NULL;
1381	while(cur3){
1382	while(cur3!=NULL && cur3->type!=XML_ELEMENT_NODE)
1383	cur2=cur3->next;
1384	if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
1385	const char *ha[2];
1386	ha[0]="key";
1387	ha[1]="value";
1388	int hai;
1389	char *has;
1390	char *key;
1391	for(hai=0;hai<2;hai++){
1392	xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
1393	#ifdef POST_DEBUG
1394	fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
1395	#endif
1396	if(hai==0){
1397	key=(char)malloc((1+strlen((char)val))*sizeof(char));
1398	snprintf(key,1+strlen((char)val),"%s",(char)val);
1399	}else{
1400	has=(char)malloc((3+strlen((char)val)+strlen(key))*sizeof(char));
1401	if(has == NULL){
1402	return errorException(m, _("Unable to allocate memory."), "InternalError");
1403	}
1404	snprintf(has,(3+strlen((char)val)+strlen(key)),"%s: %s",key,(char)val);
1405	#ifdef POST_DEBUG
1406	fprintf(stderr,"%s\n",has);
1407	#endif
1408	}
1409	}
1410	hInternet.header=curl_slist_append(hInternet.header, has);
1411	free(has);
1412	}
1413	else{
1414	#ifdef POST_DEBUG
1415	fprintf(stderr,"Try to fetch the body part of the request ...\n");
1416	#endif
1417	if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
1418	#ifdef POST_DEBUG
1419	fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
1420	#endif
1421	char *tmp=new char[cgiContentLength];
1422	memset(tmp,0,cgiContentLength);
1423	xmlNodePtr cur4=cur3->children;
1424	while(cur4!=NULL){
1425	while(cur4->type!=XML_ELEMENT_NODE)
1426	cur4=cur4->next;
1427	xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
1428	bdoc->encoding = xmlCharStrdup ("UTF-8");
1429	xmlDocSetRootElement(bdoc,cur4);
1430	xmlChar* btmps;
1431	int bsize;
1432	xmlDocDumpMemory(bdoc,&btmps,&bsize);
1433	#ifdef POST_DEBUG
1434	fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
1435	#endif
1436	if(btmps!=NULL)
1437	sprintf(tmp,"%s",(char*)btmps);
1438	xmlFreeDoc(bdoc);
1439	cur4=cur4->next;
1440	}
1441	map *btmp=getMap(tmpmaps->content,"href");
1442	if(btmp!=NULL){
1443	#ifdef POST_DEBUG
1444	fprintf(stderr,"%s %s\n",btmp->value,tmp);
1445	curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1446	#endif
1447	res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
1448	INTERNET_FLAG_NO_CACHE_WRITE,0);
1449	char* tmpContent = (char)malloc((res.nDataLen+1)sizeof(char));
1450	if(tmpContent == NULL){
1451	return errorException(m, _("Unable to allocate memory."), "InternalError");
1452	}
1453	size_t dwRead;
1454	InternetReadFile(res, (LPVOID)tmpContent,
1455	res.nDataLen, &dwRead);
1456	tmpContent[res.nDataLen]=0;
1457	if(hInternet.header!=NULL)
1458	curl_slist_free_all(hInternet.header);
1459	addToMap(tmpmaps->content,"value",tmpContent);
1460	#ifdef POST_DEBUG
1461	fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1462	#endif
1463	}
1464	}
1465	else
1466	if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
1467	xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
1468	HINTERNET bInternet,res1;
1469	bInternet=InternetOpen(
1470	#ifndef WIN32
1471	(LPCTSTR)
1472	#endif
1473	"ZooWPSClient\0",
1474	INTERNET_OPEN_TYPE_PRECONFIG,
1475	NULL,NULL, 0);
1476	if(!CHECK_INET_HANDLE(bInternet))
1477	fprintf(stderr,"WARNING : hInternet handle failed to initialize");
1478	#ifdef POST_DEBUG
1479	curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
1480	#endif
1481	res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
1482	INTERNET_FLAG_NO_CACHE_WRITE,0);
1483	char* tmp=
1484	(char)malloc((res1.nDataLen+1)sizeof(char));
1485	if(tmp == NULL){
1486	return errorException(m, _("Unable to allocate memory."), "InternalError");
1487	}
1488	size_t bRead;
1489	InternetReadFile(res1, (LPVOID)tmp,
1490	res1.nDataLen, &bRead);
1491	tmp[res1.nDataLen]=0;
1492	InternetCloseHandle(bInternet);
1493	map *btmp=getMap(tmpmaps->content,"href");
1494	if(btmp!=NULL){
1495	#ifdef POST_DEBUG
1496	fprintf(stderr,"%s %s\n",btmp->value,tmp);
1497	curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1498	#endif
1499	res=InternetOpenUrl(hInternet,btmp->value,tmp,
1500	strlen(tmp),
1501	INTERNET_FLAG_NO_CACHE_WRITE,0);
1502	char* tmpContent = (char)malloc((res.nDataLen+1)sizeof(char));
1503	if(tmpContent == NULL){
1504	return errorException(m, _("Unable to allocate memory."), "InternalError");
1505	}
1506	size_t dwRead;
1507	InternetReadFile(res, (LPVOID)tmpContent,
1508	res.nDataLen, &dwRead);
1509	tmpContent[res.nDataLen]=0;
1510	if(hInternet.header!=NULL)
1511	curl_slist_free_all(hInternet.header);
1512	addToMap(tmpmaps->content,"value",tmpContent);
1513	#ifdef POST_DEBUG
1514	fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1515	#endif
1516	}
1517	}
1518	}
1519	cur3=cur3->next;
1520	}
1521	#ifdef POST_DEBUG
1522	fprintf(stderr,"Header and Body was parsed from Reference \n");
1523	#endif
1524	#ifdef DEBUG
1525	dumpMap(tmpmaps->content);
1526	fprintf(stderr, "= element 2 node \"%s\" = (%s)\n",
1527	cur2->name,cur2->content);
1528	#endif
1529	}
1530	else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
1531	#ifdef DEBUG
1532	fprintf(stderr,"DATA\n");
1533	#endif
1534	xmlNodePtr cur4=cur2->children;
1535	while(cur4!=NULL){
1536	while(cur4!=NULL &&cur4->type!=XML_ELEMENT_NODE)
1537	cur4=cur4->next;
1538	if(cur4==NULL)
1539	break;
1540	if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
1541	/**
1542	* Get every attribute from a LiteralData node
1543	* dataType , uom
1544	*/
1545	char *list[2];
1546	list[0]=strdup("dataType");
1547	list[1]=strdup("uom");
1548	for(int l=0;l<2;l++){
1549	#ifdef DEBUG
1550	fprintf(stderr,"* LiteralData %s *",list[l]);
1551	#endif
1552	xmlChar *val=xmlGetProp(cur4,BAD_CAST list[l]);
1553	if(val!=NULL && strlen((char*)val)>0){
1554	if(tmpmaps->content!=NULL)
1555	addToMap(tmpmaps->content,list[l],(char*)val);
1556	else
1557	tmpmaps->content=createMap(list[l],(char*)val);
1558	#ifdef DEBUG
1559	fprintf(stderr,"%s\n",val);
1560	#endif
1561	}
1562	xmlFree(val);
1563	free(list[l]);
1564	}
1565	}
1566	else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
1567	/**
1568	* Get every attribute from a Reference node
1569	* mimeType, encoding, schema
1570	*/
1571	const char *coms[3]={"mimeType","encoding","schema"};
1572	for(int l=0;l<3;l++){
1573	#ifdef DEBUG
1574	fprintf(stderr,"* ComplexData %s *\n",coms[l]);
1575	#endif
1576	xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
1577	if(val!=NULL && strlen((char*)val)>0){
1578	if(tmpmaps->content!=NULL)
1579	addToMap(tmpmaps->content,coms[l],(char*)val);
1580	else
1581	tmpmaps->content=createMap(coms[l],(char*)val);
1582	#ifdef DEBUG
1583	fprintf(stderr,"%s\n",val);
1584	#endif
1585	}
1586	xmlFree(val);
1587	}
1588	}
1589
1590	map* test=getMap(tmpmaps->content,"encoding");
1591	if(test==NULL){
1592	if(tmpmaps->content!=NULL)
1593	addToMap(tmpmaps->content,"encoding","utf-8");
1594	else
1595	tmpmaps->content=createMap("encoding","utf-8");
1596	test=getMap(tmpmaps->content,"encoding");
1597	}
1598
1599	if(strcasecmp(test->value,"base64")!=0){
1600	xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
1601	map* ltmp=getMap(tmpmaps->content,"mimeType");
1602	if(mv==NULL \|\|
1603	(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0 &&
1604	(ltmp==NULL \|\| strncasecmp(ltmp->value,"text/xml",8)==0) )){
1605	xmlDocPtr doc1=xmlNewDoc(BAD_CAST "1.0");
1606	int buffersize;
1607	xmlNodePtr cur5=cur4->children;
1608	while(cur5!=NULL &&cur5->type!=XML_ELEMENT_NODE)
1609	cur5=cur5->next;
1610	xmlDocSetRootElement(doc1,cur5);
1611	xmlDocDumpFormatMemoryEnc(doc1, &mv, &buffersize, "utf-8", 1);
1612	char size[1024];
1613	sprintf(size,"%d",buffersize);
1614	addToMap(tmpmaps->content,"size",size);
1615	}
1616	addToMap(tmpmaps->content,"value",(char*)mv);
1617	xmlFree(mv);
1618	}else{
1619	xmlChar* tmp=xmlNodeListGetRawString(doc,cur4->xmlChildrenNode,0);
1620	addToMap(tmpmaps->content,"value",(char*)tmp);
1621	map* tmpv=getMap(tmpmaps->content,"value");
1622	char *res=NULL;
1623	char *curs=tmpv->value;
1624	for(int i=0;i<=strlen(tmpv->value)/64;i++) {
1625	if(res==NULL)
1626	res=(char)malloc(67sizeof(char));
1627	else
1628	res=(char)realloc(res,(((i+1)65)+i)*sizeof(char));
1629	int csize=i*65;
1630	strncpy(res + csize,curs,64);
1631	if(i==xmlStrlen(tmp)/64)
1632	strcat(res,"\n\0");
1633	else{
1634	strncpy(res + (((i+1)*64)+i),"\n\0",2);
1635	curs+=64;
1636	}
1637	}
1638	free(tmpv->value);
1639	tmpv->value=strdup(res);
1640	free(res);
1641	xmlFree(tmp);
1642	}
1643	cur4=cur4->next;
1644	}
1645	}
1646	#ifdef DEBUG
1647	fprintf(stderr,"cur2 next \n");
1648	fflush(stderr);
1649	#endif
1650	cur2=cur2->next;
1651	}
1652	#ifdef DEBUG
1653	fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
1654	fflush(stderr);
1655	#endif
1656
1657	{
1658	maps* testPresence=getMaps(request_input_real_format,tmpmaps->name);
1659	if(testPresence!=NULL){
1660	elements* elem=getElements(s1->inputs,tmpmaps->name);
1661	if(elem!=NULL){
1662	if(appendMapsToMaps(m,request_input_real_format,tmpmaps,elem)<0){
1663	freeMaps(&m);
1664	free(m);
1665	free(REQUEST);
1666	free(SERVICE_URL);
1667	InternetCloseHandle(hInternet);
1668	freeService(&s1);
1669	free(s1);
1670	return 0;
1671	}
1672	}
1673	}
1674	else
1675	addMapsToMaps(&request_input_real_format,tmpmaps);
1676	}
1677
1678	#ifdef DEBUG
1679	fprintf(stderr,"****TMPMAPS***\n");
1680	dumpMaps(tmpmaps);
1681	fprintf(stderr,"****REQUESTMAPS***\n");
1682	dumpMaps(request_input_real_format);
1683	#endif
1684	freeMaps(&tmpmaps);
1685	free(tmpmaps);
1686	tmpmaps=NULL;
1687	}
1688	#ifdef DEBUG
1689	dumpMaps(tmpmaps);
1690	#endif
1691	}
1692	#ifdef DEBUG
1693	fprintf(stderr,"Search for response document node\n");
1694	#endif
1695	xmlXPathFreeObject(tmpsptr);
1696
1697	tmpsptr=extractFromDoc(doc,"///*[local-name()='ResponseDocument']");
1698	bool asRaw=false;
1699	tmps=tmpsptr->nodesetval;
1700	if(tmps->nodeNr==0){
1701	tmpsptr=extractFromDoc(doc,"///*[local-name()='RawDataOutput']");
1702	tmps=tmpsptr->nodesetval;
1703	asRaw=true;
1704	}
1705	#ifdef DEBUG
1706	fprintf(stderr,"***%d***\n",tmps->nodeNr);
1707	#endif
1708	for(int k=0;k<tmps->nodeNr;k++){
1709	if(asRaw==true)
1710	addToMap(request_inputs,"RawDataOutput","");
1711	else
1712	addToMap(request_inputs,"ResponseDocument","");
1713	maps *tmpmaps=NULL;
1714	xmlNodePtr cur=tmps->nodeTab[k];
1715	if(cur->type == XML_ELEMENT_NODE) {
1716	/**
1717	* A specific responseDocument node.
1718	*/
1719	if(tmpmaps==NULL){
1720	tmpmaps=(maps*)malloc(MAPS_SIZE);
1721	if(tmpmaps == NULL){
1722	return errorException(m, _("Unable to allocate memory."), "InternalError");
1723	}
1724	tmpmaps->name=strdup("unknownIdentifier");
1725	tmpmaps->content=NULL;
1726	tmpmaps->next=NULL;
1727	}
1728	/**
1729	* Get every attribute: storeExecuteResponse, lineage, status
1730	*/
1731	const char *ress[3]={"storeExecuteResponse","lineage","status"};
1732	xmlChar *val;
1733	for(int l=0;l<3;l++){
1734	#ifdef DEBUG
1735	fprintf(stderr,"* %s *\t",ress[l]);
1736	#endif
1737	val=xmlGetProp(cur,BAD_CAST ress[l]);
1738	if(val!=NULL && strlen((char*)val)>0){
1739	if(tmpmaps->content!=NULL)
1740	addToMap(tmpmaps->content,ress[l],(char*)val);
1741	else
1742	tmpmaps->content=createMap(ress[l],(char*)val);
1743	addToMap(request_inputs,ress[l],(char*)val);
1744	}
1745	#ifdef DEBUG
1746	fprintf(stderr,"%s\n",val);
1747	#endif
1748	xmlFree(val);
1749	}
1750	xmlNodePtr cur1=cur->children;
1751	while(cur1!=NULL && cur1->type != XML_ELEMENT_NODE)
1752	cur1=cur1->next;
1753	while(cur1){
1754	/**
1755	* Indentifier
1756	*/
1757	if(xmlStrncasecmp(cur1->name,BAD_CAST "Identifier",xmlStrlen(cur1->name))==0){
1758	xmlChar *val=
1759	xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1760	if(tmpmaps==NULL){
1761	tmpmaps=(maps*)malloc(MAPS_SIZE);
1762	if(tmpmaps == NULL){
1763	return errorException(m, _("Unable to allocate memory."), "InternalError");
1764	}
1765	tmpmaps->name=strdup((char*)val);
1766	tmpmaps->content=NULL;
1767	tmpmaps->next=NULL;
1768	}
1769	else{
1770	//free(tmpmaps->name);
1771	tmpmaps->name=strdup((char*)val);
1772	}
1773	xmlFree(val);
1774	}
1775	/**
1776	* Title, Asbtract
1777	*/
1778	else if(xmlStrncasecmp(cur1->name,BAD_CAST "Title",xmlStrlen(cur1->name))==0 \|\|
1779	xmlStrncasecmp(cur1->name,BAD_CAST "Abstract",xmlStrlen(cur1->name))==0){
1780	xmlChar *val=
1781	xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1782	if(tmpmaps==NULL){
1783	tmpmaps=(maps*)malloc(MAPS_SIZE);
1784	if(tmpmaps == NULL){
1785	return errorException(m, _("Unable to allocate memory."), "InternalError");
1786	}
1787	tmpmaps->name=strdup("missingIndetifier");
1788	tmpmaps->content=createMap((char)cur1->name,(char)val);
1789	tmpmaps->next=NULL;
1790	}
1791	else{
1792	if(tmpmaps->content!=NULL)
1793	addToMap(tmpmaps->content,(char)cur1->name,(char)val);
1794	else
1795	tmpmaps->content=createMap((char)cur1->name,(char)val);
1796	}
1797	xmlFree(val);
1798	}
1799	else if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
1800	/**
1801	* Get every attribute from a Output node
1802	* mimeType, encoding, schema, uom, asReference
1803	*/
1804	const char *outs[5]={"mimeType","encoding","schema","uom","asReference"};
1805	for(int l=0;l<5;l++){
1806	#ifdef DEBUG
1807	fprintf(stderr,"* %s *\t",outs[l]);
1808	#endif
1809	val=xmlGetProp(cur1,BAD_CAST outs[l]);
1810	if(val!=NULL && strlen((char*)val)>0){
1811	if(tmpmaps->content!=NULL)
1812	addToMap(tmpmaps->content,outs[l],(char*)val);
1813	else
1814	tmpmaps->content=createMap(outs[l],(char*)val);
1815	}
1816	#ifdef DEBUG
1817	fprintf(stderr,"%s\n",val);
1818	#endif
1819	xmlFree(val);
1820	}
1821	xmlNodePtr cur2=cur1->children;
1822	while(cur2!=NULL && cur2->type != XML_ELEMENT_NODE)
1823	cur2=cur2->next;
1824	while(cur2){
1825	/**
1826	* Indentifier
1827	*/
1828	if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1829	xmlChar *val=
1830	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1831	if(tmpmaps==NULL){
1832	tmpmaps=(maps*)malloc(MAPS_SIZE);
1833	if(tmpmaps == NULL){
1834	return errorException(m, _("Unable to allocate memory."), "InternalError");
1835	}
1836	tmpmaps->name=strdup((char*)val);
1837	tmpmaps->content=NULL;
1838	tmpmaps->next=NULL;
1839	}
1840	else{
1841	if(tmpmaps->name!=NULL)
1842	free(tmpmaps->name);
1843	tmpmaps->name=strdup((char*)val);;
1844	}
1845	xmlFree(val);
1846	}
1847	/**
1848	* Title, Asbtract
1849	*/
1850	else if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 \|\|
1851	xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1852	xmlChar *val=
1853	xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1854	if(tmpmaps==NULL){
1855	tmpmaps=(maps*)malloc(MAPS_SIZE);
1856	if(tmpmaps == NULL){
1857	return errorException(m, _("Unable to allocate memory."), "InternalError");
1858	}
1859	tmpmaps->name=strdup("missingIndetifier");
1860	tmpmaps->content=createMap((char)cur2->name,(char)val);
1861	tmpmaps->next=NULL;
1862	}
1863	else{
1864	if(tmpmaps->content!=NULL)
1865	addToMap(tmpmaps->content,
1866	(char)cur2->name,(char)val);
1867	else
1868	tmpmaps->content=
1869	createMap((char)cur2->name,(char)val);
1870	}
1871	xmlFree(val);
1872	}
1873	if(request_output_real_format==NULL)
1874	request_output_real_format=dupMaps(&tmpmaps);
1875	else
1876	addMapsToMaps(&request_output_real_format,tmpmaps);
1877	cur2=cur2->next;
1878	while(cur2!=NULL && cur2->type != XML_ELEMENT_NODE)
1879	cur2=cur2->next;
1880	}
1881	}
1882	cur1=cur1->next;
1883	while(cur1!=NULL && cur1->type != XML_ELEMENT_NODE)
1884	cur1=cur1->next;
1885	}
1886	}
1887	if(tmpmaps!=NULL){
1888	freeMaps(&tmpmaps);
1889	free(tmpmaps);
1890	tmpmaps=NULL;
1891	}
1892	}
1893	xmlXPathFreeObject(tmpsptr);
1894	xmlCleanupParser();
1895	}
1896
1897
1898	// if(CHECK_INET_HANDLE(hInternet))
1899	InternetCloseHandle(hInternet);
1900
1901	#ifdef DEBUG
1902	fprintf(stderr,"\n%d\n",__LINE__);
1903	fflush(stderr);
1904	dumpMaps(request_input_real_format);
1905	dumpMaps(request_output_real_format);
1906	dumpMap(request_inputs);
1907	fprintf(stderr,"\n%d\n",__LINE__);
1908	fflush(stderr);
1909	#endif
1910
1911	/**
1912	* Ensure that each requested arguments are present in the request
1913	* DataInputs and ResponseDocument / RawDataOutput
1914	*/
1915	char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,0);
1916	char *dfv1=addDefaultValues(&request_output_real_format,s1->outputs,m,1);
1917	if(strcmp(dfv1,"")!=0 \|\| strcmp(dfv,"")!=0){
1918	char tmps[1024];
1919	if(strcmp(dfv,"")!=0){
1920	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);
1921	}
1922	else if(strcmp(dfv1,"")!=0){
1923	snprintf(tmps,1024,_("The <%s> argument was specified as Output identifier but not defined in the ZOO Configuration File. Please, correct your query or the ZOO Configuration File."),dfv1);
1924	}
1925	map* tmpe=createMap("text",tmps);
1926	addToMap(tmpe,"code","MissingParameterValue");
1927	printExceptionReportResponse(m,tmpe);
1928	freeService(&s1);
1929	free(s1);
1930	freeMap(&tmpe);
1931	free(tmpe);
1932	freeMaps(&m);
1933	free(m);
1934	free(REQUEST);
1935	free(SERVICE_URL);
1936	freeMaps(&request_input_real_format);
1937	free(request_input_real_format);
1938	freeMaps(&request_output_real_format);
1939	free(request_output_real_format);
1940	freeMaps(&tmpmaps);
1941	free(tmpmaps);
1942	return 1;
1943	}
1944	maps* tmpReqI=request_input_real_format;
1945	while(tmpReqI!=NULL){
1946	char name[1024];
1947	if(getMap(tmpReqI->content,"isFile")!=NULL){
1948	if (cgiFormFileName(tmpReqI->name, name, sizeof(name)) == cgiFormSuccess) {
1949	int BufferLen=1024;
1950	cgiFilePtr file;
1951	int targetFile;
1952	mode_t mode;
1953	char storageNameOnServer[2048];
1954	char fileNameOnServer[64];
1955	char contentType[1024];
1956	char buffer[1024];
1957	char *tmpStr=NULL;
1958	int size;
1959	int got,t;
1960	map *path=getMapFromMaps(m,"main","tmpPath");
1961	cgiFormFileSize(tmpReqI->name, &size);
1962	cgiFormFileContentType(tmpReqI->name, contentType, sizeof(contentType));
1963	if (cgiFormFileOpen(tmpReqI->name, &file) == cgiFormSuccess) {
1964	t=-1;
1965	while(1){
1966	tmpStr=strstr(name+t+1,"\\");
1967	if(NULL==tmpStr)
1968	tmpStr=strstr(name+t+1,"/");
1969	if(NULL!=tmpStr)
1970	t=(int)(tmpStr-name);
1971	else
1972	break;
1973	}
1974	strcpy(fileNameOnServer,name+t+1);
1975
1976	sprintf(storageNameOnServer,"%s/%s",path->value,fileNameOnServer);
1977	#ifdef DEBUG
1978	fprintf(stderr,"Name on server %s\n",storageNameOnServer);
1979	fprintf(stderr,"fileNameOnServer: %s\n",fileNameOnServer);
1980	#endif
1981	mode=S_IRWXU\|S_IRGRP\|S_IROTH;
1982	targetFile = open (storageNameOnServer,O_RDWR\|O_CREAT\|O_TRUNC,S_IRWXU\|S_IRGRP\|S_IROTH);
1983	if(targetFile<0){
1984	#ifdef DEBUG
1985	fprintf(stderr,"could not create the new file,%s\n",fileNameOnServer);
1986	#endif
1987	}else{
1988	while (cgiFormFileRead(file, buffer, BufferLen, &got) ==cgiFormSuccess){
1989	if(got>0)
1990	write(targetFile,buffer,got);
1991	}
1992	}
1993	addToMap(tmpReqI->content,"lref",storageNameOnServer);
1994	cgiFormFileClose(file);
1995	close(targetFile);
1996	#ifdef DEBUG
1997	fprintf(stderr,"File \"%s\" has been uploaded",fileNameOnServer);
1998	#endif
1999	}
2000	}
2001	}
2002	tmpReqI=tmpReqI->next;
2003	}
2004
2005	ensureDecodedBase64(&request_input_real_format);
2006
2007	#ifdef DEBUG
2008	fprintf(stderr,"REQUEST_INPUTS\n");
2009	dumpMaps(request_input_real_format);
2010	fprintf(stderr,"REQUEST_OUTPUTS\n");
2011	dumpMaps(request_output_real_format);
2012	#endif
2013
2014	maps* curs=getMaps(m,"env");
2015	if(curs!=NULL){
2016	map* mapcs=curs->content;
2017	while(mapcs!=NULLMAP){
2018	#ifndef WIN32
2019	setenv(mapcs->name,mapcs->value,1);
2020	#else
2021	#ifdef DEBUG
2022	fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
2023	#endif
2024	if(mapcs->value[strlen(mapcs->value)-2]=='\r'){
2025	#ifdef DEBUG
2026	fprintf(stderr,"[ZOO: Env var finish with \r]\n");
2027	#endif
2028	mapcs->value[strlen(mapcs->value)-1]=0;
2029	}
2030	#ifdef DEBUG
2031	fflush(stderr);
2032	fprintf(stderr,"setting variable... %s\n",(
2033	#endif
2034	SetEnvironmentVariable(mapcs->name,mapcs->value)
2035	#ifdef DEBUG
2036	==0)? "OK" : "FAILED");
2037	#else
2038	;
2039	#endif
2040	char* toto=(char)malloc((strlen(mapcs->name)+strlen(mapcs->value)+2)sizeof(char));
2041	sprintf(toto,"%s=%s",mapcs->name,mapcs->value);
2042	putenv(toto);
2043	#ifdef DEBUG
2044	fflush(stderr);
2045	#endif
2046	#endif
2047	#ifdef DEBUG
2048	fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
2049	fflush(stderr);
2050	#endif
2051	mapcs=mapcs->next;
2052	}
2053	}
2054
2055	#ifdef DEBUG
2056	dumpMap(request_inputs);
2057	#endif
2058
2059	/**
2060	* Need to check if we need to fork to load a status enabled
2061	*/
2062	r_inputs=NULL;
2063	map* store=getMap(request_inputs,"storeExecuteResponse");
2064	map* status=getMap(request_inputs,"status");
2065	/**
2066	* 05-007r7 WPS 1.0.0 page 57 :
2067	* 'If status="true" and storeExecuteResponse is "false" then the service
2068	* shall raise an exception.'
2069	*/
2070	if(status!=NULL && strcmp(status->value,"true")==0 &&
2071	store!=NULL && strcmp(store->value,"false")==0){
2072	errorException(m, _("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."), "InvalidParameterValue");
2073	freeService(&s1);
2074	free(s1);
2075	freeMaps(&m);
2076	free(m);
2077
2078	freeMaps(&request_input_real_format);
2079	free(request_input_real_format);
2080
2081	freeMaps(&request_output_real_format);
2082	free(request_output_real_format);
2083
2084	free(REQUEST);
2085	free(SERVICE_URL);
2086	return 1;
2087	}
2088	r_inputs=getMap(request_inputs,"storeExecuteResponse");
2089	int eres=SERVICE_STARTED;
2090	int cpid=getpid();
2091
2092	maps _tmpMaps=(maps)malloc(MAPS_SIZE);
2093	_tmpMaps->name=strdup("lenv");
2094	char tmpBuff[100];
2095	sprintf(tmpBuff,"%i",cpid);
2096	_tmpMaps->content=createMap("sid",tmpBuff);
2097	_tmpMaps->next=NULL;
2098	addToMap(_tmpMaps->content,"status","0");
2099	addToMap(_tmpMaps->content,"cwd",ntmp);
2100	map* ltmp=getMap(request_inputs,"soap");
2101	if(ltmp!=NULL)
2102	addToMap(_tmpMaps->content,"soap",ltmp->value);
2103	else
2104	addToMap(_tmpMaps->content,"soap","false");
2105	if(cgiCookie!=NULL && strlen(cgiCookie)>0){
2106	int hasValidCookie=-1;
2107	char *tcook=strdup(cgiCookie);
2108	if(strstr(cgiCookie,";")!=NULL){
2109	char token,saveptr;
2110	token=strtok_r(cgiCookie,";",&saveptr);
2111	while(token!=NULL){
2112	if(strcasestr(token,"ID=")!=NULL){
2113	if(tcook!=NULL)
2114	free(tcook);
2115	tcook=strdup(token);
2116	hasValidCookie=1;
2117	}
2118	token=strtok_r(NULL,";",&saveptr);
2119	}
2120	}else{
2121	if(strstr(cgiCookie,"=")!=NULL && strcasestr(cgiCookie,"ID=")!=NULL){
2122	tcook=strdup(cgiCookie);
2123	hasValidCookie=1;
2124	}
2125	}
2126	if(hasValidCookie>0){
2127	addToMap(_tmpMaps->content,"sessid",strstr(tcook,"=")+1);
2128	char session_file_path[1024];
2129	map *tmpPath=getMapFromMaps(m,"main","sessPath");
2130	if(tmpPath==NULL)
2131	tmpPath=getMapFromMaps(m,"main","tmpPath");
2132	char *tmp1=strtok(tcook,";");
2133	if(tmp1!=NULL)
2134	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(tmp1,"=")+1);
2135	else
2136	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(cgiCookie,"=")+1);
2137	free(tcook);
2138	maps tmpSess=(maps)malloc(MAPS_SIZE);
2139	struct stat file_status;
2140	int istat = stat(session_file_path, &file_status);
2141	if(istat==0 && file_status.st_size>0){
2142	conf_read(session_file_path,tmpSess);
2143	addMapsToMaps(&m,tmpSess);
2144	freeMaps(&tmpSess);
2145	}else{
2146	errorException(m, _("Unable to read your session file."), "InternalError");
2147	free(tmpSess);
2148	freeService(&s1);
2149	free(s1);
2150	freeMaps(&m);
2151	free(m);
2152	freeMaps(&request_input_real_format);
2153	free(request_input_real_format);
2154	freeMaps(&request_output_real_format);
2155	free(request_output_real_format);
2156	free(REQUEST);
2157	free(SERVICE_URL);
2158	return 1;
2159	}
2160	free(tmpSess);
2161	}
2162	}
2163	addMapsToMaps(&m,_tmpMaps);
2164	freeMaps(&_tmpMaps);
2165	free(_tmpMaps);
2166
2167	#ifdef DEBUG
2168	dumpMap(request_inputs);
2169	#endif
2170	#ifdef WIN32
2171	char *cgiSidL=NULL;
2172	if(getenv("CGISID")!=NULL)
2173	addToMap(request_inputs,"cgiSid",getenv("CGISID"));
2174	map* test1=getMap(request_inputs,"cgiSid");
2175	if(test1!=NULL){
2176	cgiSid=test1->value;
2177	addToMap(request_inputs,"storeExecuteResponse","true");
2178	addToMap(request_inputs,"status","true");
2179	setMapInMaps(m,"lenv","sid",test1->value);
2180	status=getMap(request_inputs,"status");
2181	printf("cgiSid %s\n",cgiSid);
2182	}
2183	#endif
2184	int hrstd=-1;
2185	char fbkp,fbkp1;
2186	FILE f0,f1;
2187	if(status!=NULL)
2188	if(strcasecmp(status->value,"false")==0)
2189	status=NULLMAP;
2190	if(status==NULLMAP){
2191	loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
2192	}
2193	else{
2194	int pid;
2195	#ifdef DEBUG
2196	fprintf(stderr,"\nPID : %d\n",cpid);
2197	#endif
2198
2199	#ifndef WIN32
2200	pid = fork ();
2201	#else
2202	if(cgiSid==NULL){
2203	createProcess(m,request_inputs,s1,NULL,cpid,request_input_real_format,request_output_real_format);
2204	pid = cpid;
2205	}else{
2206	pid=0;
2207	cpid=atoi(cgiSid);
2208	printf("cgiSid %s\n",cgiSid);
2209	}
2210	//printf("pid cpid %d %d\n",pid,cpid);
2211	//fflush(stderr);
2212	#endif
2213	if (pid > 0) {
2214	/**
2215	* dady :
2216	* set status to SERVICE_ACCEPTED
2217	*/
2218	#ifdef DEBUG
2219	fprintf(stderr,"father pid continue (origin %d) %d ...\n",cpid,getpid());
2220	#endif
2221	eres=SERVICE_ACCEPTED;
2222	}else if (pid == 0) {
2223	/**
2224	* son : have to close the stdout, stdin and stderr to let the parent
2225	* process answer to http client.
2226	*/
2227	r_inputs=getMapFromMaps(m,"main","tmpPath");
2228	map* r_inputs1=getMap(s1->content,"ServiceProvider");
2229	fbkp=(char)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)sizeof(char));
2230	sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
2231	char* flog=(char)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)sizeof(char));
2232	sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
2233	#ifdef DEBUG
2234	fprintf(stderr,"RUN IN BACKGROUND MODE \n");
2235	fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
2236	fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
2237	#endif
2238	freopen(flog,"w+",stderr);
2239	f0=freopen(fbkp , "w+", stdout);
2240	fclose(stdin);
2241	free(flog);
2242	/**
2243	* set status to SERVICE_STARTED and flush stdout to ensure full
2244	* content was outputed (the file used to store the ResponseDocument).
2245	* The rewind stdout to restart writing from the bgining of the file,
2246	* this way the data will be updated at the end of the process run.
2247	*/
2248	printProcessResponse(m,request_inputs,cpid,
2249	s1,r_inputs1->value,SERVICE_STARTED,
2250	request_input_real_format,
2251	request_output_real_format);
2252	#ifndef WIN32
2253	fflush(stdout);
2254	rewind(stdout);
2255	#else
2256	#endif
2257	fbkp1=(char)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)sizeof(char));
2258	sprintf(fbkp1,"%s/%s_final_%d.xml",r_inputs->value,r_inputs1->value,cpid);
2259	f1=freopen(fbkp1 , "w+", stdout);
2260	loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
2261	} else {
2262	/**
2263	* error server don't accept the process need to output a valid
2264	* error response here !!!
2265	*/
2266	eres=-1;
2267	errorException(m, _("Unable to run the child process properly"), "InternalError");
2268	}
2269	}
2270
2271	#ifdef DEBUG
2272	dumpMaps(request_output_real_format);
2273	#endif
2274	if(eres!=-1)
2275	outputResponse(s1,request_input_real_format,
2276	request_output_real_format,request_inputs,
2277	cpid,m,eres);
2278	fflush(stdout);
2279	/**
2280	* Ensure that if error occurs when freeing memory, no signal will return
2281	* an ExceptionReport document as the result was already returned to the
2282	* client.
2283	*/
2284	#ifndef USE_GDB
2285	(void) signal(SIGSEGV,donothing);
2286	(void) signal(SIGTERM,donothing);
2287	(void) signal(SIGINT,donothing);
2288	(void) signal(SIGILL,donothing);
2289	(void) signal(SIGFPE,donothing);
2290	(void) signal(SIGABRT,donothing);
2291	#endif
2292
2293	if(((int)getpid())!=cpid){
2294	fclose(stdout);
2295	fclose(stderr);
2296	unhandleStatus(m);
2297	/**
2298	* Dump back the final file fbkp1 to fbkp
2299	*/
2300	fclose(f0);
2301	fclose(f1);
2302	FILE* f2=fopen(fbkp1,"rb");
2303	FILE* f3=fopen(fbkp,"wb+");
2304	free(fbkp);
2305	fseek(f2,0,SEEK_END);
2306	long flen=ftell(f2);
2307	fseek(f2,0,SEEK_SET);
2308	char tmps1=(char)malloc((flen+1)*sizeof(char));
2309	fread(tmps1,flen,1,f2);
2310	fwrite(tmps1,1,flen,f3);
2311	fclose(f2);
2312	fclose(f3);
2313	unlink(fbkp1);
2314	free(fbkp1);
2315	}
2316
2317	freeService(&s1);
2318	free(s1);
2319	freeMaps(&m);
2320	free(m);
2321
2322	freeMaps(&request_input_real_format);
2323	free(request_input_real_format);
2324
2325	freeMaps(&request_output_real_format);
2326	free(request_output_real_format);
2327
2328	free(REQUEST);
2329	free(SERVICE_URL);
2330	#ifdef DEBUG
2331	fprintf(stderr,"Processed response \n");
2332	fflush(stdout);
2333	fflush(stderr);
2334	#endif
2335
2336	return 0;
2337	}
2338

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links