dnssd 2.0.1 → 3.0.0

data/lib/dnssd.rb

@@ -13,7 +13,7 @@ module DNSSD
   ##
   # The version of DNSSD you're using.
 
-  VERSION = '2.0.1'
+  VERSION = '3.0.0'
 
   ##
   # Registers +socket+ with DNSSD as +name+.  If +service+ is omitted it is
@@ -32,7 +32,7 @@ module DNSSD
 
     raise ArgumentError, 'socket not bound' if port == 0
 
-    service ||= DNSSD.getservbyport port
+    service ||= Socket.getservbyport port
 
     proto = case socket
             when TCPSocket then 'tcp'
@@ -65,38 +65,29 @@ module DNSSD
   ##
   # Asynchronous version of DNSSD::Service#browse
 
-  def self.browse(type, domain = nil, flags = 0,
-                  interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    Thread.start do
-      run(service, :browse, type, domain, flags, interface, &block)
-    end
-
+  def self.browse type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny
+    service = DNSSD::Service.browse type, domain, flags, interface
+    service.async_each { |r| yield r }
     service
   end
 
   ##
   # Synchronous version of DNSSD::Service#browse
 
-  def self.browse!(type, domain = nil, flags = 0,
-                  interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    run(service, :browse, type, domain, flags, interface, &block)
+  def self.browse! type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny
+    service = DNSSD::Service.browse type, domain, flags, interface
+    service.each { |r| yield r }
+  ensure
+    service.stop
   end
 
   ##
   # Asynchronous version of DNSSD::Service#enumerate_domains
 
-  def self.enumerate_domains(flags = DNSSD::Flags::BrowseDomains,
-                             interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    Thread.start do
-      run(service, :enumerate_domains, flags, interface, &block)
-    end
-
+  def self.enumerate_domains flags = DNSSD::Flags::BrowseDomains,
+                             interface = DNSSD::InterfaceAny
+    service = DNSSD::Service.enumerate_domains flags, interface
+    service.async_each { |r| yield r }
     service
   end
 
@@ -105,27 +96,21 @@ module DNSSD
 
   def self.enumerate_domains!(flags = DNSSD::Flags::BrowseDomains,
                               interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    run(service, :enumerate_domains, flags, interface, &block)
+    service = DNSSD::Service.enumerate_domains flags, interface
+    service.each { |r| yield r }
+  ensure
+    service.stop
   end
 
   ##
   # Asynchronous version of DNSSD::Service#register
 
   def self.register(name, type, domain, port, text_record = nil, flags = 0,
-                    interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    if block_given? then
-      Thread.start do
-        run(service, :register, name, type, domain, port, nil, text_record,
-            flags, interface, &block)
-      end
-    else
-      service.register name, type, domain, port, nil, text_record, flags,
-                       interface
-    end
+                    interface = DNSSD::InterfaceAny)
+    service = DNSSD::Service.register name, type, domain, port, nil,
+      text_record, flags, interface
+
+    service.async_each { |r| yield r } if block_given?
 
     service
   end
@@ -135,53 +120,32 @@ module DNSSD
 
   def self.register!(name, type, domain, port, text_record = nil, flags = 0,
                      interface = DNSSD::InterfaceAny, &block)
-    service = DNSSD::Service.new
-
-    if block_given? then
-      run(service, :register, name, type, domain, port, nil, text_record, flags,
-          interface, &block)
-    else
-      service.register name, type, domain, port, nil, text_record, flags,
-                       interface
-    end
+    service = DNSSD::Service.register name, type, domain, port, nil,
+      text_record, flags, interface
 
-    service
+    service.each { |r| yield r } if block_given?
+  ensure
+    service.stop
   end
 
   ##
   # Asynchronous version of DNSSD::Service#resolve
 
-  def self.resolve(*args, &block)
-    service = DNSSD::Service.new
-
-    Thread.start do
-      run(service, :resolve, *args, &block)
-    end
-
+  def self.resolve(*args)
+    service = DNSSD::Service.resolve(*args)
+    service.async_each { |r| yield r }
     service
   end
 
   ##
   # Synchronous version of DNSSD::Service#resolve
 
-  def self.resolve!(*args, &block)
-    service = DNSSD::Service.new
-
-    run(service, :resolve, *args, &block)
-  end
-
-  ##
-  # Dispatches +args+ and +block+ to +method+ on +service+ and ensures
-  # +service+ is shut down after use.
-
-  def self.run(service, method, *args, &block)
-    service.send(method, *args, &block)
-
-    service
+  def self.resolve!(*args)
+    service = DNSSD::Service.resolve(*args)
+    service.each { |r| yield r }
   ensure
-    service.stop unless service.stopped?
+    service.stop if service
   end
-
 end
 
 require 'socket'

data/lib/dnssd/reply/browse.rb

@@ -34,7 +34,7 @@ class DNSSD::Reply::Browse < DNSSD::Reply
   def connect(family = Socket::AF_UNSPEC, addrinfo_flags = 0)
     value = nil
 
-    DNSSD.resolve! self do |reply|
+    DNSSD.resolve! name, type, domain do |reply|
       value = reply
       break
     end
@@ -42,11 +42,14 @@ class DNSSD::Reply::Browse < DNSSD::Reply
     value.connect family, addrinfo_flags
   end
 
+  def resolve
+    service = DNSSD::Service.resolve name, type, domain
+    service.first
+  end
+
   def inspect # :nodoc:
     "#<%s:0x%x %p interface: %s flags: %p>" % [
       self.class, object_id, fullname, interface_name, @flags
     ]
   end
-
 end
-

data/lib/dnssd/reply/query_record.rb

@@ -178,6 +178,4 @@ class DNSSD::Reply::QueryRecord < DNSSD::Reply
       fullname, ttl, record_class_name, record_type_name, record_data
     ]
   end
-
 end
-

data/lib/dnssd/reply/register.rb

@@ -27,6 +27,11 @@ class DNSSD::Reply::Register < DNSSD::Reply
     set_names name, type, domain
   end
 
+  def resolve
+    service = DNSSD::Service.resolve name, type, domain
+    service.first
+  end
+
   def inspect # :nodoc:
     "#<%s:0x%x %p flags: %p>" % [
       self.class, object_id, fullname, @flags

data/lib/dnssd/reply/resolve.rb

@@ -63,10 +63,10 @@ class DNSSD::Reply::Resolve < DNSSD::Reply
                         else raise ArgumentError, "invalid family #{family}"
                         end
 
-    service = DNSSD::Service.new
+    service = DNSSD::Service.getaddrinfo target, addrinfo_protocol,
+      addrinfo_flags, @interface
 
-    service.getaddrinfo target, addrinfo_protocol, addrinfo_flags,
-                        @interface do |addrinfo|
+    service.each do |addrinfo|
       address = addrinfo.address
 
       begin
@@ -80,6 +80,7 @@ class DNSSD::Reply::Resolve < DNSSD::Reply
           socket.connect address, port
         end
 
+        service.stop
         return socket
       rescue
         next if addrinfo.flags.more_coming?

data/lib/dnssd/service.rb

@@ -8,35 +8,42 @@ require 'thread'
 # DNSSD::Service provides the raw DNS-SD functions via the +_+ variants.
 
 class DNSSD::Service
+  include Enumerable
 
   # :stopdoc:
   IPv4 = 1 unless const_defined? :IPv4
   IPv6 = 2 unless const_defined? :IPv6
   # :startdoc:
 
+  class << self; private :new; end
+
   ##
   # Creates a new DNSSD::Service
 
   def initialize
-    @replies = []
+    @replies  = []
     @continue = true
-    @thread = nil
-    @type = nil
+    @thread   = nil
+    @lock     = Mutex.new
   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
+  class Register < ::DNSSD::Service
+    def initialize
+      super
+      @records = []
+    end
 
-  def add_record(type, data, ttl = 0, flags = 0)
-    raise TypeError, 'must be called after register' unless @type == :register
-    @records ||= []
+    ##
+    # 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
 
-    _add_record flags.to_i, type, data, ttl
+    def add_record type, data, ttl = 0, flags = 0
+      @records << _add_record(flags.to_i, type, data, ttl)
+    end
   end
 
   ##
@@ -52,56 +59,77 @@ class DNSSD::Service
   #   rescue Timeout::Error
   #   end
 
-  def browse(type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny,
-             &block)
+  def self.browse type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny
     check_domain domain
     interface = DNSSD.interface_index interface unless Integer === interface
 
-    raise DNSSD::Error, 'service in progress' if started?
+    _browse flags.to_i, interface, type, domain
+  end
 
-    @type = :browse
+  def each timeout = :never
+    raise DNSSD::Error, 'already stopped' unless @continue
 
-    _browse flags.to_i, interface, type, domain
+    return enum_for __method__, timeout unless block_given?
+
+    io = IO.new ref_sock_fd
+    rd = [io]
+
+    start_at = clock_time
+
+    while @continue
+      break unless timeout == :never || clock_time - start_at < timeout
 
-    process(&block)
+      if IO.select rd, nil, nil, 1
+        begin
+          process_result
+        rescue DNSSD::UnknownError
+        end
+        @replies.each { |r| yield r }
+        @replies.clear
+      end
+    end
+  end
+
+  def async_each timeout = :never
+    @lock.synchronize do
+      raise DNSSD::Error, 'already stopped' unless @continue
+      @thread = Thread.new { each(timeout) { |r| yield r } }
+    end
+  end
+
+  def push record
+    @replies << record
   end
 
   ##
   # Raises an ArgumentError if +domain+ is too long including NULL terminator
   # and trailing '.'
 
-  def check_domain(domain)
+  def self.check_domain(domain)
     return unless domain
     raise ArgumentError, 'domain name string is too long' if
       domain.length >= MAX_DOMAIN_NAME - 1
   end
 
+
   ##
   # Enumerate domains available for browsing and registration.
   #
   # For each domain found a DNSSD::Reply object is passed to block with
   # #domain set to the enumerated domain.
   #
-  #   available_domains = []
-  #   
-  #   service.enumerate_domains! do |r|
-  #     available_domains << r.domain
+  #   service = DNSSD::Service.enumerate_domains
+  #
+  #   service.each do |r|
+  #     p r.domain
   #     break unless r.flags.more_coming?
   #   end
-  #   
-  #   p available_domains
 
-  def enumerate_domains(flags = DNSSD::Flags::BrowseDomains,
+  def self.enumerate_domains(flags = DNSSD::Flags::BrowseDomains,
                         interface = DNSSD::InterfaceAny, &block)
     interface = DNSSD.interface_index interface unless Integer === interface
 
-    raise DNSSD::Error, 'service in progress' if started?
-
     _enumerate_domains flags.to_i, interface
-
-    @type = :enumerate_domains
-
-    process(&block)
   end
 
   ##
@@ -117,18 +145,12 @@ class DNSSD::Service
   # setup your /etc/nsswitch.conf correctly.  See
   # http://avahi.org/wiki/AvahiAndUnicastDotLocal for details
 
-  def getaddrinfo(host, protocol = 0, flags = 0,
+  def self.getaddrinfo(host, protocol = 0, 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?
-
+    if respond_to? :_getaddrinfo, true then
       _getaddrinfo flags.to_i, interface, protocol, host
-
-      @type = :getaddrinfo
-
-      process(&block)
     else
       family = case protocol
                when IPv4 then Socket::AF_INET
@@ -138,43 +160,15 @@ class DNSSD::Service
 
       addrinfo = Socket.getaddrinfo host, nil, family
 
-      addrinfo.each do |_, _, a_host, ip, _|
+      list = addrinfo.map do |_, _, a_host, ip, _|
         sockaddr = Socket.pack_sockaddr_in 0, ip
-        @replies << DNSSD::Reply::AddrInfo.new(self, 0, 0, a_host, sockaddr, 0)
+        DNSSD::Reply::AddrInfo.new(self, 0, 0, a_host, sockaddr, 0)
       end
+      def list.stop; end
+      list
     end
   end
 
-  def inspect # :nodoc:
-    stopped = stopped? ? 'stopped' : 'running'
-    "#<%s:0x%x %s>" % [self.class, object_id, stopped]
-  end
-
-  ##
-  # Yields results from the mDNS daemon, blocking until data is available.
-  # Use break or return when you wish to stop receiving results.
-  #
-  # The service is automatically stopped after calling this method.
-
-  def process # :yields: DNSSD::Result
-    @thread = Thread.current
-
-    while @continue do
-      _process if @replies.empty?
-      yield @replies.shift until @replies.empty?
-    end
-
-    @thread = nil
-
-    self
-  rescue DNSSD::ServiceNotRunningError
-    # raised when we jump out of DNSServiceProcess() while it's waiting for a
-    # response
-    self
-  ensure
-    stop unless stopped?
-  end
-
   ##
   # Retrieves an arbitrary DNS record
   #
@@ -189,17 +183,11 @@ class DNSSD::Service
   #     p record
   #   end
 
-  def query_record(fullname, record_type, record_class = DNSSD::Record::IN,
-                   flags = 0, interface = DNSSD::InterfaceAny, &block)
+  def self.query_record(fullname, record_type, record_class = DNSSD::Record::IN,
+                   flags = 0, interface = DNSSD::InterfaceAny)
     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
 
   ##
@@ -210,20 +198,13 @@ class DNSSD::Service
   #     puts "successfully registered: #{r.inspect}"
   #   end
 
-  def register(name, type, domain, port, host = nil, text_record = nil,
-               flags = 0, interface = DNSSD::InterfaceAny, &block)
+  def self.register(name, type, domain, port, host = nil, text_record = nil,
+               flags = 0, interface = DNSSD::InterfaceAny)
     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 flags.to_i, interface, name, type, domain, host, port,
-              text_record, &block
-
-    @type = :register
-
-    process(&block) if block
+    _register flags.to_i, interface, name, type, domain, host, port, text_record
   end
 
   ##
@@ -242,27 +223,39 @@ class DNSSD::Service
   #     p r
   #   end
 
-  def resolve(name, type = name.type, domain = name.domain, flags = 0,
-              interface = DNSSD::InterfaceAny, &block)
+  def self.resolve(name, type = name.type, domain = name.domain, flags = 0,
+              interface = DNSSD::InterfaceAny)
     name = name.name if DNSSD::Reply === name
     check_domain domain
     interface = DNSSD.interface_index interface unless Integer === interface
 
-    raise DNSSD::Error, 'service in progress' if started?
-
     _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?
+    @continue
   end
 
-end
+  def stop
+    raise DNSSD::Error, 'service is already stopped' unless started?
+    @continue = false
+    @thread.join if @thread
+    _stop
+    self
+  end
 
+  private
+
+  if defined? Process::CLOCK_MONOTONIC
+    def clock_time
+      Process.clock_gettime Process::CLOCK_MONOTONIC
+    end
+  else
+    def clock_time
+      Time.now
+    end
+  end
+end