response_print.c @ 652

Last change on this file since 652 was 652, checked in by djay, 9 years ago
Better concurrency gesture for asynchronous requests, add db backend support for status informations.
Property svn:keywords set to `Id`
File size: 76.9 KB

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

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

Open WPS platform

source: trunk/zoo-project/zoo-kernel/response_print.c @ 652

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links