dnssd 0.6.0 → 0.7.0

data/ext/rdnssd.c

@@ -20,13 +20,6 @@ static VALUE eDNSSDUnknownError;
 
 static VALUE dnssd_errors[DNSSD_ERROR_END - DNSSD_ERROR_START];
 
-/*void 
-dnssd_check_class(VALUE obj, VALUE cClass)
-{
-	if (rb_obj_is_kind_of(obj, cClass) != Qtrue)
-		rb_raise(rb_eRuntimeError, "need %s or a subclass", rb_class2name(cClass));
-}*/
-
 static void
 dnssd_errors_store(VALUE error, int num)
 {
@@ -40,9 +33,11 @@ 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: %i", num);
+			rb_raise(dnssd_errors[num - DNSSD_ERROR_START],
+							 "DNSSD operation failed with error code: %d", num);
 		} else {
-			rb_raise(eDNSSDUnknownError, "DNSSD operation failed with unrecognized error code: %i", num);
+			rb_raise(eDNSSDUnknownError,
+							 "DNSSD operation failed with unrecognized error code: %d", num);
 		}
 	}
 }
@@ -50,15 +45,19 @@ dnssd_check_error_code(DNSServiceErrorType e)
 void
 dnssd_instantiation_error(const char *what)
 {
-	rb_raise(rb_eRuntimeError, "cannot instantiate %s, use DNSSD browse(), resolve() or register() instead", what);
+	rb_raise(rb_eRuntimeError,
+					"cannot instantiate %s, use DNSSD "
+					"enumerate_domains(), browse(), resolve() or register() instead",
+					what);
 }
 
 /*
  * Document-module: DNSSD
  * DNSSD is a wrapper for Apple's DNS Service Discovery library.
- * The methods DNSSD.browse(), DNSSD.register(), and DNSSD.resolve()
- * provide the basic API for making your applications DNS Service
- * Discovery aware.
+ * The methods DNSSD.enumerate_domains, DNSSD.browse(),
+ * DNSSD.register(), and DNSSD.resolve() provide the basic API
+ * for making your applications DNS Service Discovery aware.
+ *
  */
 
 static void

data/ext/rdnssd.h

@@ -7,14 +7,36 @@
 #define RDNSSD_INCLUDED
 
 #include <ruby.h>
+#include <intern.h>
 #include <dns_sd.h>
 
+/* for if_indextoname() and other unix networking functions */
+#ifdef HAVE_UNISTD_H
+	#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+	#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+	#include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_PARAM_H
+	#include <sys/param.h>
+#endif
+#ifdef HAVE_NET_IF_H
+	#include <net/if.h>
+#endif
+#ifdef HAVE_SYS_IF_H
+	#include <sys/if.h>
+#endif
+
 extern VALUE mDNSSD;
 
 void	dnssd_check_error_code(DNSServiceErrorType e);
 void	dnssd_instantiation_error(const char *what);
 
-VALUE	dnssd_create_fullname(VALUE name, VALUE regtype, VALUE domain, int err_flag);
+VALUE	dnssd_create_fullname(const char *name, const char *regtype, const char *domain, int err_flag);
+VALUE	dnssd_split_fullname(VALUE fullname);
 
 /* decodes a buffer, creating a new text record */
 VALUE	dnssd_tr_new(long len, const char *buf);
@@ -24,12 +46,15 @@ VALUE	dnssd_tr_to_encoded_str(VALUE v);
 /* Get DNSServiceFlags from self */
 DNSServiceFlags dnssd_to_flags(VALUE obj);
 
-VALUE	dnssd_register_new(VALUE service,	DNSServiceFlags flags, const char *name,
-													const char *regtype, const char *domain	);
+VALUE dnssd_domain_enum_new(VALUE service, DNSServiceFlags flags,
+														uint32_t interface, const char *domain);
 
 VALUE	dnssd_browse_new(VALUE service,	DNSServiceFlags flags, uint32_t interface,
 												const char *name, const char *regtype, const char *domain);
 
+VALUE dnssd_register_new(VALUE service,	DNSServiceFlags flags, const char *name,
+													const char *regtype, const char *domain);
+
 VALUE	dnssd_resolve_new(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);

data/ext/rdnssd_service.c

@@ -1,6 +1,6 @@
 /*
  * Ruby Rendezvous Binding
- * $Id: rdnssd_service.c,v 1.12 2004/10/07 15:19:14 cmills Exp $
+ * $Id: rdnssd_service.c,v 1.24 2005/03/22 00:19:37 cmills Exp $
  *
  * Copyright (c) 2004 Chad Fowler, Charles Mills, Rich Kilmer
  * Licenced under the same terms as Ruby.
@@ -8,15 +8,10 @@
  */
 
 #include "rdnssd.h"
-#include <intern.h>
-
-/* for if_nametoindex() */
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <net/if.h>
+#include <assert.h>
 
 #ifndef DNSSD_API
-	/* define as nothing if not defined in "dns_sd.h" header  */
+	/* define as nothing if not defined in Apple's "dns_sd.h" header  */
 	#define DNSSD_API 
 #endif
 
@@ -25,19 +20,19 @@ static ID dnssd_id_call;
 static ID dnssd_id_to_str;
 static ID dnssd_iv_block;
 static ID dnssd_iv_thread;
+static ID dnssd_iv_result;
 static ID dnssd_iv_service;
 
 #define IsDNSSDService(obj) (rb_obj_is_kind_of(obj,cDNSSDService)==Qtrue)
-#define GetDNSSDService(obj, var) Data_Get_Struct(obj, DNSServiceRef, var)
-
-static VALUE dnssd_process(VALUE service);
+#define GetDNSSDService(obj, var) \
+	do { assert(IsDNSSDService(obj)); Data_Get_Struct(obj, DNSServiceRef, var); } while (0)
 
-static void
-dnssd_check_block(VALUE block)
+void
+dnssd_callback(VALUE service, VALUE reply)
 {
-	if (block == Qnil) {
-		rb_raise(rb_eArgError, "block required");
-	}
+  VALUE result = rb_funcall2( rb_ivar_get(service, dnssd_iv_block),
+															dnssd_id_call, 1, &reply );
+  rb_ivar_set(service, dnssd_iv_result, result);
 }
 
 static const char *
@@ -45,7 +40,7 @@ dnssd_get_domain(VALUE service_domain)
 {
 	const char *domain = StringValueCStr(service_domain);
 	/* max len including the null terminator and trailing '.' */
-	if (strlen(domain) >= kDNSServiceMaxDomainName - 1)
+	if (RSTRING(service_domain)->len >= kDNSServiceMaxDomainName - 1)
 		rb_raise(rb_eArgError, "domain name string too large");
 	return domain;
 }
@@ -63,7 +58,7 @@ dnssd_get_interface_index(VALUE interface)
 
 /*
  * call-seq:
- *    DNSSD::Serivce.fullname(name, type, domain) => string
+ *    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.
@@ -79,20 +74,36 @@ dnssd_get_interface_index(VALUE interface)
  * Raises a <code>ArgumentError</code> if the full service name cannot be constructed from
  * the arguments.
  */
-
 static VALUE
-dnssd_service_fullname(VALUE klass, VALUE name, VALUE type, VALUE domain)
+dnssd_service_s_fullname(VALUE klass, VALUE name, VALUE type, VALUE domain)
 {
-	return dnssd_create_fullname(name, type, domain, 1);
+	return dnssd_create_fullname( StringValueCStr(name), StringValueCStr(type),
+																StringValueCStr(domain), 1 );
 }
 
 /*
  * call-seq:
- *    DNSSD::Serivce.new() => raises a RuntimeError
+ *    DNSSD::Service.split(fullname)           => array 
+ *    DNSSD::Service.split_fullname(fullname)  => array
  *
- * Services can only be instantiated using DNSSD.browse(), DNSSD.register(), and DNSSD.resolve().
+ * 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().
+ */
 static VALUE
 dnssd_service_new(int argc, VALUE *argv, VALUE klass)
 {
@@ -101,11 +112,8 @@ dnssd_service_new(int argc, VALUE *argv, VALUE klass)
 }
 
 static void
-dnssd_service_stop_client(VALUE service)
+dnssd_service_free_client(DNSServiceRef *client)
 {
-	DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
-	/* set to null right away for a bit more thread safety */
-	RDATA(service)->data = NULL;
   DNSServiceRefDeallocate(*client);
 	free(client); /* free the pointer */
 }
@@ -115,10 +123,8 @@ dnssd_service_free(void *ptr)
 {
 	DNSServiceRef *client = (DNSServiceRef*)ptr;
 	if (client) {
-		/* client will be non-null only if client has not been deallocated
-		 * see dnssd_service_stop_client() above. */
-		DNSServiceRefDeallocate(*client);
-		free(client); /* free the pointer, see dnssd_service_alloc() below */
+		/* client will be non-null only if client has not been deallocated */
+		dnssd_service_free_client(client);
 	}
 }
 
@@ -129,71 +135,131 @@ dnssd_service_alloc(VALUE block)
 	VALUE service = Data_Wrap_Struct(cDNSSDService, 0, dnssd_service_free, client);
   rb_ivar_set(service, dnssd_iv_block, block);
   rb_ivar_set(service, dnssd_iv_thread, Qnil);
+  rb_ivar_set(service, dnssd_iv_result, Qnil);
 	return service;
 }
 
-static void
-dnssd_service_start(VALUE service)
-{
-  VALUE thread = rb_thread_create(dnssd_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);
-}
-
 /*
  * call-seq:
  *    service.stopped? => true or false
  *
  * Returns <code>true</code> if _service_ has been stopped, <code>false</code> otherwise.
  */
-
 static VALUE
 dnssd_service_is_stopped(VALUE service)
 {
-  return NIL_P(rb_ivar_get(service, dnssd_iv_thread)) ? Qtrue : Qfalse;
+	DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
+  return client == NULL ? Qtrue : Qfalse;
 }
 
 /*
  * call-seq:
  *    service.stop => service
  *
- * Stops the DNSSD::Service _service_; closing the underlying socket and killing
+ * Stops _service_ closing the underlying socket and killing
  * the underlying thread.
+ * 
+ * It is good practice to all stop running services before exit.
+ *
+ *    service = DNSSD.browse('_http._tcp') do |r|
+ *        # found a service ...
+ *    end
+ *    sleep(2)
+ *    service.stop
+ *
  */
-
 static VALUE
 dnssd_service_stop(VALUE service)
 {
-	VALUE thread = rb_ivar_get(service, dnssd_iv_thread);
-	if (NIL_P(thread)) rb_raise(rb_eRuntimeError, "service is already stopped");
-
-	/* mark service as stopped, then kill thread -
-	 * just in case stop is called in thread! :( */
-	rb_ivar_set(service, dnssd_iv_thread, Qnil);
-	rb_thread_kill(thread);
-
-	/* once thread is killed we don't need to reference the block any more */
+	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(rb_eRuntimeError, "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);
- 
-	/* do this last! - thread must be killed */
-	dnssd_service_stop_client(service);
+  rb_ivar_set(service, dnssd_iv_thread, Qnil);
+	
+	if (!NIL_P(thread)) {
+		/* will raise error if thread is not a Ruby Thread */
+		rb_thread_kill(thread);
+	}
   return service;
 }
 
+static VALUE
+dnssd_service_process(VALUE service)
+{
+  int dns_sd_fd, nfds, result;
+  fd_set readfds;
+
+  DNSServiceRef *client;
+  GetDNSSDService(service, client);
+
+  dns_sd_fd = DNSServiceRefSockFD(*client);
+  nfds = dns_sd_fd + 1;
+  for ( ;; ) {
+    FD_ZERO(&readfds);
+    FD_SET(dns_sd_fd, &readfds);
+    result = rb_thread_select(nfds, &readfds,
+															(fd_set *) NULL,
+															(fd_set *) NULL,
+															(struct timeval *) NULL);
+    if (result > 0) {
+      if ( FD_ISSET(dns_sd_fd, &readfds) ) {
+				DNSServiceErrorType e = DNSServiceProcessResult(*client);
+				dnssd_check_error_code(e);
+      }
+    } else {
+      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);
+}
+
+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. */
+  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
  *
  */
-
 static VALUE
 dnssd_service_inspect(VALUE self)
 {
-	VALUE buf = rb_str_buf_new(0);
+	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)) {
@@ -203,74 +269,116 @@ dnssd_service_inspect(VALUE self)
 	return buf;
 }
 
-static VALUE
-dnssd_service_get_block(VALUE service)
+static void DNSSD_API
+dnssd_domain_enum_reply(DNSServiceRef sdRef, DNSServiceFlags flags,
+												uint32_t interface_index, DNSServiceErrorType e,
+												const char *domain, void *context)
 {
-	return rb_ivar_get(service, dnssd_iv_block);
+	VALUE service;
+	/* 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));
 }
 
 static VALUE
-dnssd_process(VALUE service)
+sd_enumerate_domains(int argc, VALUE *argv, VALUE service)
 {
-  int dns_sd_fd, nfds, result;
-  fd_set readfds;
+  VALUE tmp_flags, interface;
+	
+	DNSServiceFlags flags = 0;
+	uint32_t interface_index = 0;
 
-  DNSServiceRef *client;
-  GetDNSSDService(service, client);
+  DNSServiceErrorType e;
+	DNSServiceRef *client;
 
-  dns_sd_fd = DNSServiceRefSockFD (*client);
-  nfds = dns_sd_fd + 1;
-  while (1) {
-    FD_ZERO (&readfds);
-    FD_SET (dns_sd_fd, &readfds);
-    result = rb_thread_select (nfds, &readfds, (fd_set *) NULL, (fd_set *) NULL, (struct timeval *) NULL);
-    if (result > 0) {
-      if (FD_ISSET (dns_sd_fd, &readfds)) {
-        DNSServiceProcessResult(*client);
-      }
-    } else {
-      break;
-    }
-  }
-  return Qnil;
-}
+  rb_scan_args (argc, argv, "02", &tmp_flags, &interface);
 
-static void DNSSD_API
-dnssd_browse_reply (DNSServiceRef client, DNSServiceFlags flags,
-										uint32_t interface_index, DNSServiceErrorType errorCode,
-							      const char *replyName, const char *replyType,
-										const char *replyDomain, void *context)
-{
-  VALUE service, block, browse_reply;
-	/* other parameters are undefined if errorCode != 0 */
-	dnssd_check_error_code(errorCode);
+	/* optional parameters */
+	if (!NIL_P(tmp_flags))
+		flags = dnssd_to_flags(tmp_flags);
+	if (!NIL_P(interface))
+		interface_index = dnssd_get_interface_index(interface);
 	
-	service = (VALUE)context;
-	block = dnssd_service_get_block(service);
-	browse_reply = dnssd_browse_new(service, flags, interface_index,
-																	replyName, replyType, replyDomain);
-
-	/* client is wrapped by service */
-  rb_funcall2(block, dnssd_id_call, 1, &browse_reply);
+	GetDNSSDService(service, client);
+  e = DNSServiceEnumerateDomains (client, flags, interface_index,
+																	dnssd_domain_enum_reply, (void *)service);
+  dnssd_check_error_code(e);
+	return service;
 }
 
 /*
  * call-seq:
- *    DNSSD.browse(service_type, domain=nil, flags=0, interface=DNSSD::InterfaceAny) do |browse_reply|
- *      block
- *    end => service_handle
+ *    DNSSD.enumerate_domains!(flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
+ *
+ * Synchronously 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 = []
+ *    timeout(2) do
+ *  	  DNSSD.enumerate_domains! do |r|
+ *  	    available_domains << r.domain
+ *      end
+ *    rescue TimeoutError
+ *    end
+ *    puts available_domains.inspect
  *
- * Browse for DNSSD services.
- * For each service found DNSSD::BrowseReply object is passed to block.
+ */
+ 
+static VALUE
+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()))
+														);
+}
+/*
+ * call-seq:
+ *    DNSSD.enumerate_domains(flags=0, interface=DNSSD::InterfaceAny) {|reply| bloc } => serivce_handle
+ *
+ * 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 browsing for services (see DNSSD::Service#stop).
+ * 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
  *
  */
  
 static VALUE
-dnssd_browse (int argc, VALUE * argv, VALUE self)
+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()))
+																			);
+}
+
+static void DNSSD_API
+dnssd_browse_reply (DNSServiceRef client, DNSServiceFlags flags,
+										uint32_t interface_index, DNSServiceErrorType e,
+							      const char *name, const char *type,
+										const char *domain, void *context)
 {
-  VALUE service_type, domain, tmp_flags, interface, block;
+	VALUE service;
+	/* other parameters are undefined if errorCode != 0 */
+	dnssd_check_error_code(e);
+	service = (VALUE)context;
+	dnssd_callback(service,
+			dnssd_browse_new (service, flags, interface_index, name, type, domain)
+								);
+}
+
+static VALUE
+sd_browse(int argc, VALUE *argv, VALUE service)
+{
+  VALUE type, domain, tmp_flags, interface;
 	
 	const char *type_str;
 	const char *domain_str = NULL;
@@ -279,72 +387,91 @@ dnssd_browse (int argc, VALUE * argv, VALUE self)
 
   DNSServiceErrorType e;
 	DNSServiceRef *client;
-  VALUE service;
-
-  rb_scan_args (argc, argv, "13&", &service_type, &domain,
-								&tmp_flags, &interface, &block);
 
-	/* required */
-	dnssd_check_block(block);
-	type_str = StringValueCStr(service_type);
+  rb_scan_args (argc, argv, "13", &type,
+								&domain, &tmp_flags, &interface);
+	type_str = StringValueCStr(type);
 
 	/* optional parameters */
-  if (domain != Qnil)
+  if (!NIL_P(domain))
 		domain_str = dnssd_get_domain(domain);
-	if (tmp_flags != Qnil)
+	if (!NIL_P(tmp_flags))
 		flags = dnssd_to_flags(tmp_flags);
-	if (interface != Qnil)
+	if (!NIL_P(interface))
 		interface_index = dnssd_get_interface_index(interface);
 	
-	/* allocate this last since all other parameters are on the stack (thanks to & unary operator) */
-	service = dnssd_service_alloc(block);
 	GetDNSSDService(service, client);
-	
   e = DNSServiceBrowse (client, flags, interface_index,
 												type_str, domain_str,
 												dnssd_browse_reply, (void *)service);
   dnssd_check_error_code(e);
-	dnssd_service_start(service);
-  return service;
+	return service;
 }
 
-static void DNSSD_API
-dnssd_register_reply (DNSServiceRef client, DNSServiceFlags flags,
-											DNSServiceErrorType errorCode,
-											const char *name, const char *regtype,
-											const char *domain, void *context)
+/*
+ * call-seq:
+ *    DNSSD.browse!(type, domain=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
+ *
+ * Synchronously browse for services.
+ * 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
+ *
+ */
+static VALUE
+dnssd_browse_bang(int argc, VALUE * argv, VALUE self)
 {
-	VALUE service, block, register_reply;
-	/* other parameters are undefined if errorCode != 0 */
-	dnssd_check_error_code(errorCode);
-
-  service = (VALUE)context;
-  block = dnssd_service_get_block(service);
-	register_reply = dnssd_register_new(service, flags, name, regtype, domain);
-
-  rb_funcall2(block, dnssd_id_call, 1, &register_reply);
+	return dnssd_service_start(
+		sd_browse(argc, argv, dnssd_service_alloc(rb_block_proc()))
+														);
 }
+ 
 
 /*
  * call-seq:
- *    DNSSD.register(service_name, service_type, service_domain, service_port, text_record=nil, flags=0, interface=DNSSD::InterfaceAny) do |register_reply|
- *      block
- *    end => service_handle
- *
- * Register a service.
- * If a block is provided a DNSSD::RegisterReply object will passed to the block
- * when the registration completes or asynchronously fails.
- * If no block is passed the client will not be notified of the default values picked
- * on its behalf or of any error that occur.
+ *    DNSSD.browse(type, domain=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service_handle
+ *
+ * Asynchronously browse for services.
+ * For each service found a DNSSD::BrowseReply object is passed to block.
  * The returned _service_handle_ can be used to control when to
- * stop the service (see DNSSD::Service#stop).
+ * stop browsing for services (see DNSSD::Service#stop).
+ *
+ *    s = DNSSD.browse('_http._tcp') do |b|
+ *      puts "found: #{b.inspect}"
+ *    end
+ *
  */
+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()))
+																			);
+}
+
+static void DNSSD_API
+dnssd_register_reply (DNSServiceRef client, DNSServiceFlags flags,
+											DNSServiceErrorType e,
+											const char *name, const char *regtype,
+											const char *domain, void *context)
+{
+	VALUE service;
+	/* 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));
+}
 
 static VALUE
-dnssd_register (int argc, VALUE * argv, VALUE self)
+sd_register(int argc, VALUE *argv, VALUE service)
 {
-  VALUE service_name, service_type, service_domain, service_port,
-				text_record, tmp_flags, interface, block;
+  VALUE name, type, domain, port,
+				text_record, tmp_flags, interface;
 
 	const char *name_str, *type_str, *domain_str = NULL;
 	uint16_t opaqueport;
@@ -355,100 +482,117 @@ dnssd_register (int argc, VALUE * argv, VALUE self)
 
   DNSServiceErrorType e;
   DNSServiceRef *client;
-  VALUE service;
 
-  rb_scan_args (argc, argv, "43&",
-								&service_name, &service_type,
-								&service_domain, &service_port,
-								&text_record, &tmp_flags,
-								&interface, &block);
+  rb_scan_args (argc, argv, "43",
+								&name, &type, &domain, &port,
+								&text_record, &tmp_flags, &interface);
 
 	/* required parameters */
-	dnssd_check_block(block); /* in the future this may not be required */
-	name_str = StringValueCStr(service_name);
-	type_str = StringValueCStr(service_type);
+	name_str = StringValueCStr(name);
+	type_str = StringValueCStr(type);
 
-	if (service_domain != Qnil)
-		domain_str = dnssd_get_domain(service_domain);
+	if (!NIL_P(domain))
+		domain_str = dnssd_get_domain(domain);
 	/* convert from host to net byte order */
-	opaqueport = htons((uint16_t)NUM2UINT(service_port));
+	opaqueport = htons((uint16_t)NUM2UINT(port));
 
 	/* optional parameters */
-	if (text_record != Qnil) {
+	if (!NIL_P(text_record)) {
 		text_record = dnssd_tr_to_encoded_str(text_record);
 		txt_rec = RSTRING(text_record)->ptr;
 		txt_len = RSTRING(text_record)->len;
 	}
-	if (tmp_flags != Qnil)
+	if (!NIL_P(tmp_flags))
 		flags = dnssd_to_flags(tmp_flags);
-  if(interface != Qnil)
+  if(!NIL_P(interface))
 		interface_index = dnssd_get_interface_index(interface);
 
-	/* allocate this last since all other parameters are on the stack (thanks to & unary operator) */
-	service = dnssd_service_alloc(block);
   GetDNSSDService(service, client);
 
-  e = DNSServiceRegister( client, flags, interface_index,
+	/* HACK */
+	rb_iv_set(service, "@interface", interface);
+	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,
-													/*block == Qnil ? NULL : dnssd_register_reply,*/
 													dnssd_register_reply, (void*)service );
   dnssd_check_error_code(e);
-  dnssd_service_start(service);
   return service;
 }
 
 /*
-set text record using AddRecord
+ * 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
+ *
+ */
 static VALUE
-dnssd_service_record(VALUE self, VALUE text_record)
+dnssd_register_bang(int argc, VALUE * argv, VALUE self)
 {
-	VALUE text_record, flags, time_to_live;
-	
-	
-	text_record = dnssd_tr_to_encoded_str(text_record);
-	
+	return dnssd_service_start(
+		sd_register(argc, argv, dnssd_service_alloc(rb_block_proc()))
+														);
+}
+
+/*
+ * 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
+ *
+ */
+static VALUE
+dnssd_register(int argc, VALUE * argv, VALUE self)
+{
+	return dnssd_service_start_in_thread(
+		sd_register(argc, argv, dnssd_service_alloc(rb_block_proc()))
+																			);
 }
-*/
 
 static void DNSSD_API
 dnssd_resolve_reply (DNSServiceRef client, DNSServiceFlags flags,
-										 uint32_t interface_index, DNSServiceErrorType errorCode,
+										 uint32_t interface_index, DNSServiceErrorType e,
 										 const char *fullname, const char *host_target,
 										 uint16_t opaqueport, uint16_t txt_len,
 										 const char *txt_rec, void *context)
 {
+	VALUE service;
 	/* other parameters are undefined if errorCode != 0 */
-	dnssd_check_error_code(errorCode);
-	VALUE service, block, resolve_reply;
-
+	dnssd_check_error_code(e);
 	service = (VALUE)context;
-  block = dnssd_service_get_block(service);
-	resolve_reply = dnssd_resolve_new(service, flags, interface_index,
-																		fullname, host_target, opaqueport,
-																		txt_len, txt_rec);
-  
-	rb_funcall2(block, dnssd_id_call, 1, &resolve_reply);
+	dnssd_callback(service,
+			dnssd_resolve_new(service, flags, interface_index, fullname,
+												host_target, opaqueport, txt_len, txt_rec)
+								);
 }
 
-/*
- * call-seq:
- *    DNSSD.resolve(service_name, service_type, service_domain, flags=0, interface=DNSSD::InterfaceAny) do |resolve_reply|
- *      block
- *    end => service_handle
- *
- * 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::ResolveReply 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).
- */
-
 static VALUE
-dnssd_resolve(int argc, VALUE * argv, VALUE self)
+sd_resolve(int argc, VALUE *argv, VALUE service)
 {
-  VALUE service_name, service_type, service_domain,
-				tmp_flags, interface, block;
+  VALUE name, type, domain, tmp_flags, interface;
 
 	const char *name_str, *type_str, *domain_str;
 	DNSServiceFlags flags = 0;
@@ -456,34 +600,76 @@ dnssd_resolve(int argc, VALUE * argv, VALUE self)
 
   DNSServiceErrorType err;
   DNSServiceRef *client;
-  VALUE service;
 
-  rb_scan_args (argc, argv, "32&",
-								&service_name, &service_type, &service_domain,
-								&tmp_flags, &interface, &block);
+  rb_scan_args(argc, argv, "32", &name, &type, &domain, &tmp_flags, &interface);
 
 	/* required parameters */
-	dnssd_check_block(block);
-	name_str = StringValueCStr(service_name),
-	type_str = StringValueCStr(service_type),
-	domain_str = dnssd_get_domain(service_domain);
+	name_str = StringValueCStr(name),
+	type_str = StringValueCStr(type),
+	domain_str = dnssd_get_domain(domain);
 
 	/* optional parameters */
-	if (tmp_flags != Qnil)
+	if (!NIL_P(tmp_flags))
 		flags = dnssd_to_flags(tmp_flags);
-	if (interface != Qnil) {
+	if (!NIL_P(interface))
 		interface_index = dnssd_get_interface_index(interface);
-	}
 
-	/* allocate this last since all other parameters are on the stack (thanks to unary & operator) */
-	service = dnssd_service_alloc(block);
   GetDNSSDService(service, client);
-
   err = DNSServiceResolve (client, flags, interface_index, name_str, type_str,
-													 domain_str, dnssd_resolve_reply, (void *) service);
+													 domain_str, dnssd_resolve_reply, (void *)service);
   dnssd_check_error_code(err);
-	dnssd_service_start(service);
-  return service;
+	return service;
+}
+
+/*
+ * call-seq:
+ *    DNSSD.resolve!(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => obj
+ *
+ * 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
+ *
+ */
+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()))
+														);
+}
+
+/*
+ * call-seq:
+ *    DNSSD.resolve(name, type, domain, flags=0, interface=DNSSD::InterfaceAny) {|reply| block } => service_handle
+ *
+ * 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
+ *
+ */
+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()))
+																			);
 }
 
 void
@@ -497,19 +683,30 @@ Init_DNSSD_Service(void)
 	dnssd_id_to_str = rb_intern("to_str");
 	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);
 
 	rb_define_singleton_method(cDNSSDService, "new", dnssd_service_new, -1);
-	rb_define_singleton_method(cDNSSDService, "fullname", dnssd_service_fullname, 3);
+	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_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, "register", dnssd_register, -1);
+  rb_define_module_function(mDNSSD, "register!", dnssd_register_bang, -1);
 }