dnssd 0.6.0 → 0.7.0

data/ext/rdnssd_structs.c

@@ -5,16 +5,8 @@
  */
 #include "rdnssd.h"
 
-/* for if_indextoname() */
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <net/if.h>
-
 static VALUE cDNSSDFlags;
 static VALUE cDNSSDReply;
-static VALUE cDNSSDBrowseReply;
-static VALUE cDNSSDResolveReply;
-static VALUE cDNSSDRegisterReply;
 	
 static ID dnssd_iv_flags;
 static ID dnssd_iv_interface;
@@ -28,6 +20,10 @@ static ID dnssd_iv_domain;
 static ID dnssd_iv_service;
 
 #define IsDNSSDFlags(obj) (rb_obj_is_kind_of(obj,cDNSSDFlags)==Qtrue)
+#define VerifyDNSSDFlags(obj) \
+	do { \
+		if(!IsDNSSDFlags(obj)) rb_fatal(__FILE__":%d: bug in DNSSD",__LINE__); \
+	} while (0)
 
 /* dns sd flags, flag ID's, flag names */
 #define DNSSD_MAX_FLAGS 9
@@ -49,7 +45,13 @@ static const DNSServiceFlags dnssd_flag[DNSSD_MAX_FLAGS] = {
 	kDNSServiceFlagsLongLivedQuery
 };
 
-static ID dnssd_flag_iv[DNSSD_MAX_FLAGS];
+/* used to make sure only valid bits are set in a flag. */
+#define DNSSD_FLAGS_MASK(f) \
+		( (f) & (kDNSServiceFlagsMoreComing | \
+		kDNSServiceFlagsAdd | kDNSServiceFlagsDefault | \
+		kDNSServiceFlagsNoAutoRename | kDNSServiceFlagsShared | \
+		kDNSServiceFlagsUnique | kDNSServiceFlagsBrowseDomains | \
+		kDNSServiceFlagsRegistrationDomains | kDNSServiceFlagsLongLivedQuery) )
 
 static const char *dnssd_flag_name[DNSSD_MAX_FLAGS] = {
 	"more_coming",
@@ -63,126 +65,54 @@ static const char *dnssd_flag_name[DNSSD_MAX_FLAGS] = {
 	"long_lived_query"
 };
 
-static VALUE
-dnssd_struct_inspect(VALUE self, volatile VALUE data)
-{
-	VALUE buf = rb_str_buf_new(0);
-	rb_str_buf_cat2(buf, "#<");
-	rb_str_buf_cat2(buf, rb_obj_classname(self));
-	if (RSTRING(data)->len > 0) {
-		rb_str_buf_cat2(buf, " ");
-		rb_str_buf_append(buf, data);
-	}
-	rb_str_buf_cat2(buf, ">");
-	return buf;
-}
-
-VALUE
-dnssd_create_fullname(VALUE name, VALUE regtype, VALUE domain, int err_flag)
-{
-	char buffer[kDNSServiceMaxDomainName];
-	int ret_val = DNSServiceConstructFullName(buffer,
-																						NIL_P(name) ? NULL : StringValueCStr(name),
-																						StringValueCStr(regtype),
-																						StringValueCStr(domain)	);
-	if (ret_val) {
-		static const char msg[] = "could not construct full service name";
-		if (err_flag) rb_raise(rb_eArgError, msg);
-		/* else */
-		rb_warn(msg);
-		return name;
-	}
-	buffer[kDNSServiceMaxDomainName - 1] = '\000'; /* just in case */
-	return rb_str_new2(buffer);
-}
-
-static VALUE
-dnssd_get_fullname(VALUE self, int flag)
-{
-	return dnssd_create_fullname(	rb_ivar_get(self, dnssd_iv_name),
-																rb_ivar_get(self, dnssd_iv_type),
-																rb_ivar_get(self, dnssd_iv_domain), flag	);
-}
-
-/*
- * call-seq:
- *    reply.fullname => string
- *
- * The fullname of the resource the reply is associated with.
- * See DNSSD::Service.fullname() for more information.
- */
-
-static VALUE
-dnssd_reply_fullname(VALUE self)
-{
-	return dnssd_get_fullname(self, 1);
-}
-
-static void
-dnssd_add_names(volatile 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));
-}
-
 static void
-dnssd_init_flag_iv(void)
+dnssd_init_flags_methods(VALUE klass)
 {
-	/* initialize flag instance variable ids. */
-	char buffer[32];
+	char buffer[128];
 	int i;
 	for (i=0; i<DNSSD_MAX_FLAGS; i++) {
-		snprintf(buffer, sizeof(buffer), "@%s", dnssd_flag_name[i]);
-		dnssd_flag_iv[i] = rb_intern(buffer);
+		unsigned long flag = (unsigned long)dnssd_flag[i];
+		const char *flag_name = dnssd_flag_name[i];
+		VALUE str;
+		size_t len;
+		len = snprintf(buffer, sizeof(buffer),
+									 "def %s?; self & %lu end",
+									 flag_name, flag);
+		str = rb_str_new(buffer, (long)len);
+		rb_mod_module_eval(1, &str, klass);
+
+		/* similar to attr_writer method for each flag */
+		len = snprintf(buffer, sizeof(buffer),
+									 "def %s=(val); "
+									 "if val then self.set_flag(%lu) else self.clear_flag(%lu) end; "
+									 "val end", /* return val */
+									 flag_name, flag, flag);
+		str = rb_str_new(buffer, (long)len);
+		rb_mod_module_eval(1, &str, klass);
 	}
 }
 
-static void
-dnssd_init_flags_methods(VALUE class)
+static VALUE
+dnssd_flags_alloc(VALUE klass)
 {
-	char buffer[128];
-	int i;
-	for (i=0; i<DNSSD_MAX_FLAGS; i++) {
-		volatile VALUE str;
-		size_t len = snprintf(buffer, sizeof(buffer),
-													"def %s?; @%s end",
-													dnssd_flag_name[i],
-													dnssd_flag_name[i]);
-		str = rb_str_new(buffer, (long)len);
-		rb_mod_module_eval(1, (VALUE *)&str, class);
-		/* attr_writer method for each flag */
-		rb_define_attr(class, dnssd_flag_name[i], 0, 1);
-	}
+	/* no free function or mark function, initialize flags/data to 0 */
+	return Data_Wrap_Struct(klass, 0, 0, 0);
 }
 
 static VALUE
 dnssd_flags_init(VALUE self, DNSServiceFlags flags)
 {
-	int i;
-	for (i=0; i<DNSSD_MAX_FLAGS; i++) {
-		/* check each flag using binary and, set to Qtrue of exists */
-		if (flags & dnssd_flag[i]) {
-			rb_ivar_set(self, dnssd_flag_iv[i], Qtrue);
-		} else {
-			rb_ivar_set(self, dnssd_flag_iv[i], Qfalse);
-		}
-	}
+	VerifyDNSSDFlags(self);
+	/* note DNSSD_FLAGS_MASK() here */
+	RDATA(self)->data = (void*)DNSSD_FLAGS_MASK(flags);
 	return self;
 }
 
 static DNSServiceFlags 
 dnssd_get_flags(VALUE self)
 {
-	DNSServiceFlags flags = 0;
-	int i;
-	for (i=0; i<DNSSD_MAX_FLAGS; i++) {
-		if (RTEST(rb_ivar_get(self, dnssd_flag_iv[i]))) {
-			flags |= dnssd_flag[i];
-		}
-	}
-	return flags;
+	VerifyDNSSDFlags(self);
+	return (DNSServiceFlags)RDATA(self)->data;
 }
 
 DNSServiceFlags 
@@ -192,49 +122,146 @@ dnssd_to_flags(VALUE obj)
 	if (IsDNSSDFlags(obj)) {
 		flags = dnssd_get_flags(obj);
 	} else {
-		flags = NUM2ULONG(obj);
+		/* don't want to include any bits that aren't flags */
+		flags = DNSSD_FLAGS_MASK((DNSServiceFlags)NUM2ULONG(obj));
 	}
 	return flags;
 }
 
 /*
  * call-seq:
- *   DNSSD::Flags.new()         => flags
- *   DNSSD::Flags.new(integer)  => flags
- *   DNSSD::Flags.new(flags)    => dup_of_flags
+ *   DNSSD::Flags.new()                   => flags
+ *   DNSSD::Flags.new(flag1, flag2, ...)  => union_of_flags
  *
- * Returns a new group of flags.  In the first form,
- * none of the new flags are set.
- * In the second the flags corresponding to the bits of _integer_ are set.
- * In the third the flags set in _flags_  are set.
+ * Returns a new set of flags.
+ * In the first form an empty set of flags is created.
+ * In the second a set of flags containing the union of
+ * each flag (or set of flags) given is created.
  *
  *   flags = Flags.new()
  *   flags.more_coming = true
  *   flags.to_i                #=> DNSSD::Flags::MoreComing
  *   f.shared = true
  *   flags.to_i                #=> Flags::MoreComing | Flags::Shared
+ *
  *   same_flags = Flags.new(Flags::MoreComing | Flags::Shared)
  *   flags == same_flags       #=> true
  *
+ *   same_flags_again = Flags.new(Flags::MoreComing, Flags::Shared)
+ *   flags == same_flags_again  #=> true
+ *
  */
 
 static VALUE
 dnssd_flags_initialize(int argc, VALUE *argv, VALUE self)
 {
-	VALUE def_val = Qnil;
+	int i;
 	DNSServiceFlags flags = 0;
-	
-	rb_scan_args(argc, argv, "01", &def_val);
-	if (def_val != Qnil) {
-		flags = dnssd_to_flags(def_val);
+
+	for (i=0; i<argc; i++) {
+		flags |= dnssd_to_flags(argv[i]);
 	}
 	return dnssd_flags_init(self, flags);
 }
 
+static VALUE
+dnssd_flags_new2(VALUE klass, DNSServiceFlags flags)
+{
+	return dnssd_flags_init(dnssd_flags_alloc(klass), flags);
+}
+
 static VALUE
 dnssd_flags_new(DNSServiceFlags flags)
 {
-	return dnssd_flags_init(rb_obj_alloc(cDNSSDFlags), flags);
+	return dnssd_flags_new2(cDNSSDFlags, flags);
+}
+
+/*
+ * call-seq:
+ *    flags.set_flag(f)
+ *
+ * Set the flag _f_ in _flags_.
+ *
+ *    flags = Flags.new()                #=> #<DNSSD::Flags>
+ *    flags.set_flag(Flags::MoreComing)  #=> #<DNSSD::Flags more_coming>
+ *
+ */
+
+static VALUE
+dnssd_flags_set(VALUE self, VALUE num)
+{
+	DNSServiceFlags flags;
+	VerifyDNSSDFlags(self);
+	flags = (DNSServiceFlags)RDATA(self)->data;
+	flags |= dnssd_to_flags(num);
+	RDATA(self)->data = (void*)flags;
+	return self;
+}
+
+/*
+ * call-seq:
+ *    flags.clear_flag(f)
+ *
+ * Clear the flag _f_ in _flags_.
+ *
+ *    flags = Flags.new(Flags::MoreComing)  #=> #<DNSSD::Flags more_coming>
+ *    flags.clear_flag(Flags::MoreComing)   #=> #<DNSSD::Flags>
+ *
+ */
+
+static VALUE
+dnssd_flags_clear(VALUE self, VALUE num)
+{
+	DNSServiceFlags flags;
+	VerifyDNSSDFlags(self);
+	/* flags should stay masked here (see DNSSD_FLAGS_MASK() macro) */
+	flags = (DNSServiceFlags)RDATA(self)->data;
+	flags &= ~dnssd_to_flags(num);
+	RDATA(self)->data = (void*)flags;
+	return self;
+}
+
+/*
+ * call-seq:
+ *    flags1 & flags2 => flags
+ *
+ * Returns the set of flags included in <i>flags1</i> and <i>flags2</i>.
+ *
+ */
+
+static VALUE
+dnssd_flags_and(VALUE self, VALUE num)
+{
+	return dnssd_flags_new2(CLASS_OF(self), dnssd_get_flags(self) & dnssd_to_flags(num));
+}
+
+/*
+ * call-seq:
+ *    flags1 | flags2 => flags
+ *
+ * Returns the set of flags included in <i>flags1</i> or <i>flags2</i>.
+ *
+ */
+
+static VALUE
+dnssd_flags_or(VALUE self, VALUE num)
+{
+	return dnssd_flags_new2(CLASS_OF(self), dnssd_get_flags(self) | dnssd_to_flags(num));
+}
+
+/*
+ * call-seq:
+ *    ~flags => unset_flags
+ *
+ * Returns the set of flags not included in _flags_.
+ *
+ */
+
+static VALUE
+dnssd_flags_not(VALUE self)
+{
+	/* doesn't totally make sence to return a set of flags here... */
+	return dnssd_flags_new2(CLASS_OF(self), ~dnssd_get_flags(self));
 }
 
 /*
@@ -243,6 +270,7 @@ dnssd_flags_new(DNSServiceFlags flags)
  *
  * Get the integer representation of _flags_ by bitwise or'ing
  * each of the set flags.
+ *
  */
 
 static VALUE
@@ -254,18 +282,34 @@ dnssd_flags_to_i(VALUE self)
 static VALUE
 dnssd_flags_list(VALUE self)
 {
+	DNSServiceFlags flags = dnssd_get_flags(self);
 	VALUE buf = rb_str_buf_new(0);
 	int i;
 	for (i=0; i<DNSSD_MAX_FLAGS; i++) {
-		if (rb_ivar_get(self, dnssd_flag_iv[i])) {
+		if (flags & dnssd_flag[i]) {
 			rb_str_buf_cat2(buf, dnssd_flag_name[i]);
 			rb_str_buf_cat2(buf, ",");
 		}
 	}
 	/* get rid of trailing comma */
 	if (RSTRING(buf)->len > 0) {
-		RSTRING(buf)->len--;
+		long len = --(RSTRING(buf)->len);
+		RSTRING(buf)->ptr[len] = '\000';
+	}
+	return buf;
+}
+
+static VALUE
+dnssd_struct_inspect(VALUE self, VALUE data)
+{
+	VALUE buf = rb_str_buf_new(20 + RSTRING(data)->len);
+	rb_str_buf_cat2(buf, "#<");
+	rb_str_buf_cat2(buf, rb_obj_classname(self));
+	if (RSTRING(data)->len > 0) {
+		rb_str_buf_cat2(buf, " ");
+		rb_str_buf_append(buf, data);
 	}
+	rb_str_buf_cat2(buf, ">");
 	return buf;
 }
 
@@ -279,21 +323,20 @@ dnssd_flags_list(VALUE self)
  *    flags.add = true
  *    flags.default = true
  *    flags.inspect  # => "#<DNSSD::Flags add,default>"
+ *
  */
 
 static VALUE
 dnssd_flags_inspect(VALUE self)
 {
-	volatile VALUE data = dnssd_flags_list(self);
-	return dnssd_struct_inspect(self, data);
+	return dnssd_struct_inspect(self, dnssd_flags_list(self));
 }
 
 /*
  * call-seq:
  *    flags == obj => true or false
  *
- * Equality--Two groups of flags are equal if the flags underlying integers
- * are equal.
+ * Equality--Two sets of flags are equal if they contain the same flags.
  *
  *    flags = Flags.new()
  *    flags.more_coming = true
@@ -311,95 +354,183 @@ dnssd_flags_equal(VALUE self, VALUE obj)
 	return flags == obj_flags ? Qtrue : Qfalse;
 }
 
-static VALUE
-dnssd_interface_name(uint32_t interface)
+VALUE
+dnssd_create_fullname(const char *name, const char *regtype, const char *domain, int err_flag)
 {
-	char buffer[IF_NAMESIZE];
-	if (if_indextoname(interface, buffer)) {
-		return rb_str_new2(buffer);
-	} else {
-		return ULONG2NUM(interface);
+	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);
 }
 
-static VALUE
-dnssd_get_interface(VALUE self)
+VALUE
+dnssd_split_fullname(VALUE fullname)
 {
-	return rb_String(rb_ivar_get(self, dnssd_iv_interface));
+	static const char re[] = "(?:\\\\.|[^\\.])+\\.";
+	VALUE regexp = rb_reg_new(re, sizeof(re)-1, 0);
+	return rb_funcall2(fullname, rb_intern("scan"), 1, &regexp);
 }
 
-/*
- * call-seq:
- *    register_reply.inspect => string
- *
- */
+#if 0
+static void
+quote_and_append(VALUE buf, VALUE str)
+{
+	const char *ptr;
+	long i, last_mark, len;
+
+	ptr = RSTRING(str)->ptr;
+	len = RSTRING(str)->len;
+	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(buf)->ptr[i] = '\\';
+			last_mark = i;
+		}
+	}
+	rb_str_buf_cat(buf, ptr + last_mark, len - last_mark);
+}
+#endif
 
 static VALUE
-dnssd_register_inspect(VALUE self)
+dnssd_join_names(int argc, VALUE *argv)
 {
-	volatile VALUE data = dnssd_get_fullname(self, 0);
-	return dnssd_struct_inspect(self, data);
+	int i;
+	VALUE buf;
+	long len = 0;
+
+	for (i=0; i<argc; i++) {
+		argv[i] = StringValue(argv[i]);
+		len += RSTRING(argv[i])->len;
+	}
+	buf = rb_str_buf_new(len);
+	for (i=0; i<argc; i++) {
+		rb_str_buf_append(buf, argv[i]);
+	}
+	return buf;
 }
 
-VALUE
-dnssd_register_new(VALUE service,	DNSServiceFlags flags, const char *name,
-										const char *regtype, const char *domain	)
+static void
+reply_add_names(VALUE self, const char *name,
+								const char *regtype, const char *domain)
 {
-	volatile VALUE self = rb_obj_alloc(cDNSSDRegisterReply);
-	rb_ivar_set(self, dnssd_iv_flags, dnssd_flags_new(flags));
-	rb_ivar_set(self, dnssd_iv_service, service);
-	dnssd_add_names(self, name, regtype, domain);
-	return self;
+	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));
 }
 
-/*
- * call-seq:
- *    browse_reply.inspect => string
- *
- */
+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
-dnssd_browse_inspect(VALUE self)
+reply_new(VALUE service, DNSServiceFlags flags)
 {
-	volatile VALUE data = rb_str_buf_new(0);
-	rb_str_buf_append(data, dnssd_get_fullname(self, 0));
-	rb_str_buf_cat2(data, " interface:");
-	rb_str_buf_append(data, dnssd_get_interface(self));
-	return dnssd_struct_inspect(self, data);
+	VALUE self = rb_obj_alloc(cDNSSDReply);
+	rb_ivar_set(self, dnssd_iv_service, service);
+	rb_ivar_set(self, dnssd_iv_flags, dnssd_flags_new(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)
 {
-	volatile VALUE self = rb_obj_alloc(cDNSSDBrowseReply);
-	rb_ivar_set(self, dnssd_iv_flags, dnssd_flags_new(flags));
-	rb_ivar_set(self, dnssd_iv_interface, dnssd_interface_name(interface));
-	rb_ivar_set(self, dnssd_iv_service, service);
-	dnssd_add_names(self, name, regtype, domain);
+	VALUE self = reply_new(service, flags);
+	reply_set_interface(self, interface);
+	reply_add_names(self, name, regtype, domain);
 	return self;
 }
 
-/*
- * call-seq:
- *    resolve_reply.inspect => string
- *
- */
-
+#if 0
 static VALUE
-dnssd_resolve_inspect(VALUE self)
+dnssd_gethostname(void)
 {
-	volatile VALUE data = rb_str_buf_new(0);
-	rb_str_buf_append(data, rb_ivar_get(self, dnssd_iv_fullname));
-	rb_str_buf_cat2(data, " interface:");
-	rb_str_buf_append(data, dnssd_get_interface(self));
-	rb_str_buf_cat2(data, " target:");
-	rb_str_buf_append(data, rb_ivar_get(self, dnssd_iv_target));
-	rb_str_buf_cat2(data, ":");
-	rb_str_buf_append(data, rb_inspect(rb_ivar_get(self, dnssd_iv_port)));
-	rb_str_buf_cat2(data, " ");
-	rb_str_buf_append(data, rb_inspect(rb_ivar_get(self, dnssd_iv_text_record)));
-	return dnssd_struct_inspect(self, data);
+#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 rdnssd_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
@@ -408,24 +539,34 @@ dnssd_resolve_new(VALUE service, DNSServiceFlags flags, uint32_t interface,
 									uint16_t opaqueport, uint16_t txt_len, const char *txt_rec)
 {
 	uint16_t port = ntohs(opaqueport);
-	volatile VALUE self = rb_obj_alloc(cDNSSDResolveReply);
-	rb_ivar_set(self, dnssd_iv_flags, dnssd_flags_new(flags));
-	rb_ivar_set(self, dnssd_iv_interface, dnssd_interface_name(interface));
-	rb_ivar_set(self, dnssd_iv_fullname, rb_str_new2(fullname));
+	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));
-	rb_ivar_set(self, dnssd_iv_text_record, dnssd_tr_new((long)txt_len, txt_rec));
-	rb_ivar_set(self, dnssd_iv_service, service);
+	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
-dnssd_reply_initialize(int argc, VALUE *argv, VALUE reply)
+reply_initialize(int argc, VALUE *argv, VALUE reply)
 {
 	dnssd_instantiation_error(rb_obj_classname(reply));
 	return Qnil;
@@ -450,71 +591,54 @@ Init_DNSSD_Replies(void)
 	dnssd_iv_domain = rb_intern("@domain");
 	dnssd_iv_service = rb_intern("@service");
 
-	dnssd_init_flag_iv();
-
 	cDNSSDFlags = rb_define_class_under(mDNSSD, "Flags", rb_cObject);
+	rb_define_alloc_func(cDNSSDFlags, dnssd_flags_alloc);
 	rb_define_method(cDNSSDFlags, "initialize", dnssd_flags_initialize, -1);
-	/* this creates all the attr_accessor and flag? methods */
+	/* this creates all the attr_writer and flag? methods */
 	dnssd_init_flags_methods(cDNSSDFlags);
 	rb_define_method(cDNSSDFlags, "inspect", dnssd_flags_inspect, 0);
 	rb_define_method(cDNSSDFlags, "to_i", dnssd_flags_to_i, 0);
 	rb_define_method(cDNSSDFlags, "==", dnssd_flags_equal, 1);
+	
+	rb_define_method(cDNSSDFlags, "&", dnssd_flags_and, 1);
+	rb_define_method(cDNSSDFlags, "|", dnssd_flags_or, 1);
+	rb_define_method(cDNSSDFlags, "~", dnssd_flags_not, 0);
+	
+	rb_define_method(cDNSSDFlags, "set_flag", dnssd_flags_set, 1);
+	rb_define_method(cDNSSDFlags, "clear_flag", dnssd_flags_clear, 1);
 
-	/* prototype: rb_define_attr(class, name, read, write) */
 	cDNSSDReply = rb_define_class_under(mDNSSD, "Reply", rb_cObject);
-	/* DNSSD::Reply objects can only be instantiated by DNSSD.browse(), DNSSD.register(), DNSSD.resolve(). */
-	rb_define_method(cDNSSDReply, "initialize", dnssd_reply_initialize, -1);
-	/* Flags describing the reply.  See DNSSD::Flags for more information. */
-	rb_define_attr(cDNSSDReply, "flags", 1, 0);
+	/* 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);
-	rb_define_method(cDNSSDReply, "fullname", dnssd_reply_fullname, 0);
-
-	cDNSSDBrowseReply = rb_define_class_under(mDNSSD, "BrowseReply", cDNSSDReply);
-	/* The interface on which the service is advertised.
-	 * The interface should be passed to DNSSD.resolve() when resolving the service. */
-	rb_define_attr(cDNSSDBrowseReply, "interface", 1, 0);
-	/* The service name discovered. */
-	rb_define_attr(cDNSSDBrowseReply, "name", 1, 0);
-	/* The service type, as passed in to DNSSD.browse(). */
-	rb_define_attr(cDNSSDBrowseReply, "type", 1, 0);
-	/* The domain on which the service was discovered.
-	 * (If the application did not specify a domain in DNSSD.browse(),
-	 * this indicates the domain on which the service was discovered.) */
-	rb_define_attr(cDNSSDBrowseReply, "domain", 1, 0);
-	rb_define_method(cDNSSDBrowseReply, "inspect", dnssd_browse_inspect, 0);
-
-	cDNSSDResolveReply = rb_define_class_under(mDNSSD, "ResolveReply", cDNSSDReply);
-	/* The interface on which the service was resolved. */
-	rb_define_attr(cDNSSDResolveReply, "interface", 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(cDNSSDResolveReply, "fullname", 1, 0);
+	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(cDNSSDResolveReply, "target", 1, 0);
+	rb_define_attr(cDNSSDReply, "target", 1, 0);
 	/* The port on which connections are accepted for this service. */
-	rb_define_attr(cDNSSDResolveReply, "port", 1, 0);
-	/* The service's primary text record, see DNSSD::TextRecord for more information. */
-	rb_define_attr(cDNSSDResolveReply, "text_record", 1, 0);
-	rb_define_method(cDNSSDResolveReply, "inspect", dnssd_resolve_inspect, 0);
-
-	cDNSSDRegisterReply = rb_define_class_under(mDNSSD, "RegisterReply", cDNSSDReply);
-	/* The service name registered.
-	 * (If the application did not specify a name in DNSSD.register(),
-	 * this indicates what name was automatically chosen.) */
-	rb_define_attr(cDNSSDRegisterReply, "name", 1, 0);
-	/* The type of service registered as it was passed to DNSSD.register(). */
-	rb_define_attr(cDNSSDRegisterReply, "type", 1, 0);
-	/* The domain on which the service was registered.
-	 * (If the application did not specify a domain in DNSSD.register(),
-	 * this indicates the default domain on which the service was registered.) */
-	rb_define_attr(cDNSSDRegisterReply, "domain", 1, 0);
-	rb_define_method(cDNSSDRegisterReply, "inspect", dnssd_register_inspect, 0);
+	rb_define_attr(cDNSSDReply, "port", 1, 0);
+
+	rb_define_method(cDNSSDReply, "inspect", reply_inspect, 0);
 
 	/* flag constants */
 #if DNSSD_MAX_FLAGS != 9
@@ -575,9 +699,7 @@ Init_DNSSD_Replies(void)
 
 /* Document-class: DNSSD::Reply
  * 
- * DNSSD::Reply is the parent class of DNSSD::BrowseReply, DNSSD::RegisterReply, and DNSSD::ResolveReply.
- * It simply contains the behavior that is common to those classes, otherwise it is not
- * used by the DNSSD Ruby API.
+ * DNSSD::Reply is used to return information 
  *
  */