# class Socket

`Class` `Socket` provides access to the underlying operating system socket implementations. It can be used to provide more operating system specific functionality than the protocol-specific socket classes.

The constants defined under `Socket::Constants` are also defined under `Socket`. For example, `Socket::AF_INET` is usable as well as Socket::Constants::AF_INET. See `Socket::Constants` for the list of constants.

### What’s a socket?¶ ↑

Sockets are endpoints of a bidirectional communication channel. Sockets can communicate within a process, between processes on the same machine or between different machines. There are many types of socket: `TCPSocket`, `UDPSocket` or `UNIXSocket` for example.

Sockets have their own vocabulary:

domain: The family of protocols:

- `Socket::PF_INET`

- `Socket::PF_INET6`

- `Socket::PF_UNIX`

- etc.

type: The type of communications between the two endpoints, typically

- `Socket::SOCK_STREAM`

- `Socket::SOCK_DGRAM`.

protocol: Typically zero. This may be used to identify a variant of a protocol.

hostname: The identifier of a network interface:

- a string (hostname, IPv4 or IPv6 address or `broadcast` which specifies a broadcast address)

- a zero-length string which specifies `INADDR_ANY`

- an integer (interpreted as binary address in host byte order).

### Quick start¶ ↑

Many of the classes, such as `TCPSocket`, `UDPSocket` or `UNIXSocket`, ease the use of sockets comparatively to the equivalent C programming interface.

Let’s create an internet socket using the IPv4 protocol in a C-like manner:

    require 'socket'

    s = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
    s.connect Socket.pack_sockaddr_in(80, 'example.com')

You could also use the `TCPSocket` class:

    s = TCPSocket.new 'example.com', 80

A simple server might look like this:

    require 'socket'

    server = TCPServer.new 2000 # Server bound to port 2000

    loop do
      client = server.accept    # Wait for a client to connect
      client.puts "Hello !"
      client.puts "Time is #{Time.now}"
      client.close
    end

A simple client may look like this:

    require 'socket'

    s = TCPSocket.new 'localhost', 2000

    while line = s.gets # Read lines from socket
      puts line         # and print them
    end

    s.close             # close socket when done

### `Exception` Handling¶ ↑

Ruby’s `Socket` implementation raises exceptions based on the error generated by the system dependent implementation. This is why the methods are documented in a way that isolate Unix-based system exceptions from Windows based exceptions. If more information on a particular exception is needed, please refer to the Unix manual pages or the Windows WinSock reference.

### Convenience methods¶ ↑

Although the general way to create socket is `Socket.new`, there are several methods of socket creation for most cases.

TCP client socket

  `Socket.tcp`, `TCPSocket.open`

TCP server socket

  `Socket.tcp_server_loop`, `TCPServer.open`

UNIX client socket

  `Socket.unix`, `UNIXSocket.open`

UNIX server socket

  `Socket.unix_server_loop`, `UNIXServer.open`

### Documentation by¶ ↑

- Zach Dennis

- Sam Roberts

- Programming Ruby from The Pragmatic Bookshelf.

Much material in this documentation is taken with permission from Programming Ruby from The Pragmatic Bookshelf.

### Constants

ADDRESS_FAMILIES
AF_ALG

  Interface to kernel crypto API

AF_APPLETALK

  AppleTalk protocol

AF_ATM

  Asynchronous Transfer Mode

AF_AX25

  AX.25 protocol

AF_BLUETOOTH

  Bluetooth low-level socket protocol

AF_CAN

  Controller Area Network automotive bus protocol

AF_CCITT

  CCITT (now ITU-T) protocols

AF_CHAOS

  MIT CHAOS protocols

AF_CNT

  Computer Network Technology

AF_COIP

  Connection-oriented IP

AF_DATAKIT

  Datakit protocol

AF_DEC

  DECnet protocol

AF_DECnet

  DECnet protocol

AF_DLI

  DEC Direct Data Link Interface protocol

AF_E164

  CCITT (ITU-T) E.164 recommendation

AF_ECMA

  European Computer Manufacturers protocols

AF_HYLINK

  NSC Hyperchannel protocol

AF_IB

  InfiniBand native addressing

AF_IMPLINK

  ARPANET IMP protocol

AF_INET

  IPv4 protocol

AF_INET6

  IPv6 protocol

AF_IPX

  IPX protocol

AF_ISDN

  Integrated Services Digital Network

AF_ISO

  ISO Open Systems Interconnection protocols

AF_KCM

  KCM (kernel connection multiplexor) interface

AF_KEY

  Key management protocol, originally developed for usage with IPsec

AF_LAT

  Local Area Transport protocol

AF_LINK

  Link layer interface

AF_LLC

  Logical link control (IEEE 802.2 LLC) protocol

AF_LOCAL

  Host-internal protocols

AF_MAX

  Maximum address family for this platform

AF_MPLS

  Multiprotocol Label Switching

AF_NATM

  Native ATM access

AF_NDRV

  Network driver raw access

AF_NETBIOS

  NetBIOS

AF_NETGRAPH

  Netgraph sockets

AF_NETLINK

  Kernel user interface device

AF_NS

  XEROX NS protocols

AF_OSI

  ISO Open Systems Interconnection protocols

AF_PACKET

  Direct link-layer access

AF_PPP

  Point-to-Point Protocol

AF_PPPOX

  Generic PPP transport layer, for setting up L2 tunnels (L2TP and PPPoE)

AF_PUP

  PARC Universal Packet protocol

AF_RDS

  Reliable Datagram Sockets (RDS) protocol

AF_ROUTE

  Internal routing protocol

AF_SIP

  Simple Internet Protocol

AF_SNA

  IBM SNA protocol

AF_SYSTEM

  Kernel event messages

AF_TIPC

  TIPC, “cluster domain sockets” protocol

AF_UNIX

  UNIX sockets

AF_UNSPEC

  Unspecified protocol, any supported address family

AF_VSOCK

  VSOCK (originally “VMWare VSockets”) protocol for hypervisor-guest communication

AF_XDP

  XDP (express data path) interface

AI_ADDRCONFIG

  Accept only if any address is assigned

AI_ALL

  Allow all addresses

AI_CANONNAME

  Fill in the canonical name

AI_DEFAULT

  Default flags for getaddrinfo

AI_MASK

  Valid flag mask for getaddrinfo (not for application use)

AI_NUMERICHOST

  Prevent host name resolution

AI_NUMERICSERV

  Prevent service name resolution

AI_PASSIVE

  Get address to use with bind()

AI_V4MAPPED

  Accept IPv4-mapped IPv6 addresses

AI_V4MAPPED_CFG

  Accept IPv4 mapped addresses if the kernel supports it

CONNECTION_ATTEMPT_DELAY
EAI_ADDRFAMILY

  Address family for hostname not supported

EAI_AGAIN

  Temporary failure in name resolution

EAI_BADFLAGS

  Invalid flags

EAI_BADHINTS

  Invalid value for hints

EAI_FAIL

  Non-recoverable failure in name resolution

EAI_FAMILY

  Address family not supported

EAI_MAX

  Maximum error code from getaddrinfo

EAI_MEMORY

  Memory allocation failure

EAI_NODATA

  No address associated with hostname

EAI_NONAME

  Hostname nor servname, or not known

EAI_OVERFLOW

  Argument buffer overflow

EAI_PROTOCOL

  Resolved protocol is unknown

EAI_SERVICE

  Servname not supported for socket type

EAI_SOCKTYPE

  Socket type not supported

EAI_SYSTEM

  System error returned in errno

HOSTNAME_RESOLUTION_QUEUE_UPDATED
IFF_802_1Q_VLAN

  802.1Q VLAN device

IFF_ALLMULTI

  receive all multicast packets

IFF_ALTPHYS

  use alternate physical connection

IFF_AUTOMEDIA

  auto media select active

IFF_BONDING

  bonding master or slave

IFF_BRIDGE_PORT

  device used as bridge port

IFF_BROADCAST

  broadcast address valid

IFF_CANTCHANGE

  flags not changeable

IFF_CANTCONFIG

  unconfigurable using ioctl(2)

IFF_DEBUG

  turn on debugging

IFF_DISABLE_NETPOLL

  disable netpoll at run-time

IFF_DONT_BRIDGE

  disallow bridging this ether dev

IFF_DORMANT

  driver signals dormant

IFF_DRV_OACTIVE

  tx hardware queue is full

IFF_DRV_RUNNING

  resources allocated

IFF_DYING

  interface is winding down

IFF_DYNAMIC

  dialup device with changing addresses

IFF_EBRIDGE

  ethernet bridging device

IFF_ECHO

  echo sent packets

IFF_ISATAP

  ISATAP interface (RFC4214)

IFF_LINK0

  per link layer defined bit 0

IFF_LINK1

  per link layer defined bit 1

IFF_LINK2

  per link layer defined bit 2

IFF_LIVE_ADDR_CHANGE

  hardware address change when it’s running

IFF_LOOPBACK

  loopback net

IFF_LOWER_UP

  driver signals L1 up

IFF_MACVLAN_PORT

  device used as macvlan port

IFF_MASTER

  master of a load balancer

IFF_MASTER_8023AD

  bonding master, 802.3ad.

IFF_MASTER_ALB

  bonding master, balance-alb.

IFF_MASTER_ARPMON

  bonding master, ARP mon in use

IFF_MONITOR

  user-requested monitor mode

IFF_MULTICAST

  supports multicast

IFF_NOARP

  no address resolution protocol

IFF_NOTRAILERS

  avoid use of trailers

IFF_OACTIVE

  transmission in progress

IFF_OVS_DATAPATH

  device used as Open vSwitch datapath port

IFF_POINTOPOINT

  point-to-point link

IFF_PORTSEL

  can set media type

IFF_PPROMISC

  user-requested promisc mode

IFF_PROMISC

  receive all packets

IFF_RENAMING

  interface is being renamed

IFF_ROUTE

  routing entry installed

IFF_RUNNING

  resources allocated

IFF_SIMPLEX

  can’t hear own transmissions

IFF_SLAVE

  slave of a load balancer

IFF_SLAVE_INACTIVE

  bonding slave not the curr. active

IFF_SLAVE_NEEDARP

  need ARPs for validation

IFF_SMART

  interface manages own routes

IFF_STATICARP

  static ARP

IFF_SUPP_NOFCS

  sending custom FCS

IFF_TEAM_PORT

  used as team port

IFF_TX_SKB_SHARING

  sharing skbs on transmit

IFF_UNICAST_FLT

  unicast filtering

IFF_UP

  interface is up

IFF_VOLATILE

  volatile flags

IFF_WAN_HDLC

  WAN HDLC device

IFF_XMIT_DST_RELEASE

  dev_hard_start_xmit() is allowed to release skb->dst

IFNAMSIZ

  Maximum interface name size

IF_NAMESIZE

  Maximum interface name size

INADDR_ALLHOSTS_GROUP

  Multicast group for all systems on this subset

INADDR_ANY

  A socket bound to `INADDR_ANY` receives packets from all interfaces and sends from the default IP address

INADDR_BROADCAST

  The network broadcast address

INADDR_LOOPBACK

  The loopback address

INADDR_MAX_LOCAL_GROUP

  The last local network multicast group

INADDR_NONE

  A bitmask for matching no valid IP address

INADDR_UNSPEC_GROUP

  The reserved multicast group

INET6_ADDRSTRLEN

  Maximum length of an IPv6 address string

INET_ADDRSTRLEN

  Maximum length of an IPv4 address string

IPPORT_RESERVED

  Default minimum address for bind or connect

IPPORT_USERRESERVED

  Default maximum address for bind or connect

IPPROTO_AH

  IP6 auth header

IPPROTO_BIP

  `IPPROTO_BIP`

IPPROTO_DSTOPTS

  IP6 destination option

IPPROTO_EGP

  Exterior Gateway Protocol

IPPROTO_EON

  ISO cnlp

IPPROTO_ESP

  IP6 Encapsulated Security Payload

IPPROTO_FRAGMENT

  IP6 fragmentation header

IPPROTO_GGP

  Gateway to Gateway Protocol

IPPROTO_HELLO

  “hello” routing protocol

IPPROTO_HOPOPTS

  IP6 hop-by-hop options

IPPROTO_ICMP

  Control message protocol

IPPROTO_ICMPV6

  ICMP6

IPPROTO_IDP

  XNS IDP

IPPROTO_IGMP

  Group Management Protocol

IPPROTO_IP

  Dummy protocol for IP

IPPROTO_IPV6

  IP6 header

IPPROTO_MAX

  Maximum IPPROTO constant

IPPROTO_ND

  Sun net disk protocol

IPPROTO_NONE

  IP6 no next header

IPPROTO_PUP

  PARC Universal Packet protocol

IPPROTO_RAW

  Raw IP packet

IPPROTO_ROUTING

  IP6 routing header

IPPROTO_TCP

  TCP

IPPROTO_TP

  ISO transport protocol class 4

IPPROTO_UDP

  UDP

IPPROTO_XTP

  Xpress Transport Protocol

IPV6_ADRESS_FORMAT
IPV6_CHECKSUM

  Checksum offset for raw sockets

IPV6_DONTFRAG

  Don’t fragment packets

IPV6_DSTOPTS

  Destination option

IPV6_HOPLIMIT

  Hop limit

IPV6_HOPOPTS

  Hop-by-hop option

IPV6_JOIN_GROUP

  Join a group membership

IPV6_LEAVE_GROUP

  Leave a group membership

IPV6_MTU_DISCOVER

  Path MTU discovery

IPV6_MULTICAST_HOPS

  IP6 multicast hops

IPV6_MULTICAST_IF

  IP6 multicast interface

IPV6_MULTICAST_LOOP

  IP6 multicast loopback

IPV6_NEXTHOP

  Next hop address

IPV6_PATHMTU

  Retrieve current path MTU

IPV6_PKTINFO

  Receive packet information with datagram

IPV6_RECVDSTOPTS

  Receive all IP6 options for response

IPV6_RECVERR

  Enable extended reliable error message passing

IPV6_RECVHOPLIMIT

  Receive hop limit with datagram

IPV6_RECVHOPOPTS

  Receive hop-by-hop options

IPV6_RECVPATHMTU

  Receive current path MTU with datagram

IPV6_RECVPKTINFO

  Receive destination IP address and incoming interface

IPV6_RECVRTHDR

  Receive routing header

IPV6_RECVTCLASS

  Receive traffic class

IPV6_RTHDR

  Allows removal of sticky routing headers

IPV6_RTHDRDSTOPTS

  Allows removal of sticky destination options header

IPV6_RTHDR_TYPE_0

  Routing header type 0

IPV6_TCLASS

  Specify the traffic class

IPV6_UNICAST_HOPS

  IP6 unicast hops

IPV6_USE_MIN_MTU

  Use the minimum MTU size

IPV6_V6ONLY

  Only bind IPv6 with a wildcard bind

IPX_TYPE

  `IPX_TYPE`

IP_ADD_MEMBERSHIP

  Add a multicast group membership

IP_ADD_SOURCE_MEMBERSHIP

  Add a multicast group membership

IP_BLOCK_SOURCE

  Block IPv4 multicast packets with a give source address

IP_DEFAULT_MULTICAST_LOOP

  Default multicast loopback

IP_DEFAULT_MULTICAST_TTL

  Default multicast TTL

IP_DONTFRAG

  Don’t fragment packets

IP_DROP_MEMBERSHIP

  Drop a multicast group membership

IP_DROP_SOURCE_MEMBERSHIP

  Drop a multicast group membership

IP_FREEBIND

  Allow binding to nonexistent IP addresses

IP_HDRINCL

  Header is included with data

IP_IPSEC_POLICY

  IPsec security policy

IP_MAX_MEMBERSHIPS

  Maximum number multicast groups a socket can join

IP_MINTTL

  Minimum TTL allowed for received packets

IP_MSFILTER

  Multicast source filtering

IP_MTU

  The Maximum Transmission Unit of the socket

IP_MTU_DISCOVER

  Path MTU discovery

IP_MULTICAST_IF

  IP multicast interface

IP_MULTICAST_LOOP

  IP multicast loopback

IP_MULTICAST_TTL

  IP multicast TTL

IP_ONESBCAST

  Force outgoing broadcast datagrams to have the undirected broadcast address

IP_OPTIONS

  IP options to be included in packets

IP_PASSSEC

  Retrieve security context with datagram

IP_PKTINFO

  Receive packet information with datagrams

IP_PKTOPTIONS

  Receive packet options with datagrams

IP_PMTUDISC_DO

  Always send DF frames

IP_PMTUDISC_DONT

  Never send DF frames

IP_PMTUDISC_WANT

  Use per-route hints

IP_PORTRANGE

  Set the port range for sockets with unspecified port numbers

IP_RECVDSTADDR

  Receive IP destination address with datagram

IP_RECVERR

  Enable extended reliable error message passing

IP_RECVIF

  Receive interface information with datagrams

IP_RECVOPTS

  Receive all IP options with datagram

IP_RECVRETOPTS

  Receive all IP options for response

IP_RECVSLLA

  Receive link-layer address with datagrams

IP_RECVTOS

  Receive TOS with incoming packets

IP_RECVTTL

  Receive IP TTL with datagrams

IP_RETOPTS

  IP options to be included in datagrams

IP_ROUTER_ALERT

  Notify transit routers to more closely examine the contents of an IP packet

IP_SENDSRCADDR

  Source address for outgoing UDP datagrams

IP_TOS

  IP type-of-service

IP_TRANSPARENT

  Transparent proxy

IP_TTL

  IP time-to-live

IP_UNBLOCK_SOURCE

  Unblock IPv4 multicast packets with a give source address

IP_XFRM_POLICY

  `IP_XFRM_POLICY`

LOCAL_CONNWAIT

  Connect blocks until accepted

LOCAL_CREDS

  Pass credentials to receiver

LOCAL_PEERCRED

  Retrieve peer credentials

MCAST_BLOCK_SOURCE

  Block multicast packets from this source

MCAST_EXCLUDE

  Exclusive multicast source filter

MCAST_INCLUDE

  Inclusive multicast source filter

MCAST_JOIN_GROUP

  Join a multicast group

MCAST_JOIN_SOURCE_GROUP

  Join a multicast source group

MCAST_LEAVE_GROUP

  Leave a multicast group

MCAST_LEAVE_SOURCE_GROUP

  Leave a multicast source group

MCAST_MSFILTER

  Multicast source filtering

MCAST_UNBLOCK_SOURCE

  Unblock multicast packets from this source

MSG_COMPAT

  End of record

MSG_CONFIRM

  Confirm path validity

MSG_CTRUNC

  Control data lost before delivery

MSG_DONTROUTE

  Send without using the routing tables

MSG_DONTWAIT

  This message should be non-blocking

MSG_EOF

  Data completes connection

MSG_EOR

  Data completes record

MSG_ERRQUEUE

  Fetch message from error queue

MSG_FASTOPEN

  Reduce step of the handshake process

MSG_FIN

  `MSG_FIN`

MSG_FLUSH

  Start of a hold sequence. Dumps to so_temp

MSG_HAVEMORE

  Data ready to be read

MSG_HOLD

  Hold fragment in so_temp

MSG_MORE

  Sender will send more

MSG_NOSIGNAL

  Do not generate SIGPIPE

MSG_OOB

  Process out-of-band data

MSG_PEEK

  Peek at incoming message

MSG_PROXY

  Wait for full request

MSG_RCVMORE

  Data remains in the current packet

MSG_RST

  `MSG_RST`

MSG_SEND

  Send the packet in so_temp

MSG_SYN

  `MSG_SYN`

MSG_TRUNC

  Data discarded before delivery

MSG_WAITALL

  Wait for full request or error

NI_DGRAM

  The service specified is a datagram service (looks up UDP ports)

NI_MAXHOST

  Maximum length of a hostname

NI_MAXSERV

  Maximum length of a service name

NI_NAMEREQD

  A name is required

NI_NOFQDN

  An FQDN is not required for local hosts, return only the local part

NI_NUMERICHOST

  Return a numeric address

NI_NUMERICSERV

  Return the service name as a digit string

PF_ALG

  Interface to kernel crypto API

PF_APPLETALK

  AppleTalk protocol

PF_ATM

  Asynchronous Transfer Mode

PF_AX25

  AX.25 protocol

PF_BLUETOOTH

  Bluetooth low-level socket protocol

PF_CAN

  Controller Area Network automotive bus protocol

PF_CCITT

  CCITT (now ITU-T) protocols

PF_CHAOS

  MIT CHAOS protocols

PF_CNT

  Computer Network Technology

PF_COIP

  Connection-oriented IP

PF_DATAKIT

  Datakit protocol

PF_DEC

  DECnet protocol

PF_DECnet

  DECnet protocol

PF_DLI

  DEC Direct Data Link Interface protocol

PF_ECMA

  European Computer Manufacturers protocols

PF_HYLINK

  NSC Hyperchannel protocol

PF_IB

  InfiniBand native addressing

PF_IMPLINK

  ARPANET IMP protocol

PF_INET

  IPv4 protocol

PF_INET6

  IPv6 protocol

PF_IPX

  IPX protocol

PF_ISDN

  Integrated Services Digital Network

PF_ISO

  ISO Open Systems Interconnection protocols

PF_KCM

  KCM (kernel connection multiplexor) interface

PF_KEY

  Key management protocol, originally developed for usage with IPsec

PF_LAT

  Local Area Transport protocol

PF_LINK

  Link layer interface

PF_LLC

  Logical link control (IEEE 802.2 LLC) protocol

PF_LOCAL

  Host-internal protocols

PF_MAX

  Maximum address family for this platform

PF_MPLS

  Multiprotocol Label Switching

PF_NATM

  Native ATM access

PF_NDRV

  Network driver raw access

PF_NETBIOS

  NetBIOS

PF_NETGRAPH

  Netgraph sockets

PF_NETLINK

  Kernel user interface device

PF_NS

  XEROX NS protocols

PF_OSI

  ISO Open Systems Interconnection protocols

PF_PACKET

  Direct link-layer access

PF_PIP

  Help Identify PIP packets

PF_PPP

  Point-to-Point Protocol

PF_PPPOX

  Generic PPP transport layer, for setting up L2 tunnels (L2TP and PPPoE)

PF_PUP

  PARC Universal Packet protocol

PF_RDS

  Reliable Datagram Sockets (RDS) protocol

PF_ROUTE

  Internal routing protocol

PF_RTIP

  Help Identify RTIP packets

PF_SIP

  Simple Internet Protocol

PF_SNA

  IBM SNA protocol

PF_SYSTEM

  Kernel event messages

PF_TIPC

  TIPC, “cluster domain sockets” protocol

PF_UNIX

  UNIX sockets

PF_UNSPEC

  Unspecified protocol, any supported address family

PF_VSOCK

  VSOCK (originally “VMWare VSockets”) protocol for hypervisor-guest communication

PF_XDP

  XDP (express data path) interface

PF_XTP

  eXpress Transfer Protocol

RESOLUTION_DELAY
SCM_BINTIME

  Timestamp (bintime)

SCM_CREDENTIALS

  The sender’s credentials

SCM_CREDS

  Process credentials

SCM_RIGHTS

  Access rights

SCM_TIMESTAMP

  Timestamp (timeval)

SCM_TIMESTAMPING

  Timestamp (timespec list) (Linux 2.6.30)

SCM_TIMESTAMPNS

  Timespec (timespec)

SCM_UCRED

  User credentials

SCM_WIFI_STATUS

  Wifi status (Linux 3.3)

SHUT_RD

  Shut down the reading side of the socket

SHUT_RDWR

  Shut down the both sides of the socket

SHUT_WR

  Shut down the writing side of the socket

SOCK_CLOEXEC

  Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor.

SOCK_DGRAM

  A datagram socket provides connectionless, unreliable messaging

SOCK_NONBLOCK

  Set the O_NONBLOCK file status flag on the open file description (see open(2)) referred to by the new file descriptor.

SOCK_PACKET

  Device-level packet access

SOCK_RAW

  A raw socket provides low-level access for direct access or implementing network protocols

SOCK_RDM

  A reliable datagram socket provides reliable delivery of messages

SOCK_SEQPACKET

  A sequential packet socket provides sequenced, reliable two-way connection for datagrams

SOCK_STREAM

  A stream socket provides a sequenced, reliable two-way connection for a byte stream

SOL_ATALK

  AppleTalk socket options

SOL_AX25

  AX.25 socket options

SOL_IP

  IP socket options

SOL_IPX

  IPX socket options

SOL_SOCKET

  Socket-level options

SOL_TCP

  TCP socket options

SOL_UDP

  UDP socket options

SOMAXCONN

  Maximum connection requests that may be queued for a socket

SOPRI_BACKGROUND

  Background socket priority

SOPRI_INTERACTIVE

  Interactive socket priority

SOPRI_NORMAL

  Normal socket priority

SO_ACCEPTCONN

  Socket has had listen() called on it

SO_ACCEPTFILTER

  There is an accept filter

SO_ALLZONES

  Bypass zone boundaries

SO_ATTACH_FILTER

  Attach an accept filter

SO_BINDTODEVICE

  Only send packets from the given interface

SO_BINTIME

  Receive timestamp with datagrams (bintime)

SO_BPF_EXTENSIONS

  Query supported BPF extensions (Linux 3.14)

SO_BROADCAST

  Permit sending of broadcast messages

SO_BUSY_POLL

  Set the threshold in microseconds for low latency polling (Linux 3.11)

SO_CONNECT_TIME

  Returns the number of seconds a socket has been connected. This option is only valid for connection-oriented protocols (Windows)

SO_DEBUG

  Debug info recording

SO_DETACH_FILTER

  Detach an accept filter

SO_DOMAIN

  Domain given for socket() (Linux 2.6.32)

SO_DONTROUTE

  Use interface addresses

SO_DONTTRUNC

  Retain unread data

SO_ERROR

  Get and clear the error status

SO_GET_FILTER

  Obtain filter set by `SO_ATTACH_FILTER` (Linux 3.8)

SO_INCOMING_CPU

  Receive the cpu attached to the socket (Linux 3.19)

SO_INCOMING_NAPI_ID

  Receive the napi ID attached to a RX queue (Linux 4.12)

SO_KEEPALIVE

  Keep connections alive

SO_LINGER

  Linger on close if data is present

SO_LOCK_FILTER

  Lock the filter attached to a socket (Linux 3.9)

SO_MAC_EXEMPT

  Mandatory Access Control exemption for unlabeled peers

SO_MARK

  Set the mark for mark-based routing (Linux 2.6.25)

SO_MAX_PACING_RATE

  Cap the rate computed by transport layer. [bytes per second] (Linux 3.13)

SO_NKE

  Install socket-level Network Kernel Extension

SO_NOFCS

  Set netns of a socket (Linux 3.4)

SO_NOSIGPIPE

  Don’t SIGPIPE on EPIPE

SO_NO_CHECK

  Disable checksums

SO_NREAD

  Get first packet byte count

SO_OOBINLINE

  Leave received out-of-band data in-line

SO_PASSCRED

  Receive `SCM_CREDENTIALS` messages

SO_PASSSEC

  Toggle security context passing (Linux 2.6.18)

SO_PEEK_OFF

  Set the peek offset (Linux 3.4)

SO_PEERCRED

  The credentials of the foreign process connected to this socket

SO_PEERNAME

  Name of the connecting user

SO_PEERSEC

  Obtain the security credentials (Linux 2.6.2)

SO_PRIORITY

  The protocol-defined priority for all packets on this socket

SO_PROTOCOL

  Protocol given for socket() (Linux 2.6.32)

SO_RCVBUF

  Receive buffer size

SO_RCVBUFFORCE

  Receive buffer size without rmem_max limit (Linux 2.6.14)

SO_RCVLOWAT

  Receive low-water mark

SO_RCVTIMEO

  Receive timeout

SO_RECVUCRED

  Receive user credentials with datagram

SO_REUSEADDR

  Allow local address reuse

SO_REUSEPORT

  Allow local address and port reuse

SO_RTABLE

  Set the routing table for this socket (OpenBSD)

SO_RXQ_OVFL

  Toggle cmsg for number of packets dropped (Linux 2.6.33)

SO_SECURITY_AUTHENTICATION

  `SO_SECURITY_AUTHENTICATION`

SO_SECURITY_ENCRYPTION_NETWORK

  `SO_SECURITY_ENCRYPTION_NETWORK`

SO_SECURITY_ENCRYPTION_TRANSPORT

  `SO_SECURITY_ENCRYPTION_TRANSPORT`

SO_SELECT_ERR_QUEUE

  Make select() detect socket error queue with errorfds (Linux 3.10)

SO_SETFIB

  Set the associated routing table for the socket (FreeBSD)

SO_SNDBUF

  Send buffer size

SO_SNDBUFFORCE

  Send buffer size without wmem_max limit (Linux 2.6.14)

SO_SNDLOWAT

  Send low-water mark

SO_SNDTIMEO

  Send timeout

SO_TIMESTAMP

  Receive timestamp with datagrams (timeval)

SO_TIMESTAMPING

  Time stamping of incoming and outgoing packets (Linux 2.6.30)

SO_TIMESTAMPNS

  Receive nanosecond timestamp with datagrams (timespec)

SO_TYPE

  Get the socket type

SO_USELOOPBACK

  Bypass hardware when possible

SO_USER_COOKIE

  Setting an identifier for ipfw purpose mainly

SO_WANTMORE

  Give a hint when more data is ready

SO_WANTOOBFLAG

  OOB data is wanted in MSG_FLAG on receive

SO_WIFI_STATUS

  Toggle cmsg for wifi status (Linux 3.3)

TCP_CONGESTION

  TCP congestion control algorithm (Linux 2.6.13, glibc 2.6)

TCP_CONNECTION_INFO

  Retrieve information about this socket (macOS)

TCP_COOKIE_TRANSACTIONS

  TCP Cookie Transactions (Linux 2.6.33, glibc 2.18)

TCP_CORK

  Don’t send partial frames (Linux 2.2, glibc 2.2)

TCP_DEFER_ACCEPT

  Don’t notify a listening socket until data is ready (Linux 2.4, glibc 2.2)

TCP_FASTOPEN

  Reduce step of the handshake process (Linux 3.7, glibc 2.18)

TCP_INFO

  Retrieve information about this socket (Linux 2.4, glibc 2.2)

TCP_KEEPALIVE

  Idle time before keepalive probes are sent (macOS)

TCP_KEEPCNT

  Maximum number of keepalive probes allowed before dropping a connection (Linux 2.4, glibc 2.2)

TCP_KEEPIDLE

  Idle time before keepalive probes are sent (Linux 2.4, glibc 2.2)

TCP_KEEPINTVL

  Time between keepalive probes (Linux 2.4, glibc 2.2)

TCP_LINGER2

  Lifetime of orphaned FIN_WAIT2 sockets (Linux 2.4, glibc 2.2)

TCP_MAXSEG

  Set maximum segment size

TCP_MD5SIG

  Use MD5 digests (RFC2385, Linux 2.6.20, glibc 2.7)

TCP_NODELAY

  Don’t delay sending to coalesce packets

TCP_NOOPT

  Don’t use TCP options

TCP_NOPUSH

  Don’t push the last block of write

TCP_QUEUE_SEQ

  Sequence of a queue for repair mode (Linux 3.5, glibc 2.18)

TCP_QUICKACK

  Enable quickack mode (Linux 2.4.4, glibc 2.3)

TCP_REPAIR

  Repair mode (Linux 3.5, glibc 2.18)

TCP_REPAIR_OPTIONS

  Options for repair mode (Linux 3.5, glibc 2.18)

TCP_REPAIR_QUEUE

  Queue for repair mode (Linux 3.5, glibc 2.18)

TCP_SYNCNT

  Number of SYN retransmits before a connection is dropped (Linux 2.4, glibc 2.2)

TCP_THIN_DUPACK

  Duplicated acknowledgments handling for thin-streams (Linux 2.6.34, glibc 2.18)

TCP_THIN_LINEAR_TIMEOUTS

  Linear timeouts for thin-streams (Linux 2.6.34, glibc 2.18)

TCP_TIMESTAMP

  TCP timestamp (Linux 3.9, glibc 2.18)

TCP_USER_TIMEOUT

  Max timeout before a TCP connection is aborted (Linux 2.6.37, glibc 2.18)

TCP_WINDOW_CLAMP

  Clamp the size of the advertised window (Linux 2.4, glibc 2.2)

UDP_CORK

  Don’t send partial frames (Linux 2.5.44, glibc 2.11)

### Public Class Methods

accept_loop (*sockets) { |socket, client_addrinfo| ... }
Source

    # File ext/socket/lib/socket.rb, line 1216
    def self.accept_loop(*sockets) # :yield: socket, client_addrinfo
      sockets.flatten!(1)
      if sockets.empty?
        raise ArgumentError, "no sockets"
      end
      loop {
        readable, _, _ = IO.select(sockets)
        readable.each {|r|
          sock, addr = r.accept_nonblock(exception: false)
          next if sock == :wait_readable
          yield sock, addr
        }
      }
    end

yield socket and client address for each a connection accepted via given sockets.

The arguments are a list of sockets. The individual argument should be a socket or an array of sockets.

This method yields the block sequentially. It means that the next connection is not accepted until the block returns. So concurrent mechanism, thread for example, should be used to service multiple clients at a time.

getaddrinfo(nodename, servname[, family[, socktype[, protocol[, flags[, reverse_lookup]]]]]) → array
Source

    static VALUE
    sock_s_getaddrinfo(int argc, VALUE *argv, VALUE _)
    {
        VALUE host, port, family, socktype, protocol, flags, ret, revlookup;
        struct addrinfo hints;
        struct rb_addrinfo *res;
        int norevlookup;

        rb_scan_args(argc, argv, "25", &host, &port, &family, &socktype, &protocol, &flags, &revlookup);

        MEMZERO(&hints, struct addrinfo, 1);
        hints.ai_family = NIL_P(family) ? PF_UNSPEC : rsock_family_arg(family);

        if (!NIL_P(socktype)) {
            hints.ai_socktype = rsock_socktype_arg(socktype);
        }
        if (!NIL_P(protocol)) {
            hints.ai_protocol = NUM2INT(protocol);
        }
        if (!NIL_P(flags)) {
            hints.ai_flags = NUM2INT(flags);
        }
        if (NIL_P(revlookup) || !rsock_revlookup_flag(revlookup, &norevlookup)) {
            norevlookup = rsock_do_not_reverse_lookup;
        }

        res = rsock_getaddrinfo(host, port, &hints, 0);

        ret = make_addrinfo(res, norevlookup);
        rb_freeaddrinfo(res);
        return ret;
    }

Obtains address information for nodename:servname.

Note that `Addrinfo.getaddrinfo` provides the same functionality in an object oriented style.

family should be an address family such as: :INET, :INET6, etc.

socktype should be a socket type such as: :STREAM, :DGRAM, :RAW, etc.

protocol should be a protocol defined in the family, and defaults to 0 for the family.

flags should be bitwise OR of Socket::AI_* constants.

    Socket.getaddrinfo("www.ruby-lang.org", "http", nil, :STREAM)
    #=> [["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68", 2, 1, 6]] # PF_INET/SOCK_STREAM/IPPROTO_TCP

    Socket.getaddrinfo("localhost", nil)
    #=> [["AF_INET", 0, "localhost", "127.0.0.1", 2, 1, 6],  # PF_INET/SOCK_STREAM/IPPROTO_TCP
    #    ["AF_INET", 0, "localhost", "127.0.0.1", 2, 2, 17], # PF_INET/SOCK_DGRAM/IPPROTO_UDP
    #    ["AF_INET", 0, "localhost", "127.0.0.1", 2, 3, 0]]  # PF_INET/SOCK_RAW/IPPROTO_IP

reverse_lookup directs the form of the third element, and has to be one of below. If reverse_lookup is omitted, the default value is `nil`.

    +true+, +:hostname+:  hostname is obtained from numeric address using reverse lookup, which may take a time.
    +false+, +:numeric+:  hostname is the same as numeric address.
    +nil+:              obey to the current +do_not_reverse_lookup+ flag.

If `Addrinfo` object is preferred, use `Addrinfo.getaddrinfo`.

gethostbyaddr(address_string [, address_family]) → hostent
Source

    static VALUE
    sock_s_gethostbyaddr(int argc, VALUE *argv, VALUE _)
    {
        VALUE addr, family;
        struct hostent *h;
        char **pch;
        VALUE ary, names;
        int t = AF_INET;

        rb_warn("Socket.gethostbyaddr is deprecated; use Addrinfo#getnameinfo instead.");

        rb_scan_args(argc, argv, "11", &addr, &family);
        StringValue(addr);
        if (!NIL_P(family)) {
            t = rsock_family_arg(family);
        }
    #ifdef AF_INET6
        else if (RSTRING_LEN(addr) == 16) {
            t = AF_INET6;
        }
    #endif
        h = gethostbyaddr(RSTRING_PTR(addr), RSTRING_SOCKLEN(addr), t);
        if (h == NULL) {
    #ifdef HAVE_HSTRERROR
            extern int h_errno;
            rb_raise(rb_eSocket, "%s", (char*)hstrerror(h_errno));
    #else
            rb_raise(rb_eSocket, "host not found");
    #endif
        }
        ary = rb_ary_new();
        rb_ary_push(ary, rb_str_new2(h->h_name));
        names = rb_ary_new();
        rb_ary_push(ary, names);
        if (h->h_aliases != NULL) {
            for (pch = h->h_aliases; *pch; pch++) {
                rb_ary_push(names, rb_str_new2(*pch));
            }
        }
        rb_ary_push(ary, INT2NUM(h->h_addrtype));
    #ifdef h_addr
        for (pch = h->h_addr_list; *pch; pch++) {
            rb_ary_push(ary, rb_str_new(*pch, h->h_length));
        }
    #else
        rb_ary_push(ary, rb_str_new(h->h_addr, h->h_length));
    #endif

        return ary;
    }

Use `Addrinfo#getnameinfo` instead. This method is deprecated for the following reasons:

- Uncommon address representation: 4/16-bytes binary string to represent IPv4/IPv6 address.

- gethostbyaddr() may take a long time and it may block other threads. (GVL cannot be released since gethostbyname() is not thread safe.)

- This method uses gethostbyname() function already removed from POSIX.

This method obtains the host information for address.

    p Socket.gethostbyaddr([221,186,184,68].pack("CCCC"))
    #=> ["carbon.ruby-lang.org", [], 2, "\xDD\xBA\xB8D"]

    p Socket.gethostbyaddr([127,0,0,1].pack("CCCC"))
    ["localhost", [], 2, "\x7F\x00\x00\x01"]
    p Socket.gethostbyaddr(([0]*15+[1]).pack("C"*16))
    #=> ["localhost", ["ip6-localhost", "ip6-loopback"], 10,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"]

gethostbyname(hostname) → [official_hostname, alias_hostnames, address_family, *address_list]
Source

    static VALUE
    sock_s_gethostbyname(VALUE obj, VALUE host)
    {
        rb_warn("Socket.gethostbyname is deprecated; use Addrinfo.getaddrinfo instead.");
        struct rb_addrinfo *res =
            rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, AI_CANONNAME);
        return rsock_make_hostent(host, res, sock_sockaddr);
    }

Use `Addrinfo.getaddrinfo` instead. This method is deprecated for the following reasons:

- The 3rd element of the result is the address family of the first address. The address families of the rest of the addresses are not returned.

- Uncommon address representation: 4/16-bytes binary string to represent IPv4/IPv6 address.

- gethostbyname() may take a long time and it may block other threads. (GVL cannot be released since gethostbyname() is not thread safe.)

- This method uses gethostbyname() function already removed from POSIX.

This method obtains the host information for hostname.

    p Socket.gethostbyname("hal") #=> ["localhost", ["hal"], 2, "\x7F\x00\x00\x01"]

gethostname → hostname
Source

    static VALUE
    sock_gethostname(VALUE obj)
    {
    #if defined(NI_MAXHOST)
    #  define RUBY_MAX_HOST_NAME_LEN NI_MAXHOST
    #elif defined(HOST_NAME_MAX)
    #  define RUBY_MAX_HOST_NAME_LEN HOST_NAME_MAX
    #else
    #  define RUBY_MAX_HOST_NAME_LEN 1024
    #endif

        long len = RUBY_MAX_HOST_NAME_LEN;
        VALUE name;

        name = rb_str_new(0, len);
        while (gethostname(RSTRING_PTR(name), len) < 0) {
            int e = errno;
            switch (e) {
              case ENAMETOOLONG:
    #ifdef __linux__
              case EINVAL:
                /* glibc before version 2.1 uses EINVAL instead of ENAMETOOLONG */
    #endif
                break;
              default:
                rb_syserr_fail(e, "gethostname(3)");
            }
            rb_str_modify_expand(name, len);
            len += len;
        }
        rb_str_resize(name, strlen(RSTRING_PTR(name)));
        return name;
    }

Returns the hostname.

    p Socket.gethostname #=> "hal"

Note that it is not guaranteed to be able to convert to IP address using gethostbyname, getaddrinfo, etc. If you need local IP address, use `Socket.ip_address_list`.

getifaddrs → [ifaddr1, ...]
Source

    static VALUE
    socket_s_getifaddrs(VALUE self)
    {
        return rsock_getifaddrs();
    }

Returns an array of interface addresses. An element of the array is an instance of `Socket::Ifaddr`.

This method can be used to find multicast-enabled interfaces:

    pp Socket.getifaddrs.reject {|ifaddr|
      !ifaddr.addr.ip? || (ifaddr.flags & Socket::IFF_MULTICAST == 0)
    }.map {|ifaddr| [ifaddr.name, ifaddr.ifindex, ifaddr.addr] }
    #=> [["eth0", 2, #<Addrinfo: 221.186.184.67>],
    #    ["eth0", 2, #<Addrinfo: fe80::216:3eff:fe95:88bb%eth0>]]

Example result on GNU/Linux:

    pp Socket.getifaddrs
    #=> [#<Socket::Ifaddr lo UP,LOOPBACK,RUNNING,0x10000 PACKET[protocol=0 lo hatype=772 HOST hwaddr=00:00:00:00:00:00]>,
    #    #<Socket::Ifaddr eth0 UP,BROADCAST,RUNNING,MULTICAST,0x10000 PACKET[protocol=0 eth0 hatype=1 HOST hwaddr=00:16:3e:95:88:bb] broadcast=PACKET[protocol=0 eth0 hatype=1 HOST hwaddr=ff:ff:ff:ff:ff:ff]>,
    #    #<Socket::Ifaddr sit0 NOARP PACKET[protocol=0 sit0 hatype=776 HOST hwaddr=00:00:00:00]>,
    #    #<Socket::Ifaddr lo UP,LOOPBACK,RUNNING,0x10000 127.0.0.1 netmask=255.0.0.0>,
    #    #<Socket::Ifaddr eth0 UP,BROADCAST,RUNNING,MULTICAST,0x10000 221.186.184.67 netmask=255.255.255.240 broadcast=221.186.184.79>,
    #    #<Socket::Ifaddr lo UP,LOOPBACK,RUNNING,0x10000 ::1 netmask=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>,
    #    #<Socket::Ifaddr eth0 UP,BROADCAST,RUNNING,MULTICAST,0x10000 fe80::216:3eff:fe95:88bb%eth0 netmask=ffff:ffff:ffff:ffff::>]

Example result on FreeBSD:

    pp Socket.getifaddrs
    #=> [#<Socket::Ifaddr usbus0 UP,0x10000 LINK[usbus0]>,
    #    #<Socket::Ifaddr re0 UP,BROADCAST,RUNNING,MULTICAST,0x800 LINK[re0 3a:d0:40:9a:fe:e8]>,
    #    #<Socket::Ifaddr re0 UP,BROADCAST,RUNNING,MULTICAST,0x800 10.250.10.18 netmask=255.255.255.? (7 bytes for 16 bytes sockaddr_in) broadcast=10.250.10.255>,
    #    #<Socket::Ifaddr re0 UP,BROADCAST,RUNNING,MULTICAST,0x800 fe80:2::38d0:40ff:fe9a:fee8 netmask=ffff:ffff:ffff:ffff::>,
    #    #<Socket::Ifaddr re0 UP,BROADCAST,RUNNING,MULTICAST,0x800 2001:2e8:408:10::12 netmask=UNSPEC>,
    #    #<Socket::Ifaddr plip0 POINTOPOINT,MULTICAST,0x800 LINK[plip0]>,
    #    #<Socket::Ifaddr lo0 UP,LOOPBACK,RUNNING,MULTICAST LINK[lo0]>,
    #    #<Socket::Ifaddr lo0 UP,LOOPBACK,RUNNING,MULTICAST ::1 netmask=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>,
    #    #<Socket::Ifaddr lo0 UP,LOOPBACK,RUNNING,MULTICAST fe80:4::1 netmask=ffff:ffff:ffff:ffff::>,
    #    #<Socket::Ifaddr lo0 UP,LOOPBACK,RUNNING,MULTICAST 127.0.0.1 netmask=255.?.?.? (5 bytes for 16 bytes sockaddr_in)>]

getnameinfo(sockaddr [, flags]) → [hostname, servicename]
Source

    static VALUE
    sock_s_getnameinfo(int argc, VALUE *argv, VALUE _)
    {
        VALUE sa, af = Qnil, host = Qnil, port = Qnil, flags, tmp;
        char hbuf[1024], pbuf[1024];
        int fl;
        struct rb_addrinfo *res = NULL;
        struct addrinfo hints, *r;
        int error, saved_errno;
        union_sockaddr ss;
        struct sockaddr *sap;
        socklen_t salen;

        sa = flags = Qnil;
        rb_scan_args(argc, argv, "11", &sa, &flags);

        fl = 0;
        if (!NIL_P(flags)) {
            fl = NUM2INT(flags);
        }
        tmp = rb_check_sockaddr_string_type(sa);
        if (!NIL_P(tmp)) {
            sa = tmp;
            if (sizeof(ss) < (size_t)RSTRING_LEN(sa)) {
                rb_raise(rb_eTypeError, "sockaddr length too big");
            }
            memcpy(&ss, RSTRING_PTR(sa), RSTRING_LEN(sa));
            if (!VALIDATE_SOCKLEN(&ss.addr, RSTRING_LEN(sa))) {
                rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
            }
            sap = &ss.addr;
            salen = RSTRING_SOCKLEN(sa);
            goto call_nameinfo;
        }
        tmp = rb_check_array_type(sa);
        if (!NIL_P(tmp)) {
            sa = tmp;
            MEMZERO(&hints, struct addrinfo, 1);
            if (RARRAY_LEN(sa) == 3) {
                af = RARRAY_AREF(sa, 0);
                port = RARRAY_AREF(sa, 1);
                host = RARRAY_AREF(sa, 2);
            }
            else if (RARRAY_LEN(sa) >= 4) {
                af = RARRAY_AREF(sa, 0);
                port = RARRAY_AREF(sa, 1);
                host = RARRAY_AREF(sa, 3);
                if (NIL_P(host)) {
                    host = RARRAY_AREF(sa, 2);
                }
                else {
                    /*
                     * 4th element holds numeric form, don't resolve.
                     * see rsock_ipaddr().
                     */
    #ifdef AI_NUMERICHOST /* AIX 4.3.3 doesn't have AI_NUMERICHOST. */
                    hints.ai_flags |= AI_NUMERICHOST;
    #endif
                }
            }
            else {
                rb_raise(rb_eArgError, "array size should be 3 or 4, %ld given",
                         RARRAY_LEN(sa));
            }
            hints.ai_socktype = (fl & NI_DGRAM) ? SOCK_DGRAM : SOCK_STREAM;
            /* af */
            hints.ai_family = NIL_P(af) ? PF_UNSPEC : rsock_family_arg(af);
            res = rsock_getaddrinfo(host, port, &hints, 0);
            sap = res->ai->ai_addr;
            salen = res->ai->ai_addrlen;
        }
        else {
            rb_raise(rb_eTypeError, "expecting String or Array");
        }

      call_nameinfo:
        error = rb_getnameinfo(sap, salen, hbuf, sizeof(hbuf),
                               pbuf, sizeof(pbuf), fl);
        if (error) goto error_exit_name;
        if (res) {
            for (r = res->ai->ai_next; r; r = r->ai_next) {
                char hbuf2[1024], pbuf2[1024];

                sap = r->ai_addr;
                salen = r->ai_addrlen;
                error = rb_getnameinfo(sap, salen, hbuf2, sizeof(hbuf2),
                                       pbuf2, sizeof(pbuf2), fl);
                if (error) goto error_exit_name;
                if (strcmp(hbuf, hbuf2) != 0|| strcmp(pbuf, pbuf2) != 0) {
                    rb_freeaddrinfo(res);
                    rb_raise(rb_eSocket, "sockaddr resolved to multiple nodename");
                }
            }
            rb_freeaddrinfo(res);
        }
        return rb_assoc_new(rb_str_new2(hbuf), rb_str_new2(pbuf));

      error_exit_name:
        saved_errno = errno;
        if (res) rb_freeaddrinfo(res);
        errno = saved_errno;
        rsock_raise_resolution_error("getnameinfo", error);

        UNREACHABLE_RETURN(Qnil);
    }

Obtains name information for sockaddr.

sockaddr should be one of follows.

- packed sockaddr string such as `Socket.sockaddr_in`(80, “127.0.0.1”)

- 3-elements array such as [“AF_INET”, 80, “127.0.0.1”]

- 4-elements array such as [“AF_INET”, 80, ignored, “127.0.0.1”]

flags should be bitwise OR of Socket::NI_* constants.

Note: The last form is compatible with `IPSocket#addr` and `IPSocket#peeraddr`.

    Socket.getnameinfo(Socket.sockaddr_in(80, "127.0.0.1"))       #=> ["localhost", "www"]
    Socket.getnameinfo(["AF_INET", 80, "127.0.0.1"])              #=> ["localhost", "www"]
    Socket.getnameinfo(["AF_INET", 80, "localhost", "127.0.0.1"]) #=> ["localhost", "www"]

If `Addrinfo` object is preferred, use `Addrinfo#getnameinfo`.

getservbyname(service_name) → port_number
getservbyname(service_name, protocol_name) → port_number
Source

    static VALUE
    sock_s_getservbyname(int argc, VALUE *argv, VALUE _)
    {
        VALUE service, proto;
        struct servent *sp;
        long port;
        const char *servicename, *protoname = "tcp";

        rb_scan_args(argc, argv, "11", &service, &proto);
        StringValue(service);
        if (!NIL_P(proto)) StringValue(proto);
        servicename = StringValueCStr(service);
        if (!NIL_P(proto)) protoname = StringValueCStr(proto);
        sp = getservbyname(servicename, protoname);
        if (sp) {
            port = ntohs(sp->s_port);
        }
        else {
            char *end;

            port = STRTOUL(servicename, &end, 0);
            if (*end != '\0') {
                rb_raise(rb_eSocket, "no such service %s/%s", servicename, protoname);
            }
        }
        return INT2FIX(port);
    }

Obtains the port number for service_name.

If protocol_name is not given, “tcp” is assumed.

    Socket.getservbyname("smtp")          #=> 25
    Socket.getservbyname("shell")         #=> 514
    Socket.getservbyname("syslog", "udp") #=> 514

getservbyport(port [, protocol_name]) → service
Source

    static VALUE
    sock_s_getservbyport(int argc, VALUE *argv, VALUE _)
    {
        VALUE port, proto;
        struct servent *sp;
        long portnum;
        const char *protoname = "tcp";

        rb_scan_args(argc, argv, "11", &port, &proto);
        portnum = NUM2LONG(port);
        if (portnum != (uint16_t)portnum) {
            const char *s = portnum > 0 ? "big" : "small";
            rb_raise(rb_eRangeError, "integer %ld too %s to convert into `int16_t'", portnum, s);
        }
        if (!NIL_P(proto)) protoname = StringValueCStr(proto);

        sp = getservbyport((int)htons((uint16_t)portnum), protoname);
        if (!sp) {
            rb_raise(rb_eSocket, "no such service for port %d/%s", (int)portnum, protoname);
        }
        return rb_str_new2(sp->s_name);
    }

Obtains the port number for port.

If protocol_name is not given, “tcp” is assumed.

    Socket.getservbyport(80)         #=> "www"
    Socket.getservbyport(514, "tcp") #=> "shell"
    Socket.getservbyport(514, "udp") #=> "syslog"

ip_address_list → array
Source

    static VALUE
    socket_s_ip_address_list(VALUE self)
    {
    #if defined(HAVE_GETIFADDRS)
        struct ifaddrs *ifp = NULL;
        struct ifaddrs *p;
        int ret;
        VALUE list;

        ret = getifaddrs(&ifp);
        if (ret == -1) {
            rb_sys_fail("getifaddrs");
        }

        list = rb_ary_new();
        for (p = ifp; p; p = p->ifa_next) {
            if (p->ifa_addr != NULL && IS_IP_FAMILY(p->ifa_addr->sa_family)) {
                struct sockaddr *addr = p->ifa_addr;
    #if defined(AF_INET6) && defined(__sun)
                /*
                 * OpenIndiana SunOS 5.11 getifaddrs() returns IPv6 link local
                 * address with sin6_scope_id == 0.
                 * So fill it from the interface name (ifa_name).
                 */
                struct sockaddr_in6 addr6;
                if (addr->sa_family == AF_INET6) {
                    socklen_t len = (socklen_t)sizeof(struct sockaddr_in6);
                    memcpy(&addr6, addr, len);
                    addr = (struct sockaddr *)&addr6;
                    if (IN6_IS_ADDR_LINKLOCAL(&addr6.sin6_addr) &&
                        addr6.sin6_scope_id == 0) {
                        unsigned int ifindex = if_nametoindex(p->ifa_name);
                        if (ifindex != 0) {
                            addr6.sin6_scope_id = ifindex;
                        }
                    }
                }
    #endif
                rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));
            }
        }

        freeifaddrs(ifp);

        return list;
    #elif defined(SIOCGLIFCONF) && defined(SIOCGLIFNUM)
        /* Solaris if_tcp(7P) */
        int fd = -1;
        int ret;
        struct lifnum ln;
        struct lifconf lc;
        const char *reason = NULL;
        int save_errno;
        int i;
        VALUE list = Qnil;

        lc.lifc_buf = NULL;

        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd == -1)
            rb_sys_fail("socket(2)");

        memset(&ln, 0, sizeof(ln));
        ln.lifn_family = AF_UNSPEC;

        ret = ioctl(fd, SIOCGLIFNUM, &ln);
        if (ret == -1) {
            reason = "SIOCGLIFNUM";
            goto finish;
        }

        memset(&lc, 0, sizeof(lc));
        lc.lifc_family = AF_UNSPEC;
        lc.lifc_flags = 0;
        lc.lifc_len = sizeof(struct lifreq) * ln.lifn_count;
        lc.lifc_req = xmalloc(lc.lifc_len);

        ret = ioctl(fd, SIOCGLIFCONF, &lc);
        if (ret == -1) {
            reason = "SIOCGLIFCONF";
            goto finish;
        }

        list = rb_ary_new();
        for (i = 0; i < ln.lifn_count; i++) {
            struct lifreq *req = &lc.lifc_req[i];
            if (IS_IP_FAMILY(req->lifr_addr.ss_family)) {
                if (req->lifr_addr.ss_family == AF_INET6 &&
                    IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_addr) &&
                    ((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_scope_id == 0) {
                    struct lifreq req2;
                    memcpy(req2.lifr_name, req->lifr_name, LIFNAMSIZ);
                    ret = ioctl(fd, SIOCGLIFINDEX, &req2);
                    if (ret == -1) {
                        reason = "SIOCGLIFINDEX";
                        goto finish;
                    }
                    ((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_scope_id = req2.lifr_index;
                }
                rb_ary_push(list, sockaddr_obj((struct sockaddr *)&req->lifr_addr, req->lifr_addrlen));
            }
        }

      finish:
        save_errno = errno;
        xfree(lc.lifc_req);
        if (fd != -1)
            close(fd);
        errno = save_errno;

        if (reason)
            rb_syserr_fail(save_errno, reason);
        return list;

    #elif defined(SIOCGIFCONF)
        int fd = -1;
        int ret;
    #define EXTRA_SPACE ((int)(sizeof(struct ifconf) + sizeof(union_sockaddr)))
        char initbuf[4096+EXTRA_SPACE];
        char *buf = initbuf;
        int bufsize;
        struct ifconf conf;
        struct ifreq *req;
        VALUE list = Qnil;
        const char *reason = NULL;
        int save_errno;

        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd == -1)
            rb_sys_fail("socket(2)");

        bufsize = sizeof(initbuf);
        buf = initbuf;

      retry:
        conf.ifc_len = bufsize;
        conf.ifc_req = (struct ifreq *)buf;

        /* fprintf(stderr, "bufsize: %d\n", bufsize); */

        ret = ioctl(fd, SIOCGIFCONF, &conf);
        if (ret == -1) {
            reason = "SIOCGIFCONF";
            goto finish;
        }

        /* fprintf(stderr, "conf.ifc_len: %d\n", conf.ifc_len); */

        if (bufsize - EXTRA_SPACE < conf.ifc_len) {
            if (bufsize < conf.ifc_len) {
                /* NetBSD returns required size for all interfaces. */
                bufsize = conf.ifc_len + EXTRA_SPACE;
            }
            else {
                bufsize = bufsize << 1;
            }
            if (buf == initbuf)
                buf = NULL;
            buf = xrealloc(buf, bufsize);
            goto retry;
        }

        close(fd);
        fd = -1;

        list = rb_ary_new();
        req = conf.ifc_req;
        while ((char*)req < (char*)conf.ifc_req + conf.ifc_len) {
            struct sockaddr *addr = &req->ifr_addr;
            if (IS_IP_FAMILY(addr->sa_family)) {
                rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));
            }
    #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
    # ifndef _SIZEOF_ADDR_IFREQ
    #  define _SIZEOF_ADDR_IFREQ(r) \
              (sizeof(struct ifreq) + \
               (sizeof(struct sockaddr) < (r).ifr_addr.sa_len ? \
                (r).ifr_addr.sa_len - sizeof(struct sockaddr) : \
                0))
    # endif
            req = (struct ifreq *)((char*)req + _SIZEOF_ADDR_IFREQ(*req));
    #else
            req = (struct ifreq *)((char*)req + sizeof(struct ifreq));
    #endif
        }

      finish:

        save_errno = errno;
        if (buf != initbuf)
            xfree(buf);
        if (fd != -1)
            close(fd);
        errno = save_errno;

        if (reason)
            rb_syserr_fail(save_errno, reason);
        return list;

    #undef EXTRA_SPACE
    #elif defined(_WIN32)
        typedef struct ip_adapter_unicast_address_st {
            unsigned LONG_LONG dummy0;
            struct ip_adapter_unicast_address_st *Next;
            struct {
                struct sockaddr *lpSockaddr;
                int iSockaddrLength;
            } Address;
            int dummy1;
            int dummy2;
            int dummy3;
            long dummy4;
            long dummy5;
            long dummy6;
        } ip_adapter_unicast_address_t;
        typedef struct ip_adapter_anycast_address_st {
            unsigned LONG_LONG dummy0;
            struct ip_adapter_anycast_address_st *Next;
            struct {
                struct sockaddr *lpSockaddr;
                int iSockaddrLength;
            } Address;
        } ip_adapter_anycast_address_t;
        typedef struct ip_adapter_addresses_st {
            unsigned LONG_LONG dummy0;
            struct ip_adapter_addresses_st *Next;
            void *dummy1;
            ip_adapter_unicast_address_t *FirstUnicastAddress;
            ip_adapter_anycast_address_t *FirstAnycastAddress;
            void *dummy2;
            void *dummy3;
            void *dummy4;
            void *dummy5;
            void *dummy6;
            BYTE dummy7[8];
            DWORD dummy8;
            DWORD dummy9;
            DWORD dummy10;
            DWORD IfType;
            int OperStatus;
            DWORD dummy12;
            DWORD dummy13[16];
            void *dummy14;
        } ip_adapter_addresses_t;
        typedef ULONG (WINAPI *GetAdaptersAddresses_t)(ULONG, ULONG, PVOID, ip_adapter_addresses_t *, PULONG);
        HMODULE h;
        GetAdaptersAddresses_t pGetAdaptersAddresses;
        ULONG len;
        DWORD ret;
        ip_adapter_addresses_t *adapters;
        VALUE list;

        h = LoadLibrary("iphlpapi.dll");
        if (!h)
            rb_notimplement();
        pGetAdaptersAddresses = (GetAdaptersAddresses_t)GetProcAddress(h, "GetAdaptersAddresses");
        if (!pGetAdaptersAddresses) {
            FreeLibrary(h);
            rb_notimplement();
        }

        ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &len);
        if (ret != ERROR_SUCCESS && ret != ERROR_BUFFER_OVERFLOW) {
            errno = rb_w32_map_errno(ret);
            FreeLibrary(h);
            rb_sys_fail("GetAdaptersAddresses");
        }
        adapters = (ip_adapter_addresses_t *)ALLOCA_N(BYTE, len);
        ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &len);
        if (ret != ERROR_SUCCESS) {
            errno = rb_w32_map_errno(ret);
            FreeLibrary(h);
            rb_sys_fail("GetAdaptersAddresses");
        }

        list = rb_ary_new();
        for (; adapters; adapters = adapters->Next) {
            ip_adapter_unicast_address_t *uni;
            ip_adapter_anycast_address_t *any;
            if (adapters->OperStatus != 1)  /* 1 means IfOperStatusUp */
                continue;
            for (uni = adapters->FirstUnicastAddress; uni; uni = uni->Next) {
    #ifndef INET6
                if (uni->Address.lpSockaddr->sa_family == AF_INET)
    #else
                if (IS_IP_FAMILY(uni->Address.lpSockaddr->sa_family))
    #endif
                    rb_ary_push(list, sockaddr_obj(uni->Address.lpSockaddr, uni->Address.iSockaddrLength));
            }
            for (any = adapters->FirstAnycastAddress; any; any = any->Next) {
    #ifndef INET6
                if (any->Address.lpSockaddr->sa_family == AF_INET)
    #else
                if (IS_IP_FAMILY(any->Address.lpSockaddr->sa_family))
    #endif
                    rb_ary_push(list, sockaddr_obj(any->Address.lpSockaddr, any->Address.iSockaddrLength));
            }
        }

        FreeLibrary(h);
        return list;
    #endif
    }

Returns local IP addresses as an array.

The array contains `Addrinfo` objects.

    pp Socket.ip_address_list
    #=> [#<Addrinfo: 127.0.0.1>,
         #<Addrinfo: 192.168.0.128>,
         #<Addrinfo: ::1>,
         ...]

new(domain, socktype [, protocol]) → socket
Source

    static VALUE
    sock_initialize(int argc, VALUE *argv, VALUE sock)
    {
        VALUE domain, type, protocol;
        int fd;
        int d, t;

        rb_scan_args(argc, argv, "21", &domain, &type, &protocol);
        if (NIL_P(protocol))
            protocol = INT2FIX(0);

        setup_domain_and_type(domain, &d, type, &t);
        fd = rsock_socket(d, t, NUM2INT(protocol));
        if (fd < 0) rb_sys_fail("socket(2)");

        return rsock_init_sock(sock, fd);
    }

Creates a new socket object.

domain should be a communications domain such as: :INET, :INET6, :UNIX, etc.

socktype should be a socket type such as: :STREAM, :DGRAM, :RAW, etc.

protocol is optional and should be a protocol defined in the domain. If protocol is not given, 0 is used internally.

    Socket.new(:INET, :STREAM) # TCP socket
    Socket.new(:INET, :DGRAM)  # UDP socket
    Socket.new(:UNIX, :STREAM) # UNIX stream socket
    Socket.new(:UNIX, :DGRAM)  # UNIX datagram socket

sockaddr_in(port, host) → sockaddr
pack_sockaddr_in(port, host) → sockaddr
Source

    static VALUE
    sock_s_pack_sockaddr_in(VALUE self, VALUE port, VALUE host)
    {
        struct rb_addrinfo *res = rsock_addrinfo(host, port, AF_UNSPEC, 0, 0);
        VALUE addr = rb_str_new((char*)res->ai->ai_addr, res->ai->ai_addrlen);

        rb_freeaddrinfo(res);

        return addr;
    }

Packs port and host as an AF_INET/AF_INET6 sockaddr string.

    Socket.sockaddr_in(80, "127.0.0.1")
    #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"

    Socket.sockaddr_in(80, "::1")
    #=> "\n\x00\x00P\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00"

sockaddr_un(path) → sockaddr
pack_sockaddr_un(path) → sockaddr
Source

    static VALUE
    sock_s_pack_sockaddr_un(VALUE self, VALUE path)
    {
        struct sockaddr_un sockaddr;
        VALUE addr;

        StringValue(path);
        INIT_SOCKADDR_UN(&sockaddr, sizeof(struct sockaddr_un));
        if (sizeof(sockaddr.sun_path) < (size_t)RSTRING_LEN(path)) {
            rb_raise(rb_eArgError, "too long unix socket path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
                (size_t)RSTRING_LEN(path), sizeof(sockaddr.sun_path));
        }
        memcpy(sockaddr.sun_path, RSTRING_PTR(path), RSTRING_LEN(path));
        addr = rb_str_new((char*)&sockaddr, rsock_unix_sockaddr_len(path));

        return addr;
    }

Packs path as an `AF_UNIX` sockaddr string.

    Socket.sockaddr_un("/tmp/sock") #=> "\x01\x00/tmp/sock\x00\x00..."

pair(domain, type, protocol) → [socket1, socket2]
socketpair(domain, type, protocol) → [socket1, socket2]
Source

    VALUE
    rsock_sock_s_socketpair(int argc, VALUE *argv, VALUE klass)
    {
        VALUE domain, type, protocol;
        int d, t, p, sp[2];
        int ret;
        VALUE s1, s2, r;

        rb_scan_args(argc, argv, "21", &domain, &type, &protocol);
        if (NIL_P(protocol))
            protocol = INT2FIX(0);

        setup_domain_and_type(domain, &d, type, &t);
        p = NUM2INT(protocol);
        ret = rsock_socketpair(d, t, p, sp);
        if (ret < 0) {
            rb_sys_fail("socketpair(2)");
        }

        s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);
        s2 = rsock_init_sock(rb_obj_alloc(klass), sp[1]);
        r = rb_assoc_new(s1, s2);
        if (rb_block_given_p()) {
            return rb_ensure(pair_yield, r, io_close, s1);
        }
        return r;
    }

Creates a pair of sockets connected each other.

domain should be a communications domain such as: :INET, :INET6, :UNIX, etc.

socktype should be a socket type such as: :STREAM, :DGRAM, :RAW, etc.

protocol should be a protocol defined in the domain, defaults to 0 for the domain.

    s1, s2 = Socket.pair(:UNIX, :STREAM, 0)
    s1.send "a", 0
    s1.send "b", 0
    s1.close
    p s2.recv(10) #=> "ab"
    p s2.recv(10) #=> ""
    p s2.recv(10) #=> ""

    s1, s2 = Socket.pair(:UNIX, :DGRAM, 0)
    s1.send "a", 0
    s1.send "b", 0
    p s2.recv(10) #=> "a"
    p s2.recv(10) #=> "b"

sockaddr_in(port, host) → sockaddr
pack_sockaddr_in(port, host) → sockaddr
Source

    static VALUE
    sock_s_pack_sockaddr_in(VALUE self, VALUE port, VALUE host)
    {
        struct rb_addrinfo *res = rsock_addrinfo(host, port, AF_UNSPEC, 0, 0);
        VALUE addr = rb_str_new((char*)res->ai->ai_addr, res->ai->ai_addrlen);

        rb_freeaddrinfo(res);

        return addr;
    }

Packs port and host as an AF_INET/AF_INET6 sockaddr string.

    Socket.sockaddr_in(80, "127.0.0.1")
    #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"

    Socket.sockaddr_in(80, "::1")
    #=> "\n\x00\x00P\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00"

sockaddr_un(path) → sockaddr
pack_sockaddr_un(path) → sockaddr
Source

    static VALUE
    sock_s_pack_sockaddr_un(VALUE self, VALUE path)
    {
        struct sockaddr_un sockaddr;
        VALUE addr;

        StringValue(path);
        INIT_SOCKADDR_UN(&sockaddr, sizeof(struct sockaddr_un));
        if (sizeof(sockaddr.sun_path) < (size_t)RSTRING_LEN(path)) {
            rb_raise(rb_eArgError, "too long unix socket path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
                (size_t)RSTRING_LEN(path), sizeof(sockaddr.sun_path));
        }
        memcpy(sockaddr.sun_path, RSTRING_PTR(path), RSTRING_LEN(path));
        addr = rb_str_new((char*)&sockaddr, rsock_unix_sockaddr_len(path));

        return addr;
    }

Packs path as an `AF_UNIX` sockaddr string.

    Socket.sockaddr_un("/tmp/sock") #=> "\x01\x00/tmp/sock\x00\x00..."

pair(domain, type, protocol) → [socket1, socket2]
socketpair(domain, type, protocol) → [socket1, socket2]
Source

    VALUE
    rsock_sock_s_socketpair(int argc, VALUE *argv, VALUE klass)
    {
        VALUE domain, type, protocol;
        int d, t, p, sp[2];
        int ret;
        VALUE s1, s2, r;

        rb_scan_args(argc, argv, "21", &domain, &type, &protocol);
        if (NIL_P(protocol))
            protocol = INT2FIX(0);

        setup_domain_and_type(domain, &d, type, &t);
        p = NUM2INT(protocol);
        ret = rsock_socketpair(d, t, p, sp);
        if (ret < 0) {
            rb_sys_fail("socketpair(2)");
        }

        s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);
        s2 = rsock_init_sock(rb_obj_alloc(klass), sp[1]);
        r = rb_assoc_new(s1, s2);
        if (rb_block_given_p()) {
            return rb_ensure(pair_yield, r, io_close, s1);
        }
        return r;
    }

Creates a pair of sockets connected each other.

domain should be a communications domain such as: :INET, :INET6, :UNIX, etc.

socktype should be a socket type such as: :STREAM, :DGRAM, :RAW, etc.

protocol should be a protocol defined in the domain, defaults to 0 for the domain.

    s1, s2 = Socket.pair(:UNIX, :STREAM, 0)
    s1.send "a", 0
    s1.send "b", 0
    s1.close
    p s2.recv(10) #=> "ab"
    p s2.recv(10) #=> ""
    p s2.recv(10) #=> ""

    s1, s2 = Socket.pair(:UNIX, :DGRAM, 0)
    s1.send "a", 0
    s1.send "b", 0
    p s2.recv(10) #=> "a"
    p s2.recv(10) #=> "b"

tcp(host, port, local_host=nil, local_port=nil, [opts]) {|socket| ... }
tcp(host, port, local_host=nil, local_port=nil, [opts])
Source

    # File ext/socket/lib/socket.rb, line 659
    def self.tcp(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, fast_fallback: tcp_fast_fallback, &) # :yield: socket
      sock = if fast_fallback && !(host && ip_address?(host))
        tcp_with_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
      else
        tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
      end

      if block_given?
        begin
          yield sock
        ensure
          sock.close
        end
      else
        sock
      end
    end

creates a new socket object connected to host:port using TCP/IP.

Starting from Ruby 3.4, this method operates according to the Happy Eyeballs Version 2 (RFC 8305) algorithm by default.

For details on Happy Eyeballs Version 2, see `Socket.tcp_fast_fallback=`.

To make it behave the same as in Ruby 3.3 and earlier, explicitly specify the option fast_fallback:false. Or, setting `Socket.tcp_fast_fallback=`false will disable Happy Eyeballs Version 2 not only for this method but for all `Socket` globally.

If local_host:local_port is given, the socket is bound to it.

The optional last argument opts is options represented by a hash. opts may have following options:

:resolv_timeout

  Specifies the timeout in seconds from when the hostname resolution starts.

:connect_timeout

  This method sequentially attempts connecting to all candidate destination addresses.
  The `connect_timeout` specifies the timeout in seconds from the start of the connection attempt to the last candidate.
  By default, all connection attempts continue until the timeout occurs.
  When `fast_fallback:false` is explicitly specified,
  a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.

:fast_fallback

  Enables the Happy Eyeballs Version 2 algorithm (enabled by default).

If a block is given, the block is called with the socket. The value of the block is returned. The socket is closed when this method returns.

If no block is given, the socket is returned.

    Socket.tcp("www.ruby-lang.org", 80) {|sock|
      sock.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
      sock.close_write
      puts sock.read
    }

tcp_fast_fallback → true or false
Source

    VALUE socket_s_tcp_fast_fallback(VALUE self) {
        return rb_ivar_get(rb_cSocket, tcp_fast_fallback);
    }

Returns whether Happy Eyeballs Version 2 (RFC 8305), which is provided starting from Ruby 3.4 when using `TCPSocket.new` and `Socket.tcp`, is enabled or disabled.

If true, it is enabled for `TCPSocket.new` and `Socket.tcp`. (Note: Happy Eyeballs Version 2 is not provided when using `TCPSocket.new` on Windows.)

If false, Happy Eyeballs Version 2 is disabled.

For details on Happy Eyeballs Version 2, see `Socket.tcp_fast_fallback=`.

tcp_fast_fallback= → true or false
Source

    VALUE socket_s_tcp_fast_fallback_set(VALUE self, VALUE value) {
        rb_ivar_set(rb_cSocket, tcp_fast_fallback, value);
        return value;
    }

Enable or disable Happy Eyeballs Version 2 (RFC 8305) globally, which is provided starting from Ruby 3.4 when using `TCPSocket.new` and `Socket.tcp`.

When set to true, the feature is enabled for both ‘TCPSocket.new` and `Socket.tcp`. (Note: This feature is not available when using `TCPSocket.new` on Windows.)

When set to false, the behavior reverts to that of Ruby 3.3 or earlier.

The default value is true if no value is explicitly set by calling this method. However, when the environment variable RUBY_TCP_NO_FAST_FALLBACK=1 is set, the default is false.

To control the setting on a per-method basis, use the fast_fallback keyword argument for each method.

### Happy Eyeballs Version 2¶ ↑

Happy Eyeballs Version 2 (RFC 8305) is an algorithm designed to improve client socket connectivity.
It aims for more reliable and efficient connections by performing hostname resolution and connection attempts in parallel, instead of serially.

Starting from Ruby 3.4, this method operates as follows with this algorithm:

1. Start resolving both IPv6 and IPv4 addresses concurrently.

2. Start connecting to the one of the addresses that are obtained first.
   If IPv4 addresses are obtained first, the method waits 50 ms for IPv6 name resolution to prioritize IPv6 connections.

3. After starting a connection attempt, wait 250 ms for the connection to be established.
   If no connection is established within this time, a new connection is started every 250 ms
   until a connection is established or there are no more candidate addresses.
   (Although RFC 8305 strictly specifies sorting addresses,
   this method only alternates between IPv6 / IPv4 addresses due to the performance concerns)

4. Once a connection is established, all remaining connection attempts are canceled.

tcp_server_loop (host=nil, port) { |socket, client_addrinfo| ... }
Source

    # File ext/socket/lib/socket.rb, line 1272
    def self.tcp_server_loop(host=nil, port, &b) # :yield: socket, client_addrinfo
      tcp_server_sockets(host, port) {|sockets|
        accept_loop(sockets, &b)
      }
    end

creates a TCP/IP server on port and calls the block for each connection accepted. The block is called with a socket and a client_address as an `Addrinfo` object.

If host is specified, it is used with port to determine the server addresses.

The socket is not closed when the block returns. So application should close it explicitly.

This method calls the block sequentially. It means that the next connection is not accepted until the block returns. So concurrent mechanism, thread for example, should be used to service multiple clients at a time.

Note that `Addrinfo.getaddrinfo` is used to determine the server socket addresses. When `Addrinfo.getaddrinfo` returns two or more addresses, IPv4 and IPv6 address for example, all of them are used. `Socket.tcp_server_loop` succeeds if one socket can be used at least.

    # Sequential echo server.
    # It services only one client at a time.
    Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
      begin
        IO.copy_stream(sock, sock)
      ensure
        sock.close
      end
    }

    # Threaded echo server
    # It services multiple clients at a time.
    # Note that it may accept connections too much.
    Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
      Thread.new {
        begin
          IO.copy_stream(sock, sock)
        ensure
          sock.close
        end
      }
    }

tcp_server_sockets (host=nil, port) { |sockets| ... }
Source

    # File ext/socket/lib/socket.rb, line 1172
    def self.tcp_server_sockets(host=nil, port)
      if port == 0
        sockets = tcp_server_sockets_port0(host)
      else
        last_error = nil
        sockets = []
        begin
          Addrinfo.foreach(host, port, nil, :STREAM, nil, Socket::AI_PASSIVE) {|ai|
            begin
              s = ai.listen
            rescue SystemCallError
              last_error = $!
              next
            end
            sockets << s
          }
          if sockets.empty?
            raise last_error
          end
        rescue Exception
          sockets.each(&:close)
          raise
        end
      end
      if block_given?
        begin
          yield sockets
        ensure
          sockets.each(&:close)
        end
      else
        sockets
      end
    end

creates TCP/IP server sockets for host and port. host is optional.

If no block given, it returns an array of listening sockets.

If a block is given, the block is called with the sockets. The value of the block is returned. The socket is closed when this method returns.

If port is 0, actual port number is chosen dynamically. However all sockets in the result has same port number.

    # tcp_server_sockets returns two sockets.
    sockets = Socket.tcp_server_sockets(1296)
    p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]

    # The sockets contains IPv6 and IPv4 sockets.
    sockets.each {|s| p s.local_address }
    #=> #<Addrinfo: [::]:1296 TCP>
    #   #<Addrinfo: 0.0.0.0:1296 TCP>

    # IPv6 and IPv4 socket has same port number, 53114, even if it is chosen dynamically.
    sockets = Socket.tcp_server_sockets(0)
    sockets.each {|s| p s.local_address }
    #=> #<Addrinfo: [::]:53114 TCP>
    #   #<Addrinfo: 0.0.0.0:53114 TCP>

    # The block is called with the sockets.
    Socket.tcp_server_sockets(0) {|sockets|
      p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
    }

tcp_with_fast_fallback (host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil)
Source

    # File ext/socket/lib/socket.rb, line 677
    def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil)
      if local_host || local_port
        local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: resolv_timeout)
        resolving_family_names = local_addrinfos.map { |lai| ADDRESS_FAMILIES.key(lai.afamily) }.uniq
      else
        local_addrinfos = []
        resolving_family_names = ADDRESS_FAMILIES.keys
      end

      hostname_resolution_threads = []
      resolution_store = HostnameResolutionStore.new(resolving_family_names)
      connecting_sockets = {}
      is_windows_environment ||= (RUBY_PLATFORM =~ /mswin|mingw|cygwin/)

      now = current_clock_time
      resolution_delay_expires_at = nil
      connection_attempt_delay_expires_at = nil
      user_specified_connect_timeout_at = nil
      last_error = nil

      if resolving_family_names.size == 1
        family_name = resolving_family_names.first
        addrinfos = Addrinfo.getaddrinfo(host, port, family_name, :STREAM, timeout: resolv_timeout)
        resolution_store.add_resolved(family_name, addrinfos)
        hostname_resolution_result = nil
        hostname_resolution_notifier = nil
        user_specified_resolv_timeout_at = nil
      else
        hostname_resolution_result = HostnameResolutionResult.new(resolving_family_names.size)
        hostname_resolution_notifier = hostname_resolution_result.notifier

        hostname_resolution_threads.concat(
          resolving_family_names.map { |family|
            thread_args = [family, host, port, hostname_resolution_result]
            thread = Thread.new(*thread_args) { |*thread_args| resolve_hostname(*thread_args) }
            Thread.pass
            thread
          }
        )

        user_specified_resolv_timeout_at = resolv_timeout ? now + resolv_timeout : Float::INFINITY
      end

      loop do
        if resolution_store.any_addrinfos? &&
            !resolution_delay_expires_at &&
            !connection_attempt_delay_expires_at
          while (addrinfo = resolution_store.get_addrinfo)
            if local_addrinfos.any?
              local_addrinfo = local_addrinfos.find { |lai| lai.afamily == addrinfo.afamily }

              if local_addrinfo.nil? # Connecting addrinfoと同じアドレスファミリのLocal addrinfoがない
                if resolution_store.any_addrinfos?
                  # Try other Addrinfo in next "while"
                  next
                elsif connecting_sockets.any? || resolution_store.any_unresolved_family?
                  # Exit this "while" and wait for connections to be established or hostname resolution in next loop
                  # Or exit this "while" and wait for hostname resolution in next loop
                  break
                else
                  raise SocketError.new 'no appropriate local address'
                end
              end
            end

            begin
              if resolution_store.any_addrinfos? ||
                 connecting_sockets.any? ||
                 resolution_store.any_unresolved_family?
                socket = Socket.new(addrinfo.pfamily, addrinfo.socktype, addrinfo.protocol)
                socket.bind(local_addrinfo) if local_addrinfo
                result = socket.connect_nonblock(addrinfo, exception: false)
              else
                result = socket = local_addrinfo ?
                  addrinfo.connect_from(local_addrinfo, timeout: connect_timeout) :
                  addrinfo.connect(timeout: connect_timeout)
              end

              if result == :wait_writable
                connection_attempt_delay_expires_at = now + CONNECTION_ATTEMPT_DELAY
                if resolution_store.empty_addrinfos?
                  user_specified_connect_timeout_at = connect_timeout ? now + connect_timeout : Float::INFINITY
                end

                connecting_sockets[socket] = addrinfo
                break
              else
                return socket # connection established
              end
            rescue SystemCallError => e
              socket&.close
              last_error = e

              if resolution_store.any_addrinfos?
                # Try other Addrinfo in next "while"
                next
              elsif connecting_sockets.any? || resolution_store.any_unresolved_family?
                # Exit this "while" and wait for connections to be established or hostname resolution in next loop
                # Or exit this "while" and wait for hostname resolution in next loop
                break
              else
                raise last_error
              end
            end
          end
        end

        ends_at =
          if resolution_store.any_addrinfos?
            resolution_delay_expires_at || connection_attempt_delay_expires_at
          else
            [user_specified_resolv_timeout_at, user_specified_connect_timeout_at].compact.max
          end

        hostname_resolved, writable_sockets, except_sockets = IO.select(
          hostname_resolution_notifier,
          connecting_sockets.keys,
          # Use errorfds to wait for non-blocking connect failures on Windows
          is_windows_environment ? connecting_sockets.keys : nil,
          second_to_timeout(current_clock_time, ends_at),
        )
        now = current_clock_time
        resolution_delay_expires_at = nil if expired?(now, resolution_delay_expires_at)
        connection_attempt_delay_expires_at = nil if expired?(now, connection_attempt_delay_expires_at)

        if writable_sockets&.any?
          while (writable_socket = writable_sockets.pop)
            is_connected = is_windows_environment || (
              sockopt = writable_socket.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
              sockopt.int.zero?
            )

            if is_connected
              connecting_sockets.delete writable_socket
              return writable_socket
            else
              failed_ai = connecting_sockets.delete writable_socket
              writable_socket.close
              ip_address = failed_ai.ipv6? ? "[#{failed_ai.ip_address}]" : failed_ai.ip_address
              last_error = SystemCallError.new("connect(2) for #{ip_address}:#{failed_ai.ip_port}", sockopt.int)

              if writable_sockets.any? || connecting_sockets.any?
                # Try other writable socket in next "while"
                # Or exit this "while" and wait for connections to be established or hostname resolution in next loop
              elsif resolution_store.any_addrinfos? || resolution_store.any_unresolved_family?
                # Exit this "while" and try other connection attempt
                # Or exit this "while" and wait for hostname resolution in next loop
                connection_attempt_delay_expires_at = nil
                user_specified_connect_timeout_at = nil
              else
                raise last_error
              end
            end
          end
        end

        if except_sockets&.any?
          except_sockets.each do |except_socket|
            failed_ai = connecting_sockets.delete except_socket
            sockopt = except_socket.getsockopt(Socket::SOL_SOCKET, Socket::SO_CONNECT_TIME)
            except_socket.close
            ip_address = failed_ai.ipv6? ? "[#{failed_ai.ip_address}]" : failed_ai.ip_address
            last_error = SystemCallError.new("connect(2) for #{ip_address}:#{failed_ai.ip_port}", sockopt.int)

            if except_sockets.any? || connecting_sockets.any?
              # Cleanup other except socket in next "each"
              # Or exit this "while" and wait for connections to be established or hostname resolution in next loop
            elsif resolution_store.any_addrinfos? || resolution_store.any_unresolved_family?
              # Exit this "while" and try other connection attempt
              # Or exit this "while" and wait for hostname resolution in next loop
              connection_attempt_delay_expires_at = nil
              user_specified_connect_timeout_at = nil
            else
              raise last_error
            end
          end
        end

        if hostname_resolved&.any?
          while (family_and_result = hostname_resolution_result.get)
            family_name, result = family_and_result

            if result.is_a? Exception
              resolution_store.add_error(family_name, result)

              unless (Socket.const_defined?(:EAI_ADDRFAMILY)) &&
                (result.is_a?(Socket::ResolutionError)) &&
                (result.error_code == Socket::EAI_ADDRFAMILY)
                last_error = result
              end
            else
              resolution_store.add_resolved(family_name, result)
            end
          end

          if resolution_store.resolved?(:ipv4)
            if resolution_store.resolved?(:ipv6)
              hostname_resolution_notifier = nil
              resolution_delay_expires_at = nil
              user_specified_resolv_timeout_at = nil
            elsif resolution_store.resolved_successfully?(:ipv4)
              resolution_delay_expires_at = now + RESOLUTION_DELAY
            end
          end
        end

        if resolution_store.empty_addrinfos?
          if connecting_sockets.empty? && resolution_store.resolved_all_families?
            raise last_error
          end

          if (expired?(now, user_specified_resolv_timeout_at) || resolution_store.resolved_all_families?) &&
             (expired?(now, user_specified_connect_timeout_at) || connecting_sockets.empty?)
            raise Errno::ETIMEDOUT, 'user specified timeout'
          end
        end
      end
    ensure
      hostname_resolution_threads.each do |thread|
        thread.exit
      end

      hostname_resolution_result&.close

      connecting_sockets.each_key do |connecting_socket|
        connecting_socket.close
      end
    end

udp_server_loop(port) {|msg, msg_src| ... }
udp_server_loop(host, port) {|msg, msg_src| ... }
Source

    # File ext/socket/lib/socket.rb, line 1442
    def self.udp_server_loop(host=nil, port, &b) # :yield: message, message_source
      udp_server_sockets(host, port) {|sockets|
        udp_server_loop_on(sockets, &b)
      }
    end

creates a UDP/IP server on port and calls the block for each message arrived. The block is called with the message and its source information.

This method allocates sockets internally using port. If host is specified, it is used conjunction with port to determine the server addresses.

The msg is a string.

The msg_src is a `Socket::UDPSource` object. It is used for reply.

    # UDP/IP echo server.
    Socket.udp_server_loop(9261) {|msg, msg_src|
      msg_src.reply msg
    }

udp_server_loop_on(sockets) {|msg, msg_src| ... }
Source

    # File ext/socket/lib/socket.rb, line 1415
    def self.udp_server_loop_on(sockets, &b) # :yield: msg, msg_src
      loop {
        readable, _, _ = IO.select(sockets)
        udp_server_recv(readable, &b)
      }
    end

Run UDP/IP server loop on the given sockets.

The return value of `Socket.udp_server_sockets` is appropriate for the argument.

It calls the block for each message received.

udp_server_recv(sockets) {|msg, msg_src| ... }
Source

    # File ext/socket/lib/socket.rb, line 1388
    def self.udp_server_recv(sockets)
      sockets.each {|r|
        msg, sender_addrinfo, _, *controls = r.recvmsg_nonblock(exception: false)
        next if msg == :wait_readable
        ai = r.local_address
        if ai.ipv6? and pktinfo = controls.find {|c| c.cmsg_is?(:IPV6, :PKTINFO) }
          ai = Addrinfo.udp(pktinfo.ipv6_pktinfo_addr.ip_address, ai.ip_port)
          yield msg, UDPSource.new(sender_addrinfo, ai) {|reply_msg|
            r.sendmsg reply_msg, 0, sender_addrinfo, pktinfo
          }
        else
          yield msg, UDPSource.new(sender_addrinfo, ai) {|reply_msg|
            r.send reply_msg, 0, sender_addrinfo
          }
        end
      }
    end

Receive UDP/IP packets from the given sockets. For each packet received, the block is called.

The block receives msg and msg_src. msg is a string which is the payload of the received packet. msg_src is a `Socket::UDPSource` object which is used for reply.

`Socket.udp_server_loop` can be implemented using this method as follows.

    udp_server_sockets(host, port) {|sockets|
      loop {
        readable, _, _ = IO.select(sockets)
        udp_server_recv(readable) {|msg, msg_src| ... }
      }
    }

udp_server_sockets([host, ] port)
Source

    # File ext/socket/lib/socket.rb, line 1300
    def self.udp_server_sockets(host=nil, port)
      last_error = nil
      sockets = []

      ipv6_recvpktinfo = nil
      if defined? Socket::AncillaryData
        if defined? Socket::IPV6_RECVPKTINFO # RFC 3542
          ipv6_recvpktinfo = Socket::IPV6_RECVPKTINFO
        elsif defined? Socket::IPV6_PKTINFO # RFC 2292
          ipv6_recvpktinfo = Socket::IPV6_PKTINFO
        end
      end

      local_addrs = Socket.ip_address_list

      ip_list = []
      Addrinfo.foreach(host, port, nil, :DGRAM, nil, Socket::AI_PASSIVE) {|ai|
        if ai.ipv4? && ai.ip_address == "0.0.0.0"
          local_addrs.each {|a|
            next unless a.ipv4?
            ip_list << Addrinfo.new(a.to_sockaddr, :INET, :DGRAM, 0);
          }
        elsif ai.ipv6? && ai.ip_address == "::" && !ipv6_recvpktinfo
          local_addrs.each {|a|
            next unless a.ipv6?
            ip_list << Addrinfo.new(a.to_sockaddr, :INET6, :DGRAM, 0);
          }
        else
          ip_list << ai
        end
      }
      ip_list.uniq!(&:to_sockaddr)

      if port == 0
        sockets = ip_sockets_port0(ip_list, false)
      else
        ip_list.each {|ip|
          ai = Addrinfo.udp(ip.ip_address, port)
          begin
            s = ai.bind
          rescue SystemCallError
            last_error = $!
            next
          end
          sockets << s
        }
        if sockets.empty?
          raise last_error
        end
      end

      sockets.each {|s|
        ai = s.local_address
        if ipv6_recvpktinfo && ai.ipv6? && ai.ip_address == "::"
          s.setsockopt(:IPV6, ipv6_recvpktinfo, 1)
        end
      }

      if block_given?
        begin
          yield sockets
        ensure
          sockets.each(&:close) if sockets
        end
      else
        sockets
      end
    end

Creates UDP/IP sockets for a UDP server.

If no block given, it returns an array of sockets.

If a block is given, the block is called with the sockets. The value of the block is returned. The sockets are closed when this method returns.

If port is zero, some port is chosen. But the chosen port is used for the all sockets.

    # UDP/IP echo server
    Socket.udp_server_sockets(0) {|sockets|
      p sockets.first.local_address.ip_port     #=> 32963
      Socket.udp_server_loop_on(sockets) {|msg, msg_src|
        msg_src.reply msg
      }
    }

unix (path) { |socket| ... }
Source

    # File ext/socket/lib/socket.rb, line 1492
    def self.unix(path) # :yield: socket
      addr = Addrinfo.unix(path)
      sock = addr.connect
      if block_given?
        begin
          yield sock
        ensure
          sock.close
        end
      else
        sock
      end
    end

creates a new socket connected to path using UNIX socket socket.

If a block is given, the block is called with the socket. The value of the block is returned. The socket is closed when this method returns.

If no block is given, the socket is returned.

    # talk to /tmp/sock socket.
    Socket.unix("/tmp/sock") {|sock|
      t = Thread.new { IO.copy_stream(sock, STDOUT) }
      IO.copy_stream(STDIN, sock)
      t.join
    }

unix_server_loop (path) { |socket, client_addrinfo| ... }
Source

    # File ext/socket/lib/socket.rb, line 1579
    def self.unix_server_loop(path, &b) # :yield: socket, client_addrinfo
      unix_server_socket(path) {|serv|
        accept_loop(serv, &b)
      }
    end

creates a UNIX socket server on path. It calls the block for each socket accepted.

If host is specified, it is used with port to determine the server ports.

The socket is not closed when the block returns. So application should close it.

This method deletes the socket file pointed by path at first if the file is a socket file and it is owned by the user of the application. This is safe only if the directory of path is not changed by a malicious user. So don’t use /tmp/malicious-users-directory/socket. Note that /tmp/socket and /tmp/your-private-directory/socket is safe assuming that /tmp has sticky bit.

    # Sequential echo server.
    # It services only one client at a time.
    Socket.unix_server_loop("/tmp/sock") {|sock, client_addrinfo|
      begin
        IO.copy_stream(sock, sock)
      ensure
        sock.close
      end
    }

unix_server_socket (path) { |s| ... }
Source

    # File ext/socket/lib/socket.rb, line 1522
    def self.unix_server_socket(path)
      unless unix_socket_abstract_name?(path)
        begin
          st = File.lstat(path)
        rescue Errno::ENOENT
        end
        if st&.socket? && st.owned?
          File.unlink path
        end
      end
      s = Addrinfo.unix(path).listen
      if block_given?
        begin
          yield s
        ensure
          s.close
          unless unix_socket_abstract_name?(path)
            File.unlink path
          end
        end
      else
        s
      end
    end

creates a UNIX server socket on path

If no block given, it returns a listening socket.

If a block is given, it is called with the socket and the block value is returned. When the block exits, the socket is closed and the socket file is removed.

    socket = Socket.unix_server_socket("/tmp/s")
    p socket                  #=> #<Socket:fd 3>
    p socket.local_address    #=> #<Addrinfo: /tmp/s SOCK_STREAM>

    Socket.unix_server_socket("/tmp/sock") {|s|
      p s                     #=> #<Socket:fd 3>
      p s.local_address       #=> # #<Addrinfo: /tmp/sock SOCK_STREAM>
    }

unpack_sockaddr_in(sockaddr) → [port, ip_address]
Source

    static VALUE
    sock_s_unpack_sockaddr_in(VALUE self, VALUE addr)
    {
        struct sockaddr_in * sockaddr;
        VALUE host;

        sockaddr = (struct sockaddr_in*)SockAddrStringValuePtr(addr);
        if (RSTRING_LEN(addr) <
            (char*)&((struct sockaddr *)sockaddr)->sa_family +
            sizeof(((struct sockaddr *)sockaddr)->sa_family) -
            (char*)sockaddr)
            rb_raise(rb_eArgError, "too short sockaddr");
        if (((struct sockaddr *)sockaddr)->sa_family != AF_INET
    #ifdef INET6
            && ((struct sockaddr *)sockaddr)->sa_family != AF_INET6
    #endif
            ) {
    #ifdef INET6
            rb_raise(rb_eArgError, "not an AF_INET/AF_INET6 sockaddr");
    #else
            rb_raise(rb_eArgError, "not an AF_INET sockaddr");
    #endif
        }
        host = rsock_make_ipaddr((struct sockaddr*)sockaddr, RSTRING_SOCKLEN(addr));
        return rb_assoc_new(INT2NUM(ntohs(sockaddr->sin_port)), host);
    }

Unpacks sockaddr into port and ip_address.

sockaddr should be a string or an addrinfo for AF_INET/AF_INET6.

    sockaddr = Socket.sockaddr_in(80, "127.0.0.1")
    p sockaddr #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
    p Socket.unpack_sockaddr_in(sockaddr) #=> [80, "127.0.0.1"]

unpack_sockaddr_un(sockaddr) → path
Source

    static VALUE
    sock_s_unpack_sockaddr_un(VALUE self, VALUE addr)
    {
        struct sockaddr_un * sockaddr;
        VALUE path;

        sockaddr = (struct sockaddr_un*)SockAddrStringValuePtr(addr);
        if (RSTRING_LEN(addr) <
            (char*)&((struct sockaddr *)sockaddr)->sa_family +
            sizeof(((struct sockaddr *)sockaddr)->sa_family) -
            (char*)sockaddr)
            rb_raise(rb_eArgError, "too short sockaddr");
        if (((struct sockaddr *)sockaddr)->sa_family != AF_UNIX) {
            rb_raise(rb_eArgError, "not an AF_UNIX sockaddr");
        }
        if (sizeof(struct sockaddr_un) < (size_t)RSTRING_LEN(addr)) {
            rb_raise(rb_eTypeError, "too long sockaddr_un - %ld longer than %d",
                     RSTRING_LEN(addr), (int)sizeof(struct sockaddr_un));
        }
        path = rsock_unixpath_str(sockaddr, RSTRING_SOCKLEN(addr));
        return path;
    }

Unpacks sockaddr into path.

sockaddr should be a string or an addrinfo for `AF_UNIX`.

    sockaddr = Socket.sockaddr_un("/tmp/sock")
    p Socket.unpack_sockaddr_un(sockaddr) #=> "/tmp/sock"

### Private Class Methods

current_clock_time ()
Source

    # File ext/socket/lib/socket.rb, line 960
    def self.current_clock_time
      Process.clock_gettime(Process::CLOCK_MONOTONIC)
    end

expired? (started_at, ends_at)
Source

    # File ext/socket/lib/socket.rb, line 973
    def self.expired?(started_at, ends_at)
      second_to_timeout(started_at, ends_at)&.zero?
    end

ip_address? (hostname)
Source

    # File ext/socket/lib/socket.rb, line 945
    def self.ip_address?(hostname)
      hostname.match?(IPV6_ADRESS_FORMAT) || hostname.match?(/\A([0-9]{1,3}\.){3}[0-9]{1,3}\z/)
    end

resolve_hostname (family, host, port, hostname_resolution_result)
Source

    # File ext/socket/lib/socket.rb, line 950
    def self.resolve_hostname(family, host, port, hostname_resolution_result)
      begin
        resolved_addrinfos = Addrinfo.getaddrinfo(host, port, ADDRESS_FAMILIES[family], :STREAM)
        hostname_resolution_result.add(family, resolved_addrinfos)
      rescue => e
        hostname_resolution_result.add(family, e)
      end
    end

second_to_timeout (started_at, ends_at)
Source

    # File ext/socket/lib/socket.rb, line 965
    def self.second_to_timeout(started_at, ends_at)
      return nil if ends_at == Float::INFINITY || ends_at.nil?

      remaining = (ends_at - started_at)
      remaining.negative? ? 0 : remaining
    end

tcp_without_fast_fallback (host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
Source

    # File ext/socket/lib/socket.rb, line 906
    def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
      last_error = nil
      ret = nil

      local_addr_list = nil
      if local_host != nil || local_port != nil
        local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)
      end

      Addrinfo.foreach(host, port, nil, :STREAM, timeout: resolv_timeout) {|ai|
        if local_addr_list
          local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }
          next unless local_addr
        else
          local_addr = nil
        end
        begin
          sock = local_addr ?
            ai.connect_from(local_addr, timeout: connect_timeout) :
            ai.connect(timeout: connect_timeout)
        rescue SystemCallError
          last_error = $!
          next
        end
        ret = sock
        break
      }
      unless ret
        if last_error
          raise last_error
        else
          raise SocketError, "no appropriate local address"
        end
      end

      ret
    end

unix_socket_abstract_name? (path)
Source

    # File ext/socket/lib/socket.rb, line 1550
    def unix_socket_abstract_name?(path)
      /linux/ =~ RUBY_PLATFORM && /\A(\0|\z)/ =~ path
    end

### Public Instance Methods

accept → [client_socket, client_addrinfo]
Source

    static VALUE
    sock_accept(VALUE server)
    {
        union_sockaddr buffer;
        socklen_t length = (socklen_t)sizeof(buffer);

        VALUE peer = rsock_s_accept(rb_cSocket, server, &buffer.addr, &length);

        return rb_assoc_new(peer, rsock_io_socket_addrinfo(peer, &buffer.addr, length));
    }

Accepts a next connection. Returns a new `Socket` object and `Addrinfo` object.

    serv = Socket.new(:INET, :STREAM, 0)
    serv.listen(5)
    c = Socket.new(:INET, :STREAM, 0)
    c.connect(serv.connect_address)
    p serv.accept #=> [#<Socket:fd 6>, #<Addrinfo: 127.0.0.1:48555 TCP>]

accept_nonblock([options]) → [client_socket, client_addrinfo]
Source

    # File ext/socket/lib/socket.rb, line 598
    def accept_nonblock(exception: true)
      __accept_nonblock(exception)
    end

Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. It returns an array containing the accepted socket for the incoming connection, client_socket, and an `Addrinfo`, client_addrinfo.

### Example¶ ↑

    # In one script, start this first
    require 'socket'
    include Socket::Constants
    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
    sockaddr = Socket.sockaddr_in(2200, 'localhost')
    socket.bind(sockaddr)
    socket.listen(5)
    begin # emulate blocking accept
      client_socket, client_addrinfo = socket.accept_nonblock
    rescue IO::WaitReadable, Errno::EINTR
      IO.select([socket])
      retry
    end
    puts "The client said, '#{client_socket.readline.chomp}'"
    client_socket.puts "Hello from script one!"
    socket.close

    # In another script, start this second
    require 'socket'
    include Socket::Constants
    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
    sockaddr = Socket.sockaddr_in(2200, 'localhost')
    socket.connect(sockaddr)
    socket.puts "Hello from script 2."
    puts "The server said, '#{socket.readline.chomp}'"
    socket.close

Refer to `Socket#accept` for the exceptions that may be thrown if the call to accept_nonblock fails.

`Socket#accept_nonblock` may raise any error corresponding to accept(2) failure, including Errno::EWOULDBLOCK.

If the exception is Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNABORTED or Errno::EPROTO, it is extended by `IO::WaitReadable`. So `IO::WaitReadable` can be used to rescue the exceptions for retrying accept_nonblock.

By specifying a keyword argument exception to `false`, you can indicate that `accept_nonblock` should not raise an `IO::WaitReadable` exception, but return the symbol `:wait_readable` instead.

### See¶ ↑

- `Socket#accept`

bind(local_sockaddr) → 0
Source

    static VALUE
    sock_bind(VALUE sock, VALUE addr)
    {
        VALUE rai;
        rb_io_t *fptr;

        SockAddrStringValueWithAddrinfo(addr, rai);
        GetOpenFile(sock, fptr);
        if (bind(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr)) < 0)
            rsock_sys_fail_raddrinfo_or_sockaddr("bind(2)", addr, rai);

        return INT2FIX(0);
    }

Binds to the given local address.

### Parameter¶ ↑

- `local_sockaddr` - the `struct` sockaddr contained in a string or an `Addrinfo` object

### Example¶ ↑

    require 'socket'

    # use Addrinfo
    socket = Socket.new(:INET, :STREAM, 0)
    socket.bind(Addrinfo.tcp("127.0.0.1", 2222))
    p socket.local_address #=> #<Addrinfo: 127.0.0.1:2222 TCP>

    # use struct sockaddr
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.bind( sockaddr )

### Unix-based Exceptions¶ ↑

On unix-based based systems the following system exceptions may be raised if the call to bind fails:

- Errno::EACCES - the specified sockaddr is protected and the current user does not have permission to bind to it

- Errno::EADDRINUSE - the specified sockaddr is already in use

- Errno::EADDRNOTAVAIL - the specified sockaddr is not available from the local machine

- Errno::EAFNOSUPPORT - the specified sockaddr is not a valid address for the family of the calling `socket`

- Errno::EBADF - the sockaddr specified is not a valid file descriptor

- Errno::EFAULT - the sockaddr argument cannot be accessed

- Errno::EINVAL - the `socket` is already bound to an address, and the protocol does not support binding to the new sockaddr or the `socket` has been shut down.

- Errno::EINVAL - the address length is not a valid length for the address family

- Errno::ENAMETOOLONG - the pathname resolved had a length which exceeded PATH_MAX

- Errno::ENOBUFS - no buffer space is available

- Errno::ENOSR - there were insufficient STREAMS resources available to complete the operation

- Errno::ENOTSOCK - the `socket` does not refer to a socket

- Errno::EOPNOTSUPP - the socket type of the `socket` does not support binding to an address

On unix-based based systems if the address family of the calling `socket` is `Socket::AF_UNIX` the follow exceptions may be raised if the call to bind fails:

- Errno::EACCES - search permission is denied for a component of the prefix path or write access to the `socket` is denied

- Errno::EDESTADDRREQ - the sockaddr argument is a null pointer

- Errno::EISDIR - same as Errno::EDESTADDRREQ

- Errno::EIO - an i/o error occurred

- Errno::ELOOP - too many symbolic links were encountered in translating the pathname in sockaddr

- Errno::ENAMETOOLLONG - a component of a pathname exceeded NAME_MAX characters, or an entire pathname exceeded PATH_MAX characters

- Errno::ENOENT - a component of the pathname does not name an existing file or the pathname is an empty string

- Errno::ENOTDIR - a component of the path prefix of the pathname in sockaddr is not a directory

- Errno::EROFS - the name would reside on a read only filesystem

### Windows Exceptions¶ ↑

On Windows systems the following system exceptions may be raised if the call to bind fails:

- Errno::ENETDOWN– the network is down

- Errno::EACCES - the attempt to connect the datagram socket to the broadcast address failed

- Errno::EADDRINUSE - the socket’s local address is already in use

- Errno::EADDRNOTAVAIL - the specified address is not a valid address for this computer

- Errno::EFAULT - the socket’s internal address or address length parameter is too small or is not a valid part of the user space addressed

- Errno::EINVAL - the `socket` is already bound to an address

- Errno::ENOBUFS - no buffer space is available

- Errno::ENOTSOCK - the `socket` argument does not refer to a socket

### See¶ ↑

- bind manual pages on unix-based systems

- bind function in Microsoft’s Winsock functions reference

connect(remote_sockaddr) → 0
Source

    static VALUE
    sock_connect(VALUE self, VALUE addr)
    {
        VALUE rai;

        SockAddrStringValueWithAddrinfo(addr, rai);
        addr = rb_str_new4(addr);

        int result = rsock_connect(self, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr), 0, RUBY_IO_TIMEOUT_DEFAULT);

        if (result < 0) {
            rsock_sys_fail_raddrinfo_or_sockaddr("connect(2)", addr, rai);
        }

        return INT2FIX(result);
    }

Requests a connection to be made on the given `remote_sockaddr`. Returns 0 if successful, otherwise an exception is raised.

### Parameter¶ ↑

- `remote_sockaddr` - the `struct` sockaddr contained in a string or `Addrinfo` object

### Example:¶ ↑

    # Pull down Google's web page
    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 80, 'www.google.com' )
    socket.connect( sockaddr )
    socket.write( "GET / HTTP/1.0\r\n\r\n" )
    results = socket.read

### Unix-based Exceptions¶ ↑

On unix-based systems the following system exceptions may be raised if the call to connect fails:

- Errno::EACCES - search permission is denied for a component of the prefix path or write access to the `socket` is denied

- Errno::EADDRINUSE - the sockaddr is already in use

- Errno::EADDRNOTAVAIL - the specified sockaddr is not available from the local machine

- Errno::EAFNOSUPPORT - the specified sockaddr is not a valid address for the address family of the specified `socket`

- Errno::EALREADY - a connection is already in progress for the specified socket

- Errno::EBADF - the `socket` is not a valid file descriptor

- Errno::ECONNREFUSED - the target sockaddr was not listening for connections refused the connection request

- Errno::ECONNRESET - the remote host reset the connection request

- Errno::EFAULT - the sockaddr cannot be accessed

- Errno::EHOSTUNREACH - the destination host cannot be reached (probably because the host is down or a remote router cannot reach it)

- Errno::EINPROGRESS - the O_NONBLOCK is set for the `socket` and the connection cannot be immediately established; the connection will be established asynchronously

- Errno::EINTR - the attempt to establish the connection was interrupted by delivery of a signal that was caught; the connection will be established asynchronously

- Errno::EISCONN - the specified `socket` is already connected

- Errno::EINVAL - the address length used for the sockaddr is not a valid length for the address family or there is an invalid family in sockaddr

- Errno::ENAMETOOLONG - the pathname resolved had a length which exceeded PATH_MAX

- Errno::ENETDOWN - the local interface used to reach the destination is down

- Errno::ENETUNREACH - no route to the network is present

- Errno::ENOBUFS - no buffer space is available

- Errno::ENOSR - there were insufficient STREAMS resources available to complete the operation

- Errno::ENOTSOCK - the `socket` argument does not refer to a socket

- Errno::EOPNOTSUPP - the calling `socket` is listening and cannot be connected

- Errno::EPROTOTYPE - the sockaddr has a different type than the socket bound to the specified peer address

- Errno::ETIMEDOUT - the attempt to connect timed out before a connection was made.

On unix-based systems if the address family of the calling `socket` is `AF_UNIX` the follow exceptions may be raised if the call to connect fails:

- Errno::EIO - an i/o error occurred while reading from or writing to the file system

- Errno::ELOOP - too many symbolic links were encountered in translating the pathname in sockaddr

- Errno::ENAMETOOLLONG - a component of a pathname exceeded NAME_MAX characters, or an entire pathname exceeded PATH_MAX characters

- Errno::ENOENT - a component of the pathname does not name an existing file or the pathname is an empty string

- Errno::ENOTDIR - a component of the path prefix of the pathname in sockaddr is not a directory

### Windows Exceptions¶ ↑

On Windows systems the following system exceptions may be raised if the call to connect fails:

- Errno::ENETDOWN - the network is down

- Errno::EADDRINUSE - the socket’s local address is already in use

- Errno::EINTR - the socket was cancelled

- Errno::EINPROGRESS - a blocking socket is in progress or the service provider is still processing a callback function. Or a nonblocking connect call is in progress on the `socket`.

- Errno::EALREADY - see Errno::EINVAL

- Errno::EADDRNOTAVAIL - the remote address is not a valid address, such as ADDR_ANY TODO check ADDRANY TO `INADDR_ANY`

- Errno::EAFNOSUPPORT - addresses in the specified family cannot be used with with this `socket`

- Errno::ECONNREFUSED - the target sockaddr was not listening for connections refused the connection request

- Errno::EFAULT - the socket’s internal address or address length parameter is too small or is not a valid part of the user space address

- Errno::EINVAL - the `socket` is a listening socket

- Errno::EISCONN - the `socket` is already connected

- Errno::ENETUNREACH - the network cannot be reached from this host at this time

- Errno::EHOSTUNREACH - no route to the network is present

- Errno::ENOBUFS - no buffer space is available

- Errno::ENOTSOCK - the `socket` argument does not refer to a socket

- Errno::ETIMEDOUT - the attempt to connect timed out before a connection was made.

- Errno::EWOULDBLOCK - the socket is marked as nonblocking and the connection cannot be completed immediately

- Errno::EACCES - the attempt to connect the datagram socket to the broadcast address failed

### See¶ ↑

- connect manual pages on unix-based systems

- connect function in Microsoft’s Winsock functions reference

connect_nonblock(remote_sockaddr, [options]) → 0
Source

    # File ext/socket/lib/socket.rb, line 1629
    def connect_nonblock(addr, exception: true)
      __connect_nonblock(addr, exception)
    end

Requests a connection to be made on the given `remote_sockaddr` after O_NONBLOCK is set for the underlying file descriptor. Returns 0 if successful, otherwise an exception is raised.

### Parameter¶ ↑

- `remote_sockaddr` - the `struct` sockaddr contained in a string or `Addrinfo` object

### Example:¶ ↑

    # Pull down Google's web page
    require 'socket'
    include Socket::Constants
    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
    sockaddr = Socket.sockaddr_in(80, 'www.google.com')
    begin # emulate blocking connect
      socket.connect_nonblock(sockaddr)
    rescue IO::WaitWritable
      IO.select(nil, [socket]) # wait 3-way handshake completion
      begin
        socket.connect_nonblock(sockaddr) # check connection failure
      rescue Errno::EISCONN
      end
    end
    socket.write("GET / HTTP/1.0\r\n\r\n")
    results = socket.read

Refer to `Socket#connect` for the exceptions that may be thrown if the call to connect_nonblock fails.

`Socket#connect_nonblock` may raise any error corresponding to connect(2) failure, including Errno::EINPROGRESS.

If the exception is Errno::EINPROGRESS, it is extended by `IO::WaitWritable`. So `IO::WaitWritable` can be used to rescue the exceptions for retrying connect_nonblock.

By specifying a keyword argument exception to `false`, you can indicate that `connect_nonblock` should not raise an `IO::WaitWritable` exception, but return the symbol `:wait_writable` instead.

### See¶ ↑

- `Socket#connect`

ipv6only! ()
Source

    # File ext/socket/lib/socket.rb, line 468
    def ipv6only!
      if defined? Socket::IPV6_V6ONLY
        self.setsockopt(:IPV6, :V6ONLY, 1)
      end
    end

enable the socket option `IPV6_V6ONLY` if `IPV6_V6ONLY` is available.

listen( int ) → 0
Source

    VALUE
    rsock_sock_listen(VALUE sock, VALUE log)
    {
        rb_io_t *fptr;
        int backlog;

        backlog = NUM2INT(log);
        GetOpenFile(sock, fptr);
        if (listen(fptr->fd, backlog) < 0)
            rb_sys_fail("listen(2)");

        return INT2FIX(0);
    }

Listens for connections, using the specified `int` as the backlog. A call to listen only applies if the `socket` is of type `SOCK_STREAM` or `SOCK_SEQPACKET`.

### Parameter¶ ↑

- `backlog` - the maximum length of the queue for pending connections.

### Example 1¶ ↑

    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.bind( sockaddr )
    socket.listen( 5 )

### Example 2 (listening on an arbitrary port, unix-based systems only):¶ ↑

    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    socket.listen( 1 )

### Unix-based Exceptions¶ ↑

On unix based systems the above will work because a new `sockaddr` struct is created on the address ADDR_ANY, for an arbitrary port number as handed off by the kernel. It will not work on Windows, because Windows requires that the `socket` is bound by calling bind before it can listen.

If the backlog amount exceeds the implementation-dependent maximum queue length, the implementation’s maximum queue length will be used.

On unix-based based systems the following system exceptions may be raised if the call to listen fails:

- Errno::EBADF - the socket argument is not a valid file descriptor

- Errno::EDESTADDRREQ - the socket is not bound to a local address, and the protocol does not support listening on an unbound socket

- Errno::EINVAL - the socket is already connected

- Errno::ENOTSOCK - the socket argument does not refer to a socket

- Errno::EOPNOTSUPP - the socket protocol does not support listen

- Errno::EACCES - the calling process does not have appropriate privileges

- Errno::EINVAL - the socket has been shut down

- Errno::ENOBUFS - insufficient resources are available in the system to complete the call

### Windows Exceptions¶ ↑

On Windows systems the following system exceptions may be raised if the call to listen fails:

- Errno::ENETDOWN - the network is down

- Errno::EADDRINUSE - the socket’s local address is already in use. This usually occurs during the execution of bind but could be delayed if the call to bind was to a partially wildcard address (involving ADDR_ANY) and if a specific address needs to be committed at the time of the call to listen

- Errno::EINPROGRESS - a Windows Sockets 1.1 call is in progress or the service provider is still processing a callback function

- Errno::EINVAL - the `socket` has not been bound with a call to bind.

- Errno::EISCONN - the `socket` is already connected

- Errno::EMFILE - no more socket descriptors are available

- Errno::ENOBUFS - no buffer space is available

- Errno::ENOTSOC - `socket` is not a socket

- Errno::EOPNOTSUPP - the referenced `socket` is not a type that supports the listen method

### See¶ ↑

- listen manual pages on unix-based systems

- listen function in Microsoft’s Winsock functions reference

recvfrom(maxlen) → [mesg, sender_addrinfo]
recvfrom(maxlen, flags) → [mesg, sender_addrinfo]
Source

    static VALUE
    sock_recvfrom(int argc, VALUE *argv, VALUE sock)
    {
        return rsock_s_recvfrom(sock, argc, argv, RECV_SOCKET);
    }

Receives up to maxlen bytes from `socket`. flags is zero or more of the `MSG_` options. The first element of the results, mesg, is the data received. The second element, sender_addrinfo, contains protocol-specific address information of the sender.

### Parameters¶ ↑

- `maxlen` - the maximum number of bytes to receive from the socket

- `flags` - zero or more of the `MSG_` options

### Example¶ ↑

    # In one file, start this first
    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.bind( sockaddr )
    socket.listen( 5 )
    client, client_addrinfo = socket.accept
    data = client.recvfrom( 20 )[0].chomp
    puts "I only received 20 bytes '#{data}'"
    sleep 1
    socket.close

    # In another file, start this second
    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.connect( sockaddr )
    socket.puts "Watch this get cut short!"
    socket.close

### Unix-based Exceptions¶ ↑

On unix-based based systems the following system exceptions may be raised if the call to recvfrom fails:

- Errno::EAGAIN - the `socket` file descriptor is marked as O_NONBLOCK and no data is waiting to be received; or `MSG_OOB` is set and no out-of-band data is available and either the `socket` file descriptor is marked as O_NONBLOCK or the `socket` does not support blocking to wait for out-of-band-data

- Errno::EWOULDBLOCK - see Errno::EAGAIN

- Errno::EBADF - the `socket` is not a valid file descriptor

- Errno::ECONNRESET - a connection was forcibly closed by a peer

- Errno::EFAULT - the socket’s internal buffer, address or address length cannot be accessed or written

- Errno::EINTR - a signal interrupted recvfrom before any data was available

- Errno::EINVAL - the `MSG_OOB` flag is set and no out-of-band data is available

- Errno::EIO - an i/o error occurred while reading from or writing to the filesystem

- Errno::ENOBUFS - insufficient resources were available in the system to perform the operation

- Errno::ENOMEM - insufficient memory was available to fulfill the request

- Errno::ENOSR - there were insufficient STREAMS resources available to complete the operation

- Errno::ENOTCONN - a receive is attempted on a connection-mode socket that is not connected

- Errno::ENOTSOCK - the `socket` does not refer to a socket

- Errno::EOPNOTSUPP - the specified flags are not supported for this socket type

- Errno::ETIMEDOUT - the connection timed out during connection establishment or due to a transmission timeout on an active connection

### Windows Exceptions¶ ↑

On Windows systems the following system exceptions may be raised if the call to recvfrom fails:

- Errno::ENETDOWN - the network is down

- Errno::EFAULT - the internal buffer and from parameters on `socket` are not part of the user address space, or the internal fromlen parameter is too small to accommodate the peer address

- Errno::EINTR - the (blocking) call was cancelled by an internal call to the WinSock function WSACancelBlockingCall

- Errno::EINPROGRESS - a blocking Windows Sockets 1.1 call is in progress or the service provider is still processing a callback function

- Errno::EINVAL - `socket` has not been bound with a call to bind, or an unknown flag was specified, or `MSG_OOB` was specified for a socket with `SO_OOBINLINE` enabled, or (for byte stream-style sockets only) the internal len parameter on `socket` was zero or negative

- Errno::EISCONN - `socket` is already connected. The call to recvfrom is not permitted with a connected socket on a socket that is connection oriented or connectionless.

- Errno::ENETRESET - the connection has been broken due to the keep-alive activity detecting a failure while the operation was in progress.

- Errno::EOPNOTSUPP - `MSG_OOB` was specified, but `socket` is not stream-style such as type `SOCK_STREAM`. OOB data is not supported in the communication domain associated with `socket`, or `socket` is unidirectional and supports only send operations

- Errno::ESHUTDOWN - `socket` has been shutdown. It is not possible to call recvfrom on a socket after shutdown has been invoked.

- Errno::EWOULDBLOCK - `socket` is marked as nonblocking and a call to recvfrom would block.

- Errno::EMSGSIZE - the message was too large to fit into the specified buffer and was truncated.

- Errno::ETIMEDOUT - the connection has been dropped, because of a network failure or because the system on the other end went down without notice

- Errno::ECONNRESET - the virtual circuit was reset by the remote side executing a hard or abortive close. The application should close the socket; it is no longer usable. On a UDP-datagram socket this error indicates a previous send operation resulted in an ICMP Port Unreachable message.

recvfrom_nonblock(maxlen[, flags[, outbuf[, opts]]]) → [mesg, sender_addrinfo]
Source

    # File ext/socket/lib/socket.rb, line 541
    def recvfrom_nonblock(len, flag = 0, str = nil, exception: true)
      __recvfrom_nonblock(len, flag, str, exception)
    end

Receives up to maxlen bytes from `socket` using recvfrom(2) after O_NONBLOCK is set for the underlying file descriptor. flags is zero or more of the `MSG_` options. The first element of the results, mesg, is the data received. The second element, sender_addrinfo, contains protocol-specific address information of the sender.

When recvfrom(2) returns 0, `Socket#recv_nonblock` returns nil. In most cases it means the connection was closed, but for UDP connections it may mean an empty packet was received, as the underlying API makes it impossible to distinguish these two cases.

### Parameters¶ ↑

- `maxlen` - the maximum number of bytes to receive from the socket

- `flags` - zero or more of the `MSG_` options

- `outbuf` - destination `String` buffer

- `opts` - keyword hash, supporting ‘exception: false`

### Example¶ ↑

    # In one file, start this first
    require 'socket'
    include Socket::Constants
    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
    sockaddr = Socket.sockaddr_in(2200, 'localhost')
    socket.bind(sockaddr)
    socket.listen(5)
    client, client_addrinfo = socket.accept
    begin # emulate blocking recvfrom
      pair = client.recvfrom_nonblock(20)
    rescue IO::WaitReadable
      IO.select([client])
      retry
    end
    data = pair[0].chomp
    puts "I only received 20 bytes '#{data}'"
    sleep 1
    socket.close

    # In another file, start this second
    require 'socket'
    include Socket::Constants
    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
    sockaddr = Socket.sockaddr_in(2200, 'localhost')
    socket.connect(sockaddr)
    socket.puts "Watch this get cut short!"
    socket.close

Refer to `Socket#recvfrom` for the exceptions that may be thrown if the call to recvfrom_nonblock fails.

`Socket#recvfrom_nonblock` may raise any error corresponding to recvfrom(2) failure, including Errno::EWOULDBLOCK.

If the exception is Errno::EWOULDBLOCK or Errno::EAGAIN, it is extended by `IO::WaitReadable`. So `IO::WaitReadable` can be used to rescue the exceptions for retrying recvfrom_nonblock.

By specifying a keyword argument exception to `false`, you can indicate that `recvfrom_nonblock` should not raise an `IO::WaitReadable` exception, but return the symbol `:wait_readable` instead.

### See¶ ↑

- `Socket#recvfrom`

sysaccept → [client_socket_fd, client_addrinfo]
Source

    static VALUE
    sock_sysaccept(VALUE server)
    {
        union_sockaddr buffer;
        socklen_t length = (socklen_t)sizeof(buffer);

        VALUE peer = rsock_s_accept(0, server, &buffer.addr, &length);

        return rb_assoc_new(peer, rsock_io_socket_addrinfo(peer, &buffer.addr, length));
    }

Accepts an incoming connection returning an array containing the (integer) file descriptor for the incoming connection, client_socket_fd, and an `Addrinfo`, client_addrinfo.

### Example¶ ↑

    # In one script, start this first
    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.bind( sockaddr )
    socket.listen( 5 )
    client_fd, client_addrinfo = socket.sysaccept
    client_socket = Socket.for_fd( client_fd )
    puts "The client said, '#{client_socket.readline.chomp}'"
    client_socket.puts "Hello from script one!"
    socket.close

    # In another script, start this second
    require 'socket'
    include Socket::Constants
    socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
    sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )
    socket.connect( sockaddr )
    socket.puts "Hello from script 2."
    puts "The server said, '#{socket.readline.chomp}'"
    socket.close

Refer to `Socket#accept` for the exceptions that may be thrown if the call to sysaccept fails.

### See¶ ↑

- `Socket#accept`