'ident simple coders

Imports Kai.Classes.Processes.Structures
Imports Kai.Classes.Services.Structures

Namespace Classes
    Friend Class NativeMethods
        ''' <summary>
        '''     Retrieves information about the specified process.
        ''' </summary>
        ''' <param name="processHandle">
        '''     A handle to the process for which information is to be retrieved.
        ''' </param>
        ''' <param name="processInformationClass">
        '''     The type of process information to be retrieved. This parameter can be one of the following values from the
        '''     PROCESSINFOCLASS enumeration.
        ''' </param>
        ''' <param name="processInformation">
        '''     A pointer to a buffer supplied by the calling application into which the function writes the requested information.
        '''     The size of the information written varies depending on the data type of the ProcessInformationClass parameter:
        ''' </param>
        ''' <param name="processInformationLength">
        '''     The size of the buffer pointed to by the ProcessInformation parameter, in bytes.
        ''' </param>
        ''' <param name="returnLength">
        '''     A pointer to a variable in which the function returns the size of the requested information. If the function was successful,
        '''     this is the size of the information written to the buffer pointed to by the ProcessInformation parameter,
        '''     but if the buffer was too small, this is the minimum size of buffer needed to receive the information successfully.
        ''' </param>
        ''' <returns>
        '''     The function returns an NTSTATUS success or error code.
        '''
        '''     The forms and significance of NTSTATUS error codes are listed in the Ntstatus.h header file available in the DDK, and are
        '''     described in the DDK documentation under Kernel-Mode Driver Architecture / Design Guide / Driver Programming Techniques /
        '''     Logging Errors.
        ''' </returns>
        <DllImport("ntdll.dll")>
        Friend Shared Function NtQueryInformationProcess(processHandle As IntPtr,
                                                           processInformationClass As Integer,
                                                          ByRef processInformation As ProcessBasicInformation,
                                                           processInformationLength As IntPtr,
                                                          ByRef returnLength As Integer) As IntPtr
        End Function

        ''' <summary>
        '''
        ''' </summary>
        ''' <returns></returns>
        <DllImport("Kernel32.dll", SetLastError:=True)>
        Friend Shared Function GetConsoleWindow() As IntPtr
        End Function

        ''' <summary>
        '''     The ConvertSidToStringSid function converts a security identifier (SID) to a string format suitable for
        '''     display, storage, or transmission.
        ''' </summary>
        ''' <param name="sid">
        '''     A pointer to the SID structure to be converted.
        ''' </param>
        ''' <param name="StringSid">
        '''     A pointer to a variable that receives a pointer to a null-terminated SID string.
        '''     To free the returned buffer, call the LocalFree function.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://msdn.microsoft.com/en-us/library/windows/desktop/aa376399(v=vs.85).aspx
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function ConvertSidToStringSid(sid As IntPtr,
                                                     ByRef stringSid As String) As IntPtr
        End Function

        ''' <summary>
        '''     Retrieves a pseudo handle for the current process.
        ''' </summary>
        ''' <returns>
        '''     The return value is a pseudo handle to the current process.
        ''' </returns>
        ''' <remarks>
        '''     A pseudo handle is a special constant, currently (HANDLE)-1, that is interpreted as the current process handle.
        '''     For compatibility with future operating systems, it is best to call GetCurrentProcess instead of hard-coding this constant value.
        '''     The calling process can use a pseudo handle to specify its own process whenever a process handle is required.
        '''     Pseudo handles are not inherited by child processes.
        '''
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess
        ''' </remarks>
        <DllImport("kernel32", SetLastError:=True)>
        Friend Shared Function GetCurrentProcess() As IntPtr
        End Function

        ''' <summary>
        '''     The GetTokenInformation function retrieves a specified type of information about an access token.
        '''     The calling process must have appropriate access rights to obtain the information.
        ''' </summary>
        ''' <param name="TokenHandle">
        '''     A handle to an access token from which information is retrieved. If TokenInformationClass specifies TokenSource,
        '''     the handle must have TOKEN_QUERY_SOURCE access. For all other TokenInformationClass values, the handle must have
        '''     TOKEN_QUERY access.
        ''' </param>
        ''' <param name="tokenInformationClass">
        '''     A pointer to a buffer the function fills with the requested information. The structure put into this buffer depends
        '''     upon the type of information specified by the TokenInformationClass parameter.
        ''' </param>
        ''' <param name="tokenInformation">
        '''     Specifies the size, in bytes, of the buffer pointed to by the TokenInformation parameter. If TokenInformation is NULL,
        '''     this parameter must be zero.
        ''' </param>
        ''' <param name="tokenInformationLength">
        '''     Specifies the size, in bytes, of the buffer pointed to by the TokenInformation parameter.
        '''     If TokenInformation is NULL, this parameter must be zero.
        ''' </param>
        ''' <param name="returnLength">
        '''     A pointer to a variable that receives the number of bytes needed for the buffer pointed to by the TokenInformation parameter.
        '''     If this value is larger than the value specified in the TokenInformationLength parameter, the function fails and
        '''     stores no data in the buffer.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/securitybaseapi/nf-securitybaseapi-gettokeninformation
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function GetTokenInformation(tokenHandle As IntPtr,
                                                    tokenInformationClass As TokenInformationClass.TokenInformation,
                                                    tokenInformation As IntPtr,
                                                    tokenInformationLength As IntPtr,
                                                   ByRef returnLength As IntPtr) As IntPtr
        End Function

        ''' <summary>
        '''     Retrieves the full name of the executable image for the specified process.
        ''' </summary>
        ''' <param name="hProcess">
        '''     A handle to the process. This handle must be created with the PROCESS_QUERY_INFORMATION or PROCESS_QUERY_LIMITED_INFORMATION access right.
        ''' </param>
        ''' <param name="dwFlags">
        '''      This parameter can be one of the following values.
        ''' </param>
        ''' <param name="lpExeName">
        '''         The path to the executable image. If the function succeeds, this string is null-terminated.
        ''' </param>
        ''' <param name="lpdwSize">
        '''     On input, specifies the size of the lpExeName buffer, in characters. On success, receives the number of characters
        '''     written to the buffer, not including the null-terminating character.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-queryfullprocessimagenamea
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function QueryFullProcessImageName(hProcess As IntPtr,
                                                          dwFlags As Integer,
                                                          lpExeName As StringBuilder,
                                                         ByRef lpdwSize As Integer) As Boolean
        End Function

        ''' <summary>
        '''     Terminates the specified process and all of its threads.
        ''' </summary>
        ''' <param name="hProcess">
        '''     A handle to the process to be terminated. The handle must have the PROCESS_TERMINATE access right.
        '''     For more information, see Process Security and Access Rights.
        '''     https://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
        ''' </param>
        ''' <param name="exitCode">
        '''     The exit code to be used by the process and threads terminated as a result of this call. Use the
        '''     GetExitCodeProcess function to retrieve a process's exit value. Use the GetExitCodeThread function
        '''     to retrieve a thread's exit value.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-terminateprocess
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True, EntryPoint:="TerminateProcess")>
        Friend Shared Function Terminate(<[In]()> hProcess As IntPtr,
                                         <[In]()> exitCode As Integer) As UInteger
        End Function

        ''' <summary>
        '''     The OpenProcessToken function opens the access token associated with a process.
        ''' </summary>
        ''' <param name="ProcessHandle">
        '''     A handle to the process whose access token is opened.
        '''     The process must have the PROCESS_QUERY_INFORMATION access permission.
        ''' </param>
        ''' <param name="DesiredAccess">
        '''     Specifies an access mask that specifies the requested types of access to the access token.
        '''     These requested access types are compared with the discretionary access control list (DACL) of the token to
        '''     determine which accesses are granted or denied.
        ''' </param>
        ''' <param name="TokenHandle">
        '''     A pointer to a handle that identifies the newly opened access token when the function returns.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-openprocesstoken
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function OpenProcessToken(processHandle As IntPtr,
                                                desiredAccess As Integer,
                                                ByRef tokenHandle As IntPtr) As IntPtr
        End Function

        ''' <summary>
        '''     Closes an open object handle.
        ''' </summary>
        ''' <param name="hObject">
        '''     A valid handle to an open object.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724211(v=vs.85).aspx
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function CloseHandle(<[In]()> hObject As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

        ''' <summary>
        '''     Opens an existing local process object.
        ''' </summary>
        ''' <param name="dwDesiredAccess">
        '''     The access to the process object. This access right is checked against the
        '''     security descriptor for the process. This parameter can be one or more of the process access rights.
        ''' </param>
        ''' <param name="bInheritHandle">
        '''     If this value is TRUE, processes created by this process will inherit the handle.
        '''     Otherwise, the processes do not inherit this handle.
        ''' </param>
        ''' <param name="dwProcessId">
        '''     The identifier of the local process to be opened.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is an open handle to the specified process.
        '''     If the function fails, the return value is NULL.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-openprocess
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function OpenProcess(<[In]()> dwDesiredAccess As ProcessSecurityAccessRights.SecurityFlags,
                                           <[In]()> bInheritHandle As Boolean,
                                           <[Out]()> dwProcessId As Integer) As IntPtr
        End Function

        ''' <summary>
        '''     Retrieves the termination status of the specified process.
        ''' </summary>
        ''' <param name="hProcess">
        '''     A handle to the process.
        ''' </param>
        ''' <param name="lpExitCode">
        '''     A pointer to a variable to receive the process termination status. For more information, see Remarks.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683189(v=vs.85).aspx
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function GetExitCodeProcess(<[In]()> hProcess As IntPtr,
                                                  <[Out]()> ByRef lpExitCode As UInt32) As Boolean
        End Function

        ''' <summary>
        '''     Sends a control code to a service.
        ''' </summary>
        ''' <param name="hService">
        '''     A handle to the service. This handle is returned by the OpenService or CreateService function.
        '''     The access rights required for this handle depend on the dwControl code requested.
        ''' </param>
        ''' <param name="dwControl">
        '''     This parameter can be one of the following control codes.
        ''' </param>
        ''' <param name="lpServiceStatus">
        '''     A pointer to a SERVICE_STATUS structure that receives the latest service status information.
        '''     The information returned reflects the most recent status that the service reported to the service control manager.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-controlservice
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function ControlService(hService As IntPtr,
                                              dwControl As ServiceControlManager.ServiceControlManagerType,
                                              ByRef lpServiceStatus As ServiceStatusProcess) As Boolean
        End Function

        ''' <summary>
        '''     Starts a service.
        ''' </summary>
        ''' <param name="hService">
        '''     A handle to the service. This handle is returned by the OpenService or CreateService function,
        '''     and it must have the SERVICE_START access right. For more information, see Service Security and Access Rights.
        ''' </param>
        ''' <param name="dwNumServiceArgs">
        '''     The number of strings in the lpServiceArgVectors array. If lpServiceArgVectors is NULL, this parameter can be zero.
        ''' </param>
        ''' <param name="lpServiceArgVectors">
        '''     The null-terminated strings to be passed to the ServiceMain function for the service as arguments. If there are no arguments, this parameter can be NULL.
        '''     Otherwise, the first argument (lpServiceArgVectors[0]) is the name of the service, followed by any additional arguments (lpServiceArgVectors[1] through
        '''     lpServiceArgVectors[dwNumServiceArgs-1]).
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-startservicea
        ''' </remarks>
        <DllImport("advapi32", SetLastError:=True)>
        Friend Shared Function StartService(hService As IntPtr,
                                            dwNumServiceArgs As Integer,
                                            lpServiceArgVectors() As String) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

        ''' <summary>
        '''     Marks the specified service for deletion from the service control manager database.
        ''' </summary>
        ''' <param name="hService">
        '''     A handle to the service. This handle is returned by the OpenService or CreateService function,
        '''     and it must have the DELETE access right. For more information, see Service Security and Access Rights.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-deleteservice
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function DeleteService(hService As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

        ''' <summary>
        '''     Opens an existing service.
        ''' </summary>
        ''' <param name="hScManager">
        '''     A handle to the service control manager database. The OpenSCManager function returns this handle. For more information, see Service Security
        '''     and Access Rights.
        ''' </param>
        ''' <param name="lpServiceName">
        '''     The name of the service to be opened. This is the name specified by the lpServiceName parameter of
        '''     the CreateService function when the service object was created, not the service display name that is shown by user interface
        '''     applications to identify the service.
        ''' </param>
        ''' <param name="dwDesiredAccess">
        '''     The access to the service.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is a handle to the service.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-openservicea
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True, CharSet:=CharSet.Auto)>
        Friend Shared Function OpenService(hScManager As IntPtr,
                                           lpServiceName As String,
                                           dwDesiredAccess As Int32) As IntPtr
        End Function

        ''' <summary>
        '''     Retrieves the calling thread's last-error code value. The last-error code is maintained on
        '''     a per-thread basis. Multiple threads do not overwrite each others last-error code.
        ''' </summary>
        ''' <returns>
        '''     The return value is the calling thread's last-error code.
        ''' </returns>
        ''' <remarks>
        '''     See https://msdn.microsoft.com/en-us/library/windows/desktop/ms679360(v=vs.85).aspx
        ''' </remarks>
        <DllImport("kernel32.dll")>
        Friend Shared Function GetLastError() As Integer
        End Function

        ''' <summary>
        '''     Closes a handle to a service control manager or service object.
        ''' </summary>
        ''' <param name="hScObject">
        '''     A handle to the service control manager object or the service object to close. Handles to service control manager objects are
        '''     returned by the OpenSCManager function, and handles to service objects are returned by either the OpenService or CreateService
        '''     function.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-closeservicehandle
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True)>
        Friend Shared Function CloseServiceHandle(hScObject As IntPtr) As Boolean
        End Function

        ''' <summary>
        '''     Establishes a connection to the service control manager on the specified computer and opens the specified service control manager database.
        ''' </summary>
        ''' <param name="lpMachineName">
        '''     The name of the target computer. If the pointer is NULL or points to an empty string, the function connects to the service control
        '''     manager on the local computer.
        ''' </param>
        ''' <param name="lpDatabaseName">
        '''     The name of the service control manager database. This parameter should be set to SERVICES_ACTIVE_DATABASE. If it is NULL, the
        '''     SERVICES_ACTIVE_DATABASE database is opened by default.
        ''' </param>
        ''' <param name="dwDesiredAccess">
        '''     The access to the service control manager. For a list of access rights, see Service Security and Access Rights.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is a handle to the specified service control manager database.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-openscmanagera
        ''' </remarks>
        <DllImport("advapi32.dll", CharSet:=CharSet.Auto, SetLastError:=True)>
        Friend Shared Function OpenSCManager(lpMachineName As String,
                                             lpDatabaseName As String,
                                             dwDesiredAccess As Int32) As IntPtr
        End Function

        ''' <summary>
        '''     Creates a service object and adds it to the specified service control manager database.
        ''' </summary>
        ''' <param name="hScManager">
        '''     A handle to the service control manager database. This handle is returned by the OpenSCManager function and must have the
        '''     SC_MANAGER_CREATE_SERVICE access right.
        ''' </param>
        ''' <param name="lpServiceName">
        '''     The name of the service to install. The maximum string length is 256 characters. The service control manager database preserves
        '''     the case of the characters, but service name comparisons are always case insensitive. Forward-slash (/) and backslash () are
        '''     not valid service name characters.
        ''' </param>
        ''' <param name="lpDisplayName">
        '''     The display name to be used by user interface programs to identify the service. This string has a maximum length of 256 characters.
        '''     The name is case-preserved in the service control manager. Display name comparisons are always case-insensitive.
        ''' </param>
        ''' <param name="dwDesiredAccess">
        '''     The access to the service. Before granting the requested access, the system checks the access token of the calling process. For a list
        '''     of values, see Service Security and Access Rights.
        ''' </param>
        ''' <param name="dwServiceType">
        '''     The service type. This parameter can be one of the following values.
        ''' </param>
        ''' <param name="dwStartType">
        '''     The service start options. This parameter can be one of the following values.
        ''' </param>
        ''' <param name="dwErrorControl">
        '''     The severity of the error, and action taken, if this service fails to start. This parameter can be one of the following values.
        ''' </param>
        ''' <param name="lpBinaryPathName">
        '''     The fully qualified path to the service binary file. If the path contains a space, it must be quoted so that it is correctly interpreted.
        ''' </param>
        ''' <param name="lpLoadOrderGroup">
        '''     The names of the load ordering group of which this service is a member. Specify NULL or an empty string if the service does not belong to a group.
        ''' </param>
        ''' <param name="lpdwTagId">
        '''     A pointer to a variable that receives a tag value that is unique in the group specified in the lpLoadOrderGroup parameter.
        '''     Specify NULL if you are not changing the existing tag.
        ''' </param>
        ''' <param name="lpDependencies">
        '''     A pointer to a double null-terminated array of null-separated names of services or load ordering groups that the system must start before
        '''     this service. Specify NULL or an empty string if the service has no dependencies.
        ''' </param>
        ''' <param name="lpServiceStartName">
        '''     The name of the account under which the service should run. If the service type is SERVICE_WIN32_OWN_PROCESS, use an account name in the
        '''     form DomainName UserName.
        ''' </param>
        ''' <param name="lpPassword">
        '''     The password to the account name specified by the lpServiceStartName parameter.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is a handle to the service.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-createservicea
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True, CharSet:=CharSet.Auto)>
        Friend Shared Function CreateService(hScManager As IntPtr, lpServiceName As String,
                                             lpDisplayName As String, dwDesiredAccess As Int32, dwServiceType As Int32,
                                             dwStartType As Integer, dwErrorControl As Int32, lpBinaryPathName As String,
                                             lpLoadOrderGroup As String, lpdwTagId As Int32, lpDependencies As String,
                                             lpServiceStartName As String, lpPassword As String) As IntPtr
        End Function

        ''' <summary>
        '''     Enumerates services in the specified service control manager database. The name and status of each service are provided,
        '''     along with additional data based on the specified information level.
        ''' </summary>
        ''' <param name="hScManager">
        '''     A handle to the service control manager database. This handle is returned by the OpenSCManager function, and must have the SC_MANAGER_ENUMERATE_SERVICE access right.
        '''     For more information, see Service Security and Access Rights.
        ''' </param>
        ''' <param name="infoLevel">
        '''     The service attributes that are to be returned. Use SC_ENUM_PROCESS_INFO to retrieve the name and service status information for
        '''     each service in the database.
        ''' </param>
        ''' <param name="dwServiceType">
        '''     The type of services to be enumerated. This parameter can be one or more of the following values.
        ''' </param>
        ''' <param name="dwServiceState">
        '''     The state of the services to be enumerated. This parameter can be one of the following values.
        ''' </param>
        ''' <param name="lpServices">
        '''     A pointer to the buffer that receives the status information. The format of this data depends on the value of the InfoLevel parameter.
        ''' </param>
        ''' <param name="cbBufSize">
        '''     The size of the buffer pointed to by the lpServices parameter, in bytes.
        ''' </param>
        ''' <param name="pcbBytesNeeded">
        '''     A pointer to a variable that receives the number of bytes needed to return the remaining service entries, if the buffer is too small.
        ''' </param>
        ''' <param name="lpServicesReturned">
        '''     A pointer to a variable that receives the number of service entries returned.
        ''' </param>
        ''' <param name="lpResumeHandle">
        '''     A pointer to a variable that, on input, specifies the starting point of enumeration. You must set this value to zero the first time the
        '''     EnumServicesStatusEx function is called.
        ''' </param>
        ''' <param name="pszGroupName">
        '''     The load-order group name. If this parameter is a string, the only services enumerated are those that belong to the group that has the name
        '''     specified by the string.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''  See https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-enumservicesstatusexa
        ''' </remarks>
        <DllImport("advapi32.dll", SetLastError:=True, CharSet:=CharSet.Auto)>
        Friend Shared Function EnumServicesStatusEx(hScManager As IntPtr, infoLevel As Integer,
                                                      dwServiceType As Integer, dwServiceState As Integer,
                                                      lpServices As IntPtr, cbBufSize As UInt32,
                                                     ByRef pcbBytesNeeded As UInteger, ByRef lpServicesReturned As UInteger,
                                                     ByRef lpResumeHandle As UInteger, pszGroupName As String) As IntPtr
        End Function

        ''' <summary>
        '''     Generates simple tones on the speaker. The function is synchronous; it performs an alertable wait and does not return control to its
        '''     caller until the sound finishes.
        ''' </summary>
        ''' <param name="dwFreq">
        '''     The frequency of the sound, in hertz. This parameter must be in the range 37 through 32,767 (0x25 through 0x7FFF).
        ''' </param>
        ''' <param name="dwDuration">
        '''     The duration of the sound, in milliseconds.
        ''' </param>
        ''' <returns>
        '''     If the function succeeds, the return value is nonzero.
        ''' </returns>
        ''' <remarks>
        '''     See
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function Beep(dwFreq As UInteger, dwDuration As UInteger) As Boolean
        End Function

        ''' <summary>
        '''     Frees the specified local memory object and invalidates its handle.
        ''' </summary>
        ''' <param name="hMem">
        '''     A handle to the local memory object. This handle is returned by either the LocalAlloc or LocalReAlloc function.
        '''     It is not safe to free memory allocated with GlobalAlloc.
        ''' </param>
        ''' <returns>
        '''     If the function fails, the return value is equal to a handle to the local memory object. To get extended error information, call GetLastError.
        ''' </returns>
        ''' <remarks>
        '''     See https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-localfree
        ''' </remarks>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function LocalFree(ByVal hMem As IntPtr) As IntPtr
        End Function

        ''' <summary>
        '''
        ''' </summary>
        ''' <param name="dwFlags"></param>
        ''' <param name="lpSource"></param>
        ''' <param name="dwMessageId"></param>
        ''' <param name="dwLanguageId"></param>
        ''' <param name="lpBuffer"></param>
        ''' <param name="nSize"></param>
        ''' <param name="Arguments"></param>
        ''' <returns></returns>
        <DllImport("kernel32.dll", SetLastError:=True)>
        Friend Shared Function FormatMessage(dwFlags As FormatMessageFlags,
                                             lpSource As IntPtr,
                                             dwMessageId As UInteger,
                                             dwLanguageId As UInteger,
                                             ByRef lpBuffer As IntPtr,
                                             nSize As UInteger,
                                             Arguments As IntPtr) As IntPtr
        End Function
    End Class

End Namespace