Changeset 9 for trunk


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.

Location:
trunk
Files:
11 added
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/zoo-kernel/Makefile.in

    r8 r9  
    11JAVACFLAGS=@JAVA_CPPFLAGS@
    22JAVALDFLAGS=@JAVA_LDFLAGS@
    3 CFLAGS=-I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
     3CFLAGS=-I../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
    44PHPCFLAGS=@PHP_CPPFLAGS@
    55PHPLDFLAGS=@PHP_LDFLAGS@
    … …  
    6969
    7070zoo_service_loader.o: zoo_service_loader.c service.h
    71         g++ -g -O2 -Wall ${XML2CFLAGS} ${CFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${PHPCFLAGS} ${JS_ENABLED} ${PHP_ENABLED} ${JAVA_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
     71        g++ -g -O2 -Wall ${XML2CFLAGS} ${CFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PHPCFLAGS} ${JS_ENABLED} ${PHP_ENABLED} ${JAVA_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
    7272
    7373zoo_loader.cgi: zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y service_internal_python.o  ulinet.o main_conf_read.tab.o lex.cr.o service_internal.o ${PHP_FILE} ${JAVA_FILE} ${JS_FILE}
    7474        g++ -g -O2 -Wall ${JSCFLAGS} ${PHPCFLAGS} ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
    75         g++  ${JSCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o service_internal.o service_internal_python.o  ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -lcurl -lcgic -lcurl ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS} -lfcgi
    76 
    77 service_loader: service.h lex.sr.o service_conf.tab.o service_conf.y service_internal_python.o ulinet.o  service_loader.o main_conf_read.tab.o lex.cr.o service_internal.o
    78         g++ ${CFLAGS} lex.sr.o service_conf.tab.o main_conf_read.tab.o lex.cr.o service_internal.o service_internal_python.o ulinet.o service_loader.o -o service_loader -ldl  ${JSLDFLAGS} ${PYTHONLDFLAGS} ${XML2LDFLAGS} -lfl -lcurl  -lssl
     75        g++  ${JSCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o service_internal.o service_internal_python.o  ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -lcurl -L../thirds/cgic206 -lcgic -lcurl ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS} -lfcgi
    7976
    8077install:

  • trunk/zoo-kernel/configure.ac

    r8 r9  
    298298        LIBS="$JAVA_LDFLAGS"
    299299        # Shouldn't we get java here rather than java5 :) ??
    300         AC_CHECK_LIB([javaplugin_jni], [JNI_CreateJavaVM], [], [AC_MSG_ERROR([could not find libjava])], [])
    301         AC_CHECK_LIB([jvm], [main], [], [AC_MSG_ERROR([could not find libjava])], [])
     300        AC_CHECK_LIB([jvm], [JNI_CreateJavaVM], [], [AC_MSG_ERROR([could not find libjava])], [])
     301        #AC_CHECK_LIB([jvm], [main], [], [AC_MSG_ERROR([could not find libjava])], [])
    302302
    303303        AC_SUBST([JAVA_CPPFLAGS])
    … …  
    347347        fi
    348348       
    349 
    350349        CPPFLAGS_SAVE="$CPPFLAGS"
    351350        CPPFLAGS="$JS_CPPFLAGS"
    … …  
    367366                JS_ENABLED="-DUSE_JS"
    368367                JS_FILE="service_internal_js.o"
    369                 JS_CPPFLAGS="-I$JSHOME/include"
     368                JS_CPPFLAGS="-I$JSHOME/include/js"
    370369                JS_LDFLAGS="-L$JSHOME/lib -ljs -lm"
    371370                JS_LIB="js"

  • trunk/zoo-kernel/main_conf_read.l

    r1 r9  
    11/* pour pouvoir acceder au numero de ligne dans bison */
    22%option yylineno
    3 
    43
    54%{
    … …  
    114113{newline}+{whitesp}*                    {if (affichetrace==1) printf ("\n\nNEWLINE 1\n") ; return NEWLINE;}
    115114
    116 <INITIAL,HORSBALISE>"["{attname}"]"             {if (affichetrace==1) printf ("\n\nANID:%s\n",yytext); crlval.chaine=strdup(yytext);crlval.chaine[strlen(crlval.chaine)-1]=0;crlval.chaine+=1;return ANID; }
     115<INITIAL,HORSBALISE>"["{attname}"]"             {if (affichetrace==1) printf ("\n\nANID:%s\n",yytext); crlval.chaine=yytext;crlval.chaine[strlen(crlval.chaine)-1]=0;crlval.chaine+=1;return ANID; }
    117116
    118 <INITIAL,HORSBALISE>{attname}             {if (affichetrace==1) printf ("\n\nATT_NAME:%s\n",yytext); crlval.chaine=strdup(yytext); return SPAIR; }
     117<INITIAL,HORSBALISE>{attname}             {if (affichetrace==1) printf ("\n\nATT_NAME:%s\n",yytext); crlval.chaine=yytext; return SPAIR; }
    119118
    120 <PAIRSTART,HORSBALISE>{attvalue1}             {if (affichetrace==1) printf ("\n\nATT_VALUE:%s\n",yytext);crlval.chaine=strdup(yytext);BEGIN(INITIAL);return EPAIR;}
     119<PAIRSTART,HORSBALISE>{attvalue1}             {if (affichetrace==1) printf ("\n\nATT_VALUE:%s\n",yytext);crlval.chaine=yytext;BEGIN(INITIAL);return EPAIR;}
    121120
    122121<PAIRSTART,INITIAL,HORSBALISE>{whitesp}*"="{whitesp}*             {BEGIN(PAIRSTART);}
    … …  
    161160
    162161
    163 <DANSBALISE>{Name}                      {if (affichetrace==1) printf ("\n\nID:%s\n",yytext) ; crlval.s=strdup(yytext);return ID;}
     162<DANSBALISE>{Name}                      {if (affichetrace==1) printf ("\n\nID:%s\n",yytext) ; crlval.s=yytext;return ID;}
    164163
    165164
    … …  
    175174
    176175
    177 int yywrap()
     176int crwrap()
    178177{return 1;}

  • trunk/zoo-kernel/main_conf_read.y

    r1 r9  
    55**/
    66//======================================================
    7 
    8 
    97
    108#include <string>
    … …  
    2321static char* curr_key;
    2422static int debug=0;
    25 //static int data=-1;
    2623static int previous_data=0;
    2724static int current_data=0;
    28 //static char* myFinalObjectAsJSON="{";
    29 // namespace
    3025using namespace std;
    3126
    … …  
    4338
    4439extern int crlex(void);
    45 
     40extern int crlex_destroy(void);
    4641
    4742%}
    … …  
    128123 : STag contentetoile ETag     
    129124{
    130         /* les non terminaux rendent les valeurs de leur identifiants de balise */
    131         /* en char*, donc on peut comparer ces valeurs avec la fonction C++ strcmp(const char*;const char*) */
    132         /* de string */
    133         if (strcmp($1,$3) != 0)
    134         {
    135            crerror("Opening and ending tag mismatch");
    136            printf("\n  ::details : tag '%s' et '%s' \n",$1,$3);
    137            return 1;
    138            // on retourne different de 0
    139            // sinon yyparse rendra 0
    140            // et dans le main on croira a le fichier xml est valide !
    141         }
     125  /* les non terminaux rendent les valeurs de leur identifiants de balise */
     126  /* en char*, donc on peut comparer ces valeurs avec la fonction C++ strcmp(const char*;const char*) */
     127  /* de string */
     128  if (strcmp($1,$3) != 0)
     129    {
     130      crerror("Opening and ending tag mismatch");
     131      printf("\n  ::details : tag '%s' et '%s' \n",$1,$3);
     132      return 1;
     133      // on retourne different de 0
     134      // sinon yyparse rendra 0
     135      // et dans le main on croira a le fichier xml est valide !
     136    }
    142137}
    143138// pour neutre
    … …  
    266261  if(current_content==NULL)
    267262    current_content=createMap(curr_key,$1);
    268   else
     263  else{
    269264    addToMap(current_content,curr_key,$1);
     265  }
    270266  if(debug){
    271267    printf("EPAIR FOUND !! \n");
    … …  
    279275
    280276processid
    281  : ANID  {
     277: ANID  {
    282278   if(current_maps->name!=NULL){
    283      current_maps->content=current_content;
    284      current_maps->next=(maps*)malloc(MAP_SIZE);
     279     addMapToMap(&current_maps->content,current_content);
     280     freeMap(&current_content);
     281     free(current_content);
     282     current_maps->next=NULL;
     283     current_maps->next=(maps*)malloc(MAPS_SIZE);
     284     current_maps->next->name=strdup($1);
     285     current_maps->next->content=NULL;
     286     current_maps->next->next=NULL;
    285287     current_maps=current_maps->next;
    286      current_maps->name=strdup($1);
     288     current_content=current_maps->content;
     289   }
     290   else{
     291     current_maps->name=(char*)malloc((strlen($1)+1)*sizeof(char));
     292     snprintf(current_maps->name,(strlen($1)+1),"%s",$1);
     293     current_maps->content=NULL;
     294     current_maps->next=NULL;
    287295     current_content=NULL;
    288296   }
    289    else{
    290      current_maps->name=strdup($1);
    291    }
    292297 }
    293298 ;
    … …  
    310315//======================================================
    311316int conf_read(char* file,maps* my_map){
    312   /* mode debug ou pas : */
    313   /* 1 = debug , 0 = normal */
    314   //yydebug = 1;
    315317 
    316318  crin = fopen(file,"r");
    … …  
    320322  }
    321323
    322   //my_map=(maps*)malloc(sizeof(maps*));
    323324  my_maps=my_map;
    324325  my_maps->name=NULL;
    … …  
    326327 
    327328  int resultatYYParse = crparse() ;
    328 
    329   if(current_content!=NULL)
    330     current_maps->content=current_content;
    331          
    332   //dumpMaps(my_maps);
     329  if(current_content!=NULL){
     330    addMapToMap(&current_maps->content,current_content);
     331    current_maps->next=NULL;
     332    freeMap(&current_content);
     333    free(current_content);
     334  }
    333335
    334336  fclose(crin);
     337  crlex_destroy();
     338
    335339  return resultatYYParse;
    336340}
    337341
    338342
    339 void usage(void)
    340 {
    341     printf("usage : $./test1 <fichier_de_configuration_principale>\n") ;         
    342 }
    343343//======================================================
    344344// FIN //

  • trunk/zoo-kernel/service.h

    r1 r9  
    4040#define true 1
    4141#define false -1
     42
    4243#define SERVICE_ACCEPTED 0
    4344#define SERVICE_STARTED 1
    … …  
    4546#define SERVICE_SUCCEEDED 3
    4647#define SERVICE_FAILED 4
     48
    4749#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+sizeof(elements*))
    48 #define MAP_SIZE (2*sizeof(char*))+sizeof(map*)
    49 #define MAPS_SIZE (2*sizeof(char*))+sizeof(map*)+sizeof(maps*)
    50 
    51 
    52   static char* mtoupper(char* str){
     50#define MAP_SIZE (2*sizeof(char*))+sizeof(NULL)
     51#define IOTYPE_SIZE MAP_SIZE+sizeof(NULL)
     52#define MAPS_SIZE (2*sizeof(char*))+sizeof(map*)+MAP_SIZE
     53#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
     54
     55
     56  /*  static char* mtoupper(char* str){
    5357    char* tmp=strdup(str);
    5458    if(tmp){
    … …  
    6367      tmp[0]=0;
    6468    return tmp;
    65   }
    66 
     69    }*/
     70
     71  /**
     72   * \struct maps
     73   * \brief linked list of map pointer
     74   *
     75   * Small object to store WPS KVP set.
     76   */
    6777  typedef struct maps{
    68     char* name;
    69     struct map* content;
    70     struct maps* next;
     78    char* name;         
     79    struct map* content; 
     80    struct maps* next;   
    7181  } maps;
    7282
     83  /**
     84   * \struct map
     85   * \brief KVP linked list
     86   *
     87   * Deal with WPS KVP (name,value).
     88   */
    7389  typedef struct map{
    74     char* name;
    75     char* value;
    76     struct map* next;
     90    char* name;       /* The key */
     91    char* value;      /* The value */
     92    struct map* next; /* Next couple */
    7793  } map;
    7894
    … …  
    8399#endif
    84100
    85   static void* _dumpMap(map* t){
     101  static void _dumpMap(map* t){
    86102    if(t!=NULL){
    87103      fprintf(stderr,"[%s] => [%s] \n",t->name,t->value);
    … …  
    91107      fflush(stderr);
    92108    }
    93     return NULL;
    94   }
    95 
    96   static void* dumpMap(map* t){
     109  }
     110
     111  static void dumpMap(map* t){
    97112    map* tmp=t;
    98113    while(tmp!=NULL){
    … …  
    100115      tmp=tmp->next;
    101116    }
    102     return NULL;
    103117  }
    104118
    … …  
    112126  }
    113127
    114   static map* createMap(char* name,char* value){
     128  static map* createMap(const char* name,const char* value){
    115129    map* tmp=(map *)malloc(MAP_SIZE);
    116130    tmp->name=strdup(name);
    … …  
    130144  }
    131145   
    132   static bool hasKey(map* m,char *key){
     146  static bool hasKey(map* m,const char *key){
    133147    map* tmp=m;
    134148    while(tmp!=NULL){
    135       if(strcmp(mtoupper(tmp->name),mtoupper(key))==0)
     149      if(strncasecmp(tmp->name,key,strlen(key))==0)
    136150        return true;
    137151      tmp=tmp->next;
    … …  
    143157  }
    144158
    145   static maps* getMaps(maps* m,char *key){
     159  static maps* getMaps(maps* m,const char *key){
    146160    maps* tmp=m;
    147161    while(tmp!=NULL){
    148       if(strcmp(mtoupper(tmp->name),mtoupper(key))==0)
     162      if(strncasecmp(tmp->name,key,strlen(key))==0){
    149163        return tmp;
     164      }
    150165      tmp=tmp->next;
    151166    }
    … …  
    153168  }
    154169
    155   static map* getMap(map* m,char *key){
     170  static map* getMap(map* m,const char *key){
    156171    map* tmp=m;
    157172    while(tmp!=NULL){
    158       if(strcmp(mtoupper(tmp->name),mtoupper(key))==0)
     173      if(strncasecmp(tmp->name,key,strlen(key))==0){
    159174        return tmp;
     175      }
    160176      tmp=tmp->next;
    161177    }
    … …  
    166182    maps* _tmpm=getMaps(m,key);
    167183    if(_tmpm!=NULL){
    168       map* tmpm=getMap(_tmpm->content,mtoupper(subkey));
    169       return tmpm;
     184      map* _ztmpm=getMap(_tmpm->content,subkey);
     185      return _ztmpm;
    170186    }
    171187    else return NULL;
    172188  }
    173189
    174   static void* freeMap(map** mo){
     190  static void freeMap(map** mo){
    175191    map* _cursor=*mo;
    176192    if(_cursor!=NULL){
     193#ifdef DEBUG
     194      fprintf(stderr,"freeMap\n");
     195#endif
    177196      free(_cursor->name);
    178197      free(_cursor->value);
    … …  
    182201      }
    183202    }
    184         return NULL;
    185   }
    186 
     203  }
     204
     205  static void freeMaps(maps** mo){
     206    maps* _cursor=*mo;
     207    fflush(stderr);
     208    if(_cursor && _cursor!=NULL){
     209#ifdef DEBUG
     210      fprintf(stderr,"freeMaps\n");
     211#endif
     212      free(_cursor->name);
     213      if(_cursor->content!=NULL){
     214        freeMap(&_cursor->content);
     215        free(_cursor->content);
     216      }
     217      if(_cursor->next!=NULL){
     218        freeMaps(&_cursor->next);
     219        free(_cursor->next);
     220      }
     221    }
     222  }
    187223
    188224  typedef struct iotype{
    … …  
    217253    elements* tmp=e;
    218254    while(tmp!=NULL){
    219       mtoupper(key);
    220       mtoupper(tmp->name);
    221       if(strcmp(key,tmp->name)==0)
     255      if(strncasecmp(key,tmp->name,strlen(key))==0)
    222256        return true;
    223257      tmp=tmp->next;
    … …  
    229263    elements* tmp=m;
    230264    while(tmp!=NULL){
    231       mtoupper(tmp->name);
    232       mtoupper(key);
    233       if(strcmp(tmp->name,key)==0)
     265      if(strncasecmp(tmp->name,key,strlen(tmp->name))==0)
    234266        return tmp;
    235267      tmp=tmp->next;
    … …  
    239271
    240272
    241   static void* freeIOType(iotype** i){
     273  static void freeIOType(iotype** i){
    242274    iotype* _cursor=*i;
    243275    if(_cursor!=NULL){
    244276      freeMap(&_cursor->content);
    245277      free(_cursor->content);
    246       freeIOType(&_cursor->next);
    247       free(_cursor->next);
    248     }
    249         return NULL;
     278      if(_cursor->next!=NULL){
     279        freeIOType(&_cursor->next);
     280        free(_cursor->next);
     281      }
     282    }
    250283  }
    251284
    … …  
    253286    elements* tmp=*e;
    254287    if(tmp!=NULL){
    255 #ifdef DEBUG
    256       fprintf(stderr,"FREE 1");
    257 #endif
    258288      free(tmp->name);
    259289      freeMap(&tmp->content);
    260 #ifdef DEBUG
    261       fprintf(stderr,"FREE 2");
    262 #endif
    263290      free(tmp->content);
    264291      freeMap(&tmp->metadata);
    265 #ifdef DEBUG
    266       fprintf(stderr,"FREE 3");
    267 #endif
    268292      free(tmp->metadata);
    269 #ifdef DEBUG
    270       fprintf(stderr,"FREE 4");
    271 #endif
    272293      free(tmp->format);
    273294      freeIOType(&tmp->defaults);
    274 #ifdef DEBUG
    275       fprintf(stderr,"FREE 5");
    276 #endif
    277295      if(tmp->defaults!=NULL)
    278296        free(tmp->defaults);
    279297      freeIOType(&tmp->supported);
    280 #ifdef DEBUG
    281       fprintf(stderr,"FREE 6");
    282 #endif
    283298      if(tmp->supported!=NULL)
    284299        free(tmp->supported);
    285       tmp=tmp->next;
    286     }
    287   }
    288 
    289   static void* freeService(service** s){
     300      freeElements(&tmp->next);
     301    }
     302  }
     303
     304  static void freeService(service** s){
    290305    service* tmp=*s;
    291306    if(tmp!=NULL){
     307      if(tmp->name!=NULL)
     308        free(tmp->name);
    292309      freeMap(&tmp->content);
    293310      if(tmp->content!=NULL)
    … …  
    305322  }
    306323
    307   static void* addMapToMap(map** mo,map* mi){
    308     map* tmp=mi;
    309     map* _cursor=*mo;
    310     while(tmp!=NULL){
    311       if(_cursor==NULL){
    312         *mo=(map*)malloc(MAP_SIZE);
    313         *mo=createMap(tmp->name,tmp->value);
    314         _cursor=*mo;
    315         _cursor->next=NULL;
    316       }
    317       else{
    318         while(_cursor->next!=NULL)
    319           _cursor=_cursor->next;
    320         _cursor->next=createMap(tmp->name,tmp->value);
    321       }
    322       tmp=tmp->next;
    323     }
    324     return NULL;
    325   }
    326 
    327   static void* addMapsToMaps(maps** mo,maps* mi){
    328     maps* tmp=mi;
    329     maps* _cursor=*mo;
    330     while(tmp!=NULL){
    331       if(_cursor==NULL){
    332         *mo=(maps*)malloc(MAP_SIZE);
    333         *mo=mi;
    334         _cursor=*mo;
    335       }
    336       else{
    337         while(_cursor->next!=NULL)
    338           _cursor=_cursor->next;
    339         _cursor->next=tmp;
    340       }
    341       tmp=tmp->next;
    342     }
    343     return NULL;
    344   }
    345 
    346   static void* addMapToIotype(iotype** io,map* mi){
    347     iotype* tmp=*io;
    348     while(tmp!=NULL){
    349       fprintf(stderr,">> CURRENT MAP");
    350       dumpMap(tmp->content);
    351       tmp=tmp->next;
    352     }
    353     tmp=(iotype*)malloc(ELEMENTS_SIZE);
    354     tmp->content=NULL;
    355     tmp->next=NULL;
    356     addMapToMap(&tmp->content,mi);
    357     return NULL;
    358   }
    359 
    360   static void* addToMap(map* m,char* n,char* v){
     324  static void addToMap(map* m,const char* n,const char* v){
    361325    if(hasKey(m,n)==false){
    362326      map* _cursor=m;
    … …  
    367331    else{
    368332      map *tmp=getMap(m,n);
     333      if(tmp->value!=NULL)
     334        free(tmp->value);
    369335      tmp->value=strdup(v);
    370336    }
    371     return NULL;
    372   }
    373 
    374 
    375   static void* dumpElements(elements* e){
     337  }
     338
     339  static void addMapToMap(map** mo,map* mi){
     340    map* tmp=mi;
     341    map* _cursor=*mo;
     342    if(tmp==NULL){
     343      if(_cursor!=NULL){
     344        while(_cursor!=NULL)
     345          _cursor=_cursor->next;
     346        _cursor=NULL;
     347      }else
     348        *mo=NULL;
     349    }
     350    while(tmp!=NULL){
     351      if(_cursor==NULL){
     352        if(*mo==NULL)
     353          *mo=createMap(tmp->name,tmp->value);
     354        else
     355          addToMap(*mo,tmp->name,tmp->value);
     356      }
     357      else{
     358#ifdef DEBUG
     359        fprintf(stderr,"_CURSOR\n");
     360        dumpMap(_cursor);
     361#endif
     362        while(_cursor!=NULL)
     363          _cursor=_cursor->next;
     364        _cursor=createMap(tmp->name,tmp->value);
     365        _cursor->next=NULL;
     366      }
     367      tmp=tmp->next;
     368#ifdef DEBUG
     369      fprintf(stderr,"MO\n");
     370      dumpMap(*mo);
     371#endif
     372    }
     373  }
     374
     375  static void addMapToIoType(iotype** io,map* mi){
     376    iotype* tmp=*io;
     377    while(tmp!=NULL){
     378#ifdef DEBUG
     379      fprintf(stderr,">> CURRENT MAP");
     380      dumpMap(tmp->content);
     381#endif
     382      tmp=tmp->next;
     383    }
     384#ifdef DEBUG
     385    fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     386    fflush(stderr);
     387#endif
     388    tmp=(iotype*)malloc(IOTYPE_SIZE);
     389#ifdef DEBUG
     390    fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     391    fflush(stderr);
     392#endif
     393    tmp->content=NULL;
     394#ifdef DEBUG
     395    fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     396    fflush(stderr);
     397#endif
     398    addMapToMap(&tmp->content,mi);
     399#ifdef DEBUG
     400    fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     401    fflush(stderr);
     402#endif
     403    dumpMap(tmp->content);
     404    tmp->next=NULL;
     405  }
     406
     407
     408  static maps* dupMaps(maps** mo){
     409    maps* _cursor=*mo;
     410    maps* res=NULL;
     411    if(_cursor!=NULL){
     412      res=(maps*)malloc(MAPS_SIZE);
     413      res->name=strdup(_cursor->name);
     414      res->content=NULL;
     415      res->next=NULL;
     416      map* mc=_cursor->content;
     417      if(mc!=NULL){
     418        addMapToMap(&res->content,mc);
     419      }
     420      res->next=dupMaps(&_cursor->next);
     421    }
     422    return res;
     423  }
     424
     425  static void addMapsToMaps(maps** mo,maps* mi){
     426    maps* tmp=mi;
     427    maps* _cursor=*mo;
     428    while(tmp!=NULL){
     429      if(_cursor==NULL){
     430        *mo=dupMaps(&mi);
     431        (*mo)->next=NULL;
     432      }
     433      else{
     434        while(_cursor->next!=NULL)
     435          _cursor=_cursor->next;
     436        _cursor->next=dupMaps(&tmp);
     437      }
     438      tmp=tmp->next;
     439    }
     440  }
     441
     442
     443  static void dumpElements(elements* e){
    376444    elements* tmp=e;
    377445    while(tmp!=NULL){
    … …  
    401469      tmp=tmp->next;
    402470    }
    403     return NULL;
    404   }
    405 
     471  }
    406472
    407473  static elements* dupElements(elements* e){
    408     if(e!=NULL){
    409 #ifdef DEBUG
     474    elements* cursor=e;
     475    elements* tmp=NULL;
     476    if(cursor!=NULL){
     477#ifdef DEBUG
     478      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
    410479      dumpElements(e);
    411 #endif
    412       elements* tmp=(elements*)malloc(ELEMENTS_SIZE);
     480      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     481#endif
     482      tmp=(elements*)malloc(ELEMENTS_SIZE);
    413483      tmp->name=strdup(e->name);
    414484      tmp->content=NULL;
    … …  
    418488      tmp->format=strdup(e->format);
    419489      if(e->defaults!=NULL){
    420         tmp->defaults=(iotype*)malloc(MAP_SIZE);
     490        tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
    421491        tmp->defaults->content=NULL;
     492        addMapToMap(&tmp->defaults->content,e->defaults->content);
    422493        tmp->defaults->next=NULL;
    423         addMapToMap(&tmp->defaults->content,e->defaults->content);
    424         while(e->defaults->next!=NULL){
    425           tmp->defaults->next=(iotype*)malloc(MAP_SIZE);
    426           addMapToMap(&tmp->defaults->next->content,e->defaults->content);
    427         }
    428       }
     494#ifdef DEBUG
     495        fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     496        dumpMap(tmp->defaults->content);
     497#endif
     498      }else
     499        tmp->defaults=NULL;
    429500      if(e->supported!=NULL){
    430         tmp->supported=(iotype*)malloc(MAP_SIZE);
     501        tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
    431502        tmp->supported->content=NULL;
    432503        tmp->supported->next=NULL;
    433504        addMapToMap(&tmp->supported->content,e->supported->content);
     505        iotype *etmp=*(&tmp->supported->next) ;
    434506        iotype *tmp2=e->supported->next;
    435507        while(tmp2!=NULL){
    436           tmp->supported->next=(iotype*)malloc(MAP_SIZE);
    437           addMapToMap(&tmp->supported->next->content,tmp2->content);
     508          etmp=(iotype*)malloc(IOTYPE_SIZE);
     509          etmp->content=NULL;
     510          addMapToMap(&etmp->content,tmp2->content);
     511          etmp->next=NULL;
     512#ifdef DEBUG
     513          fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     514          dumpMap(tmp->defaults->content);
     515#endif
    438516          tmp2=tmp2->next;
     517          etmp=etmp->next;
    439518        }
    440519      }
    441       tmp->next=NULL;
    442       return tmp;
    443     }
    444     return NULL;
    445   }
    446 
    447   static void* addToElements(elements* m,elements* e){
    448     elements* _cursor=m;
     520      else
     521        tmp->supported=NULL;
     522      tmp->next=dupElements(cursor->next);
     523    }
     524    return tmp;
     525  }
     526
     527  static void addToElements(elements** m,elements* e){
     528    elements* _cursor=*m;
    449529    elements* tmp=e;
    450530    if(_cursor==NULL){
    451       m=dupElements(tmp);
    452       return NULL;
    453     }
    454     while(_cursor->next!=NULL)
    455       _cursor=_cursor->next;
    456     _cursor->next=dupElements(tmp);
    457     return NULL;
    458   }
    459 
    460   static void* dumpService(service* s){
     531      *m=dupElements(tmp);
     532    }else{
     533      while(_cursor->next!=NULL)
     534        _cursor=_cursor->next;
     535      _cursor->next=dupElements(tmp);
     536    }
     537  }
     538
     539  static void dumpService(service* s){
    461540    fprintf(stderr,"++++++++++++++++++\nSERVICE [%s]\n++++++++++++++++++\n",s->name);
    462541    if(s->content!=NULL){
    … …  
    475554    }
    476555    fprintf(stderr,"++++++++++++++++++\n");
    477     return NULL;
    478   }
    479 
    480   static void* mapsToCharXXX(maps* m,char*** c){
     556  }
     557
     558  static void mapsToCharXXX(maps* m,char*** c){
    481559    maps* tm=m;
    482560    int i=0;
    … …  
    506584    }
    507585    memcpy(c,tmp,10*10*1024);
    508         return NULL;
    509   }
    510 
    511   static void* charxxxToMaps(char*** c,maps**m){
     586  }
     587
     588  static void charxxxToMaps(char*** c,maps**m){
    512589    maps* trorf=*m;
    513590    int i,j;
    … …  
    526603          trorf->content=createMap(tmp[i][j],tmp[i][j+1]);
    527604        else
    528         addMapToMap(&trorf->content,createMap(tmp[i][j],tmp[i][j+1]));
     605          addToMap(trorf->content,tmp[i][j],tmp[i][j+1]);
    529606      }
    530607      trorf=trorf->next;
    531608    }
    532609    m=&trorf;
    533     return NULL;
    534610  }
    535611

  • trunk/zoo-kernel/service_conf.l

    r1 r9  
    124124/*====================================================*/
    125125attname [a-zA-Z0-9_\-]+
    126 attvalue1       [a-zA-Z0-9_\-.:" "\"\'/\\\(\)]+
     126attvalue1       [\*\+,;@a-zA-Z0-9_\-::.:" "\"\'/\\\(\)]+
    127127
    128128
    … …  
    159159{newline}+{whitesp}*                    {  if (affichetrace==1) fprintf (stderr,"\n\nNEWLINE 1\n") ; return NEWLINE;}
    160160
    161 <INITIAL,HORSBALISE>"["{attname}"]"             {  if (affichetrace==1){ fprintf (stderr,"\n\nANID:%s\n",yytext); fprintf(stderr,"[ZOO: service_conf.l line 161 srlval.chaine=strdup(%s), srlval.chaine=%s]\n",yytext,srlval.chaine);fflush(stderr);}srlval.chaine=strdup(yytext);srlval.chaine[strlen(srlval.chaine)-1]=0;srlval.chaine+=1;if (affichetrace==1){fprintf(stderr,"[ZOO: service_conf.l line 161 srlval.chaine=strdup(%s) done]\n",yytext);fflush(stderr);} return ANID; }
    162 
    163 <INITIAL,HORSBALISE>{attname}             {  if (affichetrace==1){fprintf (stderr,"\n\nATT_NAME:%s\n",yytext); fprintf(stderr,"[ZOO: service_conf.l line 163 srlval.chaine=strdup(%s)]\n",yytext);fflush(stderr);}srlval.chaine=strdup(yytext); if (affichetrace==1){fprintf(stderr,"[ZOO: service_conf.l line 163 srlval.chaine=strdup(%s) done]\n",yytext);fflush(stderr);} return SPAIR; }
    164 
    165 <PAIRSTART,HORSBALISE>{attvalue1}             { if (affichetrace==1){ fprintf (stderr,"\n\nATT_VALUE:%s\n",yytext);fprintf(stderr,"[ZOO: service_conf.l line 165 srlval.chaine=strdup(%s)]\n",yytext);fflush(stderr);}srlval.chaine=strdup(yytext);if (affichetrace==1){fprintf(stderr,"[ZOO: service_conf.l line 165 srlval.chaine=strdup(%s)]\n",yytext);fflush(stderr);BEGIN(INITIAL);} return EPAIR;}
     161<INITIAL,HORSBALISE>"["{attname}"]"             {  srlval.chaine=yytext;return ANID; }
     162
     163<INITIAL,HORSBALISE>{attname}             {  srlval.chaine=yytext; return SPAIR; }
     164
     165<PAIRSTART,HORSBALISE>{attvalue1}             { srlval.chaine=yytext;/*BEGIN(INITIAL);*/ return EPAIR;}
    166166
    167167<PAIRSTART,INITIAL,HORSBALISE>{whitesp}*"="{whitesp}*             {  BEGIN(PAIRSTART);}
    168168
    169 <PAIRSTART,INITIAL,HORSBALISE,DANSBALISE>{newline}+{whitesp}*             { if (affichetrace==1) fprintf (stderr,"\n\nNEWLINE 2\n") ; BEGIN(INITIAL);  return NEWLINE;}
    170 
    171 <INITIAL>"<?"[Xx][Mm][Ll]  {   if (attentionImpossibleDeTrouverXMLDeclapres == 1 || attentionImpossibleDeTrouverPIapres == 1) {/* il y a eut un commentaire ou une balise applicative avant la declaration xml */ fprintf(stderr,"\nerror : a la ligne %d : il y a eut un commentaire ou un PI avant la declaration xml\n",srlineno); exit (10) ; } ; if (affichetrace==1) fprintf (stderr,"\n\nSTARTXMLDECL:%s\n",srtext) ;  return STARTXMLDECL;}
    172 
    173 <INITIAL>"version"{egalevolue}\"1.0\"|"version"{egalevolue}\'1.0\'  {  if (affichetrace==1) fprintf (stderr,"\n\nVERSIONDECL:%s\n",srtext) ;return VERSIONDECL;  }
     169<PAIRSTART,INITIAL,HORSBALISE,DANSBALISE>{newline}+{whitesp}*             { BEGIN(INITIAL);  return NEWLINE;}
     170
     171<INITIAL>"<?"[Xx][Mm][Ll]  {   if (attentionImpossibleDeTrouverXMLDeclapres == 1 || attentionImpossibleDeTrouverPIapres == 1) {/* il y a eut un commentaire ou une balise applicative avant la declaration xml */ fprintf(stderr,"\nerror : a la ligne %d : il y a eut un commentaire ou un PI avant la declaration xml\n",srlineno); exit (10) ; } ; return STARTXMLDECL;}
     172
     173<INITIAL>"version"{egalevolue}\"1.0\"|"version"{egalevolue}\'1.0\'  { return VERSIONDECL;  }
    174174<INITIAL>"version"{egalevolue}\"[^"]*\"|"version"{egalevolue}\'[^']*\'  {/* erreur de version encoding */ fprintf(stderr,"\nerror : a la ligne %d : la version xml n est pas reconnue : %s\n",srlineno,yytext); exit (9) ; }
    175175
    176176
    177 <INITIAL>"encoding"{egalevolue}\"[Ii][Ss][Oo]"-8859-1"\"|"encoding"{egalevolue}\'[Ii][Ss][Oo]"-8859-1"\'  { if (affichetrace==1) fprintf (stderr,"\n\nENCODINGDECL:%s\n",yytext) ; return ENCODINGDECL;}
     177<INITIAL>"encoding"{egalevolue}\"[Ii][Ss][Oo]"-8859-1"\"|"encoding"{egalevolue}\'[Ii][Ss][Oo]"-8859-1"\'  { return ENCODINGDECL;}
    178178<INITIAL>"encoding"{egalevolue}\"[^"]*\"|"encoding"{egalevolue}\'[^']*\'  {/* erreur de version encoding */     fprintf(stderr,"\nerror : a la ligne %d : la version d encodage n est pas reconnue : %s\n",srlineno,yytext); exit (8) ; }
    179179
    180180
    181 <INITIAL>"standalone"{egalevolue}\"yes\"|"standalone"{egalevolue}\'yes\'|"standalone"{egalevolue}\"no\"|"standalone"{egalevolue}\'no\'  { if (affichetrace==1) fprintf (stderr,"\n\nSDDECL:%s\n",yytext) ; return SDDECL;}
     181<INITIAL>"standalone"{egalevolue}\"yes\"|"standalone"{egalevolue}\'yes\'|"standalone"{egalevolue}\"no\"|"standalone"{egalevolue}\'no\'  { return SDDECL;}
    182182
    183183<INITIAL>"standalone"{egalevolue}\"[^"]*\"|"standalone"{egalevolue}\'[^']*\'|"standalone"{egalevolue}\"[^"]*\"|"standalone"{egalevolue}\'[^']*\'  { /* erreur de version encoding */    fprintf(stderr,"\nerror : a la ligne %d : la version standalone n est pas reconnue : %s\n",srlineno,yytext); exit (7) ; }
    184184
    185185
    186 <INITIAL>"?>"  { if (affichetrace==1) fprintf (stderr,"\n\nENDXMLDECL:%s\n",yytext) ; BEGIN(HORSBALISE); return ENDXMLDECL;}
    187 
    188 
    189 <DANSBALISE,INITIAL,HORSBALISE>{S}   { if (affichetrace==1) fprintf (stderr,"\n\nS:'%s'\n",yytext) ; }
    190 
    191 
    192 <HORSBALISE>"<?"[Xx][Mm][Ll]{S}({S}|{chardata})*"?>"|"<?"[Xx][Mm][Ll]"?>"       { if (affichetrace==1) fprintf (stderr,"\n\nPIERROR:%s\n",yytext) ; return PIERROR;}
    193 <INITIAL,HORSBALISE>"<?"([^xX]|([xX][^mM])|([xX][mM][^lL]))({S}|([^?]|("?"[^>])))*"?>"          { attentionImpossibleDeTrouverPIapres=1 ;  if (affichetrace==1) fprintf (stderr,"\n\nPI:%s\n",yytext) ; return PI;}
    194 
    195 
    196 <INITIAL,HORSBALISE>{newline}*"<"                   { if (affichetrace==1) fprintf (stderr,"\n\nINFCAR:%s\n",yytext) ; BEGIN(DANSBALISE); return INFCAR;}
    197 
    198 
    199 <DANSBALISE>">"                 { if (affichetrace==1) fprintf (stderr,"\n\nSUPCAR:%s\n",yytext) ; BEGIN(HORSBALISE);return SUPCAR;}
    200 
    201 
    202 <DANSBALISE>"/"         {if (affichetrace==1) fprintf (stderr,"\n\nSLASH:%s\n",yytext) ; return SLASH;}
    203 
    204 
    205 <DANSBALISE>{egalevolue}                        {if (affichetrace==1) fprintf (stderr,"\n\nEq:'%s'\n",yytext) ; return Eq;}
    206 
    207 
    208 <DANSBALISE>{Name}                      {if (affichetrace==1){fprintf (stderr,"\n\nID:%s\n",yytext) ; fprintf(stderr,"[ZOO: service_conf.l line 208 srlval.chaine=strdup(%s)]\n",yytext);fflush(stderr);}srlval.s=strdup(yytext);if (affichetrace==1){fprintf(stderr,"[ZOO: service_conf.l line 208 srlval.chaine=strdup(%s)]\n",yytext);fflush(stderr);}return ID;}
    209 
    210 
    211 <DANSBALISE>{attvalue}          {if (affichetrace==1) fprintf (stderr,"\n\nATTVALUE:%s\n",yytext) ; return ATTVALUE;}
     186<INITIAL>"?>"  { BEGIN(HORSBALISE); return ENDXMLDECL;}
     187
     188
     189<DANSBALISE,INITIAL,HORSBALISE>{S}   { }
     190
     191
     192<HORSBALISE>"<?"[Xx][Mm][Ll]{S}({S}|{chardata})*"?>"|"<?"[Xx][Mm][Ll]"?>"       { return PIERROR;}
     193<INITIAL,HORSBALISE>"<?"([^xX]|([xX][^mM])|([xX][mM][^lL]))({S}|([^?]|("?"[^>])))*"?>"          { attentionImpossibleDeTrouverPIapres=1 ; return PI;}
     194
     195
     196<INITIAL,HORSBALISE>{newline}*"<"                   { BEGIN(DANSBALISE); return INFCAR;}
     197
     198
     199<DANSBALISE>">"                 { BEGIN(HORSBALISE);return SUPCAR;}
     200
     201
     202<DANSBALISE>"/"         {return SLASH;}
     203
     204
     205<DANSBALISE>{egalevolue}                        {return Eq;}
     206
     207
     208<DANSBALISE>{Name}                      {srlval.chaine=strdup(yytext);return ID;}
     209
     210
     211<DANSBALISE>{attvalue}          {return ATTVALUE;}
    212212
    213213
    … …  
    215215
    216216
    217 <INITIAL,DANSBALISE,HORSBALISE>.|\n     {if (affichetrace==1) fprintf(stderr,"error : ligne %d : caractere non reconnu '%s'\n",srlineno,yytext);}
     217<INITIAL,DANSBALISE,HORSBALISE>.|\n     {fprintf(stderr,"error : ligne %d : caractere non reconnu '%s'\n",srlineno,yytext);}
    218218
    219219%%

  • trunk/zoo-kernel/service_conf.y

    r1 r9  
    1313#include <ctype.h>
    1414#include <service.h>
    15 #include <vector>
     15  //#include <vector>
    1616
    1717static int tmp_count=1;
    … …  
    6565// srlex
    6666extern int srlex(void);
    67 
    68 vector<char*> lattribute;
     67extern int srlex_destroy(void);
     68
     69//vector<char*> lattribute;
    6970
    7071%}
    … …  
    132133 : STag contentetoile ETag     
    133134{
    134   if (strcmp($1,$3) != 0)
     135  /*if (strcasecmp($1,$3) != 0)
    135136    {
    136       //srerror("Opening and ending tag mismatch");
    137137      fprintf(stderr,"Opening and ending tag mismatch\n  ::details : tag '%s' et '%s' \n",$1,$3);
    138       lattribute.clear();
     138      //lattribute.clear();
    139139      //return 1;
    140     }
     140      }*/
     141  free($3);
    141142}
    142143// pour neutre
    … …  
    159160  /* parce que cet element est reconnu AVANT la balise fermante */
    160161  /* et APRES l'analyse des eventuelles balises internes ou successeur */
    161   lattribute.clear();
    162        
     162  //lattribute.clear();
     163
    163164  if(my_service->content==NULL){
    164165#ifdef DEBUG_SERVICE_CONF
    165166    fprintf(stderr,"NO CONTENT\n");
    166167#endif
    167     //addMapToMap(&my_service->content,current_content);
    168     //freeMap(&current_content);
    169     my_service->content=current_content;
     168    addMapToMap(&my_service->content,current_content);
     169    freeMap(&current_content);
     170    free(current_content);
    170171    current_content=NULL;
    171172    my_service->metadata=NULL;
    … …  
    173174  }
    174175
    175   if(strcmp($2,"DataInputs")==0){
     176  if(strncasecmp($2,"DataInputs",10)==0){
    176177    if(wait_mainmetadata==true){
    177       if(my_service->metadata==NULL)
    178         my_service->metadata=current_content;
    179       else{
    180         addMapToMap(&my_service->metadata,current_content);
    181         freeMap(&current_content);
    182       }
     178      addMapToMap(&my_service->metadata,current_content);
     179      freeMap(&current_content);
     180      free(current_content);
    183181      current_content=NULL;
    184182    }
    … …  
    208206  }
    209207  else
    210     if(strcmp($2,"DataOutputs")==0){
     208    if(strncasecmp($2,"DataOutputs",11)==0){
    211209      if(wait_inputs==true){
    212210#ifdef DEBUG_SERVICE_CONF
    213211        fprintf(stderr,"(DATAOUTPUTS) DUP INPUTS current_element\n");
    214 #endif
    215         if(my_service->inputs==NULL)
     212        fprintf(stderr,"CURRENT_ELEMENT\n");
     213        dumpElements(current_element);
     214        fprintf(stderr,"SERVICE INPUTS\n");
     215        dumpElements(my_service->inputs);
     216        dumpService(my_service);
     217#endif
     218        if(my_service->inputs==NULL){
    216219          my_service->inputs=dupElements(current_element);
     220          my_service->inputs->next=NULL;
     221        }
    217222        else
    218           addToElements(my_service->inputs,current_element);
    219 #ifdef DEBUG_SERVICE_CONF
     223          addToElements(&my_service->inputs,current_element);
     224#ifdef DEBUG_SERVICE_CONF
     225        fprintf(stderr,"CURRENT_ELEMENT\n");
    220226        dumpElements(current_element);
     227        fprintf(stderr,"SERVICE INPUTS\n");
    221228        dumpElements(my_service->inputs);
    222229        fprintf(stderr,"(DATAOUTPUTS) FREE current_element\n");
    … …  
    245252    }
    246253    else
    247       if(strcmp($2,"MetaData")==0){
     254      if(strncasecmp($2,"MetaData",8)==0){
    248255        current_data=3;
    249256        if(current_element!=NULL){
    … …  
    263270      }
    264271      else
    265         if(strcmp($2,"ComplexData")==0 || strcmp($2,"LiteralData")==0
    266         || strcmp($2,"ComplexOutput")==0 || strcmp($2,"LiteralOutput")==0){
     272        if(strncasecmp($2,"ComplexData",11)==0 || strncasecmp($2,"LiteralData",10)==0
     273           || strncasecmp($2,"ComplexOutput",13)==0 || strncasecmp($2,"LiteralOutput",12)==0){
    267274          current_data=4;
    268275          if(wait_metadata==true){
    269276            if(current_content!=NULL){
    270               current_element->metadata=current_content;
     277              addMapToMap(&current_element->metadata,current_content);
    271278              current_element->next=NULL;
    272279              current_element->format=$2;
    273280              current_element->defaults=NULL;
     281              current_element->supported=NULL;
     282              freeMap(&current_content);
     283              free(current_content);
    274284            }
    275           }else{ // No MainMetaData
    276             //addMapToMap(&current_element->content,current_content);
    277             //freeMap(&current_content);
    278             //free(current_content);
    279             current_element->content=current_content;
     285          }else{
     286            // No MainMetaData
     287            addMapToMap(&current_element->content,current_content);
     288            freeMap(&current_content);
     289            free(current_content);
    280290            current_element->metadata=NULL;
    281291            current_element->next=NULL;
    282292            current_element->format=$2;
    283293            current_element->defaults=NULL;
     294            current_element->supported=NULL;
    284295          }
    285296          current_content=NULL;
    … …  
    287298        }
    288299        else
    289           if(strcmp($2,"Default")==0){
     300          if(strncasecmp($2,"Default",7)==0){
    290301            wait_defaults=true;
    291302            current_data=5;
    292303          }
    293304          else
    294             if(strcmp($2,"Supported")==0){
     305            if(strncasecmp($2,"Supported",9)==0){
    295306              wait_supporteds=true;
    296307              if(wait_defaults==true){
    … …  
    304315  printf("* Identifiant : %s\n",$2);
    305316#endif
    306                
    307317  /* et on renvoie l'identifiant de balise afin de pouvoir le comparer */
    308318  /* avec la balise jumelle fermante ! */
    309319  $$ = $2 ;
     320  /*if($2!=NULL)
     321    free($2);*/
    310322}
    311323 ;
    … …  
    338350  printf ("attribute : %s\n",$1) ;
    339351#endif
    340   for(int i=0;i < lattribute.size(); i++)
     352  /*for(int i=0;i < lattribute.size(); i++)
    341353    {
    342354      if (strcmp($1,lattribute.at(i)) == 0)
    343355        {
    344356          fprintf (stderr,"attributs identiques : %d -- %s , %s",i,lattribute.at(i),$1) ;
    345           //srerror("attribut redondant !:");
    346357        }
    347358    }
    348   lattribute.push_back($1);
     359    lattribute.push_back($1);*/
     360  free($1);
    349361}
    350362 ;
    … …  
    359371//======================================================
    360372EmptyElemTag
    361  : INFCAR ID Attributeetoile SLASH SUPCAR       {lattribute.clear();/* voir Stag */}
     373 : INFCAR ID Attributeetoile SLASH SUPCAR       {/*lattribute.clear();/* voir Stag */}
    362374 ;
    363375//======================================================
    … …  
    387399    current_data=previous_data;
    388400    if(current_element->defaults==NULL){
    389       current_element->defaults=(iotype*)malloc(MAP_SIZE);
    390     }
    391     current_element->defaults->content=current_content;
     401      current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
     402      current_element->defaults->content=NULL;
     403    }
     404    addMapToMap(&current_element->defaults->content,current_content);
     405    freeMap(&current_content);
     406    free(current_content);
    392407    current_element->defaults->next=NULL;
    393408    wait_defaults=false;
    … …  
    398413    current_data=previous_data;
    399414    if(current_element->supported==NULL){
    400       current_element->supported=(iotype*)malloc(MAP_SIZE);
    401       current_element->supported->content=current_content;
     415      //addMapToIoType(&current_element->supported,current_content);
     416      current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
     417      current_element->supported->content=NULL;
     418      addMapToMap(&current_element->supported->content,current_content);
     419      freeMap(&current_content);
     420      free(current_content);
    402421      current_element->supported->next=NULL;
    403       /**
    404        * Need to free this ressource (HERE ?)
     422      current_content=NULL;
     423    }
     424    else{
     425#ifdef DEBUG
     426      // Currently we support only one supported format
     427      fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n");
     428#endif
     429      //addMapToIoType(&current_element->supported,current_content);
     430      /*iotype* iotmp=*(&current_element->supported);
     431      while(iotmp!=NULL){
     432        dumpMap(iotmp->content);
     433        iotmp=iotmp->next;
     434      }
     435      iotmp=(iotype*)malloc(IOTYPE_SIZE);
     436      iotmp->content=NULL;
     437      addMapToMap(&iotmp->content,current_content);
     438      iotmp->next=NULL;
     439      dumpElements(current_element);
     440      fprintf(stderr,"SECOND SUPPORTED FORMAT MAP START !!!!\n");
     441      dumpMap(current_content);
     442      fprintf(stderr,"SECOND SUPPORTED FORMAT MAP END !!!!\n");*/
     443      freeMap(&current_content);
    405444      free(current_content);
    406       */
    407     }
    408     else{
    409       /*current_element->supported->next=(iotype*)malloc(sizeof(iotype*));
    410       current_element->supported->next->content=NULL;
    411       current_element->supported->next->next=NULL;
    412       iotype* tmp1=current_element->supported;
    413       while(tmp1!=NULL){
    414         addMapToMap(&current_element->supported->next->content,current_content);
    415         freeMap(&current_content);
    416 #ifdef DEBUG_SERVICE_CONF
    417         fprintf(stderr,"LINE 409");
    418 #endif
    419         free(current_content);
    420         current_content=NULL;
    421         tmp1=tmp1->next;
    422         }*/
     445      current_content=NULL;
     446      /*freeMap(&iotmp->content);
     447      free(&iotmp->content);
     448      free(iotype);*/
     449#ifdef DEBUG
     450      // Currently we support only one supported format
     451      fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n");
     452#endif
    423453    }
    424454    current_content=NULL;
    … …  
    472502//======================================================
    473503
    474 pair: PAIR {  if(debug) fprintf(stderr,"PAIR FOUND !!\n"); }
     504pair: PAIR {  if(debug) fprintf(stderr,"PAIR FOUND !!\n");if(curr_key!=NULL){free(curr_key);curr_key=NULL;} }
    475505| EPAIR {
    476506#ifdef DEBUG_SERVICE_CONF
    … …  
    495525    dumpMap(current_content);
    496526    fprintf(stderr,"addToMap(current_content,%s,%s) !! \n",curr_key,$1);
    497    
    498 #endif
    499     //map* tmp1=createMap(curr_key,$1);
     527#endif
    500528    addToMap(current_content,curr_key,$1);
    501     //freeMap(&tmp1);
    502     //free(tmp1);
    503529#ifdef DEBUG_SERVICE_CONF
    504530    fprintf(stderr,"addToMap(current_content,%s,%s) end !! \n",curr_key,$1);
    505531#endif   
    506532  }
    507   //free(curr_key);
    508   curr_key=NULL;
    509533#ifdef DEBUG_SERVICE_CONF
    510534  fprintf(stderr,"EPAIR FOUND !! \n");
    … …  
    513537  fflush(stderr);
    514538#endif
    515   }
    516 | SPAIR  { curr_key=$1; if(debug) fprintf(stderr,"SPAIR FOUND !!\n"); }
     539  if(curr_key!=NULL){
     540    free(curr_key);
     541    curr_key=NULL;
     542  }
     543  }
     544| SPAIR  { curr_key=strdup($1);/*free($1);*/if(debug) fprintf(stderr,"SPAIR FOUND !!\n"); }
    517545 ;
    518546
    … …  
    522550  if(data==-1){
    523551    data=1;
    524     my_service->name=$1;
     552    char *cen=strdup($1);
     553    my_service->name=(char*)malloc((strlen(cen)-1)*sizeof(char*));
     554    cen[strlen(cen)-1]=0;
     555    cen+=1;
     556    sprintf(my_service->name,"%s",cen);
     557    cen-=1;
     558    free(cen);
    525559    my_service->content=NULL;
    526560    my_service->metadata=NULL;
    … …  
    530564    if(current_data==1){
    531565      if(my_service->content!=NULL && current_element->name!=NULL){
    532         //fprintf(stderr,"ELEMENT (%s)",current_element->name);
    533566        if(my_service->inputs==NULL){
    534 #ifdef DEBUG_SERVICE_CONF
    535           fprintf(stderr,"count (%i) (%s)\n",tmp_count%2,$1);
    536           fflush(stderr);
    537 #endif
    538           //if(tmp_count==1){
    539 #ifdef DEBUG_SERVICE_CONF
    540           fprintf(stderr,"(DATAINPUTS - 464)DUP current_element\n");
    541           dumpElements(current_element);
    542 #endif
    543567          my_service->inputs=dupElements(current_element);
    544 #ifdef DEBUG_SERVICE_CONF
    545           fprintf(stderr,"(DATAINPUTS - 466)FREE current_element\n");
    546 #endif
    547           freeElements(&current_element);
    548           current_element=NULL;
     568          my_service->inputs->next=NULL;
    549569          tmp_count++;
    550570        }
    551571        else{
    552           addToElements(my_service->inputs,current_element);
    553 #ifdef DEBUG_SERVICE_CONF
    554           fprintf(stderr,"(DATAINPUTS - 6)FREE current_element (after adding to allread existing inputs)");
    555 #endif
    556           freeElements(&current_element);
     572          addToElements(&my_service->inputs,current_element);
    557573        }
    558574#ifdef DEBUG_SERVICE_CONF
     575        fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__);
     576        dumpElements(current_element);
     577        fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__);
    559578        dumpElements(my_service->inputs);
    560579#endif
     580        freeElements(&current_element);
    561581        free(current_element);
    562582        current_element=NULL;
    … …  
    582602        fprintf(stderr,"(DATAINPUTS - 501) SET NAME OF current_element\n");
    583603#endif
    584         current_element->name=strdup($1);
     604        char *cen=strdup($1);
     605        current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char*));
     606        cen[strlen(cen)-1]=0;
     607        cen+=1;
     608        sprintf(current_element->name,"%s",cen);
     609        cen-=1;
     610        free(cen);
    585611#ifdef DEBUG_SERVICE_CONF
    586612        fprintf(stderr,"NAME IN %s (current - %s)\n",$1,current_element->name);
    … …  
    604630            if(my_service->inputs==NULL){
    605631              my_service->inputs=dupElements(current_element);
     632              my_service->inputs->next=NULL;
    606633            }
    607634            else{
    … …  
    609636              fprintf(stderr,"LAST NAME IN %s (current - %s)\n",$1,current_element->name);
    610637#endif
    611               addToElements(my_service->inputs,current_element);
     638              addToElements(&my_service->inputs,current_element);
    612639            }
    613640#ifdef DEBUG_SERVICE_CONF
    614641            dumpElements(current_element);
    615             fprintf(stderr,"(DATAOUTPUTS - 531) FREE current_element\n");
     642            fprintf(stderr,"(DATAOUTPUTS) FREE current_element %s %i\n",__FILE__,__LINE__);
    616643#endif
    617644            freeElements(&current_element);
    618             free(&current_element);
    619 #ifdef DEBUG_SERVICE_CONF
    620             fprintf(stderr,"free OUTPUTS\n");
    621 #endif
     645            free(current_element);
    622646            current_element=NULL;
    623647#ifdef DEBUG_SERVICE_CONF
    624             fprintf(stderr,"(DATAOUTPUTS - 536) ALLOCATE current_element\n");
     648            fprintf(stderr,"(DATAOUTPUTS) ALLOCATE current_element %s %i\n",__FILE__,__LINE__);
    625649#endif
    626650            current_element=(elements*)malloc(ELEMENTS_SIZE);
    … …  
    638662            fprintf(stderr,"(DATAOUTPUTS - 545) SET NAME OF current_element\n");
    639663#endif
    640             current_element->name=strdup($1);
     664            char *cen=strdup($1);
     665            current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char*));
     666            cen[strlen(cen)-1]=0;
     667            cen+=1;
     668            sprintf(current_element->name,"%s",cen);
     669            cen-=1;
     670            free(cen);
    641671            current_element->content=NULL;
    642672            current_element->metadata=NULL;
    … …  
    647677          }
    648678          wait_inputs=false;
     679          dumpMap(current_content);
    649680          current_content=NULL;
    650681        }
    … …  
    655686            fprintf(stderr,"(DATAOUTPUTS - 545) SET NAME OF current_element\n");
    656687#endif
    657             current_element->name=strdup($1);
     688            char *cen=strdup($1);
     689            current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char*));
     690            cen[strlen(cen)-1]=0;
     691#ifdef DEBUG
     692            fprintf(stderr,"tmp %s\n",cen);
     693#endif
     694            cen+=1;
     695            sprintf(current_element->name,"%s",cen);
     696            cen-=1;
     697            free(cen);
    658698            current_element->content=NULL;
    659699            current_element->metadata=NULL;
    … …  
    726766  if (srin==NULL){
    727767    fprintf(stderr,"error : le fichier specifie n'existe pas ou n'est pas accessible en lecture\n") ;
    728     return 22;
    729   }
    730 
    731   //printf(" ");
     768    return -1;
     769  }
     770
    732771  int resultatYYParse = srparse() ;
    733772 
    … …  
    738777#endif
    739778      my_service->outputs=dupElements(current_element);
     779      my_service->outputs->next=NULL;
     780      freeElements(&current_element);
     781      free(current_element);
    740782      current_element=NULL;
    741783    }
    … …  
    744786      fprintf(stderr,"(DATAOUTPUTS - 628) COPY current_element\n");
    745787#endif
    746       addToElements(my_service->outputs,current_element);
     788      addToElements(&my_service->outputs,current_element);
    747789    }
    748790#ifdef DEBUG_SERVICE_CONF
    … …  
    750792#endif
    751793    freeElements(&current_element);
     794    free(current_element);
     795    current_element=NULL;
    752796  }
    753797  if(current_element!=NULL){
    754798    freeElements(&current_element);
    755799    fprintf(stderr,"LINE 709");
    756     //free(current_element);
     800    free(current_element);
    757801    current_element=NULL;
    758802  }
    … …  
    760804    freeMap(&current_content);
    761805    fprintf(stderr,"LINE 715");
    762     //free(current_content);
     806    free(current_content);
    763807    current_content=NULL;
    764808  }
    … …  
    769813  *service=my_service;
    770814
     815  srlex_destroy();
    771816  return resultatYYParse;
    772817}

  • 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}

  • trunk/zoo-kernel/service_internal.h

    r1 r9  
    5353#include <libxml/parser.h>
    5454  static char* SERVICE_URL;
     55  static xmlNsPtr usedNs[5];
     56  static char* nsName[5];
     57  static int nbNs=0;
     58
    5559
    5660  void URLDecode(char *);
    5761  char *url_encode(char *);
     62  char* getEncoding(maps*);
     63
     64  int zooXmlSearchForNs(char*);
     65  int zooXmlAddNs(xmlNodePtr,char*,char*);
     66  void zooXmlCleanupNs();
    5867 
    5968  void printExceptionReportResponse(maps*,map*);
    60   void printProcessResponse1(maps*,map*,int,service*,char*,int,maps*,maps*);
    61   void printProcessResponse(maps*,int,service*,char*,int,map*,map*);
    62   void printGetCapabilitiesResponse(service**,int,char*,maps*);
     69  void printProcessResponse(maps*,map*,int,service*,char*,int,maps*,maps*);
    6370  xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr,char*,maps*);
    6471  void printGetCapabilitiesForProcess(maps*,xmlNodePtr,service*);
    65   void printGetCapabilitiesDocument(xmlDocPtr);
    66   void printDescribeProcessResponse(service*,char*);
    6772  xmlNodePtr printDescribeProcessHeader(xmlDocPtr,char*,maps*);
    68   void printDescribeProcessForProcess(maps*,xmlNodePtr,service**,int);
    69   void printDescribeProcessDocument(xmlDocPtr);
    70   void printDocument(xmlDocPtr);
     73  void printDescribeProcessForProcess(maps*,xmlNodePtr,service*,int);
     74  void printDocument(maps*,xmlDocPtr,int);
    7175  void printDescription(xmlNodePtr,xmlNsPtr,char*,map*);
    72   void printIOType1(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,char*);
    73   void printIOType(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,map*,char*);
     76  void printIOType(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,char*);
    7477  void printOutputDefinitions1(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,char*);
    75   void printOutputDefinitions(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,map*,char*);
    7678 
    7779  void outputResponse(service*,maps*,maps*,map*,int,maps*,int);
    … …  
    7981  char *base64(const unsigned char*,int);
    8082
    81   void addDefaultValues(maps**,elements*,maps*,char*);
     83  char* addDefaultValues(maps**,elements*,maps*,char*);
     84
     85  /*defined in zoo_loader.c*/
     86  int errorException(maps *m, const char *message, const char *errorcode);
    8287
    8388#ifdef __cplusplus

  • trunk/zoo-kernel/service_internal_java.c

    r1 r9  
    8686    addToMap(err,"code","NoApplicableCode");
    8787    printExceptionReportResponse(m,err);
     88    freeMap(&err);
     89    free(err);
    8890    (*jvm)->DestroyJavaVM(jvm);
    8991    return 1;
    … …  
    148150        addToMap(err,"code","NoApplicableCode");
    149151        printExceptionReportResponse(m,err);
     152        freeMap(&err);
     153        free(err);
    150154        (*jvm)->DestroyJavaVM(jvm);
    151         return 1;
     155        return -1;
    152156      }
    153157    }
    … …  
    155159      char tmpS[1024];
    156160      sprintf(tmpS, "Cannot find function %s \n", s->name);
    157       map* tmps=createMap("text",tmpS);
    158       printExceptionReportResponse(m,tmps);
     161      map* err=createMap("text",tmpS);
     162      printExceptionReportResponse(m,err);
     163      freeMap(&err);
     164      free(err);
    159165      (*jvm)->DestroyJavaVM(jvm);
    160       exit(-1);
     166      return -1;
    161167    }
    162168  }else{
    163169    char tmpS[1024];
    164170    sprintf(tmpS, "Cannot find function %s \n", tmp->value);
    165     map* tmps=createMap("text",tmpS);
    166     printExceptionReportResponse(m,tmps);
    167     if (PyErr_Occurred())
    168       PyErr_Print();
     171    map* err=createMap("text",tmpS);
     172    printExceptionReportResponse(m,err);
     173    freeMap(&err);
     174    free(err);
     175    (*jvm)->DestroyJavaVM(jvm);
     176    return -1;
    169177  }
    170178  (*jvm)->DestroyJavaVM(jvm);
    … …  
    312320    cmap->next=NULL;
    313321    if(final_res==NULL){
    314       final_res=cmap;
     322      final_res=dupMaps(&cmap);
    315323    }else
    316       addMapsToMaps(final_res,cmap);
     324      addMapsToMaps(&final_res,cmap);
    317325    final_res->next=NULL;
     326    freeMaps(&cmap);
     327    free(cmap);
     328    cmap=NULL;
    318329    res=NULL;
    319330  }

  • trunk/zoo-kernel/service_internal_js.c

    r1 r9  
    3030                   maps **inputs,maps **outputs)
    3131{
     32  maps* main=*main_conf;
     33  maps* _inputs=*inputs;
     34  maps* _outputs=*outputs;
     35
    3236  /* The class of the global object. */
    3337  JSClass global_class = {
    … …  
    4751  if (rt == NULL)
    4852    return 1;
    49 
     53 
    5054  /* Create a context. */
    51   cx = JS_NewContext(rt, 8192);
     55  cx = JS_NewContext(rt,8192);
    5256  if (cx == NULL){
    5357    return 1;
    … …  
    7882  map* tmpm1=getMap(request,"metapath");
    7983  map* tmpm2=getMap(s->content,"serviceProvider");
    80   char *filename[strlen(tmpm1->value)+strlen(tmpm2->value)+6];
     84  char filename[strlen(tmpm1->value)+strlen(tmpm2->value)+6];
    8185  char ntmp[1024];
    8286  getcwd(ntmp,1024);
    … …  
    8791  uint16 lineno;
    8892  jsval rval;
    89   FILE *jsfile=fopen(filename,"rb");
     93  FILE *jsfile=fopen(filename,"r");
    9094  JSBool ok ;
    91   JSScript *script = JS_CompileFileHandle(cx, global, filename, jsfile);
    92   if(script){
     95  JSScript *script = JS_CompileFileHandle(cx, global, filename,jsfile);
     96  if(script!=NULL){
    9397    (void)JS_ExecuteScript(cx, global, script, &rval);
    9498  }
    … …  
    102106    JS_DestroyRuntime(rt);
    103107    JS_ShutDown();
     108    fclose(jsfile);
    104109    exit(-1);
    105110  }
    106111  /* Call a function in obj's scope. */
    107112  jsval argv[3];
    108   argv[0] = OBJECT_TO_JSVAL(JSObject_FromMaps(cx,*main_conf));
    109   argv[1] = OBJECT_TO_JSVAL(JSObject_FromMaps(cx,*inputs));
    110   argv[2] = OBJECT_TO_JSVAL(JSObject_FromMaps(cx,*outputs));
    111   jsval rval1;
     113  JSObject *jsargv1=JSObject_FromMaps(cx,*main_conf);
     114  argv[0] = OBJECT_TO_JSVAL(jsargv1);
     115  JSObject *jsargv2=JSObject_FromMaps(cx,*inputs);
     116  argv[1] = OBJECT_TO_JSVAL(jsargv2);
     117  JSObject *jsargv3=JSObject_FromMaps(cx,*outputs);
     118  argv[2] = OBJECT_TO_JSVAL(jsargv3);
     119  jsval rval1=JSVAL_NULL;
    112120#ifdef JS_DEBUG
    113121  fprintf(stderr, "object %p\n", (void *) argv[2]);
    … …  
    121129
    122130  JSObject *d;
    123   if (ok==JS_TRUE) {
     131  if (ok==JS_TRUE && JSVAL_IS_OBJECT(rval1)==JS_TRUE) {
    124132#ifdef JS_DEBUG
    125133    fprintf(stderr,"Function run sucessfully !\n");
    … …  
    127135    /* Should get a number back from the service function call. */
    128136    ok = JS_ValueToObject(cx, rval1, &d);
    129     if (ok==JS_TRUE) {
    130 #ifdef JS_DEBUG
    131       fprintf(stderr,"Function run sucessfully !\n");
    132 #endif
    133       /*char tmpres[10];
    134       sprintf(tmpres,"%p",(void *)d);
    135       res=atoi(tmpres);*/
    136     }
    137137  }else{
    138138    /* Unable to run JS function */
    139139    char tmp1[1024];
    140     //sprintf(tmp1,"Unable to run %s from the JavScript file %s",s->name,filename);
     140    if(strlen(dbg)==0)
     141      sprintf(dbg,"No result was found after the function call");
    141142    sprintf(tmp1,"Unable to run %s from the JavScript file %s : \n %s",s->name,filename,dbg);
    142143    fprintf(stderr,"%s",tmp1);
    143144    map* err=createMap("text",tmp1);
    144     addMapToMap(err,createMap("code","NoApplicableCode"));
     145    addToMap(err,"code","NoApplicableCode");
    145146    printExceptionReportResponse(*main_conf,err);
     147    freeMap(&err);
     148    free(err);
    146149    JS_DestroyContext(cx);
    147150    JS_DestroyRuntime(rt);
    148151    JS_ShutDown();
     152    // Should return -1 here but the unallocation won't work from zoo_service_loader.c line 1847
    149153    exit(-1);
    150154  }
    151155
    152156  jsval t=OBJECT_TO_JSVAL(d);
    153   //JSVAL_TO_OBJECT(t);
    154   if(JS_IsArrayObject(cx,t)){
     157  if(JS_IsArrayObject(cx,d)){
    155158#ifdef JS_DEBUG
    156159    fprintf(stderr,"An array was returned !\n");
    157160#endif
    158     jsdouble len;
    159     if((JS_GetArrayLength(cx, t, &len)==JS_FALSE)){
     161    jsint len;
     162    if((JS_GetArrayLength(cx, d, &len)==JS_FALSE)){
    160163#ifdef JS_DEBUG
    161164      fprintf(stderr,"outputs array is empty\n");
    … …  
    163166    }
    164167    jsval tmp1;
    165     JSBool hasResult=JS_GetElement(cx,t,0,&tmp1);
     168    JSBool hasResult=JS_GetElement(cx,d,0,&tmp1);
    166169    res=JSVAL_TO_INT(tmp1);
    167170#ifdef JS_DEBUG
    … …  
    169172#endif
    170173    jsval tmp2;
    171     JSBool hasElement=JS_GetElement(cx,t,1,&tmp2);
    172     out=mapsFromJSObject(cx,tmp2);
    173     *outputs=out;
     174    JSBool hasElement=JS_GetElement(cx,d,1,&tmp2);
     175    if(hasElement==JS_TRUE){
     176      *outputs=mapsFromJSObject(cx,tmp2);
     177    }
    174178  }
    175179  else{
    176     //#ifdef JS_DEBUG
    177     fprintf(stderr,"The service didn't return an array !\n");
    178     //#endif
     180#ifdef JS_DEBUG
     181    fprintf(stderr,"The serice didn't return an array !\n");
     182#endif
    179183    jsval tmp1;
    180     JSBool hasResult=JS_GetProperty(cx,t,"result",&tmp1);
     184    JSBool hasResult=JS_GetProperty(cx,d,"result",&tmp1);
    181185    res=JSVAL_TO_INT(tmp1);
    182186
    183     //#ifdef JS_DEBUG
     187#ifdef JS_DEBUG
    184188    fprintf(stderr," * %d * \n",res);
    185     //#endif
     189#endif
    186190    jsval tmp2;
    187     JSBool hasElement=JS_GetProperty(cx,t,"outputs",&tmp2);
     191    JSBool hasElement=JS_GetProperty(cx,d,"outputs",&tmp2);
    188192    if(!hasElement)
    189193      fprintf(stderr,"No outputs property returned\n");
    190     if(JS_IsArrayObject(cx,tmp2))
     194    if(JS_IsArrayObject(cx,JSVAL_TO_OBJECT(tmp2)))
    191195      fprintf(stderr,"outputs is array an as expected\n");
    192196    else
    193197      fprintf(stderr,"outputs is not an array as expected\n");
    194     out=mapsFromJSObject(cx,tmp2);
     198    *outputs=mapsFromJSObject(cx,tmp2);
    195199#ifdef JS_DEBUG
    196200    dumpMaps(out);
    197201#endif
    198     *outputs=out;
    199   }
    200 
    201   *inputs=mapsFromJSObject(cx,argv[1]);
    202   *main_conf=mapsFromJSObject(cx,argv[0]);
    203 
    204  
    205   //}
    206   //else
    207   // ERROR
    208   //;
     202  }
    209203
    210204  /* Cleanup. */
    211   JS_MaybeGC(cx);
     205  // The JS_MaybeGC call imply segmentation fault
     206  //JS_MaybeGC(cx);
    212207  JS_DestroyScript(cx, script);
    213   JS_DestroyContext(cx);
     208  // If we use the DestroyContext as requested to release memory then we get
     209  // issue getting back the main configuration maps after coming back to the
     210  // runRequest function ...
     211  //JS_DestroyContext(cx);
    214212  JS_DestroyRuntime(rt);
    215213  JS_ShutDown();
    216   fflush(stderr);
    217214#ifdef JS_DEBUG
    218215  fprintf(stderr,"Returned value %d\n",res);
    … …  
    223220JSObject* JSObject_FromMaps(JSContext *cx,maps* t){
    224221  JSObject *res = JS_NewArrayObject(cx, 0, NULL);
     222  if(res==NULL)
     223    fprintf(stderr,"Array Object is NULL!\n");
    225224  maps* tmp=t;
    226225  while(tmp!=NULL){
    … …  
    247246  while(tmpm!=NULL){
    248247    jsval jsstr = STRING_TO_JSVAL(JS_NewString(cx,tmpm->value,strlen(tmpm->value)));
    249     JS_SetProperty(cx, resf, tmpm->name,&jsstr);
     248    JS_SetProperty(cx, res, tmpm->name,&jsstr);
    250249#ifdef JS_DEBUG
    251250    fprintf(stderr,"%s => %s\n",tmpm->name,tmpm->value);
    … …  
    259258  maps *res=NULL;
    260259  maps *tres=NULL;
    261   JSVAL_TO_OBJECT(t);
     260  jsint oi=0;
     261  JSObject* tt=JSVAL_TO_OBJECT(t);
    262262#ifdef JS_DEBUG
    263263  fprintf(stderr,"Is finally an array ?\n");
    264 #endif
    265   if(JS_IsArrayObject(cx,t)){
    266 #ifdef JS_DEBUG
     264  if(JS_IsArrayObject(cx,tt)){
    267265    fprintf(stderr,"Is finally an array !\n");
    268 #endif
    269   }
    270 #ifdef JS_DEBUG
     266  }
    271267  else
    272268    fprintf(stderr,"Is not an array !\n");
    273269#endif
    274   jsdouble len;
    275   if((JS_GetArrayLength(cx, t, &len)==JS_FALSE)){
     270  jsint len;
     271  JSBool hasLen=JS_GetArrayLength(cx, tt, &len);
     272  if(hasLen==JS_FALSE){
    276273#ifdef JS_DEBUG
    277274    fprintf(stderr,"outputs array is empty\n");
    278275#endif
    279276  }
    280   int i=0;
    281   char tmp[10];
    282   sprintf(tmp,"%d",len);
    283   int clen=atoi(tmp);
    284277#ifdef JS_DEBUG
    285278  fprintf(stderr,"outputs array length : %d\n",len);
    286279#endif
    287   for(i=0;i<len;i++){
    288 #ifdef JS_DEBUG
    289     fprintf(stderr,"outputs array length : %d step %d\n",len,i);
     280  for(oi=0;oi < len;oi++){
     281#ifdef JS_DEBUG
     282    fprintf(stderr,"outputs array length : %d step %d \n",len,oi);
    290283#endif
    291284    jsval tmp1;
    292     JSBool hasElement=JS_GetElement(cx,t,i,&tmp1);
    293     JSVAL_TO_OBJECT(tmp1);
    294     JSIdArray *idp=JS_Enumerate(cx,tmp1);
     285    JSBool hasElement=JS_GetElement(cx,tt,oi,&tmp1);
     286    JSObject *otmp1=JSVAL_TO_OBJECT(tmp1);
     287    JSIdArray *idp=JS_Enumerate(cx,otmp1);
    295288    if(idp!=NULL) {
    296289      int index;
    … …  
    300293#endif
    301294      for (index=0,argNum=idp->length;index<argNum;index++) {
    302         jsid* id = idp->vector[index];
     295        jsval id = idp->vector[index];
    303296        jsval vp;
    304297        JSString* str;
    … …  
    310303        len1 = JS_GetStringLength(jsmsg);
    311304#ifdef JS_DEBUG
    312         fprintf(stderr,"Enumerate id : %d => %s\n",i,JS_GetStringBytes(jsmsg));
    313 #endif
    314         jsval nvp;
    315         if((JS_GetProperty(cx, tmp1, JS_GetStringBytes(jsmsg), &nvp)==JS_FALSE))
    316 #ifdef JS_DEBUG
    317         fprintf(stderr,"Enumerate id : %d => %s => No more value\n",i,JS_GetStringBytes(jsmsg));
     305        fprintf(stderr,"Enumerate id : %d => %s\n",oi,JS_GetStringBytes(jsmsg));
     306#endif
     307        jsval nvp=JSVAL_NULL;
     308        if((JS_GetProperty(cx, JSVAL_TO_OBJECT(tmp1), JS_GetStringBytes(jsmsg), &nvp)==JS_FALSE))
     309#ifdef JS_DEBUG
     310        fprintf(stderr,"Enumerate id : %d => %s => No more value\n",oi,JS_GetStringBytes(jsmsg));
    318311#endif
    319312        if(JSVAL_IS_OBJECT(nvp)){
    … …  
    333326          fprintf(stderr,"JSVAL NVP1J IS OBJECT\n");
    334327#endif
    335           tres=(maps*)malloc(sizeof(maps*));
     328          tres=(maps*)malloc(MAPS_SIZE);
    336329          tres->name=strdup(JS_GetStringBytes(jsmsg));
    337330          tres->content=mapFromJSObject(cx,nvp1j);
    … …  
    341334#endif
    342335          if(res==NULL)
    343             res=tres;
     336            res=dupMaps(&tres);
    344337          else
    345338            addMapsToMaps(&res,tres);
     339          freeMaps(&tres);
     340          free(tres);
     341          tres=NULL;
    346342#ifdef JS_DEBUG
    347343          dumpMaps(res);
    … …  
    363359map* mapFromJSObject(JSContext *cx,jsval t){
    364360  map *res=NULL;
    365   JSIdArray *idp=JS_Enumerate(cx,t);
     361  JSIdArray *idp=JS_Enumerate(cx,JSVAL_TO_OBJECT(t));
    366362#ifdef JS_DEBUG
    367363  fprintf(stderr,"Properties %p\n",(void*)t);
    … …  
    374370#endif
    375371    for (index=0,argNum=idp->length;index<argNum;index++) {
    376       jsid* id = idp->vector[index];
     372      jsval id = idp->vector[index];
    377373      jsval vp;
    378374      JSString* str;
    … …  
    384380      len = JS_GetStringLength(jsmsg);
    385381      jsval nvp;
    386       JS_GetProperty(cx, t, JS_GetStringBytes(jsmsg), &nvp);
     382      JS_GetProperty(cx, JSVAL_TO_OBJECT(t), JS_GetStringBytes(jsmsg), &nvp);
    387383      jsmsg1 = JS_ValueToString(cx,nvp);
    388384      len1 = JS_GetStringLength(jsmsg1);
    … …  
    390386      fprintf(stderr,"Enumerate id : %d [ %s => %s ]\n",index,JS_GetStringBytes(jsmsg),JS_GetStringBytes(jsmsg1));
    391387#endif
    392       if(res!=NULL)
    393         addMapToMap(&res,createMap(JS_GetStringBytes(jsmsg),JS_GetStringBytes(jsmsg1)));
    394       else
     388      if(res!=NULL){
     389        fprintf(stderr,"%s - %s\n",JS_GetStringBytes(jsmsg),JS_GetStringBytes(jsmsg1));
     390        addToMap(res,JS_GetStringBytes(jsmsg),JS_GetStringBytes(jsmsg1));
     391      }
     392      else{
    395393        res=createMap(JS_GetStringBytes(jsmsg),JS_GetStringBytes(jsmsg1));
     394        res->next=NULL;
     395      }
     396      dumpMap(res);
    396397    }
    397398  }
    … …  
    401402  return res;
    402403}
    403 
    404404
    405405/* The error reporter callback. */

  • trunk/zoo-kernel/service_internal_python.c

    r1 r9  
    2525#include "service_internal_python.h"
    2626
    27 int python_support(maps* m,service* s,int argc,char** argv,map *inputs,map *outputs){
    28   Py_Initialize();
    29   PyObject *pName, *pModule, *pFunc;
    30   pName = PyString_FromString(argv[2]);
    31   pModule = PyImport_Import(pName);
    32   int i;
    33   if (pModule != NULL) {
    34     pFunc=PyObject_GetAttrString(pModule,argv[4]);
    35     if (pFunc && PyCallable_Check(pFunc)){
    36       PyDictObject* arg1=PyDict_FromMap(inputs);
    37       PyDictObject* arg2=PyDict_FromMap(outputs);
    38       PyObject *pArgs=PyTuple_New(2);
    39       PyObject *pValue;
    40       PyTuple_SetItem(pArgs, 0, (PyObject *)arg1);
    41       PyTuple_SetItem(pArgs, 1, (PyObject *)arg2);
    42       pValue = PyString_FromString(argv[argc-1]);
    43 #ifdef DEBUG
    44       fprintf(stderr,"Function successfully loaded\n");
    45 #endif 
    46       /**
    47        * Need to check if we need to fork to load a status enabled
    48        */
    49       if(strcmp(PyString_AsString(pValue),"bg")!=0){
    50 #ifdef DEBUG
    51         fprintf(stderr,"RUN IN NORMAL MODE \n");
    52 #endif
    53         pValue = PyObject_CallObject(pFunc, pArgs);
    54         if (pValue != NULL) {
    55           inputs=mapFromPyDict(arg1);
    56           outputs=mapFromPyDict(arg2);
    57 #ifdef DEBUG
    58           fprintf(stderr,"Result of call: %i\n", PyInt_AsLong(pValue));
    59           dumpMap(inputs);
    60           dumpMap(outputs);
    61 #ifndef WIN32
    62           fprintf(stderr,"printProcessResponse(%i,\"%s\",%i,inputs,outputs);",getpid(),argv[1],PyInt_AsLong(pValue));
    63 #endif
    64 #endif
    65           printProcessResponse(m,getpid(),s,argv[2],PyInt_AsLong(pValue),inputs,outputs);
    66         }
    67       }
    68       else{
    69         pid_t pid;
    70 #ifdef WIN32
    71         pid = 0;
    72 #else
    73         pid = fork ();
    74 #endif
    75         if (pid > 0) {
    76           /* dady */
    77           printProcessResponse(m,pid,s,argv[2],SERVICE_STARTED,inputs,outputs);
    78         }else if (pid == 0) {
    79           /* son */
    80 #ifdef DEBUG
    81           fprintf(stderr,"RUN IN BACKGROUND MODE \n");
    82 #endif
    83           char tmp1[256];
    84           sprintf(tmp1,"service/temp/%s_%d.xml",argv[2],getpid());
    85 #ifndef WIN32
    86           stdout =
    87 #endif
    88                   freopen(tmp1 , "w+" , stdout);
    89           printProcessResponse(m,getpid(),s,argv[2],SERVICE_STARTED,inputs,outputs);
    90           fflush(stdout);
    91           pValue = PyObject_CallObject(pFunc, pArgs);
    92           if (pValue != NULL) {
    93             rewind(stdout);
    94             inputs=mapFromPyDict(arg1);
    95             outputs=mapFromPyDict(arg2);
    96 #ifdef DEBUG
    97             fprintf(stderr,"Result of call: %ld\n", PyInt_AsLong(pValue));
    98             dumpMap(inputs);
    99             dumpMap(outputs);
    100             fprintf(stderr,"printProcessResponse(%i,%s,%i,inputs,outputs);",s,getpid(),argv[2],PyInt_AsLong(pValue));
    101 #endif
    102 //          sleep(6);
    103             printProcessResponse(m,getpid(),s,argv[2],PyInt_AsLong(pValue),inputs,outputs);
    104           }
    105           exit(1);
    106         } else {
    107           /* error */
    108         }
    109       }
    110       Py_DECREF(pArgs);
    111       Py_DECREF(pValue);
    112 #ifdef DEBUG
    113       fprintf(stderr,"Function ran successfully\n");
    114 #endif 
    115     }
    116     else{
    117       char tmpS[1024];
    118       sprintf(tmpS, "Cannot find function %s \n", argv[4]);
    119       map* tmps=createMap("text",tmpS);
    120       printExceptionReportResponse(m,tmps);
    121       //fprintf(stderr, "Cannot find function %s \n", argv[2]);
    122       exit(-1);
    123     }
    124   }else{
    125     char tmpS[1024];
    126     sprintf(tmpS, "Cannot find function %s \n", argv[4]);
    127     map* tmps=createMap("text",tmpS);
    128     printExceptionReportResponse(m,tmps);
    129     //fprintf(stderr, "Cannot find function %s \n", argv[4]);
    130     if (PyErr_Occurred())
    131       PyErr_Print();
    132 
    133   }
    134   Py_Finalize();
    135   return 2;
    136 }
    137 
    13827int zoo_python_support(maps** main_conf,map* request,service* s,maps **real_inputs,maps **real_outputs){
    13928  maps* m=*main_conf;
    … …  
    14433  map* tmp=NULL;
    14534  tmp=getMapFromMaps(*main_conf,"env","PYTHONPATH");
    146   char *python_path=NULL;
     35  char *python_path;
     36  fprintf(stderr,"PYTHON SUPPORT \n");
     37  fflush(stderr);
    14738  if(tmp!=NULL){
    148           python_path=(char*)malloc((1+strlen(tmp->value))*sizeof(char));
    149           sprintf(python_path,"%s",tmp->value);
     39    fprintf(stderr,"PYTHON SUPPORT (%i)\n",strlen(tmp->value));
     40    python_path=(char*)malloc((strlen(tmp->value))*sizeof(char));
     41    sprintf(python_path,"%s",tmp->value);
    15042  }
    15143  else{
    152         python_path=(char*)malloc(2*sizeof(char));
    153         python_path=".";
     44    python_path=strdup(".");
    15445  }
    15546  tmp=NULL;
    … …  
    15849  if(tmp!=NULL && strcmp(tmp->value,"")!=0)
    15950#ifdef WIN32
    160           sprintf(pythonpath,"%s/%s/;%s",ntmp,tmp->value,python_path);
     51    sprintf(pythonpath,"%s/%s/;%s",ntmp,tmp->value,python_path);
    16152#else
    162           sprintf(pythonpath,"%s/%s/:%s",ntmp,tmp->value,python_path);
     53  sprintf(pythonpath,"%s/%s/:%s",ntmp,tmp->value,python_path);
    16354#endif
    16455  else
    … …  
    16657    sprintf(pythonpath,"%s;%s",ntmp,python_path);
    16758#else
    168     sprintf(pythonpath,"%s:%s",ntmp,python_path);
    169 #endif
    170 #ifdef DEBUG
    171   fprintf(stderr,"PYTHONPATH=%s\n",pythonpath);
    172 #endif
     59  sprintf(pythonpath,"%s:%s",ntmp,python_path);
     60#endif
     61  //#ifdef DEBUG
     62    fprintf(stderr,"PYTHONPATH=%s\n",pythonpath);
     63  //#endif
    17364#ifndef WIN32
    17465  setenv("PYTHONPATH",pythonpath,1);
    … …  
    17869  free(python_path);
    17970  free(pythonpath);
    180   //
     71
    18172  Py_Initialize();
    18273  PyObject *pName, *pModule, *pFunc;
    18374  tmp=getMap(s->content,"serviceProvider");
    184   //if(tmp!=NULL)
    185   pName = PyString_FromString(tmp->value);
     75  if(tmp!=NULL)
     76    pName = PyString_FromString(tmp->value);
     77  else{
     78    map* err=createMap("text","Unable to parse serviceProvider please check your zcfg file.");
     79    addToMap(err,"code","NoApplicableCode");
     80    printExceptionReportResponse(m,err);
     81    exit(-1);
     82  }
    18683  pModule = PyImport_Import(pName);
    18784  int i;
    … …  
    20299#ifdef DEBUG
    203100      fprintf(stderr,"RUN IN NORMAL MODE \n");
    204       //fflush(stderr);
     101      fflush(stderr);
    205102#endif
    206103      pValue = PyObject_CallObject(pFunc, pArgs);
    207104      if (pValue != NULL) {
    208105        res=PyInt_AsLong(pValue);
    209         /*inputs=mapsFromPyDict(arg2);
    210         dumpMaps(inputs);*/
    211         outputs=mapsFromPyDict(arg3);
    212         *real_outputs=outputs;
    213 
     106        freeMaps(real_outputs);
     107        free(*real_outputs);
     108        //*real_inputs=mapsFromPyDict(arg2);
     109        //createMapsFromPyDict(real_outputs,arg3);
     110        *real_outputs=mapsFromPyDict(arg3);
    214111#ifdef DEBUG
    215112        fprintf(stderr,"Result of call: %i\n", PyInt_AsLong(pValue));
    216113        dumpMaps(inputs);
    217114        dumpMaps(outputs);
    218         fprintf(stderr,"printProcessResponse(%i,\"%s\",%i,inputs,outputs);",
    219                 getpid(),tmp->value,PyInt_AsLong(pValue));
    220         dumpMaps(outputs);
    221 #endif
     115#endif
     116        Py_DECREF(arg1);
     117        Py_DECREF(arg2);
     118        Py_DECREF(arg3);
     119        Py_DECREF(pArgs);
    222120        Py_DECREF(pValue);
    223121        Py_XDECREF(pFunc);
    224         Py_DECREF(pArgs);
    225122        Py_DECREF(pModule);
    226       }else{
    227          
     123      }else{     
    228124        PyObject *ptype,*pvalue, *ptraceback;
    229125        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
    … …  
    268164      map* tmps=createMap("text",tmpS);
    269165      printExceptionReportResponse(m,tmps);
    270       //fprintf(stderr, "Cannot find function %s \n", argv[2]);
    271166      Py_XDECREF(pFunc);
    272167      Py_DECREF(pModule);
    … …  
    275170  } else{
    276171    char tmpS[1024];
    277     sprintf(tmpS, "Cannot find function %s \n", tmp->value);
     172    sprintf(tmpS, "Python module %s cannot be loaded.\n", tmp->value);
    278173    map* tmps=createMap("text",tmpS);
    279174    printExceptionReportResponse(m,tmps);
    280     //fprintf(stderr, "Cannot find function %s \n", argv[4]);
    281175    if (PyErr_Occurred())
    282176      PyErr_Print();
    283177    exit(-1);
    284178  }
     179#ifndef DEBUG
     180  // Failed when DEBUG is defined
    285181  Py_Finalize();
     182#endif
    286183  return res;
    287184}
    … …  
    329226            PyString_AsString(key),PyString_AsString(value));
    330227#endif
    331     if(cursor!=NULL){
     228    while(cursor!=NULL){
    332229      cursor=cursor->next;
    333230    }
    334     cursor=(maps*)malloc(sizeof(maps*));
     231    cursor=(maps*)malloc(MAPS_SIZE);
    335232    cursor->name=PyString_AsString(key);
    336233#ifdef DEBUG

  • trunk/zoo-kernel/service_internal_python.h

    r1 r9  
    4040
    4141maps* mapsFromPyDict(PyDictObject* t);
     42void createMapsFromPyDict(maps**,PyDictObject*);
    4243map* mapFromPyDict(PyDictObject* t);
    4344
    44 int python_support(maps*,service*,int,char**,map *,map *);
    4545int zoo_python_support(maps**,map*,service*,maps**,maps**);
    4646

  • trunk/zoo-kernel/ulinet.c

    r1 r9  
    215215  if(handle.handle)
    216216    curl_easy_cleanup(handle.handle);
     217  curl_global_cleanup();
    217218}
    218219
    … …  
    233234      break;
    234235    default:
    235       sprintf(filename,"/tmp/HTCcache%d",(int)time(NULL));
     236      sprintf(filename,"/tmp/ZOO_Cache%d",(int)time(NULL));
    236237      printf("file=%s",filename);
    237238#ifdef MSG_LAF_VERBOSE

  • trunk/zoo-kernel/zoo_loader.c

    r1 r9  
    2323 */
    2424
     25#define MALLOC_CHECK_ 0
     26#define MALLOC_CHECK 0
     27
    2528/**
    2629 * Specific includes
    … …  
    3134#include <sys/types.h>
    3235#include <unistd.h>
     36#include "service_internal.h"
     37
    3338extern "C" {
    3439#include "cgic.h"
    35 }
    36 
    37 #include "service_internal.h"
    38 extern "C" {
    3940#include <libxml/tree.h>
    4041#include <libxml/xmlmemory.h>
    … …  
    4445}
    4546
     47xmlXPathObjectPtr extractFromDoc(xmlDocPtr,char*);
     48int runRequest(map*);
     49
     50using namespace std;
     51
     52/* ************************************************************************* */
     53
     54int errorException(maps *m, const char *message, const char *errorcode)
     55{
     56  map * errormap = createMap("text", message);
     57  addToMap(errormap,"code", errorcode);
     58  printExceptionReportResponse(m,errormap);
     59  freeMap(&errormap);
     60  free(errormap);
     61  return -1;
     62}
     63
     64/* ************************************************************************* */
     65
    4666#ifndef STRTOK_R
    4767char *
    48 strtok_r(char *s1, const char *s2, char **lasts)
     68strtok_r (char *s1, const char *s2, char **lasts)
    4969{
    5070  char *ret;
    … …  
    5272  if (s1 == NULL)
    5373    s1 = *lasts;
    54   while(*s1 && strchr(s2, *s1))
     74  while (*s1 && strchr(s2, *s1))
    5575    ++s1;
    56   if(*s1 == '\0')
     76  if (*s1 == '\0')
    5777    return NULL;
    5878  ret = s1;
    59   while(*s1 && !strchr(s2, *s1))
     79  while (*s1 && !strchr(s2, *s1))
    6080    ++s1;
    61   if(*s1)
     81  if (*s1)
    6282    *s1++ = '\0';
    6383  *lasts = s1;
    … …  
    6787#endif
    6888
    69 xmlNodeSet* extractFromDoc(xmlDocPtr,char*);
    70 int runRequest(map*);
    71 
    72 using namespace std;
    73 
    74 char* strtoupper(char* str)
    75 {
    76   int leng=strlen(str);
    77   for(int i=0; i<leng; i++)
    78     if (97<=str[i]&&str[i]<=122)//a-z
    79       str[i]-=32;
    80   return str;
    81 }
    82 
    83 char* strtolower(char* str)
    84 {
    85   int leng=strlen(str);
    86   for(int i=0; i<leng; i++)
    87     if (65<=str[i]&&str[i]<=90)//A-Z
    88       str[i]+=32;
    89   return str;
    90 }
    91 
    92 char* remplace(char* delim,char* rep,char* source){
    93   if(strcmp(source,"")==0){
    94 #ifdef DEBUG
    95     //char *tmp="RETURN NULL !\n";
    96     //printf((void*)tmp);
    97 #endif
    98     return "NULL";
    99   }
    100 
    101   char *_token;
    102   char *origin=strdup(source);
    103   char result[1024]="";
    104   _token = strtok(source, delim);
    105 #ifdef DEBUG
    106   fprintf(stderr,"\nREPLACE TOKEN (%s == %s => %d)\n ",_token,origin,strcmp(_token,origin));
    107 #endif
    108   if(strcmp(_token,origin)!=0)
    109     while(_token!=NULL){
    110       sprintf(result,"%s%s%s",result,_token,rep);
    111       _token = strtok (NULL, delim);
    112       if(_token==NULL)
    113         result[strlen(result)-strlen(rep)]=0;
    114 #ifdef DEBUG
    115       fprintf(stderr,"\n\nRESULT(%s)\n\n",result);
    116 #endif
    117     }
    118   else
    119     return origin;
    120  
    121   return strdup(result);
    122 }
    123 
    124 
    125 char *colors[] = {
    126   "red", "green", "blue"
    127 };
    128 
    129 #define colorsTotal 3
    130 #define TRUE -1
     89#define TRUE 1
    13190#define FALSE -1
    132 static bool started=FALSE;
    133 static bool isStarted=FALSE;
    13491
    13592int cgiMain(){
    … …  
    14097  dup2(fileno(cgiOut),fileno(stdout));
    14198#ifdef DEBUG
    142     fprintf(cgiOut,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
    143     fprintf(cgiOut,"Welcome on ZOO verbose debuging mode \r\n\r\n");
    144     fflush(cgiOut);
     99  fprintf(cgiOut,"Content-Type: text/plain; charset=utf-8\r\nStatus: 200 OK\r\n\r\n");
     100  fprintf(cgiOut,"Welcome on ZOO verbose debuging mode \r\n\r\n");
     101  fflush(cgiOut);
    145102#endif
    146103 
    147104  /**
    148105   * Read the main configuration file
    149    */
    150106  if(!isStarted){
    151107    maps* m;
    … …  
    159115    isStarted=TRUE;
    160116  }
    161 
    162 #ifdef DEBUG
    163   char textb[23];
    164   sprintf(textb,"\n%s\n%s\n",cgiRemoteAddr,cgiRequestMethod);
    165   fprintf(stderr,"****%s\n%s\n***",textb,cgiQueryString);
    166 #endif
    167 
    168   map* tmp=NULL;
     117   */
     118
     119#ifdef DEBUG
     120  fprintf (stderr, "Addr:%s\n", cgiRemoteAddr);
     121  fprintf (stderr, "RequestMethod:%s\n", cgiRequestMethod);
     122  fprintf (stderr, "Request: %s\n", cgiQueryString);
     123#endif
     124
     125  map* tmpMap=NULL;
    169126   
    170127  if(strncmp(cgiContentType,"text/xml",8)==0){
    171     char *buffer=new char[cgiContentLength];
     128    char *buffer=new char[cgiContentLength+1];
    172129    if(fread(buffer,1,cgiContentLength,cgiIn)){
    173130      buffer[cgiContentLength]=0;
    174       tmp=createMap("request",buffer);
     131      tmpMap=createMap("request",buffer);
    175132    }else{
    176133      /* Here we have to return an error message ... */
     134      fprintf(stderr, "Unable to read cgi content in zoo_loader.c line %i\n", __LINE__);     
    177135      return 1;
    178136    }
     137    delete[]buffer;
    179138  }
    180139  else{
    … …  
    190149      fprintf(stderr,"(( \n %s \n %s \n ))",*arrayStep,value);
    191150#endif
    192       if(tmp!=NULL)
    193         addToMap(tmp,*arrayStep,value);
     151      if(tmpMap!=NULL)
     152        addToMap(tmpMap,*arrayStep,value);
    194153      else
    195         tmp=createMap(*arrayStep,value);
     154        tmpMap=createMap(*arrayStep,value);
    196155      arrayStep++;
     156      delete[]value;
    197157    }
    198158    cgiStringArrayFree(array);
    … …  
    201161  /**
    202162   * In case that the POST method was used, then check if params came in XML
    203    * format (attribute request should be the once).
    204    */
    205   if(strcmp(cgiRequestMethod,mtoupper("post"))==0 && count(tmp)==1){
     163   * format else try to use the attribute "request" which should be the only
     164   * one.
     165   */
     166  if(strncasecmp(cgiRequestMethod,"post",4)==0 || count(tmpMap)==1){
    206167    /**
    207168     * First include the MetaPath and the ServiceProvider default parameters
    208169     * (which should be always available in GET params so in cgiQueryString)
    209170     */
    210     char *saveptr1, *saveptr2;
    211     char *str1, *str2, *token, *subtoken;
     171    //char *saveptr1, *saveptr2;
     172    char *str1/*, str2, *token, *subtoken*/;
    212173    str1=cgiQueryString;
    213     token=strtok_r(str1,"&",&saveptr1);
    214     while(token!=NULL){
    215 #ifdef DEBUG
    216       fprintf(stderr,"%s",token);
    217 #endif
    218       str2=token;
    219       subtoken=strtok_r(str2,"=",&saveptr2);
    220 #ifdef DEBUG
    221       fprintf(stderr,"%s\n",subtoken);
    222 #endif
    223       char* tmp_name;
    224       if(subtoken!=NULL){
    225         tmp_name=subtoken;
    226 #ifdef DEBUG
    227         fprintf(stderr,"%s",subtoken);
    228 #endif
    229         subtoken=strtok_r(NULL,"=",&saveptr2);
    230         if(subtoken!=NULL)
    231           addToMap(tmp,tmp_name,subtoken);
    232         else
    233           addToMap(tmp,tmp_name,"");
    234       }
    235       token=strtok_r(NULL,"&",&saveptr1);
    236     }
    237174    /**
    238175     * Store the original XML request in xrequest map
    239176     */
    240     map* t1=getMap(tmp,"request");
     177    map* t1=getMap(tmpMap,"request");
    241178    if(t1!=NULL){
    242       addToMap(tmp,"xrequest",t1->value);
     179      addToMap(tmpMap,"xrequest",t1->value);
    243180      xmlInitParser();
    244       xmlDocPtr doc = xmlParseMemory(t1->value,cgiContentLength);     
     181      xmlDocPtr doc = xmlParseMemory(t1->value,cgiContentLength);
    245182      xmlNodePtr cur = xmlDocGetRootElement(doc);
    246183      char *tval;
    … …  
    248185      tval = (char*) xmlGetProp(cur,BAD_CAST "service");
    249186      if(tval!=NULL)
    250         addToMap(tmp,"service",tval);
     187        addToMap(tmpMap,"service",tval);
    251188      tval=NULL;
    252189      tval = (char*) xmlGetProp(cur,BAD_CAST "language");
    253190      if(tval!=NULL)
    254         addToMap(tmp,"language",tval);
     191        addToMap(tmpMap,"language",tval);
    255192     
    256193      char* requests[3];
    … …  
    261198        char tt[35];
    262199        sprintf(tt,"/*[local-name()='%s']",requests[j]);
    263         xmlNodeSet* req=extractFromDoc(doc,tt);
    264 #ifdef DEBUG
    265         fprintf(stderr,"%i",req->nodeNr);
    266 #endif
    267         if(req->nodeNr==1){
    268           t1->value=requests[j];
    269           j=2;
     200        xmlXPathObjectPtr reqptr=extractFromDoc(doc,tt);
     201        if(reqptr!=NULL){
     202          xmlNodeSet* req=reqptr->nodesetval;
     203#ifdef DEBUG
     204          fprintf(stderr,"%i",req->nodeNr);
     205#endif
     206          if(req!=NULL && req->nodeNr==1){
     207            t1->value=requests[j];
     208            j=2;
     209          }
     210          xmlXPathFreeObject(reqptr);
    270211        }
    271         xmlFree(req);
     212        //xmlFree(req);
    272213      }
    273       if(strcmp(mtoupper(t1->value),mtoupper("GetCapabilities"))==0){   
    274         xmlNodeSet* vers=extractFromDoc(doc,"/*/*/*[local-name()='Version']");
     214      if(strncasecmp(t1->value,"GetCapabilities",15)==0){
     215        xmlXPathObjectPtr versptr=extractFromDoc(doc,"/*/*/*[local-name()='Version']");
     216        xmlNodeSet* vers=versptr->nodesetval;
    275217        xmlChar* content=xmlNodeListGetString(doc, vers->nodeTab[0]->xmlChildrenNode,1);
    276         addToMap(tmp,"version",(char*)content);
    277         xmlFree(vers);
     218        addToMap(tmpMap,"version",(char*)content);
     219        xmlXPathFreeObject(versptr);
     220        //xmlFree(vers);
    278221        xmlFree(content);
    279222      }else{
    … …  
    281224        tval = (char*) xmlGetProp(cur,BAD_CAST "version");
    282225        if(tval!=NULL)
    283           addToMap(tmp,"version",tval);
     226          addToMap(tmpMap,"version",tval);
    284227        xmlFree(tval);
    285228        tval = (char*) xmlGetProp(cur,BAD_CAST "language");
    286229        if(tval!=NULL)
    287           addToMap(tmp,"language",tval);
    288         xmlNodeSet* id=extractFromDoc(doc,"/*/*[local-name()='Identifier']");
    289         char* identifiers=NULL;
    290         identifiers=(char*)malloc(cgiContentLength);
    291         identifiers[0]=0;
    292         for(int k=0;k<id->nodeNr;k++){
    293           xmlChar* content=xmlNodeListGetString(doc, id->nodeTab[k]->xmlChildrenNode,1);
    294           if(strlen(identifiers)>0){
    295             sprintf(identifiers,"%s,%s",identifiers,content);
    296             identifiers[strlen(identifiers)]=0;
     230          addToMap(tmpMap,"language",tval);
     231        xmlXPathObjectPtr idptr=extractFromDoc(doc,"/*/*[local-name()='Identifier']");
     232        if(idptr!=NULL){
     233          xmlNodeSet* id=idptr->nodesetval;
     234          if(id!=NULL){
     235            char* identifiers=NULL;
     236            identifiers=(char*)calloc(cgiContentLength,sizeof(char));
     237            identifiers[0]=0;
     238            for(int k=0;k<id->nodeNr;k++){
     239              xmlChar* content=xmlNodeListGetString(doc, id->nodeTab[k]->xmlChildrenNode,1);
     240              if(strlen(identifiers)>0){
     241                char *tmp=strdup(identifiers);
     242                snprintf(identifiers,strlen(tmp)+xmlStrlen(content)+2,"%s,%s",tmp,content);
     243                free(tmp);
     244              }
     245              else{
     246                snprintf(identifiers,xmlStrlen(content)+1,"%s",content);
     247              }
     248              xmlFree(content);
     249            }
     250            xmlXPathFreeObject(idptr);
     251            addToMap(tmpMap,"Identifier",identifiers);
     252            free(identifiers);
    297253          }
    298           else{
    299             sprintf(identifiers,"%s",content);
    300             identifiers[strlen(identifiers)]=0;
    301           }
    302           xmlFree(content);
    303254        }
    304         xmlFree(id);
    305         addToMap(tmp,"Identifier",identifiers);
     255        //xmlFree(id);
    306256      }
    307       //xmlCleanupParser();
    308257      xmlFree(tval);
    309     }
    310   }
    311   //dumpMap(tmp);
    312   runRequest(tmp);
    313   //dumpMap(tmp);
    314 
     258      xmlFreeDoc(doc);
     259      xmlCleanupParser();
     260    }
     261  }
     262
     263  runRequest(tmpMap);
     264
     265  /**
     266   * Required but can't be made after executing a process using POST requests.
     267   */
     268  if(strncasecmp(cgiRequestMethod,"post",4)!=0 && count(tmpMap)!=1 && tmpMap!=NULL){
     269    freeMap(&tmpMap);
     270    free(tmpMap);
     271  }
    315272  return 0;
    316273

  • trunk/zoo-kernel/zoo_service_loader.c

    r5 r9  
    2727extern "C" int yylex();
    2828extern "C" int crlex();
     29
     30
    2931extern "C" {
    3032#include <libxml/tree.h>
    … …  
    7173#include <stdarg.h>
    7274
    73 xmlNodeSet* extractFromDoc(xmlDocPtr doc,char* search){
     75xmlXPathObjectPtr extractFromDoc(xmlDocPtr doc,char* search){
    7476  xmlXPathContextPtr xpathCtx;
    7577  xmlXPathObjectPtr xpathObj;
    7678  xpathCtx = xmlXPathNewContext(doc);
    7779  xpathObj = xmlXPathEvalExpression(BAD_CAST search,xpathCtx);
    78   xmlXPathFreeContext(xpathCtx); 
    79   return xpathObj->nodesetval;
     80  xmlXPathFreeContext(xpathCtx);
     81  return xpathObj;
    8082}
    8183
    82 void sigint_handler(int sig){
     84void sig_handler(int sig){
     85  char tmp[100];
     86  char *ssig;
     87  switch(sig){
     88  case SIGSEGV:
     89    ssig="SIGSEGV";
     90    break;
     91  case SIGTERM:
     92    ssig="SIGTERM";
     93    break;
     94  case SIGINT:
     95    ssig="SIGINT";
     96    break;
     97  case SIGILL:
     98    ssig="SIGILL";
     99    break;
     100  case SIGFPE:
     101    ssig="SIGFPE";
     102    break;
     103  case SIGABRT:
     104    ssig="SIGABRT";
     105    break;
     106  default:
     107    ssig="UNKNOWN";
     108    break;
     109  }
     110  sprintf(tmp,"ZOO Kernel failed to process your request receiving signal %d = %s",sig,ssig);
     111  errorException(NULL, tmp, "InternalError");
    83112  fprintf(stderr,"Not this time!\n");
     113  exit(0);
    84114}
    85115
    86116int runRequest(map* request_inputs)
    87117{
     118
     119  (void) signal(SIGSEGV,sig_handler);
     120  (void) signal(SIGTERM,sig_handler);
     121  (void) signal(SIGINT,sig_handler);
     122  (void) signal(SIGILL,sig_handler);
     123  (void) signal(SIGFPE,sig_handler);
     124  (void) signal(SIGABRT,sig_handler);
    88125
    89126  map* r_inputs=NULL,*tmps=NULL;
    … …  
    95132   * Parsing service specfic configuration file
    96133   */
    97   m=(maps*)malloc(MAPS_SIZE);
     134  m=(maps*)calloc(1,MAPS_SIZE);
     135  if(m == NULL){
     136    return errorException(m, "Unable to allocate memory.", "InternalError");
     137  }
    98138  char ntmp[1024];
    99139#ifndef WIN32
    … …  
    102142  _getcwd(ntmp,1024);
    103143#endif
    104   char conf_file[1024];
    105   sprintf(conf_file,"%s/main.cfg",ntmp); 
     144  r_inputs=getMap(request_inputs,"metapath");
     145  if(r_inputs==NULL){
     146    if(request_inputs==NULL)
     147      request_inputs=createMap("metapath","");
     148    else
     149      addToMap(request_inputs,"metapath","");
     150#ifdef DEBUG
     151    fprintf(stderr,"ADD METAPATH\n");
     152    dumpMap(request_inputs);
     153#endif
     154    r_inputs=getMap(request_inputs,"metapath");
     155  }
     156  char conf_file[10240];
     157  snprintf(conf_file,10240,"%s/%s/main.cfg",ntmp,r_inputs->value);
    106158  conf_read(conf_file,m);
    107  
     159#ifdef DEBUG
     160  fprintf(stderr, "***** BEGIN MAPS\n");
     161  dumpMaps(m);
     162  fprintf(stderr, "***** END MAPS\n");
     163#endif
     164
    108165  /**
    109166   * Check for minimum inputs
    110167   */
    111168  r_inputs=getMap(request_inputs,"Request");
    112   if(r_inputs==NULLMAP){
    113   tmps=createMap("text","Parameter <request> was not specified");
    114     addToMap(tmps,"code","MissingParameterValue");
    115     printExceptionReportResponse(m,tmps);
     169  if(request_inputs==NULL || r_inputs==NULL){
     170    errorException(m, "Parameter <request> was not specified","MissingParameterValue");
     171    freeMaps(&m);
     172    free(m);
     173    freeMap(&request_inputs);
     174    free(request_inputs);
    116175    return 1;
    117176  }
    118   else
     177  else{
    119178    REQUEST=strdup(r_inputs->value);
    120   r_inputs=NULL;
    121   r_inputs=getMap(request_inputs,"Service");
    122   if(r_inputs==NULLMAP){
    123     tmps=createMap("text","Parameter <service> was not specified");
    124     addToMap(tmps,"code","MissingParameterValue");
    125     printExceptionReportResponse(m,tmps);
    126     return 1;
    127   }
    128   if(strcmp(mtoupper(REQUEST),"GETCAPABILITIES")!=0){
    129     r_inputs=getMap(request_inputs,"Version");
    130     if(r_inputs==NULL){
    131       tmps=createMap("text","Parameter <version> was not specified");
    132       addToMap(tmps,"code","MissingParameterValue");
    133       printExceptionReportResponse(m,tmps);
     179    if(strncasecmp(r_inputs->value,"GetCapabilities",15)!=0
     180       && strncasecmp(r_inputs->value,"DescribeProcess",15)!=0
     181       && strncasecmp(r_inputs->value,"Execute",7)!=0){
     182      errorException(m, "Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute.", "InvalidParameterValue");
     183      freeMaps(&m);
     184      free(m);
     185      freeMap(&request_inputs);
     186      free(request_inputs);
     187      free(REQUEST);
    134188      return 1;
    135189    }
    136190  }
    137 
    138   /**
    139    * Need to print std exception message here
    140    */
    141   char SP[1024];
    142   if ((argc < 5 && strcmp(mtoupper(REQUEST),"GETCAPABILITIES")!=0) || (argc < 4 && strcmp(mtoupper(REQUEST),"GETCAPABILITIES")==0)){
    143     r_inputs=getMap(request_inputs,"ServiceProvider");
    144     if(r_inputs==NULLMAP){
    145       tmps=createMap("text","Parameter <serviceprovider> was not specified");
    146       addToMap(tmps,"code","MissingParameterValue");
    147       printExceptionReportResponse(m,tmps);   
     191  r_inputs=NULL;
     192  r_inputs=getMap(request_inputs,"Service");
     193  if(r_inputs==NULLMAP){
     194    errorException(m, "Parameter <service> was not specified","MissingParameterValue");
     195    freeMaps(&m);
     196    free(m);
     197    free(REQUEST);
     198    return 1;
     199  }
     200  if(strncasecmp(REQUEST,"GetCapabilities",15)!=0){
     201    r_inputs=getMap(request_inputs,"Version");
     202    if(r_inputs==NULL){
     203      errorException(m, "Parameter <version> was not specified","MissingParameterValue");
     204      freeMaps(&m);
     205      free(m);
     206      free(REQUEST);
    148207      return 1;
    149208    }
    150     else
    151       sprintf(SP,"%s",r_inputs->value);
    152     r_inputs=getMap(request_inputs,"MetaPath");
    153     if(r_inputs==NULLMAP){
    154       tmps=createMap("text","Parameter <metapath> was not specified");
    155       addToMap(tmps,"code","MissingParameterValue");
    156       printExceptionReportResponse(m,tmps);   
    157       return 1;
    158     }
    159     tmps=createMap("text","Parameter <unknown> was not specified");
    160     addToMap(tmps,"code","MissingParameterValue");
    161     printExceptionReportResponse(m,tmps);   
    162     return 1;
     209  }
     210
     211  r_inputs=getMap(request_inputs,"serviceprovider");
     212  if(r_inputs==NULL){
     213    addToMap(request_inputs,"serviceprovider","");
    163214  }
    164215
    … …  
    182233  char tmps1[1024];
    183234
    184   if(strcmp(mtoupper(REQUEST),mtoupper("GetCapabilities"))==0){
     235  r_inputs=NULL;
     236  r_inputs=getMap(request_inputs,"metapath");
     237  if(r_inputs!=NULL)
     238    snprintf(conf_dir,1024,"%s/%s",ntmp,r_inputs->value);
     239  else
     240    snprintf(conf_dir,1024,"%s",ntmp);
     241
     242  if(strncasecmp(REQUEST,"GetCapabilities",15)==0){
    185243    int i=0;
    186244    struct dirent *dp;
    187     r_inputs=NULL;
    188     r_inputs=getMap(request_inputs,"metapath");
    189245#ifdef DEBUG
    190246    dumpMap(r_inputs);
    191247#endif
    192     sprintf(conf_dir,"%s/%s",ntmp,r_inputs->value);
    193         DIR *dirp = opendir(conf_dir);
     248    DIR *dirp = opendir(conf_dir);
    194249    if(dirp==NULL){
    195       tmps=createMap("text","The specified path doesn't exist.");
    196       addToMap(tmps,"code","InvalidParameterValue");
    197       printExceptionReportResponse(m,tmps);   
    198       return -1;
     250      return errorException(m, "The specified path doesn't exist.","InvalidParameterValue");
    199251    }
    200252    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
    201     doc->encoding = xmlCharStrdup ("UTF-8");
    202253    r_inputs=NULL;
    203254    r_inputs=getMap(request_inputs,"ServiceProvider");
    204     xmlNodePtr n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
     255    xmlNodePtr n;
     256    //dumpMap(request_inputs);
     257    if(r_inputs!=NULL)
     258      n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
     259    else
     260      n = printGetCapabilitiesHeader(doc,"",m);
    205261    /**
    206262     * Strange, here we need to close stdout to ensure that no uneeded
    … …  
    211267    while ((dp = readdir(dirp)) != NULL)
    212268      if(strstr(dp->d_name,".zcfg")!=0){
    213         sprintf(tmps1,"%s/%s",conf_dir,dp->d_name);
    214         char *tmps=tmps1;
    215         s1=(service*)malloc(sizeof(service*));
    216         s[0]=(service*)malloc(sizeof(service*));
     269        memset(tmps1,0,1024);
     270        snprintf(tmps1,1024,"%s/%s",conf_dir,dp->d_name);
     271        s1=(service*)calloc(1,SERVICE_SIZE);
     272        if(s1 == NULL){
     273          return errorException(m, "Unable to allocate memory.","InternalError");
     274        }
    217275#ifdef DEBUG
    218276        fprintf(stderr,"#################\n%s\n#################\n",tmps1);
    … …  
    224282        fflush(stderr);
    225283#endif
    226         s[0]=s1;
    227284        printGetCapabilitiesForProcess(m,n,s1);
    228         //freeService(&s1);
    229         //s1=NULL;
     285        freeService(&s1);
     286        free(s1);
    230287        scount++;
    231288      }
    … …  
    233290    fflush(stdout);
    234291    dup2(saved_stdout,fileno(stdout));
    235    
    236     printDocument(doc);
     292    printDocument(m,doc,getpid());
     293    freeMaps(&m);
     294    free(m);
     295    free(REQUEST);
     296    free(SERVICE_URL);
    237297    fflush(stdout);
    238     xmlFree(n);
    239298    return 0;
    240299  }
    … …  
    243302    if(r_inputs==NULL
    244303       || strlen(r_inputs->name)==0 || strlen(r_inputs->value)==0){
    245       if(r_inputs!=NULL && strlen(r_inputs->value)==0)
    246         tmps=createMap("text","Mandatory value for <identifier> was not specified");
    247       else
    248         tmps=createMap("text","Mandatory <identifier> was not specified");
    249       addToMap(tmps,"code","MissingParameterValue");
    250       printExceptionReportResponse(m,tmps);
    251       return 1;
     304      errorException(m, "Mandatory <identifier> was not specified","MissingParameterValue");
     305      freeMaps(&m);
     306      free(m);
     307      free(REQUEST);
     308      free(SERVICE_URL);
     309      return 0;
    252310    }
    253311
    254     r_inputs=getMap(request_inputs,"metapath");
    255     sprintf(conf_dir,"%s/%s",ntmp,r_inputs->value);
    256312    struct dirent *dp;
    257313    DIR *dirp = opendir(conf_dir);
    258314    if(dirp==NULL){
    259       tmps=createMap("text","The specified metapath path doesn't exist.");
    260       addToMap(tmps,"code","InvalidParameterValue");
    261       printExceptionReportResponse(m,tmps);   
    262       return -1;
     315      errorException(m, "The specified path path doesn't exist.","InvalidParameterValue");
     316      freeMaps(&m);
     317      free(m);
     318      free(REQUEST);
     319      free(SERVICE_URL);
     320      return 0;
    263321    }
    264     if(strcmp(mtoupper(REQUEST),"DESCRIBEPROCESS")==0){
     322    if(strncasecmp(REQUEST,"DescribeProcess",15)==0){
    265323      /**
    266324       * Loop over Identifier list
    267325       */
    268326      xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
    269       doc->encoding = xmlCharStrdup ("UTF-8");
    270327      r_inputs=NULL;
    271328      r_inputs=getMap(request_inputs,"ServiceProvider");
     329
    272330      xmlNodePtr n;
    273331      if(r_inputs!=NULL)
    274332        n = printDescribeProcessHeader(doc,r_inputs->value,m);
     333      else
     334        n = printDescribeProcessHeader(doc,"",m);
    275335
    276336      r_inputs=getMap(request_inputs,"Identifier");
    … …  
    286346      while(tmps){
    287347        memset(buff,0,256);
    288         sprintf(buff,"%s.zcfg",tmps);
     348        snprintf(buff,256,"%s.zcfg",tmps);
    289349        memset(buff1,0,1024);
    290350#ifdef DEBUG
    … …  
    294354          if(strcmp(dp->d_name,buff)==0){
    295355            memset(buff1,0,1024);
    296             sprintf(buff1,"%s/%s",conf_dir,dp->d_name);
    297             s1=(service*)malloc(sizeof(service*));
    298             s[scount]=(service*)malloc(sizeof(service*));
    299 #ifdef DEBUG
    300             fprintf(stderr,"#################\n%s\n#################\n",tmps1);
     356            snprintf(buff1,1024,"%s/%s",conf_dir,dp->d_name);
     357            //s1=(service*)malloc(sizeof(service*));
     358            s1=(service*)calloc(1,SERVICE_SIZE);
     359            if(s1 == NULL){
     360              return errorException(m, "Unable to allocate memory.","InternalError");
     361            }
     362#ifdef DEBUG
     363            fprintf(stderr,"#################\n%s\n#################\n",buff1);
    301364#endif
    302365            t=getServiceFromFile(buff1,&s1);
    303             /*dumpService(s1);
    304               fflush(stdout);
    305               fflush(stderr);*/
    306             s[0]=s1;
    307             printDescribeProcessForProcess(m,n,s,1);
     366#ifdef DEBUG
     367            dumpService(s1);
     368#endif
     369            printDescribeProcessForProcess(m,n,s1,1);
     370            freeService(&s1);
     371            free(s1);
    308372            scount++;
    309373          }
    … …  
    311375        tmps=strtok(NULL,",");
    312376      }
    313       (void)closedir(dirp);
     377      closedir(dirp);
    314378      fflush(stdout);
    315379      dup2(saved_stdout,fileno(stdout));
    316 
    317       printDocument(doc);
     380      printDocument(m,doc,getpid());
     381      freeMaps(&m);
     382      free(m);
     383      free(REQUEST);
     384      free(SERVICE_URL);
    318385      fflush(stdout);
    319386      //xmlFree(n);
    320387#ifndef LINUX_FREE_ISSUE
    321       free(s1);
     388      if(s1)
     389        free(s1);
    322390#endif
    323391      return 0;
    324392    }
    325393    else
    326       if(strcmp(mtoupper(REQUEST),"EXECUTE")!=0){
    327         tmps=createMap("text","Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute.");
    328         addToMap(tmps,"code","InvalidParameterValue");
    329         printExceptionReportResponse(m,tmps);
     394      if(strncasecmp(REQUEST,"Execute",strlen(REQUEST))!=0){
     395        errorException(m, "Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute.", "InvalidParameterValue");
    330396#ifdef DEBUG
    331397        fprintf(stderr,"No request found %s",REQUEST);
    332398#endif 
     399        closedir(dirp);
    333400        free(s);
    334401        return 0;
    335402      }
     403    closedir(dirp);
    336404  }
    337405 
    338406  s1=NULL;
    339   s1=(service*)malloc(sizeof(service*));
    340   s[0]=(service*)malloc(sizeof(service*));
     407  s1=(service*)calloc(1,SERVICE_SIZE);
     408  if(s1 == NULL){
     409    return errorException(m, "Unable to allocate memory.","InternalError");
     410  }
    341411  r_inputs=getMap(request_inputs,"MetaPath");
    342   sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
     412  if(r_inputs!=NULL)
     413    snprintf(tmps1,1024,"%s/%s",ntmp,r_inputs->value);
     414  else
     415    snprintf(tmps1,1024,"%s/",ntmp);
    343416  r_inputs=getMap(request_inputs,"Identifier");
    344 
    345   sprintf(tmps1,"%s/%s.zcfg",strdup(tmps1),r_inputs->value);
    346 
     417  char *ttmp=strdup(tmps1);
     418  snprintf(tmps1,1024,"%s/%s.zcfg",ttmp,r_inputs->value);
     419  free(ttmp);
    347420#ifdef DEBUG
    348421  fprintf(stderr,"Trying to load %s\n", tmps1);
    … …  
    354427  dup2(saved_stdout,fileno(stdout));
    355428  if(t==22){
    356     tmps=createMap("text","The value for <indetifier> seems to be wrong. Please, ensure that the process exsits using the GetCapabilities request.");
    357     addToMap(tmps,"code","InvalidParameterValue");
    358     printExceptionReportResponse(m,tmps);
     429    errorException(m, "The value for <indetifier> seems to be wrong. Please, ensure that the process exsits using the GetCapabilities request.", "InvalidParameterValue");
    359430    exit(0);
    360431  }
    361   s[0]=s1;
     432  //s[0]=s1;
    362433
    363434#ifdef DEBUG
    … …  
    399470#endif
    400471    r_inputs=getMap(request_inputs,"ResponseDocument");
    401     if(r_inputs==NULLMAP)
    402       r_inputs=getMap(request_inputs,"RawDataOutput");
    403 #ifdef DEBUG
     472    if(r_inputs==NULL) r_inputs=getMap(request_inputs,"RawDataOutput");
     473   
     474    //#ifdef DEBUG
    404475    fprintf(stderr,"OUTPUT Parsing ... \n");
    405 #endif
    406     if(r_inputs!=NULLMAP){
    407 #ifdef DEBUG
     476    //#endif
     477    if(r_inputs!=NULL){
     478      //#ifdef DEBUG
    408479      fprintf(stderr,"OUTPUT Parsing start now ... \n");
    409 #endif
     480      //#endif
    410481      char current_output_as_string[10240];
    411482      char cursor_output[10240];
    412       sprintf(cursor_output,"%s",strdup(r_inputs->value));
     483      char *cotmp=strdup(r_inputs->value);
     484      snprintf(cursor_output,10240,"%s",cotmp);
     485      free(cotmp);
    413486      j=0;
    414487      map* request_kvp_outputs=NULL;
    … …  
    423496#endif
    424497      pToken=strtok(cursor_output,";");
    425       char** outputs_as_text=(char**)malloc(128*sizeof(char*));
     498      char** outputs_as_text=(char**)calloc(128,sizeof(char*));
     499      if(outputs_as_text == NULL) {
     500        return errorException(m, "Unable to allocate memory", "InternalError");
     501      }
    426502      i=0;
    427503      while(pToken!=NULL){
    … …  
    431507        fprintf(stderr,"***%s***\n",pToken);
    432508#endif
    433         outputs_as_text[i]=(char*)malloc(strlen(pToken)*sizeof(char));
    434         sprintf(outputs_as_text[i],"%s",pToken);
     509        outputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
     510        if(outputs_as_text[i] == NULL) {
     511          return errorException(m, "Unable to allocate memory", "InternalError");
     512        }
     513        snprintf(outputs_as_text[i],strlen(pToken)+1,"%s",pToken);
    435514        pToken = strtok(NULL,";");
    436515        i++;
    … …  
    438517      for(j=0;j<i;j++){
    439518        char *tmp=strdup(outputs_as_text[j]);
     519        free(outputs_as_text[j]);
    440520        char *tmpc;
    441521        tmpc=strtok(tmp,"@");
    … …  
    444524          if(k==0){
    445525            if(tmp_output==NULL){
    446               tmp_output=(maps*)malloc(MAPS_SIZE);
     526              tmp_output=(maps*)calloc(1,MAPS_SIZE);
     527              if(tmp_output == NULL){
     528                return errorException(m, "Unable to allocate memory.", "InternalError");
     529              }
    447530              tmp_output->name=strdup(tmpc);
    448531              tmp_output->content=NULL;
    … …  
    473556        }
    474557        if(request_output_real_format==NULL)
    475           request_output_real_format=tmp_output;
     558          request_output_real_format=dupMaps(&tmp_output);
    476559        else
    477560          addMapsToMaps(&request_output_real_format,tmp_output);
     561        freeMaps(&tmp_output);
     562        free(tmp_output);
     563        tmp_output=NULL;
    478564#ifdef DEBUG
    479565        dumpMaps(tmp_output);
    480566        fflush(stderr);
    481567#endif
    482         tmp_output=tmp_output->next;
     568        //tmp_output=tmp_output->next;
     569        free(tmp);
    483570      }
     571      free(outputs_as_text);
    484572    }
    485573
    … …  
    494582    char current_input_as_string[40960];
    495583    char cursor_input[40960];
    496     sprintf(cursor_input,"%s",strdup(r_inputs->value));
     584    if(r_inputs!=NULL)
     585      snprintf(cursor_input,40960,"%s",r_inputs->value);
     586    else{
     587      errorException(m, "Parameter <DataInputs> was not specified","MissingParameterValue");
     588      freeMaps(&m);
     589      free(m);
     590      free(REQUEST);
     591      free(SERVICE_URL);
     592      return 0;
     593    }
    497594    j=0;
    498595    map* request_kvp_inputs=NULL;
    … …  
    503600    char * pToken;
    504601    pToken=strtok(cursor_input,";");
    505     char** inputs_as_text=(char**)malloc(100*sizeof(char*));
     602    char** inputs_as_text=(char**)calloc(100,sizeof(char*));
     603    if(inputs_as_text == NULL){
     604      return errorException(m, "Unable to allocate memory.", "InternalError");
     605    }
    506606    i=0;
    507607    while(pToken!=NULL){
    … …  
    513613      fprintf(stderr,"***%s***\n",pToken);
    514614#endif
    515       inputs_as_text[i]=(char*)malloc(strlen(pToken)*sizeof(char));
    516       sprintf(inputs_as_text[i],"%s",pToken);
     615      inputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
     616      snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
     617      if(inputs_as_text[i] == NULL){
     618        return errorException(m, "Unable to allocate memory.", "InternalError");
     619      }
    517620      pToken = strtok(NULL,";");
    518621      i++;
    … …  
    521624    for(j=0;j<i;j++){
    522625      char *tmp=strdup(inputs_as_text[j]);
     626      free(inputs_as_text[j]);
    523627      char *tmpc;
    524628      tmpc=strtok(tmp,"@");
    … …  
    537641#endif
    538642        if(tmpmaps==NULL){
    539           tmpmaps=(maps*)malloc(MAPS_SIZE);
     643          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     644          if(tmpmaps == NULL){
     645            return errorException(m, "Unable to allocate memory.", "InternalError");
     646          }
    540647          tmpmaps->name=strdup(tmpn);
    541648          tmpmaps->content=createMap("value",tmpv+1);
    … …  
    566673#endif
    567674#ifndef WIN32
    568                 if(CHECK_INET_HANDLE(hInternet))
    569 #endif
    570                 {
    571               res=InternetOpenUrl(hInternet,tmpv1+1,NULL,0,
    572                                             INTERNET_FLAG_NO_CACHE_WRITE,0);
    573 #ifdef DEBUG
    574               fprintf(stderr,"(%s) content-length : %d,,res.nDataAlloc %d \n",
    575                       tmpv1+1,res.nDataAlloc,res.nDataLen);
    576 #endif
    577               char* tmpContent=(char*)malloc((res.nDataLen+1)*sizeof(char));
    578               size_t dwRead;
    579               InternetReadFile(res, (LPVOID)tmpContent,res.nDataLen, &dwRead);
    580               map* tmpMap=getMap(tmpmaps->content,"value");
    581               if(tmpMap!=NULL)
    582                 tmpMap->value=tmpContent;
    583             }
     675            if(CHECK_INET_HANDLE(hInternet))
     676#endif
     677              {
     678                res=InternetOpenUrl(hInternet,tmpv1+1,NULL,0,
     679                                    INTERNET_FLAG_NO_CACHE_WRITE,0);
     680#ifdef DEBUG
     681                fprintf(stderr,"(%s) content-length : %d,,res.nDataAlloc %d \n",
     682                        tmpv1+1,res.nDataAlloc,res.nDataLen);
     683#endif
     684                char* tmpContent=(char*)calloc((res.nDataLen+1),sizeof(char));
     685                if(tmpContent == NULL){
     686                  return errorException(m, "Unable to allocate memory.", "InternalError");
     687                }
     688                size_t dwRead;
     689                InternetReadFile(res, (LPVOID)tmpContent,res.nDataLen, &dwRead);
     690                map* tmpMap=getMap(tmpmaps->content,"value");
     691                if(tmpMap!=NULL)
     692                  tmpMap->value=strdup(tmpContent);
     693                free(tmpContent);
     694              }
    584695            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
    585696          }
    586697          tmpc=strtok(NULL,"@");
    587698        }
     699#ifdef DEBUG
     700        dumpMaps(tmpmaps);
     701        fflush(stderr);
     702#endif
    588703        if(request_input_real_format==NULL)
    589           request_input_real_format=tmpmaps;
     704          request_input_real_format=dupMaps(&tmpmaps);
    590705        else
    591706          addMapsToMaps(&request_input_real_format,tmpmaps);
    592 #ifdef DEBUG
    593         dumpMaps(tmpmaps);
    594         fflush(stderr);
    595 #endif
    596         tmpmaps=tmpmaps->next;
     707        /*freeMap(&tmpmaps->content);
     708        free(tmpmaps->content);
     709        tmpmaps->content=NULL;*/
     710        freeMaps(&tmpmaps);
     711        free(tmpmaps);
     712          //}
     713        tmpmaps=NULL;
     714        free(tmp);
    597715      }
    598716    }
    599   }
     717    free(inputs_as_text);
     718  }
    600719  else {
     720    /**
     721     * Parse XML request
     722     */
    601723    xmlInitParser();
    602724#ifdef DEBUG
    … …  
    616738     */
    617739    maps* tempMaps=NULL;
    618     xmlNodeSet* tmps=extractFromDoc(doc,
    619                                     "/*/*/*[local-name()='Input']");
     740    xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='Input']");
     741    xmlNodeSet* tmps=tmpsptr->nodesetval;
    620742#ifdef DEBUG
    621743    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
    … …  
    631753        fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
    632754#endif
    633         xmlNodePtr cur1=cur->children;
    634         while(cur1){
    635 #ifdef DEBUG
    636           fprintf(stderr, "= element 1 node \"%s\" = (%s)\n",
    637                   cur1->name,xmlNodeListGetString(doc,cur1,1));
    638 #endif
    639           xmlNodePtr cur2=cur1/*->next*/;
    640           while(cur2){
     755        xmlNodePtr cur2=cur->children;
     756        while(cur2){
     757          while(cur2->type!=XML_ELEMENT_NODE)
     758            cur2=cur2->next;
     759          /**
     760           * Indentifier
     761           */
     762          if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
     763            xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
     764            if(tmpmaps==NULL){
     765              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     766              if(tmpmaps == NULL){
     767                return errorException(m, "Unable to allocate memory.", "InternalError");
     768              }
     769              tmpmaps->name=strdup((char*)val);
     770              tmpmaps->content=NULL;
     771              tmpmaps->next=NULL;
     772            }
     773            xmlFree(val);
     774          }
     775          /**
     776           * Title, Asbtract
     777           */
     778          if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
     779             xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
     780            xmlChar *val=
     781              xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
     782            if(tmpmaps==NULL){
     783              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     784              if(tmpmaps == NULL){
     785                return errorException(m, "Unable to allocate memory.", "InternalError");
     786              }
     787              tmpmaps->name="missingIndetifier";
     788              tmpmaps->content=createMap((char*)cur2->name,(char*)val);
     789              tmpmaps->next=NULL;
     790            }
     791            else{
     792              if(tmpmaps->content!=NULL)
     793                addToMap(tmpmaps->content,
     794                         (char*)cur2->name,(char*)val);
     795              else
     796                tmpmaps->content=
     797                  createMap((char*)cur2->name,(char*)val);
     798            }
     799#ifdef DEBUG
     800            dumpMaps(tmpmaps);
     801#endif
     802            xmlFree(val);
     803          }
     804          /**
     805           * InputDataFormChoice (Reference or Data ?)
     806           */
     807          if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
    641808            /**
    642              * Indentifier
     809             * Get every attribute from a Reference node
     810             * mimeType, encoding, schema, href, method
     811             * Header and Body gesture should be added here
    643812             */
    644             if(strcmp(mtoupper((char*)cur2->name),
    645                       mtoupper("Identifier"))==0){
    646               xmlChar *val=
    647                 xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
    648               if(tmpmaps==NULL){
    649                 tmpmaps=(maps*)malloc(MAPS_SIZE);
    650                 tmpmaps->name=strdup((char*)val);
    651                 tmpmaps->content=NULL;
    652                 tmpmaps->next=NULL;
     813#ifdef DEBUG
     814            fprintf(stderr,"REFERENCE\n");
     815#endif
     816            map* referenceMap=NULL;
     817            char *refs[5];
     818            refs[0]="mimeType";
     819            refs[1]="encoding";
     820            refs[2]="schema";
     821            refs[3]="method";
     822            refs[4]="href";
     823            char*url;
     824            for(int l=0;l<5;l++){
     825#ifdef DEBUG
     826              fprintf(stderr,"*** %s ***",refs[l]);
     827#endif
     828              xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
     829              if(val!=NULL && xmlStrlen(val)>0){
     830                if(tmpmaps->content!=NULL)
     831                  addToMap(tmpmaps->content,refs[l],(char*)val);
     832                else
     833                  tmpmaps->content=createMap(refs[l],(char*)val);
     834                map* ltmp=getMap(tmpmaps->content,"method");
     835                if(l==4){
     836                  if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
     837                     && CHECK_INET_HANDLE(hInternet)){
     838                    res=InternetOpenUrl(hInternet,(char*)val,NULL,0,
     839                                        INTERNET_FLAG_NO_CACHE_WRITE,0);
     840                    char* tmpContent=
     841                      (char*)calloc((res.nDataLen+1),sizeof(char));
     842                    if(tmpContent == NULL){
     843                      return errorException(m, "Unable to allocate memory.", "InternalError");
     844                    }
     845                    size_t dwRead;
     846                    InternetReadFile(res, (LPVOID)tmpContent,
     847                                     res.nDataLen, &dwRead);
     848                    tmpContent[res.nDataLen]=0;
     849                    addToMap(tmpmaps->content,"value",tmpContent);
     850                  }
     851                }
    653852              }
     853#ifdef DEBUG
     854              fprintf(stderr,"%s\n",val);
     855#endif
    654856              xmlFree(val);
    655857            }
    656             /**
    657              * Title, Asbtract
    658              */
    659             if(strcmp(mtoupper((char*)cur2->name),
    660                       mtoupper("Title"))==0 ||
    661                strcmp(mtoupper((char*)cur2->name),
    662                       mtoupper("Abstract"))==0){
    663               xmlChar *val=
    664                 xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
    665               if(tmpmaps==NULL){
    666                 tmpmaps=(maps*)malloc(MAPS_SIZE);
    667                 tmpmaps->name="missingIndetifier";
    668                 tmpmaps->content=createMap((char*)cur2->name,(char*)val);
    669                 tmpmaps->next=NULL;
     858#ifdef POST_DEBUG
     859            fprintf(stderr,"Parse Header and Body from Reference \n");
     860#endif
     861            xmlNodePtr cur3=cur2->children;
     862            hInternet.header=NULL;
     863            while(cur3){
     864              if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
     865                xmlNodePtr cur4=cur3;
     866                char *tmp=new char[cgiContentLength];
     867                char *ha[2];
     868                ha[0]="key";
     869                ha[1]="value";
     870                int hai;
     871                char *has;
     872                char *key;
     873                for(hai=0;hai<2;hai++){
     874                  xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
     875#ifdef POST_DEBUG
     876                  fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
     877#endif
     878                  if(hai==0){
     879                    key=(char*)calloc((1+strlen((char*)val)),sizeof(char));
     880                    snprintf(key,1+strlen((char*)val),"%s",(char*)val);
     881                  }else{
     882                    has=(char*)calloc((3+strlen((char*)val)+strlen(key)),sizeof(char));
     883                    if(has == NULL){
     884                      return errorException(m, "Unable to allocate memory.", "InternalError");
     885                    }
     886                    snprintf(has,(3+strlen((char*)val)+strlen(key)),"%s: %s",key,(char*)val);
     887#ifdef POST_DEBUG
     888                    fprintf(stderr,"%s\n",has);
     889#endif
     890                  }
     891                }
     892                hInternet.header=curl_slist_append(hInternet.header, has);
     893                //free(has);
    670894              }
    671895              else{
    672                 if(tmpmaps->content!=NULL)
    673                   addToMap(tmpmaps->content,
    674                            (char*)cur2->name,(char*)val);
     896#ifdef POST_DEBUG
     897                fprintf(stderr,"Try to fetch the body part of the request ...\n");
     898#endif
     899                if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
     900#ifdef POST_DEBUG
     901                  fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
     902#endif
     903                  char *tmp=new char[cgiContentLength];
     904                  memset(tmp,0,cgiContentLength);
     905                  xmlNodePtr cur4=cur3->children;
     906                  while(cur4!=NULL){
     907                    xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
     908                    bdoc->encoding = xmlCharStrdup ("UTF-8");
     909                    xmlDocSetRootElement(bdoc,cur4);
     910                    xmlChar* btmps;
     911                    int bsize;
     912                    xmlDocDumpMemory(bdoc,&btmps,&bsize);
     913#ifdef POST_DEBUG
     914                    fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
     915#endif
     916                    if(btmps!=NULL)
     917                      sprintf(tmp,"%s",(char*)btmps);
     918                    xmlFreeDoc(bdoc);
     919                    cur4=cur4->next;
     920                  }
     921                  map *btmp=getMap(tmpmaps->content,"href");
     922                  if(btmp!=NULL){
     923#ifdef POST_DEBUG
     924                    fprintf(stderr,"%s %s\n",btmp->value,tmp);
     925                    curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
     926#endif
     927                    res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
     928                                        INTERNET_FLAG_NO_CACHE_WRITE,0);
     929                    char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
     930                    if(tmpContent == NULL){
     931                      return errorException(m, "Unable to allocate memory.", "InternalError");
     932                    }
     933                    size_t dwRead;
     934                    InternetReadFile(res, (LPVOID)tmpContent,
     935                                     res.nDataLen, &dwRead);
     936                    tmpContent[res.nDataLen]=0;
     937                    if(hInternet.header!=NULL)
     938                      curl_slist_free_all(hInternet.header);
     939                    addToMap(tmpmaps->content,"value",tmpContent);
     940#ifdef POST_DEBUG
     941                    fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
     942#endif
     943                  }
     944                }
    675945                else
    676                   tmpmaps->content=
    677                     createMap((char*)cur2->name,(char*)val);
    678               }
    679 #ifdef DEBUG
    680               dumpMaps(tmpmaps);
    681 #endif
    682               xmlFree(val);
    683             }
    684             /**
    685              * InputDataFormChoice (Reference or Data ?)
    686              */
    687             if(strcmp(mtoupper((char*)cur2->name),
    688                       mtoupper("Reference"))==0){
    689               /**
    690                * Get every attribute from a Reference node
    691                * mimeType, encoding, schema, href, method
    692                * Header and Body gesture should be added here
    693                */
    694 #ifdef DEBUG
    695               fprintf(stderr,"REFERENCE\n");
    696 #endif
    697               map* referenceMap=NULL;
    698               char *refs[5];
    699               refs[0]="mimeType";
    700               refs[1]="encoding";
    701               refs[2]="schema";
    702               refs[3]="method";
    703               refs[4]="href";
    704               char*url;
    705               for(int l=0;l<5;l++){
    706 #ifdef DEBUG
    707                 fprintf(stderr,"*** %s ***\t",refs[l]);
    708 #endif
    709                 xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
    710                 if(val!=NULL && strlen((char*)val)>0){
    711                   if(tmpmaps->content!=NULL)
    712                     addToMap(tmpmaps->content,refs[l],(char*)val);
    713                   else
    714                     tmpmaps->content=createMap(refs[l],(char*)val);
    715                   map* ltmp=getMap(tmpmaps->content,"method");
    716                   if(l==4){
    717                     if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
    718                        && CHECK_INET_HANDLE(hInternet)){
    719                         res=InternetOpenUrl(hInternet,(char*)val,NULL,0,
    720                                             INTERNET_FLAG_NO_CACHE_WRITE,0);
    721                         char* tmpContent=
    722                           (char*)malloc((res.nDataLen+1)*sizeof(char));
    723                         size_t dwRead;
    724                         InternetReadFile(res, (LPVOID)tmpContent,
    725                                          res.nDataLen, &dwRead);
    726                         tmpContent[res.nDataLen]=0;
    727                         addToMap(tmpmaps->content,"value",tmpContent);
     946                  if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
     947                    xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
     948                    HINTERNET bInternet,res1;
     949                    bInternet=InternetOpen(
     950#ifndef WIN32
     951                                           (LPCTSTR)
     952#endif
     953                                           "ZooWPSClient\0",
     954                                           INTERNET_OPEN_TYPE_PRECONFIG,
     955                                           NULL,NULL, 0);
     956                    if(!CHECK_INET_HANDLE(bInternet))
     957                      fprintf(stderr,"WARNING : hInternet handle failed to initialize");
     958#ifdef POST_DEBUG
     959                    curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
     960#endif
     961                    res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
     962                                         INTERNET_FLAG_NO_CACHE_WRITE,0);
     963                    char* tmp=
     964                      (char*)calloc((res1.nDataLen+1),sizeof(char));
     965                    if(tmp == NULL){
     966                      return errorException(m, "Unable to allocate memory.", "InternalError");
    728967                    }
    729                   }
    730                  
    731                 }
    732 #ifdef DEBUG
    733                 fprintf(stderr,"%s\n",val);
    734 #endif
    735                 xmlFree(val);
    736               }
    737 #ifdef POST_DEBUG
    738               fprintf(stderr,"Parse Header and Body from Reference \n");
    739 #endif
    740               xmlNodePtr cur3=cur2->children;
    741               hInternet.header=NULL;
    742               while(cur3){
    743                 if(strcmp(mtoupper((char*)cur3->name), mtoupper("Header"))==0 ){
    744                   xmlNodePtr cur4=cur3;
    745                   char *tmp=new char[cgiContentLength];
    746                   char *ha[2];
    747                   ha[0]="key";
    748                   ha[1]="value";
    749                   int hai;
    750                   char *has;
    751                   char *key;
    752                   for(hai=0;hai<2;hai++){
    753                     xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
    754 #ifdef POST_DEBUG
    755                     fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
    756 #endif
    757                     if(hai==0){
    758                       key=(char*)malloc((1+strlen((char*)val))*sizeof(char));
    759                       sprintf(key,"%s",(char*)val);
    760                     }else{
    761                       has=(char*)malloc((3+strlen((char*)val)+strlen(key))*sizeof(char));
    762                       sprintf(has,"%s: %s",key,(char*)val);
    763 #ifdef POST_DEBUG
    764                       fprintf(stderr,"%s\n",has);
    765 #endif
    766                     }
    767                   }
    768                   hInternet.header=curl_slist_append(hInternet.header, has);
    769                   //free(has);
    770                 }
    771                 else{
    772 #ifdef POST_DEBUG
    773                   fprintf(stderr,"Try to fetch the body part of the request ...\n");
    774 #endif
    775                   if(strcmp(mtoupper((char*)cur3->name),mtoupper("Body"))==0 ){
    776 #ifdef POST_DEBUG
    777                     fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
    778 #endif
    779                     char *tmp=new char[cgiContentLength];
    780                     memset(tmp,cgiContentLength,0);
    781                     xmlNodePtr cur4=cur3->children;
    782                     while(cur4!=NULL){
    783                       xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
    784                       bdoc->encoding = xmlCharStrdup ("UTF-8");
    785                       xmlDocSetRootElement(bdoc,cur4);
    786                       xmlChar* btmps;
    787                       int bsize;
    788                       xmlDocDumpMemory(bdoc,&btmps,&bsize);
    789 #ifdef POST_DEBUG
    790                       fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
    791 #endif
    792                       if(btmps!=NULL)
    793                         sprintf(tmp,"%s",(char*)btmps);
    794                       xmlFreeDoc(bdoc);
    795                       cur4=cur4->next;
    796                     }
     968                    size_t bRead;
     969                    InternetReadFile(res1, (LPVOID)tmp,
     970                                     res1.nDataLen, &bRead);
     971                    tmp[res1.nDataLen]=0;
     972                    InternetCloseHandle(bInternet);
    797973                    map *btmp=getMap(tmpmaps->content,"href");
    798974                    if(btmp!=NULL){
    … …  
    801977                      curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
    802978#endif
    803                       res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
     979                      res=InternetOpenUrl(hInternet,btmp->value,tmp,
     980                                          strlen(tmp),
    804981                                          INTERNET_FLAG_NO_CACHE_WRITE,0);
    805                       char* tmpContent=
    806                         (char*)malloc((res.nDataLen+1)*sizeof(char));
     982                      char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
     983                      if(tmpContent == NULL){
     984                        return errorException(m, "Unable to allocate memory.", "InternalError");
     985                      }
    807986                      size_t dwRead;
    808987                      InternetReadFile(res, (LPVOID)tmpContent,
    … …  
    817996                    }
    818997                  }
    819                   else
    820                     if(strcmp(mtoupper((char*)cur3->name),mtoupper("BodyReference"))==0 ){
    821                       xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
    822                       HINTERNET bInternet,res1;
    823                       bInternet=InternetOpen(
    824 #ifndef WIN32
    825                                   (LPCTSTR)
    826 #endif
    827                                   "ZooWPSClient\0",
    828                                              INTERNET_OPEN_TYPE_PRECONFIG,
    829                                              NULL,NULL, 0);
    830                       if(!CHECK_INET_HANDLE(bInternet))
    831                         fprintf(stderr,"WARNING : hInternet handle failed to initialize");
     998              }
     999              cur3=cur3->next;
     1000            }
    8321001#ifdef POST_DEBUG
    833                       curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
    834 #endif
    835                       res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
    836                                            INTERNET_FLAG_NO_CACHE_WRITE,0);
    837                       char* tmp=
    838                         (char*)malloc((res1.nDataLen+1)*sizeof(char));
    839                       size_t bRead;
    840                       InternetReadFile(res1, (LPVOID)tmp,
    841                                        res1.nDataLen, &bRead);
    842                       tmp[res1.nDataLen]=0;
    843                       InternetCloseHandle(bInternet);
    844                       map *btmp=getMap(tmpmaps->content,"href");
    845                       if(btmp!=NULL){
    846 #ifdef POST_DEBUG
    847                         fprintf(stderr,"%s %s\n",btmp->value,tmp);
    848                         curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
    849 #endif
    850                         res=InternetOpenUrl(hInternet,btmp->value,tmp,
    851                                             strlen(tmp),
    852                                             INTERNET_FLAG_NO_CACHE_WRITE,0);
    853                         char* tmpContent=
    854                           (char*)malloc((res.nDataLen+1)*sizeof(char));
    855                         size_t dwRead;
    856                         InternetReadFile(res, (LPVOID)tmpContent,
    857                                          res.nDataLen, &dwRead);
    858                         tmpContent[res.nDataLen]=0;
    859                         if(hInternet.header!=NULL)
    860                           curl_slist_free_all(hInternet.header);
    861                         addToMap(tmpmaps->content,"value",tmpContent);
    862 #ifdef POST_DEBUG
    863                         fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
    864 #endif
    865                       }
    866                     }
    867                 }
    868                 cur3=cur3->next;
    869               }
    870 #ifdef POST_DEBUG
    871               fprintf(stderr,"Header and Body was parsed from Reference \n");
    872 #endif
    873 #ifdef DEBUG
    874               dumpMap(tmpmaps->content);
    875               fprintf(stderr, "= element 2 node \"%s\" = (%s)\n",
    876                       cur2->name,cur2->content);
    877 #endif
    878             }
    879             else if(strcmp(mtoupper((char*)cur2->name),
    880                            mtoupper("Data"))==0){
    881 #ifdef DEBUG
    882               fprintf(stderr,"DATA\n");
    883 #endif
    884               xmlNodePtr cur4=cur2->children;
    885               while(cur4){
    886                 if(strcmp(mtoupper((char*)cur4->name),
    887                           mtoupper("LiteralData"))==0){
    888                   /**
    889                    * Get every attribute from a LiteralData node
    890                    * dataType , uom
    891                    */
    892                   char *lits[2];
    893                   lits[0]="dataType";
    894                   lits[1]="uom";
    895                   for(int l=0;l<2;l++){
    896 #ifdef DEBUG
    897                     fprintf(stderr,"*** %s ***\t",lits[l]);
    898 #endif
    899                     xmlChar *val=xmlGetProp(cur4,BAD_CAST lits[l]);
    900                     if(val!=NULL && strlen((char*)val)>0){
    901                       if(tmpmaps->content!=NULL)
    902                         addToMap(tmpmaps->content,lits[l],(char*)val);
    903                       else
    904                         tmpmaps->content=createMap(lits[l],(char*)val);
    905                     }
    906 #ifdef DEBUG
    907                     fprintf(stderr,"%s\n",val);
    908 #endif
    909                     xmlFree(val);
    910                   }
    911                   xmlChar* mv=xmlNodeListGetString(doc,
    912                                                    cur4->xmlChildrenNode,1);
    913                   if(tmpmaps->content!=NULL)
    914                     addToMap(tmpmaps->content,
    915                              "value",
    916                              (char*)mv);
    917                   else
    918                     tmpmaps->content=
    919                       createMap("value",
    920                                 (char*)mv);
    921                   xmlFree(mv);
    922                 }
    923                 else if(strcmp(mtoupper((char*)cur4->name),
    924                                mtoupper("ComplexData"))==0){
    925                   /**
    926                    * Get every attribute from a Reference node
    927                    * mimeType, encoding, schema
    928                    */
    929                   char *coms[2];
    930                   coms[0]="mimeType";
    931                   coms[1]="encoding";
    932                   coms[2]="schema";
    933                   for(int l=0;l<2;l++){
    934 #ifdef DEBUG
    935                     fprintf(stderr,"*** %s ***\t",coms[l]);
    936 #endif
    937                     xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
    938                     if(val!=NULL && strlen((char*)val)>0){
    939                       if(tmpmaps->content!=NULL)
    940                         addToMap(tmpmaps->content,coms[l],(char*)val);
    941                       else
    942                         tmpmaps->content=createMap(coms[l],(char*)val);
    943                     }
    944 #ifdef DEBUG
    945                     fprintf(stderr,"%s\n",val);
    946 #endif
    947                     xmlFree(val);
    948                   }
    949                   xmlChar* mv=xmlNodeListGetString(doc,
    950                                                    cur4->xmlChildrenNode,1);
    951                   if(tmpmaps->content!=NULL)
    952                     addToMap(tmpmaps->content,
    953                              "value",
    954                              (char*)mv);
    955                   else
    956                     tmpmaps->content=
    957                       createMap("value",
    958                                 (char*)mv);
    959                   xmlFree(mv);
    960                 }
    961                 cur4=cur4->next;
    962               }
    963             }
     1002            fprintf(stderr,"Header and Body was parsed from Reference \n");
     1003#endif
    9641004#ifdef DEBUG
    9651005            dumpMap(tmpmaps->content);
    9661006            fprintf(stderr, "= element 2 node \"%s\" = (%s)\n",
    967                     cur2->name,cur2->content); 
    968 #endif
    969             xmlNodePtr cur3=cur->children;
    970             while(cur3){
    971 #ifdef DEBUG
    972               fprintf(stderr, "= element 3 node \"%s\" = (%s)\n",cur3->name,
    973                       xmlNodeListGetString(doc,cur3->xmlChildrenNode,1));
    974 #endif
    975               if(strcmp(mtoupper((char*)cur3->name),
    976                         mtoupper("Title"))==0){
    977 #ifdef DEBUG
    978                 fprintf(stderr, "= element 3 node \"%s\" = (%s)\n",
    979                         cur3->name,xmlNodeListGetString(doc,cur3,1));
    980 #endif
     1007                    cur2->name,cur2->content);
     1008#endif
     1009          }
     1010          else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
     1011#ifdef DEBUG
     1012            fprintf(stderr,"DATA\n");
     1013#endif
     1014            xmlNodePtr cur4=cur2->children;
     1015            while(cur4){
     1016              while(cur4->type!=XML_ELEMENT_NODE)
     1017                cur4=cur4->next;
     1018
     1019              if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
     1020                /**
     1021                 * Get every attribute from a LiteralData node
     1022                 * dataType , uom
     1023                 */
     1024                char *lits[2];
     1025                lits[0]="dataType";
     1026                lits[1]="uom";
     1027                for(int l=0;l<2;l++){
     1028#ifdef DEBUG
     1029                  fprintf(stderr,"*** LiteralData %s ***",lits[l]);
     1030#endif
     1031                  xmlChar *val=xmlGetProp(cur4,BAD_CAST lits[l]);
     1032                  if(val!=NULL && strlen((char*)val)>0){
     1033                    if(tmpmaps->content!=NULL)
     1034                      addToMap(tmpmaps->content,lits[l],(char*)val);
     1035                    else
     1036                      tmpmaps->content=createMap(lits[l],(char*)val);
     1037                  }
     1038#ifdef DEBUG
     1039                  fprintf(stderr,"%s\n",val);
     1040#endif
     1041                  xmlFree(val);
     1042                }
    9811043              }
    982               cur3=cur3->children;
     1044              else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
     1045                /**
     1046                 * Get every attribute from a Reference node
     1047                 * mimeType, encoding, schema
     1048                 */
     1049                char *coms[3];
     1050                coms[0]="mimeType";
     1051                coms[1]="encoding";
     1052                coms[2]="schema";
     1053                for(int l=0;l<3;l++){
     1054#ifdef DEBUG
     1055                  fprintf(stderr,"*** ComplexData %s ***",coms[l]);
     1056#endif
     1057                  xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
     1058                  if(val!=NULL && strlen((char*)val)>0){
     1059                    if(tmpmaps->content!=NULL)
     1060                      addToMap(tmpmaps->content,coms[l],(char*)val);
     1061                    else
     1062                      tmpmaps->content=createMap(coms[l],(char*)val);
     1063                  }
     1064#ifdef DEBUG
     1065                  fprintf(stderr,"%s\n",val);
     1066#endif
     1067                  xmlFree(val);
     1068                }
     1069              }
     1070              xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
     1071              addToMap(tmpmaps->content,"value",(char*)mv);
     1072              xmlFree(mv);
     1073              cur4=cur4->next;
    9831074            }
    984             cur2=cur2->next;
    9851075          }
    986           cur1=cur1->children;
     1076#ifdef DEBUG
     1077          fprintf(stderr,"cur2 next \n");
     1078          fflush(stderr);
     1079#endif
     1080          cur2=cur2->next;
    9871081        }
    988         if(request_input_real_format==NULL)
    989           request_input_real_format=tmpmaps;
    990         else
    991           addMapsToMaps(&request_input_real_format,tmpmaps);
    992 #ifdef DEBUG
     1082#ifdef DEBUG
     1083        fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
     1084        fflush(stderr);
     1085#endif
     1086        addMapsToMaps(&request_input_real_format,tmpmaps);
     1087       
     1088#ifdef DEBUG
     1089        fprintf(stderr,"******TMPMAPS*****\n");
    9931090        dumpMaps(tmpmaps);
    994 #endif
    995         fflush(stderr);
     1091        fprintf(stderr,"******REQUESTMAPS*****\n");
     1092        dumpMaps(request_input_real_format);
     1093#endif
    9961094        tmpmaps=tmpmaps->next;
    9971095             
    998       } else {
    999 #ifdef DEBUG
    1000         fprintf(stderr, "= node \"%s\": type %d\n", cur->name, cur->type);
    1001 #endif
    10021096      }
    10031097#ifdef DEBUG
    … …  
    10051099#endif
    10061100    }
    1007    
    1008     xmlFree(tmps);
    1009     tmps=extractFromDoc(doc,"/*/*/*[local-name()='ResponseDocument']");
     1101#ifdef DEBUG
     1102    fprintf(stderr,"Search for response document node\n");
     1103#endif
     1104    xmlXPathFreeObject(tmpsptr);
     1105    //xmlFree(tmps);
     1106    tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='ResponseDocument']");
     1107    tmps=tmpsptr->nodesetval;
    10101108#ifdef DEBUG
    10111109    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
    … …  
    10211119         */
    10221120        if(tmpmaps==NULL){
    1023           tmpmaps=(maps*)malloc(MAPS_SIZE);
     1121          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     1122          if(tmpmaps == NULL){
     1123            return errorException(m, "Unable to allocate memory.", "InternalError");
     1124          }
    10241125          tmpmaps->name="unknownIdentifier";
    10251126          tmpmaps->next=NULL;
    … …  
    10531154        xmlNodePtr cur1=cur->children;
    10541155        while(cur1){
    1055           if(strcmp(mtoupper((char*)cur1->name),
    1056                     mtoupper("Output"))==0){
     1156          if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
    10571157            /**
    10581158             * Get every attribute from a Output node
    … …  
    10871187               * Indentifier
    10881188               */
    1089               if(strcmp(mtoupper((char*)cur2->name),
    1090                         mtoupper("Identifier"))==0){
     1189              if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
    10911190                xmlChar *val=
    10921191                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
    10931192                if(tmpmaps==NULL){
    1094                   tmpmaps=(maps*)malloc(MAPS_SIZE);
     1193                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     1194                  if(tmpmaps == NULL){
     1195                    return errorException(m, "Unable to allocate memory.", "InternalError");
     1196                  }
    10951197                  tmpmaps->name=strdup((char*)val);
    10961198                  tmpmaps->content=NULL;
    … …  
    11041206               * Title, Asbtract
    11051207               */
    1106               if(strcmp(mtoupper((char*)cur2->name),
    1107                         mtoupper("Title"))==0 ||
    1108                  strcmp(mtoupper((char*)cur2->name),
    1109                         mtoupper("Abstract"))==0){
     1208              if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
     1209                 xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
    11101210                xmlChar *val=
    11111211                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
    11121212                if(tmpmaps==NULL){
    1113                   tmpmaps=(maps*)malloc(MAPS_SIZE);
     1213                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     1214                  if(tmpmaps == NULL){
     1215                    return errorException(m, "Unable to allocate memory.", "InternalError");
     1216                  }
    11141217                  tmpmaps->name="missingIndetifier";
    11151218                  tmpmaps->content=createMap((char*)cur2->name,(char*)val);
    … …  
    11411244#endif
    11421245    }
    1143 
    1144     xmlFree(tmps);
    1145     tmps=extractFromDoc(doc,"/*/*/*[local-name()='RawDataOutput']");
     1246    xmlXPathFreeObject(tmpsptr);
     1247    //xmlFree(tmps);
     1248    tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='RawDataOutput']");
     1249    tmps=tmpsptr->nodesetval;
    11461250#ifdef DEBUG
    11471251    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
    … …  
    11671271        if(val!=NULL && strlen((char*)val)>0){
    11681272          if(tmpmaps==NULL){
    1169             tmpmaps=(maps*)malloc(MAPS_SIZE);
     1273            tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     1274            if(tmpmaps == NULL){
     1275              return errorException(m, "Unable to allocate memory.", "InternalError");
     1276            }
    11701277            tmpmaps->name="unknownIdentifier";
    11711278            tmpmaps->content=createMap(outs[l],(char*)val);
    … …  
    11861293         * Indentifier
    11871294         */
    1188         if(strcmp(mtoupper((char*)cur2->name),
    1189                   mtoupper("Identifier"))==0){
     1295        if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
    11901296          val=
    11911297            xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
    11921298          if(tmpmaps==NULL){
    1193             tmpmaps=(maps*)malloc(MAPS_SIZE);
     1299            tmpmaps=(maps*)calloc(1,MAPS_SIZE);
     1300            if(tmpmaps == NULL){
     1301              return errorException(m, "Unable to allocate memory.", "InternalError");
     1302            }
    11941303            tmpmaps->name=strdup((char*)val);
    11951304            tmpmaps->content=NULL;
    … …  
    12101319#endif
    12111320    }
    1212    
    1213     xmlFree(tmps);
     1321    xmlXPathFreeObject(tmpsptr);
     1322    //xmlFree(tmps);
    12141323    xmlCleanupParser();
    12151324  }
    12161325
    1217   if(CHECK_INET_HANDLE(hInternet))
    1218     InternetCloseHandle(hInternet);
     1326  //if(CHECK_INET_HANDLE(hInternet))
     1327  InternetCloseHandle(hInternet);
    12191328
    12201329#ifdef DEBUG
    … …  
    12221331  dumpMaps(request_input_real_format);
    12231332  dumpMaps(request_output_real_format);
    1224   dumpElements();
     1333  dumpMap(request_inputs);
    12251334#endif
    12261335
    … …  
    12281337   * Ensure that each requested arguments are present in the request
    12291338   * DataInputs and ResponseDocument / RawDataOutput
    1230    */
    1231   addDefaultValues(&request_input_real_format,s1->inputs,m,"inputs");
     1339   */ 
     1340  char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,"inputs");
     1341  if(strcmp(dfv,"")!=0){
     1342    char tmps[1024];
     1343    snprintf(tmps,1024,"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.",dfv);
     1344    map* tmpe=createMap("text",tmps);
     1345    addToMap(tmpe,"code","MissingParameterValue");
     1346    printExceptionReportResponse(m,tmpe);
     1347    freeMap(&tmpe);
     1348    free(tmpe);
     1349    freeMaps(&m);
     1350    free(m);
     1351    free(REQUEST);
     1352    freeMaps(&request_input_real_format);
     1353    free(request_input_real_format);
     1354    freeMaps(&request_output_real_format);
     1355    free(request_output_real_format);
     1356    freeMaps(&tmpmaps);
     1357    free(tmpmaps);
     1358    return 1;
     1359  }
    12321360  addDefaultValues(&request_output_real_format,s1->outputs,m,"outputs");
    12331361
    1234   const struct tm *tm;
    1235   size_t len;
    1236   time_t now;
    1237   char *sDate;
    1238  
    1239   now = time ( NULL );
    1240   tm = localtime ( &now );
    1241 
    1242   sDate = new char[TIME_SIZE];
     1362#ifdef DEBUG
     1363  fprintf(stderr,"REQUEST_INPUTS\n");
     1364  dumpMaps(request_input_real_format);
     1365  fprintf(stderr,"REQUEST_OUTPUTS\n");
     1366  dumpMaps(request_output_real_format);
     1367#endif
    12431368
    12441369  maps* curs=getMaps(m,"env");
    … …  
    12801405  }
    12811406 
    1282   len = strftime ( sDate, TIME_SIZE, "%d-%B-%YT%I:%M:%SZ", tm );
    1283 
    12841407#ifdef DEBUG
    12851408  dumpMap(request_inputs);
    … …  
    12971420#endif
    12981421
     1422  if(r_inputs!=NULL)
     1423    if(strcasecmp(r_inputs->value,"false")==0)
     1424      r_inputs=NULL;
    12991425  if(r_inputs==NULLMAP){
    13001426    /**
    … …  
    13071433    fflush(stderr);
    13081434#endif
    1309 
    1310         if(strncmp(mtoupper(r_inputs->value),"C",1)==0){
     1435    if(strncasecmp(r_inputs->value,"C",1)==0){
    13111436      r_inputs=getMap(request_inputs,"metapath");
    1312       sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
    1313           char *altPath=strdup(tmps1);
     1437      if(r_inputs!=NULL)
     1438        sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
     1439      else
     1440        sprintf(tmps1,"%s/",ntmp);
     1441      char *altPath=strdup(tmps1);
    13141442      r_inputs=getMap(s1->content,"ServiceProvider");
    13151443      sprintf(tmps1,"%s/%s",altPath,r_inputs->value);
    1316           free(altPath);
     1444      free(altPath);
    13171445#ifdef DEBUG
    13181446      fprintf(stderr,"Trying to load %s\n",tmps1);
    13191447#endif
    13201448#ifdef WIN32
    1321           HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
     1449      HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
    13221450#else
    13231451      void* so = dlopen(tmps1, RTLD_LAZY);
    13241452#endif
     1453#ifdef DEBUG
    13251454#ifdef WIN32
    13261455      DWORD errstr;
    1327           errstr = GetLastError();
    1328 #ifdef DEBUG
    1329           fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
    1330 #endif
     1456      errstr = GetLastError();
     1457      fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
    13311458#else
    13321459      char *errstr;
    1333           errstr = dlerror();
     1460      errstr = dlerror();
     1461#endif
    13341462#endif
    13351463
    … …  
    13421470#ifdef DEBUG
    13431471        dumpMap(r_inputs);
    1344         fprintf(stderr,"%s %s",r_inputs->value,mtoupper(r_inputs->value));
     1472        fprintf(stderr,"%s\n",r_inputs->value);
    13451473        fflush(stderr);
    13461474#endif
    1347         if(strcmp(mtoupper(r_inputs->value),"C-FORTRAN")==0){
     1475        if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
    13481476#ifdef WIN32
    13491477          //Strange return value needed here !
    … …  
    13521480          r_inputs=getMap(request_inputs,"Identifier");
    13531481          char fname[1024];
    1354           sprintf(fname,"%s",r_inputs->value);
     1482          sprintf(fname,"%s_",r_inputs->value);
    13551483#ifdef DEBUG
    13561484          fprintf(stderr,"Try to load function %s\n",fname);
    … …  
    13711499          fprintf(stderr,"Function loaded %s\n",errstr);
    13721500#endif 
     1501
    13731502          char main_conf[10][30][1024];
    13741503          char inputs[10][30][1024];
    … …  
    13901519          charxxxToMaps((char***)&outputs[0],&request_output_real_format);
    13911520        }else{
     1521#ifdef DEBUG
    13921522#ifdef WIN32
    13931523          errstr = GetLastError();
    1394 #ifdef DEBUG
    13951524          fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
    13961525#endif
    … …  
    14041533          execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value);
    14051534#ifdef DEBUG
    1406           /*if(!execute)*/
    14071535          errstr = GetLastError();
    14081536          fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
    1409           /*else
    1410           fprintf(stderr,"Function %s loaded\n",r_inputs->value);*/
    14111537#endif
    14121538#else
    … …  
    14331559#endif
    14341560        }
    1435 
    14361561        dlclose(so);
    14371562      } else {
    … …  
    14401565         */
    14411566        char tmps[1024];
     1567#ifdef WIN32
     1568        DWORD errstr = GetLastError();
     1569#else
     1570        char* errstr = dlerror();
     1571#endif
    14421572        sprintf(tmps,"C Library can't be loaded %s \n",errstr);
    14431573        map* tmps1=createMap("text",tmps);
    … …  
    14471577    }
    14481578    else{
    1449         if(strcmp(mtoupper(r_inputs->value),"PYTHON")==0){
    1450                 eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    1451         }
    1452         else
    1453 
    1454         #ifdef USE_JAVA
    1455         if(strcmp(mtoupper(r_inputs->value),"JAVA")==0){
     1579      if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
     1580        eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
     1581      }
     1582      else
     1583       
     1584#ifdef USE_JAVA
     1585        if(strncasecmp(r_inputs->value,"JAVA",4)==0){
    14561586          eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    14571587        }
    14581588        else
    1459         #endif
    1460 
    1461         #ifdef USE_PHP
    1462           if(strcmp(mtoupper(r_inputs->value),"PHP")==0){
     1589#endif
     1590
     1591#ifdef USE_PHP
     1592          if(strncasecmp(r_inputs->value,"PHP",3)==0){
    14631593            eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    14641594          }
    1465         else
    1466         #endif
    1467        
    1468         #ifdef USE_JS
    1469             if(strcmp(mtoupper(r_inputs->value),"JS")==0){
     1595          else
     1596#endif
     1597         
     1598#ifdef USE_JS
     1599            if(strncasecmp(r_inputs->value,"JS",2)==0){
    14701600              eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    14711601            }
    14721602            else
    1473          #endif
    1474                 {
    1475               char tmpv[1024];
    1476               sprintf(tmpv,"Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n",r_inputs->value);
    1477               map* tmps=createMap("text",tmpv);
    1478               printExceptionReportResponse(m,tmps);
    1479               return(-1);
    1480             }
     1603#endif
     1604              {
     1605                char tmpv[1024];
     1606                sprintf(tmpv,"Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n",r_inputs->value);
     1607                map* tmps=createMap("text",tmpv);
     1608                printExceptionReportResponse(m,tmps);
     1609                return(-1);
     1610              }
    14811611    }
    14821612  }
    … …  
    14871617    fprintf(stderr,"\nPID : %d\n",cpid);
    14881618#endif
     1619
    14891620#ifndef WIN32
    1490         pid = fork ();
     1621    pid = fork ();
    14911622#else
    1492         pid = 0;
     1623    pid = 0;
    14931624#endif
    14941625    if (pid > 0) {
    … …  
    15061637       * process answer to http client.
    15071638       */
    1508       char tmp1[256];
    15091639      r_inputs=getMapFromMaps(m,"main","tmpPath");
    1510       sprintf(tmp1,"%s",r_inputs->value);
    1511       r_inputs=getMap(s1->content,"ServiceProvider");
    1512       sprintf(tmp1,"%s/%s",strdup(tmp1),r_inputs->value);
    1513       sprintf(tmp1,"%s_%d.xml",strdup(tmp1),cpid);
     1640      map* r_inputs1=getMap(s1->content,"ServiceProvider");
     1641      char* fbkp=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+16)*sizeof(char));
     1642      sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
     1643      char* flog=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+22)*sizeof(char));
     1644      sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
     1645      fprintf(stderr,"File to use as backup %s\n",fbkp);
    15141646#ifdef DEBUG
    15151647      fprintf(stderr,"RUN IN BACKGROUND MODE \n");
    15161648      fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
    1517       fprintf(stderr,"\nFILE TO STORE DATA %s\n",tmp1);
    1518 #endif
    1519       freopen(tmp1 , "w+", stdout);
     1649      fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
     1650#endif
     1651      freopen(fbkp , "w+", stdout);
    15201652      fclose(stdin);
    1521       r_inputs=getMapFromMaps(m,"main","tmpPath");
    1522       sprintf(tmp1,"%s",r_inputs->value);
    1523       r_inputs=getMap(s1->content,"ServiceProvider");
    1524       sprintf(tmp1,"%s/%s",strdup(tmp1),r_inputs->value);
    1525       sprintf(tmp1,"%s_%d_error.log",strdup(tmp1),cpid);
    1526       freopen(tmp1,"w+",stderr);
     1653      freopen(flog,"w+",stderr);
     1654      free(fbkp);
     1655      free(flog);
    15271656      /**
    15281657       * set status to SERVICE_STARTED and flush stdout to ensure full
    … …  
    15311660       * this way the data will be updated at the end of the process run.
    15321661       */
    1533       printProcessResponse1(m,request_inputs,cpid,
    1534                             s[0],r_inputs->value,SERVICE_STARTED,
     1662      printProcessResponse(m,request_inputs,cpid,
     1663                            s1,r_inputs->value,SERVICE_STARTED,
    15351664                            request_input_real_format,
    15361665                            request_output_real_format);
    … …  
    15461675#endif
    15471676
    1548       if(strncmp(mtoupper(r_inputs->value),"C",1)==0){
     1677      if(strncasecmp(r_inputs->value,"C",1)==0){
     1678
    15491679        r_inputs=getMap(request_inputs,"metapath");
    1550         sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
    1551         r_inputs=getMap(s1->content,"ServiceProvider");
    1552         sprintf(tmps1,"%s/%s",strdup(tmps1),r_inputs->value);
     1680        if(r_inputs!=NULL){
     1681          sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
     1682          r_inputs=getMap(s1->content,"ServiceProvider");
     1683          if(r_inputs!=NULL)
     1684            sprintf(tmps1,"%s/%s",strdup(tmps1),r_inputs->value);
     1685        }else{
     1686          sprintf(tmps1,"%s/",ntmp);
     1687        }
     1688         
    15531689 
    15541690#ifdef DEBUG
    … …  
    15561692#endif
    15571693#ifdef WIN32
    1558           HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
     1694        HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
    15591695#else
    1560       void* so = dlopen(tmps1, RTLD_LAZY);
     1696        void* so = dlopen(tmps1, RTLD_LAZY);
    15611697#endif
    15621698#ifdef WIN32
    1563           DWORD errstr;
    1564           errstr = GetLastError();
     1699        DWORD errstr;
     1700        errstr = GetLastError();
    15651701#else
    1566           char *errstr;
    1567           errstr = dlerror();
     1702        char *errstr;
     1703        errstr = dlerror();
    15681704#endif
    15691705        if( so != NULL ) {
    … …  
    15721708          fprintf(stderr,"r_inputs->value = %s\n",r_inputs->value);
    15731709#endif
    1574           if(strcmp(mtoupper(r_inputs->value),"C-FORTRAN")==0){
     1710          if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
    15751711            r_inputs=getMap(request_inputs,"Identifier");
    15761712#ifdef DEBUG
    … …  
    15841720#endif
    15851721#ifdef WIN32
    1586           execute_t execute=(execute_t)GetProcAddress(so,fname);
     1722            execute_t execute=(execute_t)GetProcAddress(so,fname);
    15871723#else
    1588           execute_t execute=(execute_t)dlsym(so,fname);
     1724            execute_t execute=(execute_t)dlsym(so,fname);
    15891725#endif
    15901726#ifdef DEBUG
    15911727#ifdef WIN32
    1592           errstr = GetLastError();
     1728            errstr = GetLastError();
    15931729#else
    1594           errstr = dlerror();
     1730            errstr = dlerror();
    15951731#endif
    15961732#endif 
    … …  
    16221758#endif
    16231759#ifdef WIN32
    1624           execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value);
     1760            execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value);
    16251761#else
    1626           execute_t execute=(execute_t)dlsym(so,r_inputs->value);
     1762            execute_t execute=(execute_t)dlsym(so,r_inputs->value);
    16271763#endif
    16281764#ifdef DEBUG
    16291765#ifdef WIN32
    1630           errstr = GetLastError();
     1766            errstr = GetLastError();
    16311767#else
    1632           errstr = dlerror();
     1768            errstr = dlerror();
    16331769#endif
    16341770            fprintf(stderr,"Function loaded %s\n",errstr);
    … …  
    16381774             */
    16391775            eres=execute(&m,&request_input_real_format,&request_output_real_format);
    1640             dlclose(so);
    16411776          }
     1777          dlclose(so);
    16421778        } else {
    16431779          /**
    … …  
    16481784          map* tmps=createMap("text",tmps1);
    16491785          printExceptionReportResponse(m,tmps);
     1786          freeMap(&tmps);
     1787          free(tmps);
    16501788          exit(1);
    16511789        }
    16521790      } else{
    1653         if(strcmp(mtoupper(r_inputs->value),"PYTHON")==0){
     1791        if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
    16541792          eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    16551793        }
    16561794        else
    16571795
    1658         #ifdef USE_JAVA
    1659           if(strcmp(mtoupper(r_inputs->value),"JAVA")==0){
     1796#ifdef USE_JAVA
     1797          if(strncasecmp(r_inputs->value,"JAVA",4)==0){
    16601798            eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    16611799          }
    16621800          else
    1663         #endif
    1664        
    1665         #ifdef USE_PHP
    1666             if(strcmp(mtoupper(r_inputs->value),"PHP")==0){
     1801#endif
     1802           
     1803#ifdef USE_PHP
     1804            if(strncasecmp(r_inputs->value,"PHP",3)==0){
    16671805              eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    16681806            }
    16691807            else
    1670         #endif
    1671 
    1672         #ifdef USE_JS
    1673             if(strcmp(mtoupper(r_inputs->value),"JS")==0){
     1808#endif
     1809             
     1810#ifdef USE_JS
     1811              if(strncasecmp(r_inputs->value,"JS",2)==0){
    16741812                eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
    16751813              }
    1676             else
    1677         #endif
    1678         {
    1679               char tmpv[1024];
    1680               sprintf(tmpv,"Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n",r_inputs->value);
    1681               map* tmps=createMap("text",tmpv);
    1682               printExceptionReportResponse(m,tmps);
    1683               return -1;
    1684             }
     1814              else
     1815#endif
     1816                {
     1817                  char tmpv[1024];
     1818                  sprintf(tmpv,"Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n",r_inputs->value);
     1819                  map* tmps=createMap("text",tmpv);
     1820                  printExceptionReportResponse(m,tmps);
     1821                  return -1;
     1822                }
    16851823      }
    16861824 
    … …  
    16971835#ifdef DEBUG
    16981836  dumpMaps(request_output_real_format);
    1699 #endif
    1700   outputResponse(s1,request_input_real_format,
    1701                  request_output_real_format,request_inputs,
    1702                  cpid,m,eres);
    1703 
     1837  fprintf(stderr,"Function loaded and returned %d\n",eres);
     1838  fflush(stderr);
     1839#endif
     1840  if(eres!=-1)
     1841    outputResponse(s1,request_input_real_format,
     1842                   request_output_real_format,request_inputs,
     1843                   cpid,m,eres);
     1844
     1845  //if(getpid()==cpid){
     1846  freeService(&s1);
     1847  free(s1);
     1848  freeMaps(&m);
     1849  free(m);
     1850  freeMaps(&tmpmaps);
     1851  free(tmpmaps);
     1852 
     1853  freeMaps(&request_input_real_format);
     1854  free(request_input_real_format);
     1855 
     1856  //freeMap(&request_inputs);
     1857  //free(request_inputs);
     1858   
     1859  /* The following is requested but get issue using with Python support :/ */
     1860  freeMaps(&request_output_real_format);
     1861  free(request_output_real_format);
     1862 
     1863  free(REQUEST);
     1864  free(SERVICE_URL);
    17041865#ifdef DEBUG
    17051866  fprintf(stderr,"Processed response \n");
    … …  
    17071868  fflush(stderr);
    17081869#endif
     1870    //}
    17091871
    17101872  return 0;

  • trunk/zoo-services/ogr/base-vect-ops/Makefile

    r1 r9  
    1 CFLAGS=-I../../zoo-kernel/ -I./ `xml2-config --cflags` `python-config --cflags`  `gdal-config --cflags`   -DLINUX_FREE_ISSUE #-DDEBUG
     1CFLAGS=-I../../../zoo-kernel/ -I./ `xml2-config --cflags` `python-config --cflags`  `gdal-config --cflags`   -DLINUX_FREE_ISSUE #-DDEBUG
    22CC=gcc
    33
    44cgi-env/service.zo: service.c
    5         g++ ${CFLAGS} -shared -fpic -o cgi-env/ogr_service.zo ./service.c `gdal-config --libs`
     5        g++ ${CFLAGS} -shared -fpic -o cgi-env/ogr_service.zo ./service.c ../../../zoo-kernel/service_internal.o `gdal-config --libs`
    66
    77clean:

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Boundary.zcfg

    r1 r9  
    88 serviceType = C
    99 <MetaData>
    10    Test = Demo
     10   title = Demo
    1111 </MetaData>
    1212 <DataInputs>
    1313  [InputPolygon]
    14    Title = Polygon to be buffered
     14   Title = Polygon to compute boundary
    1515   Abstract = URI to a set of GML that describes the polygon.
    1616   minOccurs = 1
    1717   maxOccurs = 1
    1818   <MetaData lang="en">
    19     Test = Mon test 
     19    title = Mon test 
    2020   </MetaData>   
    2121   <ComplexData>
    2222    <Default>
    23      mimeType = text/js
     23     mimeType = text/xml
    2424     encoding = UTF-8
     25     schema = http://fooa/gml/3.1.0/polygon.xsd
    2526    </Default>
    2627    <Supported>
    … …  
    3031    </Supported>
    3132   </ComplexData>
    32   [BufferDistance]
    33    Title = Buffer Distance
    34    Abstract = Distance to be used to calculate buffer.
    35    minOccurs = 0
    36    maxOccurs = 1
    37    <LiteralData>
    38     DataType = float
    39     <Default>
    40      uom = meters
    41     </Default>
    42     <Supported>
    43      uom = feet
    44     </Supported>
    45    </LiteralData>
    4633 </DataInputs>
    4734 <DataOutputs>
    48   [Boundary]
     35  [Result]
    4936   Title = The geometry created
    5037   Abstract = The geometry containing the boundary of the geometry on which the method is invoked.
    5138   <MetaData lang="en">
    52     Test1 = Mon test 
     39    title = Mon test 
    5340   </MetaData>   
    5441   <ComplexData>
    5542    <Default>
    56      mimeType = text/xml
     43     mimeType = application/json
    5744     encoding = UTF-8
    58      schema = http://fooa/gml/3.1.0/polygon.xsd
     45     extension = js
    5946     asReference = true
    6047    </Default>
    6148    <Supported>
    6249     mimeType = text/xml
     50     encoding = UTF-8
     51     schema = http://fooa/gml/3.1.0/polygon.xsd
     52     extension = xml
     53    </Supported>
     54    <Supported>
     55     mimeType = text/xml
    6356     encoding = base64
    6457     schema = http://fooa/gml/3.1.0/polygon.xsd
    65     </Supported>
    66     <Supported>
    67      mimeType = text/js
    68      encoding = UTF-8
     58     extension = xml
    6959    </Supported>
    7060   </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Buffer.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData lang="en">
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    4949 </DataInputs>
    5050 <DataOutputs>
    51   [BufferedPolygon]
     51  [Result]
    5252   Title = Buffered Polygon
    5353   Abstract = GML stream describing the buffered polygon feature.
    5454   <MetaData lang="en">
    55     Test1 = Mon test 
     55    title = Mon test 
    5656   </MetaData>   
    5757   <ComplexData>
    5858    <Default>
    59      mimeType = text/xml
     59     mimeType = application/json
    6060     encoding = UTF-8
    61      schema = http://fooa/gml/3.1.0/polygon.xsd
     61     extension = js
    6262     asReference = true
    6363    </Default>
    … …  
    6666     encoding = base64
    6767     schema = http://fooa/gml/3.1.0/polygon.xsd
     68     extension = xml
    6869    </Supported>
    6970    <Supported>
    70      mimeType = application/json
     71     mimeType = text/xml
    7172     encoding = UTF-8
     73     schema = http://fooa/gml/3.1.0/polygon.xsd
     74     extension = xml
    7275    </Supported>
    7376   </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Centroid.zcfg

    r1 r9  
    11[Centroid]
    22 Title = Get the centroid of a polygon.
    3  Abstract = Create a buffer around a single polygon. Accepts the polygon as GML and provides GML output for the buffered feature.
     3 Abstract = Compute the geometry centroid.
    44 Profile = urn:ogc:wps:1.0.0:centroid
    55 processVersion = 2
    … …  
    99 serviceType = C
    1010 <MetaData lang="en">
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    1414  [InputPolygon]
    15    Title = Polygon to be buffered
    16    Abstract = URI to a set of GML that describes the polygon.
     15   Title = Polygon to get the centroid
     16   Abstract = The centroid which is not necessarily within the geometry.
    1717   minOccurs = 1
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3434 </DataInputs>
    3535 <DataOutputs>
    36   [Centroid]
     36  [Result]
    3737   Title = The Centroid
    3838   Abstract = JSON String / GML Entity of the centroid
    3939   <MetaData lang="en">
    40     Test1 = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    4343    <Default>
    44      mimeType = text/js
     44     mimeType = application/json
    4545     encoding = UTF-8
     46     extension = js
     47     asReference = true
    4648    </Default>
    47     <Supported>
    48      mimeType = text/xml
    49      encoding = base64
    50      schema = http://fooa/gml/3.1.0/point.xsd
    51     </Supported>
    5249    <Supported>
    5350     mimeType = text/xml
    5451     encoding = UTF-8
    5552     schema = http://fooa/gml/3.1.0/point.xsd
    56      asReference = true
     53     extension = xml
    5754    </Supported>
    5855   </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/ConvexHull.zcfg

    r1 r9  
    88 serviceType = C
    99 <MetaData lang="en">
    10    Test = Demo
     10   title = Demo
    1111 </MetaData>
    1212 <DataInputs>
    1313  [InputPolygon]
    14    Title = Polygon to compute are
     14   Title = Polygon to compute convexhull
    1515   Abstract = URI to a set of GML that describes the polygon.
    1616   minOccurs = 1
    1717   maxOccurs = 1
    1818   <MetaData lang="en">
    19    Test1 = Mon test
     19   title = Mon test
    2020   </MetaData>
    2121   <ComplexData>
    … …  
    3737   Abstract = The convex hull of the geometry
    3838   <MetaData lang="en">
    39     Test1 = Mon test 
     39    title = Mon test 
    4040   </MetaData>   
    4141   <ComplexData>
    4242    <Default>
     43     mimeType = application/json
     44     encoding = UTF-8
     45     extension = js
     46     asReference = true
     47    </Default>
     48    <Supported>
    4349     mimeType = text/xml
    4450     encoding = UTF-8
    4551     schema = http://fooa/gml/3.1.0/polygon.xsd
    46     </Default>
    47     <Supported>
    48      mimeType = text/xml
    49      encoding = base64
    50      schema = http://fooa/gml/3.1.0/polygon.xsd
     52     extension = xml
    5153    </Supported>
    5254   </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Difference.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData>
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3838   maxOccurs = 1
    3939   <MetaData lang="en">
    40     Test = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    … …  
    5454 </DataInputs>
    5555 <DataOutputs>
    56   [Distance]
    57    Title = The distance between two geometries
    58    Abstract = The shortest distance between the two geometries.
     56  [Result]
     57   Title = The difference between two geometries
     58   Abstract = The difference between the two geometries.
    5959   <MetaData lang="en">
    60     Test1 = Mon test 
     60    title = Mon test 
    6161   </MetaData>   
    6262    <ComplexData>
    … …  
    6464       mimeType = application/json
    6565       encoding = UTF-8
     66       extension = js
    6667     </Default>
    6768     <Supported>
    … …  
    6970      schema = http://fooa/gml/3.1.0/polygon.xsd
    7071      encoding = UTF-8
     72      extension = xml
    7173     </Supported>
    7274    </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Distance.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData>
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3838   maxOccurs = 1
    3939   <MetaData lang="en">
    40     Test = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    … …  
    5858   Abstract = The shortest distance between the two geometries.
    5959   <MetaData lang="en">
    60     Test1 = Mon test 
     60    title = Mon test 
    6161   </MetaData>   
    6262    <LiteralData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/GetArea.zcfg

    r1 r9  
    88 serviceType = C
    99 <MetaData lang="en">
    10    Test = Demo
     10   title = Demo
    1111 </MetaData>
    1212 <DataInputs>
    … …  
    1717   maxOccurs = 1
    1818   <MetaData lang="en">
    19    Test1 = Mon test
     19   title = Mon test
    2020   </MetaData>
    2121   <ComplexData>
    … …  
    3737   Abstract = The Computed Area Value
    3838   <MetaData lang="en">
    39     Test1 = Mon test 
     39    title = Mon test 
    4040   </MetaData>   
    4141   <LiteralData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Intersection.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData>
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3838   maxOccurs = 1
    3939   <MetaData lang="en">
    40     Test = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    … …  
    5454 </DataInputs>
    5555 <DataOutputs>
    56   [Distance]
    57    Title = The distance between two geometries
    58    Abstract = The shortest distance between the two geometries.
     56  [Result]
     57   Title = Intersection of geometries
     58   Abstract = A new geometry representing the intersection or NULL if there is no intersection or an error occurs.
    5959   <MetaData lang="en">
    60     Test1 = Mon test 
     60    title = Mon test 
    6161   </MetaData>   
    6262    <ComplexData>
    … …  
    6464       mimeType = application/json
    6565       encoding = UTF-8
     66       extension = js
    6667     </Default>
    6768     <Supported>
    … …  
    6970      schema = http://fooa/gml/3.1.0/polygon.xsd
    7071      encoding = UTF-8
     72      extension = xml
    7173     </Supported>
    7274    </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/SymDifference.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData>
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3838   maxOccurs = 1
    3939   <MetaData lang="en">
    40     Test = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    … …  
    5454 </DataInputs>
    5555 <DataOutputs>
    56   [Distance]
    57    Title = The distance between two geometries
    58    Abstract = The shortest distance between the two geometries.
     56  [Result]
     57   Title = The resulting geometry
     58   Abstract = The symmetric difference of two geometries
    5959   <MetaData lang="en">
    60     Test1 = Mon test 
     60    title = Mon test 
    6161   </MetaData>   
    6262    <ComplexData>
    … …  
    6464       mimeType = application/json
    6565       encoding = UTF-8
     66       extension = js
    6667     </Default>
    6768     <Supported>
    … …  
    6970      schema = http://fooa/gml/3.1.0/polygon.xsd
    7071      encoding = UTF-8
     72      extension = xml
    7173     </Supported>
    7274    </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/cgi-env/Union.zcfg

    r1 r9  
    99 serviceType = C
    1010 <MetaData>
    11    Test = Demo
     11   title = Demo
    1212 </MetaData>
    1313 <DataInputs>
    … …  
    1818   maxOccurs = 1
    1919   <MetaData lang="en">
    20     Test = Mon test 
     20    title = Mon test 
    2121   </MetaData>   
    2222   <ComplexData>
    … …  
    3838   maxOccurs = 1
    3939   <MetaData lang="en">
    40     Test = Mon test 
     40    title = Mon test 
    4141   </MetaData>   
    4242   <ComplexData>
    … …  
    5454 </DataInputs>
    5555 <DataOutputs>
    56   [Distance]
    57    Title = The distance between two geometries
    58    Abstract = The shortest distance between the two geometries.
     56  [Result]
     57   Title = The union of two geometries
     58   Abstract = The geometry representing the union of the two geometries.
    5959   <MetaData lang="en">
    60     Test1 = Mon test 
     60    title = Mon test 
    6161   </MetaData>   
    6262    <ComplexData>
    … …  
    6464       mimeType = application/json
    6565       encoding = UTF-8
     66       extension = js
    6667     </Default>
    6768     <Supported>
    … …  
    6970      schema = http://fooa/gml/3.1.0/polygon.xsd
    7071      encoding = UTF-8
     72      extension = xml
    7173     </Supported>
    7274    </ComplexData>

  • trunk/zoo-services/ogr/base-vect-ops/service.c

    r1 r9  
    2323 */
    2424
    25 #include "cpl_minixml.h"
     25#include "cpl_conv.h"
    2626#include "ogr_api.h"
     27#include "ogr_geometry.h"
     28#include "geos_c.h"
    2729#include "service.h"
    2830
    … …  
    3941#include <openssl/buffer.h>
    4042
    41   xmlNodeSet* extractFromDoc(xmlDocPtr,char*);
    4243  void printExceptionReportResponse(maps*,map*);
    4344  char *base64(const unsigned char *input, int length);
    … …  
    7172    }
    7273    xmlDocDumpFormatMemory(ndoc, &xmlbuff, &buffersize, 1);
    73     char *tmp=strdup(strstr((char*)xmlbuff,"?>")+2);
     74    char *tmp=(char*)calloc((xmlStrlen(xmlStrstr(xmlbuff,BAD_CAST "?>"))-1),sizeof(char));
     75    sprintf(tmp,"%s",xmlStrstr(xmlbuff,BAD_CAST "?>")+2);
     76    //strdup(strstr((char*)xmlbuff,"?>")+2);
    7477    xmlXPathFreeObject(xpathObj);
    75     xmlXPathFreeContext(xpathCtx); 
     78    xmlXPathFreeContext(xpathCtx);
    7679    xmlFree(xmlbuff);
    7780    xmlFreeDoc(doc);
     81    xmlFreeDoc(ndoc);
    7882    xmlCleanupParser();
    7983#ifdef DEBUG
    … …  
    8185#endif
    8286    OGRGeometryH res=OGR_G_CreateFromGML(tmp);
     87    free(tmp);
    8388    if(res==NULL){
    84         map* tmp=createMap("text","Unable to call OGR_G_CreatFromGML");
    85         addToMap(tmp,"code","NoApplicableCode");
    86         printExceptionReportResponse(conf,tmp);
    87         exit(0);
     89      map* tmp=createMap("text","Unable to call OGR_G_CreatFromGML");
     90      addToMap(tmp,"code","NoApplicableCode");
     91      printExceptionReportResponse(conf,tmp);
     92      exit(0);
    8893    }
    8994    else
    90         return OGR_G_CreateFromGML(tmp);
     95      return res;//OGR_G_CreateFromGML(tmp);
     96  }
     97
     98  int Simplify(maps*& conf,maps*& inputs,maps*& outputs){
     99    maps* cursor=inputs;
     100    OGRGeometryH geometry,res;
     101    double tolerance;
     102    map* tmp0=getMapFromMaps(cursor,"Tolerance","value");
     103    if(tmp0==NULL){
     104      tolerance=atof("2.0");
     105    }
     106    else
     107      tolerance=atof(tmp0->value);
     108    fprintf(stderr,"Tolerance for Simplify %f",tolerance);
     109    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
     110    if(!tmp)
     111      return SERVICE_FAILED;
     112    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeTime");
     113    if(tmp1!=NULL){
     114      if(strncmp(tmp1->value,"text/js",7)==0 ||
     115         strncmp(tmp1->value,"application/json",7)==0)
     116        geometry=OGR_G_CreateGeometryFromJson(tmp->value);
     117      else
     118        geometry=createGeometryFromGML(conf,tmp->value);
     119    }
     120    else
     121      geometry=createGeometryFromGML(conf,tmp->value);
     122    GEOSGeometry* ggeometry=((OGRGeometry *) geometry)->exportToGEOS();
     123    GEOSGeometry* gres=GEOSTopologyPreserveSimplify(ggeometry,tolerance);
     124    res=OGRGeometryFactory::createFromGEOS(gres);
     125    if(tmp1!=NULL){
     126      if(strncmp(tmp1->value,"text/js",7)==0 ||
     127         strncmp(tmp1->value,"application/json",16)==0){
     128        outputs->content=createMap("value",OGR_G_ExportToJson(tmp->value));
     129        addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
     130        addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
     131      }
     132      else{
     133        outputs->content=createMap("value",OGR_G_ExportToGML(res));
     134        addMapToMap(&outputs->content,createMap("mimeType","text/xml"));
     135        addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
     136        addMapToMap(&outputs->content,createMap("schema","http://fooa/gml/3.1.0/polygon.xsd"));
     137      }
     138    }else{
     139      outputs->content=createMap("value",OGR_G_ExportToJson(res));
     140      addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
     141      addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
     142    }
     143    outputs->next=NULL;
     144    //GEOSFree(ggeometry);
     145    //GEOSFree(gres);
     146    OGR_G_DestroyGeometry(res);
     147    OGR_G_DestroyGeometry(geometry);
     148    return SERVICE_SUCCEEDED;
     149  }
     150
     151
     152  int applyOne(maps*& conf,maps*& inputs,maps*& outputs,OGRGeometryH (*myFunc)(OGRGeometryH)){
     153#ifdef DEBUG
     154    fprintf(stderr,"\nService internal print\n");
     155#endif
     156    maps* cursor=inputs;
     157    OGRGeometryH geometry,res;
     158#ifdef DEBUG
     159    dumpMaps(cursor);
     160#endif
     161    map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
     162    if(!tmp)
     163      return SERVICE_FAILED;
     164    fprintf(stderr,"Service internal print \n");
     165    dumpMaps(inputs);
     166    fprintf(stderr,"/Service internal print \n");
     167    map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
     168    fprintf(stderr,"Service internal print \n");
     169    dumpMap(tmp1);
     170    fprintf(stderr,"/Service internal print \n");
     171    if(tmp1!=NULL){
     172      if(strncmp(tmp1->value,"text/js",7)==0 ||
     173         strncmp(tmp1->value,"application/json",7)==0)
     174        geometry=OGR_G_CreateGeometryFromJson(tmp->value);
     175      else
     176        geometry=createGeometryFromGML(conf,tmp->value);
     177    }
     178    else
     179      geometry=createGeometryFromGML(conf,tmp->value);
     180    res=(*myFunc)(geometry);
     181    fprintf(stderr,"Service internal print \n");
     182    dumpMaps(outputs);
     183    fprintf(stderr,"/Service internal print \n");
     184    map *tmp_2=getMapFromMaps(outputs,"Result","mimeType");
     185    fprintf(stderr,"Service internal print \n");
     186    dumpMap(tmp_2);
     187    fprintf(stderr,"/Service internal print \n");
     188    if(tmp_2!=NULL){
     189      if(strncmp(tmp_2->value,"text/js",7)==0 ||
     190         strncmp(tmp_2->value,"application/json",16)==0){
     191        char *tres=OGR_G_ExportToJson(res);
     192        addToMap(outputs->content,"value",tres);
     193        free(tres);
     194        addToMap(outputs->content,"mimeType","text/plain");
     195        addToMap(outputs->content,"encoding","UTF-8");
     196      }
     197      else{
     198        char *tres=OGR_G_ExportToGML(res);
     199        addToMap(outputs->content,"value",tres);
     200        free(tres);
     201      }
     202    }else{
     203      char *tres=OGR_G_ExportToJson(res);
     204      addToMap(outputs->content,"value",tres);
     205      free(tres);
     206      addToMap(outputs->content,"mimeType","text/plain");
     207      addToMap(outputs->content,"encoding","UTF-8");
     208    }
     209    outputs->next=NULL;
     210#ifdef DEBUG
     211    dumpMaps(outputs);
     212    fprintf(stderr,"\nService internal print\n===\n");
     213#endif
     214    OGR_G_DestroyGeometry(res);
     215    OGR_G_DestroyGeometry(geometry);
     216    //CPLFree(res);
     217    //CPLFree(geometry);
     218    fprintf(stderr,"Service internal print \n");
     219    dumpMaps(outputs);
     220    fprintf(stderr,"/Service internal print \n");
     221    return SERVICE_SUCCEEDED;
     222  }
     223
     224#ifdef WIN32
     225  __declspec(dllexport)
     226#endif
     227int Buffer(maps*& conf,maps*& inputs,maps*& outputs){
     228   OGRGeometryH geometry,res;
     229   map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
     230   if(tmp==NULL)
     231     return SERVICE_FAILED;
     232   map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
     233   if(strncmp(tmp1->value,"application/json",16)==0)
     234     geometry=OGR_G_CreateGeometryFromJson(tmp->value);
     235   else
     236     geometry=createGeometryFromGML(conf,tmp->value);
     237   int bufferDistance=1;
     238   tmp=getMapFromMaps(inputs,"BufferDistance","value");
     239   if(tmp!=NULL)
     240                bufferDistance=atoi(tmp->value);
     241   res=OGR_G_Buffer(geometry,bufferDistance,30);
     242   tmp1=getMapFromMaps(outputs,"Result","mimeType");
     243   if(strncmp(tmp1->value,"application/json",16)==0){
     244                addToMap(outputs->content,"value",OGR_G_ExportToJson(res));
     245                addToMap(outputs->content,"mimeType","text/plain");
     246   }
     247   else{
     248                addToMap(outputs->content,"value",OGR_G_ExportToGML(res));
     249   }
     250   outputs->next=NULL;
     251   OGR_G_DestroyGeometry(geometry);
     252   OGR_G_DestroyGeometry(res);
     253   return SERVICE_SUCCEEDED;
     254}
     255
     256/*  int Buffer(maps*& conf,maps*& inputs,maps*& outputs){
     257#ifdef DEBUG
     258    fprintf(stderr,"\nService internal print\n");
     259#endif
     260    maps* cursor=inputs;
     261    OGRGeometryH geometry,res;
     262    int bufferDistance;   
     263    if(cursor!=NULL){
     264#ifdef DEBUG
     265      fprintf(stderr,"\nService internal print\n");
     266      dumpMaps(cursor);
     267      fprintf(stderr,"\nService internal print\n");
     268      dumpMaps(inputs);
     269      fprintf(stderr,"\nService internal print\n");
     270#endif
     271      map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
     272      map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
     273      if(tmp1!=NULL){
     274        if(strncmp(tmp1->value,"application/json",16)==0 ||
     275           strncmp(tmp1->value,"text/js",7)==0)
     276          geometry=OGR_G_CreateGeometryFromJson(tmp->value);
     277        else
     278          geometry=createGeometryFromGML(conf,tmp->value);
     279      }
     280      else
     281        geometry=createGeometryFromGML(conf,tmp->value);
     282    }
     283    if(cursor!=NULL){
     284      map* tmp=getMapFromMaps(cursor,"BufferDistance","value");
     285      if(tmp==NULL){
     286        bufferDistance=10;
     287      }
     288      else
     289        bufferDistance=atoi(tmp->value);
     290#ifdef DEBUG
     291      fprintf(stderr,"\nService internal print (BufferDistance value: %i)\n",bufferDistance);
     292#endif
     293    }
     294#ifdef DEBUG
     295    dumpMaps(outputs);
     296#endif
     297    map* tmp=getMapFromMaps(outputs,"Result","mimeType");
     298    res=OGR_G_Buffer(geometry,bufferDistance,30);
     299#ifdef DEBUG
     300    dumpMap(tmp);
     301#endif
     302    if(tmp!=NULL){
     303#ifdef DEBUG
     304      dumpMap(tmp);
     305#endif
     306      if(strncmp(tmp->value,"application/json",16)==0){
     307        addToMap(outputs->content,"value",OGR_G_ExportToJson(res));
     308        addToMap(outputs->content,"mimeType","text/plain");
     309        addToMap(outputs->content,"encoding","UTF-8");
     310      }
     311      else if(strcmp(tmp->value,"text/xml")==0){
     312        xmlInitParser();
     313        xmlDocPtr doc = xmlParseMemory(tmp->value,strlen(tmp->value));
     314        xmlChar *xmlbuff;
     315        int buffersize;
     316        char *buff=OGR_G_ExportToGML(res);
     317        addToMap(outputs->content,"value",buff);
     318        map* tmp1=getMapFromMaps(outputs,"Result","encoding");
     319        if(tmp1!=NULL)
     320          addToMap(outputs->content,"encoding",tmp1->value);
     321        else
     322          addToMap(outputs->content,"encoding","UTF-8");
     323        xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
     324        xmlFree(xmlbuff);
     325        xmlFreeDoc(doc);
     326        xmlCleanupParser();
     327      }
     328      else{
     329        addToMap(outputs->content,"value",OGR_G_ExportToJson(res));
     330        addToMap(outputs->content,"mimeType","text/plain");
     331        addToMap(outputs->content,"encoding","UTF-8");
     332        outputs->next=NULL;
     333      }
     334      outputs->next=NULL;
     335    }
     336    else{
     337      addToMap(outputs->content,"value",OGR_G_ExportToJson(res));
     338      addToMap(outputs->content,"mimeType","text/plain");
     339      addToMap(outputs->content,"encoding","UTF-8");
     340      outputs->next=NULL;
     341    }
     342    outputs->next=NULL;
     343#ifdef DEBUG
     344    dumpMaps(outputs);
     345    fprintf(stderr,"\nService internal print\n===\n");
     346#endif
     347    OGR_G_DestroyGeometry(geometry);
     348    OGR_G_DestroyGeometry(res);
     349    return SERVICE_SUCCEEDED;
     350  }
     351*/
     352
     353#ifdef WIN32
     354  __declspec(dllexport)
     355#endif
     356  int Boundary(maps*& conf,maps*& inputs,maps*& outputs){
     357    return applyOne(conf,inputs,outputs,&OGR_G_GetBoundary);
     358  }
     359
     360#ifdef WIN32
     361  __declspec(dllexport)
     362#endif
     363  int ConvexHull(maps*& conf,maps*& inputs,maps*& outputs){
     364    return applyOne(conf,inputs,outputs,&OGR_G_ConvexHull);
     365  }
     366
     367
     368  OGRGeometryH MY_OGR_G_Centroid(OGRGeometryH hTarget){
     369    OGRGeometryH res;
     370    res=OGR_G_CreateGeometryFromJson("{\"type\": \"Point\", \"coordinates\": [0,0] }");
     371    OGRwkbGeometryType gtype=OGR_G_GetGeometryType(hTarget);
     372    if(gtype!=wkbPolygon){
     373      hTarget=OGR_G_ConvexHull(hTarget);
     374    }
     375    int c=OGR_G_Centroid(hTarget,res);
     376    return res;
     377  }
     378
     379#ifdef WIN32
     380  __declspec(dllexport)
     381#endif
     382  int Centroid(maps*& conf,maps*& inputs,maps*& outputs){
     383    return applyOne(conf,inputs,outputs,&MY_OGR_G_Centroid);
    91384  }
    92385
    … …  
    130423    }
    131424    res=(*myFunc)(geometry1,geometry2);
    132     outputs=(maps*)malloc(sizeof(maps*));
    133     outputs->name="Result";
    134     char tmpres[100];
    135     sprintf(tmpres,"%d",res);
    136     outputs->content=createMap("value",OGR_G_ExportToJson(res));
    137     addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    138     addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
     425    addToMap(outputs->content,"value",OGR_G_ExportToJson(res));
     426    addToMap(outputs->content,"mimeType","text/plain");
     427    addToMap(outputs->content,"encoding","UTF-8");
    139428    outputs->next=NULL;
     429    OGR_G_DestroyGeometry(geometry1);
     430    OGR_G_DestroyGeometry(geometry2);
     431    OGR_G_DestroyGeometry(res);
    140432    return SERVICE_SUCCEEDED;
    141433  }
    142 
     434 
    143435#ifdef WIN32
    144436  __declspec(dllexport)
    … …  
    162454  }
    163455
    164   int applyOne(maps*& conf,maps*& inputs,maps*& outputs,OGRGeometryH (*myFunc)(OGRGeometryH)){
    165 #ifdef DEBUG
    166     fprintf(stderr,"\nService internal print\n");
    167 #endif
    168     maps* cursor=inputs;
    169     OGRGeometryH geometry,res;
    170     int bufferDistance;
    171 #ifdef DEBUG
    172     dumpMaps(cursor);
    173 #endif
    174     map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
    175     if(!tmp)
    176       return SERVICE_FAILED;
    177     map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeTime");
    178     if(tmp1!=NULL){
    179       if(strncmp(tmp1->value,"text/js",7)==0)
    180         geometry=OGR_G_CreateGeometryFromJson(tmp->value);
    181       else
    182         geometry=createGeometryFromGML(conf,tmp->value);
    183       }
    184     else
    185       geometry=createGeometryFromGML(conf,tmp->value);
    186     res=(*myFunc)(geometry);
    187     /**
    188      * Here we should check what is the requested output.
    189      * Let's use JSON per default.
    190      */
    191     //outputs=(maps*)malloc(sizeof(maps*));
    192     outputs->name="Result";
    193     if(tmp1!=NULL){
    194       if(strncmp(tmp1->value,"text/js",7)==0){
    195         outputs->content=createMap("value",OGR_G_ExportToJson(tmp->value));
    196         addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    197         addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    198       }
    199       else{
    200         outputs->content=createMap("value",OGR_G_ExportToGML(res));
    201         addMapToMap(&outputs->content,createMap("mimeType","text/xml"));
    202         addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    203         addMapToMap(&outputs->content,createMap("schema","http://fooa/gml/3.1.0/polygon.xsd"));
    204       }
    205     }else{
    206       outputs->content=createMap("value",OGR_G_ExportToJson(res));
    207       addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    208       addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    209     }
    210     outputs->next=NULL;
    211 #ifdef DEBUG
    212     dumpMaps(outputs);
    213     fprintf(stderr,"\nService internal print\n===\n");
    214 #endif
    215     return SERVICE_SUCCEEDED;
    216   }
    217 
    218 #ifdef WIN32
    219   __declspec(dllexport)
    220 #endif
    221   int ConvexHull(maps*& conf,maps*& inputs,maps*& outputs){
    222     return applyOne(conf,inputs,outputs,&OGR_G_ConvexHull);
    223   }
    224 
    225 #ifdef WIN32
    226   __declspec(dllexport)
    227 #endif
    228   int Boundary(maps*& conf,maps*& inputs,maps*& outputs){
    229 #ifdef DEBUG
    230     fprintf(stderr,"\nService internal print\nStarting\n");
    231 #endif
    232     maps* cursor=inputs;
    233     OGRGeometryH geometry,res;
    234     int bufferDistance;
    235     xmlInitParser();
    236    
    237     if(cursor!=NULL){
    238       map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
    239       map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
    240       if(tmp1!=NULL){
    241         if(strncmp(tmp1->value,"text/js",7)==0)
    242           geometry=OGR_G_CreateGeometryFromJson(tmp->value);
    243         else
    244           geometry=createGeometryFromGML(conf,tmp->value);
    245       }
    246       else
    247         geometry=createGeometryFromGML(conf,tmp->value);
    248     }
    249     res=OGR_G_GetBoundary(geometry);
    250     outputs=(maps*)malloc(sizeof(maps*));
    251     outputs->name="Boundary";
    252     outputs->content=createMap("value",OGR_G_ExportToJson(res));
    253     addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    254     addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    255     /*
    256     outputs->content=createMap("value",OGR_G_ExportToGML(res));
    257     addMapToMap(&outputs->content,createMap("mimeType","text/xml"));
    258     addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    259     addMapToMap(&outputs->content,createMap("schema","http://fooa/gml/3.1.0/polygon.xsd"));
    260     */
    261     outputs->next=NULL;
    262 #ifdef DEBUG
    263     fprintf(stderr,"\nService internal print\n===\n");
    264 #endif
    265     xmlCleanupParser();
    266     return SERVICE_SUCCEEDED;
    267     }
    268 
    269 #ifdef WIN32
    270   __declspec(dllexport)
    271 #endif
    272   int Centroid(maps*& conf,maps*& inputs,maps*& outputs){
    273 #ifdef DEBUG
    274     fprintf(stderr,"\nService internal print\n");
    275 #endif
    276     maps* cursor=inputs;
    277     OGRGeometryH geometry,res=NULL;
    278     int bufferDistance;   
    279     if(cursor!=NULL){
    280 #ifdef DEBUG
    281       fprintf(stderr,"\nService internal print\n");
    282       dumpMaps(cursor);
    283       fprintf(stderr,"\nService internal print\n");
    284       dumpMaps(inputs);
    285       fprintf(stderr,"\nService internal print\n");
    286 #endif
    287       map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
    288       map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
    289       if(tmp1!=NULL){
    290         if(strncmp(tmp1->value,"application/json",16)==0)
    291           geometry=OGR_G_CreateGeometryFromJson(tmp->value);
    292         else
    293           geometry=createGeometryFromGML(conf,tmp->value);
    294       }
    295       else
    296         geometry=createGeometryFromGML(conf,tmp->value);
    297     }else{
    298     /**
    299      * Print WPSExceptionError message here !!
    300      */
    301     }
    302 #ifdef DEBUG
    303     dumpMaps(outputs);
    304 #endif
    305     res=OGR_G_CreateGeometryFromJson("{\"type\": \"Point\", \"coordinates\": [0,0] }");
    306     OGRwkbGeometryType gtype=OGR_G_GetGeometryType(geometry);
    307     if(gtype!=wkbPolygon){
    308         fprintf(stderr,"\n\nGeometry Type is not Polygon, let us use the ConvexHull !\n\n");
    309         geometry=OGR_G_ConvexHull(OGR_G_Clone(geometry));
    310     }else{
    311         fprintf(stderr,"\n\nGeometry Type is Polygon, thanks !\n\n");
    312     }
    313     int c=OGR_G_Centroid(geometry,res);
    314 #ifdef DEBUG
    315     fprintf(stderr,"\n\nC VALUE : %d\n\n",c);
    316 #endif
    317     map* tmp=getMapFromMaps(outputs,"Result","mimeType");
    318 #ifdef DEBUG
    319     dumpMaps(outputs);
    320 #endif
    321     if(tmp!=NULL){
    322 #ifdef DEBUG
    323       dumpMap(tmp);
    324 #endif
    325       if(strncmp(mtoupper(tmp->value),mtoupper("application/json"),16)==0){
    326         outputs->content=createMap("value",OGR_G_ExportToJson(res));
    327         addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    328         addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    329       }
    330       else if(strncmp(mtoupper(tmp->value),mtoupper("text/xml"),8)==0){
    331         /*xmlInitParser();
    332         xmlDocPtr doc = xmlParseMemory(tmp->value,strlen(tmp->value));
    333         xmlChar *xmlbuff;
    334         int buffersize;*/
    335         outputs->content=createMap("value",OGR_G_ExportToGML(res));
    336         addMapToMap(&outputs->content,createMap("mimeType","text/xml"));
    337         map* tmp1=getMapFromMaps(outputs,"Result","encoding");
    338         if(tmp1!=NULL)
    339           addMapToMap(&outputs->content,createMap("encoding",tmp1->value));
    340         else
    341           addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    342         /*xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
    343         outputs->content=createMap("value",OGR_G_ExportToGML(res));
    344         xmlFree(xmlbuff);
    345         xmlFreeDoc(doc);
    346         xmlCleanupParser();
    347         */
    348       }
    349     else{
    350       outputs=(maps*)malloc(sizeof(maps*));
    351       outputs->name="Result";
    352       outputs->content=createMap("value",OGR_G_ExportToJson(res));
    353       addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    354       addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    355       outputs->next=NULL;
    356     }
    357     outputs->next=NULL;
    358     }
    359     else{
    360       outputs=(maps*)malloc(sizeof(maps*));
    361       outputs->name="Result";
    362       outputs->content=createMap("value",OGR_G_ExportToJson(res));
    363       addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    364       addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    365       outputs->next=NULL;
    366     }
    367     outputs->next=NULL;
    368 #ifdef DEBUG
    369     dumpMaps(outputs);
    370     fprintf(stderr,"\nService internal print\n===\n");
    371 #endif
    372     return SERVICE_SUCCEEDED;
    373   }
    374 
    375 #ifdef WIN32
    376   __declspec(dllexport)
    377 #endif
    378   int Buffer(maps*& conf,maps*& inputs,maps*& outputs){
    379 #ifdef DEBUG
    380     fprintf(stderr,"\nService internal print\n");
    381 #endif
    382     maps* cursor=inputs;
    383     OGRGeometryH geometry,res;
    384     int bufferDistance;   
    385     if(cursor!=NULL){
    386 #ifdef DEBUG
    387       fprintf(stderr,"\nService internal print\n");
    388       dumpMaps(cursor);
    389       fprintf(stderr,"\nService internal print\n");
    390       dumpMaps(inputs);
    391       fprintf(stderr,"\nService internal print\n");
    392 #endif
    393       map* tmp=getMapFromMaps(inputs,"InputPolygon","value");
    394       map* tmp1=getMapFromMaps(inputs,"InputPolygon","mimeType");
    395       if(tmp1!=NULL){
    396         if(strncmp(tmp1->value,"application/json",16)==0)
    397           geometry=OGR_G_CreateGeometryFromJson(tmp->value);
    398         else
    399           geometry=createGeometryFromGML(conf,tmp->value);
    400       }
    401       else
    402         geometry=createGeometryFromGML(conf,tmp->value);
    403     }
    404     if(cursor!=NULL){
    405       map* tmp=getMapFromMaps(cursor,"BufferDistance","value");
    406       if(tmp==NULL){
    407         bufferDistance=10;
    408       }
    409       else
    410         bufferDistance=atoi(tmp->value);
    411 #ifdef DEBUG
    412       fprintf(stderr,"\nService internal print (BufferDistance value: %i)\n",bufferDistance);
    413 #endif
    414     }
    415 #ifdef DEBUG
    416     dumpMaps(outputs);
    417 #endif
    418     map* tmp=getMapFromMaps(outputs,"BufferedPolygon","mimeType");
    419     res=OGR_G_Buffer(geometry,bufferDistance,30);
    420 #ifdef DEBUG
    421     dumpMap(tmp);
    422 #endif
    423     if(tmp!=NULL){
    424 #ifdef DEBUG
    425       dumpMap(tmp);
    426 #endif
    427       if(strncmp(mtoupper(tmp->value),mtoupper("application/json"),16)==0){
    428         outputs->content=createMap("value",OGR_G_ExportToJson(res));
    429         addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    430         addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    431       }
    432       else if(strcmp(mtoupper(tmp->value),mtoupper("text/xml"))==0){
    433         xmlInitParser();
    434         xmlDocPtr doc = xmlParseMemory(tmp->value,strlen(tmp->value));
    435         xmlChar *xmlbuff;
    436         int buffersize;
    437         outputs->content=createMap("value",OGR_G_ExportToGML(res));
    438         addMapToMap(&outputs->content,createMap("mimeType","text/xml"));
    439         map* tmp1=getMapFromMaps(outputs,"BufferedPolygon","encoding");
    440         if(tmp1!=NULL)
    441           addMapToMap(&outputs->content,createMap("encoding",tmp1->value));
    442         else
    443           addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    444         xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
    445         outputs->content=createMap("value",OGR_G_ExportToGML(res));
    446         xmlFree(xmlbuff);
    447         xmlFreeDoc(doc);
    448         xmlCleanupParser();
    449       }
    450     else{
    451       outputs=(maps*)malloc(sizeof(maps*));
    452       outputs->name="BufferedPolygon";
    453       outputs->content=createMap("value",OGR_G_ExportToJson(res));
    454       addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    455       addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    456       outputs->next=NULL;
    457     }
    458     outputs->next=NULL;
    459     }
    460     else{
    461       outputs=(maps*)malloc(sizeof(maps*));
    462       outputs->name="BufferedPolygon";
    463       outputs->content=createMap("value",OGR_G_ExportToJson(res));
    464       addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    465       addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    466       outputs->next=NULL;
    467     }
    468     outputs->next=NULL;
    469 #ifdef DEBUG
    470     dumpMaps(outputs);
    471     fprintf(stderr,"\nService internal print\n===\n");
    472 #endif
    473     return SERVICE_SUCCEEDED;
    474   }
    475 
    476456#ifdef WIN32
    477457  __declspec(dllexport)
    478458#endif
    479459  int Union(maps*& conf,maps*& inputs,maps*& outputs){
    480 #ifdef DEBUG
    481     fprintf(stderr,"\nService internal print1\n");
    482     fflush(stderr);
    483 #endif
    484     maps* cursor=inputs;
    485     OGRGeometryH geometry1,geometry2;
    486     OGRGeometryH res;
    487     {
    488       map* tmp=getMapFromMaps(inputs,"InputEntity1","value");
    489       map* tmp1=getMapFromMaps(inputs,"InputEntity1","mimeType");
    490       if(tmp1!=NULL){
    491         if(strncmp(tmp1->value,"application/json",16)==0)
    492           geometry1=OGR_G_CreateGeometryFromJson(tmp->value);
    493         else
    494           geometry1=createGeometryFromGML(conf,tmp->value);
    495       }
    496       else
    497         geometry1=createGeometryFromGML(conf,tmp->value);
    498     }
    499     {
    500       map* tmp=getMapFromMaps(inputs,"InputEntity2","value");
    501       map* tmp1=getMapFromMaps(inputs,"InputEntity2","mimeType");
    502 #ifdef DEBUG
    503       fprintf(stderr,"MY MAP\n");
    504       dumpMap(tmp1);
    505       fprintf(stderr,"MY MAP\n");
    506 #endif
    507       if(tmp1!=NULL){
    508         if(strncmp(tmp1->value,"application/json",16)==0)
    509           geometry2=OGR_G_CreateGeometryFromJson(tmp->value);
    510         else
    511           geometry2=createGeometryFromGML(conf,tmp->value);
    512       }
    513       else
    514         geometry2=createGeometryFromGML(conf,tmp->value);
    515     }
    516     res=OGR_G_Union(geometry1,geometry2);
    517     outputs=(maps*)malloc(sizeof(maps*));
    518     outputs->name="Result";
    519     char tmpres[100];
    520     sprintf(tmpres,"%d",res);
    521     outputs->content=createMap("value",OGR_G_ExportToJson(res));
    522     addMapToMap(&outputs->content,createMap("mimeType","text/plain"));
    523     addMapToMap(&outputs->content,createMap("encoding","UTF-8"));
    524     outputs->next=NULL;
    525     return SERVICE_SUCCEEDED;
     460    return applyTwo(conf,inputs,outputs,&OGR_G_Union);
    526461  }
    527462
    … …  
    589524  }
    590525
     526#ifdef WIN32
     527  __declspec(dllexport)
     528#endif
    591529  int GetArea(maps*& conf,maps*& inputs,maps*& outputs){
    592530    fprintf(stderr,"GETAREA \n");
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