1 /* 2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* We use APIs that access the standard Unix environ array, which 27 * is defined by UNIX98 to look like: 28 * 29 * char **environ; 30 * 31 * These are unsorted, case-sensitive, null-terminated arrays of bytes 32 * of the form FOO=BAR\000 which are usually encoded in the user's 33 * default encoding (file.encoding is an excellent choice for 34 * encoding/decoding these). However, even though the user cannot 35 * directly access the underlying byte representation, we take pains 36 * to pass on the child the exact byte representation we inherit from 37 * the parent process for any environment name or value not created by 38 * Javaland. So we keep track of all the byte representations. 39 * 40 * Internally, we define the types Variable and Value that exhibit 41 * String/byteArray duality. The internal representation of the 42 * environment then looks like a Map<Variable,Value>. But we don't 43 * expose this to the user -- we only provide a Map<String,String> 44 * view, although we could also provide a Map<byte[],byte[]> view. 45 * 46 * The non-private methods in this class are not for general use even 47 * within this package. Instead, they are the system-dependent parts 48 * of the system-independent method of the same name. Don't even 49 * think of using this class unless your method's name appears below. 50 * 51 * @author Martin Buchholz 52 * @since 1.5 53 */ 54 55 package java.lang; 56 57 import java.io.*; 58 import java.util.*; 59 60 61 final class ProcessEnvironment 62 { 63 private static final HashMap<Variable,Value> theEnvironment; 64 private static final Map<String,String> theUnmodifiableEnvironment; 65 static final int MIN_NAME_LENGTH = 0; 66 67 static { 68 // We cache the C environment. This means that subsequent calls 69 // to putenv/setenv from C will not be visible from Java code. 70 byte[][] environ = environ(); 71 theEnvironment = new HashMap<>(environ.length/2 + 3); 72 // Read environment variables back to front, 73 // so that earlier variables override later ones. 74 for (int i = environ.length-1; i > 0; i-=2) 75 theEnvironment.put(Variable.valueOf(environ[i-1]), 76 Value.valueOf(environ[i])); 77 78 theUnmodifiableEnvironment 79 = Collections.unmodifiableMap 80 (new StringEnvironment(theEnvironment)); 81 } 82 83 /* Only for use by System.getenv(String) */ 84 static String getenv(String name) { 85 return theUnmodifiableEnvironment.get(name); 86 } 87 88 /* Only for use by System.getenv() */ 89 static Map<String,String> getenv() { 90 return theUnmodifiableEnvironment; 91 } 92 93 /* Only for use by ProcessBuilder.environment() */ 94 static Map<String,String> environment() { 95 return new StringEnvironment 96 ((Map<Variable,Value>)(theEnvironment.clone())); 97 } 98 99 /* Only for use by Runtime.exec(...String[]envp...) */ 100 static Map<String,String> emptyEnvironment(int capacity) { 101 return new StringEnvironment(new HashMap<Variable,Value>(capacity)); 102 } 103 104 private static native byte[][] environ(); 105 106 // This class is not instantiable. 107 private ProcessEnvironment() {} 108 109 // Check that name is suitable for insertion into Environment map 110 private static void validateVariable(String name) { 111 if (name.indexOf('=') != -1 || 112 name.indexOf('\u0000') != -1) 113 throw new IllegalArgumentException 114 ("Invalid environment variable name: \"" + name + "\""); 115 } 116 117 // Check that value is suitable for insertion into Environment map 118 private static void validateValue(String value) { 119 if (value.indexOf('\u0000') != -1) 120 throw new IllegalArgumentException 121 ("Invalid environment variable value: \"" + value + "\""); 122 } 123 124 // A class hiding the byteArray-String duality of 125 // text data on Unixoid operating systems. 126 private static abstract class ExternalData { 127 protected final String str; 128 protected final byte[] bytes; 129 130 protected ExternalData(String str, byte[] bytes) { 131 this.str = str; 132 this.bytes = bytes; 133 } 134 135 public byte[] getBytes() { 136 return bytes; 137 } 138 139 public String toString() { 140 return str; 141 } 142 143 public boolean equals(Object o) { 144 return o instanceof ExternalData 145 && arrayEquals(getBytes(), ((ExternalData) o).getBytes()); 146 } 147 148 public int hashCode() { 149 return arrayHash(getBytes()); 150 } 151 } 152 153 private static class Variable 154 extends ExternalData implements Comparable<Variable> 155 { 156 protected Variable(String str, byte[] bytes) { 157 super(str, bytes); 158 } 159 160 public static Variable valueOfQueryOnly(Object str) { 161 return valueOfQueryOnly((String) str); 162 } 163 164 public static Variable valueOfQueryOnly(String str) { 165 return new Variable(str, str.getBytes()); 166 } 167 168 public static Variable valueOf(String str) { 169 validateVariable(str); 170 return valueOfQueryOnly(str); 171 } 172 173 public static Variable valueOf(byte[] bytes) { 174 return new Variable(new String(bytes), bytes); 175 } 176 177 public int compareTo(Variable variable) { 178 return arrayCompare(getBytes(), variable.getBytes()); 179 } 180 181 public boolean equals(Object o) { 182 return o instanceof Variable && super.equals(o); 183 } 184 } 185 186 private static class Value 187 extends ExternalData implements Comparable<Value> 188 { 189 protected Value(String str, byte[] bytes) { 190 super(str, bytes); 191 } 192 193 public static Value valueOfQueryOnly(Object str) { 194 return valueOfQueryOnly((String) str); 195 } 196 197 public static Value valueOfQueryOnly(String str) { 198 return new Value(str, str.getBytes()); 199 } 200 201 public static Value valueOf(String str) { 202 validateValue(str); 203 return valueOfQueryOnly(str); 204 } 205 206 public static Value valueOf(byte[] bytes) { 207 return new Value(new String(bytes), bytes); 208 } 209 210 public int compareTo(Value value) { 211 return arrayCompare(getBytes(), value.getBytes()); 212 } 213 214 public boolean equals(Object o) { 215 return o instanceof Value && super.equals(o); 216 } 217 } 218 219 // This implements the String map view the user sees. 220 private static class StringEnvironment 221 extends AbstractMap<String,String> 222 { 223 private Map<Variable,Value> m; 224 private static String toString(Value v) { 225 return v == null ? null : v.toString(); 226 } 227 public StringEnvironment(Map<Variable,Value> m) {this.m = m;} 228 public int size() {return m.size();} 229 public boolean isEmpty() {return m.isEmpty();} 230 public void clear() { m.clear();} 231 public boolean containsKey(Object key) { 232 return m.containsKey(Variable.valueOfQueryOnly(key)); 233 } 234 public boolean containsValue(Object value) { 235 return m.containsValue(Value.valueOfQueryOnly(value)); 236 } 237 public String get(Object key) { 238 return toString(m.get(Variable.valueOfQueryOnly(key))); 239 } 240 public String put(String key, String value) { 241 return toString(m.put(Variable.valueOf(key), 242 Value.valueOf(value))); 243 } 244 public String remove(Object key) { 245 return toString(m.remove(Variable.valueOfQueryOnly(key))); 246 } 247 public Set<String> keySet() { 248 return new StringKeySet(m.keySet()); 249 } 250 public Set<Map.Entry<String,String>> entrySet() { 251 return new StringEntrySet(m.entrySet()); 252 } 253 public Collection<String> values() { 254 return new StringValues(m.values()); 255 } 256 257 // It is technically feasible to provide a byte-oriented view 258 // as follows: 259 // public Map<byte[],byte[]> asByteArrayMap() { 260 // return new ByteArrayEnvironment(m); 261 // } 262 263 264 // Convert to Unix style environ as a monolithic byte array 265 // inspired by the Windows Environment Block, except we work 266 // exclusively with bytes instead of chars, and we need only 267 // one trailing NUL on Unix. 268 // This keeps the JNI as simple and efficient as possible. 269 public byte[] toEnvironmentBlock(int[]envc) { 270 int count = m.size() * 2; // For added '=' and NUL 271 for (Map.Entry<Variable,Value> entry : m.entrySet()) { 272 count += entry.getKey().getBytes().length; 273 count += entry.getValue().getBytes().length; 274 } 275 276 byte[] block = new byte[count]; 277 278 int i = 0; 279 for (Map.Entry<Variable,Value> entry : m.entrySet()) { 280 byte[] key = entry.getKey ().getBytes(); 281 byte[] value = entry.getValue().getBytes(); 282 System.arraycopy(key, 0, block, i, key.length); 283 i+=key.length; 284 block[i++] = (byte) '='; 285 System.arraycopy(value, 0, block, i, value.length); 286 i+=value.length + 1; 287 // No need to write NUL byte explicitly 288 //block[i++] = (byte) '\u0000'; 289 } 290 envc[0] = m.size(); 291 return block; 292 } 293 } 294 295 static byte[] toEnvironmentBlock(Map<String,String> map, int[]envc) { 296 return map == null ? null : 297 ((StringEnvironment)map).toEnvironmentBlock(envc); 298 } 299 300 301 private static class StringEntry 302 implements Map.Entry<String,String> 303 { 304 private final Map.Entry<Variable,Value> e; 305 public StringEntry(Map.Entry<Variable,Value> e) {this.e = e;} 306 public String getKey() {return e.getKey().toString();} 307 public String getValue() {return e.getValue().toString();} 308 public String setValue(String newValue) { 309 return e.setValue(Value.valueOf(newValue)).toString(); 310 } 311 public String toString() {return getKey() + "=" + getValue();} 312 public boolean equals(Object o) { 313 return o instanceof StringEntry 314 && e.equals(((StringEntry)o).e); 315 } 316 public int hashCode() {return e.hashCode();} 317 } 318 319 private static class StringEntrySet 320 extends AbstractSet<Map.Entry<String,String>> 321 { 322 private final Set<Map.Entry<Variable,Value>> s; 323 public StringEntrySet(Set<Map.Entry<Variable,Value>> s) {this.s = s;} 324 public int size() {return s.size();} 325 public boolean isEmpty() {return s.isEmpty();} 326 public void clear() { s.clear();} 327 public Iterator<Map.Entry<String,String>> iterator() { 328 return new Iterator<Map.Entry<String,String>>() { 329 Iterator<Map.Entry<Variable,Value>> i = s.iterator(); 330 public boolean hasNext() {return i.hasNext();} 331 public Map.Entry<String,String> next() { 332 return new StringEntry(i.next()); 333 } 334 public void remove() {i.remove();} 335 }; 336 } 337 private static Map.Entry<Variable,Value> vvEntry(final Object o) { 338 if (o instanceof StringEntry) 339 return ((StringEntry)o).e; 340 return new Map.Entry<Variable,Value>() { 341 public Variable getKey() { 342 return Variable.valueOfQueryOnly(((Map.Entry)o).getKey()); 343 } 344 public Value getValue() { 345 return Value.valueOfQueryOnly(((Map.Entry)o).getValue()); 346 } 347 public Value setValue(Value value) { 348 throw new UnsupportedOperationException(); 349 } 350 }; 351 } 352 public boolean contains(Object o) { return s.contains(vvEntry(o)); } 353 public boolean remove(Object o) { return s.remove(vvEntry(o)); } 354 public boolean equals(Object o) { 355 return o instanceof StringEntrySet 356 && s.equals(((StringEntrySet) o).s); 357 } 358 public int hashCode() {return s.hashCode();} 359 } 360 361 private static class StringValues 362 extends AbstractCollection<String> 363 { 364 private final Collection<Value> c; 365 public StringValues(Collection<Value> c) {this.c = c;} 366 public int size() {return c.size();} 367 public boolean isEmpty() {return c.isEmpty();} 368 public void clear() { c.clear();} 369 public Iterator<String> iterator() { 370 return new Iterator<String>() { 371 Iterator<Value> i = c.iterator(); 372 public boolean hasNext() {return i.hasNext();} 373 public String next() {return i.next().toString();} 374 public void remove() {i.remove();} 375 }; 376 } 377 public boolean contains(Object o) { 378 return c.contains(Value.valueOfQueryOnly(o)); 379 } 380 public boolean remove(Object o) { 381 return c.remove(Value.valueOfQueryOnly(o)); 382 } 383 public boolean equals(Object o) { 384 return o instanceof StringValues 385 && c.equals(((StringValues)o).c); 386 } 387 public int hashCode() {return c.hashCode();} 388 } 389 390 private static class StringKeySet extends AbstractSet<String> { 391 private final Set<Variable> s; 392 public StringKeySet(Set<Variable> s) {this.s = s;} 393 public int size() {return s.size();} 394 public boolean isEmpty() {return s.isEmpty();} 395 public void clear() { s.clear();} 396 public Iterator<String> iterator() { 397 return new Iterator<String>() { 398 Iterator<Variable> i = s.iterator(); 399 public boolean hasNext() {return i.hasNext();} 400 public String next() {return i.next().toString();} 401 public void remove() { i.remove();} 402 }; 403 } 404 public boolean contains(Object o) { 405 return s.contains(Variable.valueOfQueryOnly(o)); 406 } 407 public boolean remove(Object o) { 408 return s.remove(Variable.valueOfQueryOnly(o)); 409 } 410 } 411 412 // Replace with general purpose method someday 413 private static int arrayCompare(byte[]x, byte[] y) { 414 int min = x.length < y.length ? x.length : y.length; 415 for (int i = 0; i < min; i++) 416 if (x[i] != y[i]) 417 return x[i] - y[i]; 418 return x.length - y.length; 419 } 420 421 // Replace with general purpose method someday 422 private static boolean arrayEquals(byte[] x, byte[] y) { 423 if (x.length != y.length) 424 return false; 425 for (int i = 0; i < x.length; i++) 426 if (x[i] != y[i]) 427 return false; 428 return true; 429 } 430 431 // Replace with general purpose method someday 432 private static int arrayHash(byte[] x) { 433 int hash = 0; 434 for (int i = 0; i < x.length; i++) 435 hash = 31 * hash + x[i]; 436 return hash; 437 } 438 439 } 440
