toolmantim-zeroconf 0.0.2

data/originals/net-mdns-0.4/TODO

@@ -0,0 +1,278 @@
+TODO
+
+Release: 0.0  "seeing if its possible" - done
+
+Release: 0.1  "making it work"
+
+A complete rewrite, too many changes to even begin to mention.
+
+Release: 0.2  "doing the right thing"
+
+- must always respond to requests for the A record for this host's .local
+  address
+
+- cache the answers in the additional section
+
+- in MDNSSD, put the handle into the reply as the "service" attribute
+
+- need to send TTL=0 message on service shutdown
+
+- implement flags, particularly add/remove flags
+
+- remove all use of absolute in name comparisons, I have had too many bugs
+  involving this
+
+- deal with timeouts in Resolv::MDNS, how long, can they be set, etc.
+
+- reverse lookup of names by addresses using mDNS, see notes in
+  #generate_candidates. I think I should allow reverse lookup of addresss in
+  the private address spaces [RFC1918] (address prefixes of 10/8, 172.16/12,
+  and 192.168/16).
+
+- correctly encode a nil in a text_record, and allow "key" w/no value for "mdns.rb -R"
+
+- probe for name conflicts before registering a service
+
+- when we see a question, flush answers over a few seconds old from cache
+    .. and do we notify queries that the answers are being deleted, too?
+
+- escape/parse DNS-SD names ...
+
+- try the meta-queries (_services._dns-sd._udp.local.)
+
+- add known answers to queries
+
+- answer unicast questions
+
+- implement a MDNSSD api for DNSServiceQueryRecord, and 'mdns.rb -Q"
+
+Release: 0.3  "keep it working"
+
+- Change the technique for looking up IPv4 address of the default interface,
+  the old technique stopped working on OS X boxes that had IPv6 enabled (which
+  was the default).
+
+- Fixed a bug causing infinite loops (in the wrong place) in background query.
+
+
+Todo:
+
+- define constants in module MDNSSD::Types  like Http = '_http._tcp', ...?
+
+- mdns.rb -K, watch for records and immediately register replacements pointing
+  to somewhere else
+
+- general code cleanups
+
+- Add #to_s to the RR types.
+
+- Add #to_s the *classes* of the RR types ("IN::TXT", ...)
+
+- HINFO RR service
+
+- A RR service
+
+- wildcard answering services
+
+- Query#start, #restart
+
+- let Query.new take a block, and yield itself, or yield with every answer?
+
+- move hierarchal DNS Name comparison operators to an optional file.
+
+- DNS packet dumper
+
+- to make both TXT objects and TXT classes have a value,
+  add methods type_value and type_class.
+
+
+
+dns-sd test mode results:
+   -A  ok, but don't support -Q so don't see HINFO add/update/remove
+   -U  ok
+   -N  ok, but don't support -Q so don't see NULL add
+   -T  ok
+   -M  no, we don't support multiple TXT records for a service
+   -I  ok
+
+
+
+Open resolv.rb issues:
+
+- Reverse DNS lookups are done by sock.recv, seems like its a problem for a
+  DNS library...
+
+  Shouldn't BasicSocket.do_not_reverse_lookup be set? Or be set on our sockets?
+  It's weird that in @sock.recv we get a tuple with the address... when we ARE
+  a resolver library.... and if you call resolv-replace, won't we call
+  ourselves in order to resolve the IP when you call recv to get the peer info?
+  And isn't resolv-replace ignoring BasicSocket.do_not_reverse_lookup?  So, it
+  is very weird that resolv.rb does ad socket.recv that causes (blocking) DNS
+  queries to occure for its peer IP address...
+
+- Resolv::Hosts returns IPv6 addresses before IPv4, so Resolv.getaddress('localhost')
+  is ::1 on my system - this is not good.
+
+- See [DNSOPV6:3.1], does resolv.rb do this?
+
+
+[DNSOPV6] 
+[DNSOPBADRES] draft-ietf-dnsop-bad-dns-res-03.tx
+
+Open design issues:
+
+- how to get the local ifx ipv4 address?
+
+- Net classes that do socksetopts, so you don't have to pack the structs
+  yourself! or maybe implement the 8 functions of Stevens?
+
+
+System differences in multicast:
+
+[EACCES] The destination address is a broadcast address, and SO_BROADCAST has not been set on the socket.
+
+
+Comments for DNS-SD:
+
+* domain and type end in a '.', is that necessary?
+
+* Names of Stuff
+
+I'm getting lost in trying to remember what goes into a method, and what is available
+in it's Reply object. I think the following convention would help:
+
+  Every function argument maps to a Reply attribute of the same name.
+
+  The Reply attributes and function arguments should be the same.
+
+This makes things easy to remember, as data goes into #browse, comes out
+BrowseReply, goes into #resolve, comes out ResolveReply it doesn't change its
+name!
+
+
+
+Currently:
+
+  DNSSD::BrowseReply.instance_methods:
+  ["flags", "service", "domain", "fullname", "interface", "name",  "type"]
+
+  Note that #type overrides Object#type.
+  service_type had its name changed to type
+
+  DNSSD::ResolveReply.instance_methods:
+  [ "flags", "service",          "fullname", "interface",                 "port", "target", "text_record"]
+
+  Missing #domain!
+  Missing #name!
+  Missing #type!
+
+  #resolve takes argument #service_name, it comes from BrowseReply#name
+  #resolve takes argument #service_type, it comes from BrowseReply#type
+  #resolve takes argument #service_domain, it comes from BrowseReply#domain
+
+  Note that interface is still interface.
+
+  #browse has argument domain, #register has argument #service_domain
+
+
+  DNSSD::RegisterReply.instance_methods:
+
+  [ "flags", "service", "domain",                        "name",    "type" ]
+
+  Missing #interface, #port, #target, #text_record.
+
+
+As it is, I find the naming really confusing. Changing the names in the replies
+causes interface breakage, so how about changing the names in the arguments so
+they are the same as the attributes in the reply, and so that all 3 functions
+use the same name for the same thing?
+
+
+This code supplies some missing methods:
+
+  module DNSSD
+    def self.namesplit(n)
+      n.scan(/(?:\\.|[^\.])+/)
+    end
+    class ResolveReply
+      def domain
+        DNSSD.namesplit(fullname)[-1]
+      end
+      def type
+        DNSSD.namesplit(fullname)[1,2].join('.')
+      end
+      def name
+        DNSSD.namesplit(fullname)[0]
+      end
+    end
+  end
+
+
+
+
+Comments for Apple:
+
+* [MDNS:5] Reverse Address Mapping - should allow reverse mapping 
+  in the [RFC1918] address space as well. Does Apple's resolver
+  do this?
+
+* TXT record is required by mDNSResponder
+
+DNS-SD does not require a responder advertising a service to have
+a TXT record.
+
+
+Problem:
+
+I assume it is done because if you ask for SRV and TXT (or ANY), and
+get only SRV, you don't know if it is because there is no TXT, or because
+it didn't make it across unreliable UDP.
+
+Solutions:
+
+Require a TXT record (curent mDNSResponder behaviour).
+
+Require that all the questions in a single DNS message be responded
+to in a single DNS message. This allows:
+
+  1 - asking for ANY?, and if you get a SRV but no TXT, it means there
+      is no TXT
+  2 - asking for TXT? and SRV?, and if you get a SRV but no TXT, it means
+      there is no TXT
+
+Recommend:
+
+I prefer the latter. It scales to more than two records associated with a
+service, so in the future if a service needs a SRV, TXT, and NUL record, a
+single query can be sent, and a single query can be expected as a response.
+
+For legacy interop reasons, we are probably stuck with having to advertise a
+TXT record. I still think all questions from a single message should be answered
+in a single message. Possible exception is when to large, in which case the
+TC bit should be set so the resolver knows to expect another message.
+
+
+* TXT records from mDNSResponder may have zero character-strings
+
+Violates DNS spec.
+
+DNS-SD claims to conform to DNS.
+
+DNS-SD says TXT has zero or more character-strings.
+
+Two statements not in agreement.
+
+Recommend that:
+- DNS-SD be altered to state TXT records MUST conform to DNS specs.
+- DNS-SD include a warning that deployed responders generate TXT
+  with zero char-strings, and implementations SHOULD be capable of handling
+  this as being equivalent to a TXT with one zero-length character string.
+
+
+* OS X puts additional answers in the answers section, not the additional section
+
+* OS X resolver generates queries for ensemble.local.local
+
+This violates DNS-SD.
+
+

data/samples/exhttp.rb

@@ -0,0 +1,50 @@
+#!/usr/local/bin/ruby18 -w
+# Author: Sam Roberts <sroberts@uniserve.com>
+# Licence: this file is placed in the public domain
+
+require 'net/http'
+require 'thread'
+require 'pp'
+
+# For MDNSSD
+require 'net/dns/mdns-sd'
+
+# To make Resolv aware of mDNS
+require 'net/dns/resolv-mdns'
+
+# To make TCPSocket use Resolv, not the C library resolver.
+require 'net/dns/resolv-replace'
+
+# Use a short name.
+DNSSD = Net::DNS::MDNSSD
+
+# Sync stdout, and don't write to console from multiple threads.
+$stdout.sync
+$lock = Mutex.new
+
+# Be quiet.
+debug = false
+
+DNSSD.browse('_http._tcp') do |b|
+  $lock.synchronize { pp b } if debug
+  DNSSD.resolve(b.name, b.type) do |r|
+    $lock.synchronize { pp r } if debug
+    begin
+      http = Net::HTTP.new(r.target, r.port)
+
+      path = r.text_record['path'] || '/'
+
+      headers = http.head(path)
+
+      $lock.synchronize do
+        puts "#{r.name.inspect} on #{r.target}:#{r.port}#{path} using server #{headers['server']}"
+      end
+    rescue
+      $lock.synchronize { puts $!; puts $!.backtrace }
+    end
+  end
+end
+
+# Hit enter when you think that's all.
+STDIN.gets
+

data/samples/exhttpv1.rb

@@ -0,0 +1,29 @@
+#!/usr/local/bin/ruby18 -w
+# Author: Sam Roberts <sroberts@uniserve.com>
+# Licence: this file is placed in the public domain
+
+require 'net/http'
+require 'net/dns/resolv-mdns'
+
+mdns = Resolv::MDNS.default
+
+mdns.each_resource('_http._tcp.local', Resolv::DNS::Resource::IN::PTR) do |rrhttp|
+  service = rrhttp.name
+  host = nil
+  port = nil
+  path = '/'
+
+  rrsrv = mdns.getresource(rrhttp.name, Resolv::DNS::Resource::IN::SRV)
+  host, port = rrsrv.target.to_s, rrsrv.port
+  rrtxt = mdns.getresource(rrhttp.name, Resolv::DNS::Resource::IN::TXT)
+  if  rrtxt.data =~ /path=(.*)/
+    path = $1
+  end
+
+  http = Net::HTTP.new(host, port)
+
+  headers = http.head(path)
+
+  puts "#{service[0]} on #{host}:#{port}#{path} was last-modified #{headers['last-modified']}"
+end
+

data/samples/exwebrick.rb

@@ -0,0 +1,56 @@
+#!/usr/local/bin/ruby18 -w
+# Author: Sam Roberts <sroberts@uniserve.com>
+# Licence: this file is placed in the public domain
+#
+# Advertise a webrick server over mDNS.
+
+require 'webrick'
+require 'net/dns/mdns-sd'
+
+DNSSD = Net::DNS::MDNSSD
+
+class HelloServlet < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(req, resp)   
+    resp.body = "hello, world\n"
+    resp['content-type'] = 'text/plain'
+    raise WEBrick::HTTPStatus::OK
+  end
+end
+
+# This may seem convoluted... but if there are multiple address families
+# available, like AF_INET6 and AF_INET, this should create multiple TCPServer
+# sockets for them.
+families = Socket.getaddrinfo(nil, 1, Socket::AF_UNSPEC, Socket::SOCK_STREAM, 0, Socket::AI_PASSIVE)
+
+listeners = []
+port = 0
+
+families.each do |af, one, dns, addr|
+  p port, addr
+  listeners << TCPServer.new(addr, port)
+  port = listeners.first.addr[1] unless port != 0
+end
+
+listeners.each do |s|
+  puts "listen on #{s.addr.inspect}"
+end
+
+# This will dynamically allocate multiple TCPServers, each on a different port.
+server = WEBrick::HTTPServer.new( :Port => 0 )
+
+# So we replace them with our TCPServer sockets which are all on the same
+# (dynamically assigned) port.
+server.listeners.each do |s| s.close end
+server.listeners.replace listeners
+server.config[:Port] = port
+
+server.mount( '/hello/', HelloServlet )
+
+handle = DNSSD.register("hello", '_http._tcp', 'local', port, 'path' => '/hello/')
+
+['INT', 'TERM'].each { |signal| 
+  trap(signal) { server.shutdown; handle.stop; }
+}
+
+server.start
+

data/samples/mdns-watch.rb

@@ -0,0 +1,132 @@
+#!/usr/local/bin/ruby18
+
+require 'socket'
+require 'ipaddr'
+require 'net/dns'
+
+$stderr.sync = true
+$stdout.sync = true
+
+Addr = "224.0.0.251"
+Port = 5353
+
+include Net::DNS
+
+@hostname = Name.create(Socket.gethostname)
+@hostname.absolute = true
+@hostaddr = Socket.getaddrinfo(@hostname.to_s, 0, Socket::AF_INET, Socket::SOCK_STREAM)[0][3]
+@hostrr   = [ @hostname, 240, IN::A.new(@hostaddr) ]
+@hostaddr = IPAddr.new(@hostaddr).hton
+
+@sock = UDPSocket.new
+
+# TODO - do we need this?
+@sock.fcntl(Fcntl::F_SETFD, 1)
+
+# Allow 5353 to be shared.
+so_reuseport = 0x0200 # The definition on OS X, where it is required.
+if Socket.constants.include? 'SO_REUSEPORT'
+  so_reuseport = Socket::SO_REUSEPORT
+end
+begin
+  @sock.setsockopt(Socket::SOL_SOCKET, so_reuseport, 1)
+rescue
+  warn( "set SO_REUSEPORT raised #{$!}, try SO_REUSEADDR" )
+  so_reuseport = Socket::SO_REUSEADDR
+  @sock.setsockopt(Socket::SOL_SOCKET, so_reuseport, 1)
+end
+
+# Request dest addr and ifx ids... no.
+
+# Join the multicast group.
+#  option is a struct ip_mreq { struct in_addr, struct in_addr }
+ip_mreq =  IPAddr.new(Addr).hton + @hostaddr
+@sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, ip_mreq)
+@sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF, @hostaddr)
+
+# Set IP TTL for outgoing packets.
+@sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, 255)
+@sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, 255)
+
+# Apple source makes it appear that optval may need to be a "char" on
+# some systems:
+#  @sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, 255 as int)
+#     - or -
+#  @sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, 255 as byte)
+
+# Bind to our port.
+@sock.bind(Socket::INADDR_ANY, Port)
+
+class Resolv
+  class DNS
+    class Resource
+      module IN
+        class SRV
+          def inspect
+            "#{target}:#{port} weight=#{weight} priority=#{priority}"
+          end
+        end
+        class TXT
+          def inspect
+            strings.inspect
+          end
+        end
+        class PTR
+          def inspect
+            name.to_s
+          end
+        end
+        class A
+          def inspect
+            address.to_s
+          end
+        end
+        class HINFO
+          def inspect
+            "os=#{os.inspect}\ncpu=#{cpu.inspect}"
+          end
+        end
+      end
+    end
+  end
+end
+
+loop do
+
+  reply, from = @sock.recvfrom(9000)
+
+  puts "++ from #{from.inspect}"
+
+  if false
+    puts reply.inspect
+    puts "--"
+  end
+
+  msg = Resolv::DNS::Message.decode(reply)
+
+  qr = msg.qr==0 ? 'Q' : 'R'
+  qrstr = msg.qr==0 ? 'Query' : 'Resp'
+
+  opcode = { 0=>'QUERY', 1=>'IQUERY', 2=>'STATUS'}[msg.opcode]
+
+  puts "#{qrstr}: id #{msg.id} qr #{qr} opcode #{opcode} aa #{msg.aa} tc #{msg.tc} rd #{msg.rd} ra #{msg.ra} rcode #{msg.rcode}"
+
+  msg.question.each do |name, type, unicast|
+    puts "qu #{Net::DNS.rrname type} #{name.to_s.inspect} unicast=#{unicast}"
+  end
+  msg.answer.each do |name, ttl, data, cacheflush|
+    puts "an #{Net::DNS.rrname data} #{name.to_s.inspect} ttl=#{ttl} cacheflush=#{cacheflush}"
+    puts "   #{data.inspect}"
+  end
+  msg.authority.each do |name, ttl, data, cacheflush|
+    puts "au #{Net::DNS.rrname data} #{name.to_s.inspect} ttl=#{ttl} cacheflush=#{cacheflush.inspect}"
+    puts "   #{data.inspect}"
+  end
+  msg.additional.each do |name, ttl, data, cacheflush|
+    puts "ad #{Net::DNS.rrname data} #{name.to_s.inspect} ttl=#{ttl} cacheflush=#{cacheflush.inspect}"
+    puts "   #{data.inspect}"
+  end
+
+  puts
+end
+