# File ext/socket/lib/socket.rb, line 1241defself.accept_loop(*sockets)# :yield: socket, client_addrinfosockets.flatten!(1)ifsockets.empty?raiseArgumentError,"no sockets"endloop {readable,_,_ =IO.select(sockets)readable.each {|r|sock,addr =r.accept_nonblock(exception:false)nextifsock==:wait_readableyieldsock,addr    }  }end

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

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

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

static VALUEsock_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, 0);    ret = make_addrinfo(res, norevlookup);    rb_freeaddrinfo(res);    return ret;}

Obtains address information fornodename:servname.

Note thatAddrinfo.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_TCPSocket.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. Ifreverse_lookup is omitted, the default value isnil.

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

IfAddrinfo object is preferred, useAddrinfo.getaddrinfo.

static VALUEsock_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;}

UseAddrinfo#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 foraddress.

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

static VALUEsock_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, 0);    return rsock_make_hostent(host, res, sock_sockaddr);}

UseAddrinfo.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 forhostname.

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

static VALUEsock_gethostname(VALUE obj){#if defined(NI_MAXHOST)#  define RUBY_MAX_HOST_NAME_LEN NI_MAXHOST#elif defined(HOST_NAME_MAX)#  define RUBY_MAX_HOST_NAME_LEN HOST_NAME_MAX#else#  define RUBY_MAX_HOST_NAME_LEN 1024#endif    long len = RUBY_MAX_HOST_NAME_LEN;    VALUE name;    name = rb_str_new(0, len);    while (gethostname(RSTRING_PTR(name), len) < 0) {        int e = errno;        switch (e) {          case ENAMETOOLONG:#ifdef __linux__          case EINVAL:            /* glibc before version 2.1 uses EINVAL instead of ENAMETOOLONG */#endif            break;          default:            rb_syserr_fail(e, "gethostname(3)");        }        rb_str_modify_expand(name, len);        len += len;    }    rb_str_resize(name, strlen(RSTRING_PTR(name)));    return name;}

Returns the hostname.

pSocket.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, useSocket.ip_address_list.

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

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

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

ppSocket.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:

ppSocket.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:

ppSocket.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)>]

static VALUEsock_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, 0);        sap = res->ai->ai_addr;        salen = res->ai->ai_addrlen;    }    else {        rb_raise(rb_eTypeError, "expecting String or Array");    }  call_nameinfo:    error = rb_getnameinfo(sap, salen, hbuf, sizeof(hbuf),                           pbuf, sizeof(pbuf), fl);    if (error) goto error_exit_name;    if (res) {        for (r = res->ai->ai_next; r; r = r->ai_next) {            char hbuf2[1024], pbuf2[1024];            sap = r->ai_addr;            salen = r->ai_addrlen;            error = rb_getnameinfo(sap, salen, hbuf2, sizeof(hbuf2),                                   pbuf2, sizeof(pbuf2), fl);            if (error) goto error_exit_name;            if (strcmp(hbuf, hbuf2) != 0|| strcmp(pbuf, pbuf2) != 0) {                rb_freeaddrinfo(res);                rb_raise(rb_eSocket, "sockaddr resolved to multiple nodename");            }        }        rb_freeaddrinfo(res);    }    return rb_assoc_new(rb_str_new2(hbuf), rb_str_new2(pbuf));  error_exit_name:    saved_errno = errno;    if (res) rb_freeaddrinfo(res);    errno = saved_errno;    rsock_raise_resolution_error("getnameinfo", error);    UNREACHABLE_RETURN(Qnil);}

Obtains name information forsockaddr.

sockaddr should be one of follows.

• packed sockaddr string such asSocket.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 withIPSocket#addr andIPSocket#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"]

IfAddrinfo object is preferred, useAddrinfo#getnameinfo.

static VALUEsock_s_getservbyname(int argc, VALUE *argv, VALUE _){    VALUE service, proto;    struct servent *sp;    long port;    const char *servicename, *protoname = "tcp";    rb_scan_args(argc, argv, "11", &service, &proto);    StringValue(service);    if (!NIL_P(proto)) StringValue(proto);    servicename = StringValueCStr(service);    if (!NIL_P(proto)) protoname = StringValueCStr(proto);    sp = getservbyname(servicename, protoname);    if (sp) {        port = ntohs(sp->s_port);    }    else {        char *end;        port = STRTOUL(servicename, &end, 0);        if (*end != '\0') {            rb_raise(rb_eSocket, "no such service %s/%s", servicename, protoname);        }    }    return INT2FIX(port);}

Obtains the port number forservice_name.

Ifprotocol_name is not given, “tcp” is assumed.

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

static VALUEsock_s_getservbyport(int argc, VALUE *argv, VALUE _){    VALUE port, proto;    struct servent *sp;    long portnum;    const char *protoname = "tcp";    rb_scan_args(argc, argv, "11", &port, &proto);    portnum = NUM2LONG(port);    if (portnum != (uint16_t)portnum) {        const char *s = portnum > 0 ? "big" : "small";        rb_raise(rb_eRangeError, "integer %ld too %s to convert into `int16_t'", portnum, s);    }    if (!NIL_P(proto)) protoname = StringValueCStr(proto);    sp = getservbyport((int)htons((uint16_t)portnum), protoname);    if (!sp) {        rb_raise(rb_eSocket, "no such service for port %d/%s", (int)portnum, protoname);    }    return rb_str_new2(sp->s_name);}

Obtains the port number forport.

Ifprotocol_name is not given, “tcp” is assumed.

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

static VALUEsocket_s_ip_address_list(VALUE self){#if defined(HAVE_GETIFADDRS)    struct ifaddrs *ifp = NULL;    struct ifaddrs *p;    int ret;    VALUE list;    ret = getifaddrs(&ifp);    if (ret == -1) {        rb_sys_fail("getifaddrs");    }    list = rb_ary_new();    for (p = ifp; p; p = p->ifa_next) {        if (p->ifa_addr != NULL && IS_IP_FAMILY(p->ifa_addr->sa_family)) {            struct sockaddr *addr = p->ifa_addr;#if defined(AF_INET6) && defined(__sun)            /*             * OpenIndiana SunOS 5.11 getifaddrs() returns IPv6 link local             * address with sin6_scope_id == 0.             * So fill it from the interface name (ifa_name).             */            struct sockaddr_in6 addr6;            if (addr->sa_family == AF_INET6) {                socklen_t len = (socklen_t)sizeof(struct sockaddr_in6);                memcpy(&addr6, addr, len);                addr = (struct sockaddr *)&addr6;                if (IN6_IS_ADDR_LINKLOCAL(&addr6.sin6_addr) &&                    addr6.sin6_scope_id == 0) {                    unsigned int ifindex = if_nametoindex(p->ifa_name);                    if (ifindex != 0) {                        addr6.sin6_scope_id = ifindex;                    }                }            }#endif            rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));        }    }    freeifaddrs(ifp);    return list;#elif defined(SIOCGLIFCONF) && defined(SIOCGLIFNUM)    /* Solaris if_tcp(7P) */    int fd = -1;    int ret;    struct lifnum ln;    struct lifconf lc;    const char *reason = NULL;    int save_errno;    int i;    VALUE list = Qnil;    lc.lifc_buf = NULL;    fd = socket(AF_INET, SOCK_DGRAM, 0);    if (fd == -1)        rb_sys_fail("socket(2)");    memset(&ln, 0, sizeof(ln));    ln.lifn_family = AF_UNSPEC;    ret = ioctl(fd, SIOCGLIFNUM, &ln);    if (ret == -1) {        reason = "SIOCGLIFNUM";        goto finish;    }    memset(&lc, 0, sizeof(lc));    lc.lifc_family = AF_UNSPEC;    lc.lifc_flags = 0;    lc.lifc_len = sizeof(struct lifreq) * ln.lifn_count;    lc.lifc_req = xmalloc(lc.lifc_len);    ret = ioctl(fd, SIOCGLIFCONF, &lc);    if (ret == -1) {        reason = "SIOCGLIFCONF";        goto finish;    }    list = rb_ary_new();    for (i = 0; i < ln.lifn_count; i++) {        struct lifreq *req = &lc.lifc_req[i];        if (IS_IP_FAMILY(req->lifr_addr.ss_family)) {            if (req->lifr_addr.ss_family == AF_INET6 &&                IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_addr) &&                ((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_scope_id == 0) {                struct lifreq req2;                memcpy(req2.lifr_name, req->lifr_name, LIFNAMSIZ);                ret = ioctl(fd, SIOCGLIFINDEX, &req2);                if (ret == -1) {                    reason = "SIOCGLIFINDEX";                    goto finish;                }                ((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_scope_id = req2.lifr_index;            }            rb_ary_push(list, sockaddr_obj((struct sockaddr *)&req->lifr_addr, req->lifr_addrlen));        }    }  finish:    save_errno = errno;    xfree(lc.lifc_req);    if (fd != -1)        close(fd);    errno = save_errno;    if (reason)        rb_syserr_fail(save_errno, reason);    return list;#elif defined(SIOCGIFCONF)    int fd = -1;    int ret;#define EXTRA_SPACE ((int)(sizeof(struct ifconf) + sizeof(union_sockaddr)))    char initbuf[4096+EXTRA_SPACE];    char *buf = initbuf;    int bufsize;    struct ifconf conf;    struct ifreq *req;    VALUE list = Qnil;    const char *reason = NULL;    int save_errno;    fd = socket(AF_INET, SOCK_DGRAM, 0);    if (fd == -1)        rb_sys_fail("socket(2)");    bufsize = sizeof(initbuf);    buf = initbuf;  retry:    conf.ifc_len = bufsize;    conf.ifc_req = (struct ifreq *)buf;    /* fprintf(stderr, "bufsize: %d\n", bufsize); */    ret = ioctl(fd, SIOCGIFCONF, &conf);    if (ret == -1) {        reason = "SIOCGIFCONF";        goto finish;    }    /* fprintf(stderr, "conf.ifc_len: %d\n", conf.ifc_len); */    if (bufsize - EXTRA_SPACE < conf.ifc_len) {        if (bufsize < conf.ifc_len) {            /* NetBSD returns required size for all interfaces. */            bufsize = conf.ifc_len + EXTRA_SPACE;        }        else {            bufsize = bufsize << 1;        }        if (buf == initbuf)            buf = NULL;        buf = xrealloc(buf, bufsize);        goto retry;    }    close(fd);    fd = -1;    list = rb_ary_new();    req = conf.ifc_req;    while ((char*)req < (char*)conf.ifc_req + conf.ifc_len) {        struct sockaddr *addr = &req->ifr_addr;        if (IS_IP_FAMILY(addr->sa_family)) {            rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));        }#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN# ifndef _SIZEOF_ADDR_IFREQ#  define _SIZEOF_ADDR_IFREQ(r) \          (sizeof(struct ifreq) + \           (sizeof(struct sockaddr) < (r).ifr_addr.sa_len ? \            (r).ifr_addr.sa_len - sizeof(struct sockaddr) : \            0))# endif        req = (struct ifreq *)((char*)req + _SIZEOF_ADDR_IFREQ(*req));#else        req = (struct ifreq *)((char*)req + sizeof(struct ifreq));#endif    }  finish:    save_errno = errno;    if (buf != initbuf)        xfree(buf);    if (fd != -1)        close(fd);    errno = save_errno;    if (reason)        rb_syserr_fail(save_errno, reason);    return list;#undef EXTRA_SPACE#elif defined(_WIN32)    typedef struct ip_adapter_unicast_address_st {        unsigned LONG_LONG dummy0;        struct ip_adapter_unicast_address_st *Next;        struct {            struct sockaddr *lpSockaddr;            int iSockaddrLength;        } Address;        int dummy1;        int dummy2;        int dummy3;        long dummy4;        long dummy5;        long dummy6;    } ip_adapter_unicast_address_t;    typedef struct ip_adapter_anycast_address_st {        unsigned LONG_LONG dummy0;        struct ip_adapter_anycast_address_st *Next;        struct {            struct sockaddr *lpSockaddr;            int iSockaddrLength;        } Address;    } ip_adapter_anycast_address_t;    typedef struct ip_adapter_addresses_st {        unsigned LONG_LONG dummy0;        struct ip_adapter_addresses_st *Next;        void *dummy1;        ip_adapter_unicast_address_t *FirstUnicastAddress;        ip_adapter_anycast_address_t *FirstAnycastAddress;        void *dummy2;        void *dummy3;        void *dummy4;        void *dummy5;        void *dummy6;        BYTE dummy7[8];        DWORD dummy8;        DWORD dummy9;        DWORD dummy10;        DWORD IfType;        int OperStatus;        DWORD dummy12;        DWORD dummy13[16];        void *dummy14;    } ip_adapter_addresses_t;    typedef ULONG (WINAPI *GetAdaptersAddresses_t)(ULONG, ULONG, PVOID, ip_adapter_addresses_t *, PULONG);    HMODULE h;    GetAdaptersAddresses_t pGetAdaptersAddresses;    ULONG len;    DWORD ret;    ip_adapter_addresses_t *adapters;    VALUE list;    h = LoadLibrary("iphlpapi.dll");    if (!h)        rb_notimplement();    pGetAdaptersAddresses = (GetAdaptersAddresses_t)GetProcAddress(h, "GetAdaptersAddresses");    if (!pGetAdaptersAddresses) {        FreeLibrary(h);        rb_notimplement();    }    ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &len);    if (ret != ERROR_SUCCESS && ret != ERROR_BUFFER_OVERFLOW) {        errno = rb_w32_map_errno(ret);        FreeLibrary(h);        rb_sys_fail("GetAdaptersAddresses");    }    adapters = (ip_adapter_addresses_t *)ALLOCA_N(BYTE, len);    ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &len);    if (ret != ERROR_SUCCESS) {        errno = rb_w32_map_errno(ret);        FreeLibrary(h);        rb_sys_fail("GetAdaptersAddresses");    }    list = rb_ary_new();    for (; adapters; adapters = adapters->Next) {        ip_adapter_unicast_address_t *uni;        ip_adapter_anycast_address_t *any;        if (adapters->OperStatus != 1)  /* 1 means IfOperStatusUp */            continue;        for (uni = adapters->FirstUnicastAddress; uni; uni = uni->Next) {#ifndef INET6            if (uni->Address.lpSockaddr->sa_family == AF_INET)#else            if (IS_IP_FAMILY(uni->Address.lpSockaddr->sa_family))#endif                rb_ary_push(list, sockaddr_obj(uni->Address.lpSockaddr, uni->Address.iSockaddrLength));        }        for (any = adapters->FirstAnycastAddress; any; any = any->Next) {#ifndef INET6            if (any->Address.lpSockaddr->sa_family == AF_INET)#else            if (IS_IP_FAMILY(any->Address.lpSockaddr->sa_family))#endif                rb_ary_push(list, sockaddr_obj(any->Address.lpSockaddr, any->Address.iSockaddrLength));        }    }    FreeLibrary(h);    return list;#endif}

Returns local IP addresses as an array.

The array containsAddrinfo objects.

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

static VALUEsock_initialize(int argc, VALUE *argv, VALUE sock){    VALUE domain, type, protocol;    int fd;    int d, t;    rb_scan_args(argc, argv, "21", &domain, &type, &protocol);    if (NIL_P(protocol))        protocol = INT2FIX(0);    setup_domain_and_type(domain, &d, type, &t);    fd = rsock_socket(d, t, NUM2INT(protocol));    if (fd < 0) rb_sys_fail("socket(2)");    return rsock_init_sock(sock, fd);}

Creates a new socket object.

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

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

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

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

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

Packsport andhost 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"

static VALUEsock_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;}

Packspath as anAF_UNIX sockaddr string.

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

VALUErsock_sock_s_socketpair(int argc, VALUE *argv, VALUE klass){    VALUE domain, type, protocol;    int d, t, p, sp[2];    int ret;    VALUE s1, s2, r;    rb_scan_args(argc, argv, "21", &domain, &type, &protocol);    if (NIL_P(protocol))        protocol = INT2FIX(0);    setup_domain_and_type(domain, &d, type, &t);    p = NUM2INT(protocol);    ret = rsock_socketpair(d, t, p, sp);    if (ret < 0) {        rb_sys_fail("socketpair(2)");    }    s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);    s2 = rsock_init_sock(rb_obj_alloc(klass), sp[1]);    r = rb_assoc_new(s1, s2);    if (rb_block_given_p()) {        return rb_ensure(pair_yield, r, io_close, s1);    }    return r;}

Creates a pair of sockets connected each other.

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

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

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

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

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

Packsport andhost 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"

static VALUEsock_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;}

Packspath as anAF_UNIX sockaddr string.

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

VALUErsock_sock_s_socketpair(int argc, VALUE *argv, VALUE klass){    VALUE domain, type, protocol;    int d, t, p, sp[2];    int ret;    VALUE s1, s2, r;    rb_scan_args(argc, argv, "21", &domain, &type, &protocol);    if (NIL_P(protocol))        protocol = INT2FIX(0);    setup_domain_and_type(domain, &d, type, &t);    p = NUM2INT(protocol);    ret = rsock_socketpair(d, t, p, sp);    if (ret < 0) {        rb_sys_fail("socketpair(2)");    }    s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);    s2 = rsock_init_sock(rb_obj_alloc(klass), sp[1]);    r = rb_assoc_new(s1, s2);    if (rb_block_given_p()) {        return rb_ensure(pair_yield, r, io_close, s1);    }    return r;}

Creates a pair of sockets connected each other.

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

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

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

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

# File ext/socket/lib/socket.rb, line 660defself.tcp(host,port,local_host =nil,local_port =nil,connect_timeout:nil,resolv_timeout:nil,open_timeout:nil,fast_fallback:tcp_fast_fallback,&)# :yield: socketifopen_timeout&& (connect_timeout||resolv_timeout)raiseArgumentError,"Cannot specify open_timeout along with connect_timeout or resolv_timeout"endsock =iffast_fallback&&!(host&&ip_address?(host))tcp_with_fast_fallback(host,port,local_host,local_port,connect_timeout:,resolv_timeout:,open_timeout:)elsetcp_without_fast_fallback(host,port,local_host,local_port,connect_timeout:,resolv_timeout:,open_timeout:)endifblock_given?beginyieldsockensuresock.closeendelsesockendend

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

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

For details on Happy Eyeballs Version 2, seeSocket.tcp_fast_fallback=.

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

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

The optional last argumentopts 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.
Theconnect_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.
Whenfast_fallback:false is explicitly specified,
a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.

:open_timeout

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

:fast_fallback

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

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

If no block is given, the socket is returned.

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

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

Returns whether Happy Eyeballs Version 2 (RFC 8305), which is provided starting from Ruby 3.4 when usingTCPSocket.new andSocket.tcp, is enabled or disabled.

If true, it is enabled forTCPSocket.new andSocket.tcp. (Note: Happy Eyeballs Version 2 is not provided when usingTCPSocket.new on Windows.)

If false, Happy Eyeballs Version 2 is disabled.

For details on Happy Eyeballs Version 2, seeSocket.tcp_fast_fallback=.

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

Enable or disable Happy Eyeballs Version 2 (RFC 8305) globally, which is provided starting from Ruby 3.4 when usingTCPSocket.new andSocket.tcp.

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

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

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

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

Happy Eyeballs Version 2¶↑

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

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

1. Start resolving both IPv6 and IPv4 addresses concurrently.

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

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

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

# File ext/socket/lib/socket.rb, line 1297defself.tcp_server_loop(host=nil,port,&b)# :yield: socket, client_addrinfotcp_server_sockets(host,port) {|sockets|accept_loop(sockets,&b)  }end

creates a TCP/IP server onport and calls the block for each connection accepted. The block is called with a socket and a client_address as anAddrinfo object.

Ifhost is specified, it is used withport to determine the server addresses.

The socket isnot 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 thatAddrinfo.getaddrinfo is used to determine the server socket addresses. WhenAddrinfo.getaddrinfo returns two or more addresses, IPv4 and IPv6 address for example, all of them are used.Socket.tcp_server_loop succeeds if one socket can be used at least.

# Sequential echo server.# It services only one client at a time.Socket.tcp_server_loop(16807) {|sock,client_addrinfo|beginIO.copy_stream(sock,sock)ensuresock.closeend}# 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 {beginIO.copy_stream(sock,sock)ensuresock.closeend  }}

# File ext/socket/lib/socket.rb, line 1197defself.tcp_server_sockets(host=nil,port)ifport==0sockets =tcp_server_sockets_port0(host)elselast_error =nilsockets = []beginAddrinfo.foreach(host,port,nil,:STREAM,nil,Socket::AI_PASSIVE) {|ai|begins =ai.listenrescueSystemCallErrorlast_error =$!nextendsockets<<s      }ifsockets.empty?raiselast_errorendrescueExceptionsockets.each(&:close)raiseendendifblock_given?beginyieldsocketsensuresockets.each(&:close)endelsesocketsendend

creates TCP/IP server sockets forhost andport.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.

Ifport 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)psockets#=> [#<Socket:fd 3>, #<Socket:fd 4>]# The sockets contains IPv6 and IPv4 sockets.sockets.each {|s|ps.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|ps.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|psockets#=> [#<Socket:fd 3>, #<Socket:fd 4>]}

# File ext/socket/lib/socket.rb, line 1467defself.udp_server_loop(host=nil,port,&b)# :yield: message, message_sourceudp_server_sockets(host,port) {|sockets|udp_server_loop_on(sockets,&b)  }end

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

This method allocates sockets internally usingport. Ifhost is specified, it is used conjunction withport to determine the server addresses.

Themsg is a string.

Themsg_src is aSocket::UDPSource object. It is used for reply.

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

# File ext/socket/lib/socket.rb, line 1440defself.udp_server_loop_on(sockets,&b)# :yield: msg, msg_srcloop {readable,_,_ =IO.select(sockets)udp_server_recv(readable,&b)  }end

Run UDP/IP server loop on the given sockets.

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

It calls the block for each message received.

# File ext/socket/lib/socket.rb, line 1413defself.udp_server_recv(sockets)sockets.each {|r|msg,sender_addrinfo,_,*controls =r.recvmsg_nonblock(exception:false)nextifmsg==:wait_readableai =r.local_addressifai.ipv6?andpktinfo =controls.find {|c|c.cmsg_is?(:IPV6,:PKTINFO) }ai =Addrinfo.udp(pktinfo.ipv6_pktinfo_addr.ip_address,ai.ip_port)yieldmsg,UDPSource.new(sender_addrinfo,ai) {|reply_msg|r.sendmsgreply_msg,0,sender_addrinfo,pktinfo      }elseyieldmsg,UDPSource.new(sender_addrinfo,ai) {|reply_msg|r.sendreply_msg,0,sender_addrinfo      }end  }end

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

The block receivesmsg andmsg_src.msg is a string which is the payload of the received packet.msg_src is aSocket::UDPSource object which is used for reply.

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

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

# File ext/socket/lib/socket.rb, line 1325defself.udp_server_sockets(host=nil,port)last_error =nilsockets = []ipv6_recvpktinfo =nilifdefined?Socket::AncillaryDataifdefined?Socket::IPV6_RECVPKTINFO# RFC 3542ipv6_recvpktinfo =Socket::IPV6_RECVPKTINFOelsifdefined?Socket::IPV6_PKTINFO# RFC 2292ipv6_recvpktinfo =Socket::IPV6_PKTINFOendendlocal_addrs =Socket.ip_address_listip_list = []Addrinfo.foreach(host,port,nil,:DGRAM,nil,Socket::AI_PASSIVE) {|ai|ifai.ipv4?&&ai.ip_address=="0.0.0.0"local_addrs.each {|a|nextunlessa.ipv4?ip_list<<Addrinfo.new(a.to_sockaddr,:INET,:DGRAM,0);      }elsifai.ipv6?&&ai.ip_address=="::"&&!ipv6_recvpktinfolocal_addrs.each {|a|nextunlessa.ipv6?ip_list<<Addrinfo.new(a.to_sockaddr,:INET6,:DGRAM,0);      }elseip_list<<aiend  }ip_list.uniq!(&:to_sockaddr)ifport==0sockets =ip_sockets_port0(ip_list,false)elseip_list.each {|ip|ai =Addrinfo.udp(ip.ip_address,port)begins =ai.bindrescueSystemCallErrorlast_error =$!nextendsockets<<s    }ifsockets.empty?raiselast_errorendendsockets.each {|s|ai =s.local_addressifipv6_recvpktinfo&&ai.ipv6?&&ai.ip_address=="::"s.setsockopt(:IPV6,ipv6_recvpktinfo,1)end  }ifblock_given?beginyieldsocketsensuresockets.each(&:close)ifsocketsendelsesocketsendend

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.

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

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

# File ext/socket/lib/socket.rb, line 1517defself.unix(path)# :yield: socketaddr =Addrinfo.unix(path)sock =addr.connectifblock_given?beginyieldsockensuresock.closeendelsesockendend

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}

# File ext/socket/lib/socket.rb, line 1604defself.unix_server_loop(path,&b)# :yield: socket, client_addrinfounix_server_socket(path) {|serv|accept_loop(serv,&b)  }end

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

Ifhost is specified, it is used withport to determine the server ports.

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

This method deletes the socket file pointed bypath 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 ofpath 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|beginIO.copy_stream(sock,sock)ensuresock.closeend}

# File ext/socket/lib/socket.rb, line 1547defself.unix_server_socket(path)unlessunix_socket_abstract_name?(path)beginst =File.lstat(path)rescueErrno::ENOENTendifst&.socket?&&st.owned?File.unlinkpathendends =Addrinfo.unix(path).listenifblock_given?beginyieldsensures.closeunlessunix_socket_abstract_name?(path)File.unlinkpathendendelsesendend

creates a UNIX server socket onpath

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")psocket#=> #<Socket:fd 3>psocket.local_address#=> #<Addrinfo: /tmp/s SOCK_STREAM>Socket.unix_server_socket("/tmp/sock") {|s|ps#=> #<Socket:fd 3>ps.local_address#=> # #<Addrinfo: /tmp/sock SOCK_STREAM>}

static VALUEsock_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);}

Unpackssockaddr 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")psockaddr#=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"pSocket.unpack_sockaddr_in(sockaddr)#=> [80, "127.0.0.1"]

static VALUEsock_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;}

Unpackssockaddr into path.

sockaddr should be a string or an addrinfo forAF_UNIX.

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

static VALUEsock_accept(VALUE server){    union_sockaddr buffer;    socklen_t length = (socklen_t)sizeof(buffer);    VALUE peer = rsock_s_accept(rb_cSocket, server, &buffer.addr, &length);    return rb_assoc_new(peer, rsock_io_socket_addrinfo(peer, &buffer.addr, length));}

Accepts a next connection. Returns a newSocket object andAddrinfo object.

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

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

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

Example¶↑

# In one script, start this firstrequire'socket'includeSocket::Constantssocket =Socket.new(AF_INET,SOCK_STREAM,0)sockaddr =Socket.sockaddr_in(2200,'localhost')socket.bind(sockaddr)socket.listen(5)begin# emulate blocking acceptclient_socket,client_addrinfo =socket.accept_nonblockrescueIO::WaitReadable,Errno::EINTRIO.select([socket])retryendputs"The client said, '#{client_socket.readline.chomp}'"client_socket.puts"Hello from script one!"socket.close# In another script, start this secondrequire'socket'includeSocket::Constantssocket =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 toSocket#accept for the exceptions that may be thrown if the call toaccept_nonblock fails.

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

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

By specifying a keyword argumentexception tofalse, you can indicate thataccept_nonblock should not raise anIO::WaitReadable exception, but return the symbol:wait_readable instead.

See¶↑

• Socket#accept

static VALUEsock_bind(VALUE sock, VALUE addr){    VALUE rai;    rb_io_t *fptr;    SockAddrStringValueWithAddrinfo(addr, rai);    GetOpenFile(sock, fptr);    if (bind(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr)) < 0)        rsock_sys_fail_raddrinfo_or_sockaddr("bind(2)", addr, rai);    return INT2FIX(0);}

Binds to the given local address.

Parameter¶↑

• local_sockaddr - thestruct sockaddr contained in a string or anAddrinfo object

Example¶↑

require'socket'# use Addrinfosocket =Socket.new(:INET,:STREAM,0)socket.bind(Addrinfo.tcp("127.0.0.1",2222))psocket.local_address#=> #<Addrinfo: 127.0.0.1:2222 TCP># use struct sockaddrincludeSocket::Constantssocket =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 tobind fails:

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

• Errno::EADDRINUSE - the specifiedsockaddr is already in use

• Errno::EADDRNOTAVAIL - the specifiedsockaddr is not available from the local machine

• Errno::EAFNOSUPPORT - the specifiedsockaddr is not a valid address for the family of the callingsocket

• Errno::EBADF - thesockaddr specified is not a valid file descriptor

• Errno::EFAULT - thesockaddr argument cannot be accessed

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

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

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

• Errno::ENOBUFS - no buffer space is available

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

• Errno::ENOTSOCK - thesocket does not refer to a socket

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

On unix-based based systems if the address family of the callingsocket isSocket::AF_UNIX the follow exceptions may be raised if the call tobind fails:

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

• Errno::EDESTADDRREQ - thesockaddr 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 insockaddr

• 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 insockaddr 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 tobind 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 - thesocket is already bound to an address

• Errno::ENOBUFS - no buffer space is available

• Errno::ENOTSOCK - thesocket argument does not refer to a socket

See¶↑

• bind manual pages on unix-based systems

• bind function in Microsoft’s Winsock functions reference

static VALUEsock_connect(VALUE self, VALUE addr){    VALUE rai;    SockAddrStringValueWithAddrinfo(addr, rai);    addr = rb_str_new4(addr);    int result = rsock_connect(self, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr), 0, RUBY_IO_TIMEOUT_DEFAULT);    if (result < 0) {        rsock_sys_fail_raddrinfo_or_sockaddr("connect(2)", addr, rai);    }    return INT2FIX(result);}

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

Parameter¶↑

• remote_sockaddr - thestruct sockaddr contained in a string orAddrinfo object

Example:¶↑

# Pull down Google's web pagerequire'socket'includeSocket::Constantssocket =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 toconnect fails:

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

• Errno::EADDRINUSE - thesockaddr is already in use

• Errno::EADDRNOTAVAIL - the specifiedsockaddr is not available from the local machine

• Errno::EAFNOSUPPORT - the specifiedsockaddr is not a valid address for the address family of the specifiedsocket

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

• Errno::EBADF - thesocket is not a valid file descriptor

• Errno::ECONNREFUSED - the targetsockaddr was not listening for connections refused the connection request

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

• Errno::EFAULT - thesockaddr 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 thesocket 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 specifiedsocket is already connected

• Errno::EINVAL - the address length used for thesockaddr is not a valid length for the address family or there is an invalid family insockaddr

• 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 - thesocket argument does not refer to a socket

• Errno::EOPNOTSUPP - the callingsocket is listening and cannot be connected

• Errno::EPROTOTYPE - thesockaddr 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 callingsocket isAF_UNIX the follow exceptions may be raised if the call toconnect 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 insockaddr

• 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 insockaddr is not a directory

Windows Exceptions¶↑

On Windows systems the following system exceptions may be raised if the call toconnect 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 thesocket.

• Errno::EALREADY - see Errno::EINVAL

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

• Errno::EAFNOSUPPORT - addresses in the specified family cannot be used with with thissocket

• Errno::ECONNREFUSED - the targetsockaddr 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 - thesocket is a listening socket

• Errno::EISCONN - thesocket 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 - thesocket 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

# File ext/socket/lib/socket.rb, line 1654defconnect_nonblock(addr,exception:true)__connect_nonblock(addr,exception)end

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

Parameter¶↑

• remote_sockaddr - thestruct sockaddr contained in a string orAddrinfo object

Example:¶↑

# Pull down Google's web pagerequire'socket'includeSocket::Constantssocket =Socket.new(AF_INET,SOCK_STREAM,0)sockaddr =Socket.sockaddr_in(80,'www.google.com')begin# emulate blocking connectsocket.connect_nonblock(sockaddr)rescueIO::WaitWritableIO.select(nil, [socket])# wait 3-way handshake completionbeginsocket.connect_nonblock(sockaddr)# check connection failurerescueErrno::EISCONNendendsocket.write("GET / HTTP/1.0\r\n\r\n")results =socket.read

Refer toSocket#connect for the exceptions that may be thrown if the call toconnect_nonblock fails.

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

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

By specifying a keyword argumentexception tofalse, you can indicate thatconnect_nonblock should not raise anIO::WaitWritable exception, but return the symbol:wait_writable instead.

See¶↑

• Socket#connect

# File ext/socket/lib/socket.rb, line 468defipv6only!ifdefined?Socket::IPV6_V6ONLYself.setsockopt(:IPV6,:V6ONLY,1)endend

enable the socket optionIPV6_V6ONLY ifIPV6_V6ONLY is available.

VALUErsock_sock_listen(VALUE sock, VALUE log){    rb_io_t *fptr;    int backlog;    backlog = NUM2INT(log);    GetOpenFile(sock, fptr);    if (listen(fptr->fd, backlog) < 0)        rb_sys_fail("listen(2)");    return INT2FIX(0);}

Listens for connections, using the specifiedint as the backlog. A call tolisten only applies if thesocket is of typeSOCK_STREAM orSOCK_SEQPACKET.

Parameter¶↑

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

Example 1¶↑

require'socket'includeSocket::Constantssocket =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'includeSocket::Constantssocket =Socket.new(AF_INET,SOCK_STREAM,0 )socket.listen(1 )

Unix-based Exceptions¶↑

On unix based systems the above will work because a newsockaddr 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 thesocket is bound by callingbind before it canlisten.

If thebacklog 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 tolisten fails:

• Errno::EBADF - thesocket argument is not a valid file descriptor

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

• Errno::EINVAL - thesocket is already connected

• Errno::ENOTSOCK - thesocket argument does not refer to a socket

• Errno::EOPNOTSUPP - thesocket protocol does not support listen

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

• Errno::EINVAL - thesocket 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 tolisten fails:

• Errno::ENETDOWN - the network is down

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

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

• Errno::EINVAL - thesocket has not been bound with a call tobind.

• Errno::EISCONN - thesocket 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 referencedsocket is not a type that supports thelisten method

See¶↑

• listen manual pages on unix-based systems

• listen function in Microsoft’s Winsock functions reference

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

Receives up tomaxlen bytes fromsocket.flags is zero or more of theMSG_ options. The first element of the results,mesg, is the data received. The second element,sender_addrinfo, contains protocol-specific address information of the sender.

Parameters¶↑

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

• flags - zero or more of theMSG_ options

Example¶↑

# In one file, start this firstrequire'socket'includeSocket::Constantssocket =Socket.new(AF_INET,SOCK_STREAM,0 )sockaddr =Socket.pack_sockaddr_in(2200,'localhost' )socket.bind(sockaddr )socket.listen(5 )client,client_addrinfo =socket.acceptdata =client.recvfrom(20 )[0].chompputs"I only received 20 bytes '#{data}'"sleep1socket.close# In another file, start this secondrequire'socket'includeSocket::Constantssocket =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 torecvfrom fails:

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

• Errno::EWOULDBLOCK - see Errno::EAGAIN

• Errno::EBADF - thesocket 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 interruptedrecvfrom before any data was available

• Errno::EINVAL - theMSG_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 - thesocket 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 torecvfrom fails:

• Errno::ENETDOWN - the network is down

• Errno::EFAULT - the internal buffer and from parameters onsocket 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 tobind, or an unknown flag was specified, orMSG_OOB was specified for a socket withSO_OOBINLINE enabled, or (for byte stream-style sockets only) the internal len parameter onsocket was zero or negative

• Errno::EISCONN -socket is already connected. The call torecvfrom 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, butsocket is not stream-style such as typeSOCK_STREAM. OOB data is not supported in the communication domain associated withsocket, orsocket is unidirectional and supports only send operations

• Errno::ESHUTDOWN -socket has been shutdown. It is not possible to callrecvfrom on a socket aftershutdown has been invoked.

• Errno::EWOULDBLOCK -socket is marked as nonblocking and a call torecvfrom 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.

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

Receives up tomaxlen bytes fromsocket using recvfrom(2) after O_NONBLOCK is set for the underlying file descriptor.flags is zero or more of theMSG_ 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 theMSG_ options

• outbuf - destinationString buffer

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

Example¶↑

# In one file, start this firstrequire'socket'includeSocket::Constantssocket =Socket.new(AF_INET,SOCK_STREAM,0)sockaddr =Socket.sockaddr_in(2200,'localhost')socket.bind(sockaddr)socket.listen(5)client,client_addrinfo =socket.acceptbegin# emulate blocking recvfrompair =client.recvfrom_nonblock(20)rescueIO::WaitReadableIO.select([client])retryenddata =pair[0].chompputs"I only received 20 bytes '#{data}'"sleep1socket.close# In another file, start this secondrequire'socket'includeSocket::Constantssocket =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 toSocket#recvfrom for the exceptions that may be thrown if the call torecvfrom_nonblock fails.

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

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

By specifying a keyword argumentexception tofalse, you can indicate thatrecvfrom_nonblock should not raise anIO::WaitReadable exception, but return the symbol:wait_readable instead.

See¶↑

• Socket#recvfrom

static VALUEsock_sysaccept(VALUE server){    union_sockaddr buffer;    socklen_t length = (socklen_t)sizeof(buffer);    VALUE peer = rsock_s_accept(0, server, &buffer.addr, &length);    return rb_assoc_new(peer, rsock_io_socket_addrinfo(peer, &buffer.addr, length));}

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

Example¶↑

# In one script, start this firstrequire'socket'includeSocket::Constantssocket =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.sysacceptclient_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 secondrequire'socket'includeSocket::Constantssocket =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 toSocket#accept for the exceptions that may be thrown if the call tosysaccept fails.

See¶↑

• Socket#accept