service_internal.c @ 464

Last change on this file since 464 was 464, checked in by djay, 11 years ago
Fix issue #92, thanks Knut for reporting this bug.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 77.9 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links