request_parser.c @ 873

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

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

Open WPS platform

source: branches/prototype-v0/zoo-project/zoo-kernel/request_parser.c @ 873

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links