envlist.c

   1 #include <assert.h>
   2 #include <errno.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6
   7 #include "qemu/queue.h"
   8 #include "qemu/envlist.h"
   9
  10 struct envlist_entry {
  11         const char *ev_var;                     /* actual env value */
  12         QLIST_ENTRY(envlist_entry) ev_link;
  13 };
  14
  15 struct envlist {
  16         QLIST_HEAD(, envlist_entry) el_entries; /* actual entries */
  17         size_t el_count;                        /* number of entries */
  18 };
  19
  20 static int envlist_parse(envlist_t *envlist,
  21     const char *env, int (*)(envlist_t *, const char *));
  22
  23 /*
  24  * Allocates new envlist and returns pointer to that or
  25  * NULL in case of error.
  26  */
  27 envlist_t *
  28 envlist_create(void)
  29 {
  30         envlist_t *envlist;
  31
  32         if ((envlist = malloc(sizeof (*envlist))) == NULL)
  33                 return (NULL);
  34
  35         QLIST_INIT(&envlist->el_entries);
  36         envlist->el_count = 0;
  37
  38         return (envlist);
  39 }
  40
  41 /*
  42  * Releases given envlist and its entries.
  43  */
  44 void
  45 envlist_free(envlist_t *envlist)
  46 {
  47         struct envlist_entry *entry;
  48
  49         assert(envlist != NULL);
  50
  51         while (envlist->el_entries.lh_first != NULL) {
  52                 entry = envlist->el_entries.lh_first;
  53                 QLIST_REMOVE(entry, ev_link);
  54
  55                 free((char *)entry->ev_var);
  56                 free(entry);
  57         }
  58         free(envlist);
  59 }
  60
  61 /*
  62  * Parses comma separated list of set/modify environment
  63  * variable entries and updates given enlist accordingly.
  64  *
  65  * For example:
  66  *     envlist_parse(el, "HOME=foo,SHELL=/bin/sh");
  67  *
  68  * inserts/sets environment variables HOME and SHELL.
  69  *
  70  * Returns 0 on success, errno otherwise.
  71  */
  72 int
  73 envlist_parse_set(envlist_t *envlist, const char *env)
  74 {
  75         return (envlist_parse(envlist, env, &envlist_setenv));
  76 }
  77
  78 /*
  79  * Parses comma separated list of unset environment variable
  80  * entries and removes given variables from given envlist.
  81  *
  82  * Returns 0 on success, errno otherwise.
  83  */
  84 int
  85 envlist_parse_unset(envlist_t *envlist, const char *env)
  86 {
  87         return (envlist_parse(envlist, env, &envlist_unsetenv));
  88 }
  89
  90 /*
  91  * Parses comma separated list of set, modify or unset entries
  92  * and calls given callback for each entry.
  93  *
  94  * Returns 0 in case of success, errno otherwise.
  95  */
  96 static int
  97 envlist_parse(envlist_t *envlist, const char *env,
  98     int (*callback)(envlist_t *, const char *))
  99 {
 100         char *tmpenv, *envvar;
 101         char *envsave = NULL;
 102
 103         assert(callback != NULL);
 104
 105         if ((envlist == NULL) || (env == NULL))
 106                 return (EINVAL);
 107
 108         /*
 109          * We need to make temporary copy of the env string
 110          * as strtok_r(3) modifies it while it tokenizes.
 111          */
 112         if ((tmpenv = strdup(env)) == NULL)
 113                 return (errno);
 114
 115         envvar = strtok_r(tmpenv, ",", &envsave);
 116         while (envvar != NULL) {
 117                 if ((*callback)(envlist, envvar) != 0) {
 118                         free(tmpenv);
 119                         return (errno);
 120                 }
 121                 envvar = strtok_r(NULL, ",", &envsave);
 122         }
 123
 124         free(tmpenv);
 125         return (0);
 126 }
 127
 128 /*
 129  * Sets environment value to envlist in similar manner
 130  * than putenv(3).
 131  *
 132  * Returns 0 in success, errno otherwise.
 133  */
 134 int
 135 envlist_setenv(envlist_t *envlist, const char *env)
 136 {
 137         struct envlist_entry *entry = NULL;
 138         const char *eq_sign;
 139         size_t envname_len;
 140
 141         if ((envlist == NULL) || (env == NULL))
 142                 return (EINVAL);
 143
 144         /* find out first equals sign in given env */
 145         if ((eq_sign = strchr(env, '=')) == NULL)
 146                 return (EINVAL);
 147         envname_len = eq_sign - env + 1;
 148
 149         /*
 150          * If there already exists variable with given name
 151          * we remove and release it before allocating a whole
 152          * new entry.
 153          */
 154         for (entry = envlist->el_entries.lh_first; entry != NULL;
 155             entry = entry->ev_link.le_next) {
 156                 if (strncmp(entry->ev_var, env, envname_len) == 0)
 157                         break;
 158         }
 159
 160         if (entry != NULL) {
 161                 QLIST_REMOVE(entry, ev_link);
 162                 free((char *)entry->ev_var);
 163                 free(entry);
 164         } else {
 165                 envlist->el_count++;
 166         }
 167
 168         if ((entry = malloc(sizeof (*entry))) == NULL)
 169                 return (errno);
 170         if ((entry->ev_var = strdup(env)) == NULL) {
 171                 free(entry);
 172                 return (errno);
 173         }
 174         QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link);
 175
 176         return (0);
 177 }
 178
 179 /*
 180  * Removes given env value from envlist in similar manner
 181  * than unsetenv(3).  Returns 0 in success, errno otherwise.
 182  */
 183 int
 184 envlist_unsetenv(envlist_t *envlist, const char *env)
 185 {
 186         struct envlist_entry *entry;
 187         size_t envname_len;
 188
 189         if ((envlist == NULL) || (env == NULL))
 190                 return (EINVAL);
 191
 192         /* env is not allowed to contain '=' */
 193         if (strchr(env, '=') != NULL)
 194                 return (EINVAL);
 195
 196         /*
 197          * Find out the requested entry and remove
 198          * it from the list.
 199          */
 200         envname_len = strlen(env);
 201         for (entry = envlist->el_entries.lh_first; entry != NULL;
 202             entry = entry->ev_link.le_next) {
 203                 if (strncmp(entry->ev_var, env, envname_len) == 0)
 204                         break;
 205         }
 206         if (entry != NULL) {
 207                 QLIST_REMOVE(entry, ev_link);
 208                 free((char *)entry->ev_var);
 209                 free(entry);
 210
 211                 envlist->el_count--;
 212         }
 213         return (0);
 214 }
 215
 216 /*
 217  * Returns given envlist as array of strings (in same form that
 218  * global variable environ is).  Caller must free returned memory
 219  * by calling free(3) for each element and for the array.  Returned
 220  * array and given envlist are not related (no common references).
 221  *
 222  * If caller provides count pointer, number of items in array is
 223  * stored there.  In case of error, NULL is returned and no memory
 224  * is allocated.
 225  */
 226 char **
 227 envlist_to_environ(const envlist_t *envlist, size_t *count)
 228 {
 229         struct envlist_entry *entry;
 230         char **env, **penv;
 231
 232         penv = env = malloc((envlist->el_count + 1) * sizeof (char *));
 233         if (env == NULL)
 234                 return (NULL);
 235
 236         for (entry = envlist->el_entries.lh_first; entry != NULL;
 237             entry = entry->ev_link.le_next) {
 238                 *(penv++) = strdup(entry->ev_var);
 239         }
 240         *penv = NULL; /* NULL terminate the list */
 241
 242         if (count != NULL)
 243                 *count = envlist->el_count;
 244
 245         return (env);
 246 }