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

Last change on this file since 510 was 510, checked in by djay, 8 years ago

Fix leaks in ZOO-Kernel.

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