Warning: Can't use blame annotator:
svn blame failed on branches/PublicaMundi_David-devel/zoo-project/zoo-kernel/service_internal.c: 200029 - Couldn't perform atomic initialization

service_internal.c @ 541

Last change on this file since 541 was 531, checked in by david, 11 years ago
remove metapath parameter for python and js support use conf in memory for C,python and js services
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 120.9 KB

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

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 @ 541

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links