Changeset 917 for trunk/zoo-project


Ignore:
Timestamp:
May 7, 2019, 2:17:08 PM (6 months ago)
Author:
djay
Message:

Merge prototype-v0 branch in trunk

Location:
trunk
Files:
59 edited
20 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/zoo-project/HISTORY.txt

    r828 r917  
    11Version 1.7.0-dev
     2  * Fix issue with UOM definitions in zcfg2sql
     3  * Make callback and HPC support independent from each other
     4  * Update SAGA-GIS support to version 7.2.0
     5  * Add support for custom MapServer style definition for raster output
     6  * Fix returned bbox definition #170
     7  * Store semaphore status in lenv section for future deletion
     8  * Update Windows support to newer compiler
     9  * Fix issue with UpdateStatus function from the Mono ZOO-API
     10  * Add logging functionality and other utility functions to the C-API
     11  * Return an exception for every output for which nb_pixel or
     12  nb_features is 0
     13  * Add a shared key to the security section to differentiate the
     14  referenced data
     15  * Add MapServer output style definition depending on the geometry
     16  type
     17  * Add ogr.tindex service
     18  * Add support for literaldata input arrays and to call services
     19  asyncrhonously from the JavaScript ZOO-API   
     20  * Expose a sleep function to the JavaScript ZOO-API
     21  * Provide FinalizeHPC and FinalizeHPC1 services using scontrol and
     22  sacct respectively 
     23  * Store md5sum of the cached file (so, local to the WPS server) to
     24  compare before uploading (if different md5sum) on the HPC server
     25  * Add support for R language
     26  * Add support for using "file://"  for referenced data input
     27  * Add an optional ecookie key for returning third-party cookies
     28  * Fix issue when parsing BoundingBox input #163
     29  * Add memory key to the main section to force the ZOO-Kernel to load
     30  data into memory or use local file
     31  * Add the dialect input to the ogr2ogr service
     32  * Store the list of generated mapfiles in a file (cf DeleteData service)
     33  * Define the correct MS_IMAGEMODE in the generated mapfile
     34  * Option to use MapServer support to publish heatmap
     35  * Add status_code key to the lenv for setting Status HTTP response header
     36  * Add the Creation Option inputs to the Gdal_Dem service
     37  * Add prohibited key in the callback section to define a list of
     38  services not requiring any invocation
     39  * Produce zcfg for OTB applications using the correct default pixel type
     40  * Add asynchronous callback invocation to send information about
     41  the ongoing services to a third-party software
     42  * Add mapsToJson, mapsToJson, and elementsToJson to the API
     43  * Provide a zcfg2sql tool to convert a zcfg metadata file to SQL script
     44  * Add support to store service metadata information into a database
     45  * Add HPC Support for remote execution of SBATCH scripts through Slurm
     46  * Add cookie reference to _HINTERNET
    247  * Support headers for GET requests from the js ZOO-API
    348  * Pass all headers listed in the attributes parameter from the
  • trunk/zoo-project/zoo-api/js/ZOO-api.js

    r828 r917  
    36863686        }
    36873687        var builder = this.parseData[data.localName().toLowerCase()];
    3688         if (builder)
     3688        if (builder){
    36893689          res.push(builder.apply(this,[data]));
     3690        }
    36903691        else
    36913692          res.push(null);
     3693        data=null;
    36923694      }
    36933695      return res.length>1?res:res[0];
    3694     } else
    3695       return null;
     3696    }
     3697    else{
     3698      var hasPercentCompleted=true;
     3699      var status = node.*::Status.*::ProcessStarted;
     3700      var msg = node.*::Status.*::ProcessStarted.*::*[0];
     3701      if(!status || !msg){
     3702        status = node.*::Status.*::ProcessAccepted;
     3703        msg = node.*::Status.*::ProcessAccepted.*::*[0];
     3704        msg=msg.toString();
     3705        hasPercentCompleted=false;
     3706      }else
     3707          msg=msg.toString();
     3708      if(status!=null && node.@statusLocation){
     3709        var res={"status": node.@statusLocation.toXMLString(), "message": msg};
     3710        if(hasPercentCompleted)
     3711          res["percentCompleted"]=status.@percentCompleted.toXMLString();
     3712        return res;
     3713      }else
     3714        return null;
     3715    }
    36963716  },
    36973717  /**
     
    37483768     * {Object} A WPS reference response.
    37493769     */
    3750     'reference': function(node) {
    3751       var result = {type:'reference',value:node.@href};
     3770    'reference': function(lnode) {
     3771      var lhref=lnode.@href;
     3772      var lmimeType=lnode.@mimeType;
     3773      var result = {type:'reference',value:lhref.toXMLString(),mimeType:lmimeType.toXMLString()};
    37523774      return result;
    37533775    }
     
    61476169  identifier: null,
    61486170  /**
     6171   * Property: async
     6172   * {Bool} Define if the process should run asyncrhonously (true) or not (false, default).
     6173   */
     6174  async: null,
     6175  /**
    61496176   * Constructor: ZOO.Process
    61506177   * Create a new Process
     
    61586185    this.url = url;
    61596186    this.identifier = identifier;
     6187    this.async = (arguments.length>2?arguments[2]:false);
    61606188  },
    61616189  /**
     
    61736201    if (this.identifier == null)
    61746202      return null;
    6175     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>');
     6203      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>');
    61766204    body = body.toXMLString();
    61776205    var headers=['Content-Type: text/xml; charset=UTF-8'];
    6178       if(arguments.length>2){
    6179         headers[headers.length]=arguments[2];
    6180       }
     6206    if(arguments.length>2){
     6207      headers[headers.length]=arguments[2];
     6208    }
    61816209    var response = ZOO.Request.Post(this.url,body,headers);
    61826210    return response;
     
    61956223     */
    61966224    'ResponseDocument': function(identifier,obj) {
    6197       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>');
     6225      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>');
     6226      output = output.toXMLString();
     6227      return output;
     6228    },
     6229    'RawDataOutput': function(identifier,obj) {
     6230      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>');
    61986231      if (obj.encoding)
    61996232        output.*::Data.*::ComplexData.@encoding = obj.encoding;
     
    62026235      output = output.toXMLString();
    62036236      return output;
    6204     },
    6205     'RawDataOutput': function(identifier,obj) {
    6206       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>');
    6207       if (obj.encoding)
    6208         output.*::Data.*::ComplexData.@encoding = obj.encoding;
    6209       if (obj.schema)
    6210         output.*::Data.*::ComplexData.@schema = obj.schema;
    6211       output = output.toXMLString();
    6212       return output;
    62136237    }
    62146238
     
    62316255     */
    62326256    'complex': function(identifier,data) {
    6233       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>');
     6257      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>');
    62346258      if(data.xlink)
    6235         input.*::Reference.@mimeType = data.mimetype ? data.mimetype : 'application/json';
     6259        input.*::Reference.@mimeType = data.mimetype ? data.mimetype : 'application/json';
    62366260      else
    6237         input.*::Data.*::ComplexData.@mimeType = data.mimetype ? data.mimetype : 'application/json';
     6261        input.*::Data.*::ComplexData.@mimeType = data.mimetype ? data.mimetype : 'application/json';
    62386262      if (data.encoding)
    62396263        input.*::Data.*::ComplexData.@encoding = data.encoding;
     
    62416265        input.*::Data.*::ComplexData.@schema = data.schema;
    62426266      input = input.toXMLString();
    6243       return input;
     6267      if(data.value)
     6268        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>'));
     6269      else
     6270        return input;
    62446271    },
    62456272    /**
     
    62696296     */
    62706297    'literal': function(identifier,data) {
    6271         if(data && !eval(data["isArray"])){
    6272             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>');
    6273       if (data.type)
    6274         input.*::Data.*::LiteralData.@dataType = data.type;
    6275       if (data.uom)
    6276         input.*::Data.*::LiteralData.@uom = data.uom;
    6277       input = input.toXMLString();
    6278       return input;
    6279         }else if(data){
    6280             var inputf="";
    6281             for(i=0;i<parseInt(data["length"]);i++){
    6282                 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>');
    6283                 if (data.type)
    6284                     input.*::Data.*::LiteralData.@dataType = data.type;
    6285                 if (data.uom)
    6286                     input.*::Data.*::LiteralData.@uom = data.uom;
    6287                 inputf += input.toXMLString();
    6288             }
    6289             return inputf;
     6298      if(data && !eval(data["isArray"])){
     6299        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>');
     6300        if (data.type)
     6301          input.*::Data.*::LiteralData.@dataType = data.type;
     6302        if (data.uom)
     6303          input.*::Data.*::LiteralData.@uom = data.uom;
     6304        input = input.toXMLString();
     6305        return input;
     6306      }else if(data){
     6307        var inputf="";
     6308        for(i=0;i<parseInt(data["length"]);i++){
     6309          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>');
     6310          if (data.type)
     6311            input.*::Data.*::LiteralData.@dataType = data.type;
     6312          if (data.uom)
     6313            input.*::Data.*::LiteralData.@uom = data.uom;
     6314          inputf += input.toXMLString();
    62906315        }
    6291        
     6316        return inputf;
     6317      }
    62926318    }
    62936319  },
     
    63186344
    63196345  buildDataOutputsNode:function(outputs){
    6320     var data, builder, outputsArray=[];
     6346    var data, builder, outputsArray=[[],[]];
    63216347    for (var attr in outputs) {
    63226348      data = outputs[attr];
    63236349      builder = this.buildOutput[data.type];
    6324       outputsArray.push(builder.apply(this,[attr,data]));
    6325     }
    6326     return outputsArray.join('\n');
     6350      if(data.type=="ResponseDocument")
     6351        outputsArray[0].push(builder.apply(this,[attr,data]));
     6352      else
     6353        outputsArray[1].push(builder.apply(this,[attr,data]));     
     6354    }
     6355    var responseDocuments=(outputsArray[0].length>0?
     6356                           new XML('<wps:ResponseDocument  '+(this.async?'storeExecuteResponse="true" status="true"':'')+' xmlns:wps="'+this.namespaces['wps']+'">'+
     6357                                   outputsArray[0].join('\n')+
     6358                                   '</wps:ResponseDocument>')
     6359                           :
     6360                           null);
     6361    var rawDataOutputs=(outputsArray[1].length>0?
     6362                        outputsArray[1].join('\n')
     6363                        :
     6364                        null);
     6365    var res=new XML('<wps:ResponseForm xmlns:wps="'+this.namespaces['wps']+'">'+
     6366                    (responseDocuments!=null?responseDocuments.toXMLString():"")+
     6367                    (rawDataOutputs!=null?rawDataOutputs:"")+
     6368                    '</wps:ResponseForm>');
     6369    return res.toXMLString();
    63276370  },
    63286371
  • trunk/zoo-project/zoo-client/lib/js/wps-client/zoo.js

    r719 r917  
    679679
    680680            $.ajax({
    681                 url: closure.statusLocation[sid]
     681                url: closure.statusLocation[sid]+"&timestamp="++(new Date()).getTime()
    682682            })
    683683                .fail(
  • trunk/zoo-project/zoo-kernel/Makefile.in

    r815 r917  
    99
    1010service.o: service.c service.h
    11         gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
     11        g++ ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
    1212
    1313main_conf_read.tab.c: main_conf_read.y service.h
     
    3838        gcc -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c ulinet.c
    3939
     40sshapi.o: sshapi.c
     41        g++ -fPIC ${CFLAGS} -c sshapi.c
     42
     43service_json.o: service_json.c
     44        g++ -fPIC ${JSON_CFLAGS} ${CFLAGS} -c service_json.c
     45
     46service_callback.o: service_callback.c
     47        g++ -fPIC ${XML2CFLAGS} ${GDAL_CFLAGS} ${JSON_CFLAGS} ${CFLAGS} -c service_callback.c
     48
    4049request_parser.o: request_parser.c request_parser.h
    4150        g++ -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c request_parser.c
    4251
    4352sqlapi.o: sqlapi.c sqlapi.h
    44         g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
     53        g++ -fPIC ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
    4554
    4655caching.o: caching.c
     
    4857
    4958response_print.o: response_print.c response_print.h
    50         g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c response_print.c
     59        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} ${HPC_ENABLED} -c response_print.c
    5160
    5261server_internal.o: server_internal.c server_internal.h service.h mimetypes.h
    53         g++ ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
     62        g++ ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
    5463
    5564service_internal.o: service_internal.c service_internal.h service.h
    56         gcc ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
     65        gcc ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
    5766
    5867service_yaml.o: service_yaml.c service.h
    5968        gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_yaml.c
     69
     70meta_sql.o: meta_sql.c meta_sql.h service.h
     71        g++  ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -c meta_sql.c
    6072
    6173service_internal_ms.o: service_internal_ms.c
     
    6678        g++ ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c service_internal_python.c
    6779
     80service_internal_r.o: service_internal_r.c service.h
     81        g++ ${XML2CFLAGS} ${RCFLAGS} ${CFLAGS} -c service_internal_r.c
     82
    6883service_internal_otb.o: service_internal_otb.c service_internal_otb.h service.h
    6984        g++ ${XML2CFLAGS} ${OTBCFLAGS} ${CFLAGS} -c service_internal_otb.c
     85
     86service_internal_hpc.o: service_internal_hpc.c service_internal_hpc.h service.h
     87        g++  ${JSON_CFLAGS} ${XML2CFLAGS} ${HPCCFLAGS} ${CFLAGS} -c service_internal_hpc.c
    7088
    7189service_internal_saga.o: service_internal_saga.c service_internal_saga.h service.h
     
    99117        g++ -c ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} service_loader.c
    100118
    101 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}
    102         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
     119zoo_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}
     120        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
    103121
    104122libzoo_service.${EXT}: version.h service_internal.o service.o sqlapi.o
    105         gcc -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS}
     123        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}
    106124
    107 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}
    108         g++ -g -O2 ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
    109         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}
     125zoo_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}
     126        g++ -g -O2 ${JSON_CFLAGS} ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
     127        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}
    110128
    111 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}
     129zcfg2yaml: 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}
    112130        g++ -g -O2 ${JSCFLAGS} ${RUBYCFLAGS} ${XML2CFLAGS} ${CFLAGS} -c zcfg2yaml.c  -fno-common -DPIC -o zcfg2yaml.o
    113         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}
     131        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}
    114132
    115133install: zoo_loader.cgi
  • trunk/zoo-project/zoo-kernel/ZOOMakefile.opts.in

    r866 r917  
    3030YAML_FILE1=@YAML_FILE1@
    3131
     32JSON_CFLAGS=@JSON_CPPFLAGS@
     33JSON_LDFLAGS=@JSON_LDFLAGS@
     34JSON_FILE=@JSON_FILE@
     35
     36METADB_ENABLED=@METADB@
     37METADB_FILE=@METADB_FILE@
     38
     39
    3240GDAL_CFLAGS=@GDAL_CFLAGS@
    3341GDAL_LIBS=@GDAL_LIBS@
     
    5058PYTHON_FILE=@PYTHON_FILE@
    5159
     60RCFLAGS=@R_CPPFLAGS@
     61RLDFLAGS=@R_LDFLAGS@
     62R_ENABLED=@R_ENABLED@
     63R_FILE=@R_FILE@
     64
    5265RUBYCFLAGS=@RUBY_CPPFLAGS@
    5366RUBYLDFLAGS=@RUBY_LDFLAGS@
     
    6881
    6982ZOO_CFLAGS=-I${ZRPATH}/../thirds/cgic206/ -I${ZRPATH}/zoo-kernel/
    70 ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ -luuid
     83ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ @UUID_LDFLAGS@
    7184
    7285JAVACFLAGS=@JAVA_CPPFLAGS@
     
    8093PHP_FILE=@PHP_FILE@
    8194
    82 
    8395PERLCFLAGS=@PERL_CPPFLAGS@
    8496PERLLDFLAGS=@PERL_LDFLAGS@
    8597PERL_ENABLED=@PERL_ENABLED@
    8698PERL_FILE=@PERL_FILE@
     99
     100HPCCFLAGS=@SSH2_CPPFLAGS@ @HPC_CPPFLAGS@
     101HPCLDFLAGS=@SSH2_LDFLAGS@ @HPC_LDFLAGS@
     102HPC_ENABLED=@HPC_ENABLED@
     103HPC_FILES=@HPC_FILES@
     104
     105CALLBACK_FILE=@CALLBACK_FILE@
     106CALLBACK_USE=@CALLBACK_USE@
    87107
    88108OTBCFLAGS=@OTB_CPPFLAGS@
     
    101121MONO_FILE=@MONO_FILE@
    102122
    103 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
    104 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}
     123CFLAGS=@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
     124LDFLAGS=-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@
    105125
    106126DATAROOTDIR=@datarootdir@/zoo-project
  • trunk/zoo-project/zoo-kernel/caching.c

    r837 r917  
    2323 */
    2424
     25#include <openssl/md5.h>
     26#include <openssl/evp.h>
    2527#include "caching.h"
    2628#include "service.h"
    2729#include "service_internal.h"
    2830#include "response_print.h"
    29 #include <openssl/md5.h>
    30 #include <openssl/hmac.h>
    31 #include <openssl/evp.h>
    32 #include <openssl/bio.h>
    33 #include <openssl/buffer.h>
    34 
     31#ifdef MS_FORCE_LOCAL_FILE_USE
     32#include "ogr_api.h"
     33#include "mapserver.h"
     34#endif
    3535/**
    3636 * Compute md5
     
    4141 */
    4242char* getMd5(char* url){
    43   EVP_MD_CTX md5ctx;
     43  EVP_MD_CTX *md5ctx=EVP_MD_CTX_create();
    4444  char* fresult=(char*)malloc((EVP_MAX_MD_SIZE+1)*sizeof(char));
    4545  unsigned char result[EVP_MAX_MD_SIZE];
    4646  unsigned int len;
    47   EVP_DigestInit(&md5ctx, EVP_md5());
    48   EVP_DigestUpdate(&md5ctx, url, strlen(url));
    49   EVP_DigestFinal_ex(&md5ctx,result,&len);
    50   EVP_MD_CTX_cleanup(&md5ctx);
     47  EVP_DigestInit(md5ctx, EVP_md5());
     48  EVP_DigestUpdate(md5ctx, url, strlen(url));
     49  EVP_DigestFinal_ex(md5ctx,result,&len);
     50  EVP_MD_CTX_destroy(md5ctx);
    5151  int i;
    5252  for(i = 0; i < len; i++){
    5353    if(i>0){
    54       char *tmp=strdup(fresult);
     54      char *tmp=zStrdup(fresult);
    5555      sprintf(fresult,"%s%02x", tmp,result[i]);
    5656      free(tmp);
     
    6262}
    6363
     64/**
     65 * Compute md5 of a file
     66 *
     67 * @param file the char*
     68 * @return a char* representing the md5 of the url
     69 * @warning make sure to free resources returned by this function
     70 */
     71char* getMd5f(char* file){
     72  EVP_MD_CTX *md5ctx=EVP_MD_CTX_create();
     73  char* fresult=(char*)malloc((EVP_MAX_MD_SIZE+1)*sizeof(char));
     74  unsigned char result[EVP_MAX_MD_SIZE];
     75  unsigned int len;
     76  int bytes;
     77  int dlen=65536;
     78  unsigned char data[65537];
     79  FILE *inFile = fopen (file, "rb");
     80  EVP_DigestInit(md5ctx, EVP_md5());
     81  while ((bytes = fread (data, sizeof(unsigned char), dlen, inFile)) != 0)
     82    EVP_DigestUpdate(md5ctx, data, bytes);
     83  EVP_DigestFinal_ex(md5ctx,result,&len);
     84  EVP_MD_CTX_destroy(md5ctx);
     85  int i;
     86  for(i = 0; i < len; i++){
     87    if(i>0){
     88      char *tmp=zStrdup(fresult);
     89      sprintf(fresult,"%s%02x", tmp,result[i]);
     90      free(tmp);
     91    }
     92    else
     93      sprintf(fresult,"%02x",result[i]);
     94  }
     95  fclose (inFile);
     96  return fresult;
     97}
     98
     99
     100
     101/**
     102 * Create a URL by appending every request header listed in the security
     103 * section.This imply that the URL will contain any authentication
     104 * informations that should be fowarded to the server from which de input
     105 * was download.
     106 * @param conf the main configuration maps
     107 * @param request the URL to transform.
     108 * @return a char* that contain the original URL plus potential header (only for
     109 * hosts that are not shared).
     110 * @warning Be sure to free the memory returned by this function.
     111 */
     112char* getFilenameForRequest(maps* conf, const char* request){
     113  map* passThrough=getMapFromMaps(conf,"security","attributes");
     114  map* targetHosts=getMapFromMaps(conf,"security","hosts");
     115  char* passedHeader[10];
     116  int cnt=0;
     117  char *res=zStrdup(request);
     118  char *toAppend=NULL;
     119  if(passThrough!=NULL && targetHosts!=NULL){
     120    char *tmp=zStrdup(passThrough->value);
     121    char *token, *saveptr;
     122    token = strtok_r (tmp, ",", &saveptr);
     123    int i;
     124    if((strstr(targetHosts->value,"*")!=NULL || isProtectedHost(targetHosts->value,request)==1) && strncasecmp(getProvenance(conf,request),"SHARED",6)!=0){
     125      while (token != NULL){
     126        int length=strlen(token)+6;
     127        char* tmp1=(char*)malloc(length*sizeof(char));
     128        map* tmpMap;
     129        snprintf(tmp1,6,"HTTP_");
     130        int j;
     131        for(j=0;token[j]!='\0';j++){
     132          if(token[j]!='-')
     133            tmp1[5+j]=toupper(token[j]);
     134          else
     135            tmp1[5+j]='_';
     136          tmp1[5+j+1]='\0';
     137        }
     138        tmpMap = getMapFromMaps(conf,"renv",tmp1);
     139        if(tmpMap!=NULL){
     140          if(toAppend==NULL){
     141            toAppend=(char*)malloc((strlen(tmpMap->value)+1)*sizeof(char));
     142            sprintf(toAppend,"%s",tmpMap->value);
     143          }else{
     144            char *tmp3=zStrdup(toAppend);
     145            toAppend=(char*)realloc(toAppend,(strlen(tmpMap->value)+strlen(tmp3)+2)*sizeof(char));
     146            sprintf(toAppend,"%s,%s",tmp3,tmpMap->value);
     147            free(tmp3);
     148          }
     149        }
     150        free(tmp1);
     151        cnt+=1;
     152        token = strtok_r (NULL, ",", &saveptr);
     153      }
     154    }
     155    free(tmp);
     156  }
     157  if(toAppend!=NULL){
     158    char *tmp3=zStrdup(res);
     159    res=(char*)realloc(res,(strlen(tmp3)+strlen(toAppend)+1)*sizeof(char));
     160    sprintf(res,"%s%s",tmp3,toAppend);
     161    free(tmp3);
     162    free(toAppend);
     163  }
     164  return res;
     165}
     166
     167/**
     168 * Store MD5 of the content of a file
     169 * @file char* the full path of the file
     170 */
     171int storeMd5(char* file){
     172  char* storage=zStrdup(file);
     173  char* md5fstr=getMd5f(file);
     174  storage[strlen(storage)-2]='m';
     175  storage[strlen(storage)-1]='d';
     176  FILE* fo=fopen(storage,"w+");
     177  if(fo==NULL)
     178    return 1;
     179  fwrite(md5fstr,sizeof(char),strlen(md5fstr),fo);
     180  free(md5fstr);
     181  free(storage);
     182  fclose(fo);
     183  return 0;
     184}
    64185
    65186/**
     
    76197 * @param max_path the size of the allocated filepath buffer 
    77198 */
     199void cacheFile(maps* conf,char* request,char* mimeType,int length,char* filename){
     200  map* tmp=getMapFromMaps(conf,"main","cacheDir");
     201  char contentr[4096];
     202  int cred=0;
     203  if(tmp!=NULL){
     204    char* myRequest=getFilenameForRequest(conf,request);
     205    char* md5str=getMd5(myRequest);
     206    free(myRequest);
     207    char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
     208    // Store md5
     209    char* md5fstr=getMd5f(filename);
     210    sprintf(fname,"%s/%s.zmd",tmp->value,md5str);
     211    FILE* fo=fopen(fname,"w+");
     212#ifdef DEBUG
     213    fprintf(stderr,"filename: %s\n",filename);
     214    fprintf(stderr,"MD5: %s\n",md5fstr);
     215#endif
     216    fwrite(md5fstr,sizeof(char),strlen(md5fstr),fo);
     217    free(md5fstr);
     218    fclose(fo);
     219   
     220    sprintf(fname,"%s/%s.zca",tmp->value,md5str);
     221    zooLock* lck=lockFile(conf,fname,'w');
     222    if(lck!=NULL){
     223#ifdef DEBUG
     224      fprintf(stderr,"Cache list : %s\n",fname);
     225      fflush(stderr);
     226#endif
     227      FILE* fi=fopen(filename,"rb");
     228      sprintf(fname,"%s/%s.zca",tmp->value,md5str);
     229      fo=fopen(fname,"w+");
     230      if(fo==NULL){
     231#ifdef DEBUG
     232        fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
     233#endif
     234        unlockFile(conf,lck);
     235        return;
     236      }
     237      if(fi==NULL){
     238#ifdef DEBUG
     239        fprintf (stderr, "Failed to open %s for reading: %s\n",filename, strerror(errno));
     240#endif
     241        unlockFile(conf,lck);
     242        return;
     243      }
     244      memset(contentr,0,4096);
     245      while((cred=fread(contentr,sizeof(char),4096,fi))>0){
     246        fwrite(contentr,sizeof(char),cred,fo);
     247        fflush(fo);
     248        memset(contentr,0,4096);
     249      }
     250      unlockFile(conf,lck);
     251      fclose(fo);
     252      fclose(fi);
     253
     254      // Store mimeType
     255      sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
     256      fo=fopen(fname,"w+");
     257#ifdef DEBUG
     258      fprintf(stderr,"MIMETYPE: %s\n",mimeType);
     259#endif
     260      fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
     261      fclose(fo);
     262
     263      // Store provenance
     264      sprintf(fname,"%s/%s.zcp",tmp->value,md5str);
     265      fo=fopen(fname,"w+");
     266      char* origin=getProvenance(conf,request);
     267#ifdef DEBUG
     268      fprintf(stderr,"ORIGIN: %s\n",mimeType);
     269#endif
     270      fwrite(origin,sizeof(char),strlen(origin),fo);
     271      fclose(fo);
     272
     273      free(md5str);
     274
     275    }
     276    free(fname);
     277  }
     278}
     279
     280/**
     281 * Cache a file for a given request.
     282 * For each cached file, the are two files stored, a .zca and a .zcm containing
     283 * the downloaded content and the mimeType respectively.
     284 *
     285 * @param conf the maps containing the settings of the main.cfg file
     286 * @param request the url used too fetch the content
     287 * @param content the downloaded content
     288 * @param mimeType the content mimeType
     289 * @param length the content size
     290 * @param filepath a buffer for storing the path of the cached file; may be NULL
     291 * @param max_path the size of the allocated filepath buffer 
     292 */
    78293void addToCache(maps* conf,char* request,char* content,char* mimeType,int length,
    79294                char* filepath, size_t max_path){
    80295  map* tmp=getMapFromMaps(conf,"main","cacheDir");
    81296  if(tmp!=NULL){
    82     char* md5str=getMd5(request);
     297    char* myRequest=getFilenameForRequest(conf,request);
     298    char* md5str=getMd5(myRequest);
     299    free(myRequest);
    83300    char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
    84301    sprintf(fname,"%s/%s.zca",tmp->value,md5str);
    85 #ifdef DEBUG
    86     fprintf(stderr,"Cache list : %s\n",fname);
    87     fflush(stderr);
    88 #endif
    89     FILE* fo=fopen(fname,"w+");
    90     if(fo==NULL){
    91 #ifdef DEBUG
    92       fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
    93 #endif
    94       filepath = NULL; 
    95       return;
    96     }
    97     fwrite(content,sizeof(char),length,fo);
    98     fclose(fo);
     302    zooLock* lck=lockFile(conf,fname,'w');
     303    if(lck!=NULL){
     304#ifdef DEBUG
     305      fprintf(stderr,"Cache list : %s\n",fname);
     306      fflush(stderr);
     307#endif
     308      FILE* fo=fopen(fname,"w+");
     309      if(fo==NULL){
     310#ifdef DEBUG
     311        fprintf (stderr, "Failed to open %s for writing: %s\n",fname, strerror(errno));
     312#endif
     313        filepath = NULL;
     314        unlockFile(conf,lck);
     315        return;
     316      }
     317      fwrite(content,sizeof(char),length,fo);
     318      unlockFile(conf,lck);
     319      fclose(fo);
    99320       
    100         if (filepath != NULL) {
    101                 strncpy(filepath, fname, max_path);
    102         }       
    103 
    104     sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
    105     fo=fopen(fname,"w+");
    106 #ifdef DEBUG
    107     fprintf(stderr,"MIMETYPE: %s\n",mimeType);
    108 #endif
    109     fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
    110     fclose(fo);
    111 
    112     free(md5str);
    113     free(fname);
     321      if (filepath != NULL) {
     322        strncpy(filepath, fname, max_path);
     323      }
     324
     325      sprintf(fname,"%s/%s.zcm",tmp->value,md5str);
     326      fo=fopen(fname,"w+");
     327#ifdef DEBUG
     328      fprintf(stderr,"MIMETYPE: %s\n",mimeType);
     329#endif
     330      fwrite(mimeType,sizeof(char),strlen(mimeType),fo);
     331      fclose(fo);
     332
     333      sprintf(fname,"%s/%s.zcp",tmp->value,md5str);
     334      fo=fopen(fname,"w+");
     335      char* origin=getProvenance(conf,request);
     336#ifdef DEBUG
     337      fprintf(stderr,"ORIGIN: %s\n",mimeType);
     338#endif
     339      fwrite(origin,sizeof(char),strlen(origin),fo);
     340      fclose(fo);
     341
     342      free(md5str);
     343      free(fname);
     344    }
    114345  }
    115346  else {
    116           filepath = NULL;
     347    filepath = NULL;
    117348  }       
    118349}
     
    127358 */
    128359char* isInCache(maps* conf,char* request){
     360  map* tmpUrl=getMapFromMaps(conf,"main","tmpUrl");
    129361  map* tmpM=getMapFromMaps(conf,"main","cacheDir");
    130   if(tmpM!=NULL){
    131     char* md5str=getMd5(request);
     362  if(tmpM==NULL)
     363    tmpM=getMapFromMaps(conf,"main","tmpPath");
     364  if(strstr(request,tmpUrl->value)!=NULL){
     365    map* tmpPath=getMapFromMaps(conf,"main","tmpPath");
     366    char* tmpStr=strstr(request,tmpUrl->value);
     367    char* tmpStr1=zStrdup(tmpStr+strlen(tmpUrl->value));
     368    char* res=(char*) malloc((strlen(tmpPath->value)+strlen(tmpStr1)+2)*sizeof(char));
     369    sprintf(res,"%s/%s",tmpPath->value,tmpStr1);
     370    free(tmpStr1);
     371    return res;
     372  }
     373#ifdef MS_FORCE_LOCAL_FILE_USE
     374  map* msUrl=getMapFromMaps(conf,"main","mapserverAddress");
     375  if(msUrl!=NULL && strstr(request,msUrl->value)!=NULL){
     376    char *tmpStr=strstr(request,"?");
     377    char *cursor=zStrdup(tmpStr+1);
     378    char *token, *saveptr;
     379    token = strtok_r (cursor, "&", &saveptr);
     380    while(token!=NULL){
     381      char *token1, *saveptr1;
     382      token1 = strtok_r (token, "=", &saveptr1);
     383      char *name=NULL;
     384      while(token1!=NULL){
     385        if(name==NULL)
     386          name=zStrdup(token1);
     387        else
     388          if(strcasecmp(name,"map")==0){
     389            mapObj *myMap=msLoadMap(token1,NULL);
     390            char * res=zStrdup(myMap->layers[0]->data);
     391            free(name);
     392            free(cursor);
     393            msFreeMap(myMap);
     394            return res;
     395          }
     396        token1 = strtok_r (NULL, "=", &saveptr1);
     397      }
     398      token = strtok_r (NULL, "&", &saveptr);
     399    }
     400    free(cursor);
     401  }
     402#endif 
     403  if(strncasecmp(request,"file://",7)==0){
     404    char* tmpStr=zStrdup(request+7);
     405    fprintf(stderr,"**** %s %d %s \n",__FILE__,__LINE__,tmpStr);
     406    return tmpStr;
     407  }
     408  else{
     409    char* myRequest=getFilenameForRequest(conf,request);
     410    char* md5str=getMd5(myRequest);
     411    free(myRequest);
    132412#ifdef DEBUG
    133413    fprintf(stderr,"MD5STR : (%s)\n\n",md5str);
     
    135415    char* fname=(char*)malloc(sizeof(char)*(strlen(tmpM->value)+strlen(md5str)+6));
    136416    sprintf(fname,"%s/%s.zca",tmpM->value,md5str);
    137     struct stat f_status;
    138     int s=stat(fname, &f_status);
     417    zStatStruct f_status;
     418    int s=zStat(fname, &f_status);
    139419    if(s==0 && f_status.st_size>0){
    140420      free(md5str);
     
    158438 */
    159439int readCurrentInput(maps** m,maps** in,int* index,HINTERNET* hInternet,map** error){
     440 
     441  int shouldClean=-1;
    160442  map* tmp1;
    161443  char sindex[5];
    162444  maps* content=*in;
    163445  map* length=getMap(content->content,"length");
    164   int shouldClean=-1;
     446  map* memUse=getMapFromMaps(*m,"main","memory");
    165447  if(length==NULL){
    166448    length=createMap("length","1");
     
    171453    char *mimeType=NULL;
    172454    int fsize=0;
     455    char oriname[12];
    173456    char cname[15];
    174457    char vname[11];
     
    178461    char icname[14];
    179462    char xname[16];
     463    char bname[8];
     464    char hname[11];
    180465    char oname[12];
     466    char ufile[12];   
    181467    if(*index>0)
    182468      sprintf(vname1,"value_%d",*index);
     
    185471   
    186472    if(i>0){
     473      sprintf(cname,"cache_file_%d",i);
    187474      tmp1=getMap(content->content,cname);
    188       sprintf(cname,"cache_file_%d",i);
     475      sprintf(oriname,"origin_%d",i);
    189476      sprintf(vname,"value_%d",i);
    190477      sprintf(sname,"size_%d",i);
     
    192479      sprintf(icname,"isCached_%d",i);
    193480      sprintf(xname,"Reference_%d",i);
     481      sprintf(bname,"body_%d",i);
     482      sprintf(hname,"headers_%d",i);
    194483      sprintf(oname,"Order_%d",i);
     484      sprintf(ufile,"use_file_%d",i);
    195485    }else{
    196486      sprintf(cname,"cache_file");
     487      sprintf(oriname,"origin");
    197488      sprintf(vname,"value");
    198489      sprintf(sname,"size");
     
    200491      sprintf(icname,"isCached");
    201492      sprintf(xname,"Reference");
     493      sprintf(bname,"body");
     494      sprintf(hname,"headers");
    202495      sprintf(oname,"Order");
     496      sprintf(ufile,"use_file");
    203497    }
    204498   
     
    206500    sprintf(sindex,"%d",*index+1);
    207501    if((tmp1=getMap(content->content,xname))!=NULL && tmap!=NULL && strcasecmp(tmap->value,sindex)==0){
    208      
    209       if(getMap(content->content,icname)==NULL){
    210         fcontent=(char*)malloc((hInternet->ihandle[*index].nDataLen+1)*sizeof(char));
    211         if(fcontent == NULL){
    212           errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
    213           return -1;
     502
     503      if(getMap(content->content,icname)==NULL) {
     504        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
     505          fcontent=(char*)malloc((hInternet->ihandle[*index].nDataLen+1)*sizeof(char));
     506          if(fcontent == NULL){
     507            errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
     508            return -1;
     509          }
     510          size_t dwRead;
     511          InternetReadFile(hInternet->ihandle[*index],
     512                           (LPVOID)fcontent,
     513                           hInternet->ihandle[*index].nDataLen,
     514                           &dwRead);
     515          fcontent[hInternet->ihandle[*index].nDataLen]=0;
    214516        }
    215         size_t dwRead;
    216         InternetReadFile(hInternet->ihandle[*index],
    217                          (LPVOID)fcontent,
    218                          hInternet->ihandle[*index].nDataLen,
    219                          &dwRead);
    220         fcontent[hInternet->ihandle[*index].nDataLen]=0;
    221517        fsize=hInternet->ihandle[*index].nDataLen;
    222518        if(hInternet->ihandle[*index].mimeType==NULL)
     
    226522       
    227523        map* tmpMap=getMapOrFill(&(*in)->content,vname,"");
    228         free(tmpMap->value);
    229         tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
    230         if(tmpMap->value==NULL){
    231           return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
    232         }
    233         memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
     524        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
     525          free(tmpMap->value);
     526          tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
     527          if(tmpMap->value==NULL){
     528            return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
     529          }
     530          memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
     531        }else
     532          addToMap((*in)->content,ufile,"true");
    234533        if(hInternet->ihandle[*index].code!=200){
    235534          const char *error_rep_str=_("Unable to download the file for the input <%s>, response code was : %d.");
     
    255554        sprintf(ltmp1,"%d",fsize);
    256555        map* tmp=getMapFromMaps(*m,"main","cacheDir");
     556        char *request=NULL;
    257557        if(tmp!=NULL){
    258           char* md5str=getMd5(tmp1->value);
     558          map* tmp2;
     559          char* md5str=NULL;
     560          if((tmp2=getMap(content->content,bname))!=NULL){
     561            char *tmpStr=(char*)malloc((strlen(tmp1->value)+strlen(tmp2->value)+1)*sizeof(char));
     562            sprintf(tmpStr,"%s%s",tmp1->value,tmp2->value);
     563            if((tmp2=getMap(content->content,"headers"))!=NULL){
     564              char *tmpStr2=zStrdup(tmpStr);
     565              free(tmpStr);
     566              tmpStr=(char*)malloc((strlen(tmpStr2)+strlen(tmp2->value)+1)*sizeof(char));
     567              sprintf(tmpStr,"%s%s",tmpStr2,tmp2->value);
     568              free(tmpStr2);
     569            }
     570            md5str=getMd5(tmpStr);
     571            request=zStrdup(tmpStr);
     572            free(tmpStr);
     573          }else{
     574            char *myRequest=getFilenameForRequest(*m,tmp1->value);
     575            md5str=getMd5(myRequest);
     576            request=zStrdup(tmp1->value);
     577            free(myRequest);
     578          }
    259579          char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
    260580          sprintf(fname,"%s/%s.zca",tmp->value,md5str);
     
    264584        addToMap((*in)->content,sname,ltmp1);
    265585        addToMap((*in)->content,mname,mimeType);
    266         addToCache(*m,tmp1->value,fcontent,mimeType,fsize, NULL, 0);
    267         free(fcontent);
     586        char* origin=getProvenance(*m,request);
     587        addToMap((*in)->content,oriname,origin);
     588        if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
     589          addToCache(*m,request,fcontent,mimeType,fsize, NULL, 0);
     590          free(fcontent);
     591        }else{
     592          addToMap((*in)->content,ufile,"true");
     593          cacheFile(*m,request,mimeType,fsize,hInternet->ihandle[*index].filename);
     594        }
    268595        free(mimeType);
    269         *index++;
    270        
     596        free(request);
     597        (*index)++;
    271598      }
    272599    }
     
    324651 */
    325652void addRequestToQueue(maps** m,HINTERNET* hInternet,const char* url,bool req){
    326   hInternet->waitingRequests[hInternet->nb]=strdup(url);
     653  hInternet->waitingRequests[hInternet->nb]=zStrdup(url);
    327654  if(req)
    328     InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0);
     655    InternetOpenUrl(hInternet,hInternet->waitingRequests[hInternet->nb],NULL,0,INTERNET_FLAG_NO_CACHE_WRITE,0,*m);
    329656  maps *oreq=getMaps(*m,"orequests");
    330657  if(oreq==NULL){
     
    335662    free(oreq);
    336663  }else{
    337     setMapArray(oreq->content,"value",hInternet->nb-1,url);
     664    setMapArray(oreq->content,"value",hInternet->nb,url);
    338665  }
    339666}
     
    352679  char* cached=isInCache(*m,url);
    353680  char *mimeType=NULL;
    354   int fsize=0;
     681  char *origin=NULL;
     682  long long fsize=0;
     683  map* memUse=getMapFromMaps(*m,"main","memory");
    355684
    356685  map* t=getMap(*content,"xlink:href");
     
    361690
    362691  if(cached!=NULL){
    363 
    364     struct stat f_status;
    365     int s=stat(cached, &f_status);
     692    zStatStruct f_status;
     693    int s=zStat(cached, &f_status);
    366694    if(s==0){
    367       fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1));
    368       FILE* f=fopen(cached,"rb");
    369       fread(fcontent,f_status.st_size,1,f);
     695      zooLock* lck=lockFile(*m,cached,'r');
     696      if(lck==NULL)
     697        return -1;
    370698      fsize=f_status.st_size;
    371       fcontent[fsize]=0;
    372       fclose(f);
     699      if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
     700        fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1));
     701        FILE* f=fopen(cached,"rb");
     702        if(f!=NULL){
     703          fread(fcontent,f_status.st_size,1,f);
     704          fcontent[fsize]=0;
     705          fclose(f);
     706        }
     707      }
    373708      addToMap(*content,"cache_file",cached);
     709      unlockFile(*m,lck);
    374710    }
    375711    cached[strlen(cached)-1]='m';
    376     s=stat(cached, &f_status);
     712    s=zStat(cached, &f_status);
    377713    if(s==0){
     714      zooLock* lck=lockFile(*m,cached,'r');
     715      if(lck==NULL)
     716        return -1;
    378717      mimeType=(char*)malloc(sizeof(char)*(f_status.st_size+1));
    379718      FILE* f=fopen(cached,"rb");
     
    381720      mimeType[f_status.st_size]=0;
    382721      fclose(f);
    383     }
    384 
     722      unlockFile(*m,lck);
     723    }
     724    cached[strlen(cached)-1]='p';
     725    s=zStat(cached, &f_status);
     726    if(s==0){
     727      zooLock* lck=lockFile(*m,cached,'r');
     728      if(lck==NULL)
     729        return -1;
     730      origin=(char*)malloc(sizeof(char)*(f_status.st_size+1));
     731      FILE* f=fopen(cached,"rb");
     732      fread(origin,f_status.st_size,1,f);
     733      mimeType[f_status.st_size]=0;
     734      fclose(f);
     735      unlockFile(*m,lck);
     736    }
    385737  }else{   
    386738    addRequestToQueue(m,hInternet,url,true);
     
    393745    addToMap(*content,"fmimeType",mimeType);
    394746  }
     747  if(origin!=NULL){
     748    addToMap(*content,"origin",origin);
     749  }
    395750
    396751  map* tmpMap=getMapOrFill(content,"value","");
    397    
    398   free(tmpMap->value);
    399   tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
    400   if(tmpMap->value==NULL || fcontent == NULL)
    401     return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
    402   memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
    403 
     752  if(memUse==NULL || strcasecmp(memUse->value,"load")==0){
     753    free(tmpMap->value);
     754    tmpMap->value=(char*)malloc((fsize+1)*sizeof(char));
     755    if(tmpMap->value==NULL || fcontent == NULL)
     756      return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL);
     757    memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char));
     758  }
     759 
    404760  char ltmp1[256];
    405   sprintf(ltmp1,"%d",fsize);
     761  sprintf(ltmp1,"%ld",fsize);
    406762  addToMap(*content,"size",ltmp1);
    407763  if(cached==NULL){
    408     addToCache(*m,url,fcontent,mimeType,fsize, NULL, 0);
     764    if(memUse==NULL || strcasecmp(memUse->value,"load")==0)
     765      addToCache(*m,url,fcontent,mimeType,fsize, NULL, 0);
     766    else
     767      cacheFile(*m,url,mimeType,fsize,hInternet->ihandle[hInternet->nb-1].filename);
    409768  }
    410769  else{
    411770    addToMap(*content,"isCached","true");
    412771    map* tmp=getMapFromMaps(*m,"main","cacheDir");
    413     if(tmp!=NULL){
     772    map* tmp1=getMap((*content),"cache_file");
     773    if(tmp!=NULL && tmp1==NULL){
    414774      map *c=getMap((*content),"xlink:href");
    415       char* md5str=getMd5(c->value);
    416       char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
    417       sprintf(fname,"%s/%s.zca",tmp->value,md5str);
    418       addToMap(*content,"cache_file",fname);
    419       free(fname);
    420     }
    421   }
    422   free(fcontent);
    423   free(mimeType);
    424   free(cached);
     775      if(strncasecmp(c->value,"file://",7)!=0){
     776        char *myRequest=getFilenameForRequest(*m,c->value);
     777        char* md5str=getMd5(myRequest);
     778        free(myRequest);
     779        char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6));
     780        sprintf(fname,"%s/%s.zca",tmp->value,md5str);
     781        addToMap(*content,"cache_file",fname);
     782        free(fname);
     783        free(md5str);
     784      }
     785    }
     786  }
     787  if(fcontent!=NULL)
     788    free(fcontent);
     789  if(mimeType!=NULL)
     790    free(mimeType);
     791  if(cached!=NULL)
     792    free(cached);
    425793  return 0;
    426794}
  • trunk/zoo-project/zoo-kernel/caching.h

    r797 r917  
    3535  void addRequestToQueue(maps**,HINTERNET*,const char*,bool);
    3636  int loadRemoteFile(maps**,map**,HINTERNET*,char*);
    37 
     37  char* getMd5f(char*);
     38  int storeMd5(char*);
     39 
    3840#ifdef __cplusplus
    3941}
  • trunk/zoo-project/zoo-kernel/configure.ac

    r817 r917  
    11AC_INIT([ZOO Kernel], [1.7.0], [bugs@zoo-project.org])
     2
     3AC_CONFIG_MACRO_DIR([macros])
    24
    35# Checks for programs.
     
    1214AC_CHECK_LIB([dl], [dlopen,dlsym,dlerror,dlclose])
    1315AC_CHECK_LIB([crypto], [EVP_DigestInit,EVP_md5,EVP_DigestUpdate,BIO_f_base64,BIO_new])
    14 AC_CHECK_LIB([uuid], [uuid_generate_time])
    1516
    1617DEFAULT_LIBS="$LIBS"
     
    2021# Checks for header files.
    2122AC_FUNC_ALLOCA
    22 AC_CHECK_HEADERS([fcntl.h inttypes.h libintl.h malloc.h stddef.h stdlib.h string.h unistd.h])
     23AC_CHECK_HEADERS([fcntl.h inttypes.h malloc.h stddef.h stdlib.h string.h unistd.h])
    2324
    2425# Checks for typedefs, structures, and compiler characteristics.
     
    3839AC_FUNC_REALLOC
    3940AC_CHECK_FUNCS([dup2 getcwd memset setenv strdup strstr])
     41
     42#============================================================================
     43# Detect if uuid is available
     44#============================================================================
     45
     46AC_ARG_WITH([uuid],
     47    [AS_HELP_STRING([--with-uuid=PATH], [Specifies an alternative location for the ossp-uuid library])],
     48    [UUID_DIR="$withval"], [UUID_DIR="/usr/"])
     49UUID_CFLAGS="-I$UUID_DIR/include"
     50UUID_LDFLAGS="-L$UUID_DIR/lib -luuid"
     51CPPFLAGS_SAVE="$CPPFLAGS"
     52CPPFLAGS="$UUID_CFLAGS"
     53LIBS_SAVE="$LIBS"
     54LIBS="$UUID_LDFLAGS"
     55AC_CHECK_HEADERS([uuid/uuid.h],
     56                        [], [AC_MSG_ERROR([could not find header file uuid.h])])
     57AC_CHECK_LIB([uuid], [uuid_generate_time],
     58                        [], [AC_MSG_ERROR([could not find function in uuid library])])
     59CPPFLAGS="$CPPFLAGS_SAVE"
     60AC_SUBST([UUID_CFLAGS])
     61AC_SUBST([UUID_LDFLAGS])
     62
     63#============================================================================
     64# Detect if json-c is available
     65#============================================================================
     66
     67AC_ARG_WITH([callback],
     68    [AS_HELP_STRING([--with-callback=yes], [Activate callback invocation during HPC execution])],
     69    [CALLBACK_ACTIVATED="$withval"], [CALLBACK_ACTIVATED="no"])
     70   
     71AC_ARG_WITH([json],
     72    [AS_HELP_STRING([--with-json=PATH], [Specifies an alternative location for the json-c library])],
     73    [JSON_DIR="$withval"], [JSON_DIR="/usr/"])
     74if test "x$JSON_DIR" != "x" && test "x$CALLBACK_ACTIVATED" == "xyes"
     75then
     76        JSON_CPPFLAGS="-I$JSON_DIR/include/json-c/"
     77        JSON_LDFLAGS="-L$JSON_DIR/lib -ljson-c"
     78        CPPFLAGS_SAVE="$CPPFLAGS"
     79        CPPFLAGS="$JSON_CPPFLAGS"
     80        LIBS_SAVE="$LIBS"
     81        LIBS="$JSON_LDFLAGS"
     82        AC_CHECK_HEADERS([json_object.h],
     83                [], [AC_MSG_ERROR([could not find header file json_object.h])])
     84        AC_CHECK_LIB([json-c], [json_object_new_object],
     85                [], [AC_MSG_ERROR([could not find function in json-c library])])
     86        CPPFLAGS="$CPPFLAGS_SAVE"
     87        JSON_FILE="service_json.o"
     88        JSON_ENABLED="-DJSON"
     89        CALLBACK_FILE="service_callback.o"
     90        CALLBACK_USE="-DUSE_CALLBACK"
     91fi
     92AC_SUBST([JSON_CPPFLAGS])
     93AC_SUBST([JSON_LDFLAGS])
     94AC_SUBST([JSON_FILE])
     95AC_SUBST([JSON_ENABLED])
     96AC_SUBST([CALLBACK_FILE])
     97AC_SUBST([CALLBACK_USE])
    4098
    4199#============================================================================
     
    56114AC_CHECK_LIB(crypto, BIO_f_base64,
    57115                        [], [AC_MSG_ERROR([could not find $i function in openssl library])])
     116CPPFLAGS="$CPPFLAGS_SAVE"
    58117AC_SUBST([OPENSSL_CFLAGS])
    59118AC_SUBST([OPENSSL_LDFLAGS])
     119
     120#============================================================================
     121# Detect if gettext is available
     122#============================================================================
     123
     124#AC_ARG_WITH([gettext],
     125#    [AS_HELP_STRING([--with-gettext=PATH], [Specifies an alternative location for the openssl library])],
     126#    [GETTEXT_DIR="$withval"], [GETTEXT_DIR="/usr/"])
     127
     128#GETTEXT_CFLAGS="-I$GETTEXT_DIR/include"
     129#GETTEXT_LDFLAGS="-L$GETTEXT_DIR/lib -lintl"
     130#CFLAGS_SAVE="$CFLAGS"
     131#CFLAGS="$GETTEXT_CFLAGS"
     132#LIBS_SAVE="$LIBS"
     133#LIBS="$GETTEXT_LDFLAGS"
     134#AM_GNU_GETTEXT([external], [], [])
     135#AC_CHECK_LIB(intl,
     136#                       [dgettext], [] , [AC_MSG_ERROR([could not find $i function in gettext library])])
     137#AC_SUBST([GETTEXT_CFLAGS])
     138#AC_SUBST([GETTEXT_LDFLAGS])
    60139
    61140#============================================================================
     
    145224AC_SUBST([FCGI_LDFLAGS])
    146225
     226AC_ARG_WITH([metadb],
     227        [AS_HELP_STRING([--with-metadb=yes], [Activates the metadata database support])],
     228        [WITHMETADB="$withval"], [WITHMETADB=""])
     229
     230if test "x$WITHMETADB" = "xyes"; then
     231        METADB="-DMETA_DB"
     232        METADB_FILE="meta_sql.o sqlapi.o"
     233else
     234        METADB=""
     235        METADB_FILE=""
     236fi
     237
     238AC_SUBST([METADB])
     239AC_SUBST([METADB_FILE])
     240
     241AC_ARG_WITH([hpc],
     242        [AS_HELP_STRING([--with-hpc=yes], [Specifies if you need to activate HPC support])],
     243        [HPCWITH="$withval"], [HPCWITH="no"])
     244
     245
     246AC_ARG_WITH([ssh2],
     247        [AS_HELP_STRING([--with-ssh2=PATH], [Specifies an alternative location for the ssh2 library])],
     248        [SSH2PATH="$withval"], [SSH2PATH="/usr"])
     249
     250if test "x$HPCWITH" = "xyes"; then
     251        HPC_FILES="service_internal_hpc.o sshapi.o"
     252        HPC_ENABLED="-DUSE_HPC"
     253        HPC_CPPFLAGS=""
     254        HPC_LDFLAGS=""
     255        # Extract the linker and include flags
     256        SSH2_LDFLAGS="-L$SSH2PATH/lib -lssh2"
     257        SSH2_CPPFLAGS="-I$SSH2PATH/include"
     258        # Check headers file
     259        CPPFLAGS_SAVE="$CPPFLAGS"
     260        CPPFLAGS="$SSH2_CPPFLAGS"
     261        LIBS_SAVE="$LIBS"
     262        LIBS="$SSH2_LDFLAGS"
     263       
     264        AC_CHECK_HEADERS([libssh2.h],
     265                 [], [AC_MSG_ERROR([could not find headers related to libssh2])])
     266        AC_CHECK_LIB([ssh2], [libssh2_session_init])
     267
     268        LIBS="$LIBS_SAVE"
     269fi
     270
     271AC_SUBST([HPC_CPPFLAGS])
     272AC_SUBST([HPC_LDFLAGS])
     273AC_SUBST([HPC_ENABLED])
     274AC_SUBST([HPC_FILES])
     275
     276AC_SUBST([SSH2_CPPFLAGS])
     277AC_SUBST([SSH2_LDFLAGS])
     278
    147279# ===========================================================================
    148280# Detect if libxml2 is installed
     
    400532AC_SUBST([MS_LIBS])
    401533AC_SUBST([MS_FILE])
     534AC_SUBST([MS_VERSION])
     535
     536# ===========================================================================
     537# Detect if R is installed
     538# ===========================================================================
     539
     540AC_ARG_WITH([r],
     541        [AS_HELP_STRING([--with-r=PATH], [To enable python support or Specifies an alternative directory for R installation,  disabled by default])],
     542        [R_PATH="$withval"; R_ENABLED="-DUSE_R"], [R_ENABLED=""])
     543
     544if test -z "$R_ENABLED"
     545then
     546        R_FILE=""
     547else
     548        R_FILE="service_internal_r.o"
     549        # Extract the linker and include flags
     550        R_LDFLAGS="-L$R_PATH/lib/ -lR"
     551        R_CPPFLAGS="-I$R_PATH/include/"
     552
     553        # Check headers file
     554        CPPFLAGS_SAVE="$CPPFLAGS"
     555        CPPFLAGS="$R_CPPFLAGS"
     556        AC_CHECK_HEADERS([RInternals.h],
     557                 [], [AC_MSG_ERROR([could not find headers include related to R])])
     558
     559        # Ensure we can link against libphp
     560        #LIBS_SAVE="$LIBS"
     561        #LIBS="$R_LDFLAGS"
     562        #AC_CHECK_LIB([$LIBS], [R_tryEval], [], [AC_MSG_ERROR([could not find libR])], [])
     563        #LIBS="$LIBS_SAVE"
     564fi
     565
     566AC_SUBST([R_CPPFLAGS])
     567AC_SUBST([R_LDFLAGS])
     568AC_SUBST([R_ENABLED])
     569AC_SUBST([R_FILE])
     570
    402571
    403572# ===========================================================================
     
    646815
    647816        AC_LANG([C++])
    648         echo $JAVA_CPPFLAGS
     817        #echo $JAVA_CPPFLAGS
    649818        # Check headers file (second time we check that in fact)
    650819        CPPFLAGS_SAVE="$CPPFLAGS"
     
    696865
    697866        AC_LANG([C++])
    698         echo $JAVA_CPPFLAGS
     867        #echo $JAVA_CPPFLAGS
    699868        # Check headers file (second time we check that in fact)
    700869        CPPFLAGS_SAVE="$CFLAGS"
     
    8881057        [SAGAPATH="$withval"], [SAGAPATH=""])
    8891058
     1059AC_ARG_WITH([saga-version],
     1060        [AS_HELP_STRING([--with-saga-version=VERSION], [Specifies the SAGA-GIS version number])],
     1061        [SAGAVERS="$withval"], [SAGAVERS="2"])
     1062
    8901063if test -z "$SAGAPATH"
    8911064then
     
    9031076        WX_ISSUE="-D_WX_WXCRTVARARG_H_"
    9041077        SAGA_DEFS="-D_SAGA_LINUX -D_TYPEDEF_BYTE -D_TYPEDEF_WORD -DMODULE_LIBRARY_PATH=\\\"$SAGAPATH/lib/saga\\\""
    905         SAGA_CPPFLAGS=" -fPIC -I$SAGAPATH/include/saga/saga_core/saga_api/ `$WXCFG --unicode=yes --static=no --cxxflags` -D_SAGA_UNICODE $SAGA_DEFS $WX_ISSUE"
     1078        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"
    9061079        SAGA_LDFLAGS="-fPIC `$WXCFG --unicode=yes --static=no --libs` -lsaga_api"
    9071080        SAGA_ENABLED="-DUSE_SAGA"
     
    9141087        LIBS_SAVE="$LIBS"
    9151088        LIBS="$SAGA_LDFLAGS"
    916         AC_CHECK_HEADERS([module_library.h],
    917                         [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
    918         AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "module_library.h"],[SG_Get_Module_Library_Manager();]])],
    919                 [AC_MSG_RESULT([checking for SG_Get_Module_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Module_Library_Manager... failed])])
     1089        if test "$SAGAVERS" == "2"; then
     1090        AC_CHECK_HEADERS([module_library.h],
     1091                        [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
     1092        AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "module_library.h"],[SG_Get_Module_Library_Manager();]])],
     1093                [AC_MSG_RESULT([checking for SG_Get_Module_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Module_Library_Manager... failed])])
     1094        else
     1095        AC_CHECK_HEADERS([tool_library.h],
     1096                        [], [AC_MSG_ERROR([could not find header file $i related to SAGA-GIS])])
     1097        AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "tool_library.h"],[SG_Get_Tool_Library_Manager();]])],
     1098                [AC_MSG_RESULT([checking for SG_Get_Tool_Library_Manager... yes])],[AC_MSG_ERROR([checking for SG_Get_Tool_Library_Manager... failed])])
     1099        fi
     1100       
    9201101        LIBS="$LIBS_SAVE"
    9211102        AC_LANG_POP([C++])
  • trunk/zoo-project/zoo-kernel/main_conf_read.y

    r790 r917  
    8787 ;
    8888
    89 pair: PAIR {curr_key=zStrdup($1);}
     89pair: PAIR {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);}
    9090| EPAIR {
    9191  if(current_content==NULL)
     
    9999  }
    100100  free(curr_key);
     101  curr_key=NULL;
    101102  }
    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"); }
    103104 ;
    104105
     
    162163    free(current_content);
    163164  }
     165  if(curr_key!=NULL){
     166    free(curr_key);
     167  }
    164168
    165169  fclose(crin);
  • trunk/zoo-project/zoo-kernel/makefile.vc

    r788 r917  
    5050        $(CPP) $(CFLAGS) /c caching.c
    5151
     52service_json.obj: service_json.c service_json.h
     53        $(CPP) $(CFLAGS) /c service_json.c
     54
    5255request_parser.obj: request_parser.c request_parser.h
    5356        $(CPP) $(CFLAGS) /c request_parser.c
     
    7174        $(CPP) /c $(CFLAGS) service_internal_ruby.c
    7275
     76service_internal_mono.obj: service_internal_mono.c service_internal_mono.h service.h
     77        $(CPP) /c $(MONO_CLAGS) $(CFLAGS) service_internal_mono.c
     78
    7379service_internal_python.obj: service_internal_python.c service.h
    7480        $(CPP) /c $(CFLAGS) service_internal_python.c
     
    8995        $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php.c
    9096   
     97service_callback.obj: service_callback.c service_callback.h service.h
     98        $(CPP) /c $(CFLAGS) service_callback.c
     99   
    91100service_internal_php7.obj: service_internal_php7.c service_internal_php.h service.h
    92101        $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php7.c   
     
    95104        link /dll /out:$(LIBZOO_SERVICE) ./service.obj ./service_internal.obj ./sqlapi.obj $(LDFLAGS) /FORCE:MULTIPLE
    96105
    97 $(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
    98         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)
     106$(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
     107        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)
    99108
    100 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
    101         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)
     109zcfg2yaml: 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
     110        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)
    102111
    103112clean:
     
    105114
    106115embed-manifest: zoo_loader.cgi
    107         mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;1
     116        mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;
  • trunk/zoo-project/zoo-kernel/mimetypes.h

    r601 r917  
    180180        { "application/vnd.dece.unspecified", "uvx" },
    181181        { "application/vnd.dece.zip", "uvz" },
    182         { "application/vnd.denovo.fcselayout-link", "fe_launch" },
     182        { "application/vnd.denovo.fcselayout-link", "fe_launch" },     
    183183        { "application/vnd.dna", "dna" },
    184184        { "application/vnd.dolby.mlp", "mlp" },
     
    818818*/
    819819static map* getFileExtensionMap(const char* mimeType, bool* hasExt) {
     820  map* ext = createMap("extension", "txt");
     821  *hasExt = false;
     822       
     823  if (mimeType != NULL) {       
     824    for (int i = 0; i < NUM_MIME_TYPES; i++) {                 
     825      if(strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
     826        free(ext->value);
     827        ext->value = zStrdup(MIME[i][M_Extension]);
     828        *hasExt = true;
     829        break;                         
     830      }
     831    }
     832    if (*hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
     833      free(ext->value);
     834      ext->value = zStrdup(strstr(mimeType, "/") + 1);
     835    }
     836  }     
     837  return ext;
     838}
    820839
    821         map* ext = createMap("extension", "txt");
    822         *hasExt = false;
    823        
    824         if (mimeType != NULL) {         
    825                 for (int i = 0; i < NUM_MIME_TYPES; i++) {                     
    826                         if      (strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
    827                                 ext->value = zStrdup(MIME[i][M_Extension]);
    828                                 *hasExt = true;
    829                                 break;                         
    830                         }               
    831                 }
    832                 if (*hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
    833                         ext->value = zStrdup(strstr(mimeType, "/") + 1);
    834                 }                       
    835         }       
    836         return ext;
     840static int isGeographic(const char* mimeType){
     841  char* imageMimeType[4]={
     842    "image/tiff",
     843    "image/png",
     844    "image/jpeg",
     845    "application/vnd.google-earth.kmz"
     846  };
     847  char* vectorMimeType[5]={
     848    "text/xml",
     849    "application/json",
     850    "application/gml+xml",
     851    "application/zip",
     852    "application/vnd.google-earth.kml+xml"
     853  };
     854  int i=0;
     855  for(;i<4;i++){
     856    if(strncmp(imageMimeType[i],mimeType,strlen(imageMimeType[i]))==0)
     857      return 1;
     858  }
     859  i=0;
     860  for(;i<5;i++){
     861    if(strncmp(vectorMimeType[i],mimeType,strlen(vectorMimeType[i]))==0)
     862      return 2;
     863  }
     864  return -1;
    837865}
  • trunk/zoo-project/zoo-kernel/nmake.opt

    r788 r917  
    8787!ENDIF
    8888
     89!IFDEF MONO_DIR
     90MONO_CFLAGS=-DUSE_MONO -I"$(MONO_DIR)"\msvc -I"$(MONO_DIR)"\msvc\include -I"$(MONO_DIR)"
     91MONO_LDFLAGS=/LIBPATH:"$(MONO_DIR)/msvc/build/sgen/x64/lib/Release" mono-2.0-sgen.lib
     92MONO_FILE=service_internal_mono.obj
     93!ENDIF
     94
    8995!IFNDEF ZOOK_DIR
    9096ZOOK_DIR=.
     
    100106!ENDIF
    101107
    102 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
     108!IFDEF WIN32_DEBUG
     109WIN32_DBG=-DWIN32_DEBUG
     110!ENDIF
     111
     112CFLAGS=$(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
    103113
    104114LDFLAGSCGI=$(TROOT)/../../thirds/cgic206/libcgic.lib
    105 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
     115LDFLAGS=$(MONO_LDFLAGS) $(FCGI_DIR)/libfcgi/Release/libfcgi.lib $(CURL_LIBRARY) $(PY_LDFLAGS) $(XML2_LIBRARY) $(SSL_DIR)/out32dll/libeay32.lib $(JAVA_LDFLAGS) $(SSL_DIR)/out32dll/ssleay32.lib $(MS_LDFLAGS) $(INTL_DIR)/intl.lib $(XML2_DIR)/win32/bin.msvc/libxml2.lib $(GDAL_DIR)/gdal_i.lib $(CURL_DIR)/lib/libcurl.lib $(JS_LDFLAGS) $(RUBY_LDFLAGS) $(PHP_LDFLAGS) /machine:i386
  • trunk/zoo-project/zoo-kernel/request_parser.c

    r889 r917  
    2828#include "response_print.h"
    2929#include "caching.h"
     30#include "cgic.h"
    3031
    3132/**
     
    154155      addToMap(cursor->content,"base64_value",tmp->value);
    155156      int size=0;
    156       char *s=strdup(tmp->value);
     157      char *s=zStrdup(tmp->value);
    157158      free(tmp->value);
    158159      tmp->value=base64d(s,strlen(s),&size);
     
    174175          addToMap(cursor->content,key,tmp->value);
    175176          int size=0;
    176           char *s=strdup(tmp->value);
     177          char *s=zStrdup(tmp->value);
    177178          free(tmp->value);
    178179          tmp->value=base64d(s,strlen(s),&size);
     
    521522  int l = 0;
    522523  map* version=getMapFromMaps(*main_conf,"main","rversion");
     524  map* memory=getMapFromMaps(*main_conf,"main","memory");
    523525  int vid=getVersionId(version->value);
    524526  for (k=0; k < nodes->nodeNr; k++)
     
    533535            xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
    534536            tmpmaps = createMaps((char *) val);
     537            xmlFree(val);
    535538          }
    536539
     
    624627                            tmpmaps->content =
    625628                              createMap (refs[l], (char *) val);
    626 
    627629                          map *ltmp = getMap (tmpmaps->content, "method");
    628630                          if (l == 4 )
    629631                            {
    630                               if ((ltmp==NULL || strncasecmp (ltmp->value, "POST",4) != 0)) //
    631                               //if ((ltmp==NULL || strncmp (ltmp->value, "POST",4) != 0))
     632                              if ((ltmp==NULL || strncmp (ltmp->value, "POST",4) != 0))
    632633                                {
    633634                                  if (loadRemoteFile
     
    751752                                      map *btmp =
    752753                                        getMap (tmpmaps->content, "Reference");
     754                                      addToMap (tmpmaps->content, "Body", tmp);
    753755                                      if (btmp != NULL)
    754756                                        {
     
    759761                                                           xmlStrlen(btmps),
    760762                                                           INTERNET_FLAG_NO_CACHE_WRITE,
    761                                                            0);
     763                                                           0,
     764                                                           *main_conf);
    762765                                          addIntToMap (tmpmaps->content, "Order", hInternet->nb);
    763766                                        }
     
    778781                                  xmlGetProp (cur3, BAD_CAST "href");
    779782                                HINTERNET bInternet, res1, res;
     783                                maps *tmpConf=createMaps("main");
     784                                tmpConf->content=createMap("memory","load");
    780785                                bInternet = InternetOpen (
    781786#ifndef WIN32
     
    785790                                                          INTERNET_OPEN_TYPE_PRECONFIG,
    786791                                                          NULL, NULL, 0);
     792#ifndef WIN32
    787793                                if (!CHECK_INET_HANDLE (bInternet))
    788794                                  fprintf (stderr,
    789795                                           "WARNING : bInternet handle failed to initialize");
     796#endif
    790797                                bInternet.waitingRequests[0] =
    791                                   strdup ((char *) val);
     798                                  zStrdup ((char *) val);
    792799                                res1 =
    793800                                  InternetOpenUrl (&bInternet,
     
    795802                                                   [0], NULL, 0,
    796803                                                   INTERNET_FLAG_NO_CACHE_WRITE,
    797                                                    0);
     804                                                   0,
     805                                                   tmpConf);
    798806                                processDownloads (&bInternet);
     807                                freeMaps(&tmpConf);
     808                                free(tmpConf);
    799809                                char *tmp =
    800810                                  (char *)
     
    816826                                                  &bRead);
    817827                                tmp[bInternet.ihandle[0].nDataLen] = 0;
    818                                 InternetCloseHandle (&bInternet);
     828                                InternetCloseHandle(&bInternet);
     829                                addToMap (tmpmaps->content, "Body", tmp);
    819830                                map *btmp =
    820831                                  getMap (tmpmaps->content, "href");
     
    829840                                                       strlen(tmp),
    830841                                                       INTERNET_FLAG_NO_CACHE_WRITE,
    831                                                        0);
     842                                                       0,
     843                                                       *main_conf);
    832844                                    addIntToMap (tmpmaps->content, "Order", hInternet->nb);
    833845                                  }
    834846                                free (tmp);
     847                                xmlFree (val);
    835848                              }
    836849                        }
     
    895908                    }
    896909                  }
    897 
    898910
    899911                  while (cur4 != NULL)
     
    967979
    968980                      map *test = getMap (tmpmaps->content, "encoding");
    969 
    970981                      if (test == NULL)
    971                         { 
     982                        {
    972983                          if (tmpmaps->content != NULL)
    973984                            addToMap (tmpmaps->content, "encoding",
     
    979990                        }
    980991
    981                       if (getMap(tmpmaps->content,"dataType")==NULL && strcasecmp (test->value, "base64") != 0)
    982                         {
    983                           xmlChar *mv = xmlNodeListGetString (doc,
    984                                                               cur4->xmlChildrenNode,
    985                                                               1);
     992                      if (getMap(tmpmaps->content,"dataType")==NULL && test!=NULL && strcasecmp (test->value, "base64") != 0)
     993                        {
     994                          xmlChar *mv = NULL;
     995                          /*if(cur4!=NULL && cur4->xmlChildrenNode!=NULL)
     996                            xmlChar *mv = xmlNodeListGetString (doc,
     997                                                                cur4->xmlChildrenNode,
     998                                                                1);*/
    986999                          map *ltmp =
    9871000                            getMap (tmpmaps->content, "mimeType");
    988                           if (mv == NULL
    989                               ||
     1001                          if (/*mv == NULL
     1002                              ||*/
    9901003                              (xmlStrcasecmp
    9911004                               (cur4->name, BAD_CAST "ComplexData") == 0
     
    10251038                                           buffersize);
    10261039                            }else{
     1040
    10271041                            if(xmlStrcasecmp
    10281042                               (cur4->name, BAD_CAST "BoundingBoxData") == 0){
     
    10391053                              xmlNodePtr cur5 = cur4->children;
    10401054                              while (cur5 != NULL
     1055                                     && cur5->type != XML_ELEMENT_NODE
     1056                                     && cur5->type != XML_TEXT_NODE
    10411057                                     && cur5->type != XML_CDATA_SECTION_NODE)
    10421058                                cur5 = cur5->next;
    10431059                              if (cur5 != NULL
    1044                                   && cur5->type == XML_CDATA_SECTION_NODE){
    1045                                 if(mv!=NULL)
    1046                                   xmlFree(mv);
    1047                                 mv=xmlStrdup(cur5->content);
     1060                                  && cur5->type != XML_CDATA_SECTION_NODE
     1061                                  && cur5->type != XML_TEXT_NODE)
     1062                                {
     1063                                  xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
     1064                                  int buffersize;
     1065                                  xmlDocSetRootElement (doc1, cur5);
     1066                                  xmlDocDumpFormatMemoryEnc (doc1, &mv,
     1067                                                             &buffersize,
     1068                                                             "utf-8", 0);
     1069                                  addIntToMap (tmpmaps->content, "size",
     1070                                               buffersize);
     1071                                }
     1072                              else if (cur5 != NULL)/*
     1073                                     && cur5->type == XML_CDATA_SECTION_NODE)*/{
     1074                                xmlFree(mv);
     1075                                if(cur5->content!=NULL){
     1076                                  mv=xmlStrdup(cur5->content);
     1077                                }
    10481078                              }
    10491079                            }
     
    10881118                cur2 = cur2->next;
    10891119              }
     1120            }
     1121          if(memory!=NULL && strncasecmp(memory->value,"load",4)!=0)
     1122            if(getMap(tmpmaps->content,"to_load")==NULL){
     1123              addToMap(tmpmaps->content,"to_load","false");
    10901124            }
    10911125          {
     
    11231157                  }
    11241158              }
    1125             else
     1159            else{
    11261160              addMapsToMaps (request_output, tmpmaps);
     1161            }
    11271162          }
    11281163          freeMaps (&tmpmaps);
     
    11981233      const char ress[4][13] =
    11991234        { "mimeType", "encoding", "schema", "transmission" };
     1235      xmlFree (val);
    12001236      for (l = 0; l < 4; l++){
    12011237        val = xmlGetProp (cur, BAD_CAST ress[l]);
     
    12171253        while (ccur != NULL){
    12181254          if(ccur->type == XML_ELEMENT_NODE){
    1219             char *xpathExpr=(char*)malloc(65+strlen(tmpmaps->name));
    1220             sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);
     1255            char *xpathExpr=(char*)malloc(66+strlen(tmpmaps->name));
     1256            sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);           
    12211257            xmlXPathObjectPtr tmpsptr = extractFromDoc (doc, xpathExpr);
    12221258            xmlNodeSet* cnodes = tmpsptr->nodesetval;
    12231259            xmlParseOutputs2(main_conf,request_inputs,&tmpmaps->child,doc,cnodes);
     1260            xmlXPathFreeObject (tmpsptr);
     1261            free(xpathExpr);
    12241262            break;
    12251263          }
     
    14701508
    14711509  xmlInitParser ();
    1472   //xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER);
    1473   xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER | XML_PARSE_HUGE); //
     1510  xmlDocPtr doc = xmlReadMemory (post, cgiContentLength, "input_request.xml", NULL, XML_PARSE_RECOVER);
    14741511
    14751512  /**
     
    15031540          else
    15041541            addToMap(*request_inputs,"mode","auto");
     1542          xmlFree(val);
    15051543          val = xmlGetProp (cur, BAD_CAST "response");
    15061544          if(val!=NULL){
     
    15151553            addToMap(*request_inputs,"ResponseDocument","");
    15161554          }
     1555          xmlFree(val);
    15171556        }
    15181557      }
     
    17681807#endif
    17691808                  targetFile =
    1770                     open (storageNameOnServer, O_RDWR | O_CREAT | O_TRUNC,
     1809                    zOpen (storageNameOnServer, O_RDWR | O_CREAT | O_TRUNC,
    17711810                          S_IRWXU | S_IRGRP | S_IROTH);
    17721811                  if (targetFile < 0)
     
    17881827                  addToMap (tmpReqI->content, "lref", storageNameOnServer);
    17891828                  cgiFormFileClose (file);
    1790                   close (targetFile);
     1829                  zClose (targetFile);
    17911830                  free(fileNameOnServer);
    17921831                  free(storageNameOnServer);
     
    18201859  if (r_inputs == NULL){
    18211860    if(mandatory>0){
    1822       const char *replace=_("Mandatory parameter <%s> was not specified");
     1861      char *replace=_("Mandatory parameter <%s> was not specified");
    18231862      char *message=(char*)malloc((strlen(replace)+strlen(toCheck)+1)*sizeof(char));
    18241863      sprintf(message,replace,toCheck);
     
    18691908    }
    18701909    if(hasValidValue<0){
    1871       const char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
     1910      char *replace=_("The value <%s> was not recognized, %s %s the only acceptable value.");
    18721911      nb=0;
    18731912      char *vvalues=NULL;
    1874       const char* num=_("is");
     1913      char* num=_("is");
    18751914      while(avalues[nb]!=NULL){
    18761915        char *tvalues;
     
    19201959  }
    19211960}
     1961
     1962/**
     1963 * Parse cookie contained in request headers.
     1964 *
     1965 * @param conf the conf maps containinfg the main.cfg
     1966 * @param cookie the
     1967 */
     1968void parseCookie(maps** conf,const char* cookie){
     1969  char* tcook=zStrdup(cookie);
     1970  char *token, *saveptr;
     1971  token = strtok_r (tcook, "; ", &saveptr);
     1972  maps* res=createMaps("cookies");
     1973  while (token != NULL){
     1974    char *token1, *saveptr1, *name;
     1975    int i=0;
     1976    token1 = strtok_r (token, "=", &saveptr1);
     1977    while (token1 != NULL){
     1978      if(i==0){
     1979        name=zStrdup(token1);
     1980        i++;
     1981      }
     1982      else{
     1983        if(res->content==NULL)
     1984          res->content=createMap(name,token1);
     1985        else
     1986          addToMap(res->content,name,token1);
     1987        free(name);
     1988        name=NULL;
     1989        i=0;
     1990      }
     1991      token1 = strtok_r (NULL, "=", &saveptr1);
     1992    }
     1993    if(name!=NULL)
     1994      free(name);
     1995    token = strtok_r (NULL, "; ", &saveptr);
     1996  }
     1997  addMapsToMaps(conf,res);
     1998  freeMaps(&res);
     1999  free(res);
     2000  free(tcook);
     2001}
  • trunk/zoo-project/zoo-kernel/request_parser.h

    r866 r917  
    4545  int kvpParseOutputs(maps**,map *,maps**);
    4646  int xmlParseInputs(maps**,service*,maps**,xmlDocPtr,xmlNodeSet*,HINTERNET*);
     47  int xmlParseBoundingBox(maps** main_conf,map** current_input,xmlDocPtr doc);
    4748  int xmlParseOutputs(maps**,map**,maps**,xmlDocPtr,xmlNodePtr,bool);
    4849  int xmlParseRequest(maps**,const char*,map**,service*,maps**,maps**,HINTERNET*);
     
    5051  void checkValidValue(map*,map**,const char*,const char**,int);
    5152  int validateRequest(maps**,service*,map*,maps**,maps**,HINTERNET*);
    52 
     53  void parseCookie(maps**,const char*);
     54 
    5355#ifdef __cplusplus
    5456}
  • trunk/zoo-project/zoo-kernel/response_print.c

    r889 r917  
    2323 */
    2424
     25#include "service.h"
    2526#include "response_print.h"
    2627#include "request_parser.h"
     
    3132#else
    3233#include "cpl_vsi.h"
     34#endif
     35#ifdef USE_CALLBACK
     36#include "service_callback.h"
    3337#endif
    3438
     
    7579    }
    7680    if(prefix!=NULL){
    77       char* tmp0=strdup(serv->name);
     81      char* tmp0=zStrdup(serv->name);
    7882      free(serv->name);
    7983      serv->name=(char*)malloc((strlen(prefix)+strlen(tmp0)+1)*sizeof(char));
     
    179183    nbNs++;
    180184    currId=0;
    181     nsName[currId]=strdup(name);
     185    nsName[currId]=zStrdup(name);
    182186    usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
    183187  }else{
     
    186190      nbNs++;
    187191      currId=nbNs-1;
    188       nsName[currId]=strdup(name);
     192      nsName[currId]=zStrdup(name);
    189193      usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
    190194    }
     
    251255  if(soap!=NULL && strcasecmp(soap->value,"true")==0){
    252256    int lNbNs=nbNs;
    253     nsName[lNbNs]=strdup("soap");
     257    nsName[lNbNs]=zStrdup("soap");
    254258    usedNs[lNbNs]=xmlNewNs(NULL,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
    255259    nbNs++;
    256260    xmlNodePtr nr = xmlNewNode(usedNs[lNbNs], BAD_CAST "Envelope");
    257     nsName[nbNs]=strdup("soap");
     261    nsName[nbNs]=zStrdup("soap");
    258262    usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
    259263    nbNs++;
    260     nsName[nbNs]=strdup("xsi");
     264    nsName[nbNs]=zStrdup("xsi");
    261265    usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
    262266    nbNs++;
     
    338342      }
    339343      else{
    340         nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
    341         xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
    342344        if(dcount==0){
    343345          if(vid==0){
     346            nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
     347            xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
    344348            xmlAddChild(nc2,nc4);
    345349            xmlAddChild(nc1,nc2);
     
    361365      nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
    362366      xmlAddChild(nc4,xmlNewText(BAD_CAST buff));             
    363         if(vid==0)
    364           xmlAddChild(nc3,nc4);
    365         else
    366           xmlAddChild(nc1,nc4);
     367      if(vid==0)
     368        xmlAddChild(nc3,nc4);
     369      else
     370        xmlAddChild(nc1,nc4);
    367371    }
    368372  }
     
    590594    map* tmp=getMap(toto1->content,"serverAddress");
    591595    if(tmp!=NULL){
    592       SERVICE_URL = strdup(tmp->value);
     596      SERVICE_URL = zStrdup(tmp->value);
    593597    }
    594598    else
    595       SERVICE_URL = strdup("not_defined");
     599      SERVICE_URL = zStrdup("not_defined");
    596600  }
    597601  else
    598     SERVICE_URL = strdup("not_defined");
     602    SERVICE_URL = zStrdup("not_defined");
    599603
    600604  for(j=0;j<nbSupportedRequests;j++){
     
    644648 * @return the generated wps:ProcessOfferings xmlNodePtr
    645649 */
    646 void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
     650void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
    647651  xmlNsPtr ns,ns_ows,ns_xml,ns_xlink;
    648   xmlNodePtr n=NULL,nc1,nc2;
     652  xmlNodePtr n=NULL,nc1,nc2,nc3;
    649653  map* version=getMapFromMaps(m,"main","rversion");
    650654  int vid=getVersionId(version->value);
     
    667671      limit=7;
    668672    }
     673    nc3=NULL;
     674    map* sType=getMap(serv->content,"serviceType");
    669675    for(;i<limit;i+=2){
    670676      if(capabilities[vid][i]==NULL)
     
    682688            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST tmp1->value);
    683689        }
    684         else
    685           xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
     690        else{
     691          if(i==3 && vid==1 && sType!=NULL && strstr(sType->value,"HPC")!=NULL)
     692            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
     693          else
     694            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
     695        }
    686696      }
    687697    }
     
    690700    printDescription(nc1,ns_ows,serv->name,serv->content,vid);
    691701    tmp1=serv->metadata;
    692     while(tmp1!=NULL){
    693       nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
    694       xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
    695       xmlAddChild(nc1,nc2);
    696       tmp1=tmp1->next;
    697     }
    698 
     702
     703    addMetadata(tmp1,doc,nc1,ns_ows,ns_xlink,vid);
     704    tmp1=serv->additional_parameters;
     705    int fromDb=-1;
     706    map* test=getMap(serv->content,"fromDb");
     707    if(test!=NULL && strncasecmp(test->value,"true",4)==0)
     708      fromDb=1;
     709    addAdditionalParameters(tmp1,doc,nc1,ns_ows,ns_xlink,fromDb);
     710
     711    if(nc3!=NULL)
     712      xmlAddChild(nc1,nc3);
    699713    xmlAddChild(nc,nc1);
    700714  }
     715
    701716}
    702717
     
    708723 * @param content the servive main content created from the zcfg file
    709724 * @param vid the version identifier (0 for 1.0.0 and 1 for 2.0.0)
    710  */
    711 void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid){
     725 * @param serviceType string containing the current service type
     726 */
     727void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid,map* serviceType){
    712728  int limit=7;
    713729  for(int i=1;i<limit;i+=2){
     
    728744    }
    729745    else{
    730       if(vid==0 && i>=2)
    731         xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
     746      if(i==3 && vid==1 && serviceType!=NULL && strstr(serviceType->value,"HPC")!=NULL)
     747        xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
    732748      else
    733         xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
    734     }
     749        if(vid==0 && i>=2)
     750          xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
     751        else
     752          xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
     753    }
     754  }
     755}
     756
     757/**
     758 * Add a Metadata node to any existing node.
     759 * @param meta the map defining the additional parameters
     760 * @param doc the XML document used
     761 * @param nb the node to add the additional parameters
     762 * @param ns_ows the OWS namespace
     763 * @param ns_xlink the xlink namespace
     764 * @param vid the version of WPS to use (0 for 1.0.0 and 1 for 2.0)
     765 */
     766void addMetadata(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int vid){
     767  int hasTitle=-1;
     768  int hasValue=-1;
     769  xmlNodePtr nc1;
     770  map* oMeta=meta;
     771  int isAdditionalParameters=-1;
     772  int level=0;
     773  map* test=getMap(meta,"title");
     774  if(test!=NULL)
     775    level+=1;
     776  test=getMap(meta,"href");
     777  if(test!=NULL)
     778    level+=1;
     779  test=getMap(meta,"role");
     780  if(test!=NULL)
     781    level+=1;
     782  if(count(oMeta)>level+1)
     783    isAdditionalParameters=1;
     784  char *ctitle=NULL;
     785  while(meta!=NULL){
     786    if(hasTitle<0)
     787      if(isAdditionalParameters<0)
     788        nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
     789      else
     790        if(hasValue<0)
     791          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
     792    if(strncasecmp(meta->name,"title",5)==0 ||
     793       strcasecmp(meta->name,"href")==0 ||
     794       strcasecmp(meta->name,"role")==0 ){
     795      int index=5;
     796      if(strncasecmp(meta->name,"title",5)==0){
     797        index=6;
     798        hasTitle=1;
     799        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
     800          xmlAddChild(nc,nc1);
     801          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
     802          free(ctitle);
     803          ctitle=NULL;
     804        }
     805        if(ctitle==NULL){
     806          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
     807          snprintf(tmp,index,"%s",meta->name);
     808          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
     809          free(tmp);
     810        }         
     811        if(ctitle!=NULL)
     812          free(ctitle);
     813        ctitle=zStrdup(meta->value);
     814      }
     815    }else{
     816      xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
     817      xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
     818      xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
     819      xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
     820      xmlAddChild(nc4,xmlNewText(BAD_CAST meta->value));
     821      xmlAddChild(nc2,nc3);
     822      xmlAddChild(nc2,nc4);
     823      xmlAddChild(nc1,nc2);
     824      hasTitle=-1;
     825    }
     826    meta=meta->next;
     827    if(hasTitle<0){
     828      hasValue=1;
     829      if(isAdditionalParameters){
     830        if(vid==0){
     831          meta=NULL;
     832          break;
     833        }else
     834          xmlAddChild(nc,nc1);
     835      }
     836    }
     837  }
     838  if(oMeta!=NULL && hasValue<0 && nc1!=NULL){
     839    xmlAddChild(nc,nc1);
     840  }
     841}
     842
     843/**
     844 * Add AdditionalParameters nodes to any existing node.
     845 * @param meta the map defining the additional parameters
     846 * @param doc the XML document used
     847 * @param nb the node to add the additional parameters
     848 * @param ns_ows the OWS namespace
     849 * @param ns_xlink the xlink namespace
     850 * @param fromDb 1 if the metadata has been extracted from the metadb,
     851 * 0 otherwise
     852 */
     853void addAdditionalParameters(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int fromDb){
     854  int hasTitle=-1;
     855  int hasValue=-1;
     856  int toAddAtEnd=-1;
     857  int cnt=0;
     858  xmlNodePtr* ncr=NULL;
     859  xmlNodePtr nc1;
     860  map* oMeta=meta;
     861  int isAdditionalParameters=-1;
     862  int level=0;
     863  map* test=getMap(meta,"title");
     864  map* otitle=getMap(meta,"title");
     865  map* length=getMap(meta,"length");
     866  int len=0;
     867  char *ctitle=NULL;
     868   
     869  if(test!=NULL)
     870    level+=1;
     871  test=getMap(meta,"href");
     872  if(test!=NULL)
     873    level+=1;
     874  test=getMap(meta,"role");
     875  if(test!=NULL)
     876    level+=1;
     877  if(count(oMeta)>level+1)
     878    isAdditionalParameters=1;
     879
     880  while(meta!=NULL){
     881    if(hasTitle<0 && hasValue<0){
     882      nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
     883    }
     884    if(strncasecmp(meta->name,"title",5)==0 ||
     885       strcasecmp(meta->name,"href")==0 ||
     886       strcasecmp(meta->name,"role")==0 ){
     887      int index=5;
     888      if(strncasecmp(meta->name,"title",5)==0){
     889        index=6;
     890        hasTitle=1;
     891        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
     892          xmlNodePtr ncTmp = xmlDocCopyNodeList(doc,nc1);
     893          xmlAddChild(nc,ncTmp);
     894          xmlFreeNode(nc1);
     895          toAddAtEnd=1;
     896          cnt++;
     897          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
     898          free(ctitle);
     899          ctitle=NULL;
     900        }
     901        if(ctitle==NULL){
     902          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
     903          snprintf(tmp,index,"%s",meta->name);
     904          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
     905          free(tmp);
     906        }         
     907        if(ctitle!=NULL)
     908          free(ctitle);
     909        ctitle=zStrdup(meta->value);
     910      }else{
     911        xmlNewNsProp(nc1,ns_xlink,BAD_CAST meta->name,BAD_CAST meta->value);
     912      }
     913    }else{
     914      if(strncasecmp(meta->name,"length",6)!=0 && strncasecmp(meta->name,"fromDb",6)!=0){
     915        xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
     916        xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
     917        xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
     918        xmlAddChild(nc2,nc3);
     919        if(fromDb<0){
     920          char *mptr;
     921          char* meta_values=strtok_r(meta->value,",",&mptr);
     922          while(meta_values!=NULL){
     923            xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
     924            xmlAddChild(nc4,xmlNewText(BAD_CAST meta_values));
     925            xmlAddChild(nc2,nc4);
     926            meta_values=strtok_r(NULL,",",&mptr);
     927          }
     928        }else{
     929          xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
     930          xmlAddChild(nc4,xmlNewCDataBlock(doc,BAD_CAST meta->value,strlen(meta->value)));
     931          xmlAddChild(nc2,nc4);
     932        }
     933        xmlAddChild(nc1,nc2);
     934      }
     935      hasTitle=-1;
     936    }
     937    meta=meta->next;
     938    if(hasTitle<0){
     939      //xmlAddChild(nc,nc1);
     940      hasValue=1;
     941    }/*else
     942       if(ctitle!=NULL)
     943       free(ctitle);*/
     944  }
     945  if(length!=NULL)
     946    len=atoi(length->value);
     947  if(otitle!=NULL)
     948    len=1;
     949  if(cnt<len){
     950    xmlAddChild(nc,nc1);
     951    free(ctitle);
    735952  }
    736953}
     
    7921009 * @return the generated wps:ProcessOfferings xmlNodePtr
    7931010 */
    794 void printDescribeProcessForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
     1011void printDescribeProcessForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
    7951012  xmlNsPtr ns,ns_ows,ns_xlink;
    7961013  xmlNodePtr n,nc1;
     
    7981015  map* version=getMapFromMaps(m,"main","rversion");
    7991016  int vid=getVersionId(version->value);
     1017  int fromDb=-1;
     1018  map* serviceType=getMap(serv->content,"serviceType");
     1019  map* test=getMap(serv->content,"fromDb");
     1020  if(test!=NULL && strncasecmp(test->value,"true",4)==0)
     1021    fromDb=1;
    8001022
    8011023  n=nc;
     
    8111033  if(vid==0){
    8121034    nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
    813     attachAttributes(nc,ns,serv->content,vid);
     1035    attachAttributes(nc,ns,serv->content,vid,NULL);
    8141036  }
    8151037  else{
     
    8281050      }
    8291051    }
    830     attachAttributes(nc2,NULL,serv->content,vid);
     1052    attachAttributes(nc2,NULL,serv->content,vid,serviceType);
    8311053    map* level=getMap(serv->content,"level");
    8321054    if(level!=NULL && strcasecmp(level->value,"generic")==0)
     
    8431065    tmp1=serv->metadata;
    8441066    while(tmp1!=NULL){
    845       nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
    846       xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
    847       xmlAddChild(nc,nc1);
     1067      addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
    8481068      tmp1=tmp1->next;
    8491069    }
     
    8551075    }
    8561076  }else{
     1077    tmp1=serv->metadata;
     1078    addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
    8571079    addInheritedMetadata(nc,ns_ows,ns_xlink,reg,m,serv);
     1080    tmp1=serv->additional_parameters;
     1081    if(vid!=0)
     1082      addAdditionalParameters(tmp1,doc,nc,ns_ows,ns_xlink,fromDb);
    8581083  }
    8591084
     
    8621087    if(vid==0){
    8631088      nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
    864       printFullDescription(1,e,"Input",ns,ns_ows,nc1,vid);
     1089      printFullDescription(doc,1,e,"Input",ns,ns_ows,nc1,vid,fromDb,NULL);
    8651090      xmlAddChild(nc,nc1);
    8661091    }
    8671092    else{
    868       printFullDescription(1,e,"wps:Input",ns,ns_ows,nc,vid);
     1093      printFullDescription(doc,1,e,"wps:Input",ns,ns_ows,nc,vid,fromDb,NULL);
    8691094    }
    8701095  }
     
    8731098  if(vid==0){
    8741099    nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
    875     printFullDescription(0,e,"Output",ns,ns_ows,nc1,vid);
     1100    printFullDescription(doc,0,e,"Output",ns,ns_ows,nc1,vid,fromDb,NULL);
    8761101    xmlAddChild(nc,nc1);
    8771102  }
    8781103  else{
    879     printFullDescription(0,e,"wps:Output",ns,ns_ows,nc,vid);
     1104    printFullDescription(doc,0,e,"wps:Output",ns,ns_ows,nc,vid,fromDb,serviceType);
    8801105  }
    8811106  if(vid==0)
     
    8991124 * @param nc1 the XML node to use to add the created tree
    9001125 * @param vid the WPS version id (0 for 1.0.0, 1 for 2.0.0)
    901  */
    902 void printFullDescription(int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid){
     1126 * @param fromDb 1 in case the metadata comes from the DB, -1 in other cases
     1127 * @param serviceType the serviceType found in the ZCFG file or the DB
     1128 */
     1129void printFullDescription(xmlDocPtr doc,int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid,int fromDb,const map* serviceType){
    9031130  xmlNsPtr ns1=NULL;
    9041131  if(vid==1)
     
    9131140    int isAnyValue=1;
    9141141    nc2 = xmlNewNode(NULL, BAD_CAST type);
     1142    // Extract min/max Occurence information
    9151143    if(strstr(type,"Input")!=NULL){
    9161144      tmp1=getMap(e->content,"minOccurs");
     
    9351163
    9361164    if(e->format!=NULL){
     1165#ifdef USE_HPC     
     1166    DEFAULT_OUT:
     1167#endif
    9371168      const char orderedFields[13][14]={
    9381169        "mimeType",
     
    9521183      //Build the (Literal/Complex/BoundingBox)Data node
    9531184      if(strncmp(type,"Output",6)==0){
    954         if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
     1185        if(strncasecmp(e->format,"LITERAL",7)==0)
    9551186          nc3 = xmlNewNode(ns1, BAD_CAST "LiteralOutput");
    9561187        else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
     
    9981229                strcmp(e->format,"BoundingBoxData")==0){
    9991230          datatype=2;
    1000           nc5 = xmlNewNode(NULL, BAD_CAST "Default");
     1231          if(vid==0)
     1232            nc5 = xmlNewNode(NULL, BAD_CAST "Default");
     1233          else{
     1234            xmlNodePtr nc6 = xmlNewNode(ns1, BAD_CAST "Format");
     1235            xmlNewProp(nc6,BAD_CAST "mimeType",BAD_CAST "text/xml");
     1236            xmlNewProp(nc6,BAD_CAST "default",BAD_CAST "true");
     1237            xmlAddChild(nc3,nc6);
     1238            nc5 = xmlNewNode(NULL, BAD_CAST "SupportedCRS");
     1239          }
    10011240        }
    10021241        else{
     
    10391278            while(token!=NULL){
    10401279              nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
    1041               char *tmps=strdup(token);
     1280              char *tmps=zStrdup(token);
    10421281              tmps[strlen(tmps)]=0;
    1043               xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
     1282              nc8 = xmlNewText(BAD_CAST tmps);
     1283              xmlAddChild(nc7,nc8);
    10441284              free(tmps);
    10451285              xmlAddChild(nc6,nc7);
     
    12071447                 strncasecmp(tmp1->name,"range",5)!=0){
    12081448                if(datatype!=1){
    1209                   char *tmp2=zCapitalize1(tmp1->name);
    1210                   nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
    1211                   free(tmp2);
     1449                  if(datatype==2 && vid==1){
     1450                    nc9 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
     1451                    xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
     1452                  }
     1453                  else{
     1454                    char *tmp2=zCapitalize1(tmp1->name);
     1455                    nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
     1456                    free(tmp2);
     1457                  }
    12121458                }
    12131459                else{
     
    12181464                xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
    12191465                if(vid==0 || oI>=3){
    1220                   if(vid==0 || oI!=4)
    1221                     xmlAddChild(nc5,nc9);
     1466                  if(vid==0 || oI!=4){
     1467                    if(datatype==2 && vid==1)
     1468                      xmlAddChild(nc3,nc9);
     1469                    else
     1470                      xmlAddChild(nc5,nc9);
     1471                  }
    12221472                  if(oI==4 && vid==1){
    12231473                    xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
    12241474                  }
    12251475                }
    1226                 else
    1227                   xmlFree(nc9);
     1476                else{
     1477                  xmlFreeNode(nc9);
     1478                }
    12281479                if(strcasecmp(tmp1->name,"uom")==0)
    12291480                  hasUOM1=true;
    12301481                hasUOM=true;
    1231               }else       
    1232                 tmp1=tmp1->next;
     1482              }
    12331483            }
    12341484        }
     
    12451495          }else{
    12461496            if(hasUOM1==false && vid==0){
    1247               xmlFreeNode(nc5);
    1248               if(datatype==1)
     1497              if(nc5!=NULL)
     1498                xmlFreeNode(nc5);
     1499              if(datatype==1){
    12491500                xmlFreeNode(nc4);
     1501              }
    12501502            }
    1251             else
     1503            else{
    12521504              xmlAddChild(nc3,nc5);
     1505            }
    12531506          }
    12541507        }else{
    1255           xmlAddChild(nc3,nc5);
     1508          if(vid==0)
     1509            xmlAddChild(nc3,nc5);
     1510          else
     1511            xmlFreeNode(nc5);
    12561512        }
    12571513     
    1258         if(datatype!=1 && default1<0){
     1514        if(datatype==0 && default1<0){
    12591515          xmlFreeNode(nc5);
    1260           if(datatype!=2)
     1516          if(datatype!=2){
    12611517            xmlFreeNode(nc4);
     1518          }
    12621519        }
    12631520
     
    13101567              nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
    13111568              free(tmp2);
    1312               //xmlNewProp(nc9, BAD_CAST "default", BAD_CAST "true");
    13131569              xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
    13141570              xmlAddChild(nc5,nc9);
    1315               /*struct iotype * _ltmp=e->supported;
    1316                 while(_ltmp!=NULL){
    1317                 tmp1=getMap(_ltmp->content,"uom");
    1318                 if(tmp1!=NULL){
    1319                 char *tmp2=zCapitalize(tmp1->name);
    1320                 nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
    1321                 free(tmp2);
    1322                 xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
    1323                 xmlAddChild(nc5,nc9);
    1324                 }
    1325                 _ltmp=_ltmp->next;
    1326                 }*/
    1327            
    13281571            }
    13291572          }
     
    13401583        xmlNsPtr ns_xlink=usedNs[xlinkId];
    13411584
    1342         while(metadata!=NULL){
    1343           nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
    1344           xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
    1345           xmlAddChild(nc2,nc6);
    1346           metadata=metadata->next;
    1347         }
     1585        addMetadata(metadata,doc,nc2,ns_ows,ns_xlink,vid);
     1586        if(vid!=0)
     1587          addAdditionalParameters(e->additional_parameters,doc,nc2,ns_ows,ns_xlink,fromDb);
    13481588
    13491589      }
    13501590
    13511591      _tmp=e->supported;
    1352       if(_tmp==NULL && datatype!=1)
     1592      if(_tmp==NULL && datatype==0)
    13531593        _tmp=e->defaults;
    13541594
     
    13961636               strcasecmp(tmp1->name,"extension")!=0){
    13971637              if(datatype!=1){
    1398                 char *tmp2=zCapitalize1(tmp1->name);
    1399                 nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
    1400                 free(tmp2);
     1638                if(datatype==2 && vid==1){
     1639                  nc6 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
     1640                }
     1641                else{
     1642                  char *tmp2=zCapitalize1(tmp1->name);
     1643                  nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
     1644                  free(tmp2);
     1645                }
    14011646              }
    14021647              else{
     
    14221667              }
    14231668              if(vid==0 || oI>=3){
    1424                 if(vid==0 || oI!=4)
    1425                   xmlAddChild(nc5,nc6);
    1426                 else
    1427                   xmlFree(nc6);
     1669                if(vid==0 || oI!=4){
     1670                  if(datatype==2 && vid==1)
     1671                    xmlAddChild(nc3,nc6);
     1672                  else
     1673                    xmlAddChild(nc5,nc6);
     1674                }
     1675                else{
     1676                  xmlFreeNode(nc6);
     1677                }
    14281678              }
    1429               else
    1430                 xmlFree(nc6);
     1679              else{
     1680                xmlFreeNode(nc6);
     1681              }
    14311682            }
    14321683            tmp1=tmp1->next;
     
    14391690            }
    14401691            else{
    1441               xmlAddChild(nc3,nc5);
     1692              if(datatype!=2)
     1693                xmlAddChild(nc3,nc5);
    14421694            }
    14431695
    14441696          }else{
    1445             if(datatype!=1)
     1697            if(datatype==2 && vid==0)
    14461698              xmlAddChild(nc3,nc5);
    14471699          }
     
    14591711          }
    14601712          else
    1461             if(datatype!=1)
     1713            if(datatype==0){
     1714              xmlFreeNode(nc4);
    14621715              xmlAddChild(nc3,nc5);
     1716            }
    14631717
    14641718        _tmp=_tmp->next;
     
    14661720
    14671721      if(hasSupported==0){
    1468         if(datatype==0 && vid!=0)
     1722        if(datatype==0 && vid!=0){
    14691723          xmlFreeNode(nc4);
     1724        }
    14701725        xmlFreeNode(nc5);
    14711726      }
     
    14781733        }
    14791734        else{
     1735          xmlFreeNode(nc4);
    14801736          xmlAddChild(nc3,nc5);
    14811737        }
     
    14911747    }else{
    14921748      if(e->child!=NULL && vid!=0){
    1493         printFullDescription(in,e->child,type,ns,ns_ows,nc2,vid);
    1494       }
    1495     }
    1496    
     1749        printFullDescription(doc,in,e->child,type,ns,ns_ows,nc2,vid,fromDb,NULL);
     1750      }
     1751    }
    14971752    if(e->child!=NULL && vid==0){
    14981753      elements* children=dupElements(e->child);
    14991754      elements* cursor=children;
    15001755      while(cursor!=NULL){
    1501         char* tmp=strdup(cursor->name);
    1502         free(cursor->name);
    1503         cursor->name=(char*)malloc((strlen(cursor->name)+strlen(e->name)+2)*sizeof(char));
    1504         sprintf(cursor->name,"%s.%s",e->name,tmp);
     1756        elements* ccursor=cursor;
     1757        char* tmp=zStrdup(ccursor->name);
     1758        free(ccursor->name);
     1759        ccursor->name=(char*)malloc((strlen(tmp)+strlen(e->name)+2)*sizeof(char));
     1760        sprintf(ccursor->name,"%s.%s",e->name,tmp);
    15051761        cursor=cursor->next;
    15061762      }
    1507       printFullDescription(in,children,type,ns,ns_ows,nc2,vid);
    1508       xmlAddChild(nc1,nc2);
     1763      printFullDescription(doc,in,children,type,ns,ns_ows,nc1,vid,fromDb,serviceType);
    15091764      freeElements(&children);
    15101765      free(children);
    1511     }else
    1512       xmlAddChild(nc1,nc2);
    1513    
     1766    }else{
     1767      if(nc2!=NULL){
     1768        xmlAddChild(nc1,nc2);
     1769      }
     1770    }
    15141771    e=e->next;
    15151772  }
     
    15281785 * @param outputs the outputs generated by the service
    15291786 */
    1530 void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
     1787void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){       
    15311788  xmlNsPtr ns,ns_ows,ns_xlink;
    15321789  xmlNodePtr nr,n,nc,nc1=NULL,nc3;
     
    15491806  char stored_path[1024];
    15501807  memset(stored_path,0,1024);
    1551    
     1808 
    15521809  if(vid==0){
    15531810    char tmp[256];
     
    17341991    }
    17351992  }
    1736 
     1993 
    17371994  /**
    17381995   * Display the process output only when requested !
     
    17442001    maps* mcursor=outputs;
    17452002    elements* scursor=serv->outputs;
    1746     map* testResponse=getMap(request,"RawDataOutput");
     2003    map* testResponse=getMap(request,"RawDataOutput"); 
    17472004    if(testResponse==NULL)
    17482005      testResponse=getMap(request,"ResponseDocument");
    1749     while(mcursor!=NULL){
     2006    while(mcursor!=NULL){               
    17502007      map* tmp0=getMap(mcursor->content,"inRequest");
    1751       scursor=getElements(serv->outputs,mcursor->name);
    1752       if(scursor!=NULL){
    1753         if(testResponse==NULL || tmp0==NULL){
     2008      scursor=getElements(serv->outputs,mcursor->name);   
     2009      if(scursor!=NULL){                 
     2010        if(testResponse==NULL || tmp0==NULL){           
    17542011          if(vid==0)
    17552012            printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
     
    17582015        }
    17592016        else
    1760 
    1761           if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){
     2017          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){             
    17622018            if(vid==0)
    17632019              printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
    17642020            else
    17652021              printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
    1766           }
     2022          }     
    17672023      }else
    17682024        /**
     
    17752031          printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
    17762032      mcursor=mcursor->next;
    1777     }
     2033    }   
    17782034    if(vid==0)
    17792035      xmlAddChild(n,nc);
    1780   }
    1781 
     2036  } 
    17822037  if(vid==0 &&
    17832038     hasStoredExecuteResponse==true
     
    18342089#endif
    18352090  }
     2091
    18362092  printDocument(m,doc,pid);
    18372093
     
    18912147  else{
    18922148    /*
    1893     dumpElements(e);
     2149      dumpElements(e);
    18942150    */
    18952151    return;
     
    19002156       || strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
    19012157       || strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
    1902     xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
     2158      xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
    19032159    tmp=tmp->next;
    19042160  }
     
    19272183 * @param type the type
    19282184 */
    1929 void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){
    1930 
     2185void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){   
    19312186  xmlNodePtr nc1,nc2,nc3;
    19322187  nc1=xmlNewNode(ns_wps, BAD_CAST type);
     
    19352190    tmp=e->content;
    19362191  else
    1937     tmp=m->content;
    1938 
     2192    tmp=m->content; 
    19392193  if(vid==0){
    19402194    nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
     
    19762230    xmlNewProp(nc1,BAD_CAST "id",BAD_CAST (e!=NULL?e->name:m->name));
    19772231  }
    1978 
     2232 
    19792233  // IO type nested outputs
    1980   if(m->child!=NULL){
     2234  if(m->child!=NULL){     
    19812235    maps* curs=m->child;
    19822236    elements* ecurs=getElements(e,(e!=NULL?e->name:m->name));
    19832237    ecurs=ecurs->child;
    1984     while(curs!=NULL){
     2238    while(curs!=NULL/* && ecurs!=NULL*/){
    19852239      ecurs=getElements(ecurs,(curs->name));
    19862240      map* inRequest=getMap(curs->content,"inRequest");
     
    19922246    }
    19932247  }
    1994   else{
     2248  else{   
    19952249    map *tmpMap=getMap(m->content,"Reference");
    1996     if(tmpMap==NULL){
     2250    if(tmpMap==NULL){           
    19972251      nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
    1998       if(e!=NULL && e->format!=NULL){
    1999         if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
    2000           nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
     2252      if(e!=NULL && e->format!=NULL){             
     2253                  if (strncasecmp(e->format, "LiteralOutput", strlen(e->format)) == 0)                                   
     2254                          nc3 = xmlNewNode(ns_wps, BAD_CAST "LiteralData");               
    20012255        else
    20022256          if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
     
    20052259            nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
    20062260          else
    2007             nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
    2008       }
    2009       else {
    2010         map* tmpV=getMapFromMaps(m,"format","value");
     2261            nc3=xmlNewNode(ns_wps, BAD_CAST e->format);           
     2262      }
     2263      else {             
     2264        map* tmpV=getMapFromMaps(m,"format","value");   
    20112265        if(tmpV!=NULL)
    20122266          nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
     
    20142268          nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
    20152269      }
    2016       tmp=m->content;
    2017      
     2270      tmp=m->content;     
     2271
    20182272      while(tmp!=NULL){
    20192273        if(strcasecmp(tmp->name,"mimeType")==0 ||
     
    20212275           strcasecmp(tmp->name,"schema")==0 ||
    20222276           strcasecmp(tmp->name,"datatype")==0 ||
    2023            strcasecmp(tmp->name,"uom")==0) {
    2024          
     2277           strcasecmp(tmp->name,"uom")==0) {   
    20252278          if(vid==0)
    20262279            xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
     
    20332286          }
    20342287        }
     2288
    20352289        if(vid==0)
    20362290          xmlAddChild(nc2,nc3);
    2037         tmp=tmp->next;
     2291        tmp=tmp->next; 
    20382292      }
    20392293      if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0) {
     
    20462300        }
    20472301      }
    2048       else {
    2049         if(e!=NULL)
    2050           tmp=getMap(e->defaults->content,"mimeType");
     2302      else {             
     2303                  //if (e != NULL) {
     2304                  if (e != NULL && e->defaults != NULL) { // knut: add extra NULL pointer check in case user omits <Default> block in config file                         
     2305                          tmp = getMap(e->defaults->content, "mimeType");
     2306                  }
    20512307        else
    2052           tmp=NULL;
    2053        
     2308          tmp=NULL;     
    20542309        map* tmp1=getMap(m->content,"encoding");
    20552310        map* tmp2=getMap(m->content,"mimeType");
     
    21062361             strstr(tmp2->value, "json") != NULL ||            //    (will not be parsed by XML reader)
    21072362             strstr(tmp2->value, "ecmascript") != NULL
    2108            ) {
     2363             ) {
    21092364            xmlAddChild((vid==0?nc3:nc2),xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
    21102365          }   
     
    21122367            if (strstr(tmp2->value, "xml") != NULL ||                 // if XML-based format
    21132368                // include for backwards compatibility,
    2114               // although correct mime type is ...kml+xml:                 
     2369                // although correct mime type is ...kml+xml:               
    21152370                strstr(tmp2->value, "google-earth.kml") != NULL
    21162371                ) {
     
    22412496  else
    22422497    exceptionCode="501 Internal Server Error";
    2243 
     2498  tmp=getMapFromMaps(m,"lenv","status_code");
     2499  if(tmp!=NULL)
     2500    exceptionCode=tmp->value;
    22442501  if(m!=NULL){
    22452502    map *tmpSid=getMapFromMaps(m,"lenv","sid");
     
    23322589
    23332590    tmp=getMapArray(s,"text",cnt);
     2591    if(tmp==NULL)
     2592      tmp=getMapArray(s,"message",cnt);
    23342593    nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
    23352594    if(tmp!=NULL){
    23362595      xmlNodePtr txt=xmlNewText(BAD_CAST tmp->value);
    23372596      xmlAddChild(nc1,txt);
     2597      if(cnt==0)
     2598        setMapInMaps(m,"lenv","message",tmp->value);
    23382599    }
    23392600    else{
     
    23812642void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
    23822643                    map* request_inputs1,int cpid,maps* m,int res){
    2383                
    23842644#ifdef DEBUG
    23852645  dumpMaps(request_inputs);
    23862646  dumpMaps(request_outputs);
    23872647  fprintf(stderr,"printProcessResponse\n");
    2388 #endif
     2648#endif 
    23892649  map* toto=getMap(request_inputs1,"RawDataOutput");
    23902650  int asRaw=0;
     
    23962656  if(tmpSess!=NULL){
    23972657    map *_tmp=getMapFromMaps(m,"lenv","cookie");
     2658    maps *tmps=getMaps(m,"senv");
    23982659    char* sessId=NULL;
    23992660    if(_tmp!=NULL){
    24002661      printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
     2662      map *_tmp1=getMapFromMaps(m,"senv","ecookie_length");
     2663      if(_tmp1!=NULL){
     2664        int len=atoi(_tmp1->value);
     2665        int cnt=0;
     2666        for(cnt=0;cnt<len;cnt++){
     2667          map* _tmp2=getMapArray(tmps->content,"ecookie",cnt);
     2668          if(_tmp2!=NULL)
     2669            printf("Set-Cookie: %s; HttpOnly\r\n",_tmp2->value);
     2670        }
     2671      }
    24012672      printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
    24022673      char session_file_path[100];
     
    24062677      else
    24072678        sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
    2408       sessId=strdup(session_file_path);
     2679      sessId=zStrdup(session_file_path);
    24092680    }else{
    24102681      maps* t=getMaps(m,"senv");
     
    24122683      while(p!=NULL){
    24132684        if(strstr(p->name,"ID")!=NULL){
    2414           sessId=strdup(p->value);
     2685          sessId=zStrdup(p->value);
    24152686          break;
    24162687        }
     
    24352706    }
    24362707  }
    2437                  
    24382708  if(res==SERVICE_FAILED){
    24392709    map *lenv;
     
    24622732    return;
    24632733  }
    2464        
     2734
     2735  if(res!=SERVICE_SUCCEEDED){     
     2736    printProcessResponse(m,request_inputs1,cpid,
     2737                         s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
     2738                         request_inputs,
     2739                         request_outputs);
     2740    return;
     2741  }
     2742     
    24652743  map *tmp1=getMapFromMaps(m,"main","tmpPath");
    24662744  if(asRaw==0){
     
    24732751    map* usid=getMapFromMaps(m,"lenv","usid");
    24742752    int itn=0;
     2753    int error=-1;
    24752754  NESTED0:
    24762755    while(tmpI!=NULL){
     
    24832762#endif
    24842763      map *gfile=getMap(tmpI->content,"generated_file");
    2485       char *file_name;
     2764      char *file_name=NULL;       
    24862765      if(gfile!=NULL){
    24872766        gfile=getMap(tmpI->content,"expected_generated_file");
     
    24912770        readGeneratedFile(m,tmpI->content,gfile->value);
    24922771        file_name=zStrdup((gfile->value)+strlen(tmp1->value));
    2493       }
    2494 
     2772      }   
    24952773      toto=getMap(tmpI->content,"asReference");
    24962774#ifdef USE_MS
    2497       if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
     2775      map* geodatatype=getMap(tmpI->content,"geodatatype");
     2776      if(toto!=NULL && strcasecmp(toto->value,"true")==0 &&
     2777         (testMap==NULL ||
     2778          strncasecmp(testMap->value,"true",4)!=0 ||
     2779          (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0) ) )
    24982780#else
    2499       if(toto!=NULL && strcasecmp(toto->value,"true")==0)
     2781        if(toto!=NULL && strcasecmp(toto->value,"true")==0)
    25002782#endif
    2501         {
    2502           elements* in=getElements(s->outputs,tmpI->name);
    2503           if(in==NULL && s->outputs->child!=NULL){
    2504             in=getElements(s->outputs->child,tmpI->name);
     2783          {             
     2784            elements* in=getElements(s->outputs,tmpI->name);
     2785            if(in==NULL && s->outputs->child!=NULL){
     2786              in=getElements(s->outputs->child,tmpI->name);
     2787            }
     2788            char *format=NULL;
     2789            if(in!=NULL && in->format!=NULL){
     2790              format=in->format;
     2791            }else
     2792              format=(char*)"LiteralData";
     2793            if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
     2794              addToMap(tmpI->content,"extension","xml");
     2795              addToMap(tmpI->content,"mimeType","text/xml");
     2796              addToMap(tmpI->content,"encoding","UTF-8");
     2797              addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
     2798            }           
     2799            char *file_path=NULL;
     2800            if(gfile==NULL) {
     2801              map *ext=getMap(tmpI->content,"extension");
     2802              char file_ext[32];
     2803           
     2804              if( ext != NULL && ext->value != NULL) {
     2805                strncpy(file_ext, ext->value, 32);
     2806              }
     2807              else {
     2808                // Obtain default file extension (see mimetypes.h).           
     2809                // If the MIME type is not recognized, txt is used as the default extension
     2810                map* mtype=getMap(tmpI->content,"mimeType");
     2811                getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
     2812              }
     2813              if(file_name!=NULL)
     2814                free(file_name);
     2815              file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
     2816              sprintf(file_name,"ZOO_DATA_%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
     2817              itn++;
     2818              file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
     2819              sprintf(file_path,"%s/%s",tmp1->value,file_name);
     2820
     2821              FILE *ofile=fopen(file_path,"wb");
     2822              if(ofile==NULL){
     2823                char tmpMsg[1024];
     2824                sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
     2825                errorException(m,tmpMsg,"InternalError",NULL);
     2826                free(file_name);
     2827                free(file_path);
     2828                return;
     2829              }
     2830
     2831              toto=getMap(tmpI->content,"value");
     2832              if(toto==NULL){
     2833                char tmpMsg[1024];
     2834                sprintf(tmpMsg,_("No value found for the requested output %s."),tmpI->name);
     2835                errorException(m,tmpMsg,"InternalError",NULL);
     2836                fclose(ofile);
     2837                free(file_name);
     2838                free(file_path);
     2839                return;
     2840              }
     2841              if(strcasecmp(format,"BoundingBoxData")!=0){
     2842                map* size=getMap(tmpI->content,"size");
     2843                if(size!=NULL && toto!=NULL)
     2844                  fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
     2845                else
     2846                  if(toto!=NULL && toto->value!=NULL)
     2847                    fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
     2848              }else{
     2849                printBoundingBoxDocument(m,tmpI,ofile);
     2850              }
     2851              fclose(ofile);
     2852            }
     2853
     2854            map *tmp2=getMapFromMaps(m,"main","tmpUrl");
     2855            map *tmp3=getMapFromMaps(m,"main","serverAddress");
     2856            char *file_url=NULL;
     2857            if(strncasecmp(tmp2->value,"http://",7)==0 ||
     2858               strncasecmp(tmp2->value,"https://",8)==0){
     2859              file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
     2860              sprintf(file_url,"%s/%s",tmp2->value,file_name);
     2861            }else{
     2862              file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
     2863              sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
     2864            }
     2865            addToMap(tmpI->content,"Reference",file_url);
     2866            if(file_name!=NULL)
     2867              free(file_name);
     2868            if(file_url!=NULL)
     2869              free(file_url);
     2870            file_name=NULL;
    25052871          }
    2506           char *format=NULL;
    2507           if(in!=NULL && in->format!=NULL){
    2508             format=in->format;
    2509           }else
    2510             format=(char*)"LiteralData";
    2511           if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
    2512             addToMap(tmpI->content,"extension","xml");
    2513             addToMap(tmpI->content,"mimeType","text/xml");
    2514             addToMap(tmpI->content,"encoding","UTF-8");
    2515             addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
     2872#ifdef USE_MS
     2873        else{
     2874          if(testMap!=NULL){
     2875            map* nbFeatures;
     2876            setMapInMaps(m,"lenv","state","out");
     2877            setReferenceUrl(m,tmpI);
     2878            nbFeatures=getMap(tmpI->content,"nb_features");
     2879            geodatatype=getMap(tmpI->content,"geodatatype");
     2880            if((nbFeatures!=NULL && atoi(nbFeatures->value)==0) ||
     2881               (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0)){
     2882              error=1;
     2883              res=SERVICE_FAILED;
     2884            }
    25162885          }
    2517 
    2518           if(gfile==NULL) {
    2519             map *ext=getMap(tmpI->content,"extension");
    2520             char *file_path;
    2521             char file_ext[32];
    2522 
    2523             if( ext != NULL && ext->value != NULL) {
    2524               strncpy(file_ext, ext->value, 32);
    2525             }
    2526             else {
    2527               // Obtain default file extension (see mimetypes.h).             
    2528               // If the MIME type is not recognized, txt is used as the default extension
    2529               map* mtype=getMap(tmpI->content,"mimeType");
    2530               getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
    2531             }
    2532 
    2533             file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
    2534             sprintf(file_name,"%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
    2535             itn++;
    2536             file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
    2537             sprintf(file_path,"%s/%s",tmp1->value,file_name);
    2538 
    2539             FILE *ofile=fopen(file_path,"wb");
    2540             if(ofile==NULL){
    2541               char tmpMsg[1024];
    2542               sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
    2543               errorException(m,tmpMsg,"InternalError",NULL);
    2544               free(file_name);
    2545               free(file_path);
    2546               return;
    2547             }
    2548             free(file_path);
    2549 
    2550             toto=getMap(tmpI->content,"value");
    2551             if(strcasecmp(format,"BoundingBoxData")!=0){
    2552               map* size=getMap(tmpI->content,"size");
    2553               if(size!=NULL && toto!=NULL)
    2554                 fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
    2555               else
    2556                 if(toto!=NULL && toto->value!=NULL)
    2557                   fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
    2558             }else{
    2559               printBoundingBoxDocument(m,tmpI,ofile);
    2560             }
    2561             fclose(ofile);
    2562 
    2563           }
    2564 
    2565           map *tmp2=getMapFromMaps(m,"main","tmpUrl");
    2566           map *tmp3=getMapFromMaps(m,"main","serverAddress");
    2567           char *file_url;
    2568           if(strncasecmp(tmp2->value,"http://",7)==0 ||
    2569              strncasecmp(tmp2->value,"https://",8)==0){
    2570             file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
    2571             sprintf(file_url,"%s/%s",tmp2->value,file_name);
    2572           }else{
    2573             file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
    2574             sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
    2575           }
    2576           addToMap(tmpI->content,"Reference",file_url);
    2577           free(file_name);
    2578           free(file_url);
    2579          
    2580         }
    2581 #ifdef USE_MS
    2582       else{
    2583         if(testMap!=NULL){
    2584           setReferenceUrl(m,tmpI);
    2585         }
    2586       }
    2587 #endif
     2886        }
     2887#endif 
     2888      if(file_name!=NULL){
     2889        free(file_name);
     2890        file_name=NULL;
     2891      }
    25882892      tmpI=tmpI->next;
    25892893    }
     
    25932897      if(tmpI!=NULL)
    25942898        goto NESTED0;
    2595     }
     2899    }   
    25962900#ifdef DEBUG
    25972901    fprintf(stderr,"SERVICE : %s\n",s->name);
    25982902    dumpMaps(m);
     2903#endif 
     2904    if(error<0)
     2905      printProcessResponse(m,request_inputs1,cpid,
     2906                           s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
     2907                           request_inputs,
     2908                           request_outputs);
     2909    else{
     2910      maps* tmpMaps=getMaps(m,"lenv");
     2911#ifdef USE_CALLBACK
     2912      invokeCallback(m,NULL,NULL,7,0);
    25992913#endif
    2600     printProcessResponse(m,request_inputs1,cpid,
    2601                          s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
    2602                          request_inputs,
    2603                          request_outputs);
     2914      printExceptionReportResponse(m,tmpMaps->content);
     2915    }
    26042916  }
    26052917  else{
  • trunk/zoo-project/zoo-kernel/response_print.h

    r785 r917  
    3939#include <libintl.h>
    4040#include <locale.h>
     41
    4142/**
    4243 * ZOO-Kernel internal messages translation function
     
    6364#include <sys/stat.h>
    6465#include <sys/types.h>
    65 #include "cgic.h"
    6666#ifndef WIN32
    6767#include <sys/ipc.h>
     
    8080#endif
    8181#ifndef WIN32
    82 #include <xlocale.h>
     82//#include <locale.h>
     83#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)
    8384#endif
    8485#include "ulinet.h"
     
    9495#include <libxml/parser.h>
    9596#include <libxml/xpath.h>
     97
     98#include "cgic.h"
    9699
    97100#ifdef __cplusplus
     
    209212  xmlNodePtr printWPSHeader(xmlDocPtr,maps*,const char*,const char*,const char*,int);
    210213  xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr,maps*,const char*);
    211   void printGetCapabilitiesForProcess(registry*,maps*,xmlNodePtr,service*);
    212   void printDescribeProcessForProcess(registry*,maps*,xmlNodePtr,service*);
    213   void printFullDescription(int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int);
     214  void printGetCapabilitiesForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
     215  void printDescribeProcessForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
     216  void printFullDescription(xmlDocPtr,int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int,int,const map*);
    214217  void printDocument(maps*,xmlDocPtr,int);
    215218  void printDescription(xmlNodePtr,xmlNsPtr,const char*,map*,int);
     
    220223  void printOutputDefinitions(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,const char*);
    221224  void printStatusInfo(maps*,map*,char*);
     225  void addAdditionalParameters(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
     226  void addMetadata(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
    222227
    223228  void outputResponse(service*,maps*,maps*,map*,int,maps*,int);
  • trunk/zoo-project/zoo-kernel/server_internal.c

    r889 r917  
    2626#include "service_internal.h"
    2727#include "response_print.h"
     28//#include "service_callback.h"
    2829#include "mimetypes.h"
    2930#ifndef WIN32
     
    366367 */
    367368void readGeneratedFile(maps* m,map* content,char* filename){
     369  char rsize[1024];
    368370  FILE * file=fopen(filename,"rb");
    369371  if(file==NULL){
    370     fprintf(stderr,"Failed to open file %s for reading purpose.\n",filename);
    371372    setMapInMaps(m,"lenv","message","Unable to read produced file. Please try again later");
    372373    return ;
    373374  }
    374375  fseek(file, 0, SEEK_END);
    375   long count = ftell(file);
     376  zStatStruct f_status;
     377  int s=zStat(filename, &f_status);
     378  sprintf(rsize,"%lld",f_status.st_size);
    376379  rewind(file);
    377   struct stat file_status;
    378   stat(filename, &file_status);
    379   map* tmpMap1=getMap(content,"value");
    380   if(tmpMap1==NULL){
    381     addToMap(content,"value","");
    382     tmpMap1=getMap(content,"value");
    383   }
    384   free(tmpMap1->value);
    385   tmpMap1->value=(char*) malloc((count+1)*sizeof(char)); 
    386   fread(tmpMap1->value,1,count,file);
    387   tmpMap1->value[count]=0;
    388   fclose(file);
    389   char rsize[1000];
    390   sprintf(rsize,"%ld",count);
     380  if(getMap(content,"storage")==NULL){
     381    map* memUse=getMapFromMaps(m,"main","memory");
     382    if(memUse==NULL || strncmp(memUse->value,"load",4)==0){
     383      map* tmpMap1=getMap(content,"value");
     384      if(tmpMap1==NULL){
     385        addToMap(content,"value","");
     386        tmpMap1=getMap(content,"value");
     387      }
     388      free(tmpMap1->value);
     389      tmpMap1->value=(char*) malloc((f_status.st_size+1)*sizeof(char));
     390      if(tmpMap1->value==NULL){
     391        setMapInMaps(m,"lenv","message","Unable to allocate the memory required to read the produced file.");
     392      }
     393      fread(&tmpMap1->value,1,f_status.st_size,file);
     394      tmpMap1->value[f_status.st_size]=0;
     395    }
     396  }
     397  fclose(file); 
    391398  addToMap(content,"size",rsize);
    392399}
     
    423430void dumpMapsValuesToFiles(maps** main_conf,maps** in){
    424431  map* tmpPath=getMapFromMaps(*main_conf,"main","tmpPath");
     432  map* tmpUrl=getMapFromMaps(*main_conf,"main","tmpUrl");
    425433  map* tmpSid=getMapFromMaps(*main_conf,"lenv","usid");
    426434  maps* inputs=*in;
     
    445453          if(cSize!=NULL){
    446454            length=atoi(cSize->value);
    447           }
     455          }else
     456            length=strlen(cValue->value);
    448457          writeFile(val,cValue->value,length);
    449458          setMapArray(cMap,"cache_file",k,val);
     459          free(val);
     460          val=(char*)malloc((strlen(tmpUrl->value)+strlen(inputs->name)+strlen(tmpSid->value)+strlen(file_ext)+16)*sizeof(char));
     461          sprintf(val,"%s/Input_%s_%s_%d.%s",tmpUrl->value,inputs->name,tmpSid->value,k,file_ext);
     462          setMapArray(cMap,"cache_url",k,val);
     463          setMapArray(cMap,"byValue",k,"true");
    450464          free(val);
    451465        }
     
    461475        if(cSize!=NULL){
    462476          length=atoi(cSize->value);
    463         }
     477        }else
     478          length=strlen(cValue->value);
    464479        writeFile(val,cValue->value,length);
    465480        addToMap(cMap,"cache_file",val);
     481        free(val);
     482        val=(char*)malloc((strlen(tmpUrl->value)+strlen(inputs->name)+strlen(tmpSid->value)+strlen(file_ext)+16)*sizeof(char));
     483        sprintf(val,"%s/Input_%s_%s_%d.%s",tmpUrl->value,inputs->name,tmpSid->value,0,file_ext);
     484        addToMap(cMap,"cache_url",val);
     485        addToMap(cMap,"byValue",val);
    466486        free(val);
    467487      }
     
    638658        }
    639659        if(res==NULL){
     660          map* tmpMaxO0=getMap(tmpInputs->content,"useMapserver");
     661          if(tmpMaxO0!=NULL){
     662            if(tmpMaps2->content==NULL)
     663              tmpMaps2->content=createMap("useMapserver",tmpMaxO0->value);
     664            else
     665              addToMap(tmpMaps2->content,"useMapserver",tmpMaxO0->value);
     666          }
    640667          map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
    641668          if(tmpMaxO!=NULL){
     
    701728      }
    702729    }
    703     else {
     730    else /*toto*/{
    704731      iotype* tmpIoType=NULL;
    705732      if(tmpMaps->content!=NULL){
     
    711738           * content map.
    712739           */
    713           map* tmpMap1=getMap(tmpInputs->content,"minOccurs");
    714           if(tmpMap1!=NULL){
    715             if(tmpMaps->content==NULL)
    716               tmpMaps->content=createMap("minOccurs",tmpMap1->value);
    717             else
    718               addToMap(tmpMaps->content,"minOccurs",tmpMap1->value);
    719           }
    720           map* tmpMaxO=getMap(tmpInputs->content,"maxOccurs");
    721           if(tmpMaxO!=NULL){
    722             if(tmpMaps->content==NULL)
    723               tmpMaps->content=createMap("maxOccurs",tmpMaxO->value);
    724             else
    725               addToMap(tmpMaps->content,"maxOccurs",tmpMaxO->value);
    726           }
    727           map* tmpMaxMB=getMap(tmpInputs->content,"maximumMegabytes");
    728           if(tmpMaxMB!=NULL){
    729             if(tmpMaps->content==NULL)
    730               tmpMaps->content=createMap("maximumMegabytes",tmpMaxMB->value);
    731             else
    732               addToMap(tmpMaps->content,"maximumMegabytes",tmpMaxMB->value);
     740          char* keys[4]={
     741            "minOccurs",
     742            "maxOccurs",
     743            "maximumMegabytes",
     744            "useMapserver"
     745          };
     746          int i=0;
     747          for(i=0;i<4;i++){
     748            map* tmpMap1=getMap(tmpInputs->content,keys[i]);
     749            if(tmpMap1!=NULL){
     750              addToMap(tmpMaps->content,keys[i],tmpMap1->value);
     751            }
    733752          }
    734753          /**
     
    743762              map* tmpV=getMap(tmpI->content,"value");
    744763              if(tmpV!=NULL){
    745                 char *tmpVS=strdup(tmpV->value);
     764                char *tmpVS=zStrdup(tmpV->value);
    746765                map* tmp=parseBoundingBox(tmpVS);
    747766                free(tmpVS);
     
    780799              map* length=getMap(tmpMaps->content,"length");
    781800              int i;
    782               char *tcn=strdup(tmpContent->name);
     801              char *tcn=zStrdup(tmpContent->name);
    783802              for(i=1;i<atoi(length->value);i++){
    784803#ifdef DEBUG
     
    806825         */
    807826        if(tmpIoType!=NULL){
    808           map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
    809           if(tmpCheck!=NULL){
     827          map* tmpCheck=getMap(tmpIoType->content,"useMapserver");
     828          if(tmpCheck!=NULL && strncasecmp(tmpCheck->value,"true",4)==0){
    810829            // Get the default value
     830            addToMap(tmpMaps->content,"useMapserver","true");
    811831            tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
    812832            tmpCheck=getMap(tmpMaps->content,"mimeType");
     
    834854        addToMap(tmpMaps->content,"inRequest","true");
    835855      elements* tmpElements=getElements(in,tmpMaps->name);
    836       if(tmpElements!=NULL && tmpElements->child!=NULL){
     856      if(/*tmpMaps->child!=NULL && */tmpElements!=NULL && tmpElements->child!=NULL){
    837857        char *res=addDefaultValues(&tmpMaps->child,tmpElements->child,m,type,err);
    838858        if(strlen(res)>0){
    839859          return res;
    840860        }
     861      }
     862    }
     863    if(tmpInputs->child!=NULL){
     864      tmpInputss=tmpInputs->next;
     865      tmpInputs=tmpInputs->child;
     866      if(tmpMaps!=NULL){
     867        out1=tmpMaps->child;
     868        out1s=tmpMaps;
    841869      }
    842870    }
     
    9721000    if(isRunning(conf,pid)>0){         
    9731001      if(strncasecmp(req,"GetResult",strlen(req))==0){
    974         errorException (conf, _("The result for the requested JobID has not yet been generated. "),
     1002        errorException (conf, _("The result for the requested JobID has not yet been generated. The service is currently running."),
    9751003                        "ResultNotReady", pid);
    9761004        return;
     
    9811009          char* tmpStr=_getStatus(conf,pid);
    9821010          if(tmpStr!=NULL && strncmp(tmpStr,"-1",2)!=0){
    983             char *tmpStr1=strdup(tmpStr);
    984             char *tmpStr0=strdup(strstr(tmpStr,"|")+1);
     1011            char *tmpStr1=zStrdup(tmpStr);
     1012            char *tmpStr0=zStrdup(strstr(tmpStr,"|")+1);
    9851013            free(tmpStr);
    9861014            tmpStr1[strlen(tmpStr1)-strlen(tmpStr0)-1]='\0';
     
    10001028          printf("%s",result);
    10011029          fflush(stdout);
     1030          free(sid);
    10021031          freeMap(&statusInfo);
    10031032          free(statusInfo);
     1033          free(result);
    10041034          return;
    10051035        }else{
    1006           errorException (conf, _("The result for the requested JobID has not yet been generated. "),
     1036          errorException (conf, _("The result for the requested JobID has not yet been generated. The service ends but it still needs to produce the outputs."),
    10071037                          "ResultNotReady", pid);
    10081038          freeMap(&statusInfo);
     
    10151045          char* tmpStr=_getStatus(conf,pid);
    10161046          if(tmpStr!=NULL && strncmp(tmpStr,"-1",2)!=0){
    1017             char *tmpStr1=strdup(tmpStr);
    1018             char *tmpStr0=strdup(strstr(tmpStr,"|")+1);
     1047            char *tmpStr1=zStrdup(tmpStr);
     1048            char *tmpStr0=zStrdup(strstr(tmpStr,"|")+1);
    10191049            free(tmpStr);
    10201050            tmpStr1[strlen(tmpStr1)-strlen(tmpStr0)-1]='\0';
     
    10261056        }
    10271057    }
     1058    free(sid);
    10281059    printStatusInfo(conf,statusInfo,req);
    10291060    freeMap(&statusInfo);
     
    10831114        if(strstr(dp->d_name,pid)!=0){
    10841115          sprintf(fileName,"%s/%s",r_inputs->value,dp->d_name);
    1085           if(unlink(fileName)!=0){
     1116          if(zUnlink(fileName)!=0){
    10861117            errorException (conf,
    10871118                            _("The job cannot be removed, a file cannot be removed"),
     
    10951126    removeService(conf,pid);
    10961127#endif
     1128    /* No need to call 7_1 when an execution is dismissed.
     1129      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
     1130      invokeCallback(conf,NULL,NULL,7,1);
     1131      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
     1132    */
    10971133    map* statusInfo=createMap("JobID",pid);
    10981134    addToMap(statusInfo,"Status","Dismissed");
  • trunk/zoo-project/zoo-kernel/service.c

    r889 r917  
    22 * Author : Gérald FENOY
    33 *
    4  * Copyright (c) 2015 GeoLabs SARL
     4 * Copyright (c) 2015-2019 GeoLabs SARL
    55 *
    66 * Permission is hereby granted, free of charge, to any person obtaining a copy
     
    2828#include <ctime>
    2929#include <chrono>
     30#ifdef WIN32
    3031#include <process.h>
     32#endif
    3133
    3234#if defined(_MSC_VER) && _MSC_VER < 1800
     
    102104    fprintf(stderr," * CONTENT [%s] \n",tmp->name);
    103105    dumpMap(tmp->content);
    104     fprintf(stderr," * CHILD [%s] \n",tmp->name);
    105     dumpMaps(tmp->child);
     106    if(tmp->child!=NULL){
     107      fprintf(stderr," * CHILD [%s] \n",tmp->name);
     108      dumpMaps(tmp->child);
     109      fprintf(stderr," * /CHILD [%s] \n",tmp->name);
     110    }
    106111    tmp=tmp->next;
    107112  }
     
    125130    fflush(file);
    126131    tmp=tmp->next;
    127     cnt++;
    128132    if(limit>=0 && cnt==limit)
    129133      tmp=NULL;
     134    cnt++;
    130135  }
    131136  fflush(file);
     
    144149  fflush(file);
    145150  fclose(file);
     151}
     152
     153/**
     154 * Create a new iotype*
     155 *
     156 * @return a pointer to the allocated iotype
     157 */
     158iotype* createIoType(){
     159  iotype* io=(iotype*)malloc(IOTYPE_SIZE);
     160  io->content=NULL;
     161  io->next=NULL;
     162  return io;
    146163}
    147164
     
    179196 * Count number of map in a map
    180197 *
    181  * @param m the maps to count
     198 * @param m the map to count
    182199 * @return number of map in a map
    183200 */
    184201int count(map* m){
    185202  map* tmp=m;
     203  int c=0;
     204  while(tmp!=NULL){
     205    c++;
     206    tmp=tmp->next;
     207  }
     208  return c;
     209}
     210
     211/**
     212 * Count number of maps in a maps
     213 *
     214 * @param m the maps to count
     215 * @return number of maps in a maps
     216 */
     217int maps_length(maps* m){
     218  maps* tmp=m;
    186219  int c=0;
    187220  while(tmp!=NULL){
     
    401434    if(tmp->metadata!=NULL)
    402435      free(tmp->metadata);
     436    freeMap(&tmp->additional_parameters);
     437    if(tmp->additional_parameters!=NULL)
     438      free(tmp->additional_parameters);
    403439    if(tmp->format!=NULL)
    404440      free(tmp->format);
     441    freeElements(&tmp->child);
    405442    if(tmp->child!=NULL){
    406       freeElements(&tmp->child);
    407443      free(tmp->child);
    408444    }
    409     freeIOType(&tmp->defaults);
    410     if(tmp->defaults!=NULL)
     445    if(tmp->defaults!=NULL){
     446      freeIOType(&tmp->defaults);
    411447      free(tmp->defaults);
    412     freeIOType(&tmp->supported);
     448    }
    413449    if(tmp->supported!=NULL){
     450      freeIOType(&tmp->supported);
    414451      free(tmp->supported);
    415452    }
    416     freeElements(&tmp->next);
    417     if(tmp->next!=NULL)
     453    if(tmp->next!=NULL){
     454      freeElements(&tmp->next);
    418455      free(tmp->next);
    419   }
     456    }
     457  }
     458}
     459
     460
     461/**
     462 * Allocate memory for a service.
     463 * Require to call free after calling this function.
     464 *
     465 * @return the service
     466 */
     467service* createService(){
     468  service *s1 = (service *) malloc (SERVICE_SIZE);
     469  s1->name=NULL;
     470  s1->content=NULL;
     471  s1->metadata=NULL;
     472  s1->additional_parameters=NULL;
     473  s1->inputs=NULL;
     474  s1->outputs=NULL;
     475  return s1;
    420476}
    421477
    422478/**
    423479 * Free allocated memory of a service.
    424  * Require to call free on e after calling this function.
     480 * Require to be invoked for every createService call.
    425481 *
    426482 * @param s the service to free
     
    437493    if(tmp->metadata!=NULL)
    438494      free(tmp->metadata);
     495    freeMap(&tmp->additional_parameters);
     496    if(tmp->additional_parameters!=NULL)
     497      free(tmp->additional_parameters);
    439498    freeElements(&tmp->inputs);
    440499    if(tmp->inputs!=NULL)
     
    454513 */
    455514void addToMap(map* m,const char* n,const char* v){
    456   if (m != NULL) { // knut: add NULL-pointer check
    457     if(hasKey(m,n)==false){
    458       map* _cursor=m;
    459       while(_cursor->next!=NULL){
    460         _cursor=_cursor->next;
    461       }
    462       _cursor->next=createMap(n,v);
    463     }
    464     else{
    465       map *tmp=getMap(m,n);
    466       if(tmp->value!=NULL)
    467         free(tmp->value);
    468       tmp->value=zStrdup(v);
    469     }
    470   }
     515    if (m != NULL) { // knut: add NULL-pointer check
     516        if (hasKey(m, n) == false) {
     517            map* _cursor = m;
     518            while (_cursor->next != NULL) {
     519                _cursor = _cursor->next;
     520            }
     521            _cursor->next = createMap(n, v);
     522        }
     523        else {
     524            map *tmp = getMap(m, n);
     525            if (tmp->value != NULL)
     526                free(tmp->value);
     527            tmp->value = zStrdup(v);
     528        }
     529    }
    471530}
    472531
     
    506565 */
    507566map* addToMapWithSize(map* m,const char* n,const char* v,int size){
     567  char sin[128];
     568  char sname[10]="size";
     569  map *tmp;
    508570  if(hasKey(m,n)==false){
    509571    map* _cursor=m;
     
    514576    }
    515577  }
    516   char sname[10]="size";
    517578  if(strlen(n)>5)
    518579    sprintf(sname,"size_%s",n+6);
    519   map *tmp=getMap(m,n);
     580  tmp=getMap(m,n);
    520581  if(tmp->value!=NULL)
    521582    free(tmp->value);
     
    524585    memmove(tmp->value,v,size*sizeof(char));
    525586  tmp->value[size]=0;
    526   char sin[128];
    527587  sprintf(sin,"%d",size);
    528588  addToMap(m,sname,sin);
     
    545605    }
    546606    else{
    547 #ifdef DEBUG
    548       fprintf(stderr,"_CURSOR\n");
    549       dumpMap(_cursor);
    550 #endif
    551       while(_cursor->next!=NULL)
    552         _cursor=_cursor->next;
    553607      map* tmp1=getMap(*mo,tmp->name);
    554608      if(tmp1==NULL){
     609        while(_cursor->next!=NULL)
     610          _cursor=_cursor->next;
    555611        _cursor->next=createMap(tmp->name,tmp->value);
    556612      }
     
    561617    _cursor=*mo;
    562618    tmp=tmp->next;
    563 #ifdef DEBUG
    564     fprintf(stderr,"MO\n");
    565     dumpMap(*mo);
    566 #endif
    567619  }
    568620}
     
    678730  map* size=getMap(in,"size");
    679731  map *lout=*out;
     732  map *tmpVin,*tmpVout;
    680733  if(size!=NULL && pos>0){
    681734    char tmp[11];
     
    683736    size=getMap(in,tmp);
    684737    sprintf(tmp,"value_%d",pos);
    685     map* tmpVin=getMap(in,tmp);
    686     map* tmpVout=getMap(lout,tmp);
     738    tmpVin=getMap(in,tmp);
     739    tmpVout=getMap(lout,tmp);
    687740    free(tmpVout->value);
    688741    tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
     
    691744  }else{
    692745    if(size!=NULL){
    693       map* tmpVin=getMap(in,"value");
    694       map* tmpVout=getMap(lout,"value");
     746      tmpVin=getMap(in,"value");
     747      tmpVout=getMap(lout,"value");
    695748      free(tmpVout->value);
    696749      tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
     
    712765  map* size=getMap(in,"size");
    713766  map* length=getMap(in,"length");
     767  map* toload=getMap(in,"to_load");
     768  if(toload!=NULL && strcasecmp(toload->value,"false")==0){
     769#ifdef DEBUG
     770    fprintf(stderr,"NO LOAD %s %d \n",__FILE__,__LINE__);
     771#endif
     772    return ;
     773  }
    714774  if(length!=NULL){
    715775    int len=atoi(length->value);
     
    734794  maps* res=NULL;
    735795  if(_cursor!=NULL){
     796    map* mc=_cursor->content;
     797    maps* mcs=_cursor->child;
    736798    res=createMaps(_cursor->name);
    737     map* mc=_cursor->content;
    738799    if(mc!=NULL){
    739800      addMapToMap(&res->content,mc);
    740801      loadMapBinaries(&res->content,mc);
    741802    }
    742     maps* mcs=_cursor->child;
    743803    if(mcs!=NULL){
    744804      res->child=dupMaps(&mcs);
     
    764824    }
    765825    else{
     826      maps* tmp1=getMaps(*mo,tmp->name);
    766827      while(_cursor->next!=NULL)
    767828        _cursor=_cursor->next;
    768       maps* tmp1=getMaps(*mo,tmp->name);
    769829      if(tmp1==NULL){
    770830        _cursor->next=dupMaps(&tmp);
     
    797857map* getMapArray(map* m,const char* key,int index){
    798858  char tmp[1024];
     859  map* tmpMap;
    799860  if(index>0)
    800861    sprintf(tmp,"%s_%d",key,index);
     
    804865  fprintf(stderr,"** KEY %s\n",tmp);
    805866#endif
    806   map* tmpMap=getMap(m,tmp);
     867  tmpMap=getMap(m,tmp);
    807868#ifdef DEBUG
    808869  if(tmpMap!=NULL)
     
    823884void setMapArray(map* m,const char* key,int index,const char* value){
    824885  char tmp[1024];
     886  map* tmpSize;
    825887  if(index>0){
     888    map* len=getMap(m,"length");
    826889    sprintf(tmp,"%s_%d",key,index);
    827     map* len=getMap(m,"length");
    828890    if((len!=NULL && atoi(len->value)<index+1) || len==NULL){
    829891      char tmp0[5];
     
    832894    }
    833895  }
    834   else
     896  else{
    835897    sprintf(tmp,"%s",key);
    836   map* tmpSize=getMapArray(m,"size",index);
     898    addToMap(m,"length","1");
     899  }
     900  tmpSize=getMapArray(m,"size",index);
    837901  if(tmpSize!=NULL && strncasecmp(key,"value",5)==0){
     902    map* ptr=getMapOrFill(&m,tmp,(char *)"");
    838903#ifdef DEBUG
    839904    fprintf(stderr,"%s\n",tmpSize->value);
    840905#endif
    841     map* ptr=getMapOrFill(&m,tmp,(char *)"");
    842906    free(ptr->value);
    843907    ptr->value=(char*)malloc((atoi(tmpSize->value)+1)*sizeof(char));
     
    846910  else
    847911    addToMap(m,tmp,value);
     912}
     913
     914/**
     915 * Add a key and an integer value to an existing map array.
     916 *
     917 * @param m the map to add the KVP
     918 * @param n the key to add
     919 * @param index the index of the MapArray
     920 * @param v the corresponding value to add
     921 */
     922void addIntToMapArray(map* m,const char* n,int index,const int v){
     923  char svalue[10];
     924  sprintf(svalue,"%d",v);
     925  setMapArray(m,n,index,svalue);
    848926}
    849927
     
    881959  maps* tmp=mi;   
    882960  maps* _cursor=getMaps(*mo,tmp->name);
    883 
    884   if(_cursor==NULL)
    885     return -1;
    886 
    887   map* tmpLength=getMap(_cursor->content,"length");
    888961  char tmpLen[10];
    889962  int len=1;
    890   if(tmpLength!=NULL){
    891     len=atoi(tmpLength->value);
    892   }
    893 
    894963  char *tmpV[14]={
    895964    (char*)"size",
     
    906975    (char*)"isCached",
    907976    (char*)"LowerCorner",
    908     (char*)"UpperCorner"   
     977    (char*)"UpperCorner"
    909978  };
     979  int i=0;
     980  map* tmpLength;
     981 
     982  if(_cursor==NULL)
     983    return -1;
     984
     985  tmpLength=getMap(_cursor->content,"length");
     986  if(tmpLength!=NULL){
     987    len=atoi(tmpLength->value);
     988  }
     989
    910990  sprintf(tmpLen,"%d",len+1);
    911991  addToMap(_cursor->content,"length",tmpLen);
    912   int i=0;
    913992  for(i=0;i<14;i++){
    914993    map* tmpVI=getMap(tmp->content,tmpV[i]);
     
    9671046  res->content=NULL;
    9681047  res->metadata=NULL;
     1048  res->additional_parameters=NULL; 
    9691049  res->format=NULL;
    9701050  res->defaults=NULL;
     
    9811061 * @return a pointer to the allocated elements
    9821062 */
    983 elements* createElements(char* name){
     1063elements* createElements(const char* name){
    9841064  elements* res=(elements*)malloc(ELEMENTS_SIZE);
    9851065  res->name=zStrdup(name);
    9861066  res->content=NULL;
    9871067  res->metadata=NULL;
     1068  res->additional_parameters=NULL;
    9881069  res->format=NULL;
    9891070  res->defaults=NULL;
     
    10201101  elements* tmp=e;
    10211102  while(tmp!=NULL){
     1103    iotype* tmpio=tmp->defaults;
     1104    int ioc=0;
    10221105    fprintf(stderr,"ELEMENT [%s]\n",tmp->name);
    10231106    fprintf(stderr," > CONTENT [%s]\n",tmp->name);
     
    10251108    fprintf(stderr," > METADATA [%s]\n",tmp->name);
    10261109    dumpMap(tmp->metadata);
     1110    fprintf(stderr," > ADDITIONAL PARAMETERS [%s]\n",tmp->name);
     1111    dumpMap(tmp->additional_parameters);
    10271112    fprintf(stderr," > FORMAT [%s]\n",tmp->format);
    1028     iotype* tmpio=tmp->defaults;
    1029     int ioc=0;
    10301113    while(tmpio!=NULL){
    10311114      fprintf(stderr," > DEFAULTS [%s] (%i)\n",tmp->name,ioc);
     
    10601143  int i;
    10611144  while(tmp!=NULL){
     1145    map* mcurs=tmp->content;
     1146    int ioc=0;
     1147    iotype* tmpio;
    10621148    for(i=0;i<2+(4*level);i++)
    10631149      fprintf(stderr," ");
    10641150    fprintf(stderr,"%s:\n",tmp->name);
    1065     map* mcurs=tmp->content;
    10661151    while(mcurs!=NULL){
    10671152      for(i=0;i<4+(4*level);i++)
     
    10911176        dumpElementsAsYAML(tmp->child,level+1);
    10921177    }
    1093     iotype* tmpio=tmp->defaults;
    1094     int ioc=0;
     1178    tmpio=tmp->defaults;
    10951179    while(tmpio!=NULL){
    10961180      for(i=0;i<6+(4*level);i++)
     
    11421226  elements* cursor=e;
    11431227  elements* tmp=NULL;
    1144   if(cursor!=NULL){
     1228  if(cursor!=NULL && cursor->name!=NULL){
    11451229#ifdef DEBUG
    11461230    fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
     
    11491233#endif
    11501234    tmp=(elements*)malloc(ELEMENTS_SIZE);
    1151     tmp->name=zStrdup(e->name);
     1235    tmp->name=zStrdup(cursor->name);
    11521236    tmp->content=NULL;
    1153     addMapToMap(&tmp->content,e->content);
     1237    addMapToMap(&tmp->content,cursor->content);
    11541238    tmp->metadata=NULL;
    1155     addMapToMap(&tmp->metadata,e->metadata);
    1156     if(e->format!=NULL)
    1157       tmp->format=zStrdup(e->format);
     1239    addMapToMap(&tmp->metadata,cursor->metadata);
     1240    tmp->additional_parameters=NULL;
     1241    addMapToMap(&tmp->additional_parameters,cursor->additional_parameters);
     1242    if(cursor->format!=NULL)
     1243      tmp->format=zStrdup(cursor->format);
    11581244    else
    11591245      tmp->format=NULL;
    1160     if(e->defaults!=NULL){
     1246    if(cursor->defaults!=NULL){
    11611247      tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
    11621248      tmp->defaults->content=NULL;
    1163       addMapToMap(&tmp->defaults->content,e->defaults->content);
     1249      addMapToMap(&tmp->defaults->content,cursor->defaults->content);
    11641250      tmp->defaults->next=NULL;
    11651251#ifdef DEBUG
     
    11691255    }else
    11701256      tmp->defaults=NULL;
    1171     if(e->supported!=NULL){
     1257    if(cursor->supported!=NULL && cursor->supported->content!=NULL){
     1258      iotype *tmp2=cursor->supported->next;
    11721259      tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
    11731260      tmp->supported->content=NULL;
    1174       addMapToMap(&tmp->supported->content,e->supported->content);
     1261      addMapToMap(&tmp->supported->content,cursor->supported->content);
    11751262      tmp->supported->next=NULL;
    1176       iotype *tmp2=e->supported->next;
    1177       while(tmp2!=NULL){
     1263            while(tmp2!=NULL){
    11781264        addMapToIoType(&tmp->supported,tmp2->content);
    11791265#ifdef DEBUG
     
    11901276    else
    11911277      tmp->child=NULL;
    1192     tmp->next=dupElements(cursor->next);
     1278    if(cursor->next!=NULL)
     1279      tmp->next=dupElements(cursor->next);
     1280    else
     1281      tmp->next=NULL;
    11931282  }
    11941283  return tmp;
     
    12051294  elements* tmp=e;
    12061295  if(*m==NULL){
    1207     *m=dupElements(tmp);
     1296    (*m)=dupElements(tmp);
    12081297  }else{
    12091298    addToElements(&(*m)->next,tmp);
     
    12371326    fprintf(stderr,"CONTENT MAP\n");
    12381327    dumpMap(s->content);
    1239     fprintf(stderr,"CONTENT METADATA\n");
     1328    if(s->metadata!=NULL)
     1329      fprintf(stderr,"CONTENT METADATA\n");
    12401330    dumpMap(s->metadata);
     1331    if(s->additional_parameters!=NULL)
     1332      fprintf(stderr,"CONTENT AdditionalParameters\n");
     1333    dumpMap(s->additional_parameters);
    12411334  }
    12421335  if(s->inputs!=NULL){
     
    12961389  res->metadata=NULL;
    12971390  addMapToMap(&res->metadata,s->metadata);
     1391  res->additional_parameters=NULL;
     1392  addMapToMap(&res->additional_parameters,s->additional_parameters);
    12981393  res->inputs=dupElements(s->inputs);
    12991394  res->outputs=dupElements(s->outputs);
     
    13091404  registry* p=r;
    13101405  while(p!=NULL){
     1406    services* s=p->content;
    13111407    fprintf(stderr,"%s \n",p->name);
    1312     services* s=p->content;
    13131408    s=p->content;
    13141409    while(s!=NULL){
     
    15091604 */
    15101605void inheritance(registry *r,service** s){
     1606  service* ls=*s;
     1607  map *profile,*level;
    15111608  if(r==NULL)
    15121609    return;
    1513   service* ls=*s;
    1514   if(ls->content==NULL)
     1610  if(ls==NULL || ls->content==NULL)
    15151611    return;
    1516   map* profile=getMap(ls->content,"extend");
    1517   map* level=getMap(ls->content,"level");
     1612  profile=getMap(ls->content,"extend");
     1613  level=getMap(ls->content,"level");
    15181614  if(profile!=NULL&&level!=NULL){
    15191615    service* s1;
     
    15501646  memset(tmp,0,1024*10*10);
    15511647  while(tm!=NULL){
     1648    map* tc=tm->content;
    15521649    if(i>=10)
    15531650      break;
     
    15561653    strcpy(tmp[i][j],tm->name);
    15571654    j++;
    1558     map* tc=tm->content;
    15591655    while(tc!=NULL){
    15601656      if(j>=30)
     
    16091705 * @return true if map has a value or false if value is missing/empty/NULL
    16101706 */
    1611 bool nonempty( map* map ) {
    1612     return ( map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0 );
    1613 }
    1614 
    1615 /**
    1616  * Verify that a particular map value exists in a maps 
     1707bool nonempty(map* map) {
     1708        return (map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0);
     1709}
     1710
     1711/**
     1712 * Verify that a particular map value exists in a maps
    16171713 * data structure, and obtain that value
    16181714 *
     
    16201716 * @param node name of maps node to search
    16211717 * @param key name of map node to find
    1622  * @param address to the map* if it exists, otherwise NULL
     1718 * @param kvp address to the map* if it exists, otherwise NULL
    16231719 * @return true if map has a value or false if value is missing/NULL
    1624  */
    1625 bool hasvalue( maps* source, const char* node, const char* key, map** kvp ) {
    1626     *kvp = getMapFromMaps(source, node, key);
    1627     return ( *kvp != NULL && (*kvp)->value != NULL &&
    1628              strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0 );
     1720 *
     1721 * @note The map assigned to kvp is owned by the source maps
     1722 */
     1723bool hasvalue(maps* source, const char* node, const char* key, map** kvp) {
     1724        *kvp = getMapFromMaps(source, node, key);
     1725        return (*kvp != NULL && (*kvp)->value != NULL &&
     1726                strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0);
    16291727}
    16301728
     
    16331731 *
    16341732 * @param conf reference to configuration maps
    1635  * @param service name of service 
     1733 * @param service name of service
    16361734 * @param exc WPSException code
    16371735 * @param message exception text (default: exception text in WPS specification)
    16381736 */
    1639 void setErrorMessage( maps*& conf, const char* service, WPSException exc, const char* message ) {
    1640  
    1641   if (message == NULL) {
    1642     message = WPSExceptionText[exc];
    1643   }
    1644 
    1645         size_t len = strlen( service ) + strlen(": ") + strlen( message ) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
    1646         char* msg = (char*) malloc( len * sizeof(char) );
     1737void setErrorMessage(maps*& conf, const char* service, WPSException exc, const char* message) {
     1738
     1739        if (message == NULL) {
     1740                message = WPSExceptionText[exc];
     1741        }
     1742
     1743        size_t len = strlen(service) + strlen(": ") + strlen(message) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
     1744        char* msg = (char*)malloc(len * sizeof(char));
    16471745
    16481746        if (msg != NULL) {
    1649                 snprintf( msg, len*sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc] );
    1650                 setMapInMaps( conf, "lenv", "message", msg );
    1651                 free( msg );
    1652         }       
     1747                snprintf(msg, len * sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc]);
     1748                setMapInMaps(conf, "lenv", "message", msg);
     1749                free(msg);
     1750        }
    16531751}
    16541752
    16551753void logMessage(const char* source, const char* function, int line, const char* file, const char* message) { //, const char* source, const char* function, int line) {
    1656  
    1657   size_t msglen = 512;
    1658   const char empty[] = "";
    1659  
    1660   FILE* log;
    1661  
    1662   // system time, process time [nanoseconds]   
    1663   unsigned long long sys_t, proc_t;
    1664  
    1665   // processor time consumed by the program:
    1666   clock_t t = clock();
    1667    
    1668   // system time:
    1669   std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
    1670  
    1671   std::time_t now_t = std::chrono::system_clock::to_time_t( now );
    1672   std::tm* tm = localtime( &now_t );
     1754
     1755        size_t msglen = 512;
     1756        const char empty[] = "";
     1757
     1758        FILE* log;
     1759
     1760        // system time, process time [nanoseconds]   
     1761        unsigned long long sys_t, proc_t;
     1762
     1763        // processor time consumed by the program:
     1764        clock_t t = clock();
     1765
     1766        // system time:
     1767        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
     1768
     1769        std::time_t now_t = std::chrono::system_clock::to_time_t(now);
     1770        std::tm* tm = localtime(&now_t);
    16731771        char* str = asctime(tm);
    1674   str[strlen(str)-1] = '\0'; // remove newline
    1675  
    1676   sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
    1677   //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
    1678   proc_t = t;
    1679  
    1680   if ( message != NULL ) {
    1681      msglen += strlen(message);
    1682   } 
    1683   else {
    1684     message = empty;
    1685   }
    1686   //getLastErrorMessage(); // cgiScriptName 
    1687   char* text = (char*) malloc( sizeof(char)*msglen );
    1688  
    1689   snprintf( text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n",
    1690     _getpid(), source, line, function, str, sys_t, proc_t, message ); // __FILE__ __LINE__ __func__ //
    1691  
    1692   if ( file != NULL && (log = fopen( file, "a+" )) != NULL ) {
    1693     fputs( text, log );
    1694     fclose( log );
    1695   }
    1696   else {
    1697     #ifdef MSG_LOG_FILE
    1698     if ( (log = fopen( MSG_LOG_FILE, "a+" )) != NULL ) {
    1699       fputs( text, log );
    1700       fclose( log );
    1701     }     
    1702     #endif
    1703   }
    1704  
    1705   if ( text != NULL ) free( text );
     1772        str[strlen(str) - 1] = '\0'; // remove newline
     1773
     1774        sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
     1775        //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
     1776        proc_t = t;
     1777
     1778        if (message != NULL) {
     1779                msglen += strlen(message);
     1780        }
     1781        else {
     1782                message = empty;
     1783        }
     1784        //getLastErrorMessage(); // cgiScriptName 
     1785        char* text = (char*)malloc(sizeof(char)*msglen);
     1786
     1787        snprintf(text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n",
     1788                zGetpid(), source, line, function, str, sys_t, proc_t, message); // __FILE__ __LINE__ __func__ //
     1789
     1790        if (file != NULL && (log = fopen(file, "a+")) != NULL) {
     1791                fputs(text, log);
     1792                fclose(log);
     1793        }
     1794        else {
     1795#ifdef MSG_LOG_FILE
     1796                if ((log = fopen(MSG_LOG_FILE, "a+")) != NULL) {
     1797                        fputs(text, log);
     1798                        fclose(log);
     1799                }
     1800#endif
     1801        }
     1802
     1803        if (text != NULL) free(text);
    17061804}
    17071805
     
    17101808// zooLog;
    17111809// zooLogMsg(NULL, getLastErrorMessage());
    1712 // zooLogMsg(log.txt, getLastErrorMessage());
    1713 
    1714 #ifdef WIN32
    1715 #ifndef USE_MS
    1716 char *strcasestr (char const *a, char const *b)
    1717   {
    1718     char *x = zStrdup (a);
    1719     char *y = zStrdup (b);
    1720  
    1721       x = _strlwr (x);
    1722       y = _strlwr (y);
    1723     char *pos = strstr (x, y);
    1724     char *ret = pos == NULL ? NULL : (char *) (a + (pos - x));
    1725       free (x);
    1726       free (y);
    1727       return ret;
    1728   };
    1729 #else
    1730    ;
    1731 #endif
    1732 #endif
     1810// zooLogMsg("log.txt", getLastErrorMessage());
  • trunk/zoo-project/zoo-kernel/service.h

    r889 r917  
    22 * Author : Gérald FENOY
    33 *
    4  * Copyright (c) 2009-2015 GeoLabs SARL
     4 * Copyright (c) 2009-2019 GeoLabs SARL
    55 *
    66 * Permission is hereby granted, free of charge, to any person obtaining a copy
     
    3434#endif
    3535
     36 // knut: add bool if necessary
     37#ifndef __cplusplus
     38#ifndef WIN32
     39#include <stdbool.h>
     40#else
     41typedef int bool;
     42#define false 0
     43#define true 1 
     44#endif
     45#endif
     46#ifndef __bool_true_false_are_defined
     47#define __bool_true_false_are_defined 1
     48#endif
     49
    3650#ifdef WIN32
    37 #ifndef USE_MS
    38 ZOO_DLL_EXPORT char *strcasestr (char const *,char const *);
    39 #endif
    40 #endif
    41 
    42 // knut: add bool if necessary
    43 #ifndef __cplusplus
    44   #ifndef WIN32
    45     #include <stdbool.h>
    46   #else
    47     typedef int bool;
    48     #define false 0
    49     #define true 1     
    50   #endif
    51 #endif
    52 #ifndef __bool_true_false_are_defined
    53   #define __bool_true_false_are_defined 1
    54 #endif
    55 
    56 #ifdef WIN32
     51#define strtok_r strtok_s
    5752#define strncasecmp _strnicmp
    5853#define strcasecmp _stricmp
    59 #define strtok_r strtok_s
    6054#if defined(_MSC_VER) && _MSC_VER < 1900
    6155#define snprintf _snprintf
    6256#endif
    63 /* knut: see new definition of bool above
    64 #if defined(_MSC_VER) && _MSC_VER < 1800
    65 #define false 0
    66 #define true 1
    67 #define bool int
    68 #endif
    69 */
    7057#define zStrdup _strdup
    7158#define zMkdir _mkdir
     59#define zGetpid _getpid
    7260#define zOpen _open
     61#define zClose _close
     62#define zUnlink _unlink
     63#define zDup _dup
     64#define zDup2 _dup2
    7365#define zWrite _write
    7466#define zSleep Sleep
     
    8072static int zGettimeofday(struct ztimeval* tp, void* tzp)
    8173{
    82   struct _timeb theTime;       
    8374  if (tp == 0) {
    8475    return -1;
    8576  }
    8677 
     78  struct _timeb theTime;
    8779  _ftime(&theTime);
    8880  tp->tv_sec = theTime.time;
     
    9284}
    9385
     86#define zStatStruct struct _stati64
     87#define zStat _stati64
     88
    9489#else
    9590/**
     
    106101#define zOpen open
    107102/**
     103 * The crossplatform close alias
     104 */
     105#define zClose close
     106/**
     107 * The crossplatform unlink alias
     108 */
     109#define zUnlink unlink
     110/**
     111 * The crossplatform dup alias
     112 */
     113#define zDup dup
     114/**
     115 * The crossplatform dup2 alias
     116 */
     117#define zDup2 dup2
     118/**
    108119 * The crossplatform write alias
    109120 */
    110121#define zWrite write
     122#include "unistd.h"
    111123/**
    112124 * The crossplatform sleep alias
    113125 */
    114 #define zSleep sleep
     126static int zSleep(const long millisecond){
     127  return usleep(millisecond*1000);
     128}
    115129/**
    116130 * The crossplatform gettimeofday alias
     
    121135 */
    122136#define ztimeval timeval
     137/**
     138 * The crossplatform getpid alias
     139 */
     140#define zGetpid getpid
     141
     142#define zStatStruct struct stat64
     143#define zStat stat64
     144
    123145#endif
    124146
     
    140162#ifndef WIN32
    141163#include <ctype.h>
    142 //#include <stdbool.h> // knut: see new definition of bool above
     164#include <stdbool.h>
    143165#endif
    144166
     
    167189 * The memory size to create an elements
    168190 */
    169 #define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+(2*sizeof(elements*)))
     191#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*3)+sizeof(char*)+((sizeof(map*) + sizeof(iotype*))*2)+(2*sizeof(elements*)))
    170192/**
    171193 * The memory size to create a map
     
    187209 */
    188210//#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
    189 #define SERVICE_SIZE sizeof(char*) + 2*sizeof(map*) + 2*sizeof(elements*)
     211#define SERVICE_SIZE sizeof(char*) + 3*sizeof(map*) + 2*sizeof(elements*)
    190212/**
    191213 * The memory size to create a services
     
    221243#ifdef WIN32
    222244#define NULLMAP ((map*) 0)
     245// knut: see new definition above
     246//#define bool int
     247//#define true 1
     248//#define false 0
    223249#else
    224250#define NULLMAP NULL
     
    256282    struct map* content; //!< the content map
    257283    struct map* metadata; //!< the metadata map
     284    struct map* additional_parameters; //!< the additional parameters map
    258285    char* format; //!< the format: LiteralData or ComplexData or BoundingBoxData
    259286    struct iotype* defaults; //!< the default iotype
     
    270297    struct map* content; //!< the content map
    271298    struct map* metadata; //!< the metadata map
     299    struct map* additional_parameters; //!< the additional parameters map
    272300    struct elements* inputs; //!< the inputs elements
    273301    struct elements* outputs; //!< the outputs elements
     
    290318    struct registry* next; //!< the next registry pointer
    291319  } registry;
    292  
     320
    293321  // knut
    294322  enum WPSException {
    295     /*
    296     * StatusOK is not a WPS exception, it is added
    297     * here for convenience.
    298     */     
    299     StatusOK,                 
    300     /*
    301     * See WPS 1.0 specification, Table 38 and Table 62.
    302     */
    303     MissingParameterValue,   
    304     InvalidParameterValue,
    305     NoApplicableCode,
    306     NotEnoughStorage,
    307     ServerBusy,
    308     FileSizeExceeded,
    309     StorageNotSupported,
    310     VersionNegotiationFailed,
    311     /*
    312     * See WPS 2.0 specification, Tables 41, 46, 48, and 50.
    313     */
    314     NoSuchProcess,
    315     NoSuchMode,
    316     NoSuchInput,
    317     NoSuchOutput,
    318     DataNotAccessible,
    319     SizeExceeded,
    320     TooManyInputs,
    321     TooManyOutputs,
    322     NoSuchFormat,
    323     WrongInputData,
    324     InternalServerError,
    325     NoSuchJob,
    326     ResultNotReady
    327   }; 
    328  
     323          /*
     324          * StatusOK is not a WPS exception, it is added
     325          * here for convenience.
     326          */
     327          StatusOK,
     328          /*
     329          * See WPS 1.0 specification, Table 38 and Table 62.
     330          */
     331          MissingParameterValue,
     332          InvalidParameterValue,
     333          NoApplicableCode,
     334          NotEnoughStorage,
     335          ServerBusy,
     336          FileSizeExceeded,
     337          StorageNotSupported,
     338          VersionNegotiationFailed,
     339          /*
     340          * See WPS 2.0 specification, Tables 41, 46, 48, and 50.
     341          */
     342          NoSuchProcess,
     343          NoSuchMode,
     344          NoSuchInput,
     345          NoSuchOutput,
     346          DataNotAccessible,
     347          SizeExceeded,
     348          TooManyInputs,
     349          TooManyOutputs,
     350          NoSuchFormat,
     351          WrongInputData,
     352          InternalServerError,
     353          NoSuchJob,
     354          ResultNotReady
     355  };
     356
    329357  static const char* const WPSExceptionCode[] = {
    330     "StatusOK",
    331     "MissingParameterValue",
    332     "InvalidParameterValue",
    333     "NoApplicableCode",
    334     "NotEnoughStorage",
    335     "ServerBusy",
    336     "FileSizeExceeded",
    337     "StorageNotSupported",
    338     "VersionNegotiationFailed",
    339     "NoSuchProcess",
    340     "NoSuchMode",
    341     "NoSuchInput",
    342     "NoSuchOutput",
    343     "DataNotAccessible",
    344     "SizeExceeded",
    345     "TooManyInputs",
    346     "TooManyOutputs",
    347     "NoSuchFormat",
    348     "WrongInputData",
    349     "InternalServerError",
    350     "NoSuchJob",
    351     "ResultNotReady"   
    352   };     
     358        "StatusOK",
     359        "MissingParameterValue",
     360        "InvalidParameterValue",
     361        "NoApplicableCode",
     362        "NotEnoughStorage",
     363        "ServerBusy",
     364        "FileSizeExceeded",
     365        "StorageNotSupported",
     366        "VersionNegotiationFailed",
     367        "NoSuchProcess",
     368        "NoSuchMode",
     369        "NoSuchInput",
     370        "NoSuchOutput",
     371        "DataNotAccessible",
     372        "SizeExceeded",
     373        "TooManyInputs",
     374        "TooManyOutputs",
     375        "NoSuchFormat",
     376        "WrongInputData",
     377        "InternalServerError",
     378        "NoSuchJob",
     379        "ResultNotReady"
     380  };
    353381
    354382  static const char* const WPSExceptionText[] = {
    355     "No problem detected",
    356     "Operation request does not include a parameter value, and this server did not declare a default value for that parameter.",
    357     "Operation request contains an invalid parameter value.",
    358     "No other exceptionCode specified by this service and server applies to this exception.",
    359     "The server does not have enough space available to store the inputs and outputs associated with the request.",
    360     "The server is too busy to accept and queue the request at this time.",
    361     "The file size of one of the input parameters was too large for this process to handle.",
    362     "Execute operation request included transmission=”reference” for one of the outputs, but storage is not offered by this server.",
    363     "Service version for a ComplexData xlink:href input was not supported by the referenced server, and version negotiation failed.",
    364     "One of the identifiers passed does not match with any of the processes offered by this server.",
    365     "The process does not permit the desired execution mode.",
    366     "One or more of the input identifiers passed does not match with any of the input identifiers of this process.",
    367     "One or more of the output identifiers passed does not match with any of the input identifiers of this process.",
    368     "One of the referenced input data sets was inaccessible.",
    369     "The size of one of the input parameters was too large for this process to handle.",
    370     "Too many input items have been specified.",
    371     "Too many output items have been specified.",
    372     "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.",
    373     "One or more of inputs for which the service was able to retrieve the data but could not read it.",
    374     "",
    375     "The JobID from the request does not match any of the Jobs running on this server.",
    376     "The result for the requested JobID has not yet been generated."
     383        "No problem detected",
     384        "Operation request does not include a parameter value, and this server did not declare a default value for that parameter.",
     385        "Operation request contains an invalid parameter value.",
     386        "No other exceptionCode specified by this service and server applies to this exception.",
     387        "The server does not have enough space available to store the inputs and outputs associated with the request.",
     388        "The server is too busy to accept and queue the request at this time.",
     389        "The file size of one of the input parameters was too large for this process to handle.",
     390        "Execute operation request included transmission=”reference” for one of the outputs, but storage is not offered by this server.",
     391        "Service version for a ComplexData xlink:href input was not supported by the referenced server, and version negotiation failed.",
     392        "One of the identifiers passed does not match with any of the processes offered by this server.",
     393        "The process does not permit the desired execution mode.",
     394        "One or more of the input identifiers passed does not match with any of the input identifiers of this process.",
     395        "One or more of the output identifiers passed does not match with any of the input identifiers of this process.",
     396        "One of the referenced input data sets was inaccessible.",
     397        "The size of one of the input parameters was too large for this process to handle.",
     398        "Too many input items have been specified.",
     399        "Too many output items have been specified.",
     400        "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.",
     401        "One or more of inputs for which the service was able to retrieve the data but could not read it.",
     402        "",
     403        "The JobID from the request does not match any of the Jobs running on this server.",
     404        "The result for the requested JobID has not yet been generated."
    377405  };
    378406
     
    392420  ZOO_DLL_EXPORT void freeMap(map**);
    393421  ZOO_DLL_EXPORT void freeMaps(maps** mo);
    394  
    395 
     422  ZOO_DLL_EXPORT iotype* createIoType();
    396423  ZOO_DLL_EXPORT elements* createEmptyElements();
    397   ZOO_DLL_EXPORT elements* createElements(char*);
     424  ZOO_DLL_EXPORT elements* createElements(const char*);
    398425  ZOO_DLL_EXPORT void setElementsName(elements**,char*);
    399426  ZOO_DLL_EXPORT bool hasElement(elements*,const char*);
     
    402429  ZOO_DLL_EXPORT void freeElements(elements**);
    403430  ZOO_DLL_EXPORT void setServiceName(service**,char*);
     431  ZOO_DLL_EXPORT service* createService();
    404432  ZOO_DLL_EXPORT void freeService(service**);
    405433  ZOO_DLL_EXPORT void addToMap(map*,const char*,const char*);
    406434  ZOO_DLL_EXPORT void addIntToMap(map*,const char*,const int);
     435  ZOO_DLL_EXPORT void addIntToMapArray(map*,const char*,int,const int);
    407436  ZOO_DLL_EXPORT map* addToMapWithSize(map*,const char*,const char*,int);
    408437  ZOO_DLL_EXPORT void addMapToMap(map**,map*);
     
    446475  ZOO_DLL_EXPORT bool nonempty(map* map);
    447476  ZOO_DLL_EXPORT bool hasvalue(maps* source, const char* node, const char* key, map** kvp);
     477#ifdef __cplusplus
    448478  ZOO_DLL_EXPORT void setErrorMessage(maps*& conf, const char* service, WPSException exc, const char* message = NULL);
    449   ZOO_DLL_EXPORT void logMessage(const char* source, const char* function, int line, const char* file = NULL, const char* message = NULL); 
     479  ZOO_DLL_EXPORT void logMessage(const char* source, const char* function, int line, const char* file = NULL, const char* message = NULL);
     480#endif
    450481  #define zooLogMsg(file,message) logMessage(__FILE__, __func__, __LINE__, (file), (message))
    451482  #define zooLog logMessage(__FILE__, __func__, __LINE__) 
    452  
     483
    453484#ifdef __cplusplus
    454485}
  • trunk/zoo-project/zoo-kernel/service_conf.y

    r790 r917  
    3333static bool wait_maincontent=true;
    3434static bool wait_mainmetadata=false;
     35static bool wait_mainap=false;
    3536static bool wait_metadata=false;
     37static bool wait_ap=false;
    3638static bool wait_nested=false;
    3739static bool wait_inputs=false;
     
    156158    current_content=NULL;
    157159    my_service->metadata=NULL;
     160    my_service->additional_parameters=NULL;
    158161    wait_maincontent=false;
    159162  }
    160163  if(strncasecmp($2,"EndNested",9)==0){
    161164#ifdef DEBUG_SERVICE_CONF
    162       fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
    163       fflush(stderr);
    164 #endif
    165       nested_level-=1;
    166       if(nested_level==0){
    167         wait_nested=false;
    168       }
     165    fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
     166    fflush(stderr);
     167#endif
     168    nested_level-=1;
     169    if(nested_level==0){
     170      wait_nested=false;
     171    }
    169172  }
    170173
     
    229232    }
    230233    else
    231       if(strncasecmp($2,"MetaData",8)==0){
    232         previous_data=current_data;
    233         current_data=3;
    234         if(current_element!=NULL){
    235 #ifdef DEBUG_SERVICE_CONF
    236           fprintf(stderr,"add current_content to current_element->content\n");
    237           fprintf(stderr,"LINE %d",__LINE__);
    238 #endif
    239           addMapToMap(&current_element->content,current_content);
    240           freeMap(&current_content);
    241           free(current_content);
    242           if(previous_data==1 || previous_data==2)
    243             wait_metadata=true;
    244           else
    245             wait_mainmetadata=true;
    246         }
    247         else{
    248           if(previous_data==1 || previous_data==2)
    249             wait_metadata=true;
    250           else
    251             wait_mainmetadata=true;
     234      if(strncasecmp($2,"MetaData",8)==0 ||
     235         strncasecmp($2,"AdditionalParameters",8)==0){
     236        if(strncasecmp($2,"AdditionalParameters",8)==0){
     237          previous_data=current_data;
     238          current_data=4;
     239          if(current_element!=NULL){
     240#ifdef DEBUG_SERVICE_CONF
     241            fprintf(stderr,"add current_content to current_element->content\n");
     242            fprintf(stderr,"LINE %d",__LINE__);
     243#endif
     244            if(wait_mainmetadata)
     245              addMapToMap(&my_service->metadata,current_content);
     246            else
     247              if(wait_metadata)
     248                addMapToMap(&current_element->metadata,current_content);
     249              else
     250                addMapToMap(&current_element->content,current_content);         
     251            freeMap(&current_content);
     252            free(current_content);
     253            if(previous_data==1 || previous_data==2)
     254              wait_ap=true;
     255            else
     256              wait_mainap=true;
     257          }
     258          else{
     259            if(previous_data==1 || previous_data==2)
     260              wait_ap=true;
     261            else
     262              wait_mainap=true;
     263          }
     264        }else{
     265          previous_data=current_data;
     266          current_data=3;
     267          if(current_element!=NULL){
     268#ifdef DEBUG_SERVICE_CONF
     269            fprintf(stderr,"add current_content to current_element->content\n");
     270            fprintf(stderr,"LINE %d",__LINE__);
     271#endif
     272            addMapToMap(&current_element->content,current_content);
     273            freeMap(&current_content);
     274            free(current_content);
     275            if(previous_data==1 || previous_data==2)
     276              wait_metadata=true;
     277            else
     278              wait_mainmetadata=true;
     279          }
     280          else{
     281            if(previous_data==1 || previous_data==2)
     282              wait_metadata=true;
     283            else
     284              wait_mainmetadata=true;
     285          }
    252286        }
    253287        current_content=NULL;
     
    425459  if(strcmp($3,"DataOutputs")==0){
    426460    current_data=2;
     461  } 
     462  if(strcmp($3,"AdditionalParameters")==0){
     463    if(current_content!=NULL){
     464#ifdef DEBUG_SERVICE_CONF
     465      fprintf(stderr,"add current_content to current_element->content\n");
     466      fprintf(stderr,"LINE %d",__LINE__);
     467#endif
     468      if(wait_ap){
     469        current_element->additional_parameters=NULL;
     470        addMapToMap(&current_element->additional_parameters,current_content);
     471        current_element->next=NULL;
     472        current_element->defaults=NULL;
     473        current_element->supported=NULL;
     474        current_element->child=NULL;
     475      }else{
     476        if(wait_mainap){
     477          addMapToMap(&my_service->additional_parameters,current_content);
     478        }
     479      }
     480
     481      freeMap(&current_content);
     482      free(current_content);
     483      current_content=NULL;
     484    }
     485    current_data=previous_data;
     486    wait_mainap=false;
     487    wait_ap=false;
    427488  }
    428489  if(strcmp($3,"MetaData")==0){
     
    866927  wait_mainmetadata=false;
    867928  wait_metadata=false;
     929  wait_mainap=false;
     930  wait_ap=false;
    868931  wait_inputs=false;
    869932  wait_defaults=false;
  • trunk/zoo-project/zoo-kernel/service_internal.c

    r889 r917  
    22 * Author : Gérald FENOY
    33 *
    4  * Copyright (c) 2009-2015 GeoLabs SARL
     4 * Copyright (c) 2009-2018 GeoLabs SARL
    55 *
    66 * Permission is hereby granted, free of charge, to any person obtaining a copy
     
    3131#include "service_internal.h"
    3232
    33 #ifndef TRUE
    34 #define TRUE 1
    35 #endif
    36 #ifndef FALSE
    37 #define FALSE -1
    38 #endif
    39 
     33#ifdef WIN32
     34// ref. https://docs.microsoft.com/en-us/windows/desktop/fileio/locking-and-unlocking-byte-ranges-in-files
     35__inline int fcntl(int fd, int cmd, ...)
     36{
     37  va_list a;
     38  va_start(a, cmd);
     39  switch(cmd)
     40    {
     41    case F_SETLK:
     42      {
     43        HANDLE h = (HANDLE)_get_osfhandle(fd);
     44        struct flock* l= va_arg(a, struct flock*);
     45        OVERLAPPED sOverlapped;
     46        sOverlapped.Offset = 0;
     47        sOverlapped.OffsetHigh = 0;
     48        switch(l->l_type)
     49          {
     50          case F_RDLCK:
     51            {
     52              if (!LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY, 0, l->l_len, 0, &sOverlapped))
     53                {
     54                  _set_errno(GetLastError() == ERROR_LOCK_VIOLATION ? EAGAIN : EBADF);
     55                  return -1;
     56                }
     57            }
     58            break;
     59          case F_WRLCK:
     60            {
     61              if (!LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY|LOCKFILE_EXCLUSIVE_LOCK, 0, l->l_len, 0, &sOverlapped))
     62                {
     63                  _set_errno(GetLastError() == ERROR_LOCK_VIOLATION ? EAGAIN : EBADF);
     64                  return -1;
     65                }
     66            }
     67            break;
     68          case F_UNLCK:
     69            {
     70              UnlockFileEx(h, 0, l->l_len, 0, &sOverlapped);
     71            }
     72            break;
     73          default:
     74            _set_errno(ENOTSUP);
     75            return -1;
     76          }
     77      }
     78      break;
     79    default:
     80      _set_errno(ENOTSUP);
     81      return -1;
     82    }
     83  return 0;
     84}
     85#endif
    4086#define ERROR_MSG_MAX_LENGTH 1024
     87
     88/**
     89 * Lock a file for read, write and upload.
     90 * @param conf the main configuration maps
     91 * @param filename the file to lock
     92 * @param mode define access: 'r' for read, 'w' for write
     93 * @return a new zooLock structure on sucess, NULL on failure
     94 */
     95struct zooLock* lockFile(maps* conf,const char* filename,const char mode){
     96  struct stat f_status;
     97  int itn=0;
     98  int s;
     99  struct zooLock* myLock=(struct zooLock*)malloc(sizeof(struct flock)+sizeof(FILE*)+sizeof(char*));
     100  int len=6;
     101  char *myTemplate="%s.lock";
     102  int res=-1;
     103 retryLockFile:
     104  myLock->filename=(char*)malloc((strlen(filename)+len)*sizeof(char));
     105  sprintf(myLock->filename,myTemplate,filename);
     106  s=stat(myLock->filename, &f_status);
     107  if(s==0 && mode!='r'){
     108    if(itn<ZOO_LOCK_MAX_RETRY){
     109      itn++;
     110#ifdef DEBUG
     111      fprintf(stderr,"(%d) Wait for write lock on %s, tried %d times (sleep) ... \n",zGetpid(),myLock->filename,itn);
     112      fflush(stderr);
     113#endif
     114      zSleep(5);
     115      free(myLock->filename);
     116      goto retryLockFile;
     117    }else{
     118      free(myLock->filename);
     119      free(myLock);
     120      return NULL;
     121    }
     122  }else{
     123    char local_mode[3];
     124    memset(local_mode,0,3);
     125    if(mode=='w')
     126      sprintf(local_mode,"%c+",mode);
     127    else
     128      sprintf(local_mode,"%c",mode);
     129    myLock->lockfile=fopen(myLock->filename,local_mode);
     130    char tmp[512];
     131    sprintf(tmp,"%d",zGetpid());
     132    if(myLock->lockfile==NULL){
     133      myLock->lockfile=fopen(myLock->filename,"w+");
     134      fwrite(tmp,sizeof(char),strlen(tmp),myLock->lockfile);
     135      fflush(myLock->lockfile);
     136      fclose(myLock->lockfile);
     137      myLock->lockfile=fopen(myLock->filename,local_mode);
     138    }/*else
     139       fprintf(stderr,"%s %d %d\n",__FILE__,__LINE__,(myLock->lockfile==NULL));*/
     140    if(mode!='r'){
     141      fwrite(tmp,sizeof(char),strlen(tmp),myLock->lockfile);
     142      fflush(myLock->lockfile);
     143    }
     144    int cnt=0;
     145    if(mode=='r'){
     146      myLock->lock.l_type = F_RDLCK;
     147    }else
     148      myLock->lock.l_type = F_WRLCK;
     149    myLock->lock.l_whence = 0;
     150    myLock->lock.l_start = 0;
     151    myLock->lock.l_len = strlen(tmp)*sizeof(char);
     152    while (true) {
     153      if((res=fcntl(fileno(myLock->lockfile), F_SETLK, &(myLock->lock)))==-1 &&
     154         (errno==EAGAIN || errno==EACCES)){
     155          if(cnt >= ZOO_LOCK_MAX_RETRY){
     156            char message[51];     
     157            sprintf(message,"Unable to get the lock after %d attempts.\n",cnt);
     158            setMapInMaps(conf,"lenv","message",message);
     159            fclose(myLock->lockfile);
     160            free(myLock->filename);
     161            free(myLock);
     162            return NULL;
     163          }
     164#ifdef DEBUG
     165          fprintf(stderr,"(%d) Wait for lock on  %s, tried %d times ... \n",zGetpid(),myLock->filename,cnt);
     166          fflush(stderr);
     167#endif
     168          zSleep(1);
     169          cnt++;
     170        }else
     171           break;
     172    }
     173    if(res<0){
     174      char *tmp;
     175      if(errno==EBADF)
     176        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.";
     177      else
     178        if(errno==EINVAL)
     179          tmp="Either the lockp argument doesn’t specify valid lock information, or the file associated with filedes doesn’t support locks.";
     180        else
     181          tmp="The system has run out of file lock resources; there are already too many file locks in place.";
     182#ifdef DEBUG
     183      fprintf(stderr,"Unable to get the lock on %s due to the following error: %s\n",myLock->filename,tmp);
     184#endif
     185      return NULL;
     186    }
     187    return myLock;
     188  }
     189}
     190
     191/**
     192 * Remove a lock.
     193 * @param conf the main configuration maps
     194 * @param s the zooLock structure
     195 * @return 0 on success, -1 on failure.
     196 */
     197int unlockFile(maps* conf,struct zooLock* s){
     198  int res=-1;
     199  if(s!=NULL){
     200    s->lock.l_type = F_UNLCK;
     201    res=fcntl(fileno(s->lockfile), F_SETLK, &s->lock);
     202    if(res==-1)
     203      return res;
     204    fclose(s->lockfile);
     205#ifndef WIN32
     206    // Check if there is any process locking a file and delete the lock if not.
     207    s->lock.l_type = F_WRLCK;
     208    if(fcntl(fileno(s->lockfile), F_GETLK, &s->lock)!=-1 && s->lock.l_type == F_UNLCK){
     209#endif
     210      zUnlink(s->filename);
     211#ifndef WIN32
     212    }
     213#endif
     214    free(s->filename);
     215    free(s);
     216  }
     217  return res;
     218}
     219
    41220#ifndef RELY_ON_DB
    42 #include <dirent.h>
     221#include "dirent.h"
    43222
    44223/**
     
    148327
    149328    //FILE* f0 = fopen (fileName, "r");
    150         // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
    151         FILE* f0 = fopen(fileName, "rb");
     329    // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
     330    FILE* f0 = fopen(fileName, "rb");
    152331    if(f0!=NULL){
    153332      fseek (f0, 0, SEEK_END);
     
    162341        free(stat);
    163342      }
    164 
    165343      return tmps1;
    166344    }
     
    250428                     * sizeof (char));
    251429  sprintf (fbkpid, "%s/%s.status", r_inputs->value, usid->value);
    252   unlink(fbkpid);
     430  zUnlink(fbkpid);
    253431  free(fbkpid);
    254432}
     
    510688            }
    511689        }
     690        setMapInMaps(conf,"lenv","semaphore","Created");
    512691    } else if (errno == EEXIST) { /* someone else got it first */
    513692        int ready = 0;
     
    529708              fprintf(stderr,"Retry to access the semaphore later ...\n");
    530709#endif
    531               zSleep(1);
     710              zSleep(1000);
    532711            }
    533712        }
     
    540719          return -1;
    541720        }
     721        setMapInMaps(conf,"lenv","semaphore","Acquired");
    542722    } else {
    543723        return sem_id; /* error, check errno */
     
    739919}
    740920
     921/**
     922 * Check if file exists in specified folder
     923 *
     924 * @param dir the folder in which to search for file
     925 * @param name the name of the file (not full path)
     926 * @return a character string with the full path [dir/name], or NULL if the file does not exist
     927 *
     928 * @attention Caller is responsible for applying free() to the returned pointer
     929 */
     930char* file_exists(const char* dir, const char* name) {
     931        const char* d = (dir != NULL ? dir : ".");
     932        if (name != NULL) {
     933                size_t length = strlen(d) + strlen(name) + 2; // including file separator and \0 character
     934                char* path = (char*)calloc(length, sizeof(char));
     935                snprintf(path, length, "%s/%s", d, name);
     936
     937                struct stat buffer;
     938                if (stat(path, &buffer) != 0) {
     939                        free(path);
     940        &n