1 /*
   2  * Copyright (c) 2003, 2011, 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     @SuppressWarnings("unchecked")
  95     static Map<String,String> environment() {
  96         return new StringEnvironment
  97             ((Map<Variable,Value>)(theEnvironment.clone()));
  98     }
  99 
 100     /* Only for use by Runtime.exec(...String[]envp...) */
 101     static Map<String,String> emptyEnvironment(int capacity) {
 102         return new StringEnvironment(new HashMap<>(capacity));
 103     }
 104 
 105     private static native byte[][] environ();
 106 
 107     // This class is not instantiable.
 108     private ProcessEnvironment() {}
 109 
 110     // Check that name is suitable for insertion into Environment map
 111     private static void validateVariable(String name) {
 112         if (name.indexOf('=')      != -1 ||
 113             name.indexOf('\u0000') != -1)
 114             throw new IllegalArgumentException
 115                 ("Invalid environment variable name: \"" + name + "\"");
 116     }
 117 
 118     // Check that value is suitable for insertion into Environment map
 119     private static void validateValue(String value) {
 120         if (value.indexOf('\u0000') != -1)
 121             throw new IllegalArgumentException
 122                 ("Invalid environment variable value: \"" + value + "\"");
 123     }
 124 
 125     // A class hiding the byteArray-String duality of
 126     // text data on Unixoid operating systems.
 127     private abstract static class ExternalData {
 128         protected final String str;
 129         protected final byte[] bytes;
 130 
 131         protected ExternalData(String str, byte[] bytes) {
 132             this.str = str;
 133             this.bytes = bytes;
 134         }
 135 
 136         public byte[] getBytes() {
 137             return bytes;
 138         }
 139 
 140         public String toString() {
 141             return str;
 142         }
 143 
 144         public boolean equals(Object o) {
 145             return o instanceof ExternalData
 146                 && arrayEquals(getBytes(), ((ExternalData) o).getBytes());
 147         }
 148 
 149         public int hashCode() {
 150             return arrayHash(getBytes());
 151         }
 152     }
 153 
 154     private static class Variable
 155         extends ExternalData implements Comparable<Variable>
 156     {
 157         protected Variable(String str, byte[] bytes) {
 158             super(str, bytes);
 159         }
 160 
 161         public static Variable valueOfQueryOnly(Object str) {
 162             return valueOfQueryOnly((String) str);
 163         }
 164 
 165         public static Variable valueOfQueryOnly(String str) {
 166             return new Variable(str, str.getBytes());
 167         }
 168 
 169         public static Variable valueOf(String str) {
 170             validateVariable(str);
 171             return valueOfQueryOnly(str);
 172         }
 173 
 174         public static Variable valueOf(byte[] bytes) {
 175             return new Variable(new String(bytes), bytes);
 176         }
 177 
 178         public int compareTo(Variable variable) {
 179             return arrayCompare(getBytes(), variable.getBytes());
 180         }
 181 
 182         public boolean equals(Object o) {
 183             return o instanceof Variable && super.equals(o);
 184         }
 185     }
 186 
 187     private static class Value
 188         extends ExternalData implements Comparable<Value>
 189     {
 190         protected Value(String str, byte[] bytes) {
 191             super(str, bytes);
 192         }
 193 
 194         public static Value valueOfQueryOnly(Object str) {
 195             return valueOfQueryOnly((String) str);
 196         }
 197 
 198         public static Value valueOfQueryOnly(String str) {
 199             return new Value(str, str.getBytes());
 200         }
 201 
 202         public static Value valueOf(String str) {
 203             validateValue(str);
 204             return valueOfQueryOnly(str);
 205         }
 206 
 207         public static Value valueOf(byte[] bytes) {
 208             return new Value(new String(bytes), bytes);
 209         }
 210 
 211         public int compareTo(Value value) {
 212             return arrayCompare(getBytes(), value.getBytes());
 213         }
 214 
 215         public boolean equals(Object o) {
 216             return o instanceof Value && super.equals(o);
 217         }
 218     }
 219 
 220     // This implements the String map view the user sees.
 221     private static class StringEnvironment
 222         extends AbstractMap<String,String>
 223     {
 224         private Map<Variable,Value> m;
 225         private static String toString(Value v) {
 226             return v == null ? null : v.toString();
 227         }
 228         public StringEnvironment(Map<Variable,Value> m) {this.m = m;}
 229         public int size()        {return m.size();}
 230         public boolean isEmpty() {return m.isEmpty();}
 231         public void clear()      {       m.clear();}
 232         public boolean containsKey(Object key) {
 233             return m.containsKey(Variable.valueOfQueryOnly(key));
 234         }
 235         public boolean containsValue(Object value) {
 236             return m.containsValue(Value.valueOfQueryOnly(value));
 237         }
 238         public String get(Object key) {
 239             return toString(m.get(Variable.valueOfQueryOnly(key)));
 240         }
 241         public String put(String key, String value) {
 242             return toString(m.put(Variable.valueOf(key),
 243                                   Value.valueOf(value)));
 244         }
 245         public String remove(Object key) {
 246             return toString(m.remove(Variable.valueOfQueryOnly(key)));
 247         }
 248         public Set<String> keySet() {
 249             return new StringKeySet(m.keySet());
 250         }
 251         public Set<Map.Entry<String,String>> entrySet() {
 252             return new StringEntrySet(m.entrySet());
 253         }
 254         public Collection<String> values() {
 255             return new StringValues(m.values());
 256         }
 257 
 258         // It is technically feasible to provide a byte-oriented view
 259         // as follows:
 260         //      public Map<byte[],byte[]> asByteArrayMap() {
 261         //          return new ByteArrayEnvironment(m);
 262         //      }
 263 
 264 
 265         // Convert to Unix style environ as a monolithic byte array
 266         // inspired by the Windows Environment Block, except we work
 267         // exclusively with bytes instead of chars, and we need only
 268         // one trailing NUL on Unix.
 269         // This keeps the JNI as simple and efficient as possible.
 270         public byte[] toEnvironmentBlock(int[]envc) {
 271             int count = m.size() * 2; // For added '=' and NUL
 272             for (Map.Entry<Variable,Value> entry : m.entrySet()) {
 273                 count += entry.getKey().getBytes().length;
 274                 count += entry.getValue().getBytes().length;
 275             }
 276 
 277             byte[] block = new byte[count];
 278 
 279             int i = 0;
 280             for (Map.Entry<Variable,Value> entry : m.entrySet()) {
 281                 byte[] key   = entry.getKey  ().getBytes();
 282                 byte[] value = entry.getValue().getBytes();
 283                 System.arraycopy(key, 0, block, i, key.length);
 284                 i+=key.length;
 285                 block[i++] = (byte) '=';
 286                 System.arraycopy(value, 0, block, i, value.length);
 287                 i+=value.length + 1;
 288                 // No need to write NUL byte explicitly
 289                 //block[i++] = (byte) '\u0000';
 290             }
 291             envc[0] = m.size();
 292             return block;
 293         }
 294     }
 295 
 296     static byte[] toEnvironmentBlock(Map<String,String> map, int[]envc) {
 297         return map == null ? null :
 298             ((StringEnvironment)map).toEnvironmentBlock(envc);
 299     }
 300 
 301 
 302     private static class StringEntry
 303         implements Map.Entry<String,String>
 304     {
 305         private final Map.Entry<Variable,Value> e;
 306         public StringEntry(Map.Entry<Variable,Value> e) {this.e = e;}
 307         public String getKey()   {return e.getKey().toString();}
 308         public String getValue() {return e.getValue().toString();}
 309         public String setValue(String newValue) {
 310             return e.setValue(Value.valueOf(newValue)).toString();
 311         }
 312         public String toString() {return getKey() + "=" + getValue();}
 313         public boolean equals(Object o) {
 314             return o instanceof StringEntry
 315                 && e.equals(((StringEntry)o).e);
 316         }
 317         public int hashCode()    {return e.hashCode();}
 318     }
 319 
 320     private static class StringEntrySet
 321         extends AbstractSet<Map.Entry<String,String>>
 322     {
 323         private final Set<Map.Entry<Variable,Value>> s;
 324         public StringEntrySet(Set<Map.Entry<Variable,Value>> s) {this.s = s;}
 325         public int size()        {return s.size();}
 326         public boolean isEmpty() {return s.isEmpty();}
 327         public void clear()      {       s.clear();}
 328         public Iterator<Map.Entry<String,String>> iterator() {
 329             return new Iterator<Map.Entry<String,String>>() {
 330                 Iterator<Map.Entry<Variable,Value>> i = s.iterator();
 331                 public boolean hasNext() {return i.hasNext();}
 332                 public Map.Entry<String,String> next() {
 333                     return new StringEntry(i.next());
 334                 }
 335                 public void remove() {i.remove();}
 336             };
 337         }
 338         private static Map.Entry<Variable,Value> vvEntry(final Object o) {
 339             if (o instanceof StringEntry)
 340                 return ((StringEntry)o).e;
 341             return new Map.Entry<Variable,Value>() {
 342                 public Variable getKey() {
 343                     return Variable.valueOfQueryOnly(((Map.Entry)o).getKey());
 344                 }
 345                 public Value getValue() {
 346                     return Value.valueOfQueryOnly(((Map.Entry)o).getValue());
 347                 }
 348                 public Value setValue(Value value) {
 349                     throw new UnsupportedOperationException();
 350                 }
 351             };
 352         }
 353         public boolean contains(Object o) { return s.contains(vvEntry(o)); }
 354         public boolean remove(Object o)   { return s.remove(vvEntry(o)); }
 355         public boolean equals(Object o) {
 356             return o instanceof StringEntrySet
 357                 && s.equals(((StringEntrySet) o).s);
 358         }
 359         public int hashCode() {return s.hashCode();}
 360     }
 361 
 362     private static class StringValues
 363           extends AbstractCollection<String>
 364     {
 365         private final Collection<Value> c;
 366         public StringValues(Collection<Value> c) {this.c = c;}
 367         public int size()        {return c.size();}
 368         public boolean isEmpty() {return c.isEmpty();}
 369         public void clear()      {       c.clear();}
 370         public Iterator<String> iterator() {
 371             return new Iterator<String>() {
 372                 Iterator<Value> i = c.iterator();
 373                 public boolean hasNext() {return i.hasNext();}
 374                 public String next()     {return i.next().toString();}
 375                 public void remove()     {i.remove();}
 376             };
 377         }
 378         public boolean contains(Object o) {
 379             return c.contains(Value.valueOfQueryOnly(o));
 380         }
 381         public boolean remove(Object o) {
 382             return c.remove(Value.valueOfQueryOnly(o));
 383         }
 384         public boolean equals(Object o) {
 385             return o instanceof StringValues
 386                 && c.equals(((StringValues)o).c);
 387         }
 388         public int hashCode() {return c.hashCode();}
 389     }
 390 
 391     private static class StringKeySet extends AbstractSet<String> {
 392         private final Set<Variable> s;
 393         public StringKeySet(Set<Variable> s) {this.s = s;}
 394         public int size()        {return s.size();}
 395         public boolean isEmpty() {return s.isEmpty();}
 396         public void clear()      {       s.clear();}
 397         public Iterator<String> iterator() {
 398             return new Iterator<String>() {
 399                 Iterator<Variable> i = s.iterator();
 400                 public boolean hasNext() {return i.hasNext();}
 401                 public String next()     {return i.next().toString();}
 402                 public void remove()     {       i.remove();}
 403             };
 404         }
 405         public boolean contains(Object o) {
 406             return s.contains(Variable.valueOfQueryOnly(o));
 407         }
 408         public boolean remove(Object o) {
 409             return s.remove(Variable.valueOfQueryOnly(o));
 410         }
 411     }
 412 
 413     // Replace with general purpose method someday
 414     private static int arrayCompare(byte[]x, byte[] y) {
 415         int min = x.length < y.length ? x.length : y.length;
 416         for (int i = 0; i < min; i++)
 417             if (x[i] != y[i])
 418                 return x[i] - y[i];
 419         return x.length - y.length;
 420     }
 421 
 422     // Replace with general purpose method someday
 423     private static boolean arrayEquals(byte[] x, byte[] y) {
 424         if (x.length != y.length)
 425             return false;
 426         for (int i = 0; i < x.length; i++)
 427             if (x[i] != y[i])
 428                 return false;
 429         return true;
 430     }
 431 
 432     // Replace with general purpose method someday
 433     private static int arrayHash(byte[] x) {
 434         int hash = 0;
 435         for (int i = 0; i < x.length; i++)
 436             hash = 31 * hash + x[i];
 437         return hash;
 438     }
 439 
 440 }