service_internal.c @ 452

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

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links