src/um/ws2spi.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! Definitions to be used with the WinSock service provider.
use ctypes::{c_char, c_int, c_long, c_uint};
use shared::basetsd::{DWORD_PTR, PDWORD_PTR, ULONG_PTR};
use shared::guiddef::{GUID, LPGUID};
use shared::minwindef::{
    BOOL, DWORD, INT, LPARAM, LPDWORD, LPHANDLE, LPINT, LPVOID, PBYTE, UINT, WORD, WPARAM,
};
use shared::windef::HWND;
use shared::ws2def::{LPSOCKADDR, LPWSABUF, SOCKADDR};
use shared::wtypesbase::LPBLOB;
use um::winnt::{HANDLE, LPCWSTR, LPWSTR, PVOID, WCHAR};
use um::winsock2::{
    GROUP, LPCONDITIONPROC, LPQOS, LPWSACOMPLETION, LPWSANETWORKEVENTS, LPWSAOVERLAPPED,
    LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSAPROTOCOL_INFOW, LPWSAQUERYSET2W, LPWSAQUERYSETW,
    LPWSASERVICECLASSINFOW, SOCKET, WSAESETSERVICEOP, WSAEVENT, fd_set, timeval,
};
#[cfg(target_pointer_width = "64")]
use um::winsock2::{LPWSANAMESPACE_INFOEXW, LPWSANAMESPACE_INFOW};
use vc::vcruntime::size_t;
pub const WSPDESCRIPTION_LEN: usize = 255;
pub const WSS_OPERATION_IN_PROGRESS: ULONG_PTR = 0x00000103;
STRUCT!{struct WSPDATA {
    wVersion: WORD,
    wHighVersion: WORD,
    szDescription: [WCHAR; WSPDESCRIPTION_LEN + 1],
}}
pub type LPWSPDATA = *mut WSPDATA;
STRUCT!{struct WSATHREADID {
    ThreadHandle: HANDLE,
    Reserved: DWORD_PTR,
}}
pub type LPWSATHREADID = *mut WSATHREADID;
FN!{stdcall LPBLOCKINGCALLBACK(
    dwContext: DWORD_PTR,
) -> BOOL}
FN!{stdcall LPWSAUSERAPC(
    dwContext: DWORD_PTR,
) -> ()}
FN!{stdcall LPWSPACCEPT(
    s: SOCKET,
    addr: *mut SOCKADDR,
    addrlen: LPINT,
    lpfnCondition: LPCONDITIONPROC,
    dwCallbackData: DWORD_PTR,
    lpErrno: LPINT,
) -> SOCKET}
FN!{stdcall LPWSPADDRESSTOSTRING(
    lpsaAddress: LPSOCKADDR,
    dwAddressLength: DWORD,
    lpProtocolInfo: LPWSAPROTOCOL_INFOW,
    lpszAddressString: LPWSTR,
    lpdwAddressStringLength: LPDWORD,
    lpErrno: LPINT,
) -> INT}
FN!{stdcall LPWSPASYNCSELECT(
    s: SOCKET,
    hWnd: HWND,
    wMsg: c_uint,
    lEvent: c_long,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPBIND(
    s: SOCKET,
    name: *mut SOCKADDR,
    namelen: c_int,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPCANCELBLOCKINGCALL(
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPCLEANUP(
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPCLOSESOCKET(
    s: SOCKET,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPCONNECT(
    s: SOCKET,
    name: *mut SOCKADDR,
    namelen: c_int,
    lpCallerData: LPWSABUF,
    lpCalleeData: LPWSABUF,
    lpSQOS: LPQOS,
    lpGQOS: LPQOS,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPDUPLICATESOCKET(
    s: SOCKET,
    dwProcessId: DWORD,
    lpProtocolInfo: LPWSAPROTOCOL_INFOW,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPENUMNETWORKEVENTS(
    s: SOCKET,
    hEventObject: WSAEVENT,
    lpNetworkEvents: LPWSANETWORKEVENTS,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPEVENTSELECT(
    s: SOCKET,
    hEventObject: WSAEVENT,
    lNetworkEvents: c_long,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPGETOVERLAPPEDRESULT(
    s: SOCKET,
    lpOverlapped: LPWSAOVERLAPPED,
    lpcbTransfer: LPDWORD,
    fWait: BOOL,
    lpdwFlags: LPDWORD,
    lpErrno: LPINT,
) -> BOOL}
FN!{stdcall LPWSPGETPEERNAME(
    s: SOCKET,
    name: *mut SOCKADDR,
    namelen: LPINT,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPGETSOCKNAME(
    s: SOCKET,
    name: *mut SOCKADDR,
    namelen: LPINT,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPGETSOCKOPT(
    s: SOCKET,
    level: c_int,
    optname: c_int,
    optval: *mut c_char,
    optlen: LPINT,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPGETQOSBYNAME(
    s: SOCKET,
    lpQOSName: LPWSABUF,
    lpQOS: LPQOS,
    lpErrno: LPINT,
) -> BOOL}
FN!{stdcall LPWSPIOCTL(
    s: SOCKET,
    dwIoControlCode: DWORD,
    lpvInBuffer: LPVOID,
    cbInBuffer: DWORD,
    lpvOutBuffer: LPVOID,
    cbOutBuffer: DWORD,
    lpcbBytesReturned: LPDWORD,
    lpOverlapped: LPWSAOVERLAPPED,
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPJOINLEAF(
    s: SOCKET,
    name: *mut SOCKADDR,
    namelen: c_int,
    lpCallerData: LPWSABUF,
    lpCalleeData: LPWSABUF,
    lpSQOS: LPQOS,
    lpGQOS: LPQOS,
    dwFlags: DWORD,
    lpErrno: LPINT,
) -> SOCKET}
FN!{stdcall LPWSPLISTEN(
    s: SOCKET,
    backlog: c_int,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPRECV(
    s: SOCKET,
    lpBuffers: LPWSABUF,
    dwBufferCount: DWORD,
    lpNumberOfBytesRecvd: LPDWORD,
    lpFlags: LPDWORD,
    lpOverlapped: LPWSAOVERLAPPED,
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPRECVDISCONNECT(
    s: SOCKET,
    lpInboundDisconnectData: LPWSABUF,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPRECVFROM(
    s: SOCKET,
    lpBuffers: LPWSABUF,
    dwBufferCount: DWORD,
    lpNumberOfBytesRecvd: LPDWORD,
    lpFlags: LPDWORD,
    lpFrom: *mut SOCKADDR,
    lpFromlen: LPINT,
    lpOverlapped: LPWSAOVERLAPPED,
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSELECT(
    nfds: c_int,
    readfds: *mut fd_set,
    writefds: *mut fd_set,
    exceptfds: *mut fd_set,
    timeout: *const timeval,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSEND(
    s: SOCKET,
    lpBuffers: LPWSABUF,
    dwBufferCount: DWORD,
    lpNumberOfBytesSent: LPDWORD,
    dwFlags: DWORD,
    lpOverlapped: LPWSAOVERLAPPED,
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSENDDISCONNECT(
    s: SOCKET,
    lpOutboundDisconnectData: LPWSABUF,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSENDTO(
    s: SOCKET,
    lpBuffers: LPWSABUF,
    dwBufferCount: DWORD,
    lpNumberOfBytesSent: LPDWORD,
    dwFlags: DWORD,
    lpTo: *const SOCKADDR,
    iTolen: c_int,
    lpOverlapped: LPWSAOVERLAPPED,
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSETSOCKOPT(
    s: SOCKET,
    level: c_int,
    optname: c_int,
    optval: *const c_char,
    optlen: c_int,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSHUTDOWN(
    s: SOCKET,
    how: c_int,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWSPSOCKET(
    af: c_int,
    _type: c_int,
    protocol: c_int,
    lpProtocolInfo: LPWSAPROTOCOL_INFOW,
    g: GROUP,
    dwFlags: DWORD,
    lpErrno: LPINT,
) -> SOCKET}
FN!{stdcall LPWSPSTRINGTOADDRESS(
    AddressString: LPWSTR,
    AddressFamily: INT,
    lpProtocolInfo: LPWSAPROTOCOL_INFOW,
    lpAddress: LPSOCKADDR,
    lpAddressLength: LPINT,
    lpErrno: LPINT,
) -> c_int}
STRUCT!{struct WSPPROC_TABLE {
    lpWSPAccept: LPWSPACCEPT,
    lpWSPAddressToString: LPWSPADDRESSTOSTRING,
    lpWSPAsyncSelect: LPWSPASYNCSELECT,
    lpWSPBind: LPWSPBIND,
    lpWSPCancelBlockingCall: LPWSPCANCELBLOCKINGCALL,
    lpWSPCleanup: LPWSPCLEANUP,
    lpWSPCloseSocket: LPWSPCLOSESOCKET,
    lpWSPConnect: LPWSPCONNECT,
    lpWSPDuplicateSocket: LPWSPDUPLICATESOCKET,
    lpWSPEnumNetworkEvents: LPWSPENUMNETWORKEVENTS,
    lpWSPEventSelect: LPWSPEVENTSELECT,
    lpWSPGetOverlappedResult: LPWSPGETOVERLAPPEDRESULT,
    lpWSPGetPeerName: LPWSPGETPEERNAME,
    lpWSPGetSockName: LPWSPGETSOCKNAME,
    lpWSPGetSockOpt: LPWSPGETSOCKOPT,
    lpWSPGetQOSByName: LPWSPGETQOSBYNAME,
    lpWSPIoctl: LPWSPIOCTL,
    lpWSPJoinLeaf: LPWSPJOINLEAF,
    lpWSPListen: LPWSPLISTEN,
    lpWSPRecv: LPWSPRECV,
    lpWSPRecvDisconnect: LPWSPRECVDISCONNECT,
    lpWSPRecvFrom: LPWSPRECVFROM,
    lpWSPSelect: LPWSPSELECT,
    lpWSPSend: LPWSPSEND,
    lpWSPSendDisconnect: LPWSPSENDDISCONNECT,
    lpWSPSendTo: LPWSPSENDTO,
    lpWSPSetSockOpt: LPWSPSETSOCKOPT,
    lpWSPShutdown: LPWSPSHUTDOWN,
    lpWSPSocket: LPWSPSOCKET,
    lpWSPStringToAddress: LPWSPSTRINGTOADDRESS,
}}
pub type LPWSPPROC_TABLE = *mut WSPPROC_TABLE;
FN!{stdcall LPWPUCLOSEEVENT(
    hEvent: WSAEVENT,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUCLOSESOCKETHANDLE(
    s: SOCKET,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUCREATEEVENT(
    lpErrno: LPINT,
) -> WSAEVENT}
FN!{stdcall LPWPUCREATESOCKETHANDLE(
    dwCatalogEntryId: DWORD,
    dwContext: DWORD_PTR,
    lpErrno: LPINT,
) -> SOCKET}
FN!{stdcall LPWPUFDISSET(
    s: SOCKET,
    fdset: *mut fd_set,
) -> c_int}
FN!{stdcall LPWPUGETPROVIDERPATH(
    lpProviderId: LPGUID,
    lpszProviderDllPath: *mut WCHAR,
    lpProviderDllPathLen: LPINT,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUMODIFYIFSHANDLE(
    dwCatalogEntryId: DWORD,
    ProposedHandle: SOCKET,
    lpErrno: LPINT,
) -> SOCKET}
FN!{stdcall LPWPUPOSTMESSAGE(
    hWnd: HWND,
    Msg: UINT,
    wParam: WPARAM,
    lParam: LPARAM,
) -> BOOL}
FN!{stdcall LPWPUQUERYBLOCKINGCALLBACK(
    dwCatalogEntryId: DWORD,
    lplpfnCallback: *mut LPBLOCKINGCALLBACK,
    lpdwContext: PDWORD_PTR,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUQUERYSOCKETHANDLECONTEXT(
    s: SOCKET,
    lpContext: PDWORD_PTR,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUQUEUEAPC(
    lpThreadId: LPWSATHREADID,
    lpfnUserApc: LPWSAUSERAPC,
    dwContext: DWORD_PTR,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPURESETEVENT(
    hEvent: WSAEVENT,
    lpErrno: LPINT,
) -> BOOL}
FN!{stdcall LPWPUSETEVENT(
    hEvent: WSAEVENT,
    lpErrno: LPINT,
) -> BOOL}
FN!{stdcall LPWPUOPENCURRENTTHREAD(
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUCLOSETHREAD(
    lpThreadId: LPWSATHREADID,
    lpErrno: LPINT,
) -> c_int}
FN!{stdcall LPWPUCOMPLETEOVERLAPPEDREQUEST(
    s: SOCKET,
    lpOverlapped: LPWSAOVERLAPPED,
    dwError: DWORD,
    cbTransferred: DWORD,
    lpErrno: LPINT,
) -> c_int}
STRUCT!{struct WSPUPCALLTABLE {
    lpWPUCloseEvent: LPWPUCLOSEEVENT,
    lpWPUCloseSocketHandle: LPWPUCLOSESOCKETHANDLE,
    lpWPUCreateEvent: LPWPUCREATEEVENT,
    lpWPUCreateSocketHandle: LPWPUCREATESOCKETHANDLE,
    lpWPUFDIsSet: LPWPUFDISSET,
    lpWPUGetProviderPath: LPWPUGETPROVIDERPATH,
    lpWPUModifyIFSHandle: LPWPUMODIFYIFSHANDLE,
    lpWPUPostMessage: LPWPUPOSTMESSAGE,
    lpWPUQueryBlockingCallback: LPWPUQUERYBLOCKINGCALLBACK,
    lpWPUQuerySocketHandleContext: LPWPUQUERYSOCKETHANDLECONTEXT,
    lpWPUQueueApc: LPWPUQUEUEAPC,
    lpWPUResetEvent: LPWPURESETEVENT,
    lpWPUSetEvent: LPWPUSETEVENT,
    lpWPUOpenCurrentThread: LPWPUOPENCURRENTTHREAD,
    lpWPUCloseThread: LPWPUCLOSETHREAD,
}}
pub type LPWSPUPCALLTABLE = *mut WSPUPCALLTABLE;
extern "system" {
    pub fn WSPStartup(
        wVersionRequested: WORD,
        lpWSPData: LPWSPDATA,
        lpProtocolInfo: LPWSAPROTOCOL_INFOW,
        UpcallTable: WSPUPCALLTABLE,
        lpProcTable: LPWSPPROC_TABLE,
    ) -> c_int;
}
FN!{stdcall LPWSPSTARTUP(
    wVersionRequested: WORD,
    lpWSPData: LPWSPDATA,
    lpProtocolInfo: LPWSAPROTOCOL_INFOW,
    UpcallTable: WSPUPCALLTABLE,
    lpProcTable: LPWSPPROC_TABLE,
) -> c_int}
extern "system" {
    pub fn WSCEnumProtocols(
        lpiProtocols: LPINT,
        lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
        lpdwBufferLength: LPDWORD,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPWSCENUMPROTOCOLS(
    lpiProtocols: LPINT,
    lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
    lpdwBufferLength: LPDWORD,
    lpErrno: LPINT,
) -> c_int}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCEnumProtocols32(
        lpiProtocols: LPINT,
        lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
        lpdwBufferLength: LPDWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCDeinstallProvider(
        lpProviderId: LPGUID,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPWSCDEINSTALLPROVIDER(
    lpProviderId: LPGUID,
    lpErrno: LPINT,
) -> c_int}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCDeinstallProvider32(
        lpProviderId: LPGUID,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCInstallProvider(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *const WCHAR,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPWSCINSTALLPROVIDER(
    lpProviderId: LPGUID,
    lpszProviderDllPath: *const WCHAR,
    lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
    dwNumberOfEntries: DWORD,
    lpErrno: LPINT,
) -> c_int}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCInstallProvider64_32(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *const WCHAR,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCGetProviderPath(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *mut WCHAR,
        lpProviderDllPathLen: LPINT,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPWSCGETPROVIDERPATH(
    lpProviderId: LPGUID,
    lpszProviderDllPath: *mut WCHAR,
    lpProviderDllPathLen: LPINT,
    lpErrno: LPINT,
) -> c_int}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCGetProviderPath32(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *mut WCHAR,
        lpProviderDllPathLen: LPINT,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCUpdateProvider(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *const WCHAR,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPWSCUPDATEPROVIDER(
    lpProviderId: LPGUID,
    lpszProviderDllPath: *const WCHAR,
    lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
    dwNumberOfEntries: DWORD,
    lpErrno: LPINT,
) -> c_int}
#[cfg(target_pointer_width = "64")]
extern "system" {
    pub fn WSCUpdateProvider32(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *const WCHAR,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
}
pub const LSP_SYSTEM: DWORD = 0x80000000;
pub const LSP_INSPECTOR: DWORD = 0x00000001;
pub const LSP_REDIRECTOR: DWORD = 0x00000002;
pub const LSP_PROXY: DWORD = 0x00000004;
pub const LSP_FIREWALL: DWORD = 0x00000008;
pub const LSP_INBOUND_MODIFY: DWORD = 0x00000010;
pub const LSP_OUTBOUND_MODIFY: DWORD = 0x00000020;
pub const LSP_CRYPTO_COMPRESS: DWORD = 0x00000040;
pub const LSP_LOCAL_CACHE: DWORD = 0x00000080;
ENUM!{enum WSC_PROVIDER_INFO_TYPE {
    ProviderInfoLspCategories,
    ProviderInfoAudit,
}}
STRUCT!{struct WSC_PROVIDER_AUDIT_INFO {
    RecordSize: DWORD,
    Reserved: PVOID,
}}
extern "system" {
    pub fn WSCSetProviderInfo(
        lpProviderId: LPGUID,
        InfoType: WSC_PROVIDER_INFO_TYPE,
        Info: PBYTE,
        InfoSize: size_t,
        Flags: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCGetProviderInfo(
        lpProviderId: LPGUID,
        InfoType: WSC_PROVIDER_INFO_TYPE,
        Info: PBYTE,
        InfoSize: *mut size_t,
        Flags: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCSetProviderInfo32(
        lpProviderId: LPGUID,
        InfoType: WSC_PROVIDER_INFO_TYPE,
        Info: PBYTE,
        InfoSize: size_t,
        Flags: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCGetProviderInfo32(
        lpProviderId: LPGUID,
        InfoType: WSC_PROVIDER_INFO_TYPE,
        Info: PBYTE,
        InfoSize: *mut size_t,
        Flags: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCSetApplicationCategory(
        Path: LPCWSTR,
        PathLength: DWORD,
        Extra: LPCWSTR,
        ExtraLength: DWORD,
        PermittedLspCategories: DWORD,
        pPrevPermLspCat: *mut DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WSCGetApplicationCategory(
        Path: LPCWSTR,
        PathLength: DWORD,
        Extra: LPCWSTR,
        ExtraLength: DWORD,
        pPermittedLspCategories: *mut DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUCloseEvent(
        hEvent: WSAEVENT,
        lpErrno: LPINT,
    ) -> BOOL;
    pub fn WPUCloseSocketHandle(
        s: SOCKET,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUCreateEvent(
        lpErrno: LPINT,
    ) -> WSAEVENT;
    pub fn WPUCreateSocketHandle(
        dwCatalogEntryId: DWORD,
        dwContext: DWORD_PTR,
        lpErrno: LPINT,
    ) -> SOCKET;
    pub fn WPUFDIsSet(
        s: SOCKET,
        fdset: *mut fd_set,
    ) -> c_int;
    pub fn WPUGetProviderPath(
        lpProviderId: LPGUID,
        lpszProviderDllPath: *mut WCHAR,
        lpProviderDllPathLen: LPINT,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUModifyIFSHandle(
        dwCatalogEntryId: DWORD,
        ProposedHandle: SOCKET,
        lpErrno: LPINT,
    ) -> SOCKET;
    pub fn WPUPostMessage(
        hWnd: HWND,
        Msg: UINT,
        wParam: WPARAM,
        lParam: LPARAM,
    ) -> BOOL;
    pub fn WPUQueryBlockingCallback(
        dwCatalogEntryId: DWORD,
        lplpfnCallback: *mut LPBLOCKINGCALLBACK,
        lpdwContext: PDWORD_PTR,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUQuerySocketHandleContext(
        s: SOCKET,
        lpContext: PDWORD_PTR,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUQueueApc(
        lpThreadId: LPWSATHREADID,
        lpfnUserApc: LPWSAUSERAPC,
        dwContext: DWORD_PTR,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUResetEvent(
        hEvent: WSAEVENT,
        lpErrno: LPINT,
    ) -> BOOL;
    pub fn WPUSetEvent(
        hEvent: WSAEVENT,
        lpErrno: LPINT,
    ) -> BOOL;
    pub fn WPUCompleteOverlappedRequest(
        s: SOCKET,
        lpOverlapped: LPWSAOVERLAPPED,
        dwError: DWORD,
        cbTransferred: DWORD,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUOpenCurrentThread(
        lpThreadId: LPWSATHREADID,
        lpErrno: LPINT,
    ) -> c_int;
    pub fn WPUCloseThread(
        lpThreadId: LPWSATHREADID,
        lpErrno: LPINT,
    ) -> c_int;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCEnumNameSpaceProviders32(
        lpdwBufferLength: LPDWORD,
        lpnspBuffer: LPWSANAMESPACE_INFOW,
    ) -> INT;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCEnumNameSpaceProvidersEx32(
        lpdwBufferLength: LPDWORD,
        lpnspBuffer: LPWSANAMESPACE_INFOEXW,
    ) -> INT;
    pub fn WSCInstallNameSpace(
        lpszIdentifier: LPWSTR,
        lpszPathName: LPWSTR,
        dwNameSpace: DWORD,
        dwVersion: DWORD,
        lpProviderId: LPGUID,
    ) -> INT;
}
FN!{stdcall LPWSCINSTALLNAMESPACE(
    lpszIdentifier: LPWSTR,
    lpszPathName: LPWSTR,
    dwNameSpace: DWORD,
    dwVersion: DWORD,
    lpProviderId: LPGUID,
) -> INT}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCInstallNameSpace32(
        lpszIdentifier: LPWSTR,
        lpszPathName: LPWSTR,
        dwNameSpace: DWORD,
        dwVersion: DWORD,
        lpProviderId: LPGUID,
    ) -> INT;
    pub fn WSCUnInstallNameSpace(
        lpProviderId: LPGUID,
    ) -> INT;
}
FN!{stdcall LPWSCUNINSTALLNAMESPACE(
    lpProviderId: LPGUID,
) -> INT}
extern "system" {
    pub fn WSCInstallNameSpaceEx(
        lpszIdentifier: LPWSTR,
        lpszPathName: LPWSTR,
        dwNameSpace: DWORD,
        dwVersion: DWORD,
        lpProviderId: LPGUID,
        lpProviderSpecific: LPBLOB,
    ) -> INT;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCInstallNameSpaceEx32(
        lpszIdentifier: LPWSTR,
        lpszPathName: LPWSTR,
        dwNameSpace: DWORD,
        dwVersion: DWORD,
        lpProviderId: LPGUID,
        lpProviderSpecific: LPBLOB,
    ) -> INT;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCUnInstallNameSpace32(
        lpProviderId: LPGUID,
    ) -> INT;
    pub fn WSCEnableNSProvider(
        lpProviderId: LPGUID,
        fEnable: BOOL,
    ) -> INT;
}
FN!{stdcall LPWSCENABLENSPROVIDER(
    lpProviderId: LPGUID,
    fEnable: BOOL,
) -> INT}
extern "system" {
    #[cfg(target_pointer_width = "64")]
    pub fn WSCEnableNSProvider32(
        lpProviderId: LPGUID,
        fEnable: BOOL,
    ) -> INT;
    #[cfg(target_pointer_width = "64")]
    pub fn WSCInstallProviderAndChains64_32(
        lpProviderId: LPGUID,
        lpszProviderDllPath: LPWSTR,
        lpszProviderDllPath32: LPWSTR,
        lpszLspName: LPWSTR,
        dwServiceFlags: DWORD,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpdwCatalogEntryId: LPDWORD,
        lpErrno: LPINT,
    ) -> c_int;
    #[cfg(target_pointer_width = "32")]
    pub fn WSCInstallProviderAndChains(
        lpProviderId: LPGUID,
        lpszProviderDllPath: LPWSTR,
        lpszLspName: LPWSTR,
        dwServiceFlags: DWORD,
        lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
        dwNumberOfEntries: DWORD,
        lpdwCatalogEntryId: LPDWORD,
        lpErrno: LPINT,
    ) -> c_int;
}
FN!{stdcall LPNSPCLEANUP(
    lpProviderId: LPGUID,
) -> INT}
FN!{stdcall LPNSPLOOKUPSERVICEBEGIN(
    lpProviderId: LPGUID,
    lpqsRestrictions: LPWSAQUERYSETW,
    lpServiceClassInfo: LPWSASERVICECLASSINFOW,
    dwControlFlags: DWORD,
    lphLookup: LPHANDLE,
) -> INT}
FN!{stdcall LPNSPLOOKUPSERVICENEXT(
    hLookup: HANDLE,
    dwControlFlags: DWORD,
    lpdwBufferLength: LPDWORD,
    lpqsResults: LPWSAQUERYSETW,
) -> INT}
FN!{stdcall LPNSPIOCTL(
    hLookup: HANDLE,
    dwControlCode: DWORD,
    lpvInBuffer: LPVOID,
    cbInBuffer: DWORD,
    lpvOutBuffer: LPVOID,
    cbOutBuffer: DWORD,
    lpcbBytesReturned: LPDWORD,
    lpCompletion: LPWSACOMPLETION,
    lpThreadId: LPWSATHREADID,
) -> INT}
FN!{stdcall LPNSPLOOKUPSERVICEEND(
    hLookup: HANDLE,
) -> INT}
FN!{stdcall LPNSPSETSERVICE(
    lpProviderId: LPGUID,
    lpServiceClassInfo: LPWSASERVICECLASSINFOW,
    lpqsRegInfo: LPWSAQUERYSETW,
    essOperation: WSAESETSERVICEOP,
    dwControlFlags: DWORD,
) -> INT}
FN!{stdcall LPNSPINSTALLSERVICECLASS(
    lpProviderId: LPGUID,
    lpServiceClassInfo: LPWSASERVICECLASSINFOW,
) -> INT}
FN!{stdcall LPNSPREMOVESERVICECLASS(
    lpProviderId: LPGUID,
    lpServiceClassId: LPGUID,
) -> INT}
FN!{stdcall LPNSPGETSERVICECLASSINFO(
    lpProviderId: LPGUID,
    lpdwBufSize: LPDWORD,
    lpServiceClassInfo: LPWSASERVICECLASSINFOW,
) -> INT}
STRUCT!{struct NSP_ROUTINE {
    cbSize: DWORD,
    dwMajorVersion: DWORD,
    dwMinorVersion: DWORD,
    NSPCleanup: LPNSPCLEANUP,
    NSPLookupServiceBegin: LPNSPLOOKUPSERVICEBEGIN,
    NSPLookupServiceNext: LPNSPLOOKUPSERVICENEXT,
    NSPLookupServiceEnd: LPNSPLOOKUPSERVICEEND,
    NSPSetService: LPNSPSETSERVICE,
    NSPInstallServiceClass: LPNSPINSTALLSERVICECLASS,
    NSPRemoveServiceClass: LPNSPREMOVESERVICECLASS,
    NSPGetServiceClassInfo: LPNSPGETSERVICECLASSINFO,
    NSPIoctl: LPNSPIOCTL,
}}
pub type LPNSP_ROUTINE = *mut NSP_ROUTINE;
extern "system" {
    pub fn NSPStartup(
        lpProviderId: LPGUID,
        lpnspRoutines: LPNSP_ROUTINE,
    ) -> INT;
}
FN!{stdcall LPNSPSTARTUP(
    lpProviderId: LPGUID,
    lpnspRoutines: LPNSP_ROUTINE,
) -> INT}
FN!{stdcall LPNSPV2STARTUP(
    lpProviderId: LPGUID,
    ppvClientSessionArg: *mut LPVOID,
) -> INT}
FN!{stdcall LPNSPV2CLEANUP(
    lpProviderId: LPGUID,
    pvClientSessionArg: LPVOID,
) -> INT}
FN!{stdcall LPNSPV2LOOKUPSERVICEBEGIN(
    lpProviderId: LPGUID,
    lpqsRestrictions: LPWSAQUERYSET2W,
    dwControlFlags: DWORD,
    lpvClientSessionArg: LPVOID,
    lphLookup: LPHANDLE,
) -> INT}
FN!{stdcall LPNSPV2LOOKUPSERVICENEXTEX(
    hAsyncCall: HANDLE,
    hLookup: HANDLE,
    dwControlFlags: DWORD,
    lpdwBufferLength: LPDWORD,
    lpqsResults: LPWSAQUERYSET2W,
) -> ()}
FN!{stdcall LPNSPV2LOOKUPSERVICEEND(
    hLookup: HANDLE,
) -> INT}
FN!{stdcall LPNSPV2SETSERVICEEX(
    hAsyncCall: HANDLE,
    lpProviderId: LPGUID,
    lpqsRegInfo: LPWSAQUERYSET2W,
    essOperation: WSAESETSERVICEOP,
    dwControlFlags: DWORD,
    lpvClientSessionArg: LPVOID,
) -> ()}
FN!{stdcall LPNSPV2CLIENTSESSIONRUNDOWN(
    lpProviderId: LPGUID,
    pvClientSessionArg: LPVOID,
) -> ()}
STRUCT!{struct NSPV2_ROUTINE {
    cbSize: DWORD,
    dwMajorVersion: DWORD,
    dwMinorVersion: DWORD,
    NSPv2Startup: LPNSPV2STARTUP,
    NSPv2Cleanup: LPNSPV2CLEANUP,
    NSPv2LookupServiceBegin: LPNSPV2LOOKUPSERVICEBEGIN,
    NSPv2LookupServiceNextEx: LPNSPV2LOOKUPSERVICENEXTEX,
    NSPv2LookupServiceEnd: LPNSPV2LOOKUPSERVICEEND,
    NSPv2SetServiceEx: LPNSPV2SETSERVICEEX,
    NSPv2ClientSessionRundown: LPNSPV2CLIENTSESSIONRUNDOWN,
}}
pub type PNSPV2_ROUTINE = *mut NSPV2_ROUTINE;
pub type LPNSPV2_ROUTINE = *mut NSPV2_ROUTINE;
pub type PCNSPV2_ROUTINE = *const NSPV2_ROUTINE;
pub type LPCNSPV2_ROUTINE = *const NSPV2_ROUTINE;
extern "system" {
    pub fn WSAAdvertiseProvider(
        puuidProviderId: *const GUID,
        pNSPv2Routine: *const LPCNSPV2_ROUTINE,
    ) -> INT;
    pub fn WSAUnadvertiseProvider(
        puuidProviderId: *const GUID,
    ) -> INT;
    pub fn WSAProviderCompleteAsyncCall(
        hAsyncCall: HANDLE,
        iRetCode: INT,
    ) -> INT;
}