A2OS/source/Windows.ADVAPI32.Mod

(* Copyright (c) 1994 - 2000 Emil J. Zeller *)

MODULE ADVAPI32;  (** non-portable / source: Windows.ADVAPI32.Mod *)	(* ejz *)
IMPORT SYSTEM, Kernel32, Modules, KernelLog; 		(* ALEX *)

	(** This module defines all the Win32 ADVAPI32 APIs used by Oberon. *)

CONST
	(** HKEYs *)
	HKEYClassesRoot* = LONGINT(080000000H);  HKEYCurrentUser* = LONGINT(080000001H);

	(** value type *)
	RegNone* = 0;  RegSZ* = 01H;

	(** sam *)
	KeyQueryValue* = 0;  KeySetValue* = 1;  KeyCreateSubKey* = 2;  KeyEnumerateSubKeys* = 3;  KeyAllAccess* = {19, 18, 17, 16, 5, 4 ,3, 2, 1, 0};

	(** options *)
	RegOptionNonVolatile* = {};

	(** error codes *)
	Success* = 0H;  ErrorMoreData* = 234;

	(* ALEX *)
	SC_MANAGER_CREATE_SERVICE*  = 0002H;
	SC_MANAGER_ALL_ACCESS*  = 000F003FH;
	SERVICE_ALL_ACCESS* = 000F01FFH;

	SERVICE_WIN32_OWN_PROCESS* = 00000010H;
	SERVICE_AUTO_START* =  00000002H;
	SERVICE_ERROR_NORMAL* = 00000001H;


	SERVICE_WIN32* = 30H;
	SERVICE_START_PENDING *= 00000002H;
	SERVICE_ACCEPT_STOP* = 00000001H;
	SERVICE_ACCEPT_SHUTDOWN* = 00000004H;

	SERVICE_RUNNING* = 00000004H;
	SERVICE_CONTROL_STOP* = 00000001H;
	SERVICE_CONTROL_SHUTDOWN* = 00000005H;
	SERVICE_STOPPED*	= 00000001H;


TYPE
	(** Handle to a registry key. *)
	HKEY* = ADDRESS;

	(* ALEX *)
    	LPSTR* = ADDRESS;
    	LPCSTR* = ARRAY  OF CHAR;
    	HWND* = Kernel32.HANDLE;
	HINSTANCE* = Kernel32.HINSTANCE;
	INT* =  LONGINT;
	LPCTSTR* = LPCSTR;
	SC_HANDLE* = Kernel32.HANDLE;
	DWORD* = LONGINT;
	LPDWORD* = ADDRESS;
	BOOL* = Kernel32.BOOL;
	LPSERVICE_MAIN_FUNCTIONA = PROCEDURE {WINAPI} (dwNumServicesArgs: DWORD; VAR lpServiceArgVectors: ARRAY  OF CHAR): BOOL;
	LPSERVICE_MAIN_FUNCTION* = LPSERVICE_MAIN_FUNCTIONA;
	SERVICE_TABLE_ENTRYA = RECORD
		lpServiceName*: LPSTR;
		lpServiceProc*: LPSERVICE_MAIN_FUNCTIONA;
	END;
	SERVICE_TABLE_ENTRY* = SERVICE_TABLE_ENTRYA;
	LPHANDLER_FUNCTION* = PROCEDURE {WINAPI} (dwControl: DWORD);
	SERVICE_STATUS_HANDLE* = Kernel32.HANDLE;
	SERVICE_STATUS* = RECORD
		dwServiceType*,
		dwCurrentState*,

		dwControlsAccepted*,
		dwWin32ExitCode*,
		dwServiceSpecificExitCode*,
		dwCheckPoint*,
		dwWaitHint*: DWORD;
	END;




VAR
	(** The GetUserName function retrieves the user name of the current thread. *)
	GetUserName-: PROCEDURE {WINAPI} (VAR lpBuffer: ARRAY   OF CHAR;  VAR nSize: LONGINT): Kernel32.BOOL;
	(** The RegCloseKey function releases a handle to the specified key. *)
	RegCloseKey-: PROCEDURE {WINAPI} (hKey: HKEY): LONGINT;
	(** The RegCreateKeyEx function creates the specified key. *)
	RegCreateKeyEx-: PROCEDURE {WINAPI} (hKey: HKEY;  lpSubKey: ARRAY   OF CHAR;  Reserved: LONGINT;  lpClass: ARRAY   OF CHAR;  dwOptions, samDesired: SET;  lpSecurityAttributes: ANY;  VAR phkResult: HKEY;  VAR lpdwDisposition: LONGINT): LONGINT;
	(** The RegDeleteKey function deleted a subkey. *)
	RegDeleteKey-: PROCEDURE {WINAPI} (hKey: HKEY;  lpSubKey: ARRAY   OF CHAR): LONGINT;
	(** The RegDeleteValue function removes a named value from the specified registry key. *)
	RegDeleteValue-: PROCEDURE {WINAPI} (hKey: HKEY;  lpValueName: ARRAY   OF CHAR): LONGINT;
	(** The RegEnumKeyEx function enumerates subkeys of the specified open registry key. *)
	RegEnumKeyEx-: PROCEDURE {WINAPI} (hKey: HKEY;  dwIndex: LONGINT;  VAR lpName: ARRAY   OF CHAR;  VAR lpcbName: LONGINT;  VAR lpReserved: LONGINT;  VAR lpClass: ARRAY   OF CHAR;  VAR lpcbClass: LONGINT;  VAR lpftLastWriteTime: Kernel32.FileTime): LONGINT;
	(** The RegEnumValue function enumerates the values for the specified open registry key. *)
	RegEnumValue-: PROCEDURE {WINAPI} (hKey: HKEY;  dwIndex: LONGINT;  VAR lpValueName: ARRAY   OF CHAR;  VAR lpcbValueName: LONGINT;  VAR lpReserved, type: LONGINT;  VAR lpData: ARRAY   OF SYSTEM.BYTE;  VAR lpcbData: LONGINT): LONGINT;
	(** The RegOpenKeyEx function opens the specified key. *)
	RegOpenKeyEx-: PROCEDURE {WINAPI} (hKey: HKEY;  lpSubKey: ARRAY   OF CHAR;  ulOptions: LONGINT;  samDesired: SET;  VAR phkResult: HKEY): LONGINT;
	(** The RegQueryValueEx function retrieves the type and data for a specified value name associated with an
			open registry key. *)
	RegQueryValueEx-: PROCEDURE {WINAPI} (hKey: HKEY;  lpValueName: ARRAY   OF CHAR;  VAR lpReserved, lpType: LONGINT;  VAR lpData: ARRAY   OF SYSTEM.BYTE;  VAR lpcbData: LONGINT): LONGINT;
	(** The RegSetValueEx function sets the data and type of a specified value under a registry key. *)
	RegSetValueEx-: PROCEDURE {WINAPI} (hKey: HKEY;  lpValueName: ARRAY   OF CHAR;  Reserved, dwType: LONGINT;  VAR lpData: ARRAY   OF SYSTEM.BYTE;  cbData: LONGINT): LONGINT;
	(** The GetFileVersionInfo function returns version information about a specified file. *)
	GetFileVersionInfo-: PROCEDURE {WINAPI} (lpstrFilename: ARRAY   OF CHAR;  dwHandle, dwLen: LONGINT;  VAR lpDate: ARRAY   OF SYSTEM.BYTE): Kernel32.BOOL;
	(** The GetFileVersionInfoSize function determines whether the operating system can obtain version information
			about a specified file. *)
	GetFileVersionInfoSize-: PROCEDURE {WINAPI} (lpstrFilename: ARRAY   OF CHAR;  VAR lpdwHandle: LONGINT): LONGINT;
	(** The VerQueryValue function returns selected version information from the specified version-information resource. *)
	VerQueryValue-: PROCEDURE {WINAPI} (pBlock: ARRAY   OF SYSTEM.BYTE;  lpSubBlock: ARRAY   OF CHAR;  VAR lplpBuffer: ADDRESS;  VAR puLen: LONGINT): Kernel32.BOOL;




	(* ALEX BEGIN *)
	CloseServiceHandle-: PROCEDURE {WINAPI} (hSCObject: SC_HANDLE): BOOL;

	CreateService-: PROCEDURE {WINAPI} (hSCManager: SC_HANDLE; VAR lpServiceName, lpDisplayName: LPCTSTR;
					dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
					VAR lpBinaryPathName, lpLoadOrderGroup: LPCTSTR; lpdwTagId: LPDWORD;
					VAR lpDependencies, lpServiceStartName, lpPassword: LPCTSTR): SC_HANDLE;


	DeleteService-: PROCEDURE {WINAPI} (hService: SC_HANDLE): BOOL;

	OpenSCManager-: PROCEDURE {WINAPI} (VAR lpMachineName, lpDatabaseName: LPCTSTR; dwDesiredAccess: DWORD): SC_HANDLE;
	OpenService-: PROCEDURE {WINAPI} (hSCManager: SC_HANDLE; VAR lpServiceName: LPCTSTR; dwDesiredAccess: DWORD): SC_HANDLE;



	RegisterServiceCtrlHandler-: PROCEDURE {WINAPI} (VAR lpServiceName: ARRAY  OF CHAR; lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE;
	SetServiceStatus-: PROCEDURE {WINAPI} (hServiceStatus: SERVICE_STATUS_HANDLE; VAR lpServiceStatus: SERVICE_STATUS): BOOL;

	StartService-: PROCEDURE {WINAPI} (hService: SC_HANDLE; dwNumServiceArgs: DWORD; VAR lpServiceArgVectors: LPCTSTR): BOOL;
	StartServiceCtrlDispatcher-: PROCEDURE {WINAPI} (VAR lpServiceTable: ARRAY  OF SYSTEM.BYTE): BOOL;

	advapi32: Kernel32.HMODULE;


	PROCEDURE InstallService*(srvName, serviceDesc, exeFile: ARRAY OF CHAR): BOOLEAN;
	VAR newService, scm: SC_HANDLE; err: LONGINT;
	BEGIN
		scm := OpenSCManager(NIL,NIL,SC_MANAGER_CREATE_SERVICE);
		IF scm = Kernel32.NULL THEN
			err := OutError("Advapi32.OpenSCManager");
			RETURN FALSE;
		END;
		newService := CreateService(scm, srvName,
			serviceDesc,
			SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_AUTO_START,
			SERVICE_ERROR_NORMAL,
			exeFile,
			NIL,0,NIL,NIL,NIL);
		IF newService = Kernel32.NULL THEN
			err := OutError("Advapi32.CreateService");
			CloseServiceHandle(scm);
			RETURN FALSE;
		END;
		CloseServiceHandle(newService);
		CloseServiceHandle(scm);
		KernelLog.Enter;
		KernelLog.String('Service "'); KernelLog.String(srvName); KernelLog.String('" was installed!'); KernelLog.Ln;
		KernelLog.Exit;
		RETURN TRUE;
	END InstallService;

	PROCEDURE UninstallService*(srvName: ARRAY OF CHAR): BOOLEAN;
	VAR scm, service:  SC_HANDLE;
		ret: BOOL; err: LONGINT;
	BEGIN
		scm := OpenSCManager(NIL, NIL, SC_MANAGER_ALL_ACCESS);
		IF scm = Kernel32.NULL THEN
			err := OutError("Advapi32.OpenSCManager");
			RETURN FALSE
		ELSE
			service := OpenService( scm, srvName, SERVICE_ALL_ACCESS);
			IF service = Kernel32.NULL THEN
				err := OutError("Advapi32.OpenService");
				RETURN FALSE
			ELSE
				ret := DeleteService(service);
				IF ret = Kernel32.NULL THEN
					err := OutError("Advapi32.DeleteService");
					RETURN FALSE
				ELSE
					KernelLog.Enter;
					KernelLog.String('Service "'); KernelLog.String(srvName); KernelLog.String('" was removed!'); KernelLog.Ln;
					KernelLog.Exit;
				END;
				CloseServiceHandle(service);
			END;
			CloseServiceHandle(scm);
			RETURN TRUE
		END
	END UninstallService;


	PROCEDURE OutError*(funcName: ARRAY OF CHAR): LONGINT;
	VAR err: LONGINT;
	BEGIN
		err := Kernel32.GetLastError();
		KernelLog.Enter;
		KernelLog.String(funcName); KernelLog.String(" failed, error code = "); KernelLog.Int(err, 10);
		KernelLog.Ln; KernelLog.Exit;
		RETURN err
	END OutError;


	PROCEDURE TermMod;
	BEGIN
		IF advapi32 # Kernel32.NULL THEN
			Kernel32.FreeLibrary(advapi32); advapi32 := Kernel32.NULL
		END
	END TermMod;

	(* ALEX END *)




PROCEDURE GetProcAddress(hModule: ADDRESS; VAR adr: ADDRESS; procName: ARRAY OF CHAR);
BEGIN
	Kernel32.GetProcAddress(hModule,procName,adr);
END GetProcAddress;


PROCEDURE Init;
VAR
 mod: Kernel32.HMODULE;str: ARRAY 32 OF CHAR;
BEGIN
	str := "ADVAPI32.DLL";
	mod := Kernel32.LoadLibrary(str);
	advapi32 := mod;
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,GetUserName  ),"GetUserNameA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegCloseKey  ),"RegCloseKey");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegCreateKeyEx  ),"RegCreateKeyExA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegDeleteKey  ),"RegDeleteKeyA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegDeleteValue  ),"RegDeleteValueA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegEnumKeyEx  ),"RegEnumKeyExA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegEnumValue  ),"RegEnumValueA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegOpenKeyEx  ),"RegOpenKeyExA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegQueryValueEx  ),"RegQueryValueExA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,RegSetValueEx  ),"RegSetValueExA");
str := "Version";
mod := Kernel32.LoadLibrary(str);
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,GetFileVersionInfo ),"GetFileVersionInfoA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,GetFileVersionInfoSize),"GetFileVersionInfoSizeA");
GetProcAddress(mod,SYSTEM.VAL(ADDRESS,VerQueryValue),"VerQueryValueA");

		(* ALEX *)
		Kernel32.GetProcAddress(advapi32, "CloseServiceHandle", SYSTEM.VAL(ADDRESS, CloseServiceHandle));
		Kernel32.GetProcAddress(advapi32, "CreateServiceA", SYSTEM.VAL(ADDRESS, CreateService));
		Kernel32.GetProcAddress(advapi32, "DeleteService", SYSTEM.VAL(ADDRESS, DeleteService));
		Kernel32.GetProcAddress(advapi32, "OpenSCManagerA", SYSTEM.VAL(ADDRESS, OpenSCManager));
		Kernel32.GetProcAddress(advapi32, "OpenServiceA", SYSTEM.VAL(ADDRESS, OpenService));

		Kernel32.GetProcAddress(advapi32, "RegisterServiceCtrlHandlerA", SYSTEM.VAL(ADDRESS, RegisterServiceCtrlHandler));
		Kernel32.GetProcAddress(advapi32, "SetServiceStatusA", SYSTEM.VAL(ADDRESS, SetServiceStatus));

		Kernel32.GetProcAddress(advapi32, "StartServiceA", SYSTEM.VAL(ADDRESS, StartService));
		Kernel32.GetProcAddress(advapi32, "StartServiceCtrlDispatcherA", SYSTEM.VAL(ADDRESS, StartServiceCtrlDispatcher));
		Modules.InstallTermHandler(TermMod)

END Init;

BEGIN
	Init;
END ADVAPI32.