service_internal.c @ 561

Last change on this file since 561 was 554, checked in by knut, 10 years ago
Changed the WIN32 version of function zGettimeofday. Changed return type for getShmLockId (WIN32). Changed type of _HINTERNET.mimeType from unsigned char* to char*. Fixed interconnected memory issues in functions getKeyValue and getShmLockId (WIN32). Added code to transfer the correct unique process identifier (usid) to background processes (applies to WIN32 version).
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 99.7 KB

Line
1	/**
2	* Author : Gérald FENOY
3	*
4	* Copyright (c) 2009-2013 GeoLabs SARL
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	#include "service_internal.h"
26	#ifdef USE_MS
27	#include "service_internal_ms.h"
28	#else
29	#include "cpl_vsi.h"
30	#endif
31
32	#ifndef TRUE
33	#define TRUE 1
34	#endif
35	#ifndef FALSE
36	#define FALSE -1
37	#endif
38
39	int isValidLang(maps* conf,const char *str){
40	map *tmpMap=getMapFromMaps(conf,"main","lang");
41	char *tmp=zStrdup(tmpMap->value);
42	char *pToken=strtok(tmp,",");
43	int res=-1;
44	while(pToken!=NULL){
45	if(strcasecmp(str,pToken)==0){
46	res=1;
47	break;
48	}
49	pToken = strtok(NULL,",");
50	}
51	free(tmp);
52	return res;
53	}
54
55	void printHeaders(maps* m){
56	maps *_tmp=getMaps(m,"headers");
57	if(_tmp!=NULL){
58	map* _tmp1=_tmp->content;
59	while(_tmp1!=NULL){
60	printf("%s: %s\r\n",_tmp1->name,_tmp1->value);
61	_tmp1=_tmp1->next;
62	}
63	}
64	}
65
66	void addLangAttr(xmlNodePtr n,maps *m){
67	map *tmpLmap=getMapFromMaps(m,"main","language");
68	if(tmpLmap!=NULL)
69	xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST tmpLmap->value);
70	else
71	xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en-US");
72	}
73
74	/* Converts a hex character to its integer value */
75	char from_hex(char ch) {
76	return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
77	}
78
79	/* Converts an integer value to its hex character*/
80	char to_hex(char code) {
81	static char hex[] = "0123456789abcdef";
82	return hex[code & 15];
83	}
84
85	char* _getStatus(maps* conf,int pid){
86	char lid[1024];
87	sprintf(lid,"%d",pid);
88	setMapInMaps(conf,"lenv","lid",lid);
89	semid lockid=getShmLockId(conf,1);
90	if(
91	#ifdef WIN32
92	lockid==NULL
93	#else
94	lockid<0
95	#endif
96	){
97	char tmp[3];
98	sprintf(tmp,"%d",ZOO_LOCK_CREATE_FAILED);
99	return tmp;
100	}
101	if(lockShm(lockid)<0){
102	fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
103	fflush(stderr);
104	char tmp[3];
105	sprintf(tmp,"%d",ZOO_LOCK_ACQUIRE_FAILED);
106	return tmp;
107	}
108	char *tmp=getStatus(pid);
109	unlockShm(lockid);
110	if(tmp==NULL \|\| strncmp(tmp,"-1",2)==0){
111	removeShmLock(conf,1);
112	}
113	return tmp;
114	}
115
116	#ifdef WIN32
117
118	#include <windows.h>
119	#include <fcgi_stdio.h>
120	#include <stdio.h>
121	#include <conio.h>
122	#include <tchar.h>
123
124	#define SHMEMSIZE 4096
125
126	size_t getKeyValue(maps* conf, char* key, size_t length){
127
128	if(conf==NULL) {
129	strncpy(key, "700666", length);
130	return strlen(key);
131	}
132
133	map *tmpMap=getMapFromMaps(conf,"lenv","lid");
134	if(tmpMap==NULL)
135	tmpMap=getMapFromMaps(conf,"lenv","usid");
136
137	if(tmpMap!=NULL){
138	snprintf(key, length, "zoo_sem_%s", tmpMap->value);
139	}
140	else {
141	strncpy(key, "-1", length);
142	}
143	return strlen(key);
144	}
145	semid getShmLockId(maps* conf, int nsems){
146	semid sem_id;
147	char key[MAX_PATH];
148	getKeyValue(conf, key, MAX_PATH);
149
150	sem_id = CreateSemaphore( NULL, nsems, nsems+1, key);
151	if(sem_id==NULL){
152
153	#ifdef DEBUG
154	fprintf(stderr,"Semaphore failed to create ! %s\n",GetLastError());
155	#endif
156	return NULL;
157	}
158	#ifdef DEBUG
159	fprintf(stderr,"%s Accessed !\n",key);
160	#endif
161
162	return sem_id;
163	}
164
165	int removeShmLock(maps* conf, int nsems){
166	semid sem_id=getShmLockId(conf,1);
167	if (CloseHandle(sem_id) == 0) {
168	fprintf(stderr,"Unable to remove semaphore %s",GetLastError());
169	return -1;
170	}
171	#ifdef DEBUG
172	fprintf(stderr,"%d Removed !\n",sem_id);
173	#endif
174	return 0;
175	}
176
177	int lockShm(semid id){
178	DWORD dwWaitResult=WaitForSingleObject(id,INFINITE);
179	switch (dwWaitResult){
180	case WAIT_OBJECT_0:
181	return 0;
182	break;
183	case WAIT_TIMEOUT:
184	return -1;
185	break;
186	default:
187	return -2;
188	break;
189	}
190	return 0;
191	}
192
193	int unlockShm(semid id){
194	if(!ReleaseSemaphore(id,1,NULL)){
195	return -1;
196	}
197	return 0;
198	}
199
200	static LPVOID lpvMemG = NULL; // pointer to shared memory
201	static HANDLE hMapObjectG = NULL; // handle to file mapping
202
203	int _updateStatus(maps *conf){
204	LPWSTR lpszTmp;
205	BOOL fInit;
206	char *final_string=NULL;
207	char *s=NULL;
208	map *tmpMap1;
209	map *tmpMap=getMapFromMaps(conf,"lenv","usid");
210	semid lockid=getShmLockId(conf,1);
211	if(lockid==NULL){
212	#ifdef DEBUG
213	fprintf(stderr,"Unable to create semaphore on line %d!! \n",__LINE__);
214	#endif
215	return ZOO_LOCK_CREATE_FAILED;
216	}
217	if(lockShm(lockid)<0){
218	#ifdef DEBUG
219	fprintf(stderr,"Unable to create semaphore on line %d!! \n",__LINE__);
220	#endif
221	return ZOO_LOCK_ACQUIRE_FAILED;
222	}
223
224	if(hMapObjectG==NULL)
225	hMapObjectG = CreateFileMapping(
226	INVALID_HANDLE_VALUE, // use paging file
227	NULL, // default security attributes
228	PAGE_READWRITE, // read/write access
229	0, // size: high 32-bits
230	SHMEMSIZE, // size: low 32-bits
231	TEXT(tmpMap->value)); // name of map object
232	if (hMapObjectG == NULL){
233	#ifdef DEBUG
234	fprintf(stderr,"Unable to create shared memory segment %d !! \n",GetLastError());
235	#endif
236	return -2;
237	}
238	fInit = (GetLastError() != ERROR_ALREADY_EXISTS);
239	if(lpvMemG==NULL)
240	lpvMemG = MapViewOfFile(
241	hMapObjectG, // object to map view of
242	FILE_MAP_WRITE, // read/write access
243	0, // high offset: map from
244	0, // low offset: beginning
245	0); // default: map entire file
246	if (lpvMemG == NULL){
247	#ifdef DEBUG
248	fprintf(stderr,"Unable to create or access the shared memory segment %s !! \n",tmpMap->value);
249	#endif
250	return -1;
251	}
252	memset(lpvMemG, '\0', SHMEMSIZE);
253	tmpMap=getMapFromMaps(conf,"lenv","status");
254	tmpMap1=NULL;
255	tmpMap1=getMapFromMaps(conf,"lenv","message");
256	lpszTmp = (LPWSTR) lpvMemG;
257	final_string=(char)malloc((strlen(tmpMap1->value)+strlen(tmpMap->value)+2)sizeof(char));
258	sprintf(final_string,"%s\|%s",tmpMap->value,tmpMap1->value);
259	for(s=final_string;s!='\0';s++){
260	lpszTmp++ = s;
261	}
262	*lpszTmp++ = '\0';
263	free(final_string);
264	unlockShm(lockid);
265	return 0;
266	}
267
268	char* getStatus(int pid){
269	char lpszBuf=(char) malloc(SHMEMSIZE*sizeof(char));
270	int i=0;
271	LPWSTR lpszTmp=NULL;
272	LPVOID lpvMem = NULL;
273	HANDLE hMapObject = NULL;
274	BOOL fIgnore,fInit;
275	char tmp[1024];
276	sprintf(tmp,"%d",pid);
277	if(hMapObject==NULL)
278	hMapObject = CreateFileMapping(
279	INVALID_HANDLE_VALUE, // use paging file
280	NULL, // default security attributes
281	PAGE_READWRITE, // read/write access
282	0, // size: high 32-bits
283	4096, // size: low 32-bits
284	TEXT(tmp)); // name of map object
285	if (hMapObject == NULL){
286	#ifdef DEBUG
287	fprintf(stderr,"ERROR on line %d\n",__LINE__);
288	#endif
289	return "-1";
290	}
291	if((GetLastError() != ERROR_ALREADY_EXISTS)){
292	#ifdef DEBUG
293	fprintf(stderr,"ERROR on line %d\n",__LINE__);
294	fprintf(stderr,"READING STRING S %s\n",GetLastError());
295	#endif
296	fIgnore = UnmapViewOfFile(lpvMem);
297	fIgnore = CloseHandle(hMapObject);
298	return "-1";
299	}
300	fInit=TRUE;
301	if(lpvMem==NULL)
302	lpvMem = MapViewOfFile(
303	hMapObject, // object to map view of
304	FILE_MAP_READ, // read/write access
305	0, // high offset: map from
306	0, // low offset: beginning
307	0); // default: map entire file
308	if (lpvMem == NULL){
309	#ifdef DEBUG
310	fprintf(stderr,"READING STRING S %d\n",__LINE__);
311	fprintf(stderr,"READING STRING S %s\n",GetLastError());
312	#endif
313	return "-1";
314	}
315	lpszTmp = (LPWSTR) lpvMem;
316	while (*lpszTmp){
317	lpszBuf[i] = (char)*lpszTmp;
318	*lpszTmp++;
319	lpszBuf[i+1] = '\0';
320	i++;
321	}
322	return (char*)lpszBuf;
323	}
324
325	void unhandleStatus(maps *conf){
326	BOOL fIgnore;
327	fIgnore = UnmapViewOfFile(lpvMemG);
328	fIgnore = CloseHandle(hMapObjectG);
329	}
330
331	#else
332
333	#define MAX_RETRIES 10
334
335	#ifndef __APPLE__
336	union semun {
337	int val;
338	struct semid_ds *buf;
339	ushort *array;
340	};
341	#endif
342
343	int getKeyValue(maps* conf){
344	if(conf==NULL)
345	return 700666;
346	map *tmpMap=getMapFromMaps(conf,"lenv","lid");
347	if(tmpMap==NULL)
348	tmpMap=getMapFromMaps(conf,"lenv","usid");
349	int key=-1;
350	if(tmpMap!=NULL)
351	key=atoi(tmpMap->value);
352	return key;
353	}
354
355	int getShmLockId(maps* conf, int nsems){
356	int i;
357	union semun arg;
358	struct semid_ds buf;
359	struct sembuf sb;
360	semid sem_id;
361	int key=getKeyValue(conf);
362
363	sem_id = semget(key, nsems, IPC_CREAT \| IPC_EXCL \| 0666);
364
365	if (sem_id >= 0) { /* we got it first */
366	sb.sem_op = 1;
367	sb.sem_flg = 0;
368	arg.val=1;
369	for(sb.sem_num = 0; sb.sem_num < nsems; sb.sem_num++) {
370	/* do a semop() to "free" the semaphores. */
371	/* this sets the sem_otime field, as needed below. */
372	if (semop(sem_id, &sb, 1) == -1) {
373	int e = errno;
374	semctl(sem_id, 0, IPC_RMID); /* clean up */
375	errno = e;
376	return -1; /* error, check errno */
377	}
378	}
379	} else if (errno == EEXIST) { /* someone else got it first */
380	int ready = 0;
381
382	sem_id = semget(key, nsems, 0); /* get the id */
383	if (sem_id < 0) return sem_id; /* error, check errno */
384
385	/* wait for other process to initialize the semaphore: */
386	arg.buf = &buf;
387	for(i = 0; i < MAX_RETRIES && !ready; i++) {
388	semctl(sem_id, nsems-1, IPC_STAT, arg);
389	if (arg.buf->sem_otime != 0) {
390	#ifdef DEBUG
391	fprintf(stderr,"Semaphore acquired ...\n");
392	#endif
393	ready = 1;
394	} else {
395	#ifdef DEBUG
396	fprintf(stderr,"Retry to access the semaphore later ...\n");
397	#endif
398	sleep(1);
399	}
400	}
401	errno = NULL;
402	if (!ready) {
403	#ifdef DEBUG
404	fprintf(stderr,"Unable to access the semaphore ...\n");
405	#endif
406	errno = ETIME;
407	return -1;
408	}
409	} else {
410	return sem_id; /* error, check errno */
411	}
412	#ifdef DEBUG
413	fprintf(stderr,"%d Created !\n",sem_id);
414	#endif
415	return sem_id;
416	}
417
418	int removeShmLock(maps* conf, int nsems){
419	union semun arg;
420	int sem_id=getShmLockId(conf,nsems);
421	if (semctl(sem_id, 0, IPC_RMID, arg) == -1) {
422	perror("semctl");
423	return -1;
424	}
425	return 0;
426	}
427
428	int lockShm(int id){
429	struct sembuf sb;
430	int i;
431	sb.sem_num = 0;
432	sb.sem_op = -1; /* set to allocate resource */
433	sb.sem_flg = SEM_UNDO;
434	if (semop(id, &sb, 1) == -1){
435	perror("semop");
436	return -1;
437	}
438	return 0;
439	}
440
441	int unlockShm(int id){
442	struct sembuf sb;
443	sb.sem_num = 0;
444	sb.sem_op = 1; /* free resource */
445	sb.sem_flg = SEM_UNDO;
446	if (semop(id, &sb, 1) == -1) {
447	perror("semop");
448	return -1;
449	}
450	return 0;
451	}
452
453	void unhandleStatus(maps *conf){
454	int shmid;
455	key_t key;
456	void *shm;
457	struct shmid_ds shmids;
458	map *tmpMap=getMapFromMaps(conf,"lenv","usid");
459	if(tmpMap!=NULL){
460	key=atoi(tmpMap->value);
461	if ((shmid = shmget(key, SHMSZ, IPC_CREAT \| 0666)) < 0) {
462	#ifdef DEBUG
463	fprintf(stderr,"shmget failed to update value\n");
464	#endif
465	}else{
466	if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
467	#ifdef DEBUG
468	fprintf(stderr,"shmat failed to update value\n");
469	#endif
470	}else{
471	shmdt(shm);
472	shmctl(shmid,IPC_RMID,&shmids);
473	}
474	}
475	}
476	}
477
478	int _updateStatus(maps *conf){
479	int shmid;
480	char shm,s,*s1;
481	map *tmpMap=NULL;
482	key_t key=getKeyValue(conf);
483	if(key!=-1){
484	semid lockid=getShmLockId(conf,1);
485	if(lockid<0)
486	return ZOO_LOCK_CREATE_FAILED;
487	if(lockShm(lockid)<0){
488	return ZOO_LOCK_ACQUIRE_FAILED;
489	}
490	if ((shmid = shmget(key, SHMSZ, IPC_CREAT \| 0666)) < 0) {
491	#ifdef DEBUG
492	fprintf(stderr,"shmget failed to create new Shared memory segment\n");
493	#endif
494	unlockShm(lockid);
495	return -2;
496	}else{
497	if ((shm = (char) shmat(shmid, NULL, 0)) == (char ) -1) {
498	#ifdef DEBUG
499	fprintf(stderr,"shmat failed to update value\n");
500	#endif
501	unlockShm(lockid);
502	return -1;
503	}
504	else{
505	tmpMap=getMapFromMaps(conf,"lenv","status");
506	s1=shm;
507	for(s=tmpMap->value;s!=NULL && s!=0;s++){
508	s1++=s;
509	}
510	*s1++='\|';
511	tmpMap=getMapFromMaps(conf,"lenv","message");
512	if(tmpMap!=NULL)
513	for(s=tmpMap->value;s!=NULL && s!=0;s++){
514	s1++=s;
515	}
516	*s1=NULL;
517	shmdt((void *)shm);
518	unlockShm(lockid);
519	}
520	}
521	}
522	return 0;
523	}
524
525	char* getStatus(int pid){
526	int shmid;
527	key_t key;
528	void *shm;
529	key=pid;
530	if ((shmid = shmget(key, SHMSZ, 0666)) < 0) {
531	#ifdef DEBUG
532	fprintf(stderr,"shmget failed in getStatus\n");
533	#endif
534	}else{
535	if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
536	#ifdef DEBUG
537	fprintf(stderr,"shmat failed in getStatus\n");
538	#endif
539	}else{
540	char ret=strdup((char)shm);
541	shmdt((void *)shm);
542	return ret;
543	}
544	}
545	return (char*)"-1";
546	}
547
548	#endif
549
550	#ifdef USE_JS
551
552	JSBool
553	JSUpdateStatus(JSContext cx, uintN argc, jsval argv1)
554	{
555	jsval *argv = JS_ARGV(cx,argv1);
556	JS_MaybeGC(cx);
557	int istatus=0;
558	char *status=NULL;
559	maps *conf;
560	if(argc>2){
561	#ifdef JS_DEBUG
562	fprintf(stderr,"Number of arguments used to call the function : %i",argc);
563	#endif
564	return JS_FALSE;
565	}
566	conf=mapsFromJSObject(cx,argv[0]);
567	if(JS_ValueToInt32(cx,argv[1],&istatus)==JS_TRUE){
568	char tmpStatus[4];
569	sprintf(tmpStatus,"%i",istatus);
570	tmpStatus[3]=0;
571	status=strdup(tmpStatus);
572	}
573	if(getMapFromMaps(conf,"lenv","status")!=NULL){
574	if(status!=NULL){
575	setMapInMaps(conf,"lenv","status",status);
576	free(status);
577	}
578	else
579	setMapInMaps(conf,"lenv","status","15");
580	_updateStatus(conf);
581	}
582	freeMaps(&conf);
583	free(conf);
584	JS_MaybeGC(cx);
585	return JS_TRUE;
586	}
587
588	#endif
589
590
591
592	/* Returns a url-encoded version of str */
593	/* IMPORTANT: be sure to free() the returned string after use */
594	char url_encode(char str) {
595	char pstr = str, buf = (char) malloc(strlen(str) 3 + 1), *pbuf = buf;
596	while (*pstr) {
597	if (isalnum(pstr) \|\| pstr == '-' \|\| pstr == '_' \|\| pstr == '.' \|\| *pstr == '~')
598	pbuf++ = pstr;
599	else if (*pstr == ' ')
600	*pbuf++ = '+';
601	else
602	pbuf++ = '%', pbuf++ = to_hex(pstr >> 4), pbuf++ = to_hex(*pstr & 15);
603	pstr++;
604	}
605	*pbuf = '\0';
606	return buf;
607	}
608
609	/* Returns a url-decoded version of str */
610	/* IMPORTANT: be sure to free() the returned string after use */
611	char url_decode(char str) {
612	char pstr = str, buf = (char) malloc(strlen(str) + 1), pbuf = buf;
613	while (*pstr) {
614	if (*pstr == '%') {
615	if (pstr[1] && pstr[2]) {
616	*pbuf++ = from_hex(pstr[1]) << 4 \| from_hex(pstr[2]);
617	pstr += 2;
618	}
619	} else if (*pstr == '+') {
620	*pbuf++ = ' ';
621	} else {
622	pbuf++ = pstr;
623	}
624	pstr++;
625	}
626	*pbuf = '\0';
627	return buf;
628	}
629
630	char zCapitalize1(char tmp){
631	char *res=strdup(tmp);
632	if(res[0]>=97 && res[0]<=122)
633	res[0]-=32;
634	return res;
635	}
636
637	char zCapitalize(char tmp){
638	int i=0;
639	char *res=strdup(tmp);
640	for(i=0;i<strlen(res);i++)
641	if(res[i]>=97 && res[i]<=122)
642	res[i]-=32;
643	return res;
644	}
645
646
647	int zooXmlSearchForNs(const char* name){
648	int i;
649	int res=-1;
650	for(i=0;i<nbNs;i++)
651	if(strncasecmp(name,nsName[i],strlen(nsName[i]))==0){
652	res=i;
653	break;
654	}
655	return res;
656	}
657
658	int zooXmlAddNs(xmlNodePtr nr,const char* url,const char* name){
659	#ifdef DEBUG
660	fprintf(stderr,"zooXmlAddNs %d %s \n",nbNs,name);
661	#endif
662	int currId=-1;
663	if(nbNs==0){
664	nbNs++;
665	currId=0;
666	nsName[currId]=strdup(name);
667	usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
668	}else{
669	currId=zooXmlSearchForNs(name);
670	if(currId<0){
671	nbNs++;
672	currId=nbNs-1;
673	nsName[currId]=strdup(name);
674	usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
675	}
676	}
677	return currId;
678	}
679
680	void zooXmlCleanupNs(){
681	int j;
682	#ifdef DEBUG
683	fprintf(stderr,"zooXmlCleanup %d\n",nbNs);
684	#endif
685	for(j=nbNs-1;j>=0;j--){
686	#ifdef DEBUG
687	fprintf(stderr,"zooXmlCleanup %d\n",j);
688	#endif
689	if(j==0)
690	xmlFreeNs(usedNs[j]);
691	free(nsName[j]);
692	nbNs--;
693	}
694	nbNs=0;
695	}
696
697
698	int zooXmlAddDoc(const char* value){
699	int currId=0;
700	nbDocs++;
701	currId=nbDocs-1;
702	iDocs[currId]=xmlParseMemory(value,strlen(value));
703	return currId;
704	}
705
706	void zooXmlCleanupDocs(){
707	int j;
708	for(j=nbDocs-1;j>=0;j--){
709	xmlFreeDoc(iDocs[j]);
710	}
711	nbDocs=0;
712	}
713
714
715	xmlNodePtr soapEnvelope(maps* conf,xmlNodePtr n){
716	map* soap=getMapFromMaps(conf,"main","isSoap");
717	if(soap!=NULL && strcasecmp(soap->value,"true")==0){
718	int lNbNs=nbNs;
719	nsName[lNbNs]=strdup("soap");
720	usedNs[lNbNs]=xmlNewNs(NULL,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
721	nbNs++;
722	xmlNodePtr nr = xmlNewNode(usedNs[lNbNs], BAD_CAST "Envelope");
723	nsName[nbNs]=strdup("soap");
724	usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
725	nbNs++;
726	nsName[nbNs]=strdup("xsi");
727	usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
728	nbNs++;
729	xmlNsPtr ns_xsi=usedNs[nbNs-1];
730	xmlNewNsProp(nr,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.w3.org/2003/05/soap-envelope http://www.w3.org/2003/05/soap-envelope");
731	xmlNodePtr nr1 = xmlNewNode(usedNs[lNbNs], BAD_CAST "Body");
732	xmlAddChild(nr1,n);
733	xmlAddChild(nr,nr1);
734	return nr;
735	}else
736	return n;
737	}
738
739	xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr doc,const char* service,maps* m){
740
741	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
742	xmlNodePtr n,nc,nc1,nc2,nc3,nc4,nc5,nc6;
743	/**
744	* Create the document and its temporary root.
745	*/
746	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
747	ns=usedNs[wpsId];
748	maps* toto1=getMaps(m,"main");
749
750	n = xmlNewNode(ns, BAD_CAST "Capabilities");
751	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
752	ns_ows=usedNs[owsId];
753	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
754	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
755	ns_xsi=usedNs[xsiId];
756	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
757	ns_xlink=usedNs[xlinkId];
758	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd");
759	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
760	addLangAttr(n,m);
761
762	if(toto1!=NULL){
763	map* tmp=getMap(toto1->content,"version");
764	if(tmp!=NULL){
765	xmlNewProp(n,BAD_CAST "version",BAD_CAST tmp->value);
766	}
767	else
768	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
769	}
770	else
771	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
772
773	char tmp[256];
774
775	nc = xmlNewNode(ns_ows, BAD_CAST "ServiceIdentification");
776	maps* tmp4=getMaps(m,"identification");
777	if(tmp4!=NULL){
778	map* tmp2=tmp4->content;
779	const char *orderedFields[5];
780	orderedFields[0]="Title";
781	orderedFields[1]="Abstract";
782	orderedFields[2]="Keywords";
783	orderedFields[3]="Fees";
784	orderedFields[4]="AccessConstraints";
785	int oI=0;
786	for(oI=0;oI<5;oI++)
787	if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
788	if(strcasecmp(tmp2->name,"abstract")==0 \|\|
789	strcasecmp(tmp2->name,"title")==0 \|\|
790	strcasecmp(tmp2->name,"accessConstraints")==0 \|\|
791	strcasecmp(tmp2->name,"fees")==0){
792	tmp2->name[0]=toupper(tmp2->name[0]);
793	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
794	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
795	xmlAddChild(nc,nc1);
796	}
797	else
798	if(strcmp(tmp2->name,"keywords")==0){
799	nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
800	char *toto=tmp2->value;
801	char buff[256];
802	int i=0;
803	int j=0;
804	while(toto[i]){
805	if(toto[i]!=',' && toto[i]!=0){
806	buff[j]=toto[i];
807	buff[j+1]=0;
808	j++;
809	}
810	else{
811	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
812	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
813	xmlAddChild(nc1,nc2);
814	j=0;
815	}
816	i++;
817	}
818	if(strlen(buff)>0){
819	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
820	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
821	xmlAddChild(nc1,nc2);
822	}
823	xmlAddChild(nc,nc1);
824	nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceType");
825	xmlAddChild(nc2,xmlNewText(BAD_CAST "WPS"));
826	xmlAddChild(nc,nc2);
827	nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceTypeVersion");
828	xmlAddChild(nc2,xmlNewText(BAD_CAST "1.0.0"));
829	xmlAddChild(nc,nc2);
830	}
831	tmp2=tmp2->next;
832	}
833	}
834	else{
835	fprintf(stderr,"TMP4 NOT FOUND !!");
836	return NULL;
837	}
838	xmlAddChild(n,nc);
839
840	nc = xmlNewNode(ns_ows, BAD_CAST "ServiceProvider");
841	nc3 = xmlNewNode(ns_ows, BAD_CAST "ServiceContact");
842	nc4 = xmlNewNode(ns_ows, BAD_CAST "ContactInfo");
843	nc5 = xmlNewNode(ns_ows, BAD_CAST "Phone");
844	nc6 = xmlNewNode(ns_ows, BAD_CAST "Address");
845	tmp4=getMaps(m,"provider");
846	if(tmp4!=NULL){
847	map* tmp2=tmp4->content;
848	const char *tmpAddress[6];
849	tmpAddress[0]="addressDeliveryPoint";
850	tmpAddress[1]="addressCity";
851	tmpAddress[2]="addressAdministrativeArea";
852	tmpAddress[3]="addressPostalCode";
853	tmpAddress[4]="addressCountry";
854	tmpAddress[5]="addressElectronicMailAddress";
855	const char *tmpPhone[2];
856	tmpPhone[0]="phoneVoice";
857	tmpPhone[1]="phoneFacsimile";
858	const char *orderedFields[12];
859	orderedFields[0]="providerName";
860	orderedFields[1]="providerSite";
861	orderedFields[2]="individualName";
862	orderedFields[3]="positionName";
863	orderedFields[4]=tmpPhone[0];
864	orderedFields[5]=tmpPhone[1];
865	orderedFields[6]=tmpAddress[0];
866	orderedFields[7]=tmpAddress[1];
867	orderedFields[8]=tmpAddress[2];
868	orderedFields[9]=tmpAddress[3];
869	orderedFields[10]=tmpAddress[4];
870	orderedFields[11]=tmpAddress[5];
871	int oI=0;
872	for(oI=0;oI<12;oI++)
873	if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
874	if(strcmp(tmp2->name,"keywords")!=0 &&
875	strcmp(tmp2->name,"serverAddress")!=0 &&
876	strcmp(tmp2->name,"lang")!=0){
877	tmp2->name[0]=toupper(tmp2->name[0]);
878	if(strcmp(tmp2->name,"ProviderName")==0){
879	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
880	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
881	xmlAddChild(nc,nc1);
882	}
883	else{
884	if(strcmp(tmp2->name,"ProviderSite")==0){
885	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
886	xmlNewNsProp(nc1,ns_xlink,BAD_CAST "href",BAD_CAST tmp2->value);
887	xmlAddChild(nc,nc1);
888	}
889	else
890	if(strcmp(tmp2->name,"IndividualName")==0 \|\|
891	strcmp(tmp2->name,"PositionName")==0){
892	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
893	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
894	xmlAddChild(nc3,nc1);
895	}
896	else
897	if(strncmp(tmp2->name,"Phone",5)==0){
898	int j;
899	for(j=0;j<2;j++)
900	if(strcasecmp(tmp2->name,tmpPhone[j])==0){
901	char *tmp4=tmp2->name;
902	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+5);
903	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
904	xmlAddChild(nc5,nc1);
905	}
906	}
907	else
908	if(strncmp(tmp2->name,"Address",7)==0){
909	int j;
910	for(j=0;j<6;j++)
911	if(strcasecmp(tmp2->name,tmpAddress[j])==0){
912	char *tmp4=tmp2->name;
913	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+7);
914	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
915	xmlAddChild(nc6,nc1);
916	}
917	}
918	}
919	}
920	else
921	if(strcmp(tmp2->name,"keywords")==0){
922	nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
923	char *toto=tmp2->value;
924	char buff[256];
925	int i=0;
926	int j=0;
927	while(toto[i]){
928	if(toto[i]!=',' && toto[i]!=0){
929	buff[j]=toto[i];
930	buff[j+1]=0;
931	j++;
932	}
933	else{
934	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
935	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
936	xmlAddChild(nc1,nc2);
937	j=0;
938	}
939	i++;
940	}
941	if(strlen(buff)>0){
942	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
943	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
944	xmlAddChild(nc1,nc2);
945	}
946	xmlAddChild(nc,nc1);
947	}
948	tmp2=tmp2->next;
949	}
950	}
951	else{
952	fprintf(stderr,"TMP4 NOT FOUND !!");
953	}
954	xmlAddChild(nc4,nc5);
955	xmlAddChild(nc4,nc6);
956	xmlAddChild(nc3,nc4);
957	xmlAddChild(nc,nc3);
958	xmlAddChild(n,nc);
959
960
961	nc = xmlNewNode(ns_ows, BAD_CAST "OperationsMetadata");
962	char *tmp2[3];
963	tmp2[0]=strdup("GetCapabilities");
964	tmp2[1]=strdup("DescribeProcess");
965	tmp2[2]=strdup("Execute");
966	int j=0;
967
968	if(toto1!=NULL){
969	map* tmp=getMap(toto1->content,"serverAddress");
970	if(tmp!=NULL){
971	SERVICE_URL = strdup(tmp->value);
972	}
973	else
974	SERVICE_URL = strdup("not_found");
975	}
976	else
977	SERVICE_URL = strdup("not_found");
978
979	for(j=0;j<3;j++){
980	nc1 = xmlNewNode(ns_ows, BAD_CAST "Operation");
981	xmlNewProp(nc1,BAD_CAST "name",BAD_CAST tmp2[j]);
982	nc2 = xmlNewNode(ns_ows, BAD_CAST "DCP");
983	nc3 = xmlNewNode(ns_ows, BAD_CAST "HTTP");
984	nc4 = xmlNewNode(ns_ows, BAD_CAST "Get");
985	sprintf(tmp,"%s/%s",SERVICE_URL,service);
986	xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
987	xmlAddChild(nc3,nc4);
988	if(j>0){
989	nc4 = xmlNewNode(ns_ows, BAD_CAST "Post");
990	xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
991	xmlAddChild(nc3,nc4);
992	}
993	xmlAddChild(nc2,nc3);
994	xmlAddChild(nc1,nc2);
995	xmlAddChild(nc,nc1);
996	}
997	for(j=2;j>=0;j--)
998	free(tmp2[j]);
999	xmlAddChild(n,nc);
1000
1001	nc = xmlNewNode(ns, BAD_CAST "ProcessOfferings");
1002	xmlAddChild(n,nc);
1003
1004	nc1 = xmlNewNode(ns, BAD_CAST "Languages");
1005	nc2 = xmlNewNode(ns, BAD_CAST "Default");
1006	nc3 = xmlNewNode(ns, BAD_CAST "Supported");
1007
1008	toto1=getMaps(m,"main");
1009	if(toto1!=NULL){
1010	map* tmp1=getMap(toto1->content,"lang");
1011	char *toto=tmp1->value;
1012	char buff[256];
1013	int i=0;
1014	int j=0;
1015	int dcount=0;
1016	while(toto[i]){
1017	if(toto[i]!=',' && toto[i]!=0){
1018	buff[j]=toto[i];
1019	buff[j+1]=0;
1020	j++;
1021	}
1022	else{
1023	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
1024	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
1025	if(dcount==0){
1026	xmlAddChild(nc2,nc4);
1027	xmlAddChild(nc1,nc2);
1028	dcount++;
1029	}
1030	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
1031	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
1032	xmlAddChild(nc3,nc4);
1033	j=0;
1034	buff[j]=0;
1035	}
1036	i++;
1037	}
1038	if(strlen(buff)>0){
1039	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
1040	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
1041	xmlAddChild(nc3,nc4);
1042	}
1043	}
1044	xmlAddChild(nc1,nc3);
1045	xmlAddChild(n,nc1);
1046
1047	xmlNodePtr fn=soapEnvelope(m,n);
1048	xmlDocSetRootElement(doc, fn);
1049	//xmlFreeNs(ns);
1050	free(SERVICE_URL);
1051	return nc;
1052	}
1053
1054	void addPrefix(maps* conf,map* level,service* serv){
1055	if(level!=NULL){
1056	char key[25];
1057	char* prefix=NULL;
1058	int clevel=atoi(level->value);
1059	int cl=0;
1060	for(cl=0;cl<clevel;cl++){
1061	sprintf(key,"sprefix_%d",cl);
1062	map* tmp2=getMapFromMaps(conf,"lenv",key);
1063	if(tmp2!=NULL){
1064	if(prefix==NULL)
1065	prefix=zStrdup(tmp2->value);
1066	else{
1067	int plen=strlen(prefix);
1068	prefix=(char)realloc(prefix,(plen+strlen(tmp2->value)+2)sizeof(char));
1069	memcpy(prefix+plen,tmp2->value,strlen(tmp2->value)*sizeof(char));
1070	prefix[plen+strlen(tmp2->value)]=0;
1071	}
1072	}
1073	}
1074	if(prefix!=NULL){
1075	char* tmp0=strdup(serv->name);
1076	free(serv->name);
1077	serv->name=(char)malloc((strlen(prefix)+strlen(tmp0)+1)sizeof(char));
1078	sprintf(serv->name,"%s%s",prefix,tmp0);
1079	free(tmp0);
1080	free(prefix);
1081	prefix=NULL;
1082	}
1083	}
1084	}
1085
1086	void printGetCapabilitiesForProcess(maps* m,xmlNodePtr nc,service* serv){
1087	xmlNsPtr ns,ns_ows,ns_xlink;
1088	xmlNodePtr n=NULL,nc1,nc2;
1089	/**
1090	* Initialize or get existing namspaces
1091	*/
1092	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
1093	ns=usedNs[wpsId];
1094	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
1095	ns_ows=usedNs[owsId];
1096	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1097	ns_xlink=usedNs[xlinkId];
1098
1099	map* tmp1;
1100	if(serv->content!=NULL){
1101	nc1 = xmlNewNode(ns, BAD_CAST "Process");
1102	tmp1=getMap(serv->content,"processVersion");
1103	if(tmp1!=NULL)
1104	xmlNewNsProp(nc1,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
1105	map* tmp3=getMapFromMaps(m,"lenv","level");
1106	addPrefix(m,tmp3,serv);
1107	printDescription(nc1,ns_ows,serv->name,serv->content);
1108	tmp1=serv->metadata;
1109	while(tmp1!=NULL){
1110	nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
1111	xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
1112	xmlAddChild(nc1,nc2);
1113	tmp1=tmp1->next;
1114	}
1115	xmlAddChild(nc,nc1);
1116	}
1117	}
1118
1119	xmlNodePtr printDescribeProcessHeader(xmlDocPtr doc,const char* service,maps* m){
1120
1121	xmlNsPtr ns,ns_xsi;
1122	xmlNodePtr n;
1123
1124	int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
1125	ns=usedNs[wpsId];
1126	n = xmlNewNode(ns, BAD_CAST "ProcessDescriptions");
1127	zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
1128	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
1129	zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1130	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1131	ns_xsi=usedNs[xsiId];
1132
1133	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd");
1134	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1135	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
1136	addLangAttr(n,m);
1137
1138	xmlNodePtr fn=soapEnvelope(m,n);
1139	xmlDocSetRootElement(doc, fn);
1140
1141	return n;
1142	}
1143
1144	void printDescribeProcessForProcess(maps* m,xmlNodePtr nc,service* serv){
1145	xmlNsPtr ns,ns_ows,ns_xlink;
1146	xmlNodePtr n,nc1;
1147
1148	n=nc;
1149
1150	int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
1151	ns=usedNs[wpsId];
1152	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
1153	ns_ows=usedNs[owsId];
1154	int xlinkId=zooXmlAddNs(NULL,"http://www.w3.org/1999/xlink","xlink");
1155	ns_xlink=usedNs[xlinkId];
1156
1157	nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
1158	const char *tmp4[3];
1159	tmp4[0]="processVersion";
1160	tmp4[1]="storeSupported";
1161	tmp4[2]="statusSupported";
1162	int j=0;
1163	map* tmp1=NULL;
1164	for(j=0;j<3;j++){
1165	tmp1=getMap(serv->content,tmp4[j]);
1166	if(tmp1!=NULL){
1167	if(j==0)
1168	xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
1169	else
1170	xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST tmp1->value);
1171	}
1172	else{
1173	if(j>0)
1174	xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST "false");
1175	}
1176	}
1177
1178	tmp1=getMapFromMaps(m,"lenv","level");
1179	addPrefix(m,tmp1,serv);
1180	printDescription(nc,ns_ows,serv->name,serv->content);
1181
1182	tmp1=serv->metadata;
1183	while(tmp1!=NULL){
1184	nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
1185	xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
1186	xmlAddChild(nc,nc1);
1187	tmp1=tmp1->next;
1188	}
1189
1190	tmp1=getMap(serv->content,"Profile");
1191	if(tmp1!=NULL){
1192	nc1 = xmlNewNode(ns, BAD_CAST "Profile");
1193	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp1->value));
1194	xmlAddChild(nc,nc1);
1195	}
1196
1197	if(serv->inputs!=NULL){
1198	nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
1199	elements* e=serv->inputs;
1200	printFullDescription(1,e,"Input",ns_ows,nc1);
1201	xmlAddChild(nc,nc1);
1202	}
1203
1204	nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
1205	elements* e=serv->outputs;
1206	printFullDescription(0,e,"Output",ns_ows,nc1);
1207	xmlAddChild(nc,nc1);
1208
1209	xmlAddChild(n,nc);
1210
1211	}
1212
1213	void printFullDescription(int in,elements elem,const char type,xmlNsPtr ns_ows,xmlNodePtr nc1){
1214	const char *orderedFields[13];
1215	orderedFields[0]="mimeType";
1216	orderedFields[1]="encoding";
1217	orderedFields[2]="schema";
1218	orderedFields[3]="dataType";
1219	orderedFields[4]="uom";
1220	orderedFields[5]="CRS";
1221	orderedFields[6]="value";
1222	orderedFields[7]="AllowedValues";
1223	orderedFields[8]="range";
1224	orderedFields[9]="rangeMin";
1225	orderedFields[10]="rangeMax";
1226	orderedFields[11]="rangeClosure";
1227	orderedFields[12]="rangeSpace";
1228
1229	xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7,nc8,nc9;
1230	elements* e=elem;
1231
1232	map* tmp1=NULL;
1233	while(e!=NULL){
1234	int default1=0;
1235	int isAnyValue=1;
1236	nc2 = xmlNewNode(NULL, BAD_CAST type);
1237	if(strncmp(type,"Input",5)==0){
1238	tmp1=getMap(e->content,"minOccurs");
1239	if(tmp1!=NULL){
1240	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
1241	}else
1242	xmlNewProp(nc2,BAD_CAST "minOccurs",BAD_CAST "0");
1243	tmp1=getMap(e->content,"maxOccurs");
1244	if(tmp1!=NULL){
1245	if(strcasecmp(tmp1->value,"unbounded")!=0)
1246	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
1247	else
1248	xmlNewProp(nc2,BAD_CAST "maxOccurs",BAD_CAST "1000");
1249	}else
1250	xmlNewProp(nc2,BAD_CAST "maxOccurs",BAD_CAST "1");
1251	if((tmp1=getMap(e->content,"maximumMegabytes"))!=NULL){
1252	xmlNewProp(nc2,BAD_CAST "maximumMegabytes",BAD_CAST tmp1->value);
1253	}
1254	}
1255
1256	printDescription(nc2,ns_ows,e->name,e->content);
1257
1258	/**
1259	* Build the (Literal/Complex/BoundingBox)Data node
1260	*/
1261	if(strncmp(type,"Output",6)==0){
1262	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
1263	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
1264	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
1265	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
1266	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
1267	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
1268	else
1269	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
1270	}else{
1271	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
1272	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
1273	}
1274	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
1275	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexData");
1276	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
1277	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxData");
1278	else
1279	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
1280	}
1281
1282	iotype* _tmp0=NULL;
1283	iotype* _tmp=e->defaults;
1284	int datatype=0;
1285	bool hasUOM=false;
1286	bool hasUOM1=false;
1287	if(_tmp!=NULL){
1288	if(strcmp(e->format,"LiteralOutput")==0 \|\|
1289	strcmp(e->format,"LiteralData")==0){
1290	datatype=1;
1291	nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
1292	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
1293	}
1294	else if(strcmp(e->format,"BoundingBoxOutput")==0 \|\|
1295	strcmp(e->format,"BoundingBoxData")==0){
1296	datatype=2;
1297	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
1298	}
1299	else{
1300	nc4 = xmlNewNode(NULL, BAD_CAST "Default");
1301	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1302	}
1303
1304	tmp1=_tmp->content;
1305
1306	if((tmp1=getMap(_tmp->content,"DataType"))!=NULL){
1307	nc8 = xmlNewNode(ns_ows, BAD_CAST "DataType");
1308	xmlAddChild(nc8,xmlNewText(BAD_CAST tmp1->value));
1309	char tmp[1024];
1310	sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
1311	xmlNewNsProp(nc8,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
1312	xmlAddChild(nc3,nc8);
1313	datatype=1;
1314	}
1315
1316	if(strncmp(type,"Input",5)==0){
1317
1318	if((tmp1=getMap(_tmp->content,"AllowedValues"))!=NULL){
1319	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1320	char token,saveptr1;
1321	token=strtok_r(tmp1->value,",",&saveptr1);
1322	while(token!=NULL){
1323	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1324	char *tmps=strdup(token);
1325	tmps[strlen(tmps)]=0;
1326	xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
1327	free(tmps);
1328	xmlAddChild(nc6,nc7);
1329	token=strtok_r(NULL,",",&saveptr1);
1330	}
1331	if(getMap(_tmp->content,"range")!=NULL \|\|
1332	getMap(_tmp->content,"rangeMin")!=NULL \|\|
1333	getMap(_tmp->content,"rangeMax")!=NULL \|\|
1334	getMap(_tmp->content,"rangeClosure")!=NULL )
1335	goto doRange;
1336	xmlAddChild(nc3,nc6);
1337	isAnyValue=-1;
1338	}
1339
1340	tmp1=getMap(_tmp->content,"range");
1341	if(tmp1==NULL)
1342	tmp1=getMap(_tmp->content,"rangeMin");
1343	if(tmp1==NULL)
1344	tmp1=getMap(_tmp->content,"rangeMax");
1345
1346	if(tmp1!=NULL && isAnyValue==1){
1347	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1348	doRange:
1349
1350	/**
1351	* Range: Table 46 OGC Web Services Common Standard
1352	*/
1353	nc8 = xmlNewNode(ns_ows, BAD_CAST "Range");
1354
1355	map* tmp0=getMap(tmp1,"range");
1356	if(tmp0!=NULL){
1357	char* pToken;
1358	char* orig=zStrdup(tmp0->value);
1359	/**
1360	* RangeClosure: Table 47 OGC Web Services Common Standard
1361	*/
1362	const char *tmp="closed";
1363	if(orig[0]=='[' && orig[strlen(orig)-1]=='[')
1364	tmp="closed-open";
1365	else
1366	if(orig[0]==']' && orig[strlen(orig)-1]==']')
1367	tmp="open-closed";
1368	else
1369	if(orig[0]==']' && orig[strlen(orig)-1]=='[')
1370	tmp="open";
1371	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
1372	pToken=strtok(orig,",");
1373	int nci0=0;
1374	while(pToken!=NULL){
1375	char tmpStr=(char) malloc((strlen(pToken))*sizeof(char));
1376	if(nci0==0){
1377	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1378	strncpy( tmpStr, pToken+1, strlen(pToken)-1 );
1379	tmpStr[strlen(pToken)-1] = '\0';
1380	}else{
1381	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1382	const char* bkt;
1383	if ( ( bkt = strchr(pToken, '[') ) != NULL \|\| ( bkt = strchr(pToken, ']') ) != NULL ){
1384	strncpy( tmpStr, pToken, bkt - pToken );
1385	tmpStr[bkt - pToken] = '\0';
1386	}
1387	}
1388	xmlAddChild(nc7,xmlNewText(BAD_CAST tmpStr));
1389	free(tmpStr);
1390	xmlAddChild(nc8,nc7);
1391	nci0++;
1392	pToken = strtok(NULL,",");
1393	}
1394	if(getMap(tmp1,"rangeSpacing")==NULL){
1395	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
1396	xmlAddChild(nc7,xmlNewText(BAD_CAST "1"));
1397	xmlAddChild(nc8,nc7);
1398	}
1399	free(orig);
1400	}else{
1401
1402	tmp0=getMap(tmp1,"rangeMin");
1403	if(tmp0!=NULL){
1404	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1405	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1406	xmlAddChild(nc8,nc7);
1407	}else{
1408	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1409	xmlAddChild(nc8,nc7);
1410	}
1411	tmp0=getMap(tmp1,"rangeMax");
1412	if(tmp0!=NULL){
1413	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1414	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1415	xmlAddChild(nc8,nc7);
1416	}else{
1417	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1418	xmlAddChild(nc8,nc7);
1419	}
1420	tmp0=getMap(tmp1,"rangeSpacing");
1421	if(tmp0!=NULL){
1422	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
1423	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1424	xmlAddChild(nc8,nc7);
1425	}
1426	tmp0=getMap(tmp1,"rangeClosure");
1427	if(tmp0!=NULL){
1428	const char *tmp="closed";
1429	if(strcasecmp(tmp0->value,"co")==0)
1430	tmp="closed-open";
1431	else
1432	if(strcasecmp(tmp0->value,"oc")==0)
1433	tmp="open-closed";
1434	else
1435	if(strcasecmp(tmp0->value,"o")==0)
1436	tmp="open";
1437	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
1438	}else
1439	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST "closed");
1440	}
1441	if(_tmp0==NULL){
1442	xmlAddChild(nc6,nc8);
1443	_tmp0=e->supported;
1444	if(_tmp0!=NULL &&
1445	(getMap(_tmp0->content,"range")!=NULL \|\|
1446	getMap(_tmp0->content,"rangeMin")!=NULL \|\|
1447	getMap(_tmp0->content,"rangeMax")!=NULL \|\|
1448	getMap(_tmp0->content,"rangeClosure")!=NULL )){
1449	tmp1=_tmp0->content;
1450	goto doRange;
1451	}
1452	}else{
1453	_tmp0=_tmp0->next;
1454	if(_tmp0!=NULL){
1455	xmlAddChild(nc6,nc8);
1456	if(getMap(_tmp0->content,"range")!=NULL \|\|
1457	getMap(_tmp0->content,"rangeMin")!=NULL \|\|
1458	getMap(_tmp0->content,"rangeMax")!=NULL \|\|
1459	getMap(_tmp0->content,"rangeClosure")!=NULL ){
1460	tmp1=_tmp0->content;
1461	goto doRange;
1462	}
1463	}
1464	}
1465	xmlAddChild(nc6,nc8);
1466	xmlAddChild(nc3,nc6);
1467	isAnyValue=-1;
1468	}
1469
1470	}
1471
1472
1473	int oI=0;
1474	for(oI=0;oI<13;oI++)
1475	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1476	#ifdef DEBUG
1477	printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
1478	#endif
1479	if(strcmp(tmp1->name,"asReference")!=0 &&
1480	strncasecmp(tmp1->name,"DataType",8)!=0 &&
1481	strcasecmp(tmp1->name,"extension")!=0 &&
1482	strcasecmp(tmp1->name,"value")!=0 &&
1483	strcasecmp(tmp1->name,"AllowedValues")!=0 &&
1484	strncasecmp(tmp1->name,"range",5)!=0){
1485	if(datatype!=1){
1486	char *tmp2=zCapitalize1(tmp1->name);
1487	nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
1488	free(tmp2);
1489	}
1490	else{
1491	char *tmp2=zCapitalize(tmp1->name);
1492	nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1493	free(tmp2);
1494	}
1495	xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
1496	xmlAddChild(nc5,nc9);
1497	if(strcasecmp(tmp1->name,"uom")==0)
1498	hasUOM1=true;
1499	hasUOM=true;
1500	}else
1501
1502	tmp1=tmp1->next;
1503	}
1504
1505
1506	if(datatype!=2){
1507	if(hasUOM==true){
1508	xmlAddChild(nc4,nc5);
1509	xmlAddChild(nc3,nc4);
1510	}else{
1511	if(hasUOM1==false){
1512	xmlFreeNode(nc5);
1513	if(datatype==1)
1514	xmlFreeNode(nc4);
1515	}
1516	}
1517	}else{
1518	xmlAddChild(nc3,nc5);
1519	}
1520
1521	if(datatype!=1 && default1<0){
1522	xmlFreeNode(nc5);
1523	if(datatype!=2)
1524	xmlFreeNode(nc4);
1525	}
1526
1527	map* metadata=e->metadata;
1528	xmlNodePtr n=NULL;
1529	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1530	xmlNsPtr ns_xlink=usedNs[xlinkId];
1531
1532	while(metadata!=NULL){
1533	nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
1534	xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
1535	xmlAddChild(nc2,nc6);
1536	metadata=metadata->next;
1537	}
1538
1539	}
1540
1541	_tmp=e->supported;
1542	if(_tmp==NULL && datatype!=1)
1543	_tmp=e->defaults;
1544
1545	int hasSupported=-1;
1546
1547	while(_tmp!=NULL){
1548	if(hasSupported<0){
1549	if(datatype==0){
1550	nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
1551	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1552	}
1553	else
1554	nc5 = xmlNewNode(NULL, BAD_CAST "Supported");
1555	hasSupported=0;
1556	}else
1557	if(datatype==0)
1558	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1559	tmp1=_tmp->content;
1560	int oI=0;
1561	for(oI=0;oI<6;oI++)
1562	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1563	#ifdef DEBUG
1564	printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
1565	#endif
1566	if(strcmp(tmp1->name,"asReference")!=0 &&
1567	strcmp(tmp1->name,"value")!=0 &&
1568	strcmp(tmp1->name,"DataType")!=0 &&
1569	strcasecmp(tmp1->name,"extension")!=0){
1570	if(datatype!=1){
1571	char *tmp2=zCapitalize1(tmp1->name);
1572	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1573	free(tmp2);
1574	}
1575	else{
1576	char *tmp2=zCapitalize(tmp1->name);
1577	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1578	free(tmp2);
1579	}
1580	if(datatype==2){
1581	char tmpv,tmps;
1582	tmps=strtok_r(tmp1->value,",",&tmpv);
1583	while(tmps){
1584	xmlAddChild(nc6,xmlNewText(BAD_CAST tmps));
1585	tmps=strtok_r(NULL,",",&tmpv);
1586	if(tmps){
1587	char *tmp2=zCapitalize1(tmp1->name);
1588	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1589	free(tmp2);
1590	}
1591	}
1592	}
1593	else{
1594	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
1595	}
1596	xmlAddChild(nc5,nc6);
1597	}
1598	tmp1=tmp1->next;
1599	}
1600	if(hasSupported<=0){
1601	if(datatype==0){
1602	xmlAddChild(nc4,nc5);
1603	xmlAddChild(nc3,nc4);
1604	}else{
1605	if(datatype!=1)
1606	xmlAddChild(nc3,nc5);
1607	}
1608	hasSupported=1;
1609	}
1610	else
1611	if(datatype==0){
1612	xmlAddChild(nc4,nc5);
1613	xmlAddChild(nc3,nc4);
1614	}
1615	else
1616	if(datatype!=1)
1617	xmlAddChild(nc3,nc5);
1618
1619	_tmp=_tmp->next;
1620	}
1621
1622	if(hasSupported==0){
1623	if(datatype==0)
1624	xmlFreeNode(nc4);
1625	xmlFreeNode(nc5);
1626	}
1627
1628	_tmp=e->defaults;
1629	if(datatype==1 && hasUOM1==true){
1630	xmlAddChild(nc4,nc5);
1631	xmlAddChild(nc3,nc4);
1632	}
1633
1634	if(in>0 && datatype==1 &&
1635	getMap(_tmp->content,"AllowedValues")==NULL &&
1636	getMap(_tmp->content,"range")==NULL &&
1637	getMap(_tmp->content,"rangeMin")==NULL &&
1638	getMap(_tmp->content,"rangeMax")==NULL &&
1639	getMap(_tmp->content,"rangeClosure")==NULL ){
1640	tmp1=getMap(_tmp->content,"dataType");
1641	if(tmp1!=NULL && strcasecmp(tmp1->value,"boolean")==0){
1642	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1643	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1644	xmlAddChild(nc7,xmlNewText(BAD_CAST "true"));
1645	xmlAddChild(nc6,nc7);
1646	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1647	xmlAddChild(nc7,xmlNewText(BAD_CAST "false"));
1648	xmlAddChild(nc6,nc7);
1649	xmlAddChild(nc3,nc6);
1650	}
1651	else
1652	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
1653	}
1654
1655	if((tmp1=getMap(_tmp->content,"value"))!=NULL){
1656	nc7 = xmlNewNode(NULL, BAD_CAST "DefaultValue");
1657	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp1->value));
1658	xmlAddChild(nc3,nc7);
1659	}
1660
1661	xmlAddChild(nc2,nc3);
1662
1663	xmlAddChild(nc1,nc2);
1664
1665	e=e->next;
1666	}
1667	}
1668
1669	void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
1670	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1671	xmlNodePtr nr,n,nc,nc1=NULL,nc3;
1672	xmlDocPtr doc;
1673	time_t time1;
1674	time(&time1);
1675	nr=NULL;
1676	/**
1677	* Create the document and its temporary root.
1678	*/
1679	doc = xmlNewDoc(BAD_CAST "1.0");
1680	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
1681	ns=usedNs[wpsId];
1682
1683	n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
1684	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
1685	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
1686	ns_ows=usedNs[owsId];
1687	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1688	ns_xlink=usedNs[xlinkId];
1689	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1690	ns_xsi=usedNs[xsiId];
1691
1692	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsExecute_response.xsd");
1693
1694	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1695	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
1696	addLangAttr(n,m);
1697
1698	char tmp[256];
1699	char url[1024];
1700	char stored_path[1024];
1701	memset(tmp,0,256);
1702	memset(url,0,1024);
1703	memset(stored_path,0,1024);
1704	maps* tmp_maps=getMaps(m,"main");
1705	if(tmp_maps!=NULL){
1706	map* tmpm1=getMap(tmp_maps->content,"serverAddress");
1707	/**
1708	* Check if the ZOO Service GetStatus is available in the local directory.
1709	* If yes, then it uses a reference to an URL which the client can access
1710	* to get information on the status of a running Service (using the
1711	* percentCompleted attribute).
1712	* Else fallback to the initial method using the xml file to write in ...
1713	*/
1714	char ntmp[1024];
1715	#ifndef WIN32
1716	getcwd(ntmp,1024);
1717	#else
1718	_getcwd(ntmp,1024);
1719	#endif
1720	struct stat myFileInfo;
1721	int statRes;
1722	char file_path[1024];
1723	sprintf(file_path,"%s/GetStatus.zcfg",ntmp);
1724	statRes=stat(file_path,&myFileInfo);
1725	if(statRes==0){
1726	char currentSid[128];
1727	map* tmpm=getMap(tmp_maps->content,"rewriteUrl");
1728	map *tmp_lenv=NULL;
1729	tmp_lenv=getMapFromMaps(m,"lenv","usid");
1730	if(tmp_lenv==NULL)
1731	sprintf(currentSid,"%i",pid);
1732	else
1733	sprintf(currentSid,"%s",tmp_lenv->value);
1734	if(tmpm==NULL \|\| strcasecmp(tmpm->value,"false")==0){
1735	sprintf(url,"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1736	}else{
1737	if(strlen(tmpm->value)>0)
1738	if(strcasecmp(tmpm->value,"true")!=0)
1739	sprintf(url,"%s/%s/GetStatus/%s",tmpm1->value,tmpm->value,currentSid);
1740	else
1741	sprintf(url,"%s/GetStatus/%s",tmpm1->value,currentSid);
1742	else
1743	sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1744	}
1745	}else{
1746	int lpid;
1747	map* tmpm2=getMapFromMaps(m,"lenv","usid");
1748	lpid=atoi(tmpm2->value);
1749	tmpm2=getMap(tmp_maps->content,"tmpUrl");
1750	if(tmpm1!=NULL && tmpm2!=NULL){
1751	if( strncasecmp( tmpm2->value, "http://", 7) == 0 \|\|
1752	strncasecmp( tmpm2->value, "https://", 8 ) == 0 ){
1753	sprintf(url,"%s/%s_%i.xml",tmpm2->value,service,lpid);
1754	}else
1755	sprintf(url,"%s/%s/%s_%i.xml",tmpm1->value,tmpm2->value,service,lpid);
1756	}
1757	}
1758	if(tmpm1!=NULL)
1759	sprintf(tmp,"%s",tmpm1->value);
1760	int lpid;
1761	tmpm1=getMapFromMaps(m,"lenv","usid");
1762	lpid=atoi(tmpm1->value);
1763	tmpm1=getMapFromMaps(m,"main","TmpPath");
1764	sprintf(stored_path,"%s/%s_%i.xml",tmpm1->value,service,lpid);
1765	}
1766
1767
1768
1769	xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
1770	map* test=getMap(request,"storeExecuteResponse");
1771	bool hasStoredExecuteResponse=false;
1772	if(test!=NULL && strcasecmp(test->value,"true")==0){
1773	xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
1774	hasStoredExecuteResponse=true;
1775	}
1776
1777	nc = xmlNewNode(ns, BAD_CAST "Process");
1778	map* tmp2=getMap(serv->content,"processVersion");
1779	if(tmp2!=NULL)
1780	xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp2->value);
1781
1782	map* tmpI=getMapFromMaps(m,"lenv","oIdentifier");
1783	printDescription(nc,ns_ows,tmpI->value,serv->content);
1784
1785	xmlAddChild(n,nc);
1786
1787	nc = xmlNewNode(ns, BAD_CAST "Status");
1788	const struct tm *tm;
1789	size_t len;
1790	time_t now;
1791	char *tmp1;
1792	map *tmpStatus;
1793
1794	now = time ( NULL );
1795	tm = localtime ( &now );
1796
1797	tmp1 = (char)malloc((TIME_SIZE+1)sizeof(char));
1798
1799	len = strftime ( tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm );
1800
1801	xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
1802
1803	char sMsg[2048];
1804	switch(status){
1805	case SERVICE_SUCCEEDED:
1806	nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
1807	sprintf(sMsg,_("Service \"%s\" run successfully."),serv->name);
1808	nc3=xmlNewText(BAD_CAST sMsg);
1809	xmlAddChild(nc1,nc3);
1810	break;
1811	case SERVICE_STARTED:
1812	nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
1813	tmpStatus=getMapFromMaps(m,"lenv","status");
1814	xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST tmpStatus->value);
1815	sprintf(sMsg,_("ZOO Service \"%s\" is currently running. Please, reload this document to get the up-to-date status of the Service."),serv->name);
1816	nc3=xmlNewText(BAD_CAST sMsg);
1817	xmlAddChild(nc1,nc3);
1818	break;
1819	case SERVICE_ACCEPTED:
1820	nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
1821	sprintf(sMsg,_("Service \"%s\" was accepted by the ZOO Kernel and it run as a background task. Please consult the statusLocation attribtue providen in this document to get the up-to-date document."),serv->name);
1822	nc3=xmlNewText(BAD_CAST sMsg);
1823	xmlAddChild(nc1,nc3);
1824	break;
1825	case SERVICE_FAILED:
1826	nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
1827	map *errorMap;
1828	map *te;
1829	te=getMapFromMaps(m,"lenv","code");
1830	if(te!=NULL)
1831	errorMap=createMap("code",te->value);
1832	else
1833	errorMap=createMap("code","NoApplicableCode");
1834	te=getMapFromMaps(m,"lenv","message");
1835	if(te!=NULL)
1836	addToMap(errorMap,"text",_ss(te->value));
1837	else
1838	addToMap(errorMap,"text",_("No more information available"));
1839	nc3=createExceptionReportNode(m,errorMap,0);
1840	freeMap(&errorMap);
1841	free(errorMap);
1842	xmlAddChild(nc1,nc3);
1843	break;
1844	default :
1845	printf(_("error code not know : %i\n"),status);
1846	//exit(1);
1847	break;
1848	}
1849	xmlAddChild(nc,nc1);
1850	xmlAddChild(n,nc);
1851	free(tmp1);
1852
1853	#ifdef DEBUG
1854	fprintf(stderr,"printProcessResponse 1 161\n");
1855	#endif
1856
1857	map* lineage=getMap(request,"lineage");
1858	if(lineage!=NULL && strcasecmp(lineage->value,"true")==0){
1859	nc = xmlNewNode(ns, BAD_CAST "DataInputs");
1860	maps* mcursor=inputs;
1861	elements* scursor=NULL;
1862	while(mcursor!=NULL /&& scursor!=NULL/){
1863	scursor=getElements(serv->inputs,mcursor->name);
1864	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Input");
1865	mcursor=mcursor->next;
1866	}
1867	xmlAddChild(n,nc);
1868
1869	#ifdef DEBUG
1870	fprintf(stderr,"printProcessResponse 1 177\n");
1871	#endif
1872
1873	nc = xmlNewNode(ns, BAD_CAST "OutputDefinitions");
1874	mcursor=outputs;
1875	scursor=NULL;
1876	while(mcursor!=NULL){
1877	scursor=getElements(serv->outputs,mcursor->name);
1878	printOutputDefinitions1(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
1879	mcursor=mcursor->next;
1880	}
1881	xmlAddChild(n,nc);
1882	}
1883	#ifdef DEBUG
1884	fprintf(stderr,"printProcessResponse 1 190\n");
1885	#endif
1886
1887	/**
1888	* Display the process output only when requested !
1889	*/
1890	if(status==SERVICE_SUCCEEDED){
1891	nc = xmlNewNode(ns, BAD_CAST "ProcessOutputs");
1892	maps* mcursor=outputs;
1893	elements* scursor=serv->outputs;
1894	map* testResponse=getMap(request,"RawDataOutput");
1895	if(testResponse==NULL)
1896	testResponse=getMap(request,"ResponseDocument");
1897	while(mcursor!=NULL){
1898	map* tmp0=getMap(mcursor->content,"inRequest");
1899	scursor=getElements(serv->outputs,mcursor->name);
1900	if(scursor!=NULL){
1901	if(testResponse==NULL \|\| tmp0==NULL)
1902	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1903	else
1904	if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0)
1905	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1906	}else
1907	/**
1908	* In case there was no definition found in the ZCFG file but
1909	* present in the service code
1910	*/
1911	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1912	mcursor=mcursor->next;
1913	}
1914	xmlAddChild(n,nc);
1915	}
1916
1917	#ifdef DEBUG
1918	fprintf(stderr,"printProcessResponse 1 202\n");
1919	#endif
1920	nr=soapEnvelope(m,n);
1921	xmlDocSetRootElement(doc, nr);
1922
1923	if(hasStoredExecuteResponse==true && status!=SERVICE_STARTED){
1924	semid lid=getShmLockId(m,1);
1925	if(lid<0)
1926	return;
1927	else{
1928	#ifdef DEBUG
1929	fprintf(stderr,"LOCK %s %d !\n",__FILE__,__LINE__);
1930	#endif
1931	lockShm(lid);
1932	/* We need to write the ExecuteResponse Document somewhere */
1933	FILE* output=fopen(stored_path,"w");
1934	if(output==NULL){
1935	/* If the file cannot be created return an ExceptionReport */
1936	char tmpMsg[1024];
1937	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the ExecuteResponse."),stored_path);
1938	map * errormap = createMap("text",tmpMsg);
1939	addToMap(errormap,"code", "InternalError");
1940	printExceptionReportResponse(m,errormap);
1941	freeMap(&errormap);
1942	free(errormap);
1943	xmlFreeDoc(doc);
1944	xmlCleanupParser();
1945	zooXmlCleanupNs();
1946	unlockShm(lid);
1947	return;
1948	}
1949	xmlChar *xmlbuff;
1950	int buffersize;
1951	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, "UTF-8", 1);
1952	fwrite(xmlbuff,1,xmlStrlen(xmlbuff)*sizeof(char),output);
1953	xmlFree(xmlbuff);
1954	fclose(output);
1955	#ifdef DEBUG
1956	fprintf(stderr,"UNLOCK %s %d !\n",__FILE__,__LINE__);
1957	#endif
1958	unlockShm(lid);
1959	map* test1=getMap(request,"status");
1960	if(test1==NULL \|\| strcasecmp(test1->value,"true")!=0){
1961	removeShmLock(m,1);
1962	}
1963	}
1964	}
1965	printDocument(m,doc,pid);
1966
1967	xmlCleanupParser();
1968	zooXmlCleanupNs();
1969	}
1970
1971
1972	void printDocument(maps* m, xmlDocPtr doc,int pid){
1973	char *encoding=getEncoding(m);
1974	if(pid==getpid()){
1975	printHeaders(m);
1976	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1977	}
1978	fflush(stdout);
1979	xmlChar *xmlbuff;
1980	int buffersize;
1981	/*
1982	* Dump the document to a buffer and print it on stdout
1983	* for demonstration purposes.
1984	*/
1985	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
1986	printf("%s",xmlbuff);
1987	fflush(stdout);
1988	/*
1989	* Free associated memory.
1990	*/
1991	xmlFree(xmlbuff);
1992	xmlFreeDoc(doc);
1993	xmlCleanupParser();
1994	zooXmlCleanupNs();
1995	}
1996
1997	void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,const char* type){
1998	xmlNodePtr nc1;
1999	nc1=xmlNewNode(ns_wps, BAD_CAST type);
2000	map *tmp=NULL;
2001	if(e!=NULL && e->defaults!=NULL)
2002	tmp=e->defaults->content;
2003	else{
2004	/*
2005	dumpElements(e);
2006	*/
2007	return;
2008	}
2009	while(tmp!=NULL){
2010	if(strncasecmp(tmp->name,"MIMETYPE",strlen(tmp->name))==0
2011	\|\| strncasecmp(tmp->name,"ENCODING",strlen(tmp->name))==0
2012	\|\| strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
2013	\|\| strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
2014	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
2015	tmp=tmp->next;
2016	}
2017	tmp=getMap(e->defaults->content,"asReference");
2018	if(tmp==NULL)
2019	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
2020
2021	tmp=e->content;
2022
2023	printDescription(nc1,ns_ows,m->name,e->content);
2024
2025	xmlAddChild(nc,nc1);
2026
2027	}
2028
2029	void printOutputDefinitions(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,map* m,const char* type){
2030	xmlNodePtr nc1;
2031	nc1=xmlNewNode(ns_wps, BAD_CAST type);
2032	map *tmp=NULL;
2033	if(e!=NULL && e->defaults!=NULL)
2034	tmp=e->defaults->content;
2035	else{
2036	/*
2037	dumpElements(e);
2038	*/
2039	return;
2040	}
2041	while(tmp!=NULL){
2042	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
2043	tmp=tmp->next;
2044	}
2045	tmp=getMap(e->defaults->content,"asReference");
2046	if(tmp==NULL)
2047	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
2048
2049	tmp=e->content;
2050
2051	printDescription(nc1,ns_ows,m->name,e->content);
2052
2053	xmlAddChild(nc,nc1);
2054
2055	}
2056
2057	void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
2058	xmlNodePtr nc1,nc2,nc3;
2059	nc1=xmlNewNode(ns_wps, BAD_CAST type);
2060	map *tmp=NULL;
2061	if(e!=NULL)
2062	tmp=e->content;
2063	else
2064	tmp=m->content;
2065	#ifdef DEBUG
2066	dumpMap(tmp);
2067	dumpElements(e);
2068	#endif
2069	nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
2070	if(e!=NULL)
2071	nc3=xmlNewText(BAD_CAST e->name);
2072	else
2073	nc3=xmlNewText(BAD_CAST m->name);
2074	xmlAddChild(nc2,nc3);
2075	xmlAddChild(nc1,nc2);
2076	xmlAddChild(nc,nc1);
2077	if(e!=NULL)
2078	tmp=getMap(e->content,"Title");
2079	else
2080	tmp=getMap(m->content,"Title");
2081
2082	if(tmp!=NULL){
2083	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
2084	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
2085	xmlAddChild(nc2,nc3);
2086	xmlAddChild(nc1,nc2);
2087	}
2088
2089	if(e!=NULL)
2090	tmp=getMap(e->content,"Abstract");
2091	else
2092	tmp=getMap(m->content,"Abstract");
2093	if(tmp!=NULL){
2094	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
2095	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
2096	xmlAddChild(nc2,nc3);
2097	xmlAddChild(nc1,nc2);
2098	xmlAddChild(nc,nc1);
2099	}
2100
2101	/**
2102	* IO type Reference or full Data ?
2103	*/
2104	#ifdef DEBUG
2105	fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
2106	#endif
2107	map *tmpMap=getMap(m->content,"Reference");
2108	if(tmpMap==NULL){
2109	nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
2110	if(e!=NULL){
2111	if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
2112	nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
2113	else
2114	if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
2115	nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
2116	else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
2117	nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
2118	else
2119	nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
2120	}
2121	else{
2122	map* tmpV=getMapFromMaps(m,"format","value");
2123	if(tmpV!=NULL)
2124	nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
2125	else
2126	nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
2127	}
2128	tmp=m->content;
2129	#ifdef USE_MS
2130	map* testMap=getMap(tmp,"requestedMimeType");
2131	#endif
2132	while(tmp!=NULL){
2133	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
2134	strcasecmp(tmp->name,"encoding")==0 \|\|
2135	strcasecmp(tmp->name,"schema")==0 \|\|
2136	strcasecmp(tmp->name,"datatype")==0 \|\|
2137	strcasecmp(tmp->name,"uom")==0){
2138	#ifdef USE_MS
2139	if(testMap==NULL \|\| (testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)==0)){
2140	#endif
2141	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
2142	#ifdef USE_MS
2143	}
2144	else
2145	if(strcasecmp(tmp->name,"mimeType")==0){
2146	if(testMap!=NULL)
2147	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
2148	else
2149	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
2150	}
2151	#endif
2152	}
2153	tmp=tmp->next;
2154	xmlAddChild(nc2,nc3);
2155	}
2156	if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
2157	map* bb=getMap(m->content,"value");
2158	if(bb!=NULL){
2159	map* tmpRes=parseBoundingBox(bb->value);
2160	printBoundingBox(ns_ows,nc3,tmpRes);
2161	freeMap(&tmpRes);
2162	free(tmpRes);
2163	}
2164	}else{
2165	if(e!=NULL)
2166	tmp=getMap(e->defaults->content,"mimeType");
2167	else
2168	tmp=NULL;
2169	#ifdef USE_MS
2170	/**
2171	* In case of OGC WebServices output use, as the data was requested
2172	* with asReference=false we have to download the resulting OWS request
2173	* stored in the Reference map value.
2174	*/
2175	map* testMap=getMap(m->content,"requestedMimeType");
2176	if(testMap!=NULL){
2177	HINTERNET hInternet;
2178	char* tmpValue;
2179	size_t dwRead;
2180	hInternet=InternetOpen(
2181	#ifndef WIN32
2182	(LPCTSTR)
2183	#endif
2184	"ZooWPSClient\0",
2185	INTERNET_OPEN_TYPE_PRECONFIG,
2186	NULL,NULL, 0);
2187	testMap=getMap(m->content,"Reference");
2188	loadRemoteFile(&m,&m->content,&hInternet,testMap->value);
2189	processDownloads(&hInternet);
2190	tmpValue=(char)malloc((hInternet.ihandle[0].nDataLen+1)sizeof(char));
2191	InternetReadFile(hInternet.ihandle[0],(LPVOID)tmpValue,hInternet.ihandle[0].nDataLen,&dwRead);
2192	InternetCloseHandle(&hInternet);
2193	}
2194	#endif
2195	map* tmp1=getMap(m->content,"encoding");
2196	map* tmp2=getMap(m->content,"mimeType");
2197	map* tmp3=getMap(m->content,"value");
2198	int hasValue=1;
2199	if(tmp3==NULL){
2200	tmp3=createMap("value","");
2201	hasValue=-1;
2202	}
2203	if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
2204	\|\| (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 \|\|
2205	(strncmp(tmp2->value,"application/",12)==0 &&
2206	strncmp(tmp2->value,"application/json",16)!=0&&
2207	strncmp(tmp2->value,"application/x-javascript",24)!=0&&
2208	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)!=0))
2209	)) {
2210	map* rs=getMap(m->content,"size");
2211	bool isSized=true;
2212	if(rs==NULL){
2213	char tmp1[1024];
2214	sprintf(tmp1,"%u",strlen(tmp3->value));
2215	rs=createMap("size",tmp1);
2216	isSized=false;
2217	}
2218
2219	xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
2220	if(tmp1==NULL \|\| (tmp1!=NULL && strncmp(tmp1->value,"base64",6)!=0))
2221	xmlNewProp(nc3,BAD_CAST "encoding",BAD_CAST "base64");
2222	if(!isSized){
2223	freeMap(&rs);
2224	free(rs);
2225	}
2226	}
2227	else if(tmp2!=NULL){
2228	if(strncmp(tmp2->value,"text/js",7)==0 \|\|
2229	strncmp(tmp2->value,"application/json",16)==0)
2230	xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
2231	else{
2232	if(strncmp(tmp2->value,"text/xml",8)==0 \|\|
2233	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
2234	int li=zooXmlAddDoc(tmp3->value);
2235	xmlDocPtr doc = iDocs[li];
2236	xmlNodePtr ir = xmlDocGetRootElement(doc);
2237	xmlAddChild(nc3,ir);
2238	}
2239	else
2240	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
2241	}
2242	xmlAddChild(nc2,nc3);
2243	}
2244	else{
2245	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
2246	}
2247	if(hasValue<0){
2248	freeMap(&tmp3);
2249	free(tmp3);
2250	}
2251	}
2252	}
2253	else{
2254	tmpMap=getMap(m->content,"Reference");
2255	nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
2256	if(strcasecmp(type,"Output")==0)
2257	xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
2258	else
2259	xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
2260	tmp=m->content;
2261	#ifdef USE_MS
2262	map* testMap=getMap(tmp,"requestedMimeType");
2263	#endif
2264	while(tmp!=NULL){
2265	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
2266	strcasecmp(tmp->name,"encoding")==0 \|\|
2267	strcasecmp(tmp->name,"schema")==0 \|\|
2268	strcasecmp(tmp->name,"datatype")==0 \|\|
2269	strcasecmp(tmp->name,"uom")==0){
2270	#ifdef USE_MS
2271	if(testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)!=0){
2272	if(strcasecmp(tmp->name,"mimeType")==0)
2273	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
2274	}
2275	else
2276	#endif
2277	if(strcasecmp(tmp->name,"datatype")==0)
2278	xmlNewProp(nc3,BAD_CAST "mimeType",BAD_CAST "text/plain");
2279	else
2280	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
2281	}
2282	tmp=tmp->next;
2283	xmlAddChild(nc2,nc3);
2284	}
2285	}
2286	xmlAddChild(nc1,nc2);
2287	xmlAddChild(nc,nc1);
2288
2289	}
2290
2291	void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
2292	xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
2293
2294	xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
2295	xmlAddChild(root,nc2);
2296	map* tmp=amap;
2297	const char *tmp2[2];
2298	tmp2[0]="Title";
2299	tmp2[1]="Abstract";
2300	int j=0;
2301	for(j=0;j<2;j++){
2302	map* tmp1=getMap(tmp,tmp2[j]);
2303	if(tmp1!=NULL){
2304	nc2 = xmlNewNode(ns_ows, BAD_CAST tmp2[j]);
2305	xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
2306	xmlAddChild(root,nc2);
2307	}
2308	}
2309	}
2310
2311	char* getEncoding(maps* m){
2312	if(m!=NULL){
2313	map* tmp=getMap(m->content,"encoding");
2314	if(tmp!=NULL){
2315	return tmp->value;
2316	}
2317	else
2318	return (char*)"UTF-8";
2319	}
2320	else
2321	return (char*)"UTF-8";
2322	}
2323
2324	char* getVersion(maps* m){
2325	if(m!=NULL){
2326	map* tmp=getMap(m->content,"version");
2327	if(tmp!=NULL){
2328	return tmp->value;
2329	}
2330	else
2331	return (char*)"1.0.0";
2332	}
2333	else
2334	return (char*)"1.0.0";
2335	}
2336
2337	void printExceptionReportResponse(maps* m,map* s){
2338	if(getMapFromMaps(m,"lenv","hasPrinted")!=NULL)
2339	return;
2340	int buffersize;
2341	xmlDocPtr doc;
2342	xmlChar *xmlbuff;
2343	xmlNodePtr n;
2344
2345	zooXmlCleanupNs();
2346	doc = xmlNewDoc(BAD_CAST "1.0");
2347	maps* tmpMap=getMaps(m,"main");
2348	char *encoding=getEncoding(tmpMap);
2349	const char *exceptionCode;
2350
2351	map* tmp=getMap(s,"code");
2352	if(tmp!=NULL){
2353	if(strcmp(tmp->value,"OperationNotSupported")==0)
2354	exceptionCode="501 Not Implemented";
2355	else
2356	if(strcmp(tmp->value,"MissingParameterValue")==0 \|\|
2357	strcmp(tmp->value,"InvalidUpdateSequence")==0 \|\|
2358	strcmp(tmp->value,"OptionNotSupported")==0 \|\|
2359	strcmp(tmp->value,"VersionNegotiationFailed")==0 \|\|
2360	strcmp(tmp->value,"InvalidParameterValue")==0)
2361	exceptionCode="400 Bad request";
2362	else
2363	if(strcmp(tmp->value,"NoApplicableCode")==0)
2364	exceptionCode="501 Internal Server Error";
2365	else
2366	exceptionCode="501 Internal Server Error";
2367	}
2368	else
2369	exceptionCode="501 Internal Server Error";
2370
2371	if(m!=NULL){
2372	map *tmpSid=getMapFromMaps(m,"lenv","sid");
2373	if(tmpSid!=NULL){
2374	if( getpid()==atoi(tmpSid->value) ){
2375	printHeaders(m);
2376	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2377	}
2378	}
2379	else{
2380	printHeaders(m);
2381	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2382	}
2383	}else{
2384	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2385	}
2386	n=createExceptionReportNode(m,s,1);
2387	xmlDocSetRootElement(doc, n);
2388	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2389	printf("%s",xmlbuff);
2390	fflush(stdout);
2391	xmlFreeDoc(doc);
2392	xmlFree(xmlbuff);
2393	xmlCleanupParser();
2394	zooXmlCleanupNs();
2395	if(m!=NULL)
2396	setMapInMaps(m,"lenv","hasPrinted","true");
2397	}
2398
2399	xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
2400
2401	xmlNsPtr ns,ns_xsi;
2402	xmlNodePtr n,nc,nc1;
2403
2404	int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows","ows");
2405	ns=usedNs[nsid];
2406	if(use_ns==1){
2407	ns=NULL;
2408	}
2409	n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
2410	if(use_ns==1){
2411	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",NULL);
2412	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2413	ns_xsi=usedNs[xsiId];
2414	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsExceptionReport.xsd");
2415	}
2416
2417
2418	addLangAttr(n,m);
2419	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.1.0");
2420
2421	nc = xmlNewNode(ns, BAD_CAST "Exception");
2422
2423	map* tmp=getMap(s,"code");
2424	if(tmp!=NULL)
2425	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST tmp->value);
2426	else
2427	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST "NoApplicableCode");
2428
2429	tmp=getMap(s,"locator");
2430	if(tmp!=NULL && strcasecmp(tmp->value,"NULL")!=0)
2431	xmlNewProp(nc,BAD_CAST "locator",BAD_CAST tmp->value);
2432
2433
2434	tmp=getMap(s,"text");
2435	nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
2436	if(tmp!=NULL){
2437	xmlNodePtr txt=xmlNewText(BAD_CAST tmp->value);
2438	xmlAddChild(nc1,txt);
2439	}
2440	else{
2441	xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
2442	}
2443	xmlAddChild(nc,nc1);
2444	xmlAddChild(n,nc);
2445	return n;
2446	}
2447
2448	/************************************************************************/
2449	/* readGeneratedFile() */
2450	/************************************************************************/
2451
2452	/**
2453	* Read a file generated by a service.
2454	*
2455	* @param m the conf maps
2456	* @param content the output item
2457	* @param filename the file to read
2458	*/
2459	void readGeneratedFile(maps* m,map* content,char* filename){
2460	FILE * file=fopen(filename,"rb");
2461	fseek(file, 0, SEEK_END);
2462	long count = ftell(file);
2463	rewind(file);
2464	struct stat file_status;
2465	stat(filename, &file_status);
2466	if(file==NULL){
2467	fprintf(stderr,"Failed to open file %s for reading purpose.\n",filename);
2468	setMapInMaps(m,"lenv","message","Unable to read produced file. Please try again later");
2469	return ;
2470	}
2471	map* tmpMap1=getMap(content,"value");
2472	if(tmpMap1==NULL){
2473	addToMap(content,"value","");
2474	tmpMap1=getMap(content,"value");
2475	}
2476	free(tmpMap1->value);
2477	tmpMap1->value=(char) malloc((count+1)sizeof(char));
2478	fread(tmpMap1->value,1,count*sizeof(char),file);
2479	fclose(file);
2480	char rsize[100];
2481	sprintf(rsize,"%d",count*sizeof(char));
2482	addToMap(tmpMap1,"size",rsize);
2483	}
2484
2485	void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
2486	map* request_inputs1,int cpid,maps* m,int res){
2487	#ifdef DEBUG
2488	dumpMaps(request_inputs);
2489	dumpMaps(request_outputs);
2490	fprintf(stderr,"printProcessResponse\n");
2491	#endif
2492	map* toto=getMap(request_inputs1,"RawDataOutput");
2493	int asRaw=0;
2494	if(toto!=NULL)
2495	asRaw=1;
2496
2497	maps* tmpSess=getMaps(m,"senv");
2498	if(tmpSess!=NULL){
2499	map *_tmp=getMapFromMaps(m,"lenv","cookie");
2500	char* sessId=NULL;
2501	if(_tmp!=NULL){
2502	printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
2503	printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
2504	char session_file_path[100];
2505	char *tmp1=strtok(_tmp->value,";");
2506	if(tmp1!=NULL)
2507	sprintf(session_file_path,"%s",strstr(tmp1,"=")+1);
2508	else
2509	sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
2510	sessId=strdup(session_file_path);
2511	}else{
2512	maps* t=getMaps(m,"senv");
2513	map*p=t->content;
2514	while(p!=NULL){
2515	if(strstr(p->name,"ID")!=NULL){
2516	sessId=strdup(p->value);
2517	break;
2518	}
2519	p=p->next;
2520	}
2521	}
2522	char session_file_path[1024];
2523	map *tmpPath=getMapFromMaps(m,"main","sessPath");
2524	if(tmpPath==NULL)
2525	tmpPath=getMapFromMaps(m,"main","tmpPath");
2526	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,sessId);
2527	FILE* teste=fopen(session_file_path,"w");
2528	if(teste==NULL){
2529	char tmpMsg[1024];
2530	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the session maps."),session_file_path);
2531	map * errormap = createMap("text",tmpMsg);
2532	addToMap(errormap,"code", "InternalError");
2533
2534	printExceptionReportResponse(m,errormap);
2535	freeMap(&errormap);
2536	free(errormap);
2537	return;
2538	}
2539	else{
2540	fclose(teste);
2541	dumpMapsToFile(tmpSess,session_file_path);
2542	}
2543	}
2544
2545	if(res==SERVICE_FAILED){
2546	map * errormap;
2547	map *lenv;
2548	lenv=getMapFromMaps(m,"lenv","message");
2549	char *tmp0;
2550	if(lenv!=NULL){
2551	tmp0=(char)malloc((strlen(lenv->value)+strlen(_("Unable to run the Service. The message returned back by the Service was the following: "))+1)sizeof(char));
2552	sprintf(tmp0,_("Unable to run the Service. The message returned back by the Service was the following: %s"),lenv->value);
2553	}
2554	else{
2555	tmp0=(char)malloc((strlen(_("Unable to run the Service. No more information was returned back by the Service."))+1)sizeof(char));
2556	sprintf(tmp0,_("Unable to run the Service. No more information was returned back by the Service."));
2557	}
2558	errormap = createMap("text",tmp0);
2559	free(tmp0);
2560	addToMap(errormap,"code", "InternalError");
2561	dumpMap(errormap);
2562	printExceptionReportResponse(m,errormap);
2563	freeMap(&errormap);
2564	free(errormap);
2565	return;
2566	}
2567
2568
2569	if(asRaw==0){
2570	#ifdef DEBUG
2571	fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
2572	dumpMaps(request_outputs);
2573	#endif
2574	maps* tmpI=request_outputs;
2575	while(tmpI!=NULL){
2576	#ifdef USE_MS
2577	map* testMap=getMap(tmpI->content,"useMapserver");
2578	#endif
2579	toto=getMap(tmpI->content,"asReference");
2580	#ifdef USE_MS
2581	if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
2582	#else
2583	if(toto!=NULL && strcasecmp(toto->value,"true")==0)
2584	#endif
2585	{
2586	elements* in=getElements(s->outputs,tmpI->name);
2587	char *format=NULL;
2588	if(in!=NULL){
2589	format=strdup(in->format);
2590	}else
2591	format=strdup("LiteralData");
2592	if(strcasecmp(format,"BoundingBoxData")==0){
2593	addToMap(tmpI->content,"extension","xml");
2594	addToMap(tmpI->content,"mimeType","text/xml");
2595	addToMap(tmpI->content,"encoding","UTF-8");
2596	addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
2597	}
2598
2599	map *tmp1=getMapFromMaps(m,"main","tmpPath");
2600
2601	map *gfile=getMap(tmpI->content,"generated_file");
2602	char *file_name;
2603	if(gfile!=NULL){
2604	readGeneratedFile(m,tmpI->content,gfile->value);
2605	file_name=(char)malloc((strlen(gfile->value)+strlen(tmp1->value)+1)sizeof(char));
2606	for(int i=0;i<strlen(gfile->value);i++)
2607	file_name[i]=gfile->value[i+strlen(tmp1->value)];
2608	}
2609	else{
2610	map *ext=getMap(tmpI->content,"extension");
2611	char *file_path;
2612	bool hasExt=true;
2613	if(ext==NULL){
2614	// We can fallback to a default list of supported formats using
2615	// mimeType information if present here. Maybe we can add more formats
2616	// here.
2617	// If mimeType was not found, we then set txt as the default extension
2618	map* mtype=getMap(tmpI->content,"mimeType");
2619	if(mtype!=NULL) {
2620	if(strncasecmp(mtype->value,"text/xml",8)==0)
2621	ext=createMap("extension","xml");
2622	else if(strncasecmp(mtype->value,"application/zip",15)==0)
2623	ext=createMap("extension","zip");
2624	else if(strncasecmp(mtype->value,"application/json",16)==0)
2625	ext=createMap("extension","js");
2626	else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
2627	ext=createMap("extension","kml");
2628	else if(strncmp(mtype->value,"image/",6)==0)
2629	ext=createMap("extension",strstr(mtype->value,"/")+1);
2630	else
2631	ext=createMap("extension","txt");
2632	}
2633	else
2634	ext=createMap("extension","txt");
2635	hasExt=false;
2636	}
2637	file_name=(char)malloc((strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+1024)sizeof(char));
2638	int cpid0=cpid+time(NULL);
2639	sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,ext->value);
2640	file_path=(char)malloc((strlen(tmp1->value)+strlen(file_name)+2)sizeof(char));
2641	sprintf(file_path,"%s/%s",tmp1->value,file_name);
2642	FILE *ofile=fopen(file_path,"wb");
2643	if(ofile==NULL){
2644	char tmpMsg[1024];
2645	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the %s final result."),file_name,tmpI->name);
2646	map * errormap = createMap("text",tmpMsg);
2647	addToMap(errormap,"code", "InternalError");
2648	printExceptionReportResponse(m,errormap);
2649	freeMap(&errormap);
2650	free(errormap);
2651	free(file_name);
2652	free(file_path);
2653	return;
2654	}
2655	free(file_path);
2656	if(!hasExt){
2657	freeMap(&ext);
2658	free(ext);
2659	}
2660	toto=getMap(tmpI->content,"value");
2661	if(strcasecmp(format,"BoundingBoxData")!=0){
2662	map* size=getMap(tmpI->content,"size");
2663	if(size!=NULL && toto!=NULL)
2664	fwrite(toto->value,1,atoi(size->value)*sizeof(char),ofile);
2665	else
2666	if(toto!=NULL && toto->value!=NULL)
2667	fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
2668	}else{
2669	printBoundingBoxDocument(m,tmpI,ofile);
2670	}
2671	fclose(ofile);
2672
2673	}
2674	map *tmp2=getMapFromMaps(m,"main","tmpUrl");
2675	map *tmp3=getMapFromMaps(m,"main","serverAddress");
2676	char *file_url;
2677	if(strncasecmp(tmp2->value,"http://",7)==0 \|\|
2678	strncasecmp(tmp2->value,"https://",8)==0){
2679	file_url=(char)malloc((strlen(tmp2->value)+strlen(file_name)+2)sizeof(char));
2680	sprintf(file_url,"%s/%s",tmp2->value,file_name);
2681	}else{
2682	file_url=(char)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)sizeof(char));
2683	sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
2684	}
2685	addToMap(tmpI->content,"Reference",file_url);
2686	free(format);
2687	free(file_name);
2688	free(file_url);
2689
2690	}
2691	#ifdef USE_MS
2692	else{
2693	if(testMap!=NULL){
2694	setReferenceUrl(m,tmpI);
2695	}
2696	}
2697	#endif
2698	tmpI=tmpI->next;
2699	}
2700	map *r_inputs=getMap(s->content,"serviceProvider");
2701	#ifdef DEBUG
2702	fprintf(stderr,"SERVICE : %s\n",r_inputs->value);
2703	dumpMaps(m);
2704	#endif
2705	printProcessResponse(m,request_inputs1,cpid,
2706	s,r_inputs->value,res,
2707	request_inputs,
2708	request_outputs);
2709	}
2710	else{
2711	/**
2712	* We get the requested output or fallback to the first one if the
2713	* requested one is not present in the resulting outputs maps.
2714	*/
2715	maps* tmpI=NULL;
2716	map* tmpIV=getMap(request_inputs1,"RawDataOutput");
2717	if(tmpIV!=NULL){
2718	tmpI=getMaps(request_outputs,tmpIV->value);
2719	}
2720	if(tmpI==NULL)
2721	tmpI=request_outputs;
2722	elements* e=getElements(s->outputs,tmpI->name);
2723	if(e!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
2724	printBoundingBoxDocument(m,tmpI,NULL);
2725	}else{
2726	map *gfile=getMap(tmpI->content,"generated_file");
2727	if(gfile!=NULL){
2728	readGeneratedFile(m,tmpI->content,gfile->value);
2729	}
2730	toto=getMap(tmpI->content,"value");
2731	if(toto==NULL){
2732	char tmpMsg[1024];
2733	sprintf(tmpMsg,_("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),tmpI->name);
2734	map * errormap = createMap("text",tmpMsg);
2735	addToMap(errormap,"code", "InvalidParameterValue");
2736	printExceptionReportResponse(m,errormap);
2737	freeMap(&errormap);
2738	free(errormap);
2739	return;
2740	}
2741	map* fname=getMapFromMaps(tmpI,tmpI->name,"filename");
2742	if(fname!=NULL)
2743	printf("Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
2744	map* rs=getMapFromMaps(tmpI,tmpI->name,"size");
2745	if(rs!=NULL)
2746	printf("Content-Length: %s\r\n",rs->value);
2747	printHeaders(m);
2748	char mime[1024];
2749	map* mi=getMap(tmpI->content,"mimeType");
2750	#ifdef DEBUG
2751	fprintf(stderr,"SERVICE OUTPUTS\n");
2752	dumpMaps(request_outputs);
2753	fprintf(stderr,"SERVICE OUTPUTS\n");
2754	#endif
2755	map* en=getMap(tmpI->content,"encoding");
2756	if(mi!=NULL && en!=NULL)
2757	sprintf(mime,
2758	"Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
2759	mi->value,en->value);
2760	else
2761	if(mi!=NULL)
2762	sprintf(mime,
2763	"Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
2764	mi->value);
2765	else
2766	sprintf(mime,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
2767	printf("%s",mime);
2768	if(rs!=NULL)
2769	fwrite(toto->value,1,atoi(rs->value),stdout);
2770	else
2771	fwrite(toto->value,1,strlen(toto->value),stdout);
2772	#ifdef DEBUG
2773	dumpMap(toto);
2774	#endif
2775	}
2776	}
2777	}
2778
2779	char base64(const char input, int length)
2780	{
2781	BIO bmem, b64;
2782	BUF_MEM *bptr;
2783
2784	b64 = BIO_new(BIO_f_base64());
2785	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
2786	bmem = BIO_new(BIO_s_mem());
2787	b64 = BIO_push(b64, bmem);
2788	BIO_write(b64, input, length+1);
2789	BIO_flush(b64);
2790	BIO_get_mem_ptr(b64, &bptr);
2791
2792	char buff = (char )malloc((bptr->length+1)*sizeof(char));
2793	memcpy(buff, bptr->data, bptr->length);
2794	buff[bptr->length-1] = 0;
2795
2796	BIO_free_all(b64);
2797
2798	return buff;
2799	}
2800
2801	char base64d(const char input, int length,int* red)
2802	{
2803	BIO b64, bmem;
2804
2805	char buffer = (char )malloc(length);
2806	if(buffer){
2807	memset(buffer, 0, length);
2808	b64 = BIO_new(BIO_f_base64());
2809	if(b64){
2810	bmem = BIO_new_mem_buf((unsigned char*)input,length);
2811	bmem = BIO_push(b64, bmem);
2812	*red=BIO_read(bmem, buffer, length);
2813	buffer[length-1]=0;
2814	BIO_free_all(bmem);
2815	}
2816	}
2817	return buffer;
2818	}
2819
2820	void ensureDecodedBase64(maps **in){
2821	maps* cursor=*in;
2822	while(cursor!=NULL){
2823	map *tmp=getMap(cursor->content,"encoding");
2824	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
2825	tmp=getMap(cursor->content,"value");
2826	addToMap(cursor->content,"base64_value",tmp->value);
2827	int size=0;
2828	char *s=strdup(tmp->value);
2829	free(tmp->value);
2830	tmp->value=base64d(s,strlen(s),&size);
2831	free(s);
2832	char sizes[1024];
2833	sprintf(sizes,"%d",size);
2834	addToMap(cursor->content,"size",sizes);
2835	}
2836	cursor=cursor->next;
2837	}
2838	}
2839
2840	char* addDefaultValues(maps** out,elements* in,maps* m,int type){
2841	elements* tmpInputs=in;
2842	maps* out1=*out;
2843	if(type==1){
2844	while(out1!=NULL){
2845	if(getElements(in,out1->name)==NULL)
2846	return out1->name;
2847	out1=out1->next;
2848	}
2849	out1=*out;
2850	}
2851	while(tmpInputs!=NULL){
2852	maps *tmpMaps=getMaps(out1,tmpInputs->name);
2853	if(tmpMaps==NULL){
2854	maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
2855	tmpMaps2->name=strdup(tmpInputs->name);
2856	tmpMaps2->content=NULL;
2857	tmpMaps2->next=NULL;
2858
2859	if(type==0){
2860	map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
2861	if(tmpMapMinO!=NULL){
2862	if(atoi(tmpMapMinO->value)>=1){
2863	freeMaps(&tmpMaps2);
2864	free(tmpMaps2);
2865	return tmpInputs->name;
2866	}
2867	else{
2868	if(tmpMaps2->content==NULL)
2869	tmpMaps2->content=createMap("minOccurs",tmpMapMinO->value);
2870	else
2871	addToMap(tmpMaps2->content,"minOccurs",tmpMapMinO->value);
2872	}
2873	}
2874	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2875	if(tmpMaxO!=NULL){
2876	if(tmpMaps2->content==NULL)
2877	tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
2878	else
2879	addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
2880	}
2881	map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
2882	if(tmpMaxMB!=NULL){
2883	if(tmpMaps2->content==NULL)
2884	tmpMaps2->content=createMap("maximumMegabytes",tmpMaxMB->value);
2885	else
2886	addToMap(tmpMaps2->content,"maximumMegabytes",tmpMaxMB->value);
2887	}
2888	}
2889
2890	iotype* tmpIoType=tmpInputs->defaults;
2891	if(tmpIoType!=NULL){
2892	map* tmpm=tmpIoType->content;
2893	while(tmpm!=NULL){
2894	if(tmpMaps2->content==NULL)
2895	tmpMaps2->content=createMap(tmpm->name,tmpm->value);
2896	else
2897	addToMap(tmpMaps2->content,tmpm->name,tmpm->value);
2898	tmpm=tmpm->next;
2899	}
2900	}
2901	addToMap(tmpMaps2->content,"inRequest","false");
2902	if(type==0){
2903	map *tmpMap=getMap(tmpMaps2->content,"value");
2904	if(tmpMap==NULL)
2905	addToMap(tmpMaps2->content,"value","NULL");
2906	}
2907	if(out1==NULL){
2908	*out=dupMaps(&tmpMaps2);
2909	out1=*out;
2910	}
2911	else
2912	addMapsToMaps(&out1,tmpMaps2);
2913	freeMap(&tmpMaps2->content);
2914	free(tmpMaps2->content);
2915	tmpMaps2->content=NULL;
2916	freeMaps(&tmpMaps2);
2917	free(tmpMaps2);
2918	tmpMaps2=NULL;
2919	}
2920	else{
2921	iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
2922	tmpMaps->content);
2923	if(type==0) {
2924	/**
2925	* In case of an Input maps, then add the minOccurs and maxOccurs to the
2926	* content map.
2927	*/
2928	map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
2929	if(tmpMap1!=NULL){
2930	if(tmpMaps->content==NULL)
2931	tmpMaps->content=createMap("minOccurs",tmpMap1->value);
2932	else
2933	addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
2934	}
2935	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2936	if(tmpMaxO!=NULL){
2937	if(tmpMaps->content==NULL)
2938	tmpMaps->content=createMap("maxOccurs",tmpMaxO->value);
2939	else
2940	addToMap(tmpMaps->content,"maxOccurs",tmpMaxO->value);
2941	}
2942	map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
2943	if(tmpMaxMB!=NULL){
2944	if(tmpMaps->content==NULL)
2945	tmpMaps->content=createMap("maximumMegabytes",tmpMaxMB->value);
2946	else
2947	addToMap(tmpMaps->content,"maximumMegabytes",tmpMaxMB->value);
2948	}
2949	/**
2950	* Parsing BoundingBoxData, fill the following map and then add it to
2951	* the content map of the Input maps:
2952	* lowerCorner, upperCorner, srs and dimensions
2953	* cf. parseBoundingBox
2954	*/
2955	if(strcasecmp(tmpInputs->format,"BoundingBoxData")==0){
2956	maps* tmpI=getMaps(*out,tmpInputs->name);
2957	if(tmpI!=NULL){
2958	map* tmpV=getMap(tmpI->content,"value");
2959	if(tmpV!=NULL){
2960	char *tmpVS=strdup(tmpV->value);
2961	map* tmp=parseBoundingBox(tmpVS);
2962	free(tmpVS);
2963	map* tmpC=tmp;
2964	while(tmpC!=NULL){
2965	addToMap(tmpMaps->content,tmpC->name,tmpC->value);
2966	tmpC=tmpC->next;
2967	}
2968	freeMap(&tmp);
2969	free(tmp);
2970	}
2971	}
2972	}
2973	}
2974
2975	if(tmpIoType!=NULL){
2976	map* tmpContent=tmpIoType->content;
2977	map* cval=NULL;
2978	int hasPassed=-1;
2979	while(tmpContent!=NULL){
2980	if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
2981	#ifdef DEBUG
2982	fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
2983	#endif
2984	if(tmpMaps->content==NULL)
2985	tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
2986	else
2987	addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
2988
2989	if(hasPassed<0 && type==0 && getMap(tmpMaps->content,"isArray")!=NULL){
2990	map* length=getMap(tmpMaps->content,"length");
2991	int i;
2992	char *tcn=strdup(tmpContent->name);
2993	for(i=1;i<atoi(length->value);i++){
2994	#ifdef DEBUG
2995	dumpMap(tmpMaps->content);
2996	fprintf(stderr,"addDefaultValues %s_%d => %s\n",tcn,i,tmpContent->value);
2997	#endif
2998	int len=strlen((char*) tcn);
2999	char tmp1=(char )malloc((len+10)*sizeof(char));
3000	sprintf(tmp1,"%s_%d",tcn,i);
3001	#ifdef DEBUG
3002	fprintf(stderr,"addDefaultValues %s => %s\n",tmp1,tmpContent->value);
3003	#endif
3004	addToMap(tmpMaps->content,tmp1,tmpContent->value);
3005	free(tmp1);
3006	hasPassed=1;
3007	}
3008	free(tcn);
3009	}
3010	}
3011	tmpContent=tmpContent->next;
3012	}
3013	#ifdef USE_MS
3014	/**
3015	* check for useMapServer presence
3016	*/
3017	map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
3018	if(tmpCheck!=NULL){
3019	// Get the default value
3020	tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
3021	tmpCheck=getMap(tmpMaps->content,"mimeType");
3022	addToMap(tmpMaps->content,"requestedMimeType",tmpCheck->value);
3023	map* cursor=tmpIoType->content;
3024	while(cursor!=NULL){
3025	addToMap(tmpMaps->content,cursor->name,cursor->value);
3026	cursor=cursor->next;
3027	}
3028
3029	cursor=tmpInputs->content;
3030	while(cursor!=NULL){
3031	if(strcasecmp(cursor->name,"Title")==0 \|\|
3032	strcasecmp(cursor->name,"Abstract")==0)
3033	addToMap(tmpMaps->content,cursor->name,cursor->value);
3034	cursor=cursor->next;
3035	}
3036	}
3037	#endif
3038	}
3039	if(tmpMaps->content==NULL)
3040	tmpMaps->content=createMap("inRequest","true");
3041	else
3042	addToMap(tmpMaps->content,"inRequest","true");
3043
3044	}
3045	tmpInputs=tmpInputs->next;
3046	}
3047	return "";
3048	}
3049
3050	/**
3051	* parseBoundingBox : parse a BoundingBox string
3052	*
3053	* OGC 06-121r3 : 10.2 Bounding box
3054	*
3055	* value is provided as : lowerCorner,upperCorner,crs,dimension
3056	* exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
3057	*
3058	* Need to create a map to store boundingbox informations :
3059	* - lowerCorner : double,double (minimum within this bounding box)
3060	* - upperCorner : double,double (maximum within this bounding box)
3061	* - crs : URI (Reference to definition of the CRS)
3062	* - dimensions : int
3063	*
3064	* Note : support only 2D bounding box.
3065	*/
3066	map* parseBoundingBox(const char* value){
3067	map *res=NULL;
3068	if(value!=NULL){
3069	char cv,cvp;
3070	cv=strtok_r((char*) value,",",&cvp);
3071	int cnt=0;
3072	int icnt=0;
3073	char *currentValue=NULL;
3074	while(cv){
3075	if(cnt<2)
3076	if(currentValue!=NULL){
3077	char finalValue=(char)malloc((strlen(currentValue)+strlen(cv)+1)*sizeof(char));
3078	sprintf(finalValue,"%s%s",currentValue,cv);
3079	switch(cnt){
3080	case 0:
3081	res=createMap("lowerCorner",finalValue);
3082	break;
3083	case 1:
3084	addToMap(res,"upperCorner",finalValue);
3085	icnt=-1;
3086	break;
3087	}
3088	cnt++;
3089	free(currentValue);
3090	currentValue=NULL;
3091	free(finalValue);
3092	}
3093	else{
3094	currentValue=(char)malloc((strlen(cv)+2)sizeof(char));
3095	sprintf(currentValue,"%s ",cv);
3096	}
3097	else
3098	if(cnt==2){
3099	addToMap(res,"crs",cv);
3100	cnt++;
3101	}
3102	else
3103	addToMap(res,"dimensions",cv);
3104	icnt++;
3105	cv=strtok_r(NULL,",",&cvp);
3106	}
3107	}
3108	return res;
3109	}
3110
3111	/**
3112	* printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
3113	* wps:BoundingBoxData). Set crs and dimensions attributes, add
3114	* Lower/UpperCorner nodes to a pre-existing XML node.
3115	*/
3116	void printBoundingBox(xmlNsPtr ns_ows,xmlNodePtr n,map* boundingbox){
3117
3118	xmlNodePtr lw=NULL,uc=NULL;
3119
3120	map* tmp=getMap(boundingbox,"value");
3121
3122	tmp=getMap(boundingbox,"lowerCorner");
3123	if(tmp!=NULL){
3124	lw=xmlNewNode(ns_ows,BAD_CAST "LowerCorner");
3125	xmlAddChild(lw,xmlNewText(BAD_CAST tmp->value));
3126	}
3127
3128	tmp=getMap(boundingbox,"upperCorner");
3129	if(tmp!=NULL){
3130	uc=xmlNewNode(ns_ows,BAD_CAST "UpperCorner");
3131	xmlAddChild(uc,xmlNewText(BAD_CAST tmp->value));
3132	}
3133
3134	tmp=getMap(boundingbox,"crs");
3135	if(tmp!=NULL)
3136	xmlNewProp(n,BAD_CAST "crs",BAD_CAST tmp->value);
3137
3138	tmp=getMap(boundingbox,"dimensions");
3139	if(tmp!=NULL)
3140	xmlNewProp(n,BAD_CAST "dimensions",BAD_CAST tmp->value);
3141
3142	xmlAddChild(n,lw);
3143	xmlAddChild(n,uc);
3144
3145	}
3146
3147	void printBoundingBoxDocument(maps* m,maps* boundingbox,FILE* file){
3148	if(file==NULL)
3149	rewind(stdout);
3150	xmlNodePtr n;
3151	xmlDocPtr doc;
3152	xmlNsPtr ns_ows,ns_xsi;
3153	xmlChar *xmlbuff;
3154	int buffersize;
3155	char *encoding=getEncoding(m);
3156	map *tmp;
3157	if(file==NULL){
3158	int pid=0;
3159	tmp=getMapFromMaps(m,"lenv","sid");
3160	if(tmp!=NULL)
3161	pid=atoi(tmp->value);
3162	if(pid==getpid()){
3163	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
3164	}
3165	fflush(stdout);
3166	}
3167
3168	doc = xmlNewDoc(BAD_CAST "1.0");
3169	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
3170	ns_ows=usedNs[owsId];
3171	n = xmlNewNode(ns_ows, BAD_CAST "BoundingBox");
3172	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
3173	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
3174	ns_xsi=usedNs[xsiId];
3175	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
3176	map *tmp1=getMap(boundingbox->content,"value");
3177	tmp=parseBoundingBox(tmp1->value);
3178	printBoundingBox(ns_ows,n,tmp);
3179	xmlDocSetRootElement(doc, n);
3180
3181	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
3182	if(file==NULL)
3183	printf("%s",xmlbuff);
3184	else{
3185	fprintf(file,"%s",xmlbuff);
3186	}
3187
3188	if(tmp!=NULL){
3189	freeMap(&tmp);
3190	free(tmp);
3191	}
3192	xmlFree(xmlbuff);
3193	xmlFreeDoc(doc);
3194	xmlCleanupParser();
3195	zooXmlCleanupNs();
3196
3197	}
3198
3199
3200	char* getMd5(char* url){
3201	EVP_MD_CTX md5ctx;
3202	char* fresult=(char)malloc((EVP_MAX_MD_SIZE+1)sizeof(char));
3203	unsigned char result[EVP_MAX_MD_SIZE];
3204	unsigned int len;
3205	EVP_DigestInit(&md5ctx, EVP_md5());
3206	EVP_DigestUpdate(&md5ctx, url, strlen(url));
3207	EVP_DigestFinal_ex(&md5ctx,result,&len);
3208	EVP_MD_CTX_cleanup(&md5ctx);
3209	int i;
3210	for(i = 0; i < len; i++){
3211	if(i>0){
3212	char *tmp=strdup(fresult);
3213	sprintf(fresult,"%s%02x", tmp,result[i]);
3214	free(tmp);
3215	}
3216	else
3217	sprintf(fresult,"%02x",result[i]);
3218	}
3219	return fresult;
3220	}
3221
3222	/**
3223	* Cache a file for a given request
3224	*/
3225	void addToCache(maps* conf,char* request,char* content,char* mimeType,int length){
3226	map* tmp=getMapFromMaps(conf,"main","cacheDir");
3227	if(tmp!=NULL){
3228	char* md5str=getMd5(request);
3229	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
3230	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
3231	#ifdef DEBUG
3232	fprintf(stderr,"Cache list : %s\n",fname);
3233	fflush(stderr);
3234	#endif
3235	FILE* fo=fopen(fname,"w+");
3236	if(fo==NULL){
3237	fprintf (stderr, "Failed to open %s for writting: %s\n",fname, strerror(errno));
3238	return;
3239	}
3240	fwrite(content,sizeof(char),length,fo);
3241	fclose(fo);
3242
3243	sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
3244	fo=fopen(fname,"w+");
3245	#ifdef DEBUG
3246	fprintf(stderr,"MIMETYPE: %s\n",mimeType);
3247	#endif
3248	fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
3249	fclose(fo);
3250
3251	free(md5str);
3252	free(fname);
3253	}
3254	}
3255
3256	char* isInCache(maps* conf,char* request){
3257	map* tmpM=getMapFromMaps(conf,"main","cacheDir");
3258	if(tmpM!=NULL){
3259	char* md5str=getMd5(request);
3260	#ifdef DEBUG
3261	fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
3262	#endif
3263	char* fname=(char)malloc(sizeof(char)(strlen(tmpM->value)+strlen(md5str)+6));
3264	sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
3265	struct stat f_status;
3266	int s=stat(fname, &f_status);
3267	if(s==0 && f_status.st_size>0){
3268	free(md5str);
3269	return fname;
3270	}
3271	free(md5str);
3272	free(fname);
3273	}
3274	return NULL;
3275	}
3276
3277	int runHttpRequests(maps m,maps inputs,HINTERNET* hInternet){
3278	if(hInternet->nb>0){
3279	processDownloads(hInternet);
3280	maps* content=*inputs;
3281	map* tmp1;
3282	int index=0;
3283	while(content!=NULL){
3284
3285	map* length=getMap(content->content,"length");
3286	int shouldClean=-1;
3287	if(length==NULL){
3288	length=createMap("length","1");
3289	shouldClean=1;
3290	}
3291	for(int i=0;i<atoi(length->value);i++){
3292
3293	char* fcontent;
3294	char *mimeType=NULL;
3295	int fsize=0;
3296	char cname[15];
3297	char vname[11];
3298	char vname1[11];
3299	char sname[9];
3300	char icname[14];
3301	char xname[16];
3302	if(index>0)
3303	sprintf(vname1,"value_%d",index);
3304	else
3305	sprintf(vname1,"value");
3306
3307	if(i>0){
3308	tmp1=getMap(content->content,cname);
3309	sprintf(cname,"cache_file_%d",i);
3310	sprintf(vname,"value_%d",i);
3311	sprintf(sname,"size_%d",i);
3312	sprintf(icname,"isCached_%d",i);
3313	sprintf(xname,"Reference_%d",i);
3314	}else{
3315	sprintf(cname,"cache_file");
3316	sprintf(vname,"value");
3317	sprintf(icname,"isCached");
3318	sprintf(sname,"size");
3319	sprintf(xname,"Reference");
3320	}
3321
3322	map* tmap=getMapFromMaps(*m,"orequests",vname1);
3323	if((tmp1=getMap(content->content,xname))!=NULL && strcasecmp(tmap->value,tmp1->value)==0 ){
3324	if(getMap(content->content,icname)==NULL){
3325
3326	fcontent=(char)malloc((hInternet->ihandle[index].nDataLen+1)sizeof(char));
3327	if(fcontent == NULL){
3328	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
3329	}
3330	size_t dwRead;
3331	InternetReadFile(hInternet->ihandle[index],
3332	(LPVOID)fcontent,
3333	hInternet->ihandle[index].nDataLen,
3334	&dwRead);
3335	fcontent[hInternet->ihandle[index].nDataLen]=0;
3336	fsize=hInternet->ihandle[index].nDataLen;
3337	if(hInternet->ihandle[index].mimeType==NULL)
3338	mimeType=strdup("none");
3339	else
3340	mimeType=strdup(hInternet->ihandle[index].mimeType);
3341
3342	map* tmpMap=getMapOrFill(&content->content,vname,"");
3343	free(tmpMap->value);
3344	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
3345	if(tmpMap->value==NULL){
3346	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
3347	}
3348	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
3349
3350	char ltmp1[256];
3351	sprintf(ltmp1,"%d",fsize);
3352	map* tmp=getMapFromMaps(*m,"main","cacheDir");
3353	if(tmp!=NULL){
3354	char* md5str=getMd5(tmp1->value);
3355	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
3356	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
3357	addToMap(content->content,cname,fname);
3358	free(fname);
3359	}
3360	addToMap(content->content,sname,ltmp1);
3361	addToCache(*m,tmp1->value,fcontent,mimeType,fsize);
3362	free(fcontent);
3363	free(mimeType);
3364	dumpMaps(content);
3365	index++;
3366
3367	}
3368	}
3369	}
3370	if(shouldClean>0){
3371	freeMap(&length);
3372	free(length);
3373	}
3374
3375	content=content->next;
3376	}
3377
3378	}
3379	}
3380
3381	/**
3382	* loadRemoteFile:
3383	* Try to load file from cache or download a remote file if not in cache
3384	*/
3385	int loadRemoteFile(maps m,map content,HINTERNET* hInternet,char *url){
3386	char* fcontent;
3387	char* cached=isInCache(*m,url);
3388	char *mimeType=NULL;
3389	int fsize=0;
3390
3391	map* t=getMap(*content,"xlink:href");
3392	if(t==NULL){
3393	t=getMap((*content),"href");
3394	addToMap(*content,"xlink:href",url);
3395	}
3396
3397	if(cached!=NULL){
3398
3399	struct stat f_status;
3400	int s=stat(cached, &f_status);
3401	if(s==0){
3402	fcontent=(char)malloc(sizeof(char)(f_status.st_size+1));
3403	FILE* f=fopen(cached,"rb");
3404	fread(fcontent,f_status.st_size,1,f);
3405	fsize=f_status.st_size;
3406	fcontent[fsize]=0;
3407	fclose(f);
3408	addToMap(*content,"cache_file",cached);
3409	}
3410	cached[strlen(cached)-1]='m';
3411	s=stat(cached, &f_status);
3412	if(s==0){
3413	mimeType=(char)malloc(sizeof(char)(f_status.st_size+1));
3414	FILE* f=fopen(cached,"rb");
3415	fread(mimeType,f_status.st_size,1,f);
3416	mimeType[f_status.st_size]=0;
3417	fclose(f);
3418	}
3419
3420	}else{
3421	hInternet->waitingRequests[hInternet->nb]=strdup(url);
3422	InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
3423	maps oreq=getMaps(m,"orequests");
3424	if(oreq==NULL){
3425	oreq=(maps*)malloc(MAPS_SIZE);
3426	oreq->name=zStrdup("orequests");
3427	oreq->content=createMap("value",url);
3428	oreq->next=NULL;
3429	addMapsToMaps(m,oreq);
3430	freeMaps(&oreq);
3431	free(oreq);
3432	}else{
3433	setMapArray(oreq->content,"value",hInternet->nb-1,url);
3434	}
3435	return 0;
3436	}
3437	if(fsize==0){
3438	return errorException(*m, _("Unable to download the file."), "InternalError",NULL);
3439	}
3440	if(mimeType!=NULL){
3441	addToMap(*content,"fmimeType",mimeType);
3442	}
3443
3444	map* tmpMap=getMapOrFill(content,"value","");
3445
3446	free(tmpMap->value);
3447
3448	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
3449	if(tmpMap->value==NULL)
3450	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
3451	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
3452
3453	char ltmp1[256];
3454	sprintf(ltmp1,"%d",fsize);
3455	addToMap(*content,"size",ltmp1);
3456	if(cached==NULL){
3457	addToCache(*m,url,fcontent,mimeType,fsize);
3458	}
3459	else{
3460	addToMap(*content,"isCached","true");
3461
3462	map* tmp=getMapFromMaps(*m,"main","cacheDir");
3463	if(tmp!=NULL){
3464	map c=getMap((content),"xlink:href");
3465	char* md5str=getMd5(c->value);
3466	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
3467	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
3468	addToMap(*content,"cache_file",fname);
3469	free(fname);
3470	}
3471	}
3472	free(fcontent);
3473	free(mimeType);
3474	free(cached);
3475	return 0;
3476	}
3477
3478	int errorException(maps m, const char message, const char errorcode, const char locator)
3479	{
3480	map* errormap = createMap("text", message);
3481	addToMap(errormap,"code", errorcode);
3482	if(locator!=NULL)
3483	addToMap(errormap,"locator", locator);
3484	else
3485	addToMap(errormap,"locator", "NULL");
3486	printExceptionReportResponse(m,errormap);
3487	freeMap(&errormap);
3488	free(errormap);
3489	return -1;
3490	}
3491
3492
3493	char readVSIFile(maps conf,const char* dataSource){
3494	VSILFILE * fichier=VSIFOpenL(dataSource,"rb");
3495	VSIStatBufL file_status;
3496	VSIStatL(dataSource, &file_status);
3497	if(fichier==NULL){
3498	char tmp[1024];
3499	sprintf(tmp,"Failed to open file %s for reading purpose. File seems empty %d.",
3500	dataSource,file_status.st_size);
3501	setMapInMaps(conf,"lenv","message",tmp);
3502	return NULL;
3503	}
3504	char res1=(char )malloc(file_status.st_size*sizeof(char));
3505	VSIFReadL(res1,1,file_status.st_size*sizeof(char),fichier);
3506	res1[file_status.st_size-1]=0;
3507	VSIFCloseL(fichier);
3508	VSIUnlink(dataSource);
3509	return res1;
3510	}
3511
3512	void parseIdentifier(maps* conf,char* conf_dir,char identifier,char buffer){
3513	setMapInMaps(conf,"lenv","oIdentifier",identifier);
3514	char *lid=zStrdup(identifier);
3515	char *saveptr1;
3516	char *tmps1=strtok_r(lid,".",&saveptr1);
3517	int level=0;
3518	char key[25];
3519	char levels[18];
3520	while(tmps1!=NULL){
3521	char *test=zStrdup(tmps1);
3522	char* tmps2=(char)malloc((strlen(test)+2)sizeof(char));
3523	sprintf(key,"sprefix_%d",level);
3524	sprintf(tmps2,"%s.",test);
3525	sprintf(levels,"%d",level);
3526	setMapInMaps(conf,"lenv","level",levels);
3527	setMapInMaps(conf,"lenv",key,tmps2);
3528	free(tmps2);
3529	free(test);
3530	level++;
3531	tmps1=strtok_r(NULL,".",&saveptr1);
3532	}
3533	int i=0;
3534	sprintf(buffer,"%s",conf_dir);
3535	for(i=0;i<level;i++){
3536	char *tmp0=zStrdup(buffer);
3537	sprintf(key,"sprefix_%d",i);
3538	map* tmp00=getMapFromMaps(conf,"lenv",key);
3539	if(tmp00!=NULL)
3540	sprintf(buffer,"%s/%s",tmp0,tmp00->value);
3541	free(tmp0);
3542	buffer[strlen(buffer)-1]=0;
3543	if(i+1<level){
3544	map* tmpMap=getMapFromMaps(conf,"lenv","metapath");
3545	if(tmpMap==NULL \|\| strlen(tmpMap->value)==0){
3546	char *tmp01=zStrdup(tmp00->value);
3547	tmp01[strlen(tmp01)-1]=0;
3548	setMapInMaps(conf,"lenv","metapath",tmp01);
3549	free(tmp01);
3550	tmp01=NULL;
3551	}
3552	else{
3553	if(tmp00!=NULL && tmpMap!=NULL){
3554	char *tmp00s=zStrdup(tmp00->value);
3555	tmp00s[strlen(tmp00s)-1]=0;
3556	char value=(char)malloc((strlen(tmp00s)+strlen(tmpMap->value)+2)*sizeof(char));
3557	sprintf(value,"%s/%s",tmpMap->value,tmp00s);
3558	setMapInMaps(conf,"lenv","metapath",value);
3559	free(value);
3560	free(tmp00s);
3561	value=NULL;
3562	}
3563	}
3564	}else{
3565	char *tmp01=zStrdup(tmp00->value);
3566	tmp01[strlen(tmp01)-1]=0;
3567	setMapInMaps(conf,"lenv","Identifier",tmp01);
3568	free(tmp01);
3569	}
3570	}
3571	char *tmp0=zStrdup(buffer);
3572	sprintf(buffer,"%s.zcfg",tmp0);
3573	free(tmp0);
3574	free(lid);
3575	}
3576
3577	int updateStatus( maps* conf, const int percentCompleted, const char* message ){
3578	char tmp[4];
3579	snprintf(tmp,4,"%d",percentCompleted);
3580	setMapInMaps( conf, "lenv", "status", tmp );
3581	setMapInMaps( conf, "lenv", "message", message);
3582	return _updateStatus( conf );
3583	}
3584
3585	char* getInputValue( maps* inputs, const char* parameterName, size_t* numberOfBytes){
3586	map* res=getMapFromMaps(inputs,parameterName,"value");
3587	if(res!=NULL){
3588	map* size=getMapFromMaps(inputs,parameterName,"size");
3589	if(size!=NULL){
3590	*numberOfBytes=(size_t)atoi(size->value);
3591	return res->value;
3592	}else{
3593	*numberOfBytes=strlen(res->value);
3594	return res->value;
3595	}
3596	}
3597	return NULL;
3598	}
3599
3600	int setOutputValue( maps* outputs, const char* parameterName, char* data, size_t numberOfBytes ){
3601	if(numberOfBytes==-1){
3602	setMapInMaps(outputs,parameterName,"value",data);
3603	}else{
3604	char size[1024];
3605	map* tmp=getMapFromMaps(outputs,parameterName,"value");
3606	if(tmp==NULL){
3607	setMapInMaps(outputs,parameterName,"value","");
3608	tmp=getMapFromMaps(outputs,parameterName,"value");
3609	}
3610	free(tmp->value);
3611	tmp->value=(char) malloc((numberOfBytes+1)sizeof(char));
3612	memcpy(tmp->value,data,numberOfBytes);
3613	sprintf(size,"%lu",numberOfBytes);
3614	setMapInMaps(outputs,parameterName,"size",size);
3615	}
3616	return 0;
3617	}

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

Open WPS platform

source: trunk/zoo-project/zoo-kernel/service_internal.c @ 561

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links