Class: Socket
- Inherits:
-
BasicSocket
- Object
- IO
- BasicSocket
- Socket
- Defined in:
- socket.c,
lib/socket.rb
Overview
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 bidirectionnal communication channel. Sockets can communicate within a process, between processes on the same machine or between different machines. There are many types of socket: TCPSocket, UDPSocket or UNIXSocket for example.
Sockets have their own vocabulary:
- domain
-
The family of protocols: Socket::PF_INET, Socket::PF_INET6, Socket::PF_UNIX, etc.
- type
-
The type of communications between the two endpoints, typically Socket::SOCK_STREAM or Socket::SOCK_DGRAM.
- protocol
-
Typically zero. This may be used to identify a variant of a protocol.
- hostname
-
The identifier of a network interface:
* a string (hostname, IPv4 or IPv6 adress or <tt><broadcast></tt> 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
Some classes such as TCPSocket, UDPSocket or UNIXSocket ease use of sockets of these types compared to C programming.
# Creating a TCP socket in a C-like manner
s = Socket.new Socket::INET, Socket::SOCK_STREAM
s.connect Socket.pack_sockaddr_in(80, 'example.com')
# Using TCPSocket
s = TCPSocket.new 'example.com', 80
A simple server would look like:
require 'socket'
server = TCPServer.new 2000 # Server bound to port 2000
loop do
client = server.accept # Wait for a client to connect
client.puts "Hello !"
client.puts "Time is #{Time.now}"
client.close
end
A simple client may look like:
require 'socket'
s = TCPSocket.new 'localhost', 2000
while line = s.gets # Read lines from socket
puts line # and print them
end
s.close # close socket when done
Exception Handling
Ruby's Socket implementation raises exceptions based on the error generated by the system dependent implementation. This is why the methods are documented in a way that isolate Unix-based system exceptions from Windows based exceptions. If more information on particular exception is needed please refer to the Unix manual pages or the Windows WinSock reference.
Convenient methods
Although the general way to create socket is Socket.new, there are several methods for 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.
Defined Under Namespace
Modules: Constants Classes: AncillaryData, UDPSource
Constant Summary collapse
- SOCK_STREAM =
A stream socket provides a sequenced, reliable two-way connection for a byte stream
INT2NUM(SOCK_STREAM)
- SOCK_DGRAM =
A datagram socket provides connectionless, unreliable messaging
INT2NUM(SOCK_DGRAM)
- SOCK_RAW =
A raw socket provides low-level access for direct access or implementing network protocols
INT2NUM(SOCK_RAW)
- SOCK_RDM =
A reliable datagram socket provides reliable delivery of messages
INT2NUM(SOCK_RDM)
- SOCK_SEQPACKET =
A sequential packet socket provides sequenced, reliable two-way connection for datagrams
INT2NUM(SOCK_SEQPACKET)
- SOCK_PACKET =
Device-level packet access
INT2NUM(SOCK_PACKET)
- AF_UNSPEC =
Unspecified protocol, any supported address family
INT2NUM(AF_UNSPEC)
- PF_UNSPEC =
Unspecified protocol, any supported address family
INT2NUM(PF_UNSPEC)
- AF_INET =
IPv4 protocol
INT2NUM(AF_INET)
- PF_INET =
IPv4 protocol
INT2NUM(PF_INET)
- AF_INET6 =
IPv6 protocol
INT2NUM(AF_INET6)
- PF_INET6 =
IPv6 protocol
INT2NUM(PF_INET6)
- AF_UNIX =
UNIX sockets
INT2NUM(AF_UNIX)
- PF_UNIX =
UNIX sockets
INT2NUM(PF_UNIX)
- AF_AX25 =
AX.25 protocol
INT2NUM(AF_AX25)
- PF_AX25 =
AX.25 protocol
INT2NUM(PF_AX25)
- AF_IPX =
IPX protocol
INT2NUM(AF_IPX)
- PF_IPX =
IPX protocol
INT2NUM(PF_IPX)
- AF_APPLETALK =
AppleTalk protocol
INT2NUM(AF_APPLETALK)
- PF_APPLETALK =
AppleTalk protocol
INT2NUM(PF_APPLETALK)
- AF_LOCAL =
Host-internal protocols
INT2NUM(AF_LOCAL)
- PF_LOCAL =
Host-internal protocols
INT2NUM(PF_LOCAL)
- AF_IMPLINK =
ARPANET IMP protocol
INT2NUM(AF_IMPLINK)
- PF_IMPLINK =
ARPANET IMP protocol
INT2NUM(PF_IMPLINK)
- AF_PUP =
PARC Universal Packet protocol
INT2NUM(AF_PUP)
- PF_PUP =
PARC Universal Packet protocol
INT2NUM(PF_PUP)
- AF_CHAOS =
MIT CHAOS protocols
INT2NUM(AF_CHAOS)
- PF_CHAOS =
MIT CHAOS protocols
INT2NUM(PF_CHAOS)
- AF_NS =
XEROX NS protocols
INT2NUM(AF_NS)
- PF_NS =
XEROX NS protocols
INT2NUM(PF_NS)
- AF_ISO =
ISO Open Systems Interconnection protocols
INT2NUM(AF_ISO)
- PF_ISO =
ISO Open Systems Interconnection protocols
INT2NUM(PF_ISO)
- AF_OSI =
ISO Open Systems Interconnection protocols
INT2NUM(AF_OSI)
- PF_OSI =
ISO Open Systems Interconnection protocols
INT2NUM(PF_OSI)
- AF_ECMA =
European Computer Manufacturers protocols
INT2NUM(AF_ECMA)
- PF_ECMA =
European Computer Manufacturers protocols
INT2NUM(PF_ECMA)
- AF_DATAKIT =
Datakit protocol
INT2NUM(AF_DATAKIT)
- PF_DATAKIT =
Datakit protocol
INT2NUM(PF_DATAKIT)
- AF_CCITT =
CCITT (now ITU-T) protocols
INT2NUM(AF_CCITT)
- PF_CCITT =
CCITT (now ITU-T) protocols
INT2NUM(PF_CCITT)
- AF_SNA =
IBM SNA protocol
INT2NUM(AF_SNA)
- PF_SNA =
IBM SNA protocol
INT2NUM(PF_SNA)
- AF_DEC =
DECnet protocol
INT2NUM(AF_DEC)
- PF_DEC =
DECnet protocol
INT2NUM(PF_DEC)
- AF_DLI =
DEC Direct Data Link Interface protocol
INT2NUM(AF_DLI)
- PF_DLI =
DEC Direct Data Link Interface protocol
INT2NUM(PF_DLI)
- AF_LAT =
Local Area Transport protocol
INT2NUM(AF_LAT)
- PF_LAT =
Local Area Transport protocol
INT2NUM(PF_LAT)
- AF_HYLINK =
NSC Hyperchannel protocol
INT2NUM(AF_HYLINK)
- PF_HYLINK =
NSC Hyperchannel protocol
INT2NUM(PF_HYLINK)
- AF_ROUTE =
Internal routing protocol
INT2NUM(AF_ROUTE)
- PF_ROUTE =
Internal routing protocol
INT2NUM(PF_ROUTE)
- AF_LINK =
Link layer interface
INT2NUM(AF_LINK)
- PF_LINK =
Link layer interface
INT2NUM(PF_LINK)
- AF_COIP =
Connection-oriented IP
INT2NUM(AF_COIP)
- PF_COIP =
Connection-oriented IP
INT2NUM(PF_COIP)
- AF_CNT =
Computer Network Technology
INT2NUM(AF_CNT)
- PF_CNT =
Computer Network Technology
INT2NUM(PF_CNT)
- AF_SIP =
Simple Internet Protocol
INT2NUM(AF_SIP)
- PF_SIP =
Simple Internet Protocol
INT2NUM(PF_SIP)
- AF_NDRV =
Network driver raw access
INT2NUM(AF_NDRV)
- PF_NDRV =
Network driver raw access
INT2NUM(PF_NDRV)
- AF_ISDN =
Integrated Services Digital Network
INT2NUM(AF_ISDN)
- PF_ISDN =
Integrated Services Digital Network
INT2NUM(PF_ISDN)
- AF_NATM =
Native ATM access
INT2NUM(AF_NATM)
- PF_NATM =
Native ATM access
INT2NUM(PF_NATM)
- AF_SYSTEM =
INT2NUM(AF_SYSTEM)
- PF_SYSTEM =
INT2NUM(PF_SYSTEM)
- AF_NETBIOS =
NetBIOS
INT2NUM(AF_NETBIOS)
- PF_NETBIOS =
NetBIOS
INT2NUM(PF_NETBIOS)
- AF_PPP =
Point-to-Point Protocol
INT2NUM(AF_PPP)
- PF_PPP =
Point-to-Point Protocol
INT2NUM(PF_PPP)
- AF_ATM =
Asynchronous Transfer Mode
INT2NUM(AF_ATM)
- PF_ATM =
Asynchronous Transfer Mode
INT2NUM(PF_ATM)
- AF_NETGRAPH =
Netgraph sockets
INT2NUM(AF_NETGRAPH)
- PF_NETGRAPH =
Netgraph sockets
INT2NUM(PF_NETGRAPH)
- AF_MAX =
Maximum address family for this platform
INT2NUM(AF_MAX)
- PF_MAX =
Maximum address family for this platform
INT2NUM(PF_MAX)
- AF_PACKET =
Direct link-layer access
INT2NUM(AF_PACKET)
- PF_PACKET =
Direct link-layer access
INT2NUM(PF_PACKET)
- AF_E164 =
CCITT (ITU-T) E.164 recommendation
INT2NUM(AF_E164)
- PF_XTP =
eXpress Transfer Protocol
INT2NUM(PF_XTP)
- PF_RTIP =
INT2NUM(PF_RTIP)
- PF_PIP =
INT2NUM(PF_PIP)
- PF_KEY =
INT2NUM(PF_KEY)
- MSG_OOB =
Process out-of-band data
INT2NUM(MSG_OOB)
- MSG_PEEK =
Peek at incoming message
INT2NUM(MSG_PEEK)
- MSG_DONTROUTE =
Send without using the routing tables
INT2NUM(MSG_DONTROUTE)
- MSG_EOR =
Data completes record
INT2NUM(MSG_EOR)
- MSG_TRUNC =
Data discarded before delivery
INT2NUM(MSG_TRUNC)
- MSG_CTRUNC =
Control data lost before delivery
INT2NUM(MSG_CTRUNC)
- MSG_WAITALL =
Wait for full request or error
INT2NUM(MSG_WAITALL)
- MSG_DONTWAIT =
This message should be non-blocking
INT2NUM(MSG_DONTWAIT)
- MSG_EOF =
Data completes connection
INT2NUM(MSG_EOF)
- MSG_FLUSH =
Start of a hold sequence. Dumps to so_temp
INT2NUM(MSG_FLUSH)
- MSG_HOLD =
Hold fragment in so_temp
INT2NUM(MSG_HOLD)
- MSG_SEND =
Send the packet in so_temp
INT2NUM(MSG_SEND)
- MSG_HAVEMORE =
Data ready to be read
INT2NUM(MSG_HAVEMORE)
- MSG_RCVMORE =
Data remains in the current packet
INT2NUM(MSG_RCVMORE)
- MSG_COMPAT =
End of record
INT2NUM(MSG_COMPAT)
- MSG_PROXY =
Wait for full request
INT2NUM(MSG_PROXY)
- MSG_FIN =
INT2NUM(MSG_FIN)
- MSG_SYN =
INT2NUM(MSG_SYN)
- MSG_CONFIRM =
Confirm path validity
INT2NUM(MSG_CONFIRM)
- MSG_RST =
INT2NUM(MSG_RST)
- MSG_ERRQUEUE =
Fetch message from error queue
INT2NUM(MSG_ERRQUEUE)
- MSG_NOSIGNAL =
Do not generate SIGPIPE
INT2NUM(MSG_NOSIGNAL)
- MSG_MORE =
Sender will send more
INT2NUM(MSG_MORE)
- SOL_SOCKET =
Socket-level options
INT2NUM(SOL_SOCKET)
- SOL_IP =
IP socket options
INT2NUM(SOL_IP)
- SOL_IPX =
IPX socket options
INT2NUM(SOL_IPX)
- SOL_AX25 =
AX.25 socket options
INT2NUM(SOL_AX25)
- SOL_ATALK =
AppleTalk socket options
INT2NUM(SOL_ATALK)
- SOL_TCP =
TCP socket options
INT2NUM(SOL_TCP)
- SOL_UDP =
UDP socket options
INT2NUM(SOL_UDP)
- IPPROTO_IP =
Dummy protocol for IP
INT2NUM(IPPROTO_IP)
- IPPROTO_ICMP =
Control message protocol
INT2NUM(IPPROTO_ICMP)
- IPPROTO_IGMP =
Group Management Protocol
INT2NUM(IPPROTO_IGMP)
- IPPROTO_GGP =
Gateway to Gateway Protocol
INT2NUM(IPPROTO_GGP)
- IPPROTO_TCP =
TCP
INT2NUM(IPPROTO_TCP)
- IPPROTO_EGP =
Exterior Gateway Protocol
INT2NUM(IPPROTO_EGP)
- IPPROTO_PUP =
PARC Universal Packet protocol
INT2NUM(IPPROTO_PUP)
- IPPROTO_UDP =
UDP
INT2NUM(IPPROTO_UDP)
- IPPROTO_IDP =
XNS IDP
INT2NUM(IPPROTO_IDP)
- IPPROTO_HELLO =
"hello" routing protocol
INT2NUM(IPPROTO_HELLO)
- IPPROTO_ND =
Sun net disk protocol
INT2NUM(IPPROTO_ND)
- IPPROTO_TP =
ISO transport protocol class 4
INT2NUM(IPPROTO_TP)
- IPPROTO_XTP =
Xpress Transport Protocol
INT2NUM(IPPROTO_XTP)
- IPPROTO_EON =
ISO cnlp
INT2NUM(IPPROTO_EON)
- IPPROTO_BIP =
INT2NUM(IPPROTO_BIP)
- IPPROTO_AH =
IP6 auth header
INT2NUM(IPPROTO_AH)
- IPPROTO_DSTOPTS =
IP6 destination option
INT2NUM(IPPROTO_DSTOPTS)
- IPPROTO_ESP =
IP6 Encapsulated Security Payload
INT2NUM(IPPROTO_ESP)
- IPPROTO_FRAGMENT =
IP6 fragmentation header
INT2NUM(IPPROTO_FRAGMENT)
- IPPROTO_HOPOPTS =
IP6 hop-by-hop options
INT2NUM(IPPROTO_HOPOPTS)
- IPPROTO_ICMPV6 =
ICMP6
INT2NUM(IPPROTO_ICMPV6)
- IPPROTO_IPV6 =
IP6 header
INT2NUM(IPPROTO_IPV6)
- IPPROTO_NONE =
IP6 no next header
INT2NUM(IPPROTO_NONE)
- IPPROTO_ROUTING =
IP6 routing header
INT2NUM(IPPROTO_ROUTING)
- IPPROTO_RAW =
Raw IP packet
INT2NUM(IPPROTO_RAW)
- IPPROTO_MAX =
Maximum IPPROTO constant
INT2NUM(IPPROTO_MAX)
- IPPORT_RESERVED =
Default minimum address for bind or connect
INT2NUM(IPPORT_RESERVED)
- IPPORT_USERRESERVED =
Default maximum address for bind or connect
INT2NUM(IPPORT_USERRESERVED)
- INADDR_ANY =
A socket bound to INADDR_ANY receives packets from all interfaces and sends from the default IP address
UINT2NUM(INADDR_ANY)
- INADDR_BROADCAST =
The network broadcast address
UINT2NUM(INADDR_BROADCAST)
- INADDR_LOOPBACK =
The loopback address
UINT2NUM(INADDR_LOOPBACK)
- INADDR_UNSPEC_GROUP =
The reserved multicast group
UINT2NUM(INADDR_UNSPEC_GROUP)
- INADDR_ALLHOSTS_GROUP =
Multicast group for all systems on this subset
UINT2NUM(INADDR_ALLHOSTS_GROUP)
- INADDR_MAX_LOCAL_GROUP =
The last local network multicast group
UINT2NUM(INADDR_MAX_LOCAL_GROUP)
- INADDR_NONE =
A bitmask for matching no valid IP address
UINT2NUM(INADDR_NONE)
- IP_OPTIONS =
IP options to be included in packets
INT2NUM(IP_OPTIONS)
- IP_HDRINCL =
Header is included with data
INT2NUM(IP_HDRINCL)
- IP_TOS =
IP type-of-service
INT2NUM(IP_TOS)
- IP_TTL =
IP time-to-live
INT2NUM(IP_TTL)
- IP_RECVOPTS =
Receive all IP options with datagram
INT2NUM(IP_RECVOPTS)
- IP_RECVRETOPTS =
Receive all IP options for response
INT2NUM(IP_RECVRETOPTS)
- IP_RECVDSTADDR =
Receive IP destination address with datagram
INT2NUM(IP_RECVDSTADDR)
- IP_RETOPTS =
IP options to be included in datagrams
INT2NUM(IP_RETOPTS)
- IP_MINTTL =
Minimum TTL allowed for received packets
INT2NUM(IP_MINTTL)
- IP_DONTFRAG =
Don't fragment packets
INT2NUM(IP_DONTFRAG)
- IP_SENDSRCADDR =
Source address for outgoing UDP datagrams
INT2NUM(IP_SENDSRCADDR)
- IP_ONESBCAST =
Force outgoing broadcast datagrams to have the undirected broadcast address
INT2NUM(IP_ONESBCAST)
- IP_RECVTTL =
Receive IP TTL with datagrams
INT2NUM(IP_RECVTTL)
- IP_RECVIF =
Receive interface information with datagrams
INT2NUM(IP_RECVIF)
- IP_RECVSLLA =
Receive link-layer address with datagrams
INT2NUM(IP_RECVSLLA)
- IP_PORTRANGE =
Set the port range for sockets with unspecified port numbers
INT2NUM(IP_PORTRANGE)
- IP_MULTICAST_IF =
IP multicast interface
INT2NUM(IP_MULTICAST_IF)
- IP_MULTICAST_TTL =
IP multicast TTL
INT2NUM(IP_MULTICAST_TTL)
- IP_MULTICAST_LOOP =
IP multicast loopback
INT2NUM(IP_MULTICAST_LOOP)
- IP_ADD_MEMBERSHIP =
Add a multicast group membership
INT2NUM(IP_ADD_MEMBERSHIP)
- IP_DROP_MEMBERSHIP =
Drop a multicast group membership
INT2NUM(IP_DROP_MEMBERSHIP)
- IP_DEFAULT_MULTICAST_TTL =
Default multicast TTL
INT2NUM(IP_DEFAULT_MULTICAST_TTL)
- IP_DEFAULT_MULTICAST_LOOP =
Default multicast loopback
INT2NUM(IP_DEFAULT_MULTICAST_LOOP)
- IP_MAX_MEMBERSHIPS =
Maximum number multicast groups a socket can join
INT2NUM(IP_MAX_MEMBERSHIPS)
- IP_ROUTER_ALERT =
Notify transit routers to more closely examine the contents of an IP packet
INT2NUM(IP_ROUTER_ALERT)
- IP_PKTINFO =
Receive packet information with datagrams
INT2NUM(IP_PKTINFO)
- IP_PKTOPTIONS =
Receive packet options with datagrams
INT2NUM(IP_PKTOPTIONS)
- IP_MTU_DISCOVER =
Path MTU discovery
INT2NUM(IP_MTU_DISCOVER)
- IP_RECVERR =
Enable extended reliable error message passing
INT2NUM(IP_RECVERR)
- IP_RECVTOS =
Receive TOS with incoming packets
INT2NUM(IP_RECVTOS)
- IP_MTU =
The Maximum Transmission Unit of the socket
INT2NUM(IP_MTU)
- IP_FREEBIND =
Allow binding to nonexistent IP addresses
INT2NUM(IP_FREEBIND)
- IP_IPSEC_POLICY =
IPsec security policy
INT2NUM(IP_IPSEC_POLICY)
- IP_XFRM_POLICY =
INT2NUM(IP_XFRM_POLICY)
- IP_PASSSEC =
Retrieve security context with datagram
INT2NUM(IP_PASSSEC)
- IP_PMTUDISC_DONT =
Never send DF frames
INT2NUM(IP_PMTUDISC_DONT)
- IP_PMTUDISC_WANT =
Use per-route hints
INT2NUM(IP_PMTUDISC_WANT)
- IP_PMTUDISC_DO =
Always send DF frames
INT2NUM(IP_PMTUDISC_DO)
- IP_UNBLOCK_SOURCE =
Unblock IPv4 multicast packets with a give source address
INT2NUM(IP_UNBLOCK_SOURCE)
- IP_BLOCK_SOURCE =
Block IPv4 multicast packets with a give source address
INT2NUM(IP_BLOCK_SOURCE)
- IP_ADD_SOURCE_MEMBERSHIP =
Add a multicast group membership
INT2NUM(IP_ADD_SOURCE_MEMBERSHIP)
- IP_DROP_SOURCE_MEMBERSHIP =
Drop a multicast group membership
INT2NUM(IP_DROP_SOURCE_MEMBERSHIP)
- IP_MSFILTER =
Multicast source filtering
INT2NUM(IP_MSFILTER)
- MCAST_JOIN_GROUP =
Join a multicast group
INT2NUM(MCAST_JOIN_GROUP)
- MCAST_BLOCK_SOURCE =
Block multicast packets from this source
INT2NUM(MCAST_BLOCK_SOURCE)
- MCAST_UNBLOCK_SOURCE =
Unblock multicast packets from this source
INT2NUM(MCAST_UNBLOCK_SOURCE)
- MCAST_LEAVE_GROUP =
Leave a multicast group
INT2NUM(MCAST_LEAVE_GROUP)
- MCAST_JOIN_SOURCE_GROUP =
Join a multicast source group
INT2NUM(MCAST_JOIN_SOURCE_GROUP)
- MCAST_LEAVE_SOURCE_GROUP =
Leave a multicast source group
INT2NUM(MCAST_LEAVE_SOURCE_GROUP)
- MCAST_MSFILTER =
Multicast source filtering
INT2NUM(MCAST_MSFILTER)
- MCAST_EXCLUDE =
Exclusive multicast source filter
INT2NUM(MCAST_EXCLUDE)
- MCAST_INCLUDE =
Inclusive multicast source filter
INT2NUM(MCAST_INCLUDE)
- SO_DEBUG =
Debug info recording
INT2NUM(SO_DEBUG)
- SO_REUSEADDR =
Allow local address reuse
INT2NUM(SO_REUSEADDR)
- SO_REUSEPORT =
Allow local address and port reuse
INT2NUM(SO_REUSEPORT)
- SO_TYPE =
Get the socket type
INT2NUM(SO_TYPE)
- SO_ERROR =
Get and clear the error status
INT2NUM(SO_ERROR)
- SO_DONTROUTE =
Use interface addresses
INT2NUM(SO_DONTROUTE)
- SO_BROADCAST =
Permit sending of broadcast messages
INT2NUM(SO_BROADCAST)
- SO_SNDBUF =
Send buffer size
INT2NUM(SO_SNDBUF)
- SO_RCVBUF =
Receive buffer size
INT2NUM(SO_RCVBUF)
- SO_KEEPALIVE =
Keep connections alive
INT2NUM(SO_KEEPALIVE)
- SO_OOBINLINE =
Leave received out-of-band data in-line
INT2NUM(SO_OOBINLINE)
- SO_NO_CHECK =
Disable checksums
INT2NUM(SO_NO_CHECK)
- SO_PRIORITY =
The protocol-defined priority for all packets on this socket
INT2NUM(SO_PRIORITY)
- SO_LINGER =
Linger on close if data is present
INT2NUM(SO_LINGER)
- SO_PASSCRED =
Receive SCM_CREDENTIALS messages
INT2NUM(SO_PASSCRED)
- SO_PEERCRED =
The credentials of the foreign process connected to this socket
INT2NUM(SO_PEERCRED)
- SO_RCVLOWAT =
Receive low-water mark
INT2NUM(SO_RCVLOWAT)
- SO_SNDLOWAT =
Send low-water mark
INT2NUM(SO_SNDLOWAT)
- SO_RCVTIMEO =
Receive timeout
INT2NUM(SO_RCVTIMEO)
- SO_SNDTIMEO =
Send timeout
INT2NUM(SO_SNDTIMEO)
- SO_ACCEPTCONN =
Socket has had listen() called on it
INT2NUM(SO_ACCEPTCONN)
- SO_USELOOPBACK =
Bypass hardware when possible
INT2NUM(SO_USELOOPBACK)
- SO_ACCEPTFILTER =
There is an accept filter
INT2NUM(SO_ACCEPTFILTER)
- SO_DONTTRUNC =
Retain unread data
INT2NUM(SO_DONTTRUNC)
- SO_WANTMORE =
Give a hint when more data is ready
INT2NUM(SO_WANTMORE)
- SO_WANTOOBFLAG =
OOB data is wanted in MSG_FLAG on receive
INT2NUM(SO_WANTOOBFLAG)
- SO_NREAD =
Get first packet byte count
INT2NUM(SO_NREAD)
- SO_NKE =
Install socket-level Network Kernel Extension
INT2NUM(SO_NKE)
- SO_NOSIGPIPE =
Don't SIGPIPE on EPIPE
INT2NUM(SO_NOSIGPIPE)
- SO_SECURITY_AUTHENTICATION =
INT2NUM(SO_SECURITY_AUTHENTICATION)
- SO_SECURITY_ENCRYPTION_TRANSPORT =
INT2NUM(SO_SECURITY_ENCRYPTION_TRANSPORT)
- SO_SECURITY_ENCRYPTION_NETWORK =
INT2NUM(SO_SECURITY_ENCRYPTION_NETWORK)
- SO_BINDTODEVICE =
Only send packets from the given interface
INT2NUM(SO_BINDTODEVICE)
- SO_ATTACH_FILTER =
Attach an accept filter
INT2NUM(SO_ATTACH_FILTER)
- SO_DETACH_FILTER =
Detach an accept filter
INT2NUM(SO_DETACH_FILTER)
- SO_PEERNAME =
Name of the connecting user
INT2NUM(SO_PEERNAME)
- SO_TIMESTAMP =
Receive timestamp with datagrams (timeval)
INT2NUM(SO_TIMESTAMP)
- SO_TIMESTAMPNS =
Receive nanosecond timestamp with datagrams (timespec)
INT2NUM(SO_TIMESTAMPNS)
- SO_BINTIME =
Receive timestamp with datagrams (bintime)
INT2NUM(SO_BINTIME)
- SO_RECVUCRED =
Receive user credentials with datagram
INT2NUM(SO_RECVUCRED)
- SO_MAC_EXEMPT =
Mandatory Access Control exemption for unlabeled peers
INT2NUM(SO_MAC_EXEMPT)
- SO_ALLZONES =
Bypass zone boundaries
INT2NUM(SO_ALLZONES)
- SOPRI_INTERACTIVE =
Interactive socket priority
INT2NUM(SOPRI_INTERACTIVE)
- SOPRI_NORMAL =
Normal socket priority
INT2NUM(SOPRI_NORMAL)
- SOPRI_BACKGROUND =
Background socket priority
INT2NUM(SOPRI_BACKGROUND)
- IPX_TYPE =
INT2NUM(IPX_TYPE)
- TCP_NODELAY =
Don't delay sending to coalesce packets
INT2NUM(TCP_NODELAY)
- TCP_MAXSEG =
Set maximum segment size
INT2NUM(TCP_MAXSEG)
- TCP_CORK =
Don't send partial frames
INT2NUM(TCP_CORK)
- TCP_DEFER_ACCEPT =
Don't notify a listening socket until data is ready
INT2NUM(TCP_DEFER_ACCEPT)
- TCP_INFO =
Retrieve information about this socket
INT2NUM(TCP_INFO)
- TCP_KEEPCNT =
Maximum number of keepalive probes allowed before dropping a connection
INT2NUM(TCP_KEEPCNT)
- TCP_KEEPIDLE =
Idle time before keepalive probes are sent
INT2NUM(TCP_KEEPIDLE)
- TCP_KEEPINTVL =
Time between keepalive probes
INT2NUM(TCP_KEEPINTVL)
- TCP_LINGER2 =
Lifetime of orphaned FIN_WAIT2 sockets
INT2NUM(TCP_LINGER2)
- TCP_MD5SIG =
Use MD5 digests (RFC2385)
INT2NUM(TCP_MD5SIG)
- TCP_NOOPT =
Don't use TCP options
INT2NUM(TCP_NOOPT)
- TCP_NOPUSH =
Don't push the last block of write
INT2NUM(TCP_NOPUSH)
- TCP_QUICKACK =
Enable quickack mode
INT2NUM(TCP_QUICKACK)
- TCP_SYNCNT =
Number of SYN retransmits before a connection is dropped
INT2NUM(TCP_SYNCNT)
- TCP_WINDOW_CLAMP =
Clamp the size of the advertised window
INT2NUM(TCP_WINDOW_CLAMP)
- UDP_CORK =
Don't send partial frames
INT2NUM(UDP_CORK)
- EAI_ADDRFAMILY =
Address family for hostname not supported
INT2NUM(EAI_ADDRFAMILY)
- EAI_AGAIN =
Temporary failure in name resolution
INT2NUM(EAI_AGAIN)
- EAI_BADFLAGS =
Invalid flags
INT2NUM(EAI_BADFLAGS)
- EAI_FAIL =
Non-recoverable failure in name resolution
INT2NUM(EAI_FAIL)
- EAI_FAMILY =
Address family not supported
INT2NUM(EAI_FAMILY)
- EAI_MEMORY =
Memory allocation failure
INT2NUM(EAI_MEMORY)
- EAI_NODATA =
No address associated with hostname
INT2NUM(EAI_NODATA)
- EAI_NONAME =
Hostname nor servname, or not known
INT2NUM(EAI_NONAME)
- EAI_OVERFLOW =
Argument buffer overflow
INT2NUM(EAI_OVERFLOW)
- EAI_SERVICE =
Servname not supported for socket type
INT2NUM(EAI_SERVICE)
- EAI_SOCKTYPE =
Socket type not supported
INT2NUM(EAI_SOCKTYPE)
- EAI_SYSTEM =
System error returned in errno
INT2NUM(EAI_SYSTEM)
- EAI_BADHINTS =
Invalid value for hints
INT2NUM(EAI_BADHINTS)
- EAI_PROTOCOL =
Resolved protocol is unknown
INT2NUM(EAI_PROTOCOL)
- EAI_MAX =
Maximum error code from getaddrinfo
INT2NUM(EAI_MAX)
- AI_PASSIVE =
Get address to use with bind()
INT2NUM(AI_PASSIVE)
- AI_CANONNAME =
Fill in the canonical name
INT2NUM(AI_CANONNAME)
- AI_NUMERICHOST =
Prevent host name resolution
INT2NUM(AI_NUMERICHOST)
- AI_NUMERICSERV =
Prevent service name resolution
INT2NUM(AI_NUMERICSERV)
- AI_MASK =
Valid flag mask for getaddrinfo (not for application use)
INT2NUM(AI_MASK)
- AI_ALL =
Allow all addresses
INT2NUM(AI_ALL)
- AI_V4MAPPED_CFG =
Accept IPv4 mapped addresses if the kernel supports it
INT2NUM(AI_V4MAPPED_CFG)
- AI_ADDRCONFIG =
Accept only if any address is assigned
INT2NUM(AI_ADDRCONFIG)
- AI_V4MAPPED =
Accept IPv4-mapped IPv6 addresses
INT2NUM(AI_V4MAPPED)
- AI_DEFAULT =
Default flags for getaddrinfo
INT2NUM(AI_DEFAULT)
- NI_MAXHOST =
Maximum length of a hostname
INT2NUM(NI_MAXHOST)
- NI_MAXSERV =
Maximum length of a service name
INT2NUM(NI_MAXSERV)
- NI_NOFQDN =
An FQDN is not required for local hosts, return only the local part
INT2NUM(NI_NOFQDN)
- NI_NUMERICHOST =
Return a numeric address
INT2NUM(NI_NUMERICHOST)
- NI_NAMEREQD =
A name is required
INT2NUM(NI_NAMEREQD)
- NI_NUMERICSERV =
Return the service name as a digit string
INT2NUM(NI_NUMERICSERV)
- NI_DGRAM =
The service specified is a datagram service (looks up UDP ports)
INT2NUM(NI_DGRAM)
- SHUT_RD =
Shut down the reading side of the socket
INT2NUM(SHUT_RD)
- SHUT_WR =
Shut down the writing side of the socket
INT2NUM(SHUT_WR)
- SHUT_RDWR =
Shut down the both sides of the socket
INT2NUM(SHUT_RDWR)
- IPV6_JOIN_GROUP =
Join a group membership
INT2NUM(IPV6_JOIN_GROUP)
- IPV6_LEAVE_GROUP =
Leave a group membership
INT2NUM(IPV6_LEAVE_GROUP)
- IPV6_MULTICAST_HOPS =
IP6 multicast hops
INT2NUM(IPV6_MULTICAST_HOPS)
- IPV6_MULTICAST_IF =
IP6 multicast interface
INT2NUM(IPV6_MULTICAST_IF)
- IPV6_MULTICAST_LOOP =
IP6 multicast loopback
INT2NUM(IPV6_MULTICAST_LOOP)
- IPV6_UNICAST_HOPS =
IP6 unicast hops
INT2NUM(IPV6_UNICAST_HOPS)
- IPV6_V6ONLY =
Only bind IPv6 with a wildcard bind
INT2NUM(IPV6_V6ONLY)
- IPV6_CHECKSUM =
Checksum offset for raw sockets
INT2NUM(IPV6_CHECKSUM)
- IPV6_DONTFRAG =
Don't fragment packets
INT2NUM(IPV6_DONTFRAG)
- IPV6_DSTOPTS =
Destination option
INT2NUM(IPV6_DSTOPTS)
- IPV6_HOPLIMIT =
Hop limit
INT2NUM(IPV6_HOPLIMIT)
- IPV6_HOPOPTS =
Hop-by-hop option
INT2NUM(IPV6_HOPOPTS)
- IPV6_NEXTHOP =
Next hop address
INT2NUM(IPV6_NEXTHOP)
- IPV6_PATHMTU =
Retrieve current path MTU
INT2NUM(IPV6_PATHMTU)
- IPV6_PKTINFO =
Receive packet information with datagram
INT2NUM(IPV6_PKTINFO)
- IPV6_RECVDSTOPTS =
Receive all IP6 options for response
INT2NUM(IPV6_RECVDSTOPTS)
- IPV6_RECVHOPLIMIT =
Receive hop limit with datagram
INT2NUM(IPV6_RECVHOPLIMIT)
- IPV6_RECVHOPOPTS =
Receive hop-by-hop options
INT2NUM(IPV6_RECVHOPOPTS)
- IPV6_RECVPKTINFO =
Receive destination IP address and incoming interface
INT2NUM(IPV6_RECVPKTINFO)
- IPV6_RECVRTHDR =
Receive routing header
INT2NUM(IPV6_RECVRTHDR)
- IPV6_RECVTCLASS =
Receive traffic class
INT2NUM(IPV6_RECVTCLASS)
- IPV6_RTHDR =
Allows removal of sticky routing headers
INT2NUM(IPV6_RTHDR)
- IPV6_RTHDRDSTOPTS =
Allows removal of sticky destination options header
INT2NUM(IPV6_RTHDRDSTOPTS)
- IPV6_RTHDR_TYPE_0 =
Routing header type 0
INT2NUM(IPV6_RTHDR_TYPE_0)
- IPV6_RECVPATHMTU =
Receive current path MTU with datagram
INT2NUM(IPV6_RECVPATHMTU)
- IPV6_TCLASS =
Specify the traffic class
INT2NUM(IPV6_TCLASS)
- IPV6_USE_MIN_MTU =
Use the minimum MTU size
INT2NUM(IPV6_USE_MIN_MTU)
- INET_ADDRSTRLEN =
Maximum length of an IPv4 address string
INT2NUM(INET_ADDRSTRLEN)
- INET6_ADDRSTRLEN =
Maximum length of an IPv6 address string
INT2NUM(INET6_ADDRSTRLEN)
- IFNAMSIZ =
Maximum interface name size
INT2NUM(IFNAMSIZ)
- IF_NAMESIZE =
Maximum interface name size
INT2NUM(IF_NAMESIZE)
- SOMAXCONN =
Maximum connection requests that may be queued for a socket
INT2NUM(SOMAXCONN)
- SCM_RIGHTS =
Access rights
INT2NUM(SCM_RIGHTS)
- SCM_TIMESTAMP =
Timestamp (timeval)
INT2NUM(SCM_TIMESTAMP)
- SCM_TIMESTAMPNS =
Timespec (timespec)
INT2NUM(SCM_TIMESTAMPNS)
- SCM_BINTIME =
Timestamp (bintime)
INT2NUM(SCM_BINTIME)
- SCM_CREDENTIALS =
The sender's credentials
INT2NUM(SCM_CREDENTIALS)
- SCM_CREDS =
Process credentials
INT2NUM(SCM_CREDS)
- SCM_UCRED =
User credentials
INT2NUM(SCM_UCRED)
- LOCAL_PEERCRED =
Retrieve peer credentials
INT2NUM(LOCAL_PEERCRED)
- LOCAL_CREDS =
Pass credentials to receiver
INT2NUM(LOCAL_CREDS)
- LOCAL_CONNWAIT =
Connect blocks until accepted
INT2NUM(LOCAL_CONNWAIT)
Class Method Summary collapse
-
.accept_loop(*sockets) ⇒ Object
yield socket and client address for each a connection accepted via given sockets.
-
.getaddrinfo(nodename, servname[, family[, socktype[, protocol[, flags[, reverse_lookup]]]]]) ⇒ Array
Obtains address information for nodename:servname.
-
.gethostbyaddr(address_string[, address_family]) ⇒ Object
Obtains the host information for address.
-
.gethostbyname(hostname) ⇒ Array
Obtains the host information for hostname.
- .gethostname ⇒ Object
-
.getnameinfo(sockaddr[, flags]) ⇒ Array
Obtains name information for sockaddr.
-
.getservbyname ⇒ Object
Obtains the port number for service_name.
-
.getservbyport(port[, protocol_name]) ⇒ Object
Obtains the port number for port.
-
.ip_address_list ⇒ Array
Returns local IP addresses as an array.
-
.pack_sockaddr_in ⇒ Object
Packs port and host as an AF_INET/AF_INET6 sockaddr string.
-
.pack_sockaddr_un ⇒ Object
Packs path as an AF_UNIX sockaddr string.
-
.pair ⇒ Object
Creates a pair of sockets connected each other.
-
.sockaddr_in ⇒ Object
Packs port and host as an AF_INET/AF_INET6 sockaddr string.
-
.sockaddr_un ⇒ Object
Packs path as an AF_UNIX sockaddr string.
-
.socketpair ⇒ Object
Creates a pair of sockets connected each other.
-
.tcp(host, port, local_host = nil, local_port = nil) ⇒ Object
creates a new socket object connected to host:port using TCP/IP.
-
.tcp_server_loop(host = nil, port, &b) ⇒ Object
creates a TCP/IP server on port and calls the block for each connection accepted.
-
.tcp_server_sockets(host = nil, port) ⇒ Object
creates TCP/IP server sockets for host and port.
-
.udp_server_loop(host = nil, port, &b) ⇒ Object
:call-seq: Socket.udp_server_loop(port) {|msg, msg_src| ... } Socket.udp_server_loop(host, port) {|msg, msg_src| ... }.
-
.udp_server_loop_on(sockets, &b) ⇒ Object
:call-seq: Socket.udp_server_loop_on(sockets) {|msg, msg_src| ... }.
-
.udp_server_recv(sockets) ⇒ Object
:call-seq: Socket.udp_server_recv(sockets) {|msg, msg_src| ... }.
-
.udp_server_sockets(host = nil, port) ⇒ Object
:call-seq: Socket.udp_server_sockets([host, ] port).
-
.unix(path) ⇒ Object
creates a new socket connected to path using UNIX socket socket.
-
.unix_server_loop(path, &b) ⇒ Object
creates a UNIX socket server on path.
-
.unix_server_socket(path) ⇒ Object
creates a UNIX server socket on path.
-
.unpack_sockaddr_in(sockaddr) ⇒ Array
Unpacks sockaddr into port and ip_address.
-
.unpack_sockaddr_un(sockaddr) ⇒ Object
Unpacks sockaddr into path.
Instance Method Summary collapse
-
#accept ⇒ Array
Accepts a next connection.
-
#accept_nonblock ⇒ Array
Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor.
-
#bind(local_sockaddr) ⇒ 0
Binds to the given local address.
-
#connect(remote_sockaddr) ⇒ 0
Requests a connection to be made on the given
remote_sockaddr
. -
#connect_nonblock(remote_sockaddr) ⇒ 0
Requests a connection to be made on the given
remote_sockaddr
after O_NONBLOCK is set for the underlying file descriptor. -
#new(domain, socktype[, protocol]) ⇒ Object
constructor
Creates a new socket object.
-
#ipv6only! ⇒ Object
enable the socket option IPV6_V6ONLY if IPV6_V6ONLY is available.
-
#listen(int) ⇒ 0
Listens for connections, using the specified
int
as the backlog. -
#recvfrom ⇒ Object
Receives up to maxlen bytes from
socket
. -
#recvfrom_nonblock ⇒ Object
Receives up to maxlen bytes from
socket
using recvfrom(2) after O_NONBLOCK is set for the underlying file descriptor. -
#sysaccept ⇒ Array
Accepts an incoming connection returning an array containing the (integer) file descriptor for the incoming connection, client_socket_fd, and an Addrinfo, client_addrinfo.
Methods inherited from BasicSocket
Constructor Details
#new(domain, socktype[, protocol]) ⇒ Object
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 should be a protocol defined in the domain. This is optional. If it is not given, 0 is used internally.
Socket.new(:INET, :STREAM) # TCP socket
Socket.new(:INET, :DGRAM) # UDP socket
Socket.new(:UNIX, :STREAM) # UNIX stream socket
Socket.new(:UNIX, :DGRAM) # UNIX datagram socket
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
# File 'socket.c', line 39
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);
rb_secure(3);
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);
}
|
Class Method Details
.accept_loop(*sockets) ⇒ Object
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.
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 |
# File 'lib/socket.rb', line 407 def self.accept_loop(*sockets) # :yield: socket, client_addrinfo sockets.flatten!(1) if sockets.empty? raise ArgumentError, "no sockets" end loop { readable, _, _ = IO.select(sockets) readable.each {|r| begin sock, addr = r.accept_nonblock rescue IO::WaitReadable next end yield sock, addr } } end |
.getaddrinfo(nodename, servname[, family[, socktype[, protocol[, flags[, reverse_lookup]]]]]) ⇒ Array
Obtains address information for nodename:servname.
family should be an address family 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 family. 0 is default protocol for the family.
flags should be bitwise OR of Socket::AI_* constants.
Socket.getaddrinfo("www.ruby-lang.org", "http", nil, :STREAM)
#=> [["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68", 2, 1, 6]] # PF_INET/SOCK_STREAM/IPPROTO_TCP
Socket.getaddrinfo("localhost", nil)
#=> [["AF_INET", 0, "localhost", "127.0.0.1", 2, 1, 6], # PF_INET/SOCK_STREAM/IPPROTO_TCP
# ["AF_INET", 0, "localhost", "127.0.0.1", 2, 2, 17], # PF_INET/SOCK_DGRAM/IPPROTO_UDP
# ["AF_INET", 0, "localhost", "127.0.0.1", 2, 3, 0]] # PF_INET/SOCK_RAW/IPPROTO_IP
reverse_lookup directs the form of the third element, and has to be one of below. If it is ommitted, 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 same as numeric address.
+nil+: obey to the current +do_not_reverse_lookup+ flag.
If Addrinfo object is preferred, use Addrinfo.getaddrinfo.
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 |
# File 'socket.c', line 1112
static VALUE
sock_s_getaddrinfo(int argc, VALUE *argv)
{
VALUE host, port, family, socktype, protocol, flags, ret, revlookup;
struct addrinfo hints, *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);
freeaddrinfo(res);
return ret;
}
|
.gethostbyaddr(address_string[, address_family]) ⇒ Object
Obtains the host information for address.
p Socket.gethostbyaddr([221,186,184,68].pack("CCCC"))
#=> ["carbon.ruby-lang.org", [], 2, "\xDD\xBA\xB8D"]
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 |
# File 'socket.c', line 952
static VALUE
sock_s_gethostbyaddr(int argc, VALUE *argv)
{
VALUE addr, family;
struct hostent *h;
struct sockaddr *sa;
char **pch;
VALUE ary, names;
int t = AF_INET;
rb_scan_args(argc, argv, "11", &addr, &family);
sa = (struct sockaddr*)StringValuePtr(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_LENINT(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;
}
|
.gethostbyname(hostname) ⇒ Array
Obtains the host information for hostname.
p Socket.gethostbyname("hal") #=> ["localhost", ["hal"], 2, "\x7F\x00\x00\x01"]
936 937 938 939 940 941 |
# File 'socket.c', line 936
static VALUE
sock_s_gethostbyname(VALUE obj, VALUE host)
{
rb_secure(3);
return rsock_make_hostent(host, rsock_addrinfo(host, Qnil, SOCK_STREAM, AI_CANONNAME), sock_sockaddr);
}
|
.gethostname ⇒ Object
867 868 869 870 871 872 873 874 875 |
# File 'socket.c', line 867
static VALUE
sock_gethostname(VALUE obj)
{
struct utsname un;
rb_secure(3);
uname(&un);
return rb_str_new2(un.nodename);
}
|
.getnameinfo(sockaddr[, flags]) ⇒ Array
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 that the last form is compatible with IPSocket#addr,peeraddr.
Socket.getnameinfo(Socket.sockaddr_in(80, "127.0.0.1")) #=> ["localhost", "www"]
Socket.getnameinfo(["AF_INET", 80, "127.0.0.1"]) #=> ["localhost", "www"]
Socket.getnameinfo(["AF_INET", 80, "localhost", "127.0.0.1"]) #=> ["localhost", "www"]
If Addrinfo object is preferred, use Addrinfo#getnameinfo.
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 |
# File 'socket.c', line 1164
static VALUE
sock_s_getnameinfo(int argc, VALUE *argv)
{
VALUE sa, af = Qnil, host = Qnil, port = Qnil, flags, tmp;
char *hptr, *pptr;
char hbuf[1024], pbuf[1024];
int fl;
struct addrinfo hints, *res = NULL, *r;
int error;
struct sockaddr_storage ss;
struct sockaddr *sap;
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 ((size_t)RSTRING_LEN(sa) != SS_LEN(&ss)) {
rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
}
sap = (struct sockaddr*)&ss;
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_PTR(sa)[0];
port = RARRAY_PTR(sa)[1];
host = RARRAY_PTR(sa)[2];
}
else if (RARRAY_LEN(sa) >= 4) {
af = RARRAY_PTR(sa)[0];
port = RARRAY_PTR(sa)[1];
host = RARRAY_PTR(sa)[3];
if (NIL_P(host)) {
host = RARRAY_PTR(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));
}
/* host */
if (NIL_P(host)) {
hptr = NULL;
}
else {
strncpy(hbuf, StringValuePtr(host), sizeof(hbuf));
hbuf[sizeof(hbuf) - 1] = '\0';
hptr = hbuf;
}
/* port */
if (NIL_P(port)) {
strcpy(pbuf, "0");
pptr = NULL;
}
else if (FIXNUM_P(port)) {
snprintf(pbuf, sizeof(pbuf), "%ld", NUM2LONG(port));
pptr = pbuf;
}
else {
strncpy(pbuf, StringValuePtr(port), sizeof(pbuf));
pbuf[sizeof(pbuf) - 1] = '\0';
pptr = pbuf;
}
hints.ai_socktype = (fl & NI_DGRAM) ? SOCK_DGRAM : SOCK_STREAM;
/* af */
hints.ai_family = NIL_P(af) ? PF_UNSPEC : rsock_family_arg(af);
error = rb_getaddrinfo(hptr, pptr, &hints, &res);
if (error) goto error_exit_addr;
sap = res->ai_addr;
}
else {
rb_raise(rb_eTypeError, "expecting String or Array");
}
call_nameinfo:
error = rb_getnameinfo(sap, SA_LEN(sap), hbuf, sizeof(hbuf),
pbuf, sizeof(pbuf), fl);
if (error) goto error_exit_name;
if (res) {
for (r = res->ai_next; r; r = r->ai_next) {
char hbuf2[1024], pbuf2[1024];
sap = r->ai_addr;
error = rb_getnameinfo(sap, SA_LEN(sap), hbuf2, sizeof(hbuf2),
pbuf2, sizeof(pbuf2), fl);
if (error) goto error_exit_name;
if (strcmp(hbuf, hbuf2) != 0|| strcmp(pbuf, pbuf2) != 0) {
freeaddrinfo(res);
rb_raise(rb_eSocket, "sockaddr resolved to multiple nodename");
}
}
freeaddrinfo(res);
}
return rb_assoc_new(rb_str_new2(hbuf), rb_str_new2(pbuf));
error_exit_addr:
if (res) freeaddrinfo(res);
rsock_raise_socket_error("getaddrinfo", error);
error_exit_name:
if (res) freeaddrinfo(res);
rsock_raise_socket_error("getnameinfo", error);
}
|
.getservbyname(service_name) ⇒ Object .getservbyname(service_name, protocol_name) ⇒ Object
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 |
# File 'socket.c', line 1015
static VALUE
sock_s_getservbyname(int argc, VALUE *argv)
{
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);
}
|
.getservbyport(port[, protocol_name]) ⇒ Object
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 |
# File 'socket.c', line 1056
static VALUE
sock_s_getservbyport(int argc, VALUE *argv)
{
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_tainted_str_new2(sp->s_name);
}
|
.ip_address_list ⇒ Array
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>,
...]
1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 |
# File 'socket.c', line 1507
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)) {
rb_ary_push(list, sockaddr_obj(p->ifa_addr));
}
}
freeifaddrs(ifp);
return list;
#elif defined(SIOCGLIFCONF) && defined(SIOCGLIFNUM) && !defined(__hpux)
/* Solaris if_tcp(7P) */
/* HP-UX has SIOCGLIFCONF too. But it uses different struct */
int fd = -1;
int ret;
struct lifnum ln;
struct lifconf lc;
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");
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));
}
}
finish:
save_errno = errno;
if (lc.lifc_buf != NULL)
xfree(lc.lifc_req);
if (fd != -1)
close(fd);
errno = save_errno;
if (reason)
rb_sys_fail(reason);
return list;
#elif defined(SIOCGIFCONF)
int fd = -1;
int ret;
#define EXTRA_SPACE (sizeof(struct ifconf) + sizeof(struct sockaddr_storage))
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");
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));
}
#ifdef HAVE_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_sys_fail(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));
}
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));
}
}
FreeLibrary(h);
return list;
#endif
}
|
.sockaddr_in(port, host) ⇒ Object .pack_sockaddr_in(port, host) ⇒ Object
Packs port and host as an AF_INET/AF_INET6 sockaddr string.
Socket.sockaddr_in(80, "127.0.0.1")
#=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
Socket.sockaddr_in(80, "::1")
#=> "\n\x00\x00P\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00"
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 |
# File 'socket.c', line 1304
static VALUE
sock_s_pack_sockaddr_in(VALUE self, VALUE port, VALUE host)
{
struct addrinfo *res = rsock_addrinfo(host, port, 0, 0);
VALUE addr = rb_str_new((char*)res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
OBJ_INFECT(addr, port);
OBJ_INFECT(addr, host);
return addr;
}
|
.sockaddr_un(path) ⇒ Object .pack_sockaddr_un(path) ⇒ Object
Packs path as an AF_UNIX sockaddr string.
Socket.sockaddr_un("/tmp/sock") #=> "\x01\x00/tmp/sock\x00\x00..."
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 |
# File 'socket.c', line 1370
static VALUE
sock_s_pack_sockaddr_un(VALUE self, VALUE path)
{
struct sockaddr_un sockaddr;
char *sun_path;
VALUE addr;
MEMZERO(&sockaddr, struct sockaddr_un, 1);
sockaddr.sun_family = AF_UNIX;
sun_path = StringValueCStr(path);
if (sizeof(sockaddr.sun_path) <= strlen(sun_path)) {
rb_raise(rb_eArgError, "too long unix socket path (max: %dbytes)",
(int)sizeof(sockaddr.sun_path)-1);
}
strncpy(sockaddr.sun_path, sun_path, sizeof(sockaddr.sun_path)-1);
addr = rb_str_new((char*)&sockaddr, sizeof(sockaddr));
OBJ_INFECT(addr, path);
return addr;
}
|
.pair(domain, type, protocol) ⇒ Array .socketpair(domain, type, protocol) ⇒ Array
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. 0 is default protocol for the domain.
s1, s2 = Socket.pair(:UNIX, :DGRAM, 0)
s1.send "a", 0
s1.send "b", 0
p s2.recv(10) #=> "a"
p s2.recv(10) #=> "b"
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
# File 'socket.c', line 100
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 = socketpair(d, t, p, sp);
if (ret < 0 && (errno == EMFILE || errno == ENFILE)) {
rb_gc();
ret = socketpair(d, t, p, sp);
}
if (ret < 0) {
rb_sys_fail("socketpair(2)");
}
rb_update_max_fd(sp[0]);
rb_update_max_fd(sp[1]);
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;
}
|
.sockaddr_in(port, host) ⇒ Object .pack_sockaddr_in(port, host) ⇒ Object
Packs port and host as an AF_INET/AF_INET6 sockaddr string.
Socket.sockaddr_in(80, "127.0.0.1")
#=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
Socket.sockaddr_in(80, "::1")
#=> "\n\x00\x00P\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00"
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 |
# File 'socket.c', line 1304
static VALUE
sock_s_pack_sockaddr_in(VALUE self, VALUE port, VALUE host)
{
struct addrinfo *res = rsock_addrinfo(host, port, 0, 0);
VALUE addr = rb_str_new((char*)res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
OBJ_INFECT(addr, port);
OBJ_INFECT(addr, host);
return addr;
}
|
.sockaddr_un(path) ⇒ Object .pack_sockaddr_un(path) ⇒ Object
Packs path as an AF_UNIX sockaddr string.
Socket.sockaddr_un("/tmp/sock") #=> "\x01\x00/tmp/sock\x00\x00..."
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 |
# File 'socket.c', line 1370
static VALUE
sock_s_pack_sockaddr_un(VALUE self, VALUE path)
{
struct sockaddr_un sockaddr;
char *sun_path;
VALUE addr;
MEMZERO(&sockaddr, struct sockaddr_un, 1);
sockaddr.sun_family = AF_UNIX;
sun_path = StringValueCStr(path);
if (sizeof(sockaddr.sun_path) <= strlen(sun_path)) {
rb_raise(rb_eArgError, "too long unix socket path (max: %dbytes)",
(int)sizeof(sockaddr.sun_path)-1);
}
strncpy(sockaddr.sun_path, sun_path, sizeof(sockaddr.sun_path)-1);
addr = rb_str_new((char*)&sockaddr, sizeof(sockaddr));
OBJ_INFECT(addr, path);
return addr;
}
|
.pair(domain, type, protocol) ⇒ Array .socketpair(domain, type, protocol) ⇒ Array
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. 0 is default protocol for the domain.
s1, s2 = Socket.pair(:UNIX, :DGRAM, 0)
s1.send "a", 0
s1.send "b", 0
p s2.recv(10) #=> "a"
p s2.recv(10) #=> "b"
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
# File 'socket.c', line 100
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 = socketpair(d, t, p, sp);
if (ret < 0 && (errno == EMFILE || errno == ENFILE)) {
rb_gc();
ret = socketpair(d, t, p, sp);
}
if (ret < 0) {
rb_sys_fail("socketpair(2)");
}
rb_update_max_fd(sp[0]);
rb_update_max_fd(sp[1]);
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;
}
|
.tcp(host, port, local_host = nil, local_port = nil) ⇒ Object
creates a new socket object connected to host:port using TCP/IP.
If local_host:local_port is given, the socket is bound to it.
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
}
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 |
# File 'lib/socket.rb', line 236 def self.tcp(host, port, local_host=nil, local_port=nil) # :yield: socket last_error = nil ret = nil local_addr_list = nil if local_host != nil || local_port != nil local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil) end Addrinfo.foreach(host, port, nil, :STREAM) {|ai| if local_addr_list local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily } next if !local_addr else local_addr = nil end begin sock = local_addr ? ai.connect_from(local_addr) : ai.connect rescue SystemCallError last_error = $! next end ret = sock break } if !ret if last_error raise last_error else raise SocketError, "no appropriate local address" end end if block_given? begin yield ret ensure ret.close if !ret.closed? end else ret end end |
.tcp_server_loop(host = nil, port, &b) ⇒ Object
creates a TCP/IP server on port and calls the block for each connection accepted. The block is called with a socket and a client_address as an Addrinfo object.
If host is specified, it is used with port to determine the server addresses.
The socket is not closed when the block returns. So application should close it explicitly.
This method calls the block sequentially. It means that the next connection is not accepted until the block returns. So concurrent mechanism, thread for example, should be used to service multiple clients at a time.
Note that Addrinfo.getaddrinfo is used to determine the server socket addresses. When Addrinfo.getaddrinfo returns two or more addresses, IPv4 and IPv6 address for example, all of them are used. Socket.tcp_server_loop succeeds if one socket can be used at least.
# Sequential echo server.
# It services only one client at a time.
Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
begin
IO.copy_stream(sock, sock)
ensure
sock.close
end
}
# Threaded echo server
# It services multiple clients at a time.
# Note that it may accept connections too much.
Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
Thread.new {
begin
IO.copy_stream(sock, sock)
ensure
sock.close
end
}
}
466 467 468 469 470 |
# File 'lib/socket.rb', line 466 def self.tcp_server_loop(host=nil, port, &b) # :yield: socket, client_addrinfo tcp_server_sockets(host, port) {|sockets| accept_loop(sockets, &b) } end |
.tcp_server_sockets(host = nil, port) ⇒ Object
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 choosen dynamically. However all sockets in the result has same port number.
# tcp_server_sockets returns two sockets.
sockets = Socket.tcp_server_sockets(1296)
p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
# The sockets contains IPv6 and IPv4 sockets.
sockets.each {|s| p s.local_address }
#=> #<Addrinfo: [::]:1296 TCP>
# #<Addrinfo: 0.0.0.0:1296 TCP>
# IPv6 and IPv4 socket has same port number, 53114, even if it is choosen dynamically.
sockets = Socket.tcp_server_sockets(0)
sockets.each {|s| p s.local_address }
#=> #<Addrinfo: [::]:53114 TCP>
# #<Addrinfo: 0.0.0.0:53114 TCP>
# The block is called with the sockets.
Socket.tcp_server_sockets(0) {|sockets|
p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
}
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 |
# File 'lib/socket.rb', line 364 def self.tcp_server_sockets(host=nil, port) if port == 0 sockets = tcp_server_sockets_port0(host) else begin last_error = nil sockets = [] 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 ensure sockets.each {|s| s.close if !s.closed? } if $! end end if block_given? begin yield sockets ensure sockets.each {|s| s.close if !s.closed? } end else sockets end end |
.udp_server_loop(host = nil, port, &b) ⇒ Object
:call-seq:
Socket.udp_server_loop(port) {|msg, msg_src| ... }
Socket.udp_server_loop(host, port) {|msg, msg_src| ... }
creates a UDP/IP server on port and calls the block for each message arrived. The block is called with the message and its source information.
This method allocates sockets internally using port. If host is specified, it is used conjunction with port to determine the server addresses.
The msg is a string.
The msg_src is a Socket::UDPSource object. It is used for reply.
# UDP/IP echo server.
Socket.udp_server_loop(9261) {|msg, msg_src|
msg_src.reply msg
}
638 639 640 641 642 |
# File 'lib/socket.rb', line 638 def self.udp_server_loop(host=nil, port, &b) # :yield: message, message_source udp_server_sockets(host, port) {|sockets| udp_server_loop_on(sockets, &b) } end |
.udp_server_loop_on(sockets, &b) ⇒ Object
:call-seq:
Socket.udp_server_loop_on(sockets) {|msg, msg_src| ... }
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.
611 612 613 614 615 616 |
# File 'lib/socket.rb', line 611 def self.udp_server_loop_on(sockets, &b) # :yield: msg, msg_src loop { readable, _, _ = IO.select(sockets) udp_server_recv(readable, &b) } end |
.udp_server_recv(sockets) ⇒ Object
:call-seq:
Socket.udp_server_recv(sockets) {|msg, msg_src| ... }
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| ... }
}
}
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 |
# File 'lib/socket.rb', line 581 def self.udp_server_recv(sockets) sockets.each {|r| begin msg, sender_addrinfo, _, *controls = r.recvmsg_nonblock rescue IO::WaitReadable next end 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 |
.udp_server_sockets(host = nil, port) ⇒ Object
:call-seq:
Socket.udp_server_sockets([host, ] port)
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 choosen. But the choosen port is used for the all sockets.
# UDP/IP echo server
Socket.udp_server_sockets(0) {|sockets|
p sockets.first.local_address.ip_port #=> 32963
Socket.udp_server_loop_on(sockets) {|msg, msg_src|
msg_src.reply msg
}
}
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 |
# File 'lib/socket.rb', line 494 def self.udp_server_sockets(host=nil, port) last_error = nil sockets = [] ipv6_recvpktinfo = nil if defined? Socket::AncillaryData if defined? Socket::IPV6_RECVPKTINFO # RFC 3542 ipv6_recvpktinfo = Socket::IPV6_RECVPKTINFO elsif defined? Socket::IPV6_PKTINFO # RFC 2292 ipv6_recvpktinfo = Socket::IPV6_PKTINFO end end local_addrs = Socket.ip_address_list ip_list = [] Addrinfo.foreach(host, port, nil, :DGRAM, nil, Socket::AI_PASSIVE) {|ai| if ai.ipv4? && ai.ip_address == "0.0.0.0" local_addrs.each {|a| next if !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 if !a.ipv6? ip_list << Addrinfo.new(a.to_sockaddr, :INET6, :DGRAM, 0); } else ip_list << ai end } 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 {|s| s.close if !s.closed? } if sockets end else sockets end end |
.unix(path) ⇒ Object
creates a new socket connected to path using UNIX socket socket.
If a block is given, the block is called with the socket. The value of the block is returned. The socket is closed when this method returns.
If no block is given, the socket is returned.
# talk to /tmp/sock socket.
Socket.unix("/tmp/sock") {|sock|
t = Thread.new { IO.copy_stream(sock, STDOUT) }
IO.copy_stream(STDIN, sock)
t.join
}
688 689 690 691 692 693 694 695 696 697 698 699 700 |
# File 'lib/socket.rb', line 688 def self.unix(path) # :yield: socket addr = Addrinfo.unix(path) sock = addr.connect if block_given? begin yield sock ensure sock.close if !sock.closed? end else sock end end |
.unix_server_loop(path, &b) ⇒ Object
creates a UNIX socket server on path. It calls the block for each socket accepted.
If host is specified, it is used with port to determine the server ports.
The socket is not closed when the block returns. So application should close it.
This method deletes the socket file pointed by path at first if the file is a socket file and it is owned by the user of the application. This is safe only if the directory of path is not changed by a malicious user. So don't use /tmp/malicious-users-directory/socket. Note that /tmp/socket and /tmp/your-private-directory/socket is safe assuming that /tmp has sticky bit.
# Sequential echo server.
# It services only one client at a time.
Socket.unix_server_loop("/tmp/sock") {|sock, client_addrinfo|
begin
IO.copy_stream(sock, sock)
ensure
sock.close
end
}
763 764 765 766 767 |
# File 'lib/socket.rb', line 763 def self.unix_server_loop(path, &b) # :yield: socket, client_addrinfo unix_server_socket(path) {|serv| accept_loop(serv, &b) } end |
.unix_server_socket(path) ⇒ Object
creates a UNIX server socket on path
If no block given, it returns a listening socket.
If a block is given, it is called with the socket and the block value is returned. When the block exits, the socket is closed and the socket file is removed.
socket = Socket.unix_server_socket("/tmp/s")
p socket #=> #<Socket:fd 3>
p socket.local_address #=> #<Addrinfo: /tmp/s SOCK_STREAM>
Socket.unix_server_socket("/tmp/sock") {|s|
p s #=> #<Socket:fd 3>
p s.local_address #=> # #<Addrinfo: /tmp/sock SOCK_STREAM>
}
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 |
# File 'lib/socket.rb', line 718 def self.unix_server_socket(path) begin st = File.lstat(path) rescue Errno::ENOENT end if st && st.socket? && st.owned? File.unlink path end s = Addrinfo.unix(path).listen if block_given? begin yield s ensure s.close if !s.closed? File.unlink path end else s end end |
.unpack_sockaddr_in(sockaddr) ⇒ Array
Unpacks sockaddr into port and ip_address.
sockaddr should be a string or an addrinfo for AF_INET/AF_INET6.
sockaddr = Socket.sockaddr_in(80, "127.0.0.1")
p sockaddr #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
p Socket.unpack_sockaddr_in(sockaddr) #=> [80, "127.0.0.1"]
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 |
# File 'socket.c', line 1330
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);
OBJ_INFECT(host, addr);
return rb_assoc_new(INT2NUM(ntohs(sockaddr->sin_port)), host);
}
|
.unpack_sockaddr_un(sockaddr) ⇒ Object
Unpacks sockaddr into path.
sockaddr should be a string or an addrinfo for AF_UNIX.
sockaddr = Socket.sockaddr_un("/tmp/sock")
p Socket.unpack_sockaddr_un(sockaddr) #=> "/tmp/sock"
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 |
# File 'socket.c', line 1403
static VALUE
sock_s_unpack_sockaddr_un(VALUE self, VALUE addr)
{
struct sockaddr_un * sockaddr;
const char *sun_path;
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));
}
sun_path = rsock_unixpath(sockaddr, RSTRING_LENINT(addr));
if (sizeof(struct sockaddr_un) == RSTRING_LEN(addr) &&
sun_path == sockaddr->sun_path &&
sun_path + strlen(sun_path) == RSTRING_PTR(addr) + RSTRING_LEN(addr)) {
rb_raise(rb_eArgError, "sockaddr_un.sun_path not NUL terminated");
}
path = rb_str_new2(sun_path);
OBJ_INFECT(path, addr);
return path;
}
|
Instance Method Details
#accept ⇒ Array
705 706 707 708 709 710 711 712 713 714 715 716 717 |
# File 'socket.c', line 705
static VALUE
sock_accept(VALUE sock)
{
rb_io_t *fptr;
VALUE sock2;
struct sockaddr_storage buf;
socklen_t len = (socklen_t)sizeof buf;
GetOpenFile(sock, fptr);
sock2 = rsock_s_accept(rb_cSocket,fptr->fd,(struct sockaddr*)&buf,&len);
return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, (struct sockaddr*)&buf, len));
}
|
#accept_nonblock ⇒ Array
Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. It returns an array containing the accepted socket for the incoming connection, client_socket, and an Addrinfo, client_addrinfo.
Example
# In one script, start this first require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(2200, 'localhost') socket.bind(sockaddr) socket.listen(5) begin # emulate blocking accept client_socket, client_addrinfo = socket.accept_nonblock rescue IO::WaitReadable, Errno::EINTR IO.select() retry end puts "The client said, '#Socket.client_socketclient_socket.readlineclient_socket.readline.chomp'" client_socket.puts "Hello from script one!" socket.close
# In another script, start this second require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(2200, 'localhost') socket.connect(sockaddr) socket.puts "Hello from script 2." puts "The server said, '#Socket.socketsocket.readlinesocket.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::AGAIN, 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.
See
-
Socket#accept
770 771 772 773 774 775 776 777 778 779 780 781 |
# File 'socket.c', line 770
static VALUE
sock_accept_nonblock(VALUE sock)
{
rb_io_t *fptr;
VALUE sock2;
struct sockaddr_storage buf;
socklen_t len = (socklen_t)sizeof buf;
GetOpenFile(sock, fptr);
sock2 = rsock_s_accept_nonblock(rb_cSocket, fptr, (struct sockaddr *)&buf, &len);
return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, (struct sockaddr*)&buf, len));
}
|
#bind(local_sockaddr) ⇒ 0
Binds to the given local address.
Parameter
-
local_sockaddr
- thestruct
sockaddr contained in a string or an Addrinfo object
Example
require 'socket'
# use Addrinfo socket = Socket.new(:INET, :STREAM, 0) socket.bind(Addrinfo.tcp("127.0.0.1", 2222)) p socket.local_address #=> #<Addrinfo: 127.0.0.1:2222 TCP>
# use struct sockaddr include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.bind( sockaddr )
Unix-based Exceptions
On unix-based based systems the following system exceptions may be raised if the call to bind fails:
-
Errno::EACCES - the specified sockaddr is protected and the current user does not have permission to bind to it
-
Errno::EADDRINUSE - the specified sockaddr is already in use
-
Errno::EADDRNOTAVAIL - the specified sockaddr is not available from the local machine
-
Errno::EAFNOSUPPORT - the specified sockaddr is not a valid address for the family of the calling
socket
-
Errno::EBADF - the sockaddr specified is not a valid file descriptor
-
Errno::EFAULT - the sockaddr argument cannot be accessed
-
Errno::EINVAL - the
socket
is already bound to an address, and the protocol does not support binding to the new sockaddr or thesocket
has been shut down. -
Errno::EINVAL - the address length is not a valid length for the address family
-
Errno::ENAMETOOLONG - the pathname resolved had a length which exceeded PATH_MAX
-
Errno::ENOBUFS - no buffer space is available
-
Errno::ENOSR - there were insufficient STREAMS resources available to complete the operation
-
Errno::ENOTSOCK - the
socket
does not refer to a socket -
Errno::EOPNOTSUPP - the socket type of the
socket
does not support binding to an address
On unix-based based systems if the address family of the calling socket
is Socket::AF_UNIX the follow exceptions may be raised if the call to bind fails:
-
Errno::EACCES - search permission is denied for a component of the prefix path or write access to the
socket
is denied -
Errno::EDESTADDRREQ - the sockaddr argument is a null pointer
-
Errno::EISDIR - same as Errno::EDESTADDRREQ
-
Errno::EIO - an i/o error occurred
-
Errno::ELOOP - too many symbolic links were encountered in translating the pathname in sockaddr
-
Errno::ENAMETOOLLONG - a component of a pathname exceeded NAME_MAX characters, or an entire pathname exceeded PATH_MAX characters
-
Errno::ENOENT - a component of the pathname does not name an existing file or the pathname is an empty string
-
Errno::ENOTDIR - a component of the path prefix of the pathname in sockaddr is not a directory
-
Errno::EROFS - the name would reside on a read only filesystem
Windows Exceptions
On Windows systems the following system exceptions may be raised if the call to bind fails:
-
Errno::ENETDOWN-- the network is down
-
Errno::EACCES - the attempt to connect the datagram socket to the broadcast address failed
-
Errno::EADDRINUSE - the socket's local address is already in use
-
Errno::EADDRNOTAVAIL - the specified address is not a valid address for this computer
-
Errno::EFAULT - the socket's internal address or address length parameter is too small or is not a valid part of the user space addressed
-
Errno::EINVAL - the
socket
is already bound to an address -
Errno::ENOBUFS - no buffer space is available
-
Errno::ENOTSOCK - the
socket
argument does not refer to a socket
See
-
bind manual pages on unix-based systems
-
bind function in Microsoft's Winsock functions reference
414 415 416 417 418 419 420 421 422 423 424 425 |
# File 'socket.c', line 414
static VALUE
sock_bind(VALUE sock, VALUE addr)
{
rb_io_t *fptr;
SockAddrStringValue(addr);
GetOpenFile(sock, fptr);
if (bind(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_LENINT(addr)) < 0)
rb_sys_fail("bind(2)");
return INT2FIX(0);
}
|
#connect(remote_sockaddr) ⇒ 0
Requests a connection to be made on the given remote_sockaddr
. Returns 0 if successful, otherwise an exception is raised.
Parameter
-
remote_sockaddr
- thestruct
sockaddr contained in a string or Addrinfo object
Example:
# Pull down Google's web page require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 80, 'www.google.com' ) socket.connect( sockaddr ) socket.write( "GET / HTTP/1.0rnrn" ) 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 time out before a connection was made.
On unix-based systems if the address family of the calling socket
is AF_UNIX the follow exceptions may be raised if the call to connect fails:
-
Errno::EIO - an i/o error occurred while reading from or writing to the file system
-
Errno::ELOOP - too many symbolic links were encountered in translating the pathname in sockaddr
-
Errno::ENAMETOOLLONG - a component of a pathname exceeded NAME_MAX characters, or an entire pathname exceeded PATH_MAX characters
-
Errno::ENOENT - a component of the pathname does not name an existing file or the pathname is an empty string
-
Errno::ENOTDIR - a component of the path prefix of the pathname in sockaddr is not a directory
Windows Exceptions
On Windows systems the following system exceptions may be raised if the call to connect fails:
-
Errno::ENETDOWN - the network is down
-
Errno::EADDRINUSE - the socket's local address is already in use
-
Errno::EINTR - the socket was cancelled
-
Errno::EINPROGRESS - a blocking socket is in progress or the service provider is still processing a callback function. Or a nonblocking connect call is in progress on the
socket
. -
Errno::EALREADY - see Errno::EINVAL
-
Errno::EADDRNOTAVAIL - the remote address is not a valid address, such as ADDR_ANY TODO check ADDRANY TO INADDR_ANY
-
Errno::EAFNOSUPPORT - addresses in the specified family cannot be used with with this
socket
-
Errno::ECONNREFUSED - the target sockaddr was not listening for connections refused the connection request
-
Errno::EFAULT - the socket's internal address or address length parameter is too small or is not a valid part of the user space address
-
Errno::EINVAL - the
socket
is a listening socket -
Errno::EISCONN - the
socket
is already connected -
Errno::ENETUNREACH - the network cannot be reached from this host at this time
-
Errno::EHOSTUNREACH - no route to the network is present
-
Errno::ENOBUFS - no buffer space is available
-
Errno::ENOTSOCK - the
socket
argument does not refer to a socket -
Errno::ETIMEDOUT - the attempt to connect time out before a connection was made.
-
Errno::EWOULDBLOCK - the socket is marked as nonblocking and the connection cannot be completed immediately
-
Errno::EACCES - the attempt to connect the datagram socket to the broadcast address failed
See
-
connect manual pages on unix-based systems
-
connect function in Microsoft's Winsock functions reference
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
# File 'socket.c', line 248
static VALUE
sock_connect(VALUE sock, VALUE addr)
{
rb_io_t *fptr;
int fd, n;
SockAddrStringValue(addr);
addr = rb_str_new4(addr);
GetOpenFile(sock, fptr);
fd = fptr->fd;
n = rsock_connect(fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_LENINT(addr), 0);
if (n < 0) {
rb_sys_fail("connect(2)");
}
return INT2FIX(n);
}
|
#connect_nonblock(remote_sockaddr) ⇒ 0
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
- thestruct
sockaddr contained in a string or Addrinfo object
Example:
# Pull down Google's web page require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(80, 'www.google.com') begin # emulate blocking connect socket.connect_nonblock(sockaddr) rescue IO::WaitWritable IO.select(nil, [socket]) # wait 3-way handshake completion begin socket.connect_nonblock(sockaddr) # check connection failure rescue Errno::EISCONN end end socket.write("GET / HTTP/1.0rnrn") 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.
See
-
Socket#connect
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 |
# File 'socket.c', line 308
static VALUE
sock_connect_nonblock(VALUE sock, VALUE addr)
{
rb_io_t *fptr;
int n;
SockAddrStringValue(addr);
addr = rb_str_new4(addr);
GetOpenFile(sock, fptr);
rb_io_set_nonblock(fptr);
n = connect(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_LENINT(addr));
if (n < 0) {
if (errno == EINPROGRESS)
rb_mod_sys_fail(rb_mWaitWritable, "connect(2) would block");
rb_sys_fail("connect(2)");
}
return INT2FIX(n);
}
|
#ipv6only! ⇒ Object
enable the socket option IPV6_V6ONLY if IPV6_V6ONLY is available.
213 214 215 216 217 |
# File 'lib/socket.rb', line 213 def ipv6only! if defined? Socket::IPV6_V6ONLY self.setsockopt(:IPV6, :V6ONLY, 1) end end |
#listen(int) ⇒ 0
Listens for connections, using the specified int
as the backlog. A call to listen only applies if the socket
is of type SOCK_STREAM or SOCK_SEQPACKET.
Parameter
-
backlog
- the maximum length of the queue for pending connections.
Example 1
require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.bind( sockaddr ) socket.listen( 5 )
Example 2 (listening on an arbitrary port, unix-based systems only):
require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) socket.listen( 1 )
Unix-based Exceptions
On unix based systems the above will work because a new sockaddr
struct is created on the address ADDR_ANY, for an arbitrary port number as handed off by the kernel. It will not work on Windows, because Windows requires that the socket
is bound by calling bind before it can listen.
If the backlog amount exceeds the implementation-dependent maximum queue length, the implementation's maximum queue length will be used.
On unix-based based systems the following system exceptions may be raised if the call to listen fails:
-
Errno::EBADF - the socket argument is not a valid file descriptor
-
Errno::EDESTADDRREQ - the socket is not bound to a local address, and the protocol does not support listening on an unbound socket
-
Errno::EINVAL - the socket is already connected
-
Errno::ENOTSOCK - the socket argument does not refer to a socket
-
Errno::EOPNOTSUPP - the socket protocol does not support listen
-
Errno::EACCES - the calling process does not have appropriate privileges
-
Errno::EINVAL - the socket has been shut down
-
Errno::ENOBUFS - insufficient resources are available in the system to complete the call
Windows Exceptions
On Windows systems the following system exceptions may be raised if the call to listen fails:
-
Errno::ENETDOWN - the network is down
-
Errno::EADDRINUSE - the socket's local address is already in use. This usually occurs during the execution of bind but could be delayed if the call to bind was to a partially wildcard address (involving ADDR_ANY) and if a specific address needs to be committed at the time of the call to listen
-
Errno::EINPROGRESS - a Windows Sockets 1.1 call is in progress or the service provider is still processing a callback function
-
Errno::EINVAL - the
socket
has not been bound with a call to bind. -
Errno::EISCONN - the
socket
is already connected -
Errno::EMFILE - no more socket descriptors are available
-
Errno::ENOBUFS - no buffer space is available
-
Errno::ENOTSOC -
socket
is not a socket -
Errno::EOPNOTSUPP - the referenced
socket
is not a type that supports the listen method
See
-
listen manual pages on unix-based systems
-
listen function in Microsoft's Winsock functions reference
497 498 499 500 501 502 503 504 505 506 507 508 509 510 |
# File 'socket.c', line 497
VALUE
rsock_sock_listen(VALUE sock, VALUE log)
{
rb_io_t *fptr;
int backlog;
rb_secure(4);
backlog = NUM2INT(log);
GetOpenFile(sock, fptr);
if (listen(fptr->fd, backlog) < 0)
rb_sys_fail("listen(2)");
return INT2FIX(0);
}
|
#recvfrom(maxlen) ⇒ Array #recvfrom(maxlen, flags) ⇒ Array
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 theMSG_
options
Example
# In one file, start this first require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.bind( sockaddr ) socket.listen( 5 ) client, client_addrinfo = socket.accept data = client.recvfrom( 20 )[0].chomp puts "I only received 20 bytes '#data'" sleep 1 socket.close
# In another file, start this second require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.connect( sockaddr ) socket.puts "Watch this get cut short!" socket.close
Unix-based Exceptions
On unix-based based systems the following system exceptions may be raised if the call to recvfrom fails:
-
Errno::EAGAIN - the
socket
file descriptor is marked as O_NONBLOCK and no data is waiting to be received; or MSG_OOB is set and no out-of-band data is available and either thesocket
file descriptor is marked as O_NONBLOCK or thesocket
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 onsocket
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 withsocket
, orsocket
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.
617 618 619 620 621 |
# File 'socket.c', line 617
static VALUE
sock_recvfrom(int argc, VALUE *argv, VALUE sock)
{
return rsock_s_recvfrom(sock, argc, argv, RECV_SOCKET);
}
|
#recvfrom_nonblock(maxlen) ⇒ Array #recvfrom_nonblock(maxlen, flags) ⇒ Array
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#recvfrom_nonblock returns an empty string as data. The meaning depends on the socket: EOF on TCP, empty packet on UDP, etc.
Parameters
-
maxlen
- the maximum number of bytes to receive from the socket -
flags
- zero or more of theMSG_
options
Example
# In one file, start this first require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(2200, 'localhost') socket.bind(sockaddr) socket.listen(5) client, client_addrinfo = socket.accept begin # emulate blocking recvfrom pair = client.recvfrom_nonblock(20) rescue IO::WaitReadable IO.select() retry end data = pair.chomp puts "I only received 20 bytes '#data'" sleep 1 socket.close
# In another file, start this second require 'socket' include Socket::Constants socket = Socket.new(AF_INET, SOCK_STREAM, 0) sockaddr = Socket.sockaddr_in(2200, 'localhost') socket.connect(sockaddr) socket.puts "Watch this get cut short!" socket.close
Refer to Socket#recvfrom for the exceptions that may be thrown if the call to recvfrom_nonblock fails.
Socket#recvfrom_nonblock may raise any error corresponding to recvfrom(2) failure, including Errno::EWOULDBLOCK.
If the exception is Errno::EWOULDBLOCK or Errno::AGAIN, it is extended by IO::WaitReadable. So IO::WaitReadable can be used to rescue the exceptions for retrying recvfrom_nonblock.
See
-
Socket#recvfrom
685 686 687 688 689 |
# File 'socket.c', line 685
static VALUE
sock_recvfrom_nonblock(int argc, VALUE *argv, VALUE sock)
{
return rsock_s_recvfrom_nonblock(sock, argc, argv, RECV_SOCKET);
}
|
#sysaccept ⇒ Array
Accepts an incoming connection returning an array containing the (integer) file descriptor for the incoming connection, client_socket_fd, and an Addrinfo, client_addrinfo.
Example
# In one script, start this first require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.bind( sockaddr ) socket.listen( 5 ) client_fd, client_addrinfo = socket.sysaccept client_socket = Socket.for_fd( client_fd ) puts "The client said, '#Socket.client_socketclient_socket.readlineclient_socket.readline.chomp'" client_socket.puts "Hello from script one!" socket.close
# In another script, start this second require 'socket' include Socket::Constants socket = Socket.new( AF_INET, SOCK_STREAM, 0 ) sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' ) socket.connect( sockaddr ) socket.puts "Hello from script 2." puts "The server said, '#Socket.socketsocket.readlinesocket.readline.chomp'" socket.close
Refer to Socket#accept for the exceptions that may be thrown if the call to sysaccept fails.
See
-
Socket#accept
821 822 823 824 825 826 827 828 829 830 831 832 833 |
# File 'socket.c', line 821
static VALUE
sock_sysaccept(VALUE sock)
{
rb_io_t *fptr;
VALUE sock2;
struct sockaddr_storage buf;
socklen_t len = (socklen_t)sizeof buf;
GetOpenFile(sock, fptr);
sock2 = rsock_s_accept(0,fptr->fd,(struct sockaddr*)&buf,&len);
return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, (struct sockaddr*)&buf, len));
}
|