source: trunk/zoo-project/zoo-kernel/service_internal.c @ 756

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

Redefined the API function addToMapWithSize to fix problem with Python/PHP support. Added some variable initializations and NULL pointer checks.

  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 18.5 KB
RevLine 
[579]1/*
[1]2 * Author : Gérald FENOY
3 *
[576]4 * Copyright (c) 2009-2015 GeoLabs SARL
[1]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
[730]25#define _LARGEFILE64_SOURCE 1
[649]26#ifdef USE_MS
27#include "service_internal_ms.h"
28#else
29#include "cpl_vsi.h"
30#endif
[703]31#include "service_internal.h"
[216]32
[365]33#ifndef TRUE
34#define TRUE 1
35#endif
36#ifndef FALSE
37#define FALSE -1
38#endif
39
[578]40#define ERROR_MSG_MAX_LENGTH 1024
[652]41#ifndef RELY_ON_DB
42#include <dirent.h>
[578]43
[579]44/**
[652]45 * Read the sid file attached of a service if any
[579]46 *
47 * @param conf the maps containing the setting of the main.cfg file
48 * @param pid the service identifier (usid key from the [lenv] section)
[652]49 * @return the reported status char* (temporary/final result)
[579]50 */
[652]51char* getStatusId(maps* conf,char* pid){
52  map* r_inputs = getMapFromMaps (conf, "main", "tmpPath");
53  char* fbkpid =
54    (char *)
55    malloc ((strlen (r_inputs->value) + strlen (pid) + 7) * sizeof (char));
56  sprintf (fbkpid, "%s/%s.sid", r_inputs->value, pid);
57  FILE* f0 = fopen (fbkpid, "r");
58  if(f0!=NULL){
[653]59    long flen;
60    char *fcontent;
[652]61    fseek (f0, 0, SEEK_END);
[653]62    flen = ftell (f0);
[652]63    fseek (f0, 0, SEEK_SET);
[653]64    fcontent = (char *) malloc ((flen + 1) * sizeof (char));
65    fread(fcontent,flen,1,f0);
66    fcontent[flen]=0;
[652]67    fclose(f0);
[653]68    return fcontent;
[652]69  }else
70    return NULL;
71}
72
73/**
74 * Acquire the global lock
75 *
76 * @param conf the maps containing the setting of the main.cfg file
77 * @return a semid
78 */
79semid acquireLock(maps* conf){
80  semid lockid;
81  int itn=0;
82 toRetry1:
83  lockid=getShmLockId(conf,1);
[507]84  if(
[216]85#ifdef WIN32
[507]86     lockid==NULL
87#else
88     lockid<0
89#endif
90     ){
[652]91#ifdef WIN32
[680]92    return NULL;
[652]93#else
94    return -1;
95#endif
[507]96  }
97  if(lockShm(lockid)<0){
[680]98#ifdef WIN32
99      return NULL;
100#else
[652]101    if(itn<ZOO_LOCK_MAX_RETRY){
102      itn++;
103      goto toRetry1;
104    }else
[680]105      return -1;
[652]106#endif
107  }else
108    return lockid;
109}
110
111/**
112 * Read the cache file of a running service
113 *
114 * @param conf the maps containing the setting of the main.cfg file
115 * @param pid the service identifier (usid key from the [lenv] section)
116 * @return the reported status char* (temporary/final result)
117 */
118char* _getStatusFile(maps* conf,char* pid){
119  map* tmpTmap = getMapFromMaps (conf, "main", "tmpPath");
120
121  struct dirent *dp;
122  DIR *dirp = opendir(tmpTmap->value);
123  char fileName[1024];
124  int hasFile=-1;
125  if(dirp!=NULL){
126    char tmp[128];
127    sprintf(tmp,"_%s.xml",pid);
128    while ((dp = readdir(dirp)) != NULL){
129#ifdef DEBUG
130      fprintf(stderr,"File : %s searched : %s\n",dp->d_name,tmp);
131#endif
132      if(strstr(dp->d_name,"final_")==0 && strstr(dp->d_name,tmp)!=0){
133        sprintf(fileName,"%s/%s",tmpTmap->value,dp->d_name);
134        hasFile=1;
135        break;
136      }
137    }
[507]138  }
[652]139  if(hasFile>0){
140    semid lockid;
141    char* stat=getStatusId(conf,pid);
142    if(stat!=NULL){
143      setMapInMaps(conf,"lenv","lid",stat);
144      lockid=acquireLock(conf);
145      if(lockid<0)
146        return NULL;
147    }
148
149    FILE* f0 = fopen (fileName, "r");
150    if(f0!=NULL){
151      fseek (f0, 0, SEEK_END);
152      long flen = ftell (f0);
153      fseek (f0, 0, SEEK_SET);
154      char *tmps1 = (char *) malloc ((flen + 1) * sizeof (char));
155      fread(tmps1,flen,1,f0);
156      tmps1[flen]=0;
157      fclose(f0);
158      if(stat!=NULL){
159        unlockShm(lockid);
160        free(stat);
161      }
162
163      return tmps1;
164    }
165    else{
166      if(stat!=NULL){
167        unlockShm(lockid);
168        free(stat);
169      }
170      return NULL;
171    }
172  }
173  else
174    return NULL;
175}
176
177/**
178 * Get the ongoing status of a running service
179 *
180 * @param conf the maps containing the setting of the main.cfg file
181 * @param pid the service identifier (usid key from the [lenv] section)
182 * @return the reported status char* (MESSAGE|POURCENTAGE)
183 */
184char* _getStatus(maps* conf,char* lid){
185  map* r_inputs = getMapFromMaps (conf, "main", "tmpPath");
186  char* fbkpid =
187    (char *)
188    malloc ((strlen (r_inputs->value) + strlen (lid) + 9) * sizeof (char));
189  sprintf (fbkpid, "%s/%s.status", r_inputs->value, lid);
190  FILE* f0 = fopen (fbkpid, "r");
[738]191  if(f0!=NULL){   
192    semid lockid = NULL;
[653]193    char* stat;
194    long flen;
195    stat=getStatusId(conf,lid);
[652]196    if(stat!=NULL){
197      setMapInMaps(conf,"lenv","lid",stat);
[653]198      lockid=acquireLock(conf);
[652]199      if(lockid<0)
200        return NULL;
201    }
202    fseek (f0, 0, SEEK_END);
[653]203    flen = ftell (f0);
[652]204    if(flen>0){
[653]205      char *fcontent;
[652]206      fseek (f0, 0, SEEK_SET);
[653]207      fcontent = (char *) malloc ((flen + 1) * sizeof (char));
208      fread(fcontent,flen,1,f0);
209      fcontent[flen]=0;
[652]210      fclose(f0);
211      free(fbkpid);
212      if(stat!=NULL){
[680]213#ifndef WIN32
[652]214        removeShmLock(conf,1);
[680]215#else
216        unlockShm(lockid);
217#endif
[652]218        free(stat);
219      }
[653]220      return fcontent;
[652]221    }
222    fclose(f0);
223    free(fbkpid);
224    if(stat!=NULL){
225      removeShmLock(conf,1);
226      free(stat);
227    }
228    return NULL;
229  }else{
230    free(fbkpid);
231    char* stat=getStatusId(conf,lid);
232    setMapInMaps(conf,"lenv","lid",stat);
[507]233    removeShmLock(conf,1);
[652]234    return NULL;
[507]235  }
236}
[216]237
[652]238/**
239 * Stop handling status repport.
240 *
241 * @param conf the map containing the setting of the main.cfg file
242 */
243void unhandleStatus(maps *conf){
244  map* r_inputs = getMapFromMaps (conf, "main", "tmpPath");
245  map* usid = getMapFromMaps (conf, "lenv", "usid");
246  char* fbkpid =
247    (char *) malloc ((strlen (r_inputs->value) + strlen (usid->value) + 9) 
248                     * sizeof (char));
249  sprintf (fbkpid, "%s/%s.status", r_inputs->value, usid->value);
250  unlink(fbkpid);
251  free(fbkpid);
252}
253
254/**
255 * Update the current status of the running service.
256 *
257 * @see acquireLock, lockShm
258 * @param conf the map containing the setting of the main.cfg file
259 * @return 0 on success, -2 if shmget failed, -1 if shmat failed
260 */
261int _updateStatus(maps *conf){
262  map* r_inputs = getMapFromMaps (conf, "main", "tmpPath");
263  map* sid = getMapFromMaps (conf, "lenv", "usid");
264  char* fbkpid =
265    (char *)
266    malloc ((strlen (r_inputs->value) + strlen (sid->value) + 9) * sizeof (char));
267  sprintf (fbkpid, "%s/%s.status", r_inputs->value, sid->value);
268  map* status=getMapFromMaps(conf,"lenv","status");
269  map* msg=getMapFromMaps(conf,"lenv","message");
270  if(status!=NULL && msg!=NULL &&
271     status->value!=NULL && msg->value!=NULL && 
[738]272     strlen(status->value)>0 && strlen(msg->value)>1){   
273    semid lockid = NULL;
[652]274    char* stat=getStatusId(conf,sid->value);
275    if(stat!=NULL){
276      lockid=acquireLock(conf);
[680]277      if(lockid<0){
278        dumpMap(status);
[652]279        return ZOO_LOCK_ACQUIRE_FAILED;
[680]280      }
[652]281    }
282    FILE* fstatus=fopen(fbkpid,"w");
283    if(fstatus!=NULL){
[654]284      fprintf(fstatus,"%s|%s",status->value,msg->value);
[652]285      fflush(fstatus);
286      fclose(fstatus);
287    }
288    if(stat!=NULL){
289      unlockShm(lockid);
290      free(stat);
291    }
292  }
293  return 0;
294}
295
296#endif
297
[507]298#ifdef WIN32
299
[216]300#define SHMEMSIZE 4096
301
[554]302size_t getKeyValue(maps* conf, char* key, size_t length){
303  if(conf==NULL) {
[579]304    strncpy(key, "700666", length);
305    return strlen(key);
[554]306  }
307 
[507]308  map *tmpMap=getMapFromMaps(conf,"lenv","lid");
309  if(tmpMap==NULL)
[680]310    tmpMap=getMapFromMaps(conf,"lenv","osid");
[554]311
[507]312  if(tmpMap!=NULL){
[680]313    snprintf(key, length, "zoo_sem_%s", tmpMap->value);     
[507]314  }
[554]315  else {
[680]316    strncpy(key, "-1", length);
[554]317  }
318  return strlen(key);
[579]319}
320
321
[507]322semid getShmLockId(maps* conf, int nsems){
[680]323  semid sem_id;
324  char key[MAX_PATH];
325  getKeyValue(conf, key, MAX_PATH);
326 
327  sem_id = CreateSemaphore( NULL, nsems, nsems+1, key);
328  if(sem_id==NULL){
[507]329#ifdef DEBUG
[680]330    fprintf(stderr,"Semaphore failed to create: %s\n", getLastErrorMessage());
[507]331#endif
[680]332    return NULL;
333  }
[507]334#ifdef DEBUG
[680]335  fprintf(stderr,"%s Accessed !\n",key);
[507]336#endif
[680]337  return sem_id;
[507]338}
339
340int removeShmLock(maps* conf, int nsems){
341  semid sem_id=getShmLockId(conf,1);
342  if (CloseHandle(sem_id) == 0) {
[652]343#ifdef DEBUG
[578]344    fprintf(stderr,"Unable to remove semaphore: %s\n", getLastErrorMessage());
[652]345#endif
[507]346    return -1;
347  }
348#ifdef DEBUG
349  fprintf(stderr,"%d Removed !\n",sem_id);
350#endif
351  return 0;
352}
353
354int lockShm(semid id){
355  DWORD dwWaitResult=WaitForSingleObject(id,INFINITE);
356  switch (dwWaitResult){
357    case WAIT_OBJECT_0:
358      return 0;
359      break;
360    case WAIT_TIMEOUT:
361      return -1;
362      break;
363    default:
364      return -2;
365      break;
366  }
367  return 0;
368}
369
370int unlockShm(semid id){
371  if(!ReleaseSemaphore(id,1,NULL)){
372    return -1;
373  }
374  return 0;
375}
376
[216]377static LPVOID lpvMemG = NULL;      // pointer to shared memory
378static HANDLE hMapObjectG = NULL;  // handle to file mapping
379
380
381char* getStatus(int pid){
[467]382  char *lpszBuf=(char*) malloc(SHMEMSIZE*sizeof(char));
[452]383  int i=0;
[216]384  LPWSTR lpszTmp=NULL;
385  LPVOID lpvMem = NULL;
386  HANDLE hMapObject = NULL;
387  BOOL fIgnore,fInit;
[507]388  char tmp[1024];
389  sprintf(tmp,"%d",pid);
[216]390  if(hMapObject==NULL)
391    hMapObject = CreateFileMapping( 
392                                   INVALID_HANDLE_VALUE,   // use paging file
393                                   NULL,                   // default security attributes
394                                   PAGE_READWRITE,         // read/write access
395                                   0,                      // size: high 32-bits
396                                   4096,                   // size: low 32-bits
397                                   TEXT(tmp));   // name of map object
[507]398  if (hMapObject == NULL){
399#ifdef DEBUG
400    fprintf(stderr,"ERROR on line %d\n",__LINE__);
401#endif
402    return "-1";
403  }
[216]404  if((GetLastError() != ERROR_ALREADY_EXISTS)){
[507]405#ifdef DEBUG
406    fprintf(stderr,"ERROR on line %d\n",__LINE__);
[578]407    fprintf(stderr,"READING STRING S %s\n", getLastErrorMessage());
[507]408#endif
[216]409    fIgnore = UnmapViewOfFile(lpvMem); 
410    fIgnore = CloseHandle(hMapObject);
411    return "-1";
412  }
413  fInit=TRUE;
414  if(lpvMem==NULL)
415    lpvMem = MapViewOfFile( 
416                           hMapObject,     // object to map view of
417                           FILE_MAP_READ,  // read/write access
418                           0,              // high offset:  map from
419                           0,              // low offset:   beginning
420                           0);             // default: map entire file
[507]421  if (lpvMem == NULL){
422#ifdef DEBUG
423    fprintf(stderr,"READING STRING S %d\n",__LINE__);
[578]424    fprintf(stderr,"READING STRING S %s\n", getLastErrorMessage());
[507]425#endif
[216]426    return "-1"; 
[507]427  }
[216]428  lpszTmp = (LPWSTR) lpvMem;
[452]429  while (*lpszTmp){
430    lpszBuf[i] = (char)*lpszTmp;
431    *lpszTmp++; 
432    lpszBuf[i+1] = '\0'; 
433    i++;
434  }
435  return (char*)lpszBuf;
[216]436}
437
438#else
[579]439/**
440 * Number of time to try to access a semaphores set
441 * @see getShmLockId
442 */
[507]443#define MAX_RETRIES 10
444
[509]445#ifndef __APPLE__
[630]446/**
447 * arg for semctl system calls.
448 */
[509]449union semun {
[630]450  int val; //!< value for SETVAL
451  struct semid_ds *buf; //!< buffer for IPC_STAT & IPC_SET
452  ushort *array; //!< array for GETALL & SETALL
[509]453};
454#endif
455
[579]456/**
[652]457 * Set in the pre-allocated key the zoo_sem_[OSID] string
458 * where [OSID] is the lid (if any) or osid value from the [lenv] section.
[579]459 *
460 * @param conf the map containing the setting of the main.cfg file
461 */
[507]462int getKeyValue(maps* conf){
[514]463  if(conf==NULL)
464     return 700666;
[507]465  map *tmpMap=getMapFromMaps(conf,"lenv","lid");
466  if(tmpMap==NULL)
[652]467    tmpMap=getMapFromMaps(conf,"lenv","osid");
[507]468  int key=-1;
469  if(tmpMap!=NULL)
470    key=atoi(tmpMap->value);
471  return key;
472}
473
[579]474/**
475 * Try to create or access a semaphore set.
476 *
477 * @see getKeyValue
478 * @param conf the map containing the setting of the main.cfg file
479 * @param nsems number of semaphores
480 * @return a semaphores set indentifier on success, -1 in other case
481 */
[507]482int getShmLockId(maps* conf, int nsems){
483    int i;
484    union semun arg;
485    struct semid_ds buf;
486    struct sembuf sb;
487    semid sem_id;
488    int key=getKeyValue(conf);
489   
490    sem_id = semget(key, nsems, IPC_CREAT | IPC_EXCL | 0666);
491
492    if (sem_id >= 0) { /* we got it first */
493        sb.sem_op = 1; 
494        sb.sem_flg = 0;
495        arg.val=1;
496        for(sb.sem_num = 0; sb.sem_num < nsems; sb.sem_num++) { 
497            /* do a semop() to "free" the semaphores. */
498            /* this sets the sem_otime field, as needed below. */
499            if (semop(sem_id, &sb, 1) == -1) {
500                int e = errno;
501                semctl(sem_id, 0, IPC_RMID); /* clean up */
502                errno = e;
503                return -1; /* error, check errno */
504            }
505        }
506    } else if (errno == EEXIST) { /* someone else got it first */
507        int ready = 0;
508
509        sem_id = semget(key, nsems, 0); /* get the id */
510        if (sem_id < 0) return sem_id; /* error, check errno */
511
512        /* wait for other process to initialize the semaphore: */
513        arg.buf = &buf;
514        for(i = 0; i < MAX_RETRIES && !ready; i++) {
515            semctl(sem_id, nsems-1, IPC_STAT, arg);
516            if (arg.buf->sem_otime != 0) {
517#ifdef DEBUG
518              fprintf(stderr,"Semaphore acquired ...\n");
519#endif
520              ready = 1;
521            } else {
522#ifdef DEBUG
523              fprintf(stderr,"Retry to access the semaphore later ...\n");
524#endif
[652]525              zSleep(1);
[507]526            }
527        }
[576]528        errno = ZOO_LOCK_ACQUIRE_FAILED;
[507]529        if (!ready) {
530#ifdef DEBUG
531          fprintf(stderr,"Unable to access the semaphore ...\n");
532#endif
533          errno = ETIME;
534          return -1;
535        }
536    } else {
537        return sem_id; /* error, check errno */
538    }
539#ifdef DEBUG
540    fprintf(stderr,"%d Created !\n",sem_id);
541#endif
542    return sem_id;
543}
544
[579]545/**
546 * Try to remove a semaphore set.
547 *
548 * @param conf the map containing the setting of the main.cfg file
549 * @param nsems number of semaphores
550 * @return 0 if the semaphore can be removed, -1 in other case.
551 */
[507]552int removeShmLock(maps* conf, int nsems){
553  union semun arg;
554  int sem_id=getShmLockId(conf,nsems);
555  if (semctl(sem_id, 0, IPC_RMID, arg) == -1) {
[652]556#ifdef DEBUG
557    perror("semctl remove");
558#endif
[507]559    return -1;
560  }
[652]561#ifdef DEBUG
562  fprintf(stderr,"Semaphore removed!\n");
563#endif
[507]564  return 0;
565}
566
[579]567/**
568 * Lock a semaphore set.
569 *
570 * @param id the semaphores set indetifier
571 * @return 0 if the semaphore can be locked, -1 in other case.
572 */
[507]573int lockShm(int id){
574  struct sembuf sb;
575  sb.sem_num = 0;
576  sb.sem_op = -1;  /* set to allocate resource */
577  sb.sem_flg = SEM_UNDO;
578  if (semop(id, &sb, 1) == -1){
[652]579#ifdef DEBUG
580    perror("semop lock");
581#endif
[507]582    return -1;
583  }
584  return 0;
585}
586
[579]587/**
588 * unLock a semaphore set.
589 *
590 * @param id the semaphores set indetifier
591 * @return 0 if the semaphore can be locked, -1 in other case.
592 */
[507]593int unlockShm(int id){
594  struct sembuf sb;
595  sb.sem_num = 0;
596  sb.sem_op = 1;  /* free resource */
597  sb.sem_flg = SEM_UNDO;
598  if (semop(id, &sb, 1) == -1) {
[26]599#ifdef DEBUG
[652]600    perror("semop unlock");
[26]601#endif
[652]602    return -1;
[26]603  }
[471]604  return 0;
[26]605}
606
[579]607/**
[652]608 * Get the current status of the running service.
[579]609 *
610 * @see getKeyValue, getShmLockId, lockShm
611 * @param pid the semaphores
612 * @return 0 on success, -2 if shmget failed, -1 if shmat failed
613 */
[26]614char* getStatus(int pid){
[490]615  int shmid;
[26]616  key_t key;
617  void *shm;
618  key=pid;
619  if ((shmid = shmget(key, SHMSZ, 0666)) < 0) {
620#ifdef DEBUG
621    fprintf(stderr,"shmget failed in getStatus\n");
622#endif
623  }else{
624    if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
625#ifdef DEBUG
626      fprintf(stderr,"shmat failed in getStatus\n");
627#endif
628    }else{
[514]629      char *ret=strdup((char*)shm);
630      shmdt((void *)shm);
631      return ret;
[26]632    }
633  }
[490]634  return (char*)"-1";
[26]635}
636
[216]637#endif
[26]638
[579]639/**
640 * Update the status of an ongoing service
641 *
642 * @param conf the maps containing the settings of the main.cfg file
643 * @param percentCompleted percentage of completude of execution of the service
644 * @param message information about the current step executed
645 * @return the value of _updateStatus
646 * @see _updateStatus
647 */
[471]648int updateStatus( maps* conf, const int percentCompleted, const char* message ){
649  char tmp[4];
650  snprintf(tmp,4,"%d",percentCompleted);
651  setMapInMaps( conf, "lenv", "status", tmp );
652  setMapInMaps( conf, "lenv", "message", message);
653  return _updateStatus( conf );
654}
655
[579]656/**
657 * Access an input value
658 *
659 * @param inputs the maps to search for the input value
660 * @param parameterName the input name to fetch the value
661 * @param numberOfBytes the resulting size of the value to add (for binary
662 *  values), -1 for basic char* data
663 * @return a pointer to the input value if found, NULL in other case.
664 */
[471]665char* getInputValue( maps* inputs, const char* parameterName, size_t* numberOfBytes){
666  map* res=getMapFromMaps(inputs,parameterName,"value");
667  if(res!=NULL){
668    map* size=getMapFromMaps(inputs,parameterName,"size");
669    if(size!=NULL){
670      *numberOfBytes=(size_t)atoi(size->value);
671      return res->value;
672    }else{
673      *numberOfBytes=strlen(res->value);
674      return res->value;
675    }
676  }
677  return NULL;
678}
679
[579]680/**
[649]681 * Read a file using the GDAL VSI API
682 *
683 * @param conf the maps containing the settings of the main.cfg file
684 * @param dataSource the datasource name to read
685 * @warning make sure to free ressources returned by this function
686 */
687char *readVSIFile(maps* conf,const char* dataSource){
688    VSILFILE * fichier=VSIFOpenL(dataSource,"rb");
[730]689    VSIStatBufL file_status;
[681]690    VSIStatL(dataSource, &file_status);
[649]691    if(fichier==NULL){
692      char tmp[1024];
693      sprintf(tmp,"Failed to open file %s for reading purpose. File seems empty %lld.",
694              dataSource,file_status.st_size);
695      setMapInMaps(conf,"lenv","message",tmp);
696      return NULL;
697    }
698    char *res1=(char *)malloc(file_status.st_size*sizeof(char));
699    VSIFReadL(res1,1,file_status.st_size*sizeof(char),fichier);
700    res1[file_status.st_size-1]=0;
701    VSIFCloseL(fichier);
702    VSIUnlink(dataSource);
703    return res1;
704}
705
706/**
[579]707 * Set an output value
708 *
709 * @param outputs the maps to define the output value
710 * @param parameterName the output name to set the value
711 * @param data the value to set
712 * @param numberOfBytes size of the value to add (for binary values), -1 for
713 *  basic char* data
714 * @return 0
715 */
[471]716int  setOutputValue( maps* outputs, const char* parameterName, char* data, size_t numberOfBytes ){
717  if(numberOfBytes==-1){
718    setMapInMaps(outputs,parameterName,"value",data);
719  }else{
720    char size[1024];
721    map* tmp=getMapFromMaps(outputs,parameterName,"value");
[539]722    if(tmp==NULL){
723      setMapInMaps(outputs,parameterName,"value","");
724      tmp=getMapFromMaps(outputs,parameterName,"value");
725    }
[471]726    free(tmp->value);
727    tmp->value=(char*) malloc((numberOfBytes+1)*sizeof(char));
728    memcpy(tmp->value,data,numberOfBytes);
[490]729    sprintf(size,"%lu",numberOfBytes);
[471]730    setMapInMaps(outputs,parameterName,"size",size);
731  }
732  return 0;
733}
[576]734
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