Changeset 917 for trunk/zoo-project

trunk ¶ ¶

Property svn:mergeinfo set to False
/branches/prototype-v0 merged eligible

TabularUnified trunk/zoo-project/HISTORY.txt ¶ ¶

-                      r828
+                      r917
 Version 1.7.0-dev
+  * Fix issue with UOM definitions in zcfg2sql
+  * Make callback and HPC support independent from each other
+  * Update SAGA-GIS support to version 7.2.0
+  * Add support for custom MapServer style definition for raster output
+  * Fix returned bbox definition #170
+  * Store semaphore status in lenv section for future deletion
+  * Update Windows support to newer compiler
+  * Fix issue with UpdateStatus function from the Mono ZOO-API
+  * Add logging functionality and other utility functions to the C-API
+  * Return an exception for every output for which nb_pixel or
+  nb_features is 0
+  * Add a shared key to the security section to differentiate the
+  referenced data
+  * Add MapServer output style definition depending on the geometry
+  type
+  * Add ogr.tindex service
+  * Add support for literaldata input arrays and to call services
+  asyncrhonously from the JavaScript ZOO-API
+  * Expose a sleep function to the JavaScript ZOO-API
+  * Provide FinalizeHPC and FinalizeHPC1 services using scontrol and
+  sacct respectively
+  * Store md5sum of the cached file (so, local to the WPS server) to
+  compare before uploading (if different md5sum) on the HPC server
+  * Add support for R language
+  * Add support for using "file://"  for referenced data input
+  * Add an optional ecookie key for returning third-party cookies
+  * Fix issue when parsing BoundingBox input #163
+  * Add memory key to the main section to force the ZOO-Kernel to load
+  data into memory or use local file
+  * Add the dialect input to the ogr2ogr service
+  * Store the list of generated mapfiles in a file (cf DeleteData service)
+  * Define the correct MS_IMAGEMODE in the generated mapfile
+  * Option to use MapServer support to publish heatmap
+  * Add status_code key to the lenv for setting Status HTTP response header
+  * Add the Creation Option inputs to the Gdal_Dem service
+  * Add prohibited key in the callback section to define a list of
+  services not requiring any invocation
+  * Produce zcfg for OTB applications using the correct default pixel type
+  * Add asynchronous callback invocation to send information about
+  the ongoing services to a third-party software
+  * Add mapsToJson, mapsToJson, and elementsToJson to the API
+  * Provide a zcfg2sql tool to convert a zcfg metadata file to SQL script
+  * Add support to store service metadata information into a database
+  * Add HPC Support for remote execution of SBATCH scripts through Slurm
+  * Add cookie reference to _HINTERNET
   * Support headers for GET requests from the js ZOO-API
   * Pass all headers listed in the attributes parameter from the

TabularUnified trunk/zoo-project/zoo-api/js/ZOO-api.js ¶ ¶

-                      r828
+                      r917
+        }
         var builder = this.parseData[data.localName().toLowerCase()];
         if (builder)
+        if (builder){
           res.push(builder.apply(this,[data]));
+        }
         else
           res.push(null);
+        data=null;
+      }
       return res.length>1?res:res[0];
+    } else
+      return null;
+    }
+    else{
+      var hasPercentCompleted=true;
+      var status = node.*::Status.*::ProcessStarted;
+      var msg = node.*::Status.*::ProcessStarted.*::*[0];
+      if(!status || !msg){
+        status = node.*::Status.*::ProcessAccepted;
+        msg = node.*::Status.*::ProcessAccepted.*::*[0];
+        msg=msg.toString();
+        hasPercentCompleted=false;
+      }else
+          msg=msg.toString();
+      if(status!=null && node.@statusLocation){
+        var res={"status": node.@statusLocation.toXMLString(), "message": msg};
+        if(hasPercentCompleted)
+          res["percentCompleted"]=status.@percentCompleted.toXMLString();
+        return res;
+      }else
+        return null;
+    }
   },
   /**
 …
      * {Object} A WPS reference response.
      */
+    'reference': function(node) {
+      var result = {type:'reference',value:node.@href};
+    'reference': function(lnode) {
+      var lhref=lnode.@href;
+      var lmimeType=lnode.@mimeType;
+      var result = {type:'reference',value:lhref.toXMLString(),mimeType:lmimeType.toXMLString()};
       return result;
+    }
 …
   identifier: null,
   /**
+   * Property: async
+   * {Bool} Define if the process should run asyncrhonously (true) or not (false, default).
+   */
+  async: null,
+  /**
    * Constructor: ZOO.Process
    * Create a new Process
 …
     this.url = url;
     this.identifier = identifier;
+    this.async = (arguments.length>2?arguments[2]:false);
   },
   /**
 …
     if (this.identifier == null)
       return null;
     var body = new XML('<wps:Execute service="WPS" version="1.0.0" xmlns:wps="'+this.namespaces['wps']+'" xmlns:ows="'+this.namespaces['ows']+'" xmlns:xlink="'+this.namespaces['xlink']+'" xmlns:xsi="'+this.namespaces['xsi']+'" xsi:schemaLocation="'+this.schemaLocation+'"><ows:Identifier>'+this.identifier+'</ows:Identifier>'+this.buildDataInputsNode(inputs)+this.buildDataOutputsNode(outputs)+'</wps:Execute>');
+      var body = new XML('<wps:Execute service="WPS" version="1.0.0" xmlns:wps="'+this.namespaces['wps']+'" xmlns:ows="'+this.namespaces['ows']+'" xmlns:xlink="'+this.namespaces['xlink']+'" xmlns:xsi="'+this.namespaces['xsi']+'" xsi:schemaLocation="'+this.schemaLocation+'"><ows:Identifier>'+this.identifier+'</ows:Identifier>'+this.buildDataInputsNode(inputs)+this.buildDataOutputsNode(outputs)+'</wps:Execute>');
     body = body.toXMLString();
     var headers=['Content-Type: text/xml; charset=UTF-8'];
       if(arguments.length>2){
         headers[headers.length]=arguments[2];
+      }
+    if(arguments.length>2){
+      headers[headers.length]=arguments[2];
+    }
     var response = ZOO.Request.Post(this.url,body,headers);
     return response;
 …
      */
     'ResponseDocument': function(identifier,obj) {
+      var output = new XML('<wps:ResponseForm xmlns:wps="'+this.namespaces['wps']+'"><wps:ResponseDocument><wps:Output'+(obj["mimeType"]?' mimeType="'+obj["mimeType"]+'" ':'')+(obj["encoding"]?' encoding="'+obj["encoding"]+'" ':'')+(obj["asReference"]?' asReference="'+obj["asReference"]+'" ':'')+'><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier></wps:Output></wps:ResponseDocument></wps:ResponseForm>');
+      var output = new XML('<wps:Output xmlns:wps="'+this.namespaces['wps']+'" '+(obj["mimeType"]?' mimeType="'+obj["mimeType"]+'" ':'')+(obj["encoding"]?' encoding="'+obj["encoding"]+'" ':'')+(obj["asReference"]?' asReference="'+obj["asReference"]+'" ':'')+'><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier></wps:Output>');
+      output = output.toXMLString();
+      return output;
+    },
+    'RawDataOutput': function(identifier,obj) {
+      var output = new XML('<wps:RawDataOutput xmlns:wps="'+this.namespaces['wps']+'" '+(obj["mimeType"]?' mimeType="'+obj["mimeType"]+'" ':'')+(obj["encoding"]?' encoding="'+obj["encoding"]+'" ':'')+'><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier></wps:RawDataOutput>');
       if (obj.encoding)
         output.*::Data.*::ComplexData.@encoding = obj.encoding;
 …
       output = output.toXMLString();
       return output;
-    },
-    'RawDataOutput': function(identifier,obj) {
-      var output = new XML('<wps:ResponseForm xmlns:wps="'+this.namespaces['wps']+'"><wps:RawDataOutput '+(obj["mimeType"]?' mimeType="'+obj["mimeType"]+'" ':'')+(obj["encoding"]?' encoding="'+obj["encoding"]+'" ':'')+'><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier></wps:RawDataOutput></wps:ResponseForm>');
-      if (obj.encoding)
-        output.*::Data.*::ComplexData.@encoding = obj.encoding;
-      if (obj.schema)
-        output.*::Data.*::ComplexData.@schema = obj.schema;
-      output = output.toXMLString();
-      return output;
+    }
 …
      */
     'complex': function(identifier,data) {
       var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier>'+(data.value?'<wps:Data><wps:ComplexData><![CDATA['+data.value+']]></wps:ComplexData></wps:Data>':(data.xlink?'<wps:Reference xmlns:xlink="'+this.namespaces['xlink']+'" xlink:href="'+data.xlink+'" mimeType="'+data.mimeType+'" />':''))+'</wps:Input>');
+      var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier>'+(data.value?'<wps:Data><wps:ComplexData '+(data.mimeType?'mimeType="'+data.mimeType+'"':"")+'><![CDATA['+data.value+']]></wps:ComplexData></wps:Data>':(data.xlink?'<wps:Reference xmlns:xlink="'+this.namespaces['xlink']+'" xlink:href="'+data.xlink+'" mimeType="'+data.mimeType+'" />':''))+'</wps:Input>');
       if(data.xlink)
         input.*::Reference.@mimeType = data.mimetype ? data.mimetype : 'application/json';
+        input.*::Reference.@mimeType = data.mimetype ? data.mimetype : 'application/json';
       else
         input.*::Data.*::ComplexData.@mimeType = data.mimetype ? data.mimetype : 'application/json';
+        input.*::Data.*::ComplexData.@mimeType = data.mimetype ? data.mimetype : 'application/json';
       if (data.encoding)
         input.*::Data.*::ComplexData.@encoding = data.encoding;
 …
         input.*::Data.*::ComplexData.@schema = data.schema;
       input = input.toXMLString();
+      return input;
+      if(data.value)
+        return (('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier>'+(data.value?'<wps:Data><wps:ComplexData '+(data.mimeType?'mimeType="'+data.mimeType+'"':"")+'><![CDATA['+data.value+']]></wps:ComplexData></wps:Data>':(data.xlink?'<wps:Reference xmlns:xlink="'+this.namespaces['xlink']+'" xlink:href="'+data.xlink+'" mimeType="'+data.mimeType+'" />':''))+'</wps:Input>'));
+      else
+        return input;
     },
     /**
 …
      */
     'literal': function(identifier,data) {
+        if(data && !eval(data["isArray"])){
+            var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier><wps:Data><wps:LiteralData>'+data.value+'</wps:LiteralData></wps:Data></wps:Input>');
+      if (data.type)
+        input.*::Data.*::LiteralData.@dataType = data.type;
+      if (data.uom)
+        input.*::Data.*::LiteralData.@uom = data.uom;
+      input = input.toXMLString();
+      return input;
+        }else if(data){
+            var inputf="";
+            for(i=0;i<parseInt(data["length"]);i++){
+                var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier><wps:Data><wps:LiteralData>'+data.value[i]+'</wps:LiteralData></wps:Data></wps:Input>');
+                if (data.type)
+                    input.*::Data.*::LiteralData.@dataType = data.type;
+                if (data.uom)
+                    input.*::Data.*::LiteralData.@uom = data.uom;
+                inputf += input.toXMLString();
+            }
+            return inputf;
+      if(data && !eval(data["isArray"])){
+        var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier><wps:Data><wps:LiteralData>'+data.value+'</wps:LiteralData></wps:Data></wps:Input>');
+        if (data.type)
+          input.*::Data.*::LiteralData.@dataType = data.type;
+        if (data.uom)
+          input.*::Data.*::LiteralData.@uom = data.uom;
+        input = input.toXMLString();
+        return input;
+      }else if(data){
+        var inputf="";
+        for(i=0;i<parseInt(data["length"]);i++){
+          var input = new XML('<wps:Input xmlns:wps="'+this.namespaces['wps']+'"><ows:Identifier xmlns:ows="'+this.namespaces['ows']+'">'+identifier+'</ows:Identifier><wps:Data><wps:LiteralData>'+data.value[i]+'</wps:LiteralData></wps:Data></wps:Input>');
+          if (data.type)
+            input.*::Data.*::LiteralData.@dataType = data.type;
+          if (data.uom)
+            input.*::Data.*::LiteralData.@uom = data.uom;
+          inputf += input.toXMLString();
+        }
+        return inputf;
+      }
+    }
   },
 …
   buildDataOutputsNode:function(outputs){
     var data, builder, outputsArray=[];
+    var data, builder, outputsArray=[[],[]];
     for (var attr in outputs) {
       data = outputs[attr];
       builder = this.buildOutput[data.type];
+      outputsArray.push(builder.apply(this,[attr,data]));
+    }
+    return outputsArray.join('\n');
+      if(data.type=="ResponseDocument")
+        outputsArray[0].push(builder.apply(this,[attr,data]));
+      else
+        outputsArray[1].push(builder.apply(this,[attr,data]));
+    }
+    var responseDocuments=(outputsArray[0].length>0?
+                           new XML('<wps:ResponseDocument  '+(this.async?'storeExecuteResponse="true" status="true"':'')+' xmlns:wps="'+this.namespaces['wps']+'">'+
+                                   outputsArray[0].join('\n')+
+                                   '</wps:ResponseDocument>')
+                           :
+                           null);
+    var rawDataOutputs=(outputsArray[1].length>0?
+                        outputsArray[1].join('\n')
+                        :
+                        null);
+    var res=new XML('<wps:ResponseForm xmlns:wps="'+this.namespaces['wps']+'">'+
+                    (responseDocuments!=null?responseDocuments.toXMLString():"")+
+                    (rawDataOutputs!=null?rawDataOutputs:"")+
+                    '</wps:ResponseForm>');
+    return res.toXMLString();
   },

TabularUnified trunk/zoo-project/zoo-client/lib/js/wps-client/zoo.js ¶ ¶

r719	r917
679	679
680	680	$.ajax({
681		url: closure.statusLocation[sid]
	681	url: closure.statusLocation[sid]+"&timestamp="++(new Date()).getTime()
682	682	})
683	683	.fail(

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

-                      r815
+                      r917
 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
 …
         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
 …
 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
 …
         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
 …
         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

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

-                      r866
+                      r917
 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@
 …
 PYTHON_FILE=@PYTHON_FILE@
+RCFLAGS=@R_CPPFLAGS@
+RLDFLAGS=@R_LDFLAGS@
+R_ENABLED=@R_ENABLED@
+R_FILE=@R_FILE@
 RUBYCFLAGS=@RUBY_CPPFLAGS@
 RUBYLDFLAGS=@RUBY_LDFLAGS@
 …
 ZOO_CFLAGS=-I${ZRPATH}/../thirds/cgic206/ -I${ZRPATH}/zoo-kernel/
 ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ -luuid
+ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ @UUID_LDFLAGS@
 JAVACFLAGS=@JAVA_CPPFLAGS@
 …
 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@
 …
 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

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

-                      r837
+                      r917
  */
+#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
 …
  */
 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);
 …
+}
+/**
+ * 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;
+}
 /**
 …
  * @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;
+  }
+}
 …
  */
 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);
 …
     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);
 …
  */
 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");
 …
     char *mimeType=NULL;
     int fsize=0;
+    char oriname[12];
     char cname[15];
     char vname[11];
 …
     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);
 …
     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);
 …
       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");
 …
       sprintf(icname,"isCached");
       sprintf(xname,"Reference");
+      sprintf(bname,"body");
+      sprintf(hname,"headers");
       sprintf(oname,"Order");
+      sprintf(ufile,"use_file");
+    }
 …
     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)
 …
         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.");
 …
         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);
 …
         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)++;
+      }
+    }
 …
  */
 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){
 …
     free(oreq);
   }else{
     setMapArray(oreq->content,"value",hInternet->nb-1,url);
+    setMapArray(oreq->content,"value",hInternet->nb,url);
+  }
+}
 …
   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");
 …
   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");
 …
       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);
 …
     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;
+}

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

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

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

-                      r817
+                      r917
 AC_INIT([ZOO Kernel], [1.7.0], [bugs@zoo-project.org])
+AC_CONFIG_MACRO_DIR([macros])
 # Checks for programs.
 …
 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"
 …
 # 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.
 …
 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])
 #============================================================================
 …
 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])
 #============================================================================
 …
 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
 …
 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])
 # ===========================================================================
 …
         AC_LANG([C++])
         echo $JAVA_CPPFLAGS
+        #echo $JAVA_CPPFLAGS
         # Check headers file (second time we check that in fact)
         CPPFLAGS_SAVE="$CPPFLAGS"
 …
         AC_LANG([C++])
         echo $JAVA_CPPFLAGS
+        #echo $JAVA_CPPFLAGS
         # Check headers file (second time we check that in fact)
         CPPFLAGS_SAVE="$CFLAGS"
 …
         [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
 …
         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"
 …
         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++])

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

r790	r917
87	87	;
88	88
89		pair: PAIR {curr_key=zStrdup($1);}
	89	pair: PAIR {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);}
90	90	\| EPAIR {
91	91	if(current_content==NULL)
…	…
99	99	}
100	100	free(curr_key);
	101	curr_key=NULL;
101	102	}
102		\| SPAIR {curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
	103	\| SPAIR {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
103	104	;
104	105
…	…
162	163	free(current_content);
163	164	}
	165	if(curr_key!=NULL){
	166	free(curr_key);
	167	}
164	168
165	169	fclose(crin);

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

-                      r788
+                      r917
         $(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
 …
         $(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
 …
         $(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
 …
         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:
 …
 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;

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

-                      r601
+                      r917
         { "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" },
 …
 */
 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;
+}

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

-                      r788
+                      r917
 !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=.
 …
 !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

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

-                      r889
+                      r917
 #include "response_print.h"
 #include "caching.h"
+#include "cgic.h"
 /**
 …
       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);
 …
           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);
 …
   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++)
 …
             xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
             tmpmaps = createMaps((char *) val);
+            xmlFree(val);
+          }
 …
                             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
 …
                                       map *btmp =
                                         getMap (tmpmaps->content, "Reference");
+                                      addToMap (tmpmaps->content, "Body", tmp);
                                       if (btmp != NULL)
+                                        {
 …
                                                            xmlStrlen(btmps),
                                                            INTERNET_FLAG_NO_CACHE_WRITE,
+);
+,
+                                                           *main_conf);
                                           addIntToMap (tmpmaps->content, "Order", hInternet->nb);
+                                        }
 …
                                   xmlGetProp (cur3, BAD_CAST "href");
                                 HINTERNET bInternet, res1, res;
+                                maps *tmpConf=createMaps("main");
+                                tmpConf->content=createMap("memory","load");
                                 bInternet = InternetOpen (
 #ifndef WIN32
 …
                                                           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,
 …
                                                    [0], NULL, 0,
                                                    INTERNET_FLAG_NO_CACHE_WRITE,
+);
+,
+                                                   tmpConf);
                                 processDownloads (&bInternet);
+                                freeMaps(&tmpConf);
+                                free(tmpConf);
                                 char *tmp =
                                   (char *)
 …
                                                   &bRead);
                                 tmp[bInternet.ihandle[0].nDataLen] = 0;
+                                InternetCloseHandle (&bInternet);
+                                InternetCloseHandle(&bInternet);
+                                addToMap (tmpmaps->content, "Body", tmp);
                                 map *btmp =
                                   getMap (tmpmaps->content, "href");
 …
                                                        strlen(tmp),
                                                        INTERNET_FLAG_NO_CACHE_WRITE,
+);
+,
+                                                       *main_conf);
                                     addIntToMap (tmpmaps->content, "Order", hInternet->nb);
+                                  }
                                 free (tmp);
+                                xmlFree (val);
+                              }
+                        }
 …
+                    }
+                  }
                   while (cur4 != NULL)
 …
                       map *test = getMap (tmpmaps->content, "encoding");
                       if (test == NULL)
+                        {
+                        {
                           if (tmpmaps->content != NULL)
                             addToMap (tmpmaps->content, "encoding",
 …
+                        }
+                      if (getMap(tmpmaps->content,"dataType")==NULL && strcasecmp (test->value, "base64") != 0)
+                        {
+                          xmlChar *mv = xmlNodeListGetString (doc,
+                                                              cur4->xmlChildrenNode,
+);
+                      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,
+);*/
                           map *ltmp =
                             getMap (tmpmaps->content, "mimeType");
                           if (mv == NULL
                               ||
+                          if (/*mv == NULL
+                              ||*/
                               (xmlStrcasecmp
                                (cur4->name, BAD_CAST "ComplexData") == 0
 …
                                            buffersize);
                             }else{
                             if(xmlStrcasecmp
                                (cur4->name, BAD_CAST "BoundingBoxData") == 0){
 …
                               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);
+                                }
+                              }
+                            }
 …
                 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");
+            }
+          {
 …
+                  }
+              }
             else
+            else{
               addMapsToMaps (request_output, tmpmaps);
+            }
+          }
           freeMaps (&tmpmaps);
 …
       const char ress[4][13] =
         { "mimeType", "encoding", "schema", "transmission" };
+      xmlFree (val);
       for (l = 0; l < 4; l++){
         val = xmlGetProp (cur, BAD_CAST ress[l]);
 …
         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;
+          }
 …
   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);
   /**
 …
           else
             addToMap(*request_inputs,"mode","auto");
+          xmlFree(val);
           val = xmlGetProp (cur, BAD_CAST "response");
           if(val!=NULL){
 …
             addToMap(*request_inputs,"ResponseDocument","");
+          }
+          xmlFree(val);
+        }
+      }
 …
 #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)
 …
                   addToMap (tmpReqI->content, "lref", storageNameOnServer);
                   cgiFormFileClose (file);
                   close (targetFile);
+                  zClose (targetFile);
                   free(fileNameOnServer);
                   free(storageNameOnServer);
 …
   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);
 …
+    }
     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;
 …
+  }
+}
+/**
+ * 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);
+}

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

-                      r866
+                      r917
   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*);
 …
   void checkValidValue(map*,map**,const char*,const char**,int);
   int validateRequest(maps**,service*,map*,maps**,maps**,HINTERNET*);
+  void parseCookie(maps**,const char*);
 #ifdef __cplusplus
+}

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

-                      r889
+                      r917
  */
+#include "service.h"
 #include "response_print.h"
 #include "request_parser.h"
 …
 #else
 #include "cpl_vsi.h"
+#endif
+#ifdef USE_CALLBACK
+#include "service_callback.h"
 #endif
 …
+    }
     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));
 …
     nbNs++;
     currId=0;
     nsName[currId]=strdup(name);
+    nsName[currId]=zStrdup(name);
     usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
   }else{
 …
       nbNs++;
       currId=nbNs-1;
       nsName[currId]=strdup(name);
+      nsName[currId]=zStrdup(name);
       usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
+    }
 …
   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++;
 …
+      }
       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);
 …
       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);
+    }
+  }
 …
     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++){
 …
  * @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);
 …
       limit=7;
+    }
+    nc3=NULL;
+    map* sType=getMap(serv->content,"serviceType");
     for(;i<limit;i+=2){
       if(capabilities[vid][i]==NULL)
 …
             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]);
+        }
+      }
+    }
 …
     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);
+  }
+}
 …
  * @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){
 …
+    }
     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);
+  }
+}
 …
  * @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;
 …
   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;
 …
   if(vid==0){
     nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
     attachAttributes(nc,ns,serv->content,vid);
+    attachAttributes(nc,ns,serv->content,vid,NULL);
+  }
   else{
 …
+      }
+    }
     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)
 …
     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;
+    }
 …
+    }
   }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);
+  }
 …
     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);
+    }
+  }
 …
   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)
 …
  * @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)
 …
     int isAnyValue=1;
     nc2 = xmlNewNode(NULL, BAD_CAST type);
+    // Extract min/max Occurence information
     if(strstr(type,"Input")!=NULL){
       tmp1=getMap(e->content,"minOccurs");
 …
     if(e->format!=NULL){
+#ifdef USE_HPC
+    DEFAULT_OUT:
+#endif
       const char orderedFields[13][14]={
         "mimeType",
 …
       //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)
 …
                 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{
 …
             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);
 …
                  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{
 …
                 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;
+              }
+            }
+        }
 …
           }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);
+          }
+        }
 …
               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;
-                }*/
+            }
+          }
 …
         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;
 …
                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{
 …
+              }
               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;
 …
+            }
             else{
+              xmlAddChild(nc3,nc5);
+              if(datatype!=2)
+                xmlAddChild(nc3,nc5);
+            }
           }else{
             if(datatype!=1)
+            if(datatype==2 && vid==0)
               xmlAddChild(nc3,nc5);
+          }
 …
+          }
           else
+            if(datatype!=1)
+            if(datatype==0){
+              xmlFreeNode(nc4);
               xmlAddChild(nc3,nc5);
+            }
         _tmp=_tmp->next;
 …
       if(hasSupported==0){
         if(datatype==0 && vid!=0)
+        if(datatype==0 && vid!=0){
           xmlFreeNode(nc4);
+        }
         xmlFreeNode(nc5);
+      }
 …
+        }
         else{
+          xmlFreeNode(nc4);
           xmlAddChild(nc3,nc5);
+        }
 …
     }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;
+  }
 …
  * @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;
 …
   char stored_path[1024];
   memset(stored_path,0,1024);
   if(vid==0){
     char tmp[256];
 …
+    }
+  }
   /**
    * Display the process output only when requested !
 …
     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);
 …
+        }
         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
         /**
 …
           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
 …
 #endif
+  }
   printDocument(m,doc,pid);
 …
   else{
     /*
     dumpElements(e);
+      dumpElements(e);
     */
     return;
 …
        || 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;
+  }
 …
  * @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);
 …
     tmp=e->content;
   else
+    tmp=m->content;
+    tmp=m->content;
   if(vid==0){
     nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
 …
     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");
 …
+    }
+  }
   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)
 …
             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);
 …
           nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
+      }
       tmp=m->content;
+      tmp=m->content;
       while(tmp!=NULL){
         if(strcasecmp(tmp->name,"mimeType")==0 ||
 …
            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);
 …
+          }
+        }
         if(vid==0)
           xmlAddChild(nc2,nc3);
         tmp=tmp->next;
+        tmp=tmp->next;
+      }
       if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0) {
 …
+        }
+      }
+      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");
 …
              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)));
+          }
 …
             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
                 ) {
 …
   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");
 …
     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{
 …
 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;
 …
   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];
 …
       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");
 …
       while(p!=NULL){
         if(strstr(p->name,"ID")!=NULL){
           sessId=strdup(p->value);
+          sessId=zStrdup(p->value);
           break;
+        }
 …
+    }
+  }
   if(res==SERVICE_FAILED){
     map *lenv;
 …
     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){
 …
     map* usid=getMapFromMaps(m,"lenv","usid");
     int itn=0;
+    int error=-1;
   NESTED0:
     while(tmpI!=NULL){
 …
 #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");
 …
         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;
+    }
 …
       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{

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

-                      r785
+                      r917
 #include <libintl.h>
 #include <locale.h>
 /**
  * ZOO-Kernel internal messages translation function
 …
 #include <sys/stat.h>
 #include <sys/types.h>
-#include "cgic.h"
 #ifndef WIN32
 #include <sys/ipc.h>
 …
 #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"
 …
 #include <libxml/parser.h>
 #include <libxml/xpath.h>
+#include "cgic.h"
 #ifdef __cplusplus
 …
   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);
 …
   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);

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

-                      r889
+                      r917
 #include "service_internal.h"
 #include "response_print.h"
+//#include "service_callback.h"
 #include "mimetypes.h"
 #ifndef WIN32
 …
  */
 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);
+}
 …
 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;
 …
           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);
+        }
 …
         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);
+      }
 …
+        }
         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){
 …
+      }
+    }
     else {
+    else /*toto*/{
       iotype* tmpIoType=NULL;
       if(tmpMaps->content!=NULL){
 …
            * 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);
+            }
+          }
           /**
 …
               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);
 …
               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
 …
          */
         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");
 …
         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;
+      }
+    }
 …
     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;
 …
           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';
 …
           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);
 …
           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';
 …
+        }
+    }
+    free(sid);
     printStatusInfo(conf,statusInfo,req);
     freeMap(&statusInfo);
 …
         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"),
 …
     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");

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

-                      r889
+                      r917
  * 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
 …
 #include <ctime>
 #include <chrono>
+#ifdef WIN32
 #include <process.h>
+#endif
 #if defined(_MSC_VER) && _MSC_VER < 1800
 …
     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;
+  }
 …
     fflush(file);
     tmp=tmp->next;
-    cnt++;
     if(limit>=0 && cnt==limit)
       tmp=NULL;
+    cnt++;
+  }
   fflush(file);
 …
   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;
+}
 …
  * 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){
 …
     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
 …
     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)
 …
  */
 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);
+        }
+    }
+}
 …
  */
 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;
 …
+    }
+  }
-  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);
 …
     memmove(tmp->value,v,size*sizeof(char));
   tmp->value[size]=0;
-  char sin[128];
   sprintf(sin,"%d",size);
   addToMap(m,sname,sin);
 …
+    }
     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);
+      }
 …
     _cursor=*mo;
     tmp=tmp->next;
-#ifdef DEBUG
-    fprintf(stderr,"MO\n");
-    dumpMap(*mo);
-#endif
+  }
+}
 …
   map* size=getMap(in,"size");
   map *lout=*out;
+  map *tmpVin,*tmpVout;
   if(size!=NULL && pos>0){
     char tmp[11];
 …
     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));
 …
   }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));
 …
   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);
 …
   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);
 …
+    }
     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);
 …
 map* getMapArray(map* m,const char* key,int index){
   char tmp[1024];
+  map* tmpMap;
   if(index>0)
     sprintf(tmp,"%s_%d",key,index);
 …
   fprintf(stderr,"** KEY %s\n",tmp);
 #endif
   map* tmpMap=getMap(m,tmp);
+  tmpMap=getMap(m,tmp);
 #ifdef DEBUG
   if(tmpMap!=NULL)
 …
 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];
 …
+    }
+  }
   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));
 …
   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);
+}
 …
   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",
 …
     (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]);
 …
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;
   res->format=NULL;
   res->defaults=NULL;
 …
  * @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;
 …
   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);
 …
     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);
 …
   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++)
 …
         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++)
 …
   elements* cursor=e;
   elements* tmp=NULL;
   if(cursor!=NULL){
+  if(cursor!=NULL && cursor->name!=NULL){
 #ifdef DEBUG
     fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
 …
 #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
 …
     }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
 …
     else
       tmp->child=NULL;
+    tmp->next=dupElements(cursor->next);
+    if(cursor->next!=NULL)
+      tmp->next=dupElements(cursor->next);
+    else
+      tmp->next=NULL;
+  }
   return tmp;
 …
   elements* tmp=e;
   if(*m==NULL){
     *m=dupElements(tmp);
+    (*m)=dupElements(tmp);
   }else{
     addToElements(&(*m)->next,tmp);
 …
     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){
 …
   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);
 …
   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){
 …
  */
 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;
 …
   memset(tmp,0,1024*10*10);
   while(tm!=NULL){
+    map* tc=tm->content;
     if(i>=10)
       break;
 …
     strcpy(tmp[i][j],tm->name);
     j++;
-    map* tc=tm->content;
     while(tc!=NULL){
       if(j>=30)
 …
  * @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
+ *
 …
  * @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);
+}
 …
+ *
  * @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);
+}
 …
 // 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());

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

-                      r889
+                      r917
  * 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
 …
 #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
 …
 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;
 …
+}
+#define zStatStruct struct _stati64
+#define zStat _stati64
 #else
 /**
 …
 #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
 …
  */
 #define ztimeval timeval
+/**
+ * The crossplatform getpid alias
+ */
+#define zGetpid getpid
+#define zStatStruct struct stat64
+#define zStat stat64
 #endif
 …
 #ifndef WIN32
 #include <ctype.h>
+//#include <stdbool.h> // knut: see new definition of bool above
+#include <stdbool.h>
 #endif
 …
  * 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
 …
  */
 //#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
 …
 #ifdef WIN32
 #define NULLMAP ((map*) 0)
+// knut: see new definition above
+//#define bool int
+//#define true 1
+//#define false 0
 #else
 #define NULLMAP NULL
 …
     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
 …
     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
 …
     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."
   };
 …
   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*);
 …
   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*);
 …
   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
+}

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

-                      r790
+                      r917
 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;
 …
     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;
+    }
+  }
 …
+    }
     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;
 …
   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){
 …
   wait_mainmetadata=false;
   wait_metadata=false;
+  wait_mainap=false;
+  wait_ap=false;
   wait_inputs=false;
   wait_defaults=false;

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

-                      r889
+                      r917
  * 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
 …
 #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"
 /**
 …
     //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);
 …
         free(stat);
+      }
       return tmps1;
+    }
 …
                      * sizeof (char));
   sprintf (fbkpid, "%s/%s.status", r_inputs->value, usid->value);
   unlink(fbkpid);
+  zUnlink(fbkpid);
   free(fbkpid);
+}
 …
+            }
+        }
+        setMapInMaps(conf,"lenv","semaphore","Created");
     } else if (errno == EEXIST) { /* someone else got it first */
         int ready = 0;
 …
               fprintf(stderr,"Retry to access the semaphore later ...\n");
 #endif
               zSleep(1);
+              zSleep(1000);
+            }
+        }
 …
           return -1;
+        }
+        setMapInMaps(conf,"lenv","semaphore","Acquired");
     } else {
         return sem_id; /* error, check errno */
 …
+}
+/**
+ * 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;
+        }
+}

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

-                      r680
+                      r917
  * 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>
 …
 #endif
 #ifndef WIN32
 #include <xlocale.h>
+#include <locale.h>
 #endif
+#include <fcntl.h>
 #include "service.h"
 …
 #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*);
 …
   ZOO_DLL_EXPORT int unlockShm(semid);
+  ZOO_DLL_EXPORT char* file_exists(const char* dir, const char* name);
 #ifdef __cplusplus
+}

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

-                      r790
+                      r917
 #endif
 #ifdef JAVA7
   cls_gr = (*env)NewGlobalRef(cls);
+  cls_gr = (*env).NewGlobalRef(cls);
 #else
   cls_gr = (*env)->NewGlobalRef(env, cls);
 …
   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
 …
+  }
 #ifdef JAVA7
       (*jvm).DestroyJavaVM();
+  (*jvm).DestroyJavaVM();
 #else
   (*jvm)->DestroyJavaVM(jvm);
 …
 #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");
 …
         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));
 …
               (*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{
 …
             jclass scArrayListClass,scArrayList_class;
             jmethodID scArrayList_constructor;
             jobject scObject2;
+            jobject scObject2,scObject3;
 #ifdef JAVA7
             scArrayListClass = (*env).FindClass("java/util/ArrayList");
 …
             jmethodID add_mid = 0;
             scObject2 = (*env).NewObject(scArrayList_class, scArrayList_constructor);
+            scObject3 = (*env).NewObject(scArrayList_class, scArrayList_constructor);
             add_mid = (*env).GetMethodID(scArrayListClass,
 …
             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,
 …
             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));
 …
 #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

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

-                      r828
+                      r917
     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))
 …
   char* tmpValue;
   size_t dwRead;
+  maps *tmpConf=createMaps("main");
+  tmpConf->content=createMap("memory","load");
   JS_MaybeGC(cx);
   hInternet=InternetOpen("ZooWPSClient\0",
 …
 #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);
 …
+        }
         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);
 …
     }else{
       InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],NULL,0,
                       INTERNET_FLAG_NO_CACHE_WRITE,0);
+                      INTERNET_FLAG_NO_CACHE_WRITE,0,tmpConf);
       processDownloads(&hInternet);
+    }
 …
   if(argc>=2)
     free(method);
+  freeMaps(&tmpConf);
+  free(tmpConf);
   InternetCloseHandle(&hInternet);
   JS_MaybeGC(cx);
 …
+}
+/**
+ * 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;
+}

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

r580	r917
49	49	JSBool JSRequest(JSContext, uintN, jsval);
50	50	JSBool JSUpdateStatus(JSContext,uintN,jsval );
	51	JSBool JSSleep(JSContext,uintN,jsval );
51	52
52	53	void reportError(JSContext cx, const char message, JSErrorReport *report);

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

-                      r794
+                      r917
 #include "response_print.h"
+MonoClass *iclasses[4];
+MonoMethod *imethods[10];
 /**
  * Load a Mono dll then run the static public method corresponding to the
 …
     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");
 …
   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);
 …
   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];
 …
   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));
 …
     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);
 …
     return 4;
+  }
   MonoMethod *serviceFunction = mono_class_get_method_from_name(serviceClass, s->name, 3);
   if(serviceFunction==NULL){
 …
     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;
+}
 …
       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);
 …
       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)
 …
  */
 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)));
+}
 …
  * @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;
+}

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

-                      r794
+                      r917
   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

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

-                      r781
+                      r917
 #include "server_internal.h"
 #include "response_print.h"
+#include "caching.h"
 /**
 …
 /**
+ * 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.
 …
  */
 void setMapSize(maps* output,double minx,double miny,double maxx,double maxy){
+  int imyIndex=getPublishedId(output);
   double maxWidth=640;
   double maxHeight=480;
 …
 #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);
+  }
+}
 …
  */
 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");
 …
     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");
+      }
+    }
+  }
 …
+  }
+  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){
 …
+  }
   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],
 …
             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],
 …
             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){
 …
     free(crs);
+  }
+  addToMap(tmpI->content,"Reference",webService_url);
+  freeMap(&rformat);
+  free(rformat);
   free(webService_url);
+}
 …
   OGRSpatialReferenceH  hSRS;
   map* msSrs=NULL;
+  int imyIndex=getPublishedId(output);
   hSRS = OSRNewSpatialReference(NULL);
   if( pszProjection!=NULL && strlen(pszProjection)>1){
 …
         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);
+        }
+      }
 …
           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);
 …
           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");
 …
   else{
     if(output!=NULL){
       msSrs=getMap(output->content,"msSrs");
+      msSrs=getMapArray(output->content,"msSrs",imyIndex);
+    }
     if(msSrs!=NULL){
 …
+    }
     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");
+    }
+  }
 …
 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);
 …
   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
 …
 #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);
+    }
+  }
 …
  */
 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;
 …
   /**
    * Try to load the file as ZIP
+   */
+   *
   OGRDataSourceH poDS1 = NULL;
   OGRSFDriverH *poDriver1 = NULL;
 …
     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
 …
       i++;
+    }
+  }
+    OGR_DS_Destroy(poDS1);
+    }
   free(sdsName);
   free(dsName);
+  free(dsName);*/
   OGRDataSourceH poDS = NULL;
   OGRSFDriverH *poDriver = NULL;
 …
 #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");
 …
+  }
+  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++ ){
 …
      * 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);
 …
     myLayer->status = MS_ON;
     msConnectLayer(myLayer,MS_OGR,pszDataSource);
+    addIntToMapArray(output->content,"nb_features",imyIndex,OGR_L_GetFeatureCount(poLayer,1));
     /**
 …
+    }
     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");
 …
     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);
+    }
 …
     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;
 …
  */
 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;
 …
    */
   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();
 …
 #endif
+  setMapArray(output->content,"geodatatype",imyIndex,"raster");
   /**
    * Add a new layer set name, data
 …
   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;
 …
   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
 …
     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());
+    }
+  }
   /**
 …
         + 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);
+  }
 …
    */
   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");
+  }
   /**
 …
   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);
 …
+    }
+  }
+  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){
 …
         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++){
             /**
 …
           char tmpMm[100];
           sprintf(tmpMm,"%.3f %.3f",adfCMinMax[0],adfCMinMax[1]);
+          sprintf(tmpMm,"%.3f %.3f",pdfMin,pdfMax);
+        }
 …
           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));
 …
+  }
+  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++;
 …
   GDALDestroyDriverManager();
   CPLCleanupTLS();
+  storeMd5(pszFilename);
   return 1;
+}
 …
  */
 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)
 …
       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");
 …
 #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
 …
     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));
 …
     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));
 …
 #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
 …
   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);
   /*
 …
   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);
+}

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

r889	r917
56	56	int tryGdal(maps* conf,maps* output,mapObj* m);
57	57	void outputMapfile(maps* conf,maps* outputs);
	58	void saveMapNames(maps,maps,char*);
	59
58	60	#ifdef __cplusplus
59	61	}

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

r796	r917
25	25	#ifdef WIN32
26	26	#define NO_FCGI_DEFINES
	27	#define ZEND_WIN32_KEEP_INLINE
27	28	#endif
28	29

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

-                      r790
+                      r917
  * 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
  */
 …
  */
 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");
 …
     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;
 …
       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);
 …
   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();
 …
       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);
 …
     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) {
 …
       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);
 …
         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));
 …
         dumpMaps(*real_outputs);
 #endif
       }else{
+      }else{
         PythonZooReport(m,tmp->value,0);
         res=-1;
 …
 #endif
   PyThreadState_Swap(mainstate);
   Py_Finalize();
+  Py_Finalize();
   return res;
+}
 …
   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;
 …
   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){
 …
         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){
 …
             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){
 …
               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);
 …
           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){
 …
+          }
+      }
       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){

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

-                      r640
+                      r917
  * 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
 …
 #pragma once
+#include <Python.h>
 #include "service_internal.h"
 #include "response_print.h"
-#include <Python.h>
-#include "cgic.h"
 #ifdef WIN32
 #include <windows.h>

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

-                      r790
+                      r917
   int hasSize=0;
   map* isArray=getMap(tmp,"isArray");
+  map* useFile=getMap(tmp,"use_file");
   map* size=getMap(tmp,"size");
   map* tmap=getMapType(tmp);
 …
         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++){
 …
           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){
 …
             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{
 …
               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);
+          }
 …
         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){

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

-                      r790
+                      r917
 #include <api_core.h>
 #include <data_manager.h>
 #include <module_library.h>
+#include <saga_api.h>
 #define _ZOO_SAGA
 #include "service_internal_saga.h"
 …
         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
 …
             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));
+        }
+      }
 …
             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){
 …
             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()) )
 …
+                        }
+                    }
+#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++)
 …
                                   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()),
++ i - nFileNames
+                                                                                    ));
+                        }
+                      setMapArray(cMaps->content,"generated_file",i,
+                                  CSG_String(param->asList()->Get_Data(i)->Get_File_Name()).b_str());
+                    }
+#endif
+                }
+            }
 …
   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];
 …
+  }
+#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];
 …
   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;
 …
   // 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];
 …
   // 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];
 …
   // Load all the parameters defined for the module
   CSG_Parameters * params=module->Get_Parameters();
-  int pc=params->Get_Count();
   if(!params){
     char tmp[255];
 …
     return res;
+  }
+  int pc=params->Get_Count();
   // Loop over each inputs to transform raster files to grid when needed,

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

r790	r917
487	487	addMapToIoType(&current_element->supported,current_content);
488	488	}
489		freeMaps(&current_content);
	489	freeMap(&current_content);
490	490	free(current_content);
491	491	current_content=NULL;

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

-                      r781
+                      r917
 -- 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

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

-                      r786
+                      r917
 /*
  * Author : David Saggiorato
  *          Gérald Fenoy
+ * Authors : David Saggiorato
+ *           Gérald Fenoy
  *  Copyright 2015 GeoLabs SARL. All rights reserved.
+ *
 …
  */
-#ifdef RELY_ON_DB
 #include "ogr_api.h"
 #include "ogrsf_frmts.h"
 …
 OGRDataSource
 #endif
  *zoo_DS = NULL;
+ **zoo_DS = NULL;
 /**
 …
 /**
+ * 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){
 …
 /**
+ * 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");
+}
 …
  * @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;
+  }
+}
 …
 /**
+ * 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.
+ *
 …
  * @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;
+}
 …
  * @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;
+}
 …
  */
 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");
 …
   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);
+}
 …
  */
 void recordServiceStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","sid");
   map *osid=getMapFromMaps(conf,"lenv","osid");
 …
           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);
+}
 …
  */
 void recordResponse(maps* conf,char* filename){
+  int zoo_ds_nb=getCurrentId(conf);
   FILE *file = fopen (filename, "rb");
   fseek (file, 0, SEEK_END);
 …
   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);
+}
 …
  */
 int _updateStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","usid");
   map *p=getMapFromMaps(conf,"lenv","status");
 …
   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;
 …
  */
 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
+#else
+#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;
 …
     for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
       if( poFeature->IsFieldSet( iField ) ){
         tmp1=strdup(poFeature->GetFieldAsString( iField ));
+        tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
+      }
       else
 …
     OGRFeature::DestroyFeature( poFeature );
+  }
   cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return (char*)tmp1;
 …
  */
 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
+#else
+#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;
 …
  */
 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
+#else
+#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();
 …
  */
 void unhandleStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   map *sid=getMapFromMaps(conf,"lenv","usid");
 …
           " 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();
+}
 …
  */
 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));
 …
           "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;
 …
     tmp1=NULL;
   free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   return (char*)tmp1;
+}
 …
  */
 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));
 …
   if( zoo_DS == NULL )
     init_sql(conf);
   execSql(conf,sqlQuery);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   int hasRes=-1;
 …
     OGRFeature::DestroyFeature( poFeature );
+  }
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   if(hasRes<0)
     addToMap(statusInfo,"Status","Failed");
 …
 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;
 …
     OGRFeature::DestroyFeature( poFeature );
+  }
   cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return res;

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

-                      r784
+                      r917
 #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*);
 …
   ZOO_DLL_EXPORT char* getStatusId(maps*,char*);
   ZOO_DLL_EXPORT void removeService(maps*,char*);
+  ZOO_DLL_EXPORT void end_sql();
+#endif
 #ifdef __cplusplus
 …
 #endif
-#endif

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

-                      r889
+                      r917
  * 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
 …
 #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"
 /**
 …
 /**
+ * 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
 …
     int i;
     char* tmp;
-    int cnt;
-    _HINTERNET *psInternet;
     for(i=0;i<12;i++)
 #ifndef WIN32
 …
 #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));
 …
   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;
+}
 …
  * @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;
+}
 …
   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);
 …
 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;
+    }
+  }
+}
 …
  * @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( );
 …
 #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;
+    }
 …
     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);
 …
   hInternet->ihandle[hInternet->nb].header=NULL;
   ++hInternet->nb;
+  hInternet->ihandle[hInternet->nb].header=NULL;
 #ifdef ULINET_DEBUG
 …
  */
 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++){
 …
     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);
 …
  */
 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");
 …
     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{
 …
+  }
   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{

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

-                      r889
+                      r917
  * 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
 …
 #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
 …
 #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
 …
   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*);
 …
   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*);
 …
   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*);

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

-                      r843
+                      r917
 #endif
+int cgiInit(){
+  fprintf(FCGI_stderr,"ZOO-Kernel initialization %s %d ... \n",__FILE__,__LINE__);
+  fflush(FCGI_stderr);
+  return 0;
+}
 /**
  * Main entry point for cgic.
 …
        if(res!=NULL)
          free(res);
     }else{
+    }else{
       char *buffer=new char[cgiContentLength+1];
       if(fread(buffer,sizeof(char),cgiContentLength,cgiIn)>0){
 …
+    }
+  }
   else{
+  else{
 #ifdef DEBUG
     dumpMap(tmpMap);
 …
     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);
 …
+    }
+  }
   if(strncasecmp(cgiContentType,"multipart/form-data",19)==0){
     map* tmp=getMap(tmpMap,"dataInputs");
 …
   if(strQuery!=NULL)
     free(strQuery);
   runRequest(&tmpMap);

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

-                      r889
+                      r917
 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
 …
 #endif
+#ifdef META_DB
+#include "meta_sql.h"
+#endif
 #ifdef USE_PYTHON
 #include "service_internal_python.h"
 …
 #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
 …
 #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
 …
 #ifdef WIN32
   #ifndef PROGRAMNAME
     #define PROGRAMNAME "zoo_loader.cgi"
   #endif
+#ifndef PROGRAMNAME
+#define PROGRAMNAME "zoo_loader.cgi"
+#endif
 #endif
 …
   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;
+}
 …
  */
 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;
 …
             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);
 …
+      {
         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;
 …
             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);
 …
                     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;
 …
               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);
 …
 sig_handler (int sig)
+{
   char tmp[100];
   const char *ssig;
 …
   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);
 …
 #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)
 …
   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 =
 …
 #ifdef USE_OTB
   if (strncasecmp (r_inputs->value, "OTB", 6) == 0)
+  if (strncasecmp (r_inputs->value, "OTB", 3) == 0)
+    {
       *eres =
 …
 #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);
 …
+    }
   *myMap = m;
   *ioutputs = request_output_real_format;
+  *ioutputs = request_output_real_format;
+}
 …
 #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", "");
 …
 #ifdef ETC_DIR
 #ifndef WIN32
     getcwd (ntmp, 1024);
+  getcwd (ntmp, 1024);
 #else
     _getcwd (ntmp, 1024);
+  _getcwd (ntmp, 1024);
 #endif
 #endif
 …
       char tmp1[13];
       sprintf (tmp1, "LC_ALL=%s", tmp);
       putenv (tmp1);
+      _putenv (tmp1);
 #endif
       free (tmp);
 …
       char tmp1[13];
       sprintf (tmp1, "LC_ALL=en_US");
       putenv (tmp1);
+      _putenv (tmp1);
 #endif
       setMapInMaps (m, "main", "language", "en-US");
 …
   char tmp1[17];
   sprintf (tmp1, "LC_NUMERIC=C");
   putenv (tmp1);
+  _putenv (tmp1);
 #endif
   bind_textdomain_codeset ("zoo-kernel", "UTF-8");
 …
   };
   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){
 …
     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;
 …
         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;
 …
   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
+  }
 …
        * 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);
 …
+            }
             inheritance(zooRegistry, &svc);
             printGetCapabilitiesForProcess(zooRegistry, m, n, svc);
+            printGetCapabilitiesForProcess(zooRegistry, m, doc, n, svc);
             freeService(&svc);
             free(svc);
 …
       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)
+        {
 …
+        }
       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);
 …
       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);
 …
             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);
 …
             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)
+              {
 …
+                      }
                       inheritance(zooRegistry, &svc);
+                      printDescribeProcessForProcess(zooRegistry, m, n, svc);
+#ifdef USE_HPC
+                      addNestedOutputs(&svc);
+#endif
+                      printDescribeProcessForProcess(zooRegistry, m, doc, n, svc);
                       freeService(&svc);
                       free(svc);
 …
                 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
 …
                     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)
+                      {
 …
                           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)
 …
                                        ("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");
 …
                             free (s1);
                             closedir (dirp);
                             xmlFreeDoc (doc);
+                            //xmlFreeDoc (doc);
                             xmlCleanupParser ();
                             zooXmlCleanupNs ();
 …
 #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);
 …
                     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)
+                      {
 …
                                    _("Unable to parse the ZCFG file: %s."),
                                    buff);
                         dup2 (saved_stdout, fileno (stdout));
+                        zDup2 (saved_stdout, fileno (stdout));
                         errorException (m, tmp01, "InvalidParameterValue",
                                         "Identifier");
 …
                         free (REQUEST);
                         closedir (dirp);
+                        if (corig != NULL)
+                          free (corig);
                         xmlFreeDoc (doc);
                         xmlCleanupParser ();
 …
                     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);
 …
             free (SERVICE_URL);
             fflush (stdout);
+#ifdef META_DB
+            close_sql(m,0);
+            //end_sql();
+#endif
             return 0;
+          }
 …
             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)
 …
+  }
   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 {
 …
   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);
 …
     return 0;
+  }
+  //InternetCloseHandle (&hInternet);
   // Define each env variable in runing environment
   maps *curs = getMaps (m, "env");
 …
 ) * 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,
 …
   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:
 …
+   *
    */
   maps *_tmpMaps = createMaps("lenv");
+  _tmpMaps = createMaps("lenv");
   char tmpBuff[100];
   struct ztimeval tp;
 …
     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");
 …
           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);
 …
           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);
 …
 #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;
 …
         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
 …
       fprintf (stderr, "\nPID : %d\n", cpid);
 #endif
 #ifndef WIN32
       pid = fork ();
 …
       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);
 …
           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,
 …
+          }
           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);
 …
             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
+        {
 …
            * 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,
 …
                     cpid, m, eres);
   fflush (stdout);
   /**
    * Ensure that if error occurs when freeing memory, no signal will return
 …
   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:
 …
         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);
 …
 #endif
   if (((int) getpid ()) != cpid || cgiSid != NULL)
+  if (((int) zGetpid ()) != cpid || cgiSid != NULL)
+    {
       exit (0);

TabularUnified trunk/zoo-project/zoo-services/cgal/Makefile ¶ ¶

-                      r779
+                      r917
 ZRPATH=../..
 include ${ZRPATH}/zoo-kernel/ZOOMakefile.opts
 CFLAGS=-I${INST_INCLUDE} ${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} ${CGAL_CFLAGS} -frounding-math -fPIC -DLINUX_FREE_ISSUE #-DDEBUG
+CFLAGS= ${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} ${CGAL_CFLAGS} -frounding-math -fPIC -DLINUX_FREE_ISSUE #-DDEBUG
 CC=gcc
 …
         g++ ${CFLAGS} -c ./delaunay.c
         g++ ${CFLAGS} -c ./voronoi.c
         g++ ${CFLAGS} -shared -o cgi-env/cgal_service.zo ./delaunay.o ./voronoi.o ./cgal_service.o ${GDAL_LIBS} ${MACOS_LD_FLAGS} ${CGAL_LDFLAGS} -lCGAL -lgmp ${GDAL_LIBS} -L${ZRPATH}/zoo-kernel/ -lzoo_service
+        g++ ${CFLAGS} -shared -o cgi-env/cgal_service.zo ./delaunay.o ./voronoi.o ./cgal_service.o ${GDAL_LIBS} ${CGAL_LDFLAGS} -lCGAL -lgmp ${GDAL_LIBS} -L${ZRPATH}/zoo-kernel/ -lzoo_service -lfcgi
 cgal_service.o: cgal_service.c cgal_service.h

TabularUnified trunk/zoo-project/zoo-services/cgal/cgal_service.c ¶ ¶

-                      r775
+                      r917
 #include "cgal_service.h"
 int parseInput(maps* conf,maps* inputs, std::vector<Point>* points,char* filename){
+int parseInput(maps* conf,maps* inputs, std::vector<Pointz>* points,char* filename){
   map* tmpm=NULL;
+  tmpm=getMapFromMaps(inputs,"InputPoints","value");
+  VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmpm->value,strlen(tmpm->value),FALSE);
+  VSIFCloseL(ifile);
+  tmpm=getMapFromMaps(inputs,"InputPoints","cache_file");
 #if GDAL_VERSION_MAJOR >= 2
+  GDALDataset *ipoDS =
+    (GDALDataset*) GDALOpenEx( filename,
+                               GDAL_OF_READONLY | GDAL_OF_VECTOR,
+                               NULL, NULL, NULL );
+  GDALDataset *ipoDS;
 #else
   OGRDataSource* ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
+  OGRDataSource* ipoDS;
 #endif
+  if(tmpm==NULL){
+    tmpm=getMapFromMaps(inputs,"InputPoints","value");
+    VSILFILE *ifile=VSIFileFromMemBuffer(filename,(GByte*)tmpm->value,strlen(tmpm->value),FALSE);
+    VSIFCloseL(ifile);
+#if GDAL_VERSION_MAJOR >= 2
+  ipoDS = (GDALDataset*) GDALOpenEx( filename,
+                                     GDAL_OF_READONLY | GDAL_OF_VECTOR,
+                                     NULL, NULL, NULL );
+#else
+  ipoDS = OGRSFDriverRegistrar::Open(filename,FALSE);
+#endif
+  }else
+#if GDAL_VERSION_MAJOR >= 2
+    ipoDS = (GDALDataset*) GDALOpenEx( tmpm->value,
+                                       GDAL_OF_READONLY | GDAL_OF_VECTOR,
+                                       NULL, NULL, NULL );
+#else
+    ipoDS = OGRSFDriverRegistrar::Open(tmpm->value,FALSE);
+#endif
   if( ipoDS == NULL )
+    {
 …
           break;
         if(poFeature->GetGeometryRef() != NULL){
           points->push_back(Point(OGR_G_GetX(poFeature->GetGeometryRef(),0),OGR_G_GetY(poFeature->GetGeometryRef(),0)));
+          points->push_back(Pointz(OGR_G_GetX(poFeature->GetGeometryRef(),0),OGR_G_GetY(poFeature->GetGeometryRef(),0)));
+        }
+      }

TabularUnified trunk/zoo-project/zoo-services/cgal/cgal_service.h ¶ ¶

-                      r469
+                      r917
 typedef CGAL::Exact_predicates_inexact_constructions_kernel            Kernel;
 typedef Kernel::Point_2                                                Point;
+typedef Kernel::Point_2                                                Pointz;
 int parseInput(maps*,maps*, std::vector<Point>*,char*);
+int parseInput(maps*,maps*, std::vector<Pointz>*,char*);
 #endif

TabularUnified trunk/zoo-project/zoo-services/cgal/cgi-env/Voronoi.zcfg ¶ ¶

-                      r536
+                      r917
     </Default>
     <Supported>
+      mimeType = image/png
+      useMapserver = true
+      asReference = true
+      msStyle = STYLE COLOR 125 0 105 OUTLINECOLOR 0 0 0 WIDTH 0.3 OPACITY 65 END
+    </Supported>
+    <Supported>
      mimeType = text/xml
      encoding = base64

TabularUnified trunk/zoo-project/zoo-services/cgal/delaunay.c ¶ ¶

r775	r917
40	40	OGRRegisterAll();
41	41
42		std::vector<Point> points;
	42	std::vector<Pointz> points;
43	43	if(int res=parseInput(conf,inputs,&points,"/vsimem/tmp")!=SERVICE_SUCCEEDED)
44	44	return res;

TabularUnified trunk/zoo-project/zoo-services/cgal/voronoi.c ¶ ¶

-                      r775
+                      r917
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Triangulation_euclidean_traits_xy_3.h>
+//#include <CGAL/Triangulation_euclidean_traits_2.h>
 #include <CGAL/Delaunay_triangulation_2.h>
 #include <CGAL/Constrained_Delaunay_triangulation_2.h>
+//#include <CGAL/Constrained_Delaunay_triangulation_2.h>
 #include <CGAL/Triangulation_conformer_2.h>
 #include <CGAL/Triangulation_face_base_2.h>
 …
 typedef CGAL::Delaunay_triangulation_2<Kernel>  Triangulation;
+typedef Triangulation::Face_iterator  Face_iterator;
 typedef Triangulation::Edge_iterator  Edge_iterator;
 typedef Triangulation::Vertex_circulator Vertex_circulator;
 …
   int Voronoi(maps*& conf,maps*& inputs,maps*& outputs){
 #ifdef DEBUG
+    //#ifdef DEBUG
     fprintf(stderr,"\nService internal print\nStarting\n");
+#endif
+    //#endif
+    //return SERVICE_FAILED;
     maps* cursor=inputs;
     OGRGeometryH geometry,res;
 …
     tmpm=getMapFromMaps(inputs,"InputPoints","value");
+    fprintf(stderr," **** %s %d\n",__FILE__,__LINE__);
+    fflush(stderr);
     OGRRegisterAll();
+    std::vector<Point> points;
+    if(int res=parseInput(conf,inputs,&points,"/vsimem/tmp")!=SERVICE_SUCCEEDED)
+      return res;
+    std::vector<Pointz> points;
+    if(int res=parseInput(conf,inputs,&points,"/vsimem/tmp")!=SERVICE_SUCCEEDED){
+      fprintf(stderr," **** %s %d\n",__FILE__,__LINE__);
+      fflush(stderr);
+      return SERVICE_FAILED;
+    }
+    fprintf(stderr," **** %s %d\n",__FILE__,__LINE__);
+    fflush(stderr);
     Triangulation T;
     T.insert(points.begin(), points.end());
     OGRRegisterAll();
+    //OGRRegisterAll();
     /* -------------------------------------------------------------------- */
     /*      Try opening the output datasource as an existing, writable      */
 …
     int ns = 0;
     int nr = 0;
+    int nf = 0;
+    Face_iterator fit =T.faces_begin();
+    FILE* f=fopen("/tmp/toto.log","w+");
+    for ( ; fit !=T.faces_end(); ++fit) {
+      fprintf(stderr," *** %s %d %d %d\n",__FILE__,__LINE__,nf,fit.info());
+      fflush(stderr);
+      nf++;
+    }
+    fclose(f);
     Edge_iterator eit =T.edges_begin();
     for ( ; eit !=T.edges_end(); ++eit) {
       CGAL::Object o = T.dual(eit);
       if (const Kernel::Segment_2 *tmp=CGAL::object_cast<Kernel::Segment_2>(&o)) {
+        const Point p1=tmp->source();
+        const Point p2=tmp->target();
+        const Pointz p1=tmp->source();
+        const Pointz p2=tmp->target();
+        fprintf(stderr,"P1 %d %d | P2 %d %d\n",p1.x(),p1.y(),p2.x(),p2.y());
 #ifdef DEBUG
         fprintf(stderr,"P1 %d %d | P2 %d %d\n",p1.x(),p1.y(),p2.x(),p2.y());
 …
+      }
       else if (const Kernel::Ray_2 *tmp=CGAL::object_cast<Kernel::Ray_2>(&o)) {
         const Point p1=tmp->source();
         const Point p2=tmp->point(2);
+        const Pointz p1=tmp->source();
+        const Pointz p2=tmp->point(2);
         OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( poDstLayer ) );
         OGRGeometryH currLine=OGR_G_CreateGeometry(wkbLineString);
 …
     fprintf(stderr,"\nService internal print\n===\n");
 #endif
     OGRCleanupAll();
+    //OGRCleanupAll();
     return SERVICE_SUCCEEDED;
+  }

TabularUnified trunk/zoo-project/zoo-services/gdal/dem/cgi-env/Gdal_Dem.zcfg ¶ ¶

-                      r412
+                      r917
     <Default />
    </LiteralData>
+  [co]
+   Title = Creation Option
+   Abstract = string representing options (NAME=VALUE)
+   minOccurs = 0
+   maxOccurs = 1
+   <LiteralData>
+    DataType = string
+    <Default />
+   </LiteralData>
  </DataInputs>
  <DataOutputs>

TabularUnified trunk/zoo-project/zoo-services/gdal/dem/service.c ¶ ¶

-                      r444
+                      r917
       setMapInMaps(outputs,"Result","value",tmpMap->value);
+    }
+    tmpMap=getMapFromMaps(inputs,"co","value");
+    if(tmpMap!=NULL){
+      papszCreateOptions = CSLAddString( papszCreateOptions, tmpMap->value );
+      map* tmpMap1;
+      maps* tmpMaps=getMaps(inputs,"co");
+      if((tmpMap1=getMapFromMaps(inputs,"co","length"))!=NULL){
+        int i=1;
+        int length=atoi(tmpMap1->value);
+        for(;i<length;i++){
+          tmpMap=getMapArray(tmpMaps->content,"value",i);
+          papszCreateOptions = CSLAddString( papszCreateOptions, tmpMap->value );
+        }
+      }
+    }
     tmpMap=NULL;

TabularUnified trunk/zoo-project/zoo-services/hello-mono/cgi-env/longProcessMono.zcfg ¶ ¶

-                      r794
+                      r917
 [longProcessMono]
  Title = Create a welcome message string.
  Abstract = Create a welcome string.
+ Title = Demo long process.
+ Abstract = This service doesn't do anything except taking its time, it demonstrates how to use the updateStatus function from your ZOO Service.
  processVersion = 2
  storeSupported = true
 …
    Title = Input string
    Abstract = The name to display in the welcome message.
    minOccurs = 1
+   minOccurs = 0
    maxOccurs = 1
    <LiteralData>
     dataType = int
+    <Default>
+    AllowedValues = 101,202,303,404
+    rangeMin = -100
+    rangeMax = 100
+    rangeSpacing = 1
+    rangeClosure = co
+      value = 11
+    </Default>
+    <Supported>
+        AllowedValues = 405,502,503,504
+    </Supported>
+    <Supported>
+        AllowedValues = 540,502,603,604
+    </Supported>
+    <Default />
    </LiteralData>
  </DataInputs>

TabularUnified trunk/zoo-project/zoo-services/ogr/base-vect-ops-py/cgi-env/ogr_sp.py ¶ ¶

-                      r465
+                      r917
 def extractInputs(conf,obj):
+    if obj.keys().count("cache_file"):
+        print >> sys.stderr,obj
+        geometry=[]
+        ds = osgeo.ogr.Open(obj["cache_file"])
+        lyr = ds.GetLayer(0)
+        feat = lyr.GetNextFeature()
+        while feat is not None:
+            geometry+=[feat.Clone()]
+            feat.Destroy()
+            feat = lyr.GetNextFeature()
+        ds.Destroy()
+        return geometry
     if obj["mimeType"]=="application/json":
         return createLayerFromJson(conf,obj["value"])

TabularUnified trunk/zoo-project/zoo-services/ogr/base-vect-ops/service.c ¶ ¶

-                      r769
+                      r917
+          {
             if( EQUAL(
+            if(
 #if GDAL_VERSION_MAJOR >=2
                       poR->GetDriver(iDriver)->GetDescription()
 #else
                       poR->GetDriver(iDriver)->GetName()
 #endif
                       ,oDriver1) )
+                EQUAL(poR->GetDriver(iDriver)->GetDescription(),oDriver1)
+#else
+                EQUAL(poR->GetDriver(iDriver)->GetName(),oDriver1)
+#endif
+                )
+              {
                 poDriver = poR->GetDriver(iDriver);

TabularUnified trunk/zoo-project/zoo-services/ogr/ogr2ogr/service.c ¶ ¶

-                      r790
+                      r917
 #endif
+{
+    char  *pszDialect = NULL;
     const char  *pszFormat = "ESRI Shapefile";
     const char  *pszDataSource = NULL;
 …
       sprintf(serverAddress,"%s",tmpMap->value);
+    }
     tmpMap=NULL;
     char tmpurl[1024];
 …
     if(tmpMap!=NULL && strncasecmp(tmpMap->value,"NULL",4)!=0){
       pszSQLStatement = tmpMap->value;
+    }
+    tmpMap=getMapFromMaps(inputs,"dialect","value");
+    if(tmpMap!=NULL){
+      pszDialect=strdup(tmpMap->value);
+    }
 …
           dfMaxSegmentLength = atof(tmpMap->value);
+    }
+    /*tmpMap=NULL;
+    tmpMap=getMapFromMaps(inputs,"segmentize","value");
+    if(tmpMap!=NULL){
+          dfMaxSegmentLength = atof(tmpMap->value);
+    }*/
     tmpMap=NULL;
     tmpMap=getMapFromMaps(inputs,"InputDSN","value");
 …
         poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
                                         NULL );
+                                        pszDialect );
         if( poResultSet != NULL )
 …
+            }
             poDS->ReleaseResultSet( poResultSet );
+        }
+    }
+        }else{
+          setMapInMaps(conf,"lenv","message","There was an error when running yoru SQL query.");
+          if(pszDialect!=NULL)
+            free(pszDialect);
+          return SERVICE_FAILED;
+        }
+    }
+    if(pszDialect!=NULL)
+      free(pszDialect);
 /* -------------------------------------------------------------------- */
 …
 #ifdef ZOO_SERVICE
+    outputs->content=createMap("value",(char*)pszwebDestData);
+    setMapInMaps(outputs,"OutputedDataSourceName","value",(char*)pszwebDestData);
+    //outputs->content=createMap("value",(char*)pszwebDestData);
 #endif
 …
     fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
     OGRCleanupAll();
+    //OGRCleanupAll();
     fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
 …
 #ifdef ZOO_SERVICE
+    //sleep(10);
     return SERVICE_SUCCEEDED;
 #else

TabularUnified trunk/zoo-project/zoo-services/utils/registry/Makefile ¶ ¶

-                      r779
+                      r917
 ZRPATH=../../..
 include ${ZRPATH}/zoo-kernel/ZOOMakefile.opts
 CFLAGS=${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} -DLINUX_FREE_ISSUE #-DDEBUG
+ZCFLAGS=-I${ZRPATH}/zoo-kernel/ ${CFLAGS} ${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} -DLINUX_FREE_ISSUE #-DDEBUG
 YAML_FILES=""
 …
 cgi-env/wps_registry.zo: service.c
         g++ ${CFLAGS} -shared -fpic -o cgi-env/wps_registry.zo ./service.c ${GDAL_LIBS} ${XML2LDFLAGS} ${MACOS_LD_FLAGS} ${ZOO_LDFLAGS} ${MACOS_LD_NET_FLAGS} ${XSLT_LDFLAGS} -lfcgi -L${ZRPATH}/zoo-kernel/ -lzoo_service ${ZRPATH}/zoo-kernel/server_internal.o ${ZRPATH}/zoo-kernel/lex.cr.o ${ZRPATH}/zoo-kernel/lex.sr.o ${ZRPATH}/zoo-kernel/service_conf.tab.o ${ZRPATH}/zoo-kernel/main_conf_read.tab.o ${ZRPATH}/zoo-kernel/response_print.o ${YAML_FILES} ${MS_FILES} ${MS_LDFLAGS} ${YAML_LDFLAGS}
+        g++ ${ZCFLAGS} -shared -fpic -o cgi-env/wps_registry.zo ./service.c ${GDAL_LIBS} ${XML2LDFLAGS} ${MACOS_LD_FLAGS} ${ZOO_LDFLAGS} ${MACOS_LD_NET_FLAGS} ${XSLT_LDFLAGS} -lfcgi -L${ZRPATH}/zoo-kernel/ -lzoo_service ${ZRPATH}/zoo-kernel/server_internal.o ${ZRPATH}/zoo-kernel/lex.cr.o ${ZRPATH}/zoo-kernel/lex.sr.o ${ZRPATH}/zoo-kernel/service_conf.tab.o ${ZRPATH}/zoo-kernel/main_conf_read.tab.o ${ZRPATH}/zoo-kernel/response_print.o ${YAML_FILES} ${MS_FILES} ${MS_LDFLAGS} ${YAML_LDFLAGS}
 install:

TabularUnified trunk/zoo-project/zoo-services/utils/registry/service.c ¶ ¶

r778	r917
80	80	root_nodes[1][1],"2.0.0",1);
81	81	setMapInMaps(conf,"main","rversion","2.0.0");
82		printDescribeProcessForProcess(zooRegistry,conf,n,inherited);
	82	printDescribeProcessForProcess(zooRegistry,conf,doc,n,inherited);
83	83	setMapInMaps(conf,"main","rversion","1.0.0");
84	84

TabularUnified trunk/zoo-project/zoo-services/utils/status/Makefile ¶ ¶

-                      r811
+                      r917
 ZRPATH=../../..
 include ${ZRPATH}/zoo-kernel/ZOOMakefile.opts
 CFLAGS=-I${INST_INCLUDE} ${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} -DLINUX_FREE_ISSUE #-DDEBUG
+CFLAGS1=${CFLAGS} -I${INST_INCLUDE} ${ZOO_CFLAGS} ${XML2CFLAGS} ${GDAL_CFLAGS} ${PYTHONCFLAGS} -DLINUX_FREE_ISSUE #-DDEBUG
 cgi-env/wps_status.zo: service.c
         g++ ${CFLAGS} -shared -fpic -o cgi-env/wps_status.zo ./service.c ${GDAL_LIBS} ${XML2LDFLAGS} ${MACOS_LD_FLAGS} ${ZOO_LDFLAGS} ${MACOS_LD_NET_FLAGS} ${XSLT_LDFLAGS} ${FCGI_LDFLAGS} -L${ZRPATH}/zoo-kernel/ -lzoo_service
+        g++ ${CFLAGS1} -shared -fpic -o cgi-env/wps_status.zo ./service.c ${GDAL_LIBS} ${XML2LDFLAGS} ${MACOS_LD_FLAGS} ${ZOO_LDFLAGS} ${MACOS_LD_NET_FLAGS} ${XSLT_LDFLAGS} ${FCGI_LDFLAGS} -L${ZRPATH}/zoo-kernel/ -lzoo_service
 install:

TabularUnified trunk/zoo-project/zoo-services/utils/status/service.c ¶ ¶

-                      r788
+                      r917
       return SERVICE_FAILED;
+    }
+    map* tmpMap1=getMapFromMaps(conf,"lenv","semaphore");
+    if(tmpMap1!=NULL && strcasecmp(tmpMap1->value,"Created")==0)
+      removeShmLock(conf,1);
     sprintf(xslFileName,"%s/updateStatus.xsl",tmpMmap->value);
     xmlSubstituteEntitiesDefault(1);
 …
        */
       char *tmpStr=_getStatus(conf,tmpMap->value);
 #ifdef DEBUG
+      //#ifdef DEBUG
       fprintf(stderr,"DEBUG: %s \n",tmpStr);
 #endif
+      //#endif
       if(tmpStr!=NULL && strncmp(tmpStr,"-1",2)!=0){
         char *tmpStr1=strdup(tmpStr);
 …
       char message[10];
       sprintf(message,"Step %d",i);
+      fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
+      fflush(stderr);
       updateStatus(conf,i,message);
 #ifndef WIN32

Open WPS platform

Legend:

trunk ¶ ¶

TabularUnified trunk/zoo-project/HISTORY.txt ¶ ¶

TabularUnified trunk/zoo-project/zoo-api/js/ZOO-api.js ¶ ¶

TabularUnified trunk/zoo-project/zoo-client/lib/js/wps-client/zoo.js ¶ ¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TabularUnified trunk/zoo-project/zoo-services/cgal/Makefile ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/cgal/cgal_service.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/cgal/cgal_service.h ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/cgal/cgi-env/Voronoi.zcfg ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/cgal/delaunay.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/cgal/voronoi.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/gdal/dem/cgi-env/Gdal_Dem.zcfg ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/gdal/dem/service.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/hello-mono/cgi-env/longProcessMono.zcfg ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/ogr/base-vect-ops-py/cgi-env/ogr_sp.py ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/ogr/base-vect-ops/service.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/ogr/ogr2ogr/service.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/utils/registry/Makefile ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/utils/registry/service.c ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/utils/status/Makefile ¶ ¶

TabularUnified trunk/zoo-project/zoo-services/utils/status/service.c ¶ ¶

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links