zoo_service_loader.c @ 487

Last change on this file since 487 was 486, checked in by djay, 11 years ago
Remove dumpMap call from zoo_service_loader.c.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 73.2 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links