| // 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 2 DLL and WinSock 2 applications. |
| use ctypes::{ |
| __uint32, __uint64, c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, |
| c_ulong, c_ushort, |
| }; |
| use shared::basetsd::{DWORD_PTR, UINT_PTR, ULONG_PTR}; |
| use shared::guiddef::{GUID, LPGUID}; |
| use shared::inaddr::in_addr; |
| use shared::minwindef::{ |
| BOOL, DWORD, FARPROC, HIWORD, INT, LOWORD, LPDWORD, LPHANDLE, LPINT, LPVOID, MAKELONG, UINT, |
| ULONG, WORD, WPARAM, |
| }; |
| use shared::qos::FLOWSPEC; |
| use shared::windef::HWND; |
| use shared::winerror::{ |
| ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_IO_INCOMPLETE, ERROR_IO_PENDING, |
| ERROR_NOT_ENOUGH_MEMORY, ERROR_OPERATION_ABORTED, WAIT_TIMEOUT, |
| }; |
| use shared::ws2def::{ |
| AF_APPLETALK, AF_ATM, AF_BAN, AF_BTH, AF_CCITT, AF_CHAOS, AF_DATAKIT, AF_DECnet, AF_DLI, |
| AF_ECMA, AF_FIREFOX, AF_HYLINK, AF_IMPLINK, AF_INET, AF_INET6, AF_IPX, AF_ISO, AF_LAT, |
| AF_MAX, AF_NS, AF_OSI, AF_PUP, AF_SNA, AF_UNIX, AF_UNKNOWN1, AF_UNSPEC, AF_VOICEVIEW, |
| INADDR_ANY, LPCSADDR_INFO, LPSOCKADDR, LPWSABUF, LPWSAMSG, PSOCKET_ADDRESS_LIST, SOCKADDR, |
| SOCKADDR_IN, WSABUF, |
| }; |
| use shared::wtypesbase::{BLOB, LPBLOB}; |
| use um::minwinbase::OVERLAPPED; |
| use um::winbase::{INFINITE, WAIT_FAILED, WAIT_IO_COMPLETION, WAIT_OBJECT_0}; |
| use um::winnt::{ |
| CHAR, HANDLE, LONG, LPCSTR, LPSTR, LPWSTR, MAXIMUM_WAIT_OBJECTS, PWSTR, SHORT, WCHAR, |
| }; |
| pub const WINSOCK_VERSION: WORD = 2 | (2 << 8); |
| pub type u_char = c_uchar; |
| pub type u_short = c_ushort; |
| pub type u_int = c_uint; |
| pub type u_long = c_ulong; |
| pub type u_int64 = __uint64; |
| pub type SOCKET = UINT_PTR; |
| pub const FD_SETSIZE: usize = 64; |
| STRUCT!{struct fd_set { |
| fd_count: u_int, |
| fd_array: [SOCKET; FD_SETSIZE], |
| }} |
| extern "system" { |
| pub fn __WSAFDIsSet( |
| fd: SOCKET, |
| _: *mut fd_set, |
| ) -> c_int; |
| } |
| STRUCT!{struct timeval { |
| tv_sec: c_long, |
| tv_usec: c_long, |
| }} |
| pub const IOCPARM_MASK: c_long = 0x7f; |
| pub const IOC_VOID: c_long = 0x20000000; |
| pub const IOC_OUT: c_long = 0x40000000; |
| pub const IOC_IN: c_long = 0x80000000; |
| pub const IOC_INOUT: c_long = IOC_IN | IOC_OUT; |
| pub const FIONREAD: c_long = IOC_OUT | ((4 & IOCPARM_MASK) << 16) | (0x66 << 8) | 127; |
| pub const FIONBIO: c_long = IOC_IN | ((4 & IOCPARM_MASK) << 16) | (0x66 << 8) | 126; |
| pub const FIOASYNC: c_long = IOC_IN | ((4 & IOCPARM_MASK) << 16) | (0x66 << 8) | 125; |
| pub const SIOCSHIWAT: c_long = IOC_IN | ((4 & IOCPARM_MASK) << 16) | (0x73 << 8) | 0; |
| pub const SIOCGHIWAT: c_long = IOC_OUT | ((4 & IOCPARM_MASK) << 16) | (0x73 << 8) | 1; |
| pub const SIOCSLOWAT: c_long = IOC_IN | ((4 & IOCPARM_MASK) << 16) | (0x73 << 8) | 2; |
| pub const SIOCGLOWAT: c_long = IOC_OUT | ((4 & IOCPARM_MASK) << 16) | (0x73 << 8) | 3; |
| pub const SIOCATMARK: c_long = IOC_OUT | ((4 & IOCPARM_MASK) << 16) | (0x73 << 8) | 7; |
| STRUCT!{struct hostent { |
| h_name: *mut c_char, |
| h_aliases: *mut *mut c_char, |
| h_addrtype: c_short, |
| h_length: c_short, |
| h_addr_list: *mut *mut c_char, |
| }} |
| STRUCT!{struct netent { |
| n_name: *mut c_char, |
| n_aliases: *mut *mut c_char, |
| n_addrtype: c_short, |
| n_net: u_long, |
| }} |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct servent { |
| s_name: *mut c_char, |
| s_aliases: *mut *mut c_char, |
| s_port: c_short, |
| s_proto: *mut c_char, |
| }} |
| #[cfg(target_pointer_width = "64")] |
| STRUCT!{struct servent { |
| s_name: *mut c_char, |
| s_aliases: *mut *mut c_char, |
| s_proto: *mut c_char, |
| s_port: c_short, |
| }} |
| STRUCT!{struct protoent { |
| p_name: *mut c_char, |
| p_aliases: *mut *mut c_char, |
| p_proto: c_short, |
| }} |
| pub const IPPORT_ECHO: c_short = 7; |
| pub const IPPORT_DISCARD: c_short = 9; |
| pub const IPPORT_SYSTAT: c_short = 11; |
| pub const IPPORT_DAYTIME: c_short = 13; |
| pub const IPPORT_NETSTAT: c_short = 15; |
| pub const IPPORT_FTP: c_short = 21; |
| pub const IPPORT_TELNET: c_short = 23; |
| pub const IPPORT_SMTP: c_short = 25; |
| pub const IPPORT_TIMESERVER: c_short = 37; |
| pub const IPPORT_NAMESERVER: c_short = 42; |
| pub const IPPORT_WHOIS: c_short = 43; |
| pub const IPPORT_MTP: c_short = 57; |
| pub const IPPORT_TFTP: c_short = 69; |
| pub const IPPORT_RJE: c_short = 77; |
| pub const IPPORT_FINGER: c_short = 79; |
| pub const IPPORT_TTYLINK: c_short = 87; |
| pub const IPPORT_SUPDUP: c_short = 95; |
| pub const IPPORT_EXECSERVER: c_short = 512; |
| pub const IPPORT_LOGINSERVER: c_short = 513; |
| pub const IPPORT_CMDSERVER: c_short = 514; |
| pub const IPPORT_EFSSERVER: c_short = 520; |
| pub const IPPORT_BIFFUDP: c_short = 512; |
| pub const IPPORT_WHOSERVER: c_short = 513; |
| pub const IPPORT_ROUTESERVER: c_short = 520; |
| pub const IPPORT_RESERVED: c_short = 1024; |
| pub const IMPLINK_IP: c_short = 155; |
| pub const IMPLINK_LOWEXPER: c_short = 156; |
| pub const IMPLINK_HIGHEXPER: c_short = 158; |
| pub const ADDR_ANY: ULONG = INADDR_ANY; |
| pub const WSADESCRIPTION_LEN: usize = 256; |
| pub const WSASYS_STATUS_LEN: usize = 128; |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct WSADATA { |
| wVersion: WORD, |
| wHighVersion: WORD, |
| szDescription: [c_char; WSADESCRIPTION_LEN + 1], |
| szSystemStatus: [c_char; WSASYS_STATUS_LEN + 1], |
| iMaxSockets: c_ushort, |
| iMaxUdpDg: c_ushort, |
| lpVendorInfo: *mut c_char, |
| }} |
| #[cfg(target_pointer_width = "64")] |
| STRUCT!{struct WSADATA { |
| wVersion: WORD, |
| wHighVersion: WORD, |
| iMaxSockets: c_ushort, |
| iMaxUdpDg: c_ushort, |
| lpVendorInfo: *mut c_char, |
| szDescription: [c_char; WSADESCRIPTION_LEN + 1], |
| szSystemStatus: [c_char; WSASYS_STATUS_LEN + 1], |
| }} |
| pub type LPWSADATA = *mut WSADATA; |
| pub const INVALID_SOCKET: SOCKET = !0; |
| pub const SOCKET_ERROR: c_int = -1; |
| pub const FROM_PROTOCOL_INFO: c_int = -1; |
| pub const SOCK_STREAM: c_int = 1; |
| pub const SOCK_DGRAM: c_int = 2; |
| pub const SOCK_RAW: c_int = 3; |
| pub const SOCK_RDM: c_int = 4; |
| pub const SOCK_SEQPACKET: c_int = 5; |
| pub const SO_DEBUG: c_int = 0x0001; |
| pub const SO_ACCEPTCONN: c_int = 0x0002; |
| pub const SO_REUSEADDR: c_int = 0x0004; |
| pub const SO_KEEPALIVE: c_int = 0x0008; |
| pub const SO_DONTROUTE: c_int = 0x0010; |
| pub const SO_BROADCAST: c_int = 0x0020; |
| pub const SO_USELOOPBACK: c_int = 0x0040; |
| pub const SO_LINGER: c_int = 0x0080; |
| pub const SO_OOBINLINE: c_int = 0x0100; |
| pub const SO_DONTLINGER: c_int = !SO_LINGER; |
| pub const SO_EXCLUSIVEADDRUSE: c_int = !SO_REUSEADDR; |
| pub const SO_SNDBUF: c_int = 0x1001; |
| pub const SO_RCVBUF: c_int = 0x1002; |
| pub const SO_SNDLOWAT: c_int = 0x1003; |
| pub const SO_RCVLOWAT: c_int = 0x1004; |
| pub const SO_SNDTIMEO: c_int = 0x1005; |
| pub const SO_RCVTIMEO: c_int = 0x1006; |
| pub const SO_ERROR: c_int = 0x1007; |
| pub const SO_TYPE: c_int = 0x1008; |
| pub const SO_GROUP_ID: c_int = 0x2001; |
| pub const SO_GROUP_PRIORITY: c_int = 0x2002; |
| pub const SO_MAX_MSG_SIZE: c_int = 0x2003; |
| pub const SO_PROTOCOL_INFOA: c_int = 0x2004; |
| pub const SO_PROTOCOL_INFOW: c_int = 0x2005; |
| pub const PVD_CONFIG: c_int = 0x3001; |
| pub const SO_CONDITIONAL_ACCEPT: c_int = 0x3002; |
| STRUCT!{struct sockproto { |
| sp_family: u_short, |
| sp_protocol: u_short, |
| }} |
| pub const PF_UNSPEC: c_int = AF_UNSPEC; |
| pub const PF_UNIX: c_int = AF_UNIX; |
| pub const PF_INET: c_int = AF_INET; |
| pub const PF_IMPLINK: c_int = AF_IMPLINK; |
| pub const PF_PUP: c_int = AF_PUP; |
| pub const PF_CHAOS: c_int = AF_CHAOS; |
| pub const PF_NS: c_int = AF_NS; |
| pub const PF_IPX: c_int = AF_IPX; |
| pub const PF_ISO: c_int = AF_ISO; |
| pub const PF_OSI: c_int = AF_OSI; |
| pub const PF_ECMA: c_int = AF_ECMA; |
| pub const PF_DATAKIT: c_int = AF_DATAKIT; |
| pub const PF_CCITT: c_int = AF_CCITT; |
| pub const PF_SNA: c_int = AF_SNA; |
| pub const PF_DECnet: c_int = AF_DECnet; |
| pub const PF_DLI: c_int = AF_DLI; |
| pub const PF_LAT: c_int = AF_LAT; |
| pub const PF_HYLINK: c_int = AF_HYLINK; |
| pub const PF_APPLETALK: c_int = AF_APPLETALK; |
| pub const PF_VOICEVIEW: c_int = AF_VOICEVIEW; |
| pub const PF_FIREFOX: c_int = AF_FIREFOX; |
| pub const PF_UNKNOWN1: c_int = AF_UNKNOWN1; |
| pub const PF_BAN: c_int = AF_BAN; |
| pub const PF_ATM: c_int = AF_ATM; |
| pub const PF_INET6: c_int = AF_INET6; |
| pub const PF_BTH: c_int = AF_BTH; |
| pub const PF_MAX: c_int = AF_MAX; |
| STRUCT!{struct linger { |
| l_onoff: u_short, |
| l_linger: u_short, |
| }} |
| pub const SOL_SOCKET: c_int = 0xffff; |
| pub const SOMAXCONN: c_int = 0x7fffffff; |
| #[inline] |
| pub fn SOMAXCONN_HINT(b: c_int) -> c_int { |
| -b |
| } |
| pub const MSG_OOB: c_int = 0x1; |
| pub const MSG_PEEK: c_int = 0x2; |
| pub const MSG_DONTROUTE: c_int = 0x4; |
| pub const MSG_WAITALL: c_int = 0x8; |
| pub const MSG_PUSH_IMMEDIATE: c_int = 0x20; |
| pub const MSG_PARTIAL: c_int = 0x8000; |
| pub const MSG_INTERRUPT: c_int = 0x10; |
| pub const MSG_MAXIOVLEN: c_int = 16; |
| pub const MAXGETHOSTSTRUCT: usize = 1024; |
| pub const FD_READ_BIT: c_long = 0; |
| pub const FD_READ: c_long = 1 << FD_READ_BIT; |
| pub const FD_WRITE_BIT: c_long = 1; |
| pub const FD_WRITE: c_long = 1 << FD_WRITE_BIT; |
| pub const FD_OOB_BIT: c_long = 2; |
| pub const FD_OOB: c_long = 1 << FD_OOB_BIT; |
| pub const FD_ACCEPT_BIT: c_long = 3; |
| pub const FD_ACCEPT: c_long = 1 << FD_ACCEPT_BIT; |
| pub const FD_CONNECT_BIT: c_long = 4; |
| pub const FD_CONNECT: c_long = 1 << FD_CONNECT_BIT; |
| pub const FD_CLOSE_BIT: c_long = 5; |
| pub const FD_CLOSE: c_long = 1 << FD_CLOSE_BIT; |
| pub const FD_QOS_BIT: c_long = 6; |
| pub const FD_QOS: c_long = 1 << FD_QOS_BIT; |
| pub const FD_GROUP_QOS_BIT: c_long = 7; |
| pub const FD_GROUP_QOS: c_long = 1 << FD_GROUP_QOS_BIT; |
| pub const FD_ROUTING_INTERFACE_CHANGE_BIT: c_long = 8; |
| pub const FD_ROUTING_INTERFACE_CHANGE: c_long = 1 << FD_ROUTING_INTERFACE_CHANGE_BIT; |
| pub const FD_ADDRESS_LIST_CHANGE_BIT: c_long = 9; |
| pub const FD_ADDRESS_LIST_CHANGE: c_long = 1 << FD_ADDRESS_LIST_CHANGE_BIT; |
| pub const FD_MAX_EVENTS: usize = 10; |
| pub const FD_ALL_EVENTS: c_long = (1 << FD_MAX_EVENTS) - 1; |
| pub const WSABASEERR: c_int = 10000; |
| pub const WSAEINTR: c_int = WSABASEERR+4; |
| pub const WSAEBADF: c_int = WSABASEERR+9; |
| pub const WSAEACCES: c_int = WSABASEERR+13; |
| pub const WSAEFAULT: c_int = WSABASEERR+14; |
| pub const WSAEINVAL: c_int = WSABASEERR+22; |
| pub const WSAEMFILE: c_int = WSABASEERR+24; |
| pub const WSAEWOULDBLOCK: c_int = WSABASEERR+35; |
| pub const WSAEINPROGRESS: c_int = WSABASEERR+36; |
| pub const WSAEALREADY: c_int = WSABASEERR+37; |
| pub const WSAENOTSOCK: c_int = WSABASEERR+38; |
| pub const WSAEDESTADDRREQ: c_int = WSABASEERR+39; |
| pub const WSAEMSGSIZE: c_int = WSABASEERR+40; |
| pub const WSAEPROTOTYPE: c_int = WSABASEERR+41; |
| pub const WSAENOPROTOOPT: c_int = WSABASEERR+42; |
| pub const WSAEPROTONOSUPPORT: c_int = WSABASEERR+43; |
| pub const WSAESOCKTNOSUPPORT: c_int = WSABASEERR+44; |
| pub const WSAEOPNOTSUPP: c_int = WSABASEERR+45; |
| pub const WSAEPFNOSUPPORT: c_int = WSABASEERR+46; |
| pub const WSAEAFNOSUPPORT: c_int = WSABASEERR+47; |
| pub const WSAEADDRINUSE: c_int = WSABASEERR+48; |
| pub const WSAEADDRNOTAVAIL: c_int = WSABASEERR+49; |
| pub const WSAENETDOWN: c_int = WSABASEERR+50; |
| pub const WSAENETUNREACH: c_int = WSABASEERR+51; |
| pub const WSAENETRESET: c_int = WSABASEERR+52; |
| pub const WSAECONNABORTED: c_int = WSABASEERR+53; |
| pub const WSAECONNRESET: c_int = WSABASEERR+54; |
| pub const WSAENOBUFS: c_int = WSABASEERR+55; |
| pub const WSAEISCONN: c_int = WSABASEERR+56; |
| pub const WSAENOTCONN: c_int = WSABASEERR+57; |
| pub const WSAESHUTDOWN: c_int = WSABASEERR+58; |
| pub const WSAETOOMANYREFS: c_int = WSABASEERR+59; |
| pub const WSAETIMEDOUT: c_int = WSABASEERR+60; |
| pub const WSAECONNREFUSED: c_int = WSABASEERR+61; |
| pub const WSAELOOP: c_int = WSABASEERR+62; |
| pub const WSAENAMETOOLONG: c_int = WSABASEERR+63; |
| pub const WSAEHOSTDOWN: c_int = WSABASEERR+64; |
| pub const WSAEHOSTUNREACH: c_int = WSABASEERR+65; |
| pub const WSAENOTEMPTY: c_int = WSABASEERR+66; |
| pub const WSAEPROCLIM: c_int = WSABASEERR+67; |
| pub const WSAEUSERS: c_int = WSABASEERR+68; |
| pub const WSAEDQUOT: c_int = WSABASEERR+69; |
| pub const WSAESTALE: c_int = WSABASEERR+70; |
| pub const WSAEREMOTE: c_int = WSABASEERR+71; |
| pub const WSASYSNOTREADY: c_int = WSABASEERR+91; |
| pub const WSAVERNOTSUPPORTED: c_int = WSABASEERR+92; |
| pub const WSANOTINITIALISED: c_int = WSABASEERR+93; |
| pub const WSAEDISCON: c_int = WSABASEERR+101; |
| pub const WSAENOMORE: c_int = WSABASEERR+102; |
| pub const WSAECANCELLED: c_int = WSABASEERR+103; |
| pub const WSAEINVALIDPROCTABLE: c_int = WSABASEERR+104; |
| pub const WSAEINVALIDPROVIDER: c_int = WSABASEERR+105; |
| pub const WSAEPROVIDERFAILEDINIT: c_int = WSABASEERR+106; |
| pub const WSASYSCALLFAILURE: c_int = WSABASEERR+107; |
| pub const WSASERVICE_NOT_FOUND: c_int = WSABASEERR+108; |
| pub const WSATYPE_NOT_FOUND: c_int = WSABASEERR+109; |
| pub const WSA_E_NO_MORE: c_int = WSABASEERR+110; |
| pub const WSA_E_CANCELLED: c_int = WSABASEERR+111; |
| pub const WSAEREFUSED: c_int = WSABASEERR+112; |
| pub const WSAHOST_NOT_FOUND: c_int = WSABASEERR+1001; |
| pub const WSATRY_AGAIN: c_int = WSABASEERR+1002; |
| pub const WSANO_RECOVERY: c_int = WSABASEERR+1003; |
| pub const WSANO_DATA: c_int = WSABASEERR+1004; |
| pub const WSA_QOS_RECEIVERS: c_int = WSABASEERR + 1005; |
| pub const WSA_QOS_SENDERS: c_int = WSABASEERR + 1006; |
| pub const WSA_QOS_NO_SENDERS: c_int = WSABASEERR + 1007; |
| pub const WSA_QOS_NO_RECEIVERS: c_int = WSABASEERR + 1008; |
| pub const WSA_QOS_REQUEST_CONFIRMED: c_int = WSABASEERR + 1009; |
| pub const WSA_QOS_ADMISSION_FAILURE: c_int = WSABASEERR + 1010; |
| pub const WSA_QOS_POLICY_FAILURE: c_int = WSABASEERR + 1011; |
| pub const WSA_QOS_BAD_STYLE: c_int = WSABASEERR + 1012; |
| pub const WSA_QOS_BAD_OBJECT: c_int = WSABASEERR + 1013; |
| pub const WSA_QOS_TRAFFIC_CTRL_ERROR: c_int = WSABASEERR + 1014; |
| pub const WSA_QOS_GENERIC_ERROR: c_int = WSABASEERR + 1015; |
| pub const WSA_QOS_ESERVICETYPE: c_int = WSABASEERR + 1016; |
| pub const WSA_QOS_EFLOWSPEC: c_int = WSABASEERR + 1017; |
| pub const WSA_QOS_EPROVSPECBUF: c_int = WSABASEERR + 1018; |
| pub const WSA_QOS_EFILTERSTYLE: c_int = WSABASEERR + 1019; |
| pub const WSA_QOS_EFILTERTYPE: c_int = WSABASEERR + 1020; |
| pub const WSA_QOS_EFILTERCOUNT: c_int = WSABASEERR + 1021; |
| pub const WSA_QOS_EOBJLENGTH: c_int = WSABASEERR + 1022; |
| pub const WSA_QOS_EFLOWCOUNT: c_int = WSABASEERR + 1023; |
| pub const WSA_QOS_EUNKOWNPSOBJ: c_int = WSABASEERR + 1024; |
| pub const WSA_QOS_EPOLICYOBJ: c_int = WSABASEERR + 1025; |
| pub const WSA_QOS_EFLOWDESC: c_int = WSABASEERR + 1026; |
| pub const WSA_QOS_EPSFLOWSPEC: c_int = WSABASEERR + 1027; |
| pub const WSA_QOS_EPSFILTERSPEC: c_int = WSABASEERR + 1028; |
| pub const WSA_QOS_ESDMODEOBJ: c_int = WSABASEERR + 1029; |
| pub const WSA_QOS_ESHAPERATEOBJ: c_int = WSABASEERR + 1030; |
| pub const WSA_QOS_RESERVED_PETYPE: c_int = WSABASEERR + 1031; |
| #[inline] |
| pub unsafe fn h_errno() -> c_int { |
| WSAGetLastError() |
| } |
| pub const HOST_NOT_FOUND: c_int = WSAHOST_NOT_FOUND; |
| pub const TRY_AGAIN: c_int = WSATRY_AGAIN; |
| pub const NO_RECOVERY: c_int = WSANO_RECOVERY; |
| pub const NO_DATA: c_int = WSANO_DATA; |
| pub const WSANO_ADDRESS: c_int = WSANO_DATA; |
| pub const NO_ADDRESS: c_int = WSANO_ADDRESS; |
| pub type WSAEVENT = HANDLE; |
| pub type LPWSAEVENT = LPHANDLE; |
| pub type WSAOVERLAPPED = OVERLAPPED; |
| pub type LPWSAOVERLAPPED = *mut OVERLAPPED; |
| pub const WSA_IO_PENDING: c_int = ERROR_IO_PENDING as i32; |
| pub const WSA_IO_INCOMPLETE: c_int = ERROR_IO_INCOMPLETE as i32; |
| pub const WSA_INVALID_HANDLE: c_int = ERROR_INVALID_HANDLE as i32; |
| pub const WSA_INVALID_PARAMETER: c_int = ERROR_INVALID_PARAMETER as i32; |
| pub const WSA_NOT_ENOUGH_MEMORY: c_int = ERROR_NOT_ENOUGH_MEMORY as i32; |
| pub const WSA_OPERATION_ABORTED: c_int = ERROR_OPERATION_ABORTED as i32; |
| pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT; |
| pub const WSA_MAXIMUM_WAIT_EVENTS: DWORD = MAXIMUM_WAIT_OBJECTS; |
| pub const WSA_WAIT_FAILED: DWORD = WAIT_FAILED; |
| pub const WSA_WAIT_EVENT_0: DWORD = WAIT_OBJECT_0; |
| pub const WSA_WAIT_IO_COMPLETION: DWORD = WAIT_IO_COMPLETION; |
| pub const WSA_WAIT_TIMEOUT: DWORD = WAIT_TIMEOUT; |
| pub const WSA_INFINITE: DWORD = INFINITE; |
| STRUCT!{struct QOS { |
| SendingFlowspec: FLOWSPEC, |
| FLOWSPEC: FLOWSPEC, |
| ProviderSpecific: WSABUF, |
| }} |
| pub type LPQOS = *mut QOS; |
| pub const CF_ACCEPT: c_int = 0x0000; |
| pub const CF_REJECT: c_int = 0x0001; |
| pub const CF_DEFER: c_int = 0x0002; |
| pub const SD_RECEIVE: c_int = 0x00; |
| pub const SD_SEND: c_int = 0x01; |
| pub const SD_BOTH: c_int = 0x02; |
| pub type GROUP = c_uint; |
| pub const SG_UNCONSTRAINED_GROUP: GROUP = 0x01; |
| pub const SG_CONSTRAINED_GROUP: GROUP = 0x02; |
| STRUCT!{struct WSANETWORKEVENTS { |
| lNetworkEvents: c_long, |
| iErrorCode: [c_int; FD_MAX_EVENTS], |
| }} |
| pub type LPWSANETWORKEVENTS = *mut WSANETWORKEVENTS; |
| pub const MAX_PROTOCOL_CHAIN: usize = 7; |
| pub const BASE_PROTOCOL: c_int = 1; |
| pub const LAYERED_PROTOCOL: c_int = 0; |
| STRUCT!{struct WSAPROTOCOLCHAIN { |
| ChainLen: c_int, |
| ChainEntries: [DWORD; MAX_PROTOCOL_CHAIN], |
| }} |
| pub type LPWSAPROTOCOLCHAIN = *mut WSAPROTOCOLCHAIN; |
| pub const WSAPROTOCOL_LEN: usize = 255; |
| STRUCT!{struct WSAPROTOCOL_INFOA { |
| dwServiceFlags1: DWORD, |
| dwServiceFlags2: DWORD, |
| dwServiceFlags3: DWORD, |
| dwServiceFlags4: DWORD, |
| dwServiceFlags5: DWORD, |
| ProviderId: GUID, |
| dwCatalogEntryId: DWORD, |
| ProtocolChain: WSAPROTOCOLCHAIN, |
| iVersion: c_int, |
| iAddressFamily: c_int, |
| iMaxSockAddr: c_int, |
| iMinSockAddr: c_int, |
| iSocketType: c_int, |
| iProtocol: c_int, |
| iProtocolMaxOffset: c_int, |
| iNetworkByteOrder: c_int, |
| iSecurityScheme: c_int, |
| dwMessageSize: DWORD, |
| dwProviderReserved: DWORD, |
| szProtocol: [CHAR; WSAPROTOCOL_LEN + 1], |
| }} |
| pub type LPWSAPROTOCOL_INFOA = *mut WSAPROTOCOL_INFOA; |
| STRUCT!{struct WSAPROTOCOL_INFOW { |
| dwServiceFlags1: DWORD, |
| dwServiceFlags2: DWORD, |
| dwServiceFlags3: DWORD, |
| dwServiceFlags4: DWORD, |
| dwServiceFlags5: DWORD, |
| ProviderId: GUID, |
| dwCatalogEntryId: DWORD, |
| ProtocolChain: WSAPROTOCOLCHAIN, |
| iVersion: c_int, |
| iAddressFamily: c_int, |
| iMaxSockAddr: c_int, |
| iMinSockAddr: c_int, |
| iSocketType: c_int, |
| iProtocol: c_int, |
| iProtocolMaxOffset: c_int, |
| iNetworkByteOrder: c_int, |
| iSecurityScheme: c_int, |
| dwMessageSize: DWORD, |
| dwProviderReserved: DWORD, |
| szProtocol: [WCHAR; WSAPROTOCOL_LEN + 1], |
| }} |
| pub type LPWSAPROTOCOL_INFOW = *mut WSAPROTOCOL_INFOW; |
| pub const PFL_MULTIPLE_PROTO_ENTRIES: DWORD = 0x00000001; |
| pub const PFL_RECOMMENDED_PROTO_ENTRY: DWORD = 0x00000002; |
| pub const PFL_HIDDEN: DWORD = 0x00000004; |
| pub const PFL_MATCHES_PROTOCOL_ZERO: DWORD = 0x00000008; |
| pub const PFL_NETWORKDIRECT_PROVIDER: DWORD = 0x00000010; |
| pub const XP1_CONNECTIONLESS: DWORD = 0x00000001; |
| pub const XP1_GUARANTEED_DELIVERY: DWORD = 0x00000002; |
| pub const XP1_GUARANTEED_ORDER: DWORD = 0x00000004; |
| pub const XP1_MESSAGE_ORIENTED: DWORD = 0x00000008; |
| pub const XP1_PSEUDO_STREAM: DWORD = 0x00000010; |
| pub const XP1_GRACEFUL_CLOSE: DWORD = 0x00000020; |
| pub const XP1_EXPEDITED_DATA: DWORD = 0x00000040; |
| pub const XP1_CONNECT_DATA: DWORD = 0x00000080; |
| pub const XP1_DISCONNECT_DATA: DWORD = 0x00000100; |
| pub const XP1_SUPPORT_BROADCAST: DWORD = 0x00000200; |
| pub const XP1_SUPPORT_MULTIPOINT: DWORD = 0x00000400; |
| pub const XP1_MULTIPOINT_CONTROL_PLANE: DWORD = 0x00000800; |
| pub const XP1_MULTIPOINT_DATA_PLANE: DWORD = 0x00001000; |
| pub const XP1_QOS_SUPPORTED: DWORD = 0x00002000; |
| pub const XP1_INTERRUPT: DWORD = 0x00004000; |
| pub const XP1_UNI_SEND: DWORD = 0x00008000; |
| pub const XP1_UNI_RECV: DWORD = 0x00010000; |
| pub const XP1_IFS_HANDLES: DWORD = 0x00020000; |
| pub const XP1_PARTIAL_MESSAGE: DWORD = 0x00040000; |
| pub const XP1_SAN_SUPPORT_SDP: DWORD = 0x00080000; |
| pub const BIGENDIAN: DWORD = 0x0000; |
| pub const LITTLEENDIAN: DWORD = 0x0001; |
| pub const SECURITY_PROTOCOL_NONE: DWORD = 0x0000; |
| pub const JL_SENDER_ONLY: DWORD = 0x01; |
| pub const JL_RECEIVER_ONLY: DWORD = 0x02; |
| pub const JL_BOTH: DWORD = 0x04; |
| pub const WSA_FLAG_OVERLAPPED: DWORD = 0x01; |
| pub const WSA_FLAG_MULTIPOINT_C_ROOT: DWORD = 0x02; |
| pub const WSA_FLAG_MULTIPOINT_C_LEAF: DWORD = 0x04; |
| pub const WSA_FLAG_MULTIPOINT_D_ROOT: DWORD = 0x08; |
| pub const WSA_FLAG_MULTIPOINT_D_LEAF: DWORD = 0x10; |
| pub const WSA_FLAG_ACCESS_SYSTEM_SECURITY: DWORD = 0x40; |
| pub const WSA_FLAG_NO_HANDLE_INHERIT: DWORD = 0x80; |
| pub const WSA_FLAG_REGISTERED_IO: DWORD = 0x100; |
| FN!{stdcall LPCONDITIONPROC( |
| lpCallerId: LPWSABUF, |
| lpCallerData: LPWSABUF, |
| lpSQOS: LPQOS, |
| lpGQOS: LPQOS, |
| lpCalleeId: LPWSABUF, |
| lpCalleeData: LPWSABUF, |
| g: *mut GROUP, |
| dwCallbackData: DWORD, |
| ) -> c_int} |
| FN!{stdcall LPWSAOVERLAPPED_COMPLETION_ROUTINE( |
| dwError: DWORD, |
| cbTransferred: DWORD, |
| lpOverlapped: LPWSAOVERLAPPED, |
| dwFlags: DWORD, |
| ) -> ()} |
| ENUM!{enum WSACOMPLETIONTYPE { |
| NSP_NOTIFY_IMMEDIATELY = 0, |
| NSP_NOTIFY_HWND, |
| NSP_NOTIFY_EVENT, |
| NSP_NOTIFY_PORT, |
| NSP_NOTIFY_APC, |
| }} |
| pub type PWSACOMPLETIONTYPE = *mut WSACOMPLETIONTYPE; |
| pub type LPWSACOMPLETIONTYPE = *mut WSACOMPLETIONTYPE; |
| STRUCT!{struct WSACOMPLETION_WindowMessage { |
| hWnd: HWND, |
| uMsg: UINT, |
| context: WPARAM, |
| }} |
| STRUCT!{struct WSACOMPLETION_Event { |
| lpOverlapped: LPWSAOVERLAPPED, |
| }} |
| STRUCT!{struct WSACOMPLETION_Apc { |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpfnCompletionProc: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| }} |
| STRUCT!{struct WSACOMPLETION_Port { |
| lpOverlapped: LPWSAOVERLAPPED, |
| hPort: HANDLE, |
| Key: ULONG_PTR, |
| }} |
| UNION!{union WSACOMPLETION_Parameter { |
| [usize; 3], |
| WindowMessage WindowMessage_mut: WSACOMPLETION_WindowMessage, |
| Event Event_mut: WSACOMPLETION_Event, |
| Apc Apc_mut: WSACOMPLETION_Apc, |
| Port Port_mut: WSACOMPLETION_Port, |
| }} |
| STRUCT!{struct WSACOMPLETION { |
| Type: WSACOMPLETIONTYPE, |
| Parameters: WSACOMPLETION_Parameter, |
| }} |
| pub type PWSACOMPLETION = *mut WSACOMPLETION; |
| pub type LPWSACOMPLETION = *mut WSACOMPLETION; |
| pub const TH_NETDEV: DWORD = 0x00000001; |
| pub const TH_TAPI: DWORD = 0x00000002; |
| pub const SERVICE_MULTIPLE: DWORD = 0x00000001; |
| pub const NS_ALL: DWORD = 0; |
| pub const NS_SAP: DWORD = 1; |
| pub const NS_NDS: DWORD = 2; |
| pub const NS_PEER_BROWSE: DWORD = 3; |
| pub const NS_SLP: DWORD = 5; |
| pub const NS_DHCP: DWORD = 6; |
| pub const NS_TCPIP_LOCAL: DWORD = 10; |
| pub const NS_TCPIP_HOSTS: DWORD = 11; |
| pub const NS_DNS: DWORD = 12; |
| pub const NS_NETBT: DWORD = 13; |
| pub const NS_WINS: DWORD = 14; |
| pub const NS_NLA: DWORD = 15; |
| pub const NS_BTH: DWORD = 16; |
| pub const NS_LOCALNAME: DWORD = 19; |
| pub const NS_NBP: DWORD = 20; |
| pub const NS_MS: DWORD = 30; |
| pub const NS_STDA: DWORD = 31; |
| pub const NS_NTDS: DWORD = 32; |
| pub const NS_EMAIL: DWORD = 37; |
| pub const NS_PNRPNAME: DWORD = 38; |
| pub const NS_PNRPCLOUD: DWORD = 39; |
| pub const NS_X500: DWORD = 40; |
| pub const NS_NIS: DWORD = 41; |
| pub const NS_NISPLUS: DWORD = 42; |
| pub const NS_WRQ: DWORD = 50; |
| pub const NS_NETDES: DWORD = 60; |
| pub const RES_UNUSED_1: DWORD = 0x00000001; |
| pub const RES_FLUSH_CACHE: DWORD = 0x00000002; |
| pub const RES_SERVICE: DWORD = 0x00000004; |
| pub const SERVICE_TYPE_VALUE_IPXPORT: &'static str = "IpxSocket"; |
| pub const SERVICE_TYPE_VALUE_SAPID: &'static str = "SapId"; |
| pub const SERVICE_TYPE_VALUE_TCPPORT: &'static str = "TcpPort"; |
| pub const SERVICE_TYPE_VALUE_UDPPORT: &'static str = "UdpPort"; |
| pub const SERVICE_TYPE_VALUE_OBJECTID: &'static str = "ObjectId"; |
| STRUCT!{struct AFPROTOCOLS { |
| iAddressFamily: INT, |
| iProtocol: INT, |
| }} |
| pub type PAFPROTOCOLS = *mut AFPROTOCOLS; |
| pub type LPAFPROTOCOLS = *mut AFPROTOCOLS; |
| ENUM!{enum WSAECOMPARATOR { |
| COMP_EQUAL = 0, |
| COMP_NOTLESS, |
| }} |
| pub type PWSAECOMPARATOR = *mut WSAECOMPARATOR; |
| pub type LPWSAECOMPARATOR = *mut WSAECOMPARATOR; |
| STRUCT!{struct WSAVERSION { |
| dwVersion: DWORD, |
| ecHow: WSAECOMPARATOR, |
| }} |
| pub type PWSAVERSION = *mut WSAVERSION; |
| pub type LPWSAVERSION = *mut WSAVERSION; |
| STRUCT!{struct WSAQUERYSETA { |
| dwSize: DWORD, |
| lpszServiceInstanceName: LPSTR, |
| lpServiceClassId: LPGUID, |
| lpVersion: LPWSAVERSION, |
| lpszComment: LPSTR, |
| dwNameSpace: DWORD, |
| lpNSProviderId: LPGUID, |
| lpszContext: LPSTR, |
| dwNumberOfProtocols: DWORD, |
| lpafpProtocols: LPAFPROTOCOLS, |
| lpszQueryString: LPSTR, |
| dwNumberOfCsAddrs: DWORD, |
| lpcsaBuffer: LPCSADDR_INFO, |
| dwOutputFlags: DWORD, |
| lpBlob: LPBLOB, |
| }} |
| pub type PWSAQUERYSETA = *mut WSAQUERYSETA; |
| pub type LPWSAQUERYSETA = *mut WSAQUERYSETA; |
| STRUCT!{struct WSAQUERYSETW { |
| dwSize: DWORD, |
| lpszServiceInstanceName: LPWSTR, |
| lpServiceClassId: LPGUID, |
| lpVersion: LPWSAVERSION, |
| lpszComment: LPWSTR, |
| dwNameSpace: DWORD, |
| lpNSProviderId: LPGUID, |
| lpszContext: LPWSTR, |
| dwNumberOfProtocols: DWORD, |
| lpafpProtocols: LPAFPROTOCOLS, |
| lpszQueryString: LPWSTR, |
| dwNumberOfCsAddrs: DWORD, |
| lpcsaBuffer: LPCSADDR_INFO, |
| dwOutputFlags: DWORD, |
| lpBlob: LPBLOB, |
| }} |
| pub type PWSAQUERYSETW = *mut WSAQUERYSETW; |
| pub type LPWSAQUERYSETW = *mut WSAQUERYSETW; |
| STRUCT!{struct WSAQUERYSET2A { |
| dwSize: DWORD, |
| lpszServiceInstanceName: LPSTR, |
| lpVersion: LPWSAVERSION, |
| lpszComment: LPSTR, |
| dwNameSpace: DWORD, |
| lpNSProviderId: LPGUID, |
| lpszContext: LPSTR, |
| dwNumberOfProtocols: DWORD, |
| lpafpProtocols: LPAFPROTOCOLS, |
| lpszQueryString: LPSTR, |
| dwNumberOfCsAddrs: DWORD, |
| lpcsaBuffer: LPCSADDR_INFO, |
| dwOutputFlags: DWORD, |
| lpBlob: LPBLOB, |
| }} |
| pub type PWSAQUERYSET2A = *mut WSAQUERYSET2A; |
| pub type LPWSAQUERYSET2A = *mut WSAQUERYSET2A; |
| STRUCT!{struct WSAQUERYSET2W { |
| dwSize: DWORD, |
| lpszServiceInstanceName: LPWSTR, |
| lpVersion: LPWSAVERSION, |
| lpszComment: LPWSTR, |
| dwNameSpace: DWORD, |
| lpNSProviderId: LPGUID, |
| lpszContext: LPWSTR, |
| dwNumberOfProtocols: DWORD, |
| lpafpProtocols: LPAFPROTOCOLS, |
| lpszQueryString: LPWSTR, |
| dwNumberOfCsAddrs: DWORD, |
| lpcsaBuffer: LPCSADDR_INFO, |
| dwOutputFlags: DWORD, |
| lpBlob: LPBLOB, |
| }} |
| pub type PWSAQUERYSET2W = *mut WSAQUERYSET2W; |
| pub type LPWSAQUERYSET2W = *mut WSAQUERYSET2W; |
| pub const LUP_DEEP: DWORD = 0x0001; |
| pub const LUP_CONTAINERS: DWORD = 0x0002; |
| pub const LUP_NOCONTAINERS: DWORD = 0x0004; |
| pub const LUP_NEAREST: DWORD = 0x0008; |
| pub const LUP_RETURN_NAME: DWORD = 0x0010; |
| pub const LUP_RETURN_TYPE: DWORD = 0x0020; |
| pub const LUP_RETURN_VERSION: DWORD = 0x0040; |
| pub const LUP_RETURN_COMMENT: DWORD = 0x0080; |
| pub const LUP_RETURN_ADDR: DWORD = 0x0100; |
| pub const LUP_RETURN_BLOB: DWORD = 0x0200; |
| pub const LUP_RETURN_ALIASES: DWORD = 0x0400; |
| pub const LUP_RETURN_QUERY_STRING: DWORD = 0x0800; |
| pub const LUP_RETURN_ALL: DWORD = 0x0FF0; |
| pub const LUP_RES_SERVICE: DWORD = 0x8000; |
| pub const LUP_FLUSHCACHE: DWORD = 0x1000; |
| pub const LUP_FLUSHPREVIOUS: DWORD = 0x2000; |
| pub const LUP_NON_AUTHORITATIVE: DWORD = 0x4000; |
| pub const LUP_SECURE: DWORD = 0x8000; |
| pub const LUP_RETURN_PREFERRED_NAMES: DWORD = 0x10000; |
| pub const LUP_DNS_ONLY: DWORD = 0x20000; |
| pub const LUP_ADDRCONFIG: DWORD = 0x00100000; |
| pub const LUP_DUAL_ADDR: DWORD = 0x00200000; |
| pub const LUP_FILESERVER: DWORD = 0x00400000; |
| pub const LUP_DISABLE_IDN_ENCODING: DWORD = 0x00800000; |
| pub const LUP_API_ANSI: DWORD = 0x01000000; |
| pub const LUP_RESOLUTION_HANDLE: DWORD = 0x80000000; |
| pub const RESULT_IS_ALIAS: DWORD = 0x0001; |
| pub const RESULT_IS_ADDED: DWORD = 0x0010; |
| pub const RESULT_IS_CHANGED: DWORD = 0x0020; |
| pub const RESULT_IS_DELETED: DWORD = 0x0040; |
| ENUM!{enum WSAESETSERVICEOP { |
| RNRSERVICE_REGISTER = 0, |
| RNRSERVICE_DEREGISTER, |
| RNRSERVICE_DELETE, |
| }} |
| pub type PWSAESETSERVICEOP = *mut WSAESETSERVICEOP; |
| pub type LPWSAESETSERVICEOP = *mut WSAESETSERVICEOP; |
| STRUCT!{struct WSANSCLASSINFOA { |
| lpszName: LPSTR, |
| dwNameSpace: DWORD, |
| dwValueType: DWORD, |
| dwValueSize: DWORD, |
| lpValue: LPVOID, |
| }} |
| pub type PWSANSCLASSINFOA = *mut WSANSCLASSINFOA; |
| pub type LPWSANSCLASSINFOA = *mut WSANSCLASSINFOA; |
| STRUCT!{struct WSANSCLASSINFOW { |
| lpszName: LPWSTR, |
| dwNameSpace: DWORD, |
| dwValueType: DWORD, |
| dwValueSize: DWORD, |
| lpValue: LPVOID, |
| }} |
| pub type PWSANSCLASSINFOW = *mut WSANSCLASSINFOW; |
| pub type LPWSANSCLASSINFOW = *mut WSANSCLASSINFOW; |
| STRUCT!{struct WSASERVICECLASSINFOA { |
| lpServiceClassId: LPGUID, |
| lpszServiceClassName: LPSTR, |
| dwCount: DWORD, |
| lpClassInfos: LPWSANSCLASSINFOA, |
| }} |
| pub type PWSASERVICECLASSINFOA = *mut WSASERVICECLASSINFOA; |
| pub type LPWSASERVICECLASSINFOA = *mut WSASERVICECLASSINFOA; |
| STRUCT!{struct WSASERVICECLASSINFOW { |
| lpServiceClassId: LPGUID, |
| lpszServiceClassName: LPWSTR, |
| dwCount: DWORD, |
| lpClassInfos: LPWSANSCLASSINFOW, |
| }} |
| pub type PWSASERVICECLASSINFOW = *mut WSASERVICECLASSINFOW; |
| pub type LPWSASERVICECLASSINFOW = *mut WSASERVICECLASSINFOW; |
| STRUCT!{struct WSANAMESPACE_INFOA { |
| NSProviderId: GUID, |
| dwNameSpace: DWORD, |
| fActive: BOOL, |
| dwVersion: DWORD, |
| lpszIdentifier: LPSTR, |
| }} |
| pub type PWSANAMESPACE_INFOA = *mut WSANAMESPACE_INFOA; |
| pub type LPWSANAMESPACE_INFOA = *mut WSANAMESPACE_INFOA; |
| STRUCT!{struct WSANAMESPACE_INFOW { |
| NSProviderId: GUID, |
| dwNameSpace: DWORD, |
| fActive: BOOL, |
| dwVersion: DWORD, |
| lpszIdentifier: LPWSTR, |
| }} |
| pub type PWSANAMESPACE_INFOW = *mut WSANAMESPACE_INFOW; |
| pub type LPWSANAMESPACE_INFOW = *mut WSANAMESPACE_INFOW; |
| STRUCT!{struct WSANAMESPACE_INFOEXA { |
| NSProviderId: GUID, |
| dwNameSpace: DWORD, |
| fActive: BOOL, |
| dwVersion: DWORD, |
| lpszIdentifier: LPSTR, |
| ProviderSpecific: BLOB, |
| }} |
| pub type PWSANAMESPACE_INFOEXA = *mut WSANAMESPACE_INFOEXA; |
| pub type LPWSANAMESPACE_INFOEXA = *mut WSANAMESPACE_INFOEXA; |
| STRUCT!{struct WSANAMESPACE_INFOEXW { |
| NSProviderId: GUID, |
| dwNameSpace: DWORD, |
| fActive: BOOL, |
| dwVersion: DWORD, |
| lpszIdentifier: LPWSTR, |
| ProviderSpecific: BLOB, |
| }} |
| pub type PWSANAMESPACE_INFOEXW = *mut WSANAMESPACE_INFOEXW; |
| pub type LPWSANAMESPACE_INFOEXW = *mut WSANAMESPACE_INFOEXW; |
| pub const POLLRDNORM: SHORT = 0x0100; |
| pub const POLLRDBAND: SHORT = 0x0200; |
| pub const POLLIN: SHORT = POLLRDNORM | POLLRDBAND; |
| pub const POLLPRI: SHORT = 0x0400; |
| pub const POLLWRNORM: SHORT = 0x0010; |
| pub const POLLOUT: SHORT = POLLWRNORM; |
| pub const POLLWRBAND: SHORT = 0x0020; |
| pub const POLLERR: SHORT = 0x0001; |
| pub const POLLHUP: SHORT = 0x0002; |
| pub const POLLNVAL: SHORT = 0x0004; |
| STRUCT!{struct WSAPOLLFD { |
| fd: SOCKET, |
| events: SHORT, |
| revents: SHORT, |
| }} |
| pub type PWSAPOLLFD = *mut WSAPOLLFD; |
| pub type LPWSAPOLLFD = *mut WSAPOLLFD; |
| extern "system" { |
| pub fn accept( |
| s: SOCKET, |
| addr: *mut SOCKADDR, |
| addrlen: *mut c_int, |
| ) -> SOCKET; |
| pub fn bind(s: SOCKET, |
| name: *const SOCKADDR, |
| namelen: c_int, |
| ) -> c_int; |
| pub fn closesocket( |
| s: SOCKET, |
| ) -> c_int; |
| pub fn connect( |
| s: SOCKET, |
| name: *const SOCKADDR, |
| namelen: c_int, |
| ) -> c_int; |
| pub fn ioctlsocket( |
| s: SOCKET, |
| cmd: c_long, |
| argp: *mut u_long, |
| ) -> c_int; |
| pub fn getpeername( |
| s: SOCKET, |
| name: *mut SOCKADDR, |
| namelen: *mut c_int, |
| ) -> c_int; |
| pub fn getsockname( |
| s: SOCKET, |
| name: *mut SOCKADDR, |
| namelen: *mut c_int, |
| ) -> c_int; |
| pub fn getsockopt( |
| s: SOCKET, |
| level: c_int, |
| optname: c_int, |
| optval: *mut c_char, |
| optlen: *mut c_int, |
| ) -> c_int; |
| pub fn htonl( |
| hostlong: u_long, |
| ) -> u_long; |
| pub fn htons( |
| hostshort: u_short, |
| ) -> u_short; |
| pub fn inet_addr( |
| cp: *const c_char, |
| ) -> c_ulong; |
| pub fn inet_ntoa( |
| _in: in_addr, |
| ) -> *mut c_char; |
| } |
| #[inline] |
| pub fn _WS2_32_WINSOCK_SWAP_LONG(l: __uint32) -> __uint32 { |
| ((l >> 24) & 0x000000FF) | ((l >> 8) & 0x0000FF00) | ((l << 8) & 0x00FF0000) |
| | ((l << 24) & 0xFF000000) |
| } |
| #[inline] |
| pub fn _WS2_32_WINSOCK_SWAP_LONGLONG(l: __uint64) -> __uint64 { |
| ((l >> 56) & 0x00000000000000FF) | ((l >> 40) & 0x000000000000FF00) |
| | ((l >> 24) & 0x0000000000FF0000) | ((l >> 8) & 0x00000000FF000000) |
| | ((l << 8) & 0x000000FF00000000) | ((l << 24) & 0x0000FF0000000000) |
| | ((l << 40) & 0x00FF000000000000) | ((l << 56) & 0xFF00000000000000) |
| } |
| #[inline] |
| pub fn htonll(Value: __uint64) -> __uint64 { |
| _WS2_32_WINSOCK_SWAP_LONGLONG(Value) |
| } |
| #[inline] |
| pub fn ntohll(Value: __uint64) -> __uint64 { |
| _WS2_32_WINSOCK_SWAP_LONGLONG(Value) |
| } |
| #[inline] |
| pub fn htonf(Value: c_float) -> __uint32 { |
| let Tempval: __uint32 = unsafe { ::core::mem::transmute(Value) }; |
| _WS2_32_WINSOCK_SWAP_LONG(Tempval) |
| } |
| #[inline] |
| pub fn ntohf(Value: __uint32) -> c_float { |
| let Tempval = _WS2_32_WINSOCK_SWAP_LONG(Value); |
| unsafe { ::core::mem::transmute(Tempval) } |
| } |
| #[inline] |
| pub fn htond(Value: c_double) -> __uint64 { |
| let Tempval: __uint64 = unsafe { ::core::mem::transmute(Value) }; |
| _WS2_32_WINSOCK_SWAP_LONGLONG(Tempval) |
| } |
| #[inline] |
| pub fn ntohd(Value: __uint64) -> c_double { |
| let Tempval = _WS2_32_WINSOCK_SWAP_LONGLONG(Value); |
| unsafe { ::core::mem::transmute(Tempval) } |
| } |
| extern "system" { |
| pub fn listen( |
| s: SOCKET, |
| backlog: c_int, |
| ) -> c_int; |
| pub fn ntohl( |
| netlong: u_long, |
| ) -> u_long; |
| pub fn ntohs( |
| netshort: u_short, |
| ) -> u_short; |
| pub fn recv( |
| s: SOCKET, |
| buf: *mut c_char, |
| len: c_int, |
| flags: c_int, |
| ) -> c_int; |
| pub fn recvfrom( |
| s: SOCKET, |
| buf: *mut c_char, |
| len: c_int, |
| flags: c_int, |
| from: *mut SOCKADDR, |
| fromlen: *mut c_int, |
| ) -> c_int; |
| pub fn select( |
| nfds: c_int, |
| readfds: *mut fd_set, |
| writefds: *mut fd_set, |
| exceptfds: *mut fd_set, |
| timeout: *const timeval, |
| ) -> c_int; |
| pub fn send( |
| s: SOCKET, |
| buf: *const c_char, |
| len: c_int, |
| flags: c_int, |
| ) -> c_int; |
| pub fn sendto( |
| s: SOCKET, |
| buf: *const c_char, |
| len: c_int, |
| flags: c_int, |
| to: *const SOCKADDR, |
| tolen: c_int, |
| ) -> c_int; |
| pub fn setsockopt( |
| s: SOCKET, |
| level: c_int, |
| optname: c_int, |
| optval: *const c_char, |
| optlen: c_int, |
| ) -> c_int; |
| pub fn shutdown( |
| s: SOCKET, |
| how: c_int, |
| ) -> c_int; |
| pub fn socket( |
| af: c_int, |
| _type: c_int, |
| protocol: c_int, |
| ) -> SOCKET; |
| pub fn gethostbyaddr( |
| addr: *const c_char, |
| len: c_int, |
| _type: c_int, |
| ) -> *mut hostent; |
| pub fn gethostbyname( |
| name: *const c_char, |
| ) -> *mut hostent; |
| pub fn gethostname( |
| name: *mut c_char, |
| namelen: c_int, |
| ) -> c_int; |
| pub fn GetHostNameW( |
| name: PWSTR, |
| namelen: c_int, |
| ) -> c_int; |
| pub fn getservbyport( |
| port: c_int, |
| proto: *const c_char, |
| ) -> *mut servent; |
| pub fn getservbyname( |
| name: *const c_char, |
| proto: *const c_char, |
| ) -> *mut servent; |
| pub fn getprotobynumber( |
| number: c_int, |
| ) -> *mut protoent; |
| pub fn getprotobyname( |
| name: *const c_char, |
| ) -> *mut protoent; |
| pub fn WSAStartup( |
| wVersionRequested: WORD, |
| lpWSAData: LPWSADATA, |
| ) -> c_int; |
| pub fn WSACleanup() -> c_int; |
| pub fn WSASetLastError( |
| iError: c_int, |
| ); |
| pub fn WSAGetLastError() -> c_int; |
| pub fn WSAIsBlocking() -> BOOL; |
| pub fn WSAUnhookBlockingHook() -> c_int; |
| pub fn WSASetBlockingHook( |
| lpBlockFunc: FARPROC, |
| ) -> FARPROC; |
| pub fn WSACancelBlockingCall() -> c_int; |
| pub fn WSAAsyncGetServByName( |
| hWnd: HWND, |
| wMsg: u_int, |
| name: *const c_char, |
| proto: *const c_char, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSAAsyncGetServByPort( |
| hWnd: HWND, |
| wMsg: u_int, |
| port: c_int, |
| proto: *const c_char, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSAAsyncGetProtoByName( |
| hWnd: HWND, |
| wMsg: u_int, |
| name: *const c_char, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSAAsyncGetProtoByNumber( |
| hWnd: HWND, |
| wMsg: u_int, |
| number: c_int, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSAAsyncGetHostByName( |
| hWnd: HWND, |
| wMsg: u_int, |
| name: *const c_char, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSAAsyncGetHostByAddr( |
| hWnd: HWND, |
| wMsg: u_int, |
| addr: *const c_char, |
| len: c_int, |
| _type: c_int, |
| buf: *mut c_char, |
| buflen: c_int, |
| ) -> HANDLE; |
| pub fn WSACancelAsyncRequest( |
| hAsyncTaskHandle: HANDLE, |
| ) -> c_int; |
| pub fn WSAAsyncSelect( |
| s: SOCKET, |
| hWnd: HWND, |
| wMsg: u_int, |
| lEvent: c_long, |
| ) -> c_int; |
| pub fn WSAAccept( |
| s: SOCKET, |
| addr: *mut SOCKADDR, |
| addrlen: LPINT, |
| lpfnCondition: LPCONDITIONPROC, |
| dwCallbackData: DWORD_PTR, |
| ) -> SOCKET; |
| pub fn WSACloseEvent( |
| hEvent: WSAEVENT, |
| ) -> BOOL; |
| pub fn WSAConnect( |
| s: SOCKET, |
| name: *const SOCKADDR, |
| namelen: c_int, |
| lpCallerData: LPWSABUF, |
| lpCalleeData: LPWSABUF, |
| lpSQOS: LPQOS, |
| lpGQOS: LPQOS, |
| ) -> c_int; |
| pub fn WSAConnectByNameW( |
| s: SOCKET, |
| nodename: LPWSTR, |
| servicename: LPWSTR, |
| LocalAddressLength: LPDWORD, |
| LocalAddress: LPSOCKADDR, |
| RemoteAddressLength: LPDWORD, |
| RemoteAddress: LPSOCKADDR, |
| timeout: *const timeval, |
| Reserved: LPWSAOVERLAPPED, |
| ) -> BOOL; |
| pub fn WSAConnectByNameA( |
| s: SOCKET, |
| nodename: LPCSTR, |
| servicename: LPCSTR, |
| LocalAddressLength: LPDWORD, |
| LocalAddress: LPSOCKADDR, |
| RemoteAddressLength: LPDWORD, |
| RemoteAddress: LPSOCKADDR, |
| timeout: *const timeval, |
| Reserved: LPWSAOVERLAPPED, |
| ) -> BOOL; |
| pub fn WSAConnectByList( |
| s: SOCKET, |
| SocketAddress: PSOCKET_ADDRESS_LIST, |
| LocalAddressLength: LPDWORD, |
| LocalAddress: LPSOCKADDR, |
| RemoteAddressLength: LPDWORD, |
| RemoteAddress: LPSOCKADDR, |
| timeout: *const timeval, |
| Reserved: LPWSAOVERLAPPED, |
| ) -> BOOL; |
| pub fn WSACreateEvent() -> WSAEVENT; |
| pub fn WSADuplicateSocketA( |
| s: SOCKET, |
| dwProcessId: DWORD, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOA, |
| ) -> c_int; |
| pub fn WSADuplicateSocketW( |
| s: SOCKET, |
| dwProcessId: DWORD, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOW, |
| ) -> c_int; |
| pub fn WSAEnumNetworkEvents( |
| s: SOCKET, |
| hEventObject: WSAEVENT, |
| lpNetworkEvents: LPWSANETWORKEVENTS, |
| ) -> c_int; |
| pub fn WSAEnumProtocolsA( |
| lpiProtocols: LPINT, |
| lpProtocolBuffer: LPWSAPROTOCOL_INFOA, |
| lpdwBufferLength: LPDWORD, |
| ) -> c_int; |
| pub fn WSAEnumProtocolsW( |
| lpiProtocols: LPINT, |
| lpProtocolBuffer: LPWSAPROTOCOL_INFOW, |
| lpdwBufferLength: LPDWORD, |
| ) -> c_int; |
| pub fn WSAEventSelect( |
| s: SOCKET, |
| hEventObject: WSAEVENT, |
| lNetworkEvents: c_long, |
| ) -> c_int; |
| pub fn WSAGetOverlappedResult( |
| s: SOCKET, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpcbTransfer: LPDWORD, |
| fWait: BOOL, |
| lpdwFlags: LPDWORD, |
| ) -> BOOL; |
| pub fn WSAGetQOSByName( |
| s: SOCKET, |
| lpQOSName: LPWSABUF, |
| lpQOS: LPQOS, |
| ) -> BOOL; |
| pub fn WSAHtonl( |
| s: SOCKET, |
| hostlong: u_long, |
| lpnetlong: *mut u_long, |
| ) -> c_int; |
| pub fn WSAHtons(s: SOCKET, |
| hostshort: u_short, |
| lpnetshort: *mut u_short, |
| ) -> c_int; |
| pub fn WSAIoctl( |
| s: SOCKET, |
| dwIoControlCode: DWORD, |
| lpvInBuffer: LPVOID, |
| cbInBuffer: DWORD, |
| lpvOutBuffer: LPVOID, |
| cbOutBuffer: DWORD, |
| lpcbBytesReturned: LPDWORD, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSAJoinLeaf( |
| s: SOCKET, |
| name: *const SOCKADDR, |
| namelen: c_int, |
| lpCallerData: LPWSABUF, |
| lpCalleeData: LPWSABUF, |
| lpSQOS: LPQOS, |
| lpGQOS: LPQOS, |
| dwFlags: DWORD, |
| ) -> SOCKET; |
| pub fn WSANtohl( |
| s: SOCKET, |
| netlong: u_long, |
| lphostlong: *mut c_long, |
| ) -> c_int; |
| pub fn WSANtohs( |
| s: SOCKET, |
| netshort: u_short, |
| lphostshort: *mut c_short, |
| ) -> c_int; |
| pub fn WSARecv( |
| s: SOCKET, |
| lpBuffers: LPWSABUF, |
| dwBufferCount: DWORD, |
| lpNumberOfBytesRecvd: LPDWORD, |
| lpFlags: LPDWORD, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSARecvDisconnect( |
| s: SOCKET, |
| lpInboundDisconnectData: LPWSABUF, |
| ) -> c_int; |
| pub fn WSARecvFrom( |
| s: SOCKET, |
| lpBuffers: LPWSABUF, |
| dwBufferCount: DWORD, |
| lpNumberOfBytesRecvd: LPDWORD, |
| lpFlags: LPDWORD, |
| lpFrom: *mut SOCKADDR, |
| lpFromlen: LPINT, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSAResetEvent( |
| hEvent: WSAEVENT, |
| ) -> BOOL; |
| pub fn WSASend( |
| s: SOCKET, |
| lpBuffers: LPWSABUF, |
| dwBufferCount: DWORD, |
| lpNumberOfBytesSent: LPDWORD, |
| dwFlags: DWORD, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSASendMsg( |
| Handle: SOCKET, |
| lpMsg: LPWSAMSG, |
| dwFlags: DWORD, |
| lpNumberOfBytesSent: LPDWORD, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSASendDisconnect( |
| s: SOCKET, |
| lpOutboundDisconnectData: LPWSABUF, |
| ) -> c_int; |
| pub fn WSASendTo( |
| s: SOCKET, |
| lpBuffers: LPWSABUF, |
| dwBufferCount: DWORD, |
| lpNumberOfBytesSent: LPDWORD, |
| dwFlags: DWORD, |
| lpTo: *const SOCKADDR, |
| iToLen: c_int, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> c_int; |
| pub fn WSASetEvent( |
| hEvent: WSAEVENT, |
| ) -> BOOL; |
| pub fn WSASocketA( |
| af: c_int, |
| _type: c_int, |
| protocol: c_int, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOA, |
| g: GROUP, |
| dwFlags: DWORD, |
| ) -> SOCKET; |
| pub fn WSASocketW( |
| af: c_int, |
| _type: c_int, |
| protocol: c_int, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOW, |
| g: GROUP, |
| dwFlags: DWORD, |
| ) -> SOCKET; |
| pub fn WSAWaitForMultipleEvents( |
| cEvents: DWORD, |
| lphEvents: *const WSAEVENT, |
| fWaitAll: BOOL, |
| dwTimeout: DWORD, |
| fAlertable: BOOL, |
| ) -> DWORD; |
| pub fn WSAAddressToStringA( |
| lpsaAddress: LPSOCKADDR, |
| dwAddressLength: DWORD, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOA, |
| lpszAddressString: LPSTR, |
| lpdwAddressStringLength: LPDWORD, |
| ) -> INT; |
| pub fn WSAAddressToStringW( |
| lpsaAddress: LPSOCKADDR, |
| dwAddressLength: DWORD, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOW, |
| lpszAddressString: LPWSTR, |
| lpdwAddressStringLength: LPDWORD, |
| ) -> INT; |
| pub fn WSAStringToAddressA( |
| AddressString: LPSTR, |
| AddressFamily: INT, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOA, |
| lpAddress: LPSOCKADDR, |
| lpAddressLength: LPINT, |
| ) -> INT; |
| pub fn WSAStringToAddressW( |
| AddressString: LPWSTR, |
| AddressFamily: INT, |
| lpProtocolInfo: LPWSAPROTOCOL_INFOW, |
| lpAddress: LPSOCKADDR, |
| lpAddressLength: LPINT, |
| ) -> INT; |
| pub fn WSALookupServiceBeginA( |
| lpqsRestrictions: LPWSAQUERYSETA, |
| dwControlFlags: DWORD, |
| lphLookup: LPHANDLE, |
| ) -> INT; |
| pub fn WSALookupServiceBeginW( |
| lpqsRestrictions: LPWSAQUERYSETW, |
| dwControlFlags: DWORD, |
| lphLookup: LPHANDLE, |
| ) -> INT; |
| pub fn WSALookupServiceNextA( |
| hLookup: HANDLE, |
| dwControlFlags: DWORD, |
| lpdwBufferLength: LPDWORD, |
| lpqsResults: LPWSAQUERYSETA, |
| ) -> INT; |
| pub fn WSALookupServiceNextW( |
| hLookup: HANDLE, |
| dwControlFlags: DWORD, |
| lpdwBufferLength: LPDWORD, |
| lpqsResults: LPWSAQUERYSETW, |
| ) -> INT; |
| pub fn WSANSPIoctl( |
| hLookup: HANDLE, |
| dwControlFlags: DWORD, |
| lpvInBuffer: LPVOID, |
| cbInBuffer: DWORD, |
| lpvOutBuffer: LPVOID, |
| cbOutBuffer: DWORD, |
| lpcbBytesReturned: LPDWORD, |
| lpCompletion: LPWSACOMPLETION, |
| ) -> INT; |
| pub fn WSALookupServiceEnd( |
| hLookup: HANDLE, |
| ) -> INT; |
| pub fn WSAInstallServiceClassA( |
| lpServiceClassInfo: LPWSASERVICECLASSINFOA, |
| ) -> INT; |
| pub fn WSAInstallServiceClassW( |
| lpServiceClassInfo: LPWSASERVICECLASSINFOW, |
| ) -> INT; |
| pub fn WSARemoveServiceClass( |
| lpServiceClassId: LPGUID, |
| ) -> INT; |
| pub fn WSAGetServiceClassInfoA( |
| lpProviderId: LPGUID, |
| lpServiceClassId: LPGUID, |
| lpdwBufSize: LPDWORD, |
| lpServiceClassInfo: LPWSASERVICECLASSINFOA, |
| ) -> INT; |
| pub fn WSAGetServiceClassInfoW( |
| lpProviderId: LPGUID, |
| lpServiceClassId: LPGUID, |
| lpdwBufSize: LPDWORD, |
| lpServiceClassInfo: LPWSASERVICECLASSINFOW, |
| ) -> INT; |
| pub fn WSAEnumNameSpaceProvidersA( |
| lpdwBufferLength: LPDWORD, |
| lpnspBuffer: LPWSANAMESPACE_INFOA, |
| ) -> INT; |
| pub fn WSAEnumNameSpaceProvidersW( |
| lpdwBufferLength: LPDWORD, |
| lpnspBuffer: LPWSANAMESPACE_INFOW, |
| ) -> INT; |
| pub fn WSAEnumNameSpaceProvidersExA( |
| lpdwBufferLength: LPDWORD, |
| lpnspBuffer: LPWSANAMESPACE_INFOEXA, |
| ) -> INT; |
| pub fn WSAEnumNameSpaceProvidersExW( |
| lpdwBufferLength: LPDWORD, |
| lpnspBuffer: LPWSANAMESPACE_INFOEXW, |
| ) -> INT; |
| pub fn WSAGetServiceClassNameByClassIdA( |
| lpServiceClassId: LPGUID, |
| lpszServiceClassName: LPSTR, |
| lpdwBufferLength: LPDWORD, |
| ) -> INT; |
| pub fn WSAGetServiceClassNameByClassIdW( |
| lpServiceClassId: LPGUID, |
| lpszServiceClassName: LPWSTR, |
| lpdwBufferLength: LPDWORD, |
| ) -> INT; |
| pub fn WSASetServiceA( |
| lpqsRegInfo: LPWSAQUERYSETA, |
| essoperation: WSAESETSERVICEOP, |
| dwControlFlags: DWORD, |
| ) -> INT; |
| pub fn WSASetServiceW( |
| lpqsRegInfo: LPWSAQUERYSETW, |
| essoperation: WSAESETSERVICEOP, |
| dwControlFlags: DWORD, |
| ) -> INT; |
| pub fn WSAProviderConfigChange( |
| lpNotificationHandle: LPHANDLE, |
| lpOverlapped: LPWSAOVERLAPPED, |
| lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE, |
| ) -> INT; |
| pub fn WSAPoll( |
| fdArray: LPWSAPOLLFD, |
| fds: ULONG, |
| timeout: INT, |
| ) -> c_int; |
| } |
| pub type LPSOCKADDR_IN = *mut SOCKADDR_IN; |
| pub type LINGER = linger; |
| pub type PLINGER = *mut linger; |
| pub type LPLINGER = *mut linger; |
| pub type FD_SET = fd_set; |
| pub type PFD_SET = *mut fd_set; |
| pub type LPFD_SET = *mut fd_set; |
| pub type HOSTENT = hostent; |
| pub type PHOSTENT = *mut hostent; |
| pub type LPHOSTENT = *mut hostent; |
| pub type SERVENT = servent; |
| pub type PSERVENT = *mut servent; |
| pub type LPSERVENT = *mut servent; |
| pub type PROTOENT = protoent; |
| pub type PPROTOENT = *mut protoent; |
| pub type LPPROTOENT = *mut protoent; |
| pub type TIMEVAL = timeval; |
| pub type PTIMEVAL = *mut timeval; |
| pub type LPTIMEVAL = *mut timeval; |
| #[inline] |
| pub fn WSAMAKEASYNCREPLY(buflen: WORD, error: WORD) -> LONG { |
| MAKELONG(buflen, error) |
| } |
| #[inline] |
| pub fn WSAMAKESELECTREPLY(event: WORD, error: WORD) -> LONG { |
| MAKELONG(event, error) |
| } |
| #[inline] |
| pub fn WSAGETASYNCBUFLEN(lParam: DWORD) -> WORD { |
| LOWORD(lParam) |
| } |
| #[inline] |
| pub fn WSAGETASYNCERROR(lParam: DWORD) -> WORD { |
| HIWORD(lParam) |
| } |
| #[inline] |
| pub fn WSAGETSELECTEVENT(lParam: DWORD) -> WORD { |
| LOWORD(lParam) |
| } |
| #[inline] |
| pub fn WSAGETSELECTERROR(lParam: DWORD) -> WORD { |
| HIWORD(lParam) |
| } |
