1. /*

  2.  * @(#)ProcessEnvironment.java	1.6 04/04/05

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. /* We use APIs that access a so-called Windows "Environment Block",

  9.  * which looks like an array of jchars like this:

  10.  *

  11.  * FOO=BAR\u0000 ... GORP=QUUX\u0000\u0000

  12.  *

  13.  * This data structure has a number of peculiarities we must contend with:

  14.  * - The NUL jchar separators, and a double NUL jchar terminator.

  15.  *   It appears that the Windows implementation requires double NUL

  16.  *   termination even if the environment is empty.  We should always

  17.  *   generate environments with double NUL termination, while accepting

  18.  *   empty environments consisting of a single NUL.

  19.  * - on Windows9x, this is actually an array of 8-bit chars, not jchars,

  20.  *   encoded in the system default encoding.

  21.  * - The block must be sorted by Unicode value, case-insensitively.

  22.  * - There are magic environment variables maintained by Windows

  23.  *   that start with a `=' (!) character.  These are used for

  24.  *   Windows drive current directory (e.g. "=C:=C:\WINNT") or the

  25.  *   exit code of the last command (e.g. "=ExitCode=0000001").

  26.  *

  27.  * Since Java and non-9x Windows speak the same character set, and

  28.  * even the same encoding, we don't have to deal with unreliable

  29.  * conversion to byte streams.  Just add a few NUL terminators.

  30.  *

  31.  * System.getenv(String) is case-insensitive, while System.getenv()

  32.  * returns a map that is case-sensitive, which is consistent with

  33.  * native Windows APIs.

  34.  *

  35.  * The non-private methods in this class are not for general use even

  36.  * within this package.  Instead, they are the system-dependent parts

  37.  * of the system-independent method of the same name.  Don't even

  38.  * think of using this class unless your method's name appears below.

  39.  *

  40.  * @author Martin Buchholz

  41.  * @version 1.6, 04/04/05

  42.  * @since 1.5

  43.  */

  44. 

  45. package java.lang;

  46. 

  47. import java.io.*;

  48. import java.util.*;

  49. 

  50. final class ProcessEnvironment extends HashMap<String,String>

  51. {

  52.     private static String validateName(String name) {

  53. 	// An initial `=' indicates a magic Windows variable name -- OK

  54. 	if (name.indexOf('=', 1)   != -1 ||

  55. 	    name.indexOf('\u0000') != -1)

  56. 	    throw new IllegalArgumentException

  57. 		("Invalid environment variable name: \"" + name + "\"");

  58. 	return name;

  59.     }

  60. 

  61.     private static String validateValue(String value) {

  62. 	if (value.indexOf('\u0000') != -1)

  63. 	    throw new IllegalArgumentException

  64. 		("Invalid environment variable value: \"" + value + "\"");

  65. 	return value;

  66.     }

  67. 

  68.     private static String nonNullString(Object o) {

  69. 	if (o == null)

  70. 	    throw new NullPointerException();

  71. 	return (String) o;

  72.     }

  73. 

  74.     public String put(String key, String value) {

  75. 	return super.put(validateName(key), validateValue(value));

  76.     }

  77. 

  78.     public String get(Object key) {

  79. 	return super.get(nonNullString(key));

  80.     }

  81. 

  82.     public boolean containsKey(Object key) {

  83. 	return super.containsKey(nonNullString(key));

  84.     }

  85. 

  86.     public boolean containsValue(Object value) {

  87. 	return super.containsValue(nonNullString(value));

  88.     }

  89. 

  90.     public String remove(Object key) {

  91. 	return super.remove(nonNullString(key));

  92.     }

  93. 

  94.     private static class CheckedEntry

  95. 	implements Map.Entry<String,String>

  96.     {

  97. 	private final Map.Entry<String,String> e;

  98. 	public CheckedEntry(Map.Entry<String,String> e) {this.e = e;}

  99. 	public String getKey()   { return e.getKey();}

  100. 	public String getValue() { return e.getValue();}

  101. 	public String setValue(String value) {

  102. 	    return e.setValue(validateValue(value));

  103. 	}

  104. 	public String toString() { return getKey() + "=" + getValue();}

  105. 	public boolean equals(Object o) {return e.equals(o);}

  106. 	public int hashCode()    {return e.hashCode();}

  107.     }

  108. 

  109.     private static class CheckedEntrySet

  110. 	extends AbstractSet<Map.Entry<String,String>>

  111.     {

  112. 	private final Set<Map.Entry<String,String>> s;

  113. 	public CheckedEntrySet(Set<Map.Entry<String,String>> s) {this.s = s;}

  114. 	public int size()        {return s.size();}

  115. 	public boolean isEmpty() {return s.isEmpty();}

  116. 	public void clear()      {       s.clear();}

  117. 	public Iterator<Map.Entry<String,String>> iterator() {

  118. 	    return new Iterator<Map.Entry<String,String>>() {

  119. 		Iterator<Map.Entry<String,String>> i = s.iterator();

  120. 		public boolean hasNext() { return i.hasNext();}

  121. 		public Map.Entry<String,String> next() {

  122. 		    return new CheckedEntry(i.next());

  123. 		}

  124. 		public void remove() { i.remove();}

  125. 	    };

  126. 	}

  127. 	private static Map.Entry<String,String> checkedEntry (Object o) {

  128. 	    Map.Entry<String,String> e = (Map.Entry<String,String>) o;

  129. 	    nonNullString(e.getKey());

  130. 	    nonNullString(e.getValue());

  131. 	    return e;

  132. 	}

  133. 	public boolean contains(Object o) {return s.contains(checkedEntry(o));}

  134. 	public boolean remove(Object o)   {return s.remove(checkedEntry(o));}

  135.     }

  136. 

  137.     private static class CheckedValues extends AbstractCollection<String> {

  138. 	private final Collection<String> c;

  139. 	public CheckedValues(Collection<String> c) {this.c = c;}

  140. 	public int size()                  {return c.size();}

  141. 	public boolean isEmpty()           {return c.isEmpty();}

  142. 	public void clear()                {       c.clear();}

  143. 	public Iterator<String> iterator() {return c.iterator();}

  144. 	public boolean contains(Object o)  {return c.contains(nonNullString(o));}

  145. 	public boolean remove(Object o)    {return c.remove(nonNullString(o));}

  146.     }

  147. 

  148.     private static class CheckedKeySet extends AbstractSet<String> {

  149. 	private final Set<String> s;

  150. 	public CheckedKeySet(Set<String> s) {this.s = s;}

  151. 	public int size()                  {return s.size();}

  152. 	public boolean isEmpty()           {return s.isEmpty();}

  153. 	public void clear()                {       s.clear();}

  154. 	public Iterator<String> iterator() {return s.iterator();}

  155. 	public boolean contains(Object o)  {return s.contains(nonNullString(o));}

  156. 	public boolean remove(Object o)    {return s.remove(nonNullString(o));}

  157.     }

  158. 

  159.     public Set<String> keySet() {

  160. 	return new CheckedKeySet(super.keySet());

  161.     }

  162. 

  163.     public Collection<String> values() {

  164. 	return new CheckedValues(super.values());

  165.     }

  166. 

  167.     public Set<Map.Entry<String,String>> entrySet() {

  168. 	return new CheckedEntrySet(super.entrySet());

  169.     }

  170. 

  171. 

  172.     private static final class NameComparator

  173. 	implements Comparator<String> {

  174. 	public int compare(String x, String y) {

  175. 	    return x.compareToIgnoreCase(y);

  176. 	}

  177.     }

  178. 

  179.     private static final class EntryComparator

  180. 	implements Comparator<Map.Entry<String,String>> {

  181. 	public int compare(Map.Entry<String,String> e1,

  182. 			   Map.Entry<String,String> e2) {

  183. 	    return e1.getKey().compareToIgnoreCase(e2.getKey());

  184. 	}

  185.     }

  186. 

  187.     // Allow `=' as first char in name, e.g. =C:=C:\DIR

  188.     static final int MIN_NAME_LENGTH = 1;

  189. 

  190.     private static final NameComparator nameComparator;

  191.     private static final EntryComparator entryComparator;

  192.     private static final ProcessEnvironment theEnvironment;

  193.     private static final Map<String,String> theUnmodifiableEnvironment;

  194.     private static final Map<String,String> theCaseInsensitiveEnvironment;

  195. 

  196.     static {

  197. 	nameComparator  = new NameComparator();

  198. 	entryComparator = new EntryComparator();

  199. 	theEnvironment  = new ProcessEnvironment();

  200. 	theUnmodifiableEnvironment

  201. 	    = Collections.unmodifiableMap(theEnvironment);

  202. 

  203. 	String envblock = environmentBlock();

  204. 	int beg, end, eql;

  205. 	for (beg = 0;

  206. 	     ((end = envblock.indexOf('\u0000', beg  )) != -1 &&

  207. 	      // An initial `=' indicates a magic Windows variable name -- OK

  208. 	      (eql = envblock.indexOf('='     , beg+1)) != -1);

  209. 	     beg = end + 1) {

  210. 	    // Ignore corrupted environment strings.

  211. 	    if (eql < end)

  212. 		theEnvironment.put(envblock.substring(beg, eql),

  213. 				   envblock.substring(eql+1,end));

  214. 	}

  215. 

  216. 	theCaseInsensitiveEnvironment

  217. 	    = new TreeMap<String,String>(nameComparator);

  218. 	theCaseInsensitiveEnvironment.putAll(theEnvironment);

  219.     }

  220. 

  221.     private ProcessEnvironment() {

  222. 	super();

  223.     }

  224. 

  225.     private ProcessEnvironment(int capacity) {

  226. 	super(capacity);

  227.     }

  228. 

  229.     // Only for use by System.getenv(String)

  230.     static String getenv(String name) {

  231. 	// The original implementation used a native call to _wgetenv,

  232. 	// but it turns out that _wgetenv is only consistent with

  233. 	// GetEnvironmentStringsW (for non-ASCII) if `wmain' is used

  234. 	// instead of `main', even in a process created using

  235. 	// CREATE_UNICODE_ENVIRONMENT.  Instead we perform the

  236. 	// case-insensitive comparison ourselves.  At least this

  237. 	// guarantees that System.getenv().get(String) will be

  238. 	// consistent with System.getenv(String).

  239. 	return theCaseInsensitiveEnvironment.get(name);

  240.     }

  241. 

  242.     // Only for use by System.getenv()

  243.     static Map<String,String> getenv() {

  244. 	return theUnmodifiableEnvironment;

  245.     }

  246. 

  247.     // Only for use by ProcessBuilder.environment()

  248.     static Map<String,String> environment() {

  249. 	return (Map<String,String>) theEnvironment.clone();

  250.     }

  251. 

  252.     // Only for use by Runtime.exec(...String[]envp...)

  253.     static Map<String,String> emptyEnvironment(int capacity) {

  254. 	return new ProcessEnvironment(capacity);

  255.     }

  256. 

  257.     private static native String environmentBlock();

  258. 

  259.     // Only for use by ProcessImpl.start()

  260.     String toEnvironmentBlock() {

  261. 	// Sort Unicode-case-insensitively by name

  262. 	List<Map.Entry<String,String>> list

  263. 	    = new ArrayList<Map.Entry<String,String>>(entrySet());

  264. 	Collections.sort(list, entryComparator);

  265. 

  266. 	StringBuilder sb = new StringBuilder(size()*30);

  267. 	for (Map.Entry<String,String> e : list)

  268. 	    sb.append(e.getKey())

  269. 	      .append('=')

  270. 	      .append(e.getValue())

  271. 	      .append('\u0000');

  272. 	// Ensure double NUL termination,

  273. 	// even if environment is empty.

  274. 	if (sb.length() == 0)

  275. 	    sb.append('\u0000');

  276. 	sb.append('\u0000');

  277. 	return sb.toString();

  278.     }

  279. 

  280.     static String toEnvironmentBlock(Map<String,String> map) {

  281. 	return map == null ? null :

  282. 	    ((ProcessEnvironment)map).toEnvironmentBlock();

  283.     }

  284. }