|
|
|
|
Quelle winsock2.rs
Sprache: unbekannt
|
|
// 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)
}
[ Dauer der Verarbeitung: 0.5 Sekunden
(vorverarbeitet)
]
|
2026-04-02
|
|
|
|
|
