Ignore:
Timestamp:
Sep 14, 2010, 2:04:55 PM (14 years ago)
Author:
djay
Message:

Update of both ZOO Kernel and ZOO Services (ogr base-vect-ops ServicesProvider?).
All the ZCFG files have been corrected to remove all references to wrong metadata (Test = Demo) to avoid validation issues.
Main Memory leaks has been removed from this version.
Addition of the Simplify Service in the C ogr base-vect-ops ServicesProvider? and addition of the Python version (without Simplify).
Update of the configure.ac and Makefile.in to follow dicussions on the mailing list and ensure to use our cgic206 and not another one, path to our cgic library is now directly in the Makefile.in file.
Accept the "-" character to name inputs, to solve issue on GRASS 7 integration.
Addition of the extension keyword for ZCFG file to be able to store resulting outputs in a file name using the extension suffix.
This version after a testing period shall be considerate as 1.0.1 version of the ZOO Project.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/zoo-kernel/service_internal.c

    r4 r9  
    7474}
    7575
    76 
    77 void 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"); 
     76char *zCapitalize1(char *tmp){
     77        char *res=strdup(tmp);
     78        if(res[0]>=97 && res[0]<=122)
     79                res[0]-=32;
     80        return res;
     81}
     82
     83char *zCapitalize(char *tmp){
     84  int i=0;
     85  char *res=strdup(tmp);
     86  for(i=0;i<strlen(res);i++)
     87    if(res[i]>=97 && res[i]<=122)
     88      res[i]-=32;
     89  return res;
     90}
     91
     92
     93int zooXmlSearchForNs(char* name){
     94  int i;
     95  int res=-1;
     96  for(i=0;i<nbNs;i++)
     97    if(strncasecmp(name,nsName[i],strlen(nsName[i]))==0){
     98      res=i;
     99      break;
     100    }
     101  return res;
     102}
     103
     104int zooXmlAddNs(xmlNodePtr nr,char* url,char* name){
     105#ifdef DEBUG
     106  fprintf(stderr,"zooXmlAddNs %d \n",nbNs);
     107#endif
     108  int currId=-1;
     109  if(nbNs==0){
     110    nbNs++;
     111    currId=0;
     112    nsName[currId]=strdup(name);
     113    usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
     114  }else{
     115    currId=zooXmlSearchForNs(name);
     116    if(currId<0){
     117      nbNs++;
     118      currId=nbNs-1;
     119      nsName[currId]=strdup(name);
     120      usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
     121    }
     122  }
     123  return currId;
     124}
     125
     126void zooXmlCleanupNs(){
     127  int j;
     128#ifdef DEBUG
     129  fprintf(stderr,"zooXmlCleanup %d\n",nbNs);
     130#endif
     131  for(j=nbNs-1;j>=0;j--){
     132#ifdef DEBUG
     133    fprintf(stderr,"zooXmlCleanup %d\n",j);
     134#endif
     135    if(j==0)
     136      xmlFreeNs(usedNs[j]);
     137    free(nsName[j]);
     138    nbNs--;
     139  }
     140  nbNs=0;
     141}
     142
     143xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr doc,char* service,maps* m){
     144
    80145  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 
    257 void 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 
    426 void 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;
     146  xmlNodePtr n,nc,nc1,nc2,nc3,nc4,nc5,nc6,pseudor;
    431147  xmlChar *xmlbuff;
    432148  int buffersize;
    … …  
    434150   * Create the document and its temporary root.
    435151   */
    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 
     152  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
     153  ns=usedNs[wpsId];
    439154  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");
     155
     156  n = xmlNewNode(ns, BAD_CAST "Capabilities");
     157  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
     158  ns_ows=usedNs[owsId];
    454159  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");
     160  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
     161  ns_xsi=usedNs[xsiId];
     162  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
     163  ns_xlink=usedNs[xlinkId];
     164  xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd");
    458165  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
    459166 
    … …  
    476183    map* tmp2=tmp4->content;
    477184    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 
    732 xmlNodePtr 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){
     185      if(strncasecmp(tmp2->name,"keywords",8)!=0 &&
     186         strncasecmp(tmp2->name,"serverAddress",13)!=0 &&
     187         strncasecmp(tmp2->name,"lang",4)!=0 &&
     188         strncasecmp(tmp2->name,"encoding",8)!=0 &&
     189         strncasecmp(tmp2->name,"version",7)!=0){
    789190        tmp2->name[0]=toupper(tmp2->name[0]);
    790191        nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
    … …  
    857258          if(strcmp(tmp2->name,"ProviderSite")==0){
    858259            nc1 = xmlNewNode(ns_ows, BAD_CAST tmp2->name);
    859             xmlNewProp(nc1,BAD_CAST "xlink:href",BAD_CAST tmp2->value);
     260            xmlNewNsProp(nc1,ns_xlink,BAD_CAST "href",BAD_CAST tmp2->value);
    860261            xmlAddChild(nc,nc1);
    861262          }
    … …  
    931332  nc = xmlNewNode(ns_ows, BAD_CAST "OperationsMetadata");
    932333  char *tmp2[3];
    933   tmp2[0]="GetCapabilities";
    934   tmp2[1]="DescribeProcess";
    935   tmp2[2]="Execute";
     334  tmp2[0]=strdup("GetCapabilities");
     335  tmp2[1]=strdup("DescribeProcess");
     336  tmp2[2]=strdup("Execute");
    936337  int j=0;
    937338
    … …  
    942343    }
    943344    else
    944       SERVICE_URL = "not_found";
     345      SERVICE_URL = strdup("not_found");
    945346  }
    946347  else
    947     SERVICE_URL = "not_found";
     348    SERVICE_URL = strdup("not_found");
    948349
    949350  for(j=0;j<3;j++){
    … …  
    954355    nc4 = xmlNewNode(ns_ows, BAD_CAST "Get");
    955356    sprintf(tmp,"%s/%s",SERVICE_URL,service);
    956     xmlNewProp(nc4,BAD_CAST "xlink:href",BAD_CAST tmp);
     357    xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
    957358    xmlAddChild(nc3,nc4);
    958359    if(j>0){
    959360      nc4 = xmlNewNode(ns_ows, BAD_CAST "Post");
    960       xmlNewProp(nc4,BAD_CAST "xlink:href",BAD_CAST tmp);
     361      xmlNewNsProp(nc4,ns_xlink,BAD_CAST "href",BAD_CAST tmp);
    961362      xmlAddChild(nc3,nc4);
    962363    }
    … …  
    965366    xmlAddChild(nc,nc1);   
    966367  }
     368  for(j=2;j>=0;j--)
     369    free(tmp2[j]);
    967370  xmlAddChild(n,nc);
    968371
    969372  nc = xmlNewNode(ns, BAD_CAST "ProcessOfferings");
    970373  xmlAddChild(n,nc);
    971 
    972 
    973374
    974375  nc1 = xmlNewNode(ns, BAD_CAST "Languages");
    … …  
    1017418 
    1018419  xmlDocSetRootElement(doc, n);
    1019 
     420  //xmlFreeNs(ns);
     421  free(SERVICE_URL);
    1020422  return nc;
    1021423}
    1022424
    1023425void printGetCapabilitiesForProcess(maps* m,xmlNodePtr nc,service* serv){
    1024 
    1025   xmlNsPtr ns,ns_ows;
     426  xmlNsPtr ns,ns_ows,ns_xlink;
    1026427  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");
     428  /**
     429   * Initialize or get existing namspaces
     430   */
     431  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
     432  ns=usedNs[wpsId];
     433  int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
     434  ns_ows=usedNs[owsId];
     435  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
     436  ns_xlink=usedNs[xlinkId];
    1031437
    1032438  int cursor=0;
    … …  
    1036442    tmp1=getMap(serv->content,"processVersion");
    1037443    if(tmp1!=NULL)
    1038       xmlNewProp(nc1,BAD_CAST "wps:processVersion",BAD_CAST tmp1->value);
    1039    
     444      xmlNewNsProp(nc1,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);
    1040445    printDescription(nc1,ns_ows,serv->name,serv->content);
    1041446    tmp1=serv->metadata;
    1042447    while(tmp1!=NULL){
    1043448      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);
     449      xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
    1047450      xmlAddChild(nc1,nc2);
    1048451      tmp1=tmp1->next;
    … …  
    1050453    xmlAddChild(nc,nc1);
    1051454  }
    1052  
    1053 }
    1054 
    1055 void 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);
     455}
     456
     457xmlNodePtr printDescribeProcessHeader(xmlDocPtr doc,char* service,maps* m){
     458
     459  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
     460  xmlNodePtr n,nr;
    1059461  xmlChar *xmlbuff;
    1060462  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 
    1074 void 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 }
     463
     464  int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
     465  ns=usedNs[wpsId];
     466  n = xmlNewNode(ns, BAD_CAST "ProcessDescriptions");
     467  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
     468  ns_ows=usedNs[owsId];
     469  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
     470  zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
     471  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
     472  ns_xsi=usedNs[xsiId];
    1090473 
    1091 
    1092 void 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");
     474  xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd");
    1114475  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
    1115476  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
     477  xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en");
     478
     479  xmlDocSetRootElement(doc, n);
     480
     481  return n;
     482}
     483
     484void printDescribeProcessForProcess(maps* m,xmlNodePtr nc,service* serv,int sc){
     485  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
     486  xmlNodePtr nr,n,nc1,nc2,nc3,nc4,nc5,nc6,pseudor;
     487
    1116488  char tmp[256];
     489  n=nc;
    1117490 
     491  int wpsId=zooXmlAddNs(NULL,"http://schemas.opengis.net/wps/1.0.0","wps");
     492  ns=usedNs[wpsId];
     493  int owsId=zooXmlAddNs(NULL,"http://www.opengis.net/ows/1.1","ows");
     494  ns_ows=usedNs[owsId];
     495  int xlinkId=zooXmlAddNs(NULL,"http://www.w3.org/1999/xlink","xlink");
     496  ns_xlink=usedNs[xlinkId];
     497
    1118498  nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
    1119499  char *tmp4[3];
    … …  
    1127507    if(tmp1!=NULL){
    1128508      if(j==0)
    1129         xmlNewProp(nc,BAD_CAST "wps:processVersion",BAD_CAST tmp1->value);     
     509        xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp1->value);     
    1130510      else
    1131511        xmlNewProp(nc,BAD_CAST tmp4[j],BAD_CAST tmp1->value);     
    … …  
    1142522  while(tmp1!=NULL){
    1143523    nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
    1144     xmlNewProp(nc1,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
     524    xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
    1145525    xmlAddChild(nc,nc1);
    1146526    tmp1=tmp1->next;
    … …  
    1173553    nc3 = xmlNewNode(NULL, BAD_CAST e->format);
    1174554    iotype* _tmp=e->defaults;
     555    int datatype=0;
    1175556    if(_tmp!=NULL){
     557      int isAnyValue=1;
    1176558      if(strcmp(e->format,"LiteralData")!=0){
    1177559        nc4 = xmlNewNode(NULL, BAD_CAST "Default");
    … …  
    1181563        nc4 = xmlNewNode(NULL, BAD_CAST "UOMs");
    1182564        nc5 = xmlNewNode(NULL, BAD_CAST "Default");
     565        datatype=1;
    1183566      }
    1184567      tmp1=_tmp->content;
     568      int default1=0;
     569      xmlNodePtr nc7;
    1185570      while(tmp1!=NULL){
    1186571#ifdef DEBUG
    1187572        printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
    1188573#endif
    1189         if(strcmp(tmp1->name,"DataType")==0){
    1190           nc6 = xmlNewNode(ns_ows, BAD_CAST tmp1->name);
     574        if(strncasecmp(tmp1->name,"DataType",8)==0){
     575          nc6 = xmlNewNode(ns_ows, BAD_CAST "DataType");
    1191576          xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1192577          char tmp[1024];
    1193578          sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
    1194           xmlNewProp(nc6,BAD_CAST "ows:reference",BAD_CAST tmp);
     579          xmlNewNsProp(nc6,ns_ows,BAD_CAST "reference",BAD_CAST tmp);
    1195580          xmlAddChild(nc3,nc6);
    1196581          tmp1=tmp1->next;
    1197582          continue;
    1198583        }
    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);
     584        if(strcasecmp(tmp1->name,"asReference")!=0 &&
     585           strcasecmp(tmp1->name,"DataType")!=0 &&
     586           strncasecmp(tmp1->name,"AllowedValues",13)!=0 &&
     587           strcasecmp(tmp1->name,"value")!=0 &&
     588           strcasecmp(tmp1->name,"extension")!=0){
     589          if(datatype==0){
     590            char *tmp2=zCapitalize1(tmp1->name);
     591            nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
     592            free(tmp2);
    1211593          }
    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 
    1366 xmlNodePtr 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 
    1397 void 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);
     594          else{
     595            char *tmp2=zCapitalize(tmp1->name);
     596            nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
     597            free(tmp2);
     598          }
    1502599          xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1503600          xmlAddChild(nc5,nc6);
    … …  
    1509606            default1=1;
    1510607          }
     608          if(strncasecmp(tmp1->name,"AllowedValues",13)==0){
     609            nc6 = xmlNewNode(ns_ows, BAD_CAST "AllowedValues");
     610            char *token,*saveptr1;
     611            token=strtok_r(tmp1->value,",",&saveptr1);
     612            while(token!=NULL){
     613                nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
     614                char *tmps=strdup(token);
     615                tmps[strlen(tmps)]=0;
     616                xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
     617                fprintf(stderr,"strgin : %s\n",tmps);
     618                xmlAddChild(nc6,nc7);
     619                token=strtok_r(NULL,",",&saveptr1);
     620            }
     621            xmlAddChild(nc3,nc6);
     622            isAnyValue=-1;
     623          }
    1511624        }
    1512625        tmp1=tmp1->next;
    … …  
    1514627      xmlAddChild(nc4,nc5);
    1515628      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       }
     629      if(datatype==1 && isAnyValue==1){
     630        xmlAddChild(nc3,xmlNewNode(ns_ows, BAD_CAST "AnyValue"));
     631        if(default1>0)
     632          xmlAddChild(nc3,nc7);
     633      }
     634      if(datatype==1 && default1>0)
     635        xmlAddChild(nc3,nc7);
    1521636    }
    1522637    xmlAddChild(nc2,nc3);
    1523638   
    1524639    _tmp=e->supported;
    1525     if(_tmp!=NULL){
     640    while(_tmp!=NULL){
    1526641      if(datatype==0){
    1527642        nc4 = xmlNewNode(NULL, BAD_CAST "Supported");
    … …  
    1535650        /*if(strcmp(e->format,"LiteralData")==0)
    1536651          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);
     652        if(datatype==0){
     653          char *tmp2=zCapitalize1(tmp1->name);
     654          nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
     655          free(tmp2);
     656        }
     657        else{
     658          char *tmp2=zCapitalize(tmp1->name);     
     659          nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
     660          free(tmp2);
     661        }
    1541662        xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1542663        xmlAddChild(nc5,nc6);
    … …  
    1549670        xmlAddChild(nc4,nc5);
    1550671        //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);
     672      }
     673      _tmp=_tmp->next;
     674      if(strcmp(e->format,"LiteralData")!=0){
     675        xmlAddChild(nc2,nc3);
     676      }
     677      xmlAddChild(nc1,nc2);
     678    }
    1557679   
    1558680   
    … …  
    1563685  nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
    1564686 
    1565   e=serv[0]->outputs;
     687  e=serv->outputs;
    1566688  while(e!=NULL){
    1567689    nc2 = xmlNewNode(NULL, BAD_CAST "Output");
    … …  
    1577699    printDescription(nc2,ns_ows,e->name,e->content);
    1578700
    1579     if(strcmp(mtoupper(e->format),"LITERALDATA")==0)
     701    if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
    1580702      nc3 = xmlNewNode(NULL, BAD_CAST "LiteralOutput");
    1581703    else
    1582       if(strcmp(mtoupper(e->format),"COMPLEXDATA")==0)
     704      if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
    1583705        nc3 = xmlNewNode(NULL, BAD_CAST "ComplexOutput");
    1584706      else
    … …  
    1594716     }
    1595717      else{
    1596       nc4 = xmlNewNode(NULL, BAD_CAST "Default");
    1597       nc5 = xmlNewNode(NULL, BAD_CAST "Format");
     718        nc4 = xmlNewNode(NULL, BAD_CAST "Default");
     719        nc5 = xmlNewNode(NULL, BAD_CAST "Format");
    1598720      }
    1599721      tmp1=_tmp->content;
    … …  
    1602724        printf("DATATYPE DEFAULT ? %s\n",tmp1->name);
    1603725#endif
    1604         if(strcmp(tmp1->name,"DataType")==0){
    1605           nc6 = xmlNewNode(ns_ows, BAD_CAST tmp1->name);
     726        if(strncasecmp(tmp1->name,"DataType",8)==0){
     727          nc6 = xmlNewNode(ns_ows, BAD_CAST "DataType");
    1606728          xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1607729          char tmp[1024];
    1608730          sprintf(tmp,"http://www.w3.org/TR/xmlschema-2/#%s",tmp1->value);
    1609           xmlNewProp(nc6,BAD_CAST "ows:reference",BAD_CAST tmp);
     731          xmlNewNsProp(nc6,ns_xlink,BAD_CAST "reference",BAD_CAST tmp);
    1610732          xmlAddChild(nc3,nc6);
    1611733          tmp1=tmp1->next;
    … …  
    1613735          continue;
    1614736        }
    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);
     737        if(strcmp(tmp1->name,"asReference")!=0 &&
     738           strncasecmp(tmp1->name,"DataType",8)!=0 &&
     739           strcasecmp(tmp1->name,"extension")!=0){
     740          if(datatype==0){
     741            char *tmp2=zCapitalize1(tmp1->name);
     742            nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
     743            free(tmp2);
     744          }
     745          else{
     746            char *tmp2=zCapitalize(tmp1->name);
     747            nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
     748            free(tmp2);
     749          }
    1620750          xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1621751          xmlAddChild(nc5,nc6);
    … …  
    1639769        printf("DATATYPE SUPPORTED ? %s\n",tmp1->name);
    1640770#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);
     771        if(strcmp(tmp1->name,"asReference")!=0 &&
     772           strcmp(tmp1->name,"DataType")!=0 &&
     773           strcasecmp(tmp1->name,"extension")!=0){
     774          if(datatype==0){
     775            char *tmp2=zCapitalize1(tmp1->name);
     776            nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
     777            free(tmp2);
     778          }
     779          else{
     780            char *tmp2=zCapitalize(tmp1->name);
     781            nc6 = xmlNewNode(ns_ows, BAD_CAST tmp2);
     782            free(tmp2);
     783          }
    1646784          xmlAddChild(nc6,xmlNewText(BAD_CAST tmp1->value));
    1647785          xmlAddChild(nc5,nc6);
    … …  
    1673811}
    1674812
    1675 void printDescribeProcessDocument(xmlDocPtr doc){
     813void printProcessResponse(maps* m,map* request, int pid,service* serv,char* service,int status,maps* inputs,maps* outputs){
     814  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
     815  xmlNodePtr nr,n,nc,nc1,nc2,nc3,pseudor;
     816  xmlDocPtr doc;
     817  xmlChar *xmlbuff;
     818  int buffersize;
     819  time_t time1; 
     820  time(&time1);
     821  /**
     822   * Create the document and its temporary root.
     823   */
     824  doc = xmlNewDoc(BAD_CAST "1.0");
     825  int wpsId=zooXmlAddNs(NULL,"http://www.opengis.net/wps/1.0.0","wps");
     826  ns=usedNs[wpsId];
     827 
     828  n = xmlNewNode(ns, BAD_CAST "ExecuteResponse");
     829  int owsId=zooXmlAddNs(n,"http://www.opengis.net/ows/1.1","ows");
     830  ns_ows=usedNs[owsId];
     831  int xlinkId=zooXmlAddNs(n,"http://www.w3.org/1999/xlink","xlink");
     832  ns_xlink=usedNs[xlinkId];
     833  int xsiId=zooXmlAddNs(n,"http://www.w3.org/2001/XMLSchema-instance","xsi");
     834  ns_xsi=usedNs[xsiId];
     835  xmlNewNs(n,BAD_CAST "http://www.opengis.net/wps/1.0.0",BAD_CAST "wps");
     836
     837  xmlNewNsProp(n,ns_xsi,BAD_CAST "schemaLocation",BAD_CAST "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsExecute_response.xsd");
     838 
     839  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
     840  xmlNewProp(n,BAD_CAST "version",BAD_CAST "1.0.0");
     841  xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en");
     842  char tmp[256];
     843  char url[256];
     844  memset(tmp,0,256);
     845  memset(url,0,256);
     846  maps* tmp_maps=getMaps(m,"main");
     847  if(tmp_maps!=NULL){
     848    map* tmpm=getMap(tmp_maps->content,"serverAddress");
     849    map* tmpm1=getMap(tmp_maps->content,"tmpUrl");
     850    if(tmpm!=NULL && tmpm1!=NULL){
     851      sprintf(url,"%s/%s/%s_%i.xml",tmpm->value,tmpm1->value,service,pid);
     852    }
     853    if(tmpm!=NULL)
     854      sprintf(tmp,"%s/",tmpm->value);
     855  }
     856
     857  xmlNewProp(n,BAD_CAST "serviceInstance",BAD_CAST tmp);
     858  if(status!=SERVICE_SUCCEEDED){
     859    xmlNewProp(n,BAD_CAST "statusLocation",BAD_CAST url);
     860  }
     861
     862  nc = xmlNewNode(ns, BAD_CAST "Process");
     863  map* tmp2=getMap(serv->content,"processVersion");
     864
     865  if(tmp2!=NULL)
     866    xmlNewNsProp(nc,ns,BAD_CAST "processVersion",BAD_CAST tmp2->value);
     867 
     868  printDescription(nc,ns_ows,serv->name,serv->content);
     869  fflush(stderr);
     870
     871  xmlAddChild(n,nc);
     872
     873  nc = xmlNewNode(ns, BAD_CAST "Status");
     874  const struct tm *tm;
     875  size_t len;
     876  time_t now;
     877  char *tmp1;
     878 
     879  now = time ( NULL );
     880  tm = localtime ( &now );
     881
     882  tmp1 = (char*)malloc((TIME_SIZE+1)*sizeof(char));
     883
     884  len = strftime ( tmp1, TIME_SIZE, "%Y-%m-%dT%I:%M:%SZ", tm );
     885
     886  switch(status){
     887  case SERVICE_SUCCEEDED:
     888    xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
     889    nc1 = xmlNewNode(ns, BAD_CAST "ProcessSucceeded");
     890    break;
     891  case SERVICE_STARTED:
     892    xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
     893    nc1 = xmlNewNode(ns, BAD_CAST "ProcessStarted");
     894    xmlNewProp(nc1,BAD_CAST "percentCompleted",BAD_CAST "NEED_SERVICE_ACCESS");
     895    break;
     896  case SERVICE_ACCEPTED:
     897    xmlNewProp(nc,BAD_CAST "creationTime",BAD_CAST tmp1);
     898    nc1 = xmlNewNode(ns, BAD_CAST "ProcessAccepted");
     899    break;
     900  case SERVICE_FAILED:
     901    nc1 = xmlNewNode(ns, BAD_CAST "ProcessFailed");
     902    break;
     903  default :
     904    printf("error code not know : %i\n",status);
     905    exit(1);
     906    break;
     907  }
     908  xmlAddChild(nc,nc1);
     909  xmlAddChild(n,nc);
     910  free(tmp1);
     911
     912#ifdef DEBUG
     913  fprintf(stderr,"printProcessResponse 1 161\n");
     914#endif
     915
     916  map* lineage=getMap(request,"lineage");
     917  if(lineage!=NULL){
     918    nc = xmlNewNode(ns, BAD_CAST "DataInputs");
     919    int i;
     920    maps* mcursor=inputs;
     921    elements* scursor=serv->inputs;
     922    while(mcursor!=NULL /*&& scursor!=NULL*/){
     923      printIOType(doc,nc,ns,ns_ows,scursor,mcursor,"Input");
     924      mcursor=mcursor->next;
     925      //scursor=scursor->next;
     926    }
     927    xmlAddChild(n,nc);
     928   
     929#ifdef DEBUG
     930    fprintf(stderr,"printProcessResponse 1 177\n");
     931#endif
     932
     933    nc = xmlNewNode(ns, BAD_CAST "OutputDefinitions");
     934    mcursor=outputs;
     935    scursor=serv->outputs;
     936    while(mcursor!=NULL /*&& scursor!=NULL*/){
     937      printOutputDefinitions1(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
     938      mcursor=mcursor->next;
     939      //scursor=scursor->next;
     940    }
     941    xmlAddChild(n,nc);
     942  }
     943#ifdef DEBUG
     944  fprintf(stderr,"printProcessResponse 1 190\n");
     945#endif
     946
     947  /**
     948   * Display the process output only when requested !
     949   */
     950  if(status==SERVICE_SUCCEEDED){
     951    nc = xmlNewNode(ns, BAD_CAST "ProcessOutputs");
     952    maps* mcursor=outputs;
     953    elements* scursor=serv->outputs;
     954    while(mcursor!=NULL && scursor!=NULL){
     955      printIOType(doc,nc,ns,ns_ows,scursor,mcursor,"Output");
     956      mcursor=mcursor->next;
     957      scursor=scursor->next;
     958    }
     959    xmlAddChild(n,nc);
     960  }
     961#ifdef DEBUG
     962  fprintf(stderr,"printProcessResponse 1 202\n");
     963#endif
     964  xmlDocSetRootElement(doc, n);
     965  printDocument(m,doc,pid);
     966
     967  xmlCleanupParser();
     968  zooXmlCleanupNs();
     969}
     970
     971
     972void printDocument(maps* m, xmlDocPtr doc,int pid){
     973  rewind(stdout);
     974  char *encoding=getEncoding(m);
     975  if(pid==getpid()){
     976    printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
     977  }
     978  fflush(stdout);
    1676979  xmlChar *xmlbuff;
    1677980  int buffersize;
    1678981  /*
    1679    * Dump the document to a buffer and print it
     982   * Dump the document to a buffer and print it on stdout
    1680983   * for demonstration purposes.
    1681984   */
    1682   xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
     985  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
    1683986  printf((char *) xmlbuff);
    1684  
     987  //fflush(stdout);
    1685988  /*
    1686989   * Free associated memory.
    1687990   */
    1688991  xmlFree(xmlbuff);
    1689   //xmlFreeDoc(doc);
    1690 
    1691 }
    1692 //printGetCapabilitiesHeader
     992  xmlFreeDoc(doc);
     993  xmlCleanupParser();
     994  zooXmlCleanupNs();
     995}
    1693996
    1694997void printOutputDefinitions1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,char* type){
    … …  
    17051008  }
    17061009  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)
     1010    if(strncasecmp(tmp->name,"MIMETYPE",strlen(tmp->name))==0
     1011       || strncasecmp(tmp->name,"ENCODING",strlen(tmp->name))==0
     1012       || strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
     1013       || strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
    17111014    xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
    17121015    tmp=tmp->next;
    … …  
    17521055}
    17531056
    1754 void printIOType1(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,char* type){
     1057void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,elements* e,maps* m,char* type){
    17551058  xmlNodePtr nc1,nc2,nc3;
    17561059  nc1=xmlNewNode(ns_wps, BAD_CAST type);
    17571060  map *tmp=e->content;
    1758 #ifdef DEBUG
     1061  //#ifdef DEBUG
    17591062  dumpMap(tmp);
    17601063  dumpElements(e);
    1761 #endif
     1064  //#endif
    17621065  nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
    1763   xmlAddChild(nc2,xmlNewText(BAD_CAST m->name));
     1066  nc3=xmlNewText(BAD_CAST e->name);
     1067  xmlAddChild(nc2,nc3);
    17641068  xmlAddChild(nc1,nc2);
    17651069  xmlAddChild(nc,nc1);
     1070  // Extract Title required to be first element in the ZCFG file !
    17661071  nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
    1767   xmlAddChild(nc2,xmlNewText(BAD_CAST tmp->value));
     1072  nc3=xmlNewText(BAD_CAST tmp->value);
     1073  xmlAddChild(nc2,nc3); 
     1074  xmlAddChild(nc1,nc2);
     1075  // Extract Abstract required to be second element in the ZCFG file !
     1076  tmp=tmp->next;
     1077  nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
     1078  nc3=xmlNewText(BAD_CAST tmp->value);
     1079  xmlAddChild(nc2,nc3); 
    17681080  xmlAddChild(nc1,nc2);
    17691081  xmlAddChild(nc,nc1);
    … …  
    17731085   * IO type Reference or full Data ?
    17741086   */
    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");
     1087  //#ifdef DEBUG
     1088  fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
     1089  //#endif
     1090  map *tmpMap=getMap(m->content,"Reference");
     1091  if(tmpMap==NULL){
     1092    nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
     1093    if(strncasecmp(e->format,"LITERALOUTPUT",strlen(e->format))==0)
     1094      nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
    17841095    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)));
     1096      if(strncasecmp(e->format,"COMPLEXOUTPUT",strlen(e->format))==0)
     1097        nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
     1098      else
     1099        nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
     1100    tmp=m->content;
     1101    while(tmp!=NULL){
     1102      if(strncasecmp(tmp->name,"value",strlen(tmp->name))!=0 &&
     1103         strncasecmp(tmp->name,"extension",strlen(tmp->name))!=0)
     1104        xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
     1105      tmp=tmp->next;
     1106      xmlAddChild(nc2,nc3);
     1107    }
     1108    tmp=getMap(e->defaults->content,"mimeType");
     1109    map* tmp1=getMap(m->content,"encoding");
     1110    map* tmp2=getMap(m->content,"mimeType");
     1111    map* toto=getMap(m->content,"value");
     1112    if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
     1113       || (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0
     1114                          || strncmp(tmp2->value,"application/",6)==0)) ){
     1115      map* rs=getMap(m->content,"size");
     1116      if(rs==NULL){
     1117        char tmp1[1024];
     1118        sprintf(tmp1,"%d",strlen(toto->value));
     1119        rs=createMap("z",tmp1);
     1120      }
     1121      xmlAddChild(nc3,xmlNewText(BAD_CAST base64((const unsigned char*)toto->value,atoi(rs->value))));
     1122    }
     1123    else if(tmp!=NULL){
     1124      if(strcmp(tmp->value,"text/js")==0)
     1125        xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST toto->value,strlen(toto->value)));
     1126      else
     1127        xmlAddChild(nc3,xmlNewText(BAD_CAST toto->value));
     1128      xmlAddChild(nc2,nc3);
     1129    }
    18111130    else
    18121131      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 
    1823 void 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));
     1132  }
     1133  else{
     1134    nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
     1135    xmlNewProp(nc3,BAD_CAST "href",BAD_CAST tmpMap->value);
     1136    tmp=m->content;
     1137    while(tmp!=NULL){
     1138      if(strncasecmp(tmp->name,"value",strlen(tmp->name))!=0 &&
     1139         strncasecmp(tmp->name,"reference",strlen(tmp->name))!=0 &&
     1140         strncasecmp(tmp->name,"extension",strlen(tmp->name))!=0 &&
     1141         strncasecmp(tmp->name,"abstract",strlen(tmp->name))!=0 &&
     1142         strncasecmp(tmp->name,"status",strlen(tmp->name))!=0 &&
     1143         strncasecmp(tmp->name,"storeExecuteResponse",strlen(tmp->name))!=0 &&
     1144         strncasecmp(tmp->name,"asReference",strlen(tmp->name))!=0)
     1145        xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
     1146      tmp=tmp->next;
     1147      xmlAddChild(nc2,nc3);
     1148    }
     1149  }
    18611150
    18621151  xmlAddChild(nc1,nc2);
    … …  
    18841173}
    18851174
     1175char* getEncoding(maps* m){
     1176  if(m!=NULL){
     1177    map* tmp=getMap(m->content,"encoding");
     1178    if(tmp!=NULL){
     1179      return tmp->value;
     1180    }
     1181    else
     1182      return "UTF-8";
     1183  }
     1184  else
     1185    return "UTF-8"; 
     1186}
     1187
     1188char* getVersion(maps* m){
     1189  if(m!=NULL){
     1190    map* tmp=getMap(m->content,"version");
     1191    if(tmp!=NULL){
     1192      return tmp->value;
     1193    }
     1194    else
     1195      return "1.0.0";
     1196  }
     1197  else
     1198    return "1.0.0";
     1199}
     1200
    18861201void printExceptionReportResponse(maps* m,map* s){
    18871202 
    1888   printf("Content-Type: text/xml; charset=utf-8\r\nStatus: 200 OK\r\n\r\n"); 
    18891203  int buffersize;
    18901204  xmlDocPtr doc;
    18911205  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");
     1206  xmlNsPtr ns,ns_ows,ns_xlink,ns_xsi;
     1207  xmlNodePtr n,nc,nc1,nc2;
     1208
    18971209  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");
     1210  maps* tmpMap=getMaps(m,"main");
     1211  char *encoding=getEncoding(tmpMap);
     1212  printf("Content-Type: text/xml; charset=%s\r\nStatus: 200 OK\r\n\r\n",encoding);
     1213
     1214  ns=xmlNewNs(NULL,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
     1215  n = xmlNewNode(ns, BAD_CAST "ExceptionReport"); 
     1216  ns_ows=xmlNewNs(n,BAD_CAST "http://www.opengis.net/ows/1.1",BAD_CAST "ows");
     1217  ns_xlink=xmlNewNs(n,BAD_CAST "http://www.w3.org/1999/xlink",BAD_CAST "xlink");
     1218  ns_xsi=xmlNewNs(n,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
     1219  xmlNewProp(n,BAD_CAST "xsi:schemaLocation",BAD_CAST "http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1/owsExceptionReport.xsd");
     1220  xmlNewProp(n,BAD_CAST "xml:lang",BAD_CAST "en");
    19161221  xmlNewProp(n,BAD_CAST "service",BAD_CAST "WPS");
    19171222
    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"); 
     1223  xmlNewProp(n,BAD_CAST "version",BAD_CAST getVersion(tmpMap));
     1224
     1225  nc = xmlNewNode(ns, BAD_CAST "Exception"); 
    19311226
    19321227  map* tmp=getMap(s,"code");
    … …  
    19371232
    19381233  tmp=getMap(s,"text");
    1939   xmlNodePtr nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
     1234  nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
     1235  nc2=NULL;
    19401236  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  
     1237    xmlNodeSetContent(nc1, BAD_CAST tmp->value);
     1238  }
     1239  else{
     1240    xmlNodeSetContent(nc1, BAD_CAST "No debug message available");
     1241  }
    19461242  xmlAddChild(nc,nc1);
    19471243  xmlAddChild(n,nc);
    19481244  xmlDocSetRootElement(doc, n);
    19491245
    1950   xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
    1951   printf((char *) xmlbuff);
     1246  xmlDocDumpFormatMemoryEnc(doc, &xmlbuff, &buffersize, encoding, 1);
     1247  printf("%s",xmlbuff);
     1248  fflush(stdout);
     1249  xmlFreeDoc(doc);
    19521250  xmlFree(xmlbuff);
    1953   xmlFree(ns_ows);
    1954   xmlFree(nr);
    1955   xmlFree(nc1);
    1956   xmlFree(nc);
    1957   xmlFree(n);
    1958   xmlFree(ns);
    1959   xmlFree(doc);
     1251  xmlFreeNs(ns);
     1252  xmlCleanupParser();
    19601253}
    19611254
    … …  
    19721265  if(toto!=NULL)
    19731266    asRaw=1;
    1974    
     1267 
    19751268  if(asRaw==0){
     1269#ifdef DEBUG
     1270    fprintf(stderr,"REQUEST_OUTPUTS FINAL\n");
     1271    dumpMaps(request_outputs);
     1272#endif
     1273    toto=getMap(request_outputs->content,"asReference");
     1274    if(toto!=NULL && strcasecmp(toto->value,"true")==0){
     1275      toto=getMap(request_outputs->content,"extension");
     1276      map *tmp1=getMapFromMaps(m,"main","tmpPath");
     1277      char *file_name=(char*)malloc((strlen(tmp1->value)+strlen(s->name)+strlen(toto->value)+13)*sizeof(char));
     1278      sprintf(file_name,"%s/%s_%i.%s",tmp1->value,s->name,cpid+100000,toto->value);
     1279      FILE *ofile=fopen(file_name,"w");
     1280      map *tmp2=getMapFromMaps(m,"main","tmpUrl");
     1281      map *tmp3=getMapFromMaps(m,"main","serverAddress");
     1282      char *file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(s->name)+strlen(toto->value)+13)*sizeof(char));
     1283      sprintf(file_url,"%s/%s/%s_%i.%s",tmp3->value,tmp2->value,s->name,cpid+100000,toto->value);
     1284      addToMap(request_outputs->content,"Reference",file_url);
     1285      toto=getMap(request_outputs->content,"value");
     1286      if(toto!=NULL)
     1287        fwrite(toto->value,sizeof(char),strlen(toto->value),ofile);
     1288      fclose(ofile);
     1289      free(file_name);
     1290      free(file_url);
     1291    }
    19761292    map *r_inputs=getMap(s->content,"serviceProvider");
    19771293#ifdef DEBUG
    … …  
    19791295    dumpMaps(m);
    19801296#endif
    1981     printProcessResponse1(m,request_inputs1,cpid,
     1297    printProcessResponse(m,request_inputs1,cpid,
    19821298                          s,r_inputs->value,res,
    19831299                          request_inputs,
    … …  
    20071323      else
    20081324        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");
     1325    printf("%s",mime);
     1326    toto=getMap(request_outputs->content,"value");
    20121327    if(mi!=NULL && strncmp(mi->value,"image",5)==0){
    2013       map* rs=getMapFromMaps(request_outputs,
    2014                              request_outputs->name,"size");
     1328      map* rs=getMapFromMaps(request_outputs,request_outputs->name,"size");
    20151329      fwrite(toto->value,atoi(rs->value),1,stdout);
    20161330    }
    20171331    else
    2018       printf(toto->value);
     1332      printf("%s",toto->value);
    20191333#ifdef DEBUG
    20201334    dumpMap(toto);
    … …  
    20451359}
    20461360
    2047 void addDefaultValues(maps** out,elements* in,maps* m,char* type){
     1361char* addDefaultValues(maps** out,elements* in,maps* m,char* type){
    20481362  elements* tmpInputs=in;
    20491363  maps* out1=*out;
    … …  
    20521366    if(tmpMaps==NULL){
    20531367      map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
    2054       if(strcmp(type,"inputs")==0)
     1368      if(strncmp(type,"inputs",6)==0)
    20551369        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);
     1370          return tmpInputs->name;
    20621371        }
    2063       tmpMaps=(maps*)malloc(MAPS_SIZE);
    2064       tmpMaps->name=strdup((char*)tmpInputs->name);
    2065       tmpMaps->content=NULL;
     1372      maps* tmpMaps2=(maps*)malloc(MAPS_SIZE);
     1373      tmpMaps2->name=strdup((char*)tmpInputs->name);
     1374      tmpMaps2->content=NULL;
     1375      tmpMaps2->next=NULL;
    20661376      iotype* tmpIoType=tmpInputs->defaults;
    20671377      while(tmpIoType!=NULL){
    2068         tmpMaps->content=tmpIoType->content;
    2069         tmpMaps->content->next;
     1378        addMapToMap(&tmpMaps2->content,tmpIoType->content);
    20701379        tmpIoType=tmpIoType->next;
    20711380      }
    2072       map *tmpMap=getMap(tmpMaps->content,"value");
     1381      map *tmpMap=getMap(tmpMaps2->content,"value");
    20731382      if(tmpMap==NULL)
    2074         addToMap(tmpMaps->content,"value","NULL");
    2075       tmpMaps->next=NULL;
    2076       dumpMaps(tmpMaps);
     1383        addToMap(tmpMaps2->content,"value","NULL");
    20771384      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;
     1385        *out=dupMaps(&tmpMaps2);
    20831386      }
    20841387      else
    2085         addMapsToMaps(&out1,tmpMaps);
     1388        addMapsToMaps(&out1,tmpMaps2);
     1389      freeMaps(&tmpMaps2);
     1390      free(tmpMaps2);
     1391      tmpMaps2=NULL;
    20861392    }
    20871393    else{
    20881394      map* tmpContent=tmpInputs->defaults->content;
     1395     
     1396      map* cval=NULL;
     1397     
    20891398      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);
     1399        if((cval=getMap(tmpMaps->content,tmpContent->name))==NULL){
     1400#ifdef DEBUG
     1401          fprintf(stderr,"addDefaultValues %s => %s\n",tmpContent->name,tmpContent->value);
     1402#endif
     1403          if(tmpMaps->content==NULL)
     1404            tmpMaps->content=createMap(tmpContent->name,tmpContent->value);
    20941405          else
    2095             addToMap(out1->content,tmpContent->name,tmpContent->value);
     1406            addToMap(tmpMaps->content,tmpContent->name,tmpContent->value);
     1407        }
    20961408        tmpContent=tmpContent->next;
    20971409      }
    … …  
    20991411    tmpInputs=tmpInputs->next;
    21001412  }
    2101 }
     1413  return "";
     1414}
Note: See TracChangeset for help on using the changeset viewer.

Download now !

Search

Context Navigation

Main 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