msxfs.dll函数加载代码

msxfs.dll函数加载代码

#include "stdafx.h"
#include "WSXFSLoader.h"

NS_AWP_DEVICE_WOSA_BEGIN

WSXFSLoader::WSXFSLoader()
{
    hDllLib = LoadLibrary(_T("msxfs.dll"));
    if (hDllLib == nullptr)
        return;

    WCHAR lpDllPath[MAX_PATH];
    GetModuleFileName(hDllLib, lpDllPath, sizeof(lpDllPath));

    // 获取进程文件路径
    HINSTANCE hModule = GetModuleHandle(NULL);
    WCHAR lpszPath[MAX_PATH];
    DWORD dwPathLength = GetModuleFileName(hModule, lpszPath, sizeof(lpszPath));
    //截取目录
    *(wcsrchr(lpszPath, '\\') + 1) = 0;
    wcscat_s(lpszPath, _T("Temp\\"));

    //WFM
    m_fpWFMAllocateBuffer = (WFMAllocateBufferProc)GetProcAddress(hDllLib, "WFMAllocateBuffer");
    m_fpWFMAllocateMore = (WFMAllocateMoreProc)GetProcAddress(hDllLib, "WFMAllocateMore");
    m_fpWFMFreeBuffer = (WFMFreeBufferProc)GetProcAddress(hDllLib, "WFMFreeBuffer");
    m_fpWFMGetTraceLevel = (WFMGetTraceLevelProc)GetProcAddress(hDllLib, "WFMGetTraceLevel");
    m_fpWFMKillTimer = (WFMKillTimerProc)GetProcAddress(hDllLib, "WFMKillTimer");
    m_fpWFMOutputTraceData = (WFMOutputTraceDataProc)GetProcAddress(hDllLib, "WFMOutputTraceData");
    m_fpWFMReleaseDLL = (WFMReleaseDLLProc)GetProcAddress(hDllLib, "WFMReleaseDLL");
    m_fpWFMSetTimer = (WFMSetTimerProc)GetProcAddress(hDllLib, "WFMSetTimer");
    m_fpWFMSetTraceLevel = (WFMSetTraceLevelProc)GetProcAddress(hDllLib, "WFMSetTraceLevel");
    //WFS
    m_fpWFSAsyncClose = (WFSAsyncCloseProc)GetProcAddress(hDllLib, "WFSAsyncClose");
    m_fpWFSAsyncDeregister = (WFSAsyncDeregisterProc)GetProcAddress(hDllLib, "WFSAsyncDeregister");
    m_fpWFSAsyncExecute = (WFSAsyncExecuteProc)GetProcAddress(hDllLib, "WFSAsyncExecute");
    m_fpWFSAsyncGetInfo = (WFSAsyncGetInfoProc)GetProcAddress(hDllLib, "WFSAsyncGetInfo");
    m_fpWFSAsyncLock = (WFSAsyncLockProc)GetProcAddress(hDllLib, "WFSAsyncLock");
    m_fpWFSAsyncOpen = (WFSAsyncOpenProc)GetProcAddress(hDllLib, "WFSAsyncOpen");
    m_fpWFSAsyncRegister = (WFSAsyncRegisterProc)GetProcAddress(hDllLib, "WFSAsyncRegister");
    m_fpWFSAsyncUnlock = (WFSAsyncUnlockProc)GetProcAddress(hDllLib, "WFSAsyncUnlock");
    m_fpWFSCancelAsyncRequest = (WFSCancelAsyncRequestProc)GetProcAddress(hDllLib, "WFSCancelAsyncRequest");
    m_fpWFSCancelBlockingCall = (WFSCancelBlockingCallProc)GetProcAddress(hDllLib, "WFSCancelBlockingCall");
    m_fpWFSCleanUp = (WFSCleanUpProc)GetProcAddress(hDllLib, "WFSCleanUp");
    m_fpWFSClose = (WFSCloseProc)GetProcAddress(hDllLib, "WFSClose");
    m_fpWFSDeregister = (WFSDeregisterProc)GetProcAddress(hDllLib, "WFSDeregister");
    m_fpWFSDestroyAppHandle = (WFSDestroyAppHandleProc)GetProcAddress(hDllLib, "WFSDestroyAppHandle");
    m_fpWFSFreeResult = (WFSFreeResultProc)GetProcAddress(hDllLib, "WFSFreeResult");
    m_fpWFSGetInfo = (WFSGetInfoProc)GetProcAddress(hDllLib, "WFSGetInfo");
    m_fpWFSIsBlocking = (WFSIsBlockingProc)GetProcAddress(hDllLib, "WFSIsBlocking");
    m_fpWFSLock = (WFSLockProc)GetProcAddress(hDllLib, "WFSLock");
    m_fpWFSOpen = (WFSOpenProc)GetProcAddress(hDllLib, "WFSOpen");
    m_fpWFSRegister = (WFSRegisterProc)GetProcAddress(hDllLib, "WFSRegister");
    m_fpWFSSetBlockingHook = (WFSSetBlockingHookProc)GetProcAddress(hDllLib, "WFSSetBlockingHook");
    m_fpWFSStartUp = (WFSStartUpProc)GetProcAddress(hDllLib, "WFSStartUp");
    m_fpWFSUnhookBlockingHook = (WFSUnhookBlockingHookProc)GetProcAddress(hDllLib, "WFSUnhookBlockingHook");
    m_fpWFSUnlock = (WFSUnlockProc)GetProcAddress(hDllLib, "WFSUnlock");

    //DWORD dwVersion = (*fpWFSStartUp)();
    //DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
    //DWORD dwWindowsMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
    //const int nBufSize = 512;
    //TCHAR chBuf[nBufSize];
    //ZeroMemory(chBuf, nBufSize);
    //OutputDebugString(chBuf);
    //FreeLibrary(hDllLib);
    LPWFSVERSION lpVersion = nullptr;
    auto result = WFMAllocateBuffer(sizeof(WFSVERSION), ulMemFlags, (void**)&lpVersion);
    DWORD dwVersion = 0x00031403;
    auto startupResult = this->WFSStartUp(dwVersion, lpVersion);
}

WSXFSLoader::~WSXFSLoader()
{
    if (hDllLib != nullptr)
    {
        FreeLibrary(hDllLib);
    }
}

HRESULT WSXFSLoader::WFMAllocateBuffer(ULONG ulSize, ULONG ulFlags, LPVOID * lppvData)
{
    return (*m_fpWFMAllocateBuffer)(ulSize, ulFlags, lppvData);
}

HRESULT WSXFSLoader::WFMAllocateMore(ULONG ulSize, LPVOID lpvOriginal, LPVOID * lppvData)
{
    return (*m_fpWFMAllocateMore)(ulSize, lpvOriginal, lppvData);
}

HRESULT WSXFSLoader::WFMFreeBuffer(LPVOID lpvData)
{
    return (*m_fpWFMFreeBuffer)(lpvData);
}

HRESULT WSXFSLoader::WFMGetTraceLevel(HSERVICE hService, LPDWORD lpdwTraceLevel)
{
    return (*m_fpWFMGetTraceLevel)(hService, lpdwTraceLevel);
}

HRESULT WSXFSLoader::WFMKillTimer(WORD wTimerID)
{
    return (*m_fpWFMKillTimer)(wTimerID);
}

HRESULT WSXFSLoader::WFMOutputTraceData(LPSTR lpszData)
{
    return (*m_fpWFMOutputTraceData)(lpszData);
}

HRESULT WSXFSLoader::WFMReleaseDLL(HPROVIDER hProvider)
{
    return (*m_fpWFMReleaseDLL)(hProvider);
}

HRESULT WSXFSLoader::WFMSetTimer(HWND hWnd, LPVOID lpContext, DWORD dwTimeVal, LPWORD lpwTimerID)
{
    return (*m_fpWFMSetTimer)(hWnd, lpContext, dwTimeVal, lpwTimerID);
}

HRESULT WSXFSLoader::WFMSetTraceLevel(HSERVICE hService, DWORD dwTraceLevel)
{
    return (*m_fpWFMSetTraceLevel)(hService, dwTraceLevel);
}

HRESULT WSXFSLoader::WFSAsyncClose(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncClose)(hService, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncDeregister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncDeregister)(hService, dwEventClass, hWndReg, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncExecute(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncExecute)(hService, dwCommand, lpCmdData, dwTimeOut, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncGetInfo(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncGetInfo)(hService, dwCategory, lpQueryDetails, dwTimeOut, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncLock(HSERVICE hService, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncLock)(hService, dwTimeOut, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncOpen(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, LPHSERVICE lphService, HWND hWnd, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncOpen)(lpszLogicalName, hApp, lpszAppID, dwTraceLevel, dwTimeOut, lphService, hWnd, dwSrvcVersionsRequired, lpSrvcVersion, lpSPIVersion, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncRegister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncRegister)(hService, dwEventClass, hWndReg, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSAsyncUnlock(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID)
{
    return (*m_fpWFSAsyncUnlock)(hService, hWnd, lpRequestID);
}

HRESULT WSXFSLoader::WFSCancelAsyncRequest(HSERVICE hService, REQUESTID lpRequestID)
{
    return (*m_fpWFSCancelAsyncRequest)(hService, lpRequestID);
}

HRESULT WSXFSLoader::WFSCancelBlockingCall(DWORD dwThreadID)
{
    return (*m_fpWFSCancelBlockingCall)(dwThreadID);
}

HRESULT WSXFSLoader::WFSCleanUp()
{
    return (*m_fpWFSCleanUp)();
}

HRESULT WSXFSLoader::WFSClose(HSERVICE hService)
{
    return (*m_fpWFSClose)(hService);
}

HRESULT WSXFSLoader::WFSDeregister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg)
{
    return (*m_fpWFSDeregister)(hService, dwEventClass, hWndReg);
}

HRESULT WSXFSLoader::WFSDestroyAppHandle(HAPP hApp)
{
    return (*m_fpWFSDestroyAppHandle)(hApp);
}

HRESULT WSXFSLoader::WFSExecute(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, LPWFSRESULT * lppResult)
{
    return (*m_fpWFSExecute)(hService, dwCommand, lpCmdData, dwTimeOut, lppResult);
}

HRESULT WSXFSLoader::WFSFreeResult(LPWFSRESULT lpResult)
{
    return (*m_fpWFSFreeResult)(lpResult);
}

HRESULT WSXFSLoader::WFSGetInfo(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, LPWFSRESULT * lppResult)
{
    return (*m_fpWFSGetInfo)(hService, dwCategory, lpQueryDetails, dwTimeOut, lppResult);
}

HRESULT WSXFSLoader::WFSIsBlocking()
{
    return (*m_fpWFSIsBlocking)();
}

HRESULT WSXFSLoader::WFSLock(HSERVICE hService, DWORD dwTimeOut, LPWFSRESULT * lppResult)
{
    return (*m_fpWFSLock)(hService, dwTimeOut, lppResult);
}

HRESULT WSXFSLoader::WFSOpen(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPHSERVICE lphService)
{
    return (*m_fpWFSOpen)(lpszLogicalName, hApp, lpszAppID, dwTraceLevel, dwTimeOut, dwSrvcVersionsRequired, lpSrvcVersion, lpSPIVersion, lphService);
}

HRESULT WSXFSLoader::WFSRegister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg)
{
    return (*m_fpWFSRegister)(hService, dwEventClass, hWndReg);
}

HRESULT WSXFSLoader::WFSSetBlockingHook(XFSBLOCKINGHOOK lpBlockFunc, LPXFSBLOCKINGHOOK lppPrevFunc)
{
    return (*m_fpWFSSetBlockingHook)(lpBlockFunc, lppPrevFunc);
}

HRESULT WSXFSLoader::WFSStartUp(DWORD dwVersionsRequired, LPWFSVERSION lpWFSVersion)
{
    return (*m_fpWFSStartUp)(dwVersionsRequired, lpWFSVersion);
}

HRESULT WSXFSLoader::WFSUnhookBlockingHook()
{
    return (*m_fpWFSUnhookBlockingHook)();
}

HRESULT WSXFSLoader::WFSUnlock(HSERVICE hService)
{
    return (*m_fpWFSUnlock)(hService);
}

NS_AWP_DEVICE_WOSA_END

头文件定义

#pragma once

NS_AWP_DEVICE_WOSA_BEGIN

//WFM
typedef HRESULT(CALLBACK * WFMAllocateBufferProc)(ULONG, ULONG, LPVOID);
typedef HRESULT(CALLBACK * WFMAllocateMoreProc)(ULONG ulSize, LPVOID lpvOriginal, LPVOID * lppvData);
typedef HRESULT(CALLBACK * WFMFreeBufferProc)(LPVOID lpvData);
typedef HRESULT(CALLBACK * WFMGetTraceLevelProc)(HSERVICE hService, LPDWORD lpdwTraceLevel);
typedef HRESULT(CALLBACK * WFMKillTimerProc)(WORD wTimerID);
typedef HRESULT(CALLBACK * WFMOutputTraceDataProc)(LPSTR lpszData);
typedef HRESULT(CALLBACK * WFMReleaseDLLProc)(HPROVIDER hProvider);
typedef HRESULT(CALLBACK * WFMSetTimerProc)(HWND hWnd, LPVOID lpContext, DWORD dwTimeVal, LPWORD lpwTimerID);
typedef HRESULT(CALLBACK * WFMSetTraceLevelProc)(HSERVICE hService, DWORD dwTraceLevel);
//WFS
typedef HRESULT(CALLBACK * WFSAsyncCloseProc)(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncDeregisterProc)(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncExecuteProc)(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncGetInfoProc)(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncLockProc)(HSERVICE hService, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncOpenProc)(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, LPHSERVICE lphService, HWND hWnd, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncRegisterProc)(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSAsyncUnlockProc)(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID);
typedef HRESULT(CALLBACK * WFSCancelAsyncRequestProc)(HSERVICE hService, REQUESTID RequestID);
typedef HRESULT(CALLBACK * WFSCancelBlockingCallProc)(DWORD dwThreadID);
typedef HRESULT(CALLBACK * WFSCleanUpProc)();
typedef HRESULT(CALLBACK * WFSCloseProc)(HSERVICE hService);
typedef HRESULT(CALLBACK * WFSDeregisterProc)(HSERVICE hService, DWORD dwEventClass, HWND hWndReg);
typedef HRESULT(CALLBACK * WFSDestroyAppHandleProc)(HAPP hApp);
typedef HRESULT(CALLBACK * WFSExecuteProc)(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, LPWFSRESULT * lppResult);
typedef HRESULT(CALLBACK * WFSFreeResultProc)(LPWFSRESULT lpResult);
typedef HRESULT(CALLBACK * WFSGetInfoProc)(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, LPWFSRESULT * lppResult);
typedef BOOL(CALLBACK * WFSIsBlockingProc)();
typedef HRESULT(CALLBACK * WFSLockProc)(HSERVICE hService, DWORD dwTimeOut, LPWFSRESULT * lppResult);
typedef HRESULT(CALLBACK * WFSOpenProc)(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPHSERVICE lphService);
typedef HRESULT(CALLBACK * WFSRegisterProc)(HSERVICE hService, DWORD dwEventClass, HWND hWndReg);
typedef HRESULT(CALLBACK * WFSSetBlockingHookProc)(XFSBLOCKINGHOOK lpBlockFunc, LPXFSBLOCKINGHOOK lppPrevFunc);
typedef HRESULT(CALLBACK * WFSStartUpProc)(DWORD dwVersionsRequired, LPWFSVERSION lpWFSVersion);
typedef HRESULT(CALLBACK * WFSUnhookBlockingHookProc)();
typedef HRESULT(CALLBACK * WFSUnlockProc)(HSERVICE hService);

public ref class WSXFSLoader
{
private:
    ULONG ulMemFlags = WFS_MEM_ZEROINIT | WFS_MEM_SHARE;
    HMODULE hDllLib;

    //WFM
    WFMAllocateBufferProc m_fpWFMAllocateBuffer;
    WFMAllocateMoreProc m_fpWFMAllocateMore;
    WFMFreeBufferProc m_fpWFMFreeBuffer;
    WFMGetTraceLevelProc m_fpWFMGetTraceLevel;
    WFMKillTimerProc m_fpWFMKillTimer;
    WFMOutputTraceDataProc m_fpWFMOutputTraceData;
    WFMReleaseDLLProc m_fpWFMReleaseDLL;
    WFMSetTimerProc m_fpWFMSetTimer;
    WFMSetTraceLevelProc m_fpWFMSetTraceLevel;
    //WFS
    WFSAsyncCloseProc m_fpWFSAsyncClose;
    WFSAsyncDeregisterProc m_fpWFSAsyncDeregister;
    WFSAsyncExecuteProc m_fpWFSAsyncExecute;
    WFSAsyncGetInfoProc m_fpWFSAsyncGetInfo;
    WFSAsyncLockProc m_fpWFSAsyncLock;
    WFSAsyncOpenProc m_fpWFSAsyncOpen;
    WFSAsyncRegisterProc m_fpWFSAsyncRegister;
    WFSAsyncUnlockProc m_fpWFSAsyncUnlock;
    WFSCancelAsyncRequestProc m_fpWFSCancelAsyncRequest;
    WFSCancelBlockingCallProc m_fpWFSCancelBlockingCall;
    WFSCleanUpProc m_fpWFSCleanUp;
    WFSCloseProc m_fpWFSClose;
    WFSDeregisterProc m_fpWFSDeregister;
    WFSDestroyAppHandleProc m_fpWFSDestroyAppHandle;
    WFSExecuteProc m_fpWFSExecute;
    WFSFreeResultProc m_fpWFSFreeResult;
    WFSGetInfoProc m_fpWFSGetInfo;
    WFSIsBlockingProc m_fpWFSIsBlocking;
    WFSLockProc m_fpWFSLock;
    WFSOpenProc m_fpWFSOpen;
    WFSRegisterProc m_fpWFSRegister;
    WFSSetBlockingHookProc m_fpWFSSetBlockingHook;
    WFSStartUpProc m_fpWFSStartUp;
    WFSUnhookBlockingHookProc  m_fpWFSUnhookBlockingHook;
    WFSUnlockProc m_fpWFSUnlock;

public:
    WSXFSLoader();
    ~WSXFSLoader();
    HRESULT WFMAllocateBuffer(ULONG ulSize, ULONG ulFlags, LPVOID * lppvData);
    HRESULT WFMAllocateMore(ULONG ulSize, LPVOID lpvOriginal, LPVOID * lppvData);
    HRESULT WFMFreeBuffer(LPVOID lpvData);
    HRESULT WFMGetTraceLevel(HSERVICE hService, LPDWORD lpdwTraceLevel);
    HRESULT WFMKillTimer(WORD wTimerID);
    HRESULT WFMOutputTraceData(LPSTR lpszData);
    HRESULT WFMReleaseDLL(HPROVIDER hProvider);
    HRESULT WFMSetTimer(HWND hWnd, LPVOID lpContext, DWORD dwTimeVal, LPWORD lpwTimerID);
    HRESULT WFMSetTraceLevel(HSERVICE hService, DWORD dwTraceLevel);
    HRESULT WFSAsyncClose(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncDeregister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncExecute(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncGetInfo(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncLock(HSERVICE hService, DWORD dwTimeOut, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncOpen(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, LPHSERVICE lphService, HWND hWnd, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncRegister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSAsyncUnlock(HSERVICE hService, HWND hWnd, LPREQUESTID lpRequestID);
    HRESULT WFSCancelAsyncRequest(HSERVICE hService, REQUESTID RequestID);
    HRESULT WFSCancelBlockingCall(DWORD dwThreadID);
    HRESULT WFSCleanUp();
    HRESULT WFSClose(HSERVICE hService);
    HRESULT WFSDeregister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg);
    HRESULT WFSDestroyAppHandle(HAPP hApp);
    HRESULT WFSExecute(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, LPWFSRESULT * lppResult);
    HRESULT WFSFreeResult(LPWFSRESULT lpResult);
    HRESULT WFSGetInfo(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, LPWFSRESULT * lppResult);
    HRESULT WFSIsBlocking();
    HRESULT WFSLock(HSERVICE hService, DWORD dwTimeOut, LPWFSRESULT * lppResult);
    HRESULT WFSOpen(LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion, LPWFSVERSION lpSPIVersion, LPHSERVICE lphService);
    HRESULT WFSRegister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg);
    HRESULT WFSSetBlockingHook(XFSBLOCKINGHOOK lpBlockFunc, LPXFSBLOCKINGHOOK lppPrevFunc);
    HRESULT WFSStartUp(DWORD dwVersionsRequired, LPWFSVERSION lpWFSVersion);
    HRESULT WFSUnhookBlockingHook();
    HRESULT WFSUnlock(HSERVICE hService);
};

NS_AWP_DEVICE_WOSA_END