response_print.c @ 958

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links