class IPSocket - Documentation for Ruby 4.0
Description: class IPSocket: IPSocket is the super class of TCPSocket and UDPSocket.
Keywords: ruby,class,IPSocket

🔍

No recent searches

# class IPSocket

`IPSocket` is the super class of `TCPSocket` and `UDPSocket`.

### Public Class Methods

getaddress(host) → ipaddress
Source

    static VALUE
    ip_s_getaddress(VALUE obj, VALUE host)
    {
        union_sockaddr addr;
        struct rb_addrinfo *res = rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, 0, Qnil);
        socklen_t len = res->ai->ai_addrlen;

        /* just take the first one */
        memcpy(&addr, res->ai->ai_addr, len);
        rb_freeaddrinfo(res);

        return rsock_make_ipaddr(&addr.addr, len);
    }

Lookups the IP address of host.

    require 'socket'

    IPSocket.getaddress("localhost")     #=> "127.0.0.1"
    IPSocket.getaddress("ip6-localhost") #=> "::1"

Also aliased as: getaddress_orig

### Private Class Methods

getaddress_orig
Alias for: getaddress

### Public Instance Methods

addr([reverse_lookup]) → [address_family, port, hostname, numeric_address]
Source

    static VALUE
    ip_addr(int argc, VALUE *argv, VALUE sock)
    {
        union_sockaddr addr;
        socklen_t len = (socklen_t)sizeof addr;
        int norevlookup;

        if (argc < 1 || !rsock_revlookup_flag(argv[0], &norevlookup))
            norevlookup = rb_io_mode(sock) & FMODE_NOREVLOOKUP;
        if (getsockname(rb_io_descriptor(sock), &addr.addr, &len) < 0)
            rb_sys_fail("getsockname(2)");
        return rsock_ipaddr(&addr.addr, len, norevlookup);
    }

Returns the local address as an array which contains address_family, port, hostname and numeric_address.

If `reverse_lookup` is `true` or `:hostname`, hostname is obtained from numeric_address using reverse lookup. Or if it is `false`, or `:numeric`, hostname is the same as numeric_address. Or if it is `nil` or omitted, obeys to `ipsocket.do_not_reverse_lookup`. See `Socket.getaddrinfo` also.

    TCPSocket.open("www.ruby-lang.org", 80) {|sock|
      p sock.addr #=> ["AF_INET", 49429, "hal", "192.168.0.128"]
      p sock.addr(true)  #=> ["AF_INET", 49429, "hal", "192.168.0.128"]
      p sock.addr(false) #=> ["AF_INET", 49429, "192.168.0.128", "192.168.0.128"]
      p sock.addr(:hostname)  #=> ["AF_INET", 49429, "hal", "192.168.0.128"]
      p sock.addr(:numeric)   #=> ["AF_INET", 49429, "192.168.0.128", "192.168.0.128"]
    }

inspect → string
Source

    static VALUE
    ip_inspect(VALUE sock)
    {
        VALUE str = rb_call_super(0, 0);
        rb_io_t *fptr = RFILE(sock)->fptr;
        union_sockaddr addr;
        socklen_t len = (socklen_t)sizeof addr;
        ID id;
        if (fptr && fptr->fd >= 0 &&
            getsockname(fptr->fd, &addr.addr, &len) >= 0 &&
            (id = rsock_intern_family(addr.addr.sa_family)) != 0) {
            VALUE family = rb_id2str(id);
            char hbuf[1024], pbuf[1024];
            long slen = RSTRING_LEN(str);
            const char last = (slen > 1 && RSTRING_PTR(str)[slen - 1] == '>') ?
                (--slen, '>') : 0;
            str = rb_str_subseq(str, 0, slen);
            rb_str_cat_cstr(str, ", ");
            rb_str_append(str, family);
            if (!rb_getnameinfo(&addr.addr, len, hbuf, sizeof(hbuf),
                                pbuf, sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
                rb_str_cat_cstr(str, ", ");
                rb_str_cat_cstr(str, hbuf);
                rb_str_cat_cstr(str, ", ");
                rb_str_cat_cstr(str, pbuf);
            }
            if (last) rb_str_cat(str, &last, 1);
        }
        return str;
    }

Return a string describing this `IPSocket` object.

peeraddr([reverse_lookup]) → [address_family, port, hostname, numeric_address]
Source

    static VALUE
    ip_peeraddr(int argc, VALUE *argv, VALUE sock)
    {
        union_sockaddr addr;
        socklen_t len = (socklen_t)sizeof addr;
        int norevlookup;

        if (argc < 1 || !rsock_revlookup_flag(argv[0], &norevlookup))
            norevlookup = rb_io_mode(sock) & FMODE_NOREVLOOKUP;
        if (getpeername(rb_io_descriptor(sock), &addr.addr, &len) < 0)
            rb_sys_fail("getpeername(2)");
        return rsock_ipaddr(&addr.addr, len, norevlookup);
    }

Returns the remote address as an array which contains address_family, port, hostname and numeric_address. It is defined for connection oriented socket such as `TCPSocket`.

If `reverse_lookup` is `true` or `:hostname`, hostname is obtained from numeric_address using reverse lookup. Or if it is `false`, or `:numeric`, hostname is the same as numeric_address. Or if it is `nil` or omitted, obeys to `ipsocket.do_not_reverse_lookup`. See `Socket.getaddrinfo` also.

    TCPSocket.open("www.ruby-lang.org", 80) {|sock|
      p sock.peeraddr #=> ["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68"]
      p sock.peeraddr(true)  #=> ["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68"]
      p sock.peeraddr(false) #=> ["AF_INET", 80, "221.186.184.68", "221.186.184.68"]
      p sock.peeraddr(:hostname) #=> ["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68"]
      p sock.peeraddr(:numeric)  #=> ["AF_INET", 80, "221.186.184.68", "221.186.184.68"]
    }

recvfrom(maxlen) → [mesg, ipaddr]
recvfrom(maxlen, flags) → [mesg, ipaddr]
Source

    static VALUE
    ip_recvfrom(int argc, VALUE *argv, VALUE sock)
    {
        return rsock_s_recvfrom(sock, argc, argv, RECV_IP);
    }

Receives a message and return the message as a string and an address which the message come from.

maxlen is the maximum number of bytes to receive.

flags should be a bitwise OR of Socket::MSG_* constants.

ipaddr is the same as IPSocket#{peeraddr,addr}.

    u1 = UDPSocket.new
    u1.bind("127.0.0.1", 4913)
    u2 = UDPSocket.new
    u2.send "uuuu", 0, "127.0.0.1", 4913
    p u1.recvfrom(10) #=> ["uuuu", ["AF_INET", 33230, "localhost", "127.0.0.1"]]