gprofng/libcollector/envmgmt.c

   1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
   2    Contributed by Oracle.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 /*
  22  *      Routines for managing the target's environment array
  23  */
  24
  25 #include "config.h"
  26 #include "descendants.h"
  27
  28 #define MAX_LD_PRELOADS 2
  29
  30 /* TprintfT(<level>,...) definitions.  Adjust per module as needed */
  31 #define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
  32 #define DBG_LT1 1 // for configuration details, warnings
  33 #define DBG_LT2 2
  34 #define DBG_LT3 3
  35 #define DBG_LT4 4
  36
  37 /* original environment settings to be saved for later restoration */
  38 static char *sp_preloads[MAX_LD_PRELOADS];
  39 static char *sp_libpaths[MAX_LD_PRELOADS];
  40 char **sp_env_backup;
  41
  42 static const char *SP_ENV[];
  43 static const char *LD_ENV[];
  44 static const char *SP_PRELOAD[];
  45 static const char *LD_PRELOAD[];
  46 static const char *SP_LIBRARY_PATH[];
  47 static const char *LD_LIBRARY_PATH[];
  48 static int NUM_SP_ENV_VARS;
  49 static int NUM_LD_ENV_VARS;
  50 static int NUM_SP_PRELOADS;
  51 static int NUM_LD_PRELOADS;
  52 static int NUM_SP_LIBPATHS;
  53 static int NUM_LD_LIBPATHS;
  54
  55 static const char *SP_ENV[] = {
  56   SP_COLLECTOR_PARAMS,      /* data descriptor */
  57   SP_COLLECTOR_EXPNAME,     /* experiment name */
  58   SP_COLLECTOR_FOLLOW_SPEC, /* linetrace */
  59   SP_COLLECTOR_FOUNDER,     /* determine founder exp */
  60   SP_PRELOAD_STRINGS,       /* LD_PRELOADs for data collection */
  61   SP_LIBPATH_STRINGS,       /* LD_LIBRARY_PATHs for data collection */
  62   "SP_COLLECTOR_TRACELEVEL", /* tprintf */
  63 #if DEBUG
  64   "SP_COLLECTOR_SIGACTION", /* dispatcher, hwprofile */
  65 #endif
  66   /* JAVA* */
  67   /* LD_DEBUG=audit,bindings,detail */
  68   /* LD_ORIGIN=yes */
  69   NULL
  70 };
  71
  72 static const char *LD_ENV[] = {
  73   LD_PRELOAD_STRINGS,       /* LD_PRELOADs */
  74   LD_LIBPATH_STRINGS,       /* LD_LIBRARY_PATHs */
  75   JAVA_TOOL_OPTIONS,        /* enable -agentlib:collector for JVMTI */
  76   NULL
  77 };
  78
  79 static const char *SP_PRELOAD[] = {
  80   SP_PRELOAD_STRINGS,
  81   NULL
  82 };
  83
  84 static const char *LD_PRELOAD[] = {
  85   LD_PRELOAD_STRINGS,
  86   NULL
  87 };
  88
  89 static const char *SP_LIBRARY_PATH[] = {
  90   SP_LIBPATH_STRINGS,
  91   NULL
  92 };
  93 static const char *LD_LIBRARY_PATH[] = {
  94   LD_LIBPATH_STRINGS,
  95   NULL
  96 };
  97
  98 void
  99 __collector_env_save_preloads ()
 100 {
 101   /* save the list of SP_PRELOADs */
 102   int v;
 103   for (v = 0; SP_PRELOAD[v]; v++)
 104     {
 105       sp_preloads[v] = __collector_strdup (CALL_UTIL (getenv)(SP_PRELOAD[v]));
 106       TprintfT (DBG_LT3, "__collector_env_save_preloads: %s=%s\n", SP_PRELOAD[v], sp_preloads[v]);
 107     }
 108   NUM_SP_PRELOADS = v;
 109   for (v = 0; SP_LIBRARY_PATH[v]; v++)
 110     {
 111       sp_libpaths[v] = __collector_strdup (CALL_UTIL (getenv)(SP_LIBRARY_PATH[v]));
 112       TprintfT (DBG_LT4, "__collector_env_save_preloads: %s=%s\n", SP_LIBRARY_PATH[v],
 113                 sp_libpaths[v] ? sp_libpaths[v] : "NULL");
 114     }
 115   NUM_SP_LIBPATHS = v;
 116   for (v = 0; LD_PRELOAD[v]; v++)
 117     ;
 118   NUM_LD_PRELOADS = v;
 119   for (v = 0; LD_LIBRARY_PATH[v]; v++)
 120     ;
 121   NUM_LD_LIBPATHS = v;
 122   for (v = 0; SP_ENV[v]; v++)
 123     ;
 124   NUM_SP_ENV_VARS = v;
 125   for (v = 0; LD_ENV[v]; v++)
 126     ;
 127   NUM_LD_ENV_VARS = v;
 128 }
 129
 130 /* free the memory involved in backing up the environment */
 131 void
 132 __collector_env_backup_free ()
 133 {
 134   int v = 0;
 135   TprintfT (DBG_LT2, "env_backup_free()\n");
 136   for (v = 0; sp_env_backup[v]; v++)
 137     {
 138       TprintfT (DBG_LT2, "env_backup_free():sp_env_backup[%d]=%s \n", v, sp_env_backup[v]);
 139       __collector_freeCSize (__collector_heap, (char *) sp_env_backup[v], __collector_strlen (sp_env_backup[v]) + 1);
 140     }
 141   __collector_freeCSize (__collector_heap, (char**) sp_env_backup,
 142                          (NUM_SP_ENV_VARS + NUM_LD_ENV_VARS + 1) * sizeof (char*));
 143 }
 144
 145 char **
 146 __collector_env_backup ()
 147 {
 148   TprintfT (DBG_LT2, "env_backup_()\n");
 149   char **backup = __collector_env_allocate (NULL, 1);
 150   __collector_env_update (backup);
 151   TprintfT (DBG_LT2, "env_backup_()\n");
 152   return backup;
 153 }
 154
 155 /*
 156    function: env_prepend()
 157      given an <old_str>, check to see if <str>
 158      is already defined by it.  If not, allocate
 159      a new string and concat <envvar>=<str><separator><old_str>
 160    params:
 161      old_str: original string
 162      str: substring to prepend
 163      return: pointer to updated string or NULL if string was not updated.
 164  */
 165 static char *
 166 env_prepend (const char *envvar, const char *str, const char *separator,
 167              const char *old_str)
 168 {
 169   if (!envvar || *envvar == 0 || !str || *str == 0)
 170     {
 171       /* nothing to do */
 172       TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\") -- nothing to do\n",
 173                 envvar, str, separator, old_str);
 174
 175       return NULL;
 176     }
 177   TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\")\n",
 178             envvar, str, separator, old_str);
 179   char *ev;
 180   size_t strsz;
 181   if (!old_str || *old_str == 0)
 182     {
 183       strsz = __collector_strlen (envvar) + 1 + __collector_strlen (str) + 1;
 184       ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
 185       if (ev)
 186         {
 187           CALL_UTIL (snprintf)(ev, strsz, "%s=%s", envvar, str);
 188           assert (__collector_strlen (ev) + 1 == strsz);
 189         }
 190       else
 191         TprintfT (DBG_LT2, "env_prepend(): could not allocate memory\n");
 192     }
 193   else
 194     {
 195       char *p = CALL_UTIL (strstr)(old_str, str);
 196       if (p)
 197         {
 198           TprintfT (DBG_LT2, "env_prepend(): %s=%s was already set\n",
 199                     envvar, old_str);
 200           return NULL;
 201         }
 202       strsz = __collector_strlen (envvar) + 1 + __collector_strlen (str) +
 203               __collector_strlen (separator) + __collector_strlen (old_str) + 1;
 204       ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
 205       if (ev)
 206         {
 207           CALL_UTIL (snprintf)(ev, strsz, "%s=%s%s%s", envvar, str, separator, old_str);
 208           assert (__collector_strlen (ev) + 1 == strsz);
 209         }
 210       else
 211         TprintfT (DBG_LT2, "env_prepend(): could not allocate memory\n");
 212     }
 213   TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\") returns \"%s\"\n",
 214             envvar, str, separator, old_str, (ev == NULL ? "NULL" : ev));
 215   return ev;
 216 }
 217
 218 /*
 219    function: putenv_prepend()
 220      get environment variable <envvar>, check to see if <str>
 221      is already defined by it.  If not prepend <str>
 222      and put it back to environment.
 223    params:
 224      envvar: environment variable
 225      str: substring to find
 226      return: 0==success, nonzero on failure.
 227  */
 228 int
 229 putenv_prepend (const char *envvar, const char *str, const char *separator)
 230 {
 231   if (!envvar || *envvar == 0)
 232     return 1;
 233   const char * old_str = CALL_UTIL (getenv)(envvar);
 234   char * newstr = env_prepend (envvar, str, separator, old_str);
 235   if (newstr)
 236     // now put the new variable into the environment
 237     if (CALL_UTIL (putenv)(newstr) != 0)
 238       {
 239         TprintfT (DBG_LT2, "putenv_prepend(): ERROR %s is not set!\n", newstr);
 240         return 1;
 241       }
 242   return 0;
 243 }
 244
 245 /*
 246    function: env_strip()
 247      Finds substr in origstr; Removes
 248      all characters from previous ':' or ' '
 249      up to and including any trailing ':' or ' '.
 250    params:
 251      env: environment variable contents
 252      str: substring to find
 253      return: count of instances removed from env
 254  */
 255 static int
 256 env_strip (char *origstr, const char *substr)
 257 {
 258   int removed = 0;
 259   char *p, *q;
 260   if (origstr == NULL || substr == NULL || *substr == 0)
 261     return 0;
 262   while ((p = q = CALL_UTIL (strstr)(origstr, substr)))
 263     {
 264       p += __collector_strlen (substr);
 265       while (*p == ':' || *p == ' ') /* strip trailing separator */
 266         p++;
 267       while (*q != ':' && *q != ' ' && *q != '=' && q != origstr) /* strip path */
 268         q--;
 269       if (q != origstr) /* restore leading separator (if any) */
 270         q++;
 271       __collector_strlcpy (q, p, __collector_strlen (p) + 1);
 272       removed++;
 273     }
 274   return removed;
 275 }
 276
 277 /*
 278    function: env_ld_preload_strip()
 279      Removes known libcollector shared objects from envv.
 280    params:
 281      var: shared object name (leading characters don't have to match)
 282      return: 0 = so's removed, non-zero = so's not found.
 283  */
 284 static int
 285 env_ld_preload_strip (char *envv)
 286 {
 287   if (!envv || *envv == 0)
 288     {
 289       TprintfT (DBG_LT2, "env_ld_preload_strip(): WARNING - envv is NULL\n");
 290       return -1;
 291     }
 292   for (int v = 0; SP_PRELOAD[v]; v++)
 293     if (env_strip (envv, sp_preloads[v]))
 294       return 0;
 295   if (line_mode != LM_CLOSED)
 296     TprintfT (DBG_LT2, "env_ld_preload_strip(): WARNING - could not strip SP_PRELOADS from '%s'\n",
 297               envv);
 298   return -2;
 299 }
 300
 301 void
 302 __collector_env_print (char * label)
 303 {
 304 #if DEBUG
 305   TprintfT (DBG_LT2, "__collector_env_print(%s)\n", label);
 306   for (int v = 0; v < MAX_LD_PRELOADS; v++)
 307     TprintfT (DBG_LT2, " %s  sp_preloads[%d] (0x%p)=%s\n", label,
 308               v, sp_preloads[v], (sp_preloads[v] == NULL ? "NULL" : sp_preloads[v]));
 309   for (int v = 0; SP_ENV[v]; v++)
 310     {
 311       char *s = CALL_UTIL (getenv)(SP_ENV[v]);
 312       if (s == NULL)
 313         s = "<null>";
 314       TprintfT (DBG_LT2, " %s  SP_ENV[%d] (0x%p): %s=\"%s\"\n", label, v, SP_ENV[v], SP_ENV[v], s);
 315     }
 316   for (int v = 0; LD_ENV[v]; v++)
 317     {
 318       char *s = CALL_UTIL (getenv)(LD_ENV[v]);
 319       if (s == NULL)
 320         s = "<null>";
 321       TprintfT (DBG_LT2, " %s  LD_ENV[%d] (0x%p): %s=\"%s\"\n", label, v, LD_ENV[v], LD_ENV[v], s);
 322     }
 323 #endif
 324 }
 325
 326 void
 327 __collector_env_printall (char *label, char *envp[])
 328 {
 329 #if DEBUG
 330   TprintfT (DBG_LT2, "__collector_env_printall(%s): environment @ 0x%p\n", label, envp);
 331   for (int i = 0; envp[i]; i++)
 332     Tprintf (DBG_LT2, "\tenv[%d]@0x%p == %s\n", i, envp[i], envp[i]);
 333 #endif
 334 }
 335
 336 /* match collector environment variable */
 337 int
 338 env_match (char *envp[], const char *envvar)
 339 {
 340   int match = -1;
 341   if (envp == NULL)
 342     TprintfT (DBG_LT1, "env_match(%s): NULL envp!\n", envvar);
 343   else
 344     {
 345       int i = 0;
 346       while ((envp[i] != NULL) && (__collector_strStartWith (envp[i], envvar)))
 347         i++;
 348       if ((envp[i] == NULL) || (envp[i][__collector_strlen (envvar)] != '='))
 349         TprintfT (DBG_LT4, "env_match(): @%p []%s not defined in envp\n", envp, envvar);
 350       else
 351         {
 352           TprintfT (DBG_LT4, "env_match(): @%p [%d]%s defined in envp\n", envp, i, envp[i]);
 353           match = i;
 354         }
 355     }
 356   TprintfT (DBG_LT1, "env_match(%s): found in slot %d\n", envvar, match);
 357   return (match);
 358 }
 359
 360 /* allocate new environment with collector variables */
 361 /* 1) copy all current envp[] ptrs into a new array, coll_env[] */
 362 /* 2) if collector-related env ptrs not in envp[], append them to coll_env */
 363 /*     from processes' "environ" (allocate_env==1) */
 364 /*     or from sp_env_backup (allocate_env==0)*/
 365 /*     If they already exist in envp, probably is an error... */
 366 /* 3) return coll_env */
 367
 368 /* __collector__env_update() need be called after this to set LD_ENV*/
 369 char **
 370 __collector_env_allocate (char *const old_env[], int allocate_env)
 371 {
 372   extern char **environ;    /* the process' actual environment */
 373   char **new_env;           /* a new environment for collection */
 374   TprintfT (DBG_LT3, "__collector_env_allocate(old_env=0x%p %s environ=0x%p)\n",
 375             old_env, (old_env == environ) ? "==" : "!=", environ);
 376   /* set up a copy of the provided old_env for collector use */
 377   int old_env_size = 0;
 378
 379   /* determine number of (used) slots in old_env */
 380   if (old_env)
 381     while (old_env[old_env_size] != NULL)
 382       old_env_size++;
 383   /* allocate a new vector with additional slots */
 384   int new_env_alloc_sz = old_env_size + NUM_SP_ENV_VARS + NUM_LD_ENV_VARS + 1;
 385   new_env = (char**) __collector_allocCSize (__collector_heap, new_env_alloc_sz * sizeof (char*), 1);
 386   if (new_env == NULL)
 387     return NULL;
 388   TprintfT (DBG_LT4, "__collector_env_allocate(): old_env has %d entries, new_env @ 0x%p\n", old_env_size, new_env);
 389
 390   /* copy provided old_env pointers to new collector environment */
 391   int new_env_size = 0;
 392   for (new_env_size = 0; new_env_size < old_env_size; new_env_size++)
 393     new_env[new_env_size] = old_env[new_env_size];
 394
 395   /* check each required environment variable, adding as required */
 396   const char * env_var;
 397   int v;
 398   for (v = 0; (env_var = SP_ENV[v]) != NULL; v++)
 399     {
 400       if (env_match ((char**) old_env, env_var) == -1)
 401         {
 402           int idx;
 403           /* not found in old_env */
 404           if (allocate_env)
 405             {
 406               if ((idx = env_match (environ, env_var)) != -1)
 407                 {
 408                   /* found in environ */
 409                   TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
 410                             new_env_size, environ[idx]);
 411                   int varsz = __collector_strlen (environ[idx]) + 1;
 412                   char * var = (char*) __collector_allocCSize (__collector_heap, varsz, 1);
 413                   if (var == NULL)
 414                     return NULL;
 415                   __collector_strlcpy (var, environ[idx], varsz);
 416                   new_env[new_env_size++] = var;
 417                 }
 418               else
 419                 {
 420                   /* not found in environ */
 421                   if ((__collector_strcmp (env_var, SP_COLLECTOR_PARAMS) == 0) ||
 422                       (__collector_strcmp (env_var, SP_COLLECTOR_EXPNAME) == 0))
 423                     TprintfT (DBG_LT1, "__collector_env_allocate(): note: %s environment variable not found\n",
 424                               env_var);
 425                 }
 426             }
 427           else
 428             {
 429               if ((idx = env_match (sp_env_backup, env_var)) != -1)
 430                 {
 431                   /* found in backup */
 432                   TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
 433                             new_env_size, sp_env_backup[idx]);
 434                   new_env[new_env_size++] = sp_env_backup[idx];
 435                 }
 436               else
 437                 {
 438                   /* not found in environ */
 439                   if ((__collector_strcmp (env_var, SP_COLLECTOR_PARAMS) == 0) ||
 440                       (__collector_strcmp (env_var, SP_COLLECTOR_EXPNAME) == 0))
 441                     TprintfT (DBG_LT1, "__collector_env_allocate(): note: %s environment variable not found\n",
 442                                 env_var);
 443                 }
 444             }
 445         }
 446     }
 447
 448   for (v = 0; (env_var = LD_ENV[v]) != NULL; v++)
 449     {
 450       if (env_match ((char**) old_env, env_var) == -1)
 451         {
 452           int idx;
 453           /* not found in old_env */
 454           if (allocate_env)
 455             {
 456               if ((idx = env_match (environ, env_var)) != -1)
 457                 {
 458                   /* found in environ */
 459                   TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
 460                             new_env_size, environ[idx]);
 461
 462                   int varsz = __collector_strlen (env_var) + 2;
 463                   char * var = (char*) __collector_allocCSize (__collector_heap, varsz, 1);
 464                   if (var == NULL)
 465                     return NULL;
 466                   // assume __collector_env_update() will fill content of env_var
 467                   CALL_UTIL (snprintf)(var, varsz, "%s=", env_var);
 468                   new_env[new_env_size++] = var;
 469                 }
 470             }
 471           else
 472             {
 473               if ((idx = env_match (sp_env_backup, env_var)) != -1)
 474                 {
 475                   /* found in backup */
 476                   TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
 477                             new_env_size, sp_env_backup[idx]);
 478                   new_env[new_env_size++] = sp_env_backup[idx];
 479                 }
 480             }
 481         }
 482     }
 483
 484   /* ensure new_env vector ends with NULL */
 485   new_env[new_env_size] = NULL;
 486   assert (new_env_size <= new_env_alloc_sz);
 487   TprintfT (DBG_LT4, "__collector_env_allocate(): new_env has %d entries (%d added), new_env=0x%p\n",
 488             new_env_size, new_env_size - old_env_size, new_env);
 489   if (new_env_size != old_env_size && !allocate_env)
 490     __collector_log_write ("<event kind=\"%s\" id=\"%d\">%d</event>\n",
 491                            SP_JCMD_CWARN, COL_WARN_EXECENV, new_env_size - old_env_size);
 492   __collector_env_printall ("__collector_env_allocate", new_env);
 493   return (new_env);
 494 }
 495
 496 /* unset collection environment variables */
 497 /* if they exist in env... */
 498 /* 1) push non-collectorized version to env */
 499
 500 /* Not mt safe */
 501 void
 502 __collector_env_unset (char *envp[])
 503 {
 504   int v;
 505   const char * env_name;
 506   TprintfT (DBG_LT3, "env_unset(envp=0x%p)\n", envp);
 507   if (envp == NULL)
 508     {
 509       for (v = 0; (env_name = LD_PRELOAD[v]); v++)
 510         {
 511           const char *env_val = CALL_UTIL (getenv)(env_name);
 512           if (env_val && CALL_UTIL (strstr)(env_val, sp_preloads[v]))
 513             {
 514               size_t sz = __collector_strlen (env_name) + 1 + __collector_strlen (env_val) + 1;
 515               char * ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
 516               if (ev == NULL)
 517                 return;
 518               CALL_UTIL (snprintf)(ev, sz, "%s=%s", env_name, env_val);
 519               assert (__collector_strlen (ev) + 1 == sz);
 520               TprintfT (DBG_LT4, "env_unset(): old %s\n", ev);
 521               env_ld_preload_strip (ev);
 522               CALL_UTIL (putenv)(ev);
 523               TprintfT (DBG_LT4, "env_unset(): new %s\n", ev);
 524             }
 525         }
 526       // unset JAVA_TOOL_OPTIONS
 527       env_name = JAVA_TOOL_OPTIONS;
 528       const char * env_val = CALL_UTIL (getenv)(env_name);
 529       if (env_val && CALL_UTIL (strstr)(env_val, COLLECTOR_JVMTI_OPTION))
 530         {
 531           size_t sz = __collector_strlen (env_name) + 1 + __collector_strlen (env_val) + 1;
 532           char * ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
 533           if (ev == NULL)
 534             return;
 535           CALL_UTIL (snprintf)(ev, sz, "%s=%s", env_name, env_val);
 536           assert (__collector_strlen (ev) + 1 == sz);
 537           TprintfT (DBG_LT4, "env_unset(): old %s\n", ev);
 538           env_strip (ev, COLLECTOR_JVMTI_OPTION);
 539           CALL_UTIL (putenv)(ev);
 540           TprintfT (DBG_LT4, "env_unset(): new %s\n", ev);
 541         }
 542       __collector_env_print ("__collector_env_unset");
 543     }
 544   else
 545     {
 546       __collector_env_printall ("__collector_env_unset, before", envp);
 547       for (v = 0; (env_name = LD_PRELOAD[v]); v++)
 548         {
 549           int idx = env_match (envp, env_name);
 550           if (idx != -1)
 551             {
 552               char *env_val = envp[idx];
 553               TprintfT (DBG_LT4, "env_unset(): old %s\n", env_val);
 554               envp[idx] = "junk="; /* xxxx is it ok to use original string? */
 555               env_ld_preload_strip (env_val);
 556               envp[idx] = env_val;
 557               TprintfT (DBG_LT4, "env_unset(): new %s\n", envp[idx]);
 558             }
 559         }
 560         // unset JAVA_TOOL_OPTIONS
 561         env_name = JAVA_TOOL_OPTIONS;
 562         int idx = env_match(envp, env_name);
 563         if (idx != -1) {
 564             char *env_val = envp[idx];
 565             TprintfT(DBG_LT4, "env_unset(): old %s\n", env_val);
 566             envp[idx] = "junk="; /* xxxx is it ok to use original string? */
 567             env_strip(env_val, COLLECTOR_JVMTI_OPTION);
 568             envp[idx] = env_val;
 569             TprintfT(DBG_LT4, "env_unset(): new %s\n", envp[idx]);
 570         }
 571         __collector_env_printall ("__collector_env_unset, after", envp );
 572     }
 573 }
 574
 575 /* update collection environment variables */
 576 /* update LD_PRELOADs and push them */
 577 /* not mt safe */
 578 void
 579 __collector_env_update (char *envp[])
 580 {
 581   const char *env_name;
 582   TprintfT (DBG_LT1, "__collector_env_update(envp=0x%p)\n", envp);
 583   extern char **environ;
 584   if (envp == NULL)
 585     {
 586       int v;
 587       TprintfT (DBG_LT2, "__collector_env_update(envp=NULL)\n");
 588       __collector_env_printall ("  environ array, before", environ);
 589       __collector_env_print ("  env_update at entry ");
 590
 591       /* SP_ENV */
 592       for (v = 0; (env_name = SP_ENV[v]) != NULL; v++)
 593         {
 594           if (env_match (environ, env_name) == -1)
 595             {
 596               int idx;
 597               if ((idx = env_match (sp_env_backup, env_name)) != -1)
 598                 {
 599                   unsigned strsz = __collector_strlen (sp_env_backup[idx]) + 1;
 600                   char *ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
 601                   CALL_UTIL (snprintf)(ev, strsz, "%s", sp_env_backup[idx]);
 602                   if (CALL_UTIL (putenv)(ev) != 0)
 603                     TprintfT (DBG_LT2, "__collector_env_update(): ERROR %s is not set!\n",
 604                                 sp_env_backup[idx]);
 605                 }
 606             }
 607         }
 608       __collector_env_print ("  env_update after SP_ENV settings ");
 609
 610       /* LD_LIBRARY_PATH */
 611       for (v = 0; (env_name = LD_LIBRARY_PATH[v]); v++)
 612         /* assumes same index used between LD and SP vars */
 613         if (putenv_prepend (env_name, sp_libpaths[v], ":"))
 614           TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
 615                     env_name, sp_libpaths[v]);
 616       __collector_env_print ("  env_update after LD_LIBRARY_PATH settings ");
 617
 618       /* LD_PRELOAD */
 619       for (v = 0; (env_name = LD_PRELOAD[v]); v++)
 620         /* assumes same index used between LD and SP vars */
 621         if (putenv_prepend (env_name, sp_preloads[v], " "))
 622           TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
 623                     env_name, sp_preloads[v]);
 624       __collector_env_print ("  env_update after LD_PRELOAD settings ");
 625
 626       /* JAVA_TOOL_OPTIONS */
 627       if (java_mode)
 628         if (putenv_prepend (JAVA_TOOL_OPTIONS, COLLECTOR_JVMTI_OPTION, " "))
 629           TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
 630                     JAVA_TOOL_OPTIONS, COLLECTOR_JVMTI_OPTION);
 631       __collector_env_print ("  env_update after JAVA_TOOL settings ");
 632     }
 633   else
 634     {
 635       int v;
 636       int idx;
 637       TprintfT (DBG_LT2, "__collector_env_update(envp=0x%p) not NULL\n", envp);
 638       __collector_env_printall ("__collector_env_update, before", envp);
 639       /* LD_LIBRARY_PATH */
 640       for (v = 0; (env_name = LD_LIBRARY_PATH[v]); v++)
 641         {
 642           int idx = env_match (envp, env_name);
 643           if (idx != -1)
 644             {
 645               char *env_val = __collector_strchr (envp[idx], '=');
 646               if (env_val)
 647                 env_val++; /* skip '=' */
 648               /* assumes same index used between LD and SP vars */
 649               char *new_str = env_prepend (env_name, sp_libpaths[v],
 650                                            ":", env_val);
 651               if (new_str)
 652                 envp[idx] = new_str;
 653             }
 654         }
 655
 656       /* LD_PRELOAD */
 657       for (v = 0; (env_name = LD_PRELOAD[v]); v++)
 658         {
 659           int idx = env_match (envp, env_name);
 660           if (idx != -1)
 661             {
 662               char *env_val = __collector_strchr (envp[idx], '=');
 663               if (env_val)
 664                 env_val++; /* skip '=' */
 665               /* assumes same index used between LD and SP vars */
 666               char *new_str = env_prepend (env_name, sp_preloads[v],
 667                                            " ", env_val);
 668               if (new_str)
 669                 envp[idx] = new_str;
 670             }
 671         }
 672
 673       /* JAVA_TOOL_OPTIONS */
 674       if (java_mode)
 675         {
 676           env_name = JAVA_TOOL_OPTIONS;
 677           idx = env_match (envp, env_name);
 678           if (idx != -1)
 679             {
 680               char *env_val = __collector_strchr (envp[idx], '=');
 681               if (env_val)
 682                 env_val++; /* skip '=' */
 683               char *new_str = env_prepend (env_name, COLLECTOR_JVMTI_OPTION,
 684                                            " ", env_val);
 685               if (new_str)
 686                 envp[idx] = new_str;
 687             }
 688         }
 689     }
 690   __collector_env_printall ("__collector_env_update, after", environ);
 691 }
 692
 693
 694 /*------------------------------------------------------------- putenv */
 695 int putenv () __attribute__ ((weak, alias ("__collector_putenv")));
 696 int _putenv () __attribute__ ((weak, alias ("__collector_putenv")));
 697
 698 int
 699 __collector_putenv (char * string)
 700 {
 701   if (CALL_UTIL (putenv) == __collector_putenv ||
 702       CALL_UTIL (putenv) == NULL)
 703     { // __collector_libc_funcs_init failed
 704       CALL_UTIL (putenv) = (int(*)())dlsym (RTLD_NEXT, "putenv");
 705       if (CALL_UTIL (putenv) == NULL || CALL_UTIL (putenv) == __collector_putenv)
 706           CALL_UTIL (putenv) = (int(*)())dlsym (RTLD_DEFAULT, "putenv");
 707       if (CALL_UTIL (putenv) == NULL || CALL_UTIL (putenv) == __collector_putenv)
 708         {
 709           TprintfT (DBG_LT2, "__collector_putenv(): ERROR: no pointer found.\n");
 710           errno = EBUSY;
 711           return -1;
 712         }
 713     }
 714   if (user_follow_mode == FOLLOW_NONE)
 715     return CALL_UTIL (putenv)(string);
 716   char * envp[] = {string, NULL};
 717   __collector_env_update (envp);
 718   return CALL_UTIL (putenv)(envp[0]);
 719 }
 720
 721 /*------------------------------------------------------------- setenv */
 722 int setenv () __attribute__ ((weak, alias ("__collector_setenv")));
 723 int _setenv () __attribute__ ((weak, alias ("__collector_setenv")));
 724
 725 int
 726 __collector_setenv (const char *name, const char *value, int overwrite)
 727 {
 728   if (CALL_UTIL (setenv) == __collector_setenv ||
 729       CALL_UTIL (setenv) == NULL)
 730     { // __collector_libc_funcs_init failed
 731       CALL_UTIL (setenv) = (int(*)())dlsym (RTLD_NEXT, "setenv");
 732       if (CALL_UTIL (setenv) == NULL || CALL_UTIL (setenv) == __collector_setenv)
 733         CALL_UTIL (setenv) = (int(*)())dlsym (RTLD_DEFAULT, "setenv");
 734       if (CALL_UTIL (setenv) == NULL || CALL_UTIL (setenv) == __collector_setenv)
 735         {
 736           TprintfT (DBG_LT2, "__collector_setenv(): ERROR: no pointer found.\n");
 737           errno = EBUSY;
 738           return -1;
 739         }
 740     }
 741   if (user_follow_mode == FOLLOW_NONE || !overwrite)
 742     return CALL_UTIL (setenv)(name, value, overwrite);
 743   size_t sz = __collector_strlen (name) + 1 + __collector_strlen (value) + 1;
 744   char *ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
 745   if (ev == NULL)
 746     return CALL_UTIL (setenv)(name, value, overwrite);
 747   CALL_UTIL (snprintf)(ev, sz, "%s=%s", name, value);
 748   char * envp[] = {ev, NULL};
 749   __collector_env_update (envp);
 750   if (envp[0] == ev)
 751     {
 752       __collector_freeCSize (__collector_heap, ev, sz);
 753       return CALL_UTIL (setenv)(name, value, overwrite);
 754     }
 755   else
 756     {
 757       char *env_val = __collector_strchr (envp[0], '=');
 758       if (env_val)
 759         {
 760           *env_val = '\0';
 761           env_val++; /* skip '=' */
 762         }
 763       return CALL_UTIL (setenv)(envp[0], env_val, overwrite);
 764     }
 765 }
 766
 767 /*------------------------------------------------------------- unsetenv */
 768 int unsetenv () __attribute__ ((weak, alias ("__collector_unsetenv")));
 769 int _unsetenv () __attribute__ ((weak, alias ("__collector_unsetenv")));
 770
 771 int
 772 __collector_unsetenv (const char *name)
 773 {
 774   if (CALL_UTIL (unsetenv) == __collector_unsetenv ||
 775       CALL_UTIL (unsetenv) == NULL)
 776     { // __collector_libc_funcs_init failed
 777       CALL_UTIL (unsetenv) = (int(*)())dlsym (RTLD_NEXT, "unsetenv");
 778       if (CALL_UTIL (unsetenv) == NULL || CALL_UTIL (unsetenv) == __collector_unsetenv)
 779         CALL_UTIL (unsetenv) = (int(*)())dlsym (RTLD_DEFAULT, "unsetenv");
 780       if (CALL_UTIL (unsetenv) == NULL || CALL_UTIL (unsetenv) == __collector_unsetenv)
 781         {
 782           TprintfT (DBG_LT2, "__collector_unsetenv(): ERROR: no pointer found.\n");
 783           errno = EBUSY;
 784           return -1;
 785         }
 786     }
 787   int ret = CALL_UTIL (unsetenv)(name);
 788   if (user_follow_mode == FOLLOW_NONE)
 789     return ret;
 790   TprintfT (DBG_LT2, "__collector_unsetenv(): %d.\n", user_follow_mode);
 791   size_t sz = __collector_strlen (name) + 1 + 1;
 792   char *ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
 793   if (ev == NULL)
 794     return ret;
 795   CALL_UTIL (snprintf)(ev, sz, "%s=", name);
 796   char * envp[] = {ev, NULL};
 797   __collector_env_update (envp);
 798   if (envp[0] == ev)
 799     __collector_freeCSize (__collector_heap, ev, sz);
 800   else
 801     CALL_UTIL (putenv)(envp[0]);
 802   return ret;
 803 }
 804
 805 /*------------------------------------------------------------- clearenv */
 806 int clearenv () __attribute__ ((weak, alias ("__collector_clearenv")));
 807
 808 int
 809 __collector_clearenv (void)
 810 {
 811   if (CALL_UTIL (clearenv) == __collector_clearenv || CALL_UTIL (clearenv) == NULL)
 812     {
 813       /* __collector_libc_funcs_init failed; look up clearenv now */
 814       CALL_UTIL (clearenv) = (int(*)())dlsym (RTLD_NEXT, "clearenv");
 815       if (CALL_UTIL (clearenv) == NULL || CALL_UTIL (clearenv) == __collector_clearenv)
 816         /* still not found; try again */
 817         CALL_UTIL (clearenv) = (int(*)())dlsym (RTLD_DEFAULT, "clearenv");
 818       if (CALL_UTIL (clearenv) == NULL || CALL_UTIL (clearenv) == __collector_clearenv)
 819         {
 820           /* still not found -- a fatal error */
 821           TprintfT (DBG_LT2, "__collector_clearenv(): ERROR: %s\n", dlerror ());
 822           CALL_UTIL (fprintf)(stderr, "__collector_clearenv(): ERROR: %s\n", dlerror ());
 823           errno = EBUSY;
 824           return -1;
 825         }
 826     }
 827   int ret = CALL_UTIL (clearenv)();
 828   if (user_follow_mode == FOLLOW_NONE)
 829     return ret;
 830   if (sp_env_backup == NULL)
 831     {
 832       TprintfT (DBG_LT2, "__collector_clearenv: ERROR sp_env_backup is not set!\n");
 833       return ret;
 834     }
 835   for (int v = 0; v < NUM_SP_ENV_VARS + NUM_LD_ENV_VARS; v++)
 836     if (sp_env_backup[v] && CALL_UTIL (putenv)(sp_env_backup[v]) != 0)
 837       TprintfT (DBG_LT2, "__collector_clearenv: ERROR %s is not set!\n",
 838                 sp_env_backup[v]);
 839   return ret;
 840 }