request_parser.c @ 940

Last change on this file since 940 was 940, checked in by djay, 6 years ago
Small change
Property svn:keywords set to `Id`
File size: 57.1 KB

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links