libs/envvar.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *  MODULE OF       fvwm
  19  *
  20  *  DESCRIPTION     Routines to expand environment-variables into strings.
  21  *                  Will understand both $ENV and ${ENV} -type variables.
  22  *
  23  *  WRITTEN BY      Sverre H. Huseby
  24  *                  sverrehu@ifi.uio.no
  25  *
  26  *  CREATED         1995/10/3
  27  *
  28  *  UPDATED         migo - 21/Jun/1999 - added getFirstEnv, some changes
  29  *
  30  */
  31
  32 /* ---------------------------- included header files ---------------------- */
  33
  34 #include "config.h"
  35 #include <stdio.h>
  36 #include <ctype.h>
  37
  38 #include "fvwmlib.h"
  39 #include "envvar.h"
  40
  41 /* ---------------------------- local definitions -------------------------- */
  42
  43 #ifdef HAVE_UNSETENV
  44 #define FHaveUnsetenv 1
  45 #else
  46 #define unsetenv(x) do { } while (0)
  47 #define FHaveUnsetenv 0
  48 #endif
  49
  50 /* ---------------------------- local macros ------------------------------- */
  51
  52 #define ENV_LIST_INC 10
  53 #ifndef NULL
  54 #define NULL 0
  55 #endif
  56
  57 /* ---------------------------- imports ------------------------------------ */
  58
  59 /* ---------------------------- included code files ------------------------ */
  60
  61 /* ---------------------------- local types -------------------------------- */
  62
  63 typedef struct
  64 {
  65         char *var;
  66         char *env;
  67 } env_list_item;
  68
  69 /* ---------------------------- forward declarations ----------------------- */
  70
  71 /* ---------------------------- local variables ---------------------------- */
  72
  73 /* ---------------------------- exported variables (globals) --------------- */
  74
  75 /* ---------------------------- local functions ---------------------------- */
  76
  77 /*-------------------------------------------------------------------------
  78  *
  79  *  NAME          strDel
  80  *
  81  *  FUNCTION      Delete characters from a string.
  82  *
  83  *  INPUT         s       the string to delete characters from.
  84  *                idx     index of first character to delete.
  85  *                n       number of characters to delete.
  86  *
  87  *  OUTPUT        s       string with characters deleted.
  88  *
  89  *  DESCRIPTION   Deletes characters from a string by moving following
  90  *                characters back.
  91  *
  92  */
  93 static void strDel(char *s, int idx, int n)
  94 {
  95         int  l;
  96         char *p;
  97
  98         if (idx >= (l = strlen(s)))
  99                 return;
 100         if (idx + n > l)
 101                 n = l - idx;
 102         s += idx;
 103         p = s + n;
 104         do {
 105                 *s++ = *p;
 106         } while (*p++);
 107 }
 108
 109 /*-------------------------------------------------------------------------
 110  *
 111  *  NAME          strIns
 112  *
 113  *  FUNCTION      Insert a string into a string.
 114  *
 115  *  INPUT         s       the string to insert into.
 116  *                ins     the string to insert.
 117  *                idx     index of where to insert the string.
 118  *                maxstrlen     max length of s, including '\0'.
 119  *
 120  *  OUTPUT        s       string with characters inserted.
 121  *
 122  *  DESCRIPTION   The insertion will be done even if the string gets to
 123  *                long, but characters will be sacrificed at the end of s.
 124  *                The string is always '\0'-terminated.
 125  *
 126  */
 127 static void strIns(char *s, const char *ins, int idx, int maxstrlen)
 128 {
 129         int  l, li, move;
 130         char *p1, *p2;
 131
 132         if (idx > (l = strlen(s)))
 133         {
 134                 idx = l;
 135         }
 136         li = strlen(ins);
 137         move = l - idx + 1; /* include '\0' in move */
 138         p1 = s + l;
 139         p2 = p1 + li;
 140         while (p2 >= s + maxstrlen) {
 141                 --p1;
 142                 --p2;
 143                 --move;
 144         }
 145         while (move-- > 0)
 146                 *p2-- = *p1--;
 147         p1 = s + idx;
 148         if (idx + li >= maxstrlen)
 149         {
 150                 li = maxstrlen - idx - 1;
 151         }
 152         while (li-- > 0)
 153                 *p1++ = *ins++;
 154         s[maxstrlen - 1] = '\0';
 155 }
 156
 157 /*-------------------------------------------------------------------------
 158  *
 159  *  NAME          findEnvVar
 160  *
 161  *  FUNCTION      Find first environment variable in a string.
 162  *
 163  *  INPUT         s       the string to scan.
 164  *
 165  *  OUTPUT        len     length of variable, including $ and { }.
 166  *
 167  *  RETURNS       Pointer to the $ that introduces the variable, or NULL
 168  *                if no variable is found.
 169  *
 170  *  DESCRIPTION   Searches for matches like $NAME and ${NAME}, where NAME is
 171  *                a sequence of characters, digits and underscores, of which
 172  *                the first can not be a digit.
 173  *
 174  *  NOTE          This function will only return `legal' variables. There
 175  *                may be $'s in the string that are not followed by what
 176  *                is considered a legal variable name introducer. Such
 177  *                occurrences are skipped.
 178  *
 179  */
 180 static char *findEnvVar(const char *s, int *len)
 181 {
 182         int   brace = 0;
 183         char  *ret = NULL;
 184         const char *next;
 185
 186         if (!s)
 187                 return NULL;
 188         while (*s) {
 189                 next = s + 1;
 190                 if (*s == '$' &&
 191                     (isalpha(*next) || *next == '_' || *next == '{')) {
 192                         ret = (char *) s++;
 193                         if (*s == '{') {
 194                                 brace = 1;
 195                                 ++s;
 196                         }
 197                         while (*s && (isalnum(*s) || *s == '_'))
 198                                 ++s;
 199                         *len = s - ret;
 200                         if (brace) {
 201                                 if (*s == '}') {
 202                                         ++*len;
 203                                         break;
 204                                 }
 205                                 ret = NULL;
 206                         } else
 207                                 break;
 208                 }
 209                 ++s;
 210         }
 211         return ret;
 212 }
 213
 214 /*-------------------------------------------------------------------------
 215  *
 216  *  FUNCTION      Look up environment variable.
 217  *
 218  *  INPUT         name    name of environment variable to look up. This
 219  *                        may include $ and { }.
 220  *                len     length for environment variable name (0 - ignore).
 221  *
 222  *  RETURNS       The variable contents, or "" if not found.
 223  *
 224  */
 225 static const char *getEnv(const char *name, int len)
 226 {
 227         static char *empty = "";
 228         char   *ret = NULL, *tmp, *p, *p2;
 229
 230         if ((tmp = safestrdup(name)) == NULL)
 231                 return empty;  /* better than no test at all. */
 232         p = tmp;
 233         if (*p == '$')
 234                 ++p;
 235         if (*p == '{') {
 236                 ++p;
 237                 if ((p2 = strchr(p, '}')) != NULL)
 238                         *p2 = '\0';
 239         }
 240         if (len > 0 && len < strlen(tmp)) tmp[len] = '\0';
 241         if ((ret = getenv(p)) == NULL)
 242                 ret = empty;
 243         free(tmp);
 244         return ret;
 245 }
 246
 247 /* ---------------------------- interface functions ------------------------ */
 248
 249 /*
 250  *  FUNCTION      Expand environment variables in a string.
 251  *
 252  *  SYNOPSIS      #include "envvar.h"
 253  *                int envExpand(char *s, int maxstrlen);
 254  *
 255  *  INPUT         s       string to expand environment variables in.
 256  *                maxstrlen     max length of string, including '\0'.
 257  *
 258  *  OUTPUT        s       the string with environment variables expanded.
 259  *
 260  *  RETURNS       Number of changes done.
 261  *
 262  *  NOTES         A non-existing variable is substituted with the empty
 263  *                string.
 264  *
 265  */
 266 int envExpand(char *s, int maxstrlen)
 267 {
 268         char  *var, *s2;
 269         const char *env;
 270         int   len, ret = 0;
 271
 272         s2 = s;
 273         while ((var = findEnvVar(s2, &len)) != NULL) {
 274                 ++ret;
 275                 env = getEnv(var, len);
 276                 strDel(s, var - s, len);
 277                 strIns(s, env, var - s, maxstrlen);
 278                 s2 = var + strlen(env);
 279         }
 280         return ret;
 281 }
 282
 283 /*
 284  *  FUNCTION      Expand environment variables into a new string.
 285  *
 286  *  SYNOPSIS      #include "envvar.h"
 287  *                char *envDupExpand(const char *s, int extra);
 288  *
 289  *  INPUT         s       string to expand environment variables in.
 290  *                extra   number of extra bytes to allocate in the
 291  *                        string, in addition to the string contents
 292  *                        and the terminating '\0'.
 293  *
 294  *  RETURNS       A dynamically allocated string with environment
 295  *                variables expanded.
 296  *                Use free() to deallocate the buffer when it is no
 297  *                longer needed.
 298  *                NULL is returned if there is not enough memory.
 299  *
 300  *  NOTES         A non-existing variable is substituted with the empty
 301  *                string.
 302  *
 303  */
 304 char *envDupExpand(const char *s, int extra)
 305 {
 306         char  *var, *ret;
 307         const char *env, *s2;
 308         int   len, slen, elen, bufflen;
 309
 310         /*
 311          *  calculate length needed.
 312          */
 313         s2 = s;
 314         slen = strlen(s);
 315         bufflen = slen + 1 + extra;
 316         while ((var = findEnvVar(s2, &len)) != NULL) {
 317                 env = getEnv(var, len);
 318                 elen = strlen(env);
 319                 /* need to make a buffer the maximum possible size, else we
 320                  * may get trouble while expanding. */
 321                 bufflen += len > elen ? len : elen;
 322                 s2 = var + len;
 323         }
 324         if (bufflen < slen + 1)
 325                 bufflen = slen + 1;
 326
 327         ret = safemalloc(bufflen);
 328
 329         /*
 330          *  now do the real expansion.
 331          */
 332         strcpy(ret, s);
 333         envExpand(ret, bufflen - extra);
 334
 335         return ret;
 336 }
 337
 338 /*
 339  *  FUNCTION      Search for the first environment variable and return
 340  *                its contents and coordinates in the given string.
 341  *
 342  *  INPUT         s       the string to scan.
 343  *                        may include $ and { } that introduce variable.
 344  *
 345  *  OUTPUT        beg     index in the string of matching $.
 346  *                end     index in the string, first after matching var.
 347  *
 348  *  RETURNS       The variable contents; "" if env variable has legal name,
 349  *                but does not exist; or NULL if no env variables found.
 350  *                Returned constant string must not be deallocated.
 351  *
 352  *  NOTE          This function will only return `legal' variables. There
 353  *                may be $'s in the string that are not followed by what
 354  *                is considered a legal variable name introducer. Such
 355  *                occurrences are skipped.
 356  *                If nothing is found returns NULL and sets beg and end to 0.
 357  *
 358  *  EXAMPLE       getFirstEnv("echo $HOME/.fvwm/config", &beg, &end)
 359  *                returns "/home/username" and beg=5, end=10.
 360  *
 361  */
 362 const char* getFirstEnv(const char *s, int *beg, int *end)
 363 {
 364         char *var;
 365         const char *env;
 366         int len;
 367
 368         *beg = *end = 0;
 369         if ((var = findEnvVar(s, &len)) == NULL) return NULL;
 370         env = getEnv(var, len);
 371
 372         *beg = var - s;
 373         *end = *beg + len;
 374
 375         return env;
 376 }
 377
 378 /* If env is NULL, var is removed from the environment list */
 379 static void add_to_envlist(char *var, char *env)
 380 {
 381         static env_list_item *env_list = NULL;
 382         static unsigned int env_len = 0;
 383         static unsigned int env_len_allocated = 0;
 384         unsigned int i;
 385
 386         /* find string in list */
 387         if (env_list && env_len)
 388         {
 389                 for (i = 0; i < env_len; i++)
 390                 {
 391                         if (strcmp(var, env_list[i].var) != 0)
 392                         {
 393                                 continue;
 394                         }
 395                         /* found it - replace old string */
 396                         free(env_list[i].var);
 397                         free(env_list[i].env);
 398                         if (env == NULL)
 399                         {
 400                                 /* delete */
 401                                 env_len--;
 402                                 env_list[i].var =
 403                                         env_list[env_len].var;
 404                                 env_list[i].env =
 405                                         env_list[env_len].env;
 406                         }
 407                         else
 408                         {
 409                                 /* replace */
 410                                 env_list[i].var = var;
 411                                 env_list[i].env = env;
 412                         }
 413
 414                         return;
 415                 }
 416         }
 417         if (env == NULL)
 418         {
 419                 return;
 420         }
 421         /* not found */
 422         if (env_list == NULL)
 423         {
 424                 /* list is still empty */
 425                 env_len_allocated = ENV_LIST_INC;
 426                 env_list = (env_list_item *)safecalloc(
 427                         sizeof(env_list_item), env_len_allocated);
 428         }
 429         else if (env_len >= env_len_allocated && env != NULL)
 430         {
 431                 /* need more memory */
 432                 env_len_allocated = env_len + ENV_LIST_INC;
 433                 env_list = (env_list_item *)saferealloc(
 434                         (void *)env_list, (env_len_allocated) *
 435                         sizeof(env_list_item));
 436         }
 437         env_list[env_len].var = var;
 438         env_list[env_len].env = env;
 439         env_len++;
 440
 441         return;
 442 }
 443
 444 /* This function keeps a list of all strings that were set in the environment.
 445  * If a variable is written again, the old memory is freed.  This function
 446  * should be called instead of putenv().
 447  *
 448  *   var - environement variable name
 449  *   env - environment string ("variable=value")
 450  *
 451  * Both arguments are copied internally and should be freed after calling this
 452  * function.
 453  */
 454 void flib_putenv(char *var, char *env)
 455 {
 456         char *s;
 457
 458         s = safestrdup(var);
 459         var = s;
 460         s = safestrdup(env);
 461         env = s;
 462         putenv(env);
 463         add_to_envlist(var, env);
 464
 465         return;
 466 }
 467
 468 void flib_unsetenv(const char *name)
 469 {
 470         if (FHaveUnsetenv)
 471         {
 472                 unsetenv(name);
 473         }
 474         else
 475         {
 476                 int rc;
 477
 478                 /* try putenv without '=' */
 479                 rc = putenv((char *)name);
 480                 if (rc == 0 || getenv(name) != NULL)
 481                 {
 482                         /* failed, write empty string */
 483                         flib_putenv((char *)name, "");
 484                         return;
 485                 }
 486         }
 487         add_to_envlist((char *)name, NULL);
 488
 489         return;
 490 }