dnssd 1.1.0 → 1.2

data/ext/dnssd/service.c

@@ -1,5 +1,4 @@
 #include "dnssd.h"
-#include <assert.h>
 
 #ifndef DNSSD_API
   /* define as nothing if not defined in Apple's "dns_sd.h" header  */
@@ -10,28 +9,52 @@ static VALUE cDNSSDReply;
 static VALUE cDNSSDService;
 static VALUE cDNSSDTextRecord;
 
-static ID dnssd_id_call;
-static ID dnssd_id_encode;
-static ID dnssd_id_to_i;
-static ID dnssd_id_to_str;
+static ID dnssd_id_join;
+static ID dnssd_id_push;
 
-static ID dnssd_iv_block;
+static ID dnssd_iv_continue;
 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_replies;
 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)
+/* HACK why is this a macro */
 #define GetDNSSDService(obj, var) \
-  do { assert(IsDNSSDService(obj)); Data_Get_Struct(obj, DNSServiceRef, var); } while (0)
+  do {\
+    Check_Type(obj, T_DATA);\
+    if (rb_obj_is_kind_of(obj, cDNSSDService) != Qtrue)\
+      rb_raise(rb_eTypeError,\
+          "wrong argument type %s (expected DNSSD::Service)",\
+          rb_class2name(CLASS_OF(obj)));\
+    Data_Get_Struct(obj, DNSServiceRef, var);\
+  } while (0)
 
-static DNSServiceFlags
-dnssd_to_flags(VALUE obj) {
-  return (DNSServiceFlags)NUM2ULONG(rb_funcall(obj, dnssd_id_to_i, 0));
+static void
+dnssd_service_callback(VALUE self, VALUE reply) {
+  VALUE replies = rb_ivar_get(self, dnssd_iv_replies);
+
+  rb_funcall(replies, dnssd_id_push, 1, reply);
+}
+
+static void
+dnssd_service_free_client(DNSServiceRef *client) {
+  if (*client) {
+    DNSServiceRefDeallocate(*client);
+    *client = NULL;
+  }
+}
+
+static void
+dnssd_service_free(void *ptr) {
+  DNSServiceRef *client = (DNSServiceRef*)ptr;
+
+  if (client)
+    dnssd_service_free_client(client);
+
+  free(client);
 }
 
 static VALUE
@@ -48,6 +71,26 @@ create_fullname(const char *name, const char *regtype,
   return rb_str_new2(buffer);
 }
 
+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);
+}
+
 /*
  * call-seq:
  *    DNSSD::Service.fullname(name, type, domain) => String
@@ -77,147 +120,28 @@ dnssd_service_s_fullname(VALUE klass, VALUE name, VALUE type, VALUE 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;
-}
+dnssd_service_s_allocate(VALUE klass) {
+  DNSServiceRef *client = ALLOC(DNSServiceRef);
 
-static void
-dnssd_callback(VALUE service, VALUE 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);
-}
+  *client = NULL;
 
-static const char *
-dnssd_get_domain(VALUE service_domain) {
-  const char *domain = StringValueCStr(service_domain);
-  /* max len including the null terminator and trailing '.' */
-  if (RSTRING_LEN(service_domain) >= kDNSServiceMaxDomainName - 1)
-    rb_raise(rb_eArgError, "domain name string too large");
-  return domain;
-}
-
-static uint32_t
-dnssd_get_interface_index(VALUE interface) {
-  /* if the interface is a string then convert it to the interface index */
-  if (rb_respond_to(interface, dnssd_id_to_str)) {
-    return if_nametoindex(StringValueCStr(interface));
-  } else {
-    return (uint32_t)NUM2ULONG(interface);
-  }
+  return Data_Wrap_Struct(klass, 0, dnssd_service_free, client);
 }
 
 /*
  * call-seq:
- *    DNSSD::Service.new() => raises a RuntimeError
+ *    service.started? => true or false
  *
- * Services can only be instantiated using ::enumerate_domains, ::browse,
- * ::register, and ::resolve.
+ * Returns true if the service has been started.
  */
 
 static VALUE
-dnssd_service_new(int argc, VALUE *argv, VALUE klass) {
-  dnssd_instantiation_error(rb_class2name(klass));
-  return Qnil;
-}
-
-static void
-dnssd_service_free_client(DNSServiceRef *client) {
-  DNSServiceRefDeallocate(*client);
-  free(client); /* free the pointer */
-}
-
-static void
-dnssd_service_free(void *ptr) {
-  DNSServiceRef *client = (DNSServiceRef*)ptr;
-  if (client) {
-    /* client will be non-null only if client has not been deallocated */
-    dnssd_service_free_client(client);
-  }
-}
+dnssd_service_started_p(VALUE service) {
+  DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
+  if (client)
+    return (*client) == NULL ? Qfalse : Qtrue;
 
-static VALUE
-dnssd_service_alloc(VALUE block) {
-  DNSServiceRef *client = ALLOC(DNSServiceRef);
-  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;
+  return Qtrue;
 }
 
 /*
@@ -230,7 +154,11 @@ dnssd_service_alloc(VALUE block) {
 static VALUE
 dnssd_service_stopped_p(VALUE service) {
   DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
-  return client == NULL ? Qtrue : Qfalse;
+
+  if (client)
+    return (*client) == NULL ? Qtrue : Qfalse;
+
+  return Qtrue;
 }
 
 /*
@@ -250,527 +178,285 @@ dnssd_service_stopped_p(VALUE service) {
  */
 
 static VALUE
-dnssd_service_stop(VALUE service) {
+dnssd_service_stop(VALUE self) {
   VALUE thread;
-  DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
+  DNSServiceRef *client = (DNSServiceRef*)RDATA(self)->data;
 
   /* set to null right away for a bit more thread safety */
-  RDATA(service)->data = NULL;
+  RDATA(self)->data = NULL;
 
   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);
+  thread = rb_ivar_get(self, dnssd_iv_thread);
+  rb_ivar_set(self, dnssd_iv_continue, Qfalse);
 
-  if (!NIL_P(thread)) {
-    /* will raise error if thread is not a Ruby Thread */
-    rb_thread_kill(thread);
+  if (!NIL_P(thread) && thread != rb_thread_current()) {
+    rb_thread_run(thread);
+    rb_funcall(thread, dnssd_id_join, 0);
   }
 
-  return service;
-}
-
-/* stop the service only if it is still running */
+  dnssd_service_free_client(client);
 
-static VALUE
-dnssd_service_stop2(VALUE service) {
-  if (RTEST(dnssd_service_stopped_p(service))) {
-    return service;
-  }
-  return dnssd_service_stop(service);
+  return self;
 }
 
 static VALUE
-dnssd_service_process(VALUE service) {
-  int dns_sd_fd, nfds, result;
-  fd_set readfds;
-
+dnssd_service_process(VALUE self) {
   DNSServiceRef *client;
-  GetDNSSDService(service, client);
+
+  GetDNSSDService(self, 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 ( ;; ) {
-    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);
-}
-
-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's
-   * @thread is set and if the block calls #stop will raise an error, even
-   * though the service has been started and is running. */
+  rb_thread_wait_fd(DNSServiceRefSockFD(*client));
 
-  VALUE thread = rb_thread_create(dnssd_service_process, (void *)service);
-  rb_ivar_set(service, dnssd_iv_thread, thread);
+  if (rb_ivar_get(self, dnssd_iv_continue) == Qfalse)
+    return Qnil;
 
-  /* !! 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. !! */
+  DNSServiceErrorType e = DNSServiceProcessResult(*client);
+  dnssd_check_error_code(e);
 
-  rb_ivar_set(thread, dnssd_iv_service, service);
-  return service;
+  return self;
 }
 
 static void DNSSD_API
-dnssd_domain_enum_reply(DNSServiceRef sdRef, DNSServiceFlags flags,
-    uint32_t interface_index, DNSServiceErrorType e,
-    const char *domain, void *context) {
-  VALUE service;
-  /* other parameters are undefined if errorCode != 0 */
+dnssd_service_browse_reply(DNSServiceRef client, DNSServiceFlags flags,
+    uint32_t interface, DNSServiceErrorType e, const char *name,
+    const char *type, const char *domain, void *context) {
+  VALUE service, reply;
+
   dnssd_check_error_code(e);
+
   service = (VALUE)context;
-  dnssd_callback(service,
-      reply_from_domain_enum(service, flags, interface_index, domain));
+
+  reply = reply_new(service, flags);
+  reply_set_interface(reply, interface);
+  rb_funcall(reply, rb_intern("set_names"), 3, rb_str_new2(name),
+      rb_str_new2(type), rb_str_new2(domain));
+
+  dnssd_service_callback(service, reply);
 }
 
-static VALUE
-sd_enumerate_domains(int argc, VALUE *argv, VALUE service) {
-  VALUE tmp_flags, interface;
+/* Binding to DNSServiceBrowse
+ */
 
+static VALUE
+dnssd_service_browse(VALUE self, VALUE _type, VALUE _domain, VALUE _flags,
+    VALUE _interface) {
+  const char *type;
+  const char *domain = NULL;
   DNSServiceFlags flags = 0;
-  uint32_t interface_index = 0;
+  uint32_t interface = 0;
 
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args(argc, argv, "02", &tmp_flags, &interface);
+  type = StringValueCStr(_type);
 
-  /* optional parameters */
-  if (!NIL_P(tmp_flags))
-    flags = dnssd_to_flags(tmp_flags);
+  if (!NIL_P(_domain))
+    domain = StringValueCStr(_domain);
 
-  if (!NIL_P(interface))
-    interface_index = dnssd_get_interface_index(interface);
+  if (!NIL_P(_flags))
+    flags = (DNSServiceFlags)NUM2ULONG(_flags);
 
-  GetDNSSDService(service, client);
-  e = DNSServiceEnumerateDomains(client, flags, interface_index,
-      dnssd_domain_enum_reply, (void *)service);
-  dnssd_check_error_code(e);
-  return service;
-}
+  if (!NIL_P(_interface))
+    interface = NUM2ULONG(_interface);
 
-/*
- * call-seq:
- *    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
- * 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
- *
- */
+  GetDNSSDService(self, client);
 
-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())));
-}
+  e = DNSServiceBrowse(client, flags, interface, type, domain,
+      dnssd_service_browse_reply, (void *)self);
 
-/*
- * call-seq:
- *    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).
- *
- *   domains = []
- *   
- *   s = DNSSD.enumerate_domains do |d|
- *     domains << d.domain
- *   end
- *   
- *   sleep(0.2)
- *   s.stop
- *   p domains
- */
+  dnssd_check_error_code(e);
 
-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())));
+  return self;
 }
 
 static void DNSSD_API
-dnssd_browse_reply(DNSServiceRef client, DNSServiceFlags flags,
-    uint32_t interface_index, DNSServiceErrorType e,
-    const char *name, const char *type,
+dnssd_service_enumerate_domains_reply(DNSServiceRef client,
+    DNSServiceFlags flags, uint32_t interface, DNSServiceErrorType e,
     const char *domain, void *context) {
-  VALUE service;
-  /* other parameters are undefined if errorCode != 0 */
+  VALUE service, reply;
+
   dnssd_check_error_code(e);
+
   service = (VALUE)context;
-  dnssd_callback(service,
-      reply_from_browse(service, flags, interface_index, name, type, domain));
+
+  reply = reply_new(service, flags);
+  reply_set_interface(reply, interface);
+  rb_ivar_set(reply, dnssd_iv_domain, rb_str_new2(domain));
+
+  dnssd_service_callback(service, reply);
 }
 
-static VALUE
-sd_browse(int argc, VALUE *argv, VALUE service) {
-  VALUE type, domain, tmp_flags, interface;
+/* Binding to DNSServiceEnumerateDomains
+ */
 
-  const char *type_str;
-  const char *domain_str = NULL;
+static VALUE
+dnssd_service_enumerate_domains(VALUE self, VALUE _flags, VALUE _interface) {
   DNSServiceFlags flags = 0;
-  uint32_t interface_index = 0;
+  uint32_t interface = 0;
 
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args(argc, argv, "13", &type, &domain, &tmp_flags, &interface);
-  type_str = StringValueCStr(type);
+  if (!NIL_P(_flags))
+    flags = (DNSServiceFlags)NUM2ULONG(_flags);
 
-  /* optional parameters */
-  if (!NIL_P(domain))
-    domain_str = dnssd_get_domain(domain);
+  if (!NIL_P(_interface))
+    interface = NUM2ULONG(_interface);
 
-  if (!NIL_P(tmp_flags))
-    flags = dnssd_to_flags(tmp_flags);
+  GetDNSSDService(self, client);
 
-  if (!NIL_P(interface))
-    interface_index = dnssd_get_interface_index(interface);
+  e = DNSServiceEnumerateDomains(client, flags, interface,
+      dnssd_service_enumerate_domains_reply, (void *)self);
 
-  GetDNSSDService(service, client);
-  e = DNSServiceBrowse(client, flags, interface_index, type_str, domain_str,
-      dnssd_browse_reply, (void *)service);
   dnssd_check_error_code(e);
-  return service;
-}
 
-/*
- * call-seq:
- *    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.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())));
-}
-
-/*
- * call-seq:
- *    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 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())));
+  return self;
 }
 
 static void DNSSD_API
-dnssd_register_reply(DNSServiceRef client, DNSServiceFlags flags,
-    DNSServiceErrorType e,
-    const char *name, const char *regtype,
+dnssd_service_register_reply(DNSServiceRef client, DNSServiceFlags flags,
+    DNSServiceErrorType e, const char *name, const char *type,
     const char *domain, void *context) {
-  VALUE service;
-  /* other parameters are undefined if errorCode != 0 */
+  VALUE service, reply;
+
   dnssd_check_error_code(e);
+
   service = (VALUE)context;
-  dnssd_callback(service,
-      reply_from_register(service, flags, name, regtype, domain));
+
+  reply = reply_new(service, flags);
+  rb_funcall(reply, rb_intern("set_names"), 3, rb_str_new2(name),
+      rb_str_new2(type), rb_str_new2(domain));
+
+  dnssd_service_callback(service, reply);
 }
 
-static VALUE
-sd_register(int argc, VALUE *argv, VALUE service) {
-  VALUE name, type, domain, port, text_record, tmp_flags, interface;
+/* Binding to DNSServiceRegister
+ */
 
-  const char *name_str, *type_str, *domain_str = NULL;
-  uint16_t opaqueport;
+static VALUE
+dnssd_service_register(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
+    VALUE _host, VALUE _port, VALUE _text_record, VALUE _flags,
+    VALUE _interface) {
+  const char *name, *type, *host = NULL, *domain = NULL;
+  uint16_t port;
   uint16_t txt_len = 0;
   char *txt_rec = NULL;
   DNSServiceFlags flags = 0;
-  uint32_t interface_index = 0;
+  uint32_t interface = 0;
 
   DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  rb_scan_args(argc, argv, "43", &name, &type, &domain, &port,
-      &text_record, &tmp_flags, &interface);
+  name = StringValueCStr(_name);
+  type = StringValueCStr(_type);
 
-  /* required parameters */
-  name_str = StringValueCStr(name);
-  type_str = StringValueCStr(type);
+  if (!NIL_P(_host))
+    host = StringValueCStr(_host);
 
-  if (!NIL_P(domain))
-    domain_str = dnssd_get_domain(domain);
+  if (!NIL_P(_domain))
+    domain = StringValueCStr(_domain);
 
-  /* convert from host to net byte order */
-  opaqueport = htons((uint16_t)NUM2UINT(port));
+  port = htons((uint16_t)NUM2UINT(_port));
 
-  /* optional parameters */
-  if (!NIL_P(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(_text_record)) {
+    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(_flags))
+    flags = (DNSServiceFlags)NUM2ULONG(_flags);
 
-  if(!NIL_P(interface))
-    interface_index = dnssd_get_interface_index(interface);
+  if (!NIL_P(_interface))
+    interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(service, client);
+  GetDNSSDService(self, client);
 
-  /* 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, name, type,
+      domain, host, port, txt_len, txt_rec, dnssd_service_register_reply,
+      (void*)self);
 
-  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;
-}
 
-/*
- * 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
- * optional block when the registration completes.
- *
- *   DNSSD.register! "My Files", "_http._tcp", nil, 8080 do |r|
- *     puts "successfully registered: #{r.inspect}"
- *   end
- */
+  return self;
+}
 
-static VALUE
-dnssd_register_bang(int argc, VALUE * argv, VALUE self) {
-  VALUE block = Qnil;
+static void DNSSD_API
+dnssd_service_resolve_reply(DNSServiceRef client, DNSServiceFlags flags,
+    uint32_t interface, DNSServiceErrorType e, const char *name,
+    const char *target, uint16_t port, uint16_t txt_len,
+    const unsigned char *txt_rec, void *context) {
+  VALUE service, reply, text_record, text_record_str;
 
-  if (rb_block_given_p())
-    block = rb_block_proc();
+  dnssd_check_error_code(e);
 
-  return dnssd_service_start(
-      sd_register(argc, argv, dnssd_service_alloc(block)));
-}
+  service = (VALUE)context;
 
-/*
- * call-seq:
- *    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
- */
+  reply = reply_new(service, flags);
 
-static VALUE
-dnssd_register(int argc, VALUE * argv, VALUE self) {
-  VALUE block = Qnil;
+  reply_set_interface(reply, interface);
+  rb_funcall(reply, rb_intern("set_fullname"), 1, rb_str_new2(name));
+  rb_ivar_set(reply, dnssd_iv_target, rb_str_new2(target));
+  rb_ivar_set(reply, dnssd_iv_port, UINT2NUM(ntohs(port)));
 
-  if (rb_block_given_p())
-    block = rb_block_proc();
+  text_record_str = rb_str_new((char *)txt_rec, txt_len);
+  text_record = rb_class_new_instance(1, &text_record_str, cDNSSDTextRecord);
+  rb_ivar_set(reply, dnssd_iv_text_record, text_record);
 
-  return dnssd_service_start_in_thread(
-      sd_register(argc, argv, dnssd_service_alloc(block)));
+  dnssd_service_callback(service, reply);
 }
 
-static void DNSSD_API
-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,
-    const char *txt_rec, void *context) {
-  VALUE service;
-  /* other parameters are undefined if errorCode != 0 */
-  dnssd_check_error_code(e);
-  service = (VALUE)context;
-  dnssd_callback(service,
-      reply_from_resolve(service, flags, interface_index, fullname,
-        host_target, opaqueport, txt_len, txt_rec));
-}
+/* Binding to DNSServiceResolve
+ */
 
 static VALUE
-sd_resolve(int argc, VALUE *argv, VALUE service) {
-  VALUE name, type, domain, tmp_flags, interface;
-
-  const char *name_str, *type_str, *domain_str;
+dnssd_service_resolve(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
+    VALUE _flags, VALUE _interface) {
+  const char *name, *type, *domain;
   DNSServiceFlags flags = 0;
-  uint32_t interface_index = 0;
+  uint32_t interface = 0;
 
-  DNSServiceErrorType err;
+  DNSServiceErrorType e;
   DNSServiceRef *client;
 
-  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 = StringValueCStr(_name);
+  type = StringValueCStr(_type);
+  domain = StringValueCStr(_domain);
 
-  /* optional parameters */
-  if (!NIL_P(tmp_flags))
-    flags = dnssd_to_flags(tmp_flags);
+  if (!NIL_P(_flags))
+    flags = NUM2ULONG(_flags);
 
-  if (!NIL_P(interface))
-    interface_index = dnssd_get_interface_index(interface);
+  if (!NIL_P(_interface))
+    interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(service, client);
-  err = DNSServiceResolve(client, flags, interface_index, name_str, type_str,
-      domain_str, dnssd_resolve_reply, (void *)service);
-  dnssd_check_error_code(err);
-  return service;
-}
-
-/*
- * call-seq:
- *    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|
- *       p r
- *     end
- *   rescue TimeoutError
- *   end
- */
+  GetDNSSDService(self, client);
 
-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())));
-}
+  e = DNSServiceResolve(client, flags, interface, name, type, domain,
+      dnssd_service_resolve_reply, (void *)self);
 
-/*
- * call-seq:
- *    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 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
- */
+  dnssd_check_error_code(e);
 
-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())));
+  return self;
 }
 
 void
 Init_DNSSD_Service(void) {
   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_id_join        = rb_intern("join");
+  dnssd_id_push        = rb_intern("push");
 
-  dnssd_iv_block       = rb_intern("@block");
+  dnssd_iv_continue    = rb_intern("@continue");
   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_replies     = rb_intern("@replies");
   dnssd_iv_target      = rb_intern("@target");
   dnssd_iv_text_record = rb_intern("@text_record");
   dnssd_iv_thread      = rb_intern("@thread");
@@ -779,22 +465,25 @@ Init_DNSSD_Service(void) {
   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_const(cDNSSDService, "MAX_DOMAIN_NAME",
+      ULONG2NUM(kDNSServiceMaxDomainName));
+  rb_define_const(cDNSSDService, "MAX_SERVICE_NAME",
+      ULONG2NUM(kDNSServiceMaxServiceName));
+
+
+  rb_define_alloc_func(cDNSSDService, dnssd_service_s_allocate);
   rb_define_singleton_method(cDNSSDService, "fullname", dnssd_service_s_fullname, 3);
 
+  rb_define_method(cDNSSDService, "started?", dnssd_service_started_p, 0);
+
   rb_define_method(cDNSSDService, "stop", dnssd_service_stop, 0);
   rb_define_method(cDNSSDService, "stopped?", dnssd_service_stopped_p, 0);
 
-  rb_define_module_function(mDNSSD, "browse", dnssd_browse, -1);
-  rb_define_module_function(mDNSSD, "browse!", dnssd_browse_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_method(cDNSSDService, "_browse", dnssd_service_browse, 4);
+  rb_define_method(cDNSSDService, "_enumerate_domains", dnssd_service_enumerate_domains, 2);
+  rb_define_method(cDNSSDService, "_register", dnssd_service_register, 8);
+  rb_define_method(cDNSSDService, "_resolve", dnssd_service_resolve, 5);
 
-  rb_define_module_function(mDNSSD, "resolve", dnssd_resolve, -1);
-  rb_define_module_function(mDNSSD, "resolve!", dnssd_resolve_bang, -1);
+  rb_define_method(cDNSSDService, "_process", dnssd_service_process, 0);
 }