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

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

Initial ZOO SVN Repository Import.

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

Search

Context Navigation

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