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

Last change on this file since 348 was 348, checked in by neteler, 8 years ago

set correctly svn propset

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 57.9 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 and output 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 *tmp1=strdup(cursor_input);
927    char * pToken;
928    pToken=strtok(cursor_input,";");
929    if(pToken!=NULL && strncasecmp(pToken,tmp1,strlen(tmp1))==0){
930      char* tmp2=url_decode(tmp1);
931      snprintf(cursor_input,(strlen(tmp2)+1)*sizeof(char),"%s",tmp2);
932      free(tmp2);
933      pToken=strtok(cursor_input,";");
934    }
935    free(tmp1);
936
937    char** inputs_as_text=(char**)calloc(100,sizeof(char*));
938    if(inputs_as_text == NULL){
939      return errorException(m, _("Unable to allocate memory."), "InternalError");
940    }
941    i=0;
942    while(pToken!=NULL){
943#ifdef DEBUG
944      fprintf(stderr,"***%s***\n",pToken);
945#endif
946      fflush(stderr);
947#ifdef DEBUG
948      fprintf(stderr,"***%s***\n",pToken);
949#endif
950      inputs_as_text[i]=(char*)calloc(strlen(pToken)+1,sizeof(char));
951      snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
952      if(inputs_as_text[i] == NULL){
953        return errorException(m, _("Unable to allocate memory."), "InternalError");
954      }
955      pToken = strtok(NULL,";");
956      i++;
957    }
958
959    for(j=0;j<i;j++){
960      char *tmp=strdup(inputs_as_text[j]);
961      free(inputs_as_text[j]);
962      char *tmpc;
963      tmpc=strtok(tmp,"@");
964      while(tmpc!=NULL){
965#ifdef DEBUG
966        fprintf(stderr,"***\n***%s***\n",tmpc);
967#endif
968        char *tmpv=strstr(tmpc,"=");
969        char tmpn[256];
970        memset(tmpn,0,256);
971        if(tmpv!=NULL){
972          strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
973          tmpn[strlen(tmpc)-strlen(tmpv)]=0;
974        }
975        else{
976          strncpy(tmpn,tmpc,strlen(tmpc)*sizeof(char));
977          tmpn[strlen(tmpc)]=0;
978        }
979#ifdef DEBUG
980        fprintf(stderr,"***\n*** %s = %s ***\n",tmpn,tmpv+1);
981#endif
982        if(tmpmaps==NULL){
983          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
984          if(tmpmaps == NULL){
985            return errorException(m, _("Unable to allocate memory."), "InternalError");
986          }
987          tmpmaps->name=strdup(tmpn);
988          if(tmpv!=NULL){
989            char *tmpvf=url_decode(tmpv+1);
990            tmpmaps->content=createMap("value",tmpvf);
991            free(tmpvf);
992          }
993          else
994            tmpmaps->content=createMap("value","Reference");
995          tmpmaps->next=NULL;
996        }
997        tmpc=strtok(NULL,"@");
998        while(tmpc!=NULL){
999#ifdef DEBUG
1000          fprintf(stderr,"*** KVP NON URL-ENCODED \n***%s***\n",tmpc);
1001#endif
1002          char *tmpv1=strstr(tmpc,"=");
1003#ifdef DEBUG
1004          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
1005#endif
1006          char tmpn1[1024];
1007          memset(tmpn1,0,1024);
1008          if(tmpv1!=NULL){
1009            strncpy(tmpn1,tmpc,strlen(tmpc)-strlen(tmpv1));
1010            tmpn1[strlen(tmpc)-strlen(tmpv1)]=0;
1011            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1012          }
1013          else{
1014            strncpy(tmpn1,tmpc,strlen(tmpc));
1015            tmpn1[strlen(tmpc)]=0;
1016            map* lmap=getLastMap(tmpmaps->content);
1017            char *tmpValue=(char*)calloc((strlen(lmap->value)+strlen(tmpc)+1),sizeof(char));
1018            sprintf(tmpValue,"%s@%s",lmap->value,tmpc);
1019            free(lmap->value);
1020            lmap->value=strdup(tmpValue);
1021            free(tmpValue);
1022            tmpc=strtok(NULL,"@");
1023            continue;
1024          }
1025#ifdef DEBUG
1026          fprintf(stderr,"*** NAME NON URL-ENCODED \n***%s***\n",tmpn1);
1027          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
1028#endif
1029          if(strcmp(tmpn1,"xlink:href")!=0)
1030            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1031          else
1032            if(tmpv1!=NULL){
1033              char *tmpx2=url_decode(tmpv1+1);
1034              if(strncasecmp(tmpx2,"http://",7)!=0 &&
1035                 strncasecmp(tmpx2,"ftp://",6)!=0){
1036                char emsg[1024];
1037                sprintf(emsg,_("Unable to find a valid protocol to download the remote file %s"),tmpv1+1);
1038                errorException(m,emsg,"InternalError");
1039                freeMaps(&m);
1040                free(m);
1041                free(REQUEST);
1042                free(SERVICE_URL);
1043                InternetCloseHandle(hInternet);
1044                freeService(&s1);
1045                free(s1);
1046                return 0;
1047              }
1048#ifdef DEBUG
1049              fprintf(stderr,"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",tmpv1+1);
1050#endif
1051              addToMap(tmpmaps->content,tmpn1,tmpx2);
1052             
1053#ifndef WIN32
1054              if(CHECK_INET_HANDLE(hInternet))
1055#endif
1056                {
1057                  loadRemoteFile(m,tmpmaps->content,hInternet,tmpx2);
1058                }
1059              free(tmpx2);
1060              addToMap(tmpmaps->content,"Reference",tmpv1+1);
1061            }
1062          tmpc=strtok(NULL,"@");
1063        }
1064#ifdef DEBUG
1065        dumpMaps(tmpmaps);
1066        fflush(stderr);
1067#endif
1068        if(request_input_real_format==NULL)
1069          request_input_real_format=dupMaps(&tmpmaps);
1070        else
1071          addMapsToMaps(&request_input_real_format,tmpmaps);
1072        freeMaps(&tmpmaps);
1073        free(tmpmaps);
1074        tmpmaps=NULL;
1075        free(tmp);
1076      }
1077    }
1078    free(inputs_as_text);
1079  }
1080  else {
1081    /**
1082     * Parse XML request
1083     */ 
1084    xmlInitParser();
1085#ifdef DEBUG
1086    fflush(stderr);
1087    fprintf(stderr,"BEFORE %s\n",postRequest->value);
1088    fflush(stderr);
1089#endif
1090    xmlDocPtr doc =
1091      xmlParseMemory(postRequest->value,cgiContentLength);
1092#ifdef DEBUG
1093    fprintf(stderr,"AFTER\n");
1094    fflush(stderr);
1095#endif
1096    /**
1097     * Parse every Input in DataInputs node.
1098     */
1099    xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='Input']");
1100    xmlNodeSet* tmps=tmpsptr->nodesetval;
1101#ifdef DEBUG
1102    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1103#endif
1104    for(int k=0;k<tmps->nodeNr;k++){
1105      maps *tmpmaps=NULL;
1106      xmlNodePtr cur=tmps->nodeTab[k];
1107      if(tmps->nodeTab[k]->type == XML_ELEMENT_NODE) {
1108        /**
1109         * A specific Input node.
1110         */
1111#ifdef DEBUG
1112        fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
1113#endif
1114        xmlNodePtr cur2=cur->children;
1115        while(cur2!=NULL){
1116          while(cur2!=NULL && cur2->type!=XML_ELEMENT_NODE)
1117            cur2=cur2->next;
1118          if(cur2==NULL)
1119            break;
1120          /**
1121           * Indentifier
1122           */
1123          if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1124            xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1125            if(tmpmaps==NULL){
1126              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1127              if(tmpmaps == NULL){
1128                return errorException(m, _("Unable to allocate memory."), "InternalError");
1129              }
1130              tmpmaps->name=strdup((char*)val);
1131              tmpmaps->content=NULL;
1132              tmpmaps->next=NULL;
1133            }
1134            xmlFree(val);
1135          }
1136          /**
1137           * Title, Asbtract
1138           */
1139          if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1140             xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1141            xmlChar *val=
1142              xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1143            if(tmpmaps==NULL){
1144              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1145              if(tmpmaps == NULL){
1146                return errorException(m, _("Unable to allocate memory."), "InternalError");
1147              }
1148              tmpmaps->name=strdup("missingIndetifier");
1149              tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1150              tmpmaps->next=NULL;
1151            }
1152            else{
1153              if(tmpmaps->content!=NULL)
1154                addToMap(tmpmaps->content,
1155                         (char*)cur2->name,(char*)val);
1156              else
1157                tmpmaps->content=
1158                  createMap((char*)cur2->name,(char*)val);
1159            }
1160#ifdef DEBUG
1161            dumpMaps(tmpmaps);
1162#endif
1163            xmlFree(val);
1164          }
1165          /**
1166           * InputDataFormChoice (Reference or Data ?)
1167           */
1168          if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
1169            /**
1170             * Get every attribute from a Reference node
1171             * mimeType, encoding, schema, href, method
1172             * Header and Body gesture should be added here
1173             */
1174#ifdef DEBUG
1175            fprintf(stderr,"REFERENCE\n");
1176#endif
1177            const char *refs[5]={"mimeType","encoding","schema","method","href"};
1178            for(int l=0;l<5;l++){
1179#ifdef DEBUG
1180              fprintf(stderr,"*** %s ***",refs[l]);
1181#endif
1182              xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
1183              if(val!=NULL && xmlStrlen(val)>0){
1184                if(tmpmaps->content!=NULL)
1185                  addToMap(tmpmaps->content,refs[l],(char*)val);
1186                else
1187                  tmpmaps->content=createMap(refs[l],(char*)val);
1188                map* ltmp=getMap(tmpmaps->content,"method");
1189                if(l==4){
1190                  if(!(ltmp!=NULL && strcmp(ltmp->value,"POST")==0)
1191                     && CHECK_INET_HANDLE(hInternet)){
1192                    loadRemoteFile(m,tmpmaps->content,hInternet,(char*)val);
1193                  }
1194                }
1195              }
1196#ifdef DEBUG
1197              fprintf(stderr,"%s\n",val);
1198#endif
1199              xmlFree(val);
1200            }
1201#ifdef POST_DEBUG
1202            fprintf(stderr,"Parse Header and Body from Reference \n");
1203#endif
1204            xmlNodePtr cur3=cur2->children;
1205            hInternet.header=NULL;
1206            while(cur3){
1207              while(cur3!=NULL && cur3->type!=XML_ELEMENT_NODE)
1208                cur2=cur3->next;
1209              if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
1210                const char *ha[2];
1211                ha[0]="key";
1212                ha[1]="value";
1213                int hai;
1214                char *has;
1215                char *key;
1216                for(hai=0;hai<2;hai++){
1217                  xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
1218#ifdef POST_DEBUG
1219                  fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
1220#endif
1221                  if(hai==0){
1222                    key=(char*)calloc((1+strlen((char*)val)),sizeof(char));
1223                    snprintf(key,1+strlen((char*)val),"%s",(char*)val);
1224                  }else{
1225                    has=(char*)calloc((3+strlen((char*)val)+strlen(key)),sizeof(char));
1226                    if(has == NULL){
1227                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1228                    }
1229                    snprintf(has,(3+strlen((char*)val)+strlen(key)),"%s: %s",key,(char*)val);
1230#ifdef POST_DEBUG
1231                    fprintf(stderr,"%s\n",has);
1232#endif
1233                  }
1234                }
1235                hInternet.header=curl_slist_append(hInternet.header, has);
1236                free(has);
1237              }
1238              else{
1239#ifdef POST_DEBUG
1240                fprintf(stderr,"Try to fetch the body part of the request ...\n");
1241#endif
1242                if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
1243#ifdef POST_DEBUG
1244                  fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
1245#endif
1246                  char *tmp=new char[cgiContentLength];
1247                  memset(tmp,0,cgiContentLength);
1248                  xmlNodePtr cur4=cur3->children;
1249                  while(cur4!=NULL){
1250                    while(cur4->type!=XML_ELEMENT_NODE)
1251                      cur4=cur4->next;
1252                    xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
1253                    bdoc->encoding = xmlCharStrdup ("UTF-8");
1254                    xmlDocSetRootElement(bdoc,cur4);
1255                    xmlChar* btmps;
1256                    int bsize;
1257                    xmlDocDumpMemory(bdoc,&btmps,&bsize);
1258#ifdef POST_DEBUG
1259                    fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
1260#endif
1261                    if(btmps!=NULL)
1262                      sprintf(tmp,"%s",(char*)btmps);
1263                    xmlFreeDoc(bdoc);
1264                    cur4=cur4->next;
1265                  }
1266                  map *btmp=getMap(tmpmaps->content,"href");
1267                  if(btmp!=NULL){
1268#ifdef POST_DEBUG
1269                    fprintf(stderr,"%s %s\n",btmp->value,tmp);
1270                    curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1271#endif
1272                    res=InternetOpenUrl(hInternet,btmp->value,tmp,strlen(tmp),
1273                                        INTERNET_FLAG_NO_CACHE_WRITE,0);
1274                    char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
1275                    if(tmpContent == NULL){
1276                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1277                    }
1278                    size_t dwRead;
1279                    InternetReadFile(res, (LPVOID)tmpContent,
1280                                     res.nDataLen, &dwRead);
1281                    tmpContent[res.nDataLen]=0;
1282                    if(hInternet.header!=NULL)
1283                      curl_slist_free_all(hInternet.header);
1284                    addToMap(tmpmaps->content,"value",tmpContent);
1285#ifdef POST_DEBUG
1286                    fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1287#endif
1288                  }
1289                }
1290                else
1291                  if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
1292                    xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
1293                    HINTERNET bInternet,res1;
1294                    bInternet=InternetOpen(
1295#ifndef WIN32
1296                                           (LPCTSTR)
1297#endif
1298                                           "ZooWPSClient\0",
1299                                           INTERNET_OPEN_TYPE_PRECONFIG,
1300                                           NULL,NULL, 0);
1301                    if(!CHECK_INET_HANDLE(bInternet))
1302                      fprintf(stderr,"WARNING : hInternet handle failed to initialize");
1303#ifdef POST_DEBUG
1304                    curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
1305#endif
1306                    res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
1307                                         INTERNET_FLAG_NO_CACHE_WRITE,0);
1308                    char* tmp=
1309                      (char*)calloc((res1.nDataLen+1),sizeof(char));
1310                    if(tmp == NULL){
1311                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1312                    }
1313                    size_t bRead;
1314                    InternetReadFile(res1, (LPVOID)tmp,
1315                                     res1.nDataLen, &bRead);
1316                    tmp[res1.nDataLen]=0;
1317                    InternetCloseHandle(bInternet);
1318                    map *btmp=getMap(tmpmaps->content,"href");
1319                    if(btmp!=NULL){
1320#ifdef POST_DEBUG
1321                      fprintf(stderr,"%s %s\n",btmp->value,tmp);
1322                      curl_easy_setopt(hInternet.handle, CURLOPT_VERBOSE, 1);
1323#endif
1324                      res=InternetOpenUrl(hInternet,btmp->value,tmp,
1325                                          strlen(tmp),
1326                                          INTERNET_FLAG_NO_CACHE_WRITE,0);
1327                      char* tmpContent = (char*)calloc((res.nDataLen+1),sizeof(char));
1328                      if(tmpContent == NULL){
1329                        return errorException(m, _("Unable to allocate memory."), "InternalError");
1330                      }
1331                      size_t dwRead;
1332                      InternetReadFile(res, (LPVOID)tmpContent,
1333                                       res.nDataLen, &dwRead);
1334                      tmpContent[res.nDataLen]=0;
1335                      if(hInternet.header!=NULL)
1336                        curl_slist_free_all(hInternet.header);
1337                      addToMap(tmpmaps->content,"value",tmpContent);
1338#ifdef POST_DEBUG
1339                      fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1340#endif
1341                    }
1342                  }
1343              }
1344              cur3=cur3->next;
1345            }
1346#ifdef POST_DEBUG
1347            fprintf(stderr,"Header and Body was parsed from Reference \n");
1348#endif
1349#ifdef DEBUG
1350            dumpMap(tmpmaps->content);
1351            fprintf(stderr, "= element 2 node \"%s\" = (%s)\n", 
1352                    cur2->name,cur2->content);
1353#endif
1354          }
1355          else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
1356#ifdef DEBUG
1357            fprintf(stderr,"DATA\n");
1358#endif
1359            xmlNodePtr cur4=cur2->children;
1360            while(cur4!=NULL){
1361              while(cur4!=NULL &&cur4->type!=XML_ELEMENT_NODE)
1362                cur4=cur4->next;
1363              if(cur4==NULL)
1364                break;
1365              if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
1366                /**
1367                 * Get every attribute from a LiteralData node
1368                 * dataType , uom
1369                 */
1370                char *list[2];
1371                list[0]=strdup("dataType");
1372                list[1]=strdup("uom");
1373                for(int l=0;l<2;l++){
1374#ifdef DEBUG
1375                  fprintf(stderr,"*** LiteralData %s ***",list[l]);
1376#endif
1377                  xmlChar *val=xmlGetProp(cur4,BAD_CAST list[l]);
1378                  if(val!=NULL && strlen((char*)val)>0){
1379                    if(tmpmaps->content!=NULL)
1380                      addToMap(tmpmaps->content,list[l],(char*)val);
1381                    else
1382                      tmpmaps->content=createMap(list[l],(char*)val);
1383#ifdef DEBUG
1384                    fprintf(stderr,"%s\n",val);
1385#endif
1386                  }
1387                  xmlFree(val);
1388                  free(list[l]);                 
1389                }
1390              }
1391              else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
1392                /**
1393                 * Get every attribute from a Reference node
1394                 * mimeType, encoding, schema
1395                 */
1396                const char *coms[3]={"mimeType","encoding","schema"};
1397                for(int l=0;l<3;l++){
1398#ifdef DEBUG
1399                  fprintf(stderr,"*** ComplexData %s ***\n",coms[l]);
1400#endif
1401                  xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
1402                  if(val!=NULL && strlen((char*)val)>0){
1403                    if(tmpmaps->content!=NULL)
1404                      addToMap(tmpmaps->content,coms[l],(char*)val);
1405                    else
1406                      tmpmaps->content=createMap(coms[l],(char*)val);
1407#ifdef DEBUG
1408                    fprintf(stderr,"%s\n",val);
1409#endif
1410                  }
1411                  xmlFree(val);
1412                }
1413              }
1414
1415              map* test=getMap(tmpmaps->content,"encoding");
1416              if(test==NULL){
1417                if(tmpmaps->content!=NULL)
1418                  addToMap(tmpmaps->content,"encoding","utf-8");
1419                else
1420                  tmpmaps->content=createMap("encoding","utf-8");
1421                test=getMap(tmpmaps->content,"encoding");
1422              }
1423
1424              if(strcasecmp(test->value,"base64")!=0){
1425                xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
1426                map* ltmp=getMap(tmpmaps->content,"mimeType");
1427                if(mv==NULL || 
1428                   (xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0 &&
1429                    (ltmp==NULL || strncasecmp(ltmp->value,"text/xml",8)==0) )){
1430                  xmlDocPtr doc1=xmlNewDoc(BAD_CAST "1.0");
1431                  int buffersize;
1432                  xmlNodePtr cur5=cur4->children;
1433                  while(cur5!=NULL &&cur5->type!=XML_ELEMENT_NODE)
1434                    cur5=cur5->next;
1435                  xmlDocSetRootElement(doc1,cur5);
1436                  xmlDocDumpFormatMemoryEnc(doc1, &mv, &buffersize, "utf-8", 1);
1437                  char size[1024];
1438                  sprintf(size,"%d",buffersize);
1439                  addToMap(tmpmaps->content,"size",size);
1440                }
1441                addToMap(tmpmaps->content,"value",(char*)mv);
1442                xmlFree(mv);
1443              }else{
1444                xmlChar* tmp=xmlNodeListGetRawString(doc,cur4->xmlChildrenNode,0);
1445                addToMap(tmpmaps->content,"value",(char*)tmp);
1446                map* tmpv=getMap(tmpmaps->content,"value");
1447                char *res=NULL;
1448                char *curs=tmpv->value;
1449                for(int i=0;i<=strlen(tmpv->value)/64;i++) {
1450                  if(res==NULL)
1451                    res=(char*)malloc(67*sizeof(char));
1452                  else
1453                    res=(char*)realloc(res,(((i+1)*65)+i)*sizeof(char));
1454                  int csize=i*65;
1455                  strncpy(res + csize,curs,64);
1456                  if(i==xmlStrlen(tmp)/64)
1457                    strcat(res,"\n\0");
1458                  else{
1459                    strncpy(res + (((i+1)*64)+i),"\n\0",2);
1460                    curs+=64;
1461                  }
1462                }
1463                free(tmpv->value);
1464                tmpv->value=strdup(res);
1465                free(res);
1466                xmlFree(tmp);
1467              }
1468              cur4=cur4->next;
1469            }
1470          }
1471#ifdef DEBUG
1472          fprintf(stderr,"cur2 next \n");
1473          fflush(stderr);
1474#endif
1475          cur2=cur2->next;
1476        }
1477#ifdef DEBUG
1478        fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
1479        fflush(stderr);
1480#endif
1481        addMapsToMaps(&request_input_real_format,tmpmaps);
1482       
1483#ifdef DEBUG
1484        fprintf(stderr,"******TMPMAPS*****\n");
1485        dumpMaps(tmpmaps);
1486        fprintf(stderr,"******REQUESTMAPS*****\n");
1487        dumpMaps(request_input_real_format);
1488#endif
1489        freeMaps(&tmpmaps);
1490        free(tmpmaps);
1491        tmpmaps=NULL;         
1492      }
1493#ifdef DEBUG
1494      dumpMaps(tmpmaps); 
1495#endif
1496    }
1497#ifdef DEBUG
1498    fprintf(stderr,"Search for response document node\n");
1499#endif
1500    xmlXPathFreeObject(tmpsptr);
1501   
1502    tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='ResponseDocument']");
1503    bool asRaw=false;
1504    tmps=tmpsptr->nodesetval;
1505    if(tmps->nodeNr==0){
1506      tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='RawDataOutput']");
1507      tmps=tmpsptr->nodesetval;
1508      asRaw=true;
1509    }
1510#ifdef DEBUG
1511    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1512#endif
1513    for(int k=0;k<tmps->nodeNr;k++){
1514      if(asRaw==true)
1515        addToMap(request_inputs,"RawDataOutput","");
1516      else
1517        addToMap(request_inputs,"ResponseDocument","");
1518      maps *tmpmaps=NULL;
1519      xmlNodePtr cur=tmps->nodeTab[k];
1520      if(cur->type == XML_ELEMENT_NODE) {
1521        /**
1522         * A specific responseDocument node.
1523         */
1524        if(tmpmaps==NULL){
1525          tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1526          if(tmpmaps == NULL){
1527            return errorException(m, _("Unable to allocate memory."), "InternalError");
1528          }
1529          tmpmaps->name=strdup("unknownIdentifier");
1530          tmpmaps->next=NULL;
1531        }
1532        /**
1533         * Get every attribute from a LiteralData node
1534         * storeExecuteResponse, lineage, status
1535         */
1536        const char *ress[3]={"storeExecuteResponse","lineage","status"};
1537        xmlChar *val;
1538        for(int l=0;l<3;l++){
1539#ifdef DEBUG
1540          fprintf(stderr,"*** %s ***\t",ress[l]);
1541#endif
1542          val=xmlGetProp(cur,BAD_CAST ress[l]);
1543          if(val!=NULL && strlen((char*)val)>0){
1544            if(tmpmaps->content!=NULL)
1545              addToMap(tmpmaps->content,ress[l],(char*)val);
1546            else
1547              tmpmaps->content=createMap(ress[l],(char*)val);
1548            addToMap(request_inputs,ress[l],(char*)val);
1549          }
1550#ifdef DEBUG
1551          fprintf(stderr,"%s\n",val);
1552#endif
1553          xmlFree(val);
1554        }
1555        xmlNodePtr cur1=cur->children;
1556        while(cur1){
1557          /**
1558           * Indentifier
1559           */
1560          if(xmlStrncasecmp(cur1->name,BAD_CAST "Identifier",xmlStrlen(cur1->name))==0){
1561            xmlChar *val=
1562              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1563            if(tmpmaps==NULL){
1564              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1565              if(tmpmaps == NULL){
1566                return errorException(m, _("Unable to allocate memory."), "InternalError");
1567              }
1568              tmpmaps->name=strdup((char*)val);
1569              tmpmaps->content=NULL;
1570              tmpmaps->next=NULL;
1571            }
1572            else
1573              tmpmaps->name=strdup((char*)val);;
1574            xmlFree(val);
1575          }
1576          /**
1577           * Title, Asbtract
1578           */
1579          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Title",xmlStrlen(cur1->name))==0 ||
1580                  xmlStrncasecmp(cur1->name,BAD_CAST "Abstract",xmlStrlen(cur1->name))==0){
1581            xmlChar *val=
1582              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1583            if(tmpmaps==NULL){
1584              tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1585              if(tmpmaps == NULL){
1586                return errorException(m, _("Unable to allocate memory."), "InternalError");
1587              }
1588              tmpmaps->name=strdup("missingIndetifier");
1589              tmpmaps->content=createMap((char*)cur1->name,(char*)val);
1590              tmpmaps->next=NULL;
1591            }
1592            else{
1593              if(tmpmaps->content!=NULL)
1594                addToMap(tmpmaps->content,
1595                         (char*)cur1->name,(char*)val);
1596              else
1597                tmpmaps->content=
1598                  createMap((char*)cur1->name,(char*)val);
1599            }
1600            xmlFree(val);
1601          }
1602          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
1603            /**
1604             * Get every attribute from a Output node
1605             * mimeType, encoding, schema, uom, asReference
1606             */
1607            const char *outs[5]={"mimeType","encoding","schema","uom","asReference"};
1608            for(int l=0;l<5;l++){
1609#ifdef DEBUG
1610              fprintf(stderr,"*** %s ***\t",outs[l]);
1611#endif
1612              val=xmlGetProp(cur1,BAD_CAST outs[l]);
1613              if(val!=NULL && strlen((char*)val)>0){
1614                if(tmpmaps->content!=NULL)
1615                  addToMap(tmpmaps->content,outs[l],(char*)val);
1616                else
1617                  tmpmaps->content=createMap(outs[l],(char*)val);
1618              }
1619#ifdef DEBUG
1620              fprintf(stderr,"%s\n",val);
1621#endif
1622              xmlFree(val);
1623            }
1624           
1625            xmlNodePtr cur2=cur1->children;
1626            while(cur2){
1627              /**
1628               * Indentifier
1629               */
1630              if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1631                xmlChar *val=
1632                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1633                if(tmpmaps==NULL){
1634                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1635                  if(tmpmaps == NULL){
1636                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1637                  }
1638                  tmpmaps->name=strdup((char*)val);
1639                  tmpmaps->content=NULL;
1640                  tmpmaps->next=NULL;
1641                }
1642                else
1643                  tmpmaps->name=strdup((char*)val);;
1644                xmlFree(val);
1645              }
1646              /**
1647               * Title, Asbtract
1648               */
1649              else if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1650                      xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1651                xmlChar *val=
1652                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1653                if(tmpmaps==NULL){
1654                  tmpmaps=(maps*)calloc(1,MAPS_SIZE);
1655                  if(tmpmaps == NULL){
1656                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1657                  }
1658                  tmpmaps->name=strdup("missingIndetifier");
1659                  tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1660                  tmpmaps->next=NULL;
1661                }
1662                else{
1663                  if(tmpmaps->content!=NULL)
1664                    addToMap(tmpmaps->content,
1665                             (char*)cur2->name,(char*)val);
1666                  else
1667                    tmpmaps->content=
1668                      createMap((char*)cur2->name,(char*)val);
1669                }
1670                xmlFree(val);
1671              }
1672              cur2=cur2->next;
1673            }
1674          }
1675          cur1=cur1->next;
1676        }
1677      }
1678      if(request_output_real_format==NULL)
1679        request_output_real_format=dupMaps(&tmpmaps);
1680      else
1681        addMapsToMaps(&request_output_real_format,tmpmaps);
1682#ifdef DEBUG
1683      dumpMaps(tmpmaps);
1684#endif
1685      freeMaps(&tmpmaps);
1686      free(tmpmaps);
1687    }
1688
1689    xmlXPathFreeObject(tmpsptr);
1690    xmlCleanupParser();
1691  }
1692 
1693  //if(CHECK_INET_HANDLE(hInternet))
1694  InternetCloseHandle(hInternet);
1695
1696#ifdef DEBUG
1697  fprintf(stderr,"\n%i\n",i);
1698  dumpMaps(request_input_real_format);
1699  dumpMaps(request_output_real_format);
1700  dumpMap(request_inputs);
1701  fprintf(stderr,"\n%i\n",i);
1702#endif
1703
1704  /**
1705   * Ensure that each requested arguments are present in the request
1706   * DataInputs and ResponseDocument / RawDataOutput
1707   */
1708  char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,0);
1709  char *dfv1=addDefaultValues(&request_output_real_format,s1->outputs,m,1);
1710  if(strcmp(dfv1,"")!=0 || strcmp(dfv,"")!=0){
1711    char tmps[1024];
1712    if(strcmp(dfv,"")!=0){
1713      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);
1714    }
1715    else if(strcmp(dfv1,"")!=0){
1716      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);
1717    }
1718    map* tmpe=createMap("text",tmps);
1719    addToMap(tmpe,"code","MissingParameterValue");
1720    printExceptionReportResponse(m,tmpe);
1721    freeService(&s1);
1722    free(s1);
1723    freeMap(&tmpe);
1724    free(tmpe);
1725    freeMaps(&m);
1726    free(m);
1727    free(REQUEST);
1728    free(SERVICE_URL);
1729    freeMaps(&request_input_real_format);
1730    free(request_input_real_format);
1731    freeMaps(&request_output_real_format);
1732    free(request_output_real_format);
1733    freeMaps(&tmpmaps);
1734    free(tmpmaps);
1735    return 1;
1736  }
1737
1738  maps* tmpReqI=request_input_real_format;
1739  while(tmpReqI!=NULL){
1740    char name[1024];
1741    if(getMap(tmpReqI->content,"isFile")!=NULL){
1742      if (cgiFormFileName(tmpReqI->name, name, sizeof(name)) == cgiFormSuccess) {
1743        int BufferLen=1024;
1744        cgiFilePtr file;
1745        int targetFile;
1746        mode_t mode;
1747        char storageNameOnServer[2048];
1748        char fileNameOnServer[64];
1749        char contentType[1024];
1750        char buffer[BufferLen];
1751        char *tmpStr=NULL;
1752        int size;
1753        int got,t;
1754        map *path=getMapFromMaps(m,"main","tmpPath");
1755        cgiFormFileSize(tmpReqI->name, &size);
1756        cgiFormFileContentType(tmpReqI->name, contentType, sizeof(contentType));
1757        if (cgiFormFileOpen(tmpReqI->name, &file) == cgiFormSuccess) {
1758          t=-1;
1759          while(1){
1760            tmpStr=strstr(name+t+1,"\\");
1761            if(NULL==tmpStr)
1762              tmpStr=strstr(name+t+1,"/");
1763            if(NULL!=tmpStr)
1764              t=(int)(tmpStr-name);
1765            else
1766              break;
1767          }
1768          strcpy(fileNameOnServer,name+t+1);
1769         
1770          sprintf(storageNameOnServer,"%s/%s",path->value,fileNameOnServer);
1771          fprintf(stderr,"Name on server %s\n",storageNameOnServer);
1772          fprintf(stderr,"fileNameOnServer: %s\n",fileNameOnServer);
1773          mode=S_IRWXU|S_IRGRP|S_IROTH;
1774          targetFile = open (storageNameOnServer,O_RDWR|O_CREAT|O_TRUNC,mode);
1775          if(targetFile<0){
1776            fprintf(stderr,"could not create the new file,%s\n",fileNameOnServer);         
1777          }else{
1778            while (cgiFormFileRead(file, buffer, BufferLen, &got) ==cgiFormSuccess){
1779              if(got>0)
1780                write(targetFile,buffer,got);
1781            }
1782          }
1783          addToMap(tmpReqI->content,"lref",storageNameOnServer);
1784          cgiFormFileClose(file);
1785          close(targetFile);
1786          fprintf(stderr,"File \"%s\" has been uploaded",fileNameOnServer);
1787        }
1788      }
1789    }
1790    tmpReqI=tmpReqI->next;
1791  }
1792
1793  ensureDecodedBase64(&request_input_real_format);
1794
1795#ifdef DEBUG
1796  fprintf(stderr,"REQUEST_INPUTS\n");
1797  dumpMaps(request_input_real_format);
1798  fprintf(stderr,"REQUEST_OUTPUTS\n");
1799  dumpMaps(request_output_real_format);
1800#endif
1801
1802  maps* curs=getMaps(m,"env");
1803  if(curs!=NULL){
1804    map* mapcs=curs->content;
1805    while(mapcs!=NULLMAP){
1806#ifndef WIN32
1807      setenv(mapcs->name,mapcs->value,1);
1808#else
1809#ifdef DEBUG
1810      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
1811#endif
1812      if(mapcs->value[strlen(mapcs->value)-2]=='\r'){
1813#ifdef DEBUG
1814        fprintf(stderr,"[ZOO: Env var finish with \r]\n");
1815#endif
1816        mapcs->value[strlen(mapcs->value)-1]=0;
1817      }
1818#ifdef DEBUG
1819      fflush(stderr);
1820      fprintf(stderr,"setting variable... %s\n",
1821#endif
1822              SetEnvironmentVariable(mapcs->name,mapcs->value)
1823#ifdef DEBUG
1824              ? "OK" : "FAILED");
1825#else
1826      ;
1827#endif
1828#ifdef DEBUG
1829      fflush(stderr);
1830#endif
1831#endif
1832#ifdef DEBUG
1833      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
1834      fflush(stderr);
1835#endif
1836      mapcs=mapcs->next;
1837    }
1838  }
1839 
1840#ifdef DEBUG
1841  dumpMap(request_inputs);
1842#endif
1843
1844  /**
1845   * Need to check if we need to fork to load a status enabled
1846   */
1847  r_inputs=NULL;
1848  map* store=getMap(request_inputs,"storeExecuteResponse");
1849  map* status=getMap(request_inputs,"status");
1850  /**
1851   * 05-007r7 WPS 1.0.0 page 57 :
1852   * 'If status="true" and storeExecuteResponse is "false" then the service
1853   * shall raise an exception.'
1854   */
1855  if(status!=NULL && strcmp(status->value,"true")==0 && 
1856     store!=NULL && strcmp(store->value,"false")==0){
1857    errorException(m, _("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."), "InvalidParameterValue");
1858    freeService(&s1);
1859    free(s1);
1860    freeMaps(&m);
1861    free(m);
1862   
1863    freeMaps(&request_input_real_format);
1864    free(request_input_real_format);
1865   
1866    freeMaps(&request_output_real_format);
1867    free(request_output_real_format);
1868   
1869    free(REQUEST);
1870    free(SERVICE_URL);
1871    return 1;
1872  }
1873  r_inputs=getMap(request_inputs,"storeExecuteResponse");
1874  int eres=SERVICE_STARTED;
1875  int cpid=getpid();
1876
1877  maps *_tmpMaps=(maps*)malloc(MAPS_SIZE);
1878  _tmpMaps->name=strdup("lenv");
1879  char tmpBuff[100];
1880  sprintf(tmpBuff,"%i",cpid);
1881  _tmpMaps->content=createMap("sid",tmpBuff);
1882  _tmpMaps->next=NULL;
1883  addToMap(_tmpMaps->content,"status","0");
1884  addToMap(_tmpMaps->content,"cwd",ntmp);
1885  map* ltmp=getMap(request_inputs,"soap");
1886  if(ltmp!=NULL)
1887    addToMap(_tmpMaps->content,"soap",ltmp->value);
1888  else
1889    addToMap(_tmpMaps->content,"soap","false");
1890  if(cgiCookie!=NULL && strlen(cgiCookie)>0){
1891    char *tcook=strdup(cgiCookie);
1892    if(strstr(cgiCookie,";")>0){
1893      char *token,*saveptr;
1894      token=strtok_r(cgiCookie,";",&saveptr);
1895      while(token!=NULL){
1896        if(strcasestr(token,"ID")!=NULL){
1897          if(tcook!=NULL)
1898            free(tcook);
1899          tcook=strdup(token);
1900        }
1901        token=strtok_r(NULL,";",&saveptr);
1902      }
1903    }
1904    addToMap(_tmpMaps->content,"sessid",strstr(tcook,"=")+1);
1905    char session_file_path[1024];
1906    map *tmpPath=getMapFromMaps(m,"main","sessPath");
1907    if(tmpPath==NULL)
1908      tmpPath=getMapFromMaps(m,"main","tmpPath");
1909    char *tmp1=strtok(tcook,";");
1910    if(tmp1!=NULL)
1911      sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(tmp1,"=")+1);
1912    else
1913      sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(cgiCookie,"=")+1);
1914    free(tcook);
1915    maps *tmpSess=(maps*)calloc(1,MAPS_SIZE);
1916    struct stat file_status;
1917    int istat = stat(session_file_path, &file_status);
1918    if(istat==0 && file_status.st_size>0){
1919      conf_read(session_file_path,tmpSess);
1920      addMapsToMaps(&m,tmpSess);
1921      freeMaps(&tmpSess);
1922    }
1923    free(tmpSess);
1924  }
1925  addMapsToMaps(&m,_tmpMaps);
1926  freeMaps(&_tmpMaps);
1927  free(_tmpMaps);
1928
1929#ifdef DEBUG
1930  dumpMap(request_inputs);
1931#endif
1932#ifdef WIN32
1933  char *cgiSidL=NULL;
1934  if(getenv("CGISID")!=NULL)
1935    addToMap(request_inputs,"cgiSid",getenv("CGISID"));
1936  map* test1=getMap(request_inputs,"cgiSid");
1937  if(test1!=NULL){
1938    cgiSid=test1->value;
1939  }
1940  if(cgiSid!=NULL){
1941    addToMap(request_inputs,"storeExecuteResponse","true");
1942    addToMap(request_inputs,"status","true");
1943    status=getMap(request_inputs,"status");
1944    fprintf(stderr,"cgiSID : %s",cgiSid);
1945  }
1946#endif
1947  if(status!=NULL)
1948    if(strcasecmp(status->value,"false")==0)
1949      status=NULL;
1950  if(status==NULLMAP){
1951    loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
1952  }
1953  else{
1954    pid_t   pid;
1955#ifdef DEBUG
1956    fprintf(stderr,"\nPID : %d\n",cpid);
1957#endif
1958
1959#ifndef WIN32
1960    pid = fork ();
1961#else
1962    if(cgiSid==NULL){
1963      addToMap(request_inputs,"cgSid",cgiSid);
1964      createProcess(m,request_inputs,s1,NULL,cpid,request_input_real_format,request_output_real_format);
1965      pid = cpid;
1966    }else{
1967      pid=0;
1968      cpid=atoi(cgiSid);
1969    }
1970    fflush(stderr);
1971#endif
1972    if (pid > 0) {
1973      /**
1974       * dady :
1975       * set status to SERVICE_ACCEPTED
1976       */
1977#ifdef DEBUG
1978      fprintf(stderr,"father pid continue (origin %d) %d ...\n",cpid,getpid());
1979#endif
1980      eres=SERVICE_ACCEPTED;
1981    }else if (pid == 0) {
1982      /**
1983       * son : have to close the stdout, stdin and stderr to let the parent
1984       * process answer to http client.
1985       */
1986      r_inputs=getMapFromMaps(m,"main","tmpPath");
1987      map* r_inputs1=getMap(s1->content,"ServiceProvider");
1988      char* fbkp=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)*sizeof(char));
1989      sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
1990      char* flog=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+100)*sizeof(char));
1991      sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
1992#ifdef DEBUG
1993      fprintf(stderr,"RUN IN BACKGROUND MODE \n");
1994      fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
1995      fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
1996#endif
1997      freopen(flog,"w+",stderr);
1998      freopen(fbkp , "w+", stdout);
1999      fclose(stdin);
2000      free(fbkp);
2001      free(flog);
2002      /**
2003       * set status to SERVICE_STARTED and flush stdout to ensure full
2004       * content was outputed (the file used to store the ResponseDocument).
2005       * The rewind stdout to restart writing from the bgining of the file,
2006       * this way the data will be updated at the end of the process run.
2007       */
2008      updateStatus(m);
2009      printProcessResponse(m,request_inputs,cpid,
2010                           s1,r_inputs1->value,SERVICE_STARTED,
2011                           request_input_real_format,
2012                           request_output_real_format);
2013#ifndef WIN32
2014      fflush(stdout);
2015      rewind(stdout);
2016#endif
2017
2018      loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
2019
2020    } else {
2021      /**
2022       * error server don't accept the process need to output a valid
2023       * error response here !!!
2024       */
2025      eres=-1;
2026      errorException(m, _("Unable to run the child process properly"), "InternalError");
2027    }
2028  }
2029
2030#ifdef DEBUG
2031  dumpMaps(request_output_real_format);
2032#endif
2033  if(eres!=-1)
2034    outputResponse(s1,request_input_real_format,
2035                   request_output_real_format,request_inputs,
2036                   cpid,m,eres);
2037  fflush(stdout);
2038  /**
2039   * Ensure that if error occurs when freeing memory, no signal will return
2040   * an ExceptionReport document as the result was already returned to the
2041   * client.
2042   */
2043#ifndef USE_GDB
2044  (void) signal(SIGSEGV,donothing);
2045  (void) signal(SIGTERM,donothing);
2046  (void) signal(SIGINT,donothing);
2047  (void) signal(SIGILL,donothing);
2048  (void) signal(SIGFPE,donothing);
2049  (void) signal(SIGABRT,donothing);
2050#endif
2051
2052  if(((int)getpid())!=cpid){
2053    fclose(stdout);
2054    fclose(stderr);
2055    unhandleStatus(m);
2056  }
2057
2058  freeService(&s1);
2059  free(s1);
2060  freeMaps(&m);
2061  free(m);
2062 
2063  freeMaps(&request_input_real_format);
2064  free(request_input_real_format);
2065 
2066  freeMaps(&request_output_real_format);
2067  free(request_output_real_format);
2068 
2069  free(REQUEST);
2070  free(SERVICE_URL);
2071#ifdef DEBUG
2072  fprintf(stderr,"Processed response \n");
2073  fflush(stdout);
2074  fflush(stderr);
2075#endif
2076
2077  return 0;
2078}
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