net-proto 1.0.6 → 1.1.0

data/lib/net/proto.rb

@@ -0,0 +1,10 @@
+require 'rbconfig'
+
+case RbConfig::CONFIG['host_os']
+when /linux/i
+  require 'linux/net/proto'
+when /sunos|solaris/i
+  require 'sunos/net/proto'
+else
+  require 'generic/net/proto'
+end

data/lib/net/proto/common.rb

@@ -0,0 +1,37 @@
+require 'ffi'
+
+module Net
+  class Proto
+    extend FFI::Library
+
+    # The version of the net-proto library
+    VERSION = '1.1.0'
+
+    private_class_method :new
+
+    class ProtocolStruct < FFI::Struct
+      layout(
+        :p_name,    :string,
+        :p_aliases, :pointer,
+        :p_proto,   :int
+      )
+    end
+
+    class FFI::Pointer
+      def read_array_of_string
+        elements = []
+
+        loc = self
+
+        until ((element = loc.read_pointer).null?)
+          elements << element.read_string
+          loc += FFI::Type::POINTER.size
+        end
+
+        elements
+      end
+    end
+
+    ProtoStruct = Struct.new('ProtoStruct', :name, :aliases, :proto)
+  end
+end

data/lib/sunos/net/proto.rb

@@ -0,0 +1,134 @@
+require 'net/proto/common'
+
+# The Net module serves as a namespace only.
+module Net
+
+  # The Proto class serves as the base class for the various protocol methods.
+  class Proto
+    ffi_lib 'socket'
+
+    attach_function :setprotoent, [:int], :void
+    attach_function :endprotoent, [], :void
+    attach_function :getprotobyname_r, [:string, :pointer, :pointer, :int], :pointer
+    attach_function :getprotobynumber_r, [:int, :pointer, :pointer, :int], :pointer
+    attach_function :getprotoent_r, [:pointer, :pointer, :int], :pointer
+
+    private_class_method :setprotoent, :endprotoent, :getprotobyname_r
+    private_class_method :getprotobynumber_r, :getprotoent_r
+
+    public
+
+    # If given a protocol string, returns the corresponding number. If
+    # given a protocol number, returns the corresponding string.
+    #
+    # Returns nil if not found in either case.
+    #
+    # Examples:
+    #
+    #   Net::Proto.get_protocol('tcp') # => 6
+    #   Net::Proto.get_protocol(1)     # => 'icmp'
+    #
+    def self.get_protocol(argument)
+      if argument.is_a?(String)
+        getprotobyname(argument)
+      else
+        getprotobynumber(argument)
+      end
+    end
+
+    # Given a protocol string, returns the corresponding number, or nil if
+    # not found.
+    #
+    # Examples:
+    #
+    #    Net::Proto.getprotobyname('tcp')   # => 6
+    #    Net::Proto.getprotobyname('bogus') # => nil
+    #
+    def self.getprotobyname(protocol)
+      raise TypeError unless protocol.is_a?(String)
+
+      pptr = FFI::MemoryPointer.new(ProtocolStruct.size)
+      buff = FFI::MemoryPointer.new(:char, 1024)
+
+      begin
+        setprotoent(0)
+        ptr = getprotobyname_r(protocol, pptr, buff, buff.size)
+      ensure
+        endprotoent()
+      end
+
+      ptr.null? ? nil : ProtocolStruct.new(pptr)[:p_proto]
+    end
+
+    # Given a protocol number, returns the corresponding string, or nil if
+    # not found.
+    #
+    # Examples:
+    #
+    #   Net::Proto.getprotobynumber(6)   # => 'tcp'
+    #   Net::Proto.getprotobynumber(999) # => nil
+    #
+    def self.getprotobynumber(protocol)
+      raise TypeError unless protocol.is_a?(Integer)
+
+      pptr = FFI::MemoryPointer.new(ProtocolStruct.size)
+      buff = FFI::MemoryPointer.new(:char, 1024)
+
+      begin
+        setprotoent(0)
+        ptr = getprotobynumber_r(protocol, pptr, buff, buff.size)
+      ensure
+        endprotoent()
+      end
+
+      ptr.null? ? nil : ProtocolStruct.new(pptr)[:p_name]
+    end
+
+    # In block form, yields each entry from /etc/protocols as a struct of type
+    # Proto::ProtoStruct. In non-block form, returns an array of structs.
+    #
+    # The fields are 'name' (a string), 'aliases' (an array of strings,
+    # though often only one element), and 'proto' (a number).
+    #
+    # Example:
+    #
+    #   Net::Proto.getprotoent.each{ |prot|
+    #      p prot.name
+    #      p prot.aliases
+    #      p prot.proto
+    #   }
+    #
+    def self.getprotoent
+      structs = block_given? ? nil : []
+
+      pptr = FFI::MemoryPointer.new(ProtocolStruct.size)
+      buff = FFI::MemoryPointer.new(1024)
+
+      begin
+        setprotoent(0)
+
+        while ptr = getprotoent_r(pptr, buff, buff.size)
+          break if ptr.null?
+
+          ffi_struct = ProtocolStruct.new(pptr)
+
+          ruby_struct = ProtoStruct.new(
+            ffi_struct[:p_name],
+            ffi_struct[:p_aliases].read_array_of_string,
+            ffi_struct[:p_proto]
+          ).freeze
+
+          if block_given?
+            yield ruby_struct
+          else
+            structs << ruby_struct
+          end
+        end
+      ensure
+        endprotoent
+      end
+
+      structs
+    end
+  end
+end

data/net-proto.gemspec

@@ -1,11 +1,8 @@
 require 'rubygems'
 
-# To build a regular gem => rake build_gem
-# To build a binary gem  => rake build_binary_gem
-
 Gem::Specification.new do |gem|
   gem.name       = 'net-proto'
-  gem.version    = '1.0.6'
+  gem.version    = '1.1.0'
   gem.author     = 'Daniel J. Berger'
   gem.license    = 'Artistic 2.0'
   gem.email      = 'djberg96@gmail.com'
@@ -13,13 +10,13 @@ Gem::Specification.new do |gem|
   gem.platform   = Gem::Platform::RUBY
   gem.summary    = 'A Ruby interface for determining protocol information'
   gem.test_file  = 'test/test_net_proto.rb'
-  gem.extensions = ['ext/extconf.rb']
   gem.files      = Dir['**/*'].reject{ |f| f.include?('git') }
 
   gem.rubyforge_project = 'sysutils'
   gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/netproto.txt']
 
-  gem.add_development_dependency('test-unit', '>= 2.1.1')
+  gem.add_dependency('ffi', '>= 1.0.0')
+  gem.add_development_dependency('test-unit', '>= 2.2.0')
 
   gem.description = <<-EOF
     The net-proto library provides an interface for get protocol information

data/test/test_net_proto.rb

@@ -6,7 +6,6 @@
 ###########################################################################
 require 'rubygems'
 gem 'test-unit'
-
 require 'net/proto'
 require 'test/unit'
 
@@ -14,22 +13,39 @@ class TC_Net_Proto < Test::Unit::TestCase
 
   # These were the protocols listed in my own /etc/protocols file on Solaris 9
   def self.startup
-    @@windows = Config::CONFIG['host_os'] =~ /win32|msdos|mswin|cygwin|mingw/i
-
     @@protocols = %w/
       ip icmp igmp ggp ipip tcp cbt egp igp pup udp mux hmp
       xns-idp rdp idpr idpr-cmtp sdrp idrp rsvp gre
       mobile ospf pim ipcomp vrrp sctp hopopt ipv6
       ipv6-route ipv6-frag esp ah ipv6-icmp ipv6-nonxt ipv6-opts
     /
+
+    @@windows = File::ALT_SEPARATOR
   end
 
   def setup
     @protoent = nil
   end
 
-  test "version number returns expected value" do
-    assert_equal('1.0.6', Net::Proto::VERSION)
+  test "version number is set to expected value" do
+    assert_equal('1.1.0', Net::Proto::VERSION)
+  end
+
+  test "get_protocol method basic functionality" do
+    assert_respond_to(Net::Proto, :get_protocol)
+  end
+
+  test "get_protocol method accepts a string or a number" do
+    assert_nothing_raised{ Net::Proto.get_protocol(1) }
+    assert_nothing_raised{ Net::Proto.get_protocol('tcp') }
+  end
+
+  test "get_protocol returns nil if protocol not found" do
+    assert_nil(Net::Proto.get_protocol(9999999))
+  end
+
+  test "get_protocol fails if an invalid type is passed" do
+    assert_raise(TypeError){ Net::Proto.get_protocol([]) }
   end
 
   test "getprotobynumber basic functionality" do
@@ -43,94 +59,85 @@ class TC_Net_Proto < Test::Unit::TestCase
     assert_equal('tcp', Net::Proto.getprotobynumber(6))
   end
 
-  test "getprotobynumber returns nil if the protocol cannot be found" do
+  test "getprotobynumber returns nil if not found" do
     assert_equal(nil, Net::Proto.getprotobynumber(9999999))
     assert_equal(nil, Net::Proto.getprotobynumber(-1))
   end
 
-  test "getprotobynumber requires a numeric argument" do
+  test "getprotobynumber raises a TypeError if a non-numeric arg is used" do
     assert_raise(TypeError){ Net::Proto.getprotobynumber('foo') }
     assert_raise(TypeError){ Net::Proto.getprotobynumber(nil) }
   end
 
-  test "getprotobyname basic functionality" do
+  test "getprotobyname method basic functionality" do
     assert_respond_to(Net::Proto, :getprotobyname)
     @@protocols.each{ |n| assert_nothing_raised{ Net::Proto.getprotobyname(n) } }
-    assert_kind_of(Fixnum, Net::Proto.getprotobyname('tcp'))
   end
 
-  test "getprotobyname returns expected result" do
+  test "getprotobyname returns the expected result" do
     assert_equal(1, Net::Proto.getprotobyname('icmp'))
     assert_equal(6, Net::Proto.getprotobyname('tcp'))
   end
 
-  test "getprotobyname returns nil if the protocol cannot be found" do
-    assert_equal(nil, Net::Proto.getprotobyname('foo'))
-    assert_equal(nil, Net::Proto.getprotobyname('tcpx'))
-    assert_equal(nil, Net::Proto.getprotobyname(''))
+  test "getprotobyname returns nil if the protocol is not found" do
+    assert_nil(Net::Proto.getprotobyname('foo'))
+    assert_nil(Net::Proto.getprotobyname('tcpx'))
+    assert_nil(Net::Proto.getprotobyname(''))
   end
 
-  test "getprotobyname requires a string argument" do
+  test "getprotobyname raises a TypeError if an invalid arg is passed" do
     assert_raises(TypeError){ Net::Proto.getprotobyname(1) }
-    assert_raises(TypeError){ Net::Proto.getprotobyname(nil) }        
+    assert_raises(TypeError){ Net::Proto.getprotobyname(nil) }
   end
 
   test "getprotoent basic functionality" do
-    omit_if(@@windows, 'Skipped on MS Windows')
-    assert_respond_to(Net::Proto, :getprotoent)    
+    omit_if(@@windows, 'getprotoent tests skipped on MS Windows')
+    assert_respond_to(Net::Proto, :getprotoent)
     assert_nothing_raised{ Net::Proto.getprotoent }
-  end
-
-  test "getprotoent returns an array if no block is provided" do
-    omit_if(@@windows, 'Skipped on MS Windows')
     assert_kind_of(Array, Net::Proto.getprotoent)
   end
 
-  test "getprotoent accepts a block" do
-    omit_if(@@windows, 'Skipped on MS Windows')
-    assert_nothing_raised{ Net::Proto.getprotoent{} }
-    assert_nil(Net::Proto.getprotoent{})
-  end
-
-  test "getprotoent returns an array of structs" do
-    omit_if(@@windows, 'Skipped on MS Windows')
+  test "getprotoent method returns the expected results" do
+    omit_if(@@windows, 'getprotoent tests skipped on MS Windows')
     assert_kind_of(Struct::ProtoStruct, Net::Proto.getprotoent.first)
+    assert_nil(Net::Proto.getprotoent{})
   end
 
-  test "structs returned by getprotoent contain specific members" do
-    omit_if(@@windows, 'Skipped on MS Windows')
+  test "struct returned by getprotoent method contains the expected data" do
+    omit_if(@@windows, 'getprotoent tests skipped on MS Windows')
     @protoent = Net::Proto.getprotoent.first
     assert_equal(['name', 'aliases', 'proto'], @protoent.members)
-  end
-
-  test "struct members are of a specific type" do
-    omit_if(@@windows, 'Skipped on MS Windows')
-    @protoent = Net::Proto.getprotoent.first
     assert_kind_of(String, @protoent.name)
     assert_kind_of(Array, @protoent.aliases)
     assert_kind_of(Integer, @protoent.proto)
   end
 
-  test "aliases struct member returns an array of strings" do
-    omit_if(@@windows, 'Skipped on MS Windows')
+  test "all members of the aliases struct member are strings" do
+    omit_if(@@windows, 'getprotoent tests on MS Windows')
     @protoent = Net::Proto.getprotoent.first
     assert_true(@protoent.aliases.all?{ |e| e.is_a?(String) })
   end
 
-  test "the structs returned by getprotoent are frozen" do
-    omit_if(@@windows, 'Skipped on MS Windows')
+  test "struct returned by getprotoent method is frozen" do
+    omit_if(@@windows, 'getprotoent tests skipped on MS Windows')
     @protoent = Net::Proto.getprotoent.first
     assert_true(@protoent.frozen?)
   end
-   
-  test "there is no constructor for the Proto class" do
-    assert_raise(NoMethodError){ Net::Proto.new }      
+
+  test "there is no constructor" do
+    assert_raise(NoMethodError){ Net::Proto.new }
+  end
+
+  test "ffi functions are private" do
+    methods = Net::Proto.methods(false).map{ |m| m.to_sym }
+    assert_false(methods.include?(:setprotoent))
+    assert_false(methods.include?(:endprotoent))
   end
 
   def teardown
     @protoent = nil
   end
-   
+
   def self.shutdown
     @@protocols = nil
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: net-proto
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 6
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors: 
 - Daniel J. Berger
@@ -15,52 +15,65 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-22 00:00:00 -06:00
-default_executable: 
+date: 2012-01-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: test-unit
+  name: ffi
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 23
         segments: 
-        - 2
         - 1
-        - 1
-        version: 2.1.1
-  type: :development
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        - 0
+        version: 2.2.0
+  type: :development
+  version_requirements: *id002
 description: "    The net-proto library provides an interface for get protocol information\n    by name or by number. It can also iterate over the list of protocol\n    entries defined on your system.\n"
 email: djberg96@gmail.com
 executables: []
 
-extensions: 
-- ext/extconf.rb
+extensions: []
+
 extra_rdoc_files: 
 - CHANGES
 - README
 - MANIFEST
 - doc/netproto.txt
 files: 
-- Rakefile
-- README
-- doc/netproto.txt
-- net-proto.gemspec
 - CHANGES
+- doc/netproto.txt
 - examples/example_net_proto.rb
-- test/test_net_proto.rb
+- lib/generic/net/proto.rb
+- lib/linux/net/proto.rb
+- lib/net/proto/common.rb
+- lib/net/proto.rb
+- lib/sunos/net/proto.rb
 - MANIFEST
-- ext/extconf.rb
-- ext/version.h
-- ext/generic/generic.c
-- ext/linux/linux.c
-- ext/sunos/sunos.c
-- ext/windows/windows.c
-has_rdoc: true
+- net-proto.gemspec
+- Rakefile
+- README
+- test/test_net_proto.rb
 homepage: http://www.rubyforge.org/projects/sysutils
 licenses: 
 - Artistic 2.0
@@ -90,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: sysutils
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A Ruby interface for determining protocol information