source: trunk/gli/src/org/greenstone/gatherer/util/WinRegistry.java@ 6540

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.util;

/**
 * Title:        The Gatherer
 * Description:  The Gatherer: a tool for gathering and enriching digital collections.
 * Copyright:    Copyright (c) 2001
 * Company:      The University of Waikato
 * Written:      18/11/01
 * Revised:      24/07/02
 * @author John Thompson, Greenstone Digital Libraries
 * @version 2.1
 */
import java.lang.reflect.Method;
/** This class provides access to the Windows registry via the preferences modules of JDK1.4. But wouldn't you know it, it doesn't always read the windows key files correctly as they appear to have changed how they store keys between win98, win2000 and winNT. To combat this, this class will eventually be swallowed by the LauchProgramManager, and used only to attempt to determine the default launching commands. */
public class WinRegistry {
    /** Windows security mask */
    private final static int KEY_QUERY_VALUE = 1;
    /** A constant used to interpret the return of a native function as successful. */
    private final static int NATIVE_HANDLE = 0;
    /** A constant used to interpret the return of a native function as an error. */
    private final static int ERROR_CODE = 1;
    /** Windows error codes. */
    private final static int ERROR_SUCCESS = 0;
    /** HKEY_LOCAL_MACHINE address. */
    private final static int HKEY_LOCAL_MACHINE = 0x80000002;
    /** Called to build a command string that will launch the given file in its associated program according to the windows registry.
     * @param filename The name of a file, including the required extension, as a <strong>String</strong>.
     * @return Another <strong>String</strong> containing a command line which, when run in a command shell, will launch an external application to view this file.
     */
    public static String openCommand(String filename) {
    if(filename.indexOf(".") != -1) {
        String extension = filename.substring(filename.indexOf("."));
        try {
        // First find the name of the file type that is associated with this extension.
        String file_type = getValue("Software\\CLASSES\\" + extension);
        // Then if we got a type, get the open command from its shell reference.
        ///ystem.err.println("Searching for file-type = " + file_type);
        if(file_type != null) {
            String raw = getValue("Software\\CLASSES\\" + file_type + "\\shell\\open\\command");
            //Replace "%1" with "filename"
            if(raw.indexOf("%1") != -1) {
            String prefix = raw.substring(0, raw.indexOf("%1"));
            if(!prefix.endsWith("\"")) {
                prefix = prefix + "\"";
            }
            String suffix = raw.substring(raw.indexOf("%1") + 2);
            if(!suffix.endsWith("\"")) {
                suffix = suffix + "\"";
            }
            return prefix + filename + suffix;
            }
            // Arg. There is a windows flag called /dde, which if it exists in a command tells it to use the filename (hence the meaningful name dde eh?)
            else if(raw.indexOf("/dde") != -1) {
            String prefix = raw.substring(0, raw.indexOf("/dde"));
            if(!prefix.endsWith("\"")) {
                prefix = prefix + "\"";
            }
            String suffix = raw.substring(raw.indexOf("/dde") + 4);
            if(!suffix.endsWith("\"")) {
                suffix = suffix + "\"";
            }
            return prefix + filename + suffix;
            }
            // No file parameter. Append the file to the command and hope for the best.
            return raw + " \"" + filename + "\"";
        }
        }
        catch (Exception error) {
        ///ystem.err.println("No such value.");
        //error.printStackTrace();
        }
    }
    return null;
    }
    /** Attempts to retrieve the value at the location given from the registry using Reflection.
     * @param path The path to the desired key as a <strong>String</strong>.
     * @return The value found at the indicated key as a <strong>String</strong>.
     */ 
    private static String getValue(String path)
    throws ClassNotFoundException, Exception, NoSuchMethodException {
    ///ystem.err.println("Get value " + path);
    byte[] WINDOWS_ROOT_PATH = stringToByteArray(path);
    Class theClass = Class.forName("java.util.prefs.WindowsPreferences");
    int[] result = openKey(HKEY_LOCAL_MACHINE, WINDOWS_ROOT_PATH, KEY_QUERY_VALUE);
    if (result[ERROR_CODE] != ERROR_SUCCESS) {
        throw new Exception("Path not found!");
    }
    int native_handle = result[NATIVE_HANDLE];
    Method m = theClass.getDeclaredMethod("WindowsRegQueryValueEx", new Class[]{int.class, byte[].class});
    m.setAccessible(true);
    byte[] windows_name = toWindowsName("");
    Object value = m.invoke(null, new Object[]{new Integer(native_handle), windows_name});
    WindowsRegCloseKey(native_handle);
    if (value == null) {
        throw new Exception("Path found. Key not found.");
    }
    byte[] origBuffer = (byte[]) value;
    byte[] destBuffer = new byte[origBuffer.length - 1];
    System.arraycopy(origBuffer, 0, destBuffer, 0, origBuffer.length - 1);
    return new String(destBuffer);
    }
    /** Closes the reference (and hence the instantiated objects) to a certain entry within the registry. Do this or suffer massive memory leaks.
     * @param nativeHandle A reference to the piece of memory containing an inspected windows key-value pair.
     * @return The status code returned from closing the key, as an <i>int</i>.
     */
    public static int WindowsRegCloseKey(int nativeHandle)
    throws Exception {
    Class theClass = Class.forName("java.util.prefs.WindowsPreferences");
    Method m = theClass.getDeclaredMethod("WindowsRegCloseKey", new Class[]{int.class});
    m.setAccessible(true);
    Object ret = m.invoke(null, new Object[]{new Integer(nativeHandle)});
    return ((Integer) ret).intValue();
    }
    /** Attempts to open a certain key-value pair from the windows registry, from within a certain region (or HKEY). 
     * @param hkey An <i>int</i> which is the offset for a certain group within the registry.
     * @param windowsAbsolutePath A <i>byte[]</i> containing the path to the desired key, relative to the given HKEY.
     * @param securityMask A mask needed to read values from the registry, as an <i>int</i>.
     * @return An <i>int[]</i> pair, the first of which is the reference to the indicated key if no error occured, and the second of which reports the end error state of the registry open attempt.
     */
    public static int[] openKey(int hkey, byte[] windowsAbsolutePath, int securityMask)
    throws Exception {
    Class theClass = Class.forName("java.util.prefs.WindowsPreferences");
    Method m = theClass.getDeclaredMethod("WindowsRegOpenKey", new Class[]{int.class, byte[].class, int.class});
    m.setAccessible(true);
    Object ret = m.invoke(null, new Object[]{new Integer(hkey), windowsAbsolutePath, new Integer(securityMask)});
    return (int[]) ret;
    }
    /** Converts a string to a byte array. Duh!
     * @param str The <strong>String</strong> to be converted.
     * @return A <i>byte[]</i> containing orderer characters from the String.
     */
    private static byte[] stringToByteArray(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;
    }
     
    private static String toJavaValueString(byte[] windowsNameArray) {
    // Use modified native2ascii algorithm
    String windowsName = byteArrayToString(windowsNameArray);
    StringBuffer javaName = new StringBuffer();
    char ch;
    for (int i = 0; i < windowsName.length(); i++) {
        if ((ch = windowsName.charAt(i)) == '/') {
        char next = ' ';
                     
        if (windowsName.length() > i + 1 &&
            (next = windowsName.charAt(i + 1)) == 'u') {
            if (windowsName.length() < i + 6) {
            break;
            } else {
            ch = (char) Integer.parseInt
                (windowsName.substring(i + 2, i + 6), 16);
            i += 5;
            }
        } else
            if ((windowsName.length() > i + 1) &&
            ((windowsName.charAt(i + 1)) >= 'A') && (next <= 'Z')) {
            ch = next;
            i++;
            } else if ((windowsName.length() > i + 1) &&
                   (next == '/')) {
            ch = '\\';
            i++;
            }
        } else if (ch == '\\') {
        ch = '/';
        }
        javaName.append(ch);
    }
    return javaName.toString();
    }
    /** */
    private static String byteArrayToString(byte[] array) {
    StringBuffer result = new StringBuffer();
    for (int i = 0; i < array.length - 1; i++) {
        result.append((char) array[i]);
    }
    return result.toString();
    }
    /** Magics the name of a certain path component from a Java String to the unique string windows requires.
     * @param javaName The name of a path component as a <strong>String</strong>.
     * @return A <i>byte[]</i> containing the translated string.
     */
    private static byte[] toWindowsName(String javaName) {
    StringBuffer windowsName = new StringBuffer();
    for (int i = 0; i < javaName.length(); i++) {
        char ch = javaName.charAt(i);
        if ((ch < 0x0020) || (ch > 0x007f)) {
        throw new RuntimeException("Unable to convert to Windows name");
        }
        if (ch == '\\') {
        windowsName.append("//");
        } else if (ch == '/') {
        windowsName.append('\\');
        } else if ((ch >= 'A') && (ch <= 'Z')) {
        windowsName.append("/" + ch);
        } else {
        windowsName.append(ch);
        }
    }
    return stringToByteArray(windowsName.toString());
    } 
}