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

Last change on this file since 510 was 510, checked in by djay, 9 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
RevLine 
[1]1/**
2 * Author : Gérald FENOY
3 *
[392]4 * Copyright (c) 2009-2013 GeoLabs SARL
[1]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"
[364]26#ifdef USE_MS
27#include "service_internal_ms.h"
[478]28#else
29#include "cpl_vsi.h"
[216]30#endif
31
[365]32#ifndef TRUE
33#define TRUE 1
34#endif
35#ifndef FALSE
36#define FALSE -1
37#endif
38
[501]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
[375]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
[216]66void addLangAttr(xmlNodePtr n,maps *m){
[34]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
[1]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
[507]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(
[216]91#ifdef WIN32
[507]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}
[216]115
[507]116#ifdef WIN32
117
[216]118#include <windows.h>
[476]119#include <fcgi_stdio.h>
[216]120#include <stdio.h>
121#include <conio.h>
122#include <tchar.h>
123
124#define SHMEMSIZE 4096
125
[507]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
[216]195static LPVOID lpvMemG = NULL;      // pointer to shared memory
196static HANDLE hMapObjectG = NULL;  // handle to file mapping
197
[471]198int _updateStatus(maps *conf){
[384]199  LPWSTR lpszTmp;
200  BOOL fInit;
[452]201  char *final_string=NULL;
[384]202  char *s=NULL;
[452]203  map *tmpMap1;
[384]204  map *tmpMap=getMapFromMaps(conf,"lenv","sid");
[507]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 
[384]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){
[507]228#ifdef DEBUG
229    fprintf(stderr,"Unable to create shared memory segment %d !! \n",GetLastError());
230#endif
[471]231    return -2;
[384]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){
[507]242#ifdef DEBUG
[384]243    fprintf(stderr,"Unable to create or access the shared memory segment %s !! \n",tmpMap->value);
[507]244#endif
[471]245    return -1;
[384]246  } 
[452]247  memset(lpvMemG, '\0', SHMEMSIZE);
[384]248  tmpMap=getMapFromMaps(conf,"lenv","status");
[452]249  tmpMap1=NULL;
250  tmpMap1=getMapFromMaps(conf,"lenv","message");
[384]251  lpszTmp = (LPWSTR) lpvMemG;
[452]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++){
[384]255    *lpszTmp++ = *s;
[452]256  }
257  *lpszTmp++ = '\0';
258  free(final_string);
[507]259  unlockShm(lockid);
[471]260  return 0;
[216]261}
262
263char* getStatus(int pid){
[467]264  char *lpszBuf=(char*) malloc(SHMEMSIZE*sizeof(char));
[452]265  int i=0;
[216]266  LPWSTR lpszTmp=NULL;
267  LPVOID lpvMem = NULL;
268  HANDLE hMapObject = NULL;
269  BOOL fIgnore,fInit;
[507]270  char tmp[1024];
271  sprintf(tmp,"%d",pid);
[216]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
[507]280  if (hMapObject == NULL){
281#ifdef DEBUG
282    fprintf(stderr,"ERROR on line %d\n",__LINE__);
283#endif
284    return "-1";
285  }
[216]286  if((GetLastError() != ERROR_ALREADY_EXISTS)){
[507]287#ifdef DEBUG
288    fprintf(stderr,"ERROR on line %d\n",__LINE__);
289    fprintf(stderr,"READING STRING S %s\n",GetLastError());
290#endif
[216]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
[507]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
[216]308    return "-1"; 
[507]309  }
[216]310  lpszTmp = (LPWSTR) lpvMem;
[452]311  while (*lpszTmp){
312    lpszBuf[i] = (char)*lpszTmp;
313    *lpszTmp++; 
314    lpszBuf[i+1] = '\0'; 
315    i++;
316  }
317  return (char*)lpszBuf;
[216]318}
319
320void unhandleStatus(maps *conf){
321  BOOL fIgnore;
322  fIgnore = UnmapViewOfFile(lpvMemG); 
323  fIgnore = CloseHandle(hMapObjectG);
324}
[507]325
[216]326#else
[255]327
[507]328#define MAX_RETRIES 10
329
[509]330#ifndef __APPLE__
331union semun {
332  int val;
333  struct semid_ds *buf;
334  ushort *array;
335};
336#endif
337
[507]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
[216]446void unhandleStatus(maps *conf){
[490]447  int shmid;
[26]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
[471]471int _updateStatus(maps *conf){
[490]472  int shmid;
[26]473  char *shm,*s,*s1;
474  map *tmpMap=NULL;
[507]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    }
[26]483    if ((shmid = shmget(key, SHMSZ, IPC_CREAT | 0666)) < 0) {
484#ifdef DEBUG
[255]485      fprintf(stderr,"shmget failed to create new Shared memory segment\n");
[26]486#endif
[507]487      unlockShm(lockid);
[471]488      return -2;
[26]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
[507]494        unlockShm(lockid);
[471]495        return -1;
[26]496      }
497      else{
498        tmpMap=getMapFromMaps(conf,"lenv","status");
499        s1=shm;
[255]500        for(s=tmpMap->value;*s!=NULL && *s!=0;s++){
[26]501          *s1++=*s;
[255]502        }
[440]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        }
[255]509        *s1=NULL;
[26]510        shmdt((void *)shm);
[507]511        unlockShm(lockid);
[26]512      }
513    }
514  }
[471]515  return 0;
[26]516}
517
518char* getStatus(int pid){
[490]519  int shmid;
[26]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  }
[490]536  return (char*)"-1";
[26]537}
538
[216]539#endif
[26]540
[216]541#ifdef USE_JS
542
543JSBool
[274]544JSUpdateStatus(JSContext *cx, uintN argc, jsval *argv1)
[216]545{
[274]546  jsval *argv = JS_ARGV(cx,argv1);
[216]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){
[274]565    if(status!=NULL){
[216]566      setMapInMaps(conf,"lenv","status",status);
[274]567      free(status);
568    }
[216]569    else
570      setMapInMaps(conf,"lenv","status","15");
[471]571    _updateStatus(conf);
[216]572  }
573  freeMaps(&conf);
574  free(conf);
575  JS_MaybeGC(cx);
576  return JS_TRUE;
577}
578
579#endif
580
581
582
[1]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
[9]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}
[1]627
[9]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}
[1]636
[9]637
[114]638int zooXmlSearchForNs(const char* name){
[9]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;
[1]645    }
[9]646  return res;
647}
[1]648
[114]649int zooXmlAddNs(xmlNodePtr nr,const char* url,const char* name){
[1]650#ifdef DEBUG
[483]651  fprintf(stderr,"zooXmlAddNs %d %s \n",nbNs,name);
[1]652#endif
[9]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);
[1]666    }
[9]667  }
668  return currId;
669}
[1]670
[9]671void zooXmlCleanupNs(){
672  int j;
[1]673#ifdef DEBUG
[9]674  fprintf(stderr,"zooXmlCleanup %d\n",nbNs);
[1]675#endif
[9]676  for(j=nbNs-1;j>=0;j--){
[1]677#ifdef DEBUG
[9]678    fprintf(stderr,"zooXmlCleanup %d\n",j);
[1]679#endif
[9]680    if(j==0)
681      xmlFreeNs(usedNs[j]);
682    free(nsName[j]);
683    nbNs--;
[1]684  }
[9]685  nbNs=0;
[1]686}
687
[490]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
[280]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
[114]730xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr doc,const char* service,maps* m){
[1]731
732  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
[490]733  xmlNodePtr n,nc,nc1,nc2,nc3,nc4,nc5,nc6;
[1]734  /**
735   * Create the document and its temporary root.
736   */
[9]737  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
738  ns=usedNs[wpsId];
[1]739  maps* toto1=getMaps(m,"main");
740
[9]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];
[1]744  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
[9]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"); 
[1]750  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
[34]751  addLangAttr(n,m);
[1]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;
[490]770    const char *orderedFields[5];
[71]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++;
[1]808            }
[71]809            if(strlen(buff)>0){
[1]810              nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
811              xmlAddChild(nc2,xmlNewText(BAD_CAST buff));             
812              xmlAddChild(nc1,nc2);
813            }
[71]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);         
[1]821          }
[71]822        tmp2=tmp2->next;
823      }
[1]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;
[490]839    const char *tmpAddress[6];
[57]840    tmpAddress[0]="addressDeliveryPoint";
841    tmpAddress[1]="addressCity";
842    tmpAddress[2]="addressAdministrativeArea";
843    tmpAddress[3]="addressPostalCode";
844    tmpAddress[4]="addressCountry";
845    tmpAddress[5]="addressElectronicMailAddress";
[490]846    const char *tmpPhone[2];
[57]847    tmpPhone[0]="phoneVoice";
848    tmpPhone[1]="phoneFacsimile";
[490]849    const char *orderedFields[12];
[71]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){
[1]870            nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
[71]871            xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
[1]872            xmlAddChild(nc,nc1);
[71]873          }
874          else{
875            if(strcmp(tmp2->name,"ProviderSite")==0){
[1]876              nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
[71]877              xmlNewNsProp(nc1,ns_xlink,BAD_CAST "href",BAD_CAST tmp2->value);
878              xmlAddChild(nc,nc1);
[1]879            } 
[71]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              } 
[1]887              else 
[71]888                if(strncmp(tmp2->name,"Phone",5)==0){
[57]889                  int j;
[71]890                  for(j=0;j<2;j++)
891                    if(strcasecmp(tmp2->name,tmpPhone[j])==0){
[490]892                      char *tmp4=tmp2->name;
893                      nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+5);
[57]894                      xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
[71]895                      xmlAddChild(nc5,nc1);
[57]896                    }
[1]897                }
[71]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){
[490]903                        char *tmp4=tmp2->name;
904                        nc1 = xmlNewNode(ns_ows, BAD_CAST tmp4+7);
[71]905                        xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
906                        xmlAddChild(nc6,nc1);
907                      }
908                  }
909          }
[1]910        }
[71]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++;
[1]931            }
[71]932            if(strlen(buff)>0){
[1]933              nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
934              xmlAddChild(nc2,xmlNewText(BAD_CAST buff));             
935              xmlAddChild(nc1,nc2);
936            }
[71]937            xmlAddChild(nc,nc1);
[1]938          }
[71]939        tmp2=tmp2->next;
940      }
[1]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];
[9]954  tmp2[0]=strdup("GetCapabilities");
955  tmp2[1]=strdup("DescribeProcess");
956  tmp2[2]=strdup("Execute");
[1]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
[9]965      SERVICE_URL = strdup("not_found");
[1]966  }
967  else
[9]968    SERVICE_URL = strdup("not_found");
[1]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);
[9]977    xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
[1]978    xmlAddChild(nc3,nc4);
979    if(j>0){
980      nc4 = xmlNewNode(ns_ows, BAD_CAST "Post");
[9]981      xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
[1]982      xmlAddChild(nc3,nc4);
983    }
984    xmlAddChild(nc2,nc3);
985    xmlAddChild(nc1,nc2);   
986    xmlAddChild(nc,nc1);   
987  }
[9]988  for(j=2;j>=0;j--)
989    free(tmp2[j]);
[1]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 
[280]1038  xmlNodePtr fn=soapEnvelope(m,n);
1039  xmlDocSetRootElement(doc, fn);
[9]1040  //xmlFreeNs(ns);
1041  free(SERVICE_URL);
[1]1042  return nc;
1043}
1044
[469]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
[1]1077void printGetCapabilitiesForProcess(maps* m,xmlNodePtr nc,service* serv){
[9]1078  xmlNsPtr ns,ns_ows,ns_xlink;
[490]1079  xmlNodePtr n=NULL,nc1,nc2;
[9]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];
[1]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)
[9]1095      xmlNewNsProp(nc1,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
[469]1096    map* tmp3=getMapFromMaps(m,"lenv","level");
1097    addPrefix(m,tmp3,serv);
[1]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");
[9]1102      xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
[1]1103      xmlAddChild(nc1,nc2);
1104      tmp1=tmp1->next;
1105    }
1106    xmlAddChild(nc,nc1);
1107  }
1108}
1109
[114]1110xmlNodePtr printDescribeProcessHeader(xmlDocPtr doc,const char* service,maps* m){
[1]1111
[490]1112  xmlNsPtr ns,ns_xsi;
1113  xmlNodePtr n;
[1]1114
[9]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");
[490]1118  zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
[1]1119  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
[9]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");
[1]1125  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1126  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
[34]1127  addLangAttr(n,m);
[1]1128
[280]1129  xmlNodePtr fn=soapEnvelope(m,n);
1130  xmlDocSetRootElement(doc, fn);
[1]1131
1132  return n;
1133}
1134
[469]1135void printDescribeProcessForProcess(maps* m,xmlNodePtr nc,service* serv){
[490]1136  xmlNsPtr ns,ns_ows,ns_xlink;
1137  xmlNodePtr n,nc1;
[1]1138
1139  n=nc;
1140 
[9]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];
[1]1147
1148  nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
[490]1149  const char *tmp4[3];
[1]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++){
[9]1156    tmp1=getMap(serv->content,tmp4[j]);
[1]1157    if(tmp1!=NULL){
1158      if(j==0)
[9]1159        xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);     
[1]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 
[469]1169  tmp1=getMapFromMaps(m,"lenv","level");
1170  addPrefix(m,tmp1,serv);
[9]1171  printDescription(nc,ns_ows,serv->name,serv->content);
[1]1172
[9]1173  tmp1=serv->metadata;
[1]1174  while(tmp1!=NULL){
1175    nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
[9]1176    xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
[1]1177    xmlAddChild(nc,nc1);
1178    tmp1=tmp1->next;
1179  }
1180
[9]1181  tmp1=getMap(serv->content,"Profile");
[1]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
[471]1188  if(serv->inputs!=NULL){
1189    nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
1190    elements* e=serv->inputs;
[490]1191    printFullDescription(1,e,"Input",ns_ows,nc1);
[471]1192    xmlAddChild(nc,nc1);
1193  }
[1]1194
[76]1195  nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
[471]1196  elements* e=serv->outputs;
[490]1197  printFullDescription(0,e,"Output",ns_ows,nc1);
[76]1198  xmlAddChild(nc,nc1);
[1]1199
[76]1200  xmlAddChild(n,nc);
[1]1201
[76]1202}
[1]1203
[490]1204void printFullDescription(int in,elements *elem,const char* type,xmlNsPtr ns_ows,xmlNodePtr nc1){
1205  const char *orderedFields[13];
[76]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";
[459]1213  orderedFields[7]="AllowedValues";
[465]1214  orderedFields[8]="range";
1215  orderedFields[9]="rangeMin";
1216  orderedFields[10]="rangeMax";
1217  orderedFields[11]="rangeClosure";
1218  orderedFields[12]="rangeSpace";
[76]1219
[471]1220  xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7,nc8,nc9;
[76]1221  elements* e=elem;
[471]1222
[76]1223  map* tmp1=NULL;
[1]1224  while(e!=NULL){
[76]1225    int default1=0;
1226    int isAnyValue=1;
1227    nc2 = xmlNewNode(NULL, BAD_CAST type);
[471]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");
[485]1242      if((tmp1=getMap(e->content,"maximumMegabytes"))!=NULL){
1243        xmlNewProp(nc2,BAD_CAST "maximumMegabytes",BAD_CAST tmp1->value);
1244      }
[1]1245    }
1246
1247    printDescription(nc2,ns_ows,e->name,e->content);
1248
[471]1249    /**
1250     * Build the (Literal/Complex/BoundingBox)Data node
1251     */
[76]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)
[1]1256        nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
[76]1257      else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
1258        nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
[1]1259      else
1260        nc3 = xmlNewNode(NULL, BAD_CAST e->format);
[76]1261    }else{
[79]1262      if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
[76]1263        nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
[79]1264      }
[76]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    }
[471]1272
[465]1273    iotype* _tmp0=NULL;
[1]1274    iotype* _tmp=e->defaults;
1275    int datatype=0;
[79]1276    bool hasUOM=false;
[471]1277    bool hasUOM1=false;
[1]1278    if(_tmp!=NULL){
[79]1279      if(strcmp(e->format,"LiteralOutput")==0 ||
1280         strcmp(e->format,"LiteralData")==0){
[1]1281        datatype=1;
1282        nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
1283        nc5 = xmlNewNode(NULL, BAD_CAST "Default");
[79]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;
[459]1296
[471]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){
[465]1308
[471]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        }
[465]1330
[471]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             */
[490]1353            const char *tmp="closed";
[471]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");
[507]1369                strncpy( tmpStr, pToken+1, strlen(pToken)-1 );
1370                tmpStr[strlen(pToken)-1] = '\0';
1371              }else{
[471]1372                nc7 = xmlNewNode(ns_ows, BAD_CAST "MaximumValue");
[507]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                  }
[459]1378              }
[471]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);
[79]1389            }
[471]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);
[79]1401            }
[471]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){
[490]1419              const char *tmp="closed";
[471]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;
[507]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 )){
[476]1440              tmp1=_tmp0->content;
1441              goto doRange;
1442            }
[79]1443          }else{
[471]1444            _tmp0=_tmp0->next;
1445            if(_tmp0!=NULL){
1446              xmlAddChild(nc6,nc8);
[476]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              }
[79]1454            }
1455          }
[471]1456          xmlAddChild(nc6,nc8);
1457          xmlAddChild(nc3,nc6);
1458          isAnyValue=-1;
[1]1459        }
[471]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          }
[459]1507        }
[471]1508      }else{
1509        xmlAddChild(nc3,nc5);
[459]1510      }
[465]1511     
[471]1512      if(datatype!=1 && default1<0){
1513        xmlFreeNode(nc5);
1514        if(datatype!=2)
1515          xmlFreeNode(nc4);
1516      }
1517
[465]1518      map* metadata=e->metadata;
[490]1519      xmlNodePtr n=NULL;
[465]1520      int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1521      xmlNsPtr ns_xlink=usedNs[xlinkId];
1522
1523      while(metadata!=NULL){
[471]1524        nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
[465]1525        xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
1526        xmlAddChild(nc2,nc6);
1527        metadata=metadata->next;
1528      }
[471]1529
[1]1530    }
[280]1531
[1]1532    _tmp=e->supported;
[471]1533    if(_tmp==NULL && datatype!=1)
[280]1534      _tmp=e->defaults;
1535
[71]1536    int hasSupported=-1;
[471]1537
[1]1538    while(_tmp!=NULL){
[71]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
[76]1548        if(datatype==0)
1549          nc5 = xmlNewNode(NULL, BAD_CAST "Format");
[1]1550      tmp1=_tmp->content;
[71]1551      int oI=0;
[76]1552      for(oI=0;oI<6;oI++)
[71]1553        if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
[1]1554#ifdef DEBUG
[71]1555          printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
[1]1556#endif
[71]1557          if(strcmp(tmp1->name,"asReference")!=0 && 
[471]1558             strcmp(tmp1->name,"value")!=0 && 
[71]1559             strcmp(tmp1->name,"DataType")!=0 &&
1560             strcasecmp(tmp1->name,"extension")!=0){
[76]1561            if(datatype!=1){
[71]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            }
[76]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            }
[471]1587            xmlAddChild(nc5,nc6);
[9]1588          }
[71]1589          tmp1=tmp1->next;
[1]1590        }
[71]1591      if(hasSupported<=0){
[471]1592        if(datatype==0){
[71]1593          xmlAddChild(nc4,nc5);
1594          xmlAddChild(nc3,nc4);
[471]1595        }else{
1596          if(datatype!=1)
1597            xmlAddChild(nc3,nc5);
1598        }
[71]1599        hasSupported=1;
[1]1600      }
[71]1601      else
[471]1602        if(datatype==0){
[76]1603          xmlAddChild(nc4,nc5);
[471]1604          xmlAddChild(nc3,nc4);
[76]1605        }
1606        else
[471]1607          if(datatype!=1)
1608            xmlAddChild(nc3,nc5);
1609
[76]1610      _tmp=_tmp->next;
[1]1611    }
[471]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
[490]1625    if(in>0 && datatype==1 &&
[471]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   
[1]1652    xmlAddChild(nc2,nc3);
1653   
1654    xmlAddChild(nc1,nc2);
1655   
1656    e=e->next;
1657  }
1658}
1659
[114]1660void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
[490]1661  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1662  xmlNodePtr nr,n,nc,nc1=NULL,nc3;
[9]1663  xmlDocPtr doc;
1664  time_t time1; 
1665  time(&time1);
[280]1666  nr=NULL;
[9]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];
[280]1673
[9]1674  n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
[280]1675  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
[9]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];
[280]1682 
[9]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");
[34]1687  addLangAttr(n,m);
1688
[9]1689  char tmp[256];
[26]1690  char url[1024];
[72]1691  char stored_path[1024];
[9]1692  memset(tmp,0,256);
[72]1693  memset(url,0,1024);
1694  memset(stored_path,0,1024);
[9]1695  maps* tmp_maps=getMaps(m,"main");
1696  if(tmp_maps!=NULL){
[26]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){
[280]1726        sprintf(url,"%s?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
[26]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
[41]1734          sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
[26]1735      }
1736    }else{
1737      map* tmpm2=getMap(tmp_maps->content,"tmpUrl");
1738      if(tmpm1!=NULL && tmpm2!=NULL){
[453]1739        if( strncasecmp( tmpm2->value, "http://", 7) == 0 ||
1740            strncasecmp( tmpm2->value, "https://", 8 ) == 0 ){
[378]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);
[26]1744      }
[9]1745    }
[26]1746    if(tmpm1!=NULL)
[280]1747      sprintf(tmp,"%s",tmpm1->value);
[72]1748    tmpm1=getMapFromMaps(m,"main","TmpPath");
1749    sprintf(stored_path,"%s/%s_%i.xml",tmpm1->value,service,pid);
[9]1750  }
1751
[72]1752
[364]1753
[9]1754  xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
[72]1755  map* test=getMap(request,"storeExecuteResponse");
1756  bool hasStoredExecuteResponse=false;
1757  if(test!=NULL && strcasecmp(test->value,"true")==0){
[9]1758    xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
[72]1759    hasStoredExecuteResponse=true;
[9]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;
[26]1776  map *tmpStatus;
[9]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
[26]1785  xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
1786
1787  char sMsg[2048];
[9]1788  switch(status){
1789  case SERVICE_SUCCEEDED:
1790    nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
[34]1791    sprintf(sMsg,_("Service \"%s\" run successfully."),serv->name);
[26]1792    nc3=xmlNewText(BAD_CAST sMsg);
1793    xmlAddChild(nc1,nc3);
[9]1794    break;
1795  case SERVICE_STARTED:
1796    nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
[26]1797    tmpStatus=getMapFromMaps(m,"lenv","status");
1798    xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST tmpStatus->value);
[34]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);
[26]1800    nc3=xmlNewText(BAD_CAST sMsg);
1801    xmlAddChild(nc1,nc3);
[9]1802    break;
1803  case SERVICE_ACCEPTED:
1804    nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
[34]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);
[26]1806    nc3=xmlNewText(BAD_CAST sMsg);
1807    xmlAddChild(nc1,nc3);
[9]1808    break;
1809  case SERVICE_FAILED:
1810    nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
[26]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)
[57]1820      addToMap(errorMap,"text",_ss(te->value));
[26]1821    else
[34]1822      addToMap(errorMap,"text",_("No more information available"));
[26]1823    nc3=createExceptionReportNode(m,errorMap,0);
[59]1824    freeMap(&errorMap);
1825    free(errorMap);
[26]1826    xmlAddChild(nc1,nc3);
[9]1827    break;
1828  default :
[34]1829    printf(_("error code not know : %i\n"),status);
[26]1830    //exit(1);
[9]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");
[87]1842  if(lineage!=NULL && strcasecmp(lineage->value,"true")==0){
[9]1843    nc = xmlNewNode(ns, BAD_CAST "DataInputs");
1844    maps* mcursor=inputs;
[65]1845    elements* scursor=NULL;
[9]1846    while(mcursor!=NULL /*&& scursor!=NULL*/){
[65]1847      scursor=getElements(serv->inputs,mcursor->name);
[76]1848      printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Input");
[9]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;
[65]1859    scursor=NULL;
1860    while(mcursor!=NULL){
1861      scursor=getElements(serv->outputs,mcursor->name);
[9]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;
[379]1878    map* testResponse=getMap(request,"RawDataOutput");
1879    if(testResponse==NULL)
1880      testResponse=getMap(request,"ResponseDocument");
[63]1881    while(mcursor!=NULL){
[379]1882      map* tmp0=getMap(mcursor->content,"inRequest");
[65]1883      scursor=getElements(serv->outputs,mcursor->name);
[280]1884      if(scursor!=NULL){
[403]1885        if(testResponse==NULL || tmp0==NULL)
[379]1886          printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1887        else
[403]1888          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0)
[379]1889            printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
[449]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");
[9]1896      mcursor=mcursor->next;
1897    }
1898    xmlAddChild(n,nc);
1899  }
[364]1900
[9]1901#ifdef DEBUG
1902  fprintf(stderr,"printProcessResponse 1 202\n");
1903#endif
[280]1904  nr=soapEnvelope(m,n);
1905  xmlDocSetRootElement(doc, nr);
1906
[507]1907  if(hasStoredExecuteResponse==true && status!=SERVICE_STARTED){
1908    semid lid=getShmLockId(m,1);
1909    if(lid<0)
[393]1910      return;
[507]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      }
[393]1947    }
[72]1948  }
[9]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()){
[384]1959    printHeaders(m);
[9]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;
[1]1965  /*
[9]1966   * Dump the document to a buffer and print it on stdout
[1]1967   * for demonstration purposes.
1968   */
[9]1969  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
[114]1970  printf("%s",xmlbuff);
[216]1971  fflush(stdout);
[1]1972  /*
1973   * Free associated memory.
1974   */
1975  xmlFree(xmlbuff);
[9]1976  xmlFreeDoc(doc);
1977  xmlCleanupParser();
1978  zooXmlCleanupNs();
[1]1979}
1980
[114]1981void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,const char* type){
[1]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){
[9]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)
[1]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
[114]2013void printOutputDefinitions(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,map* m,const char* type){
[490]2014  xmlNodePtr nc1;
[1]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
[114]2041void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
[1]2042  xmlNodePtr nc1,nc2,nc3;
2043  nc1=xmlNewNode(ns_wps, BAD_CAST type);
[65]2044  map *tmp=NULL;
2045  if(e!=NULL)
2046    tmp=e->content;
2047  else
2048    tmp=m->content;
[26]2049#ifdef DEBUG
[1]2050  dumpMap(tmp);
2051  dumpElements(e);
[26]2052#endif
[1]2053  nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
[65]2054  if(e!=NULL)
2055    nc3=xmlNewText(BAD_CAST e->name);
2056  else
2057    nc3=xmlNewText(BAD_CAST m->name);
[9]2058  xmlAddChild(nc2,nc3);
[1]2059  xmlAddChild(nc1,nc2);
2060  xmlAddChild(nc,nc1);
[65]2061  if(e!=NULL)
2062    tmp=getMap(e->content,"Title");
2063  else
2064    tmp=getMap(m->content,"Title");
2065 
2066  if(tmp!=NULL){
[43]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);
[65]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);
[43]2082    xmlAddChild(nc,nc1);
2083  }
[1]2084
2085  /**
2086   * IO type Reference or full Data ?
2087   */
[26]2088#ifdef DEBUG
[9]2089  fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
[26]2090#endif
[9]2091  map *tmpMap=getMap(m->content,"Reference");
2092  if(tmpMap==NULL){
2093    nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
[65]2094    if(e!=NULL){
[76]2095      if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
[65]2096        nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
[9]2097      else
[76]2098        if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
[65]2099          nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
[76]2100        else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
2101          nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
[65]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");
[76]2111    } 
[9]2112    tmp=m->content;
[297]2113#ifdef USE_MS
2114    map* testMap=getMap(tmp,"requestedMimeType");
2115#endif
[9]2116    while(tmp!=NULL){
[70]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 ||
[490]2121         strcasecmp(tmp->name,"uom")==0){
[297]2122#ifdef USE_MS
[299]2123        if(testMap==NULL || (testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)==0)){
[297]2124#endif
[490]2125          xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
[297]2126#ifdef USE_MS
[299]2127        }
[490]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          }
[297]2135#endif
[490]2136      }
[9]2137      tmp=tmp->next;
2138      xmlAddChild(nc2,nc3);
[1]2139    }
[76]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);
[9]2147      }
[76]2148    }else{
2149      if(e!=NULL)
2150        tmp=getMap(e->defaults->content,"mimeType");
2151      else
2152        tmp=NULL;
[297]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;
[492]2162        char* tmpValue;
2163        size_t dwRead;
[297]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");
[492]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);
[297]2177      }
2178#endif
[76]2179      map* tmp1=getMap(m->content,"encoding");
2180      map* tmp2=getMap(m->content,"mimeType");
[379]2181      map* tmp3=getMap(m->content,"value");
2182      int hasValue=1;
2183      if(tmp3==NULL){
2184        tmp3=createMap("value","");
2185        hasValue=-1;
2186      }
[76]2187      if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
2188         || (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 ||
[490]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))
[279]2193             )) {
[76]2194        map* rs=getMap(m->content,"size");
2195        bool isSized=true;
2196        if(rs==NULL){
2197          char tmp1[1024];
[490]2198          sprintf(tmp1,"%u",strlen(tmp3->value));
[280]2199          rs=createMap("size",tmp1);
[76]2200          isSized=false;
2201        }
[94]2202
[379]2203        xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
[500]2204        if(tmp1==NULL || (tmp1!=NULL && strncmp(tmp1->value,"base64",6)!=0))
2205          xmlNewProp(nc3,BAD_CAST "encoding",BAD_CAST "base64");
[76]2206        if(!isSized){
2207          freeMap(&rs);
2208          free(rs);
2209        }
[59]2210      }
[280]2211      else if(tmp2!=NULL){
2212        if(strncmp(tmp2->value,"text/js",7)==0 ||
2213           strncmp(tmp2->value,"application/json",16)==0)
[379]2214          xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
[280]2215        else{
2216          if(strncmp(tmp2->value,"text/xml",8)==0 ||
[307]2217             strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
[490]2218            int li=zooXmlAddDoc(tmp3->value);
2219            xmlDocPtr doc = iDocs[li];
[280]2220            xmlNodePtr ir = xmlDocGetRootElement(doc);
2221            xmlAddChild(nc3,ir);
2222          }
2223          else
[379]2224            xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
[280]2225        }
[76]2226        xmlAddChild(nc2,nc3);
2227      }
[364]2228      else{
[379]2229        xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
2230      }
2231      if(hasValue<0){
2232        freeMap(&tmp3);
2233        free(tmp3);
2234      }
[9]2235    }
[1]2236  }
[9]2237  else{
[297]2238    tmpMap=getMap(m->content,"Reference");
[9]2239    nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
[76]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);
[9]2244    tmp=m->content;
[297]2245#ifdef USE_MS
2246    map* testMap=getMap(tmp,"requestedMimeType");
2247#endif
[9]2248    while(tmp!=NULL){
[70]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 ||
[490]2253         strcasecmp(tmp->name,"uom")==0){
[297]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
[492]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);
[490]2265      }
[9]2266      tmp=tmp->next;
2267      xmlAddChild(nc2,nc3);
2268    }
[1]2269  }
2270  xmlAddChild(nc1,nc2);
2271  xmlAddChild(nc,nc1);
2272
2273}
2274
[114]2275void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
[1]2276  xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
[469]2277 
[1]2278  xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
2279  xmlAddChild(root,nc2);
2280  map* tmp=amap;
[490]2281  const char *tmp2[2];
[1]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]);
[34]2289      xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
[1]2290      xmlAddChild(root,nc2);
2291    }
2292  }
2293}
2294
[9]2295char* getEncoding(maps* m){
2296  if(m!=NULL){
2297    map* tmp=getMap(m->content,"encoding");
[1]2298    if(tmp!=NULL){
[9]2299      return tmp->value;
[1]2300    }
2301    else
[490]2302      return (char*)"UTF-8";
[1]2303  }
2304  else
[490]2305    return (char*)"UTF-8"; 
[9]2306}
[1]2307
[9]2308char* getVersion(maps* m){
2309  if(m!=NULL){
2310    map* tmp=getMap(m->content,"version");
[1]2311    if(tmp!=NULL){
[9]2312      return tmp->value;
[1]2313    }
2314    else
[490]2315      return (char*)"1.0.0";
[1]2316  }
2317  else
[490]2318    return (char*)"1.0.0";
[9]2319}
[1]2320
[9]2321void printExceptionReportResponse(maps* m,map* s){
[469]2322  if(getMapFromMaps(m,"lenv","hasPrinted")!=NULL)
2323    return;
[9]2324  int buffersize;
2325  xmlDocPtr doc;
2326  xmlChar *xmlbuff;
[34]2327  xmlNodePtr n;
[1]2328
[483]2329  zooXmlCleanupNs();
[9]2330  doc = xmlNewDoc(BAD_CAST "1.0");
2331  maps* tmpMap=getMaps(m,"main");
2332  char *encoding=getEncoding(tmpMap);
[490]2333  const char *exceptionCode;
[459]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
[32]2355  if(m!=NULL){
2356    map *tmpSid=getMapFromMaps(m,"lenv","sid");
2357    if(tmpSid!=NULL){
[384]2358      if( getpid()==atoi(tmpSid->value) ){
2359        printHeaders(m);
[459]2360        printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[384]2361      }
[32]2362    }
[384]2363    else{
2364      printHeaders(m);
[459]2365      printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[384]2366    }
[385]2367  }else{
[459]2368    printf("Content-Type: text/xml; charset=%s\r\nStatus: %s\r\n\r\n",encoding,exceptionCode);
[385]2369  }
[34]2370  n=createExceptionReportNode(m,s,1);
[1]2371  xmlDocSetRootElement(doc, n);
[9]2372  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2373  printf("%s",xmlbuff);
2374  fflush(stdout);
2375  xmlFreeDoc(doc);
[1]2376  xmlFree(xmlbuff);
[9]2377  xmlCleanupParser();
[57]2378  zooXmlCleanupNs();
[471]2379  if(m!=NULL)
2380    setMapInMaps(m,"lenv","hasPrinted","true");
[1]2381}
2382
[26]2383xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
2384 
[490]2385  xmlNsPtr ns,ns_xsi;
2386  xmlNodePtr n,nc,nc1;
[1]2387
[469]2388  int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows","ows");
[57]2389  ns=usedNs[nsid];
[481]2390  if(use_ns==1){
2391    ns=NULL;
2392  }
[26]2393  n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
2394  if(use_ns==1){
[490]2395    xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",NULL);
[26]2396    int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2397    ns_xsi=usedNs[xsiId];
[469]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");
[26]2399  }
[481]2400
2401
[34]2402  addLangAttr(n,m);
[26]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
[459]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
[26]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{
[34]2424    xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
[26]2425  }
2426  xmlAddChild(nc,nc1);
2427  xmlAddChild(n,nc);
2428  return n;
2429}
2430
2431
[1]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;
[9]2443 
[379]2444  maps* tmpSess=getMaps(m,"senv");
2445  if(tmpSess!=NULL){
2446    map *_tmp=getMapFromMaps(m,"lenv","cookie");
[490]2447    char* sessId=NULL;
[379]2448    if(_tmp!=NULL){
[442]2449      printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
[379]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];
[92]2452      char *tmp1=strtok(_tmp->value,";");
2453      if(tmp1!=NULL)
[379]2454        sprintf(session_file_path,"%s",strstr(tmp1,"=")+1);
[92]2455      else
[379]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      }
[92]2468    }
[379]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);
[387]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");
[453]2480     
[387]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    }
[92]2490  }
[379]2491 
[453]2492
[1]2493  if(asRaw==0){
[9]2494#ifdef DEBUG
2495    fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
2496    dumpMaps(request_outputs);
2497#endif
[70]2498    maps* tmpI=request_outputs;
2499    while(tmpI!=NULL){
[297]2500#ifdef USE_MS
[364]2501      map* testMap=getMap(tmpI->content,"useMapserver");       
[297]2502#endif
[70]2503      toto=getMap(tmpI->content,"asReference");
[297]2504#ifdef USE_MS
[453]2505      if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
[297]2506#else
[453]2507      if(toto!=NULL && strcasecmp(toto->value,"true")==0)
[297]2508#endif
[453]2509        {
[76]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");
[70]2523        map *tmp1=getMapFromMaps(m,"main","tmpPath");
[453]2524        char *file_name,*file_path;
[70]2525        bool hasExt=true;
[76]2526        if(ext==NULL){
[70]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.
[383]2530          // If mimeType was not found, we then set txt as the default extension
[70]2531          map* mtype=getMap(tmpI->content,"mimeType");
2532          if(mtype!=NULL){
2533            if(strcasecmp(mtype->value,"text/xml")==0)
[76]2534              ext=createMap("extension","xml");
[70]2535            else if(strcasecmp(mtype->value,"application/json")==0)
[76]2536              ext=createMap("extension","js");
[306]2537            else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
[279]2538              ext=createMap("extension","kml");
[306]2539            else if(strncmp(mtype->value,"image/",6)==0)
2540              ext=createMap("extension",strstr(mtype->value,"/")+1);
[70]2541            else
[76]2542              ext=createMap("extension","txt");
[70]2543          }
[57]2544          else
[76]2545            ext=createMap("extension","txt");
[70]2546          hasExt=false;
[57]2547        }
[453]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");
[386]2554        if(ofile==NULL){
2555          char tmpMsg[1024];
[387]2556          sprintf(tmpMsg,_("Unable to create the file : \"%s\" for storing the %s final result."),file_name,tmpI->name);
[386]2557          map * errormap = createMap("text",tmpMsg);
2558          addToMap(errormap,"code", "InternalError");
2559          printExceptionReportResponse(m,errormap);
2560          freeMap(&errormap);
2561          free(errormap);
[453]2562          free(file_name);
2563          free(file_path);
[386]2564          return;
2565        }
[453]2566        free(file_path);
[70]2567        map *tmp2=getMapFromMaps(m,"main","tmpUrl");
2568        map *tmp3=getMapFromMaps(m,"main","serverAddress");
2569        char *file_url;
[458]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));
[453]2573          sprintf(file_url,"%s/%s",tmp2->value,file_name);
[378]2574        }else{
[458]2575          file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
[453]2576          sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
[378]2577        }
[70]2578        addToMap(tmpI->content,"Reference",file_url);
[387]2579        if(!hasExt){
[76]2580          freeMap(&ext);
2581          free(ext);
[70]2582        }
2583        toto=getMap(tmpI->content,"value");
[76]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);
[70]2595        fclose(ofile);
2596        free(file_name);
[76]2597        free(file_url); 
[500]2598        }
[297]2599#ifdef USE_MS
2600      else{
2601        if(testMap!=NULL){
2602          setReferenceUrl(m,tmpI);
2603        }
2604      }
2605#endif
[70]2606      tmpI=tmpI->next;
[9]2607    }
[1]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
[9]2613    printProcessResponse(m,request_inputs1,cpid,
[26]2614                         s,r_inputs->value,res,
2615                         request_inputs,
2616                         request_outputs);
[453]2617    }
2618    else{
[481]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      }
[26]2640      /**
[66]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.
[26]2643       */
[66]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;
[76]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);
[114]2664          return;
[76]2665        }
[383]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);
[384]2672        printHeaders(m);
[76]2673        char mime[1024];
2674        map* mi=getMap(tmpI->content,"mimeType");
[1]2675#ifdef DEBUG
[76]2676        fprintf(stderr,"SERVICE OUTPUTS\n");
2677        dumpMaps(request_outputs);
2678        fprintf(stderr,"SERVICE OUTPUTS\n");
[1]2679#endif
[76]2680        map* en=getMap(tmpI->content,"encoding");
2681        if(mi!=NULL && en!=NULL)
[26]2682          sprintf(mime,
[76]2683                  "Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
2684                  mi->value,en->value);
[26]2685        else
[76]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);
[383]2693        if(rs!=NULL)
[385]2694          fwrite(toto->value,1,atoi(rs->value),stdout);
[76]2695        else
[385]2696          fwrite(toto->value,1,strlen(toto->value),stdout);
[1]2697#ifdef DEBUG
[76]2698        dumpMap(toto);
[1]2699#endif
[76]2700      }
[26]2701    }
[1]2702}
2703
[216]2704char *base64(const char *input, int length)
[1]2705{
2706  BIO *bmem, *b64;
2707  BUF_MEM *bptr;
2708
2709  b64 = BIO_new(BIO_f_base64());
[94]2710  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
[1]2711  bmem = BIO_new(BIO_s_mem());
2712  b64 = BIO_push(b64, bmem);
[500]2713  BIO_write(b64, input, length+1);
[1]2714  BIO_flush(b64);
2715  BIO_get_mem_ptr(b64, &bptr);
2716
[500]2717  char *buff = (char *)malloc((bptr->length+1)*sizeof(char));
2718  memcpy(buff, bptr->data, bptr->length);
[1]2719  buff[bptr->length-1] = 0;
2720
2721  BIO_free_all(b64);
2722
2723  return buff;
2724}
2725
[216]2726char *base64d(const char *input, int length,int* red)
[88]2727{
2728  BIO *b64, *bmem;
2729
2730  char *buffer = (char *)malloc(length);
[94]2731  if(buffer){
2732    memset(buffer, 0, length);
2733    b64 = BIO_new(BIO_f_base64());
2734    if(b64){
[216]2735      bmem = BIO_new_mem_buf((unsigned char*)input,length);
[94]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  }
[88]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);
[94]2752      int size=0;
[88]2753      char *s=strdup(tmp->value);
2754      free(tmp->value);
2755      tmp->value=base64d(s,strlen(s),&size);
[94]2756      free(s);
[88]2757      char sizes[1024];
2758      sprintf(sizes,"%d",size);
2759      addToMap(cursor->content,"size",sizes);
2760    }
2761    cursor=cursor->next;
2762  }
2763}
2764
[63]2765char* addDefaultValues(maps** out,elements* in,maps* m,int type){
[1]2766  elements* tmpInputs=in;
2767  maps* out1=*out;
[280]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  }
[1]2776  while(tmpInputs!=NULL){
2777    maps *tmpMaps=getMaps(out1,tmpInputs->name);
2778    if(tmpMaps==NULL){
[9]2779      maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
[57]2780      tmpMaps2->name=strdup(tmpInputs->name);
[9]2781      tmpMaps2->content=NULL;
2782      tmpMaps2->next=NULL;
[63]2783     
2784      if(type==0){
2785        map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
[490]2786        if(tmpMapMinO!=NULL){
[63]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          }
[490]2798        }
[63]2799        map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
[490]2800        if(tmpMaxO!=NULL){
[63]2801          if(tmpMaps2->content==NULL)
2802            tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
2803          else
2804            addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
[490]2805        }
[485]2806        map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
[490]2807        if(tmpMaxMB!=NULL){
[485]2808          if(tmpMaps2->content==NULL)
2809            tmpMaps2->content=createMap("maximumMegabytes",tmpMaxMB->value);
2810          else
2811            addToMap(tmpMaps2->content,"maximumMegabytes",tmpMaxMB->value);
[490]2812        }
[63]2813      }
2814
[1]2815      iotype* tmpIoType=tmpInputs->defaults;
[63]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        }
[1]2825      }
[88]2826      addToMap(tmpMaps2->content,"inRequest","false");
[93]2827      if(type==0){
[57]2828        map *tmpMap=getMap(tmpMaps2->content,"value");
2829        if(tmpMap==NULL)
2830          addToMap(tmpMaps2->content,"value","NULL");
2831      }
[1]2832      if(out1==NULL){
[9]2833        *out=dupMaps(&tmpMaps2);
[63]2834        out1=*out;
[1]2835      }
2836      else
[9]2837        addMapsToMaps(&out1,tmpMaps2);
[63]2838      freeMap(&tmpMaps2->content);
2839      free(tmpMaps2->content);
2840      tmpMaps2->content=NULL;
[9]2841      freeMaps(&tmpMaps2);
2842      free(tmpMaps2);
2843      tmpMaps2=NULL;
[1]2844    }
2845    else{
[57]2846      iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
2847                                             tmpMaps->content);
[63]2848      if(type==0) {
[76]2849        /**
2850         * In case of an Input maps, then add the minOccurs and maxOccurs to the
2851         * content map.
2852         */
[63]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)
[485]2863            tmpMaps->content=createMap("maxOccurs",tmpMaxO->value);
[63]2864          else
[485]2865            addToMap(tmpMaps->content,"maxOccurs",tmpMaxO->value);
[63]2866        }
[485]2867        map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
[490]2868        if(tmpMaxMB!=NULL){
[485]2869          if(tmpMaps->content==NULL)
2870            tmpMaps->content=createMap("maximumMegabytes",tmpMaxMB->value);
2871          else
2872            addToMap(tmpMaps->content,"maximumMegabytes",tmpMaxMB->value);
[490]2873        }
[76]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        }
[63]2898      }
2899
[57]2900      if(tmpIoType!=NULL){
2901        map* tmpContent=tmpIoType->content;
2902        map* cval=NULL;
[360]2903        int hasPassed=-1;
[57]2904        while(tmpContent!=NULL){
2905          if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
[9]2906#ifdef DEBUG
[57]2907            fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
[9]2908#endif
[63]2909            if(tmpMaps->content==NULL)
2910              tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
2911            else
2912              addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
[360]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++){
[364]2919#ifdef DEBUG
[360]2920                dumpMap(tmpMaps->content);
2921                fprintf(stderr,"addDefaultValues %s_%d => %s\n",tcn,i,tmpContent->value);
[364]2922#endif
2923                int len=strlen((char*) tcn);
2924                char *tmp1=(char *)malloc((len+10)*sizeof(char));
[360]2925                sprintf(tmp1,"%s_%d",tcn,i);
[364]2926#ifdef DEBUG
[360]2927                fprintf(stderr,"addDefaultValues %s => %s\n",tmp1,tmpContent->value);
[364]2928#endif
[360]2929                addToMap(tmpMaps->content,tmp1,tmpContent->value);
2930                free(tmp1);
2931                hasPassed=1;
2932              }
2933              free(tcn);
2934            }
[57]2935          }
2936          tmpContent=tmpContent->next;
[9]2937        }
[297]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
[1]2963      }
[92]2964      if(tmpMaps->content==NULL)
2965        tmpMaps->content=createMap("inRequest","true");
2966      else
2967        addToMap(tmpMaps->content,"inRequest","true");
[280]2968
[1]2969    }
2970    tmpInputs=tmpInputs->next;
2971  }
[9]2972  return "";
[1]2973}
[76]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 */
[114]2991map* parseBoundingBox(const char* value){
[76]2992  map *res=NULL;
2993  if(value!=NULL){
2994    char *cv,*cvp;
[114]2995    cv=strtok_r((char*) value,",",&cvp);
[76]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
[490]3043  xmlNodePtr lw=NULL,uc=NULL;
[76]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");
[216]3097  xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
[76]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)
[114]3108    printf("%s",xmlbuff);
[76]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}
[280]3123
[281]3124
[364]3125char* getMd5(char* url){
[291]3126  EVP_MD_CTX md5ctx;
[364]3127  char* fresult=(char*)malloc((EVP_MAX_MD_SIZE+1)*sizeof(char));
[291]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
[280]3147/**
3148 * Cache a file for a given request
3149 */
[446]3150void addToCache(maps* conf,char* request,char* content,char* mimeType,int length){
[280]3151  map* tmp=getMapFromMaps(conf,"main","cacheDir");
3152  if(tmp!=NULL){
[364]3153    char* md5str=getMd5(request);
[292]3154    char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
3155    sprintf(fname,"%s/%s.zca",tmp->value,md5str);
[291]3156#ifdef DEBUG
[280]3157    fprintf(stderr,"Cache list : %s\n",fname);
3158    fflush(stderr);
[291]3159#endif
[293]3160    FILE* fo=fopen(fname,"w+");
[471]3161    if(fo==NULL){
3162      fprintf (stderr, "Failed to open %s for writting: %s\n",fname, strerror(errno));
3163      return;
3164    }
[293]3165    fwrite(content,sizeof(char),length,fo);
3166    fclose(fo);
[446]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
[492]3173    fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
[446]3174    fclose(fo);
3175
[293]3176    free(md5str);
3177    free(fname);
[280]3178  }
3179}
3180
3181char* isInCache(maps* conf,char* request){
[291]3182  map* tmpM=getMapFromMaps(conf,"main","cacheDir");
3183  if(tmpM!=NULL){
[364]3184    char* md5str=getMd5(request);
[291]3185#ifdef DEBUG
3186    fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
3187#endif
[392]3188    char* fname=(char*)malloc(sizeof(char)*(strlen(tmpM->value)+strlen(md5str)+6));
[292]3189    sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
[280]3190    struct stat f_status;
3191    int s=stat(fname, &f_status);
[292]3192    if(s==0 && f_status.st_size>0){
3193      free(md5str);
3194      return fname;
3195    }
[291]3196    free(md5str);
3197    free(fname);
[280]3198  }
3199  return NULL;
3200}
[281]3201
[492]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;
[510]3227          if(hInternet->ihandle[index].mimeType==NULL)
3228            mimeType=strdup("none");
3229          else
3230            mimeType=strdup((char*)hInternet->ihandle[index].mimeType);
[492]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
[281]3254/**
3255 * loadRemoteFile:
3256 * Try to load file from cache or download a remote file if not in cache
3257 */
[492]3258int loadRemoteFile(maps** m,map** content,HINTERNET* hInternet,char *url){
[281]3259  char* fcontent;
[471]3260  char* cached=isInCache(*m,url);
[446]3261  char *mimeType=NULL;
[490]3262  int fsize=0;
[281]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));
[375]3268      FILE* f=fopen(cached,"rb");
[490]3269      fread(fcontent,f_status.st_size,1,f);
[281]3270      fsize=f_status.st_size;
[392]3271      fcontent[fsize]=0;
[446]3272      fclose(f);
[281]3273    }
[446]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");
[490]3279      fread(mimeType,f_status.st_size,1,f);
[446]3280      mimeType[f_status.st_size]=0;
3281      fclose(f);
3282    }
[281]3283  }else{
[492]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;
[281]3287  }
[344]3288  if(fsize==0){
[471]3289    return errorException(*m, _("Unable to download the file."), "InternalError",NULL);
[344]3290  }
[446]3291  if(mimeType!=NULL){
[471]3292    addToMap(*content,"fmimeType",mimeType);
[446]3293  }
3294
[282]3295  map* tmpMap=getMapOrFill(content,"value","");
[360]3296   
[281]3297  free(tmpMap->value);
3298  tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
[379]3299  if(tmpMap->value==NULL)
[478]3300    return errorException(*m, _("Unable to allocate memory."), "InternalError",NULL);
[392]3301  memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
[379]3302 
[281]3303  char ltmp1[256];
3304  sprintf(ltmp1,"%d",fsize);
[471]3305  addToMap(*content,"size",ltmp1);
[281]3306  if(cached==NULL)
[471]3307    addToCache(*m,url,fcontent,mimeType,fsize);
[492]3308  else
3309    addToMap(*content,"isCached","true");
[490]3310  free(fcontent);
3311  free(mimeType);
3312  free(cached);
[364]3313  return 0;
[281]3314}
3315
[459]3316int errorException(maps *m, const char *message, const char *errorcode, const char *locator) 
[284]3317{
3318  map* errormap = createMap("text", message);
3319  addToMap(errormap,"code", errorcode);
[459]3320  if(locator!=NULL)
3321    addToMap(errormap,"locator", locator);
3322  else
3323    addToMap(errormap,"locator", "NULL");
[284]3324  printExceptionReportResponse(m,errormap);
3325  freeMap(&errormap);
3326  free(errormap);
3327  return -1;
3328}
[469]3329
[490]3330
[469]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));
[490]3343    VSIFReadL(res1,1,file_status.st_size*sizeof(char),fichier);
3344    res1[file_status.st_size-1]=0;
[469]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);
[470]3365    free(test);
[469]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);
[503]3375    if(tmp00!=NULL)
3376      sprintf(buffer,"%s/%s",tmp0,tmp00->value);
[469]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);
[505]3383        tmp01[strlen(tmp01)-1]=0;
[469]3384        setMapInMaps(conf,"lenv","metapath",tmp01);
3385        free(tmp01);
[503]3386        tmp01=NULL;
[469]3387      }
3388      else{
[503]3389        if(tmp00!=NULL && tmpMap!=NULL){
[505]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);
[503]3394          setMapInMaps(conf,"lenv","metapath",value);
3395          free(value);
[505]3396          free(tmp00s);
[503]3397          value=NULL;
3398        }
[469]3399      }
3400    }else{
[470]3401      char *tmp01=zStrdup(tmp00->value);
3402      tmp01[strlen(tmp01)-1]=0;
3403      setMapInMaps(conf,"lenv","Identifier",tmp01);
3404      free(tmp01);
[469]3405    }
3406  }
3407  char *tmp0=zStrdup(buffer);
3408  sprintf(buffer,"%s.zcfg",tmp0);
3409  free(tmp0);
3410}
3411
[471]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);
[490]3444    sprintf(size,"%lu",numberOfBytes);
[471]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