dnssd 0.6.0

data/ext/rdnssd_tr.c

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2004 Chad Fowler, Charles Mills, Rich Kilmer
+ * Licenced under the same terms as Ruby.
+ * This software has absolutely no warrenty.
+ */
+#include "rdnssd.h"
+#include <intern.h>
+#include <string.h> /* for strchr() */
+
+static VALUE cDNSSDTextRecord;
+
+static void
+dnssd_tr_decode_error(void)
+{
+	rb_raise(rb_eArgError, "buffer contains invalid text record");
+}
+
+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 >= buf_len || i + len > buf_len)
+			dnssd_tr_decode_error();
+
+		p = strchr(buf_ptr + i, '=');
+		if (p == NULL) {
+			key_len = len;
+			key = rb_str_new(buf_ptr + i, key_len);
+			value = Qnil;
+		} else {
+			key_len = p - (buf_ptr + i);
+			if (key_len >= len)
+				dnssd_tr_decode_error();
+			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(str)->len > UINT16_MAX)
+		rb_raise(rb_eArgError, "string is to large to encode");
+	dnssd_tr_decode_buffer (self, RSTRING(str)->len, RSTRING(str)->ptr);
+}
+
+/*
+ * 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(rb_eRuntimeError, "key '%s' contains '='", key_cstr);
+
+	if (len <= 0)
+		rb_raise(rb_eRuntimeError, "empty key given");
+}
+
+static long
+dnssd_tr_convert_pairs(volatile VALUE ary)
+{
+	long i, tot_len = 0;
+	VALUE *ptr = RARRAY(ary)->ptr;
+	/* iterate over key, value pairs checking if each one is valid */
+	for(i=0; i<RARRAY(ary)->len; i++) {
+		VALUE key = RARRAY(ptr[i])->ptr[0];
+		VALUE value = RARRAY(ptr[i])->ptr[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(key)->len;
+		dnssd_tr_valid_key(key_cstr, len);
+
+		if (!NIL_P(value)) {
+			value = StringValue(value);
+			len += 1 + RSTRING(value)->len;
+		}
+		/* len == sum(key length, 1 for '=' if value != nil, value length) */
+		if (len > UINT8_MAX)
+			rb_raise(rb_eRuntimeError, "key, value pair at '%s' is too large to encode", key_cstr);
+	
+		/* now that we know no errors are going to occur */
+		if (RSTRING(key)->len > 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[i])->ptr[0] = key;
+		RARRAY(ptr[i])->ptr[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(ary)->ptr;
+	
+	buf = rb_str_buf_new(dnssd_tr_convert_pairs(ary));
+	for(i=0; i<RARRAY(ary)->len; i++) {
+		uint8_t len;
+		VALUE key = RARRAY(ptr[i])->ptr[0];
+		VALUE value = RARRAY(ptr[i])->ptr[1];
+		if (!NIL_P(value)) {
+			len = (uint8_t)(RSTRING(key)->len + RSTRING(value)->len + 1);
+			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 = (uint8_t)RSTRING(key)->len;
+			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);
+}
+

data/ext/run_rdoc

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+rdoc -w 2 -S *.c 
+

data/lib/dnssd.rb

@@ -0,0 +1,137 @@
+require 'rdnssd'
+
+=begin
+
+module DNSSD
+  class MalformedDomainException < Exception; end
+  class MalformedPortException < Exception; end
+  
+  def self.new_text_record(hash={})
+    TextRecord.new(hash)
+  end
+
+  class ServiceDescription
+  
+    class Location
+      attr_accessor :name, :port, :iface
+      def initialize(port, name=nil, iface=0)
+        @name = name
+        @port = port
+        @iface = iface
+      end
+    end
+
+    def initialize(type, name, domain, location)
+      @type = type
+      @name = name
+      @domain = validate_domain(domain)
+      @location = validate_location(location)
+    end
+    
+    def self.for_browse_notification(name, domain, 
+
+    def stop
+      @registrar.stop
+    end
+
+    def validate_location(location)
+      unless(location.port.respond_to?(:to_int))
+        raise MalformedPortException.new("#{location.port} is not a valid port number")
+      end
+      location
+    end
+
+    def validate_domain(domain)
+      unless(domain.empty? || domain =~ /^[a-z_]+$/)
+	      raise MalformedDomainException.new("#{domain} is not a valid domain name")
+      end
+      domain
+    end
+
+    def advertise_and_confirm
+      thread = Thread.current
+       @registrar = register(@name, @type, @domain, @location.port, TextRecord.new) do |service, name, type, domain|
+        @name = name
+        @type = type
+        @domain = domain
+        thread.wakeup
+      end
+      Thread.stop
+    end
+
+    def self.advertise_http(name, port=80, domain="", iface=0, &block)
+      self.advertise("_http._tcp", name, port, domain, iface, &block)
+    end
+    
+    ##
+    # iface: Numerical interface (0 = all interfaces, This should be used for most applications)
+    #
+    def self.advertise(type, name, port, domain="", iface=0, &block)
+      service_description = ServiceDescription.new(type, name, domain, Location.new(port,nil,iface))
+      service_description.advertise_and_confirm 
+      yield service_description if block_given?
+      service_description
+    end
+  end
+
+  class Browser
+  
+    Context = Struct.new(:service, :name, :type, :domain, :operation, :interface)
+    
+    class Context
+      def ==(other)
+        self.to_s == other.to_s
+      end
+      
+      def to_s
+        "#{name}.#{type}.#{domain}"
+      end
+      
+      def eql?(other)
+        self == other
+      end
+      
+      def hash
+        to_s.hash
+      end
+    end
+  
+    def on_change(&block)
+      @change_listener ||= []
+      @change_listeners << block
+    end
+    
+    def on_add(&block)
+      @add_listeners || = []
+      @add_listeners << block
+    end
+    
+    def on_remove(&block)
+      @remove_listeners || = []
+      @remove_listeners << block
+    end
+    
+    def initialize(type, domain="")
+      @list = []
+      @browse_service = DNSSD::Protocol.browse(type, domain) do 
+         |service, name, type, domain, operation, interface|
+         context = Context.new(service, name, type, domain, operation, interface)
+         puts "Name: #{name} Type: #{type} Domain: #{domain} Operation: #{operation} Interface: #{interface}"
+      end
+    end
+    
+    def service_descriptions
+      @list.clone
+    end
+
+    def stop
+      @browse_service.stop
+    end
+
+    def self.for_http(domain="")
+      self.new("_http._tcp", domain)
+    end
+  end
+end
+
+=end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: dnssd
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+date: 2004-10-07
+summary: DNS Service Discovery (aka Rendezvous) API for Ruby
+require_paths: 
+  - lib
+  - ext
+author: Charlie Mills
+email: cmills@freeshell.org
+homepage: http://dnssd.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: dnssd
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/dnssd.rb
+  - ext/dns_sd.h
+  - ext/extconf.rb
+  - ext/MANIFEST
+  - ext/rdnssd.c
+  - ext/rdnssd.h
+  - ext/rdnssd_service.c
+  - ext/rdnssd_structs.c
+  - ext/rdnssd_tr.c
+  - ext/run_rdoc
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: 
+  - ext/extconf.rb
+requirements: []
+dependencies: []