source: trunk/zoo-project/zoo-kernel/zoo_service_loader.c @ 557

Last change on this file since 557 was 557, checked in by knut, 9 years ago

Fix to ensure that only configuration files whose name ends with .zcfg are read (e.g. avoid reading ServiceName?.zcfg~).

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 124.7 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 *  Copyright 2008-2013 GeoLabs SARL. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25
26
27extern "C" int yylex ();
28extern "C" int crlex ();
29
30#ifdef USE_OTB
31#include "service_internal_otb.h"
32#else
33#define length(x) (sizeof(x) / sizeof(x[0]))
34#endif
35
36#include "cgic.h"
37
38extern "C"
39{
40#include <libxml/tree.h>
41#include <libxml/xmlmemory.h>
42#include <libxml/parser.h>
43#include <libxml/xpath.h>
44#include <libxml/xpathInternals.h>
45}
46
47#include "ulinet.h"
48
49#include <libintl.h>
50#include <locale.h>
51#include <string.h>
52
53#include "service.h"
54
55#include "service_internal.h"
56
57#ifdef USE_PYTHON
58#include "service_internal_python.h"
59#endif
60
61#ifdef USE_JAVA
62#include "service_internal_java.h"
63#endif
64
65#ifdef USE_PHP
66#include "service_internal_php.h"
67#endif
68
69#ifdef USE_JS
70#include "service_internal_js.h"
71#endif
72
73#ifdef USE_RUBY
74#include "service_internal_ruby.h"
75#endif
76
77#ifdef USE_PERL
78#include "service_internal_perl.h"
79#endif
80
81#include <dirent.h>
82#include <signal.h>
83#include <unistd.h>
84#ifndef WIN32
85#include <dlfcn.h>
86#include <libgen.h>
87#else
88#include <windows.h>
89#include <direct.h>
90#include <sys/types.h>
91#include <sys/stat.h>
92#include <unistd.h>
93#define pid_t int;
94#endif
95#include <fcntl.h>
96#include <time.h>
97#include <stdarg.h>
98
99#ifdef WIN32
100extern "C"
101{
102  __declspec (dllexport) char *strcasestr (char const *a, char const *b)
103#ifndef USE_MS
104  {
105    char *x = zStrdup (a);
106    char *y = zStrdup (b);
107
108      x = _strlwr (x);
109      y = _strlwr (y);
110    char *pos = strstr (x, y);
111    char *ret = pos == NULL ? NULL : (char *) (a + (pos - x));
112      free (x);
113      free (y);
114      return ret;
115  };
116#else
117   ;
118#endif
119}
120#endif
121
122#define _(String) dgettext ("zoo-kernel",String)
123#define __(String) dgettext ("zoo-service",String)
124
125extern int getServiceFromFile (maps *, const char *, service **);
126
127int
128readServiceFile (maps * conf, char *file, service ** service, char *name)
129{
130  int t = getServiceFromFile (conf, file, service);
131#ifdef YAML
132  if (t < 0)
133    {
134      t = getServiceFromYAML (conf, file, service, name);
135    }
136#endif
137  return t;
138}
139
140void
141translateChar (char *str, char toReplace, char toReplaceBy)
142{
143  int i = 0, len = strlen (str);
144  for (i = 0; i < len; i++)
145    {
146      if (str[i] == toReplace)
147        str[i] = toReplaceBy;
148    }
149}
150
151/**
152 * Create (or append to) an array valued maps
153 * value = "["",""]"
154 */
155int
156appendMapsToMaps (maps * m, maps * mo, maps * mi, elements * elem)
157{
158  maps *tmpMaps = getMaps (mo, mi->name);
159  map *tmap = getMapType (tmpMaps->content);
160  elements *el = getElements (elem, mi->name);
161  int hasEl = 1;
162  if (el == NULL)
163    hasEl = -1;
164  if (tmap == NULL)
165    {
166      if (hasEl > 0)
167        tmap = getMapType (el->defaults->content);
168    }
169
170  map *testMap = NULL;
171  if (hasEl > 0)
172    {
173      testMap = getMap (el->content, "maxOccurs");
174    }
175  else
176    {
177      testMap = createMap ("maxOccurs", "unbounded");
178    }
179
180  if (testMap != NULL)
181    {
182      if (strncasecmp (testMap->value, "unbounded", 9) != 0
183          && atoi (testMap->value) > 1)
184        {
185          addMapsArrayToMaps (&mo, mi, tmap->name);
186          map* nb=getMapFromMaps(mo,mi->name,"length");
187          if (nb!=NULL && atoi(nb->value)>atoi(testMap->value))
188            {
189              char emsg[1024];
190              sprintf (emsg,
191                       _("You set maximum occurences for <%s> as %i but you tried to use it more than the limit you set. Please correct your ZCFG file or your request."),
192                       mi->name, atoi (testMap->value));
193              errorException (m, emsg, "InternalError", NULL);
194              return -1;
195            }
196        }
197      else
198        {
199          if (strncasecmp (testMap->value, "unbounded", 9) == 0)
200            {
201              if (hasEl < 0)
202                {
203                  freeMap (&testMap);
204                  free (testMap);
205                }
206              if (addMapsArrayToMaps (&mo, mi, tmap->name) < 0)
207                {
208                  char emsg[1024];
209                  map *tmpMap = getMap (mi->content, "length");
210                  sprintf (emsg,
211                           _
212                           ("ZOO-Kernel was unable to load your data for %s position %s."),
213                           mi->name, tmpMap->value);
214                  errorException (m, emsg, "InternalError", NULL);
215                  return -1;
216                }
217            }
218          else
219            {
220              char emsg[1024];
221              sprintf (emsg,
222                       _
223                       ("You set maximum occurences for <%s> to one but you tried to use it more than once. Please correct your ZCFG file or your request."),
224                       mi->name);
225              errorException (m, emsg, "InternalError", NULL);
226              return -1;
227            }
228        }
229    }
230  return 0;
231}
232
233int
234recursReaddirF (maps * m, xmlNodePtr n, char *conf_dir, char *prefix,
235                int saved_stdout, int level, void (func) (maps *, xmlNodePtr,
236                                                          service *))
237{
238  struct dirent *dp;
239  int scount = 0;
240
241  if (conf_dir == NULL)
242    return 1;
243  DIR *dirp = opendir (conf_dir);
244  if (dirp == NULL)
245    {
246      if (level > 0)
247        return 1;
248      else
249        return -1;
250    }
251  char tmp1[25];
252  sprintf (tmp1, "sprefix_%d", level);
253  char levels[17];
254  sprintf (levels, "%d", level);
255  setMapInMaps (m, "lenv", "level", levels);
256  while ((dp = readdir (dirp)) != NULL)
257    if ((dp->d_type == DT_DIR || dp->d_type == DT_LNK) && dp->d_name[0] != '.'
258        && strstr (dp->d_name, ".") == NULL)
259      {
260
261        char *tmp =
262          (char *) malloc ((strlen (conf_dir) + strlen (dp->d_name) + 2) *
263                           sizeof (char));
264        sprintf (tmp, "%s/%s", conf_dir, dp->d_name);
265
266        if (prefix != NULL)
267          {
268            prefix = NULL;
269          }
270        prefix = (char *) malloc ((strlen (dp->d_name) + 2) * sizeof (char));
271        sprintf (prefix, "%s.", dp->d_name);
272
273        //map* tmpMap=getMapFromMaps(m,"lenv",tmp1);
274
275        int res;
276        if (prefix != NULL)
277          {
278            setMapInMaps (m, "lenv", tmp1, prefix);
279            char levels1[17];
280            sprintf (levels1, "%d", level + 1);
281            setMapInMaps (m, "lenv", "level", levels1);
282            res =
283              recursReaddirF (m, n, tmp, prefix, saved_stdout, level + 1,
284                              func);
285            sprintf (levels1, "%d", level);
286            setMapInMaps (m, "lenv", "level", levels1);
287            free (prefix);
288            prefix = NULL;
289          }
290        else
291          res = -1;
292        free (tmp);
293        if (res < 0)
294          {
295            return res;
296          }
297      }
298    else
299      {
300        char* extn = strstr(dp->d_name, ".zcfg");
301        if(dp->d_name[0] != '.' && extn != NULL && strlen(extn) == 5)
302          {
303            int t;
304            char tmps1[1024];
305            memset (tmps1, 0, 1024);
306            snprintf (tmps1, 1024, "%s/%s", conf_dir, dp->d_name);
307            service *s1 = (service *) malloc (SERVICE_SIZE);
308            if (s1 == NULL)
309              {
310                dup2 (saved_stdout, fileno (stdout));
311                errorException (m, _("Unable to allocate memory."),
312                                "InternalError", NULL);
313                return -1;
314              }
315#ifdef DEBUG
316            fprintf (stderr, "#################\n%s\n#################\n",
317                     tmps1);
318#endif
319            char *tmpsn = zStrdup (dp->d_name);
320            tmpsn[strlen (tmpsn) - 5] = 0;
321            t = readServiceFile (m, tmps1, &s1, tmpsn);
322            free (tmpsn);
323            if (t < 0)
324              {
325                map *tmp00 = getMapFromMaps (m, "lenv", "message");
326                char tmp01[1024];
327                if (tmp00 != NULL)
328                  sprintf (tmp01, _("Unable to parse the ZCFG file: %s (%s)"),
329                           dp->d_name, tmp00->value);
330                else
331                  sprintf (tmp01, _("Unable to parse the ZCFG file: %s."),
332                           dp->d_name);
333                dup2 (saved_stdout, fileno (stdout));
334                errorException (m, tmp01, "InternalError", NULL);
335                return -1;
336              }
337#ifdef DEBUG
338            dumpService (s1);
339            fflush (stdout);
340            fflush (stderr);
341#endif
342            func (m, n, s1);
343            freeService (&s1);
344            free (s1);
345            scount++;
346          }
347      }
348  (void) closedir (dirp);
349  return 1;
350}
351
352xmlXPathObjectPtr
353extractFromDoc (xmlDocPtr doc, const char *search)
354{
355  xmlXPathContextPtr xpathCtx;
356  xmlXPathObjectPtr xpathObj;
357  xpathCtx = xmlXPathNewContext (doc);
358  xpathObj = xmlXPathEvalExpression (BAD_CAST search, xpathCtx);
359  xmlXPathFreeContext (xpathCtx);
360  return xpathObj;
361}
362
363void
364donothing (int sig)
365{
366#ifdef DEBUG
367  fprintf (stderr, "Signal %d after the ZOO-Kernel returned result !\n", sig);
368#endif
369  exit (0);
370}
371
372void
373sig_handler (int sig)
374{
375  char tmp[100];
376  const char *ssig;
377  switch (sig)
378    {
379    case SIGSEGV:
380      ssig = "SIGSEGV";
381      break;
382    case SIGTERM:
383      ssig = "SIGTERM";
384      break;
385    case SIGINT:
386      ssig = "SIGINT";
387      break;
388    case SIGILL:
389      ssig = "SIGILL";
390      break;
391    case SIGFPE:
392      ssig = "SIGFPE";
393      break;
394    case SIGABRT:
395      ssig = "SIGABRT";
396      break;
397    default:
398      ssig = "UNKNOWN";
399      break;
400    }
401  sprintf (tmp,
402           _
403           ("ZOO Kernel failed to process your request receiving signal %d = %s"),
404           sig, ssig);
405  errorException (NULL, tmp, "InternalError", NULL);
406#ifdef DEBUG
407  fprintf (stderr, "Not this time!\n");
408#endif
409  exit (0);
410}
411
412void
413loadServiceAndRun (maps ** myMap, service * s1, map * request_inputs,
414                   maps ** inputs, maps ** ioutputs, int *eres)
415{
416  char tmps1[1024];
417  char ntmp[1024];
418  maps *m = *myMap;
419  maps *request_output_real_format = *ioutputs;
420  maps *request_input_real_format = *inputs;
421  /**
422   * Extract serviceType to know what kind of service should be loaded
423   */
424  map *r_inputs = NULL;
425#ifndef WIN32
426  getcwd (ntmp, 1024);
427#else
428  _getcwd (ntmp, 1024);
429#endif
430  r_inputs = getMap (s1->content, "serviceType");
431#ifdef DEBUG
432  fprintf (stderr, "LOAD A %s SERVICE PROVIDER \n", r_inputs->value);
433  fflush (stderr);
434#endif
435  if (strlen (r_inputs->value) == 1
436      && strncasecmp (r_inputs->value, "C", 1) == 0)
437    {
438      r_inputs = getMap (request_inputs, "metapath");
439      if (r_inputs != NULL)
440        sprintf (tmps1, "%s/%s", ntmp, r_inputs->value);
441      else
442        sprintf (tmps1, "%s/", ntmp);
443      char *altPath = zStrdup (tmps1);
444      r_inputs = getMap (s1->content, "ServiceProvider");
445      sprintf (tmps1, "%s/%s", altPath, r_inputs->value);
446      free (altPath);
447#ifdef DEBUG
448      fprintf (stderr, "Trying to load %s\n", tmps1);
449#endif
450#ifdef WIN32
451      HINSTANCE so =
452        LoadLibraryEx (tmps1, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
453#else
454      void *so = dlopen (tmps1, RTLD_LAZY);
455#endif
456#ifdef WIN32
457      DWORD errstr;
458      errstr = GetLastError ();
459#else
460      char *errstr;
461      errstr = dlerror ();
462#endif
463#ifdef DEBUG
464      fprintf (stderr, "%s loaded (%d) \n", tmps1, errstr);
465#endif
466      if (so != NULL)
467        {
468#ifdef DEBUG
469          fprintf (stderr, "Library loaded %s \n", errstr);
470          fprintf (stderr, "Service Shared Object = %s\n", r_inputs->value);
471#endif
472          r_inputs = getMap (s1->content, "serviceType");
473#ifdef DEBUG
474          dumpMap (r_inputs);
475          fprintf (stderr, "%s\n", r_inputs->value);
476          fflush (stderr);
477#endif
478          if (strncasecmp (r_inputs->value, "C-FORTRAN", 9) == 0)
479            {
480              r_inputs = getMap (request_inputs, "Identifier");
481              char fname[1024];
482              sprintf (fname, "%s_", r_inputs->value);
483#ifdef DEBUG
484              fprintf (stderr, "Try to load function %s\n", fname);
485#endif
486#ifdef WIN32
487              typedef int (CALLBACK * execute_t) (char ***, char ***,
488                                                  char ***);
489              execute_t execute = (execute_t) GetProcAddress (so, fname);
490#else
491              typedef int (*execute_t) (char ***, char ***, char ***);
492              execute_t execute = (execute_t) dlsym (so, fname);
493#endif
494#ifdef DEBUG
495#ifdef WIN32
496              errstr = GetLastError ();
497#else
498              errstr = dlerror ();
499#endif
500              fprintf (stderr, "Function loaded %s\n", errstr);
501#endif
502
503              char main_conf[10][30][1024];
504              char inputs[10][30][1024];
505              char outputs[10][30][1024];
506              for (int i = 0; i < 10; i++)
507                {
508                  for (int j = 0; j < 30; j++)
509                    {
510                      memset (main_conf[i][j], 0, 1024);
511                      memset (inputs[i][j], 0, 1024);
512                      memset (outputs[i][j], 0, 1024);
513                    }
514                }
515              mapsToCharXXX (m, (char ***) main_conf);
516              mapsToCharXXX (request_input_real_format, (char ***) inputs);
517              mapsToCharXXX (request_output_real_format, (char ***) outputs);
518              *eres =
519                execute ((char ***) &main_conf[0], (char ***) &inputs[0],
520                         (char ***) &outputs[0]);
521#ifdef DEBUG
522              fprintf (stderr, "Function run successfully \n");
523#endif
524              charxxxToMaps ((char ***) &outputs[0],
525                             &request_output_real_format);
526            }
527          else
528            {
529#ifdef DEBUG
530#ifdef WIN32
531              errstr = GetLastError ();
532              fprintf (stderr, "Function %s failed to load because of %d\n",
533                       r_inputs->value, errstr);
534#endif
535#endif
536              r_inputs = getMapFromMaps (m, "lenv", "Identifier");
537#ifdef DEBUG
538              fprintf (stderr, "Try to load function %s\n", r_inputs->value);
539#endif
540              typedef int (*execute_t) (maps **, maps **, maps **);
541#ifdef WIN32
542              execute_t execute =
543                (execute_t) GetProcAddress (so, r_inputs->value);
544#else
545              execute_t execute = (execute_t) dlsym (so, r_inputs->value);
546#endif
547
548              if (execute == NULL)
549                {
550#ifdef WIN32
551                  errstr = GetLastError ();
552#else
553                  errstr = dlerror ();
554#endif
555                  char *tmpMsg =
556                    (char *) malloc (2048 + strlen (r_inputs->value));
557                  sprintf (tmpMsg,
558                           _
559                           ("Error occured while running the %s function: %s"),
560                           r_inputs->value, errstr);
561                  errorException (m, tmpMsg, "InternalError", NULL);
562                  free (tmpMsg);
563#ifdef DEBUG
564                  fprintf (stderr, "Function %s error %s\n", r_inputs->value,
565                           errstr);
566#endif
567                  *eres = -1;
568                  return;
569                }
570
571#ifdef DEBUG
572#ifdef WIN32
573              errstr = GetLastError ();
574#else
575              errstr = dlerror ();
576#endif
577              fprintf (stderr, "Function loaded %s\n", errstr);
578#endif
579
580#ifdef DEBUG
581              fprintf (stderr, "Now run the function \n");
582              fflush (stderr);
583#endif
584              *eres =
585                execute (&m, &request_input_real_format,
586                         &request_output_real_format);
587#ifdef DEBUG
588              fprintf (stderr, "Function loaded and returned %d\n", eres);
589              fflush (stderr);
590#endif
591            }
592#ifdef WIN32
593          *ioutputs = dupMaps (&request_output_real_format);
594          FreeLibrary (so);
595#else
596          dlclose (so);
597#endif
598        }
599      else
600        {
601      /**
602       * Unable to load the specified shared library
603       */
604          char tmps[1024];
605#ifdef WIN32
606          DWORD errstr = GetLastError ();
607#else
608          char *errstr = dlerror ();
609#endif
610          sprintf (tmps, _("C Library can't be loaded %s"), errstr);
611          map *tmps1 = createMap ("text", tmps);
612          printExceptionReportResponse (m, tmps1);
613          *eres = -1;
614          freeMap (&tmps1);
615          free (tmps1);
616        }
617    }
618  else
619
620#ifdef USE_OTB
621  if (strncasecmp (r_inputs->value, "OTB", 6) == 0)
622    {
623      *eres =
624        zoo_otb_support (&m, request_inputs, s1,
625                            &request_input_real_format,
626                            &request_output_real_format);
627    }
628  else
629#endif
630
631#ifdef USE_PYTHON
632  if (strncasecmp (r_inputs->value, "PYTHON", 6) == 0)
633    {
634      *eres =
635        zoo_python_support (&m, request_inputs, s1,
636                            &request_input_real_format,
637                            &request_output_real_format);
638    }
639  else
640#endif
641
642#ifdef USE_JAVA
643  if (strncasecmp (r_inputs->value, "JAVA", 4) == 0)
644    {
645      *eres =
646        zoo_java_support (&m, request_inputs, s1, &request_input_real_format,
647                          &request_output_real_format);
648    }
649  else
650#endif
651
652#ifdef USE_PHP
653  if (strncasecmp (r_inputs->value, "PHP", 3) == 0)
654    {
655      *eres =
656        zoo_php_support (&m, request_inputs, s1, &request_input_real_format,
657                         &request_output_real_format);
658    }
659  else
660#endif
661
662
663#ifdef USE_PERL
664  if (strncasecmp (r_inputs->value, "PERL", 4) == 0)
665    {
666      *eres =
667        zoo_perl_support (&m, request_inputs, s1, &request_input_real_format,
668                          &request_output_real_format);
669    }
670  else
671#endif
672
673#ifdef USE_JS
674  if (strncasecmp (r_inputs->value, "JS", 2) == 0)
675    {
676      *eres =
677        zoo_js_support (&m, request_inputs, s1, &request_input_real_format,
678                        &request_output_real_format);
679    }
680  else
681#endif
682
683#ifdef USE_RUBY
684  if (strncasecmp (r_inputs->value, "Ruby", 4) == 0)
685    {
686      *eres =
687        zoo_ruby_support (&m, request_inputs, s1, &request_input_real_format,
688                          &request_output_real_format);
689    }
690  else
691#endif
692
693    {
694      char tmpv[1024];
695      sprintf (tmpv,
696               _
697               ("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),
698               r_inputs->value);
699      map *tmps = createMap ("text", tmpv);
700      printExceptionReportResponse (m, tmps);
701      *eres = -1;
702    }
703  *myMap = m;
704  *ioutputs = request_output_real_format;
705}
706
707
708#ifdef WIN32
709/**
710 * createProcess function: create a new process after setting some env variables
711 */
712void
713createProcess (maps * m, map * request_inputs, service * s1, char *opts,
714               int cpid, maps * inputs, maps * outputs)
715{
716  STARTUPINFO si;
717  PROCESS_INFORMATION pi;
718  ZeroMemory (&si, sizeof (si));
719  si.cb = sizeof (si);
720  ZeroMemory (&pi, sizeof (pi));
721  char *tmp = (char *) malloc ((1024 + cgiContentLength) * sizeof (char));
722  char *tmpq = (char *) malloc ((1024 + cgiContentLength) * sizeof (char));
723  map *req = getMap (request_inputs, "request");
724  map *id = getMap (request_inputs, "identifier");
725  map *di = getMap (request_inputs, "DataInputs");
726
727  char *dataInputsKVP = getMapsAsKVP (inputs, cgiContentLength, 0);
728  char *dataOutputsKVP = getMapsAsKVP (outputs, cgiContentLength, 1);
729#ifdef DEBUG
730  fprintf (stderr, "DATAINPUTSKVP %s\n", dataInputsKVP);
731  fprintf (stderr, "DATAOUTPUTSKVP %s\n", dataOutputsKVP);
732#endif
733  map *sid = getMapFromMaps (m, "lenv", "sid");
734  map *r_inputs = getMapFromMaps (m, "main", "tmpPath");
735  map *r_inputs1 = getMap (request_inputs, "metapath");
736  int hasIn = -1;
737  if (r_inputs1 == NULL)
738    {
739      r_inputs1 = createMap ("metapath", "");
740      hasIn = 1;
741    }
742  map *r_inputs2 = getMap (request_inputs, "ResponseDocument");
743  if (r_inputs2 == NULL)
744    r_inputs2 = getMap (request_inputs, "RawDataOutput");
745  map *tmpPath = getMapFromMaps (m, "lenv", "cwd");
746
747  map *tmpReq = getMap (request_inputs, "xrequest");
748  if (r_inputs2 != NULL)
749    {
750      sprintf (tmp,
751               "\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",
752               r_inputs1->value, req->value, id->value, dataInputsKVP,
753               r_inputs2->name, dataOutputsKVP, sid->value);
754      sprintf (tmpq,
755               "metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",
756               r_inputs1->value, req->value, id->value, dataInputsKVP,
757               r_inputs2->name, dataOutputsKVP);
758    }
759  else
760    {
761      sprintf (tmp,
762               "\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",
763               r_inputs1->value, req->value, id->value, dataInputsKVP,
764               sid->value);
765      sprintf (tmpq,
766               "metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",
767               r_inputs1->value, req->value, id->value, dataInputsKVP,
768               sid->value);
769    }
770
771  if (hasIn > 0)
772    {
773      freeMap (&r_inputs1);
774      free (r_inputs1);
775    }
776  char *tmp1 = zStrdup (tmp);
777  sprintf (tmp, "\"zoo_loader.cgi\" %s \"%s\"", tmp1, sid->value);
778
779  free (dataInputsKVP);
780  free (dataOutputsKVP);
781#ifdef DEBUG
782  fprintf (stderr, "REQUEST IS : %s \n", tmp);
783#endif
784
785  map* usid = getMapFromMaps (m, "lenv", "usid");
786  if (usid != NULL && usid->value != NULL) {
787    SetEnvironmentVariable("USID", TEXT (usid->value));
788  }
789
790  SetEnvironmentVariable ("CGISID", TEXT (sid->value));
791  SetEnvironmentVariable ("QUERY_STRING", TEXT (tmpq));
792  char clen[1000];
793  sprintf (clen, "%d", strlen (tmpq));
794  SetEnvironmentVariable ("CONTENT_LENGTH", TEXT (clen));
795
796  if (!CreateProcess (NULL,     // No module name (use command line)
797                      TEXT (tmp),       // Command line
798                      NULL,     // Process handle not inheritable
799                      NULL,     // Thread handle not inheritable
800                      FALSE,    // Set handle inheritance to FALSE
801                      CREATE_NO_WINDOW, // Apache won't wait until the end
802                      NULL,     // Use parent's environment block
803                      NULL,     // Use parent's starting directory
804                      &si,      // Pointer to STARTUPINFO struct
805                      &pi)      // Pointer to PROCESS_INFORMATION struct
806    )
807    {
808#ifdef DEBUG
809      fprintf (stderr, "CreateProcess failed (%d).\n", GetLastError ());
810#endif
811      return;
812    }
813  else
814    {
815#ifdef DEBUG
816      fprintf (stderr, "CreateProcess successfull (%d).\n\n\n\n",
817               GetLastError ());
818#endif
819    }
820  CloseHandle (pi.hProcess);
821  CloseHandle (pi.hThread);
822#ifdef DEBUG
823  fprintf (stderr, "CreateProcess finished !\n");
824#endif
825}
826#endif
827
828int
829runRequest (map ** inputs)
830{
831
832#ifndef USE_GDB
833#ifndef WIN32
834  signal (SIGCHLD, SIG_IGN);
835#endif 
836  signal (SIGSEGV, sig_handler);
837  signal (SIGTERM, sig_handler);
838  signal (SIGINT, sig_handler);
839  signal (SIGILL, sig_handler);
840  signal (SIGFPE, sig_handler);
841  signal (SIGABRT, sig_handler);
842#endif
843
844  map *r_inputs = NULL;
845  map *request_inputs = *inputs;
846  maps *m = NULL;
847  char *REQUEST = NULL;
848  /**
849   * Parsing service specfic configuration file
850   */
851  m = (maps *) malloc (MAPS_SIZE);
852  if (m == NULL)
853    {
854      return errorException (m, _("Unable to allocate memory."),
855                             "InternalError", NULL);
856    }
857  char ntmp[1024];
858#ifndef WIN32
859  getcwd (ntmp, 1024);
860#else
861  _getcwd (ntmp, 1024);
862#endif
863  r_inputs = getMapOrFill (&request_inputs, "metapath", "");
864
865
866  char conf_file[10240];
867  snprintf (conf_file, 10240, "%s/%s/main.cfg", ntmp, r_inputs->value);
868  if (conf_read (conf_file, m) == 2)
869    {
870      errorException (NULL, _("Unable to load the main.cfg file."),
871                      "InternalError", NULL);
872      free (m);
873      return 1;
874    }
875#ifdef DEBUG
876  fprintf (stderr, "***** BEGIN MAPS\n");
877  dumpMaps (m);
878  fprintf (stderr, "***** END MAPS\n");
879#endif
880
881  map *getPath = getMapFromMaps (m, "main", "gettextPath");
882  if (getPath != NULL)
883    {
884      bindtextdomain ("zoo-kernel", getPath->value);
885      bindtextdomain ("zoo-services", getPath->value);
886    }
887  else
888    {
889      bindtextdomain ("zoo-kernel", "/usr/share/locale/");
890      bindtextdomain ("zoo-services", "/usr/share/locale/");
891    }
892
893
894  /**
895   * Manage our own error log file (usefull to separate standard apache debug
896   * messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
897   * headers messages returned by the CGI due to wrong redirection of stderr)
898   */
899  FILE *fstde = NULL;
900  map *fstdem = getMapFromMaps (m, "main", "logPath");
901  if (fstdem != NULL)
902    fstde = freopen (fstdem->value, "a+", stderr);
903
904  r_inputs = getMap (request_inputs, "language");
905  if (r_inputs == NULL)
906    r_inputs = getMapFromMaps (m, "main", "language");
907  if (r_inputs != NULL)
908    {
909      if (isValidLang (m, r_inputs->value) < 0)
910        {
911          char tmp[1024];
912          sprintf (tmp,
913                   _
914                   ("The value %s is not supported for the <language> parameter"),
915                   r_inputs->value);
916          errorException (m, tmp, "InvalidParameterValue", "language");
917          freeMaps (&m);
918          free (m);
919          free (REQUEST);
920          return 1;
921
922        }
923      char *tmp = zStrdup (r_inputs->value);
924      setMapInMaps (m, "main", "language", tmp);
925#ifdef DEB
926      char tmp2[12];
927      sprintf (tmp2, "%s.utf-8", tmp);
928      translateChar (tmp2, '-', '_');
929      setlocale (LC_ALL, tmp2);
930#else
931      translateChar (tmp, '-', '_');
932      setlocale (LC_ALL, tmp);
933#endif
934#ifndef WIN32
935      setenv ("LC_ALL", tmp, 1);
936#else
937      char tmp1[12];
938      sprintf (tmp1, "LC_ALL=%s", tmp);
939      putenv (tmp1);
940#endif
941      free (tmp);
942    }
943  else
944    {
945      setlocale (LC_ALL, "en_US");
946#ifndef WIN32
947      setenv ("LC_ALL", "en_US", 1);
948#else
949      char tmp1[12];
950      sprintf (tmp1, "LC_ALL=en_US");
951      putenv (tmp1);
952#endif
953      setMapInMaps (m, "main", "language", "en-US");
954    }
955  setlocale (LC_NUMERIC, "en_US");
956  bind_textdomain_codeset ("zoo-kernel", "UTF-8");
957  textdomain ("zoo-kernel");
958  bind_textdomain_codeset ("zoo-services", "UTF-8");
959  textdomain ("zoo-services");
960
961  map *lsoap = getMap (request_inputs, "soap");
962  if (lsoap != NULL && strcasecmp (lsoap->value, "true") == 0)
963    setMapInMaps (m, "main", "isSoap", "true");
964  else
965    setMapInMaps (m, "main", "isSoap", "false");
966
967  if (strlen (cgiServerName) > 0)
968    {
969      char tmpUrl[1024];
970      if (strncmp (cgiServerPort, "80", 2) == 0)
971        {
972          sprintf (tmpUrl, "http://%s%s", cgiServerName, cgiScriptName);
973        }
974      else
975        {
976          sprintf (tmpUrl, "http://%s:%s%s", cgiServerName, cgiServerPort,
977                   cgiScriptName);
978        }
979#ifdef DEBUG
980      fprintf (stderr, "*** %s ***\n", tmpUrl);
981#endif
982      setMapInMaps (m, "main", "serverAddress", tmpUrl);
983    }
984
985  /**
986   * Check for minimum inputs
987   */
988  r_inputs = getMap (request_inputs, "Request");
989  if (request_inputs == NULL || r_inputs == NULL)
990    {
991      errorException (m, _("Parameter <request> was not specified"),
992                      "MissingParameterValue", "request");
993      if (count (request_inputs) == 1)
994        {
995          freeMap (&request_inputs);
996          free (request_inputs);
997        }
998      freeMaps (&m);
999      free (m);
1000      return 1;
1001    }
1002  else
1003    {
1004      REQUEST = zStrdup (r_inputs->value);
1005      if (strncasecmp (r_inputs->value, "GetCapabilities", 15) != 0
1006          && strncasecmp (r_inputs->value, "DescribeProcess", 15) != 0
1007          && strncasecmp (r_inputs->value, "Execute", 7) != 0)
1008        {
1009          errorException (m,
1010                          _
1011                          ("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
1012                          "OperationNotSupported", r_inputs->value);
1013          freeMaps (&m);
1014          free (m);
1015          free (REQUEST);
1016          return 1;
1017        }
1018    }
1019  r_inputs = NULL;
1020  r_inputs = getMap (request_inputs, "Service");
1021  if (r_inputs == NULLMAP)
1022    {
1023      errorException (m, _("Parameter <service> was not specified"),
1024                      "MissingParameterValue", "service");
1025      freeMaps (&m);
1026      free (m);
1027      free (REQUEST);
1028      return 1;
1029    }
1030  else
1031    {
1032      if (strcasecmp (r_inputs->value, "WPS") != 0)
1033        {
1034          errorException (m,
1035                          _
1036                          ("Unenderstood <service> value, WPS is the only acceptable value."),
1037                          "InvalidParameterValue", "service");
1038          freeMaps (&m);
1039          free (m);
1040          free (REQUEST);
1041          return 1;
1042        }
1043    }
1044  if (strncasecmp (REQUEST, "GetCapabilities", 15) != 0)
1045    {
1046      r_inputs = getMap (request_inputs, "Version");
1047      if (r_inputs == NULL)
1048        {
1049          errorException (m, _("Parameter <version> was not specified"),
1050                          "MissingParameterValue", "version");
1051          freeMaps (&m);
1052          free (m);
1053          free (REQUEST);
1054          return 1;
1055        }
1056      else
1057        {
1058          if (strcasecmp (r_inputs->value, "1.0.0") != 0)
1059            {
1060              errorException (m,
1061                              _
1062                              ("Unenderstood <version> value, 1.0.0 is the only acceptable value."),
1063                              "InvalidParameterValue", "service");
1064              freeMaps (&m);
1065              free (m);
1066              free (REQUEST);
1067              return 1;
1068            }
1069        }
1070    }
1071  else
1072    {
1073      r_inputs = getMap (request_inputs, "AcceptVersions");
1074      if (r_inputs != NULL)
1075        {
1076          if (strncmp (r_inputs->value, "1.0.0", 5) != 0)
1077            {
1078              errorException (m,
1079                              _
1080                              ("Unenderstood <AcceptVersions> value, 1.0.0 is the only acceptable value."),
1081                              "VersionNegotiationFailed", NULL);
1082              freeMaps (&m);
1083              free (m);
1084              free (REQUEST);
1085              return 1;
1086            }
1087        }
1088    }
1089
1090  r_inputs = getMap (request_inputs, "serviceprovider");
1091  if (r_inputs == NULL)
1092    {
1093      addToMap (request_inputs, "serviceprovider", "");
1094    }
1095
1096  maps *request_output_real_format = NULL;
1097  map *tmpm = getMapFromMaps (m, "main", "serverAddress");
1098  if (tmpm != NULL)
1099    SERVICE_URL = zStrdup (tmpm->value);
1100  else
1101    SERVICE_URL = zStrdup (DEFAULT_SERVICE_URL);
1102
1103  service *s1;
1104  int scount = 0;
1105#ifdef DEBUG
1106  dumpMap (r_inputs);
1107#endif
1108  char conf_dir[1024];
1109  int t;
1110  char tmps1[1024];
1111
1112  r_inputs = NULL;
1113  r_inputs = getMap (request_inputs, "metapath");
1114  if (r_inputs != NULL)
1115    snprintf (conf_dir, 1024, "%s/%s", ntmp, r_inputs->value);
1116  else
1117    snprintf (conf_dir, 1024, "%s", ntmp);
1118
1119  if (strncasecmp (REQUEST, "GetCapabilities", 15) == 0)
1120    {
1121#ifdef DEBUG
1122      dumpMap (r_inputs);
1123#endif
1124      xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1125      r_inputs = NULL;
1126      r_inputs = getMap (request_inputs, "ServiceProvider");
1127      xmlNodePtr n;
1128      if (r_inputs != NULL)
1129        n = printGetCapabilitiesHeader (doc, r_inputs->value, m);
1130      else
1131        n = printGetCapabilitiesHeader (doc, "", m);
1132    /**
1133     * Here we need to close stdout to ensure that not supported chars
1134     * has been found in the zcfg and then printed on stdout
1135     */
1136      int saved_stdout = dup (fileno (stdout));
1137      dup2 (fileno (stderr), fileno (stdout));
1138      if (int res =
1139          recursReaddirF (m, n, conf_dir, NULL, saved_stdout, 0,
1140                          printGetCapabilitiesForProcess) < 0)
1141        {
1142          freeMaps (&m);
1143          free (m);
1144          free (REQUEST);
1145          free (SERVICE_URL);
1146          fflush (stdout);
1147          return res;
1148        }
1149      dup2 (saved_stdout, fileno (stdout));
1150      printDocument (m, doc, getpid ());
1151      freeMaps (&m);
1152      free (m);
1153      free (REQUEST);
1154      free (SERVICE_URL);
1155      fflush (stdout);
1156      return 0;
1157    }
1158  else
1159    {
1160      r_inputs = getMap (request_inputs, "Identifier");
1161      if (r_inputs == NULL
1162          || strlen (r_inputs->name) == 0 || strlen (r_inputs->value) == 0)
1163        {
1164          errorException (m, _("Mandatory <identifier> was not specified"),
1165                          "MissingParameterValue", "identifier");
1166          freeMaps (&m);
1167          free (m);
1168          free (REQUEST);
1169          free (SERVICE_URL);
1170          return 0;
1171        }
1172
1173      struct dirent *dp;
1174      DIR *dirp = opendir (conf_dir);
1175      if (dirp == NULL)
1176        {
1177          errorException (m, _("The specified path path doesn't exist."),
1178                          "InvalidParameterValue", conf_dir);
1179          freeMaps (&m);
1180          free (m);
1181          free (REQUEST);
1182          free (SERVICE_URL);
1183          return 0;
1184        }
1185      if (strncasecmp (REQUEST, "DescribeProcess", 15) == 0)
1186        {
1187      /**
1188       * Loop over Identifier list
1189       */
1190          xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0");
1191          r_inputs = NULL;
1192          r_inputs = getMap (request_inputs, "ServiceProvider");
1193
1194          xmlNodePtr n;
1195          if (r_inputs != NULL)
1196            n = printDescribeProcessHeader (doc, r_inputs->value, m);
1197          else
1198            n = printDescribeProcessHeader (doc, "", m);
1199
1200          r_inputs = getMap (request_inputs, "Identifier");
1201
1202          char *orig = zStrdup (r_inputs->value);
1203
1204          int saved_stdout = dup (fileno (stdout));
1205          dup2 (fileno (stderr), fileno (stdout));
1206          if (strcasecmp ("all", orig) == 0)
1207            {
1208              if (int res =
1209                  recursReaddirF (m, n, conf_dir, NULL, saved_stdout, 0,
1210                                  printDescribeProcessForProcess) < 0)
1211                return res;
1212            }
1213          else
1214            {
1215              char *saveptr;
1216              char *tmps = strtok_r (orig, ",", &saveptr);
1217
1218              char buff[256];
1219              char buff1[1024];
1220              while (tmps != NULL)
1221                {
1222                  int hasVal = -1;
1223                  char *corig = zStrdup (tmps);
1224                  if (strstr (corig, ".") != NULL)
1225                    {
1226
1227                      parseIdentifier (m, conf_dir, corig, buff1);
1228                      map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
1229                      if (tmpMap != NULL)
1230                        addToMap (request_inputs, "metapath", tmpMap->value);
1231                      map *tmpMapI = getMapFromMaps (m, "lenv", "Identifier");
1232
1233                      s1 = (service *) malloc (SERVICE_SIZE);
1234                      t = readServiceFile (m, buff1, &s1, tmpMapI->value);
1235                      if (t < 0)
1236                        {
1237                          map *tmp00 = getMapFromMaps (m, "lenv", "message");
1238                          char tmp01[1024];
1239                          if (tmp00 != NULL)
1240                            sprintf (tmp01,
1241                                     _
1242                                     ("Unable to parse the ZCFG file for the following ZOO-Service: %s. Message: %s"),
1243                                     tmps, tmp00->value);
1244                          else
1245                            sprintf (tmp01,
1246                                     _
1247                                     ("Unable to parse the ZCFG file for the following ZOO-Service: %s."),
1248                                     tmps);
1249                          dup2 (saved_stdout, fileno (stdout));
1250                          errorException (m, tmp01, "InvalidParameterValue",
1251                                          "identifier");
1252                          freeMaps (&m);
1253                          free (m);
1254                          free (REQUEST);
1255                          free (corig);
1256                          free (orig);
1257                          free (SERVICE_URL);
1258                          free (s1);
1259                          closedir (dirp);
1260                          xmlFreeDoc (doc);
1261                          xmlCleanupParser ();
1262                          zooXmlCleanupNs ();
1263                          return 1;
1264                        }
1265#ifdef DEBUG
1266                      dumpService (s1);
1267#endif
1268                      printDescribeProcessForProcess (m, n, s1);
1269                      freeService (&s1);
1270                      free (s1);
1271                      s1 = NULL;
1272                      scount++;
1273                      hasVal = 1;
1274                      setMapInMaps (m, "lenv", "level", "0");
1275                    }
1276                  else
1277                    {
1278                      memset (buff, 0, 256);
1279                      snprintf (buff, 256, "%s.zcfg", corig);
1280                      memset (buff1, 0, 1024);
1281#ifdef DEBUG
1282                      printf ("\n#######%s\n########\n", buff);
1283#endif
1284                      while ((dp = readdir (dirp)) != NULL)
1285                        {
1286                          if (strcasecmp (dp->d_name, buff) == 0)
1287                            {
1288                              memset (buff1, 0, 1024);
1289                              snprintf (buff1, 1024, "%s/%s", conf_dir,
1290                                        dp->d_name);
1291                              s1 = (service *) malloc (SERVICE_SIZE);
1292                              if (s1 == NULL)
1293                                {
1294                                  dup2 (saved_stdout, fileno (stdout));
1295                                  return errorException (m,
1296                                                         _
1297                                                         ("Unable to allocate memory."),
1298                                                         "InternalError",
1299                                                         NULL);
1300                                }
1301#ifdef DEBUG
1302                              printf
1303                                ("#################\n(%s) %s\n#################\n",
1304                                 r_inputs->value, buff1);
1305#endif
1306                              char *tmp0 = zStrdup (dp->d_name);
1307                              tmp0[strlen (tmp0) - 5] = 0;
1308                              t = readServiceFile (m, buff1, &s1, tmp0);
1309                              free (tmp0);
1310                              if (t < 0)
1311                                {
1312                                  map *tmp00 =
1313                                    getMapFromMaps (m, "lenv", "message");
1314                                  char tmp01[1024];
1315                                  if (tmp00 != NULL)
1316                                    sprintf (tmp01,
1317                                             _
1318                                             ("Unable to parse the ZCFG file: %s (%s)"),
1319                                             dp->d_name, tmp00->value);
1320                                  else
1321                                    sprintf (tmp01,
1322                                             _
1323                                             ("Unable to parse the ZCFG file: %s."),
1324                                             dp->d_name);
1325                                  dup2 (saved_stdout, fileno (stdout));
1326                                  errorException (m, tmp01, "InternalError",
1327                                                  NULL);
1328                                  freeMaps (&m);
1329                                  free (m);
1330                                  free (orig);
1331                                  free (REQUEST);
1332                                  closedir (dirp);
1333                                  xmlFreeDoc (doc);
1334                                  xmlCleanupParser ();
1335                                  zooXmlCleanupNs ();
1336                                  return 1;
1337                                }
1338#ifdef DEBUG
1339                              dumpService (s1);
1340#endif
1341                              printDescribeProcessForProcess (m, n, s1);
1342                              freeService (&s1);
1343                              free (s1);
1344                              s1 = NULL;
1345                              scount++;
1346                              hasVal = 1;
1347                            }
1348                        }
1349                    }
1350                  if (hasVal < 0)
1351                    {
1352                      map *tmp00 = getMapFromMaps (m, "lenv", "message");
1353                      char tmp01[1024];
1354                      if (tmp00 != NULL)
1355                        sprintf (tmp01,
1356                                 _("Unable to parse the ZCFG file: %s (%s)"),
1357                                 buff, tmp00->value);
1358                      else
1359                        sprintf (tmp01,
1360                                 _("Unable to parse the ZCFG file: %s."),
1361                                 buff);
1362                      dup2 (saved_stdout, fileno (stdout));
1363                      errorException (m, tmp01, "InvalidParameterValue",
1364                                      "Identifier");
1365                      freeMaps (&m);
1366                      free (m);
1367                      free (orig);
1368                      free (REQUEST);
1369                      closedir (dirp);
1370                      xmlFreeDoc (doc);
1371                      xmlCleanupParser ();
1372                      zooXmlCleanupNs ();
1373                      return 1;
1374                    }
1375                  rewinddir (dirp);
1376                  tmps = strtok_r (NULL, ",", &saveptr);
1377                  if (corig != NULL)
1378                    free (corig);
1379                }
1380            }
1381          closedir (dirp);
1382          fflush (stdout);
1383          dup2 (saved_stdout, fileno (stdout));
1384          free (orig);
1385          printDocument (m, doc, getpid ());
1386          freeMaps (&m);
1387          free (m);
1388          free (REQUEST);
1389          free (SERVICE_URL);
1390          fflush (stdout);
1391          return 0;
1392        }
1393      else if (strncasecmp (REQUEST, "Execute", strlen (REQUEST)) != 0)
1394        {
1395          errorException (m,
1396                          _
1397                          ("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."),
1398                          "InvalidParameterValue", "request");
1399#ifdef DEBUG
1400          fprintf (stderr, "No request found %s", REQUEST);
1401#endif
1402          closedir (dirp);
1403          freeMaps (&m);
1404          free (m);
1405          free (REQUEST);
1406          free (SERVICE_URL);
1407          fflush (stdout);
1408          return 0;
1409        }
1410      closedir (dirp);
1411    }
1412
1413  s1 = NULL;
1414  s1 = (service *) malloc (SERVICE_SIZE);
1415  if (s1 == NULL)
1416    {
1417      freeMaps (&m);
1418      free (m);
1419      free (REQUEST);
1420      free (SERVICE_URL);
1421      return errorException (m, _("Unable to allocate memory."),
1422                             "InternalError", NULL);
1423    }
1424  r_inputs = getMap (request_inputs, "MetaPath");
1425  if (r_inputs != NULL)
1426    snprintf (tmps1, 1024, "%s/%s", ntmp, r_inputs->value);
1427  else
1428    snprintf (tmps1, 1024, "%s/", ntmp);
1429  r_inputs = getMap (request_inputs, "Identifier");
1430  char *ttmp = zStrdup (tmps1);
1431  snprintf (tmps1, 1024, "%s/%s.zcfg", ttmp, r_inputs->value);
1432  free (ttmp);
1433#ifdef DEBUG
1434  fprintf (stderr, "Trying to load %s\n", tmps1);
1435#endif
1436  if (strstr (r_inputs->value, ".") != NULL)
1437    {
1438      char *identifier = zStrdup (r_inputs->value);
1439      parseIdentifier (m, conf_dir, identifier, tmps1);
1440      map *tmpMap = getMapFromMaps (m, "lenv", "metapath");
1441      if (tmpMap != NULL)
1442        addToMap (request_inputs, "metapath", tmpMap->value);
1443      free (identifier);
1444    }
1445  else
1446    {
1447      setMapInMaps (m, "lenv", "Identifier", r_inputs->value);
1448      setMapInMaps (m, "lenv", "oIdentifier", r_inputs->value);
1449    }
1450
1451  r_inputs = getMapFromMaps (m, "lenv", "Identifier");
1452  int saved_stdout = dup (fileno (stdout));
1453  dup2 (fileno (stderr), fileno (stdout));
1454  t = readServiceFile (m, tmps1, &s1, r_inputs->value);
1455  fflush (stdout);
1456  dup2 (saved_stdout, fileno (stdout));
1457  if (t < 0)
1458    {
1459      char *tmpMsg = (char *) malloc (2048 + strlen (r_inputs->value));
1460      sprintf (tmpMsg,
1461               _
1462               ("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),
1463               r_inputs->value);
1464      errorException (m, tmpMsg, "InvalidParameterValue", "identifier");
1465      free (tmpMsg);
1466      free (s1);
1467      freeMaps (&m);
1468      free (m);
1469      free (REQUEST);
1470      free (SERVICE_URL);
1471      return 0;
1472    }
1473  close (saved_stdout);
1474
1475#ifdef DEBUG
1476  dumpService (s1);
1477#endif
1478  int j;
1479
1480
1481  /**
1482   * Create the input and output maps data structure
1483   */
1484  int i = 0;
1485  HINTERNET hInternet;
1486  HINTERNET res;
1487  hInternet = InternetOpen (
1488#ifndef WIN32
1489                             (LPCTSTR)
1490#endif
1491                             "ZooWPSClient\0",
1492                             INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1493
1494#ifndef WIN32
1495  if (!CHECK_INET_HANDLE (hInternet))
1496    fprintf (stderr, "WARNING : hInternet handle failed to initialize");
1497#endif
1498  maps *request_input_real_format = NULL;
1499  maps *tmpmaps = request_input_real_format;
1500  map *postRequest = NULL;
1501  postRequest = getMap (request_inputs, "xrequest");
1502  if (postRequest == NULLMAP)
1503    {
1504    /**
1505     * Parsing outputs provided as KVP
1506     */
1507      r_inputs = NULL;
1508#ifdef DEBUG
1509      fprintf (stderr, "OUTPUT Parsing ... \n");
1510#endif
1511      r_inputs = getMap (request_inputs, "ResponseDocument");
1512      if (r_inputs == NULL)
1513        r_inputs = getMap (request_inputs, "RawDataOutput");
1514
1515#ifdef DEBUG
1516      fprintf (stderr, "OUTPUT Parsing ... \n");
1517#endif
1518      if (r_inputs != NULL)
1519        {
1520#ifdef DEBUG
1521          fprintf (stderr, "OUTPUT Parsing start now ... \n");
1522#endif
1523          char cursor_output[10240];
1524          char *cotmp = zStrdup (r_inputs->value);
1525          snprintf (cursor_output, 10240, "%s", cotmp);
1526          free (cotmp);
1527          j = 0;
1528
1529      /**
1530       * Put each Output into the outputs_as_text array
1531       */
1532          char *pToken;
1533          maps *tmp_output = NULL;
1534#ifdef DEBUG
1535          fprintf (stderr, "OUTPUT [%s]\n", cursor_output);
1536#endif
1537          pToken = strtok (cursor_output, ";");
1538          char **outputs_as_text = (char **) malloc (128 * sizeof (char *));
1539          if (outputs_as_text == NULL)
1540            {
1541              return errorException (m, _("Unable to allocate memory"),
1542                                     "InternalError", NULL);
1543            }
1544          i = 0;
1545          while (pToken != NULL)
1546            {
1547#ifdef DEBUG
1548              fprintf (stderr, "***%s***\n", pToken);
1549              fflush (stderr);
1550              fprintf (stderr, "***%s***\n", pToken);
1551#endif
1552              outputs_as_text[i] =
1553                (char *) malloc ((strlen (pToken) + 1) * sizeof (char));
1554              if (outputs_as_text[i] == NULL)
1555                {
1556                  return errorException (m, _("Unable to allocate memory"),
1557                                         "InternalError", NULL);
1558                }
1559              snprintf (outputs_as_text[i], strlen (pToken) + 1, "%s",
1560                        pToken);
1561              pToken = strtok (NULL, ";");
1562              i++;
1563            }
1564          for (j = 0; j < i; j++)
1565            {
1566              char *tmp = zStrdup (outputs_as_text[j]);
1567              free (outputs_as_text[j]);
1568              char *tmpc;
1569              tmpc = strtok (tmp, "@");
1570              int k = 0;
1571              while (tmpc != NULL)
1572                {
1573                  if (k == 0)
1574                    {
1575                      if (tmp_output == NULL)
1576                        {
1577                          tmp_output = (maps *) malloc (MAPS_SIZE);
1578                          if (tmp_output == NULL)
1579                            {
1580                              return errorException (m,
1581                                                     _
1582                                                     ("Unable to allocate memory."),
1583                                                     "InternalError", NULL);
1584                            }
1585                          tmp_output->name = zStrdup (tmpc);
1586                          tmp_output->content = NULL;
1587                          tmp_output->next = NULL;
1588                        }
1589                    }
1590                  else
1591                    {
1592                      char *tmpv = strstr (tmpc, "=");
1593                      char tmpn[256];
1594                      memset (tmpn, 0, 256);
1595                      strncpy (tmpn, tmpc,
1596                               (strlen (tmpc) -
1597                                strlen (tmpv)) * sizeof (char));
1598                      tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
1599#ifdef DEBUG
1600                      fprintf (stderr, "OUTPUT DEF [%s]=[%s]\n", tmpn,
1601                               tmpv + 1);
1602#endif
1603                      if (tmp_output->content == NULL)
1604                        {
1605                          tmp_output->content = createMap (tmpn, tmpv + 1);
1606                          tmp_output->content->next = NULL;
1607                        }
1608                      else
1609                        addToMap (tmp_output->content, tmpn, tmpv + 1);
1610                    }
1611                  k++;
1612#ifdef DEBUG
1613                  fprintf (stderr, "***%s***\n", tmpc);
1614#endif
1615                  tmpc = strtok (NULL, "@");
1616                }
1617              if (request_output_real_format == NULL)
1618                request_output_real_format = dupMaps (&tmp_output);
1619              else
1620                addMapsToMaps (&request_output_real_format, tmp_output);
1621              freeMaps (&tmp_output);
1622              free (tmp_output);
1623              tmp_output = NULL;
1624#ifdef DEBUG
1625              dumpMaps (tmp_output);
1626              fflush (stderr);
1627#endif
1628              free (tmp);
1629            }
1630          free (outputs_as_text);
1631        }
1632
1633
1634    /**
1635     * Parsing inputs provided as KVP
1636     */
1637      r_inputs = getMap (request_inputs, "DataInputs");
1638#ifdef DEBUG
1639      fprintf (stderr, "DATA INPUTS [%s]\n", r_inputs->value);
1640#endif
1641      char cursor_input[40960];
1642      if (r_inputs != NULL)
1643        snprintf (cursor_input, 40960, "%s", r_inputs->value);
1644      else
1645        {
1646          errorException (m, _("Parameter <DataInputs> was not specified"),
1647                          "MissingParameterValue", "DataInputs");
1648          freeMaps (&m);
1649          free (m);
1650          free (REQUEST);
1651          free (SERVICE_URL);
1652          InternetCloseHandle (&hInternet);
1653          freeService (&s1);
1654          free (s1);
1655          return 0;
1656        }
1657      j = 0;
1658
1659    /**
1660     * Put each DataInputs into the inputs_as_text array
1661     */
1662      char *tmp1 = zStrdup (cursor_input);
1663      char *pToken;
1664      pToken = strtok (cursor_input, ";");
1665      if (pToken != NULL && strncasecmp (pToken, tmp1, strlen (tmp1)) == 0)
1666        {
1667          char *tmp2 = url_decode (tmp1);
1668          snprintf (cursor_input, (strlen (tmp2) + 1) * sizeof (char), "%s",
1669                    tmp2);
1670          free (tmp2);
1671          pToken = strtok (cursor_input, ";");
1672        }
1673      free (tmp1);
1674
1675      char **inputs_as_text = (char **) malloc (100 * sizeof (char *));
1676      if (inputs_as_text == NULL)
1677        {
1678          return errorException (m, _("Unable to allocate memory."),
1679                                 "InternalError", NULL);
1680        }
1681      i = 0;
1682      while (pToken != NULL)
1683        {
1684#ifdef DEBUG
1685          fprintf (stderr, "***%s***\n", pToken);
1686#endif
1687          fflush (stderr);
1688#ifdef DEBUG
1689          fprintf (stderr, "***%s***\n", pToken);
1690#endif
1691          inputs_as_text[i] =
1692            (char *) malloc ((strlen (pToken) + 1) * sizeof (char));
1693          snprintf (inputs_as_text[i], strlen (pToken) + 1, "%s", pToken);
1694          if (inputs_as_text[i] == NULL)
1695            {
1696              return errorException (m, _("Unable to allocate memory."),
1697                                     "InternalError", NULL);
1698            }
1699          pToken = strtok (NULL, ";");
1700          i++;
1701        }
1702
1703      for (j = 0; j < i; j++)
1704        {
1705          char *tmp = zStrdup (inputs_as_text[j]);
1706          free (inputs_as_text[j]);
1707          char *tmpc;
1708          tmpc = strtok (tmp, "@");
1709          while (tmpc != NULL)
1710            {
1711#ifdef DEBUG
1712              fprintf (stderr, "***\n***%s***\n", tmpc);
1713#endif
1714              char *tmpv = strstr (tmpc, "=");
1715              char tmpn[256];
1716              memset (tmpn, 0, 256);
1717              if (tmpv != NULL)
1718                {
1719                  strncpy (tmpn, tmpc,
1720                           (strlen (tmpc) - strlen (tmpv)) * sizeof (char));
1721                  tmpn[strlen (tmpc) - strlen (tmpv)] = 0;
1722                }
1723              else
1724                {
1725                  strncpy (tmpn, tmpc, strlen (tmpc) * sizeof (char));
1726                  tmpn[strlen (tmpc)] = 0;
1727                }
1728#ifdef DEBUG
1729              fprintf (stderr, "***\n*** %s = %s ***\n", tmpn, tmpv + 1);
1730#endif
1731              if (tmpmaps == NULL)
1732                {
1733                  tmpmaps = (maps *) malloc (MAPS_SIZE);
1734                  if (tmpmaps == NULL)
1735                    {
1736                      return errorException (m,
1737                                             _("Unable to allocate memory."),
1738                                             "InternalError", NULL);
1739                    }
1740                  tmpmaps->name = zStrdup (tmpn);
1741                  if (tmpv != NULL)
1742                    {
1743                      char *tmpvf = url_decode (tmpv + 1);
1744                      tmpmaps->content = createMap ("value", tmpvf);
1745                      free (tmpvf);
1746                    }
1747                  else
1748                    tmpmaps->content = createMap ("value", "Reference");
1749                  tmpmaps->next = NULL;
1750                }
1751              tmpc = strtok (NULL, "@");
1752              while (tmpc != NULL)
1753                {
1754#ifdef DEBUG
1755                  fprintf (stderr, "*** KVP NON URL-ENCODED \n***%s***\n",
1756                           tmpc);
1757#endif
1758                  char *tmpv1 = strstr (tmpc, "=");
1759#ifdef DEBUG
1760                  fprintf (stderr, "*** VALUE NON URL-ENCODED \n***%s***\n",
1761                           tmpv1 + 1);
1762#endif
1763                  char tmpn1[1024];
1764                  memset (tmpn1, 0, 1024);
1765                  if (tmpv1 != NULL)
1766                    {
1767                      strncpy (tmpn1, tmpc, strlen (tmpc) - strlen (tmpv1));
1768                      tmpn1[strlen (tmpc) - strlen (tmpv1)] = 0;
1769                      addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
1770                    }
1771                  else
1772                    {
1773                      strncpy (tmpn1, tmpc, strlen (tmpc));
1774                      tmpn1[strlen (tmpc)] = 0;
1775                      map *lmap = getLastMap (tmpmaps->content);
1776                      char *tmpValue =
1777                        (char *) malloc ((strlen (tmpv) + strlen (tmpc) + 1) *
1778                                         sizeof (char));
1779                      sprintf (tmpValue, "%s@%s", tmpv + 1, tmpc);
1780                      free (lmap->value);
1781                      lmap->value = zStrdup (tmpValue);
1782                      free (tmpValue);
1783                      tmpc = strtok (NULL, "@");
1784                      continue;
1785                    }
1786#ifdef DEBUG
1787                  fprintf (stderr, "*** NAME NON URL-ENCODED \n***%s***\n",
1788                           tmpn1);
1789                  fprintf (stderr, "*** VALUE NON URL-ENCODED \n***%s***\n",
1790                           tmpv1 + 1);
1791#endif
1792                  if (strcmp (tmpn1, "xlink:href") != 0)
1793                    addToMap (tmpmaps->content, tmpn1, tmpv1 + 1);
1794                  else if (tmpv1 != NULL)
1795                    {
1796                      char *tmpx2 = url_decode (tmpv1 + 1);
1797                      if (strncasecmp (tmpx2, "http://", 7) != 0 &&
1798                          strncasecmp (tmpx2, "ftp://", 6) != 0 &&
1799                          strncasecmp (tmpx2, "https://", 8) != 0)
1800                        {
1801                          char emsg[1024];
1802                          sprintf (emsg,
1803                                   _
1804                                   ("Unable to find a valid protocol to download the remote file %s"),
1805                                   tmpv1 + 1);
1806                          errorException (m, emsg, "InternalError", NULL);
1807                          freeMaps (&m);
1808                          free (m);
1809                          free (REQUEST);
1810                          free (SERVICE_URL);
1811                          InternetCloseHandle (&hInternet);
1812                          freeService (&s1);
1813                          free (s1);
1814                          return 0;
1815                        }
1816#ifdef DEBUG
1817                      fprintf (stderr,
1818                               "REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",
1819                               tmpv1 + 1);
1820#endif
1821                      addToMap (tmpmaps->content, tmpn1, tmpx2);
1822#ifndef WIN32
1823                      if (CHECK_INET_HANDLE (hInternet))
1824#endif
1825                        {
1826                          if (loadRemoteFile
1827                              (&m, &tmpmaps->content, &hInternet, tmpx2) < 0)
1828                            {
1829                              freeMaps (&m);
1830                              free (m);
1831                              free (REQUEST);
1832                              free (SERVICE_URL);
1833                              InternetCloseHandle (&hInternet);
1834                              freeService (&s1);
1835                              free (s1);
1836                              return 0;
1837                            }
1838                        }
1839                      free (tmpx2);
1840                      addToMap (tmpmaps->content, "Reference", tmpv1 + 1);
1841                    }
1842                  tmpc = strtok (NULL, "@");
1843                }
1844#ifdef DEBUG
1845              dumpMaps (tmpmaps);
1846              fflush (stderr);
1847#endif
1848              if (request_input_real_format == NULL)
1849                request_input_real_format = dupMaps (&tmpmaps);
1850              else
1851                {
1852                  maps *testPresence =
1853                    getMaps (request_input_real_format, tmpmaps->name);
1854                  if (testPresence != NULL)
1855                    {
1856                      elements *elem =
1857                        getElements (s1->inputs, tmpmaps->name);
1858                      if (elem != NULL)
1859                        {
1860                          if (appendMapsToMaps
1861                              (m, request_input_real_format, tmpmaps,
1862                               elem) < 0)
1863                            {
1864                              freeMaps (&m);
1865                              free (m);
1866                              free (REQUEST);
1867                              free (SERVICE_URL);
1868                              InternetCloseHandle (&hInternet);
1869                              freeService (&s1);
1870                              free (s1);
1871                              return 0;
1872                            }
1873                        }
1874                    }
1875                  else
1876                    addMapsToMaps (&request_input_real_format, tmpmaps);
1877                }
1878              freeMaps (&tmpmaps);
1879              free (tmpmaps);
1880              tmpmaps = NULL;
1881              free (tmp);
1882            }
1883        }
1884      free (inputs_as_text);
1885    }
1886  else
1887    {
1888    /**
1889     * Parse XML request
1890     */
1891      xmlInitParser ();
1892#ifdef DEBUG
1893      fflush (stderr);
1894      fprintf (stderr, "BEFORE %s\n", postRequest->value);
1895      fflush (stderr);
1896#endif
1897      xmlDocPtr doc = xmlParseMemory (postRequest->value, cgiContentLength);
1898#ifdef DEBUG
1899      fprintf (stderr, "AFTER\n");
1900      fflush (stderr);
1901#endif
1902    /**
1903     * Parse every Input in DataInputs node.
1904     */
1905      xmlXPathObjectPtr tmpsptr =
1906        extractFromDoc (doc, "/*/*/*[local-name()='Input']");
1907      xmlNodeSet *tmps = tmpsptr->nodesetval;
1908#ifdef DEBUG
1909      fprintf (stderr, "*****%d*****\n", tmps->nodeNr);
1910#endif
1911      for (int k = 0; k < tmps->nodeNr; k++)
1912        {
1913          maps *tmpmaps = NULL;
1914          xmlNodePtr cur = tmps->nodeTab[k];
1915          if (tmps->nodeTab[k]->type == XML_ELEMENT_NODE)
1916            {
1917        /**
1918         * A specific Input node.
1919         */
1920#ifdef DEBUG
1921              fprintf (stderr, "= element 0 node \"%s\"\n", cur->name);
1922#endif
1923              xmlNodePtr cur2 = cur->children;
1924              while (cur2 != NULL)
1925                {
1926                  while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
1927                    cur2 = cur2->next;
1928                  if (cur2 == NULL)
1929                    break;
1930          /**
1931           * Indentifier
1932           */
1933                  if (xmlStrncasecmp
1934                      (cur2->name, BAD_CAST "Identifier",
1935                       xmlStrlen (cur2->name)) == 0)
1936                    {
1937                      xmlChar *val =
1938                        xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
1939                      if (tmpmaps == NULL)
1940                        {
1941                          tmpmaps = (maps *) malloc (MAPS_SIZE);
1942                          if (tmpmaps == NULL)
1943                            {
1944                              return errorException (m,
1945                                                     _
1946                                                     ("Unable to allocate memory."),
1947                                                     "InternalError", NULL);
1948                            }
1949                          tmpmaps->name = zStrdup ((char *) val);
1950                          tmpmaps->content = NULL;
1951                          tmpmaps->next = NULL;
1952                        }
1953                      xmlFree (val);
1954                    }
1955          /**
1956           * Title, Asbtract
1957           */
1958                  if (xmlStrncasecmp
1959                      (cur2->name, BAD_CAST "Title",
1960                       xmlStrlen (cur2->name)) == 0
1961                      || xmlStrncasecmp (cur2->name, BAD_CAST "Abstract",
1962                                         xmlStrlen (cur2->name)) == 0)
1963                    {
1964                      xmlChar *val =
1965                        xmlNodeListGetString (doc, cur2->xmlChildrenNode, 1);
1966                      if (tmpmaps == NULL)
1967                        {
1968                          tmpmaps = (maps *) malloc (MAPS_SIZE);
1969                          if (tmpmaps == NULL)
1970                            {
1971                              return errorException (m,
1972                                                     _
1973                                                     ("Unable to allocate memory."),
1974                                                     "InternalError", NULL);
1975                            }
1976                          tmpmaps->name = zStrdup ("missingIndetifier");
1977                          tmpmaps->content =
1978                            createMap ((char *) cur2->name, (char *) val);
1979                          tmpmaps->next = NULL;
1980                        }
1981                      else
1982                        {
1983                          if (tmpmaps->content != NULL)
1984                            addToMap (tmpmaps->content,
1985                                      (char *) cur2->name, (char *) val);
1986                          else
1987                            tmpmaps->content =
1988                              createMap ((char *) cur2->name, (char *) val);
1989                        }
1990#ifdef DEBUG
1991                      dumpMaps (tmpmaps);
1992#endif
1993                      xmlFree (val);
1994                    }
1995          /**
1996           * InputDataFormChoice (Reference or Data ?)
1997           */
1998                  if (xmlStrcasecmp (cur2->name, BAD_CAST "Reference") == 0)
1999                    {
2000            /**
2001             * Get every attribute from a Reference node
2002             * mimeType, encoding, schema, href, method
2003             * Header and Body gesture should be added here
2004             */
2005#ifdef DEBUG
2006                      fprintf (stderr, "REFERENCE\n");
2007#endif
2008                      const char *refs[5] =
2009                        { "mimeType", "encoding", "schema", "method",
2010                        "href"
2011                      };
2012                      for (int l = 0; l < 5; l++)
2013                        {
2014#ifdef DEBUG
2015                          fprintf (stderr, "*** %s ***", refs[l]);
2016#endif
2017                          xmlChar *val = xmlGetProp (cur2, BAD_CAST refs[l]);
2018                          if (val != NULL && xmlStrlen (val) > 0)
2019                            {
2020                              if (tmpmaps->content != NULL)
2021                                addToMap (tmpmaps->content, refs[l],
2022                                          (char *) val);
2023                              else
2024                                tmpmaps->content =
2025                                  createMap (refs[l], (char *) val);
2026                              map *ltmp = getMap (tmpmaps->content, "method");
2027                              if (l == 4)
2028                                {
2029                                  if (!
2030                                      (ltmp != NULL
2031                                       && strncmp (ltmp->value, "POST",
2032                                                   4) == 0)
2033                                      && CHECK_INET_HANDLE (hInternet))
2034                                    {
2035                                      if (loadRemoteFile
2036                                          (&m, &tmpmaps->content, &hInternet,
2037                                           (char *) val) != 0)
2038                                        {
2039                                          freeMaps (&m);
2040                                          free (m);
2041                                          free (REQUEST);
2042                                          free (SERVICE_URL);
2043                                          InternetCloseHandle (&hInternet);
2044                                          freeService (&s1);
2045                                          free (s1);
2046                                          return 0;
2047                                        }
2048                                    }
2049                                }
2050                            }
2051#ifdef DEBUG
2052                          fprintf (stderr, "%s\n", val);
2053#endif
2054                          xmlFree (val);
2055                        }
2056#ifdef POST_DEBUG
2057                      fprintf (stderr,
2058                               "Parse Header and Body from Reference \n");
2059#endif
2060                      xmlNodePtr cur3 = cur2->children;
2061                      /*      HINTERNET hInternetP;
2062                         hInternetP=InternetOpen(
2063                         #ifndef WIN32
2064                         (LPCTSTR)
2065                         #endif
2066                         "ZooWPSClient\0",
2067                         INTERNET_OPEN_TYPE_PRECONFIG,
2068                         NULL,NULL, 0); */
2069                      //hInternet.ihandle[hInternet.nb].header=NULL;
2070                      while (cur3 != NULL)
2071                        {
2072                          while (cur3 != NULL
2073                                 && cur3->type != XML_ELEMENT_NODE)
2074                            cur3 = cur3->next;
2075                          if (cur3 == NULL)
2076                            break;
2077                          if (xmlStrcasecmp (cur3->name, BAD_CAST "Header") ==
2078                              0)
2079                            {
2080                              const char *ha[2];
2081                              ha[0] = "key";
2082                              ha[1] = "value";
2083                              int hai;
2084                              char *has;
2085                              char *key;
2086                              for (hai = 0; hai < 2; hai++)
2087                                {
2088                                  xmlChar *val =
2089                                    xmlGetProp (cur3, BAD_CAST ha[hai]);
2090#ifdef POST_DEBUG
2091                                  fprintf (stderr, "%s = %s\n", ha[hai],
2092                                           (char *) val);
2093#endif
2094                                  if (hai == 0)
2095                                    {
2096                                      key = zStrdup ((char *) val);
2097                                    }
2098                                  else
2099                                    {
2100                                      has =
2101                                        (char *)
2102                                        malloc ((4 + xmlStrlen (val) +
2103                                                 strlen (key)) *
2104                                                sizeof (char));
2105                                      if (has == NULL)
2106                                        {
2107                                          return errorException (m,
2108                                                                 _
2109                                                                 ("Unable to allocate memory."),
2110                                                                 "InternalError",
2111                                                                 NULL);
2112                                        }
2113                                      snprintf (has,
2114                                                (3 + xmlStrlen (val) +
2115                                                 strlen (key)), "%s: %s", key,
2116                                                (char *) val);
2117                                      free (key);
2118#ifdef POST_DEBUG
2119                                      fprintf (stderr, "%s\n", has);
2120#endif
2121                                    }
2122                                  xmlFree (val);
2123                                }
2124                              hInternet.ihandle[hInternet.nb].header =
2125                                curl_slist_append (hInternet.ihandle
2126                                                   [hInternet.nb].header,
2127                                                   has);
2128                              if (has != NULL)
2129                                free (has);
2130                            }
2131                          else
2132                            {
2133#ifdef POST_DEBUG
2134                              fprintf (stderr,
2135                                       "Try to fetch the body part of the request ...\n");
2136#endif
2137                              if (xmlStrcasecmp (cur3->name, BAD_CAST "Body")
2138                                  == 0)
2139                                {
2140#ifdef POST_DEBUG
2141                                  fprintf (stderr, "Body part found !!!\n",
2142                                           (char *) cur3->content);
2143#endif
2144                                  char *tmp =
2145                                    (char *) malloc (cgiContentLength +
2146                                                     1 * sizeof (char));
2147                                  memset (tmp, 0, cgiContentLength);
2148                                  xmlNodePtr cur4 = cur3->children;
2149                                  while (cur4 != NULL)
2150                                    {
2151                                      while (cur4->type != XML_ELEMENT_NODE)
2152                                        cur4 = cur4->next;
2153                                      xmlDocPtr bdoc =
2154                                        xmlNewDoc (BAD_CAST "1.0");
2155                                      bdoc->encoding =
2156                                        xmlCharStrdup ("UTF-8");
2157                                      xmlDocSetRootElement (bdoc, cur4);
2158                                      xmlChar *btmps;
2159                                      int bsize;
2160                                      xmlDocDumpMemory (bdoc, &btmps, &bsize);
2161#ifdef POST_DEBUG
2162                                      fprintf (stderr,
2163                                               "Body part found !!! %s %s\n",
2164                                               tmp, (char *) btmps);
2165#endif
2166                                      if (btmps != NULL)
2167                                        sprintf (tmp, "%s", (char *) btmps);
2168                                      xmlFree (btmps);
2169                                      cur4 = cur4->next;
2170                                      xmlFreeDoc (bdoc);
2171                                    }
2172                                  map *btmp =
2173                                    getMap (tmpmaps->content, "href");
2174                                  if (btmp != NULL)
2175                                    {
2176#ifdef POST_DEBUG
2177                                      fprintf (stderr, "%s %s\n", btmp->value,
2178                                               tmp);
2179                                      curl_easy_setopt (hInternet.handle,
2180                                                        CURLOPT_VERBOSE, 1);
2181#endif
2182                                      hInternet.
2183                                        waitingRequests[hInternet.nb] =
2184                                        strdup (tmp);
2185                                      InternetOpenUrl (&hInternet,
2186                                                       btmp->value,
2187                                                       hInternet.waitingRequests
2188                                                       [hInternet.nb],
2189                                                       strlen
2190                                                       (hInternet.waitingRequests
2191                                                        [hInternet.nb]),
2192                                                       INTERNET_FLAG_NO_CACHE_WRITE,
2193                                                       0);
2194                                    }
2195                                  free (tmp);
2196                                }
2197                              else
2198                                if (xmlStrcasecmp
2199                                    (cur3->name,
2200                                     BAD_CAST "BodyReference") == 0)
2201                                {
2202                                  xmlChar *val =
2203                                    xmlGetProp (cur3, BAD_CAST "href");
2204                                  HINTERNET bInternet, res1;
2205                                  bInternet = InternetOpen (
2206#ifndef WIN32
2207                                                             (LPCTSTR)
2208#endif
2209                                                             "ZooWPSClient\0",
2210                                                             INTERNET_OPEN_TYPE_PRECONFIG,
2211                                                             NULL, NULL, 0);
2212                                  if (!CHECK_INET_HANDLE (hInternet))
2213                                    fprintf (stderr,
2214                                             "WARNING : hInternet handle failed to initialize");
2215#ifdef POST_DEBUG
2216                                  curl_easy_setopt (bInternet.handle,
2217                                                    CURLOPT_VERBOSE, 1);
2218#endif
2219                                  bInternet.waitingRequests[0] =
2220                                    strdup ((char *) val);
2221                                  res1 =
2222                                    InternetOpenUrl (&bInternet,
2223                                                     bInternet.waitingRequests
2224                                                     [0], NULL, 0,
2225                                                     INTERNET_FLAG_NO_CACHE_WRITE,
2226                                                     0);
2227                                  processDownloads (&bInternet);
2228                                  char *tmp =
2229                                    (char *)
2230                                    malloc ((bInternet.ihandle[0].nDataLen +
2231                                             1) * sizeof (char));
2232                                  if (tmp == NULL)
2233                                    {
2234                                      return errorException (m,
2235                                                             _
2236                                                             ("Unable to allocate memory."),
2237                                                             "InternalError",
2238                                                             NULL);
2239                                    }
2240                                  size_t bRead;
2241                                  InternetReadFile (bInternet.ihandle[0],
2242                                                    (LPVOID) tmp,
2243                                                    bInternet.
2244                                                    ihandle[0].nDataLen,
2245                                                    &bRead);
2246                                  tmp[bInternet.ihandle[0].nDataLen] = 0;
2247                                  InternetCloseHandle (&bInternet);
2248                                  map *btmp =
2249                                    getMap (tmpmaps->content, "href");
2250                                  if (btmp != NULL)
2251                                    {
2252#ifdef POST_DEBUG
2253                                      fprintf (stderr, "%s %s\n", btmp->value,
2254                                               tmp);
2255#endif
2256                                      hInternet.
2257                                        waitingRequests[hInternet.nb] =
2258                                        strdup (tmp);
2259                                      res =
2260                                        InternetOpenUrl (&hInternet,
2261                                                         btmp->value,
2262                                                         hInternet.waitingRequests
2263                                                         [hInternet.nb],
2264                                                         strlen
2265                                                         (hInternet.waitingRequests
2266                                                          [hInternet.nb]),
2267                                                         INTERNET_FLAG_NO_CACHE_WRITE,
2268                                                         0);
2269                                    }
2270                                  free (tmp);
2271                                }
2272                            }
2273                          cur3 = cur3->next;
2274                        }
2275#ifdef POST_DEBUG
2276                      fprintf (stderr,
2277                               "Header and Body was parsed from Reference \n");
2278#endif
2279#ifdef DEBUG
2280                      dumpMap (tmpmaps->content);
2281                      fprintf (stderr, "= element 2 node \"%s\" = (%s)\n",
2282                               cur2->name, cur2->content);
2283#endif
2284                    }
2285                  else if (xmlStrcasecmp (cur2->name, BAD_CAST "Data") == 0)
2286                    {
2287#ifdef DEBUG
2288                      fprintf (stderr, "DATA\n");
2289#endif
2290                      xmlNodePtr cur4 = cur2->children;
2291                      while (cur4 != NULL)
2292                        {
2293                          while (cur4 != NULL
2294                                 && cur4->type != XML_ELEMENT_NODE)
2295                            cur4 = cur4->next;
2296                          if (cur4 == NULL)
2297                            break;
2298                          if (xmlStrcasecmp
2299                              (cur4->name, BAD_CAST "LiteralData") == 0)
2300                            {
2301                /**
2302                 * Get every attribute from a LiteralData node
2303                 * dataType , uom
2304                 */
2305                              char *list[2];
2306                              list[0] = zStrdup ("dataType");
2307                              list[1] = zStrdup ("uom");
2308                              for (int l = 0; l < 2; l++)
2309                                {
2310#ifdef DEBUG
2311                                  fprintf (stderr, "*** LiteralData %s ***",
2312                                           list[l]);
2313#endif
2314                                  xmlChar *val =
2315                                    xmlGetProp (cur4, BAD_CAST list[l]);
2316                                  if (val != NULL
2317                                      && strlen ((char *) val) > 0)
2318                                    {
2319                                      if (tmpmaps->content != NULL)
2320                                        addToMap (tmpmaps->content, list[l],
2321                                                  (char *) val);
2322                                      else
2323                                        tmpmaps->content =
2324                                          createMap (list[l], (char *) val);
2325#ifdef DEBUG
2326                                      fprintf (stderr, "%s\n", val);
2327#endif
2328                                    }
2329                                  xmlFree (val);
2330                                  free (list[l]);
2331                                }
2332                            }
2333                          else
2334                            if (xmlStrcasecmp
2335                                (cur4->name, BAD_CAST "ComplexData") == 0)
2336                            {
2337                /**
2338                 * Get every attribute from a Reference node
2339                 * mimeType, encoding, schema
2340                 */
2341                              const char *coms[3] =
2342                                { "mimeType", "encoding", "schema" };
2343                              for (int l = 0; l < 3; l++)
2344                                {
2345#ifdef DEBUG
2346                                  fprintf (stderr, "*** ComplexData %s ***\n",
2347                                           coms[l]);
2348#endif
2349                                  xmlChar *val =
2350                                    xmlGetProp (cur4, BAD_CAST coms[l]);
2351                                  if (val != NULL
2352                                      && strlen ((char *) val) > 0)
2353                                    {
2354                                      if (tmpmaps->content != NULL)
2355                                        addToMap (tmpmaps->content, coms[l],
2356                                                  (char *) val);
2357                                      else
2358                                        tmpmaps->content =
2359                                          createMap (coms[l], (char *) val);
2360#ifdef DEBUG
2361                                      fprintf (stderr, "%s\n", val);
2362#endif
2363                                    }
2364                                  xmlFree (val);
2365                                }
2366                            }
2367
2368                          map *test = getMap (tmpmaps->content, "encoding");
2369                          if (test == NULL)
2370                            {
2371                              if (tmpmaps->content != NULL)
2372                                addToMap (tmpmaps->content, "encoding",
2373                                          "utf-8");
2374                              else
2375                                tmpmaps->content =
2376                                  createMap ("encoding", "utf-8");
2377                              test = getMap (tmpmaps->content, "encoding");
2378                            }
2379
2380                          if (strcasecmp (test->value, "base64") != 0)
2381                            {
2382                              xmlChar *mv = xmlNodeListGetString (doc,
2383                                                                  cur4->
2384                                                                  xmlChildrenNode,
2385                                                                  1);
2386                              map *ltmp =
2387                                getMap (tmpmaps->content, "mimeType");
2388                              if (mv == NULL
2389                                  ||
2390                                  (xmlStrcasecmp
2391                                   (cur4->name, BAD_CAST "ComplexData") == 0
2392                                   && (ltmp == NULL
2393                                       || strncasecmp (ltmp->value,
2394                                                       "text/xml", 8) == 0)))
2395                                {
2396                                  xmlDocPtr doc1 = xmlNewDoc (BAD_CAST "1.0");
2397                                  int buffersize;
2398                                  xmlNodePtr cur5 = cur4->children;
2399                                  while (cur5 != NULL
2400                                         && cur5->type != XML_ELEMENT_NODE
2401                                         && cur5->type !=
2402                                         XML_CDATA_SECTION_NODE)
2403                                    cur5 = cur5->next;
2404                                  if (cur5 != NULL
2405                                      && cur5->type != XML_CDATA_SECTION_NODE)
2406                                    {
2407                                      xmlDocSetRootElement (doc1, cur5);
2408                                      xmlDocDumpFormatMemoryEnc (doc1, &mv,
2409                                                                 &buffersize,
2410                                                                 "utf-8", 1);
2411                                      char size[1024];
2412                                      sprintf (size, "%d", buffersize);
2413                                      addToMap (tmpmaps->content, "size",
2414                                                size);
2415                                      xmlFreeDoc (doc1);
2416                                    }
2417                                }
2418                              if (mv != NULL)
2419                                {
2420                                  addToMap (tmpmaps->content, "value",
2421                                            (char *) mv);
2422                                  xmlFree (mv);
2423                                }
2424                            }
2425                          else
2426                            {
2427                              xmlChar *tmp = xmlNodeListGetRawString (doc,
2428                                                                      cur4->xmlChildrenNode,
2429                                                                      0);
2430                              addToMap (tmpmaps->content, "value",
2431                                        (char *) tmp);
2432                              map *tmpv = getMap (tmpmaps->content, "value");
2433                              char *res = NULL;
2434                              char *curs = tmpv->value;
2435                              for (int i = 0; i <= strlen (tmpv->value) / 64;
2436                                   i++)
2437                                {
2438                                  if (res == NULL)
2439                                    res =
2440                                      (char *) malloc (67 * sizeof (char));
2441                                  else
2442                                    res =
2443                                      (char *) realloc (res,
2444                                                        (((i + 1) * 65) +
2445                                                         i) * sizeof (char));
2446                                  int csize = i * 65;
2447                                  strncpy (res + csize, curs, 64);
2448                                  if (i == xmlStrlen (tmp) / 64)
2449                                    strcat (res, "\n\0");
2450                                  else
2451                                    {
2452                                      strncpy (res + (((i + 1) * 64) + i),
2453                                               "\n\0", 2);
2454                                      curs += 64;
2455                                    }
2456                                }
2457                              free (tmpv->value);
2458                              tmpv->value = zStrdup (res);
2459                              free (res);
2460                              xmlFree (tmp);
2461                            }
2462                          cur4 = cur4->next;
2463                        }
2464                    }
2465#ifdef DEBUG
2466                  fprintf (stderr, "cur2 next \n");
2467                  fflush (stderr);
2468#endif
2469                  cur2 = cur2->next;
2470                }
2471#ifdef DEBUG
2472              fprintf (stderr, "ADD MAPS TO REQUEST MAPS !\n");
2473              fflush (stderr);
2474#endif
2475
2476              {
2477                maps *testPresence =
2478                  getMaps (request_input_real_format, tmpmaps->name);
2479                if (testPresence != NULL)
2480                  {
2481                    elements *elem = getElements (s1->inputs, tmpmaps->name);
2482                    if (elem != NULL)
2483                      {
2484                        if (appendMapsToMaps
2485                            (m, request_input_real_format, tmpmaps, elem) < 0)
2486                          {
2487                            freeMaps (&m);
2488                            free (m);
2489                            free (REQUEST);
2490                            free (SERVICE_URL);
2491                            InternetCloseHandle (&hInternet);
2492                            freeService (&s1);
2493                            free (s1);
2494                            return 0;
2495                          }
2496                      }
2497                  }
2498                else
2499                  addMapsToMaps (&request_input_real_format, tmpmaps);
2500              }
2501
2502#ifdef DEBUG
2503              fprintf (stderr, "******TMPMAPS*****\n");
2504              dumpMaps (tmpmaps);
2505              fprintf (stderr, "******REQUESTMAPS*****\n");
2506              dumpMaps (request_input_real_format);
2507#endif
2508              freeMaps (&tmpmaps);
2509              free (tmpmaps);
2510              tmpmaps = NULL;
2511            }
2512#ifdef DEBUG
2513          dumpMaps (tmpmaps);
2514#endif
2515        }
2516#ifdef DEBUG
2517      fprintf (stderr, "Search for response document node\n");
2518#endif
2519      xmlXPathFreeObject (tmpsptr);
2520
2521      tmpsptr =
2522        extractFromDoc (doc, "/*/*/*[local-name()='ResponseDocument']");
2523      bool asRaw = false;
2524      tmps = tmpsptr->nodesetval;
2525      if (tmps->nodeNr == 0)
2526        {
2527          xmlXPathFreeObject (tmpsptr);
2528          tmpsptr =
2529            extractFromDoc (doc, "/*/*/*[local-name()='RawDataOutput']");
2530          tmps = tmpsptr->nodesetval;
2531          asRaw = true;
2532        }
2533#ifdef DEBUG
2534      fprintf (stderr, "*****%d*****\n", tmps->nodeNr);
2535#endif
2536      if (asRaw == true)
2537        {
2538          addToMap (request_inputs, "RawDataOutput", "");
2539          xmlNodePtr cur0 = tmps->nodeTab[0];
2540          if (cur0->type == XML_ELEMENT_NODE)
2541            {
2542
2543              maps *tmpmaps = (maps *) malloc (MAPS_SIZE);
2544              if (tmpmaps == NULL)
2545                {
2546                  return errorException (m, _("Unable to allocate memory."),
2547                                         "InternalError", NULL);
2548                }
2549              tmpmaps->name = zStrdup ("unknownIdentifier");
2550              tmpmaps->content = NULL;
2551              tmpmaps->next = NULL;
2552
2553        /**
2554         * Get every attribute from a RawDataOutput node
2555         * mimeType, encoding, schema, uom
2556         */
2557              const char *outs[4] =
2558                { "mimeType", "encoding", "schema", "uom" };
2559              for (int l = 0; l < 4; l++)
2560                {
2561#ifdef DEBUG
2562                  fprintf (stderr, "*** %s ***\t", outs[l]);
2563#endif
2564                  xmlChar *val = xmlGetProp (cur0, BAD_CAST outs[l]);
2565                  if (val != NULL)
2566                    {
2567                      if (strlen ((char *) val) > 0)
2568                        {
2569                          if (tmpmaps->content != NULL)
2570                            addToMap (tmpmaps->content, outs[l],
2571                                      (char *) val);
2572                          else
2573                            tmpmaps->content =
2574                              createMap (outs[l], (char *) val);
2575                        }
2576                      xmlFree (val);
2577                    }
2578                }
2579              xmlNodePtr cur2 = cur0->children;
2580              while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
2581                cur2 = cur2->next;
2582              int cur1cnt = 0;
2583              while (cur2 != NULL)
2584                {
2585                  if (xmlStrncasecmp
2586                      (cur2->name, BAD_CAST "Identifier",
2587                       xmlStrlen (cur2->name)) == 0)
2588                    {
2589                      xmlChar *val =
2590                        xmlNodeListGetString (NULL, cur2->xmlChildrenNode, 1);
2591                      free (tmpmaps->name);
2592                      tmpmaps->name = zStrdup ((char *) val);
2593                      xmlFree (val);
2594                    }
2595                  cur2 = cur2->next;
2596                  while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
2597                    cur2 = cur2->next;
2598                }
2599              if (request_output_real_format == NULL)
2600                request_output_real_format = dupMaps (&tmpmaps);
2601              else
2602                addMapsToMaps (&request_output_real_format, tmpmaps);
2603              if (tmpmaps != NULL)
2604                {
2605                  freeMaps (&tmpmaps);
2606                  free (tmpmaps);
2607                  tmpmaps = NULL;
2608                }
2609            }
2610        }
2611      else
2612        for (int k = 0; k < tmps->nodeNr; k++)
2613          {
2614            //else
2615            addToMap (request_inputs, "ResponseDocument", "");
2616            maps *tmpmaps = NULL;
2617            xmlNodePtr cur = tmps->nodeTab[k];
2618            if (cur->type == XML_ELEMENT_NODE)
2619              {
2620          /**
2621           * A specific responseDocument node.
2622           */
2623                if (tmpmaps == NULL)
2624                  {
2625                    tmpmaps = (maps *) malloc (MAPS_SIZE);
2626                    if (tmpmaps == NULL)
2627                      {
2628                        return errorException (m,
2629                                               _
2630                                               ("Unable to allocate memory."),
2631                                               "InternalError", NULL);
2632                      }
2633                    tmpmaps->name = zStrdup ("unknownIdentifier");
2634                    tmpmaps->content = NULL;
2635                    tmpmaps->next = NULL;
2636                  }
2637          /**
2638           * Get every attribute: storeExecuteResponse, lineage, status
2639           */
2640                const char *ress[3] =
2641                  { "storeExecuteResponse", "lineage", "status" };
2642                xmlChar *val;
2643                for (int l = 0; l < 3; l++)
2644                  {
2645#ifdef DEBUG
2646                    fprintf (stderr, "*** %s ***\t", ress[l]);
2647#endif
2648                    val = xmlGetProp (cur, BAD_CAST ress[l]);
2649                    if (val != NULL && strlen ((char *) val) > 0)
2650                      {
2651                        if (tmpmaps->content != NULL)
2652                          addToMap (tmpmaps->content, ress[l], (char *) val);
2653                        else
2654                          tmpmaps->content =
2655                            createMap (ress[l], (char *) val);
2656                        addToMap (request_inputs, ress[l], (char *) val);
2657                      }
2658#ifdef DEBUG
2659                    fprintf (stderr, "%s\n", val);
2660#endif
2661                    xmlFree (val);
2662                  }
2663                xmlNodePtr cur1 = cur->children;
2664                while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
2665                  cur1 = cur1->next;
2666                int cur1cnt = 0;
2667                while (cur1)
2668                  {
2669            /**
2670             * Indentifier
2671             */
2672                    if (xmlStrncasecmp
2673                        (cur1->name, BAD_CAST "Identifier",
2674                         xmlStrlen (cur1->name)) == 0)
2675                      {
2676                        xmlChar *val =
2677                          xmlNodeListGetString (doc, cur1->xmlChildrenNode,
2678                                                1);
2679                        if (tmpmaps == NULL)
2680                          {
2681                            tmpmaps = (maps *) malloc (MAPS_SIZE);
2682                            if (tmpmaps == NULL)
2683                              {
2684                                return errorException (m,
2685                                                       _
2686                                                       ("Unable to allocate memory."),
2687                                                       "InternalError", NULL);
2688                              }
2689                            tmpmaps->name = zStrdup ((char *) val);
2690                            tmpmaps->content = NULL;
2691                            tmpmaps->next = NULL;
2692                          }
2693                        else
2694                          {
2695                            free (tmpmaps->name);
2696                            tmpmaps->name = zStrdup ((char *) val);
2697                          }
2698                        if (asRaw == true)
2699                          addToMap (request_inputs, "RawDataOutput",
2700                                    (char *) val);
2701                        else
2702                          {
2703                            if (cur1cnt == 0)
2704                              addToMap (request_inputs, "ResponseDocument",
2705                                        (char *) val);
2706                            else
2707                              {
2708                                map *tt =
2709                                  getMap (request_inputs, "ResponseDocument");
2710                                char *tmp = zStrdup (tt->value);
2711                                free (tt->value);
2712                                tt->value =
2713                                  (char *)
2714                                  malloc ((strlen (tmp) +
2715                                           strlen ((char *) val) +
2716                                           1) * sizeof (char));
2717                                sprintf (tt->value, "%s;%s", tmp,
2718                                         (char *) val);
2719                                free (tmp);
2720                              }
2721                          }
2722                        cur1cnt += 1;
2723                        xmlFree (val);
2724                      }
2725            /**
2726             * Title, Asbtract
2727             */
2728                    else
2729                      if (xmlStrncasecmp
2730                          (cur1->name, BAD_CAST "Title",
2731                           xmlStrlen (cur1->name)) == 0
2732                          || xmlStrncasecmp (cur1->name, BAD_CAST "Abstract",
2733                                             xmlStrlen (cur1->name)) == 0)
2734                      {
2735                        xmlChar *val =
2736                          xmlNodeListGetString (doc, cur1->xmlChildrenNode,
2737                                                1);
2738                        if (tmpmaps == NULL)
2739                          {
2740                            tmpmaps = (maps *) malloc (MAPS_SIZE);
2741                            if (tmpmaps == NULL)
2742                              {
2743                                return errorException (m,
2744                                                       _
2745                                                       ("Unable to allocate memory."),
2746                                                       "InternalError", NULL);
2747                              }
2748                            tmpmaps->name = zStrdup ("missingIndetifier");
2749                            tmpmaps->content =
2750                              createMap ((char *) cur1->name, (char *) val);
2751                            tmpmaps->next = NULL;
2752                          }
2753                        else
2754                          {
2755                            if (tmpmaps->content != NULL)
2756                              addToMap (tmpmaps->content, (char *) cur1->name,
2757                                        (char *) val);
2758                            else
2759                              tmpmaps->content =
2760                                createMap ((char *) cur1->name, (char *) val);
2761                          }
2762                        xmlFree (val);
2763                      }
2764                    else
2765                      if (xmlStrncasecmp
2766                          (cur1->name, BAD_CAST "Output",
2767                           xmlStrlen (cur1->name)) == 0)
2768                      {
2769              /**
2770               * Get every attribute from a Output node
2771               * mimeType, encoding, schema, uom, asReference
2772               */
2773                        const char *outs[5] =
2774                          { "mimeType", "encoding", "schema", "uom",
2775                          "asReference"
2776                        };
2777                        for (int l = 0; l < 5; l++)
2778                          {
2779#ifdef DEBUG
2780                            fprintf (stderr, "*** %s ***\t", outs[l]);
2781#endif
2782                            xmlChar *val =
2783                              xmlGetProp (cur1, BAD_CAST outs[l]);
2784                            if (val != NULL && strlen ((char *) val) > 0)
2785                              {
2786                                if (tmpmaps->content != NULL)
2787                                  addToMap (tmpmaps->content, outs[l],
2788                                            (char *) val);
2789                                else
2790                                  tmpmaps->content =
2791                                    createMap (outs[l], (char *) val);
2792                              }
2793#ifdef DEBUG
2794                            fprintf (stderr, "%s\n", val);
2795#endif
2796                            xmlFree (val);
2797                          }
2798                        xmlNodePtr cur2 = cur1->children;
2799                        while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
2800                          cur2 = cur2->next;
2801                        while (cur2)
2802                          {
2803                /**
2804                 * Indentifier
2805                 */
2806                            if (xmlStrncasecmp
2807                                (cur2->name, BAD_CAST "Identifier",
2808                                 xmlStrlen (cur2->name)) == 0)
2809                              {
2810                                xmlChar *val = xmlNodeListGetString (doc,
2811                                                                     cur2->
2812                                                                     xmlChildrenNode,
2813                                                                     1);
2814                                if (tmpmaps == NULL)
2815                                  {
2816                                    tmpmaps = (maps *) malloc (MAPS_SIZE);
2817                                    if (tmpmaps == NULL)
2818                                      {
2819                                        return errorException (m,
2820                                                               _
2821                                                               ("Unable to allocate memory."),
2822                                                               "InternalError",
2823                                                               NULL);
2824                                      }
2825                                    tmpmaps->name = zStrdup ((char *) val);
2826                                    tmpmaps->content = NULL;
2827                                    tmpmaps->next = NULL;
2828                                  }
2829                                else
2830                                  {
2831                                    if (tmpmaps->name != NULL)
2832                                      free (tmpmaps->name);
2833                                    tmpmaps->name = zStrdup ((char *) val);;
2834                                  }
2835                                xmlFree (val);
2836                              }
2837                /**
2838                 * Title, Asbtract
2839                 */
2840                            else
2841                              if (xmlStrncasecmp
2842                                  (cur2->name, BAD_CAST "Title",
2843                                   xmlStrlen (cur2->name)) == 0
2844                                  || xmlStrncasecmp (cur2->name,
2845                                                     BAD_CAST "Abstract",
2846                                                     xmlStrlen (cur2->name))
2847                                  == 0)
2848                              {
2849                                xmlChar *val = xmlNodeListGetString (doc,
2850                                                                     cur2->
2851                                                                     xmlChildrenNode,
2852                                                                     1);
2853                                if (tmpmaps == NULL)
2854                                  {
2855                                    tmpmaps = (maps *) malloc (MAPS_SIZE);
2856                                    if (tmpmaps == NULL)
2857                                      {
2858                                        return errorException (m,
2859                                                               _
2860                                                               ("Unable to allocate memory."),
2861                                                               "InternalError",
2862                                                               NULL);
2863                                      }
2864                                    tmpmaps->name =
2865                                      zStrdup ("missingIndetifier");
2866                                    tmpmaps->content =
2867                                      createMap ((char *) cur2->name,
2868                                                 (char *) val);
2869                                    tmpmaps->next = NULL;
2870                                  }
2871                                else
2872                                  {
2873                                    if (tmpmaps->content != NULL)
2874                                      addToMap (tmpmaps->content,
2875                                                (char *) cur2->name,
2876                                                (char *) val);
2877                                    else
2878                                      tmpmaps->content =
2879                                        createMap ((char *) cur2->name,
2880                                                   (char *) val);
2881                                  }
2882                                xmlFree (val);
2883                              }
2884                            cur2 = cur2->next;
2885                            while (cur2 != NULL
2886                                   && cur2->type != XML_ELEMENT_NODE)
2887                              cur2 = cur2->next;
2888                          }
2889                      }
2890                    cur1 = cur1->next;
2891                    while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
2892                      cur1 = cur1->next;
2893                  }
2894              }
2895            if (request_output_real_format == NULL)
2896              request_output_real_format = dupMaps (&tmpmaps);
2897            else
2898              addMapsToMaps (&request_output_real_format, tmpmaps);
2899            if (tmpmaps != NULL)
2900              {
2901                freeMaps (&tmpmaps);
2902                free (tmpmaps);
2903                tmpmaps = NULL;
2904              }
2905          }
2906      xmlXPathFreeObject (tmpsptr);
2907      xmlFreeDoc (doc);
2908      xmlCleanupParser ();
2909    }
2910
2911  runHttpRequests (&m, &request_input_real_format, &hInternet);
2912
2913  //  if(CHECK_INET_HANDLE(hInternet))
2914  InternetCloseHandle (&hInternet);
2915
2916#ifdef DEBUG
2917  fprintf (stderr, "\n%d\n", __LINE__);
2918  fflush (stderr);
2919  dumpMaps (request_input_real_format);
2920  dumpMaps (request_output_real_format);
2921  dumpMap (request_inputs);
2922  fprintf (stderr, "\n%d\n", __LINE__);
2923  fflush (stderr);
2924#endif
2925
2926  /**
2927   * Ensure that each requested arguments are present in the request
2928   * DataInputs and ResponseDocument / RawDataOutput
2929   */
2930  char *dfv = addDefaultValues (&request_input_real_format, s1->inputs, m, 0);
2931  maps *ptr = request_input_real_format;
2932  while (ptr != NULL)
2933    {
2934      map *tmp0 = getMap (ptr->content, "size");
2935      map *tmp1 = getMap (ptr->content, "maximumMegabytes");
2936      if (tmp1 != NULL && tmp0 != NULL)
2937        {
2938          float i = atof (tmp0->value) / 1048576.0;
2939          if (i >= atoi (tmp1->value))
2940            {
2941              char tmps[1024];
2942              map *tmpe = createMap ("code", "FileSizeExceeded");
2943              snprintf (tmps, 1024,
2944                        _
2945                        ("The <%s> parameter has a limited size (%sMB) defined in ZOO ServicesProvider configuration file but the reference you provided exceed this limitation (%fMB), please correct your query or the ZOO Configuration file."),
2946                        ptr->name, tmp1->value, i);
2947              addToMap (tmpe, "locator", ptr->name);
2948              addToMap (tmpe, "text", tmps);
2949              printExceptionReportResponse (m, tmpe);
2950              freeService (&s1);
2951              free (s1);
2952              freeMap (&tmpe);
2953              free (tmpe);
2954              freeMaps (&m);
2955              free (m);
2956              free (REQUEST);
2957              free (SERVICE_URL);
2958              freeMaps (&request_input_real_format);
2959              free (request_input_real_format);
2960              freeMaps (&request_output_real_format);
2961              free (request_output_real_format);
2962              freeMaps (&tmpmaps);
2963              free (tmpmaps);
2964              return 1;
2965            }
2966        }
2967      ptr = ptr->next;
2968    }
2969
2970  char *dfv1 =
2971    addDefaultValues (&request_output_real_format, s1->outputs, m, 1);
2972  if (strcmp (dfv1, "") != 0 || strcmp (dfv, "") != 0)
2973    {
2974      char tmps[1024];
2975      map *tmpe = createMap ("code", "MissingParameterValue");
2976      if (strcmp (dfv, "") != 0)
2977        {
2978          snprintf (tmps, 1024,
2979                    _
2980                    ("The <%s> argument was not specified in DataInputs but defined as requested in ZOO ServicesProvider configuration file, please correct your query or the ZOO Configuration file."),
2981                    dfv);
2982          addToMap (tmpe, "locator", dfv);
2983        }
2984      else if (strcmp (dfv1, "") != 0)
2985        {
2986          snprintf (tmps, 1024,
2987                    _
2988                    ("The <%s> argument was specified as Output identifier but not defined in the ZOO Configuration File. Please, correct your query or the ZOO Configuration File."),
2989                    dfv1);
2990          addToMap (tmpe, "locator", dfv1);
2991        }
2992      addToMap (tmpe, "text", tmps);
2993      printExceptionReportResponse (m, tmpe);
2994      freeService (&s1);
2995      free (s1);
2996      freeMap (&tmpe);
2997      free (tmpe);
2998      freeMaps (&m);
2999      free (m);
3000      free (REQUEST);
3001      free (SERVICE_URL);
3002      freeMaps (&request_input_real_format);
3003      free (request_input_real_format);
3004      freeMaps (&request_output_real_format);
3005      free (request_output_real_format);
3006      freeMaps (&tmpmaps);
3007      free (tmpmaps);
3008      return 1;
3009    }
3010  maps *tmpReqI = request_input_real_format;
3011  while (tmpReqI != NULL)
3012    {
3013      char name[1024];
3014      if (getMap (tmpReqI->content, "isFile") != NULL)
3015        {
3016          if (cgiFormFileName (tmpReqI->name, name, sizeof (name)) ==
3017              cgiFormSuccess)
3018            {
3019              int BufferLen = 1024;
3020              cgiFilePtr file;
3021              int targetFile;
3022              char storageNameOnServer[2048];
3023              char fileNameOnServer[64];
3024              char contentType[1024];
3025              char buffer[1024];
3026              char *tmpStr = NULL;
3027              int size;
3028              int got, t;
3029              map *path = getMapFromMaps (m, "main", "tmpPath");
3030              cgiFormFileSize (tmpReqI->name, &size);
3031              cgiFormFileContentType (tmpReqI->name, contentType,
3032                                      sizeof (contentType));
3033              if (cgiFormFileOpen (tmpReqI->name, &file) == cgiFormSuccess)
3034                {
3035                  t = -1;
3036                  while (1)
3037                    {
3038                      tmpStr = strstr (name + t + 1, "\\");
3039                      if (NULL == tmpStr)
3040                        tmpStr = strstr (name + t + 1, "/");
3041                      if (NULL != tmpStr)
3042                        t = (int) (tmpStr - name);
3043                      else
3044                        break;
3045                    }
3046                  strcpy (fileNameOnServer, name + t + 1);
3047
3048                  sprintf (storageNameOnServer, "%s/%s", path->value,
3049                           fileNameOnServer);
3050#ifdef DEBUG
3051                  fprintf (stderr, "Name on server %s\n",
3052                           storageNameOnServer);
3053                  fprintf (stderr, "fileNameOnServer: %s\n",
3054                           fileNameOnServer);
3055#endif
3056                  targetFile =
3057                    open (storageNameOnServer, O_RDWR | O_CREAT | O_TRUNC,
3058                          S_IRWXU | S_IRGRP | S_IROTH);
3059                  if (targetFile < 0)
3060                    {
3061#ifdef DEBUG
3062                      fprintf (stderr, "could not create the new file,%s\n",
3063                               fileNameOnServer);
3064#endif
3065                    }
3066                  else
3067                    {
3068                      while (cgiFormFileRead (file, buffer, BufferLen, &got)
3069                             == cgiFormSuccess)
3070                        {
3071                          if (got > 0)
3072                            write (targetFile, buffer, got);
3073                        }
3074                    }
3075                  addToMap (tmpReqI->content, "lref", storageNameOnServer);
3076                  cgiFormFileClose (file);
3077                  close (targetFile);
3078#ifdef DEBUG
3079                  fprintf (stderr, "File \"%s\" has been uploaded",
3080                           fileNameOnServer);
3081#endif
3082                }
3083            }
3084        }
3085      tmpReqI = tmpReqI->next;
3086    }
3087
3088  ensureDecodedBase64 (&request_input_real_format);
3089
3090#ifdef DEBUG
3091  fprintf (stderr, "REQUEST_INPUTS\n");
3092  dumpMaps (request_input_real_format);
3093  fprintf (stderr, "REQUEST_OUTPUTS\n");
3094  dumpMaps (request_output_real_format);
3095#endif
3096
3097  maps *curs = getMaps (m, "env");
3098  if (curs != NULL)
3099    {
3100      map *mapcs = curs->content;
3101      while (mapcs != NULLMAP)
3102        {
3103#ifndef WIN32
3104          setenv (mapcs->name, mapcs->value, 1);
3105#else
3106#ifdef DEBUG
3107          fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
3108                   mapcs->value);
3109#endif
3110          if (mapcs->value[strlen (mapcs->value) - 2] == '\r')
3111            {
3112#ifdef DEBUG
3113              fprintf (stderr, "[ZOO: Env var finish with \r]\n");
3114#endif
3115              mapcs->value[strlen (mapcs->value) - 1] = 0;
3116            }
3117#ifdef DEBUG
3118          if (SetEnvironmentVariable (mapcs->name, mapcs->value) == 0)
3119            {
3120              fflush (stderr);
3121              fprintf (stderr, "setting variable... %s\n", "OK");
3122            }
3123          else
3124            {
3125              fflush (stderr);
3126              fprintf (stderr, "setting variable... %s\n", "OK");
3127            }
3128#else
3129
3130
3131          SetEnvironmentVariable (mapcs->name, mapcs->value);
3132#endif
3133          char *toto =
3134            (char *)
3135            malloc ((strlen (mapcs->name) + strlen (mapcs->value) +
3136                     2) * sizeof (char));
3137          sprintf (toto, "%s=%s", mapcs->name, mapcs->value);
3138          putenv (toto);
3139#ifdef DEBUG
3140          fflush (stderr);
3141#endif
3142#endif
3143#ifdef DEBUG
3144          fprintf (stderr, "[ZOO: setenv (%s=%s)]\n", mapcs->name,
3145                   mapcs->value);
3146          fflush (stderr);
3147#endif
3148          mapcs = mapcs->next;
3149        }
3150    }
3151
3152#ifdef DEBUG
3153  dumpMap (request_inputs);
3154#endif
3155
3156  /**
3157   * Need to check if we need to fork to load a status enabled
3158   */
3159  r_inputs = NULL;
3160  map *store = getMap (request_inputs, "storeExecuteResponse");
3161  map *status = getMap (request_inputs, "status");
3162  /**
3163   * 05-007r7 WPS 1.0.0 page 57 :
3164   * 'If status="true" and storeExecuteResponse is "false" then the service
3165   * shall raise an exception.'
3166   */
3167  if (status != NULL && strcmp (status->value, "true") == 0 &&
3168      store != NULL && strcmp (store->value, "false") == 0)
3169    {
3170      errorException (m,
3171                      _
3172                      ("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."),
3173                      "InvalidParameterValue", "storeExecuteResponse");
3174      freeService (&s1);
3175      free (s1);
3176      freeMaps (&m);
3177      free (m);
3178
3179      freeMaps (&request_input_real_format);
3180      free (request_input_real_format);
3181
3182      freeMaps (&request_output_real_format);
3183      free (request_output_real_format);
3184
3185      free (REQUEST);
3186      free (SERVICE_URL);
3187      return 1;
3188    }
3189  r_inputs = getMap (request_inputs, "storeExecuteResponse");
3190  int eres = SERVICE_STARTED;
3191  int cpid = getpid ();
3192
3193  /**
3194   * Initialize the specific [lenv] section which contains runtime variables:
3195   *
3196   *  - usid : it is an unique identification number
3197   *  - sid : it is the process idenfitication number (OS)
3198   *  - status : value between 0 and 100 to express the  completude of
3199   * the operations of the running service
3200   *  - message : is a string where you can store error messages, in case
3201   * service is failing, or o provide details on the ongoing operation.
3202   *  - cwd : is the current working directory
3203   *  - soap : is a boolean value, true if the request was contained in a SOAP
3204   * Envelop
3205   *  - sessid : string storing the session identifier (only when cookie is
3206   * used)
3207   *  - cgiSid : only defined on Window platforms (for being able to identify
3208   * the created process)
3209   *
3210   */
3211  maps *_tmpMaps = (maps *) malloc (MAPS_SIZE);
3212  _tmpMaps->name = zStrdup ("lenv");
3213  char tmpBuff[100];
3214  semid lid = getShmLockId (NULL, 1);
3215  lockShm (lid);
3216  struct ztimeval tp;
3217  if (zGettimeofday (&tp, NULL) == 0)
3218    sprintf (tmpBuff, "%i", (cpid + ((int) tp.tv_sec + (int) tp.tv_usec)));
3219  else
3220    sprintf (tmpBuff, "%i", (cpid + (int) time (NULL)));
3221  unlockShm (lid);
3222  removeShmLock (NULL, 1);
3223  _tmpMaps->content = createMap ("usid", tmpBuff);
3224  _tmpMaps->next = NULL;
3225  sprintf (tmpBuff, "%i", cpid);
3226  addToMap (_tmpMaps->content, "sid", tmpBuff);
3227  addToMap (_tmpMaps->content, "status", "0");
3228  addToMap (_tmpMaps->content, "cwd", ntmp);
3229  addToMap (_tmpMaps->content, "message", _("No message provided"));
3230  map *ltmp = getMap (request_inputs, "soap");
3231  if (ltmp != NULL)
3232    addToMap (_tmpMaps->content, "soap", ltmp->value);
3233  else
3234    addToMap (_tmpMaps->content, "soap", "false");
3235  if (cgiCookie != NULL && strlen (cgiCookie) > 0)
3236    {
3237      int hasValidCookie = -1;
3238      char *tcook = zStrdup (cgiCookie);
3239      char *tmp = NULL;
3240      map *testing = getMapFromMaps (m, "main", "cookiePrefix");
3241      if (testing == NULL)
3242        {
3243          tmp = zStrdup ("ID=");
3244        }
3245      else
3246        {
3247          tmp =
3248            (char *) malloc ((strlen (testing->value) + 2) * sizeof (char));
3249          sprintf (tmp, "%s=", testing->value);
3250        }
3251      if (strstr (cgiCookie, ";") != NULL)
3252        {
3253          char *token, *saveptr;
3254          token = strtok_r (cgiCookie, ";", &saveptr);
3255          while (token != NULL)
3256            {
3257              if (strcasestr (token, tmp) != NULL)
3258                {
3259                  if (tcook != NULL)
3260                    free (tcook);
3261                  tcook = zStrdup (token);
3262                  hasValidCookie = 1;
3263                }
3264              token = strtok_r (NULL, ";", &saveptr);
3265            }
3266        }
3267      else
3268        {
3269          if (strstr (cgiCookie, "=") != NULL
3270              && strcasestr (cgiCookie, tmp) != NULL)
3271            {
3272              tcook = zStrdup (cgiCookie);
3273              hasValidCookie = 1;
3274            }
3275          if (tmp != NULL)
3276            {
3277              free (tmp);
3278            }
3279        }
3280      if (hasValidCookie > 0)
3281        {
3282          addToMap (_tmpMaps->content, "sessid", strstr (tcook, "=") + 1);
3283          char session_file_path[1024];
3284          map *tmpPath = getMapFromMaps (m, "main", "sessPath");
3285          if (tmpPath == NULL)
3286            tmpPath = getMapFromMaps (m, "main", "tmpPath");
3287          char *tmp1 = strtok (tcook, ";");
3288          if (tmp1 != NULL)
3289            sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
3290                     strstr (tmp1, "=") + 1);
3291          else
3292            sprintf (session_file_path, "%s/sess_%s.cfg", tmpPath->value,
3293                     strstr (cgiCookie, "=") + 1);
3294          free (tcook);
3295          maps *tmpSess = (maps *) malloc (MAPS_SIZE);
3296          struct stat file_status;
3297          int istat = stat (session_file_path, &file_status);
3298          if (istat == 0 && file_status.st_size > 0)
3299            {
3300              conf_read (session_file_path, tmpSess);
3301              addMapsToMaps (&m, tmpSess);
3302              freeMaps (&tmpSess);
3303              free (tmpSess);
3304            }
3305        }
3306    }
3307  addMapsToMaps (&m, _tmpMaps);
3308  freeMaps (&_tmpMaps);
3309  free (_tmpMaps);
3310
3311#ifdef DEBUG
3312  dumpMap (request_inputs);
3313#endif
3314#ifdef WIN32
3315  char *cgiSidL = NULL;
3316  if (getenv ("CGISID") != NULL)
3317    addToMap (request_inputs, "cgiSid", getenv ("CGISID"));
3318
3319  char* usidp;
3320  if ( (usidp = getenv("USID")) != NULL ) {
3321    setMapInMaps (m, "lenv", "usid", usidp);
3322  }
3323
3324  map *test1 = getMap (request_inputs, "cgiSid");
3325  if (test1 != NULL)
3326    {
3327      cgiSid = test1->value;
3328      addToMap (request_inputs, "storeExecuteResponse", "true");
3329      addToMap (request_inputs, "status", "true");
3330      setMapInMaps (m, "lenv", "sid", test1->value);
3331      status = getMap (request_inputs, "status");
3332    }
3333#endif
3334  char *fbkp, *fbkp1;
3335  FILE *f0, *f1;
3336  if (status != NULL)
3337    if (strcasecmp (status->value, "false") == 0)
3338      status = NULLMAP;
3339  if (status == NULLMAP)
3340    {
3341      loadServiceAndRun (&m, s1, request_inputs, &request_input_real_format,
3342                         &request_output_real_format, &eres);
3343    }
3344  else
3345    {
3346      int pid;
3347#ifdef DEBUG
3348      fprintf (stderr, "\nPID : %d\n", cpid);
3349#endif
3350
3351#ifndef WIN32
3352      pid = fork ();
3353#else
3354      if (cgiSid == NULL)
3355        {
3356          createProcess (m, request_inputs, s1, NULL, cpid,
3357                         request_input_real_format,
3358                         request_output_real_format);
3359          pid = cpid;
3360        }
3361      else
3362        {
3363          pid = 0;
3364          cpid = atoi (cgiSid);
3365        }
3366#endif
3367      if (pid > 0)
3368        {
3369      /**
3370       * dady :
3371       * set status to SERVICE_ACCEPTED
3372       */
3373#ifdef DEBUG
3374          fprintf (stderr, "father pid continue (origin %d) %d ...\n", cpid,
3375                   getpid ());
3376#endif
3377          eres = SERVICE_ACCEPTED;
3378        }
3379      else if (pid == 0)
3380        {
3381      /**
3382       * son : have to close the stdout, stdin and stderr to let the parent
3383       * process answer to http client.
3384       */
3385#ifndef WIN32
3386          zSleep (1);
3387#endif
3388          r_inputs = getMapFromMaps (m, "lenv", "usid");
3389          int cpid = atoi (r_inputs->value);
3390          r_inputs = getMapFromMaps (m, "main", "tmpPath");
3391          map *r_inputs1 = getMap (s1->content, "ServiceProvider");
3392          fbkp =
3393            (char *)
3394            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
3395                     1024) * sizeof (char));
3396          sprintf (fbkp, "%s/%s_%d.xml", r_inputs->value, r_inputs1->value,
3397                   cpid);
3398          char *flog =
3399            (char *)
3400            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
3401                     1024) * sizeof (char));
3402          sprintf (flog, "%s/%s_%d_error.log", r_inputs->value,
3403                   r_inputs1->value, cpid);
3404#ifdef DEBUG
3405          fprintf (stderr, "RUN IN BACKGROUND MODE \n");
3406          fprintf (stderr, "son pid continue (origin %d) %d ...\n", cpid,
3407                   getpid ());
3408          fprintf (stderr, "\nFILE TO STORE DATA %s\n", r_inputs->value);
3409#endif
3410          freopen (flog, "w+", stderr);
3411          semid lid = getShmLockId (m, 1);
3412          fflush (stderr);
3413          if (lid < 0)
3414            {
3415              fprintf (stderr, "ERROR %s %d\n", __FILE__, __LINE__);
3416              fflush (stderr);
3417              return -1;
3418            }
3419          else
3420            {
3421              if (lockShm (lid) < 0)
3422                {
3423                  fprintf (stderr, "ERROR %s %d\n", __FILE__, __LINE__);
3424                  fflush (stderr);
3425                  return -1;
3426                }
3427              fflush (stderr);
3428            }
3429          f0 = freopen (fbkp, "w+", stdout);
3430          rewind (stdout);
3431#ifndef WIN32
3432          fclose (stdin);
3433#endif
3434          free (flog);
3435      /**
3436       * set status to SERVICE_STARTED and flush stdout to ensure full
3437       * content was outputed (the file used to store the ResponseDocument).
3438       * The rewind stdout to restart writing from the bgining of the file,
3439       * this way the data will be updated at the end of the process run.
3440       */
3441          printProcessResponse (m, request_inputs, cpid, s1, r_inputs1->value,
3442                                SERVICE_STARTED, request_input_real_format,
3443                                request_output_real_format);
3444          fflush (stdout);
3445          unlockShm (lid);
3446          fflush (stderr);
3447          fbkp1 =
3448            (char *)
3449            malloc ((strlen (r_inputs->value) + strlen (r_inputs1->value) +
3450                     1024) * sizeof (char));
3451          sprintf (fbkp1, "%s/%s_final_%d.xml", r_inputs->value,
3452                   r_inputs1->value, cpid);
3453          f1 = freopen (fbkp1, "w+", stdout);
3454          loadServiceAndRun (&m, s1, request_inputs,
3455                             &request_input_real_format,
3456                             &request_output_real_format, &eres);
3457        }
3458      else
3459        {
3460      /**
3461       * error server don't accept the process need to output a valid
3462       * error response here !!!
3463       */
3464          eres = -1;
3465          errorException (m, _("Unable to run the child process properly"),
3466                          "InternalError", NULL);
3467        }
3468    }
3469
3470#ifdef DEBUG
3471  dumpMaps (request_output_real_format);
3472#endif
3473  if (eres != -1)
3474    outputResponse (s1, request_input_real_format,
3475                    request_output_real_format, request_inputs,
3476                    cpid, m, eres);
3477  fflush (stdout);
3478  /**
3479   * Ensure that if error occurs when freeing memory, no signal will return
3480   * an ExceptionReport document as the result was already returned to the
3481   * client.
3482   */
3483#ifndef USE_GDB
3484  signal (SIGSEGV, donothing);
3485  signal (SIGTERM, donothing);
3486  signal (SIGINT, donothing);
3487  signal (SIGILL, donothing);
3488  signal (SIGFPE, donothing);
3489  signal (SIGABRT, donothing);
3490#endif
3491  if (((int) getpid ()) != cpid || cgiSid != NULL)
3492    {
3493      fclose (stdout);
3494      fclose (stderr);
3495    /**
3496     * Dump back the final file fbkp1 to fbkp
3497     */
3498      fclose (f0);
3499      fclose (f1);
3500      FILE *f2 = fopen (fbkp1, "rb");
3501      semid lid = getShmLockId (m, 1);
3502      if (lid < 0)
3503        return -1;
3504      lockShm (lid);
3505      FILE *f3 = fopen (fbkp, "wb+");
3506      free (fbkp);
3507      fseek (f2, 0, SEEK_END);
3508      long flen = ftell (f2);
3509      fseek (f2, 0, SEEK_SET);
3510      char *tmps1 = (char *) malloc ((flen + 1) * sizeof (char));
3511      fread (tmps1, flen, 1, f2);
3512      fwrite (tmps1, 1, flen, f3);
3513      fclose (f2);
3514      fclose (f3);
3515      unlockShm (lid);
3516      unlink (fbkp1);
3517      free (fbkp1);
3518      free (tmps1);
3519      unhandleStatus (m);
3520    }
3521
3522  freeService (&s1);
3523  free (s1);
3524  freeMaps (&m);
3525  free (m);
3526
3527  freeMaps (&request_input_real_format);
3528  free (request_input_real_format);
3529
3530  freeMaps (&request_output_real_format);
3531  free (request_output_real_format);
3532
3533  free (REQUEST);
3534  free (SERVICE_URL);
3535#ifdef DEBUG
3536  fprintf (stderr, "Processed response \n");
3537  fflush (stdout);
3538  fflush (stderr);
3539#endif
3540
3541  if (((int) getpid ()) != cpid || cgiSid != NULL)
3542    {
3543      exit (0);
3544    }
3545
3546  return 0;
3547}
Note: See TracBrowser for help on using the repository browser.

Search

ZOO Sponsors

http://www.zoo-project.org/trac/chrome/site/img/geolabs-logo.pnghttp://www.zoo-project.org/trac/chrome/site/img/neogeo-logo.png http://www.zoo-project.org/trac/chrome/site/img/apptech-logo.png http://www.zoo-project.org/trac/chrome/site/img/3liz-logo.png http://www.zoo-project.org/trac/chrome/site/img/gateway-logo.png

Become a sponsor !

Knowledge partners

http://www.zoo-project.org/trac/chrome/site/img/ocu-logo.png http://www.zoo-project.org/trac/chrome/site/img/gucas-logo.png http://www.zoo-project.org/trac/chrome/site/img/polimi-logo.png http://www.zoo-project.org/trac/chrome/site/img/fem-logo.png http://www.zoo-project.org/trac/chrome/site/img/supsi-logo.png http://www.zoo-project.org/trac/chrome/site/img/cumtb-logo.png

Become a knowledge partner

Related links

http://zoo-project.org/img/ogclogo.png http://zoo-project.org/img/osgeologo.png