class Socket - Documentation for Ruby 3.5 (original) (raw)

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:

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

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

hostname: The identifier of a network interface:

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

loop do client = server.accept
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 puts line
end

s.close

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 ↑

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_ADDRESS_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

Source

def self.accept_loop(*sockets) 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.

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)

Socket.getaddrinfo("localhost", nil)

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.

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:

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

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:

This method obtains the host information for hostname.

p Socket.gethostbyname("hal")

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

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.

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

Example result on GNU/Linux:

pp Socket.getifaddrs

Example result on FreeBSD:

pp Socket.getifaddrs

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.

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"))
Socket.getnameinfo(["AF_INET", 80, "127.0.0.1"])
Socket.getnameinfo(["AF_INET", 80, "localhost", "127.0.0.1"])

If Addrinfo object is preferred, use Addrinfo#getnameinfo.

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")
Socket.getservbyname("shell")
Socket.getservbyname("syslog", "udp")

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)
Socket.getservbyport(514, "tcp") Socket.getservbyport(514, "udp")

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>, ...]

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) Socket.new(:INET, :DGRAM)
Socket.new(:UNIX, :STREAM) Socket.new(:UNIX, :DGRAM)

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

Socket.sockaddr_in(80, "::1")

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

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) 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) p s2.recv(10)

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

Socket.sockaddr_in(80, "::1")

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

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) 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) p s2.recv(10)

Source

def self.tcp(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, open_timeout: nil, fast_fallback: tcp_fast_fallback, &)

if open_timeout && (connect_timeout || resolv_timeout) raise ArgumentError, "Cannot specify open_timeout along with connect_timeout or resolv_timeout" end

sock = if fast_fallback && !(host && ip_address?(host)) tcp_with_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_timeout:) else tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_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.

:open_timeout

Specifies the timeout in seconds from the start of the method execution.
If this timeout is reached while there are still addresses that have not yet been attempted for connection, no further attempts will be made.

: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 }

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=.

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.

Source

def self.tcp_server_loop(host=nil, port, &b) 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.

Socket.tcp_server_loop(16807) {|sock, client_addrinfo| begin IO.copy_stream(sock, sock) ensure sock.close end }

Socket.tcp_server_loop(16807) {|sock, client_addrinfo| Thread.new { begin IO.copy_stream(sock, sock) ensure sock.close end } }

Source

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.

sockets = Socket.tcp_server_sockets(1296) p sockets

sockets.each {|s| p s.local_address }

sockets = Socket.tcp_server_sockets(0) sockets.each {|s| p s.local_address }

Socket.tcp_server_sockets(0) {|sockets| p sockets }

Source

def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, open_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 user_specified_open_timeout_at = open_timeout ? now + open_timeout : nil last_error = nil last_error_from_thread = false

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? 
        if resolution_store.any_addrinfos?
          
          next
        elsif connecting_sockets.any? || resolution_store.any_unresolved_family?
          
          
          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 
      end
    rescue SystemCallError => e
      socket&.close
      last_error = e

      if resolution_store.any_addrinfos?
        
        next
      elsif connecting_sockets.any? || resolution_store.any_unresolved_family?
        
        
        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),
     user_specified_open_timeout_at].compact.min
  elsif user_specified_open_timeout_at
    user_specified_open_timeout_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,
  
  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?
        
        
      elsif resolution_store.any_addrinfos? || resolution_store.any_unresolved_family?
        
        
        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_ERROR)
    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?
      
      
    elsif resolution_store.any_addrinfos? || resolution_store.any_unresolved_family?
      
      
      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)
        other = family_name == :ipv6 ? :ipv4 : :ipv6
        if !resolution_store.resolved?(other) || !resolution_store.resolved_successfully?(other)
          last_error = result
          last_error_from_thread = true
        end
      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

raise(Errno::ETIMEDOUT, 'user specified timeout') if expired?(now, user_specified_open_timeout_at)

if resolution_store.empty_addrinfos?
  if connecting_sockets.empty? && resolution_store.resolved_all_families?
    if last_error_from_thread
      raise last_error.class, last_error.message, cause: last_error
    else
      raise last_error
    end
  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

Source

def self.udp_server_loop(host=nil, port, &b) 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.

Socket.udp_server_loop(9261) {|msg, msg_src| msg_src.reply msg }

Source

def self.udp_server_loop_on(sockets, &b) 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.

Source

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| ... } } }

Source

def self.udp_server_sockets(host=nil, port) last_error = nil sockets = []

ipv6_recvpktinfo = nil if defined? Socket::AncillaryData if defined? Socket::IPV6_RECVPKTINFO ipv6_recvpktinfo = Socket::IPV6_RECVPKTINFO elsif defined? Socket::IPV6_PKTINFO 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.

Socket.udp_server_sockets(0) {|sockets| p sockets.first.local_address.ip_port
Socket.udp_server_loop_on(sockets) {|msg, msg_src| msg_src.reply msg } }

Source

def self.unix(path) 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.

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

Source

def self.unix_server_loop(path, &b) 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.

Socket.unix_server_loop("/tmp/sock") {|sock, client_addrinfo| begin IO.copy_stream(sock, sock) ensure sock.close end }

Source

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
p socket.local_address

Socket.unix_server_socket("/tmp/sock") {|s| p s
p s.local_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 p Socket.unpack_sockaddr_in(sockaddr)

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)

Private Class Methods

Source

def self.current_clock_time Process.clock_gettime(Process::CLOCK_MONOTONIC) end

Source

def self.expired?(started_at, ends_at) second_to_timeout(started_at, ends_at)&.zero? end

Source

def self.ip_address?(hostname) hostname.match?(IPV6_ADDRESS_FORMAT) || hostname.match?(/\A([0-9]{1,3}.){3}[0-9]{1,3}\z/) end

Source

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

Source

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

Source

def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_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

timeout = open_timeout ? open_timeout : resolv_timeout starts_at = current_clock_time

Addrinfo.foreach(host, port, nil, :STREAM, 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 timeout = open_timeout ? open_timeout - (current_clock_time - starts_at) : connect_timeout sock = local_addr ? ai.connect_from(local_addr, timeout:) : ai.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

Source

def unix_socket_abstract_name?(path) /linux/ =~ RUBY_PLATFORM && /\A(\0|\z)/ =~ path end

Public Instance Methods

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

Source

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 ↑

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

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 ↑

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 ↑

Example ↑

require 'socket'

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

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:

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:

Windows Exceptions ↑

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

See ↑

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 ↑

Example: ↑

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:

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:

Windows Exceptions ↑

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

See ↑

Source

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 ↑

Example: ↑

require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(80, 'www.google.com') begin socket.connect_nonblock(sockaddr) rescue IO::WaitWritable IO.select(nil, [socket]) begin socket.connect_nonblock(sockaddr) 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 ↑

Source

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.

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 ↑

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:

Windows Exceptions ↑

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

See ↑

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 ↑

Example ↑

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

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:

Windows Exceptions ↑

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

Source

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 ↑

Example ↑

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

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 ↑

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 ↑

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

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 ↑