Class: Dnsruby::IPv6

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

Overview

Dnsruby::IPv6 class

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 =

Compresses IPv6 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:



101
102
103
104
105
106
 
# File 'lib/dnsruby/ipv6.rb', line 101

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



109
110
111
 
# File 'lib/dnsruby/ipv6.rb', line 109

def address
  @address
end

Class Method Details

.create(arg) ⇒ Object

Created a new IPv6 address from arg which may be:

  • IPv6

    returns arg

  • String

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



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/dnsruby/ipv6.rb', line 55

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:



132
133
134
 
# File 'lib/dnsruby/ipv6.rb', line 132

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

#eql?(other) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


136
137
138
 
# File 'lib/dnsruby/ipv6.rb', line 136

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

#hash ⇒ Object 



140
141
142
 
# File 'lib/dnsruby/ipv6.rb', line 140

def hash
  return @address.hash
end

#inspect ⇒ Object

:nodoc:



119
120
121
 
# File 'lib/dnsruby/ipv6.rb', line 119

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

#to_name ⇒ Object

Turns this IPv6 address into a Dnsruby::Name –

ip6.arpa should be searched too. [RFC3152]



126
127
128
129
130
 
# File 'lib/dnsruby/ipv6.rb', line 126

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

#to_s ⇒ Object 



111
112
113
114
115
116
117
 
# File 'lib/dnsruby/ipv6.rb', line 111

def to_s
  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