tipcsocket 0.1

data/CHANGELOG

@@ -0,0 +1,7 @@
+= TIPCSocket Changelog
+
+== Version 0.0.1
+
+=== January 14, 2008
+
+* Initial creation.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Corey Burrows
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,77 @@
+= TIPCSocket
+
+Ruby bindings for the TIPC[http://tipc.sourceforge.net] native socket API.
+
+= Installing TIPCSocket
+
+Get TIPCSocket from RubyForge.
+
+  $ gem install tipcsocket
+
+= Example
+
+Server:
+
+  require 'rubygems'
+  require 'tipcsocket'
+  
+  include TIPCSocket::Constants
+  
+  server_addr = TIPCNameSeq.new(18888, 17, 17, TIPC_ZONE_SCOPE)
+  
+  s = TIPCSocket.new(:rdm)
+  s.bind(server_addr)
+  
+  data, client = s.recvfrom(65535)
+  
+  client = TIPCSocket.unpack_sockaddr(client)
+  
+  p client
+  
+  puts "server: message received: #{data}"
+  
+  s.send("hello client!", 0, client)
+  
+  s.close
+
+Client:
+
+  require 'rubygems'
+  require 'tipcsocket'
+  
+  include TIPCSocket::Constants
+  
+  server_addr = TIPCName.new(18888, 17, TIPC_NODE_SCOPE)
+  
+  s = TIPCSocket.new(:rdm)
+  s.send("hello server!", 0, server_addr)
+  
+  msg = s.recv(65535)
+  
+  puts "client: received response: #{msg}"
+  
+  s.close
+
+Server Output:
+
+  $ ruby server.rb 
+  #<TIPCPortId:0xb79c89a4 @family=30, @ref=2292940796, @scope=0, @addrtype=3, @node=0>
+  server: message received: hello server!
+
+Client Output:
+
+  $ ruby client.rb 
+  client: received response: hello client!
+
+= More Examples
+
+See the demo/ directory for more examples.
+
+= Project Page
+
+http://rubyforge.org/projects/tipcsocket
+
+= Author
+
+Corey Burrows (mailto:corey.burrows@gmail.com)
+

data/Rakefile

@@ -0,0 +1,56 @@
+
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+require 'rake/clean'
+require 'rake/rdoctask'
+
+NAME           = 'tipcsocket'
+VERS           = '0.1'
+RUBYFORGE_USER = "burrows"
+WWW            = "#{RUBYFORGE_USER}@rubyforge.org:/var/www/gforge-projects/#{NAME}/"
+
+RDOC_MAIN = "README"
+
+spec = Gem::Specification.new do |s|
+  s.name             = NAME
+  s.version          = VERS
+  s.author           = "Corey Burrows"
+  s.email            = "corey.burrows@gmail.com"
+  s.platform         = Gem::Platform::RUBY
+  s.summary          = "Ruby bindings for the TIPC socket API."
+  s.files            = %w{README CHANGELOG LICENSE Rakefile} +
+                       Dir.glob("lib/**/*.{rb}") +
+                       Dir.glob("test/**/*.rb") +
+                       Dir.glob("demo/**/*.rb")
+  s.require_path     = "lib"
+  s.autorequire      = "tipcsocket"
+  #s.test_file        = ""
+  s.has_rdoc         = true
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = RDOC_MAIN
+  rd.rdoc_files.include(RDOC_MAIN, "lib/**/*.rb", "CHANGELOG", "LICENSE")
+  rd.options << "--all"
+end
+
+CLEAN += FileList["ext/**/*.o", "ext/**/*.so", "ext/**/*.bundle", "ext/**/mkmf.log"]
+
+task :test => :build do
+end
+
+task :install do
+  name = "#{NAME}-#{VERS}.gem"
+  sh %{rake pkg/#{name}}
+  sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall do
+  sh %{sudo gem uninstall #{NAME}}
+end
+

data/demo/hello_world/client.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'tipcsocket'
+include TIPCSocket::Constants
+
+puts "****** TIPC client hello world program started ******\n"
+
+$server_type = 18888
+$server_inst = 17
+
+def wait_for_server(name, wait)
+  puts "Client: waiting for server #{name.type}, #{name.instance}..."
+
+  topsrv = TIPCName.new(TIPC_TOP_SRV, TIPC_TOP_SRV)
+  subscr = TIPCSubscr.new(
+    TIPCNameSeq.new(name.type, name.instance, name.instance),
+    wait,
+    TIPC_SUB_SERVICE)
+
+  s = TIPCSocket.new(:seqpacket)
+  s.connect(topsrv)
+  s.send(subscr.pack, 0)
+
+  rsp = s.recv(65535)
+
+  event = TIPCEvent.unpack(rsp)
+
+  if event.event != TIPC_PUBLISHED
+    puts "Client: server #{name.type}, #{name.instance} not published within #{wait/1000} [s]"
+    exit 1
+  end
+
+  s.close
+end
+
+s = TIPCSocket.new(:rdm)
+
+# send a message to the server
+server_addr = TIPCName.new($server_type, $server_inst, TIPC_NODE_SCOPE)
+
+wait_for_server(server_addr, 10000)
+
+s.send("Hello World", 0, server_addr)
+
+# wait for a response
+msg = s.recv(65535)
+
+puts "Client: Received response: #{msg}"
+
+s.close
+
+puts "****** TIPC client hello program finished ******"
+

data/demo/hello_world/server.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'tipcsocket'
+include TIPCSocket::Constants
+
+$server_type = 18888
+$server_inst = 17
+
+puts "****** TIPC server hello world program started ******\n\n"
+
+server_addr = TIPCNameSeq.new($server_type, $server_inst, $server_inst, TIPC_ZONE_SCOPE)
+
+s = TIPCSocket.new(:rdm)
+s.bind(server_addr)
+
+data, client = s.recvfrom(65535)
+
+client = TIPCSocket.unpack_sockaddr(client)
+
+puts "Server: Message received: #{data} !"
+
+s.send("Uh ?", 0, client)
+
+s.close
+
+puts "\n****** TIPC server hello program finished ******"
+

data/demo/stream_demo/client.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'tipcsocket'
+include TIPCSocket::Constants
+
+$server_type = 8888
+$server_inst = 17
+
+$buf_size    = 2000
+$msg_size    = 80
+
+def wait_for_server(name, wait)
+  puts "Client: waiting for server #{name.type}, #{name.instance}..."
+
+  topsrv = TIPCName.new(TIPC_TOP_SRV, TIPC_TOP_SRV)
+  subscr = TIPCSubscr.new(
+    TIPCNameSeq.new(name.type, name.instance, name.instance),
+    wait,
+    TIPC_SUB_SERVICE)
+
+  s = TIPCSocket.new(:seqpacket)
+  s.connect(topsrv)
+  s.send(subscr.pack, 0)
+
+  rsp = s.recv(65535)
+
+  event = TIPCEvent.unpack(rsp)
+
+  if event.event != TIPC_PUBLISHED
+    puts "Client: server #{name.type}, #{name.instance} not published within #{wait/1000} [s]"
+    exit 1
+  end
+
+  s.close
+end
+
+puts "****** TIPC stream demo client started ******"
+
+server_addr = TIPCName.new($server_type, $server_inst)
+
+wait_for_server(server_addr, 10000)
+
+s = TIPCSocket.new(:stream)
+
+begin
+  s.connect(server_addr)
+rescue Exception => e
+  puts "Client: connect failed: #{e}"
+  exit 1
+end
+
+# create buffer containing numerous (size,data) records
+
+tot_size = 0
+rec_size = 1
+rec_num  = 0
+buf      = ""
+
+while tot_size + 4 + rec_size < $buf_size
+  rec_num += 1
+  buf += [rec_size].pack("N")
+  rec_size.times do
+    buf += [rec_size].pack("C")
+  end
+  puts "Client: creating record #{rec_num} of size #{rec_size} bytes"
+
+  tot_size += (4 + rec_size)
+  rec_size = (rec_size + 147) & 0xFF;
+
+  rec_size = 1 if (rec_size == 0) # record size must me 1-255 bytes
+end
+
+# now send records using messages that break record boundaries
+
+puts "Client: sending records using #{$msg_size} byte messages"
+
+sent_size = 0
+while sent_size < tot_size
+  if (sent_size + $msg_size) <= tot_size
+    msg_size = $msg_size
+  else
+    msg_size = (tot_size - sent_size)
+  end
+
+  if (0 > s.send(buf[sent_size, msg_size], 0))
+    puts "Client: failed to send"
+    exit 1
+  end
+
+  sent_size += msg_size
+end
+
+# now grab set of one-byte client acknowledgements all at once
+
+puts "Client: waiting for server acknowledgements"
+rsp = s.recv(rec_num, Socket::MSG_WAITALL)
+if rsp.length != rec_num
+  puts "Client: acknowledge error 1"
+  exit 1
+end
+
+rsp = nil
+begin
+  rsp = s.recv_nonblock(1)
+rescue Errno::EAGAIN => e
+end
+
+if rsp
+  puts "Client: acknowledge error 2"
+  exit 1
+end
+
+puts "Client: received #{rec_num} acknowledgements"
+
+s.shutdown(Socket::SHUT_RDWR)
+s.close
+
+puts "****** TIPC stream demo client finished ******"
+exit 0

data/demo/stream_demo/server.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'tipcsocket'
+include TIPCSocket::Constants
+
+$server_type  = 8888
+$server_inst  = 17
+
+puts "****** TIPC stream demo server started ******"
+
+listener = TIPCSocket.new(:stream)
+
+server_addr = TIPCNameSeq.new($server_type, $server_inst, $server_inst, TIPC_ZONE_SCOPE)
+
+listener.bind(server_addr)
+listener.listen(0)
+
+peer, peer_addr = listener.accept
+
+rec_num = 0
+
+loop do
+  begin
+    puts "calling peer.recv..."
+    msg = peer.recv(4, Socket::MSG_WAITALL)
+    puts "recieved #{msg.length} bytes"
+  rescue Exception => e
+    puts "Server: client terminated abnormally: #{e}"
+    exit 1
+  end
+
+  if msg.length == 0
+    puts "Server: client terminated normally"
+    break
+  end
+
+  rec_num += 1
+
+  rec_size = msg.unpack("N")[0]
+  puts "Server: receiving record #{rec_num} of #{rec_size} bytes"
+
+  msg = peer.recv(rec_size, Socket::MSG_WAITALL)
+
+  if msg.length != rec_size
+    puts "Server: receive error, got #{msg.length} bytes"    
+    exit 1
+  end
+
+  msg.each_byte do |b|
+    if b != rec_size
+      puts "Server: record content error"
+      exit 1
+    end
+  end
+
+  puts "Server: record #{rec_num} received"
+
+  # send 1 byte acknowledgement (value is irrelevant)
+  peer.send("X", 0)
+
+  puts "Server: record #{rec_num} acknowledged"
+end
+
+puts "****** TIPC stream demo server finished ******"
+
+exit 0
+

data/lib/tipcsocket.rb

@@ -0,0 +1,514 @@
+
+require 'socket'
+
+module Socket::Constants
+  AF_TIPC  = 30
+  PF_TIPC  = AF_TIPC
+  SOL_TIPC = 271
+end
+
+# Represents a TIPC port identifier.
+#
+# From the {TIPC Programmer's Guide}[http://tipc.sourceforge.net/doc/Programmers_Guide.txt]:
+#
+#   Each port in a TIPC network has a unique "port identifier" or "port ID", 
+#   which is typically denoted as <Z.C.N:ref>.  The port ID is assigned 
+#   automatically by TIPC when the port is created, and consists of the 32-bit 
+#   network address of the port's node and a 32-bit reference value.  The 
+#   reference value is guaranteed to be unique on a per-node basis and will not 
+#   be reused for a long time once the port ceases to exist. 
+class TIPCPortId
+  attr_reader   :family, :addrtype
+  attr_accessor :ref, :node, :scope
+
+  # Create a new TIPCPortId instance.
+  #
+  # === Parameters
+  #   * ref   - 32 bit reference value
+  #   * node  - 32 bit network address of the port's node
+  #   * scope - the scope (zone, cluster, or node) to use when packing this port
+  #             id as a TIPC address (optional)
+  def initialize(ref, node, scope = TIPCSocket::Constants::TIPC_NODE_SCOPE)
+    @family   = Socket::Constants::AF_TIPC
+    @addrtype = TIPCSocket::Constants::TIPC_ADDR_ID
+    @ref      = ref
+    @node     = node
+    @scope    = scope
+  end
+
+  # Pack an instance of a TIPCPortId as a 16 byte TIPC network address suitable
+  # for passing to one of the standard Socket methods (connect, send, etc.).
+  #
+  # Produces a 16 byte binary string with the following format:
+  #   * family   - unsigned short (2 bytes)
+  #   * addrtype - unsigned char  (1 byte)
+  #   * scope    - signed char    (1 byte)
+  #   * ref      - uint32         (4 bytes)
+  #   * node     - uint32         (4 bytes)
+  #   * padding  - uint32         (4 bytes)
+  def pack_addr
+    [
+      self.family,
+      self.addrtype,
+      self.scope,
+      self.ref,
+      self.node,
+      0
+    ].pack("SCcL3")
+  end
+
+  # Pack an instance of a TIPCPortId.
+  #
+  # Produces an 8 byte string with the following format:
+  #   * ref  - uint32 (4 bytes)
+  #   * node - uint32 (4 bytes)
+  def pack
+    [
+      self.ref,
+      self.node,
+    ].pack("L2")
+  end
+
+  # Create a new TIPCPortId instance from a 16 byte binary string containing a
+  # TIPC address.
+  #
+  # === Parameters
+  #   * bytes - 16 byte string containing TIPC address
+  def self.unpack_addr(bytes)
+    data = bytes.unpack("SCcL3")
+    self.new(data[3], data[4], data[2])
+  end
+
+  # Create a new TIPCPortId instance from an 8 byte binary string containing 
+  # a TIPC port indentifier.
+  #
+  # === Parameters
+  #   * bytes - 8 byte string containing TIPC port identifier
+  def self.unpack(bytes)
+    data = bytes.unpack("L2")
+    self.new(data[0], data[1])
+  end
+end
+
+# Represents a TIPC name address of the form <type, instance>.
+#
+# From the {TIPC Programmer's Guide}[http://tipc.sourceforge.net/doc/Programmers_Guide.txt]:
+#
+#   The basic unit of functional addressing within TIPC is the "port name", which 
+#   is typically denoted as {type,instance}.  A port name consists of a 32-bit 
+#   type field and a 32-bit instance field, both of which are chosen by the 
+#   application.  Typically, the type field is used to indicate the class of 
+#   service provided by the port, while the instance field can be used as a sub-
+#   class indicator.
+class TIPCName
+  attr_reader   :family, :addrtype
+  attr_accessor :type, :instance, :scope, :domain
+
+  # Create a new TIPCName instance.
+  #
+  # === Parameters
+  #   * type     - arbitrary 32 bit type value
+  #   * instance - arbitrary 32 bit instance value
+  #   * scope    - the scope (zone, cluster, or node) to use when packing
+  #                this name as a TIPC address (optional)
+  #   * domain   - indicates the search domain used during the name lookup
+  #                process (optional)
+  def initialize(type, instance, scope = TIPCSocket::Constants::TIPC_NODE_SCOPE, domain = 0)
+    @family   = Socket::Constants::AF_TIPC
+    @addrtype = TIPCSocket::Constants::TIPC_ADDR_NAME
+    @type     = type
+    @instance = instance
+    @scope    = scope
+    @domain   = 0
+  end
+
+  # Pack an instance of a TIPCName as a 16 byte TIPC network address suitable
+  # for passing to one of the standard Socket methods (connect, send, etc.).
+  #
+  # Produces a 16 byte binary string with the following format:
+  #   * family   - unsigned short (2 bytes)
+  #   * addrtype - unsigned char  (1 byte)
+  #   * scope    - signed char    (1 byte)
+  #   * type     - uint32         (4 bytes)
+  #   * instance - uint32         (4 bytes)
+  #   * domain   - uint32         (4 bytes)
+  def pack_addr
+    [
+      self.family,
+      self.addrtype,
+      self.scope,
+      self.type,
+      self.instance,
+      self.domain
+    ].pack("SCcL3")
+  end
+
+  # Pack an instance of a TIPCName.
+  #
+  # Produces an 8 byte string with the following format:
+  #   * type     - uint32 (4 bytes)
+  #   * instance - uint32 (4 bytes)
+  def pack
+    [
+      self.type,
+      self.instance
+    ].pack("L2")
+  end
+
+  # Create a new TIPCName instance from a 16 byte binary string containing a
+  # TIPC address.
+  #
+  # === Parameters
+  #   * bytes - 16 byte string containing TIPC address
+  def self.unpack_addr(bytes)
+    data = bytes.unpack("SCcL3")
+    self.new(data[3], data[4], data[2], data[5])
+  end
+
+  # Create a new TIPCName instance from an 8 byte binary string containing 
+  # a TIPC name.
+  #
+  # === Parameters
+  #   * bytes - 8 byte string containing TIPC name
+  def self.unpack(bytes)
+    data = bytes.unpack("L2")
+    self.new(data[0], data[1])
+  end
+end
+
+# Represents a TIPC port name sequence address of the form
+# <type, lower bound, upper bound>.
+#
+# From the {TIPC Programmer's Guide}[http://tipc.sourceforge.net/doc/Programmers_Guide.txt]:
+#
+#   A port name sequence consists of a 32-bit type field and a pair of 32-bit
+#   instance fields, and represents the set of port names from {type,lower bound}
+#   through {type,upper bound}, inclusive.  The lower bound of a name sequence
+#   cannot be larger than the upper bound.
+class TIPCNameSeq
+  attr_reader   :family, :addrtype
+  attr_accessor :type, :lower, :upper, :scope
+
+  # Create a new TIPCNameSeq instance.
+  #
+  # === Parameters
+  #   * type  - arbitrary 32 bit type value
+  #   * lower - 32-bit lower bound of the name sequence
+  #   * upper - 32-bit upper bound of the name sequence
+  #   * scope - the scope (zone, cluster, or node) to use when packing
+  #                this name as a TIPC address (optional)
+  def initialize(type, lower, upper, scope = TIPCSocket::Constants::TIPC_NODE_SCOPE)
+    @family   = Socket::Constants::AF_TIPC
+    @addrtype = TIPCSocket::Constants::TIPC_ADDR_NAMESEQ
+    @type     = type
+    @lower    = lower
+    @upper    = upper
+    @scope    = scope
+  end
+
+  # Pack an instance of a TIPCNameSeq as a 16 byte TIPC network address suitable
+  # for passing to one of the standard Socket methods (connect, send, etc.).
+  #
+  # Produces a 16 byte binary string with the following format:
+  #   * family   - unsigned short (2 bytes)
+  #   * addrtype - unsigned char  (1 byte)
+  #   * scope    - signed char    (1 byte)
+  #   * type     - uint32         (4 bytes)
+  #   * lower    - uint32         (4 bytes)
+  #   * upper    - uint32         (4 bytes)
+  def pack_addr
+    [
+      self.family,
+      self.addrtype,
+      self.scope,
+      self.type,
+      self.lower,
+      self.upper
+    ].pack("SCcL3")
+  end
+
+  # Pack an instance of a TIPCNameSeq.
+  #
+  # Produces an 12 byte string with the following format:
+  #   * type  - uint32 (4 bytes)
+  #   * lower - uint32 (4 bytes)
+  #   * upper - uint32 (4 bytes)
+  def pack
+    [
+      self.type,
+      self.lower,
+      self.upper
+    ].pack("L3")
+  end
+
+  # Create a new TIPCNameSeq instance from a 16 byte binary string containing a
+  # TIPC address.
+  #
+  # === Parameters
+  #   * bytes - 16 byte string containing TIPC address
+  def self.unpack_addr(bytes)
+    data = bytes.unpack("SCcL3")
+    self.new(data[3], data[4], data[5], data[2])
+  end
+
+  # Create a new TIPCNameSeq instance from a 12 byte binary string containing 
+  # a TIPC name sequence.
+  #
+  # === Parameters
+  #   * bytes - 12 byte string containing TIPC name sequence
+  def self.unpack(bytes)
+    data = bytes.unpack("L3")
+    self.new(data[0], data[1], data[2])
+  end
+end
+
+# Represents a TIPC subscription.
+#
+# From the {TIPC Programmer's Guide}[http://tipc.sourceforge.net/doc/Programmers_Guide.txt]:
+# 
+#   TIPC provides a network topology service that applications can use to receive
+#   information about what port names exist within the application's network zone.
+#   
+#   An application accesses the topology service by opening a message-based 
+#   connection to port name {1,1} and then sending "subscription" messages to the 
+#   topology service that indicate the port names of interest to the application; 
+#   in return, the topology service sends "event" messages to the application when 
+#   these names are published or withdrawn by ports within the network.
+class TIPCSubscr
+  attr_accessor :name_seq, :timeout, :filter, :usr_handle
+
+  # Create a new TIPCSubscr instance.
+  #
+  # === Parameters
+  #   * name_seq   - the port name sequence of interest, must be an instance of
+  #                  TIPCNameSeq
+  #   * timeout    - subscription timeout value in milliseconds, use the constant
+  #                  TIPC_WAIT_FOREVER to specify no timeout
+  #   * filter     - a bitmask containing one or more event filters, see below
+  #                  for a description of filter types
+  #   * usr_handle - 8 byte string that is application defined, this value is
+  #                  returned to the application as part of all events associated
+  #                  with the subscription event
+  #
+  # === Filter Types
+  #   * TIPC_SUB_PORTS   - causes the topology service to generate a TIPC_PUBLISHED
+  #                        event for each port name or port name sequence it finds
+  #                        that overlaps the specified port name sequence; a
+  #                        TIPC_WITHDRAWN event is issued each time a previously
+  #                        reported name becomes unavailable
+  #   * TIPC_SUB_SERVICE - causes the topology service to generate a single publish 
+  #                        event for the first port it finds with an overlapping
+  #                        name and a single withdraw event when the last such port
+  #                        becomes unavailable
+  #   * TIPC_SUB_CANCEL  - cancels and existing topology service subscription, all
+  #                        other parameters should match the original subscription
+  #                        request
+  def initialize(name_seq, timeout, filter, usr_handle = '')
+    @name_seq   = name_seq
+    @timeout    = timeout
+    @filter     = filter
+    @usr_handle = usr_handle
+  end
+
+  # Pack an instance of a TIPCSubscr.
+  #
+  # Produces a 28 byte string with the following format:
+  #   * name_seq             (12 bytes)
+  #   * timeout    - uint32  (4 bytes)
+  #   * filter     - uint32  (4 bytes)
+  #   * usr_handle - char[8] (8 bytes)
+  def pack
+    [
+      self.name_seq.pack,
+      self.timeout,
+      self.filter,
+      self.usr_handle
+    ].pack("a12L2a8")
+  end
+
+  # Create a new TIPCSubscr instance from a 28 byte binary string containing 
+  # a TIPC name sequence.
+  #
+  # === Parameters
+  #   * bytes - 28 byte string containing TIPC name sequence
+  def self.unpack(bytes)
+    data = bytes.unpack("a12L2a8")
+    self.new(TIPCNameSeq.unpack(data[0]), data[1], data[2], data[3])
+  end
+end
+
+# Represents a TIPC event message.
+#
+# TIPC event messages are returned by the TIPC topology server when subscribed
+# to events occur.
+class TIPCEvent
+  attr_accessor :event, :found_lower, :found_upper, :port, :subscr
+
+  # Create a new TIPCEvent instance.
+  #
+  # === Parameters
+  #   * event       - 32-bit event type, may be either TIPC_PUBLISHED, TIPC_WITHDRAWN,
+  #                   or TIPC_SUBSCR_TIMEOUT
+  #   * found_lower - 32-bit lower bound of the port name sequence that overlaps
+  #                   the name sequence specified by the subscription
+  #   * found_upper - 32-bit upper bound of the port name sequence that overlaps
+  #                   the name sequence specified by the subscription
+  #   * port        - an instance of TIPCPortId that represents the port ID of the
+  #                   associated port
+  #   * subscr      - an instance of TIPCSubscr that represents the subscription
+  #                   request associated with the event
+  def initialize(event, found_lower, found_upper, port, subscr)
+    @event       = event
+    @found_lower = found_lower
+    @found_upper = found_upper
+    @port        = port
+    @subscr      = subscr
+  end
+
+  # Pack an instance of a TIPCEvent.
+  #
+  # Produces an 48 byte string with the following format:
+  #   * event       - uint32 = 4
+  #   * found_lower - uint32 = 4
+  #   * found_upper - uint32 = 4
+  #   * port_id              = 8
+  #   * subscr               = 28
+  def pack
+    [
+      self.event,
+      self.found_lower,
+      self.found_upper,
+      port.pack,
+      subscr.pack
+    ].pack("L3a8a28")
+  end
+
+  # Create a new TIPCEvent instance from a 48 byte binary string containing a
+  # TIPC event.
+  #
+  # === Parameters
+  #   * bytes - 48 byte string containing TIPC address
+  def self.unpack(bytes)
+    data = bytes.unpack("L3a8a28")
+    self.new(data[0], data[1], data[2], TIPCPortId.unpack(data[3]),
+             TIPCSubscr.unpack(data[4]))
+  end
+end
+
+# Provides access to a TIPC[http://tipc.sourceforge.net] socket.  Subclass of
+# the standard ruby Socket class.
+class TIPCSocket < Socket
+  module Constants
+    # application accessible port name types
+    TIPC_CFG_SRV        = 0
+    TIPC_TOP_SRV        = 1
+    TIPC_RESERVED_TYPES = 64
+
+    # publication scopes when binding port names and port name sequences
+    TIPC_ZONE_SCOPE    = 1
+    TIPC_CLUSTER_SCOPE = 2
+    TIPC_NODE_SCOPE    = 3
+
+    # limiting values for messages
+    TIPC_MAX_USER_MSG_SIZE = 66000
+
+    # message importance levels
+    TIPC_LOW_IMPORTANCE      = 0
+    TIPC_MEDIUM_IMPORTANCE   = 1
+    TIPC_HIGH_IMPORTANCE     = 2
+    TIPC_CRITICAL_IMPORTANCE = 3
+
+    # message rejection/connection shutdown reasons
+    TIPC_OK            = 0
+    TIPC_ERR_NO_NAME   = 1
+    TIPC_ERR_NO_PORT   = 2
+    TIPC_ERR_NO_NODE   = 3
+    TIPC_ERR_OVERLOAD  = 4
+    TIPC_CONN_SHUTDOWN = 5
+
+    # topology subscription service definitions
+    TIPC_SUB_PORTS   = 0x01
+    TIPC_SUB_SERVICE = 0x02
+    TIPC_SUB_CANCEL  = 0x04
+
+    TIPC_WAIT_FOREVER = -1
+    
+    # address types
+    TIPC_ADDR_NAMESEQ  = 1
+    TIPC_ADDR_MCAST    = 1
+    TIPC_ADDR_NAME     = 2
+    TIPC_ADDR_ID       = 3
+
+    # events
+    TIPC_PUBLISHED      = 1
+    TIPC_WITHDRAWN      = 2
+    TIPC_SUBSCR_TIMEOUT = 3
+  end
+
+  # Create a new TIPCSocket instance from a 16 byte binary string containing a
+  # TIPC address.  Returns one of the following depending on the addrtype
+  # field: TIPCNameSeq, TIPCName, TIPCPortId.
+  #
+  # === Parameters
+  #   * bytes - 16 byte string containing TIPC address
+  def self.unpack_sockaddr(bytes)
+    family, addrtype = bytes.unpack("SC")
+
+    case
+    when addrtype == Constants::TIPC_ADDR_NAMESEQ
+      TIPCNameSeq.unpack_addr(bytes)
+    when addrtype == Constants::TIPC_ADDR_NAME
+      TIPCName.unpack_addr(bytes)
+    when addrtype == Constants::TIPC_ADDR_ID
+      TIPCPortId.unpack_addr(bytes)
+    else
+      raise ArgumentError, "invalid address type (#{addrtype})"
+    end
+  end
+
+  # Create a new instance of a TIPCSocket.
+  #
+  # === Parameters
+  #   - type: must be one of the following
+  #     * :stream      - for reliable connection-oriented byte streams
+  #     * :seqpacket   - for reliable connection-oriented messages
+  #     * :rdm         - for reliable connectionless messages
+  #     * :dgram       - for unreliable connectionless messages
+  #   - protocol: passed directly to Socket.new (optional)
+  def initialize(type, protocol = 0)
+    case type.to_s.downcase
+    when 'stream'
+      type = Socket::Constants::SOCK_STREAM
+    when 'seqpacket'
+      type = Socket::Constants::SOCK_SEQPACKET
+    when 'rdm'
+      type = Socket::Constants::SOCK_RDM
+    when 'dgram'
+      type = Socket::Constants::SOCK_DGRAM
+    else
+      raise TypeError, "invalid TIPC socket type (#{type})"
+    end
+
+    super(Socket::Constants::AF_TIPC, type, protocol) 
+  end
+
+  def send(msg, flags, tipc_addr = nil)
+    if tipc_addr
+      tipc_addr = tipc_addr.is_a?(String) ? tipc_addr : tipc_addr.pack_addr
+      super(msg, flags, tipc_addr)
+    else
+      super(msg, flags)
+    end
+  end
+
+  def bind(tipc_addr)
+    tipc_addr = tipc_addr.is_a?(String) ? tipc_addr : tipc_addr.pack_addr
+    super(tipc_addr)
+  end
+
+  def connect(tipc_addr)
+    tipc_addr = tipc_addr.is_a?(String) ? tipc_addr : tipc_addr.pack_addr
+    super(tipc_addr)
+  end
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: tipcsocket
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-01-14 00:00:00 -06:00
+summary: Ruby bindings for the TIPC socket API.
+require_paths: 
+- lib
+email: corey.burrows@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: tipcsocket
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Corey Burrows
+files: 
+- README
+- CHANGELOG
+- LICENSE
+- Rakefile
+- lib/tipcsocket.rb
+- demo/hello_world/client.rb
+- demo/hello_world/server.rb
+- demo/stream_demo/client.rb
+- demo/stream_demo/server.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+