source: trunk/zoo-kernel/zoo_service_loader.c @ 283

Last change on this file since 283 was 283, checked in by djay, 11 years ago

Fix XML validation when only Default node is provided in the ZCFG file.

File size: 55.7 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 *  Copyright 2008-2011 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#define length(x) (sizeof(x) / sizeof(x[0]))
26
27extern "C" int yylex();
28extern "C" int crlex();
29
30extern "C" {
31#include <libxml/tree.h>
32#include <libxml/xmlmemory.h>
33#include <libxml/parser.h>
34#include <libxml/xpath.h>
35#include <libxml/xpathInternals.h>
36}
37
38#include "cgic.h"
39#include "ulinet.h"
40
41#include <libintl.h>
42#include <locale.h>
43#include <string.h>
44
45#include "service.h"
46
47#include "service_internal.h"
48
49#ifdef USE_PYTHON
50#include "service_internal_python.h"
51#endif
52
53#ifdef USE_JAVA
54#include "service_internal_java.h"
55#endif
56
57#ifdef USE_PHP
58#include "service_internal_php.h"
59#endif
60
61#ifdef USE_JS
62#include "service_internal_js.h"
63#endif
64
65#ifdef USE_PERL
66#include "service_internal_perl.h"
67#endif
68
69
70
71#include <dirent.h>
72#include <signal.h>
73#include <unistd.h>
74#ifndef WIN32
75#include <dlfcn.h>
76#include <libgen.h>
77#else
78#include <windows.h>
79#include <direct.h>
80#endif
81#include <fcntl.h>
82#include <time.h>
83#include <stdarg.h>
84
85#define _(String) dgettext ("zoo-kernel",String)
86
87
88void translateChar(char* str,char toReplace,char toReplaceBy){
89  int i=0,len=strlen(str);
90  for(i=0;i<len;i++){
91    if(str[i]==toReplace)
92      str[i]=toReplaceBy;
93  }
94}
95
96xmlXPathObjectPtr extractFromDoc(xmlDocPtr doc,const char* search){
97  xmlXPathContextPtr xpathCtx;
98  xmlXPathObjectPtr xpathObj;
99  xpathCtx = xmlXPathNewContext(doc);
100  xpathObj = xmlXPathEvalExpression(BAD_CAST search,xpathCtx);
101  xmlXPathFreeContext(xpathCtx);
102  return xpathObj;
103}
104
105void donothing(int sig){
106  fprintf(stderr,"Signal %d after the ZOO-Kernel returned result !\n",sig);
107  exit(0);
108}
109
110void sig_handler(int sig){
111  char tmp[100];
112  const char *ssig;
113  switch(sig){
114  case SIGSEGV:
115    ssig="SIGSEGV";
116    break;
117  case SIGTERM:
118    ssig="SIGTERM";
119    break;
120  case SIGINT:
121    ssig="SIGINT";
122    break;
123  case SIGILL:
124    ssig="SIGILL";
125    break;
126  case SIGFPE:
127    ssig="SIGFPE";
128    break;
129  case SIGABRT:
130    ssig="SIGABRT";
131    break;
132  default:
133    ssig="UNKNOWN";
134    break;
135  }
136  sprintf(tmp,_("ZOO Kernel failed to process your request receiving signal %d = %s"),sig,ssig);
137  errorException(NULL, tmp, "InternalError");
138#ifdef DEBUG
139  fprintf(stderr,"Not this time!\n");
140#endif
141  exit(0);
142}
143
144void loadServiceAndRun(maps **myMap,service* s1,map* request_inputs,maps **inputs,maps** ioutputs,int* eres){
145  char tmps1[1024];
146  char ntmp[1024];
147  maps *m=*myMap;
148  maps *request_output_real_format=*ioutputs;
149  maps *request_input_real_format=*inputs;
150  /**
151   * Extract serviceType to know what kind of service should be loaded
152   */
153  map* r_inputs=NULL;
154#ifndef WIN32
155  char* pntmp=getcwd(ntmp,1024);
156#else
157  _getcwd(ntmp,1024);
158#endif
159  r_inputs=getMap(s1->content,"serviceType");
160#ifdef DEBUG
161  fprintf(stderr,"LOAD A %s SERVICE PROVIDER \n",r_inputs->value);
162  fflush(stderr);
163#endif
164  if(strncasecmp(r_inputs->value,"C",1)==0){
165    r_inputs=getMap(request_inputs,"metapath");
166    if(r_inputs!=NULL)
167      sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
168    else
169      sprintf(tmps1,"%s/",ntmp);
170    char *altPath=strdup(tmps1);
171    r_inputs=getMap(s1->content,"ServiceProvider");
172    sprintf(tmps1,"%s/%s",altPath,r_inputs->value);
173    free(altPath);
174#ifdef DEBUG
175    fprintf(stderr,"Trying to load %s\n",tmps1);
176#endif
177#ifdef WIN32
178    HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
179#else
180    void* so = dlopen(tmps1, RTLD_LAZY);
181#endif
182#ifdef DEBUG
183#ifdef WIN32
184    DWORD errstr;
185    errstr = GetLastError();
186    fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
187#else
188    char *errstr;
189    errstr = dlerror();
190#endif
191#endif
192
193    if( so != NULL ) {
194#ifdef DEBUG
195      fprintf(stderr,"Library loaded %s \n",errstr);
196      fprintf(stderr,"Service Shared Object = %s\n",r_inputs->value);
197#endif
198      r_inputs=getMap(s1->content,"serviceType");
199#ifdef DEBUG
200      dumpMap(r_inputs);
201      fprintf(stderr,"%s\n",r_inputs->value);
202      fflush(stderr);
203#endif
204      if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
205        r_inputs=getMap(request_inputs,"Identifier");
206        char fname[1024];
207        sprintf(fname,"%s_",r_inputs->value);
208#ifdef DEBUG
209        fprintf(stderr,"Try to load function %s\n",fname);
210#endif
211#ifdef WIN32
212        typedef int (CALLBACK* execute_t)(char***,char***,char***);
213        execute_t execute=(execute_t)GetProcAddress(so,fname);
214#else
215        typedef int (*execute_t)(char***,char***,char***);
216        execute_t execute=(execute_t)dlsym(so,fname);
217#endif
218#ifdef DEBUG
219#ifdef WIN32
220        errstr = GetLastError();
221#else
222        errstr = dlerror();
223#endif
224        fprintf(stderr,"Function loaded %s\n",errstr);
225#endif 
226
227        char main_conf[10][30][1024];
228        char inputs[10][30][1024];
229        char outputs[10][30][1024];
230        for(int i=0;i<10;i++){
231          for(int j=0;j<30;j++){
232            memset(main_conf[i][j],0,1024);
233            memset(inputs[i][j],0,1024);
234            memset(outputs[i][j],0,1024);
235          }
236        }
237        mapsToCharXXX(m,(char***)main_conf);
238        mapsToCharXXX(request_input_real_format,(char***)inputs);
239        mapsToCharXXX(request_output_real_format,(char***)outputs);
240        *eres=execute((char***)&main_conf[0],(char***)&inputs[0],(char***)&outputs[0]);
241#ifdef DEBUG
242        fprintf(stderr,"Function run successfully \n");
243#endif
244        charxxxToMaps((char***)&outputs[0],&request_output_real_format);
245      }else{
246#ifdef DEBUG
247#ifdef WIN32
248        errstr = GetLastError();
249        fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
250#endif
251#endif
252        r_inputs=getMap(request_inputs,"Identifier");
253#ifdef DEBUG
254        fprintf(stderr,"Try to load function %s\n",r_inputs->value);
255#endif
256        typedef int (*execute_t)(maps**,maps**,maps**);
257#ifdef WIN32
258        execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value); 
259#else
260        execute_t execute=(execute_t)dlsym(so,r_inputs->value);
261#endif
262
263#ifdef DEBUG
264#ifdef WIN32
265        errstr = GetLastError();
266#else
267        errstr = dlerror();
268#endif
269        fprintf(stderr,"Function loaded %s\n",errstr);
270#endif 
271
272#ifdef DEBUG
273        fprintf(stderr,"Now run the function \n");
274        fflush(stderr);
275#endif
276        *eres=execute(&m,&request_input_real_format,&request_output_real_format);
277#ifdef DEBUG
278        fprintf(stderr,"Function loaded and returned %d\n",eres);
279        fflush(stderr);
280#endif
281      }
282#ifdef WIN32
283      *ioutputs=dupMaps(&request_output_real_format);
284      FreeLibrary(so);
285#else
286      dlclose(so);
287#endif
288    } else {
289      /**
290       * Unable to load the specified shared library
291       */
292      char tmps[1024];
293#ifdef WIN32
294      DWORD errstr = GetLastError();
295#else
296      char* errstr = dlerror();
297#endif
298      sprintf(tmps,_("C Library can't be loaded %s \n"),errstr);
299      map* tmps1=createMap("text",tmps);
300      printExceptionReportResponse(m,tmps1);
301      *eres=-1;
302    }
303  }
304  else
305#ifdef USE_PYTHON
306    if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
307      *eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
308    }
309    else
310#endif
311       
312#ifdef USE_JAVA
313      if(strncasecmp(r_inputs->value,"JAVA",4)==0){
314        *eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
315      }
316      else
317#endif
318
319#ifdef USE_PHP
320        if(strncasecmp(r_inputs->value,"PHP",3)==0){
321          *eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
322        }
323        else
324#endif
325           
326           
327#ifdef USE_PERL
328          if(strncasecmp(r_inputs->value,"PERL",4)==0){
329            *eres=zoo_perl_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
330          }
331          else
332#endif
333
334#ifdef USE_JS
335            if(strncasecmp(r_inputs->value,"JS",2)==0){
336              *eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
337            }
338            else
339#endif
340              {
341                char tmpv[1024];
342                sprintf(tmpv,_("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),r_inputs->value);
343                map* tmps=createMap("text",tmpv);
344                printExceptionReportResponse(m,tmps);
345                *eres=-1;
346              }
347  *myMap=m;
348#ifndef WIN32
349  *ioutputs=request_output_real_format;
350#endif
351}
352
353#ifdef WIN32
354/**
355 * createProcess function: create a new process after setting some env variables
356 */
357void createProcess(maps* m,map* request_inputs,service* s1,char* opts,int cpid, maps* inputs,maps* outputs){
358  STARTUPINFO si;
359  PROCESS_INFORMATION pi;
360  ZeroMemory( &si, sizeof(si) );
361  si.cb = sizeof(si);
362  ZeroMemory( &pi, sizeof(pi) );
363  char *tmp=(char *)malloc((1024+cgiContentLength)*sizeof(char));
364  char *tmpq=(char *)malloc((1024+cgiContentLength)*sizeof(char));
365  map *req=getMap(request_inputs,"request");
366  map *id=getMap(request_inputs,"identifier");
367  map *di=getMap(request_inputs,"DataInputs");
368
369  char *dataInputsKVP=getMapsAsKVP(inputs,cgiContentLength,0);
370  char *dataOutputsKVP=getMapsAsKVP(outputs,cgiContentLength,1);
371  fprintf(stderr,"DATAINPUTSKVP %s\n",dataInputsKVP);
372  fprintf(stderr,"DATAOUTPUTSKVP %s\n",dataOutputsKVP);
373  map *sid=getMapFromMaps(m,"lenv","sid");
374  map* r_inputs=getMapFromMaps(m,"main","tmpPath");
375  map* r_inputs1=getMap(s1->content,"ServiceProvider");
376  map* r_inputs2=getMap(s1->content,"ResponseDocument");
377  if(r_inputs2==NULL)
378    r_inputs2=getMap(s1->content,"RawDataOutput");
379  map *tmpPath=getMapFromMaps(m,"lenv","cwd");
380
381  if(r_inputs2!=NULL){
382    sprintf(tmp,"\"request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",req->value,id->value,dataInputsKVP,r_inputs2->name,r_inputs2->value,sid->value);
383        sprintf(tmpq,"request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",req->value,id->value,dataInputsKVP,r_inputs2->name,dataOutputsKVP);
384  }
385  else{
386    sprintf(tmp,"\"request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",req->value,id->value,dataInputsKVP,sid->value);
387    sprintf(tmpq,"request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",req->value,id->value,dataInputsKVP,sid->value);
388  }
389
390  char *tmp1=strdup(tmp);
391  sprintf(tmp,"zoo_loader.cgi %s \"%s\"",tmp1,sid->value);
392
393  free(dataInputsKVP);
394  free(dataOutputsKVP);
395  fprintf(stderr,"REQUEST IS : %s \n",tmp);
396  SetEnvironmentVariable("CGISID",TEXT(sid->value));
397  SetEnvironmentVariable("QUERY_STRING",TEXT(tmpq));
398  char clen[1000];
399  sprintf(clen,"%d",strlen(tmpq));
400  SetEnvironmentVariable("CONTENT_LENGTH",TEXT(clen));
401
402  if( !CreateProcess( NULL,             // No module name (use command line)
403                      TEXT(tmp),        // Command line
404                      NULL,             // Process handle not inheritable
405                      NULL,             // Thread handle not inheritable
406                      FALSE,            // Set handle inheritance to FALSE
407                      CREATE_NO_WINDOW, // Apache won't wait until the end
408                      NULL,             // Use parent's environment block
409                      NULL,             // Use parent's starting directory
410                      &si,              // Pointer to STARTUPINFO struct
411                      &pi )             // Pointer to PROCESS_INFORMATION struct
412      ) 
413    { 
414      fprintf( stderr, "CreateProcess failed (%d).\n", GetLastError() );
415      return ;
416    }else{
417    fprintf( stderr, "CreateProcess successfull (%d).\n\n\n\n", GetLastError() );
418  }
419  CloseHandle( pi.hProcess );
420  CloseHandle( pi.hThread );
421  fprintf(stderr,"CreateProcess finished !\n");
422}
423#endif
424
425int runRequest(map* request_inputs)
426{
427
428#ifndef USE_GDB
429  (void) signal(SIGSEGV,sig_handler);
430  (void) signal(SIGTERM,sig_handler);
431  (void) signal(SIGINT,sig_handler);
432  (void) signal(SIGILL,sig_handler);
433  (void) signal(SIGFPE,sig_handler);
434  (void) signal(SIGABRT,sig_handler);
435#endif
436
437  map* r_inputs=NULL;
438  maps* m=NULL;
439
440  char* REQUEST=NULL;
441  /**
442   * Parsing service specfic configuration file
443   */
444  m=(maps*)calloc(1,MAPS_SIZE);
445  if(m == NULL){
446    return errorException(m, _("Unable to allocate memory."), "InternalError");
447  }
448  char ntmp[1024];
449#ifndef WIN32
450  char *pntmp=getcwd(ntmp,1024);
451#else
452  _getcwd(ntmp,1024);
453#endif
454  r_inputs=getMapOrFill(request_inputs,"metapath","");
455
456  char conf_file[10240];
457  snprintf(conf_file,10240,"%s/%s/main.cfg",ntmp,r_inputs->value);
458  conf_read(conf_file,m);
459#ifdef DEBUG
460  fprintf(stderr, "***** BEGIN MAPS\n"); 
461  dumpMaps(m);
462  fprintf(stderr, "***** END MAPS\n");
463#endif
464
465  bindtextdomain ("zoo-kernel","/usr/share/locale/");
466  bindtextdomain ("zoo-services","/usr/share/locale/");
467 
468  if((r_inputs=getMap(request_inputs,"language"))!=NULL){
469    char *tmp=strdup(r_inputs->value);
470    translateChar(tmp,'-','_');
471    setlocale (LC_ALL, tmp);
472    free(tmp);
473    setMapInMaps(m,"main","language",r_inputs->value);
474  }
475  else{
476    setlocale (LC_ALL, "en_US");
477    setMapInMaps(m,"main","language","en-US");
478  }
479  setlocale (LC_NUMERIC, "en_US");
480  bind_textdomain_codeset("zoo-kernel","UTF-8");
481  textdomain("zoo-kernel");
482  bind_textdomain_codeset("zoo-services","UTF-8");
483  textdomain("zoo-services");
484
485  map* lsoap=getMap(request_inputs,"soap");
486  if(lsoap!=NULL && strcasecmp(lsoap->value,"true")==0)
487    setMapInMaps(m,"main","isSoap","true");
488  else
489    setMapInMaps(m,"main","isSoap","false");
490
491  /**
492   * Check for minimum inputs
493   */
494  r_inputs=getMap(request_inputs,"Request");
495  if(request_inputs==NULL || r_inputs==NULL){ 
496    errorException(m, _("Parameter <request> was not specified"),"MissingParameterValue");
497    freeMaps(&m);
498    free(m);
499    freeMap(&request_inputs);
500    free(request_inputs);
501    free(REQUEST);
502    return 1;
503  }
504  else{
505    REQUEST=strdup(r_inputs->value);
506    if(strncasecmp(r_inputs->value,"GetCapabilities",15)!=0
507       && strncasecmp(r_inputs->value,"DescribeProcess",15)!=0
508       && strncasecmp(r_inputs->value,"Execute",7)!=0){ 
509      errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
510      freeMaps(&m);
511      free(m);
512      free(REQUEST);
513      return 1;
514    }
515  }
516  r_inputs=NULL;
517  r_inputs=getMap(request_inputs,"Service");
518  if(r_inputs==NULLMAP){
519    errorException(m, _("Parameter <service> was not specified"),"MissingParameterValue");
520    freeMaps(&m);
521    free(m);
522    free(REQUEST);
523    return 1;
524  }
525  if(strncasecmp(REQUEST,"GetCapabilities",15)!=0){
526    r_inputs=getMap(request_inputs,"Version");
527    if(r_inputs==NULL){ 
528      errorException(m, _("Parameter <version> was not specified"),"MissingParameterValue");
529      freeMaps(&m);
530      free(m);
531      free(REQUEST);
532      return 1;
533    }
534  }
535
536  r_inputs=getMap(request_inputs,"serviceprovider");
537  if(r_inputs==NULL){
538    addToMap(request_inputs,"serviceprovider","");
539  }
540
541  maps* request_output_real_format=NULL;
542  map* tmpm=getMapFromMaps(m,"main","serverAddress");
543  if(tmpm!=NULL)
544    SERVICE_URL=strdup(tmpm->value);
545  else
546    SERVICE_URL=strdup(DEFAULT_SERVICE_URL);
547
548  service* s1;
549  int scount=0;
550
551#ifdef DEBUG
552  dumpMap(r_inputs);
553#endif
554  char conf_dir[1024];
555  int t;
556  char tmps1[1024];
557
558  r_inputs=NULL;
559  r_inputs=getMap(request_inputs,"metapath");
560  if(r_inputs!=NULL)
561    snprintf(conf_dir,1024,"%s/%s",ntmp,r_inputs->value);
562  else
563    snprintf(conf_dir,1024,"%s",ntmp);
564
565  if(strncasecmp(REQUEST,"GetCapabilities",15)==0){
566    struct dirent *dp;
567#ifdef DEBUG
568    dumpMap(r_inputs);
569#endif
570    DIR *dirp = opendir(conf_dir);
571    if(dirp==NULL){
572      return errorException(m, _("The specified path doesn't exist."),"InvalidParameterValue");
573    }
574    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
575    r_inputs=NULL;
576    r_inputs=getMap(request_inputs,"ServiceProvider");
577    xmlNodePtr n;
578    if(r_inputs!=NULL)
579      n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
580    else
581      n = printGetCapabilitiesHeader(doc,"",m);
582    /**
583     * Here we need to close stdout to ensure that not supported chars
584     * has been found in the zcfg and then printed on stdout
585     */
586    int saved_stdout = dup(fileno(stdout));
587    dup2(fileno(stderr),fileno(stdout));
588    while ((dp = readdir(dirp)) != NULL)
589      if(strstr(dp->d_name,".zcfg")!=0){
590        memset(tmps1,0,1024);
591        snprintf(tmps1,1024,"%s/%s",conf_dir,dp->d_name);
592        s1=(service*)calloc(1,SERVICE_SIZE);
593        if(s1 == NULL){ 
594          return errorException(m, _("Unable to allocate memory."),"InternalError");
595        }
596#ifdef DEBUG
597        fprintf(stderr,"#################\n%s\n#################\n",tmps1);
598#endif
599        t=getServiceFromFile(tmps1,&s1);
600#ifdef DEBUG
601        dumpService(s1);
602        fflush(stdout);
603        fflush(stderr);
604#endif
605        printGetCapabilitiesForProcess(m,n,s1);
606        freeService(&s1);
607        free(s1);
608        scount++;
609      }
610    (void)closedir(dirp);
611    fflush(stdout);
612    dup2(saved_stdout,fileno(stdout));
613    printDocument(m,doc,getpid());
614    freeMaps(&m);
615    free(m);
616    free(REQUEST);
617    free(SERVICE_URL);
618    fflush(stdout);
619    return 0;
620  }
621  else{
622    r_inputs=getMap(request_inputs,"Identifier");
623    if(r_inputs==NULL 
624       || strlen(r_inputs->name)==0 || strlen(r_inputs->value)==0){ 
625      errorException(m, _("Mandatory <identifier> was not specified"),"MissingParameterValue");
626      freeMaps(&m);
627      free(m);
628      free(REQUEST);
629      free(SERVICE_URL);
630      return 0;
631    }
632
633    struct dirent *dp;
634    DIR *dirp = opendir(conf_dir);
635    if(dirp==NULL){
636      errorException(m, _("The specified path path doesn't exist."),"InvalidParameterValue");
637      freeMaps(&m);
638      free(m);
639      free(REQUEST);
640      free(SERVICE_URL);
641      return 0;
642    }
643    if(strncasecmp(REQUEST,"DescribeProcess",15)==0){
644      /**
645       * Loop over Identifier list
646       */
647      xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
648      r_inputs=NULL;
649      r_inputs=getMap(request_inputs,"ServiceProvider");
650
651      xmlNodePtr n;
652      if(r_inputs!=NULL)
653        n = printDescribeProcessHeader(doc,r_inputs->value,m);
654      else
655        n = printDescribeProcessHeader(doc,"",m);
656
657      r_inputs=getMap(request_inputs,"Identifier");
658      char *tmps=strtok(r_inputs->value,",");
659     
660      char buff[256];
661      char buff1[1024];
662      int saved_stdout = dup(fileno(stdout));
663      dup2(fileno(stderr),fileno(stdout));
664      while(tmps){
665        memset(buff,0,256);
666        snprintf(buff,256,"%s.zcfg",tmps);
667        memset(buff1,0,1024);
668#ifdef DEBUG
669        fprintf(stderr,"\n#######%s\n########\n",buff1);
670#endif
671        while ((dp = readdir(dirp)) != NULL)
672          if((strcasecmp("all.zcfg",buff)==0 && strstr(dp->d_name,".zcfg")>0)
673             || strcasecmp(dp->d_name,buff)==0){
674            memset(buff1,0,1024);
675            snprintf(buff1,1024,"%s/%s",conf_dir,dp->d_name);
676            s1=(service*)calloc(1,SERVICE_SIZE);
677            if(s1 == NULL){
678              return errorException(m, _("Unable to allocate memory."),"InternalError");
679            }
680#ifdef DEBUG
681            fprintf(stderr,"#################\n%s\n#################\n",buff1);
682#endif
683            t=getServiceFromFile(buff1,&s1);
684#ifdef DEBUG
685            dumpService(s1);
686#endif
687            printDescribeProcessForProcess(m,n,s1,1);
688            freeService(&s1);
689            free(s1);
690            scount++;
691          }
692        rewinddir(dirp);
693        tmps=strtok(NULL,",");
694      }
695      closedir(dirp);
696      fflush(stdout);
697      dup2(saved_stdout,fileno(stdout));
698      printDocument(m,doc,getpid());
699      freeMaps(&m);
700      free(m);
701      free(REQUEST);
702      free(SERVICE_URL);
703      fflush(stdout);
704#ifndef LINUX_FREE_ISSUE
705      if(s1)
706        free(s1);
707#endif
708      return 0;
709    }
710    else
711      if(strncasecmp(REQUEST,"Execute",strlen(REQUEST))!=0){
712        errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
713#ifdef DEBUG
714        fprintf(stderr,"No request found %s",REQUEST);
715#endif 
716        closedir(dirp);
717        return 0;
718      }
719    closedir(dirp);
720  }
721 
722  s1=NULL;
723  s1=(service*)calloc(1,SERVICE_SIZE);
724  if(s1 == NULL){
725    freeMaps(&m);
726    free(m);
727    free(REQUEST);
728    free(SERVICE_URL);
729    return errorException(m, _("Unable to allocate memory."),"InternalError");
730  }
731  r_inputs=getMap(request_inputs,"MetaPath");
732  if(r_inputs!=NULL)
733    snprintf(tmps1,1024,"%s/%s",ntmp,r_inputs->value);
734  else
735    snprintf(tmps1,1024,"%s/",ntmp);
736  r_inputs=getMap(request_inputs,"Identifier");
737  char *ttmp=strdup(tmps1);
738  snprintf(tmps1,1024,"%s/%s.zcfg",ttmp,r_inputs->value);
739  free(ttmp);
740#ifdef DEBUG
741  fprintf(stderr,"Trying to load %s\n", tmps1);
742#endif
743  int saved_stdout = dup(fileno(stdout));
744    dup2(fileno(stderr),fileno(stdout));
745  t=getServiceFromFile(tmps1,&s1);
746  fflush(stdout);
747  dup2(saved_stdout,fileno(stdout));
748  if(t<0){
749    char *tmpMsg=(char*)malloc(2048+strlen(r_inputs->value));
750   
751    sprintf(tmpMsg,_("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),r_inputs->value);
752    errorException(m, tmpMsg, "InvalidParameterValue");
753    free(tmpMsg);
754    freeService(&s1);
755    free(s1);
756    freeMaps(&m);
757    free(m);
758    free(REQUEST);
759    free(SERVICE_URL);
760    return 0;
761  }
762  close(saved_stdout);
763
764#ifdef DEBUG
765  dumpService(s1);
766#endif
767  int j;
768 
769  /**
770   * Create the input maps data structure
771   */
772  int i=0;
773  HINTERNET hInternet;
774  HINTERNET res;
775  hInternet=InternetOpen(
776#ifndef WIN32
777                         (LPCTSTR)
778#endif
779                         "ZooWPSClient\0",
780                         INTERNET_OPEN_TYPE_PRECONFIG,
781                         NULL,NULL, 0);
782
783#ifndef WIN32
784  if(!CHECK_INET_HANDLE(hInternet))
785    fprintf(stderr,"WARNING : hInternet handle failed to initialize");
786#endif
787  maps* request_input_real_format=NULL;
788  maps* tmpmaps = request_input_real_format;
789  map* postRequest=NULL;
790  postRequest=getMap(request_inputs,"xrequest");
791  if(postRequest==NULLMAP){
792    /**
793     * Parsing outputs provided as KVP
794     */
795    r_inputs=NULL;
796#ifdef DEBUG
797    fprintf(stderr,"OUTPUT Parsing ... \n");
798#endif
799    r_inputs=getMap(request_inputs,"ResponseDocument"); 
800    if(r_inputs==NULL) r_inputs=getMap(request_inputs,"RawDataOutput");
801   
802#ifdef DEBUG
803    fprintf(stderr,"OUTPUT Parsing ... \n");
804#endif
805    if(r_inputs!=NULL){
806#ifdef DEBUG
807      fprintf(stderr,"OUTPUT Parsing start now ... \n");
808#endif
809      char cursor_output[10240];
810      char *cotmp=strdup(r_inputs->value);
811      snprintf(cursor_output,10240,"%s",cotmp);
812      free(cotmp);
813      j=0;
814       
815      /**
816       * Put each Output into the outputs_as_text array
817       */
818      char * pToken;
819      maps* tmp_output=NULL;
820#ifdef DEBUG
821      fprintf(stderr,"OUTPUT [%s]\n",cursor_output);
822#endif
823      pToken=strtok(cursor_output,";");
824      char** outputs_as_text=(char**)calloc(128,sizeof(char*));
825      if(outputs_as_text == NULL) {
826        return errorException(m, _("Unable to allocate memory"), "InternalError");
827      }
828      i=0;
829      while(pToken!=NULL){
830#ifdef DEBUG
831        fprintf(stderr,"***%s***\n",pToken);
832        fflush(stderr);
833        fprintf(stderr,"***%s***\n",pToken);
834#endif
835        outputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
836        if(outputs_as_text[i] == NULL) {
837          return errorException(m, _("Unable to allocate memory"), "InternalError");
838        }
839        snprintf(outputs_as_text[i],strlen(pToken)+1,"%s",pToken);
840        pToken = strtok(NULL,";");
841        i++;
842      }
843      for(j=0;j<i;j++){
844        char *tmp=strdup(outputs_as_text[j]);
845        free(outputs_as_text[j]);
846        char *tmpc;
847        tmpc=strtok(tmp,"@");
848        int k=0;
849        while(tmpc!=NULL){
850          if(k==0){
851            if(tmp_output==NULL){
852              tmp_output=(maps*)calloc(1,MAPS_SIZE);
853              if(tmp_output == NULL){
854                return errorException(m, _("Unable to allocate memory."), "InternalError");
855              }
856              tmp_output->name=strdup(tmpc);
857              tmp_output->content=NULL;
858              tmp_output->next=NULL;
859            }
860          }
861          else{
862            char *tmpv=strstr(tmpc,"=");
863            char tmpn[256];
864            memset(tmpn,0,256);
865            strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
866            tmpn[strlen(tmpc)-strlen(tmpv)]=0;
867#ifdef DEBUG
868            fprintf(stderr,"OUTPUT DEF [%s]=[%s]\n",tmpn,tmpv+1);
869#endif
870            if(tmp_output->content==NULL){
871              tmp_output->content=createMap(tmpn,tmpv+1);
872              tmp_output->content->next=NULL;
873            }
874            else
875              addToMap(tmp_output->content,tmpn,tmpv+1);
876          }
877          k++;
878#ifdef DEBUG
879          fprintf(stderr,"***%s***\n",tmpc);
880#endif
881          tmpc=strtok(NULL,"@");
882        }
883        if(request_output_real_format==NULL)
884          request_output_real_format=dupMaps(&tmp_output);
885        else
886          addMapsToMaps(&request_output_real_format,tmp_output);
887        freeMaps(&tmp_output);
888        free(tmp_output);
889        tmp_output=NULL;
890#ifdef DEBUG
891        dumpMaps(tmp_output);
892        fflush(stderr);
893#endif
894        free(tmp);
895      }
896      free(outputs_as_text);
897    }
898
899
900    /**
901     * Parsing inputs provided as KVP
902     */
903    r_inputs=getMap(request_inputs,"DataInputs");
904#ifdef DEBUG
905    fprintf(stderr,"DATA INPUTS [%s]\n",r_inputs->value);
906#endif
907    char cursor_input[40960];
908    if(r_inputs!=NULL)
909      snprintf(cursor_input,40960,"%s",r_inputs->value);
910    else{
911      errorException(m, _("Parameter <DataInputs> was not specified"),"MissingParameterValue");
912      freeMaps(&m);
913      free(m);
914      free(REQUEST);
915      free(SERVICE_URL);
916      InternetCloseHandle(hInternet);
917      freeService(&s1);
918      free(s1);
919      return 0;
920    }
921    j=0;
922 
923    /**
924     * Put each DataInputs into the inputs_as_text array
925     */
926    char * pToken;
927    pToken=strtok(cursor_input,";");
928    char** inputs_as_text=(char**)calloc(100,sizeof(char*));
929    if(inputs_as_text == NULL){
930      return errorException(m, _("Unable to allocate memory."), "InternalError");
931    }
932    i=0;
933    while(pToken!=NULL){
934#ifdef DEBUG
935      fprintf(stderr,"***%s***\n",pToken);
936#endif
937      fflush(stderr);
938#ifdef DEBUG
939      fprintf(stderr,"***%s***\n",pToken);
940#endif
941      inputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
942      snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
943      if(inputs_as_text[i] == NULL){
944        return errorException(m, _("Unable to allocate memory."), "InternalError");
945      }
946      pToken = strtok(NULL,";");
947      i++;
948    }
949
950    for(j=0;j<i;j++){
951      char *tmp=strdup(inputs_as_text[j]);
952      free(inputs_as_text[j]);
953      char *tmpc;
954      tmpc=strtok(tmp,"@");
955      while(tmpc!=NULL){
956#ifdef DEBUG
957        fprintf(stderr,"***\n***%s***\n",tmpc);
958#endif
959        char *tmpv=strstr(tmpc,"=");
960        char tmpn[256];
961        memset(tmpn,0,256);
962        if(tmpv!=NULL){
963          strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
964          tmpn[strlen(tmpc)-strlen(tmpv)]=0;
965        }
966        else{
967          strncpy(tmpn,tmpc,strlen(tmpc)*sizeof(char));
968          tmpn[strlen(tmpc)]=0;
969        }
970#ifdef DEBUG
971        fprintf(stderr,"***\n*** %s = %s ***\n",tmpn,tmpv+1);
972#endif
973        if(tmpmaps==NULL){
974          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
975          if(tmpmaps == NULL){
976            return errorException(m, _("Unable to allocate memory."), "InternalError");
977          }
978          tmpmaps->name=strdup(tmpn);
979          if(tmpv!=NULL)
980            tmpmaps->content=createMap("value",tmpv+1);
981          else
982            tmpmaps->content=createMap("value","Reference");
983          tmpmaps->next=NULL;
984        }
985        tmpc=strtok(NULL,"@");
986        while(tmpc!=NULL){
987#ifdef DEBUG
988          fprintf(stderr,"*** KVP NON URL-ENCODED \n***%s***\n",tmpc);
989#endif
990          char *tmpv1=strstr(tmpc,"=");
991#ifdef DEBUG
992          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
993#endif
994          char tmpn1[1024];
995          memset(tmpn1,0,1024);
996          if(tmpv1!=NULL){
997            strncpy(tmpn1,tmpc,strlen(tmpc)-strlen(tmpv1));
998            tmpn1[strlen(tmpc)-strlen(tmpv1)]=0;
999            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1000          }
1001          else{
1002            strncpy(tmpn1,tmpc,strlen(tmpc));
1003            tmpn1[strlen(tmpc)]=0;
1004            map* lmap=getLastMap(tmpmaps->content);
1005            char *tmpValue=(char*)calloc((strlen(lmap->value)+strlen(tmpc)+1),sizeof(char));
1006            sprintf(tmpValue,"%s@%s",lmap->value,tmpc);
1007            free(lmap->value);
1008            lmap->value=strdup(tmpValue);
1009            free(tmpValue);
1010            tmpc=strtok(NULL,"@");
1011            continue;
1012          }
1013#ifdef DEBUG
1014          fprintf(stderr,"*** NAME NON URL-ENCODED \n***%s***\n",tmpn1);
1015          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
1016#endif
1017          if(strcmp(tmpn1,"xlink:href")!=0)
1018            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1019          else
1020            if(tmpv1!=NULL){
1021              if(strncasecmp(tmpv1+1,"http://",7)!=0 &&
1022                 strncasecmp(tmpv1+1,"ftp://",6)!=0){
1023                char emsg[1024];
1024                sprintf(emsg,_("Unable to find a valid protocol to download the remote file %s"),tmpv1+1);
1025                errorException(m,emsg,"InternalError");
1026                freeMaps(&m);
1027                free(m);
1028                free(REQUEST);
1029                free(SERVICE_URL);
1030                InternetCloseHandle(hInternet);
1031                freeService(&s1);
1032                free(s1);
1033                return 0;
1034              }
1035#ifdef DEBUG
1036              fprintf(stderr,"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",tmpv1+1);
1037#endif
1038              char *tmpx=url_encode(tmpv1+1);
1039              addToMap(tmpmaps->content,tmpn1,tmpx);
1040             
1041#ifndef WIN32
1042              if(CHECK_INET_HANDLE(hInternet))
1043#endif
1044                {
1045                  loadRemoteFile(m,tmpmaps->content,hInternet,tmpv1+1);
1046                }
1047              char *tmpx1=url_encode(tmpv1+1);
1048              addToMap(tmpmaps->content,tmpn1,tmpx1);
1049              free(tmpx1);
1050              addToMap(tmpmaps->content,"Reference",tmpv1+1);
1051            }
1052          tmpc=strtok(NULL,"@");
1053        }
1054#ifdef DEBUG
1055        dumpMaps(tmpmaps);
1056        fflush(stderr);
1057#endif
1058        if(request_input_real_format==NULL)
1059          request_input_real_format=dupMaps(&tmpmaps);
1060        else
1061          addMapsToMaps(&request_input_real_format,tmpmaps);
1062        freeMaps(&tmpmaps);
1063        free(tmpmaps);
1064        tmpmaps=NULL;
1065        free(tmp);
1066      }
1067    }
1068    free(inputs_as_text);
1069  }
1070  else {
1071    /**
1072     * Parse XML request
1073     */ 
1074    xmlInitParser();
1075#ifdef DEBUG
1076    fflush(stderr);
1077    fprintf(stderr,"BEFORE %s\n",postRequest->value);
1078    fflush(stderr);
1079#endif
1080    xmlDocPtr doc =
1081      xmlParseMemory(postRequest->value,cgiContentLength);
1082#ifdef DEBUG
1083    fprintf(stderr,"AFTER\n");
1084    fflush(stderr);
1085#endif
1086    /**
1087     * Parse every Input in DataInputs node.
1088     */
1089    xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='Input']");
1090    xmlNodeSet* tmps=tmpsptr->nodesetval;
1091#ifdef DEBUG
1092    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1093#endif
1094    for(int k=0;k<tmps->nodeNr;k++){
1095      maps *tmpmaps=NULL;
1096      xmlNodePtr cur=tmps->nodeTab[k];
1097      if(tmps->nodeTab[k]->type == XML_ELEMENT_NODE) {
1098        /**
1099         * A specific Input node.
1100         */
1101#ifdef DEBUG
1102        fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
1103#endif
1104        xmlNodePtr cur2=cur->children;
1105        while(cur2!=NULL){
1106          while(cur2!=NULL && cur2->type!=XML_ELEMENT_NODE)
1107            cur2=cur2->next;
1108          if(cur2==NULL)
1109            break;
1110          /**
1111           * Indentifier
1112           */
1113          if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1114            xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1115            if(tmpmaps==NULL){
1116              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1117              if(tmpmaps == NULL){
1118                return errorException(m, _("Unable to allocate memory."), "InternalError");
1119              }
1120              tmpmaps->name=strdup((char*)val);
1121              tmpmaps->content=NULL;
1122              tmpmaps->next=NULL;
1123            }
1124            xmlFree(val);
1125          }
1126          /**
1127           * Title, Asbtract
1128           */
1129          if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1130             xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1131            xmlChar *val=
1132              xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1133            if(tmpmaps==NULL){
1134              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1135              if(tmpmaps == NULL){
1136                return errorException(m, _("Unable to allocate memory."), "InternalError");
1137              }
1138              tmpmaps->name=strdup("missingIndetifier");
1139              tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1140              tmpmaps->next=NULL;
1141            }
1142            else{
1143              if(tmpmaps->content!=NULL)
1144                addToMap(tmpmaps->content,
1145                         (char*)cur2->name,(char*)val);
1146              else
1147                tmpmaps->content=
1148                  createMap((char*)cur2->name,(char*)val);
1149            }
1150#ifdef DEBUG
1151            dumpMaps(tmpmaps);
1152#endif
1153            xmlFree(val);
1154          }
1155          /**
1156           * InputDataFormChoice (Reference or Data ?)
1157           */
1158          if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
1159            /**
1160             * Get every attribute from a Reference node
1161             * mimeType, encoding, schema, href, method
1162             * Header and Body gesture should be added here
1163             */
1164#ifdef DEBUG
1165            fprintf(stderr,"REFERENCE\n");
1166#endif
1167            const char *refs[5]={"mimeType","encoding","schema","method","href"};
1168            for(int l=0;l<5;l++){
1169#ifdef DEBUG
1170              fprintf(stderr,"*** %s ***",refs[l]);
1171#endif
1172              xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
1173              if(val!=NULL && xmlStrlen(val)>0){
1174                if(tmpmaps->content!=NULL)
1175                  addToMap(tmpmaps->content,refs[l],(char*)val);
1176                else
1177                  tmpmaps->content=createMap(refs[l],(char*)val);
1178                map* ltmp=getMap(tmpmaps->content,"method");
1179                if(l==4){
1180                  if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
1181                     && CHECK_INET_HANDLE(hInternet)){
1182                    loadRemoteFile(m,tmpmaps->content,hInternet,(char*)val);
1183                  }
1184                }
1185              }
1186#ifdef DEBUG
1187              fprintf(stderr,"%s\n",val);
1188#endif
1189              xmlFree(val);
1190            }
1191#ifdef POST_DEBUG
1192            fprintf(stderr,"Parse Header and Body from Reference \n");
1193#endif
1194            xmlNodePtr cur3=cur2->children;
1195            hInternet.header=NULL;
1196            while(cur3){
1197              while(cur3!=NULL && cur3->type!=XML_ELEMENT_NODE)
1198                cur2=cur3->next;
1199              if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
1200                const char *ha[2];
1201                ha[0]="key";
1202                ha[1]="value";
1203                int hai;
1204                char *has;
1205                char *key;
1206                for(hai=0;hai<2;hai++){
1207                  xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
1208#ifdef POST_DEBUG
1209                  fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
1210#endif
1211                  if(hai==0){
1212                    key=(char*)calloc((1+strlen((char*)val)),sizeof(char));
1213                    snprintf(key,1+strlen((char*)val),"%s",(char*)val);
1214                  }else{
1215                    has=(char*)calloc((3+strlen((char*)val)+strlen(key)),sizeof(char));
1216                    if(has == NULL){
1217                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1218                    }
1219                    snprintf(has,(3+strlen((char*)val)+strlen(key)),"%s: %s",key,(char*)val);
1220#ifdef POST_DEBUG
1221                    fprintf(stderr,"%s\n",has);
1222#endif
1223                  }
1224                }
1225                hInternet.header=curl_slist_append(hInternet.header, has);
1226                free(has);
1227              }
1228              else{
1229#ifdef POST_DEBUG
1230                fprintf(stderr,"Try to fetch the body part of the request ...\n");
1231#endif
1232                if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
1233#ifdef POST_DEBUG
1234                  fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
1235#endif
1236                  char *tmp=new char[cgiContentLength];
1237                  memset(tmp,0,cgiContentLength);
1238                  xmlNodePtr cur4=cur3->children;
1239                  while(cur4!=NULL){
1240                    while(cur4->type!=XML_ELEMENT_NODE)
1241                      cur4=cur4->next;
1242                    xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
1243                    bdoc->encoding = xmlCharStrdup ("UTF-8");
1244                    xmlDocSetRootElement(bdoc,cur4);
1245                    xmlChar* btmps;
1246                    int bsize;
1247                    xmlDocDumpMemory(bdoc,&btmps,&bsize);
1248#ifdef POST_DEBUG
1249                    fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
1250#endif
1251                    if(btmps!=NULL)
1252                      sprintf(tmp,"%s",(char*)btmps);
1253                    xmlFreeDoc(bdoc);
1254                    cur4=cur4->next;
1255                  }
1256                  map *btmp=getMap(tmpmaps->content,"href");
1257                  if(btmp!=NULL){
1258#ifdef POST_DEBUG
1259                    fprintf(stderr,"%s %s\n",btmp->value,tmp);
1260                    curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1261#endif
1262                    res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
1263                                        INTERNET_FLAG_NO_CACHE_WRITE,0);
1264                    char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
1265                    if(tmpContent == NULL){
1266                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1267                    }
1268                    size_t dwRead;
1269                    InternetReadFile(res, (LPVOID)tmpContent,
1270                                     res.nDataLen, &dwRead);
1271                    tmpContent[res.nDataLen]=0;
1272                    if(hInternet.header!=NULL)
1273                      curl_slist_free_all(hInternet.header);
1274                    addToMap(tmpmaps->content,"value",tmpContent);
1275#ifdef POST_DEBUG
1276                    fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1277#endif
1278                  }
1279                }
1280                else
1281                  if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
1282                    xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
1283                    HINTERNET bInternet,res1;
1284                    bInternet=InternetOpen(
1285#ifndef WIN32
1286                                           (LPCTSTR)
1287#endif
1288                                           "ZooWPSClient\0",
1289                                           INTERNET_OPEN_TYPE_PRECONFIG,
1290                                           NULL,NULL, 0);
1291                    if(!CHECK_INET_HANDLE(bInternet))
1292                      fprintf(stderr,"WARNING : hInternet handle failed to initialize");
1293#ifdef POST_DEBUG
1294                    curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
1295#endif
1296                    res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
1297                                         INTERNET_FLAG_NO_CACHE_WRITE,0);
1298                    char* tmp=
1299                      (char*)calloc((res1.nDataLen+1),sizeof(char));
1300                    if(tmp == NULL){
1301                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1302                    }
1303                    size_t bRead;
1304                    InternetReadFile(res1, (LPVOID)tmp,
1305                                     res1.nDataLen, &bRead);
1306                    tmp[res1.nDataLen]=0;
1307                    InternetCloseHandle(bInternet);
1308                    map *btmp=getMap(tmpmaps->content,"href");
1309                    if(btmp!=NULL){
1310#ifdef POST_DEBUG
1311                      fprintf(stderr,"%s %s\n",btmp->value,tmp);
1312                      curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1313#endif
1314                      res=InternetOpenUrl(hInternet,btmp->value,tmp,
1315                                          strlen(tmp),
1316                                          INTERNET_FLAG_NO_CACHE_WRITE,0);
1317                      char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
1318                      if(tmpContent == NULL){
1319                        return errorException(m, _("Unable to allocate memory."), "InternalError");
1320                      }
1321                      size_t dwRead;
1322                      InternetReadFile(res, (LPVOID)tmpContent,
1323                                       res.nDataLen, &dwRead);
1324                      tmpContent[res.nDataLen]=0;
1325                      if(hInternet.header!=NULL)
1326                        curl_slist_free_all(hInternet.header);
1327                      addToMap(tmpmaps->content,"value",tmpContent);
1328#ifdef POST_DEBUG
1329                      fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1330#endif
1331                    }
1332                  }
1333              }
1334              cur3=cur3->next;
1335            }
1336#ifdef POST_DEBUG
1337            fprintf(stderr,"Header and Body was parsed from Reference \n");
1338#endif
1339#ifdef DEBUG
1340            dumpMap(tmpmaps->content);
1341            fprintf(stderr, "= element 2 node \"%s\" = (%s)\n", 
1342                    cur2->name,cur2->content);
1343#endif
1344          }
1345          else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
1346#ifdef DEBUG
1347            fprintf(stderr,"DATA\n");
1348#endif
1349            xmlNodePtr cur4=cur2->children;
1350            while(cur4!=NULL){
1351              while(cur4!=NULL &&cur4->type!=XML_ELEMENT_NODE)
1352                cur4=cur4->next;
1353              if(cur4==NULL)
1354                break;
1355              if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
1356                /**
1357                 * Get every attribute from a LiteralData node
1358                 * dataType , uom
1359                 */
1360                char *list[2];
1361                list[0]=strdup("dataType");
1362                list[1]=strdup("uom");
1363                for(int l=0;l<2;l++){
1364#ifdef DEBUG
1365                  fprintf(stderr,"*** LiteralData %s ***",list[l]);
1366#endif
1367                  xmlChar *val=xmlGetProp(cur4,BAD_CAST list[l]);
1368                  if(val!=NULL && strlen((char*)val)>0){
1369                    if(tmpmaps->content!=NULL)
1370                      addToMap(tmpmaps->content,list[l],(char*)val);
1371                    else
1372                      tmpmaps->content=createMap(list[l],(char*)val);
1373#ifdef DEBUG
1374                    fprintf(stderr,"%s\n",val);
1375#endif
1376                  }
1377                  xmlFree(val);
1378                  free(list[l]);                 
1379                }
1380              }
1381              else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
1382                /**
1383                 * Get every attribute from a Reference node
1384                 * mimeType, encoding, schema
1385                 */
1386                const char *coms[3]={"mimeType","encoding","schema"};
1387                for(int l=0;l<3;l++){
1388#ifdef DEBUG
1389                  fprintf(stderr,"*** ComplexData %s ***\n",coms[l]);
1390#endif
1391                  xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
1392                  if(val!=NULL && strlen((char*)val)>0){
1393                    if(tmpmaps->content!=NULL)
1394                      addToMap(tmpmaps->content,coms[l],(char*)val);
1395                    else
1396                      tmpmaps->content=createMap(coms[l],(char*)val);
1397#ifdef DEBUG
1398                    fprintf(stderr,"%s\n",val);
1399#endif
1400                  }
1401                  xmlFree(val);
1402                }
1403              }
1404
1405              map* test=getMap(tmpmaps->content,"encoding");
1406              if(test==NULL){
1407                if(tmpmaps->content!=NULL)
1408                  addToMap(tmpmaps->content,"encoding","utf-8");
1409                else
1410                  tmpmaps->content=createMap("encoding","utf-8");
1411                test=getMap(tmpmaps->content,"encoding");
1412              }
1413
1414              if(strcasecmp(test->value,"base64")!=0){
1415                xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
1416                map* ltmp=getMap(tmpmaps->content,"mimeType");
1417                dumpMap(ltmp);
1418                if(mv==NULL || 
1419                   (xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0 &&
1420                    (ltmp==NULL || strncasecmp(ltmp->value,"text/xml",8)==0) )){
1421                  xmlDocPtr doc1=xmlNewDoc(BAD_CAST "1.0");
1422                  int buffersize;
1423                  xmlNodePtr cur5=cur4->children;
1424                  while(cur5!=NULL &&cur5->type!=XML_ELEMENT_NODE)
1425                    cur5=cur5->next;
1426                  xmlDocSetRootElement(doc1,cur5);
1427                  xmlDocDumpFormatMemoryEnc(doc1, &mv, &buffersize, "utf-8", 1);
1428                  char size[1024];
1429                  sprintf(size,"%d",buffersize);
1430                  addToMap(tmpmaps->content,"size",size);
1431                }
1432                addToMap(tmpmaps->content,"value",(char*)mv);
1433                xmlFree(mv);
1434              }else{
1435                xmlChar* tmp=xmlNodeListGetRawString(doc,cur4->xmlChildrenNode,0);
1436                addToMap(tmpmaps->content,"value",(char*)tmp);
1437                map* tmpv=getMap(tmpmaps->content,"value");
1438                char *res=NULL;
1439                char *curs=tmpv->value;
1440                for(int i=0;i<=strlen(tmpv->value)/64;i++) {
1441                  if(res==NULL)
1442                    res=(char*)malloc(67*sizeof(char));
1443                  else
1444                    res=(char*)realloc(res,(((i+1)*65)+i)*sizeof(char));
1445                  int csize=i*65;
1446                  strncpy(res + csize,curs,64);
1447                  if(i==xmlStrlen(tmp)/64)
1448                    strcat(res,"\n\0");
1449                  else{
1450                    strncpy(res + (((i+1)*64)+i),"\n\0",2);
1451                    curs+=64;
1452                  }
1453                }
1454                free(tmpv->value);
1455                tmpv->value=strdup(res);
1456                free(res);
1457                xmlFree(tmp);
1458              }
1459              cur4=cur4->next;
1460            }
1461          }
1462#ifdef DEBUG
1463          fprintf(stderr,"cur2 next \n");
1464          fflush(stderr);
1465#endif
1466          cur2=cur2->next;
1467        }
1468#ifdef DEBUG
1469        fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
1470        fflush(stderr);
1471#endif
1472        addMapsToMaps(&request_input_real_format,tmpmaps);
1473       
1474#ifdef DEBUG
1475        fprintf(stderr,"******TMPMAPS*****\n");
1476        dumpMaps(tmpmaps);
1477        fprintf(stderr,"******REQUESTMAPS*****\n");
1478        dumpMaps(request_input_real_format);
1479#endif
1480        freeMaps(&tmpmaps);
1481        free(tmpmaps);
1482        tmpmaps=NULL;         
1483      }
1484#ifdef DEBUG
1485      dumpMaps(tmpmaps); 
1486#endif
1487    }
1488#ifdef DEBUG
1489    fprintf(stderr,"Search for response document node\n");
1490#endif
1491    xmlXPathFreeObject(tmpsptr);
1492   
1493    tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='ResponseDocument']");
1494    bool asRaw=false;
1495    tmps=tmpsptr->nodesetval;
1496    if(tmps->nodeNr==0){
1497      tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='RawDataOutput']");
1498      tmps=tmpsptr->nodesetval;
1499      asRaw=true;
1500    }
1501#ifdef DEBUG
1502    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1503#endif
1504    for(int k=0;k<tmps->nodeNr;k++){
1505      if(asRaw==true)
1506        addToMap(request_inputs,"RawDataOutput","");
1507      else
1508        addToMap(request_inputs,"ResponseDocument","");
1509      maps *tmpmaps=NULL;
1510      xmlNodePtr cur=tmps->nodeTab[k];
1511      if(cur->type == XML_ELEMENT_NODE) {
1512        /**
1513         * A specific responseDocument node.
1514         */
1515        if(tmpmaps==NULL){
1516          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1517          if(tmpmaps == NULL){
1518            return errorException(m, _("Unable to allocate memory."), "InternalError");
1519          }
1520          tmpmaps->name=strdup("unknownIdentifier");
1521          tmpmaps->next=NULL;
1522        }
1523        /**
1524         * Get every attribute from a LiteralData node
1525         * storeExecuteResponse, lineage, status
1526         */
1527        const char *ress[3]={"storeExecuteResponse","lineage","status"};
1528        xmlChar *val;
1529        for(int l=0;l<3;l++){
1530#ifdef DEBUG
1531          fprintf(stderr,"*** %s ***\t",ress[l]);
1532#endif
1533          val=xmlGetProp(cur,BAD_CAST ress[l]);
1534          if(val!=NULL && strlen((char*)val)>0){
1535            if(tmpmaps->content!=NULL)
1536              addToMap(tmpmaps->content,ress[l],(char*)val);
1537            else
1538              tmpmaps->content=createMap(ress[l],(char*)val);
1539            addToMap(request_inputs,ress[l],(char*)val);
1540          }
1541#ifdef DEBUG
1542          fprintf(stderr,"%s\n",val);
1543#endif
1544          xmlFree(val);
1545        }
1546        xmlNodePtr cur1=cur->children;
1547        while(cur1){
1548          /**
1549           * Indentifier
1550           */
1551          if(xmlStrncasecmp(cur1->name,BAD_CAST "Identifier",xmlStrlen(cur1->name))==0){
1552            xmlChar *val=
1553              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1554            if(tmpmaps==NULL){
1555              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1556              if(tmpmaps == NULL){
1557                return errorException(m, _("Unable to allocate memory."), "InternalError");
1558              }
1559              tmpmaps->name=strdup((char*)val);
1560              tmpmaps->content=NULL;
1561              tmpmaps->next=NULL;
1562            }
1563            else
1564              tmpmaps->name=strdup((char*)val);;
1565            xmlFree(val);
1566          }
1567          /**
1568           * Title, Asbtract
1569           */
1570          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Title",xmlStrlen(cur1->name))==0 ||
1571                  xmlStrncasecmp(cur1->name,BAD_CAST "Abstract",xmlStrlen(cur1->name))==0){
1572            xmlChar *val=
1573              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1574            if(tmpmaps==NULL){
1575              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1576              if(tmpmaps == NULL){
1577                return errorException(m, _("Unable to allocate memory."), "InternalError");
1578              }
1579              tmpmaps->name=strdup("missingIndetifier");
1580              tmpmaps->content=createMap((char*)cur1->name,(char*)val);
1581              tmpmaps->next=NULL;
1582            }
1583            else{
1584              if(tmpmaps->content!=NULL)
1585                addToMap(tmpmaps->content,
1586                         (char*)cur1->name,(char*)val);
1587              else
1588                tmpmaps->content=
1589                  createMap((char*)cur1->name,(char*)val);
1590            }
1591            xmlFree(val);
1592          }
1593          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
1594            /**
1595             * Get every attribute from a Output node
1596             * mimeType, encoding, schema, uom, asReference
1597             */
1598            const char *outs[5]={"mimeType","encoding","schema","uom","asReference"};
1599            for(int l=0;l<5;l++){
1600#ifdef DEBUG
1601              fprintf(stderr,"*** %s ***\t",outs[l]);
1602#endif
1603              val=xmlGetProp(cur1,BAD_CAST outs[l]);
1604              if(val!=NULL && strlen((char*)val)>0){
1605                if(tmpmaps->content!=NULL)
1606                  addToMap(tmpmaps->content,outs[l],(char*)val);
1607                else
1608                  tmpmaps->content=createMap(outs[l],(char*)val);
1609              }
1610#ifdef DEBUG
1611              fprintf(stderr,"%s\n",val);
1612#endif
1613              xmlFree(val);
1614            }
1615           
1616            xmlNodePtr cur2=cur1->children;
1617            while(cur2){
1618              /**
1619               * Indentifier
1620               */
1621              if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1622                xmlChar *val=
1623                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1624                if(tmpmaps==NULL){
1625                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1626                  if(tmpmaps == NULL){
1627                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1628                  }
1629                  tmpmaps->name=strdup((char*)val);
1630                  tmpmaps->content=NULL;
1631                  tmpmaps->next=NULL;
1632                }
1633                else
1634                  tmpmaps->name=strdup((char*)val);;
1635                xmlFree(val);
1636              }
1637              /**
1638               * Title, Asbtract
1639               */
1640              else if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1641                 xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1642                xmlChar *val=
1643                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1644                if(tmpmaps==NULL){
1645                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1646                  if(tmpmaps == NULL){
1647                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1648                  }
1649                  tmpmaps->name=strdup("missingIndetifier");
1650                  tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1651                  tmpmaps->next=NULL;
1652                }
1653                else{
1654                  if(tmpmaps->content!=NULL)
1655                    addToMap(tmpmaps->content,
1656                             (char*)cur2->name,(char*)val);
1657                  else
1658                    tmpmaps->content=
1659                      createMap((char*)cur2->name,(char*)val);
1660                }
1661                xmlFree(val);
1662              }
1663              cur2=cur2->next;
1664            }
1665          }
1666          cur1=cur1->next;
1667        }
1668      }
1669      if(request_output_real_format==NULL)
1670        request_output_real_format=dupMaps(&tmpmaps);
1671      else
1672        addMapsToMaps(&request_output_real_format,tmpmaps);
1673#ifdef DEBUG
1674      dumpMaps(tmpmaps);
1675#endif
1676      freeMaps(&tmpmaps);
1677      free(tmpmaps);
1678    }
1679
1680    xmlXPathFreeObject(tmpsptr);
1681    xmlCleanupParser();
1682  }
1683 
1684  //if(CHECK_INET_HANDLE(hInternet))
1685  InternetCloseHandle(hInternet);
1686
1687#ifdef DEBUG
1688  fprintf(stderr,"\n%i\n",i);
1689  dumpMaps(request_input_real_format);
1690  dumpMaps(request_output_real_format);
1691  dumpMap(request_inputs);
1692  fprintf(stderr,"\n%i\n",i);
1693#endif
1694
1695  /**
1696   * Ensure that each requested arguments are present in the request
1697   * DataInputs and ResponseDocument / RawDataOutput
1698   */
1699  char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,0);
1700  char *dfv1=addDefaultValues(&request_output_real_format,s1->outputs,m,1);
1701  if(strcmp(dfv1,"")!=0 || strcmp(dfv,"")!=0){
1702    char tmps[1024];
1703    if(strcmp(dfv,"")!=0){
1704      snprintf(tmps,1024,_("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."),dfv);
1705    }
1706    else if(strcmp(dfv1,"")!=0){
1707      snprintf(tmps,1024,_("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."),dfv1);
1708    }
1709    map* tmpe=createMap("text",tmps);
1710    addToMap(tmpe,"code","MissingParameterValue");
1711    printExceptionReportResponse(m,tmpe);
1712    freeService(&s1);
1713    free(s1);
1714    freeMap(&tmpe);
1715    free(tmpe);
1716    freeMaps(&m);
1717    free(m);
1718    free(REQUEST);
1719    free(SERVICE_URL);
1720    freeMaps(&request_input_real_format);
1721    free(request_input_real_format);
1722    freeMaps(&request_output_real_format);
1723    free(request_output_real_format);
1724    freeMaps(&tmpmaps);
1725    free(tmpmaps);
1726    return 1;
1727  }
1728
1729  ensureDecodedBase64(&request_input_real_format);
1730
1731#ifdef DEBUG
1732  fprintf(stderr,"REQUEST_INPUTS\n");
1733  dumpMaps(request_input_real_format);
1734  fprintf(stderr,"REQUEST_OUTPUTS\n");
1735  dumpMaps(request_output_real_format);
1736#endif
1737
1738  maps* curs=getMaps(m,"env");
1739  if(curs!=NULL){
1740    map* mapcs=curs->content;
1741    while(mapcs!=NULLMAP){
1742#ifndef WIN32
1743      setenv(mapcs->name,mapcs->value,1);
1744#else
1745#ifdef DEBUG
1746      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
1747#endif
1748      if(mapcs->value[strlen(mapcs->value)-2]=='\r'){
1749#ifdef DEBUG
1750        fprintf(stderr,"[ZOO: Env var finish with \r]\n");
1751#endif
1752        mapcs->value[strlen(mapcs->value)-1]=0;
1753      }
1754#ifdef DEBUG
1755      fflush(stderr);
1756      fprintf(stderr,"setting variable... %s\n",
1757#endif
1758              SetEnvironmentVariable(mapcs->name,mapcs->value)
1759#ifdef DEBUG
1760              ? "OK" : "FAILED");
1761#else
1762      ;
1763#endif
1764#ifdef DEBUG
1765      fflush(stderr);
1766#endif
1767#endif
1768#ifdef DEBUG
1769      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
1770      fflush(stderr);
1771#endif
1772      mapcs=mapcs->next;
1773    }
1774  }
1775 
1776#ifdef DEBUG
1777  dumpMap(request_inputs);
1778#endif
1779
1780  /**
1781   * Need to check if we need to fork to load a status enabled
1782   */
1783  r_inputs=NULL;
1784  map* store=getMap(request_inputs,"storeExecuteResponse");
1785  map* status=getMap(request_inputs,"status");
1786  /**
1787   * 05-007r7 WPS 1.0.0 page 57 :
1788   * 'If status="true" and storeExecuteResponse is "false" then the service
1789   * shall raise an exception.'
1790   */
1791  if(status!=NULL && strcmp(status->value,"true")==0 && 
1792     store!=NULL && strcmp(store->value,"false")==0){
1793    errorException(m, _("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."), "InvalidParameterValue");
1794    freeService(&s1);
1795    free(s1);
1796    freeMaps(&m);
1797    free(m);
1798   
1799    freeMaps(&request_input_real_format);
1800    free(request_input_real_format);
1801   
1802    freeMaps(&request_output_real_format);
1803    free(request_output_real_format);
1804   
1805    free(REQUEST);
1806    free(SERVICE_URL);
1807    return 1;
1808  }
1809  r_inputs=getMap(request_inputs,"storeExecuteResponse");
1810  int eres=SERVICE_STARTED;
1811  int cpid=getpid();
1812
1813  maps *_tmpMaps=(maps*)malloc(MAPS_SIZE);
1814  _tmpMaps->name=strdup("lenv");
1815  char tmpBuff[100];
1816  sprintf(tmpBuff,"%i",cpid);
1817  _tmpMaps->content=createMap("sid",tmpBuff);
1818  _tmpMaps->next=NULL;
1819  addToMap(_tmpMaps->content,"status","0");
1820  addToMap(_tmpMaps->content,"cwd",ntmp);
1821  map* ltmp=getMap(request_inputs,"soap");
1822  if(ltmp!=NULL)
1823    addToMap(_tmpMaps->content,"soap",ltmp->value);
1824  else
1825    addToMap(_tmpMaps->content,"soap","false");
1826  if(cgiCookie!=NULL && strlen(cgiCookie)>0){
1827    addToMap(_tmpMaps->content,"sessid",strstr(cgiCookie,"=")+1);
1828    char session_file_path[1024];
1829    map *tmpPath=getMapFromMaps(m,"main","sessPath");
1830    if(tmpPath==NULL)
1831      tmpPath=getMapFromMaps(m,"main","tmpPath");
1832    char *tmp1=strtok(cgiCookie,";");
1833    if(tmp1!=NULL)
1834      sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(tmp1,"=")+1);
1835    else
1836      sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(cgiCookie,"=")+1);
1837
1838    maps *tmpSess=(maps*)calloc(1,MAPS_SIZE);
1839    struct stat file_status;
1840    int istat = stat(session_file_path, &file_status);
1841    if(istat==0 && file_status.st_size>0){
1842      conf_read(session_file_path,tmpSess);
1843      addMapsToMaps(&m,tmpSess);
1844      freeMaps(&tmpSess);
1845    }
1846    free(tmpSess);
1847  }
1848  addMapsToMaps(&m,_tmpMaps);
1849  freeMaps(&_tmpMaps);
1850  free(_tmpMaps);
1851
1852#ifdef DEBUG
1853  dumpMap(request_inputs);
1854#endif
1855#ifdef WIN32
1856  char *cgiSidL=NULL;
1857  if(getenv("CGISID")!=NULL)
1858        addToMap(request_inputs,"cgiSid",getenv("CGISID"));
1859  map* test1=getMap(request_inputs,"cgiSid");
1860  if(test1!=NULL){
1861    cgiSid=test1->value;
1862  }
1863  if(cgiSid!=NULL){
1864    addToMap(request_inputs,"storeExecuteResponse","true");
1865    addToMap(request_inputs,"status","true");
1866    status=getMap(request_inputs,"status");
1867    fprintf(stderr,"cgiSID : %s",cgiSid);
1868  }
1869#endif
1870  if(status!=NULL)
1871    if(strcasecmp(status->value,"false")==0)
1872      status=NULL;
1873  if(status==NULLMAP){
1874    loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
1875  }
1876  else{
1877    pid_t   pid;
1878#ifdef DEBUG
1879    fprintf(stderr,"\nPID : %d\n",cpid);
1880#endif
1881
1882#ifndef WIN32
1883    pid = fork ();
1884#else
1885    if(cgiSid==NULL){
1886      addToMap(request_inputs,"cgSid",cgiSid);
1887      createProcess(m,request_inputs,s1,NULL,cpid,request_input_real_format,request_output_real_format);
1888      pid = cpid;
1889    }else{
1890      pid=0;
1891      cpid=atoi(cgiSid);
1892    }
1893    fflush(stderr);
1894#endif
1895    if (pid > 0) {
1896      /**
1897       * dady :
1898       * set status to SERVICE_ACCEPTED
1899       */
1900#ifdef DEBUG
1901      fprintf(stderr,"father pid continue (origin %d) %d ...\n",cpid,getpid());
1902#endif
1903      eres=SERVICE_ACCEPTED;
1904    }else if (pid == 0) {
1905      /**
1906       * son : have to close the stdout, stdin and stderr to let the parent
1907       * process answer to http client.
1908       */
1909      r_inputs=getMapFromMaps(m,"main","tmpPath");
1910      map* r_inputs1=getMap(s1->content,"ServiceProvider");
1911      char* fbkp=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)*sizeof(char));
1912      sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
1913      char* flog=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)*sizeof(char));
1914      sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
1915#ifdef DEBUG
1916      fprintf(stderr,"RUN IN BACKGROUND MODE \n");
1917      fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
1918      fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
1919#endif
1920      freopen(flog,"w+",stderr);
1921      freopen(fbkp , "w+", stdout);
1922      fclose(stdin);
1923      free(fbkp);
1924      free(flog);
1925      /**
1926       * set status to SERVICE_STARTED and flush stdout to ensure full
1927       * content was outputed (the file used to store the ResponseDocument).
1928       * The rewind stdout to restart writing from the bgining of the file,
1929       * this way the data will be updated at the end of the process run.
1930       */
1931      updateStatus(m);
1932      printProcessResponse(m,request_inputs,cpid,
1933                           s1,r_inputs1->value,SERVICE_STARTED,
1934                           request_input_real_format,
1935                           request_output_real_format);
1936#ifndef WIN32
1937      fflush(stdout);
1938      rewind(stdout);
1939#endif
1940
1941      loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
1942
1943    } else {
1944      /**
1945       * error server don't accept the process need to output a valid
1946       * error response here !!!
1947       */
1948      eres=-1;
1949      errorException(m, _("Unable to run the child process properly"), "InternalError");
1950    }
1951  }
1952
1953#ifdef DEBUG
1954  dumpMaps(request_output_real_format);
1955  fprintf(stderr,"Function loaded and returned %d\n",*eres);
1956  fflush(stderr);
1957#endif
1958  if(eres!=-1)
1959    outputResponse(s1,request_input_real_format,
1960                   request_output_real_format,request_inputs,
1961                   cpid,m,eres);
1962  fflush(stdout);
1963  /**
1964   * Ensure that if error occurs when freeing memory, no signal will return
1965   * an ExceptionReport document as the result was already returned to the
1966   * client.
1967   */
1968#ifndef USE_GDB
1969  (void) signal(SIGSEGV,donothing);
1970  (void) signal(SIGTERM,donothing);
1971  (void) signal(SIGINT,donothing);
1972  (void) signal(SIGILL,donothing);
1973  (void) signal(SIGFPE,donothing);
1974  (void) signal(SIGABRT,donothing);
1975#endif
1976
1977  if(((int)getpid())!=cpid){
1978    fclose(stdout);
1979    fclose(stderr);
1980    unhandleStatus(m);
1981  }
1982
1983  freeService(&s1);
1984  free(s1);
1985  freeMaps(&m);
1986  free(m);
1987 
1988  freeMaps(&request_input_real_format);
1989  free(request_input_real_format);
1990 
1991  freeMaps(&request_output_real_format);
1992  free(request_output_real_format);
1993 
1994  free(REQUEST);
1995  free(SERVICE_URL);
1996#ifdef DEBUG
1997  fprintf(stderr,"Processed response \n");
1998  fflush(stdout);
1999  fflush(stderr);
2000#endif
2001
2002  return 0;
2003}
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