request_parser.c @ 960

Last change on this file since 960 was 957, checked in by knut, 5 years ago
Added function for allocating memory for map values (allocateMapValue). Fixed issue with getting attributes from input data node. Added code to support MIME subtype attributes in key-value pairs.
Property svn:keywords set to `Id`
File size: 58.0 KB

Rev	Line
[621]	1	/*
	2	* Author : Gérald FENOY
	3	*
	4	* Copyright (c) 2015 GeoLabs SARL
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#include "request_parser.h"
	26	#include "service_internal.h"
[640]	27	#include "server_internal.h"
	28	#include "response_print.h"
	29	#include "caching.h"
[917]	30	#include "cgic.h"
[621]	31
	32	/**
	33	* Apply XPath Expression on XML document.
	34	*
	35	* @param doc the XML Document
	36	* @param search the XPath expression
	37	* @return xmlXPathObjectPtr containing the resulting nodes set
	38	*/
	39	xmlXPathObjectPtr
	40	extractFromDoc (xmlDocPtr doc, const char *search)
	41	{
	42	xmlXPathContextPtr xpathCtx;
	43	xmlXPathObjectPtr xpathObj;
	44	xpathCtx = xmlXPathNewContext (doc);
	45	xpathObj = xmlXPathEvalExpression (BAD_CAST search, xpathCtx);
	46	xmlXPathFreeContext (xpathCtx);
	47	return xpathObj;
	48	}
	49
	50	/**
	51	* Create (or append to) an array valued maps value = "["",""]"
	52	*
	53	* @param m the conf maps containing the main.cfg settings
	54	* @param mo the map to update
	55	* @param mi the map to append
	56	* @param elem the elements containing default definitions
	57	* @return 0 on success, -1 on failure
	58	*/
	59	int appendMapsToMaps (maps * m, maps * mo, maps * mi, elements * elem){
	60	maps *tmpMaps = getMaps (mo, mi->name);
	61	map *tmap = getMapType (tmpMaps->content);
	62	elements *el = getElements (elem, mi->name);
[790]	63	elements *cursor = elem;
	64	while(cursor!=NULL && el==NULL){
	65	if(cursor->child!=NULL)
	66	el = getElements (cursor->child, mi->name);
	67	cursor=cursor->next;
	68	}
[621]	69	int hasEl = 1;
	70	if (el == NULL)
	71	hasEl = -1;
[790]	72
[621]	73	if (tmap == NULL)
	74	{
	75	if (hasEl > 0)
	76	tmap = getMapType (el->defaults->content);
	77	}
	78
	79	map *testMap = NULL;
	80	if (hasEl > 0)
	81	{
	82	testMap = getMap (el->content, "maxOccurs");
	83	}
	84	else
	85	{
	86	testMap = createMap ("maxOccurs", "unbounded");
	87	}
	88
	89	if (testMap != NULL)
	90	{
	91	if (strncasecmp (testMap->value, "unbounded", 9) != 0
	92	&& atoi (testMap->value) > 1)
	93	{
	94	addMapsArrayToMaps (&mo, mi, tmap->name);
	95	map* nb=getMapFromMaps(mo,mi->name,"length");
	96	if (nb!=NULL && atoi(nb->value)>atoi(testMap->value))
	97	{
	98	char emsg[1024];
	99	sprintf (emsg,
	100	_("The maximum allowed occurrences for <%s> (%i) was exceeded."),
	101	mi->name, atoi (testMap->value));
	102	errorException (m, emsg, "InternalError", NULL);
	103	return -1;
	104	}
	105	}
	106	else
	107	{
	108	if (strncasecmp (testMap->value, "unbounded", 9) == 0)
	109	{
	110	if (hasEl < 0)
	111	{
	112	freeMap (&testMap);
	113	free (testMap);
	114	}
	115	if (addMapsArrayToMaps (&mo, mi, tmap->name) < 0)
	116	{
	117	char emsg[1024];
	118	map *tmpMap = getMap (mi->content, "length");
	119	sprintf (emsg,
	120	_
	121	("ZOO-Kernel was unable to load your data for %s position %s."),
	122	mi->name, tmpMap->value);
	123	errorException (m, emsg, "InternalError", NULL);
	124	return -1;
	125	}
	126	}
	127	else
	128	{
	129	char emsg[1024];
	130	sprintf (emsg,
	131	_
	132	("The maximum allowed occurrences for <%s> is one."),
	133	mi->name);
	134	errorException (m, emsg, "InternalError", NULL);
	135	return -1;
	136	}
	137	}
	138	}
	139	return 0;
	140	}
	141
	142	/**
[640]	143	* Make sure that each value encoded in base64 in a maps is decoded.
	144	*
	145	* @param in the maps containing the values
	146	* @see readBase64
	147	*/
	148	void ensureDecodedBase64(maps **in){
	149	maps* cursor=*in;
	150	while(cursor!=NULL){
	151	map *tmp=getMap(cursor->content,"encoding");
	152	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
	153	tmp=getMap(cursor->content,"value");
	154	readBase64(&tmp);
	155	addToMap(cursor->content,"base64_value",tmp->value);
	156	int size=0;
[917]	157	char *s=zStrdup(tmp->value);
[640]	158	free(tmp->value);
	159	tmp->value=base64d(s,strlen(s),&size);
	160	free(s);
	161	char sizes[1024];
	162	sprintf(sizes,"%d",size);
	163	addToMap(cursor->content,"size",sizes);
	164	}
	165	map* length=getMap(cursor->content,"length");
	166	if(length!=NULL){
	167	int len=atoi(length->value);
	168	for(int i=1;i<len;i++){
	169	tmp=getMapArray(cursor->content,"encoding",i);
	170	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
	171	char key[17];
	172	sprintf(key,"base64_value_%d",i);
	173	tmp=getMapArray(cursor->content,"value",i);
	174	readBase64(&tmp);
	175	addToMap(cursor->content,key,tmp->value);
	176	int size=0;
[917]	177	char *s=zStrdup(tmp->value);
[640]	178	free(tmp->value);
	179	tmp->value=base64d(s,strlen(s),&size);
	180	free(s);
	181	char sizes[1024];
	182	sprintf(sizes,"%d",size);
	183	sprintf(key,"size_%d",i);
	184	addToMap(cursor->content,key,sizes);
	185	}
	186	}
	187	}
[790]	188	if(cursor->child!=NULL)
	189	ensureDecodedBase64(&cursor->child);
[640]	190	cursor=cursor->next;
	191	}
	192	}
	193
	194	/**
[621]	195	* Parse inputs provided as KVP and store them in a maps.
	196	*
	197	* @param main_conf the conf maps containing the main.cfg settings
	198	* @param s the service
	199	* @param request_inputs the map storing KVP raw value
	200	* @param request_output the maps to store the KVP pairs
	201	* @param hInternet the HINTERNET queue to add potential requests
	202	* @return 0 on success, -1 on failure
	203	*/
	204	int kvpParseInputs(maps** main_conf,service* s,map request_inputs,maps* request_output,HINTERNET* hInternet){
	205	// Parsing inputs provided as KVP
	206	maps tmpmaps = request_output;
	207	map* r_inputs = getMap (request_inputs, "DataInputs");
	208	char* cursor_input;
	209	if (r_inputs != NULL){
	210	//snprintf (cursor_input, 40960, "%s", r_inputs->value);
[625]	211	if(strstr(r_inputs->value,"=")==NULL)
	212	cursor_input = url_decode (r_inputs->value);
	213	else
	214	cursor_input = zStrdup (r_inputs->value);
[621]	215	int j = 0;
	216
	217	// Put each DataInputs into the inputs_as_text array
	218	char *pToken;
	219	pToken = strtok (cursor_input, ";");
	220	char inputs_as_text = (char ) malloc (100 * sizeof (char *));
	221	if (inputs_as_text == NULL)
	222	{
[626]	223	free(cursor_input);
[725]	224	return errorException (*main_conf, _("Unable to allocate memory"),
[621]	225	"InternalError", NULL);
	226	}
	227	int i = 0;
	228	while (pToken != NULL)
	229	{
	230	inputs_as_text[i] =
	231	(char ) malloc ((strlen (pToken) + 1) sizeof (char));
	232	if (inputs_as_text[i] == NULL)
	233	{
[626]	234	free(cursor_input);
[725]	235	return errorException (*main_conf, _("Unable to allocate memory"),
[621]	236	"InternalError", NULL);
	237	}
	238	snprintf (inputs_as_text[i], strlen (pToken) + 1, "%s", pToken);
	239	pToken = strtok (NULL, ";");
	240	i++;
	241	}
	242
	243	for (j = 0; j < i; j++)
	244	{
	245	char *tmp = zStrdup (inputs_as_text[j]);
	246	free (inputs_as_text[j]);
	247	char *tmpc;
	248	tmpc = strtok (tmp, "@");
	249	while (tmpc != NULL)
	250	{
	251	char *tmpv = strstr (tmpc, "=");
	252	char tmpn[256];
	253	memset (tmpn, 0, 256);
	254	if (tmpv != NULL)
	255	{
	256	strncpy (tmpn, tmpc,
	257	(strlen (tmpc) - strlen (tmpv)) * sizeof (char));
	258	tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
	259	}
	260	else
	261	{
	262	strncpy (tmpn, tmpc, strlen (tmpc) * sizeof (char));
	263	tmpn[strlen (tmpc)] = 0;
	264	}
	265	if (tmpmaps == NULL)
	266	{
[790]	267	tmpmaps = createMaps(tmpn);
[621]	268	if (tmpmaps == NULL)
	269	{
[626]	270	free(cursor_input);
[621]	271	return errorException (*main_conf,
[725]	272	_("Unable to allocate memory"),
[621]	273	"InternalError", NULL);
	274	}
	275	if (tmpv != NULL)
	276	{
	277	char *tmpvf = url_decode (tmpv + 1);
	278	tmpmaps->content = createMap ("value", tmpvf);
	279	free (tmpvf);
	280	}
	281	else
	282	tmpmaps->content = createMap ("value", "Reference");
	283	tmpmaps->next = NULL;
	284	}
	285	tmpc = strtok (NULL, "@");
	286	while (tmpc != NULL)
	287	{
	288	char *tmpv1 = strstr (tmpc, "=");
	289	char tmpn1[1024];
	290	memset (tmpn1, 0, 1024);
	291	if (tmpv1 != NULL)
	292	{
	293	strncpy (tmpn1, tmpc, strlen (tmpc) - strlen (tmpv1));
	294	tmpn1[strlen (tmpc) - strlen (tmpv1)] = 0;
	295	addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
	296	}
	297	else
	298	{
	299	strncpy (tmpn1, tmpc, strlen (tmpc));
	300	tmpn1[strlen (tmpc)] = 0;
	301	map *lmap = getLastMap (tmpmaps->content);
	302	char *tmpValue =
	303	(char ) malloc ((strlen (tmpv) + strlen (tmpc) + 1)
	304	sizeof (char));
	305	sprintf (tmpValue, "%s@%s", tmpv + 1, tmpc);
	306	free (lmap->value);
	307	lmap->value = zStrdup (tmpValue);
	308	free (tmpValue);
	309	tmpc = strtok (NULL, "@");
	310	continue;
	311	}
	312	if (strcmp (tmpn1, "xlink:href") != 0)
	313	addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
	314	else if (tmpv1 != NULL)
	315	{
	316	char *tmpx2 = url_decode (tmpv1 + 1);
	317	if (strncasecmp (tmpx2, "http://", 7) != 0 &&
	318	strncasecmp (tmpx2, "ftp://", 6) != 0 &&
	319	strncasecmp (tmpx2, "https://", 8) != 0)
	320	{
	321	char emsg[1024];
	322	sprintf (emsg,
	323	_
	324	("Unable to find a valid protocol to download the remote file %s"),
	325	tmpv1 + 1);
[626]	326	free(cursor_input);
[621]	327	return errorException (*main_conf, emsg, "InternalError", NULL);
	328	}
	329	addToMap (tmpmaps->content, tmpn1, tmpx2);
	330	{
	331	if (loadRemoteFile
	332	(&*main_conf, &tmpmaps->content, hInternet, tmpx2) < 0)
	333	{
[626]	334	free(cursor_input);
[781]	335	return errorException (*main_conf, "Unable to fetch any resource", "InternalError", NULL);
[626]	336	}
[621]	337	}
	338	free (tmpx2);
[627]	339	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	340	addToMap (tmpmaps->content, "Reference", tmpv1 + 1);
	341	}
	342	tmpc = strtok (NULL, "@");
	343	}
	344	if (*request_output == NULL)
	345	*request_output = dupMaps (&tmpmaps);
	346	else
	347	{
	348	maps *testPresence =
	349	getMaps (*request_output, tmpmaps->name);
	350	if (testPresence != NULL)
	351	{
	352	elements *elem =
	353	getElements (s->inputs, tmpmaps->name);
	354	if (elem != NULL)
	355	{
	356	if (appendMapsToMaps
	357	(main_conf, request_output, tmpmaps,
	358	elem) < 0)
	359	{
[626]	360	free(cursor_input);
[621]	361	return errorException (*main_conf, "Unable to append maps", "InternalError", NULL);
	362	}
	363	}
	364	}
	365	else
[623]	366	addMapsToMaps (request_output, tmpmaps);
[621]	367	}
	368	freeMaps (&tmpmaps);
	369	free (tmpmaps);
	370	tmpmaps = NULL;
	371	free (tmp);
	372	}
	373	}
	374	free (inputs_as_text);
[626]	375	free(cursor_input);
[621]	376	}
	377	return 1;
	378	}
	379
	380	/**
	381	* Parse outputs provided as KVP and store them in a maps.
	382	*
	383	* @param main_conf the conf maps containing the main.cfg settings
	384	* @param request_inputs the map storing KVP raw value
	385	* @param request_output the maps to store the KVP pairs
	386	* @return 0 on success, -1 on failure
	387	*/
	388	int kvpParseOutputs(maps** main_conf,map request_inputs,maps* request_output){
	389	/**
	390	* Parsing outputs provided as KVP
	391	*/
	392	map *r_inputs = NULL;
	393	r_inputs = getMap (request_inputs, "ResponseDocument");
	394	if (r_inputs == NULL)
	395	r_inputs = getMap (request_inputs, "RawDataOutput");
	396
	397	if (r_inputs != NULL)
	398	{
	399	char *cursor_output = zStrdup (r_inputs->value);
	400	int j = 0;
	401
	402	/**
	403	* Put each Output into the outputs_as_text array
	404	*/
	405	char *pToken;
	406	maps *tmp_output = NULL;
	407	pToken = strtok (cursor_output, ";");
	408	char outputs_as_text = (char ) malloc (128 * sizeof (char *));
	409	if (outputs_as_text == NULL)
	410	{
[626]	411	free(cursor_output);
[621]	412	return errorException (*main_conf, _("Unable to allocate memory"),
	413	"InternalError", NULL);
	414	}
	415	int i = 0;
	416	while (pToken != NULL)
	417	{
[957]	418	/* outputs_as_text[i] =
[621]	419	(char ) malloc ((strlen (pToken) + 1) sizeof (char));
	420	if (outputs_as_text[i] == NULL)
	421	{
[626]	422	free(cursor_output);
[621]	423	return errorException (*main_conf, _("Unable to allocate memory"),
	424	"InternalError", NULL);
	425	}
	426	snprintf (outputs_as_text[i], strlen (pToken) + 1, "%s",
	427	pToken);
	428	pToken = strtok (NULL, ";");
[957]	429	i++; */
	430
	431	// knut : rewrite above fragment to enable parsing of mimetype;subtype strings in key-value pairs:
	432
	433	char* _token = zStrdup(pToken);
	434	pToken = strtok (NULL, ";");
	435
	436	if (pToken != NULL && strncmp(pToken, "subtype=", 8) == 0)
	437	{
	438	size_t _length = strlen(pToken) + strlen(_token) + 2;
	439	outputs_as_text[i] = (char ) malloc(_length sizeof (char));
	440	snprintf(outputs_as_text[i], _length, "%s;%s", _token, pToken);
	441	pToken = strtok (NULL, ";");
	442	}
	443	else
	444	{
	445	outputs_as_text[i] = (char ) malloc((strlen(_token) + 1) sizeof (char));
	446	snprintf (outputs_as_text[i], strlen(_token) + 1, "%s", _token);
	447	}
	448	free(_token);
	449	i++;
[621]	450	}
	451	for (j = 0; j < i; j++)
	452	{
	453	char *tmp = zStrdup (outputs_as_text[j]);
	454	free (outputs_as_text[j]);
	455	char *tmpc;
	456	tmpc = strtok (tmp, "@");
	457	int k = 0;
	458	while (tmpc != NULL)
	459	{
	460	if (k == 0)
	461	{
	462	if (tmp_output == NULL)
	463	{
[790]	464	tmp_output = createMaps(tmpc);
[621]	465	if (tmp_output == NULL)
	466	{
[626]	467	free(cursor_output);
[621]	468	return errorException (*main_conf,
	469	_
[725]	470	("Unable to allocate memory"),
[621]	471	"InternalError", NULL);
	472	}
	473	}
	474	}
	475	else
	476	{
	477	char *tmpv = strstr (tmpc, "=");
	478	char tmpn[256];
	479	memset (tmpn, 0, 256);
	480	strncpy (tmpn, tmpc,
	481	(strlen (tmpc) -
	482	strlen (tmpv)) * sizeof (char));
	483	tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
	484	if (tmp_output->content == NULL)
	485	{
	486	tmp_output->content = createMap (tmpn, tmpv + 1);
	487	tmp_output->content->next = NULL;
	488	}
	489	else
	490	addToMap (tmp_output->content, tmpn, tmpv + 1);
	491	}
	492	k++;
	493	tmpc = strtok (NULL, "@");
	494	}
	495	if (*request_output == NULL)
	496	*request_output = dupMaps (&tmp_output);
	497	else
[623]	498	addMapsToMaps (request_output, tmp_output);
[621]	499	freeMaps (&tmp_output);
	500	free (tmp_output);
	501	tmp_output = NULL;
	502	free (tmp);
	503	}
	504	free (outputs_as_text);
[626]	505	free(cursor_output);
[621]	506	}
	507	return 1;
	508	}
	509
	510	/**
[745]	511	* Create a "missingIdentifier" maps in case it is NULL.
	512	*
	513	* @param main_conf the conf maps containing the main.cfg settings
	514	* @param mymaps the maps to update
	515	* @return 0 on success, 4 on failure
	516	*/
	517	int defineMissingIdentifier(maps main_conf,maps mymaps){
	518	if (*mymaps == NULL){
[790]	519	*mymaps = createMaps("missingIndetifier");
[745]	520	if (*mymaps == NULL){
	521	return errorException (*main_conf,
	522	_("Unable to allocate memory"),
	523	"InternalError", NULL);
	524	}
	525	}
	526	return 0;
	527	}
	528
	529	/**
[621]	530	* Parse inputs from XML nodes and store them in a maps.
	531	*
	532	* @param main_conf the conf maps containing the main.cfg settings
	533	* @param s the service
	534	* @param request_output the maps to store the KVP pairs
	535	* @param doc the xmlDocPtr containing the original request
	536	* @param nodes the input nodes array
	537	* @param hInternet the HINTERNET queue to add potential requests
	538	* @return 0 on success, -1 on failure
	539	*/
	540	int xmlParseInputs(maps** main_conf,service* s,maps** request_output,xmlDocPtr doc,xmlNodeSet* nodes,HINTERNET* hInternet){
[622]	541	int k = 0;
	542	int l = 0;
[654]	543	map* version=getMapFromMaps(*main_conf,"main","rversion");
[917]	544	map* memory=getMapFromMaps(*main_conf,"main","memory");
[654]	545	int vid=getVersionId(version->value);
[622]	546	for (k=0; k < nodes->nodeNr; k++)
[621]	547	{
	548	maps *tmpmaps = NULL;
	549	xmlNodePtr cur = nodes->nodeTab[k];
	550
	551	if (nodes->nodeTab[k]->type == XML_ELEMENT_NODE)
	552	{
	553	// A specific Input node.
[654]	554	if(vid==1){
	555	xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
[790]	556	tmpmaps = createMaps((char *) val);
[917]	557	xmlFree(val);
[654]	558	}
	559
[621]	560	xmlNodePtr cur2 = cur->children;
	561	while (cur2 != NULL)
	562	{
	563	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	564	cur2 = cur2->next;
	565	if (cur2 == NULL)
	566	break;
	567	// Indentifier
	568	if (xmlStrncasecmp
	569	(cur2->name, BAD_CAST "Identifier",
	570	xmlStrlen (cur2->name)) == 0)
	571	{
	572	xmlChar *val =
	573	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
[745]	574	if (tmpmaps == NULL && val!=NULL)
[621]	575	{
[790]	576	tmpmaps = createMaps((char*)val);
[621]	577	if (tmpmaps == NULL)
	578	{
	579	return errorException (*main_conf,
	580	_
[725]	581	("Unable to allocate memory"),
[621]	582	"InternalError", NULL);
	583	}
[745]	584	xmlFree (val);
[621]	585	}
	586	}
	587	// Title, Asbtract
	588	if (xmlStrncasecmp
	589	(cur2->name, BAD_CAST "Title",
	590	xmlStrlen (cur2->name)) == 0
	591	\|\| xmlStrncasecmp (cur2->name, BAD_CAST "Abstract",
	592	xmlStrlen (cur2->name)) == 0)
	593	{
	594	xmlChar *val =
	595	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
[745]	596	defineMissingIdentifier(main_conf,&tmpmaps);
	597	if(val!=NULL){
	598	if (tmpmaps->content != NULL)
	599	addToMap (tmpmaps->content,
	600	(char ) cur2->name, (char ) val);
	601	else
[621]	602	tmpmaps->content =
	603	createMap ((char ) cur2->name, (char ) val);
[745]	604	xmlFree (val);
	605	}
[621]	606	}
[790]	607	// InputDataFormChoice (Reference or Data ?) / 2.0.0 DataInputType / Input
	608	if (xmlStrcasecmp (cur2->name, BAD_CAST "Input") == 0)
[621]	609	{
[790]	610	char xpathExpr=(char)malloc(61+strlen(tmpmaps->name));
	611	sprintf(xpathExpr,"//[local-name()='Input' and @id='%s']/*[local-name()='Input']",tmpmaps->name);
	612	xmlXPathObjectPtr tmpsptr = extractFromDoc (doc, xpathExpr);
	613	xmlNodeSet *tmps = tmpsptr->nodesetval;
	614	if(tmps!=NULL){
	615	maps* request_output1=NULL;
	616	if(xmlParseInputs(main_conf,s,&request_output1,doc,tmps,hInternet)<0)
	617	return -1;
	618	if(tmpmaps->child==NULL)
	619	tmpmaps->child=dupMaps(&request_output1);
	620	else
	621	addMapsToMaps(&tmpmaps->child,request_output1);
	622	freeMaps(&request_output1);
	623	free(request_output1);
	624	}
	625	while(cur2->next!=NULL)
	626	cur2=cur2->next;
	627	}
	628	else if (xmlStrcasecmp (cur2->name, BAD_CAST "Reference") == 0)
	629	{
[745]	630	defineMissingIdentifier(main_conf,&tmpmaps);
[621]	631	// Get every attribute from a Reference node
	632	// mimeType, encoding, schema, href, method
	633	// Header and Body gesture should be added here
	634	const char *refs[5] =
	635	{ "mimeType", "encoding", "schema", "method",
	636	"href"
	637	};
[622]	638	for (l = 0; l < 5; l++)
[621]	639	{
	640	xmlChar *val = xmlGetProp (cur2, BAD_CAST refs[l]);
	641	if (val != NULL && xmlStrlen (val) > 0)
	642	{
	643	if (tmpmaps->content != NULL)
	644	addToMap (tmpmaps->content, refs[l],
	645	(char *) val);
	646	else
	647	tmpmaps->content =
	648	createMap (refs[l], (char *) val);
	649	map *ltmp = getMap (tmpmaps->content, "method");
	650	if (l == 4 )
	651	{
[917]	652	if ((ltmp==NULL \|\| strncmp (ltmp->value, "POST",4) != 0))
[621]	653	{
	654	if (loadRemoteFile
[623]	655	(main_conf, &tmpmaps->content, hInternet,
[621]	656	(char *) val) != 0)
	657	{
	658	return errorException (*main_conf,
	659	_("Unable to add a request in the queue."),
	660	"InternalError",
	661	NULL);
	662	}
[628]	663	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	664	}
[627]	665	addToMap (tmpmaps->content, "Reference", (char*) val);
[621]	666	}
	667	}
	668	xmlFree (val);
	669	}
	670	// Parse Header and Body from Reference
	671	xmlNodePtr cur3 = cur2->children;
	672	while (cur3 != NULL)
	673	{
	674	while (cur3 != NULL
	675	&& cur3->type != XML_ELEMENT_NODE)
	676	cur3 = cur3->next;
	677	if (cur3 == NULL)
	678	break;
	679	if (xmlStrcasecmp (cur3->name, BAD_CAST "Header") ==
	680	0)
	681	{
	682	const char *ha[2];
	683	ha[0] = "key";
	684	ha[1] = "value";
	685	int hai;
[695]	686	char *has=NULL;
[621]	687	char *key;
	688	for (hai = 0; hai < 2; hai++)
	689	{
	690	xmlChar *val =
	691	xmlGetProp (cur3, BAD_CAST ha[hai]);
	692	#ifdef POST_DEBUG
	693	fprintf (stderr, "%s = %s\n", ha[hai],
	694	(char *) val);
	695	#endif
	696	if (hai == 0)
	697	{
	698	key = zStrdup ((char *) val);
	699	}
	700	else
	701	{
	702	has =
	703	(char *)
	704	malloc ((4 + xmlStrlen (val) +
	705	strlen (key)) *
	706	sizeof (char));
	707	if (has == NULL)
	708	{
	709	return errorException (*main_conf,
	710	_
[725]	711	("Unable to allocate memory"),
[621]	712	"InternalError",
	713	NULL);
	714	}
	715	snprintf (has,
	716	(3 + xmlStrlen (val) +
	717	strlen (key)), "%s: %s", key,
	718	(char *) val);
	719	free (key);
	720	}
	721	xmlFree (val);
	722	}
[695]	723	if (has != NULL){
	724	hInternet->ihandle[hInternet->nb].header = NULL;
	725	hInternet->ihandle[hInternet->nb].header =
	726	curl_slist_append (hInternet->ihandle
	727	[hInternet->nb].header,
	728	has);
[621]	729	free (has);
[695]	730	}
[621]	731	}
	732	else
	733	{
	734	#ifdef POST_DEBUG
	735	fprintf (stderr,
	736	"Try to fetch the body part of the request ...\n");
	737	#endif
	738	if (xmlStrcasecmp (cur3->name, BAD_CAST "Body")
	739	== 0)
	740	{
	741	#ifdef POST_DEBUG
	742	fprintf (stderr, "Body part found (%s) !!!\n",
	743	(char *) cur3->content);
	744	#endif
	745	char *tmp = NULL;
	746	xmlNodePtr cur4 = cur3->children;
	747	while (cur4 != NULL)
	748	{
	749	while (cur4 && cur4 != NULL && cur4->type && cur4->type != XML_ELEMENT_NODE){
	750	if(cur4->next)
	751	cur4 = cur4->next;
	752	else
	753	cur4 = NULL;
	754	}
	755	if(cur4 != NULL) {
	756	xmlDocPtr bdoc =
	757	xmlNewDoc (BAD_CAST "1.0");
	758	bdoc->encoding =
	759	xmlCharStrdup ("UTF-8");
	760	xmlDocSetRootElement (bdoc, cur4);
	761	xmlChar *btmps;
	762	int bsize;
	763	// TODO : check for encoding defined in the input
	764	xmlDocDumpFormatMemoryEnc(bdoc, &btmps, &bsize, "UTF-8", 0);
	765	if (btmps != NULL){
	766	tmp = (char ) malloc ((bsize + 1) sizeof (char));
	767
	768	sprintf (tmp, "%s", (char*) btmps);
[745]	769
	770	//xmlFreeDoc (bdoc);
[621]	771
	772	map *btmp =
	773	getMap (tmpmaps->content, "Reference");
[917]	774	addToMap (tmpmaps->content, "Body", tmp);
[621]	775	if (btmp != NULL)
	776	{
[623]	777	addRequestToQueue(main_conf,hInternet,(char *) btmp->value,false);
[621]	778	InternetOpenUrl (hInternet,
	779	btmp->value,
	780	tmp,
	781	xmlStrlen(btmps),
	782	INTERNET_FLAG_NO_CACHE_WRITE,
[917]	783	0,
	784	*main_conf);
[627]	785	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	786	}
	787	xmlFree (btmps);
	788	free (tmp);
	789	break;
	790	}
	791	}
	792	cur4 = cur4->next;
	793	}
	794	}
	795	else
	796	if (xmlStrcasecmp
	797	(cur3->name,
	798	BAD_CAST "BodyReference") == 0)
	799	{
	800	xmlChar *val =
	801	xmlGetProp (cur3, BAD_CAST "href");
	802	HINTERNET bInternet, res1, res;
[917]	803	maps *tmpConf=createMaps("main");
	804	tmpConf->content=createMap("memory","load");
[621]	805	bInternet = InternetOpen (
	806	#ifndef WIN32
	807	(LPCTSTR)
	808	#endif
	809	"ZooWPSClient\0",
	810	INTERNET_OPEN_TYPE_PRECONFIG,
	811	NULL, NULL, 0);
[917]	812	#ifndef WIN32
[621]	813	if (!CHECK_INET_HANDLE (bInternet))
	814	fprintf (stderr,
	815	"WARNING : bInternet handle failed to initialize");
[917]	816	#endif
[621]	817	bInternet.waitingRequests[0] =
[917]	818	zStrdup ((char *) val);
[621]	819	res1 =
	820	InternetOpenUrl (&bInternet,
	821	bInternet.waitingRequests
	822	[0], NULL, 0,
	823	INTERNET_FLAG_NO_CACHE_WRITE,
[917]	824	0,
	825	tmpConf);
[621]	826	processDownloads (&bInternet);
[917]	827	freeMaps(&tmpConf);
	828	free(tmpConf);
[621]	829	char *tmp =
	830	(char *)
	831	malloc ((bInternet.ihandle[0].nDataLen +
	832	1) * sizeof (char));
	833	if (tmp == NULL)
	834	{
	835	return errorException (*main_conf,
	836	_
[725]	837	("Unable to allocate memory"),
[621]	838	"InternalError",
	839	NULL);
	840	}
	841	size_t bRead;
	842	InternetReadFile (bInternet.ihandle[0],
	843	(LPVOID) tmp,
	844	bInternet.
	845	ihandle[0].nDataLen,
	846	&bRead);
	847	tmp[bInternet.ihandle[0].nDataLen] = 0;
[917]	848	InternetCloseHandle(&bInternet);
	849	addToMap (tmpmaps->content, "Body", tmp);
[621]	850	map *btmp =
	851	getMap (tmpmaps->content, "href");
	852	if (btmp != NULL)
	853	{
[623]	854	addRequestToQueue(main_conf,hInternet,(char *) btmp->value,false);
[621]	855
	856	res =
	857	InternetOpenUrl (hInternet,
	858	btmp->value,
	859	tmp,
	860	strlen(tmp),
	861	INTERNET_FLAG_NO_CACHE_WRITE,
[917]	862	0,
	863	*main_conf);
[627]	864	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	865	}
	866	free (tmp);
[917]	867	xmlFree (val);
[621]	868	}
	869	}
	870	cur3 = cur3->next;
	871	}
	872	}
	873	else if (xmlStrcasecmp (cur2->name, BAD_CAST "Data") == 0)
	874	{
[745]	875	defineMissingIdentifier(main_conf,&tmpmaps);
[621]	876	xmlNodePtr cur4 = cur2->children;
[654]	877	if(vid==1){
	878	// Get every dataEncodingAttributes from a Data node:
	879	// mimeType, encoding, schema
	880	const char *coms[3] =
	881	{ "mimeType", "encoding", "schema" };
	882	for (l = 0; l < 3; l++){
	883	xmlChar *val =
[957]	884	//xmlGetProp (cur4, BAD_CAST coms[l]);
	885	xmlGetProp (cur2, BAD_CAST coms[l]); // knut : get attributes from the Data xml element, not it's children (the content)
[654]	886	if (val != NULL && strlen ((char *) val) > 0){
	887	if (tmpmaps->content != NULL)
	888	addToMap (tmpmaps->content,coms[l],(char *) val);
	889	else
	890	tmpmaps->content =
	891	createMap (coms[l],(char *) val);
	892	}
	893	xmlFree (val);
	894	}
	895	while (cur4 != NULL){
	896	while(cur4 != NULL &&
	897	cur4->type != XML_CDATA_SECTION_NODE &&
[802]	898	cur4->type != XML_TEXT_NODE &&
	899	cur4->type != XML_ELEMENT_NODE)
[654]	900	cur4=cur4->next;
	901	if(cur4!=NULL){
[802]	902	if (cur4->type == XML_ELEMENT_NODE)
	903	{
	904	xmlChar *mv;
	905	int buffersize;
	906	xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
	907	xmlDocSetRootElement (doc1, cur4);
	908	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	909	&buffersize,
	910	"utf-8", 0);
	911	if (tmpmaps->content != NULL)
	912	addToMap (tmpmaps->content, "value",
	913	(char *) mv);
	914	else
	915	tmpmaps->content =
	916	createMap ("value", (char *) mv);
	917	free(mv);
	918	}
	919	else{
[654]	920	if (tmpmaps->content != NULL)
	921	addToMap (tmpmaps->content, "value",
	922	(char *) cur4->content);
	923	else
	924	tmpmaps->content =
	925	createMap ("value", (char *) cur4->content);
[790]	926	}
[654]	927	cur4=cur4->next;
	928	}
	929	}
	930	}
	931
[621]	932	while (cur4 != NULL)
	933	{
	934	while (cur4 != NULL
	935	&& cur4->type != XML_ELEMENT_NODE)
	936	cur4 = cur4->next;
	937	if (cur4 == NULL)
	938	break;
	939	if (xmlStrcasecmp
	940	(cur4->name, BAD_CAST "LiteralData") == 0)
	941	{
	942	// Get every attribute from a LiteralData node
	943	// dataType , uom
	944	char *list[2];
	945	list[0] = zStrdup ("dataType");
	946	list[1] = zStrdup ("uom");
[622]	947	for (l = 0; l < 2; l++)
[621]	948	{
	949	xmlChar *val =
	950	xmlGetProp (cur4, BAD_CAST list[l]);
	951	if (val != NULL
	952	&& strlen ((char *) val) > 0)
	953	{
	954	if (tmpmaps->content != NULL)
	955	addToMap (tmpmaps->content, list[l],
	956	(char *) val);
	957	else
	958	tmpmaps->content =
	959	createMap (list[l], (char *) val);
[870]	960	xmlFree (val);
[621]	961	}
[870]	962	else{
	963	if(l==0){
	964	if (tmpmaps->content != NULL)
	965	addToMap (tmpmaps->content, list[l],
	966	"string");
	967	else
	968	tmpmaps->content =
	969	createMap (list[l],"string");
	970	}
	971	}
[621]	972	free (list[l]);
	973	}
	974	}
	975	else
	976	if (xmlStrcasecmp
	977	(cur4->name, BAD_CAST "ComplexData") == 0)
	978	{
	979	// Get every attribute from a Reference node
	980	// mimeType, encoding, schema
	981	const char *coms[3] =
	982	{ "mimeType", "encoding", "schema" };
[622]	983	for (l = 0; l < 3; l++)
[621]	984	{
	985	xmlChar *val =
	986	xmlGetProp (cur4, BAD_CAST coms[l]);
	987	if (val != NULL
	988	&& strlen ((char *) val) > 0)
	989	{
	990	if (tmpmaps->content != NULL)
	991	addToMap (tmpmaps->content, coms[l],
	992	(char *) val);
	993	else
	994	tmpmaps->content =
	995	createMap (coms[l], (char *) val);
[870]	996	xmlFree (val);
[621]	997	}
	998	}
	999	}
	1000
	1001	map *test = getMap (tmpmaps->content, "encoding");
	1002	if (test == NULL)
[917]	1003	{
[621]	1004	if (tmpmaps->content != NULL)
	1005	addToMap (tmpmaps->content, "encoding",
	1006	"utf-8");
	1007	else
	1008	tmpmaps->content =
	1009	createMap ("encoding", "utf-8");
	1010	test = getMap (tmpmaps->content, "encoding");
	1011	}
	1012
[917]	1013	if (getMap(tmpmaps->content,"dataType")==NULL && test!=NULL && strcasecmp (test->value, "base64") != 0)
	1014	{
	1015	xmlChar *mv = NULL;
	1016	/*if(cur4!=NULL && cur4->xmlChildrenNode!=NULL)
	1017	xmlChar *mv = xmlNodeListGetString (doc,
	1018	cur4->xmlChildrenNode,
	1019	1);*/
[621]	1020	map *ltmp =
	1021	getMap (tmpmaps->content, "mimeType");
[917]	1022	if (/*mv == NULL
	1023	\|\|*/
[621]	1024	(xmlStrcasecmp
	1025	(cur4->name, BAD_CAST "ComplexData") == 0
	1026	&& (ltmp == NULL
	1027	\|\| strncasecmp (ltmp->value,
	1028	"text/xml", 8) == 0)))
	1029	{
	1030	xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
	1031	int buffersize;
	1032	xmlNodePtr cur5 = cur4->children;
	1033	while (cur5 != NULL
	1034	&& cur5->type != XML_ELEMENT_NODE
[654]	1035	&& cur5->type != XML_CDATA_SECTION_NODE)
[621]	1036	cur5 = cur5->next;
	1037	if (cur5 != NULL
	1038	&& cur5->type != XML_CDATA_SECTION_NODE)
	1039	{
	1040	xmlDocSetRootElement (doc1, cur5);
	1041	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	1042	&buffersize,
[703]	1043	"utf-8", 0);
[866]	1044	xmlFreeDoc (doc1);
[621]	1045	}
	1046	else
	1047	{
	1048	if (cur5 != NULL
	1049	&& cur5->type == XML_CDATA_SECTION_NODE){
[745]	1050	xmlDocPtr doc2 = xmlReadMemory((const char*)cur5->content,xmlStrlen(cur5->content),
	1051	"input_content.xml", NULL, XML_PARSE_RECOVER);
	1052	xmlDocDumpFormatMemoryEnc (doc2, &mv,
[621]	1053	&buffersize,
[703]	1054	"utf-8", 0);
[621]	1055	xmlFreeDoc (doc2);
	1056	}
	1057	}
[745]	1058	addIntToMap (tmpmaps->content, "size",
	1059	buffersize);
[621]	1060	}else{
[917]	1061
[866]	1062	if(xmlStrcasecmp
	1063	(cur4->name, BAD_CAST "BoundingBoxData") == 0){
	1064	xmlDocPtr doc1 = xmlNewDoc(BAD_CAST "1.0");
	1065	int buffersize;
	1066	xmlDocSetRootElement(doc1,cur4);
	1067	xmlDocDumpFormatMemoryEnc(doc1,&mv,
	1068	&buffersize,
	1069	"utf-8",0);
	1070	addIntToMap (tmpmaps->content, "size",
	1071	buffersize);
	1072	xmlParseBoundingBox(main_conf,&tmpmaps->content,doc1);
	1073	}else{
	1074	xmlNodePtr cur5 = cur4->children;
	1075	while (cur5 != NULL
[917]	1076	&& cur5->type != XML_ELEMENT_NODE
	1077	&& cur5->type != XML_TEXT_NODE
[866]	1078	&& cur5->type != XML_CDATA_SECTION_NODE)
	1079	cur5 = cur5->next;
	1080	if (cur5 != NULL
[917]	1081	&& cur5->type != XML_CDATA_SECTION_NODE
	1082	&& cur5->type != XML_TEXT_NODE)
	1083	{
	1084	xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
	1085	int buffersize;
	1086	xmlDocSetRootElement (doc1, cur5);
	1087	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	1088	&buffersize,
	1089	"utf-8", 0);
	1090	addIntToMap (tmpmaps->content, "size",
	1091	buffersize);
	1092	}
[939]	1093	else if (cur5 != NULL){
[946]	1094	map* handleText=getMapFromMaps(*main_conf,"main","handleText");
	1095	if(handleText!=NULL && strcasecmp(handleText->value,"true")==0 && ltmp!= NULL && strstr(ltmp->value,"text/")!=NULL){
[939]	1096	xmlChar *tmp = xmlNodeListGetRawString (doc,
	1097	cur4->xmlChildrenNode,
	1098	0);
	1099	addToMap (tmpmaps->content, "value",
	1100	(char *) tmp);
	1101	xmlFree (tmp);
	1102	}else{
	1103	while(cur5!=NULL && cur5->type != XML_CDATA_SECTION_NODE)
	1104	cur5=cur5->next;
	1105	xmlFree(mv);
	1106	if(cur5!=NULL && cur5->content!=NULL){
	1107	mv=xmlStrdup(cur5->content);
	1108	}
	1109	}
[866]	1110	}
[621]	1111	}
	1112	}
	1113	if (mv != NULL)
	1114	{
	1115	addToMap (tmpmaps->content, "value",
[703]	1116	(char*) mv);
[621]	1117	xmlFree (mv);
	1118	}
	1119	}
	1120	else
	1121	{
[869]	1122	xmlNodePtr cur5 = cur4->children;
	1123	while (cur5 != NULL
	1124	&& cur5->type != XML_CDATA_SECTION_NODE)
	1125	cur5 = cur5->next;
	1126	if (cur5 != NULL
	1127	&& cur5->type == XML_CDATA_SECTION_NODE)
	1128	{
	1129	addToMap (tmpmaps->content,
	1130	"value",
	1131	(char *) cur5->content);
	1132	}
	1133	else{
	1134	if(cur4->xmlChildrenNode!=NULL){
	1135	xmlChar *tmp = xmlNodeListGetRawString (doc,
	1136	cur4->xmlChildrenNode,
	1137	0);
	1138	addToMap (tmpmaps->content, "value",
	1139	(char *) tmp);
	1140	xmlFree (tmp);
	1141	}
	1142	}
[621]	1143	}
[703]	1144
[621]	1145	cur4 = cur4->next;
	1146	}
	1147	}
	1148	cur2 = cur2->next;
[631]	1149	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE){
	1150	cur2 = cur2->next;
	1151	}
[621]	1152	}
[917]	1153	if(memory!=NULL && strncasecmp(memory->value,"load",4)!=0)
	1154	if(getMap(tmpmaps->content,"to_load")==NULL){
	1155	addToMap(tmpmaps->content,"to_load","false");
	1156	}
[621]	1157	{
[745]	1158	map* test=getMap(tmpmaps->content,"value");
[790]	1159	if(test==NULL && tmpmaps->child==NULL)
[745]	1160	addToMap(tmpmaps->content,"value","");
[790]	1161	maps testPresence = getMaps (request_output, tmpmaps->name);
	1162	maps cursor=request_output;
	1163	while(testPresence == NULL && cursor!=NULL){
	1164	if(cursor->child!=NULL){
	1165	testPresence = getMaps (cursor->child, tmpmaps->name);
	1166	}
	1167	cursor=cursor->next;
	1168	}
[621]	1169	if (testPresence != NULL)
	1170	{
	1171	elements *elem = getElements (s->inputs, tmpmaps->name);
[790]	1172	elements *cursor=s->inputs;
	1173	while(elem == NULL && cursor!=NULL){
	1174	if(cursor->child!=NULL){
	1175	elem = getElements (cursor->child, tmpmaps->name);
	1176	}
	1177	cursor=cursor->next;
	1178	}
[621]	1179	if (elem != NULL)
	1180	{
	1181	if (appendMapsToMaps
[790]	1182	(*main_conf, testPresence, tmpmaps, elem) < 0)
[621]	1183	{
	1184	return errorException (*main_conf,
	1185	_("Unable to append maps to maps."),
	1186	"InternalError",
	1187	NULL);
	1188	}
	1189	}
	1190	}
[917]	1191	else{
[623]	1192	addMapsToMaps (request_output, tmpmaps);
[917]	1193	}
[621]	1194	}
	1195	freeMaps (&tmpmaps);
	1196	free (tmpmaps);
	1197	tmpmaps = NULL;
	1198	}
	1199	}
	1200	return 1;
	1201	}
	1202
	1203	/**
[866]	1204	* Parse a BoundingBoxData node
	1205	*
	1206	* http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd: BoundingBoxType
	1207	*
	1208	* A map to store boundingbox information will contain:
	1209	* - LowerCorner : double double (minimum within this bounding box)
	1210	* - UpperCorner : double double (maximum within this bounding box)
	1211	* - crs : URI (Reference to definition of the CRS)
	1212	* - dimensions : int
	1213	*
	1214	* @param main_conf the conf maps containing the main.cfg settings
	1215	* @param request_inputs the map storing KVP raw value
	1216	* @param doc the xmlDocPtr containing the BoudingoxData node
	1217	* @return a map containing all the bounding box keys
	1218	*/
	1219	int xmlParseBoundingBox(maps main_conf,map current_input,xmlDocPtr doc){
	1220	xmlNode *root_element = xmlDocGetRootElement(doc);
	1221	for(xmlAttrPtr attr = root_element->properties; NULL != attr; attr = attr->next){
	1222	xmlChar *val = xmlGetProp (root_element, BAD_CAST attr->name);
	1223	addToMap(current_input,(char)attr->name,(char*)val);
	1224	xmlFree(val);
	1225	xmlNodePtr cur = root_element->children;
	1226	while(cur!=NULL && cur->type != XML_ELEMENT_NODE)
	1227	cur=cur->next;
	1228	while(cur!=NULL && cur->type==XML_ELEMENT_NODE){
	1229	xmlChar *val =
	1230	xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
	1231	addToMap(current_input,(char)cur->name,(char*)val);
	1232	cur=cur->next;
	1233	xmlFree(val);
	1234	while(cur!=NULL && cur->type != XML_ELEMENT_NODE)
	1235	cur=cur->next;
	1236	}
	1237	}
[889]	1238	return 0;
[866]	1239	}
	1240
	1241	/**
[654]	1242	* Parse outputs from XML nodes and store them in a maps (WPS version 2.0.0).
	1243	*
	1244	* @param main_conf the conf maps containing the main.cfg settings
	1245	* @param request_inputs the map storing KVP raw value
	1246	* @param request_output the maps to store the KVP pairs
	1247	* @param doc the xmlDocPtr containing the original request
	1248	* @param cur the xmlNodePtr corresponding to the ResponseDocument or RawDataOutput XML node
	1249	* @param raw true if the node is RawDataOutput, false in case of ResponseDocument
	1250	* @return 0 on success, -1 on failure
	1251	*/
	1252	int xmlParseOutputs2(maps main_conf,map request_inputs,maps** request_output,xmlDocPtr doc,xmlNodeSet* nodes){
	1253	int k = 0;
	1254	int l = 0;
	1255	for (k=0; k < nodes->nodeNr; k++){
	1256	maps *tmpmaps = NULL;
	1257	xmlNodePtr cur = nodes->nodeTab[k];
	1258	if (cur->type == XML_ELEMENT_NODE){
[790]	1259	maps *tmpmaps = NULL;
[654]	1260	xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
	1261	if(val!=NULL)
[790]	1262	tmpmaps = createMaps((char *)val);
[654]	1263	else
[790]	1264	tmpmaps = createMaps("unknownIdentifier");
[654]	1265	const char ress[4][13] =
	1266	{ "mimeType", "encoding", "schema", "transmission" };
[917]	1267	xmlFree (val);
[654]	1268	for (l = 0; l < 4; l++){
	1269	val = xmlGetProp (cur, BAD_CAST ress[l]);
	1270	if (val != NULL && strlen ((char *) val) > 0)
	1271	{
	1272	if (tmpmaps->content != NULL)
	1273	addToMap (tmpmaps->content, ress[l],
	1274	(char *) val);
	1275	else
	1276	tmpmaps->content =
	1277	createMap (ress[l], (char *) val);
	1278	if(l==3 && strncasecmp((char*)val,"reference",xmlStrlen(val))==0)
	1279	addToMap (tmpmaps->content,"asReference","true");
	1280	}
	1281	xmlFree (val);
	1282	}
[790]	1283	if(cur->children!=NULL){
	1284	xmlNodePtr ccur = cur->children;
	1285	while (ccur != NULL){
	1286	if(ccur->type == XML_ELEMENT_NODE){
[917]	1287	char xpathExpr=(char)malloc(66+strlen(tmpmaps->name));
	1288	sprintf(xpathExpr,"//[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);
[790]	1289	xmlXPathObjectPtr tmpsptr = extractFromDoc (doc, xpathExpr);
	1290	xmlNodeSet* cnodes = tmpsptr->nodesetval;
	1291	xmlParseOutputs2(main_conf,request_inputs,&tmpmaps->child,doc,cnodes);
[917]	1292	xmlXPathFreeObject (tmpsptr);
	1293	free(xpathExpr);
[790]	1294	break;
	1295	}
	1296	ccur = ccur->next;
	1297	}
	1298	}
	1299	if (*request_output == NULL){
[654]	1300	*request_output = dupMaps(&tmpmaps);
[790]	1301	}
	1302	else{
[654]	1303	addMapsToMaps(request_output,tmpmaps);
[790]	1304	}
	1305	freeMaps(&tmpmaps);
	1306	free(tmpmaps);
[654]	1307	}
	1308	}
[680]	1309	return 0;
[654]	1310	}
	1311
	1312	/**
[621]	1313	* Parse outputs from XML nodes and store them in a maps.
	1314	*
	1315	* @param main_conf the conf maps containing the main.cfg settings
	1316	* @param request_inputs the map storing KVP raw value
	1317	* @param request_output the maps to store the KVP pairs
	1318	* @param doc the xmlDocPtr containing the original request
	1319	* @param cur the xmlNodePtr corresponding to the ResponseDocument or RawDataOutput XML node
	1320	* @param raw true if the node is RawDataOutput, false in case of ResponseDocument
	1321	* @return 0 on success, -1 on failure
	1322	*/
	1323	int xmlParseOutputs(maps main_conf,map request_inputs,maps** request_output,xmlDocPtr doc,xmlNodePtr cur,bool raw){
[622]	1324	int l=0;
[621]	1325	if( raw == true)
	1326	{
	1327	addToMap (*request_inputs, "RawDataOutput", "");
	1328	if (cur->type == XML_ELEMENT_NODE)
	1329	{
	1330
[790]	1331	maps *tmpmaps = createMaps("unknownIdentifier");
[621]	1332	if (tmpmaps == NULL)
	1333	{
[725]	1334	return errorException (*main_conf, _("Unable to allocate memory"),
[621]	1335	"InternalError", NULL);
	1336	}
	1337
	1338	// Get every attribute from a RawDataOutput node
	1339	// mimeType, encoding, schema, uom
	1340	const char *outs[4] =
	1341	{ "mimeType", "encoding", "schema", "uom" };
[622]	1342	for (l = 0; l < 4; l++)
[621]	1343	{
	1344	xmlChar *val = xmlGetProp (cur, BAD_CAST outs[l]);
	1345	if (val != NULL)
	1346	{
	1347	if (strlen ((char *) val) > 0)
	1348	{
	1349	if (tmpmaps->content != NULL)
	1350	addToMap (tmpmaps->content, outs[l],
	1351	(char *) val);
	1352	else
	1353	tmpmaps->content =
	1354	createMap (outs[l], (char *) val);
	1355	}
	1356	xmlFree (val);
	1357	}
	1358	}
	1359	xmlNodePtr cur2 = cur->children;
	1360	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	1361	cur2 = cur2->next;
	1362	while (cur2 != NULL)
	1363	{
	1364	if (xmlStrncasecmp
	1365	(cur2->name, BAD_CAST "Identifier",
	1366	xmlStrlen (cur2->name)) == 0)
	1367	{
	1368	xmlChar *val =
	1369	xmlNodeListGetString (NULL, cur2->xmlChildrenNode, 1);
	1370	free (tmpmaps->name);
	1371	tmpmaps->name = zStrdup ((char *) val);
	1372	xmlFree (val);
	1373	}
	1374	cur2 = cur2->next;
	1375	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	1376	cur2 = cur2->next;
	1377	}
	1378	if (*request_output == NULL)
	1379	*request_output = dupMaps (&tmpmaps);
	1380	else
[623]	1381	addMapsToMaps (request_output, tmpmaps);
[621]	1382	if (tmpmaps != NULL)
	1383	{
	1384	freeMaps (&tmpmaps);
	1385	free (tmpmaps);
	1386	tmpmaps = NULL;
	1387	}
	1388	}
	1389	}
	1390	else
	1391	{
	1392	addToMap (*request_inputs, "ResponseDocument", "");
	1393
	1394	if (cur->type == XML_ELEMENT_NODE) {
	1395	// Get every attribute: storeExecuteResponse, lineage, status
	1396	const char *ress[3] =
	1397	{ "storeExecuteResponse", "lineage", "status" };
	1398	xmlChar *val;
[622]	1399	for (l = 0; l < 3; l++)
[621]	1400	{
	1401	val = xmlGetProp (cur, BAD_CAST ress[l]);
	1402	if (val != NULL && strlen ((char *) val) > 0)
	1403	{
	1404	addToMap (request_inputs, ress[l], (char ) val);
	1405	}
	1406	xmlFree (val);
	1407	}
	1408
	1409	xmlNodePtr cur1 = cur->children;
	1410	while (cur1 != NULL) // iterate over Output nodes
	1411	{
	1412	if (cur1->type != XML_ELEMENT_NODE \|\|
	1413	xmlStrncasecmp(cur1->name, BAD_CAST "Output",
	1414	xmlStrlen (cur1->name)) != 0) {
	1415	cur1 = cur1->next;
	1416	continue;
	1417	}
	1418
[790]	1419	maps *tmpmaps = createMaps("unknownIdentifier"); // one per Output node
[621]	1420	if (tmpmaps == NULL) {
	1421	return errorException (*main_conf,
	1422	_
[725]	1423	("Unable to allocate memory"),
[621]	1424	"InternalError", NULL);
	1425	}
	1426
	1427	xmlNodePtr elems = cur1->children;
	1428
	1429	while (elems != NULL) {
	1430
	1431	// Identifier
	1432	if (xmlStrncasecmp
	1433	(elems->name, BAD_CAST "Identifier",
	1434	xmlStrlen (elems->name)) == 0)
	1435	{
	1436	xmlChar *val =
	1437	xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
	1438
	1439	free(tmpmaps->name);
	1440	tmpmaps->name = zStrdup ((char *) val);
	1441	if (tmpmaps->content == NULL) {
	1442	tmpmaps->content = createMap("Identifier", zStrdup ((char *) val));
	1443	}
	1444	else {
	1445	addToMap(tmpmaps->content, "Identifier", zStrdup ((char *) val));
	1446	}
	1447
	1448	map* tt = getMap (*request_inputs, "ResponseDocument");
	1449	if (strlen(tt->value) == 0) {
	1450	addToMap (*request_inputs, "ResponseDocument",
	1451	(char *) val);
	1452	}
	1453	else {
	1454	char* tmp = (char*) malloc((strlen(tt->value) + 1
	1455	+ strlen((char) val) + 1) sizeof(char));
	1456	sprintf (tmp, "%s;%s", tt->value, (char *) val);
	1457	free(tt->value);
	1458	tt->value = tmp;
	1459	}
	1460	xmlFree (val);
	1461	}
	1462
	1463	// Title, Abstract
	1464	else if (xmlStrncasecmp(elems->name, BAD_CAST "Title",
	1465	xmlStrlen (elems->name)) == 0
	1466	\|\| xmlStrncasecmp(elems->name, BAD_CAST "Abstract",
	1467	xmlStrlen (elems->name)) == 0)
	1468	{
	1469	xmlChar *val =
	1470	xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
	1471
	1472	if (tmpmaps->content == NULL) {
	1473	tmpmaps->content = createMap((char) elems->name, zStrdup ((char ) val));
	1474	}
	1475	else {
	1476	addToMap(tmpmaps->content, (char) elems->name, zStrdup ((char ) val));
	1477	}
	1478	xmlFree (val);
	1479	}
	1480	elems = elems->next;
	1481	}
	1482
	1483	// Get every attribute from an Output node:
	1484	// mimeType, encoding, schema, uom, asReference
	1485	const char *outs[5] =
	1486	{ "mimeType", "encoding", "schema", "uom", "asReference" };
	1487
[622]	1488	for (l = 0; l < 5; l++) {
[621]	1489	xmlChar *val = xmlGetProp (cur1, BAD_CAST outs[l]);
	1490	if (val != NULL && xmlStrlen(val) > 0) {
	1491	if (tmpmaps->content != NULL) {
	1492	addToMap (tmpmaps->content, outs[l], (char *) val);
	1493	}
	1494	else {
	1495	tmpmaps->content = createMap (outs[l], (char *) val);
	1496	}
	1497	}
	1498	xmlFree (val);
	1499	}
	1500
	1501	if (*request_output == NULL) {
	1502	*request_output = tmpmaps;
	1503	}
	1504	else if (getMaps(*request_output, tmpmaps->name) != NULL) {
	1505	return errorException (*main_conf,
	1506	_
	1507	("Duplicate <Output> elements in WPS Execute request"),
	1508	"InternalError", NULL);
	1509	}
	1510	else {
	1511	maps* mptr = *request_output;
	1512	while (mptr->next != NULL) {
	1513	mptr = mptr->next;
	1514	}
	1515	mptr->next = tmpmaps;
	1516	}
	1517	cur1 = cur1->next;
	1518	}
	1519	}
	1520	}
	1521	return 1;
	1522	}
	1523
	1524	/**
[781]	1525	* Parse XML request and store information in maps.
[621]	1526	*
	1527	* @param main_conf the conf maps containing the main.cfg settings
	1528	* @param post the string containing the XML request
	1529	* @param request_inputs the map storing KVP raw value
	1530	* @param s the service
	1531	* @param inputs the maps to store the KVP pairs
	1532	* @param outputs the maps to store the KVP pairs
	1533	* @param hInternet the HINTERNET queue to add potential requests
	1534	* @return 0 on success, -1 on failure
	1535	*/
	1536	int xmlParseRequest(maps** main_conf,const char* post,map** request_inputs,service* s,maps inputs,maps outputs,HINTERNET* hInternet){
[654]	1537
	1538	map* version=getMapFromMaps(*main_conf,"main","rversion");
	1539	int vid=getVersionId(version->value);
	1540
[621]	1541	xmlInitParser ();
[917]	1542	xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER);
[621]	1543
	1544	/**
	1545	* Extract Input nodes from the XML Request.
	1546	*/
	1547	xmlXPathObjectPtr tmpsptr =
[654]	1548	extractFromDoc (doc, (vid==0?"///[local-name()='Input']":"//*[local-name()='Input']"));
[621]	1549	xmlNodeSet *tmps = tmpsptr->nodesetval;
[654]	1550	if(tmps==NULL \|\| xmlParseInputs(main_conf,s,inputs,doc,tmps,hInternet)<0){
[621]	1551	xmlXPathFreeObject (tmpsptr);
	1552	xmlFreeDoc (doc);
	1553	xmlCleanupParser ();
	1554	return -1;
	1555	}
	1556	xmlXPathFreeObject (tmpsptr);
	1557
[654]	1558	if(vid==1){
	1559	tmpsptr =
	1560	extractFromDoc (doc, "/*[local-name()='Execute']");
	1561	bool asRaw = false;
	1562	tmps = tmpsptr->nodesetval;
	1563	if(tmps->nodeNr > 0){
	1564	int k = 0;
	1565	for (k=0; k < tmps->nodeNr; k++){
	1566	maps *tmpmaps = NULL;
	1567	xmlNodePtr cur = tmps->nodeTab[k];
	1568	if (cur->type == XML_ELEMENT_NODE){
	1569	xmlChar *val = xmlGetProp (cur, BAD_CAST "mode");
	1570	if(val!=NULL)
	1571	addToMap(request_inputs,"mode",(char)val);
	1572	else
	1573	addToMap(*request_inputs,"mode","auto");
[917]	1574	xmlFree(val);
[654]	1575	val = xmlGetProp (cur, BAD_CAST "response");
	1576	if(val!=NULL){
	1577	addToMap(request_inputs,"response",(char)val);
	1578	if(strncasecmp((char*)val,"raw",xmlStrlen(val))==0)
	1579	addToMap(*request_inputs,"RawDataOutput","");
	1580	else
	1581	addToMap(*request_inputs,"ResponseDocument","");
	1582	}
	1583	else{
	1584	addToMap(*request_inputs,"response","document");
	1585	addToMap(*request_inputs,"ResponseDocument","");
	1586	}
[917]	1587	xmlFree(val);
[654]	1588	}
	1589	}
[621]	1590	}
[654]	1591	xmlXPathFreeObject (tmpsptr);
	1592	tmpsptr =
	1593	extractFromDoc (doc, "//[local-name()='Output']");
	1594	tmps = tmpsptr->nodesetval;
	1595	if(tmps->nodeNr > 0){
	1596	if(xmlParseOutputs2(main_conf,request_inputs,outputs,doc,tmps)<0){
	1597	xmlXPathFreeObject (tmpsptr);
	1598	xmlFreeDoc (doc);
	1599	xmlCleanupParser ();
	1600	return -1;
	1601	}
[621]	1602	}
	1603	}
[654]	1604	else{
	1605	// Extract ResponseDocument / RawDataOutput from the XML Request
	1606	tmpsptr =
	1607	extractFromDoc (doc, "///*[local-name()='ResponseDocument']");
	1608	bool asRaw = false;
	1609	tmps = tmpsptr->nodesetval;
	1610	if (tmps->nodeNr == 0)
	1611	{
	1612	xmlXPathFreeObject (tmpsptr);
	1613	tmpsptr =
	1614	extractFromDoc (doc, "///*[local-name()='RawDataOutput']");
	1615	tmps = tmpsptr->nodesetval;
	1616	asRaw = true;
	1617	}
	1618	if(tmps->nodeNr != 0){
	1619	if(xmlParseOutputs(main_conf,request_inputs,outputs,doc,tmps->nodeTab[0],asRaw)<0){
	1620	xmlXPathFreeObject (tmpsptr);
	1621	xmlFreeDoc (doc);
	1622	xmlCleanupParser ();
	1623	return -1;
	1624	}
	1625	}
	1626	}
[621]	1627	xmlXPathFreeObject (tmpsptr);
	1628	xmlFreeDoc (doc);
	1629	xmlCleanupParser ();
	1630	return 1;
	1631	}
	1632
	1633	/**
[781]	1634	* Parse request and store information in maps.
[621]	1635	*
	1636	* @param main_conf the conf maps containing the main.cfg settings
	1637	* @param post the string containing the XML request
	1638	* @param request_inputs the map storing KVP raw value
	1639	* @param s the service
	1640	* @param inputs the maps to store the KVP pairs
	1641	* @param outputs the maps to store the KVP pairs
	1642	* @param hInternet the HINTERNET queue to add potential requests
	1643	* @return 0 on success, -1 on failure
	1644	* @see kvpParseOutputs,kvpParseInputs,xmlParseRequest
	1645	*/
	1646	int parseRequest(maps main_conf,map request_inputs,service* s,maps inputs,maps outputs,HINTERNET* hInternet){
	1647	map *postRequest = NULL;
	1648	postRequest = getMap (*request_inputs, "xrequest");
	1649	if (postRequest == NULLMAP)
	1650	{
	1651	if(kvpParseOutputs(main_conf,*request_inputs,outputs)<0){
	1652	return -1;
	1653	}
	1654	if(kvpParseInputs(main_conf,s,*request_inputs,inputs,hInternet)<0){
	1655	return -1;
	1656	}
	1657	}
	1658	else
	1659	{
	1660	//Parse XML request
	1661	if(xmlParseRequest(main_conf,postRequest->value,request_inputs,s,inputs,outputs,hInternet)<0){
	1662	return -1;
	1663	}
	1664	}
	1665	return 1;
	1666	}
	1667
	1668	/**
	1669	* Ensure that each requested arguments are present in the request
	1670	* DataInputs and ResponseDocument / RawDataOutput. Potentially run
	1671	* http requests from the queue in parallel.
	1672	* For optional inputs add default values defined in the ZCFG file.
	1673	*
	1674	* @param main_conf
	1675	* @param s
	1676	* @param original_request
	1677	* @param request_inputs
	1678	* @param request_outputs
	1679	* @param hInternet
	1680	*
	1681	* @see runHttpRequests
	1682	*/
	1683	int validateRequest(maps** main_conf,service* s,map* original_request, maps request_inputs,maps request_outputs,HINTERNET* hInternet){
	1684
[797]	1685	map* errI0=NULL;
	1686	runHttpRequests (main_conf, request_inputs, hInternet,&errI0);
	1687	if(errI0!=NULL){
	1688	printExceptionReportResponse (*main_conf, errI0);
	1689	InternetCloseHandle (hInternet);
	1690	return -1;
	1691	}
[621]	1692	InternetCloseHandle (hInternet);
	1693
[797]	1694
[621]	1695	map* errI=NULL;
	1696	char dfv = addDefaultValues (request_inputs, s->inputs, main_conf, 0,&errI);
	1697
	1698	maps ptr = request_inputs;
	1699	while (ptr != NULL)
	1700	{
	1701	map *tmp0 = getMap (ptr->content, "size");
	1702	map *tmp1 = getMap (ptr->content, "maximumMegabytes");
	1703	if (tmp1 != NULL && tmp0 != NULL)
	1704	{
	1705	float i = atof (tmp0->value) / 1048576.0;
	1706	if (i >= atoi (tmp1->value))
	1707	{
	1708	char tmps[1024];
	1709	map *tmpe = createMap ("code", "FileSizeExceeded");
	1710	snprintf (tmps, 1024,
	1711	_
	1712	("The <%s> parameter has a size limit (%s MB) defined in the ZOO ServicesProvider configuration file, but the reference you provided exceeds this limit (%f MB)."),
	1713	ptr->name, tmp1->value, i);
	1714	addToMap (tmpe, "locator", ptr->name);
	1715	addToMap (tmpe, "text", tmps);
	1716	printExceptionReportResponse (*main_conf, tmpe);
	1717	freeMap (&tmpe);
	1718	free (tmpe);
	1719	return -1;
	1720	}
	1721	}
	1722	ptr = ptr->next;
	1723	}
	1724
	1725	map* errO=NULL;
	1726	char *dfv1 =
	1727	addDefaultValues (request_outputs, s->outputs, *main_conf, 1,&errO);
[790]	1728
[621]	1729	if (strcmp (dfv1, "") != 0 \|\| strcmp (dfv, "") != 0)
	1730	{
	1731	char tmps[1024];
	1732	map *tmpe = NULL;
	1733	if (strcmp (dfv, "") != 0)
	1734	{
	1735	tmpe = createMap ("code", "MissingParameterValue");
	1736	int nb=0;
	1737	int length=1;
	1738	map* len=getMap(errI,"length");
	1739	if(len!=NULL)
	1740	length=atoi(len->value);
	1741	for(nb=0;nb<length;nb++){
	1742	map* errp=getMapArray(errI,"value",nb);
	1743	snprintf (tmps, 1024,
	1744	_
	1745	("The <%s> argument was not specified in DataInputs but is required according to the ZOO ServicesProvider configuration file."),
	1746	errp->value);
	1747	setMapArray (tmpe, "locator", nb , errp->value);
	1748	setMapArray (tmpe, "text", nb , tmps);
	1749	setMapArray (tmpe, "code", nb , "MissingParameterValue");
	1750	}
	1751	}
	1752	if (strcmp (dfv1, "") != 0)
	1753	{
	1754	int ilength=0;
	1755	if(tmpe==NULL)
	1756	tmpe = createMap ("code", "InvalidParameterValue");
	1757	else{
	1758	map* len=getMap(tmpe,"length");
	1759	if(len!=NULL)
	1760	ilength=atoi(len->value);
	1761	}
	1762	int nb=0;
	1763	int length=1;
	1764	map* len=getMap(errO,"length");
	1765	if(len!=NULL)
	1766	length=atoi(len->value);
	1767	for(nb=0;nb<length;nb++){
	1768	map* errp=getMapArray(errO,"value",nb);
	1769	snprintf (tmps, 1024,
	1770	_
	1771	("The <%s> argument specified as %s identifier was not recognized (not defined in the ZOO Configuration File)."),
	1772	errp->value,
	1773	((getMap(original_request,"RawDataOutput")!=NULL)?"RawDataOutput":"ResponseDocument"));
	1774	setMapArray (tmpe, "locator", nb+ilength , errp->value);
	1775	setMapArray (tmpe, "text", nb+ilength , tmps);
	1776	setMapArray (tmpe, "code", nb+ilength , "InvalidParameterValue");
	1777	}
	1778	}
	1779	printExceptionReportResponse (*main_conf, tmpe);
	1780	if(errI!=NULL){
	1781	freeMap(&errI);
	1782	free(errI);
	1783	}
	1784	if(errO!=NULL){
	1785	freeMap(&errO);
	1786	free(errO);
	1787	}
	1788	freeMap (&tmpe);
	1789	free (tmpe);
	1790	return -1;
	1791	}
	1792	maps tmpReqI = request_inputs;
	1793	while (tmpReqI != NULL)
	1794	{
	1795	char name[1024];
	1796	if (getMap (tmpReqI->content, "isFile") != NULL)
	1797	{
	1798	if (cgiFormFileName (tmpReqI->name, name, sizeof (name)) ==
	1799	cgiFormSuccess)
	1800	{
	1801	int BufferLen = 1024;
	1802	cgiFilePtr file;
	1803	int targetFile;
[794]	1804	char *storageNameOnServer;
	1805	char *fileNameOnServer;
[621]	1806	char contentType[1024];
	1807	char buffer[1024];
	1808	char *tmpStr = NULL;
	1809	int size;
	1810	int got, t;
	1811	map path = getMapFromMaps (main_conf, "main", "tmpPath");
	1812	cgiFormFileSize (tmpReqI->name, &size);
	1813	cgiFormFileContentType (tmpReqI->name, contentType,
	1814	sizeof (contentType));
	1815	if (cgiFormFileOpen (tmpReqI->name, &file) == cgiFormSuccess)
	1816	{
	1817	t = -1;
	1818	while (1)
	1819	{
	1820	tmpStr = strstr (name + t + 1, "\\");
	1821	if (NULL == tmpStr)
	1822	tmpStr = strstr (name + t + 1, "/");
	1823	if (NULL != tmpStr)
	1824	t = (int) (tmpStr - name);
	1825	else
	1826	break;
	1827	}
[794]	1828	fileNameOnServer=(char)malloc((strlen(name) - t - 1 )sizeof(char));
[621]	1829	strcpy (fileNameOnServer, name + t + 1);
	1830
[794]	1831	storageNameOnServer=(char)malloc((strlen(path->value) + strlen(fileNameOnServer) + 2)sizeof(char));
[621]	1832	sprintf (storageNameOnServer, "%s/%s", path->value,
	1833	fileNameOnServer);
	1834	#ifdef DEBUG
	1835	fprintf (stderr, "Name on server %s\n",
	1836	storageNameOnServer);
	1837	fprintf (stderr, "fileNameOnServer: %s\n",
	1838	fileNameOnServer);
	1839	#endif
	1840	targetFile =
[917]	1841	zOpen (storageNameOnServer, O_RDWR \| O_CREAT \| O_TRUNC,
[621]	1842	S_IRWXU \| S_IRGRP \| S_IROTH);
	1843	if (targetFile < 0)
	1844	{
	1845	#ifdef DEBUG
	1846	fprintf (stderr, "could not create the new file,%s\n",
	1847	fileNameOnServer);
	1848	#endif
	1849	}
	1850	else
	1851	{
	1852	while (cgiFormFileRead (file, buffer, BufferLen, &got)
	1853	== cgiFormSuccess)
	1854	{
	1855	if (got > 0)
	1856	write (targetFile, buffer, got);
	1857	}
	1858	}
	1859	addToMap (tmpReqI->content, "lref", storageNameOnServer);
	1860	cgiFormFileClose (file);
[917]	1861	zClose (targetFile);
[794]	1862	free(fileNameOnServer);
	1863	free(storageNameOnServer);
[621]	1864	#ifdef DEBUG
	1865	fprintf (stderr, "File \"%s\" has been uploaded",
	1866	fileNameOnServer);
	1867	#endif
	1868	}
	1869	}
	1870	}
	1871	tmpReqI = tmpReqI->next;
	1872	}
	1873
	1874	ensureDecodedBase64 (request_inputs);
	1875	return 1;
	1876	}
[640]	1877
	1878
	1879	/**
	1880	* Verify if a parameter value is valid.
	1881	*
	1882	* @param request the request map
	1883	* @param res the error map potentially generated
	1884	* @param toCheck the parameter to use
	1885	* @param avalues the acceptable values (or null if testing only for presence)
	1886	* @param mandatory verify the presence of the parameter if mandatory > 0
	1887	*/
	1888	void checkValidValue(map* request,map** res,const char* toCheck,const char** avalues,int mandatory){
	1889	map* lres=*res;
	1890	map* r_inputs = getMap (request,toCheck);
	1891	if (r_inputs == NULL){
	1892	if(mandatory>0){
[939]	1893	const char *replace=_("Mandatory parameter <%s> was not specified");
[640]	1894	char message=(char)malloc((strlen(replace)+strlen(toCheck)+1)*sizeof(char));
	1895	sprintf(message,replace,toCheck);
	1896	if(lres==NULL){
	1897	lres=createMap("code","MissingParameterValue");
	1898	addToMap(lres,"text",message);
	1899	addToMap(lres,"locator",toCheck);
	1900	}else{
	1901	int length=1;
	1902	map* len=getMap(lres,"length");
	1903	if(len!=NULL){
	1904	length=atoi(len->value);
	1905	}
	1906	setMapArray(lres,"text",length,message);
	1907	setMapArray(lres,"locator",length,toCheck);
[756]	1908	setMapArray(lres,"code",length,"MissingParameterValue");
[640]	1909	}
	1910	free(message);
	1911	}
	1912	}else{
	1913	if(avalues==NULL)
	1914	return;
	1915	int nb=0;
	1916	int hasValidValue=-1;
	1917	if(strncasecmp(toCheck,"Accept",6)==0){
	1918	char *tmp=zStrdup(r_inputs->value);
	1919	char pToken,saveptr;
	1920	pToken=strtok_r(tmp,",",&saveptr);
	1921	while(pToken!=NULL){
	1922	while(avalues[nb]!=NULL){
	1923	if(strcasecmp(avalues[nb],pToken)==0){
	1924	hasValidValue=1;
	1925	break;
	1926	}
	1927	nb++;
	1928	}
	1929	pToken=strtok_r(NULL,",",&saveptr);
	1930	}
	1931	free(tmp);
	1932	}else{
	1933	while(avalues[nb]!=NULL){
	1934	if(strcasecmp(avalues[nb],r_inputs->value)==0){
	1935	hasValidValue=1;
	1936	break;
	1937	}
	1938	nb++;
	1939	}
	1940	}
	1941	if(hasValidValue<0){
[939]	1942	const char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
[640]	1943	nb=0;
	1944	char *vvalues=NULL;
[940]	1945	const char* num=_("is");
[640]	1946	while(avalues[nb]!=NULL){
	1947	char *tvalues;
	1948	if(vvalues==NULL){
	1949	vvalues=(char)malloc((strlen(avalues[nb])+3)sizeof(char));
	1950	sprintf(vvalues,"%s",avalues[nb]);
	1951	}
	1952	else{
	1953	tvalues=zStrdup(vvalues);
	1954	vvalues=(char)realloc(vvalues,(strlen(tvalues)+strlen(avalues[nb])+3)sizeof(char));
	1955	sprintf(vvalues,"%s, %s",tvalues,avalues[nb]);
	1956	free(tvalues);
	1957	num=_("are");
	1958	}
	1959	nb++;
	1960	}
	1961	char message=(char)malloc((strlen(replace)+strlen(num)+strlen(vvalues)+strlen(toCheck)+1)*sizeof(char));
	1962	sprintf(message,replace,toCheck,vvalues,num);
	1963	const char *code="VersionNegotiationFailed";
	1964	code="InvalidParameterValue";
	1965	const char *locator=toCheck;
	1966	if( strncasecmp(toCheck,"version",7)==0 \|\|
	1967	strncasecmp(toCheck,"AcceptVersions",14)==0 )
	1968	code="VersionNegotiationFailed";
	1969	if( strncasecmp(toCheck,"request",7)==0){
	1970	code="OperationNotSupported";
	1971	locator=r_inputs->value;
	1972	}
	1973	if(lres==NULL){
[756]	1974	lres=createMap("code",code);
[640]	1975	addToMap(lres,"text",message);
	1976	addToMap(lres,"locator",locator);
	1977	}else{
	1978	int length=1;
	1979	map* len=getMap(lres,"length");
	1980	if(len!=NULL){
	1981	length=atoi(len->value);
	1982	}
	1983	setMapArray(lres,"text",length,message);
	1984	setMapArray(lres,"locator",length,locator);
[756]	1985	setMapArray(lres,"code",length,code);
[640]	1986	}
	1987	}
	1988	}
	1989	if(lres!=NULL){
	1990	*res=lres;
	1991	}
	1992	}
[917]	1993
	1994	/**
	1995	* Parse cookie contained in request headers.
	1996	*
	1997	* @param conf the conf maps containinfg the main.cfg
	1998	* @param cookie the
	1999	*/
	2000	void parseCookie(maps** conf,const char* cookie){
	2001	char* tcook=zStrdup(cookie);
	2002	char token, saveptr;
	2003	token = strtok_r (tcook, "; ", &saveptr);
	2004	maps* res=createMaps("cookies");
	2005	while (token != NULL){
	2006	char token1, saveptr1, *name;
	2007	int i=0;
	2008	token1 = strtok_r (token, "=", &saveptr1);
	2009	while (token1 != NULL){
	2010	if(i==0){
	2011	name=zStrdup(token1);
	2012	i++;
	2013	}
	2014	else{
	2015	if(res->content==NULL)
	2016	res->content=createMap(name,token1);
	2017	else
	2018	addToMap(res->content,name,token1);
	2019	free(name);
	2020	name=NULL;
	2021	i=0;
	2022	}
	2023	token1 = strtok_r (NULL, "=", &saveptr1);
	2024	}
	2025	if(name!=NULL)
	2026	free(name);
	2027	token = strtok_r (NULL, "; ", &saveptr);
	2028	}
	2029	addMapsToMaps(conf,res);
	2030	freeMaps(&res);
	2031	free(res);
	2032	free(tcook);
	2033	}

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

Open WPS platform

source: trunk/zoo-project/zoo-kernel/request_parser.c @ 960

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links