zoo_service_loader.c @ 175

Last change on this file since 175 was 109, checked in by djay, 14 years ago
Correct void functions. Special thanks to Angelos Tzotsos for pointing this out and for his work in packaging ZOO-Project for OpenSuSE.
File size: 50.1 KB

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

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

Open WPS platform

source: branches/branch-1.2/zoo-kernel/zoo_service_loader.c @ 175

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links