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

Last change on this file since 454 was 454, checked in by djay, 8 years ago

Dumping final file fix. Add missing functions definition.

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 66.8 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 *  Copyright 2008-2013 GeoLabs SARL. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#define length(x) (sizeof(x) / sizeof(x[0]))
26
27extern "C" int yylex();
28extern "C" int crlex();
29
30#include "cgic.h"
31
32extern "C" {
33#include <libxml/tree.h>
34#include <libxml/xmlmemory.h>
35#include <libxml/parser.h>
36#include <libxml/xpath.h>
37#include <libxml/xpathInternals.h>
38}
39
40#include "ulinet.h"
41
42#include <libintl.h>
43#include <locale.h>
44#include <string.h>
45
46#include "service.h"
47
48#include "service_internal.h"
49
50#ifdef USE_PYTHON
51#include "service_internal_python.h"
52#endif
53
54#ifdef USE_JAVA
55#include "service_internal_java.h"
56#endif
57
58#ifdef USE_PHP
59#include "service_internal_php.h"
60#endif
61
62#ifdef USE_JS
63#include "service_internal_js.h"
64#endif
65
66#ifdef USE_RUBY
67#include "service_internal_ruby.h"
68#endif
69
70#ifdef USE_PERL
71#include "service_internal_perl.h"
72#endif
73
74#include <dirent.h>
75#include <signal.h>
76#include <unistd.h>
77#ifndef WIN32
78#include <dlfcn.h>
79#include <libgen.h>
80#else
81#include <windows.h>
82#include <direct.h>
83#include <sys/types.h>
84#include <sys/stat.h>
85#include <unistd.h>
86#define pid_t int;
87#endif
88#include <fcntl.h>
89#include <time.h>
90#include <stdarg.h>
91
92#ifdef WIN32
93extern "C" {
94  __declspec(dllexport) char *strcasestr(char const *a, char const *b)
95#ifndef USE_MS
96 { 
97  char *x=_zStrdup(a); 
98  char *y=_zStrdup(b); 
99 
100  x=_strlwr(x); 
101  y=_strlwr(y); 
102  char *pos = strstr(x, y); 
103  char *ret = pos == NULL ? NULL : (char *)(a + (pos-x)); 
104  free(x); 
105  free(y); 
106  return ret; 
107 };
108#else
109  ;
110#endif
111}
112#endif
113
114#define _(String) dgettext ("zoo-kernel",String)
115#define __(String) dgettext ("zoo-service",String)
116
117
118void translateChar(char* str,char toReplace,char toReplaceBy){
119  int i=0,len=strlen(str);
120  for(i=0;i<len;i++){
121    if(str[i]==toReplace)
122      str[i]=toReplaceBy;
123  }
124}
125
126/**
127 * Create (or append to) an array valued maps
128 * value = "["",""]"
129 */
130int appendMapsToMaps(maps* m,maps* mo,maps* mi,elements* elem){
131  maps* tmpMaps=getMaps(mo,mi->name);
132  map* tmap=getMapType(tmpMaps->content);
133  elements* el=getElements(elem,mi->name);
134  int hasEl=1;
135  if(el==NULL)
136    hasEl=-1;
137  if(tmap==NULL){
138    if(hasEl>0)
139      tmap=getMapType(el->defaults->content);     
140  }
141
142  map* testMap=NULL;
143  if(hasEl>0){
144    testMap=getMap(el->content,"maxOccurs");
145  }else{
146    testMap=createMap("maxOccurs","unbounded");
147  }
148
149  if(testMap!=NULL){
150    if(strncasecmp(testMap->value,"unbounded",9)!=0 && atoi(testMap->value)>1){
151      if(addMapsArrayToMaps(&mo,mi,tmap->name)<0){
152        char emsg[1024];
153        sprintf(emsg,_("You set maximum occurences for <%s> as %i but you tried to use it more than the limit you set. Please correct your ZCFG file or your request."),mi->name,atoi(testMap->value));
154        errorException(m,emsg,"InternalError");
155        return -1;
156      }
157    }else{
158      if(strncasecmp(testMap->value,"unbounded",9)==0){
159        if(hasEl<0){
160          freeMap(&testMap);
161          free(testMap);
162        }
163        if(addMapsArrayToMaps(&mo,mi,tmap->name)<0){
164          char emsg[1024];
165          map* tmpMap=getMap(mi->content,"length");
166          sprintf(emsg,_("ZOO-Kernel was unable to load your data for %s position %s."),mi->name,tmpMap->value);
167          errorException(m,emsg,"InternalError");
168          return -1;
169        }
170      }
171      else{
172        char emsg[1024];
173        sprintf(emsg,_("You set maximum occurences for <%s> to one but you tried to use it more than once. Please correct your ZCFG file or your request."),mi->name);
174        errorException(m,emsg,"InternalError");
175        return -1;
176      }
177    }
178  }
179  return 0;
180}
181
182xmlXPathObjectPtr extractFromDoc(xmlDocPtr doc,const char* search){
183  xmlXPathContextPtr xpathCtx;
184  xmlXPathObjectPtr xpathObj;
185  xpathCtx = xmlXPathNewContext(doc);
186  xpathObj = xmlXPathEvalExpression(BAD_CAST search,xpathCtx);
187  xmlXPathFreeContext(xpathCtx);
188  return xpathObj;
189}
190
191void donothing(int sig){
192  fprintf(stderr,"Signal %d after the ZOO-Kernel returned result !\n",sig);
193  exit(0);
194}
195
196void sig_handler(int sig){
197  char tmp[100];
198  const char *ssig;
199  switch(sig){
200  case SIGSEGV:
201    ssig="SIGSEGV";
202    break;
203  case SIGTERM:
204    ssig="SIGTERM";
205    break;
206  case SIGINT:
207    ssig="SIGINT";
208    break;
209  case SIGILL:
210    ssig="SIGILL";
211    break;
212  case SIGFPE:
213    ssig="SIGFPE";
214    break;
215  case SIGABRT:
216    ssig="SIGABRT";
217    break;
218  default:
219    ssig="UNKNOWN";
220    break;
221  }
222  sprintf(tmp,_("ZOO Kernel failed to process your request receiving signal %d = %s"),sig,ssig);
223  errorException(NULL, tmp, "InternalError");
224#ifdef DEBUG
225  fprintf(stderr,"Not this time!\n");
226#endif
227  exit(0);
228}
229
230void loadServiceAndRun(maps **myMap,service* s1,map* request_inputs,maps **inputs,maps** ioutputs,int* eres){
231  char tmps1[1024];
232  char ntmp[1024];
233  maps *m=*myMap;
234  maps *request_output_real_format=*ioutputs;
235  maps *request_input_real_format=*inputs;
236  /**
237   * Extract serviceType to know what kind of service should be loaded
238   */
239  map* r_inputs=NULL;
240#ifndef WIN32
241  char* pntmp=getcwd(ntmp,1024);
242#else
243  _getcwd(ntmp,1024);
244#endif
245  r_inputs=getMap(s1->content,"serviceType");
246#ifdef DEBUG
247  fprintf(stderr,"LOAD A %s SERVICE PROVIDER \n",r_inputs->value);
248  fflush(stderr);
249#endif
250  if(strlen(r_inputs->value)==1 && strncasecmp(r_inputs->value,"C",1)==0){
251    r_inputs=getMap(request_inputs,"metapath");
252    if(r_inputs!=NULL)
253      sprintf(tmps1,"%s/%s",ntmp,r_inputs->value);
254    else
255      sprintf(tmps1,"%s/",ntmp);
256    char *altPath=zStrdup(tmps1);
257    r_inputs=getMap(s1->content,"ServiceProvider");
258    sprintf(tmps1,"%s/%s",altPath,r_inputs->value);
259    free(altPath);
260#ifdef DEBUG
261    fprintf(stderr,"Trying to load %s\n",tmps1);
262#endif
263#ifdef WIN32
264    HINSTANCE so = LoadLibraryEx(tmps1,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
265#else
266    void* so = dlopen(tmps1, RTLD_LAZY);
267#endif
268#ifdef DEBUG
269#ifdef WIN32
270    DWORD errstr;
271    errstr = GetLastError();
272    fprintf(stderr,"%s loaded (%d) \n",tmps1,errstr);
273#else
274    char *errstr;
275    errstr = dlerror();
276#endif
277#endif
278    if( so != NULL ) {
279#ifdef DEBUG
280      fprintf(stderr,"Library loaded %s \n",errstr);
281      fprintf(stderr,"Service Shared Object = %s\n",r_inputs->value);
282#endif
283      r_inputs=getMap(s1->content,"serviceType");
284#ifdef DEBUG
285      dumpMap(r_inputs);
286      fprintf(stderr,"%s\n",r_inputs->value);
287      fflush(stderr);
288#endif
289      if(strncasecmp(r_inputs->value,"C-FORTRAN",9)==0){
290        r_inputs=getMap(request_inputs,"Identifier");
291        char fname[1024];
292        sprintf(fname,"%s_",r_inputs->value);
293#ifdef DEBUG
294        fprintf(stderr,"Try to load function %s\n",fname);
295#endif
296#ifdef WIN32
297        typedef int (CALLBACK* execute_t)(char***,char***,char***);
298        execute_t execute=(execute_t)GetProcAddress(so,fname);
299#else
300        typedef int (*execute_t)(char***,char***,char***);
301        execute_t execute=(execute_t)dlsym(so,fname);
302#endif
303#ifdef DEBUG
304#ifdef WIN32
305        errstr = GetLastError();
306#else
307        errstr = dlerror();
308#endif
309        fprintf(stderr,"Function loaded %s\n",errstr);
310#endif 
311
312        char main_conf[10][30][1024];
313        char inputs[10][30][1024];
314        char outputs[10][30][1024];
315        for(int i=0;i<10;i++){
316          for(int j=0;j<30;j++){
317            memset(main_conf[i][j],0,1024);
318            memset(inputs[i][j],0,1024);
319            memset(outputs[i][j],0,1024);
320          }
321        }
322        mapsToCharXXX(m,(char***)main_conf);
323        mapsToCharXXX(request_input_real_format,(char***)inputs);
324        mapsToCharXXX(request_output_real_format,(char***)outputs);
325        *eres=execute((char***)&main_conf[0],(char***)&inputs[0],(char***)&outputs[0]);
326#ifdef DEBUG
327        fprintf(stderr,"Function run successfully \n");
328#endif
329        charxxxToMaps((char***)&outputs[0],&request_output_real_format);
330      }else{
331#ifdef DEBUG
332#ifdef WIN32
333        errstr = GetLastError();
334        fprintf(stderr,"Function %s failed to load because of %d\n",r_inputs->value,errstr);
335#endif
336#endif
337        r_inputs=getMap(request_inputs,"Identifier");
338#ifdef DEBUG
339        fprintf(stderr,"Try to load function %s\n",r_inputs->value);
340#endif
341        typedef int (*execute_t)(maps**,maps**,maps**);
342#ifdef WIN32
343        execute_t execute=(execute_t)GetProcAddress(so,r_inputs->value); 
344#else
345        execute_t execute=(execute_t)dlsym(so,r_inputs->value);
346#endif
347
348#ifdef DEBUG
349#ifdef WIN32
350        errstr = GetLastError();
351#else
352        errstr = dlerror();
353#endif
354        fprintf(stderr,"Function loaded %s\n",errstr);
355#endif 
356
357#ifdef DEBUG
358        fprintf(stderr,"Now run the function \n");
359        fflush(stderr);
360#endif
361        *eres=execute(&m,&request_input_real_format,&request_output_real_format);
362#ifdef DEBUG
363        fprintf(stderr,"Function loaded and returned %d\n",eres);
364        fflush(stderr);
365#endif
366      }
367#ifdef WIN32
368      *ioutputs=dupMaps(&request_output_real_format);
369      FreeLibrary(so);
370#else
371      dlclose(so);
372#endif
373    } else {
374      /**
375       * Unable to load the specified shared library
376       */
377      char tmps[1024];
378#ifdef WIN32
379      DWORD errstr = GetLastError();
380#else
381      char* errstr = dlerror();
382#endif
383      sprintf(tmps,_("C Library can't be loaded %s"),errstr);
384      map* tmps1=createMap("text",tmps);
385      printExceptionReportResponse(m,tmps1);
386      *eres=-1;
387    }
388  }
389  else
390#ifdef USE_PYTHON
391    if(strncasecmp(r_inputs->value,"PYTHON",6)==0){
392      *eres=zoo_python_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
393    }
394    else
395#endif
396       
397#ifdef USE_JAVA
398      if(strncasecmp(r_inputs->value,"JAVA",4)==0){
399        *eres=zoo_java_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
400      }
401      else
402#endif
403
404#ifdef USE_PHP
405        if(strncasecmp(r_inputs->value,"PHP",3)==0){
406          *eres=zoo_php_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
407        }
408        else
409#endif
410           
411           
412#ifdef USE_PERL
413          if(strncasecmp(r_inputs->value,"PERL",4)==0){
414            *eres=zoo_perl_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
415          }
416          else
417#endif
418
419#ifdef USE_JS
420            if(strncasecmp(r_inputs->value,"JS",2)==0){
421              *eres=zoo_js_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
422            }
423            else
424#endif
425
426#ifdef USE_RUBY
427          if(strncasecmp(r_inputs->value,"Ruby",4)==0){
428            *eres=zoo_ruby_support(&m,request_inputs,s1,&request_input_real_format,&request_output_real_format);
429          }
430          else
431#endif
432
433              {
434                char tmpv[1024];
435                sprintf(tmpv,_("Programming Language (%s) set in ZCFG file is not currently supported by ZOO Kernel.\n"),r_inputs->value);
436                map* tmps=createMap("text",tmpv);
437                printExceptionReportResponse(m,tmps);
438                *eres=-1;
439              }
440  *myMap=m;
441  *ioutputs=request_output_real_format;
442}
443
444
445#ifdef WIN32
446/**
447 * createProcess function: create a new process after setting some env variables
448 */
449void createProcess(maps* m,map* request_inputs,service* s1,char* opts,int cpid, maps* inputs,maps* outputs){
450  STARTUPINFO si;
451  PROCESS_INFORMATION pi;
452  ZeroMemory( &si, sizeof(si) );
453  si.cb = sizeof(si);
454  ZeroMemory( &pi, sizeof(pi) );
455  char *tmp=(char *)malloc((1024+cgiContentLength)*sizeof(char));
456  char *tmpq=(char *)malloc((1024+cgiContentLength)*sizeof(char));
457  map *req=getMap(request_inputs,"request");
458  map *id=getMap(request_inputs,"identifier");
459  map *di=getMap(request_inputs,"DataInputs");
460
461  char *dataInputsKVP=getMapsAsKVP(inputs,cgiContentLength,0);
462  char *dataOutputsKVP=getMapsAsKVP(outputs,cgiContentLength,1);
463#ifdef DEBUG
464  fprintf(stderr,"DATAINPUTSKVP %s\n",dataInputsKVP);
465  fprintf(stderr,"DATAOUTPUTSKVP %s\n",dataOutputsKVP);
466#endif
467  map *sid=getMapFromMaps(m,"lenv","sid");
468  map* r_inputs=getMapFromMaps(m,"main","tmpPath");
469  map* r_inputs1=getMap(request_inputs,"metapath");
470  int hasIn=-1;
471  if(r_inputs1==NULL){
472    r_inputs1=createMap("metapath","");
473    hasIn=1;
474  }
475  map* r_inputs2=getMap(request_inputs,"ResponseDocument");
476  if(r_inputs2==NULL)
477    r_inputs2=getMap(request_inputs,"RawDataOutput");
478  map *tmpPath=getMapFromMaps(m,"lenv","cwd");
479
480  if(r_inputs2!=NULL){
481    sprintf(tmp,"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s&cgiSid=%s\"",r_inputs1->value,req->value,id->value,dataInputsKVP,r_inputs2->name,dataOutputsKVP,sid->value);
482    sprintf(tmpq,"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&%s=%s",r_inputs1->value,req->value,id->value,dataInputsKVP,r_inputs2->name,dataOutputsKVP);
483    }
484  else{
485    sprintf(tmp,"\"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s&cgiSid=%s\"",r_inputs1->value,req->value,id->value,dataInputsKVP,sid->value);
486    sprintf(tmpq,"metapath=%s&request=%s&service=WPS&version=1.0.0&Identifier=%s&DataInputs=%s",r_inputs1->value,req->value,id->value,dataInputsKVP,sid->value);
487  }
488 
489  if(hasIn>0){
490    freeMap(&r_inputs1);
491    free(r_inputs1);
492  }
493  char *tmp1=zStrdup(tmp);
494  sprintf(tmp,"zoo_loader.cgi %s \"%s\"",tmp1,sid->value);
495 
496  free(dataInputsKVP);
497  free(dataOutputsKVP);
498#ifdef DEBUG
499  fprintf(stderr,"REQUEST IS : %s \n",tmp);
500#endif
501  SetEnvironmentVariable("CGISID",TEXT(sid->value));
502  SetEnvironmentVariable("QUERY_STRING",TEXT(tmpq));
503  char clen[1000];
504  sprintf(clen,"%d",strlen(tmpq));
505  SetEnvironmentVariable("CONTENT_LENGTH",TEXT(clen));
506
507  if( !CreateProcess( NULL,             // No module name (use command line)
508                      TEXT(tmp),        // Command line
509                      NULL,             // Process handle not inheritable
510                      NULL,             // Thread handle not inheritable
511                      FALSE,            // Set handle inheritance to FALSE
512                      CREATE_NO_WINDOW, // Apache won't wait until the end
513                      NULL,             // Use parent's environment block
514                      NULL,             // Use parent's starting directory
515                      &si,              // Pointer to STARTUPINFO struct
516                      &pi )             // Pointer to PROCESS_INFORMATION struct
517      ) 
518    { 
519      //printf("CreateProcess failed (%d).\n",GetLastError() );
520#ifdef DEBUG
521      fprintf( stderr, "CreateProcess failed (%d).\n", GetLastError() );
522#endif
523      return ;
524    }else{
525    //printf("CreateProcess successfull (%d).\n",GetLastError() );
526#ifdef DEBUG
527    fprintf( stderr, "CreateProcess successfull (%d).\n\n\n\n", GetLastError() );
528#endif
529  }
530  CloseHandle( pi.hProcess );
531  CloseHandle( pi.hThread );
532  //printf("CreateProcess finished !\n");
533#ifdef DEBUG
534  fprintf(stderr,"CreateProcess finished !\n");
535#endif
536}
537#endif
538
539int runRequest(map* request_inputs)
540{
541
542#ifndef USE_GDB
543  (void) signal(SIGSEGV,sig_handler);
544  (void) signal(SIGTERM,sig_handler);
545  (void) signal(SIGINT,sig_handler);
546  (void) signal(SIGILL,sig_handler);
547  (void) signal(SIGFPE,sig_handler);
548  (void) signal(SIGABRT,sig_handler);
549#endif
550
551  map* r_inputs=NULL;
552  maps* m=NULL;
553
554  char* REQUEST=NULL;
555  /**
556   * Parsing service specfic configuration file
557   */
558  m=(maps*)malloc(MAPS_SIZE);
559  if(m == NULL){
560    return errorException(m, _("Unable to allocate memory."), "InternalError");
561  }
562  char ntmp[1024];
563#ifndef WIN32
564  char *pntmp=getcwd(ntmp,1024);
565#else
566  _getcwd(ntmp,1024);
567#endif
568  r_inputs=getMapOrFill(request_inputs,"metapath","");
569
570
571  char conf_file[10240];
572  snprintf(conf_file,10240,"%s/%s/main.cfg",ntmp,r_inputs->value);
573  if(conf_read(conf_file,m)==2){
574    errorException(NULL, _("Unable to load the main.cfg file."),"InternalError");
575    free(m);
576    return 1;
577  }
578#ifdef DEBUG
579  fprintf(stderr, "***** BEGIN MAPS\n"); 
580  dumpMaps(m);
581  fprintf(stderr, "***** END MAPS\n");
582#endif
583
584  map *getPath=getMapFromMaps(m,"main","gettextPath");
585  if(getPath!=NULL){
586    bindtextdomain ("zoo-kernel",getPath->value);
587    bindtextdomain ("zoo-services",getPath->value);   
588  }else{
589    bindtextdomain ("zoo-kernel","/usr/share/locale/");
590    bindtextdomain ("zoo-services","/usr/share/locale/");
591  }
592
593
594  /**
595   * Manage our own error log file (usefull to separate standard apache debug
596   * messages from the ZOO-Kernel ones but also for IIS users to avoid wrong
597   * headers messages returned by the CGI due to wrong redirection of stderr)
598   */
599  FILE * fstde=NULL;
600  map* fstdem=getMapFromMaps(m,"main","logPath");
601  if(fstdem!=NULL)
602        fstde = freopen(fstdem->value, "a+", stderr) ;
603
604  r_inputs=getMap(request_inputs,"language");
605  if(r_inputs==NULL)
606    r_inputs=getMapFromMaps(m,"main","language");
607  if(r_inputs!=NULL){
608    char *tmp=zStrdup(r_inputs->value);
609    setMapInMaps(m,"main","language",tmp);
610    translateChar(tmp,'-','_');
611    setlocale (LC_ALL, tmp);
612#ifndef WIN32
613    setenv("LC_ALL",tmp,1);
614#else
615    char tmp1[12];
616    sprintf(tmp1,"LC_ALL=%s",tmp);
617    putenv(tmp1);
618#endif
619    free(tmp);
620  }
621  else{
622    setlocale (LC_ALL, "en_US");
623#ifndef WIN32
624    setenv("LC_ALL","en_US",1);
625#else
626    char tmp1[12];
627    sprintf(tmp1,"LC_ALL=en_US");
628    putenv(tmp1);
629#endif
630    setMapInMaps(m,"main","language","en-US");
631  }
632  setlocale (LC_NUMERIC, "en_US");
633  bind_textdomain_codeset("zoo-kernel","UTF-8");
634  textdomain("zoo-kernel");
635  bind_textdomain_codeset("zoo-services","UTF-8");
636  textdomain("zoo-services");
637
638  map* lsoap=getMap(request_inputs,"soap");
639  if(lsoap!=NULL && strcasecmp(lsoap->value,"true")==0)
640    setMapInMaps(m,"main","isSoap","true");
641  else
642    setMapInMaps(m,"main","isSoap","false");
643
644  if(strlen(cgiServerName)>0){
645    char tmpUrl[1024];
646    sprintf(tmpUrl,"http://%s%s",cgiServerName,cgiScriptName);
647#ifdef DEBUG
648    fprintf(stderr,"*** %s ***\n",tmpUrl);
649#endif
650    setMapInMaps(m,"main","serverAddress",tmpUrl);
651  }
652
653  /**
654   * Check for minimum inputs
655   */
656  r_inputs=getMap(request_inputs,"Request");
657  if(request_inputs==NULL || r_inputs==NULL){ 
658    errorException(m, _("Parameter <request> was not specified"),"MissingParameterValue");
659    freeMaps(&m);
660    free(m);
661    return 1;
662  }
663  else{
664    REQUEST=zStrdup(r_inputs->value);
665    if(strncasecmp(r_inputs->value,"GetCapabilities",15)!=0
666       && strncasecmp(r_inputs->value,"DescribeProcess",15)!=0
667       && strncasecmp(r_inputs->value,"Execute",7)!=0){ 
668      errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
669      freeMaps(&m);
670      free(m);
671      free(REQUEST);
672      return 1;
673    }
674  }
675  r_inputs=NULL;
676  r_inputs=getMap(request_inputs,"Service");
677  if(r_inputs==NULLMAP){
678    errorException(m, _("Parameter <service> was not specified"),"MissingParameterValue");
679    freeMaps(&m);
680    free(m);
681    free(REQUEST);
682    return 1;
683  }
684  if(strncasecmp(REQUEST,"GetCapabilities",15)!=0){
685    r_inputs=getMap(request_inputs,"Version");
686    if(r_inputs==NULL){ 
687      errorException(m, _("Parameter <version> was not specified"),"MissingParameterValue");
688      freeMaps(&m);
689      free(m);
690      free(REQUEST);
691      return 1;
692    }
693  }
694
695  r_inputs=getMap(request_inputs,"serviceprovider");
696  if(r_inputs==NULL){
697    addToMap(request_inputs,"serviceprovider","");
698  }
699
700  maps* request_output_real_format=NULL;
701  map* tmpm=getMapFromMaps(m,"main","serverAddress");
702  if(tmpm!=NULL)
703    SERVICE_URL=zStrdup(tmpm->value);
704  else
705    SERVICE_URL=zStrdup(DEFAULT_SERVICE_URL);
706
707  service* s1;
708  int scount=0;
709#ifdef DEBUG
710  dumpMap(r_inputs);
711#endif
712  char conf_dir[1024];
713  int t;
714  char tmps1[1024];
715
716  r_inputs=NULL;
717  r_inputs=getMap(request_inputs,"metapath");
718  if(r_inputs!=NULL)
719    snprintf(conf_dir,1024,"%s/%s",ntmp,r_inputs->value);
720  else
721    snprintf(conf_dir,1024,"%s",ntmp);
722
723  if(strncasecmp(REQUEST,"GetCapabilities",15)==0){
724    struct dirent *dp;
725#ifdef DEBUG
726    dumpMap(r_inputs);
727#endif
728    DIR *dirp = opendir(conf_dir);
729    if(dirp==NULL){
730      return errorException(m, _("The specified path doesn't exist."),"InvalidParameterValue");
731    }
732    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
733    r_inputs=NULL;
734    r_inputs=getMap(request_inputs,"ServiceProvider");
735    xmlNodePtr n;
736    if(r_inputs!=NULL)
737      n = printGetCapabilitiesHeader(doc,r_inputs->value,m);
738    else
739      n = printGetCapabilitiesHeader(doc,"",m);
740    /**
741     * Here we need to close stdout to ensure that not supported chars
742     * has been found in the zcfg and then printed on stdout
743     */
744    int saved_stdout = dup(fileno(stdout));
745    dup2(fileno(stderr),fileno(stdout));
746    while ((dp = readdir(dirp)) != NULL)
747      if(strstr(dp->d_name,".zcfg")!=0){
748        memset(tmps1,0,1024);
749        snprintf(tmps1,1024,"%s/%s",conf_dir,dp->d_name);
750        s1=(service*)malloc(SERVICE_SIZE);
751        if(s1 == NULL){ 
752          return errorException(m, _("Unable to allocate memory."),"InternalError");
753        }
754#ifdef DEBUG
755        fprintf(stderr,"#################\n%s\n#################\n",tmps1);
756#endif
757        t=getServiceFromFile(tmps1,&s1);
758#ifdef DEBUG
759        dumpService(s1);
760        fflush(stdout);
761        fflush(stderr);
762#endif
763        printGetCapabilitiesForProcess(m,n,s1);
764        freeService(&s1);
765        free(s1);
766        scount++;
767      }
768    (void)closedir(dirp);
769    fflush(stdout);
770    dup2(saved_stdout,fileno(stdout));
771    printDocument(m,doc,getpid());
772    freeMaps(&m);
773    free(m);
774    free(REQUEST);
775    free(SERVICE_URL);
776    fflush(stdout);
777    return 0;
778  }
779  else{
780    r_inputs=getMap(request_inputs,"Identifier");
781    if(r_inputs==NULL 
782       || strlen(r_inputs->name)==0 || strlen(r_inputs->value)==0){ 
783      errorException(m, _("Mandatory <identifier> was not specified"),"MissingParameterValue");
784      freeMaps(&m);
785      free(m);
786      free(REQUEST);
787      free(SERVICE_URL);
788      return 0;
789    }
790
791    struct dirent *dp;
792    DIR *dirp = opendir(conf_dir);
793    if(dirp==NULL){
794      errorException(m, _("The specified path path doesn't exist."),"InvalidParameterValue");
795      freeMaps(&m);
796      free(m);
797      free(REQUEST);
798      free(SERVICE_URL);
799      return 0;
800    }
801    if(strncasecmp(REQUEST,"DescribeProcess",15)==0){
802      /**
803       * Loop over Identifier list
804       */
805      xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
806      r_inputs=NULL;
807      r_inputs=getMap(request_inputs,"ServiceProvider");
808
809      xmlNodePtr n;
810      if(r_inputs!=NULL)
811        n = printDescribeProcessHeader(doc,r_inputs->value,m);
812      else
813        n = printDescribeProcessHeader(doc,"",m);
814
815      r_inputs=getMap(request_inputs,"Identifier");
816      char *tmps=strtok(r_inputs->value,",");
817     
818      char buff[256];
819      char buff1[1024];
820      int saved_stdout = dup(fileno(stdout));
821      dup2(fileno(stderr),fileno(stdout));
822      while(tmps){
823        memset(buff,0,256);
824        snprintf(buff,256,"%s.zcfg",tmps);
825        memset(buff1,0,1024);
826#ifdef DEBUG
827        printf("\n#######%s\n########\n",buff1);
828#endif
829        while ((dp = readdir(dirp)) != NULL)
830          if((strcasecmp("all.zcfg",buff)==0 && strstr(dp->d_name,".zcfg")>0)
831             || strcasecmp(dp->d_name,buff)==0){
832            memset(buff1,0,1024);
833            snprintf(buff1,1024,"%s/%s",conf_dir,dp->d_name);
834            s1=(service*)malloc(SERVICE_SIZE);
835            if(s1 == NULL){
836              dup2(saved_stdout,fileno(stdout));
837              return errorException(m, _("Unable to allocate memory."),"InternalError");
838            }
839#ifdef DEBUG
840            printf("#################\n%s\n#################\n",buff1);
841#endif
842            t=getServiceFromFile(buff1,&s1);
843#ifdef DEBUG
844            dumpService(s1);
845#endif
846            printDescribeProcessForProcess(m,n,s1,1);
847            freeService(&s1);
848            free(s1);
849            scount++;
850          }
851        rewinddir(dirp);
852        tmps=strtok(NULL,",");
853      }
854      closedir(dirp);
855      fflush(stdout);
856      dup2(saved_stdout,fileno(stdout));
857      printDocument(m,doc,getpid());
858      freeMaps(&m);
859      free(m);
860      free(REQUEST);
861      free(SERVICE_URL);
862      fflush(stdout);
863      return 0;
864    }
865    else
866      if(strncasecmp(REQUEST,"Execute",strlen(REQUEST))!=0){
867        errorException(m, _("Unenderstood <request> value. Please check that it was set to GetCapabilities, DescribeProcess or Execute."), "InvalidParameterValue");
868#ifdef DEBUG
869        fprintf(stderr,"No request found %s",REQUEST);
870#endif 
871        closedir(dirp);
872        freeMaps(&m);
873        free(m);
874        free(REQUEST);
875        free(SERVICE_URL);
876        fflush(stdout);
877        return 0;
878      }
879    closedir(dirp);
880  }
881 
882  s1=NULL;
883  s1=(service*)malloc(SERVICE_SIZE);
884  if(s1 == NULL){
885    freeMaps(&m);
886    free(m);
887    free(REQUEST);
888    free(SERVICE_URL);
889    return errorException(m, _("Unable to allocate memory."),"InternalError");
890  }
891  r_inputs=getMap(request_inputs,"MetaPath");
892  if(r_inputs!=NULL)
893    snprintf(tmps1,1024,"%s/%s",ntmp,r_inputs->value);
894  else
895    snprintf(tmps1,1024,"%s/",ntmp);
896  r_inputs=getMap(request_inputs,"Identifier");
897  char *ttmp=zStrdup(tmps1);
898  snprintf(tmps1,1024,"%s/%s.zcfg",ttmp,r_inputs->value);
899  free(ttmp);
900#ifdef DEBUG
901  fprintf(stderr,"Trying to load %s\n", tmps1);
902#endif
903  int saved_stdout = dup(fileno(stdout));
904  dup2(fileno(stderr),fileno(stdout));
905  t=getServiceFromFile(tmps1,&s1);
906  fflush(stdout);
907  dup2(saved_stdout,fileno(stdout));
908  if(t<0){
909    char *tmpMsg=(char*)malloc(2048+strlen(r_inputs->value));
910   
911    sprintf(tmpMsg,_("The value for <indetifier> seems to be wrong (%s). Please, ensure that the process exist using the GetCapabilities request."),r_inputs->value);
912    errorException(m, tmpMsg, "InvalidParameterValue");
913    free(tmpMsg);
914    free(s1);
915    freeMaps(&m);
916    free(m);
917    free(REQUEST);
918    free(SERVICE_URL);
919    return 0;
920  }
921  close(saved_stdout);
922
923#ifdef DEBUG
924  dumpService(s1);
925#endif
926  int j;
927 
928
929  /**
930   * Create the input and output maps data structure
931   */
932  int i=0;
933  HINTERNET hInternet;
934  HINTERNET res;
935  hInternet=InternetOpen(
936#ifndef WIN32
937                         (LPCTSTR)
938#endif
939                         "ZooWPSClient\0",
940                         INTERNET_OPEN_TYPE_PRECONFIG,
941                         NULL,NULL, 0);
942
943#ifndef WIN32
944  if(!CHECK_INET_HANDLE(hInternet))
945    fprintf(stderr,"WARNING : hInternet handle failed to initialize");
946#endif
947  maps* request_input_real_format=NULL;
948  maps* tmpmaps = request_input_real_format;
949  map* postRequest=NULL;
950  postRequest=getMap(request_inputs,"xrequest");
951  if(postRequest==NULLMAP){
952    /**
953     * Parsing outputs provided as KVP
954     */
955    r_inputs=NULL;
956#ifdef DEBUG
957    fprintf(stderr,"OUTPUT Parsing ... \n");
958#endif
959    r_inputs=getMap(request_inputs,"ResponseDocument"); 
960    if(r_inputs==NULL) r_inputs=getMap(request_inputs,"RawDataOutput");
961   
962#ifdef DEBUG
963    fprintf(stderr,"OUTPUT Parsing ... \n");
964#endif
965    if(r_inputs!=NULL){
966#ifdef DEBUG
967      fprintf(stderr,"OUTPUT Parsing start now ... \n");
968#endif
969      char cursor_output[10240];
970      char *cotmp=zStrdup(r_inputs->value);
971      snprintf(cursor_output,10240,"%s",cotmp);
972      free(cotmp);
973      j=0;
974       
975      /**
976       * Put each Output into the outputs_as_text array
977       */
978      char * pToken;
979      maps* tmp_output=NULL;
980#ifdef DEBUG
981      fprintf(stderr,"OUTPUT [%s]\n",cursor_output);
982#endif
983      pToken=strtok(cursor_output,";");
984      char** outputs_as_text=(char**)malloc(128*sizeof(char*));
985      if(outputs_as_text == NULL) {
986        return errorException(m, _("Unable to allocate memory"), "InternalError");
987      }
988      i=0;
989      while(pToken!=NULL){
990#ifdef DEBUG
991        fprintf(stderr,"***%s***\n",pToken);
992        fflush(stderr);
993        fprintf(stderr,"***%s***\n",pToken);
994#endif
995        outputs_as_text[i]=(char*)malloc((strlen(pToken)+1)*sizeof(char));
996        if(outputs_as_text[i] == NULL) {
997          return errorException(m, _("Unable to allocate memory"), "InternalError");
998        }
999        snprintf(outputs_as_text[i],strlen(pToken)+1,"%s",pToken);
1000        pToken = strtok(NULL,";");
1001        i++;
1002      }
1003      for(j=0;j<i;j++){
1004        char *tmp=zStrdup(outputs_as_text[j]);
1005        free(outputs_as_text[j]);
1006        char *tmpc;
1007        tmpc=strtok(tmp,"@");
1008        int k=0;
1009        while(tmpc!=NULL){
1010          if(k==0){
1011            if(tmp_output==NULL){
1012              tmp_output=(maps*)malloc(MAPS_SIZE);
1013              if(tmp_output == NULL){
1014                return errorException(m, _("Unable to allocate memory."), "InternalError");
1015              }
1016              tmp_output->name=zStrdup(tmpc);
1017              tmp_output->content=NULL;
1018              tmp_output->next=NULL;
1019            }
1020          }
1021          else{
1022            char *tmpv=strstr(tmpc,"=");
1023            char tmpn[256];
1024            memset(tmpn,0,256);
1025            strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
1026            tmpn[strlen(tmpc)-strlen(tmpv)]=0;
1027#ifdef DEBUG
1028            fprintf(stderr,"OUTPUT DEF [%s]=[%s]\n",tmpn,tmpv+1);
1029#endif
1030            if(tmp_output->content==NULL){
1031              tmp_output->content=createMap(tmpn,tmpv+1);
1032              tmp_output->content->next=NULL;
1033            }
1034            else
1035              addToMap(tmp_output->content,tmpn,tmpv+1);
1036          }
1037          k++;
1038#ifdef DEBUG
1039          fprintf(stderr,"***%s***\n",tmpc);
1040#endif
1041          tmpc=strtok(NULL,"@");
1042        }
1043        if(request_output_real_format==NULL)
1044          request_output_real_format=dupMaps(&tmp_output);
1045        else
1046          addMapsToMaps(&request_output_real_format,tmp_output);
1047        freeMaps(&tmp_output);
1048        free(tmp_output);
1049        tmp_output=NULL;
1050#ifdef DEBUG
1051        dumpMaps(tmp_output);
1052        fflush(stderr);
1053#endif
1054        free(tmp);
1055      }
1056      free(outputs_as_text);
1057    }
1058
1059
1060    /**
1061     * Parsing inputs provided as KVP
1062     */
1063    r_inputs=getMap(request_inputs,"DataInputs");
1064#ifdef DEBUG
1065    fprintf(stderr,"DATA INPUTS [%s]\n",r_inputs->value);
1066#endif
1067    char cursor_input[40960];
1068    if(r_inputs!=NULL)
1069      snprintf(cursor_input,40960,"%s",r_inputs->value);
1070    else{
1071      errorException(m, _("Parameter <DataInputs> was not specified"),"MissingParameterValue");
1072      freeMaps(&m);
1073      free(m);
1074      free(REQUEST);
1075      free(SERVICE_URL);
1076      InternetCloseHandle(hInternet);
1077      freeService(&s1);
1078      free(s1);
1079      return 0;
1080    }
1081    j=0;
1082 
1083    /**
1084     * Put each DataInputs into the inputs_as_text array
1085     */
1086    char *tmp1=zStrdup(cursor_input);
1087    char * pToken;
1088    pToken=strtok(cursor_input,";");
1089    if(pToken!=NULL && strncasecmp(pToken,tmp1,strlen(tmp1))==0){
1090      char* tmp2=url_decode(tmp1);
1091      snprintf(cursor_input,(strlen(tmp2)+1)*sizeof(char),"%s",tmp2);
1092      free(tmp2);
1093      pToken=strtok(cursor_input,";");
1094    }
1095    free(tmp1);
1096
1097    char** inputs_as_text=(char**)malloc(100*sizeof(char*));
1098    if(inputs_as_text == NULL){
1099      return errorException(m, _("Unable to allocate memory."), "InternalError");
1100    }
1101    i=0;
1102    while(pToken!=NULL){
1103#ifdef DEBUG
1104      fprintf(stderr,"***%s***\n",pToken);
1105#endif
1106      fflush(stderr);
1107#ifdef DEBUG
1108      fprintf(stderr,"***%s***\n",pToken);
1109#endif
1110      inputs_as_text[i]=(char*)malloc((strlen(pToken)+1)*sizeof(char));
1111      snprintf(inputs_as_text[i],strlen(pToken)+1,"%s",pToken);
1112      if(inputs_as_text[i] == NULL){
1113        return errorException(m, _("Unable to allocate memory."), "InternalError");
1114      }
1115      pToken = strtok(NULL,";");
1116      i++;
1117    }
1118
1119    for(j=0;j<i;j++){
1120      char *tmp=zStrdup(inputs_as_text[j]);
1121      free(inputs_as_text[j]);
1122      char *tmpc;
1123      tmpc=strtok(tmp,"@");
1124      while(tmpc!=NULL){
1125#ifdef DEBUG
1126        fprintf(stderr,"***\n***%s***\n",tmpc);
1127#endif
1128        char *tmpv=strstr(tmpc,"=");
1129        char tmpn[256];
1130        memset(tmpn,0,256);
1131        if(tmpv!=NULL){
1132          strncpy(tmpn,tmpc,(strlen(tmpc)-strlen(tmpv))*sizeof(char));
1133          tmpn[strlen(tmpc)-strlen(tmpv)]=0;
1134        }
1135        else{
1136          strncpy(tmpn,tmpc,strlen(tmpc)*sizeof(char));
1137          tmpn[strlen(tmpc)]=0;
1138        }
1139#ifdef DEBUG
1140        fprintf(stderr,"***\n*** %s = %s ***\n",tmpn,tmpv+1);
1141#endif
1142        if(tmpmaps==NULL){
1143          tmpmaps=(maps*)malloc(MAPS_SIZE);
1144          if(tmpmaps == NULL){
1145            return errorException(m, _("Unable to allocate memory."), "InternalError");
1146          }
1147          tmpmaps->name=zStrdup(tmpn);
1148          if(tmpv!=NULL){
1149            char *tmpvf=url_decode(tmpv+1);
1150            tmpmaps->content=createMap("value",tmpvf);
1151            free(tmpvf);
1152          }
1153          else
1154            tmpmaps->content=createMap("value","Reference");
1155          tmpmaps->next=NULL;
1156        }
1157        tmpc=strtok(NULL,"@");
1158        while(tmpc!=NULL){
1159#ifdef DEBUG
1160          fprintf(stderr,"*** KVP NON URL-ENCODED \n***%s***\n",tmpc);
1161#endif
1162          char *tmpv1=strstr(tmpc,"=");
1163#ifdef DEBUG
1164          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
1165#endif
1166          char tmpn1[1024];
1167          memset(tmpn1,0,1024);
1168          if(tmpv1!=NULL){
1169            strncpy(tmpn1,tmpc,strlen(tmpc)-strlen(tmpv1));
1170            tmpn1[strlen(tmpc)-strlen(tmpv1)]=0;
1171            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1172          }
1173          else{
1174            strncpy(tmpn1,tmpc,strlen(tmpc));
1175            tmpn1[strlen(tmpc)]=0;
1176            map* lmap=getLastMap(tmpmaps->content);
1177            char *tmpValue=(char*)malloc((strlen(tmpv)+strlen(tmpc)+1)*sizeof(char));
1178            sprintf(tmpValue,"%s@%s",tmpv+1,tmpc);
1179            free(lmap->value);
1180            lmap->value=zStrdup(tmpValue);
1181            free(tmpValue);
1182            tmpc=strtok(NULL,"@");
1183            continue;
1184          }
1185#ifdef DEBUG
1186          fprintf(stderr,"*** NAME NON URL-ENCODED \n***%s***\n",tmpn1);
1187          fprintf(stderr,"*** VALUE NON URL-ENCODED \n***%s***\n",tmpv1+1);
1188#endif
1189          if(strcmp(tmpn1,"xlink:href")!=0)
1190            addToMap(tmpmaps->content,tmpn1,tmpv1+1);
1191          else
1192            if(tmpv1!=NULL){
1193              char *tmpx2=url_decode(tmpv1+1);
1194              if(strncasecmp(tmpx2,"http://",7)!=0 &&
1195                 strncasecmp(tmpx2,"ftp://",6)!=0 &&
1196                 strncasecmp(tmpx2,"https://",8)!=0){
1197                char emsg[1024];
1198                sprintf(emsg,_("Unable to find a valid protocol to download the remote file %s"),tmpv1+1);
1199                errorException(m,emsg,"InternalError");
1200                freeMaps(&m);
1201                free(m);
1202                free(REQUEST);
1203                free(SERVICE_URL);
1204                InternetCloseHandle(hInternet);
1205                freeService(&s1);
1206                free(s1);
1207                return 0;
1208              }
1209#ifdef DEBUG
1210              fprintf(stderr,"REQUIRE TO DOWNLOAD A FILE FROM A SERVER : url(%s)\n",tmpv1+1);
1211#endif
1212              addToMap(tmpmaps->content,tmpn1,tmpx2);
1213             
1214#ifndef WIN32
1215              if(CHECK_INET_HANDLE(hInternet))
1216#endif
1217                {
1218                  if(loadRemoteFile(m,tmpmaps->content,hInternet,tmpx2)<0){
1219                    freeMaps(&m);
1220                    free(m);
1221                    free(REQUEST);
1222                    free(SERVICE_URL);
1223                    InternetCloseHandle(hInternet);
1224                    freeService(&s1);
1225                    free(s1);
1226                    return 0;
1227                  }
1228                }
1229              free(tmpx2);
1230              addToMap(tmpmaps->content,"Reference",tmpv1+1);
1231            }
1232          tmpc=strtok(NULL,"@");
1233        }
1234#ifdef DEBUG
1235        dumpMaps(tmpmaps);
1236        fflush(stderr);
1237#endif
1238        if(request_input_real_format==NULL)
1239          request_input_real_format=dupMaps(&tmpmaps);
1240        else{
1241          maps* testPresence=getMaps(request_input_real_format,tmpmaps->name);
1242          if(testPresence!=NULL){
1243            elements* elem=getElements(s1->inputs,tmpmaps->name);
1244            if(elem!=NULL){
1245              if(appendMapsToMaps(m,request_input_real_format,tmpmaps,elem)<0){
1246                freeMaps(&m);
1247                free(m);
1248                free(REQUEST);
1249                free(SERVICE_URL);
1250                InternetCloseHandle(hInternet);
1251                freeService(&s1);
1252                free(s1);
1253                return 0;
1254              }
1255            }
1256          }
1257          else
1258            addMapsToMaps(&request_input_real_format,tmpmaps);
1259        }
1260        freeMaps(&tmpmaps);
1261        free(tmpmaps);
1262        tmpmaps=NULL;
1263        free(tmp);
1264      }
1265    }
1266    free(inputs_as_text);
1267  }
1268  else {
1269    /**
1270     * Parse XML request
1271     */ 
1272    xmlInitParser();
1273#ifdef DEBUG
1274    fflush(stderr);
1275    fprintf(stderr,"BEFORE %s\n",postRequest->value);
1276    fflush(stderr);
1277#endif
1278    xmlDocPtr doc =
1279      xmlParseMemory(postRequest->value,cgiContentLength);
1280#ifdef DEBUG
1281    fprintf(stderr,"AFTER\n");
1282    fflush(stderr);
1283#endif
1284    /**
1285     * Parse every Input in DataInputs node.
1286     */
1287    xmlXPathObjectPtr tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='Input']");
1288    xmlNodeSet* tmps=tmpsptr->nodesetval;
1289#ifdef DEBUG
1290    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1291#endif
1292    for(int k=0;k<tmps->nodeNr;k++){
1293      maps *tmpmaps=NULL;
1294      xmlNodePtr cur=tmps->nodeTab[k];
1295      if(tmps->nodeTab[k]->type == XML_ELEMENT_NODE) {
1296        /**
1297         * A specific Input node.
1298         */
1299#ifdef DEBUG
1300        fprintf(stderr, "= element 0 node \"%s\"\n", cur->name);
1301#endif
1302        xmlNodePtr cur2=cur->children;
1303        while(cur2!=NULL){
1304          while(cur2!=NULL && cur2->type!=XML_ELEMENT_NODE)
1305            cur2=cur2->next;
1306          if(cur2==NULL)
1307            break;
1308          /**
1309           * Indentifier
1310           */
1311          if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1312            xmlChar *val= xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1313            if(tmpmaps==NULL){
1314              tmpmaps=(maps*)malloc(MAPS_SIZE);
1315              if(tmpmaps == NULL){
1316                return errorException(m, _("Unable to allocate memory."), "InternalError");
1317              }
1318              tmpmaps->name=zStrdup((char*)val);
1319              tmpmaps->content=NULL;
1320              tmpmaps->next=NULL;
1321            }
1322            xmlFree(val);
1323          }
1324          /**
1325           * Title, Asbtract
1326           */
1327          if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1328             xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1329            xmlChar *val=
1330              xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1331            if(tmpmaps==NULL){
1332              tmpmaps=(maps*)malloc(MAPS_SIZE);
1333              if(tmpmaps == NULL){
1334                return errorException(m, _("Unable to allocate memory."), "InternalError");
1335              }
1336              tmpmaps->name=zStrdup("missingIndetifier");
1337              tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1338              tmpmaps->next=NULL;
1339            }
1340            else{
1341              if(tmpmaps->content!=NULL)
1342                addToMap(tmpmaps->content,
1343                         (char*)cur2->name,(char*)val);
1344              else
1345                tmpmaps->content=
1346                  createMap((char*)cur2->name,(char*)val);
1347            }
1348#ifdef DEBUG
1349            dumpMaps(tmpmaps);
1350#endif
1351            xmlFree(val);
1352          }
1353          /**
1354           * InputDataFormChoice (Reference or Data ?)
1355           */
1356          if(xmlStrcasecmp(cur2->name,BAD_CAST "Reference")==0){
1357            /**
1358             * Get every attribute from a Reference node
1359             * mimeType, encoding, schema, href, method
1360             * Header and Body gesture should be added here
1361             */
1362#ifdef DEBUG
1363            fprintf(stderr,"REFERENCE\n");
1364#endif
1365            const char *refs[5]={"mimeType","encoding","schema","method","href"};
1366            for(int l=0;l<5;l++){
1367#ifdef DEBUG
1368              fprintf(stderr,"*** %s ***",refs[l]);
1369#endif
1370              xmlChar *val=xmlGetProp(cur2,BAD_CAST refs[l]);
1371              if(val!=NULL && xmlStrlen(val)>0){
1372                if(tmpmaps->content!=NULL)
1373                  addToMap(tmpmaps->content,refs[l],(char*)val);
1374                else
1375                  tmpmaps->content=createMap(refs[l],(char*)val);
1376                map* ltmp=getMap(tmpmaps->content,"method");
1377                if(l==4){
1378                  if(!(ltmp!=NULL && strncmp(ltmp->value,"POST",4)==0)
1379                     && CHECK_INET_HANDLE(hInternet)){
1380                    if(loadRemoteFile(m,tmpmaps->content,hInternet,(char*)val)!=0){
1381                      freeMaps(&m);
1382                      free(m);
1383                      free(REQUEST);
1384                      free(SERVICE_URL);
1385                      InternetCloseHandle(hInternet);
1386                      freeService(&s1);
1387                      free(s1);
1388                      return 0;
1389                    }
1390                  }
1391                }
1392              }
1393#ifdef DEBUG
1394              fprintf(stderr,"%s\n",val);
1395#endif
1396              xmlFree(val);
1397            }
1398#ifdef POST_DEBUG
1399            fprintf(stderr,"Parse Header and Body from Reference \n");
1400#endif
1401            xmlNodePtr cur3=cur2->children;
1402            HINTERNET hInternetP;
1403            hInternetP=InternetOpen(
1404#ifndef WIN32
1405                                   (LPCTSTR)
1406#endif
1407                                   "ZooWPSClient\0",
1408                                   INTERNET_OPEN_TYPE_PRECONFIG,
1409                                   NULL,NULL, 0);
1410            hInternetP.header=NULL;
1411            while(cur3){
1412              while(cur3!=NULL && cur3->type!=XML_ELEMENT_NODE)
1413                cur2=cur3->next;
1414              if(xmlStrcasecmp(cur3->name,BAD_CAST "Header")==0 ){
1415                const char *ha[2];
1416                ha[0]="key";
1417                ha[1]="value";
1418                int hai;
1419                char *has;
1420                char *key;
1421                for(hai=0;hai<2;hai++){
1422                  xmlChar *val=xmlGetProp(cur3,BAD_CAST ha[hai]);
1423#ifdef POST_DEBUG
1424                  fprintf(stderr,"%s = %s\n",ha[hai],(char*)val);
1425#endif
1426                  if(hai==0){
1427                    key=(char*)malloc((1+strlen((char*)val))*sizeof(char));
1428                    snprintf(key,1+strlen((char*)val),"%s",(char*)val);
1429                  }else{
1430                    has=(char*)malloc((3+strlen((char*)val)+strlen(key))*sizeof(char));
1431                    if(has == NULL){
1432                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1433                    }
1434                    snprintf(has,(3+strlen((char*)val)+strlen(key)),"%s: %s",key,(char*)val);
1435#ifdef POST_DEBUG
1436                    fprintf(stderr,"%s\n",has);
1437#endif
1438                  }
1439                }
1440                hInternetP.header=curl_slist_append(hInternetP.header, has);
1441                if(has!=NULL)
1442                  free(has);
1443              }
1444              else{
1445#ifdef POST_DEBUG
1446                fprintf(stderr,"Try to fetch the body part of the request ...\n");
1447#endif
1448                if(xmlStrcasecmp(cur3->name,BAD_CAST "Body")==0 ){
1449#ifdef POST_DEBUG
1450                  fprintf(stderr,"Body part found !!!\n",(char*)cur3->content);
1451#endif
1452                  char *tmp=new char[cgiContentLength];
1453                  memset(tmp,0,cgiContentLength);
1454                  xmlNodePtr cur4=cur3->children;
1455                  while(cur4!=NULL){
1456                    while(cur4->type!=XML_ELEMENT_NODE)
1457                      cur4=cur4->next;
1458                    xmlDocPtr bdoc = xmlNewDoc(BAD_CAST "1.0");
1459                    bdoc->encoding = xmlCharStrdup ("UTF-8");
1460                    xmlDocSetRootElement(bdoc,cur4);
1461                    xmlChar* btmps;
1462                    int bsize;
1463                    xmlDocDumpMemory(bdoc,&btmps,&bsize);
1464#ifdef POST_DEBUG
1465                    fprintf(stderr,"Body part found !!! %s %s\n",tmp,(char*)btmps);
1466#endif
1467                    if(btmps!=NULL)
1468                      sprintf(tmp,"%s",(char*)btmps);
1469                    xmlFreeDoc(bdoc);
1470                    cur4=cur4->next;
1471                  }
1472                  map *btmp=getMap(tmpmaps->content,"href");
1473                  if(btmp!=NULL){
1474#ifdef POST_DEBUG
1475                    fprintf(stderr,"%s %s\n",btmp->value,tmp);
1476                    curl_easy_setopt(hInternetP.handle, CURLOPT_VERBOSE, 1);
1477#endif
1478                    res=InternetOpenUrl(hInternetP,btmp->value,tmp,strlen(tmp),
1479                                        INTERNET_FLAG_NO_CACHE_WRITE,0);
1480                    char* tmpContent = (char*)malloc((res.nDataLen+1)*sizeof(char));
1481                    if(tmpContent == NULL){
1482                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1483                    }
1484                    size_t dwRead;
1485                    InternetReadFile(res, (LPVOID)tmpContent,
1486                                     res.nDataLen, &dwRead);
1487                    tmpContent[res.nDataLen]=0;
1488                    if(hInternetP.header!=NULL)
1489                      curl_slist_free_all(hInternetP.header);
1490                    addToMap(tmpmaps->content,"value",tmpContent);
1491#ifdef POST_DEBUG
1492                    fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1493#endif
1494                  }
1495                }
1496                else
1497                  if(xmlStrcasecmp(cur3->name,BAD_CAST "BodyReference")==0 ){
1498                    xmlChar *val=xmlGetProp(cur3,BAD_CAST "href");
1499                    HINTERNET bInternet,res1;
1500                    bInternet=InternetOpen(
1501#ifndef WIN32
1502                                           (LPCTSTR)
1503#endif
1504                                           "ZooWPSClient\0",
1505                                           INTERNET_OPEN_TYPE_PRECONFIG,
1506                                           NULL,NULL, 0);
1507                    if(!CHECK_INET_HANDLE(bInternet))
1508                      fprintf(stderr,"WARNING : hInternet handle failed to initialize");
1509#ifdef POST_DEBUG
1510                    curl_easy_setopt(bInternet.handle, CURLOPT_VERBOSE, 1);
1511#endif
1512                    res1=InternetOpenUrl(bInternet,(char*)val,NULL,0,
1513                                         INTERNET_FLAG_NO_CACHE_WRITE,0);
1514                    char* tmp=
1515                      (char*)malloc((res1.nDataLen+1)*sizeof(char));
1516                    if(tmp == NULL){
1517                      return errorException(m, _("Unable to allocate memory."), "InternalError");
1518                    }
1519                    size_t bRead;
1520                    InternetReadFile(res1, (LPVOID)tmp,
1521                                     res1.nDataLen, &bRead);
1522                    tmp[res1.nDataLen]=0;
1523                    InternetCloseHandle(bInternet);
1524                    map *btmp=getMap(tmpmaps->content,"href");
1525                    if(btmp!=NULL){
1526#ifdef POST_DEBUG
1527                      fprintf(stderr,"%s %s\n",btmp->value,tmp);
1528                      curl_easy_setopt(hInternetP.handle, CURLOPT_VERBOSE, 1);
1529#endif
1530                      res=InternetOpenUrl(hInternetP,btmp->value,tmp,
1531                                          strlen(tmp),
1532                                          INTERNET_FLAG_NO_CACHE_WRITE,0);
1533                      char* tmpContent = (char*)malloc((res.nDataLen+1)*sizeof(char));
1534                      if(tmpContent == NULL){
1535                        return errorException(m, _("Unable to allocate memory."), "InternalError");
1536                      }
1537                      size_t dwRead;
1538                      InternetReadFile(res, (LPVOID)tmpContent,
1539                                       res.nDataLen, &dwRead);
1540                      tmpContent[res.nDataLen]=0;
1541                      if(hInternetP.header!=NULL)
1542                        curl_slist_free_all(hInternetP.header);
1543                      addToMap(tmpmaps->content,"value",tmpContent);
1544#ifdef POST_DEBUG
1545                      fprintf(stderr,"DL CONTENT : (%s)\n",tmpContent);
1546#endif
1547                    }
1548                  }
1549              }
1550              cur3=cur3->next;
1551            }
1552            InternetCloseHandle(hInternetP);
1553#ifdef POST_DEBUG
1554            fprintf(stderr,"Header and Body was parsed from Reference \n");
1555#endif
1556#ifdef DEBUG
1557            dumpMap(tmpmaps->content);
1558            fprintf(stderr, "= element 2 node \"%s\" = (%s)\n", 
1559                    cur2->name,cur2->content);
1560#endif
1561          }
1562          else if(xmlStrcasecmp(cur2->name,BAD_CAST "Data")==0){
1563#ifdef DEBUG
1564            fprintf(stderr,"DATA\n");
1565#endif
1566            xmlNodePtr cur4=cur2->children;
1567            while(cur4!=NULL){
1568              while(cur4!=NULL &&cur4->type!=XML_ELEMENT_NODE)
1569                cur4=cur4->next;
1570              if(cur4==NULL)
1571                break;
1572              if(xmlStrcasecmp(cur4->name, BAD_CAST "LiteralData")==0){
1573                /**
1574                 * Get every attribute from a LiteralData node
1575                 * dataType , uom
1576                 */
1577                char *list[2];
1578                list[0]=zStrdup("dataType");
1579                list[1]=zStrdup("uom");
1580                for(int l=0;l<2;l++){
1581#ifdef DEBUG
1582                  fprintf(stderr,"*** LiteralData %s ***",list[l]);
1583#endif
1584                  xmlChar *val=xmlGetProp(cur4,BAD_CAST list[l]);
1585                  if(val!=NULL && strlen((char*)val)>0){
1586                    if(tmpmaps->content!=NULL)
1587                      addToMap(tmpmaps->content,list[l],(char*)val);
1588                    else
1589                      tmpmaps->content=createMap(list[l],(char*)val);
1590#ifdef DEBUG
1591                    fprintf(stderr,"%s\n",val);
1592#endif
1593                  }
1594                  xmlFree(val);
1595                  free(list[l]);                 
1596                }
1597              }
1598              else if(xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0){
1599                /**
1600                 * Get every attribute from a Reference node
1601                 * mimeType, encoding, schema
1602                 */
1603                const char *coms[3]={"mimeType","encoding","schema"};
1604                for(int l=0;l<3;l++){
1605#ifdef DEBUG
1606                  fprintf(stderr,"*** ComplexData %s ***\n",coms[l]);
1607#endif
1608                  xmlChar *val=xmlGetProp(cur4,BAD_CAST coms[l]);
1609                  if(val!=NULL && strlen((char*)val)>0){
1610                    if(tmpmaps->content!=NULL)
1611                      addToMap(tmpmaps->content,coms[l],(char*)val);
1612                    else
1613                      tmpmaps->content=createMap(coms[l],(char*)val);
1614#ifdef DEBUG
1615                    fprintf(stderr,"%s\n",val);
1616#endif
1617                  }
1618                  xmlFree(val);
1619                }
1620              }
1621
1622              map* test=getMap(tmpmaps->content,"encoding");
1623              if(test==NULL){
1624                if(tmpmaps->content!=NULL)
1625                  addToMap(tmpmaps->content,"encoding","utf-8");
1626                else
1627                  tmpmaps->content=createMap("encoding","utf-8");
1628                test=getMap(tmpmaps->content,"encoding");
1629              }
1630
1631              if(strcasecmp(test->value,"base64")!=0){
1632                xmlChar* mv=xmlNodeListGetString(doc,cur4->xmlChildrenNode,1);
1633                map* ltmp=getMap(tmpmaps->content,"mimeType");
1634                if(mv==NULL || 
1635                   (xmlStrcasecmp(cur4->name, BAD_CAST "ComplexData")==0 &&
1636                    (ltmp==NULL || strncasecmp(ltmp->value,"text/xml",8)==0) )){
1637                  xmlDocPtr doc1=xmlNewDoc(BAD_CAST "1.0");
1638                  int buffersize;
1639                  xmlNodePtr cur5=cur4->children;
1640                  while(cur5!=NULL &&cur5->type!=XML_ELEMENT_NODE)
1641                    cur5=cur5->next;
1642                  xmlDocSetRootElement(doc1,cur5);
1643                  xmlDocDumpFormatMemoryEnc(doc1, &mv, &buffersize, "utf-8", 1);
1644                  char size[1024];
1645                  sprintf(size,"%d",buffersize);
1646                  addToMap(tmpmaps->content,"size",size);
1647                }
1648                addToMap(tmpmaps->content,"value",(char*)mv);
1649                xmlFree(mv);
1650              }else{
1651                xmlChar* tmp=xmlNodeListGetRawString(doc,cur4->xmlChildrenNode,0);
1652                addToMap(tmpmaps->content,"value",(char*)tmp);
1653                map* tmpv=getMap(tmpmaps->content,"value");
1654                char *res=NULL;
1655                char *curs=tmpv->value;
1656                for(int i=0;i<=strlen(tmpv->value)/64;i++) {
1657                  if(res==NULL)
1658                    res=(char*)malloc(67*sizeof(char));
1659                  else
1660                    res=(char*)realloc(res,(((i+1)*65)+i)*sizeof(char));
1661                  int csize=i*65;
1662                  strncpy(res + csize,curs,64);
1663                  if(i==xmlStrlen(tmp)/64)
1664                    strcat(res,"\n\0");
1665                  else{
1666                    strncpy(res + (((i+1)*64)+i),"\n\0",2);
1667                    curs+=64;
1668                  }
1669                }
1670                free(tmpv->value);
1671                tmpv->value=zStrdup(res);
1672                free(res);
1673                xmlFree(tmp);
1674              }
1675              cur4=cur4->next;
1676            }
1677          }
1678#ifdef DEBUG
1679          fprintf(stderr,"cur2 next \n");
1680          fflush(stderr);
1681#endif
1682          cur2=cur2->next;
1683        }
1684#ifdef DEBUG
1685        fprintf(stderr,"ADD MAPS TO REQUEST MAPS !\n");
1686        fflush(stderr);
1687#endif
1688
1689        {
1690          maps* testPresence=getMaps(request_input_real_format,tmpmaps->name);
1691          if(testPresence!=NULL){
1692            elements* elem=getElements(s1->inputs,tmpmaps->name);
1693            if(elem!=NULL){
1694              if(appendMapsToMaps(m,request_input_real_format,tmpmaps,elem)<0){
1695                freeMaps(&m);
1696                free(m);
1697                free(REQUEST);
1698                free(SERVICE_URL);
1699                InternetCloseHandle(hInternet);
1700                freeService(&s1);
1701                free(s1);
1702                return 0;
1703              }
1704            }
1705          }
1706          else
1707            addMapsToMaps(&request_input_real_format,tmpmaps);
1708        }
1709
1710#ifdef DEBUG
1711        fprintf(stderr,"******TMPMAPS*****\n");
1712        dumpMaps(tmpmaps);
1713        fprintf(stderr,"******REQUESTMAPS*****\n");
1714        dumpMaps(request_input_real_format);
1715#endif
1716        freeMaps(&tmpmaps);
1717        free(tmpmaps);
1718        tmpmaps=NULL;         
1719      }
1720#ifdef DEBUG
1721      dumpMaps(tmpmaps); 
1722#endif
1723    }
1724#ifdef DEBUG
1725    fprintf(stderr,"Search for response document node\n");
1726#endif
1727    xmlXPathFreeObject(tmpsptr);
1728   
1729    tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='ResponseDocument']");
1730    bool asRaw=false;
1731    tmps=tmpsptr->nodesetval;
1732    if(tmps->nodeNr==0){
1733      tmpsptr=extractFromDoc(doc,"/*/*/*[local-name()='RawDataOutput']");
1734      tmps=tmpsptr->nodesetval;
1735      asRaw=true;
1736    }
1737#ifdef DEBUG
1738    fprintf(stderr,"*****%d*****\n",tmps->nodeNr);
1739#endif
1740    for(int k=0;k<tmps->nodeNr;k++){
1741      if(asRaw==true)
1742        addToMap(request_inputs,"RawDataOutput","");
1743      else
1744        addToMap(request_inputs,"ResponseDocument","");
1745      maps *tmpmaps=NULL;
1746      xmlNodePtr cur=tmps->nodeTab[k];
1747      if(cur->type == XML_ELEMENT_NODE) {
1748        /**
1749         * A specific responseDocument node.
1750         */
1751        if(tmpmaps==NULL){
1752          tmpmaps=(maps*)malloc(MAPS_SIZE);
1753          if(tmpmaps == NULL){
1754            return errorException(m, _("Unable to allocate memory."), "InternalError");
1755          }
1756          tmpmaps->name=zStrdup("unknownIdentifier");
1757          tmpmaps->content=NULL;
1758          tmpmaps->next=NULL;
1759        }
1760        /**
1761         * Get every attribute: storeExecuteResponse, lineage, status
1762         */
1763        const char *ress[3]={"storeExecuteResponse","lineage","status"};
1764        xmlChar *val;
1765        for(int l=0;l<3;l++){
1766#ifdef DEBUG
1767          fprintf(stderr,"*** %s ***\t",ress[l]);
1768#endif
1769          val=xmlGetProp(cur,BAD_CAST ress[l]);
1770          if(val!=NULL && strlen((char*)val)>0){
1771            if(tmpmaps->content!=NULL)
1772              addToMap(tmpmaps->content,ress[l],(char*)val);
1773            else
1774              tmpmaps->content=createMap(ress[l],(char*)val);
1775            addToMap(request_inputs,ress[l],(char*)val);
1776          }
1777#ifdef DEBUG
1778          fprintf(stderr,"%s\n",val);
1779#endif
1780          xmlFree(val);
1781        }
1782        xmlNodePtr cur1=cur->children;
1783        while(cur1!=NULL && cur1->type != XML_ELEMENT_NODE)
1784          cur1=cur1->next;
1785        int cur1cnt=0;
1786        while(cur1){
1787          /**
1788           * Indentifier
1789           */
1790          if(xmlStrncasecmp(cur1->name,BAD_CAST "Identifier",xmlStrlen(cur1->name))==0){
1791            xmlChar *val=
1792              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1793            if(tmpmaps==NULL){
1794              tmpmaps=(maps*)malloc(MAPS_SIZE);
1795              if(tmpmaps == NULL){
1796                return errorException(m, _("Unable to allocate memory."), "InternalError");
1797              }
1798              tmpmaps->name=zStrdup((char*)val);
1799              tmpmaps->content=NULL;
1800              tmpmaps->next=NULL;
1801            }
1802            else{
1803              //free(tmpmaps->name);
1804              tmpmaps->name=zStrdup((char*)val);
1805            }
1806            if(asRaw==true)
1807              addToMap(request_inputs,"RawDataOutput",(char*)val);
1808            else{
1809              if(cur1cnt==0)
1810                addToMap(request_inputs,"ResponseDocument",(char*)val);
1811              else{
1812                map* tt=getMap(request_inputs,"ResponseDocument");
1813                char* tmp=zStrdup(tt->value);
1814                free(tt->value);
1815                tt->value=(char*)malloc((strlen(tmp)+strlen((char*)val)+1)*sizeof(char));
1816                sprintf(tt->value,"%s;%s",tmp,(char*)val);
1817                free(tmp);
1818              }
1819            }
1820            cur1cnt+=1;
1821            xmlFree(val);
1822          }
1823          /**
1824           * Title, Asbtract
1825           */
1826          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Title",xmlStrlen(cur1->name))==0 ||
1827                  xmlStrncasecmp(cur1->name,BAD_CAST "Abstract",xmlStrlen(cur1->name))==0){
1828            xmlChar *val=
1829              xmlNodeListGetString(doc,cur1->xmlChildrenNode,1);
1830            if(tmpmaps==NULL){
1831              tmpmaps=(maps*)malloc(MAPS_SIZE);
1832              if(tmpmaps == NULL){
1833                return errorException(m, _("Unable to allocate memory."), "InternalError");
1834              }
1835              tmpmaps->name=zStrdup("missingIndetifier");
1836              tmpmaps->content=createMap((char*)cur1->name,(char*)val);
1837              tmpmaps->next=NULL;
1838            }
1839            else{
1840              if(tmpmaps->content!=NULL)
1841                addToMap(tmpmaps->content,(char*)cur1->name,(char*)val);
1842              else
1843                tmpmaps->content=createMap((char*)cur1->name,(char*)val);
1844            }
1845            xmlFree(val);
1846          }
1847          else if(xmlStrncasecmp(cur1->name,BAD_CAST "Output",xmlStrlen(cur1->name))==0){
1848            /**
1849             * Get every attribute from a Output node
1850             * mimeType, encoding, schema, uom, asReference
1851             */
1852            const char *outs[5]={"mimeType","encoding","schema","uom","asReference"};
1853            for(int l=0;l<5;l++){
1854#ifdef DEBUG
1855              fprintf(stderr,"*** %s ***\t",outs[l]);
1856#endif
1857              val=xmlGetProp(cur1,BAD_CAST outs[l]);
1858              if(val!=NULL && strlen((char*)val)>0){
1859                if(tmpmaps->content!=NULL)
1860                  addToMap(tmpmaps->content,outs[l],(char*)val);
1861                else
1862                  tmpmaps->content=createMap(outs[l],(char*)val);
1863              }
1864#ifdef DEBUG
1865              fprintf(stderr,"%s\n",val);
1866#endif
1867              xmlFree(val);
1868            }
1869            xmlNodePtr cur2=cur1->children;
1870            while(cur2!=NULL && cur2->type != XML_ELEMENT_NODE)
1871              cur2=cur2->next;
1872            while(cur2){
1873              /**
1874               * Indentifier
1875               */
1876              if(xmlStrncasecmp(cur2->name,BAD_CAST "Identifier",xmlStrlen(cur2->name))==0){
1877                xmlChar *val=
1878                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1879                if(tmpmaps==NULL){
1880                  tmpmaps=(maps*)malloc(MAPS_SIZE);
1881                  if(tmpmaps == NULL){
1882                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1883                  }
1884                  tmpmaps->name=zStrdup((char*)val);
1885                  tmpmaps->content=NULL;
1886                  tmpmaps->next=NULL;
1887                }
1888                else{
1889                  if(tmpmaps->name!=NULL)
1890                    free(tmpmaps->name);
1891                  tmpmaps->name=zStrdup((char*)val);;
1892                }
1893                xmlFree(val);
1894              }
1895              /**
1896               * Title, Asbtract
1897               */
1898              else if(xmlStrncasecmp(cur2->name,BAD_CAST "Title",xmlStrlen(cur2->name))==0 ||
1899                      xmlStrncasecmp(cur2->name,BAD_CAST "Abstract",xmlStrlen(cur2->name))==0){
1900                xmlChar *val=
1901                  xmlNodeListGetString(doc,cur2->xmlChildrenNode,1);
1902                if(tmpmaps==NULL){
1903                  tmpmaps=(maps*)malloc(MAPS_SIZE);
1904                  if(tmpmaps == NULL){
1905                    return errorException(m, _("Unable to allocate memory."), "InternalError");
1906                  }
1907                  tmpmaps->name=zStrdup("missingIndetifier");
1908                  tmpmaps->content=createMap((char*)cur2->name,(char*)val);
1909                  tmpmaps->next=NULL;
1910                }
1911                else{
1912                  if(tmpmaps->content!=NULL)
1913                    addToMap(tmpmaps->content,
1914                             (char*)cur2->name,(char*)val);
1915                  else
1916                    tmpmaps->content=
1917                      createMap((char*)cur2->name,(char*)val);
1918                }
1919                xmlFree(val);
1920              }
1921              cur2=cur2->next;
1922              while(cur2!=NULL && cur2->type != XML_ELEMENT_NODE)
1923                cur2=cur2->next;
1924            }
1925          }
1926          cur1=cur1->next;
1927          while(cur1!=NULL && cur1->type != XML_ELEMENT_NODE)
1928            cur1=cur1->next;
1929        }
1930      }
1931      if(request_output_real_format==NULL)
1932        request_output_real_format=dupMaps(&tmpmaps);
1933      else
1934        addMapsToMaps(&request_output_real_format,tmpmaps);
1935      if(tmpmaps!=NULL){
1936        freeMaps(&tmpmaps);
1937        free(tmpmaps);
1938        tmpmaps=NULL;
1939      }
1940    }
1941    xmlXPathFreeObject(tmpsptr);
1942    xmlCleanupParser();
1943  }
1944 
1945
1946  //  if(CHECK_INET_HANDLE(hInternet))
1947  InternetCloseHandle(hInternet);
1948
1949#ifdef DEBUG
1950  fprintf(stderr,"\n%d\n",__LINE__);
1951  fflush(stderr);
1952  dumpMaps(request_input_real_format);
1953  dumpMaps(request_output_real_format);
1954  dumpMap(request_inputs);
1955  fprintf(stderr,"\n%d\n",__LINE__);
1956  fflush(stderr);
1957#endif
1958
1959  /**
1960   * Ensure that each requested arguments are present in the request
1961   * DataInputs and ResponseDocument / RawDataOutput
1962   */
1963  char *dfv=addDefaultValues(&request_input_real_format,s1->inputs,m,0);
1964  char *dfv1=addDefaultValues(&request_output_real_format,s1->outputs,m,1);
1965  if(strcmp(dfv1,"")!=0 || strcmp(dfv,"")!=0){
1966    char tmps[1024];
1967    if(strcmp(dfv,"")!=0){
1968      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);
1969    }
1970    else if(strcmp(dfv1,"")!=0){
1971      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);
1972    }
1973    map* tmpe=createMap("text",tmps);
1974    addToMap(tmpe,"code","MissingParameterValue");
1975    printExceptionReportResponse(m,tmpe);
1976    freeService(&s1);
1977    free(s1);
1978    freeMap(&tmpe);
1979    free(tmpe);
1980    freeMaps(&m);
1981    free(m);
1982    free(REQUEST);
1983    free(SERVICE_URL);
1984    freeMaps(&request_input_real_format);
1985    free(request_input_real_format);
1986    freeMaps(&request_output_real_format);
1987    free(request_output_real_format);
1988    freeMaps(&tmpmaps);
1989    free(tmpmaps);
1990    return 1;
1991  }
1992  maps* tmpReqI=request_input_real_format;
1993  while(tmpReqI!=NULL){
1994    char name[1024];
1995    if(getMap(tmpReqI->content,"isFile")!=NULL){
1996      if (cgiFormFileName(tmpReqI->name, name, sizeof(name)) == cgiFormSuccess) {
1997        int BufferLen=1024;
1998        cgiFilePtr file;
1999        int targetFile;
2000        mode_t mode;
2001        char storageNameOnServer[2048];
2002        char fileNameOnServer[64];
2003        char contentType[1024];
2004        char buffer[1024];
2005        char *tmpStr=NULL;
2006        int size;
2007        int got,t;
2008        map *path=getMapFromMaps(m,"main","tmpPath");
2009        cgiFormFileSize(tmpReqI->name, &size);
2010        cgiFormFileContentType(tmpReqI->name, contentType, sizeof(contentType));
2011        if (cgiFormFileOpen(tmpReqI->name, &file) == cgiFormSuccess) {
2012          t=-1;
2013          while(1){
2014            tmpStr=strstr(name+t+1,"\\");
2015            if(NULL==tmpStr)
2016              tmpStr=strstr(name+t+1,"/");
2017            if(NULL!=tmpStr)
2018              t=(int)(tmpStr-name);
2019            else
2020              break;
2021          }
2022          strcpy(fileNameOnServer,name+t+1);
2023         
2024          sprintf(storageNameOnServer,"%s/%s",path->value,fileNameOnServer);
2025#ifdef DEBUG
2026          fprintf(stderr,"Name on server %s\n",storageNameOnServer);
2027          fprintf(stderr,"fileNameOnServer: %s\n",fileNameOnServer);
2028#endif
2029          mode=S_IRWXU|S_IRGRP|S_IROTH;
2030          targetFile = open (storageNameOnServer,O_RDWR|O_CREAT|O_TRUNC,S_IRWXU|S_IRGRP|S_IROTH);
2031          if(targetFile<0){
2032#ifdef DEBUG
2033            fprintf(stderr,"could not create the new file,%s\n",fileNameOnServer);         
2034#endif
2035          }else{
2036            while (cgiFormFileRead(file, buffer, BufferLen, &got) ==cgiFormSuccess){
2037              if(got>0)
2038                write(targetFile,buffer,got);
2039            }
2040          }
2041          addToMap(tmpReqI->content,"lref",storageNameOnServer);
2042          cgiFormFileClose(file);
2043          close(targetFile);
2044#ifdef DEBUG
2045          fprintf(stderr,"File \"%s\" has been uploaded",fileNameOnServer);
2046#endif
2047        }
2048      }
2049    }
2050    tmpReqI=tmpReqI->next;
2051  }
2052
2053  ensureDecodedBase64(&request_input_real_format);
2054
2055#ifdef DEBUG
2056  fprintf(stderr,"REQUEST_INPUTS\n");
2057  dumpMaps(request_input_real_format);
2058  fprintf(stderr,"REQUEST_OUTPUTS\n");
2059  dumpMaps(request_output_real_format);
2060#endif
2061
2062  maps* curs=getMaps(m,"env");
2063  if(curs!=NULL){
2064    map* mapcs=curs->content;
2065    while(mapcs!=NULLMAP){
2066#ifndef WIN32
2067      setenv(mapcs->name,mapcs->value,1);
2068#else
2069#ifdef DEBUG
2070      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
2071#endif
2072      if(mapcs->value[strlen(mapcs->value)-2]=='\r'){
2073#ifdef DEBUG
2074        fprintf(stderr,"[ZOO: Env var finish with \r]\n");
2075#endif
2076        mapcs->value[strlen(mapcs->value)-1]=0;
2077      }
2078#ifdef DEBUG
2079      fflush(stderr);
2080      fprintf(stderr,"setting variable... %s\n",(
2081#endif
2082              SetEnvironmentVariable(mapcs->name,mapcs->value)
2083#ifdef DEBUG
2084              ==0)? "OK" : "FAILED");
2085#else
2086      ;
2087#endif
2088      char* toto=(char*)malloc((strlen(mapcs->name)+strlen(mapcs->value)+2)*sizeof(char));
2089      sprintf(toto,"%s=%s",mapcs->name,mapcs->value);
2090      putenv(toto);
2091#ifdef DEBUG
2092      fflush(stderr);
2093#endif
2094#endif
2095#ifdef DEBUG
2096      fprintf(stderr,"[ZOO: setenv (%s=%s)]\n",mapcs->name,mapcs->value);
2097      fflush(stderr);
2098#endif
2099      mapcs=mapcs->next;
2100    }
2101  }
2102 
2103#ifdef DEBUG
2104  dumpMap(request_inputs);
2105#endif
2106
2107  /**
2108   * Need to check if we need to fork to load a status enabled
2109   */
2110  r_inputs=NULL;
2111  map* store=getMap(request_inputs,"storeExecuteResponse");
2112  map* status=getMap(request_inputs,"status");
2113  /**
2114   * 05-007r7 WPS 1.0.0 page 57 :
2115   * 'If status="true" and storeExecuteResponse is "false" then the service
2116   * shall raise an exception.'
2117   */
2118  if(status!=NULL && strcmp(status->value,"true")==0 && 
2119     store!=NULL && strcmp(store->value,"false")==0){
2120    errorException(m, _("Status cannot be set to true with storeExecuteResponse to false. Please, modify your request parameters."), "InvalidParameterValue");
2121    freeService(&s1);
2122    free(s1);
2123    freeMaps(&m);
2124    free(m);
2125   
2126    freeMaps(&request_input_real_format);
2127    free(request_input_real_format);
2128   
2129    freeMaps(&request_output_real_format);
2130    free(request_output_real_format);
2131   
2132    free(REQUEST);
2133    free(SERVICE_URL);
2134    return 1;
2135  }
2136  r_inputs=getMap(request_inputs,"storeExecuteResponse");
2137  int eres=SERVICE_STARTED;
2138  int cpid=getpid();
2139
2140  /**
2141   * Initialize the specific [lenv] section which contains runtime variables:
2142   *
2143   *  - usid : it is an unique identification number
2144   *  - sid : it is the process idenfitication number (OS)
2145   *  - status : value between 0 and 100 to express the  completude of
2146   * the operations of the running service
2147   *  - message : is a string where you can store error messages, in case
2148   * service is failing, or o provide details on the ongoing operation.
2149   *  - cwd : is the current working directory
2150   *  - soap : is a boolean value, true if the request was contained in a SOAP
2151   * Envelop
2152   *  - sessid : string storing the session identifier (only when cookie is
2153   * used)
2154   *  - cgiSid : only defined on Window platforms (for being able to identify
2155   * the created process)
2156   *
2157   */
2158  maps *_tmpMaps=(maps*)malloc(MAPS_SIZE);
2159  _tmpMaps->name=zStrdup("lenv");
2160  char tmpBuff[100];
2161  sprintf(tmpBuff,"%i",(cpid+(int)time(NULL)));
2162  _tmpMaps->content=createMap("usid",tmpBuff);
2163  _tmpMaps->next=NULL;
2164  sprintf(tmpBuff,"%i",cpid);
2165  addToMap(_tmpMaps->content,"sid",tmpBuff);
2166  addToMap(_tmpMaps->content,"status","0");
2167  addToMap(_tmpMaps->content,"message",_("No message provided"));
2168  addToMap(_tmpMaps->content,"cwd",ntmp);
2169  map* ltmp=getMap(request_inputs,"soap");
2170  if(ltmp!=NULL)
2171    addToMap(_tmpMaps->content,"soap",ltmp->value);
2172  else
2173    addToMap(_tmpMaps->content,"soap","false");
2174  if(cgiCookie!=NULL && strlen(cgiCookie)>0){
2175    int hasValidCookie=-1;
2176    char *tcook=zStrdup(cgiCookie);
2177    char *tmp=NULL;
2178    int hasVal=-1;
2179    map* testing=getMapFromMaps(m,"main","cookiePrefix");
2180    if(testing==NULL){
2181      tmp=zStrdup("ID=");
2182    }else{
2183      tmp=(char*)malloc((strlen(testing->value)+2)*sizeof(char));
2184      sprintf(tmp,"%s=",testing->value);
2185      hasVal=1;
2186    }
2187    if(strstr(cgiCookie,";")!=NULL){
2188      char *token,*saveptr;
2189      token=strtok_r(cgiCookie,";",&saveptr);
2190      while(token!=NULL){
2191        if(strcasestr(token,tmp)!=NULL){
2192          if(tcook!=NULL)
2193            free(tcook);
2194          tcook=zStrdup(token);
2195          hasValidCookie=1;
2196        }
2197        token=strtok_r(NULL,";",&saveptr);
2198      }
2199    }else{
2200      if(strstr(cgiCookie,"=")!=NULL && strcasestr(cgiCookie,tmp)!=NULL){
2201        tcook=zStrdup(cgiCookie);
2202        hasValidCookie=1;
2203      }
2204      if(tmp!=NULL){
2205        free(tmp);
2206      }
2207    }
2208    if(hasValidCookie>0){
2209      addToMap(_tmpMaps->content,"sessid",strstr(tcook,"=")+1);
2210      char session_file_path[1024];
2211      map *tmpPath=getMapFromMaps(m,"main","sessPath");
2212      if(tmpPath==NULL)
2213        tmpPath=getMapFromMaps(m,"main","tmpPath");
2214      char *tmp1=strtok(tcook,";");
2215      if(tmp1!=NULL)
2216        sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(tmp1,"=")+1);
2217      else
2218        sprintf(session_file_path,"%s/sess_%s.cfg",tmpPath->value,strstr(cgiCookie,"=")+1);
2219      free(tcook);
2220      maps *tmpSess=(maps*)malloc(MAPS_SIZE);
2221      struct stat file_status;
2222      int istat = stat(session_file_path, &file_status);
2223      if(istat==0 && file_status.st_size>0){
2224        conf_read(session_file_path,tmpSess);
2225        addMapsToMaps(&m,tmpSess);
2226        freeMaps(&tmpSess);
2227        free(tmpSess);
2228      }
2229    }
2230  }
2231  addMapsToMaps(&m,_tmpMaps);
2232  freeMaps(&_tmpMaps);
2233  free(_tmpMaps);
2234
2235#ifdef DEBUG
2236  dumpMap(request_inputs);
2237#endif
2238#ifdef WIN32
2239  char *cgiSidL=NULL;
2240  if(getenv("CGISID")!=NULL)
2241    addToMap(request_inputs,"cgiSid",getenv("CGISID"));
2242  map* test1=getMap(request_inputs,"cgiSid");
2243  if(test1!=NULL){
2244    cgiSid=test1->value;
2245    addToMap(request_inputs,"storeExecuteResponse","true");
2246    addToMap(request_inputs,"status","true");
2247    setMapInMaps(m,"lenv","sid",test1->value);
2248    status=getMap(request_inputs,"status");
2249    printf("cgiSid %s\n",cgiSid);
2250  }
2251#endif
2252  int hrstd=-1;
2253  char *fbkp,*fbkp1;
2254  FILE *f0,*f1;
2255  if(status!=NULL)
2256    if(strcasecmp(status->value,"false")==0)
2257      status=NULLMAP;
2258  if(status==NULLMAP){
2259    loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
2260  }
2261  else{
2262    int   pid;
2263#ifdef DEBUG
2264    fprintf(stderr,"\nPID : %d\n",cpid);
2265#endif
2266
2267#ifndef WIN32
2268    pid = fork ();
2269#else
2270    if(cgiSid==NULL){
2271      createProcess(m,request_inputs,s1,NULL,cpid,request_input_real_format,request_output_real_format);
2272      pid = cpid;
2273    }else{
2274      pid=0;
2275      cpid=atoi(cgiSid);
2276      printf("cgiSid %s\n",cgiSid);
2277    }
2278    //printf("pid cpid %d %d\n",pid,cpid);
2279    //fflush(stderr);
2280#endif
2281    if (pid > 0) {
2282      /**
2283       * dady :
2284       * set status to SERVICE_ACCEPTED
2285       */
2286#ifdef DEBUG
2287      fprintf(stderr,"father pid continue (origin %d) %d ...\n",cpid,getpid());
2288#endif
2289      eres=SERVICE_ACCEPTED;
2290    }else if (pid == 0) {
2291      /**
2292       * son : have to close the stdout, stdin and stderr to let the parent
2293       * process answer to http client.
2294       */
2295      r_inputs=getMapFromMaps(m,"main","tmpPath");
2296      map* r_inputs1=getMap(s1->content,"ServiceProvider");
2297      fbkp=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)*sizeof(char));
2298      sprintf(fbkp,"%s/%s_%d.xml",r_inputs->value,r_inputs1->value,cpid);
2299      char* flog=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)*sizeof(char));
2300      sprintf(flog,"%s/%s_%d_error.log",r_inputs->value,r_inputs1->value,cpid);
2301#ifdef DEBUG
2302      fprintf(stderr,"RUN IN BACKGROUND MODE \n");
2303      fprintf(stderr,"son pid continue (origin %d) %d ...\n",cpid,getpid());
2304      fprintf(stderr,"\nFILE TO STORE DATA %s\n",r_inputs->value);
2305#endif
2306      freopen(flog,"w+",stderr);
2307      f0=freopen(fbkp , "w+", stdout);
2308      fclose(stdin);
2309      free(flog);
2310      /**
2311       * set status to SERVICE_STARTED and flush stdout to ensure full
2312       * content was outputed (the file used to store the ResponseDocument).
2313       * The rewind stdout to restart writing from the bgining of the file,
2314       * this way the data will be updated at the end of the process run.
2315       */
2316      printProcessResponse(m,request_inputs,cpid,
2317                           s1,r_inputs1->value,SERVICE_STARTED,
2318                           request_input_real_format,
2319                           request_output_real_format);
2320#ifndef WIN32
2321      fflush(stdout);
2322      rewind(stdout);
2323#else
2324#endif
2325      fbkp1=(char*)malloc((strlen(r_inputs->value)+strlen(r_inputs1->value)+1024)*sizeof(char));
2326      sprintf(fbkp1,"%s/%s_final_%d.xml",r_inputs->value,r_inputs1->value,cpid);
2327      f1=freopen(fbkp1 , "w+", stdout);
2328      loadServiceAndRun(&m,s1,request_inputs,&request_input_real_format,&request_output_real_format,&eres);
2329    } else {
2330      /**
2331       * error server don't accept the process need to output a valid
2332       * error response here !!!
2333       */
2334      eres=-1;
2335      errorException(m, _("Unable to run the child process properly"), "InternalError");
2336    }
2337  }
2338
2339#ifdef DEBUG
2340  dumpMaps(request_output_real_format);
2341#endif
2342  if(eres!=-1)
2343    outputResponse(s1,request_input_real_format,
2344                   request_output_real_format,request_inputs,
2345                   cpid,m,eres);
2346  fflush(stdout);
2347  /**
2348   * Ensure that if error occurs when freeing memory, no signal will return
2349   * an ExceptionReport document as the result was already returned to the
2350   * client.
2351   */
2352#ifndef USE_GDB
2353  (void) signal(SIGSEGV,donothing);
2354  (void) signal(SIGTERM,donothing);
2355  (void) signal(SIGINT,donothing);
2356  (void) signal(SIGILL,donothing);
2357  (void) signal(SIGFPE,donothing);
2358  (void) signal(SIGABRT,donothing);
2359#endif
2360
2361  if(((int)getpid())!=cpid){
2362    fclose(stdout);
2363    fclose(stderr);
2364    unhandleStatus(m);
2365    /**
2366     * Dump back the final file fbkp1 to fbkp
2367     */
2368    fclose(f0);
2369    fclose(f1);
2370    FILE* f2=fopen(fbkp1,"rb");
2371    FILE* f3=fopen(fbkp,"wb+");
2372    free(fbkp);
2373    fseek(f2,0,SEEK_END);
2374    long flen=ftell(f2);
2375    fseek(f2,0,SEEK_SET);
2376    char *tmps1=(char*)malloc((flen+1)*sizeof(char));
2377    fread(tmps1,flen,1,f2);
2378    fwrite(tmps1,1,flen+1,f3);
2379    fclose(f2);
2380    fclose(f3);
2381    unlink(fbkp1);
2382    free(fbkp1);
2383  }
2384
2385  freeService(&s1);
2386  free(s1);
2387  freeMaps(&m);
2388  free(m);
2389 
2390  freeMaps(&request_input_real_format);
2391  free(request_input_real_format);
2392 
2393  freeMaps(&request_output_real_format);
2394  free(request_output_real_format);
2395 
2396  free(REQUEST);
2397  free(SERVICE_URL);
2398#ifdef DEBUG
2399  fprintf(stderr,"Processed response \n");
2400  fflush(stdout);
2401  fflush(stderr);
2402#endif
2403
2404  return 0;
2405}
2406
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