response_print.c @ 822

Last change on this file since 822 was 822, checked in by djay, 7 years ago
Commit the minimal requirements for remote HPC support
Property svn:keywords set to `Id`
File size: 87.1 KB

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

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

Open WPS platform

source: branches/prototype-v0/zoo-project/zoo-kernel/response_print.c @ 822

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links