rubyapi.org

Class

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:

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

  • 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

Interface to kernel crypto API

AppleTalk protocol

Asynchronous Transfer Mode

AX.25 protocol

Bluetooth low-level socket protocol

Controller Area Network automotive bus protocol

CCITT (now ITU-T) protocols

MIT CHAOS protocols

Computer Network Technology

Connection-oriented IP

Datakit protocol

DECnet protocol

DECnet protocol

DEC Direct Data Link Interface protocol

CCITT (ITU-T) E.164 recommendation

European Computer Manufacturers protocols

NSC Hyperchannel protocol

InfiniBand native addressing

ARPANET IMP protocol

IPv4 protocol

IPv6 protocol

IPX protocol

Integrated Services Digital Network

ISO Open Systems Interconnection protocols

KCM (kernel connection multiplexor) interface

Key management protocol, originally developed for usage with IPsec

Local Area Transport protocol

Link layer interface

Logical link control (IEEE 802.2 LLC) protocol

Host-internal protocols

Maximum address family for this platform

Multiprotocol Label Switching

Native ATM access

Network driver raw access

NetBIOS

Netgraph sockets

Kernel user interface device

XEROX NS protocols

ISO Open Systems Interconnection protocols

Direct link-layer access

Point-to-Point Protocol

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

PARC Universal Packet protocol

Reliable Datagram Sockets (RDS) protocol

Internal routing protocol

Simple Internet Protocol

IBM SNA protocol

Kernel event messages

TIPC, “cluster domain sockets” protocol

UNIX sockets

Unspecified protocol, any supported address family

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

XDP (express data path) interface

Accept only if any address is assigned

Allow all addresses

Fill in the canonical name

Default flags for getaddrinfo

Valid flag mask for getaddrinfo (not for application use)

Prevent host name resolution

Prevent service name resolution

Get address to use with bind()

Accept IPv4-mapped IPv6 addresses

Accept IPv4 mapped addresses if the kernel supports it

Address family for hostname not supported

Temporary failure in name resolution

Invalid flags

Invalid value for hints

Non-recoverable failure in name resolution

Address family not supported

Maximum error code from getaddrinfo

Memory allocation failure

No address associated with hostname

Hostname nor servname, or not known

Argument buffer overflow

Resolved protocol is unknown

Servname not supported for socket type

Socket type not supported

System error returned in errno

802.1Q VLAN device

receive all multicast packets

use alternate physical connection

auto media select active

bonding master or slave

device used as bridge port

broadcast address valid

flags not changeable

unconfigurable using ioctl(2)

turn on debugging

disable netpoll at run-time

disallow bridging this ether dev

driver signals dormant

tx hardware queue is full

resources allocated

interface is winding down

dialup device with changing addresses

ethernet bridging device

echo sent packets

ISATAP interface (RFC4214)

per link layer defined bit 0

per link layer defined bit 1

per link layer defined bit 2

hardware address change when it’s running

loopback net

driver signals L1 up

device used as macvlan port

master of a load balancer

bonding master, 802.3ad.

bonding master, balance-alb.

bonding master, ARP mon in use

user-requested monitor mode

supports multicast

no address resolution protocol

avoid use of trailers

transmission in progress

device used as Open vSwitch datapath port

point-to-point link

can set media type

user-requested promisc mode

receive all packets

interface is being renamed

routing entry installed

resources allocated

can’t hear own transmissions

slave of a load balancer

bonding slave not the curr. active

need ARPs for validation

interface manages own routes

static ARP

sending custom FCS

used as team port

sharing skbs on transmit

unicast filtering

interface is up

volatile flags

WAN HDLC device

dev_hard_start_xmit() is allowed to release skb->dst

Maximum interface name size

Maximum interface name size

Multicast group for all systems on this subset

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

The network broadcast address

The loopback address

The last local network multicast group

A bitmask for matching no valid IP address

The reserved multicast group

Maximum length of an IPv6 address string

Maximum length of an IPv4 address string

Add a multicast group membership

Add a multicast group membership

Block IPv4 multicast packets with a give source address

Default multicast loopback

Default multicast TTL

Don’t fragment packets

Drop a multicast group membership

Drop a multicast group membership

Allow binding to nonexistent IP addresses

Header is included with data

IPsec security policy

Maximum number multicast groups a socket can join

Minimum TTL allowed for received packets

Multicast source filtering

The Maximum Transmission Unit of the socket

Path MTU discovery

IP multicast interface

IP multicast loopback

IP multicast TTL

Force outgoing broadcast datagrams to have the undirected broadcast address

IP options to be included in packets

Retrieve security context with datagram

Receive packet information with datagrams

Receive packet options with datagrams

Always send DF frames

Never send DF frames

Use per-route hints

Set the port range for sockets with unspecified port numbers

Default minimum address for bind or connect

Default maximum address for bind or connect

IP6 auth header

IP6 destination option

Exterior Gateway Protocol

ISO cnlp

IP6 Encapsulated Security Payload

IP6 fragmentation header

Gateway to Gateway Protocol

“hello” routing protocol

IP6 hop-by-hop options

Control message protocol

ICMP6

XNS IDP

Group Management Protocol

Dummy protocol for IP

IP6 header

Maximum IPPROTO constant

Sun net disk protocol

IP6 no next header

PARC Universal Packet protocol

Raw IP packet

IP6 routing header

TCP

ISO transport protocol class 4

UDP

Xpress Transport Protocol

Receive IP destination address with datagram

Enable extended reliable error message passing

Receive interface information with datagrams

Receive all IP options with datagram

Receive all IP options for response

Receive link-layer address with datagrams

Receive TOS with incoming packets

Receive IP TTL with datagrams

IP options to be included in datagrams

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

Source address for outgoing UDP datagrams

IP type-of-service

Transparent proxy

IP time-to-live

Unblock IPv4 multicast packets with a give source address

Checksum offset for raw sockets

Don’t fragment packets

Destination option

Hop limit

Hop-by-hop option

Join a group membership

Leave a group membership

Path MTU discovery

IP6 multicast hops

IP6 multicast interface

IP6 multicast loopback

Next hop address

Retrieve current path MTU

Receive packet information with datagram

Receive all IP6 options for response

Enable extended reliable error message passing

Receive hop limit with datagram

Receive hop-by-hop options

Receive current path MTU with datagram

Receive destination IP address and incoming interface

Receive routing header

Receive traffic class

Allows removal of sticky routing headers

Allows removal of sticky destination options header

Routing header type 0

Specify the traffic class

IP6 unicast hops

Use the minimum MTU size

Only bind IPv6 with a wildcard bind

Connect blocks until accepted

Pass credentials to receiver

Retrieve peer credentials

Block multicast packets from this source

Exclusive multicast source filter

Inclusive multicast source filter

Join a multicast group

Join a multicast source group

Leave a multicast group

Leave a multicast source group

Multicast source filtering

Unblock multicast packets from this source

End of record

Confirm path validity

Control data lost before delivery

Send without using the routing tables

This message should be non-blocking

Data completes connection

Data completes record

Fetch message from error queue

Reduce step of the handshake process

Start of a hold sequence. Dumps to so_temp

Data ready to be read

Hold fragment in so_temp

Sender will send more

Do not generate SIGPIPE

Process out-of-band data

Peek at incoming message

Wait for full request

Data remains in the current packet

Send the packet in so_temp

Data discarded before delivery

Wait for full request or error

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

Maximum length of a hostname

Maximum length of a service name

A name is required

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

Return a numeric address

Return the service name as a digit string

Interface to kernel crypto API

AppleTalk protocol

Asynchronous Transfer Mode

AX.25 protocol

Bluetooth low-level socket protocol

Controller Area Network automotive bus protocol

CCITT (now ITU-T) protocols

MIT CHAOS protocols

Computer Network Technology

Connection-oriented IP

Datakit protocol

DECnet protocol

DECnet protocol

DEC Direct Data Link Interface protocol

European Computer Manufacturers protocols

NSC Hyperchannel protocol

InfiniBand native addressing

ARPANET IMP protocol

IPv4 protocol

IPv6 protocol

IPX protocol

Integrated Services Digital Network

ISO Open Systems Interconnection protocols

KCM (kernel connection multiplexor) interface

Key management protocol, originally developed for usage with IPsec

Local Area Transport protocol

Link layer interface

Logical link control (IEEE 802.2 LLC) protocol

Host-internal protocols

Maximum address family for this platform

Multiprotocol Label Switching

Native ATM access

Network driver raw access

NetBIOS

Netgraph sockets

Kernel user interface device

XEROX NS protocols

ISO Open Systems Interconnection protocols

Direct link-layer access

Help Identify PIP packets

Point-to-Point Protocol

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

PARC Universal Packet protocol

Reliable Datagram Sockets (RDS) protocol

Internal routing protocol

Help Identify RTIP packets

Simple Internet Protocol

IBM SNA protocol

Kernel event messages

TIPC, “cluster domain sockets” protocol

UNIX sockets

Unspecified protocol, any supported address family

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

XDP (express data path) interface

eXpress Transfer Protocol

Timestamp (bintime)

The sender’s credentials

Process credentials

Access rights

Timestamp (timeval)

Timestamp (timespec list) (Linux 2.6.30)

Timespec (timespec)

User credentials

Wifi status (Linux 3.3)

Shut down the reading side of the socket

Shut down the both sides of the socket

Shut down the writing side of the socket

Socket has had listen() called on it

There is an accept filter

Bypass zone boundaries

Attach an accept filter

Only send packets from the given interface

Receive timestamp with datagrams (bintime)

Query supported BPF extensions (Linux 3.14)

Permit sending of broadcast messages

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

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

A datagram socket provides connectionless, unreliable messaging

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

Device-level packet access

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

A reliable datagram socket provides reliable delivery of messages

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

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

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

Debug info recording

Detach an accept filter

Domain given for socket() (Linux 2.6.32)

Use interface addresses

Retain unread data

Get and clear the error status

Receive the cpu attached to the socket (Linux 3.19)

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

Keep connections alive

AppleTalk socket options

AX.25 socket options

Linger on close if data is present

IP socket options

IPX socket options

Lock the filter attached to a socket (Linux 3.9)

Socket-level options

TCP socket options

UDP socket options

Mandatory Access Control exemption for unlabeled peers

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

Maximum connection requests that may be queued for a socket

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

Install socket-level Network Kernel Extension

Disable checksums

Set netns of a socket (Linux 3.4)

Don’t SIGPIPE on EPIPE

Get first packet byte count

Leave received out-of-band data in-line

Toggle security context passing (Linux 2.6.18)

Set the peek offset (Linux 3.4)

The credentials of the foreign process connected to this socket

Name of the connecting user

Obtain the security credentials (Linux 2.6.2)

Background socket priority

Interactive socket priority

Normal socket priority

The protocol-defined priority for all packets on this socket

Protocol given for socket() (Linux 2.6.32)

Receive buffer size

Receive buffer size without rmem_max limit (Linux 2.6.14)

Receive low-water mark

Receive timeout

Receive user credentials with datagram

Allow local address reuse

Allow local address and port reuse

Set the routing table for this socket (OpenBSD)

Toggle cmsg for number of packets dropped (Linux 2.6.33)

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

Set the associated routing table for the socket (FreeBSD)

Send buffer size

Send buffer size without wmem_max limit (Linux 2.6.14)

Send low-water mark

Send timeout

Receive timestamp with datagrams (timeval)

Time stamping of incoming and outgoing packets (Linux 2.6.30)

Receive nanosecond timestamp with datagrams (timespec)

Get the socket type

Bypass hardware when possible

Setting an identifier for ipfw purpose mainly

Give a hint when more data is ready

OOB data is wanted in MSG_FLAG on receive

Toggle cmsg for wifi status (Linux 3.3)

TCP congestion control algorithm (Linux 2.6.13, glibc 2.6)

Retrieve information about this socket (macOS)

TCP Cookie Transactions (Linux 2.6.33, glibc 2.18)

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

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

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

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

Idle time before keepalive probes are sent (macOS)

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

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

Time between keepalive probes (Linux 2.4, glibc 2.2)

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

Set maximum segment size

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

Don’t delay sending to coalesce packets

Don’t use TCP options

Don’t push the last block of write

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

Enable quickack mode (Linux 2.4.4, glibc 2.3)

Repair mode (Linux 3.5, glibc 2.18)

Options for repair mode (Linux 3.5, glibc 2.18)

Queue for repair mode (Linux 3.5, glibc 2.18)

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

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

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

TCP timestamp (Linux 3.9, glibc 2.18)

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

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

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

Class Methods

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.

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.

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

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

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.

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

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

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

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

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

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)

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

Packs path as an AF_UNIX sockaddr string.

Socket.sockaddr_un("/tmp/sock")

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)

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

Packs path as an AF_UNIX sockaddr string.

Socket.sockaddr_un("/tmp/sock")

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)

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.
If this option is specified together with other timeout options, an ArgumentError will be raised.

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

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.

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

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
}

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
}

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.

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

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

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
}

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
}

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
}

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)

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)

Instance Methods

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

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

Binds to the given local address.

Parameter

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

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:

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

See

  • bind manual pages on unix-based systems

  • bind function in Microsoft’s Winsock functions reference

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:

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:

See

  • connect manual pages on unix-based systems

  • connect function in Microsoft’s Winsock functions reference

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:

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

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

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

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:

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

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

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

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

Read the original on rubyapi.org ↗