Class: Resolv::IPv6

Inherits:
Object
  • Object
show all
Defined in:
lib/rubysl/resolv/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:



2486
2487
2488
2489
2490
2491
 
# File 'lib/rubysl/resolv/resolv.rb', line 2486

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.



2496
2497
2498
 
# File 'lib/rubysl/resolv/resolv.rb', line 2496

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



2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
 
# File 'lib/rubysl/resolv/resolv.rb', line 2440

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:



2520
2521
2522
 
# File 'lib/rubysl/resolv/resolv.rb', line 2520

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

#eql?(other) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


2524
2525
2526
 
# File 'lib/rubysl/resolv/resolv.rb', line 2524

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

#hash ⇒ Object

:nodoc:



2528
2529
2530
 
# File 'lib/rubysl/resolv/resolv.rb', line 2528

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

#inspect ⇒ Object

:nodoc:



2506
2507
2508
 
# File 'lib/rubysl/resolv/resolv.rb', line 2506

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

#to_name ⇒ Object

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



2515
2516
2517
2518
 
# File 'lib/rubysl/resolv/resolv.rb', line 2515

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

#to_s ⇒ Object

:nodoc:



2498
2499
2500
2501
2502
2503
2504
 
# File 'lib/rubysl/resolv/resolv.rb', line 2498

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