class Dnsruby::Name

Dnsruby::Name class

A representation of a DNS name (RFC1035, section 3.1)

methods

Constants

MaxNameLength

Attributes

labels[RW]

Public Class Methods

create(arg) click to toggle source

Creates a new Dnsruby::Name from arg. arg can be :

  • Name

    returns arg

  • String

    returns a new Name

# File lib/Dnsruby/name.rb, line 43
def self.create(arg)
  case arg
  when Name
    return Name.new(arg.labels, arg.absolute?)
  when String
    #        arg.gsub!(/\.$/o, "")
    if (arg==".")
      return Name.new([],true)
    end
    if (arg=="")
      return Name.new([],false)
    end
    return Name.new(split_escaped(arg), /\.\z/ =~ arg ? true : false)
    #        return Name.new(Label.split(arg), /\.\z/ =~ arg ? true : false)
  when Array
    return Name.new(arg, /\.\z/ =~ (arg.last ? ((arg.last.kind_of?String)?arg.last : arg.last.string) : arg.last) ? true : false)
  else        
    raise ArgumentError.new("cannot interpret as DNS name: #{arg.inspect}")
  end
end
split(name) click to toggle source
# File lib/Dnsruby/name.rb, line 69
def self.split(name)
  encodedlabels = name2encodedlabels(name)
  labels = encodedlabels.each  {|el| Name.decode(el.to_s)}
  return labels
end

Public Instance Methods

<=>(other) click to toggle source
# File lib/Dnsruby/name.rb, line 135
def <=>(other)
  # return -1 if other less than us, +1 if greater than us
  return 0 if (canonical == other.canonical)
  if (canonically_before(other))
    return +1
  end
  return -1
end
absolute?() click to toggle source

Returns true if this Name is absolute

# File lib/Dnsruby/name.rb, line 105
def absolute?
  return @absolute
end
canonical() click to toggle source

Return the canonical form of this name (RFC 4034 section 6.2)

# File lib/Dnsruby/name.rb, line 127
def canonical
  #
  return MessageEncoder.new {|msg|
    msg.put_name(self, true)
  }.to_s

end
canonically_before(n) click to toggle source
# File lib/Dnsruby/name.rb, line 144
def canonically_before(n)
  if (!(Name === n))
    n = Name.create(n)
  end
  # Work out whether this name is canonically before the passed Name
  # RFC 4034 section 6.1
  # For the purposes of DNS security, owner names are ordered by treating
  #individual labels as unsigned left-justified octet strings.  The
  #absence of a octet sorts before a zero value octet, and uppercase
  #US-ASCII letters are treated as if they were lowercase US-ASCII
  #letters.
  #To compute the canonical ordering of a set of DNS names, start by
  #sorting the names according to their most significant (rightmost)
  #labels.  For names in which the most significant label is identical,
  #continue sorting according to their next most significant label, and
  #so forth.

  # Get the list of labels for both names, and then swap them
  my_labels = @labels.reverse
  other_labels = n.labels.reverse
  my_labels.each_index {|i|
    if (!other_labels[i])
      return false
    end
    next if (other_labels[i].downcase == my_labels[i].downcase)
    return (my_labels[i].downcase < other_labels[i].downcase)
  }
  return true
end
downcase() click to toggle source
# File lib/Dnsruby/name.rb, line 94
def downcase
  labels = []
  @labels.each do |label| labels << Label.new(label.downcase) end
  return Name.new(labels)
end
subdomain_of?(other) click to toggle source

Tests subdomain-of relation : returns true if this name is a subdomain of other.

domain = Resolv::Name.create("y.z")
p Resolv::Name.create("w.x.y.z").subdomain_of?(domain) #=> true
p Resolv::Name.create("x.y.z").subdomain_of?(domain) #=> true
p Resolv::Name.create("y.z").subdomain_of?(domain) #=> false
p Resolv::Name.create("z").subdomain_of?(domain) #=> false
p Resolv::Name.create("x.y.z.").subdomain_of?(domain) #=> false
p Resolv::Name.create("w.z").subdomain_of?(domain) #=> false
# File lib/Dnsruby/name.rb, line 190
def subdomain_of?(other)
  raise ArgumentError, "not a domain name: #{other.inspect}" unless Name === other
  return false if @absolute != other.absolute?
  other_len = other.length
  return false if @labels.length <= other_len
  return @labels[-other_len, other_len] == other.to_a
end
to_s(include_absolute=false) click to toggle source

returns the domain name as a string.

The domain name doesn't have a trailing dot even if the name object is absolute.

Example :

p Resolv::Name.create("x.y.z.").to_s #=> "x.y.z"
p Resolv::Name.create("x.y.z").to_s #=> "x.y.z"
# File lib/Dnsruby/name.rb, line 224
def to_s(include_absolute=false)
  ret = to_str(@labels)
  if (@absolute && include_absolute)
    ret += "."
  end
  return ret
end
wild?() click to toggle source

Is this name a wildcard?

# File lib/Dnsruby/name.rb, line 119
def wild?
  if (labels.length == 0)
    return false
  end
  return (labels[0].string == '*')
end