request_parser.c @ 689

Last change on this file since 689 was 680, checked in by djay, 10 years ago
Various fixes for Windows support: generate uuid using UuidCreate?, pass usid to the created process, call TerminateProcess? on dismiss request.
Property svn:keywords set to `Id`
File size: 49.7 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);
[621]	214	return errorException (*main_conf, _("Unable to allocate memory."),
	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);
[621]	225	return errorException (*main_conf, _("Unable to allocate memory."),
	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,
	262	_("Unable to allocate memory."),
	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	_
	441	("Unable to allocate memory."),
	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	/**
	485	* Parse inputs from XML nodes and store them in a maps.
	486	*
	487	* @param main_conf the conf maps containing the main.cfg settings
	488	* @param s the service
	489	* @param request_output the maps to store the KVP pairs
	490	* @param doc the xmlDocPtr containing the original request
	491	* @param nodes the input nodes array
	492	* @param hInternet the HINTERNET queue to add potential requests
	493	* @return 0 on success, -1 on failure
	494	*/
	495	int xmlParseInputs(maps** main_conf,service* s,maps** request_output,xmlDocPtr doc,xmlNodeSet* nodes,HINTERNET* hInternet){
[622]	496	int k = 0;
	497	int l = 0;
[654]	498	map* version=getMapFromMaps(*main_conf,"main","rversion");
	499	int vid=getVersionId(version->value);
[622]	500	for (k=0; k < nodes->nodeNr; k++)
[621]	501	{
	502	maps *tmpmaps = NULL;
	503	xmlNodePtr cur = nodes->nodeTab[k];
	504
	505	if (nodes->nodeTab[k]->type == XML_ELEMENT_NODE)
	506	{
	507	// A specific Input node.
[654]	508	if(vid==1){
	509	tmpmaps = (maps *) malloc (MAPS_SIZE);
	510	xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
	511	tmpmaps->name = zStrdup ((char *) val);
	512	tmpmaps->content = NULL;
	513	tmpmaps->next = NULL;
	514	}
	515
[621]	516	xmlNodePtr cur2 = cur->children;
	517	while (cur2 != NULL)
	518	{
	519	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	520	cur2 = cur2->next;
	521	if (cur2 == NULL)
	522	break;
	523	// Indentifier
	524	if (xmlStrncasecmp
	525	(cur2->name, BAD_CAST "Identifier",
	526	xmlStrlen (cur2->name)) == 0)
	527	{
	528	xmlChar *val =
	529	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
	530	if (tmpmaps == NULL)
	531	{
	532	tmpmaps = (maps *) malloc (MAPS_SIZE);
	533	if (tmpmaps == NULL)
	534	{
	535	return errorException (*main_conf,
	536	_
	537	("Unable to allocate memory."),
	538	"InternalError", NULL);
	539	}
	540	tmpmaps->name = zStrdup ((char *) val);
	541	tmpmaps->content = NULL;
	542	tmpmaps->next = NULL;
	543	}
	544	xmlFree (val);
	545	}
	546	// Title, Asbtract
	547	if (xmlStrncasecmp
	548	(cur2->name, BAD_CAST "Title",
	549	xmlStrlen (cur2->name)) == 0
	550	\|\| xmlStrncasecmp (cur2->name, BAD_CAST "Abstract",
	551	xmlStrlen (cur2->name)) == 0)
	552	{
	553	xmlChar *val =
	554	xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
	555	if (tmpmaps == NULL)
	556	{
	557	tmpmaps = (maps *) malloc (MAPS_SIZE);
	558	if (tmpmaps == NULL)
	559	{
	560	return errorException (*main_conf,
	561	_
	562	("Unable to allocate memory."),
	563	"InternalError", NULL);
	564	}
	565	tmpmaps->name = zStrdup ("missingIndetifier");
	566	tmpmaps->content =
	567	createMap ((char ) cur2->name, (char ) val);
	568	tmpmaps->next = NULL;
	569	}
	570	else
	571	{
	572	if (tmpmaps->content != NULL)
	573	addToMap (tmpmaps->content,
	574	(char ) cur2->name, (char ) val);
	575	else
	576	tmpmaps->content =
	577	createMap ((char ) cur2->name, (char ) val);
	578	}
	579	xmlFree (val);
	580	}
	581	// InputDataFormChoice (Reference or Data ?)
	582	if (xmlStrcasecmp (cur2->name, BAD_CAST "Reference") == 0)
	583	{
	584	// Get every attribute from a Reference node
	585	// mimeType, encoding, schema, href, method
	586	// Header and Body gesture should be added here
	587	const char *refs[5] =
	588	{ "mimeType", "encoding", "schema", "method",
	589	"href"
	590	};
[622]	591	for (l = 0; l < 5; l++)
[621]	592	{
	593	xmlChar *val = xmlGetProp (cur2, BAD_CAST refs[l]);
	594	if (val != NULL && xmlStrlen (val) > 0)
	595	{
	596	if (tmpmaps->content != NULL)
	597	addToMap (tmpmaps->content, refs[l],
	598	(char *) val);
	599	else
	600	tmpmaps->content =
	601	createMap (refs[l], (char *) val);
	602
	603	map *ltmp = getMap (tmpmaps->content, "method");
	604	if (l == 4 )
	605	{
	606	if ((ltmp==NULL \|\| strncmp (ltmp->value, "POST",4) != 0))
	607	{
	608	if (loadRemoteFile
[623]	609	(main_conf, &tmpmaps->content, hInternet,
[621]	610	(char *) val) != 0)
	611	{
	612	return errorException (*main_conf,
	613	_("Unable to add a request in the queue."),
	614	"InternalError",
	615	NULL);
	616	}
[628]	617	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	618	}
[627]	619	addToMap (tmpmaps->content, "Reference", (char*) val);
[621]	620	}
	621	}
	622	xmlFree (val);
	623	}
	624	// Parse Header and Body from Reference
	625	xmlNodePtr cur3 = cur2->children;
	626	while (cur3 != NULL)
	627	{
	628	while (cur3 != NULL
	629	&& cur3->type != XML_ELEMENT_NODE)
	630	cur3 = cur3->next;
	631	if (cur3 == NULL)
	632	break;
	633	if (xmlStrcasecmp (cur3->name, BAD_CAST "Header") ==
	634	0)
	635	{
	636	const char *ha[2];
	637	ha[0] = "key";
	638	ha[1] = "value";
	639	int hai;
	640	char *has;
	641	char *key;
	642	for (hai = 0; hai < 2; hai++)
	643	{
	644	xmlChar *val =
	645	xmlGetProp (cur3, BAD_CAST ha[hai]);
	646	#ifdef POST_DEBUG
	647	fprintf (stderr, "%s = %s\n", ha[hai],
	648	(char *) val);
	649	#endif
	650	if (hai == 0)
	651	{
	652	key = zStrdup ((char *) val);
	653	}
	654	else
	655	{
	656	has =
	657	(char *)
	658	malloc ((4 + xmlStrlen (val) +
	659	strlen (key)) *
	660	sizeof (char));
	661	if (has == NULL)
	662	{
	663	return errorException (*main_conf,
	664	_
	665	("Unable to allocate memory."),
	666	"InternalError",
	667	NULL);
	668	}
	669	snprintf (has,
	670	(3 + xmlStrlen (val) +
	671	strlen (key)), "%s: %s", key,
	672	(char *) val);
	673	free (key);
	674	}
	675	xmlFree (val);
	676	}
[629]	677	hInternet->ihandle[hInternet->nb].header = NULL;
[621]	678	hInternet->ihandle[hInternet->nb].header =
	679	curl_slist_append (hInternet->ihandle
	680	[hInternet->nb].header,
	681	has);
	682	if (has != NULL)
	683	free (has);
	684	}
	685	else
	686	{
	687	#ifdef POST_DEBUG
	688	fprintf (stderr,
	689	"Try to fetch the body part of the request ...\n");
	690	#endif
	691	if (xmlStrcasecmp (cur3->name, BAD_CAST "Body")
	692	== 0)
	693	{
	694	#ifdef POST_DEBUG
	695	fprintf (stderr, "Body part found (%s) !!!\n",
	696	(char *) cur3->content);
	697	#endif
	698	char *tmp = NULL;
	699	xmlNodePtr cur4 = cur3->children;
	700	while (cur4 != NULL)
	701	{
	702	while (cur4 && cur4 != NULL && cur4->type && cur4->type != XML_ELEMENT_NODE){
	703	if(cur4->next)
	704	cur4 = cur4->next;
	705	else
	706	cur4 = NULL;
	707	}
	708	if(cur4 != NULL) {
	709	xmlDocPtr bdoc =
	710	xmlNewDoc (BAD_CAST "1.0");
	711	bdoc->encoding =
	712	xmlCharStrdup ("UTF-8");
	713	xmlDocSetRootElement (bdoc, cur4);
	714	xmlChar *btmps;
	715	int bsize;
	716	// TODO : check for encoding defined in the input
	717	xmlDocDumpFormatMemoryEnc(bdoc, &btmps, &bsize, "UTF-8", 0);
	718	if (btmps != NULL){
	719	tmp = (char ) malloc ((bsize + 1) sizeof (char));
	720
	721	sprintf (tmp, "%s", (char*) btmps);
	722
	723	xmlFreeDoc (bdoc);
	724
	725	map *btmp =
	726	getMap (tmpmaps->content, "Reference");
	727	if (btmp != NULL)
	728	{
[623]	729	addRequestToQueue(main_conf,hInternet,(char *) btmp->value,false);
[621]	730	InternetOpenUrl (hInternet,
	731	btmp->value,
	732	tmp,
	733	xmlStrlen(btmps),
	734	INTERNET_FLAG_NO_CACHE_WRITE,
	735	0);
[627]	736	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	737	}
	738	xmlFree (btmps);
	739	free (tmp);
	740	break;
	741	}
	742	}
	743	cur4 = cur4->next;
	744	}
	745	}
	746	else
	747	if (xmlStrcasecmp
	748	(cur3->name,
	749	BAD_CAST "BodyReference") == 0)
	750	{
	751	xmlChar *val =
	752	xmlGetProp (cur3, BAD_CAST "href");
	753	HINTERNET bInternet, res1, res;
	754	bInternet = InternetOpen (
	755	#ifndef WIN32
	756	(LPCTSTR)
	757	#endif
	758	"ZooWPSClient\0",
	759	INTERNET_OPEN_TYPE_PRECONFIG,
	760	NULL, NULL, 0);
	761	if (!CHECK_INET_HANDLE (bInternet))
	762	fprintf (stderr,
	763	"WARNING : bInternet handle failed to initialize");
	764	bInternet.waitingRequests[0] =
	765	strdup ((char *) val);
	766	res1 =
	767	InternetOpenUrl (&bInternet,
	768	bInternet.waitingRequests
	769	[0], NULL, 0,
	770	INTERNET_FLAG_NO_CACHE_WRITE,
	771	0);
	772	processDownloads (&bInternet);
	773	char *tmp =
	774	(char *)
	775	malloc ((bInternet.ihandle[0].nDataLen +
	776	1) * sizeof (char));
	777	if (tmp == NULL)
	778	{
	779	return errorException (*main_conf,
	780	_
	781	("Unable to allocate memory."),
	782	"InternalError",
	783	NULL);
	784	}
	785	size_t bRead;
	786	InternetReadFile (bInternet.ihandle[0],
	787	(LPVOID) tmp,
	788	bInternet.
	789	ihandle[0].nDataLen,
	790	&bRead);
	791	tmp[bInternet.ihandle[0].nDataLen] = 0;
	792	InternetCloseHandle (&bInternet);
	793	map *btmp =
	794	getMap (tmpmaps->content, "href");
	795	if (btmp != NULL)
	796	{
[623]	797	addRequestToQueue(main_conf,hInternet,(char *) btmp->value,false);
[621]	798
	799	res =
	800	InternetOpenUrl (hInternet,
	801	btmp->value,
	802	tmp,
	803	strlen(tmp),
	804	INTERNET_FLAG_NO_CACHE_WRITE,
	805	0);
[627]	806	addIntToMap (tmpmaps->content, "Order", hInternet->nb);
[621]	807	}
	808	free (tmp);
	809	}
	810	}
	811	cur3 = cur3->next;
	812	}
	813	}
	814	else if (xmlStrcasecmp (cur2->name, BAD_CAST "Data") == 0)
	815	{
	816	xmlNodePtr cur4 = cur2->children;
[654]	817	if(vid==1){
	818	// Get every dataEncodingAttributes from a Data node:
	819	// mimeType, encoding, schema
	820	const char *coms[3] =
	821	{ "mimeType", "encoding", "schema" };
	822	for (l = 0; l < 3; l++){
	823	xmlChar *val =
	824	xmlGetProp (cur4, BAD_CAST coms[l]);
	825	if (val != NULL && strlen ((char *) val) > 0){
	826	if (tmpmaps->content != NULL)
	827	addToMap (tmpmaps->content,coms[l],(char *) val);
	828	else
	829	tmpmaps->content =
	830	createMap (coms[l],(char *) val);
	831	}
	832	xmlFree (val);
	833	}
	834	while (cur4 != NULL){
	835	while(cur4 != NULL &&
	836	cur4->type != XML_CDATA_SECTION_NODE &&
	837	cur4->type != XML_TEXT_NODE)
	838	cur4=cur4->next;
	839	if(cur4!=NULL){
	840	if(cur4->content!=NULL)
	841	if (tmpmaps->content != NULL)
	842	addToMap (tmpmaps->content, "value",
	843	(char *) cur4->content);
	844	else
	845	tmpmaps->content =
	846	createMap ("value", (char *) cur4->content);
	847	cur4=cur4->next;
	848	}
	849	}
	850	}
	851
	852
[621]	853	while (cur4 != NULL)
	854	{
	855	while (cur4 != NULL
	856	&& cur4->type != XML_ELEMENT_NODE)
	857	cur4 = cur4->next;
	858	if (cur4 == NULL)
	859	break;
	860	if (xmlStrcasecmp
	861	(cur4->name, BAD_CAST "LiteralData") == 0)
	862	{
	863	// Get every attribute from a LiteralData node
	864	// dataType , uom
	865	char *list[2];
	866	list[0] = zStrdup ("dataType");
	867	list[1] = zStrdup ("uom");
[622]	868	for (l = 0; l < 2; l++)
[621]	869	{
	870	xmlChar *val =
	871	xmlGetProp (cur4, BAD_CAST list[l]);
	872	if (val != NULL
	873	&& strlen ((char *) val) > 0)
	874	{
	875	if (tmpmaps->content != NULL)
	876	addToMap (tmpmaps->content, list[l],
	877	(char *) val);
	878	else
	879	tmpmaps->content =
	880	createMap (list[l], (char *) val);
	881	}
	882	xmlFree (val);
	883	free (list[l]);
	884	}
	885	}
	886	else
	887	if (xmlStrcasecmp
	888	(cur4->name, BAD_CAST "ComplexData") == 0)
	889	{
	890	// Get every attribute from a Reference node
	891	// mimeType, encoding, schema
	892	const char *coms[3] =
	893	{ "mimeType", "encoding", "schema" };
[622]	894	for (l = 0; l < 3; l++)
[621]	895	{
	896	xmlChar *val =
	897	xmlGetProp (cur4, BAD_CAST coms[l]);
	898	if (val != NULL
	899	&& strlen ((char *) val) > 0)
	900	{
	901	if (tmpmaps->content != NULL)
	902	addToMap (tmpmaps->content, coms[l],
	903	(char *) val);
	904	else
	905	tmpmaps->content =
	906	createMap (coms[l], (char *) val);
	907	}
	908	xmlFree (val);
	909	}
	910	}
	911
	912	map *test = getMap (tmpmaps->content, "encoding");
	913
	914	if (test == NULL)
	915	{
	916	if (tmpmaps->content != NULL)
	917	addToMap (tmpmaps->content, "encoding",
	918	"utf-8");
	919	else
	920	tmpmaps->content =
	921	createMap ("encoding", "utf-8");
	922	test = getMap (tmpmaps->content, "encoding");
	923	}
	924
	925	if (strcasecmp (test->value, "base64") != 0)
	926	{
	927	xmlChar *mv = xmlNodeListGetString (doc,
	928	cur4->xmlChildrenNode,
	929	1);
	930	map *ltmp =
	931	getMap (tmpmaps->content, "mimeType");
	932	if (mv == NULL
	933	\|\|
	934	(xmlStrcasecmp
	935	(cur4->name, BAD_CAST "ComplexData") == 0
	936	&& (ltmp == NULL
	937	\|\| strncasecmp (ltmp->value,
	938	"text/xml", 8) == 0)))
	939	{
	940	xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
	941	int buffersize;
	942	xmlNodePtr cur5 = cur4->children;
	943	while (cur5 != NULL
	944	&& cur5->type != XML_ELEMENT_NODE
[654]	945	&& cur5->type != XML_CDATA_SECTION_NODE)
[621]	946	cur5 = cur5->next;
	947	if (cur5 != NULL
	948	&& cur5->type != XML_CDATA_SECTION_NODE)
	949	{
	950	xmlDocSetRootElement (doc1, cur5);
	951	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	952	&buffersize,
	953	"utf-8", 1);
	954	char size[1024];
	955	sprintf (size, "%d", buffersize);
	956	addToMap (tmpmaps->content, "size",
	957	size);
	958	xmlFreeDoc (doc1);
	959	}
	960	else
	961	{
	962	if (cur5 != NULL
	963	&& cur5->type == XML_CDATA_SECTION_NODE){
	964	xmlDocPtr doc2 = xmlParseMemory((const char*)cur5->content,xmlStrlen(cur5->content));
	965	xmlDocSetRootElement (doc1,xmlDocGetRootElement(doc2));
	966	xmlDocDumpFormatMemoryEnc (doc1, &mv,
	967	&buffersize,
	968	"utf-8", 1);
	969	char size[1024];
	970	sprintf (size, "%d", buffersize);
	971	addToMap (tmpmaps->content, "size",
	972	size);
	973	xmlFreeDoc (doc2);
	974	xmlFreeDoc (doc1);
	975	}
	976	}
	977	}else{
	978	xmlNodePtr cur5 = cur4->children;
	979	while (cur5 != NULL
	980	&& cur5->type != XML_CDATA_SECTION_NODE)
	981	cur5 = cur5->next;
	982	if (cur5 != NULL
	983	&& cur5->type == XML_CDATA_SECTION_NODE){
	984	xmlFree(mv);
	985	mv=xmlStrdup(cur5->content);
	986	}
	987	}
	988	if (mv != NULL)
	989	{
	990	addToMap (tmpmaps->content, "value",
	991	(char *) mv);
	992	xmlFree (mv);
	993	}
	994	}
	995	else
	996	{
	997	xmlChar *tmp = xmlNodeListGetRawString (doc,
	998	cur4->xmlChildrenNode,
	999	0);
	1000	addToMap (tmpmaps->content, "value",
	1001	(char *) tmp);
	1002	xmlFree (tmp);
	1003	}
	1004	cur4 = cur4->next;
	1005	}
	1006	}
	1007	cur2 = cur2->next;
[631]	1008	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE){
	1009	cur2 = cur2->next;
	1010	}
[621]	1011	}
	1012	{
	1013	maps *testPresence =
	1014	getMaps (*request_output, tmpmaps->name);
	1015	if (testPresence != NULL)
	1016	{
	1017	elements *elem = getElements (s->inputs, tmpmaps->name);
	1018	if (elem != NULL)
	1019	{
	1020	if (appendMapsToMaps
	1021	(main_conf, request_output, tmpmaps, elem) < 0)
	1022	{
	1023	return errorException (*main_conf,
	1024	_("Unable to append maps to maps."),
	1025	"InternalError",
	1026	NULL);
	1027	}
	1028	}
	1029	}
	1030	else
[623]	1031	addMapsToMaps (request_output, tmpmaps);
[621]	1032	}
	1033	freeMaps (&tmpmaps);
	1034	free (tmpmaps);
	1035	tmpmaps = NULL;
	1036	}
	1037	}
	1038	return 1;
	1039	}
	1040
	1041	/**
[654]	1042	* Parse outputs from XML nodes and store them in a maps (WPS version 2.0.0).
	1043	*
	1044	* @param main_conf the conf maps containing the main.cfg settings
	1045	* @param request_inputs the map storing KVP raw value
	1046	* @param request_output the maps to store the KVP pairs
	1047	* @param doc the xmlDocPtr containing the original request
	1048	* @param cur the xmlNodePtr corresponding to the ResponseDocument or RawDataOutput XML node
	1049	* @param raw true if the node is RawDataOutput, false in case of ResponseDocument
	1050	* @return 0 on success, -1 on failure
	1051	*/
	1052	int xmlParseOutputs2(maps main_conf,map request_inputs,maps** request_output,xmlDocPtr doc,xmlNodeSet* nodes){
	1053	int k = 0;
	1054	int l = 0;
	1055	for (k=0; k < nodes->nodeNr; k++){
	1056	maps *tmpmaps = NULL;
	1057	xmlNodePtr cur = nodes->nodeTab[k];
	1058	if (cur->type == XML_ELEMENT_NODE){
	1059	maps tmpmaps = (maps ) malloc (MAPS_SIZE);
	1060	xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
	1061	if(val!=NULL)
	1062	tmpmaps->name = zStrdup ((char*)val);
	1063	else
	1064	tmpmaps->name = zStrdup ("unknownIdentifier");
	1065	tmpmaps->content = NULL;
	1066	tmpmaps->next = NULL;
	1067	const char ress[4][13] =
	1068	{ "mimeType", "encoding", "schema", "transmission" };
	1069	for (l = 0; l < 4; l++){
	1070	val = xmlGetProp (cur, BAD_CAST ress[l]);
	1071	if (val != NULL && strlen ((char *) val) > 0)
	1072	{
	1073	if (tmpmaps->content != NULL)
	1074	addToMap (tmpmaps->content, ress[l],
	1075	(char *) val);
	1076	else
	1077	tmpmaps->content =
	1078	createMap (ress[l], (char *) val);
	1079	if(l==3 && strncasecmp((char*)val,"reference",xmlStrlen(val))==0)
	1080	addToMap (tmpmaps->content,"asReference","true");
	1081	}
	1082	xmlFree (val);
	1083	}
	1084	if (*request_output == NULL)
	1085	*request_output = dupMaps(&tmpmaps);
	1086	else
	1087	addMapsToMaps(request_output,tmpmaps);
	1088	}
	1089	}
[680]	1090	return 0;
[654]	1091	}
	1092
	1093	/**
[621]	1094	* Parse outputs from XML nodes and store them in a maps.
	1095	*
	1096	* @param main_conf the conf maps containing the main.cfg settings
	1097	* @param request_inputs the map storing KVP raw value
	1098	* @param request_output the maps to store the KVP pairs
	1099	* @param doc the xmlDocPtr containing the original request
	1100	* @param cur the xmlNodePtr corresponding to the ResponseDocument or RawDataOutput XML node
	1101	* @param raw true if the node is RawDataOutput, false in case of ResponseDocument
	1102	* @return 0 on success, -1 on failure
	1103	*/
	1104	int xmlParseOutputs(maps main_conf,map request_inputs,maps** request_output,xmlDocPtr doc,xmlNodePtr cur,bool raw){
[622]	1105	int l=0;
[621]	1106	if( raw == true)
	1107	{
	1108	addToMap (*request_inputs, "RawDataOutput", "");
	1109	if (cur->type == XML_ELEMENT_NODE)
	1110	{
	1111
	1112	maps tmpmaps = (maps ) malloc (MAPS_SIZE);
	1113	if (tmpmaps == NULL)
	1114	{
	1115	return errorException (*main_conf, _("Unable to allocate memory."),
	1116	"InternalError", NULL);
	1117	}
	1118	tmpmaps->name = zStrdup ("unknownIdentifier");
	1119	tmpmaps->content = NULL;
	1120	tmpmaps->next = NULL;
	1121
	1122	// Get every attribute from a RawDataOutput node
	1123	// mimeType, encoding, schema, uom
	1124	const char *outs[4] =
	1125	{ "mimeType", "encoding", "schema", "uom" };
[622]	1126	for (l = 0; l < 4; l++)
[621]	1127	{
	1128	xmlChar *val = xmlGetProp (cur, BAD_CAST outs[l]);
	1129	if (val != NULL)
	1130	{
	1131	if (strlen ((char *) val) > 0)
	1132	{
	1133	if (tmpmaps->content != NULL)
	1134	addToMap (tmpmaps->content, outs[l],
	1135	(char *) val);
	1136	else
	1137	tmpmaps->content =
	1138	createMap (outs[l], (char *) val);
	1139	}
	1140	xmlFree (val);
	1141	}
	1142	}
	1143	xmlNodePtr cur2 = cur->children;
	1144	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	1145	cur2 = cur2->next;
	1146	while (cur2 != NULL)
	1147	{
	1148	if (xmlStrncasecmp
	1149	(cur2->name, BAD_CAST "Identifier",
	1150	xmlStrlen (cur2->name)) == 0)
	1151	{
	1152	xmlChar *val =
	1153	xmlNodeListGetString (NULL, cur2->xmlChildrenNode, 1);
	1154	free (tmpmaps->name);
	1155	tmpmaps->name = zStrdup ((char *) val);
	1156	xmlFree (val);
	1157	}
	1158	cur2 = cur2->next;
	1159	while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
	1160	cur2 = cur2->next;
	1161	}
	1162	if (*request_output == NULL)
	1163	*request_output = dupMaps (&tmpmaps);
	1164	else
[623]	1165	addMapsToMaps (request_output, tmpmaps);
[621]	1166	if (tmpmaps != NULL)
	1167	{
	1168	freeMaps (&tmpmaps);
	1169	free (tmpmaps);
	1170	tmpmaps = NULL;
	1171	}
	1172	}
	1173	}
	1174	else
	1175	{
	1176	addToMap (*request_inputs, "ResponseDocument", "");
	1177
	1178	if (cur->type == XML_ELEMENT_NODE) {
	1179	// Get every attribute: storeExecuteResponse, lineage, status
	1180	const char *ress[3] =
	1181	{ "storeExecuteResponse", "lineage", "status" };
	1182	xmlChar *val;
[622]	1183	for (l = 0; l < 3; l++)
[621]	1184	{
	1185	val = xmlGetProp (cur, BAD_CAST ress[l]);
	1186	if (val != NULL && strlen ((char *) val) > 0)
	1187	{
	1188	addToMap (request_inputs, ress[l], (char ) val);
	1189	}
	1190	xmlFree (val);
	1191	}
	1192
	1193	xmlNodePtr cur1 = cur->children;
	1194	while (cur1 != NULL) // iterate over Output nodes
	1195	{
	1196	if (cur1->type != XML_ELEMENT_NODE \|\|
	1197	xmlStrncasecmp(cur1->name, BAD_CAST "Output",
	1198	xmlStrlen (cur1->name)) != 0) {
	1199	cur1 = cur1->next;
	1200	continue;
	1201	}
	1202
	1203	maps tmpmaps = (maps ) malloc (MAPS_SIZE); // one per Output node
	1204	if (tmpmaps == NULL) {
	1205	return errorException (*main_conf,
	1206	_
	1207	("Unable to allocate memory."),
	1208	"InternalError", NULL);
	1209	}
	1210	tmpmaps->name = zStrdup ("unknownIdentifier");
	1211	tmpmaps->content = NULL;
	1212	tmpmaps->next = NULL;
	1213
	1214	xmlNodePtr elems = cur1->children;
	1215
	1216	while (elems != NULL) {
	1217
	1218	// Identifier
	1219	if (xmlStrncasecmp
	1220	(elems->name, BAD_CAST "Identifier",
	1221	xmlStrlen (elems->name)) == 0)
	1222	{
	1223	xmlChar *val =
	1224	xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
	1225
	1226	free(tmpmaps->name);
	1227	tmpmaps->name = zStrdup ((char *) val);
	1228	if (tmpmaps->content == NULL) {
	1229	tmpmaps->content = createMap("Identifier", zStrdup ((char *) val));
	1230	}
	1231	else {
	1232	addToMap(tmpmaps->content, "Identifier", zStrdup ((char *) val));
	1233	}
	1234
	1235	map* tt = getMap (*request_inputs, "ResponseDocument");
	1236	if (strlen(tt->value) == 0) {
	1237	addToMap (*request_inputs, "ResponseDocument",
	1238	(char *) val);
	1239	}
	1240	else {
	1241	char* tmp = (char*) malloc((strlen(tt->value) + 1
	1242	+ strlen((char) val) + 1) sizeof(char));
	1243	sprintf (tmp, "%s;%s", tt->value, (char *) val);
	1244	free(tt->value);
	1245	tt->value = tmp;
	1246	}
	1247	xmlFree (val);
	1248	}
	1249
	1250	// Title, Abstract
	1251	else if (xmlStrncasecmp(elems->name, BAD_CAST "Title",
	1252	xmlStrlen (elems->name)) == 0
	1253	\|\| xmlStrncasecmp(elems->name, BAD_CAST "Abstract",
	1254	xmlStrlen (elems->name)) == 0)
	1255	{
	1256	xmlChar *val =
	1257	xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
	1258
	1259	if (tmpmaps->content == NULL) {
	1260	tmpmaps->content = createMap((char) elems->name, zStrdup ((char ) val));
	1261	}
	1262	else {
	1263	addToMap(tmpmaps->content, (char) elems->name, zStrdup ((char ) val));
	1264	}
	1265	xmlFree (val);
	1266	}
	1267	elems = elems->next;
	1268	}
	1269
	1270	// Get every attribute from an Output node:
	1271	// mimeType, encoding, schema, uom, asReference
	1272	const char *outs[5] =
	1273	{ "mimeType", "encoding", "schema", "uom", "asReference" };
	1274
[622]	1275	for (l = 0; l < 5; l++) {
[621]	1276	xmlChar *val = xmlGetProp (cur1, BAD_CAST outs[l]);
	1277	if (val != NULL && xmlStrlen(val) > 0) {
	1278	if (tmpmaps->content != NULL) {
	1279	addToMap (tmpmaps->content, outs[l], (char *) val);
	1280	}
	1281	else {
	1282	tmpmaps->content = createMap (outs[l], (char *) val);
	1283	}
	1284	}
	1285	xmlFree (val);
	1286	}
	1287
	1288	if (*request_output == NULL) {
	1289	*request_output = tmpmaps;
	1290	}
	1291	else if (getMaps(*request_output, tmpmaps->name) != NULL) {
	1292	return errorException (*main_conf,
	1293	_
	1294	("Duplicate <Output> elements in WPS Execute request"),
	1295	"InternalError", NULL);
	1296	}
	1297	else {
	1298	maps* mptr = *request_output;
	1299	while (mptr->next != NULL) {
	1300	mptr = mptr->next;
	1301	}
	1302	mptr->next = tmpmaps;
	1303	}
	1304	cur1 = cur1->next;
	1305	}
	1306	}
	1307	}
	1308	return 1;
	1309	}
	1310
	1311	/**
	1312	* Parse XML request and store informations in maps.
	1313	*
	1314	* @param main_conf the conf maps containing the main.cfg settings
	1315	* @param post the string containing the XML request
	1316	* @param request_inputs the map storing KVP raw value
	1317	* @param s the service
	1318	* @param inputs the maps to store the KVP pairs
	1319	* @param outputs the maps to store the KVP pairs
	1320	* @param hInternet the HINTERNET queue to add potential requests
	1321	* @return 0 on success, -1 on failure
	1322	*/
	1323	int xmlParseRequest(maps** main_conf,const char* post,map** request_inputs,service* s,maps inputs,maps outputs,HINTERNET* hInternet){
[654]	1324
	1325	map* version=getMapFromMaps(*main_conf,"main","rversion");
	1326	int vid=getVersionId(version->value);
	1327
[621]	1328	xmlInitParser ();
	1329	xmlDocPtr doc = xmlParseMemory (post, cgiContentLength);
	1330
	1331	/**
	1332	* Extract Input nodes from the XML Request.
	1333	*/
	1334	xmlXPathObjectPtr tmpsptr =
[654]	1335	extractFromDoc (doc, (vid==0?"///[local-name()='Input']":"//*[local-name()='Input']"));
[621]	1336	xmlNodeSet *tmps = tmpsptr->nodesetval;
[654]	1337	if(tmps==NULL \|\| xmlParseInputs(main_conf,s,inputs,doc,tmps,hInternet)<0){
[621]	1338	xmlXPathFreeObject (tmpsptr);
	1339	xmlFreeDoc (doc);
	1340	xmlCleanupParser ();
	1341	return -1;
	1342	}
	1343	xmlXPathFreeObject (tmpsptr);
	1344
[654]	1345	if(vid==1){
	1346	tmpsptr =
	1347	extractFromDoc (doc, "/*[local-name()='Execute']");
	1348	bool asRaw = false;
	1349	tmps = tmpsptr->nodesetval;
	1350	if(tmps->nodeNr > 0){
	1351	int k = 0;
	1352	for (k=0; k < tmps->nodeNr; k++){
	1353	maps *tmpmaps = NULL;
	1354	xmlNodePtr cur = tmps->nodeTab[k];
	1355	if (cur->type == XML_ELEMENT_NODE){
	1356	xmlChar *val = xmlGetProp (cur, BAD_CAST "mode");
	1357	if(val!=NULL)
	1358	addToMap(request_inputs,"mode",(char)val);
	1359	else
	1360	addToMap(*request_inputs,"mode","auto");
	1361	val = xmlGetProp (cur, BAD_CAST "response");
	1362	if(val!=NULL){
	1363	addToMap(request_inputs,"response",(char)val);
	1364	if(strncasecmp((char*)val,"raw",xmlStrlen(val))==0)
	1365	addToMap(*request_inputs,"RawDataOutput","");
	1366	else
	1367	addToMap(*request_inputs,"ResponseDocument","");
	1368	}
	1369	else{
	1370	addToMap(*request_inputs,"response","document");
	1371	addToMap(*request_inputs,"ResponseDocument","");
	1372	}
	1373	}
	1374	}
[621]	1375	}
[654]	1376	xmlXPathFreeObject (tmpsptr);
	1377	tmpsptr =
	1378	extractFromDoc (doc, "//[local-name()='Output']");
	1379	tmps = tmpsptr->nodesetval;
	1380	if(tmps->nodeNr > 0){
	1381	if(xmlParseOutputs2(main_conf,request_inputs,outputs,doc,tmps)<0){
	1382	xmlXPathFreeObject (tmpsptr);
	1383	xmlFreeDoc (doc);
	1384	xmlCleanupParser ();
	1385	return -1;
	1386	}
[621]	1387	}
	1388	}
[654]	1389	else{
	1390	// Extract ResponseDocument / RawDataOutput from the XML Request
	1391	tmpsptr =
	1392	extractFromDoc (doc, "///*[local-name()='ResponseDocument']");
	1393	bool asRaw = false;
	1394	tmps = tmpsptr->nodesetval;
	1395	if (tmps->nodeNr == 0)
	1396	{
	1397	xmlXPathFreeObject (tmpsptr);
	1398	tmpsptr =
	1399	extractFromDoc (doc, "///*[local-name()='RawDataOutput']");
	1400	tmps = tmpsptr->nodesetval;
	1401	asRaw = true;
	1402	}
	1403	if(tmps->nodeNr != 0){
	1404	if(xmlParseOutputs(main_conf,request_inputs,outputs,doc,tmps->nodeTab[0],asRaw)<0){
	1405	xmlXPathFreeObject (tmpsptr);
	1406	xmlFreeDoc (doc);
	1407	xmlCleanupParser ();
	1408	return -1;
	1409	}
	1410	}
	1411	}
[621]	1412	xmlXPathFreeObject (tmpsptr);
	1413	xmlFreeDoc (doc);
	1414	xmlCleanupParser ();
	1415	return 1;
	1416	}
	1417
	1418	/**
	1419	* Parse request and store informations in maps.
	1420	*
	1421	* @param main_conf the conf maps containing the main.cfg settings
	1422	* @param post the string containing the XML request
	1423	* @param request_inputs the map storing KVP raw value
	1424	* @param s the service
	1425	* @param inputs the maps to store the KVP pairs
	1426	* @param outputs the maps to store the KVP pairs
	1427	* @param hInternet the HINTERNET queue to add potential requests
	1428	* @return 0 on success, -1 on failure
	1429	* @see kvpParseOutputs,kvpParseInputs,xmlParseRequest
	1430	*/
	1431	int parseRequest(maps main_conf,map request_inputs,service* s,maps inputs,maps outputs,HINTERNET* hInternet){
	1432	map *postRequest = NULL;
	1433	postRequest = getMap (*request_inputs, "xrequest");
	1434	if (postRequest == NULLMAP)
	1435	{
	1436	if(kvpParseOutputs(main_conf,*request_inputs,outputs)<0){
	1437	return -1;
	1438	}
	1439	if(kvpParseInputs(main_conf,s,*request_inputs,inputs,hInternet)<0){
	1440	return -1;
	1441	}
	1442	}
	1443	else
	1444	{
	1445	//Parse XML request
	1446	if(xmlParseRequest(main_conf,postRequest->value,request_inputs,s,inputs,outputs,hInternet)<0){
	1447	return -1;
	1448	}
	1449	}
	1450	return 1;
	1451	}
	1452
	1453	/**
	1454	* Ensure that each requested arguments are present in the request
	1455	* DataInputs and ResponseDocument / RawDataOutput. Potentially run
	1456	* http requests from the queue in parallel.
	1457	* For optional inputs add default values defined in the ZCFG file.
	1458	*
	1459	* @param main_conf
	1460	* @param s
	1461	* @param original_request
	1462	* @param request_inputs
	1463	* @param request_outputs
	1464	* @param hInternet
	1465	*
	1466	* @see runHttpRequests
	1467	*/
	1468	int validateRequest(maps** main_conf,service* s,map* original_request, maps request_inputs,maps request_outputs,HINTERNET* hInternet){
	1469
	1470	runHttpRequests (main_conf, request_inputs, hInternet);
	1471	InternetCloseHandle (hInternet);
	1472
	1473	map* errI=NULL;
	1474	char dfv = addDefaultValues (request_inputs, s->inputs, main_conf, 0,&errI);
	1475
	1476	maps ptr = request_inputs;
	1477	while (ptr != NULL)
	1478	{
	1479	map *tmp0 = getMap (ptr->content, "size");
	1480	map *tmp1 = getMap (ptr->content, "maximumMegabytes");
	1481	if (tmp1 != NULL && tmp0 != NULL)
	1482	{
	1483	float i = atof (tmp0->value) / 1048576.0;
	1484	if (i >= atoi (tmp1->value))
	1485	{
	1486	char tmps[1024];
	1487	map *tmpe = createMap ("code", "FileSizeExceeded");
	1488	snprintf (tmps, 1024,
	1489	_
	1490	("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)."),
	1491	ptr->name, tmp1->value, i);
	1492	addToMap (tmpe, "locator", ptr->name);
	1493	addToMap (tmpe, "text", tmps);
	1494	printExceptionReportResponse (*main_conf, tmpe);
	1495	freeMap (&tmpe);
	1496	free (tmpe);
	1497	return -1;
	1498	}
	1499	}
	1500	ptr = ptr->next;
	1501	}
	1502
	1503	map* errO=NULL;
	1504	char *dfv1 =
	1505	addDefaultValues (request_outputs, s->outputs, *main_conf, 1,&errO);
	1506	if (strcmp (dfv1, "") != 0 \|\| strcmp (dfv, "") != 0)
	1507	{
	1508	char tmps[1024];
	1509	map *tmpe = NULL;
	1510	if (strcmp (dfv, "") != 0)
	1511	{
	1512	tmpe = createMap ("code", "MissingParameterValue");
	1513	int nb=0;
	1514	int length=1;
	1515	map* len=getMap(errI,"length");
	1516	if(len!=NULL)
	1517	length=atoi(len->value);
	1518	for(nb=0;nb<length;nb++){
	1519	map* errp=getMapArray(errI,"value",nb);
	1520	snprintf (tmps, 1024,
	1521	_
	1522	("The <%s> argument was not specified in DataInputs but is required according to the ZOO ServicesProvider configuration file."),
	1523	errp->value);
	1524	setMapArray (tmpe, "locator", nb , errp->value);
	1525	setMapArray (tmpe, "text", nb , tmps);
	1526	setMapArray (tmpe, "code", nb , "MissingParameterValue");
	1527	}
	1528	}
	1529	if (strcmp (dfv1, "") != 0)
	1530	{
	1531	int ilength=0;
	1532	if(tmpe==NULL)
	1533	tmpe = createMap ("code", "InvalidParameterValue");
	1534	else{
	1535	map* len=getMap(tmpe,"length");
	1536	if(len!=NULL)
	1537	ilength=atoi(len->value);
	1538	}
	1539	int nb=0;
	1540	int length=1;
	1541	map* len=getMap(errO,"length");
	1542	if(len!=NULL)
	1543	length=atoi(len->value);
	1544	for(nb=0;nb<length;nb++){
	1545	map* errp=getMapArray(errO,"value",nb);
	1546	snprintf (tmps, 1024,
	1547	_
	1548	("The <%s> argument specified as %s identifier was not recognized (not defined in the ZOO Configuration File)."),
	1549	errp->value,
	1550	((getMap(original_request,"RawDataOutput")!=NULL)?"RawDataOutput":"ResponseDocument"));
	1551	setMapArray (tmpe, "locator", nb+ilength , errp->value);
	1552	setMapArray (tmpe, "text", nb+ilength , tmps);
	1553	setMapArray (tmpe, "code", nb+ilength , "InvalidParameterValue");
	1554	}
	1555	}
	1556	printExceptionReportResponse (*main_conf, tmpe);
	1557	if(errI!=NULL){
	1558	freeMap(&errI);
	1559	free(errI);
	1560	}
	1561	if(errO!=NULL){
	1562	freeMap(&errO);
	1563	free(errO);
	1564	}
	1565	freeMap (&tmpe);
	1566	free (tmpe);
	1567	return -1;
	1568	}
	1569	maps tmpReqI = request_inputs;
	1570	while (tmpReqI != NULL)
	1571	{
	1572	char name[1024];
	1573	if (getMap (tmpReqI->content, "isFile") != NULL)
	1574	{
	1575	if (cgiFormFileName (tmpReqI->name, name, sizeof (name)) ==
	1576	cgiFormSuccess)
	1577	{
	1578	int BufferLen = 1024;
	1579	cgiFilePtr file;
	1580	int targetFile;
	1581	char storageNameOnServer[2048];
	1582	char fileNameOnServer[64];
	1583	char contentType[1024];
	1584	char buffer[1024];
	1585	char *tmpStr = NULL;
	1586	int size;
	1587	int got, t;
	1588	map path = getMapFromMaps (main_conf, "main", "tmpPath");
	1589	cgiFormFileSize (tmpReqI->name, &size);
	1590	cgiFormFileContentType (tmpReqI->name, contentType,
	1591	sizeof (contentType));
	1592	if (cgiFormFileOpen (tmpReqI->name, &file) == cgiFormSuccess)
	1593	{
	1594	t = -1;
	1595	while (1)
	1596	{
	1597	tmpStr = strstr (name + t + 1, "\\");
	1598	if (NULL == tmpStr)
	1599	tmpStr = strstr (name + t + 1, "/");
	1600	if (NULL != tmpStr)
	1601	t = (int) (tmpStr - name);
	1602	else
	1603	break;
	1604	}
	1605	strcpy (fileNameOnServer, name + t + 1);
	1606
	1607	sprintf (storageNameOnServer, "%s/%s", path->value,
	1608	fileNameOnServer);
	1609	#ifdef DEBUG
	1610	fprintf (stderr, "Name on server %s\n",
	1611	storageNameOnServer);
	1612	fprintf (stderr, "fileNameOnServer: %s\n",
	1613	fileNameOnServer);
	1614	#endif
	1615	targetFile =
	1616	open (storageNameOnServer, O_RDWR \| O_CREAT \| O_TRUNC,
	1617	S_IRWXU \| S_IRGRP \| S_IROTH);
	1618	if (targetFile < 0)
	1619	{
	1620	#ifdef DEBUG
	1621	fprintf (stderr, "could not create the new file,%s\n",
	1622	fileNameOnServer);
	1623	#endif
	1624	}
	1625	else
	1626	{
	1627	while (cgiFormFileRead (file, buffer, BufferLen, &got)
	1628	== cgiFormSuccess)
	1629	{
	1630	if (got > 0)
	1631	write (targetFile, buffer, got);
	1632	}
	1633	}
	1634	addToMap (tmpReqI->content, "lref", storageNameOnServer);
	1635	cgiFormFileClose (file);
	1636	close (targetFile);
	1637	#ifdef DEBUG
	1638	fprintf (stderr, "File \"%s\" has been uploaded",
	1639	fileNameOnServer);
	1640	#endif
	1641	}
	1642	}
	1643	}
	1644	tmpReqI = tmpReqI->next;
	1645	}
	1646
	1647	ensureDecodedBase64 (request_inputs);
	1648	return 1;
	1649	}
[640]	1650
	1651
	1652	/**
	1653	* Verify if a parameter value is valid.
	1654	*
	1655	* @param request the request map
	1656	* @param res the error map potentially generated
	1657	* @param toCheck the parameter to use
	1658	* @param avalues the acceptable values (or null if testing only for presence)
	1659	* @param mandatory verify the presence of the parameter if mandatory > 0
	1660	*/
	1661	void checkValidValue(map* request,map** res,const char* toCheck,const char** avalues,int mandatory){
	1662	map* lres=*res;
	1663	map* r_inputs = getMap (request,toCheck);
	1664	if (r_inputs == NULL){
	1665	if(mandatory>0){
	1666	char *replace=_("Mandatory parameter <%s> was not specified");
	1667	char message=(char)malloc((strlen(replace)+strlen(toCheck)+1)*sizeof(char));
	1668	sprintf(message,replace,toCheck);
	1669	if(lres==NULL){
	1670	lres=createMap("code","MissingParameterValue");
	1671	addToMap(lres,"text",message);
	1672	addToMap(lres,"locator",toCheck);
	1673	}else{
	1674	int length=1;
	1675	map* len=getMap(lres,"length");
	1676	if(len!=NULL){
	1677	length=atoi(len->value);
	1678	}
	1679	setMapArray(lres,"text",length,message);
	1680	setMapArray(lres,"locator",length,toCheck);
	1681	setMapArray(lres,"code",length,"MissingParameter");
	1682	}
	1683	free(message);
	1684	}
	1685	}else{
	1686	if(avalues==NULL)
	1687	return;
	1688	int nb=0;
	1689	int hasValidValue=-1;
	1690	if(strncasecmp(toCheck,"Accept",6)==0){
	1691	char *tmp=zStrdup(r_inputs->value);
	1692	char pToken,saveptr;
	1693	pToken=strtok_r(tmp,",",&saveptr);
	1694	while(pToken!=NULL){
	1695	while(avalues[nb]!=NULL){
	1696	if(strcasecmp(avalues[nb],pToken)==0){
	1697	hasValidValue=1;
	1698	break;
	1699	}
	1700	nb++;
	1701	}
	1702	pToken=strtok_r(NULL,",",&saveptr);
	1703	}
	1704	free(tmp);
	1705	}else{
	1706	while(avalues[nb]!=NULL){
	1707	if(strcasecmp(avalues[nb],r_inputs->value)==0){
	1708	hasValidValue=1;
	1709	break;
	1710	}
	1711	nb++;
	1712	}
	1713	}
	1714	if(hasValidValue<0){
	1715	char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
	1716	nb=0;
	1717	char *vvalues=NULL;
	1718	char* num=_("is");
	1719	while(avalues[nb]!=NULL){
	1720	char *tvalues;
	1721	if(vvalues==NULL){
	1722	vvalues=(char)malloc((strlen(avalues[nb])+3)sizeof(char));
	1723	sprintf(vvalues,"%s",avalues[nb]);
	1724	}
	1725	else{
	1726	tvalues=zStrdup(vvalues);
	1727	vvalues=(char)realloc(vvalues,(strlen(tvalues)+strlen(avalues[nb])+3)sizeof(char));
	1728	sprintf(vvalues,"%s, %s",tvalues,avalues[nb]);
	1729	free(tvalues);
	1730	num=_("are");
	1731	}
	1732	nb++;
	1733	}
	1734	char message=(char)malloc((strlen(replace)+strlen(num)+strlen(vvalues)+strlen(toCheck)+1)*sizeof(char));
	1735	sprintf(message,replace,toCheck,vvalues,num);
	1736	const char *code="VersionNegotiationFailed";
	1737	code="InvalidParameterValue";
	1738	const char *locator=toCheck;
	1739	if( strncasecmp(toCheck,"version",7)==0 \|\|
	1740	strncasecmp(toCheck,"AcceptVersions",14)==0 )
	1741	code="VersionNegotiationFailed";
	1742	if( strncasecmp(toCheck,"request",7)==0){
	1743	code="OperationNotSupported";
	1744	locator=r_inputs->value;
	1745	}
	1746	if(lres==NULL){
	1747	lres=createMap("code","InvalidParameterValue");
	1748	addToMap(lres,"text",message);
	1749	addToMap(lres,"locator",locator);
	1750	}else{
	1751	int length=1;
	1752	map* len=getMap(lres,"length");
	1753	if(len!=NULL){
	1754	length=atoi(len->value);
	1755	}
	1756	setMapArray(lres,"text",length,message);
	1757	setMapArray(lres,"locator",length,locator);
	1758	setMapArray(lres,"code",length,"InvalidParameterValue");
	1759	}
	1760	}
	1761	}
	1762	if(lres!=NULL){
	1763	*res=lres;
	1764	}
	1765	}

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links