Changeset 917

trunk

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

trunk/docs/install/installation.rst

-                      r809
+                      r917
     <http://zoo-project.org/trac/browser/trunk/zoo-project/zoo-kernel/sql/schema.sql#L34>`_.
+Metadata Database (Optional)
+*****************************
+.. _zoo_create_metadb:
+It is possible to use a PostgreSQL database to store metadata
+information about WPS Services. This support is optional and require
+to be activated by using the ``--with-metadb=yes`` option.
+To create the database for storing the metadata informations about the
+WPS Services, you may use the following command:
+.. code::
+    createdb zoo_metadb
+    psql zoo_metadb -f zoo-project/zoo-kernel/sql/zoo_collectiondb.sql
+In case you want to convert an existing zcfg file then, you can use
+the ``zcfg2sql`` tool from the command line. It can be found in
+``thirds/zcfg2sql`` and can be build simply by running the ``make``
+command. After compilation you only need to give it the path of the
+zcfg file you want to obtain the SQL queries required to store the
+metadata informations in the database rather than in zcfg file.
+For instance you may use the following command:
+.. code::
+    #Direct import in the zoo_metadb database
+    ./zcfg2sql /Path/To/MyZCFGs/myService.zcfg | psql zoo_metadb
+    #Create a SQL file for a futur import
+    ./zcfg2sql /Path/To/MyZCFGs/myService.zcfg > myService.sql
 …
 If ``yaml.h`` file is not found in your ``/usr/include`` directory and
 ``libyaml.so`` is not found in ``/usr/lib``, a ``--with-yaml`` option
 can be used to specify its location. For instance, if the headeer file
+can be used to specify its location. For instance, if the header file
 lies in ``/usr/local/include`` and the shared library is located in
 ``/usr/local/lib``, you may use the following command:

trunk/docs/kernel/configuration.rst

-                      r817
+                      r917
    service providers, e.g., shared libraries with service implementations
    (the ``serviceProvider`` parameter in the service configuration (.zcfg) file).
+ * ``memory``: (Optional) can take the value ``load`` to ensure that
+   the value field of the inputs data will be filled by the ZOO-Kernel
+   or ``protected`` to have only the ``cache_file`` filled.
 .. warning::
   The ``libPath`` parameter is currently only recognized by services implemented
   in C/C++ or PHP, and may be moved to another section in future versions.
+.. warning::
+  Depending on the ``memory`` parameter the WPS Service will receive
+  different fields (``value`` or ``cache_file``).
 In case you have activated the MapServer support, please refer to
 :ref:`this specific section <kernel-mapserver-main.cfg>`.
 …
     hosts=localhost,127.0.0.1
+Optionaly, you can also define the shared url(s), meaning that even if
+the ressource requires authentication to be accessed, this
+authentifcation won't be used to define the name for storing the
+file. Hence, two user with different authentication will use the same
+file as it is considerated as shared. You can find bellow a sample
+security section containing the shared parameter. In this example,
+every requests to access the coverage using the url defined in the
+shared parameter (``myHost/cgi-bin/WCS_Server``) will be shared
+between users.
+.. code::
+    [security]
+    attributes=Authorization,Cookie,User-Agent
+    hosts=localhost,127.0.0.1
+    shared=myHost/cgi-bin/WCS_Server
 .. _zoo_activate_db_backend:
 …
 to setup the database.
+Database section
+...............................
+The database section allows to configure the ZOO-Kernel to access the
+metadata information about WPS Services by using a PostgreSQL database
+in addition to the zcfg files.
+.. code-block:: guess
+        [metadb]
+        dbname=zoo_metadb
+        port=5432
+        user=username
+        host=127.0.0.1
+        type=PG
+This will generate strings to be passed to GDAL to connect the
+database server:
+.. code-block:: guess
+    <type>:host=<host> port=<port>  user=<user> dbname=<dbname>
+With the previous database section, it will give the following:
+.. code-block:: guess
+    PG:"dbname=zoo_metadb host=127.0.0.1 port=5432 user=username"
+Please refer to this `section <zoo_create_metadb>`_ to learn how
+to setup the database.
 Include section
 ...............................

trunk/docs/kernel/index.rst

r725	r917
14	14	orfeotoolbox
15	15	sagagis
16
	16	hpc

trunk/docs/kernel/mapserver.rst

-                      r752
+                      r917
    * `MapServer <http://mapserver/org>`__ version >= 6.0.1
 First download the lastest zoo-kernel by checking out the svn. Use the following command from do the directory where your previously checked out (in this example we will use ``<PREV_SVN_CO>`` to design this directory).
 .. code-block:: guess
     cd <PREV_SVN_CO>
     svn checkout http://svn.zoo-project.org/svn/trunk/zoo-kernel zoo-kernel-ms
+First download the lastest zoo-kernel by checking out the svn. Use the following command from do the directory where your previously checked out (in this example we will use ``$PREV_SVN_CO`` to design this directory).
+.. code-block:: guess
+    svn checkout http://svn.zoo-project.org/svn/trunk/ $PREV_SVN_CO
+    cd $PREV_SVN_CO
 Then uncompress the MapServer archive (ie. ``mapserver-6.0.1.tar.bz2``) into ``/tmp/zoo-ms-src``, and compile it using the following command:
 …
      cp mapserv /usr/lib/cgi-bin
 Once done, compile ZOO-Kernel with MapServer support from the ``<PREV_SVN_CO>`` directory, using the following command:
 .. code-block:: guess
      cd zoo-kernel-ms
+Once done, compile ZOO-Kernel with MapServer support from the ``$PREV_SVN_CO`` directory, using the following command:
+.. code-block:: guess
+     cd zoo-kernel
      autoconf
      ./configure --with-python --with-mapserver=/tmp/zoo-ms-src/mapserver-6.0.1
      make
+You can then copy the new ZOO-Kernel to ``/usr/lib/cgi-bin`` directory, as follow:
+.. code-block:: guess
+     cp zoo_loader.cgi /usr/lib/cgi-bin
+     sudo make install
 …
       dataPath = /var/www/temp/
       mapserverAddress=http://localhost/cgi-bin/mapserv
+You can also add the following lines to the ``[main]`` section, in case
+you want to use a default style for Polygon, Lines and Points vector
+layer.
+.. code-block:: guess
+      msStylePoly=STYLE COLOR 202 109 19 OUTLINECOLOR 105 105 105 WIDTH 3 END
+      msStyleLine=STYLE OUTLINECOLOR 202 109 19 WIDTH 3 END
+      msStylePoint=STYLE COLOR 202 109 19 OUTLINECOLOR 105 105 105 SYMBOL 0 SIZE 14 END
 The ``dataPath`` directory is mandatory and must belong to the Apache user.
 …
 *************
+You have different options to define the style of the layer created
+using the data returned by your service.
+msStyle
++++++++
 The optional ``msStyle`` parameter can also be used to define a custom MapServer style block (used for vector datasource only), as follow:
 …
      msStyle = STYLE COLOR 125 0 105 OUTLINECOLOR 0 0 0 WIDTH 3 END
+If a WPS service outputs a one band raster file, then it is possible to add a ``msClassify`` parameter and set it to ``true`` in the output ComplexData ``<Default>`` or ``<Supported>`` nodes of its ``zcfg`` file. This allows ZOO-Kernel to use its own default style definitions in order to classify the raster using equivalent intervals.
+.. code-block:: guess
+     msClassify = ....
+msClassify
+++++++++++
+If a WPS service outputs a one band raster file, then it is possible
+to add a ``msClassify`` parameter and set it to ``true`` in the output
+ComplexData ``<Default>`` or ``<Supported>`` nodes of its zcfg
+file. This allows ZOO-Kernel to use its own default style definitions
+in order to classify the raster using equivalent intervals.
+.. code-block:: guess
+     msClassify = true
+msInclude
++++++++++
+In case you want to use another layer which use the result of your
+service, for instance to produce a `heatmap
+<https://mapserver.org/output/kerneldensity.html>`_, then you can use
+the
+``msInclude`` and ``msLayer`` options in the output ``ComplexData``
+``<Default>`` or ``<Supported>`` nodes of its zcfg file. You can see below an
+example of use of this two options with the associated mapfile.
+.. code-block:: guess
+     msInclude = /var/data/template.map
+     msLayer = heatmap
+You can find below a sample ``/var/data/template.map``:
+.. code-block:: guess
+     MAP
+       SIZE 1000 500
+       EXTENT -180 -90 180 90
+       NAME "test heat"
+       IMAGETYPE "png"
+       WEB
+         METADATA
+           "ows_srs" "epsg:4326  epsg:3857 epsg:900913"
+           "ows_enable_request" "*"
+         END # METADATA
+       END # WEB
+       PROJECTION
+         "+init=epsg:4326"
+       END # PROJECTION
+       LAYER
+         NAME "heatmap" # Corresponding to the msLayer defined
+         TYPE raster
+         CONNECTIONTYPE kerneldensity
+         CONNECTION "Result"
+         STATUS on
+         PROCESSING "RANGE_COLORSPACE=HSL"
+         PROCESSING "KERNELDENSITY_RADIUS=20"
+         PROCESSING "KERNELDENSITY_COMPUTE_BORDERS=ON"
+         PROCESSING "KERNELDENSITY_NORMALIZATION=AUTO"
+         OFFSITE 0 0 0
+         CLASS
+           STYLE
+             COLORRANGE  "#0000ff00"  "#0000ffff"
+             DATARANGE 0 32
+           END # STYLE
+           STYLE
+             COLORRANGE  "#0000ffff"  "#ff0000ff"
+             DATARANGE 32 255
+           END # STYLE
+         END # CLASS
+       END # LAYER
+       LAYER
+         NAME "points"
+         STATUS on
+         TYPE POINT
+         #DATA "/Library/WebServer/cache//ef76ee6642c1ea704e847e28120ba1ca.zca"
+       END # LAYER
+     END # MAPFILE
 Example
 …
      useMapserver = true
      asReference = true
      msClassify = ....
+     msClassify = true
     </Supported>

trunk/docs/kernel/sagagis.rst

-                      r725
+                      r917
 ======================
 `SAGA GIS <http://orfeo-toolbox.org/otb/>`_ provides a comprehensive set of geoscientific methods and spatial algorithms. The optional SAGA GIS support is available since `ZOO-Project 1.5 <http://zoo-project.org>`__. It allows to execute the `SAGA Modules <http://www.saga-gis.org/saga_module_doc/2.1.4/index.html>`_ directly as ZOO WPS Services thanks to a :ref:`kernel_index` specific internal mechanism which is detailed in this section.
+`SAGA GIS <http://www.saga-gis.org/>`_ provides a comprehensive set of geoscientific methods and spatial algorithms. The optional SAGA GIS support is available since `ZOO-Project 1.5 <http://zoo-project.org>`__. It allows to execute the `SAGA Modules <http://www.saga-gis.org/saga_module_doc/2.1.4/index.html>`_ directly as ZOO WPS Services thanks to a :ref:`kernel_index` specific internal mechanism which is detailed in this section.
 .. note::
    |saga| `SAGA GIS <https://www.orfeo-toolbox.org>`__ is the System for Automated Geoscientific Analyses. Learn more on official `website <http://www.saga-gis.org/en/index.html>`__.
+   |saga| `SAGA GIS <http://www.saga-gis.org/>`__ is the System for Automated Geoscientific Analyses. Learn more on official `website <http://www.saga-gis.org/en/index.html>`__.
 …
    * latest `ZOO-Kernel <http://zoo-project.org/trac/browser/trunk/zoo-project/zoo-kernel>`_ trunk version
+   * SAGA GIS (`SAGA-GIS 2.1.4  <http://saga-gis.org>`_ )
+   * libLAS-1.2 (`LibLAS-1.2  <https://github.com/libLAS/libLAS-1.2>`_ )
+   * `SAGA GIS  <http://saga-gis.org>`_  (7.2.0)
 Installation steps
 ...........................
+.. Note:: These installation steps were successfully tested on Ubuntu 14.4 LTS
+Download lastest ZOO-Kernel code from SVN.
+.. code-block:: guess
+    svn checkout http://svn.zoo-project.org/svn/trunk/zoo-kernel zoo-kernel
+Then compile ZOO-Kernel using the needed configuration options as shown bellow:
+Compile ZOO-Kernel using the configuration options as shown bellow:
 .. code-block:: guess
 …
      cd zoo-kernel
      autoconf
      ./configure  --with-saga=/usr/local/
+     ./configure  --with-saga=/usr/local/ --with-saga-version=7
      make
+And copy the newly created zoo_loader.cgi to ``/usr/lib/cgi-bin`` :
+And copy the newly created zoo_loader.cgi to ``/usr/lib/cgi-bin``.
+.. note::
+    The ``--with-saga-version`` option let you set the major
+    version number of SAGA-GIS.
 .. code-block:: guess
 …
 ****************************
+Building the `saga2zcfg
+<http://zoo-project.org/trac/browser/trunk/thirds/otb2zcfg >`_ utility is required to activate the available SAGA-GIS Modules as WPS Services. This can be done using the following command:
+Building the
+`saga2zcfg <http://zoo-project.org/trac/browser/trunk/thirds/saga2zcfg>`_
+utility is required to activate the available SAGA-GIS Modules as WPS
+Services. This can be done using the following command:
 .. code-block:: guess

trunk/docs/services/howtos.rst

-                      r794
+                      r917
+  }
+R
+----------
+ZOO API
+*********
+For using the R language from the ZOO-Project, you have first to copy
+``minimal.r`` in the same directory as the ZOO-Kernel.
+The ZOO-API is available from a R script and provide access to a
+global zoo environment which contains both static variables and also
+the dictionaries for outputs and conf:
+:int zoo[["SERVICE_SUCCEEDED"]]:
+   Value to return in case your service end successfully.
+:int zoo[["SERVICE_FAILED"]]:
+   Value to retrun in case of failure.
+The ZOO-API provides the following functions:
+:string ZOOTranslate(String s):
+   This function call the internal ZOO-Kernel function responsible for
+   searching a translation of ``s`` in the zoo-services dictionary.
+:void ZOOUpdateStatus(ZMaps conf,String pourcent):
+   This function call the updateStatus ZOO-Kernel function responsible
+   for updating the status of the running service (only usefull when
+   the service has been called asynchronously).
+R ZCFG requirements
+**********************************
+.. Note:: For each Service provided by your ZOO R Services Provider,
+          the ZCFG File must be named the same as the R function name
+          (it is case-sensitive).
+The ZCFG file should contain the following :
+serviceType
+   R
+serviceProvider
+    The name of the R file to use as a ZOO Service Provider. For instance, if your
+    script, located in the same directory as your ZOO Kernel, was named ``my_module.r`` then
+    you should use ``my_module.r``.
+R Data Structure used
+********************************
+The three parameters of the function are passed to the R function as
+R dictionaries.
+The specificity of the R language make that it was easier to use
+global variales than passing parameters by reference as we do in
+other progamming languages. It is the reason why you will have to
+access outpus by using the global variable as for the main
+configuration dictionary.
+Sample ZOO R Services Provider
+******************************************
+.. code-block:: javascript
+    source("minimal.r")
+    hellor <- function(a,b,c) {
+        # Set the result
+        zoo[["outputs"]][["Result"]][["value"]] <<- ZOOTranslate(paste("Hello",b[["S"]][["value"]],"from the R World!",sep=" "))
+        # Return SERVICE_SUCCEEDEED
+        return(zoo[["SERVICE_SUCCEEDEED"]])
+    }

trunk/thirds/otb2zcfg/otb2zcfg.cxx

-                      r783
+                      r917
   std::cout << "    </Supported>" << std::endl;
   std::cout << "    <Supported>" << std::endl;
+  std::cout << "     mimeType = application/json" << std::endl;
+  std::cout << "     encoding = utf-8" << std::endl;
+  std::cout << "    </Supported>" << std::endl;
+  std::cout << "    <Supported>" << std::endl;
   std::cout << "     mimeType = application/zip" << std::endl;
   std::cout << "    </Supported>" << std::endl;
+}
 void printOutputImage(){
+void printOutputImage(ImagePixelType pt){
   std::cout << "   <LiteralData>" << std::endl;
   std::cout << "    dataType = string" << std::endl;
   std::cout << "    <Default>" << std::endl;
+  std::cout << "     value = float" << std::endl;
+  std::cout << "     AllowedValues = uint8,uint16,int16n,int32,int32,float,double" << std::endl;
+  // Check for the default pixel type
+  switch(pt){
+  case ImagePixelType_uint8:
+    std::cout << "     value = uint8" << std::endl;
+    break;
+  case ImagePixelType_int16:
+    std::cout << "     value = int16" << std::endl;
+    break;
+  case ImagePixelType_uint16:
+    std::cout << "     value = uint16" << std::endl;
+    break;
+  case ImagePixelType_int32:
+    std::cout << "     value = int32" << std::endl;
+    break;
+  case ImagePixelType_uint32:
+    std::cout << "     value = uint8" << std::endl;
+    break;
+  case ImagePixelType_double:
+    std::cout << "     value = uint8" << std::endl;
+    break;
+  default:
+    std::cout << "     value = float" << std::endl;
+    break;
+  }
+  std::cout << "     AllowedValues = uint8,uint16,int16,int32,int32,float,double" << std::endl;
   std::cout << "    </Default>" << std::endl;
   std::cout << "   </LiteralData>" << std::endl;
+}
 void printOutputComplexImage(){
+void printOutputComplexImage(ComplexImagePixelType pt){
   std::cout << "   <LiteralData>" << std::endl;
   std::cout << "    dataType = string" << std::endl;
   std::cout << "    <Default>" << std::endl;
+  std::cout << "     value = cfloat" << std::endl;
+  // Check for the default pixel type
+  switch(pt){
+  case ComplexImagePixelType_double:
+    std::cout << "     value = cdouble" << std::endl;
+    break;
+  default:
+    std::cout << "     value = cfloat" << std::endl;
+    break;
+  }
   std::cout << "     AllowedValues = cfloat,cdouble" << std::endl;
   std::cout << "    </Default>" << std::endl;
 …
+          }
           else{
+            if(type == ParameterType_OutputImage)
+              printOutputImage();
+            if(type == ParameterType_OutputImage){
+              printOutputImage(m_Application->GetParameterOutputImagePixelType(paramKey));
+            }
             else{
               if(type == ParameterType_ComplexOutputImage){
                 printOutputComplexImage();
+                printOutputComplexImage(m_Application->GetParameterComplexOutputImagePixelType(paramKey));
               }else{
                 std::cout << "   <ComplexData>" << std::endl;
 …
           std::string s=m_Application->GetParameterDescription(paramKey);
           if(s.length()>0){
+            s=ReplaceAll(ReplaceAll(s,std::string("\n"),std::string("")),std::string("\t"),std::string(""));
             std::cout << "   Title = " << s << std::endl;
             std::cout << "   Abstract = " << s << std::endl;

trunk/thirds/saga2zcfg/saga2zcfg.c

-                      r703
+                      r917
 #include <api_core.h>
 #include <module_library.h>
+#include <saga_api.h>
 int Callback(TSG_UI_Callback_ID ID, CSG_UI_Parameter &Param_1, CSG_UI_Parameter &Param_2){
 …
   static bool g_bShow_Messages = false;
   SG_Set_UI_Callback(Get_Callback());
+#if SAGA_MAJOR_VERSION == 2
   int n = SG_Get_Module_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
+  if( SG_Get_Module_Library_Manager().Get_Count() <= 0 ){
+  if( SG_Get_Module_Library_Manager().Get_Count() <= 0 )
+#else
+  int n = SG_Get_Tool_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
+  if( SG_Get_Tool_Library_Manager().Get_Count() <= 0 )
+#endif
+  {
     fprintf(stderr,"could not load any tool library");
     return -2;
+  }
+  for(int i=0;i<SG_Get_Module_Library_Manager().Get_Count();i++){
+#if SAGA_MAJOR_VERSION == 2
+  for(int i=0;i<SG_Get_Module_Library_Manager().Get_Count();i++)
+#else
+  for(int i=0;i<SG_Get_Tool_Library_Manager().Get_Count();i++)
+#endif
+    {
+#if SAGA_MAJOR_VERSION == 2
     CSG_Module_Library * library=SG_Get_Module_Library_Manager().Get_Library(i);
+#else
+    CSG_Tool_Library * library=SG_Get_Tool_Library_Manager().Get_Library(i);
+#endif
     int lc=library->Get_Count();
     if(!library->Get_Library_Name().Contains("io_")) {
       for(int j=0;j<lc;j++){
+#if SAGA_MAJOR_VERSION == 2
         CSG_Module * module=library->Get_Module(j);
+#else
+        CSG_Tool * module=library->Get_Tool(j);
+#endif
         if(module!=NULL && !module->needs_GUI() /*&& !module->is_Interactive()*/ ){
           mkdir(library->Get_Library_Name().b_str(),0755);
           FILE *stdout1=fopen((library->Get_Library_Name()+"/"+module->Get_ID()+".zcfg").b_str(),"w+");
           fprintf(stdout1,"[%d]\n",j);
 …
+            }
+            else if(CSG_String(param->Get_Type_Identifier()).is_Same_As(CSG_String("date"),true)){
+              printBasicMetadata(stdout1,param,false,true,true);
+              fprintf(stdout1,"  <LiteralData>\n");
+              fprintf(stdout1,"   dataType = date\n");
+              fprintf(stdout1,"   <Default/>\n");
+              fprintf(stdout1,"  </LiteralData>\n");
+            }
             else if(CSG_String(param->Get_Type_Identifier()).is_Same_As(CSG_String("range"),true)){
 …
               CSG_Parameter_Range *range=param->asRange();
               fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
               fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->Get_Data())->Get_LoVal());
+#else
+              //fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->asDataObject())->Get_Min());
+#endif
               fprintf(stdout1,"   </Default>\n");
               fprintf(stdout1,"  </LiteralData>\n");
 …
               fprintf(stdout1,"   dataType = float\n");
               fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
               fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->Get_Data())->Get_HiVal());
+#else
+              //fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->asDataObject())->Get_Max());
+#endif
               fprintf(stdout1,"   </Default>\n");
               fprintf(stdout1,"  </LiteralData>\n");
 …
                 fprintf(stdout1,"   dataType = string\n");
                 fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
                 if( !param->Get_Data()->Get_Default().is_Empty() ){
                   fprintf(stdout1,"    value = %s\n",param->Get_Data()->Get_Default().b_str());
+                }
+#else
+                if( !param->Get_Default().is_Empty() ){
+                  fprintf(stdout1,"    value = %s\n",param->Get_Default().b_str());
+                }
+#endif
                 fprintf(stdout1,"   </Default>\n");
                 fprintf(stdout1,"  </LiteralData>\n");
 …
                 fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
                 if( !param->Get_Data()->Get_Default().is_Empty() ){
                   fprintf(stdout1,"    value = %s\n",param->Get_Data()->Get_Default().b_str());
+                }
+#else
+                if( !param->Get_Default().is_Empty() ){
+                  fprintf(stdout1,"    value = %s\n",param->Get_Default().b_str());
+                }
+#endif
                 if(param->asValue()->has_Minimum() && param->asValue()->has_Maximum()){
                   fprintf(stdout1,"    rangeMin = %f\n",param->asValue()->Get_Minimum());
 …
                 fprintf(stdout1,"   dataType = bool\n");
                 fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
                 if( !param->Get_Data()->Get_Default().is_Empty() ){
                   fprintf(stdout1,"    value = %s\n",(param->Get_Data()->Get_Default().Contains("0")?"false":"true"));
+                }
+#else
+                if( !param->Get_Default().is_Empty() ){
+                  fprintf(stdout1,"    value = %s\n",(param->Get_Default().Contains("0")?"false":"true"));
+                }
+#endif
                 fprintf(stdout1,"   </Default>\n");
                 fprintf(stdout1,"  </LiteralData>\n");
 …
+                  }
                   fprintf(stdout1,"   <Default>\n");
+#if SAGA_MAJOR_VERSION == 2
                   if( !param->Get_Data()->Get_Default().is_Empty() ){
                     fprintf(stdout1,"    value = %s\n",CSG_String(choice->Get_Item(atoi(param->Get_Data()->Get_Default()))).b_str());
+                  }
+#else
+                  if( !param->Get_Default().is_Empty() ){
+                    fprintf(stdout1,"    value = %s\n",CSG_String(choice->Get_Item(atoi(param->Get_Default()))).b_str());
+                  }
+#endif
                   fprintf(stdout1,"   </Default>\n");
                   fprintf(stdout1,"  </LiteralData>\n");

trunk/zoo-project/HISTORY.txt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-                      r889
+                      r917
  */
+#include "service.h"
 #include "response_print.h"
 #include "request_parser.h"
 …
 #else
 #include "cpl_vsi.h"
+#endif
+#ifdef USE_CALLBACK
+#include "service_callback.h"
 #endif
 …
+    }
     if(prefix!=NULL){
       char* tmp0=strdup(serv->name);
+      char* tmp0=zStrdup(serv->name);
       free(serv->name);
       serv->name=(char*)malloc((strlen(prefix)+strlen(tmp0)+1)*sizeof(char));
 …
     nbNs++;
     currId=0;
     nsName[currId]=strdup(name);
+    nsName[currId]=zStrdup(name);
     usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
   }else{
 …
       nbNs++;
       currId=nbNs-1;
       nsName[currId]=strdup(name);
+      nsName[currId]=zStrdup(name);
       usedNs[currId]=xmlNewNs(nr,BAD_CAST url,BAD_CAST name);
+    }
 …
   if(soap!=NULL && strcasecmp(soap->value,"true")==0){
     int lNbNs=nbNs;
     nsName[lNbNs]=strdup("soap");
+    nsName[lNbNs]=zStrdup("soap");
     usedNs[lNbNs]=xmlNewNs(NULL,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
     nbNs++;
     xmlNodePtr nr = xmlNewNode(usedNs[lNbNs], BAD_CAST "Envelope");
     nsName[nbNs]=strdup("soap");
+    nsName[nbNs]=zStrdup("soap");
     usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2003/05/soap-envelope",BAD_CAST "soap");
     nbNs++;
     nsName[nbNs]=strdup("xsi");
+    nsName[nbNs]=zStrdup("xsi");
     usedNs[nbNs]=xmlNewNs(nr,BAD_CAST "http://www.w3.org/2001/XMLSchema-instance",BAD_CAST "xsi");
     nbNs++;
 …
+      }
       else{
-        nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
-        xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
         if(dcount==0){
           if(vid==0){
+            nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
+            xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
             xmlAddChild(nc2,nc4);
             xmlAddChild(nc1,nc2);
 …
       nc4 = xmlNewNode(ns_ows, BAD_CAST "Language");
       xmlAddChild(nc4,xmlNewText(BAD_CAST buff));
         if(vid==0)
           xmlAddChild(nc3,nc4);
         else
           xmlAddChild(nc1,nc4);
+      if(vid==0)
+        xmlAddChild(nc3,nc4);
+      else
+        xmlAddChild(nc1,nc4);
+    }
+  }
 …
     map* tmp=getMap(toto1->content,"serverAddress");
     if(tmp!=NULL){
       SERVICE_URL = strdup(tmp->value);
+      SERVICE_URL = zStrdup(tmp->value);
+    }
     else
       SERVICE_URL = strdup("not_defined");
+      SERVICE_URL = zStrdup("not_defined");
+  }
   else
     SERVICE_URL = strdup("not_defined");
+    SERVICE_URL = zStrdup("not_defined");
   for(j=0;j<nbSupportedRequests;j++){
 …
  * @return the generated wps:ProcessOfferings xmlNodePtr
  */
 void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xml,ns_xlink;
   xmlNodePtr n=NULL,nc1,nc2;
+  xmlNodePtr n=NULL,nc1,nc2,nc3;
   map* version=getMapFromMaps(m,"main","rversion");
   int vid=getVersionId(version->value);
 …
       limit=7;
+    }
+    nc3=NULL;
+    map* sType=getMap(serv->content,"serviceType");
     for(;i<limit;i+=2){
       if(capabilities[vid][i]==NULL)
 …
             xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST tmp1->value);
+        }
+        else
+          xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        else{
+          if(i==3 && vid==1 && sType!=NULL && strstr(sType->value,"HPC")!=NULL)
+            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
+          else
+            xmlNewNsProp(nc1,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        }
+      }
+    }
 …
     printDescription(nc1,ns_ows,serv->name,serv->content,vid);
     tmp1=serv->metadata;
+    while(tmp1!=NULL){
+      nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
+      xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
+      xmlAddChild(nc1,nc2);
+      tmp1=tmp1->next;
+    }
+    addMetadata(tmp1,doc,nc1,ns_ows,ns_xlink,vid);
+    tmp1=serv->additional_parameters;
+    int fromDb=-1;
+    map* test=getMap(serv->content,"fromDb");
+    if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+      fromDb=1;
+    addAdditionalParameters(tmp1,doc,nc1,ns_ows,ns_xlink,fromDb);
+    if(nc3!=NULL)
+      xmlAddChild(nc1,nc3);
     xmlAddChild(nc,nc1);
+  }
+}
 …
  * @param content the servive main content created from the zcfg file
  * @param vid the version identifier (0 for 1.0.0 and 1 for 2.0.0)
+ */
+void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid){
+ * @param serviceType string containing the current service type
+ */
+void attachAttributes(xmlNodePtr n,xmlNsPtr ns,map* content,int vid,map* serviceType){
   int limit=7;
   for(int i=1;i<limit;i+=2){
 …
+    }
     else{
       if(vid==0 && i>=2)
         xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+      if(i==3 && vid==1 && serviceType!=NULL && strstr(serviceType->value,"HPC")!=NULL)
+        xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST "async-execute dismiss");
       else
+        xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+    }
+        if(vid==0 && i>=2)
+          xmlNewProp(n,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+        else
+          xmlNewNsProp(n,ns,BAD_CAST capabilities[vid][i],BAD_CAST capabilities[vid][i+1]);
+    }
+  }
+}
+/**
+ * Add a Metadata node to any existing node.
+ * @param meta the map defining the additional parameters
+ * @param doc the XML document used
+ * @param nb the node to add the additional parameters
+ * @param ns_ows the OWS namespace
+ * @param ns_xlink the xlink namespace
+ * @param vid the version of WPS to use (0 for 1.0.0 and 1 for 2.0)
+ */
+void addMetadata(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int vid){
+  int hasTitle=-1;
+  int hasValue=-1;
+  xmlNodePtr nc1;
+  map* oMeta=meta;
+  int isAdditionalParameters=-1;
+  int level=0;
+  map* test=getMap(meta,"title");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"href");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"role");
+  if(test!=NULL)
+    level+=1;
+  if(count(oMeta)>level+1)
+    isAdditionalParameters=1;
+  char *ctitle=NULL;
+  while(meta!=NULL){
+    if(hasTitle<0)
+      if(isAdditionalParameters<0)
+        nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
+      else
+        if(hasValue<0)
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+    if(strncasecmp(meta->name,"title",5)==0 ||
+       strcasecmp(meta->name,"href")==0 ||
+       strcasecmp(meta->name,"role")==0 ){
+      int index=5;
+      if(strncasecmp(meta->name,"title",5)==0){
+        index=6;
+        hasTitle=1;
+        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
+          xmlAddChild(nc,nc1);
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+          free(ctitle);
+          ctitle=NULL;
+        }
+        if(ctitle==NULL){
+          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
+          snprintf(tmp,index,"%s",meta->name);
+          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
+          free(tmp);
+        }
+        if(ctitle!=NULL)
+          free(ctitle);
+        ctitle=zStrdup(meta->value);
+      }
+    }else{
+      xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
+      xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
+      xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
+      xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+      xmlAddChild(nc4,xmlNewText(BAD_CAST meta->value));
+      xmlAddChild(nc2,nc3);
+      xmlAddChild(nc2,nc4);
+      xmlAddChild(nc1,nc2);
+      hasTitle=-1;
+    }
+    meta=meta->next;
+    if(hasTitle<0){
+      hasValue=1;
+      if(isAdditionalParameters){
+        if(vid==0){
+          meta=NULL;
+          break;
+        }else
+          xmlAddChild(nc,nc1);
+      }
+    }
+  }
+  if(oMeta!=NULL && hasValue<0 && nc1!=NULL){
+    xmlAddChild(nc,nc1);
+  }
+}
+/**
+ * Add AdditionalParameters nodes to any existing node.
+ * @param meta the map defining the additional parameters
+ * @param doc the XML document used
+ * @param nb the node to add the additional parameters
+ * @param ns_ows the OWS namespace
+ * @param ns_xlink the xlink namespace
+ * @param fromDb 1 if the metadata has been extracted from the metadb,
+ * 0 otherwise
+ */
+void addAdditionalParameters(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int fromDb){
+  int hasTitle=-1;
+  int hasValue=-1;
+  int toAddAtEnd=-1;
+  int cnt=0;
+  xmlNodePtr* ncr=NULL;
+  xmlNodePtr nc1;
+  map* oMeta=meta;
+  int isAdditionalParameters=-1;
+  int level=0;
+  map* test=getMap(meta,"title");
+  map* otitle=getMap(meta,"title");
+  map* length=getMap(meta,"length");
+  int len=0;
+  char *ctitle=NULL;
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"href");
+  if(test!=NULL)
+    level+=1;
+  test=getMap(meta,"role");
+  if(test!=NULL)
+    level+=1;
+  if(count(oMeta)>level+1)
+    isAdditionalParameters=1;
+  while(meta!=NULL){
+    if(hasTitle<0 && hasValue<0){
+      nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+    }
+    if(strncasecmp(meta->name,"title",5)==0 ||
+       strcasecmp(meta->name,"href")==0 ||
+       strcasecmp(meta->name,"role")==0 ){
+      int index=5;
+      if(strncasecmp(meta->name,"title",5)==0){
+        index=6;
+        hasTitle=1;
+        if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
+          xmlNodePtr ncTmp = xmlDocCopyNodeList(doc,nc1);
+          xmlAddChild(nc,ncTmp);
+          xmlFreeNode(nc1);
+          toAddAtEnd=1;
+          cnt++;
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+          free(ctitle);
+          ctitle=NULL;
+        }
+        if(ctitle==NULL){
+          char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
+          snprintf(tmp,index,"%s",meta->name);
+          xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
+          free(tmp);
+        }
+        if(ctitle!=NULL)
+          free(ctitle);
+        ctitle=zStrdup(meta->value);
+      }else{
+        xmlNewNsProp(nc1,ns_xlink,BAD_CAST meta->name,BAD_CAST meta->value);
+      }
+    }else{
+      if(strncasecmp(meta->name,"length",6)!=0 && strncasecmp(meta->name,"fromDb",6)!=0){
+        xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
+        xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
+        xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
+        xmlAddChild(nc2,nc3);
+        if(fromDb<0){
+          char *mptr;
+          char* meta_values=strtok_r(meta->value,",",&mptr);
+          while(meta_values!=NULL){
+            xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+            xmlAddChild(nc4,xmlNewText(BAD_CAST meta_values));
+            xmlAddChild(nc2,nc4);
+            meta_values=strtok_r(NULL,",",&mptr);
+          }
+        }else{
+          xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+          xmlAddChild(nc4,xmlNewCDataBlock(doc,BAD_CAST meta->value,strlen(meta->value)));
+          xmlAddChild(nc2,nc4);
+        }
+        xmlAddChild(nc1,nc2);
+      }
+      hasTitle=-1;
+    }
+    meta=meta->next;
+    if(hasTitle<0){
+      //xmlAddChild(nc,nc1);
+      hasValue=1;
+    }/*else
+       if(ctitle!=NULL)
+       free(ctitle);*/
+  }
+  if(length!=NULL)
+    len=atoi(length->value);
+  if(otitle!=NULL)
+    len=1;
+  if(cnt<len){
+    xmlAddChild(nc,nc1);
+    free(ctitle);
+  }
+}
 …
  * @return the generated wps:ProcessOfferings xmlNodePtr
  */
 void printDescribeProcessForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printDescribeProcessForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xlink;
   xmlNodePtr n,nc1;
 …
   map* version=getMapFromMaps(m,"main","rversion");
   int vid=getVersionId(version->value);
+  int fromDb=-1;
+  map* serviceType=getMap(serv->content,"serviceType");
+  map* test=getMap(serv->content,"fromDb");
+  if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+    fromDb=1;
   n=nc;
 …
   if(vid==0){
     nc = xmlNewNode(NULL, BAD_CAST "ProcessDescription");
     attachAttributes(nc,ns,serv->content,vid);
+    attachAttributes(nc,ns,serv->content,vid,NULL);
+  }
   else{
 …
+      }
+    }
     attachAttributes(nc2,NULL,serv->content,vid);
+    attachAttributes(nc2,NULL,serv->content,vid,serviceType);
     map* level=getMap(serv->content,"level");
     if(level!=NULL && strcasecmp(level->value,"generic")==0)
 …
     tmp1=serv->metadata;
     while(tmp1!=NULL){
+      nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
+      xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
+      xmlAddChild(nc,nc1);
+      addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
       tmp1=tmp1->next;
+    }
 …
+    }
   }else{
+    tmp1=serv->metadata;
+    addMetadata(tmp1,doc,nc,ns_ows,ns_xlink,vid);
     addInheritedMetadata(nc,ns_ows,ns_xlink,reg,m,serv);
+    tmp1=serv->additional_parameters;
+    if(vid!=0)
+      addAdditionalParameters(tmp1,doc,nc,ns_ows,ns_xlink,fromDb);
+  }
 …
     if(vid==0){
       nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
       printFullDescription(1,e,"Input",ns,ns_ows,nc1,vid);
+      printFullDescription(doc,1,e,"Input",ns,ns_ows,nc1,vid,fromDb,NULL);
       xmlAddChild(nc,nc1);
+    }
     else{
       printFullDescription(1,e,"wps:Input",ns,ns_ows,nc,vid);
+      printFullDescription(doc,1,e,"wps:Input",ns,ns_ows,nc,vid,fromDb,NULL);
+    }
+  }
 …
   if(vid==0){
     nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
     printFullDescription(0,e,"Output",ns,ns_ows,nc1,vid);
+    printFullDescription(doc,0,e,"Output",ns,ns_ows,nc1,vid,fromDb,NULL);
     xmlAddChild(nc,nc1);
+  }
   else{
     printFullDescription(0,e,"wps:Output",ns,ns_ows,nc,vid);
+    printFullDescription(doc,0,e,"wps:Output",ns,ns_ows,nc,vid,fromDb,serviceType);
+  }
   if(vid==0)
 …
  * @param nc1 the XML node to use to add the created tree
  * @param vid the WPS version id (0 for 1.0.0, 1 for 2.0.0)
+ */
+void printFullDescription(int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid){
+ * @param fromDb 1 in case the metadata comes from the DB, -1 in other cases
+ * @param serviceType the serviceType found in the ZCFG file or the DB
+ */
+void printFullDescription(xmlDocPtr doc,int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid,int fromDb,const map* serviceType){
   xmlNsPtr ns1=NULL;
   if(vid==1)
 …
     int isAnyValue=1;
     nc2 = xmlNewNode(NULL, BAD_CAST type);
+    // Extract min/max Occurence information
     if(strstr(type,"Input")!=NULL){
       tmp1=getMap(e->content,"minOccurs");
 …
     if(e->format!=NULL){
+#ifdef USE_HPC
+    DEFAULT_OUT:
+#endif
       const char orderedFields[13][14]={
         "mimeType",
 …
       //Build the (Literal/Complex/BoundingBox)Data node
       if(strncmp(type,"Output",6)==0){
         if(strncasecmp(e->format,"LITERALDATA",strlen(e->format))==0)
+        if(strncasecmp(e->format,"LITERAL",7)==0)
           nc3 = xmlNewNode(ns1, BAD_CAST "LiteralOutput");
         else if(strncasecmp(e->format,"COMPLEXDATA",strlen(e->format))==0)
 …
                 strcmp(e->format,"BoundingBoxData")==0){
           datatype=2;
+          nc5 = xmlNewNode(NULL, BAD_CAST "Default");
+          if(vid==0)
+            nc5 = xmlNewNode(NULL, BAD_CAST "Default");
+          else{
+            xmlNodePtr nc6 = xmlNewNode(ns1, BAD_CAST "Format");
+            xmlNewProp(nc6,BAD_CAST "mimeType",BAD_CAST "text/xml");
+            xmlNewProp(nc6,BAD_CAST "default",BAD_CAST "true");
+            xmlAddChild(nc3,nc6);
+            nc5 = xmlNewNode(NULL, BAD_CAST "SupportedCRS");
+          }
+        }
         else{
 …
             while(token!=NULL){
               nc7 = xmlNewNode(ns_ows, BAD_CAST "Value");
               char *tmps=strdup(token);
+              char *tmps=zStrdup(token);
               tmps[strlen(tmps)]=0;
+              xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
+              nc8 = xmlNewText(BAD_CAST tmps);
+              xmlAddChild(nc7,nc8);
               free(tmps);
               xmlAddChild(nc6,nc7);
 …
                  strncasecmp(tmp1->name,"range",5)!=0){
                 if(datatype!=1){
+                  char *tmp2=zCapitalize1(tmp1->name);
+                  nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
+                  free(tmp2);
+                  if(datatype==2 && vid==1){
+                    nc9 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
+                    xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
+                  }
+                  else{
+                    char *tmp2=zCapitalize1(tmp1->name);
+                    nc9 = xmlNewNode(NULL, BAD_CAST tmp2);
+                    free(tmp2);
+                  }
+                }
                 else{
 …
                 xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
                 if(vid==0 || oI>=3){
+                  if(vid==0 || oI!=4)
+                    xmlAddChild(nc5,nc9);
+                  if(vid==0 || oI!=4){
+                    if(datatype==2 && vid==1)
+                      xmlAddChild(nc3,nc9);
+                    else
+                      xmlAddChild(nc5,nc9);
+                  }
                   if(oI==4 && vid==1){
                     xmlNewProp(nc9,BAD_CAST "default",BAD_CAST "true");
+                  }
+                }
+                else
+                  xmlFree(nc9);
+                else{
+                  xmlFreeNode(nc9);
+                }
                 if(strcasecmp(tmp1->name,"uom")==0)
                   hasUOM1=true;
                 hasUOM=true;
+              }else
+                tmp1=tmp1->next;
+              }
+            }
+        }
 …
           }else{
             if(hasUOM1==false && vid==0){
+              xmlFreeNode(nc5);
+              if(datatype==1)
+              if(nc5!=NULL)
+                xmlFreeNode(nc5);
+              if(datatype==1){
                 xmlFreeNode(nc4);
+              }
+            }
             else
+            else{
               xmlAddChild(nc3,nc5);
+            }
+          }
         }else{
+          xmlAddChild(nc3,nc5);
+          if(vid==0)
+            xmlAddChild(nc3,nc5);
+          else
+            xmlFreeNode(nc5);
+        }
         if(datatype!=1 && default1<0){
+        if(datatype==0 && default1<0){
           xmlFreeNode(nc5);
           if(datatype!=2)
+          if(datatype!=2){
             xmlFreeNode(nc4);
+          }
+        }
 …
               nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
               free(tmp2);
-              //xmlNewProp(nc9, BAD_CAST "default", BAD_CAST "true");
               xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
               xmlAddChild(nc5,nc9);
-              /*struct iotype * _ltmp=e->supported;
-                while(_ltmp!=NULL){
-                tmp1=getMap(_ltmp->content,"uom");
-                if(tmp1!=NULL){
-                char *tmp2=zCapitalize(tmp1->name);
-                nc9 = xmlNewNode(ns_ows, BAD_CAST tmp2);
-                free(tmp2);
-                xmlAddChild(nc9,xmlNewText(BAD_CAST tmp1->value));
-                xmlAddChild(nc5,nc9);
+                }
-                _ltmp=_ltmp->next;
-                }*/
+            }
+          }
 …
         xmlNsPtr ns_xlink=usedNs[xlinkId];
+        while(metadata!=NULL){
+          nc6=xmlNewNode(ns_ows, BAD_CAST "Metadata");
+          xmlNewNsProp(nc6,ns_xlink,BAD_CAST metadata->name,BAD_CAST metadata->value);
+          xmlAddChild(nc2,nc6);
+          metadata=metadata->next;
+        }
+        addMetadata(metadata,doc,nc2,ns_ows,ns_xlink,vid);
+        if(vid!=0)
+          addAdditionalParameters(e->additional_parameters,doc,nc2,ns_ows,ns_xlink,fromDb);
+      }
       _tmp=e->supported;
       if(_tmp==NULL && datatype!=1)
+      if(_tmp==NULL && datatype==0)
         _tmp=e->defaults;
 …
                strcasecmp(tmp1->name,"extension")!=0){
               if(datatype!=1){
+                char *tmp2=zCapitalize1(tmp1->name);
+                nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
+                free(tmp2);
+                if(datatype==2 && vid==1){
+                  nc6 = xmlNewNode(ns, BAD_CAST "SupportedCRS");
+                }
+                else{
+                  char *tmp2=zCapitalize1(tmp1->name);
+                  nc6 = xmlNewNode(NULL, BAD_CAST tmp2);
+                  free(tmp2);
+                }
+              }
               else{
 …
+              }
               if(vid==0 || oI>=3){
+                if(vid==0 || oI!=4)
+                  xmlAddChild(nc5,nc6);
+                else
+                  xmlFree(nc6);
+                if(vid==0 || oI!=4){
+                  if(datatype==2 && vid==1)
+                    xmlAddChild(nc3,nc6);
+                  else
+                    xmlAddChild(nc5,nc6);
+                }
+                else{
+                  xmlFreeNode(nc6);
+                }
+              }
+              else
+                xmlFree(nc6);
+              else{
+                xmlFreeNode(nc6);
+              }
+            }
             tmp1=tmp1->next;
 …
+            }
             else{
+              xmlAddChild(nc3,nc5);
+              if(datatype!=2)
+                xmlAddChild(nc3,nc5);
+            }
           }else{
             if(datatype!=1)
+            if(datatype==2 && vid==0)
               xmlAddChild(nc3,nc5);
+          }
 …
+          }
           else
+            if(datatype!=1)
+            if(datatype==0){
+              xmlFreeNode(nc4);
               xmlAddChild(nc3,nc5);
+            }
         _tmp=_tmp->next;
 …
       if(hasSupported==0){
         if(datatype==0 && vid!=0)
+        if(datatype==0 && vid!=0){
           xmlFreeNode(nc4);
+        }
         xmlFreeNode(nc5);
+      }
 …
+        }
         else{
+          xmlFreeNode(nc4);
           xmlAddChild(nc3,nc5);
+        }
 …
     }else{
       if(e->child!=NULL && vid!=0){
+        printFullDescription(in,e->child,type,ns,ns_ows,nc2,vid);
+      }
+    }
+        printFullDescription(doc,in,e->child,type,ns,ns_ows,nc2,vid,fromDb,NULL);
+      }
+    }
     if(e->child!=NULL && vid==0){
       elements* children=dupElements(e->child);
       elements* cursor=children;
       while(cursor!=NULL){
+        char* tmp=strdup(cursor->name);
+        free(cursor->name);
+        cursor->name=(char*)malloc((strlen(cursor->name)+strlen(e->name)+2)*sizeof(char));
+        sprintf(cursor->name,"%s.%s",e->name,tmp);
+        elements* ccursor=cursor;
+        char* tmp=zStrdup(ccursor->name);
+        free(ccursor->name);
+        ccursor->name=(char*)malloc((strlen(tmp)+strlen(e->name)+2)*sizeof(char));
+        sprintf(ccursor->name,"%s.%s",e->name,tmp);
         cursor=cursor->next;
+      }
+      printFullDescription(in,children,type,ns,ns_ows,nc2,vid);
+      xmlAddChild(nc1,nc2);
+      printFullDescription(doc,in,children,type,ns,ns_ows,nc1,vid,fromDb,serviceType);
       freeElements(&children);
       free(children);
+    }else
+      xmlAddChild(nc1,nc2);
+    }else{
+      if(nc2!=NULL){
+        xmlAddChild(nc1,nc2);
+      }
+    }
     e=e->next;
+  }
 …
  * @param outputs the outputs generated by the service
  */
 void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
+void printProcessResponse(maps* m,map* request, int pid,service* serv,const char* service,int status,maps* inputs,maps* outputs){
   xmlNsPtr ns,ns_ows,ns_xlink;
   xmlNodePtr nr,n,nc,nc1=NULL,nc3;
 …
   char stored_path[1024];
   memset(stored_path,0,1024);
   if(vid==0){
     char tmp[256];
 …
+    }
+  }
   /**
    * Display the process output only when requested !
 …
     maps* mcursor=outputs;
     elements* scursor=serv->outputs;
     map* testResponse=getMap(request,"RawDataOutput");
+    map* testResponse=getMap(request,"RawDataOutput");
     if(testResponse==NULL)
       testResponse=getMap(request,"ResponseDocument");
     while(mcursor!=NULL){
+    while(mcursor!=NULL){
       map* tmp0=getMap(mcursor->content,"inRequest");
       scursor=getElements(serv->outputs,mcursor->name);
       if(scursor!=NULL){
         if(testResponse==NULL || tmp0==NULL){
+      scursor=getElements(serv->outputs,mcursor->name);
+      if(scursor!=NULL){
+        if(testResponse==NULL || tmp0==NULL){
           if(vid==0)
             printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
 …
+        }
         else
+          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){
+          if(tmp0!=NULL && strncmp(tmp0->value,"true",4)==0){
             if(vid==0)
               printIOType(doc,nc,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
             else
               printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
+          }
+          }
       }else
         /**
 …
           printIOType(doc,n,ns,ns_ows,ns_xlink,scursor,mcursor,"Output",vid);
       mcursor=mcursor->next;
+    }
+    }
     if(vid==0)
       xmlAddChild(n,nc);
+  }
+  }
   if(vid==0 &&
      hasStoredExecuteResponse==true
 …
 #endif
+  }
   printDocument(m,doc,pid);
 …
   else{
     /*
     dumpElements(e);
+      dumpElements(e);
     */
     return;
 …
        || strncasecmp(tmp->name,"SCHEMA",strlen(tmp->name))==0
        || strncasecmp(tmp->name,"UOM",strlen(tmp->name))==0)
     xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
+      xmlNewProp(nc1,BAD_CAST tmp->name,BAD_CAST tmp->value);
     tmp=tmp->next;
+  }
 …
  * @param type the type
  */
+void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){
+void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type,int vid){
   xmlNodePtr nc1,nc2,nc3;
   nc1=xmlNewNode(ns_wps, BAD_CAST type);
 …
     tmp=e->content;
   else
+    tmp=m->content;
+    tmp=m->content;
   if(vid==0){
     nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
 …
     xmlNewProp(nc1,BAD_CAST "id",BAD_CAST (e!=NULL?e->name:m->name));
+  }
   // IO type nested outputs
   if(m->child!=NULL){
+  if(m->child!=NULL){
     maps* curs=m->child;
     elements* ecurs=getElements(e,(e!=NULL?e->name:m->name));
     ecurs=ecurs->child;
     while(curs!=NULL){
+    while(curs!=NULL/* && ecurs!=NULL*/){
       ecurs=getElements(ecurs,(curs->name));
       map* inRequest=getMap(curs->content,"inRequest");
 …
+    }
+  }
   else{
+  else{
     map *tmpMap=getMap(m->content,"Reference");
     if(tmpMap==NULL){
+    if(tmpMap==NULL){
       nc2=xmlNewNode(ns_wps, BAD_CAST "Data");
       if(e!=NULL && e->format!=NULL){
         if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
           nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
+      if(e!=NULL && e->format!=NULL){
+                  if (strncasecmp(e->format, "LiteralOutput", strlen(e->format)) == 0)
+                          nc3 = xmlNewNode(ns_wps, BAD_CAST "LiteralData");
         else
           if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
 …
             nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
           else
             nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
+      }
       else {
         map* tmpV=getMapFromMaps(m,"format","value");
+            nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
+      }
+      else {
+        map* tmpV=getMapFromMaps(m,"format","value");
         if(tmpV!=NULL)
           nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
 …
           nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
+      }
       tmp=m->content;
+      tmp=m->content;
       while(tmp!=NULL){
         if(strcasecmp(tmp->name,"mimeType")==0 ||
 …
            strcasecmp(tmp->name,"schema")==0 ||
            strcasecmp(tmp->name,"datatype")==0 ||
+           strcasecmp(tmp->name,"uom")==0) {
+           strcasecmp(tmp->name,"uom")==0) {
           if(vid==0)
             xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
 …
+          }
+        }
         if(vid==0)
           xmlAddChild(nc2,nc3);
         tmp=tmp->next;
+        tmp=tmp->next;
+      }
       if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0) {
 …
+        }
+      }
+      else {
+        if(e!=NULL)
+          tmp=getMap(e->defaults->content,"mimeType");
+      else {
+                  //if (e != NULL) {
+                  if (e != NULL && e->defaults != NULL) { // knut: add extra NULL pointer check in case user omits <Default> block in config file
+                          tmp = getMap(e->defaults->content, "mimeType");
+                  }
         else
+          tmp=NULL;
+          tmp=NULL;
         map* tmp1=getMap(m->content,"encoding");
         map* tmp2=getMap(m->content,"mimeType");
 …
              strstr(tmp2->value, "json") != NULL ||            //    (will not be parsed by XML reader)
              strstr(tmp2->value, "ecmascript") != NULL
            ) {
+             ) {
             xmlAddChild((vid==0?nc3:nc2),xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
+          }
 …
             if (strstr(tmp2->value, "xml") != NULL ||                 // if XML-based format
                 // include for backwards compatibility,
               // although correct mime type is ...kml+xml:
+                // although correct mime type is ...kml+xml:
                 strstr(tmp2->value, "google-earth.kml") != NULL
                 ) {
 …
   else
     exceptionCode="501 Internal Server Error";
+  tmp=getMapFromMaps(m,"lenv","status_code");
+  if(tmp!=NULL)
+    exceptionCode=tmp->value;
   if(m!=NULL){
     map *tmpSid=getMapFromMaps(m,"lenv","sid");
 …
     tmp=getMapArray(s,"text",cnt);
+    if(tmp==NULL)
+      tmp=getMapArray(s,"message",cnt);
     nc1 = xmlNewNode(ns, BAD_CAST "ExceptionText");
     if(tmp!=NULL){
       xmlNodePtr txt=xmlNewText(BAD_CAST tmp->value);
       xmlAddChild(nc1,txt);
+      if(cnt==0)
+        setMapInMaps(m,"lenv","message",tmp->value);
+    }
     else{
 …
 void outputResponse(service* s,maps* request_inputs,maps* request_outputs,
                     map* request_inputs1,int cpid,maps* m,int res){
 #ifdef DEBUG
   dumpMaps(request_inputs);
   dumpMaps(request_outputs);
   fprintf(stderr,"printProcessResponse\n");
 #endif
+#endif
   map* toto=getMap(request_inputs1,"RawDataOutput");
   int asRaw=0;
 …
   if(tmpSess!=NULL){
     map *_tmp=getMapFromMaps(m,"lenv","cookie");
+    maps *tmps=getMaps(m,"senv");
     char* sessId=NULL;
     if(_tmp!=NULL){
       printf("Set-Cookie: %s; HttpOnly\r\n",_tmp->value);
+      map *_tmp1=getMapFromMaps(m,"senv","ecookie_length");
+      if(_tmp1!=NULL){
+        int len=atoi(_tmp1->value);
+        int cnt=0;
+        for(cnt=0;cnt<len;cnt++){
+          map* _tmp2=getMapArray(tmps->content,"ecookie",cnt);
+          if(_tmp2!=NULL)
+            printf("Set-Cookie: %s; HttpOnly\r\n",_tmp2->value);
+        }
+      }
       printf("P3P: CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\"\r\n");
       char session_file_path[100];
 …
       else
         sprintf(session_file_path,"%s",strstr(_tmp->value,"=")+1);
       sessId=strdup(session_file_path);
+      sessId=zStrdup(session_file_path);
     }else{
       maps* t=getMaps(m,"senv");
 …
       while(p!=NULL){
         if(strstr(p->name,"ID")!=NULL){
           sessId=strdup(p->value);
+          sessId=zStrdup(p->value);
           break;
+        }
 …
+    }
+  }
   if(res==SERVICE_FAILED){
     map *lenv;
 …
     return;
+  }
+  if(res!=SERVICE_SUCCEEDED){
+    printProcessResponse(m,request_inputs1,cpid,
+                         s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
+                         request_inputs,
+                         request_outputs);
+    return;
+  }
   map *tmp1=getMapFromMaps(m,"main","tmpPath");
   if(asRaw==0){
 …
     map* usid=getMapFromMaps(m,"lenv","usid");
     int itn=0;
+    int error=-1;
   NESTED0:
     while(tmpI!=NULL){
 …
 #endif
       map *gfile=getMap(tmpI->content,"generated_file");
       char *file_name;
+      char *file_name=NULL;
       if(gfile!=NULL){
         gfile=getMap(tmpI->content,"expected_generated_file");
 …
         readGeneratedFile(m,tmpI->content,gfile->value);
         file_name=zStrdup((gfile->value)+strlen(tmp1->value));
+      }
+      }
       toto=getMap(tmpI->content,"asReference");
 #ifdef USE_MS
+      if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
+      map* geodatatype=getMap(tmpI->content,"geodatatype");
+      if(toto!=NULL && strcasecmp(toto->value,"true")==0 &&
+         (testMap==NULL ||
+          strncasecmp(testMap->value,"true",4)!=0 ||
+          (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0) ) )
 #else
       if(toto!=NULL && strcasecmp(toto->value,"true")==0)
+        if(toto!=NULL && strcasecmp(toto->value,"true")==0)
 #endif
+        {
+          elements* in=getElements(s->outputs,tmpI->name);
+          if(in==NULL && s->outputs->child!=NULL){
+            in=getElements(s->outputs->child,tmpI->name);
+          {
+            elements* in=getElements(s->outputs,tmpI->name);
+            if(in==NULL && s->outputs->child!=NULL){
+              in=getElements(s->outputs->child,tmpI->name);
+            }
+            char *format=NULL;
+            if(in!=NULL && in->format!=NULL){
+              format=in->format;
+            }else
+              format=(char*)"LiteralData";
+            if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
+              addToMap(tmpI->content,"extension","xml");
+              addToMap(tmpI->content,"mimeType","text/xml");
+              addToMap(tmpI->content,"encoding","UTF-8");
+              addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
+            }
+            char *file_path=NULL;
+            if(gfile==NULL) {
+              map *ext=getMap(tmpI->content,"extension");
+              char file_ext[32];
+              if( ext != NULL && ext->value != NULL) {
+                strncpy(file_ext, ext->value, 32);
+              }
+              else {
+                // Obtain default file extension (see mimetypes.h).
+                // If the MIME type is not recognized, txt is used as the default extension
+                map* mtype=getMap(tmpI->content,"mimeType");
+                getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
+              }
+              if(file_name!=NULL)
+                free(file_name);
+              file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
+              sprintf(file_name,"ZOO_DATA_%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
+              itn++;
+              file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
+              sprintf(file_path,"%s/%s",tmp1->value,file_name);
+              FILE *ofile=fopen(file_path,"wb");
+              if(ofile==NULL){
+                char tmpMsg[1024];
+                sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
+                errorException(m,tmpMsg,"InternalError",NULL);
+                free(file_name);
+                free(file_path);
+                return;
+              }
+              toto=getMap(tmpI->content,"value");
+              if(toto==NULL){
+                char tmpMsg[1024];
+                sprintf(tmpMsg,_("No value found for the requested output %s."),tmpI->name);
+                errorException(m,tmpMsg,"InternalError",NULL);
+                fclose(ofile);
+                free(file_name);
+                free(file_path);
+                return;
+              }
+              if(strcasecmp(format,"BoundingBoxData")!=0){
+                map* size=getMap(tmpI->content,"size");
+                if(size!=NULL && toto!=NULL)
+                  fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
+                else
+                  if(toto!=NULL && toto->value!=NULL)
+                    fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
+              }else{
+                printBoundingBoxDocument(m,tmpI,ofile);
+              }
+              fclose(ofile);
+            }
+            map *tmp2=getMapFromMaps(m,"main","tmpUrl");
+            map *tmp3=getMapFromMaps(m,"main","serverAddress");
+            char *file_url=NULL;
+            if(strncasecmp(tmp2->value,"http://",7)==0 ||
+               strncasecmp(tmp2->value,"https://",8)==0){
+              file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
+              sprintf(file_url,"%s/%s",tmp2->value,file_name);
+            }else{
+              file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
+              sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
+            }
+            addToMap(tmpI->content,"Reference",file_url);
+            if(file_name!=NULL)
+              free(file_name);
+            if(file_url!=NULL)
+              free(file_url);
+            file_name=NULL;
+          }
+          char *format=NULL;
+          if(in!=NULL && in->format!=NULL){
+            format=in->format;
+          }else
+            format=(char*)"LiteralData";
+          if(format!=NULL && strcasecmp(format,"BoundingBoxData")==0){
+            addToMap(tmpI->content,"extension","xml");
+            addToMap(tmpI->content,"mimeType","text/xml");
+            addToMap(tmpI->content,"encoding","UTF-8");
+            addToMap(tmpI->content,"schema","http://schemas.opengis.net/ows/1.1.0/owsCommon.xsd");
+#ifdef USE_MS
+        else{
+          if(testMap!=NULL){
+            map* nbFeatures;
+            setMapInMaps(m,"lenv","state","out");
+            setReferenceUrl(m,tmpI);
+            nbFeatures=getMap(tmpI->content,"nb_features");
+            geodatatype=getMap(tmpI->content,"geodatatype");
+            if((nbFeatures!=NULL && atoi(nbFeatures->value)==0) ||
+               (geodatatype!=NULL && strcasecmp(geodatatype->value,"other")==0)){
+              error=1;
+              res=SERVICE_FAILED;
+            }
+          }
+          if(gfile==NULL) {
+            map *ext=getMap(tmpI->content,"extension");
+            char *file_path;
+            char file_ext[32];
+            if( ext != NULL && ext->value != NULL) {
+              strncpy(file_ext, ext->value, 32);
+            }
+            else {
+              // Obtain default file extension (see mimetypes.h).
+              // If the MIME type is not recognized, txt is used as the default extension
+              map* mtype=getMap(tmpI->content,"mimeType");
+              getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
+            }
+            file_name=(char*)malloc((strlen(s->name)+strlen(usid->value)+strlen(file_ext)+strlen(tmpI->name)+45)*sizeof(char));
+            sprintf(file_name,"%s_%s_%s_%d.%s",s->name,tmpI->name,usid->value,itn,file_ext);
+            itn++;
+            file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
+            sprintf(file_path,"%s/%s",tmp1->value,file_name);
+            FILE *ofile=fopen(file_path,"wb");
+            if(ofile==NULL){
+              char tmpMsg[1024];
+              sprintf(tmpMsg,_("Unable to create the file \"%s\" for storing the %s final result."),file_name,tmpI->name);
+              errorException(m,tmpMsg,"InternalError",NULL);
+              free(file_name);
+              free(file_path);
+              return;
+            }
+            free(file_path);
+            toto=getMap(tmpI->content,"value");
+            if(strcasecmp(format,"BoundingBoxData")!=0){
+              map* size=getMap(tmpI->content,"size");
+              if(size!=NULL && toto!=NULL)
+                fwrite(toto->value,1,(atoi(size->value))*sizeof(char),ofile);
+              else
+                if(toto!=NULL && toto->value!=NULL)
+                  fwrite(toto->value,1,strlen(toto->value)*sizeof(char),ofile);
+            }else{
+              printBoundingBoxDocument(m,tmpI,ofile);
+            }
+            fclose(ofile);
+          }
+          map *tmp2=getMapFromMaps(m,"main","tmpUrl");
+          map *tmp3=getMapFromMaps(m,"main","serverAddress");
+          char *file_url;
+          if(strncasecmp(tmp2->value,"http://",7)==0 ||
+             strncasecmp(tmp2->value,"https://",8)==0){
+            file_url=(char*)malloc((strlen(tmp2->value)+strlen(file_name)+2)*sizeof(char));
+            sprintf(file_url,"%s/%s",tmp2->value,file_name);
+          }else{
+            file_url=(char*)malloc((strlen(tmp3->value)+strlen(tmp2->value)+strlen(file_name)+3)*sizeof(char));
+            sprintf(file_url,"%s/%s/%s",tmp3->value,tmp2->value,file_name);
+          }
+          addToMap(tmpI->content,"Reference",file_url);
+          free(file_name);
+          free(file_url);
+        }
+#ifdef USE_MS
+      else{
+        if(testMap!=NULL){
+          setReferenceUrl(m,tmpI);
+        }
+      }
+#endif
+        }
+#endif
+      if(file_name!=NULL){
+        free(file_name);
+        file_name=NULL;
+      }
       tmpI=tmpI->next;
+    }
 …
       if(tmpI!=NULL)
         goto NESTED0;
+    }
+    }
 #ifdef DEBUG
     fprintf(stderr,"SERVICE : %s\n",s->name);
     dumpMaps(m);
+#endif
+    if(error<0)
+      printProcessResponse(m,request_inputs1,cpid,
+                           s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
+                           request_inputs,
+                           request_outputs);
+    else{
+      maps* tmpMaps=getMaps(m,"lenv");
+#ifdef USE_CALLBACK
+      invokeCallback(m,NULL,NULL,7,0);
 #endif
+    printProcessResponse(m,request_inputs1,cpid,
+                         s, s->name,res,  // replace serviceProvider with serviceName in stored response file name
+                         request_inputs,
+                         request_outputs);
+      printExceptionReportResponse(m,tmpMaps->content);
+    }
+  }
   else{

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

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

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

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

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

-                      r889
+                      r917
  * Author : Gérald FENOY
+ *
  * Copyright (c) 2015 GeoLabs SARL
+ * Copyright (c) 2015-2019 GeoLabs SARL
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
 …
 #include <ctime>
 #include <chrono>
+#ifdef WIN32
 #include <process.h>
+#endif
 #if defined(_MSC_VER) && _MSC_VER < 1800
 …
     fprintf(stderr," * CONTENT [%s] \n",tmp->name);
     dumpMap(tmp->content);
+    fprintf(stderr," * CHILD [%s] \n",tmp->name);
+    dumpMaps(tmp->child);
+    if(tmp->child!=NULL){
+      fprintf(stderr," * CHILD [%s] \n",tmp->name);
+      dumpMaps(tmp->child);
+      fprintf(stderr," * /CHILD [%s] \n",tmp->name);
+    }
     tmp=tmp->next;
+  }
 …
     fflush(file);
     tmp=tmp->next;
-    cnt++;
     if(limit>=0 && cnt==limit)
       tmp=NULL;
+    cnt++;
+  }
   fflush(file);
 …
   fflush(file);
   fclose(file);
+}
+/**
+ * Create a new iotype*
+ *
+ * @return a pointer to the allocated iotype
+ */
+iotype* createIoType(){
+  iotype* io=(iotype*)malloc(IOTYPE_SIZE);
+  io->content=NULL;
+  io->next=NULL;
+  return io;
+}
 …
  * Count number of map in a map
+ *
  * @param m the maps to count
+ * @param m the map to count
  * @return number of map in a map
  */
 int count(map* m){
   map* tmp=m;
+  int c=0;
+  while(tmp!=NULL){
+    c++;
+    tmp=tmp->next;
+  }
+  return c;
+}
+/**
+ * Count number of maps in a maps
+ *
+ * @param m the maps to count
+ * @return number of maps in a maps
+ */
+int maps_length(maps* m){
+  maps* tmp=m;
   int c=0;
   while(tmp!=NULL){
 …
     if(tmp->metadata!=NULL)
       free(tmp->metadata);
+    freeMap(&tmp->additional_parameters);
+    if(tmp->additional_parameters!=NULL)
+      free(tmp->additional_parameters);
     if(tmp->format!=NULL)
       free(tmp->format);
+    freeElements(&tmp->child);
     if(tmp->child!=NULL){
-      freeElements(&tmp->child);
       free(tmp->child);
+    }
     freeIOType(&tmp->defaults);
     if(tmp->defaults!=NULL)
+    if(tmp->defaults!=NULL){
+      freeIOType(&tmp->defaults);
       free(tmp->defaults);
     freeIOType(&tmp->supported);
+    }
     if(tmp->supported!=NULL){
+      freeIOType(&tmp->supported);
       free(tmp->supported);
+    }
     freeElements(&tmp->next);
     if(tmp->next!=NULL)
+    if(tmp->next!=NULL){
+      freeElements(&tmp->next);
       free(tmp->next);
+  }
+    }
+  }
+}
+/**
+ * Allocate memory for a service.
+ * Require to call free after calling this function.
+ *
+ * @return the service
+ */
+service* createService(){
+  service *s1 = (service *) malloc (SERVICE_SIZE);
+  s1->name=NULL;
+  s1->content=NULL;
+  s1->metadata=NULL;
+  s1->additional_parameters=NULL;
+  s1->inputs=NULL;
+  s1->outputs=NULL;
+  return s1;
+}
 /**
  * Free allocated memory of a service.
  * Require to call free on e after calling this function.
+ * Require to be invoked for every createService call.
+ *
  * @param s the service to free
 …
     if(tmp->metadata!=NULL)
       free(tmp->metadata);
+    freeMap(&tmp->additional_parameters);
+    if(tmp->additional_parameters!=NULL)
+      free(tmp->additional_parameters);
     freeElements(&tmp->inputs);
     if(tmp->inputs!=NULL)
 …
  */
 void addToMap(map* m,const char* n,const char* v){
   if (m != NULL) { // knut: add NULL-pointer check
     if(hasKey(m,n)==false){
       map* _cursor=m;
       while(_cursor->next!=NULL){
         _cursor=_cursor->next;
+      }
       _cursor->next=createMap(n,v);
+    }
     else{
       map *tmp=getMap(m,n);
       if(tmp->value!=NULL)
         free(tmp->value);
       tmp->value=zStrdup(v);
+    }
+  }
+    if (m != NULL) { // knut: add NULL-pointer check
+        if (hasKey(m, n) == false) {
+            map* _cursor = m;
+            while (_cursor->next != NULL) {
+                _cursor = _cursor->next;
+            }
+            _cursor->next = createMap(n, v);
+        }
+        else {
+            map *tmp = getMap(m, n);
+            if (tmp->value != NULL)
+                free(tmp->value);
+            tmp->value = zStrdup(v);
+        }
+    }
+}
 …
  */
 map* addToMapWithSize(map* m,const char* n,const char* v,int size){
+  char sin[128];
+  char sname[10]="size";
+  map *tmp;
   if(hasKey(m,n)==false){
     map* _cursor=m;
 …
+    }
+  }
-  char sname[10]="size";
   if(strlen(n)>5)
     sprintf(sname,"size_%s",n+6);
   map *tmp=getMap(m,n);
+  tmp=getMap(m,n);
   if(tmp->value!=NULL)
     free(tmp->value);
 …
     memmove(tmp->value,v,size*sizeof(char));
   tmp->value[size]=0;
-  char sin[128];
   sprintf(sin,"%d",size);
   addToMap(m,sname,sin);
 …
+    }
     else{
-#ifdef DEBUG
-      fprintf(stderr,"_CURSOR\n");
-      dumpMap(_cursor);
-#endif
-      while(_cursor->next!=NULL)
-        _cursor=_cursor->next;
       map* tmp1=getMap(*mo,tmp->name);
       if(tmp1==NULL){
+        while(_cursor->next!=NULL)
+          _cursor=_cursor->next;
         _cursor->next=createMap(tmp->name,tmp->value);
+      }
 …
     _cursor=*mo;
     tmp=tmp->next;
-#ifdef DEBUG
-    fprintf(stderr,"MO\n");
-    dumpMap(*mo);
-#endif
+  }
+}
 …
   map* size=getMap(in,"size");
   map *lout=*out;
+  map *tmpVin,*tmpVout;
   if(size!=NULL && pos>0){
     char tmp[11];
 …
     size=getMap(in,tmp);
     sprintf(tmp,"value_%d",pos);
     map* tmpVin=getMap(in,tmp);
     map* tmpVout=getMap(lout,tmp);
+    tmpVin=getMap(in,tmp);
+    tmpVout=getMap(lout,tmp);
     free(tmpVout->value);
     tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
 …
   }else{
     if(size!=NULL){
       map* tmpVin=getMap(in,"value");
       map* tmpVout=getMap(lout,"value");
+      tmpVin=getMap(in,"value");
+      tmpVout=getMap(lout,"value");
       free(tmpVout->value);
       tmpVout->value=(char*)malloc((atoi(size->value)+1)*sizeof(char));
 …
   map* size=getMap(in,"size");
   map* length=getMap(in,"length");
+  map* toload=getMap(in,"to_load");
+  if(toload!=NULL && strcasecmp(toload->value,"false")==0){
+#ifdef DEBUG
+    fprintf(stderr,"NO LOAD %s %d \n",__FILE__,__LINE__);
+#endif
+    return ;
+  }
   if(length!=NULL){
     int len=atoi(length->value);
 …
   maps* res=NULL;
   if(_cursor!=NULL){
+    map* mc=_cursor->content;
+    maps* mcs=_cursor->child;
     res=createMaps(_cursor->name);
-    map* mc=_cursor->content;
     if(mc!=NULL){
       addMapToMap(&res->content,mc);
       loadMapBinaries(&res->content,mc);
+    }
-    maps* mcs=_cursor->child;
     if(mcs!=NULL){
       res->child=dupMaps(&mcs);
 …
+    }
     else{
+      maps* tmp1=getMaps(*mo,tmp->name);
       while(_cursor->next!=NULL)
         _cursor=_cursor->next;
-      maps* tmp1=getMaps(*mo,tmp->name);
       if(tmp1==NULL){
         _cursor->next=dupMaps(&tmp);
 …
 map* getMapArray(map* m,const char* key,int index){
   char tmp[1024];
+  map* tmpMap;
   if(index>0)
     sprintf(tmp,"%s_%d",key,index);
 …
   fprintf(stderr,"** KEY %s\n",tmp);
 #endif
   map* tmpMap=getMap(m,tmp);
+  tmpMap=getMap(m,tmp);
 #ifdef DEBUG
   if(tmpMap!=NULL)
 …
 void setMapArray(map* m,const char* key,int index,const char* value){
   char tmp[1024];
+  map* tmpSize;
   if(index>0){
+    map* len=getMap(m,"length");
     sprintf(tmp,"%s_%d",key,index);
-    map* len=getMap(m,"length");
     if((len!=NULL && atoi(len->value)<index+1) || len==NULL){
       char tmp0[5];
 …
+    }
+  }
   else
+  else{
     sprintf(tmp,"%s",key);
+  map* tmpSize=getMapArray(m,"size",index);
+    addToMap(m,"length","1");
+  }
+  tmpSize=getMapArray(m,"size",index);
   if(tmpSize!=NULL && strncasecmp(key,"value",5)==0){
+    map* ptr=getMapOrFill(&m,tmp,(char *)"");
 #ifdef DEBUG
     fprintf(stderr,"%s\n",tmpSize->value);
 #endif
-    map* ptr=getMapOrFill(&m,tmp,(char *)"");
     free(ptr->value);
     ptr->value=(char*)malloc((atoi(tmpSize->value)+1)*sizeof(char));
 …
   else
     addToMap(m,tmp,value);
+}
+/**
+ * Add a key and an integer value to an existing map array.
+ *
+ * @param m the map to add the KVP
+ * @param n the key to add
+ * @param index the index of the MapArray
+ * @param v the corresponding value to add
+ */
+void addIntToMapArray(map* m,const char* n,int index,const int v){
+  char svalue[10];
+  sprintf(svalue,"%d",v);
+  setMapArray(m,n,index,svalue);
+}
 …
   maps* tmp=mi;
   maps* _cursor=getMaps(*mo,tmp->name);
-  if(_cursor==NULL)
-    return -1;
-  map* tmpLength=getMap(_cursor->content,"length");
   char tmpLen[10];
   int len=1;
-  if(tmpLength!=NULL){
-    len=atoi(tmpLength->value);
+  }
   char *tmpV[14]={
     (char*)"size",
 …
     (char*)"isCached",
     (char*)"LowerCorner",
     (char*)"UpperCorner"
+    (char*)"UpperCorner"
   };
+  int i=0;
+  map* tmpLength;
+  if(_cursor==NULL)
+    return -1;
+  tmpLength=getMap(_cursor->content,"length");
+  if(tmpLength!=NULL){
+    len=atoi(tmpLength->value);
+  }
   sprintf(tmpLen,"%d",len+1);
   addToMap(_cursor->content,"length",tmpLen);
-  int i=0;
   for(i=0;i<14;i++){
     map* tmpVI=getMap(tmp->content,tmpV[i]);
 …
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;
   res->format=NULL;
   res->defaults=NULL;
 …
  * @return a pointer to the allocated elements
  */
 elements* createElements(char* name){
+elements* createElements(const char* name){
   elements* res=(elements*)malloc(ELEMENTS_SIZE);
   res->name=zStrdup(name);
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;
   res->format=NULL;
   res->defaults=NULL;
 …
   elements* tmp=e;
   while(tmp!=NULL){
+    iotype* tmpio=tmp->defaults;
+    int ioc=0;
     fprintf(stderr,"ELEMENT [%s]\n",tmp->name);
     fprintf(stderr," > CONTENT [%s]\n",tmp->name);
 …
     fprintf(stderr," > METADATA [%s]\n",tmp->name);
     dumpMap(tmp->metadata);
+    fprintf(stderr," > ADDITIONAL PARAMETERS [%s]\n",tmp->name);
+    dumpMap(tmp->additional_parameters);
     fprintf(stderr," > FORMAT [%s]\n",tmp->format);
-    iotype* tmpio=tmp->defaults;
-    int ioc=0;
     while(tmpio!=NULL){
       fprintf(stderr," > DEFAULTS [%s] (%i)\n",tmp->name,ioc);
 …
   int i;
   while(tmp!=NULL){
+    map* mcurs=tmp->content;
+    int ioc=0;
+    iotype* tmpio;
     for(i=0;i<2+(4*level);i++)
       fprintf(stderr," ");
     fprintf(stderr,"%s:\n",tmp->name);
-    map* mcurs=tmp->content;
     while(mcurs!=NULL){
       for(i=0;i<4+(4*level);i++)
 …
         dumpElementsAsYAML(tmp->child,level+1);
+    }
+    iotype* tmpio=tmp->defaults;
+    int ioc=0;
+    tmpio=tmp->defaults;
     while(tmpio!=NULL){
       for(i=0;i<6+(4*level);i++)
 …
   elements* cursor=e;
   elements* tmp=NULL;
   if(cursor!=NULL){
+  if(cursor!=NULL && cursor->name!=NULL){
 #ifdef DEBUG
     fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
 …
 #endif
     tmp=(elements*)malloc(ELEMENTS_SIZE);
     tmp->name=zStrdup(e->name);
+    tmp->name=zStrdup(cursor->name);
     tmp->content=NULL;
     addMapToMap(&tmp->content,e->content);
+    addMapToMap(&tmp->content,cursor->content);
     tmp->metadata=NULL;
+    addMapToMap(&tmp->metadata,e->metadata);
+    if(e->format!=NULL)
+      tmp->format=zStrdup(e->format);
+    addMapToMap(&tmp->metadata,cursor->metadata);
+    tmp->additional_parameters=NULL;
+    addMapToMap(&tmp->additional_parameters,cursor->additional_parameters);
+    if(cursor->format!=NULL)
+      tmp->format=zStrdup(cursor->format);
     else
       tmp->format=NULL;
     if(e->defaults!=NULL){
+    if(cursor->defaults!=NULL){
       tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
       tmp->defaults->content=NULL;
       addMapToMap(&tmp->defaults->content,e->defaults->content);
+      addMapToMap(&tmp->defaults->content,cursor->defaults->content);
       tmp->defaults->next=NULL;
 #ifdef DEBUG
 …
     }else
       tmp->defaults=NULL;
+    if(e->supported!=NULL){
+    if(cursor->supported!=NULL && cursor->supported->content!=NULL){
+      iotype *tmp2=cursor->supported->next;
       tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
       tmp->supported->content=NULL;
       addMapToMap(&tmp->supported->content,e->supported->content);
+      addMapToMap(&tmp->supported->content,cursor->supported->content);
       tmp->supported->next=NULL;
+      iotype *tmp2=e->supported->next;
+      while(tmp2!=NULL){
+            while(tmp2!=NULL){
         addMapToIoType(&tmp->supported,tmp2->content);
 #ifdef DEBUG
 …
     else
       tmp->child=NULL;
+    tmp->next=dupElements(cursor->next);
+    if(cursor->next!=NULL)
+      tmp->next=dupElements(cursor->next);
+    else
+      tmp->next=NULL;
+  }
   return tmp;
 …
   elements* tmp=e;
   if(*m==NULL){
     *m=dupElements(tmp);
+    (*m)=dupElements(tmp);
   }else{
     addToElements(&(*m)->next,tmp);
 …
     fprintf(stderr,"CONTENT MAP\n");
     dumpMap(s->content);
+    fprintf(stderr,"CONTENT METADATA\n");
+    if(s->metadata!=NULL)
+      fprintf(stderr,"CONTENT METADATA\n");
     dumpMap(s->metadata);
+    if(s->additional_parameters!=NULL)
+      fprintf(stderr,"CONTENT AdditionalParameters\n");
+    dumpMap(s->additional_parameters);
+  }
   if(s->inputs!=NULL){
 …
   res->metadata=NULL;
   addMapToMap(&res->metadata,s->metadata);
+  res->additional_parameters=NULL;
+  addMapToMap(&res->additional_parameters,s->additional_parameters);
   res->inputs=dupElements(s->inputs);
   res->outputs=dupElements(s->outputs);
 …
   registry* p=r;
   while(p!=NULL){
+    services* s=p->content;
     fprintf(stderr,"%s \n",p->name);
-    services* s=p->content;
     s=p->content;
     while(s!=NULL){
 …
  */
 void inheritance(registry *r,service** s){
+  service* ls=*s;
+  map *profile,*level;
   if(r==NULL)
     return;
+  service* ls=*s;
+  if(ls->content==NULL)
+  if(ls==NULL || ls->content==NULL)
     return;
   map* profile=getMap(ls->content,"extend");
   map* level=getMap(ls->content,"level");
+  profile=getMap(ls->content,"extend");
+  level=getMap(ls->content,"level");
   if(profile!=NULL&&level!=NULL){
     service* s1;
 …
   memset(tmp,0,1024*10*10);
   while(tm!=NULL){
+    map* tc=tm->content;
     if(i>=10)
       break;
 …
     strcpy(tmp[i][j],tm->name);
     j++;
-    map* tc=tm->content;
     while(tc!=NULL){
       if(j>=30)
 …
  * @return true if map has a value or false if value is missing/empty/NULL
  */
 bool nonempty( map* map ) {
     return ( map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0 );
+}
 /**
  * Verify that a particular map value exists in a maps
+bool nonempty(map* map) {
+        return (map != NULL && map->value != NULL && strlen(map->value) > 0 && strcmp(map->value, "NULL") != 0);
+}
+/**
+ * Verify that a particular map value exists in a maps
  * data structure, and obtain that value
+ *
 …
  * @param node name of maps node to search
  * @param key name of map node to find
  * @param address to the map* if it exists, otherwise NULL
+ * @param kvp address to the map* if it exists, otherwise NULL
  * @return true if map has a value or false if value is missing/NULL
+ */
+bool hasvalue( maps* source, const char* node, const char* key, map** kvp ) {
+    *kvp = getMapFromMaps(source, node, key);
+    return ( *kvp != NULL && (*kvp)->value != NULL &&
+             strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0 );
+ *
+ * @note The map assigned to kvp is owned by the source maps
+ */
+bool hasvalue(maps* source, const char* node, const char* key, map** kvp) {
+        *kvp = getMapFromMaps(source, node, key);
+        return (*kvp != NULL && (*kvp)->value != NULL &&
+                strlen((*kvp)->value) > 0 && strcmp((*kvp)->value, "NULL") != 0);
+}
 …
+ *
  * @param conf reference to configuration maps
  * @param service name of service
+ * @param service name of service
  * @param exc WPSException code
  * @param message exception text (default: exception text in WPS specification)
  */
 void setErrorMessage( maps*& conf, const char* service, WPSException exc, const char* message ) {
   if (message == NULL) {
     message = WPSExceptionText[exc];
+  }
         size_t len = strlen( service ) + strlen(": ") + strlen( message ) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
         char* msg = (char*) malloc( len * sizeof(char) );
+void setErrorMessage(maps*& conf, const char* service, WPSException exc, const char* message) {
+        if (message == NULL) {
+                message = WPSExceptionText[exc];
+        }
+        size_t len = strlen(service) + strlen(": ") + strlen(message) + strlen(": ") + strlen(WPSExceptionCode[exc]) + 16;
+        char* msg = (char*)malloc(len * sizeof(char));
         if (msg != NULL) {
                 snprintf( msg, len*sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc] );
                 setMapInMaps( conf, "lenv", "message", msg );
                 free( msg );
+        }
+                snprintf(msg, len * sizeof(char), "\n%s: %s: %s\n", service, message, WPSExceptionCode[exc]);
+                setMapInMaps(conf, "lenv", "message", msg);
+                free(msg);
+        }
+}
 void logMessage(const char* source, const char* function, int line, const char* file, const char* message) { //, const char* source, const char* function, int line) {
   size_t msglen = 512;
   const char empty[] = "";
   FILE* log;
   // system time, process time [nanoseconds]
   unsigned long long sys_t, proc_t;
   // processor time consumed by the program:
   clock_t t = clock();
   // system time:
   std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
   std::time_t now_t = std::chrono::system_clock::to_time_t( now );
   std::tm* tm = localtime( &now_t );
+        size_t msglen = 512;
+        const char empty[] = "";
+        FILE* log;
+        // system time, process time [nanoseconds]
+        unsigned long long sys_t, proc_t;
+        // processor time consumed by the program:
+        clock_t t = clock();
+        // system time:
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+        std::time_t now_t = std::chrono::system_clock::to_time_t(now);
+        std::tm* tm = localtime(&now_t);
         char* str = asctime(tm);
   str[strlen(str)-1] = '\0'; // remove newline
   sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
   //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
   proc_t = t;
   if ( message != NULL ) {
      msglen += strlen(message);
+  }
   else {
     message = empty;
+  }
   //getLastErrorMessage(); // cgiScriptName
   char* text = (char*) malloc( sizeof(char)*msglen );
+  snprintf( text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n",
     _getpid(), source, line, function, str, sys_t, proc_t, message ); // __FILE__ __LINE__ __func__ //
   if ( file != NULL && (log = fopen( file, "a+" )) != NULL ) {
     fputs( text, log );
     fclose( log );
+  }
   else {
     #ifdef MSG_LOG_FILE
     if ( (log = fopen( MSG_LOG_FILE, "a+" )) != NULL ) {
       fputs( text, log );
       fclose( log );
+    }
     #endif
+  }
   if ( text != NULL ) free( text );
+        str[strlen(str) - 1] = '\0'; // remove newline
+        sys_t = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
+        //proc_t = (unsigned long long)(1.0e9*t/CLOCKS_PER_SEC);
+        proc_t = t;
+        if (message != NULL) {
+                msglen += strlen(message);
+        }
+        else {
+                message = empty;
+        }
+        //getLastErrorMessage(); // cgiScriptName
+        char* text = (char*)malloc(sizeof(char)*msglen);
+        snprintf(text, msglen, "pid: %d %s line %d %s() %s systime: %lld ns ticks: %lld %s\n",
+                zGetpid(), source, line, function, str, sys_t, proc_t, message); // __FILE__ __LINE__ __func__ //
+        if (file != NULL && (log = fopen(file, "a+")) != NULL) {
+                fputs(text, log);
+                fclose(log);
+        }
+        else {
+#ifdef MSG_LOG_FILE
+                if ((log = fopen(MSG_LOG_FILE, "a+")) != NULL) {
+                        fputs(text, log);
+                        fclose(log);
+                }
+#endif
+        }
+        if (text != NULL) free(text);
+}
 …
 // zooLog;
 // zooLogMsg(NULL, getLastErrorMessage());
+// zooLogMsg(log.txt, getLastErrorMessage());
+#ifdef WIN32
+#ifndef USE_MS
+char *strcasestr (char const *a, char const *b)
+  {
+    char *x = zStrdup (a);
+    char *y = zStrdup (b);
+      x = _strlwr (x);
+      y = _strlwr (y);
+    char *pos = strstr (x, y);
+    char *ret = pos == NULL ? NULL : (char *) (a + (pos - x));
+      free (x);
+      free (y);
+      return ret;
+  };
+#else
+   ;
+#endif
+#endif
+// zooLogMsg("log.txt", getLastErrorMessage());

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

-                      r889
+                      r917
  * Author : Gérald FENOY
+ *
  * Copyright (c) 2009-2015 GeoLabs SARL
+ * Copyright (c) 2009-2019 GeoLabs SARL
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
 …
 #endif
+ // knut: add bool if necessary
+#ifndef __cplusplus
+#ifndef WIN32
+#include <stdbool.h>
+#else
+typedef int bool;
+#define false 0
+#define true 1
+#endif
+#endif
+#ifndef __bool_true_false_are_defined
+#define __bool_true_false_are_defined 1
+#endif
 #ifdef WIN32
+#ifndef USE_MS
+ZOO_DLL_EXPORT char *strcasestr (char const *,char const *);
+#endif
+#endif
+// knut: add bool if necessary
+#ifndef __cplusplus
+  #ifndef WIN32
+    #include <stdbool.h>
+  #else
+    typedef int bool;
+    #define false 0
+    #define true 1
+  #endif
+#endif
+#ifndef __bool_true_false_are_defined
+  #define __bool_true_false_are_defined 1
+#endif
+#ifdef WIN32
+#define strtok_r strtok_s
 #define strncasecmp _strnicmp
 #define strcasecmp _stricmp
-#define strtok_r strtok_s
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
 #endif
-/* knut: see new definition of bool above
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#define false 0
-#define true 1
-#define bool int
-#endif
-*/
 #define zStrdup _strdup
 #define zMkdir _mkdir
+#define zGetpid _getpid
 #define zOpen _open
+#define zClose _close
+#define zUnlink _unlink
+#define zDup _dup
+#define zDup2 _dup2
 #define zWrite _write
 #define zSleep Sleep
 …
 static int zGettimeofday(struct ztimeval* tp, void* tzp)
+{
-  struct _timeb theTime;
   if (tp == 0) {

Open WPS platform

Legend:

trunk

trunk/docs/install/installation.rst

trunk/docs/kernel/configuration.rst

trunk/docs/kernel/index.rst

trunk/docs/kernel/mapserver.rst

trunk/docs/kernel/sagagis.rst

trunk/docs/services/howtos.rst

trunk/thirds/otb2zcfg/otb2zcfg.cxx

trunk/thirds/saga2zcfg/saga2zcfg.c

trunk/zoo-project/HISTORY.txt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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