oni2/platformtools/WinRegistry.java

package net.oni2.platformtools;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.prefs.Preferences;

/**
 * @author Unknown
 */
public class WinRegistry {
        /**
         * Constant for accessing HKCU
         */
        public static final int HKEY_CURRENT_USER = 0x80000001;
        /**
         * Constant for accessing HKLM
         */
        public static final int HKEY_LOCAL_MACHINE = 0x80000002;
        /**
         * Constant for successful accesses
         */
        public static final int REG_SUCCESS = 0;
        /**
         * Constant for not found
         */
        public static final int REG_NOTFOUND = 2;
        /**
         * Constant for access denied
         */
        public static final int REG_ACCESSDENIED = 5;

        /**
         * Access 32bit registry view when running as 64bit application
         */
        public static final int KEY_WOW64_32KEY = 0x0200;
        /**
         * Access 64bit registry view when running as 32bit application
         */
        public static final int KEY_WOW64_64KEY = 0x0100;

        private static final int KEY_ALL_ACCESS = 0xf003f;
        private static final int KEY_READ = 0x20019;
        private static Preferences userRoot = Preferences.userRoot();
        private static Preferences systemRoot = Preferences.systemRoot();
        private static Class<? extends Preferences> userClass = userRoot.getClass();
        private static Method regOpenKey = null;
        private static Method regCloseKey = null;
        private static Method regQueryValueEx = null;
        private static Method regEnumValue = null;
        private static Method regQueryInfoKey = null;
        private static Method regEnumKeyEx = null;
        private static Method regCreateKeyEx = null;
        private static Method regSetValueEx = null;
        private static Method regDeleteKey = null;
        private static Method regDeleteValue = null;

        private static boolean usable = false;

        static {
                try {
                        regOpenKey = userClass.getDeclaredMethod("WindowsRegOpenKey",
                                        new Class[] { int.class, byte[].class, int.class });
                        regOpenKey.setAccessible(true);
                        regCloseKey = userClass.getDeclaredMethod("WindowsRegCloseKey",
                                        new Class[] { int.class });
                        regCloseKey.setAccessible(true);
                        regQueryValueEx = userClass.getDeclaredMethod(
                                        "WindowsRegQueryValueEx", new Class[] { int.class,
                                                        byte[].class });
                        regQueryValueEx.setAccessible(true);
                        regEnumValue = userClass.getDeclaredMethod("WindowsRegEnumValue",
                                        new Class[] { int.class, int.class, int.class });
                        regEnumValue.setAccessible(true);
                        regQueryInfoKey = userClass.getDeclaredMethod(
                                        "WindowsRegQueryInfoKey1", new Class[] { int.class });
                        regQueryInfoKey.setAccessible(true);
                        regEnumKeyEx = userClass.getDeclaredMethod("WindowsRegEnumKeyEx",
                                        new Class[] { int.class, int.class, int.class });
                        regEnumKeyEx.setAccessible(true);
                        regCreateKeyEx = userClass.getDeclaredMethod(
                                        "WindowsRegCreateKeyEx", new Class[] { int.class,
                                                        byte[].class });
                        regCreateKeyEx.setAccessible(true);
                        regSetValueEx = userClass.getDeclaredMethod("WindowsRegSetValueEx",
                                        new Class[] { int.class, byte[].class, byte[].class });
                        regSetValueEx.setAccessible(true);
                        regDeleteValue = userClass.getDeclaredMethod(
                                        "WindowsRegDeleteValue", new Class[] { int.class,
                                                        byte[].class });
                        regDeleteValue.setAccessible(true);
                        regDeleteKey = userClass.getDeclaredMethod("WindowsRegDeleteKey",
                                        new Class[] { int.class, byte[].class });
                        regDeleteKey.setAccessible(true);
                        usable = true;
                } catch (Exception e) {
                        // e.printStackTrace();
                }
        }

        private WinRegistry() {
        }

        /**
         * Read a value from key and value name
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @param valueName
         *            Name of value to read
         * @param wow64
         *            0 for standard registry access (32-bits for 32-bit app,
         *            64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
         *            32-bit registry view, or KEY_WOW64_64KEY to force access to
         *            64-bit registry view
         * @return the value
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static String readString(int hkey, String key, String valueName,
                        int wow64) throws Exception, IllegalArgumentException,
                        IllegalAccessException, InvocationTargetException {
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        return readString(systemRoot, hkey, key, valueName, wow64);
                } else if (hkey == HKEY_CURRENT_USER) {
                        return readString(userRoot, hkey, key, valueName, wow64);
                } else {
                        throw new IllegalArgumentException("hkey=" + hkey);
                }
        }

        /**
         * Read value(s) and value name(s) form given key
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @param wow64
         *            0 for standard registry access (32-bits for 32-bit app,
         *            64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
         *            32-bit registry view, or KEY_WOW64_64KEY to force access to
         *            64-bit registry view
         * @return the value name(s) plus the value(s)
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static Map<String, String> readStringValues(int hkey, String key,
                        int wow64) throws Exception, IllegalArgumentException,
                        IllegalAccessException, InvocationTargetException {
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        return readStringValues(systemRoot, hkey, key, wow64);
                } else if (hkey == HKEY_CURRENT_USER) {
                        return readStringValues(userRoot, hkey, key, wow64);
                } else {
                        throw new IllegalArgumentException("hkey=" + hkey);
                }
        }

        /**
         * Read the value name(s) from a given key
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @param wow64
         *            0 for standard registry access (32-bits for 32-bit app,
         *            64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
         *            32-bit registry view, or KEY_WOW64_64KEY to force access to
         *            64-bit registry view
         * @return the value name(s)
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static List<String> readStringSubKeys(int hkey, String key, int wow64)
                        throws Exception, IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        return readStringSubKeys(systemRoot, hkey, key, wow64);
                } else if (hkey == HKEY_CURRENT_USER) {
                        return readStringSubKeys(userRoot, hkey, key, wow64);
                } else {
                        throw new IllegalArgumentException("hkey=" + hkey);
                }
        }

        /**
         * Create a key
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static void createKey(int hkey, String key) throws Exception,
                        IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                int[] ret;
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        ret = createKey(systemRoot, hkey, key);
                        regCloseKey
                                        .invoke(systemRoot, new Object[] { new Integer(ret[0]) });
                } else if (hkey == HKEY_CURRENT_USER) {
                        ret = createKey(userRoot, hkey, key);
                        regCloseKey.invoke(userRoot, new Object[] { new Integer(ret[0]) });
                } else {
                        throw new IllegalArgumentException("hkey=" + hkey);
                }
                if (ret[1] != REG_SUCCESS) {
                        throw new IllegalArgumentException("rc=" + ret[1] + "  key=" + key);
                }
        }

        /**
         * Write a value in a given key/value name
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @param valueName
         *            Name of value to write to
         * @param value
         *            String to write
         * @param wow64
         *            0 for standard registry access (32-bits for 32-bit app,
         *            64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
         *            32-bit registry view, or KEY_WOW64_64KEY to force access to
         *            64-bit registry view
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static void writeStringValue(int hkey, String key, String valueName,
                        String value, int wow64) throws Exception,
                        IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        writeStringValue(systemRoot, hkey, key, valueName, value, wow64);
                } else if (hkey == HKEY_CURRENT_USER) {
                        writeStringValue(userRoot, hkey, key, valueName, value, wow64);
                } else {
                        throw new IllegalArgumentException("hkey=" + hkey);
                }
        }

        /**
         * Delete a given key
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to delete
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static void deleteKey(int hkey, String key) throws Exception,
                        IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                int rc = -1;
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                if (hkey == HKEY_LOCAL_MACHINE) {
                        rc = deleteKey(systemRoot, hkey, key);
                } else if (hkey == HKEY_CURRENT_USER) {
                        rc = deleteKey(userRoot, hkey, key);
                }
                if (rc != REG_SUCCESS) {
                        throw new IllegalArgumentException("rc=" + rc + "  key=" + key);
                }
        }

        /**
         * delete a value from a given key/value name
         * 
         * @param hkey
         *            HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
         * @param key
         *            Key to access
         * @param value
         *            Name of value to delete
         * @param wow64
         *            0 for standard registry access (32-bits for 32-bit app,
         *            64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
         *            32-bit registry view, or KEY_WOW64_64KEY to force access to
         *            64-bit registry view
         * @throws Exception
         *             If registry access impossible
         * @throws IllegalArgumentException
         *             On illegal arguments
         * @throws IllegalAccessException
         *             On illegal access
         * @throws InvocationTargetException
         *             On reflection problems
         */
        public static void deleteValue(int hkey, String key, String value, int wow64)
                        throws Exception, IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                if (!usable)
                        throw new Exception(
                                        "Registry access not supported (not a Windows OS?).");
                int rc = -1;
                if (hkey == HKEY_LOCAL_MACHINE) {
                        rc = deleteValue(systemRoot, hkey, key, value, wow64);
                } else if (hkey == HKEY_CURRENT_USER) {
                        rc = deleteValue(userRoot, hkey, key, value, wow64);
                }
                if (rc != REG_SUCCESS) {
                        throw new IllegalArgumentException("rc=" + rc + "  key=" + key
                                        + "  value=" + value);
                }
        }

        // ========================================================================
        private static int deleteValue(Preferences root, int hkey, String key,
                        String value, int wow64) throws IllegalArgumentException,
                        IllegalAccessException, InvocationTargetException {
                int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
                                new Integer(hkey), toCstr(key),
                                new Integer(KEY_ALL_ACCESS | wow64) });
                if (handles[1] != REG_SUCCESS) {
                        return handles[1]; // can be REG_NOTFOUND, REG_ACCESSDENIED
                }
                int rc = ((Integer) regDeleteValue.invoke(root, new Object[] {
                                new Integer(handles[0]), toCstr(value) })).intValue();
                regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
                return rc;
        }

        // ========================================================================
        private static int deleteKey(Preferences root, int hkey, String key)
                        throws IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                int rc = ((Integer) regDeleteKey.invoke(root, new Object[] {
                                new Integer(hkey), toCstr(key) })).intValue();
                return rc; // can REG_NOTFOUND, REG_ACCESSDENIED, REG_SUCCESS
        }

        // ========================================================================
        private static String readString(Preferences root, int hkey, String key,
                        String value, int wow64) throws IllegalArgumentException,
                        IllegalAccessException, InvocationTargetException {
                int[] handles = (int[]) regOpenKey
                                .invoke(root, new Object[] { new Integer(hkey), toCstr(key),
                                                new Integer(KEY_READ | wow64) });
                if (handles[1] != REG_SUCCESS) {
                        return null;
                }
                byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[] {
                                new Integer(handles[0]), toCstr(value) });
                regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
                return (valb != null ? new String(valb).trim() : null);
        }

        // ========================================================================
        private static Map<String, String> readStringValues(Preferences root,
                        int hkey, String key, int wow64) throws Exception,
                        IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                HashMap<String, String> results = new HashMap<String, String>();
                int[] handles = (int[]) regOpenKey
                                .invoke(root, new Object[] { new Integer(hkey), toCstr(key),
                                                new Integer(KEY_READ | wow64) });
                if (handles[1] != REG_SUCCESS) {
                        return null;
                }
                int[] info = (int[]) regQueryInfoKey.invoke(root,
                                new Object[] { new Integer(handles[0]) });

                int count = info[2]; // count
                int maxlen = info[4]; // value length max
                for (int index = 0; index < count; index++) {
                        byte[] name = (byte[]) regEnumValue.invoke(root, new Object[] {
                                        new Integer(handles[0]), new Integer(index),
                                        new Integer(maxlen + 1) });
                        String value = readString(hkey, key, new String(name), wow64);
                        results.put(new String(name).trim(), value);
                }
                regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
                return results;
        }

        // ========================================================================
        private static List<String> readStringSubKeys(Preferences root, int hkey,
                        String key, int wow64) throws IllegalArgumentException,
                        IllegalAccessException, InvocationTargetException {
                List<String> results = new ArrayList<String>();
                int[] handles = (int[]) regOpenKey
                                .invoke(root, new Object[] { new Integer(hkey), toCstr(key),
                                                new Integer(KEY_READ | wow64) });
                if (handles[1] != REG_SUCCESS) {
                        return null;
                }
                int[] info = (int[]) regQueryInfoKey.invoke(root,
                                new Object[] { new Integer(handles[0]) });

                int count = info[0]; // Fix: info[2] was being used here with wrong
                                                                // results. Suggested by davenpcj, confirmed by
                                                                // Petrucio
                int maxlen = info[3]; // value length max
                for (int index = 0; index < count; index++) {
                        byte[] name = (byte[]) regEnumKeyEx.invoke(root, new Object[] {
                                        new Integer(handles[0]), new Integer(index),
                                        new Integer(maxlen + 1) });
                        results.add(new String(name).trim());
                }
                regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
                return results;
        }

        // ========================================================================
        private static int[] createKey(Preferences root, int hkey, String key)
                        throws IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                return (int[]) regCreateKeyEx.invoke(root, new Object[] {
                                new Integer(hkey), toCstr(key) });
        }

        // ========================================================================
        private static void writeStringValue(Preferences root, int hkey,
                        String key, String valueName, String value, int wow64)
                        throws IllegalArgumentException, IllegalAccessException,
                        InvocationTargetException {
                int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
                                new Integer(hkey), toCstr(key),
                                new Integer(KEY_ALL_ACCESS | wow64) });
                regSetValueEx.invoke(root, new Object[] { new Integer(handles[0]),
                                toCstr(valueName), toCstr(value) });
                regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
        }

        // ========================================================================
        // utility
        private static byte[] toCstr(String str) {
                byte[] result = new byte[str.length() + 1];

                for (int i = 0; i < str.length(); i++) {
                        result[i] = (byte) str.charAt(i);
                }
                result[str.length()] = 0;
                return result;
        }
}
Revision:	724
Committed:	Thu Mar 21 11:43:42 2013 UTC (12 years, 7 months ago) by alloc
Content type:	text/x-java
File size:	17988 byte(s)
Log Message:	Platform tools library (information about platform, program execution)
#	Content
1	package net.oni2.platformtools;
2
3
4	import java.lang.reflect.InvocationTargetException;
5	import java.lang.reflect.Method;
6	import java.util.ArrayList;
7	import java.util.HashMap;
8	import java.util.List;
9	import java.util.Map;
10	import java.util.prefs.Preferences;
11
12	/**
13	* @author Unknown
14	*/
15	public class WinRegistry {
16	/**
17	* Constant for accessing HKCU
18	*/
19	public static final int HKEY_CURRENT_USER = 0x80000001;
20	/**
21	* Constant for accessing HKLM
22	*/
23	public static final int HKEY_LOCAL_MACHINE = 0x80000002;
24	/**
25	* Constant for successful accesses
26	*/
27	public static final int REG_SUCCESS = 0;
28	/**
29	* Constant for not found
30	*/
31	public static final int REG_NOTFOUND = 2;
32	/**
33	* Constant for access denied
34	*/
35	public static final int REG_ACCESSDENIED = 5;
36
37	/**
38	* Access 32bit registry view when running as 64bit application
39	*/
40	public static final int KEY_WOW64_32KEY = 0x0200;
41	/**
42	* Access 64bit registry view when running as 32bit application
43	*/
44	public static final int KEY_WOW64_64KEY = 0x0100;
45
46	private static final int KEY_ALL_ACCESS = 0xf003f;
47	private static final int KEY_READ = 0x20019;
48	private static Preferences userRoot = Preferences.userRoot();
49	private static Preferences systemRoot = Preferences.systemRoot();
50	private static Class<? extends Preferences> userClass = userRoot.getClass();
51	private static Method regOpenKey = null;
52	private static Method regCloseKey = null;
53	private static Method regQueryValueEx = null;
54	private static Method regEnumValue = null;
55	private static Method regQueryInfoKey = null;
56	private static Method regEnumKeyEx = null;
57	private static Method regCreateKeyEx = null;
58	private static Method regSetValueEx = null;
59	private static Method regDeleteKey = null;
60	private static Method regDeleteValue = null;
61
62	private static boolean usable = false;
63
64	static {
65	try {
66	regOpenKey = userClass.getDeclaredMethod("WindowsRegOpenKey",
67	new Class[] { int.class, byte[].class, int.class });
68	regOpenKey.setAccessible(true);
69	regCloseKey = userClass.getDeclaredMethod("WindowsRegCloseKey",
70	new Class[] { int.class });
71	regCloseKey.setAccessible(true);
72	regQueryValueEx = userClass.getDeclaredMethod(
73	"WindowsRegQueryValueEx", new Class[] { int.class,
74	byte[].class });
75	regQueryValueEx.setAccessible(true);
76	regEnumValue = userClass.getDeclaredMethod("WindowsRegEnumValue",
77	new Class[] { int.class, int.class, int.class });
78	regEnumValue.setAccessible(true);
79	regQueryInfoKey = userClass.getDeclaredMethod(
80	"WindowsRegQueryInfoKey1", new Class[] { int.class });
81	regQueryInfoKey.setAccessible(true);
82	regEnumKeyEx = userClass.getDeclaredMethod("WindowsRegEnumKeyEx",
83	new Class[] { int.class, int.class, int.class });
84	regEnumKeyEx.setAccessible(true);
85	regCreateKeyEx = userClass.getDeclaredMethod(
86	"WindowsRegCreateKeyEx", new Class[] { int.class,
87	byte[].class });
88	regCreateKeyEx.setAccessible(true);
89	regSetValueEx = userClass.getDeclaredMethod("WindowsRegSetValueEx",
90	new Class[] { int.class, byte[].class, byte[].class });
91	regSetValueEx.setAccessible(true);
92	regDeleteValue = userClass.getDeclaredMethod(
93	"WindowsRegDeleteValue", new Class[] { int.class,
94	byte[].class });
95	regDeleteValue.setAccessible(true);
96	regDeleteKey = userClass.getDeclaredMethod("WindowsRegDeleteKey",
97	new Class[] { int.class, byte[].class });
98	regDeleteKey.setAccessible(true);
99	usable = true;
100	} catch (Exception e) {
101	// e.printStackTrace();
102	}
103	}
104
105	private WinRegistry() {
106	}
107
108	/**
109	* Read a value from key and value name
110	*
111	* @param hkey
112	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
113	* @param key
114	* Key to access
115	* @param valueName
116	* Name of value to read
117	* @param wow64
118	* 0 for standard registry access (32-bits for 32-bit app,
119	* 64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
120	* 32-bit registry view, or KEY_WOW64_64KEY to force access to
121	* 64-bit registry view
122	* @return the value
123	* @throws Exception
124	* If registry access impossible
125	* @throws IllegalArgumentException
126	* On illegal arguments
127	* @throws IllegalAccessException
128	* On illegal access
129	* @throws InvocationTargetException
130	* On reflection problems
131	*/
132	public static String readString(int hkey, String key, String valueName,
133	int wow64) throws Exception, IllegalArgumentException,
134	IllegalAccessException, InvocationTargetException {
135	if (!usable)
136	throw new Exception(
137	"Registry access not supported (not a Windows OS?).");
138	if (hkey == HKEY_LOCAL_MACHINE) {
139	return readString(systemRoot, hkey, key, valueName, wow64);
140	} else if (hkey == HKEY_CURRENT_USER) {
141	return readString(userRoot, hkey, key, valueName, wow64);
142	} else {
143	throw new IllegalArgumentException("hkey=" + hkey);
144	}
145	}
146
147	/**
148	* Read value(s) and value name(s) form given key
149	*
150	* @param hkey
151	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
152	* @param key
153	* Key to access
154	* @param wow64
155	* 0 for standard registry access (32-bits for 32-bit app,
156	* 64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
157	* 32-bit registry view, or KEY_WOW64_64KEY to force access to
158	* 64-bit registry view
159	* @return the value name(s) plus the value(s)
160	* @throws Exception
161	* If registry access impossible
162	* @throws IllegalArgumentException
163	* On illegal arguments
164	* @throws IllegalAccessException
165	* On illegal access
166	* @throws InvocationTargetException
167	* On reflection problems
168	*/
169	public static Map<String, String> readStringValues(int hkey, String key,
170	int wow64) throws Exception, IllegalArgumentException,
171	IllegalAccessException, InvocationTargetException {
172	if (!usable)
173	throw new Exception(
174	"Registry access not supported (not a Windows OS?).");
175	if (hkey == HKEY_LOCAL_MACHINE) {
176	return readStringValues(systemRoot, hkey, key, wow64);
177	} else if (hkey == HKEY_CURRENT_USER) {
178	return readStringValues(userRoot, hkey, key, wow64);
179	} else {
180	throw new IllegalArgumentException("hkey=" + hkey);
181	}
182	}
183
184	/**
185	* Read the value name(s) from a given key
186	*
187	* @param hkey
188	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
189	* @param key
190	* Key to access
191	* @param wow64
192	* 0 for standard registry access (32-bits for 32-bit app,
193	* 64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
194	* 32-bit registry view, or KEY_WOW64_64KEY to force access to
195	* 64-bit registry view
196	* @return the value name(s)
197	* @throws Exception
198	* If registry access impossible
199	* @throws IllegalArgumentException
200	* On illegal arguments
201	* @throws IllegalAccessException
202	* On illegal access
203	* @throws InvocationTargetException
204	* On reflection problems
205	*/
206	public static List<String> readStringSubKeys(int hkey, String key, int wow64)
207	throws Exception, IllegalArgumentException, IllegalAccessException,
208	InvocationTargetException {
209	if (!usable)
210	throw new Exception(
211	"Registry access not supported (not a Windows OS?).");
212	if (hkey == HKEY_LOCAL_MACHINE) {
213	return readStringSubKeys(systemRoot, hkey, key, wow64);
214	} else if (hkey == HKEY_CURRENT_USER) {
215	return readStringSubKeys(userRoot, hkey, key, wow64);
216	} else {
217	throw new IllegalArgumentException("hkey=" + hkey);
218	}
219	}
220
221	/**
222	* Create a key
223	*
224	* @param hkey
225	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
226	* @param key
227	* Key to access
228	* @throws Exception
229	* If registry access impossible
230	* @throws IllegalArgumentException
231	* On illegal arguments
232	* @throws IllegalAccessException
233	* On illegal access
234	* @throws InvocationTargetException
235	* On reflection problems
236	*/
237	public static void createKey(int hkey, String key) throws Exception,
238	IllegalArgumentException, IllegalAccessException,
239	InvocationTargetException {
240	int[] ret;
241	if (!usable)
242	throw new Exception(
243	"Registry access not supported (not a Windows OS?).");
244	if (hkey == HKEY_LOCAL_MACHINE) {
245	ret = createKey(systemRoot, hkey, key);
246	regCloseKey
247	.invoke(systemRoot, new Object[] { new Integer(ret[0]) });
248	} else if (hkey == HKEY_CURRENT_USER) {
249	ret = createKey(userRoot, hkey, key);
250	regCloseKey.invoke(userRoot, new Object[] { new Integer(ret[0]) });
251	} else {
252	throw new IllegalArgumentException("hkey=" + hkey);
253	}
254	if (ret[1] != REG_SUCCESS) {
255	throw new IllegalArgumentException("rc=" + ret[1] + " key=" + key);
256	}
257	}
258
259	/**
260	* Write a value in a given key/value name
261	*
262	* @param hkey
263	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
264	* @param key
265	* Key to access
266	* @param valueName
267	* Name of value to write to
268	* @param value
269	* String to write
270	* @param wow64
271	* 0 for standard registry access (32-bits for 32-bit app,
272	* 64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
273	* 32-bit registry view, or KEY_WOW64_64KEY to force access to
274	* 64-bit registry view
275	* @throws Exception
276	* If registry access impossible
277	* @throws IllegalArgumentException
278	* On illegal arguments
279	* @throws IllegalAccessException
280	* On illegal access
281	* @throws InvocationTargetException
282	* On reflection problems
283	*/
284	public static void writeStringValue(int hkey, String key, String valueName,
285	String value, int wow64) throws Exception,
286	IllegalArgumentException, IllegalAccessException,
287	InvocationTargetException {
288	if (!usable)
289	throw new Exception(
290	"Registry access not supported (not a Windows OS?).");
291	if (hkey == HKEY_LOCAL_MACHINE) {
292	writeStringValue(systemRoot, hkey, key, valueName, value, wow64);
293	} else if (hkey == HKEY_CURRENT_USER) {
294	writeStringValue(userRoot, hkey, key, valueName, value, wow64);
295	} else {
296	throw new IllegalArgumentException("hkey=" + hkey);
297	}
298	}
299
300	/**
301	* Delete a given key
302	*
303	* @param hkey
304	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
305	* @param key
306	* Key to delete
307	* @throws Exception
308	* If registry access impossible
309	* @throws IllegalArgumentException
310	* On illegal arguments
311	* @throws IllegalAccessException
312	* On illegal access
313	* @throws InvocationTargetException
314	* On reflection problems
315	*/
316	public static void deleteKey(int hkey, String key) throws Exception,
317	IllegalArgumentException, IllegalAccessException,
318	InvocationTargetException {
319	int rc = -1;
320	if (!usable)
321	throw new Exception(
322	"Registry access not supported (not a Windows OS?).");
323	if (hkey == HKEY_LOCAL_MACHINE) {
324	rc = deleteKey(systemRoot, hkey, key);
325	} else if (hkey == HKEY_CURRENT_USER) {
326	rc = deleteKey(userRoot, hkey, key);
327	}
328	if (rc != REG_SUCCESS) {
329	throw new IllegalArgumentException("rc=" + rc + " key=" + key);
330	}
331	}
332
333	/**
334	* delete a value from a given key/value name
335	*
336	* @param hkey
337	* HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
338	* @param key
339	* Key to access
340	* @param value
341	* Name of value to delete
342	* @param wow64
343	* 0 for standard registry access (32-bits for 32-bit app,
344	* 64-bits for 64-bits app) or KEY_WOW64_32KEY to force access to
345	* 32-bit registry view, or KEY_WOW64_64KEY to force access to
346	* 64-bit registry view
347	* @throws Exception
348	* If registry access impossible
349	* @throws IllegalArgumentException
350	* On illegal arguments
351	* @throws IllegalAccessException
352	* On illegal access
353	* @throws InvocationTargetException
354	* On reflection problems
355	*/
356	public static void deleteValue(int hkey, String key, String value, int wow64)
357	throws Exception, IllegalArgumentException, IllegalAccessException,
358	InvocationTargetException {
359	if (!usable)
360	throw new Exception(
361	"Registry access not supported (not a Windows OS?).");
362	int rc = -1;
363	if (hkey == HKEY_LOCAL_MACHINE) {
364	rc = deleteValue(systemRoot, hkey, key, value, wow64);
365	} else if (hkey == HKEY_CURRENT_USER) {
366	rc = deleteValue(userRoot, hkey, key, value, wow64);
367	}
368	if (rc != REG_SUCCESS) {
369	throw new IllegalArgumentException("rc=" + rc + " key=" + key
370	+ " value=" + value);
371	}
372	}
373
374	// ========================================================================
375	private static int deleteValue(Preferences root, int hkey, String key,
376	String value, int wow64) throws IllegalArgumentException,
377	IllegalAccessException, InvocationTargetException {
378	int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
379	new Integer(hkey), toCstr(key),
380	new Integer(KEY_ALL_ACCESS \| wow64) });
381	if (handles[1] != REG_SUCCESS) {
382	return handles[1]; // can be REG_NOTFOUND, REG_ACCESSDENIED
383	}
384	int rc = ((Integer) regDeleteValue.invoke(root, new Object[] {
385	new Integer(handles[0]), toCstr(value) })).intValue();
386	regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
387	return rc;
388	}
389
390	// ========================================================================
391	private static int deleteKey(Preferences root, int hkey, String key)
392	throws IllegalArgumentException, IllegalAccessException,
393	InvocationTargetException {
394	int rc = ((Integer) regDeleteKey.invoke(root, new Object[] {
395	new Integer(hkey), toCstr(key) })).intValue();
396	return rc; // can REG_NOTFOUND, REG_ACCESSDENIED, REG_SUCCESS
397	}
398
399	// ========================================================================
400	private static String readString(Preferences root, int hkey, String key,
401	String value, int wow64) throws IllegalArgumentException,
402	IllegalAccessException, InvocationTargetException {
403	int[] handles = (int[]) regOpenKey
404	.invoke(root, new Object[] { new Integer(hkey), toCstr(key),
405	new Integer(KEY_READ \| wow64) });
406	if (handles[1] != REG_SUCCESS) {
407	return null;
408	}
409	byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[] {
410	new Integer(handles[0]), toCstr(value) });
411	regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
412	return (valb != null ? new String(valb).trim() : null);
413	}
414
415	// ========================================================================
416	private static Map<String, String> readStringValues(Preferences root,
417	int hkey, String key, int wow64) throws Exception,
418	IllegalArgumentException, IllegalAccessException,
419	InvocationTargetException {
420	HashMap<String, String> results = new HashMap<String, String>();
421	int[] handles = (int[]) regOpenKey
422	.invoke(root, new Object[] { new Integer(hkey), toCstr(key),
423	new Integer(KEY_READ \| wow64) });
424	if (handles[1] != REG_SUCCESS) {
425	return null;
426	}
427	int[] info = (int[]) regQueryInfoKey.invoke(root,
428	new Object[] { new Integer(handles[0]) });
429
430	int count = info[2]; // count
431	int maxlen = info[4]; // value length max
432	for (int index = 0; index < count; index++) {
433	byte[] name = (byte[]) regEnumValue.invoke(root, new Object[] {
434	new Integer(handles[0]), new Integer(index),
435	new Integer(maxlen + 1) });
436	String value = readString(hkey, key, new String(name), wow64);
437	results.put(new String(name).trim(), value);
438	}
439	regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
440	return results;
441	}
442
443	// ========================================================================
444	private static List<String> readStringSubKeys(Preferences root, int hkey,
445	String key, int wow64) throws IllegalArgumentException,
446	IllegalAccessException, InvocationTargetException {
447	List<String> results = new ArrayList<String>();
448	int[] handles = (int[]) regOpenKey
449	.invoke(root, new Object[] { new Integer(hkey), toCstr(key),
450	new Integer(KEY_READ \| wow64) });
451	if (handles[1] != REG_SUCCESS) {
452	return null;
453	}
454	int[] info = (int[]) regQueryInfoKey.invoke(root,
455	new Object[] { new Integer(handles[0]) });
456
457	int count = info[0]; // Fix: info[2] was being used here with wrong
458	// results. Suggested by davenpcj, confirmed by
459	// Petrucio
460	int maxlen = info[3]; // value length max
461	for (int index = 0; index < count; index++) {
462	byte[] name = (byte[]) regEnumKeyEx.invoke(root, new Object[] {
463	new Integer(handles[0]), new Integer(index),
464	new Integer(maxlen + 1) });
465	results.add(new String(name).trim());
466	}
467	regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
468	return results;
469	}
470
471	// ========================================================================
472	private static int[] createKey(Preferences root, int hkey, String key)
473	throws IllegalArgumentException, IllegalAccessException,
474	InvocationTargetException {
475	return (int[]) regCreateKeyEx.invoke(root, new Object[] {
476	new Integer(hkey), toCstr(key) });
477	}
478
479	// ========================================================================
480	private static void writeStringValue(Preferences root, int hkey,
481	String key, String valueName, String value, int wow64)
482	throws IllegalArgumentException, IllegalAccessException,
483	InvocationTargetException {
484	int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
485	new Integer(hkey), toCstr(key),
486	new Integer(KEY_ALL_ACCESS \| wow64) });
487	regSetValueEx.invoke(root, new Object[] { new Integer(handles[0]),
488	toCstr(valueName), toCstr(value) });
489	regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
490	}
491
492	// ========================================================================
493	// utility
494	private static byte[] toCstr(String str) {
495	byte[] result = new byte[str.length() + 1];
496
497	for (int i = 0; i < str.length(); i++) {
498	result[i] = (byte) str.charAt(i);
499	}
500	result[str.length()] = 0;
501	return result;
502	}
503	}