request_parser.c @ 779

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links