Advapi32.java

/*
 * Advapi32.java
 *
 * Created on 6. August 2007, 11:24
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package jnacontrib.jna;

import java.util.ArrayList;
import java.util.List;

import com.sun.jna.Memory;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import com.sun.jna.WString;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.ptr.PointerByReference;
import com.sun.jna.win32.StdCallLibrary;

/**
 * 
 * @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
	{
	}

	/*
	 * YAJSW additions start here
	 */

	/*
	 * BOOL WINAPI QueryServiceConfig( __in SC_HANDLE hService, __out_opt
	 * LPQUERY_SERVICE_CONFIG lpServiceConfig, __in DWORD cbBufSize, __out
	 * LPDWORD pcbBytesNeeded );
	 */
	boolean QueryServiceConfig(Pointer hService, Memory lpServiceConfig, int cbBufSize, IntByReference pcbBytesNeeded);

	/*
	 * BOOL WINAPI QueryServiceStatusEx( __in SC_HANDLE hService, __in
	 * SC_STATUS_TYPE InfoLevel, __out_opt LPBYTE lpBuffer, __in DWORD
	 * cbBufSize, __out LPDWORD pcbBytesNeeded );
	 */
	boolean QueryServiceStatusEx(Pointer hService, short InfoLevel, Memory lpBuffer, int cbBufSize, IntByReference pcbBytesNeeded);

	public static final int	SC_STATUS_PROCESS_INFO	= 0;

	/*
	 * BOOL WINAPI QueryServiceConfig2( __in SC_HANDLE hService, __in DWORD
	 * dwInfoLevel, __out_opt LPBYTE lpBuffer, __in DWORD cbBufSize, __out
	 * LPDWORD pcbBytesNeeded );
	 */
	boolean QueryServiceConfig2(Pointer hService, short InfoLevel, Memory lpBuffer, int cbBufSize, IntByReference pcbBytesNeeded);

	public static final int	SERVICE_CONFIG_DESCRIPTION	= 1;

	/*
	 * typedef struct _ENUM_SERVICE_STATUS_PROCESS { LPTSTR lpServiceName;
	 * LPTSTR lpDisplayName; SERVICE_STATUS_PROCESS ServiceStatusProcess; }
	 * ENUM_SERVICE_STATUS_PROCESS,LPENUM_SERVICE_STATUS_PROCESS;
	 */

	public static class ENUM_SERVICE_STATUS_PROCESS extends Structure
	{
		public Pointer					lpServiceName;
		public Pointer					lpDisplayName;
		public SERVICE_STATUS_PROCESS	ServiceStatusProcess;

		public void init(Pointer pointer)
		{
			useMemory(pointer);
			read();
		}

		public ENUM_SERVICE_STATUS_PROCESS next()
		{
			ENUM_SERVICE_STATUS_PROCESS next = new ENUM_SERVICE_STATUS_PROCESS();
			next.useMemory(getPointer(), size());
			next.read();
			return next;
		}

		public String getServiceName()
		{
			return lpServiceName.getString(0, true);
		}

		public String getDisplayName()
		{
			return lpDisplayName.getString(0, true);
		}

		public int getProcessId()
		{
			return ServiceStatusProcess.dwProcessId;
		}

		public int getCurrentState()
		{
			return ServiceStatusProcess.dwCurrentState;
		}

	}

	/*
	 * typedef struct _SERVICE_STATUS_PROCESS { DWORD dwServiceType; DWORD
	 * dwCurrentState; DWORD dwControlsAccepted; DWORD dwWin32ExitCode; DWORD
	 * dwServiceSpecificExitCode; DWORD dwCheckPoint; DWORD dwWaitHint; DWORD
	 * dwProcessId; DWORD dwServiceFlags; } SERVICE_STATUS_PROCESS,
	 * LPSERVICE_STATUS_PROCESS;
	 */

	public static class SERVICE_STATUS_PROCESS extends Structure
	{
		public void init(Pointer pointer)
		{
			useMemory(pointer);
			read();
		}

		public int	dwServiceType;
		public int	dwCurrentState;
		public int	dwControlsAccepted;
		public int	dwWin32ExitCode;
		public int	dwServiceSpecificExitCode;
		public int	dwCheckPoint;
		public int	dwWaitHint;
		public int	dwProcessId;
		public int	dwServiceFlags;

	}

	public static final int	SERVICE_RUNNING			= 0x00000004;
	public static final int	SERVICE_STOPPED			= 0x00000001;
	public static final int	SERVICE_PAUSED			= 0x00000007;
	public static final int	SERVICE_START_PENDING	= 0x00000002;
	public static final int	SERVICE_STOP_PENDING	= 0x00000003;

	/*
	 * typedef struct _QUERY_SERVICE_CONFIG { DWORD dwServiceType; DWORD
	 * dwStartType; DWORD dwErrorControl; LPTSTR lpBinaryPathName; LPTSTR
	 * lpLoadOrderGroup; DWORD dwTagId; LPTSTR lpDependencies; LPTSTR
	 * lpServiceStartName; LPTSTR lpDisplayName; } QUERY_SERVICE_CONFIG,
	 * LPQUERY_SERVICE_CONFIG;
	 */

	public static class QUERY_SERVICE_CONFIG extends Structure
	{
		public void init(Pointer pointer)
		{
			useMemory(pointer);
			read();
		}

		public int		dwServiceType;
		public int		dwStartType;
		public int		dwErrorControl;
		public String	lpBinaryPathName;
		public String	lpLoadOrderGroup;
		public int		dwTagId;
		public Pointer	lpDependencies;
		public String	lpServiceStartName;
		public String	lpDisplayName;

		public String[] getDependencies()
		{
			List<String> result = new ArrayList<String>();
			Pointer ptr = lpDependencies;
			int offset = 0;
			String s = "";
			if (ptr != null)
				do
				{
					s = ptr.getString(offset, true);
					if (s != null && !"".equals(s))
					{
						result.add(s);
						offset += s.getBytes().length * 2 + 2;
					}
				}
				while (s != null && !"".equals(s));
			return result.toArray(new String[0]);
		}

	}

	/*
	 * typedef struct _SERVICE_DESCRIPTION { LPTSTR lpDescription; }
	 * SERVICE_DESCRIPTION,LPSERVICE_DESCRIPTION;
	 */
	public static class SERVICE_DESCRIPTION extends ChangeServiceConfig2Info
	{
		public String	lpDescription;

		public void init(Pointer pointer)
		{
			useMemory(pointer);
			read();
		}
	}
	
	/*
	 * typedef struct _SERVICE_DELAYED_AUTO_START_INFO {
  BOOL fDelayedAutostart;}
	 */
	public static class SERVICE_DELAYED_AUTO_START_INFO extends ChangeServiceConfig2Info
	{
		public boolean	fDelayedAutostart;

		public void init(Pointer pointer)
		{
			useMemory(pointer);
			read();
		}
	}
	
	/*
	 * typedef struct _SC_ACTION {
  SC_ACTION_TYPE Type;
  DWORD          Delay;
} SC_ACTION, *LPSC_ACTION;
	 */
	public static class SC_ACTION extends Structure
	{
		  public SC_ACTION()
		  {
			  super();
			  setAutoWrite(true);
			  setAutoRead(false);
		  }
		  public int Type;
		  public int Delay;
		}
	
	// SC_ACTION types
	public static final int SC_ACTION_NONE = 0; //	No action.
	public static final int SC_ACTION_REBOOT = 2; // Reboot the computer.
	public static final int SC_ACTION_RESTART = 1; // Restart the service.
	public static final int SC_ACTION_RUN_COMMAND = 3; // Run a command.
	
	/*
	 * typedef struct _SERVICE_FAILURE_ACTIONS {
  DWORD     dwResetPeriod;
  LPTSTR    lpRebootMsg;
  LPTSTR    lpCommand;
  DWORD     cActions;
  SC_ACTION *lpsaActions;
} SERVICE_FAILURE_ACTIONS, *LPSERVICE_FAILURE_ACTIONS;
	 */
	public static class SERVICE_FAILURE_ACTIONS extends ChangeServiceConfig2Info
	{
		  public int     dwResetPeriod;
		  public String    lpRebootMsg;
		  public String    lpCommand;
		  public int     cActions;
		  public Pointer lpsaActions;

	}
	

	/*
	 * BOOL WINAPI EnumServicesStatusEx( __in SC_HANDLE hSCManager, __in
	 * SC_ENUM_TYPE InfoLevel, __in DWORD dwServiceType, __in DWORD
	 * dwServiceState, __out_opt LPBYTE lpServices, __in DWORD cbBufSize, __out
	 * LPDWORD pcbBytesNeeded, __out LPDWORD lpServicesReturned, __inout_opt
	 * LPDWORD lpResumeHandle, __in_opt LPCTSTR pszGroupName );
	 */
	public boolean EnumServicesStatusExW(Pointer hSCManager, int InfoLevel, int dwServiceType, int dwServiceState, Memory lpServices, int cbBufSize,
			IntByReference pcbBytesNeeded, IntByReference lpServicesReturned, IntByReference lpResumeHandle, String pszGroupName);

	public static final int	SERVICE_DISABLED			= 0x00000004;
	public static final int	SERVICE_INTERACTIVE_PROCESS	= 0x00000100;
	public static final int	SERVICE_AUTO_START			= 0x00000002;
	public static final int	SERVICE_BOOT_START			= 0x00000000;
	public static final int	SERVICE_DEMAND_START		= 0x00000003;
	public static final int	SERVICE_SYSTEM_START		= 0x00000001;

}