Changeset 917 for trunk/zoo-project/zoo-kernel

Timestamp:

May 7, 2019, 2:17:08 PM (5 years ago)

Author:

djay

Message:

Merge prototype-v0 branch in trunk

Location:

trunk

Files:

• . (modified) (1 prop)
• zoo-project/zoo-kernel/Makefile.in (modified) (5 diffs)
• zoo-project/zoo-kernel/ZOOMakefile.opts.in (modified) (5 diffs)
• zoo-project/zoo-kernel/caching.c (modified) (22 diffs)
• zoo-project/zoo-kernel/caching.h (modified) (1 diff)
• zoo-project/zoo-kernel/configure.ac (modified) (12 diffs)
• zoo-project/zoo-kernel/main_conf_read.y (modified) (3 diffs)
• zoo-project/zoo-kernel/makefile.vc (modified) (5 diffs)
• zoo-project/zoo-kernel/meta_sql.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/meta_sql.c)
• zoo-project/zoo-kernel/meta_sql.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/meta_sql.h)
• zoo-project/zoo-kernel/mimetypes.h (modified) (2 diffs)
• zoo-project/zoo-kernel/nmake.opt (modified) (2 diffs)
• zoo-project/zoo-kernel/request_parser.c (modified) (30 diffs)
• zoo-project/zoo-kernel/request_parser.h (modified) (2 diffs)
• zoo-project/zoo-kernel/response_print.c (modified) (73 diffs)
• zoo-project/zoo-kernel/response_print.h (modified) (6 diffs)
• zoo-project/zoo-kernel/server_internal.c (modified) (19 diffs)
• zoo-project/zoo-kernel/service.c (modified) (48 diffs)
• zoo-project/zoo-kernel/service.h (modified) (16 diffs)
• zoo-project/zoo-kernel/service_callback.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_callback.c)
• zoo-project/zoo-kernel/service_callback.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_callback.h)
• zoo-project/zoo-kernel/service_conf.y (modified) (5 diffs)
• zoo-project/zoo-kernel/service_internal.c (modified) (9 diffs)
• zoo-project/zoo-kernel/service_internal.h (modified) (4 diffs)
• zoo-project/zoo-kernel/service_internal_hpc.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_internal_hpc.c)
• zoo-project/zoo-kernel/service_internal_hpc.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_internal_hpc.h)
• zoo-project/zoo-kernel/service_internal_java.c (modified) (11 diffs)
• zoo-project/zoo-kernel/service_internal_js.c (modified) (7 diffs)
• zoo-project/zoo-kernel/service_internal_js.h (modified) (1 diff)
• zoo-project/zoo-kernel/service_internal_mono.c (modified) (12 diffs)
• zoo-project/zoo-kernel/service_internal_mono.h (modified) (1 diff)
• zoo-project/zoo-kernel/service_internal_ms.c (modified) (54 diffs)
• zoo-project/zoo-kernel/service_internal_ms.h (modified) (1 diff)
• zoo-project/zoo-kernel/service_internal_php7.c (modified) (1 diff)
• zoo-project/zoo-kernel/service_internal_python.c (modified) (18 diffs)
• zoo-project/zoo-kernel/service_internal_python.h (modified) (2 diffs)
• zoo-project/zoo-kernel/service_internal_r.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_internal_r.c)
• zoo-project/zoo-kernel/service_internal_r.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_internal_r.h)
• zoo-project/zoo-kernel/service_internal_ruby.c (modified) (6 diffs)
• zoo-project/zoo-kernel/service_internal_saga.c (modified) (14 diffs)
• zoo-project/zoo-kernel/service_json.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_json.c)
• zoo-project/zoo-kernel/service_json.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/service_json.h)
• zoo-project/zoo-kernel/service_yaml.c (modified) (1 diff)
• zoo-project/zoo-kernel/sql/schema.sql (modified) (1 diff)
• zoo-project/zoo-kernel/sql/zoo_collectiondb.sql (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/sql/zoo_collectiondb.sql)
• zoo-project/zoo-kernel/sqlapi.c (modified) (32 diffs)
• zoo-project/zoo-kernel/sqlapi.h (modified) (3 diffs)
• zoo-project/zoo-kernel/sshapi.c (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/sshapi.c)
• zoo-project/zoo-kernel/sshapi.h (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/sshapi.h)
• zoo-project/zoo-kernel/ulinet.c (modified) (18 diffs)
• zoo-project/zoo-kernel/ulinet.h (modified) (6 diffs)
• zoo-project/zoo-kernel/xslt (copied) (copied from branches/prototype-v0/zoo-project/zoo-kernel/xslt)
• zoo-project/zoo-kernel/zoo_loader.c (modified) (6 diffs)
• zoo-project/zoo-kernel/zoo_service_loader.c (modified) (69 diffs)

trunk/zoo-project/zoo-kernel/Makefile.in

@@ -9 +9 @@
 
 service.o: service.c service.h
-        gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
+        g++ ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
 
 main_conf_read.tab.c: main_conf_read.y service.h
@@ -38 +38 @@
         gcc -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c ulinet.c
 
+sshapi.o: sshapi.c
+        g++ -fPIC ${CFLAGS} -c sshapi.c
+
+service_json.o: service_json.c
+        g++ -fPIC ${JSON_CFLAGS} ${CFLAGS} -c service_json.c
+
+service_callback.o: service_callback.c
+        g++ -fPIC ${XML2CFLAGS} ${GDAL_CFLAGS} ${JSON_CFLAGS} ${CFLAGS} -c service_callback.c
+
 request_parser.o: request_parser.c request_parser.h
         g++ -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c request_parser.c
 
 sqlapi.o: sqlapi.c sqlapi.h
-        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
+        g++ -fPIC ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
 
 caching.o: caching.c
@@ -48 +57 @@
 
 response_print.o: response_print.c response_print.h
-        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c response_print.c
+        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} ${HPC_ENABLED} -c response_print.c
 
 server_internal.o: server_internal.c server_internal.h service.h mimetypes.h
-        g++ ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
+        g++ ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
 
 service_internal.o: service_internal.c service_internal.h service.h
-        gcc ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
+        gcc ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
 
 service_yaml.o: service_yaml.c service.h
         gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_yaml.c
+
+meta_sql.o: meta_sql.c meta_sql.h service.h
+        g++  ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -c meta_sql.c
 
 service_internal_ms.o: service_internal_ms.c
@@ -66 +78 @@
         g++ ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c service_internal_python.c
 
+service_internal_r.o: service_internal_r.c service.h
+        g++ ${XML2CFLAGS} ${RCFLAGS} ${CFLAGS} -c service_internal_r.c
+
 service_internal_otb.o: service_internal_otb.c service_internal_otb.h service.h
         g++ ${XML2CFLAGS} ${OTBCFLAGS} ${CFLAGS} -c service_internal_otb.c
+
+service_internal_hpc.o: service_internal_hpc.c service_internal_hpc.h service.h
+        g++  ${JSON_CFLAGS} ${XML2CFLAGS} ${HPCCFLAGS} ${CFLAGS} -c service_internal_hpc.c
 
 service_internal_saga.o: service_internal_saga.c service_internal_saga.h service.h
@@ -99 +117 @@
         g++ -c ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} service_loader.c
 
-zoo_service_loader.o: zoo_service_loader.c service.h version.h ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE}
-        g++ -g -O2 ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${PYTHON_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED}  -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
+zoo_service_loader.o: zoo_service_loader.c service.h version.h ${MS_FILE} ${R_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE}
+        g++ -g -O2 ${JSON_CFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${RCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${HPC_ENABLED} ${PYTHON_ENABLED} ${R_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED} ${METADB_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
 
 libzoo_service.${EXT}: version.h service_internal.o service.o sqlapi.o
-        gcc -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS}
+        g++ -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS} ${ZOO_LDFLAGS} ${MACOS_LD_FLAGS}
 
-zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE}
-        g++ -g -O2 ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
-        g++  ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
+zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${R_FILE} ${SAGA_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} ${CALLBACK_FILE}
+        g++ -g -O2 ${JSON_CFLAGS} ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
+        g++  ${JSON_CFLAGS} ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} ${R_FILE} ${CALLBACK_FILE} response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
 
-zcfg2yaml: zcfg2yaml.c service.h lex.sr.o service_conf.tab.o service_conf.y main_conf_read.tab.o lex.cr.o response_print.o server_internal.o service_internal.o ${MS_FILE} ${YAML_FILE}
+zcfg2yaml: zcfg2yaml.c service.h lex.sr.o service_conf.tab.o service_conf.y main_conf_read.tab.o lex.cr.o response_print.o server_internal.o service_internal.o ${MS_FILE} ${YAML_FILE} ${CALLBACK_FILE}
         g++ -g -O2 ${JSCFLAGS} ${RUBYCFLAGS} ${XML2CFLAGS} ${CFLAGS} -c zcfg2yaml.c  -fno-common -DPIC -o zcfg2yaml.o
-        g++  ${XML2CFLAGS} ${CFLAGS} zcfg2yaml.o server_internal.o service_internal.o ${MS_FILE} response_print.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o  ${YAML_FILE} -o zcfg2yaml -L. ${LDFLAGS}
+        g++  ${XML2CFLAGS} ${CFLAGS} zcfg2yaml.o caching.o ulinet.o ${CALLBACK_FILE} server_internal.o service_internal.o ${MS_FILE} response_print.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o  ${YAML_FILE} -o zcfg2yaml -L. ${LDFLAGS}
 
 install: zoo_loader.cgi

trunk/zoo-project/zoo-kernel/ZOOMakefile.opts.in

@@ -30 +30 @@
 YAML_FILE1=@YAML_FILE1@
 
+JSON_CFLAGS=@JSON_CPPFLAGS@
+JSON_LDFLAGS=@JSON_LDFLAGS@
+JSON_FILE=@JSON_FILE@
+
+METADB_ENABLED=@METADB@
+METADB_FILE=@METADB_FILE@
+
+
 GDAL_CFLAGS=@GDAL_CFLAGS@
 GDAL_LIBS=@GDAL_LIBS@
@@ -50 +58 @@
 PYTHON_FILE=@PYTHON_FILE@
 
+RCFLAGS=@R_CPPFLAGS@
+RLDFLAGS=@R_LDFLAGS@
+R_ENABLED=@R_ENABLED@
+R_FILE=@R_FILE@
+
 RUBYCFLAGS=@RUBY_CPPFLAGS@
 RUBYLDFLAGS=@RUBY_LDFLAGS@
@@ -68 +81 @@
 
 ZOO_CFLAGS=-I${ZRPATH}/../thirds/cgic206/ -I${ZRPATH}/zoo-kernel/
-ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ -luuid
+ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ @UUID_LDFLAGS@
 
 JAVACFLAGS=@JAVA_CPPFLAGS@
@@ -80 +93 @@
 PHP_FILE=@PHP_FILE@
 
-
 PERLCFLAGS=@PERL_CPPFLAGS@
 PERLLDFLAGS=@PERL_LDFLAGS@
 PERL_ENABLED=@PERL_ENABLED@
 PERL_FILE=@PERL_FILE@
+
+HPCCFLAGS=@SSH2_CPPFLAGS@ @HPC_CPPFLAGS@
+HPCLDFLAGS=@SSH2_LDFLAGS@ @HPC_LDFLAGS@
+HPC_ENABLED=@HPC_ENABLED@
+HPC_FILES=@HPC_FILES@
+
+CALLBACK_FILE=@CALLBACK_FILE@
+CALLBACK_USE=@CALLBACK_USE@
 
 OTBCFLAGS=@OTB_CPPFLAGS@
@@ -101 +121 @@
 MONO_FILE=@MONO_FILE@
 
-CFLAGS=-Wdeclaration-after-statement @RELY_ON_DB@ @DEB_DEF@ -fpic @OPENSSL_CFLAGS@ ${FCGI_CFLAGS} ${YAML_CFLAGS} ${MACOS_CFLAGS} ${MS_CFLAGS} -I../../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
-LDFLAGS=-lzoo_service @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ -luuid ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS}
+CFLAGS=@CALLBACK_USE@ @SSH2_CPPFLAGS@ @PROJ_CPPFLAGS@ @RELY_ON_DB@ @DEB_DEF@ -fpic @OPENSSL_CFLAGS@ @UUID_CFLAGS@ ${FCGI_CFLAGS} ${YAML_CFLAGS} ${MACOS_CFLAGS} ${MS_CFLAGS} -I../../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
+LDFLAGS=-lzoo_service @SSH2_LDFLAGS@ @PROJ_LDFLAGS@ @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS} ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ @UUID_LDFLAGS@ ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS} ${RLDFLAGS} @JSON_LDFLAGS@ @XSLT_LDFLAGS@
 
 DATAROOTDIR=@datarootdir@/zoo-project

trunk/zoo-project/zoo-kernel/caching.c

@@ -23 +23 @@
  */
 
+#include <openssl/md5.h>
+#include <openssl/evp.h>
 #include "caching.h"
 #include "service.h"
 #include "service_internal.h"
 #include "response_print.h"
-#include <openssl/md5.h>
-#include <openssl/hmac.h>
-#include <openssl/evp.h>
-#include <openssl/bio.h>
-#include <openssl/buffer.h>
-
+#ifdef MS_FORCE_LOCAL_FILE_USE
+#include "ogr_api.h"
+#include "mapserver.h"
+#endif
 /**
  * Compute md5
@@ -41 +41 @@
  */
 char* getMd5(char* url){
-  EVP_MD_CTX md5ctx;
+  EVP_MD_CTX *md5ctx=EVP_MD_CTX_create();
   char* fresult=(char*)malloc((EVP_MAX_MD_SIZE+1)*sizeof(char));
   unsigned char result[EVP_MAX_MD_SIZE];
   unsigned int len;
-  EVP_DigestInit(&md5ctx, EVP_md5());
-  EVP_DigestUpdate(&md5ctx, url, strlen(url));
-  EVP_DigestFinal_ex(&md5ctx,result,&len);
-  EVP_MD_CTX_cleanup(&md5ctx);
+  EVP_DigestInit(md5ctx, EVP_md5());
+  EVP_DigestUpdate(md5ctx, url, strlen(url));
+  EVP_DigestFinal_ex(md5ctx,result,&len);
+  EVP_MD_CTX_destroy(md5ctx);
   int i;
   for(i = 0; i < len; i++){
     if(i>0){
-      char *tmp=strdup(fresult);
+      char *tmp=zStrdup(fresult);
       sprintf(fresult,"%s%02x", tmp,result[i]);
       free(tmp);
@@ -62 +62 @@
 }
 
+/**
+ * Compute md5 of a file
+ * 
+ * @param file the char* 
+ * @return a char* representing the md5 of the url
+ * @warning make sure to free resources returned by this function
+ */
+char* getMd5f(char* file){
+  EVP_MD_CTX *md5ctx=EVP_MD_CTX_create();
+  char* fresult=(char*)malloc((EVP_MAX_MD_SIZE+1)*sizeof(char));
+  unsigned char result[EVP_MAX_MD_SIZE];
+  unsigned int len;
+  int bytes;
+  int dlen=65536;
+  unsigned char data[65537];
+  FILE *inFile = fopen (file, "rb");
+  EVP_DigestInit(md5ctx, EVP_md5());
+  while ((bytes = fread (data, sizeof(unsigned char), dlen, inFile)) != 0)
+    EVP_DigestUpdate(md5ctx, data, bytes);
+  EVP_DigestFinal_ex(md5ctx,result,&len);
+  EVP_MD_CTX_destroy(md5ctx);
+  int i;
+  for(i = 0; i < len; i++){
+    if(i>0){
+      char *tmp=zStrdup(fresult);
+      sprintf(fresult,"%s%02x", tmp,result[i]);
+      free(tmp);
+    }
+    else
+      sprintf(fresult,"%02x",result[i]);
+  }
+  fclose (inFile);
+  return fresult;
+}
+
+
+
+/**
+ * Create a URL by appending every request header listed in the security 
+ * section.This imply that the URL will contain any authentication 
+ * informations that should be fowarded to the server from which de input
+ * was download.
+ * @param conf the main configuration maps
+ * @param request the URL to transform.
+ * @return a char* that contain the original URL plus potential header (only for
+ * hosts that are not shared).
+ * @warning Be sure to free the memory returned by this function.
+ */
+char* getFilenameForRequest(maps* conf, const char* request){
+  map* passThrough=getMapFromMaps(conf,"security","attributes");
+  map* targetHosts=getMapFromMaps(conf,"security","hosts");
+  char* passedHeader[10];
+  int cnt=0;
+  char *res=zStrdup(request);
+  char *toAppend=NULL;
+  if(passThrough!=NULL && targetHosts!=NULL){
+    char *tmp=zStrdup(passThrough->value);
+    char *token, *saveptr;
+    token = strtok_r (tmp, ",", &saveptr);
+    int i;
+    if((strstr(targetHosts->value,"*")!=NULL || isProtectedHost(targetHosts->value,request)==1) && strncasecmp(getProvenance(conf,request),"SHARED",6)!=0){
+      while (token != NULL){
+        int length=strlen(token)+6;
+        char* tmp1=(char*)malloc(length*sizeof(char));
+        map* tmpMap;
+        snprintf(tmp1,6,"HTTP_");
+        int j;
+        for(j=0;token[j]!='\0';j++){
+          if(token[j]!='-')
+            tmp1[5+j]=toupper(token[j]);
+          else
+            tmp1[5+j]='_';
+          tmp1[5+j+1]='\0';
+        }
+        tmpMap = getMapFromMaps(conf,"renv",tmp1);
+        if(tmpMap!=NULL){
+          if(toAppend==NULL){
+            toAppend=(char*)malloc((strlen(tmpMap->value)+1)*sizeof(char));
+            sprintf(toAppend,"%s",tmpMap->value);
+          }else{
+            char *tmp3=zStrdup(toAppend);
+            toAppend=(char*)realloc(toAppend,(strlen(tmpMap->value)+strlen(tmp3)+2)*sizeof(char));
+            sprintf(toAppend,"%s,%s",tmp3,tmpMap->value);
+            free(tmp3);
+          }
+        }
+        free(tmp1);
+        cnt+=1;
+        token = strtok_r (NULL, ",", &saveptr);
+      }
+    }
+    free(tmp);
+  }
+  if(toAppend!=NULL){
+    char *tmp3=zStrdup(res);
+    res=(char*)realloc(res,(strlen(tmp3)+strlen(toAppend)+1)*sizeof(char));
+    sprintf(res,"%s%s",tmp3,toAppend);
+    free(tmp3);
+    free(toAppend);
+  }
+  return res;
+}
+
+/**
+ * Store MD5 of the content of a file
+ * @file char* the full path of the file
+ */
+int storeMd5(char* file){
+  char* storage=zStrdup(file);
+  char* md5fstr=getMd5f(file);
+  storage[strlen(storage)-2]='m';
+  storage[strlen(storage)-1]='d';
+  FILE* fo=fopen(storage,"w+");
+  if(fo==NULL)
+    return 1;
+  fwrite(md5fstr,sizeof(char),strlen(md5fstr),fo);
+  free(md5fstr);
+  free(storage);
+  fclose(fo);
+  return 0;
+}
 
 /**
@@ -76 +197 @@
  * @param max_path the size of the allocated filepath buffer  
  */
+void cacheFile(maps* conf,char* request,char* mimeType,int length,char* filename){
+  map* tmp=getMapFromMaps(conf,"main","cacheDir");
+  char contentr[4096];
+  int cred=0;
+  if(tmp!=NULL){
+    char* myRequest=getFilenameForRequest(conf,request);
+    char* md5str=getMd5(myRequest);
+    free(myRequest);
+    char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
+    // Store md5
+    char* md5fstr=getMd5f(filename);
+    sprintf(fname,"%s/%s.zmd",tmp->value,md5str);
+    FILE* fo=fopen(fname,"w+");
+#ifdef DEBUG
+    fprintf(stderr,"filename: %s\n",filename);
+    fprintf(stderr,"MD5: %s\n",md5fstr);
+#endif
+    fwrite(md5fstr,sizeof(char),strlen(md5fstr),fo);
+    free(md5fstr);
+    fclose(fo);
+    
+    sprintf(fname,"%s/%s.zca",tmp->value,md5str);
+    zooLock* lck=lockFile(conf,fname,'w');
+    if(lck!=NULL){
+#ifdef DEBUG
+      fprintf(stderr,"Cache list : %s\n",fname);
+      fflush(stderr);
+#endif
+      FILE* fi=fopen(filename,"rb");
+      sprintf(fname,"%s/%s.zca",tmp->value,md5str);
+      fo=fopen(fname,"w+");
+      if(fo==NULL){
+#ifdef DEBUG
+        fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
+#endif
+        unlockFile(conf,lck);
+        return;
+      }
+      if(fi==NULL){
+#ifdef DEBUG
+        fprintf (stderr, "Failed to open %s for reading: %s\n",filename, strerror(errno));
+#endif
+        unlockFile(conf,lck);
+        return;
+      }
+      memset(contentr,0,4096);
+      while((cred=fread(contentr,sizeof(char),4096,fi))>0){
+        fwrite(contentr,sizeof(char),cred,fo);
+        fflush(fo);
+        memset(contentr,0,4096);
+      }
+      unlockFile(conf,lck);
+      fclose(fo);
+      fclose(fi);
+
+      // Store mimeType
+      sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
+      fo=fopen(fname,"w+");
+#ifdef DEBUG
+      fprintf(stderr,"MIMETYPE: %s\n",mimeType);
+#endif
+      fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
+      fclose(fo);
+
+      // Store provenance
+      sprintf(fname,"%s/%s.zcp",tmp->value,md5str);
+      fo=fopen(fname,"w+");
+      char* origin=getProvenance(conf,request);
+#ifdef DEBUG
+      fprintf(stderr,"ORIGIN: %s\n",mimeType);
+#endif
+      fwrite(origin,sizeof(char),strlen(origin),fo);
+      fclose(fo);
+
+      free(md5str);
+
+    }
+    free(fname);
+  }
+}
+
+/**
+ * Cache a file for a given request.
+ * For each cached file, the are two files stored, a .zca and a .zcm containing
+ * the downloaded content and the mimeType respectively. 
+ *
+ * @param conf the maps containing the settings of the main.cfg file
+ * @param request the url used too fetch the content
+ * @param content the downloaded content
+ * @param mimeType the content mimeType 
+ * @param length the content size
+ * @param filepath a buffer for storing the path of the cached file; may be NULL
+ * @param max_path the size of the allocated filepath buffer  
+ */
 void addToCache(maps* conf,char* request,char* content,char* mimeType,int length, 
                 char* filepath, size_t max_path){
   map* tmp=getMapFromMaps(conf,"main","cacheDir");
   if(tmp!=NULL){
-    char* md5str=getMd5(request);
+    char* myRequest=getFilenameForRequest(conf,request);
+    char* md5str=getMd5(myRequest);
+    free(myRequest);
     char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
     sprintf(fname,"%s/%s.zca",tmp->value,md5str);
-#ifdef DEBUG
-    fprintf(stderr,"Cache list : %s\n",fname);
-    fflush(stderr);
-#endif
-    FILE* fo=fopen(fname,"w+");
-    if(fo==NULL){
-#ifdef DEBUG
-      fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
-#endif
-      filepath = NULL;  
-      return;
-    }
-    fwrite(content,sizeof(char),length,fo);
-    fclose(fo);
+    zooLock* lck=lockFile(conf,fname,'w');
+    if(lck!=NULL){
+#ifdef DEBUG
+      fprintf(stderr,"Cache list : %s\n",fname);
+      fflush(stderr);
+#endif
+      FILE* fo=fopen(fname,"w+");
+      if(fo==NULL){
+#ifdef DEBUG
+        fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
+#endif
+        filepath = NULL;
+        unlockFile(conf,lck);
+        return;
+      }
+      fwrite(content,sizeof(char),length,fo);
+      unlockFile(conf,lck);
+      fclose(fo);
         
-        if (filepath != NULL) {
-                strncpy(filepath, fname, max_path);
-        }       
-
-    sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
-    fo=fopen(fname,"w+");
-#ifdef DEBUG
-    fprintf(stderr,"MIMETYPE: %s\n",mimeType);
-#endif
-    fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
-    fclose(fo);
-
-    free(md5str);
-    free(fname);
+      if (filepath != NULL) {
+        strncpy(filepath, fname, max_path);
+      }
+
+      sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
+      fo=fopen(fname,"w+");
+#ifdef DEBUG
+      fprintf(stderr,"MIMETYPE: %s\n",mimeType);
+#endif
+      fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
+      fclose(fo);
+
+      sprintf(fname,"%s/%s.zcp",tmp->value,md5str);
+      fo=fopen(fname,"w+");
+      char* origin=getProvenance(conf,request);
+#ifdef DEBUG
+      fprintf(stderr,"ORIGIN: %s\n",mimeType);
+#endif
+      fwrite(origin,sizeof(char),strlen(origin),fo);
+      fclose(fo);
+
+      free(md5str);
+      free(fname);
+    }
   }
   else {
-          filepath = NULL;
+    filepath = NULL;
   }       
 }
@@ -127 +358 @@
  */
 char* isInCache(maps* conf,char* request){
+  map* tmpUrl=getMapFromMaps(conf,"main","tmpUrl");
   map* tmpM=getMapFromMaps(conf,"main","cacheDir");
-  if(tmpM!=NULL){
-    char* md5str=getMd5(request);
+  if(tmpM==NULL)
+    tmpM=getMapFromMaps(conf,"main","tmpPath");
+  if(strstr(request,tmpUrl->value)!=NULL){
+    map* tmpPath=getMapFromMaps(conf,"main","tmpPath");
+    char* tmpStr=strstr(request,tmpUrl->value);
+    char* tmpStr1=zStrdup(tmpStr+strlen(tmpUrl->value));
+    char* res=(char*) malloc((strlen(tmpPath->value)+strlen(tmpStr1)+2)*sizeof(char));
+    sprintf(res,"%s/%s",tmpPath->value,tmpStr1);
+    free(tmpStr1);
+    return res;
+  }
+#ifdef MS_FORCE_LOCAL_FILE_USE
+  map* msUrl=getMapFromMaps(conf,"main","mapserverAddress");
+  if(msUrl!=NULL && strstr(request,msUrl->value)!=NULL){
+    char *tmpStr=strstr(request,"?");
+    char *cursor=zStrdup(tmpStr+1);
+    char *token, *saveptr;
+    token = strtok_r (cursor, "&", &saveptr);
+    while(token!=NULL){
+      char *token1, *saveptr1;
+      token1 = strtok_r (token, "=", &saveptr1);
+      char *name=NULL;
+      while(token1!=NULL){
+        if(name==NULL)
+          name=zStrdup(token1);
+        else
+          if(strcasecmp(name,"map")==0){
+            mapObj *myMap=msLoadMap(token1,NULL);
+            char * res=zStrdup(myMap->layers[0]->data);
+            free(name);
+            free(cursor);
+            msFreeMap(myMap);
+            return res;
+          }
+        token1 = strtok_r (NULL, "=", &saveptr1);
+      }
+      token = strtok_r (NULL, "&", &saveptr);
+    }
+    free(cursor);
+  }
+#endif  
+  if(strncasecmp(request,"file://",7)==0){
+    char* tmpStr=zStrdup(request+7);
+    fprintf(stderr,"**** %s %d %s \n",__FILE__,__LINE__,tmpStr);
+    return tmpStr;
+  }
+  else{
+    char* myRequest=getFilenameForRequest(conf,request);
+    char* md5str=getMd5(myRequest);
+    free(myRequest);
 #ifdef DEBUG
     fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
@@ -135 +415 @@
     char* fname=(char*)malloc(sizeof(char)*(strlen(tmpM->value)+strlen(md5str)+6));
     sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
-    struct stat f_status;
-    int s=stat(fname, &f_status);
+    zStatStruct f_status;
+    int s=zStat(fname, &f_status);
     if(s==0 && f_status.st_size>0){
       free(md5str);
@@ -158 +438 @@
  */
 int readCurrentInput(maps** m,maps** in,int* index,HINTERNET* hInternet,map** error){
+  
+  int shouldClean=-1;
   map* tmp1;
   char sindex[5];
   maps* content=*in;
   map* length=getMap(content->content,"length");
-  int shouldClean=-1;
+  map* memUse=getMapFromMaps(*m,"main","memory");
   if(length==NULL){
     length=createMap("length","1");
@@ -171 +453 @@
     char *mimeType=NULL;
     int fsize=0;
+    char oriname[12];
     char cname[15];
     char vname[11];
@@ -178 +461 @@
     char icname[14];
     char xname[16];
+    char bname[8];
+    char hname[11];
     char oname[12];
+    char ufile[12];    
     if(*index>0)
       sprintf(vname1,"value_%d",*index);
@@ -185 +471 @@
     
     if(i>0){
+      sprintf(cname,"cache_file_%d",i);
       tmp1=getMap(content->content,cname);
-      sprintf(cname,"cache_file_%d",i);
+      sprintf(oriname,"origin_%d",i);
       sprintf(vname,"value_%d",i);
       sprintf(sname,"size_%d",i);
@@ -192 +479 @@
       sprintf(icname,"isCached_%d",i);
       sprintf(xname,"Reference_%d",i);
+      sprintf(bname,"body_%d",i);
+      sprintf(hname,"headers_%d",i);
       sprintf(oname,"Order_%d",i);
+      sprintf(ufile,"use_file_%d",i);
     }else{
       sprintf(cname,"cache_file");
+      sprintf(oriname,"origin");
       sprintf(vname,"value");
       sprintf(sname,"size");
@@ -200 +491 @@
       sprintf(icname,"isCached");
       sprintf(xname,"Reference");
+      sprintf(bname,"body");
+      sprintf(hname,"headers");
       sprintf(oname,"Order");
+      sprintf(ufile,"use_file");
     }
     
@@ -206 +500 @@
     sprintf(sindex,"%d",*index+1);
     if((tmp1=getMap(content->content,xname))!=NULL && tmap!=NULL && strcasecmp(tmap->value,sindex)==0){
-      
-      if(getMap(content->content,icname)==NULL){
-        fcontent=(char*)malloc((hInternet->ihandle[*index].nDataLen+1)*sizeof(char));
-        if(fcontent == NULL){
-          errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
-          return -1;
+
+      if(getMap(content->content,icname)==NULL) {
+        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
+          fcontent=(char*)malloc((hInternet->ihandle[*index].nDataLen+1)*sizeof(char));
+          if(fcontent == NULL){
+            errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
+            return -1;
+          }
+          size_t dwRead;
+          InternetReadFile(hInternet->ihandle[*index], 
+                           (LPVOID)fcontent, 
+                           hInternet->ihandle[*index].nDataLen, 
+                           &dwRead);
+          fcontent[hInternet->ihandle[*index].nDataLen]=0;
         }
-        size_t dwRead;
-        InternetReadFile(hInternet->ihandle[*index], 
-                         (LPVOID)fcontent, 
-                         hInternet->ihandle[*index].nDataLen, 
-                         &dwRead);
-        fcontent[hInternet->ihandle[*index].nDataLen]=0;
         fsize=hInternet->ihandle[*index].nDataLen;
         if(hInternet->ihandle[*index].mimeType==NULL)
@@ -226 +522 @@
         
         map* tmpMap=getMapOrFill(&(*in)->content,vname,"");
-        free(tmpMap->value);
-        tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
-        if(tmpMap->value==NULL){
-          return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
-        }
-        memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
+        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
+          free(tmpMap->value);
+          tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
+          if(tmpMap->value==NULL){
+            return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
+          }
+          memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
+        }else
+          addToMap((*in)->content,ufile,"true");
         if(hInternet->ihandle[*index].code!=200){
           const char *error_rep_str=_("Unable to download the file for the input <%s>, response code was : %d.");
@@ -255 +554 @@
         sprintf(ltmp1,"%d",fsize);
         map* tmp=getMapFromMaps(*m,"main","cacheDir");
+        char *request=NULL;
         if(tmp!=NULL){
-          char* md5str=getMd5(tmp1->value);
+          map* tmp2;
+          char* md5str=NULL;
+          if((tmp2=getMap(content->content,bname))!=NULL){
+            char *tmpStr=(char*)malloc((strlen(tmp1->value)+strlen(tmp2->value)+1)*sizeof(char));
+            sprintf(tmpStr,"%s%s",tmp1->value,tmp2->value);
+            if((tmp2=getMap(content->content,"headers"))!=NULL){
+              char *tmpStr2=zStrdup(tmpStr);
+              free(tmpStr);
+              tmpStr=(char*)malloc((strlen(tmpStr2)+strlen(tmp2->value)+1)*sizeof(char));
+              sprintf(tmpStr,"%s%s",tmpStr2,tmp2->value);
+              free(tmpStr2);
+            }
+            md5str=getMd5(tmpStr);
+            request=zStrdup(tmpStr);
+            free(tmpStr);
+          }else{
+            char *myRequest=getFilenameForRequest(*m,tmp1->value);
+            md5str=getMd5(myRequest);
+            request=zStrdup(tmp1->value);
+            free(myRequest);
+          }
           char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
           sprintf(fname,"%s/%s.zca",tmp->value,md5str);
@@ -264 +584 @@
         addToMap((*in)->content,sname,ltmp1);
         addToMap((*in)->content,mname,mimeType);
-        addToCache(*m,tmp1->value,fcontent,mimeType,fsize, NULL, 0);
-        free(fcontent);
+        char* origin=getProvenance(*m,request);
+        addToMap((*in)->content,oriname,origin);
+        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
+          addToCache(*m,request,fcontent,mimeType,fsize, NULL, 0);
+          free(fcontent);
+        }else{
+          addToMap((*in)->content,ufile,"true");
+          cacheFile(*m,request,mimeType,fsize,hInternet->ihandle[*index].filename);
+        }
         free(mimeType);
-        *index++;
-        
+        free(request);
+        (*index)++;
       }
     }
@@ -324 +651 @@
  */
 void addRequestToQueue(maps** m,HINTERNET* hInternet,const char* url,bool req){
-  hInternet->waitingRequests[hInternet->nb]=strdup(url);
+  hInternet->waitingRequests[hInternet->nb]=zStrdup(url);
   if(req)
-    InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
+    InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0,*m);
   maps *oreq=getMaps(*m,"orequests");
   if(oreq==NULL){
@@ -335 +662 @@
     free(oreq);
   }else{
-    setMapArray(oreq->content,"value",hInternet->nb-1,url);
+    setMapArray(oreq->content,"value",hInternet->nb,url);
   }
 }
@@ -352 +679 @@
   char* cached=isInCache(*m,url);
   char *mimeType=NULL;
-  int fsize=0;
+  char *origin=NULL;
+  long long fsize=0;
+  map* memUse=getMapFromMaps(*m,"main","memory");
 
   map* t=getMap(*content,"xlink:href");
@@ -361 +690 @@
 
   if(cached!=NULL){
-
-    struct stat f_status;
-    int s=stat(cached, &f_status);
+    zStatStruct f_status;
+    int s=zStat(cached, &f_status);
     if(s==0){
-      fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1));
-      FILE* f=fopen(cached,"rb");
-      fread(fcontent,f_status.st_size,1,f);
+      zooLock* lck=lockFile(*m,cached,'r');
+      if(lck==NULL)
+        return -1;
       fsize=f_status.st_size;
-      fcontent[fsize]=0;
-      fclose(f);
+      if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
+        fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1));
+        FILE* f=fopen(cached,"rb");
+        if(f!=NULL){
+          fread(fcontent,f_status.st_size,1,f);
+          fcontent[fsize]=0;
+          fclose(f);
+        }
+      }
       addToMap(*content,"cache_file",cached);
+      unlockFile(*m,lck);
     }
     cached[strlen(cached)-1]='m';
-    s=stat(cached, &f_status);
+    s=zStat(cached, &f_status);
     if(s==0){
+      zooLock* lck=lockFile(*m,cached,'r');
+      if(lck==NULL)
+        return -1;
       mimeType=(char*)malloc(sizeof(char)*(f_status.st_size+1));
       FILE* f=fopen(cached,"rb");
@@ -381 +720 @@
       mimeType[f_status.st_size]=0;
       fclose(f);
-    }
-
+      unlockFile(*m,lck);
+    }
+    cached[strlen(cached)-1]='p';
+    s=zStat(cached, &f_status);
+    if(s==0){
+      zooLock* lck=lockFile(*m,cached,'r');
+      if(lck==NULL)
+        return -1;
+      origin=(char*)malloc(sizeof(char)*(f_status.st_size+1));
+      FILE* f=fopen(cached,"rb");
+      fread(origin,f_status.st_size,1,f);
+      mimeType[f_status.st_size]=0;
+      fclose(f);
+      unlockFile(*m,lck);
+    }
   }else{    
     addRequestToQueue(m,hInternet,url,true);
@@ -393 +745 @@
     addToMap(*content,"fmimeType",mimeType);
   }
+  if(origin!=NULL){
+    addToMap(*content,"origin",origin);
+  }
 
   map* tmpMap=getMapOrFill(content,"value","");
-    
-  free(tmpMap->value);
-  tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
-  if(tmpMap->value==NULL || fcontent == NULL)
-    return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
-  memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
-
+  if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
+    free(tmpMap->value);
+    tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
+    if(tmpMap->value==NULL || fcontent == NULL)
+      return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
+    memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
+  }
+  
   char ltmp1[256];
-  sprintf(ltmp1,"%d",fsize);
+  sprintf(ltmp1,"%ld",fsize);
   addToMap(*content,"size",ltmp1);
   if(cached==NULL){
-    addToCache(*m,url,fcontent,mimeType,fsize, NULL, 0);
+    if(memUse==NULL || strcasecmp(memUse->value,"load")==0)
+      addToCache(*m,url,fcontent,mimeType,fsize, NULL, 0);
+    else
+      cacheFile(*m,url,mimeType,fsize,hInternet->ihandle[hInternet->nb-1].filename);
   }
   else{
     addToMap(*content,"isCached","true");
     map* tmp=getMapFromMaps(*m,"main","cacheDir");
-    if(tmp!=NULL){
+    map* tmp1=getMap((*content),"cache_file");
+    if(tmp!=NULL && tmp1==NULL){
       map *c=getMap((*content),"xlink:href");
-      char* md5str=getMd5(c->value);
-      char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
-      sprintf(fname,"%s/%s.zca",tmp->value,md5str);
-      addToMap(*content,"cache_file",fname);
-      free(fname);
-    }
-  }
-  free(fcontent);
-  free(mimeType);
-  free(cached);
+      if(strncasecmp(c->value,"file://",7)!=0){
+        char *myRequest=getFilenameForRequest(*m,c->value);
+        char* md5str=getMd5(myRequest);
+        free(myRequest);
+        char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
+        sprintf(fname,"%s/%s.zca",tmp->value,md5str);
+        addToMap(*content,"cache_file",fname);
+        free(fname);
+        free(md5str);
+      }
+    }
+  }
+  if(fcontent!=NULL)
+    free(fcontent);
+  if(mimeType!=NULL)
+    free(mimeType);
+  if(cached!=NULL)
+    free(cached);
   return 0;
 }

trunk/zoo-project/zoo-kernel/caching.h

@@ -35 +35 @@
   void addRequestToQueue(maps**,HINTERNET*,const char*,bool);
   int loadRemoteFile(maps**,map**,HINTERNET*,char*);
-
+  char* getMd5f(char*);
+  int storeMd5(char*);
+  
 #ifdef __cplusplus
 }

trunk/zoo-project/zoo-kernel/configure.ac

@@ -1 +1 @@
 AC_INIT([ZOO Kernel], [1.7.0], [bugs@zoo-project.org])
+
+AC_CONFIG_MACRO_DIR([macros])
 
 # Checks for programs.
@@ -12 +14 @@
 AC_CHECK_LIB([dl], [dlopen,dlsym,dlerror,dlclose])
 AC_CHECK_LIB([crypto], [EVP_DigestInit,EVP_md5,EVP_DigestUpdate,BIO_f_base64,BIO_new])
-AC_CHECK_LIB([uuid], [uuid_generate_time])
 
 DEFAULT_LIBS="$LIBS"
@@ -20 +21 @@
 # Checks for header files.
 AC_FUNC_ALLOCA
-AC_CHECK_HEADERS([fcntl.h inttypes.h libintl.h malloc.h stddef.h stdlib.h string.h unistd.h])
+AC_CHECK_HEADERS([fcntl.h inttypes.h malloc.h stddef.h stdlib.h string.h unistd.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
@@ -38 +39 @@
 AC_FUNC_REALLOC
 AC_CHECK_FUNCS([dup2 getcwd memset setenv strdup strstr])
+
+#============================================================================
+# Detect if uuid is available
+#============================================================================
+
+AC_ARG_WITH([uuid],
+    [AS_HELP_STRING([--with-uuid=PATH], [Specifies an alternative location for the ossp-uuid library])],
+    [UUID_DIR="$withval"], [UUID_DIR="/usr/"])
+UUID_CFLAGS="-I$UUID_DIR/include"
+UUID_LDFLAGS="-L$UUID_DIR/lib -luuid"
+CPPFLAGS_SAVE="$CPPFLAGS"
+CPPFLAGS="$UUID_CFLAGS"
+LIBS_SAVE="$LIBS"
+LIBS="$UUID_LDFLAGS"
+AC_CHECK_HEADERS([uuid/uuid.h],
+                        [], [AC_MSG_ERROR([could not find header file uuid.h])])
+AC_CHECK_LIB([uuid], [uuid_generate_time],
+                        [], [AC_MSG_ERROR([could not find function in uuid library])])
+CPPFLAGS="$CPPFLAGS_SAVE"
+AC_SUBST([UUID_CFLAGS])
+AC_SUBST([UUID_LDFLAGS])
+
+#============================================================================
+# Detect if json-c is available
+#============================================================================
+
+AC_ARG_WITH([callback],
+    [AS_HELP_STRING([--with-callback=yes], [Activate callback invocation during HPC execution])],
+    [CALLBACK_ACTIVATED="$withval"], [CALLBACK_ACTIVATED="no"])
+    
+AC_ARG_WITH([json],
+    [AS_HELP_STRING([--with-json=PATH], [Specifies an alternative location for the json-c library])],
+    [JSON_DIR="$withval"], [JSON_DIR="/usr/"])
+if test "x$JSON_DIR" != "x" && test "x$CALLBACK_ACTIVATED" == "xyes"
+then
+        JSON_CPPFLAGS="-I$JSON_DIR/include/json-c/"
+        JSON_LDFLAGS="-L$JSON_DIR/lib -ljson-c"
+        CPPFLAGS_SAVE="$CPPFLAGS"
+        CPPFLAGS="$JSON_CPPFLAGS"
+        LIBS_SAVE="$LIBS"
+        LIBS="$JSON_LDFLAGS"
+        AC_CHECK_HEADERS([json_object.h],
+                [], [AC_MSG_ERROR([could not find header file json_object.h])])
+        AC_CHECK_LIB([json-c], [json_object_new_object],
+                [], [AC_MSG_ERROR([could not find function in json-c library])])
+        CPPFLAGS="$CPPFLAGS_SAVE"
+        JSON_FILE="service_json.o"
+        JSON_ENABLED="-DJSON"
+        CALLBACK_FILE="service_callback.o"
+        CALLBACK_USE="-DUSE_CALLBACK"
+fi
+AC_SUBST([JSON_CPPFLAGS])
+AC_SUBST([JSON_LDFLAGS])
+AC_SUBST([JSON_FILE])
+AC_SUBST([JSON_ENABLED])
+AC_SUBST([CALLBACK_FILE])
+AC_SUBST([CALLBACK_USE])
 
 #============================================================================
@@ -56 +114 @@
 AC_CHECK_LIB(crypto, BIO_f_base64,
                         [], [AC_MSG_ERROR([could not find $i function in openssl library])])
+CPPFLAGS="$CPPFLAGS_SAVE"
 AC_SUBST([OPENSSL_CFLAGS])
 AC_SUBST([OPENSSL_LDFLAGS])
+
+#============================================================================
+# Detect if gettext is available
+#============================================================================
+
+#AC_ARG_WITH([gettext],
+#    [AS_HELP_STRING([--with-gettext=PATH], [Specifies an alternative location for the openssl library])],
+#    [GETTEXT_DIR="$withval"], [GETTEXT_DIR="/usr/"])
+
+#GETTEXT_CFLAGS="-I$GETTEXT_DIR/include"
+#GETTEXT_LDFLAGS="-L$GETTEXT_DIR/lib -lintl"
+#CFLAGS_SAVE="$CFLAGS"
+#CFLAGS="$GETTEXT_CFLAGS"
+#LIBS_SAVE="$LIBS"
+#LIBS="$GETTEXT_LDFLAGS"
+#AM_GNU_GETTEXT([external], [], [])
+#AC_CHECK_LIB(intl,
+#                       [dgettext], [] , [AC_MSG_ERROR([could not find $i function in gettext library])])
+#AC_SUBST([GETTEXT_CFLAGS])
+#AC_SUBST([GETTEXT_LDFLAGS])
 
 #============================================================================
@@ -145 +224 @@
 AC_SUBST([FCGI_LDFLAGS])
 
+AC_ARG_WITH([metadb],
+        [AS_HELP_STRING([--with-metadb=yes], [Activates the metadata database support])],
+        [WITHMETADB="$withval"], [WITHMETADB=""])
+
+if test "x$WITHMETADB" = "xyes"; then
+        METADB="-DMETA_DB"
+        METADB_FILE="meta_sql.o sqlapi.o"
+else
+        METADB=""
+        METADB_FILE=""
+fi
+
+AC_SUBST([METADB])
+AC_SUBST([METADB_FILE])
+
+AC_ARG_WITH([hpc],
+        [AS_HELP_STRING([--with-hpc=yes], [Specifies if you need to activate HPC support])],
+        [HPCWITH="$withval"], [HPCWITH="no"])
+
+
+AC_ARG_WITH([ssh2],
+        [AS_HELP_STRING([--with-ssh2=PATH], [Specifies an alternative location for the ssh2 library])],
+        [SSH2PATH="$withval"], [SSH2PATH="/usr"])
+
+if test "x$HPCWITH" = "xyes"; then
+        HPC_FILES="service_internal_hpc.o sshapi.o"
+        HPC_ENABLED="-DUSE_HPC"
+        HPC_CPPFLAGS=""
+        HPC_LDFLAGS=""
+        # Extract the linker and include flags
+        SSH2_LDFLAGS="-L$SSH2PATH/lib -lssh2"
+        SSH2_CPPFLAGS="-I$SSH2PATH/include"
+        # Check headers file
+        CPPFLAGS_SAVE="$CPPFLAGS"
+        CPPFLAGS="$SSH2_CPPFLAGS"
+        LIBS_SAVE="$LIBS"
+        LIBS="$SSH2_LDFLAGS"
+        
+        AC_CHECK_HEADERS([libssh2.h],
+                 [], [AC_MSG_ERROR([could not find headers related to libssh2])])
+        AC_CHECK_LIB([ssh2], [libssh2_session_init])
+
+        LIBS="$LIBS_SAVE"
+fi
+
+AC_SUBST([HPC_CPPFLAGS])
+AC_SUBST([HPC_LDFLAGS])
+AC_SUBST([HPC_ENABLED])
+AC_SUBST([HPC_FILES])
+
+AC_SUBST([SSH2_CPPFLAGS])
+AC_SUBST([SSH2_LDFLAGS])
+
 # ===========================================================================
 # Detect if libxml2 is installed
@@ -400 +532 @@
 AC_SUBST([MS_LIBS])
 AC_SUBST([MS_FILE])
+AC_SUBST([MS_VERSION])
+
+# ===========================================================================
+# Detect if R is installed
+# ===========================================================================
+
+AC_ARG_WITH([r], 
+        [AS_HELP_STRING([--with-r=PATH], [To enable python support or Specifies an alternative directory for R installation,  disabled by default])], 
+        [R_PATH="$withval"; R_ENABLED="-DUSE_R"], [R_ENABLED=""])
+
+if test -z "$R_ENABLED"
+then
+        R_FILE=""
+else
+        R_FILE="service_internal_r.o"
+        # Extract the linker and include flags 
+        R_LDFLAGS="-L$R_PATH/lib/ -lR"
+        R_CPPFLAGS="-I$R_PATH/include/"
+
+        # Check headers file
+        CPPFLAGS_SAVE="$CPPFLAGS"
+        CPPFLAGS="$R_CPPFLAGS"
+        AC_CHECK_HEADERS([RInternals.h],
+                 [], [AC_MSG_ERROR([could not find headers include related to R])])
+
+        # Ensure we can link against libphp
+        #LIBS_SAVE="$LIBS"
+        #LIBS="$R_LDFLAGS"
+        #AC_CHECK_LIB([$LIBS], [R_tryEval], [], [AC_MSG_ERROR([could not find libR])], [])
+        #LIBS="$LIBS_SAVE"
+fi
+
+AC_SUBST([R_CPPFLAGS])
+AC_SUBST([R_LDFLAGS])
+AC_SUBST([R_ENABLED])
+AC_SUBST([R_FILE])
+
 
 # ===========================================================================
@@ -646 +815 @@
 
         AC_LANG([C++])
-        echo $JAVA_CPPFLAGS
+        #echo $JAVA_CPPFLAGS
         # Check headers file (second time we check that in fact)
         CPPFLAGS_SAVE="$CPPFLAGS"
@@ -696 +865 @@
 
         AC_LANG([C++])
-        echo $JAVA_CPPFLAGS
+        #echo $JAVA_CPPFLAGS
         # Check headers file (second time we check that in fact)
         CPPFLAGS_SAVE="$CFLAGS"
@@ -888 +1057 @@
         [SAGAPATH="$withval"], [SAGAPATH=""])
 
+AC_ARG_WITH([saga-version],
+        [AS_HELP_STRING([--with-saga-version=VERSION], [Specifies the SAGA-GIS version number])],
+        [SAGAVERS="$withval"], [SAGAVERS="2"])
+
 if test -z "$SAGAPATH"
 then
@@ -903 +1076 @@
         WX_ISSUE="-D_WX_WXCRTVARARG_H_"
         SAGA_DEFS="-D_SAGA_LINUX -D_TYPEDEF_BYTE -D_TYPEDEF_WORD -DMODULE_LIBRARY_PATH=\\\"$SAGAPATH/lib/saga\\\""
-        SAGA_CPPFLAGS=" -fPIC -I$SAGAPATH/include/saga/saga_core/saga_api/ `$WXCFG --unicode=yes --static=no --cxxflags` -D_SAGA_UNICODE $SAGA_DEFS $WX_ISSUE"
+        SAGA_CPPFLAGS="-DSAGA_VERSION=${SAGAVERS} -fPIC -I$SAGAPATH/include/saga/saga_core/saga_api/ `$WXCFG --unicode=yes --static=no --cxxflags` -D_SAGA_UNICODE $SAGA_DEFS $WX_ISSUE"
         SAGA_LDFLAGS="-fPIC `$WXCFG --unicode=yes --static=no --libs` -lsaga_api"
         SAGA_ENABLED="-DUSE_SAGA"
@@ -914 +1087 @@
         LIBS_SAVE="$LIBS"
         LIBS="$SAGA_LDFLAGS"
-        AC_CHECK_HEADERS([module_library.h],
-                        [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
-        AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "module_library.h"],[SG_Get_Module_Library_Manager();]])],
-                [AC_MSG_RESULT([checking for SG_Get_Module_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Module_Library_Manager... failed])])
+        if test "$SAGAVERS" == "2"; then
+        AC_CHECK_HEADERS([module_library.h],
+                        [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "module_library.h"],[SG_Get_Module_Library_Manager();]])],
+                [AC_MSG_RESULT([checking for SG_Get_Module_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Module_Library_Manager... failed])])
+        else
+        AC_CHECK_HEADERS([tool_library.h],
+                        [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "tool_library.h"],[SG_Get_Tool_Library_Manager();]])],
+                [AC_MSG_RESULT([checking for SG_Get_Tool_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Tool_Library_Manager... failed])])
+        fi
+        
         LIBS="$LIBS_SAVE"
         AC_LANG_POP([C++])

trunk/zoo-project/zoo-kernel/main_conf_read.y

@@ -87 +87 @@
  ;
 
-pair: PAIR {curr_key=zStrdup($1);}
+pair: PAIR {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);}
 | EPAIR {
   if(current_content==NULL) 
@@ -99 +99 @@
   }
   free(curr_key);
+  curr_key=NULL;
   }
-| SPAIR  {curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
+| SPAIR  {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
  ;
 
@@ -162 +163 @@
     free(current_content);
   }
+  if(curr_key!=NULL){
+    free(curr_key);
+  }
 
   fclose(crin);

trunk/zoo-project/zoo-kernel/makefile.vc

@@ -50 +50 @@
         $(CPP) $(CFLAGS) /c caching.c
 
+service_json.obj: service_json.c service_json.h
+        $(CPP) $(CFLAGS) /c service_json.c
+
 request_parser.obj: request_parser.c request_parser.h
         $(CPP) $(CFLAGS) /c request_parser.c
@@ -71 +74 @@
         $(CPP) /c $(CFLAGS) service_internal_ruby.c
 
+service_internal_mono.obj: service_internal_mono.c service_internal_mono.h service.h
+        $(CPP) /c $(MONO_CLAGS) $(CFLAGS) service_internal_mono.c
+
 service_internal_python.obj: service_internal_python.c service.h
         $(CPP) /c $(CFLAGS) service_internal_python.c
@@ -89 +95 @@
         $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php.c
     
+service_callback.obj: service_callback.c service_callback.h service.h
+        $(CPP) /c $(CFLAGS) service_callback.c
+    
 service_internal_php7.obj: service_internal_php7.c service_internal_php.h service.h
         $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php7.c    
@@ -95 +104 @@
         link /dll /out:$(LIBZOO_SERVICE) ./service.obj ./service_internal.obj ./sqlapi.obj $(LDFLAGS) /FORCE:MULTIPLE
 
-$(PROGRAMNAME): version.h $(LIBZOO_SERVICE) zoo_loader.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj request_parser.obj response_print.obj server_internal.obj caching.obj
-        link zoo_loader.obj request_parser.obj response_print.obj server_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj  zoo_service_loader.obj ./libzoo_service.lib /out:$(PROGRAMNAME) $(LDFLAGS) $(LDFLAGSCGI) 
+$(PROGRAMNAME): version.h $(LIBZOO_SERVICE) zoo_loader.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj request_parser.obj response_print.obj server_internal.obj caching.obj service_json.obj service_callback.obj
+        link zoo_loader.obj request_parser.obj response_print.obj server_internal.obj caching.obj service_json.obj service_callback.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj  zoo_service_loader.obj ./libzoo_service.lib /out:$(PROGRAMNAME) $(LDFLAGS) $(LDFLAGSCGI) $(JSONC_LIB) $(PTHREADS_LIB) $(XSLT_LIB)
 
-zcfg2yaml: version.h zcfg2yaml.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj
-        link zcfg2yaml.obj server_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj response_print.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj ./libzoo_service.lib /out:zcfg2yaml.exe $(LDFLAGS) $(LDFLAGSCGI)
+zcfg2yaml: version.h zcfg2yaml.obj zoo_service_loader.obj service_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj
+        link zcfg2yaml.obj server_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj response_print.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj ./libzoo_service.lib /out:zcfg2yaml.exe $(LDFLAGS) $(LDFLAGSCGI)
 
 clean:
@@ -105 +114 @@
 
 embed-manifest: zoo_loader.cgi
-        mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;1
+        mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;

trunk/zoo-project/zoo-kernel/mimetypes.h

@@ -180 +180 @@
         { "application/vnd.dece.unspecified", "uvx" },
         { "application/vnd.dece.zip", "uvz" },
-        { "application/vnd.denovo.fcselayout-link", "fe_launch" },
+        { "application/vnd.denovo.fcselayout-link", "fe_launch" },      
         { "application/vnd.dna", "dna" },
         { "application/vnd.dolby.mlp", "mlp" },
@@ -818 +818 @@
 */
 static map* getFileExtensionMap(const char* mimeType, bool* hasExt) {
+  map* ext = createMap("extension", "txt");
+  *hasExt = false;
+        
+  if (mimeType != NULL) {       
+    for (int i = 0; i < NUM_MIME_TYPES; i++) {                  
+      if(strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
+        free(ext->value);
+        ext->value = zStrdup(MIME[i][M_Extension]);
+        *hasExt = true;
+        break;                          
+      } 
+    }
+    if (*hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
+      free(ext->value);
+      ext->value = zStrdup(strstr(mimeType, "/") + 1);
+    }
+  }     
+  return ext;
+}
 
-        map* ext = createMap("extension", "txt");
-        *hasExt = false;
-        
-        if (mimeType != NULL) {         
-                for (int i = 0; i < NUM_MIME_TYPES; i++) {                      
-                        if      (strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
-                                ext->value = zStrdup(MIME[i][M_Extension]);
-                                *hasExt = true;
-                                break;                          
-                        }               
-                }
-                if (*hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
-                        ext->value = zStrdup(strstr(mimeType, "/") + 1);
-                }                       
-        }       
-        return ext;
+static int isGeographic(const char* mimeType){
+  char* imageMimeType[4]={
+    "image/tiff",
+    "image/png",
+    "image/jpeg",
+    "application/vnd.google-earth.kmz"
+  };
+  char* vectorMimeType[5]={
+    "text/xml",
+    "application/json",
+    "application/gml+xml",
+    "application/zip",
+    "application/vnd.google-earth.kml+xml"
+  };
+  int i=0;
+  for(;i<4;i++){
+    if(strncmp(imageMimeType[i],mimeType,strlen(imageMimeType[i]))==0)
+      return 1;
+  }
+  i=0;
+  for(;i<5;i++){
+    if(strncmp(vectorMimeType[i],mimeType,strlen(vectorMimeType[i]))==0)
+      return 2;
+  }
+  return -1;
 }

trunk/zoo-project/zoo-kernel/nmake.opt

@@ -87 +87 @@
 !ENDIF
 
+!IFDEF MONO_DIR
+MONO_CFLAGS=-DUSE_MONO -I"$(MONO_DIR)"\msvc -I"$(MONO_DIR)"\msvc\include -I"$(MONO_DIR)"
+MONO_LDFLAGS=/LIBPATH:"$(MONO_DIR)/msvc/build/sgen/x64/lib/Release" mono-2.0-sgen.lib
+MONO_FILE=service_internal_mono.obj
+!ENDIF
+
 !IFNDEF ZOOK_DIR
 ZOOK_DIR=.
@@ -100 +106 @@
 !ENDIF
 
-CFLAGS= $(DB_FLAGS) $(MS_DEFS) $(INCLUDES) $(CFLAGS1) /nologo /MD /W3 /EHsc /Ox /D_CRT_SECURE_NO_WARNINGS /DWIN32 /DPROGRAMNAME=\"$(PROGRAMNAME)\" $(CJFLAGS) -I$(ZOOK_DIR) $(RUBY_CFLAGS) -I./ $(JAVA_CFLAGS) $(MS_CFLAGS) -I$(TROOT)\..\..\thirds\dirent-win32 -I$(INTL_DIR) -I$(CURL_DIR)\include -I$(XML2_DIR)\include -I$(GDAL_DIR)\port $(JS_CFLAGS) -I$(GDAL_DIR)\ogr -I$(GDAL_DIR)\gcore -I$(GD_DIR) -I$(ICONV_DIR) -I$(TROOT)\..\..\thirds\include -I$(TROOT)\..\..\thirds\cgic206 -I$(PYTHON_CPATH)\include -I$(SSL_DIR)/inc32 -I$(FCGI_DIR)\include $(PY_CFLAGS) $(PHP_CFLAGS) -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
+!IFDEF WIN32_DEBUG
+WIN32_DBG=-DWIN32_DEBUG
+!ENDIF
+
+CFLAGS=$(MONO_CFLAGS) $(WIN32_DBG) $(DB_FLAGS) $(MS_DEFS) $(INCLUDES) $(CFLAGS1) /nologo /MD /W3 /EHsc /Ox /D_CRT_SECURE_NO_WARNINGS /DWIN32 /DPROGRAMNAME=\"$(PROGRAMNAME)\" $(CJFLAGS) -I$(ZOOK_DIR) $(RUBY_CFLAGS) -I./ $(JAVA_CFLAGS) $(MS_CFLAGS) -I$(TROOT)\..\..\thirds\dirent-win32 -I$(INTL_DIR) -I$(CURL_DIR)\include -I$(XML2_DIR)\include -I$(GDAL_DIR)\port $(JS_CFLAGS) -I$(GDAL_DIR)\ogr -I$(GDAL_DIR)\gcore -I$(GD_DIR) -I$(ICONV_DIR) -I$(TROOT)\..\..\thirds\include -I$(TROOT)\..\..\thirds\cgic206 -I$(PYTHON_CPATH)\include -I$(SSL_DIR)/inc32 -I$(FCGI_DIR)\include $(PY_CFLAGS) $(PHP_CFLAGS) -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
 
 LDFLAGSCGI=$(TROOT)/../../thirds/cgic206/libcgic.lib 
-LDFLAGS=$(FCGI_DIR)/libfcgi/Release/libfcgi.lib $(CURL_LIBRARY) $(PY_LDFLAGS) $(XML2_LIBRARY) $(SSL_DIR)/out32dll/libeay32.lib $(JAVA_LDFLAGS) $(SSL_DIR)/out32dll/ssleay32.lib $(MS_LDFLAGS) $(INTL_DIR)/intl.lib $(XML2_DIR)/win32/bin.msvc/libxml2.lib $(GDAL_DIR)/gdal_i.lib $(CURL_DIR)/lib/libcurl.lib $(JS_LDFLAGS) $(RUBY_LDFLAGS) $(PHP_LDFLAGS) /machine:i386
+LDFLAGS=$(MONO_LDFLAGS) $(FCGI_DIR)/libfcgi/Release/libfcgi.lib $(CURL_LIBRARY) $(PY_LDFLAGS) $(XML2_LIBRARY) $(SSL_DIR)/out32dll/libeay32.lib $(JAVA_LDFLAGS) $(SSL_DIR)/out32dll/ssleay32.lib $(MS_LDFLAGS) $(INTL_DIR)/intl.lib $(XML2_DIR)/win32/bin.msvc/libxml2.lib $(GDAL_DIR)/gdal_i.lib $(CURL_DIR)/lib/libcurl.lib $(JS_LDFLAGS) $(RUBY_LDFLAGS) $(PHP_LDFLAGS) /machine:i386

trunk/zoo-project/zoo-kernel/request_parser.c

@@ -28 +28 @@
 #include "response_print.h"
 #include "caching.h"
+#include "cgic.h"
 
 /**
@@ -154 +155 @@
       addToMap(cursor->content,"base64_value",tmp->value);
       int size=0;
-      char *s=strdup(tmp->value);
+      char *s=zStrdup(tmp->value);
       free(tmp->value);
       tmp->value=base64d(s,strlen(s),&size);
@@ -174 +175 @@
           addToMap(cursor->content,key,tmp->value);
           int size=0;
-          char *s=strdup(tmp->value);
+          char *s=zStrdup(tmp->value);
           free(tmp->value);
           tmp->value=base64d(s,strlen(s),&size);
@@ -521 +522 @@
   int l = 0;
   map* version=getMapFromMaps(*main_conf,"main","rversion");
+  map* memory=getMapFromMaps(*main_conf,"main","memory");
   int vid=getVersionId(version->value);
   for (k=0; k < nodes->nodeNr; k++)
@@ -533 +535 @@
             xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
             tmpmaps = createMaps((char *) val);
+            xmlFree(val);
           }
 
@@ -624 +627 @@
                             tmpmaps->content =
                               createMap (refs[l], (char *) val);
-
                           map *ltmp = getMap (tmpmaps->content, "method");
                           if (l == 4 )
                             {
-                              if ((ltmp==NULL || strncasecmp (ltmp->value, "POST",4) != 0)) // 
-                              //if ((ltmp==NULL || strncmp (ltmp->value, "POST",4) != 0))
+                              if ((ltmp==NULL || strncmp (ltmp->value, "POST",4) != 0))
                                 {
                                   if (loadRemoteFile
@@ -751 +752 @@
                                       map *btmp =
                                         getMap (tmpmaps->content, "Reference");
+                                      addToMap (tmpmaps->content, "Body", tmp);
                                       if (btmp != NULL)
                                         {
@@ -759 +761 @@
                                                            xmlStrlen(btmps),
                                                            INTERNET_FLAG_NO_CACHE_WRITE,
-                                                           0);
+                                                           0,
+                                                           *main_conf);
                                           addIntToMap (tmpmaps->content, "Order", hInternet->nb);
                                         }
@@ -778 +781 @@
                                   xmlGetProp (cur3, BAD_CAST "href");
                                 HINTERNET bInternet, res1, res;
+                                maps *tmpConf=createMaps("main");
+                                tmpConf->content=createMap("memory","load");
                                 bInternet = InternetOpen (
 #ifndef WIN32
@@ -785 +790 @@
                                                           INTERNET_OPEN_TYPE_PRECONFIG,
                                                           NULL, NULL, 0);
+#ifndef WIN32
                                 if (!CHECK_INET_HANDLE (bInternet))
                                   fprintf (stderr,
                                            "WARNING : bInternet handle failed to initialize");
+#endif
                                 bInternet.waitingRequests[0] =
-                                  strdup ((char *) val);
+                                  zStrdup ((char *) val);
                                 res1 =
                                   InternetOpenUrl (&bInternet,
@@ -795 +802 @@
                                                    [0], NULL, 0,
                                                    INTERNET_FLAG_NO_CACHE_WRITE,
-                                                   0);
+                                                   0,
+                                                   tmpConf);
                                 processDownloads (&bInternet);
+                                freeMaps(&tmpConf);
+                                free(tmpConf);
                                 char *tmp =
                                   (char *)
@@ -816 +826 @@
                                                   &bRead);
                                 tmp[bInternet.ihandle[0].nDataLen] = 0;
-                                InternetCloseHandle (&bInternet);
+                                InternetCloseHandle(&bInternet);
+                                addToMap (tmpmaps->content, "Body", tmp);
                                 map *btmp =
                                   getMap (tmpmaps->content, "href");
@@ -829 +840 @@
                                                        strlen(tmp),
                                                        INTERNET_FLAG_NO_CACHE_WRITE,
-                                                       0);
+                                                       0,
+                                                       *main_conf);
                                     addIntToMap (tmpmaps->content, "Order", hInternet->nb);
                                   }
                                 free (tmp);
+                                xmlFree (val);
                               }
                         }
@@ -895 +908 @@
                     }
                   }
-
 
                   while (cur4 != NULL)
@@ -967 +979 @@
 
                       map *test = getMap (tmpmaps->content, "encoding");
-
                       if (test == NULL)
-                        { 
+                        {
                           if (tmpmaps->content != NULL)
                             addToMap (tmpmaps->content, "encoding",
@@ -979 +990 @@
                         }
 
-                      if (getMap(tmpmaps->content,"dataType")==NULL && strcasecmp (test->value, "base64") != 0)
-                        { 
-                          xmlChar *mv = xmlNodeListGetString (doc,
-                                                              cur4->xmlChildrenNode,
-                                                              1);
+                      if (getMap(tmpmaps->content,"dataType")==NULL && test!=NULL && strcasecmp (test->value, "base64") != 0)
+                        {
+                          xmlChar *mv = NULL;
+                          /*if(cur4!=NULL && cur4->xmlChildrenNode!=NULL)
+                            xmlChar *mv = xmlNodeListGetString (doc,
+                                                                cur4->xmlChildrenNode,
+                                                                1);*/
                           map *ltmp =
                             getMap (tmpmaps->content, "mimeType");
-                          if (mv == NULL
-                              ||
+                          if (/*mv == NULL
+                              ||*/
                               (xmlStrcasecmp
                                (cur4->name, BAD_CAST "ComplexData") == 0
@@ -1025 +1038 @@
                                            buffersize);
                             }else{
+
                             if(xmlStrcasecmp
                                (cur4->name, BAD_CAST "BoundingBoxData") == 0){
@@ -1039 +1053 @@
                               xmlNodePtr cur5 = cur4->children;
                               while (cur5 != NULL
+                                     && cur5->type != XML_ELEMENT_NODE
+                                     && cur5->type != XML_TEXT_NODE
                                      && cur5->type != XML_CDATA_SECTION_NODE)
                                 cur5 = cur5->next;
                               if (cur5 != NULL
-                                  && cur5->type == XML_CDATA_SECTION_NODE){
-                                if(mv!=NULL)
-                                  xmlFree(mv);
-                                mv=xmlStrdup(cur5->content);
+                                  && cur5->type != XML_CDATA_SECTION_NODE
+                                  && cur5->type != XML_TEXT_NODE)
+                                {
+                                  xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
+                                  int buffersize;
+                                  xmlDocSetRootElement (doc1, cur5);
+                                  xmlDocDumpFormatMemoryEnc (doc1, &mv,
+                                                             &buffersize,
+                                                             "utf-8", 0);
+                                  addIntToMap (tmpmaps->content, "size",
+                                               buffersize);
+                                }
+                              else if (cur5 != NULL)/*
+                                     && cur5->type == XML_CDATA_SECTION_NODE)*/{
+                                xmlFree(mv);
+                                if(cur5->content!=NULL){
+                                  mv=xmlStrdup(cur5->content);
+                                }
                               }
                             }
@@ -1088 +1118 @@
                 cur2 = cur2->next;
               }
+            }
+          if(memory!=NULL && strncasecmp(memory->value,"load",4)!=0)
+            if(getMap(tmpmaps->content,"to_load")==NULL){
+              addToMap(tmpmaps->content,"to_load","false");
             }
           {
@@ -1123 +1157 @@
                   }
               }
-            else
+            else{
               addMapsToMaps (request_output, tmpmaps);
+            }
           }
           freeMaps (&tmpmaps);
@@ -1198 +1233 @@
       const char ress[4][13] =
         { "mimeType", "encoding", "schema", "transmission" };
+      xmlFree (val);
       for (l = 0; l < 4; l++){
         val = xmlGetProp (cur, BAD_CAST ress[l]);
@@ -1217 +1253 @@
         while (ccur != NULL){
           if(ccur->type == XML_ELEMENT_NODE){
-            char *xpathExpr=(char*)malloc(65+strlen(tmpmaps->name));
-            sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);
+            char *xpathExpr=(char*)malloc(66+strlen(tmpmaps->name));
+            sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);           
             xmlXPathObjectPtr tmpsptr = extractFromDoc (doc, xpathExpr);
             xmlNodeSet* cnodes = tmpsptr->nodesetval;
             xmlParseOutputs2(main_conf,request_inputs,&tmpmaps->child,doc,cnodes);
+            xmlXPathFreeObject (tmpsptr);
+            free(xpathExpr);
             break;
           }
@@ -1470 +1508 @@
 
   xmlInitParser ();
-  //xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER);
-  xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER | XML_PARSE_HUGE); // 
+  xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER);
 
   /**
@@ -1503 +1540 @@
           else
             addToMap(*request_inputs,"mode","auto");
+          xmlFree(val);
           val = xmlGetProp (cur, BAD_CAST "response");
           if(val!=NULL){
@@ -1515 +1553 @@
             addToMap(*request_inputs,"ResponseDocument","");
           }
+          xmlFree(val);
         }
       }
@@ -1768 +1807 @@
 #endif
                   targetFile =
-                    open (storageNameOnServer, O_RDWR | O_CREAT | O_TRUNC,
+                    zOpen (storageNameOnServer, O_RDWR | O_CREAT | O_TRUNC,
                           S_IRWXU | S_IRGRP | S_IROTH);
                   if (targetFile < 0)
@@ -1788 +1827 @@
                   addToMap (tmpReqI->content, "lref", storageNameOnServer);
                   cgiFormFileClose (file);
-                  close (targetFile);
+                  zClose (targetFile);
                   free(fileNameOnServer);
                   free(storageNameOnServer);
@@ -1820 +1859 @@
   if (r_inputs == NULL){
     if(mandatory>0){
-      const char *replace=_("Mandatory parameter <%s> was not specified");
+      char *replace=_("Mandatory parameter <%s> was not specified");
       char *message=(char*)malloc((strlen(replace)+strlen(toCheck)+1)*sizeof(char));
       sprintf(message,replace,toCheck);
@@ -1869 +1908 @@
     }
     if(hasValidValue<0){
-      const char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
+      char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
       nb=0;
       char *vvalues=NULL;
-      const char* num=_("is");
+      char* num=_("is");
       while(avalues[nb]!=NULL){
         char *tvalues;
@@ -1920 +1959 @@
   }
 }
+
+/**
+ * Parse cookie contained in request headers.
+ *
+ * @param conf the conf maps containinfg the main.cfg
+ * @param cookie the 
+ */
+void parseCookie(maps** conf,const char* cookie){
+  char* tcook=zStrdup(cookie);
+  char *token, *saveptr;
+  token = strtok_r (tcook, "; ", &saveptr);
+  maps* res=createMaps("cookies");
+  while (token != NULL){
+    char *token1, *saveptr1, *name;
+    int i=0;
+    token1 = strtok_r (token, "=", &saveptr1);
+    while (token1 != NULL){
+      if(i==0){
+        name=zStrdup(token1);
+        i++;
+      }
+      else{
+        if(res->content==NULL)
+          res->content=createMap(name,token1);
+        else
+          addToMap(res->content,name,token1);
+        free(name);
+        name=NULL;
+        i=0;
+      }
+      token1 = strtok_r (NULL, "=", &saveptr1);
+    }
+    if(name!=NULL)
+      free(name);
+    token = strtok_r (NULL, "; ", &saveptr);
+  }
+  addMapsToMaps(conf,res);
+  freeMaps(&res);
+  free(res);
+  free(tcook);
+}

trunk/zoo-project/zoo-kernel/request_parser.h

@@ -45 +45 @@
   int kvpParseOutputs(maps**,map *,maps**);
   int xmlParseInputs(maps**,service*,maps**,xmlDocPtr,xmlNodeSet*,HINTERNET*);
+  int xmlParseBoundingBox(maps** main_conf,map** current_input,xmlDocPtr doc);
   int xmlParseOutputs(maps**,map**,maps**,xmlDocPtr,xmlNodePtr,bool);
   int xmlParseRequest(maps**,const char*,map**,service*,maps**,maps**,HINTERNET*);
@@ -50 +51 @@
   void checkValidValue(map*,map**,const char*,const char**,int);
   int validateRequest(maps**,service*,map*,maps**,maps**,HINTERNET*);
-
+  void parseCookie(maps**,const char*);
+  
 #ifdef __cplusplus
 }

trunk/zoo-project/zoo-kernel/response_print.c

@@ -23 +23 @@
  */
 
+#include "service.h"
 #include "response_print.h"
 #include "request_parser.h"
@@ -31 +32 @@
 #else
 #include "cpl_vsi.h"
+#endif
+#ifdef USE_CALLBACK
+#include "service_callback.h"
 #endif
 
@@ -75 +79 @@
     }
     if(prefix!=NULL){
-      char* tmp0=strdup(serv->name);
+      char* tmp0=zStrdup(serv->name);
       free(serv->name);
       serv->name=(char*)malloc((strlen(prefix)+strlen(tmp0)+1)*sizeof(char));
@@ -179 +183 @@
     nbNs++;
     currId=0;
-    nsName[currId]=strdup(name);
+    nsName[currId]=zStrdup(name);
     usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
   }else{
@@ -186 +190 @@
       nbNs++;
       currId=nbNs-1;
-      nsName[currId]=strdup(name);
+      nsName[currId]=zStrdup(name);
       usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
     }
@@ -251 +255 @@
   if(soap!=NULL && strcasecmp(soap->value,"true")==0){
     int lNbNs=nbNs;
-    nsName[lNbNs]=strdup("soap");
+    nsName[lNbNs]=zStrdup("soap");
     usedNs[lNbNs]=xmlNewNs(NULL,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
     nbNs++;
     xmlNodePtr nr = xmlNewNode(usedNs[lNbNs], BAD_CAST "Envelope");
-    nsName[nbNs]=strdup("soap");
+    nsName[nbNs]=zStrdup("soap");
     usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
     nbNs++;
-    nsName[nbNs]=strdup("xsi");
+    nsName[nbNs]=zStrdup("xsi");
     usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
     nbNs++;
@@ -338 +342 @@
       }
       else{
-        nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
-        xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
         if(dcount==0){
           if(vid==0){
+            nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
+            xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
             xmlAddChild(nc2,nc4);
             xmlAddChild(nc1,nc2);
@@ -361 +365 @@
       nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
       xmlAddChild(nc4,xmlNewText(BAD_CAST buff));             
-        if(vid==0)
-          xmlAddChild(nc3,nc4);
-        else
-          xmlAddChild(nc1,nc4);
+      if(vid==0)
+        xmlAddChild(nc3,nc4);
+      else
+        xmlAddChild(nc1,nc4);
     }
   }
@@ -590 +594 @@
     map* tmp=getMap(toto1->content,"serverAddress");
     if(tmp!=NULL){
-      SERVICE_URL = strdup(tmp->value);
+      SERVICE_URL = zStrdup(tmp->value);
     }
     else
-      SERVICE_URL = strdup("not_defined");
+      SERVICE_URL = zStrdup("not_defined");
   }
   else
-    SERVICE_URL = strdup("not_defined");
+    SERVICE_URL = zStrdup("not_defined");
 
   for(j=0;j<nbSupportedRequests;j++){
@@ -644 +648 @@
  * @return the generated wps:ProcessOfferings xmlNodePtr 
  */
-void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xml,ns_xlink;
-  xmlNodePtr n=NULL,nc1,nc2;
+  xmlNodePtr n=NULL,nc1,nc2,nc3;
   map* version=getMapFromMaps(m,"main","rversion");
   int vid=getVersionId(version->value);
@@ -667 +671 @@
       limit=7;
     }
+    nc3=NULL;
+    map* sType=getMap(serv->content,"serviceType");
     for(;i<limit;i+=2){
       if(capabilities[vid][i]==NULL)
@@ -682 +688 @@
             xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST tmp1->value);
         }
-        else
-          xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        else{
+          if(i==3 && vid==1 && sType!=NULL && strstr(sType->value,"HPC")!=NULL)
+            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
+          else
+            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        }
       }
     }
@@ -690 +700 @@
     printDescription(nc1,ns_ows,serv->name,serv->content,vid);
     tmp1=serv->metadata;
-    while(tmp1!=NULL){
-      nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
-      xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
-      xmlAddChild(nc1,nc2);
-      tmp1=tmp1->next;
-    }
-
+
+    addMetadata(tmp1,doc,nc1,ns_ows,ns_xlink,vid);
+    tmp1=serv->additional_parameters;
+    int fromDb=-1;
+    map* test=getMap(serv->content,"fromDb");
+    if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+      fromDb=1;
+    addAdditionalParameters(tmp1,doc,nc1,ns_ows,ns_xlink,fromDb);
+
+    if(nc3!=NULL)
+      xmlAddChild(nc1,nc3);
     xmlAddChild(nc,nc1);
   }
+
 }
 
@@ -708 +723 @@
  * @param content the servive main content created from the zcfg file
  * @param vid the version identifier (0 for 1.0.0 and 1 for 2.0.0)
- */
-void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid){
+ * @param serviceType string containing the current service type
+ */
+void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid,map* serviceType){
   int limit=7;
   for(int i=1;i<limit;i+=2){
@@ -728 +744 @@
     }
     else{
-      if(vid==0 && i>=2)
-        xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+      if(i==3 && vid==1 && serviceType!=NULL && strstr(serviceType->value,"HPC")!=NULL)
+        xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
       else
-        xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
-    }
+        if(vid==0 && i>=2)
+          xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        else
+          xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+    }
+  }
+}
+
+/**
+ * Add a Metadata node to any existing node.
+ * @param meta the map defining the additional parameters
+ * @param doc the XML document used
+ * @param nb the node to add the additional parameters
+ * @param ns_ows the OWS namespace
+ * @param ns_xlink the xlink namespace
+ * @param vid the version of WPS to use (0 for 1.0.0 and 1 for 2.0)
+ */
+void addMetadata(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int vid){
+  int hasTitle=-1;
+  int hasValue=-1;
+  xmlNodePtr nc1;
+  map* oMeta=meta;
+  int isAdditionalParameters=-1;
+  int level=0;
+  map* test=getMap(meta,"title");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"href");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"role");
+  if(test!=NULL)
+    level+=1;
+  if(count(oMeta)>level+1)
+    isAdditionalParameters=1;
+  char *ctitle=NULL;
+  while(meta!=NULL){
+    if(hasTitle<0)
+      if(isAdditionalParameters<0)
+        nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
+      else
+        if(hasValue<0)
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+    if(strncasecmp(meta->name,"title",5)==0 ||
+       strcasecmp(meta->name,"href")==0 ||
+       strcasecmp(meta->name,"role")==0 ){
+      int index=5;
+      if(strncasecmp(meta->name,"title",5)==0){
+        index=6;
+        hasTitle=1;
+        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
+          xmlAddChild(nc,nc1);
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+          free(ctitle);
+          ctitle=NULL;
+        }
+        if(ctitle==NULL){
+          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
+          snprintf(tmp,index,"%s",meta->name);
+          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
+          free(tmp);
+        }         
+        if(ctitle!=NULL)
+          free(ctitle);
+        ctitle=zStrdup(meta->value);
+      }
+    }else{
+      xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
+      xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
+      xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
+      xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+      xmlAddChild(nc4,xmlNewText(BAD_CAST meta->value));
+      xmlAddChild(nc2,nc3);
+      xmlAddChild(nc2,nc4);
+      xmlAddChild(nc1,nc2);
+      hasTitle=-1;
+    }
+    meta=meta->next;
+    if(hasTitle<0){
+      hasValue=1;
+      if(isAdditionalParameters){
+        if(vid==0){
+          meta=NULL;
+          break;
+        }else
+          xmlAddChild(nc,nc1);
+      }
+    }
+  }
+  if(oMeta!=NULL && hasValue<0 && nc1!=NULL){
+    xmlAddChild(nc,nc1);
+  }
+}
+
+/**
+ * Add AdditionalParameters nodes to any existing node.
+ * @param meta the map defining the additional parameters
+ * @param doc the XML document used
+ * @param nb the node to add the additional parameters
+ * @param ns_ows the OWS namespace
+ * @param ns_xlink the xlink namespace
+ * @param fromDb 1 if the metadata has been extracted from the metadb, 
+ * 0 otherwise
+ */
+void addAdditionalParameters(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int fromDb){
+  int hasTitle=-1;
+  int hasValue=-1;
+  int toAddAtEnd=-1;
+  int cnt=0;
+  xmlNodePtr* ncr=NULL;
+  xmlNodePtr nc1;
+  map* oMeta=meta;
+  int isAdditionalParameters=-1;
+  int level=0;
+  map* test=getMap(meta,"title");
+  map* otitle=getMap(meta,"title");
+  map* length=getMap(meta,"length");
+  int len=0;
+  char *ctitle=NULL;
+    
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"href");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"role");
+  if(test!=NULL)
+    level+=1;
+  if(count(oMeta)>level+1)
+    isAdditionalParameters=1;
+
+  while(meta!=NULL){
+    if(hasTitle<0 && hasValue<0){
+      nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+    }
+    if(strncasecmp(meta->name,"title",5)==0 ||
+       strcasecmp(meta->name,"href")==0 ||
+       strcasecmp(meta->name,"role")==0 ){
+      int index=5;
+      if(strncasecmp(meta->name,"title",5)==0){
+        index=6;
+        hasTitle=1;
+        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
+          xmlNodePtr ncTmp = xmlDocCopyNodeList(doc,nc1);
+          xmlAddChild(nc,ncTmp);
+          xmlFreeNode(nc1);
+          toAddAtEnd=1;
+          cnt++;
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+          free(ctitle);
+          ctitle=NULL;
+        }
+        if(ctitle==NULL){
+          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
+          snprintf(tmp,index,"%s",meta->name);
+          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
+          free(tmp);
+        }         
+        if(ctitle!=NULL)
+          free(ctitle);
+        ctitle=zStrdup(meta->value);
+      }else{
+        xmlNewNsProp(nc1,ns_xlink,BAD_CAST meta->name,BAD_CAST meta->value);
+      }
+    }else{
+      if(strncasecmp(meta->name,"length",6)!=0 && strncasecmp(meta->name,"fromDb",6)!=0){
+        xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
+        xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
+        xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
+        xmlAddChild(nc2,nc3);
+        if(fromDb<0){
+          char *mptr;
+          char* meta_values=strtok_r(meta->value,",",&mptr);
+          while(meta_values!=NULL){
+            xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+            xmlAddChild(nc4,xmlNewText(BAD_CAST meta_values));
+            xmlAddChild(nc2,nc4);
+            meta_values=strtok_r(NULL,",",&mptr);
+          }
+        }else{
+          xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+          xmlAddChild(nc4,xmlNewCDataBlock(doc,BAD_CAST meta->value,strlen(meta->value)));
+          xmlAddChild(nc2,nc4);
+        }
+        xmlAddChild(nc1,nc2);
+      }
+      hasTitle=-1;
+    }
+    meta=meta->next;
+    if(hasTitle<0){
+      //xmlAddChild(nc,nc1);
+      hasValue=1;
+    }/*else
+       if(ctitle!=NULL)
+       free(ctitle);*/
+  }
+  if(length!=NULL)
+    len=atoi(length->value);
+  if(otitle!=NULL)
+    len=1;
+  if(cnt<len){
+    xmlAddChild(nc,nc1);
+    free(ctitle);
   }
 }
@@ -792 +1009 @@
  * @return the generated wps:ProcessOfferings xmlNodePtr 
  */
-void printDescribeProcessForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printDescribeProcessForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xlink;
   xmlNodePtr n,nc1;
@@ -798 +1015 @@
   map* version=getMapFromMaps(m,"main","rversion");
   int vid=getVersionId(version->value);
+  int fromDb=-1;
+  map* serviceType=getMap(serv->content,"serviceType");
+  map* test=getMap(serv->content,"fromDb");
+  if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+    fromDb=1;
 
   n=nc;
@@ -811 +1033 @@
   if(vid==0){
     nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
-    attachAttributes(nc,ns,serv->content,vid);
+    attachAttributes(nc,ns,serv->content,vid,NULL);
   }
   else{
@@ -828 +1050 @@
       }
     }
-    attachAttributes(nc2,NULL,serv->content,vid);
+    attachAttributes(nc2,NULL,serv->content,vid,serviceType);
     map* level=getMap(serv->content,"level");
     if(level!=NULL && strcasecmp(level->value,"generic")==0)
@@ -843 +1065 @@
     tmp1=serv->metadata;
     while(tmp1!=NULL){
-      nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
-      xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
-      xmlAddChild(nc,nc1);
+      addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
       tmp1=tmp1->next;
     }
@@ -855 +1075 @@
     }
   }else{
+    tmp1=serv->metadata;
+    addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
     addInheritedMetadata(nc,ns_ows,ns_xlink,reg,m,serv);
+    tmp1=serv->additional_parameters;
+    if(vid!=0)
+      addAdditionalParameters(tmp1,doc,nc,ns_ows,ns_xlink,fromDb);
   }
 
@@ -862 +1087 @@
     if(vid==0){
       nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
-      printFullDescription(1,e,"Input",ns,ns_ows,nc1,vid);
+      printFullDescription(doc,1,e,"Input",ns,ns_ows,nc1,vid,fromDb,NULL);
       xmlAddChild(nc,nc1);
     }
     else{
-      printFullDescription(1,e,"wps:Input",ns,ns_ows,nc,vid);
+      printFullDescription(doc,1,e,"wps:Input",ns,ns_ows,nc,vid,fromDb,NULL);
     }
   }
@@ -873 +1098 @@
   if(vid==0){
     nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
-    printFullDescription(0,e,"Output",ns,ns_ows,nc1,vid);
+    printFullDescription(doc,0,e,"Output",ns,ns_ows,nc1,vid,fromDb,NULL);
     xmlAddChild(nc,nc1);
   }
   else{
-    printFullDescription(0,e,"wps:Output",ns,ns_ows,nc,vid);
+    printFullDescription(doc,0,e,"wps:Output",ns,ns_ows,nc,vid,fromDb,serviceType);
   }
   if(vid==0)
@@ -899 +1124 @@
  * @param nc1 the XML node to use to add the created tree
  * @param vid the WPS version id (0 for 1.0.0, 1 for 2.0.0)
- */
-void printFullDescription(int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid){
+ * @param fromDb 1 in case the metadata comes from the DB, -1 in other cases
+ * @param serviceType the serviceType found in the ZCFG file or the DB
+ */
+void printFullDescription(xmlDocPtr doc,int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid,int fromDb,const map* serviceType){
   xmlNsPtr ns1=NULL;
   if(vid==1)
@@ -913 +1140 @@
     int isAnyValue=1;
     nc2 = xmlNewNode(NULL, BAD_CAST type);
+    // Extract min/max Occurence information
     if(strstr(type,"Input")!=NULL){
       tmp1=getMap(e->content,"minOccurs");
@@ -935 +1163 @@
 
     if(e->format!=NULL){
+#ifdef USE_HPC      
+    DEFAULT_OUT:
+#endif
       const char orderedFields[13][14]={
         "mimeType",
@@ -952 +1183 @@
       //Build the (Literal/Complex/BoundingBox)Data node
       if(strncmp(type,"Output",6)==0){
-        if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
+        if(strncasecmp(e->format,"LITERAL",7)==0)
           nc3 = xmlNewNode(ns1, BAD_CAST "LiteralOutput");
         else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
@@ -998 +1229 @@
                 strcmp(e->format,"BoundingBoxData")==0){
           datatype=2;
-          nc5 = xmlNewNode(NULL, BAD_CAST "Default");
+          if(vid==0)
+            nc5 = xmlNewNode(NULL, BAD_CAST "Default");
+          else{
+            xmlNodePtr nc6 = xmlNewNode(ns1, BAD_CAST "Format");
+            xmlNewProp(nc6,BAD_CAST "mimeType",BAD_CAST "text/xml");
+            xmlNewProp(nc6,BAD_CAST "default",BAD_CAST "true");
+            xmlAddChild(nc3,nc6);
+            nc5 = xmlNewNode(NULL, BAD_CAST "SupportedCRS");
+          }
         }
         else{
@@ -1039 +1278 @@
             while(token!=NULL){
               nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
-              char *tmps=strdup(token);
+              char *tmps=zStrdup(token);
               tmps[strlen(tmps)]=0;
-              xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
+              nc8 = xmlNewText(BAD_CAST tmps);
+              xmlAddChild(nc7,nc8);
               free(tmps);
               xmlAddChild(nc6,nc7);
@@ -1207 +1447 @@
                  strncasecmp(tmp1->name,"range",5)!=0){
                 if(datatype!=1){
-                  char *tmp2=zCapitalize1(tmp1->name);
-                  nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
-                  free(tmp2);
+                  if(datatype==2 && vid==1){
+                    nc9 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
+                    xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
+                  }
+                  else{
+                    char *tmp2=zCapitalize1(tmp1->name);
+                    nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
+                    free(tmp2);
+                  }
                 }
                 else{
@@ -1218 +1464 @@
                 xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
                 if(vid==0 || oI>=3){
-                  if(vid==0 || oI!=4)
-                    xmlAddChild(nc5,nc9);
+                  if(vid==0 || oI!=4){
+                    if(datatype==2 && vid==1)
+                      xmlAddChild(nc3,nc9);
+                    else
+                      xmlAddChild(nc5,nc9);
+                  }
                   if(oI==4 && vid==1){
                     xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
                   }
                 }
-                else
-                  xmlFree(nc9);
+                else{
+                  xmlFreeNode(nc9);
+                }
                 if(strcasecmp(tmp1->name,"uom")==0)
                   hasUOM1=true;
                 hasUOM=true;
-              }else       
-                tmp1=tmp1->next;
+              }
             }
         }
@@ -1245 +1495 @@
           }else{
             if(hasUOM1==false && vid==0){
-              xmlFreeNode(nc5);
-              if(datatype==1)
+              if(nc5!=NULL)
+                xmlFreeNode(nc5);
+              if(datatype==1){
                 xmlFreeNode(nc4);
+              }
             }
-            else
+            else{
               xmlAddChild(nc3,nc5);
+            }
           }
         }else{
-          xmlAddChild(nc3,nc5);
+          if(vid==0)
+            xmlAddChild(nc3,nc5);
+          else
+            xmlFreeNode(nc5);
         }
       
-        if(datatype!=1 && default1<0){
+        if(datatype==0 && default1<0){
           xmlFreeNode(nc5);
-          if(datatype!=2)
+          if(datatype!=2){
             xmlFreeNode(nc4);
+          }
         }
 
@@ -1310 +1567 @@
               nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
               free(tmp2);
-              //xmlNewProp(nc9, BAD_CAST "default", BAD_CAST "true");
               xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
               xmlAddChild(nc5,nc9);
-              /*struct iotype * _ltmp=e->supported;
-                while(_ltmp!=NULL){
-                tmp1=getMap(_ltmp->content,"uom");
-                if(tmp1!=NULL){
-                char *tmp2=zCapitalize(tmp1->name);
-                nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
-                free(tmp2);
-                xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
-                xmlAddChild(nc5,nc9);
-                }
-                _ltmp=_ltmp->next;
-                }*/
-            
             }
           }
@@ -1340 +1583 @@
         xmlNsPtr ns_xlink=usedNs[xlinkId];
 
-        while(metadata!=NULL){
-          nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
-          xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
-          xmlAddChild(nc2,nc6);
-          metadata=metadata->next;
-        }
+        addMetadata(metadata,doc,nc2,ns_ows,ns_xlink,vid);
+        if(vid!=0)
+          addAdditionalParameters(e->additional_parameters,doc,nc2,ns_ows,ns_xlink,fromDb);
 
       }
 
       _tmp=e->supported;
-      if(_tmp==NULL && datatype!=1)
+      if(_tmp==NULL && datatype==0)
         _tmp=e->defaults;
 
@@ -1396 +1636 @@
                strcasecmp(tmp1->name,"extension")!=0){
               if(datatype!=1){
-                char *tmp2=zCapitalize1(tmp1->name);
-                nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
-                free(tmp2);
+                if(datatype==2 && vid==1){
+                  nc6 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
+                }
+                else{
+                  char *tmp2=zCapitalize1(tmp1->name);
+                  nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
+                  free(tmp2);
+                }
               }
               else{
@@ -1422 +1667 @@
               }
               if(vid==0 || oI>=3){
-                if(vid==0 || oI!=4)
-                  xmlAddChild(nc5,nc6);
-                else
-                  xmlFree(nc6);
+                if(vid==0 || oI!=4){
+                  if(datatype==2 && vid==1)
+                    xmlAddChild(nc3,nc6);
+                  else
+                    xmlAddChild(nc5,nc6);
+                }
+                else{
+                  xmlFreeNode(nc6);
+                }
               }
-              else
-                xmlFree(nc6);
+              else{
+                xmlFreeNode(nc6);
+              }
             }
             tmp1=tmp1->next;
@@ -1439 +1690 @@
             }
             else{
-              xmlAddChild(nc3,nc5);
+              if(datatype!=2)
+                xmlAddChild(nc3,nc5);
             }
 
           }else{
-            if(datatype!=1)
+            if(datatype==2 && vid==0)
               xmlAddChild(nc3,nc5);
           }
@@ -1459 +1711 @@
           }
           else
-            if(datatype!=1)
+            if(datatype==0){
+              xmlFreeNode(nc4);
               xmlAddChild(nc3,nc5);
+            }
 
         _tmp=_tmp->next;
@@ -1466 +1720 @@
 
       if(hasSupported==0){
-        if(datatype==0 && vid!=0)
+        if(datatype==0 && vid!=0){
           xmlFreeNode(nc4);
+        }
         xmlFreeNode(nc5);
       }
@@ -1478 +1733 @@
         }
         else{
+          xmlFreeNode(nc4);
           xmlAddChild(nc3,nc5);
         }
@@ -1491 +1747 @@
     }else{
       if(e->child!=NULL && vid!=0){
-        printFullDescription(in,e->child,type,ns,ns_ows,nc2,vid);
-      }
-    }
-    
+        printFullDescription(doc,in,e->child,type,ns,ns_ows,nc2,vid,fromDb,NULL);
+      }
+    }
     if(e->child!=NULL && vid==0){
       elements* children=dupElements(e->child);
       elements* cursor=children;
       while(cursor!=NULL){
-        char* tmp=strdup(cursor->name);
-        free(cursor->name);
-        cursor->name=(char*)malloc((strlen(cursor->name)+strlen(e->name)+2)*sizeof(char));
-        sprintf(cursor->name,"%s.%s",e->name,tmp);
+        elements* ccursor=cursor;
+        char* tmp=zStrdup(ccursor->name);
+        free(ccursor->name);
+        ccursor->name=(char*)malloc((strlen(tmp)+strlen(e->name)+2)*sizeof(char));
+        sprintf(ccursor->name,"%s.%s",e->name,tmp);
         cursor=cursor->next;
       }
-      printFullDescription(in,children,type,ns,ns_ows,nc2,vid);
-      xmlAddChild(nc1,nc2);
+      printFullDescription(doc,in,children,type,ns,ns_ows,nc1,vid,fromDb,serviceType);
       freeElements(&children);
       free(children);
-    }else
-      xmlAddChild(nc1,nc2);
-    
+    }else{
+      if(nc2!=NULL){
+        xmlAddChild(nc1,nc2);
+      }
+    }
     e=e->next;
   }
@@ -1528 +1785 @@
  * @param outputs the outputs generated by the service
  */
-void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
+void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){       
   xmlNsPtr ns,ns_ows,ns_xlink;
   xmlNodePtr nr,n,nc,nc1=NULL,nc3;
@@ -1549 +1806 @@
   char stored_path[1024];
   memset(stored_path,0,1024);
-    
+  
   if(vid==0){
     char tmp[256];
@@ -1734 +1991 @@
     }
   }
-
+  
   /**
    * Display the process output only when requested !
@@ -1744 +2001 @@
     maps* mcursor=outputs;
     elements* scursor=serv->outputs;
-    map* testResponse=getMap(request,"RawDataOutput");
+    map* testResponse=getMap(request,"RawDataOutput");  
     if(testResponse==NULL)
       testResponse=getMap(request,"ResponseDocument");
-    while(mcursor!=NULL){
+    while(mcursor!=NULL){               
       map* tmp0=getMap(mcursor->content,"inRequest");
-      scursor=getElements(serv->outputs,mcursor->name);
-      if(scursor!=NULL){
-        if(testResponse==NULL || tmp0==NULL){
+      scursor=getElements(serv->outputs,mcursor->name);   
+      if(scursor!=NULL){                  
+        if(testResponse==NULL || tmp0==NULL){           
           if(vid==0)
             printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
@@ -1758 +2015 @@
         }
         else
-
-          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){
+          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){             
             if(vid==0)
               printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
             else
               printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
-          }
+          }     
       }else
         /**
@@ -1775 +2031 @@
           printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
       mcursor=mcursor->next;
-    }
+    }   
     if(vid==0)
       xmlAddChild(n,nc);
-  }
-
+  }  
   if(vid==0 && 
      hasStoredExecuteResponse==true 
@@ -1834 +2089 @@
 #endif
   }
+
   printDocument(m,doc,pid);
 
@@ -1891 +2147 @@
   else{
     /*
-    dumpElements(e);
+      dumpElements(e);
     */
     return;
@@ -1900 +2156 @@
        || strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
        || strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
-    xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
+      xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
     tmp=tmp->next;
   }
@@ -1927 +2183 @@
  * @param type the type
  */
-void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){
-
+void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){   
   xmlNodePtr nc1,nc2,nc3;
   nc1=xmlNewNode(ns_wps, BAD_CAST type);
@@ -1935 +2190 @@
     tmp=e->content;
   else
-    tmp=m->content;
-
+    tmp=m->content;  
   if(vid==0){
     nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
@@ -1976 +2230 @@
     xmlNewProp(nc1,BAD_CAST "id",BAD_CAST (e!=NULL?e->name:m->name));
   }
-
+  
   // IO type nested outputs
-  if(m->child!=NULL){
+  if(m->child!=NULL){     
     maps* curs=m->child;
     elements* ecurs=getElements(e,(e!=NULL?e->name:m->name));
     ecurs=ecurs->child;
-    while(curs!=NULL){
+    while(curs!=NULL/* && ecurs!=NULL*/){
       ecurs=getElements(ecurs,(curs->name));
       map* inRequest=getMap(curs->content,"inRequest");
@@ -1992 +2246 @@
     }
   }
-  else{
+  else{   
     map *tmpMap=getMap(m->content,"Reference");
-    if(tmpMap==NULL){
+    if(tmpMap==NULL){           
       nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
-      if(e!=NULL && e->format!=NULL){
-        if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
-          nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
+      if(e!=NULL && e->format!=NULL){             
+                  if (strncasecmp(e->format, "LiteralOutput", strlen(e->format)) == 0)                                    
+                          nc3 = xmlNewNode(ns_wps, BAD_CAST "LiteralData");               
         else
           if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
@@ -2005 +2259 @@
             nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
           else
-            nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
-      }
-      else {
-        map* tmpV=getMapFromMaps(m,"format","value");
+            nc3=xmlNewNode(ns_wps, BAD_CAST e->format);           
+      }
+      else {              
+        map* tmpV=getMapFromMaps(m,"format","value");   
         if(tmpV!=NULL)
           nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
@@ -2014 +2268 @@
           nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
       } 
-      tmp=m->content;
-      
+      tmp=m->content;     
+
       while(tmp!=NULL){
         if(strcasecmp(tmp->name,"mimeType")==0 ||
@@ -2021 +2275 @@
            strcasecmp(tmp->name,"schema")==0 ||
            strcasecmp(tmp->name,"datatype")==0 ||
-           strcasecmp(tmp->name,"uom")==0) {
-          
+           strcasecmp(tmp->name,"uom")==0) {    
           if(vid==0)
             xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
@@ -2033 +2286 @@
           }
         }
+
         if(vid==0)
           xmlAddChild(nc2,nc3);
-        tmp=tmp->next;
+        tmp=tmp->next;  
       }
       if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0) {
@@ -2046 +2300 @@
         }
       }
-      else {
-        if(e!=NULL)
-          tmp=getMap(e->defaults->content,"mimeType");
+      else {              
+                  //if (e != NULL) {
+                  if (e != NULL && e->defaults != NULL) { // knut: add extra NULL pointer check in case user omits <Default> block in config file                         
+                          tmp = getMap(e->defaults->content, "mimeType");
+                  }
         else
-          tmp=NULL;
-        
+          tmp=NULL;     
         map* tmp1=getMap(m->content,"encoding");
         map* tmp2=getMap(m->content,"mimeType");
@@ -2106 +2361 @@
              strstr(tmp2->value, "json") != NULL ||            //    (will not be parsed by XML reader) 
              strstr(tmp2->value, "ecmascript") != NULL
-           ) {
+             ) {
             xmlAddChild((vid==0?nc3:nc2),xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
           }   
@@ -2112 +2367 @@
             if (strstr(tmp2->value, "xml") != NULL ||                 // if XML-based format
                 // include for backwards compatibility,
-              // although correct mime type is ...kml+xml:                 
+                // although correct mime type is ...kml+xml:               
                 strstr(tmp2->value, "google-earth.kml") != NULL
                 ) { 
@@ -2241 +2496 @@
   else
     exceptionCode="501 Internal Server Error";
-
+  tmp=getMapFromMaps(m,"lenv","status_code");
+  if(tmp!=NULL)
+    exceptionCode=tmp->value;
   if(m!=NULL){
     map *tmpSid=getMapFromMaps(m,"lenv","sid");
@@ -2332 +2589 @@
 
     tmp=getMapArray(s,"text",cnt);
+    if(tmp==NULL)
+      tmp=getMapArray(s,"message",cnt);
     nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
     if(tmp!=NULL){
       xmlNodePtr txt=xmlNewText(BAD_CAST tmp->value);
       xmlAddChild(nc1,txt);
+      if(cnt==0)
+        setMapInMaps(m,"lenv","message",tmp->value);
     }
     else{
@@ -2381 +2642 @@
 void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
                     map* request_inputs1,int cpid,maps* m,int res){
-                
 #ifdef DEBUG
   dumpMaps(request_inputs);
   dumpMaps(request_outputs);
   fprintf(stderr,"printProcessResponse\n");
-#endif
+#endif  
   map* toto=getMap(request_inputs1,"RawDataOutput");
   int asRaw=0;
@@ -2396 +2656 @@
   if(tmpSess!=NULL){
     map *_tmp=getMapFromMaps(m,"lenv","cookie");
+    maps *tmps=getMaps(m,"senv");
     char* sessId=NULL;
     if(_tmp!=NULL){
       printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
+      map *_tmp1=getMapFromMaps(m,"senv","ecookie_length");
+      if(_tmp1!=NULL){
+        int len=atoi(_tmp1->value);
+        int cnt=0;
+        for(cnt=0;cnt<len;cnt++){
+          map* _tmp2=getMapArray(tmps->content,"ecookie",cnt);
+          if(_tmp2!=NULL)
+            printf("Set-Cookie: %s; HttpOnly\r\n",_tmp2->value);
+        }
+      }
       printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
       char session_file_path[100];
@@ -2406 +2677 @@
       else
         sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
-      sessId=strdup(session_file_path);
+      sessId=zStrdup(session_file_path);
     }else{
       maps* t=getMaps(m,"senv");
@@ -2412 +2683 @@
       while(p!=NULL){
         if(strstr(p->name,"ID")!=NULL){
-          sessId=strdup(p->value);
+          sessId=zStrdup(p->value);
           break;
         }
@@ -2435 +2706 @@
     }
   }
-                 
   if(res==SERVICE_FAILED){
     map *lenv;
@@ -2462 +2732 @@
     return;
   }
-        
+
+  if(res!=SERVICE_SUCCEEDED){     
+    printProcessResponse(m,request_inputs1,cpid,
+                         s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
+                         request_inputs,
+                         request_outputs);
+    return;
+  }
+      
   map *tmp1=getMapFromMaps(m,"main","tmpPath");
   if(asRaw==0){
@@ -2473 +2751 @@
     map* usid=getMapFromMaps(m,"lenv","usid");
     int itn=0;
+    int error=-1;
   NESTED0:
     while(tmpI!=NULL){
@@ -2483 +2762 @@
 #endif
       map *gfile=getMap(tmpI->content,"generated_file");
-      char *file_name;
+      char *file_name=NULL;       
       if(gfile!=NULL){
         gfile=getMap(tmpI->content,"expected_generated_file");
@@ -2491 +2770 @@
         readGeneratedFile(m,tmpI->content,gfile->value);
         file_name=zStrdup((gfile->value)+strlen(tmp1->value));
-      }
-
+      }   
       toto=getMap(tmpI->content,"asReference");
 #ifdef USE_MS
-      if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
+      map* geodatatype=getMap(tmpI->content,"geodatatype");
+      if(toto!=NULL && strcasecmp(toto->value,"true")==0 &&
+         (testMap==NULL ||
+          strncasecmp(testMap->value,"true",4)!=0 ||
+          (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0) ) ) 
 #else
-      if(toto!=NULL && strcasecmp(toto->value,"true")==0)
+        if(toto!=NULL && strcasecmp(toto->value,"true")==0)
 #endif
-        {
-          elements* in=getElements(s->outputs,tmpI->name);
-          if(in==NULL && s->outputs->child!=NULL){
-            in=getElements(s->outputs->child,tmpI->name);
+          {             
+            elements* in=getElements(s->outputs,tmpI->name);
+            if(in==NULL && s->outputs->child!=NULL){
+              in=getElements(s->outputs->child,tmpI->name);
+            }
+            char *format=NULL;
+            if(in!=NULL && in->format!=NULL){
+              format=in->format;
+            }else
+              format=(char*)"LiteralData";
+            if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
+              addToMap(tmpI->content,"extension","xml");
+              addToMap(tmpI->content,"mimeType","text/xml");
+              addToMap(tmpI->content,"encoding","UTF-8");
+              addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
+            }           
+            char *file_path=NULL;
+            if(gfile==NULL) {
+              map *ext=getMap(tmpI->content,"extension");
+              char file_ext[32];
+            
+              if( ext != NULL && ext->value != NULL) {
+                strncpy(file_ext, ext->value, 32);
+              }
+              else {
+                // Obtain default file extension (see mimetypes.h).           
+                // If the MIME type is not recognized, txt is used as the default extension
+                map* mtype=getMap(tmpI->content,"mimeType");
+                getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
+              }
+              if(file_name!=NULL)
+                free(file_name);
+              file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
+              sprintf(file_name,"ZOO_DATA_%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
+              itn++;
+              file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
+              sprintf(file_path,"%s/%s",tmp1->value,file_name);
+
+              FILE *ofile=fopen(file_path,"wb");
+              if(ofile==NULL){
+                char tmpMsg[1024];
+                sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
+                errorException(m,tmpMsg,"InternalError",NULL);
+                free(file_name);
+                free(file_path);
+                return;
+              }
+
+              toto=getMap(tmpI->content,"value");
+              if(toto==NULL){
+                char tmpMsg[1024];
+                sprintf(tmpMsg,_("No value found for the requested output %s."),tmpI->name);
+                errorException(m,tmpMsg,"InternalError",NULL);
+                fclose(ofile);
+                free(file_name);
+                free(file_path);
+                return;
+              }
+              if(strcasecmp(format,"BoundingBoxData")!=0){
+                map* size=getMap(tmpI->content,"size");
+                if(size!=NULL && toto!=NULL)
+                  fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
+                else
+                  if(toto!=NULL && toto->value!=NULL)
+                    fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
+              }else{
+                printBoundingBoxDocument(m,tmpI,ofile);
+              }
+              fclose(ofile);
+            }
+
+            map *tmp2=getMapFromMaps(m,"main","tmpUrl");
+            map *tmp3=getMapFromMaps(m,"main","serverAddress");
+            char *file_url=NULL;
+            if(strncasecmp(tmp2->value,"http://",7)==0 ||
+               strncasecmp(tmp2->value,"https://",8)==0){
+              file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
+              sprintf(file_url,"%s/%s",tmp2->value,file_name);
+            }else{
+              file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
+              sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
+            }
+            addToMap(tmpI->content,"Reference",file_url);
+            if(file_name!=NULL)
+              free(file_name);
+            if(file_url!=NULL)
+              free(file_url);
+            file_name=NULL;
           }
-          char *format=NULL;
-          if(in!=NULL && in->format!=NULL){
-            format=in->format;
-          }else
-            format=(char*)"LiteralData";
-          if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
-            addToMap(tmpI->content,"extension","xml");
-            addToMap(tmpI->content,"mimeType","text/xml");
-            addToMap(tmpI->content,"encoding","UTF-8");
-            addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
+#ifdef USE_MS
+        else{
+          if(testMap!=NULL){
+            map* nbFeatures;
+            setMapInMaps(m,"lenv","state","out");
+            setReferenceUrl(m,tmpI);
+            nbFeatures=getMap(tmpI->content,"nb_features");
+            geodatatype=getMap(tmpI->content,"geodatatype");
+            if((nbFeatures!=NULL && atoi(nbFeatures->value)==0) ||
+               (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0)){
+              error=1;
+              res=SERVICE_FAILED;
+            }
           }
-
-          if(gfile==NULL) {
-            map *ext=getMap(tmpI->content,"extension");
-            char *file_path;
-            char file_ext[32];
-
-            if( ext != NULL && ext->value != NULL) {
-              strncpy(file_ext, ext->value, 32);
-            }
-            else {
-              // Obtain default file extension (see mimetypes.h).             
-              // If the MIME type is not recognized, txt is used as the default extension
-              map* mtype=getMap(tmpI->content,"mimeType");
-              getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
-            }
-
-            file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
-            sprintf(file_name,"%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
-            itn++;
-            file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
-            sprintf(file_path,"%s/%s",tmp1->value,file_name);
-
-            FILE *ofile=fopen(file_path,"wb");
-            if(ofile==NULL){
-              char tmpMsg[1024];
-              sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
-              errorException(m,tmpMsg,"InternalError",NULL);
-              free(file_name);
-              free(file_path);
-              return;
-            }
-            free(file_path);
-
-            toto=getMap(tmpI->content,"value");
-            if(strcasecmp(format,"BoundingBoxData")!=0){
-              map* size=getMap(tmpI->content,"size");
-              if(size!=NULL && toto!=NULL)
-                fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
-              else
-                if(toto!=NULL && toto->value!=NULL)
-                  fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
-            }else{
-              printBoundingBoxDocument(m,tmpI,ofile);
-            }
-            fclose(ofile);
-
-          }
-
-          map *tmp2=getMapFromMaps(m,"main","tmpUrl");
-          map *tmp3=getMapFromMaps(m,"main","serverAddress");
-          char *file_url;
-          if(strncasecmp(tmp2->value,"http://",7)==0 ||
-             strncasecmp(tmp2->value,"https://",8)==0){
-            file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
-            sprintf(file_url,"%s/%s",tmp2->value,file_name);
-          }else{
-            file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
-            sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
-          }
-          addToMap(tmpI->content,"Reference",file_url);
-          free(file_name);
-          free(file_url);
-          
-        }
-#ifdef USE_MS
-      else{
-        if(testMap!=NULL){
-          setReferenceUrl(m,tmpI);
-        }
-      }
-#endif
+        }
+#endif  
+      if(file_name!=NULL){
+        free(file_name);
+        file_name=NULL;
+      }
       tmpI=tmpI->next;
     }
@@ -2593 +2897 @@
       if(tmpI!=NULL)
         goto NESTED0;
-    }
+    }    
 #ifdef DEBUG
     fprintf(stderr,"SERVICE : %s\n",s->name);
     dumpMaps(m);
+#endif  
+    if(error<0)
+      printProcessResponse(m,request_inputs1,cpid,
+                           s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
+                           request_inputs,
+                           request_outputs);
+    else{
+      maps* tmpMaps=getMaps(m,"lenv");
+#ifdef USE_CALLBACK
+      invokeCallback(m,NULL,NULL,7,0);
 #endif
-    printProcessResponse(m,request_inputs1,cpid,
-                         s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
-                         request_inputs,
-                         request_outputs);
+      printExceptionReportResponse(m,tmpMaps->content);
+    }
   }
   else{

trunk/zoo-project/zoo-kernel/response_print.h

@@ -39 +39 @@
 #include <libintl.h>
 #include <locale.h>
+
 /**
  * ZOO-Kernel internal messages translation function
@@ -63 +64 @@
 #include <sys/stat.h>
 #include <sys/types.h>
-#include "cgic.h"
 #ifndef WIN32
 #include <sys/ipc.h>
@@ -80 +80 @@
 #endif
 #ifndef WIN32
-#include <xlocale.h>
+//#include <locale.h>
+#include <locale.h> // knut: this appears to be a non-standard header file that has been removed in newer versions of glibc; it may be sufficient to include <locale.h> (see above) 
 #endif
 #include "ulinet.h"
@@ -94 +95 @@
 #include <libxml/parser.h>
 #include <libxml/xpath.h>
+
+#include "cgic.h"
 
 #ifdef __cplusplus
@@ -209 +212 @@
   xmlNodePtr printWPSHeader(xmlDocPtr,maps*,const char*,const char*,const char*,int);
   xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr,maps*,const char*);
-  void printGetCapabilitiesForProcess(registry*,maps*,xmlNodePtr,service*);
-  void printDescribeProcessForProcess(registry*,maps*,xmlNodePtr,service*);
-  void printFullDescription(int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int);
+  void printGetCapabilitiesForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
+  void printDescribeProcessForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
+  void printFullDescription(xmlDocPtr,int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int,int,const map*);
   void printDocument(maps*,xmlDocPtr,int);
   void printDescription(xmlNodePtr,xmlNsPtr,const char*,map*,int);
@@ -220 +223 @@
   void printOutputDefinitions(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,const char*);
   void printStatusInfo(maps*,map*,char*);
+  void addAdditionalParameters(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
+  void addMetadata(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
 
   void outputResponse(service*,maps*,maps*,map*,int,maps*,int);

trunk/zoo-project/zoo-kernel/server_internal.c

@@ -26 +26 @@
 #include "service_internal.h"
 #include "response_print.h"
+//#include "service_callback.h"
 #include "mimetypes.h"
 #ifndef WIN32
@@ -366 +367 @@
  */
 void readGeneratedFile(maps* m,map* content,char* filename){
+  char rsize[1024];
   FILE * file=fopen(filename,"rb");
   if(file==NULL){
-    fprintf(stderr,"Failed to open file %s for reading purpose.\n",filename);
     setMapInMaps(m,"lenv","message","Unable to read produced file. Please try again later");
     return ;
   }
   fseek(file, 0, SEEK_END);
-  long count = ftell(file);
+  zStatStruct f_status;
+  int s=zStat(filename, &f_status);
+  sprintf(rsize,"%lld",f_status.st_size);
   rewind(file);
-  struct stat file_status; 
-  stat(filename, &file_status);
-  map* tmpMap1=getMap(content,"value");
-  if(tmpMap1==NULL){
-    addToMap(content,"value","");
-    tmpMap1=getMap(content,"value");
-  }
-  free(tmpMap1->value);
-  tmpMap1->value=(char*) malloc((count+1)*sizeof(char));  
-  fread(tmpMap1->value,1,count,file);
-  tmpMap1->value[count]=0;
-  fclose(file);
-  char rsize[1000];
-  sprintf(rsize,"%ld",count);
+  if(getMap(content,"storage")==NULL){
+    map* memUse=getMapFromMaps(m,"main","memory");
+    if(memUse==NULL || strncmp(memUse->value,"load",4)==0){
+      map* tmpMap1=getMap(content,"value");
+      if(tmpMap1==NULL){
+        addToMap(content,"value","");
+        tmpMap1=getMap(content,"value");
+      }
+      free(tmpMap1->value);
+      tmpMap1->value=(char*) malloc((f_status.st_size+1)*sizeof(char));
+      if(tmpMap1->value==NULL){
+        setMapInMaps(m,"lenv","message","Unable to allocate the memory required to read the produced file.");
+      }
+      fread(&tmpMap1->value,1,f_status.st_size,file);
+      tmpMap1->value[f_status.st_size]=0;
+    }
+  }
+  fclose(file);  
   addToMap(content,"size",rsize);
 }
@@ -423 +430 @@
 void dumpMapsValuesToFiles(maps** main_conf,maps** in){
   map* tmpPath=getMapFromMaps(*main_conf,"main","tmpPath");
+  map* tmpUrl=getMapFromMaps(*main_conf,"main","tmpUrl");
   map* tmpSid=getMapFromMaps(*main_conf,"lenv","usid");
   maps* inputs=*in;
@@ -445 +453 @@
           if(cSize!=NULL){
             length=atoi(cSize->value);
-          }
+          }else
+            length=strlen(cValue->value);
           writeFile(val,cValue->value,length);
           setMapArray(cMap,"cache_file",k,val);
+          free(val);
+          val=(char*)malloc((strlen(tmpUrl->value)+strlen(inputs->name)+strlen(tmpSid->value)+strlen(file_ext)+16)*sizeof(char));
+          sprintf(val,"%s/Input_%s_%s_%d.%s",tmpUrl->value,inputs->name,tmpSid->value,k,file_ext);
+          setMapArray(cMap,"cache_url",k,val);
+          setMapArray(cMap,"byValue",k,"true");
           free(val);
         }
@@ -461 +475 @@
         if(cSize!=NULL){
           length=atoi(cSize->value);
-        }
+        }else
+          length=strlen(cValue->value);
         writeFile(val,cValue->value,length);
         addToMap(cMap,"cache_file",val);
+        free(val);
+        val=(char*)malloc((strlen(tmpUrl->value)+strlen(inputs->name)+strlen(tmpSid->value)+strlen(file_ext)+16)*sizeof(char));
+        sprintf(val,"%s/Input_%s_%s_%d.%s",tmpUrl->value,inputs->name,tmpSid->value,0,file_ext);
+        addToMap(cMap,"cache_url",val);
+        addToMap(cMap,"byValue",val);
         free(val);
       }
@@ -638 +658 @@
         }
         if(res==NULL){
+          map* tmpMaxO0=getMap(tmpInputs->content,"useMapserver");
+          if(tmpMaxO0!=NULL){
+            if(tmpMaps2->content==NULL)
+              tmpMaps2->content=createMap("useMapserver",tmpMaxO0->value);
+            else
+              addToMap(tmpMaps2->content,"useMapserver",tmpMaxO0->value);
+          }
           map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
           if(tmpMaxO!=NULL){
@@ -701 +728 @@
       }
     }
-    else { 
+    else /*toto*/{ 
       iotype* tmpIoType=NULL;
       if(tmpMaps->content!=NULL){
@@ -711 +738 @@
            * content map.
            */
-          map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
-          if(tmpMap1!=NULL){
-            if(tmpMaps->content==NULL)
-              tmpMaps->content=createMap("minOccurs",tmpMap1->value);
-            else
-              addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
-          }
-          map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
-          if(tmpMaxO!=NULL){
-            if(tmpMaps->content==NULL)
-              tmpMaps->content=createMap("maxOccurs",tmpMaxO->value);
-            else
-              addToMap(tmpMaps->content,"maxOccurs",tmpMaxO->value);
-          }
-          map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
-          if(tmpMaxMB!=NULL){
-            if(tmpMaps->content==NULL)
-              tmpMaps->content=createMap("maximumMegabytes",tmpMaxMB->value);
-            else
-              addToMap(tmpMaps->content,"maximumMegabytes",tmpMaxMB->value);
+          char* keys[4]={
+            "minOccurs",
+            "maxOccurs",
+            "maximumMegabytes",
+            "useMapserver"
+          };
+          int i=0;
+          for(i=0;i<4;i++){
+            map* tmpMap1=getMap(tmpInputs->content,keys[i]);
+            if(tmpMap1!=NULL){
+              addToMap(tmpMaps->content,keys[i],tmpMap1->value);
+            }
           }
           /**
@@ -743 +762 @@
               map* tmpV=getMap(tmpI->content,"value");
               if(tmpV!=NULL){
-                char *tmpVS=strdup(tmpV->value);
+                char *tmpVS=zStrdup(tmpV->value);
                 map* tmp=parseBoundingBox(tmpVS);
                 free(tmpVS);
@@ -780 +799 @@
               map* length=getMap(tmpMaps->content,"length");
               int i;
-              char *tcn=strdup(tmpContent->name);
+              char *tcn=zStrdup(tmpContent->name);
               for(i=1;i<atoi(length->value);i++){
 #ifdef DEBUG
@@ -806 +825 @@
          */
         if(tmpIoType!=NULL){
-          map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
-          if(tmpCheck!=NULL){
+          map* tmpCheck=getMap(tmpIoType->content,"useMapserver");
+          if(tmpCheck!=NULL && strncasecmp(tmpCheck->value,"true",4)==0){
             // Get the default value
+            addToMap(tmpMaps->content,"useMapserver","true");
             tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
             tmpCheck=getMap(tmpMaps->content,"mimeType");
@@ -834 +854 @@
         addToMap(tmpMaps->content,"inRequest","true");
       elements* tmpElements=getElements(in,tmpMaps->name);
-      if(tmpElements!=NULL && tmpElements->child!=NULL){
+      if(/*tmpMaps->child!=NULL && */tmpElements!=NULL && tmpElements->child!=NULL){
         char *res=addDefaultValues(&tmpMaps->child,tmpElements->child,m,type,err);
         if(strlen(res)>0){
           return res;
         }
+      }
+    }
+    if(tmpInputs->child!=NULL){
+      tmpInputss=tmpInputs->next;
+      tmpInputs=tmpInputs->child;
+      if(tmpMaps!=NULL){
+        out1=tmpMaps->child;
+        out1s=tmpMaps;
       }
     }
@@ -972 +1000 @@
     if(isRunning(conf,pid)>0){          
       if(strncasecmp(req,"GetResult",strlen(req))==0){
-        errorException (conf, _("The result for the requested JobID has not yet been generated. "),
+        errorException (conf, _("The result for the requested JobID has not yet been generated. The service is currently running."),
                         "ResultNotReady", pid);
         return;
@@ -981 +1009 @@
           char* tmpStr=_getStatus(conf,pid);
           if(tmpStr!=NULL && strncmp(tmpStr,"-1",2)!=0){
-            char *tmpStr1=strdup(tmpStr);
-            char *tmpStr0=strdup(strstr(tmpStr,"|")+1);
+            char *tmpStr1=zStrdup(tmpStr);
+            char *tmpStr0=zStrdup(strstr(tmpStr,"|")+1);
             free(tmpStr);
             tmpStr1[strlen(tmpStr1)-strlen(tmpStr0)-1]='\0';
@@ -1000 +1028 @@
           printf("%s",result);
           fflush(stdout);
+          free(sid);
           freeMap(&statusInfo);
           free(statusInfo);
+          free(result);
           return;
         }else{
-          errorException (conf, _("The result for the requested JobID has not yet been generated. "),
+          errorException (conf, _("The result for the requested JobID has not yet been generated. The service ends but it still needs to produce the outputs."),
                           "ResultNotReady", pid);
           freeMap(&statusInfo);
@@ -1015 +1045 @@
           char* tmpStr=_getStatus(conf,pid);
           if(tmpStr!=NULL && strncmp(tmpStr,"-1",2)!=0){
-            char *tmpStr1=strdup(tmpStr);
-            char *tmpStr0=strdup(strstr(tmpStr,"|")+1);
+            char *tmpStr1=zStrdup(tmpStr);
+            char *tmpStr0=zStrdup(strstr(tmpStr,"|")+1);
             free(tmpStr);
             tmpStr1[strlen(tmpStr1)-strlen(tmpStr0)-1]='\0';
@@ -1026 +1056 @@
         }
     }
+    free(sid);
     printStatusInfo(conf,statusInfo,req);
     freeMap(&statusInfo);
@@ -1083 +1114 @@
         if(strstr(dp->d_name,pid)!=0){
           sprintf(fileName,"%s/%s",r_inputs->value,dp->d_name);
-          if(unlink(fileName)!=0){
+          if(zUnlink(fileName)!=0){
             errorException (conf, 
                             _("The job cannot be removed, a file cannot be removed"),
@@ -1095 +1126 @@
     removeService(conf,pid);
 #endif
+    /* No need to call 7_1 when an execution is dismissed.
+      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+      invokeCallback(conf,NULL,NULL,7,1);
+      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+    */
     map* statusInfo=createMap("JobID",pid);
     addToMap(statusInfo,"Status","Dismissed");

trunk/zoo-project/zoo-kernel/service.c

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2015 GeoLabs SARL
+ * Copyright (c) 2015-2019 GeoLabs SARL
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -28 +28 @@
 #include <ctime>
 #include <chrono>
+#ifdef WIN32
 #include <process.h>
+#endif
 
 #if defined(_MSC_VER) && _MSC_VER < 1800
@@ -102 +104 @@
     fprintf(stderr," * CONTENT [%s] \n",tmp->name);
     dumpMap(tmp->content);
-    fprintf(stderr," * CHILD [%s] \n",tmp->name);
-    dumpMaps(tmp->child);
+    if(tmp->child!=NULL){
+      fprintf(stderr," * CHILD [%s] \n",tmp->name);
+      dumpMaps(tmp->child);
+      fprintf(stderr," * /CHILD [%s] \n",tmp->name);
+    }
     tmp=tmp->next;
   }
@@ -125 +130 @@
     fflush(file);
     tmp=tmp->next;
-    cnt++;
     if(limit>=0 && cnt==limit)
       tmp=NULL;
+    cnt++;
   }
   fflush(file);
@@ -144 +149 @@
   fflush(file);
   fclose(file);
+}
+
+/**
+ * Create a new iotype*
+ *
+ * @return a pointer to the allocated iotype 
+ */
+iotype* createIoType(){
+  iotype* io=(iotype*)malloc(IOTYPE_SIZE);
+  io->content=NULL;
+  io->next=NULL;
+  return io;
 }
 
@@ -179 +196 @@
  * Count number of map in a map
  *
- * @param m the maps to count
+ * @param m the map to count
  * @return number of map in a map
  */
 int count(map* m){
   map* tmp=m;
+  int c=0;
+  while(tmp!=NULL){
+    c++;
+    tmp=tmp->next;
+  }
+  return c;
+}
+
+/**
+ * Count number of maps in a maps
+ *
+ * @param m the maps to count
+ * @return number of maps in a maps
+ */
+int maps_length(maps* m){
+  maps* tmp=m;
   int c=0;
   while(tmp!=NULL){
@@ -401 +434 @@
     if(tmp->metadata!=NULL)
       free(tmp->metadata);
+    freeMap(&tmp->additional_parameters);
+    if(tmp->additional_parameters!=NULL)
+      free(tmp->additional_parameters);
     if(tmp->format!=NULL)
       free(tmp->format);
+    freeElements(&tmp->child);
     if(tmp->child!=NULL){
-      freeElements(&tmp->child);
       free(tmp->child);
     }
-    freeIOType(&tmp->defaults);
-    if(tmp->defaults!=NULL)
+    if(tmp->defaults!=NULL){
+      freeIOType(&tmp->defaults);
       free(tmp->defaults);
-    freeIOType(&tmp->supported);
+    }
     if(tmp->supported!=NULL){
+      freeIOType(&tmp->supported);
       free(tmp->supported);
     }
-    freeElements(&tmp->next);
-    if(tmp->next!=NULL)
+    if(tmp->next!=NULL){
+      freeElements(&tmp->next);
       free(tmp->next);
-  }
+    }
+  }
+}
+
+
+/**
+ * Allocate memory for a service.
+ * Require to call free after calling this function.
+ *
+ * @return the service
+ */
+service* createService(){
+  service *s1 = (service *) malloc (SERVICE_SIZE);
+  s1->name=NULL;
+  s1->content=NULL;
+  s1->metadata=NULL;
+  s1->additional_parameters=NULL;
+  s1->inputs=NULL;
+  s1->outputs=NULL;
+  return s1;
 }
 
 /**
  * Free allocated memory of a service.
- * Require to call free on e after calling this function.
+ * Require to be invoked for every createService call.
  *
  * @param s the service to free
@@ -437 +493 @@
     if(tmp->metadata!=NULL)
       free(tmp->metadata);
+    freeMap(&tmp->additional_parameters);
+    if(tmp->additional_parameters!=NULL)
+      free(tmp->additional_parameters);
     freeElements(&tmp->inputs);
     if(tmp->inputs!=NULL)
@@ -454 +513 @@
  */
 void addToMap(map* m,const char* n,const char* v){
-  if (m != NULL) { // knut: add NULL-pointer check
-    if(hasKey(m,n)==false){
-      map* _cursor=m;
-      while(_cursor->next!=NULL){
-        _cursor=_cursor->next;
-      }
-      _cursor->next=createMap(n,v);
-    }
-    else{
-      map *tmp=getMap(m,n);
-      if(tmp->value!=NULL)
-        free(tmp->value);
-      tmp->value=zStrdup(v);
-    }
-  }
+    if (m != NULL) { // knut: add NULL-pointer check
+        if (hasKey(m, n) == false) {
+            map* _cursor = m;
+            while (_cursor->next != NULL) {
+                _cursor = _cursor->next;
+            }
+            _cursor->next = createMap(n, v);
+        }
+        else {
+            map *tmp = getMap(m, n);
+            if (tmp->value != NULL)
+                free(tmp->value);
+            tmp->value = zStrdup(v);
+        }
+    }
 }
 
@@ -506 +565 @@
  */
 map* addToMapWithSize(map* m,const char* n,const char* v,int size){
+  char sin[128];
+  char sname[10]="size";
+  map *tmp;
   if(hasKey(m,n)==false){
     map* _cursor=m;
@@ -514 +576 @@
     }
   }
-  char sname[10]="size";
   if(strlen(n)>5)
     sprintf(sname,"size_%s",n+6);
-  map *tmp=getMap(m,n);
+  tmp=getMap(m,n);
   if(tmp->value!=NULL)
     free(tmp->value);
@@ -524 +585 @@
     memmove(tmp->value,v,size*sizeof(char));
   tmp->value[size]=0;
-  char sin[128];
   sprintf(sin,"%d",size);
   addToMap(m,sname,sin);
@@ -545 +605 @@
     }
     else{
-#ifdef DEBUG
-      fprintf(stderr,"_CURSOR\n");
-      dumpMap(_cursor);
-#endif
-      while(_cursor->next!=NULL)
-        _cursor=_cursor->next;
       map* tmp1=getMap(*mo,tmp->name);
       if(tmp1==NULL){
+        while(_cursor->next!=NULL)
+          _cursor=_cursor->next;
         _cursor->next=createMap(tmp->name,tmp->value);
       }
@@ -561 +617 @@
     _cursor=*mo;
     tmp=tmp->next;
-#ifdef DEBUG
-    fprintf(stderr,"MO\n");
-    dumpMap(*mo);
-#endif
   }
 }
@@ -678 +730 @@
   map* size=getMap(in,"size");
   map *lout=*out;
+  map *tmpVin,*tmpVout;
   if(size!=NULL && pos>0){
     char tmp[11];
@@ -683 +736 @@
     size=getMap(in,tmp);
     sprintf(tmp,"value_%d",pos);
-    map* tmpVin=getMap(in,tmp);
-    map* tmpVout=getMap(lout,tmp);
+    tmpVin=getMap(in,tmp);
+    tmpVout=getMap(lout,tmp);
     free(tmpVout->value);
     tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
@@ -691 +744 @@
   }else{
     if(size!=NULL){
-      map* tmpVin=getMap(in,"value");
-      map* tmpVout=getMap(lout,"value");
+      tmpVin=getMap(in,"value");
+      tmpVout=getMap(lout,"value");
       free(tmpVout->value);
       tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
@@ -712 +765 @@
   map* size=getMap(in,"size");
   map* length=getMap(in,"length");
+  map* toload=getMap(in,"to_load");
+  if(toload!=NULL && strcasecmp(toload->value,"false")==0){
+#ifdef DEBUG
+    fprintf(stderr,"NO LOAD %s %d \n",__FILE__,__LINE__);
+#endif
+    return ;
+  }
   if(length!=NULL){
     int len=atoi(length->value);
@@ -734 +794 @@
   maps* res=NULL;
   if(_cursor!=NULL){
+    map* mc=_cursor->content;
+    maps* mcs=_cursor->child;
     res=createMaps(_cursor->name);
-    map* mc=_cursor->content;
     if(mc!=NULL){
       addMapToMap(&res->content,mc);
       loadMapBinaries(&res->content,mc);
     }
-    maps* mcs=_cursor->child;
     if(mcs!=NULL){
       res->child=dupMaps(&mcs);
@@ -764 +824 @@
     }
     else{
+      maps* tmp1=getMaps(*mo,tmp->name);
       while(_cursor->next!=NULL)
         _cursor=_cursor->next;
-      maps* tmp1=getMaps(*mo,tmp->name);
       if(tmp1==NULL){
         _cursor->next=dupMaps(&tmp);
@@ -797 +857 @@
 map* getMapArray(map* m,const char* key,int index){
   char tmp[1024];
+  map* tmpMap;
   if(index>0)
     sprintf(tmp,"%s_%d",key,index);
@@ -804 +865 @@
   fprintf(stderr,"** KEY %s\n",tmp);
 #endif
-  map* tmpMap=getMap(m,tmp);
+  tmpMap=getMap(m,tmp);
 #ifdef DEBUG
   if(tmpMap!=NULL)
@@ -823 +884 @@
 void setMapArray(map* m,const char* key,int index,const char* value){
   char tmp[1024];
+  map* tmpSize;
   if(index>0){
+    map* len=getMap(m,"length");
     sprintf(tmp,"%s_%d",key,index);
-    map* len=getMap(m,"length");
     if((len!=NULL && atoi(len->value)<index+1) || len==NULL){
       char tmp0[5];
@@ -832 +894 @@
     }
   }
-  else
+  else{
     sprintf(tmp,"%s",key);
-  map* tmpSize=getMapArray(m,"size",index);
+    addToMap(m,"length","1");
+  }
+  tmpSize=getMapArray(m,"size",index);
   if(tmpSize!=NULL && strncasecmp(key,"value",5)==0){
+    map* ptr=getMapOrFill(&m,tmp,(char *)"");
 #ifdef DEBUG
     fprintf(stderr,"%s\n",tmpSize->value);
 #endif
-    map* ptr=getMapOrFill(&m,tmp,(char *)"");
     free(ptr->value);
     ptr->value=(char*)malloc((atoi(tmpSize->value)+1)*sizeof(char));
@@ -846 +910 @@
   else
     addToMap(m,tmp,value);
+}
+
+/**
+ * Add a key and an integer value to an existing map array.
+ *
+ * @param m the map to add the KVP
+ * @param n the key to add
+ * @param index the index of the MapArray 
+ * @param v the corresponding value to add
+ */
+void addIntToMapArray(map* m,const char* n,int index,const int v){
+  char svalue[10];
+  sprintf(svalue,"%d",v);
+  setMapArray(m,n,index,svalue);
 }
 
@@ -881 +959 @@
   maps* tmp=mi;    
   maps* _cursor=getMaps(*mo,tmp->name);
-
-  if(_cursor==NULL)
-    return -1;
-
-  map* tmpLength=getMap(_cursor->content,"length");
   char tmpLen[10];
   int len=1;
-  if(tmpLength!=NULL){
-    len=atoi(tmpLength->value);
-  }
-
   char *tmpV[14]={
     (char*)"size",
@@ -906 +975 @@
     (char*)"isCached",
     (char*)"LowerCorner",
-    (char*)"UpperCorner"    
+    (char*)"UpperCorner"
   };
+  int i=0;
+  map* tmpLength;
+  
+  if(_cursor==NULL)
+    return -1;
+
+  tmpLength=getMap(_cursor->content,"length");
+  if(tmpLength!=NULL){
+    len=atoi(tmpLength->value);
+  }
+
   sprintf(tmpLen,"%d",len+1);
   addToMap(_cursor->content,"length",tmpLen);
-  int i=0;
   for(i=0;i<14;i++){
     map* tmpVI=getMap(tmp->content,tmpV[i]);
@@ -967 +1046 @@
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;  
   res->format=NULL;
   res->defaults=NULL;
@@ -981 +1061 @@
  * @return a pointer to the allocated elements
  */
-elements* createElements(char* name){
+elements* createElements(const char* name){
   elements* res=(elements*)malloc(ELEMENTS_SIZE);
   res->name=zStrdup(name);
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;
   res->format=NULL;
   res->defaults=NULL;
@@ -1020 +1101 @@
   elements* tmp=e;
   while(tmp!=NULL){
+    iotype* tmpio=tmp->defaults;
+    int ioc=0;
     fprintf(stderr,"ELEMENT [%s]\n",tmp->name);
     fprintf(stderr," > CONTENT [%s]\n",tmp->name);
@@ -1025 +1108 @@
     fprintf(stderr," > METADATA [%s]\n",tmp->name);
     dumpMap(tmp->metadata);
+    fprintf(stderr," > ADDITIONAL PARAMETERS [%s]\n",tmp->name);
+    dumpMap(tmp->additional_parameters);
     fprintf(stderr," > FORMAT [%s]\n",tmp->format);
-    iotype* tmpio=tmp->defaults;
-    int ioc=0;
     while(tmpio!=NULL){
       fprintf(stderr," > DEFAULTS [%s] (%i)\n",tmp->name,ioc);
@@ -1060 +1143 @@
   int i;
   while(tmp!=NULL){
+    map* mcurs=tmp->content;
+    int ioc=0;
+    iotype* tmpio;
     for(i=0;i<2+(4*level);i++)
       fprintf(stderr," ");
     fprintf(stderr,"%s:\n",tmp->name);
-    map* mcurs=tmp->content;
     while(mcurs!=NULL){
       for(i=0;i<4+(4*level);i++)
@@ -1091 +1176 @@
         dumpElementsAsYAML(tmp->child,level+1);
     }
-    iotype* tmpio=tmp->defaults;
-    int ioc=0;
+    tmpio=tmp->defaults;
     while(tmpio!=NULL){
       for(i=0;i<6+(4*level);i++)
@@ -1142 +1226 @@
   elements* cursor=e;
   elements* tmp=NULL;
-  if(cursor!=NULL){
+  if(cursor!=NULL && cursor->name!=NULL){
 #ifdef DEBUG
     fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
@@ -1149 +1233 @@
 #endif
     tmp=(elements*)malloc(ELEMENTS_SIZE);
-    tmp->name=zStrdup(e->name);
+    tmp->name=zStrdup(cursor->name);
     tmp->content=NULL;
-    addMapToMap(&tmp->content,e->content);
+    addMapToMap(&tmp->content,cursor->content);
     tmp->metadata=NULL;
-    addMapToMap(&tmp->metadata,e->metadata);
-    if(e->format!=NULL)
-      tmp->format=zStrdup(e->format);
+    addMapToMap(&tmp->metadata,cursor->metadata);
+    tmp->additional_parameters=NULL;
+    addMapToMap(&tmp->additional_parameters,cursor->additional_parameters);
+    if(cursor->format!=NULL)
+      tmp->format=zStrdup(cursor->format);
     else
       tmp->format=NULL;
-    if(e->defaults!=NULL){
+    if(cursor->defaults!=NULL){
       tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
       tmp->defaults->content=NULL;
-      addMapToMap(&tmp->defaults->content,e->defaults->content);
+      addMapToMap(&tmp->defaults->content,cursor->defaults->content);
       tmp->defaults->next=NULL;
 #ifdef DEBUG
@@ -1169 +1255 @@
     }else
       tmp->defaults=NULL;
-    if(e->supported!=NULL){
+    if(cursor->supported!=NULL && cursor->supported->content!=NULL){
+      iotype *tmp2=cursor->supported->next;
       tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
       tmp->supported->content=NULL;
-      addMapToMap(&tmp->supported->content,e->supported->content);
+      addMapToMap(&tmp->supported->content,cursor->supported->content);
       tmp->supported->next=NULL;
-      iotype *tmp2=e->supported->next;
-      while(tmp2!=NULL){
+            while(tmp2!=NULL){
         addMapToIoType(&tmp->supported,tmp2->content);
 #ifdef DEBUG
@@ -1190 +1276 @@
     else
       tmp->child=NULL;
-    tmp->next=dupElements(cursor->next);
+    if(cursor->next!=NULL)
+      tmp->next=dupElements(cursor->next);
+    else
+      tmp->next=NULL;
   }
   return tmp;
@@ -1205 +1294 @@
   elements* tmp=e;
   if(*m==NULL){
-    *m=dupElements(tmp);
+    (*m)=dupElements(tmp);
   }else{
     addToElements(&(*m)->next,tmp);
@@ -1237 +1326 @@
     fprintf(stderr,"CONTENT MAP\n");
     dumpMap(s->content);
-    fprintf(stderr,"CONTENT METADATA\n");
+    if(s->metadata!=NULL)
+      fprintf(stderr,"CONTENT METADATA\n");
     dumpMap(s->metadata);
+    if(s->additional_parameters!=NULL)
+      fprintf(stderr,"CONTENT AdditionalParameters\n");
+    dumpMap(s->additional_parameters);
   }
   if(s->inputs!=NULL){
@@ -1296 +1389 @@
   res->metadata=NULL;
   addMapToMap(&res->metadata,s->metadata);
+  res->additional_parameters=NULL;
+  addMapToMap(&res->additional_parameters,s->additional_parameters);
   res->inputs=dupElements(s->inputs);
   res->outputs=dupElements(s->outputs);
@@ -1309 +1404 @@
   registry* p=r;
   while(p!=NULL){
+    services* s=p->content;
     fprintf(stderr,"%s \n",p->name);
-    services* s=p->content;
     s=p->content;
     while(s!=NULL){
@@ -1509 +1604 @@
  */
 void inheritance(registry *r,service** s){
+  service* ls=*s;
+  map *profile,*level;
   if(r==NULL)
     return;
-  service* ls=*s;
-  if(ls->content==NULL)
+  if(ls==NULL || ls->content==NULL)
     return;
-  map* profile=getMap(ls->content,"extend");
-  map* level=getMap(ls->content,"level");
+  profile=getMap(ls->content,"extend");
+  level=getMap(ls->content,"level");
   if(profile!=NULL&&level!=NULL){
     service* s1;
@@ -1550 +1646 @@
   memset(tmp,0,1024*10*10);
   while(tm!=NULL){
+    map* tc=tm->content;
     if(i>=10)
       break;
@@ -1556 +1653 @@
     strcpy(tmp[i][j],tm->name);
     j++;
-    map* tc=tm->content;
     while(tc!=NULL){
       if(j>=30)
@@ -1609 +1705 @@
  * @return true if map has a value or false if value is missing/empty/NULL
  */
-bool nonempty( map* map ) {
-    return ( map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0 );
-}
-
-/**
- * Verify that a particular map value exists in a maps 
+bool nonempty(map* map) {
+        return (map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0);
+}
+
+/**
+ * Verify that a particular map value exists in a maps
  * data structure, and obtain that value
  *
@@ -1620 +1716 @@
  * @param node name of maps node to search
  * @param key name of map node to find
- * @param address to the map* if it exists, otherwise NULL
+ * @param kvp address to the map* if it exists, otherwise NULL
  * @return true if map has a value or false if value is missing/NULL
- */
-bool hasvalue( maps* source, const char* node, const char* key, map** kvp ) {
-    *kvp = getMapFromMaps(source, node, key);
-    return ( *kvp != NULL && (*kvp)->value != NULL && 
-             strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0 );
+ *
+ * @note The map assigned to kvp is owned by the source maps
+ */
+bool hasvalue(maps* source, const char* node, const char* key, map** kvp) {
+        *kvp = getMapFromMaps(source, node, key);
+        return (*kvp != NULL && (*kvp)->value != NULL &&
+                strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0);
 }
 
@@ -1633 +1731 @@
  *
  * @param conf reference to configuration maps
- * @param service name of service 
+ * @param service name of service
  * @param exc WPSException code
  * @param message exception text (default: exception text in WPS specification)
  */
-void setErrorMessage( maps*& conf, const char* service, WPSException exc, const char* message ) {
-  
-  if (message == NULL) {
-    message = WPSExceptionText[exc];
-  } 
-
-        size_t len = strlen( service ) + strlen(": ") + strlen( message ) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
-        char* msg = (char*) malloc( len * sizeof(char) );
+void setErrorMessage(maps*& conf, const char* service, WPSException exc, const char* message) {
+
+        if (message == NULL) {
+                message = WPSExceptionText[exc];
+        }
+
+        size_t len = strlen(service) + strlen(": ") + strlen(message) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
+        char* msg = (char*)malloc(len * sizeof(char));
 
         if (msg != NULL) {
-                snprintf( msg, len*sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc] );
-                setMapInMaps( conf, "lenv", "message", msg );
-                free( msg );
-        }       
+                snprintf(msg, len * sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc]);
+                setMapInMaps(conf, "lenv", "message", msg);
+                free(msg);
+        }
 }
 
 void logMessage(const char* source, const char* function, int line, const char* file, const char* message) { //, const char* source, const char* function, int line) {
-  
-  size_t msglen = 512;
-  const char empty[] = "";
-  
-  FILE* log;
-  
-  // system time, process time [nanoseconds]   
-  unsigned long long sys_t, proc_t;
-  
-  // processor time consumed by the program:
-  clock_t t = clock();
-    
-  // system time:
-  std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
-  
-  std::time_t now_t = std::chrono::system_clock::to_time_t( now );
-  std::tm* tm = localtime( &now_t );
+
+        size_t msglen = 512;
+        const char empty[] = "";
+
+        FILE* log;
+
+        // system time, process time [nanoseconds]   
+        unsigned long long sys_t, proc_t;
+
+        // processor time consumed by the program:
+        clock_t t = clock();
+
+        // system time:
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+
+        std::time_t now_t = std::chrono::system_clock::to_time_t(now);
+        std::tm* tm = localtime(&now_t);
         char* str = asctime(tm);
-  str[strlen(str)-1] = '\0'; // remove newline
-  
-  sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
-  //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
-  proc_t = t;
-  
-  if ( message != NULL ) {
-     msglen += strlen(message);
-  }  
-  else {
-    message = empty;
-  }
-  //getLastErrorMessage(); // cgiScriptName  
-  char* text = (char*) malloc( sizeof(char)*msglen );
-  
-  snprintf( text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n", 
-    _getpid(), source, line, function, str, sys_t, proc_t, message ); // __FILE__ __LINE__ __func__ //
-  
-  if ( file != NULL && (log = fopen( file, "a+" )) != NULL ) {
-    fputs( text, log );
-    fclose( log );
-  }
-  else {
-    #ifdef MSG_LOG_FILE
-    if ( (log = fopen( MSG_LOG_FILE, "a+" )) != NULL ) {
-      fputs( text, log );
-      fclose( log );
-    }      
-    #endif
-  }
-  
-  if ( text != NULL ) free( text );
+        str[strlen(str) - 1] = '\0'; // remove newline
+
+        sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
+        //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
+        proc_t = t;
+
+        if (message != NULL) {
+                msglen += strlen(message);
+        }
+        else {
+                message = empty;
+        }
+        //getLastErrorMessage(); // cgiScriptName  
+        char* text = (char*)malloc(sizeof(char)*msglen);
+
+        snprintf(text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n",
+                zGetpid(), source, line, function, str, sys_t, proc_t, message); // __FILE__ __LINE__ __func__ //
+
+        if (file != NULL && (log = fopen(file, "a+")) != NULL) {
+                fputs(text, log);
+                fclose(log);
+        }
+        else {
+#ifdef MSG_LOG_FILE
+                if ((log = fopen(MSG_LOG_FILE, "a+")) != NULL) {
+                        fputs(text, log);
+                        fclose(log);
+                }
+#endif
+        }
+
+        if (text != NULL) free(text);
 }
 
@@ -1710 +1808 @@
 // zooLog;
 // zooLogMsg(NULL, getLastErrorMessage()); 
-// zooLogMsg(log.txt, getLastErrorMessage()); 
-
-#ifdef WIN32
-#ifndef USE_MS
-char *strcasestr (char const *a, char const *b)
-  {
-    char *x = zStrdup (a);
-    char *y = zStrdup (b);
- 
-      x = _strlwr (x);
-      y = _strlwr (y);
-    char *pos = strstr (x, y);
-    char *ret = pos == NULL ? NULL : (char *) (a + (pos - x));
-      free (x);
-      free (y);
-      return ret;
-  };
-#else
-   ;
-#endif
-#endif
+// zooLogMsg("log.txt", getLastErrorMessage()); 

trunk/zoo-project/zoo-kernel/service.h

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2009-2015 GeoLabs SARL
+ * Copyright (c) 2009-2019 GeoLabs SARL
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -34 +34 @@
 #endif
 
+ // knut: add bool if necessary
+#ifndef __cplusplus
+#ifndef WIN32
+#include <stdbool.h>
+#else
+typedef int bool;
+#define false 0
+#define true 1  
+#endif
+#endif
+#ifndef __bool_true_false_are_defined
+#define __bool_true_false_are_defined 1
+#endif
+
 #ifdef WIN32
-#ifndef USE_MS
-ZOO_DLL_EXPORT char *strcasestr (char const *,char const *);
-#endif
-#endif
-
-// knut: add bool if necessary
-#ifndef __cplusplus
-  #ifndef WIN32
-    #include <stdbool.h>
-  #else
-    typedef int bool;
-    #define false 0
-    #define true 1      
-  #endif
-#endif
-#ifndef __bool_true_false_are_defined
-  #define __bool_true_false_are_defined 1
-#endif
-
-#ifdef WIN32
+#define strtok_r strtok_s
 #define strncasecmp _strnicmp
 #define strcasecmp _stricmp
-#define strtok_r strtok_s
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
 #endif
-/* knut: see new definition of bool above
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#define false 0
-#define true 1
-#define bool int
-#endif
-*/
 #define zStrdup _strdup
 #define zMkdir _mkdir
+#define zGetpid _getpid
 #define zOpen _open
+#define zClose _close
+#define zUnlink _unlink
+#define zDup _dup
+#define zDup2 _dup2
 #define zWrite _write
 #define zSleep Sleep
@@ -80 +72 @@
 static int zGettimeofday(struct ztimeval* tp, void* tzp)
 {
-  struct _timeb theTime;        
   if (tp == 0) {
     return -1;
   }
   
+  struct _timeb theTime;
   _ftime(&theTime);
   tp->tv_sec = theTime.time;
@@ -92 +84 @@
 }
 
+#define zStatStruct struct _stati64
+#define zStat _stati64
+
 #else
 /**
@@ -106 +101 @@
 #define zOpen open
 /**
+ * The crossplatform close alias
+ */
+#define zClose close
+/**
+ * The crossplatform unlink alias
+ */
+#define zUnlink unlink
+/**
+ * The crossplatform dup alias
+ */
+#define zDup dup
+/**
+ * The crossplatform dup2 alias
+ */
+#define zDup2 dup2
+/**
  * The crossplatform write alias
  */
 #define zWrite write
+#include "unistd.h"
 /**
  * The crossplatform sleep alias
  */
-#define zSleep sleep
+static int zSleep(const long millisecond){
+  return usleep(millisecond*1000);
+}
 /**
  * The crossplatform gettimeofday alias
@@ -121 +135 @@
  */
 #define ztimeval timeval
+/**
+ * The crossplatform getpid alias
+ */
+#define zGetpid getpid
+
+#define zStatStruct struct stat64
+#define zStat stat64
+
 #endif 
 
@@ -140 +162 @@
 #ifndef WIN32
 #include <ctype.h>
-//#include <stdbool.h> // knut: see new definition of bool above
+#include <stdbool.h>
 #endif
 
@@ -167 +189 @@
  * The memory size to create an elements
  */
-#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+(2*sizeof(elements*)))
+#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*3)+sizeof(char*)+((sizeof(map*) + sizeof(iotype*))*2)+(2*sizeof(elements*)))
 /**
  * The memory size to create a map
@@ -187 +209 @@
  */
 //#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
-#define SERVICE_SIZE sizeof(char*) + 2*sizeof(map*) + 2*sizeof(elements*)
+#define SERVICE_SIZE sizeof(char*) + 3*sizeof(map*) + 2*sizeof(elements*)
 /**
  * The memory size to create a services
@@ -221 +243 @@
 #ifdef WIN32
 #define NULLMAP ((map*) 0)
+// knut: see new definition above
+//#define bool int
+//#define true 1
+//#define false 0
 #else
 #define NULLMAP NULL
@@ -256 +282 @@
     struct map* content; //!< the content map
     struct map* metadata; //!< the metadata map
+    struct map* additional_parameters; //!< the additional parameters map
     char* format; //!< the format: LiteralData or ComplexData or BoundingBoxData
     struct iotype* defaults; //!< the default iotype 
@@ -270 +297 @@
     struct map* content; //!< the content map
     struct map* metadata; //!< the metadata map
+    struct map* additional_parameters; //!< the additional parameters map
     struct elements* inputs; //!< the inputs elements
     struct elements* outputs; //!< the outputs elements
@@ -290 +318 @@
     struct registry* next; //!< the next registry pointer
   } registry;
-  
+
   // knut
   enum WPSException {
-    /*
-    * StatusOK is not a WPS exception, it is added
-    * here for convenience.
-    */      
-    StatusOK,                 
-    /*
-    * See WPS 1.0 specification, Table 38 and Table 62.
-    */
-    MissingParameterValue,    
-    InvalidParameterValue,
-    NoApplicableCode,
-    NotEnoughStorage,
-    ServerBusy,
-    FileSizeExceeded,
-    StorageNotSupported,
-    VersionNegotiationFailed,
-    /*
-    * See WPS 2.0 specification, Tables 41, 46, 48, and 50.
-    */
-    NoSuchProcess,
-    NoSuchMode,
-    NoSuchInput,
-    NoSuchOutput,
-    DataNotAccessible,
-    SizeExceeded,
-    TooManyInputs,
-    TooManyOutputs,
-    NoSuchFormat,
-    WrongInputData,
-    InternalServerError,
-    NoSuchJob,
-    ResultNotReady
-  }; 
-  
+          /*
+          * StatusOK is not a WPS exception, it is added
+          * here for convenience.
+          */
+          StatusOK,
+          /*
+          * See WPS 1.0 specification, Table 38 and Table 62.
+          */
+          MissingParameterValue,
+          InvalidParameterValue,
+          NoApplicableCode,
+          NotEnoughStorage,
+          ServerBusy,
+          FileSizeExceeded,
+          StorageNotSupported,
+          VersionNegotiationFailed,
+          /*
+          * See WPS 2.0 specification, Tables 41, 46, 48, and 50.
+          */
+          NoSuchProcess,
+          NoSuchMode,
+          NoSuchInput,
+          NoSuchOutput,
+          DataNotAccessible,
+          SizeExceeded,
+          TooManyInputs,
+          TooManyOutputs,
+          NoSuchFormat,
+          WrongInputData,
+          InternalServerError,
+          NoSuchJob,
+          ResultNotReady
+  };
+
   static const char* const WPSExceptionCode[] = {
-    "StatusOK",
-    "MissingParameterValue", 
-    "InvalidParameterValue",
-    "NoApplicableCode",
-    "NotEnoughStorage",
-    "ServerBusy",
-    "FileSizeExceeded",
-    "StorageNotSupported",
-    "VersionNegotiationFailed",
-    "NoSuchProcess",
-    "NoSuchMode",
-    "NoSuchInput",
-    "NoSuchOutput",
-    "DataNotAccessible",
-    "SizeExceeded",
-    "TooManyInputs",
-    "TooManyOutputs",
-    "NoSuchFormat",
-    "WrongInputData",
-    "InternalServerError",
-    "NoSuchJob",
-    "ResultNotReady"    
-  };      
+        "StatusOK",
+        "MissingParameterValue",
+        "InvalidParameterValue",
+        "NoApplicableCode",
+        "NotEnoughStorage",
+        "ServerBusy",
+        "FileSizeExceeded",
+        "StorageNotSupported",
+        "VersionNegotiationFailed",
+        "NoSuchProcess",
+        "NoSuchMode",
+        "NoSuchInput",
+        "NoSuchOutput",
+        "DataNotAccessible",
+        "SizeExceeded",
+        "TooManyInputs",
+        "TooManyOutputs",
+        "NoSuchFormat",
+        "WrongInputData",
+        "InternalServerError",
+        "NoSuchJob",
+        "ResultNotReady"
+  };
 
   static const char* const WPSExceptionText[] = {
-    "No problem detected",
-    "Operation request does not include a parameter value, and this server did not declare a default value for that parameter.", 
-    "Operation request contains an invalid parameter value.",
-    "No other exceptionCode specified by this service and server applies to this exception.",
-    "The server does not have enough space available to store the inputs and outputs associated with the request.",
-    "The server is too busy to accept and queue the request at this time.",
-    "The file size of one of the input parameters was too large for this process to handle.",
-    "Execute operation request included transmission=”reference” for one of the outputs, but storage is not offered by this server.",
-    "Service version for a ComplexData xlink:href input was not supported by the referenced server, and version negotiation failed.",
-    "One of the identifiers passed does not match with any of the processes offered by this server.",
-    "The process does not permit the desired execution mode.",
-    "One or more of the input identifiers passed does not match with any of the input identifiers of this process.",
-    "One or more of the output identifiers passed does not match with any of the input identifiers of this process.",
-    "One of the referenced input data sets was inaccessible.",
-    "The size of one of the input parameters was too large for this process to handle.",
-    "Too many input items have been specified.",
-    "Too many output items have been specified.",
-    "One or more of the input or output formats specified in the request did not match with any of the formats defined for that particular input or output.",
-    "One or more of inputs for which the service was able to retrieve the data but could not read it.",
-    "",
-    "The JobID from the request does not match any of the Jobs running on this server.",
-    "The result for the requested JobID has not yet been generated."
+        "No problem detected",
+        "Operation request does not include a parameter value, and this server did not declare a default value for that parameter.",
+        "Operation request contains an invalid parameter value.",
+        "No other exceptionCode specified by this service and server applies to this exception.",
+        "The server does not have enough space available to store the inputs and outputs associated with the request.",
+        "The server is too busy to accept and queue the request at this time.",
+        "The file size of one of the input parameters was too large for this process to handle.",
+        "Execute operation request included transmission=”reference” for one of the outputs, but storage is not offered by this server.",
+        "Service version for a ComplexData xlink:href input was not supported by the referenced server, and version negotiation failed.",
+        "One of the identifiers passed does not match with any of the processes offered by this server.",
+        "The process does not permit the desired execution mode.",
+        "One or more of the input identifiers passed does not match with any of the input identifiers of this process.",
+        "One or more of the output identifiers passed does not match with any of the input identifiers of this process.",
+        "One of the referenced input data sets was inaccessible.",
+        "The size of one of the input parameters was too large for this process to handle.",
+        "Too many input items have been specified.",
+        "Too many output items have been specified.",
+        "One or more of the input or output formats specified in the request did not match with any of the formats defined for that particular input or output.",
+        "One or more of inputs for which the service was able to retrieve the data but could not read it.",
+        "",
+        "The JobID from the request does not match any of the Jobs running on this server.",
+        "The result for the requested JobID has not yet been generated."
   };
 
@@ -392 +420 @@
   ZOO_DLL_EXPORT void freeMap(map**);
   ZOO_DLL_EXPORT void freeMaps(maps** mo);
-  
-
+  ZOO_DLL_EXPORT iotype* createIoType();
   ZOO_DLL_EXPORT elements* createEmptyElements();
-  ZOO_DLL_EXPORT elements* createElements(char*);
+  ZOO_DLL_EXPORT elements* createElements(const char*);
   ZOO_DLL_EXPORT void setElementsName(elements**,char*);
   ZOO_DLL_EXPORT bool hasElement(elements*,const char*);
@@ -402 +429 @@
   ZOO_DLL_EXPORT void freeElements(elements**);
   ZOO_DLL_EXPORT void setServiceName(service**,char*);
+  ZOO_DLL_EXPORT service* createService();
   ZOO_DLL_EXPORT void freeService(service**);
   ZOO_DLL_EXPORT void addToMap(map*,const char*,const char*);
   ZOO_DLL_EXPORT void addIntToMap(map*,const char*,const int);
+  ZOO_DLL_EXPORT void addIntToMapArray(map*,const char*,int,const int);
   ZOO_DLL_EXPORT map* addToMapWithSize(map*,const char*,const char*,int);
   ZOO_DLL_EXPORT void addMapToMap(map**,map*);
@@ -446 +475 @@
   ZOO_DLL_EXPORT bool nonempty(map* map);
   ZOO_DLL_EXPORT bool hasvalue(maps* source, const char* node, const char* key, map** kvp);
+#ifdef __cplusplus
   ZOO_DLL_EXPORT void setErrorMessage(maps*& conf, const char* service, WPSException exc, const char* message = NULL);
-  ZOO_DLL_EXPORT void logMessage(const char* source, const char* function, int line, const char* file = NULL, const char* message = NULL);  
+  ZOO_DLL_EXPORT void logMessage(const char* source, const char* function, int line, const char* file = NULL, const char* message = NULL);
+#endif
   #define zooLogMsg(file,message) logMessage(__FILE__, __func__, __LINE__, (file), (message)) 
   #define zooLog logMessage(__FILE__, __func__, __LINE__)  
-  
+
 #ifdef __cplusplus
 }

trunk/zoo-project/zoo-kernel/service_conf.y

@@ -33 +33 @@
 static bool wait_maincontent=true;
 static bool wait_mainmetadata=false;
+static bool wait_mainap=false;
 static bool wait_metadata=false;
+static bool wait_ap=false;
 static bool wait_nested=false;
 static bool wait_inputs=false;
@@ -156 +158 @@
     current_content=NULL;
     my_service->metadata=NULL;
+    my_service->additional_parameters=NULL;
     wait_maincontent=false;
   }
   if(strncasecmp($2,"EndNested",9)==0){
 #ifdef DEBUG_SERVICE_CONF
-      fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
-      fflush(stderr);
-#endif
-      nested_level-=1;
-      if(nested_level==0){
-        wait_nested=false;
-      }
+    fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
+    fflush(stderr);
+#endif
+    nested_level-=1;
+    if(nested_level==0){
+      wait_nested=false;
+    }
   }
 
@@ -229 +232 @@
     }
     else
-      if(strncasecmp($2,"MetaData",8)==0){
-        previous_data=current_data;
-        current_data=3;
-        if(current_element!=NULL){
-#ifdef DEBUG_SERVICE_CONF
-          fprintf(stderr,"add current_content to current_element->content\n");
-          fprintf(stderr,"LINE %d",__LINE__);
-#endif
-          addMapToMap(&current_element->content,current_content);
-          freeMap(&current_content);
-          free(current_content);
-          if(previous_data==1 || previous_data==2)
-            wait_metadata=true;
-          else
-            wait_mainmetadata=true;
-        }
-        else{
-          if(previous_data==1 || previous_data==2)
-            wait_metadata=true;
-          else
-            wait_mainmetadata=true;
+      if(strncasecmp($2,"MetaData",8)==0 ||
+         strncasecmp($2,"AdditionalParameters",8)==0){
+        if(strncasecmp($2,"AdditionalParameters",8)==0){
+          previous_data=current_data;
+          current_data=4;
+          if(current_element!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+            fprintf(stderr,"add current_content to current_element->content\n");
+            fprintf(stderr,"LINE %d",__LINE__);
+#endif
+            if(wait_mainmetadata)
+              addMapToMap(&my_service->metadata,current_content);
+            else
+              if(wait_metadata)
+                addMapToMap(&current_element->metadata,current_content);
+              else
+                addMapToMap(&current_element->content,current_content);         
+            freeMap(&current_content);
+            free(current_content);
+            if(previous_data==1 || previous_data==2)
+              wait_ap=true;
+            else
+              wait_mainap=true;
+          }
+          else{
+            if(previous_data==1 || previous_data==2)
+              wait_ap=true;
+            else
+              wait_mainap=true;
+          }
+        }else{
+          previous_data=current_data;
+          current_data=3;
+          if(current_element!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+            fprintf(stderr,"add current_content to current_element->content\n");
+            fprintf(stderr,"LINE %d",__LINE__);
+#endif
+            addMapToMap(&current_element->content,current_content);
+            freeMap(&current_content);
+            free(current_content);
+            if(previous_data==1 || previous_data==2)
+              wait_metadata=true;
+            else
+              wait_mainmetadata=true;
+          }
+          else{
+            if(previous_data==1 || previous_data==2)
+              wait_metadata=true;
+            else
+              wait_mainmetadata=true;
+          }
         }
         current_content=NULL;
@@ -425 +459 @@
   if(strcmp($3,"DataOutputs")==0){
     current_data=2;
+  }  
+  if(strcmp($3,"AdditionalParameters")==0){
+    if(current_content!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+      fprintf(stderr,"add current_content to current_element->content\n");
+      fprintf(stderr,"LINE %d",__LINE__);
+#endif
+      if(wait_ap){
+        current_element->additional_parameters=NULL;
+        addMapToMap(&current_element->additional_parameters,current_content);
+        current_element->next=NULL;
+        current_element->defaults=NULL;
+        current_element->supported=NULL;
+        current_element->child=NULL;
+      }else{
+        if(wait_mainap){
+          addMapToMap(&my_service->additional_parameters,current_content);
+        }
+      }
+
+      freeMap(&current_content);
+      free(current_content);
+      current_content=NULL;
+    }
+    current_data=previous_data;
+    wait_mainap=false;
+    wait_ap=false;
   }
   if(strcmp($3,"MetaData")==0){
@@ -866 +927 @@
   wait_mainmetadata=false;
   wait_metadata=false;
+  wait_mainap=false;
+  wait_ap=false;
   wait_inputs=false;
   wait_defaults=false;

trunk/zoo-project/zoo-kernel/service_internal.c

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2009-2015 GeoLabs SARL
+ * Copyright (c) 2009-2018 GeoLabs SARL
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -31 +31 @@
 #include "service_internal.h"
 
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE -1
-#endif
-
+#ifdef WIN32
+// ref. https://docs.microsoft.com/en-us/windows/desktop/fileio/locking-and-unlocking-byte-ranges-in-files
+__inline int fcntl(int fd, int cmd, ...)
+{
+  va_list a;
+  va_start(a, cmd);
+  switch(cmd)
+    {
+    case F_SETLK:
+      {
+        HANDLE h = (HANDLE)_get_osfhandle(fd);
+        struct flock* l= va_arg(a, struct flock*);
+        OVERLAPPED sOverlapped;
+        sOverlapped.Offset = 0;
+        sOverlapped.OffsetHigh = 0;
+        switch(l->l_type)
+          {
+          case F_RDLCK:
+            {
+              if (!LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY, 0, l->l_len, 0, &sOverlapped)) 
+                {
+                  _set_errno(GetLastError() == ERROR_LOCK_VIOLATION ? EAGAIN : EBADF);
+                  return -1;
+                }
+            }
+            break;
+          case F_WRLCK:
+            {
+              if (!LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY|LOCKFILE_EXCLUSIVE_LOCK, 0, l->l_len, 0, &sOverlapped))
+                {
+                  _set_errno(GetLastError() == ERROR_LOCK_VIOLATION ? EAGAIN : EBADF);
+                  return -1;
+                }
+            }
+            break;
+          case F_UNLCK:
+            {
+              UnlockFileEx(h, 0, l->l_len, 0, &sOverlapped);
+            }
+            break;
+          default:
+            _set_errno(ENOTSUP);
+            return -1;
+          }
+      }
+      break;
+    default:
+      _set_errno(ENOTSUP);
+      return -1;
+    }
+  return 0;
+}
+#endif
 #define ERROR_MSG_MAX_LENGTH 1024
+
+/**
+ * Lock a file for read, write and upload.
+ * @param conf the main configuration maps
+ * @param filename the file to lock
+ * @param mode define access: 'r' for read, 'w' for write
+ * @return a new zooLock structure on sucess, NULL on failure 
+ */
+struct zooLock* lockFile(maps* conf,const char* filename,const char mode){
+  struct stat f_status;
+  int itn=0;
+  int s;
+  struct zooLock* myLock=(struct zooLock*)malloc(sizeof(struct flock)+sizeof(FILE*)+sizeof(char*));
+  int len=6;
+  char *myTemplate="%s.lock";
+  int res=-1;
+ retryLockFile:
+  myLock->filename=(char*)malloc((strlen(filename)+len)*sizeof(char));
+  sprintf(myLock->filename,myTemplate,filename);
+  s=stat(myLock->filename, &f_status);
+  if(s==0 && mode!='r'){
+    if(itn<ZOO_LOCK_MAX_RETRY){
+      itn++;
+#ifdef DEBUG
+      fprintf(stderr,"(%d) Wait for write lock on %s, tried %d times (sleep) ... \n",zGetpid(),myLock->filename,itn);
+      fflush(stderr);
+#endif
+      zSleep(5);
+      free(myLock->filename);
+      goto retryLockFile;
+    }else{
+      free(myLock->filename);
+      free(myLock);
+      return NULL;
+    }
+  }else{
+    char local_mode[3];
+    memset(local_mode,0,3);
+    if(mode=='w')
+      sprintf(local_mode,"%c+",mode);
+    else
+      sprintf(local_mode,"%c",mode);
+    myLock->lockfile=fopen(myLock->filename,local_mode);
+    char tmp[512];
+    sprintf(tmp,"%d",zGetpid());
+    if(myLock->lockfile==NULL){
+      myLock->lockfile=fopen(myLock->filename,"w+");
+      fwrite(tmp,sizeof(char),strlen(tmp),myLock->lockfile);
+      fflush(myLock->lockfile);
+      fclose(myLock->lockfile);
+      myLock->lockfile=fopen(myLock->filename,local_mode);
+    }/*else
+       fprintf(stderr,"%s %d %d\n",__FILE__,__LINE__,(myLock->lockfile==NULL));*/
+    if(mode!='r'){
+      fwrite(tmp,sizeof(char),strlen(tmp),myLock->lockfile);
+      fflush(myLock->lockfile);
+    }
+    int cnt=0;
+    if(mode=='r'){
+      myLock->lock.l_type = F_RDLCK;
+    }else
+      myLock->lock.l_type = F_WRLCK;
+    myLock->lock.l_whence = 0;
+    myLock->lock.l_start = 0;
+    myLock->lock.l_len = strlen(tmp)*sizeof(char);
+    while (true) {
+      if((res=fcntl(fileno(myLock->lockfile), F_SETLK, &(myLock->lock)))==-1 &&
+         (errno==EAGAIN || errno==EACCES)){
+          if(cnt >= ZOO_LOCK_MAX_RETRY){
+            char message[51];     
+            sprintf(message,"Unable to get the lock after %d attempts.\n",cnt);
+            setMapInMaps(conf,"lenv","message",message);
+            fclose(myLock->lockfile);
+            free(myLock->filename);
+            free(myLock);
+            return NULL;
+          }
+#ifdef DEBUG
+          fprintf(stderr,"(%d) Wait for lock on  %s, tried %d times ... \n",zGetpid(),myLock->filename,cnt);
+          fflush(stderr);
+#endif
+          zSleep(1);
+          cnt++;
+        }else
+           break;
+    }
+    if(res<0){
+      char *tmp;
+      if(errno==EBADF)
+        tmp="Either: the filedes argument is invalid; you requested a read lock but the filedes is not open for read access; or, you requested a write lock but the filedes is not open for write access.";
+      else
+        if(errno==EINVAL)
+          tmp="Either the lockp argument doesn’t specify valid lock information, or the file associated with filedes doesn’t support locks.";
+        else
+          tmp="The system has run out of file lock resources; there are already too many file locks in place.";
+#ifdef DEBUG
+      fprintf(stderr,"Unable to get the lock on %s due to the following error: %s\n",myLock->filename,tmp);
+#endif
+      return NULL;
+    }
+    return myLock;
+  }
+}
+
+/**
+ * Remove a lock.
+ * @param conf the main configuration maps
+ * @param s the zooLock structure
+ * @return 0 on success, -1 on failure.
+ */
+int unlockFile(maps* conf,struct zooLock* s){
+  int res=-1;
+  if(s!=NULL){
+    s->lock.l_type = F_UNLCK;
+    res=fcntl(fileno(s->lockfile), F_SETLK, &s->lock);
+    if(res==-1)
+      return res;
+    fclose(s->lockfile);
+#ifndef WIN32
+    // Check if there is any process locking a file and delete the lock if not.
+    s->lock.l_type = F_WRLCK;
+    if(fcntl(fileno(s->lockfile), F_GETLK, &s->lock)!=-1 && s->lock.l_type == F_UNLCK){
+#endif
+      zUnlink(s->filename);
+#ifndef WIN32
+    }
+#endif
+    free(s->filename);
+    free(s);
+  }
+  return res;
+}
+
 #ifndef RELY_ON_DB
-#include <dirent.h>
+#include "dirent.h"
 
 /**
@@ -148 +327 @@
 
     //FILE* f0 = fopen (fileName, "r");
-        // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
-        FILE* f0 = fopen(fileName, "rb"); 
+    // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
+    FILE* f0 = fopen(fileName, "rb"); 
     if(f0!=NULL){
       fseek (f0, 0, SEEK_END);
@@ -162 +341 @@
         free(stat);
       }
-
       return tmps1;
     }
@@ -250 +428 @@
                      * sizeof (char));
   sprintf (fbkpid, "%s/%s.status", r_inputs->value, usid->value);
-  unlink(fbkpid);
+  zUnlink(fbkpid);
   free(fbkpid);
 }
@@ -510 +688 @@
             }
         }
+        setMapInMaps(conf,"lenv","semaphore","Created");
     } else if (errno == EEXIST) { /* someone else got it first */
         int ready = 0;
@@ -529 +708 @@
               fprintf(stderr,"Retry to access the semaphore later ...\n");
 #endif
-              zSleep(1);
+              zSleep(1000);
             }
         }
@@ -540 +719 @@
           return -1;
         }
+        setMapInMaps(conf,"lenv","semaphore","Acquired");
     } else {
         return sem_id; /* error, check errno */
@@ -739 +919 @@
 }
 
+/**
+ * Check if file exists in specified folder
+ *
+ * @param dir the folder in which to search for file
+ * @param name the name of the file (not full path) 
+ * @return a character string with the full path [dir/name], or NULL if the file does not exist
+ *
+ * @attention Caller is responsible for applying free() to the returned pointer
+ */
+char* file_exists(const char* dir, const char* name) {
+        const char* d = (dir != NULL ? dir : ".");
+        if (name != NULL) {
+                size_t length = strlen(d) + strlen(name) + 2; // including file separator and \0 character
+                char* path = (char*)calloc(length, sizeof(char));
+                snprintf(path, length, "%s/%s", d, name);
+
+                struct stat buffer;
+                if (stat(path, &buffer) != 0) {
+                        free(path);
+                        path = NULL;
+                }
+                return path;
+        }
+        else {
+                return NULL;
+        }
+}

trunk/zoo-project/zoo-kernel/service_internal.h

@@ -63 +63 @@
  * Number of time the ZOO-Kernel will try to acquire lock
  */
-#define ZOO_LOCK_MAX_RETRY 10
+#define ZOO_LOCK_MAX_RETRY 180
 
 #include <sys/stat.h>
 #include <sys/types.h>
-#include "cgic.h"
 #ifndef WIN32
 #include <sys/ipc.h>
@@ -82 +81 @@
 #endif
 #ifndef WIN32
-#include <xlocale.h>
+#include <locale.h>
 #endif
 
+#include <fcntl.h>
+  
 #include "service.h"
 
@@ -94 +95 @@
 #endif
 
+#ifdef WIN32
+// fcntl flock definitions
+#define F_SETLK  8   // Non-Blocking set or clear a lock
+#define F_SETLKW 9   // Blocking set or clear a lock
+#define F_GETLK 10
+#define F_RDLCK  1   // read lock
+#define F_WRLCK  2   // write lock
+#define F_UNLCK  3   // remove lock
+struct flock {
+    short l_type;   // F_RDLCK, F_WRLCK, or F_UNLCK
+    short l_whence; // flag to choose starting offset, must be SEEK_SET
+    long  l_start;  // relative offset, in bytes, must be 0
+    long  l_len;    // length, in bytes; 0 means lock to EOF, must be 0
+    short l_pid;    // unused (returned with the unsupported F_GETLK)
+    short l_xxx;    // reserved for future use
+};
+#endif
+
+/**
+ * The lock structure used by the ZOO-Kernel to ensure atomicity of operations
+ *
+ */ 
+typedef struct zooLock{
+  struct flock lock; //!< The lock
+  FILE* lockfile;    //!< The pointer to the lock file
+  char* filename;    //!< The filename to lock
+} zooLock;
+
+static zooLock** zoo_file_locks=NULL;
+static int zoo_file_locks_cnt=0;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+  
   ZOO_DLL_EXPORT char *readVSIFile(maps*,const char*);
   ZOO_DLL_EXPORT int  setOutputValue( maps*, const char*, char*, size_t);
   ZOO_DLL_EXPORT char* getInputValue( maps*,const char*,size_t*);
+
+  ZOO_DLL_EXPORT struct zooLock* lockFile(maps*,const char*,const char);
+  ZOO_DLL_EXPORT int unlockFile(maps*,struct zooLock*);
 
   ZOO_DLL_EXPORT void unhandleStatus(maps*);
@@ -125 +161 @@
   ZOO_DLL_EXPORT int unlockShm(semid);
 
+  ZOO_DLL_EXPORT char* file_exists(const char* dir, const char* name); 
+
 #ifdef __cplusplus
 }

trunk/zoo-project/zoo-kernel/service_internal_java.c

@@ -208 +208 @@
 #endif
 #ifdef JAVA7
-  cls_gr = (*env)NewGlobalRef(cls);
+  cls_gr = (*env).NewGlobalRef(cls);
 #else
   cls_gr = (*env)->NewGlobalRef(env, cls);
@@ -215 +215 @@
   if (cls != NULL) {
 #ifdef JAVA7
-@    (*env).ExceptionClear();
+    (*env).ExceptionClear();
     pmid=(*env).GetStaticMethodID(cls, s->name, "(Ljava/util/HashMap;Ljava/util/HashMap;Ljava/util/HashMap;)I");
 #else
@@ -284 +284 @@
   }
 #ifdef JAVA7
-      (*jvm).DestroyJavaVM();
+  (*jvm).DestroyJavaVM();
 #else
   (*jvm)->DestroyJavaVM(jvm);
@@ -427 +427 @@
 #endif
       map* sizeV=getMap(tmp1,"size");
+      map* useFile=getMap(tmp1,"use_file");
+      map* cacheFile=getMap(tmp1,"cache_file");
       map* isArray=getMap(tmp1,"isArray");
       map* alen=getMap(tmp1,"length");
@@ -432 +434 @@
         if(strcmp(tmp1->name,"value")==0){
           if(isArray==NULL){
-            if(sizeV!=NULL && strcmp(tmp1->name,"value")==0){
+            if(sizeV!=NULL && strcmp(tmp1->name,"value")==0 && useFile==NULL){
 #ifdef JAVA7
               jbyteArray tmpData=(*env).NewByteArray(atoi(sizeV->value));
               (*env).SetByteArrayRegion(tmpData,0,atoi(sizeV->value),(const jbyte *)tmp1->value);
-              (*env).CallObjectMethod(env,scObject1, put_mid, (*env).NewStringUTF(env,tmp1->name), tmpData);
+              (*env).CallObjectMethod(scObject1, put_mid, (*env).NewStringUTF(tmp1->name), tmpData);
 #else
               jbyteArray tmpData=(*env)->NewByteArray(env,atoi(sizeV->value));
@@ -448 +450 @@
               (*env)->CallObjectMethod(env,scObject1, put_mid, (*env)->NewStringUTF(env,tmp1->name), (*env)->NewStringUTF(env,tmp1->value));
 #endif
+              if(useFile!=NULL)
+#ifdef JAVA7
+                (*env).CallObjectMethod(scObject1, put_mid, (*env).NewStringUTF("cache_file"), (*env).NewStringUTF(cacheFile->value));
+#else
+                (*env)->CallObjectMethod(env,scObject1, put_mid, (*env)->NewStringUTF(env,"cache_file"), (*env)->NewStringUTF(env,cacheFile->value));
+#endif
+              
           }
           else{
@@ -455 +464 @@
             jclass scArrayListClass,scArrayList_class;
             jmethodID scArrayList_constructor;
-            jobject scObject2;
+            jobject scObject2,scObject3;
 #ifdef JAVA7
             scArrayListClass = (*env).FindClass("java/util/ArrayList");
@@ -462 +471 @@
             jmethodID add_mid = 0;
             scObject2 = (*env).NewObject(scArrayList_class, scArrayList_constructor);
+            scObject3 = (*env).NewObject(scArrayList_class, scArrayList_constructor);
 
             add_mid = (*env).GetMethodID(scArrayListClass,
@@ -471 +481 @@
             jmethodID add_mid = 0;
             scObject2 = (*env)->NewObject(env, scArrayList_class, scArrayList_constructor);
+            scObject3 = (*env)->NewObject(env, scArrayList_class, scArrayList_constructor);
 
             add_mid = (*env)->GetMethodID(env,scArrayListClass,
@@ -478 +489 @@
             
             for(i=0;i<alen1;i++){
+              map* cMap=getMapArray(tmp->content,"cache_file",i);
+              map* uMap=getMapArray(tmp->content,"use_file",i);
               map* vMap=getMapArray(tmp->content,"value",i);
               map* sMap=getMapArray(tmp->content,"size",i);
               map* mMap=getMapArray(tmp->content,tmap->value,i);
               
-              if(sMap!=NULL && vMap!=NULL && strncmp(vMap->name,"value",5)==0){
+              if(sMap!=NULL && vMap!=NULL && strncmp(vMap->name,"value",5)==0 && uMap==NULL){
 #ifdef JAVA7
                 jbyteArray tmpData=(*env).NewByteArray(atoi(sMap->value));
@@ -501 +514 @@
 #endif
               }
-              
+
+              if(cMap!=NULL){
+#ifdef JAVA7
+                jobject tmpData=(*env).NewStringUTF(cMap->value);
+                (*env).CallObjectMethod(scObject3, add_mid, tmpData);
+#else
+                jobject tmpData=(*env)->NewStringUTF(env,cMap->value);
+                (*env)->CallObjectMethod(env,scObject3, add_mid, tmpData);
+#endif
+
+              }
             }
 
 #ifdef JAVA7
             (*env).CallObjectMethod(scObject1, put_mid, (*env).NewStringUTF(tmp1->name), scObject2);
+            (*env).CallObjectMethod(scObject1, put_mid, (*env).NewStringUTF("cache_file"), scObject3);
 #else       
             (*env)->CallObjectMethod(env,scObject1, put_mid, (*env)->NewStringUTF(env,tmp1->name), scObject2);
+            (*env)->CallObjectMethod(env,scObject1, put_mid, (*env)->NewStringUTF(env,"cache_file"), scObject3);
 #endif
 

trunk/zoo-project/zoo-kernel/service_internal_js.c

@@ -157 +157 @@
     return 1;
   if (!JS_DefineFunction(cx, global, "alert", JSAlert, 2, 0))
+    return 1;  
+  if (!JS_DefineFunction(cx, global, "sleep", JSSleep, 1, 0))
     return 1;  
   if (!JS_DefineFunction(cx, global, "importScripts", JSLoadScripts, 1, 0))
@@ -901 +903 @@
   char* tmpValue;
   size_t dwRead;
+  maps *tmpConf=createMaps("main");
+  tmpConf->content=createMap("memory","load");
   JS_MaybeGC(cx);
   hInternet=InternetOpen("ZooWPSClient\0",
@@ -929 +933 @@
 #endif
     InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],body,strlen(body),
-                    INTERNET_FLAG_NO_CACHE_WRITE,0);    
+                    INTERNET_FLAG_NO_CACHE_WRITE,0,tmpConf);    
     processDownloads(&hInternet);
     free(body);
@@ -940 +944 @@
         }
         InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],NULL,0,
-                        INTERNET_FLAG_NO_CACHE_WRITE,0);
+                        INTERNET_FLAG_NO_CACHE_WRITE,0,tmpConf);
         processDownloads(&hInternet);
       }else{
         char *body=JSValToChar(cx,&argv[2]);
         InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],body,strlen(body),
-                        INTERNET_FLAG_NO_CACHE_WRITE,0);
+                        INTERNET_FLAG_NO_CACHE_WRITE,0,tmpConf);
         processDownloads(&hInternet);
         free(body);
@@ -951 +955 @@
     }else{
       InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],NULL,0,
-                      INTERNET_FLAG_NO_CACHE_WRITE,0);
+                      INTERNET_FLAG_NO_CACHE_WRITE,0,tmpConf);
       processDownloads(&hInternet);
     }
@@ -972 +976 @@
   if(argc>=2)
     free(method);
+  freeMaps(&tmpConf);
+  free(tmpConf);
   InternetCloseHandle(&hInternet);
   JS_MaybeGC(cx);
@@ -1023 +1029 @@
 }
 
+/**
+ * The function used as sleep from the JavaScript environment
+ * (ZOO-API).
+ *
+ * @param cx the JavaScript context
+ * @param argc the number of parameters
+ * @param argv1 the parameter values
+ * @return true
+ */
+JSBool
+JSSleep(JSContext *cx, uintN argc, jsval *argv1)
+{
+  jsval *argv = JS_ARGV(cx,argv1);
+  JS_MaybeGC(cx);
+  int isleep=0;
+  if(JS_ValueToInt32(cx,argv[0],&isleep)==JS_TRUE){
+    zSleep(isleep);
+  }
+  JS_MaybeGC(cx);
+  return JS_TRUE;
+}
+

trunk/zoo-project/zoo-kernel/service_internal_js.h

@@ -49 +49 @@
   JSBool JSRequest(JSContext*, uintN, jsval*);
   JSBool JSUpdateStatus(JSContext*,uintN,jsval *);
+  JSBool JSSleep(JSContext*,uintN,jsval *);
 
   void reportError(JSContext *cx, const char *message, JSErrorReport *report);

trunk/zoo-project/zoo-kernel/service_internal_mono.c

@@ -30 +30 @@
 #include "response_print.h"
 
+MonoClass *iclasses[4];
+MonoMethod *imethods[10];
+
 /**
  * Load a Mono dll then run the static public method corresponding to the 
@@ -69 +72 @@
     mono_config_parse(NULL);
 
-  MonoDomain* monoDomain = mono_jit_init_version("ZOO_Embedded_Domain",
-                                                 "v4.0.30319");
-
-  map* cwdMap=getMapFromMaps(*main_conf,"main","servicePath");
-  if(cwdMap==NULL)
-    cwdMap=getMapFromMaps(*main_conf,"lenv","cwd");
-  
-  char *zooAssembly=(char*)malloc((strlen(cwdMap->value)+11)*sizeof(char));
-  sprintf(zooAssembly,"%s/ZMaps.dll",cwdMap->value);
-  assembly = mono_domain_assembly_open(monoDomain,zooAssembly);
-  if(assembly==NULL){
-    setMapInMaps(*main_conf,"lenv","message",_("The ZMaps.dll assembly cannot be found!"));
-    return 4;
-  }
-  mono_add_internal_call ("ZOO_API::Translate", MonoTranslate);
-  mono_add_internal_call ("ZOO_API::UpdateStatus", MonoUpdateStatus);
-
+  MonoDomain* monoDomain;
+  map* mono;
+  if (hasvalue(*main_conf, "mono", "version", &mono)) {   
+          monoDomain = mono_jit_init_version("ZOO_Embedded_Domain", mono->value);
+  }
+  else {          
+          monoDomain = mono_jit_init("ZOO_Embedded_Domain"); // use default framework version
+  }
+
+  //MonoDomain* monoDomain = mono_jit_init_version("ZOO_Embedded_Domain", "v4.0.30319"); 
+  //MonoDomain* monoDomain = mono_jit_init("ZOO_Embedded_Domain");  
+
+  char* ZMapsLib = "ZMaps.dll";
+  char *zooAssembly = NULL;
+  
+  map* config = NULL, *basedir = NULL;
+  if (hasvalue(*main_conf, "mono", "configdir", &basedir) && // knut: rename to e.g. "base_dir"?
+          hasvalue(*main_conf, "mono", "configfile", &config)) {          
+          mono_domain_set_config(monoDomain, basedir->value, config->value); 
+          zooAssembly = file_exists(basedir->value, ZMapsLib);
+  }
+  else {          
+          mono_domain_set_config(monoDomain, "./", "");
+  }    
+
+  map* cwdMap;
+  if (! hasvalue(*main_conf, "main", "servicePath", &cwdMap) &&
+          ! hasvalue(*main_conf, "main", "libPath", &cwdMap) ) {
+          cwdMap = getMapFromMaps(*main_conf, "lenv", "cwd");
+  }  
+
+  if (zooAssembly != NULL || (zooAssembly = file_exists(cwdMap->value, ZMapsLib)) != NULL) {
+          assembly = mono_domain_assembly_open(monoDomain, zooAssembly);
+  }
+  else { 
+          // try to load from default locations (GAC?)
+          assembly = mono_domain_assembly_open(monoDomain, ZMapsLib);
+  }  
+  free(zooAssembly);
+
+  if (assembly == NULL) {
+          setMapInMaps(*main_conf, "lenv", "message", _("The ZMaps.dll assembly cannot be found!"));
+          return 4;
+  }
+
+  mono_add_internal_call ("ZOO_API::Translate", MonoTranslate);    
+  mono_add_internal_call("ZOO_API::UpdateStatus", MonoUpdateStatus);
+  
   monoImage = mono_assembly_get_image(assembly);
   MonoClass *KeysList = mono_class_from_name(monoImage, "ZooGenerics", "KeysList");
@@ -104 +138 @@
   MonoClass *classes[3]={_ZMapsClass,ZMapsClass,ZMapClass};
   MonoMethod *methods[5]={ZMapsAdd,_ZMapsSetContent,_ZMapsSetChild,ZMapAdd,ZMapDisplay};
-
+  
   MonoMethod *ZMapsGetKeys = mono_class_get_method_from_name(ZMapsClass, "getKeys", 0);
+  
   MonoMethod *ZMapsGetKeysCount = mono_class_get_method_from_name(ZMapsClass, "getKeysCount", 0);
   MonoMethod *ZMapsGetKey = mono_class_get_method_from_name(ZMapsClass, "getKey", 1);
@@ -116 +151 @@
   MonoClass *oclasses[4]={_ZMapsClass,ZMapsClass,ZMapClass,KeysList};
   MonoMethod *omethods[10]={ZMapsGetMaps,ZMapsGetKeysCount,ZMapsGetKey,ZMapGetMap,ZMapGetKeysCount,ZMapGetKey,_ZMapsGetContent,_ZMapsGetChild,ZMapGetSize,ZMapGetMapAsBytes};
-
+  
   for(int i=0;i<4;i++){
     iclasses[i]=oclasses[i];
@@ -131 +166 @@
 
   MonoObject * out=ZMapsFromMaps(monoDomain,classes,methods,&exc,outputs);
-
+  
   args [0] = main;
   args [1] = in;
   args [2] = out;
 
-  tmp=getMap(s->content,"serviceProvider");
-  char *sName=(char*)malloc((strlen(tmp->value)+strlen(cwdMap->value)+2)*sizeof(char));
-  sprintf(sName,"%s/%s",cwdMap->value,tmp->value);
-  MonoAssembly* serviceAssembly = mono_domain_assembly_open(monoDomain,sName);
+  char* sName = NULL;
+  MonoAssembly* serviceAssembly = NULL;
+  
+  tmp = getMap(s->content, "serviceProvider");  
+  char* test = file_exists(NULL, "log.txt");
+  if ( (sName = file_exists(cwdMap->value, tmp->value)) != NULL ||
+           (sName = file_exists(".", tmp->value)) != NULL ||  // in case servicePath is defined but serviceProvider is in working directory
+           (basedir != NULL && (sName = file_exists(basedir->value, tmp->value)) != NULL) ) {
+
+           serviceAssembly = mono_domain_assembly_open(monoDomain, sName);
+  }
+  else {
+          // try to open from default locations   
+          serviceAssembly = mono_domain_assembly_open(monoDomain, tmp->value);
+  }
+  free(sName);
+
+  //char *sName=(char*)malloc((strlen(tmp->value)+strlen(cwdMap->value)+2)*sizeof(char));
+  //sprintf(sName,"%s/%s",cwdMap->value,tmp->value);
+  //MonoAssembly* serviceAssembly = mono_domain_assembly_open(monoDomain,sName);
+  
   if(serviceAssembly==NULL){
     char *msg=(char*)malloc((strlen(_("Your service assembly: %s cannot be found!"))+strlen(tmp->value)+1)*sizeof(char));
@@ -147 +199 @@
     return 4;
   }
-
+  
   MonoImage* serviceImage = mono_assembly_get_image(serviceAssembly);
 
   map* tmp1=getMap(s->content,"serviceNameSpace");
+  
   tmp=getMap(s->content,"serviceClass");
   MonoClass *serviceClass = mono_class_from_name(serviceImage, tmp1->value, tmp->value);
@@ -160 +213 @@
     return 4;
   }
+  
   MonoMethod *serviceFunction = mono_class_get_method_from_name(serviceClass, s->name, 3);
   if(serviceFunction==NULL){
@@ -168 +222 @@
     return 4;
   }
+  
   MonoObject *exception=NULL;
   MonoObject *result = mono_runtime_invoke(serviceFunction,NULL,args,&exception);
+  
+  if (exception != NULL) { // knut: add exception handling
+          MonoString* pMsg = mono_object_to_string(exception, NULL);      
+          setErrorMessage(*main_conf, s->name, NoApplicableCode, mono_string_to_utf8(pMsg));
+          return 4;
+  }
+
   res=*(int*)mono_object_unbox (result);
+  
   if(res==3){
     freeMaps(&outputs);
     free(outputs);
-    outputs=mapsFromZMaps(monoDomain,oclasses,omethods,args[2]);
+    outputs=mapsFromZMaps(monoDomain,oclasses,omethods,(MonoObject*)args[2]);
     *real_outputs=outputs;
   }
+  
   freeMaps(&m);
   free(m);
-  m=mapsFromZMaps(monoDomain,oclasses,omethods,args[0]);
+  m=mapsFromZMaps(monoDomain,oclasses,omethods,(MonoObject*)args[0]);
   *main_conf=m;
-  mono_jit_cleanup (monoDomain);
+  mono_jit_cleanup (monoDomain);  
   return res;
 }
@@ -288 +352 @@
       values[0]=&i;
       exc=NULL;
-      MonoObject *okey = (MonoString*) mono_runtime_invoke(methods[2],m,values,&exc);
+      MonoString *okey = (MonoString*) mono_runtime_invoke(methods[2],m,values,&exc);
       char* key = mono_string_to_utf8(okey);
       maps* tmp=createMaps(key);
       values[0]=mono_string_new (domain, key);
-      MonoObject *content_ZMaps = (MonoString*) mono_runtime_invoke(methods[0],m,values,&exc);
-      MonoObject *content = mono_runtime_invoke(methods[6],content_ZMaps,NULL,&exc);
+      MonoString *content_ZMaps = (MonoString*) mono_runtime_invoke(methods[0],m,values,&exc);
+      MonoObject *content = mono_runtime_invoke(methods[6],(MonoObject*)content_ZMaps,NULL,&exc);
       tmp->content=mapFromZMap(domain,classes,methods,content);
       MonoObject *childs = mono_runtime_invoke(methods[7],content_ZMaps,NULL,&exc);
@@ -329 +393 @@
       values[0]=&i;
       exc=NULL;
-      MonoObject *okey = (MonoString*) mono_runtime_invoke(methods[5],m,values,&exc);
+      MonoString *okey = (MonoString*) mono_runtime_invoke(methods[5],m,values,&exc);
       char* key = mono_string_to_utf8(okey);
       values[0]=mono_string_new (domain, key);
       exc=NULL;
-      MonoObject *ovalue = (MonoString*) mono_runtime_invoke(methods[3],m,values,&exc);
+      MonoString *ovalue = (MonoString*) mono_runtime_invoke(methods[3],m,values,&exc);
       char* value = mono_string_to_utf8(ovalue);
       if(res==NULL)
@@ -350 +414 @@
  */
 static MonoString* MonoTranslate(MonoString *str){
-  return mono_string_new (mono_domain_get(), mono_string_to_utf8(_(str)));
+  return mono_string_new (mono_domain_get(), _(mono_string_to_utf8(str)));
 }
 
@@ -360 +424 @@
  * @return the translated string
  */
-static void MonoUpdateStatus(MonoObject* obj,MonoString *str,int* p){
-  MonoDomain* domain = mono_object_get_domain (obj);
-  maps *confMaps=mapsFromZMaps(domain,iclasses,imethods,obj);
-  setMapInMaps(confMaps,"lenv","message",mono_string_to_utf8(str));
-  int tmp=p;
-  if (p < 0 || p > 100){
-    tmp=-1;
-  }
-  char tmpStatus[5];
-  snprintf(tmpStatus, 4, "%d", tmp);
-  setMapInMaps(confMaps,"lenv","status",(char*)tmpStatus);
-  _updateStatus(confMaps);
-  freeMaps(&confMaps);
-  free(confMaps);
-  return;
-}
+static void MonoUpdateStatus(MonoObject* obj, MonoString *str, int p) { 
+        MonoDomain* domain = mono_object_get_domain(obj);       
+        maps *confMaps = mapsFromZMaps(domain, iclasses, imethods, obj);        
+        setMapInMaps(confMaps, "lenv", "message", mono_string_to_utf8(str));    
+        int tmp = p > 100 || p < 0 ? -1 : p;    
+        char tmpStatus[5];
+        snprintf(tmpStatus, 4, "%d", tmp);      
+        setMapInMaps(confMaps, "lenv", "status", (char*)tmpStatus);     
+        _updateStatus(confMaps);        
+        freeMaps(&confMaps);    
+        free(confMaps);
+        return;
+}

trunk/zoo-project/zoo-kernel/service_internal_mono.h

@@ -45 +45 @@
   map* mapFromZMap(MonoDomain*,MonoClass**,MonoMethod**,MonoObject*);
   static MonoString* MonoTranslate(MonoString*);
-  static void MonoUpdateStatus(MonoObject*,MonoString*,int*);
-  MonoClass *iclasses[4];
-  MonoMethod *imethods[10];
+  //static void MonoUpdateStatus(MonoObject*,MonoString*,int*);
+  static void MonoUpdateStatus(MonoObject*, MonoString*, int);
+  //MonoClass *iclasses[4]; // knut: move declarations to service_internal_mono.c
+  //MonoMethod *imethods[10];
 
 #ifdef __cplusplus

trunk/zoo-project/zoo-kernel/service_internal_ms.c

@@ -34 +34 @@
 #include "server_internal.h"
 #include "response_print.h"
+#include "caching.h"
 
 /**
@@ -76 +77 @@
 
 /**
+ * Return the current publish_id value
+ * @param elem and maps pointer on which the search occur
+ * @return the integer value of the publish_id field, if any, 0 otherwise
+ */ 
+int getPublishedId(maps* elem){
+  if(elem!=NULL && elem->content!=NULL){
+    map* myIndex=getMap(elem->content,"published_id");
+    if(myIndex!=NULL){
+      return atoi(myIndex->value);
+    }
+  }
+  return 0;
+}
+
+/**
  * Add width and height keys to an output maps containing the maximum width
  * and height for displaying the full data extent.
@@ -87 +103 @@
  */
 void setMapSize(maps* output,double minx,double miny,double maxx,double maxy){
+  int imyIndex=getPublishedId(output);
   double maxWidth=640;
   double maxHeight=480;
@@ -118 +135 @@
 #endif
   if(output!=NULL){
-    addToMap(output->content,"width",sWidth);
-    addToMap(output->content,"height",sHeight);
+    setMapArray(output->content,"width",imyIndex,sWidth);
+    setMapArray(output->content,"height",imyIndex,sHeight);
   }
 }
@@ -131 +148 @@
  */
 void setReferenceUrl(maps* m,maps* tmpI){
+  int imyIndex=getPublishedId(tmpI);
+  if(getMapArray(tmpI->content,"ref_wms_link",imyIndex)!=NULL)
+    return;
   outputMapfile(m,tmpI);
   map *msUrl=getMapFromMaps(m,"main","mapserverAddress");
@@ -138 +158 @@
     exit(-1);
   }
+  if(getMapArray(tmpI->content,"ref_wms_link",imyIndex)!=NULL)
+    return;
+  int finalProto=-1;
   map *msOgcVersion=getMapFromMaps(m,"main","msOgcVersion");
   map *dataPath=getMapFromMaps(m,"main","dataPath");
   map *sid=getMapFromMaps(m,"lenv","usid");
-  map* format=getMap(tmpI->content,"mimeType");
-  map* rformat=getMap(tmpI->content,"requestedMimeType");
-  map* width=getMap(tmpI->content,"width");
-  map* height=getMap(tmpI->content,"height");
-  map* protoMap=getMap(tmpI->content,"msOgc");
-  map* versionMap=getMap(tmpI->content,"msOgcVersion");
-  char options[3][5][25]={
+  map* format=getMapArray(tmpI->content,"mimeType",imyIndex);
+  map* rformat=getMapArray(tmpI->content,"requestedMimeType",imyIndex);
+  map* width=getMapArray(tmpI->content,"width",imyIndex);
+  map* height=getMapArray(tmpI->content,"height",imyIndex);
+  map* protoMap=getMapArray(tmpI->content,"msOgc",imyIndex);
+  map* versionMap=getMapArray(tmpI->content,"msOgcVersion",imyIndex);
+  map* datatype=getMapArray(tmpI->content,"geodatatype",imyIndex);
+  map* layerName=getMapArray(tmpI->content,"msLayer",imyIndex);
+  char options[4][5][25]={
     {"WMS","1.3.0","GetMap","layers=%s","wms_extent"},
-    {"WFS","1.1.0","GetFeature","typename=%s","wcs_extent"},
-    {"WCS","1.1.0","GetCoverage","coverage=%s","wcs_extent"}
+    {"WFS","1.0.0","GetFeature","typename=%s","wcs_extent"},
+    {"WCS","2.0.0","GetCoverage","coverageid=%s","wcs_extent"},
+    {"WCS","1.0.0","GetCoverage","coverage=%s","wcs_extent"}
   };
+  map *nbElements=getMapArray(tmpI->content,"nb_features",imyIndex);
+  if(nbElements==NULL)
+    nbElements=getMapArray(tmpI->content,"nb_pixels",imyIndex);
+  if(datatype==NULL || strncmp(datatype->value,"other",5)==0 || (nbElements!=NULL && atoi(nbElements->value)==0)){
+    map* minNb=getMap(tmpI->content,"minoccurs");
+    map* useMs=getMap(tmpI->content,"useMapserver");
+    if((minNb==NULL || atoi(minNb->value)>=1) && useMs!=NULL && strncasecmp(useMs->value,"true",4)==0){
+      int lIndex=0;
+      maps* lenv=getMaps(m,"lenv");
+      if(getMapFromMaps(m,"lenv","mapErrorNb")==NULL)
+        setMapInMaps(m,"lenv","mapErrorNb","0");
+      else{
+        map* tmpV=getMapFromMaps(m,"lenv","mapErrorNb");
+        lIndex=atoi(tmpV->value)+1;
+        addIntToMap(lenv->content,"mapErrorNb",lIndex);
+      }
+      setMapInMaps(m,"lenv","mapError","true");
+      setMapArray(lenv->content,"locator",lIndex,tmpI->name);
+      if(nbElements==NULL)
+        setMapArray(lenv->content,"message",lIndex,_("The ZOO-Kernel was able to retrieve the data but could not read it as geographic data."));
+      else
+        setMapArray(lenv->content,"message",lIndex,_("The ZOO-Kernel was able to retrieve the data but could not access any feature or pixel in te resulting file."));
+      if(getMapFromMaps(m,"lenv","state")==NULL)
+        errorException (m, _("Unable to find any geographic data"), "WrongInputData", tmpI->name);
+    }
+    return;
+  }
   int proto=0;
   if(rformat==NULL){
-    rformat=getMap(tmpI->content,"mimeType");
+    rformat=getMapArray(tmpI->content,"mimeType",imyIndex);
   }
   if(strncasecmp(rformat->value,"text/xml",8)==0)
     proto=1;
-  if(strncasecmp(rformat->value,"image/tiff",10)==0)
+  if(strncasecmp(rformat->value,"image/tiff",10)==0 ||
+     strncasecmp(rformat->value,"image/geotiff",10)==0)
     proto=2;
+  int hasFormat=-1;
   if(protoMap!=NULL){
-    if(strncasecmp(protoMap->value,"WMS",3)==0)
+    hasFormat=1;
+    if(strncasecmp(protoMap->value,"WMS",3)==0){
       proto=0;
+      rformat=createMap("value","image/png");
+    }
     else{
-      if(strncasecmp(protoMap->value,"WFS",3)==0)
+      if(strncasecmp(protoMap->value,"WFS",3)==0){
         proto=1;
-      else 
+        rformat=createMap("value","text/xml");
+      }
+      else {
         proto=2;
+        rformat=createMap("value","image/tiff");
+      }
     }
   }
@@ -178 +240 @@
   }
 
-  map* extent=getMap(tmpI->content,options[proto][4]);
-  map* crs=getMap(tmpI->content,"crs");
+
+  map* extent=getMapArray(tmpI->content,options[proto][4],imyIndex);
+  map* crs=getMapArray(tmpI->content,"crs",imyIndex);
   int hasCRS=1;
   if(crs==NULL){
@@ -189 +252 @@
   }
   char layers[128];
-  sprintf(layers,options[proto][3],tmpI->name);
-
-  char* webService_url=(char*)malloc((strlen(msUrl->value)+strlen(format->value)+strlen(tmpI->name)+strlen(width->value)+strlen(height->value)+strlen(extent->value)+256)*sizeof(char));
+  if(layerName==NULL)
+    sprintf(layers,options[proto][3],tmpI->name);
+  else
+    sprintf(layers,options[proto][3],layerName->value);
+
+  if(format==NULL || width==NULL || height==NULL || extent==NULL){
+    char tmpStr[1024];
+    sprintf(tmpStr,_("Unable to create the mapfile for %s because of missing values."),tmpI->name);
+    errorException (m, tmpStr,
+                    "InternalError", NULL);
+    exit(-1);
+    return;
+  }
+
+  if(proto==0){
+    hasFormat=1;
+    rformat=createMap("mimeType","image/png");
+  }else{
+    if(proto==1){
+      rformat=createMap("mimeType","text/xml");
+      hasFormat=1;
+    }
+    else
+      if(proto==2){
+        rformat=createMap("mimeType","image/tiff");
+        hasFormat=1;
+        finalProto=1;
+      }
+  }
+  
+  char* webService_url=(char*)malloc((strlen(msUrl->value)+strlen(rformat->value)+strlen(tmpI->name)+strlen(width->value)+strlen(height->value)+strlen(extent->value)+256)*sizeof(char));
+
 
   if(proto>0){
+    if(proto==2)
+      finalProto=1;
     sprintf(webService_url,
-            "%s?map=%s/%s_%s.map&request=%s&service=%s&version=%s&%s&format=%s&bbox=%s&crs=%s",
+            "%s?map=%s/%s_%d_%s.map&request=%s&service=%s&version=%s&%s&format=%s&bbox=%s&crs=%s",
             msUrl->value,
             dataPath->value,
             tmpI->name,
+            imyIndex,
             sid->value,
             options[proto][2],
@@ -208 +303 @@
             crs->value
             );
+    if(datatype!=NULL && strncasecmp(datatype->value,"raster",6)==0){
+      setMapArray(tmpI->content,"ref_wcs_link",imyIndex,webService_url);
+    }
+    else{
+      setMapArray(tmpI->content,"ref_wfs_link",imyIndex,webService_url);
+    }
+    proto=0;
+    freeMap(&rformat);
+    free(rformat);
+    rformat=createMap("mimeType","image/png");
   }
   else{
     sprintf(webService_url,
-            "%s?map=%s/%s_%s.map&request=%s&service=%s&version=%s&%s&width=%s&height=%s&format=%s&bbox=%s&crs=%s",
+            "%s?map=%s/%s_%d_%s.map&request=%s&service=%s&version=%s&%s&width=%s&height=%s&format=%s&bbox=%s&crs=%s",
             msUrl->value,
             dataPath->value,
             tmpI->name,
+            imyIndex,
             sid->value,
             options[proto][2],
@@ -226 +332 @@
             crs->value
             );
+    setMapArray(tmpI->content,"ref_wms_link",imyIndex,webService_url);
+    if(datatype!=NULL && strncasecmp(datatype->value,"raster",6)==0){
+      proto=2;
+      freeMap(&rformat);
+      free(rformat);
+      rformat=createMap("mimeType","image/tiff");
+    }
+    else{
+      proto=1;
+      freeMap(&rformat);
+      free(rformat);
+      rformat=createMap("mimeType","text/xml");
+    }
+  }
+  setMapArray(tmpI->content,"Reference",imyIndex,webService_url);
+  memset(layers,0,128);
+  sprintf(layers,options[proto][3],tmpI->name);
+  protoVersion=options[proto][1];
+  extent=getMapArray(tmpI->content,options[proto][4],imyIndex);
+  memset(webService_url,0,strlen(webService_url));
+  if(proto>0){
+    if(proto==2)
+      finalProto=1;
+    sprintf(webService_url,
+            "%s?map=%s/%s_%d_%s.map&request=%s&service=%s&version=%s&%s&format=%s&bbox=%s&crs=%s",
+            msUrl->value,
+            dataPath->value,
+            tmpI->name,
+            imyIndex,
+            sid->value,
+            options[proto][2],
+            options[proto][0],
+            protoVersion,
+            layers,
+            rformat->value,
+            extent->value,
+            crs->value
+            );
+    if(datatype!=NULL && strncasecmp(datatype->value,"raster",6)==0){
+      setMapArray(tmpI->content,"ref_wcs_link",imyIndex,webService_url);
+    }
+    else{
+      setMapArray(tmpI->content,"ref_wfs_link",imyIndex,webService_url);
+    }
+  }else{
+    sprintf(webService_url,
+            "%s?map=%s/%s_%d_%s.map&request=%s&service=%s&version=%s&%s&width=%s&height=%s&format=%s&bbox=%s&crs=%s",
+            msUrl->value,
+            dataPath->value,
+            tmpI->name,
+            imyIndex,
+            sid->value,
+            options[proto][2],
+            options[proto][0],
+            protoVersion,
+            layers,
+            width->value,
+            height->value,
+            rformat->value,
+            extent->value,
+            crs->value
+            );
+    setMapArray(tmpI->content,"ref_wms_link",imyIndex,webService_url);
+  }
+  if(finalProto>0){
+    proto=3;
+    memset(layers,0,128);
+    sprintf(layers,options[proto][3],tmpI->name);
+    protoVersion=options[proto][1];
+    extent=getMapArray(tmpI->content,options[proto][4],imyIndex);
+    memset(webService_url,0,strlen(webService_url));
+     freeMap(&rformat);
+    free(rformat);
+    rformat=createMap("value","image/tiff");
+    sprintf(webService_url,
+            "%s?map=%s/%s_%d_%s.map&request=%s&service=%s&version=%s&%s&format=%s&bbox=%s&crs=%s",
+            msUrl->value,
+            dataPath->value,
+            tmpI->name,
+            imyIndex,
+            sid->value,
+            options[proto][2],
+            options[proto][0],
+            protoVersion,
+            layers,
+            rformat->value,
+            extent->value,
+            crs->value
+            );
+    setMapArray(tmpI->content,"ref_wcs_preview_link",imyIndex,webService_url);
   }
   if(hasCRS==0){
@@ -231 +427 @@
     free(crs);
   }
-  addToMap(tmpI->content,"Reference",webService_url);
+  freeMap(&rformat);
+  free(rformat);
   free(webService_url);
 }
@@ -249 +446 @@
   OGRSpatialReferenceH  hSRS;
   map* msSrs=NULL;
+  int imyIndex=getPublishedId(output);
   hSRS = OSRNewSpatialReference(NULL);
   if( pszProjection!=NULL && strlen(pszProjection)>1){
@@ -272 +470 @@
         if(output!=NULL){
           if(OSRIsGeographic(hSRS)==TRUE)
-            addToMap(output->content,"crs_isGeographic","true");
+            setMapArray(output->content,"crs_isGeographic",imyIndex,"true");
           else
-            addToMap(output->content,"crs_isGeographic","false");
-          addToMap(output->content,"crs",tmpSrs);
+            setMapArray(output->content,"crs_isGeographic",imyIndex,"false");
+          setMapArray(output->content,"crs",imyIndex,tmpSrs);
         }
       }
@@ -288 +486 @@
           if(output!=NULL){ 
             if(OSRIsGeographic(hSRS)==TRUE)
-              addToMap(output->content,"crs_isGeographic","true");
+              setMapArray(output->content,"crs_isGeographic",imyIndex,"true");
             else
-              addToMap(output->content,"crs_isGeographic","false");
+              setMapArray(output->content,"crs_isGeographic",imyIndex,"false");
           }
           free(proj4Str);
@@ -298 +496 @@
           msLoadProjectionStringEPSG(&myLayer->projection,"EPSG:4326");
           if(output!=NULL){
-            addToMap(output->content,"crs_isGeographic","true");
+            setMapArray(output->content,"crs_isGeographic",imyIndex,"true");
           }
         }
         if(output!=NULL){
-          addToMap(output->content,"crs","EPSG:4326");
-          addToMap(output->content,"real_extent","true");
+          setMapArray(output->content,"crs",imyIndex,"EPSG:4326");
+          setMapArray(output->content,"real_extent",imyIndex,"true");
         }
         msInsertHashTable(&(m->web.metadata),"ows_srs", "EPSG:4326 EPSG:900913 EPSG:3857");
@@ -312 +510 @@
   else{
     if(output!=NULL){
-      msSrs=getMap(output->content,"msSrs");
+      msSrs=getMapArray(output->content,"msSrs",imyIndex);
     }
     if(msSrs!=NULL){
@@ -328 +526 @@
     }
     if(output!=NULL){
-      addToMap(output->content,"crs",msSrs->value);
-      addToMap(output->content,"crs_isGeographic","true");
+      setMapArray(output->content,"crs",imyIndex,msSrs->value);
+      setMapArray(output->content,"crs_isGeographic",imyIndex,"true");
     }
   }
@@ -351 +549 @@
 void setMsExtent(maps* output,mapObj* m,layerObj* myLayer,
                  double minX,double minY,double maxX,double maxY){
+  int imyIndex=getPublishedId(output);
   msMapSetExtent(m,minX,minY,maxX,maxY);
+  //m->maxsize=4096;
 #ifdef DEBUGMS
   fprintf(stderr,"Extent %.15f %.15f %.15f %.15f\n",minX,minY,maxX,maxY);
@@ -363 +563 @@
   
   if(output!=NULL){
-    map* test=getMap(output->content,"real_extent");
+    map* test=getMapArray(output->content,"real_extent",imyIndex);
+    pointObj min, max;
+    projectionObj tempSrs;
+    min.x = m->extent.minx;
+    min.y = m->extent.miny;
+    max.x = m->extent.maxx;
+    max.y = m->extent.maxy;
+    char tmpSrsStr[1024];
+    msInitProjection(&tempSrs);
+    msLoadProjectionStringEPSG(&tempSrs,"EPSG:4326");
+
+    msProjectPoint(&(myLayer->projection),&tempSrs,&min);
+    msProjectPoint(&myLayer->projection,&tempSrs,&max);
+  
     if(test!=NULL){
-      pointObj min, max;
-      projectionObj tempSrs;
-      min.x = m->extent.minx;
-      min.y = m->extent.miny;
-      max.x = m->extent.maxx;
-      max.y = m->extent.maxy;
-      char tmpSrsStr[1024];
-      msInitProjection(&tempSrs);
-      msLoadProjectionStringEPSG(&tempSrs,"EPSG:4326");
-
-      msProjectPoint(&(m->projection),&tempSrs,&min);
-      msProjectPoint(&m->projection,&tempSrs,&max);
-      
-      sprintf(tmpExtent,"%.3f,%.3f,%.3f,%.3f",min.y,min.x,max.y,max.x);
-      map* isGeo=getMap(output->content,"crs_isGeographic");
+      sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",min.y,min.x,max.y,max.x);
+      map* isGeo=getMapArray(output->content,"crs_isGeographic",imyIndex);
 #ifdef DEBUGMS
       fprintf(stderr,"isGeo = %s\n",isGeo->value);
 #endif
-      if(isGeo!=NULL && strcasecmp("true",isGeo->value)==0)
-        sprintf(tmpExtent,"%f,%f,%f,%f", minY,minX, maxY, maxX);
-      addToMap(output->content,"wms_extent",tmpExtent);
-      sprintf(tmpSrsStr,"%.3f,%.3f,%.3f,%.3f",min.x,min.y,max.x,max.y);
-      addToMap(output->content,"wcs_extent",tmpExtent);
+      if(isGeo!=NULL && strcasecmp("true",isGeo->value)==0){
+        sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",min.y,min.x,max.y,max.x);
+        setMapArray(output->content,"wgs84_extent",imyIndex,tmpExtent);
+        sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f", minY,minX, maxY, maxX);
+      }else{
+        sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",min.x,min.y,max.x,max.y);
+        setMapArray(output->content,"wgs84_extent",imyIndex,tmpExtent);
+      }
+      setMapArray(output->content,"wms_extent",imyIndex,tmpExtent);
+      sprintf(tmpSrsStr,"%.15f,%.15f,%.15f,%.15f",min.x,min.y,max.x,max.y);
+      setMapArray(output->content,"wcs_extent",imyIndex,tmpExtent);
     }else{
-      sprintf(tmpExtent,"%f,%f,%f,%f",minX, minY, maxX, maxY);
-      map* isGeo=getMap(output->content,"crs_isGeographic");
+      sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",min.x,min.y,max.x,max.y);
+      setMapArray(output->content,"wgs84_extent",imyIndex,tmpExtent);
+      sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",minX, minY, maxX, maxY);
+      map* isGeo=getMapArray(output->content,"crs_isGeographic",imyIndex);
       if(isGeo!=NULL){
 #ifdef DEBUGMS
@@ -396 +604 @@
 #endif
         if(isGeo!=NULL && strcasecmp("true",isGeo->value)==0)
-          sprintf(tmpExtent,"%f,%f,%f,%f", minY,minX, maxY, maxX);
-      }
-      addToMap(output->content,"wms_extent",tmpExtent); 
-      sprintf(tmpExtent,"%.3f,%.3f,%.3f,%.3f",minX,minY,maxX,maxY);
-      addToMap(output->content,"wcs_extent",tmpExtent);
+          sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f", minY,minX, maxY, maxX);
+      }
+      setMapArray(output->content,"wms_extent",imyIndex,tmpExtent); 
+      sprintf(tmpExtent,"%.15f,%.15f,%.15f,%.15f",minX,minY,maxX,maxY);
+      setMapArray(output->content,"wcs_extent",imyIndex,tmpExtent);
     }
   }
@@ -415 +623 @@
  */
 int tryOgr(maps* conf,maps* output,mapObj* m){
-
-  map* tmpMap=getMap(output->content,"storage");
+  int imyIndex=getPublishedId(output);
+  map* tmpMap=getMapArray(output->content,"storage",imyIndex);
   char *pszDataSource=tmpMap->value;
 
@@ -425 +633 @@
   /**
    * Try to load the file as ZIP
-   */
-
+   *
   OGRDataSourceH poDS1 = NULL;
   OGRSFDriverH *poDriver1 = NULL;
@@ -467 +674 @@
     fprintf(stderr,"Unable to access the DataSource as ZIP File\n");
     setMapInMaps(conf,"lenv","message","Unable to open datasource in read only mode");
-    OGR_DS_Destroy(poDS1);
+    fprintf(stderr,"Remove ZIP File!\n");
+    unlink(odsName);
+    //OGR_DS_Destroy(poDS1);
   }else{
 #ifdef DEBUGMS
@@ -526 +735 @@
       i++;
     }
-  }
+    OGR_DS_Destroy(poDS1);
+    }
   free(sdsName);
-  free(dsName);
-
+  free(dsName);*/
+  
   OGRDataSourceH poDS = NULL;
   OGRSFDriverH *poDriver = NULL;
@@ -538 +748 @@
 #endif
     setMapInMaps(conf,"lenv","message","Unable to open datasource in read only mode");
-    OGR_DS_Destroy(poDS);
-    OGRCleanupAll();
 #ifdef DEBUGMS
     fprintf(stderr,"Unable to access the DataSource, exit! \n"); 
@@ -546 +754 @@
   }
 
+  setMapArray(output->content,"gdalType",imyIndex,OGR_Dr_GetName(OGR_DS_GetDriver(poDS)));  
+  setMapArray(output->content,"geodatatype",imyIndex,"vector");
   int iLayer = 0;
   for( iLayer=0; iLayer < OGR_DS_GetLayerCount(poDS); iLayer++ ){
@@ -561 +771 @@
      * Add a new layer set name, data
      */
-    if(msGrowMapLayers(m)==NULL){
-      return -1;
-    }
-    if(initLayer((m->layers[m->numlayers]), m) == -1){
-      return -1;
-    }
-
-    layerObj* myLayer=m->layers[m->numlayers];
+    layerObj* myLayer=NULL;
+    if(getMapArray(output->content,"msInclude",imyIndex)==NULL){
+      if(msGrowMapLayers(m)==NULL){
+        return -1;
+      }
+      if(initLayer((m->layers[m->numlayers]), m) == -1){
+        return -1;
+      }
+      myLayer=m->layers[m->numlayers];
+    }else{
+      myLayer=m->layers[m->numlayers-1];
+    }
+    
 #ifdef DEBUGMS
     dumpMaps(output);
@@ -580 +795 @@
     myLayer->status = MS_ON;
     msConnectLayer(myLayer,MS_OGR,pszDataSource);
+
+    addIntToMapArray(output->content,"nb_features",imyIndex,OGR_L_GetFeatureCount(poLayer,1));
 
     /**
@@ -631 +848 @@
     }
     else{
-      addToMap(output->content,"crs","EPSG:4326");
-      addToMap(output->content,"crs_isGeographic","true");
+      setMapArray(output->content,"crs",imyIndex,"EPSG:4326");
+      setMapArray(output->content,"crs_isGeographic",imyIndex,"true");
       msLoadProjectionStringEPSG(&m->projection,"EPSG:4326");
       msInsertHashTable(&(m->web.metadata), "ows_srs", "EPSG:4326 EPSG:900913 EPSG:3857");
@@ -641 +858 @@
     if (OGR_L_GetExtent(poLayer,&oExt, TRUE) == OGRERR_NONE){
       setMsExtent(output,m,myLayer,oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
+      char extent[1024];
+      memset(&extent,0,1024);
+      sprintf(extent,"%d,%d,%d,%d",oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
+      setMapArray(output->content,"boundingbox",imyIndex,extent);
     }
   
@@ -659 +880 @@
     msInsertHashTable(&(myLayer->metadata), "gml_include_items", "all");
     msInsertHashTable(&(myLayer->metadata), "ows_name", output->name);
-    map* tmpMap=getMap(output->content,"title");
+    map* tmpMap=getMapArray(output->content,"title",imyIndex);
     if(tmpMap!=NULL)
       msInsertHashTable(&(myLayer->metadata), "ows_title", tmpMap->value);
     else
       msInsertHashTable(&(myLayer->metadata), "ows_title", "Default Title");
+
+    if(getMapArray(output->content,"msInclude",imyIndex)==NULL){
+      if(msGrowLayerClasses(myLayer) == NULL)
+        return -1;
+      if(initClass((myLayer->CLASS[myLayer->numclasses])) == -1)
+        return -1;
+      if(msGrowClassStyles(myLayer->CLASS[myLayer->numclasses]) == NULL)
+        return -1;
+      if(initStyle(myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]) == -1)
+        return -1;
+      /**
+       * Apply msStyle else fallback to the default style
+       */
+      tmpMap=getMap(output->content,"msStyle");
+      if(tmpMap==NULL){
+        switch(myLayer->type){
+        case MS_LAYER_POLYGON:
+          tmpMap=getMapFromMaps(conf,"main","msStylePoly");
+          break;
+        case MS_LAYER_LINE:
+          tmpMap=getMapFromMaps(conf,"main","msStyleLine");
+          break;
+        default:
+          tmpMap=getMapFromMaps(conf,"main","msStylePoint");
+          break;
+        }
+      }
+      if(tmpMap!=NULL)
+        msUpdateStyleFromString(myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles],tmpMap->value,0);
+      else{
+        /**
+         * Set style
+         */
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.red=125;
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.green=125;
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.blue=255;
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.red=80;
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.green=80;
+        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.blue=80;
+        
+        /**
+         * Set specific style depending on type
+         */
+        if(myLayer->type == MS_LAYER_POLYGON)
+          myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->width=3;
+        if(myLayer->type == MS_LAYER_LINE){
+          myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->width=3;
+          myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinewidth=1.5;
+        }
+        if(myLayer->type == MS_LAYER_POINT){
+          myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->symbol=1;
+          myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->size=15;
+        }
+        
+      }
+      myLayer->CLASS[myLayer->numclasses]->numstyles++;
+      myLayer->numclasses++;
     
-    if(msGrowLayerClasses(myLayer) == NULL)
-      return -1;
-    if(initClass((myLayer->CLASS[myLayer->numclasses])) == -1)
-      return -1;
-    if(msGrowClassStyles(myLayer->CLASS[myLayer->numclasses]) == NULL)
-      return -1;
-    if(initStyle(myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]) == -1)
-      return -1;
-    /**
-     * Apply msStyle else fallback to the default style
-     */
-    tmpMap=getMap(output->content,"msStyle");
-    if(tmpMap!=NULL)
-      msUpdateStyleFromString(myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles],tmpMap->value,0);
-    else{
-      /**
-       * Set style
-       */
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.red=125;
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.green=125;
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->color.blue=255;
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.red=80;
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.green=80;
-      myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinecolor.blue=80;
-      
-      /**
-       * Set specific style depending on type
-       */
-      if(myLayer->type == MS_LAYER_POLYGON)
-        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->width=3;
-      if(myLayer->type == MS_LAYER_LINE){
-        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->width=3;
-        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->outlinewidth=1.5;
-      }
-      if(myLayer->type == MS_LAYER_POINT){
-        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->symbol=1;
-        myLayer->CLASS[myLayer->numclasses]->styles[myLayer->CLASS[myLayer->numclasses]->numstyles]->size=15;
-      }
-      
-    }
-    myLayer->CLASS[myLayer->numclasses]->numstyles++;
-    myLayer->numclasses++;
-    
-    m->layerorder[m->numlayers] = m->numlayers;
-    m->numlayers++;
-
-  }
-
+      m->layerorder[m->numlayers] = m->numlayers;
+      m->numlayers++;
+
+    }
+  }
   OGR_DS_Destroy(poDS);
-  OGRCleanupAll();
+  //OGRCleanupAll();
 
   return 1;
@@ -727 +962 @@
  */
 int tryGdal(maps* conf,maps* output,mapObj* m){
-  map* tmpMap=getMap(output->content,"storage");
+  int imyIndex=getPublishedId(output);
+  map* tmpMap=getMapArray(output->content,"storage",imyIndex);
+  map* styleMap=getMap(output->content,"msStyle");
   char *pszFilename=tmpMap->value;
   GDALDatasetH hDataset;
@@ -738 +975 @@
    */
   GDALAllRegister();
-  hDataset = GDALOpen( pszFilename, GA_ReadOnly );
+  hDataset = GDALOpen( pszFilename, GA_Update ); /*GA_ReadOnly*/
   if( hDataset == NULL ){
 #ifdef DEBUGMS
     fprintf(stderr,"Unable to access the DataSource %s \n",pszFilename);
 #endif
+    setMapArray(output->content,"geodatatype",imyIndex,"other");
     setMapInMaps(conf,"lenv","message","gdalinfo failed - unable to open");
     GDALDestroyDriverManager();
@@ -751 +989 @@
 #endif
 
+  setMapArray(output->content,"geodatatype",imyIndex,"raster");
   /**
    * Add a new layer set name, data
@@ -772 +1011 @@
 
   char *title=output->name;
-  tmpMap=getMap(output->content,"title");
+  tmpMap=getMapArray(output->content,"title",imyIndex);
   if(tmpMap!=NULL)
     title=tmpMap->value;
   char *abstract=output->name;
-  tmpMap=getMap(output->content,"abstract");
+  tmpMap=getMapArray(output->content,"abstract",imyIndex);
   if(tmpMap!=NULL)
     abstract=tmpMap->value;
@@ -791 +1030 @@
   m->width=GDALGetRasterXSize( hDataset );
   m->height=GDALGetRasterYSize( hDataset );
-  
+  if(m->width>4096 || m->height>4096){
+    if(m->width>m->height)
+      m->maxsize=m->width;
+    else  
+      m->maxsize=m->height;
+  }else
+    m->maxsize=4096;
+  addIntToMapArray(output->content,"nb_pixels",imyIndex,GDALGetRasterXSize( hDataset )*GDALGetRasterYSize( hDataset ));
+  int pixel_type=GDALGetRasterDataType( hDataset );
+  addIntToMapArray(output->content,"pixel_data_type",imyIndex,pixel_type);
+
+  int outputIndex=msGetOutputFormatIndex(m,"tiff");
+  if(outputIndex>=0){
+    m->outputformatlist[outputIndex]->imagemode=((pixel_type==GDT_Byte)?MS_IMAGEMODE_BYTE:((pixel_type==GDT_Int16 || pixel_type==GDT_UInt16)?MS_IMAGEMODE_INT16:((pixel_type!=GDT_Float32)?MS_IMAGEMODE_FLOAT32:MS_IMAGEMODE_BYTE)));
+    outputIndex=msGetOutputFormatIndex(m,"geotiff");
+    if(outputIndex>=0)
+      m->outputformatlist[outputIndex]->imagemode=((pixel_type==GDT_Byte)?MS_IMAGEMODE_BYTE:((pixel_type==GDT_Int16 || pixel_type==GDT_UInt16)?MS_IMAGEMODE_INT16:((pixel_type!=GDT_Float32)?MS_IMAGEMODE_FLOAT32:MS_IMAGEMODE_BYTE)));
+  }
+  //
+    
   /**
    * Set projection using Authority Code and Name if available or fallback to 
@@ -805 +1063 @@
     setSrsInformations(output,m,myLayer,pszProjection);
   }else{
-    fprintf(stderr,"NO SRS FOUND ! %s\n",GDALGetProjectionRef( hDataset ));    
-  }
-
+    fprintf(stderr,"NO SRS FOUND %s %d ! %s\n",__FILE__,__LINE__,GDALGetProjectionRef( hDataset ));
+    fflush(stderr);
+    CPLErr sp=GDALSetProjection( hDataset , "+init=epsg:4326" );
+    if(sp!=CE_None){
+      fprintf(stderr,"NO SRS SET ! %s\n",CPLGetLastErrorMsg());
+    }
+  }
 
   /**
@@ -825 +1087 @@
         + adfGeoTransform[4] * GDALGetRasterXSize(hDataset);
 
-       setMsExtent(output,m,myLayer,minX,minY,maxX,maxY);
-
-    }
+      setMsExtent(output,m,myLayer,minX,minY,maxX,maxY);
+      char extent[1024];
+      memset(&extent,0,1024);
+      sprintf(extent,"%d,%d,%d,%d",minX,minY,maxX,maxY);
+      setMapArray(output->content,"boundingbox",imyIndex,extent);
+    }
+  }else{
+    int scale=1;
+    if(m->width>2048){
+      addIntToMapArray(output->content,"width",imyIndex,2048);
+      scale=2048/m->width;
+    }else
+      addIntToMapArray(output->content,"width",imyIndex,m->width);
+    addIntToMapArray(output->content,"height",imyIndex,m->height*scale);
   }
 
@@ -835 +1108 @@
    */
   char nBands[3];
+  memset(&nBands,0,3);
   int nBandsI=GDALGetRasterCount( hDataset );
-  sprintf(nBands,"%d",GDALGetRasterCount( hDataset ));
-  msInsertHashTable(&(myLayer->metadata), "ows_bandcount", nBands);
-  if(nBandsI>=3)
-    msLayerAddProcessing(myLayer,"BANDS=1,2,3");
-  else if(nBandsI>=2)
-    msLayerAddProcessing(myLayer,"BANDS=1,2");
-  else
-    msLayerAddProcessing(myLayer,"BANDS=1");
+  if(nBandsI<100){
+    sprintf(nBands,"%d",GDALGetRasterCount( hDataset ));
+    msInsertHashTable(&(myLayer->metadata), "ows_bandcount", nBands);
+  }
+  if(styleMap==NULL || strstr(styleMap->value,"BANDS=")==NULL){
+    if(nBandsI>=3)
+      if(nBandsI==4)
+        msLayerAddProcessing(myLayer,"BANDS=1,2,3,4");
+      else
+        msLayerAddProcessing(myLayer,"BANDS=1,2,3");
+    else if(nBandsI>=2)
+      msLayerAddProcessing(myLayer,"BANDS=1,2");
+    else
+      msLayerAddProcessing(myLayer,"BANDS=1");
+  }
 
   /**
@@ -851 +1132 @@
   char *nameBands=NULL;
   for( iBand = 0; iBand < nBandsI; iBand++ ){
-    sprintf(lBands,"Band%d",iBand+1);
+    memset(&lBands,0,7);
+    sprintf(lBands,"Band%d",iBand+1);    
     if(nameBands==NULL){
       nameBands=(char*)malloc((strlen(lBands)+1)*sizeof(char));
       sprintf(nameBands,"%s",lBands);
     }else{
-      if(iBand<4){
+      /*if(iBand<4)*/{
         char *tmpS=zStrdup(nameBands);
-        nameBands=(char*)realloc(nameBands,(strlen(nameBands)+strlen(lBands)+1)*sizeof(char));
+        nameBands=(char*)realloc(nameBands,(strlen(tmpS)+strlen(lBands)+2)*sizeof(char));
         sprintf(nameBands,"%s %s",tmpS,lBands);
         free(tmpS);
@@ -864 +1146 @@
     }
   }
-  msInsertHashTable(&(myLayer->metadata), "ows_bandnames", nameBands);
-  
+  if(nameBands!=NULL){
+    msInsertHashTable(&(myLayer->metadata), "ows_bandnames", nameBands);
+    free(nameBands);
+  }
+
   /**
    * Loops over metadata information to setup specific information
    */
   for( iBand = 0; iBand < nBandsI; iBand++ ){
-    //int         bGotNodata;//, bSuccess;
-    double      adfCMinMax[2]/*, dfNoData*/;
-    //int         nBlockXSize, nBlockYSize, nMaskFlags;
-    //double      /*dfMean, dfStdDev*/;
+    double      pdfMin, pdfMax, pdfMean, pdfStdDev;
     hBand = GDALGetRasterBand( hDataset, iBand+1 );
 
     CPLErrorReset();
-    GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
+    GDALGetRasterStatistics( hBand, TRUE, TRUE, &pdfMin, &pdfMax, &pdfMean, &pdfStdDev);
     char tmpN[21];
     sprintf(tmpN,"Band%d",iBand+1);
     if (CPLGetLastErrorType() == CE_None){
-      char tmpMm[100];
-      sprintf(tmpMm,"%.3f %.3f",adfCMinMax[0],adfCMinMax[1]);
-      char tmpI[21];
+      char tmpMm[100],tmpMp[100],tmpNb[3];
+      sprintf(tmpMm,"%.3f %.3f",pdfMin,pdfMax);
+      if(pdfMin!=pdfMax && (styleMap==NULL || strstr(styleMap->value,"SCALE_")==NULL)){
+        sprintf(tmpNb,"%d",iBand+1);
+        if(styleMap==NULL || strstr(styleMap->value,"BANDS=")==NULL || strstr(strstr(styleMap->value,"BANDS="),tmpNb)!=NULL){ 
+          if(pdfMean-(2*pdfStdDev)<0)
+            sprintf(tmpMp,"SCALE_%d=%.3f,%.3f",iBand+1,0.0,pdfMean+(2*pdfStdDev));
+          else
+            sprintf(tmpMp,"SCALE_%d=%.3f,%.3f",iBand+1,pdfMean-(2*pdfStdDev),pdfMean+(2*pdfStdDev));
+          msLayerAddProcessing(myLayer,tmpMp);
+        }
+      }
+      char tmpI[31];      
       sprintf(tmpI,"%s_interval",tmpN);
       msInsertHashTable(&(myLayer->metadata), tmpI, tmpMm);
-
       map* test=getMap(output->content,"msClassify");
       if(test!=NULL && strncasecmp(test->value,"true",4)==0){
@@ -906 +1197 @@
           
         if(nBandsI==1){
-          double delta=adfCMinMax[1]-adfCMinMax[0];
+          double delta=pdfMax-pdfMin;
           double interval=delta/10;
-          double cstep=adfCMinMax[0];
+          double cstep=pdfMin;
           for(i=0;i<10;i++){
             /**
@@ -952 +1243 @@
           
           char tmpMm[100];
-          sprintf(tmpMm,"%.3f %.3f",adfCMinMax[0],adfCMinMax[1]);
+          sprintf(tmpMm,"%.3f %.3f",pdfMin,pdfMax);
           
         }
@@ -962 +1253 @@
           myLayer->offsite.blue=0;
         }
-        msLayerAddProcessing(myLayer,"RESAMPLE=BILINEAR");
       }
     }
     if( strlen(GDALGetRasterUnitType(hBand)) > 0 ){
-      char tmpU[21];
+      char tmpU[31];
       sprintf(tmpU,"%s_band_uom",tmpN);
       msInsertHashTable(&(myLayer->metadata), tmpU, GDALGetRasterUnitType(hBand));
@@ -972 +1262 @@
 
   }
-
+  if(styleMap==NULL || strstr(styleMap->value,"RESAMPLE")==NULL)
+    msLayerAddProcessing(myLayer,"RESAMPLE=BILINEAR");
+  
+  if(styleMap!=NULL && strlen(styleMap->value)>9){
+    msUpdateLayerFromString(myLayer,styleMap->value,MS_FALSE);
+  }
+  
   m->layerorder[m->numlayers] = m->numlayers;
   m->numlayers++;
@@ -978 +1274 @@
   GDALDestroyDriverManager();
   CPLCleanupTLS();
+  storeMd5(pszFilename);
   return 1;
 }
@@ -988 +1285 @@
  */
 void outputMapfile(maps* conf,maps* outputs){
-
   /**
    * First store the value on disk
    */
-  map* mime=getMap(outputs->content,"mimeType");
+  int imyIndex=getPublishedId(outputs);
+  map* mime=getMapArray(outputs->content,"mimeType",imyIndex);
+  map* msUrl=getMapFromMaps(conf,"main","mapserverAddress");
+  map* dataPath=getMapFromMaps(conf,"main","dataPath");
   char *ext="data";
   if(mime!=NULL)
@@ -998 +1297 @@
       ext="json";
 
-  map* tmpMap=getMapFromMaps(conf,"main","dataPath");
-  map* sidMap=getMapFromMaps(conf,"lenv","usid");
-  char *pszDataSource=(char*)malloc((strlen(tmpMap->value)+strlen(sidMap->value)+strlen(outputs->name)+17)*sizeof(char));
-  sprintf(pszDataSource,"%s/ZOO_DATA_%s_%s.%s",tmpMap->value,outputs->name,sidMap->value,ext); 
-  int f=zOpen(pszDataSource,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
-  map *gfile=getMap(outputs->content,"generated_file");
-  if(gfile!=NULL){
-    readGeneratedFile(conf,outputs->content,gfile->value);          
-  }
-  map* sizeMap=getMap(outputs->content,"size");
-  map* vData=getMap(outputs->content,"value");
-  if(sizeMap!=NULL){
-    zWrite(f,vData->value,atoi(sizeMap->value)*sizeof(char));
-  }
-  else{
-    zWrite(f,vData->value,(strlen(vData->value)+1)*sizeof(char));
-  }
-  close(f);
-  addToMap(outputs->content,"storage",pszDataSource);
-  free(pszDataSource);
+  map* storage=getMapArray(outputs->content,"storage",imyIndex);
+  if(storage==NULL){
+    map* tmpMap=getMapFromMaps(conf,"main","dataPath");
+    map* sidMap=getMapFromMaps(conf,"lenv","usid");
+    char *pszDataSource=(char*)malloc((strlen(tmpMap->value)+strlen(sidMap->value)+strlen(outputs->name)+17)*sizeof(char));
+    sprintf(pszDataSource,"%s/ZOO_DATA_%d_%s_%s.%s",tmpMap->value,imyIndex,outputs->name,sidMap->value,ext);
+    int f=zOpen(pszDataSource,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
+    map *gfile=getMapArray(outputs->content,"generated_file",imyIndex);
+    if(gfile!=NULL){
+      readGeneratedFile(conf,outputs->content,gfile->value);        
+    }
+    map* sizeMap=getMapArray(outputs->content,"size",imyIndex);
+    map* vData=getMapArray(outputs->content,"value",imyIndex);
+    if(sizeMap!=NULL){
+      zWrite(f,vData->value,atoi(sizeMap->value)*sizeof(char));
+    }
+    else{
+      zWrite(f,vData->value,(strlen(vData->value)+1)*sizeof(char));
+    }
+    close(f);
+    setMapArray(outputs->content,"storage",imyIndex,pszDataSource);
+    free(pszDataSource);
+  }
 
   /*
    * Create an empty map, set name, default size and extent
    */
-  mapObj *myMap=msNewMapObj();
+  map* mapfileTemplate=getMapArray(outputs->content,"msInclude",imyIndex);
+  mapObj *myMap=NULL;
+  if(mapfileTemplate==NULL){
+    myMap=msNewMapObj();
+  }
+  else{
+    map* dataPath=getMapFromMaps(conf,"main","dataPath");
+    map* sid=getMapFromMaps(conf,"lenv","sid");
+    char *mapfileTemplatePath=(char*)malloc(((strlen(dataPath->value)+strlen(sid->value)+strlen(outputs->name)+10)*sizeof(char)));
+    sprintf(mapfileTemplatePath,"%s/%s_%s.map",dataPath->value,outputs->name,sid->value);
+    myMap=msLoadMap(mapfileTemplate->value,mapfileTemplatePath);
+    if(myMap==NULL){
+      setMapInMaps(conf,"lenv","message",_("Unable to open your template mapfile!"));
+      return ;
+    }
+  }
   free(myMap->name);
   myMap->name=zStrdup("ZOO-Project_WXS_Server");
@@ -1048 +1365 @@
 #ifdef USE_KML
   outputFormatObj *o2=msCreateDefaultOutputFormat(NULL,"KML","kml");
-  o2->inmapfile=MS_TRUE;  
-  msAppendOutputFormat(myMap,msCloneOutputFormat(o2));
-  msFreeOutputFormat(o2);
+  if(!o2){
+    perror("Unable to initialize KML driver");
+    fprintf(stderr,"Unable to initialize KML driver !\n");
+  }else{
+    o2->inmapfile=MS_TRUE;  
+    msAppendOutputFormat(myMap,msCloneOutputFormat(o2));
+    msFreeOutputFormat(o2);
+  }
 #endif
 
@@ -1057 +1379 @@
     fprintf(stderr,"Unable to initialize GDAL driver !\n");
   else{
-    o3->imagemode=MS_IMAGEMODE_BYTE;
+    o3->imagemode=MS_IMAGEMODE_INT16;
     o3->inmapfile=MS_TRUE;  
     msAppendOutputFormat(myMap,msCloneOutputFormat(o3));
@@ -1067 +1389 @@
     fprintf(stderr,"Unable to initialize GDAL driver !\n");
   else{
-    o4->imagemode=MS_IMAGEMODE_INT16;
+    o4->imagemode=MS_IMAGEMODE_BYTE;
     o4->inmapfile=MS_TRUE;  
     msAppendOutputFormat(myMap,msCloneOutputFormat(o4));
@@ -1086 +1408 @@
 #endif
 
+  
+  outputFormatObj *o6=msCreateDefaultOutputFormat(NULL,"GDAL/GTiff","geotiff");
+  if(!o6)
+    fprintf(stderr,"Unable to initialize GDAL driver !\n");
+  else{
+    o6->imagemode=MS_IMAGEMODE_BYTE;
+    o6->mimetype=strdup("image/geotiff");
+    o6->inmapfile=MS_TRUE;
+    msAppendOutputFormat(myMap,msCloneOutputFormat(o6));
+    msFreeOutputFormat(o6);
+  }
+
+  
   /*
    * Set default projection to EPSG:4326
@@ -1091 +1426 @@
   msLoadProjectionStringEPSG(&myMap->projection,"EPSG:4326");
   myMap->transparent=1;
-
-  /**
-   * Set metadata extracted from main.cfg file maps
-   */
-  maps* cursor=conf;
-  map* correspondance=getCorrespondance();
-  while(cursor!=NULL){
-    map* _cursor=cursor->content;
-    map* vMap;
-    while(_cursor!=NULL){
-      if((vMap=getMap(correspondance,_cursor->name))!=NULL){
-        if (msInsertHashTable(&(myMap->web.metadata), vMap->value, _cursor->value) == NULL){
-#ifdef DEBUGMS
-          fprintf(stderr,"Unable to add metadata");
-#endif
-          return;
-        }
-      }
-      _cursor=_cursor->next;
-    }
-    cursor=cursor->next;
-  }
-  freeMap(&correspondance);
-  free(correspondance);
 
   /*
@@ -1157 +1468 @@
   msInsertHashTable(&(myMap->web.metadata), "ows_srs", "EPSG:4326");
 
+  /**
+   * Set metadata extracted from main.cfg file maps
+   */
+  maps* cursor=conf;
+  map* correspondance=getCorrespondance();
+  while(cursor!=NULL){
+    if(strstr(cursor->name,"_help")==NULL){
+      map* _cursor=cursor->content;
+      map* vMap;
+      while(_cursor!=NULL){
+        if((vMap=getMap(correspondance,_cursor->name))!=NULL){
+          if (msInsertHashTable(&(myMap->web.metadata), vMap->value, _cursor->value) == NULL){
+#ifdef DEBUGMS
+            fprintf(stderr,"Unable to add metadata");
+#endif
+            freeMap(&correspondance);
+            free(correspondance);
+            return;
+          }
+        }
+        _cursor=_cursor->next;
+      }
+    }
+    cursor=cursor->next;
+  }
+  freeMap(&correspondance);
+  free(correspondance);
+
+  map* sid=getMapFromMaps(conf,"lenv","usid");
+  char *mapPath=
+    (char*)malloc((14+strlen(sid->value)+strlen(outputs->name)+strlen(dataPath->value))*sizeof(char));
+  sprintf(mapPath,"%s/%s_%d_%s.map",dataPath->value,outputs->name,imyIndex,sid->value);
+  char *mapUrl=
+    (char*)malloc((6+strlen(mapPath)+strlen(msUrl->value))*sizeof(char));
+  sprintf(mapUrl,"%s?map=%s",msUrl->value,mapPath);
+
+  if (msInsertHashTable(&(myMap->web.metadata), "ows_onlineresource", mapUrl) == NULL){
+#ifdef DEBUGMS
+    fprintf(stderr,"Unable to add metadata");
+#endif
+    return;
+  }
+
   if(tryOgr(conf,outputs,myMap)<0)
     if(tryGdal(conf,outputs,myMap)<0)
       return ;
 
-  tmp1=getMapFromMaps(conf,"main","dataPath");
-  char *tmpPath=(char*)malloc((13+strlen(tmp1->value))*sizeof(char));
-  sprintf(tmpPath,"%s/symbols.sym",tmp1->value);
+  char *tmpPath=(char*)malloc((13+strlen(dataPath->value))*sizeof(char));
+  sprintf(tmpPath,"%s/symbols.sym",dataPath->value);
   msInitSymbolSet(&myMap->symbolset);
   myMap->symbolset.filename=zStrdup(tmpPath);
   free(tmpPath);
 
-  map* sid=getMapFromMaps(conf,"lenv","usid");
-  char *mapPath=
-    (char*)malloc((7+strlen(sid->value)+strlen(outputs->name)+strlen(tmp1->value))*sizeof(char));
-  sprintf(mapPath,"%s/%s_%s.map",tmp1->value,outputs->name,sid->value);
   msSaveMap(myMap,mapPath);
+  saveMapNames(conf,outputs,mapPath);
   free(mapPath);
+  //free(myMap->symbolset.filename);
+  //msFreeSymbolSet(&myMap->symbolset);
+  msFreeMap(myMap);
+  //msFree(myMap);
   msGDALCleanup();
-  msFreeMap(myMap);
 }
 
+/**
+ * Save the map fullpath in a text file (.maps)
+ * @param conf the main configuration map pointer
+ * @param output the current output for which a mapfile has been generated
+ * @param mapfile the mapfile saved to store in the text file
+ */
+void saveMapNames(maps* conf,maps* output,char* mapfile){
+  map* storage=getMap(output->content,"storage");
+  char *tmp=zStrdup(storage->value);
+  tmp[strlen(tmp)-strlen(strrchr(tmp,'.'))]=0;
+  char* mapName=(char*)malloc((strlen(tmp)+6)*sizeof(char*));
+  sprintf(mapName,"%s.maps",tmp);
+  FILE* myMaps=fopen(mapName,"a");
+  if(myMaps!=NULL){
+    fprintf(myMaps,"%s\n",mapfile);
+    fclose(myMaps);
+  }
+  free(mapName);
+  free(tmp);
+}

trunk/zoo-project/zoo-kernel/service_internal_ms.h

@@ -56 +56 @@
   int tryGdal(maps* conf,maps* output,mapObj* m);
   void outputMapfile(maps* conf,maps* outputs);
+  void saveMapNames(maps*,maps*,char*);
+
 #ifdef __cplusplus
 }

trunk/zoo-project/zoo-kernel/service_internal_php7.c

@@ -25 +25 @@
 #ifdef WIN32
   #define NO_FCGI_DEFINES
+  #define ZEND_WIN32_KEEP_INLINE
 #endif
 

trunk/zoo-project/zoo-kernel/service_internal_python.c

@@ -57 +57 @@
  * from the ZOO-Kernel Python environment:
  *  - "_" corresponding to the PythonTranslate function
- *  - "updte_status" corresponding to the PythonUpdateStatus function
+ *  - "update_status" corresponding to the PythonUpdateStatus function
  * @see PythonTranslate, PythonUpdateStatus
  */
@@ -146 +146 @@
  */
 int zoo_python_support(maps** main_conf,map* request,service* s,maps **real_inputs,maps **real_outputs){
+
   char *pythonpath;
   char *python_path;
+
+#ifdef WIN32
+  char* os_pathsep = ";";
+#else
+  char* os_pathsep = ":";
+#endif
+
   maps* m=*main_conf;
   maps* inputs=*real_inputs;
   maps* outputs=*real_outputs;
   map* tmp0=getMapFromMaps(*main_conf,"lenv","cwd");
-  char *ntmp=tmp0->value;
+  char *ntmp=tmp0->value;  
   map* tmp=NULL;
   int hasToClean=0;
-  tmp=getMapFromMaps(*main_conf,"env","PYTHONPATH");
+  tmp=getMapFromMaps(*main_conf,"env","PYTHONPATH"); 
+
+  map* kvp = NULL;
+  char* libPath = NULL;
+  if (hasvalue(*main_conf, "main", "libPath", &kvp)) {
+          libPath = kvp->value;
+  }
+  else {
+          libPath = "";
+  }
+
 #ifdef DEBUG
   fprintf(stderr,"PYTHON SUPPORT \n");
@@ -163 +181 @@
     fprintf(stderr,"PYTHON SUPPORT (%i)\n",strlen(tmp->value));
 #endif
-    python_path=(char*)malloc((strlen(tmp->value))*sizeof(char));
+    python_path=(char*)malloc((strlen(tmp->value)+1)*sizeof(char));
     sprintf(python_path,"%s",tmp->value);
     hasToClean=1;
@@ -172 +190 @@
       python_path=cwdMap->value;
     else
-      python_path=(char*)".";
+      python_path=(char*)".";   
   }
   tmp=NULL;
   tmp=getMap(request,"metapath");
   if(tmp!=NULL && strcmp(tmp->value,"")!=0){
-    pythonpath=(char*)malloc((4+strlen(python_path)+strlen(ntmp)+strlen(tmp->value))*sizeof(char));
+    //pythonpath=(char*)malloc((4+strlen(python_path)+strlen(ntmp)+strlen(tmp->value))*sizeof(char));
+          pythonpath = (char*)malloc((5 + strlen(python_path) + strlen(ntmp) + strlen(tmp->value) + strlen(libPath)) * sizeof(char));
 #ifdef WIN32
-  sprintf(pythonpath,"%s/%s/;%s",ntmp,tmp->value,python_path);
+  //sprintf(pythonpath,"%s/%s/;%s",ntmp,tmp->value,python_path);
+        sprintf(pythonpath, "%s/%s/;%s;%s", ntmp, tmp->value, python_path, libPath);
 #else
-  sprintf(pythonpath,"%s/%s/:%s",ntmp,tmp->value,python_path);
+  //sprintf(pythonpath,"%s/%s/:%s",ntmp,tmp->value,python_path);
+  sprintf(pythonpath, "%s/%s/:%s:%s", ntmp, tmp->value, python_path, libPath);  
 #endif
   }
   else{
-    pythonpath=(char*)malloc((2+strlen(python_path)+strlen(ntmp))*sizeof(char));
+    //pythonpath=(char*)malloc((2+strlen(python_path)+strlen(ntmp))*sizeof(char));
+          pythonpath = (char*)malloc((3 + strlen(python_path) + strlen(ntmp) + strlen(libPath)) * sizeof(char));
 #ifdef WIN32
-    sprintf(pythonpath,"%s;%s",ntmp,python_path);
+    //sprintf(pythonpath,"%s;%s",ntmp,python_path);
+        sprintf(pythonpath, "%s;%s;%s", ntmp, python_path, libPath);
 #else
-    sprintf(pythonpath,"%s:%s",ntmp,python_path);
-#endif
+    //sprintf(pythonpath,"%s:%s",ntmp,python_path);
+        sprintf(pythonpath, "%s:%s:%s", ntmp, python_path, libPath);
+#endif  
   }
 #ifdef DEBUG
     fprintf(stderr,"PYTHONPATH=%s\n",pythonpath);
 #endif
-#ifndef WIN32
-  setenv("PYTHONPATH",pythonpath,1);
-#else
+        map* home = NULL;
+// knut: also set PYTHONHOME environment variable so that Python can load standard modules
+#ifndef WIN32   
+  setenv("PYTHONPATH",pythonpath,1);  
+  //= getMapFromMaps(*main_conf, "env", "PYTHONHOME"); 
+  if (hasvalue(*main_conf, "env", "PYTHONHOME", &home)) {
+          setenv("PYTHONHOME", home->value, 1); // overwrite
+  }
+#else   
   SetEnvironmentVariable("PYTHONPATH",pythonpath);
   char* toto=(char*)malloc((strlen(pythonpath)+12)*sizeof(char));
   sprintf(toto,"PYTHONPATH=%s",pythonpath);
-  putenv(toto);
+  _putenv(toto);
   free(toto);
-#endif
+  if (hasvalue(*main_conf, "env", "PYTHONHOME", &home)) { 
+          SetEnvironmentVariable("PYTHONHOME", home->value);
+  }
+  char buffer[128];        
+#endif  
   if(hasToClean>0)
     free(python_path);
@@ -209 +243 @@
 
   PyThreadState *mainstate;
-#if PY_MAJOR_VERSION >= 3
-  PyImport_AppendInittab("zoo", init_zoo);
+#if PY_MAJOR_VERSION >= 3  
+  PyImport_AppendInittab("zoo", init_zoo);  
 #else
   PyEval_InitThreads();
-#endif
-  Py_Initialize();
-#if PY_MAJOR_VERSION >= 3
+#endif  
+  Py_Initialize();  
+#if PY_MAJOR_VERSION >= 3  
   PyEval_InitThreads();
-  PyImport_ImportModule("zoo");
+  PyImport_ImportModule("zoo");  
 #else
   init_zoo();
-#endif
+#endif  
   mainstate = PyThreadState_Swap(NULL);
   PyEval_ReleaseLock();
@@ -240 +274 @@
       char *mn=(char*)malloc((strlen(mps)+strlen(tmp->value)+2)*sizeof(char));
       sprintf(mn,"%s.%s",mps,tmp->value);
-      pName = PyString_FromString(mn);
+      pName = PyString_FromString(mn);    
       free(mn);
       free(mps);
@@ -251 +285 @@
     errorException (m, "Unable to parse serviceProvider please check your zcfg file.", "NoApplicableCode", NULL);
     exit(-1);
-  }
-  pModule = PyImport_Import(pName);
+  }  
+  pModule = PyImport_Import(pName);    
   int res=SERVICE_FAILED;
   if (pModule != NULL) {
@@ -267 +301 @@
       PyTuple_SetItem(pArgs, 1, (PyObject *)arg2);
       PyTuple_SetItem(pArgs, 2, (PyObject *)arg3);
-      pValue = PyObject_CallObject(pFunc, pArgs);
+      pValue = PyObject_CallObject(pFunc, pArgs);         
       if (pValue != NULL) {
         res=PyInt_AsLong(pValue);
@@ -275 +309 @@
         free(*main_conf);
         *main_conf=mapsFromPyDict(arg1);
-        *real_outputs=mapsFromPyDict(arg3);
+        *real_outputs=mapsFromPyDict(arg3);     
 #ifdef DEBUG
         fprintf(stderr,"Result of call: %i\n", PyInt_AsLong(pValue));
@@ -281 +315 @@
         dumpMaps(*real_outputs);
 #endif
-      }else{      
+      }else{
         PythonZooReport(m,tmp->value,0);
         res=-1;
@@ -301 +335 @@
 #endif
   PyThreadState_Swap(mainstate);
-  Py_Finalize();
+  Py_Finalize();  
   return res;
 }
@@ -323 +357 @@
   char *pbt=NULL;
   if(PyString_Check(trace)){
-    pbt=(char*)malloc((7+strlen(PyString_AsString(trace))+1)*sizeof(char));
+    pbt=(char*)malloc((8+strlen(PyString_AsString(trace)))*sizeof(char));
     sprintf(pbt,"TRACE: %s",PyString_AsString(trace));
   }
   else
     fprintf(stderr,"EMPTY TRACE ?");
-  
+
   trace=NULL;
   
@@ -425 +459 @@
   map* isArray=getMap(tmp,"isArray");
   map* size=getMap(tmp,"size");
+  map* useFile=getMap(tmp,"use_file");
+  map* cacheFile=getMap(tmp,"cache_file");
   map* tmap=getMapType(tmp);
   while(tmp!=NULL){
@@ -435 +471 @@
         PyObject* mvalue=PyList_New(cnt);
         PyObject* svalue=PyList_New(cnt);
+        PyObject* cvalue=PyList_New(cnt);
 
         for(int i=0;i<cnt;i++){
           
-          map* vMap=getMapArray(tmp,"value",i);     
-          map* sMap=getMapArray(tmp,"size",i);
+          map* vMap=getMapArray(t,"value",i);
+          map* uMap=getMapArray(t,"use_file",i);
+          map* sMap=getMapArray(t,"size",i);
+          map* cMap=getMapArray(t,"cache_file",i);
 
           if(vMap!=NULL){
@@ -445 +484 @@
             PyObject* lvalue;
             PyObject* lsvalue;
-            if(sMap==NULL){
+            PyObject* lcvalue;
+            if(sMap==NULL || uMap!=NULL){
               lvalue=PyString_FromString(vMap->value);
-              lsvalue=Py_None;
             }
             else{    
               lvalue=PyString_FromStringAndSize(vMap->value,atoi(sMap->value));
+            }
+            if(sMap!=NULL){
               lsvalue=PyString_FromString(sMap->value);
               hasSize=1;
             }
+            else
+              lsvalue=Py_None;
+            if(uMap!=NULL){
+              lcvalue=PyString_FromString(cMap->value);;
+            }else
+              lcvalue=Py_None;
 
             if(PyList_SetItem(value,i,lvalue)<0){
@@ -463 +510 @@
               return NULL;
             } 
+            if(PyList_SetItem(cvalue,i,lcvalue)<0){
+              fprintf(stderr,"Unable to set key value pair...");
+              return NULL;
+            }
           }
           
+          PyObject* lmvalue;
           map* mMap=getMapArray(tmp,tmap->name,i);
-          PyObject* lmvalue;
           if(mMap!=NULL){
             lmvalue=PyString_FromString(mMap->value);
@@ -487 +538 @@
           return NULL;
         }
+        if(PyDict_SetItem(res,PyString_FromString("cache_file"),cvalue)<0){
+          fprintf(stderr,"Unable to set key value pair...");
+          return NULL;
+        }
         if(hasSize>0)
           if(PyDict_SetItem(res,PyString_FromString("size"),svalue)<0){
@@ -493 +548 @@
           }
       }
-      else if(size!=NULL){
+      else if(size!=NULL && useFile==NULL){
         PyObject* value=PyString_FromStringAndSize(tmp->value,atoi(size->value));
         if(PyDict_SetItem(res,name,value)<0){

trunk/zoo-project/zoo-kernel/service_internal_python.h

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2009-2010 GeoLabs SARL
+ * Copyright (c) 2009-2019 GeoLabs SARL
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -28 +28 @@
 #pragma once 
 
+#include <Python.h>
 #include "service_internal.h"
 #include "response_print.h"
-#include <Python.h>
-#include "cgic.h"
 #ifdef WIN32
 #include <windows.h>

trunk/zoo-project/zoo-kernel/service_internal_ruby.c

@@ -260 +260 @@
   int hasSize=0;
   map* isArray=getMap(tmp,"isArray");
+  map* useFile=getMap(tmp,"use_file");
   map* size=getMap(tmp,"size");
   map* tmap=getMapType(tmp);
@@ -271 +272 @@
         VALUE mvalue=rb_ary_new2(cnt);
         VALUE svalue=rb_ary_new2(cnt);
+        VALUE cvalue=rb_ary_new2(cnt);
 
         for(int i=0;i<cnt;i++){
@@ -276 +278 @@
           map* vMap=getMapArray(tmp,"value",i);     
           map* sMap=getMapArray(tmp,"size",i);
+          map* uMap=getMapArray(tmp,"use_file",i);
+          map* cMap=getMapArray(tmp,"cache_file",i);
 
           if(vMap!=NULL){
@@ -281 +285 @@
             VALUE lvalue;
             VALUE lsvalue;
-            if(sMap==NULL){
+            VALUE lcvalue;
+            if(sMap==NULL || uMap==NULL){
               lvalue=rb_str_new2(vMap->value);
-              lsvalue=Qnil;
+              if(sMap==NULL)
+                lsvalue=Qnil;
+              else
+                lsvalue=rb_str_new2(sMap->value);
             }
             else{
@@ -290 +298 @@
               hasSize=1;
             }
+            if(uMap!=NULL)
+              lcvalue=rb_str_new2(cMap->value);
+            else
+              lcvalue=Qnil;
 
             rb_ary_push(value,lvalue);
             rb_ary_push(svalue,lsvalue);
+            rb_ary_push(cvalue,lcvalue);
           }
           
@@ -308 +321 @@
         rb_hash_aset(res, name, mvalue);
         rb_hash_aset(res, rb_str_new2(tmap->name), mvalue);
+        VALUE lname0=rb_str_new2("cache_size");
+        rb_hash_aset(res, lname0, value);
       
         if(hasSize>0){

trunk/zoo-project/zoo-kernel/service_internal_saga.c

@@ -30 +30 @@
 #include <api_core.h>
 #include <data_manager.h>
-#include <module_library.h>
+#include <saga_api.h>
 #define _ZOO_SAGA
 #include "service_internal_saga.h"
@@ -237 +237 @@
         return false;
       }
-      return( param->Set_Value(SG_Get_Data_Manager().Find(&fileName)) );
+      fprintf(stderr,"%s %s\n",carg->name,carg->value);
+      fflush(stderr);
+      return( param->Set_Value(SG_Get_Data_Manager().Find(&fileName,false)) );
     }
     else
@@ -250 +252 @@
             SG_Get_Data_Manager().Add(&fileName);
           }
-          param->asList()->Add_Item(SG_Get_Data_Manager().Find(&fileName));
+          param->asList()->Add_Item(SG_Get_Data_Manager().Find(&fileName,false));
         }
       }
@@ -327 +329 @@
             inmap=getMap(argument,(CSG_String(param->Get_Identifier())+"_MIN").b_str());
             if(inmap!=NULL)
+#if SAGA_MAJOR_VERSION == 2           
               param->asRange()->Set_LoVal(strtod(inmap->value,NULL));
+#else
+              param->asRange()->Set_Min(strtod(inmap->value,NULL));
+#endif      
             inmap=getMap(argument,(CSG_String(param->Get_Identifier())+"_MAX").b_str());
             if(inmap!=NULL)
+#if SAGA_MAJOR_VERSION == 2           
               param->asRange()->Set_HiVal(strtod(inmap->value,NULL));       
+#else
+              param->asRange()->Set_Max(strtod(inmap->value,NULL));
+#endif      
           }
           if(inmap==NULL){
@@ -386 +396 @@
             else if( param->is_DataObject_List() )
               {
-                for(int i=0; i<param->asList()->Get_Count(); i++)
+                for(int i=0; i<
+#if SAGA_MAJOR_VERSION == 2
+                      param->asList()->Get_Count()
+#else
+                      param->asList()->Get_Data_Count()
+#endif                
+                      ; i++)
                   {
-                    CSG_Data_Object *pObject = param->asList()->asDataObject(i);
+                    CSG_Data_Object *pObject =
+#if SAGA_MAJOR_VERSION == 2                   
+                      param->asList()->asDataObject(i)
+#else
+                      param->asList()->Get_Data(i)
+#endif                
+                      ;
                     
                     if( pObject->is_Modified() && SG_File_Exists(pObject->Get_File_Name()) )
@@ -439 +461 @@
                         }
                     }
-                  
+#if SAGA_MAJOR_VERSION == 2               
                   int nFileNames = param->asList()->Get_Count() <= fileNames.Get_Count() ? fileNames.Get_Count() : fileNames.Get_Count() - 1;
                   for(int i=0; i<param->asList()->Get_Count(); i++)
@@ -458 +480 @@
                                   CSG_String(param->asList()->asDataObject(i)->Get_File_Name()).b_str());
                     }
+#else
+                  int nFileNames = param->asList()->Get_Data_Count() <= fileNames.Get_Count() ? fileNames.Get_Count() : fileNames.Get_Count() - 1;
+                  for(int i=0; i<param->asList()->Get_Data_Count(); i++)
+                    {
+                      if( i < nFileNames )
+                        {
+                          param->asList()->Get_Data(i)->Save(fileNames[i]);
+                        }
+                      else
+                        {
+                          param->asList()->Get_Data(i)->Save(CSG_String::Format(SG_T("%s_%0*d"),
+                                                                                    fileNames[fileNames.Get_Count() - 1].c_str(),
+                                                                                    SG_Get_Digit_Count(param->asList()->Get_Data_Count()),
+                                                                                    1 + i - nFileNames
+                                                                                    ));
+                        }
+                      setMapArray(cMaps->content,"generated_file",i,
+                                  CSG_String(param->asList()->Get_Data(i)->Get_File_Name()).b_str());
+                    }
+                  
+#endif            
                 }
             }
@@ -477 +520 @@
   int res=SERVICE_FAILED;
 
+#if SAGA_MAJOR_VERSION == 2  
   CSG_Module_Library * library=SG_Get_Module_Library_Manager().Get_Library(CSG_String(lib_name),true);
+#else
+  CSG_Tool_Library * library=SG_Get_Tool_Library_Manager().Get_Library(CSG_String(lib_name),true);
+#endif  
   if( library == NULL){
     char tmp[255];
@@ -486 +533 @@
   }
 
+#if SAGA_MAJOR_VERSION == 2  
   CSG_Module * module=library->Get_Module(atoi(module_name));
+#else
+  CSG_Tool * module=library->Get_Tool(atoi(module_name));
+#endif  
   if(module == NULL){
     char tmp[255];
@@ -985 +1036 @@
   SG_Set_UI_Callback(Get_Callback(watcher));
 
+#if SAGA_MAJOR_VERSION == 2  
   int n = SG_Get_Module_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
-  if( SG_Get_Module_Library_Manager().Get_Count() <= 0 ){
+  if( SG_Get_Module_Library_Manager().Get_Count() <= 0 )
+#else
+  int n = SG_Get_Tool_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
+  if( SG_Get_Tool_Library_Manager().Get_Count() <= 0 )
+#endif
+  {
     setMapInMaps(*main_conf,"lenv","message","Could not load any SAGA tool library");
     res=SERVICE_FAILED;
@@ -995 +1052 @@
 
   // Load the SAGA-GIS library corresponding to the serviceProvider
+#if SAGA_MAJOR_VERSION == 2  
   CSG_Module_Library * library=SG_Get_Module_Library_Manager().Get_Library(CSG_String(serviceProvider->value),true);
+#else
+  CSG_Tool_Library * library=SG_Get_Tool_Library_Manager().Get_Library(CSG_String(serviceProvider->value),true);
+#endif
   if( library == NULL){
     char tmp[255];
@@ -1005 +1066 @@
   
   // Load the SAGA-GIS module corresponding to the service name from the library
+#if SAGA_MAJOR_VERSION == 2  
   CSG_Module * module=library->Get_Module(atoi(s->name));
+#else
+  CSG_Tool * module=library->Get_Tool(atoi(s->name));
+#endif
   if(module == NULL){
     char tmp[255];
@@ -1017 +1082 @@
   // Load all the parameters defined for the module
   CSG_Parameters * params=module->Get_Parameters();
-  int pc=params->Get_Count();
   if(!params){
     char tmp[255];
@@ -1026 +1090 @@
     return res;
   }
+  int pc=params->Get_Count();
 
   // Loop over each inputs to transform raster files to grid when needed, 

trunk/zoo-project/zoo-kernel/service_yaml.c

@@ -487 +487 @@
               addMapToIoType(&current_element->supported,current_content);
           }
-          freeMaps(&current_content);
+          freeMap(&current_content);
           free(current_content);
           current_content=NULL;

trunk/zoo-project/zoo-kernel/sql/schema.sql

@@ -31 +31 @@
 -- Create a dedicated schema to store all tables
 -- Uncomment the following 2 lines to activate the schema use
--- CREATE SCHEMA zoo;
--- SET search_path TO zoo;
+-- CREATE SCHEMA processdb;
+-- SET search_path TO processdb;
 --------------------------------------------------------------------------------
 -- Services table

trunk/zoo-project/zoo-kernel/sqlapi.c

@@ -1 +1 @@
 /*
- * Author : David Saggiorato
- *          Gérald Fenoy
+ * Authors : David Saggiorato
+ *           Gérald Fenoy
  *  Copyright 2015 GeoLabs SARL. All rights reserved.
  *
@@ -23 +23 @@
  */
 
-#ifdef RELY_ON_DB
 #include "ogr_api.h"
 #include "ogrsf_frmts.h"
@@ -44 +43 @@
 OGRDataSource 
 #endif
- *zoo_DS = NULL;
+ **zoo_DS = NULL;
 
 /**
@@ -52 +51 @@
 
 /**
- * Create a GDAL / OGR string for connecting to the db backend
- * (do not support active_schema)
- * 
- * @param conf the maps containing the setting of the main.cfg file
- */
-char* createInitString(maps* conf){
+ * Create a GDAL / OGR string for connecting to a db backend defined in the
+ * key section.
+ * 
+ * @param conf the maps containing the setting of the main.cfg file
+ * @param key the name of the section containing the connection setting
+ * @return the OGR connection string
+ */
+char* _createInitString(maps* conf,const char* key){
   char* res=NULL;
-  char keywords[5][9]={
+  char keywords[6][14]={
     "dbname",
     "host",
     "port",
     "user",
-    "password"
+    "password",
+    "active_schema"    
   };
   int i=0;
-  maps* cconf=getMaps(conf,"database");
+  maps* cconf=getMaps(conf,key);
+  if(cconf==NULL){
+    fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+    return "-1";
+  }
   int len=0;
-  for(i=0;i<5;i++){
+  for(i=0;i<6;i++){
     map* tmp=getMap(cconf->content,keywords[i]);
     if(tmp!=NULL){
@@ -98 +104 @@
 
 /**
- * Connect to the db backend.
+ * Create a GDAL / OGR string for connecting to the db backend
+ * 
+ * @param conf the maps containing the setting of the main.cfg file
+ * @return the OGR connection string
+ */
+char* createInitString(maps* conf){
+  return _createInitString(conf,"database");
+}
+
+/**
+ * Connect to a db backend.
  * 
  * @param conf the maps containing the setting of the main.cfg file
  * @see createInitString
  */
-void init_sql(maps* conf){
-  char* sqlInitString=createInitString(conf);
+int _init_sql(maps* conf,const char* key){
+  char* sqlInitString=_createInitString(conf,key);
+#ifdef SQL_DEBUG
+  fprintf(stderr,"Try to connect to: %s %s !\n",key,sqlInitString);
+  fflush(stderr);  
+#endif
+  if(strncmp(sqlInitString,"-1",2)==0)
+    return -1;
   OGRSFDriver *poDriver = NULL;
   OGRRegisterAll();
-
+  int zoo_ds_nb=0;
+  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
+  if(dsNb==NULL){
+    setMapInMaps(conf,"lenv","ds_nb","1");
+  }else{
+    zoo_ds_nb=atoi(dsNb->value);
+    char* tmp=(char*)malloc(11*sizeof(char));
+    sprintf(tmp,"%d",zoo_ds_nb+1);
+    setMapInMaps(conf,"lenv","ds_nb",(const char*)tmp);
+    free(tmp);
+  }
+  if(zoo_DS==NULL)
+    zoo_DS=
 #if GDAL_VERSION_MAJOR >= 2
-  zoo_DS = (GDALDataset*) GDALOpenEx( sqlInitString,
+      (GDALDataset**) malloc(sizeof(GDALDataset*))
+#else
+      (OGRDataSource**) malloc(sizeof(OGRDataSource*))
+#endif
+      ;
+  else
+    zoo_DS=      
+#if GDAL_VERSION_MAJOR >= 2
+      (GDALDataset**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(GDALDataset*))
+#else
+      (OGRDataSource**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(OGRDataSource*))
+#endif
+      ;
+  
+#if GDAL_VERSION_MAJOR >= 2
+  zoo_DS[zoo_ds_nb] = (GDALDataset*) GDALOpenEx( sqlInitString,
                                       GDAL_OF_UPDATE | GDAL_OF_VECTOR,
                                       NULL, NULL, NULL );
 #else
-  zoo_DS = OGRSFDriverRegistrar::Open(sqlInitString,false,&poDriver);
-#endif
-  if( zoo_DS == NULL ){
-#ifdef DEBUG
+  zoo_DS[zoo_ds_nb] = OGRSFDriverRegistrar::Open(sqlInitString,false,&poDriver);
+#endif
+  if( zoo_DS[zoo_ds_nb] == NULL ){
+#ifdef SQL_DEBUG
     fprintf(stderr,"sqlInitString: %s FAILED !\n",sqlInitString);
     fflush(stderr);
 #endif
     free(sqlInitString);
-    setMapInMaps(conf,"lenv","message","Failed to connect to the database backend");
-    return;
-  }
-#ifdef DEBUG
+    setMapInMaps(conf,"lenv","dbIssue","1");
+    setMapInMaps(conf,"lenv","message",_("Failed to connect to the database backend"));
+    return -2;
+  }
+#ifdef SQL_DEBUG
   fprintf(stderr,"sqlInitString: %s SUCEED !\n",sqlInitString);
   fflush(stderr);
 #endif
   free(sqlInitString);
+  zoo_ds_nb++;
+  return zoo_ds_nb;
+}
+
+/**
+ * Connect to the db backend.
+ * 
+ * @param conf the maps containing the setting of the main.cfg file
+ * @see createInitString
+ */
+int init_sql(maps* conf){
+  return _init_sql(conf,"database");
 }
 
@@ -136 +198 @@
  * @param conf the maps containing the setting of the main.cfg file
  */
-void close_sql(maps* conf){
-  if( zoo_ResultSet != NULL )
-    zoo_DS->ReleaseResultSet( zoo_ResultSet );
-  if(zoo_DS!=NULL){
+void close_sql(maps* conf,int cid){
+  if( zoo_ResultSet != NULL ){
+    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
+    zoo_ResultSet=NULL;
+  }
+  if(zoo_DS!=NULL && zoo_DS[cid]!=NULL){
 #if GDAL_VERSION_MAJOR >= 2
-    GDALClose(zoo_DS);
-#else
-    OGRDataSource::DestroyDataSource( zoo_DS );
-#endif
-    zoo_DS=NULL;
+    GDALClose(zoo_DS[cid]);
+#else
+    OGRDataSource::DestroyDataSource( zoo_DS[cid] );
+#endif
+    zoo_DS[cid]=NULL;
   }
 }
@@ -158 +222 @@
 
 /**
+ * Fetch a tuple set by executing a SQL query to the Database Backend.
+ * 
+ * @param conf the maps containing the setting of the main.cfg file
+ * @param sqlQuery the SQL query to run
+ * @return NULL in case of failure or an OGRLayer pointer if the query succeed.
+ */
+OGRLayer *fetchSql(maps* conf,int cid,const char* sqlQuery){
+  if(zoo_DS==NULL || zoo_DS[cid]==NULL)
+    return NULL;
+  OGRLayer *res=NULL;
+#ifdef SQL_DEBUG
+  fprintf(stderr,"************************* %s %s %d\n\n",sqlQuery,__FILE__,__LINE__);
+  fflush(stderr);
+#endif
+  res = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
+  return res;
+}
+
+void cleanFetchSql(maps* conf,int cid,OGRLayer *objects){
+  if( objects != NULL ){
+    zoo_DS[cid]->ReleaseResultSet( objects );
+    objects=NULL;
+  }
+}
+
+/**
  * Execute a SQL query to the SQL Database Backend.
  * 
@@ -164 +254 @@
  * @return -1 in case of failure and 1 if the query succeed.
  */
-int execSql(maps* conf,const char* sqlQuery){
-  zoo_ResultSet = zoo_DS->ExecuteSQL( sqlQuery, NULL, NULL);
+int execSql(maps* conf,int cid,const char* sqlQuery){
+  int res=-1;
+  if(zoo_DS == NULL || zoo_DS[cid]==NULL)
+    return -1;
+  zoo_ResultSet = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
   if( zoo_ResultSet != NULL ){
-    return 1;
-  }
-  return -1;
+    res=1;
+  }
+  return res;
 }
 
@@ -179 +272 @@
  * @return -1 in case of failure and 1 if the query succeed.
  */
-void cleanUpResultSet(const maps* conf){
+void cleanUpResultSet(const maps* conf,int cid){
   if( zoo_ResultSet != NULL ){
-    zoo_DS->ReleaseResultSet( zoo_ResultSet );
+    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
     zoo_ResultSet=NULL;
   }
+}
+
+#ifdef RELY_ON_DB
+int getCurrentId(maps* conf){
+  int res=0;
+  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
+  if(dsNb!=NULL)
+    res=atoi(dsNb->value);
+  return res;
 }
 
@@ -195 +297 @@
  */
 void recordStoredFile(maps* conf,const char* filename,const char* type,const char* name){
+  int zoo_ds_nb=getCurrentId(conf);
   map *uusid=getMapFromMaps(conf,"lenv","usid");
   map *schema=getMapFromMaps(conf,"database","schema");
@@ -202 +305 @@
   else
     sprintf(sqlQuery,"INSERT INTO %s.files (uuid,filename,nature,name) VALUES ('%s','%s','%s',NULL);",schema->value,uusid->value,filename,type);
-  execSql(conf,sqlQuery);
-  free(sqlQuery);
-  cleanUpResultSet(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
 }
 
@@ -213 +316 @@
  */
 void recordServiceStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","sid");
   map *osid=getMapFromMaps(conf,"lenv","osid");
@@ -230 +334 @@
           osid->value,
           wpsStatus[2]);
-  execSql(conf,sqlQuery);
-  free(sqlQuery);
-  cleanUpResultSet(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
 }
 
@@ -242 +346 @@
  */
 void recordResponse(maps* conf,char* filename){
+  int zoo_ds_nb=getCurrentId(conf);
   FILE *file = fopen (filename, "rb");
   fseek (file, 0, SEEK_END);
@@ -254 +359 @@
   char *sqlQuery=(char*)malloc((strlen(schema->value)+flen+strlen(sid->value)+57+1)*sizeof(char));
   sprintf(sqlQuery,"INSERT INTO %s.responses (content,uuid) VALUES ($$%s$$,$$%s$$);",schema->value,tmps,sid->value);
-  execSql(conf,sqlQuery);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   free(sqlQuery);
   free(tmps);
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
 }
 
@@ -267 +372 @@
  */
 int _updateStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","usid");
   map *p=getMapFromMaps(conf,"lenv","status");
@@ -273 +379 @@
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(msg->value)+strlen(p->value)+strlen(sid->value)+64+1)*sizeof(char));
   sprintf(sqlQuery,"UPDATE %s.services set status=$$%s$$,message=$$%s$$ where uuid=$$%s$$;",schema->value,p->value,msg->value,sid->value);
-  fflush(stderr);
-  if( zoo_DS == NULL )
+  if( zoo_DS == NULL || zoo_DS[zoo_ds_nb-1]==NULL ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return 0;
@@ -290 +397 @@
  */
 char* _getStatus(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
+  int created=-1;
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
   sprintf(sqlQuery,"select status||'|'||message from %s.services where uuid=$$%s$$;",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+    created=1;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -301 +419 @@
     for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
       if( poFeature->IsFieldSet( iField ) ){
-        tmp1=strdup(poFeature->GetFieldAsString( iField ));
+        tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
       }
       else
@@ -308 +426 @@
     OGRFeature::DestroyFeature( poFeature );
   }
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return (char*)tmp1;
@@ -321 +439 @@
  */
 char* _getStatusFile(maps* conf,char* pid){
-  map *schema=getMapFromMaps(conf,"database","schema");
+  int zoo_ds_nb=getCurrentId(conf);
+  map *schema=getMapFromMaps(conf,"database","schema");
+  OGRFeature  *poFeature = NULL;
+  const char *tmp1=NULL;
+  int hasRes=-1;
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+82+1)*sizeof(char));
   sprintf(sqlQuery,
           "select content from %s.responses where uuid=$$%s$$"
           " order by creation_time desc limit 1",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
-  OGRFeature  *poFeature = NULL;
-  const char *tmp1;
-  int hasRes=-1;
-  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
-    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
-      if( poFeature->IsFieldSet( iField ) ){
-        tmp1=strdup(poFeature->GetFieldAsString( iField ));
-        hasRes=1;
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  if(zoo_ResultSet!=NULL){
+      while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
+        for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
+          if( poFeature->IsFieldSet( iField ) ){
+            tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
+            hasRes=1;
+          }
+          else
+            tmp1=NULL;
+        }
+        OGRFeature::DestroyFeature( poFeature );
       }
-      else
-        tmp1=NULL;
-    }
-    OGRFeature::DestroyFeature( poFeature );
   }
   if(hasRes<0)
     tmp1=NULL;
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return (char*)tmp1;
@@ -357 +486 @@
  */
 void removeService(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)
     malloc((strlen(pid)+strlen(schema->value)+38+1)
            *sizeof(char));
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
+    zoo_ds_nb++;
+  }
   sprintf(sqlQuery,
           "DELETE FROM %s.services where uuid=$$%s$$;",
           schema->value,pid);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
-  close_sql(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
+  close_sql(conf,zoo_ds_nb-1);
   free(sqlQuery);
   end_sql();
@@ -379 +517 @@
  */
 void unhandleStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   map *sid=getMapFromMaps(conf,"lenv","usid");
@@ -392 +531 @@
           " where uuid=$$%s$$;",
           schema->value,(fstate!=NULL?fstate->value:"Failed"),sid->value);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
-  close_sql(conf);
-  free(sqlQuery);
-  end_sql();
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
+  //close_sql(conf,zoo_ds_nb-1);
+  free(sqlQuery);
+  //end_sql();
 }
 
@@ -407 +546 @@
  */
 char* getStatusId(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
@@ -412 +552 @@
           "select osid from %s.services where uuid=$$%s$$",
           schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==0 ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  if(execSql(conf,zoo_ds_nb-1,sqlQuery)<0)
+    return NULL;
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -431 +574 @@
     tmp1=NULL;
   free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   return (char*)tmp1;
 }
@@ -441 +585 @@
  */
 void readFinalRes(maps* conf,char* pid,map* statusInfo){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
@@ -448 +593 @@
   if( zoo_DS == NULL )
     init_sql(conf);
-  execSql(conf,sqlQuery);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   int hasRes=-1;
@@ -461 +606 @@
     OGRFeature::DestroyFeature( poFeature );
   }
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   if(hasRes<0)
     addToMap(statusInfo,"Status","Failed");
@@ -476 +622 @@
 int isRunning(maps* conf,char* pid){
   int res=0;
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+73+1)*sizeof(char));
   sprintf(sqlQuery,"select count(*) as t from %s.services where uuid=$$%s$$ and end_time is null;",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb == 0 ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -494 +643 @@
     OGRFeature::DestroyFeature( poFeature );
   }
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return res;

trunk/zoo-project/zoo-kernel/sqlapi.h

@@ -25 +25 @@
 #ifndef ZOO_SQLAPI_H
 #define ZOO_SQLAPI_H 1
-#ifdef RELY_ON_DB
+
+#ifdef META_DB
+#include "ogrsf_frmts.h"
+#include "ogr_p.h"
+#if GDAL_VERSION_MAJOR >= 2
+#include <gdal_priv.h>
+#endif
+#endif
+
 #include "service.h"
 #include "service_internal.h"
+
+#ifdef META_DB
+extern "C" 
+#if GDAL_VERSION_MAJOR >=2
+  GDALDataset
+#else
+  OGRDataSource 
+#endif
+  **zoo_DS;
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-  ZOO_DLL_EXPORT void init_sql(maps*);
-  ZOO_DLL_EXPORT void close_sql(maps*);
-  ZOO_DLL_EXPORT int execSql(maps*,const char*);
+
+  
+#ifdef META_DB
+  ZOO_DLL_EXPORT char* _createInitString(maps*,const char*);
+  ZOO_DLL_EXPORT int _init_sql(maps*,const char*);
+  ZOO_DLL_EXPORT OGRLayer *fetchSql(maps*,int,const char*);
+  ZOO_DLL_EXPORT void cleanFetchSql(maps*,int,OGRLayer*);
+#endif
+#ifdef RELY_ON_DB
+  ZOO_DLL_EXPORT int init_sql(maps*);
+  ZOO_DLL_EXPORT void close_sql(maps*,int);
+  ZOO_DLL_EXPORT int execSql(maps*,int,const char*);
   ZOO_DLL_EXPORT void recordStoredFile(maps*,const char*,const char*,const char*);
   ZOO_DLL_EXPORT void recordServiceStatus(maps*);
@@ -42 +69 @@
   ZOO_DLL_EXPORT char* getStatusId(maps*,char*);
   ZOO_DLL_EXPORT void removeService(maps*,char*);
+  ZOO_DLL_EXPORT void end_sql();
+#endif
 
 #ifdef __cplusplus
@@ -48 +77 @@
 
 #endif
-#endif

trunk/zoo-project/zoo-kernel/ulinet.c

@@ -4 +4 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2008-2015 GeoLabs SARL
+ * Copyright (c) 2008-2019 GeoLabs SARL
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -29 +29 @@
 #define MAX_WAIT_MSECS 180*1000 /* Wait max. 180 seconds */
 #include "ulinet.h"
+#include "server_internal.h"
 #include <assert.h>
 #include <ctype.h>
+#include "fcgi_stdio.h"
 
 /**
@@ -69 +71 @@
 
 /**
+ * Write the downloaded content in the file pouted by the _HINTERNET structure
+ *
+ * @param buffer the buffer to read
+ * @param size size of each member
+ * @param nmemb number of element to read
+ * @param data the _HINTERNET structure to write in
+ * @return the size red, -1 if buffer is NULL
+ */
+size_t write_data_into_file(void *buffer, size_t size, size_t nmemb, void *data) 
+{ 
+   size_t realsize = size * nmemb;
+   int writen=0;
+   _HINTERNET *psInternet;
+   if(buffer==NULL){
+     buffer=NULL;
+     return -1;
+   }
+   psInternet=(_HINTERNET *)data;
+   writen+=fwrite(buffer, size, nmemb, psInternet->file);
+   fflush(psInternet->file);
+   psInternet->nDataLen += realsize;
+
+   buffer=NULL;
+   return realsize;
+}
+
+
+/**
  * In case of presence of "Set-Cookie" in the headers red, store the cookie
  * identifier in cookie
@@ -83 +113 @@
     int i;
     char* tmp;
-    int cnt;
-    _HINTERNET *psInternet;
     for(i=0;i<12;i++)
 #ifndef WIN32
@@ -92 +120 @@
 #endif
     tmp=strtok((char*) buffer,";"); // knut: added cast to char*
-    cnt=0;
-    psInternet=(_HINTERNET *)data;
+    int cnt=0;
+    _HINTERNET *psInternet=(_HINTERNET *)data;
     if(tmp!=NULL && psInternet!=NULL){
       psInternet->cookie=(char*)malloc(sizeof(char)*(strlen(tmp)+1));
@@ -211 +239 @@
   HINTERNET ret;
   ret.handle=curl_multi_init();
-  ret.agent=strdup(lpszAgent);
+  ret.agent=zStrdup(lpszAgent);
   ret.nb=0;
+  ret.waitingRequests[ret.nb] = NULL;
   ret.ihandle[ret.nb].header=NULL;
+  ret.ihandle[ret.nb].handle=NULL;
+  ret.ihandle[ret.nb].hasCacheFile=0;
+  ret.ihandle[ret.nb].nDataAlloc = 0;
+  ret.ihandle[ret.nb].url = NULL;
+  ret.ihandle[ret.nb].mimeType = NULL;
+  ret.ihandle[ret.nb].cookie = NULL;
+  ret.ihandle[ret.nb].nDataLen = 0;
+  ret.ihandle[ret.nb].nDataAlloc = 0;
+  ret.ihandle[ret.nb].pabyData = NULL;
+  ret.ihandle[ret.nb].post = NULL;
   return ret;
+}
+
+/**
+ * Verify if the URL should use a shared cache or not.
+ *
+ * In case the security section contains a key named "shared", then if the
+ * domain listed in the shared key are contained in the url given as parameter
+ * then it return "SHARED" in other cases, it returns "OTHER".
+ *
+ * @param conf the main configuration file maps
+ * @param url the URL to evaluate
+ * @return a string "SHARED" in case the host is in a domain listed in the
+ * shared key, "OTHER" in other cases.
+ */
+char* getProvenance(maps* conf,const char* url){
+  map* sharedCache=getMapFromMaps(conf,"security","shared");
+  char *res="OTHER";
+  char *paths[2]={
+    "mapserverAddress",
+    "tmpUrl"
+  };
+  if(sharedCache!=NULL){
+    char *hosts=sharedCache->value;
+    char *curs=strtok(hosts,",");
+    while(curs!=NULL){
+      if(strstr(url,curs)==NULL){
+        return "SHARED";
+      }
+      curs=strtok(NULL,",");
+    }
+  }
+  for(int i=0;i<2;i++){
+    sharedCache=getMapFromMaps(conf,"main",paths[i]);
+    if(sharedCache!=NULL){
+      if(strstr(url,sharedCache->value)!=NULL){
+        return "LOCAL";
+      }
+    }
+  }
+  return res;
 }
 
@@ -244 +323 @@
  * @return 1 if the host is listed as protected, 0 in other case
  */
-int isProtectedHost(const char* protectedHosts,const char* url){
-  char *token, *saveptr;
-  int cnt;
-  char* host; 
-  
-  // knut: make a copy of url since strtok family modifies first argument and cannot be used on constant strings  
-  char* urlcpy = (char*) malloc(sizeof(char)*(strlen(url)+1)); 
-  urlcpy = strncpy(urlcpy, url, strlen(url)+1); // since count > strlen(url), a null character is properly appended
- 
-  //token = strtok_r (url, "//", &saveptr);
-  token = strtok_r (urlcpy, "//", &saveptr);   // knut
-  cnt=0;
-  while(token!=NULL && cnt<=1){
-    fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,token);
-    if(cnt==1)
-      fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,strstr(protectedHosts,token));
-    fflush(stderr);
-    if(cnt==1 && strstr(protectedHosts,token)!=NULL){
-      fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,strstr(protectedHosts,token));
-      free(urlcpy); 
-      return 1;
-    }
-    token = strtok_r (NULL, "/", &saveptr);
-    cnt+=1;
-  }
-  free(urlcpy);
-  return 0;
+int isProtectedHost(const char* protectedHosts, const char* url) {
+        char *token, *saveptr;
+        int cnt;
+        char* host;
+
+        // knut: make a copy of url since strtok family modifies first argument and cannot be used on constant strings  
+        char* urlcpy = (char*)malloc(sizeof(char)*(strlen(url) + 1));
+        urlcpy = strncpy(urlcpy, url, strlen(url) + 1); // since count > strlen(url), a null character is properly appended
+
+        //token = strtok_r (url, "//", &saveptr);
+        token = strtok_r(urlcpy, "//", &saveptr);   // knut
+        cnt = 0;
+        while (token != NULL && cnt <= 1) {
+                fprintf(stderr, "%s %d %s \n", __FILE__, __LINE__, token);
+                if (cnt == 1)
+                        fprintf(stderr, "%s %d %s \n", __FILE__, __LINE__, strstr(protectedHosts, token));
+                fflush(stderr);
+                if (cnt == 1 && strstr(protectedHosts, token) != NULL) {
+                        fprintf(stderr, "%s %d %s \n", __FILE__, __LINE__, strstr(protectedHosts, token));
+                        free(urlcpy);
+                        return 1;
+                }
+                token = strtok_r(NULL, "/", &saveptr);
+                cnt += 1;
+        }
+        free(urlcpy);
+        return 0;
 }
 
@@ -289 +368 @@
   if(passThrough!=NULL && targetHosts!=NULL){
     char *tmp=zStrdup(passThrough->value);
-    char *token, *saveptr;
-    int i;    
-    token = strtok_r (tmp, ",", &saveptr);
+    int i;
     for(i=0;i<handle->nb;i++){
-      if(targetHosts->value[0]=='*' || isProtectedHost(targetHosts->value,handle->ihandle[i].url)==1){
+      if(strstr(targetHosts->value,"*")!=NULL || isProtectedHost(targetHosts->value,handle->ihandle[i].url)==1){
+        char *token, *saveptr;
+        token = strtok_r (tmp, ",", &saveptr);
         while (token != NULL){
-          int j;
-      map* tmpMap;        
           int length=strlen(token)+6;
           char* tmp1=(char*)malloc(length*sizeof(char));
+          map* tmpMap;
           snprintf(tmp1,6,"HTTP_");
+          int j;
           for(j=0;token[j]!='\0';j++){
             if(token[j]!='-')
-              tmp1[5+j]=toupper(token[i]);
+              tmp1[5+j]=toupper(token[j]);
             else
               tmp1[5+j]='_';
             tmp1[5+j+1]='\0';
           }
-          fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,tmp1);
           tmpMap = getMapFromMaps(conf,"renv",tmp1);
-          if(tmpMap!=NULL)          
+          if(tmpMap!=NULL){
             AddMissingHeaderEntry(&handle->ihandle[i],token,tmpMap->value);
-          free(tmp1);
+          }
           if(handle->ihandle[i].header!=NULL)
             curl_easy_setopt(handle->ihandle[i].handle,CURLOPT_HTTPHEADER,handle->ihandle[i].header);
+          free(tmp1);
           cnt+=1;
           token = strtok_r (NULL, ",", &saveptr);
@@ -330 +409 @@
 void InternetCloseHandle(HINTERNET* handle0){
   int i=0;
-  for(i=0;i<handle0->nb;i++){
-    _HINTERNET handle=handle0->ihandle[i];
-    if(handle.hasCacheFile>0){
-      fclose(handle.file);
-      unlink(handle.filename);
-    }
-    else{
-      handle.pabyData = NULL;
-      handle.nDataAlloc = handle.nDataLen = 0;
-    }
-    if(handle0->ihandle[i].header!=NULL){
-      curl_slist_free_all(handle0->ihandle[i].header);
-      handle0->ihandle[i].header=NULL;
-    }
-    if(handle.post!=NULL)
-      free(handle.post);
-    if(handle.url!=NULL)
-      free(handle.url);
-    if(handle.mimeType!=NULL)
-      free(handle.mimeType);
-    if(handle.cookie!=NULL)
-      free(handle.cookie);
-  }
-  if(handle0->handle)
-    curl_multi_cleanup(handle0->handle);
-  free(handle0->agent);
-  for(i=handle0->nb-1;i>=0;i--){
-    free(handle0->waitingRequests[i]);
+  if(handle0!=NULL){
+    for(i=0;i<handle0->nb;i++){
+      _HINTERNET handle=handle0->ihandle[i];
+      if(handle.hasCacheFile>0){
+        fclose(handle.file);
+        unlink(handle.filename);
+        free(handle.filename);
+      }
+      else{
+        handle.pabyData = NULL;
+        handle.nDataAlloc = handle.nDataLen = 0;
+      }
+      if(handle.header!=NULL){
+        curl_slist_free_all(handle.header);
+        handle.header=NULL;
+      }
+      if(handle.post!=NULL){
+        free(handle.post);
+        handle.post=NULL;
+      }
+      if(handle.url!=NULL){
+        free(handle.url);
+        handle.url=NULL;
+      }
+      if(handle.mimeType!=NULL){
+        free(handle.mimeType);
+        handle.mimeType=NULL;
+      }
+      if(handle.cookie!=NULL){
+        free(handle.cookie);
+        handle.cookie=NULL;
+      }
+      if(handle0->waitingRequests[i]!=NULL){
+        free(handle0->waitingRequests[i]);
+        handle0->waitingRequests[i]=NULL;
+      }
+    }
+    if(handle0->handle)
+      curl_multi_cleanup(handle0->handle);
+    if(handle0->agent!=NULL){
+      free(handle0->agent);
+      handle0->agent=NULL;
+    }
   }
 }
@@ -370 +464 @@
  * @param dwFlags desired download mode (INTERNET_FLAG_NO_CACHE_WRITE for not using cache file)
  * @param dwContext not used
- */
-HINTERNET InternetOpenUrl(HINTERNET* hInternet,LPCTSTR lpszUrl,LPCTSTR lpszHeaders,size_t dwHeadersLength,size_t dwFlags,size_t dwContext){
+ * @param conf the main configuration file maps pointer
+ * @return the updated HINTERNET 
+ */
+HINTERNET InternetOpenUrl(HINTERNET* hInternet,LPCTSTR lpszUrl,LPCTSTR lpszHeaders,size_t dwHeadersLength,size_t dwFlags,size_t dwContext,const maps* conf){
 
   char filename[255];
+  int ldwFlags=INTERNET_FLAG_NEED_FILE;
   struct MemoryStruct header;
+  map* memUse=getMapFromMaps((maps*) conf,"main","memory"); // knut: addad cast to maps*
 
   hInternet->ihandle[hInternet->nb].handle=curl_easy_init( );
@@ -407 +505 @@
 #endif
 
-      
-  switch(dwFlags)
+  if(memUse!=NULL && strcasecmp(memUse->value,"load")==0)
+    ldwFlags=INTERNET_FLAG_NO_CACHE_WRITE;
+  
+  switch(ldwFlags)
     {
     case INTERNET_FLAG_NO_CACHE_WRITE:
-      hInternet->ihandle[hInternet->nb].hasCacheFile=-1;
       curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEFUNCTION, write_data_into);
       curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEDATA, (void*)&hInternet->ihandle[hInternet->nb]);
+      hInternet->ihandle[hInternet->nb].hasCacheFile=-1;
       break;
     default:
-      sprintf(hInternet->ihandle[hInternet->nb].filename,"/tmp/ZOO_Cache%d",(int)time(NULL));
-      hInternet->ihandle[hInternet->nb].filename[24]=0;
-#ifdef MSG_LAF_VERBOSE
-      fprintf(stderr,"file=%s",hInternet->ihandle[hInternet->nb].filename);
-#endif
-      hInternet->ihandle[hInternet->nb].filename=filename;
+      memset(filename,0,255);
+      char* tmpUuid=get_uuid();
+      map* tmpPath=NULL;
+      if(conf!=NULL){
+        tmpPath=getMapFromMaps((maps*) conf,"main","tmpPath"); // knut added cast to maps*
+      }
+      if(tmpPath==NULL)
+        sprintf(filename,"/tmp/ZOO_Cache%s", tmpUuid);
+      else
+        sprintf(filename,"%s/ZOO_Cache%s", tmpPath->value,tmpUuid);
+      free(tmpUuid);
+      hInternet->ihandle[hInternet->nb].filename=zStrdup(filename);
       hInternet->ihandle[hInternet->nb].file=fopen(hInternet->ihandle[hInternet->nb].filename,"w+");
-    
       hInternet->ihandle[hInternet->nb].hasCacheFile=1;
-      curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEFUNCTION, NULL);
-      curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEDATA, hInternet->ihandle[hInternet->nb].file);
-      hInternet->ihandle[hInternet->nb].nDataLen=0;
+      curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEFUNCTION, write_data_into_file);
+      curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_WRITEDATA, (void*)&hInternet->ihandle[hInternet->nb]);
       break;
     }
@@ -443 +547 @@
     curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle,CURLOPT_VERBOSE,1);
 #endif
-    hInternet->ihandle[hInternet->nb].post=strdup(lpszHeaders);
+    hInternet->ihandle[hInternet->nb].post=zStrdup(lpszHeaders);
     curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle,CURLOPT_POSTFIELDS,hInternet->ihandle[hInternet->nb].post);
     curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle,CURLOPT_POSTFIELDSIZE,(long)dwHeadersLength);
@@ -457 +561 @@
   hInternet->ihandle[hInternet->nb].header=NULL;
   ++hInternet->nb;
+  hInternet->ihandle[hInternet->nb].header=NULL;
 
 #ifdef ULINET_DEBUG
@@ -472 +577 @@
  */
 int processDownloads(HINTERNET* hInternet){
-  int still_running=0;
+  int still_running=0,numfds;
   int msgs_left=0;
   int i=0;
   do{
-    curl_multi_perform(hInternet->handle, &still_running);
+    CURLMcode mc;
+    mc = curl_multi_perform(hInternet->handle, &still_running);
+    if(mc==CURLM_OK){
+#if LIBCURL_VERSION_MINOR >= 28
+      mc = curl_multi_wait(hInternet->handle, NULL, 0, 1000, &numfds);
+#else
+      struct timeval timeout;
+      fd_set fdread;
+      fd_set fdwrite;
+      fd_set fdexcep;
+      int maxfd = -1;
+
+      long curl_timeo = -1;
+
+      FD_ZERO(&fdread);
+      FD_ZERO(&fdwrite);
+      FD_ZERO(&fdexcep);
+
+      /* set a suitable timeout to play around with */
+      timeout.tv_sec = 1;
+      timeout.tv_usec = 0;
+
+      curl_multi_timeout(hInternet->handle, &curl_timeo);
+      if(curl_timeo >= 0) {
+        timeout.tv_sec = curl_timeo / 1000;
+        if(timeout.tv_sec > 1)
+          timeout.tv_sec = 1;
+        else
+          timeout.tv_usec = (curl_timeo % 1000) * 1000;
+      }
+
+      /* get file descriptors from the transfers */
+      mc = curl_multi_fdset(hInternet->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+#endif
+    }
+    if(mc != CURLM_OK) {
+      fprintf(stderr, "curl_multi failed, code %d.n", mc);
+      break;
+    }
   }while(still_running);  
   for(i=0;i<hInternet->nb;i++){
@@ -482 +625 @@
     curl_easy_getinfo(hInternet->ihandle[i].handle,CURLINFO_CONTENT_TYPE,&tmp);
     if(tmp!=NULL)
-      hInternet->ihandle[i].mimeType=strdup(tmp);
+      hInternet->ihandle[i].mimeType=zStrdup(tmp);
     curl_easy_getinfo(hInternet->ihandle[i].handle,CURLINFO_RESPONSE_CODE,&hInternet->ihandle[i].code);
     curl_multi_remove_handle(hInternet->handle, hInternet->ihandle[i].handle);
@@ -498 +641 @@
  */
 int freeCookieList(HINTERNET hInternet){
-  if(hInternet.ihandle[hInternet.nb].cookie)
-    free(hInternet.ihandle[hInternet.nb].cookie);
-  hInternet.ihandle[hInternet.nb].cookie=NULL;
+  hInternet.ihandle[hInternet.nb].cookie=zStrdup("");
 #ifndef TIGER
   curl_easy_setopt(hInternet.ihandle[hInternet.nb].handle, CURLOPT_COOKIELIST, "ALL");
@@ -522 +663 @@
     fseek (hInternet.file , 0 , SEEK_END);
     dwDataSize=ftell(hInternet.file); //taille du ficher
-    rewind (hInternet.file);
+    //dwDataSize=hInternet.nDataLen;
+    //rewind (hInternet.file);
+    fseek(hInternet.file, 0, SEEK_SET);
   }
   else{
@@ -532 +675 @@
   }
 
-  if( dwNumberOfBytesToRead /* buffer size */ < dwDataSize )
+  if( dwNumberOfBytesToRead /* buffer size */ < dwDataSize ){
     return 0;
+  }
 
 #ifdef MSG_LAF_VERBOSE
-  printf("\nfile size : %dko\n",dwDataSize/1024);
+  fprintf(stderr,"\nfile size : %dko\n",dwDataSize/1024);
 #endif
 
   if(hInternet.hasCacheFile>0){
-    *lpdwNumberOfBytesRead = fread(lpBuffer,1,dwDataSize,hInternet.file); 
+    int freadRes = fread(lpBuffer,dwDataSize+1,1,hInternet.file); 
+    *lpdwNumberOfBytesRead = hInternet.nDataLen;
   }
   else{

trunk/zoo-project/zoo-kernel/ulinet.h

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- *  Copyright 2008-2009 GeoLabs SARL. All rights reserved.
+ *  Copyright 2008-2019 GeoLabs SARL. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26 +26 @@
 #define _ULINET_H
 
-#include "fcgi_stdio.h"
 #include <stdlib.h>
 #include <fcntl.h>
 #include <curl/curl.h>
+#include <curl/curlver.h>
 #include "service.h"
 #ifndef WIN32
@@ -44 +44 @@
 #include "jsapi.h"
 #endif
-/* knut: see new definition of bool in service.h
-#ifndef bool
-#define bool int
+#ifndef __cplusplus
+// knut: see new def of bool in service.h
+//#ifndef bool
+//#define bool int
+//#endif
+//#ifndef true
+//#define true 1
+//#define false 0
+//#endif
 #endif
-#ifndef true
-#define true 1
-#define false 0
-#endif
-*/
 
 #define MAX_REQ 50
@@ -102 +103 @@
   size_t write_data_into(void*,size_t,size_t,void*);
 
+  size_t write_data_into_file(void*,size_t,size_t,void*);
+
   size_t header_write_data(void*,size_t,size_t,void*);
 
@@ -130 +133 @@
   HINTERNET InternetOpen(char*,int,char*,char*,int);
 
+  char* getProvenance(maps*,const char*);
   int isProtectedHost(const char*,const char*);
   int AddMissingHeaderEntry(_HINTERNET*,const char*,const char*);
@@ -153 +157 @@
   typedef size_t* LPDWORD;
 #endif
-/* knut: see new definition of bool in service.h
-#ifndef bool
-#define bool int
-#endif
-*/
+// knut: see new definition of bool in service.h
+//#ifndef bool
+//#define bool int
+//#endif
 
 #  define CHECK_INET_HANDLE(h) (h.handle != 0)
 
-  HINTERNET InternetOpenUrl(HINTERNET*,LPCTSTR,LPCTSTR,size_t,size_t,size_t);
+  HINTERNET InternetOpenUrl(HINTERNET*,LPCTSTR,LPCTSTR,size_t,size_t,size_t,const maps*);
 
   int processDownloads(HINTERNET*);

trunk/zoo-project/zoo-kernel/zoo_loader.c

@@ -65 +65 @@
 #endif
 
+int cgiInit(){
+  fprintf(FCGI_stderr,"ZOO-Kernel initialization %s %d ... \n",__FILE__,__LINE__);
+  fflush(FCGI_stderr);
+  return 0;
+}
+
 /**
  * Main entry point for cgic.
@@ -117 +123 @@
        if(res!=NULL)
          free(res);
-    }else{
+    }else{              
       char *buffer=new char[cgiContentLength+1];
       if(fread(buffer,sizeof(char),cgiContentLength,cgiIn)>0){
@@ -157 +163 @@
     }   
   }
-  else{
+  else{   
 #ifdef DEBUG
     dumpMap(tmpMap);
@@ -181 +187 @@
     cgiStringArrayFree(array);
   }
-
+ 
 #ifdef WIN32
-  map *tmpReq=getMap(tmpMap,"rfile");
-  if(tmpReq!=NULL){
-    FILE *lf=fopen(tmpReq->value,"r");
+  map *tmpReq=getMap(tmpMap,"rfile");  
+  if(tmpReq!=NULL){               
+    FILE *lf=fopen(tmpReq->value,"r");  
     fseek(lf,0,SEEK_END);
     long flen=ftell(lf);
@@ -389 +395 @@
     }
   }
-
+  
   if(strncasecmp(cgiContentType,"multipart/form-data",19)==0){
     map* tmp=getMap(tmpMap,"dataInputs");
@@ -402 +408 @@
   if(strQuery!=NULL)
     free(strQuery);
-
+  
   runRequest(&tmpMap);
 

trunk/zoo-project/zoo-kernel/zoo_service_loader.c

@@ -26 +26 @@
 extern "C" int crlex ();
 
+#ifdef META_DB
+#include "ogrsf_frmts.h"
+#if GDAL_VERSION_MAJOR >= 2
+#include <gdal_priv.h>
+#endif
+#endif
+
 #ifdef USE_OTB
 #include "service_internal_otb.h"
+#endif
+
+#ifdef USE_R
+#include "service_internal_r.h"
+#endif
+
+#ifdef USE_HPC
+#include "service_internal_hpc.h"
 #endif
 
@@ -55 +70 @@
 #endif
 
+#ifdef META_DB
+#include "meta_sql.h"
+#endif
+
 #ifdef USE_PYTHON
 #include "service_internal_python.h"
@@ -87 +106 @@
 #endif
 
+#ifdef USE_CALLBACK
+#include "service_json.h"
+#include "service_callback.h"
+#endif
+
 #include <dirent.h>
 #include <signal.h>
+#ifndef WIN32
+#include <execinfo.h>
+#endif
 #include <unistd.h>
 #ifndef WIN32
@@ -105 +132 @@
 #include <stdarg.h>
 
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <libxslt/xsltutils.h>
+
 #ifndef WIN32
 extern char **environ;
+#endif
+
+
+#ifdef WIN32
+extern "C"
+{
+  __declspec (dllexport) char *strcasestr (char const *a, char const *b)
+#ifndef USE_MS
+  {
+    char *x = zStrdup (a);
+    char *y = zStrdup (b);
+
+      x = _strlwr (x);
+      y = _strlwr (y);
+    char *pos = strstr (x, y);
+    char *ret = pos == NULL ? NULL : (char *) (a + (pos - x));
+      free (x);
+      free (y);
+      return ret;
+  };
+#else
+   ;
+#endif
+}
 #endif
 
@@ -119 +180 @@
 
 #ifdef WIN32
-  #ifndef PROGRAMNAME
-    #define PROGRAMNAME "zoo_loader.cgi"
-  #endif
+#ifndef PROGRAMNAME
+#define PROGRAMNAME "zoo_loader.cgi"
+#endif
 #endif
 
@@ -159 +220 @@
   lockShm (lid);
 #endif
-  FILE *f3 = fopen (fbkp, "wb+");  
-  free (fbkp);  
+  FILE *f3 = fopen (fbkp, "wb+");
+  free (fbkp);
   fseek (f2, 0, SEEK_END);
   long flen = ftell (f2);
   fseek (f2, 0, SEEK_SET);
   char *tmps1 = (char *) malloc ((flen + 1) * sizeof (char));
-  fread (tmps1, flen, 1, f2);  
+  fread (tmps1, flen, 1, f2);
 #ifdef WIN32
   /* knut: I think this block can be dropped; pchr may be NULL if result is not in XML format
-  char *pchr=strrchr(tmps1,'>');   
-  flen=strlen(tmps1)-strlen(pchr)+1;  
-  tmps1[flen]=0;  
+  char *pchr=strrchr(tmps1,'>');
+  flen=strlen(tmps1)-strlen(pchr)+1;
+  tmps1[flen]=0;
   */
-#endif  
+#endif
   fwrite (tmps1, 1, flen, f3);
+  fclose (f2);
+  fclose (f3);
   free(tmps1);
-  fclose (f2);
-  fclose (f3);  
   return 1;
 }
@@ -197 +258 @@
  */
 int
-recursReaddirF ( maps * m, registry *r, xmlNodePtr n, char *conf_dir, 
+recursReaddirF ( maps * m, registry *r, xmlDocPtr doc, xmlNodePtr n, char *conf_dir, 
                  char *prefix, int saved_stdout, int level, 
-                 void (func) (registry *, maps *, xmlNodePtr, service *) )
+                 void (func) (registry *, maps *, xmlDocPtr, xmlNodePtr, service *) )
 {
   struct dirent *dp;
@@ -246 +307 @@
             setMapInMaps (m, "lenv", "level", levels1);
             res =
-              recursReaddirF (m, r, n, tmp, prefix, saved_stdout, level + 1,
+              recursReaddirF (m, r, doc, n, tmp, prefix, saved_stdout, level + 1,
                               func);
             sprintf (levels1, "%d", level);
@@ -264 +325 @@
       {
         char* extn = strstr(dp->d_name, ".zcfg");
-        if(dp->d_name[0] != '.' && extn != NULL && strlen(extn) == 5)
+        if(dp->d_name[0] != '.' && extn != NULL && strlen(extn) == 5 && strlen(dp->d_name)>6)
           {
             int t;
@@ -271 +332 @@
             snprintf (tmps1, 1024, "%s/%s", conf_dir, dp->d_name);
 
-            char *tmpsn = zStrdup (dp->d_name);
-            tmpsn[strlen (tmpsn) - 5] = 0;
+            char *tmpsn = (char*)malloc((strlen(dp->d_name)-4)*sizeof(char));//zStrdup (dp->d_name);
+            memset (tmpsn, 0, strlen(dp->d_name)-4);
+            snprintf(tmpsn,strlen(dp->d_name)-4,"%s",dp->d_name);
             
             map* import = getMapFromMaps (m, IMPORTSERVICE, tmpsn);
             if (import == NULL || import->value == NULL || zoo_path_compare(tmps1, import->value) != 0 ) { // service is not in [include] block 
-              service *s1 = (service *) malloc (SERVICE_SIZE);
+              service *s1 = createService();
               if (s1 == NULL)
                 {
-                  dup2 (saved_stdout, fileno (stdout));
+                  zDup2 (saved_stdout, fileno (stdout));
                   errorException (m, _("Unable to allocate memory"),
                                   "InternalError", NULL);
@@ -300 +362 @@
                     sprintf (tmp01, _("Unable to parse the ZCFG file: %s."),
                              dp->d_name);
-                  dup2 (saved_stdout, fileno (stdout));
+                  zDup2 (saved_stdout, fileno (stdout));
                   errorException (m, tmp01, "InternalError", NULL);
                   return -1;
@@ -309 +371 @@
               fflush (stderr);
   #endif
-        inheritance(r,&s1);
-              func (r, m, n, s1);
+              if(s1!=NULL)
+                inheritance(r,&s1);
+              func (r, m, doc, n, s1);
               freeService (&s1);
               free (s1);
@@ -344 +407 @@
 sig_handler (int sig)
 {
+  
   char tmp[100];
   const char *ssig;
@@ -372 +436 @@
   sprintf (tmp,
            _
-           ("ZOO Kernel failed to process your request, receiving signal %d = %s"),
+           ("ZOO Kernel failed to process your request, receiving signal %d = %s "),
            sig, ssig);
   errorException (NULL, tmp, "InternalError", NULL);
@@ -420 +484 @@
 #endif
 
-  map* libp = getMapFromMaps(m, "main", "libPath");
-
+  map* libp = getMapFromMaps(m, "main", "libPath");  
   if (strlen (r_inputs->value) == 1
       && strncasecmp (r_inputs->value, "C", 1) == 0)
@@ -610 +673 @@
   else
 
+#ifdef USE_HPC
+  if (strncasecmp (r_inputs->value, "HPC", 3) == 0)
+    {
+      *eres =
+        zoo_hpc_support (&m, request_inputs, s1,
+                            &request_input_real_format,
+                            &request_output_real_format);
+    }
+  else
+#endif
+
 #ifdef USE_SAGA
-  if (strncasecmp (r_inputs->value, "SAGA", 6) == 0)
+  if (strncasecmp (r_inputs->value, "SAGA", 4) == 0)
     {
       *eres =
@@ -622 +696 @@
 
 #ifdef USE_OTB
-  if (strncasecmp (r_inputs->value, "OTB", 6) == 0)
+  if (strncasecmp (r_inputs->value, "OTB", 3) == 0)
     {
       *eres =
@@ -633 +707 @@
 #ifdef USE_PYTHON
   if (strncasecmp (r_inputs->value, "PYTHON", 6) == 0)
+    {             
+      *eres =
+        zoo_python_support (&m, request_inputs, s1,
+                            &request_input_real_format,
+                            &request_output_real_format);         
+    }
+  else
+#endif
+
+#ifdef USE_R
+  if (strncasecmp (r_inputs->value, "R", 6) == 0)
     {     
       *eres =
-        zoo_python_support (&m, request_inputs, s1,
+        zoo_r_support (&m, request_inputs, s1,
                             &request_input_real_format,
                             &request_output_real_format);
@@ -713 +798 @@
     }
   *myMap = m;
-  *ioutputs = request_output_real_format;
+  *ioutputs = request_output_real_format;  
 }
 
@@ -902 +987 @@
 #endif
 
+  
   map *r_inputs = NULL;
   map *request_inputs = *inputs;
+  //fprintf(stderr,"%s \n",json_object_to_json_string_ext(mapToJson(request_inputs),JSON_C_TO_STRING_PLAIN));
+  
 #ifdef IGNORE_METAPATH
   addToMap(request_inputs, "metapath", "");
@@ -935 +1023 @@
 #ifdef ETC_DIR
 #ifndef WIN32
-    getcwd (ntmp, 1024);
+  getcwd (ntmp, 1024);
 #else
-    _getcwd (ntmp, 1024);
+  _getcwd (ntmp, 1024);
 #endif
 #endif
@@ -1013 +1101 @@
       char tmp1[13];
       sprintf (tmp1, "LC_ALL=%s", tmp);
-      putenv (tmp1);
+      _putenv (tmp1);
 #endif
       free (tmp);
@@ -1025 +1113 @@
       char tmp1[13];
       sprintf (tmp1, "LC_ALL=en_US");
-      putenv (tmp1);
+      _putenv (tmp1);
 #endif
       setMapInMaps (m, "main", "language", "en-US");
@@ -1035 +1123 @@
   char tmp1[17];
   sprintf (tmp1, "LC_NUMERIC=C");
-  putenv (tmp1);
+  _putenv (tmp1);
 #endif
   bind_textdomain_codeset ("zoo-kernel", "UTF-8");
@@ -1127 +1215 @@
   };
   r_inputs = getMap (request_inputs, "Request");
-  REQUEST = zStrdup (r_inputs->value);
+  if(r_inputs!=NULL)
+    REQUEST = zStrdup (r_inputs->value);
   int reqId=-1;
   if (strncasecmp (REQUEST, "GetCapabilities", 15) != 0){
@@ -1134 +1223 @@
     for(j=0;j<nbSupportedRequests;j++){
       if(requests[vid][j]!=NULL && requests[vid][j+1]!=NULL){
-        if(j<nbReqIdentifier && strncasecmp(REQUEST,requests[vid][j+1],strlen(REQUEST))==0){
+        if(j<nbReqIdentifier && strncasecmp(REQUEST,requests[vid][j+1],strlen(requests[vid][j+1]))==0){
           checkValidValue(request_inputs,&err,"identifier",NULL,1);
           reqId=j+1;
@@ -1141 +1230 @@
         else
           if(j>=nbReqIdentifier && j<nbReqIdentifier+nbReqJob && 
-             strncasecmp(REQUEST,requests[vid][j+1],strlen(REQUEST))==0){
+             strncasecmp(REQUEST,requests[vid][j+1],strlen(requests[vid][j+1]))==0){
             checkValidValue(request_inputs,&err,"jobid",NULL,1);
             reqId=j+1;
@@ -1217 +1306 @@
   registry* zooRegistry=NULL;
   if(reg!=NULL){
-    int saved_stdout = dup (fileno (stdout));
-    dup2 (fileno (stderr), fileno (stdout));
+#ifndef WIN32
+    int saved_stdout = zDup (fileno (stdout));
+    zDup2 (fileno (stderr), fileno (stdout));
+#endif
     if(createRegistry (m,&zooRegistry,reg->value)<0){
       map *message=getMapFromMaps(m,"lenv","message");
       map *type=getMapFromMaps(m,"lenv","type");
-      dup2 (saved_stdout, fileno (stdout));
+#ifndef WIN32
+      zDup2 (saved_stdout, fileno (stdout));
+#endif
       errorException (m, message->value,
                       type->value, NULL);
       return 0;
     }
-    dup2 (saved_stdout, fileno (stdout));
-    close(saved_stdout);
+#ifndef WIN32
+    zDup2 (saved_stdout, fileno (stdout));
+    zClose(saved_stdout);
+#endif
   }
 
@@ -1242 +1337 @@
        * has been found in the zcfg and then printed on stdout
        */
-      int saved_stdout = dup (fileno (stdout));
-      dup2 (fileno (stderr), fileno (stdout));
+      int saved_stdout = zDup (fileno (stdout));
+      zDup2 (fileno (stderr), fileno (stdout));
 
       maps* imports = getMaps(m, IMPORTSERVICE);
@@ -1258 +1353 @@
             }
             inheritance(zooRegistry, &svc);
-            printGetCapabilitiesForProcess(zooRegistry, m, n, svc);
+            printGetCapabilitiesForProcess(zooRegistry, m, doc, n, svc);
             freeService(&svc);
             free(svc);                             
@@ -1267 +1362 @@
 
       if (int res =               
-          recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
+          recursReaddirF (m, zooRegistry, doc, n, conf_dir, NULL, saved_stdout, 0,
                           printGetCapabilitiesForProcess) < 0)
         {
@@ -1282 +1377 @@
         }
       fflush (stdout);
-      dup2 (saved_stdout, fileno (stdout));
-      printDocument (m, doc, getpid ());
+      zDup2 (saved_stdout, fileno (stdout));
+#ifdef META_DB
+      fetchServicesFromDb(zooRegistry,m,doc,n,printGetCapabilitiesForProcess,1);
+      close_sql(m,0);
+#endif      
+      printDocument (m, doc, zGetpid ());
       freeMaps (&m);
       free (m);
@@ -1299 +1398 @@
       r_inputs = getMap (request_inputs, "JobId");
       if(reqId>nbReqIdentifier){
-        if (strncasecmp (REQUEST, "GetStatus", strlen(REQUEST)) == 0 ||
-            strncasecmp (REQUEST, "GetResult", strlen(REQUEST)) == 0){
+        if (strncasecmp (REQUEST, "GetStatus", 9) == 0 ||
+            strncasecmp (REQUEST, "GetResult", 9) == 0){
           runGetStatus(m,r_inputs->value,REQUEST);
+#ifdef RELY_ON_DB
+          map* dsNb=getMapFromMaps(m,"lenv","ds_nb");
+          if(dsNb!=NULL && atoi(dsNb->value)>1)
+            close_sql(m,1);
+          close_sql(m,0);
+#endif
+          
           freeMaps (&m);
-          free (m);
+          free(m);
           if(zooRegistry!=NULL){
             freeRegistry(&zooRegistry);
@@ -1355 +1461 @@
             r_inputs = NULL;
             r_inputs = getMap (request_inputs, "version");
+#ifdef DEBUG
+            fprintf(stderr," ** DEBUG %s %d \n",__FILE__,__LINE__);
+            fflush(stderr);
+#endif
             xmlNodePtr n = printWPSHeader(doc,m,"DescribeProcess",
                                           root_nodes[vid][1],(version!=NULL?version->value:"1.0.0"),1);
@@ -1362 +1472 @@
             char *orig = zStrdup (r_inputs->value);
 
-            int saved_stdout = dup (fileno (stdout));
-            dup2 (fileno (stderr), fileno (stdout));
+            int saved_stdout = zDup (fileno (stdout));
+            zDup2 (fileno (stderr), fileno (stdout));
             if (strcasecmp ("all", orig) == 0)
               {
@@ -1379 +1489 @@
                       }
                       inheritance(zooRegistry, &svc);
-                      printDescribeProcessForProcess(zooRegistry, m, n, svc);
+#ifdef USE_HPC
+                      addNestedOutputs(&svc);
+#endif
+
+                      printDescribeProcessForProcess(zooRegistry, m, doc, n, svc);
                       freeService(&svc);
                       free(svc);                             
@@ -1388 +1502 @@
   
                 if (int res =
-                    recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
+                    recursReaddirF (m, zooRegistry, doc, n, conf_dir, NULL, saved_stdout, 0,
                                     printDescribeProcessForProcess) < 0)
                   return res;
+#ifdef META_DB
+                fetchServicesFromDb(zooRegistry,m,doc,n,printDescribeProcessForProcess,0);
+                close_sql(m,0);
+#endif      
+
               }
             else
@@ -1406 +1525 @@
                     if (import != NULL && import->value != NULL) 
                       {
-                        s1 = (service *) malloc (SERVICE_SIZE);
-                        t = readServiceFile (m, import->value, &s1, import->name);
+#ifdef META_DB                  
+                        service* s2=extractServiceFromDb(m,import->name,0);
+                        if(s2==NULL){
+#endif
+                          s1 = createService();
+                          t = readServiceFile (m, import->value, &s1, import->name);
                 
-                        if (t < 0) // failure reading zcfg
-                          {
-                            map *tmp00 = getMapFromMaps (m, "lenv", "message");
-                            char tmp01[1024];
-                            if (tmp00 != NULL)
-                              sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"), import->value, tmp00->value);
-                            else
-                              sprintf (tmp01, _("Unable to parse the ZCFG file: %s."), import->value);
-
-                            dup2 (saved_stdout, fileno (stdout));
-                            errorException (m, tmp01, "InternalError", NULL);
-            
-                            freeMaps (&m);
-                            free (m);
-
-                            if(zooRegistry!=NULL){
-                              freeRegistry(&zooRegistry);
-                              free(zooRegistry);
+                          if (t < 0) // failure reading zcfg
+                            {
+                              map *tmp00 = getMapFromMaps (m, "lenv", "message");
+                              char tmp01[1024];
+                              if (tmp00 != NULL)
+                                sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"), import->value, tmp00->value);
+                              else
+                                sprintf (tmp01, _("Unable to parse the ZCFG file: %s."), import->value);
+                              
+                              zDup2 (saved_stdout, fileno (stdout));
+                              errorException (m, tmp01, "InternalError", NULL);
+                              
+                              freeMaps (&m);
+                              free (m);
+
+                              if(zooRegistry!=NULL){
+                                freeRegistry(&zooRegistry);
+                                free(zooRegistry);
+                              }
+                              free (orig);
+                              free (REQUEST);
+                              closedir (dirp);
+                              //xmlFreeDoc (doc);
+                              xmlCleanupParser ();
+                              zooXmlCleanupNs ();
+                    
+                              return 1;
                             }
-                            free (orig);
-                            free (REQUEST);
-                            closedir (dirp);
-                            xmlFreeDoc (doc);
-                            xmlCleanupParser ();
-                            zooXmlCleanupNs ();
-                    
-                            return 1;
-                          }
-#ifdef DEBUG
-                        dumpService (s1);
-#endif
-
-                        inheritance(zooRegistry,&s1);
-                        printDescribeProcessForProcess (zooRegistry,m, n, s1);
-                        freeService (&s1);
-                        free (s1);
-                        s1 = NULL;
-                        scount++;
-                        hasVal = 1;                
-                    }
+#ifdef DEBUG
+                          dumpService (s1);
+#endif
+                          inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+                          addNestedOutputs(&s1);
+#endif
+                          printDescribeProcessForProcess (zooRegistry, m, doc, n, s1);
+                          freeService (&s1);
+                          free (s1);
+                          s1 = NULL;
+                          scount++;
+                          hasVal = 1;                
+#ifdef META_DB
+                        }
+#endif
+                      }
                     else if (strstr (corig, ".") != NULL)
                       {
@@ -1457 +1585 @@
                           addToMap (request_inputs, "metapath", tmpMap->value);
                         map *tmpMapI = getMapFromMaps (m, "lenv", "Identifier");
-
-                        s1 = (service *) malloc (SERVICE_SIZE);
+                        /**
+                         * No support for dot in service name stored in metadb!?
+                         #ifdef META_DB
+                         service* s2=extractServiceFromDb(m,tmpMapI->value,0);
+                         if(s2==NULL){
+                         #endif
+                        */
+                        s1 = createService();
                         t = readServiceFile (m, buff1, &s1, tmpMapI->value);
                         if (t < 0)
@@ -1474 +1608 @@
                                        ("Unable to parse the ZCFG file for the following ZOO-Service: %s."),
                                        tmps);
-                            dup2 (saved_stdout, fileno (stdout));
+                            zDup2 (saved_stdout, fileno (stdout));
                             errorException (m, tmp01, "InvalidParameterValue",
                                             "identifier");
@@ -1489 +1623 @@
                             free (s1);
                             closedir (dirp);
-                            xmlFreeDoc (doc);
+                            //xmlFreeDoc (doc);
                             xmlCleanupParser ();
                             zooXmlCleanupNs ();
@@ -1498 +1632 @@
 #endif
                         inheritance(zooRegistry,&s1);
-                        printDescribeProcessForProcess (zooRegistry,m, n, s1);
+#ifdef USE_HPC
+                        addNestedOutputs(&s1);
+#endif
+                        printDescribeProcessForProcess (zooRegistry, m, doc, n, s1);
                         freeService (&s1);
                         free (s1);
@@ -1508 +1645 @@
                     else
                       {
-                        memset (buff, 0, 256);
-                        snprintf (buff, 256, "%s.zcfg", corig);
-                        memset (buff1, 0, 1024);
-#ifdef DEBUG
-                        printf ("\n#######%s\n########\n", buff);
-#endif
-                        while ((dp = readdir (dirp)) != NULL)
-                          {
-                            if (strcasecmp (dp->d_name, buff) == 0)
-                              {
-                                memset (buff1, 0, 1024);
-                                snprintf (buff1, 1024, "%s/%s", conf_dir,
-                                          dp->d_name);
-                                s1 = (service *) malloc (SERVICE_SIZE);
-                                if (s1 == NULL)
-                                  {
-                                    dup2 (saved_stdout, fileno (stdout));
-                                    return errorException (m,
-                                                           _
-                                                           ("Unable to allocate memory"),
-                                                           "InternalError",
-                                                           NULL);
-                                  }
+#ifdef META_DB
+                        _init_sql(m,"metadb");
+                        //FAILED CONNECTING DB
+                        if(getMapFromMaps(m,"lenv","dbIssue")!=NULL){
+                          fprintf(stderr,"ERROR CONNECTING METADB");
+                        }
+                        service* s2=extractServiceFromDb(m,corig,0);
+                        if(s2!=NULL){
+                          inheritance(zooRegistry,&s2);
+#ifdef USE_HPC
+                          addNestedOutputs(&s2);
+#endif
+                          printDescribeProcessForProcess (zooRegistry,m, doc, n, s2);
+                          freeService (&s2);
+                          free (s2);
+                          s2 = NULL;
+                          hasVal = 1;
+                        }else /*TOTO*/{
+#endif
+                          memset (buff, 0, 256);
+                          snprintf (buff, 256, "%s.zcfg", corig);
+                          memset (buff1, 0, 1024);
+#ifdef DEBUG
+                          printf ("\n#######%s\n########\n", buff);
+#endif
+                          while ((dp = readdir (dirp)) != NULL)
+                            {
+                              if (strcasecmp (dp->d_name, buff) == 0)
+                                {
+                                  memset (buff1, 0, 1024);
+                                  snprintf (buff1, 1024, "%s/%s", conf_dir,
+                                            dp->d_name);
+                                  s1 = createService();
+                                  if (s1 == NULL)
+                                    {
+                                      zDup2 (saved_stdout, fileno (stdout));
+                                      return errorException (m,
+                                                             _
+                                                             ("Unable to allocate memory"),
+                                                             "InternalError",
+                                                             NULL);
+                                    }
 #ifdef DEBUG_SERVICE_CONF
-                                fprintf
-                                  (stderr,"#################\n(%s) %s\n#################\n",
-                                   r_inputs->value, buff1);
-#endif
-                                char *tmp0 = zStrdup (dp->d_name);
-                                tmp0[strlen (tmp0) - 5] = 0;
-                                t = readServiceFile (m, buff1, &s1, tmp0);
-                                free (tmp0);
-                                if (t < 0)
-                                  {
-                                    map *tmp00 =
-                                      getMapFromMaps (m, "lenv", "message");
-                                    char tmp01[1024];
-                                    if (tmp00 != NULL)
-                                      sprintf (tmp01,
-                                               _
-                                               ("Unable to parse the ZCFG file: %s (%s)"),
-                                               dp->d_name, tmp00->value);
-                                    else
-                                      sprintf (tmp01,
-                                               _
-                                               ("Unable to parse the ZCFG file: %s."),
-                                               dp->d_name);
-                                    dup2 (saved_stdout, fileno (stdout));
-                                    errorException (m, tmp01, "InternalError",
-                                                    NULL);
-                                    freeMaps (&m);
-                                    free (m);
-                                    if(zooRegistry!=NULL){
-                                      freeRegistry(&zooRegistry);
-                                      free(zooRegistry);
+                                  fprintf
+                                    (stderr,"#################\n(%s) %s\n#################\n",
+                                     r_inputs->value, buff1);
+#endif
+                                  char *tmp0 = zStrdup (dp->d_name);
+                                  tmp0[strlen (tmp0) - 5] = 0;
+                                  t = readServiceFile (m, buff1, &s1, tmp0);
+                                  free (tmp0);
+                                  if (t < 0)
+                                    {
+                                      map *tmp00 =
+                                        getMapFromMaps (m, "lenv", "message");
+                                      char tmp01[1024];
+                                      if (tmp00 != NULL)
+                                        sprintf (tmp01,
+                                                 _
+                                                 ("Unable to parse the ZCFG file: %s (%s)"),
+                                                 dp->d_name, tmp00->value);
+                                      else
+                                        sprintf (tmp01,
+                                                 _
+                                                 ("Unable to parse the ZCFG file: %s."),
+                                                 dp->d_name);
+                                      zDup2 (saved_stdout, fileno (stdout));
+                                      errorException (m, tmp01, "InternalError",
+                                                      NULL);
+                                      freeMaps (&m);
+                                      free (m);
+                                      if(zooRegistry!=NULL){
+                                        freeRegistry(&zooRegistry);
+                                        free(zooRegistry);
+                                      }
+                                      free (orig);
+                                      free (REQUEST);
+                                      closedir (dirp);
+                                      //xmlFreeDoc (doc);
+                                      xmlCleanupParser ();
+                                      zooXmlCleanupNs ();
+                                      return 1;
                                     }
-                                    free (orig);
-                                    free (REQUEST);
-                                    closedir (dirp);
-                                    xmlFreeDoc (doc);
-                                    xmlCleanupParser ();
-                                    zooXmlCleanupNs ();
-                                    return 1;
-                                  }
-#ifdef DEBUG
-                                dumpService (s1);
-#endif
-                                inheritance(zooRegistry,&s1);
-                                printDescribeProcessForProcess (zooRegistry,m, n, s1);
-                                freeService (&s1);
-                                free (s1);
-                                s1 = NULL;
-                                scount++;
-                                hasVal = 1;
-                              }
-                          }
-                      }
+#ifdef DEBUG
+                                  dumpService (s1);
+#endif
+                                  inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+                                  addNestedOutputs(&s1);
+#endif
+                                  /*json_object* jobj=serviceToJson(s1);
+                                  const char* jsonStr=json_object_to_json_string_ext(jobj,JSON_C_TO_STRING_PLAIN);
+                                  fprintf(stderr,"*** %s %d %s \n",__FILE__,__LINE__,jsonStr);*/
+
+                                  printDescribeProcessForProcess (zooRegistry,m, doc, n, s1);
+                                  freeService (&s1);
+                                  free (s1);
+                                  s1 = NULL;
+                                  scount++;
+                                  hasVal = 1;
+                                }
+                            }
+#ifdef META_DB
+                        }
+#endif
+                      }               
                     if (hasVal < 0)
                       {
@@ -1597 +1763 @@
                                    _("Unable to parse the ZCFG file: %s."),
                                    buff);
-                        dup2 (saved_stdout, fileno (stdout));
+                        zDup2 (saved_stdout, fileno (stdout));
                         errorException (m, tmp01, "InvalidParameterValue",
                                         "Identifier");
@@ -1609 +1775 @@
                         free (REQUEST);
                         closedir (dirp);
+                        if (corig != NULL)
+                          free (corig);
                         xmlFreeDoc (doc);
                         xmlCleanupParser ();
@@ -1618 +1786 @@
                     if (corig != NULL)
                       free (corig);
-                  }
+                  }               
               }
             closedir (dirp);
             fflush (stdout);
-            dup2 (saved_stdout, fileno (stdout));
+            zDup2 (saved_stdout, fileno (stdout));
             free (orig);
-            printDocument (m, doc, getpid ());
+            printDocument (m, doc, zGetpid ());
             freeMaps (&m);
             free (m);
@@ -1634 +1802 @@
             free (SERVICE_URL);
             fflush (stdout);
+#ifdef META_DB
+            close_sql(m,0);
+            //end_sql();
+#endif
             return 0;
           }
@@ -1640 +1812 @@
             map* version=getMapFromMaps(m,"main","rversion");
             int vid=getVersionId(version->value);           
-                int len = 0;
-                int j = 0;
+            int len = 0;
+            int j = 0;
             for(j=0;j<nbSupportedRequests;j++){
               if(requests[vid][j]!=NULL)
@@ -1712 +1884 @@
   }
   s1 = NULL;
-  s1 = (service *) malloc (SERVICE_SIZE);
-  if (s1 == NULL)
-    {
-      freeMaps (&m);
-      free (m);
-      if(zooRegistry!=NULL){
-        freeRegistry(&zooRegistry);
-        free(zooRegistry);
-      }
-      free (REQUEST);
-      free (SERVICE_URL);
-      return errorException (m, _("Unable to allocate memory"),
-                             "InternalError", NULL);
-    }
-
+ 
   r_inputs = getMap (request_inputs, "Identifier");
-
   map* import = getMapFromMaps (m, IMPORTSERVICE, r_inputs->value); 
   if (import != NULL && import->value != NULL) { 
-      strncpy(tmps1, import->value, 1024);
-      setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
-      setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
+    strncpy(tmps1, import->value, 1024);
+    setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
+    setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
   } 
   else {
@@ -1757 +1914 @@
 
   r_inputs = getMapFromMaps (m, "lenv", "Identifier");
-  int saved_stdout = dup (fileno (stdout));
-  dup2 (fileno (stderr), fileno (stdout));
-  t = readServiceFile (m, tmps1, &s1, r_inputs->value);
-  inheritance(zooRegistry,&s1);
-  if(zooRegistry!=NULL){
-    freeRegistry(&zooRegistry);
-    free(zooRegistry);
+  
+#ifdef META_DB
+  int metadb_id=_init_sql(m,"metadb");
+  //FAILED CONNECTING DB
+  if(getMapFromMaps(m,"lenv","dbIssue")!=NULL || metadb_id<0){
+    fprintf(stderr,"ERROR CONNECTING METADB\n");
   }
-  fflush (stdout);
-  dup2 (saved_stdout, fileno (stdout));
-  if (t < 0)
-    {
-      char *tmpMsg = (char *) malloc (2048 + strlen (r_inputs->value));
-      sprintf (tmpMsg,
-               _
-               ("The value for <identifier> seems to be wrong (%s). Please specify one of the processes in the list returned by a GetCapabilities request."),
-               r_inputs->value);
-      errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
-      free (tmpMsg);
-      free (s1);
-      freeMaps (&m);
-      free (m);
-      free (REQUEST);
-      free (SERVICE_URL);
-      return 0;
-    }
-  close (saved_stdout);
-
+  if(metadb_id>=0)
+    s1=extractServiceFromDb(m,r_inputs->value,0);
+  //close_sql(m,0);
+  if(s1!=NULL){
+    inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+    addNestedOutputs(&s1);
+#endif
+    if(zooRegistry!=NULL){
+      freeRegistry(&zooRegistry);
+      free(zooRegistry);
+    }
+  }else /* Not found in MetaDB */{
+#endif
+    s1 = createService();
+    if (s1 == NULL)
+      {
+        freeMaps (&m);
+        free (m);
+        if(zooRegistry!=NULL){
+          freeRegistry(&zooRegistry);
+          free(zooRegistry);
+        }
+        free (REQUEST);
+        free (SERVICE_URL);
+        return errorException (m, _("Unable to allocate memory"),
+                               "InternalError", NULL);
+      }
+
+    int saved_stdout = zDup (fileno (stdout));
+    zDup2 (fileno (stderr), fileno (stdout));
+    t = readServiceFile (m, tmps1, &s1, r_inputs->value);
+    if(t>=0){
+      inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+      addNestedOutputs(&s1);
+#endif
+    }
+    if(zooRegistry!=NULL){
+      freeRegistry(&zooRegistry);
+      free(zooRegistry);
+    }
+    fflush (stdout);
+    zDup2 (saved_stdout, fileno (stdout));
+    if (t < 0)
+      {
+        char *tmpMsg = (char *) malloc (2048 + strlen (r_inputs->value));
+        sprintf (tmpMsg,
+                 _
+                 ("The value for <identifier> seems to be wrong (%s). Please specify one of the processes in the list returned by a GetCapabilities request."),
+                 r_inputs->value);
+        errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
+        free (tmpMsg);
+        free (s1);
+        freeMaps (&m);
+        free (m);
+        free (REQUEST);
+        free (SERVICE_URL);
+        return 0;
+      }
+    zClose (saved_stdout);
+#ifdef META_DB
+  }
+#endif
+  
 #ifdef DEBUG
   dumpService (s1);
@@ -1821 +2022 @@
     return 0;
   }
-
+  //InternetCloseHandle (&hInternet);
+  
   // Define each env variable in runing environment
   maps *curs = getMaps (m, "env");
@@ -1862 +2064 @@
                      2) * sizeof (char));
           sprintf (toto, "%s=%s", mapcs->name, mapcs->value);
-          putenv (toto);
+          _putenv (toto);
 #ifdef DEBUG
           fflush (stderr);
 #endif
 #endif
+
 #ifdef DEBUG
           fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
@@ -1959 +2162 @@
 
   int eres = SERVICE_STARTED;
-  int cpid = getpid ();
-
+  int cpid = zGetpid ();
+
+  // Create a map containing a copy of the request map
+  maps *_tmpMaps = createMaps("request");
+  addMapToMap(&_tmpMaps->content,request_inputs);
+  addMapsToMaps (&m, _tmpMaps);
+  freeMaps (&_tmpMaps);
+  free (_tmpMaps);
   /**
    * Initialize the specific [lenv] section which contains runtime variables:
@@ -1981 +2190 @@
    *
    */
-  maps *_tmpMaps = createMaps("lenv");
+  _tmpMaps = createMaps("lenv");
   char tmpBuff[100];
   struct ztimeval tp;
@@ -2009 +2218 @@
     addToMap (_tmpMaps->content, "soap", "false");
 
-  // Parse the session file and add it to the main maps 
+  // Parse the session file and add it to the main maps
+  char* originalCookie=NULL;
   if (cgiCookie != NULL && strlen (cgiCookie) > 0)
     {
       int hasValidCookie = -1;
-      char *tcook = zStrdup (cgiCookie);
-      char *tmp = NULL;
+      char *tcook = originalCookie = zStrdup (cgiCookie);
       map *testing = getMapFromMaps (m, "main", "cookiePrefix");
-      if (testing == NULL)
+      parseCookie(&m,originalCookie);
+      map *sessId=getMapFromMaps(m,"cookies",(testing==NULL?"ID":testing->value));
+      if (sessId!=NULL)
         {
-          tmp = zStrdup ("ID=");
-        }
-      else
-        {
-          tmp =
-            (char *) malloc ((strlen (testing->value) + 2) * sizeof (char));
-          sprintf (tmp, "%s=", testing->value);
-        }
-      if (strstr (cgiCookie, ";") != NULL)
-        {
-          char *token, *saveptr;
-          token = strtok_r (cgiCookie, ";", &saveptr);
-          while (token != NULL)
-            {
-              if (strcasestr (token, tmp) != NULL)
-                {
-                  if (tcook != NULL)
-                    free (tcook);
-                  tcook = zStrdup (token);
-                  hasValidCookie = 1;
-                }
-              token = strtok_r (NULL, ";", &saveptr);
-            }
-        }
-      else
-        {
-          if (strstr (cgiCookie, "=") != NULL
-              && strcasestr (cgiCookie, tmp) != NULL)
-            {
-              tcook = zStrdup (cgiCookie);
-              hasValidCookie = 1;
-            }
-          if (tmp != NULL)
-            {
-              free (tmp);
-            }
-        }
-      if (hasValidCookie > 0)
-        {
-          addToMap (_tmpMaps->content, "sessid", strstr (tcook, "=") + 1);
+          addToMap (_tmpMaps->content, "sessid", sessId->value);
           char session_file_path[1024];
           map *tmpPath = getMapFromMaps (m, "main", "sessPath");
@@ -2065 +2237 @@
           if (tmp1 != NULL)
             sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
-                     strstr (tmp1, "=") + 1);
+                     sessId->value);
           else
             sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
-                     strstr (cgiCookie, "=") + 1);
+                     sessId->value);
           free (tcook);
           maps *tmpSess = (maps *) malloc (MAPS_SIZE);
@@ -2076 +2248 @@
           if (istat == 0 && file_status.st_size > 0)
             {
+              int saved_stdout = zDup (fileno (stdout));
+              zDup2 (fileno (stderr), fileno (stdout));
               conf_read (session_file_path, tmpSess);
               addMapsToMaps (&m, tmpSess);
               freeMaps (&tmpSess);
+              fflush(stdout);
+              zDup2 (saved_stdout, fileno (stdout));
+              zClose(saved_stdout);
             }
           free (tmpSess);
@@ -2091 +2268 @@
 #endif
   int ei = 1;
-  char *s = 
+  
 #ifdef WIN32
-    GetEnvironmentStrings();
+  LPVOID orig = GetEnvironmentStrings();
+  LPTSTR s = (LPTSTR) orig;
 #else
-    *environ;
-#endif
+  char **orig = environ;
+  char *s=*orig;
+#endif
+
   _tmpMaps = createMaps("renv");
-  for (; s; ei++) {
-    char* tmpName=zStrdup(s);
-    char* tmpValue=strstr(s,"=")+1;
-    tmpName[strlen(tmpName)-strlen(tmpValue)-1]=0;
-    if(_tmpMaps->content == NULL)
-      _tmpMaps->content = createMap (tmpName,tmpValue);
-    else
-      addToMap (_tmpMaps->content,tmpName,tmpValue);
-    free(tmpName);
-    s = *(environ+ei);
+if(orig!=NULL)
+  for (; 
+#ifdef WIN32
+       *s;
+       s++
+#else
+       s;
+       ei++
+#endif
+       ) {
+    if(strstr(s,"=")!=NULL && strlen(strstr(s,"="))>1){
+      int len=strlen(s);
+      char* tmpName=zStrdup(s);
+      char* tmpValue=strstr(s,"=")+1;
+      char* tmpName1=(char*)malloc((1+(len-(strlen(tmpValue)+1)))*sizeof(char));
+      snprintf(tmpName1,(len-strlen(tmpValue)),"%s",tmpName);
+      if(_tmpMaps->content == NULL)
+        _tmpMaps->content = createMap (tmpName1,tmpValue);
+      else
+        addToMap (_tmpMaps->content,tmpName1,tmpValue);
+      free(tmpName1);
+      free(tmpName);
+    }
+#ifndef WIN32
+    s = *(orig+ei);
+#endif
+  }
+  if(_tmpMaps->content!=NULL && getMap(_tmpMaps->content,"HTTP_COOKIE")!=NULL){
+    addToMap(_tmpMaps->content,"HTTP_COOKIE1",&cgiCookie[0]);
   }
   addMapsToMaps (&m, _tmpMaps);
   freeMaps (&_tmpMaps);
   free (_tmpMaps);
-
+#ifdef WIN32
+  FreeEnvironmentStrings((LPCH)orig);
+#endif
+  if(postRequest!=NULL)
+    setMapInMaps (m, "renv", "xrequest", postRequest->value);
+  //dumpMaps(m);
 #ifdef WIN32
   char *cgiSidL = NULL;
@@ -2160 +2364 @@
         return -1;
       }
+      map* testMap=getMapFromMaps(m,"main","memory");
+      if(testMap==NULL || strcasecmp(testMap->value,"load")!=0)
+        dumpMapsValuesToFiles(&m,&request_input_real_format);
       loadServiceAndRun (&m, s1, request_inputs, &request_input_real_format,
-                         &request_output_real_format, &eres);
+                         &request_output_real_format, &eres);     
+
+#ifdef META_DB
+      close_sql(m,0);      
+#endif      
     }
   else
@@ -2169 +2380 @@
       fprintf (stderr, "\nPID : %d\n", cpid);
 #endif
-
 #ifndef WIN32
       pid = fork ();
@@ -2175 +2385 @@
       if (cgiSid == NULL)
         {
-          createProcess (m, request_inputs, s1, NULL, cpid,
-                         request_input_real_format,
-                         request_output_real_format);
-          pid = cpid;
+          createProcess (m, request_inputs, s1, NULL, cpid,
+                         request_input_real_format,
+                         request_output_real_format);
+          pid = cpid;
         }
       else
         {
-          pid = 0;
-          cpid = atoi (cgiSid);
+          pid = 0;
+          cpid = atoi (cgiSid);
           updateStatus(m,0,_("Initializing"));
         }
 #endif
       if (pid > 0)
-        {
-          /**
-           * dady :
-           * set status to SERVICE_ACCEPTED
-           */
-#ifdef DEBUG
-          fprintf (stderr, "father pid continue (origin %d) %d ...\n", cpid,
-                   getpid ());
-#endif
-          eres = SERVICE_ACCEPTED;
-        }
+        {
+          //
+          // dady :
+          // set status to SERVICE_ACCEPTED
+          //
+#ifdef DEBUG
+          fprintf (stderr, "father pid continue (origin %d) %d ...\n", cpid,
+                   zGetpid ());
+#endif
+          eres = SERVICE_ACCEPTED;
+        }
       else if (pid == 0)
-        {
-          /**
-           * son : have to close the stdout, stdin and stderr to let the parent
-           * process answer to http client.
-           */
+        {
+          eres = SERVICE_ACCEPTED;
+          //
+          // son : have to close the stdout, stdin and stderr to let the parent
+          // process answer to http client.
+          //
           map* usid = getMapFromMaps (m, "lenv", "uusid");
-          map* tmpm = getMapFromMaps (m, "lenv", "osid");
-          int cpid = atoi (tmpm->value);
-          r_inputs = getMapFromMaps (m, "main", "tmpPath");
+          map* tmpm = getMapFromMaps (m, "lenv", "osid");
+          int cpid = atoi (tmpm->value);
+          pid=cpid;
+          r_inputs = getMapFromMaps (m, "main", "tmpPath");
+          setMapInMaps (m, "lenv", "async","true");
           map* r_inputs1 = createMap("ServiceName", s1->name);
 
           // Create the filename for the result file (.res)
-          fbkpres =
-            (char *)
-            malloc ((strlen (r_inputs->value) +
-                     strlen (usid->value) + 7) * sizeof (char));                    
-          sprintf (fbkpres, "%s/%s.res", r_inputs->value, usid->value);
+          fbkpres =
+            (char *)
+            malloc ((strlen (r_inputs->value) +
+                     strlen (usid->value) + 7) * sizeof (char));                    
+          sprintf (fbkpres, "%s/%s.res", r_inputs->value, usid->value);
           bmap = createMaps("status");
           bmap->content=createMap("usid",usid->value);
           addToMap(bmap->content,"sid",tmpm->value);
-          addIntToMap(bmap->content,"pid",getpid());
-                  
+          addIntToMap(bmap->content,"pid",zGetpid());
+          
           // Create PID file referencing the OS process identifier
-          fbkpid =
-            (char *)
-            malloc ((strlen (r_inputs->value) +
-                     strlen (usid->value) + 7) * sizeof (char));
-          sprintf (fbkpid, "%s/%s.pid", r_inputs->value, usid->value);
+          fbkpid =
+            (char *)
+            malloc ((strlen (r_inputs->value) +
+                     strlen (usid->value) + 7) * sizeof (char));
+          sprintf (fbkpid, "%s/%s.pid", r_inputs->value, usid->value);
           setMapInMaps (m, "lenv", "file.pid", fbkpid);
 
-          f0 = freopen (fbkpid, "w+",stdout);
-          printf("%d",getpid());
+          f0 = freopen (fbkpid, "w+",stdout);
+          printf("%d",zGetpid());
           fflush(stdout);
 
           // Create SID file referencing the semaphore name
-          fbkp =
-            (char *)
-            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
-                     strlen (usid->value) + 7) * sizeof (char));
-          sprintf (fbkp, "%s/%s.sid", r_inputs->value, usid->value);
+          fbkp =
+            (char *)
+            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
+                     strlen (usid->value) + 7) * sizeof (char));
+          sprintf (fbkp, "%s/%s.sid", r_inputs->value, usid->value);
           setMapInMaps (m, "lenv", "file.sid", fbkp);
-          FILE* f2 = freopen (fbkp, "w+",stdout);
+          FILE* f2 = freopen (fbkp, "w+",stdout);
           printf("%s",tmpm->value);
           fflush(f2);
           free(fbkp);
 
-          fbkp =
-            (char *)
-            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
-                     strlen (usid->value) + 7) * sizeof (char));
-          sprintf (fbkp, "%s/%s_%s.xml", r_inputs->value, r_inputs1->value,
-                   usid->value);
+          fbkp =
+            (char *)
+            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
+                     strlen (usid->value) + 7) * sizeof (char));
+          sprintf (fbkp, "%s/%s_%s.xml", r_inputs->value, r_inputs1->value,
+                   usid->value);
           setMapInMaps (m, "lenv", "file.responseInit", fbkp);
-          flog =
-            (char *)
-            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
-                     strlen (usid->value) + 13) * sizeof (char));
-          sprintf (flog, "%s/%s_%s_error.log", r_inputs->value,
-                   r_inputs1->value, usid->value);
+          flog =
+            (char *)
+            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
+                     strlen (usid->value) + 13) * sizeof (char));
+          sprintf (flog, "%s/%s_%s_error.log", r_inputs->value,
+                   r_inputs1->value, usid->value);
           setMapInMaps (m, "lenv", "file.log", flog);
 #ifdef DEBUG
-          fprintf (stderr, "RUN IN BACKGROUND MODE \n");
-          fprintf (stderr, "son pid continue (origin %d) %d ...\n", cpid,
-                   getpid ());
-          fprintf (stderr, "\nFILE TO STORE DATA %s\n", r_inputs->value);
-#endif
-          freopen (flog, "w+", stderr);
-          fflush (stderr);
+          fprintf (stderr, "RUN IN BACKGROUND MODE \n");
+          fprintf (stderr, "son pid continue (origin %d) %d ...\n", cpid,
+                   zGetpid ());
+          fprintf (stderr, "\nFILE TO STORE DATA %s\n", r_inputs->value);
+#endif
+          freopen (flog, "w+", stderr);
+          fflush (stderr);
           f0 = freopen (fbkp, "w+", stdout);
           rewind (stdout);
@@ -2277 +2490 @@
           recordServiceStatus(m);
 #endif
+#ifdef USE_CALLBACK
+          invokeCallback(m,NULL,NULL,0,0);
+#endif
           if(vid==0){
-            /**
-             * set status to SERVICE_STARTED and flush stdout to ensure full 
-             * content was outputed (the file used to store the ResponseDocument).
-             * The rewind stdout to restart writing from the bgining of the file,
-             * this way the data will be updated at the end of the process run.
-             */
+            //
+            // set status to SERVICE_STARTED and flush stdout to ensure full 
+            // content was outputed (the file used to store the ResponseDocument).
+            // Then, rewind stdout to restart writing from the begining of the file.
+            // This way, the data will be updated at the end of the process run.
+            //
             printProcessResponse (m, request_inputs, cpid, s1, r_inputs1->value,
                                   SERVICE_STARTED, request_input_real_format,
@@ -2293 +2509 @@
           }
 
-          fflush (stderr);
-
-          fbkp1 =
-            (char *)
-            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
-                     strlen (usid->value) + 13) * sizeof (char));
-          sprintf (fbkp1, "%s/%s_final_%s.xml", r_inputs->value,
-                   r_inputs1->value, usid->value);
+          fflush (stderr);
+
+          fbkp1 =
+            (char *)
+            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
+                     strlen (usid->value) + 13) * sizeof (char));
+          sprintf (fbkp1, "%s/%s_final_%s.xml", r_inputs->value,
+                   r_inputs1->value, usid->value);
           setMapInMaps (m, "lenv", "file.responseFinal", fbkp1);
 
-          f1 = freopen (fbkp1, "w+", stdout);
-
+          f1 = freopen (fbkp1, "w+", stdout);
+
+          map* serviceTypeMap=getMap(s1->content,"serviceType");
+          if(serviceTypeMap!=NULL)
+            setMapInMaps (m, "lenv", "serviceType", serviceTypeMap->value);
+
+          char *flenv =
+            (char *)
+            malloc ((strlen (r_inputs->value) + 
+                     strlen (usid->value) + 12) * sizeof (char));
+          sprintf (flenv, "%s/%s_lenv.cfg", r_inputs->value, usid->value);
+          maps* lenvMaps=getMaps(m,"lenv");
+          dumpMapsToFile(lenvMaps,flenv,0);
+          free(flenv);
+
+#ifdef USE_CALLBACK
+          invokeCallback(m,request_input_real_format,NULL,1,0);
+#endif
           if(validateRequest(&m,s1,request_inputs, &request_input_real_format,&request_output_real_format,&hInternet)<0){
             freeService (&s1);
             free (s1);
+            fflush (stdout);
+            fflush (stderr);
             fclose (f0);
             fclose (f1);
             if(dumpBackFinalFile(m,fbkp,fbkp1)<0)
               return -1;
-            unlink (fbkpid);            
+#ifndef RELY_ON_DB
+            dumpMapsToFile(bmap,fbkpres,1);
+            removeShmLock (m, 1);
+#else
+            recordResponse(m,fbkp1);
+#ifdef USE_CALLBACK
+            invokeCallback(m,NULL,NULL,7,0);
+#endif
+#endif
+            zUnlink (fbkpid);
             unhandleStatus (m);
+#ifdef RELY_ON_DB
+#ifdef META_DB
+            cleanupCallbackThreads();
+            close_sql(m,1);
+#endif
+            close_sql(m,0);
+#endif
             freeMaps (&m);
             free (m);
@@ -2324 +2574 @@
             freeMaps (&tmpmaps);
             free (tmpmaps);
-            fflush (stdout);
-            fflush (stderr);
             return -1;
           }
-          loadServiceAndRun (&m, s1, request_inputs,
-                             &request_input_real_format,
-                             &request_output_real_format, &eres);
-        }
+          if(getMapFromMaps(m,"lenv","mapError")!=NULL){
+            setMapInMaps(m,"lenv","message",_("Issue with geographic data"));
+#ifdef USE_CALLBACK
+            invokeCallback(m,NULL,NULL,7,0);
+#endif
+            eres=-1;//SERVICE_FAILED;
+          }else{
+            map* testMap=getMapFromMaps(m,"main","memory");
+            if(testMap==NULL || strcasecmp(testMap->value,"load")!=0)
+              dumpMapsValuesToFiles(&m,&request_input_real_format);
+            loadServiceAndRun (&m, s1, request_inputs,
+                               &request_input_real_format,
+                               &request_output_real_format, &eres);
+          }
+        }
       else
         {
@@ -2338 +2597 @@
            * error response here !!!
            */
-          eres = -1;
-          errorException (m, _("Unable to run the child process properly"),
-                          "InternalError", NULL);
+          eres = -1;
+          errorException (m, _("Unable to run the child process properly"),
+                          "InternalError", NULL);
         }
     }
-
-#ifdef DEBUG
+        
+#ifdef DEBUG
+  fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
   dumpMaps (request_output_real_format);
-#endif
-
+  fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
+#endif
+  fflush(stdout);
+  rewind(stdout);
+
+  //fprintf(stderr,"%s %d %d\n",__FILE__,__LINE__,eres);  
   if (eres != -1)
     outputResponse (s1, request_input_real_format,
@@ -2353 +2617 @@
                     cpid, m, eres);
   fflush (stdout);
-
+  
   /**
    * Ensure that if error occurs when freeing memory, no signal will return
@@ -2367 +2631 @@
   signal (SIGABRT, donothing);
 #endif
-  if (((int) getpid ()) != cpid || cgiSid != NULL)
-    {     
+
+  if (((int) zGetpid ()) != cpid || cgiSid != NULL)
+    {
+      if (eres == SERVICE_SUCCEEDED)
+#ifdef USE_CALLBACK
+        invokeCallback(m,NULL,request_output_real_format,5,1);
+#endif
+      fflush(stderr);
+      fflush(stdout);
+
       fclose (stdout);
-      fclose (stderr);
 
       fclose (f0);
       fclose (f1);
-         
-          if (dumpBackFinalFile(m, fbkp, fbkp1) < 0)
-                  return -1;
-        
-      unlink (fbkpid);    
+
+      if(dumpBackFinalFile(m,fbkp,fbkp1)<0)
+        return -1;
+      zUnlink (fbkpid);
       switch(eres){
       default:
@@ -2390 +2660 @@
         break;
       }      
-#ifndef RELY_ON_DB        
+#ifndef RELY_ON_DB
       dumpMapsToFile(bmap,fbkpres,1);
       removeShmLock (m, 1);
 #else
       recordResponse(m,fbkp1);
+      if (eres == SERVICE_SUCCEEDED)
+#ifdef USE_CALLBACK
+        invokeCallback(m,NULL,request_output_real_format,6,0);
+#endif
 #endif
       freeMaps(&bmap);
       free(bmap);
-      unlink (fbkp1);
-      unlink (flog);
+      zUnlink (fbkp1);
       unhandleStatus (m);
+#ifdef RELY_ON_DB
+#ifdef META_DB
+      cleanupCallbackThreads();
+      close_sql(m,1);
+#endif
+      close_sql(m,0);
+      end_sql();
+#endif
       free(fbkpid);
       free(fbkpres); 
-      free (flog);           
       free (fbkp1);
-      // free (tmps1); // tmps1 is stack memory and should not be freed
       if(cgiSid!=NULL)
         free(cgiSid);
-    }
-
+      //InternetCloseHandle (&hInternet);
+      fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
+      fflush(stderr);
+      fclose (stderr);
+      zUnlink (flog);
+      free (flog);
+    }
+  else{
+    //InternetCloseHandle (&hInternet);  
+#ifdef META_DB
+    close_sql(m,0);
+#endif
+  }
+  
   freeService (&s1);
   free (s1);
@@ -2429 +2720 @@
 #endif
 
-  if (((int) getpid ()) != cpid || cgiSid != NULL)
+  if (((int) zGetpid ()) != cpid || cgiSid != NULL)
     {
       exit (0);