common/env.c

   1 /*
   2  * env.c - environment variables storage
   3  *
   4  * Copyright (c) 2007 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /**
  24  * @file
  25  * @brief Environment support
  26  */
  27
  28 #include <common.h>
  29 #include <driver.h>
  30 #include <malloc.h>
  31 #include <xfuncs.h>
  32 #include <errno.h>
  33 #include <init.h>
  34 #include <environment.h>
  35
  36 #define VARIABLE_D_SIZE(name, value) (sizeof(struct variable_d) + strlen(name) + strlen(value) + 2)
  37
  38 static struct env_context *context;
  39
  40 /**
  41  * Remove a list of environment variables
  42  * @param[in] v Variable anchor to remove
  43  */
  44 static void free_variables(struct variable_d *v)
  45 {
  46         struct variable_d *next;
  47
  48         while (v) {
  49                 next = v->next;
  50                 free(v);
  51                 v = next;
  52         }
  53 }
  54
  55 /** Read back current context */
  56 struct env_context *get_current_context(void)
  57 {
  58         return context;
  59 }
  60 EXPORT_SYMBOL(get_current_context);
  61
  62
  63 /**
  64  * FIXME
  65  */
  66 int env_push_context(void)
  67 {
  68         struct env_context *c = xzalloc(sizeof(struct env_context));
  69
  70         c->local = xzalloc(VARIABLE_D_SIZE("", ""));
  71         c->global = xzalloc(VARIABLE_D_SIZE("", ""));
  72
  73         if (!context) {
  74                 context = c;
  75                 return 0;
  76         }
  77
  78         c->parent = context;
  79         context = c;
  80
  81         return 0;
  82 }
  83
  84 late_initcall(env_push_context);
  85
  86 /**
  87  * FIXME
  88  */
  89 int env_pop_context(void)
  90 {
  91         struct env_context *c = context;
  92
  93         if (context->parent) {
  94                 c = context->parent;
  95                 free_variables(context->local);
  96                 free_variables(context->global);
  97                 free(context);
  98                 context = c;
  99                 return 0;
 100         }
 101         return -EINVAL;
 102 }
 103
 104 /**
 105  * Return variable's value
 106  * @param[in] var Variable of interest
 107  * @return Value as text
 108  */
 109 char *var_val(struct variable_d *var)
 110 {
 111         return &var->data[strlen(var->data) + 1];
 112 }
 113
 114 /**
 115  * Return variable's name
 116  * @param[in] var Variable of interest
 117  * @return Name as text
 118  */
 119 char *var_name(struct variable_d *var)
 120 {
 121         return var->data;
 122 }
 123
 124 static const char *getenv_raw(struct variable_d *var, const char *name)
 125 {
 126         while (var) {
 127                 if (!strcmp(var_name(var), name))
 128                         return var_val(var);
 129                 var = var->next;
 130         }
 131         return NULL;
 132 }
 133
 134 const char *getenv (const char *name)
 135 {
 136         struct env_context *c;
 137         const char *val;
 138
 139         if (strchr(name, '.')) {
 140                 const char *ret = 0;
 141                 char *devstr = strdup(name);
 142                 char *par = strchr(devstr, '.');
 143                 struct device_d *dev;
 144                 *par = 0;
 145                 dev = get_device_by_name(devstr);
 146                 if (dev) {
 147                                 par++;
 148                                 ret = dev_get_param(dev, par);
 149                 }
 150                 free(devstr);
 151                 return ret;
 152         }
 153
 154         c = context;
 155
 156         val = getenv_raw(c->local, name);
 157         if (val)
 158                 return val;
 159
 160         while (c) {
 161                 val = getenv_raw(c->global, name);
 162                 if (val)
 163                         return val;
 164                 c = c->parent;
 165         }
 166         return NULL;
 167 }
 168 EXPORT_SYMBOL(getenv);
 169
 170 static int setenv_raw(struct variable_d *var, const char *name, const char *value)
 171 {
 172         struct variable_d *newvar = NULL;
 173
 174         if (value) {
 175                 newvar = xzalloc(VARIABLE_D_SIZE(name, value));
 176                 strcpy(&newvar->data[0], name);
 177                 strcpy(&newvar->data[strlen(name) + 1], value);
 178         }
 179
 180         while (var->next) {
 181                 if (!strcmp(var->next->data, name)) {
 182                         if (value) {
 183                                 newvar->next = var->next->next;
 184                                 free(var->next);
 185                                 var->next = newvar;
 186                                 return 0;
 187                         } else {
 188                                 struct variable_d *tmp;
 189                                 tmp = var->next;
 190                                 var->next = var->next->next;
 191                                 free(tmp);
 192                                 return 0;
 193                         }
 194                 }
 195                 var = var->next;
 196         }
 197         var->next = newvar;
 198         return 0;
 199 }
 200
 201 int setenv(const char *_name, const char *value)
 202 {
 203         char *name = strdup(_name);
 204         char *par;
 205         struct variable_d *var;
 206         int ret = 0;
 207
 208         if (!*value)
 209                 value = NULL;
 210
 211
 212         if ((par = strchr(name, '.'))) {
 213                 struct device_d *dev;
 214
 215                 *par++ = 0;
 216                 dev = get_device_by_name(name);
 217                 if (dev)
 218                         ret = dev_set_param(dev, par, value);
 219                 else
 220                         ret = -ENODEV;
 221
 222                 errno = ret;
 223
 224                 if (ret < 0)
 225                         perror("set parameter");
 226
 227                 goto out;
 228         }
 229
 230         if (getenv_raw(context->global, name))
 231                 var = context->global;
 232         else
 233                 var = context->local;
 234
 235         ret = setenv_raw(var, name, value);
 236 out:
 237         free(name);
 238
 239         return ret;
 240 }
 241 EXPORT_SYMBOL(setenv);
 242
 243 int export(const char *varname)
 244 {
 245         const char *val = getenv_raw(context->local, varname);
 246
 247         if (val) {
 248                 setenv_raw(context->global, varname, val);
 249                 setenv_raw(context->local, varname, NULL);
 250                 return 0;
 251         }
 252         return -1;
 253 }
 254 EXPORT_SYMBOL(export);