class Dnsruby::Name

Constants

MaxNameLength

Attributes

labels[RW]

Public Class Methods

create(arg) click to toggle source

A Name is a collection of Labels. Each label is presentation-formatted
When a Name is wire-encoded, the label array is walked, and each label is wire-encoded.
When a Name is unencoded, each label is unencoded, and added to the Name collection of labels.
When a Name is made from a string, the Name is split into Labels.

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

  • Name

    returns arg

  • String

    returns a new Name

# File lib/dnsruby/name.rb, line 44
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
    arg = punycode(arg)
    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
punycode(d) click to toggle source

Convert IDN domain from Unicode UTF-8 to ASCII punycode @param [Object|String] d Unicode domain with emoji inside @return [String] ASCII punycode domain @example

Dnsruby::Name.punycode('🏳.cf')
=> "xn--en8h.cf"
# File lib/dnsruby/name.rb, line 72
def self.punycode(d)
  begin
    return SimpleIDN.to_ascii(d)
  rescue
    return d
  end
end
split(name) click to toggle source
# File lib/dnsruby/name.rb, line 85
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 151
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 121
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 143
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 160
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 110
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 206
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 240
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 135
def wild?
  if (labels.length == 0)
    return false
  end
  return (labels[0].string == '*')
end