service_internal.c @ 468

Last change on this file since 468 was 467, checked in by djay, 11 years ago
Various fixes for tickets #93, #94, #95, #95, #96.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 80.1 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){
[467]	125	char lpszBuf=(char) malloc(SHMEMSIZE*sizeof(char));
[452]	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){
[465]	885	char *orderedFields[13];
[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";
[465]	894	orderedFields[8]="range";
	895	orderedFields[9]="rangeMin";
	896	orderedFields[10]="rangeMax";
	897	orderedFields[11]="rangeClosure";
	898	orderedFields[12]="rangeSpace";
[76]	899
[459]	900	xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7,nc8;
[76]	901	elements* e=elem;
	902	map* tmp1=NULL;
[1]	903	while(e!=NULL){
[76]	904	int default1=0;
	905	int isAnyValue=1;
	906	nc2 = xmlNewNode(NULL, BAD_CAST type);
[1]	907	tmp1=getMap(e->content,"minOccurs");
	908	if(tmp1){
	909	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
	910	}
	911	tmp1=getMap(e->content,"maxOccurs");
	912	if(tmp1){
	913	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
	914	}
	915
	916	printDescription(nc2,ns_ows,e->name,e->content);
	917
[76]	918	if(strncmp(type,"Output",6)==0){
	919	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
	920	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
	921	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
[1]	922	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
[76]	923	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
	924	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
[1]	925	else
	926	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
[76]	927	}else{
[79]	928	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
[76]	929	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
[79]	930	}
[76]	931	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
	932	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexData");
	933	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
	934	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxData");
	935	else
	936	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
	937	}
[465]	938	iotype* _tmp0=NULL;
[1]	939	iotype* _tmp=e->defaults;
	940	int datatype=0;
[79]	941	bool hasDefault=false;
	942	bool hasUOM=false;
[1]	943	if(_tmp!=NULL){
[79]	944	if(strcmp(e->format,"LiteralOutput")==0 \|\|
	945	strcmp(e->format,"LiteralData")==0){
[1]	946	datatype=1;
	947	nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
	948	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
[79]	949	}
	950	else if(strcmp(e->format,"BoundingBoxOutput")==0 \|\|
	951	strcmp(e->format,"BoundingBoxData")==0){
	952	datatype=2;
	953	//nc4 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
	954	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
	955	}
	956	else{
	957	nc4 = xmlNewNode(NULL, BAD_CAST "Default");
	958	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
	959	}
	960
	961	tmp1=_tmp->content;
	962	int avcnt=0;
	963	int dcnt=0;
	964	int oI=0;
[465]	965	for(oI=0;oI<13;oI++)
[79]	966	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
	967	//while(tmp1!=NULL){
[1]	968	#ifdef DEBUG
[79]	969	printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
[1]	970	#endif
[79]	971	if(strncasecmp(tmp1->name,"DataType",8)==0){
	972	nc6 = xmlNewNode(ns_ows, BAD_CAST "DataType");
	973	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
	974	char tmp[1024];
	975	sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
	976	xmlNewNsProp(nc6,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
	977	xmlAddChild(nc3,nc6);
	978	tmp1=tmp1->next;
	979	datatype=1;
	980	continue;
	981	}
	982	if(strcmp(tmp1->name,"asReference")!=0 &&
	983	strncasecmp(tmp1->name,"DataType",8)!=0 &&
	984	strcasecmp(tmp1->name,"extension")!=0 &&
	985	strcasecmp(tmp1->name,"value")!=0 &&
[459]	986	strncasecmp(tmp1->name,"AllowedValues",13)!=0&&
	987	strncasecmp(tmp1->name,"range",5)!=0){
[79]	988	if(datatype!=1){
	989	char *tmp2=zCapitalize1(tmp1->name);
	990	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
	991	free(tmp2);
	992	}
	993	else{
	994	char *tmp2=zCapitalize(tmp1->name);
	995	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
	996	free(tmp2);
	997	}
	998	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
	999	xmlAddChild(nc5,nc6);
	1000	hasUOM=true;
	1001	}else
	1002	if(strncmp(type,"Input",5)==0){
[459]	1003
[79]	1004	if(strcmp(tmp1->name,"value")==0){
	1005	nc7 = xmlNewNode(NULL, BAD_CAST "DefaultValue");
	1006	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp1->value));
	1007	default1=1;
[459]	1008	hasDefault=true;
[79]	1009	}
	1010	if(strncasecmp(tmp1->name,"AllowedValues",13)==0){
	1011	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
	1012	char token,saveptr1;
	1013	token=strtok_r(tmp1->value,",",&saveptr1);
	1014	while(token!=NULL){
	1015	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
	1016	char *tmps=strdup(token);
	1017	tmps[strlen(tmps)]=0;
	1018	xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
	1019	xmlAddChild(nc6,nc7);
	1020	token=strtok_r(NULL,",",&saveptr1);
	1021	}
[465]	1022	if(getMap(_tmp->content,"range")!=NULL \|\|
	1023	getMap(_tmp->content,"rangeMin")!=NULL \|\|
[459]	1024	getMap(_tmp->content,"rangeMax")!=NULL \|\|
	1025	getMap(_tmp->content,"rangeClosure")!=NULL )
	1026	goto doRange;
[79]	1027	xmlAddChild(nc3,nc6);
	1028	isAnyValue=-1;
	1029	}
[459]	1030	if(strncasecmp(tmp1->name,"range",5)==0){
	1031	if(isAnyValue==1){
	1032	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
	1033	doRange:
[465]	1034
	1035	/**
	1036	* Range: Table 46 OGC Web Services Common Standard
	1037	*/
[459]	1038	nc8 = xmlNewNode(ns_ows, BAD_CAST "Range");
[465]	1039
	1040	map* tmp0=getMap(tmp1,"range");
[459]	1041	if(tmp0!=NULL){
[465]	1042	char* pToken;
	1043	char* orig=zStrdup(tmp0->value);
	1044	/**
	1045	* RangeClosure: Table 47 OGC Web Services Common Standard
	1046	*/
	1047	char *tmp="closed";
	1048	if(orig[0]=='[' && orig[strlen(orig)-1]=='[')
	1049	tmp="closed-open";
	1050	else
	1051	if(orig[0]==']' && orig[strlen(orig)-1]==']')
	1052	tmp="open-closed";
	1053	else
	1054	if(orig[0]==']' && orig[strlen(orig)-1]=='[')
	1055	tmp="open";
	1056	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
	1057	pToken=strtok(orig,",");
	1058	int nci0=0;
	1059	while(pToken!=NULL){
	1060	char tmpStr=(char) malloc((strlen(pToken))*sizeof(char));
	1061	if(nci0==0){
	1062	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
	1063	int nci=1;
	1064	for(nci=1;nci<strlen(pToken);nci++){
	1065	tmpStr[nci-1]=pToken[nci];
	1066	}
	1067	}else{
	1068	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
	1069	int nci=0;
	1070	for(nci=0;nci<strlen(pToken)-1;nci++){
	1071	tmpStr[nci]=pToken[nci];
	1072	}
	1073	}
	1074	xmlAddChild(nc7,xmlNewText(BAD_CAST tmpStr));
	1075	xmlAddChild(nc8,nc7);
	1076	nci0++;
	1077	pToken = strtok(NULL,",");
	1078	}
	1079	if(getMap(tmp1,"rangeSpacing")==NULL){
	1080	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
	1081	xmlAddChild(nc7,xmlNewText(BAD_CAST "1"));
	1082	xmlAddChild(nc8,nc7);
	1083	}
	1084	}else{
	1085
	1086	tmp0=getMap(tmp1,"rangeMin");
	1087	if(tmp0!=NULL){
[459]	1088	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
	1089	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
	1090	xmlAddChild(nc8,nc7);
	1091	}else{
	1092	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
	1093	xmlAddChild(nc8,nc7);
	1094	}
	1095	tmp0=getMap(tmp1,"rangeMax");
	1096	if(tmp0!=NULL){
	1097	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
	1098	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
	1099	xmlAddChild(nc8,nc7);
	1100	}else{
	1101	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
	1102	xmlAddChild(nc8,nc7);
	1103	}
	1104	tmp0=getMap(tmp1,"rangeSpacing");
	1105	if(tmp0!=NULL){
	1106	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
	1107	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
	1108	xmlAddChild(nc8,nc7);
	1109	}
	1110	tmp0=getMap(tmp1,"rangeClosure");
	1111	if(tmp0!=NULL){
	1112	char *tmp="closed";
	1113	if(strcasecmp(tmp0->value,"co")==0)
	1114	tmp="closed-open";
	1115	else
	1116	if(strcasecmp(tmp0->value,"oc")==0)
	1117	tmp="open-closed";
	1118	else
	1119	if(strcasecmp(tmp0->value,"o")==0)
	1120	tmp="open";
	1121	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
	1122	}else
	1123	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST "closed");
[465]	1124	}
	1125	if(_tmp0==NULL){
	1126	xmlAddChild(nc6,nc8);
	1127	_tmp0=e->supported;
	1128	tmp1=_tmp0->content;
	1129	goto doRange;
	1130	}else{
	1131	_tmp0=_tmp0->next;
	1132	if(_tmp0!=NULL){
	1133	xmlAddChild(nc6,nc8);
	1134	tmp1=_tmp0->content;
	1135	goto doRange;
	1136	}
	1137
	1138	}
	1139	xmlAddChild(nc6,nc8);
	1140	xmlAddChild(nc3,nc6);
	1141	isAnyValue=-1;
[459]	1142	}
	1143	}
[79]	1144	}
	1145	tmp1=tmp1->next;
	1146	if(datatype!=2){
	1147	if(hasUOM==true){
	1148	xmlAddChild(nc4,nc5);
	1149	xmlAddChild(nc3,nc4);
	1150	}
	1151	}else{
	1152	xmlAddChild(nc3,nc5);
	1153	}
	1154	if(strncmp(type,"Input",5)==0){
[459]	1155	if(datatype==1 && isAnyValue==1 && default1>0){
[79]	1156	xmlAddChild(nc3,nc7);
	1157	}
	1158	}
[459]	1159
[1]	1160	}
[459]	1161	if(strncmp(type,"Input",5)==0){
	1162	if(datatype==1 && isAnyValue==1 && avcnt==0){
	1163	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
	1164	hasDefault=true;
	1165	avcnt++;
	1166	}
	1167	}
[465]	1168
	1169	map* metadata=e->metadata;
	1170	xmlNodePtr n;
	1171	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
	1172	xmlNsPtr ns_xlink=usedNs[xlinkId];
	1173
	1174	while(metadata!=NULL){
	1175	nc6=xmlNewNode(ns_ows, BAD_CAST "MetaData");
	1176	xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
	1177	xmlAddChild(nc2,nc6);
	1178	metadata=metadata->next;
	1179	}
[1]	1180	}
[280]	1181
[1]	1182	_tmp=e->supported;
[289]	1183	if(_tmp==NULL && (getMap(e->defaults->content,"uom")!=NULL \|\| datatype!=1))
[280]	1184	_tmp=e->defaults;
	1185
[71]	1186	int hasSupported=-1;
[1]	1187	while(_tmp!=NULL){
[71]	1188	if(hasSupported<0){
	1189	if(datatype==0){
	1190	nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
	1191	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
	1192	}
	1193	else
	1194	nc5 = xmlNewNode(NULL, BAD_CAST "Supported");
	1195	hasSupported=0;
	1196	}else
[76]	1197	if(datatype==0)
	1198	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
[1]	1199	tmp1=_tmp->content;
[71]	1200	int oI=0;
[76]	1201	for(oI=0;oI<6;oI++)
[71]	1202	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
[1]	1203	#ifdef DEBUG
[71]	1204	printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
[1]	1205	#endif
[71]	1206	if(strcmp(tmp1->name,"asReference")!=0 &&
	1207	strcmp(tmp1->name,"DataType")!=0 &&
	1208	strcasecmp(tmp1->name,"extension")!=0){
[76]	1209	if(datatype!=1){
[71]	1210	char *tmp2=zCapitalize1(tmp1->name);
	1211	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
	1212	free(tmp2);
	1213	}
	1214	else{
	1215	char *tmp2=zCapitalize(tmp1->name);
	1216	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
	1217	free(tmp2);
	1218	}
[76]	1219	if(datatype==2){
	1220	char tmpv,tmps;
	1221	tmps=strtok_r(tmp1->value,",",&tmpv);
	1222	while(tmps){
	1223	xmlAddChild(nc6,xmlNewText(BAD_CAST tmps));
	1224	xmlAddChild(nc5,nc6);
	1225	tmps=strtok_r(NULL,",",&tmpv);
	1226	if(tmps){
	1227	char *tmp2=zCapitalize1(tmp1->name);
	1228	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
	1229	free(tmp2);
	1230	}
	1231	}
	1232	}
	1233	else{
	1234	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
	1235	xmlAddChild(nc5,nc6);
	1236	}
[9]	1237	}
[71]	1238	tmp1=tmp1->next;
[1]	1239	}
[71]	1240	if(hasSupported<=0){
[76]	1241	if(datatype!=2){
[71]	1242	xmlAddChild(nc4,nc5);
	1243	xmlAddChild(nc3,nc4);
	1244	}else
[76]	1245	xmlAddChild(nc3,nc5);
[71]	1246	hasSupported=1;
[1]	1247	}
[71]	1248	else
[76]	1249	if(datatype!=2){
	1250	xmlAddChild(nc4,nc5);
	1251	}
	1252	else
	1253	xmlAddChild(nc3,nc5);
	1254	_tmp=_tmp->next;
[1]	1255	}
	1256	xmlAddChild(nc2,nc3);
	1257
[79]	1258	if(datatype!=2 && hasUOM==true){
[76]	1259	xmlAddChild(nc3,nc4);
	1260	xmlAddChild(nc2,nc3);
[459]	1261	}/*else if(datatype!=2){
	1262	if(hasDefault!=true && strncmp(type,"Input",5)==0 && isAnyValue==1)
[79]	1263	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
[459]	1264	}*/
[1]	1265
	1266	xmlAddChild(nc1,nc2);
	1267
	1268	e=e->next;
	1269	}
	1270	}
	1271
[114]	1272	void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
[280]	1273	xmlNsPtr ns,ns1,ns_ows,ns_xlink,ns_xsi;
[9]	1274	xmlNodePtr nr,n,nc,nc1,nc2,nc3,pseudor;
	1275	xmlDocPtr doc;
[1]	1276	xmlChar *xmlbuff;
	1277	int buffersize;
[9]	1278	time_t time1;
	1279	time(&time1);
[280]	1280	nr=NULL;
[9]	1281	/**
	1282	* Create the document and its temporary root.
	1283	*/
	1284	doc = xmlNewDoc(BAD_CAST "1.0");
	1285	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
	1286	ns=usedNs[wpsId];
[280]	1287
[9]	1288	n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
[280]	1289	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
[9]	1290	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
	1291	ns_ows=usedNs[owsId];
	1292	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
	1293	ns_xlink=usedNs[xlinkId];
	1294	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
	1295	ns_xsi=usedNs[xsiId];
[280]	1296
[9]	1297	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");
	1298
	1299	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
	1300	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
[34]	1301	addLangAttr(n,m);
	1302
[9]	1303	char tmp[256];
[26]	1304	char url[1024];
[72]	1305	char stored_path[1024];
[9]	1306	memset(tmp,0,256);
[72]	1307	memset(url,0,1024);
	1308	memset(stored_path,0,1024);
[9]	1309	maps* tmp_maps=getMaps(m,"main");
	1310	if(tmp_maps!=NULL){
[26]	1311	map* tmpm1=getMap(tmp_maps->content,"serverAddress");
	1312	/**
	1313	* Check if the ZOO Service GetStatus is available in the local directory.
	1314	* If yes, then it uses a reference to an URL which the client can access
	1315	* to get information on the status of a running Service (using the
	1316	* percentCompleted attribute).
	1317	* Else fallback to the initial method using the xml file to write in ...
	1318	*/
	1319	char ntmp[1024];
	1320	#ifndef WIN32
	1321	getcwd(ntmp,1024);
	1322	#else
	1323	_getcwd(ntmp,1024);
	1324	#endif
	1325	struct stat myFileInfo;
	1326	int statRes;
	1327	char file_path[1024];
	1328	sprintf(file_path,"%s/GetStatus.zcfg",ntmp);
	1329	statRes=stat(file_path,&myFileInfo);
	1330	if(statRes==0){
	1331	char currentSid[128];
	1332	map* tmpm=getMap(tmp_maps->content,"rewriteUrl");
	1333	map *tmp_lenv=NULL;
	1334	tmp_lenv=getMapFromMaps(m,"lenv","sid");
	1335	if(tmp_lenv==NULL)
	1336	sprintf(currentSid,"%i",pid);
	1337	else
	1338	sprintf(currentSid,"%s",tmp_lenv->value);
	1339	if(tmpm==NULL \|\| strcasecmp(tmpm->value,"false")==0){
[280]	1340	sprintf(url,"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
[26]	1341	}else{
	1342	if(strlen(tmpm->value)>0)
	1343	if(strcasecmp(tmpm->value,"true")!=0)
	1344	sprintf(url,"%s/%s/GetStatus/%s",tmpm1->value,tmpm->value,currentSid);
	1345	else
	1346	sprintf(url,"%s/GetStatus/%s",tmpm1->value,currentSid);
	1347	else
[41]	1348	sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
[26]	1349	}
	1350	}else{
	1351	map* tmpm2=getMap(tmp_maps->content,"tmpUrl");
	1352	if(tmpm1!=NULL && tmpm2!=NULL){
[453]	1353	if( strncasecmp( tmpm2->value, "http://", 7) == 0 \|\|
	1354	strncasecmp( tmpm2->value, "https://", 8 ) == 0 ){
[378]	1355	sprintf(url,"%s/%s_%i.xml",tmpm2->value,service,pid);
	1356	}else
	1357	sprintf(url,"%s/%s/%s_%i.xml",tmpm1->value,tmpm2->value,service,pid);
[26]	1358	}
[9]	1359	}
[26]	1360	if(tmpm1!=NULL)
[280]	1361	sprintf(tmp,"%s",tmpm1->value);
[72]	1362	tmpm1=getMapFromMaps(m,"main","TmpPath");
	1363	sprintf(stored_path,"%s/%s_%i.xml",tmpm1->value,service,pid);
[9]	1364	}
	1365
[72]	1366
[364]	1367
[9]	1368	xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
[72]	1369	map* test=getMap(request,"storeExecuteResponse");
	1370	bool hasStoredExecuteResponse=false;
	1371	if(test!=NULL && strcasecmp(test->value,"true")==0){
[9]	1372	xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
[72]	1373	hasStoredExecuteResponse=true;
[9]	1374	}
	1375
	1376	nc = xmlNewNode(ns, BAD_CAST "Process");
	1377	map* tmp2=getMap(serv->content,"processVersion");
	1378	if(tmp2!=NULL)
	1379	xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp2->value);
	1380
	1381	printDescription(nc,ns_ows,serv->name,serv->content);
	1382
	1383	xmlAddChild(n,nc);
	1384
	1385	nc = xmlNewNode(ns, BAD_CAST "Status");
	1386	const struct tm *tm;
	1387	size_t len;
	1388	time_t now;
	1389	char *tmp1;
[26]	1390	map *tmpStatus;
[9]	1391
	1392	now = time ( NULL );
	1393	tm = localtime ( &now );
	1394
	1395	tmp1 = (char)malloc((TIME_SIZE+1)sizeof(char));
	1396
	1397	len = strftime ( tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm );
	1398
[26]	1399	xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
	1400
	1401	char sMsg[2048];
[9]	1402	switch(status){
	1403	case SERVICE_SUCCEEDED:
	1404	nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
[34]	1405	sprintf(sMsg,_("Service \"%s\" run successfully."),serv->name);
[26]	1406	nc3=xmlNewText(BAD_CAST sMsg);
	1407	xmlAddChild(nc1,nc3);
[9]	1408	break;
	1409	case SERVICE_STARTED:
	1410	nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
[26]	1411	tmpStatus=getMapFromMaps(m,"lenv","status");
	1412	xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST tmpStatus->value);
[34]	1413	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]	1414	nc3=xmlNewText(BAD_CAST sMsg);
	1415	xmlAddChild(nc1,nc3);
[9]	1416	break;
	1417	case SERVICE_ACCEPTED:
	1418	nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
[34]	1419	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]	1420	nc3=xmlNewText(BAD_CAST sMsg);
	1421	xmlAddChild(nc1,nc3);
[9]	1422	break;
	1423	case SERVICE_FAILED:
	1424	nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
[26]	1425	map *errorMap;
	1426	map *te;
	1427	te=getMapFromMaps(m,"lenv","code");
	1428	if(te!=NULL)
	1429	errorMap=createMap("code",te->value);
	1430	else
	1431	errorMap=createMap("code","NoApplicableCode");
	1432	te=getMapFromMaps(m,"lenv","message");
	1433	if(te!=NULL)
[57]	1434	addToMap(errorMap,"text",_ss(te->value));
[26]	1435	else
[34]	1436	addToMap(errorMap,"text",_("No more information available"));
[26]	1437	nc3=createExceptionReportNode(m,errorMap,0);
[59]	1438	freeMap(&errorMap);
	1439	free(errorMap);
[26]	1440	xmlAddChild(nc1,nc3);
[9]	1441	break;
	1442	default :
[34]	1443	printf(_("error code not know : %i\n"),status);
[26]	1444	//exit(1);
[9]	1445	break;
	1446	}
	1447	xmlAddChild(nc,nc1);
	1448	xmlAddChild(n,nc);
	1449	free(tmp1);
	1450
	1451	#ifdef DEBUG
	1452	fprintf(stderr,"printProcessResponse 1 161\n");
	1453	#endif
	1454
	1455	map* lineage=getMap(request,"lineage");
[87]	1456	if(lineage!=NULL && strcasecmp(lineage->value,"true")==0){
[9]	1457	nc = xmlNewNode(ns, BAD_CAST "DataInputs");
	1458	int i;
	1459	maps* mcursor=inputs;
[65]	1460	elements* scursor=NULL;
[9]	1461	while(mcursor!=NULL /&& scursor!=NULL/){
[65]	1462	scursor=getElements(serv->inputs,mcursor->name);
[76]	1463	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Input");
[9]	1464	mcursor=mcursor->next;
	1465	}
	1466	xmlAddChild(n,nc);
	1467
	1468	#ifdef DEBUG
	1469	fprintf(stderr,"printProcessResponse 1 177\n");
	1470	#endif
	1471
	1472	nc = xmlNewNode(ns, BAD_CAST "OutputDefinitions");
	1473	mcursor=outputs;
[65]	1474	scursor=NULL;
	1475	while(mcursor!=NULL){
	1476	scursor=getElements(serv->outputs,mcursor->name);
[9]	1477	printOutputDefinitions1(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
	1478	mcursor=mcursor->next;
	1479	}
	1480	xmlAddChild(n,nc);
	1481	}
	1482	#ifdef DEBUG
	1483	fprintf(stderr,"printProcessResponse 1 190\n");
	1484	#endif
	1485
	1486	/**
	1487	* Display the process output only when requested !
	1488	*/
	1489	if(status==SERVICE_SUCCEEDED){
	1490	nc = xmlNewNode(ns, BAD_CAST "ProcessOutputs");
	1491	maps* mcursor=outputs;
	1492	elements* scursor=serv->outputs;
[379]	1493	map* testResponse=getMap(request,"RawDataOutput");
	1494	if(testResponse==NULL)
	1495	testResponse=getMap(request,"ResponseDocument");
[63]	1496	while(mcursor!=NULL){
[379]	1497	map* tmp0=getMap(mcursor->content,"inRequest");
[65]	1498	scursor=getElements(serv->outputs,mcursor->name);
[280]	1499	if(scursor!=NULL){
[403]	1500	if(testResponse==NULL \|\| tmp0==NULL)
[379]	1501	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
	1502	else
[403]	1503	if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0)
[379]	1504	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
[449]	1505	}else
	1506	/**
	1507	* In case there was no definition found in the ZCFG file but
	1508	* present in the service code
	1509	*/
	1510	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
[9]	1511	mcursor=mcursor->next;
	1512	}
	1513	xmlAddChild(n,nc);
	1514	}
[364]	1515
[9]	1516	#ifdef DEBUG
	1517	fprintf(stderr,"printProcessResponse 1 202\n");
	1518	#endif
[280]	1519	nr=soapEnvelope(m,n);
	1520	xmlDocSetRootElement(doc, nr);
	1521
[76]	1522	if(hasStoredExecuteResponse==true){
[72]	1523	/* We need to write the ExecuteResponse Document somewhere */
	1524	FILE* output=fopen(stored_path,"w");
[393]	1525	if(output==NULL){
	1526	/* If the file cannot be created return an ExceptionReport */
	1527	char tmpMsg[1024];
	1528	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the ExecuteResponse."),stored_path);
	1529	map * errormap = createMap("text",tmpMsg);
	1530	addToMap(errormap,"code", "InternalError");
	1531	printExceptionReportResponse(m,errormap);
	1532	freeMap(&errormap);
	1533	free(errormap);
	1534	xmlCleanupParser();
	1535	zooXmlCleanupNs();
	1536	return;
	1537	}
[72]	1538	xmlChar *xmlbuff;
	1539	int buffersize;
	1540	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, "UTF-8", 1);
[216]	1541	fwrite(xmlbuff,1,xmlStrlen(xmlbuff)*sizeof(char),output);
[72]	1542	xmlFree(xmlbuff);
	1543	fclose(output);
	1544	}
[9]	1545	printDocument(m,doc,pid);
	1546
	1547	xmlCleanupParser();
	1548	zooXmlCleanupNs();
	1549	}
	1550
	1551
	1552	void printDocument(maps* m, xmlDocPtr doc,int pid){
	1553	char *encoding=getEncoding(m);
	1554	if(pid==getpid()){
[384]	1555	printHeaders(m);
[9]	1556	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
	1557	}
	1558	fflush(stdout);
	1559	xmlChar *xmlbuff;
	1560	int buffersize;
[1]	1561	/*
[9]	1562	* Dump the document to a buffer and print it on stdout
[1]	1563	* for demonstration purposes.
	1564	*/
[9]	1565	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
[114]	1566	printf("%s",xmlbuff);
[216]	1567	fflush(stdout);
[1]	1568	/*
	1569	* Free associated memory.
	1570	*/
	1571	xmlFree(xmlbuff);
[9]	1572	xmlFreeDoc(doc);
	1573	xmlCleanupParser();
	1574	zooXmlCleanupNs();
[1]	1575	}
	1576
[114]	1577	void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,const char* type){
[1]	1578	xmlNodePtr nc1;
	1579	nc1=xmlNewNode(ns_wps, BAD_CAST type);
	1580	map *tmp=NULL;
	1581	if(e!=NULL && e->defaults!=NULL)
	1582	tmp=e->defaults->content;
	1583	else{
	1584	/*
	1585	dumpElements(e);
	1586	*/
	1587	return;
	1588	}
	1589	while(tmp!=NULL){
[9]	1590	if(strncasecmp(tmp->name,"MIMETYPE",strlen(tmp->name))==0
	1591	\|\| strncasecmp(tmp->name,"ENCODING",strlen(tmp->name))==0
	1592	\|\| strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
	1593	\|\| strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
[1]	1594	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
	1595	tmp=tmp->next;
	1596	}
	1597	tmp=getMap(e->defaults->content,"asReference");
	1598	if(tmp==NULL)
	1599	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
	1600
	1601	tmp=e->content;
	1602
	1603	printDescription(nc1,ns_ows,m->name,e->content);
	1604
	1605	xmlAddChild(nc,nc1);
	1606
	1607	}
	1608
[114]	1609	void printOutputDefinitions(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,map* m,const char* type){
[1]	1610	xmlNodePtr nc1,nc2,nc3;
	1611	nc1=xmlNewNode(ns_wps, BAD_CAST type);
	1612	map *tmp=NULL;
	1613	if(e!=NULL && e->defaults!=NULL)
	1614	tmp=e->defaults->content;
	1615	else{
	1616	/*
	1617	dumpElements(e);
	1618	*/
	1619	return;
	1620	}
	1621	while(tmp!=NULL){
	1622	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
	1623	tmp=tmp->next;
	1624	}
	1625	tmp=getMap(e->defaults->content,"asReference");
	1626	if(tmp==NULL)
	1627	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
	1628
	1629	tmp=e->content;
	1630
	1631	printDescription(nc1,ns_ows,m->name,e->content);
	1632
	1633	xmlAddChild(nc,nc1);
	1634
	1635	}
	1636
[114]	1637	void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
[1]	1638	xmlNodePtr nc1,nc2,nc3;
	1639	nc1=xmlNewNode(ns_wps, BAD_CAST type);
[65]	1640	map *tmp=NULL;
	1641	if(e!=NULL)
	1642	tmp=e->content;
	1643	else
	1644	tmp=m->content;
[26]	1645	#ifdef DEBUG
[1]	1646	dumpMap(tmp);
	1647	dumpElements(e);
[26]	1648	#endif
[1]	1649	nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
[65]	1650	if(e!=NULL)
	1651	nc3=xmlNewText(BAD_CAST e->name);
	1652	else
	1653	nc3=xmlNewText(BAD_CAST m->name);
[9]	1654	xmlAddChild(nc2,nc3);
[1]	1655	xmlAddChild(nc1,nc2);
	1656	xmlAddChild(nc,nc1);
[9]	1657	// Extract Title required to be first element in the ZCFG file !
[364]	1658	bool isTitle=TRUE;
[65]	1659	if(e!=NULL)
	1660	tmp=getMap(e->content,"Title");
	1661	else
	1662	tmp=getMap(m->content,"Title");
	1663
	1664	if(tmp!=NULL){
[43]	1665	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
	1666	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
	1667	xmlAddChild(nc2,nc3);
	1668	xmlAddChild(nc1,nc2);
[65]	1669	}
	1670
	1671	if(e!=NULL)
	1672	tmp=getMap(e->content,"Abstract");
	1673	else
	1674	tmp=getMap(m->content,"Abstract");
	1675	if(tmp!=NULL){
	1676	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
	1677	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
	1678	xmlAddChild(nc2,nc3);
	1679	xmlAddChild(nc1,nc2);
[43]	1680	xmlAddChild(nc,nc1);
	1681	}
[1]	1682
	1683	/**
	1684	* IO type Reference or full Data ?
	1685	*/
[26]	1686	#ifdef DEBUG
[9]	1687	fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
[26]	1688	#endif
[9]	1689	map *tmpMap=getMap(m->content,"Reference");
	1690	if(tmpMap==NULL){
	1691	nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
[65]	1692	if(e!=NULL){
[76]	1693	if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
[65]	1694	nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
[9]	1695	else
[76]	1696	if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
[65]	1697	nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
[76]	1698	else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
	1699	nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
[65]	1700	else
	1701	nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
	1702	}
	1703	else{
	1704	map* tmpV=getMapFromMaps(m,"format","value");
	1705	if(tmpV!=NULL)
	1706	nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
	1707	else
	1708	nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
[76]	1709	}
[9]	1710	tmp=m->content;
[297]	1711	#ifdef USE_MS
	1712	map* testMap=getMap(tmp,"requestedMimeType");
	1713	#endif
[9]	1714	while(tmp!=NULL){
[70]	1715	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
	1716	strcasecmp(tmp->name,"encoding")==0 \|\|
	1717	strcasecmp(tmp->name,"schema")==0 \|\|
	1718	strcasecmp(tmp->name,"datatype")==0 \|\|
	1719	strcasecmp(tmp->name,"uom")==0)
[297]	1720	#ifdef USE_MS
[299]	1721	if(testMap==NULL \|\| (testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)==0)){
[297]	1722	#endif
[9]	1723	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
[297]	1724	#ifdef USE_MS
[299]	1725	}
	1726	else
	1727	if(strcasecmp(tmp->name,"mimeType")==0)
	1728	if(testMap!=NULL)
	1729	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
	1730	else
	1731	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
[297]	1732	#endif
[9]	1733	tmp=tmp->next;
	1734	xmlAddChild(nc2,nc3);
[1]	1735	}
[76]	1736	if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
	1737	map* bb=getMap(m->content,"value");
	1738	if(bb!=NULL){
	1739	map* tmpRes=parseBoundingBox(bb->value);
	1740	printBoundingBox(ns_ows,nc3,tmpRes);
	1741	freeMap(&tmpRes);
	1742	free(tmpRes);
[9]	1743	}
[76]	1744	}else{
	1745	if(e!=NULL)
	1746	tmp=getMap(e->defaults->content,"mimeType");
	1747	else
	1748	tmp=NULL;
[297]	1749	#ifdef USE_MS
	1750	/**
	1751	* In case of OGC WebServices output use, as the data was requested
	1752	* with asReference=false we have to download the resulting OWS request
	1753	* stored in the Reference map value.
	1754	*/
	1755	map* testMap=getMap(m->content,"requestedMimeType");
	1756	if(testMap!=NULL){
	1757	HINTERNET hInternet;
	1758	hInternet=InternetOpen(
	1759	#ifndef WIN32
	1760	(LPCTSTR)
	1761	#endif
	1762	"ZooWPSClient\0",
	1763	INTERNET_OPEN_TYPE_PRECONFIG,
	1764	NULL,NULL, 0);
	1765	testMap=getMap(m->content,"Reference");
	1766	loadRemoteFile(m,m->content,hInternet,testMap->value);
	1767	InternetCloseHandle(hInternet);
	1768	}
	1769	#endif
[76]	1770	map* tmp1=getMap(m->content,"encoding");
	1771	map* tmp2=getMap(m->content,"mimeType");
[379]	1772	map* tmp3=getMap(m->content,"value");
	1773	int hasValue=1;
	1774	if(tmp3==NULL){
	1775	tmp3=createMap("value","");
	1776	hasValue=-1;
	1777	}
[76]	1778	if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
	1779	\|\| (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 \|\|
	1780	(strncmp(tmp2->value,"application/",12)==0) &&
[279]	1781	strncmp(tmp2->value,"application/json",16)!=0&&
[458]	1782	strncmp(tmp2->value,"application/x-javascript",24)!=0&&
[279]	1783	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)!=0)
	1784	)) {
[76]	1785	map* rs=getMap(m->content,"size");
	1786	bool isSized=true;
	1787	if(rs==NULL){
	1788	char tmp1[1024];
[379]	1789	sprintf(tmp1,"%d",strlen(tmp3->value));
[280]	1790	rs=createMap("size",tmp1);
[76]	1791	isSized=false;
	1792	}
[94]	1793
[379]	1794	xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
[76]	1795	if(!isSized){
	1796	freeMap(&rs);
	1797	free(rs);
	1798	}
[59]	1799	}
[280]	1800	else if(tmp2!=NULL){
	1801	if(strncmp(tmp2->value,"text/js",7)==0 \|\|
	1802	strncmp(tmp2->value,"application/json",16)==0)
[379]	1803	xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
[280]	1804	else{
	1805	if(strncmp(tmp2->value,"text/xml",8)==0 \|\|
[307]	1806	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
[280]	1807	xmlDocPtr doc =
[379]	1808	xmlParseMemory(tmp3->value,strlen(tmp3->value));
[280]	1809	xmlNodePtr ir = xmlDocGetRootElement(doc);
	1810	xmlAddChild(nc3,ir);
	1811	}
	1812	else
[379]	1813	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
[280]	1814	}
[76]	1815	xmlAddChild(nc2,nc3);
	1816	}
[364]	1817	else{
[379]	1818	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
	1819	}
	1820	if(hasValue<0){
	1821	freeMap(&tmp3);
	1822	free(tmp3);
	1823	}
[9]	1824	}
[1]	1825	}
[9]	1826	else{
[297]	1827	tmpMap=getMap(m->content,"Reference");
[9]	1828	nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
[76]	1829	if(strcasecmp(type,"Output")==0)
	1830	xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
	1831	else
	1832	xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
[9]	1833	tmp=m->content;
[297]	1834	#ifdef USE_MS
	1835	map* testMap=getMap(tmp,"requestedMimeType");
	1836	#endif
[9]	1837	while(tmp!=NULL){
[70]	1838	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
	1839	strcasecmp(tmp->name,"encoding")==0 \|\|
	1840	strcasecmp(tmp->name,"schema")==0 \|\|
	1841	strcasecmp(tmp->name,"datatype")==0 \|\|
	1842	strcasecmp(tmp->name,"uom")==0)
[297]	1843	#ifdef USE_MS
	1844	if(testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)!=0){
	1845	if(strcasecmp(tmp->name,"mimeType")==0)
	1846	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
	1847	}
	1848	else
	1849	#endif
[9]	1850	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
	1851	tmp=tmp->next;
	1852	xmlAddChild(nc2,nc3);
	1853	}
[1]	1854	}
	1855	xmlAddChild(nc1,nc2);
	1856	xmlAddChild(nc,nc1);
	1857
	1858	}
	1859
[114]	1860	void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
[1]	1861	xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
	1862	xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
	1863	xmlAddChild(root,nc2);
	1864	map* tmp=amap;
	1865	char *tmp2[2];
	1866	tmp2[0]="Title";
	1867	tmp2[1]="Abstract";
	1868	int j=0;
	1869	for(j=0;j<2;j++){
	1870	map* tmp1=getMap(tmp,tmp2[j]);
	1871	if(tmp1!=NULL){
	1872	nc2 = xmlNewNode(ns_ows, BAD_CAST tmp2[j]);
[34]	1873	xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
[1]	1874	xmlAddChild(root,nc2);
	1875	}
	1876	}
	1877	}
	1878
[9]	1879	char* getEncoding(maps* m){
	1880	if(m!=NULL){
	1881	map* tmp=getMap(m->content,"encoding");
[1]	1882	if(tmp!=NULL){
[9]	1883	return tmp->value;
[1]	1884	}
	1885	else
[9]	1886	return "UTF-8";
[1]	1887	}
	1888	else
[9]	1889	return "UTF-8";
	1890	}
[1]	1891
[9]	1892	char* getVersion(maps* m){
	1893	if(m!=NULL){
	1894	map* tmp=getMap(m->content,"version");
[1]	1895	if(tmp!=NULL){
[9]	1896	return tmp->value;
[1]	1897	}
	1898	else
[9]	1899	return "1.0.0";
[1]	1900	}
	1901	else
[9]	1902	return "1.0.0";
	1903	}
[1]	1904
[9]	1905	void printExceptionReportResponse(maps* m,map* s){
	1906	int buffersize;
	1907	xmlDocPtr doc;
	1908	xmlChar *xmlbuff;
[34]	1909	xmlNodePtr n;
[1]	1910
[9]	1911	doc = xmlNewDoc(BAD_CAST "1.0");
	1912	maps* tmpMap=getMaps(m,"main");
	1913	char *encoding=getEncoding(tmpMap);
[459]	1914	char *exceptionCode;
	1915
	1916	map* tmp=getMap(s,"code");
	1917	if(tmp!=NULL){
	1918	if(strcmp(tmp->value,"OperationNotSupported")==0)
	1919	exceptionCode="501 Not Implemented";
	1920	else
	1921	if(strcmp(tmp->value,"MissingParameterValue")==0 \|\|
	1922	strcmp(tmp->value,"InvalidUpdateSequence")==0 \|\|
	1923	strcmp(tmp->value,"OptionNotSupported")==0 \|\|
	1924	strcmp(tmp->value,"VersionNegotiationFailed")==0 \|\|
	1925	strcmp(tmp->value,"InvalidParameterValue")==0)
	1926	exceptionCode="400 Bad request";
	1927	else
	1928	if(strcmp(tmp->value,"NoApplicableCode")==0)
	1929	exceptionCode="501 Internal Server Error";
	1930	else
	1931	exceptionCode="501 Internal Server Error";
	1932	}
	1933	else
	1934	exceptionCode="501 Internal Server Error";
	1935
[32]	1936	if(m!=NULL){
	1937	map *tmpSid=getMapFromMaps(m,"lenv","sid");
	1938	if(tmpSid!=NULL){
[384]	1939	if( getpid()==atoi(tmpSid->value) ){
	1940	printHeaders(m);
[459]	1941	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[384]	1942	}
[32]	1943	}
[384]	1944	else{
	1945	printHeaders(m);
[459]	1946	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[384]	1947	}
[385]	1948	}else{
[459]	1949	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[385]	1950	}
[34]	1951	n=createExceptionReportNode(m,s,1);
[1]	1952	xmlDocSetRootElement(doc, n);
[9]	1953	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
	1954	printf("%s",xmlbuff);
	1955	fflush(stdout);
	1956	xmlFreeDoc(doc);
[1]	1957	xmlFree(xmlbuff);
[9]	1958	xmlCleanupParser();
[57]	1959	zooXmlCleanupNs();
[1]	1960	}
	1961
[26]	1962	xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
	1963
	1964	int buffersize;
	1965	xmlChar *xmlbuff;
	1966	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
	1967	xmlNodePtr n,nc,nc1,nc2;
[1]	1968
[26]	1969	maps* tmpMap=getMaps(m,"main");
	1970
[216]	1971	int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
[57]	1972	ns=usedNs[nsid];
[26]	1973	n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
	1974
	1975	if(use_ns==1){
	1976	ns_ows=xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
	1977	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
	1978	ns_xsi=usedNs[xsiId];
	1979	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
	1980	ns_xlink=usedNs[xlinkId];
	1981	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");
	1982	}
[34]	1983	addLangAttr(n,m);
[26]	1984	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.1.0");
	1985
	1986	nc = xmlNewNode(ns, BAD_CAST "Exception");
	1987
	1988	map* tmp=getMap(s,"code");
	1989	if(tmp!=NULL)
	1990	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST tmp->value);
	1991	else
	1992	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST "NoApplicableCode");
	1993
[459]	1994	tmp=getMap(s,"locator");
	1995	if(tmp!=NULL && strcasecmp(tmp->value,"NULL")!=0)
	1996	xmlNewProp(nc,BAD_CAST "locator",BAD_CAST tmp->value);
	1997
	1998
[26]	1999	tmp=getMap(s,"text");
	2000	nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
	2001	nc2=NULL;
	2002	if(tmp!=NULL){
	2003	xmlNodeSetContent(nc1, BAD_CAST tmp->value);
	2004	}
	2005	else{
[34]	2006	xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
[26]	2007	}
	2008	xmlAddChild(nc,nc1);
	2009	xmlAddChild(n,nc);
	2010	return n;
	2011	}
	2012
	2013
[1]	2014	void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
	2015	map* request_inputs1,int cpid,maps* m,int res){
	2016	#ifdef DEBUG
	2017	dumpMaps(request_inputs);
	2018	dumpMaps(request_outputs);
	2019	fprintf(stderr,"printProcessResponse\n");
	2020	#endif
	2021	map* toto=getMap(request_inputs1,"RawDataOutput");
	2022	int asRaw=0;
	2023	if(toto!=NULL)
	2024	asRaw=1;
[9]	2025
[379]	2026	maps* tmpSess=getMaps(m,"senv");
	2027	if(tmpSess!=NULL){
	2028	map *_tmp=getMapFromMaps(m,"lenv","cookie");
	2029	char* sessId;
	2030	if(_tmp!=NULL){
[442]	2031	printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
[379]	2032	printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
	2033	char session_file_path[100];
[92]	2034	char *tmp1=strtok(_tmp->value,";");
	2035	if(tmp1!=NULL)
[379]	2036	sprintf(session_file_path,"%s",strstr(tmp1,"=")+1);
[92]	2037	else
[379]	2038	sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
	2039	sessId=strdup(session_file_path);
	2040	}else{
	2041	maps* t=getMaps(m,"senv");
	2042	map*p=t->content;
	2043	while(p!=NULL){
	2044	if(strstr(p->name,"ID")!=NULL){
	2045	sessId=strdup(p->value);
	2046	break;
	2047	}
	2048	p=p->next;
	2049	}
[92]	2050	}
[379]	2051	char session_file_path[1024];
	2052	map *tmpPath=getMapFromMaps(m,"main","sessPath");
	2053	if(tmpPath==NULL)
	2054	tmpPath=getMapFromMaps(m,"main","tmpPath");
	2055	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,sessId);
[387]	2056	FILE* teste=fopen(session_file_path,"w");
	2057	if(teste==NULL){
	2058	char tmpMsg[1024];
	2059	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the session maps."),session_file_path);
	2060	map * errormap = createMap("text",tmpMsg);
	2061	addToMap(errormap,"code", "InternalError");
[453]	2062
[387]	2063	printExceptionReportResponse(m,errormap);
	2064	freeMap(&errormap);
	2065	free(errormap);
	2066	return;
	2067	}
	2068	else{
	2069	fclose(teste);
	2070	dumpMapsToFile(tmpSess,session_file_path);
	2071	}
[92]	2072	}
[379]	2073
[453]	2074	if(res==SERVICE_FAILED){
	2075	map * errormap;
	2076	map *lenv;
	2077	lenv=getMapFromMaps(m,"lenv","message");
	2078	char *tmp0;
	2079	if(lenv!=NULL){
[464]	2080	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]	2081	sprintf(tmp0,_("Unable to run the Service. The message returned back by the Service was the following: %s"),lenv->value);
	2082	}
	2083	else{
	2084	tmp0=(char)malloc((strlen(_("Unable to run the Service. No more information was returned back by the Service."))+1)sizeof(char));
	2085	sprintf(tmp0,_("Unable to run the Service. No more information was returned back by the Service."));
	2086	}
	2087	errormap = createMap("text",tmp0);
	2088	free(tmp0);
	2089	addToMap(errormap,"code", "InternalError");
	2090	printExceptionReportResponse(m,errormap);
	2091	freeMap(&errormap);
	2092	free(errormap);
	2093	return;
	2094	}
	2095
[1]	2096	if(asRaw==0){
[9]	2097	#ifdef DEBUG
	2098	fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
	2099	dumpMaps(request_outputs);
	2100	#endif
[70]	2101	maps* tmpI=request_outputs;
	2102	while(tmpI!=NULL){
[297]	2103	#ifdef USE_MS
[364]	2104	map* testMap=getMap(tmpI->content,"useMapserver");
[297]	2105	#endif
[70]	2106	toto=getMap(tmpI->content,"asReference");
[297]	2107	#ifdef USE_MS
[453]	2108	if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
[297]	2109	#else
[453]	2110	if(toto!=NULL && strcasecmp(toto->value,"true")==0)
[297]	2111	#endif
[453]	2112	{
[76]	2113	elements* in=getElements(s->outputs,tmpI->name);
	2114	char *format=NULL;
	2115	if(in!=NULL){
	2116	format=strdup(in->format);
	2117	}else
	2118	format=strdup("LiteralData");
	2119	if(strcasecmp(format,"BoundingBoxData")==0){
	2120	addToMap(tmpI->content,"extension","xml");
	2121	addToMap(tmpI->content,"mimeType","text/xml");
	2122	addToMap(tmpI->content,"encoding","UTF-8");
	2123	addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
	2124	}
	2125	map *ext=getMap(tmpI->content,"extension");
[70]	2126	map *tmp1=getMapFromMaps(m,"main","tmpPath");
[453]	2127	char file_name,file_path;
[70]	2128	bool hasExt=true;
[76]	2129	if(ext==NULL){
[70]	2130	// We can fallback to a default list of supported formats using
	2131	// mimeType information if present here. Maybe we can add more formats
	2132	// here.
[383]	2133	// If mimeType was not found, we then set txt as the default extension
[70]	2134	map* mtype=getMap(tmpI->content,"mimeType");
	2135	if(mtype!=NULL){
	2136	if(strcasecmp(mtype->value,"text/xml")==0)
[76]	2137	ext=createMap("extension","xml");
[70]	2138	else if(strcasecmp(mtype->value,"application/json")==0)
[76]	2139	ext=createMap("extension","js");
[306]	2140	else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
[279]	2141	ext=createMap("extension","kml");
[306]	2142	else if(strncmp(mtype->value,"image/",6)==0)
	2143	ext=createMap("extension",strstr(mtype->value,"/")+1);
[70]	2144	else
[76]	2145	ext=createMap("extension","txt");
[70]	2146	}
[57]	2147	else
[76]	2148	ext=createMap("extension","txt");
[70]	2149	hasExt=false;
[57]	2150	}
[453]	2151	file_name=(char)malloc((strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+1024)sizeof(char));
	2152	int cpid0=cpid+time(NULL);
	2153	sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,ext->value);
	2154	file_path=(char)malloc((strlen(tmp1->value)+strlen(file_name)+2)sizeof(char));
	2155	sprintf(file_path,"%s/%s",tmp1->value,file_name);
	2156	FILE *ofile=fopen(file_path,"wb");
[386]	2157	if(ofile==NULL){
	2158	char tmpMsg[1024];
[387]	2159	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the %s final result."),file_name,tmpI->name);
[386]	2160	map * errormap = createMap("text",tmpMsg);
	2161	addToMap(errormap,"code", "InternalError");
	2162	printExceptionReportResponse(m,errormap);
	2163	freeMap(&errormap);
	2164	free(errormap);
[453]	2165	free(file_name);
	2166	free(file_path);
[386]	2167	return;
	2168	}
[453]	2169	free(file_path);
[70]	2170	map *tmp2=getMapFromMaps(m,"main","tmpUrl");
	2171	map *tmp3=getMapFromMaps(m,"main","serverAddress");
	2172	char *file_url;
[458]	2173	if(strncasecmp(tmp2->value,"http://",7)==0 \|\|
	2174	strncasecmp(tmp2->value,"https://",8)==0){
	2175	file_url=(char)malloc((strlen(tmp2->value)+strlen(file_name)+2)sizeof(char));
[453]	2176	sprintf(file_url,"%s/%s",tmp2->value,file_name);
[378]	2177	}else{
[458]	2178	file_url=(char)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)sizeof(char));
[453]	2179	sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
[378]	2180	}
[70]	2181	addToMap(tmpI->content,"Reference",file_url);
[387]	2182	if(!hasExt){
[76]	2183	freeMap(&ext);
	2184	free(ext);
[70]	2185	}
	2186	toto=getMap(tmpI->content,"value");
[76]	2187	if(strcasecmp(format,"BoundingBoxData")!=0){
	2188	map* size=getMap(tmpI->content,"size");
	2189	if(size!=NULL && toto!=NULL)
	2190	fwrite(toto->value,1,atoi(size->value)*sizeof(char),ofile);
	2191	else
	2192	if(toto!=NULL && toto->value!=NULL)
	2193	fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
	2194	}else{
	2195	printBoundingBoxDocument(m,tmpI,ofile);
	2196	}
	2197	free(format);
[70]	2198	fclose(ofile);
	2199	free(file_name);
[76]	2200	free(file_url);
[52]	2201	}
[297]	2202	#ifdef USE_MS
	2203	else{
	2204	if(testMap!=NULL){
	2205	setReferenceUrl(m,tmpI);
	2206	}
	2207	}
	2208	#endif
[70]	2209	tmpI=tmpI->next;
[9]	2210	}
[1]	2211	map *r_inputs=getMap(s->content,"serviceProvider");
	2212	#ifdef DEBUG
	2213	fprintf(stderr,"SERVICE : %s\n",r_inputs->value);
	2214	dumpMaps(m);
	2215	#endif
[9]	2216	printProcessResponse(m,request_inputs1,cpid,
[26]	2217	s,r_inputs->value,res,
	2218	request_inputs,
	2219	request_outputs);
[453]	2220	}
	2221	else{
[26]	2222	/**
[66]	2223	* We get the requested output or fallback to the first one if the
	2224	* requested one is not present in the resulting outputs maps.
[26]	2225	*/
[66]	2226	maps* tmpI=NULL;
	2227	map* tmpIV=getMap(request_inputs1,"RawDataOutput");
	2228	if(tmpIV!=NULL){
	2229	tmpI=getMaps(request_outputs,tmpIV->value);
	2230	}
	2231	if(tmpI==NULL)
	2232	tmpI=request_outputs;
[76]	2233	elements* e=getElements(s->outputs,tmpI->name);
	2234	if(e!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
	2235	printBoundingBoxDocument(m,tmpI,NULL);
	2236	}else{
	2237	toto=getMap(tmpI->content,"value");
	2238	if(toto==NULL){
	2239	char tmpMsg[1024];
	2240	sprintf(tmpMsg,_("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),tmpI->name);
	2241	map * errormap = createMap("text",tmpMsg);
	2242	addToMap(errormap,"code", "InvalidParameterValue");
	2243	printExceptionReportResponse(m,errormap);
	2244	freeMap(&errormap);
	2245	free(errormap);
[114]	2246	return;
[76]	2247	}
[383]	2248	map* fname=getMapFromMaps(tmpI,tmpI->name,"filename");
	2249	if(fname!=NULL)
	2250	printf("Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
	2251	map* rs=getMapFromMaps(tmpI,tmpI->name,"size");
	2252	if(rs!=NULL)
	2253	printf("Content-Length: %s\r\n",rs->value);
[384]	2254	printHeaders(m);
[76]	2255	char mime[1024];
	2256	map* mi=getMap(tmpI->content,"mimeType");
[1]	2257	#ifdef DEBUG
[76]	2258	fprintf(stderr,"SERVICE OUTPUTS\n");
	2259	dumpMaps(request_outputs);
	2260	fprintf(stderr,"SERVICE OUTPUTS\n");
[1]	2261	#endif
[76]	2262	map* en=getMap(tmpI->content,"encoding");
	2263	if(mi!=NULL && en!=NULL)
[26]	2264	sprintf(mime,
[76]	2265	"Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
	2266	mi->value,en->value);
[26]	2267	else
[76]	2268	if(mi!=NULL)
	2269	sprintf(mime,
	2270	"Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
	2271	mi->value);
	2272	else
	2273	sprintf(mime,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
	2274	printf("%s",mime);
[383]	2275	if(rs!=NULL)
[385]	2276	fwrite(toto->value,1,atoi(rs->value),stdout);
[76]	2277	else
[385]	2278	fwrite(toto->value,1,strlen(toto->value),stdout);
[1]	2279	#ifdef DEBUG
[76]	2280	dumpMap(toto);
[1]	2281	#endif
[76]	2282	}
[26]	2283	}
[1]	2284	}
	2285
[216]	2286	char base64(const char input, int length)
[1]	2287	{
	2288	BIO bmem, b64;
	2289	BUF_MEM *bptr;
	2290
	2291	b64 = BIO_new(BIO_f_base64());
[94]	2292	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
[1]	2293	bmem = BIO_new(BIO_s_mem());
	2294	b64 = BIO_push(b64, bmem);
	2295	BIO_write(b64, input, length);
	2296	BIO_flush(b64);
	2297	BIO_get_mem_ptr(b64, &bptr);
	2298
[94]	2299	char buff = (char )malloc((bptr->length)*sizeof(char));
[1]	2300	memcpy(buff, bptr->data, bptr->length-1);
	2301	buff[bptr->length-1] = 0;
	2302
	2303	BIO_free_all(b64);
	2304
	2305	return buff;
	2306	}
	2307
[216]	2308	char base64d(const char input, int length,int* red)
[88]	2309	{
	2310	BIO b64, bmem;
	2311
	2312	char buffer = (char )malloc(length);
[94]	2313	if(buffer){
	2314	memset(buffer, 0, length);
	2315	b64 = BIO_new(BIO_f_base64());
	2316	if(b64){
[216]	2317	bmem = BIO_new_mem_buf((unsigned char*)input,length);
[94]	2318	bmem = BIO_push(b64, bmem);
	2319	*red=BIO_read(bmem, buffer, length);
	2320	buffer[length-1]=0;
	2321	BIO_free_all(bmem);
	2322	}
	2323	}
[88]	2324	return buffer;
	2325	}
	2326
	2327	void ensureDecodedBase64(maps **in){
	2328	maps* cursor=*in;
	2329	while(cursor!=NULL){
	2330	map *tmp=getMap(cursor->content,"encoding");
	2331	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
	2332	tmp=getMap(cursor->content,"value");
	2333	addToMap(cursor->content,"base64_value",tmp->value);
[94]	2334	int size=0;
[88]	2335	char *s=strdup(tmp->value);
	2336	free(tmp->value);
	2337	tmp->value=base64d(s,strlen(s),&size);
[94]	2338	free(s);
[88]	2339	char sizes[1024];
	2340	sprintf(sizes,"%d",size);
	2341	addToMap(cursor->content,"size",sizes);
	2342	}
	2343	cursor=cursor->next;
	2344	}
	2345	}
	2346
[63]	2347	char* addDefaultValues(maps** out,elements* in,maps* m,int type){
[1]	2348	elements* tmpInputs=in;
	2349	maps* out1=*out;
[280]	2350	if(type==1){
	2351	while(out1!=NULL){
	2352	if(getElements(in,out1->name)==NULL)
	2353	return out1->name;
	2354	out1=out1->next;
	2355	}
	2356	out1=*out;
	2357	}
[1]	2358	while(tmpInputs!=NULL){
	2359	maps *tmpMaps=getMaps(out1,tmpInputs->name);
	2360	if(tmpMaps==NULL){
[9]	2361	maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
[57]	2362	tmpMaps2->name=strdup(tmpInputs->name);
[9]	2363	tmpMaps2->content=NULL;
	2364	tmpMaps2->next=NULL;
[63]	2365
	2366	if(type==0){
	2367	map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
	2368	if(tmpMapMinO!=NULL)
	2369	if(atoi(tmpMapMinO->value)>=1){
	2370	freeMaps(&tmpMaps2);
	2371	free(tmpMaps2);
	2372	return tmpInputs->name;
	2373	}
	2374	else{
	2375	if(tmpMaps2->content==NULL)
	2376	tmpMaps2->content=createMap("minOccurs",tmpMapMinO->value);
	2377	else
	2378	addToMap(tmpMaps2->content,"minOccurs",tmpMapMinO->value);
	2379	}
	2380	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
	2381	if(tmpMaxO!=NULL)
	2382	if(tmpMaps2->content==NULL)
	2383	tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
	2384	else
	2385	addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
	2386	}
	2387
[1]	2388	iotype* tmpIoType=tmpInputs->defaults;
[63]	2389	if(tmpIoType!=NULL){
	2390	map* tmpm=tmpIoType->content;
	2391	while(tmpm!=NULL){
	2392	if(tmpMaps2->content==NULL)
	2393	tmpMaps2->content=createMap(tmpm->name,tmpm->value);
	2394	else
	2395	addToMap(tmpMaps2->content,tmpm->name,tmpm->value);
	2396	tmpm=tmpm->next;
	2397	}
[1]	2398	}
[88]	2399	addToMap(tmpMaps2->content,"inRequest","false");
[93]	2400	if(type==0){
[57]	2401	map *tmpMap=getMap(tmpMaps2->content,"value");
	2402	if(tmpMap==NULL)
	2403	addToMap(tmpMaps2->content,"value","NULL");
	2404	}
[1]	2405	if(out1==NULL){
[9]	2406	*out=dupMaps(&tmpMaps2);
[63]	2407	out1=*out;
[1]	2408	}
	2409	else
[9]	2410	addMapsToMaps(&out1,tmpMaps2);
[63]	2411	freeMap(&tmpMaps2->content);
	2412	free(tmpMaps2->content);
	2413	tmpMaps2->content=NULL;
[9]	2414	freeMaps(&tmpMaps2);
	2415	free(tmpMaps2);
	2416	tmpMaps2=NULL;
[1]	2417	}
	2418	else{
[57]	2419	iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
	2420	tmpMaps->content);
[63]	2421	if(type==0) {
[76]	2422	/**
	2423	* In case of an Input maps, then add the minOccurs and maxOccurs to the
	2424	* content map.
	2425	*/
[63]	2426	map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
	2427	if(tmpMap1!=NULL){
	2428	if(tmpMaps->content==NULL)
	2429	tmpMaps->content=createMap("minOccurs",tmpMap1->value);
	2430	else
	2431	addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
	2432	}
	2433	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
	2434	if(tmpMaxO!=NULL){
	2435	if(tmpMaps->content==NULL)
	2436	tmpMaps->content=createMap("maxOccurs",tmpMap1->value);
	2437	else
	2438	addToMap(tmpMaps->content,"maxOccurs",tmpMap1->value);
	2439	}
[76]	2440	/**
	2441	* Parsing BoundingBoxData, fill the following map and then add it to
	2442	* the content map of the Input maps:
	2443	* lowerCorner, upperCorner, srs and dimensions
	2444	* cf. parseBoundingBox
	2445	*/
	2446	if(strcasecmp(tmpInputs->format,"BoundingBoxData")==0){
	2447	maps* tmpI=getMaps(*out,tmpInputs->name);
	2448	if(tmpI!=NULL){
	2449	map* tmpV=getMap(tmpI->content,"value");
	2450	if(tmpV!=NULL){
	2451	char *tmpVS=strdup(tmpV->value);
	2452	map* tmp=parseBoundingBox(tmpVS);
	2453	free(tmpVS);
	2454	map* tmpC=tmp;
	2455	while(tmpC!=NULL){
	2456	addToMap(tmpMaps->content,tmpC->name,tmpC->value);
	2457	tmpC=tmpC->next;
	2458	}
	2459	freeMap(&tmp);
	2460	free(tmp);
	2461	}
	2462	}
	2463	}
[63]	2464	}
	2465
[57]	2466	if(tmpIoType!=NULL){
	2467	map* tmpContent=tmpIoType->content;
	2468	map* cval=NULL;
[360]	2469	int hasPassed=-1;
[57]	2470	while(tmpContent!=NULL){
	2471	if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
[9]	2472	#ifdef DEBUG
[57]	2473	fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
[9]	2474	#endif
[63]	2475	if(tmpMaps->content==NULL)
	2476	tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
	2477	else
	2478	addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
[360]	2479
	2480	if(hasPassed<0 && type==0 && getMap(tmpMaps->content,"isArray")!=NULL){
	2481	map* length=getMap(tmpMaps->content,"length");
	2482	int i;
	2483	char *tcn=strdup(tmpContent->name);
	2484	for(i=1;i<atoi(length->value);i++){
[364]	2485	#ifdef DEBUG
[360]	2486	dumpMap(tmpMaps->content);
	2487	fprintf(stderr,"addDefaultValues %s_%d => %s\n",tcn,i,tmpContent->value);
[364]	2488	#endif
	2489	int len=strlen((char*) tcn);
	2490	char tmp1=(char )malloc((len+10)*sizeof(char));
[360]	2491	sprintf(tmp1,"%s_%d",tcn,i);
[364]	2492	#ifdef DEBUG
[360]	2493	fprintf(stderr,"addDefaultValues %s => %s\n",tmp1,tmpContent->value);
[364]	2494	#endif
[360]	2495	addToMap(tmpMaps->content,tmp1,tmpContent->value);
	2496	free(tmp1);
	2497	hasPassed=1;
	2498	}
	2499	free(tcn);
	2500	}
[57]	2501	}
	2502	tmpContent=tmpContent->next;
[9]	2503	}
[297]	2504	#ifdef USE_MS
	2505	/**
	2506	* check for useMapServer presence
	2507	*/
	2508	map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
	2509	if(tmpCheck!=NULL){
	2510	// Get the default value
	2511	tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
	2512	tmpCheck=getMap(tmpMaps->content,"mimeType");
	2513	addToMap(tmpMaps->content,"requestedMimeType",tmpCheck->value);
	2514	map* cursor=tmpIoType->content;
	2515	while(cursor!=NULL){
	2516	addToMap(tmpMaps->content,cursor->name,cursor->value);
	2517	cursor=cursor->next;
	2518	}
	2519
	2520	cursor=tmpInputs->content;
	2521	while(cursor!=NULL){
	2522	if(strcasecmp(cursor->name,"Title")==0 \|\|
	2523	strcasecmp(cursor->name,"Abstract")==0)
	2524	addToMap(tmpMaps->content,cursor->name,cursor->value);
	2525	cursor=cursor->next;
	2526	}
	2527	}
	2528	#endif
[1]	2529	}
[92]	2530	if(tmpMaps->content==NULL)
	2531	tmpMaps->content=createMap("inRequest","true");
	2532	else
	2533	addToMap(tmpMaps->content,"inRequest","true");
[280]	2534
[1]	2535	}
	2536	tmpInputs=tmpInputs->next;
	2537	}
[9]	2538	return "";
[1]	2539	}
[76]	2540
	2541	/**
	2542	* parseBoundingBox : parse a BoundingBox string
	2543	*
	2544	* OGC 06-121r3 : 10.2 Bounding box
	2545	*
	2546	* value is provided as : lowerCorner,upperCorner,crs,dimension
	2547	* exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
	2548	*
	2549	* Need to create a map to store boundingbox informations :
	2550	* - lowerCorner : double,double (minimum within this bounding box)
	2551	* - upperCorner : double,double (maximum within this bounding box)
	2552	* - crs : URI (Reference to definition of the CRS)
	2553	* - dimensions : int
	2554	*
	2555	* Note : support only 2D bounding box.
	2556	*/
[114]	2557	map* parseBoundingBox(const char* value){
[76]	2558	map *res=NULL;
	2559	if(value!=NULL){
	2560	char cv,cvp;
[114]	2561	cv=strtok_r((char*) value,",",&cvp);
[76]	2562	int cnt=0;
	2563	int icnt=0;
	2564	char *currentValue=NULL;
	2565	while(cv){
	2566	if(cnt<2)
	2567	if(currentValue!=NULL){
	2568	char finalValue=(char)malloc((strlen(currentValue)+strlen(cv)+1)*sizeof(char));
	2569	sprintf(finalValue,"%s%s",currentValue,cv);
	2570	switch(cnt){
	2571	case 0:
	2572	res=createMap("lowerCorner",finalValue);
	2573	break;
	2574	case 1:
	2575	addToMap(res,"upperCorner",finalValue);
	2576	icnt=-1;
	2577	break;
	2578	}
	2579	cnt++;
	2580	free(currentValue);
	2581	currentValue=NULL;
	2582	free(finalValue);
	2583	}
	2584	else{
	2585	currentValue=(char)malloc((strlen(cv)+2)sizeof(char));
	2586	sprintf(currentValue,"%s ",cv);
	2587	}
	2588	else
	2589	if(cnt==2){
	2590	addToMap(res,"crs",cv);
	2591	cnt++;
	2592	}
	2593	else
	2594	addToMap(res,"dimensions",cv);
	2595	icnt++;
	2596	cv=strtok_r(NULL,",",&cvp);
	2597	}
	2598	}
	2599	return res;
	2600	}
	2601
	2602	/**
	2603	* printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
	2604	* wps:BoundingBoxData). Set crs and dimensions attributes, add
	2605	* Lower/UpperCorner nodes to a pre-existing XML node.
	2606	*/
	2607	void printBoundingBox(xmlNsPtr ns_ows,xmlNodePtr n,map* boundingbox){
	2608
	2609	xmlNodePtr bb,lw,uc;
	2610
	2611	map* tmp=getMap(boundingbox,"value");
	2612
	2613	tmp=getMap(boundingbox,"lowerCorner");
	2614	if(tmp!=NULL){
	2615	lw=xmlNewNode(ns_ows,BAD_CAST "LowerCorner");
	2616	xmlAddChild(lw,xmlNewText(BAD_CAST tmp->value));
	2617	}
	2618
	2619	tmp=getMap(boundingbox,"upperCorner");
	2620	if(tmp!=NULL){
	2621	uc=xmlNewNode(ns_ows,BAD_CAST "UpperCorner");
	2622	xmlAddChild(uc,xmlNewText(BAD_CAST tmp->value));
	2623	}
	2624
	2625	tmp=getMap(boundingbox,"crs");
	2626	if(tmp!=NULL)
	2627	xmlNewProp(n,BAD_CAST "crs",BAD_CAST tmp->value);
	2628
	2629	tmp=getMap(boundingbox,"dimensions");
	2630	if(tmp!=NULL)
	2631	xmlNewProp(n,BAD_CAST "dimensions",BAD_CAST tmp->value);
	2632
	2633	xmlAddChild(n,lw);
	2634	xmlAddChild(n,uc);
	2635
	2636	}
	2637
	2638	void printBoundingBoxDocument(maps* m,maps* boundingbox,FILE* file){
	2639	if(file==NULL)
	2640	rewind(stdout);
	2641	xmlNodePtr n;
	2642	xmlDocPtr doc;
	2643	xmlNsPtr ns_ows,ns_xsi;
	2644	xmlChar *xmlbuff;
	2645	int buffersize;
	2646	char *encoding=getEncoding(m);
	2647	map *tmp;
	2648	if(file==NULL){
	2649	int pid=0;
	2650	tmp=getMapFromMaps(m,"lenv","sid");
	2651	if(tmp!=NULL)
	2652	pid=atoi(tmp->value);
	2653	if(pid==getpid()){
	2654	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
	2655	}
	2656	fflush(stdout);
	2657	}
	2658
	2659	doc = xmlNewDoc(BAD_CAST "1.0");
	2660	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
	2661	ns_ows=usedNs[owsId];
	2662	n = xmlNewNode(ns_ows, BAD_CAST "BoundingBox");
[216]	2663	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
[76]	2664	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
	2665	ns_xsi=usedNs[xsiId];
	2666	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");
	2667	map *tmp1=getMap(boundingbox->content,"value");
	2668	tmp=parseBoundingBox(tmp1->value);
	2669	printBoundingBox(ns_ows,n,tmp);
	2670	xmlDocSetRootElement(doc, n);
	2671
	2672	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
	2673	if(file==NULL)
[114]	2674	printf("%s",xmlbuff);
[76]	2675	else{
	2676	fprintf(file,"%s",xmlbuff);
	2677	}
	2678
	2679	if(tmp!=NULL){
	2680	freeMap(&tmp);
	2681	free(tmp);
	2682	}
	2683	xmlFree(xmlbuff);
	2684	xmlFreeDoc(doc);
	2685	xmlCleanupParser();
	2686	zooXmlCleanupNs();
	2687
	2688	}
[280]	2689
[281]	2690
[364]	2691	char* getMd5(char* url){
[291]	2692	EVP_MD_CTX md5ctx;
[364]	2693	char* fresult=(char)malloc((EVP_MAX_MD_SIZE+1)sizeof(char));
[291]	2694	unsigned char result[EVP_MAX_MD_SIZE];
	2695	unsigned int len;
	2696	EVP_DigestInit(&md5ctx, EVP_md5());
	2697	EVP_DigestUpdate(&md5ctx, url, strlen(url));
	2698	EVP_DigestFinal_ex(&md5ctx,result,&len);
	2699	EVP_MD_CTX_cleanup(&md5ctx);
	2700	int i;
	2701	for(i = 0; i < len; i++){
	2702	if(i>0){
	2703	char *tmp=strdup(fresult);
	2704	sprintf(fresult,"%s%02x", tmp,result[i]);
	2705	free(tmp);
	2706	}
	2707	else
	2708	sprintf(fresult,"%02x",result[i]);
	2709	}
	2710	return fresult;
	2711	}
	2712
[280]	2713	/**
	2714	* Cache a file for a given request
	2715	*/
[446]	2716	void addToCache(maps* conf,char* request,char* content,char* mimeType,int length){
[280]	2717	map* tmp=getMapFromMaps(conf,"main","cacheDir");
	2718	if(tmp!=NULL){
[364]	2719	char* md5str=getMd5(request);
[292]	2720	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
	2721	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
[291]	2722	#ifdef DEBUG
[280]	2723	fprintf(stderr,"Cache list : %s\n",fname);
	2724	fflush(stderr);
[291]	2725	#endif
[293]	2726	FILE* fo=fopen(fname,"w+");
	2727	fwrite(content,sizeof(char),length,fo);
	2728	fclose(fo);
[446]	2729
	2730	sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
	2731	fo=fopen(fname,"w+");
	2732	#ifdef DEBUG
	2733	fprintf(stderr,"MIMETYPE: %s\n",mimeType);
	2734	#endif
	2735	fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
	2736	fclose(fo);
	2737
[293]	2738	free(md5str);
	2739	free(fname);
[280]	2740	}
	2741	}
	2742
	2743	char* isInCache(maps* conf,char* request){
[291]	2744	map* tmpM=getMapFromMaps(conf,"main","cacheDir");
	2745	if(tmpM!=NULL){
[364]	2746	char* md5str=getMd5(request);
[291]	2747	#ifdef DEBUG
	2748	fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
	2749	#endif
[392]	2750	char* fname=(char)malloc(sizeof(char)(strlen(tmpM->value)+strlen(md5str)+6));
[292]	2751	sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
[280]	2752	struct stat f_status;
	2753	int s=stat(fname, &f_status);
[292]	2754	if(s==0 && f_status.st_size>0){
	2755	free(md5str);
	2756	return fname;
	2757	}
[291]	2758	free(md5str);
	2759	free(fname);
[280]	2760	}
	2761	return NULL;
	2762	}
[281]	2763
	2764	/**
	2765	* loadRemoteFile:
	2766	* Try to load file from cache or download a remote file if not in cache
	2767	*/
[364]	2768	int loadRemoteFile(maps* m,map* content,HINTERNET hInternet,char *url){
[281]	2769	HINTERNET res;
	2770	char* fcontent;
	2771	char* cached=isInCache(m,url);
[446]	2772	char *mimeType=NULL;
[281]	2773	int fsize;
[379]	2774	int hasF=-1;
[281]	2775	if(cached!=NULL){
	2776	struct stat f_status;
	2777	int s=stat(cached, &f_status);
	2778	if(s==0){
	2779	fcontent=(char)malloc(sizeof(char)(f_status.st_size+1));
[375]	2780	FILE* f=fopen(cached,"rb");
[392]	2781	int len=fread(fcontent,f_status.st_size,1,f);
[281]	2782	fsize=f_status.st_size;
[392]	2783	fcontent[fsize]=0;
[446]	2784	fclose(f);
[281]	2785	}
[446]	2786	cached[strlen(cached)-1]='m';
	2787	s=stat(cached, &f_status);
	2788	if(s==0){
	2789	mimeType=(char)malloc(sizeof(char)(f_status.st_size+1));
	2790	FILE* f=fopen(cached,"rb");
	2791	int len=fread(mimeType,f_status.st_size,1,f);
	2792	mimeType[f_status.st_size]=0;
	2793	fclose(f);
	2794	}
[281]	2795	}else{
	2796	res=InternetOpenUrl(hInternet,url,NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
[379]	2797	fcontent=(char)malloc((res.nDataLen+1)sizeof(char));
[281]	2798	if(fcontent == NULL){
[459]	2799	return errorException(m, _("Unable to allocate memory."), "InternalError",NULL);
[281]	2800	}
	2801	size_t dwRead;
	2802	InternetReadFile(res, (LPVOID)fcontent, res.nDataLen, &dwRead);
	2803	fcontent[res.nDataLen]=0;
	2804	fsize=res.nDataLen;
[451]	2805	mimeType=(char*)res.mimeType;
[281]	2806	}
[344]	2807	if(fsize==0){
[459]	2808	return errorException(m, _("Unable to download the file."), "InternalError",NULL);
[344]	2809	}
[360]	2810
[446]	2811	if(mimeType!=NULL){
	2812	addToMap(content,"fmimeType",mimeType);
	2813	}
	2814
[282]	2815	map* tmpMap=getMapOrFill(content,"value","");
[360]	2816
[281]	2817	free(tmpMap->value);
	2818	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
[379]	2819	if(tmpMap->value==NULL)
	2820	fprintf(stderr,"Unable to allocate memory!\n");
[392]	2821	//snprintf(tmpMap->value,(fsize+1)*sizeof(char),fcontent);
	2822	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
[379]	2823
[281]	2824	char ltmp1[256];
	2825	sprintf(ltmp1,"%d",fsize);
	2826	addToMap(content,"size",ltmp1);
	2827	if(cached==NULL)
[446]	2828	addToCache(m,url,fcontent,mimeType,fsize);
[379]	2829	else{
[446]	2830	free(fcontent);
	2831	free(mimeType);
[378]	2832	free(cached);
[379]	2833	}
[364]	2834	return 0;
[281]	2835	}
	2836
[459]	2837	int errorException(maps m, const char message, const char errorcode, const char locator)
[284]	2838	{
	2839	map* errormap = createMap("text", message);
	2840	addToMap(errormap,"code", errorcode);
[459]	2841	if(locator!=NULL)
	2842	addToMap(errormap,"locator", locator);
	2843	else
	2844	addToMap(errormap,"locator", "NULL");
[284]	2845	printExceptionReportResponse(m,errormap);
	2846	freeMap(&errormap);
	2847	free(errormap);
	2848	return -1;
	2849	}

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links