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 #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
  95    __env_item **curr;
  96
  97    for (
  98        curr = &__env_list;
  99        *curr && strcmp((*curr)->name, name);
 100        curr = &((*curr)->next)
 101    );
 102
 103   return curr;
 104 }
 105
 106 /*
 107   Allocates space for a variable with name 'name' returning a pointer to it.
 108   If a variable with this name already exists then returns a pointer to that
 109   variable.
 110
 111   Returns NULL on error.
 112 */
 113 __env_item *__env_getvar(const char *name, int valuesize)
 114 {
 115     register __env_item **curr;
 116
 117     curr = internal_findvar(name);
 118
 119     if (*curr)
 120     {
 121         if (strlen((*curr)->value) < valuesize)
 122         {
 123             free((*curr)->value);
 124             (*curr)->value = malloc(valuesize);
 125
 126             if (!(*curr)->value)
 127             {
 128                 __env_item *tmp = (*curr)->next;
 129
 130                 free(*curr);
 131                 *curr = tmp;
 132             }
 133         }
 134     }
 135     else
 136     {
 137         *curr = __env_newvar(name, valuesize);
 138     }
 139
 140     return *curr;
 141 }
 142
 143 void __env_delvar(const char *name)
 144 {
 145     register __env_item **curr;
 146
 147     curr = internal_findvar(name);
 148
 149     if (*curr)
 150     {
 151         register __env_item *tmp = *curr;
 152
 153         *curr = (*curr)->next;
 154
 155         free(tmp->name);
 156         free(tmp->value);
 157         free(tmp);
 158     }
 159 }
 160
 161 struct EnvData
 162 {
 163    int envcount;
 164    int varbufsize;
 165    char * varbufptr;
 166 };
 167
 168 /* Hook function counting the number of variables and computing the buffer size
 169    needed for name=value character buffer. */
 170 LONG get_var_len(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 171 {
 172     struct EnvData *data = (struct EnvData *) userdata;
 173     data->envcount++;
 174     data->varbufsize +=
 175         (ptrdiff_t) strlen((char*)message->sv_Name) +
 176         message->sv_VarLen + 2;
 177     return 0;
 178 }
 179
 180 /* Hook function storing name=value strings in buffer */
 181 LONG get_var(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
 182 {
 183     struct EnvData *data = userdata;
 184     data->varbufptr[0] = '\0';
 185     strcat(data->varbufptr, (char*) message->sv_Name);
 186     strcat(data->varbufptr, "=");
 187     strncat(data->varbufptr, (char*) message->sv_Var, message->sv_VarLen);
 188     data->varbufptr = data->varbufptr + strlen(data->varbufptr) + 1;
 189     return 0;
 190 }
 191
 192 /* Function storing name=value strings in given environ buffer. When buffer is
 193    null, it returns minimal necessary size of the buffer needed to store all
 194    name=value strings. */
 195 int __env_get_environ(char **environ, int size)
 196 {
 197     int i;
 198     struct Hook hook;
 199     struct EnvData u;
 200     char *varbuf;
 201
 202     u.envcount = 0;
 203     u.varbufsize = 0;
 204
 205     memset(&hook, 0, sizeof(struct Hook));
 206     hook.h_Entry = (HOOKFUNC) get_var_len;
 207     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 208
 209     if(environ == NULL)
 210         return sizeof(char*) * (u.envcount + 1) + u.varbufsize;
 211     else if(size < sizeof(char*) *(u.envcount + 1) + u.varbufsize)
 212         return -1;
 213
 214     /* store name=value strings after table of pointers */
 215     varbuf = (char*) (environ + (u.envcount + 1));
 216
 217     /* time to fill in the buffers */
 218     u.varbufptr = varbuf;
 219     u.varbufptr[0] = '\0';
 220     hook.h_Entry = (HOOKFUNC) get_var;
 221     ScanVars(&hook, GVF_LOCAL_ONLY, &u);
 222
 223     for(i = 0; i < u.envcount; i++)
 224     {
 225         environ[i] = varbuf;
 226         varbuf = strchr(varbuf, '\0') + 1;
 227     }
 228     environ[u.envcount] = NULL;
 229
 230     return 0;
 231 }