zoo_service_loader.c @ 364

Last change on this file since 364 was 364, checked in by djay, 12 years ago
Update to make ZOO-Kernel able to compile and run from Windows Platforms. A special thanks to Espen Messel, Knut Landmark and Benrd Härtwig for providing many patches that I can successfully apply on the SVN source tree and to Farkas for continuing requesting for ZOO-Kernel to run on Windows platforms privately and through the ZOO-Discuss mailing list.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 61.3 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links