qemu/envlist.c
<<
>>
Prefs
   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 "envlist.h"
   9
  10struct envlist_entry {
  11        const char *ev_var;                     /* actual env value */
  12        QLIST_ENTRY(envlist_entry) ev_link;
  13};
  14
  15struct envlist {
  16        QLIST_HEAD(, envlist_entry) el_entries; /* actual entries */
  17        size_t el_count;                        /* number of entries */
  18};
  19
  20static 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 */
  27envlist_t *
  28envlist_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 */
  44void
  45envlist_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 */
  72int
  73envlist_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 */
  84int
  85envlist_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 */
  96static int
  97envlist_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 */
 134int
 135envlist_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 */
 183int
 184envlist_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 */
 226char **
 227envlist_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}
 247