service_internal.c @ 483

Last change on this file since 483 was 483, checked in by djay, 10 years ago
Fix issue with namspaces in printExceptionReportResponse when Header were already created.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 86.2 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links