use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};

#[cfg(all(unix, not(target_os = "redox")))]

use crate::vm::convert::ToPyException;

use crate::vm::{

AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,

builtins::{

PyBaseExceptionRef, PyListRef, PyModule, PyOSError, PyStrRef, PyTupleRef, PyTypeRef,

PyUtf8StrRef,

},

convert::{IntoPyException, ToPyObject, TryFromBorrowedObject, TryFromObject},

function::{

ArgBytesLike, ArgIntoFloat, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath,

OptionalArg, OptionalOption,

},

types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},

utils::ToCString,

};

use rustpython_host_env::os::ErrorExt;

#[cfg(any(unix, windows))]

use rustpython_host_env::socket as host_socket;

#[cfg(windows)]

use rustpython_host_env::windows as host_windows;

#[expect(clippy::unnecessary_wraps, reason = "Needs to comply with a signature")]

pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {

#[cfg(windows)]

host_windows::init_winsock();

__module_exec(vm, module);

Ok(())

}

use core::{

mem::MaybeUninit,

net::{Ipv4Addr, Ipv6Addr, SocketAddr},

time::Duration,

};

use crossbeam_utils::atomic::AtomicCell;

use num_traits::ToPrimitive;

use socket2::Socket;

use std::{

ffi,

io::{self, Read, Write},

net::{self, Shutdown, ToSocketAddrs},

time::Instant,

};

#[cfg(unix)]

use libc as c;

#[cfg(windows)]

mod c {

pub(super) use rustpython_host_env::socket::{

AF_APPLETALK, AF_DECnet, AF_INET, AF_INET6, AF_IPX, AF_LINK, AF_UNSPEC, AI_ADDRCONFIG,

AI_ALL, AI_CANONNAME, AI_NUMERICHOST, AI_NUMERICSERV, AI_PASSIVE, AI_V4MAPPED,

EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NODATA, EAI_NONAME,

EAI_SERVICE, EAI_SOCKTYPE, INADDR_ANY, INADDR_BROADCAST, INADDR_LOOPBACK, INADDR_NONE,

IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_HDRINCL, IP_MULTICAST_IF, IP_MULTICAST_LOOP,

IP_MULTICAST_TTL, IP_OPTIONS, IP_RECVDSTADDR, IP_TOS, IP_TTL, IPPORT_RESERVED,

IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP, IPPROTO_FRAGMENT, IPPROTO_GGP,

IPPROTO_HOPOPTS, IPPROTO_ICMP, IPPROTO_ICMPV6, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IP,

IPPROTO_IP as IPPROTO_IPIP, IPPROTO_IPV4, IPPROTO_IPV6, IPPROTO_ND, IPPROTO_NONE,

IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING, IPPROTO_TCP, IPPROTO_UDP,

IPV6_CHECKSUM, IPV6_DONTFRAG, IPV6_HOPLIMIT, IPV6_HOPOPTS, IPV6_JOIN_GROUP,

IPV6_LEAVE_GROUP, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP,

IPV6_PKTINFO, IPV6_RECVRTHDR, IPV6_RECVTCLASS, IPV6_RTHDR, IPV6_TCLASS,

IPV6_UNICAST_HOPS, IPV6_V6ONLY, MSG_BCAST, MSG_CTRUNC, MSG_DONTROUTE, MSG_MCAST,

MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM, NI_MAXHOST, NI_MAXSERV,

NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV, RCVALL_IPLEVEL, RCVALL_OFF,

RCVALL_ON, RCVALL_SOCKETLEVELONLY, SD_BOTH as SHUT_RDWR, SD_RECEIVE as SHUT_RD,

SD_SEND as SHUT_WR, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH, SIO_RCVALL,

SO_BROADCAST, SO_ERROR, SO_EXCLUSIVEADDRUSE, SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE,

SO_RCVBUF, SO_REUSEADDR, SO_SNDBUF, SO_TYPE, SO_USELOOPBACK, SOCK_DGRAM, SOCK_RAW,

SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM, SOL_SOCKET, SOMAXCONN, TCP_NODELAY, WSAEBADF,

WSAENOTSOCK, WSAEWOULDBLOCK, getprotobyname, getservbyname, getservbyport,

};

}

// constants

#[pyattr(name = "has_ipv6")]

const HAS_IPV6: bool = true;

#[pyattr]

// put IPPROTO_MAX later

use c::{

AF_INET, AF_INET6, AF_UNSPEC, INADDR_ANY, INADDR_LOOPBACK, INADDR_NONE, IPPROTO_ICMP,

IPPROTO_ICMPV6, IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP, IPPROTO_TCP as SOL_TCP, IPPROTO_UDP,

MSG_CTRUNC, MSG_DONTROUTE, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM, NI_MAXHOST,

NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV, SHUT_RD, SHUT_RDWR, SHUT_WR,

SO_BROADCAST, SO_ERROR, SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE, SO_RCVBUF, SO_REUSEADDR,

SO_SNDBUF, SO_TYPE, SOCK_DGRAM, SOCK_STREAM, SOL_SOCKET, TCP_NODELAY,

};

#[cfg(not(target_os = "redox"))]

#[pyattr]

use c::{

AF_APPLETALK, AF_DECnet, AF_IPX, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP,

IPPROTO_FRAGMENT, IPPROTO_HOPOPTS, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IPIP, IPPROTO_NONE,

IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING,

};

#[cfg(unix)]

#[pyattr]

use c::{AF_UNIX, SO_REUSEPORT};

#[pyattr]

use c::{AI_ADDRCONFIG, AI_NUMERICHOST, AI_NUMERICSERV, AI_PASSIVE};

#[cfg(not(target_os = "redox"))]

#[pyattr]

use c::{SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET};

#[cfg(target_os = "android")]

#[pyattr]

use c::{SOL_ATALK, SOL_AX25, SOL_IPX, SOL_NETROM, SOL_ROSE};

#[cfg(target_os = "freebsd")]

#[pyattr]

use c::SO_SETFIB;

#[cfg(target_os = "linux")]

#[pyattr]

use c::{

CAN_BCM, CAN_EFF_FLAG, CAN_EFF_MASK, CAN_ERR_FLAG, CAN_ERR_MASK, CAN_ISOTP, CAN_J1939,

CAN_RAW, CAN_RAW_ERR_FILTER, CAN_RAW_FD_FRAMES, CAN_RAW_FILTER, CAN_RAW_JOIN_FILTERS,

CAN_RAW_LOOPBACK, CAN_RAW_RECV_OWN_MSGS, CAN_RTR_FLAG, CAN_SFF_MASK, IPPROTO_MPTCP,

J1939_IDLE_ADDR, J1939_MAX_UNICAST_ADDR, J1939_NLA_BYTES_ACKED, J1939_NLA_PAD,

J1939_NO_ADDR, J1939_NO_NAME, J1939_NO_PGN, J1939_PGN_ADDRESS_CLAIMED,

J1939_PGN_ADDRESS_COMMANDED, J1939_PGN_MAX, J1939_PGN_PDU1_MAX, J1939_PGN_REQUEST,

SCM_J1939_DEST_ADDR, SCM_J1939_DEST_NAME, SCM_J1939_ERRQUEUE, SCM_J1939_PRIO,

SO_J1939_ERRQUEUE, SO_J1939_FILTER, SO_J1939_PROMISC, SO_J1939_SEND_PRIO, SOL_CAN_BASE,

SOL_CAN_RAW,

};

// CAN BCM opcodes

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_SETUP: i32 = 1;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_DELETE: i32 = 2;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_READ: i32 = 3;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_SEND: i32 = 4;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_SETUP: i32 = 5;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_DELETE: i32 = 6;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_READ: i32 = 7;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_STATUS: i32 = 8;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_EXPIRED: i32 = 9;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_STATUS: i32 = 10;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_TIMEOUT: i32 = 11;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_CHANGED: i32 = 12;

// CAN BCM flags (linux/can/bcm.h)

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_SETTIMER: i32 = 0x0001;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_STARTTIMER: i32 = 0x0002;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_COUNTEVT: i32 = 0x0004;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_ANNOUNCE: i32 = 0x0008;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_CP_CAN_ID: i32 = 0x0010;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_FILTER_ID: i32 = 0x0020;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_CHECK_DLC: i32 = 0x0040;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_NO_AUTOTIMER: i32 = 0x0080;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_ANNOUNCE_RESUME: i32 = 0x0100;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_TX_RESET_MULTI_IDX: i32 = 0x0200;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_RX_RTR_FRAME: i32 = 0x0400;

#[cfg(target_os = "linux")]

#[pyattr]

const CAN_BCM_CAN_FD_FRAME: i32 = 0x0800;

#[cfg(all(target_os = "linux", target_env = "gnu"))]

#[pyattr]

use c::SOL_RDS;

#[cfg(target_os = "netbsd")]

#[pyattr]

use c::IPPROTO_VRRP;

#[cfg(target_vendor = "apple")]

#[pyattr]

use c::{AF_SYSTEM, PF_SYSTEM, SYSPROTO_CONTROL, TCP_KEEPALIVE};

// RFC3542 IPv6 socket options for macOS (netinet6/in6.h)

// Not available in libc, define manually

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RECVHOPLIMIT: i32 = 37;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RECVRTHDR: i32 = 38;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RECVHOPOPTS: i32 = 39;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RECVDSTOPTS: i32 = 40;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_USE_MIN_MTU: i32 = 42;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RECVPATHMTU: i32 = 43;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_PATHMTU: i32 = 44;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_NEXTHOP: i32 = 48;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_HOPOPTS: i32 = 49;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_DSTOPTS: i32 = 50;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RTHDR: i32 = 51;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RTHDRDSTOPTS: i32 = 57;

#[cfg(target_vendor = "apple")]

#[pyattr]

const IPV6_RTHDR_TYPE_0: i32 = 0;

#[cfg(windows)]

#[pyattr]

use c::{

IPPORT_RESERVED, IPPROTO_IPV4, RCVALL_IPLEVEL, RCVALL_OFF, RCVALL_ON,

RCVALL_SOCKETLEVELONLY, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH, SIO_RCVALL,

SO_EXCLUSIVEADDRUSE,

};

#[cfg(not(windows))]

#[pyattr]

const IPPORT_RESERVED: i32 = 1024;

#[pyattr]

const IPPORT_USERRESERVED: i32 = 5000;

#[cfg(any(unix, target_os = "android"))]

#[pyattr]

use c::{

EAI_SYSTEM, MSG_EOR, SO_ACCEPTCONN, SO_DEBUG, SO_DONTROUTE, SO_RCVLOWAT, SO_RCVTIMEO,

SO_SNDLOWAT, SO_SNDTIMEO,

};

#[cfg(any(target_os = "android", target_os = "linux"))]

#[pyattr]

use c::{

ALG_OP_DECRYPT, ALG_OP_ENCRYPT, ALG_SET_AEAD_ASSOCLEN, ALG_SET_AEAD_AUTHSIZE, ALG_SET_IV,

ALG_SET_KEY, ALG_SET_OP, IP_DEFAULT_MULTICAST_LOOP, IP_RECVOPTS, IP_RETOPTS, IPV6_DSTOPTS,

IPV6_NEXTHOP, IPV6_PATHMTU, IPV6_RECVDSTOPTS, IPV6_RECVHOPLIMIT, IPV6_RECVHOPOPTS,

IPV6_RECVPATHMTU, IPV6_RTHDRDSTOPTS, NETLINK_CRYPTO, NETLINK_DNRTMSG, NETLINK_FIREWALL,

NETLINK_IP6_FW, NETLINK_NFLOG, NETLINK_ROUTE, NETLINK_USERSOCK, NETLINK_XFRM, SO_PASSSEC,

SO_PEERSEC, SOL_ALG,

};

#[cfg(any(target_os = "android", target_vendor = "apple"))]

#[pyattr]

use c::{AI_DEFAULT, AI_MASK, AI_V4MAPPED_CFG};

#[cfg(any(target_os = "freebsd", target_os = "netbsd"))]

#[pyattr]

use c::MSG_NOTIFICATION;

#[cfg(any(target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

use c::TCP_USER_TIMEOUT;

#[cfg(any(unix, target_os = "android", windows))]

#[pyattr]

use c::{

INADDR_BROADCAST, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_IF,

IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF,

IPV6_MULTICAST_LOOP, IPV6_UNICAST_HOPS, IPV6_V6ONLY,

};

#[cfg(any(unix, target_os = "android", windows))]

#[pyattr]

const INADDR_UNSPEC_GROUP: u32 = 0xe0000000;

#[cfg(any(unix, target_os = "android", windows))]

#[pyattr]

const INADDR_ALLHOSTS_GROUP: u32 = 0xe0000001;

#[cfg(any(unix, target_os = "android", windows))]

#[pyattr]

const INADDR_MAX_LOCAL_GROUP: u32 = 0xe00000ff;

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

use c::{

AF_ALG, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25, AF_BRIDGE, AF_CAN, AF_ECONET, AF_IRDA,

AF_LLC, AF_NETBEUI, AF_NETLINK, AF_NETROM, AF_PACKET, AF_PPPOX, AF_RDS, AF_SECURITY,

AF_TIPC, AF_VSOCK, AF_WANPIPE, AF_X25, IP_TRANSPARENT, MSG_CONFIRM, MSG_ERRQUEUE,

MSG_FASTOPEN, MSG_MORE, PF_CAN, PF_PACKET, PF_RDS, SCM_CREDENTIALS, SO_BINDTODEVICE,

SO_MARK, SOL_IP, SOL_TIPC, SOL_UDP, TCP_CORK, TCP_DEFER_ACCEPT, TCP_LINGER2, TCP_QUICKACK,

TCP_SYNCNT, TCP_WINDOW_CLAMP,

};

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const SO_VM_SOCKETS_BUFFER_SIZE: u32 = 0;

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const SO_VM_SOCKETS_BUFFER_MIN_SIZE: u32 = 1;

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const SO_VM_SOCKETS_BUFFER_MAX_SIZE: u32 = 2;

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const VMADDR_CID_ANY: u32 = 0xffffffff; // 0xffffffff

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const VMADDR_PORT_ANY: u32 = 0xffffffff; // 0xffffffff

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const VMADDR_CID_HOST: u32 = 2;

// gated on presence of AF_VSOCK:

#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

#[pyattr]

const VM_SOCKETS_INVALID_VERSION: u32 = 0xffffffff; // 0xffffffff

// TODO: gated on https://github.com/rust-lang/libc/pull/1662

// // gated on presence of AF_VSOCK:

// #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

// #[pyattr(name = "IOCTL_VM_SOCKETS_GET_LOCAL_CID", once)]

// fn ioctl_vm_sockets_get_local_cid(_vm: &VirtualMachine) -> i32 {

// c::_IO(7, 0xb9)

// }

#[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]

#[pyattr]

const SOL_IP: i32 = 0;

#[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]

#[pyattr]

const SOL_UDP: i32 = 17;

#[cfg(any(target_os = "android", target_os = "linux", windows))]

#[pyattr]

use c::{IP_OPTIONS, IPV6_HOPOPTS, IPV6_RECVRTHDR, IPV6_RTHDR};

#[cfg(any(

#[pyattr]

use c::{IPPROTO_HELLO, IPPROTO_XTP, LOCAL_PEERCRED, MSG_EOF};

#[cfg(any(target_os = "netbsd", target_os = "openbsd", windows))]

#[pyattr]

use c::{MSG_BCAST, MSG_MCAST};

#[cfg(any(

#[pyattr]

use c::{IPPROTO_UDPLITE, TCP_CONGESTION};

#[cfg(any(

#[pyattr]

const UDPLITE_SEND_CSCOV: i32 = 10;

#[cfg(any(

#[pyattr]

const UDPLITE_RECV_CSCOV: i32 = 11;

#[cfg(any(

#[pyattr]

use c::AF_KEY;

#[cfg(any(

#[pyattr]

use c::SO_DOMAIN;

#[cfg(any(

#[pyattr]

use c::SO_PRIORITY;

#[cfg(any(

#[pyattr]

use c::IPPROTO_MOBILE;

#[cfg(any(

#[pyattr]

use c::SCM_CREDS;

#[cfg(any(

#[pyattr]

use c::TCP_FASTOPEN;

#[cfg(any(

#[pyattr]

use c::SO_PROTOCOL;

#[cfg(any(

#[pyattr]

use c::IPV6_DONTFRAG;

#[cfg(any(

#[pyattr]

use c::{SO_PASSCRED, SO_PEERCRED};

#[cfg(any(

#[pyattr]

use c::TCP_INFO;

#[cfg(any(

#[pyattr]

use c::IP_RECVTOS;

#[cfg(any(

#[pyattr]

use c::NI_MAXSERV;

#[cfg(any(

#[pyattr]

use c::{IPPROTO_EON, IPPROTO_IPCOMP};

#[cfg(any(

#[pyattr]

use c::IPPROTO_ND;

#[cfg(any(

#[pyattr]

use c::{IPV6_CHECKSUM, IPV6_HOPLIMIT};

#[cfg(any(

#[pyattr]

use c::IPPROTO_SCTP; // also in windows

#[cfg(any(

#[pyattr]

use c::{AI_ALL, AI_V4MAPPED};

#[cfg(any(

#[pyattr]

use c::EAI_NODATA;

#[cfg(any(

#[pyattr]

use c::{

AF_LINK, IP_RECVDSTADDR, IPPROTO_GGP, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, SO_USELOOPBACK,

};

#[cfg(any(

#[pyattr]

use c::{MSG_CMSG_CLOEXEC, MSG_NOSIGNAL};

#[cfg(any(

#[pyattr]

use c::TCP_KEEPIDLE;

#[cfg(any(

#[pyattr]

use c::{TCP_KEEPCNT, TCP_KEEPINTVL};

#[cfg(any(

#[pyattr]

use c::{SOCK_CLOEXEC, SOCK_NONBLOCK};

#[cfg(any(

#[pyattr]

use c::{

AF_ROUTE, AF_SNA, EAI_OVERFLOW, IPPROTO_GRE, IPPROTO_RSVP, IPPROTO_TP, IPV6_RECVPKTINFO,

MSG_DONTWAIT, SCM_RIGHTS, TCP_MAXSEG,

};

#[cfg(any(

#[pyattr]

use c::IPV6_PKTINFO;

#[cfg(any(

#[pyattr]

use c::AI_CANONNAME;

#[cfg(any(

#[pyattr]

use c::{

EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NONAME, EAI_SERVICE,

EAI_SOCKTYPE, IP_HDRINCL, IP_TOS, IPV6_RECVTCLASS, IPV6_TCLASS, SOMAXCONN,

};

#[cfg(not(any(

#[pyattr]

const SOMAXCONN: i32 = 5; // Common value

// HERE IS WHERE THE BLUETOOTH CONSTANTS START

// TODO: there should be a more intelligent way of detecting bluetooth on a platform.

// CPython uses header-detection, but blocks NetBSD and DragonFly BSD

#[cfg(any(

#[pyattr]

use c::AF_BLUETOOTH;

#[cfg(any(

#[pyattr]

const BDADDR_ANY: &str = "00:00:00:00:00:00";

#[cfg(any(

#[pyattr]

const BDADDR_LOCAL: &str = "00:00:00:FF:FF:FF";

// HERE IS WHERE THE BLUETOOTH CONSTANTS END

#[cfg(windows)]

#[pyattr]

use host_socket::{

IPPROTO_CBT, IPPROTO_ICLFXBM, IPPROTO_IGP, IPPROTO_L2TP, IPPROTO_PGM, IPPROTO_RDP,

IPPROTO_SCTP, IPPROTO_ST,

};

#[pyattr]

fn error(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx.exceptions.os_error.to_owned()

}

#[pyattr]

fn timeout(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx.exceptions.timeout_error.to_owned()

}

#[pyattr(once)]

fn herror(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx.new_exception_type(

"socket",

"herror",

Some(vec![vm.ctx.exceptions.os_error.to_owned()]),

)

}

#[pyattr(once)]

fn gaierror(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx.new_exception_type(

"socket",

"gaierror",

Some(vec![vm.ctx.exceptions.os_error.to_owned()]),

)

}

#[pyfunction]

const fn htonl(x: u32) -> u32 {

u32::to_be(x)

}

#[pyfunction]

const fn htons(x: u16) -> u16 {

u16::to_be(x)

}

#[pyfunction]

const fn ntohl(x: u32) -> u32 {

u32::from_be(x)

}

#[pyfunction]

const fn ntohs(x: u16) -> u16 {

u16::from_be(x)

}

#[cfg(unix)]

type RawSocket = std::os::unix::io::RawFd;

#[cfg(windows)]

type RawSocket = std::os::windows::raw::SOCKET;

#[cfg(unix)]

macro_rules! errcode {

($e:ident) => {

c::$e

};

}

#[cfg(windows)]

macro_rules! errcode {

($e:ident) => {

paste::paste!(c::[<WSA $e>])

};

fn get_raw_sock(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<RawSocket> {

#[cfg(unix)]

type CastFrom = libc::c_long;

#[cfg(windows)]

type CastFrom = libc::c_longlong;

// should really just be to_index() but test_socket tests the error messages explicitly

if obj.fast_isinstance(vm.ctx.types.float_type) {

return Err(vm.new_type_error("integer argument expected, got float"));

}

let int = obj

.try_index_opt(vm)

.unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?;

int.try_to_primitive::<CastFrom>(vm)

.map(|sock| sock as RawSocket)

}

#[cfg(target_os = "linux")]

#[derive(FromArgs)]

struct SendmsgAfalgArgs {

#[pyarg(any, default)]

msg: Vec<ArgBytesLike>,

#[pyarg(named)]

op: u32,

#[pyarg(named, default)]

iv: Option<ArgBytesLike>,

#[pyarg(named, default)]

assoclen: OptionalArg<isize>,

#[pyarg(named, default)]

flags: i32,

}

#[pyattr(name = "socket")]