service_internal.c @ 467

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links