service_internal.c @ 471

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links