service_internal.c @ 961

Last change on this file since 961 was 617, checked in by david, 10 years ago
commit of partial async queue process management
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 122.2 KB

Rev	Line
[1]	1	/**
[549]	2	* Author : Gérald FENOY
[1]	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"
[478]	28	#else
	29	#include "cpl_vsi.h"
[216]	30	#endif
	31
[365]	32	#ifndef TRUE
	33	#define TRUE 1
	34	#endif
	35	#ifndef FALSE
	36	#define FALSE -1
	37	#endif
	38
[531]	39	int
	40	isValidLang (maps * conf, const char *str)
	41	{
	42	map *tmpMap = getMapFromMaps (conf, "main", "lang");
	43	char *tmp = zStrdup (tmpMap->value);
	44	char *pToken = strtok (tmp, ",");
	45	int res = -1;
	46	while (pToken != NULL)
	47	{
	48	if (strcasecmp (str, pToken) == 0)
	49	{
	50	res = 1;
	51	break;
	52	}
	53	pToken = strtok (NULL, ",");
[501]	54	}
[531]	55	free (tmp);
[501]	56	return res;
	57	}
	58
[531]	59	void
[549]	60	printHeaders (maps * m,FCGX_Stream *out)
[531]	61	{
	62	maps *_tmp = getMaps (m, "headers");
	63	if (_tmp != NULL)
	64	{
	65	map *_tmp1 = _tmp->content;
	66	while (_tmp1 != NULL)
	67	{
[549]	68	FCGX_FPrintF(out,"%s: %s\r\n", _tmp1->name, _tmp1->value);
	69	//printf ("%s: %s\r\n", _tmp1->name, _tmp1->value);
[531]	70	_tmp1 = _tmp1->next;
	71	}
[375]	72	}
	73	}
	74
[531]	75	void
	76	addLangAttr (xmlNodePtr n, maps * m)
	77	{
	78	map *tmpLmap = getMapFromMaps (m, "main", "language");
	79	if (tmpLmap != NULL)
	80	xmlNewProp (n, BAD_CAST "xml:lang", BAD_CAST tmpLmap->value);
[34]	81	else
[531]	82	xmlNewProp (n, BAD_CAST "xml:lang", BAD_CAST "en-US");
[34]	83	}
	84
[1]	85	/* Converts a hex character to its integer value */
[531]	86	char
	87	from_hex (char ch)
	88	{
	89	return isdigit (ch) ? ch - '0' : tolower (ch) - 'a' + 10;
[1]	90	}
	91
	92	/* Converts an integer value to its hex character*/
[531]	93	char
	94	to_hex (char code)
	95	{
[1]	96	static char hex[] = "0123456789abcdef";
	97	return hex[code & 15];
	98	}
	99
[216]	100	#ifdef WIN32
	101
	102	#include <windows.h>
[549]	103	//#include <fcgi_stdio.h>
[216]	104	#include <stdio.h>
	105	#include <conio.h>
	106	#include <tchar.h>
	107
	108	#define SHMEMSIZE 4096
	109
[531]	110	static LPVOID lpvMemG = NULL; // pointer to shared memory
	111	static HANDLE hMapObjectG = NULL; // handle to file mapping
[216]	112
[531]	113	int
	114	_updateStatus (maps * conf)
	115	{
[384]	116	LPWSTR lpszTmp;
	117	BOOL fInit;
[531]	118	char *final_string = NULL;
	119	char *s = NULL;
[452]	120	map *tmpMap1;
[531]	121	map *tmpMap = getMapFromMaps (conf, "lenv", "sid");
	122	if (hMapObjectG == NULL)
	123	hMapObjectG = CreateFileMapping (INVALID_HANDLE_VALUE, // use paging file
	124	NULL, // default security attributes
	125	PAGE_READWRITE, // read/write access
	126	0, // size: high 32-bits
	127	SHMEMSIZE, // size: low 32-bits
	128	TEXT (tmpMap->value)); // name of map object
	129	if (hMapObjectG == NULL)
	130	{
	131	fprintf (stderr, "Unable to create share memory segment %s !! \n",
	132	tmpMap->value);
	133	return -2;
	134	}
	135	fInit = (GetLastError () != ERROR_ALREADY_EXISTS);
	136	if (lpvMemG == NULL)
	137	lpvMemG = MapViewOfFile (hMapObjectG, // object to map view of
	138	FILE_MAP_WRITE, // read/write access
	139	0, // high offset: map from
	140	0, // low offset: beginning
	141	0); // default: map entire file
	142	if (lpvMemG == NULL)
	143	{
	144	fprintf (stderr,
	145	"Unable to create or access the shared memory segment %s !! \n",
	146	tmpMap->value);
	147	return -1;
	148	}
	149	memset (lpvMemG, '\0', SHMEMSIZE);
	150	tmpMap = getMapFromMaps (conf, "lenv", "status");
	151	tmpMap1 = NULL;
	152	tmpMap1 = getMapFromMaps (conf, "lenv", "message");
[384]	153	lpszTmp = (LPWSTR) lpvMemG;
[531]	154	final_string =
	155	(char ) malloc ((strlen (tmpMap1->value) + strlen (tmpMap->value) + 2)
	156	sizeof (char));
	157	sprintf (final_string, "%s\|%s", tmpMap->value, tmpMap1->value);
	158	for (s = final_string; s != '\0'; s++)
	159	{
	160	lpszTmp++ = s;
	161	}
[452]	162	*lpszTmp++ = '\0';
[531]	163	free (final_string);
[471]	164	return 0;
[216]	165	}
	166
[531]	167	char *
	168	getStatus (int pid)
	169	{
	170	char lpszBuf = (char ) malloc (SHMEMSIZE * sizeof (char));
	171	int i = 0;
	172	LPWSTR lpszTmp = NULL;
[216]	173	LPVOID lpvMem = NULL;
	174	HANDLE hMapObject = NULL;
[531]	175	BOOL fIgnore, fInit;
[216]	176	char tmp[100];
[531]	177	sprintf (tmp, "%i", pid);
	178	if (hMapObject == NULL)
	179	hMapObject = CreateFileMapping (INVALID_HANDLE_VALUE, // use paging file
	180	NULL, // default security attributes
	181	PAGE_READWRITE, // read/write access
	182	0, // size: high 32-bits
	183	4096, // size: low 32-bits
	184	TEXT (tmp)); // name of map object
	185	if (hMapObject == NULL)
[216]	186	return FALSE;
[531]	187	if ((GetLastError () != ERROR_ALREADY_EXISTS))
	188	{
	189	fIgnore = UnmapViewOfFile (lpvMem);
	190	fIgnore = CloseHandle (hMapObject);
	191	return "-1";
	192	}
	193	fInit = TRUE;
	194	if (lpvMem == NULL)
	195	lpvMem = MapViewOfFile (hMapObject, // object to map view of
	196	FILE_MAP_READ, // read/write access
	197	0, // high offset: map from
	198	0, // low offset: beginning
	199	0); // default: map entire file
	200	if (lpvMem == NULL)
[216]	201	return "-1";
	202	lpszTmp = (LPWSTR) lpvMem;
[531]	203	while (*lpszTmp)
	204	{
	205	lpszBuf[i] = (char) *lpszTmp;
	206	*lpszTmp++;
	207	lpszBuf[i + 1] = '\0';
	208	i++;
	209	}
[478]	210	#ifdef DEBUG
[531]	211	fprintf (stderr, "READING STRING S %s\n", lpszBuf);
[478]	212	#endif
[531]	213	return (char *) lpszBuf;
[216]	214	}
	215
[531]	216	void
	217	unhandleStatus (maps * conf)
	218	{
[216]	219	BOOL fIgnore;
[531]	220	fIgnore = UnmapViewOfFile (lpvMemG);
	221	fIgnore = CloseHandle (hMapObjectG);
[216]	222	}
	223	#else
[255]	224
[531]	225	void
	226	unhandleStatus (maps * conf)
	227	{
[490]	228	int shmid;
[26]	229	key_t key;
	230	void *shm;
	231	struct shmid_ds shmids;
[531]	232	map *tmpMap = getMapFromMaps (conf, "lenv", "sid");
	233	if (tmpMap != NULL)
	234	{
	235	key = atoi (tmpMap->value);
	236	if ((shmid = shmget (key, SHMSZ, IPC_CREAT \| 0666)) < 0)
	237	{
[26]	238	#ifdef DEBUG
[531]	239	fprintf (stderr, "shmget failed to update value\n");
[26]	240	#endif
[531]	241	}
	242	else
	243	{
	244	if ((shm = shmat (shmid, NULL, 0)) == (char *) -1)
	245	{
[26]	246	#ifdef DEBUG
[531]	247	fprintf (stderr, "shmat failed to update value\n");
[26]	248	#endif
[531]	249	}
	250	else
	251	{
	252	shmdt (shm);
	253	shmctl (shmid, IPC_RMID, &shmids);
	254	}
	255	}
[26]	256	}
	257	}
	258
[531]	259	int
	260	_updateStatus (maps * conf)
	261	{
[490]	262	int shmid;
[26]	263	key_t key;
[531]	264	char shm, s, *s1;
	265	map *tmpMap = NULL;
	266	tmpMap = getMapFromMaps (conf, "lenv", "sid");
	267	if (tmpMap != NULL)
	268	{
	269	key = atoi (tmpMap->value);
	270	if ((shmid = shmget (key, SHMSZ, IPC_CREAT \| 0666)) < 0)
	271	{
[26]	272	#ifdef DEBUG
[531]	273	fprintf (stderr,
	274	"shmget failed to create new Shared memory segment\n");
[26]	275	#endif
[531]	276	return -2;
	277	}
	278	else
	279	{
	280	if ((shm = (char ) shmat (shmid, NULL, 0)) == (char ) -1)
	281	{
[26]	282	#ifdef DEBUG
[531]	283	fprintf (stderr, "shmat failed to update value\n");
[26]	284	#endif
[531]	285	return -1;
	286	}
	287	else
	288	{
	289	tmpMap = getMapFromMaps (conf, "lenv", "status");
	290	s1 = shm;
	291	for (s = tmpMap->value; s != NULL && s != 0; s++)
	292	{
	293	s1++ = s;
	294	}
	295	*s1++ = '\|';
	296	tmpMap = getMapFromMaps (conf, "lenv", "message");
	297	if (tmpMap != NULL)
	298	for (s = tmpMap->value; s != NULL && s != 0; s++)
	299	{
	300	s1++ = s;
	301	}
	302	*s1 = NULL;
	303	shmdt ((void *) shm);
	304	}
	305	}
[26]	306	}
[471]	307	return 0;
[26]	308	}
	309
[531]	310	char *
	311	getStatus (int pid)
	312	{
[490]	313	int shmid;
[26]	314	key_t key;
	315	void *shm;
[531]	316	key = pid;
	317	if ((shmid = shmget (key, SHMSZ, 0666)) < 0)
	318	{
[26]	319	#ifdef DEBUG
[531]	320	fprintf (stderr, "shmget failed in getStatus\n");
[26]	321	#endif
[531]	322	}
	323	else
	324	{
	325	if ((shm = shmat (shmid, NULL, 0)) == (char *) -1)
	326	{
[26]	327	#ifdef DEBUG
[531]	328	fprintf (stderr, "shmat failed in getStatus\n");
[26]	329	#endif
[531]	330	}
	331	else
	332	{
	333	return (char *) shm;
	334	}
[26]	335	}
[531]	336	return (char *) "-1";
[26]	337	}
	338
[216]	339	#endif
[26]	340
[216]	341	#ifdef USE_JS
	342
	343	JSBool
[531]	344	JSUpdateStatus (JSContext * cx, uintN argc, jsval * argv1)
[216]	345	{
[531]	346	jsval *argv = JS_ARGV (cx, argv1);
	347	JS_MaybeGC (cx);
	348	int istatus = 0;
	349	char *status = NULL;
[216]	350	maps *conf;
[531]	351	if (argc > 2)
	352	{
[216]	353	#ifdef JS_DEBUG
[531]	354	fprintf (stderr, "Number of arguments used to call the function : %i",
	355	argc);
[216]	356	#endif
[531]	357	return JS_FALSE;
[274]	358	}
[531]	359	conf = mapsFromJSObject (cx, argv[0]);
	360	if (JS_ValueToInt32 (cx, argv[1], &istatus) == JS_TRUE)
	361	{
	362	char tmpStatus[4];
	363	sprintf (tmpStatus, "%i", istatus);
	364	tmpStatus[3] = 0;
	365	status = strdup (tmpStatus);
	366	}
	367	if (getMapFromMaps (conf, "lenv", "status") != NULL)
	368	{
	369	if (status != NULL)
	370	{
	371	setMapInMaps (conf, "lenv", "status", status);
	372	free (status);
	373	}
	374	else
	375	setMapInMaps (conf, "lenv", "status", "15");
	376	_updateStatus (conf);
	377	}
	378	freeMaps (&conf);
	379	free (conf);
	380	JS_MaybeGC (cx);
[216]	381	return JS_TRUE;
	382	}
	383
	384	#endif
	385
	386
	387
[1]	388	/* Returns a url-encoded version of str */
	389	/* IMPORTANT: be sure to free() the returned string after use */
[531]	390	char *
	391	url_encode (char *str)
	392	{
	393	char pstr = str, buf = (char ) malloc (strlen (str) 3 + 1), *pbuf =
	394	buf;
	395	while (*pstr)
	396	{
	397	if (isalnum (pstr) \|\| pstr == '-' \|\| pstr == '_' \|\| pstr == '.'
	398	\|\| *pstr == '~')
	399	pbuf++ = pstr;
	400	else if (*pstr == ' ')
	401	*pbuf++ = '+';
	402	else
	403	pbuf++ = '%', pbuf++ = to_hex (pstr >> 4), pbuf++ =
	404	to_hex (*pstr & 15);
	405	pstr++;
	406	}
[1]	407	*pbuf = '\0';
	408	return buf;
	409	}
	410
	411	/* Returns a url-decoded version of str */
	412	/* IMPORTANT: be sure to free() the returned string after use */
[531]	413	char *
	414	url_decode (char *str)
	415	{
	416	char pstr = str, buf = (char ) malloc (strlen (str) + 1), pbuf = buf;
	417	while (*pstr)
	418	{
	419	if (*pstr == '%')
	420	{
	421	if (pstr[1] && pstr[2])
	422	{
	423	*pbuf++ = from_hex (pstr[1]) << 4 \| from_hex (pstr[2]);
	424	pstr += 2;
	425	}
	426	}
	427	else if (*pstr == '+')
	428	{
	429	*pbuf++ = ' ';
	430	}
	431	else
	432	{
	433	pbuf++ = pstr;
	434	}
	435	pstr++;
[1]	436	}
	437	*pbuf = '\0';
	438	return buf;
	439	}
	440
[531]	441	char *
	442	zCapitalize1 (char *tmp)
	443	{
	444	char *res = strdup (tmp);
	445	if (res[0] >= 97 && res[0] <= 122)
	446	res[0] -= 32;
	447	return res;
[9]	448	}
[1]	449
[531]	450	char *
	451	zCapitalize (char *tmp)
	452	{
	453	int i = 0;
	454	char *res = strdup (tmp);
	455	for (i = 0; i < strlen (res); i++)
	456	if (res[i] >= 97 && res[i] <= 122)
	457	res[i] -= 32;
[9]	458	return res;
	459	}
[1]	460
[9]	461
[531]	462	int
	463	zooXmlSearchForNs (const char *name)
	464	{
[9]	465	int i;
[531]	466	int res = -1;
	467	for (i = 0; i < nbNs; i++)
	468	if (strncasecmp (name, nsName[i], strlen (nsName[i])) == 0)
	469	{
	470	res = i;
	471	break;
	472	}
[9]	473	return res;
	474	}
[1]	475
[531]	476	int
	477	zooXmlAddNs (xmlNodePtr nr, const char url, const char name)
	478	{
[1]	479	#ifdef DEBUG
[531]	480	fprintf (stderr, "zooXmlAddNs %d %s \n", nbNs, name);
[1]	481	#endif
[531]	482	int currId = -1;
	483	if (nbNs == 0)
	484	{
[9]	485	nbNs++;
[531]	486	currId = 0;
	487	nsName[currId] = strdup (name);
	488	usedNs[currId] = xmlNewNs (nr, BAD_CAST url, BAD_CAST name);
[1]	489	}
[531]	490	else
	491	{
	492	currId = zooXmlSearchForNs (name);
	493	if (currId < 0)
	494	{
	495	nbNs++;
	496	currId = nbNs - 1;
	497	nsName[currId] = strdup (name);
	498	usedNs[currId] = xmlNewNs (nr, BAD_CAST url, BAD_CAST name);
	499	}
	500	}
[9]	501	return currId;
	502	}
[1]	503
[531]	504	void
	505	zooXmlCleanupNs ()
	506	{
[9]	507	int j;
[1]	508	#ifdef DEBUG
[531]	509	fprintf (stderr, "zooXmlCleanup %d\n", nbNs);
[1]	510	#endif
[531]	511	for (j = nbNs - 1; j >= 0; j--)
	512	{
[1]	513	#ifdef DEBUG
[531]	514	fprintf (stderr, "zooXmlCleanup %d\n", j);
[1]	515	#endif
[531]	516	if (j == 0)
	517	xmlFreeNs (usedNs[j]);
	518	free (nsName[j]);
	519	nbNs--;
	520	}
	521	nbNs = 0;
[1]	522	}
	523
[490]	524
[531]	525	int
	526	zooXmlAddDoc (const char *value)
	527	{
	528	int currId = 0;
[490]	529	nbDocs++;
[531]	530	currId = nbDocs - 1;
	531	iDocs[currId] = xmlParseMemory (value, strlen (value));
[490]	532	return currId;
	533	}
	534
[531]	535	void
	536	zooXmlCleanupDocs ()
	537	{
[490]	538	int j;
[531]	539	for (j = nbDocs - 1; j >= 0; j--)
	540	{
	541	xmlFreeDoc (iDocs[j]);
	542	}
	543	nbDocs = 0;
[490]	544	}
	545
	546
[531]	547	xmlNodePtr
	548	soapEnvelope (maps * conf, xmlNodePtr n)
	549	{
	550	map *soap = getMapFromMaps (conf, "main", "isSoap");
	551	if (soap != NULL && strcasecmp (soap->value, "true") == 0)
	552	{
	553	int lNbNs = nbNs;
	554	nsName[lNbNs] = strdup ("soap");
	555	usedNs[lNbNs] =
	556	xmlNewNs (NULL, BAD_CAST "http://www.w3.org/2003/05/soap-envelope",
	557	BAD_CAST "soap");
	558	nbNs++;
	559	xmlNodePtr nr = xmlNewNode (usedNs[lNbNs], BAD_CAST "Envelope");
	560	nsName[nbNs] = strdup ("soap");
	561	usedNs[nbNs] =
	562	xmlNewNs (nr, BAD_CAST "http://www.w3.org/2003/05/soap-envelope",
	563	BAD_CAST "soap");
	564	nbNs++;
	565	nsName[nbNs] = strdup ("xsi");
	566	usedNs[nbNs] =
	567	xmlNewNs (nr, BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",
	568	BAD_CAST "xsi");
	569	nbNs++;
	570	xmlNsPtr ns_xsi = usedNs[nbNs - 1];
	571	xmlNewNsProp (nr, ns_xsi, BAD_CAST "schemaLocation",
	572	BAD_CAST
	573	"http://www.w3.org/2003/05/soap-envelope http://www.w3.org/2003/05/soap-envelope");
	574	xmlNodePtr nr1 = xmlNewNode (usedNs[lNbNs], BAD_CAST "Body");
	575	xmlAddChild (nr1, n);
	576	xmlAddChild (nr, nr1);
	577	return nr;
	578	}
	579	else
[280]	580	return n;
	581	}
	582
[531]	583	xmlNodePtr
	584	printGetCapabilitiesHeader (xmlDocPtr doc, const char service, maps m)
	585	{
[1]	586
[531]	587	xmlNsPtr ns, ns_ows, ns_xlink, ns_xsi;
	588	xmlNodePtr n, nc, nc1, nc2, nc3, nc4, nc5, nc6;
[1]	589	/**
	590	* Create the document and its temporary root.
	591	*/
[531]	592	int wpsId = zooXmlAddNs (NULL, "http://www.opengis.net/wps/1.0.0", "wps");
	593	ns = usedNs[wpsId];
	594	maps *toto1 = getMaps (m, "main");
[1]	595
[531]	596	n = xmlNewNode (ns, BAD_CAST "Capabilities");
	597	int owsId = zooXmlAddNs (n, "http://www.opengis.net/ows/1.1", "ows");
	598	ns_ows = usedNs[owsId];
	599	xmlNewNs (n, BAD_CAST "http://www.opengis.net/wps/1.0.0", BAD_CAST "wps");
	600	int xsiId =
	601	zooXmlAddNs (n, "http://www.w3.org/2001/XMLSchema-instance", "xsi");
	602	ns_xsi = usedNs[xsiId];
	603	int xlinkId = zooXmlAddNs (n, "http://www.w3.org/1999/xlink", "xlink");
	604	ns_xlink = usedNs[xlinkId];
	605	xmlNewNsProp (n, ns_xsi, BAD_CAST "schemaLocation",
	606	BAD_CAST
	607	"http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd");
	608	xmlNewProp (n, BAD_CAST "service", BAD_CAST "WPS");
	609	addLangAttr (n, m);
	610
	611	if (toto1 != NULL)
	612	{
	613	map *tmp = getMap (toto1->content, "version");
	614	if (tmp != NULL)
	615	{
	616	xmlNewProp (n, BAD_CAST "version", BAD_CAST tmp->value);
	617	}
	618	else
	619	xmlNewProp (n, BAD_CAST "version", BAD_CAST "1.0.0");
[1]	620	}
	621	else
[531]	622	xmlNewProp (n, BAD_CAST "version", BAD_CAST "1.0.0");
[1]	623
	624	char tmp[256];
	625
[531]	626	nc = xmlNewNode (ns_ows, BAD_CAST "ServiceIdentification");
	627	maps *tmp4 = getMaps (m, "identification");
	628	if (tmp4 != NULL)
	629	{
	630	map *tmp2 = tmp4->content;
	631	const char *orderedFields[5];
	632	orderedFields[0] = "Title";
	633	orderedFields[1] = "Abstract";
	634	orderedFields[2] = "Keywords";
	635	orderedFields[3] = "Fees";
	636	orderedFields[4] = "AccessConstraints";
	637	int oI = 0;
	638	for (oI = 0; oI < 5; oI++)
	639	if ((tmp2 = getMap (tmp4->content, orderedFields[oI])) != NULL)
	640	{
	641	if (strcasecmp (tmp2->name, "abstract") == 0 \|\|
	642	strcasecmp (tmp2->name, "title") == 0 \|\|
	643	strcasecmp (tmp2->name, "accessConstraints") == 0 \|\|
	644	strcasecmp (tmp2->name, "fees") == 0)
	645	{
	646	tmp2->name[0] = toupper (tmp2->name[0]);
	647	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp2->name);
	648	xmlAddChild (nc1, xmlNewText (BAD_CAST tmp2->value));
	649	xmlAddChild (nc, nc1);
	650	}
	651	else if (strcmp (tmp2->name, "keywords") == 0)
	652	{
	653	nc1 = xmlNewNode (ns_ows, BAD_CAST "Keywords");
	654	char *toto = tmp2->value;
	655	char buff[256];
	656	int i = 0;
	657	int j = 0;
	658	while (toto[i])
	659	{
	660	if (toto[i] != ',' && toto[i] != 0)
	661	{
	662	buff[j] = toto[i];
	663	buff[j + 1] = 0;
	664	j++;
	665	}
	666	else
	667	{
	668	nc2 = xmlNewNode (ns_ows, BAD_CAST "Keyword");
	669	xmlAddChild (nc2, xmlNewText (BAD_CAST buff));
	670	xmlAddChild (nc1, nc2);
	671	j = 0;
	672	}
	673	i++;
	674	}
	675	if (strlen (buff) > 0)
	676	{
	677	nc2 = xmlNewNode (ns_ows, BAD_CAST "Keyword");
	678	xmlAddChild (nc2, xmlNewText (BAD_CAST buff));
	679	xmlAddChild (nc1, nc2);
	680	}
	681	xmlAddChild (nc, nc1);
	682	nc2 = xmlNewNode (ns_ows, BAD_CAST "ServiceType");
	683	xmlAddChild (nc2, xmlNewText (BAD_CAST "WPS"));
	684	xmlAddChild (nc, nc2);
	685	nc2 = xmlNewNode (ns_ows, BAD_CAST "ServiceTypeVersion");
	686	xmlAddChild (nc2, xmlNewText (BAD_CAST "1.0.0"));
	687	xmlAddChild (nc, nc2);
	688	}
	689	tmp2 = tmp2->next;
	690	}
	691	}
	692	else
	693	{
	694	fprintf (stderr, "TMP4 NOT FOUND !!");
	695	return NULL;
	696	}
	697	xmlAddChild (n, nc);
[1]	698
[531]	699	nc = xmlNewNode (ns_ows, BAD_CAST "ServiceProvider");
	700	nc3 = xmlNewNode (ns_ows, BAD_CAST "ServiceContact");
	701	nc4 = xmlNewNode (ns_ows, BAD_CAST "ContactInfo");
	702	nc5 = xmlNewNode (ns_ows, BAD_CAST "Phone");
	703	nc6 = xmlNewNode (ns_ows, BAD_CAST "Address");
	704	tmp4 = getMaps (m, "provider");
	705	if (tmp4 != NULL)
	706	{
	707	map *tmp2 = tmp4->content;
	708	const char *tmpAddress[6];
	709	tmpAddress[0] = "addressDeliveryPoint";
	710	tmpAddress[1] = "addressCity";
	711	tmpAddress[2] = "addressAdministrativeArea";
	712	tmpAddress[3] = "addressPostalCode";
	713	tmpAddress[4] = "addressCountry";
	714	tmpAddress[5] = "addressElectronicMailAddress";
	715	const char *tmpPhone[2];
	716	tmpPhone[0] = "phoneVoice";
	717	tmpPhone[1] = "phoneFacsimile";
	718	const char *orderedFields[12];
	719	orderedFields[0] = "providerName";
	720	orderedFields[1] = "providerSite";
	721	orderedFields[2] = "individualName";
	722	orderedFields[3] = "positionName";
	723	orderedFields[4] = tmpPhone[0];
	724	orderedFields[5] = tmpPhone[1];
	725	orderedFields[6] = tmpAddress[0];
	726	orderedFields[7] = tmpAddress[1];
	727	orderedFields[8] = tmpAddress[2];
	728	orderedFields[9] = tmpAddress[3];
	729	orderedFields[10] = tmpAddress[4];
	730	orderedFields[11] = tmpAddress[5];
	731	int oI = 0;
	732	for (oI = 0; oI < 12; oI++)
	733	if ((tmp2 = getMap (tmp4->content, orderedFields[oI])) != NULL)
	734	{
	735	if (strcmp (tmp2->name, "keywords") != 0 &&
	736	strcmp (tmp2->name, "serverAddress") != 0 &&
	737	strcmp (tmp2->name, "lang") != 0)
	738	{
	739	tmp2->name[0] = toupper (tmp2->name[0]);
	740	if (strcmp (tmp2->name, "ProviderName") == 0)
	741	{
	742	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp2->name);
	743	xmlAddChild (nc1, xmlNewText (BAD_CAST tmp2->value));
	744	xmlAddChild (nc, nc1);
	745	}
	746	else
	747	{
	748	if (strcmp (tmp2->name, "ProviderSite") == 0)
	749	{
	750	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp2->name);
	751	xmlNewNsProp (nc1, ns_xlink, BAD_CAST "href",
	752	BAD_CAST tmp2->value);
	753	xmlAddChild (nc, nc1);
	754	}
	755	else
	756	if (strcmp (tmp2->name, "IndividualName") == 0 \|\|
	757	strcmp (tmp2->name, "PositionName") == 0)
	758	{
	759	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp2->name);
	760	xmlAddChild (nc1, xmlNewText (BAD_CAST tmp2->value));
	761	xmlAddChild (nc3, nc1);
	762	}
	763	else if (strncmp (tmp2->name, "Phone", 5) == 0)
	764	{
	765	int j;
	766	for (j = 0; j < 2; j++)
	767	if (strcasecmp (tmp2->name, tmpPhone[j]) == 0)
	768	{
	769	char *tmp4 = tmp2->name;
	770	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp4 + 5);
	771	xmlAddChild (nc1,
	772	xmlNewText (BAD_CAST tmp2->value));
	773	xmlAddChild (nc5, nc1);
	774	}
	775	}
	776	else if (strncmp (tmp2->name, "Address", 7) == 0)
	777	{
	778	int j;
	779	for (j = 0; j < 6; j++)
	780	if (strcasecmp (tmp2->name, tmpAddress[j]) == 0)
	781	{
	782	char *tmp4 = tmp2->name;
	783	nc1 = xmlNewNode (ns_ows, BAD_CAST tmp4 + 7);
	784	xmlAddChild (nc1,
	785	xmlNewText (BAD_CAST tmp2->value));
	786	xmlAddChild (nc6, nc1);
	787	}
	788	}
	789	}
	790	}
	791	else if (strcmp (tmp2->name, "keywords") == 0)
	792	{
	793	nc1 = xmlNewNode (ns_ows, BAD_CAST "Keywords");
	794	char *toto = tmp2->value;
	795	char buff[256];
	796	int i = 0;
	797	int j = 0;
	798	while (toto[i])
	799	{
	800	if (toto[i] != ',' && toto[i] != 0)
	801	{
	802	buff[j] = toto[i];
	803	buff[j + 1] = 0;
	804	j++;
	805	}
	806	else
	807	{
	808	nc2 = xmlNewNode (ns_ows, BAD_CAST "Keyword");
	809	xmlAddChild (nc2, xmlNewText (BAD_CAST buff));
	810	xmlAddChild (nc1, nc2);
	811	j = 0;
	812	}
	813	i++;
	814	}
	815	if (strlen (buff) > 0)
	816	{
	817	nc2 = xmlNewNode (ns_ows, BAD_CAST "Keyword");
	818	xmlAddChild (nc2, xmlNewText (BAD_CAST buff));
	819	xmlAddChild (nc1, nc2);
	820	}
	821	xmlAddChild (nc, nc1);
	822	}
	823	tmp2 = tmp2->next;
	824	}
	825	}
	826	else
	827	{
	828	fprintf (stderr, "TMP4 NOT FOUND !!");
	829	}
	830	xmlAddChild (nc4, nc5);
	831	xmlAddChild (nc4, nc6);
	832	xmlAddChild (nc3, nc4);
	833	xmlAddChild (nc, nc3);
	834	xmlAddChild (n, nc);
[1]	835
[531]	836
	837	nc = xmlNewNode (ns_ows, BAD_CAST "OperationsMetadata");
[1]	838	char *tmp2[3];
[531]	839	tmp2[0] = strdup ("GetCapabilities");
	840	tmp2[1] = strdup ("DescribeProcess");
	841	tmp2[2] = strdup ("Execute");
	842	int j = 0;
[1]	843
[531]	844	if (toto1 != NULL)
	845	{
	846	map *tmp = getMap (toto1->content, "serverAddress");
	847	if (tmp != NULL)
	848	{
	849	SERVICE_URL = strdup (tmp->value);
	850	}
	851	else
	852	SERVICE_URL = strdup ("not_found");
[1]	853	}
	854	else
[531]	855	SERVICE_URL = strdup ("not_found");
[1]	856
[531]	857	for (j = 0; j < 3; j++)
	858	{
	859	nc1 = xmlNewNode (ns_ows, BAD_CAST "Operation");
	860	xmlNewProp (nc1, BAD_CAST "name", BAD_CAST tmp2[j]);
	861	nc2 = xmlNewNode (ns_ows, BAD_CAST "DCP");
	862	nc3 = xmlNewNode (ns_ows, BAD_CAST "HTTP");
	863	nc4 = xmlNewNode (ns_ows, BAD_CAST "Get");
	864	sprintf (tmp, "%s/%s", SERVICE_URL, service);
	865	xmlNewNsProp (nc4, ns_xlink, BAD_CAST "href", BAD_CAST tmp);
	866	xmlAddChild (nc3, nc4);
	867	if (j > 0)
	868	{
	869	nc4 = xmlNewNode (ns_ows, BAD_CAST "Post");
	870	xmlNewNsProp (nc4, ns_xlink, BAD_CAST "href", BAD_CAST tmp);
	871	xmlAddChild (nc3, nc4);
	872	}
	873	xmlAddChild (nc2, nc3);
	874	xmlAddChild (nc1, nc2);
	875	xmlAddChild (nc, nc1);
[1]	876	}
[531]	877	for (j = 2; j >= 0; j--)
	878	free (tmp2[j]);
	879	xmlAddChild (n, nc);
[1]	880
[531]	881	nc = xmlNewNode (ns, BAD_CAST "ProcessOfferings");
	882	xmlAddChild (n, nc);
[1]	883
[531]	884	nc1 = xmlNewNode (ns, BAD_CAST "Languages");
	885	nc2 = xmlNewNode (ns, BAD_CAST "Default");
	886	nc3 = xmlNewNode (ns, BAD_CAST "Supported");
	887
	888	toto1 = getMaps (m, "main");
	889	if (toto1 != NULL)
	890	{
	891	map *tmp1 = getMap (toto1->content, "lang");
	892	char *toto = tmp1->value;
	893	char buff[256];
	894	int i = 0;
	895	int j = 0;
	896	int dcount = 0;
	897	while (toto[i])
	898	{
	899	if (toto[i] != ',' && toto[i] != 0)
	900	{
	901	buff[j] = toto[i];
	902	buff[j + 1] = 0;
	903	j++;
	904	}
	905	else
	906	{
	907	nc4 = xmlNewNode (ns_ows, BAD_CAST "Language");
	908	xmlAddChild (nc4, xmlNewText (BAD_CAST buff));
	909	if (dcount == 0)
	910	{
	911	xmlAddChild (nc2, nc4);
	912	xmlAddChild (nc1, nc2);
	913	dcount++;
	914	}
	915	nc4 = xmlNewNode (ns_ows, BAD_CAST "Language");
	916	xmlAddChild (nc4, xmlNewText (BAD_CAST buff));
	917	xmlAddChild (nc3, nc4);
	918	j = 0;
	919	buff[j] = 0;
	920	}
	921	i++;
	922	}
	923	if (strlen (buff) > 0)
	924	{
	925	nc4 = xmlNewNode (ns_ows, BAD_CAST "Language");
	926	xmlAddChild (nc4, xmlNewText (BAD_CAST buff));
	927	xmlAddChild (nc3, nc4);
	928	}
[1]	929	}
[531]	930	xmlAddChild (nc1, nc3);
	931	xmlAddChild (n, nc1);
	932
	933	xmlNodePtr fn = soapEnvelope (m, n);
	934	xmlDocSetRootElement (doc, fn);
[9]	935	//xmlFreeNs(ns);
[531]	936	free (SERVICE_URL);
[1]	937	return nc;
	938	}
	939
[531]	940	void
	941	addPrefix (maps * conf, map * level, service * serv)
	942	{
	943	if (level != NULL)
	944	{
	945	char key[25];
	946	char *prefix = NULL;
	947	int clevel = atoi (level->value);
	948	int cl = 0;
	949	for (cl = 0; cl < clevel; cl++)
	950	{
	951	sprintf (key, "sprefix_%d", cl);
	952	map *tmp2 = getMapFromMaps (conf, "lenv", key);
	953	if (tmp2 != NULL)
	954	{
	955	if (prefix == NULL)
	956	prefix = zStrdup (tmp2->value);
	957	else
	958	{
	959	int plen = strlen (prefix);
	960	prefix =
	961	(char *) realloc (prefix,
	962	(plen + strlen (tmp2->value) +
	963	2) * sizeof (char));
	964	memcpy (prefix + plen, tmp2->value,
	965	strlen (tmp2->value) * sizeof (char));
	966	prefix[plen + strlen (tmp2->value)] = 0;
	967	}
	968	}
	969	}
	970	if (prefix != NULL)
	971	{
	972	char *tmp0 = strdup (serv->name);
	973	free (serv->name);
	974	serv->name =
	975	(char ) malloc ((strlen (prefix) + strlen (tmp0) + 1)
	976	sizeof (char));
	977	sprintf (serv->name, "%s%s", prefix, tmp0);
	978	free (tmp0);
	979	free (prefix);
	980	prefix = NULL;
	981	}
[469]	982	}
	983	}
	984
[531]	985	void
	986	printGetCapabilitiesForProcess (maps * m, xmlNodePtr nc, service * serv)
	987	{
	988	xmlNsPtr ns, ns_ows, ns_xlink;
	989	xmlNodePtr n = NULL, nc1, nc2;
[9]	990	/**
	991	* Initialize or get existing namspaces
	992	*/
[531]	993	int wpsId = zooXmlAddNs (NULL, "http://www.opengis.net/wps/1.0.0", "wps");
	994	ns = usedNs[wpsId];
	995	int owsId = zooXmlAddNs (NULL, "http://www.opengis.net/ows/1.1", "ows");
	996	ns_ows = usedNs[owsId];
	997	int xlinkId = zooXmlAddNs (n, "http://www.w3.org/1999/xlink", "xlink");
	998	ns_xlink = usedNs[xlinkId];
[1]	999
[531]	1000	map *tmp1;
	1001	if (serv->content != NULL)
	1002	{
	1003	nc1 = xmlNewNode (ns, BAD_CAST "Process");
	1004	tmp1 = getMap (serv->content, "processVersion");
	1005	if (tmp1 != NULL)
	1006	xmlNewNsProp (nc1, ns, BAD_CAST "processVersion",
	1007	BAD_CAST tmp1->value);
	1008	map *tmp3 = getMapFromMaps (m, "lenv", "level");
	1009	addPrefix (m, tmp3, serv);
	1010	printDescription (nc1, ns_ows, serv->name, serv->content);
	1011	tmp1 = serv->metadata;
	1012	while (tmp1 != NULL)
	1013	{
	1014	nc2 = xmlNewNode (ns_ows, BAD_CAST "Metadata");
	1015	xmlNewNsProp (nc2, ns_xlink, BAD_CAST tmp1->name,
	1016	BAD_CAST tmp1->value);
	1017	xmlAddChild (nc1, nc2);
	1018	tmp1 = tmp1->next;
	1019	}
	1020	xmlAddChild (nc, nc1);
[1]	1021	}
	1022	}
	1023
[531]	1024	xmlNodePtr
	1025	printDescribeProcessHeader (xmlDocPtr doc, const char service, maps m)
	1026	{
[1]	1027
[531]	1028	xmlNsPtr ns, ns_xsi;
[490]	1029	xmlNodePtr n;
[1]	1030
[531]	1031	int wpsId =
	1032	zooXmlAddNs (NULL, "http://schemas.opengis.net/wps/1.0.0", "wps");
	1033	ns = usedNs[wpsId];
	1034	n = xmlNewNode (ns, BAD_CAST "ProcessDescriptions");
	1035	zooXmlAddNs (n, "http://www.opengis.net/ows/1.1", "ows");
	1036	xmlNewNs (n, BAD_CAST "http://www.opengis.net/wps/1.0.0", BAD_CAST "wps");
	1037	zooXmlAddNs (n, "http://www.w3.org/1999/xlink", "xlink");
	1038	int xsiId =
	1039	zooXmlAddNs (n, "http://www.w3.org/2001/XMLSchema-instance", "xsi");
	1040	ns_xsi = usedNs[xsiId];
[1]	1041
[531]	1042	xmlNewNsProp (n, ns_xsi, BAD_CAST "schemaLocation",
	1043	BAD_CAST
	1044	"http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd");
	1045	xmlNewProp (n, BAD_CAST "service", BAD_CAST "WPS");
	1046	xmlNewProp (n, BAD_CAST "version", BAD_CAST "1.0.0");
	1047	addLangAttr (n, m);
[1]	1048
[531]	1049	xmlNodePtr fn = soapEnvelope (m, n);
	1050	xmlDocSetRootElement (doc, fn);
	1051
[1]	1052	return n;
	1053	}
	1054
[531]	1055	void
	1056	printDescribeProcessForProcess (maps * m, xmlNodePtr nc, service * serv)
	1057	{
	1058	xmlNsPtr ns, ns_ows, ns_xlink;
	1059	xmlNodePtr n, nc1;
[1]	1060
[531]	1061	n = nc;
[1]	1062
[531]	1063	int wpsId =
	1064	zooXmlAddNs (NULL, "http://schemas.opengis.net/wps/1.0.0", "wps");
	1065	ns = usedNs[wpsId];
	1066	int owsId = zooXmlAddNs (NULL, "http://www.opengis.net/ows/1.1", "ows");
	1067	ns_ows = usedNs[owsId];
	1068	int xlinkId = zooXmlAddNs (NULL, "http://www.w3.org/1999/xlink", "xlink");
	1069	ns_xlink = usedNs[xlinkId];
	1070
	1071	nc = xmlNewNode (NULL, BAD_CAST "ProcessDescription");
[490]	1072	const char *tmp4[3];
[531]	1073	tmp4[0] = "processVersion";
	1074	tmp4[1] = "storeSupported";
	1075	tmp4[2] = "statusSupported";
	1076	int j = 0;
	1077	map *tmp1 = NULL;
	1078	for (j = 0; j < 3; j++)
	1079	{
	1080	tmp1 = getMap (serv->content, tmp4[j]);
	1081	if (tmp1 != NULL)
	1082	{
	1083	if (j == 0)
	1084	xmlNewNsProp (nc, ns, BAD_CAST "processVersion",
	1085	BAD_CAST tmp1->value);
	1086	else
	1087	xmlNewProp (nc, BAD_CAST tmp4[j], BAD_CAST tmp1->value);
	1088	}
[1]	1089	else
[531]	1090	{
	1091	if (j > 0)
	1092	xmlNewProp (nc, BAD_CAST tmp4[j], BAD_CAST "false");
	1093	}
[1]	1094	}
[531]	1095
	1096	tmp1 = getMapFromMaps (m, "lenv", "level");
	1097	addPrefix (m, tmp1, serv);
	1098	printDescription (nc, ns_ows, serv->identifier, serv->content);
	1099
	1100	tmp1 = serv->metadata;
	1101	while (tmp1 != NULL)
	1102	{
	1103	nc1 = xmlNewNode (ns_ows, BAD_CAST "Metadata");
	1104	xmlNewNsProp (nc1, ns_xlink, BAD_CAST tmp1->name, BAD_CAST tmp1->value);
	1105	xmlAddChild (nc, nc1);
	1106	tmp1 = tmp1->next;
[1]	1107	}
	1108
[531]	1109	tmp1 = getMap (serv->content, "Profile");
	1110	if (tmp1 != NULL)
	1111	{
	1112	nc1 = xmlNewNode (ns, BAD_CAST "Profile");
	1113	xmlAddChild (nc1, xmlNewText (BAD_CAST tmp1->value));
	1114	xmlAddChild (nc, nc1);
	1115	}
[1]	1116
[531]	1117	if (serv->inputs != NULL)
	1118	{
	1119	nc1 = xmlNewNode (NULL, BAD_CAST "DataInputs");
	1120	elements *e = serv->inputs;
	1121	printFullDescription (1, e, "Input", ns_ows, nc1);
	1122	xmlAddChild (nc, nc1);
	1123	}
[1]	1124
[531]	1125	nc1 = xmlNewNode (NULL, BAD_CAST "ProcessOutputs");
	1126	elements *e = serv->outputs;
	1127	printFullDescription (0, e, "Output", ns_ows, nc1);
	1128	xmlAddChild (nc, nc1);
[1]	1129
[531]	1130	xmlAddChild (n, nc);
[1]	1131
[76]	1132	}
[1]	1133
[531]	1134	void
	1135	printFullDescription (int in, elements * elem, const char *type,
	1136	xmlNsPtr ns_ows, xmlNodePtr nc1)
	1137	{
[490]	1138	const char *orderedFields[13];
[531]	1139	orderedFields[0] = "mimeType";
	1140	orderedFields[1] = "encoding";
	1141	orderedFields[2] = "schema";
	1142	orderedFields[3] = "dataType";
	1143	orderedFields[4] = "uom";
	1144	orderedFields[5] = "CRS";
	1145	orderedFields[6] = "value";
	1146	orderedFields[7] = "AllowedValues";
	1147	orderedFields[8] = "range";
	1148	orderedFields[9] = "rangeMin";
	1149	orderedFields[10] = "rangeMax";
	1150	orderedFields[11] = "rangeClosure";
	1151	orderedFields[12] = "rangeSpace";
[76]	1152
[531]	1153	xmlNodePtr nc2, nc3, nc4, nc5, nc6, nc7, nc8, nc9;
	1154	elements *e = elem;
[471]	1155
[531]	1156	map *tmp1 = NULL;
	1157	while (e != NULL)
	1158	{
	1159	int default1 = 0;
	1160	int isAnyValue = 1;
	1161	nc2 = xmlNewNode (NULL, BAD_CAST type);
	1162	if (strncmp (type, "Input", 5) == 0)
	1163	{
	1164	tmp1 = getMap (e->content, "minOccurs");
	1165	if (tmp1 != NULL)
	1166	{
	1167	xmlNewProp (nc2, BAD_CAST tmp1->name, BAD_CAST tmp1->value);
	1168	}
	1169	else
	1170	xmlNewProp (nc2, BAD_CAST "minOccurs", BAD_CAST "0");
	1171	tmp1 = getMap (e->content, "maxOccurs");
	1172	if (tmp1 != NULL)
	1173	{
	1174	if (strcasecmp (tmp1->value, "unbounded") != 0)
	1175	xmlNewProp (nc2, BAD_CAST tmp1->name, BAD_CAST tmp1->value);
	1176	else
	1177	xmlNewProp (nc2, BAD_CAST "maxOccurs", BAD_CAST "1000");
	1178	}
	1179	else
	1180	xmlNewProp (nc2, BAD_CAST "maxOccurs", BAD_CAST "1");
	1181	if ((tmp1 = getMap (e->content, "maximumMegabytes")) != NULL)
	1182	{
	1183	xmlNewProp (nc2, BAD_CAST "maximumMegabytes",
	1184	BAD_CAST tmp1->value);
	1185	}
	1186	}
[1]	1187
[531]	1188	printDescription (nc2, ns_ows, e->name, e->content);
[1]	1189
[471]	1190	/**
	1191	* Build the (Literal/Complex/BoundingBox)Data node
	1192	*/
[531]	1193	if (strncmp (type, "Output", 6) == 0)
	1194	{
	1195	if (strncasecmp (e->format, "LITERALDATA", strlen (e->format)) == 0)
	1196	nc3 = xmlNewNode (NULL, BAD_CAST "LiteralOutput");
	1197	else if (strncasecmp (e->format, "COMPLEXDATA", strlen (e->format))
	1198	== 0)
	1199	nc3 = xmlNewNode (NULL, BAD_CAST "ComplexOutput");
	1200	else
	1201	if (strncasecmp (e->format, "BOUNDINGBOXDATA", strlen (e->format))
	1202	== 0)
	1203	nc3 = xmlNewNode (NULL, BAD_CAST "BoundingBoxOutput");
	1204	else
	1205	nc3 = xmlNewNode (NULL, BAD_CAST e->format);
	1206	}
[1]	1207	else
[531]	1208	{
	1209	if (strncasecmp (e->format, "LITERALDATA", strlen (e->format)) == 0)
	1210	{
	1211	nc3 = xmlNewNode (NULL, BAD_CAST "LiteralData");
	1212	}
	1213	else if (strncasecmp (e->format, "COMPLEXDATA", strlen (e->format))
	1214	== 0)
	1215	nc3 = xmlNewNode (NULL, BAD_CAST "ComplexData");
	1216	else
	1217	if (strncasecmp (e->format, "BOUNDINGBOXDATA", strlen (e->format))
	1218	== 0)
	1219	nc3 = xmlNewNode (NULL, BAD_CAST "BoundingBoxData");
	1220	else
	1221	nc3 = xmlNewNode (NULL, BAD_CAST e->format);
	1222	}
[471]	1223
[531]	1224	iotype *_tmp0 = NULL;
	1225	iotype *_tmp = e->defaults;
	1226	int datatype = 0;
	1227	bool hasUOM = false;
	1228	bool hasUOM1 = false;
	1229	if (_tmp != NULL)
	1230	{
	1231	if (strcmp (e->format, "LiteralOutput") == 0 \|\|
	1232	strcmp (e->format, "LiteralData") == 0)
	1233	{
	1234	datatype = 1;
	1235	nc4 = xmlNewNode (NULL, BAD_CAST "UOMs");
	1236	nc5 = xmlNewNode (NULL, BAD_CAST "Default");
	1237	}
	1238	else if (strcmp (e->format, "BoundingBoxOutput") == 0 \|\|
	1239	strcmp (e->format, "BoundingBoxData") == 0)
	1240	{
	1241	datatype = 2;
	1242	nc5 = xmlNewNode (NULL, BAD_CAST "Default");
	1243	}
	1244	else
	1245	{
	1246	nc4 = xmlNewNode (NULL, BAD_CAST "Default");
	1247	nc5 = xmlNewNode (NULL, BAD_CAST "Format");
	1248	}
[459]	1249
[531]	1250	tmp1 = _tmp->content;
[465]	1251
[531]	1252	if ((tmp1 = getMap (_tmp->content, "DataType")) != NULL)
	1253	{
	1254	nc8 = xmlNewNode (ns_ows, BAD_CAST "DataType");
	1255	xmlAddChild (nc8, xmlNewText (BAD_CAST tmp1->value));
	1256	char tmp[1024];
	1257	sprintf (tmp, "http://www.w3.org/TR/xmlschema-2/#%s",
	1258	tmp1->value);
	1259	xmlNewNsProp (nc8, ns_ows, BAD_CAST "reference", BAD_CAST tmp);
	1260	xmlAddChild (nc3, nc8);
	1261	datatype = 1;
	1262	}
[465]	1263
[531]	1264	if (strncmp (type, "Input", 5) == 0)
	1265	{
	1266
	1267	if ((tmp1 = getMap (_tmp->content, "AllowedValues")) != NULL)
	1268	{
	1269	nc6 = xmlNewNode (ns_ows, BAD_CAST "AllowedValues");
	1270	char token, saveptr1;
	1271	token = strtok_r (tmp1->value, ",", &saveptr1);
	1272	while (token != NULL)
	1273	{
	1274	nc7 = xmlNewNode (ns_ows, BAD_CAST "Value");
	1275	char *tmps = strdup (token);
	1276	tmps[strlen (tmps)] = 0;
	1277	xmlAddChild (nc7, xmlNewText (BAD_CAST tmps));
	1278	free (tmps);
	1279	xmlAddChild (nc6, nc7);
	1280	token = strtok_r (NULL, ",", &saveptr1);
	1281	}
	1282	if (getMap (_tmp->content, "range") != NULL \|\|
	1283	getMap (_tmp->content, "rangeMin") != NULL \|\|
	1284	getMap (_tmp->content, "rangeMax") != NULL \|\|
	1285	getMap (_tmp->content, "rangeClosure") != NULL)
	1286	goto doRange;
	1287	xmlAddChild (nc3, nc6);
	1288	isAnyValue = -1;
	1289	}
	1290
	1291	tmp1 = getMap (_tmp->content, "range");
	1292	if (tmp1 == NULL)
	1293	tmp1 = getMap (_tmp->content, "rangeMin");
	1294	if (tmp1 == NULL)
	1295	tmp1 = getMap (_tmp->content, "rangeMax");
	1296
	1297	if (tmp1 != NULL && isAnyValue == 1)
	1298	{
	1299	nc6 = xmlNewNode (ns_ows, BAD_CAST "AllowedValues");
	1300	doRange:
	1301
	1302	/**
[471]	1303	* Range: Table 46 OGC Web Services Common Standard
	1304	*/
[531]	1305	nc8 = xmlNewNode (ns_ows, BAD_CAST "Range");
	1306
	1307	map *tmp0 = getMap (tmp1, "range");
	1308	if (tmp0 != NULL)
	1309	{
	1310	char *pToken;
	1311	char *orig = zStrdup (tmp0->value);
	1312	/**
[471]	1313	* RangeClosure: Table 47 OGC Web Services Common Standard
	1314	*/
[531]	1315	const char *tmp = "closed";
	1316	if (orig[0] == '[' && orig[strlen (orig) - 1] == '[')
	1317	tmp = "closed-open";
	1318	else
	1319	if (orig[0] == ']' && orig[strlen (orig) - 1] == ']')
	1320	tmp = "open-closed";
	1321	else
	1322	if (orig[0] == ']' && orig[strlen (orig) - 1] == '[')
	1323	tmp = "open";
	1324	xmlNewNsProp (nc8, ns_ows, BAD_CAST "rangeClosure",
	1325	BAD_CAST tmp);
	1326	pToken = strtok (orig, ",");
	1327	int nci0 = 0;
	1328	while (pToken != NULL)
	1329	{
	1330	char *tmpStr =
	1331	(char ) malloc ((strlen (pToken))
	1332	sizeof (char));
	1333	if (nci0 == 0)
	1334	{
	1335	nc7 =
	1336	xmlNewNode (ns_ows, BAD_CAST "MinimumValue");
	1337	int nci = 1;
	1338	for (nci = 1; nci < strlen (pToken); nci++)
	1339	{
	1340	tmpStr[nci - 1] = pToken[nci];
	1341	}
	1342	}
	1343	else
	1344	{
	1345	nc7 =
	1346	xmlNewNode (ns_ows, BAD_CAST "MaximumValue");
	1347	int nci = 0;
	1348	for (nci = 0; nci < strlen (pToken) - 1; nci++)
	1349	{
	1350	tmpStr[nci] = pToken[nci];
	1351	}
	1352	}
	1353	xmlAddChild (nc7, xmlNewText (BAD_CAST tmpStr));
	1354	free (tmpStr);
	1355	xmlAddChild (nc8, nc7);
	1356	nci0++;
	1357	pToken = strtok (NULL, ",");
	1358	}
	1359	if (getMap (tmp1, "rangeSpacing") == NULL)
	1360	{
	1361	nc7 = xmlNewNode (ns_ows, BAD_CAST "Spacing");
	1362	xmlAddChild (nc7, xmlNewText (BAD_CAST "1"));
	1363	xmlAddChild (nc8, nc7);
	1364	}
	1365	free (orig);
	1366	}
	1367	else
	1368	{
	1369
	1370	tmp0 = getMap (tmp1, "rangeMin");
	1371	if (tmp0 != NULL)
	1372	{
	1373	nc7 = xmlNewNode (ns_ows, BAD_CAST "MinimumValue");
	1374	xmlAddChild (nc7,
	1375	xmlNewText (BAD_CAST tmp0->value));
	1376	xmlAddChild (nc8, nc7);
	1377	}
	1378	else
	1379	{
	1380	nc7 = xmlNewNode (ns_ows, BAD_CAST "MinimumValue");
	1381	xmlAddChild (nc8, nc7);
	1382	}
	1383	tmp0 = getMap (tmp1, "rangeMax");
	1384	if (tmp0 != NULL)
	1385	{
	1386	nc7 = xmlNewNode (ns_ows, BAD_CAST "MaximumValue");
	1387	xmlAddChild (nc7,
	1388	xmlNewText (BAD_CAST tmp0->value));
	1389	xmlAddChild (nc8, nc7);
	1390	}
	1391	else
	1392	{
	1393	nc7 = xmlNewNode (ns_ows, BAD_CAST "MaximumValue");
	1394	xmlAddChild (nc8, nc7);
	1395	}
	1396	tmp0 = getMap (tmp1, "rangeSpacing");
	1397	if (tmp0 != NULL)
	1398	{
	1399	nc7 = xmlNewNode (ns_ows, BAD_CAST "Spacing");
	1400	xmlAddChild (nc7,
	1401	xmlNewText (BAD_CAST tmp0->value));
	1402	xmlAddChild (nc8, nc7);
	1403	}
	1404	tmp0 = getMap (tmp1, "rangeClosure");
	1405	if (tmp0 != NULL)
	1406	{
	1407	const char *tmp = "closed";
	1408	if (strcasecmp (tmp0->value, "co") == 0)
	1409	tmp = "closed-open";
	1410	else if (strcasecmp (tmp0->value, "oc") == 0)
	1411	tmp = "open-closed";
	1412	else if (strcasecmp (tmp0->value, "o") == 0)
	1413	tmp = "open";
	1414	xmlNewNsProp (nc8, ns_ows, BAD_CAST "rangeClosure",
	1415	BAD_CAST tmp);
	1416	}
	1417	else
	1418	xmlNewNsProp (nc8, ns_ows, BAD_CAST "rangeClosure",
	1419	BAD_CAST "closed");
	1420	}
	1421	if (_tmp0 == NULL)
	1422	{
	1423	xmlAddChild (nc6, nc8);
	1424	_tmp0 = e->supported;
	1425	if (getMap (_tmp0->content, "range") != NULL \|\|
	1426	getMap (_tmp0->content, "rangeMin") != NULL \|\|
	1427	getMap (_tmp0->content, "rangeMax") != NULL \|\|
	1428	getMap (_tmp0->content, "rangeClosure") != NULL)
	1429	{
	1430	tmp1 = _tmp0->content;
	1431	goto doRange;
	1432	}
	1433	}
	1434	else
	1435	{
	1436	_tmp0 = _tmp0->next;
	1437	if (_tmp0 != NULL)
	1438	{
	1439	xmlAddChild (nc6, nc8);
	1440	if (getMap (_tmp0->content, "range") != NULL \|\|
	1441	getMap (_tmp0->content, "rangeMin") != NULL \|\|
	1442	getMap (_tmp0->content, "rangeMax") != NULL \|\|
	1443	getMap (_tmp0->content, "rangeClosure") != NULL)
	1444	{
	1445	tmp1 = _tmp0->content;
	1446	goto doRange;
	1447	}
	1448	}
	1449	}
	1450	xmlAddChild (nc6, nc8);
	1451	xmlAddChild (nc3, nc6);
	1452	isAnyValue = -1;
	1453	}
	1454
	1455	}
	1456
	1457
	1458	int oI = 0;
	1459	for (oI = 0; oI < 13; oI++)
	1460	if ((tmp1 = getMap (_tmp->content, orderedFields[oI])) != NULL)
	1461	{
[471]	1462	#ifdef DEBUG
[531]	1463	printf ("DATATYPE DEFAULT ? %s\n", tmp1->name);
[471]	1464	#endif
[531]	1465	if (strcmp (tmp1->name, "asReference") != 0 &&
	1466	strncasecmp (tmp1->name, "DataType", 8) != 0 &&
	1467	strcasecmp (tmp1->name, "extension") != 0 &&
	1468	strcasecmp (tmp1->name, "value") != 0 &&
	1469	strcasecmp (tmp1->name, "AllowedValues") != 0 &&
	1470	strncasecmp (tmp1->name, "range", 5) != 0)
	1471	{
	1472	if (datatype != 1)
	1473	{
	1474	char *tmp2 = zCapitalize1 (tmp1->name);
	1475	nc9 = xmlNewNode (NULL, BAD_CAST tmp2);
	1476	free (tmp2);
	1477	}
	1478	else
	1479	{
	1480	char *tmp2 = zCapitalize (tmp1->name);
	1481	nc9 = xmlNewNode (ns_ows, BAD_CAST tmp2);
	1482	free (tmp2);
	1483	}
	1484	xmlAddChild (nc9, xmlNewText (BAD_CAST tmp1->value));
	1485	xmlAddChild (nc5, nc9);
	1486	if (strcasecmp (tmp1->name, "uom") == 0)
	1487	hasUOM1 = true;
	1488	hasUOM = true;
	1489	}
	1490	else
[471]	1491
[531]	1492	tmp1 = tmp1->next;
	1493	}
[465]	1494
[471]	1495
[531]	1496	if (datatype != 2)
	1497	{
	1498	if (hasUOM == true)
	1499	{
	1500	xmlAddChild (nc4, nc5);
	1501	xmlAddChild (nc3, nc4);
	1502	}
	1503	else
	1504	{
	1505	if (hasUOM1 == false)
	1506	{
	1507	xmlFreeNode (nc5);
	1508	if (datatype == 1)
	1509	xmlFreeNode (nc4);
	1510	}
	1511	}
	1512	}
	1513	else
	1514	{
	1515	xmlAddChild (nc3, nc5);
	1516	}
[280]	1517
[531]	1518	if (datatype != 1 && default1 < 0)
	1519	{
	1520	xmlFreeNode (nc5);
	1521	if (datatype != 2)
	1522	xmlFreeNode (nc4);
	1523	}
[280]	1524
[531]	1525	map *metadata = e->metadata;
	1526	xmlNodePtr n = NULL;
	1527	int xlinkId =
	1528	zooXmlAddNs (n, "http://www.w3.org/1999/xlink", "xlink");
	1529	xmlNsPtr ns_xlink = usedNs[xlinkId];
[471]	1530
[531]	1531	while (metadata != NULL)
	1532	{
	1533	nc6 = xmlNewNode (ns_ows, BAD_CAST "Metadata");
	1534	xmlNewNsProp (nc6, ns_xlink, BAD_CAST metadata->name,
	1535	BAD_CAST metadata->value);
	1536	xmlAddChild (nc2, nc6);
	1537	metadata = metadata->next;
	1538	}
	1539
	1540	}
	1541
	1542	_tmp = e->supported;
	1543	if (_tmp == NULL && datatype != 1)
	1544	_tmp = e->defaults;
	1545
	1546	int hasSupported = -1;
	1547
	1548	while (_tmp != NULL)
	1549	{
	1550	if (hasSupported < 0)
	1551	{
	1552	if (datatype == 0)
	1553	{
	1554	nc4 = xmlNewNode (NULL, BAD_CAST "Supported");
	1555	nc5 = xmlNewNode (NULL, BAD_CAST "Format");
	1556	}
	1557	else
	1558	nc5 = xmlNewNode (NULL, BAD_CAST "Supported");
	1559	hasSupported = 0;
	1560	}
	1561	else if (datatype == 0)
	1562	nc5 = xmlNewNode (NULL, BAD_CAST "Format");
	1563	tmp1 = _tmp->content;
	1564	int oI = 0;
	1565	for (oI = 0; oI < 6; oI++)
	1566	if ((tmp1 = getMap (_tmp->content, orderedFields[oI])) != NULL)
	1567	{
[1]	1568	#ifdef DEBUG
[531]	1569	printf ("DATATYPE SUPPORTED ? %s\n", tmp1->name);
[1]	1570	#endif
[531]	1571	if (strcmp (tmp1->name, "asReference") != 0 &&
	1572	strcmp (tmp1->name, "value") != 0 &&
	1573	strcmp (tmp1->name, "DataType") != 0 &&
	1574	strcasecmp (tmp1->name, "extension") != 0)
	1575	{
	1576	if (datatype != 1)
	1577	{
	1578	char *tmp2 = zCapitalize1 (tmp1->name);
	1579	nc6 = xmlNewNode (NULL, BAD_CAST tmp2);
	1580	free (tmp2);
	1581	}
	1582	else
	1583	{
	1584	char *tmp2 = zCapitalize (tmp1->name);
	1585	nc6 = xmlNewNode (ns_ows, BAD_CAST tmp2);
	1586	free (tmp2);
	1587	}
	1588	if (datatype == 2)
	1589	{
	1590	char tmpv, tmps;
	1591	tmps = strtok_r (tmp1->value, ",", &tmpv);
	1592	while (tmps)
	1593	{
	1594	xmlAddChild (nc6, xmlNewText (BAD_CAST tmps));
	1595	tmps = strtok_r (NULL, ",", &tmpv);
	1596	if (tmps)
	1597	{
	1598	char *tmp2 = zCapitalize1 (tmp1->name);
	1599	nc6 = xmlNewNode (NULL, BAD_CAST tmp2);
	1600	free (tmp2);
	1601	}
	1602	}
	1603	}
	1604	else
	1605	{
	1606	xmlAddChild (nc6, xmlNewText (BAD_CAST tmp1->value));
	1607	}
	1608	xmlAddChild (nc5, nc6);
	1609	}
	1610	tmp1 = tmp1->next;
	1611	}
	1612	if (hasSupported <= 0)
	1613	{
	1614	if (datatype == 0)
	1615	{
	1616	xmlAddChild (nc4, nc5);
	1617	xmlAddChild (nc3, nc4);
	1618	}
	1619	else
	1620	{
	1621	if (datatype != 1)
	1622	xmlAddChild (nc3, nc5);
	1623	}
	1624	hasSupported = 1;
	1625	}
	1626	else if (datatype == 0)
	1627	{
	1628	xmlAddChild (nc4, nc5);
	1629	xmlAddChild (nc3, nc4);
	1630	}
	1631	else if (datatype != 1)
	1632	xmlAddChild (nc3, nc5);
[471]	1633
[531]	1634	_tmp = _tmp->next;
	1635	}
[471]	1636
[531]	1637	if (hasSupported == 0)
	1638	{
	1639	if (datatype == 0)
	1640	xmlFreeNode (nc4);
	1641	xmlFreeNode (nc5);
	1642	}
[471]	1643
[531]	1644	_tmp = e->defaults;
	1645	if (datatype == 1 && hasUOM1 == true)
	1646	{
	1647	xmlAddChild (nc4, nc5);
	1648	xmlAddChild (nc3, nc4);
	1649	}
[471]	1650
[531]	1651	if (in > 0 && datatype == 1 &&
	1652	getMap (_tmp->content, "AllowedValues") == NULL &&
	1653	getMap (_tmp->content, "range") == NULL &&
	1654	getMap (_tmp->content, "rangeMin") == NULL &&
	1655	getMap (_tmp->content, "rangeMax") == NULL &&
	1656	getMap (_tmp->content, "rangeClosure") == NULL)
	1657	{
	1658	tmp1 = getMap (_tmp->content, "dataType");
	1659	if (tmp1 != NULL)
	1660	if (strcasecmp (tmp1->value, "boolean") == 0)
	1661	{
	1662	nc6 = xmlNewNode (ns_ows, BAD_CAST "AllowedValues");
	1663	nc7 = xmlNewNode (ns_ows, BAD_CAST "Value");
	1664	xmlAddChild (nc7, xmlNewText (BAD_CAST "true"));
	1665	xmlAddChild (nc6, nc7);
	1666	nc7 = xmlNewNode (ns_ows, BAD_CAST "Value");
	1667	xmlAddChild (nc7, xmlNewText (BAD_CAST "false"));
	1668	xmlAddChild (nc6, nc7);
	1669	xmlAddChild (nc3, nc6);
	1670	}
	1671	xmlAddChild (nc3, xmlNewNode (ns_ows, BAD_CAST "AnyValue"));
	1672	}
	1673
	1674	if ((tmp1 = getMap (_tmp->content, "value")) != NULL)
	1675	{
	1676	nc7 = xmlNewNode (NULL, BAD_CAST "DefaultValue");
	1677	xmlAddChild (nc7, xmlNewText (BAD_CAST tmp1->value));
	1678	xmlAddChild (nc3, nc7);
	1679	}
	1680
	1681	xmlAddChild (nc2, nc3);
	1682
	1683	xmlAddChild (nc1, nc2);
	1684
	1685	e = e->next;
[471]	1686	}
[1]	1687	}
	1688
[531]	1689	void
	1690	printProcessResponse (maps * m, map * request, int pid, service * serv,
	1691	const char service, int status, maps inputs,
[549]	1692	maps * outputs, FCGX_Stream* out)
[531]	1693	{
	1694	xmlNsPtr ns, ns_ows, ns_xlink, ns_xsi;
	1695	xmlNodePtr nr, n, nc, nc1 = NULL, nc3;
[9]	1696	xmlDocPtr doc;
[531]	1697	time_t time1;
	1698	time (&time1);
	1699	nr = NULL;
[9]	1700	/**
	1701	* Create the document and its temporary root.
	1702	*/
[531]	1703	doc = xmlNewDoc (BAD_CAST "1.0");
	1704	int wpsId = zooXmlAddNs (NULL, "http://www.opengis.net/wps/1.0.0", "wps");
	1705	ns = usedNs[wpsId];
[280]	1706
[531]	1707	n = xmlNewNode (ns, BAD_CAST "ExecuteResponse");
	1708	xmlNewNs (n, BAD_CAST "http://www.opengis.net/wps/1.0.0", BAD_CAST "wps");
	1709	int owsId = zooXmlAddNs (n, "http://www.opengis.net/ows/1.1", "ows");
	1710	ns_ows = usedNs[owsId];
	1711	int xlinkId = zooXmlAddNs (n, "http://www.w3.org/1999/xlink", "xlink");
	1712	ns_xlink = usedNs[xlinkId];
	1713	int xsiId =
	1714	zooXmlAddNs (n, "http://www.w3.org/2001/XMLSchema-instance", "xsi");
	1715	ns_xsi = usedNs[xsiId];
[34]	1716
[531]	1717	xmlNewNsProp (n, ns_xsi, BAD_CAST "schemaLocation",
	1718	BAD_CAST
	1719	"http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsExecute_response.xsd");
	1720
	1721	xmlNewProp (n, BAD_CAST "service", BAD_CAST "WPS");
	1722	xmlNewProp (n, BAD_CAST "version", BAD_CAST "1.0.0");
	1723	addLangAttr (n, m);
	1724
[9]	1725	char tmp[256];
[26]	1726	char url[1024];
[72]	1727	char stored_path[1024];
[531]	1728	memset (tmp, 0, 256);
	1729	memset (url, 0, 1024);
	1730	memset (stored_path, 0, 1024);
	1731	maps *tmp_maps = getMaps (m, "main");
	1732	if (tmp_maps != NULL)
	1733	{
	1734	map *tmpm1 = getMap (tmp_maps->content, "serverAddress");
[26]	1735	/**
	1736	* Check if the ZOO Service GetStatus is available in the local directory.
	1737	* If yes, then it uses a reference to an URL which the client can access
	1738	* to get information on the status of a running Service (using the
	1739	* percentCompleted attribute).
	1740	* Else fallback to the initial method using the xml file to write in ...
	1741	*/
[531]	1742	char ntmp[1024];
[26]	1743	#ifndef WIN32
[531]	1744	getcwd (ntmp, 1024);
[26]	1745	#else
[531]	1746	_getcwd (ntmp, 1024);
[26]	1747	#endif
[531]	1748	struct stat myFileInfo;
	1749	int statRes;
	1750	char file_path[1024];
	1751	sprintf (file_path, "%s/GetStatus.zcfg", ntmp);
	1752	statRes = stat (file_path, &myFileInfo);
	1753	if (statRes == 0)
	1754	{
	1755	char currentSid[128];
	1756	map *tmpm = getMap (tmp_maps->content, "rewriteUrl");
	1757	map *tmp_lenv = NULL;
	1758	tmp_lenv = getMapFromMaps (m, "lenv", "sid");
	1759	if (tmp_lenv == NULL)
	1760	sprintf (currentSid, "%i", pid);
	1761	else
	1762	sprintf (currentSid, "%s", tmp_lenv->value);
	1763	if (tmpm == NULL \|\| strcasecmp (tmpm->value, "false") == 0)
	1764	{
	1765	sprintf (url,
	1766	"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",
	1767	tmpm1->value, currentSid);
	1768	}
	1769	else
	1770	{
	1771	if (strlen (tmpm->value) > 0)
	1772	if (strcasecmp (tmpm->value, "true") != 0)
	1773	sprintf (url, "%s/%s/GetStatus/%s", tmpm1->value,
	1774	tmpm->value, currentSid);
	1775	else
	1776	sprintf (url, "%s/GetStatus/%s", tmpm1->value, currentSid);
	1777	else
	1778	sprintf (url,
	1779	"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",
	1780	tmpm1->value, currentSid);
	1781	}
	1782	}
[26]	1783	else
[531]	1784	{
	1785	map *tmpm2 = getMap (tmp_maps->content, "tmpUrl");
	1786	if (tmpm1 != NULL && tmpm2 != NULL)
	1787	{
	1788	if (strncasecmp (tmpm2->value, "http://", 7) == 0 \|\|
	1789	strncasecmp (tmpm2->value, "https://", 8) == 0)
	1790	{
	1791	sprintf (url, "%s/%s_%i.xml", tmpm2->value, service, pid);
	1792	}
	1793	else
	1794	sprintf (url, "%s/%s/%s_%i.xml", tmpm1->value, tmpm2->value,
	1795	service, pid);
	1796	}
	1797	}
	1798	if (tmpm1 != NULL)
	1799	sprintf (tmp, "%s", tmpm1->value);
	1800	tmpm1 = getMapFromMaps (m, "main", "TmpPath");
	1801	sprintf (stored_path, "%s/%s_%i.xml", tmpm1->value, service, pid);
[9]	1802	}
	1803
[72]	1804
[364]	1805
[531]	1806	xmlNewProp (n, BAD_CAST "serviceInstance", BAD_CAST tmp);
	1807	map *test = getMap (request, "storeExecuteResponse");
	1808	bool hasStoredExecuteResponse = false;
	1809	if (test != NULL && strcasecmp (test->value, "true") == 0)
	1810	{
	1811	xmlNewProp (n, BAD_CAST "statusLocation", BAD_CAST url);
	1812	hasStoredExecuteResponse = true;
	1813	}
[9]	1814
[531]	1815	nc = xmlNewNode (ns, BAD_CAST "Process");
	1816	map *tmp2 = getMap (serv->content, "processVersion");
	1817	if (tmp2 != NULL)
	1818	xmlNewNsProp (nc, ns, BAD_CAST "processVersion", BAD_CAST tmp2->value);
[9]	1819
[531]	1820	printDescription (nc, ns_ows, serv->name, serv->content);
[9]	1821
[531]	1822	xmlAddChild (n, nc);
	1823
	1824	nc = xmlNewNode (ns, BAD_CAST "Status");
[9]	1825	const struct tm *tm;
	1826	size_t len;
	1827	time_t now;
	1828	char *tmp1;
[26]	1829	map *tmpStatus;
[9]	1830
[531]	1831	now = time (NULL);
	1832	tm = localtime (&now);
[9]	1833
[531]	1834	tmp1 = (char ) malloc ((TIME_SIZE + 1) sizeof (char));
[9]	1835
[531]	1836	len = strftime (tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm);
[26]	1837
[531]	1838	xmlNewProp (nc, BAD_CAST "creationTime", BAD_CAST tmp1);
	1839
[26]	1840	char sMsg[2048];
[531]	1841	switch (status)
	1842	{
	1843	case SERVICE_SUCCEEDED:
	1844	nc1 = xmlNewNode (ns, BAD_CAST "ProcessSucceeded");
	1845	sprintf (sMsg, _("Service \"%s\" run successfully."), serv->name);
	1846	nc3 = xmlNewText (BAD_CAST sMsg);
	1847	xmlAddChild (nc1, nc3);
	1848	break;
	1849	case SERVICE_STARTED:
	1850	nc1 = xmlNewNode (ns, BAD_CAST "ProcessStarted");
	1851	tmpStatus = getMapFromMaps (m, "lenv", "status");
	1852	xmlNewProp (nc1, BAD_CAST "percentCompleted",
	1853	BAD_CAST tmpStatus->value);
	1854	sprintf (sMsg,
	1855	_
	1856	("ZOO Service \"%s\" is currently running. Please, reload this document to get the up-to-date status of the Service."),
	1857	serv->name);
	1858	nc3 = xmlNewText (BAD_CAST sMsg);
	1859	xmlAddChild (nc1, nc3);
	1860	break;
	1861	case SERVICE_ACCEPTED:
	1862	nc1 = xmlNewNode (ns, BAD_CAST "ProcessAccepted");
	1863	sprintf (sMsg,
	1864	_
	1865	("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."),
	1866	serv->name);
	1867	nc3 = xmlNewText (BAD_CAST sMsg);
	1868	xmlAddChild (nc1, nc3);
	1869	break;
	1870	case SERVICE_FAILED:
	1871	nc1 = xmlNewNode (ns, BAD_CAST "ProcessFailed");
	1872	map *errorMap;
	1873	map *te;
	1874	te = getMapFromMaps (m, "lenv", "code");
	1875	if (te != NULL)
	1876	errorMap = createMap ("code", te->value);
	1877	else
	1878	errorMap = createMap ("code", "NoApplicableCode");
	1879	te = getMapFromMaps (m, "lenv", "message");
	1880	if (te != NULL)
	1881	addToMap (errorMap, "text", _ss (te->value));
	1882	else
	1883	addToMap (errorMap, "text", _("No more information available"));
	1884	nc3 = createExceptionReportNode (m, errorMap, 0);
	1885	freeMap (&errorMap);
	1886	free (errorMap);
	1887	xmlAddChild (nc1, nc3);
	1888	break;
	1889	default:
	1890	printf (_("error code not know : %i\n"), status);
	1891	//exit(1);
	1892	break;
	1893	}
	1894	xmlAddChild (nc, nc1);
	1895	xmlAddChild (n, nc);
	1896	free (tmp1);
[9]	1897
	1898	#ifdef DEBUG
[531]	1899	fprintf (stderr, "printProcessResponse 1 161\n");
[9]	1900	#endif
	1901
[531]	1902	map *lineage = getMap (request, "lineage");
	1903	if (lineage != NULL && strcasecmp (lineage->value, "true") == 0)
	1904	{
	1905	nc = xmlNewNode (ns, BAD_CAST "DataInputs");
	1906	maps *mcursor = inputs;
	1907	elements *scursor = NULL;
	1908	while (mcursor != NULL /&& scursor!=NULL / )
	1909	{
	1910	scursor = getElements (serv->inputs, mcursor->name);
	1911	printIOType (doc, nc, ns, ns_ows, ns_xlink, scursor, mcursor,
	1912	"Input");
	1913	mcursor = mcursor->next;
	1914	}
	1915	xmlAddChild (n, nc);
	1916
[9]	1917	#ifdef DEBUG
[531]	1918	fprintf (stderr, "printProcessResponse 1 177\n");
[9]	1919	#endif
	1920
[531]	1921	nc = xmlNewNode (ns, BAD_CAST "OutputDefinitions");
	1922	mcursor = outputs;
	1923	scursor = NULL;
	1924	while (mcursor != NULL)
	1925	{
	1926	scursor = getElements (serv->outputs, mcursor->name);
	1927	printOutputDefinitions1 (doc, nc, ns, ns_ows, scursor, mcursor,
	1928	"Output");
	1929	mcursor = mcursor->next;
	1930	}
	1931	xmlAddChild (n, nc);
[9]	1932	}
	1933	#ifdef DEBUG
[531]	1934	fprintf (stderr, "printProcessResponse 1 190\n");
[9]	1935	#endif
	1936
	1937	/**
	1938	* Display the process output only when requested !
	1939	*/
[531]	1940	if (status == SERVICE_SUCCEEDED)
	1941	{
	1942	nc = xmlNewNode (ns, BAD_CAST "ProcessOutputs");
	1943	maps *mcursor = outputs;
	1944	elements *scursor = serv->outputs;
	1945	map *testResponse = getMap (request, "RawDataOutput");
	1946	if (testResponse == NULL)
	1947	testResponse = getMap (request, "ResponseDocument");
	1948	while (mcursor != NULL)
	1949	{
	1950	map *tmp0 = getMap (mcursor->content, "inRequest");
	1951	scursor = getElements (serv->outputs, mcursor->name);
	1952	if (scursor != NULL)
	1953	{
	1954	if (testResponse == NULL \|\| tmp0 == NULL)
	1955	printIOType (doc, nc, ns, ns_ows, ns_xlink, scursor, mcursor,
	1956	"Output");
	1957	else if (tmp0 != NULL && strncmp (tmp0->value, "true", 4) == 0)
	1958	printIOType (doc, nc, ns, ns_ows, ns_xlink, scursor, mcursor,
	1959	"Output");
	1960	}
	1961	else
	1962	/**
[449]	1963	* In case there was no definition found in the ZCFG file but
	1964	* present in the service code
	1965	*/
[531]	1966	printIOType (doc, nc, ns, ns_ows, ns_xlink, scursor, mcursor,
	1967	"Output");
	1968	mcursor = mcursor->next;
	1969	}
	1970	xmlAddChild (n, nc);
[9]	1971	}
[364]	1972
[9]	1973	#ifdef DEBUG
[531]	1974	fprintf (stderr, "printProcessResponse 1 202\n");
[9]	1975	#endif
[531]	1976	nr = soapEnvelope (m, n);
	1977	xmlDocSetRootElement (doc, nr);
[280]	1978
[617]	1979
	1980	map * background = NULL;
	1981	background = getMapFromMaps(m,"lenv","background");
	1982
	1983	if (background != NULL){
	1984	/* requete asynchrone */
[531]	1985	/* We need to write the ExecuteResponse Document somewhere */
	1986	FILE *output = fopen (stored_path, "w");
	1987	if (output == NULL)
	1988	{
	1989	/* If the file cannot be created return an ExceptionReport */
	1990	char tmpMsg[1024];
	1991	sprintf (tmpMsg,
	1992	_
	1993	("Unable to create the file : \"%s\" for storing the ExecuteResponse."),
	1994	stored_path);
	1995	map *errormap = createMap ("text", tmpMsg);
	1996	addToMap (errormap, "code", "InternalError");
[549]	1997	printExceptionReportResponse (m, errormap,out);
[531]	1998	freeMap (&errormap);
	1999	free (errormap);
	2000	xmlFreeDoc (doc);
	2001	xmlCleanupParser ();
	2002	zooXmlCleanupNs ();
	2003	return;
	2004	}
	2005	xmlChar *xmlbuff;
	2006	int buffersize;
	2007	xmlDocDumpFormatMemoryEnc (doc, &xmlbuff, &buffersize, "UTF-8", 1);
	2008	fwrite (xmlbuff, 1, xmlStrlen (xmlbuff) * sizeof (char), output);
	2009	xmlFree (xmlbuff);
	2010	fclose (output);
[393]	2011	}
[617]	2012	else {
[549]	2013	printDocument (m, doc, pid,out);
[617]	2014	}
[531]	2015	xmlCleanupParser ();
	2016	zooXmlCleanupNs ();
[9]	2017	}
	2018
	2019
[531]	2020	void
[549]	2021	printDocument (maps * m, xmlDocPtr doc, int pid,FCGX_Stream * out)
[531]	2022	{
	2023	char *encoding = getEncoding (m);
	2024	if (pid == getpid ())
	2025	{
[549]	2026	printHeaders (m,out);
	2027	FCGX_FPrintF(out,"Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
	2028	//printf ("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
[531]	2029	}
[549]	2030	//fflush (stdout);
[9]	2031	xmlChar *xmlbuff;
	2032	int buffersize;
[1]	2033	/*
[9]	2034	* Dump the document to a buffer and print it on stdout
[1]	2035	* for demonstration purposes.
	2036	*/
[531]	2037	xmlDocDumpFormatMemoryEnc (doc, &xmlbuff, &buffersize, encoding, 1);
[617]	2038
	2039
	2040	if (out != NULL){
	2041	FCGX_FPrintF(out,(char *)xmlbuff);
	2042	FCGX_FFlush(out);
	2043	}
[549]	2044	//printf ("%s", xmlbuff);
	2045	//fflush (stdout);
[1]	2046	/*
	2047	* Free associated memory.
	2048	*/
[531]	2049	xmlFree (xmlbuff);
	2050	xmlFreeDoc (doc);
	2051	xmlCleanupParser ();
	2052	zooXmlCleanupNs ();
[1]	2053	}
	2054
[531]	2055	void
	2056	printOutputDefinitions1 (xmlDocPtr doc, xmlNodePtr nc, xmlNsPtr ns_wps,
	2057	xmlNsPtr ns_ows, elements * e, maps * m,
	2058	const char *type)
	2059	{
[1]	2060	xmlNodePtr nc1;
[531]	2061	nc1 = xmlNewNode (ns_wps, BAD_CAST type);
	2062	map *tmp = NULL;
	2063	if (e != NULL && e->defaults != NULL)
	2064	tmp = e->defaults->content;
	2065	else
	2066	{
	2067	/*
	2068	dumpElements(e);
	2069	*/
	2070	return;
	2071	}
	2072	while (tmp != NULL)
	2073	{
	2074	if (strncasecmp (tmp->name, "MIMETYPE", strlen (tmp->name)) == 0
	2075	\|\| strncasecmp (tmp->name, "ENCODING", strlen (tmp->name)) == 0
	2076	\|\| strncasecmp (tmp->name, "SCHEMA", strlen (tmp->name)) == 0
	2077	\|\| strncasecmp (tmp->name, "UOM", strlen (tmp->name)) == 0)
	2078	xmlNewProp (nc1, BAD_CAST tmp->name, BAD_CAST tmp->value);
	2079	tmp = tmp->next;
	2080	}
	2081	tmp = getMap (e->defaults->content, "asReference");
	2082	if (tmp == NULL)
	2083	xmlNewProp (nc1, BAD_CAST "asReference", BAD_CAST "false");
[1]	2084
[531]	2085	tmp = e->content;
[1]	2086
[531]	2087	printDescription (nc1, ns_ows, m->name, e->content);
[1]	2088
[531]	2089	xmlAddChild (nc, nc1);
[1]	2090
	2091	}
	2092
[531]	2093	void
	2094	printOutputDefinitions (xmlDocPtr doc, xmlNodePtr nc, xmlNsPtr ns_wps,
	2095	xmlNsPtr ns_ows, elements * e, map * m,
	2096	const char *type)
	2097	{
[490]	2098	xmlNodePtr nc1;
[531]	2099	nc1 = xmlNewNode (ns_wps, BAD_CAST type);
	2100	map *tmp = NULL;
	2101	if (e != NULL && e->defaults != NULL)
	2102	tmp = e->defaults->content;
	2103	else
	2104	{
	2105	/*
	2106	dumpElements(e);
	2107	*/
	2108	return;
	2109	}
	2110	while (tmp != NULL)
	2111	{
	2112	xmlNewProp (nc1, BAD_CAST tmp->name, BAD_CAST tmp->value);
	2113	tmp = tmp->next;
	2114	}
	2115	tmp = getMap (e->defaults->content, "asReference");
	2116	if (tmp == NULL)
	2117	xmlNewProp (nc1, BAD_CAST "asReference", BAD_CAST "false");
[1]	2118
[531]	2119	tmp = e->content;
[1]	2120
[531]	2121	printDescription (nc1, ns_ows, m->name, e->content);
[1]	2122
[531]	2123	xmlAddChild (nc, nc1);
[1]	2124
	2125	}
	2126
[531]	2127	void
	2128	printIOType (xmlDocPtr doc, xmlNodePtr nc, xmlNsPtr ns_wps, xmlNsPtr ns_ows,
	2129	xmlNsPtr ns_xlink, elements * e, maps * m, const char *type)
	2130	{
	2131	xmlNodePtr nc1, nc2, nc3;
	2132	nc1 = xmlNewNode (ns_wps, BAD_CAST type);
	2133	map *tmp = NULL;
	2134	if (e != NULL)
	2135	tmp = e->content;
[65]	2136	else
[531]	2137	tmp = m->content;
[26]	2138	#ifdef DEBUG
[531]	2139	dumpMap (tmp);
	2140	dumpElements (e);
[26]	2141	#endif
[531]	2142	nc2 = xmlNewNode (ns_ows, BAD_CAST "Identifier");
	2143	if (e != NULL)
	2144	nc3 = xmlNewText (BAD_CAST e->name);
[65]	2145	else
[531]	2146	nc3 = xmlNewText (BAD_CAST m->name);
	2147	xmlAddChild (nc2, nc3);
	2148	xmlAddChild (nc1, nc2);
	2149	xmlAddChild (nc, nc1);
	2150	if (e != NULL)
	2151	tmp = getMap (e->content, "Title");
[65]	2152	else
[531]	2153	tmp = getMap (m->content, "Title");
[65]	2154
[531]	2155	if (tmp != NULL)
	2156	{
	2157	nc2 = xmlNewNode (ns_ows, BAD_CAST tmp->name);
	2158	nc3 = xmlNewText (BAD_CAST _ss (tmp->value));
	2159	xmlAddChild (nc2, nc3);
	2160	xmlAddChild (nc1, nc2);
	2161	}
	2162
	2163	if (e != NULL)
	2164	tmp = getMap (e->content, "Abstract");
[65]	2165	else
[531]	2166	tmp = getMap (m->content, "Abstract");
	2167	if (tmp != NULL)
	2168	{
	2169	nc2 = xmlNewNode (ns_ows, BAD_CAST tmp->name);
	2170	nc3 = xmlNewText (BAD_CAST _ss (tmp->value));
	2171	xmlAddChild (nc2, nc3);
	2172	xmlAddChild (nc1, nc2);
	2173	xmlAddChild (nc, nc1);
	2174	}
[1]	2175
	2176	/**
	2177	* IO type Reference or full Data ?
	2178	*/
[26]	2179	#ifdef DEBUG
[531]	2180	fprintf (stderr, "FORMAT %s %s\n", e->format, e->format);
[26]	2181	#endif
[531]	2182	map *tmpMap = getMap (m->content, "Reference");
	2183	if (tmpMap == NULL)
	2184	{
	2185	nc2 = xmlNewNode (ns_wps, BAD_CAST "Data");
	2186	if (e != NULL)
	2187	{
	2188	if (strncasecmp (e->format, "LiteralOutput", strlen (e->format)) ==
	2189	0)
	2190	nc3 = xmlNewNode (ns_wps, BAD_CAST "LiteralData");
	2191	else
	2192	if (strncasecmp (e->format, "ComplexOutput", strlen (e->format))
	2193	== 0)
	2194	nc3 = xmlNewNode (ns_wps, BAD_CAST "ComplexData");
	2195	else
	2196	if (strncasecmp
	2197	(e->format, "BoundingBoxOutput", strlen (e->format)) == 0)
	2198	nc3 = xmlNewNode (ns_wps, BAD_CAST "BoundingBoxData");
	2199	else
	2200	nc3 = xmlNewNode (ns_wps, BAD_CAST e->format);
	2201	}
[9]	2202	else
[531]	2203	{
	2204	map *tmpV = getMapFromMaps (m, "format", "value");
	2205	if (tmpV != NULL)
	2206	nc3 = xmlNewNode (ns_wps, BAD_CAST tmpV->value);
	2207	else
	2208	nc3 = xmlNewNode (ns_wps, BAD_CAST "LitteralData");
	2209	}
	2210	tmp = m->content;
[297]	2211	#ifdef USE_MS
[531]	2212	map *testMap = getMap (tmp, "requestedMimeType");
[297]	2213	#endif
[531]	2214	while (tmp != NULL)
	2215	{
	2216	if (strcasecmp (tmp->name, "mimeType") == 0 \|\|
	2217	strcasecmp (tmp->name, "encoding") == 0 \|\|
	2218	strcasecmp (tmp->name, "schema") == 0 \|\|
	2219	strcasecmp (tmp->name, "datatype") == 0 \|\|
	2220	strcasecmp (tmp->name, "uom") == 0)
	2221	{
[297]	2222	#ifdef USE_MS
[531]	2223	if (testMap == NULL
	2224	\|\| (testMap != NULL
	2225	&& strncasecmp (testMap->value, "text/xml", 8) == 0))
	2226	{
[297]	2227	#endif
[531]	2228	xmlNewProp (nc3, BAD_CAST tmp->name, BAD_CAST tmp->value);
[297]	2229	#ifdef USE_MS
[531]	2230	}
	2231	else if (strcasecmp (tmp->name, "mimeType") == 0)
	2232	{
	2233	if (testMap != NULL)
	2234	xmlNewProp (nc3, BAD_CAST tmp->name,
	2235	BAD_CAST testMap->value);
	2236	else
	2237	xmlNewProp (nc3, BAD_CAST tmp->name, BAD_CAST tmp->value);
	2238	}
[297]	2239	#endif
[531]	2240	}
	2241	tmp = tmp->next;
	2242	xmlAddChild (nc2, nc3);
	2243	}
	2244	if (e != NULL && e->format != NULL
	2245	&& strcasecmp (e->format, "BoundingBoxData") == 0)
	2246	{
	2247	map *bb = getMap (m->content, "value");
	2248	if (bb != NULL)
	2249	{
	2250	map *tmpRes = parseBoundingBox (bb->value);
	2251	printBoundingBox (ns_ows, nc3, tmpRes);
	2252	freeMap (&tmpRes);
	2253	free (tmpRes);
	2254	}
	2255	}
[76]	2256	else
[531]	2257	{
	2258	if (e != NULL)
	2259	tmp = getMap (e->defaults->content, "mimeType");
	2260	else
	2261	tmp = NULL;
[297]	2262	#ifdef USE_MS
	2263	/**
	2264	* In case of OGC WebServices output use, as the data was requested
	2265	* with asReference=false we have to download the resulting OWS request
	2266	* stored in the Reference map value.
	2267	*/
[531]	2268	map *testMap = getMap (m->content, "requestedMimeType");
	2269	if (testMap != NULL)
	2270	{
	2271	HINTERNET hInternet;
	2272	char *tmpValue;
	2273	size_t dwRead;
	2274	hInternet = InternetOpen (
[297]	2275	#ifndef WIN32
[531]	2276	(LPCTSTR)
[297]	2277	#endif
[531]	2278	"ZooWPSClient\0",
	2279	INTERNET_OPEN_TYPE_PRECONFIG,
	2280	NULL, NULL, 0);
	2281	testMap = getMap (m->content, "Reference");
	2282	loadRemoteFile (&m, &m->content, &hInternet, testMap->value);
	2283	processDownloads (&hInternet);
	2284	tmpValue =
	2285	(char ) malloc ((hInternet.ihandle[0].nDataLen + 1)
	2286	sizeof (char));
	2287	InternetReadFile (hInternet.ihandle[0], (LPVOID) tmpValue,
	2288	hInternet.ihandle[0].nDataLen, &dwRead);
	2289	InternetCloseHandle (&hInternet);
	2290	}
[297]	2291	#endif
[531]	2292	map *tmp1 = getMap (m->content, "encoding");
	2293	map *tmp2 = getMap (m->content, "mimeType");
	2294	map *tmp3 = getMap (m->content, "value");
	2295	int hasValue = 1;
	2296	if (tmp3 == NULL)
	2297	{
	2298	tmp3 = createMap ("value", "");
	2299	hasValue = -1;
	2300	}
	2301	if ((tmp1 != NULL && strncmp (tmp1->value, "base64", 6) == 0)
	2302	\|\| (tmp2 != NULL && (strncmp (tmp2->value, "image/", 6) == 0 \|\|
	2303	(strncmp (tmp2->value, "application/", 12)
	2304	== 0
	2305	&& strncmp (tmp2->value,
	2306	"application/json", 16) != 0
	2307	&& strncmp (tmp2->value,
	2308	"application/x-javascript",
	2309	24) != 0
	2310	&& strncmp (tmp2->value,
	2311	"application/vnd.google-earth.kml",
	2312	32) != 0))))
	2313	{
	2314	map *rs = getMap (m->content, "size");
	2315	bool isSized = true;
	2316	if (rs == NULL)
	2317	{
	2318	char tmp1[1024];
	2319	sprintf (tmp1, "%u", strlen (tmp3->value));
	2320	rs = createMap ("size", tmp1);
	2321	isSized = false;
	2322	}
[94]	2323
[531]	2324	xmlAddChild (nc3,
	2325	xmlNewText (BAD_CAST
	2326	base64 (tmp3->value,
	2327	atoi (rs->value))));
	2328	if (tmp1 == NULL
	2329	\|\| (tmp1 != NULL
	2330	&& strncmp (tmp1->value, "base64", 6) != 0))
	2331	xmlNewProp (nc3, BAD_CAST "encoding", BAD_CAST "base64");
	2332	if (!isSized)
	2333	{
	2334	freeMap (&rs);
	2335	free (rs);
	2336	}
	2337	}
	2338	else if (tmp2 != NULL)
	2339	{
	2340	if (strncmp (tmp2->value, "text/js", 7) == 0 \|\|
	2341	strncmp (tmp2->value, "application/json", 16) == 0)
	2342	xmlAddChild (nc3,
	2343	xmlNewCDataBlock (doc, BAD_CAST tmp3->value,
	2344	strlen (tmp3->value)));
	2345	else
	2346	{
	2347	if (strncmp (tmp2->value, "text/xml", 8) == 0 \|\|
	2348	strncmp (tmp2->value,
	2349	"application/vnd.google-earth.kml", 32) == 0)
	2350	{
	2351	int li = zooXmlAddDoc (tmp3->value);
	2352	xmlDocPtr doc = iDocs[li];
	2353	xmlNodePtr ir = xmlDocGetRootElement (doc);
	2354	xmlAddChild (nc3, ir);
	2355	}
	2356	else
	2357	xmlAddChild (nc3, xmlNewText (BAD_CAST tmp3->value));
	2358	}
	2359	xmlAddChild (nc2, nc3);
	2360	}
	2361	else
	2362	{
	2363	xmlAddChild (nc3, xmlNewText (BAD_CAST tmp3->value));
	2364	}
	2365	if (hasValue < 0)
	2366	{
	2367	freeMap (&tmp3);
	2368	free (tmp3);
	2369	}
	2370	}
[9]	2371	}
[531]	2372	else
	2373	{
	2374	tmpMap = getMap (m->content, "Reference");
	2375	nc3 = nc2 = xmlNewNode (ns_wps, BAD_CAST "Reference");
	2376	if (strcasecmp (type, "Output") == 0)
	2377	xmlNewProp (nc3, BAD_CAST "href", BAD_CAST tmpMap->value);
	2378	else
	2379	xmlNewNsProp (nc3, ns_xlink, BAD_CAST "href", BAD_CAST tmpMap->value);
	2380	tmp = m->content;
[297]	2381	#ifdef USE_MS
[531]	2382	map *testMap = getMap (tmp, "requestedMimeType");
[297]	2383	#endif
[531]	2384	while (tmp != NULL)
	2385	{
	2386	if (strcasecmp (tmp->name, "mimeType") == 0 \|\|
	2387	strcasecmp (tmp->name, "encoding") == 0 \|\|
	2388	strcasecmp (tmp->name, "schema") == 0 \|\|
	2389	strcasecmp (tmp->name, "datatype") == 0 \|\|
	2390	strcasecmp (tmp->name, "uom") == 0)
	2391	{
[297]	2392	#ifdef USE_MS
[531]	2393	if (testMap != NULL
	2394	&& strncasecmp (testMap->value, "text/xml", 8) != 0)
	2395	{
	2396	if (strcasecmp (tmp->name, "mimeType") == 0)
	2397	xmlNewProp (nc3, BAD_CAST tmp->name,
	2398	BAD_CAST testMap->value);
	2399	}
	2400	else
[297]	2401	#endif
[531]	2402	if (strcasecmp (tmp->name, "datatype") == 0)
	2403	xmlNewProp (nc3, BAD_CAST "mimeType", BAD_CAST "text/plain");
	2404	else
	2405	xmlNewProp (nc3, BAD_CAST tmp->name, BAD_CAST tmp->value);
	2406	}
	2407	tmp = tmp->next;
	2408	xmlAddChild (nc2, nc3);
	2409	}
[9]	2410	}
[531]	2411	xmlAddChild (nc1, nc2);
	2412	xmlAddChild (nc, nc1);
[1]	2413
	2414	}
	2415
[531]	2416	void
	2417	printDescription (xmlNodePtr root, xmlNsPtr ns_ows, const char *identifier,
	2418	map * amap)
	2419	{
	2420	xmlNodePtr nc2 = xmlNewNode (ns_ows, BAD_CAST "Identifier");
	2421
	2422	xmlAddChild (nc2, xmlNewText (BAD_CAST identifier));
	2423	xmlAddChild (root, nc2);
	2424	map *tmp = amap;
[490]	2425	const char *tmp2[2];
[531]	2426	tmp2[0] = "Title";
	2427	tmp2[1] = "Abstract";
	2428	int j = 0;
	2429	for (j = 0; j < 2; j++)
	2430	{
	2431	map *tmp1 = getMap (tmp, tmp2[j]);
	2432	if (tmp1 != NULL)
	2433	{
	2434	nc2 = xmlNewNode (ns_ows, BAD_CAST tmp2[j]);
	2435	xmlAddChild (nc2, xmlNewText (BAD_CAST _ss (tmp1->value)));
	2436	xmlAddChild (root, nc2);
	2437	}
[1]	2438	}
	2439	}
	2440
[531]	2441	char *
	2442	getEncoding (maps * m)
	2443	{
	2444	if (m != NULL)
	2445	{
	2446	map *tmp = getMap (m->content, "encoding");
	2447	if (tmp != NULL)
	2448	{
	2449	return tmp->value;
	2450	}
	2451	else
	2452	return (char *) "UTF-8";
[1]	2453	}
	2454	else
[531]	2455	return (char *) "UTF-8";
[9]	2456	}
[1]	2457
[531]	2458	char *
	2459	getVersion (maps * m)
	2460	{
	2461	if (m != NULL)
	2462	{
	2463	map *tmp = getMap (m->content, "version");
	2464	if (tmp != NULL)
	2465	{
	2466	return tmp->value;
	2467	}
	2468	else
	2469	return (char *) "1.0.0";
[1]	2470	}
	2471	else
[531]	2472	return (char *) "1.0.0";
[9]	2473	}
[1]	2474
[531]	2475	void
[549]	2476	printExceptionReportResponse (maps * m, map * s,FCGX_Stream * out)
[531]	2477	{
	2478	if (getMapFromMaps (m, "lenv", "hasPrinted") != NULL)
[469]	2479	return;
[9]	2480	int buffersize;
	2481	xmlDocPtr doc;
	2482	xmlChar *xmlbuff;
[34]	2483	xmlNodePtr n;
[1]	2484
[531]	2485	zooXmlCleanupNs ();
	2486	doc = xmlNewDoc (BAD_CAST "1.0");
	2487	maps *tmpMap = getMaps (m, "main");
	2488	char *encoding = getEncoding (tmpMap);
[490]	2489	const char *exceptionCode;
[531]	2490
	2491	map *tmp = getMap (s, "code");
	2492	if (tmp != NULL)
	2493	{
	2494	if (strcmp (tmp->value, "OperationNotSupported") == 0)
	2495	exceptionCode = "501 Not Implemented";
[459]	2496	else
[531]	2497	if (strcmp (tmp->value, "MissingParameterValue") == 0 \|\|
	2498	strcmp (tmp->value, "InvalidUpdateSequence") == 0 \|\|
	2499	strcmp (tmp->value, "OptionNotSupported") == 0 \|\|
	2500	strcmp (tmp->value, "VersionNegotiationFailed") == 0 \|\|
	2501	strcmp (tmp->value, "InvalidParameterValue") == 0)
	2502	exceptionCode = "400 Bad request";
	2503	else if (strcmp (tmp->value, "NoApplicableCode") == 0)
	2504	exceptionCode = "501 Internal Server Error";
	2505	else
	2506	exceptionCode = "501 Internal Server Error";
	2507	}
[459]	2508	else
[531]	2509	exceptionCode = "501 Internal Server Error";
[459]	2510
[531]	2511	if (m != NULL)
	2512	{
	2513	map *tmpSid = getMapFromMaps (m, "lenv", "sid");
	2514	if (tmpSid != NULL)
	2515	{
	2516	if (getpid () == atoi (tmpSid->value))
	2517	{
[549]	2518	printHeaders (m,out);
	2519	FCGX_FPrintF(out,"Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding, exceptionCode);
	2520	//printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding, exceptionCode);
[531]	2521	}
	2522	}
	2523	else
	2524	{
[549]	2525	printHeaders (m,out);
	2526	FCGX_FPrintF(out,"Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",
	2527	encoding, exceptionCode);
	2528	//printf ("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding, exceptionCode);
[531]	2529	}
[32]	2530	}
[531]	2531	else
[549]	2532	{
	2533	FCGX_FPrintF(out,"Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding, exceptionCode);
	2534	//printf ("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding, exceptionCode);
[384]	2535	}
[531]	2536	n = createExceptionReportNode (m, s, 1);
	2537	xmlDocSetRootElement (doc, n);
	2538	xmlDocDumpFormatMemoryEnc (doc, &xmlbuff, &buffersize, encoding, 1);
[549]	2539	//printf ("%s", xmlbuff);
	2540	FCGX_FPrintF(out,"%s",xmlbuff);
	2541	FCGX_FFlush(out);
	2542	//fflush (stdout);
[531]	2543	xmlFreeDoc (doc);
	2544	xmlFree (xmlbuff);
	2545	xmlCleanupParser ();
	2546	zooXmlCleanupNs ();
	2547	if (m != NULL)
	2548	setMapInMaps (m, "lenv", "hasPrinted", "true");
[1]	2549	}
	2550
[531]	2551	xmlNodePtr
	2552	createExceptionReportNode (maps * m, map * s, int use_ns)
	2553	{
[1]	2554
[531]	2555	xmlNsPtr ns, ns_xsi;
	2556	xmlNodePtr n, nc, nc1;
[481]	2557
[531]	2558	int nsid = zooXmlAddNs (NULL, "http://www.opengis.net/ows", "ows");
	2559	ns = usedNs[nsid];
	2560	if (use_ns == 1)
	2561	{
	2562	ns = NULL;
	2563	}
	2564	n = xmlNewNode (ns, BAD_CAST "ExceptionReport");
	2565	if (use_ns == 1)
	2566	{
	2567	xmlNewNs (n, BAD_CAST "http://www.opengis.net/ows/1.1", NULL);
	2568	int xsiId =
	2569	zooXmlAddNs (n, "http://www.w3.org/2001/XMLSchema-instance", "xsi");
	2570	ns_xsi = usedNs[xsiId];
	2571	xmlNewNsProp (n, ns_xsi, BAD_CAST "schemaLocation",
	2572	BAD_CAST
	2573	"http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsExceptionReport.xsd");
	2574	}
[481]	2575
[26]	2576
[531]	2577	addLangAttr (n, m);
	2578	xmlNewProp (n, BAD_CAST "version", BAD_CAST "1.1.0");
	2579
	2580	nc = xmlNewNode (ns, BAD_CAST "Exception");
	2581
	2582	map *tmp = getMap (s, "code");
	2583	if (tmp != NULL)
	2584	xmlNewProp (nc, BAD_CAST "exceptionCode", BAD_CAST tmp->value);
[26]	2585	else
[531]	2586	xmlNewProp (nc, BAD_CAST "exceptionCode", BAD_CAST "NoApplicableCode");
[26]	2587
[531]	2588	tmp = getMap (s, "locator");
	2589	if (tmp != NULL && strcasecmp (tmp->value, "NULL") != 0)
	2590	xmlNewProp (nc, BAD_CAST "locator", BAD_CAST tmp->value);
[459]	2591
	2592
[531]	2593	tmp = getMap (s, "text");
	2594	nc1 = xmlNewNode (ns, BAD_CAST "ExceptionText");
	2595	if (tmp != NULL)
	2596	{
	2597	xmlNodeSetContent (nc1, BAD_CAST tmp->value);
	2598	}
	2599	else
	2600	{
	2601	xmlNodeSetContent (nc1, BAD_CAST _("No debug message available"));
	2602	}
	2603	xmlAddChild (nc, nc1);
	2604	xmlAddChild (n, nc);
[26]	2605	return n;
	2606	}
	2607
	2608
[531]	2609	void
	2610	outputResponse (service * s, maps * request_inputs, maps * request_outputs,
[549]	2611	map * request_inputs1, int cpid, maps * m, int res,FCGX_Stream out,FCGX_Stream err)
[531]	2612	{
[549]	2613
	2614
[1]	2615	#ifdef DEBUG
[531]	2616	dumpMaps (request_inputs);
	2617	dumpMaps (request_outputs);
	2618	fprintf (stderr, "printProcessResponse\n");
[1]	2619	#endif
[531]	2620	map *toto = getMap (request_inputs1, "RawDataOutput");
	2621	int asRaw = 0;
	2622	if (toto != NULL)
	2623	asRaw = 1;
	2624
	2625	maps *tmpSess = getMaps (m, "senv");
	2626	if (tmpSess != NULL)
	2627	{
	2628	map *_tmp = getMapFromMaps (m, "lenv", "cookie");
	2629	char *sessId = NULL;
	2630	if (_tmp != NULL)
	2631	{
	2632	printf ("Set-Cookie: %s; HttpOnly\r\n", _tmp->value);
	2633	printf
	2634	("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
	2635	char session_file_path[100];
	2636	char *tmp1 = strtok (_tmp->value, ";");
	2637	if (tmp1 != NULL)
	2638	sprintf (session_file_path, "%s", strstr (tmp1, "=") + 1);
	2639	else
	2640	sprintf (session_file_path, "%s", strstr (_tmp->value, "=") + 1);
	2641	sessId = strdup (session_file_path);
	2642	}
[92]	2643	else
[531]	2644	{
	2645	maps *t = getMaps (m, "senv");
	2646	map *p = t->content;
	2647	while (p != NULL)
	2648	{
	2649	if (strstr (p->name, "ID") != NULL)
	2650	{
	2651	sessId = strdup (p->value);
	2652	break;
	2653	}
	2654	p = p->next;
	2655	}
	2656	}
	2657	char session_file_path[1024];
	2658	map *tmpPath = getMapFromMaps (m, "main", "sessPath");
	2659	if (tmpPath == NULL)
	2660	tmpPath = getMapFromMaps (m, "main", "tmpPath");
	2661	sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value, sessId);
	2662	FILE *teste = fopen (session_file_path, "w");
	2663	if (teste == NULL)
	2664	{
	2665	char tmpMsg[1024];
	2666	sprintf (tmpMsg,
	2667	_
	2668	("Unable to create the file : \"%s\" for storing the session maps."),
	2669	session_file_path);
	2670	map *errormap = createMap ("text", tmpMsg);
	2671	addToMap (errormap, "code", "InternalError");
	2672
[549]	2673	printExceptionReportResponse (m, errormap,out);
[531]	2674	freeMap (&errormap);
	2675	free (errormap);
	2676	return;
	2677	}
	2678	else
	2679	{
	2680	fclose (teste);
	2681	dumpMapsToFile (tmpSess, session_file_path);
	2682	}
[92]	2683	}
[453]	2684
[531]	2685
	2686	if (asRaw == 0)
	2687	{
[549]	2688
	2689
[9]	2690	#ifdef DEBUG
[531]	2691	fprintf (stderr, "REQUEST_OUTPUTS FINAL\n");
	2692	dumpMaps (request_outputs);
[9]	2693	#endif
[531]	2694	maps *tmpI = request_outputs;
	2695	while (tmpI != NULL)
	2696	{
[297]	2697	#ifdef USE_MS
[531]	2698	map *testMap = getMap (tmpI->content, "useMapserver");
[297]	2699	#endif
[531]	2700	toto = getMap (tmpI->content, "asReference");
[297]	2701	#ifdef USE_MS
[531]	2702	if (toto != NULL && strcasecmp (toto->value, "true") == 0
	2703	&& testMap == NULL)
[297]	2704	#else
[531]	2705	if (toto != NULL && strcasecmp (toto->value, "true") == 0)
[297]	2706	#endif
[531]	2707	{
	2708	elements *in = getElements (s->outputs, tmpI->name);
	2709	char *format = NULL;
	2710	if (in != NULL)
	2711	{
	2712	format = strdup (in->format);
	2713	}
	2714	else
	2715	format = strdup ("LiteralData");
	2716	if (strcasecmp (format, "BoundingBoxData") == 0)
	2717	{
	2718	addToMap (tmpI->content, "extension", "xml");
	2719	addToMap (tmpI->content, "mimeType", "text/xml");
	2720	addToMap (tmpI->content, "encoding", "UTF-8");
	2721	addToMap (tmpI->content, "schema",
	2722	"http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
	2723	}
	2724	map *ext = getMap (tmpI->content, "extension");
	2725	map *tmp1 = getMapFromMaps (m, "main", "tmpPath");
	2726	char file_name, file_path;
	2727	bool hasExt = true;
	2728	if (ext == NULL)
	2729	{
	2730	// We can fallback to a default list of supported formats using
	2731	// mimeType information if present here. Maybe we can add more formats
	2732	// here.
	2733	// If mimeType was not found, we then set txt as the default extension
	2734	map *mtype = getMap (tmpI->content, "mimeType");
	2735	if (mtype != NULL)
	2736	{
	2737	if (strcasecmp (mtype->value, "text/xml") == 0)
	2738	ext = createMap ("extension", "xml");
	2739	else if (strcasecmp (mtype->value, "application/json")
	2740	== 0)
	2741	ext = createMap ("extension", "js");
	2742	else
	2743	if (strncmp
	2744	(mtype->value, "application/vnd.google-earth.kml",
	2745	32) == 0)
	2746	ext = createMap ("extension", "kml");
	2747	else if (strncmp (mtype->value, "image/", 6) == 0)
	2748	ext =
	2749	createMap ("extension",
	2750	strstr (mtype->value, "/") + 1);
	2751	else
	2752	ext = createMap ("extension", "txt");
	2753	}
	2754	else
	2755	ext = createMap ("extension", "txt");
	2756	hasExt = false;
	2757	}
	2758	file_name =
	2759	(char *)
	2760	malloc ((strlen (s->name) + strlen (ext->value) +
	2761	strlen (tmpI->name) + 1024) * sizeof (char));
	2762	int cpid0 = cpid + time (NULL);
	2763	sprintf (file_name, "%s_%s_%i.%s", s->name, tmpI->name, cpid0,
	2764	ext->value);
	2765	file_path =
	2766	(char *)
	2767	malloc ((strlen (tmp1->value) + strlen (file_name) +
	2768	2) * sizeof (char));
	2769	sprintf (file_path, "%s/%s", tmp1->value, file_name);
	2770	FILE *ofile = fopen (file_path, "wb");
	2771	if (ofile == NULL)
	2772	{
	2773	char tmpMsg[1024];
	2774	sprintf (tmpMsg,
	2775	_
	2776	("Unable to create the file : \"%s\" for storing the %s final result."),
	2777	file_name, tmpI->name);
	2778	map *errormap = createMap ("text", tmpMsg);
	2779	addToMap (errormap, "code", "InternalError");
[549]	2780
	2781	printExceptionReportResponse (m, errormap,out);
[531]	2782	freeMap (&errormap);
	2783	free (errormap);
	2784	free (file_name);
	2785	free (file_path);
	2786	return;
	2787	}
	2788	free (file_path);
	2789	map *tmp2 = getMapFromMaps (m, "main", "tmpUrl");
	2790	map *tmp3 = getMapFromMaps (m, "main", "serverAddress");
	2791	char *file_url;
	2792	if (strncasecmp (tmp2->value, "http://", 7) == 0 \|\|
	2793	strncasecmp (tmp2->value, "https://", 8) == 0)
	2794	{
	2795	file_url =
	2796	(char *)
	2797	malloc ((strlen (tmp2->value) + strlen (file_name) +
	2798	2) * sizeof (char));
	2799	sprintf (file_url, "%s/%s", tmp2->value, file_name);
	2800	}
	2801	else
	2802	{
	2803	file_url =
	2804	(char *)
	2805	malloc ((strlen (tmp3->value) + strlen (tmp2->value) +
	2806	strlen (file_name) + 3) * sizeof (char));
	2807	sprintf (file_url, "%s/%s/%s", tmp3->value, tmp2->value,
	2808	file_name);
	2809	}
	2810	addToMap (tmpI->content, "Reference", file_url);
	2811	if (!hasExt)
	2812	{
	2813	freeMap (&ext);
	2814	free (ext);
	2815	}
	2816	toto = getMap (tmpI->content, "value");
	2817	if (strcasecmp (format, "BoundingBoxData") != 0)
	2818	{
	2819	map *size = getMap (tmpI->content, "size");
	2820	if (size != NULL && toto != NULL)
	2821	fwrite (toto->value, 1,
	2822	atoi (size->value) * sizeof (char), ofile);
	2823	else if (toto != NULL && toto->value != NULL)
	2824	fwrite (toto->value, 1,
	2825	strlen (toto->value) * sizeof (char), ofile);
	2826	}
	2827	else
	2828	{
	2829	printBoundingBoxDocument (m, tmpI, ofile);
	2830	}
	2831	free (format);
	2832	fclose (ofile);
	2833	free (file_name);
	2834	free (file_url);
	2835	}
[297]	2836	#ifdef USE_MS
[531]	2837	else
	2838	{
	2839	if (testMap != NULL)
	2840	{
	2841	setReferenceUrl (m, tmpI);
	2842	}
	2843	}
[297]	2844	#endif
[531]	2845	tmpI = tmpI->next;
	2846	}
	2847	map *r_inputs = getMap (s->content, "serviceProvider");
[1]	2848	#ifdef DEBUG
[531]	2849	fprintf (stderr, "SERVICE : %s\n", r_inputs->value);
	2850	dumpMaps (m);
[1]	2851	#endif
[531]	2852	printProcessResponse (m, request_inputs1, cpid,
	2853	s, r_inputs->value, res,
[549]	2854	request_inputs, request_outputs,out);
[453]	2855	}
[531]	2856	else
	2857	{
[549]	2858
[531]	2859	if (res == SERVICE_FAILED)
	2860	{
[549]	2861
[531]	2862	map *errormap;
	2863	map *lenv;
	2864	lenv = getMapFromMaps (m, "lenv", "message");
	2865	char *tmp0;
	2866	if (lenv != NULL)
	2867	{
	2868	tmp0 =
	2869	(char *)
	2870	malloc ((strlen (lenv->value) +
	2871	strlen (_
	2872	("Unable to run the Service. The message returned back by the Service was the following: "))
	2873	+ 1) * sizeof (char));
	2874	sprintf (tmp0,
	2875	_
	2876	("Unable to run the Service. The message returned back by the Service was the following: %s"),
	2877	lenv->value);
	2878	}
	2879	else
	2880	{
	2881	tmp0 =
	2882	(char *)
	2883	malloc ((strlen
	2884	(_
	2885	("Unable to run the Service. No more information was returned back by the Service."))
	2886	+ 1) * sizeof (char));
	2887	sprintf (tmp0,
	2888	_
	2889	("Unable to run the Service. No more information was returned back by the Service."));
	2890	}
	2891	errormap = createMap ("text", tmp0);
	2892	free (tmp0);
	2893	addToMap (errormap, "code", "InternalError");
[549]	2894	printExceptionReportResponse (m, errormap,out);
[531]	2895	freeMap (&errormap);
	2896	free (errormap);
	2897	return;
	2898	}
[26]	2899	/**
[66]	2900	* We get the requested output or fallback to the first one if the
	2901	* requested one is not present in the resulting outputs maps.
[26]	2902	*/
[549]	2903
	2904
[531]	2905	maps *tmpI = NULL;
	2906	map *tmpIV = getMap (request_inputs1, "RawDataOutput");
	2907	if (tmpIV != NULL)
	2908	{
	2909	tmpI = getMaps (request_outputs, tmpIV->value);
	2910	}
	2911	if (tmpI == NULL)
	2912	tmpI = request_outputs;
	2913	elements *e = getElements (s->outputs, tmpI->name);
	2914	if (e != NULL && strcasecmp (e->format, "BoundingBoxData") == 0)
	2915	{
	2916	printBoundingBoxDocument (m, tmpI, NULL);
	2917	}
	2918	else
	2919	{
	2920	toto = getMap (tmpI->content, "value");
	2921	if (toto == NULL)
	2922	{
	2923	char tmpMsg[1024];
	2924	sprintf (tmpMsg,
	2925	_
	2926	("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),
	2927	tmpI->name);
	2928	map *errormap = createMap ("text", tmpMsg);
	2929	addToMap (errormap, "code", "InvalidParameterValue");
[549]	2930	printExceptionReportResponse (m, errormap,out);
[531]	2931	freeMap (&errormap);
	2932	free (errormap);
	2933	return;
	2934	}
	2935	map *fname = getMapFromMaps (tmpI, tmpI->name, "filename");
	2936	if (fname != NULL)
[549]	2937	FCGX_FPrintF(out,"Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
	2938	//printf ("Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
[531]	2939	map *rs = getMapFromMaps (tmpI, tmpI->name, "size");
	2940	if (rs != NULL)
[549]	2941	FCGX_FPrintF(out,"Content-Length: %s\r\n", rs->value);
	2942	//printf ("Content-Length: %s\r\n", rs->value);
	2943	printHeaders (m,out);
[531]	2944	char mime[1024];
	2945	map *mi = getMap (tmpI->content, "mimeType");
[1]	2946	#ifdef DEBUG
[531]	2947	fprintf (stderr, "SERVICE OUTPUTS\n");
	2948	dumpMaps (request_outputs);
	2949	fprintf (stderr, "SERVICE OUTPUTS\n");
[1]	2950	#endif
[531]	2951	map *en = getMap (tmpI->content, "encoding");
	2952	if (mi != NULL && en != NULL)
	2953	sprintf (mime,
	2954	"Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
	2955	mi->value, en->value);
	2956	else if (mi != NULL)
	2957	sprintf (mime,
	2958	"Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
	2959	mi->value);
	2960	else
	2961	sprintf (mime,
	2962	"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
[549]	2963	FCGX_FPrintF(out,"%s", mime);
	2964
	2965	//printf ("%s", mime);
[531]	2966	if (rs != NULL)
[549]	2967	FCGX_PutStr(toto->value,atoi(rs->value),out);
	2968	//fwrite (toto->value, 1, atoi (rs->value), stdout);
[531]	2969	else
[549]	2970	FCGX_PutStr(toto->value,strlen (toto->value),out);
	2971	//fwrite (toto->value, 1, strlen (toto->value), stdout);
	2972
	2973	FCGX_FFlush(out);
[1]	2974	#ifdef DEBUG
[531]	2975	dumpMap (toto);
[1]	2976	#endif
[531]	2977	}
[26]	2978	}
[1]	2979	}
	2980
[531]	2981	char *
	2982	base64 (const char *input, int length)
[1]	2983	{
	2984	BIO bmem, b64;
	2985	BUF_MEM *bptr;
	2986
[531]	2987	b64 = BIO_new (BIO_f_base64 ());
	2988	BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
	2989	bmem = BIO_new (BIO_s_mem ());
	2990	b64 = BIO_push (b64, bmem);
	2991	BIO_write (b64, input, length + 1);
	2992	BIO_flush (b64);
	2993	BIO_get_mem_ptr (b64, &bptr);
[1]	2994
[531]	2995	char buff = (char ) malloc ((bptr->length + 1) * sizeof (char));
	2996	memcpy (buff, bptr->data, bptr->length);
	2997	buff[bptr->length - 1] = 0;
[1]	2998
[531]	2999	BIO_free_all (b64);
[1]	3000
	3001	return buff;
	3002	}
	3003
[531]	3004	char *
	3005	base64d (const char input, int length, int red)
[88]	3006	{
	3007	BIO b64, bmem;
	3008
[531]	3009	char buffer = (char ) malloc (length);
	3010	if (buffer)
	3011	{
	3012	memset (buffer, 0, length);
	3013	b64 = BIO_new (BIO_f_base64 ());
	3014	if (b64)
	3015	{
	3016	bmem = BIO_new_mem_buf ((unsigned char *) input, length);
	3017	bmem = BIO_push (b64, bmem);
	3018	*red = BIO_read (bmem, buffer, length);
	3019	buffer[length - 1] = 0;
	3020	BIO_free_all (bmem);
	3021	}
[94]	3022	}
[88]	3023	return buffer;
	3024	}
	3025
[531]	3026	void
	3027	ensureDecodedBase64 (maps ** in)
	3028	{
	3029	maps cursor = in;
	3030	while (cursor != NULL)
	3031	{
	3032	map *tmp = getMap (cursor->content, "encoding");
	3033	if (tmp != NULL && strncasecmp (tmp->value, "base64", 6) == 0)
	3034	{
	3035	tmp = getMap (cursor->content, "value");
	3036	addToMap (cursor->content, "base64_value", tmp->value);
	3037	int size = 0;
	3038	char *s = strdup (tmp->value);
	3039	free (tmp->value);
	3040	tmp->value = base64d (s, strlen (s), &size);
	3041	free (s);
	3042	char sizes[1024];
	3043	sprintf (sizes, "%d", size);
	3044	addToMap (cursor->content, "size", sizes);
	3045	}
	3046	cursor = cursor->next;
[88]	3047	}
	3048	}
	3049
[531]	3050	char *
	3051	addDefaultValues (maps ** out, elements * in, maps * m, int type)
	3052	{
	3053	elements *tmpInputs = in;
	3054	maps out1 = out;
	3055	if (type == 1)
	3056	{
	3057	while (out1 != NULL)
	3058	{
	3059	if (getElements (in, out1->name) == NULL)
	3060	return out1->name;
	3061	out1 = out1->next;
	3062	}
	3063	out1 = *out;
[280]	3064	}
[531]	3065	while (tmpInputs != NULL)
	3066	{
	3067	maps *tmpMaps = getMaps (out1, tmpInputs->name);
	3068	if (tmpMaps == NULL)
	3069	{
	3070	maps tmpMaps2 = (maps ) malloc (MAPS_SIZE);
	3071	tmpMaps2->name = strdup (tmpInputs->name);
	3072	tmpMaps2->content = NULL;
	3073	tmpMaps2->next = NULL;
[63]	3074
[531]	3075	if (type == 0)
	3076	{
	3077	map *tmpMapMinO = getMap (tmpInputs->content, "minOccurs");
	3078	if (tmpMapMinO != NULL)
	3079	{
	3080	if (atoi (tmpMapMinO->value) >= 1)
	3081	{
	3082	freeMaps (&tmpMaps2);
	3083	free (tmpMaps2);
	3084	return tmpInputs->name;
	3085	}
	3086	else
	3087	{
	3088	if (tmpMaps2->content == NULL)
	3089	tmpMaps2->content =
	3090	createMap ("minOccurs", tmpMapMinO->value);
	3091	else
	3092	addToMap (tmpMaps2->content, "minOccurs",
	3093	tmpMapMinO->value);
	3094	}
	3095	}
	3096	map *tmpMaxO = getMap (tmpInputs->content, "maxOccurs");
	3097	if (tmpMaxO != NULL)
	3098	{
	3099	if (tmpMaps2->content == NULL)
	3100	tmpMaps2->content =
	3101	createMap ("maxOccurs", tmpMaxO->value);
	3102	else
	3103	addToMap (tmpMaps2->content, "maxOccurs", tmpMaxO->value);
	3104	}
	3105	map *tmpMaxMB = getMap (tmpInputs->content, "maximumMegabytes");
	3106	if (tmpMaxMB != NULL)
	3107	{
	3108	if (tmpMaps2->content == NULL)
	3109	tmpMaps2->content =
	3110	createMap ("maximumMegabytes", tmpMaxMB->value);
	3111	else
	3112	addToMap (tmpMaps2->content, "maximumMegabytes",
	3113	tmpMaxMB->value);
	3114	}
	3115	}
	3116
	3117	iotype *tmpIoType = tmpInputs->defaults;
	3118	if (tmpIoType != NULL)
	3119	{
	3120	map *tmpm = tmpIoType->content;
	3121	while (tmpm != NULL)
	3122	{
	3123	if (tmpMaps2->content == NULL)
	3124	tmpMaps2->content = createMap (tmpm->name, tmpm->value);
	3125	else
	3126	addToMap (tmpMaps2->content, tmpm->name, tmpm->value);
	3127	tmpm = tmpm->next;
	3128	}
	3129	}
	3130	addToMap (tmpMaps2->content, "inRequest", "false");
	3131	if (type == 0)
	3132	{
	3133	map *tmpMap = getMap (tmpMaps2->content, "value");
	3134	if (tmpMap == NULL)
	3135	addToMap (tmpMaps2->content, "value", "NULL");
	3136	}
	3137	if (out1 == NULL)
	3138	{
	3139	*out = dupMaps (&tmpMaps2);
	3140	out1 = *out;
	3141	}
	3142	else
	3143	addMapsToMaps (&out1, tmpMaps2);
	3144	freeMap (&tmpMaps2->content);
	3145	free (tmpMaps2->content);
	3146	tmpMaps2->content = NULL;
	3147	freeMaps (&tmpMaps2);
	3148	free (tmpMaps2);
	3149	tmpMaps2 = NULL;
	3150	}
[1]	3151	else
[531]	3152	{
	3153	iotype *tmpIoType =
	3154	getIoTypeFromElement (tmpInputs, tmpInputs->name,
	3155	tmpMaps->content);
	3156	if (type == 0)
	3157	{
	3158	/**
[76]	3159	* In case of an Input maps, then add the minOccurs and maxOccurs to the
	3160	* content map.
	3161	*/
[531]	3162	map *tmpMap1 = getMap (tmpInputs->content, "minOccurs");
	3163	if (tmpMap1 != NULL)
	3164	{
	3165	if (tmpMaps->content == NULL)
	3166	tmpMaps->content =
	3167	createMap ("minOccurs", tmpMap1->value);
	3168	else
	3169	addToMap (tmpMaps->content, "minOccurs", tmpMap1->value);
	3170	}
	3171	map *tmpMaxO = getMap (tmpInputs->content, "maxOccurs");
	3172	if (tmpMaxO != NULL)
	3173	{
	3174	if (tmpMaps->content == NULL)
	3175	tmpMaps->content =
	3176	createMap ("maxOccurs", tmpMaxO->value);
	3177	else
	3178	addToMap (tmpMaps->content, "maxOccurs", tmpMaxO->value);
	3179	}
	3180	map *tmpMaxMB = getMap (tmpInputs->content, "maximumMegabytes");
	3181	if (tmpMaxMB != NULL)
	3182	{
	3183	if (tmpMaps->content == NULL)
	3184	tmpMaps->content =
	3185	createMap ("maximumMegabytes", tmpMaxMB->value);
	3186	else
	3187	addToMap (tmpMaps->content, "maximumMegabytes",
	3188	tmpMaxMB->value);
	3189	}
	3190	/**
[76]	3191	* Parsing BoundingBoxData, fill the following map and then add it to
	3192	* the content map of the Input maps:
	3193	* lowerCorner, upperCorner, srs and dimensions
	3194	* cf. parseBoundingBox
	3195	*/
[531]	3196	if (strcasecmp (tmpInputs->format, "BoundingBoxData") == 0)
	3197	{
	3198	maps tmpI = getMaps (out, tmpInputs->name);
	3199	if (tmpI != NULL)
	3200	{
	3201	map *tmpV = getMap (tmpI->content, "value");
	3202	if (tmpV != NULL)
	3203	{
	3204	char *tmpVS = strdup (tmpV->value);
	3205	map *tmp = parseBoundingBox (tmpVS);
	3206	free (tmpVS);
	3207	map *tmpC = tmp;
	3208	while (tmpC != NULL)
	3209	{
	3210	addToMap (tmpMaps->content, tmpC->name,
	3211	tmpC->value);
	3212	tmpC = tmpC->next;
	3213	}
	3214	freeMap (&tmp);
	3215	free (tmp);
	3216	}
	3217	}
	3218	}
	3219	}
[63]	3220
[531]	3221	if (tmpIoType != NULL)
	3222	{
	3223	map *tmpContent = tmpIoType->content;
	3224	map *cval = NULL;
	3225	int hasPassed = -1;
	3226	while (tmpContent != NULL)
	3227	{
	3228	if ((cval =
	3229	getMap (tmpMaps->content, tmpContent->name)) == NULL)
	3230	{
[9]	3231	#ifdef DEBUG
[531]	3232	fprintf (stderr, "addDefaultValues %s => %s\n",
	3233	tmpContent->name, tmpContent->value);
[9]	3234	#endif
[531]	3235	if (tmpMaps->content == NULL)
	3236	tmpMaps->content =
	3237	createMap (tmpContent->name, tmpContent->value);
	3238	else
	3239	addToMap (tmpMaps->content, tmpContent->name,
	3240	tmpContent->value);
	3241
	3242	if (hasPassed < 0 && type == 0
	3243	&& getMap (tmpMaps->content, "isArray") != NULL)
	3244	{
	3245	map *length = getMap (tmpMaps->content, "length");
	3246	int i;
	3247	char *tcn = strdup (tmpContent->name);
	3248	for (i = 1; i < atoi (length->value); i++)
	3249	{
[364]	3250	#ifdef DEBUG
[531]	3251	dumpMap (tmpMaps->content);
	3252	fprintf (stderr,
	3253	"addDefaultValues %s_%d => %s\n", tcn,
	3254	i, tmpContent->value);
[364]	3255	#endif
[531]	3256	int len = strlen ((char *) tcn);
	3257	char *tmp1 =
	3258	(char ) malloc ((len + 10) sizeof (char));
	3259	sprintf (tmp1, "%s_%d", tcn, i);
[364]	3260	#ifdef DEBUG
[531]	3261	fprintf (stderr, "addDefaultValues %s => %s\n",
	3262	tmp1, tmpContent->value);
[364]	3263	#endif
[531]	3264	addToMap (tmpMaps->content, tmp1,
	3265	tmpContent->value);
	3266	free (tmp1);
	3267	hasPassed = 1;
	3268	}
	3269	free (tcn);
	3270	}
	3271	}
	3272	tmpContent = tmpContent->next;
	3273	}
[297]	3274	#ifdef USE_MS
[531]	3275	/**
[297]	3276	* check for useMapServer presence
	3277	*/
[531]	3278	map *tmpCheck = getMap (tmpIoType->content, "useMapServer");
	3279	if (tmpCheck != NULL)
	3280	{
	3281	// Get the default value
	3282	tmpIoType =
	3283	getIoTypeFromElement (tmpInputs, tmpInputs->name, NULL);
	3284	tmpCheck = getMap (tmpMaps->content, "mimeType");
	3285	addToMap (tmpMaps->content, "requestedMimeType",
	3286	tmpCheck->value);
	3287	map *cursor = tmpIoType->content;
	3288	while (cursor != NULL)
	3289	{
	3290	addToMap (tmpMaps->content, cursor->name,
	3291	cursor->value);
	3292	cursor = cursor->next;
	3293	}
	3294
	3295	cursor = tmpInputs->content;
	3296	while (cursor != NULL)
	3297	{
	3298	if (strcasecmp (cursor->name, "Title") == 0 \|\|
	3299	strcasecmp (cursor->name, "Abstract") == 0)
	3300	addToMap (tmpMaps->content, cursor->name,
	3301	cursor->value);
	3302	cursor = cursor->next;
	3303	}
	3304	}
[297]	3305	#endif
[531]	3306	}
	3307	if (tmpMaps->content == NULL)
	3308	tmpMaps->content = createMap ("inRequest", "true");
	3309	else
	3310	addToMap (tmpMaps->content, "inRequest", "true");
[280]	3311
[531]	3312	}
	3313	tmpInputs = tmpInputs->next;
[1]	3314	}
[9]	3315	return "";
[1]	3316	}
[76]	3317
	3318	/**
	3319	* parseBoundingBox : parse a BoundingBox string
	3320	*
	3321	* OGC 06-121r3 : 10.2 Bounding box
	3322	*
	3323	* value is provided as : lowerCorner,upperCorner,crs,dimension
	3324	* exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
	3325	*
	3326	* Need to create a map to store boundingbox informations :
	3327	* - lowerCorner : double,double (minimum within this bounding box)
	3328	* - upperCorner : double,double (maximum within this bounding box)
	3329	* - crs : URI (Reference to definition of the CRS)
	3330	* - dimensions : int
	3331	*
	3332	* Note : support only 2D bounding box.
	3333	*/
[531]	3334	map *
	3335	parseBoundingBox (const char *value)
	3336	{
	3337	map *res = NULL;
	3338	if (value != NULL)
	3339	{
	3340	char cv, cvp;
	3341	cv = strtok_r ((char *) value, ",", &cvp);
	3342	int cnt = 0;
	3343	int icnt = 0;
	3344	char *currentValue = NULL;
	3345	while (cv)
	3346	{
	3347	if (cnt < 2)
	3348	if (currentValue != NULL)
	3349	{
	3350	char *finalValue =
	3351	(char ) malloc ((strlen (currentValue) + strlen (cv) + 1)
	3352	sizeof (char));
	3353	sprintf (finalValue, "%s%s", currentValue, cv);
	3354	switch (cnt)
	3355	{
	3356	case 0:
	3357	res = createMap ("lowerCorner", finalValue);
	3358	break;
	3359	case 1:
	3360	addToMap (res, "upperCorner", finalValue);
	3361	icnt = -1;
	3362	break;
	3363	}
	3364	cnt++;
	3365	free (currentValue);
	3366	currentValue = NULL;
	3367	free (finalValue);
	3368	}
	3369	else
	3370	{
	3371	currentValue =
	3372	(char ) malloc ((strlen (cv) + 2) sizeof (char));
	3373	sprintf (currentValue, "%s ", cv);
	3374	}
	3375	else if (cnt == 2)
	3376	{
	3377	addToMap (res, "crs", cv);
	3378	cnt++;
	3379	}
	3380	else
	3381	addToMap (res, "dimensions", cv);
	3382	icnt++;
	3383	cv = strtok_r (NULL, ",", &cvp);
	3384	}
[76]	3385	}
	3386	return res;
	3387	}
	3388
	3389	/**
	3390	* printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
	3391	* wps:BoundingBoxData). Set crs and dimensions attributes, add
	3392	* Lower/UpperCorner nodes to a pre-existing XML node.
	3393	*/
[531]	3394	void
	3395	printBoundingBox (xmlNsPtr ns_ows, xmlNodePtr n, map * boundingbox)
	3396	{
[76]	3397
[531]	3398	xmlNodePtr lw = NULL, uc = NULL;
[76]	3399
[531]	3400	map *tmp = getMap (boundingbox, "value");
[76]	3401
[531]	3402	tmp = getMap (boundingbox, "lowerCorner");
	3403	if (tmp != NULL)
	3404	{
	3405	lw = xmlNewNode (ns_ows, BAD_CAST "LowerCorner");
	3406	xmlAddChild (lw, xmlNewText (BAD_CAST tmp->value));
	3407	}
[76]	3408
[531]	3409	tmp = getMap (boundingbox, "upperCorner");
	3410	if (tmp != NULL)
	3411	{
	3412	uc = xmlNewNode (ns_ows, BAD_CAST "UpperCorner");
	3413	xmlAddChild (uc, xmlNewText (BAD_CAST tmp->value));
	3414	}
[76]	3415
[531]	3416	tmp = getMap (boundingbox, "crs");
	3417	if (tmp != NULL)
	3418	xmlNewProp (n, BAD_CAST "crs", BAD_CAST tmp->value);
[76]	3419
[531]	3420	tmp = getMap (boundingbox, "dimensions");
	3421	if (tmp != NULL)
	3422	xmlNewProp (n, BAD_CAST "dimensions", BAD_CAST tmp->value);
[76]	3423
[531]	3424	xmlAddChild (n, lw);
	3425	xmlAddChild (n, uc);
[76]	3426
	3427	}
	3428
[531]	3429	void
	3430	printBoundingBoxDocument (maps * m, maps * boundingbox, FILE * file)
	3431	{
[549]	3432	//if (file == NULL)
	3433	// rewind (stdout);
[76]	3434	xmlNodePtr n;
	3435	xmlDocPtr doc;
[531]	3436	xmlNsPtr ns_ows, ns_xsi;
[76]	3437	xmlChar *xmlbuff;
	3438	int buffersize;
[531]	3439	char *encoding = getEncoding (m);
[76]	3440	map *tmp;
[531]	3441	if (file == NULL)
	3442	{
	3443	int pid = 0;
	3444	tmp = getMapFromMaps (m, "lenv", "sid");
	3445	if (tmp != NULL)
	3446	pid = atoi (tmp->value);
	3447	if (pid == getpid ())
	3448	{
	3449	printf
	3450	("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",
	3451	encoding);
	3452	}
[549]	3453	//fflush (stdout);
[76]	3454	}
	3455
[531]	3456	doc = xmlNewDoc (BAD_CAST "1.0");
	3457	int owsId = zooXmlAddNs (NULL, "http://www.opengis.net/ows/1.1", "ows");
	3458	ns_ows = usedNs[owsId];
	3459	n = xmlNewNode (ns_ows, BAD_CAST "BoundingBox");
	3460	xmlNewNs (n, BAD_CAST "http://www.opengis.net/ows/1.1", BAD_CAST "ows");
	3461	int xsiId =
	3462	zooXmlAddNs (n, "http://www.w3.org/2001/XMLSchema-instance", "xsi");
	3463	ns_xsi = usedNs[xsiId];
	3464	xmlNewNsProp (n, ns_xsi, BAD_CAST "schemaLocation",
	3465	BAD_CAST
	3466	"http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
	3467	map *tmp1 = getMap (boundingbox->content, "value");
	3468	tmp = parseBoundingBox (tmp1->value);
	3469	printBoundingBox (ns_ows, n, tmp);
	3470	xmlDocSetRootElement (doc, n);
[76]	3471
[531]	3472	xmlDocDumpFormatMemoryEnc (doc, &xmlbuff, &buffersize, encoding, 1);
	3473	if (file == NULL)
	3474	printf ("%s", xmlbuff);
	3475	else
	3476	{
	3477	fprintf (file, "%s", xmlbuff);
	3478	}
[76]	3479
[531]	3480	if (tmp != NULL)
	3481	{
	3482	freeMap (&tmp);
	3483	free (tmp);
	3484	}
	3485	xmlFree (xmlbuff);
	3486	xmlFreeDoc (doc);
	3487	xmlCleanupParser ();
	3488	zooXmlCleanupNs ();
	3489
[76]	3490	}
[280]	3491
[281]	3492
[531]	3493	char *
	3494	getMd5 (char *url)
	3495	{
[291]	3496	EVP_MD_CTX md5ctx;
[531]	3497	char fresult = (char ) malloc ((EVP_MAX_MD_SIZE + 1) * sizeof (char));
[291]	3498	unsigned char result[EVP_MAX_MD_SIZE];
	3499	unsigned int len;
[531]	3500	EVP_DigestInit (&md5ctx, EVP_md5 ());
	3501	EVP_DigestUpdate (&md5ctx, url, strlen (url));
	3502	EVP_DigestFinal_ex (&md5ctx, result, &len);
	3503	EVP_MD_CTX_cleanup (&md5ctx);
[291]	3504	int i;
[531]	3505	for (i = 0; i < len; i++)
	3506	{
	3507	if (i > 0)
	3508	{
	3509	char *tmp = strdup (fresult);
	3510	sprintf (fresult, "%s%02x", tmp, result[i]);
	3511	free (tmp);
	3512	}
	3513	else
	3514	sprintf (fresult, "%02x", result[i]);
[291]	3515	}
	3516	return fresult;
	3517	}
	3518
[280]	3519	/**
	3520	* Cache a file for a given request
	3521	*/
[531]	3522	void
	3523	addToCache (maps * conf, char request, char content, char *mimeType,
	3524	int length)
	3525	{
	3526	map *tmp = getMapFromMaps (conf, "main", "cacheDir");
	3527	if (tmp != NULL)
	3528	{
	3529	char *md5str = getMd5 (request);
	3530	char *fname =
	3531	(char ) malloc (sizeof (char)
	3532	(strlen (tmp->value) + strlen (md5str) + 6));
	3533	sprintf (fname, "%s/%s.zca", tmp->value, md5str);
[291]	3534	#ifdef DEBUG
[531]	3535	fprintf (stderr, "Cache list : %s\n", fname);
	3536	fflush (stderr);
[291]	3537	#endif
[531]	3538	FILE *fo = fopen (fname, "w+");
	3539	if (fo == NULL)
	3540	{
	3541	fprintf (stderr, "Failed to open %s for writting: %s\n", fname,
	3542	strerror (errno));
	3543	return;
	3544	}
	3545	fwrite (content, sizeof (char), length, fo);
	3546	fclose (fo);
[446]	3547
[531]	3548	sprintf (fname, "%s/%s.zcm", tmp->value, md5str);
	3549	fo = fopen (fname, "w+");
[446]	3550	#ifdef DEBUG
[531]	3551	fprintf (stderr, "MIMETYPE: %s\n", mimeType);
[446]	3552	#endif
[531]	3553	fwrite (mimeType, sizeof (char), strlen (mimeType), fo);
	3554	fclose (fo);
[446]	3555
[531]	3556	free (md5str);
	3557	free (fname);
	3558	}
[280]	3559	}
	3560
[531]	3561	char *
	3562	isInCache (maps * conf, char *request)
	3563	{
	3564	map *tmpM = getMapFromMaps (conf, "main", "cacheDir");
	3565	if (tmpM != NULL)
	3566	{
	3567	char *md5str = getMd5 (request);
[291]	3568	#ifdef DEBUG
[531]	3569	fprintf (stderr, "MD5STR : (%s)\n\n", md5str);
[291]	3570	#endif
[531]	3571	char *fname =
	3572	(char ) malloc (sizeof (char)
	3573	(strlen (tmpM->value) + strlen (md5str) + 6));
	3574	sprintf (fname, "%s/%s.zca", tmpM->value, md5str);
	3575	struct stat f_status;
	3576	int s = stat (fname, &f_status);
	3577	if (s == 0 && f_status.st_size > 0)
	3578	{
	3579	free (md5str);
	3580	return fname;
	3581	}
	3582	free (md5str);
	3583	free (fname);
[292]	3584	}
[280]	3585	return NULL;
	3586	}
[281]	3587
[531]	3588	int
	3589	runHttpRequests (maps m, maps inputs, HINTERNET * hInternet)
	3590	{
	3591	if (hInternet->nb > 0)
	3592	{
	3593	processDownloads (hInternet);
	3594	maps content = inputs;
	3595	map *tmp1;
	3596	int index = 0;
	3597	while (content != NULL)
	3598	{
	3599	if ((tmp1 = getMap (content->content, "href")) \|\|
	3600	(tmp1 = getMap (content->content, "xlink:href")))
	3601	{
	3602	if (getMap (content->content, "isCached") == NULL)
	3603	{
	3604	char *fcontent;
	3605	char *mimeType = NULL;
	3606	int fsize = 0;
[492]	3607
[531]	3608	fcontent =
	3609	(char *) malloc ((hInternet->ihandle[index].nDataLen + 1)
	3610	* sizeof (char));
	3611	if (fcontent == NULL)
	3612	{
	3613	return errorException (*m,
	3614	_("Unable to allocate memory."),
[549]	3615	"InternalError", NULL,NULL);
[531]	3616	}
	3617	size_t dwRead;
	3618	InternetReadFile (hInternet->ihandle[index],
	3619	(LPVOID) fcontent,
	3620	hInternet->ihandle[index].nDataLen,
	3621	&dwRead);
	3622	fcontent[hInternet->ihandle[index].nDataLen] = 0;
	3623	fsize = hInternet->ihandle[index].nDataLen;
	3624	mimeType =
	3625	strdup ((char *) hInternet->ihandle[index].mimeType);
	3626
	3627	map *tmpMap = getMapOrFill (&content->content, "value", "");
	3628	free (tmpMap->value);
	3629	tmpMap->value =
	3630	(char ) malloc ((fsize + 1) sizeof (char));
	3631	if (tmpMap->value == NULL)
	3632	{
	3633	return errorException (*m,
	3634	_("Unable to allocate memory."),
[549]	3635	"InternalError", NULL,NULL);
[531]	3636	}
	3637	memcpy (tmpMap->value, fcontent,
	3638	(fsize + 1) * sizeof (char));
	3639
	3640	char ltmp1[256];
	3641	sprintf (ltmp1, "%d", fsize);
	3642	addToMap (content->content, "size", ltmp1);
	3643	addToCache (*m, tmp1->value, fcontent, mimeType, fsize);
	3644	free (fcontent);
	3645	free (mimeType);
	3646	}
	3647	index++;
	3648	}
	3649	content = content->next;
	3650	}
[492]	3651	}
	3652	}
	3653
[281]	3654	/**
	3655	* loadRemoteFile:
	3656	* Try to load file from cache or download a remote file if not in cache
	3657	*/
[531]	3658	int
	3659	loadRemoteFile (maps m, map content, HINTERNET * hInternet, char *url)
	3660	{
	3661	char *fcontent;
	3662	char cached = isInCache (m, url);
	3663	char *mimeType = NULL;
	3664	int fsize = 0;
	3665	if (cached != NULL)
	3666	{
	3667	struct stat f_status;
	3668	int s = stat (cached, &f_status);
	3669	if (s == 0)
	3670	{
	3671	fcontent = (char ) malloc (sizeof (char) (f_status.st_size + 1));
	3672	FILE *f = fopen (cached, "rb");
	3673	fread (fcontent, f_status.st_size, 1, f);
	3674	fsize = f_status.st_size;
	3675	fcontent[fsize] = 0;
	3676	fclose (f);
	3677	}
	3678	cached[strlen (cached) - 1] = 'm';
	3679	s = stat (cached, &f_status);
	3680	if (s == 0)
	3681	{
	3682	mimeType = (char ) malloc (sizeof (char) (f_status.st_size + 1));
	3683	FILE *f = fopen (cached, "rb");
	3684	fread (mimeType, f_status.st_size, 1, f);
	3685	mimeType[f_status.st_size] = 0;
	3686	fclose (f);
	3687	}
[281]	3688	}
[531]	3689	else
	3690	{
	3691	hInternet->waitingRequests[hInternet->nb] = strdup (url);
	3692	InternetOpenUrl (hInternet, hInternet->waitingRequests[hInternet->nb],
	3693	NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
	3694	return 0;
[446]	3695	}
[531]	3696	if (fsize == 0)
	3697	{
[617]	3698
[531]	3699	return errorException (*m, _("Unable to download the file."),
[549]	3700	"InternalError", NULL,NULL);
[531]	3701	}
	3702	if (mimeType != NULL)
	3703	{
	3704	addToMap (*content, "fmimeType", mimeType);
	3705	}
[446]	3706
[531]	3707	map *tmpMap = getMapOrFill (content, "value", "");
	3708
	3709	free (tmpMap->value);
	3710	tmpMap->value = (char ) malloc ((fsize + 1) sizeof (char));
[617]	3711	if (tmpMap->value == NULL){
	3712
[531]	3713	return errorException (*m, _("Unable to allocate memory."),
[549]	3714	"InternalError", NULL,NULL);
[617]	3715	}
[531]	3716	memcpy (tmpMap->value, fcontent, (fsize + 1) * sizeof (char));
	3717
[281]	3718	char ltmp1[256];
[531]	3719	sprintf (ltmp1, "%d", fsize);
	3720	addToMap (*content, "size", ltmp1);
	3721	if (cached == NULL)
	3722	addToCache (*m, url, fcontent, mimeType, fsize);
[492]	3723	else
[531]	3724	addToMap (*content, "isCached", "true");
	3725	free (fcontent);
	3726	free (mimeType);
	3727	free (cached);
[364]	3728	return 0;
[281]	3729	}
	3730
[531]	3731	int
	3732	errorException (maps * m, const char message, const char errorcode,
[549]	3733	const char locator,FCGX_Stream out)
[284]	3734	{
[531]	3735	map *errormap = createMap ("text", message);
	3736	addToMap (errormap, "code", errorcode);
	3737	if (locator != NULL)
	3738	addToMap (errormap, "locator", locator);
[459]	3739	else
[531]	3740	addToMap (errormap, "locator", "NULL");
[549]	3741	printExceptionReportResponse (m, errormap,out);
[531]	3742	freeMap (&errormap);
	3743	free (errormap);
[284]	3744	return -1;
	3745	}
[469]	3746
[490]	3747
[531]	3748	char *
	3749	readVSIFile (maps * conf, const char *dataSource)
	3750	{
	3751	VSILFILE *fichier = VSIFOpenL (dataSource, "rb");
	3752	VSIStatBufL file_status;
	3753	VSIStatL (dataSource, &file_status);
	3754	if (fichier == NULL)
	3755	{
[469]	3756	char tmp[1024];
[531]	3757	sprintf (tmp,
	3758	"Failed to open file %s for reading purpose. File seems empty %d.",
	3759	dataSource, file_status.st_size);
	3760	setMapInMaps (conf, "lenv", "message", tmp);
[469]	3761	return NULL;
	3762	}
[531]	3763	char res1 = (char ) malloc (file_status.st_size * sizeof (char));
	3764	VSIFReadL (res1, 1, file_status.st_size * sizeof (char), fichier);
	3765	res1[file_status.st_size - 1] = 0;
	3766	VSIFCloseL (fichier);
	3767	VSIUnlink (dataSource);
	3768	return res1;
[469]	3769	}
	3770
[531]	3771	void
	3772	parseIdentifier (maps * conf, char conf_dir, char identifier, char *buffer)
	3773	{
[469]	3774	char *saveptr1;
[531]	3775	char *tmps1 = strtok_r (identifier, ".", &saveptr1);
	3776	int level = 0;
[469]	3777	char key[25];
	3778	char levels[18];
[531]	3779	while (tmps1 != NULL)
	3780	{
	3781	char *test = zStrdup (tmps1);
	3782	char tmps2 = (char ) malloc ((strlen (test) + 2) * sizeof (char));
	3783	sprintf (key, "sprefix_%d", level);
	3784	sprintf (tmps2, "%s.", test);
	3785	sprintf (levels, "%d", level);
	3786	setMapInMaps (conf, "lenv", "level", levels);
	3787	setMapInMaps (conf, "lenv", key, tmps2);
	3788	free (tmps2);
	3789	free (test);
	3790	level++;
	3791	tmps1 = strtok_r (NULL, ".", &saveptr1);
[469]	3792	}
[531]	3793	int i = 0;
	3794	sprintf (buffer, "%s", conf_dir);
	3795	for (i = 0; i < level; i++)
	3796	{
	3797	char *tmp0 = zStrdup (buffer);
	3798	sprintf (key, "sprefix_%d", i);
	3799	map *tmp00 = getMapFromMaps (conf, "lenv", key);
	3800	if (tmp00 != NULL)
	3801	sprintf (buffer, "%s/%s", tmp0, tmp00->value);
	3802	free (tmp0);
	3803	buffer[strlen (buffer) - 1] = 0;
	3804	if (i + 1 < level)
	3805	{
	3806	map *tmpMap = getMapFromMaps (conf, "lenv", "metapath");
	3807	if (tmpMap == NULL \|\| strlen (tmpMap->value) == 0)
	3808	{
	3809	char *tmp01 = zStrdup (tmp00->value);
	3810	tmp01[strlen (tmp01) - 1] = 0;
	3811	setMapInMaps (conf, "lenv", "metapath", tmp01);
	3812	free (tmp01);
	3813	tmp01 = NULL;
	3814	}
	3815	else
	3816	{
	3817	if (tmp00 != NULL && tmpMap != NULL)
	3818	{
	3819	char *tmp00s = zStrdup (tmp00->value);
	3820	tmp00s[strlen (tmp00s) - 1] = 0;
	3821	char *value =
	3822	(char *)
	3823	malloc ((strlen (tmp00s) + strlen (tmpMap->value) +
	3824	2) * sizeof (char));
	3825	sprintf (value, "%s/%s", tmpMap->value, tmp00s);
	3826	setMapInMaps (conf, "lenv", "metapath", value);
	3827	free (value);
	3828	free (tmp00s);
	3829	value = NULL;
	3830	}
	3831	}
	3832	}
	3833	else
	3834	{
	3835	char *tmp01 = zStrdup (tmp00->value);
	3836	tmp01[strlen (tmp01) - 1] = 0;
	3837	setMapInMaps (conf, "lenv", "Identifier", tmp01);
	3838	free (tmp01);
	3839	}
	3840	}
	3841	char *tmp0 = zStrdup (buffer);
	3842	sprintf (buffer, "%s.zcfg", tmp0);
	3843	free (tmp0);
[469]	3844	}
	3845
[531]	3846	int
	3847	updateStatus (maps * conf, const int percentCompleted, const char *message)
	3848	{
[471]	3849	char tmp[4];
[531]	3850	snprintf (tmp, 4, "%d", percentCompleted);
	3851	setMapInMaps (conf, "lenv", "status", tmp);
	3852	setMapInMaps (conf, "lenv", "message", message);
	3853	return _updateStatus (conf);
[471]	3854	}
	3855
[531]	3856	char *
	3857	getInputValue (maps * inputs, const char *parameterName,
	3858	size_t * numberOfBytes)
	3859	{
	3860	map *res = getMapFromMaps (inputs, parameterName, "value");
	3861	if (res != NULL)
	3862	{
	3863	map *size = getMapFromMaps (inputs, parameterName, "size");
	3864	if (size != NULL)
	3865	{
	3866	*numberOfBytes = (size_t) atoi (size->value);
	3867	return res->value;
	3868	}
	3869	else
	3870	{
	3871	*numberOfBytes = strlen (res->value);
	3872	return res->value;
	3873	}
[471]	3874	}
	3875	return NULL;
	3876	}
	3877
[531]	3878	int
	3879	setOutputValue (maps * outputs, const char parameterName, char data,
	3880	size_t numberOfBytes)
	3881	{
	3882	if (numberOfBytes == -1)
	3883	{
	3884	setMapInMaps (outputs, parameterName, "value", data);
	3885	}
	3886	else
	3887	{
	3888	char size[1024];
	3889	map *tmp = getMapFromMaps (outputs, parameterName, "value");
	3890	free (tmp->value);
	3891	tmp->value = (char ) malloc ((numberOfBytes + 1) sizeof (char));
	3892	memcpy (tmp->value, data, numberOfBytes);
	3893	sprintf (size, "%lu", numberOfBytes);
	3894	setMapInMaps (outputs, parameterName, "size", size);
	3895	}
[471]	3896	return 0;
	3897	}

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

Open WPS platform

source: branches/PublicaMundi_David-devel/zoo-project/zoo-kernel/service_internal.c @ 961

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links