dnssd 1.0 → 1.1.0

data/ext/dnssd/{dnssd_service.c → service.c}

@@ -1,11 +1,3 @@
-/*
- * Ruby Rendezvous Binding
- *
- * Copyright (c) 2004 Chad Fowler, Charles Mills, Rich Kilmer
- * Licenced under the same terms as Ruby.
- * This software has absolutely no warranty.
- */
-
 #include "dnssd.h"
 #include <assert.h>
 
@@ -14,14 +6,24 @@
   #define DNSSD_API
 #endif
 
+static VALUE cDNSSDReply;
 static VALUE cDNSSDService;
+static VALUE cDNSSDTextRecord;
+
 static ID dnssd_id_call;
-static ID dnssd_id_to_str;
+static ID dnssd_id_encode;
 static ID dnssd_id_to_i;
+static ID dnssd_id_to_str;
+
 static ID dnssd_iv_block;
-static ID dnssd_iv_thread;
+static ID dnssd_iv_domain;
+static ID dnssd_iv_interface;
+static ID dnssd_iv_port;
 static ID dnssd_iv_result;
 static ID dnssd_iv_service;
+static ID dnssd_iv_target;
+static ID dnssd_iv_text_record;
+static ID dnssd_iv_thread;
 
 #define IsDNSSDService(obj) (rb_obj_is_kind_of(obj,cDNSSDService)==Qtrue)
 #define GetDNSSDService(obj, var) \
@@ -32,10 +34,131 @@ dnssd_to_flags(VALUE obj) {
   return (DNSServiceFlags)NUM2ULONG(rb_funcall(obj, dnssd_id_to_i, 0));
 }
 
-void
+static VALUE
+create_fullname(const char *name, const char *regtype,
+    const char *domain) {
+  char buffer[kDNSServiceMaxDomainName];
+
+  if (DNSServiceConstructFullName(buffer, name, regtype, domain)) {
+    static const char msg[] = "could not construct full service name";
+    rb_raise(rb_eArgError, msg);
+  }
+
+  buffer[kDNSServiceMaxDomainName - 1] = '\000'; /* just in case */
+  return rb_str_new2(buffer);
+}
+
+/*
+ * call-seq:
+ *    DNSSD::Service.fullname(name, type, domain) => String
+ *
+ * Concatenate a three-part domain name like DNSSD::Reply#fullname into a
+ * properly-escaped full domain name.
+ *
+ * Any dots or slashes in the +name+ must NOT be escaped.
+ *
+ * +name+ may be +nil+ (to construct a PTR record name, e.g.
+ * "_ftp._tcp.apple.com").
+ *
+ * The +type+ is the service type followed by the protocol, separated by a dot
+ * (e.g. "_ftp._tcp").
+ *
+ * The +domain+ is the domain name, e.g. "apple.com".  Any literal dots or
+ * backslashes must be escaped.
+ *
+ * Raises ArgumentError if the full service name cannot be
+ * constructed from the arguments.
+ */
+
+static VALUE
+dnssd_service_s_fullname(VALUE klass, VALUE name, VALUE type, VALUE domain) {
+  return create_fullname(StringValueCStr(name), StringValueCStr(type),
+      StringValueCStr(domain));
+}
+
+static VALUE
+text_record_new(VALUE text_record) {
+  return rb_funcall(cDNSSDTextRecord, rb_intern("new"), 1, text_record);
+}
+
+static VALUE
+reply_new(VALUE service, DNSServiceFlags flags) {
+  return rb_funcall(cDNSSDReply, rb_intern("from_service"), 2, service,
+                    UINT2NUM(flags));
+}
+
+static void
+reply_set_interface(VALUE self, uint32_t interface) {
+  VALUE if_value;
+  char buffer[IF_NAMESIZE];
+
+  if (if_indextoname(interface, buffer)) {
+    if_value = rb_str_new2(buffer);
+  } else {
+    if_value = ULONG2NUM(interface);
+  }
+
+  rb_ivar_set(self, dnssd_iv_interface, if_value);
+}
+
+static VALUE
+reply_from_browse(VALUE service, DNSServiceFlags flags,
+    uint32_t interface, const char *name, const char *regtype,
+    const char *domain) {
+  VALUE self = reply_new(service, flags);
+  reply_set_interface(self, interface);
+  rb_funcall(self, rb_intern("set_names"), 3, rb_str_new2(name),
+      rb_str_new2(regtype), rb_str_new2(domain));
+  return self;
+}
+
+static VALUE
+reply_from_domain_enum(VALUE service, DNSServiceFlags flags,
+    uint32_t interface, const char *domain) {
+  VALUE self = reply_new(service, flags);
+  reply_set_interface(self, interface);
+  rb_ivar_set(self, dnssd_iv_domain, rb_str_new2(domain));
+  return self;
+}
+
+static VALUE
+reply_from_register(VALUE service, DNSServiceFlags flags,
+    const char *name, const char *regtype, const char *domain) {
+  VALUE self = reply_new(service, flags);
+  rb_funcall(self, rb_intern("set_names"), 3, rb_str_new2(name),
+      rb_str_new2(regtype), rb_str_new2(domain));
+  /* HACK */
+  /* See HACK in dnssd_service.c */
+  rb_ivar_set(self, dnssd_iv_interface,
+      rb_ivar_get(service, dnssd_iv_interface));
+  rb_ivar_set(self, dnssd_iv_port, rb_ivar_get(service, dnssd_iv_port));
+  rb_ivar_set(self, dnssd_iv_text_record,
+      rb_ivar_get(service, dnssd_iv_text_record));
+  /********/
+  return self;
+}
+
+static VALUE
+reply_from_resolve(VALUE service, DNSServiceFlags flags, uint32_t
+    interface, const char *fullname, const char *host_target, uint16_t
+    opaqueport, uint16_t txt_len, const char *txt_rec) {
+  uint16_t port = ntohs(opaqueport);
+  VALUE self = reply_new(service, flags);
+
+  reply_set_interface(self, interface);
+  rb_funcall(self, rb_intern("set_fullname"), 1, rb_str_new2(fullname));
+  rb_ivar_set(self, dnssd_iv_target, rb_str_new2(host_target));
+  rb_ivar_set(self, dnssd_iv_port, UINT2NUM(port));
+  rb_ivar_set(self, dnssd_iv_text_record,
+      text_record_new(rb_str_new(txt_rec, txt_len)));
+
+  return self;
+}
+
+static void
 dnssd_callback(VALUE service, VALUE reply) {
-  VALUE result = rb_funcall2( rb_ivar_get(service, dnssd_iv_block),
-      dnssd_id_call, 1, &reply );
+  VALUE result = rb_funcall2(rb_ivar_get(service, dnssd_iv_block),
+      dnssd_id_call, 1, &reply);
   rb_ivar_set(service, dnssd_iv_result, result);
 }
 
@@ -58,53 +181,12 @@ dnssd_get_interface_index(VALUE interface) {
   }
 }
 
-/*
- * call-seq:
- *    DNSSD::Service.fullname(name, type, domain) => string
- *
- * Concatenate a three-part domain name (as seen in DNSSD::Reply#fullname())
- * into a properly-escaped full domain name.
- *
- * Any dots or slashes in the _name_ must NOT be escaped.
- * May be <code>nil</code> (to construct a PTR record name, e.g. "_ftp._tcp.apple.com").
- *
- * The _type_ is the service type followed by the protocol, separated by a dot (e.g. "_ftp._tcp").
- *
- * The _domain_ is the domain name, e.g. "apple.com".  Any literal dots or backslashes
- * must be escaped.
- *
- * Raises a <code>ArgumentError</code> if the full service name cannot be constructed from
- * the arguments.
- */
-
-static VALUE
-dnssd_service_s_fullname(VALUE klass, VALUE name, VALUE type, VALUE domain) {
-  return dnssd_create_fullname( StringValueCStr(name), StringValueCStr(type),
-      StringValueCStr(domain), 1 );
-}
-
-/*
- * call-seq:
- *    DNSSD::Service.split(fullname)           => array 
- *    DNSSD::Service.split_fullname(fullname)  => array
- *
- * Split a properly escaped multi-part domain name (as seen in DNSSD::Reply#fullname())
- * into an array of names.
- *
- *    DNSSD::Service.split('_http._tcp.local.') #=> ["_http.", "_tcp.", "local."]
- */
-
-static VALUE
-dnssd_service_s_split(VALUE klass, VALUE fullname) {
-  return dnssd_split_fullname(fullname);
-}
-
 /*
  * call-seq:
  *    DNSSD::Service.new() => raises a RuntimeError
  *
- * Services can only be instantiated using DNSSD.enumerate_domains(),
- * DNSSD.browse(), DNSSD.register(), and DNSSD.resolve().
+ * Services can only be instantiated using ::enumerate_domains, ::browse,
+ * ::register, and ::resolve.
  */
 
 static VALUE
@@ -142,11 +224,11 @@ dnssd_service_alloc(VALUE block) {
  * call-seq:
  *    service.stopped? => true or false
  *
- * Returns <code>true</code> if _service_ has been stopped, <code>false</code> otherwise.
+ * Returns true if the service has been stopped.
  */
 
 static VALUE
-dnssd_service_is_stopped(VALUE service) {
+dnssd_service_stopped_p(VALUE service) {
   DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
   return client == NULL ? Qtrue : Qfalse;
 }
@@ -155,27 +237,31 @@ dnssd_service_is_stopped(VALUE service) {
  * call-seq:
  *    service.stop => service
  *
- * Stops _service_ closing the underlying socket and killing
- * the underlying thread.
- * 
- * It is good practice to all stop running services before exit.
+ * Stops the service, closing the underlying socket and killing the underlying
+ * thread.
  *
- *    service = DNSSD.browse('_http._tcp') do |r|
- *        # found a service ...
- *    end
- *    sleep(2)
- *    service.stop
+ * It is good practice to all stop running services before exit.
  *
+ *   service = DNSSD.browse('_http._tcp') do |r|
+ *     puts "Found #{r.name}"
+ *   end
+ *   sleep(2)
+ *   service.stop
  */
 
 static VALUE
 dnssd_service_stop(VALUE service) {
   VALUE thread;
   DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
+
   /* set to null right away for a bit more thread safety */
   RDATA(service)->data = NULL;
-  if (client == NULL) rb_raise(eDNSSDError, "service is already stopped");
+
+  if (client == NULL)
+    rb_raise(eDNSSDError, "service is already stopped");
+
   dnssd_service_free_client(client);
+
   thread = rb_ivar_get(service, dnssd_iv_thread);
   rb_ivar_set(service, dnssd_iv_block, Qnil);
   rb_ivar_set(service, dnssd_iv_thread, Qnil);
@@ -184,9 +270,20 @@ dnssd_service_stop(VALUE service) {
     /* will raise error if thread is not a Ruby Thread */
     rb_thread_kill(thread);
   }
+
   return service;
 }
 
+/* stop the service only if it is still running */
+
+static VALUE
+dnssd_service_stop2(VALUE service) {
+  if (RTEST(dnssd_service_stopped_p(service))) {
+    return service;
+  }
+  return dnssd_service_stop(service);
+}
+
 static VALUE
 dnssd_service_process(VALUE service) {
   int dns_sd_fd, nfds, result;
@@ -195,6 +292,11 @@ dnssd_service_process(VALUE service) {
   DNSServiceRef *client;
   GetDNSSDService(service, client);
 
+  if (client == NULL) {
+    /* looks like this thread has already been stopped */
+    return Qnil;
+  }
+
   dns_sd_fd = DNSServiceRefSockFD(*client);
   nfds = dns_sd_fd + 1;
   for ( ;; ) {
@@ -205,7 +307,7 @@ dnssd_service_process(VALUE service) {
         (fd_set *) NULL,
         (struct timeval *) NULL);
     if (result > 0) {
-      if ( FD_ISSET(dns_sd_fd, &readfds) ) {
+      if (FD_ISSET(dns_sd_fd, &readfds)) {
         DNSServiceErrorType e = DNSServiceProcessResult(*client);
         dnssd_check_error_code(e);
       }
@@ -213,56 +315,33 @@ dnssd_service_process(VALUE service) {
       break;
     }
   }
+
   /* return the result from the processing */
   return rb_ivar_get(service, dnssd_iv_result);
 }
 
-/* stop the service only if it is still running */
-
-static VALUE
-dnssd_service_stop2(VALUE service) {
-  if (dnssd_service_is_stopped(service)) {
-    return service;
-  }
-  return dnssd_service_stop(service);
-}
-
 static VALUE
 dnssd_service_start(VALUE service) {
-  return rb_ensure(dnssd_service_process, service, dnssd_service_stop2, service);
+  return rb_ensure(dnssd_service_process, service, dnssd_service_stop2,
+      service);
 }
 
 static VALUE
 dnssd_service_start_in_thread(VALUE service) {
-  /* race condition - service.@block could be called before the service.@thread
-   * is set and if the block calls service.stop() will raise an error, even though
-   * the service has been started and is running. */
+  /* race condition - service.@block could be called before the service's
+   * @thread is set and if the block calls #stop will raise an error, even
+   * though the service has been started and is running. */
+
   VALUE thread = rb_thread_create(dnssd_service_process, (void *)service);
   rb_ivar_set(service, dnssd_iv_thread, thread);
-  /* !! IMPORTANT: prevents premature garbage collection of the service,
-   * this way the thread holds a reference to the service and
-   * the service gets marked as long as the thread is running.
-   * Running threads are always marked by Ruby. !! */
-  rb_ivar_set(thread, dnssd_iv_service, service);
-  return service;
-}
 
-/*
- * call-seq:
- *    service.inspect => string
- *
- */
+  /* !! IMPORTANT: prevents premature garbage collection of the service, this
+   * way the thread holds a reference to the service and the service gets
+   * marked as long as the thread is running.  Running threads are always
+   * marked by Ruby. !! */
 
-static VALUE
-dnssd_service_inspect(VALUE self) {
-  VALUE buf = rb_str_buf_new(32);
-  rb_str_buf_cat2(buf, "<#");
-  rb_str_buf_cat2(buf, rb_obj_classname(self));
-  if (dnssd_service_is_stopped(self)) {
-    rb_str_buf_cat2(buf, " (stopped)");
-  }
-  rb_str_buf_cat2(buf, ">");
-  return buf;
+  rb_ivar_set(thread, dnssd_iv_service, service);
+  return service;
 }
 
 static void DNSSD_API
@@ -273,7 +352,8 @@ dnssd_domain_enum_reply(DNSServiceRef sdRef, DNSServiceFlags flags,
   /* other parameters are undefined if errorCode != 0 */
   dnssd_check_error_code(e);
   service = (VALUE)context;
-  dnssd_callback(service, dnssd_domain_enum_new(service, flags, interface_index, domain));
+  dnssd_callback(service,
+      reply_from_domain_enum(service, flags, interface_index, domain));
 }
 
 static VALUE
@@ -286,16 +366,17 @@ sd_enumerate_domains(int argc, VALUE *argv, VALUE service) {
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args (argc, argv, "02", &tmp_flags, &interface);
+  rb_scan_args(argc, argv, "02", &tmp_flags, &interface);
 
   /* optional parameters */
   if (!NIL_P(tmp_flags))
     flags = dnssd_to_flags(tmp_flags);
+
   if (!NIL_P(interface))
     interface_index = dnssd_get_interface_index(interface);
 
   GetDNSSDService(service, client);
-  e = DNSServiceEnumerateDomains (client, flags, interface_index,
+  e = DNSServiceEnumerateDomains(client, flags, interface_index,
       dnssd_domain_enum_reply, (void *)service);
   dnssd_check_error_code(e);
   return service;
@@ -303,7 +384,7 @@ sd_enumerate_domains(int argc, VALUE *argv, VALUE service) {
 
 /*
  * call-seq:
- *    DNSSD.enumerate_domains!(flags, interface) { |reply| } => obj
+ *    DNSSD.enumerate_domains!(flags, interface) { |reply| } => service
  *
  * Synchronously enumerate domains available for browsing and registration.
  * For each domain found a DNSSD::Reply object is passed to block with #domain
@@ -321,40 +402,39 @@ sd_enumerate_domains(int argc, VALUE *argv, VALUE service) {
  */
 
 static VALUE
-dnssd_enumerate_domains_bang (int argc, VALUE * argv, VALUE self) {
+dnssd_enumerate_domains_bang(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start(
-      sd_enumerate_domains(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_enumerate_domains(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 /*
  * call-seq:
- *    DNSSD.enumerate_domains(flags=0, interface=DNSSD::InterfaceAny) {|reply| bloc } => serivce_handle
+ *    DNSSD.enumerate_domains(flags, interface) {|reply| } => serivce
  *
  * Asynchronously enumerate domains available for browsing and registration.
  * For each domain found a DNSSD::DomainEnumReply object is passed to block.
- * The returned _service_handle_ can be used to control when to
- * stop enumerating domains (see DNSSD::Service#stop).
- *
- *    available_domains = []
- *    s = DNSSD.enumerate_domains do |d|
- *      available_domains << d.domain
- *    end
- *    sleep(0.2)
- *    s.stop
- *    puts available_domains.inspect
- *
+ * The returned _service_handle_ can be used to control when to stop
+ * enumerating domains (see DNSSD::Service#stop).
+ *
+ *   domains = []
+ *   
+ *   s = DNSSD.enumerate_domains do |d|
+ *     domains << d.domain
+ *   end
+ *   
+ *   sleep(0.2)
+ *   s.stop
+ *   p domains
  */
 
 static VALUE
 dnssd_enumerate_domains(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start_in_thread(
-      sd_enumerate_domains(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_enumerate_domains(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 static void DNSSD_API
-dnssd_browse_reply (DNSServiceRef client, DNSServiceFlags flags,
+dnssd_browse_reply(DNSServiceRef client, DNSServiceFlags flags,
     uint32_t interface_index, DNSServiceErrorType e,
     const char *name, const char *type,
     const char *domain, void *context) {
@@ -363,8 +443,7 @@ dnssd_browse_reply (DNSServiceRef client, DNSServiceFlags flags,
   dnssd_check_error_code(e);
   service = (VALUE)context;
   dnssd_callback(service,
-      dnssd_browse_new (service, flags, interface_index, name, type, domain)
-      );
+      reply_from_browse(service, flags, interface_index, name, type, domain));
 }
 
 static VALUE
@@ -379,21 +458,21 @@ sd_browse(int argc, VALUE *argv, VALUE service) {
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args (argc, argv, "13", &type,
-      &domain, &tmp_flags, &interface);
+  rb_scan_args(argc, argv, "13", &type, &domain, &tmp_flags, &interface);
   type_str = StringValueCStr(type);
 
   /* optional parameters */
   if (!NIL_P(domain))
     domain_str = dnssd_get_domain(domain);
+
   if (!NIL_P(tmp_flags))
     flags = dnssd_to_flags(tmp_flags);
+
   if (!NIL_P(interface))
     interface_index = dnssd_get_interface_index(interface);
 
   GetDNSSDService(service, client);
-  e = DNSServiceBrowse (client, flags, interface_index,
-      type_str, domain_str,
+  e = DNSServiceBrowse(client, flags, interface_index, type_str, domain_str,
       dnssd_browse_reply, (void *)service);
   dnssd_check_error_code(e);
   return service;
@@ -401,51 +480,65 @@ sd_browse(int argc, VALUE *argv, VALUE service) {
 
 /*
  * call-seq:
- *    DNSSD.browse!(type, domain=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
+ *    DNSSD.browse!(type, domain, flags, interface) {|reply| } => service
  *
  * Synchronously browse for services.
+ *
+ * +domain+ is optional
+ *
+ * +flags+ is 0 by default
+ *
+ * +interface+ is DNSSD::InterfaceAny by default
+ *
  * For each service found a DNSSD::Reply object is passed to block.
  *
- *    timeout(6) do
- *      DNSSD.browse!('_http._tcp') do |r|
- *        puts "found: #{r.inspect}"
- *      end
- *    rescue TimeoutError
- *    end
+ *   timeout 6 do
+ *     DNSSD.browse! '_http._tcp' do |r|
+ *       puts "found: #{r.name}"
+ *     end
+ *   rescue TimeoutError
+ *   end
  *
  */
 
 static VALUE
 dnssd_browse_bang(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start(
-      sd_browse(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_browse(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 /*
  * call-seq:
- *    DNSSD.browse(type, domain=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service_handle
+ *    DNSSD.browse(type, domain, flags, interface) {|reply| } => service
  *
  * Asynchronously browse for services.
+ *
+ * +domain+ is optional
+ *
+ * +flags+ is 0 by default
+ *
+ * +interface+ is DNSSD::InterfaceAny by default
+ *
  * For each service found a DNSSD::BrowseReply object is passed to block.
- * The returned _service_handle_ can be used to control when to
- * stop browsing for services (see DNSSD::Service#stop).
  *
- *    s = DNSSD.browse('_http._tcp') do |b|
- *      puts "found: #{b.inspect}"
- *    end
+ * The returned service can be used to control when to stop browsing for
+ * services (see DNSSD::Service#stop).
  *
+ *   s = DNSSD.browse '_http._tcp' do |b|
+ *     puts "found: #{b.name}"
+ *   end
+ *   
+ *   s.stop
  */
 
 static VALUE
 dnssd_browse(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start_in_thread(
-      sd_browse(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_browse(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 static void DNSSD_API
-dnssd_register_reply (DNSServiceRef client, DNSServiceFlags flags,
+dnssd_register_reply(DNSServiceRef client, DNSServiceFlags flags,
     DNSServiceErrorType e,
     const char *name, const char *regtype,
     const char *domain, void *context) {
@@ -453,13 +546,13 @@ dnssd_register_reply (DNSServiceRef client, DNSServiceFlags flags,
   /* other parameters are undefined if errorCode != 0 */
   dnssd_check_error_code(e);
   service = (VALUE)context;
-  dnssd_callback(service, dnssd_register_new(service, flags, name, regtype, domain));
+  dnssd_callback(service,
+      reply_from_register(service, flags, name, regtype, domain));
 }
 
 static VALUE
 sd_register(int argc, VALUE *argv, VALUE service) {
-  VALUE name, type, domain, port,
-  text_record, tmp_flags, interface;
+  VALUE name, type, domain, port, text_record, tmp_flags, interface;
 
   const char *name_str, *type_str, *domain_str = NULL;
   uint16_t opaqueport;
@@ -471,8 +564,7 @@ sd_register(int argc, VALUE *argv, VALUE service) {
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args (argc, argv, "43",
-      &name, &type, &domain, &port,
+  rb_scan_args(argc, argv, "43", &name, &type, &domain, &port,
       &text_record, &tmp_flags, &interface);
 
   /* required parameters */
@@ -481,17 +573,20 @@ sd_register(int argc, VALUE *argv, VALUE service) {
 
   if (!NIL_P(domain))
     domain_str = dnssd_get_domain(domain);
+
   /* convert from host to net byte order */
   opaqueport = htons((uint16_t)NUM2UINT(port));
 
   /* optional parameters */
   if (!NIL_P(text_record)) {
-    text_record = dnssd_tr_to_encoded_str(text_record);
+    text_record = rb_funcall(text_record, dnssd_id_encode, 0);
     txt_rec = RSTRING_PTR(text_record);
     txt_len = RSTRING_LEN(text_record);
   }
+
   if (!NIL_P(tmp_flags))
     flags = dnssd_to_flags(tmp_flags);
+
   if(!NIL_P(interface))
     interface_index = dnssd_get_interface_index(interface);
 
@@ -502,10 +597,10 @@ sd_register(int argc, VALUE *argv, VALUE service) {
   rb_iv_set(service, "@port", port);
   rb_iv_set(service, "@text_record", text_record);
   /********/
-  e = DNSServiceRegister (client, flags, interface_index,
-      name_str, type_str, domain_str,
-      NULL, opaqueport, txt_len, txt_rec,
-      dnssd_register_reply, (void*)service );
+
+  e = DNSServiceRegister(client, flags, interface_index, name_str, type_str,
+      domain_str, NULL, opaqueport, txt_len, txt_rec, dnssd_register_reply,
+      (void*)service);
   dnssd_check_error_code(e);
   return service;
 }
@@ -514,54 +609,60 @@ sd_register(int argc, VALUE *argv, VALUE service) {
  * call-seq:
  *    DNSSD.register!(name, type, domain, port, text_record=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
  *
- * Synchronously register a service.  A DNSSD::Reply object is passed
- * to the block when the registration completes.
- *
- *    DNSSD.register!("My Files", "_http._tcp", nil, 8080) do |r|
- *      warn("successfully registered: #{r.inspect}")
- *    end
+ * Synchronously 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|
+ *     puts "successfully registered: #{r.inspect}"
+ *   end
  */
 
 static VALUE
 dnssd_register_bang(int argc, VALUE * argv, VALUE self) {
+  VALUE block = Qnil;
+
+  if (rb_block_given_p())
+    block = rb_block_proc();
+
   return dnssd_service_start(
-      sd_register(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_register(argc, argv, dnssd_service_alloc(block)));
 }
 
 /*
  * call-seq:
- *    DNSSD.register(name, type, domain, port, text_record=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service_handle
- *
- * Asynchronously register a service.  A DNSSD::Reply object is
- * passed to the block when the registration completes.
- * The returned _service_handle_ can be used to control when to
- * stop the service (see DNSSD::Service#stop).
- *
- *    # Start a webserver and register it using DNS Service Discovery
- *    require 'dnssd'
- *    require 'webrick'
- *    
- *    web_s = WEBrick::HTTPServer.new(:Port=>8080, :DocumentRoot=>Dir::pwd)
- *    dns_s = DNSSD.register("My Files", "_http._tcp", nil, 8080) do |r|
- *      warn("successfully registered: #{r.inspect}")
- *    end
- *    
- *    trap("INT"){ dns_s.stop; web_s.shutdown }
- *    web_s.start
- *
+ *    DNSSD.register(name, type, domain, port, text_record=nil, flags=0, interface=DNSSD::InterfaceAny) { |reply| } => service
+ *
+ * Asynchronously register a service.  A DNSSD::Reply object is passed to the
+ * optional block when the registration completes.
+ *
+ * The returned service can be used to control when to stop the service.
+ *
+ *   # Start a webserver and register it using DNS Service Discovery
+ *   require 'dnssd'
+ *   require 'webrick'
+ *   
+ *   web_s = WEBrick::HTTPServer.new :Port => 8080, :DocumentRoot => Dir.pwd
+ *   dns_s = DNSSD.register "My Files", "_http._tcp", nil, 8080 do |r|
+ *     warn "successfully registered: #{r.inspect}"
+ *   end
+ *   
+ *   trap "INT" do dns_s.stop; web_s.shutdown end
+ *   web_s.start
  */
 
 static VALUE
 dnssd_register(int argc, VALUE * argv, VALUE self) {
+  VALUE block = Qnil;
+
+  if (rb_block_given_p())
+    block = rb_block_proc();
+
   return dnssd_service_start_in_thread(
-      sd_register(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_register(argc, argv, dnssd_service_alloc(block)));
 }
 
 static void DNSSD_API
-dnssd_resolve_reply (DNSServiceRef client, DNSServiceFlags flags,
+dnssd_resolve_reply(DNSServiceRef client, DNSServiceFlags flags,
     uint32_t interface_index, DNSServiceErrorType e,
     const char *fullname, const char *host_target,
     uint16_t opaqueport, uint16_t txt_len,
@@ -571,9 +672,8 @@ dnssd_resolve_reply (DNSServiceRef client, DNSServiceFlags flags,
   dnssd_check_error_code(e);
   service = (VALUE)context;
   dnssd_callback(service,
-      dnssd_resolve_new(service, flags, interface_index, fullname,
-        host_target, opaqueport, txt_len, txt_rec)
-      );
+      reply_from_resolve(service, flags, interface_index, fullname,
+        host_target, opaqueport, txt_len, txt_rec));
 }
 
 static VALUE
@@ -590,18 +690,19 @@ sd_resolve(int argc, VALUE *argv, VALUE service) {
   rb_scan_args(argc, argv, "32", &name, &type, &domain, &tmp_flags, &interface);
 
   /* required parameters */
-  name_str = StringValueCStr(name),
-           type_str = StringValueCStr(type),
-           domain_str = dnssd_get_domain(domain);
+  name_str = StringValueCStr(name);
+  type_str = StringValueCStr(type);
+  domain_str = dnssd_get_domain(domain);
 
   /* optional parameters */
   if (!NIL_P(tmp_flags))
     flags = dnssd_to_flags(tmp_flags);
+
   if (!NIL_P(interface))
     interface_index = dnssd_get_interface_index(interface);
 
   GetDNSSDService(service, client);
-  err = DNSServiceResolve (client, flags, interface_index, name_str, type_str,
+  err = DNSServiceResolve(client, flags, interface_index, name_str, type_str,
       domain_str, dnssd_resolve_reply, (void *)service);
   dnssd_check_error_code(err);
   return service;
@@ -609,90 +710,91 @@ sd_resolve(int argc, VALUE *argv, VALUE service) {
 
 /*
  * call-seq:
- *    DNSSD.resolve!(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
+ *    DNSSD.resolve!(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service
  *
  * Synchronously resolve a service discovered via DNSSD.browse().
- * The service is resolved to a target host name, port number, and
- * text record - all contained in the DNSSD::Reply object
- * passed to the required block.
  *
- *    timeout(2) do
- *      DNSSD.resolve!("foo bar", "_http._tcp", "local") do |r|
- *        puts r.inspect
- *      end
- *    rescue TimeoutError
- *    end
+ * The service is resolved to a target host name, port number, and text record
+ * - all contained in the DNSSD::Reply object passed to the required block.
  *
+ *   timeout 2 do
+ *     DNSSD.resolve! "foo bar", "_http._tcp", "local" do |r|
+ *       p r
+ *     end
+ *   rescue TimeoutError
+ *   end
  */
 
 static VALUE
 dnssd_resolve_bang(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start(
-      sd_resolve(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_resolve(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 /*
  * call-seq:
- *    DNSSD.resolve(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service_handle
+ *    DNSSD.resolve(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| } => service
  *
  * Asynchronously resolve a service discovered via DNSSD.browse().
- * The service is resolved to a target host name, port number, and
- * text record - all contained in the DNSSD::Reply object
- * passed to the required block.  
- * The returned _service_handle_ 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|
- *      puts r.inspect
- *    end
- *    sleep(2)
- *    s.stop
  *
+ * The service is resolved to a target host name, port number, and text record
+ * - all contained in the DNSSD::Reply object passed to the required block.
+ *
+ * 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|
+ *     p r
+ *   end
+ *   sleep 2
+ *   s.stop
  */
 
 static VALUE
 dnssd_resolve(int argc, VALUE * argv, VALUE self) {
   return dnssd_service_start_in_thread(
-      sd_resolve(argc, argv, dnssd_service_alloc(rb_block_proc()))
-      );
+      sd_resolve(argc, argv, dnssd_service_alloc(rb_block_proc())));
 }
 
 void
 Init_DNSSD_Service(void) {
-  /* hack so rdoc documents the project correctly */
-#ifdef mDNSSD_RDOC_HACK
-  mDNSSD = rb_define_module("DNSSD");
-#endif
-  dnssd_id_call = rb_intern("call");
-  dnssd_id_to_str = rb_intern("to_str");
-  dnssd_id_to_i = rb_intern("to_i");
-  dnssd_iv_block = rb_intern("@block");
-  dnssd_iv_thread = rb_intern("@thread");
-  dnssd_iv_result = rb_intern("@result");
-  dnssd_iv_service = rb_intern("@service");
-
-  cDNSSDService = rb_define_class_under(mDNSSD, "Service", rb_cObject);
+  VALUE mDNSSD = rb_define_module("DNSSD");
+
+  dnssd_id_call        = rb_intern("call");
+  dnssd_id_encode      = rb_intern("encode");
+  dnssd_id_to_i        = rb_intern("to_i");
+  dnssd_id_to_str      = rb_intern("to_str");
+
+  dnssd_iv_block       = rb_intern("@block");
+  dnssd_iv_domain      = rb_intern("@domain");
+  dnssd_iv_interface   = rb_intern("@interface");
+  dnssd_iv_port        = rb_intern("@port");
+  dnssd_iv_result      = rb_intern("@result");
+  dnssd_iv_service     = rb_intern("@service");
+  dnssd_iv_target      = rb_intern("@target");
+  dnssd_iv_text_record = rb_intern("@text_record");
+  dnssd_iv_thread      = rb_intern("@thread");
+
+  cDNSSDReply      = rb_define_class_under(mDNSSD, "Reply",      rb_cObject);
+  cDNSSDService    = rb_define_class_under(mDNSSD, "Service",    rb_cObject);
+  cDNSSDTextRecord = rb_define_class_under(mDNSSD, "TextRecord", rb_cObject);
 
   rb_define_singleton_method(cDNSSDService, "new", dnssd_service_new, -1);
   rb_define_singleton_method(cDNSSDService, "fullname", dnssd_service_s_fullname, 3);
-  rb_define_singleton_method(cDNSSDService, "split_fullname", dnssd_service_s_split, 1);
-  rb_define_singleton_method(cDNSSDService, "split", dnssd_service_s_split, 1);
-
-  /* Access the services underlying thread.  Returns nil if the service is synchronous. */
-  rb_define_attr(cDNSSDService, "thread", 1, 0);
 
   rb_define_method(cDNSSDService, "stop", dnssd_service_stop, 0);
-  rb_define_method(cDNSSDService, "stopped?", dnssd_service_is_stopped, 0);
-  rb_define_method(cDNSSDService, "inspect", dnssd_service_inspect, 0);
+  rb_define_method(cDNSSDService, "stopped?", dnssd_service_stopped_p, 0);
 
-  rb_define_module_function(mDNSSD, "enumerate_domains", dnssd_enumerate_domains, -1);
-  rb_define_module_function(mDNSSD, "enumerate_domains!", dnssd_enumerate_domains_bang, -1);
   rb_define_module_function(mDNSSD, "browse", dnssd_browse, -1);
   rb_define_module_function(mDNSSD, "browse!", dnssd_browse_bang, -1);
-  rb_define_module_function(mDNSSD, "resolve", dnssd_resolve, -1);
-  rb_define_module_function(mDNSSD, "resolve!", dnssd_resolve_bang, -1);
+
+  rb_define_module_function(mDNSSD, "enumerate_domains", dnssd_enumerate_domains, -1);
+  rb_define_module_function(mDNSSD, "enumerate_domains!", dnssd_enumerate_domains_bang, -1);
+
   rb_define_module_function(mDNSSD, "register", dnssd_register, -1);
   rb_define_module_function(mDNSSD, "register!", dnssd_register_bang, -1);
+
+  rb_define_module_function(mDNSSD, "resolve", dnssd_resolve, -1);
+  rb_define_module_function(mDNSSD, "resolve!", dnssd_resolve_bang, -1);
 }