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

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

Small fix to make storeExecuteResponse working again.

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