dnssd 1.2 → 1.3

data/lib/dnssd/reply/domain.rb

@@ -0,0 +1,22 @@
+##
+# Returned by DNSSD::Service#enumerate_domains
+
+class DNSSD::Reply::Domain < DNSSD::Reply
+
+  ##
+  # A domain for registration or browsing
+
+  attr_reader :domain
+
+  ##
+  # Creates a new Browse, called internally by
+  # DNSSD::Service#enumerate_domains
+
+  def initialize(service, flags, interface, domain)
+    super service, flags, interface
+
+    @domain = domain
+  end
+
+end
+

data/lib/dnssd/reply/query_record.rb

@@ -0,0 +1,183 @@
+require 'ipaddr'
+
+##
+# Created by DNSSD::Service#query_record
+
+class DNSSD::Reply::QueryRecord < DNSSD::Reply
+
+  ##
+  # A domain for registration or browsing
+
+  attr_reader :domain
+
+  ##
+  # The service name
+
+  attr_reader :name
+
+  ##
+  # DNS Record data
+
+  attr_reader :record
+
+  ##
+  # DNS Record class (only IN is supported)
+
+  attr_reader :record_class
+
+  ##
+  # DNS Record type
+
+  attr_reader :record_type
+
+  ##
+  # Time-to-live for this record.  See #expired?
+
+  attr_reader :ttl
+
+  ##
+  # The service type
+
+  attr_reader :type
+
+  ##
+  # Creates a new QueryRecord, called internally by
+  # DNSSD::Service#query_record
+
+  def initialize(service, flags, interface, fullname, record_type,
+                 record_class, record, ttl)
+    super service, flags, interface
+
+    set_fullname fullname
+
+    @record_type = record_type
+    @record_class = record_class
+    @record = record
+
+    @created = Time.now
+    @ttl = ttl
+  end
+
+  ##
+  # Converts a RFC 1035 character-string into a ruby String
+
+  def character_string_to_string(character_string)
+    length = character_string.slice 0
+    length = length.ord unless Numeric === length
+    string = character_string.slice 1, length
+
+    if string.length != length then
+      raise TypeError,
+        "invalid character string, expected #{length} got #{string.length} in #{@record.inspect}"
+    end
+
+    string
+  end
+
+  ##
+  # Converts a RFC 1035 domain-name into a ruby String
+
+  def domain_name_to_string(domain_name)
+    return '.' if domain_name == "\0"
+
+    domain_name = domain_name.dup
+    string = []
+
+    until domain_name.empty? do
+      string << character_string_to_string(domain_name)
+      domain_name.slice! 0, string.last.length + 1
+    end
+
+    string << nil unless string.last.empty?
+
+    string.join('.')
+  end
+
+  ##
+  # Has this QueryRecord passed its TTL?
+
+  def expired?
+    Time.now > @created + ttl
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %s %s %s %p interface: %s flags: %p>" % [
+      self.class, object_id,
+      fullname, record_class_name, record_type_name, record,
+      interface_name, @flags
+    ]
+  end
+
+  ##
+  # Name of this record's record_class
+
+  def record_class_name
+    return "unknown #{@record_class}" unless @record_class == DNSSD::Record::IN
+    'IN' # Only IN is supported
+  end
+
+  ##
+  # Decodes output for #record, returning the raw record if it can't be
+  # decoded.  Handles:
+  #
+  # A AAAA CNAME MX NS PTR SOA SRV TXT
+
+  def record_data
+    return @record unless @record_class == DNSSD::Record::IN
+
+    case @record_type
+    when DNSSD::Record::A,
+         DNSSD::Record::AAAA then
+      IPAddr.new_ntoh @record
+    when DNSSD::Record::CNAME,
+         DNSSD::Record::NS,
+         DNSSD::Record::PTR then
+      domain_name_to_string @record
+    when DNSSD::Record::MX then
+      mx = @record.unpack 'nZ*'
+      mx[-1] = domain_name_to_string mx.last
+      mx
+    when DNSSD::Record::SOA then
+      soa = @record.unpack 'Z*Z*NNNNN'
+      soa[0] = domain_name_to_string soa[0]
+      soa[1] = domain_name_to_string soa[1]
+      soa
+    when DNSSD::Record::SRV then
+      srv = @record.unpack 'nnnZ*'
+      srv[-1] = domain_name_to_string srv.last
+      srv
+    when DNSSD::Record::TXT then
+      record = @record.dup
+      txt = []
+
+      until record.empty? do
+        txt << character_string_to_string(record)
+        record.slice! 0, txt.last.length + 1
+      end
+
+      txt
+    else
+      @record
+    end
+  end
+
+  ##
+  # Name of this record's record_type
+
+  def record_type_name
+    return "unknown #{@record_type} for record class (#{@record_class})" unless
+      @record_class == DNSSD::Record::IN
+    DNSSD::Record::VALUE_TO_NAME[@record_type]
+  end
+
+  ##
+  # Outputs this record in a BIND-like DNS format
+
+  def to_s
+    "%s %d %s %s %p" % [
+      fullname, ttl, record_class_name, record_type_name, record_data
+    ]
+  end
+
+end
+

data/lib/dnssd/reply/register.rb

@@ -0,0 +1,37 @@
+##
+# Returned by DNSSD::Service#register
+
+class DNSSD::Reply::Register < DNSSD::Reply
+
+  ##
+  # A domain for registration or browsing
+
+  attr_reader :domain
+
+  ##
+  # The service name
+
+  attr_reader :name
+
+  ##
+  # The service type
+
+  attr_reader :type
+
+  ##
+  # Creates a Register, called internally by DNSSD::Service#register
+
+  def initialize(service, flags, name, type, domain)
+    super service, flags, nil
+
+    set_names name, type, domain
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %p flags: %p>" % [
+      self.class, object_id, fullname, @flags
+    ]
+  end
+
+end
+

data/lib/dnssd/reply/resolve.rb

@@ -0,0 +1,105 @@
+##
+# Created by DNSSD::Service#resolve
+
+class DNSSD::Reply::Resolve < DNSSD::Reply
+
+  ##
+  # A domain for registration or browsing
+
+  attr_reader :domain
+
+  ##
+  # The service name
+
+  attr_reader :name
+
+  ##
+  # The port for this service
+
+  attr_reader :port
+
+  ##
+  # The hostname of the host provide the service
+
+  attr_reader :target
+
+  ##
+  # The service's primary text record
+
+  attr_reader :text_record
+
+  ##
+  # The service type
+
+  attr_reader :type
+
+  ##
+  # Creates a new Resolve, called internally by DNSSD::Service#resolve
+
+  def initialize(service, flags, interface, fullname, target, port,
+                 text_record)
+    super service, flags, interface
+
+    set_fullname fullname
+
+    @target = target
+    @port = port
+    @text_record = DNSSD::TextRecord.new text_record
+  end
+
+  ##
+  # Connects to this Reply.  If #target and #port are missing, DNSSD.resolve
+  # is automatically called.
+  #
+  # +family+ can be used to select a particular address family (IPv6 vs IPv4).
+  #
+  # +addrinfo_flags+ are passed to DNSSD::Service#getaddrinfo as flags.
+
+  def connect(family = Socket::AF_UNSPEC, addrinfo_flags = 0)
+    addrinfo_protocol = case family
+                        when Socket::AF_INET   then DNSSD::Service::IPv4
+                        when Socket::AF_INET6  then DNSSD::Service::IPv6
+                        when Socket::AF_UNSPEC then 0
+                        else raise ArgumentError, "invalid family #{family}"
+                        end
+
+    addresses = []
+
+    service = DNSSD::Service.new
+
+    begin
+      service.getaddrinfo target, addrinfo_protocol, addrinfo_flags,
+                          @interface do |addrinfo|
+        address = addrinfo.address
+
+        begin
+          socket = nil
+
+          case protocol
+          when 'tcp' then
+            socket = TCPSocket.new address, port
+          when 'udp' then
+            socket = UDPSocket.new
+            socket.connect address, port
+          end
+
+          return socket
+        rescue
+          next if addrinfo.flags.more_coming?
+          raise
+        end
+      end
+    ensure
+      service.stop
+    end
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %s at %s:%d text_record: %p interface: %s flags: %p>" % [
+      self.class, object_id,
+      fullname, @target, @port, @text_record, interface_name, @flags
+    ]
+  end
+
+end
+

data/lib/dnssd/service.rb

@@ -8,6 +8,11 @@ require 'thread'
 
 class DNSSD::Service
 
+  # :stopdoc:
+  IPv4 = 1 unless const_defined? :IPv4
+  IPv6 = 2 unless const_defined? :IPv6
+  # :startdoc:
+
   ##
   # Creates a new DNSSD::Service
 
@@ -15,6 +20,22 @@ class DNSSD::Service
     @replies = []
     @continue = true
     @thread = nil
+    @type = nil
+  end
+
+  ##
+  # Adds an extra DNS record of +type+ containing +data+.  +ttl+ is in
+  # seconds, use 0 for the default value.  +flags+ are currently ignored.  
+  #
+  # Must be called on a service only after #register.
+  #
+  # Returns the added DNSSD::Record
+
+  def add_record(type, data, ttl = 0, flags = 0)
+    raise TypeError, 'must be called after register' unless @type == :register
+    @records ||= []
+
+    _add_record flags.to_i, type, data, ttl
   end
 
   ##
@@ -37,7 +58,9 @@ class DNSSD::Service
 
     raise DNSSD::Error, 'service in progress' if started?
 
-    _browse type, domain, flags.to_i, interface
+    @type = :browse
+
+    _browse flags.to_i, interface, type, domain
 
     process(&block)
   end
@@ -60,11 +83,9 @@ class DNSSD::Service
   #
   #   available_domains = []
   #   
-  #   timeout(2) do
-  #     DNSSD.enumerate_domains! do |r|
-  #       available_domains << r.domain
-  #     end
-  #   rescue TimeoutError
+  #   service.enumerate_domains! do |r|
+  #     available_domains << r.domain
+  #     break unless r.flags.more_coming?
   #   end
   #   
   #   p available_domains
@@ -77,15 +98,61 @@ class DNSSD::Service
 
     _enumerate_domains flags.to_i, interface
 
+    @type = :enumerate_domains
+
     process(&block)
   end
-  
+
+  ##
+  # Retrieve address information for +host+ on +protocol+
+  #
+  #   addresses = []
+  #   service.getaddrinfo reply.target do |addrinfo|
+  #     addresses << addrinfo.address
+  #     break unless addrinfo.flags.more_coming?
+  #   end
+  #
+  # When using DNSSD on top of the Avahi compatibilty shim you'll need to
+  # setup your /etc/nsswitch.conf correctly.  See
+  # http://avahi.org/wiki/AvahiAndUnicastDotLocal for details
+
+  def getaddrinfo(host, protocol = nil, flags = 0,
+                  interface = DNSSD::InterfaceAny, &block)
+    interface = DNSSD.interface_index interface unless Integer === interface
+
+    if respond_to? :_getaddrinfo then
+      raise DNSSD::Error, 'service in progress' if started?
+
+      _getaddrinfo flags.to_i, interface, protocol, host
+
+      @type = :getaddrinfo
+
+      process(&block)
+    else
+      family = case protocol
+               when IPv4 then Socket::AF_INET
+               when IPv6 then Socket::AF_INET6
+               else protocol
+               end
+
+      addrinfo = Socket.getaddrinfo host, nil, family
+
+      addrinfo.each do |_, _, host, ip, _|
+        sockaddr = Socket.pack_sockaddr_in 0, ip
+        @replies << DNSSD::Reply::AddrInfo.new(self, 0, 0, host, sockaddr, 0)
+      end
+    end
+  end
+
   def inspect # :nodoc:
     stopped = stopped? ? 'stopped' : 'running'
     "#<%s:0x%x %s>" % [self.class, object_id, stopped]
   end
 
-  def process
+  ##
+  # Yields results from the mDNS daemon, blocking until data is available.
+
+  def process # :yields: DNSSD::Result
     @thread = Thread.current
 
     while @continue do
@@ -95,14 +162,45 @@ class DNSSD::Service
 
     @thread = nil
 
+    self
+  rescue DNSSD::ServiceNotRunningError
+    # raised when we jump out of DNSServiceProcess() while it's waiting for a
+    # response
     self
   end
 
+  ##
+  # Retrieves an arbitrary DNS record
+  #
+  # +fullname+ is the full name of the resource record.  +record_type+ is the
+  # type of the resource record (see DNSSD::Resource).
+  #
+  # +flags+ may be either DNSSD::Flags::ForceMulticast or
+  # DNSSD::Flags::LongLivedQuery
+  #
+  #   service.query_record "hostname._afpovertcp._tcp.local",
+  #                        DNSService::Record::SRV do |record|
+  #     p record
+  #   end
+
+  def query_record(fullname, record_type, record_class = DNSSD::Record::IN,
+                   flags = 0, interface = DNSSD::InterfaceAny, &block)
+    interface = DNSSD.interface_index interface unless Integer === interface
+
+    raise DNSSD::Error, 'service in progress' if started?
+
+    _query_record flags.to_i, interface, fullname, record_type, record_class
+
+    @type = :query_record
+
+    process(&block)
+  end
+
   ##
   # Register a service.  A DNSSD::Reply object is passed to the optional block
   # when the registration completes.
   #
-  #   DNSSD.register! "My Files", "_http._tcp", nil, 8080 do |r|
+  #   service.register "My Files", "_http._tcp", nil, 8080 do |r|
   #     puts "successfully registered: #{r.inspect}"
   #   end
 
@@ -110,14 +208,16 @@ class DNSSD::Service
                flags = 0, interface = DNSSD::InterfaceAny, &block)
     check_domain domain
     interface = DNSSD.interface_index interface unless Integer === interface
+    text_record = text_record.encode if text_record
 
     raise DNSSD::Error, 'service in progress' if started?
 
-    _register name, type, domain, host, port, text_record, flags.to_i, interface
+    _register flags.to_i, interface, name, type, domain, host, port,
+              text_record, &block
 
-    block = proc { } unless block
+    @type = :register
 
-    process(&block)
+    process(&block) if block
   end
 
   ##
@@ -135,11 +235,9 @@ class DNSSD::Service
   # The returned service can be used to control when to stop resolving the
   # service (see DNSSD::Service#stop).
   #
-  #   s = DNSSD.resolve "foo bar", "_http._tcp", "local" do |r|
+  #   service.resolve "foo bar", "_http._tcp", "local" do |r|
   #     p r
   #   end
-  #   sleep 2
-  #   s.stop
 
   def resolve(name, type = name.type, domain = name.domain, flags = 0,
               interface = DNSSD::InterfaceAny, &block)
@@ -149,10 +247,19 @@ class DNSSD::Service
 
     raise DNSSD::Error, 'service in progress' if started?
 
-    _resolve name, type, domain, flags.to_i, interface
+    _resolve flags.to_i, interface, name, type, domain
+
+    @type = :resolve
 
     process(&block)
   end
 
+  ##
+  # Returns true if the service has been started.
+
+  def started?
+    not stopped?
+  end
+
 end