service_internal.c @ 615

Last change on this file since 615 was 607, checked in by djay, 10 years ago
Introduce the Process Profiles Registry with its documentation.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 114.3 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links