Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 346 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/ws2tcpip.rs b/vendor/winapi/src/um/ws2tcpip.rs
new file mode 100644
index 0000000..4867c74
--- /dev/null
+++ b/vendor/winapi/src/um/ws2tcpip.rs
@@ -0,0 +1,346 @@
+// 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
+//! WinSock2 Extension for TCP/IP protocols
+use ctypes::c_int;
+use shared::guiddef::LPGUID;
+use shared::minwindef::{DWORD, INT, LPHANDLE, ULONG};
+use shared::mstcpip::{
+    SOCKET_PEER_TARGET_NAME, SOCKET_SECURITY_QUERY_INFO, SOCKET_SECURITY_QUERY_TEMPLATE,
+    SOCKET_SECURITY_SETTINGS,
+};
+use shared::winerror::{
+    WSAEAFNOSUPPORT, WSAEINVAL, WSAESOCKTNOSUPPORT, WSAHOST_NOT_FOUND, WSANO_RECOVERY,
+    WSATRY_AGAIN, WSATYPE_NOT_FOUND, WSA_IPSEC_NAME_POLICY_ERROR, WSA_SECURE_HOST_NOT_FOUND,
+};
+use shared::ws2def::{
+    ADDRINFOA, ADDRINFOEXA, ADDRINFOEXW, ADDRINFOW, PADDRINFOA, PADDRINFOEXA, PADDRINFOEXW,
+    PADDRINFOW, SOCKADDR, SOCKET_ADDRESS,
+};
+use shared::wtypesbase::LPBLOB;
+use um::minwinbase::LPOVERLAPPED;
+use um::winnt::{PCHAR, PCSTR, PCWSTR, PSTR, PVOID, PWCHAR, PWSTR, VOID};
+use um::winsock2::{
+    LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE, SOCKET, WSA_NOT_ENOUGH_MEMORY, timeval,
+};
+use vc::vcruntime::size_t;
+pub const UDP_NOCHECKSUM: c_int = 1;
+pub const UDP_CHECKSUM_COVERAGE: c_int = 20;
+pub const EAI_AGAIN: DWORD = WSATRY_AGAIN;
+pub const EAI_BADFLAGS: DWORD = WSAEINVAL;
+pub const EAI_FAIL: DWORD = WSANO_RECOVERY;
+pub const EAI_FAMILY: DWORD = WSAEAFNOSUPPORT;
+pub const EAI_MEMORY: DWORD = WSA_NOT_ENOUGH_MEMORY as u32;
+pub const EAI_NOSECURENAME: DWORD = WSA_SECURE_HOST_NOT_FOUND;
+pub const EAI_NONAME: DWORD = WSAHOST_NOT_FOUND;
+pub const EAI_SERVICE: DWORD = WSATYPE_NOT_FOUND;
+pub const EAI_SOCKTYPE: DWORD = WSAESOCKTNOSUPPORT;
+pub const EAI_IPSECPOLICY: DWORD = WSA_IPSEC_NAME_POLICY_ERROR;
+pub const EAI_NODATA: DWORD = EAI_NONAME;
+pub type ADDRINFO = ADDRINFOA;
+pub type LPADDRINFO = *mut ADDRINFOA;
+extern "system" {
+    pub fn getaddrinfo(
+        pNodeName: PCSTR,
+        pServiceName: PCSTR,
+        pHints: *const ADDRINFOA,
+        ppResult: *mut PADDRINFOA,
+    ) -> INT;
+    pub fn GetAddrInfoW(
+        pNodeName: PCWSTR,
+        pServiceName: PCWSTR,
+        pHints: *const ADDRINFOW,
+        ppResult: *mut PADDRINFOW,
+    ) -> INT;
+}
+FN!{stdcall LPFN_GETADDRINFO(
+    pNodeName: PCSTR,
+    pServiceName: PCSTR,
+    pHints: *const ADDRINFOA,
+    ppResult: *mut PADDRINFOA,
+) -> INT}
+FN!{stdcall LPFN_GETADDRINFOW(
+    pNodeName: PCWSTR,
+    pServiceName: PCWSTR,
+    pHints: *const ADDRINFOW,
+    ppResult: *mut PADDRINFOW,
+) -> INT}
+FN!{stdcall LPLOOKUPSERVICE_COMPLETION_ROUTINE(
+    dwError: DWORD,
+    dwBytes: DWORD,
+    lpOverlapped: LPWSAOVERLAPPED,
+) -> ()}
+extern "system" {
+    pub fn GetAddrInfoExA(
+        pName: PCSTR,
+        pServiceName: PCSTR,
+        dwNameSpace: DWORD,
+        lpNspId: LPGUID,
+        hints: *const ADDRINFOEXA,
+        ppResult: *mut PADDRINFOEXA,
+        timeout: *mut timeval,
+        lpOverlapped: LPOVERLAPPED,
+        lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+        lpNameHandle: LPHANDLE,
+    ) -> INT;
+    pub fn GetAddrInfoExW(
+        pName: PCWSTR,
+        pServiceName: PCWSTR,
+        dwNameSpace: DWORD,
+        lpNspId: LPGUID,
+        hints: *const ADDRINFOEXW,
+        ppResult: *mut PADDRINFOEXW,
+        timeout: *mut timeval,
+        lpOverlapped: LPOVERLAPPED,
+        lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+        lpNameHandle: LPHANDLE,
+    ) -> INT;
+    pub fn GetAddrInfoExCancel(
+        lpHandle: LPHANDLE,
+    ) -> INT;
+    pub fn GetAddrInfoExOverlappedResult(
+        lpOverlapped: LPOVERLAPPED,
+    ) -> INT;
+}
+FN!{stdcall LPFN_GETADDRINFOEXA(
+    pName: PCSTR,
+    pServiceName: PCSTR,
+    dwNameSpace: DWORD,
+    lpNspId: LPGUID,
+    hints: *const ADDRINFOEXA,
+    ppResult: *mut PADDRINFOEXA,
+    timeout: *mut timeval,
+    lpOverlapped: LPOVERLAPPED,
+    lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+    lpNameHandle: LPHANDLE,
+) -> INT}
+FN!{stdcall LPFN_GETADDRINFOEXW(
+    pName: PCWSTR,
+    pServiceName: PCWSTR,
+    dwNameSpace: DWORD,
+    lpNspId: LPGUID,
+    hints: *const ADDRINFOEXW,
+    ppResult: *mut PADDRINFOEXW,
+    timeout: *mut timeval,
+    lpOverlapped: LPOVERLAPPED,
+    lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+    lpNameHandle: LPHANDLE,
+) -> INT}
+FN!{stdcall LPFN_GETADDRINFOEXCANCEL(
+    lpHandle: LPHANDLE,
+) -> INT}
+FN!{stdcall LPFN_GETADDRINFOEXOVERLAPPEDRESULT(
+    lpOverlapped: LPOVERLAPPED,
+) -> INT}
+extern "system" {
+    pub fn SetAddrInfoExA(
+        pName: PCSTR,
+        pServiceName: PCSTR,
+        pAddresses: *mut SOCKET_ADDRESS,
+        dwAddressCount: DWORD,
+        lpBlob: LPBLOB,
+        dwFlags: DWORD,
+        dwNameSpace: DWORD,
+        lpNspId: LPGUID,
+        timeout: *mut timeval,
+        lpOverlapped: LPOVERLAPPED,
+        lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+        lpNameHandle: LPHANDLE,
+    ) -> INT;
+    pub fn SetAddrInfoExW(
+        pName: PCWSTR,
+        pServiceName: PCWSTR,
+        pAddresses: *mut SOCKET_ADDRESS,
+        dwAddressCount: DWORD,
+        lpBlob: LPBLOB,
+        dwFlags: DWORD,
+        dwNameSpace: DWORD,
+        lpNspId: LPGUID,
+        timeout: *mut timeval,
+        lpOverlapped: LPOVERLAPPED,
+        lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+        lpNameHandle: LPHANDLE,
+    ) -> INT;
+}
+FN!{stdcall LPFN_SETADDRINFOEXA(
+    pName: PCSTR,
+    pServiceName: PCSTR,
+    pAddresses: *mut SOCKET_ADDRESS,
+    dwAddressCount: DWORD,
+    lpBlob: LPBLOB,
+    dwFlags: DWORD,
+    dwNameSpace: DWORD,
+    lpNspId: LPGUID,
+    timeout: *mut timeval,
+    lpOverlapped: LPOVERLAPPED,
+    lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+    lpNameHandle: LPHANDLE,
+) -> INT}
+FN!{stdcall LPFN_SETADDRINFOEXW(
+    pName: PCWSTR,
+    pServiceName: PCWSTR,
+    pAddresses: *mut SOCKET_ADDRESS,
+    dwAddressCount: DWORD,
+    lpBlob: LPBLOB,
+    dwFlags: DWORD,
+    dwNameSpace: DWORD,
+    lpNspId: LPGUID,
+    timeout: *mut timeval,
+    lpOverlapped: LPOVERLAPPED,
+    lpCompletionRoutine: LPLOOKUPSERVICE_COMPLETION_ROUTINE,
+    lpNameHandle: LPHANDLE,
+) -> INT}
+extern "system" {
+    pub fn freeaddrinfo(
+        pAddrInfo: PADDRINFOA,
+    );
+    pub fn FreeAddrInfoW(
+        pAddrInfo: PADDRINFOW,
+    );
+}
+FN!{stdcall LPFN_FREEADDRINFO(
+    pAddrInfo: PADDRINFOA,
+) -> ()}
+FN!{stdcall LPFN_FREEADDRINFOW(
+    pAddrInfo: PADDRINFOW,
+) -> ()}
+extern "system" {
+    pub fn FreeAddrInfoEx(
+        pAddrInfoEx: PADDRINFOEXA,
+    );
+    pub fn FreeAddrInfoExW(
+        pAddrInfoEx: PADDRINFOEXW,
+    );
+}
+FN!{stdcall LPFN_FREEADDRINFOEXA(
+    pAddrInfoEx: PADDRINFOEXA,
+) -> ()}
+FN!{stdcall LPFN_FREEADDRINFOEXW(
+    pAddrInfoEx: PADDRINFOEXW,
+) -> ()}
+pub type socklen_t = c_int;
+extern "system" {
+    pub fn getnameinfo(
+        pSockaddr: *const SOCKADDR,
+        SockaddrLength: socklen_t,
+        pNodeBuffer: PCHAR,
+        NodeBufferSize: DWORD,
+        pServiceBuffer: PCHAR,
+        ServiceBufferSize: DWORD,
+        Flags: INT,
+    ) -> INT;
+    pub fn GetNameInfoW(
+        pSockaddr: *const SOCKADDR,
+        SockaddrLength: socklen_t,
+        pNodeBuffer: PWCHAR,
+        NodeBufferSize: DWORD,
+        pServiceBuffer: PWCHAR,
+        ServiceBufferSize: DWORD,
+        Flags: INT,
+    ) -> INT;
+}
+FN!{stdcall LPFN_GETNAMEINFO(
+    pSockaddr: *const SOCKADDR,
+    SockaddrLength: socklen_t,
+    pNodeBuffer: PCHAR,
+    NodeBufferSize: DWORD,
+    pServiceBuffer: PCHAR,
+    ServiceBufferSize: DWORD,
+    Flags: INT,
+) -> c_int}
+FN!{stdcall LPFN_GETNAMEINFOW(
+    pSockaddr: *const SOCKADDR,
+    SockaddrLength: socklen_t,
+    pNodeBuffer: PWCHAR,
+    NodeBufferSize: DWORD,
+    pServiceBuffer: PWCHAR,
+    ServiceBufferSize: DWORD,
+    Flags: INT,
+) -> INT}
+extern "system" {
+    pub fn inet_pton(
+        Family: INT,
+        pszAddrString: PCSTR,
+        pAddrBuf: PVOID,
+    ) -> INT;
+    pub fn InetPtonW(
+        Family: INT,
+        pszAddrString: PCWSTR,
+        pAddrBuf: PVOID,
+    ) -> INT;
+    pub fn inet_ntop(
+        Family: INT,
+        pAddr: *const VOID,
+        pStringBuf: PSTR,
+        StringBufSize: size_t,
+    ) -> PCSTR;
+    pub fn InetNtopW(
+        Family: INT,
+        pAddr: *const VOID,
+        pStringBuf: PWSTR,
+        StringBufSize: size_t,
+    ) -> PCWSTR;
+}
+FN!{stdcall LPFN_INET_PTONA(
+    Family: INT,
+    pszAddrString: PCSTR,
+    pAddrBuf: PVOID,
+) -> INT}
+FN!{stdcall LPFN_INET_PTONW(
+    Family: INT,
+    pszAddrString: PCWSTR,
+    pAddrBuf: PVOID,
+) -> INT}
+FN!{stdcall LPFN_INET_NTOPA(
+    Family: INT,
+    pAddr: *const VOID,
+    pStringBuf: PSTR,
+    StringBufSize: size_t,
+) -> PCSTR}
+FN!{stdcall LPFN_INET_NTOPW(
+    Family: INT,
+    pAddr: *const VOID,
+    pStringBuf: PWSTR,
+    StringBufSize: size_t,
+) -> PCWSTR}
+pub const GAI_STRERROR_BUFFER_SIZE: usize = 1024;
+extern "system" {
+    pub fn WSASetSocketSecurity(
+        Socket: SOCKET,
+        SecuritySettings: *const SOCKET_SECURITY_SETTINGS,
+        SecuritySettingsLen: ULONG,
+        Overlapped: LPWSAOVERLAPPED,
+        CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
+    ) -> INT;
+    pub fn WSAQuerySocketSecurity(
+        Socket: SOCKET,
+        SecurityQueryTemplate: *const SOCKET_SECURITY_QUERY_TEMPLATE,
+        SecurityQueryTemplateLen: ULONG,
+        SecurityQueryInfo: *mut SOCKET_SECURITY_QUERY_INFO,
+        SecurityQueryInfoLen: *mut ULONG,
+        Overlapped: LPWSAOVERLAPPED,
+        CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
+    ) -> INT;
+    pub fn WSASetSocketPeerTargetName(
+        Socket: SOCKET,
+        PeerTargetName: *const SOCKET_PEER_TARGET_NAME,
+        PeerTargetNameLen: ULONG,
+        Overlapped: LPWSAOVERLAPPED,
+        CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
+    ) -> INT;
+    pub fn WSADeleteSocketPeerTargetName(
+        Socket: SOCKET,
+        PeerAddr: *const SOCKADDR,
+        PeerAddrLen: ULONG,
+        Overlapped: LPWSAOVERLAPPED,
+        CompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
+    ) -> INT;
+    pub fn WSAImpersonateSocketPeer(
+        Socket: SOCKET,
+        PeerAddr: *const SOCKADDR,
+        PeerAddrLen: ULONG,
+    ) -> INT;
+    pub fn WSARevertImpersonation();
+}