#[cfg(windows)]

crate::vm::stdlib::nt::init_winsock();

_socket::make_module(vm)

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

use crate::vm::{

builtins::{PyBaseExceptionRef, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},

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

function::{ArgBytesLike, ArgMemoryBuffer, Either, OptionalArg, OptionalOption},

types::{DefaultConstructor, Initializer},

utils::ToCString,

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

};

use crossbeam_utils::atomic::AtomicCell;

use num_traits::ToPrimitive;

use socket2::{Domain, Protocol, Socket, Type as SocketType};

use std::{

ffi,

io::{self, Read, Write},

mem::MaybeUninit,

net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs},

time::{Duration, Instant},

};

#[cfg(unix)]

use libc as c;

#[cfg(windows)]

mod c {

pub use winapi::shared::ifdef::IF_MAX_STRING_SIZE as IF_NAMESIZE;

pub use winapi::shared::mstcpip::*;

pub use winapi::shared::netioapi::{if_indextoname, if_nametoindex};

pub use winapi::shared::ws2def::*;

pub use winapi::shared::ws2ipdef::*;

pub use winapi::um::winsock2::{

IPPORT_RESERVED, SD_BOTH as SHUT_RDWR, SD_RECEIVE as SHUT_RD, SD_SEND as SHUT_WR,

SOCK_DGRAM, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM, SOL_SOCKET, SO_BROADCAST,

SO_ERROR, SO_EXCLUSIVEADDRUSE, SO_LINGER, SO_OOBINLINE, SO_REUSEADDR, SO_TYPE,

SO_USELOOPBACK, *,

};

pub use winapi::um::ws2tcpip::*;

}

// constants

#[pyattr(name = "has_ipv6")]

const HAS_IPV6: bool = true;

#[pyattr]

// put IPPROTO_MAX later

use c::{

AF_DECnet, AF_APPLETALK, AF_INET, AF_INET6, AF_IPX, AF_UNSPEC, INADDR_ANY, INADDR_LOOPBACK,

INADDR_NONE, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP, IPPROTO_FRAGMENT,

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

IPPROTO_IP as IPPROTO_IPIP, IPPROTO_IPV6, IPPROTO_NONE, IPPROTO_PIM, IPPROTO_PUP,

IPPROTO_RAW, IPPROTO_ROUTING, 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,

SOCK_DGRAM, SOCK_STREAM, SOL_SOCKET, SO_BROADCAST, SO_ERROR, SO_LINGER, SO_OOBINLINE,

SO_REUSEADDR, SO_TYPE, TCP_NODELAY,

};

#[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, SOL_CAN_BASE,

SOL_CAN_RAW, SO_J1939_ERRQUEUE, SO_J1939_FILTER, SO_J1939_PROMISC, SO_J1939_SEND_PRIO,

};

#[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};

#[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_KEEPALIVE, SO_RCVBUF,

SO_RCVLOWAT, SO_RCVTIMEO, SO_SNDBUF, 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, IPV6_DSTOPTS, IPV6_NEXTHOP, IPV6_PATHMTU, IPV6_RECVDSTOPTS,

IPV6_RECVHOPLIMIT, IPV6_RECVHOPOPTS, IPV6_RECVPATHMTU, IPV6_RTHDRDSTOPTS,

IP_DEFAULT_MULTICAST_LOOP, IP_RECVOPTS, IP_RETOPTS, NETLINK_CRYPTO, NETLINK_DNRTMSG,

NETLINK_FIREWALL, NETLINK_IP6_FW, NETLINK_NFLOG, NETLINK_ROUTE, NETLINK_USERSOCK,

NETLINK_XFRM, SOL_ALG, SO_PASSSEC, SO_PEERSEC,

};

#[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, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP,

IPV6_UNICAST_HOPS, IPV6_V6ONLY, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_IF,

IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL,

};

#[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, SOL_IP, SOL_TIPC,

SOL_UDP, SO_BINDTODEVICE, SO_MARK, 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::{IPV6_HOPOPTS, IPV6_RECVRTHDR, IPV6_RTHDR, IP_OPTIONS};

#[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, IPPROTO_GGP, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, IP_RECVDSTADDR, 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, IPV6_RECVTCLASS, IPV6_TCLASS, IP_HDRINCL, IP_TOS, 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 winapi::shared::ws2def::{

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]

fn htonl(x: u32) -> u32 {

u32::to_be(x)

}

#[pyfunction]

fn htons(x: u16) -> u16 {

u16::to_be(x)

}

#[pyfunction]

fn ntohl(x: u32) -> u32 {

u32::from_be(x)

}

#[pyfunction]

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

};

#[cfg(windows)]

use winapi::shared::netioapi;

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".to_owned()));

}

let int = obj

.try_index_opt(vm)

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

int.try_to_primitive::<CastFrom>(vm)

.map(|sock| sock as RawSocket)

}

#[cfg(unix)]

mod nullable_socket {

use super::*;

use std::os::unix::io::AsRawFd;

#[derive(Debug)]

#[repr(transparent)]

pub struct NullableSocket(Option<socket2::Socket>);

impl From<socket2::Socket> for NullableSocket {

fn from(sock: socket2::Socket) -> Self {

NullableSocket(Some(sock))

}

}

impl NullableSocket {

pub fn invalid() -> Self {

Self(None)

}

pub fn get(&self) -> Option<&socket2::Socket> {

self.0.as_ref()

}

pub fn fd(&self) -> RawSocket {

self.get().map_or(INVALID_SOCKET, |sock| sock.as_raw_fd())

}

pub fn insert(&mut self, sock: socket2::Socket) -> &mut socket2::Socket {

self.0.insert(sock)

}

}

}

#[cfg(windows)]

mod nullable_socket {

use super::*;

use std::os::windows::io::{AsRawSocket, FromRawSocket};

// TODO: may change if windows changes its TcpStream repr

#[derive(Debug)]

#[repr(transparent)]

pub struct NullableSocket(socket2::Socket);

impl From<socket2::Socket> for NullableSocket {

fn from(sock: socket2::Socket) -> Self {

NullableSocket(sock)

}

}

impl NullableSocket {

pub fn invalid() -> Self {

// TODO: may become UB in the future; maybe see rust-lang/rust#74699

Self(unsafe { socket2::Socket::from_raw_socket(INVALID_SOCKET) })

}

pub fn get(&self) -> Option<&socket2::Socket> {

(self.0.as_raw_socket() != INVALID_SOCKET).then(|| &self.0)

}

pub fn fd(&self) -> RawSocket {

self.0.as_raw_socket()

}

pub fn insert(&mut self, sock: socket2::Socket) -> &mut socket2::Socket {

self.0 = sock;

&mut self.0

}

}

}

use nullable_socket::NullableSocket;

impl Default for NullableSocket {

fn default() -> Self {

Self::invalid()

}

}

#[pyattr(name = "socket")]

#[pyattr(name = "SocketType")]

#[pyclass(name = "socket")]

#[derive(Debug, PyPayload)]

pub struct PySocket {

kind: AtomicCell<i32>,

family: AtomicCell<i32>,

proto: AtomicCell<i32>,

pub(crate) timeout: AtomicCell<f64>,

sock: PyRwLock<NullableSocket>,

}

impl Default for PySocket {

fn default() -> Self {

PySocket {

kind: AtomicCell::default(),

family: AtomicCell::default(),

proto: AtomicCell::default(),

timeout: AtomicCell::new(-1.0),

sock: PyRwLock::new(NullableSocket::invalid()),

}

}

}

#[cfg(windows)]

const CLOSED_ERR: i32 = c::WSAENOTSOCK;

#[cfg(unix)]

const CLOSED_ERR: i32 = c::EBADF;

impl Read for &PySocket {

fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {

(&mut &*self.sock()?).read(buf)

}

}

impl Write for &PySocket {

fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {

(&mut &*self.sock()?).write(buf)

}

fn flush(&mut self) -> std::io::Result<()> {

(&mut &*self.sock()?).flush()

}

}

impl PySocket {

pub fn sock_opt(&self) -> Option<PyMappedRwLockReadGuard<'_, Socket>> {

PyRwLockReadGuard::try_map(self.sock.read(), |sock| sock.get()).ok()

}

pub fn sock(&self) -> io::Result<PyMappedRwLockReadGuard<'_, Socket>> {

self.sock_opt()

.ok_or_else(|| io::Error::from_raw_os_error(CLOSED_ERR))

}

fn init_inner(

&self,

family: i32,

socket_kind: i32,

proto: i32,

sock: Socket,

) -> io::Result<()> {

self.family.store(family);

self.kind.store(socket_kind);

self.proto.store(proto);

let mut s = self.sock.write();

let sock = s.insert(sock);

let timeout = DEFAULT_TIMEOUT.load();

self.timeout.store(timeout);

if timeout >= 0.0 {

sock.set_nonblocking(true)?;

}

Ok(())

}

/// returns Err(blocking)

pub fn get_timeout(&self) -> Result<Duration, bool> {

let timeout = self.timeout.load();

if timeout > 0.0 {

Ok(Duration::from_secs_f64(timeout))

} else {

Err(timeout != 0.0)

}

}

fn sock_op<F, R>(

&self,

vm: &VirtualMachine,

select: SelectKind,

f: F,

) -> Result<R, IoOrPyException>

where

F: FnMut() -> io::Result<R>,

{

self.sock_op_timeout_err(vm, select, self.get_timeout().ok(), f)