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

Last change on this file since 481 was 481, checked in by djay, 10 years ago

Fix ExceptionReport? nodes

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