base/environment.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/environment.h"
   6
   7 #include <vector>
   8
   9 #include "base/strings/string_piece.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12
  13 #if defined(OS_POSIX)
  14 #include <stdlib.h>
  15 #elif defined(OS_WIN)
  16 #include <windows.h>
  17 #endif
  18
  19 namespace base {
  20
  21 namespace {
  22
  23 class EnvironmentImpl : public base::Environment {
  24  public:
  25   virtual bool GetVar(const char* variable_name,
  26                       std::string* result) OVERRIDE {
  27     if (GetVarImpl(variable_name, result))
  28       return true;
  29
  30     // Some commonly used variable names are uppercase while others
  31     // are lowercase, which is inconsistent. Let's try to be helpful
  32     // and look for a variable name with the reverse case.
  33     // I.e. HTTP_PROXY may be http_proxy for some users/systems.
  34     char first_char = variable_name[0];
  35     std::string alternate_case_var;
  36     if (first_char >= 'a' && first_char <= 'z')
  37       alternate_case_var = StringToUpperASCII(std::string(variable_name));
  38     else if (first_char >= 'A' && first_char <= 'Z')
  39       alternate_case_var = base::StringToLowerASCII(std::string(variable_name));
  40     else
  41       return false;
  42     return GetVarImpl(alternate_case_var.c_str(), result);
  43   }
  44
  45   virtual bool SetVar(const char* variable_name,
  46                       const std::string& new_value) OVERRIDE {
  47     return SetVarImpl(variable_name, new_value);
  48   }
  49
  50   virtual bool UnSetVar(const char* variable_name) OVERRIDE {
  51     return UnSetVarImpl(variable_name);
  52   }
  53
  54  private:
  55   bool GetVarImpl(const char* variable_name, std::string* result) {
  56 #if defined(OS_POSIX)
  57     const char* env_value = getenv(variable_name);
  58     if (!env_value)
  59       return false;
  60     // Note that the variable may be defined but empty.
  61     if (result)
  62       *result = env_value;
  63     return true;
  64 #elif defined(OS_WIN)
  65     DWORD value_length = ::GetEnvironmentVariable(
  66         UTF8ToWide(variable_name).c_str(), NULL, 0);
  67     if (value_length == 0)
  68       return false;
  69     if (result) {
  70       scoped_ptr<wchar_t[]> value(new wchar_t[value_length]);
  71       ::GetEnvironmentVariable(UTF8ToWide(variable_name).c_str(), value.get(),
  72                                value_length);
  73       *result = WideToUTF8(value.get());
  74     }
  75     return true;
  76 #else
  77 #error need to port
  78 #endif
  79   }
  80
  81   bool SetVarImpl(const char* variable_name, const std::string& new_value) {
  82 #if defined(OS_POSIX)
  83     // On success, zero is returned.
  84     return !setenv(variable_name, new_value.c_str(), 1);
  85 #elif defined(OS_WIN)
  86     // On success, a nonzero value is returned.
  87     return !!SetEnvironmentVariable(UTF8ToWide(variable_name).c_str(),
  88                                     UTF8ToWide(new_value).c_str());
  89 #endif
  90   }
  91
  92   bool UnSetVarImpl(const char* variable_name) {
  93 #if defined(OS_POSIX)
  94     // On success, zero is returned.
  95     return !unsetenv(variable_name);
  96 #elif defined(OS_WIN)
  97     // On success, a nonzero value is returned.
  98     return !!SetEnvironmentVariable(UTF8ToWide(variable_name).c_str(), NULL);
  99 #endif
 100   }
 101 };
 102
 103 // Parses a null-terminated input string of an environment block. The key is
 104 // placed into the given string, and the total length of the line, including
 105 // the terminating null, is returned.
 106 size_t ParseEnvLine(const NativeEnvironmentString::value_type* input,
 107                     NativeEnvironmentString* key) {
 108   // Skip to the equals or end of the string, this is the key.
 109   size_t cur = 0;
 110   while (input[cur] && input[cur] != '=')
 111     cur++;
 112   *key = NativeEnvironmentString(&input[0], cur);
 113
 114   // Now just skip to the end of the string.
 115   while (input[cur])
 116     cur++;
 117   return cur + 1;
 118 }
 119
 120 }  // namespace
 121
 122 namespace env_vars {
 123
 124 #if defined(OS_POSIX)
 125 // On Posix systems, this variable contains the location of the user's home
 126 // directory. (e.g, /home/username/).
 127 const char kHome[] = "HOME";
 128 #endif
 129
 130 }  // namespace env_vars
 131
 132 Environment::~Environment() {}
 133
 134 // static
 135 Environment* Environment::Create() {
 136   return new EnvironmentImpl();
 137 }
 138
 139 bool Environment::HasVar(const char* variable_name) {
 140   return GetVar(variable_name, NULL);
 141 }
 142
 143 #if defined(OS_WIN)
 144
 145 string16 AlterEnvironment(const wchar_t* env,
 146                           const EnvironmentMap& changes) {
 147   string16 result;
 148
 149   // First copy all unmodified values to the output.
 150   size_t cur_env = 0;
 151   string16 key;
 152   while (env[cur_env]) {
 153     const wchar_t* line = &env[cur_env];
 154     size_t line_length = ParseEnvLine(line, &key);
 155
 156     // Keep only values not specified in the change vector.
 157     EnvironmentMap::const_iterator found_change = changes.find(key);
 158     if (found_change == changes.end())
 159       result.append(line, line_length);
 160
 161     cur_env += line_length;
 162   }
 163
 164   // Now append all modified and new values.
 165   for (EnvironmentMap::const_iterator i = changes.begin();
 166        i != changes.end(); ++i) {
 167     if (!i->second.empty()) {
 168       result.append(i->first);
 169       result.push_back('=');
 170       result.append(i->second);
 171       result.push_back(0);
 172     }
 173   }
 174
 175   // An additional null marks the end of the list. We always need a double-null
 176   // in case nothing was added above.
 177   if (result.empty())
 178     result.push_back(0);
 179   result.push_back(0);
 180   return result;
 181 }
 182
 183 #elif defined(OS_POSIX)
 184
 185 scoped_ptr<char*[]> AlterEnvironment(const char* const* const env,
 186                                      const EnvironmentMap& changes) {
 187   std::string value_storage;  // Holds concatenated null-terminated strings.
 188   std::vector<size_t> result_indices;  // Line indices into value_storage.
 189
 190   // First build up all of the unchanged environment strings. These are
 191   // null-terminated of the form "key=value".
 192   std::string key;
 193   for (size_t i = 0; env[i]; i++) {
 194     size_t line_length = ParseEnvLine(env[i], &key);
 195
 196     // Keep only values not specified in the change vector.
 197     EnvironmentMap::const_iterator found_change = changes.find(key);
 198     if (found_change == changes.end()) {
 199       result_indices.push_back(value_storage.size());
 200       value_storage.append(env[i], line_length);
 201     }
 202   }
 203
 204   // Now append all modified and new values.
 205   for (EnvironmentMap::const_iterator i = changes.begin();
 206        i != changes.end(); ++i) {
 207     if (!i->second.empty()) {
 208       result_indices.push_back(value_storage.size());
 209       value_storage.append(i->first);
 210       value_storage.push_back('=');
 211       value_storage.append(i->second);
 212       value_storage.push_back(0);
 213     }
 214   }
 215
 216   size_t pointer_count_required =
 217       result_indices.size() + 1 +  // Null-terminated array of pointers.
 218       (value_storage.size() + sizeof(char*) - 1) / sizeof(char*);  // Buffer.
 219   scoped_ptr<char*[]> result(new char*[pointer_count_required]);
 220
 221   // The string storage goes after the array of pointers.
 222   char* storage_data = reinterpret_cast<char*>(
 223       &result.get()[result_indices.size() + 1]);
 224   if (!value_storage.empty())
 225     memcpy(storage_data, value_storage.data(), value_storage.size());
 226
 227   // Fill array of pointers at the beginning of the result.
 228   for (size_t i = 0; i < result_indices.size(); i++)
 229     result[i] = &storage_data[result_indices[i]];
 230   result[result_indices.size()] = 0;  // Null terminator.
 231
 232   return result.Pass();
 233 }
 234
 235 #endif  // OS_POSIX
 236
 237 }  // namespace base