qemu

envlist.c (5141B)

---

 #include "qemu/osdep.h"
 #include "qemu/queue.h"
 #include "qemu/envlist.h"
 
 struct envlist_entry {
 	const char *ev_var;			/* actual env value */
 	QLIST_ENTRY(envlist_entry) ev_link;
 };
 
 struct envlist {
 	QLIST_HEAD(, envlist_entry) el_entries;	/* actual entries */
 	size_t el_count;			/* number of entries */
 };
 
 static int envlist_parse(envlist_t *envlist,
     const char *env, int (*)(envlist_t *, const char *));
 
 /*
  * Allocates new envlist and returns pointer to it.
  */
 envlist_t *
 envlist_create(void)
 {
 	envlist_t *envlist;
 
 	envlist = g_malloc(sizeof(*envlist));
 
 	QLIST_INIT(&envlist->el_entries);
 	envlist->el_count = 0;
 
 	return (envlist);
 }
 
 /*
  * Releases given envlist and its entries.
  */
 void
 envlist_free(envlist_t *envlist)
 {
 	struct envlist_entry *entry;
 
 	assert(envlist != NULL);
 
 	while (envlist->el_entries.lh_first != NULL) {
 		entry = envlist->el_entries.lh_first;
 		QLIST_REMOVE(entry, ev_link);
 
 		g_free((char *)entry->ev_var);
 		g_free(entry);
 	}
 	g_free(envlist);
 }
 
 /*
  * Parses comma separated list of set/modify environment
  * variable entries and updates given enlist accordingly.
  *
  * For example:
  *     envlist_parse(el, "HOME=foo,SHELL=/bin/sh");
  *
  * inserts/sets environment variables HOME and SHELL.
  *
  * Returns 0 on success, errno otherwise.
  */
 int
 envlist_parse_set(envlist_t *envlist, const char *env)
 {
 	return (envlist_parse(envlist, env, &envlist_setenv));
 }
 
 /*
  * Parses comma separated list of unset environment variable
  * entries and removes given variables from given envlist.
  *
  * Returns 0 on success, errno otherwise.
  */
 int
 envlist_parse_unset(envlist_t *envlist, const char *env)
 {
 	return (envlist_parse(envlist, env, &envlist_unsetenv));
 }
 
 /*
  * Parses comma separated list of set, modify or unset entries
  * and calls given callback for each entry.
  *
  * Returns 0 in case of success, errno otherwise.
  */
 static int
 envlist_parse(envlist_t *envlist, const char *env,
     int (*callback)(envlist_t *, const char *))
 {
 	char *tmpenv, *envvar;
 	char *envsave = NULL;
     int ret = 0;
     assert(callback != NULL);
 
 	if ((envlist == NULL) || (env == NULL))
 		return (EINVAL);
 
 	tmpenv = g_strdup(env);
     envsave = tmpenv;
 
     do {
         envvar = strchr(tmpenv, ',');
         if (envvar != NULL) {
             *envvar = '\0';
         }
         if ((*callback)(envlist, tmpenv) != 0) {
             ret = errno;
             break;
 		}
         tmpenv = envvar + 1;
     } while (envvar != NULL);
 
     g_free(envsave);
     return ret;
 }
 
 /*
  * Sets environment value to envlist in similar manner
  * than putenv(3).
  *
  * Returns 0 in success, errno otherwise.
  */
 int
 envlist_setenv(envlist_t *envlist, const char *env)
 {
 	struct envlist_entry *entry = NULL;
 	const char *eq_sign;
 	size_t envname_len;
 
 	if ((envlist == NULL) || (env == NULL))
 		return (EINVAL);
 
 	/* find out first equals sign in given env */
 	if ((eq_sign = strchr(env, '=')) == NULL)
 		return (EINVAL);
 	envname_len = eq_sign - env + 1;
 
 	/*
 	 * If there already exists variable with given name
 	 * we remove and release it before allocating a whole
 	 * new entry.
 	 */
 	for (entry = envlist->el_entries.lh_first; entry != NULL;
 	    entry = entry->ev_link.le_next) {
 		if (strncmp(entry->ev_var, env, envname_len) == 0)
 			break;
 	}
 
 	if (entry != NULL) {
 		QLIST_REMOVE(entry, ev_link);
 		g_free((char *)entry->ev_var);
 		g_free(entry);
 	} else {
 		envlist->el_count++;
 	}
 
 	entry = g_malloc(sizeof(*entry));
 	entry->ev_var = g_strdup(env);
 	QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link);
 
 	return (0);
 }
 
 /*
  * Removes given env value from envlist in similar manner
  * than unsetenv(3).  Returns 0 in success, errno otherwise.
  */
 int
 envlist_unsetenv(envlist_t *envlist, const char *env)
 {
 	struct envlist_entry *entry;
 	size_t envname_len;
 
 	if ((envlist == NULL) || (env == NULL))
 		return (EINVAL);
 
 	/* env is not allowed to contain '=' */
 	if (strchr(env, '=') != NULL)
 		return (EINVAL);
 
 	/*
 	 * Find out the requested entry and remove
 	 * it from the list.
 	 */
 	envname_len = strlen(env);
 	for (entry = envlist->el_entries.lh_first; entry != NULL;
 	    entry = entry->ev_link.le_next) {
 		if (strncmp(entry->ev_var, env, envname_len) == 0)
 			break;
 	}
 	if (entry != NULL) {
 		QLIST_REMOVE(entry, ev_link);
 		g_free((char *)entry->ev_var);
 		g_free(entry);
 
 		envlist->el_count--;
 	}
 	return (0);
 }
 
 /*
  * Returns given envlist as array of strings (in same form that
  * global variable environ is).  Caller must free returned memory
  * by calling g_free for each element and the array.
  * Returned array and given envlist are not related (no common
  * references).
  *
  * If caller provides count pointer, number of items in array is
  * stored there.
  */
 char **
 envlist_to_environ(const envlist_t *envlist, size_t *count)
 {
 	struct envlist_entry *entry;
 	char **env, **penv;
 
 	penv = env = g_new(char *, envlist->el_count + 1);
 
 	for (entry = envlist->el_entries.lh_first; entry != NULL;
 	    entry = entry->ev_link.le_next) {
 		*(penv++) = g_strdup(entry->ev_var);
 	}
 	*penv = NULL; /* NULL terminate the list */
 
 	if (count != NULL)
 		*count = envlist->el_count;
 
 	return (env);
 }