Changeset 9


Ignore:
Timestamp:
Sep 14, 2010, 2:04:55 PM (10 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                         siz