source: trunk/zoo-project/zoo-kernel/service.h @ 458

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

Fix some issue in background execution on windows platform (basic array and xlink). Fix issue #89.

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr
File size: 21.8 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 * Copyright (c) 2009-2012 GeoLabs SARL
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#ifndef ZOO_SERVICE_H
26#define ZOO_SERVICE_H 1
27
28#pragma once
29
30#ifdef WIN32
31#ifndef USE_MS
32#define strncasecmp _strnicmp
33#define strcasecmp _stricmp
34#endif
35#ifndef snprintf
36#define snprintf sprintf_s
37#endif
38#define zStrdup _strdup
39#define zMkdir _mkdir
40#define zOpen _open
41#define zWrite _write
42#else
43#define zStrdup strdup
44#define zMkdir mkdir
45#define zOpen open
46#define zWrite write
47#endif
48
49#ifdef __cplusplus
50extern "C" {
51#endif
52
53#ifdef WIN32
54#ifdef USE_MS
55#include <mapserver.h>
56#endif
57#endif
58#include <stdlib.h>
59#include <ctype.h>
60#include <stdio.h>
61#include <string.h>
62#ifndef WIN32
63#define bool int
64#define true 1
65#define false -1
66#else
67  //#include <stdbool.h>
68#endif
69
70#define SERVICE_ACCEPTED 0
71#define SERVICE_STARTED 1
72#define SERVICE_PAUSED 2
73#define SERVICE_SUCCEEDED 3
74#define SERVICE_FAILED 4
75
76#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+sizeof(elements*))
77#define MAP_SIZE (2*sizeof(char*))+sizeof(NULL)
78#define IOTYPE_SIZE MAP_SIZE+sizeof(NULL)
79#define MAPS_SIZE (2*sizeof(char*))+sizeof(map*)+MAP_SIZE
80#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
81
82#define SHMSZ     27
83
84
85#ifdef DEBUG_STACK
86  void debugStack(const char* file,const int line){
87    int stack;
88    fprintf(stderr,"stack %p (%s: %d) \n",&stack,file,line);
89  }
90#endif
91
92  /**
93   * \struct map
94   * \brief KVP linked list
95   *
96   * Deal with WPS KVP (name,value).
97   * A map is defined as:
98   *  - name : a key,
99   *  - value: a value,
100   *  - next : a pointer to the next map if any.
101   */
102  typedef struct map{
103    char* name;
104    char* value;
105    struct map* next;
106  } map;
107
108#ifdef WIN32
109#define NULLMAP ((map*) 0)
110#else
111#define NULLMAP NULL
112#endif
113
114  /**
115   * \struct maps
116   * \brief linked list of map pointer
117   *
118   * Small object to store WPS KVP set.
119   * Maps is defined as:
120   *  - a name,
121   *  - a content map,
122   *  - a pointer to the next maps if any.
123   */
124  typedef struct maps{
125    char* name;         
126    struct map* content; 
127    struct maps* next;   
128  } maps;
129
130  /**
131   * \brief Dump a map on stderr
132   */
133  static void _dumpMap(map* t){
134    if(t!=NULL){
135      fprintf(stderr,"[%s] => [%s] \n",t->name,t->value);
136      fflush(stderr);
137        }else{
138      fprintf(stderr,"NULL\n");
139      fflush(stderr);
140    }
141  }
142
143  static void dumpMap(map* t){
144    map* tmp=t;
145    while(tmp!=NULL){
146      _dumpMap(tmp);
147      tmp=tmp->next;
148    }
149  }
150
151  static void dumpMapToFile(map* t,FILE* file){
152    map* tmp=t;
153    while(tmp!=NULL){
154#ifdef DEBUG
155      fprintf(stderr,"%s = %s\n",tmp->name,tmp->value);
156#endif
157      fprintf(file,"%s = %s\n",tmp->name,tmp->value);
158      tmp=tmp->next;
159    }
160  }
161
162  static void dumpMaps(maps* m){
163    maps* tmp=m;
164    while(tmp!=NULL){
165      fprintf(stderr,"MAP => [%s] \n",tmp->name);
166      dumpMap(tmp->content);
167      tmp=tmp->next;
168    }
169  }
170
171  static void dumpMapsToFile(maps* m,char* file_path){
172    FILE* file=fopen(file_path,"w");
173    maps* tmp=m;
174    if(tmp!=NULL){
175      fprintf(file,"[%s]\n",tmp->name);
176      dumpMapToFile(tmp->content,file);
177      fflush(file);
178    }
179    fclose(file);
180  }
181
182  static map* createMap(const char* name,const char* value){
183    map* tmp=(map *)malloc(MAP_SIZE);
184    tmp->name=zStrdup(name);
185    tmp->value=zStrdup(value);
186    tmp->next=NULL;
187    return tmp;
188  }
189
190  static int count(map* m){
191    map* tmp=m;
192    int c=0;
193    while(tmp!=NULL){
194      c++;
195      tmp=tmp->next;
196    }
197    return c;
198  }
199   
200  static bool hasKey(map* m,const char *key){
201    map* tmp=m;
202    while(tmp!=NULL){
203      if(strcasecmp(tmp->name,key)==0)
204        return true;
205      tmp=tmp->next;
206    }
207#ifdef DEBUG_MAP
208    fprintf(stderr,"NOT FOUND \n");
209#endif
210    return false;
211  }
212
213  static maps* getMaps(maps* m,const char *key){
214    maps* tmp=m;
215    while(tmp!=NULL){
216      if(strcasecmp(tmp->name,key)==0){
217        return tmp;
218      }
219      tmp=tmp->next;
220    }
221    return NULL;
222  }
223
224  static map* getMap(map* m,const char *key){
225    map* tmp=m;
226    while(tmp!=NULL){
227      if(strcasecmp(tmp->name,key)==0){
228        return tmp;
229      }
230      tmp=tmp->next;
231    }
232    return NULL;
233  }
234
235
236  static map* getLastMap(map* m){
237    map* tmp=m;
238    while(tmp!=NULL){
239      if(tmp->next==NULL){
240        return tmp;
241      }
242      tmp=tmp->next;
243    }
244    return NULL;
245  }
246
247  static map* getMapFromMaps(maps* m,const char* key,const char* subkey){
248    maps* _tmpm=getMaps(m,key);
249    if(_tmpm!=NULL){
250      map* _ztmpm=getMap(_tmpm->content,subkey);
251      return _ztmpm;
252    }
253    else return NULL;
254  }
255
256
257  static void freeMap(map** mo){
258    map* _cursor=*mo;
259    if(_cursor!=NULL){
260#ifdef DEBUG
261      fprintf(stderr,"freeMap\n");
262#endif
263      free(_cursor->name);
264      free(_cursor->value);
265      if(_cursor->next!=NULL){
266        freeMap(&_cursor->next);
267        free(_cursor->next);
268      }
269    }
270  }
271
272  static void freeMaps(maps** mo){
273    maps* _cursor=*mo;
274    fflush(stderr);
275    if(_cursor && _cursor!=NULL){
276#ifdef DEBUG
277      fprintf(stderr,"freeMaps\n");
278#endif
279      free(_cursor->name);
280      if(_cursor->content!=NULL){
281        freeMap(&_cursor->content);
282        free(_cursor->content);
283      }
284      if(_cursor->next!=NULL){
285        freeMaps(&_cursor->next);
286        free(_cursor->next);
287      }
288    }
289  }
290
291  /**
292   * \brief Not named linked list
293   *
294   * Used to store informations about formats, such as mimeType, encoding ...
295   *
296   * An iotype is defined as :
297   *  - a content map,
298   *  - a pointer to the next iotype if any.
299   */
300  typedef struct iotype{
301    struct map* content;
302    struct iotype* next;
303  } iotype;
304
305  /**
306   * \brief Metadata information about input or output.
307   *
308   * The elements are used to store metadata informations defined in the ZCFG.
309   *
310   * An elements is defined as :
311   *  - a name,
312   *  - a content map,
313   *  - a metadata map,
314   *  - a format (possible values are LiteralData, ComplexData or
315   * BoundingBoxData),
316   *  - a default iotype,
317   *  - a pointer to the next elements id any.
318   */
319  typedef struct elements{
320    char* name;
321    struct map* content;
322    struct map* metadata;
323    char* format;
324    struct iotype* defaults;
325    struct iotype* supported;
326    struct elements* next;
327  } elements;
328
329  typedef struct service{
330    char* name;
331    struct map* content;
332    struct map* metadata;
333    struct elements* inputs;
334    struct elements* outputs; 
335  } service;
336
337  typedef struct services{
338    struct service* content; 
339    struct services* next; 
340  } services;
341
342  static bool hasElement(elements* e,const char* key){
343    elements* tmp=e;
344    while(tmp!=NULL){
345      if(strcasecmp(key,tmp->name)==0)
346        return true;
347      tmp=tmp->next;
348    }
349    return false;
350  }
351
352  static elements* getElements(elements* m,char *key){
353    elements* tmp=m;
354    while(tmp!=NULL){
355      if(strcasecmp(tmp->name,key)==0)
356        return tmp;
357      tmp=tmp->next;
358    }
359    return NULL;
360  }
361
362
363  static void freeIOType(iotype** i){
364    iotype* _cursor=*i;
365    if(_cursor!=NULL){
366      if(_cursor->next!=NULL){
367        freeIOType(&_cursor->next);
368        free(_cursor->next);
369      }
370      freeMap(&_cursor->content);
371      free(_cursor->content);
372    }
373  }
374
375  static void freeElements(elements** e){
376    elements* tmp=*e;
377    if(tmp!=NULL){
378      if(tmp->name!=NULL)
379        free(tmp->name);
380      freeMap(&tmp->content);
381      if(tmp->content!=NULL)
382        free(tmp->content);
383      freeMap(&tmp->metadata);
384      if(tmp->metadata!=NULL)
385        free(tmp->metadata);
386      if(tmp->format!=NULL)
387        free(tmp->format);
388      freeIOType(&tmp->defaults);
389      if(tmp->defaults!=NULL)
390        free(tmp->defaults);
391      freeIOType(&tmp->supported);
392      if(tmp->supported!=NULL){
393        free(tmp->supported);
394      }
395      freeElements(&tmp->next);
396      if(tmp->next!=NULL)
397        free(tmp->next);
398    }
399  }
400
401  static void freeService(service** s){
402    service* tmp=*s;
403    if(tmp!=NULL){
404      if(tmp->name!=NULL)
405        free(tmp->name);
406      freeMap(&tmp->content);
407      if(tmp->content!=NULL)
408        free(tmp->content);
409      freeMap(&tmp->metadata);
410      if(tmp->metadata!=NULL)
411        free(tmp->metadata);
412      freeElements(&tmp->inputs);
413      if(tmp->inputs!=NULL)
414        free(tmp->inputs);
415      freeElements(&tmp->outputs);
416      if(tmp->outputs!=NULL)
417        free(tmp->outputs);
418    }
419  }
420
421  static void addToMap(map* m,const char* n,const char* v){
422    if(hasKey(m,n)==false){
423      map* _cursor=m;
424      while(_cursor->next!=NULL)
425        _cursor=_cursor->next;
426      _cursor->next=createMap(n,v);
427    }
428    else{
429      map *tmp=getMap(m,n);
430      if(tmp->value!=NULL)
431        free(tmp->value);
432      tmp->value=zStrdup(v);
433    }
434  }
435
436  static void addMapToMap(map** mo,map* mi){
437    map* tmp=mi;
438    map* _cursor=*mo;
439    if(tmp==NULL){
440      if(_cursor!=NULL){
441        while(_cursor!=NULL)
442          _cursor=_cursor->next;
443        _cursor=NULL;
444      }else
445        *mo=NULL;
446    }
447    while(tmp!=NULL){
448      if(_cursor==NULL){
449        if(*mo==NULL)
450          *mo=createMap(tmp->name,tmp->value);
451        else
452          addToMap(*mo,tmp->name,tmp->value);
453      }
454      else{
455#ifdef DEBUG
456        fprintf(stderr,"_CURSOR\n");
457        dumpMap(_cursor);
458#endif
459        while(_cursor!=NULL)
460          _cursor=_cursor->next;
461        _cursor=createMap(tmp->name,tmp->value);
462        _cursor->next=NULL;
463      }
464      tmp=tmp->next;
465#ifdef DEBUG
466      fprintf(stderr,"MO\n");
467      dumpMap(*mo);
468#endif
469    }
470  }
471
472  static void addMapToIoType(iotype** io,map* mi){
473    iotype* tmp=*io;
474    while(tmp->next!=NULL){
475      tmp=tmp->next;
476    }
477    tmp->next=(iotype*)malloc(IOTYPE_SIZE);
478    tmp->next->content=NULL;
479    addMapToMap(&tmp->next->content,mi);
480    tmp->next->next=NULL;
481  }
482
483  static map* getMapOrFill(map* m,const char *key,char* value){
484    map* tmp=m;
485    map* tmpMap=getMap(tmp,key);
486    if(tmpMap==NULL){
487      if(tmp!=NULL)
488        addToMap(tmp,key,value);
489      else
490        tmp=createMap(key,value);
491      tmpMap=getMap(tmp,key);
492    }
493    return tmpMap;
494  }
495
496  static bool contains(map* m,map* i){
497    while(i!=NULL){     
498      if(strcasecmp(i->name,"value")!=0 &&
499         strcasecmp(i->name,"xlink:href")!=0 &&
500         strcasecmp(i->name,"useMapServer")!=0 &&
501         strcasecmp(i->name,"asReference")!=0){
502        map *tmp;
503        if(hasKey(m,i->name) && (tmp=getMap(m,i->name))!=NULL && 
504           strcasecmp(i->value,tmp->value)!=0)
505          return false;
506      }
507      i=i->next;
508    }
509    return true;
510  }
511
512  static iotype* getIoTypeFromElement(elements* e,char *name, map* values){
513    elements* cursor=e;
514    while(cursor!=NULL){
515      if(strcasecmp(cursor->name,name)==0){
516        if(contains(cursor->defaults->content,values)==true)
517          return cursor->defaults;
518        else{
519          iotype* tmp=cursor->supported;
520          while(tmp!=NULL){
521            if(contains(tmp->content,values)==true)
522              return tmp;           
523            tmp=tmp->next;
524          }
525        }
526      }
527      cursor=cursor->next;
528    }
529    return NULL;
530  }
531
532  static maps* dupMaps(maps** mo){
533    maps* _cursor=*mo;
534    maps* res=NULL;
535    if(_cursor!=NULL){
536      res=(maps*)malloc(MAPS_SIZE);
537      res->name=zStrdup(_cursor->name);
538      res->content=NULL;
539      res->next=NULL;
540      map* mc=_cursor->content;
541      map* tmp=getMap(mc,"size");
542      char* tmpSized=NULL;
543      if(tmp!=NULL){
544        map* tmpV=getMap(mc,"value");
545        tmpSized=(char*)malloc((atoi(tmp->value)+1)*sizeof(char));
546        memmove(tmpSized,tmpV->value,atoi(tmp->value)*sizeof(char));
547      }
548      if(mc!=NULL){
549        addMapToMap(&res->content,mc);
550      }
551      if(tmp!=NULL){
552        map* tmpV=getMap(res->content,"value");
553        free(tmpV->value);
554        tmpV->value=(char*)malloc((atoi(tmp->value)+1)*sizeof(char));
555        memmove(tmpV->value,tmpSized,atoi(tmp->value)*sizeof(char));
556        tmpV->value[atoi(tmp->value)]=0;
557        free(tmpSized);
558      }
559      res->next=dupMaps(&_cursor->next);
560    }
561    return res;
562  }
563
564  static void addMapsToMaps(maps** mo,maps* mi){
565    maps* tmp=mi;
566    maps* _cursor=*mo;
567    while(tmp!=NULL){
568      if(_cursor==NULL){
569        *mo=dupMaps(&mi);
570        (*mo)->next=NULL;
571      }
572      else{
573        while(_cursor->next!=NULL)
574          _cursor=_cursor->next;
575        _cursor->next=dupMaps(&tmp);
576      }
577      tmp=tmp->next;
578    }
579  }
580
581  static map* getMapArray(map* m,char* key,int index){
582    char tmp[1024];
583    if(index>0)
584      sprintf(tmp,"%s_%d",key,index);
585    else
586      sprintf(tmp,"%s",key);
587#ifdef DEBUG
588    fprintf(stderr,"** KEY %s\n",tmp);
589#endif
590    map* tmpMap=getMap(m,tmp);
591#ifdef DEBUG
592    if(tmpMap!=NULL)
593      dumpMap(tmpMap);
594#endif
595    return tmpMap;
596  }
597
598
599  static void setMapArray(map* m,char* key,int index,char* value){
600    char tmp[1024];
601    if(index>0)
602      sprintf(tmp,"%s_%d",key,index);
603    else
604      sprintf(tmp,"%s",key);
605    map* tmpSize=getMapArray(m,"size",index);
606    if(tmpSize!=NULL && strncasecmp(key,"value",5)==0){
607#ifdef DEBUG
608      fprintf(stderr,"%s\n",tmpSize->value);
609#endif
610      map* ptr=getMapOrFill(m,tmp,"");
611      free(ptr->value);
612      ptr->value=(char*)malloc((atoi(tmpSize->value)+1)*sizeof(char));
613      memcpy(ptr->value,value,atoi(tmpSize->value)); 
614    }
615    else
616      addToMap(m,tmp,value);
617  }
618
619  static map* getMapType(map* mt){
620    map* tmap=getMap(mt,"mimeType");
621    if(tmap==NULL){
622      tmap=getMap(mt,"dataType");
623      if(tmap==NULL){
624        tmap=getMap(mt,"CRS");
625      }
626    }
627#ifdef DEBUG
628        dumpMap(tmap);
629#endif
630    return tmap;
631  }
632
633  static int addMapsArrayToMaps(maps** mo,maps* mi,char* typ){
634    maps* tmp=mi;   
635    maps* _cursor=getMaps(*mo,tmp->name);
636
637    if(_cursor==NULL)
638      return -1;
639
640    map* tmpLength=getMap(_cursor->content,"length");
641    char tmpLen[10];
642    int len=1;
643    if(tmpLength!=NULL){
644      len=atoi(tmpLength->value);
645    }
646
647    char *tmpV[8]={
648      "size",
649      "value",
650      "uom",
651      "Reference",
652      "xlink:href",
653      typ,
654      "schema",
655      "encoding"
656    };
657    sprintf(tmpLen,"%d",len+1);
658    addToMap(_cursor->content,"length",tmpLen);
659    int i=0;
660    map* tmpSizeI=getMap(tmp->content,tmpV[i]);
661    for(i=0;i<8;i++){
662      map* tmpVI=getMap(tmp->content,tmpV[i]);
663      if(tmpVI!=NULL){
664#ifdef DEBUG
665        fprintf(stderr,"%s = %s\n",tmpV[i],tmpVI->value);
666#endif
667        if(i<5)
668          setMapArray(_cursor->content,tmpV[i],len,tmpVI->value);
669        else
670          if(strncasecmp(tmpV[5],"mimeType",8)==0)
671            setMapArray(_cursor->content,tmpV[i],len,tmpVI->value);
672      }
673    }
674   
675    addToMap(_cursor->content,"isArray","true");
676    return 0;
677  }
678
679  static void setMapInMaps(maps* m,const char* key,const char* subkey,const char *value){
680    maps* _tmpm=getMaps(m,key);
681    if(_tmpm!=NULL){
682      map* _ztmpm=getMap(_tmpm->content,subkey);
683      if(_ztmpm!=NULL){
684        if(_ztmpm->value!=NULL)
685          free(_ztmpm->value);
686        _ztmpm->value=zStrdup(value);
687      }else{
688        addToMap(_tmpm->content,subkey,value);
689      }
690    }else{
691      maps *tmp=(maps*)malloc(MAPS_SIZE);
692      tmp->name=zStrdup(key);
693      tmp->content=createMap(subkey,value);
694      tmp->next=NULL;
695      addMapsToMaps(&m,tmp);
696      freeMaps(&tmp);
697      free(tmp);
698    }
699  }
700
701
702  static void dumpElements(elements* e){
703    elements* tmp=e;
704    while(tmp!=NULL){
705      fprintf(stderr,"ELEMENT [%s]\n",tmp->name);
706      fprintf(stderr," > CONTENT [%s]\n",tmp->name);
707      dumpMap(tmp->content);
708      fprintf(stderr," > METADATA [%s]\n",tmp->name);
709      dumpMap(tmp->metadata);
710      fprintf(stderr," > FORMAT [%s]\n",tmp->format);
711      iotype* tmpio=tmp->defaults;
712      int ioc=0;
713      while(tmpio!=NULL){
714        fprintf(stderr," > DEFAULTS [%s] (%i)\n",tmp->name,ioc);
715        dumpMap(tmpio->content);
716        tmpio=tmpio->next;
717        ioc++;
718      }
719      tmpio=tmp->supported;
720      ioc=0;
721      while(tmpio!=NULL){
722        fprintf(stderr," > SUPPORTED [%s] (%i)\n",tmp->name,ioc);
723        dumpMap(tmpio->content);
724        tmpio=tmpio->next;
725        ioc++;
726      }
727      fprintf(stderr,"------------------\n");
728      tmp=tmp->next;
729    }
730  }
731
732  static elements* dupElements(elements* e){
733    elements* cursor=e;
734    elements* tmp=NULL;
735    if(cursor!=NULL){
736#ifdef DEBUG
737      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
738      dumpElements(e);
739      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
740#endif
741      tmp=(elements*)malloc(ELEMENTS_SIZE);
742      tmp->name=zStrdup(e->name);
743      tmp->content=NULL;
744      addMapToMap(&tmp->content,e->content);
745      tmp->metadata=NULL;
746      addMapToMap(&tmp->metadata,e->metadata);
747      tmp->format=zStrdup(e->format);
748      if(e->defaults!=NULL){
749        tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
750        tmp->defaults->content=NULL;
751        addMapToMap(&tmp->defaults->content,e->defaults->content);
752        tmp->defaults->next=NULL;
753#ifdef DEBUG
754        fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
755        dumpMap(tmp->defaults->content);
756#endif
757      }else
758        tmp->defaults=NULL;
759      if(e->supported!=NULL){
760        tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
761        tmp->supported->content=NULL;
762        addMapToMap(&tmp->supported->content,e->supported->content);
763        tmp->supported->next=NULL;
764        iotype *tmp2=e->supported->next;
765        while(tmp2!=NULL){
766          addMapToIoType(&tmp->supported,tmp2->content);
767#ifdef DEBUG
768          fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
769          dumpMap(tmp->defaults->content);
770#endif
771          tmp2=tmp2->next;
772        }
773      }
774      else
775        tmp->supported=NULL;
776      tmp->next=dupElements(cursor->next);
777    }
778    return tmp;
779  }
780
781  static void addToElements(elements** m,elements* e){
782    elements* tmp=e;
783    if(*m==NULL){
784      *m=dupElements(tmp);
785    }else{
786      addToElements(&(*m)->next,tmp);
787    }
788  }
789
790  static void dumpService(service* s){
791    fprintf(stderr,"++++++++++++++++++\nSERVICE [%s]\n++++++++++++++++++\n",s->name);
792    if(s->content!=NULL){
793      fprintf(stderr,"CONTENT MAP\n");
794      dumpMap(s->content);
795      fprintf(stderr,"CONTENT METADATA\n");
796      dumpMap(s->metadata);
797    }
798    if(s->inputs!=NULL){
799      fprintf(stderr,"INPUT ELEMENTS [%s]\n------------------\n",s->name);
800      dumpElements(s->inputs);
801    }
802    if(s->outputs!=NULL){
803      fprintf(stderr,"OUTPUT ELEMENTS [%s]\n------------------\n",s->name);
804      dumpElements(s->outputs);
805    }
806    fprintf(stderr,"++++++++++++++++++\n");
807  }
808
809  static void mapsToCharXXX(maps* m,char*** c){
810    maps* tm=m;
811    int i=0;
812    int j=0;
813    char tmp[10][30][1024];
814    memset(tmp,0,1024*10*10);
815    while(tm!=NULL){
816      if(i>=10)
817        break;
818      strcpy(tmp[i][j],"name");
819      j++;
820      strcpy(tmp[i][j],tm->name);
821      j++;
822      map* tc=tm->content;
823      while(tc!=NULL){
824        if(j>=30)
825          break;
826        strcpy(tmp[i][j],tc->name);
827        j++;
828        strcpy(tmp[i][j],tc->value);
829        j++;
830        tc=tc->next;
831      }
832      tm=tm->next;
833      j=0;
834      i++;
835    }
836    memcpy(c,tmp,10*10*1024);
837  }
838
839  static void charxxxToMaps(char*** c,maps**m){
840    maps* trorf=*m;
841    int i,j;
842    char tmp[10][30][1024];
843    memcpy(tmp,c,10*30*1024);
844    for(i=0;i<10;i++){
845      if(strlen(tmp[i][1])==0)
846        break;
847      trorf->name=tmp[i][1];
848      trorf->content=NULL;
849      trorf->next=NULL;
850      for(j=2;j<29;j+=2){
851        if(strlen(tmp[i][j+1])==0)
852          break;
853        if(trorf->content==NULL)
854          trorf->content=createMap(tmp[i][j],tmp[i][j+1]);
855        else
856          addToMap(trorf->content,tmp[i][j],tmp[i][j+1]);
857      }
858      trorf=trorf->next;
859    }
860    m=&trorf;
861  }
862
863#ifdef WIN32
864  extern char *url_encode(char *);
865
866  static char* getMapsAsKVP(maps* m,int length,int type){
867    char *dataInputsKVP=(char*) malloc(length*sizeof(char));
868    char *dataInputsKVPi=NULL;
869    maps* curs=m;
870    int i=0;
871    while(curs!=NULL){
872      map *inRequest=getMap(curs->content,"inRequest");
873      map *hasLength=getMap(curs->content,"length");
874      if((inRequest!=NULL && strncasecmp(inRequest->value,"true",4)==0) ||
875         inRequest==NULL){
876        if(i==0)
877          if(type==0){
878            sprintf(dataInputsKVP,"%s=",curs->name);
879            if(hasLength!=NULL){
880              dataInputsKVPi=(char*)malloc((strlen(curs->name)+2)*sizeof(char));
881              sprintf(dataInputsKVPi,"%s=",curs->name);
882            }
883          }
884          else
885            sprintf(dataInputsKVP,"%s",curs->name);
886        else{
887          char *temp=zStrdup(dataInputsKVP);
888          if(type==0)
889            sprintf(dataInputsKVP,"%s;%s=",temp,curs->name);
890          else
891            sprintf(dataInputsKVP,"%s;%s",temp,curs->name);
892        }
893        map* icurs=curs->content;
894        if(type==0){
895          char *temp=zStrdup(dataInputsKVP);
896          if(getMap(curs->content,"xlink:href")!=NULL)
897            sprintf(dataInputsKVP,"%sReference",temp);
898          else{
899            if(hasLength!=NULL){
900              for(int j=0;j<atoi(hasLength->value);j++){
901                map* tmp0=getMapArray(curs->content,"value",j);
902                if(j==0)
903                  free(temp);
904                temp=zStrdup(dataInputsKVP);
905                if(j==0)
906                  sprintf(dataInputsKVP,"%s%s",temp,tmp0->value);
907                else
908                  sprintf(dataInputsKVP,"%s;%s%s",temp,dataInputsKVPi,tmp0->value);
909              }
910            }
911            else
912              sprintf(dataInputsKVP,"%s%s",temp,icurs->value);
913          }
914          free(temp);
915        }
916        while(icurs!=NULL){
917          if(strncasecmp(icurs->name,"value",5)!=0 &&
918             strncasecmp(icurs->name,"mimeType_",9)!=0 &&
919             strncasecmp(icurs->name,"dataType_",9)!=0 &&
920             strncasecmp(icurs->name,"size",4)!=0 &&
921             strncasecmp(icurs->name,"length",4)!=0 &&
922             strncasecmp(icurs->name,"isArray",7)!=0 &&
923             strcasecmp(icurs->name,"Reference")!=0 &&
924             strcasecmp(icurs->name,"minOccurs")!=0 &&
925             strcasecmp(icurs->name,"maxOccurs")!=0 &&
926             strncasecmp(icurs->name,"fmimeType",9)!=0 &&
927             strcasecmp(icurs->name,"inRequest")!=0){
928            char *itemp=zStrdup(dataInputsKVP);
929            if(strcasecmp(icurs->name,"xlink:href")!=0)
930              sprintf(dataInputsKVP,"%s@%s=%s",itemp,icurs->name,icurs->value);
931            else
932              sprintf(dataInputsKVP,"%s@%s=%s",itemp,icurs->name,url_encode(icurs->value));
933            free(itemp);
934          }
935          icurs=icurs->next;
936        }
937      }
938      curs=curs->next;
939      i++;
940    }
941    return dataInputsKVP;
942  }
943#endif
944
945#ifdef __cplusplus
946}
947#endif
948
949#endif
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