source: trunk/zoo-kernel/service_internal.c @ 255

Last change on this file since 255 was 255, checked in by djay, 11 years ago

Bug fix in shared memory gesture. Add test.sh shell script to run tests for the utils/status services (both longProcess and GetStatus?).

File size: 62.2 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 * Copyright (c) 2009-2011 GeoLabs SARL
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#include "service_internal.h"
26
27#ifdef WIN32
28char *
29strtok_r (char *s1, const char *s2, char **lasts)
30{
31  char *ret;
32  if (s1 == NULL)
33    s1 = *lasts;
34  while (*s1 && strchr(s2, *s1))
35    ++s1;
36  if (*s1 == '\0')
37    return NULL;
38  ret = s1;
39  while (*s1 && !strchr(s2, *s1))
40    ++s1;
41  if (*s1)
42    *s1++ = '\0';
43  *lasts = s1;
44  return ret;
45}
46#endif
47
48void addLangAttr(xmlNodePtr n,maps *m){
49  map *tmpLmap=getMapFromMaps(m,"main","language");
50  if(tmpLmap!=NULL)
51    xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST tmpLmap->value);
52  else
53    xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en-US");
54}
55
56/* Converts a hex character to its integer value */
57char from_hex(char ch) {
58  return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
59}
60
61/* Converts an integer value to its hex character*/
62char to_hex(char code) {
63  static char hex[] = "0123456789abcdef";
64  return hex[code & 15];
65}
66
67#ifdef WIN32
68
69#include <windows.h>
70#include <stdio.h>
71#include <conio.h>
72#include <tchar.h>
73
74#define SHMEMSIZE 4096
75
76static LPVOID lpvMemG = NULL;      // pointer to shared memory
77static HANDLE hMapObjectG = NULL;  // handle to file mapping
78
79void updateStatus(maps *conf){
80        fprintf(stderr,"OK Final 1 \n");
81        fflush(stderr);
82        LPWSTR lpszTmp;
83        BOOL fInit;
84        char *s=NULL;
85        map *tmpMap=getMapFromMaps(conf,"lenv","sid");
86        fprintf(stderr,"OK Final 11 \n");
87        fflush(stderr);
88        if(hMapObjectG==NULL)
89        hMapObjectG = CreateFileMapping( 
90                INVALID_HANDLE_VALUE,   // use paging file
91                NULL,                   // default security attributes
92                PAGE_READWRITE,         // read/write access
93                0,                      // size: high 32-bits
94                SHMEMSIZE,              // size: low 32-bits
95                TEXT(tmpMap->value));   // name of map object
96        if (hMapObjectG == NULL){
97                fprintf(stderr,"Unable to create share memory segment %s !! \n",tmpMap->value);
98                return ;
99        }
100        fprintf(stderr,"OK Final 2 \n");
101        fflush(stderr);
102        fInit = (GetLastError() != ERROR_ALREADY_EXISTS); 
103        if(lpvMemG==NULL)
104        lpvMemG = MapViewOfFile( 
105                hMapObjectG,     // object to map view of
106                FILE_MAP_WRITE, // read/write access
107                0,              // high offset:  map from
108                0,              // low offset:   beginning
109                0);             // default: map entire file
110        if (lpvMemG == NULL){
111                fprintf(stderr,"Unable to create or access the shared memory segment %s !! \n",tmpMap->value);
112                return ;
113        } 
114        fprintf(stderr,"OK Final 3 \n");
115        fflush(stderr);
116        if (fInit)
117                memset(lpvMemG, '\0', SHMEMSIZE);
118        fprintf(stderr,"OK Final 4 \n");
119        fflush(stderr);
120        tmpMap=getMapFromMaps(conf,"lenv","status");
121        lpszTmp = (LPWSTR) lpvMemG;
122        for(s=tmpMap->value;*s!=NULL;s++)
123                *lpszTmp++ = *s;
124        *lpszTmp = '\0'; 
125}
126
127char* getStatus(int pid){
128  LPWSTR lpszBuf=NULL;
129  LPWSTR lpszTmp=NULL;
130  LPVOID lpvMem = NULL;
131  HANDLE hMapObject = NULL;
132  BOOL fIgnore,fInit;
133  char tmp[100];
134  sprintf(tmp,"%i",pid);
135  if(hMapObject==NULL)
136    hMapObject = CreateFileMapping( 
137                                   INVALID_HANDLE_VALUE,   // use paging file
138                                   NULL,                   // default security attributes
139                                   PAGE_READWRITE,         // read/write access
140                                   0,                      // size: high 32-bits
141                                   4096,                   // size: low 32-bits
142                                   TEXT(tmp));   // name of map object
143  if (hMapObject == NULL) 
144    return FALSE;
145  if((GetLastError() != ERROR_ALREADY_EXISTS)){
146    fIgnore = UnmapViewOfFile(lpvMem); 
147    fIgnore = CloseHandle(hMapObject);
148    return "-1";
149  }
150  fInit=TRUE;
151  if(lpvMem==NULL)
152    lpvMem = MapViewOfFile( 
153                           hMapObject,     // object to map view of
154                           FILE_MAP_READ,  // read/write access
155                           0,              // high offset:  map from
156                           0,              // low offset:   beginning
157                           0);             // default: map entire file
158  if (lpvMem == NULL) 
159    return "-1"; 
160  lpszTmp = (LPWSTR) lpvMem;
161  while (*lpszTmp!=NULL)
162    *lpszBuf++ = *lpszTmp++;
163  *lpszBuf = '\0';
164  fIgnore = UnmapViewOfFile(lpvMem); 
165  fIgnore = CloseHandle(hMapObject);
166  return (char*)lpszBuf;
167}
168
169void unhandleStatus(maps *conf){
170  BOOL fIgnore;
171  fIgnore = UnmapViewOfFile(lpvMemG); 
172  fIgnore = CloseHandle(hMapObjectG);
173}
174#else
175
176void unhandleStatus(maps *conf){
177  int shmid,i;
178  key_t key;
179  void *shm;
180  struct shmid_ds shmids;
181  char *s,*s1;
182  map *tmpMap=getMapFromMaps(conf,"lenv","sid");
183  if(tmpMap!=NULL){
184    key=atoi(tmpMap->value);
185    if ((shmid = shmget(key, SHMSZ, IPC_CREAT | 0666)) < 0) {
186#ifdef DEBUG
187      fprintf(stderr,"shmget failed to update value\n");
188#endif
189    }else{
190      if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
191#ifdef DEBUG
192        fprintf(stderr,"shmat failed to update value\n");
193#endif
194      }else{
195        shmdt(shm);
196        shmctl(shmid,IPC_RMID,&shmids);
197      }
198    }
199  }
200}
201
202void updateStatus(maps *conf){
203  int shmid,i;
204  key_t key;
205  char *shm,*s,*s1;
206  map *tmpMap=NULL;
207  tmpMap=getMapFromMaps(conf,"lenv","sid");
208  if(tmpMap!=NULL){
209    key=atoi(tmpMap->value);
210    if ((shmid = shmget(key, SHMSZ, IPC_CREAT | 0666)) < 0) {
211#ifdef DEBUG
212      fprintf(stderr,"shmget failed to create new Shared memory segment\n");
213#endif
214    }else{
215      if ((shm = (char*) shmat(shmid, NULL, 0)) == (char *) -1) {
216#ifdef DEBUG
217        fprintf(stderr,"shmat failed to update value\n");
218#endif
219      }
220      else{
221        tmpMap=getMapFromMaps(conf,"lenv","status");
222        s1=shm;
223        for(s=tmpMap->value;*s!=NULL && *s!=0;s++){
224          *s1++=*s;
225        }
226        *s1=NULL;
227        shmdt((void *)shm);
228      }
229    }
230  }
231}
232
233char* getStatus(int pid){
234  int shmid,i;
235  key_t key;
236  void *shm;
237  char *s;
238  key=pid;
239  if ((shmid = shmget(key, SHMSZ, 0666)) < 0) {
240#ifdef DEBUG
241    fprintf(stderr,"shmget failed in getStatus\n");
242#endif
243  }else{
244    if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
245#ifdef DEBUG
246      fprintf(stderr,"shmat failed in getStatus\n");
247#endif
248    }else{
249      return (char*)shm;
250    }
251  }
252  return "-1";
253}
254
255#endif
256
257#ifdef USE_JS
258
259JSBool
260JSUpdateStatus(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
261{
262  JS_MaybeGC(cx);
263  char *sid;
264  int istatus=0;
265  char *status=NULL;
266  maps *conf;
267  int i=0;
268  if(argc>2){
269#ifdef JS_DEBUG
270    fprintf(stderr,"Number of arguments used to call the function : %i",argc);
271#endif
272    return JS_FALSE;
273  }
274  conf=mapsFromJSObject(cx,argv[0]);
275  if(JS_ValueToInt32(cx,argv[1],&istatus)==JS_TRUE){
276    char tmpStatus[4];
277    sprintf(tmpStatus,"%i",istatus);
278    tmpStatus[3]=0;
279    status=strdup(tmpStatus);
280  }
281  if(getMapFromMaps(conf,"lenv","status")!=NULL){
282    if(status!=NULL)
283      setMapInMaps(conf,"lenv","status",status);
284    else
285      setMapInMaps(conf,"lenv","status","15");
286    updateStatus(conf);
287  }
288  freeMaps(&conf);
289  free(conf);
290  JS_MaybeGC(cx);
291  return JS_TRUE;
292}
293
294#endif
295
296
297
298/* Returns a url-encoded version of str */
299/* IMPORTANT: be sure to free() the returned string after use */
300char *url_encode(char *str) {
301  char *pstr = str, *buf = (char*) malloc(strlen(str) * 3 + 1), *pbuf = buf;
302  while (*pstr) {
303    if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~') 
304      *pbuf++ = *pstr;
305    else if (*pstr == ' ') 
306      *pbuf++ = '+';
307    else 
308      *pbuf++ = '%', *pbuf++ = to_hex(*pstr >> 4), *pbuf++ = to_hex(*pstr & 15);
309    pstr++;
310  }
311  *pbuf = '\0';
312  return buf;
313}
314
315/* Returns a url-decoded version of str */
316/* IMPORTANT: be sure to free() the returned string after use */
317char *url_decode(char *str) {
318  char *pstr = str, *buf = (char*) malloc(strlen(str) + 1), *pbuf = buf;
319  while (*pstr) {
320    if (*pstr == '%') {
321      if (pstr[1] && pstr[2]) {
322        *pbuf++ = from_hex(pstr[1]) << 4 | from_hex(pstr[2]);
323        pstr += 2;
324      }
325    } else if (*pstr == '+') { 
326      *pbuf++ = ' ';
327    } else {
328      *pbuf++ = *pstr;
329    }
330    pstr++;
331  }
332  *pbuf = '\0';
333  return buf;
334}
335
336char *zCapitalize1(char *tmp){
337        char *res=strdup(tmp);
338        if(res[0]>=97 && res[0]<=122)
339                res[0]-=32;
340        return res;
341}
342
343char *zCapitalize(char *tmp){
344  int i=0;
345  char *res=strdup(tmp);
346  for(i=0;i<strlen(res);i++)
347    if(res[i]>=97 && res[i]<=122)
348      res[i]-=32;
349  return res;
350}
351
352
353int zooXmlSearchForNs(const char* name){
354  int i;
355  int res=-1;
356  for(i=0;i<nbNs;i++)
357    if(strncasecmp(name,nsName[i],strlen(nsName[i]))==0){
358      res=i;
359      break;
360    }
361  return res;
362}
363
364int zooXmlAddNs(xmlNodePtr nr,const char* url,const char* name){
365#ifdef DEBUG
366  fprintf(stderr,"zooXmlAddNs %d \n",nbNs);
367#endif
368  int currId=-1;
369  if(nbNs==0){
370    nbNs++;
371    currId=0;
372    nsName[currId]=strdup(name);
373    usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
374  }else{
375    currId=zooXmlSearchForNs(name);
376    if(currId<0){
377      nbNs++;
378      currId=nbNs-1;
379      nsName[currId]=strdup(name);
380      usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
381    }
382  }
383  return currId;
384}
385
386void zooXmlCleanupNs(){
387  int j;
388#ifdef DEBUG
389  fprintf(stderr,"zooXmlCleanup %d\n",nbNs);
390#endif
391  for(j=nbNs-1;j>=0;j--){
392#ifdef DEBUG
393    fprintf(stderr,"zooXmlCleanup %d\n",j);
394#endif
395    if(j==0)
396      xmlFreeNs(usedNs[j]);
397    free(nsName[j]);
398    nbNs--;
399  }
400  nbNs=0;
401}
402
403xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr doc,const char* service,maps* m){
404
405  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
406  xmlNodePtr n,nc,nc1,nc2,nc3,nc4,nc5,nc6,pseudor;
407  xmlChar *xmlbuff;
408  int buffersize;
409  /**
410   * Create the document and its temporary root.
411   */
412  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
413  ns=usedNs[wpsId];
414  maps* toto1=getMaps(m,"main");
415
416  n = xmlNewNode(ns, BAD_CAST "Capabilities");
417  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
418  ns_ows=usedNs[owsId];
419  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
420  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
421  ns_xsi=usedNs[xsiId];
422  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
423  ns_xlink=usedNs[xlinkId];
424  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"); 
425  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
426  addLangAttr(n,m);
427 
428  if(toto1!=NULL){
429    map* tmp=getMap(toto1->content,"version");
430    if(tmp!=NULL){
431      xmlNewProp(n,BAD_CAST "version",BAD_CAST tmp->value);
432    }
433    else
434      xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
435  }
436  else
437    xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
438
439  char tmp[256];
440 
441  nc = xmlNewNode(ns_ows, BAD_CAST "ServiceIdentification");
442  maps* tmp4=getMaps(m,"identification");
443  if(tmp4!=NULL){
444    map* tmp2=tmp4->content;
445    char *orderedFields[5];
446    orderedFields[0]="Title";
447    orderedFields[1]="Abstract";
448    orderedFields[2]="Keywords";
449    orderedFields[3]="Fees";
450    orderedFields[4]="AccessConstraints";
451    int oI=0;
452    for(oI=0;oI<5;oI++)
453      if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
454        if(strcasecmp(tmp2->name,"abstract")==0 ||
455           strcasecmp(tmp2->name,"title")==0 ||
456           strcasecmp(tmp2->name,"accessConstraints")==0 ||
457           strcasecmp(tmp2->name,"fees")==0){
458          tmp2->name[0]=toupper(tmp2->name[0]);
459          nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
460          xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
461          xmlAddChild(nc,nc1);
462        }
463        else
464          if(strcmp(tmp2->name,"keywords")==0){
465            nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
466            char *toto=tmp2->value;
467            char buff[256];
468            int i=0;
469            int j=0;
470            while(toto[i]){
471              if(toto[i]!=',' && toto[i]!=0){
472                buff[j]=toto[i];
473                buff[j+1]=0;
474                j++;
475              }
476              else{
477                nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
478                xmlAddChild(nc2,xmlNewText(BAD_CAST buff));           
479                xmlAddChild(nc1,nc2);
480                j=0;
481              }
482              i++;
483            }
484            if(strlen(buff)>0){
485              nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
486              xmlAddChild(nc2,xmlNewText(BAD_CAST buff));             
487              xmlAddChild(nc1,nc2);
488            }
489            xmlAddChild(nc,nc1);
490            nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceType");
491            xmlAddChild(nc2,xmlNewText(BAD_CAST "WPS"));
492            xmlAddChild(nc,nc2);
493            nc2 = xmlNewNode(ns_ows, BAD_CAST "ServiceTypeVersion");
494            xmlAddChild(nc2,xmlNewText(BAD_CAST "1.0.0"));
495            xmlAddChild(nc,nc2);         
496          }
497        tmp2=tmp2->next;
498      }
499  }
500  else{
501    fprintf(stderr,"TMP4 NOT FOUND !!");
502    return NULL;
503  }
504  xmlAddChild(n,nc);
505
506  nc = xmlNewNode(ns_ows, BAD_CAST "ServiceProvider");
507  nc3 = xmlNewNode(ns_ows, BAD_CAST "ServiceContact");
508  nc4 = xmlNewNode(ns_ows, BAD_CAST "ContactInfo");
509  nc5 = xmlNewNode(ns_ows, BAD_CAST "Phone");
510  nc6 = xmlNewNode(ns_ows, BAD_CAST "Address");
511  tmp4=getMaps(m,"provider");
512  if(tmp4!=NULL){
513    map* tmp2=tmp4->content;
514    char *tmpAddress[6];
515    tmpAddress[0]="addressDeliveryPoint";
516    tmpAddress[1]="addressCity";
517    tmpAddress[2]="addressAdministrativeArea";
518    tmpAddress[3]="addressPostalCode";
519    tmpAddress[4]="addressCountry";
520    tmpAddress[5]="addressElectronicMailAddress";
521    char *tmpPhone[2];
522    tmpPhone[0]="phoneVoice";
523    tmpPhone[1]="phoneFacsimile";
524    char *orderedFields[12];
525    orderedFields[0]="providerName";
526    orderedFields[1]="providerSite";
527    orderedFields[2]="individualName";
528    orderedFields[3]="positionName";
529    orderedFields[4]=tmpPhone[0];
530    orderedFields[5]=tmpPhone[1];
531    orderedFields[6]=tmpAddress[0];
532    orderedFields[7]=tmpAddress[1];
533    orderedFields[8]=tmpAddress[2];
534    orderedFields[9]=tmpAddress[3];
535    orderedFields[10]=tmpAddress[4];
536    orderedFields[11]=tmpAddress[5];
537    int oI=0;
538    for(oI=0;oI<12;oI++)
539      if((tmp2=getMap(tmp4->content,orderedFields[oI]))!=NULL){
540        if(strcmp(tmp2->name,"keywords")!=0 &&
541           strcmp(tmp2->name,"serverAddress")!=0 &&
542           strcmp(tmp2->name,"lang")!=0){
543          tmp2->name[0]=toupper(tmp2->name[0]);
544          if(strcmp(tmp2->name,"ProviderName")==0){
545            nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
546            xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
547            xmlAddChild(nc,nc1);
548          }
549          else{
550            if(strcmp(tmp2->name,"ProviderSite")==0){
551              nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
552              xmlNewNsProp(nc1,ns_xlink,BAD_CAST "href",BAD_CAST tmp2->value);
553              xmlAddChild(nc,nc1);
554            } 
555            else 
556              if(strcmp(tmp2->name,"IndividualName")==0 || 
557                 strcmp(tmp2->name,"PositionName")==0){
558                nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
559                xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
560                xmlAddChild(nc3,nc1);
561              } 
562              else 
563                if(strncmp(tmp2->name,"Phone",5)==0){
564                  int j;
565                  for(j=0;j<2;j++)
566                    if(strcasecmp(tmp2->name,tmpPhone[j])==0){
567                      char *toto=NULL;
568                      char *toto1=tmp2->name;
569                      toto=strstr(toto1,"Phone");
570                      nc1 = xmlNewNode(ns_ows, BAD_CAST toto1+5);
571                      xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
572                      xmlAddChild(nc5,nc1);
573                    }
574                }
575                else 
576                  if(strncmp(tmp2->name,"Address",7)==0){
577                    int j;
578                    for(j=0;j<6;j++)
579                      if(strcasecmp(tmp2->name,tmpAddress[j])==0){
580                        char *toto=NULL;
581                        char *toto1=tmp2->name;
582                        toto=strstr(toto1,"Address");
583                        nc1 = xmlNewNode(ns_ows, BAD_CAST toto1+7);
584                        xmlAddChild(nc1,xmlNewText(BAD_CAST tmp2->value));
585                        xmlAddChild(nc6,nc1);
586                      }
587                  }
588          }
589        }
590        else
591          if(strcmp(tmp2->name,"keywords")==0){
592            nc1 = xmlNewNode(ns_ows, BAD_CAST "Keywords");
593            char *toto=tmp2->value;
594            char buff[256];
595            int i=0;
596            int j=0;
597            while(toto[i]){
598              if(toto[i]!=',' && toto[i]!=0){
599                buff[j]=toto[i];
600                buff[j+1]=0;
601                j++;
602              }
603              else{
604                nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
605                xmlAddChild(nc2,xmlNewText(BAD_CAST buff));           
606                xmlAddChild(nc1,nc2);
607                j=0;
608              }
609              i++;
610            }
611            if(strlen(buff)>0){
612              nc2 = xmlNewNode(ns_ows, BAD_CAST "Keyword");
613              xmlAddChild(nc2,xmlNewText(BAD_CAST buff));             
614              xmlAddChild(nc1,nc2);
615            }
616            xmlAddChild(nc,nc1);
617          }
618        tmp2=tmp2->next;
619      }
620  }
621  else{
622    fprintf(stderr,"TMP4 NOT FOUND !!");
623  }
624  xmlAddChild(nc4,nc5);
625  xmlAddChild(nc4,nc6);
626  xmlAddChild(nc3,nc4);
627  xmlAddChild(nc,nc3);
628  xmlAddChild(n,nc);
629
630
631  nc = xmlNewNode(ns_ows, BAD_CAST "OperationsMetadata");
632  char *tmp2[3];
633  tmp2[0]=strdup("GetCapabilities");
634  tmp2[1]=strdup("DescribeProcess");
635  tmp2[2]=strdup("Execute");
636  int j=0;
637
638  if(toto1!=NULL){
639    map* tmp=getMap(toto1->content,"serverAddress");
640    if(tmp!=NULL){
641      SERVICE_URL = strdup(tmp->value);
642    }
643    else
644      SERVICE_URL = strdup("not_found");
645  }
646  else
647    SERVICE_URL = strdup("not_found");
648
649  for(j=0;j<3;j++){
650    nc1 = xmlNewNode(ns_ows, BAD_CAST "Operation");
651    xmlNewProp(nc1,BAD_CAST "name",BAD_CAST tmp2[j]);
652    nc2 = xmlNewNode(ns_ows, BAD_CAST "DCP");
653    nc3 = xmlNewNode(ns_ows, BAD_CAST "HTTP");
654    nc4 = xmlNewNode(ns_ows, BAD_CAST "Get");
655    sprintf(tmp,"%s/%s",SERVICE_URL,service);
656    xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
657    xmlAddChild(nc3,nc4);
658    if(j>0){
659      nc4 = xmlNewNode(ns_ows, BAD_CAST "Post");
660      xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
661      xmlAddChild(nc3,nc4);
662    }
663    xmlAddChild(nc2,nc3);
664    xmlAddChild(nc1,nc2);   
665    xmlAddChild(nc,nc1);   
666  }
667  for(j=2;j>=0;j--)
668    free(tmp2[j]);
669  xmlAddChild(n,nc);
670
671  nc = xmlNewNode(ns, BAD_CAST "ProcessOfferings");
672  xmlAddChild(n,nc);
673
674  nc1 = xmlNewNode(ns, BAD_CAST "Languages");
675  nc2 = xmlNewNode(ns, BAD_CAST "Default");
676  nc3 = xmlNewNode(ns, BAD_CAST "Supported");
677 
678  toto1=getMaps(m,"main");
679  if(toto1!=NULL){
680    map* tmp1=getMap(toto1->content,"lang");
681    char *toto=tmp1->value;
682    char buff[256];
683    int i=0;
684    int j=0;
685    int dcount=0;
686    while(toto[i]){
687      if(toto[i]!=',' && toto[i]!=0){
688        buff[j]=toto[i];
689        buff[j+1]=0;
690        j++;
691      }
692      else{
693        nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
694        xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
695        if(dcount==0){
696          xmlAddChild(nc2,nc4);
697          xmlAddChild(nc1,nc2);
698          dcount++;
699        }
700        nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
701        xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
702        xmlAddChild(nc3,nc4);
703        j=0;
704        buff[j]=0;
705      }
706      i++;
707    }
708    if(strlen(buff)>0){
709      nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
710      xmlAddChild(nc4,xmlNewText(BAD_CAST buff));             
711      xmlAddChild(nc3,nc4);
712    }
713  }
714  xmlAddChild(nc1,nc3);
715  xmlAddChild(n,nc1);
716 
717  xmlDocSetRootElement(doc, n);
718  //xmlFreeNs(ns);
719  free(SERVICE_URL);
720  return nc;
721}
722
723void printGetCapabilitiesForProcess(maps* m,xmlNodePtr nc,service* serv){
724  xmlNsPtr ns,ns_ows,ns_xlink;
725  xmlNodePtr nr,n,nc1,nc2,nc3,nc4,nc5,nc6,pseudor;
726  /**
727   * Initialize or get existing namspaces
728   */
729  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
730  ns=usedNs[wpsId];
731  int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
732  ns_ows=usedNs[owsId];
733  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
734  ns_xlink=usedNs[xlinkId];
735
736  int cursor=0;
737  map* tmp1;
738  if(serv->content!=NULL){
739    nc1 = xmlNewNode(ns, BAD_CAST "Process");
740    tmp1=getMap(serv->content,"processVersion");
741    if(tmp1!=NULL)
742      xmlNewNsProp(nc1,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
743    printDescription(nc1,ns_ows,serv->name,serv->content);
744    tmp1=serv->metadata;
745    while(tmp1!=NULL){
746      nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
747      xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
748      xmlAddChild(nc1,nc2);
749      tmp1=tmp1->next;
750    }
751    xmlAddChild(nc,nc1);
752  }
753}
754
755xmlNodePtr printDescribeProcessHeader(xmlDocPtr doc,const char* service,maps* m){
756
757  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
758  xmlNodePtr n,nr;
759  xmlChar *xmlbuff;
760  int buffersize;
761
762  int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
763  ns=usedNs[wpsId];
764  n = xmlNewNode(ns, BAD_CAST "ProcessDescriptions");
765  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
766  ns_ows=usedNs[owsId];
767  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
768  zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
769  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
770  ns_xsi=usedNs[xsiId];
771 
772  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");
773  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
774  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
775  addLangAttr(n,m);
776
777  xmlDocSetRootElement(doc, n);
778
779  return n;
780}
781
782void printDescribeProcessForProcess(maps* m,xmlNodePtr nc,service* serv,int sc){
783  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
784  xmlNodePtr nr,n,nc1,nc2,nc3,nc4,nc5,nc6,pseudor;
785
786  char tmp[256];
787  n=nc;
788 
789  int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
790  ns=usedNs[wpsId];
791  int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
792  ns_ows=usedNs[owsId];
793  int xlinkId=zooXmlAddNs(NULL,"http://www.w3.org/1999/xlink","xlink");
794  ns_xlink=usedNs[xlinkId];
795
796  nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
797  char *tmp4[3];
798  tmp4[0]="processVersion";
799  tmp4[1]="storeSupported";
800  tmp4[2]="statusSupported";
801  int j=0;
802  map* tmp1=NULL;
803  for(j=0;j<3;j++){
804    tmp1=getMap(serv->content,tmp4[j]);
805    if(tmp1!=NULL){
806      if(j==0)
807        xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);     
808      else
809        xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST tmp1->value);     
810    }
811    else{
812      if(j>0)
813        xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST "false");     
814    }
815  }
816 
817  printDescription(nc,ns_ows,serv->name,serv->content);
818
819  tmp1=serv->metadata;
820  while(tmp1!=NULL){
821    nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
822    xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
823    xmlAddChild(nc,nc1);
824    tmp1=tmp1->next;
825  }
826
827  tmp1=getMap(serv->content,"Profile");
828  if(tmp1!=NULL){
829    nc1 = xmlNewNode(ns, BAD_CAST "Profile");
830    xmlAddChild(nc1,xmlNewText(BAD_CAST tmp1->value));
831    xmlAddChild(nc,nc1);
832  }
833
834  nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
835  elements* e=serv->inputs;
836  printFullDescription(e,"Input",ns_ows,nc1);
837  xmlAddChild(nc,nc1);
838
839  nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
840  e=serv->outputs;
841  printFullDescription(e,"Output",ns_ows,nc1);
842  xmlAddChild(nc,nc1);
843
844  xmlAddChild(n,nc);
845
846}
847
848void printFullDescription(elements *elem,const char* type,xmlNsPtr ns_ows,xmlNodePtr nc1){
849  char *orderedFields[7];
850  orderedFields[0]="mimeType";
851  orderedFields[1]="encoding";
852  orderedFields[2]="schema";
853  orderedFields[3]="dataType";
854  orderedFields[4]="uom";
855  orderedFields[5]="CRS";
856  orderedFields[6]="value";
857
858  xmlNodePtr nc2,nc3,nc4,nc5,nc6,nc7;
859  elements* e=elem;
860  map* tmp1=NULL;
861  while(e!=NULL){
862    int default1=0;
863    int isAnyValue=1;
864    nc2 = xmlNewNode(NULL, BAD_CAST type);
865    tmp1=getMap(e->content,"minOccurs");
866    if(tmp1){
867      xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
868    }
869    tmp1=getMap(e->content,"maxOccurs");
870    if(tmp1){
871      xmlNewProp(nc2,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
872    }
873
874    printDescription(nc2,ns_ows,e->name,e->content);
875
876    if(strncmp(type,"Output",6)==0){
877      if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
878        nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
879      else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
880        nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
881      else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
882        nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
883      else
884        nc3 = xmlNewNode(NULL, BAD_CAST e->format);
885    }else{
886      if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0){
887        nc3 = xmlNewNode(NULL, BAD_CAST "LiteralData");
888      }
889      else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
890        nc3 = xmlNewNode(NULL, BAD_CAST "ComplexData");
891      else if(strncasecmp(e->format,"BOUNDINGBOXDATA",strlen(e->format))==0)
892        nc3 = xmlNewNode(NULL, BAD_CAST "BoundingBoxData");
893      else
894        nc3 = xmlNewNode(NULL, BAD_CAST e->format);
895    }
896    iotype* _tmp=e->defaults;
897    int datatype=0;
898    bool hasDefault=false;
899    bool hasUOM=false;
900    if(_tmp!=NULL){
901      if(strcmp(e->format,"LiteralOutput")==0 ||
902         strcmp(e->format,"LiteralData")==0){
903        datatype=1;
904        nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
905        nc5 = xmlNewNode(NULL, BAD_CAST "Default");
906      }
907      else if(strcmp(e->format,"BoundingBoxOutput")==0 ||
908              strcmp(e->format,"BoundingBoxData")==0){
909        datatype=2;
910        //nc4 = xmlNewNode(NULL, BAD_CAST "BoundingBoxOutput");
911        nc5 = xmlNewNode(NULL, BAD_CAST "Default");
912      }
913      else{
914        nc4 = xmlNewNode(NULL, BAD_CAST "Default");
915        nc5 = xmlNewNode(NULL, BAD_CAST "Format");
916      }
917     
918      tmp1=_tmp->content;
919      int avcnt=0;
920      int dcnt=0;
921      int oI=0;
922      for(oI=0;oI<7;oI++)
923        if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
924          //while(tmp1!=NULL){
925#ifdef DEBUG
926          printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
927#endif
928          if(strncasecmp(tmp1->name,"DataType",8)==0){
929            nc6 = xmlNewNode(ns_ows, BAD_CAST "DataType");
930            xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
931            char tmp[1024];
932            sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
933            xmlNewNsProp(nc6,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
934            xmlAddChild(nc3,nc6);
935            tmp1=tmp1->next;
936            datatype=1;
937            continue;
938          }
939          if(strcmp(tmp1->name,"asReference")!=0 &&
940             strncasecmp(tmp1->name,"DataType",8)!=0 &&
941             strcasecmp(tmp1->name,"extension")!=0 &&
942             strcasecmp(tmp1->name,"value")!=0 &&
943             strncasecmp(tmp1->name,"AllowedValues",13)!=0){
944            if(datatype!=1){
945              char *tmp2=zCapitalize1(tmp1->name);
946              nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
947              free(tmp2);
948            }
949            else{
950              char *tmp2=zCapitalize(tmp1->name);
951              nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
952              free(tmp2);
953            }
954            xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
955            xmlAddChild(nc5,nc6);
956            hasUOM=true;
957          }else 
958            if(strncmp(type,"Input",5)==0){
959              if(strcmp(tmp1->name,"value")==0){
960                nc7 = xmlNewNode(NULL, BAD_CAST "DefaultValue");
961                xmlAddChild(nc7,xmlNewText(BAD_CAST tmp1->value));
962                default1=1;
963              }
964              if(strncasecmp(tmp1->name,"AllowedValues",13)==0){
965                nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
966                fprintf(stderr,"ALLOWED VALUE %s\n",tmp1->value);
967                char *token,*saveptr1;
968                token=strtok_r(tmp1->value,",",&saveptr1);
969                while(token!=NULL){
970                  nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
971                  char *tmps=strdup(token);
972                  tmps[strlen(tmps)]=0;
973                  xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
974                  fprintf(stderr,"strgin : %s\n",tmps);
975                  xmlAddChild(nc6,nc7);
976                  token=strtok_r(NULL,",",&saveptr1);
977                }
978                xmlAddChild(nc3,nc6);
979                isAnyValue=-1;
980              }
981              hasDefault=true;
982            }
983          tmp1=tmp1->next;
984          if(datatype!=2){
985            if(hasUOM==true){
986              xmlAddChild(nc4,nc5);
987              xmlAddChild(nc3,nc4);
988            }
989          }else{
990            xmlAddChild(nc3,nc5);
991          }
992         
993          if(strncmp(type,"Input",5)==0){
994            if(datatype==1 && isAnyValue==1 && avcnt==0){
995              xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
996              hasDefault=true;
997              avcnt++;
998            }
999            if(datatype==1 && default1>0){
1000              xmlAddChild(nc3,nc7);
1001            }
1002          }
1003        }
1004    }
1005    _tmp=e->supported;
1006    int hasSupported=-1;
1007    while(_tmp!=NULL){
1008      if(hasSupported<0){
1009        if(datatype==0){
1010          nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
1011          nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1012        }
1013        else
1014          nc5 = xmlNewNode(NULL, BAD_CAST "Supported");
1015        hasSupported=0;
1016      }else
1017        if(datatype==0)
1018          nc5 = xmlNewNode(NULL, BAD_CAST "Format");
1019      tmp1=_tmp->content;
1020      int oI=0;
1021      for(oI=0;oI<6;oI++)
1022        if((tmp1=getMap(_tmp->content,orderedFields[oI]))!=NULL){
1023#ifdef DEBUG
1024          printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
1025#endif
1026          if(strcmp(tmp1->name,"asReference")!=0 && 
1027             strcmp(tmp1->name,"DataType")!=0 &&
1028             strcasecmp(tmp1->name,"extension")!=0){
1029            if(datatype!=1){
1030              char *tmp2=zCapitalize1(tmp1->name);
1031              nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1032              free(tmp2);
1033            }
1034            else{
1035              char *tmp2=zCapitalize(tmp1->name);
1036              nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
1037              free(tmp2);
1038            }
1039            if(datatype==2){
1040              char *tmpv,*tmps;
1041              tmps=strtok_r(tmp1->value,",",&tmpv);
1042              while(tmps){
1043                xmlAddChild(nc6,xmlNewText(BAD_CAST tmps));
1044                xmlAddChild(nc5,nc6);
1045                tmps=strtok_r(NULL,",",&tmpv);
1046                if(tmps){
1047                  char *tmp2=zCapitalize1(tmp1->name);
1048                  nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
1049                  free(tmp2);
1050                }
1051              }
1052            }
1053            else{
1054              xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
1055              xmlAddChild(nc5,nc6);
1056            }
1057          }
1058          tmp1=tmp1->next;
1059        }
1060      if(hasSupported<=0){
1061        if(datatype!=2){
1062          xmlAddChild(nc4,nc5);
1063          xmlAddChild(nc3,nc4);
1064        }else
1065          xmlAddChild(nc3,nc5);
1066        hasSupported=1;
1067      }
1068      else
1069        if(datatype!=2){
1070          xmlAddChild(nc4,nc5);
1071        }
1072        else
1073          xmlAddChild(nc3,nc5);
1074      _tmp=_tmp->next;
1075    }
1076    xmlAddChild(nc2,nc3);
1077   
1078    if(datatype!=2 && hasUOM==true){
1079      xmlAddChild(nc3,nc4);
1080      xmlAddChild(nc2,nc3);
1081    }else if(datatype!=2){
1082      if(hasDefault!=true && strncmp(type,"Input",5)==0)
1083        xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
1084      xmlFreeNodeList(nc5);
1085      xmlFreeNodeList(nc4);
1086    }
1087   
1088    xmlAddChild(nc1,nc2);
1089   
1090    e=e->next;
1091  }
1092}
1093
1094void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
1095  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1096  xmlNodePtr nr,n,nc,nc1,nc2,nc3,pseudor;
1097  xmlDocPtr doc;
1098  xmlChar *xmlbuff;
1099  int buffersize;
1100  time_t time1; 
1101  time(&time1);
1102  /**
1103   * Create the document and its temporary root.
1104   */
1105  doc = xmlNewDoc(BAD_CAST "1.0");
1106  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
1107  ns=usedNs[wpsId];
1108 
1109  n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
1110  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
1111  ns_ows=usedNs[owsId];
1112  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1113  ns_xlink=usedNs[xlinkId];
1114  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1115  ns_xsi=usedNs[xsiId];
1116  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
1117
1118  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");
1119 
1120  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
1121  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
1122  addLangAttr(n,m);
1123
1124  char tmp[256];
1125  char url[1024];
1126  char stored_path[1024];
1127  memset(tmp,0,256);
1128  memset(url,0,1024);
1129  memset(stored_path,0,1024);
1130  maps* tmp_maps=getMaps(m,"main");
1131  if(tmp_maps!=NULL){
1132    map* tmpm1=getMap(tmp_maps->content,"serverAddress");
1133    /**
1134     * Check if the ZOO Service GetStatus is available in the local directory.
1135     * If yes, then it uses a reference to an URL which the client can access
1136     * to get information on the status of a running Service (using the
1137     * percentCompleted attribute).
1138     * Else fallback to the initial method using the xml file to write in ...
1139     */
1140    char ntmp[1024];
1141#ifndef WIN32
1142    getcwd(ntmp,1024);
1143#else
1144    _getcwd(ntmp,1024);
1145#endif
1146    struct stat myFileInfo;
1147    int statRes;
1148    char file_path[1024];
1149    sprintf(file_path,"%s/GetStatus.zcfg",ntmp);
1150    statRes=stat(file_path,&myFileInfo);
1151    if(statRes==0){
1152      char currentSid[128];
1153      map* tmpm=getMap(tmp_maps->content,"rewriteUrl");
1154      map *tmp_lenv=NULL;
1155      tmp_lenv=getMapFromMaps(m,"lenv","sid");
1156      if(tmp_lenv==NULL)
1157        sprintf(currentSid,"%i",pid);
1158      else
1159        sprintf(currentSid,"%s",tmp_lenv->value);
1160      if(tmpm==NULL || strcasecmp(tmpm->value,"false")==0){
1161        sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1162      }else{
1163        if(strlen(tmpm->value)>0)
1164          if(strcasecmp(tmpm->value,"true")!=0)
1165            sprintf(url,"%s/%s/GetStatus/%s",tmpm1->value,tmpm->value,currentSid);
1166          else
1167            sprintf(url,"%s/GetStatus/%s",tmpm1->value,currentSid);
1168        else
1169          sprintf(url,"%s/?request=Execute&service=WPS&version=1.0.0&Identifier=GetStatus&DataInputs=sid=%s&RawDataOutput=Result",tmpm1->value,currentSid);
1170      }
1171    }else{
1172      map* tmpm2=getMap(tmp_maps->content,"tmpUrl");
1173      if(tmpm1!=NULL && tmpm2!=NULL){
1174        sprintf(url,"%s/%s/%s_%i.xml",tmpm1->value,tmpm2->value,service,pid);
1175      }
1176    }
1177    if(tmpm1!=NULL)
1178      sprintf(tmp,"%s/",tmpm1->value);
1179    tmpm1=getMapFromMaps(m,"main","TmpPath");
1180    sprintf(stored_path,"%s/%s_%i.xml",tmpm1->value,service,pid);
1181  }
1182
1183 
1184
1185  xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
1186  map* test=getMap(request,"storeExecuteResponse");
1187  bool hasStoredExecuteResponse=false;
1188  if(test!=NULL && strcasecmp(test->value,"true")==0){
1189    xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
1190    hasStoredExecuteResponse=true;
1191  }
1192
1193  nc = xmlNewNode(ns, BAD_CAST "Process");
1194  map* tmp2=getMap(serv->content,"processVersion");
1195
1196  if(tmp2!=NULL)
1197    xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp2->value);
1198 
1199  printDescription(nc,ns_ows,serv->name,serv->content);
1200  fflush(stderr);
1201
1202  xmlAddChild(n,nc);
1203
1204  nc = xmlNewNode(ns, BAD_CAST "Status");
1205  const struct tm *tm;
1206  size_t len;
1207  time_t now;
1208  char *tmp1;
1209  map *tmpStatus;
1210 
1211  now = time ( NULL );
1212  tm = localtime ( &now );
1213
1214  tmp1 = (char*)malloc((TIME_SIZE+1)*sizeof(char));
1215
1216  len = strftime ( tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm );
1217
1218  xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
1219
1220  char sMsg[2048];
1221  switch(status){
1222  case SERVICE_SUCCEEDED:
1223    nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
1224    sprintf(sMsg,_("Service \"%s\" run successfully."),serv->name);
1225    nc3=xmlNewText(BAD_CAST sMsg);
1226    xmlAddChild(nc1,nc3);
1227    break;
1228  case SERVICE_STARTED:
1229    nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
1230    tmpStatus=getMapFromMaps(m,"lenv","status");
1231    xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST tmpStatus->value);
1232    sprintf(sMsg,_("ZOO Service \"%s\" is currently running. Please, reload this document to get the up-to-date status of the Service."),serv->name);
1233    nc3=xmlNewText(BAD_CAST sMsg);
1234    xmlAddChild(nc1,nc3);
1235    break;
1236  case SERVICE_ACCEPTED:
1237    nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
1238    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);
1239    nc3=xmlNewText(BAD_CAST sMsg);
1240    xmlAddChild(nc1,nc3);
1241    break;
1242  case SERVICE_FAILED:
1243    nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
1244    map *errorMap;
1245    map *te;
1246    te=getMapFromMaps(m,"lenv","code");
1247    if(te!=NULL)
1248      errorMap=createMap("code",te->value);
1249    else
1250      errorMap=createMap("code","NoApplicableCode");
1251    te=getMapFromMaps(m,"lenv","message");
1252    if(te!=NULL)
1253      addToMap(errorMap,"text",_ss(te->value));
1254    else
1255      addToMap(errorMap,"text",_("No more information available"));
1256    nc3=createExceptionReportNode(m,errorMap,0);
1257    freeMap(&errorMap);
1258    free(errorMap);
1259    xmlAddChild(nc1,nc3);
1260    break;
1261  default :
1262    printf(_("error code not know : %i\n"),status);
1263    //exit(1);
1264    break;
1265  }
1266  xmlAddChild(nc,nc1);
1267  xmlAddChild(n,nc);
1268  free(tmp1);
1269
1270#ifdef DEBUG
1271  fprintf(stderr,"printProcessResponse 1 161\n");
1272#endif
1273
1274  map* lineage=getMap(request,"lineage");
1275  if(lineage!=NULL && strcasecmp(lineage->value,"true")==0){
1276    nc = xmlNewNode(ns, BAD_CAST "DataInputs");
1277    int i;
1278    maps* mcursor=inputs;
1279    elements* scursor=NULL;
1280    while(mcursor!=NULL /*&& scursor!=NULL*/){
1281      scursor=getElements(serv->inputs,mcursor->name);
1282      printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Input");
1283      mcursor=mcursor->next;
1284    }
1285    xmlAddChild(n,nc);
1286   
1287#ifdef DEBUG
1288    fprintf(stderr,"printProcessResponse 1 177\n");
1289#endif
1290
1291    nc = xmlNewNode(ns, BAD_CAST "OutputDefinitions");
1292    mcursor=outputs;
1293    scursor=NULL;
1294    while(mcursor!=NULL){
1295      scursor=getElements(serv->outputs,mcursor->name);
1296      printOutputDefinitions1(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
1297      mcursor=mcursor->next;
1298    }
1299    xmlAddChild(n,nc);
1300  }
1301#ifdef DEBUG
1302  fprintf(stderr,"printProcessResponse 1 190\n");
1303#endif
1304
1305  /**
1306   * Display the process output only when requested !
1307   */
1308  if(status==SERVICE_SUCCEEDED){
1309    nc = xmlNewNode(ns, BAD_CAST "ProcessOutputs");
1310    maps* mcursor=outputs;
1311    elements* scursor=serv->outputs;
1312    while(mcursor!=NULL){
1313      scursor=getElements(serv->outputs,mcursor->name);
1314      printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output");
1315      mcursor=mcursor->next;
1316    }
1317    xmlAddChild(n,nc);
1318  }
1319#ifdef DEBUG
1320  fprintf(stderr,"printProcessResponse 1 202\n");
1321#endif
1322  xmlDocSetRootElement(doc, n);
1323  if(hasStoredExecuteResponse==true){
1324    /* We need to write the ExecuteResponse Document somewhere */
1325    FILE* output=fopen(stored_path,"w");
1326    xmlChar *xmlbuff;
1327    int buffersize;
1328    xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, "UTF-8", 1);
1329    fwrite(xmlbuff,1,xmlStrlen(xmlbuff)*sizeof(char),output);
1330    xmlFree(xmlbuff);
1331    fclose(output);
1332  }
1333  printDocument(m,doc,pid);
1334
1335  xmlCleanupParser();
1336  zooXmlCleanupNs();
1337}
1338
1339
1340void printDocument(maps* m, xmlDocPtr doc,int pid){
1341  char *encoding=getEncoding(m);
1342  if(pid==getpid()){
1343    printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1344  }
1345  fflush(stdout);
1346  xmlChar *xmlbuff;
1347  int buffersize;
1348  /*
1349   * Dump the document to a buffer and print it on stdout
1350   * for demonstration purposes.
1351   */
1352  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
1353  printf("%s",xmlbuff);
1354  fflush(stdout);
1355  /*
1356   * Free associated memory.
1357   */
1358  xmlFree(xmlbuff);
1359  xmlFreeDoc(doc);
1360  xmlCleanupParser();
1361  zooXmlCleanupNs();
1362}
1363
1364void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,const char* type){
1365  xmlNodePtr nc1;
1366  nc1=xmlNewNode(ns_wps, BAD_CAST type);
1367  map *tmp=NULL; 
1368  if(e!=NULL && e->defaults!=NULL)
1369    tmp=e->defaults->content;
1370  else{
1371    /*
1372    dumpElements(e);
1373    */
1374    return;
1375  }
1376  while(tmp!=NULL){
1377    if(strncasecmp(tmp->name,"MIMETYPE",strlen(tmp->name))==0
1378       || strncasecmp(tmp->name,"ENCODING",strlen(tmp->name))==0
1379       || strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
1380       || strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
1381    xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
1382    tmp=tmp->next;
1383  }
1384  tmp=getMap(e->defaults->content,"asReference");
1385  if(tmp==NULL)
1386    xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
1387
1388  tmp=e->content;
1389
1390  printDescription(nc1,ns_ows,m->name,e->content);
1391
1392  xmlAddChild(nc,nc1);
1393
1394}
1395
1396void printOutputDefinitions(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,map* m,const char* type){
1397  xmlNodePtr nc1,nc2,nc3;
1398  nc1=xmlNewNode(ns_wps, BAD_CAST type);
1399  map *tmp=NULL; 
1400  if(e!=NULL && e->defaults!=NULL)
1401    tmp=e->defaults->content;
1402  else{
1403    /*
1404    dumpElements(e);
1405    */
1406    return;
1407  }
1408  while(tmp!=NULL){
1409    xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
1410    tmp=tmp->next;
1411  }
1412  tmp=getMap(e->defaults->content,"asReference");
1413  if(tmp==NULL)
1414    xmlNewProp(nc1,BAD_CAST "asReference",BAD_CAST "false");
1415
1416  tmp=e->content;
1417
1418  printDescription(nc1,ns_ows,m->name,e->content);
1419
1420  xmlAddChild(nc,nc1);
1421
1422}
1423
1424void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
1425  xmlNodePtr nc1,nc2,nc3;
1426  nc1=xmlNewNode(ns_wps, BAD_CAST type);
1427  map *tmp=NULL;
1428  if(e!=NULL)
1429    tmp=e->content;
1430  else
1431    tmp=m->content;
1432#ifdef DEBUG
1433  dumpMap(tmp);
1434  dumpElements(e);
1435#endif
1436  nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
1437  if(e!=NULL)
1438    nc3=xmlNewText(BAD_CAST e->name);
1439  else
1440    nc3=xmlNewText(BAD_CAST m->name);
1441  xmlAddChild(nc2,nc3);
1442  xmlAddChild(nc1,nc2);
1443  xmlAddChild(nc,nc1);
1444  // Extract Title required to be first element in the ZCFG file !
1445  bool isTitle=true;
1446  if(e!=NULL)
1447    tmp=getMap(e->content,"Title");
1448  else
1449    tmp=getMap(m->content,"Title");
1450 
1451  if(tmp!=NULL){
1452    nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
1453    nc3=xmlNewText(BAD_CAST _ss(tmp->value));
1454    xmlAddChild(nc2,nc3); 
1455    xmlAddChild(nc1,nc2);
1456  }
1457
1458  if(e!=NULL)
1459    tmp=getMap(e->content,"Abstract");
1460  else
1461    tmp=getMap(m->content,"Abstract");
1462  if(tmp!=NULL){
1463    nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
1464    nc3=xmlNewText(BAD_CAST _ss(tmp->value));
1465    xmlAddChild(nc2,nc3); 
1466    xmlAddChild(nc1,nc2);
1467    xmlAddChild(nc,nc1);
1468  }
1469
1470  /**
1471   * IO type Reference or full Data ?
1472   */
1473#ifdef DEBUG
1474  fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
1475#endif
1476  map *tmpMap=getMap(m->content,"Reference");
1477  if(tmpMap==NULL){
1478    nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
1479    if(e!=NULL){
1480      if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
1481        nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
1482      else
1483        if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
1484          nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
1485        else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
1486          nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
1487        else
1488          nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
1489    }
1490    else{
1491      map* tmpV=getMapFromMaps(m,"format","value");
1492      if(tmpV!=NULL)
1493        nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
1494      else
1495        nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
1496    } 
1497    tmp=m->content;
1498    while(tmp!=NULL){
1499      if(strcasecmp(tmp->name,"mimeType")==0 ||
1500         strcasecmp(tmp->name,"encoding")==0 ||
1501         strcasecmp(tmp->name,"schema")==0 ||
1502         strcasecmp(tmp->name,"datatype")==0 ||
1503         strcasecmp(tmp->name,"uom")==0)
1504        xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1505      tmp=tmp->next;
1506      xmlAddChild(nc2,nc3);
1507    }
1508    if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
1509      map* bb=getMap(m->content,"value");
1510      if(bb!=NULL){
1511        map* tmpRes=parseBoundingBox(bb->value);
1512        printBoundingBox(ns_ows,nc3,tmpRes);
1513        freeMap(&tmpRes);
1514        free(tmpRes);
1515      }
1516    }else{
1517      if(e!=NULL)
1518        tmp=getMap(e->defaults->content,"mimeType");
1519      else
1520        tmp=NULL;
1521      map* tmp1=getMap(m->content,"encoding");
1522      map* tmp2=getMap(m->content,"mimeType");
1523      map* toto=getMap(m->content,"value");
1524      if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
1525         || (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 ||
1526                            (strncmp(tmp2->value,"application/",12)==0) &&
1527                            strncmp(tmp2->value,"application/json",16)!=0))) {
1528        map* rs=getMap(m->content,"size");
1529        bool isSized=true;
1530        if(rs==NULL){
1531          char tmp1[1024];
1532          sprintf(tmp1,"%d",strlen(toto->value));
1533          rs=createMap("z",tmp1);
1534          isSized=false;
1535        }
1536
1537        xmlAddChild(nc3,xmlNewText(BAD_CAST base64(toto->value, atoi(rs->value))));
1538        if(!isSized){
1539          freeMap(&rs);
1540          free(rs);
1541        }
1542      }
1543      else if(tmp!=NULL){
1544        if(strncmp(tmp->value,"text/js",4)==0 ||
1545           strncmp(tmp->value,"application/js",14)==0)
1546          xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST toto->value,strlen(toto->value)));
1547        else
1548          xmlAddChild(nc3,xmlNewText(BAD_CAST toto->value));
1549        xmlAddChild(nc2,nc3);
1550      }
1551      else
1552        xmlAddChild(nc3,xmlNewText(BAD_CAST toto->value));
1553    }
1554  }
1555  else{
1556    nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
1557    if(strcasecmp(type,"Output")==0)
1558      xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
1559    else
1560      xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
1561    tmp=m->content;
1562    while(tmp!=NULL){
1563      if(strcasecmp(tmp->name,"mimeType")==0 ||
1564         strcasecmp(tmp->name,"encoding")==0 ||
1565         strcasecmp(tmp->name,"schema")==0 ||
1566         strcasecmp(tmp->name,"datatype")==0 ||
1567         strcasecmp(tmp->name,"uom")==0)
1568        xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
1569      tmp=tmp->next;
1570      xmlAddChild(nc2,nc3);
1571    }
1572  }
1573
1574  xmlAddChild(nc1,nc2);
1575  xmlAddChild(nc,nc1);
1576
1577}
1578
1579void printDescription(xmlNodePtr root,xmlNsPtr ns_ows,const char* identifier,map* amap){
1580  xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "Identifier");
1581  xmlAddChild(nc2,xmlNewText(BAD_CAST identifier));
1582  xmlAddChild(root,nc2);
1583  map* tmp=amap;
1584  char *tmp2[2];
1585  tmp2[0]="Title";
1586  tmp2[1]="Abstract";
1587  int j=0;
1588  for(j=0;j<2;j++){
1589    map* tmp1=getMap(tmp,tmp2[j]);
1590    if(tmp1!=NULL){
1591      nc2 = xmlNewNode(ns_ows, BAD_CAST tmp2[j]);
1592      xmlAddChild(nc2,xmlNewText(BAD_CAST _ss(tmp1->value)));
1593      xmlAddChild(root,nc2);
1594    }
1595  }
1596}
1597
1598char* getEncoding(maps* m){
1599  if(m!=NULL){
1600    map* tmp=getMap(m->content,"encoding");
1601    if(tmp!=NULL){
1602      return tmp->value;
1603    }
1604    else
1605      return "UTF-8";
1606  }
1607  else
1608    return "UTF-8"; 
1609}
1610
1611char* getVersion(maps* m){
1612  if(m!=NULL){
1613    map* tmp=getMap(m->content,"version");
1614    if(tmp!=NULL){
1615      return tmp->value;
1616    }
1617    else
1618      return "1.0.0";
1619  }
1620  else
1621    return "1.0.0";
1622}
1623
1624void printExceptionReportResponse(maps* m,map* s){
1625  int buffersize;
1626  xmlDocPtr doc;
1627  xmlChar *xmlbuff;
1628  xmlNodePtr n;
1629
1630  doc = xmlNewDoc(BAD_CAST "1.0");
1631  maps* tmpMap=getMaps(m,"main");
1632  char *encoding=getEncoding(tmpMap);
1633  if(m!=NULL){
1634    map *tmpSid=getMapFromMaps(m,"lenv","sid");
1635    if(tmpSid!=NULL){
1636      if( getpid()==atoi(tmpSid->value) )
1637        printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1638    }
1639    else
1640      printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1641  }else
1642    printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
1643  n=createExceptionReportNode(m,s,1);
1644  xmlDocSetRootElement(doc, n);
1645  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
1646  printf("%s",xmlbuff);
1647  fflush(stdout);
1648  xmlFreeDoc(doc);
1649  xmlFree(xmlbuff);
1650  xmlCleanupParser();
1651  zooXmlCleanupNs();
1652}
1653
1654xmlNodePtr createExceptionReportNode(maps* m,map* s,int use_ns){
1655 
1656  int buffersize;
1657  xmlChar *xmlbuff;
1658  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
1659  xmlNodePtr n,nc,nc1,nc2;
1660
1661  maps* tmpMap=getMaps(m,"main");
1662
1663  int nsid=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
1664  ns=usedNs[nsid];
1665  n = xmlNewNode(ns, BAD_CAST "ExceptionReport");
1666
1667  if(use_ns==1){
1668    ns_ows=xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
1669    int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
1670    ns_xsi=usedNs[xsiId];
1671    int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
1672    ns_xlink=usedNs[xlinkId];
1673    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");
1674  }
1675  addLangAttr(n,m);
1676  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.1.0");
1677 
1678  nc = xmlNewNode(ns, BAD_CAST "Exception");
1679
1680  map* tmp=getMap(s,"code");
1681  if(tmp!=NULL)
1682    xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST tmp->value);
1683  else
1684    xmlNewProp(nc,BAD_CAST "exceptionCode",BAD_CAST "NoApplicableCode");
1685
1686  tmp=getMap(s,"text");
1687  nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
1688  nc2=NULL;
1689  if(tmp!=NULL){
1690    xmlNodeSetContent(nc1, BAD_CAST tmp->value);
1691  }
1692  else{
1693    xmlNodeSetContent(nc1, BAD_CAST _("No debug message available"));
1694  }
1695  xmlAddChild(nc,nc1);
1696  xmlAddChild(n,nc);
1697  return n;
1698}
1699
1700
1701void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
1702                    map* request_inputs1,int cpid,maps* m,int res){
1703#ifdef DEBUG
1704  dumpMaps(request_inputs);
1705  dumpMaps(request_outputs);
1706  fprintf(stderr,"printProcessResponse\n");
1707#endif
1708  map* toto=getMap(request_inputs1,"RawDataOutput");
1709  int asRaw=0;
1710  if(toto!=NULL)
1711    asRaw=1;
1712 
1713  map *_tmp=getMapFromMaps(m,"lenv","cookie");
1714  if(_tmp!=NULL){
1715    printf("Set-Cookie: %s\r\n",_tmp->value);
1716    maps *tmpSess=getMaps(m,"senv");
1717    if(tmpSess!=NULL){
1718      char session_file_path[1024];
1719      map *tmpPath=getMapFromMaps(m,"main","sessPath");
1720      if(tmpPath==NULL)
1721        tmpPath=getMapFromMaps(m,"main","tmpPath");
1722      char *tmp1=strtok(_tmp->value,";");
1723      if(tmp1!=NULL)
1724        sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(tmp1,"=")+1);
1725      else
1726        sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(_tmp->value,"=")+1);
1727      dumpMapsToFile(tmpSess,session_file_path);
1728    }
1729  }
1730  if(asRaw==0){
1731#ifdef DEBUG
1732    fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
1733    dumpMaps(request_outputs);
1734#endif
1735    maps* tmpI=request_outputs;
1736    while(tmpI!=NULL){
1737      toto=getMap(tmpI->content,"asReference");
1738      if(toto!=NULL && strcasecmp(toto->value,"true")==0){
1739        elements* in=getElements(s->outputs,tmpI->name);
1740        char *format=NULL;
1741        if(in!=NULL){
1742          format=strdup(in->format);
1743        }else
1744          format=strdup("LiteralData");
1745        if(strcasecmp(format,"BoundingBoxData")==0){
1746          addToMap(tmpI->content,"extension","xml");
1747          addToMap(tmpI->content,"mimeType","text/xml");
1748          addToMap(tmpI->content,"encoding","UTF-8");
1749          addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
1750        }
1751        map *ext=getMap(tmpI->content,"extension");
1752        map *tmp1=getMapFromMaps(m,"main","tmpPath");
1753        char *file_name;
1754        bool hasExt=true;
1755        if(ext==NULL){
1756          // We can fallback to a default list of supported formats using
1757          // mimeType information if present here. Maybe we can add more formats
1758          // here.
1759          // If mimeType was not found, we then set txt as the default extension.
1760          map* mtype=getMap(tmpI->content,"mimeType");
1761          if(mtype!=NULL){
1762            if(strcasecmp(mtype->value,"text/xml")==0)
1763              ext=createMap("extension","xml");
1764            else if(strcasecmp(mtype->value,"application/json")==0)
1765              ext=createMap("extension","js");
1766            else
1767              ext=createMap("extension","txt");
1768          }
1769          else
1770            ext=createMap("extension","txt");
1771          hasExt=false;
1772        }
1773        file_name=(char*)malloc((strlen(tmp1->value)+strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+13)*sizeof(char));
1774        sprintf(file_name,"%s/%s_%s_%i.%s",tmp1->value,s->name,tmpI->name,cpid+100000,ext->value);
1775        FILE *ofile=fopen(file_name,"w");
1776        if(ofile==NULL)
1777          fprintf(stderr,"Unable to create file on disk implying segfault ! \n");
1778        map *tmp2=getMapFromMaps(m,"main","tmpUrl");
1779        map *tmp3=getMapFromMaps(m,"main","serverAddress");
1780        char *file_url;
1781        file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+13)*sizeof(char));
1782        sprintf(file_url,"%s/%s/%s_%s_%i.%s",tmp3->value,tmp2->value,s->name,tmpI->name,cpid+100000,ext->value);
1783        addToMap(tmpI->content,"Reference",file_url);
1784        if(hasExt!=true){
1785          freeMap(&ext);
1786          free(ext);
1787        }
1788        toto=getMap(tmpI->content,"value");
1789        if(strcasecmp(format,"BoundingBoxData")!=0){
1790          map* size=getMap(tmpI->content,"size");
1791          if(size!=NULL && toto!=NULL)
1792            fwrite(toto->value,1,atoi(size->value)*sizeof(char),ofile);
1793          else
1794            if(toto!=NULL && toto->value!=NULL)
1795              fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
1796        }else{
1797          printBoundingBoxDocument(m,tmpI,ofile);
1798        }
1799        free(format);
1800        fclose(ofile);
1801        free(file_name);
1802        free(file_url); 
1803      }
1804      tmpI=tmpI->next;
1805    }
1806    map *r_inputs=getMap(s->content,"serviceProvider");
1807#ifdef DEBUG
1808    fprintf(stderr,"SERVICE : %s\n",r_inputs->value);
1809    dumpMaps(m);
1810#endif
1811    printProcessResponse(m,request_inputs1,cpid,
1812                         s,r_inputs->value,res,
1813                         request_inputs,
1814                         request_outputs);
1815  }
1816  else
1817    if(res!=SERVICE_FAILED){
1818      /**
1819       * We get the requested output or fallback to the first one if the
1820       * requested one is not present in the resulting outputs maps.
1821       */
1822      maps* tmpI=NULL;
1823      map* tmpIV=getMap(request_inputs1,"RawDataOutput");
1824      if(tmpIV!=NULL){
1825        tmpI=getMaps(request_outputs,tmpIV->value);
1826      }
1827      if(tmpI==NULL)
1828        tmpI=request_outputs;
1829      elements* e=getElements(s->outputs,tmpI->name);
1830      if(e!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
1831        printBoundingBoxDocument(m,tmpI,NULL);
1832      }else{
1833        toto=getMap(tmpI->content,"value");
1834        if(toto==NULL){
1835          char tmpMsg[1024];
1836          sprintf(tmpMsg,_("Wrong RawDataOutput parameter, unable to fetch any result for the name your provided : \"%s\"."),tmpI->name);
1837          map * errormap = createMap("text",tmpMsg);
1838          addToMap(errormap,"code", "InvalidParameterValue");
1839          printExceptionReportResponse(m,errormap);
1840          freeMap(&errormap);
1841          free(errormap);
1842          return;
1843        }
1844        char mime[1024];
1845        map* mi=getMap(tmpI->content,"mimeType");
1846#ifdef DEBUG
1847        fprintf(stderr,"SERVICE OUTPUTS\n");
1848        dumpMaps(request_outputs);
1849        fprintf(stderr,"SERVICE OUTPUTS\n");
1850#endif
1851        map* en=getMap(tmpI->content,"encoding");
1852        if(mi!=NULL && en!=NULL)
1853          sprintf(mime,
1854                  "Content-Type: %s; charset=%s\r\nStatus: 200 OK\r\n\r\n",
1855                  mi->value,en->value);
1856        else
1857          if(mi!=NULL)
1858            sprintf(mime,
1859                    "Content-Type: %s; charset=UTF-8\r\nStatus: 200 OK\r\n\r\n",
1860                    mi->value);
1861          else
1862            sprintf(mime,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
1863        printf("%s",mime);
1864        if(mi!=NULL && strncmp(mi->value,"image",5)==0){
1865          map* rs=getMapFromMaps(tmpI,tmpI->name,"size");
1866          fwrite(toto->value,atoi(rs->value),1,stdout);
1867        }
1868        else
1869          printf("%s",toto->value);
1870#ifdef DEBUG
1871        dumpMap(toto);
1872#endif
1873      }
1874    }else{
1875      char tmp[1024];
1876      map * errormap;
1877      map *lenv;
1878      lenv=getMapFromMaps(m,"lenv","message");
1879      if(lenv!=NULL)
1880        sprintf(tmp,_("Unable to run the Service. The message returned back by the Service was the following : %s"),lenv->value);
1881      else
1882        sprintf(tmp,_("Unable to run the Service. No more information was returned back by the Service."));
1883      errormap = createMap("text",tmp);     
1884      addToMap(errormap,"code", "InternalError");
1885      printExceptionReportResponse(m,errormap);
1886      freeMap(&errormap);
1887      free(errormap);
1888    }
1889}
1890
1891char *base64(const char *input, int length)
1892{
1893  BIO *bmem, *b64;
1894  BUF_MEM *bptr;
1895
1896  b64 = BIO_new(BIO_f_base64());
1897  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
1898  bmem = BIO_new(BIO_s_mem());
1899  b64 = BIO_push(b64, bmem);
1900  BIO_write(b64, input, length);
1901  BIO_flush(b64);
1902  BIO_get_mem_ptr(b64, &bptr);
1903
1904  char *buff = (char *)malloc((bptr->length)*sizeof(char));
1905  memcpy(buff, bptr->data, bptr->length-1);
1906  buff[bptr->length-1] = 0;
1907
1908  BIO_free_all(b64);
1909
1910  return buff;
1911}
1912
1913char *base64d(const char *input, int length,int* red)
1914{
1915  BIO *b64, *bmem;
1916
1917  char *buffer = (char *)malloc(length);
1918  if(buffer){
1919    memset(buffer, 0, length);
1920    b64 = BIO_new(BIO_f_base64());
1921    if(b64){
1922      bmem = BIO_new_mem_buf((unsigned char*)input,length);
1923      bmem = BIO_push(b64, bmem);
1924      *red=BIO_read(bmem, buffer, length);
1925      buffer[length-1]=0;
1926      BIO_free_all(bmem);
1927    }
1928  }
1929  return buffer;
1930}
1931
1932void ensureDecodedBase64(maps **in){
1933  maps* cursor=*in;
1934  while(cursor!=NULL){
1935    map *tmp=getMap(cursor->content,"encoding");
1936    if(tmp!=NULL && strncasecmp(tmp->value,"base64",6)==0){
1937      tmp=getMap(cursor->content,"value");
1938      addToMap(cursor->content,"base64_value",tmp->value);
1939      int size=0;
1940      char *s=strdup(tmp->value);
1941      free(tmp->value);
1942      tmp->value=base64d(s,strlen(s),&size);
1943      free(s);
1944      char sizes[1024];
1945      sprintf(sizes,"%d",size);
1946      addToMap(cursor->content,"size",sizes);
1947    }
1948    cursor=cursor->next;
1949  }
1950}
1951
1952char* addDefaultValues(maps** out,elements* in,maps* m,int type){
1953  elements* tmpInputs=in;
1954  maps* out1=*out;
1955  while(tmpInputs!=NULL){
1956    maps *tmpMaps=getMaps(out1,tmpInputs->name);
1957    if(tmpMaps==NULL){
1958      maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
1959      tmpMaps2->name=strdup(tmpInputs->name);
1960      tmpMaps2->content=NULL;
1961      tmpMaps2->next=NULL;
1962     
1963      if(type==0){
1964        map* tmpMapMinO=getMap(tmpInputs->content,"minOccurs");
1965        if(tmpMapMinO!=NULL)
1966          if(atoi(tmpMapMinO->value)>=1){
1967            freeMaps(&tmpMaps2);
1968            free(tmpMaps2);
1969            return tmpInputs->name;
1970          }
1971          else{
1972            if(tmpMaps2->content==NULL)
1973              tmpMaps2->content=createMap("minOccurs",tmpMapMinO->value);
1974            else
1975              addToMap(tmpMaps2->content,"minOccurs",tmpMapMinO->value);
1976          }
1977        map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
1978        if(tmpMaxO!=NULL)
1979          if(tmpMaps2->content==NULL)
1980            tmpMaps2->content=createMap("maxOccurs",tmpMaxO->value);
1981          else
1982            addToMap(tmpMaps2->content,"maxOccurs",tmpMaxO->value);
1983      }
1984
1985      iotype* tmpIoType=tmpInputs->defaults;
1986      if(tmpIoType!=NULL){
1987        map* tmpm=tmpIoType->content;
1988        while(tmpm!=NULL){
1989          if(tmpMaps2->content==NULL)
1990            tmpMaps2->content=createMap(tmpm->name,tmpm->value);
1991          else
1992            addToMap(tmpMaps2->content,tmpm->name,tmpm->value);
1993          tmpm=tmpm->next;
1994        }
1995      }
1996      addToMap(tmpMaps2->content,"inRequest","false");
1997      if(type==0){
1998        map *tmpMap=getMap(tmpMaps2->content,"value");
1999        if(tmpMap==NULL)
2000          addToMap(tmpMaps2->content,"value","NULL");
2001      }
2002      if(out1==NULL){
2003        *out=dupMaps(&tmpMaps2);
2004        out1=*out;
2005      }
2006      else
2007        addMapsToMaps(&out1,tmpMaps2);
2008      freeMap(&tmpMaps2->content);
2009      free(tmpMaps2->content);
2010      tmpMaps2->content=NULL;
2011      freeMaps(&tmpMaps2);
2012      free(tmpMaps2);
2013      tmpMaps2=NULL;
2014    }
2015    else{
2016      iotype* tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,
2017                                             tmpMaps->content);
2018      if(type==0) {
2019        /**
2020         * In case of an Input maps, then add the minOccurs and maxOccurs to the
2021         * content map.
2022         */
2023        map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
2024        if(tmpMap1!=NULL){
2025          if(tmpMaps->content==NULL)
2026            tmpMaps->content=createMap("minOccurs",tmpMap1->value);
2027          else
2028            addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
2029        }
2030        map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
2031        if(tmpMaxO!=NULL){
2032          if(tmpMaps->content==NULL)
2033            tmpMaps->content=createMap("maxOccurs",tmpMap1->value);
2034          else
2035            addToMap(tmpMaps->content,"maxOccurs",tmpMap1->value);
2036        }
2037        /**
2038         * Parsing BoundingBoxData, fill the following map and then add it to
2039         * the content map of the Input maps:
2040         * lowerCorner, upperCorner, srs and dimensions
2041         * cf. parseBoundingBox
2042         */
2043        if(strcasecmp(tmpInputs->format,"BoundingBoxData")==0){
2044          maps* tmpI=getMaps(*out,tmpInputs->name);
2045          if(tmpI!=NULL){
2046            map* tmpV=getMap(tmpI->content,"value");
2047            if(tmpV!=NULL){
2048              char *tmpVS=strdup(tmpV->value);
2049              map* tmp=parseBoundingBox(tmpVS);
2050              free(tmpVS);
2051              map* tmpC=tmp;
2052              while(tmpC!=NULL){
2053                addToMap(tmpMaps->content,tmpC->name,tmpC->value);
2054                tmpC=tmpC->next;
2055              }
2056              freeMap(&tmp);
2057              free(tmp);
2058            }
2059          }
2060        }
2061      }
2062
2063      if(tmpIoType!=NULL){
2064        map* tmpContent=tmpIoType->content;
2065        map* cval=NULL;
2066
2067        while(tmpContent!=NULL){
2068          if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
2069#ifdef DEBUG
2070            fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
2071#endif
2072            if(tmpMaps->content==NULL)
2073              tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
2074            else
2075              addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
2076          }
2077          tmpContent=tmpContent->next;
2078        }
2079      }
2080      if(tmpMaps->content==NULL)
2081        tmpMaps->content=createMap("inRequest","true");
2082      else
2083        addToMap(tmpMaps->content,"inRequest","true");
2084    }
2085    tmpInputs=tmpInputs->next;
2086  }
2087  return "";
2088}
2089
2090/**
2091 * parseBoundingBox : parse a BoundingBox string
2092 *
2093 * OGC 06-121r3 : 10.2 Bounding box
2094 *
2095 * value is provided as : lowerCorner,upperCorner,crs,dimension
2096 * exemple : 189000,834000,285000,962000,urn:ogc:def:crs:OGC:1.3:CRS84
2097 *
2098 * Need to create a map to store boundingbox informations :
2099 *  - lowerCorner : double,double (minimum within this bounding box)
2100 *  - upperCorner : double,double (maximum within this bounding box)
2101 *  - crs : URI (Reference to definition of the CRS)
2102 *  - dimensions : int
2103 *
2104 * Note : support only 2D bounding box.
2105 */
2106map* parseBoundingBox(const char* value){
2107  map *res=NULL;
2108  if(value!=NULL){
2109    char *cv,*cvp;
2110    cv=strtok_r((char*) value,",",&cvp);
2111    int cnt=0;
2112    int icnt=0;
2113    char *currentValue=NULL;
2114    while(cv){
2115      if(cnt<2)
2116        if(currentValue!=NULL){
2117          char *finalValue=(char*)malloc((strlen(currentValue)+strlen(cv)+1)*sizeof(char));
2118          sprintf(finalValue,"%s%s",currentValue,cv);
2119          switch(cnt){
2120          case 0:
2121            res=createMap("lowerCorner",finalValue);
2122            break;
2123          case 1:
2124            addToMap(res,"upperCorner",finalValue);
2125            icnt=-1;
2126            break;
2127          }
2128          cnt++;
2129          free(currentValue);
2130          currentValue=NULL;
2131          free(finalValue);
2132        }
2133        else{
2134          currentValue=(char*)malloc((strlen(cv)+2)*sizeof(char));
2135          sprintf(currentValue,"%s ",cv);
2136        }
2137      else
2138        if(cnt==2){
2139          addToMap(res,"crs",cv);
2140          cnt++;
2141        }
2142        else
2143          addToMap(res,"dimensions",cv);
2144      icnt++;
2145      cv=strtok_r(NULL,",",&cvp);
2146    }
2147  }
2148  return res;
2149}
2150
2151/**
2152 * printBoundingBox : fill a BoundingBox node (ows:BoundingBox or
2153 * wps:BoundingBoxData). Set crs and dimensions attributes, add
2154 * Lower/UpperCorner nodes to a pre-existing XML node.
2155 */
2156void printBoundingBox(xmlNsPtr ns_ows,xmlNodePtr n,map* boundingbox){
2157
2158  xmlNodePtr bb,lw,uc;
2159
2160  map* tmp=getMap(boundingbox,"value");
2161
2162  tmp=getMap(boundingbox,"lowerCorner");
2163  if(tmp!=NULL){
2164    lw=xmlNewNode(ns_ows,BAD_CAST "LowerCorner");
2165    xmlAddChild(lw,xmlNewText(BAD_CAST tmp->value));
2166  }
2167
2168  tmp=getMap(boundingbox,"upperCorner");
2169  if(tmp!=NULL){
2170    uc=xmlNewNode(ns_ows,BAD_CAST "UpperCorner");
2171    xmlAddChild(uc,xmlNewText(BAD_CAST tmp->value));
2172  }
2173
2174  tmp=getMap(boundingbox,"crs");
2175  if(tmp!=NULL)
2176    xmlNewProp(n,BAD_CAST "crs",BAD_CAST tmp->value);
2177
2178  tmp=getMap(boundingbox,"dimensions");
2179  if(tmp!=NULL)
2180    xmlNewProp(n,BAD_CAST "dimensions",BAD_CAST tmp->value);
2181
2182  xmlAddChild(n,lw);
2183  xmlAddChild(n,uc);
2184
2185}
2186
2187void printBoundingBoxDocument(maps* m,maps* boundingbox,FILE* file){
2188  if(file==NULL)
2189    rewind(stdout);
2190  xmlNodePtr n;
2191  xmlDocPtr doc;
2192  xmlNsPtr ns_ows,ns_xsi;
2193  xmlChar *xmlbuff;
2194  int buffersize;
2195  char *encoding=getEncoding(m);
2196  map *tmp;
2197  if(file==NULL){
2198    int pid=0;
2199    tmp=getMapFromMaps(m,"lenv","sid");
2200    if(tmp!=NULL)
2201      pid=atoi(tmp->value);
2202    if(pid==getpid()){
2203      printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
2204    }
2205    fflush(stdout);
2206  }
2207
2208  doc = xmlNewDoc(BAD_CAST "1.0");
2209  int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
2210  ns_ows=usedNs[owsId];
2211  n = xmlNewNode(ns_ows, BAD_CAST "BoundingBox");
2212  xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
2213  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
2214  ns_xsi=usedNs[xsiId];
2215  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");
2216  map *tmp1=getMap(boundingbox->content,"value");
2217  tmp=parseBoundingBox(tmp1->value);
2218  printBoundingBox(ns_ows,n,tmp);
2219  xmlDocSetRootElement(doc, n);
2220
2221  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
2222  if(file==NULL)
2223    printf("%s",xmlbuff);
2224  else{
2225    fprintf(file,"%s",xmlbuff);
2226  }
2227
2228  if(tmp!=NULL){
2229    freeMap(&tmp);
2230    free(tmp);
2231  }
2232  xmlFree(xmlbuff);
2233  xmlFreeDoc(doc);
2234  xmlCleanupParser();
2235  zooXmlCleanupNs();
2236 
2237}
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