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

Last change on this file since 114 was 114, checked in by djay, 9 years ago

Code cleanup to avoid most of the warning messages at compilation time.

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