dnssd 0.7.1 → 1.0

data/ext/dnssd/dnssd_structs.c

@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2004 Chad Fowler, Charles Mills, Rich Kilmer
+ * Licensed under the same terms as Ruby.
+ * This software has absolutely no warranty.
+ */
+#include "dnssd.h"
+
+static VALUE cDNSSDFlags;
+static VALUE cDNSSDReply;
+
+static ID dnssd_iv_flags;
+static ID dnssd_iv_interface;
+static ID dnssd_iv_fullname;
+static ID dnssd_iv_target;
+static ID dnssd_iv_port;
+static ID dnssd_iv_text_record;
+static ID dnssd_iv_name;
+static ID dnssd_iv_type;
+static ID dnssd_iv_domain;
+static ID dnssd_iv_service;
+
+/* dns sd flags, flag ID's, flag names */
+#define DNSSD_MAX_FLAGS 9
+
+static const DNSServiceFlags dnssd_flag[DNSSD_MAX_FLAGS] = {
+  kDNSServiceFlagsMoreComing,
+
+  kDNSServiceFlagsAdd,
+  kDNSServiceFlagsDefault,
+
+  kDNSServiceFlagsNoAutoRename,
+
+  kDNSServiceFlagsShared,
+  kDNSServiceFlagsUnique,
+
+  kDNSServiceFlagsBrowseDomains,
+  kDNSServiceFlagsRegistrationDomains,
+
+  kDNSServiceFlagsLongLivedQuery
+};
+
+static const char *dnssd_flag_name[DNSSD_MAX_FLAGS] = {
+  "more_coming",
+  "add",
+  "default",
+  "no_auto_rename",
+  "shared",
+  "unique",
+  "browse_domains",
+  "registration_domains",
+  "long_lived_query"
+};
+
+static VALUE
+dnssd_struct_inspect(VALUE self, VALUE data) {
+  VALUE buf = rb_str_buf_new(20 + RSTRING_LEN(data));
+  rb_str_buf_cat2(buf, "#<");
+  rb_str_buf_cat2(buf, rb_obj_classname(self));
+  if (RSTRING_LEN(data) > 0) {
+    rb_str_buf_cat2(buf, " ");
+    rb_str_buf_append(buf, data);
+  }
+  rb_str_buf_cat2(buf, ">");
+  return buf;
+}
+
+VALUE
+dnssd_create_fullname(const char *name, const char *regtype, const char *domain, int err_flag) {
+  char buffer[kDNSServiceMaxDomainName];
+  if ( DNSServiceConstructFullName(buffer, name, regtype, domain) ) {
+    static const char msg[] = "could not construct full service name";
+    if (err_flag) {
+      rb_raise(rb_eArgError, msg);
+    } else {
+      VALUE buf;
+      rb_warn(msg);
+      /* just join them all */
+      buf = rb_str_buf_new2(name);
+      rb_str_buf_cat2(buf, regtype);
+      rb_str_buf_cat2(buf, domain);
+      return buf;
+    }
+  }
+  buffer[kDNSServiceMaxDomainName - 1] = '\000'; /* just in case */
+  return rb_str_new2(buffer);
+}
+
+VALUE
+dnssd_split_fullname(VALUE fullname) {
+  static const char re[] = "(?:\\\\.|[^\\.])+\\.";
+  VALUE regexp = rb_reg_new(re, sizeof(re)-1, 0);
+  return rb_funcall2(fullname, rb_intern("scan"), 1, &regexp);
+}
+
+#if 0
+  static void
+quote_and_append(VALUE buf, VALUE str)
+{
+  const char *ptr;
+  long i, last_mark, len;
+
+  ptr = RSTRING_PTR(str);
+  len = RSTRING_LEN(str);
+  last_mark = 0;
+  /* last character should be '.' */
+  for (i=0; i<len-1; i++) {
+    if (ptr[i] == '.') {
+      /* write 1 extra character and replace it with '\\' */
+      rb_str_buf_cat(buf, ptr + last_mark, i + 1 - last_mark);
+      RSTRING_PTR(buf)[i] = '\\';
+      last_mark = i;
+    }
+  }
+  rb_str_buf_cat(buf, ptr + last_mark, len - last_mark);
+}
+#endif
+
+static VALUE
+dnssd_join_names(int argc, VALUE *argv) {
+  int i;
+  VALUE buf;
+  long len = 0;
+
+  for (i=0; i<argc; i++) {
+    argv[i] = StringValue(argv[i]);
+    len += RSTRING_LEN(argv[i]);
+  }
+  buf = rb_str_buf_new(len);
+  for (i=0; i<argc; i++) {
+    rb_str_buf_append(buf, argv[i]);
+  }
+  return buf;
+}
+
+static void
+reply_add_names(VALUE self, const char *name,
+    const char *regtype, const char *domain) {
+  rb_ivar_set(self, dnssd_iv_name, rb_str_new2(name));
+  rb_ivar_set(self, dnssd_iv_type, rb_str_new2(regtype));
+  rb_ivar_set(self, dnssd_iv_domain, rb_str_new2(domain));
+  rb_ivar_set(self, dnssd_iv_fullname, dnssd_create_fullname(name, regtype, domain, 0));
+}
+
+static void
+reply_add_names2(VALUE self, const char *fullname) {
+  VALUE fn = rb_str_new2(fullname);
+  VALUE ary = dnssd_split_fullname(fn);
+  VALUE type[2] =  { rb_ary_entry(ary, 1), rb_ary_entry(ary, 2) };
+
+  rb_ivar_set(self, dnssd_iv_name, rb_ary_entry(ary, 0));
+  rb_ivar_set(self, dnssd_iv_type, dnssd_join_names(2, type));
+  rb_ivar_set(self, dnssd_iv_domain, rb_ary_entry(ary, -1));
+  rb_ivar_set(self, dnssd_iv_fullname, fn);
+}
+
+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 void
+reply_set_tr(VALUE self, uint16_t txt_len, const char *txt_rec) {
+  rb_ivar_set(self, dnssd_iv_text_record, dnssd_tr_new((long)txt_len, txt_rec));
+}
+
+static VALUE
+reply_new(VALUE service, DNSServiceFlags flags) {
+  VALUE self = rb_obj_alloc(cDNSSDReply);
+  rb_ivar_set(self, dnssd_iv_service, service);
+  rb_ivar_set(self, dnssd_iv_flags,
+              rb_funcall(cDNSSDFlags, rb_intern("new"), 1, flags));
+  return self;
+}
+
+VALUE
+dnssd_domain_enum_new(VALUE service, DNSServiceFlags flags,
+    uint32_t interface, const char *domain) {
+  VALUE d, self = reply_new(service, flags);
+  reply_set_interface(self, interface);
+  d = rb_str_new2(domain);
+  rb_ivar_set(self, dnssd_iv_domain, d);
+  rb_ivar_set(self, dnssd_iv_fullname, d);
+  return self;
+}
+
+VALUE
+dnssd_browse_new(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);
+  reply_add_names(self, name, regtype, domain);
+  return self;
+}
+
+#if 0
+  static VALUE
+dnssd_gethostname(void)
+{
+#if HAVE_GETHOSTNAME
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 256
+#endif
+  char buffer[MAXHOSTNAMELEN + 1];
+  if (gethostname(buffer, MAXHOSTNAMELEN))
+    return Qnil;
+  buffer[MAXHOSTNAMELEN] = '\000';
+  return rb_str_new2(buffer);
+#else
+  return Qnil;
+#endif
+}
+#endif
+
+VALUE
+dnssd_register_new(VALUE service, DNSServiceFlags flags, const char *name,
+    const char *regtype, const char *domain) {
+  VALUE self = reply_new(service, flags);
+  reply_add_names(self, name, regtype, 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;
+}
+
+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) {
+  uint16_t port = ntohs(opaqueport);
+  VALUE self = reply_new(service, flags);
+  reply_set_interface(self, interface);
+  reply_add_names2(self, fullname);
+  rb_ivar_set(self, dnssd_iv_target, rb_str_new2(host_target));
+  rb_ivar_set(self, dnssd_iv_port, UINT2NUM(port));
+  reply_set_tr(self, txt_len, txt_rec);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    reply.inspect   => string
+ *
+ */
+static VALUE
+reply_inspect(VALUE self) {
+  VALUE fullname = rb_ivar_get(self, dnssd_iv_fullname);
+  return dnssd_struct_inspect(self, StringValue(fullname));
+}
+
+/*
+ * call-seq:
+ *    DNSSD::Reply.new() => raises a RuntimeError
+ *
+ */
+static VALUE
+reply_initialize(int argc, VALUE *argv, VALUE reply) {
+  dnssd_instantiation_error(rb_obj_classname(reply));
+  return Qnil;
+}
+
+void
+Init_DNSSD_Replies(void) {
+  int i;
+  VALUE flags_hash;
+  /* hack so rdoc documents the project correctly */
+#ifdef mDNSSD_RDOC_HACK
+  mDNSSD = rb_define_module("DNSSD");
+#endif
+
+  dnssd_iv_flags = rb_intern("@flags");
+  dnssd_iv_interface = rb_intern("@interface");
+  dnssd_iv_fullname = rb_intern("@fullname");
+  dnssd_iv_target = rb_intern("@target");
+  dnssd_iv_port = rb_intern("@port");
+  dnssd_iv_text_record = rb_intern("@text_record");
+  dnssd_iv_name = rb_intern("@name");
+  dnssd_iv_type = rb_intern("@type");
+  dnssd_iv_domain = rb_intern("@domain");
+  dnssd_iv_service = rb_intern("@service");
+
+  cDNSSDFlags = rb_define_class_under(mDNSSD, "Flags", rb_cObject);
+
+  cDNSSDReply = rb_define_class_under(mDNSSD, "Reply", rb_cObject);
+  /* DNSSD::Reply objects can only be instantiated by
+   * DNSSD.browse(), DNSSD.register(), DNSSD.resolve(), DNSSD.enumerate_domains(). */
+  rb_define_method(cDNSSDReply, "initialize", reply_initialize, -1);
+  /* The service associated with the reply.  See DNSSD::Service for more information. */
+  rb_define_attr(cDNSSDReply, "service", 1, 0);
+  /* Flags describing the reply.  See DNSSD::Flags for more information. */
+  rb_define_attr(cDNSSDReply, "flags", 1, 0);
+  /* The service name. (Not used by DNSSD.enumerate_domains().) */
+  rb_define_attr(cDNSSDReply, "name", 1, 0);
+  /* The service type. (Not used by DNSSD.enumerate_domains().) */
+  rb_define_attr(cDNSSDReply, "type", 1, 0);
+  /* The service domain. */
+  rb_define_attr(cDNSSDReply, "domain", 1, 0);
+  /* The interface on which the service is available. (Used only by DNSSSD.resolve().) */
+  rb_define_attr(cDNSSDReply, "interface", 1, 0);
+  /* The full service domain name, in the form "<servicename>.<protocol>.<domain>.".
+   * (Any literal dots (".") are escaped with a backslash ("\."), and literal
+   * backslashes are escaped with a second backslash ("\\"), e.g. a web server
+   * named "Dr. Pepper" would have the fullname  "Dr\.\032Pepper._http._tcp.local.".)
+   * See DNSSD::Service.fullname() for more information. */
+  rb_define_attr(cDNSSDReply, "fullname", 1, 0);
+  /* The service's primary text record, see DNSSD::TextRecord for more information. */
+  rb_define_attr(cDNSSDReply, "text_record", 1, 0);
+  /* The target hostname of the machine providing the service.
+   * This name can be passed to functions like Socket.gethostbyname()
+   * to identify the host's IP address. */
+  rb_define_attr(cDNSSDReply, "target", 1, 0);
+  /* The port on which connections are accepted for this service. */
+  rb_define_attr(cDNSSDReply, "port", 1, 0);
+
+  rb_define_method(cDNSSDReply, "inspect", reply_inspect, 0);
+
+  /* flag constants */
+#if DNSSD_MAX_FLAGS != 9
+#error The code below needs to be updated.
+#endif
+  /* MoreComing indicates that at least one more result is queued and will be delivered following immediately after this one.
+   * Applications should not update their UI to display browse
+   * results when the MoreComing flag is set, because this would
+   * result in a great deal of ugly flickering on the screen.
+   * Applications should instead wait until until MoreComing is not set,
+   * and then update their UI.
+   * When MoreComing is not set, that doesn't mean there will be no more
+   * answers EVER, just that there are no more answers immediately
+   * available right now at this instant. If more answers become available
+   * in the future they will be delivered as usual.
+   */
+  rb_define_const(cDNSSDFlags, "MoreComing", ULONG2NUM(kDNSServiceFlagsMoreComing));
+
+
+  /* Flags for domain enumeration and DNSSD.browse() reply callbacks.
+   * DNSSD::Flags::Default applies only to enumeration and is only valid in
+   * conjuction with DNSSD::Flags::Add.  An enumeration callback with the DNSSD::Flags::Add
+   * flag NOT set indicates a DNSSD::Flags::Remove, i.e. the domain is no longer valid.
+   */
+  rb_define_const(cDNSSDFlags, "Add", ULONG2NUM(kDNSServiceFlagsAdd));
+  rb_define_const(cDNSSDFlags, "Default", ULONG2NUM(kDNSServiceFlagsDefault));
+
+  /* Flag for specifying renaming behavior on name conflict when registering non-shared records.
+   * By default, name conflicts are automatically handled by renaming the service.
+   * DNSSD::Flags::NoAutoRename overrides this behavior - with this
+   * flag set, name conflicts will result in a callback.  The NoAutoRename flag
+   * is only valid if a name is explicitly specified when registering a service
+   * (ie the default name is not used.)
+   */
+  rb_define_const(cDNSSDFlags, "NoAutoRename", ULONG2NUM(kDNSServiceFlagsNoAutoRename));
+
+  /* Flag for registering individual records on a connected DNSServiceRef.
+   * DNSSD::Flags::Shared indicates that there may be multiple records
+   * with this name on the network (e.g. PTR records).  DNSSD::Flags::Unique indicates that the
+   * record's name is to be unique on the network (e.g. SRV records).
+   * (DNSSD::Flags::Shared and DNSSD::Flags::Unique are currently not used by the Ruby API.)
+   */
+  rb_define_const(cDNSSDFlags, "Shared", ULONG2NUM(kDNSServiceFlagsShared));
+  rb_define_const(cDNSSDFlags, "Unique", ULONG2NUM(kDNSServiceFlagsUnique));
+
+  /* Flags for specifying domain enumeration type in DNSSD.enumerate_domains()
+   * (currently not part of the Ruby API).
+   * DNSSD::Flags::BrowseDomains enumerates domains recommended for browsing,
+   * DNSSD::Flags::RegistrationDomains enumerates domains recommended for registration.
+   */
+  rb_define_const(cDNSSDFlags, "BrowseDomains", ULONG2NUM(kDNSServiceFlagsBrowseDomains));
+  rb_define_const(cDNSSDFlags, "RegistrationDomains", ULONG2NUM(kDNSServiceFlagsRegistrationDomains));
+
+  /* Flag for creating a long-lived unicast query for the DNSDS.query_record()
+   * (currently not part of the Ruby API). */
+  rb_define_const(cDNSSDFlags, "LongLivedQuery", ULONG2NUM(kDNSServiceFlagsLongLivedQuery));
+
+  flags_hash = rb_hash_new();
+
+  for (i = 0; i < DNSSD_MAX_FLAGS; i++) {
+    rb_hash_aset(flags_hash, rb_str_new2(dnssd_flag_name[i]),
+		 ULONG2NUM(dnssd_flag[i]));
+  }
+
+  rb_define_const(cDNSSDFlags, "FLAGS", flags_hash);
+}
+
+/* Document-class: DNSSD::Reply
+ *
+ * DNSSD::Reply is used to return information
+ *
+ */
+

data/ext/dnssd/dnssd_tr.c

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2004 Chad Fowler, Charles Mills, Rich Kilmer
+ * Licenced under the same terms as Ruby.
+ * This software has absolutely no warrenty.
+ */
+#include "dnssd.h"
+#include <string.h> /* for strchr() */
+
+static VALUE cDNSSDTextRecord;
+
+static void
+dnssd_tr_decode_buffer(VALUE self, long buf_len, const char *buf_ptr) {
+  /* iterate through text record, inserting key, value pairs into hash */
+  long i = 0;
+  while(i < buf_len) {
+    VALUE key, value;
+    const char *p;
+    long key_len, len = (long)(uint8_t)buf_ptr[i++];
+    if (i + len > buf_len)
+      rb_raise(rb_eArgError, "invalid text record (string longer than buffer)");
+
+    if (len == 0) {
+      /* 0-length key/value, handle this by skipping over it.
+       * Probably the RR should have zero-length, but some services have been
+       * found to advertise a non-zero length TXT record, with a zero-length
+       * key/value string.
+       */
+      continue;
+    }
+
+    p = memchr(buf_ptr + i, '=', buf_len - i);
+    if (p == NULL) {
+      /* key, with no value, this is OK */
+      key_len = len;
+      key = rb_str_new(buf_ptr + i, key_len);
+      value = Qnil;
+    } else {
+      key_len = p - (buf_ptr + i);
+      if(key_len == 0)
+        rb_raise(rb_eArgError, "invalid text record (zero-length key)");
+
+      key = rb_str_new(buf_ptr + i, key_len);
+      key_len++; /* step over '=' */
+      value = rb_str_new(buf_ptr + i + key_len, len - key_len);
+    }
+    rb_hash_aset(self, key, value);
+    i += len;
+  }
+}
+
+static void
+dnssd_tr_decode_str(VALUE self, VALUE str) {
+  str = StringValue(str);
+  /* text records cannot be longer than 65535 (0xFFFF) */
+  if (RSTRING_LEN(str) > UINT16_MAX)
+    rb_raise(rb_eArgError, "string is to large to encode");
+  dnssd_tr_decode_buffer (self, RSTRING_LEN(str), RSTRING_PTR(str));
+}
+
+/*
+ * call-seq:
+ *    DNSSD::TextRecord.decode(binary_string) => text_record
+ *
+ * Create a new DNSSD::TextRecord be decoding the key
+ * value pairs contained in _binary_string_.  See DNSSD::TextRecord.encode()
+ * for more information.
+ */
+
+static VALUE
+dnssd_tr_decode(VALUE klass, VALUE str) {
+  /* self needs to be on the stack - we add (allocate)
+   * lots of key, value pairs when decoding and this could
+   * cause the gc to run. */
+  volatile VALUE self = rb_obj_alloc(klass);
+  dnssd_tr_decode_str(self, str);
+  return self;
+}
+
+VALUE
+dnssd_tr_new(long len, const char *buf) {
+  VALUE self = rb_obj_alloc(cDNSSDTextRecord);
+  dnssd_tr_decode_buffer(self, len, buf);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    DNSSD::TextRecord.new()               => text_record
+ *    DNSSD::TextRecord.new(binary_string)  => text_record
+ *
+ * The first form creates an empty text record.  The second
+ * creates a new text record populated with the key, value pairs
+ * found in the encoded string _binary_string_.  See
+ * DNSSD::TextRecord.encode() for more information.
+ *
+ *    tr = DNSSD::TextRecord.new  #=> {}
+ *    tr["name"] = "Chad"
+ *    tr["port"] = 3871.to_s
+ *
+ */
+
+static VALUE
+dnssd_tr_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE encoded_str;
+  rb_scan_args(argc, argv, "01", &encoded_str);
+  if (argc == 1) {
+    /* try to decode the string */
+    dnssd_tr_decode_str(self, encoded_str);
+  }
+  return self;
+}
+
+static void
+dnssd_tr_valid_key(const char *key_cstr, long len) {
+  /* keys cannot contain '=' */
+  if (strchr(key_cstr, '='))
+    rb_raise(eDNSSDError, "key '%s' contains '='", key_cstr);
+
+  if (len <= 0)
+    rb_raise(eDNSSDError, "empty key given");
+}
+
+static long
+dnssd_tr_convert_pairs(volatile VALUE ary) {
+  long i, tot_len = 0;
+  VALUE *ptr = RARRAY_PTR(ary);
+  /* iterate over key, value pairs checking if each one is valid */
+  for(i=0; i<RARRAY_LEN(ary); i++) {
+    VALUE key = RARRAY_PTR(ptr[i])[0];
+    VALUE value = RARRAY_PTR(ptr[i])[1];
+    /* checks if key is a valid C String (null terminated)
+     * note: StringValueCStr takes a pointer to key by &key
+     * this may cause key to be reassigned. */
+    const char *key_cstr = StringValueCStr(key);
+    long len = RSTRING_LEN(key);
+    dnssd_tr_valid_key(key_cstr, len);
+
+    if (!NIL_P(value)) {
+      value = StringValue(value);
+      len += 1 + RSTRING_LEN(value);
+    }
+    /* len == sum(key length, 1 for '=' if value != nil, value length) */
+    if (len > UINT8_MAX)
+      rb_raise(eDNSSDError, "key, value pair at '%s' is too large to encode", key_cstr);
+
+    /* now that we know no errors are going to occur */
+    if (RSTRING_LEN(key) > 14)
+      rb_warn("key '%s' is greator than 14 bytes, may not be compatible with all clients", key_cstr);
+    /* key and value may have been reassigned by StringValue macros */
+    RARRAY_PTR(ptr[i])[0] = key;
+    RARRAY_PTR(ptr[i])[1] = value;
+    tot_len += len + 1; /* plus 1 to hold key, value pair length */
+  }
+  return tot_len;
+}
+
+/*
+ * call-seq:
+ *    text_record.encode => an_encoded_string
+ *
+ * Encodes the contents of _text_record_ into a sequence of <em>binary strings</em>
+ * (one for each key, value pair).
+ * The each <em>binary string</em> comprises of a <em>length</em> and a <em>payload</em>.
+ * The <em>length</em> gives the number of bytes in the <em>payload</em>
+ * (must be between <code>0</code> and <code>255</code>).
+ * This is an unsigned integer packed into the first byte of the binary string.
+ * The <em>payload</em> contains a key, value pair separated by a <code>=</code> character.
+ * Because <code>=</code> is used as a separator, keys must not contain any
+ * <code>=</code> characters.  Here is an example of how the key, value pair
+ * <code>"1rst"</code>, <code>"Sam"</code> is encoded.
+ *
+ *    [00][01][02][03][04][05][06][07][08]
+ *    \010 1   r   s   t   =   S   a   m
+ *
+ * It is recommended to use keys with a length less than or equal to <code>14</code> bytes
+ * to ensure compatibility with all clients.
+ *
+ *    text_record = DNSSD::TextRecord.new
+ *    text_record["1rst"]="Sam"
+ *    text_record["Last"]="Green"
+ *    text_record["email"]="sam@green.org"
+ *    s = text_record.encode      #=> "\nLast=Green\0101rst=Sam\023email=sam@green.org"
+ *    DNSSD::TextRecord.decode(s) #=> {"Last"=>"Green", "1rst"=>"Sam", "email"=>"sam@green.org"}
+ *
+ */
+
+static VALUE
+dnssd_tr_encode(VALUE self) {
+  long i;
+  VALUE buf;
+  /* Declare ary volatile to prevent it from being reclaimed when:
+   * buf is allocated later, key/values are converted to strings */
+  volatile VALUE ary = rb_funcall2(self, rb_intern("to_a"), 0, 0);
+  /* array of key, value pairs */
+  VALUE *ptr = RARRAY_PTR(ary);
+
+  buf = rb_str_buf_new(dnssd_tr_convert_pairs(ary));
+  for(i=0; i<RARRAY_LEN(ary); i++) {
+    int len;
+    VALUE key = RARRAY_PTR(ptr[i])[0];
+    VALUE value = RARRAY_PTR(ptr[i])[1];
+    if (!NIL_P(value)) {
+      len = (RSTRING_LEN(key) + RSTRING_LEN(value) + 1);
+      /* FIXME: This can't work.  WTF */
+      /* len is a number, not a pointer to a character. */
+      rb_str_buf_cat(buf, &len, 1);
+      rb_str_buf_append(buf, key);
+      rb_str_buf_cat(buf, "=", 1);
+      rb_str_buf_append(buf, value);
+    } else {
+      len = RSTRING_LEN(key);
+      rb_str_buf_cat(buf, &len, 1);
+      rb_str_buf_append(buf, key);
+    }
+  }
+  return buf;
+}
+
+VALUE
+  dnssd_tr_to_encoded_str(VALUE v) {
+    if (rb_obj_is_kind_of(v, rb_cHash) == Qtrue)
+      return dnssd_tr_encode(v);
+    /* allow the user to use arbitrary strings as text records */
+    return StringValue(v);
+  }
+
+/*
+ * Document-class: DNSSD::TextRecord
+ *
+ * DNSSD::TextRecord is a Hash with the ability to encode its contents into
+ * a binary string that can be send over the wire as using the DNSSD protocol.
+ *
+ */
+
+void
+Init_DNSSD_TextRecord(void) {
+  /* hack so rdoc documents the project correctly */
+#ifdef mDNSSD_RDOC_HACK
+  mDNSSD = rb_define_module("DNSSD");
+#endif
+  cDNSSDTextRecord = rb_define_class_under(mDNSSD, "TextRecord", rb_cHash);
+
+  rb_define_singleton_method(cDNSSDTextRecord, "decode", dnssd_tr_decode, 1);
+
+  rb_define_method(cDNSSDTextRecord, "initialize", dnssd_tr_initialize, -1);
+  rb_define_method(cDNSSDTextRecord, "encode", dnssd_tr_encode, 0);
+}
+