Class: Addrinfo

Inherits:
Object
  • Object
show all
Defined in:
mrbgems/mruby-socket/mrblib/socket.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sockaddr, family = Socket::PF_UNSPEC, socktype = 0, protocol = 0) ⇒ Addrinfo

call-seq:

Addrinfo.new(sockaddr, family=Socket::PF_UNSPEC, socktype=0, protocol=0) -> addrinfo

Creates a new Addrinfo object from socket address information. sockaddr can be a packed sockaddr string or an array representation.

Addrinfo.new(Socket.sockaddr_in(80, "127.0.0.1"))
Addrinfo.new(["AF_INET", 80, "localhost", "127.0.0.1"])
Addrinfo.new(["AF_UNIX", "/tmp/socket"])


13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 13

def initialize(sockaddr, family=Socket::PF_UNSPEC, socktype=0, protocol=0)
  @hostname = nil
  if sockaddr.is_a? Array
    sary = sockaddr
    if sary[0] == 'AF_INET' || sary[0] == 'AF_INET6'
      @sockaddr = Socket.sockaddr_in(sary[1], sary[3])
      @hostname = sary[2]
    elsif sary[0] == 'AF_UNIX'
      @sockaddr = Socket.sockaddr_un(sary[1])
    end
  else
    @sockaddr = sockaddr.dup
  end
  if family == Socket::PF_UNSPEC or family == nil
    @family = Socket._sockaddr_family(@sockaddr)
  else
    @family = family
  end
  @socktype = socktype
  @protocol = protocol
end

Instance Attribute Details

#protocol ⇒ Object (readonly)

call-seq:

addrinfo.protocol -> integer

Returns the protocol number.

Addrinfo.tcp("localhost", 80).protocol  #=> 6 (IPPROTO_TCP)
Addrinfo.udp("localhost", 53).protocol  #=> 17 (IPPROTO_UDP)


302
303
304
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 302

def protocol
  @protocol
end

#socktype ⇒ Object (readonly)

call-seq:

addrinfo.socktype -> integer

Returns the socket type.

Addrinfo.tcp("localhost", 80).socktype  #=> 1 (SOCK_STREAM)
Addrinfo.udp("localhost", 53).socktype  #=> 2 (SOCK_DGRAM)


313
314
315
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 313

def socktype
  @socktype
end

Class Method Details

.foreach(nodename, service, family = nil, socktype = nil, protocol = nil, flags = 0, &block) ⇒ Object

call-seq:

Addrinfo.foreach(nodename, service, family=nil, socktype=nil, protocol=nil, flags=0) { |addrinfo| block } -> array

Iterates over all address information for the given nodename and service. Returns an array of Addrinfo objects.

Addrinfo.foreach("www.example.com", "http") { |ai| puts ai.ip_address }
Addrinfo.foreach("localhost", 80) { |ai| puts ai.inspect }


45
46
47
48
49
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 45

def self.foreach(nodename, service, family=nil, socktype=nil, protocol=nil, flags=0, &block)
  a = self.getaddrinfo(nodename, service, family, socktype, protocol, flags)
  a.each {|ai| block.call(ai) }
  a
end

.ip(host) ⇒ Object

call-seq:

Addrinfo.ip(host) -> addrinfo

Creates an Addrinfo object for the given host with port 0. Useful for creating address info without specifying a port.

Addrinfo.ip("127.0.0.1")     #=> #<Addrinfo: 127.0.0.1:0>
Addrinfo.ip("::1")           #=> #<Addrinfo: [::1]:0>


61
62
63
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 61

def self.ip(host)
  Addrinfo.new(Socket.sockaddr_in(0, host))
end

.tcp(host, port) ⇒ Object

call-seq:

Addrinfo.tcp(host, port) -> addrinfo

Creates an Addrinfo object for TCP connection to the given host and port.

Addrinfo.tcp("localhost", 80)        #=> #<Addrinfo: 127.0.0.1:80 TCP>
Addrinfo.tcp("www.example.com", 443) #=> #<Addrinfo: 93.184.216.34:443 TCP>


74
75
76
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 74

def self.tcp(host, port)
  Addrinfo.getaddrinfo(host, port, nil, Socket::SOCK_STREAM, Socket::IPPROTO_TCP)[0]
end

.udp(host, port) ⇒ Object

call-seq:

Addrinfo.udp(host, port) -> addrinfo

Creates an Addrinfo object for UDP connection to the given host and port.

Addrinfo.udp("localhost", 53)        #=> #<Addrinfo: 127.0.0.1:53 UDP>
Addrinfo.udp("8.8.8.8", 53)         #=> #<Addrinfo: 8.8.8.8:53 UDP>


87
88
89
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 87

def self.udp(host, port)
  Addrinfo.getaddrinfo(host, port, nil, Socket::SOCK_DGRAM, Socket::IPPROTO_UDP)[0]
end

.unix(path, socktype = Socket::SOCK_STREAM) ⇒ Object

call-seq:

Addrinfo.unix(path, socktype=Socket::SOCK_STREAM) -> addrinfo

Creates an Addrinfo object for Unix domain socket at the given path.

Addrinfo.unix("/tmp/socket")                    #=> #<Addrinfo: /tmp/socket SOCK_STREAM>
Addrinfo.unix("/var/run/daemon.sock", Socket::SOCK_DGRAM) #=> #<Addrinfo: /var/run/daemon.sock SOCK_DGRAM>


100
101
102
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 100

def self.unix(path, socktype=Socket::SOCK_STREAM)
  Addrinfo.new(Socket.sockaddr_un(path), Socket::AF_UNIX, socktype)
end

Instance Method Details

#_to_array ⇒ Object

call-seq:

addrinfo._to_array -> array

Internal method that returns the address information as an array. Used internally by socket operations.



322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 322

def _to_array
  case @family
  when Socket::AF_INET
    s = "AF_INET"
  when Socket::AF_INET6
    s = "AF_INET6"
  when Socket::AF_UNIX
    s = "AF_UNIX"
  else
    s = "(unknown AF)"
  end
  addr, port = self.getnameinfo(Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV)
  [ s, port.to_i, addr, addr ]
end

#afamily ⇒ Object

call-seq:

addrinfo.afamily -> integer

Returns the address family of the socket address.

Addrinfo.tcp("localhost", 80).afamily  #=> 2 (AF_INET)
Addrinfo.unix("/tmp/sock").afamily     #=> 1 (AF_UNIX)

call-seq:

addrinfo.afamily -> integer

Returns the address family of the socket address.

Addrinfo.tcp("localhost", 80).afamily  #=> 2 (AF_INET)
Addrinfo.unix("/tmp/sock").afamily     #=> 1 (AF_UNIX)


122
123
124
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 122

def afamily
  @family
end

#inspect ⇒ Object

call-seq:

addrinfo.inspect -> string

Returns a string representation of the Addrinfo object.

Addrinfo.tcp("localhost", 80).inspect  #=> "#<Addrinfo: 127.0.0.1:80 TCP>"
Addrinfo.unix("/tmp/sock").inspect     #=> "#<Addrinfo: /tmp/sock SOCK_STREAM>"


146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 146

def inspect
  if ipv4? or ipv6?
    if @protocol == Socket::IPPROTO_TCP or (@socktype == Socket::SOCK_STREAM and @protocol == 0)
      proto = 'TCP'
    elsif @protocol == Socket::IPPROTO_UDP or (@socktype == Socket::SOCK_DGRAM and @protocol == 0)
      proto = 'UDP'
    else
      proto = '???'
    end
  else
    proto = "SOCK_STREAM"
  end
  "#<Addrinfo: #{inspect_sockaddr} #{proto}>"
end

#inspect_sockaddr ⇒ Object

call-seq:

addrinfo.inspect_sockaddr -> string

Returns a string representation of the socket address portion.

Addrinfo.tcp("localhost", 80).inspect_sockaddr  #=> "127.0.0.1:80"
Addrinfo.unix("/tmp/sock").inspect_sockaddr     #=> "/tmp/sock"


170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 170

def inspect_sockaddr
  if ipv4?
    a, p = ip_unpack
    "#{a}:#{p}"
  elsif ipv6?
    a, p = ip_unpack
    "[#{a}]:#{p}"
  elsif unix?
    unix_path
  else
    '???'
  end
end

#ip? ⇒ Boolean

call-seq:

addrinfo.ip? -> true or false

Returns true if the address is an IP address (IPv4 or IPv6).

Addrinfo.tcp("localhost", 80).ip?  #=> true
Addrinfo.unix("/tmp/sock").ip?     #=> false

Returns:

  • (Boolean) 


193
194
195
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 193

def ip?
  ipv4? or ipv6?
end

#ip_address ⇒ Object

call-seq:

addrinfo.ip_address -> string

Returns the IP address as a string. Raises an exception if not an IP address.

Addrinfo.tcp("localhost", 80).ip_address  #=> "127.0.0.1"
Addrinfo.udp("::1", 53).ip_address       #=> "::1"


206
207
208
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 206

def ip_address
  ip_unpack[0]
end

#ip_port ⇒ Object

call-seq:

addrinfo.ip_port -> integer

Returns the port number. Raises an exception if not an IP address.

Addrinfo.tcp("localhost", 80).ip_port   #=> 80
Addrinfo.udp("127.0.0.1", 53).ip_port  #=> 53


219
220
221
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 219

def ip_port
  ip_unpack[1]
end

#ip_unpack ⇒ Object

call-seq:

addrinfo.ip_unpack -> [ip_address, port]

Returns an array containing the IP address and port number.

Addrinfo.tcp("localhost", 80).ip_unpack   #=> ["127.0.0.1", 80]
Addrinfo.udp("::1", 53).ip_unpack        #=> ["::1", 53]


232
233
234
235
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 232

def ip_unpack
  h, p = getnameinfo(Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV)
  [ h, p.to_i ]
end

#ipv4? ⇒ Boolean

call-seq:

addrinfo.ipv4? -> true or false

Returns true if the address is an IPv4 address.

Addrinfo.tcp("127.0.0.1", 80).ipv4?  #=> true
Addrinfo.tcp("::1", 80).ipv4?        #=> false

Returns:

  • (Boolean) 


246
247
248
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 246

def ipv4?
  @family == Socket::AF_INET
end

#ipv6? ⇒ Boolean

call-seq:

addrinfo.ipv6? -> true or false

Returns true if the address is an IPv6 address.

Addrinfo.tcp("::1", 80).ipv6?        #=> true
Addrinfo.tcp("127.0.0.1", 80).ipv6?  #=> false

Returns:

  • (Boolean) 


263
264
265
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 263

def ipv6?
  @family == Socket::AF_INET6
end

#pfamily ⇒ Object

call-seq:

addrinfo.pfamily -> integer

Returns the protocol family (same as afamily).

Addrinfo.tcp("localhost", 80).pfamily  #=> 2 (PF_INET)
Addrinfo.unix("/tmp/sock").pfamily     #=> 1 (PF_UNIX)


289
290
291
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 289

def pfamily
  @family
end

#to_sockaddr ⇒ Object Also known as: to_s

call-seq:

addrinfo.to_sockaddr -> string

Returns the socket address as a packed string.

ai = Addrinfo.tcp("localhost", 80)
ai.to_sockaddr  #=> packed sockaddr string


346
347
348
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 346

def to_sockaddr
  @sockaddr
end

#unix? ⇒ Boolean

call-seq:

addrinfo.unix? -> true or false

Returns true if the address is a Unix domain socket address.

Addrinfo.unix("/tmp/sock").unix?      #=> true
Addrinfo.tcp("localhost", 80).unix?  #=> false

Returns:

  • (Boolean) 


361
362
363
 
# File 'mrbgems/mruby-socket/mrblib/socket.rb', line 361

def unix?
  @family == Socket::AF_UNIX
end