Changeset 917


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

Merge prototype-v0 branch in trunk

Location:
trunk
Files:
1 deleted
67 edited
22 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/docs/install/installation.rst

    r809 r917  
    147147    <http://zoo-project.org/trac/browser/trunk/zoo-project/zoo-kernel/sql/schema.sql#L34>`_.
    148148
     149Metadata Database (Optional)
     150*****************************
     151
     152.. _zoo_create_metadb:
     153
     154It is possible to use a PostgreSQL database to store metadata
     155information about WPS Services. This support is optional and require
     156to be activated by using the ``--with-metadb=yes`` option.
     157
     158To create the database for storing the metadata informations about the
     159WPS Services, you may use the following command:
     160
     161.. code::
     162
     163    createdb zoo_metadb
     164    psql zoo_metadb -f zoo-project/zoo-kernel/sql/zoo_collectiondb.sql
     165
     166In case you want to convert an existing zcfg file then, you can use
     167the ``zcfg2sql`` tool from the command line. It can be found in
     168``thirds/zcfg2sql`` and can be build simply by running the ``make``
     169command. After compilation you only need to give it the path of the
     170zcfg file you want to obtain the SQL queries required to store the
     171metadata informations in the database rather than in zcfg file.
     172
     173For instance you may use the following command:
     174
     175.. code::
     176
     177    #Direct import in the zoo_metadb database
     178    ./zcfg2sql /Path/To/MyZCFGs/myService.zcfg | psql zoo_metadb
     179    #Create a SQL file for a futur import
     180    ./zcfg2sql /Path/To/MyZCFGs/myService.zcfg > myService.sql
     181
    149182
    150183
     
    154187If ``yaml.h`` file is not found in your ``/usr/include`` directory and
    155188``libyaml.so`` is not found in ``/usr/lib``, a ``--with-yaml`` option
    156 can be used to specify its location. For instance, if the headeer file
     189can be used to specify its location. For instance, if the header file
    157190lies in ``/usr/local/include`` and the shared library is located in
    158191``/usr/local/lib``, you may use the following command:
  • trunk/docs/kernel/configuration.rst

    r817 r917  
    9494   service providers, e.g., shared libraries with service implementations
    9595   (the ``serviceProvider`` parameter in the service configuration (.zcfg) file).   
     96 * ``memory``: (Optional) can take the value ``load`` to ensure that
     97   the value field of the inputs data will be filled by the ZOO-Kernel
     98   or ``protected`` to have only the ``cache_file`` filled.
     99
    96100
    97101.. warning::
    98102  The ``libPath`` parameter is currently only recognized by services implemented
    99103  in C/C++ or PHP, and may be moved to another section in future versions.
    100  
     104
     105
     106.. warning::
     107  Depending on the ``memory`` parameter the WPS Service will receive
     108  different fields (``value`` or ``cache_file``).
     109   
    101110In case you have activated the MapServer support, please refer to
    102111:ref:`this specific section <kernel-mapserver-main.cfg>`.
     
    264273    hosts=localhost,127.0.0.1
    265274
     275Optionaly, you can also define the shared url(s), meaning that even if
     276the ressource requires authentication to be accessed, this
     277authentifcation won't be used to define the name for storing the
     278file. Hence, two user with different authentication will use the same
     279file as it is considerated as shared. You can find bellow a sample
     280security section containing the shared parameter. In this example,
     281every requests to access the coverage using the url defined in the
     282shared parameter (``myHost/cgi-bin/WCS_Server``) will be shared
     283between users.
     284
     285.. code::
     286
     287    [security]
     288    attributes=Authorization,Cookie,User-Agent
     289    hosts=localhost,127.0.0.1
     290    shared=myHost/cgi-bin/WCS_Server
    266291
    267292.. _zoo_activate_db_backend:
     
    300325to setup the database.
    301326
     327
     328Database section
     329...............................
     330
     331The database section allows to configure the ZOO-Kernel to access the
     332metadata information about WPS Services by using a PostgreSQL database
     333in addition to the zcfg files.
     334
     335.. code-block:: guess
     336
     337        [metadb]
     338        dbname=zoo_metadb
     339        port=5432
     340        user=username
     341        host=127.0.0.1
     342        type=PG
     343
     344This will generate strings to be passed to GDAL to connect the
     345database server:
     346
     347.. code-block:: guess
     348   
     349    <type>:host=<host> port=<port>  user=<user> dbname=<dbname>
     350
     351
     352With the previous database section, it will give the following:
     353
     354.. code-block:: guess
     355
     356    PG:"dbname=zoo_metadb host=127.0.0.1 port=5432 user=username"
     357
     358Please refer to this `section <zoo_create_metadb>`_ to learn how
     359to setup the database.
     360
    302361Include section
    303362...............................
  • trunk/docs/kernel/index.rst

    r725 r917  
    1414   orfeotoolbox
    1515   sagagis
    16 
     16   hpc
  • trunk/docs/kernel/mapserver.rst

    r752 r917  
    7373   * `MapServer <http://mapserver/org>`__ version >= 6.0.1
    7474
    75 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).
    76 
    77 .. code-block:: guess
    78 
    79     cd <PREV_SVN_CO>
    80     svn checkout http://svn.zoo-project.org/svn/trunk/zoo-kernel zoo-kernel-ms
    81 
     75First 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).
     76
     77.. code-block:: guess
     78
     79    svn checkout http://svn.zoo-project.org/svn/trunk/ $PREV_SVN_CO
     80    cd $PREV_SVN_CO
     81   
    8282Then uncompress the MapServer archive (ie. ``mapserver-6.0.1.tar.bz2``) into ``/tmp/zoo-ms-src``, and compile it using the following command:
    8383
     
    9292     cp mapserv /usr/lib/cgi-bin
    9393
    94 Once done, compile ZOO-Kernel with MapServer support from the ``<PREV_SVN_CO>`` directory, using the following command:
    95 
    96 .. code-block:: guess
    97 
    98      cd zoo-kernel-ms
     94Once done, compile ZOO-Kernel with MapServer support from the ``$PREV_SVN_CO`` directory, using the following command:
     95
     96.. code-block:: guess
     97
     98     cd zoo-kernel
    9999     autoconf
    100100     ./configure --with-python --with-mapserver=/tmp/zoo-ms-src/mapserver-6.0.1
    101101     make
    102 
    103 You can then copy the new ZOO-Kernel to ``/usr/lib/cgi-bin`` directory, as follow:
    104 
    105 .. code-block:: guess
    106 
    107      cp zoo_loader.cgi /usr/lib/cgi-bin
     102     sudo make install
    108103
    109104
     
    119114      dataPath = /var/www/temp/
    120115      mapserverAddress=http://localhost/cgi-bin/mapserv
     116
     117You can also add the following lines to the ``[main]`` section, in case
     118you want to use a default style for Polygon, Lines and Points vector
     119layer.
     120
     121.. code-block:: guess
     122
     123      msStylePoly=STYLE COLOR 202 109 19 OUTLINECOLOR 105 105 105 WIDTH 3 END
     124      msStyleLine=STYLE OUTLINECOLOR 202 109 19 WIDTH 3 END
     125      msStylePoint=STYLE COLOR 202 109 19 OUTLINECOLOR 105 105 105 SYMBOL 0 SIZE 14 END
    121126
    122127The ``dataPath`` directory is mandatory and must belong to the Apache user.
     
    175180*************
    176181
     182You have different options to define the style of the layer created
     183using the data returned by your service.
     184
     185msStyle
     186+++++++
     187
    177188The optional ``msStyle`` parameter can also be used to define a custom MapServer style block (used for vector datasource only), as follow:
    178189
     
    181192     msStyle = STYLE COLOR 125 0 105 OUTLINECOLOR 0 0 0 WIDTH 3 END
    182193
    183 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.
    184 
    185 .. code-block:: guess
    186 
    187      msClassify = ....
     194msClassify
     195++++++++++
     196
     197If a WPS service outputs a one band raster file, then it is possible
     198to add a ``msClassify`` parameter and set it to ``true`` in the output
     199ComplexData ``<Default>`` or ``<Supported>`` nodes of its zcfg
     200file. This allows ZOO-Kernel to use its own default style definitions
     201in order to classify the raster using equivalent intervals. 
     202
     203.. code-block:: guess
     204
     205     msClassify = true
     206
     207
     208msInclude
     209+++++++++
     210
     211In case you want to use another layer which use the result of your
     212service, for instance to produce a `heatmap
     213<https://mapserver.org/output/kerneldensity.html>`_, then you can use
     214the
     215``msInclude`` and ``msLayer`` options in the output ``ComplexData``
     216``<Default>`` or ``<Supported>`` nodes of its zcfg file. You can see below an
     217example of use of this two options with the associated mapfile.
     218
     219.. code-block:: guess
     220
     221     msInclude = /var/data/template.map
     222     msLayer = heatmap
     223
     224You can find below a sample ``/var/data/template.map``:
     225
     226.. code-block:: guess
     227
     228     MAP
     229       SIZE 1000 500
     230       EXTENT -180 -90 180 90
     231       NAME "test heat"
     232       IMAGETYPE "png"
     233
     234       WEB
     235         METADATA
     236           "ows_srs" "epsg:4326  epsg:3857 epsg:900913"
     237           "ows_enable_request" "*"
     238         END # METADATA
     239       END # WEB
     240       
     241       PROJECTION
     242         "+init=epsg:4326"
     243       END # PROJECTION
     244
     245       LAYER
     246         NAME "heatmap" # Corresponding to the msLayer defined
     247         TYPE raster
     248         CONNECTIONTYPE kerneldensity
     249         CONNECTION "Result"
     250         STATUS on
     251         PROCESSING "RANGE_COLORSPACE=HSL"
     252         PROCESSING "KERNELDENSITY_RADIUS=20"
     253         PROCESSING "KERNELDENSITY_COMPUTE_BORDERS=ON"
     254         PROCESSING "KERNELDENSITY_NORMALIZATION=AUTO"
     255         OFFSITE 0 0 0
     256         CLASS
     257           STYLE
     258             COLORRANGE  "#0000ff00"  "#0000ffff"
     259             DATARANGE 0 32
     260           END # STYLE
     261           STYLE
     262             COLORRANGE  "#0000ffff"  "#ff0000ff"
     263             DATARANGE 32 255
     264           END # STYLE
     265         END # CLASS
     266       END # LAYER
     267       
     268       LAYER
     269         NAME "points"
     270         STATUS on
     271         TYPE POINT
     272         #DATA "/Library/WebServer/cache//ef76ee6642c1ea704e847e28120ba1ca.zca"
     273       END # LAYER
     274     END # MAPFILE
     275
     276
     277
    188278
    189279Example
     
    216306     useMapserver = true
    217307     asReference = true
    218      msClassify = ....
     308     msClassify = true
    219309    </Supported>
    220310
  • trunk/docs/kernel/sagagis.rst

    r725 r917  
    44======================
    55
    6 `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.
     6`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.
    77
    88.. note::
    99
    10    |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>`__.
     10   |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>`__.
    1111 
    1212
     
    2727
    2828   * latest `ZOO-Kernel <http://zoo-project.org/trac/browser/trunk/zoo-project/zoo-kernel>`_ trunk version
    29    * SAGA GIS (`SAGA-GIS 2.1.4  <http://saga-gis.org>`_ )
    30    * libLAS-1.2 (`LibLAS-1.2  <https://github.com/libLAS/libLAS-1.2>`_ )
     29   * `SAGA GIS  <http://saga-gis.org>`_  (7.2.0)
    3130
    3231Installation steps
    3332...........................
    3433
    35 .. Note:: These installation steps were successfully tested on Ubuntu 14.4 LTS
    36 
    37 Download lastest ZOO-Kernel code from SVN.
    38 
    39 .. code-block:: guess
    40 
    41     svn checkout http://svn.zoo-project.org/svn/trunk/zoo-kernel zoo-kernel
    42 
    43 Then compile ZOO-Kernel using the needed configuration options as shown bellow:
     34Compile ZOO-Kernel using the configuration options as shown bellow:
    4435
    4536.. code-block:: guess
     
    4738     cd zoo-kernel
    4839     autoconf
    49      ./configure  --with-saga=/usr/local/
     40     ./configure  --with-saga=/usr/local/ --with-saga-version=7
    5041     make
    5142
    52 And copy the newly created zoo_loader.cgi to ``/usr/lib/cgi-bin`` :
    53 
     43And copy the newly created zoo_loader.cgi to ``/usr/lib/cgi-bin``.
     44     
     45.. note::
     46   
     47    The ``--with-saga-version`` option let you set the major
     48    version number of SAGA-GIS. 
     49     
    5450.. code-block:: guess
    5551
     
    6258****************************
    6359
    64 Building the `saga2zcfg
    65 <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:
     60Building the
     61`saga2zcfg <http://zoo-project.org/trac/browser/trunk/thirds/saga2zcfg>`_
     62utility is required to activate the available SAGA-GIS Modules as WPS
     63Services. This can be done using the following command:
    6664
    6765.. code-block:: guess
  • trunk/docs/services/howtos.rst

    r794 r917  
    439439  }
    440440
     441
     442R
     443----------
     444
     445ZOO API
     446*********
     447
     448For using the R language from the ZOO-Project, you have first to copy
     449``minimal.r`` in the same directory as the ZOO-Kernel.
     450
     451The ZOO-API is available from a R script and provide access to a
     452global zoo environment which contains both static variables and also
     453the dictionaries for outputs and conf:
     454
     455:int zoo[["SERVICE_SUCCEEDED"]]:
     456   Value to return in case your service end successfully.
     457:int zoo[["SERVICE_FAILED"]]:
     458   Value to retrun in case of failure.
     459
     460The ZOO-API provides the following functions:
     461
     462:string ZOOTranslate(String s):
     463   This function call the internal ZOO-Kernel function responsible for
     464   searching a translation of ``s`` in the zoo-services dictionary.
     465
     466:void ZOOUpdateStatus(ZMaps conf,String pourcent):
     467   This function call the updateStatus ZOO-Kernel function responsible
     468   for updating the status of the running service (only usefull when
     469   the service has been called asynchronously).
     470
     471
     472R ZCFG requirements
     473**********************************
     474
     475.. Note:: For each Service provided by your ZOO R Services Provider,
     476          the ZCFG File must be named the same as the R function name
     477          (it is case-sensitive).
     478
     479The ZCFG file should contain the following :
     480
     481serviceType
     482   R
     483serviceProvider
     484    The name of the R file to use as a ZOO Service Provider. For instance, if your
     485    script, located in the same directory as your ZOO Kernel, was named ``my_module.r`` then
     486    you should use ``my_module.r``.
     487
     488
     489R Data Structure used
     490********************************
     491
     492The three parameters of the function are passed to the R function as
     493R dictionaries.
     494
     495The specificity of the R language make that it was easier to use
     496global variales than passing parameters by reference as we do in
     497other progamming languages. It is the reason why you will have to
     498access outpus by using the global variable as for the main
     499configuration dictionary.
     500
     501Sample ZOO R Services Provider
     502******************************************
     503
     504.. code-block:: javascript
     505
     506    source("minimal.r")
     507               
     508    hellor <- function(a,b,c) {
     509        # Set the result
     510        zoo[["outputs"]][["Result"]][["value"]] <<- ZOOTranslate(paste("Hello",b[["S"]][["value"]],"from the R World!",sep=" "))
     511        # Return SERVICE_SUCCEEDEED
     512        return(zoo[["SERVICE_SUCCEEDEED"]])
     513    }
     514
  • trunk/thirds/otb2zcfg/otb2zcfg.cxx

    r783 r917  
    9797  std::cout << "    </Supported>" << std::endl;
    9898  std::cout << "    <Supported>" << std::endl;
     99  std::cout << "     mimeType = application/json" << std::endl;
     100  std::cout << "     encoding = utf-8" << std::endl;
     101  std::cout << "    </Supported>" << std::endl;
     102  std::cout << "    <Supported>" << std::endl;
    99103  std::cout << "     mimeType = application/zip" << std::endl;
    100104  std::cout << "    </Supported>" << std::endl;
    101105}
    102106
    103 void printOutputImage(){
     107void printOutputImage(ImagePixelType pt){
    104108  std::cout << "   <LiteralData>" << std::endl;
    105109  std::cout << "    dataType = string" << std::endl;
    106110  std::cout << "    <Default>" << std::endl;
    107   std::cout << "     value = float" << std::endl;
    108   std::cout << "     AllowedValues = uint8,uint16,int16n,int32,int32,float,double" << std::endl;
     111  // Check for the default pixel type
     112  switch(pt){
     113  case ImagePixelType_uint8:
     114    std::cout << "     value = uint8" << std::endl;
     115    break;
     116  case ImagePixelType_int16:
     117    std::cout << "     value = int16" << std::endl;
     118    break;
     119  case ImagePixelType_uint16:
     120    std::cout << "     value = uint16" << std::endl;
     121    break;
     122  case ImagePixelType_int32:
     123    std::cout << "     value = int32" << std::endl;
     124    break;
     125  case ImagePixelType_uint32:
     126    std::cout << "     value = uint8" << std::endl;
     127    break;
     128  case ImagePixelType_double:
     129    std::cout << "     value = uint8" << std::endl;
     130    break;
     131  default:
     132    std::cout << "     value = float" << std::endl;
     133    break;
     134  }
     135  std::cout << "     AllowedValues = uint8,uint16,int16,int32,int32,float,double" << std::endl;
    109136  std::cout << "    </Default>" << std::endl;
    110137  std::cout << "   </LiteralData>" << std::endl;
    111138}
    112139
    113 void printOutputComplexImage(){
     140void printOutputComplexImage(ComplexImagePixelType pt){
    114141  std::cout << "   <LiteralData>" << std::endl;
    115142  std::cout << "    dataType = string" << std::endl;
    116143  std::cout << "    <Default>" << std::endl;
    117   std::cout << "     value = cfloat" << std::endl;
     144  // Check for the default pixel type
     145  switch(pt){
     146  case ComplexImagePixelType_double:
     147    std::cout << "     value = cdouble" << std::endl;
     148    break;
     149  default:
     150    std::cout << "     value = cfloat" << std::endl;
     151    break;
     152  }
    118153  std::cout << "     AllowedValues = cfloat,cdouble" << std::endl;
    119154  std::cout << "    </Default>" << std::endl;
     
    242277          }
    243278          else{
    244             if(type == ParameterType_OutputImage)
    245               printOutputImage();
     279            if(type == ParameterType_OutputImage){
     280              printOutputImage(m_Application->GetParameterOutputImagePixelType(paramKey));
     281            }
    246282            else{
    247283              if(type == ParameterType_ComplexOutputImage){
    248                 printOutputComplexImage();
     284                printOutputComplexImage(m_Application->GetParameterComplexOutputImagePixelType(paramKey));
    249285              }else{
    250286                std::cout << "   <ComplexData>" << std::endl;
     
    312348          std::string s=m_Application->GetParameterDescription(paramKey);
    313349          if(s.length()>0){
     350            s=ReplaceAll(ReplaceAll(s,std::string("\n"),std::string("")),std::string("\t"),std::string(""));
    314351            std::cout << "   Title = " << s << std::endl;
    315352            std::cout << "   Abstract = " << s << std::endl;
  • trunk/thirds/saga2zcfg/saga2zcfg.c

    r703 r917  
    55
    66#include <api_core.h>
    7 #include <module_library.h>
     7#include <saga_api.h>
    88
    99int Callback(TSG_UI_Callback_ID ID, CSG_UI_Parameter &Param_1, CSG_UI_Parameter &Param_2){
     
    144144  static bool g_bShow_Messages = false;
    145145  SG_Set_UI_Callback(Get_Callback());
     146#if SAGA_MAJOR_VERSION == 2
    146147  int n = SG_Get_Module_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
    147   if( SG_Get_Module_Library_Manager().Get_Count() <= 0 ){
     148  if( SG_Get_Module_Library_Manager().Get_Count() <= 0 )
     149#else
     150  int n = SG_Get_Tool_Library_Manager().Add_Directory(wxT(MODULE_LIBRARY_PATH),false);
     151  if( SG_Get_Tool_Library_Manager().Get_Count() <= 0 )
     152#endif
     153  {
    148154    fprintf(stderr,"could not load any tool library");
    149155    return -2;
    150156  }
    151157
    152   for(int i=0;i<SG_Get_Module_Library_Manager().Get_Count();i++){
     158#if SAGA_MAJOR_VERSION == 2
     159  for(int i=0;i<SG_Get_Module_Library_Manager().Get_Count();i++)
     160#else
     161  for(int i=0;i<SG_Get_Tool_Library_Manager().Get_Count();i++)
     162#endif
     163    {
    153164   
     165#if SAGA_MAJOR_VERSION == 2
    154166    CSG_Module_Library * library=SG_Get_Module_Library_Manager().Get_Library(i);
     167#else
     168    CSG_Tool_Library * library=SG_Get_Tool_Library_Manager().Get_Library(i);
     169#endif
    155170    int lc=library->Get_Count();
    156171    if(!library->Get_Library_Name().Contains("io_")) {
    157172
    158173      for(int j=0;j<lc;j++){
     174#if SAGA_MAJOR_VERSION == 2
    159175        CSG_Module * module=library->Get_Module(j);
     176#else
     177        CSG_Tool * module=library->Get_Tool(j);
     178#endif
    160179        if(module!=NULL && !module->needs_GUI() /*&& !module->is_Interactive()*/ ){
    161180
    162181          mkdir(library->Get_Library_Name().b_str(),0755);
    163 
     182         
    164183          FILE *stdout1=fopen((library->Get_Library_Name()+"/"+module->Get_ID()+".zcfg").b_str(),"w+");
    165184          fprintf(stdout1,"[%d]\n",j);
     
    203222             
    204223            }
     224            else if(CSG_String(param->Get_Type_Identifier()).is_Same_As(CSG_String("date"),true)){
     225              printBasicMetadata(stdout1,param,false,true,true);
     226              fprintf(stdout1,"  <LiteralData>\n");
     227              fprintf(stdout1,"   dataType = date\n");
     228              fprintf(stdout1,"   <Default/>\n");
     229              fprintf(stdout1,"  </LiteralData>\n");
     230             
     231            }
    205232            else if(CSG_String(param->Get_Type_Identifier()).is_Same_As(CSG_String("range"),true)){
    206233
     
    212239              CSG_Parameter_Range *range=param->asRange();
    213240              fprintf(stdout1,"   <Default>\n");
     241#if SAGA_MAJOR_VERSION == 2
    214242              fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->Get_Data())->Get_LoVal());
     243#else
     244              //fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->asDataObject())->Get_Min());         
     245#endif
    215246              fprintf(stdout1,"   </Default>\n");
    216247              fprintf(stdout1,"  </LiteralData>\n");
     
    220251              fprintf(stdout1,"   dataType = float\n");
    221252              fprintf(stdout1,"   <Default>\n");
     253#if SAGA_MAJOR_VERSION == 2
    222254              fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->Get_Data())->Get_HiVal());
     255#else
     256              //fprintf(stdout1,"    value = %f\n",((CSG_Parameter_Range*)param->asDataObject())->Get_Max());         
     257#endif
    223258              fprintf(stdout1,"   </Default>\n");
    224259              fprintf(stdout1,"  </LiteralData>\n");
     
    280315                fprintf(stdout1,"   dataType = string\n");
    281316                fprintf(stdout1,"   <Default>\n");
     317#if SAGA_MAJOR_VERSION == 2
    282318                if( !param->Get_Data()->Get_Default().is_Empty() ){
    283319                  fprintf(stdout1,"    value = %s\n",param->Get_Data()->Get_Default().b_str());
    284320                }
     321#else
     322                if( !param->Get_Default().is_Empty() ){
     323                  fprintf(stdout1,"    value = %s\n",param->Get_Default().b_str());
     324                }
     325#endif
    285326                fprintf(stdout1,"   </Default>\n");
    286327                fprintf(stdout1,"  </LiteralData>\n");
     
    299340
    300341                fprintf(stdout1,"   <Default>\n");
     342#if SAGA_MAJOR_VERSION == 2
    301343                if( !param->Get_Data()->Get_Default().is_Empty() ){
    302344                  fprintf(stdout1,"    value = %s\n",param->Get_Data()->Get_Default().b_str());
    303345                }
     346#else
     347                if( !param->Get_Default().is_Empty() ){
     348                  fprintf(stdout1,"    value = %s\n",param->Get_Default().b_str());
     349                }
     350#endif
    304351                if(param->asValue()->has_Minimum() && param->asValue()->has_Maximum()){
    305352                  fprintf(stdout1,"    rangeMin = %f\n",param->asValue()->Get_Minimum());
     
    314361                fprintf(stdout1,"   dataType = bool\n");
    315362                fprintf(stdout1,"   <Default>\n");
     363#if SAGA_MAJOR_VERSION == 2
    316364                if( !param->Get_Data()->Get_Default().is_Empty() ){
    317365                  fprintf(stdout1,"    value = %s\n",(param->Get_Data()->Get_Default().Contains("0")?"false":"true"));
    318366                }
     367#else
     368                if( !param->Get_Default().is_Empty() ){
     369                  fprintf(stdout1,"    value = %s\n",(param->Get_Default().Contains("0")?"false":"true"));
     370                }
     371#endif
    319372                fprintf(stdout1,"   </Default>\n");
    320373                fprintf(stdout1,"  </LiteralData>\n"); 
     
    337390                  }
    338391                  fprintf(stdout1,"   <Default>\n");
     392#if SAGA_MAJOR_VERSION == 2
    339393                  if( !param->Get_Data()->Get_Default().is_Empty() ){
    340394                    fprintf(stdout1,"    value = %s\n",CSG_String(choice->Get_Item(atoi(param->Get_Data()->Get_Default()))).b_str());
    341395                  }
     396#else
     397                  if( !param->Get_Default().is_Empty() ){
     398                    fprintf(stdout1,"    value = %s\n",CSG_String(choice->Get_Item(atoi(param->Get_Default()))).b_str());
     399                  }               
     400#endif
    342401                  fprintf(stdout1,"   </Default>\n");
    343402                  fprintf(stdout1,"  </LiteralData>\n");
  • trunk/zoo-project/HISTORY.txt

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

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

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

    r815 r917  
    99
    1010service.o: service.c service.h
    11         gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
     11        g++ ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service.c
    1212
    1313main_conf_read.tab.c: main_conf_read.y service.h
     
    3838        gcc -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c ulinet.c
    3939
     40sshapi.o: sshapi.c
     41        g++ -fPIC ${CFLAGS} -c sshapi.c
     42
     43service_json.o: service_json.c
     44        g++ -fPIC ${JSON_CFLAGS} ${CFLAGS} -c service_json.c
     45
     46service_callback.o: service_callback.c
     47        g++ -fPIC ${XML2CFLAGS} ${GDAL_CFLAGS} ${JSON_CFLAGS} ${CFLAGS} -c service_callback.c
     48
    4049request_parser.o: request_parser.c request_parser.h
    4150        g++ -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c request_parser.c
    4251
    4352sqlapi.o: sqlapi.c sqlapi.h
    44         g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
     53        g++ -fPIC ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c sqlapi.c
    4554
    4655caching.o: caching.c
     
    4857
    4958response_print.o: response_print.c response_print.h
    50         g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c response_print.c
     59        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} ${HPC_ENABLED} -c response_print.c
    5160
    5261server_internal.o: server_internal.c server_internal.h service.h mimetypes.h
    53         g++ ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
     62        g++ ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c server_internal.c
    5463
    5564service_internal.o: service_internal.c service_internal.h service.h
    56         gcc ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
     65        gcc ${JSON_CFLAGS} ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
    5766
    5867service_yaml.o: service_yaml.c service.h
    5968        gcc ${YAML_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_yaml.c
     69
     70meta_sql.o: meta_sql.c meta_sql.h service.h
     71        g++  ${METADB_ENABLED} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} -c meta_sql.c
    6072
    6173service_internal_ms.o: service_internal_ms.c
     
    6678        g++ ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c service_internal_python.c
    6779
     80service_internal_r.o: service_internal_r.c service.h
     81        g++ ${XML2CFLAGS} ${RCFLAGS} ${CFLAGS} -c service_internal_r.c
     82
    6883service_internal_otb.o: service_internal_otb.c service_internal_otb.h service.h
    6984        g++ ${XML2CFLAGS} ${OTBCFLAGS} ${CFLAGS} -c service_internal_otb.c
     85
     86service_internal_hpc.o: service_internal_hpc.c service_internal_hpc.h service.h
     87        g++  ${JSON_CFLAGS} ${XML2CFLAGS} ${HPCCFLAGS} ${CFLAGS} -c service_internal_hpc.c
    7088
    7189service_internal_saga.o: service_internal_saga.c service_internal_saga.h service.h
     
    99117        g++ -c ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} service_loader.c
    100118
    101 zoo_service_loader.o: zoo_service_loader.c service.h version.h ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE}
    102         g++ -g -O2 ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${PYTHON_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
     119zoo_service_loader.o: zoo_service_loader.c service.h version.h ${MS_FILE} ${R_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE}
     120        g++ -g -O2 ${JSON_CFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${RCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${HPC_ENABLED} ${PYTHON_ENABLED} ${R_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED} ${METADB_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
    103121
    104122libzoo_service.${EXT}: version.h service_internal.o service.o sqlapi.o
    105         gcc -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS}
     123        g++ -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS} ${ZOO_LDFLAGS} ${MACOS_LD_FLAGS}
    106124
    107 zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE}
    108         g++ -g -O2 ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
    109         g++  ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
     125zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${R_FILE} ${SAGA_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} ${CALLBACK_FILE}
     126        g++ -g -O2 ${JSON_CFLAGS} ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
     127        g++  ${JSON_CFLAGS} ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} ${R_FILE} ${CALLBACK_FILE} response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
    110128
    111 zcfg2yaml: zcfg2yaml.c service.h lex.sr.o service_conf.tab.o service_conf.y main_conf_read.tab.o lex.cr.o response_print.o server_internal.o service_internal.o ${MS_FILE} ${YAML_FILE}
     129zcfg2yaml: zcfg2yaml.c service.h lex.sr.o service_conf.tab.o service_conf.y main_conf_read.tab.o lex.cr.o response_print.o server_internal.o service_internal.o ${MS_FILE} ${YAML_FILE} ${CALLBACK_FILE}
    112130        g++ -g -O2 ${JSCFLAGS} ${RUBYCFLAGS} ${XML2CFLAGS} ${CFLAGS} -c zcfg2yaml.c  -fno-common -DPIC -o zcfg2yaml.o
    113         g++  ${XML2CFLAGS} ${CFLAGS} zcfg2yaml.o server_internal.o service_internal.o ${MS_FILE} response_print.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o  ${YAML_FILE} -o zcfg2yaml -L. ${LDFLAGS}
     131        g++  ${XML2CFLAGS} ${CFLAGS} zcfg2yaml.o caching.o ulinet.o ${CALLBACK_FILE} server_internal.o service_internal.o ${MS_FILE} response_print.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o  ${YAML_FILE} -o zcfg2yaml -L. ${LDFLAGS}
    114132
    115133install: zoo_loader.cgi
  • trunk/zoo-project/zoo-kernel/ZOOMakefile.opts.in

    r866 r917  
    3030YAML_FILE1=@YAML_FILE1@
    3131
     32JSON_CFLAGS=@JSON_CPPFLAGS@
     33JSON_LDFLAGS=@JSON_LDFLAGS@
     34JSON_FILE=@JSON_FILE@
     35
     36METADB_ENABLED=@METADB@
     37METADB_FILE=@METADB_FILE@
     38
     39
    3240GDAL_CFLAGS=@GDAL_CFLAGS@
    3341GDAL_LIBS=@GDAL_LIBS@
     
    5058PYTHON_FILE=@PYTHON_FILE@
    5159
     60RCFLAGS=@R_CPPFLAGS@
     61RLDFLAGS=@R_LDFLAGS@
     62R_ENABLED=@R_ENABLED@
     63R_FILE=@R_FILE@
     64
    5265RUBYCFLAGS=@RUBY_CPPFLAGS@
    5366RUBYLDFLAGS=@RUBY_LDFLAGS@
     
    6881
    6982ZOO_CFLAGS=-I${ZRPATH}/../thirds/cgic206/ -I${ZRPATH}/zoo-kernel/
    70 ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ -luuid
     83ZOO_LDFLAGS=@OPENSSL_LDFLAGS@ @UUID_LDFLAGS@
    7184
    7285JAVACFLAGS=@JAVA_CPPFLAGS@
     
    8093PHP_FILE=@PHP_FILE@
    8194
    82 
    8395PERLCFLAGS=@PERL_CPPFLAGS@
    8496PERLLDFLAGS=@PERL_LDFLAGS@
    8597PERL_ENABLED=@PERL_ENABLED@
    8698PERL_FILE=@PERL_FILE@
     99
     100HPCCFLAGS=@SSH2_CPPFLAGS@ @HPC_CPPFLAGS@
     101HPCLDFLAGS=@SSH2_LDFLAGS@ @HPC_LDFLAGS@
     102HPC_ENABLED=@HPC_ENABLED@
     103HPC_FILES=@HPC_FILES@
     104
     105CALLBACK_FILE=@CALLBACK_FILE@
     106CALLBACK_USE=@CALLBACK_USE@
    87107
    88108OTBCFLAGS=@OTB_CPPFLAGS@
     
    101121MONO_FILE=@MONO_FILE@
    102122
    103 CFLAGS=-Wdeclaration-after-statement @RELY_ON_DB@ @DEB_DEF@ -fpic @OPENSSL_CFLAGS@ ${FCGI_CFLAGS} ${YAML_CFLAGS} ${MACOS_CFLAGS} ${MS_CFLAGS} -I../../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
    104 LDFLAGS=-lzoo_service @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ -luuid ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS}
     123CFLAGS=@CALLBACK_USE@ @SSH2_CPPFLAGS@ @PROJ_CPPFLAGS@ @RELY_ON_DB@ @DEB_DEF@ -fpic @OPENSSL_CFLAGS@ @UUID_CFLAGS@ ${FCGI_CFLAGS} ${YAML_CFLAGS} ${MACOS_CFLAGS} ${MS_CFLAGS} -I../../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
     124LDFLAGS=-lzoo_service @SSH2_LDFLAGS@ @PROJ_LDFLAGS@ @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS} ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ @UUID_LDFLAGS@ ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS} ${RLDFLAGS} @JSON_LDFLAGS@ @XSLT_LDFLAGS@
    105125
    106126DATAROOTDIR=@datarootdir@/zoo-project
  • trunk/zoo-project/zoo-kernel/caching.c

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

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

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

    r790 r917  
    8787 ;
    8888
    89 pair: PAIR {curr_key=zStrdup($1);}
     89pair: PAIR {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);}
    9090| EPAIR {
    9191  if(current_content==NULL)
     
    9999  }
    100100  free(curr_key);
     101  curr_key=NULL;
    101102  }
    102 | SPAIR  {curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
     103| SPAIR  {if(curr_key!=NULL) free(curr_key);curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
    103104 ;
    104105
     
    162163    free(current_content);
    163164  }
     165  if(curr_key!=NULL){
     166    free(curr_key);
     167  }
    164168
    165169  fclose(crin);
  • trunk/zoo-project/zoo-kernel/makefile.vc

    r788 r917  
    5050        $(CPP) $(CFLAGS) /c caching.c
    5151
     52service_json.obj: service_json.c service_json.h
     53        $(CPP) $(CFLAGS) /c service_json.c
     54
    5255request_parser.obj: request_parser.c request_parser.h
    5356        $(CPP) $(CFLAGS) /c request_parser.c
     
    7174        $(CPP) /c $(CFLAGS) service_internal_ruby.c
    7275
     76service_internal_mono.obj: service_internal_mono.c service_internal_mono.h service.h
     77        $(CPP) /c $(MONO_CLAGS) $(CFLAGS) service_internal_mono.c
     78
    7379service_internal_python.obj: service_internal_python.c service.h
    7480        $(CPP) /c $(CFLAGS) service_internal_python.c
     
    8995        $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php.c
    9096   
     97service_callback.obj: service_callback.c service_callback.h service.h
     98        $(CPP) /c $(CFLAGS) service_callback.c
     99   
    91100service_internal_php7.obj: service_internal_php7.c service_internal_php.h service.h
    92101        $(CPP) /c $(CFLAGS) $(PHP_CFLAGS) service_internal_php7.c   
     
    95104        link /dll /out:$(LIBZOO_SERVICE) ./service.obj ./service_internal.obj ./sqlapi.obj $(LDFLAGS) /FORCE:MULTIPLE
    96105
    97 $(PROGRAMNAME): version.h $(LIBZOO_SERVICE) zoo_loader.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj request_parser.obj response_print.obj server_internal.obj caching.obj
    98         link zoo_loader.obj request_parser.obj response_print.obj server_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj  zoo_service_loader.obj ./libzoo_service.lib /out:$(PROGRAMNAME) $(LDFLAGS) $(LDFLAGSCGI)
     106$(PROGRAMNAME): version.h $(LIBZOO_SERVICE) zoo_loader.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj request_parser.obj response_print.obj server_internal.obj caching.obj service_json.obj service_callback.obj
     107        link zoo_loader.obj request_parser.obj response_print.obj server_internal.obj caching.obj service_json.obj service_callback.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj  zoo_service_loader.obj ./libzoo_service.lib /out:$(PROGRAMNAME) $(LDFLAGS) $(LDFLAGSCGI) $(JSONC_LIB) $(PTHREADS_LIB) $(XSLT_LIB)
    99108
    100 zcfg2yaml: version.h zcfg2yaml.obj zoo_service_loader.obj service_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj
    101         link zcfg2yaml.obj server_internal.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj response_print.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj ./libzoo_service.lib /out:zcfg2yaml.exe $(LDFLAGS) $(LDFLAGSCGI)
     109zcfg2yaml: version.h zcfg2yaml.obj zoo_service_loader.obj service_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) ulinet.obj lex.cr.obj lex.sr.obj service_conf.tab.obj main_conf_read.tab.obj
     110        link zcfg2yaml.obj server_internal.obj caching.obj $(PY_FILE) $(JAVA_FILE) $(MS_FILE) $(JS_FILE) $(MONO_FILE) $(RUBY_FILE) $(PHP_FILE) ulinet.obj response_print.obj main_conf_read.tab.obj lex.cr.obj service_conf.tab.obj lex.sr.obj ./libzoo_service.lib /out:zcfg2yaml.exe $(LDFLAGS) $(LDFLAGSCGI)
    102111
    103112clean:
     
    105114
    106115embed-manifest: zoo_loader.cgi
    107         mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;1
     116        mt.exe -manifest zoo_loader.cgi.manifest -outputresource:zoo_loader.cgi;
  • trunk/zoo-project/zoo-kernel/mimetypes.h

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

    r788 r917  
    8787!ENDIF
    8888
     89!IFDEF MONO_DIR
     90MONO_CFLAGS=-DUSE_MONO -I"$(MONO_DIR)"\msvc -I"$(MONO_DIR)"\msvc\include -I"$(MONO_DIR)"
     91MONO_LDFLAGS=/LIBPATH:"$(MONO_DIR)/msvc/build/sgen/x64/lib/Release" mono-2.0-sgen.lib
     92MONO_FILE=service_internal_mono.obj
     93!ENDIF
     94
    8995!IFNDEF ZOOK_DIR
    9096ZOOK_DIR=.
     
    100106!ENDIF
    101107
    102 CFLAGS= $(DB_FLAGS) $(MS_DEFS) $(INCLUDES) $(CFLAGS1) /nologo /MD /W3 /EHsc /Ox /D_CRT_SECURE_NO_WARNINGS /DWIN32 /DPROGRAMNAME=\"$(PROGRAMNAME)\" $(CJFLAGS) -I$(ZOOK_DIR) $(RUBY_CFLAGS) -I./ $(JAVA_CFLAGS) $(MS_CFLAGS) -I$(TROOT)\..\..\thirds\dirent-win32 -I$(INTL_DIR) -I$(CURL_DIR)\include -I$(XML2_DIR)\include -I$(GDAL_DIR)\port $(JS_CFLAGS) -I$(GDAL_DIR)\ogr -I$(GDAL_DIR)\gcore -I$(GD_DIR) -I$(ICONV_DIR) -I$(TROOT)\..\..\thirds\include -I$(TROOT)\..\..\thirds\cgic206 -I$(PYTHON_CPATH)\include -I$(SSL_DIR)/inc32 -I$(FCGI_DIR)\include $(PY_CFLAGS) $(PHP_CFLAGS) -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
     108!IFDEF WIN32_DEBUG
     109WIN32_DBG=-DWIN32_DEBUG
     110!ENDIF
     111
     112CFLAGS=$(MONO_CFLAGS) $(WIN32_DBG) $(DB_FLAGS) $(MS_DEFS) $(INCLUDES) $(CFLAGS1) /nologo /MD /W3 /EHsc /Ox /D_CRT_SECURE_NO_WARNINGS /DWIN32 /DPROGRAMNAME=\"$(PROGRAMNAME)\" $(CJFLAGS) -I$(ZOOK_DIR) $(RUBY_CFLAGS) -I./ $(JAVA_CFLAGS) $(MS_CFLAGS) -I$(TROOT)\..\..\thirds\dirent-win32 -I$(INTL_DIR) -I$(CURL_DIR)\include -I$(XML2_DIR)\include -I$(GDAL_DIR)\port $(JS_CFLAGS) -I$(GDAL_DIR)\ogr -I$(GDAL_DIR)\gcore -I$(GD_DIR) -I$(ICONV_DIR) -I$(TROOT)\..\..\thirds\include -I$(TROOT)\..\..\thirds\cgic206 -I$(PYTHON_CPATH)\include -I$(SSL_DIR)/inc32 -I$(FCGI_DIR)\include $(PY_CFLAGS) $(PHP_CFLAGS) -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
    103113
    104114LDFLAGSCGI=$(TROOT)/../../thirds/cgic206/libcgic.lib
    105 LDFLAGS=$(FCGI_DIR)/libfcgi/Release/libfcgi.lib $(CURL_LIBRARY) $(PY_LDFLAGS) $(XML2_LIBRARY) $(SSL_DIR)/out32dll/libeay32.lib $(JAVA_LDFLAGS) $(SSL_DIR)/out32dll/ssleay32.lib $(MS_LDFLAGS) $(INTL_DIR)/intl.lib $(XML2_DIR)/win32/bin.msvc/libxml2.lib $(GDAL_DIR)/gdal_i.lib $(CURL_DIR)/lib/libcurl.lib $(JS_LDFLAGS) $(RUBY_LDFLAGS) $(PHP_LDFLAGS) /machine:i386
     115LDFLAGS=$(MONO_LDFLAGS) $(FCGI_DIR)/libfcgi/Release/libfcgi.lib $(CURL_LIBRARY) $(PY_LDFLAGS) $(XML2_LIBRARY) $(SSL_DIR)/out32dll/libeay32.lib $(JAVA_LDFLAGS) $(SSL_DIR)/out32dll/ssleay32.lib $(MS_LDFLAGS) $(INTL_DIR)/intl.lib $(XML2_DIR)/win32/bin.msvc/libxml2.lib $(GDAL_DIR)/gdal_i.lib $(CURL_DIR)/lib/libcurl.lib $(JS_LDFLAGS) $(RUBY_LDFLAGS) $(PHP_LDFLAGS) /machine:i386
  • trunk/zoo-project/zoo-kernel/request_parser.c

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

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

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

    r785 r917  
    3939#include <libintl.h>
    4040#include <locale.h>
     41
    4142/**
    4243 * ZOO-Kernel internal messages translation function
     
    6364#include <sys/stat.h>
    6465#include <sys/types.h>
    65 #include "cgic.h"
    6666#ifndef WIN32
    6767#include <sys/ipc.h>
     
    8080#endif
    8181#ifndef WIN32
    82 #include <xlocale.h>
     82//#include <locale.h>
     83#include <locale.h> // knut: this appears to be a non-standard header file that has been removed in newer versions of glibc; it may be sufficient to include <locale.h> (see above)
    8384#endif
    8485#include "ulinet.h"
     
    9495#include <libxml/parser.h>
    9596#include <libxml/xpath.h>
     97
     98#include "cgic.h"
    9699
    97100#ifdef __cplusplus
     
    209212  xmlNodePtr printWPSHeader(xmlDocPtr,maps*,const char*,const char*,const char*,int);
    210213  xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr,maps*,const char*);
    211   void printGetCapabilitiesForProcess(registry*,maps*,xmlNodePtr,service*);
    212   void printDescribeProcessForProcess(registry*,maps*,xmlNodePtr,service*);
    213   void printFullDescription(int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int);
     214  void printGetCapabilitiesForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
     215  void printDescribeProcessForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
     216  void printFullDescription(xmlDocPtr,int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int,int,const map*);
    214217  void printDocument(maps*,xmlDocPtr,int);
    215218  void printDescription(xmlNodePtr,xmlNsPtr,const char*,map*,int);
     
    220223  void printOutputDefinitions(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,const char*);
    221224  void printStatusInfo(maps*,map*,char*);
     225  void addAdditionalParameters(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
     226  void addMetadata(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
    222227
    223228  void outputResponse(service*,maps*,maps*,map*,int,maps*,int);
  • trunk/zoo-project/zoo-kernel/server_internal.c

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

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

    r889 r917  
    22 * Author : Gérald FENOY
    33 *
    4  * Copyright (c) 2009-2015 GeoLabs SARL
     4 * Copyright (c) 2009-2019 GeoLabs SARL
    55 *
    66 * Permission is hereby granted, free of charge, to any person obtaining a copy
     
    3434#endif
    3535
     36 // knut: add bool if necessary
     37#ifndef __cplusplus
     38#ifndef WIN32
     39#include <stdbool.h>
     40#else
     41typedef int bool;
     42#define false 0
     43#define true 1 
     44#endif
     45#endif
     46#ifndef __bool_true_false_are_defined
     47#define __bool_true_false_are_defined 1
     48#endif
     49
    3650#ifdef WIN32
    37 #ifndef USE_MS
    38 ZOO_DLL_EXPORT char *strcasestr (char const *,char const *);
    39 #endif
    40 #endif
    41 
    42 // knut: add bool if necessary
    43 #ifndef __cplusplus
    44   #ifndef WIN32
    45     #include <stdbool.h>
    46   #else
    47     typedef int bool;
    48     #define false 0
    49     #define true 1     
    50   #endif
    51 #endif
    52 #ifndef __bool_true_false_are_defined
    53   #define __bool_true_false_are_defined 1
    54 #endif
    55 
    56 #ifdef WIN32
     51#define strtok_r strtok_s
    5752#define strncasecmp _strnicmp
    5853#define strcasecmp _stricmp
    59 #define strtok_r strtok_s
    6054#if defined(_MSC_VER) && _MSC_VER < 1900
    6155#define snprintf _snprintf
    6256#endif
    63 /* knut: see new definition of bool above
    64 #if defined(_MSC_VER) && _MSC_VER < 1800
    65 #define false 0
    66 #define true 1
    67 #define bool int
    68 #endif
    69 */
    7057#define zStrdup _strdup
    7158#define zMkdir _mkdir
     59#define zGetpid _getpid
    7260#define zOpen _open
     61#define zClose _close
     62#define zUnlink _unlink
     63#define zDup _dup
     64#define zDup2 _dup2
    7365#define zWrite _write
    7466#define zSleep Sleep
     
    8072static int zGettimeofday(struct ztimeval* tp, void* tzp)
    8173{
    82   struct _timeb theTime;       
    8374  if (tp == 0) {
    8475