dnssd 1.2 → 1.3

data/ext/dnssd/record.c

@@ -0,0 +1,218 @@
+#include "dnssd.h"
+
+static VALUE cDNSSDRecord;
+
+static void
+dnssd_record_free(void *ptr) {
+  DNSRecordRef *record = (DNSRecordRef *)ptr;
+
+  /* TODO */
+
+  free(record);
+}
+
+static VALUE
+dnssd_record_s_allocate(VALUE klass) {
+  DNSRecordRef *record = ALLOC(DNSRecordRef);
+
+  *record = NULL;
+
+  return Data_Wrap_Struct(klass, 0, dnssd_record_free, record);
+}
+
+void
+Init_DNSSD_Record(void) {
+  VALUE mDNSSD = rb_define_module("DNSSD");
+
+  cDNSSDRecord = rb_define_class_under(mDNSSD, "Record", rb_cObject);
+
+  rb_define_alloc_func(cDNSSDRecord, dnssd_record_s_allocate);
+
+  /* Internet service class */
+  rb_define_const(cDNSSDRecord, "IN", UINT2NUM(kDNSServiceClass_IN));
+
+  /* Wildcard match. */
+  rb_define_const(cDNSSDRecord, "ANY", UINT2NUM(kDNSServiceType_ANY));
+
+  /* Host address. */
+  rb_define_const(cDNSSDRecord, "A", UINT2NUM(kDNSServiceType_A));
+
+  /* IPv6 Address (deprecated) */
+  rb_define_const(cDNSSDRecord, "A6", UINT2NUM(kDNSServiceType_A6));
+
+  /* IPv6 Address. */
+  rb_define_const(cDNSSDRecord, "AAAA", UINT2NUM(kDNSServiceType_AAAA));
+
+#ifdef kDNSServiceType_APL
+  /* Address Prefix List */
+  rb_define_const(cDNSSDRecord, "APL", UINT2NUM(kDNSServiceType_APL));
+#endif
+
+  /* AFS cell database. */
+  rb_define_const(cDNSSDRecord, "AFSDB", UINT2NUM(kDNSServiceType_AFSDB));
+
+  /* ATM Address */
+  rb_define_const(cDNSSDRecord, "ATMA", UINT2NUM(kDNSServiceType_ATMA));
+
+  /* Transfer zone of authority. */
+  rb_define_const(cDNSSDRecord, "AXFR", UINT2NUM(kDNSServiceType_AXFR));
+
+  /* Certification record */
+  rb_define_const(cDNSSDRecord, "CERT", UINT2NUM(kDNSServiceType_CERT));
+
+  /* Canonical name. */
+  rb_define_const(cDNSSDRecord, "CNAME", UINT2NUM(kDNSServiceType_CNAME));
+
+#ifdef kDNSServiceType_DHCID
+  /* DHCID */
+  rb_define_const(cDNSSDRecord, "DHCID", UINT2NUM(kDNSServiceType_DHCID));
+#endif
+
+  /* Non-terminal DNAME (for IPv6) */
+  rb_define_const(cDNSSDRecord, "DNAME", UINT2NUM(kDNSServiceType_DNAME));
+
+#ifdef kDNSServiceType_DNSKEY
+  /* DNSKEY */
+  rb_define_const(cDNSSDRecord, "DNSKEY", UINT2NUM(kDNSServiceType_DNSKEY));
+#endif
+
+#ifdef kDNSServiceType_DS
+  /* Delegation Signer */
+  rb_define_const(cDNSSDRecord, "DS", UINT2NUM(kDNSServiceType_DS));
+#endif
+
+  /* Endpoint identifier. */
+  rb_define_const(cDNSSDRecord, "EID", UINT2NUM(kDNSServiceType_EID));
+
+  /* Geographical position (withdrawn). */
+  rb_define_const(cDNSSDRecord, "GPOS", UINT2NUM(kDNSServiceType_GPOS));
+
+  /* Host information. */
+  rb_define_const(cDNSSDRecord, "HINFO", UINT2NUM(kDNSServiceType_HINFO));
+
+#ifdef kDNSServiceType_IPSECKEY
+  /* IPSECKEY */
+  rb_define_const(cDNSSDRecord, "IPSECKEY", UINT2NUM(kDNSServiceType_IPSECKEY));
+#endif
+
+  /* ISDN calling address. */
+  rb_define_const(cDNSSDRecord, "ISDN", UINT2NUM(kDNSServiceType_ISDN));
+
+  /* Incremental zone transfer. */
+  rb_define_const(cDNSSDRecord, "IXFR", UINT2NUM(kDNSServiceType_IXFR));
+
+  /* Security key. */
+  rb_define_const(cDNSSDRecord, "KEY", UINT2NUM(kDNSServiceType_KEY));
+
+  /* Key Exchange */
+  rb_define_const(cDNSSDRecord, "KX", UINT2NUM(kDNSServiceType_KX));
+
+  /* Location Information. */
+  rb_define_const(cDNSSDRecord, "LOC", UINT2NUM(kDNSServiceType_LOC));
+
+  /* Transfer mail agent records. */
+  rb_define_const(cDNSSDRecord, "MAILA", UINT2NUM(kDNSServiceType_MAILA));
+
+  /* Transfer mailbox records. */
+  rb_define_const(cDNSSDRecord, "MAILB", UINT2NUM(kDNSServiceType_MAILB));
+
+  /* Mailbox domain name. */
+  rb_define_const(cDNSSDRecord, "MB", UINT2NUM(kDNSServiceType_MB));
+
+  /* Mail destination. */
+  rb_define_const(cDNSSDRecord, "MD", UINT2NUM(kDNSServiceType_MD));
+
+  /* Mail forwarder. */
+  rb_define_const(cDNSSDRecord, "MF", UINT2NUM(kDNSServiceType_MF));
+
+  /* Mail group member. */
+  rb_define_const(cDNSSDRecord, "MG", UINT2NUM(kDNSServiceType_MG));
+
+  /* Mailbox information. */
+  rb_define_const(cDNSSDRecord, "MINFO", UINT2NUM(kDNSServiceType_MINFO));
+
+  /* Mail rename name. */
+  rb_define_const(cDNSSDRecord, "MR", UINT2NUM(kDNSServiceType_MR));
+
+  /* Mail routing information. */
+  rb_define_const(cDNSSDRecord, "MX", UINT2NUM(kDNSServiceType_MX));
+
+  /* Naming Authority PoinTeR */
+  rb_define_const(cDNSSDRecord, "NAPTR", UINT2NUM(kDNSServiceType_NAPTR));
+
+  /* Nimrod Locator. */
+  rb_define_const(cDNSSDRecord, "NIMLOC", UINT2NUM(kDNSServiceType_NIMLOC));
+
+  /* Authoritative server. */
+  rb_define_const(cDNSSDRecord, "NS", UINT2NUM(kDNSServiceType_NS));
+
+  /* NSAP address. */
+  rb_define_const(cDNSSDRecord, "NSAP", UINT2NUM(kDNSServiceType_NSAP));
+
+  /* Reverse NSAP lookup (deprecated). */
+  rb_define_const(cDNSSDRecord, "NSAP_PTR", UINT2NUM(kDNSServiceType_NSAP_PTR));
+
+#ifdef kDNSServiceType_NSEC
+  /* NSEC */
+  rb_define_const(cDNSSDRecord, "NSEC", UINT2NUM(kDNSServiceType_NSEC));
+#endif
+
+  /* Null resource record. */
+  rb_define_const(cDNSSDRecord, "NULL", UINT2NUM(kDNSServiceType_NULL));
+
+  /* Next domain (security). */
+  rb_define_const(cDNSSDRecord, "NXT", UINT2NUM(kDNSServiceType_NXT));
+
+  /* EDNS0 option (meta-RR) */
+  rb_define_const(cDNSSDRecord, "OPT", UINT2NUM(kDNSServiceType_OPT));
+
+  /* Domain name pointer. */
+  rb_define_const(cDNSSDRecord, "PTR", UINT2NUM(kDNSServiceType_PTR));
+
+  /* X.400 mail mapping. */
+  rb_define_const(cDNSSDRecord, "PX", UINT2NUM(kDNSServiceType_PX));
+
+  /* Responsible person. */
+  rb_define_const(cDNSSDRecord, "RP", UINT2NUM(kDNSServiceType_RP));
+
+#ifdef kDNSServiceType_RRSIG
+  /* RRSIG */
+  rb_define_const(cDNSSDRecord, "RRSIG", UINT2NUM(kDNSServiceType_RRSIG));
+#endif
+
+  /* Router. */
+  rb_define_const(cDNSSDRecord, "RT", UINT2NUM(kDNSServiceType_RT));
+
+  /* Security signature. */
+  rb_define_const(cDNSSDRecord, "SIG", UINT2NUM(kDNSServiceType_SIG));
+
+  /* Kitchen sink (experimental) */
+  rb_define_const(cDNSSDRecord, "SINK", UINT2NUM(kDNSServiceType_SINK));
+
+  /* Start of authority zone. */
+  rb_define_const(cDNSSDRecord, "SOA", UINT2NUM(kDNSServiceType_SOA));
+
+  /* Server Selection. */
+  rb_define_const(cDNSSDRecord, "SRV", UINT2NUM(kDNSServiceType_SRV));
+
+#ifdef kDNSServiceType_SSHFP
+  /* SSH Key Fingerprint */
+  rb_define_const(cDNSSDRecord, "SSHFP", UINT2NUM(kDNSServiceType_SSHFP));
+#endif
+
+  /* Transaction key */
+  rb_define_const(cDNSSDRecord, "TKEY", UINT2NUM(kDNSServiceType_TKEY));
+
+  /* Transaction signature. */
+  rb_define_const(cDNSSDRecord, "TSIG", UINT2NUM(kDNSServiceType_TSIG));
+
+  /* One or more text strings (NOT "zero or more..."). */
+  rb_define_const(cDNSSDRecord, "TXT", UINT2NUM(kDNSServiceType_TXT));
+
+  /* Well known service. */
+  rb_define_const(cDNSSDRecord, "WKS", UINT2NUM(kDNSServiceType_WKS));
+
+  /* X_25 calling address. */
+  rb_define_const(cDNSSDRecord, "X25", UINT2NUM(kDNSServiceType_X25));
+}
+

data/ext/dnssd/service.c

@@ -1,35 +1,36 @@
 #include "dnssd.h"
 
-#ifndef DNSSD_API
-  /* define as nothing if not defined in Apple's "dns_sd.h" header  */
-  #define DNSSD_API
-#endif
-
-static VALUE cDNSSDReply;
+static VALUE mDNSSD;
+static VALUE cDNSSDFlags;
+static VALUE cDNSSDRecord;
+static VALUE cDNSSDReplyAddrInfo;
+static VALUE cDNSSDReplyBrowse;
+static VALUE cDNSSDReplyDomain;
+static VALUE cDNSSDReplyQueryRecord;
+static VALUE cDNSSDReplyRegister;
+static VALUE cDNSSDReplyResolve;
 static VALUE cDNSSDService;
 static VALUE cDNSSDTextRecord;
+static VALUE rb_cSocket;
 
 static ID dnssd_id_join;
 static ID dnssd_id_push;
 
 static ID dnssd_iv_continue;
-static ID dnssd_iv_domain;
-static ID dnssd_iv_interface;
-static ID dnssd_iv_port;
+static ID dnssd_iv_records;
 static ID dnssd_iv_replies;
-static ID dnssd_iv_target;
-static ID dnssd_iv_text_record;
+static ID dnssd_iv_service;
 static ID dnssd_iv_thread;
+static ID dnssd_iv_type;
 
-/* HACK why is this a macro */
-#define GetDNSSDService(obj, var) \
+#define get(klass, obj, type, var) \
   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);\
+    if (rb_obj_is_kind_of(obj, klass) != Qtrue)\
+    rb_raise(rb_eTypeError,\
+        "wrong argument type %s",\
+        rb_class2name(CLASS_OF(obj)));\
+    Data_Get_Struct(obj, type, var);\
   } while (0)
 
 static void
@@ -71,29 +72,9 @@ 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
+ *   DNSSD::Service.fullname(name, type, domain)
  *
  * Concatenate a three-part domain name like DNSSD::Reply#fullname into a
  * properly-escaped full domain name.
@@ -119,6 +100,29 @@ dnssd_service_s_fullname(VALUE klass, VALUE name, VALUE type, VALUE domain) {
       StringValueCStr(domain));
 }
 
+#ifdef HAVE_DNSSERVICEGETPROPERTY
+/*
+ * call-seq:
+ *   service.get_property(property)
+ *
+ * Binding for DNSServiceGetProperty.  The only property currently supported in
+ * DNSSD is DaemonVersion
+ */
+static VALUE
+dnssd_service_s_get_property(VALUE klass, VALUE property) {
+  uint32_t result = 0;
+  uint32_t size = sizeof(result);
+  DNSServiceErrorType e;
+
+  e = DNSServiceGetProperty(StringValueCStr(property), (void *)&result, &size);
+
+  dnssd_check_error_code(e);
+
+  /* as of this writing only a uint32_t will be returned */
+  return ULONG2NUM(result);
+}
+#endif
+
 static VALUE
 dnssd_service_s_allocate(VALUE klass) {
   DNSServiceRef *client = ALLOC(DNSServiceRef);
@@ -128,32 +132,14 @@ dnssd_service_s_allocate(VALUE klass) {
   return Data_Wrap_Struct(klass, 0, dnssd_service_free, client);
 }
 
-/*
- * call-seq:
- *    service.started? => true or false
- *
- * Returns true if the service has been started.
+/* Returns true if the service has been stopped.
  */
 
 static VALUE
-dnssd_service_started_p(VALUE service) {
-  DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
-  if (client)
-    return (*client) == NULL ? Qfalse : Qtrue;
-
-  return Qtrue;
-}
-
-/*
- * call-seq:
- *    service.stopped? => true or false
- *
- * Returns true if the service has been stopped.
- */
+dnssd_service_stopped_p(VALUE self) {
+  DNSServiceRef *client;
 
-static VALUE
-dnssd_service_stopped_p(VALUE service) {
-  DNSServiceRef *client = (DNSServiceRef*)RDATA(service)->data;
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   if (client)
     return (*client) == NULL ? Qtrue : Qfalse;
@@ -161,11 +147,7 @@ dnssd_service_stopped_p(VALUE service) {
   return Qtrue;
 }
 
-/*
- * call-seq:
- *    service.stop => service
- *
- * Stops the service, closing the underlying socket and killing the underlying
+/* Stops the service, closing the underlying socket and killing the underlying
  * thread.
  *
  * It is good practice to all stop running services before exit.
@@ -180,9 +162,10 @@ dnssd_service_stopped_p(VALUE service) {
 static VALUE
 dnssd_service_stop(VALUE self) {
   VALUE thread;
-  DNSServiceRef *client = (DNSServiceRef*)RDATA(self)->data;
+  DNSServiceRef *client;
+
+  get(cDNSSDService, self, DNSServiceRef, client);
 
-  /* set to null right away for a bit more thread safety */
   RDATA(self)->data = NULL;
 
   if (client == NULL)
@@ -198,14 +181,25 @@ dnssd_service_stop(VALUE self) {
 
   dnssd_service_free_client(client);
 
+  rb_ivar_set(self, dnssd_iv_type, Qnil);
+
   return self;
 }
 
+/* Binding to DNSServiceProcessResult
+ *
+ * When run with a single thread _process will block.
+ *
+ * _process works intelligently with threads.  If a service is waiting on data
+ * from the daemon in a thread you can force _process to abort by setting
+ * @continue to false and running the thread.
+ */
+
 static VALUE
 dnssd_service_process(VALUE self) {
   DNSServiceRef *client;
 
-  GetDNSSDService(self, client);
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   if (client == NULL) {
     /* looks like this thread has already been stopped */
@@ -223,30 +217,80 @@ dnssd_service_process(VALUE self) {
   return self;
 }
 
+/* call-seq:
+ *   service._add_record(flags, type, data, ttl)
+ *
+ * Binding to DNSServiceAddRecord
+ */
+
+static VALUE
+dnssd_service_add_record(VALUE self, VALUE _flags, VALUE _rrtype, VALUE _rdata,
+    VALUE _ttl) {
+  VALUE _record = Qnil;
+  DNSServiceRef *client;
+  DNSRecordRef *record;
+  DNSServiceFlags flags;
+  DNSServiceErrorType e;
+  uint16_t rrtype;
+  uint16_t rdlen;
+  const void *rdata;
+  uint32_t ttl;
+
+  _rdata = rb_str_to_str(_rdata);
+  flags = (DNSServiceFlags)NUM2ULONG(_flags);
+  rrtype = NUM2UINT(_rrtype);
+  rdlen = RSTRING_LEN(_rdata);
+  rdata = (void *)RSTRING_PTR(_rdata);
+  ttl = NUM2ULONG(_ttl);
+
+  get(cDNSSDService, self, DNSServiceRef, client);
+
+  _record = rb_class_new_instance(0, NULL, cDNSSDRecord);
+
+  get(cDNSSDRecord, _record, DNSRecordRef, record);
+
+  e = DNSServiceAddRecord(*client, record, flags, rrtype, rdlen, rdata, ttl);
+
+  dnssd_check_error_code(e);
+
+  /* record will become invalid when this service is destroyed */
+  rb_ivar_set(_record, dnssd_iv_service, self);
+  rb_ary_push(rb_ivar_get(self, dnssd_iv_records), _record);
+
+  return _record;
+}
+
 static void DNSSD_API
 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;
+  VALUE service, reply, argv[6];
 
   dnssd_check_error_code(e);
 
   service = (VALUE)context;
 
-  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));
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = ULONG2NUM(interface);
+  argv[3] = rb_str_new2(name);
+  argv[4] = rb_str_new2(type);
+  argv[5] = rb_str_new2(domain);
+
+  reply = rb_class_new_instance(6, argv, cDNSSDReplyBrowse);
 
   dnssd_service_callback(service, reply);
 }
 
-/* Binding to DNSServiceBrowse
+/* call-seq:
+ *   service._browse(flags, interface, type, domain)
+ *
+ * Binding to DNSServiceBrowse
  */
 
 static VALUE
-dnssd_service_browse(VALUE self, VALUE _type, VALUE _domain, VALUE _flags,
-    VALUE _interface) {
+dnssd_service_browse(VALUE self, VALUE _flags, VALUE _interface, VALUE _type,
+    VALUE _domain) {
   const char *type;
   const char *domain = NULL;
   DNSServiceFlags flags = 0;
@@ -266,7 +310,7 @@ dnssd_service_browse(VALUE self, VALUE _type, VALUE _domain, VALUE _flags,
   if (!NIL_P(_interface))
     interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(self, client);
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   e = DNSServiceBrowse(client, flags, interface, type, domain,
       dnssd_service_browse_reply, (void *)self);
@@ -280,20 +324,26 @@ static void DNSSD_API
 dnssd_service_enumerate_domains_reply(DNSServiceRef client,
     DNSServiceFlags flags, uint32_t interface, DNSServiceErrorType e,
     const char *domain, void *context) {
-  VALUE service, reply;
+  VALUE service, reply, argv[4];
 
   dnssd_check_error_code(e);
 
   service = (VALUE)context;
 
-  reply = reply_new(service, flags);
-  reply_set_interface(reply, interface);
-  rb_ivar_set(reply, dnssd_iv_domain, rb_str_new2(domain));
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = ULONG2NUM(interface);
+  argv[3] = rb_str_new2(domain);
+
+  reply = rb_class_new_instance(4, argv, cDNSSDReplyDomain);
 
   dnssd_service_callback(service, reply);
 }
 
-/* Binding to DNSServiceEnumerateDomains
+/* call-seq:
+ *   service._enumerate_domains(flags, interface)
+ *
+ * Binding to DNSServiceEnumerateDomains
  */
 
 static VALUE
@@ -310,7 +360,7 @@ dnssd_service_enumerate_domains(VALUE self, VALUE _flags, VALUE _interface) {
   if (!NIL_P(_interface))
     interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(self, client);
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   e = DNSServiceEnumerateDomains(client, flags, interface,
       dnssd_service_enumerate_domains_reply, (void *)self);
@@ -320,36 +370,162 @@ dnssd_service_enumerate_domains(VALUE self, VALUE _flags, VALUE _interface) {
   return self;
 }
 
+#ifdef HAVE_DNSSERVICEGETADDRINFO
+static void DNSSD_API
+dnssd_service_getaddrinfo_reply(DNSServiceRef client, DNSServiceFlags flags,
+    uint32_t interface, DNSServiceErrorType e, const char *host,
+    const struct sockaddr *address, uint32_t ttl, void *context) {
+  VALUE service, reply, argv[6];
+
+  dnssd_check_error_code(e);
+
+  service = (VALUE)context;
+
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = ULONG2NUM(interface);
+  argv[3] = rb_str_new2(host);
+  argv[4] = rb_str_new((char *)address, SIN_LEN((struct sockaddr_in*)address));
+  argv[5] = ULONG2NUM(ttl);
+
+  reply = rb_class_new_instance(6, argv, cDNSSDReplyAddrInfo);
+
+  dnssd_service_callback(service, reply);
+}
+
+/* call-seq:
+ *   service._getaddrinfo(flags, interface, host, protocol)
+ *
+ * Binding to DNSServiceGetAddrInfo
+ */
+
+static VALUE
+dnssd_service_getaddrinfo(VALUE self, VALUE _flags, VALUE _interface,
+    VALUE _protocol, VALUE _host) {
+  DNSServiceFlags flags = 0;
+  uint32_t interface = 0;
+  DNSServiceProtocol protocol = 0;
+  const char *host;
+
+  DNSServiceErrorType e;
+  DNSServiceRef *client;
+
+  host = StringValueCStr(_host);
+
+  protocol = (DNSServiceProtocol)NUM2ULONG(_protocol);
+
+  if (!NIL_P(_flags))
+    flags = (DNSServiceFlags)NUM2ULONG(_flags);
+
+  if (!NIL_P(_interface))
+    interface = NUM2ULONG(_interface);
+
+  get(cDNSSDService, self, DNSServiceRef, client);
+
+  e = DNSServiceGetAddrInfo(client, flags, interface, protocol, host,
+      dnssd_service_getaddrinfo_reply, (void *)self);
+
+  dnssd_check_error_code(e);
+
+  return self;
+}
+#endif
+
+static void DNSSD_API
+dnssd_service_query_record_reply(DNSServiceRef client, DNSServiceFlags flags,
+    uint32_t interface, DNSServiceErrorType e, const char *fullname,
+    uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata,
+    uint32_t ttl, void *context) {
+  VALUE service, reply, argv[8];
+
+  dnssd_check_error_code(e);
+
+  service = (VALUE)context;
+
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = ULONG2NUM(interface);
+  argv[3] = rb_str_new2(fullname);
+  argv[4] = UINT2NUM(rrtype);
+  argv[5] = UINT2NUM(rrclass);
+  argv[6] = rb_str_new((char *)rdata, rdlen);
+  argv[7] = ULONG2NUM(ttl);
+
+  reply = rb_class_new_instance(8, argv, cDNSSDReplyQueryRecord);
+
+  dnssd_service_callback(service, reply);
+}
+
+/* call-seq:
+ *   service._query_record(flags, interface, fullname, record_type, record_class)
+ *
+ * Binding to DNSServiceQueryRecord
+ */
+
+static VALUE
+dnssd_service_query_record(VALUE self, VALUE _flags, VALUE _interface,
+    VALUE _fullname, VALUE _rrtype, VALUE _rrclass) {
+  DNSServiceRef *client;
+  DNSServiceFlags flags;
+  DNSServiceErrorType e;
+  char *fullname;
+  uint32_t interface;
+  uint16_t rrtype;
+  uint16_t rrclass;
+
+  flags = (DNSServiceFlags)NUM2ULONG(_flags);
+  interface = NUM2ULONG(_interface);
+  fullname = StringValueCStr(_fullname);
+  rrtype = NUM2UINT(_rrtype);
+  rrclass = NUM2UINT(_rrclass);
+
+  get(cDNSSDService, self, DNSServiceRef, client);
+
+  e = DNSServiceQueryRecord(client, flags, interface, fullname, rrtype,
+      rrclass, dnssd_service_query_record_reply, (void *)self);
+
+  dnssd_check_error_code(e);
+
+  return self;
+}
+
 static void DNSSD_API
 dnssd_service_register_reply(DNSServiceRef client, DNSServiceFlags flags,
     DNSServiceErrorType e, const char *name, const char *type,
     const char *domain, void *context) {
-  VALUE service, reply;
+  VALUE service, reply, argv[5];
 
   dnssd_check_error_code(e);
 
   service = (VALUE)context;
 
-  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));
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = rb_str_new2(name);
+  argv[3] = rb_str_new2(type);
+  argv[4] = rb_str_new2(domain);
+
+  reply = rb_class_new_instance(5, argv, cDNSSDReplyRegister);
 
   dnssd_service_callback(service, reply);
 }
 
-/* Binding to DNSServiceRegister
+/* call-seq:
+ *   service._register(flags, interface, name, type, domain, host, port, text_record)
+ *
+ * Binding to DNSServiceRegister
  */
 
 static VALUE
-dnssd_service_register(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
-    VALUE _host, VALUE _port, VALUE _text_record, VALUE _flags,
-    VALUE _interface) {
+dnssd_service_register(VALUE self, VALUE _flags, VALUE _interface, VALUE _name,
+    VALUE _type, VALUE _domain, VALUE _host, VALUE _port, VALUE _text_record) {
   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 = 0;
+  DNSServiceRegisterReply callback = NULL;
 
   DNSServiceErrorType e;
   DNSServiceRef *client;
@@ -376,11 +552,13 @@ dnssd_service_register(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
   if (!NIL_P(_interface))
     interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(self, client);
+  if (rb_block_given_p())
+    callback = dnssd_service_register_reply;
+
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   e = DNSServiceRegister(client, flags, interface, name, type,
-      domain, host, port, txt_len, txt_rec, dnssd_service_register_reply,
-      (void*)self);
+      domain, host, port, txt_len, txt_rec, callback, (void*)self);
 
   dnssd_check_error_code(e);
 
@@ -392,32 +570,34 @@ 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;
+  VALUE service, reply, argv[7];
 
   dnssd_check_error_code(e);
 
   service = (VALUE)context;
 
-  reply = reply_new(service, flags);
+  argv[0] = service;
+  argv[1] = ULONG2NUM(flags);
+  argv[2] = ULONG2NUM(interface);
+  argv[3] = rb_str_new2(name);
+  argv[4] = rb_str_new2(target);
+  argv[5] = UINT2NUM(ntohs(port));
+  argv[6] = rb_str_new((char *)txt_rec, txt_len);
 
-  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)));
-
-  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);
+  reply = rb_class_new_instance(7, argv, cDNSSDReplyResolve);
 
   dnssd_service_callback(service, reply);
 }
 
-/* Binding to DNSServiceResolve
+/* call-seq:
+ *   service._resolve(flags, interface, name, type, domain)
+ *
+ * Binding to DNSServiceResolve
  */
 
 static VALUE
-dnssd_service_resolve(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
-    VALUE _flags, VALUE _interface) {
+dnssd_service_resolve(VALUE self, VALUE _flags, VALUE _interface, VALUE _name,
+    VALUE _type, VALUE _domain) {
   const char *name, *type, *domain;
   DNSServiceFlags flags = 0;
   uint32_t interface = 0;
@@ -435,7 +615,7 @@ dnssd_service_resolve(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
   if (!NIL_P(_interface))
     interface = NUM2ULONG(_interface);
 
-  GetDNSSDService(self, client);
+  get(cDNSSDService, self, DNSServiceRef, client);
 
   e = DNSServiceResolve(client, flags, interface, name, type, domain,
       dnssd_service_resolve_reply, (void *)self);
@@ -447,40 +627,80 @@ dnssd_service_resolve(VALUE self, VALUE _name, VALUE _type, VALUE _domain,
 
 void
 Init_DNSSD_Service(void) {
-  VALUE mDNSSD = rb_define_module("DNSSD");
+  mDNSSD = rb_define_module("DNSSD");
 
-  dnssd_id_join        = rb_intern("join");
-  dnssd_id_push        = rb_intern("push");
+  dnssd_id_join = rb_intern("join");
+  dnssd_id_push = rb_intern("push");
 
   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_records     = rb_intern("@records");
   dnssd_iv_replies     = rb_intern("@replies");
-  dnssd_iv_target      = rb_intern("@target");
-  dnssd_iv_text_record = rb_intern("@text_record");
+  dnssd_iv_service     = rb_intern("@service");
   dnssd_iv_thread      = rb_intern("@thread");
+  dnssd_iv_type        = rb_intern("@type");
 
-  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);
+  cDNSSDFlags      = rb_define_class_under(mDNSSD, "Flags", rb_cObject);
+  cDNSSDRecord     = rb_define_class_under(mDNSSD, "Record", rb_cObject);
+  cDNSSDService    = rb_define_class_under(mDNSSD, "Service", rb_cObject);
+  cDNSSDTextRecord = rb_path2class("DNSSD::TextRecord");
 
+  cDNSSDReplyAddrInfo    = rb_path2class("DNSSD::Reply::AddrInfo");
+  cDNSSDReplyBrowse      = rb_path2class("DNSSD::Reply::Browse");
+  cDNSSDReplyDomain      = rb_path2class("DNSSD::Reply::Domain");
+  cDNSSDReplyQueryRecord = rb_path2class("DNSSD::Reply::QueryRecord");
+  cDNSSDReplyRegister    = rb_path2class("DNSSD::Reply::Register");
+  cDNSSDReplyResolve     = rb_path2class("DNSSD::Reply::Resolve");
+
+  rb_cSocket = rb_path2class("Socket");
+
+
+  /* Maximum length for a domain name */
   rb_define_const(cDNSSDService, "MAX_DOMAIN_NAME",
       ULONG2NUM(kDNSServiceMaxDomainName));
+
+  /* Maximum length for a service name */
   rb_define_const(cDNSSDService, "MAX_SERVICE_NAME",
       ULONG2NUM(kDNSServiceMaxServiceName));
 
+#ifdef kDNSServiceProperty_DaemonVersion
+  /* DaemonVersion property value */
+  rb_define_const(cDNSSDService, "DaemonVersion",
+      rb_str_new2(kDNSServiceProperty_DaemonVersion));
+#endif
+
+#ifdef HAVE_DNSSERVICEGETPROPERTY
+  /* IPv4 protocol for #getaddrinfo */
+  rb_define_const(cDNSSDService, "IPv4", ULONG2NUM(kDNSServiceProtocol_IPv4));
+
+  /* IPv6 protocol for #getaddrinfo */
+  rb_define_const(cDNSSDService, "IPv6", ULONG2NUM(kDNSServiceProtocol_IPv6));
+
+  /* HACK the below are only used by NAT, fix with proper HAVE_ */
+
+  /* TCP protocol for creating NAT port mappings */
+  rb_define_const(cDNSSDService, "TCP", ULONG2NUM(kDNSServiceProtocol_TCP));
+
+  /* UDP protocol for creating NAT port mappings */
+  rb_define_const(cDNSSDService, "UDP", ULONG2NUM(kDNSServiceProtocol_UDP));
+#endif
 
   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);
+#ifdef HAVE_DNSSERVICEGETPROPERTY
+  rb_define_singleton_method(cDNSSDService, "get_property", dnssd_service_s_get_property, 1);
+#endif
 
   rb_define_method(cDNSSDService, "stop", dnssd_service_stop, 0);
   rb_define_method(cDNSSDService, "stopped?", dnssd_service_stopped_p, 0);
 
+  rb_define_method(cDNSSDService, "_add_record", dnssd_service_add_record, 4);
   rb_define_method(cDNSSDService, "_browse", dnssd_service_browse, 4);
   rb_define_method(cDNSSDService, "_enumerate_domains", dnssd_service_enumerate_domains, 2);
+#ifdef HAVE_DNSSERVICEGETADDRINFO
+  rb_define_method(cDNSSDService, "_getaddrinfo", dnssd_service_getaddrinfo, 4);
+#endif
+  rb_define_method(cDNSSDService, "_query_record", dnssd_service_query_record, 5);
   rb_define_method(cDNSSDService, "_register", dnssd_service_register, 8);
   rb_define_method(cDNSSDService, "_resolve", dnssd_service_resolve, 5);