kern/env.c

   1 /* env.c - Environment variables */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2003,2005,2006,2007,2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/env.h>
  21 #include <grub/misc.h>
  22 #include <grub/mm.h>
  23
  24 /* The size of the hash table.  */
  25 #define HASHSZ  13
  26
  27 /* A hashtable for quick lookup of variables.  */
  28 struct grub_env_context
  29 {
  30   /* A hash table for variables.  */
  31   struct grub_env_var *vars[HASHSZ];
  32
  33   /* One level deeper on the stack.  */
  34   struct grub_env_context *prev;
  35 };
  36
  37 /* This is used for sorting only.  */
  38 struct grub_env_sorted_var
  39 {
  40   struct grub_env_var *var;
  41   struct grub_env_sorted_var *next;
  42 };
  43
  44 /* The initial context.  */
  45 static struct grub_env_context initial_context;
  46
  47 /* The current context.  */
  48 static struct grub_env_context *current_context = &initial_context;
  49
  50 /* Return the hash representation of the string S.  */
  51 static unsigned int
  52 grub_env_hashval (const char *s)
  53 {
  54   unsigned int i = 0;
  55
  56   /* XXX: This can be done much more efficiently.  */
  57   while (*s)
  58     i += 5 * *(s++);
  59
  60   return i % HASHSZ;
  61 }
  62
  63 static struct grub_env_var *
  64 grub_env_find (const char *name)
  65 {
  66   struct grub_env_var *var;
  67   int idx = grub_env_hashval (name);
  68
  69   /* Look for the variable in the current context.  */
  70   for (var = current_context->vars[idx]; var; var = var->next)
  71     if (grub_strcmp (var->name, name) == 0)
  72       return var;
  73
  74   return 0;
  75 }
  76
  77 grub_err_t
  78 grub_env_context_open (void)
  79 {
  80   struct grub_env_context *context;
  81   int i;
  82
  83   context = grub_malloc (sizeof (*context));
  84   if (! context)
  85     return grub_errno;
  86
  87   grub_memset (context, 0, sizeof (*context));
  88   context->prev = current_context;
  89   current_context = context;
  90
  91   /* Copy exported variables.  */
  92   for (i = 0; i < HASHSZ; i++)
  93     {
  94       struct grub_env_var *var;
  95
  96       for (var = context->prev->vars[i]; var; var = var->next)
  97         {
  98           if (var->type == GRUB_ENV_VAR_GLOBAL)
  99             {
 100               if (grub_env_set (var->name, var->value) != GRUB_ERR_NONE)
 101                 {
 102                   grub_env_context_close ();
 103                   return grub_errno;
 104                 }
 105               grub_register_variable_hook (var->name, var->read_hook, var->write_hook);
 106             }
 107         }
 108     }
 109
 110   return GRUB_ERR_NONE;
 111 }
 112
 113 grub_err_t
 114 grub_env_context_close (void)
 115 {
 116   struct grub_env_context *context;
 117   int i;
 118
 119   if (! current_context->prev)
 120     grub_fatal ("cannot close the initial context");
 121
 122   /* Free the variables associated with this context.  */
 123   for (i = 0; i < HASHSZ; i++)
 124     {
 125       struct grub_env_var *p, *q;
 126
 127       for (p = current_context->prev->vars[i]; p; p = q)
 128         {
 129           q = p->next;
 130           grub_free (p);
 131         }
 132     }
 133
 134   /* Restore the previous context.  */
 135   context = current_context->prev;
 136   grub_free (current_context);
 137   current_context = context;
 138
 139   return GRUB_ERR_NONE;
 140 }
 141
 142 static void
 143 grub_env_insert (struct grub_env_context *context,
 144                  struct grub_env_var *var)
 145 {
 146   int idx = grub_env_hashval (var->name);
 147
 148   /* Insert the variable into the hashtable.  */
 149   var->prevp = &context->vars[idx];;
 150   var->next = context->vars[idx];
 151   if (var->next)
 152     var->next->prevp = &var;
 153   context->vars[idx] = var;
 154 }
 155
 156 static void
 157 grub_env_remove (struct grub_env_var *var)
 158 {
 159   /* Remove the entry from the variable table.  */
 160   *var->prevp = var->next;
 161   if (var->next)
 162     var->next->prevp = var->prevp;
 163 }
 164
 165 grub_err_t
 166 grub_env_export (const char *name)
 167 {
 168   struct grub_env_var *var;
 169
 170   var = grub_env_find (name);
 171   if (var)
 172     var->type = GRUB_ENV_VAR_GLOBAL;
 173
 174   return GRUB_ERR_NONE;
 175 }
 176
 177 grub_err_t
 178 grub_env_set (const char *name, const char *val)
 179 {
 180   struct grub_env_var *var;
 181
 182   /* If the variable does already exist, just update the variable.  */
 183   var = grub_env_find (name);
 184   if (var)
 185     {
 186       char *old = var->value;
 187
 188       if (var->write_hook)
 189         var->value = var->write_hook (var, val);
 190       else
 191         var->value = grub_strdup (val);
 192
 193       if (! var->value)
 194         {
 195           var->value = old;
 196           return grub_errno;
 197         }
 198
 199       grub_free (old);
 200       return GRUB_ERR_NONE;
 201     }
 202
 203   /* The variable does not exist, so create a new one.  */
 204   var = grub_malloc (sizeof (*var));
 205   if (! var)
 206     return grub_errno;
 207
 208   grub_memset (var, 0, sizeof (*var));
 209
 210   /* This is not necessary, because GRUB_ENV_VAR_LOCAL == 0. But leave
 211      this for readability.  */
 212   var->type = GRUB_ENV_VAR_LOCAL;
 213
 214   var->name = grub_strdup (name);
 215   if (! var->name)
 216     goto fail;
 217
 218   var->value = grub_strdup (val);
 219   if (! var->value)
 220     goto fail;
 221
 222   grub_env_insert (current_context, var);
 223
 224   return GRUB_ERR_NONE;
 225
 226  fail:
 227   grub_free (var->name);
 228   grub_free (var->value);
 229   grub_free (var);
 230
 231   return grub_errno;
 232 }
 233
 234 char *
 235 grub_env_get (const char *name)
 236 {
 237   struct grub_env_var *var;
 238
 239   var = grub_env_find (name);
 240   if (! var)
 241     return 0;
 242
 243   if (var->read_hook)
 244     return var->read_hook (var, var->value);
 245
 246   return var->value;
 247 }
 248
 249 void
 250 grub_env_unset (const char *name)
 251 {
 252   struct grub_env_var *var;
 253
 254   var = grub_env_find (name);
 255   if (! var)
 256     return;
 257
 258   /* XXX: It is not possible to unset variables with a read or write
 259      hook.  */
 260   if (var->read_hook || var->write_hook)
 261     return;
 262
 263   grub_env_remove (var);
 264
 265   grub_free (var->name);
 266   if (var->type != GRUB_ENV_VAR_DATA)
 267     grub_free (var->value);
 268   grub_free (var);
 269 }
 270
 271 void
 272 grub_env_iterate (int (*func) (struct grub_env_var *var))
 273 {
 274   struct grub_env_sorted_var *sorted_list = 0;
 275   struct grub_env_sorted_var *sorted_var;
 276   int i;
 277
 278   /* Add variables associated with this context into a sorted list.  */
 279   for (i = 0; i < HASHSZ; i++)
 280     {
 281       struct grub_env_var *var;
 282
 283       for (var = current_context->vars[i]; var; var = var->next)
 284         {
 285           struct grub_env_sorted_var *p, **q;
 286
 287           /* Ignore data slots.  */
 288           if (var->type == GRUB_ENV_VAR_DATA)
 289             continue;
 290
 291           sorted_var = grub_malloc (sizeof (*sorted_var));
 292           if (! sorted_var)
 293             goto fail;
 294
 295           sorted_var->var = var;
 296
 297           for (q = &sorted_list, p = *q; p; q = &((*q)->next), p = *q)
 298             {
 299               if (grub_strcmp (p->var->name, var->name) > 0)
 300                 break;
 301             }
 302
 303           sorted_var->next = *q;
 304           *q = sorted_var;
 305         }
 306     }
 307
 308   /* Iterate FUNC on the sorted list.  */
 309   for (sorted_var = sorted_list; sorted_var; sorted_var = sorted_var->next)
 310     if (func (sorted_var->var))
 311       break;
 312
 313  fail:
 314
 315   /* Free the sorted list.  */
 316   for (sorted_var = sorted_list; sorted_var; )
 317     {
 318       struct grub_env_sorted_var *tmp = sorted_var->next;
 319
 320       grub_free (sorted_var);
 321       sorted_var = tmp;
 322     }
 323 }
 324
 325 grub_err_t
 326 grub_register_variable_hook (const char *name,
 327                              grub_env_read_hook_t read_hook,
 328                              grub_env_write_hook_t write_hook)
 329 {
 330   struct grub_env_var *var = grub_env_find (name);
 331
 332   if (! var)
 333     {
 334       char *val = grub_strdup ("");
 335
 336       if (! val)
 337         return grub_errno;
 338
 339       if (grub_env_set (name, val) != GRUB_ERR_NONE)
 340         return grub_errno;
 341
 342       var = grub_env_find (name);
 343       /* XXX Insert an assertion?  */
 344     }
 345
 346   var->read_hook = read_hook;
 347   var->write_hook = write_hook;
 348
 349   return GRUB_ERR_NONE;
 350 }
 351
 352 static char *
 353 mangle_data_slot_name (const char *name)
 354 {
 355   char *mangled_name;
 356
 357   mangled_name = grub_malloc (grub_strlen (name) + 2);
 358   if (! mangled_name)
 359     return 0;
 360
 361   grub_sprintf (mangled_name, "\e%s", name);
 362   return mangled_name;
 363 }
 364
 365 grub_err_t
 366 grub_env_set_data_slot (const char *name, const void *ptr)
 367 {
 368   char *mangled_name;
 369   struct grub_env_var *var;
 370
 371   mangled_name = mangle_data_slot_name (name);
 372   if (! mangled_name)
 373     goto fail;
 374
 375   /* If the variable does already exist, just update the variable.  */
 376   var = grub_env_find (mangled_name);
 377   if (var)
 378     {
 379       var->value = (char *) ptr;
 380       return GRUB_ERR_NONE;
 381     }
 382
 383   /* The variable does not exist, so create a new one.  */
 384   var = grub_malloc (sizeof (*var));
 385   if (! var)
 386     goto fail;
 387
 388   grub_memset (var, 0, sizeof (*var));
 389
 390   var->type = GRUB_ENV_VAR_DATA;
 391   var->name = mangled_name;
 392   var->value = (char *) ptr;
 393
 394   grub_env_insert (current_context, var);
 395
 396   return GRUB_ERR_NONE;
 397
 398  fail:
 399
 400   grub_free (mangled_name);
 401   return grub_errno;
 402 }
 403
 404 void *
 405 grub_env_get_data_slot (const char *name)
 406 {
 407   char *mangled_name;
 408   void *ptr = 0;
 409
 410   mangled_name = mangle_data_slot_name (name);
 411   if (! mangled_name)
 412     goto fail;
 413
 414   ptr = grub_env_get (mangled_name);
 415   grub_free (mangled_name);
 416
 417  fail:
 418
 419   return ptr;
 420 }
 421
 422 void
 423 grub_env_unset_data_slot (const char *name)
 424 {
 425   char *mangled_name;
 426
 427   mangled_name = mangle_data_slot_name (name);
 428   if (! mangled_name)
 429     return;
 430
 431   grub_env_unset (mangled_name);
 432   grub_free (mangled_name);
 433 }