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