dnssd 1.1.0 → 1.2

data/.autotest

@@ -1,15 +1,14 @@
-require 'autotest/restart'
-
-Autotest.add_hook :initialize do |at|
-  at.testlib = 'minitest/unit'
+begin
+  require 'autotest/fsevent'
+rescue LoadError
+end
 
-  def at.path_to_classname(s)
-    sep = File::SEPARATOR
-    f = s.sub(/^test#{sep}/, '').sub(/\.rb$/, '').split(sep)
-    f = f.map { |path| path.split(/_|(\d+)/).map { |seg| seg.capitalize }.join }
-    f = f.map { |path| path =~ /^Test/ ? path : "Test#{path}"  }
-    f.join('::').sub 'Dnssd', 'DNSSD'
+Autotest.add_hook :run_command do |at|
+  at.unit_diff = 'cat'
+  if ENV['ONENINE']
+    system "rake1.9 compile"
+  else
+    system "rake compile"
   end
-
 end
 

data/History.txt

@@ -1,13 +1,38 @@
+=== 1.2.0 / 2009-08-11
+
+* 3 major enhancements
+  * DNSSD::Service is now directly instantiable
+  * DNSSD.announce which registers a server socket you've created
+  * DNSSD::Reply.connect which connects to a browsed service
+  * Fix asynchronous service shutdown crash
+
+* 3 minor enhancements
+  * DNSSD.resolve now optionally accepts a DNSSD::Reply from DNSSD.browse
+  * Use rb_thread_wait_fd instead of custom rb_thread_select code
+  * DNSSD::Reply#protocol and DNSSD::Reply#service_name
+  * Added missing error classes
+  * Added missing InterfaceUnicast constant
+  * Improved Documentation
+  * Use C constants in ext/dnssd/errors.c
+  * Reduced C code in ext/dnssd/service.c for greater control.  See
+    DNSSD::Service
+
+* 4 bug fixes
+  * Don't invoke block on callback if none was provided
+  * Remove ext/dnssd/dns_sd.h so the correct header is used
+  * DNSSD::NoMemoryError is now raised instead of NoMemError
+  * DNSSD::ReferenceUsedError is now correctly named DNSSD::RefusedError
+
 === 1.1.0 / 2009-08-10
 
-* 2 Major enhancements
+* 2 major enhancements
   * Packaging files that need to be here
   * Increased the version number
 
-* 1 Minor enhancement
+* 1 minor enhancement
   * Less C codes
 
-* 1 Bugfix
+* 1 bug fix
   * Increased INTERNET!
 
 === 0.7.2 / 2009-08-05

data/Manifest.txt

@@ -3,7 +3,6 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-ext/dnssd/dns_sd.h
 ext/dnssd/dnssd.c
 ext/dnssd/dnssd.h
 ext/dnssd/errors.c
@@ -16,11 +15,14 @@ lib/dnssd/reply.rb
 lib/dnssd/service.rb
 lib/dnssd/text_record.rb
 sample/browse.rb
+sample/enumerate_domains.rb
 sample/growl.rb
-sample/highlevel_api.rb
 sample/register.rb
 sample/resolve.rb
 sample/resolve_ichat.rb
+sample/server.rb
+sample/socket.rb
+test/test_dnssd.rb
 test/test_dnssd_flags.rb
 test/test_dnssd_reply.rb
 test/test_dnssd_text_record.rb

data/README.txt

@@ -10,17 +10,19 @@ resolving, registration and domain enumeration.
 
 == FEATURES/PROBLEMS:
 
-* Too much C, too little ruby
+* Needs more pie.
+* Not all of the DNSSD API is implemented
+* Sometimes tests fail
 
 == SYNOPSIS:
 
+See the sample directory (Hint: gem contents --prefix dnssd)
+
 Registering a service:
 
-  registration = DNSSD.register 'my web service', '_http._tcp', nil, 80
-  
-  # ...
+  http = TCPServer.new nil, 80
   
-  registration.stop # unregister when we're done
+  DNSSD.announce http, 'my awesome HTTP server'
 
 Browsing services:
 
@@ -32,12 +34,12 @@ Browsing services:
 
 == REQUIREMENTS:
 
-* The mdns library on OS X
-* The dns-sd library on other operating systems
+* OS X
+* The dns-sd library on other operating systems (or dns-sd shim)
 
 == INSTALL:
 
-* FIX (sudo gem install, anything else)
+  sudo gem install dnssd
 
 == LICENSE:
 

data/ext/dnssd/dnssd.c

@@ -4,15 +4,92 @@ void Init_DNSSD_Errors(void);
 void Init_DNSSD_Flags(void);
 void Init_DNSSD_Service(void);
 
+/*
+ * call-seq:
+ *   DNSSD.getservbyport(port, proto = nil) => service_name
+ * 
+ * Wrapper for getservbyport(3) - returns the service name for +port+.
+ *
+ *   DNSSD.getservbyport 1025 # => 'blackjack'
+ */
+
+static VALUE
+dnssd_getservbyport(int argc, VALUE * argv, VALUE self) {
+  VALUE _port, _proto;
+  struct servent * result;
+  int port;
+  char * proto = NULL;
+
+  rb_scan_args(argc, argv, "11", &_port, &_proto);
+
+  port = htons(FIX2INT(_port));
+
+  if (RTEST(_proto))
+    proto = StringValueCStr(_proto);
+
+  result = getservbyport(port, proto);
+
+  if (result == NULL)
+    return Qnil;
+
+  return rb_str_new2(result->s_name);
+}
+
+/*
+ * call-seq:
+ *   DNSSD.interface_name(interface_index) # => interface_name
+ *
+ * Returns the interface name for interface +interface_index+.
+ *
+ *   DNSSD.interface_name 1 # => 'lo0'
+ */
+
+static VALUE
+dnssd_if_nametoindex(VALUE self, VALUE name) {
+  return UINT2NUM(if_nametoindex(StringValueCStr(name)));
+}
+
+/*
+ * call-seq:
+ *   DNSSD.interface_index(interface_name) # => interface_index
+ *
+ * Returns the interface index for interface +interface_name+.
+ *
+ *   DNSSD.interface_index 'lo0' # => 1
+ */
+
+static VALUE
+dnssd_if_indextoname(VALUE self, VALUE index) {
+  char buffer[IF_NAMESIZE];
+
+  if (if_indextoname(NUM2UINT(index), buffer))
+    return rb_str_new2(buffer);
+
+  rb_raise(rb_eArgError, "invalid interface %d", NUM2UINT(index));
+
+  return Qnil;
+}
+
 void
 Init_dnssd(void) {
   VALUE mDNSSD = rb_define_module("DNSSD");
 
-  /* Specifies all interfaces. */
-  rb_define_const(mDNSSD, "InterfaceAny", ULONG2NUM(kDNSServiceInterfaceIndexAny));
+  /* All interfaces */
+  rb_define_const(mDNSSD, "InterfaceAny",
+      ULONG2NUM(kDNSServiceInterfaceIndexAny));
+
+  /* Local interfaces, for services running only on the same machine */
+  rb_define_const(mDNSSD, "InterfaceLocalOnly",
+      ULONG2NUM(kDNSServiceInterfaceIndexLocalOnly));
+
+  /* Unicast interfaces */
+  rb_define_const(mDNSSD, "InterfaceUnicast",
+      ULONG2NUM(kDNSServiceInterfaceIndexUnicast));
+
+  rb_define_singleton_method(mDNSSD, "getservbyport", dnssd_getservbyport, -1);
 
-  /* Specifies local interfaces only. */
-  rb_define_const(mDNSSD, "InterfaceLocalOnly", ULONG2NUM(kDNSServiceInterfaceIndexLocalOnly));
+  rb_define_singleton_method(mDNSSD, "interface_index", dnssd_if_nametoindex, 1);
+  rb_define_singleton_method(mDNSSD, "interface_name", dnssd_if_indextoname, 1);
 
   Init_DNSSD_Errors();
   Init_DNSSD_Flags();

data/ext/dnssd/dnssd.h

@@ -23,11 +23,13 @@
 #ifdef HAVE_SYS_IF_H
 #include <sys/if.h>
 #endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
 
 extern VALUE eDNSSDError;
 
 void dnssd_check_error_code(DNSServiceErrorType e);
-void dnssd_instantiation_error(const char *what);
 
 #endif /* RDNSSD_INCLUDED */
 

data/ext/dnssd/errors.c

@@ -4,39 +4,30 @@
 VALUE eDNSSDError;
 static VALUE eDNSSDUnknownError;
 
-#define DNSSD_ERROR_START (-65556)
-#define DNSSD_ERROR_END   (-65536)
+#define DNSSD_ERROR_START (DNSServiceErrorType)(-65792) /* 0xFFFE FF00 */
+#define DNSSD_ERROR_END   (DNSServiceErrorType)(-65537) /* 0xFFFE FFFF */
 
 static VALUE dnssd_errors[DNSSD_ERROR_END - DNSSD_ERROR_START];
 
 static void
-dnssd_errors_store(VALUE error, int num) {
-  assert(DNSSD_ERROR_START <= num && num < DNSSD_ERROR_END);
-  dnssd_errors[num - DNSSD_ERROR_START] = error;
+dnssd_errors_store(VALUE error, DNSServiceErrorType err) {
+  assert(DNSSD_ERROR_START <= err && err <= DNSSD_ERROR_END);
+  dnssd_errors[err - DNSSD_ERROR_START] = error;
 }
 
 void
-dnssd_check_error_code(DNSServiceErrorType e) {
-  int num = (int)e;
-  if (num) {
-    if(DNSSD_ERROR_START <= num && num < DNSSD_ERROR_END) {
-      rb_raise(dnssd_errors[num - DNSSD_ERROR_START],
-          "DNSSD operation failed with error code: %d", num);
+dnssd_check_error_code(DNSServiceErrorType err) {
+  if (err) {
+    if(DNSSD_ERROR_START <= err && err < DNSSD_ERROR_END) {
+      rb_raise(dnssd_errors[err - DNSSD_ERROR_START],
+          "DNSSD operation failed with error code: %d", err);
     } else {
       rb_raise(eDNSSDUnknownError,
-          "DNSSD operation failed with unrecognized error code: %d", num);
+          "DNSSD operation failed with unrecognized error code: %d", err);
     }
   }
 }
 
-void
-dnssd_instantiation_error(const char *what) {
-  rb_raise(rb_eRuntimeError,
-      "cannot instantiate %s, use DNSSD "
-      "enumerate_domains(), browse(), resolve() or register() instead",
-      what);
-}
-
 /* Document-class: DNSSD::Error
  *
  * Base class of all DNS Service Discovery related errors.
@@ -51,55 +42,86 @@ Init_DNSSD_Errors(void) {
   eDNSSDError = rb_define_class_under(mDNSSD, "Error", rb_eStandardError);
 
   eDNSSDUnknownError = rb_define_class_under(mDNSSD, "UnknownError", eDNSSDError);
-  dnssd_errors_store(eDNSSDUnknownError, -65537);
+  dnssd_errors_store(eDNSSDUnknownError, kDNSServiceErr_Unknown);
 
   error_class = rb_define_class_under(mDNSSD, "NoSuchNameError", eDNSSDError);
-  dnssd_errors_store(error_class, -65538);
+  dnssd_errors_store(error_class, kDNSServiceErr_NoSuchName);
 
-  dnssd_errors_store(rb_eNoMemError, -65539);
+  error_class = rb_define_class_under(mDNSSD, "NoMemoryError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_NoMemory);
 
   error_class = rb_define_class_under(mDNSSD, "BadParamError", eDNSSDError);
-  dnssd_errors_store(error_class, -65540);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadParam);
 
   error_class = rb_define_class_under(mDNSSD, "BadReferenceError", eDNSSDError);
-  dnssd_errors_store(error_class, -65541);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadReference);
 
   error_class = rb_define_class_under(mDNSSD, "BadStateError", eDNSSDError);
-  dnssd_errors_store(error_class, -65542);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadState);
 
   error_class = rb_define_class_under(mDNSSD, "BadFlagsError", eDNSSDError);
-  dnssd_errors_store(error_class, -65543);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadFlags);
 
   error_class = rb_define_class_under(mDNSSD, "UnsupportedError", eDNSSDError);
-  dnssd_errors_store(error_class, -65544);
+  dnssd_errors_store(error_class, kDNSServiceErr_Unsupported);
 
   error_class = rb_define_class_under(mDNSSD, "NotInitializedError", eDNSSDError);
-  dnssd_errors_store(error_class, -65545);
+  dnssd_errors_store(error_class, kDNSServiceErr_NotInitialized);
 
   error_class = rb_define_class_under(mDNSSD, "AlreadyRegisteredError", eDNSSDError);
-  dnssd_errors_store(error_class, -65547);
+  dnssd_errors_store(error_class, kDNSServiceErr_AlreadyRegistered);
 
   error_class = rb_define_class_under(mDNSSD, "NameConflictError", eDNSSDError);
-  dnssd_errors_store(error_class, -65548);
+  dnssd_errors_store(error_class, kDNSServiceErr_NameConflict);
 
   error_class = rb_define_class_under(mDNSSD, "InvalidError", eDNSSDError);
-  dnssd_errors_store(error_class, -65549);
+  dnssd_errors_store(error_class, kDNSServiceErr_Invalid);
+
+  error_class = rb_define_class_under(mDNSSD, "FirewallError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_Firewall);
 
   error_class = rb_define_class_under(mDNSSD, "ClientIncompatibleError", eDNSSDError);
-  dnssd_errors_store(error_class, -65551);
+  dnssd_errors_store(error_class, kDNSServiceErr_Incompatible);
 
   error_class = rb_define_class_under(mDNSSD, "BadInterfaceIndexError", eDNSSDError);
-  dnssd_errors_store(error_class, -65552);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadInterfaceIndex);
 
-  error_class = rb_define_class_under(mDNSSD, "ReferenceUsedError", eDNSSDError);
-  dnssd_errors_store(error_class, -65553);
+  error_class = rb_define_class_under(mDNSSD, "RefusedError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_Refused);
 
   error_class = rb_define_class_under(mDNSSD, "NoSuchRecordError", eDNSSDError);
-  dnssd_errors_store(error_class, -65554);
+  dnssd_errors_store(error_class, kDNSServiceErr_NoSuchRecord);
 
   error_class = rb_define_class_under(mDNSSD, "NoAuthenticationError", eDNSSDError);
-  dnssd_errors_store(error_class, -65555);
+  dnssd_errors_store(error_class, kDNSServiceErr_NoAuth);
 
   error_class = rb_define_class_under(mDNSSD, "NoSuchKeyError", eDNSSDError);
-  dnssd_errors_store(error_class, -65556);
+  dnssd_errors_store(error_class, kDNSServiceErr_NoSuchKey);
+
+  error_class = rb_define_class_under(mDNSSD, "NATTraversalError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_NATTraversal);
+
+  error_class = rb_define_class_under(mDNSSD, "DoubleNATError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_DoubleNAT);
+
+  error_class = rb_define_class_under(mDNSSD, "BadTimeError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadTime);
+
+  error_class = rb_define_class_under(mDNSSD, "BadSigError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadSig);
+
+  error_class = rb_define_class_under(mDNSSD, "BadKeyError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_BadKey);
+
+  error_class = rb_define_class_under(mDNSSD, "TransientError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_Transient);
+
+  error_class = rb_define_class_under(mDNSSD, "ServiceNotRunningError", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_ServiceNotRunning);
+
+  error_class = rb_define_class_under(mDNSSD, "NATPortMappingUnsupported", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_NATPortMappingUnsupported);
+
+  error_class = rb_define_class_under(mDNSSD, "NATPortMappingDisabled", eDNSSDError);
+  dnssd_errors_store(error_class, kDNSServiceErr_NATPortMappingDisabled);
 }

data/ext/dnssd/extconf.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# :nodoc: all
+# :stopdoc:
 #
 # Extension configuration script for DNS_SD C Extension.
 
@@ -38,6 +38,7 @@ have_header "sys/param.h"
 have_header "sys/if.h"
 have_header "net/if.h"
 have_header "arpa/inet.h"
+have_header "netdb.h"
 
 abort "need function #{f}" unless have_macro("htons") || have_func("htons")
 abort "need function #{f}" unless have_macro("ntohs") || have_func("ntohs")
@@ -54,3 +55,5 @@ s1 >= s2 or abort("sizeof(void*) < sizeof(DNSServiceFlags) please contact the au
 
 create_makefile "dnssd"
 
+# :startdoc:
+

data/ext/dnssd/flags.c

@@ -1,7 +1,7 @@
 #include "dnssd.h"
 
-/* dns sd flags, flag ID's, flag names */
-#define DNSSD_MAX_FLAGS 9
+/* dnssd flags, flag IDs, flag names */
+#define DNSSD_MAX_FLAGS 13
 
 static const DNSServiceFlags dnssd_flag[DNSSD_MAX_FLAGS] = {
   kDNSServiceFlagsMoreComing,
@@ -17,7 +17,15 @@ static const DNSServiceFlags dnssd_flag[DNSSD_MAX_FLAGS] = {
   kDNSServiceFlagsBrowseDomains,
   kDNSServiceFlagsRegistrationDomains,
 
-  kDNSServiceFlagsLongLivedQuery
+  kDNSServiceFlagsLongLivedQuery,
+
+  kDNSServiceFlagsAllowRemoteQuery,
+
+  kDNSServiceFlagsForceMulticast,
+
+  kDNSServiceFlagsForce,
+
+  kDNSServiceFlagsReturnIntermediates
 };
 
 static const char *dnssd_flag_name[DNSSD_MAX_FLAGS] = {
@@ -29,7 +37,11 @@ static const char *dnssd_flag_name[DNSSD_MAX_FLAGS] = {
   "unique",
   "browse_domains",
   "registration_domains",
-  "long_lived_query"
+  "long_lived_query",
+  "allow_remote_query",
+  "force_multicast",
+  "force",
+  "return_intermediates"
 };
 
 void
@@ -42,7 +54,7 @@ Init_DNSSD_Flags(void) {
   cDNSSDFlags = rb_define_class_under(mDNSSD, "Flags", rb_cObject);
 
   /* flag constants */
-#if DNSSD_MAX_FLAGS != 9
+#if DNSSD_MAX_FLAGS != 13
 #error The code below needs to be updated.
 #endif
 
@@ -60,7 +72,7 @@ Init_DNSSD_Flags(void) {
    * they will be delivered as usual.
    */
   rb_define_const(cDNSSDFlags, "MoreComing",
-		  ULONG2NUM(kDNSServiceFlagsMoreComing));
+      ULONG2NUM(kDNSServiceFlagsMoreComing));
 
   /* Applies only to enumeration.  An enumeration callback with the
    * DNSSD::Flags::Add flag NOT set indicates a DNSSD::Flags::Remove, i.e. the
@@ -79,46 +91,96 @@ Init_DNSSD_Flags(void) {
    * service.  DNSSD::Flags::NoAutoRename overrides this behavior - with this
    * flag set, name conflicts will result in a callback.  The NoAutoRename flag
    * is only valid if a name is explicitly specified when registering a service
-   * (ie the default name is not used.)
+   * (i.e. the default name is not used.)
    */
   rb_define_const(cDNSSDFlags, "NoAutoRename",
-		  ULONG2NUM(kDNSServiceFlagsNoAutoRename));
+      ULONG2NUM(kDNSServiceFlagsNoAutoRename));
 
-  /* Flag for registering individual records on a connected DNSServiceRef.
+  /* Flag for registering individual records on a connected DNSSD::Service.
    *
    * DNSSD::Flags::Shared indicates that there may be multiple records with
-   * this name on the network (e.g. PTR records).  DNSSD::Flags::Unique
-   * indicates that the record's name is to be unique on the network (e.g. SRV
-   * records).  (DNSSD::Flags::Shared and DNSSD::Flags::Unique are currently
-   * not used by the Ruby API.)
+   * this name on the network (e.g. PTR records).
+   *
+   * (Not used currently by the Ruby API)
    */
   rb_define_const(cDNSSDFlags, "Shared", ULONG2NUM(kDNSServiceFlagsShared));
+
+  /* DNSSD::Flags::Unique indicates that the record's name is to be unique on
+   * the network (e.g. SRV records).
+   *
+   * (Not used currently by the Ruby API)
+   */
   rb_define_const(cDNSSDFlags, "Unique", ULONG2NUM(kDNSServiceFlagsUnique));
 
-  /* DNSSD::Flags::BrowseDomains enumerates domains recommended for browsing
+  /* Specifies domain enumeration type.
+   *
+   * DNSSD::Flags::BrowseDomains enumerates domains recommended for browsing
    */
   rb_define_const(cDNSSDFlags, "BrowseDomains",
-		  ULONG2NUM(kDNSServiceFlagsBrowseDomains));
+      ULONG2NUM(kDNSServiceFlagsBrowseDomains));
 
-  /* DNSSD::Flags::RegistrationDomains enumerates domains recommended for
+  /* Specifies domain enumeration type.
+   *
+   * DNSSD::Flags::RegistrationDomains enumerates domains recommended for
    * registration.
    */
-
   rb_define_const(cDNSSDFlags, "RegistrationDomains",
-		  ULONG2NUM(kDNSServiceFlagsRegistrationDomains));
+      ULONG2NUM(kDNSServiceFlagsRegistrationDomains));
 
-  /* Flag for creating a long-lived unicast query for the DNSDS.query_record()
-   * (currently not part of the Ruby API). */
+  /* Flag for creating a long-lived unicast query for DNSSD.query_record
+   *
+   * (Not used by the Ruby API)
+   */
   rb_define_const(cDNSSDFlags, "LongLivedQuery",
-		  ULONG2NUM(kDNSServiceFlagsLongLivedQuery));
+      ULONG2NUM(kDNSServiceFlagsLongLivedQuery));
+
+  /* Flag for creating a record for which we will answer remote queries
+   * (queries from hosts more than one hop away; hosts not directly connected
+   * to the local link).
+   */
+  rb_define_const(cDNSSDFlags, "AllowRemoteQuery",
+      ULONG2NUM(kDNSServiceFlagsAllowRemoteQuery));
+
+  /* Flag for signifying that a query or registration should be performed
+   * exclusively via multicast DNS, even for a name in a domain (e.g.
+   * foo.apple.com.) that would normally imply unicast DNS.
+   */
+  rb_define_const(cDNSSDFlags, "ForceMulticast",
+      ULONG2NUM(kDNSServiceFlagsForceMulticast));
+
+  /* Flag for signifying a "stronger" variant of an operation. Currently
+   * defined only for DNSSD.reconfirm_record, where it forces a record to
+   * be removed from the cache immediately, instead of querying for a few
+   * seconds before concluding that the record is no longer valid and then
+   * removing it. This flag should be used with caution because if a service
+   * browsing PTR record is indeed still valid on the network, forcing its
+   * removal will result in a user-interface flap -- the discovered service
+   * instance will disappear, and then re-appear moments later.
+   */
+  rb_define_const(cDNSSDFlags, "Force", ULONG2NUM(kDNSServiceFlagsForce));
+
+  /* Flag for returning intermediate results. For example, if a query results
+   * in an authoritative NXDomain (name does not exist) then that result is
+   * returned to the client. However the query is not implicitly cancelled --
+   * it remains active and if the answer subsequently changes (e.g. because a
+   * VPN tunnel is subsequently established) then that positive result will
+   * still be returned to the client. Similarly, if a query results in a CNAME
+   * record, then in addition to following the CNAME referral, the intermediate
+   * CNAME result is also returned to the client. When this flag is not set,
+   * NXDomain errors are not returned, and CNAME records are followed silently
+   * without informing the client of the intermediate steps.
+   */
+  rb_define_const(cDNSSDFlags, "ReturnIntermediates",
+      ULONG2NUM(kDNSServiceFlagsReturnIntermediates));
 
   flags_hash = rb_hash_new();
 
   for (i = 0; i < DNSSD_MAX_FLAGS; i++) {
     rb_hash_aset(flags_hash, rb_str_new2(dnssd_flag_name[i]),
-		 ULONG2NUM(dnssd_flag[i]));
+        ULONG2NUM(dnssd_flag[i]));
   }
 
+  /* Hash of flags => flag_name */
   rb_define_const(cDNSSDFlags, "FLAGS", flags_hash);
 }