filter.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS kernel-mode tests
 * LICENSE:         GPLv2+ - See COPYING in the top level directory
 * PURPOSE:         File system filter implementation of the original service.c file
 * PROGRAMMER:      Thomas Faber <thomas.faber@reactos.org>
 *                  Ged Murphy <gedmurphy@reactos.org>
 */
 
//#include <fltuser.h>
#include <kmt_test.h>
#include "kmtest.h"
 
#include <assert.h>
 
#define SERVICE_ACCESS (SERVICE_START | SERVICE_STOP | DELETE)
 
 
 
DWORD
KmtFltLoad(
    _In_z_ PCWSTR ServiceName)
{
    HRESULT hResult;
    DWORD Error = ERROR_SUCCESS;
 
    assert(ServiceName);
 
    hResult = FilterLoad(ServiceName);
    Error = SCODE_CODE(hResult);
 
    return Error;
}
#if 0
DWORD
KmtFltCreateAndStartService(
    _In_z_ PCWSTR ServiceName,
    _In_z_ PCWSTR ServicePath,
    _In_z_ PCWSTR DisplayName OPTIONAL,
    _Out_ SC_HANDLE *ServiceHandle,
    _In_ BOOLEAN RestartIfRunning)
{
    DWORD Error = ERROR_SUCCESS;
 
    assert(ServiceHandle);
 
    Error = KmtFltCreateService(ServiceName, ServicePath, DisplayName, ServiceHandle);
 
    if (Error == ERROR_SERVICE_EXISTS)
        *ServiceHandle = OpenService(ScmHandle, ServiceName, SERVICE_ACCESS);
 
    if (Error && Error != ERROR_SERVICE_EXISTS)
        goto cleanup;
 
    Error = KmtFltLoad(ServiceName);
 
    if (Error != ERROR_SERVICE_ALREADY_RUNNING)
        goto cleanup;
 
    Error = ERROR_SUCCESS;
 
    if (!RestartIfRunning)
        goto cleanup;
 
    Error = KmtFltUnload(ServiceName);
    if (Error)
        goto cleanup;
 
    Error = KmtFltLoad(ServiceName);
    if (Error)
        goto cleanup;
 
cleanup:
    assert(Error);
    return Error;
}
#endif
 
DWORD
KmtFltConnect(
    _In_z_ PCWSTR ServiceName,
    _Out_ HANDLE *hPort)
{
    HRESULT hResult;
    DWORD Error;
 
    assert(ServiceName);
    assert(hPort);
 
    hResult = FilterConnectCommunicationPort(ServiceName,
                                             0,
                                             NULL,
                                             0,
                                             NULL,
                                             hPort);
    Error = SCODE_CODE(hResult);
 
    return Error;
}
 
DWORD
KmtFltDisconnect(
    _In_ HANDLE hPort)
{
    DWORD Error = ERROR_SUCCESS;
 
    assert(hPort);
 
    if (!CloseHandle(hPort))
    {
        Error = GetLastError();
    }
 
    return Error;
}
 
DWORD
KmtFltSendMessage(
    _In_ HANDLE hPort,
    _In_reads_bytes_(dwInBufferSize) LPVOID InBuffer,
    _In_ DWORD InBufferSize,
    _Out_writes_bytes_to_opt_(dutBufferSize, *BytesReturned) LPVOID OutBuffer,
    _In_ DWORD OutBufferSize,
    _Out_opt_ LPDWORD BytesReturned)
{
    DWORD BytesRet;
    HRESULT hResult;
    DWORD Error;
 
    assert(hPort);
    assert(InBuffer);
    assert(InBufferSize);
 
    if (BytesReturned) *BytesReturned = 0;
 
    hResult = FilterSendMessage(hPort,
                                InBuffer,
                                InBufferSize,
                                OutBuffer,
                                OutBufferSize,
                                &BytesRet);
 
    Error = SCODE_CODE(hResult);
    if (Error == ERROR_SUCCESS)
    {
        if (BytesRet)
        {
            *BytesReturned = BytesRet;
        }
    }
 
    return Error;
}
 
DWORD
KmtFltGetMessage(
    _In_ HANDLE hPort,
    _Out_writes_bytes_(MessageBufferSize) PFILTER_MESSAGE_HEADER MessageBuffer,
    _In_ DWORD MessageBufferSize,
    _In_opt_ LPOVERLAPPED Overlapped)
{
    HRESULT hResult;
    DWORD Error;
 
    assert(hPort);
    assert(MessageBuffer);
 
    hResult = FilterGetMessage(hPort,
                               MessageBuffer,
                               MessageBufferSize,
                               Overlapped);
    Error = SCODE_CODE(hResult);
    return Error;
}
 
DWORD
KmtFltReplyMessage(
    _In_ HANDLE hPort,
    _In_reads_bytes_(ReplyBufferSize) PFILTER_REPLY_HEADER ReplyBuffer,
    _In_ DWORD ReplyBufferSize)
{
    HRESULT hResult;
    DWORD Error;
 
    hResult = FilterReplyMessage(hPort,
                                 ReplyBuffer,
                                 ReplyBufferSize);
    Error = SCODE_CODE(hResult);
    return Error;
}
 
DWORD
KmtFltGetMessageResult(
    _In_ HANDLE hPort,
    _In_ LPOVERLAPPED Overlapped,
    _Out_ LPDWORD BytesTransferred)
{
    BOOL Success;
    DWORD Error = ERROR_SUCCESS;
 
    *BytesTransferred = 0;
 
    Success = GetOverlappedResult(hPort, Overlapped, BytesTransferred, TRUE);
    if (!Success)
    {
        Error = GetLastError();
    }
 
    return Error;
}
 
DWORD
KmtFltUnload(
    _In_z_ PCWSTR ServiceName)
{
    HRESULT hResult;
    DWORD Error = ERROR_SUCCESS;
 
    assert(ServiceName);
 
    hResult = FilterUnload(ServiceName);
    Error = SCODE_CODE(hResult);
 
    return Error;
}