compiler/clib/__env.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Internal functions for environment variables handling.
   6 */
   7
   8 #include "__arosc_privdata.h"
   9
  10 #include <stdlib.h>
  11 #include <strings.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14 #include <proto/utility.h>
  15 #include <dos/var.h>
  16
  17 #include "__env.h"
  18
  19 static __env_item *__env_newvar(const char *name, int valuesize)
  20 {
  21     __env_item *item;
  22
  23     item = malloc(sizeof(__env_item));
  24     if (!item) goto err1;
  25
  26     item->name = strdup(name);
  27     if (!item->name) goto err2;
  28
  29     item->value = malloc(valuesize);
  30     if (!item->value) goto err3;
  31
  32     item->next = NULL;
  33
  34     return item;
  35
  36 err3:
  37     free(item->name);
  38 err2:
  39     free(item);
  40 err1:
  41     return NULL;
  42 }
  43
  44 static __env_item **internal_findvar(register const char *name)
  45 {
  46
  47    __env_item **curr;
  48
  49    for (
  50        curr = &__env_list;
  51        *curr && strcmp((*curr)->name, name);
  52        curr = &((*curr)->next)
  53    );
  54
  55   return curr;
  56 }
  57
  58 /*
  59   Allocates space for a variable with name 'name' returning a pointer to it.
  60   If a variable with this name already exists then returns a pointer to that
  61   variable.
  62
  63   Returns NULL on error.
  64 */
  65 __env_item *__env_getvar(const char *name, int valuesize)
  66 {
  67     register __env_item **curr;
  68
  69     curr = internal_findvar(name);
  70
  71     if (*curr)
  72     {
  73         if (strlen((*curr)->value) < valuesize)
  74         {
  75             free((*curr)->value);
  76             (*curr)->value = malloc(valuesize);
  77
  78             if (!(*curr)->value)
  79             {
  80                 __env_item *tmp = (*curr)->next;
  81
  82                 free(*curr);
  83                 *curr = tmp;
  84             }
  85         }
  86     }
  87     else
  88     {
  89         *curr = __env_newvar(name, valuesize);
  90     }
  91
  92     return *curr;
  93 }
  94
  95 void __env_delvar(const char *name)
  96 {
  97     register __env_item **curr;
  98
  99     curr = internal_findvar(name);
 100
 101     if (*curr)
 102     {
 103         register __env_item *tmp = *curr;
 104
 105         *curr = (*curr)->next;
 106
 107         free(tmp->name);
 108         free(tmp->value);
 109         free(tmp);
 110     }
 111 }
 112
 113 struct EnvData
 114 {
 115    int envcount;
 116    int varbufsize;
 117    char * varbufptr;
 118 };
 119
 120 /* Hook function counting the number of variables and computing the buffer size
 121    needed for name=value character buffer. */
 122 LONG get_var_len(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 123 {
 124     struct EnvData *data = (struct EnvData *) userdata;
 125     data->envcount++;
 126     data->varbufsize +=
 127         (ptrdiff_t) strlen((char*)message->sv_Name) +
 128         message->sv_VarLen + 2;
 129     return 0;
 130 }
 131
 132 /* Hook function storing name=value strings in buffer */
 133 LONG get_var(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 134 {
 135     struct EnvData *data = userdata;
 136     data->varbufptr[0] = '\0';
 137     strcat(data->varbufptr, (char*) message->sv_Name);
 138     strcat(data->varbufptr, "=");
 139     strncat(data->varbufptr, (char*) message->sv_Var, message->sv_VarLen);
 140     data->varbufptr = data->varbufptr + strlen(data->varbufptr) + 1;
 141     return 0;
 142 }
 143
 144 /* Function storing name=value strings in given environ buffer. When buffer is
 145    null, it returns minimal necessary size of the buffer needed to store all
 146    name=value strings. */
 147 int __env_get_environ(char **environ, int size)
 148 {
 149     int i;
 150     struct Hook hook;
 151     struct EnvData u;
 152     char *varbuf;
 153
 154     u.envcount = 0;
 155     u.varbufsize = 0;
 156
 157     memset(&hook, 0, sizeof(struct Hook));
 158     hook.h_Entry = (HOOKFUNC) get_var_len;
 159     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 160
 161     if(environ == NULL)
 162         return sizeof(char*) * (u.envcount + 1) + u.varbufsize;
 163     else if(size < sizeof(char*) *(u.envcount + 1) + u.varbufsize)
 164         return -1;
 165
 166     /* store name=value strings after table of pointers */
 167     varbuf = (char*) (environ + (u.envcount + 1));
 168
 169     /* time to fill in the buffers */
 170     u.varbufptr = varbuf;
 171     u.varbufptr[0] = '\0';
 172     hook.h_Entry = (HOOKFUNC) get_var;
 173     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 174
 175     for(i = 0; i < u.envcount; i++)
 176     {
 177         environ[i] = varbuf;
 178         varbuf = strchr(varbuf, '\0') + 1;
 179     }
 180     environ[u.envcount] = NULL;
 181
 182     return 0;
 183 }