stand/libsa/environment.c

   1 /*
   2  * Copyright (c) 1998 Michael Smith.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 /*
  31  * Manage an environment-like space in which string variables may be stored.
  32  * Provide support for some method-like operations for setting/retrieving
  33  * variables in order to allow some type strength.
  34  */
  35
  36 #include "stand.h"
  37
  38 #include <string.h>
  39
  40 struct env_var  *environ = NULL;
  41
  42 /*
  43  * Look up (name) and return it's env_var structure.
  44  */
  45 struct env_var  *
  46 env_getenv(const char *name)
  47 {
  48         struct env_var  *ev;
  49
  50         for (ev = environ; ev != NULL; ev = ev->ev_next)
  51                 if (!strcmp(ev->ev_name, name))
  52                         break;
  53         return (ev);
  54 }
  55
  56 /*
  57  * Some notes:
  58  *
  59  * If the EV_VOLATILE flag is set, a copy of the variable is made.
  60  * If EV_DYNAMIC is set, the variable has been allocated with
  61  * malloc and ownership transferred to the environment.
  62  * If (value) is NULL, the variable is set but has no value.
  63  */
  64 int
  65 env_setenv(const char *name, int flags, const void *value,
  66     ev_sethook_t sethook, ev_unsethook_t unsethook)
  67 {
  68         struct env_var  *ev, *curr, *last;
  69
  70         if ((ev = env_getenv(name)) != NULL) {
  71                 /*
  72                  * If there's a set hook, let it do the work
  73                  * (unless we are working for one already).
  74                  */
  75                 if ((ev->ev_sethook != NULL) && !(flags & EV_NOHOOK))
  76                         return (ev->ev_sethook(ev, flags, value));
  77
  78                 /* If there is data in the variable, discard it. */
  79                 if (ev->ev_value != NULL && (ev->ev_flags & EV_DYNAMIC) != 0)
  80                         free(ev->ev_value);
  81                 ev->ev_value = NULL;
  82                 ev->ev_flags &= ~EV_DYNAMIC;
  83
  84         } else {
  85
  86                 /*
  87                  * New variable; create and sort into list
  88                  */
  89                 ev = malloc(sizeof(struct env_var));
  90                 ev->ev_name = strdup(name);
  91                 ev->ev_value = NULL;
  92                 ev->ev_flags = 0;
  93                 /* hooks can only be set when the variable is instantiated */
  94                 ev->ev_sethook = sethook;
  95                 ev->ev_unsethook = unsethook;
  96
  97                 /* Sort into list */
  98                 ev->ev_prev = NULL;
  99                 ev->ev_next = NULL;
 100                 /* Search for the record to insert before */
 101                 for (last = NULL, curr = environ; curr != NULL;
 102                     last = curr, curr = curr->ev_next) {
 103
 104                         if (strcmp(ev->ev_name, curr->ev_name) < 0) {
 105                                 if (curr->ev_prev) {
 106                                         curr->ev_prev->ev_next = ev;
 107                                 } else {
 108                                         environ = ev;
 109                                 }
 110                                 ev->ev_next = curr;
 111                                 ev->ev_prev = curr->ev_prev;
 112                                 curr->ev_prev = ev;
 113                                 break;
 114                         }
 115                 }
 116                 if (curr == NULL) {
 117                         if (last == NULL) {
 118                                 environ = ev;
 119                         } else {
 120                                 last->ev_next = ev;
 121                                 ev->ev_prev = last;
 122                         }
 123                 }
 124         }
 125
 126         /* If we have a new value, use it */
 127         if (flags & EV_VOLATILE) {
 128                 ev->ev_value = strdup(value);
 129                 ev->ev_flags |= EV_DYNAMIC;
 130         } else {
 131                 ev->ev_value = (char *)value;
 132                 ev->ev_flags |= flags & EV_DYNAMIC;
 133         }
 134
 135         return (0);
 136 }
 137
 138 /* coverity[ -tainted_string_return_content ] */
 139 char *
 140 getenv(const char *name)
 141 {
 142         struct env_var  *ev;
 143
 144         /* Set but no value gives empty string */
 145         if ((ev = env_getenv(name)) != NULL) {
 146                 if (ev->ev_value != NULL)
 147                         return (ev->ev_value);
 148                 return ("");
 149         }
 150         return (NULL);
 151 }
 152
 153 int
 154 setenv(const char *name, const char *value, int overwrite)
 155 {
 156         /* No guarantees about state, always assume volatile */
 157         if (overwrite || (env_getenv(name) == NULL))
 158                 return (env_setenv(name, EV_VOLATILE, value, NULL, NULL));
 159         return (0);
 160 }
 161
 162 int
 163 putenv(char *string)
 164 {
 165         char    *value, *copy;
 166         int     result;
 167
 168         copy = strdup(string);
 169         if ((value = strchr(copy, '=')) != NULL)
 170                 *(value++) = 0;
 171         result = setenv(copy, value, 1);
 172         free(copy);
 173         return (result);
 174 }
 175
 176 int
 177 unsetenv(const char *name)
 178 {
 179         struct env_var  *ev;
 180         int             err;
 181
 182         err = 0;
 183         if ((ev = env_getenv(name)) == NULL) {
 184                 err = ENOENT;
 185         } else {
 186                 if (ev->ev_unsethook != NULL)
 187                         err = ev->ev_unsethook(ev);
 188                 if (err == 0) {
 189                         env_discard(ev);
 190                 }
 191         }
 192         return (err);
 193 }
 194
 195 void
 196 env_discard(struct env_var *ev)
 197 {
 198         if (ev->ev_prev)
 199                 ev->ev_prev->ev_next = ev->ev_next;
 200         if (ev->ev_next)
 201                 ev->ev_next->ev_prev = ev->ev_prev;
 202         if (environ == ev)
 203                 environ = ev->ev_next;
 204         free(ev->ev_name);
 205         if (ev->ev_value != NULL && (ev->ev_flags & EV_DYNAMIC) != 0)
 206                 free(ev->ev_value);
 207         free(ev);
 208 }
 209
 210 int
 211 env_noset(struct env_var *ev __unused, int flags __unused,
 212     const void *value __unused)
 213 {
 214         return (EPERM);
 215 }
 216
 217 int
 218 env_nounset(struct env_var *ev __unused)
 219 {
 220         return (EPERM);
 221 }