123456789_123456789_123456789_123456789_123456789_

Class: Socket

Relationships & Source Files
Namespace Children
Modules:
Constants
Classes:
AncillaryData, HostnameResolutionResult, HostnameResolutionStore, Ifaddr, Option, UDPSource
Exceptions:
ResolutionError
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::BasicSocket, ::IO
Instance Chain:
self, ::BasicSocket, ::IO
Inherits: BasicSocket
Defined in: ext/socket/socket.c,
ext/socket/constdefs.c,
ext/socket/ifaddr.c,
ext/socket/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 Constants are also defined under Socket. For example, AF_INET is usable as well as Constants::AF_INET. See Constants for the list of constants.

What’s a socket?

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

Sockets have their own vocabulary:

domain: The family of protocols:

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

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

hostname: The identifier of a network interface:

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

  • a zero-length string which specifies INADDR_ANY

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

Quick start

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

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

require 'socket'

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

You could also use the ::TCPSocket class:

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

A simple server might look like this:

require 'socket'

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

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

A simple client may look like this:

require 'socket'

s = TCPSocket.new 'localhost', 2000

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

s.close             # close socket when done

Exception Handling

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

Convenience methods

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

TCP client socket

Socket.tcp, TCPSocket.open

TCP server socket

Socket.tcp_server_loop, TCPServer.open

UNIX client socket

Socket.unix, UNIXSocket.open

UNIX server socket

Socket.unix_server_loop, UNIXServer.open

Documentation by

  • Zach Dennis

  • Sam Roberts

  • Programming Ruby from The Pragmatic Bookshelf.

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

Constant Summary

Class Attribute Summary

::BasicSocket - Inherited

.do_not_reverse_lookup

Gets the global do_not_reverse_lookup flag.
.do_not_reverse_lookup=

Sets the global do_not_reverse_lookup flag.

Class Method Summary

::BasicSocket - Inherited

.for_fd

Returns a socket object which contains the file descriptor, fd.

Instance Attribute Summary

::BasicSocket - Inherited

#do_not_reverse_lookup

Gets the do_not_reverse_lookup flag of basicsocket.
#do_not_reverse_lookup=

Sets the do_not_reverse_lookup flag of basicsocket.

Instance Method Summary

::BasicSocket - Inherited

#close_read

Disallows further read using shutdown system call.
#close_write

Disallows further write using shutdown system call.
#connect_address

Returns an address of the socket suitable for connect in the local machine.
#getpeereid

Returns the user and group on the peer of the UNIX socket.
#getpeername

Returns the remote address of the socket as a sockaddr string.
#getsockname

Returns the local address of the socket as a sockaddr string.
#getsockopt

Gets a socket option.
#local_address

Returns an ::Addrinfo object for local address obtained by getsockname.
#recv

Receives a message.
#recv_nonblock

Receives up to maxlen bytes from socket using recvfrom(2) after O_NONBLOCK is set for the underlying file descriptor.
#recvmsg

recvmsg receives a message using recvmsg(2) system call in blocking manner.
#recvmsg_nonblock

recvmsg receives a message using recvmsg(2) system call in non-blocking manner.
#remote_address

Returns an ::Addrinfo object for remote address obtained by getpeername.
#send

send mesg via basicsocket.
#sendmsg

sendmsg sends a message using sendmsg(2) system call in blocking manner.
#sendmsg_nonblock

sendmsg_nonblock sends a message using sendmsg(2) system call in non-blocking manner.
#setsockopt

Sets a socket option.
#shutdown

Calls shutdown(2) system call.
#__recvmsg, #__recvmsg_nonblock, #__sendmsg, #__sendmsg_nonblock, #read_nonblock, #write_nonblock, #__read_nonblock, #__recv_nonblock, #__write_nonblock

Constructor Details

.new(domain, socktype [, protocol]) ⇒ Socket

Creates a new socket object.

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

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

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

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

  


# File 'ext/socket/socket.c', line 136



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

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

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

    return rsock_init_sock(sock, fd);
}


  







Class Attribute Details



  

    .tcp_fast_fallback   (rw)
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 623



attr_accessor :tcp_fast_fallback


  







Class Method Details



  

    .accept_loop(*sockets)  
  



  

    

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.


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1237



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


  








  

    .current_clock_time   (private)
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 981



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


  








  

    .expired?(started_at, ends_at)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 994



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


  








  

    .getaddrinfo(nodename, servname[, family[, socktype[, protocol[, flags[, reverse_lookup]]]]])  ⇒ Array   



  

    

Obtains address information for nodename:servname.



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



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



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



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



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



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

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



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



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



If Addrinfo object is preferred, use Addrinfo.getaddrinfo.


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1158



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

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

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

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

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

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


  








  

    .gethostbyaddr(address_string [, address_family])  ⇒ hostent   



  

    

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


  • 

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

  • 

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

  • 

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




This method obtains the host information for address.



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

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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 995



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

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

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

    return ary;
}


  








  

    .gethostbyname(hostname)  ⇒ Array, ...   



  

    

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


  • 

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

  • 

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

  • 

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

  • 

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




This method obtains the host information for hostname.



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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 961



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


  








  

    .gethostname  ⇒ hostname   



  

    

Returns the hostname.



p Socket.gethostname #=> "hal"



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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 844



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

    long len = RUBY_MAX_HOST_NAME_LEN;
    VALUE name;

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


  








  

    .getifaddrs  ⇒ Array, ...   



  

    

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



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



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



Example result on GNU/Linux:



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



Example result on FreeBSD:



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


  



  [ GitHub ]


  

  


# File 'ext/socket/ifaddr.c', line 444



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


  








  

    .getnameinfo(sockaddr [, flags])  ⇒ Array, servicename   



  

    

Obtains name information for sockaddr.



sockaddr should be one of follows.


  • 

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

  • 

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

  • 

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




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



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



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



If Addrinfo object is preferred, use Addrinfo#getnameinfo.


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1213



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

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

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

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

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

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

    UNREACHABLE_RETURN(Qnil);
}


  








  

    

      .getservbyname(service_name)  ⇒ port_number 
      .getservbyname(service_name, protocol_name)  ⇒ port_number 
    

  



  

    

Obtains the port number for service_name.



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



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


  





  


  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1059



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

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

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


  








  

    .getservbyport(port [, protocol_name])  ⇒ service   



  

    

Obtains the port number for port.



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



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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1100



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

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

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


  








  

    .ip_address?(hostname)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 966



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


  








  

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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1550



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

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

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

    freeifaddrs(ifp);

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

    lc.lifc_buf = NULL;

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

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

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

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

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

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

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

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

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

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

    bufsize = sizeof(initbuf);
    buf = initbuf;

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

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

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

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

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

    close(fd);
    fd = -1;

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

  finish:

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

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

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

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

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

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

    FreeLibrary(h);
    return list;
#endif
}


  








  

    .ip_sockets_port0(ai_list, reuseaddr)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1106



def self.ip_sockets_port0(ai_list, reuseaddr)
  sockets = []
  begin
    sockets.clear
    port = nil
    ai_list.each {|ai|
      begin
        s = Socket.new(ai.pfamily, ai.socktype, ai.protocol)
      rescue SystemCallError
        next
      end
      sockets << s
      s.ipv6only! if ai.ipv6?
      if reuseaddr
        s.setsockopt(:SOCKET, :REUSEADDR, 1)
      end
      unless port
        s.bind(ai)
        port = s.local_address.ip_port
      else
        s.bind(ai.family_addrinfo(ai.ip_address, port))
      end
    }
  rescue Errno::EADDRINUSE
    sockets.each(&:close)
    retry
  rescue Exception
    sockets.each(&:close)
    raise
  end
  sockets
end


  








  

    

      .sockaddr_in(port, host)  ⇒ sockaddr 
      .pack_sockaddr_in(port, host)  ⇒ sockaddr 
    

  



  

    

Alias for .sockaddr_in.


  





  








  

    

      .sockaddr_un(path)  ⇒ sockaddr 
      .pack_sockaddr_un(path)  ⇒ sockaddr 
    

  



  

    

Alias for .sockaddr_un.


  





  








  

    

      .pair(domain, type, protocol)  ⇒ Socket 
      .socketpair(domain, type, protocol)  ⇒ Socket 
    

    Also known as: .socketpair
  



  

    

Creates a pair of sockets connected each other.



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



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



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



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

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


  





  


  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 247



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

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

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

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


  








  

    .resolve_hostname(family, host, port, hostname_resolution_result)   (private)
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 971



def self.resolve_hostname(family, host, port, hostname_resolution_result)
  begin
    resolved_addrinfos = Addrinfo.getaddrinfo(host, port, ADDRESS_FAMILIES[family], :STREAM)
    hostname_resolution_result.add(family, resolved_addrinfos)
  rescue => e
    hostname_resolution_result.add(family, e)
  end
end


  








  

    .second_to_timeout(started_at, ends_at)   (private)
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 986



def self.second_to_timeout(started_at, ends_at)
  return nil if ends_at == Float::INFINITY || ends_at.nil?

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


  








  

    

      .sockaddr_in(port, host)  ⇒ sockaddr 
      .pack_sockaddr_in(port, host)  ⇒ sockaddr 
    

    Also known as: .pack_sockaddr_in
  



  

    

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"


  





  


  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1333



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

    rb_freeaddrinfo(res);

    return addr;
}


  








  

    

      .sockaddr_un(path)  ⇒ sockaddr 
      .pack_sockaddr_un(path)  ⇒ sockaddr 
    

    Also known as: .pack_sockaddr_un
  



  

    

Packs path as an AF_UNIX sockaddr string.



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


  





  


  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1396



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

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

    return addr;
}


  








  

    

      .pair(domain, type, protocol)  ⇒ Socket 
      .socketpair(domain, type, protocol)  ⇒ Socket 
    

  



  

    

Alias for .pair.


  





  








  

    

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

  



  

    

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



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



To make it behave the same as in Ruby 3.3 and earlier, explicitly specify the option fast_fallback:false.



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



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


:resolv_timeout




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


:connect_timeout




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


:fast_fallback




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





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



If no block is given, the socket is returned.



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



Happy Eyeballs Version 2



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



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


  1. 

    Start resolving both IPv6 and IPv4 addresses concurrently.
    

  2. 

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

  3. 

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

  4. 

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



  





  


  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 678



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

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


  








  

    .tcp_server_loop(host = nil, port, &b)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1293



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)  
  



  

    

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



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



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



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



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

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

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

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


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1193



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


  








  

    .tcp_server_sockets_port0(host)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1142



def self.tcp_server_sockets_port0(host)
  ai_list = Addrinfo.getaddrinfo(host, 0, nil, :STREAM, nil, Socket::AI_PASSIVE)
  sockets = ip_sockets_port0(ai_list, true)
  begin
    sockets.each {|s|
      s.listen(Socket::SOMAXCONN)
    }
  rescue Exception
    sockets.each(&:close)
    raise
  end
  sockets
end


  








  

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

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 696



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  hostname_resolution_result&.close

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


  








  

    .tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)   (private)
  

  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 927



def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
  last_error = nil
  ret = nil

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

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

  ret
end


  








  

    

      .udp_server_loop(port) {|msg, msg_src| ... } 
      .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
}


  





  


  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1463



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) {|msg, msg_src| ... }   



  

    

Run UDP/IP server loop on the given sockets.



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



It calls the block for each message received.


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1436



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



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


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1409



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


  








  

    .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 chosen. But the chosen port is used for the all sockets.



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


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1321



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

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

  local_addrs = Socket.ip_address_list

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

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

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

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


  








  

    .unix(path)  
  



  

    

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
}


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1513



def self.unix(path) # :yield: socket
  addr = Addrinfo.unix(path)
  sock = addr.connect
  if block_given?
    begin
      yield sock
    ensure
      sock.close
    end
  else
    sock
  end
end


  








  

    .unix_server_loop(path, &b)  
  



  

    

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
}


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1600



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)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1543



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


  








  

    .unix_socket_abstract_name?(path)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1571



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


  








  

    .unpack_sockaddr_in(sockaddr)  ⇒ Array, ip_address   



  

    

Unpacks sockaddr into port and ip_address.



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



sockaddr = Socket.sockaddr_in(80, "127.0.0.1")
p sockaddr #=> "\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"]


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1357



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

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


  








  

    .unpack_sockaddr_un(sockaddr)  ⇒ path   



  

    

Unpacks sockaddr into path.



sockaddr should be a string or an addrinfo for AF_UNIX.



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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 1426



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

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


  







Instance Method Details



  

    #__accept_nonblock(ex)   (private)
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 766



static VALUE
sock_accept_nonblock(VALUE sock, VALUE ex)
{
    rb_io_t *fptr;
    VALUE sock2;
    union_sockaddr buf;
    struct sockaddr *addr = &buf.addr;
    socklen_t len = (socklen_t)sizeof buf;

    GetOpenFile(sock, fptr);
    sock2 = rsock_s_accept_nonblock(rb_cSocket, ex, fptr, addr, &len);

    if (SYMBOL_P(sock2)) /* :wait_readable */
        return sock2;
    return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, &buf.addr, len));
}


  








  

    #__connect_nonblock(addr, ex)   (private)
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 407



static VALUE
sock_connect_nonblock(VALUE sock, VALUE addr, VALUE ex)
{
    VALUE rai;
    rb_io_t *fptr;
    int n;

    SockAddrStringValueWithAddrinfo(addr, rai);
    addr = rb_str_new4(addr);
    GetOpenFile(sock, fptr);
    rb_io_set_nonblock(fptr);
    n = connect(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr));
    if (n < 0) {
        int e = errno;
        if (e == EINPROGRESS) {
            if (ex == Qfalse) {
                return sym_wait_writable;
            }
            rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e, "connect(2) would block");
        }
        if (e == EISCONN) {
            if (ex == Qfalse) {
                return INT2FIX(0);
            }
        }
        rsock_syserr_fail_raddrinfo_or_sockaddr(e, "connect(2)", addr, rai);
    }

    return INT2FIX(n);
}


  








  

    #__recvfrom_nonblock(len, flg, str, ex)   (private)
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 734



static VALUE
sock_recvfrom_nonblock(VALUE sock, VALUE len, VALUE flg, VALUE str, VALUE ex)
{
    return rsock_s_recvfrom_nonblock(sock, len, flg, str, ex, RECV_SOCKET);
}


  








  

    #accept  ⇒ Socket, client_addrinfo   



  

    

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



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


  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 754



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

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

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


  








  

    #accept_nonblock([options])  ⇒ Socket, client_addrinfo   



  

    

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



Example



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

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



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



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



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



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



See



  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 598



def accept_nonblock(exception: true)
  __accept_nonblock(exception)
end


  








  

    #bind(local_sockaddr)  ⇒ 0   



  

    

Binds to the given local address.



Parameter


  • 

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




Example



require 'socket'

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

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



Unix-based Exceptions



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


  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

    Errno::EFAULT - the sockaddr argument cannot be accessed
    

  • 

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

  • 

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

  • 

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

  • 

    Errno::ENOBUFS - no buffer space is available
    

  • 

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

  • 

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

  • 

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




On unix-based based systems if the address family of the calling socket is 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
    



  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 524



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

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

    return INT2FIX(0);
}


  








  

    #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 - the struct sockaddr contained in a string or ::Addrinfo object
    




Example:



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



Unix-based Exceptions



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


  • 

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

  • 

    Errno::EADDRINUSE - the sockaddr is already in use
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

    Errno::EFAULT - the sockaddr cannot be accessed
    

  • 

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

  • 

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

  • 

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

  • 

    Errno::EISCONN - the specified socket is already connected
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

    Errno::ENOBUFS - no buffer space is available
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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




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


  • 

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

  • 

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

  • 

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

  • 

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

  • 

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




Windows Exceptions



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


  • 

    Errno::ENETDOWN - the network is down
    

  • 

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

  • 

    Errno::EINTR - the socket was cancelled
    

  • 

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

  • 

    Errno::EALREADY - see Errno::EINVAL
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

    Errno::EINVAL - the socket is a listening socket
    

  • 

    Errno::EISCONN - the socket is already connected
    

  • 

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

  • 

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

  • 

    Errno::ENOBUFS - no buffer space is available
    

  • 

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

  • 

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

  • 

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

  • 

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




See


  • 

    connect manual pages on unix-based systems
    

  • 

    connect function in Microsoft’s Winsock functions reference
    



  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 389



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

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

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

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

    return INT2FIX(result);
}


  








  

    #connect_nonblock(remote_sockaddr, [options])  ⇒ 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} - the {struct} sockaddr contained in a string or Addrinfo object



Example:



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



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



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



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



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



See



# Socket#connect


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 1650



def connect_nonblock(addr, exception: true)
  __connect_nonblock(addr, exception)
end


  








  

    #ipv6only!  
  



  

    

enable the socket option IPV6_V6ONLY if IPV6_V6ONLY is available.


  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 468



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
    



  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 608



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

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

    return INT2FIX(0);
}


  








  

    

      #recvfrom(maxlen)  ⇒ Array, sender_addrinfo 
      #recvfrom(maxlen, flags)  ⇒ Array, sender_addrinfo 
    

  



  

    

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



Parameters


  • 

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

  • 

    flags - zero or more of the MSG_ options
    




Example



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

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



Unix-based Exceptions



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


  • 

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

  • 

    Errno::EWOULDBLOCK - see Errno::EAGAIN
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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




Windows Exceptions



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


  • 

    Errno::ENETDOWN - the network is down
    

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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

  • 

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



  





  


  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 727



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


  








  

    #recvfrom_nonblock(maxlen[, flags[, outbuf[, opts]]])  ⇒ Array, sender_addrinfo   



  

    

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



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



Parameters


  • 

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

  • 

    flags - zero or more of the MSG_ options
    

  • 

    outbuf - destination String buffer
    

  • 

    opts - keyword hash, supporting exception: false
    




Example



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

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



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



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



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



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



See



  



  [ GitHub ]


  

  


# File 'ext/socket/lib/socket.rb', line 541



def recvfrom_nonblock(len, flag = 0, str = nil, exception: true)
  __recvfrom_nonblock(len, flag, str, exception)
end


  








  

    #sysaccept  ⇒ Socket, client_addrinfo   



  

    

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



Example



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

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



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



See



  



  [ GitHub ]


  

  


# File 'ext/socket/socket.c', line 821



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

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

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