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, '\\') + ) = ;

    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