diff --git a/core/src/main/java/hudson/util/jna/Advapi32.java b/core/src/main/java/hudson/util/jna/Advapi32.java new file mode 100644 index 0000000000..96962a3ca9 --- /dev/null +++ b/core/src/main/java/hudson/util/jna/Advapi32.java @@ -0,0 +1,343 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +import com.sun.jna.Structure; +import com.sun.jna.Native; +import com.sun.jna.WString; +import com.sun.jna.Pointer; +import com.sun.jna.win32.StdCallLibrary; +import com.sun.jna.ptr.PointerByReference; +import com.sun.jna.ptr.IntByReference; + +/** + * + * @author TB + */ +public interface Advapi32 extends StdCallLibrary { + Advapi32 INSTANCE = (Advapi32) Native.loadLibrary("Advapi32", Advapi32.class, Options.UNICODE_OPTIONS); + +/* +BOOL WINAPI LookupAccountName( + LPCTSTR lpSystemName, + LPCTSTR lpAccountName, + PSID Sid, + LPDWORD cbSid, + LPTSTR ReferencedDomainName, + LPDWORD cchReferencedDomainName, + PSID_NAME_USE peUse +);*/ + public boolean LookupAccountName(String lpSystemName, String lpAccountName, + byte[] Sid, IntByReference cbSid, char[] ReferencedDomainName, + IntByReference cchReferencedDomainName, PointerByReference peUse); + +/* +BOOL WINAPI LookupAccountSid( + LPCTSTR lpSystemName, + PSID lpSid, + LPTSTR lpName, + LPDWORD cchName, + LPTSTR lpReferencedDomainName, + LPDWORD cchReferencedDomainName, + PSID_NAME_USE peUse +);*/ + public boolean LookupAccountSid(String lpSystemName, byte[] Sid, + char[] lpName, IntByReference cchName, char[] ReferencedDomainName, + IntByReference cchReferencedDomainName, PointerByReference peUse); + +/* +BOOL ConvertSidToStringSid( + PSID Sid, + LPTSTR* StringSid +);*/ + public boolean ConvertSidToStringSid(byte[] Sid, PointerByReference StringSid); + +/* +BOOL WINAPI ConvertStringSidToSid( + LPCTSTR StringSid, + PSID* Sid +);*/ + public boolean ConvertStringSidToSid(String StringSid, PointerByReference Sid); + +/* +SC_HANDLE WINAPI OpenSCManager( + LPCTSTR lpMachineName, + LPCTSTR lpDatabaseName, + DWORD dwDesiredAccess +);*/ + public Pointer OpenSCManager(String lpMachineName, WString lpDatabaseName, int dwDesiredAccess); + +/* +BOOL WINAPI CloseServiceHandle( + SC_HANDLE hSCObject +);*/ + public boolean CloseServiceHandle(Pointer hSCObject); + +/* +SC_HANDLE WINAPI OpenService( + SC_HANDLE hSCManager, + LPCTSTR lpServiceName, + DWORD dwDesiredAccess +);*/ + public Pointer OpenService(Pointer hSCManager, String lpServiceName, int dwDesiredAccess); + +/* +BOOL WINAPI StartService( + SC_HANDLE hService, + DWORD dwNumServiceArgs, + LPCTSTR* lpServiceArgVectors +);*/ + public boolean StartService(Pointer hService, int dwNumServiceArgs, char[] lpServiceArgVectors); + +/* +BOOL WINAPI ControlService( + SC_HANDLE hService, + DWORD dwControl, + LPSERVICE_STATUS lpServiceStatus +);*/ + public boolean ControlService(Pointer hService, int dwControl, SERVICE_STATUS lpServiceStatus); + +/* +BOOL WINAPI StartServiceCtrlDispatcher( + const SERVICE_TABLE_ENTRY* lpServiceTable +);*/ + public boolean StartServiceCtrlDispatcher(Structure[] lpServiceTable); + +/* +SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandler( + LPCTSTR lpServiceName, + LPHANDLER_FUNCTION lpHandlerProc +);*/ + public Pointer RegisterServiceCtrlHandler(String lpServiceName, Handler lpHandlerProc); + +/* +SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerEx( + LPCTSTR lpServiceName, + LPHANDLER_FUNCTION_EX lpHandlerProc, + LPVOID lpContext +);*/ + public Pointer RegisterServiceCtrlHandlerEx(String lpServiceName, HandlerEx lpHandlerProc, Pointer lpContext); + +/* +BOOL WINAPI SetServiceStatus( + SERVICE_STATUS_HANDLE hServiceStatus, + LPSERVICE_STATUS lpServiceStatus +);*/ + public boolean SetServiceStatus(Pointer hServiceStatus, SERVICE_STATUS lpServiceStatus); + +/* +SC_HANDLE WINAPI CreateService( + SC_HANDLE hSCManager, + LPCTSTR lpServiceName, + LPCTSTR lpDisplayName, + DWORD dwDesiredAccess, + DWORD dwServiceType, + DWORD dwStartType, + DWORD dwErrorControl, + LPCTSTR lpBinaryPathName, + LPCTSTR lpLoadOrderGroup, + LPDWORD lpdwTagId, + LPCTSTR lpDependencies, + LPCTSTR lpServiceStartName, + LPCTSTR lpPassword +);*/ + public Pointer CreateService(Pointer hSCManager, String lpServiceName, String lpDisplayName, + int dwDesiredAccess, int dwServiceType, int dwStartType, int dwErrorControl, + String lpBinaryPathName, String lpLoadOrderGroup, IntByReference lpdwTagId, + String lpDependencies, String lpServiceStartName, String lpPassword); + +/* +BOOL WINAPI DeleteService( + SC_HANDLE hService +);*/ + public boolean DeleteService(Pointer hService); + +/* +BOOL WINAPI ChangeServiceConfig2( + SC_HANDLE hService, + DWORD dwInfoLevel, + LPVOID lpInfo +);*/ + public boolean ChangeServiceConfig2(Pointer hService, int dwInfoLevel, ChangeServiceConfig2Info lpInfo); + +/* +LONG WINAPI RegOpenKeyEx( + HKEY hKey, + LPCTSTR lpSubKey, + DWORD ulOptions, + REGSAM samDesired, + PHKEY phkResult +);*/ + public int RegOpenKeyEx(int hKey, String lpSubKey, int ulOptions, int samDesired, IntByReference phkResult); + +/* +LONG WINAPI RegQueryValueEx( + HKEY hKey, + LPCTSTR lpValueName, + LPDWORD lpReserved, + LPDWORD lpType, + LPBYTE lpData, + LPDWORD lpcbData +);*/ + public int RegQueryValueEx(int hKey, String lpValueName, IntByReference lpReserved, IntByReference lpType, byte[] lpData, IntByReference lpcbData); + +/* +LONG WINAPI RegCloseKey( + HKEY hKey +);*/ + public int RegCloseKey(int hKey); + +/* +LONG WINAPI RegDeleteValue( + HKEY hKey, + LPCTSTR lpValueName +);*/ + public int RegDeleteValue(int hKey, String lpValueName); + +/* +LONG WINAPI RegSetValueEx( + HKEY hKey, + LPCTSTR lpValueName, + DWORD Reserved, + DWORD dwType, + const BYTE* lpData, + DWORD cbData +);*/ + public int RegSetValueEx(int hKey, String lpValueName, int Reserved, int dwType, byte[] lpData, int cbData); + +/* +LONG WINAPI RegCreateKeyEx( + HKEY hKey, + LPCTSTR lpSubKey, + DWORD Reserved, + LPTSTR lpClass, + DWORD dwOptions, + REGSAM samDesired, + LPSECURITY_ATTRIBUTES lpSecurityAttributes, + PHKEY phkResult, + LPDWORD lpdwDisposition +);*/ + public int RegCreateKeyEx(int hKey, String lpSubKey, int Reserved, String lpClass, int dwOptions, + int samDesired, WINBASE.SECURITY_ATTRIBUTES lpSecurityAttributes, IntByReference phkResult, + IntByReference lpdwDisposition); + +/* +LONG WINAPI RegDeleteKey( + HKEY hKey, + LPCTSTR lpSubKey +);*/ + public int RegDeleteKey(int hKey, String name); + +/* +LONG WINAPI RegEnumKeyEx( + HKEY hKey, + DWORD dwIndex, + LPTSTR lpName, + LPDWORD lpcName, + LPDWORD lpReserved, + LPTSTR lpClass, + LPDWORD lpcClass, + PFILETIME lpftLastWriteTime +);*/ + public int RegEnumKeyEx(int hKey, int dwIndex, char[] lpName, IntByReference lpcName, IntByReference reserved, + char[] lpClass, IntByReference lpcClass, WINBASE.FILETIME lpftLastWriteTime); + +/* +LONG WINAPI RegEnumValue( + HKEY hKey, + DWORD dwIndex, + LPTSTR lpValueName, + LPDWORD lpcchValueName, + LPDWORD lpReserved, + LPDWORD lpType, + LPBYTE lpData, + LPDWORD lpcbData +);*/ + public int RegEnumValue(int hKey, int dwIndex, char[] lpValueName, IntByReference lpcchValueName, IntByReference reserved, + IntByReference lpType, byte[] lpData, IntByReference lpcbData); + + interface SERVICE_MAIN_FUNCTION extends StdCallCallback { + /* + VOID WINAPI ServiceMain( + DWORD dwArgc, + LPTSTR* lpszArgv + );*/ + public void callback(int dwArgc, Pointer lpszArgv); + } + + interface Handler extends StdCallCallback { + /* + VOID WINAPI Handler( + DWORD fdwControl + );*/ + public void callback(int fdwControl); + } + + interface HandlerEx extends StdCallCallback { + /* + DWORD WINAPI HandlerEx( + DWORD dwControl, + DWORD dwEventType, + LPVOID lpEventData, + LPVOID lpContext + );*/ + public int callback(int dwControl, int dwEventType, Pointer lpEventData, Pointer lpContext); + } + +/* +typedef struct _SERVICE_STATUS { + DWORD dwServiceType; + DWORD dwCurrentState; + DWORD dwControlsAccepted; + DWORD dwWin32ExitCode; + DWORD dwServiceSpecificExitCode; + DWORD dwCheckPoint; + DWORD dwWaitHint; +} SERVICE_STATUS, + *LPSERVICE_STATUS;*/ + public static class SERVICE_STATUS extends Structure { + public int dwServiceType; + public int dwCurrentState; + public int dwControlsAccepted; + public int dwWin32ExitCode; + public int dwServiceSpecificExitCode; + public int dwCheckPoint; + public int dwWaitHint; + } + +/* +typedef struct _SERVICE_TABLE_ENTRY { + LPTSTR lpServiceName; + LPSERVICE_MAIN_FUNCTION lpServiceProc; +} SERVICE_TABLE_ENTRY, + *LPSERVICE_TABLE_ENTRY;*/ + public static class SERVICE_TABLE_ENTRY extends Structure { + public String lpServiceName; + public SERVICE_MAIN_FUNCTION lpServiceProc; + } + + public static class ChangeServiceConfig2Info extends Structure { + } + +/* + typedef struct _SERVICE_DESCRIPTION { + LPTSTR lpDescription; +} SERVICE_DESCRIPTION, + *LPSERVICE_DESCRIPTION;*/ + public static class SERVICE_DESCRIPTION extends ChangeServiceConfig2Info { + public String lpDescription; + } +} \ No newline at end of file diff --git a/core/src/main/java/hudson/util/jna/DotNet.java b/core/src/main/java/hudson/util/jna/DotNet.java new file mode 100644 index 0000000000..95d212c72a --- /dev/null +++ b/core/src/main/java/hudson/util/jna/DotNet.java @@ -0,0 +1,35 @@ +package hudson.util.jna; + +import java.util.regex.Pattern; +import java.util.regex.Matcher; + +/** + * .NET related code. + * + * @author Kohsuke Kawaguchi + */ +public class DotNet { + /** + * Returns true if the .NET framework of the given version (or greater) is installed. + */ + public static boolean isInstalled(int major, int minor) { + // see http://support.microsoft.com/?scid=kb;en-us;315291 for the basic algorithm + // observation in my registry shows that the actual key name can be things like "v2.0 SP1" + // or "v2.0.50727", so the regexp is written to accomodate this. + RegistryKey key = RegistryKey.LOCAL_MACHINE.openReadonly("SOFTWARE\\Microsoft\\.NETFramework"); + for( String keyName : key.getSubKeys() ) { + Matcher m = VERSION_PATTERN.matcher(keyName); + if(m.matches()) { + int mj = Integer.parseInt(m.group(1)); + if(mj>=major) { + int mn = Integer.parseInt(m.group(2)); + if(mn>=minor) + return true; + } + } + } + return false; + } + + private static final Pattern VERSION_PATTERN = Pattern.compile("v(\\d+)\\.(\\d+).*"); +} diff --git a/core/src/main/java/hudson/util/jna/JnaException.java b/core/src/main/java/hudson/util/jna/JnaException.java new file mode 100644 index 0000000000..56d789d1d3 --- /dev/null +++ b/core/src/main/java/hudson/util/jna/JnaException.java @@ -0,0 +1,12 @@ +package hudson.util.jna; + +/** + * Exception in the registry code. + * + * @author Kohsuke Kawaguchi + */ +public class JnaException extends RuntimeException { + public JnaException(int errorCode) { + super("Win32 error: "+errorCode); + } +} diff --git a/core/src/main/java/hudson/util/jna/Options.java b/core/src/main/java/hudson/util/jna/Options.java new file mode 100644 index 0000000000..bb736159bd --- /dev/null +++ b/core/src/main/java/hudson/util/jna/Options.java @@ -0,0 +1,36 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +import static com.sun.jna.Library.*; +import com.sun.jna.win32.W32APITypeMapper; +import com.sun.jna.win32.W32APIFunctionMapper; + +import java.util.Map; +import java.util.HashMap; + +/** + * + * @author TB + */ +public interface Options { + Map UNICODE_OPTIONS = new HashMap() { + { + put(OPTION_TYPE_MAPPER, W32APITypeMapper.UNICODE); + put(OPTION_FUNCTION_MAPPER, W32APIFunctionMapper.UNICODE); + } + }; +} \ No newline at end of file diff --git a/core/src/main/java/hudson/util/jna/RegistryKey.java b/core/src/main/java/hudson/util/jna/RegistryKey.java new file mode 100644 index 0000000000..678ea5a8ab --- /dev/null +++ b/core/src/main/java/hudson/util/jna/RegistryKey.java @@ -0,0 +1,286 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +import com.sun.jna.ptr.IntByReference; + +import java.io.UnsupportedEncodingException; +import java.util.Arrays; +import java.util.Collection; +import java.util.TreeMap; +import java.util.TreeSet; + +/** + * Represents a Win32 registry key. + * + * @author Kohsuke Kawaguchi + */ +public class RegistryKey { + /** + * 32bit Windows key value. + */ + private int handle; + + private final RegistryKey root; + private final String path; + + /** + * Constructor for the root key. + */ + private RegistryKey(int handle) { + this.handle = handle; + root = this; + path = ""; + } + + private RegistryKey(RegistryKey ancestor, String path,int handle) { + this.handle = handle; + this.root = ancestor.root; + this.path = combine(ancestor.path,path); + } + + private static String combine(String a, String b) { + if(a.length()==0) return b; + if(b.length()==0) return a; + return a+'\\'+b; + } + + /** + * Converts a Windows buffer to a Java String. + * + * @param buf buffer + * @throws java.io.UnsupportedEncodingException on error + * @return String + */ + private static String convertBufferToString(byte[] buf) { + try { + return new String(buf, 0, buf.length - 2, "UTF-16LE"); + } catch (UnsupportedEncodingException e) { + throw new AssertionError(e); // impossible + } + } + + /** + * Converts a Windows buffer to an int. + * + * @param buf buffer + * @return int + */ + private static int convertBufferToInt(byte[] buf) { + return (((int) (buf[0] & 0xff)) + (((int) (buf[1] & 0xff)) << 8) + (((int) (buf[2] & 0xff)) << 16) + (((int) (buf[3] & 0xff)) << 24)); + } + + public String getStringValue(String valueName) { + return convertBufferToString(getValue(valueName)); + } + + /** + * Read an int value. + */ + public int getIntValue(String valueName) { + return convertBufferToInt(getValue(valueName)); + } + + private byte[] getValue(String valueName) { + IntByReference pType, lpcbData; + byte[] lpData = new byte[1]; + + pType = new IntByReference(); + lpcbData = new IntByReference(); + + OUTER: + while(true) { + int r = Advapi32.INSTANCE.RegQueryValueEx(handle, valueName, null, pType, lpData, lpcbData); + switch (r) { + case WINERROR.ERROR_MORE_DATA: + lpData = new byte[lpcbData.getValue()]; + continue OUTER; + + case WINERROR.ERROR_SUCCESS: + return lpData; + } + throw new JnaException(r); + } + } + + public void deleteValue(String valueName) { + check(Advapi32.INSTANCE.RegDeleteValue(handle, valueName)); + } + + private void check(int r) { + if (r != WINERROR.ERROR_SUCCESS) + throw new JnaException(r); + } + + /** + * Writes a String value. + */ + public void setValue(String name, String value) { + try { + byte[] data = Arrays.copyOf(value.getBytes("UTF-16LE"), value.length() * 2 + 2); + check(Advapi32.INSTANCE.RegSetValueEx(handle, name, 0, WINNT.REG_SZ, data, data.length)); + } catch (UnsupportedEncodingException e) { + throw new AssertionError(e); + } + } + + /** + * Writes a DWORD value. + */ + public void setValue(String name, int value) { + byte[] data = new byte[4]; + data[0] = (byte) (value & 0xff); + data[1] = (byte) ((value >> 8) & 0xff); + data[2] = (byte) ((value >> 16) & 0xff); + data[3] = (byte) ((value >> 24) & 0xff); + + check(Advapi32.INSTANCE.RegSetValueEx(handle, name, 0, WINNT.REG_DWORD, data, data.length)); + } + + /** + * Does a specified value exist? + */ + public boolean valueExists(String name) { + int r = Advapi32.INSTANCE.RegQueryValueEx(handle, name, null, new IntByReference(), new byte[1], new IntByReference()); + switch(r) { + case WINERROR.ERROR_FILE_NOT_FOUND: + return false; + case WINERROR.ERROR_SUCCESS: + return true; + default: + throw new JnaException(r); + } + } + + /** + * Deletes this key (and disposes the key.) + */ + public void delete() { + check(Advapi32.INSTANCE.RegDeleteKey(handle, path)); + dispose(); + } + + /** + * Get all sub keys of a key. + * + * @return array with all sub key names + */ + public Collection getSubKeys() { + WINBASE.FILETIME lpftLastWriteTime; + TreeSet subKeys = new TreeSet(); + char[] lpName = new char[256]; + IntByReference lpcName = new IntByReference(256); + lpftLastWriteTime = new WINBASE.FILETIME(); + int dwIndex = 0; + + while (Advapi32.INSTANCE.RegEnumKeyEx(handle, dwIndex, lpName, lpcName, null, + null, null, lpftLastWriteTime) == WINERROR.ERROR_SUCCESS) { + subKeys.add(new String(lpName, 0, lpcName.getValue())); + lpcName.setValue(256); + dwIndex++; + } + + return subKeys; + } + + public RegistryKey open(String subKeyName) { + return open(subKeyName,0xF003F/*KEY_ALL_ACCESS*/); + } + + public RegistryKey openReadonly(String subKeyName) { + return open(subKeyName,0x20019/*KEY_READ*/); + } + + public RegistryKey open(String subKeyName, int access) { + IntByReference pHandle = new IntByReference(); + check(Advapi32.INSTANCE.RegOpenKeyEx(handle, subKeyName, 0, access, pHandle)); + return new RegistryKey(this,subKeyName,pHandle.getValue()); + } + + /** + * Get all values under a key. + * + * @return TreeMap with name and value pairs + */ + public TreeMap getValues() { + int dwIndex, result; + char[] lpValueName; + byte[] lpData; + IntByReference lpcchValueName, lpType, lpcbData; + String name; + TreeMap values = new TreeMap(String.CASE_INSENSITIVE_ORDER); + + lpValueName = new char[16384]; + lpcchValueName = new IntByReference(16384); + lpType = new IntByReference(); + lpData = new byte[1]; + lpcbData = new IntByReference(); + + dwIndex = 0; + + while (true) { + lpcbData.setValue(0); + result = Advapi32.INSTANCE.RegEnumValue(handle, dwIndex, lpValueName, lpcchValueName, null, + lpType, lpData, lpcbData); + switch (result) { + case WINERROR.ERROR_NO_MORE_ITEMS: + return values; + + case WINERROR.ERROR_MORE_DATA: + lpData = new byte[lpcbData.getValue()]; + lpcchValueName = new IntByReference(16384); + check(Advapi32.INSTANCE.RegEnumValue(handle, dwIndex, lpValueName, lpcchValueName, null, + lpType, lpData, lpcbData)); + + name = new String(lpValueName, 0, lpcchValueName.getValue()); + + switch (lpType.getValue()) { + case WINNT.REG_SZ: + values.put(name, convertBufferToString(lpData)); + break; + case WINNT.REG_DWORD: + values.put(name, convertBufferToInt(lpData)); + break; + default: + break; // not supported yet + } + default: + check(result); + } + dwIndex++; + } + } + + + protected void finalize() throws Throwable { + super.finalize(); + dispose(); + } + + public void dispose() { + if(handle!=0) + Advapi32.INSTANCE.RegCloseKey(handle); + handle = 0; + } + + // +// Root keys +// + public static final RegistryKey CLASSES_ROOT = new RegistryKey(0x80000000); + public static final RegistryKey CURRENT_USER = new RegistryKey(0x80000001); + public static final RegistryKey LOCAL_MACHINE = new RegistryKey(0x80000002); + public static final RegistryKey USERS = new RegistryKey(0x80000003); +} diff --git a/core/src/main/java/hudson/util/jna/WINBASE.java b/core/src/main/java/hudson/util/jna/WINBASE.java new file mode 100644 index 0000000000..75080cb641 --- /dev/null +++ b/core/src/main/java/hudson/util/jna/WINBASE.java @@ -0,0 +1,49 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +import com.sun.jna.Structure; +import com.sun.jna.Pointer; + +/** + * + * @author TB + */ +public interface WINBASE { +/* +typedef struct _SECURITY_ATTRIBUTES { + DWORD nLength; + LPVOID lpSecurityDescriptor; + BOOL bInheritHandle; +} SECURITY_ATTRIBUTES, + *PSECURITY_ATTRIBUTES, + *LPSECURITY_ATTRIBUTES;*/ + public static class SECURITY_ATTRIBUTES extends Structure { + public int nLength; + public Pointer lpSecurityDescriptor; + public boolean bInheritHandle; + } + +/* +typedef struct _FILETIME { + DWORD dwLowDateTime; + DWORD dwHighDateTime; +} FILETIME, *PFILETIME, *LPFILETIME;*/ + public static class FILETIME extends Structure { + public int dwLowDateTime; + public int dwHighDateTime; + } +} \ No newline at end of file diff --git a/core/src/main/java/hudson/util/jna/WINERROR.java b/core/src/main/java/hudson/util/jna/WINERROR.java new file mode 100644 index 0000000000..052024993c --- /dev/null +++ b/core/src/main/java/hudson/util/jna/WINERROR.java @@ -0,0 +1,28 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +/** + * + * @author TB + */ +public interface WINERROR { + public final static int ERROR_SUCCESS = 0; + public final static int NO_ERROR = 0; + public final static int ERROR_FILE_NOT_FOUND = 2; + public final static int ERROR_MORE_DATA = 234; + public final static int ERROR_NO_MORE_ITEMS = 259; +} diff --git a/core/src/main/java/hudson/util/jna/WINNT.java b/core/src/main/java/hudson/util/jna/WINNT.java new file mode 100644 index 0000000000..c66fe338d7 --- /dev/null +++ b/core/src/main/java/hudson/util/jna/WINNT.java @@ -0,0 +1,79 @@ +/* +Copyright (c) 2007 Thomas Boerkel, All Rights Reserved + +Disclaimer: +=========== +This code is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This code 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 +Lesser General Public License for more details. + */ +package hudson.util.jna; + +/** + * + * @author TB + */ +public interface WINNT { + public final static int DELETE = 0x00010000; + public final static int READ_CONTROL = 0x00020000; + public final static int WRITE_DAC = 0x00040000; + public final static int WRITE_OWNER = 0x00080000; + public final static int SYNCHRONIZE = 0x00100000; + + public final static int STANDARD_RIGHTS_REQUIRED = 0x000F0000; + + public final static int STANDARD_RIGHTS_READ = READ_CONTROL; + public final static int STANDARD_RIGHTS_WRITE = READ_CONTROL; + public final static int STANDARD_RIGHTS_EXECUTE = READ_CONTROL; + + public final static int STANDARD_RIGHTS_ALL = 0x001F0000; + + public final static int SPECIFIC_RIGHTS_ALL = 0x0000FFFF; + + public final static int GENERIC_EXECUTE = 0x20000000; + + public final static int SERVICE_WIN32_OWN_PROCESS = 0x00000010; + + public final static int KEY_QUERY_VALUE = 0x0001; + public final static int KEY_SET_VALUE = 0x0002; + public final static int KEY_CREATE_SUB_KEY = 0x0004; + public final static int KEY_ENUMERATE_SUB_KEYS = 0x0008; + public final static int KEY_NOTIFY = 0x0010; + public final static int KEY_CREATE_LINK = 0x0020; + + public final static int KEY_READ = ((STANDARD_RIGHTS_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY) & (~SYNCHRONIZE)); + public final static int KEY_WRITE = ((STANDARD_RIGHTS_WRITE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY) & (~SYNCHRONIZE)); + + public final static int REG_NONE = 0; // No value type + public final static int REG_SZ = 1; // Unicode nul terminated string + public final static int REG_EXPAND_SZ = 2; // Unicode nul terminated string + // (with environment variable references) + public final static int REG_BINARY = 3; // Free form binary + public final static int REG_DWORD = 4; // 32-bit number + public final static int REG_DWORD_LITTLE_ENDIAN = 4; // 32-bit number (same as REG_DWORD) + public final static int REG_DWORD_BIG_ENDIAN = 5; // 32-bit number + public final static int REG_LINK = 6; // Symbolic Link (unicode) + public final static int REG_MULTI_SZ = 7; // Multiple Unicode strings + public final static int REG_RESOURCE_LIST = 8; // Resource list in the resource map + public final static int REG_FULL_RESOURCE_DESCRIPTOR = 9; // Resource list in the hardware description + public final static int REG_RESOURCE_REQUIREMENTS_LIST = 10; + + public final static int REG_OPTION_RESERVED = 0x00000000; // Parameter is reserved + public final static int REG_OPTION_NON_VOLATILE = 0x00000000; // Key is preserved + // when system is rebooted + public final static int REG_OPTION_VOLATILE = 0x00000001; // Key is not preserved + // when system is rebooted + public final static int REG_OPTION_CREATE_LINK = 0x00000002; // Created key is a + // symbolic link + public final static int REG_OPTION_BACKUP_RESTORE = 0x00000004; // open for backup or restore + // special access rules + // privilege required + public final static int REG_OPTION_OPEN_LINK = 0x00000008; // Open symbolic link + +}