response_print.c @ 668

Last change on this file since 668 was 666, checked in by djay, 10 years ago
Small fix for version id detection.
Property svn:keywords set to `Id`
File size: 79.9 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links