класс Socket

# File ext/socket/lib/socket.rb, line 1216
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

Выполняет итерацию по приёму подключений через заданные сокеты, передавая сокет и адрес клиента в блок.

В качестве аргументов передаётся список сокетов. Каждый аргумент может быть сокетом или массивом сокетов.

Метод последовательно выполняет блок. Это означает, что следующее подключение не будет принято, пока блок не вернёт значение. Таким образом, для обслуживания нескольких клиентов одновременно необходимо использовать механизм одновременного выполнения, например, потоки.

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

Получает информацию об адресе для nodename:servname.

Обратите внимание, что Addrinfo.getaddrinfo предоставляет ту же функциональность в объектно-ориентированном стиле.

family должен быть семейством адресов, например: :INET, :INET6 и т. д.

socktype должен быть типом сокета, например: :STREAM, :DGRAM, :RAW и т. д.

protocol должен быть протоколом, определённым в семействе, и по умолчанию равен 0 для семейства.

flags должны быть битовой комбинацией констант Socket::AI_*.

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 определяет формат третьего элемента и должен быть одним из следующих значений. Если reverse_lookup не указан, используется значение по умолчанию 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.

Если предпочтительнее использовать объект Addrinfo, используйте Addrinfo.getaddrinfo.

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

Вместо этого используйте Addrinfo#getnameinfo. Данный метод устарел по следующим причинам:

• Нестандартное представление адреса: 4/16-байтовая двоичная строка для представления адресов IPv4/IPv6.

• gethostbyaddr() может занимать много времени и блокировать другие потоки. (GVL не может быть освобождён, так как gethostbyname() не потокобезопасен.)

• Этот метод использует функцию gethostbyname(), которая уже удалена из POSIX.

Этот метод получает информацию о хосте для 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"]

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

Вместо этого используйте Addrinfo.getaddrinfo. Данный метод устарел по следующим причинам:

• Третий элемент результата — семейство адресов первого адреса. Семейства адресов остальных адресов не возвращаются.

• Нестандартное представление адреса: 4/16-байтовая двоичная строка для представления адресов IPv4/IPv6.

• gethostbyname() может занимать много времени и блокировать другие потоки. (GVL не может быть освобождён, так как gethostbyname() не потокобезопасен.)

• Этот метод использует функцию gethostbyname(), которая уже удалена из POSIX.

Этот метод получает информацию о хосте для hostname.

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

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

Возвращает имя хоста.

p Socket.gethostname #=> "hal"

Обратите внимание, что нет гарантии возможности преобразования в IP-адрес с помощью gethostbyname, getaddrinfo и т. д. Если вам нужен локальный IP-адрес, используйте Socket.ip_address_list.

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

Возвращает массив адресов интерфейсов. Элементом массива является экземпляр Socket::Ifaddr.

Этот метод можно использовать для поиска интерфейсов с поддержкой многоадресной рассылки:

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

Пример результата на 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::>]

Пример результата на 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)>]

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

Получает информацию о имени для sockaddr.

sockaddr должен быть одним из следующих.

• Упакованная строка sockaddr, например, Socket.sockaddr_in(80, “127.0.0.1”)

• Массив из 3 элементов, например, [“AF_INET”, 80, “127.0.0.1”]

• Массив из 4 элементов, например, [“AF_INET”, 80, игнорируется, “127.0.0.1”]

flags должны быть битовой комбинацией констант Socket::NI_*.

Примечание: Последний формат совместим с IPSocket#addr и 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"]

Если предпочтительнее использовать объект Addrinfo, используйте Addrinfo#getnameinfo.

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

Получает номер порта для service_name.

Если protocol_name не указан, используется «tcp».

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

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

Получает номер порта для port.

Если protocol_name не указан, используется «tcp».

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

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-адреса в виде массива.

Массив содержит объекты Addrinfo.

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

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

Создаёт новый объект сокета.

domain должен быть областью связи, например: :INET, :INET6, :UNIX и т. д.

socktype должен быть типом сокета, например: :STREAM, :DGRAM, :RAW и т. д.

protocol — необязательный аргумент, должен быть протоколом, определённым в области. Если protocol не указан, используется 0.

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

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 AF_INET/AF_INET6.

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

Упаковывает путь в строку sockaddr AF_UNIX.

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

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

Создаёт пару сокетов, соединённых друг с другом.

домен должен быть домен связи, например: :INET, :INET6, :UNIX и т.д.

тип сокета должен быть типом сокета, например: :STREAM, :DGRAM, :RAW и т.д.

протокол должен быть определённым протоколом в домене, по умолчанию 0 для данного домена.

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"

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 AF_INET/AF_INET6.

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

Упаковывает путь в строку sockaddr AF_UNIX.

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

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

Создаёт пару сокетов, соединённых друг с другом.

домен должен быть домен связи, например: :INET, :INET6, :UNIX и т.д.

тип сокета должен быть типом сокета, например: :STREAM, :DGRAM, :RAW и т.д.

протокол должен быть определённым протоколом в домене, по умолчанию 0 для данного домена.

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"

# File ext/socket/lib/socket.rb, line 659
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/IP.

Начиная с Ruby 3.4, этот метод по умолчанию работает согласно алгоритму Happy Eyeballs Version 2 (RFC 8305).

Подробную информацию об алгоритме Happy Eyeballs Version 2 см. в Socket.tcp_fast_fallback=.

Чтобы заставить его работать так же, как в Ruby 3.3 и ранее, явно укажите параметр fast_fallback:false. Или, установив Socket.tcp_fast_fallback=false, отключите Happy Eyeballs Version 2 не только для этого метода, но и для всех Socket глобально.

Если заданы локальный_хост:локальный_порт, сокет привязывается к ним.

Дополнительный последний аргумент opts представляет собой опции, заданные в виде хэша. opts может иметь следующие опции:

:resolv_timeout

Устанавливает таймаут в секундах с момента начала разрешения имени хоста.

:connect_timeout

Этот метод последовательно пытается подключиться ко всем кандидатам-адресам назначения.
Параметр connect_timeout устанавливает таймаут в секундах с начала попытки подключения к последнему кандидату.
По умолчанию все попытки подключения продолжаются до истечения таймаута.
Когда fast_fallback:false явно указан,
таймаут устанавливается для каждой попытки подключения, и любая попытка подключения, которая превысит свой таймаут, будет отменена.

:fast_fallback

Включает алгоритм Happy Eyeballs Version 2 (по умолчанию включен).

Если блок задан, блок вызывается с сокетом. Возвращается значение блока. Сокет закрывается при возвращении из этого метода.

Если блок не задан, возвращается сокет.

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
}

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

Возвращает, включен или отключен алгоритм Happy Eyeballs Version 2 (RFC 8305), предоставляемый начиная с Ruby 3.4 при использовании TCPSocket.new и Socket.tcp.

Если true, он включен для TCPSocket.new и Socket.tcp. (Примечание: Happy Eyeballs Version 2 не предоставляется при использовании TCPSocket.new в Windows.)

Если false, Happy Eyeballs Version 2 отключен.

Подробную информацию об алгоритме Happy Eyeballs Version 2 см. в Socket.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;
}

Включить или отключить Happy Eyeballs Version 2 (RFC 8305) глобально. Эта функция доступна начиная с Ruby 3.4 при использовании TCPSocket.new и Socket.tcp.

Если установлено значение true, функция включена как для `TCPSocket.new`, так и для `Socket.tcp`. (Примечание: Эта функция недоступна при использовании TCPSocket.new в Windows.)

Если установлено значение false, поведение возвращается к поведению Ruby 3.3 или более ранних версий.

Значение по умолчанию — true, если значение не установлено явно вызовом этого метода. Однако, если установлена переменная окружения RUBY_TCP_NO_FAST_FALLBACK=1, значение по умолчанию — false.

Для управления настройкой на основе каждого метода используйте именованный аргумент fast_fallback для каждого метода.

Happy Eyeballs Version 2

Happy Eyeballs Version 2 (RFC 8305) — это алгоритм, предназначенный для улучшения подключения клиентских сокетов.
Он направлен на обеспечение более надежных и эффективных соединений путем параллельного, а не последовательного выполнения разрешения имен хостов и попыток соединения.

Начиная с Ruby 3.4, этот метод работает следующим образом с этим алгоритмом:

1. Начать одновременное разрешение адресов IPv6 и IPv4.

2. Начать соединение с одним из адресов, полученных первым.
   Если адреса IPv4 получены первыми, метод ожидает 50 мс разрешения имени IPv6, чтобы приоритизировать соединения IPv6.

3. После начала попытки соединения подождать 250 мс установления соединения.
   Если соединение не установлено в течение этого времени, новое соединение запускается каждые 250 мс
   до тех пор, пока соединение не будет установлено или не останется кандидатов на адреса.
   (Хотя RFC 8305 строго указывает на сортировку адресов,
   этот метод только чередует адреса IPv6/IPv4 из-за проблем с производительностью)

4. После установления соединения все остальные попытки соединения отменяются.

# File ext/socket/lib/socket.rb, line 1272
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/IP сервер на порту и вызывает блок для каждого принятого соединения. Блок вызывается с сокетом и адресом клиента в виде объекта Addrinfo.

Если указан хост, он используется с портом для определения адресов сервера.

Сокет не закрывается при возврате блока. Поэтому приложение должно закрыть его явно.

Этот метод вызывает блок последовательно. Это означает, что следующее соединение не принимается до тех пор, пока не вернется блок. Таким образом, для обслуживания нескольких клиентов одновременно следует использовать конкурентный механизм, например, поток.

Обратите внимание, что Addrinfo.getaddrinfo используется для определения адресов серверного сокета. Когда Addrinfo.getaddrinfo возвращает два или более адреса, например, адрес IPv4 и IPv6, используются все они. Socket.tcp_server_loop завершается успешно, если хотя бы один сокет может быть использован.

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

# File ext/socket/lib/socket.rb, line 1172
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/IP серверные сокеты для хоста и порта. Хост является необязательным.

Если блок не задан, возвращается массив прослушивающих сокетов.

Если блок задан, блок вызывается с сокетами. Возвращается значение блока. Сокет закрывается при возврате этого метода.

Если порт равен 0, фактический номер порта выбирается динамически. Однако все сокеты в результате имеют одинаковый номер порта.

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

# File ext/socket/lib/socket.rb, line 1442
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/IP сервер на порту и вызывает блок для каждого полученного сообщения. Блок вызывается с сообщением и информацией об источнике.

Этот метод выделяет сокеты внутренне, используя порт. Если указан хост, он используется совместно с портом для определения адресов сервера.

msg — это строка.

msg_src — это объект Socket::UDPSource. Он используется для ответа.

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

# File ext/socket/lib/socket.rb, line 1415
def self.udp_server_loop_on(sockets, &b) # :yield: msg, msg_src
  loop {
    readable, _, _ = IO.select(sockets)
    udp_server_recv(readable, &b)
  }
end

Запустить цикл UDP/IP сервера на заданных сокетах.

Результат Socket.udp_server_sockets подходит для аргумента.

Он вызывает блок для каждого полученного сообщения.

# File ext/socket/lib/socket.rb, line 1388
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/IP пакеты от заданных сокетов. Для каждого полученного пакета вызывается блок.

Блок получает msg и msg_src. msg — это строка, которая является полезной нагрузкой принятого пакета. msg_src — это объект Socket::UDPSource, который используется для ответа.

Socket.udp_server_loop может быть реализован с помощью этого метода следующим образом.

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

Создает UDP/IP сокеты для UDP сервера.

Если блок не задан, возвращается массив сокетов.

Если блок задан, блок вызывается с сокетами. Возвращается значение блока. Сокеты закрываются при возврате этого метода.

Если порт равен нулю, выбирается какой-то порт. Но выбранный порт используется для всех сокетов.

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

# File ext/socket/lib/socket.rb, line 1492
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.

Если блок задан, блок вызывается с сокетом. Возвращается значение блока. Сокет закрывается при возврате этого метода.

Если блок не задан, возвращается сокет.

# 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 1579
def self.unix_server_loop(path, &b) # :yield: socket, client_addrinfo
  unix_server_socket(path) {|serv|
    accept_loop(serv, &b)
  }
end

создаёт сервер сокета Unix по пути path. Вызывает блок кода для каждого принятого сокета.

Если указан параметр host, он используется вместе с port для определения портов сервера.

Сокет не закрывается при возврате блока. Поэтому приложение должно закрыть его.

Этот метод сначала удаляет файл сокета, указанный в path, если это файл сокета и он принадлежит пользователю приложения. Это безопасно только в том случае, если каталог path не изменяется злонамеренным пользователем. Поэтому не используйте /tmp/malicious-users-directory/socket. Обратите внимание, что /tmp/socket и /tmp/your-private-directory/socket безопасны, предполагая, что у /tmp установлен бит «липкость».

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

# File ext/socket/lib/socket.rb, line 1522
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 по пути path

Если блок не указан, возвращается сокет прослушивания.

Если блок указан, он вызывается с сокетом, а значение блока возвращается. При завершении работы блока сокет закрывается, а файл сокета удаляется.

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

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

Распаковывает sockaddr в порт и ip_address.

sockaddr должен быть строкой или addrinfo для 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"]

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

Распаковывает sockaddr в путь.

sockaddr должен быть строкой или addrinfo для AF_UNIX.

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

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

Принимает следующее соединение. Возвращает новый объект Socket и объект Addrinfo.

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

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

Принимает входящее соединение, используя accept(2) после установки O_NONBLOCK для базового файлового дескриптора. Возвращает массив, содержащий принятый сокет для входящего соединения, client_socket, и Addrinfo, client_addrinfo.

Пример

# 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

Обратитесь к Socket#accept для получения информации об исключениях, которые могут быть выброшены, если вызов accept_nonblock завершится неудачей.

Socket#accept_nonblock может вызвать любую ошибку, соответствующую ошибке accept(2), включая Errno::EWOULDBLOCK.

Если исключение является Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNABORTED или Errno::EPROTO, оно расширяется с помощью IO::WaitReadable. Таким образом, IO::WaitReadable может использоваться для обработки исключений при повторной попытке accept_nonblock.

Указав именованный аргумент exception для false, вы можете указать, что accept_nonblock не должен вызывать исключение IO::WaitReadable, а возвращать символ :wait_readable вместо этого.

См. также

• Socket#accept

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

Привязывается к указанному локальному адресу.

Параметр

• local_sockaddr - struct sockaddr, содержащийся в строке или объект Addrinfo

Пример

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-системах

В Unix-подобных системах могут возникать следующие системные исключения, если вызов bind завершится неудачей:

• Errno::EACCES - указанный sockaddr защищен, и текущий пользователь не имеет разрешения на привязку к нему

• Errno::EADDRINUSE - указанный sockaddr уже используется

• Errno::EADDRNOTAVAIL - указанный sockaddr недоступен с локальной машины

• Errno::EAFNOSUPPORT - указанный sockaddr не является допустимым адресом для семейства вызывающего socket

• Errno::EBADF - указанный sockaddr не является допустимым файловым дескриптором

• Errno::EFAULT - к аргументу sockaddr невозможно получить доступ

• Errno::EINVAL - socket уже привязан к адресу, и протокол не поддерживает привязку к новому sockaddr или socket был закрыт.

• Errno::EINVAL - длина адреса не является допустимой длиной для семейства адресов

• Errno::ENAMETOOLONG - длина разрешенного пути превысила PATH_MAX

• Errno::ENOBUFS - доступно недостаточно буферного пространства

• Errno::ENOSR - доступно недостаточно ресурсов STREAMS для завершения операции

• Errno::ENOTSOCK - socket не ссылается на сокет

• Errno::EOPNOTSUPP - тип сокета socket не поддерживает привязку к адресу

В Unix-подобных системах, если семейство адресов вызывающего socket является Socket::AF_UNIX, могут возникнуть следующие исключения, если вызов bind завершится неудачей:

• Errno::EACCES - разрешение на поиск отказано для компонента префиксного пути или доступ на запись к socket запрещен

• Errno::EDESTADDRREQ - аргумент sockaddr является нулевым указателем

• Errno::EISDIR - то же, что и Errno::EDESTADDRREQ

• Errno::EIO - произошла ошибка ввода-вывода

• Errno::ELOOP - при преобразовании пути в sockaddr было обнаружено слишком много символических ссылок

• Errno::ENAMETOOLLONG - компонент пути превысил NAME_MAX символов, или весь путь превысил PATH_MAX символов

• Errno::ENOENT - компонент пути не обозначает существующий файл или путь является пустой строкой

• Errno::ENOTDIR - компонент префиксного пути в sockaddr не является директорией

• Errno::EROFS - имя будет находиться в файловой системе только для чтения

Исключения в Windows

В Windows могут возникать следующие системные исключения, если вызов bind завершится неудачей:

• Errno::ENETDOWN– сеть не работает

• Errno::EACCES - попытка подключения сокета дейтаграммы к широковещательному адресу завершилась неудачей

• Errno::EADDRINUSE - локальный адрес сокета уже используется

• Errno::EADDRNOTAVAIL - указанный адрес не является допустимым адресом для этого компьютера

• Errno::EFAULT - внутренний адрес сокета или параметр длины адреса слишком мал или не является допустимой частью адресованного пространства пользователя

• Errno::EINVAL - socket уже привязан к адресу

• Errno::ENOBUFS - доступно недостаточно буферного пространства

• Errno::ENOTSOCK - аргумент socket не ссылается на сокет

См. также

• Страницы руководства bind в Unix-подобных системах

• Функция bind в справочнике функций Winsock от Microsoft

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

Запрашивает установление соединения с указанным remote_sockaddr. Возвращает 0 в случае успеха, в противном случае генерируется исключение.

Параметр

• remote_sockaddr - struct sockaddr, содержащийся в строке или объекте Addrinfo

Пример:

# 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

В системах на базе Unix могут быть сгенерированы следующие системные исключения, если вызов connect завершился неудачей:

• Errno::EACCES - запрещено разрешение доступа к компоненту пути префикса или запрещен доступ для записи к socket

• Errno::EADDRINUSE - Addrinfo уже используется

• Errno::EADDRNOTAVAIL - указанный Addrinfo недоступен на локальной машине

• Errno::EAFNOSUPPORT - указанный Addrinfo не является допустимым адресом для семейства адресов указанного socket

• Errno::EALREADY - для указанного сокета уже происходит соединение

• Errno::EBADF - socket не является допустимым дескриптором файла

• Errno::ECONNREFUSED - целевой Addrinfo не ожидал подключения, отклонил запрос на подключение

• Errno::ECONNRESET - удаленный хост прервал запрос на подключение

• Errno::EFAULT - доступ к Addrinfo невозможен

• Errno::EHOSTUNREACH - целевой хост недоступен (вероятно, потому что хост выключен или удалённый маршрутизатор не может к нему подключиться)

• Errno::EINPROGRESS - для socket установлен флаг O_NONBLOCK, и соединение не может быть установлено немедленно; соединение будет установлено асинхронно

• Errno::EINTR - попытка установить соединение была прервана доставкой сигнала, который был перехвачен; соединение будет установлено асинхронно

• Errno::EISCONN - указанный socket уже подключён

• Errno::EINVAL - длина адреса, используемого для Addrinfo, не является допустимой длиной для семейства адресов или в Addrinfo присутствует некорректное семейство

• Errno::ENAMETOOLONG - длина пути, который был разрешен, превысила PATH_MAX

• Errno::ENETDOWN - локальный интерфейс, используемый для достижения пункта назначения, выключен

• Errno::ENETUNREACH - маршрут к сети отсутствует

• Errno::ENOBUFS - нет доступного буферного пространства

• Errno::ENOSR - недостаточно ресурсов STREAMS для завершения операции

• Errno::ENOTSOCK - аргумент socket не относится к сокету

• Errno::EOPNOTSUPP - вызывающий socket прослушивает и не может быть подключён

• Errno::EPROTOTYPE - Addrinfo имеет другой тип, чем сокет, привязанный к указанному адресу удалённого узла

• Errno::ETIMEDOUT - попытка подключения истекла, прежде чем подключение было установлено.

В системах на базе Unix, если семейство адресов вызывающего socket является AF_UNIX, при неудаче вызова connect могут быть сгенерированы следующие исключения:

• Errno::EIO - произошла ошибка ввода-вывода при чтении или записи в файловую систему

• Errno::ELOOP - при преобразовании пути в Addrinfo было обнаружено слишком много символических ссылок

• Errno::ENAMETOOLLONG - компонент пути превысил NAME_MAX символов или весь путь превысил PATH_MAX символов

• Errno::ENOENT - компонент пути не указывает на существующий файл или путь является пустой строкой

• Errno::ENOTDIR - компонент префикса пути в Addrinfo не является каталогом

Исключения в Windows

В системах Windows могут быть сгенерированы следующие системные исключения, если вызов connect завершился неудачей:

• Errno::ENETDOWN - сеть не активна

• Errno::EADDRINUSE - локальный адрес сокета уже используется

• Errno::EINTR - сокет был отменён

• Errno::EINPROGRESS - блокирующий сокет находится в процессе обработки, или поставщик услуг всё ещё обрабатывает функцию обратного вызова. Или неблокирующий вызов connect выполняется на socket.

• Errno::EALREADY - см. Errno::EINVAL

• Errno::EADDRNOTAVAIL - удалённый адрес не является допустимым, например, ADDR_ANY TODO проверить ADDRANY до INADDR_ANY

• Errno::EAFNOSUPPORT - адреса в указанном семействе не могут быть использованы с данным socket

• Errno::ECONNREFUSED - целевой Addrinfo не ожидал подключения, отклонил запрос на подключение

• Errno::EFAULT - внутренний адрес или параметр длины адреса сокета слишком мал или не является допустимой частью адреса пользовательского пространства

• Errno::EINVAL - socket является прослушивающим сокетом

• Errno::EISCONN - socket уже подключён

• Errno::ENETUNREACH - сеть недоступна с этого хоста в данный момент

• Errno::EHOSTUNREACH - маршрут к сети отсутствует

• Errno::ENOBUFS - нет доступного буферного пространства

• Errno::ENOTSOCK - аргумент socket не относится к сокету

• Errno::ETIMEDOUT - попытка подключения истекла, прежде чем подключение было установлено.

• Errno::EWOULDBLOCK - сокет помечен как неблокирующий, и соединение не может быть выполнено немедленно

• Errno::EACCES - попытка подключить сокет данных к широковещательному адресу завершилась неудачей

См. также

• Страницы руководства connect в системах на базе Unix

• Функция connect в справочнике функций Winsock Майкрософт

# File ext/socket/lib/socket.rb, line 1629
def connect_nonblock(addr, exception: true)
  __connect_nonblock(addr, exception)
end

Запрашивает установление соединения с указанным remote_sockaddr после установки флага O_NONBLOCK для базового дескриптора файла. Возвращает 0 в случае успеха, в противном случае генерируется исключение.

Параметр

• remote_sockaddr - struct sockaddr, содержащийся в строке или объекте Addrinfo

Пример:

# 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

Обратитесь к Socket#connect для получения списка исключений, которые могут быть сгенерированы, если вызов connect_nonblock завершился неудачей.

Socket#connect_nonblock может генерировать любые ошибки, соответствующие ошибке connect(2), включая Errno::EINPROGRESS.

Если исключение Errno::EINPROGRESS, оно дополняется IO::WaitWritable. Поэтому IO::WaitWritable может быть использована для перехвата исключений для повторной попытки connect_nonblock.

Указав ключевой аргумент exception в false, вы можете указать, что connect_nonblock не должен генерировать исключение IO::WaitWritable, а вместо этого должен возвращать символ :wait_writable.

См. также

• Socket#connect

# File ext/socket/lib/socket.rb, line 468
def ipv6only!
  if defined? Socket::IPV6_V6ONLY
    self.setsockopt(:IPV6, :V6ONLY, 1)
  end
end

Включает опцию сокета IPV6_V6ONLY, если IPV6_V6ONLY доступна.

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

Прослушивает подключения, используя указанный int в качестве очереди ожидающих подключений. Вызов listen применяется только если socket имеет тип SOCK_STREAM или SOCK_SEQPACKET.

Параметр

• backlog - максимальная длина очереди ожидающих подключений.

Пример 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 )

Пример 2 (прослушивание на произвольном порту, только системы на Unix):

require 'socket'
include Socket::Constants
socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
socket.listen( 1 )

Исключения для систем на Unix

В системах на основе Unix вышеуказанный код будет работать, так как новый sockaddr создаётся по адресу ADDR_ANY для произвольного номера порта, переданного ядром. Он не будет работать в Windows, так как Windows требует, чтобы socket был привязан вызовом bind перед вызовом listen.

Если значение backlog превышает максимальную длину очереди, зависящую от реализации, будет использоваться максимальная длина очереди реализации.

В системах на основе Unix при неудачном вызове listen могут быть выброшены следующие системные исключения:

• Errno::EBADF - аргумент socket не является допустимым дескриптором файла

• Errno::EDESTADDRREQ - сокет не привязан к локальному адресу, и протокол не поддерживает прослушивание на не привязанном сокете

• Errno::EINVAL - сокет уже подключён

• Errno::ENOTSOCK - аргумент socket не ссылается на сокет

• Errno::EOPNOTSUPP - протокол сокета не поддерживает listen

• Errno::EACCES - у вызывающего процесса нет соответствующих привилегий

• Errno::EINVAL - сокет был закрыт

• Errno::ENOBUFS - в системе недостаточно ресурсов для завершения вызова

Исключения для Windows

В системах Windows при неудачном вызове listen могут быть выброшены следующие системные исключения:

• Errno::ENETDOWN - сеть недоступна

• Errno::EADDRINUSE - локальный адрес сокета уже используется. Это обычно происходит во время выполнения bind, но может произойти с задержкой, если вызов bind был к частичному адресу с подстановкой (вовлекая ADDR_ANY), и если конкретный адрес необходимо зафиксировать во время вызова listen

• Errno::EINPROGRESS - вызов Windows Sockets 1.1 выполняется или поставщик сервиса всё ещё обрабатывает функцию обратного вызова

• Errno::EINVAL - socket не был привязан вызовом bind.

• Errno::EISCONN - socket уже подключен

• Errno::EMFILE - больше нет доступных дескрипторов сокетов

• Errno::ENOBUFS - нет доступного буферного пространства

• Errno::ENOTSOC - socket не является сокетом

• Errno::EOPNOTSUPP - указанный socket не является типом, поддерживающим метод listen

См. также

• Страницы руководства listen в системах на основе Unix

• Функция listen в справочнике функций Winsock Майкрософт

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

Принимает до maxlen байтов от socket. flags равно нулю или большему числу MSG_ опций. Первый элемент результата, mesg, представляет полученные данные. Второй элемент, sender_addrinfo, содержит информацию о протоколе адреса отправителя.

Параметры

• maxlen - максимальное количество байтов для получения из сокета

• flags - ноль или более MSG_ опций

Пример

# 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

В системах на основе Unix при неудачном вызове recvfrom могут быть выброшены следующие системные исключения:

• Errno::EAGAIN - дескриптор файла socket помечен как O_NONBLOCK и данные для получения отсутствуют; или MSG_OOB установлено, и данные вне очереди отсутствуют, и дескриптор файла socket помечен как O_NONBLOCK или дескриптор socket не поддерживает блокирование для ожидания данных вне очереди

• Errno::EWOULDBLOCK - см. Errno::EAGAIN

• Errno::EBADF - socket не является допустимым дескриптором файла

• Errno::ECONNRESET - соединение было принудительно закрыто удалённым узлом

• Errno::EFAULT - к внутреннему буферу сокета, адресу или длине адреса невозможно получить доступ или записать

• Errno::EINTR - сигнал прервал recvfrom до получения данных

• Errno::EINVAL - флаг MSG_OOB установлен, но данные вне очереди отсутствуют

• Errno::EIO - произошла ошибка ввода-вывода при чтении или записи на файловую систему

• Errno::ENOBUFS - в системе недостаточно ресурсов для выполнения операции

• Errno::ENOMEM - недостаточно памяти для выполнения запроса

• Errno::ENOSR - недостаточно ресурсов STREAMS для завершения операции

• Errno::ENOTCONN - попытка получения данных на сокете в режиме соединения, который не подключен

• Errno::ENOTSOCK - socket не ссылается на сокет

• Errno::EOPNOTSUPP - указанные флаги не поддерживаются для этого типа сокета

• Errno::ETIMEDOUT - соединение истекло во время установления соединения или из-за таймаута передачи по активному соединению

Исключения для Windows

В системах Windows при неудачном вызове recvfrom могут быть выброшены следующие системные исключения:

• Errno::ENETDOWN - сеть недоступна

• Errno::EFAULT - внутренний буфер и параметры from в socket не являются частью адресного пространства пользователя, или внутренний параметр fromlen слишком мал для размещения адреса удалённого узла

• Errno::EINTR - (блокирующий) вызов был отменён внутренним вызовом функции WinSock WSACancelBlockingCall

• Errno::EINPROGRESS - блокирующий вызов Windows Sockets 1.1 выполняется или поставщик сервиса всё ещё обрабатывает функцию обратного вызова

• Errno::EINVAL - socket не был привязан вызовом bind, или был указан неизвестный флаг, или MSG_OOB был указан для сокета с SO_OOBINLINE включённым, или (только для сокетов типа потока байтов) внутренний параметр len в socket был нулём или отрицательным

• Errno::EISCONN - socket уже подключен. Вызов recvfrom не разрешен с подключённым сокетом на сокете, ориентированном на соединение или беспроводном.

• Errno::ENETRESET - соединение было прервано из-за активности проверки поддержания соединения, обнаружившей ошибку во время выполнения операции.

• Errno::EOPNOTSUPP - MSG_OOB был указан, но socket не является потоковым, например типа SOCK_STREAM. Данные вне очереди не поддерживаются в области связи, связанной с socket, или socket однонаправленный и поддерживает только операции отправки.

• Errno::ESHUTDOWN - socket был закрыт. Невозможно вызвать recvfrom для сокета после вызова shutdown.

• Errno::EWOULDBLOCK - socket помечен как неблокирующий, и вызов recvfrom заблокировал бы.

• Errno::EMSGSIZE - сообщение было слишком большим для указанного буфера и было усечено.

• Errno::ETIMEDOUT - соединение было прервано из-за ошибки сети или из-за выхода системы на другом конце без уведомления

• Errno::ECONNRESET - виртуальный канал был сброшен удалённой стороной, выполнившей жёсткое или аварийное закрытие. Приложение должно закрыть сокет; он больше не пригоден для использования. В сокете UDP-датаграмм эта ошибка указывает, что предыдущая операция отправки привела к сообщению ICMP Port Unreachable.

# 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

Принимает до maxlen байтов данных от socket с помощью recvfrom(2) после установки O_NONBLOCK для базового дескриптора файла. flags — это ноль или более MSG_ опций. Первый элемент результатов, mesg, содержит полученные данные. Второй элемент, sender_addrinfo, содержит информацию об адресе отправителя, специфичную для протокола.

Когда recvfrom(2) возвращает 0, Socket#recv_nonblock возвращает nil. В большинстве случаев это означает закрытие соединения, но для UDP-соединений это может означать получение пустого пакета, так как базовый API не позволяет отличить эти два случая.

Параметры

• maxlen — максимальное количество байтов для приема с сокета

• flags — ноль или более MSG_ опций

• outbuf — буфер для назначения String

• opts — хэш ключевых слов, поддерживающий «исключение: false»

Пример

# 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

Обратитесь к Socket#recvfrom для получения информации об исключениях, которые могут возникнуть, если вызов recvfrom_nonblock завершится неудачно.

Socket#recvfrom_nonblock может вызвать любые ошибки, соответствующие неудачному вызову recvfrom(2), включая Errno::EWOULDBLOCK.

Если исключение — Errno::EWOULDBLOCK или Errno::EAGAIN, оно расширяется IO::WaitReadable. Таким образом, IO::WaitReadable можно использовать для перехвата исключений и повторной попытки вызова recvfrom_nonblock.

Указав ключевой аргумент exception в false, вы можете указать, что recvfrom_nonblock не должен вызывать исключение IO::WaitReadable, а вместо этого должен возвращать символ :wait_readable.

См. также

• Socket#recvfrom

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

Принимает входящее соединение, возвращая массив, содержащий дескриптор файла (целое число) входящего соединения, client_socket_fd, и Addrinfo, client_addrinfo.

Пример

# 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

Обратитесь к Socket#accept для получения информации об исключениях, которые могут возникнуть, если вызов sysaccept завершится неудачно.

См. также

• Socket#accept