service_internal.c @ 492

Last change on this file since 492 was 492, checked in by djay, 9 years ago
Inputs passed by reference downloaded in parallel. Conform behavior for DescribeProcess? when the Identifier was not found.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 88.1 KB

Line
1	/**
2	* Author : Gérald FENOY
3	*
4	* Copyright (c) 2009-2013 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 "service_internal.h"
26	#ifdef USE_MS
27	#include "service_internal_ms.h"
28	#else
29	#include "cpl_vsi.h"
30	#endif
31
32	#ifndef TRUE
33	#define TRUE 1
34	#endif
35	#ifndef FALSE
36	#define FALSE -1
37	#endif
38
39	void printHeaders(maps* m){
40	maps *_tmp=getMaps(m,"headers");
41	if(_tmp!=NULL){
42	map* _tmp1=_tmp->content;
43	while(_tmp1!=NULL){
44	printf("%s: %s\r\n",_tmp1->name,_tmp1->value);
45	_tmp1=_tmp1->next;
46	}
47	}
48	}
49
50	void addLangAttr(xmlNodePtr n,maps *m){
51	map *tmpLmap=getMapFromMaps(m,"main","language");
52	if(tmpLmap!=NULL)
53	xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST tmpLmap->value);
54	else
55	xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en-US");
56	}
57
58	/* Converts a hex character to its integer value */
59	char from_hex(char ch) {
60	return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
61	}
62
63	/* Converts an integer value to its hex character*/
64	char to_hex(char code) {
65	static char hex[] = "0123456789abcdef";
66	return hex[code & 15];
67	}
68
69	#ifdef WIN32
70
71	#include <windows.h>
72	#include <fcgi_stdio.h>
73	#include <stdio.h>
74	#include <conio.h>
75	#include <tchar.h>
76
77	#define SHMEMSIZE 4096
78
79	static LPVOID lpvMemG = NULL; // pointer to shared memory
80	static HANDLE hMapObjectG = NULL; // handle to file mapping
81
82	int _updateStatus(maps *conf){
83	LPWSTR lpszTmp;
84	BOOL fInit;
85	char *final_string=NULL;
86	char *s=NULL;
87	map *tmpMap1;
88	map *tmpMap=getMapFromMaps(conf,"lenv","sid");
89	if(hMapObjectG==NULL)
90	hMapObjectG = CreateFileMapping(
91	INVALID_HANDLE_VALUE, // use paging file
92	NULL, // default security attributes
93	PAGE_READWRITE, // read/write access
94	0, // size: high 32-bits
95	SHMEMSIZE, // size: low 32-bits
96	TEXT(tmpMap->value)); // name of map object
97	if (hMapObjectG == NULL){
98	fprintf(stderr,"Unable to create share memory segment %s !! \n",tmpMap->value);
99	return -2;
100	}
101	fInit = (GetLastError() != ERROR_ALREADY_EXISTS);
102	if(lpvMemG==NULL)
103	lpvMemG = MapViewOfFile(
104	hMapObjectG, // object to map view of
105	FILE_MAP_WRITE, // read/write access
106	0, // high offset: map from
107	0, // low offset: beginning
108	0); // default: map entire file
109	if (lpvMemG == NULL){
110	fprintf(stderr,"Unable to create or access the shared memory segment %s !! \n",tmpMap->value);
111	return -1;
112	}
113	memset(lpvMemG, '\0', SHMEMSIZE);
114	tmpMap=getMapFromMaps(conf,"lenv","status");
115	tmpMap1=NULL;
116	tmpMap1=getMapFromMaps(conf,"lenv","message");
117	lpszTmp = (LPWSTR) lpvMemG;
118	final_string=(char)malloc((strlen(tmpMap1->value)+strlen(tmpMap->value)+2)sizeof(char));
119	sprintf(final_string,"%s\|%s",tmpMap->value,tmpMap1->value);
120	for(s=final_string;s!='\0';s++){
121	lpszTmp++ = s;
122	}
123	*lpszTmp++ = '\0';
124	free(final_string);
125	return 0;
126	}
127
128	char* getStatus(int pid){
129	char lpszBuf=(char) malloc(SHMEMSIZE*sizeof(char));
130	int i=0;
131	LPWSTR lpszTmp=NULL;
132	LPVOID lpvMem = NULL;
133	HANDLE hMapObject = NULL;
134	BOOL fIgnore,fInit;
135	char tmp[100];
136	sprintf(tmp,"%i",pid);
137	if(hMapObject==NULL)
138	hMapObject = CreateFileMapping(
139	INVALID_HANDLE_VALUE, // use paging file
140	NULL, // default security attributes
141	PAGE_READWRITE, // read/write access
142	0, // size: high 32-bits
143	4096, // size: low 32-bits
144	TEXT(tmp)); // name of map object
145	if (hMapObject == NULL)
146	return FALSE;
147	if((GetLastError() != ERROR_ALREADY_EXISTS)){
148	fIgnore = UnmapViewOfFile(lpvMem);
149	fIgnore = CloseHandle(hMapObject);
150	return "-1";
151	}
152	fInit=TRUE;
153	if(lpvMem==NULL)
154	lpvMem = MapViewOfFile(
155	hMapObject, // object to map view of
156	FILE_MAP_READ, // read/write access
157	0, // high offset: map from
158	0, // low offset: beginning
159	0); // default: map entire file
160	if (lpvMem == NULL)
161	return "-1";
162	lpszTmp = (LPWSTR) lpvMem;
163	while (*lpszTmp){
164	lpszBuf[i] = (char)*lpszTmp;
165	*lpszTmp++;
166	lpszBuf[i+1] = '\0';
167	i++;
168	}
169	#ifdef DEBUG
170	fprintf(stderr,"READING STRING S %s\n",lpszBuf);
171	#endif
172	return (char*)lpszBuf;
173	}
174
175	void unhandleStatus(maps *conf){
176	BOOL fIgnore;
177	fIgnore = UnmapViewOfFile(lpvMemG);
178	fIgnore = CloseHandle(hMapObjectG);
179	}
180	#else
181
182	void unhandleStatus(maps *conf){
183	int shmid;
184	key_t key;
185	void *shm;
186	struct shmid_ds shmids;
187	map *tmpMap=getMapFromMaps(conf,"lenv","sid");
188	if(tmpMap!=NULL){
189	key=atoi(tmpMap->value);
190	if ((shmid = shmget(key, SHMSZ, IPC_CREAT \| 0666)) < 0) {
191	#ifdef DEBUG
192	fprintf(stderr,"shmget failed to update value\n");
193	#endif
194	}else{
195	if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
196	#ifdef DEBUG
197	fprintf(stderr,"shmat failed to update value\n");
198	#endif
199	}else{
200	shmdt(shm);
201	shmctl(shmid,IPC_RMID,&shmids);
202	}
203	}
204	}
205	}
206
207	int _updateStatus(maps *conf){
208	int shmid;
209	key_t key;
210	char shm,s,*s1;
211	map *tmpMap=NULL;
212	tmpMap=getMapFromMaps(conf,"lenv","sid");
213	if(tmpMap!=NULL){
214	key=atoi(tmpMap->value);
215	if ((shmid = shmget(key, SHMSZ, IPC_CREAT \| 0666)) < 0) {
216	#ifdef DEBUG
217	fprintf(stderr,"shmget failed to create new Shared memory segment\n");
218	#endif
219	return -2;
220	}else{
221	if ((shm = (char) shmat(shmid, NULL, 0)) == (char ) -1) {
222	#ifdef DEBUG
223	fprintf(stderr,"shmat failed to update value\n");
224	#endif
225	return -1;
226	}
227	else{
228	tmpMap=getMapFromMaps(conf,"lenv","status");
229	s1=shm;
230	for(s=tmpMap->value;s!=NULL && s!=0;s++){
231	s1++=s;
232	}
233	*s1++='\|';
234	tmpMap=getMapFromMaps(conf,"lenv","message");
235	if(tmpMap!=NULL)
236	for(s=tmpMap->value;s!=NULL && s!=0;s++){
237	s1++=s;
238	}
239	*s1=NULL;
240	shmdt((void *)shm);
241	}
242	}
243	}
244	return 0;
245	}
246
247	char* getStatus(int pid){
248	int shmid;
249	key_t key;
250	void *shm;
251	key=pid;
252	if ((shmid = shmget(key, SHMSZ, 0666)) < 0) {
253	#ifdef DEBUG
254	fprintf(stderr,"shmget failed in getStatus\n");
255	#endif
256	}else{
257	if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
258	#ifdef DEBUG
259	fprintf(stderr,"shmat failed in getStatus\n");
260	#endif
261	}else{
262	return (char*)shm;
263	}
264	}
265	return (char*)"-1";
266	}
267
268	#endif
269
270	#ifdef USE_JS
271
272	JSBool
273	JSUpdateStatus(JSContext cx, uintN argc, jsval argv1)
274	{
275	jsval *argv = JS_ARGV(cx,argv1);
276	JS_MaybeGC(cx);
277	int istatus=0;
278	char *status=NULL;
279	maps *conf;
280	if(argc>2){
281	#ifdef JS_DEBUG
282	fprintf(stderr,"Number of arguments used to call the function : %i",argc);
283	#endif
284	return JS_FALSE;
285	}
286	conf=mapsFromJSObject(cx,argv[0]);
287	if(JS_ValueToInt32(cx,argv[1],&istatus)==JS_TRUE){
288	char tmpStatus[4];
289	sprintf(tmpStatus,"%i",istatus);
290	tmpStatus[3]=0;
291	status=strdup(tmpStatus);
292	}
293	if(getMapFromMaps(conf,"lenv","status")!=NULL){
294	if(status!=NULL){
295	setMapInMaps(conf,"lenv","status",status);
296	free(status);
297	}
298	else
299	setMapInMaps(conf,"lenv","status","15");
300	_updateStatus(conf);
301	}
302	freeMaps(&conf);
303	free(conf);
304	JS_MaybeGC(cx);
305	return JS_TRUE;
306	}
307
308	#endif
309
310
311
312	/* Returns a url-encoded version of str */
313	/* IMPORTANT: be sure to free() the returned string after use */
314	char url_encode(char str) {
315	char pstr = str, buf = (char) malloc(strlen(str) 3 + 1), *pbuf = buf;
316	while (*pstr) {
317	if (isalnum(pstr) \|\| pstr == '-' \|\| pstr == '_' \|\| pstr == '.' \|\| *pstr == '~')
318	pbuf++ = pstr;
319	else if (*pstr == ' ')
320	*pbuf++ = '+';
321	else
322	pbuf++ = '%', pbuf++ = to_hex(pstr >> 4), pbuf++ = to_hex(*pstr & 15);
323	pstr++;
324	}
325	*pbuf = '\0';
326	return buf;
327	}
328
329	/* Returns a url-decoded version of str */
330	/* IMPORTANT: be sure to free() the returned string after use */
331	char url_decode(char str) {
332	char pstr = str, buf = (char) malloc(strlen(str) + 1), pbuf = buf;
333	while (*pstr) {
334	if (*pstr == '%') {
335	if (pstr[1] && pstr[2]) {
336	*pbuf++ = from_hex(pstr[1]) << 4 \| from_hex(pstr[2]);
337	pstr += 2;
338	}
339	} else if (*pstr == '+') {
340	*pbuf++ = ' ';
341	} else {
342	pbuf++ = pstr;
343	}
344	pstr++;
345	}
346	*pbuf = '\0';
347	return buf;
348	}
349
350	char zCapitalize1(char tmp){
351	char *res=strdup(tmp);
352	if(res[0]>=97 && res[0]<=122)
353	res[0]-=32;
354	return res;
355	}
356
357	char zCapitalize(char tmp){
358	int i=0;
359	char *res=strdup(tmp);
360	for(i=0;i<strlen(res);i++)
361	if(res[i]>=97 && res[i]<=122)
362	res[i]-=32;
363	return res;
364	}
365
366
367	int zooXmlSearchForNs(const char* name){
368	int i;
369	int res=-1;
370	for(i=0;i<nbNs;i++)
371	if(strncasecmp(name,nsName[i],strlen(nsName[i]))==0){
372	res=i;
373	break;
374	}
375	return res;
376	}
377
378	int zooXmlAddNs(xmlNodePtr nr,const char* url,const char* name){
379	#ifdef DEBUG
380	fprintf(stderr,"zooXmlAddNs %d %s \n",nbNs,name);
381	#endif
382	int currId=-1;
383	if(nbNs==0){
384	nbNs++;
385	currId=0;
386	nsName[currId]=strdup(name);
387	usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
388	}else{
389	currId=zooXmlSearchForNs(name);
390	if(currId<0){
391	nbNs++;
392	currId=nbNs-1;
393	nsName[currId]=strdup(name);
394	usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
395	}
396	}
397	return currId;
398	}
399
400	void zooXmlCleanupNs(){
401	int j;
402	#ifdef DEBUG
403	fprintf(stderr,"zooXmlCleanup %d\n",nbNs);
404	#endif
405	for(j=nbNs-1;j>=0;j--){
406	#ifdef DEBUG
407	fprintf(stderr,"zooXmlCleanup %d\n",j);
408	#endif
409	if(j==0)
410	xmlFreeNs(usedNs[j]);
411	free(nsName[j]);
412	nbNs--;
413	}
414	nbNs=0;
415	}
416
417
418	int zooXmlAddDoc(const char* value){
419	int currId=0;
420	nbDocs++;
421	currId=nbDocs-1;
422	iDocs[currId]=xmlParseMemory(value,strlen(value));
423	return currId;
424	}
425
426	void zooXmlCleanupDocs(){
427	int j;
428	for(j=nbDocs-1;j>=0;j--){
429	xmlFreeDoc(iDocs[j]);
430	}
431	nbDocs=0;
432	}
433
434
435	xmlNodePtr soapEnvelope(maps* conf,xmlNodePtr n){
436	map* soap=getMapFromMaps(conf,"main","isSoap");
437	if(soap!=NULL && strcasecmp(soap->value,"true")==0){
438	int lNbNs=nbNs;
439	nsName[lNbNs]=strdup("soap");
440	usedNs[lNbNs]=xmlNewNs(NULL,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
441	nbNs++;
442	xmlNodePtr nr = xmlNewNode(usedNs[lNbNs], BAD_CAST "Envelope");
443	nsName[nbNs]=strdup("soap");
444	usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
445	nbNs++;
446	nsName[nbNs]=strdup("xsi");
447	usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
448	nbNs++;
449	xmlNsPtr ns_xsi=usedNs[nbNs-1];
450	xmlNewNsProp(nr,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.w3.org/2003/05/soap-envelope http://www.w3.org/2003/05/soap-envelope");
451	xmlNodePtr nr1 = xmlNewNode(usedNs[lNbNs], BAD_CAST "Body");
452	xmlAddChild(nr1,n);
453	xmlAddChild(nr,nr1);
454	return nr;
455	}else
456	return n;
457	}
458
459	xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr doc,const char* service,maps* m){
460
461	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
462	xmlNodePtr n,nc,nc1,nc2,nc3,nc4,nc5,nc6;
463	/**
464	* Create the document and its temporary root.
465	*/
466	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
467	ns=usedNs[wpsId];
468	maps* toto1=getMaps(m,"main");
469
470	n = xmlNewNode(ns, BAD_CAST "Capabilities");
471	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
472	ns_ows=usedNs[owsId];
473	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
474	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
475	ns_xsi=usedNs[xsiId];
476	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
477	ns_xlink=usedNs[xlinkId];
478	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd");
479	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
480	addLangAttr(n,m);
481
482	if(toto1!=NULL){
483	map* tmp=getMap(toto1->content,"version");
484	if(tmp!=NULL){
485	xmlNewProp(n,BAD_CAST "version",BAD_CAST tmp->value);
486	}
487	else
488	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
489	}
490	else
491	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
492
493	char tmp[256];
494
495	nc = xmlNewNode(ns_ows, BAD_CAST "ServiceIdentification");
496	maps* tmp4=getMaps(m,"identification");
497	if(tmp4!=NULL){
498	map* tmp2=tmp4->content;
499	const char *orderedFields[5];
500	orderedFields[0]="Title";
501	orderedFields[1]="Abstract";
502	orderedFields[2]="Keywords";
503	orderedFields[3]="Fees";
504	orderedFields[4]="AccessConstraints";
505	int oI=0;
506	for(oI=0;oI<5;oI++)
507	if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
508	if(strcasecmp(tmp2->name,"abstract")==0 \|\|
509	strcasecmp(tmp2->name,"title")==0 \|\|
510	strcasecmp(tmp2->name,"accessConstraints")==0 \|\|
511	strcasecmp(tmp2->name,"fees")==0){
512	tmp2->name[0]=toupper(tmp2->name[0]);
513	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
514	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
515	xmlAddChild(nc,nc1);
516	}
517	else
518	if(strcmp(tmp2->name,"keywords")==0){
519	nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
520	char *toto=tmp2->value;
521	char buff[256];
522	int i=0;
523	int j=0;
524	while(toto[i]){
525	if(toto[i]!=',' && toto[i]!=0){
526	buff[j]=toto[i];
527	buff[j+1]=0;
528	j++;
529	}
530	else{
531	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
532	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
533	xmlAddChild(nc1,nc2);
534	j=0;
535	}
536	i++;
537	}
538	if(strlen(buff)>0){
539	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
540	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
541	xmlAddChild(nc1,nc2);
542	}
543	xmlAddChild(nc,nc1);
544	nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceType");
545	xmlAddChild(nc2,xmlNewText(BAD_CAST "WPS"));
546	xmlAddChild(nc,nc2);
547	nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceTypeVersion");
548	xmlAddChild(nc2,xmlNewText(BAD_CAST "1.0.0"));
549	xmlAddChild(nc,nc2);
550	}
551	tmp2=tmp2->next;
552	}
553	}
554	else{
555	fprintf(stderr,"TMP4 NOT FOUND !!");
556	return NULL;
557	}
558	xmlAddChild(n,nc);
559
560	nc = xmlNewNode(ns_ows, BAD_CAST "ServiceProvider");
561	nc3 = xmlNewNode(ns_ows, BAD_CAST "ServiceContact");
562	nc4 = xmlNewNode(ns_ows, BAD_CAST "ContactInfo");
563	nc5 = xmlNewNode(ns_ows, BAD_CAST "Phone");
564	nc6 = xmlNewNode(ns_ows, BAD_CAST "Address");
565	tmp4=getMaps(m,"provider");
566	if(tmp4!=NULL){
567	map* tmp2=tmp4->content;
568	const char *tmpAddress[6];
569	tmpAddress[0]="addressDeliveryPoint";
570	tmpAddress[1]="addressCity";
571	tmpAddress[2]="addressAdministrativeArea";
572	tmpAddress[3]="addressPostalCode";
573	tmpAddress[4]="addressCountry";
574	tmpAddress[5]="addressElectronicMailAddress";
575	const char *tmpPhone[2];
576	tmpPhone[0]="phoneVoice";
577	tmpPhone[1]="phoneFacsimile";
578	const char *orderedFields[12];
579	orderedFields[0]="providerName";
580	orderedFields[1]="providerSite";
581	orderedFields[2]="individualName";
582	orderedFields[3]="positionName";
583	orderedFields[4]=tmpPhone[0];
584	orderedFields[5]=tmpPhone[1];
585	orderedFields[6]=tmpAddress[0];
586	orderedFields[7]=tmpAddress[1];
587	orderedFields[8]=tmpAddress[2];
588	orderedFields[9]=tmpAddress[3];
589	orderedFields[10]=tmpAddress[4];
590	orderedFields[11]=tmpAddress[5];
591	int oI=0;
592	for(oI=0;oI<12;oI++)
593	if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
594	if(strcmp(tmp2->name,"keywords")!=0 &&
595	strcmp(tmp2->name,"serverAddress")!=0 &&
596	strcmp(tmp2->name,"lang")!=0){
597	tmp2->name[0]=toupper(tmp2->name[0]);
598	if(strcmp(tmp2->name,"ProviderName")==0){
599	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
600	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
601	xmlAddChild(nc,nc1);
602	}
603	else{
604	if(strcmp(tmp2->name,"ProviderSite")==0){
605	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
606	xmlNewNsProp(nc1,ns_xlink,BAD_CAST "href",BAD_CAST tmp2->value);
607	xmlAddChild(nc,nc1);
608	}
609	else
610	if(strcmp(tmp2->name,"IndividualName")==0 \|\|
611	strcmp(tmp2->name,"PositionName")==0){
612	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
613	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
614	xmlAddChild(nc3,nc1);
615	}
616	else
617	if(strncmp(tmp2->name,"Phone",5)==0){
618	int j;
619	for(j=0;j<2;j++)
620	if(strcasecmp(tmp2->name,tmpPhone[j])==0){
621	char *tmp4=tmp2->name;
622	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+5);
623	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
624	xmlAddChild(nc5,nc1);
625	}
626	}
627	else
628	if(strncmp(tmp2->name,"Address",7)==0){
629	int j;
630	for(j=0;j<6;j++)
631	if(strcasecmp(tmp2->name,tmpAddress[j])==0){
632	char *tmp4=tmp2->name;
633	nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+7);
634	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
635	xmlAddChild(nc6,nc1);
636	}
637	}
638	}
639	}
640	else
641	if(strcmp(tmp2->name,"keywords")==0){
642	nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
643	char *toto=tmp2->value;
644	char buff[256];
645	int i=0;
646	int j=0;
647	while(toto[i]){
648	if(toto[i]!=',' && toto[i]!=0){
649	buff[j]=toto[i];
650	buff[j+1]=0;
651	j++;
652	}
653	else{
654	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
655	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
656	xmlAddChild(nc1,nc2);
657	j=0;
658	}
659	i++;
660	}
661	if(strlen(buff)>0){
662	nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
663	xmlAddChild(nc2,xmlNewText(BAD_CAST buff));
664	xmlAddChild(nc1,nc2);
665	}
666	xmlAddChild(nc,nc1);
667	}
668	tmp2=tmp2->next;
669	}
670	}
671	else{
672	fprintf(stderr,"TMP4 NOT FOUND !!");
673	}
674	xmlAddChild(nc4,nc5);
675	xmlAddChild(nc4,nc6);
676	xmlAddChild(nc3,nc4);
677	xmlAddChild(nc,nc3);
678	xmlAddChild(n,nc);
679
680
681	nc = xmlNewNode(ns_ows, BAD_CAST "OperationsMetadata");
682	char *tmp2[3];
683	tmp2[0]=strdup("GetCapabilities");
684	tmp2[1]=strdup("DescribeProcess");
685	tmp2[2]=strdup("Execute");
686	int j=0;
687
688	if(toto1!=NULL){
689	map* tmp=getMap(toto1->content,"serverAddress");
690	if(tmp!=NULL){
691	SERVICE_URL = strdup(tmp->value);
692	}
693	else
694	SERVICE_URL = strdup("not_found");
695	}
696	else
697	SERVICE_URL = strdup("not_found");
698
699	for(j=0;j<3;j++){
700	nc1 = xmlNewNode(ns_ows, BAD_CAST "Operation");
701	xmlNewProp(nc1,BAD_CAST "name",BAD_CAST tmp2[j]);
702	nc2 = xmlNewNode(ns_ows, BAD_CAST "DCP");
703	nc3 = xmlNewNode(ns_ows, BAD_CAST "HTTP");
704	nc4 = xmlNewNode(ns_ows, BAD_CAST "Get");
705	sprintf(tmp,"%s/%s",SERVICE_URL,service);
706	xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
707	xmlAddChild(nc3,nc4);
708	if(j>0){
709	nc4 = xmlNewNode(ns_ows, BAD_CAST "Post");
710	xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
711	xmlAddChild(nc3,nc4);
712	}
713	xmlAddChild(nc2,nc3);
714	xmlAddChild(nc1,nc2);
715	xmlAddChild(nc,nc1);
716	}
717	for(j=2;j>=0;j--)
718	free(tmp2[j]);
719	xmlAddChild(n,nc);
720
721	nc = xmlNewNode(ns, BAD_CAST "ProcessOfferings");
722	xmlAddChild(n,nc);
723
724	nc1 = xmlNewNode(ns, BAD_CAST "Languages");
725	nc2 = xmlNewNode(ns, BAD_CAST "Default");
726	nc3 = xmlNewNode(ns, BAD_CAST "Supported");
727
728	toto1=getMaps(m,"main");
729	if(toto1!=NULL){
730	map* tmp1=getMap(toto1->content,"lang");
731	char *toto=tmp1->value;
732	char buff[256];
733	int i=0;
734	int j=0;
735	int dcount=0;
736	while(toto[i]){
737	if(toto[i]!=',' && toto[i]!=0){
738	buff[j]=toto[i];
739	buff[j+1]=0;
740	j++;
741	}
742	else{
743	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
744	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
745	if(dcount==0){
746	xmlAddChild(nc2,nc4);
747	xmlAddChild(nc1,nc2);
748	dcount++;
749	}
750	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
751	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
752	xmlAddChild(nc3,nc4);
753	j=0;
754	buff[j]=0;
755	}
756	i++;
757	}
758	if(strlen(buff)>0){
759	nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
760	xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
761	xmlAddChild(nc3,nc4);
762	}
763	}
764	xmlAddChild(nc1,nc3);
765	xmlAddChild(n,nc1);
766
767	xmlNodePtr fn=soapEnvelope(m,n);
768	xmlDocSetRootElement(doc, fn);
769	//xmlFreeNs(ns);
770	free(SERVICE_URL);
771	return nc;
772	}
773
774	void addPrefix(maps* conf,map* level,service* serv){
775	if(level!=NULL){
776	char key[25];
777	char* prefix=NULL;
778	int clevel=atoi(level->value);
779	int cl=0;
780	for(cl=0;cl<clevel;cl++){
781	sprintf(key,"sprefix_%d",cl);
782	map* tmp2=getMapFromMaps(conf,"lenv",key);
783	if(tmp2!=NULL){
784	if(prefix==NULL)
785	prefix=zStrdup(tmp2->value);
786	else{
787	int plen=strlen(prefix);
788	prefix=(char)realloc(prefix,(plen+strlen(tmp2->value)+2)sizeof(char));
789	memcpy(prefix+plen,tmp2->value,strlen(tmp2->value)*sizeof(char));
790	prefix[plen+strlen(tmp2->value)]=0;
791	}
792	}
793	}
794	if(prefix!=NULL){
795	char* tmp0=strdup(serv->name);
796	free(serv->name);
797	serv->name=(char)malloc((strlen(prefix)+strlen(tmp0)+1)sizeof(char));
798	sprintf(serv->name,"%s%s",prefix,tmp0);
799	free(tmp0);
800	free(prefix);
801	prefix=NULL;
802	}
803	}
804	}
805
806	void printGetCapabilitiesForProcess(maps* m,xmlNodePtr nc,service* serv){
807	xmlNsPtr ns,ns_ows,ns_xlink;
808	xmlNodePtr n=NULL,nc1,nc2;
809	/**
810	* Initialize or get existing namspaces
811	*/
812	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
813	ns=usedNs[wpsId];
814	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
815	ns_ows=usedNs[owsId];
816	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
817	ns_xlink=usedNs[xlinkId];
818
819	map* tmp1;
820	if(serv->content!=NULL){
821	nc1 = xmlNewNode(ns, BAD_CAST "Process");
822	tmp1=getMap(serv->content,"processVersion");
823	if(tmp1!=NULL)
824	xmlNewNsProp(nc1,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
825	map* tmp3=getMapFromMaps(m,"lenv","level");
826	addPrefix(m,tmp3,serv);
827	printDescription(nc1,ns_ows,serv->name,serv->content);
828	tmp1=serv->metadata;
829	while(tmp1!=NULL){
830	nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
831	xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
832	xmlAddChild(nc1,nc2);
833	tmp1=tmp1->next;
834	}
835	xmlAddChild(nc,nc1);
836	}
837	}
838
839	xmlNodePtr printDescribeProcessHeader(xmlDocPtr doc,const char* service,maps* m){
840
841	xmlNsPtr ns,ns_xsi;
842	xmlNodePtr n;
843
844	int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
845	ns=usedNs[wpsId];
846	n = xmlNewNode(ns, BAD_CAST "ProcessDescriptions");
847	zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
848	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
849	zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
850	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
851	ns_xsi=usedNs[xsiId];
852
853	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd");
854	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
855	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
856	addLangAttr(n,m);
857
858	xmlNodePtr fn=soapEnvelope(m,n);
859	xmlDocSetRootElement(doc, fn);
860
861	return n;
862	}
863
864	void printDescribeProcessForProcess(maps* m,xmlNodePtr nc,service* serv){
865	xmlNsPtr ns,ns_ows,ns_xlink;
866	xmlNodePtr n,nc1;
867
868	n=nc;
869
870	int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
871	ns=usedNs[wpsId];
872	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
873	ns_ows=usedNs[owsId];
874	int xlinkId=zooXmlAddNs(NULL,"http://www.w3.org/1999/xlink","xlink");
875	ns_xlink=usedNs[xlinkId];
876
877	nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
878	const char *tmp4[3];
879	tmp4[0]="processVersion";
880	tmp4[1]="storeSupported";
881	tmp4[2]="statusSupported";
882	int j=0;
883	map* tmp1=NULL;
884	for(j=0;j<3;j++){
885	tmp1=getMap(serv->content,tmp4[j]);
886	if(tmp1!=NULL){
887	if(j==0)
888	xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
889	else
890	xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST tmp1->value);
891	}
892	else{
893	if(j>0)
894	xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST "false");
895	}
896	}
897
898	tmp1=getMapFromMaps(m,"lenv","level");
899	addPrefix(m,tmp1,serv);
900	printDescription(nc,ns_ows,serv->name,serv->content);
901
902	tmp1=serv->metadata;
903	while(tmp1!=NULL){
904	nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
905	xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
906	xmlAddChild(nc,nc1);
907	tmp1=tmp1->next;
908	}
909
910	tmp1=getMap(serv->content,"Profile");
911	if(tmp1!=NULL){
912	nc1 = xmlNewNode(ns, BAD_CAST "Profile");
913	xmlAddChild(nc1,xmlNewText(BAD_CAST tmp1->value));
914	xmlAddChild(nc,nc1);
915	}
916
917	if(serv->inputs!=NULL){
918	nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
919	elements* e=serv->inputs;
920	printFullDescription(1,e,"Input",ns_ows,nc1);
921	xmlAddChild(nc,nc1);
922	}
923
924	nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
925	elements* e=serv->outputs;
926	printFullDescription(0,e,"Output",ns_ows,nc1);
927	xmlAddChild(nc,nc1);
928
929	xmlAddChild(n,nc);
930
931	}
932
933	void printFullDescription(int in,elements elem,const char type,xmlNsPtr ns_ows,xmlNodePtr nc1){
934	const char *orderedFields[13];
935	orderedFields[0]="mimeType";
936	orderedFields[1]="encoding";
937	orderedFields[2]="schema";
938	orderedFields[3]="dataType";
939	orderedFields[4]="uom";
940	orderedFields[5]="CRS";
941	orderedFields[6]="value";
942	orderedFields[7]="AllowedValues";
943	orderedFields[8]="range";
944	orderedFields[9]="rangeMin";
945	orderedFields[10]="rangeMax";
946	orderedFields[11]="rangeClosure";
947	orderedFields[12]="rangeSpace";
948
949	xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7,nc8,nc9;
950	elements* e=elem;
951
952	map* tmp1=NULL;
953	while(e!=NULL){
954	int default1=0;
955	int isAnyValue=1;
956	nc2 = xmlNewNode(NULL, BAD_CAST type);
957	if(strncmp(type,"Input",5)==0){
958	tmp1=getMap(e->content,"minOccurs");
959	if(tmp1!=NULL){
960	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
961	}else
962	xmlNewProp(nc2,BAD_CAST "minOccurs",BAD_CAST "0");
963	tmp1=getMap(e->content,"maxOccurs");
964	if(tmp1!=NULL){
965	if(strcasecmp(tmp1->value,"unbounded")!=0)
966	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
967	else
968	xmlNewProp(nc2,BAD_CAST "maxOccurs",BAD_CAST "1000");
969	}else
970	xmlNewProp(nc2,BAD_CAST "maxOccurs",BAD_CAST "1");
971	if((tmp1=getMap(e->content,"maximumMegabytes"))!=NULL){
972	xmlNewProp(nc2,BAD_CAST "maximumMegabytes",BAD_CAST tmp1->value);
973	}
974	}
975
976	printDescription(nc2,ns_ows,e->name,e->content);
977
978	/**
979	* Build the (Literal/Complex/BoundingBox)Data node
980	*/
981	if(strncmp(type,"Output",6)==0){
982	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
983	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
984	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
985	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
986	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
987	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
988	else
989	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
990	}else{
991	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
992	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
993	}
994	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
995	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexData");
996	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
997	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxData");
998	else
999	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
1000	}
1001
1002	iotype* _tmp0=NULL;
1003	iotype* _tmp=e->defaults;
1004	int datatype=0;
1005	bool hasUOM=false;
1006	bool hasUOM1=false;
1007	if(_tmp!=NULL){
1008	if(strcmp(e->format,"LiteralOutput")==0 \|\|
1009	strcmp(e->format,"LiteralData")==0){
1010	datatype=1;
1011	nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
1012	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
1013	}
1014	else if(strcmp(e->format,"BoundingBoxOutput")==0 \|\|
1015	strcmp(e->format,"BoundingBoxData")==0){
1016	datatype=2;
1017	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
1018	}
1019	else{
1020	nc4 = xmlNewNode(NULL, BAD_CAST "Default");
1021	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1022	}
1023
1024	tmp1=_tmp->content;
1025
1026	if((tmp1=getMap(_tmp->content,"DataType"))!=NULL){
1027	nc8 = xmlNewNode(ns_ows, BAD_CAST "DataType");
1028	xmlAddChild(nc8,xmlNewText(BAD_CAST tmp1->value));
1029	char tmp[1024];
1030	sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
1031	xmlNewNsProp(nc8,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
1032	xmlAddChild(nc3,nc8);
1033	datatype=1;
1034	}
1035
1036	if(strncmp(type,"Input",5)==0){
1037
1038	if((tmp1=getMap(_tmp->content,"AllowedValues"))!=NULL){
1039	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1040	char token,saveptr1;
1041	token=strtok_r(tmp1->value,",",&saveptr1);
1042	while(token!=NULL){
1043	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1044	char *tmps=strdup(token);
1045	tmps[strlen(tmps)]=0;
1046	xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
1047	free(tmps);
1048	xmlAddChild(nc6,nc7);
1049	token=strtok_r(NULL,",",&saveptr1);
1050	}
1051	if(getMap(_tmp->content,"range")!=NULL \|\|
1052	getMap(_tmp->content,"rangeMin")!=NULL \|\|
1053	getMap(_tmp->content,"rangeMax")!=NULL \|\|
1054	getMap(_tmp->content,"rangeClosure")!=NULL )
1055	goto doRange;
1056	xmlAddChild(nc3,nc6);
1057	isAnyValue=-1;
1058	}
1059
1060	tmp1=getMap(_tmp->content,"range");
1061	if(tmp1==NULL)
1062	tmp1=getMap(_tmp->content,"rangeMin");
1063	if(tmp1==NULL)
1064	tmp1=getMap(_tmp->content,"rangeMax");
1065
1066	if(tmp1!=NULL && isAnyValue==1){
1067	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1068	doRange:
1069
1070	/**
1071	* Range: Table 46 OGC Web Services Common Standard
1072	*/
1073	nc8 = xmlNewNode(ns_ows, BAD_CAST "Range");
1074
1075	map* tmp0=getMap(tmp1,"range");
1076	if(tmp0!=NULL){
1077	char* pToken;
1078	char* orig=zStrdup(tmp0->value);
1079	/**
1080	* RangeClosure: Table 47 OGC Web Services Common Standard
1081	*/
1082	const char *tmp="closed";
1083	if(orig[0]=='[' && orig[strlen(orig)-1]=='[')
1084	tmp="closed-open";
1085	else
1086	if(orig[0]==']' && orig[strlen(orig)-1]==']')
1087	tmp="open-closed";
1088	else
1089	if(orig[0]==']' && orig[strlen(orig)-1]=='[')
1090	tmp="open";
1091	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
1092	pToken=strtok(orig,",");
1093	int nci0=0;
1094	while(pToken!=NULL){
1095	char tmpStr=(char) malloc((strlen(pToken))*sizeof(char));
1096	if(nci0==0){
1097	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1098	int nci=1;
1099	for(nci=1;nci<strlen(pToken);nci++){
1100	tmpStr[nci-1]=pToken[nci];
1101	}
1102	}else{
1103	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1104	int nci=0;
1105	for(nci=0;nci<strlen(pToken)-1;nci++){
1106	tmpStr[nci]=pToken[nci];
1107	}
1108	}
1109	xmlAddChild(nc7,xmlNewText(BAD_CAST tmpStr));
1110	free(tmpStr);
1111	xmlAddChild(nc8,nc7);
1112	nci0++;
1113	pToken = strtok(NULL,",");
1114	}
1115	if(getMap(tmp1,"rangeSpacing")==NULL){
1116	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
1117	xmlAddChild(nc7,xmlNewText(BAD_CAST "1"));
1118	xmlAddChild(nc8,nc7);
1119	}
1120	free(orig);
1121	}else{
1122
1123	tmp0=getMap(tmp1,"rangeMin");
1124	if(tmp0!=NULL){
1125	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1126	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1127	xmlAddChild(nc8,nc7);
1128	}else{
1129	nc7 = xmlNewNode(ns_ows, BAD_CAST "MinimumValue");
1130	xmlAddChild(nc8,nc7);
1131	}
1132	tmp0=getMap(tmp1,"rangeMax");
1133	if(tmp0!=NULL){
1134	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1135	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1136	xmlAddChild(nc8,nc7);
1137	}else{
1138	nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
1139	xmlAddChild(nc8,nc7);
1140	}
1141	tmp0=getMap(tmp1,"rangeSpacing");
1142	if(tmp0!=NULL){
1143	nc7 = xmlNewNode(ns_ows, BAD_CAST "Spacing");
1144	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp0->value));
1145	xmlAddChild(nc8,nc7);
1146	}
1147	tmp0=getMap(tmp1,"rangeClosure");
1148	if(tmp0!=NULL){
1149	const char *tmp="closed";
1150	if(strcasecmp(tmp0->value,"co")==0)
1151	tmp="closed-open";
1152	else
1153	if(strcasecmp(tmp0->value,"oc")==0)
1154	tmp="open-closed";
1155	else
1156	if(strcasecmp(tmp0->value,"o")==0)
1157	tmp="open";
1158	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST tmp);
1159	}else
1160	xmlNewNsProp(nc8,ns_ows,BAD_CAST "rangeClosure",BAD_CAST "closed");
1161	}
1162	if(_tmp0==NULL){
1163	xmlAddChild(nc6,nc8);
1164	_tmp0=e->supported;
1165	if(getMap(_tmp0->content,"range")!=NULL \|\|
1166	getMap(_tmp0->content,"rangeMin")!=NULL \|\|
1167	getMap(_tmp0->content,"rangeMax")!=NULL \|\|
1168	getMap(_tmp0->content,"rangeClosure")!=NULL ){
1169	tmp1=_tmp0->content;
1170	goto doRange;
1171	}
1172	}else{
1173	_tmp0=_tmp0->next;
1174	if(_tmp0!=NULL){
1175	xmlAddChild(nc6,nc8);
1176	if(getMap(_tmp0->content,"range")!=NULL \|\|
1177	getMap(_tmp0->content,"rangeMin")!=NULL \|\|
1178	getMap(_tmp0->content,"rangeMax")!=NULL \|\|
1179	getMap(_tmp0->content,"rangeClosure")!=NULL ){
1180	tmp1=_tmp0->content;
1181	goto doRange;
1182	}
1183	}
1184	}
1185	xmlAddChild(nc6,nc8);
1186	xmlAddChild(nc3,nc6);
1187	isAnyValue=-1;
1188	}
1189
1190	}
1191
1192
1193	int oI=0;
1194	for(oI=0;oI<13;oI++)
1195	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1196	#ifdef DEBUG
1197	printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
1198	#endif
1199	if(strcmp(tmp1->name,"asReference")!=0 &&
1200	strncasecmp(tmp1->name,"DataType",8)!=0 &&
1201	strcasecmp(tmp1->name,"extension")!=0 &&
1202	strcasecmp(tmp1->name,"value")!=0 &&
1203	strcasecmp(tmp1->name,"AllowedValues")!=0 &&
1204	strncasecmp(tmp1->name,"range",5)!=0){
1205	if(datatype!=1){
1206	char *tmp2=zCapitalize1(tmp1->name);
1207	nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
1208	free(tmp2);
1209	}
1210	else{
1211	char *tmp2=zCapitalize(tmp1->name);
1212	nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1213	free(tmp2);
1214	}
1215	xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
1216	xmlAddChild(nc5,nc9);
1217	if(strcasecmp(tmp1->name,"uom")==0)
1218	hasUOM1=true;
1219	hasUOM=true;
1220	}else
1221
1222	tmp1=tmp1->next;
1223	}
1224
1225
1226	if(datatype!=2){
1227	if(hasUOM==true){
1228	xmlAddChild(nc4,nc5);
1229	xmlAddChild(nc3,nc4);
1230	}else{
1231	if(hasUOM1==false){
1232	xmlFreeNode(nc5);
1233	if(datatype==1)
1234	xmlFreeNode(nc4);
1235	}
1236	}
1237	}else{
1238	xmlAddChild(nc3,nc5);
1239	}
1240
1241	if(datatype!=1 && default1<0){
1242	xmlFreeNode(nc5);
1243	if(datatype!=2)
1244	xmlFreeNode(nc4);
1245	}
1246
1247	map* metadata=e->metadata;
1248	xmlNodePtr n=NULL;
1249	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1250	xmlNsPtr ns_xlink=usedNs[xlinkId];
1251
1252	while(metadata!=NULL){
1253	nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
1254	xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
1255	xmlAddChild(nc2,nc6);
1256	metadata=metadata->next;
1257	}
1258
1259	}
1260
1261	_tmp=e->supported;
1262	if(_tmp==NULL && datatype!=1)
1263	_tmp=e->defaults;
1264
1265	int hasSupported=-1;
1266
1267	while(_tmp!=NULL){
1268	if(hasSupported<0){
1269	if(datatype==0){
1270	nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
1271	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1272	}
1273	else
1274	nc5 = xmlNewNode(NULL, BAD_CAST "Supported");
1275	hasSupported=0;
1276	}else
1277	if(datatype==0)
1278	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1279	tmp1=_tmp->content;
1280	int oI=0;
1281	for(oI=0;oI<6;oI++)
1282	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1283	#ifdef DEBUG
1284	printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
1285	#endif
1286	if(strcmp(tmp1->name,"asReference")!=0 &&
1287	strcmp(tmp1->name,"value")!=0 &&
1288	strcmp(tmp1->name,"DataType")!=0 &&
1289	strcasecmp(tmp1->name,"extension")!=0){
1290	if(datatype!=1){
1291	char *tmp2=zCapitalize1(tmp1->name);
1292	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1293	free(tmp2);
1294	}
1295	else{
1296	char *tmp2=zCapitalize(tmp1->name);
1297	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1298	free(tmp2);
1299	}
1300	if(datatype==2){
1301	char tmpv,tmps;
1302	tmps=strtok_r(tmp1->value,",",&tmpv);
1303	while(tmps){
1304	xmlAddChild(nc6,xmlNewText(BAD_CAST tmps));
1305	tmps=strtok_r(NULL,",",&tmpv);
1306	if(tmps){
1307	char *tmp2=zCapitalize1(tmp1->name);
1308	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1309	free(tmp2);
1310	}
1311	}
1312	}
1313	else{
1314	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
1315	}
1316	xmlAddChild(nc5,nc6);
1317	}
1318	tmp1=tmp1->next;
1319	}
1320	if(hasSupported<=0){
1321	if(datatype==0){
1322	xmlAddChild(nc4,nc5);
1323	xmlAddChild(nc3,nc4);
1324	}else{
1325	if(datatype!=1)
1326	xmlAddChild(nc3,nc5);
1327	}
1328	hasSupported=1;
1329	}
1330	else
1331	if(datatype==0){
1332	xmlAddChild(nc4,nc5);
1333	xmlAddChild(nc3,nc4);
1334	}
1335	else
1336	if(datatype!=1)
1337	xmlAddChild(nc3,nc5);
1338
1339	_tmp=_tmp->next;
1340	}
1341
1342	if(hasSupported==0){
1343	if(datatype==0)
1344	xmlFreeNode(nc4);
1345	xmlFreeNode(nc5);
1346	}
1347
1348	_tmp=e->defaults;
1349	if(datatype==1 && hasUOM1==true){
1350	xmlAddChild(nc4,nc5);
1351	xmlAddChild(nc3,nc4);
1352	}
1353
1354	if(in>0 && datatype==1 &&
1355	getMap(_tmp->content,"AllowedValues")==NULL &&
1356	getMap(_tmp->content,"range")==NULL &&
1357	getMap(_tmp->content,"rangeMin")==NULL &&
1358	getMap(_tmp->content,"rangeMax")==NULL &&
1359	getMap(_tmp->content,"rangeClosure")==NULL ){
1360	tmp1=getMap(_tmp->content,"dataType");
1361	if(tmp1!=NULL)
1362	if(strcasecmp(tmp1->value,"boolean")==0){
1363	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1364	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1365	xmlAddChild(nc7,xmlNewText(BAD_CAST "true"));
1366	xmlAddChild(nc6,nc7);
1367	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1368	xmlAddChild(nc7,xmlNewText(BAD_CAST "false"));
1369	xmlAddChild(nc6,nc7);
1370	xmlAddChild(nc3,nc6);
1371	}
1372	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
1373	}
1374
1375	if((tmp1=getMap(_tmp->content,"value"))!=NULL){
1376	nc7 = xmlNewNode(NULL, BAD_CAST "DefaultValue");
1377	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp1->value));
1378	xmlAddChild(nc3,nc7);
1379	}
1380
1381	xmlAddChild(nc2,nc3);
1382
1383	xmlAddChild(nc1,nc2);
1384
1385	e=e->next;
1386	}
1387	}
1388
1389	void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
1390	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1391	xmlNodePtr nr,n,nc,nc1=NULL,nc3;
1392	xmlDocPtr doc;
1393	time_t time1;
1394	time(&time1);
1395	nr=NULL;
1396	/**
1397	* Create the document and its temporary root.
1398	*/
1399	doc = xmlNewDoc(BAD_CAST "1.0");
1400	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
1401	ns=usedNs[wpsId];
1402
1403	n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
1404	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
1405	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
1406	ns_ows=usedNs[owsId];
1407	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1408	ns_xlink=usedNs[xlinkId];
1409	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1410	ns_xsi=usedNs[xsiId];
1411
1412	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsExecute_response.xsd");
1413
1414	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1415	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
1416	addLangAttr(n,m);
1417
1418	char tmp[256];
1419	char url[1024];
1420	char stored_path[1024];
1421	memset(tmp,0,256);
1422	memset(url,0,1024);
1423	memset(stored_path,0,1024);
1424	maps* tmp_maps=getMaps(m,"main");
1425	if(tmp_maps!=NULL){
1426	map* tmpm1=getMap(tmp_maps->content,"serverAddress");
1427	/**
1428	* Check if the ZOO Service GetStatus is available in the local directory.
1429	* If yes, then it uses a reference to an URL which the client can access
1430	* to get information on the status of a running Service (using the
1431	* percentCompleted attribute).
1432	* Else fallback to the initial method using the xml file to write in ...
1433	*/
1434	char ntmp[1024];
1435	#ifndef WIN32
1436	getcwd(ntmp,1024);
1437	#else
1438	_getcwd(ntmp,1024);
1439	#endif
1440	struct stat myFileInfo;
1441	int statRes;
1442	char file_path[1024];
1443	sprintf(file_path,"%s/GetStatus.zcfg",ntmp);
1444	statRes=stat(file_path,&myFileInfo);
1445	if(statRes==0){
1446	char currentSid[128];
1447	map* tmpm=getMap(tmp_maps->content,"rewriteUrl");
1448	map *tmp_lenv=NULL;
1449	tmp_lenv=getMapFromMaps(m,"lenv","sid");
1450	if(tmp_lenv==NULL)
1451	sprintf(currentSid,"%i",pid);
1452	else
1453	sprintf(currentSid,"%s",tmp_lenv->value);
1454	if(tmpm==NULL \|\| strcasecmp(tmpm->value,"false")==0){
1455	sprintf(url,"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1456	}else{
1457	if(strlen(tmpm->value)>0)
1458	if(strcasecmp(tmpm->value,"true")!=0)
1459	sprintf(url,"%s/%s/GetStatus/%s",tmpm1->value,tmpm->value,currentSid);
1460	else
1461	sprintf(url,"%s/GetStatus/%s",tmpm1->value,currentSid);
1462	else
1463	sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1464	}
1465	}else{
1466	map* tmpm2=getMap(tmp_maps->content,"tmpUrl");
1467	if(tmpm1!=NULL && tmpm2!=NULL){
1468	if( strncasecmp( tmpm2->value, "http://", 7) == 0 \|\|
1469	strncasecmp( tmpm2->value, "https://", 8 ) == 0 ){
1470	sprintf(url,"%s/%s_%i.xml",tmpm2->value,service,pid);
1471	}else
1472	sprintf(url,"%s/%s/%s_%i.xml",tmpm1->value,tmpm2->value,service,pid);
1473	}
1474	}
1475	if(tmpm1!=NULL)
1476	sprintf(tmp,"%s",tmpm1->value);
1477	tmpm1=getMapFromMaps(m,"main","TmpPath");
1478	sprintf(stored_path,"%s/%s_%i.xml",tmpm1->value,service,pid);
1479	}
1480
1481
1482
1483	xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
1484	map* test=getMap(request,"storeExecuteResponse");
1485	bool hasStoredExecuteResponse=false;
1486	if(test!=NULL && strcasecmp(test->value,"true")==0){
1487	xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
1488	hasStoredExecuteResponse=true;
1489	}
1490
1491	nc = xmlNewNode(ns, BAD_CAST "Process");
1492	map* tmp2=getMap(serv->content,"processVersion");
1493	if(tmp2!=NULL)
1494	xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp2->value);
1495
1496	printDescription(nc,ns_ows,serv->name,serv->content);
1497
1498	xmlAddChild(n,nc);
1499
1500	nc = xmlNewNode(ns, BAD_CAST "Status");
1501	const struct tm *tm;
1502	size_t len;
1503	time_t now;
1504	char *tmp1;
1505	map *tmpStatus;
1506
1507	now = time ( NULL );
1508	tm = localtime ( &now );
1509
1510	tmp1 = (char)malloc((TIME_SIZE+1)sizeof(char));
1511
1512	len = strftime ( tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm );
1513
1514	xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
1515
1516	char sMsg[2048];
1517	switch(status){
1518	case SERVICE_SUCCEEDED:
1519	nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
1520	sprintf(sMsg,_("Service \"%s\" run successfully."),serv->name);
1521	nc3=xmlNewText(BAD_CAST sMsg);
1522	xmlAddChild(nc1,nc3);
1523	break;
1524	case SERVICE_STARTED:
1525	nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
1526	tmpStatus=getMapFromMaps(m,"lenv","status");
1527	xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST tmpStatus->value);
1528	sprintf(sMsg,_("ZOO Service \"%s\" is currently running. Please, reload this document to get the up-to-date status of the Service."),serv->name);
1529	nc3=xmlNewText(BAD_CAST sMsg);
1530	xmlAddChild(nc1,nc3);
1531	break;
1532	case SERVICE_ACCEPTED:
1533	nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
1534	sprintf(sMsg,_("Service \"%s\" was accepted by the ZOO Kernel and it run as a background task. Please consult the statusLocation attribtue providen in this document to get the up-to-date document."),serv->name);
1535	nc3=xmlNewText(BAD_CAST sMsg);
1536	xmlAddChild(nc1,nc3);
1537	break;
1538	case SERVICE_FAILED:
1539	nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
1540	map *errorMap;
1541	map *te;
1542	te=getMapFromMaps(m,"lenv","code");
1543	if(te!=NULL)
1544	errorMap=createMap("code",te->value);
1545	else
1546	errorMap=createMap("code","NoApplicableCode");
1547	te=getMapFromMaps(m,"lenv","message");
1548	if(te!=NULL)
1549	addToMap(errorMap,"text",_ss(te->value));
1550	else
1551	addToMap(errorMap,"text",_("No more information available"));
1552	nc3=createExceptionReportNode(m,errorMap,0);
1553	freeMap(&errorMap);
1554	free(errorMap);
1555	xmlAddChild(nc1,nc3);
1556	break;
1557	default :
1558	printf(_("error code not know : %i\n"),status);
1559	//exit(1);
1560	break;
1561	}
1562	xmlAddChild(nc,nc1);
1563	xmlAddChild(n,nc);
1564	free(tmp1);
1565
1566	#ifdef DEBUG
1567	fprintf(stderr,"printProcessResponse 1 161\n");
1568	#endif
1569
1570	map* lineage=getMap(request,"lineage");
1571	if(lineage!=NULL && strcasecmp(lineage->value,"true")==0){
1572	nc = xmlNewNode(ns, BAD_CAST "DataInputs");
1573	maps* mcursor=inputs;
1574	elements* scursor=NULL;
1575	while(mcursor!=NULL /&& scursor!=NULL/){
1576	scursor=getElements(serv->inputs,mcursor->name);
1577	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Input");
1578	mcursor=mcursor->next;
1579	}
1580	xmlAddChild(n,nc);
1581
1582	#ifdef DEBUG
1583	fprintf(stderr,"printProcessResponse 1 177\n");
1584	#endif
1585
1586	nc = xmlNewNode(ns, BAD_CAST "OutputDefinitions");
1587	mcursor=outputs;
1588	scursor=NULL;
1589	while(mcursor!=NULL){
1590	scursor=getElements(serv->outputs,mcursor->name);
1591	printOutputDefinitions1(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
1592	mcursor=mcursor->next;
1593	}
1594	xmlAddChild(n,nc);
1595	}
1596	#ifdef DEBUG
1597	fprintf(stderr,"printProcessResponse 1 190\n");
1598	#endif
1599
1600	/**
1601	* Display the process output only when requested !
1602	*/
1603	if(status==SERVICE_SUCCEEDED){
1604	nc = xmlNewNode(ns, BAD_CAST "ProcessOutputs");
1605	maps* mcursor=outputs;
1606	elements* scursor=serv->outputs;
1607	map* testResponse=getMap(request,"RawDataOutput");
1608	if(testResponse==NULL)
1609	testResponse=getMap(request,"ResponseDocument");
1610	while(mcursor!=NULL){
1611	map* tmp0=getMap(mcursor->content,"inRequest");
1612	scursor=getElements(serv->outputs,mcursor->name);
1613	if(scursor!=NULL){
1614	if(testResponse==NULL \|\| tmp0==NULL)
1615	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1616	else
1617	if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0)
1618	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1619	}else
1620	/**
1621	* In case there was no definition found in the ZCFG file but
1622	* present in the service code
1623	*/
1624	printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1625	mcursor=mcursor->next;
1626	}
1627	xmlAddChild(n,nc);
1628	}
1629
1630	#ifdef DEBUG
1631	fprintf(stderr,"printProcessResponse 1 202\n");
1632	#endif
1633	nr=soapEnvelope(m,n);
1634	xmlDocSetRootElement(doc, nr);
1635
1636	if(hasStoredExecuteResponse==true){
1637	/* We need to write the ExecuteResponse Document somewhere */
1638	FILE* output=fopen(stored_path,"w");
1639	if(output==NULL){
1640	/* If the file cannot be created return an ExceptionReport */
1641	char tmpMsg[1024];
1642	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the ExecuteResponse."),stored_path);
1643	map * errormap = createMap("text",tmpMsg);
1644	addToMap(errormap,"code", "InternalError");
1645	printExceptionReportResponse(m,errormap);
1646	freeMap(&errormap);
1647	free(errormap);
1648	xmlFreeDoc(doc);
1649	xmlCleanupParser();
1650	zooXmlCleanupNs();
1651	return;
1652	}
1653	xmlChar *xmlbuff;
1654	int buffersize;
1655	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, "UTF-8", 1);
1656	fwrite(xmlbuff,1,xmlStrlen(xmlbuff)*sizeof(char),output);
1657	xmlFree(xmlbuff);
1658	fclose(output);
1659	}
1660	printDocument(m,doc,pid);
1661
1662	xmlCleanupParser();
1663	zooXmlCleanupNs();
1664	}
1665
1666
1667	void printDocument(maps* m, xmlDocPtr doc,int pid){
1668	char *encoding=getEncoding(m);
1669	if(pid==getpid()){
1670	printHeaders(m);
1671	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1672	}
1673	fflush(stdout);
1674	xmlChar *xmlbuff;
1675	int buffersize;
1676	/*
1677	* Dump the document to a buffer and print it on stdout
1678	* for demonstration purposes.
1679	*/
1680	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
1681	printf("%s",xmlbuff);
1682	fflush(stdout);
1683	/*
1684	* Free associated memory.
1685	*/
1686	xmlFree(xmlbuff);
1687	xmlFreeDoc(doc);
1688	xmlCleanupParser();
1689	zooXmlCleanupNs();
1690	}
1691
1692	void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,const char* type){
1693	xmlNodePtr nc1;
1694	nc1=xmlNewNode(ns_wps, BAD_CAST type);
1695	map *tmp=NULL;
1696	if(e!=NULL && e->defaults!=NULL)
1697	tmp=e->defaults->content;
1698	else{
1699	/*
1700	dumpElements(e);
1701	*/
1702	return;
1703	}
1704	while(tmp!=NULL){
1705	if(strncasecmp(tmp->name,"MIMETYPE",strlen(tmp->name))==0
1706	\|\| strncasecmp(tmp->name,"ENCODING",strlen(tmp->name))==0
1707	\|\| strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
1708	\|\| strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
1709	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
1710	tmp=tmp->next;
1711	}
1712	tmp=getMap(e->defaults->content,"asReference");
1713	if(tmp==NULL)
1714	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
1715
1716	tmp=e->content;
1717
1718	printDescription(nc1,ns_ows,m->name,e->content);
1719
1720	xmlAddChild(nc,nc1);
1721
1722	}
1723
1724	void printOutputDefinitions(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,map* m,const char* type){
1725	xmlNodePtr nc1;
1726	nc1=xmlNewNode(ns_wps, BAD_CAST type);
1727	map *tmp=NULL;
1728	if(e!=NULL && e->defaults!=NULL)
1729	tmp=e->defaults->content;
1730	else{
1731	/*
1732	dumpElements(e);
1733	*/
1734	return;
1735	}
1736	while(tmp!=NULL){
1737	xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
1738	tmp=tmp->next;
1739	}
1740	tmp=getMap(e->defaults->content,"asReference");
1741	if(tmp==NULL)
1742	xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
1743
1744	tmp=e->content;
1745
1746	printDescription(nc1,ns_ows,m->name,e->content);
1747
1748	xmlAddChild(nc,nc1);
1749
1750	}
1751
1752	void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
1753	xmlNodePtr nc1,nc2,nc3;
1754	nc1=xmlNewNode(ns_wps, BAD_CAST type);
1755	map *tmp=NULL;
1756	if(e!=NULL)
1757	tmp=e->content;
1758	else
1759	tmp=m->content;
1760	#ifdef DEBUG
1761	dumpMap(tmp);
1762	dumpElements(e);
1763	#endif
1764	nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
1765	if(e!=NULL)
1766	nc3=xmlNewText(BAD_CAST e->name);
1767	else
1768	nc3=xmlNewText(BAD_CAST m->name);
1769	xmlAddChild(nc2,nc3);
1770	xmlAddChild(nc1,nc2);
1771	xmlAddChild(nc,nc1);
1772	if(e!=NULL)
1773	tmp=getMap(e->content,"Title");
1774	else
1775	tmp=getMap(m->content,"Title");
1776
1777	if(tmp!=NULL){
1778	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
1779	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
1780	xmlAddChild(nc2,nc3);
1781	xmlAddChild(nc1,nc2);
1782	}
1783
1784	if(e!=NULL)
1785	tmp=getMap(e->content,"Abstract");
1786	else
1787	tmp=getMap(m->content,"Abstract");
1788	if(tmp!=NULL){
1789	nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
1790	nc3=xmlNewText(BAD_CAST _ss(tmp->value));
1791	xmlAddChild(nc2,nc3);
1792	xmlAddChild(nc1,nc2);
1793	xmlAddChild(nc,nc1);
1794	}
1795
1796	/**
1797	* IO type Reference or full Data ?
1798	*/
1799	#ifdef DEBUG
1800	fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
1801	#endif
1802	map *tmpMap=getMap(m->content,"Reference");
1803	if(tmpMap==NULL){
1804	nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
1805	if(e!=NULL){
1806	if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
1807	nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
1808	else
1809	if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
1810	nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
1811	else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
1812	nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
1813	else
1814	nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
1815	}
1816	else{
1817	map* tmpV=getMapFromMaps(m,"format","value");
1818	if(tmpV!=NULL)
1819	nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
1820	else
1821	nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
1822	}
1823	tmp=m->content;
1824	#ifdef USE_MS
1825	map* testMap=getMap(tmp,"requestedMimeType");
1826	#endif
1827	while(tmp!=NULL){
1828	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
1829	strcasecmp(tmp->name,"encoding")==0 \|\|
1830	strcasecmp(tmp->name,"schema")==0 \|\|
1831	strcasecmp(tmp->name,"datatype")==0 \|\|
1832	strcasecmp(tmp->name,"uom")==0){
1833	#ifdef USE_MS
1834	if(testMap==NULL \|\| (testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)==0)){
1835	#endif
1836	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1837	#ifdef USE_MS
1838	}
1839	else
1840	if(strcasecmp(tmp->name,"mimeType")==0){
1841	if(testMap!=NULL)
1842	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
1843	else
1844	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1845	}
1846	#endif
1847	}
1848	tmp=tmp->next;
1849	xmlAddChild(nc2,nc3);
1850	}
1851	if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
1852	map* bb=getMap(m->content,"value");
1853	if(bb!=NULL){
1854	map* tmpRes=parseBoundingBox(bb->value);
1855	printBoundingBox(ns_ows,nc3,tmpRes);
1856	freeMap(&tmpRes);
1857	free(tmpRes);
1858	}
1859	}else{
1860	if(e!=NULL)
1861	tmp=getMap(e->defaults->content,"mimeType");
1862	else
1863	tmp=NULL;
1864	#ifdef USE_MS
1865	/**
1866	* In case of OGC WebServices output use, as the data was requested
1867	* with asReference=false we have to download the resulting OWS request
1868	* stored in the Reference map value.
1869	*/
1870	map* testMap=getMap(m->content,"requestedMimeType");
1871	if(testMap!=NULL){
1872	HINTERNET hInternet;
1873	char* tmpValue;
1874	size_t dwRead;
1875	hInternet=InternetOpen(
1876	#ifndef WIN32
1877	(LPCTSTR)
1878	#endif
1879	"ZooWPSClient\0",
1880	INTERNET_OPEN_TYPE_PRECONFIG,
1881	NULL,NULL, 0);
1882	testMap=getMap(m->content,"Reference");
1883	loadRemoteFile(&m,&m->content,&hInternet,testMap->value);
1884	processDownloads(&hInternet);
1885	tmpValue=(char)malloc((hInternet.ihandle[0].nDataLen+1)sizeof(char));
1886	InternetReadFile(hInternet.ihandle[0],(LPVOID)tmpValue,hInternet.ihandle[0].nDataLen,&dwRead);
1887	InternetCloseHandle(&hInternet);
1888	}
1889	#endif
1890	map* tmp1=getMap(m->content,"encoding");
1891	map* tmp2=getMap(m->content,"mimeType");
1892	map* tmp3=getMap(m->content,"value");
1893	int hasValue=1;
1894	if(tmp3==NULL){
1895	tmp3=createMap("value","");
1896	hasValue=-1;
1897	}
1898	if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
1899	\|\| (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 \|\|
1900	(strncmp(tmp2->value,"application/",12)==0 &&
1901	strncmp(tmp2->value,"application/json",16)!=0&&
1902	strncmp(tmp2->value,"application/x-javascript",24)!=0&&
1903	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)!=0))
1904	)) {
1905	map* rs=getMap(m->content,"size");
1906	bool isSized=true;
1907	if(rs==NULL){
1908	char tmp1[1024];
1909	sprintf(tmp1,"%u",strlen(tmp3->value));
1910	rs=createMap("size",tmp1);
1911	isSized=false;
1912	}
1913
1914	xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
1915	if(!isSized){
1916	freeMap(&rs);
1917	free(rs);
1918	}
1919	}
1920	else if(tmp2!=NULL){
1921	if(strncmp(tmp2->value,"text/js",7)==0 \|\|
1922	strncmp(tmp2->value,"application/json",16)==0)
1923	xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
1924	else{
1925	if(strncmp(tmp2->value,"text/xml",8)==0 \|\|
1926	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
1927	int li=zooXmlAddDoc(tmp3->value);
1928	xmlDocPtr doc = iDocs[li];
1929	xmlNodePtr ir = xmlDocGetRootElement(doc);
1930	xmlAddChild(nc3,ir);
1931	}
1932	else
1933	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
1934	}
1935	xmlAddChild(nc2,nc3);
1936	}
1937	else{
1938	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
1939	}
1940	if(hasValue<0){
1941	freeMap(&tmp3);
1942	free(tmp3);
1943	}
1944	}
1945	}
1946	else{
1947	tmpMap=getMap(m->content,"Reference");
1948	nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
1949	if(strcasecmp(type,"Output")==0)
1950	xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
1951	else
1952	xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
1953	tmp=m->content;
1954	#ifdef USE_MS
1955	map* testMap=getMap(tmp,"requestedMimeType");
1956	#endif
1957	while(tmp!=NULL){
1958	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
1959	strcasecmp(tmp->name,"encoding")==0 \|\|
1960	strcasecmp(tmp->name,"schema")==0 \|\|
1961	strcasecmp(tmp->name,"datatype")==0 \|\|
1962	strcasecmp(tmp->name,"uom")==0){
1963	#ifdef USE_MS
1964	if(testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)!=0){
1965	if(strcasecmp(tmp->name,"mimeType")==0)
1966	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
1967	}
1968	else
1969	#endif
1970	if(strcasecmp(tmp->name,"datatype")==0)
1971	xmlNewProp(nc3,BAD_CAST "mimeType",BAD_CAST "text/plain");
1972	else
1973	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1974	}
1975	tmp=tmp->next;
1976	xmlAddChild(nc2,nc3);
1977	}
1978	}
1979	xmlAddChild(nc1,nc2);
1980	xmlAddChild(nc,nc1);
1981
1982	}
1983
1984	void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
1985	xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
1986
1987	xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
1988	xmlAddChild(root,nc2);
1989	map* tmp=amap;
1990	const char *tmp2[2];
1991	tmp2[0]="Title";
1992	tmp2[1]="Abstract";
1993	int j=0;
1994	for(j=0;j<2;j++){
1995	map* tmp1=getMap(tmp,tmp2[j]);
1996	if(tmp1!=NULL){
1997	nc2 = xmlNewNode(ns_ows, BAD_CAST tmp2[j]);
1998	xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
1999	xmlAddChild(root,nc2);
2000	}
2001	}
2002	}
2003
2004	char* getEncoding(maps* m){
2005	if(m!=NULL){
2006	map* tmp=getMap(m->content,"encoding");
2007	if(tmp!=NULL){
2008	return tmp->value;
2009	}
2010	else
2011	return (char*)"UTF-8";
2012	}
2013	else
2014	return (char*)"UTF-8";
2015	}
2016
2017	char* getVersion(maps* m){
2018	if(m!=NULL){
2019	map* tmp=getMap(m->content,"version");
2020	if(tmp!=NULL){
2021	return tmp->value;
2022	}
2023	else
2024	return (char*)"1.0.0";
2025	}
2026	else
2027	return (char*)"1.0.0";
2028	}
2029
2030	void printExceptionReportResponse(maps* m,map* s){
2031	if(getMapFromMaps(m,"lenv","hasPrinted")!=NULL)
2032	return;
2033	int buffersize;
2034	xmlDocPtr doc;
2035	xmlChar *xmlbuff;
2036	xmlNodePtr n;
2037
2038	zooXmlCleanupNs();
2039	doc = xmlNewDoc(BAD_CAST "1.0");
2040	maps* tmpMap=getMaps(m,"main");
2041	char *encoding=getEncoding(tmpMap);
2042	const char *exceptionCode;
2043
2044	map* tmp=getMap(s,"code");
2045	if(tmp!=NULL){
2046	if(strcmp(tmp->value,"OperationNotSupported")==0)
2047	exceptionCode="501 Not Implemented";
2048	else
2049	if(strcmp(tmp->value,"MissingParameterValue")==0 \|\|
2050	strcmp(tmp->value,"InvalidUpdateSequence")==0 \|\|
2051	strcmp(tmp->value,"OptionNotSupported")==0 \|\|
2052	strcmp(tmp->value,"VersionNegotiationFailed")==0 \|\|
2053	strcmp(tmp->value,"InvalidParameterValue")==0)
2054	exceptionCode="400 Bad request";
2055	else
2056	if(strcmp(tmp->value,"NoApplicableCode")==0)
2057	exceptionCode="501 Internal Server Error";
2058	else
2059	exceptionCode="501 Internal Server Error";
2060	}
2061	else
2062	exceptionCode="501 Internal Server Error";
2063
2064	if(m!=NULL){
2065	map *tmpSid=getMapFromMaps(m,"lenv","sid");
2066	if(tmpSid!=NULL){
2067	if( getpid()==atoi(tmpSid->value) ){
2068	printHeaders(m);
2069	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2070	}
2071	}
2072	else{
2073	printHeaders(m);
2074	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2075	}
2076	}else{
2077	printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
2078	}
2079	n=createExceptionReportNode(m,s,1);
2080	xmlDocSetRootElement(doc, n);
2081	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2082	printf("%s",xmlbuff);
2083	fflush(stdout);
2084	xmlFreeDoc(doc);
2085	xmlFree(xmlbuff);
2086	xmlCleanupParser();
2087	zooXmlCleanupNs();
2088	if(m!=NULL)
2089	setMapInMaps(m,"lenv","hasPrinted","true");
2090	}
2091
2092	xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
2093
2094	xmlNsPtr ns,ns_xsi;
2095	xmlNodePtr n,nc,nc1;
2096
2097	int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows","ows");
2098	ns=usedNs[nsid];
2099	if(use_ns==1){
2100	ns=NULL;
2101	}
2102	n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
2103	if(use_ns==1){
2104	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",NULL);
2105	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2106	ns_xsi=usedNs[xsiId];
2107	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsExceptionReport.xsd");
2108	}
2109
2110
2111	addLangAttr(n,m);
2112	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.1.0");
2113
2114	nc = xmlNewNode(ns, BAD_CAST "Exception");
2115
2116	map* tmp=getMap(s,"code");
2117	if(tmp!=NULL)
2118	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST tmp->value);
2119	else
2120	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST "NoApplicableCode");
2121
2122	tmp=getMap(s,"locator");
2123	if(tmp!=NULL && strcasecmp(tmp->value,"NULL")!=0)
2124	xmlNewProp(nc,BAD_CAST "locator",BAD_CAST tmp->value);
2125
2126
2127	tmp=getMap(s,"text");
2128	nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
2129	if(tmp!=NULL){
2130	xmlNodeSetContent(nc1, BAD_CAST tmp->value);
2131	}
2132	else{
2133	xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
2134	}
2135	xmlAddChild(nc,nc1);
2136	xmlAddChild(n,nc);
2137	return n;
2138	}
2139
2140
2141	void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
2142	map* request_inputs1,int cpid,maps* m,int res){
2143	#ifdef DEBUG
2144	dumpMaps(request_inputs);
2145	dumpMaps(request_outputs);
2146	fprintf(stderr,"printProcessResponse\n");
2147	#endif
2148	map* toto=getMap(request_inputs1,"RawDataOutput");
2149	int asRaw=0;
2150	if(toto!=NULL)
2151	asRaw=1;
2152
2153	maps* tmpSess=getMaps(m,"senv");
2154	if(tmpSess!=NULL){
2155	map *_tmp=getMapFromMaps(m,"lenv","cookie");
2156	char* sessId=NULL;
2157	if(_tmp!=NULL){
2158	printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
2159	printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
2160	char session_file_path[100];
2161	char *tmp1=strtok(_tmp->value,";");
2162	if(tmp1!=NULL)
2163	sprintf(session_file_path,"%s",strstr(tmp1,"=")+1);
2164	else
2165	sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
2166	sessId=strdup(session_file_path);
2167	}else{
2168	maps* t=getMaps(m,"senv");
2169	map*p=t->content;
2170	while(p!=NULL){
2171	if(strstr(p->name,"ID")!=NULL){
2172	sessId=strdup(p->value);
2173	break;
2174	}
2175	p=p->next;
2176	}
2177	}
2178	char session_file_path[1024];
2179	map *tmpPath=getMapFromMaps(m,"main","sessPath");
2180	if(tmpPath==NULL)
2181	tmpPath=getMapFromMaps(m,"main","tmpPath");
2182	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,sessId);
2183	FILE* teste=fopen(session_file_path,"w");
2184	if(teste==NULL){
2185	char tmpMsg[1024];
2186	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the session maps."),session_file_path);
2187	map * errormap = createMap("text",tmpMsg);
2188	addToMap(errormap,"code", "InternalError");
2189
2190	printExceptionReportResponse(m,errormap);
2191	freeMap(&errormap);
2192	free(errormap);
2193	return;
2194	}
2195	else{
2196	fclose(teste);
2197	dumpMapsToFile(tmpSess,session_file_path);
2198	}
2199	}
2200
2201
2202	if(asRaw==0){
2203	#ifdef DEBUG
2204	fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
2205	dumpMaps(request_outputs);
2206	#endif
2207	maps* tmpI=request_outputs;
2208	while(tmpI!=NULL){
2209	#ifdef USE_MS
2210	map* testMap=getMap(tmpI->content,"useMapserver");
2211	#endif
2212	toto=getMap(tmpI->content,"asReference");
2213	#ifdef USE_MS
2214	if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
2215	#else
2216	if(toto!=NULL && strcasecmp(toto->value,"true")==0)
2217	#endif
2218	{
2219	elements* in=getElements(s->outputs,tmpI->name);
2220	char *format=NULL;
2221	if(in!=NULL){
2222	format=strdup(in->format);
2223	}else
2224	format=strdup("LiteralData");
2225	if(strcasecmp(format,"BoundingBoxData")==0){
2226	addToMap(tmpI->content,"extension","xml");
2227	addToMap(tmpI->content,"mimeType","text/xml");
2228	addToMap(tmpI->content,"encoding","UTF-8");
2229	addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
2230	}
2231	map *ext=getMap(tmpI->content,"extension");
2232	map *tmp1=getMapFromMaps(m,"main","tmpPath");
2233	char file_name,file_path;
2234	bool hasExt=true;
2235	if(ext==NULL){
2236	// We can fallback to a default list of supported formats using
2237	// mimeType information if present here. Maybe we can add more formats
2238	// here.
2239	// If mimeType was not found, we then set txt as the default extension
2240	map* mtype=getMap(tmpI->content,"mimeType");
2241	if(mtype!=NULL){
2242	if(strcasecmp(mtype->value,"text/xml")==0)
2243	ext=createMap("extension","xml");
2244	else if(strcasecmp(mtype->value,"application/json")==0)
2245	ext=createMap("extension","js");
2246	else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
2247	ext=createMap("extension","kml");
2248	else if(strncmp(mtype->value,"image/",6)==0)
2249	ext=createMap("extension",strstr(mtype->value,"/")+1);
2250	else
2251	ext=createMap("extension","txt");
2252	}
2253	else
2254	ext=createMap("extension","txt");
2255	hasExt=false;
2256	}
2257	file_name=(char)malloc((strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+1024)sizeof(char));
2258	int cpid0=cpid+time(NULL);
2259	sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,ext->value);
2260	file_path=(char)malloc((strlen(tmp1->value)+strlen(file_name)+2)sizeof(char));
2261	sprintf(file_path,"%s/%s",tmp1->value,file_name);
2262	FILE *ofile=fopen(file_path,"wb");
2263	if(ofile==NULL){
2264	char tmpMsg[1024];
2265	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the %s final result."),file_name,tmpI->name);
2266	map * errormap = createMap("text",tmpMsg);
2267	addToMap(errormap,"code", "InternalError");
2268	printExceptionReportResponse(m,errormap);
2269	freeMap(&errormap);
2270	free(errormap);
2271	free(file_name);
2272	free(file_path);
2273	return;
2274	}
2275	free(file_path);
2276	map *tmp2=getMapFromMaps(m,"main","tmpUrl");
2277	map *tmp3=getMapFromMaps(m,"main","serverAddress");
2278	char *file_url;
2279	if(strncasecmp(tmp2->value,"http://",7)==0 \|\|
2280	strncasecmp(tmp2->value,"https://",8)==0){
2281	file_url=(char)malloc((strlen(tmp2->value)+strlen(file_name)+2)sizeof(char));
2282	sprintf(file_url,"%s/%s",tmp2->value,file_name);
2283	}else{
2284	file_url=(char)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)sizeof(char));
2285	sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
2286	}
2287	addToMap(tmpI->content,"Reference",file_url);
2288	if(!hasExt){
2289	freeMap(&ext);
2290	free(ext);
2291	}
2292	toto=getMap(tmpI->content,"value");
2293	if(strcasecmp(format,"BoundingBoxData")!=0){
2294	map* size=getMap(tmpI->content,"size");
2295	if(size!=NULL && toto!=NULL)
2296	fwrite(toto->value,1,atoi(size->value)*sizeof(char),ofile);
2297	else
2298	if(toto!=NULL && toto->value!=NULL)
2299	fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
2300	}else{
2301	printBoundingBoxDocument(m,tmpI,ofile);
2302	}
2303	free(format);
2304	fclose(ofile);
2305	free(file_name);
2306	free(file_url);
2307	}
2308	#ifdef USE_MS
2309	else{
2310	if(testMap!=NULL){
2311	setReferenceUrl(m,tmpI);
2312	}
2313	}
2314	#endif
2315	tmpI=tmpI->next;
2316	}
2317	map *r_inputs=getMap(s->content,"serviceProvider");
2318	#ifdef DEBUG
2319	fprintf(stderr,"SERVICE : %s\n",r_inputs->value);
2320	dumpMaps(m);
2321	#endif
2322	printProcessResponse(m,request_inputs1,cpid,
2323	s,r_inputs->value,res,
2324	request_inputs,
2325	request_outputs);
2326	}
2327	else{
2328	if(res==SERVICE_FAILED){
2329	map * errormap;
2330	map *lenv;
2331	lenv=getMapFromMaps(m,"lenv","message");
2332	char *tmp0;
2333	if(lenv!=NULL){
2334	tmp0=(char)malloc((strlen(lenv->value)+strlen(_("Unable to run the Service. The message returned back by the Service was the following: "))+1)sizeof(char));
2335	sprintf(tmp0,_("Unable to run the Service. The message returned back by the Service was the following: %s"),lenv->value);
2336	}
2337	else{
2338	tmp0=(char)malloc((strlen(_("Unable to run the Service. No more information was returned back by the Service."))+1)sizeof(char));
2339	sprintf(tmp0,_("Unable to run the Service. No more information was returned back by the Service."));
2340	}
2341	errormap = createMap("text",tmp0);
2342	free(tmp0);
2343	addToMap(errormap,"code", "InternalError");
2344	printExceptionReportResponse(m,errormap);
2345	freeMap(&errormap);
2346	free(errormap);
2347	return;
2348	}
2349	/**
2350	* We get the requested output or fallback to the first one if the
2351	* requested one is not present in the resulting outputs maps.
2352	*/
2353	maps* tmpI=NULL;
2354	map* tmpIV=getMap(request_inputs1,"RawDataOutput");
2355	if(tmpIV!=NULL){
2356	tmpI=getMaps(request_outputs,tmpIV->value);
2357	}
2358	if(tmpI==NULL)
2359	tmpI=request_outputs;
2360	elements* e=getElements(s->outputs,tmpI->name);
2361	if(e!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
2362	printBoundingBoxDocument(m,tmpI,NULL);
2363	}else{
2364	toto=getMap(tmpI->content,"value");
2365	if(toto==NULL){
2366	char tmpMsg[1024];
2367	sprintf(tmpMsg,_("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),tmpI->name);
2368	map * errormap = createMap("text",tmpMsg);
2369	addToMap(errormap,"code", "InvalidParameterValue");
2370	printExceptionReportResponse(m,errormap);
2371	freeMap(&errormap);
2372	free(errormap);
2373	return;
2374	}
2375	map* fname=getMapFromMaps(tmpI,tmpI->name,"filename");
2376	if(fname!=NULL)
2377	printf("Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
2378	map* rs=getMapFromMaps(tmpI,tmpI->name,"size");
2379	if(rs!=NULL)
2380	printf("Content-Length: %s\r\n",rs->value);
2381	printHeaders(m);
2382	char mime[1024];
2383	map* mi=getMap(tmpI->content,"mimeType");
2384	#ifdef DEBUG
2385	fprintf(stderr,"SERVICE OUTPUTS\n");
2386	dumpMaps(request_outputs);
2387	fprintf(stderr,"SERVICE OUTPUTS\n");
2388	#endif
2389	map* en=getMap(tmpI->content,"encoding");
2390	if(mi!=NULL && en!=NULL)
2391	sprintf(mime,
2392	"Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
2393	mi->value,en->value);
2394	else
2395	if(mi!=NULL)
2396	sprintf(mime,
2397	"Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
2398	mi->value);
2399	else
2400	sprintf(mime,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
2401	printf("%s",mime);
2402	if(rs!=NULL)
2403	fwrite(toto->value,1,atoi(rs->value),stdout);
2404	else
2405	fwrite(toto->value,1,strlen(toto->value),stdout);
2406	#ifdef DEBUG
2407	dumpMap(toto);
2408	#endif
2409	}
2410	}
2411	}
2412
2413	char base64(const char input, int length)
2414	{
2415	BIO bmem, b64;
2416	BUF_MEM *bptr;
2417
2418	b64 = BIO_new(BIO_f_base64());
2419	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
2420	bmem = BIO_new(BIO_s_mem());
2421	b64 = BIO_push(b64, bmem);
2422	BIO_write(b64, input, length);
2423	BIO_flush(b64);
2424	BIO_get_mem_ptr(b64, &bptr);
2425
2426	char buff = (char )malloc((bptr->length)*sizeof(char));
2427	memcpy(buff, bptr->data, bptr->length-1);
2428	buff[bptr->length-1] = 0;
2429
2430	BIO_free_all(b64);
2431
2432	return buff;
2433	}
2434
2435	char base64d(const char input, int length,int* red)
2436	{
2437	BIO b64, bmem;
2438
2439	char buffer = (char )malloc(length);
2440	if(buffer){
2441	memset(buffer, 0, length);
2442	b64 = BIO_new(BIO_f_base64());
2443	if(b64){
2444	bmem = BIO_new_mem_buf((unsigned char*)input,length);
2445	bmem = BIO_push(b64, bmem);
2446	*red=BIO_read(bmem, buffer, length);
2447	buffer[length-1]=0;
2448	BIO_free_all(bmem);
2449	}
2450	}
2451	return buffer;
2452	}
2453
2454	void ensureDecodedBase64(maps **in){
2455	maps* cursor=*in;
2456	while(cursor!=NULL){
2457	map *tmp=getMap(cursor->content,"encoding");
2458	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
2459	tmp=getMap(cursor->content,"value");
2460	addToMap(cursor->content,"base64_value",tmp->value);
2461	int size=0;
2462	char *s=strdup(tmp->value);
2463	free(tmp->value);
2464	tmp->value=base64d(s,strlen(s),&size);
2465	free(s);
2466	char sizes[1024];
2467	sprintf(sizes,"%d",size);
2468	addToMap(cursor->content,"size",sizes);
2469	}
2470	cursor=cursor->next;
2471	}
2472	}
2473
2474	char* addDefaultValues(maps** out,elements* in,maps* m,int type){
2475	elements* tmpInputs=in;
2476	maps* out1=*out;
2477	if(type==1){
2478	while(out1!=NULL){
2479	if(getElements(in,out1->name)==NULL)
2480	return out1->name;
2481	out1=out1->next;
2482	}
2483	out1=*out;
2484	}
2485	while(tmpInputs!=NULL){
2486	maps *tmpMaps=getMaps(out1,tmpInputs->name);
2487	if(tmpMaps==NULL){
2488	maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
2489	tmpMaps2->name=strdup(tmpInputs->name);
2490	tmpMaps2->content=NULL;
2491	tmpMaps2->next=NULL;
2492
2493	if(type==0){
2494	map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
2495	if(tmpMapMinO!=NULL){
2496	if(atoi(tmpMapMinO->value)>=1){
2497	freeMaps(&tmpMaps2);
2498	free(tmpMaps2);
2499	return tmpInputs->name;
2500	}
2501	else{
2502	if(tmpMaps2->content==NULL)
2503	tmpMaps2->content=createMap("minOccurs",tmpMapMinO->value);
2504	else
2505	addToMap(tmpMaps2->content,"minOccurs",tmpMapMinO->value);
2506	}
2507	}
2508	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2509	if(tmpMaxO!=NULL){
2510	if(tmpMaps2->content==NULL)
2511	tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
2512	else
2513	addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
2514	}
2515	map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
2516	if(tmpMaxMB!=NULL){
2517	if(tmpMaps2->content==NULL)
2518	tmpMaps2->content=createMap("maximumMegabytes",tmpMaxMB->value);
2519	else
2520	addToMap(tmpMaps2->content,"maximumMegabytes",tmpMaxMB->value);
2521	}
2522	}
2523
2524	iotype* tmpIoType=tmpInputs->defaults;
2525	if(tmpIoType!=NULL){
2526	map* tmpm=tmpIoType->content;
2527	while(tmpm!=NULL){
2528	if(tmpMaps2->content==NULL)
2529	tmpMaps2->content=createMap(tmpm->name,tmpm->value);
2530	else
2531	addToMap(tmpMaps2->content,tmpm->name,tmpm->value);
2532	tmpm=tmpm->next;
2533	}
2534	}
2535	addToMap(tmpMaps2->content,"inRequest","false");
2536	if(type==0){
2537	map *tmpMap=getMap(tmpMaps2->content,"value");
2538	if(tmpMap==NULL)
2539	addToMap(tmpMaps2->content,"value","NULL");
2540	}
2541	if(out1==NULL){
2542	*out=dupMaps(&tmpMaps2);
2543	out1=*out;
2544	}
2545	else
2546	addMapsToMaps(&out1,tmpMaps2);
2547	freeMap(&tmpMaps2->content);
2548	free(tmpMaps2->content);
2549	tmpMaps2->content=NULL;
2550	freeMaps(&tmpMaps2);
2551	free(tmpMaps2);
2552	tmpMaps2=NULL;
2553	}
2554	else{
2555	iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
2556	tmpMaps->content);
2557	if(type==0) {
2558	/**
2559	* In case of an Input maps, then add the minOccurs and maxOccurs to the
2560	* content map.
2561	*/
2562	map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
2563	if(tmpMap1!=NULL){
2564	if(tmpMaps->content==NULL)
2565	tmpMaps->content=createMap("minOccurs",tmpMap1->value);
2566	else
2567	addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
2568	}
2569	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2570	if(tmpMaxO!=NULL){
2571	if(tmpMaps->content==NULL)
2572	tmpMaps->content=createMap("maxOccurs",tmpMaxO->value);
2573	else
2574	addToMap(tmpMaps->content,"maxOccurs",tmpMaxO->value);
2575	}
2576	map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
2577	if(tmpMaxMB!=NULL){
2578	if(tmpMaps->content==NULL)
2579	tmpMaps->content=createMap("maximumMegabytes",tmpMaxMB->value);
2580	else
2581	addToMap(tmpMaps->content,"maximumMegabytes",tmpMaxMB->value);
2582	}
2583	/**
2584	* Parsing BoundingBoxData, fill the following map and then add it to
2585	* the content map of the Input maps:
2586	* lowerCorner, upperCorner, srs and dimensions
2587	* cf. parseBoundingBox
2588	*/
2589	if(strcasecmp(tmpInputs->format,"BoundingBoxData")==0){
2590	maps* tmpI=getMaps(*out,tmpInputs->name);
2591	if(tmpI!=NULL){
2592	map* tmpV=getMap(tmpI->content,"value");
2593	if(tmpV!=NULL){
2594	char *tmpVS=strdup(tmpV->value);
2595	map* tmp=parseBoundingBox(tmpVS);
2596	free(tmpVS);
2597	map* tmpC=tmp;
2598	while(tmpC!=NULL){
2599	addToMap(tmpMaps->content,tmpC->name,tmpC->value);
2600	tmpC=tmpC->next;
2601	}
2602	freeMap(&tmp);
2603	free(tmp);
2604	}
2605	}
2606	}
2607	}
2608
2609	if(tmpIoType!=NULL){
2610	map* tmpContent=tmpIoType->content;
2611	map* cval=NULL;
2612	int hasPassed=-1;
2613	while(tmpContent!=NULL){
2614	if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
2615	#ifdef DEBUG
2616	fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
2617	#endif
2618	if(tmpMaps->content==NULL)
2619	tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
2620	else
2621	addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
2622
2623	if(hasPassed<0 && type==0 && getMap(tmpMaps->content,"isArray")!=NULL){
2624	map* length=getMap(tmpMaps->content,"length");
2625	int i;
2626	char *tcn=strdup(tmpContent->name);
2627	for(i=1;i<atoi(length->value);i++){
2628	#ifdef DEBUG
2629	dumpMap(tmpMaps->content);
2630	fprintf(stderr,"addDefaultValues %s_%d => %s\n",tcn,i,tmpContent->value);
2631	#endif
2632	int len=strlen((char*) tcn);
2633	char tmp1=(char )malloc((len+10)*sizeof(char));
2634	sprintf(tmp1,"%s_%d",tcn,i);
2635	#ifdef DEBUG
2636	fprintf(stderr,"addDefaultValues %s => %s\n",tmp1,tmpContent->value);
2637	#endif
2638	addToMap(tmpMaps->content,tmp1,tmpContent->value);
2639	free(tmp1);
2640	hasPassed=1;
2641	}
2642	free(tcn);
2643	}
2644	}
2645	tmpContent=tmpContent->next;
2646	}
2647	#ifdef USE_MS
2648	/**
2649	* check for useMapServer presence
2650	*/
2651	map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
2652	if(tmpCheck!=NULL){
2653	// Get the default value
2654	tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
2655	tmpCheck=getMap(tmpMaps->content,"mimeType");
2656	addToMap(tmpMaps->content,"requestedMimeType",tmpCheck->value);
2657	map* cursor=tmpIoType->content;
2658	while(cursor!=NULL){
2659	addToMap(tmpMaps->content,cursor->name,cursor->value);
2660	cursor=cursor->next;
2661	}
2662
2663	cursor=tmpInputs->content;
2664	while(cursor!=NULL){
2665	if(strcasecmp(cursor->name,"Title")==0 \|\|
2666	strcasecmp(cursor->name,"Abstract")==0)
2667	addToMap(tmpMaps->content,cursor->name,cursor->value);
2668	cursor=cursor->next;
2669	}
2670	}
2671	#endif
2672	}
2673	if(tmpMaps->content==NULL)
2674	tmpMaps->content=createMap("inRequest","true");
2675	else
2676	addToMap(tmpMaps->content,"inRequest","true");
2677
2678	}
2679	tmpInputs=tmpInputs->next;
2680	}
2681	return "";
2682	}
2683
2684	/**
2685	* parseBoundingBox : parse a BoundingBox string
2686	*
2687	* OGC 06-121r3 : 10.2 Bounding box
2688	*
2689	* value is provided as : lowerCorner,upperCorner,crs,dimension
2690	* exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
2691	*
2692	* Need to create a map to store boundingbox informations :
2693	* - lowerCorner : double,double (minimum within this bounding box)
2694	* - upperCorner : double,double (maximum within this bounding box)
2695	* - crs : URI (Reference to definition of the CRS)
2696	* - dimensions : int
2697	*
2698	* Note : support only 2D bounding box.
2699	*/
2700	map* parseBoundingBox(const char* value){
2701	map *res=NULL;
2702	if(value!=NULL){
2703	char cv,cvp;
2704	cv=strtok_r((char*) value,",",&cvp);
2705	int cnt=0;
2706	int icnt=0;
2707	char *currentValue=NULL;
2708	while(cv){
2709	if(cnt<2)
2710	if(currentValue!=NULL){
2711	char finalValue=(char)malloc((strlen(currentValue)+strlen(cv)+1)*sizeof(char));
2712	sprintf(finalValue,"%s%s",currentValue,cv);
2713	switch(cnt){
2714	case 0:
2715	res=createMap("lowerCorner",finalValue);
2716	break;
2717	case 1:
2718	addToMap(res,"upperCorner",finalValue);
2719	icnt=-1;
2720	break;
2721	}
2722	cnt++;
2723	free(currentValue);
2724	currentValue=NULL;
2725	free(finalValue);
2726	}
2727	else{
2728	currentValue=(char)malloc((strlen(cv)+2)sizeof(char));
2729	sprintf(currentValue,"%s ",cv);
2730	}
2731	else
2732	if(cnt==2){
2733	addToMap(res,"crs",cv);
2734	cnt++;
2735	}
2736	else
2737	addToMap(res,"dimensions",cv);
2738	icnt++;
2739	cv=strtok_r(NULL,",",&cvp);
2740	}
2741	}
2742	return res;
2743	}
2744
2745	/**
2746	* printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
2747	* wps:BoundingBoxData). Set crs and dimensions attributes, add
2748	* Lower/UpperCorner nodes to a pre-existing XML node.
2749	*/
2750	void printBoundingBox(xmlNsPtr ns_ows,xmlNodePtr n,map* boundingbox){
2751
2752	xmlNodePtr lw=NULL,uc=NULL;
2753
2754	map* tmp=getMap(boundingbox,"value");
2755
2756	tmp=getMap(boundingbox,"lowerCorner");
2757	if(tmp!=NULL){
2758	lw=xmlNewNode(ns_ows,BAD_CAST "LowerCorner");
2759	xmlAddChild(lw,xmlNewText(BAD_CAST tmp->value));
2760	}
2761
2762	tmp=getMap(boundingbox,"upperCorner");
2763	if(tmp!=NULL){
2764	uc=xmlNewNode(ns_ows,BAD_CAST "UpperCorner");
2765	xmlAddChild(uc,xmlNewText(BAD_CAST tmp->value));
2766	}
2767
2768	tmp=getMap(boundingbox,"crs");
2769	if(tmp!=NULL)
2770	xmlNewProp(n,BAD_CAST "crs",BAD_CAST tmp->value);
2771
2772	tmp=getMap(boundingbox,"dimensions");
2773	if(tmp!=NULL)
2774	xmlNewProp(n,BAD_CAST "dimensions",BAD_CAST tmp->value);
2775
2776	xmlAddChild(n,lw);
2777	xmlAddChild(n,uc);
2778
2779	}
2780
2781	void printBoundingBoxDocument(maps* m,maps* boundingbox,FILE* file){
2782	if(file==NULL)
2783	rewind(stdout);
2784	xmlNodePtr n;
2785	xmlDocPtr doc;
2786	xmlNsPtr ns_ows,ns_xsi;
2787	xmlChar *xmlbuff;
2788	int buffersize;
2789	char *encoding=getEncoding(m);
2790	map *tmp;
2791	if(file==NULL){
2792	int pid=0;
2793	tmp=getMapFromMaps(m,"lenv","sid");
2794	if(tmp!=NULL)
2795	pid=atoi(tmp->value);
2796	if(pid==getpid()){
2797	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
2798	}
2799	fflush(stdout);
2800	}
2801
2802	doc = xmlNewDoc(BAD_CAST "1.0");
2803	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
2804	ns_ows=usedNs[owsId];
2805	n = xmlNewNode(ns_ows, BAD_CAST "BoundingBox");
2806	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
2807	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2808	ns_xsi=usedNs[xsiId];
2809	xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
2810	map *tmp1=getMap(boundingbox->content,"value");
2811	tmp=parseBoundingBox(tmp1->value);
2812	printBoundingBox(ns_ows,n,tmp);
2813	xmlDocSetRootElement(doc, n);
2814
2815	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2816	if(file==NULL)
2817	printf("%s",xmlbuff);
2818	else{
2819	fprintf(file,"%s",xmlbuff);
2820	}
2821
2822	if(tmp!=NULL){
2823	freeMap(&tmp);
2824	free(tmp);
2825	}
2826	xmlFree(xmlbuff);
2827	xmlFreeDoc(doc);
2828	xmlCleanupParser();
2829	zooXmlCleanupNs();
2830
2831	}
2832
2833
2834	char* getMd5(char* url){
2835	EVP_MD_CTX md5ctx;
2836	char* fresult=(char)malloc((EVP_MAX_MD_SIZE+1)sizeof(char));
2837	unsigned char result[EVP_MAX_MD_SIZE];
2838	unsigned int len;
2839	EVP_DigestInit(&md5ctx, EVP_md5());
2840	EVP_DigestUpdate(&md5ctx, url, strlen(url));
2841	EVP_DigestFinal_ex(&md5ctx,result,&len);
2842	EVP_MD_CTX_cleanup(&md5ctx);
2843	int i;
2844	for(i = 0; i < len; i++){
2845	if(i>0){
2846	char *tmp=strdup(fresult);
2847	sprintf(fresult,"%s%02x", tmp,result[i]);
2848	free(tmp);
2849	}
2850	else
2851	sprintf(fresult,"%02x",result[i]);
2852	}
2853	return fresult;
2854	}
2855
2856	/**
2857	* Cache a file for a given request
2858	*/
2859	void addToCache(maps* conf,char* request,char* content,char* mimeType,int length){
2860	map* tmp=getMapFromMaps(conf,"main","cacheDir");
2861	if(tmp!=NULL){
2862	char* md5str=getMd5(request);
2863	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
2864	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
2865	#ifdef DEBUG
2866	fprintf(stderr,"Cache list : %s\n",fname);
2867	fflush(stderr);
2868	#endif
2869	FILE* fo=fopen(fname,"w+");
2870	if(fo==NULL){
2871	fprintf (stderr, "Failed to open %s for writting: %s\n",fname, strerror(errno));
2872	return;
2873	}
2874	fwrite(content,sizeof(char),length,fo);
2875	fclose(fo);
2876
2877	sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
2878	fo=fopen(fname,"w+");
2879	#ifdef DEBUG
2880	fprintf(stderr,"MIMETYPE: %s\n",mimeType);
2881	#endif
2882	fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
2883	fclose(fo);
2884
2885	free(md5str);
2886	free(fname);
2887	}
2888	}
2889
2890	char* isInCache(maps* conf,char* request){
2891	map* tmpM=getMapFromMaps(conf,"main","cacheDir");
2892	if(tmpM!=NULL){
2893	char* md5str=getMd5(request);
2894	#ifdef DEBUG
2895	fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
2896	#endif
2897	char* fname=(char)malloc(sizeof(char)(strlen(tmpM->value)+strlen(md5str)+6));
2898	sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
2899	struct stat f_status;
2900	int s=stat(fname, &f_status);
2901	if(s==0 && f_status.st_size>0){
2902	free(md5str);
2903	return fname;
2904	}
2905	free(md5str);
2906	free(fname);
2907	}
2908	return NULL;
2909	}
2910
2911	int runHttpRequests(maps m,maps inputs,HINTERNET* hInternet){
2912	if(hInternet->nb>0){
2913	processDownloads(hInternet);
2914	maps* content=*inputs;
2915	map* tmp1;
2916	int index=0;
2917	while(content!=NULL){
2918	if((tmp1=getMap(content->content,"href")) \|\|
2919	(tmp1=getMap(content->content,"xlink:href"))){
2920	if(getMap(content->content,"isCached")==NULL){
2921	char* fcontent;
2922	char *mimeType=NULL;
2923	int fsize=0;
2924
2925	fcontent=(char)malloc((hInternet->ihandle[index].nDataLen+1)sizeof(char));
2926	if(fcontent == NULL){
2927	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
2928	}
2929	size_t dwRead;
2930	InternetReadFile(hInternet->ihandle[index],
2931	(LPVOID)fcontent,
2932	hInternet->ihandle[index].nDataLen,
2933	&dwRead);
2934	fcontent[hInternet->ihandle[index].nDataLen]=0;
2935	fsize=hInternet->ihandle[index].nDataLen;
2936	mimeType=strdup((char*)hInternet->ihandle[index].mimeType);
2937
2938	map* tmpMap=getMapOrFill(&content->content,"value","");
2939	free(tmpMap->value);
2940	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
2941	if(tmpMap->value==NULL){
2942	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
2943	}
2944	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
2945
2946	char ltmp1[256];
2947	sprintf(ltmp1,"%d",fsize);
2948	addToMap(content->content,"size",ltmp1);
2949	addToCache(*m,tmp1->value,fcontent,mimeType,fsize);
2950	free(fcontent);
2951	free(mimeType);
2952	}
2953	index++;
2954	}
2955	content=content->next;
2956	}
2957	}
2958	}
2959
2960	/**
2961	* loadRemoteFile:
2962	* Try to load file from cache or download a remote file if not in cache
2963	*/
2964	int loadRemoteFile(maps m,map content,HINTERNET* hInternet,char *url){
2965	char* fcontent;
2966	char* cached=isInCache(*m,url);
2967	char *mimeType=NULL;
2968	int fsize=0;
2969	if(cached!=NULL){
2970	struct stat f_status;
2971	int s=stat(cached, &f_status);
2972	if(s==0){
2973	fcontent=(char)malloc(sizeof(char)(f_status.st_size+1));
2974	FILE* f=fopen(cached,"rb");
2975	fread(fcontent,f_status.st_size,1,f);
2976	fsize=f_status.st_size;
2977	fcontent[fsize]=0;
2978	fclose(f);
2979	}
2980	cached[strlen(cached)-1]='m';
2981	s=stat(cached, &f_status);
2982	if(s==0){
2983	mimeType=(char)malloc(sizeof(char)(f_status.st_size+1));
2984	FILE* f=fopen(cached,"rb");
2985	fread(mimeType,f_status.st_size,1,f);
2986	mimeType[f_status.st_size]=0;
2987	fclose(f);
2988	}
2989	}else{
2990	hInternet->waitingRequests[hInternet->nb]=strdup(url);
2991	InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
2992	return 0;
2993	}
2994	if(fsize==0){
2995	return errorException(*m, _("Unable to download the file."), "InternalError",NULL);
2996	}
2997	if(mimeType!=NULL){
2998	addToMap(*content,"fmimeType",mimeType);
2999	}
3000
3001	map* tmpMap=getMapOrFill(content,"value","");
3002
3003	free(tmpMap->value);
3004	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
3005	if(tmpMap->value==NULL)
3006	return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
3007	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
3008
3009	char ltmp1[256];
3010	sprintf(ltmp1,"%d",fsize);
3011	addToMap(*content,"size",ltmp1);
3012	if(cached==NULL)
3013	addToCache(*m,url,fcontent,mimeType,fsize);
3014	else
3015	addToMap(*content,"isCached","true");
3016	free(fcontent);
3017	free(mimeType);
3018	free(cached);
3019	return 0;
3020	}
3021
3022	int errorException(maps m, const char message, const char errorcode, const char locator)
3023	{
3024	map* errormap = createMap("text", message);
3025	addToMap(errormap,"code", errorcode);
3026	if(locator!=NULL)
3027	addToMap(errormap,"locator", locator);
3028	else
3029	addToMap(errormap,"locator", "NULL");
3030	printExceptionReportResponse(m,errormap);
3031	freeMap(&errormap);
3032	free(errormap);
3033	return -1;
3034	}
3035
3036
3037	char readVSIFile(maps conf,const char* dataSource){
3038	VSILFILE * fichier=VSIFOpenL(dataSource,"rb");
3039	VSIStatBufL file_status;
3040	VSIStatL(dataSource, &file_status);
3041	if(fichier==NULL){
3042	char tmp[1024];
3043	sprintf(tmp,"Failed to open file %s for reading purpose. File seems empty %d.",
3044	dataSource,file_status.st_size);
3045	setMapInMaps(conf,"lenv","message",tmp);
3046	return NULL;
3047	}
3048	char res1=(char )malloc(file_status.st_size*sizeof(char));
3049	VSIFReadL(res1,1,file_status.st_size*sizeof(char),fichier);
3050	res1[file_status.st_size-1]=0;
3051	VSIFCloseL(fichier);
3052	VSIUnlink(dataSource);
3053	return res1;
3054	}
3055
3056	void parseIdentifier(maps* conf,char* conf_dir,char identifier,char buffer){
3057	char *saveptr1;
3058	char *tmps1=strtok_r(identifier,".",&saveptr1);
3059	int level=0;
3060	char key[25];
3061	char levels[18];
3062	while(tmps1!=NULL){
3063	char *test=zStrdup(tmps1);
3064	char* tmps2=(char)malloc((strlen(test)+2)sizeof(char));
3065	sprintf(key,"sprefix_%d",level);
3066	sprintf(tmps2,"%s.",test);
3067	sprintf(levels,"%d",level);
3068	setMapInMaps(conf,"lenv","level",levels);
3069	setMapInMaps(conf,"lenv",key,tmps2);
3070	free(tmps2);
3071	free(test);
3072	level++;
3073	tmps1=strtok_r(NULL,".",&saveptr1);
3074	}
3075	int i=0;
3076	sprintf(buffer,"%s",conf_dir);
3077	for(i=0;i<level;i++){
3078	char *tmp0=zStrdup(buffer);
3079	sprintf(key,"sprefix_%d",i);
3080	map* tmp00=getMapFromMaps(conf,"lenv",key);
3081	sprintf(buffer,"%s/%s",tmp0,tmp00->value);
3082	free(tmp0);
3083	buffer[strlen(buffer)-1]=0;
3084	if(i+1<level){
3085	map* tmpMap=getMapFromMaps(conf,"lenv","metapath");
3086	if(tmpMap==NULL \|\| strlen(tmpMap->value)==0){
3087	char *tmp01=zStrdup(tmp00->value);
3088	tmp01[strlen(tmp01)-1]=0;
3089	setMapInMaps(conf,"lenv","metapath",tmp01);
3090	free(tmp01);
3091	}
3092	else{
3093	char value=(char)malloc((strlen(tmp00->value)+strlen(tmpMap->value)+2)*sizeof(char));
3094	sprintf(value,"%s/%s",tmpMap->value,tmp00->value);
3095	value[strlen(value)-1]=0;
3096	setMapInMaps(conf,"lenv","metapath",value);
3097	free(value);
3098	}
3099	}else{
3100	char *tmp01=zStrdup(tmp00->value);
3101	tmp01[strlen(tmp01)-1]=0;
3102	setMapInMaps(conf,"lenv","Identifier",tmp01);
3103	free(tmp01);
3104	}
3105	}
3106	char *tmp0=zStrdup(buffer);
3107	sprintf(buffer,"%s.zcfg",tmp0);
3108	free(tmp0);
3109	}
3110
3111	int updateStatus( maps* conf, const int percentCompleted, const char* message ){
3112	char tmp[4];
3113	snprintf(tmp,4,"%d",percentCompleted);
3114	setMapInMaps( conf, "lenv", "status", tmp );
3115	setMapInMaps( conf, "lenv", "message", message);
3116	return _updateStatus( conf );
3117	}
3118
3119	char* getInputValue( maps* inputs, const char* parameterName, size_t* numberOfBytes){
3120	map* res=getMapFromMaps(inputs,parameterName,"value");
3121	if(res!=NULL){
3122	map* size=getMapFromMaps(inputs,parameterName,"size");
3123	if(size!=NULL){
3124	*numberOfBytes=(size_t)atoi(size->value);
3125	return res->value;
3126	}else{
3127	*numberOfBytes=strlen(res->value);
3128	return res->value;
3129	}
3130	}
3131	return NULL;
3132	}
3133
3134	int setOutputValue( maps* outputs, const char* parameterName, char* data, size_t numberOfBytes ){
3135	if(numberOfBytes==-1){
3136	setMapInMaps(outputs,parameterName,"value",data);
3137	}else{
3138	char size[1024];
3139	map* tmp=getMapFromMaps(outputs,parameterName,"value");
3140	free(tmp->value);
3141	tmp->value=(char) malloc((numberOfBytes+1)sizeof(char));
3142	memcpy(tmp->value,data,numberOfBytes);
3143	sprintf(size,"%lu",numberOfBytes);
3144	setMapInMaps(outputs,parameterName,"size",size);
3145	}
3146	return 0;
3147	}

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

Open WPS platform

source: trunk/zoo-project/zoo-kernel/service_internal.c @ 492

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links