service_internal.c @ 458

Last change on this file since 458 was 458, checked in by djay, 9 years ago
Fix some issue in background execution on windows platform (basic array and xlink). Fix issue #89.
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc`
File size: 75.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[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	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[7];
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
894	xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7;
895	elements* e=elem;
896	map* tmp1=NULL;
897	while(e!=NULL){
898	int default1=0;
899	int isAnyValue=1;
900	nc2 = xmlNewNode(NULL, BAD_CAST type);
901	tmp1=getMap(e->content,"minOccurs");
902	if(tmp1){
903	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
904	}
905	tmp1=getMap(e->content,"maxOccurs");
906	if(tmp1){
907	xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
908	}
909
910	printDescription(nc2,ns_ows,e->name,e->content);
911
912	if(strncmp(type,"Output",6)==0){
913	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
914	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
915	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
916	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
917	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
918	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
919	else
920	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
921	}else{
922	if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
923	nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
924	}
925	else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
926	nc3 = xmlNewNode(NULL, BAD_CAST "ComplexData");
927	else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
928	nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxData");
929	else
930	nc3 = xmlNewNode(NULL, BAD_CAST e->format);
931	}
932	iotype* _tmp=e->defaults;
933	int datatype=0;
934	bool hasDefault=false;
935	bool hasUOM=false;
936	if(_tmp!=NULL){
937	if(strcmp(e->format,"LiteralOutput")==0 \|\|
938	strcmp(e->format,"LiteralData")==0){
939	datatype=1;
940	nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
941	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
942	}
943	else if(strcmp(e->format,"BoundingBoxOutput")==0 \|\|
944	strcmp(e->format,"BoundingBoxData")==0){
945	datatype=2;
946	//nc4 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
947	nc5 = xmlNewNode(NULL, BAD_CAST "Default");
948	}
949	else{
950	nc4 = xmlNewNode(NULL, BAD_CAST "Default");
951	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
952	}
953
954	tmp1=_tmp->content;
955	int avcnt=0;
956	int dcnt=0;
957	int oI=0;
958	for(oI=0;oI<7;oI++)
959	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
960	//while(tmp1!=NULL){
961	#ifdef DEBUG
962	printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
963	#endif
964	if(strncasecmp(tmp1->name,"DataType",8)==0){
965	nc6 = xmlNewNode(ns_ows, BAD_CAST "DataType");
966	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
967	char tmp[1024];
968	sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
969	xmlNewNsProp(nc6,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
970	xmlAddChild(nc3,nc6);
971	tmp1=tmp1->next;
972	datatype=1;
973	continue;
974	}
975	if(strcmp(tmp1->name,"asReference")!=0 &&
976	strncasecmp(tmp1->name,"DataType",8)!=0 &&
977	strcasecmp(tmp1->name,"extension")!=0 &&
978	strcasecmp(tmp1->name,"value")!=0 &&
979	strncasecmp(tmp1->name,"AllowedValues",13)!=0){
980	if(datatype!=1){
981	char *tmp2=zCapitalize1(tmp1->name);
982	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
983	free(tmp2);
984	}
985	else{
986	char *tmp2=zCapitalize(tmp1->name);
987	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
988	free(tmp2);
989	}
990	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
991	xmlAddChild(nc5,nc6);
992	hasUOM=true;
993	}else
994	if(strncmp(type,"Input",5)==0){
995	if(strcmp(tmp1->name,"value")==0){
996	nc7 = xmlNewNode(NULL, BAD_CAST "DefaultValue");
997	xmlAddChild(nc7,xmlNewText(BAD_CAST tmp1->value));
998	default1=1;
999	}
1000	if(strncasecmp(tmp1->name,"AllowedValues",13)==0){
1001	nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
1002	fprintf(stderr,"ALLOWED VALUE %s\n",tmp1->value);
1003	char token,saveptr1;
1004	token=strtok_r(tmp1->value,",",&saveptr1);
1005	while(token!=NULL){
1006	nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
1007	char *tmps=strdup(token);
1008	tmps[strlen(tmps)]=0;
1009	xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
1010	fprintf(stderr,"strgin : %s\n",tmps);
1011	xmlAddChild(nc6,nc7);
1012	token=strtok_r(NULL,",",&saveptr1);
1013	}
1014	xmlAddChild(nc3,nc6);
1015	isAnyValue=-1;
1016	}
1017	hasDefault=true;
1018	}
1019	tmp1=tmp1->next;
1020	if(datatype!=2){
1021	if(hasUOM==true){
1022	xmlAddChild(nc4,nc5);
1023	xmlAddChild(nc3,nc4);
1024	}
1025	}else{
1026	xmlAddChild(nc3,nc5);
1027	}
1028
1029	if(strncmp(type,"Input",5)==0){
1030	if(datatype==1 && isAnyValue==1 && avcnt==0){
1031	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
1032	hasDefault=true;
1033	avcnt++;
1034	}
1035	if(datatype==1 && default1>0){
1036	xmlAddChild(nc3,nc7);
1037	}
1038	}
1039	}
1040	}
1041
1042	_tmp=e->supported;
1043	if(_tmp==NULL && (getMap(e->defaults->content,"uom")!=NULL \|\| datatype!=1))
1044	_tmp=e->defaults;
1045
1046	int hasSupported=-1;
1047	while(_tmp!=NULL){
1048	if(hasSupported<0){
1049	if(datatype==0){
1050	nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
1051	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1052	}
1053	else
1054	nc5 = xmlNewNode(NULL, BAD_CAST "Supported");
1055	hasSupported=0;
1056	}else
1057	if(datatype==0)
1058	nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1059	tmp1=_tmp->content;
1060	int oI=0;
1061	for(oI=0;oI<6;oI++)
1062	if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1063	#ifdef DEBUG
1064	printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
1065	#endif
1066	if(strcmp(tmp1->name,"asReference")!=0 &&
1067	strcmp(tmp1->name,"DataType")!=0 &&
1068	strcasecmp(tmp1->name,"extension")!=0){
1069	if(datatype!=1){
1070	char *tmp2=zCapitalize1(tmp1->name);
1071	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1072	free(tmp2);
1073	}
1074	else{
1075	char *tmp2=zCapitalize(tmp1->name);
1076	nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1077	free(tmp2);
1078	}
1079	if(datatype==2){
1080	char tmpv,tmps;
1081	tmps=strtok_r(tmp1->value,",",&tmpv);
1082	while(tmps){
1083	xmlAddChild(nc6,xmlNewText(BAD_CAST tmps));
1084	xmlAddChild(nc5,nc6);
1085	tmps=strtok_r(NULL,",",&tmpv);
1086	if(tmps){
1087	char *tmp2=zCapitalize1(tmp1->name);
1088	nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1089	free(tmp2);
1090	}
1091	}
1092	}
1093	else{
1094	xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
1095	xmlAddChild(nc5,nc6);
1096	}
1097	}
1098	tmp1=tmp1->next;
1099	}
1100	if(hasSupported<=0){
1101	if(datatype!=2){
1102	xmlAddChild(nc4,nc5);
1103	xmlAddChild(nc3,nc4);
1104	}else
1105	xmlAddChild(nc3,nc5);
1106	hasSupported=1;
1107	}
1108	else
1109	if(datatype!=2){
1110	xmlAddChild(nc4,nc5);
1111	}
1112	else
1113	xmlAddChild(nc3,nc5);
1114	_tmp=_tmp->next;
1115	}
1116	xmlAddChild(nc2,nc3);
1117
1118	if(datatype!=2 && hasUOM==true){
1119	xmlAddChild(nc3,nc4);
1120	xmlAddChild(nc2,nc3);
1121	}else if(datatype!=2){
1122	if(hasDefault!=true && strncmp(type,"Input",5)==0)
1123	xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
1124	}
1125
1126	xmlAddChild(nc1,nc2);
1127
1128	e=e->next;
1129	}
1130	}
1131
1132	void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
1133	xmlNsPtr ns,ns1,ns_ows,ns_xlink,ns_xsi;
1134	xmlNodePtr nr,n,nc,nc1,nc2,nc3,pseudor;
1135	xmlDocPtr doc;
1136	xmlChar *xmlbuff;
1137	int buffersize;
1138	time_t time1;
1139	time(&time1);
1140	nr=NULL;
1141	/**
1142	* Create the document and its temporary root.
1143	*/
1144	doc = xmlNewDoc(BAD_CAST "1.0");
1145	int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
1146	ns=usedNs[wpsId];
1147
1148	n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
1149	xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
1150	int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
1151	ns_ows=usedNs[owsId];
1152	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1153	ns_xlink=usedNs[xlinkId];
1154	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1155	ns_xsi=usedNs[xsiId];
1156
1157	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");
1158
1159	xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1160	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
1161	addLangAttr(n,m);
1162
1163	char tmp[256];
1164	char url[1024];
1165	char stored_path[1024];
1166	memset(tmp,0,256);
1167	memset(url,0,1024);
1168	memset(stored_path,0,1024);
1169	maps* tmp_maps=getMaps(m,"main");
1170	if(tmp_maps!=NULL){
1171	map* tmpm1=getMap(tmp_maps->content,"serverAddress");
1172	/**
1173	* Check if the ZOO Service GetStatus is available in the local directory.
1174	* If yes, then it uses a reference to an URL which the client can access
1175	* to get information on the status of a running Service (using the
1176	* percentCompleted attribute).
1177	* Else fallback to the initial method using the xml file to write in ...
1178	*/
1179	char ntmp[1024];
1180	#ifndef WIN32
1181	getcwd(ntmp,1024);
1182	#else
1183	_getcwd(ntmp,1024);
1184	#endif
1185	struct stat myFileInfo;
1186	int statRes;
1187	char file_path[1024];
1188	sprintf(file_path,"%s/GetStatus.zcfg",ntmp);
1189	statRes=stat(file_path,&myFileInfo);
1190	if(statRes==0){
1191	char currentSid[128];
1192	map* tmpm=getMap(tmp_maps->content,"rewriteUrl");
1193	map *tmp_lenv=NULL;
1194	tmp_lenv=getMapFromMaps(m,"lenv","sid");
1195	if(tmp_lenv==NULL)
1196	sprintf(currentSid,"%i",pid);
1197	else
1198	sprintf(currentSid,"%s",tmp_lenv->value);
1199	if(tmpm==NULL \|\| strcasecmp(tmpm->value,"false")==0){
1200	sprintf(url,"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1201	}else{
1202	if(strlen(tmpm->value)>0)
1203	if(strcasecmp(tmpm->value,"true")!=0)
1204	sprintf(url,"%s/%s/GetStatus/%s",tmpm1->value,tmpm->value,currentSid);
1205	else
1206	sprintf(url,"%s/GetStatus/%s",tmpm1->value,currentSid);
1207	else
1208	sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1209	}
1210	}else{
1211	map* tmpm2=getMap(tmp_maps->content,"tmpUrl");
1212	if(tmpm1!=NULL && tmpm2!=NULL){
1213	if( strncasecmp( tmpm2->value, "http://", 7) == 0 \|\|
1214	strncasecmp( tmpm2->value, "https://", 8 ) == 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/x-javascript",24)!=0&&
1643	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)!=0)
1644	)) {
1645	map* rs=getMap(m->content,"size");
1646	bool isSized=true;
1647	if(rs==NULL){
1648	char tmp1[1024];
1649	sprintf(tmp1,"%d",strlen(tmp3->value));
1650	rs=createMap("size",tmp1);
1651	isSized=false;
1652	}
1653
1654	xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
1655	if(!isSized){
1656	freeMap(&rs);
1657	free(rs);
1658	}
1659	}
1660	else if(tmp2!=NULL){
1661	if(strncmp(tmp2->value,"text/js",7)==0 \|\|
1662	strncmp(tmp2->value,"application/json",16)==0)
1663	xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
1664	else{
1665	if(strncmp(tmp2->value,"text/xml",8)==0 \|\|
1666	strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
1667	xmlDocPtr doc =
1668	xmlParseMemory(tmp3->value,strlen(tmp3->value));
1669	xmlNodePtr ir = xmlDocGetRootElement(doc);
1670	xmlAddChild(nc3,ir);
1671	}
1672	else
1673	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
1674	}
1675	xmlAddChild(nc2,nc3);
1676	}
1677	else{
1678	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
1679	}
1680	if(hasValue<0){
1681	freeMap(&tmp3);
1682	free(tmp3);
1683	}
1684	}
1685	}
1686	else{
1687	tmpMap=getMap(m->content,"Reference");
1688	nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
1689	if(strcasecmp(type,"Output")==0)
1690	xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
1691	else
1692	xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
1693	tmp=m->content;
1694	#ifdef USE_MS
1695	map* testMap=getMap(tmp,"requestedMimeType");
1696	#endif
1697	while(tmp!=NULL){
1698	if(strcasecmp(tmp->name,"mimeType")==0 \|\|
1699	strcasecmp(tmp->name,"encoding")==0 \|\|
1700	strcasecmp(tmp->name,"schema")==0 \|\|
1701	strcasecmp(tmp->name,"datatype")==0 \|\|
1702	strcasecmp(tmp->name,"uom")==0)
1703	#ifdef USE_MS
1704	if(testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)!=0){
1705	if(strcasecmp(tmp->name,"mimeType")==0)
1706	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
1707	}
1708	else
1709	#endif
1710	xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1711	tmp=tmp->next;
1712	xmlAddChild(nc2,nc3);
1713	}
1714	}
1715	xmlAddChild(nc1,nc2);
1716	xmlAddChild(nc,nc1);
1717
1718	}
1719
1720	void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
1721	xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
1722	xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
1723	xmlAddChild(root,nc2);
1724	map* tmp=amap;
1725	char *tmp2[2];
1726	tmp2[0]="Title";
1727	tmp2[1]="Abstract";
1728	int j=0;
1729	for(j=0;j<2;j++){
1730	map* tmp1=getMap(tmp,tmp2[j]);
1731	if(tmp1!=NULL){
1732	nc2 = xmlNewNode(ns_ows, BAD_CAST tmp2[j]);
1733	xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
1734	xmlAddChild(root,nc2);
1735	}
1736	}
1737	}
1738
1739	char* getEncoding(maps* m){
1740	if(m!=NULL){
1741	map* tmp=getMap(m->content,"encoding");
1742	if(tmp!=NULL){
1743	return tmp->value;
1744	}
1745	else
1746	return "UTF-8";
1747	}
1748	else
1749	return "UTF-8";
1750	}
1751
1752	char* getVersion(maps* m){
1753	if(m!=NULL){
1754	map* tmp=getMap(m->content,"version");
1755	if(tmp!=NULL){
1756	return tmp->value;
1757	}
1758	else
1759	return "1.0.0";
1760	}
1761	else
1762	return "1.0.0";
1763	}
1764
1765	void printExceptionReportResponse(maps* m,map* s){
1766	int buffersize;
1767	xmlDocPtr doc;
1768	xmlChar *xmlbuff;
1769	xmlNodePtr n;
1770
1771	doc = xmlNewDoc(BAD_CAST "1.0");
1772	maps* tmpMap=getMaps(m,"main");
1773	char *encoding=getEncoding(tmpMap);
1774	if(m!=NULL){
1775	map *tmpSid=getMapFromMaps(m,"lenv","sid");
1776	if(tmpSid!=NULL){
1777	if( getpid()==atoi(tmpSid->value) ){
1778	printHeaders(m);
1779	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1780	}
1781	}
1782	else{
1783	printHeaders(m);
1784	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1785	}
1786	}else{
1787	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1788	}
1789	n=createExceptionReportNode(m,s,1);
1790	xmlDocSetRootElement(doc, n);
1791	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
1792	printf("%s",xmlbuff);
1793	fflush(stdout);
1794	xmlFreeDoc(doc);
1795	xmlFree(xmlbuff);
1796	xmlCleanupParser();
1797	zooXmlCleanupNs();
1798	}
1799
1800	xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
1801
1802	int buffersize;
1803	xmlChar *xmlbuff;
1804	xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1805	xmlNodePtr n,nc,nc1,nc2;
1806
1807	maps* tmpMap=getMaps(m,"main");
1808
1809	int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
1810	ns=usedNs[nsid];
1811	n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
1812
1813	if(use_ns==1){
1814	ns_ows=xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
1815	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1816	ns_xsi=usedNs[xsiId];
1817	int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1818	ns_xlink=usedNs[xlinkId];
1819	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");
1820	}
1821	addLangAttr(n,m);
1822	xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.1.0");
1823
1824	nc = xmlNewNode(ns, BAD_CAST "Exception");
1825
1826	map* tmp=getMap(s,"code");
1827	if(tmp!=NULL)
1828	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST tmp->value);
1829	else
1830	xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST "NoApplicableCode");
1831
1832	tmp=getMap(s,"text");
1833	nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
1834	nc2=NULL;
1835	if(tmp!=NULL){
1836	xmlNodeSetContent(nc1, BAD_CAST tmp->value);
1837	}
1838	else{
1839	xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
1840	}
1841	xmlAddChild(nc,nc1);
1842	xmlAddChild(n,nc);
1843	return n;
1844	}
1845
1846
1847	void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
1848	map* request_inputs1,int cpid,maps* m,int res){
1849	#ifdef DEBUG
1850	dumpMaps(request_inputs);
1851	dumpMaps(request_outputs);
1852	fprintf(stderr,"printProcessResponse\n");
1853	#endif
1854	map* toto=getMap(request_inputs1,"RawDataOutput");
1855	int asRaw=0;
1856	if(toto!=NULL)
1857	asRaw=1;
1858
1859	maps* tmpSess=getMaps(m,"senv");
1860	if(tmpSess!=NULL){
1861	map *_tmp=getMapFromMaps(m,"lenv","cookie");
1862	char* sessId;
1863	if(_tmp!=NULL){
1864	printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
1865	printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
1866	char session_file_path[100];
1867	char *tmp1=strtok(_tmp->value,";");
1868	if(tmp1!=NULL)
1869	sprintf(session_file_path,"%s",strstr(tmp1,"=")+1);
1870	else
1871	sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
1872	sessId=strdup(session_file_path);
1873	}else{
1874	maps* t=getMaps(m,"senv");
1875	map*p=t->content;
1876	while(p!=NULL){
1877	if(strstr(p->name,"ID")!=NULL){
1878	sessId=strdup(p->value);
1879	break;
1880	}
1881	p=p->next;
1882	}
1883	}
1884	char session_file_path[1024];
1885	map *tmpPath=getMapFromMaps(m,"main","sessPath");
1886	if(tmpPath==NULL)
1887	tmpPath=getMapFromMaps(m,"main","tmpPath");
1888	sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,sessId);
1889	FILE* teste=fopen(session_file_path,"w");
1890	if(teste==NULL){
1891	char tmpMsg[1024];
1892	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the session maps."),session_file_path);
1893	map * errormap = createMap("text",tmpMsg);
1894	addToMap(errormap,"code", "InternalError");
1895
1896	printExceptionReportResponse(m,errormap);
1897	freeMap(&errormap);
1898	free(errormap);
1899	return;
1900	}
1901	else{
1902	fclose(teste);
1903	dumpMapsToFile(tmpSess,session_file_path);
1904	}
1905	}
1906
1907	if(res==SERVICE_FAILED){
1908	map * errormap;
1909	map *lenv;
1910	lenv=getMapFromMaps(m,"lenv","message");
1911	char *tmp0;
1912	if(lenv!=NULL){
1913	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));
1914	sprintf(tmp0,_("Unable to run the Service. The message returned back by the Service was the following: %s"),lenv->value);
1915	}
1916	else{
1917	tmp0=(char)malloc((strlen(_("Unable to run the Service. No more information was returned back by the Service."))+1)sizeof(char));
1918	sprintf(tmp0,_("Unable to run the Service. No more information was returned back by the Service."));
1919	}
1920	errormap = createMap("text",tmp0);
1921	free(tmp0);
1922	addToMap(errormap,"code", "InternalError");
1923	printExceptionReportResponse(m,errormap);
1924	freeMap(&errormap);
1925	free(errormap);
1926	return;
1927	}
1928
1929	if(asRaw==0){
1930	#ifdef DEBUG
1931	fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
1932	dumpMaps(request_outputs);
1933	#endif
1934	maps* tmpI=request_outputs;
1935	while(tmpI!=NULL){
1936	#ifdef USE_MS
1937	map* testMap=getMap(tmpI->content,"useMapserver");
1938	#endif
1939	toto=getMap(tmpI->content,"asReference");
1940	#ifdef USE_MS
1941	if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
1942	#else
1943	if(toto!=NULL && strcasecmp(toto->value,"true")==0)
1944	#endif
1945	{
1946	elements* in=getElements(s->outputs,tmpI->name);
1947	char *format=NULL;
1948	if(in!=NULL){
1949	format=strdup(in->format);
1950	}else
1951	format=strdup("LiteralData");
1952	if(strcasecmp(format,"BoundingBoxData")==0){
1953	addToMap(tmpI->content,"extension","xml");
1954	addToMap(tmpI->content,"mimeType","text/xml");
1955	addToMap(tmpI->content,"encoding","UTF-8");
1956	addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
1957	}
1958	map *ext=getMap(tmpI->content,"extension");
1959	map *tmp1=getMapFromMaps(m,"main","tmpPath");
1960	char file_name,file_path;
1961	bool hasExt=true;
1962	if(ext==NULL){
1963	// We can fallback to a default list of supported formats using
1964	// mimeType information if present here. Maybe we can add more formats
1965	// here.
1966	// If mimeType was not found, we then set txt as the default extension
1967	map* mtype=getMap(tmpI->content,"mimeType");
1968	if(mtype!=NULL){
1969	if(strcasecmp(mtype->value,"text/xml")==0)
1970	ext=createMap("extension","xml");
1971	else if(strcasecmp(mtype->value,"application/json")==0)
1972	ext=createMap("extension","js");
1973	else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
1974	ext=createMap("extension","kml");
1975	else if(strncmp(mtype->value,"image/",6)==0)
1976	ext=createMap("extension",strstr(mtype->value,"/")+1);
1977	else
1978	ext=createMap("extension","txt");
1979	}
1980	else
1981	ext=createMap("extension","txt");
1982	hasExt=false;
1983	}
1984	file_name=(char)malloc((strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+1024)sizeof(char));
1985	int cpid0=cpid+time(NULL);
1986	sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,ext->value);
1987	file_path=(char)malloc((strlen(tmp1->value)+strlen(file_name)+2)sizeof(char));
1988	sprintf(file_path,"%s/%s",tmp1->value,file_name);
1989	FILE *ofile=fopen(file_path,"wb");
1990	if(ofile==NULL){
1991	char tmpMsg[1024];
1992	sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the %s final result."),file_name,tmpI->name);
1993	map * errormap = createMap("text",tmpMsg);
1994	addToMap(errormap,"code", "InternalError");
1995	printExceptionReportResponse(m,errormap);
1996	freeMap(&errormap);
1997	free(errormap);
1998	free(file_name);
1999	free(file_path);
2000	return;
2001	}
2002	free(file_path);
2003	map *tmp2=getMapFromMaps(m,"main","tmpUrl");
2004	map *tmp3=getMapFromMaps(m,"main","serverAddress");
2005	char *file_url;
2006	if(strncasecmp(tmp2->value,"http://",7)==0 \|\|
2007	strncasecmp(tmp2->value,"https://",8)==0){
2008	file_url=(char)malloc((strlen(tmp2->value)+strlen(file_name)+2)sizeof(char));
2009	sprintf(file_url,"%s/%s",tmp2->value,file_name);
2010	}else{
2011	file_url=(char)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)sizeof(char));
2012	sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
2013	}
2014	addToMap(tmpI->content,"Reference",file_url);
2015	if(!hasExt){
2016	freeMap(&ext);
2017	free(ext);
2018	}
2019	toto=getMap(tmpI->content,"value");
2020	if(strcasecmp(format,"BoundingBoxData")!=0){
2021	map* size=getMap(tmpI->content,"size");
2022	if(size!=NULL && toto!=NULL)
2023	fwrite(toto->value,1,atoi(size->value)*sizeof(char),ofile);
2024	else
2025	if(toto!=NULL && toto->value!=NULL)
2026	fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
2027	}else{
2028	printBoundingBoxDocument(m,tmpI,ofile);
2029	}
2030	free(format);
2031	fclose(ofile);
2032	free(file_name);
2033	free(file_url);
2034	}
2035	#ifdef USE_MS
2036	else{
2037	if(testMap!=NULL){
2038	setReferenceUrl(m,tmpI);
2039	}
2040	}
2041	#endif
2042	tmpI=tmpI->next;
2043	}
2044	map *r_inputs=getMap(s->content,"serviceProvider");
2045	#ifdef DEBUG
2046	fprintf(stderr,"SERVICE : %s\n",r_inputs->value);
2047	dumpMaps(m);
2048	#endif
2049	printProcessResponse(m,request_inputs1,cpid,
2050	s,r_inputs->value,res,
2051	request_inputs,
2052	request_outputs);
2053	}
2054	else{
2055	/**
2056	* We get the requested output or fallback to the first one if the
2057	* requested one is not present in the resulting outputs maps.
2058	*/
2059	maps* tmpI=NULL;
2060	map* tmpIV=getMap(request_inputs1,"RawDataOutput");
2061	if(tmpIV!=NULL){
2062	tmpI=getMaps(request_outputs,tmpIV->value);
2063	}
2064	if(tmpI==NULL)
2065	tmpI=request_outputs;
2066	elements* e=getElements(s->outputs,tmpI->name);
2067	if(e!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
2068	printBoundingBoxDocument(m,tmpI,NULL);
2069	}else{
2070	toto=getMap(tmpI->content,"value");
2071	if(toto==NULL){
2072	char tmpMsg[1024];
2073	sprintf(tmpMsg,_("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),tmpI->name);
2074	map * errormap = createMap("text",tmpMsg);
2075	addToMap(errormap,"code", "InvalidParameterValue");
2076	printExceptionReportResponse(m,errormap);
2077	freeMap(&errormap);
2078	free(errormap);
2079	return;
2080	}
2081	map* fname=getMapFromMaps(tmpI,tmpI->name,"filename");
2082	if(fname!=NULL)
2083	printf("Content-Disposition: attachment; filename=\"%s\"\r\n",fname->value);
2084	map* rs=getMapFromMaps(tmpI,tmpI->name,"size");
2085	if(rs!=NULL)
2086	printf("Content-Length: %s\r\n",rs->value);
2087	printHeaders(m);
2088	char mime[1024];
2089	map* mi=getMap(tmpI->content,"mimeType");
2090	#ifdef DEBUG
2091	fprintf(stderr,"SERVICE OUTPUTS\n");
2092	dumpMaps(request_outputs);
2093	fprintf(stderr,"SERVICE OUTPUTS\n");
2094	#endif
2095	map* en=getMap(tmpI->content,"encoding");
2096	if(mi!=NULL && en!=NULL)
2097	sprintf(mime,
2098	"Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
2099	mi->value,en->value);
2100	else
2101	if(mi!=NULL)
2102	sprintf(mime,
2103	"Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
2104	mi->value);
2105	else
2106	sprintf(mime,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
2107	printf("%s",mime);
2108	if(rs!=NULL)
2109	fwrite(toto->value,1,atoi(rs->value),stdout);
2110	else
2111	fwrite(toto->value,1,strlen(toto->value),stdout);
2112	#ifdef DEBUG
2113	dumpMap(toto);
2114	#endif
2115	}
2116	}
2117	}
2118
2119	char base64(const char input, int length)
2120	{
2121	BIO bmem, b64;
2122	BUF_MEM *bptr;
2123
2124	b64 = BIO_new(BIO_f_base64());
2125	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
2126	bmem = BIO_new(BIO_s_mem());
2127	b64 = BIO_push(b64, bmem);
2128	BIO_write(b64, input, length);
2129	BIO_flush(b64);
2130	BIO_get_mem_ptr(b64, &bptr);
2131
2132	char buff = (char )malloc((bptr->length)*sizeof(char));
2133	memcpy(buff, bptr->data, bptr->length-1);
2134	buff[bptr->length-1] = 0;
2135
2136	BIO_free_all(b64);
2137
2138	return buff;
2139	}
2140
2141	char base64d(const char input, int length,int* red)
2142	{
2143	BIO b64, bmem;
2144
2145	char buffer = (char )malloc(length);
2146	if(buffer){
2147	memset(buffer, 0, length);
2148	b64 = BIO_new(BIO_f_base64());
2149	if(b64){
2150	bmem = BIO_new_mem_buf((unsigned char*)input,length);
2151	bmem = BIO_push(b64, bmem);
2152	*red=BIO_read(bmem, buffer, length);
2153	buffer[length-1]=0;
2154	BIO_free_all(bmem);
2155	}
2156	}
2157	return buffer;
2158	}
2159
2160	void ensureDecodedBase64(maps **in){
2161	maps* cursor=*in;
2162	while(cursor!=NULL){
2163	map *tmp=getMap(cursor->content,"encoding");
2164	if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
2165	tmp=getMap(cursor->content,"value");
2166	addToMap(cursor->content,"base64_value",tmp->value);
2167	int size=0;
2168	char *s=strdup(tmp->value);
2169	free(tmp->value);
2170	tmp->value=base64d(s,strlen(s),&size);
2171	free(s);
2172	char sizes[1024];
2173	sprintf(sizes,"%d",size);
2174	addToMap(cursor->content,"size",sizes);
2175	}
2176	cursor=cursor->next;
2177	}
2178	}
2179
2180	char* addDefaultValues(maps** out,elements* in,maps* m,int type){
2181	elements* tmpInputs=in;
2182	maps* out1=*out;
2183	if(type==1){
2184	while(out1!=NULL){
2185	if(getElements(in,out1->name)==NULL)
2186	return out1->name;
2187	out1=out1->next;
2188	}
2189	out1=*out;
2190	}
2191	while(tmpInputs!=NULL){
2192	maps *tmpMaps=getMaps(out1,tmpInputs->name);
2193	if(tmpMaps==NULL){
2194	maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
2195	tmpMaps2->name=strdup(tmpInputs->name);
2196	tmpMaps2->content=NULL;
2197	tmpMaps2->next=NULL;
2198
2199	if(type==0){
2200	map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
2201	if(tmpMapMinO!=NULL)
2202	if(atoi(tmpMapMinO->value)>=1){
2203	freeMaps(&tmpMaps2);
2204	free(tmpMaps2);
2205	return tmpInputs->name;
2206	}
2207	else{
2208	if(tmpMaps2->content==NULL)
2209	tmpMaps2->content=createMap("minOccurs",tmpMapMinO->value);
2210	else
2211	addToMap(tmpMaps2->content,"minOccurs",tmpMapMinO->value);
2212	}
2213	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2214	if(tmpMaxO!=NULL)
2215	if(tmpMaps2->content==NULL)
2216	tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
2217	else
2218	addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
2219	}
2220
2221	iotype* tmpIoType=tmpInputs->defaults;
2222	if(tmpIoType!=NULL){
2223	map* tmpm=tmpIoType->content;
2224	while(tmpm!=NULL){
2225	if(tmpMaps2->content==NULL)
2226	tmpMaps2->content=createMap(tmpm->name,tmpm->value);
2227	else
2228	addToMap(tmpMaps2->content,tmpm->name,tmpm->value);
2229	tmpm=tmpm->next;
2230	}
2231	}
2232	addToMap(tmpMaps2->content,"inRequest","false");
2233	if(type==0){
2234	map *tmpMap=getMap(tmpMaps2->content,"value");
2235	if(tmpMap==NULL)
2236	addToMap(tmpMaps2->content,"value","NULL");
2237	}
2238	if(out1==NULL){
2239	*out=dupMaps(&tmpMaps2);
2240	out1=*out;
2241	}
2242	else
2243	addMapsToMaps(&out1,tmpMaps2);
2244	freeMap(&tmpMaps2->content);
2245	free(tmpMaps2->content);
2246	tmpMaps2->content=NULL;
2247	freeMaps(&tmpMaps2);
2248	free(tmpMaps2);
2249	tmpMaps2=NULL;
2250	}
2251	else{
2252	iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
2253	tmpMaps->content);
2254	if(type==0) {
2255	/**
2256	* In case of an Input maps, then add the minOccurs and maxOccurs to the
2257	* content map.
2258	*/
2259	map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
2260	if(tmpMap1!=NULL){
2261	if(tmpMaps->content==NULL)
2262	tmpMaps->content=createMap("minOccurs",tmpMap1->value);
2263	else
2264	addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
2265	}
2266	map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2267	if(tmpMaxO!=NULL){
2268	if(tmpMaps->content==NULL)
2269	tmpMaps->content=createMap("maxOccurs",tmpMap1->value);
2270	else
2271	addToMap(tmpMaps->content,"maxOccurs",tmpMap1->value);
2272	}
2273	/**
2274	* Parsing BoundingBoxData, fill the following map and then add it to
2275	* the content map of the Input maps:
2276	* lowerCorner, upperCorner, srs and dimensions
2277	* cf. parseBoundingBox
2278	*/
2279	if(strcasecmp(tmpInputs->format,"BoundingBoxData")==0){
2280	maps* tmpI=getMaps(*out,tmpInputs->name);
2281	if(tmpI!=NULL){
2282	map* tmpV=getMap(tmpI->content,"value");
2283	if(tmpV!=NULL){
2284	char *tmpVS=strdup(tmpV->value);
2285	map* tmp=parseBoundingBox(tmpVS);
2286	free(tmpVS);
2287	map* tmpC=tmp;
2288	while(tmpC!=NULL){
2289	addToMap(tmpMaps->content,tmpC->name,tmpC->value);
2290	tmpC=tmpC->next;
2291	}
2292	freeMap(&tmp);
2293	free(tmp);
2294	}
2295	}
2296	}
2297	}
2298
2299	if(tmpIoType!=NULL){
2300	map* tmpContent=tmpIoType->content;
2301	map* cval=NULL;
2302	int hasPassed=-1;
2303	while(tmpContent!=NULL){
2304	if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
2305	#ifdef DEBUG
2306	fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
2307	#endif
2308	if(tmpMaps->content==NULL)
2309	tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
2310	else
2311	addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
2312
2313	if(hasPassed<0 && type==0 && getMap(tmpMaps->content,"isArray")!=NULL){
2314	map* length=getMap(tmpMaps->content,"length");
2315	int i;
2316	char *tcn=strdup(tmpContent->name);
2317	for(i=1;i<atoi(length->value);i++){
2318	#ifdef DEBUG
2319	dumpMap(tmpMaps->content);
2320	fprintf(stderr,"addDefaultValues %s_%d => %s\n",tcn,i,tmpContent->value);
2321	#endif
2322	int len=strlen((char*) tcn);
2323	char tmp1=(char )malloc((len+10)*sizeof(char));
2324	sprintf(tmp1,"%s_%d",tcn,i);
2325	#ifdef DEBUG
2326	fprintf(stderr,"addDefaultValues %s => %s\n",tmp1,tmpContent->value);
2327	#endif
2328	addToMap(tmpMaps->content,tmp1,tmpContent->value);
2329	free(tmp1);
2330	hasPassed=1;
2331	}
2332	free(tcn);
2333	}
2334	}
2335	tmpContent=tmpContent->next;
2336	}
2337	#ifdef USE_MS
2338	/**
2339	* check for useMapServer presence
2340	*/
2341	map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
2342	if(tmpCheck!=NULL){
2343	// Get the default value
2344	tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
2345	tmpCheck=getMap(tmpMaps->content,"mimeType");
2346	addToMap(tmpMaps->content,"requestedMimeType",tmpCheck->value);
2347	map* cursor=tmpIoType->content;
2348	while(cursor!=NULL){
2349	addToMap(tmpMaps->content,cursor->name,cursor->value);
2350	cursor=cursor->next;
2351	}
2352
2353	cursor=tmpInputs->content;
2354	while(cursor!=NULL){
2355	if(strcasecmp(cursor->name,"Title")==0 \|\|
2356	strcasecmp(cursor->name,"Abstract")==0)
2357	addToMap(tmpMaps->content,cursor->name,cursor->value);
2358	cursor=cursor->next;
2359	}
2360	}
2361	#endif
2362	}
2363	if(tmpMaps->content==NULL)
2364	tmpMaps->content=createMap("inRequest","true");
2365	else
2366	addToMap(tmpMaps->content,"inRequest","true");
2367
2368	}
2369	tmpInputs=tmpInputs->next;
2370	}
2371	return "";
2372	}
2373
2374	/**
2375	* parseBoundingBox : parse a BoundingBox string
2376	*
2377	* OGC 06-121r3 : 10.2 Bounding box
2378	*
2379	* value is provided as : lowerCorner,upperCorner,crs,dimension
2380	* exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
2381	*
2382	* Need to create a map to store boundingbox informations :
2383	* - lowerCorner : double,double (minimum within this bounding box)
2384	* - upperCorner : double,double (maximum within this bounding box)
2385	* - crs : URI (Reference to definition of the CRS)
2386	* - dimensions : int
2387	*
2388	* Note : support only 2D bounding box.
2389	*/
2390	map* parseBoundingBox(const char* value){
2391	map *res=NULL;
2392	if(value!=NULL){
2393	char cv,cvp;
2394	cv=strtok_r((char*) value,",",&cvp);
2395	int cnt=0;
2396	int icnt=0;
2397	char *currentValue=NULL;
2398	while(cv){
2399	if(cnt<2)
2400	if(currentValue!=NULL){
2401	char finalValue=(char)malloc((strlen(currentValue)+strlen(cv)+1)*sizeof(char));
2402	sprintf(finalValue,"%s%s",currentValue,cv);
2403	switch(cnt){
2404	case 0:
2405	res=createMap("lowerCorner",finalValue);
2406	break;
2407	case 1:
2408	addToMap(res,"upperCorner",finalValue);
2409	icnt=-1;
2410	break;
2411	}
2412	cnt++;
2413	free(currentValue);
2414	currentValue=NULL;
2415	free(finalValue);
2416	}
2417	else{
2418	currentValue=(char)malloc((strlen(cv)+2)sizeof(char));
2419	sprintf(currentValue,"%s ",cv);
2420	}
2421	else
2422	if(cnt==2){
2423	addToMap(res,"crs",cv);
2424	cnt++;
2425	}
2426	else
2427	addToMap(res,"dimensions",cv);
2428	icnt++;
2429	cv=strtok_r(NULL,",",&cvp);
2430	}
2431	}
2432	return res;
2433	}
2434
2435	/**
2436	* printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
2437	* wps:BoundingBoxData). Set crs and dimensions attributes, add
2438	* Lower/UpperCorner nodes to a pre-existing XML node.
2439	*/
2440	void printBoundingBox(xmlNsPtr ns_ows,xmlNodePtr n,map* boundingbox){
2441
2442	xmlNodePtr bb,lw,uc;
2443
2444	map* tmp=getMap(boundingbox,"value");
2445
2446	tmp=getMap(boundingbox,"lowerCorner");
2447	if(tmp!=NULL){
2448	lw=xmlNewNode(ns_ows,BAD_CAST "LowerCorner");
2449	xmlAddChild(lw,xmlNewText(BAD_CAST tmp->value));
2450	}
2451
2452	tmp=getMap(boundingbox,"upperCorner");
2453	if(tmp!=NULL){
2454	uc=xmlNewNode(ns_ows,BAD_CAST "UpperCorner");
2455	xmlAddChild(uc,xmlNewText(BAD_CAST tmp->value));
2456	}
2457
2458	tmp=getMap(boundingbox,"crs");
2459	if(tmp!=NULL)
2460	xmlNewProp(n,BAD_CAST "crs",BAD_CAST tmp->value);
2461
2462	tmp=getMap(boundingbox,"dimensions");
2463	if(tmp!=NULL)
2464	xmlNewProp(n,BAD_CAST "dimensions",BAD_CAST tmp->value);
2465
2466	xmlAddChild(n,lw);
2467	xmlAddChild(n,uc);
2468
2469	}
2470
2471	void printBoundingBoxDocument(maps* m,maps* boundingbox,FILE* file){
2472	if(file==NULL)
2473	rewind(stdout);
2474	xmlNodePtr n;
2475	xmlDocPtr doc;
2476	xmlNsPtr ns_ows,ns_xsi;
2477	xmlChar *xmlbuff;
2478	int buffersize;
2479	char *encoding=getEncoding(m);
2480	map *tmp;
2481	if(file==NULL){
2482	int pid=0;
2483	tmp=getMapFromMaps(m,"lenv","sid");
2484	if(tmp!=NULL)
2485	pid=atoi(tmp->value);
2486	if(pid==getpid()){
2487	printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
2488	}
2489	fflush(stdout);
2490	}
2491
2492	doc = xmlNewDoc(BAD_CAST "1.0");
2493	int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
2494	ns_ows=usedNs[owsId];
2495	n = xmlNewNode(ns_ows, BAD_CAST "BoundingBox");
2496	xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
2497	int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2498	ns_xsi=usedNs[xsiId];
2499	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");
2500	map *tmp1=getMap(boundingbox->content,"value");
2501	tmp=parseBoundingBox(tmp1->value);
2502	printBoundingBox(ns_ows,n,tmp);
2503	xmlDocSetRootElement(doc, n);
2504
2505	xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2506	if(file==NULL)
2507	printf("%s",xmlbuff);
2508	else{
2509	fprintf(file,"%s",xmlbuff);
2510	}
2511
2512	if(tmp!=NULL){
2513	freeMap(&tmp);
2514	free(tmp);
2515	}
2516	xmlFree(xmlbuff);
2517	xmlFreeDoc(doc);
2518	xmlCleanupParser();
2519	zooXmlCleanupNs();
2520
2521	}
2522
2523
2524	char* getMd5(char* url){
2525	EVP_MD_CTX md5ctx;
2526	char* fresult=(char)malloc((EVP_MAX_MD_SIZE+1)sizeof(char));
2527	unsigned char result[EVP_MAX_MD_SIZE];
2528	unsigned int len;
2529	EVP_DigestInit(&md5ctx, EVP_md5());
2530	EVP_DigestUpdate(&md5ctx, url, strlen(url));
2531	EVP_DigestFinal_ex(&md5ctx,result,&len);
2532	EVP_MD_CTX_cleanup(&md5ctx);
2533	int i;
2534	for(i = 0; i < len; i++){
2535	if(i>0){
2536	char *tmp=strdup(fresult);
2537	sprintf(fresult,"%s%02x", tmp,result[i]);
2538	free(tmp);
2539	}
2540	else
2541	sprintf(fresult,"%02x",result[i]);
2542	}
2543	return fresult;
2544	}
2545
2546	/**
2547	* Cache a file for a given request
2548	*/
2549	void addToCache(maps* conf,char* request,char* content,char* mimeType,int length){
2550	map* tmp=getMapFromMaps(conf,"main","cacheDir");
2551	if(tmp!=NULL){
2552	char* md5str=getMd5(request);
2553	char* fname=(char)malloc(sizeof(char)(strlen(tmp->value)+strlen(md5str)+6));
2554	sprintf(fname,"%s/%s.zca",tmp->value,md5str);
2555	#ifdef DEBUG
2556	fprintf(stderr,"Cache list : %s\n",fname);
2557	fflush(stderr);
2558	#endif
2559	FILE* fo=fopen(fname,"w+");
2560	fwrite(content,sizeof(char),length,fo);
2561	fclose(fo);
2562
2563	sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
2564	fo=fopen(fname,"w+");
2565	#ifdef DEBUG
2566	fprintf(stderr,"MIMETYPE: %s\n",mimeType);
2567	#endif
2568	fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
2569	fclose(fo);
2570
2571	free(md5str);
2572	free(fname);
2573	}
2574	}
2575
2576	char* isInCache(maps* conf,char* request){
2577	map* tmpM=getMapFromMaps(conf,"main","cacheDir");
2578	if(tmpM!=NULL){
2579	char* md5str=getMd5(request);
2580	#ifdef DEBUG
2581	fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
2582	#endif
2583	char* fname=(char)malloc(sizeof(char)(strlen(tmpM->value)+strlen(md5str)+6));
2584	sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
2585	struct stat f_status;
2586	int s=stat(fname, &f_status);
2587	if(s==0 && f_status.st_size>0){
2588	free(md5str);
2589	return fname;
2590	}
2591	free(md5str);
2592	free(fname);
2593	}
2594	return NULL;
2595	}
2596
2597	/**
2598	* loadRemoteFile:
2599	* Try to load file from cache or download a remote file if not in cache
2600	*/
2601	int loadRemoteFile(maps* m,map* content,HINTERNET hInternet,char *url){
2602	HINTERNET res;
2603	char* fcontent;
2604	char* cached=isInCache(m,url);
2605	char *mimeType=NULL;
2606	int fsize;
2607	int hasF=-1;
2608	if(cached!=NULL){
2609	struct stat f_status;
2610	int s=stat(cached, &f_status);
2611	if(s==0){
2612	fcontent=(char)malloc(sizeof(char)(f_status.st_size+1));
2613	FILE* f=fopen(cached,"rb");
2614	int len=fread(fcontent,f_status.st_size,1,f);
2615	fsize=f_status.st_size;
2616	fcontent[fsize]=0;
2617	fclose(f);
2618	}
2619	cached[strlen(cached)-1]='m';
2620	s=stat(cached, &f_status);
2621	if(s==0){
2622	mimeType=(char)malloc(sizeof(char)(f_status.st_size+1));
2623	FILE* f=fopen(cached,"rb");
2624	int len=fread(mimeType,f_status.st_size,1,f);
2625	mimeType[f_status.st_size]=0;
2626	fclose(f);
2627	}
2628	}else{
2629	res=InternetOpenUrl(hInternet,url,NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
2630	fcontent=(char)malloc((res.nDataLen+1)sizeof(char));
2631	if(fcontent == NULL){
2632	return errorException(m, _("Unable to allocate memory."), "InternalError");
2633	}
2634	size_t dwRead;
2635	InternetReadFile(res, (LPVOID)fcontent, res.nDataLen, &dwRead);
2636	fcontent[res.nDataLen]=0;
2637	fsize=res.nDataLen;
2638	mimeType=(char*)res.mimeType;
2639	}
2640	if(fsize==0){
2641	return errorException(m, _("Unable to download the file."), "InternalError");
2642	}
2643
2644	if(mimeType!=NULL){
2645	addToMap(content,"fmimeType",mimeType);
2646	}
2647
2648	map* tmpMap=getMapOrFill(content,"value","");
2649
2650	free(tmpMap->value);
2651	tmpMap->value=(char)malloc((fsize+1)sizeof(char));
2652	if(tmpMap->value==NULL)
2653	fprintf(stderr,"Unable to allocate memory!\n");
2654	//snprintf(tmpMap->value,(fsize+1)*sizeof(char),fcontent);
2655	memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
2656
2657	char ltmp1[256];
2658	sprintf(ltmp1,"%d",fsize);
2659	addToMap(content,"size",ltmp1);
2660	if(cached==NULL)
2661	addToCache(m,url,fcontent,mimeType,fsize);
2662	else{
2663	free(fcontent);
2664	free(mimeType);
2665	free(cached);
2666	}
2667	return 0;
2668	}
2669
2670	int errorException(maps m, const char message, const char *errorcode)
2671	{
2672	map* errormap = createMap("text", message);
2673	addToMap(errormap,"code", errorcode);
2674	printExceptionReportResponse(m,errormap);
2675	freeMap(&errormap);
2676	free(errormap);
2677	return -1;
2678	}

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

Open WPS platform

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

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links