toolmantim-zeroconf 0.0.2

data/README.rdoc

@@ -0,0 +1,44 @@
+= Zeroconf
+
+Frankenstein marriage of net-mdns and dnssd.
+
+
+== Installation
+
+  sudo gem sources -a http://gems.github.com
+  sudo gem install lachie-zeroconf
+  
+== Usage
+
+Use zeroconf like dnssd. If you find a disparity between the pure and ext that trips you up, send me a patch!
+
+Currently I'm thinking that the interface should be more dnssd-like, since I develop an a mac and get that for free :)
+
+The basic discovery and publishing interfaces are similar. However the details, semantics (esp threading model, exceptions) and implementations are obviously quite different.
+
+== Raison d'être
+
+The interfaces of the C-based dnssd and pure ruby net-mdns are quite similar. However, there's no gem-based mechanism for switching between them based on availability.
+
+This has lead to the forking of many of the *jour apps into dnssd and net-mdns based versions.
+
+Zeroconf provides:
+
+* a json-gem-style way of falling back to the pure-ruby implementation if the ext doesn't work.
+* bridging discrepancies between the two extant libraries' implementations.
+* perhaps a rubycocoa based implementation for osx.
+
+Additionally, I'm hoping that this fork will breathe new life into the maintenance and development of the code; net-mdns 0.4.0 was released on 2006-05-30; dnssd 0.6.0 was released on 2004-10-07.
+
+== Thanks
+
+To the original authors of
+
+* dnssd: Charlie Mills, Rich Kilmer, Chad Fowler and Stuart Cheshire.
+* net-mdns: Sam Roberts
+
+== TODO
+
+* make the build failing warn but be non-fatal, so that the gem will install on systems without dnssd native libraries.
+* make a windows gem.
+* continue bridging discrepancies between dnssd and net-mdns interfaces

data/Rakefile

@@ -0,0 +1,71 @@
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+end
+require 'rake/clean'
+
+require 'rbconfig'
+include Config
+
+require "./lib/zeroconf/version"
+
+PKG = "zeroconf"
+ON_WINDOWS = RUBY_PLATFORM =~ /mswin32/i 
+EXT_ROOT   = "ext"
+EXT_DL     = "#{EXT_ROOT}/rdnssd.#{CONFIG['DLEXT']}"
+EXT_SRC    = FileList.new("#{EXT_ROOT}/*.c","#{EXT_ROOT}/*.h")
+CLEAN.include 'doc', 'coverage',
+  FileList["ext/**/*.{so,bundle,#{CONFIG['DLEXT']},o,obj,pdb,lib,manifest,exp,def}"],
+  FileList["ext/**/Makefile"]
+
+desc "compile the native extension"
+task :compile => EXT_DL
+
+file EXT_DL => EXT_SRC do
+  cd EXT_ROOT do
+    ruby 'extconf.rb'
+    sh 'make'
+  end
+end
+
+
+zeroconf_gemspec = Gem::Specification.new do |s|
+  s.name             = PKG
+  s.version          = Zeroconf::VERSION
+  s.platform         = Gem::Platform::RUBY
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.summary          = "Cross-platform zeroconf (aka bonjour™) library."
+  s.description      = s.summary
+  s.authors          = ["Lachie Cox"]
+  s.email            = "lachiec@gmail.com"
+  s.homepage         = "http://github.com/lachie/zeroconf"
+  s.require_path     = "lib"
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{bin,lib,spec,originals,samples,test}/**/*")
+end
+
+Rake::GemPackageTask.new(zeroconf_gemspec) do |pkg|
+  pkg.gem_spec = zeroconf_gemspec
+end
+
+namespace :gem do
+  namespace :spec do
+    desc "Update #{PKG}.gemspec"
+    task :generate do
+      File.open("#{PKG}.gemspec", "w") do |f|
+        f.puts(zeroconf_gemspec.to_ruby)
+      end
+    end
+    
+    desc "test spec in github cleanroom"
+    task :test => :generate do
+      require 'rubygems/specification'
+      data = File.read("#{PKG}.gemspec")
+      spec = nil
+      Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+      puts spec
+    end
+  end
+end
+
+task :install => [ :compile, :package ]

data/lib/dnssd.rb

@@ -0,0 +1,137 @@
+require 'rdnssd'
+
+=begin
+
+module DNSSD
+  class MalformedDomainException < Exception; end
+  class MalformedPortException < Exception; end
+  
+  def self.new_text_record(hash={})
+    TextRecord.new(hash)
+  end
+
+  class ServiceDescription
+  
+    class Location
+      attr_accessor :name, :port, :iface
+      def initialize(port, name=nil, iface=0)
+        @name = name
+        @port = port
+        @iface = iface
+      end
+    end
+
+    def initialize(type, name, domain, location)
+      @type = type
+      @name = name
+      @domain = validate_domain(domain)
+      @location = validate_location(location)
+    end
+    
+    def self.for_browse_notification(name, domain, 
+
+    def stop
+      @registrar.stop
+    end
+
+    def validate_location(location)
+      unless(location.port.respond_to?(:to_int))
+        raise MalformedPortException.new("#{location.port} is not a valid port number")
+      end
+      location
+    end
+
+    def validate_domain(domain)
+      unless(domain.empty? || domain =~ /^[a-z_]+$/)
+	      raise MalformedDomainException.new("#{domain} is not a valid domain name")
+      end
+      domain
+    end
+
+    def advertise_and_confirm
+      thread = Thread.current
+       @registrar = register(@name, @type, @domain, @location.port, TextRecord.new) do |service, name, type, domain|
+        @name = name
+        @type = type
+        @domain = domain
+        thread.wakeup
+      end
+      Thread.stop
+    end
+
+    def self.advertise_http(name, port=80, domain="", iface=0, &block)
+      self.advertise("_http._tcp", name, port, domain, iface, &block)
+    end
+    
+    ##
+    # iface: Numerical interface (0 = all interfaces, This should be used for most applications)
+    #
+    def self.advertise(type, name, port, domain="", iface=0, &block)
+      service_description = ServiceDescription.new(type, name, domain, Location.new(port,nil,iface))
+      service_description.advertise_and_confirm 
+      yield service_description if block_given?
+      service_description
+    end
+  end
+
+  class Browser
+  
+    Context = Struct.new(:service, :name, :type, :domain, :operation, :interface)
+    
+    class Context
+      def ==(other)
+        self.to_s == other.to_s
+      end
+      
+      def to_s
+        "#{name}.#{type}.#{domain}"
+      end
+      
+      def eql?(other)
+        self == other
+      end
+      
+      def hash
+        to_s.hash
+      end
+    end
+  
+    def on_change(&block)
+      @change_listener ||= []
+      @change_listeners << block
+    end
+    
+    def on_add(&block)
+      @add_listeners || = []
+      @add_listeners << block
+    end
+    
+    def on_remove(&block)
+      @remove_listeners || = []
+      @remove_listeners << block
+    end
+    
+    def initialize(type, domain="")
+      @list = []
+      @browse_service = DNSSD::Protocol.browse(type, domain) do 
+         |service, name, type, domain, operation, interface|
+         context = Context.new(service, name, type, domain, operation, interface)
+         puts "Name: #{name} Type: #{type} Domain: #{domain} Operation: #{operation} Interface: #{interface}"
+      end
+    end
+    
+    def service_descriptions
+      @list.clone
+    end
+
+    def stop
+      @browse_service.stop
+    end
+
+    def self.for_http(domain="")
+      self.new("_http._tcp", domain)
+    end
+  end
+end
+
+=end

data/lib/net/dns.rb

@@ -0,0 +1,49 @@
+=begin
+  Copyright (C) 2005 Sam Roberts
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+require 'net/dns/resolvx'
+
+BasicSocket.do_not_reverse_lookup = true
+
+module Net
+  # DNS exposes some of Resolv::DNS from resolv.rb to make them easier to use
+  # outside of the context of the Resolv class and it's DNS resolver - such as
+  # in MDNS. In particular, Net::DNS can be included so that full names to DNS
+  # classes in Resolv::DNS can be imported into your namespace.
+  module DNS
+
+    Message      = Resolv::DNS::Message
+    Name         = Resolv::DNS::Name
+    DecodeError  = Resolv::DNS::DecodeError
+
+    module IN
+      A      = Resolv::DNS::Resource::IN::A
+      AAAA   = Resolv::DNS::Resource::IN::AAAA
+      ANY    = Resolv::DNS::Resource::IN::ANY
+      CNAME  = Resolv::DNS::Resource::IN::CNAME
+      HINFO  = Resolv::DNS::Resource::IN::HINFO
+      MINFO  = Resolv::DNS::Resource::IN::MINFO
+      MX     = Resolv::DNS::Resource::IN::MX
+      NS     = Resolv::DNS::Resource::IN::NS
+      PTR    = Resolv::DNS::Resource::IN::PTR
+      SOA    = Resolv::DNS::Resource::IN::SOA
+      SRV    = Resolv::DNS::Resource::IN::SRV
+      TXT    = Resolv::DNS::Resource::IN::TXT
+      WKS    = Resolv::DNS::Resource::IN::WKS
+    end
+
+    # Returns the resource record name of +rr+ as a short string ("IN::A",
+    # ...).
+    def self.rrname(rr)
+      rr = rr.class unless rr.class == Class
+      rr = rr.to_s.sub(/.*Resource::/, '')
+      rr = rr.to_s.sub(/.*DNS::/, '')
+    end
+  end
+end
+

data/lib/net/dns/mdns-sd.rb

@@ -0,0 +1,240 @@
+=begin
+  Copyright (C) 2005 Sam Roberts
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+require 'net/dns/mdns'
+
+module Net
+  module DNS
+
+    # = DNS-SD over mDNS
+    #
+    # An implementation of DNS Service-Discovery (DNS-SD) using Net::DNS::MDNS.
+    #
+    # DNS-SD is described in draft-cheshire-dnsext-dns-sd.txt, see
+    # http://www.dns-sd.org for more information. It is most often seen as part
+    # of Apple's OS X, but is widely useful.
+    #
+    # These APIs accept and return a set of arguments which are documented once,
+    # here, for convenience.
+    #
+    # - type: DNS-SD classifies services into types using a naming convention.
+    #   That convention is <_service>.<_protocol>.  The underscores ("_") serve
+    #   to differentiate from normal DNS names. Protocol is always one of
+    #   "_tcp" or "_udp". The service is a short name, see the list at
+    #   http://www.dns-sd.org/ServiceTypes.html. A common service is "http", the type
+    #   of which would be "_http._tcp".
+    #
+    # - domain: Services operate in a domain, theoretically. In current practice,
+    #   that domain is always "local".
+    #
+    # - name: Service lookup with #browse results in a name of a service of that
+    #   type. That name is associated with a target (a host name), port,
+    #   priority, and weight, as well as series of key to value mappings,
+    #   specific to the service. In practice, priority and weight are widely
+    #   ignored.
+    #
+    # - fullname: The concatention of the service name (optionally), type, and
+    #   domain results in a single dot-seperated domain name - the "fullname".
+    #   See Util.parse_name for more information about the format.
+    #
+    # - text_record: Service information in the form of key/value pairs.
+    #   See Util.parse_strings for more information about the format.
+    #
+    # - flags: should return flags, similar to DNSSD, but for now we just return the
+    #   TTL of the DNS message. A TTL of zero means a deregistration of the record.
+    #
+    # Services are advertised and resolved over specific network interfaces.
+    # Currently, Net::DNS::MDNS supports only a single default interface, and
+    # the interface will always be +nil+.
+    module MDNSSD
+
+      # A reply yielded by #browse, see MDNSSD for a description of the attributes.
+      class BrowseReply
+        attr_reader :interface, :fullname, :name, :type, :domain, :flags
+        def initialize(an) # :nodoc:
+          @interface = nil
+          @fullname = an.name.to_s
+          @domain, @type, @name = MDNSSD::Util.parse_name(an.data.name)
+          @flags = an.ttl
+        end
+      end
+
+      # Lookup a service by +type+ and +domain+.
+      #
+      # Yields a BrowseReply as services are found, in a background thread, not
+      # the caller's thread!
+      #
+      # Returns a MDNS::BackgroundQuery, call MDNS::BackgroundQuery#stop when
+      # you have found all the replies you are interested in.
+      def self.browse(type, domain = '.local', *ignored) # :yield: BrowseReply
+        dnsname = DNS::Name.create(type)
+        dnsname << DNS::Name.create(domain)
+        dnsname.absolute = true
+
+        q = MDNS::BackgroundQuery.new(dnsname, IN::PTR) do |q, answers|
+          answers.each do |an|
+            yield BrowseReply.new( an )
+          end
+        end
+        q
+      end
+
+      # A reply yielded by #resolve, see MDNSSD for a description of the attributes.
+      class ResolveReply
+        attr_reader :interface, :fullname, :name, :type, :domain, :target, :port, :priority, :weight, :text_record, :flags
+        def initialize(ansrv, antxt) # :nodoc:
+          @interface = nil
+          @fullname = ansrv.name.to_s
+          @domain, @type, @name = MDNSSD::Util.parse_name(ansrv.name)
+          @target = ansrv.data.target.to_s
+          @port = ansrv.data.port
+          @priority = ansrv.data.priority
+          @weight = ansrv.data.weight
+          @text_record = MDNSSD::Util.parse_strings(antxt.data.strings)
+          @flags = ansrv.ttl
+        end
+      end
+
+      # Resolve a service instance by +name+, +type+ and +domain+.
+      #
+      # Yields a ResolveReply as service instances are found, in a background
+      # thread, not the caller's thread!
+      #
+      # Returns a MDNS::BackgroundQuery, call MDNS::BackgroundQuery#stop when
+      # you have found all the replies you are interested in.
+      def self.resolve(name, type, domain = '.local', *ignored) # :yield: ResolveReply
+        dnsname = DNS::Name.create(name)
+        dnsname << DNS::Name.create(type)
+        dnsname << DNS::Name.create(domain)
+        dnsname.absolute = true
+
+        rrs = {}
+
+        q = MDNS::BackgroundQuery.new(dnsname, IN::ANY) do |q, answers|
+          _rrs = {}
+          answers.each do |an|
+            if an.name == dnsname
+              _rrs[an.type] = an
+            end
+          end
+          # We queried for ANY, but don't yield unless we got a SRV or TXT.
+          if( _rrs[IN::SRV] || _rrs[IN::TXT] )
+            rrs.update _rrs
+
+            ansrv, antxt = rrs[IN::SRV], rrs[IN::TXT]
+
+#           puts "ansrv->#{ansrv}"
+#           puts "antxt->#{antxt}"
+
+            # Even though we got an SRV or TXT, we can't yield until we have both.
+            if ansrv && antxt
+              yield ResolveReply.new( ansrv, antxt )
+            end
+          end
+        end
+        q
+      end
+
+      # A reply yielded by #register, see MDNSSD for a description of the attributes.
+      class RegisterReply
+        attr_reader :interface, :fullname, :name, :type, :domain
+        def initialize(name, type, domain)
+          @interface = nil
+          @fullname = (DNS::Name.create(name) << type << domain).to_s
+          @name, @type, @domain = name, type, domain
+        end
+      end
+
+      # Register a service instance on the local host.
+      #
+      # +txt+ is a Hash of String keys to String values.
+      #
+      # Because the service +name+ may already be in use on the network, a
+      # different name may be registered than that requested. Because of this,
+      # if a block is supplied, a RegisterReply will be yielded so that the
+      # actual service name registered may be seen.
+      #
+      # Returns a MDNS::Service, call MDNS::Service#stop when you no longer
+      # want to advertise the service.
+      #
+      # NOTE - The service +name+ should be unique on the network, MDNSSD
+      # doesn't currently attempt to ensure this. This will be fixed in
+      # an upcoming release.
+      def self.register(name, type, domain, port, txt = {}, *ignored) # :yields: RegisterReply
+        dnsname = DNS::Name.create(name)
+        dnsname << DNS::Name.create(type)
+        dnsname << DNS::Name.create(domain)
+        dnsname.absolute = true
+
+        s = MDNS::Service.new(name, type, port, txt) do |s|
+          s.domain = domain
+        end
+
+        yield RegisterReply.new(name, type, domain) if block_given?
+
+        s
+      end
+
+      # Utility routines not for general use.
+      module Util
+        # Decode a DNS-SD domain name. The format is:
+        #   [<instance>.]<_service>.<_protocol>.<domain>
+        #
+        # Examples are:
+        #   _http._tcp.local
+        #   guest._http._tcp.local
+        #   Ensemble Musique._daap._tcp.local
+        #
+        # The <_service>.<_protocol> combined is the <type>.
+        #
+        # Return either:
+        #  [ <domain>, <type> ]
+        # or
+        #  [ <domain>, <type>, <instance>]
+        #
+        # Because of the order of the return values, it can be called like:
+        #   domain, type = MDNSSD::Util.parse_name(fullname)
+        # or
+        #   domain, type, name = MDNSSD::Util.parse_name(fullname)
+        # If there is no name component to fullname, name will be nil.
+        def self.parse_name(dnsname)
+          domain, t1, t0, name = dnsname.to_a.reverse.map {|n| n.to_s}
+          [ domain, t0 + '.' + t1, name].compact
+        end
+
+        # Decode TXT record strings, an array of String.
+        #
+        # DNS-SD defines formatting conventions for them:
+        # - Keys must be at least one char in range (0x20-0x7E), excluding '='
+        #   (0x3D), and they must be matched case-insensitively.
+        # - There may be no '=', in which case value is nil.
+        # - There may be an '=' with no value, in which case value is empty string, "".
+        # - Anything following the '=' is a value, it is not case sensitive, can be binary,
+        #   and can include whitespace.
+        # - Discard all keys but the first.
+        # - Discard a string that aren't formatting accorded to these rules.
+        def self.parse_strings(strings)
+          h = {}
+
+          strings.each do |kv|
+            if kv.match( /^([\x20-\x3c\x3f-\x7e]+)(?:=(.*))?$/ )
+              key = $1.downcase
+              value = $2
+              next if h.has_key? key
+              h[key] = value
+            end
+          end
+
+          h
+        end
+      end
+
+    end
+  end
+end
+