vendor/winapi/src/um/ws2spi.rs

   1 // Licensed under the Apache License, Version 2.0
   2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   4 // All files in the project carrying such notice may not be copied, modified, or distributed
   5 // except according to those terms.
   6 //! Definitions to be used with the WinSock service provider.
   7 use ctypes::{c_char, c_int, c_long, c_uint};
   8 use shared::basetsd::{DWORD_PTR, PDWORD_PTR, ULONG_PTR};
   9 use shared::guiddef::{GUID, LPGUID};
  10 use shared::minwindef::{
  11     BOOL, DWORD, INT, LPARAM, LPDWORD, LPHANDLE, LPINT, LPVOID, PBYTE, UINT, WORD, WPARAM,
  12 };
  13 use shared::windef::HWND;
  14 use shared::ws2def::{LPSOCKADDR, LPWSABUF, SOCKADDR};
  15 use shared::wtypesbase::LPBLOB;
  16 use um::winnt::{HANDLE, LPCWSTR, LPWSTR, PVOID, WCHAR};
  17 use um::winsock2::{
  18     GROUP, LPCONDITIONPROC, LPQOS, LPWSACOMPLETION, LPWSANETWORKEVENTS, LPWSAOVERLAPPED,
  19     LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSAPROTOCOL_INFOW, LPWSAQUERYSET2W, LPWSAQUERYSETW,
  20     LPWSASERVICECLASSINFOW, SOCKET, WSAESETSERVICEOP, WSAEVENT, fd_set, timeval,
  21 };
  22 #[cfg(target_pointer_width = "64")]
  23 use um::winsock2::{LPWSANAMESPACE_INFOEXW, LPWSANAMESPACE_INFOW};
  24 use vc::vcruntime::size_t;
  25 pub const WSPDESCRIPTION_LEN: usize = 255;
  26 pub const WSS_OPERATION_IN_PROGRESS: ULONG_PTR = 0x00000103;
  27 STRUCT!{struct WSPDATA {
  28     wVersion: WORD,
  29     wHighVersion: WORD,
  30     szDescription: [WCHAR; WSPDESCRIPTION_LEN + 1],
  31 }}
  32 pub type LPWSPDATA = *mut WSPDATA;
  33 STRUCT!{struct WSATHREADID {
  34     ThreadHandle: HANDLE,
  35     Reserved: DWORD_PTR,
  36 }}
  37 pub type LPWSATHREADID = *mut WSATHREADID;
  38 FN!{stdcall LPBLOCKINGCALLBACK(
  39     dwContext: DWORD_PTR,
  40 ) -> BOOL}
  41 FN!{stdcall LPWSAUSERAPC(
  42     dwContext: DWORD_PTR,
  43 ) -> ()}
  44 FN!{stdcall LPWSPACCEPT(
  45     s: SOCKET,
  46     addr: *mut SOCKADDR,
  47     addrlen: LPINT,
  48     lpfnCondition: LPCONDITIONPROC,
  49     dwCallbackData: DWORD_PTR,
  50     lpErrno: LPINT,
  51 ) -> SOCKET}
  52 FN!{stdcall LPWSPADDRESSTOSTRING(
  53     lpsaAddress: LPSOCKADDR,
  54     dwAddressLength: DWORD,
  55     lpProtocolInfo: LPWSAPROTOCOL_INFOW,
  56     lpszAddressString: LPWSTR,
  57     lpdwAddressStringLength: LPDWORD,
  58     lpErrno: LPINT,
  59 ) -> INT}
  60 FN!{stdcall LPWSPASYNCSELECT(
  61     s: SOCKET,
  62     hWnd: HWND,
  63     wMsg: c_uint,
  64     lEvent: c_long,
  65     lpErrno: LPINT,
  66 ) -> c_int}
  67 FN!{stdcall LPWSPBIND(
  68     s: SOCKET,
  69     name: *mut SOCKADDR,
  70     namelen: c_int,
  71     lpErrno: LPINT,
  72 ) -> c_int}
  73 FN!{stdcall LPWSPCANCELBLOCKINGCALL(
  74     lpErrno: LPINT,
  75 ) -> c_int}
  76 FN!{stdcall LPWSPCLEANUP(
  77     lpErrno: LPINT,
  78 ) -> c_int}
  79 FN!{stdcall LPWSPCLOSESOCKET(
  80     s: SOCKET,
  81     lpErrno: LPINT,
  82 ) -> c_int}
  83 FN!{stdcall LPWSPCONNECT(
  84     s: SOCKET,
  85     name: *mut SOCKADDR,
  86     namelen: c_int,
  87     lpCallerData: LPWSABUF,
  88     lpCalleeData: LPWSABUF,
  89     lpSQOS: LPQOS,
  90     lpGQOS: LPQOS,
  91     lpErrno: LPINT,
  92 ) -> c_int}
  93 FN!{stdcall LPWSPDUPLICATESOCKET(
  94     s: SOCKET,
  95     dwProcessId: DWORD,
  96     lpProtocolInfo: LPWSAPROTOCOL_INFOW,
  97     lpErrno: LPINT,
  98 ) -> c_int}
  99 FN!{stdcall LPWSPENUMNETWORKEVENTS(
 100     s: SOCKET,
 101     hEventObject: WSAEVENT,
 102     lpNetworkEvents: LPWSANETWORKEVENTS,
 103     lpErrno: LPINT,
 104 ) -> c_int}
 105 FN!{stdcall LPWSPEVENTSELECT(
 106     s: SOCKET,
 107     hEventObject: WSAEVENT,
 108     lNetworkEvents: c_long,
 109     lpErrno: LPINT,
 110 ) -> c_int}
 111 FN!{stdcall LPWSPGETOVERLAPPEDRESULT(
 112     s: SOCKET,
 113     lpOverlapped: LPWSAOVERLAPPED,
 114     lpcbTransfer: LPDWORD,
 115     fWait: BOOL,
 116     lpdwFlags: LPDWORD,
 117     lpErrno: LPINT,
 118 ) -> BOOL}
 119 FN!{stdcall LPWSPGETPEERNAME(
 120     s: SOCKET,
 121     name: *mut SOCKADDR,
 122     namelen: LPINT,
 123     lpErrno: LPINT,
 124 ) -> c_int}
 125 FN!{stdcall LPWSPGETSOCKNAME(
 126     s: SOCKET,
 127     name: *mut SOCKADDR,
 128     namelen: LPINT,
 129     lpErrno: LPINT,
 130 ) -> c_int}
 131 FN!{stdcall LPWSPGETSOCKOPT(
 132     s: SOCKET,
 133     level: c_int,
 134     optname: c_int,
 135     optval: *mut c_char,
 136     optlen: LPINT,
 137     lpErrno: LPINT,
 138 ) -> c_int}
 139 FN!{stdcall LPWSPGETQOSBYNAME(
 140     s: SOCKET,
 141     lpQOSName: LPWSABUF,
 142     lpQOS: LPQOS,
 143     lpErrno: LPINT,
 144 ) -> BOOL}
 145 FN!{stdcall LPWSPIOCTL(
 146     s: SOCKET,
 147     dwIoControlCode: DWORD,
 148     lpvInBuffer: LPVOID,
 149     cbInBuffer: DWORD,
 150     lpvOutBuffer: LPVOID,
 151     cbOutBuffer: DWORD,
 152     lpcbBytesReturned: LPDWORD,
 153     lpOverlapped: LPWSAOVERLAPPED,
 154     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
 155     lpThreadId: LPWSATHREADID,
 156     lpErrno: LPINT,
 157 ) -> c_int}
 158 FN!{stdcall LPWSPJOINLEAF(
 159     s: SOCKET,
 160     name: *mut SOCKADDR,
 161     namelen: c_int,
 162     lpCallerData: LPWSABUF,
 163     lpCalleeData: LPWSABUF,
 164     lpSQOS: LPQOS,
 165     lpGQOS: LPQOS,
 166     dwFlags: DWORD,
 167     lpErrno: LPINT,
 168 ) -> SOCKET}
 169 FN!{stdcall LPWSPLISTEN(
 170     s: SOCKET,
 171     backlog: c_int,
 172     lpErrno: LPINT,
 173 ) -> c_int}
 174 FN!{stdcall LPWSPRECV(
 175     s: SOCKET,
 176     lpBuffers: LPWSABUF,
 177     dwBufferCount: DWORD,
 178     lpNumberOfBytesRecvd: LPDWORD,
 179     lpFlags: LPDWORD,
 180     lpOverlapped: LPWSAOVERLAPPED,
 181     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
 182     lpThreadId: LPWSATHREADID,
 183     lpErrno: LPINT,
 184 ) -> c_int}
 185 FN!{stdcall LPWSPRECVDISCONNECT(
 186     s: SOCKET,
 187     lpInboundDisconnectData: LPWSABUF,
 188     lpErrno: LPINT,
 189 ) -> c_int}
 190 FN!{stdcall LPWSPRECVFROM(
 191     s: SOCKET,
 192     lpBuffers: LPWSABUF,
 193     dwBufferCount: DWORD,
 194     lpNumberOfBytesRecvd: LPDWORD,
 195     lpFlags: LPDWORD,
 196     lpFrom: *mut SOCKADDR,
 197     lpFromlen: LPINT,
 198     lpOverlapped: LPWSAOVERLAPPED,
 199     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
 200     lpThreadId: LPWSATHREADID,
 201     lpErrno: LPINT,
 202 ) -> c_int}
 203 FN!{stdcall LPWSPSELECT(
 204     nfds: c_int,
 205     readfds: *mut fd_set,
 206     writefds: *mut fd_set,
 207     exceptfds: *mut fd_set,
 208     timeout: *const timeval,
 209     lpErrno: LPINT,
 210 ) -> c_int}
 211 FN!{stdcall LPWSPSEND(
 212     s: SOCKET,
 213     lpBuffers: LPWSABUF,
 214     dwBufferCount: DWORD,
 215     lpNumberOfBytesSent: LPDWORD,
 216     dwFlags: DWORD,
 217     lpOverlapped: LPWSAOVERLAPPED,
 218     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
 219     lpThreadId: LPWSATHREADID,
 220     lpErrno: LPINT,
 221 ) -> c_int}
 222 FN!{stdcall LPWSPSENDDISCONNECT(
 223     s: SOCKET,
 224     lpOutboundDisconnectData: LPWSABUF,
 225     lpErrno: LPINT,
 226 ) -> c_int}
 227 FN!{stdcall LPWSPSENDTO(
 228     s: SOCKET,
 229     lpBuffers: LPWSABUF,
 230     dwBufferCount: DWORD,
 231     lpNumberOfBytesSent: LPDWORD,
 232     dwFlags: DWORD,
 233     lpTo: *const SOCKADDR,
 234     iTolen: c_int,
 235     lpOverlapped: LPWSAOVERLAPPED,
 236     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
 237     lpThreadId: LPWSATHREADID,
 238     lpErrno: LPINT,
 239 ) -> c_int}
 240 FN!{stdcall LPWSPSETSOCKOPT(
 241     s: SOCKET,
 242     level: c_int,
 243     optname: c_int,
 244     optval: *const c_char,
 245     optlen: c_int,
 246     lpErrno: LPINT,
 247 ) -> c_int}
 248 FN!{stdcall LPWSPSHUTDOWN(
 249     s: SOCKET,
 250     how: c_int,
 251     lpErrno: LPINT,
 252 ) -> c_int}
 253 FN!{stdcall LPWSPSOCKET(
 254     af: c_int,
 255     _type: c_int,
 256     protocol: c_int,
 257     lpProtocolInfo: LPWSAPROTOCOL_INFOW,
 258     g: GROUP,
 259     dwFlags: DWORD,
 260     lpErrno: LPINT,
 261 ) -> SOCKET}
 262 FN!{stdcall LPWSPSTRINGTOADDRESS(
 263     AddressString: LPWSTR,
 264     AddressFamily: INT,
 265     lpProtocolInfo: LPWSAPROTOCOL_INFOW,
 266     lpAddress: LPSOCKADDR,
 267     lpAddressLength: LPINT,
 268     lpErrno: LPINT,
 269 ) -> c_int}
 270 STRUCT!{struct WSPPROC_TABLE {
 271     lpWSPAccept: LPWSPACCEPT,
 272     lpWSPAddressToString: LPWSPADDRESSTOSTRING,
 273     lpWSPAsyncSelect: LPWSPASYNCSELECT,
 274     lpWSPBind: LPWSPBIND,
 275     lpWSPCancelBlockingCall: LPWSPCANCELBLOCKINGCALL,
 276     lpWSPCleanup: LPWSPCLEANUP,
 277     lpWSPCloseSocket: LPWSPCLOSESOCKET,
 278     lpWSPConnect: LPWSPCONNECT,
 279     lpWSPDuplicateSocket: LPWSPDUPLICATESOCKET,
 280     lpWSPEnumNetworkEvents: LPWSPENUMNETWORKEVENTS,
 281     lpWSPEventSelect: LPWSPEVENTSELECT,
 282     lpWSPGetOverlappedResult: LPWSPGETOVERLAPPEDRESULT,
 283     lpWSPGetPeerName: LPWSPGETPEERNAME,
 284     lpWSPGetSockName: LPWSPGETSOCKNAME,
 285     lpWSPGetSockOpt: LPWSPGETSOCKOPT,
 286     lpWSPGetQOSByName: LPWSPGETQOSBYNAME,
 287     lpWSPIoctl: LPWSPIOCTL,
 288     lpWSPJoinLeaf: LPWSPJOINLEAF,
 289     lpWSPListen: LPWSPLISTEN,
 290     lpWSPRecv: LPWSPRECV,
 291     lpWSPRecvDisconnect: LPWSPRECVDISCONNECT,
 292     lpWSPRecvFrom: LPWSPRECVFROM,
 293     lpWSPSelect: LPWSPSELECT,
 294     lpWSPSend: LPWSPSEND,
 295     lpWSPSendDisconnect: LPWSPSENDDISCONNECT,
 296     lpWSPSendTo: LPWSPSENDTO,
 297     lpWSPSetSockOpt: LPWSPSETSOCKOPT,
 298     lpWSPShutdown: LPWSPSHUTDOWN,
 299     lpWSPSocket: LPWSPSOCKET,
 300     lpWSPStringToAddress: LPWSPSTRINGTOADDRESS,
 301 }}
 302 pub type LPWSPPROC_TABLE = *mut WSPPROC_TABLE;
 303 FN!{stdcall LPWPUCLOSEEVENT(
 304     hEvent: WSAEVENT,
 305     lpErrno: LPINT,
 306 ) -> c_int}
 307 FN!{stdcall LPWPUCLOSESOCKETHANDLE(
 308     s: SOCKET,
 309     lpErrno: LPINT,
 310 ) -> c_int}
 311 FN!{stdcall LPWPUCREATEEVENT(
 312     lpErrno: LPINT,
 313 ) -> WSAEVENT}
 314 FN!{stdcall LPWPUCREATESOCKETHANDLE(
 315     dwCatalogEntryId: DWORD,
 316     dwContext: DWORD_PTR,
 317     lpErrno: LPINT,
 318 ) -> SOCKET}
 319 FN!{stdcall LPWPUFDISSET(
 320     s: SOCKET,
 321     fdset: *mut fd_set,
 322 ) -> c_int}
 323 FN!{stdcall LPWPUGETPROVIDERPATH(
 324     lpProviderId: LPGUID,
 325     lpszProviderDllPath: *mut WCHAR,
 326     lpProviderDllPathLen: LPINT,
 327     lpErrno: LPINT,
 328 ) -> c_int}
 329 FN!{stdcall LPWPUMODIFYIFSHANDLE(
 330     dwCatalogEntryId: DWORD,
 331     ProposedHandle: SOCKET,
 332     lpErrno: LPINT,
 333 ) -> SOCKET}
 334 FN!{stdcall LPWPUPOSTMESSAGE(
 335     hWnd: HWND,
 336     Msg: UINT,
 337     wParam: WPARAM,
 338     lParam: LPARAM,
 339 ) -> BOOL}
 340 FN!{stdcall LPWPUQUERYBLOCKINGCALLBACK(
 341     dwCatalogEntryId: DWORD,
 342     lplpfnCallback: *mut LPBLOCKINGCALLBACK,
 343     lpdwContext: PDWORD_PTR,
 344     lpErrno: LPINT,
 345 ) -> c_int}
 346 FN!{stdcall LPWPUQUERYSOCKETHANDLECONTEXT(
 347     s: SOCKET,
 348     lpContext: PDWORD_PTR,
 349     lpErrno: LPINT,
 350 ) -> c_int}
 351 FN!{stdcall LPWPUQUEUEAPC(
 352     lpThreadId: LPWSATHREADID,
 353     lpfnUserApc: LPWSAUSERAPC,
 354     dwContext: DWORD_PTR,
 355     lpErrno: LPINT,
 356 ) -> c_int}
 357 FN!{stdcall LPWPURESETEVENT(
 358     hEvent: WSAEVENT,
 359     lpErrno: LPINT,
 360 ) -> BOOL}
 361 FN!{stdcall LPWPUSETEVENT(
 362     hEvent: WSAEVENT,
 363     lpErrno: LPINT,
 364 ) -> BOOL}
 365 FN!{stdcall LPWPUOPENCURRENTTHREAD(
 366     lpThreadId: LPWSATHREADID,
 367     lpErrno: LPINT,
 368 ) -> c_int}
 369 FN!{stdcall LPWPUCLOSETHREAD(
 370     lpThreadId: LPWSATHREADID,
 371     lpErrno: LPINT,
 372 ) -> c_int}
 373 FN!{stdcall LPWPUCOMPLETEOVERLAPPEDREQUEST(
 374     s: SOCKET,
 375     lpOverlapped: LPWSAOVERLAPPED,
 376     dwError: DWORD,
 377     cbTransferred: DWORD,
 378     lpErrno: LPINT,
 379 ) -> c_int}
 380 STRUCT!{struct WSPUPCALLTABLE {
 381     lpWPUCloseEvent: LPWPUCLOSEEVENT,
 382     lpWPUCloseSocketHandle: LPWPUCLOSESOCKETHANDLE,
 383     lpWPUCreateEvent: LPWPUCREATEEVENT,
 384     lpWPUCreateSocketHandle: LPWPUCREATESOCKETHANDLE,
 385     lpWPUFDIsSet: LPWPUFDISSET,
 386     lpWPUGetProviderPath: LPWPUGETPROVIDERPATH,
 387     lpWPUModifyIFSHandle: LPWPUMODIFYIFSHANDLE,
 388     lpWPUPostMessage: LPWPUPOSTMESSAGE,
 389     lpWPUQueryBlockingCallback: LPWPUQUERYBLOCKINGCALLBACK,
 390     lpWPUQuerySocketHandleContext: LPWPUQUERYSOCKETHANDLECONTEXT,
 391     lpWPUQueueApc: LPWPUQUEUEAPC,
 392     lpWPUResetEvent: LPWPURESETEVENT,
 393     lpWPUSetEvent: LPWPUSETEVENT,
 394     lpWPUOpenCurrentThread: LPWPUOPENCURRENTTHREAD,
 395     lpWPUCloseThread: LPWPUCLOSETHREAD,
 396 }}
 397 pub type LPWSPUPCALLTABLE = *mut WSPUPCALLTABLE;
 398 extern "system" {
 399     pub fn WSPStartup(
 400         wVersionRequested: WORD,
 401         lpWSPData: LPWSPDATA,
 402         lpProtocolInfo: LPWSAPROTOCOL_INFOW,
 403         UpcallTable: WSPUPCALLTABLE,
 404         lpProcTable: LPWSPPROC_TABLE,
 405     ) -> c_int;
 406 }
 407 FN!{stdcall LPWSPSTARTUP(
 408     wVersionRequested: WORD,
 409     lpWSPData: LPWSPDATA,
 410     lpProtocolInfo: LPWSAPROTOCOL_INFOW,
 411     UpcallTable: WSPUPCALLTABLE,
 412     lpProcTable: LPWSPPROC_TABLE,
 413 ) -> c_int}
 414 extern "system" {
 415     pub fn WSCEnumProtocols(
 416         lpiProtocols: LPINT,
 417         lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
 418         lpdwBufferLength: LPDWORD,
 419         lpErrno: LPINT,
 420     ) -> c_int;
 421 }
 422 FN!{stdcall LPWSCENUMPROTOCOLS(
 423     lpiProtocols: LPINT,
 424     lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
 425     lpdwBufferLength: LPDWORD,
 426     lpErrno: LPINT,
 427 ) -> c_int}
 428 extern "system" {
 429     #[cfg(target_pointer_width = "64")]
 430     pub fn WSCEnumProtocols32(
 431         lpiProtocols: LPINT,
 432         lpProtocolBuffer: LPWSAPROTOCOL_INFOW,
 433         lpdwBufferLength: LPDWORD,
 434         lpErrno: LPINT,
 435     ) -> c_int;
 436     pub fn WSCDeinstallProvider(
 437         lpProviderId: LPGUID,
 438         lpErrno: LPINT,
 439     ) -> c_int;
 440 }
 441 FN!{stdcall LPWSCDEINSTALLPROVIDER(
 442     lpProviderId: LPGUID,
 443     lpErrno: LPINT,
 444 ) -> c_int}
 445 extern "system" {
 446     #[cfg(target_pointer_width = "64")]
 447     pub fn WSCDeinstallProvider32(
 448         lpProviderId: LPGUID,
 449         lpErrno: LPINT,
 450     ) -> c_int;
 451     pub fn WSCInstallProvider(
 452         lpProviderId: LPGUID,
 453         lpszProviderDllPath: *const WCHAR,
 454         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 455         dwNumberOfEntries: DWORD,
 456         lpErrno: LPINT,
 457     ) -> c_int;
 458 }
 459 FN!{stdcall LPWSCINSTALLPROVIDER(
 460     lpProviderId: LPGUID,
 461     lpszProviderDllPath: *const WCHAR,
 462     lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 463     dwNumberOfEntries: DWORD,
 464     lpErrno: LPINT,
 465 ) -> c_int}
 466 extern "system" {
 467     #[cfg(target_pointer_width = "64")]
 468     pub fn WSCInstallProvider64_32(
 469         lpProviderId: LPGUID,
 470         lpszProviderDllPath: *const WCHAR,
 471         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 472         dwNumberOfEntries: DWORD,
 473         lpErrno: LPINT,
 474     ) -> c_int;
 475     pub fn WSCGetProviderPath(
 476         lpProviderId: LPGUID,
 477         lpszProviderDllPath: *mut WCHAR,
 478         lpProviderDllPathLen: LPINT,
 479         lpErrno: LPINT,
 480     ) -> c_int;
 481 }
 482 FN!{stdcall LPWSCGETPROVIDERPATH(
 483     lpProviderId: LPGUID,
 484     lpszProviderDllPath: *mut WCHAR,
 485     lpProviderDllPathLen: LPINT,
 486     lpErrno: LPINT,
 487 ) -> c_int}
 488 extern "system" {
 489     #[cfg(target_pointer_width = "64")]
 490     pub fn WSCGetProviderPath32(
 491         lpProviderId: LPGUID,
 492         lpszProviderDllPath: *mut WCHAR,
 493         lpProviderDllPathLen: LPINT,
 494         lpErrno: LPINT,
 495     ) -> c_int;
 496     pub fn WSCUpdateProvider(
 497         lpProviderId: LPGUID,
 498         lpszProviderDllPath: *const WCHAR,
 499         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 500         dwNumberOfEntries: DWORD,
 501         lpErrno: LPINT,
 502     ) -> c_int;
 503 }
 504 FN!{stdcall LPWSCUPDATEPROVIDER(
 505     lpProviderId: LPGUID,
 506     lpszProviderDllPath: *const WCHAR,
 507     lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 508     dwNumberOfEntries: DWORD,
 509     lpErrno: LPINT,
 510 ) -> c_int}
 511 #[cfg(target_pointer_width = "64")]
 512 extern "system" {
 513     pub fn WSCUpdateProvider32(
 514         lpProviderId: LPGUID,
 515         lpszProviderDllPath: *const WCHAR,
 516         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 517         dwNumberOfEntries: DWORD,
 518         lpErrno: LPINT,
 519     ) -> c_int;
 520 }
 521 pub const LSP_SYSTEM: DWORD = 0x80000000;
 522 pub const LSP_INSPECTOR: DWORD = 0x00000001;
 523 pub const LSP_REDIRECTOR: DWORD = 0x00000002;
 524 pub const LSP_PROXY: DWORD = 0x00000004;
 525 pub const LSP_FIREWALL: DWORD = 0x00000008;
 526 pub const LSP_INBOUND_MODIFY: DWORD = 0x00000010;
 527 pub const LSP_OUTBOUND_MODIFY: DWORD = 0x00000020;
 528 pub const LSP_CRYPTO_COMPRESS: DWORD = 0x00000040;
 529 pub const LSP_LOCAL_CACHE: DWORD = 0x00000080;
 530 ENUM!{enum WSC_PROVIDER_INFO_TYPE {
 531     ProviderInfoLspCategories,
 532     ProviderInfoAudit,
 533 }}
 534 STRUCT!{struct WSC_PROVIDER_AUDIT_INFO {
 535     RecordSize: DWORD,
 536     Reserved: PVOID,
 537 }}
 538 extern "system" {
 539     pub fn WSCSetProviderInfo(
 540         lpProviderId: LPGUID,
 541         InfoType: WSC_PROVIDER_INFO_TYPE,
 542         Info: PBYTE,
 543         InfoSize: size_t,
 544         Flags: DWORD,
 545         lpErrno: LPINT,
 546     ) -> c_int;
 547     pub fn WSCGetProviderInfo(
 548         lpProviderId: LPGUID,
 549         InfoType: WSC_PROVIDER_INFO_TYPE,
 550         Info: PBYTE,
 551         InfoSize: *mut size_t,
 552         Flags: DWORD,
 553         lpErrno: LPINT,
 554     ) -> c_int;
 555     #[cfg(target_pointer_width = "64")]
 556     pub fn WSCSetProviderInfo32(
 557         lpProviderId: LPGUID,
 558         InfoType: WSC_PROVIDER_INFO_TYPE,
 559         Info: PBYTE,
 560         InfoSize: size_t,
 561         Flags: DWORD,
 562         lpErrno: LPINT,
 563     ) -> c_int;
 564     #[cfg(target_pointer_width = "64")]
 565     pub fn WSCGetProviderInfo32(
 566         lpProviderId: LPGUID,
 567         InfoType: WSC_PROVIDER_INFO_TYPE,
 568         Info: PBYTE,
 569         InfoSize: *mut size_t,
 570         Flags: DWORD,
 571         lpErrno: LPINT,
 572     ) -> c_int;
 573     pub fn WSCSetApplicationCategory(
 574         Path: LPCWSTR,
 575         PathLength: DWORD,
 576         Extra: LPCWSTR,
 577         ExtraLength: DWORD,
 578         PermittedLspCategories: DWORD,
 579         pPrevPermLspCat: *mut DWORD,
 580         lpErrno: LPINT,
 581     ) -> c_int;
 582     pub fn WSCGetApplicationCategory(
 583         Path: LPCWSTR,
 584         PathLength: DWORD,
 585         Extra: LPCWSTR,
 586         ExtraLength: DWORD,
 587         pPermittedLspCategories: *mut DWORD,
 588         lpErrno: LPINT,
 589     ) -> c_int;
 590     pub fn WPUCloseEvent(
 591         hEvent: WSAEVENT,
 592         lpErrno: LPINT,
 593     ) -> BOOL;
 594     pub fn WPUCloseSocketHandle(
 595         s: SOCKET,
 596         lpErrno: LPINT,
 597     ) -> c_int;
 598     pub fn WPUCreateEvent(
 599         lpErrno: LPINT,
 600     ) -> WSAEVENT;
 601     pub fn WPUCreateSocketHandle(
 602         dwCatalogEntryId: DWORD,
 603         dwContext: DWORD_PTR,
 604         lpErrno: LPINT,
 605     ) -> SOCKET;
 606     pub fn WPUFDIsSet(
 607         s: SOCKET,
 608         fdset: *mut fd_set,
 609     ) -> c_int;
 610     pub fn WPUGetProviderPath(
 611         lpProviderId: LPGUID,
 612         lpszProviderDllPath: *mut WCHAR,
 613         lpProviderDllPathLen: LPINT,
 614         lpErrno: LPINT,
 615     ) -> c_int;
 616     pub fn WPUModifyIFSHandle(
 617         dwCatalogEntryId: DWORD,
 618         ProposedHandle: SOCKET,
 619         lpErrno: LPINT,
 620     ) -> SOCKET;
 621     pub fn WPUPostMessage(
 622         hWnd: HWND,
 623         Msg: UINT,
 624         wParam: WPARAM,
 625         lParam: LPARAM,
 626     ) -> BOOL;
 627     pub fn WPUQueryBlockingCallback(
 628         dwCatalogEntryId: DWORD,
 629         lplpfnCallback: *mut LPBLOCKINGCALLBACK,
 630         lpdwContext: PDWORD_PTR,
 631         lpErrno: LPINT,
 632     ) -> c_int;
 633     pub fn WPUQuerySocketHandleContext(
 634         s: SOCKET,
 635         lpContext: PDWORD_PTR,
 636         lpErrno: LPINT,
 637     ) -> c_int;
 638     pub fn WPUQueueApc(
 639         lpThreadId: LPWSATHREADID,
 640         lpfnUserApc: LPWSAUSERAPC,
 641         dwContext: DWORD_PTR,
 642         lpErrno: LPINT,
 643     ) -> c_int;
 644     pub fn WPUResetEvent(
 645         hEvent: WSAEVENT,
 646         lpErrno: LPINT,
 647     ) -> BOOL;
 648     pub fn WPUSetEvent(
 649         hEvent: WSAEVENT,
 650         lpErrno: LPINT,
 651     ) -> BOOL;
 652     pub fn WPUCompleteOverlappedRequest(
 653         s: SOCKET,
 654         lpOverlapped: LPWSAOVERLAPPED,
 655         dwError: DWORD,
 656         cbTransferred: DWORD,
 657         lpErrno: LPINT,
 658     ) -> c_int;
 659     pub fn WPUOpenCurrentThread(
 660         lpThreadId: LPWSATHREADID,
 661         lpErrno: LPINT,
 662     ) -> c_int;
 663     pub fn WPUCloseThread(
 664         lpThreadId: LPWSATHREADID,
 665         lpErrno: LPINT,
 666     ) -> c_int;
 667     #[cfg(target_pointer_width = "64")]
 668     pub fn WSCEnumNameSpaceProviders32(
 669         lpdwBufferLength: LPDWORD,
 670         lpnspBuffer: LPWSANAMESPACE_INFOW,
 671     ) -> INT;
 672     #[cfg(target_pointer_width = "64")]
 673     pub fn WSCEnumNameSpaceProvidersEx32(
 674         lpdwBufferLength: LPDWORD,
 675         lpnspBuffer: LPWSANAMESPACE_INFOEXW,
 676     ) -> INT;
 677     pub fn WSCInstallNameSpace(
 678         lpszIdentifier: LPWSTR,
 679         lpszPathName: LPWSTR,
 680         dwNameSpace: DWORD,
 681         dwVersion: DWORD,
 682         lpProviderId: LPGUID,
 683     ) -> INT;
 684 }
 685 FN!{stdcall LPWSCINSTALLNAMESPACE(
 686     lpszIdentifier: LPWSTR,
 687     lpszPathName: LPWSTR,
 688     dwNameSpace: DWORD,
 689     dwVersion: DWORD,
 690     lpProviderId: LPGUID,
 691 ) -> INT}
 692 extern "system" {
 693     #[cfg(target_pointer_width = "64")]
 694     pub fn WSCInstallNameSpace32(
 695         lpszIdentifier: LPWSTR,
 696         lpszPathName: LPWSTR,
 697         dwNameSpace: DWORD,
 698         dwVersion: DWORD,
 699         lpProviderId: LPGUID,
 700     ) -> INT;
 701     pub fn WSCUnInstallNameSpace(
 702         lpProviderId: LPGUID,
 703     ) -> INT;
 704 }
 705 FN!{stdcall LPWSCUNINSTALLNAMESPACE(
 706     lpProviderId: LPGUID,
 707 ) -> INT}
 708 extern "system" {
 709     pub fn WSCInstallNameSpaceEx(
 710         lpszIdentifier: LPWSTR,
 711         lpszPathName: LPWSTR,
 712         dwNameSpace: DWORD,
 713         dwVersion: DWORD,
 714         lpProviderId: LPGUID,
 715         lpProviderSpecific: LPBLOB,
 716     ) -> INT;
 717     #[cfg(target_pointer_width = "64")]
 718     pub fn WSCInstallNameSpaceEx32(
 719         lpszIdentifier: LPWSTR,
 720         lpszPathName: LPWSTR,
 721         dwNameSpace: DWORD,
 722         dwVersion: DWORD,
 723         lpProviderId: LPGUID,
 724         lpProviderSpecific: LPBLOB,
 725     ) -> INT;
 726     #[cfg(target_pointer_width = "64")]
 727     pub fn WSCUnInstallNameSpace32(
 728         lpProviderId: LPGUID,
 729     ) -> INT;
 730     pub fn WSCEnableNSProvider(
 731         lpProviderId: LPGUID,
 732         fEnable: BOOL,
 733     ) -> INT;
 734 }
 735 FN!{stdcall LPWSCENABLENSPROVIDER(
 736     lpProviderId: LPGUID,
 737     fEnable: BOOL,
 738 ) -> INT}
 739 extern "system" {
 740     #[cfg(target_pointer_width = "64")]
 741     pub fn WSCEnableNSProvider32(
 742         lpProviderId: LPGUID,
 743         fEnable: BOOL,
 744     ) -> INT;
 745     #[cfg(target_pointer_width = "64")]
 746     pub fn WSCInstallProviderAndChains64_32(
 747         lpProviderId: LPGUID,
 748         lpszProviderDllPath: LPWSTR,
 749         lpszProviderDllPath32: LPWSTR,
 750         lpszLspName: LPWSTR,
 751         dwServiceFlags: DWORD,
 752         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 753         dwNumberOfEntries: DWORD,
 754         lpdwCatalogEntryId: LPDWORD,
 755         lpErrno: LPINT,
 756     ) -> c_int;
 757     #[cfg(target_pointer_width = "32")]
 758     pub fn WSCInstallProviderAndChains(
 759         lpProviderId: LPGUID,
 760         lpszProviderDllPath: LPWSTR,
 761         lpszLspName: LPWSTR,
 762         dwServiceFlags: DWORD,
 763         lpProtocolInfoList: LPWSAPROTOCOL_INFOW,
 764         dwNumberOfEntries: DWORD,
 765         lpdwCatalogEntryId: LPDWORD,
 766         lpErrno: LPINT,
 767     ) -> c_int;
 768 }
 769 FN!{stdcall LPNSPCLEANUP(
 770     lpProviderId: LPGUID,
 771 ) -> INT}
 772 FN!{stdcall LPNSPLOOKUPSERVICEBEGIN(
 773     lpProviderId: LPGUID,
 774     lpqsRestrictions: LPWSAQUERYSETW,
 775     lpServiceClassInfo: LPWSASERVICECLASSINFOW,
 776     dwControlFlags: DWORD,
 777     lphLookup: LPHANDLE,
 778 ) -> INT}
 779 FN!{stdcall LPNSPLOOKUPSERVICENEXT(
 780     hLookup: HANDLE,
 781     dwControlFlags: DWORD,
 782     lpdwBufferLength: LPDWORD,
 783     lpqsResults: LPWSAQUERYSETW,
 784 ) -> INT}
 785 FN!{stdcall LPNSPIOCTL(
 786     hLookup: HANDLE,
 787     dwControlCode: DWORD,
 788     lpvInBuffer: LPVOID,
 789     cbInBuffer: DWORD,
 790     lpvOutBuffer: LPVOID,
 791     cbOutBuffer: DWORD,
 792     lpcbBytesReturned: LPDWORD,
 793     lpCompletion: LPWSACOMPLETION,
 794     lpThreadId: LPWSATHREADID,
 795 ) -> INT}
 796 FN!{stdcall LPNSPLOOKUPSERVICEEND(
 797     hLookup: HANDLE,
 798 ) -> INT}
 799 FN!{stdcall LPNSPSETSERVICE(
 800     lpProviderId: LPGUID,
 801     lpServiceClassInfo: LPWSASERVICECLASSINFOW,
 802     lpqsRegInfo: LPWSAQUERYSETW,
 803     essOperation: WSAESETSERVICEOP,
 804     dwControlFlags: DWORD,
 805 ) -> INT}
 806 FN!{stdcall LPNSPINSTALLSERVICECLASS(
 807     lpProviderId: LPGUID,
 808     lpServiceClassInfo: LPWSASERVICECLASSINFOW,
 809 ) -> INT}
 810 FN!{stdcall LPNSPREMOVESERVICECLASS(
 811     lpProviderId: LPGUID,
 812     lpServiceClassId: LPGUID,
 813 ) -> INT}
 814 FN!{stdcall LPNSPGETSERVICECLASSINFO(
 815     lpProviderId: LPGUID,
 816     lpdwBufSize: LPDWORD,
 817     lpServiceClassInfo: LPWSASERVICECLASSINFOW,
 818 ) -> INT}
 819 STRUCT!{struct NSP_ROUTINE {
 820     cbSize: DWORD,
 821     dwMajorVersion: DWORD,
 822     dwMinorVersion: DWORD,
 823     NSPCleanup: LPNSPCLEANUP,
 824     NSPLookupServiceBegin: LPNSPLOOKUPSERVICEBEGIN,
 825     NSPLookupServiceNext: LPNSPLOOKUPSERVICENEXT,
 826     NSPLookupServiceEnd: LPNSPLOOKUPSERVICEEND,
 827     NSPSetService: LPNSPSETSERVICE,
 828     NSPInstallServiceClass: LPNSPINSTALLSERVICECLASS,
 829     NSPRemoveServiceClass: LPNSPREMOVESERVICECLASS,
 830     NSPGetServiceClassInfo: LPNSPGETSERVICECLASSINFO,
 831     NSPIoctl: LPNSPIOCTL,
 832 }}
 833 pub type LPNSP_ROUTINE = *mut NSP_ROUTINE;
 834 extern "system" {
 835     pub fn NSPStartup(
 836         lpProviderId: LPGUID,
 837         lpnspRoutines: LPNSP_ROUTINE,
 838     ) -> INT;
 839 }
 840 FN!{stdcall LPNSPSTARTUP(
 841     lpProviderId: LPGUID,
 842     lpnspRoutines: LPNSP_ROUTINE,
 843 ) -> INT}
 844 FN!{stdcall LPNSPV2STARTUP(
 845     lpProviderId: LPGUID,
 846     ppvClientSessionArg: *mut LPVOID,
 847 ) -> INT}
 848 FN!{stdcall LPNSPV2CLEANUP(
 849     lpProviderId: LPGUID,
 850     pvClientSessionArg: LPVOID,
 851 ) -> INT}
 852 FN!{stdcall LPNSPV2LOOKUPSERVICEBEGIN(
 853     lpProviderId: LPGUID,
 854     lpqsRestrictions: LPWSAQUERYSET2W,
 855     dwControlFlags: DWORD,
 856     lpvClientSessionArg: LPVOID,
 857     lphLookup: LPHANDLE,
 858 ) -> INT}
 859 FN!{stdcall LPNSPV2LOOKUPSERVICENEXTEX(
 860     hAsyncCall: HANDLE,
 861     hLookup: HANDLE,
 862     dwControlFlags: DWORD,
 863     lpdwBufferLength: LPDWORD,
 864     lpqsResults: LPWSAQUERYSET2W,
 865 ) -> ()}
 866 FN!{stdcall LPNSPV2LOOKUPSERVICEEND(
 867     hLookup: HANDLE,
 868 ) -> INT}
 869 FN!{stdcall LPNSPV2SETSERVICEEX(
 870     hAsyncCall: HANDLE,
 871     lpProviderId: LPGUID,
 872     lpqsRegInfo: LPWSAQUERYSET2W,
 873     essOperation: WSAESETSERVICEOP,
 874     dwControlFlags: DWORD,
 875     lpvClientSessionArg: LPVOID,
 876 ) -> ()}
 877 FN!{stdcall LPNSPV2CLIENTSESSIONRUNDOWN(
 878     lpProviderId: LPGUID,
 879     pvClientSessionArg: LPVOID,
 880 ) -> ()}
 881 STRUCT!{struct NSPV2_ROUTINE {
 882     cbSize: DWORD,
 883     dwMajorVersion: DWORD,
 884     dwMinorVersion: DWORD,
 885     NSPv2Startup: LPNSPV2STARTUP,
 886     NSPv2Cleanup: LPNSPV2CLEANUP,
 887     NSPv2LookupServiceBegin: LPNSPV2LOOKUPSERVICEBEGIN,
 888     NSPv2LookupServiceNextEx: LPNSPV2LOOKUPSERVICENEXTEX,
 889     NSPv2LookupServiceEnd: LPNSPV2LOOKUPSERVICEEND,
 890     NSPv2SetServiceEx: LPNSPV2SETSERVICEEX,
 891     NSPv2ClientSessionRundown: LPNSPV2CLIENTSESSIONRUNDOWN,
 892 }}
 893 pub type PNSPV2_ROUTINE = *mut NSPV2_ROUTINE;
 894 pub type LPNSPV2_ROUTINE = *mut NSPV2_ROUTINE;
 895 pub type PCNSPV2_ROUTINE = *const NSPV2_ROUTINE;
 896 pub type LPCNSPV2_ROUTINE = *const NSPV2_ROUTINE;
 897 extern "system" {
 898     pub fn WSAAdvertiseProvider(
 899         puuidProviderId: *const GUID,
 900         pNSPv2Routine: *const LPCNSPV2_ROUTINE,
 901     ) -> INT;
 902     pub fn WSAUnadvertiseProvider(
 903         puuidProviderId: *const GUID,
 904     ) -> INT;
 905     pub fn WSAProviderCompleteAsyncCall(
 906         hAsyncCall: HANDLE,
 907         iRetCode: INT,
 908     ) -> INT;
 909 }