compiler/posixc/__env.c

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