winsock2.rs - mozsearch

comm-central/third_party/rust/winapi/src/um/winsock2.rs

Enable keyboard shortcuts

Revision control

Copy as Markdown

Other Tools

HG Web

// 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)