zoo_service_loader.c @ 105

Last change on this file since 105 was 105, checked in by djay, 13 years ago
Simplification of RawDataOutput? and ResponseDocument? parsing code for XML requests.
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: trunk/zoo-kernel/zoo_service_loader.c @ 105

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links