From 9d6b88165f30fcbaf1874485112d9ed5d7c78226 Mon Sep 17 00:00:00 2001 From: tkellner Date: Mon, 1 Aug 2011 08:23:21 +0000 Subject: Autostart feature added (Linux, Windows) git-svn-id: https://joinup.ec.europa.eu/svn/mocca/trunk@948 8a26b1a7-26f0-462f-b9ef-d0e30c41f5a4 --- .../bku/webstart/autostart/AbstractAutostart.java | 38 ++ .../gv/egiz/bku/webstart/autostart/Autostart.java | 68 ++++ .../bku/webstart/autostart/AutostartInterface.java | 30 ++ .../bku/webstart/autostart/AutostartLinux.java | 135 +++++++ .../bku/webstart/autostart/AutostartWindows.java | 207 +++++++++++ .../egiz/bku/webstart/autostart/WinRegistry.java | 386 +++++++++++++++++++++ 6 files changed, 864 insertions(+) create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AbstractAutostart.java create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/Autostart.java create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartInterface.java create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartLinux.java create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartWindows.java create mode 100644 BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/WinRegistry.java (limited to 'BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart') diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AbstractAutostart.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AbstractAutostart.java new file mode 100644 index 00000000..5e7966b8 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AbstractAutostart.java @@ -0,0 +1,38 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +public abstract class AbstractAutostart implements AutostartInterface { + protected static final String AUTOSTART_FILENAME_PREFIX = "MOCCA"; + + String _os = System.getProperty("os.name"); + String _userHome = System.getProperty("user.home") + System.getProperty("file.separator"); + String _webstartName = null; + + @Override + public void setWebstartName(String webstartName) { + _webstartName = webstartName; + } + +} diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/Autostart.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/Autostart.java new file mode 100644 index 00000000..a3291d05 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/Autostart.java @@ -0,0 +1,68 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +public class Autostart { + private static AutostartInterface _autostart = null; + + private String _webstartName = null; + + private AutostartInterface getAutostart() + { + if (_autostart == null) + { + String os = System.getProperty("os.name"); + if (os.equalsIgnoreCase("linux")) + _autostart = new AutostartLinux(); + else if (os.toLowerCase().contains("windows")) + _autostart = new AutostartWindows(); + if (_webstartName != null) + _autostart.setWebstartName(_webstartName); + } + + return _autostart; + } + + public boolean isEnabled() { + if (getAutostart() == null) + return false; + + return getAutostart().isEnabled(); + } + + public boolean set(boolean enable) { + if (getAutostart() == null) + return false; + + return getAutostart().set(enable); + } + + public void setWebstartName(String webstartName) { + if (_autostart == null) + _webstartName = webstartName; + else + _autostart.setWebstartName(webstartName); + } + +} diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartInterface.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartInterface.java new file mode 100644 index 00000000..f085fc94 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartInterface.java @@ -0,0 +1,30 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +public interface AutostartInterface { + public boolean isEnabled(); + public boolean set(boolean enable); + public void setWebstartName(String webstartName); +} diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartLinux.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartLinux.java new file mode 100644 index 00000000..4fc91a30 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartLinux.java @@ -0,0 +1,135 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.util.HashMap; +import java.util.Map; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AutostartLinux extends AbstractAutostart { + private static Logger log = LoggerFactory.getLogger(AutostartLinux.class); + + private Map getAutostartFiles() + { + Map autostartFiles = new HashMap(); + String autostartFileName, autostartFileContent; + String autostartCommand = "javaws -Xnosplash " + _webstartName; + + // KDE Autostart + File f = new File(_userHome + ".kde/Autostart"); + if ((f.exists()) && (f.isDirectory())) { + autostartFileName = _userHome + ".kde/Autostart/" + + AUTOSTART_FILENAME_PREFIX + ".sh"; + autostartFileContent = "#!/bin/sh\n" + autostartCommand + "\n"; + autostartFiles.put(autostartFileName, autostartFileContent); + } + + // Gnome Autostart + f = new File(_userHome + ".config/autostart"); + if ((f.exists()) && (f.isDirectory())) { + autostartFileName = _userHome + ".config/autostart/" + + AUTOSTART_FILENAME_PREFIX + ".desktop"; + autostartFileContent = + "[Desktop Entry]\n" + + "Name=" + AUTOSTART_FILENAME_PREFIX + "\n" + + "Type=Application\n" + + "Exec=" + autostartCommand + "\n" + + "Terminal=false\n" + + "Hidden=false\n"; + autostartFiles.put(autostartFileName, autostartFileContent); + } + return autostartFiles; + } + + @Override + public boolean isEnabled() { + Map autostartFiles = getAutostartFiles(); + + if (autostartFiles.isEmpty()) + return false; + + for (Map.Entry file : autostartFiles.entrySet()) { + String autostartFileName = file.getKey(); + try { + File f = new File(autostartFileName); + if (f.exists()) + return true; + } catch (Exception e) { + // ignore + } + } + return false; + } + + @Override + public boolean set(boolean enable) { + Map autostartFiles = getAutostartFiles(); + + if (autostartFiles.isEmpty()) + return false; + + boolean ret = false; + for (Map.Entry file : autostartFiles.entrySet()) { + String autostartFileName = file.getKey(); + String autostartFileContent = file.getValue(); + File f = new File(autostartFileName); + + if (enable) + { + log.debug("Enabling AutoStart (" + autostartFileName + ")"); + try { + FileWriter fw = new FileWriter(f, false); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(autostartFileContent); + bw.flush(); + bw.close(); + fw.close(); + if (autostartFileName.contains(".kde")) + f.setExecutable(true, false); + f.setReadable(true, false); + ret = true; + } catch (Exception e) { + log.error("Failed to add autostart file", e); + } + } + else + { + log.debug("Disabling AutoStart (" + autostartFileName + ")"); + try { + f.delete(); + } catch (Exception e) { + log.error("Failed to remove autostart file", e); + } + } + } + + return ret; + } + +} diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartWindows.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartWindows.java new file mode 100644 index 00000000..50c38d97 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/AutostartWindows.java @@ -0,0 +1,207 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.channels.FileChannel; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AutostartWindows extends AbstractAutostart { + private static Logger log = LoggerFactory.getLogger(AutostartWindows.class); + private static final String DESKTOP_SHORTCUT_NAME = "MOCCA Start.lnk"; + + private String _linkname = null; + + public AutostartWindows() { + try { + // BKA Workaround: If shortcut exists on desktop, use it for autostart + _linkname = WinRegistry.readString( + WinRegistry.HKEY_CURRENT_USER, + "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", + "Desktop") + + "\\" + DESKTOP_SHORTCUT_NAME; + File f = new File(_linkname); + if (f.exists()) + return; + _linkname = WinRegistry.readString( + WinRegistry.HKEY_LOCAL_MACHINE, + "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", + "Common Desktop") + + "\\" + DESKTOP_SHORTCUT_NAME; + f = new File(_linkname); + if (f.exists()) + return; + _linkname = null; + } catch (Exception e) { + log.debug("Registry reading failed", e); + } + } + + private static boolean copyFile(File srcF, File dstF) { + boolean ret = false; + try { + if (!dstF.exists()) + dstF.createNewFile(); + FileChannel src = null; + FileChannel dst = null; + try { + src = new FileInputStream(srcF).getChannel(); + dst = new FileOutputStream(dstF).getChannel(); + if (dst.transferFrom(src, 0, src.size()) < src.size()) { + dst.close(); + dst = null; + dstF.delete(); + log.error("Failed to copy autostart shortcut"); + } else + ret = true; + } catch (FileNotFoundException e) { + log.error("Failed to copy autostart shortcut", e); + } finally { + if (src != null) + src.close(); + if (dst != null) + dst.close(); + } + } catch (IOException e) { + log.error("Failed to copy autostart shortcut", e); + } + return ret; + } + + private static boolean createFile(File f, String content) { + try { + FileWriter fw = new FileWriter(f, false); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(content); + bw.flush(); + bw.close(); + fw.close(); + f.setExecutable(true); + return true; + } catch (Exception e) { + log.error("Failed to add autostart file", e); + } + return false; + } + + private String getAutostartFileName() { + String fileName = AUTOSTART_FILENAME_PREFIX + + (_linkname != null ? ".lnk" : ".bat"); + String autostartFileName = null; + try { + autostartFileName = WinRegistry + .readString( + WinRegistry.HKEY_CURRENT_USER, + "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", + "Startup"); + if (autostartFileName == null) + throw new Exception("Null returned"); + autostartFileName += "\\" + fileName; + } catch (Exception e) { + log.debug("Registry reading failed - trying fallback", e); + + String autostartFolderPaths[] = { + _userHome + "Startmenü\\Programme\\Autostart", // German + // Windows + // default + // autostart + // path + _userHome + "Startmenu\\Programs\\Startup" // English + // Windows + // default + // autostart + // path + }; + + for (String path : autostartFolderPaths) { + File f = new File(path); + if (f.exists()) { + autostartFileName = _userHome + path + "\\" + fileName; + break; + } + } + } + return autostartFileName; + } + + @Override + public boolean isEnabled() { + String autostartFileName = getAutostartFileName(); + + if (autostartFileName == null) + return false; + + try { + File f = new File(autostartFileName); + if (f.exists()) + return true; + } catch (Exception e) { + // ignore + } + return false; + } + + @Override + public boolean set(boolean enable) { + String autostartFileName = getAutostartFileName(); + + if (autostartFileName == null) + return false; + + String javaws_loc = System.getProperty("java.home") + + "\\bin\\javaws.exe"; + File f = new File(javaws_loc); + if (!f.exists()) + javaws_loc = "javaws.exe"; + String autostartFileContent = "@\"" + javaws_loc + "\" -Xnosplash " + + _webstartName + "\r\n"; + + f = new File(autostartFileName); + + if (enable) { + log.debug("Enabling AutoStart (" + autostartFileName + ")"); + if (_linkname != null) + return copyFile(new File(_linkname), f); + else + return createFile(f, autostartFileContent); + } else { + log.debug("Disabling AutoStart (" + autostartFileName + ")"); + try { + f.delete(); + } catch (Exception e) { + log.error("Failed to remove autostart file", e); + } + return false; + } + } + +} diff --git a/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/WinRegistry.java b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/WinRegistry.java new file mode 100644 index 00000000..8a79d227 --- /dev/null +++ b/BKUWebStart/src/main/java/at/gv/egiz/bku/webstart/autostart/WinRegistry.java @@ -0,0 +1,386 @@ +/* + * Copyright 2011 by Graz University of Technology, Austria + * MOCCA has been developed by the E-Government Innovation Center EGIZ, a joint + * initiative of the Federal Chancellery Austria and Graz University of Technology. + * + * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by + * the European Commission - subsequent versions of the EUPL (the "Licence"); + * You may not use this work except in compliance with the Licence. + * You may obtain a copy of the Licence at: + * http://www.osor.eu/eupl/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the Licence is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Licence for the specific language governing permissions and + * limitations under the Licence. + * + * This product combines work with different licenses. See the "NOTICE" text + * file for details on the various modules and licenses. + * The "NOTICE" text file is part of the distribution. Any derivative works + * that you distribute must include a readable copy of the "NOTICE" text file. + */ + +package at.gv.egiz.bku.webstart.autostart; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; +import java.util.ArrayList; +import java.util.List; +import java.util.prefs.Preferences; + +public class WinRegistry { + public static final int HKEY_CURRENT_USER = 0x80000001; + public static final int HKEY_LOCAL_MACHINE = 0x80000002; + public static final int REG_SUCCESS = 0; + public static final int REG_NOTFOUND = 2; + public static final int REG_ACCESSDENIED = 5; + +// 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 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; + + 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); + } 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 + * @param valueName + * @return the value + * @throws IllegalArgumentException + * @throws IllegalAccessException + * @throws InvocationTargetException + */ + public static String readString(int hkey, String key, String valueName) + throws IllegalArgumentException, IllegalAccessException, + InvocationTargetException { + if (hkey == HKEY_LOCAL_MACHINE) { + return readString(systemRoot, hkey, key, valueName); + } else if (hkey == HKEY_CURRENT_USER) { + return readString(userRoot, hkey, key, valueName); + } 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 + * @return the value name(s) plus the value(s) + * @throws IllegalArgumentException + * @throws IllegalAccessException + * @throws InvocationTargetException + */ + public static Map readStringValues(int hkey, String key) + throws IllegalArgumentException, IllegalAccessException, + InvocationTargetException { + if (hkey == HKEY_LOCAL_MACHINE) { + return readStringValues(systemRoot, hkey, key); + } else if (hkey == HKEY_CURRENT_USER) { + return readStringValues(userRoot, hkey, key); + } 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 + * @return the value name(s) + * @throws IllegalArgumentException + * @throws IllegalAccessException + * @throws InvocationTargetException + */ + public static List readStringSubKeys(int hkey, String key) + throws IllegalArgumentException, IllegalAccessException, + InvocationTargetException { + if (hkey == HKEY_LOCAL_MACHINE) { + return readStringSubKeys(systemRoot, hkey, key); + } else if (hkey == HKEY_CURRENT_USER) { + return readStringSubKeys(userRoot, hkey, key); + } else { + throw new IllegalArgumentException("hkey=" + hkey); + } + } + +// /** +// * Create a key +// * +// * @param hkey +// * HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE +// * @param key +// * @throws IllegalArgumentException +// * @throws IllegalAccessException +// * @throws InvocationTargetException +// */ +// public static void createKey(int hkey, String key) +// throws IllegalArgumentException, IllegalAccessException, +// InvocationTargetException { +// int[] ret; +// 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 +// * @param key +// * @param valueName +// * @param value +// * @throws IllegalArgumentException +// * @throws IllegalAccessException +// * @throws InvocationTargetException +// */ +// public static void writeStringValue(int hkey, String key, String valueName, +// String value) throws IllegalArgumentException, +// IllegalAccessException, InvocationTargetException { +// if (hkey == HKEY_LOCAL_MACHINE) { +// writeStringValue(systemRoot, hkey, key, valueName, value); +// } else if (hkey == HKEY_CURRENT_USER) { +// writeStringValue(userRoot, hkey, key, valueName, value); +// } else { +// throw new IllegalArgumentException("hkey=" + hkey); +// } +// } + +// /** +// * Delete a given key +// * +// * @param hkey +// * @param key +// * @throws IllegalArgumentException +// * @throws IllegalAccessException +// * @throws InvocationTargetException +// */ +// public static void deleteKey(int hkey, String key) +// throws IllegalArgumentException, IllegalAccessException, +// InvocationTargetException { +// int rc = -1; +// 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 +// * @param key +// * @param value +// * @throws IllegalArgumentException +// * @throws IllegalAccessException +// * @throws InvocationTargetException +// */ +// public static void deleteValue(int hkey, String key, String value) +// throws IllegalArgumentException, IllegalAccessException, +// InvocationTargetException { +// int rc = -1; +// if (hkey == HKEY_LOCAL_MACHINE) { +// rc = deleteValue(systemRoot, hkey, key, value); +// } else if (hkey == HKEY_CURRENT_USER) { +// rc = deleteValue(userRoot, hkey, key, value); +// } +// 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) throws IllegalArgumentException, +// IllegalAccessException, InvocationTargetException { +// int[] handles = (int[]) regOpenKey.invoke(root, new Object[] { +// new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) }); +// 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) throws IllegalArgumentException, + IllegalAccessException, InvocationTargetException { + int[] handles = (int[]) regOpenKey.invoke(root, new Object[] { + new Integer(hkey), toCstr(key), new Integer(KEY_READ) }); + 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 readStringValues(Preferences root, + int hkey, String key) throws IllegalArgumentException, + IllegalAccessException, InvocationTargetException { + HashMap results = new HashMap(); + int[] handles = (int[]) regOpenKey.invoke(root, new Object[] { + new Integer(hkey), toCstr(key), new Integer(KEY_READ) }); + 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[3]; // 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)); + results.put(new String(name).trim(), value); + } + regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) }); + return results; + } + + private static List readStringSubKeys(Preferences root, int hkey, + String key) throws IllegalArgumentException, + IllegalAccessException, InvocationTargetException { + List results = new ArrayList(); + int[] handles = (int[]) regOpenKey.invoke(root, new Object[] { + new Integer(hkey), toCstr(key), new Integer(KEY_READ) }); + 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[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) +// throws IllegalArgumentException, IllegalAccessException, +// InvocationTargetException { +// int[] handles = (int[]) regOpenKey.invoke(root, new Object[] { +// new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) }); +// +// 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; + } +} -- cgit v1.2.3