compiler/clib/__env.c

   1 /*
   2     Copyright © 1995-2012, 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 <string.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 #if AROS_AMIGAOS_COMPLIANCE && (AROS_AMIGAOS_COMPLIANCE >= 30)
  20 /* ScanVars is a Morphos addition in dos.library v50, so we
  21  * have this stub here for arosc.library compatability with
  22  * dos.library v30..v39.
  23  */
  24 static LONG v30_ScanVars(struct Hook *hook, ULONG flags, APTR userdata)
  25 {
  26     /* We scan through the process->pr_LocalVars list */
  27     struct Process  *pr;
  28     struct LocalVar *var;
  29     struct ScanVarsMsg msg;
  30     LONG res = 0;
  31     APTR UtilityBase;
  32
  33     UtilityBase = OpenLibrary("utility.library", 0);
  34     if (UtilityBase == NULL)
  35         return 0;
  36
  37     msg.sv_SVMSize = sizeof(struct ScanVarsMsg);
  38     msg.sv_Flags = flags;
  39     pr  = (struct Process *)FindTask(NULL);
  40
  41     /* We know that the callers of this routine
  42      * will be asking for GVF_LOCAL_ONLY
  43      */
  44     var = (struct LocalVar *)pr->pr_LocalVars.mlh_Head;
  45
  46     ForeachNode(&pr->pr_LocalVars, var)
  47     {
  48         if (var->lv_Node.ln_Type == LV_VAR)
  49         {
  50             msg.sv_Name = var->lv_Node.ln_Name;
  51             msg.sv_Var = var->lv_Value;
  52             msg.sv_VarLen = var->lv_Len;
  53             msg.sv_GDir = "";
  54             res = CallHookPkt(hook, userdata, &msg);
  55             if(res != 0)
  56                 break;
  57         }
  58     }
  59
  60     CloseLibrary(UtilityBase);
  61     return res;
  62 }
  63 #undef ScanVars
  64 #define ScanVars(a,b,c) v30_ScanVars(a,b,c)
  65 #endif
  66
  67 static __env_item *__env_newvar(const char *name, int valuesize)
  68 {
  69     __env_item *item;
  70
  71     item = malloc(sizeof(__env_item));
  72     if (!item) goto err1;
  73
  74     item->name = strdup(name);
  75     if (!item->name) goto err2;
  76
  77     item->value = malloc(valuesize);
  78     if (!item->value) goto err3;
  79
  80     item->next = NULL;
  81
  82     return item;
  83
  84 err3:
  85     free(item->name);
  86 err2:
  87     free(item);
  88 err1:
  89     return NULL;
  90 }
  91
  92 static __env_item **internal_findvar(register const char *name)
  93 {
  94     struct aroscbase *aroscbase = __aros_getbase_aroscbase();
  95
  96    __env_item **curr;
  97
  98    for (
  99        curr = &aroscbase->acb_env_list;
 100        *curr && strcmp((*curr)->name, name);
 101        curr = &((*curr)->next)
 102    );
 103
 104   return curr;
 105 }
 106
 107 /*
 108   Allocates space for a variable with name 'name' returning a pointer to it.
 109   If a variable with this name already exists then returns a pointer to that
 110   variable.
 111
 112   Returns NULL on error.
 113 */
 114 __env_item *__env_getvar(const char *name, int valuesize)
 115 {
 116     register __env_item **curr;
 117
 118     curr = internal_findvar(name);
 119
 120     if (*curr)
 121     {
 122         if (strlen((*curr)->value) < valuesize)
 123         {
 124             free((*curr)->value);
 125             (*curr)->value = malloc(valuesize);
 126
 127             if (!(*curr)->value)
 128             {
 129                 __env_item *tmp = (*curr)->next;
 130
 131                 free(*curr);
 132                 *curr = tmp;
 133             }
 134         }
 135     }
 136     else
 137     {
 138         *curr = __env_newvar(name, valuesize);
 139     }
 140
 141     return *curr;
 142 }
 143
 144 void __env_delvar(const char *name)
 145 {
 146     register __env_item **curr;
 147
 148     curr = internal_findvar(name);
 149
 150     if (*curr)
 151     {
 152         register __env_item *tmp = *curr;
 153
 154         *curr = (*curr)->next;
 155
 156         free(tmp->name);
 157         free(tmp->value);
 158         free(tmp);
 159     }
 160 }
 161
 162 struct EnvData
 163 {
 164    int envcount;
 165    int varbufsize;
 166    char * varbufptr;
 167 };
 168
 169 /* Hook function counting the number of variables and computing the buffer size
 170    needed for name=value character buffer. */
 171 LONG get_var_len(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 172 {
 173     struct EnvData *data = (struct EnvData *) userdata;
 174     data->envcount++;
 175     data->varbufsize +=
 176         (ptrdiff_t) strlen((char*)message->sv_Name) +
 177         message->sv_VarLen + 2;
 178     return 0;
 179 }
 180
 181 /* Hook function storing name=value strings in buffer */
 182 LONG get_var(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 183 {
 184     struct EnvData *data = userdata;
 185     data->varbufptr[0] = '\0';
 186     strcat(data->varbufptr, (char*) message->sv_Name);
 187     strcat(data->varbufptr, "=");
 188     strncat(data->varbufptr, (char*) message->sv_Var, message->sv_VarLen);
 189     data->varbufptr = data->varbufptr + strlen(data->varbufptr) + 1;
 190     return 0;
 191 }
 192
 193 /* Function storing name=value strings in given environ buffer. When buffer is
 194    null, it returns minimal necessary size of the buffer needed to store all
 195    name=value strings. */
 196 int __env_get_environ(char **environ, int size)
 197 {
 198     int i;
 199     struct Hook hook;
 200     struct EnvData u;
 201     char *varbuf;
 202
 203     u.envcount = 0;
 204     u.varbufsize = 0;
 205
 206     memset(&hook, 0, sizeof(struct Hook));
 207     hook.h_Entry = (HOOKFUNC) get_var_len;
 208     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 209
 210     if(environ == NULL)
 211         return sizeof(char*) * (u.envcount + 1) + u.varbufsize;
 212     else if(size < sizeof(char*) *(u.envcount + 1) + u.varbufsize)
 213         return -1;
 214
 215     /* store name=value strings after table of pointers */
 216     varbuf = (char*) (environ + (u.envcount + 1));
 217
 218     /* time to fill in the buffers */
 219     u.varbufptr = varbuf;
 220     u.varbufptr[0] = '\0';
 221     hook.h_Entry = (HOOKFUNC) get_var;
 222     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 223
 224     for(i = 0; i < u.envcount; i++)
 225     {
 226         environ[i] = varbuf;
 227         varbuf = strchr(varbuf, '\0') + 1;
 228     }
 229     environ[u.envcount] = NULL;
 230
 231     return 0;
 232 }