Class: Resolv::IPv6

Inherits:
Object
  • Object
show all
Defined in:
lib/resolv.rb

Overview

A Resolv::DNS IPv6 address.

Constant Summary collapse

Regex_8Hex =

IPv6 address format a:b:c:d:e:f:g:h

/\A
(?:[0-9A-Fa-f]{1,4}:){7}
   [0-9A-Fa-f]{1,4}
\z/x
Regex_CompressedHex =

Compressed IPv6 address format a::b

/\A
((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
\z/x
Regex_6Hex4Dec =

IPv4 mapped IPv6 address format a:b:c:d:e:f:w.x.y.z

/\A
((?:[0-9A-Fa-f]{1,4}:){6,6})
(\d+)\.(\d+)\.(\d+)\.(\d+)
\z/x
Regex_CompressedHex4Dec =

Compressed IPv4 mapped IPv6 address format a::b:w.x.y.z

/\A
((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
((?:[0-9A-Fa-f]{1,4}:)*)
(\d+)\.(\d+)\.(\d+)\.(\d+)
\z/x
Regex =

A composite IPv6 address Regexp.

/
(?:#{Regex_8Hex}) |
(?:#{Regex_CompressedHex}) |
(?:#{Regex_6Hex4Dec}) |
(?:#{Regex_CompressedHex4Dec})/x

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(address) ⇒ IPv6

:nodoc:



2337
2338
2339
2340
2341
2342
 
# File 'lib/resolv.rb', line 2337

def initialize(address) # :nodoc:
  unless address.kind_of?(String) && address.length == 16
    raise ArgumentError.new('IPv6 address must be 16 bytes')
  end
  @address = address
end

Instance Attribute Details

#address ⇒ Object (readonly)

The raw IPv6 address as a String.



2347
2348
2349
 
# File 'lib/resolv.rb', line 2347

def address
  @address
end

Class Method Details

.create(arg) ⇒ Object

Creates a new IPv6 address from arg which may be:

IPv6

returns arg.

String

arg must match one of the IPv6::Regex* constants



2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
 
# File 'lib/resolv.rb', line 2291

def self.create(arg)
  case arg
  when IPv6
    return arg
  when String
    address = ''
    if Regex_8Hex =~ arg
      arg.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
    elsif Regex_CompressedHex =~ arg
      prefix = $1
      suffix = $2
      a1 = ''
      a2 = ''
      prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
      suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
      omitlen = 16 - a1.length - a2.length
      address << a1 << "\0" * omitlen << a2
    elsif Regex_6Hex4Dec =~ arg
      prefix, a, b, c, d = $1, $2.to_i, $3.to_i, $4.to_i, $5.to_i
      if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
        prefix.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
        address << [a, b, c, d].pack('CCCC')
      else
        raise ArgumentError.new("not numeric IPv6 address: " + arg)
      end
    elsif Regex_CompressedHex4Dec =~ arg
      prefix, suffix, a, b, c, d = $1, $2, $3.to_i, $4.to_i, $5.to_i, $6.to_i
      if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
        a1 = ''
        a2 = ''
        prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
        suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
        omitlen = 12 - a1.length - a2.length
        address << a1 << "\0" * omitlen << a2 << [a, b, c, d].pack('CCCC')
      else
        raise ArgumentError.new("not numeric IPv6 address: " + arg)
      end
    else
      raise ArgumentError.new("not numeric IPv6 address: " + arg)
    end
    return IPv6.new(address)
  else
    raise ArgumentError.new("cannot interpret as IPv6 address: #{arg.inspect}")
  end
end

Instance Method Details

#==(other) ⇒ Object

:nodoc:



2371
2372
2373
 
# File 'lib/resolv.rb', line 2371

def ==(other) # :nodoc:
  return @address == other.address
end

#eql?(other) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


2375
2376
2377
 
# File 'lib/resolv.rb', line 2375

def eql?(other) # :nodoc:
  return self == other
end

#hash ⇒ Object

:nodoc:



2379
2380
2381
 
# File 'lib/resolv.rb', line 2379

def hash # :nodoc:
  return @address.hash
end

#inspect ⇒ Object

:nodoc:



2357
2358
2359
 
# File 'lib/resolv.rb', line 2357

def inspect # :nodoc:
  return "#<#{self.class} #{self.to_s}>"
end

#to_name ⇒ Object

Turns this IPv6 address into a Resolv::DNS::Name. – ip6.arpa should be searched too. [RFC3152]



2366
2367
2368
2369
 
# File 'lib/resolv.rb', line 2366

def to_name
  return DNS::Name.new(
    @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
end

#to_s ⇒ Object

:nodoc:



2349
2350
2351
2352
2353
2354
2355
 
# File 'lib/resolv.rb', line 2349

def to_s # :nodoc:
  address = sprintf("%X:%X:%X:%X:%X:%X:%X:%X", *@address.unpack("nnnnnnnn"))
  unless address.sub!(/(^|:)0(:0)+(:|$)/, '::')
    address.sub!(/(^|:)0(:|$)/, '::')
  end
  return address
end