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

Last change on this file since 478 was 478, checked in by djay, 5 years ago

Fix issue on win32 platform for Python support. Remove dirent.obj dependency from utils/status service. readVSIFile defined when MapServer? is not activated.

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

Search

ZOO Sponsors

http://www.zoo-project.org/trac/chrome/site/img/geolabs-logo.pnghttp://www.zoo-project.org/trac/chrome/site/img/neogeo-logo.png http://www.zoo-project.org/trac/chrome/site/img/apptech-logo.png http://www.zoo-project.org/trac/chrome/site/img/3liz-logo.png http://www.zoo-project.org/trac/chrome/site/img/gateway-logo.png

Become a sponsor !

Knowledge partners

http://www.zoo-project.org/trac/chrome/site/img/ocu-logo.png http://www.zoo-project.org/trac/chrome/site/img/gucas-logo.png http://www.zoo-project.org/trac/chrome/site/img/polimi-logo.png http://www.zoo-project.org/trac/chrome/site/img/fem-logo.png http://www.zoo-project.org/trac/chrome/site/img/supsi-logo.png http://www.zoo-project.org/trac/chrome/site/img/cumtb-logo.png

Become a knowledge partner

Related links

http://zoo-project.org/img/ogclogo.png http://zoo-project.org/img/osgeologo.png