net-ping 2.1.0-universal-linux

data/lib/net/ping/wmi.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), 'ping')
+require 'win32ole'
+
+# The Net module serves as a namespace only.
+#
+module Net
+   
+   # The Ping::WMI class encapsulates the Win32_PingStatus WMI class for
+   # MS Windows.
+   #
+   class Ping::WMI < Ping
+
+      PingStatus = Struct.new(
+         'PingStatus',
+         :address,
+         :buffer_size,
+         :no_fragmentation,
+         :primary_address_resolution_status,
+         :protocol_address,
+         :protocol_address_resolved,
+         :record_route,
+         :reply_inconsistency,
+         :reply_size,
+         :resolve_address_names,
+         :response_time,
+         :response_time_to_live,
+         :route_record,
+         :route_record_resolved,
+         :source_route,
+         :source_route_type,
+         :status_code,
+         :timeout,
+         :timestamp_record,
+         :timestamp_record_address,
+         :timestamp_record_address_resolved,
+         :timestamp_route,
+         :time_to_live,
+         :type_of_service
+      )
+
+      # Unlike the ping method for other Ping subclasses, this version returns
+      # a PingStatus struct which contains various bits of information about
+      # the results of the ping itself, such as response time.
+      #
+      # In addition, this version allows you to pass certain options that are
+      # then passed on to the underlying WQL query. See the MSDN documentation
+      # on Win32_PingStatus for details.
+      #
+      # Examples:
+      #
+      #  # Ping with no options
+      #  Ping::WMI.ping('www.perl.com')
+      #
+      #  # Ping with options
+      #  Ping::WMI.ping('www.perl.com', :BufferSize => 64, :NoFragmentation => true)
+      #--
+      # The PingStatus struct is a wrapper for the Win32_PingStatus WMI class.
+      #
+      def ping(host = @host, options = {})
+         super(host)
+
+         lhost = Socket.gethostname
+
+         cs = "winmgmts:{impersonationLevel=impersonate}!//#{lhost}/root/cimv2"
+         wmi = WIN32OLE.connect(cs)
+
+         query = "select * from win32_pingstatus where address = '#{host}'"
+
+         unless options.empty?
+            options.each{ |key, value|
+               if value.is_a?(String)
+                  query << " and #{key} = '#{value}'"
+               else
+                  query << " and #{key} = #{value}"
+               end
+            }
+         end
+
+         status = Struct::PingStatus.new
+
+         wmi.execquery(query).each{ |obj|
+            status.address                           = obj.Address
+            status.buffer_size                       = obj.BufferSize
+            status.no_fragmentation                  = obj.NoFragmentation
+            status.primary_address_resolution_status = obj.PrimaryAddressResolutionStatus
+            status.protocol_address                  = obj.ProtocolAddress
+            status.protocol_address_resolved         = obj.ProtocolAddressResolved
+            status.record_route                      = obj.RecordRoute 
+            status.reply_inconsistency               = obj.ReplyInconsistency
+            status.reply_size                        = obj.ReplySize
+            status.resolve_address_names             = obj.ResolveAddressNames
+            status.response_time                     = obj.ResponseTime
+            status.response_time_to_live             = obj.ResponseTimeToLive
+            status.route_record                      = obj.RouteRecord
+            status.route_record_resolved             = obj.RouteRecordResolved
+            status.source_route                      = obj.SourceRoute
+            status.source_route_type                 = obj.SourceRouteType
+            status.status_code                       = obj.StatusCode
+            status.timeout                           = obj.Timeout
+            status.timestamp_record                  = obj.TimeStampRecord
+            status.timestamp_record_address          = obj.TimeStampRecordAddress
+            status.timestamp_record_address_resolved = obj.TimeStampRecordAddressResolved
+            status.timestamp_route                   = obj.TimeStampRoute
+            status.time_to_live                      = obj.TimeToLive
+            status.type_of_service                   = obj.TypeOfService
+         }
+
+         status.freeze # Read-only data
+      end      
+
+      # Unlike Net::Ping::WMI#ping, this method returns true or false to
+      # indicate whether or not the ping was successful.
+      #
+      def ping?(host = @host, options = {})
+         ping(host, options).status_code == 0
+      end
+   end   
+end

data/lib/net/ping.rb

@@ -0,0 +1,24 @@
+# By doing a "require 'net/ping'" you are requiring every subclass.  If you
+# want to require a specific ping type only, do "require 'net/ping/tcp'",
+# for example.
+#
+require 'rbconfig'
+
+require_relative 'ping/tcp'
+require_relative 'ping/udp'
+require_relative 'ping/icmp'
+require_relative 'ping/external'
+require_relative 'ping/http'
+
+RbConfig = Config unless Object.const_defined?(:RbConfig)
+
+begin
+  `busybox`
+  RbConfig::CONFIG['busybox'] = true
+rescue Errno::ENOENT
+  RbConfig::CONFIG['busybox'] = false
+end
+
+if File::ALT_SEPARATOR
+  require_relative 'ping/wmi'
+end

data/net-ping-universal-linux.gemspec

@@ -0,0 +1,4 @@
+spec = Gem::Specification.load('net-ping.gemspec').dup
+spec.platform = Gem::Platform.new(['universal', 'linux'])
+spec.add_dependency('cap2', '>= 0.2.2')
+spec

data/net-ping-universal-mingw-ucrt.gemspec

@@ -0,0 +1,7 @@
+spec = Gem::Specification.load('net-ping.gemspec').dup
+spec.platform = Gem::Platform.new(['universal', 'mingw-ucrt'])
+spec.add_dependency('win32-security', '>= 0.2.0')
+
+# No longer a default gem as of Ruby 4.0. Used by the WMI ping class.
+spec.add_dependency('win32ole', '>= 1.8.8')
+spec

data/net-ping.gemspec

@@ -0,0 +1,36 @@
+require_relative "lib/net/ping/version"
+
+Gem::Specification.new do |spec|
+  spec.name      = 'net-ping'
+  spec.version   = Net::Ping::VERSION
+  spec.license   = 'Artistic 2.0'
+  spec.author    = 'Chris Chernesky'
+  spec.email     = 'chris.netping@tinderglow.com'
+  spec.homepage  = 'https://github.com/chernesk/net-ping'
+  spec.summary   = 'A ping interface for Ruby.'
+  spec.test_file = 'test/test_net_ping.rb'
+  spec.files     = Dir['**/*'].reject { |f| f.include?('git') || File.extname(f) == '.gem' }
+  spec.metadata = {
+    'bug_tracker_uri' => "#{spec.homepage}/issues",
+    'changelog_uri' => "#{spec.homepage}/blob/master/CHANGES",
+    'documentation_uri' => "https://www.rubydoc.info/gems/#{spec.name}",
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage
+  }
+
+  spec.extra_rdoc_files  = ['README.md', 'CHANGES', 'doc/ping.txt']
+
+  # The TCP Ping class requires this for non-blocking sockets.
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.add_development_dependency('test-unit', '>= 0')
+  spec.add_development_dependency('webmock', '>= 0')
+  spec.add_development_dependency('rake', '>= 0')
+  spec.add_development_dependency('pry-byebug', '>= 0')
+
+  spec.description = <<-EOF
+    The net-ping library provides a ping interface for Ruby. It includes
+    separate TCP, HTTP, LDAP, ICMP, UDP, WMI (for Windows) and external ping
+    classes.
+  EOF
+end

data/test/test_net_ping.rb

@@ -0,0 +1,44 @@
+######################################################################
+# test_net_ping.rb
+#
+# Test suite for all the Ping subclasses. Note that the Ping::ICMP
+# class test won't be run unless this is run as a privileged process.
+######################################################################
+require 'test_net_ping_external'
+require 'test_net_ping_gem_packaging'
+require 'test_net_ping_http'
+require 'test_net_ping_tcp'
+require 'test_net_ping_udp'
+
+if File::ALT_SEPARATOR
+  require 'win32/security'
+
+  if Win32::Security.elevated_security?
+    require 'test_net_ping_icmp'
+  end
+else
+  # If cap2 is availble, check if we are root, or our process has net_raw,
+  # then include ICMP tests
+  begin
+    require 'cap2'
+    current_process = Cap2.process
+    if Process.euid == 0 \
+      || current_process.permitted?(:net_raw) \
+      && current_process.enabled?(:net_raw)
+      require 'test_net_ping_icmp'
+    end
+  rescue LoadError
+    # If we don't have cap2, include ICMP tests if we are root
+    require 'test_net_ping_icmp' if Process.euid == 0
+  end
+end
+
+if File::ALT_SEPARATOR
+  require 'test_net_ping_wmi'
+end
+
+class TC_Net_Ping < Test::Unit::TestCase
+  def test_net_ping_version
+    assert_equal(Gem::Specification.load('net-ping.gemspec').version.to_s, Net::Ping::VERSION)
+  end
+end

data/test/test_net_ping_external.rb

@@ -0,0 +1,232 @@
+#########################################################################
+# test_net_ping_external.rb
+#
+# Test case for the Net::PingExternal class. Run this via the 'test' or
+# 'test:external' rake task.
+#
+# WARNING: I've noticed that test failures will occur if you're using
+# OpenDNS. This is apparently caused by them messing with upstream
+# replies for advertising purposes.
+#########################################################################
+require 'test-unit'
+require 'net/ping/external'
+require 'mkmf'
+require 'stringio'
+
+class TC_Net_Ping_External < Test::Unit::TestCase
+  def setup
+    @host  = 'localhost'
+    @bogus = 'foo.bar.baz'
+    @pe    = Net::Ping::External.new(@host)
+    @bad   = Net::Ping::External.new(@bogus)
+  end
+
+  test "ping basic functionality" do
+    assert_respond_to(@pe, :ping)
+  end
+
+  test "ping with no arguments" do
+    assert_nothing_raised{ @pe.ping }
+  end
+
+  test "ping accepts a hostname" do
+    assert_nothing_raised{ @pe.ping(@host) }
+  end
+
+  test "ping returns a boolean" do
+    assert_boolean(@pe.ping)
+    assert_boolean(@bad.ping)
+  end
+
+  test "ping? alias" do
+    assert_respond_to(@pe, :ping?)
+    assert_alias_method(@pe, :ping?, :ping)
+  end
+
+  test "pingecho alias" do
+    assert_nothing_raised{ @pe.pingecho }
+    assert_alias_method(@pe, :pingecho, :ping)
+  end
+
+  test "pinging a good host returns true" do
+    omit_if(find_executable0('ping').nil?)
+    assert_true(@pe.ping?)
+  end
+
+  test "pinging a bogus host returns false" do
+    assert_false(@bad.ping?)
+  end
+
+  test "duration basic functionality" do
+    omit_if(find_executable0('ping').nil?)
+    assert_nothing_raised{ @pe.ping }
+    assert_respond_to(@pe, :duration)
+    assert_kind_of(Float, @pe.duration)
+  end
+
+  test "duration is unset if a bad ping follows a good ping" do
+    omit_if(find_executable0('ping').nil?)
+    assert_nothing_raised{ @pe.ping }
+    assert_not_nil(@pe.duration)
+    assert_false(@pe.ping?(@bogus))
+    assert_nil(@pe.duration)
+  end
+
+  test "host getter basic functionality" do
+    assert_respond_to(@pe, :host)
+    assert_equal('localhost', @pe.host)
+  end
+
+  test "host setter basic functionality" do
+    assert_respond_to(@pe, :host=)
+    assert_nothing_raised{ @pe.host = @bad }
+    assert_equal(@bad, @pe.host)
+  end
+
+  test "port getter basic functionality" do
+    assert_respond_to(@pe, :port)
+    assert_equal(7, @pe.port)
+  end
+
+  test "port setter basic functionality" do
+    assert_respond_to(@pe, :port=)
+    assert_nothing_raised{ @pe.port = 90 }
+    assert_equal(90, @pe.port)
+  end
+
+  test "timeout getter basic functionality" do
+    assert_respond_to(@pe, :timeout)
+    assert_equal(5, @pe.timeout)
+  end
+
+  test "timeout setter basic functionality" do
+    assert_respond_to(@pe, :timeout=)
+    assert_nothing_raised{ @pe.timeout = 30 }
+    assert_equal(30, @pe.timeout)
+  end
+
+  test "exception method basic functionality" do
+    assert_respond_to(@pe, :exception)
+    assert_nil(@pe.exception)
+  end
+
+  test "pinging a bogus host stores exception data" do
+    assert_nothing_raised{ @bad.ping? }
+    assert_not_nil(@bad.exception)
+  end
+
+  test "pinging a good host results in no exception data" do
+    omit_if(find_executable0('ping').nil?)
+    assert_nothing_raised{ @pe.ping }
+    assert_nil(@pe.exception)
+  end
+
+  test "warning basic functionality" do
+    assert_respond_to(@pe, :warning)
+    assert_nil(@pe.warning)
+  end
+
+  test "timing out causes expected result" do
+    ext = Net::Ping::External.new('foo.bar.baz', nil, 1)
+    start = Time.now
+    assert_false(ext.ping?)
+    elapsed = Time.now - start
+    assert_true(elapsed < 2.5, "Actual elapsed: #{elapsed}")
+    assert_not_nil(ext.exception)
+  end
+
+  test "pinging an unreachable host on the same subnet returns false" do
+    @bad = Net::Ping::External.new('192.168.0.99')
+    assert_false(@bad.ping?)
+  end
+
+  test "ping6 uses timeout for FreeBSD" do
+    command = nil
+    original_os = RbConfig::CONFIG['host_os']
+    original_popen3 = Open3.method(:popen3)
+
+    RbConfig::CONFIG['host_os'] = 'freebsd'
+    Open3.define_singleton_method(:popen3) do |*args, &block|
+      command = args
+      stdin = StringIO.new
+      stdout = StringIO.new
+      stderr = StringIO.new
+      status = Struct.new(:exitstatus).new(0)
+      thread = Struct.new(:value).new(status)
+      block.call(stdin, stdout, stderr, thread)
+    end
+
+    @pe.ping6('example.test', 2, 3, 4)
+
+    assert_equal(['ping6', '-c', '2', '-x', '4', 'example.test'], command)
+  ensure
+    RbConfig::CONFIG['host_os'] = original_os
+    Open3.define_singleton_method(:popen3, original_popen3)
+  end
+
+  test "ping6 uses interval for macOS" do
+    command = nil
+    original_os = RbConfig::CONFIG['host_os']
+    original_popen3 = Open3.method(:popen3)
+
+    RbConfig::CONFIG['host_os'] = 'darwin'
+    Open3.define_singleton_method(:popen3) do |*args, &block|
+      command = args
+      stdin = StringIO.new
+      stdout = StringIO.new
+      stderr = StringIO.new
+      status = Struct.new(:exitstatus).new(0)
+      thread = Struct.new(:value).new(status)
+      block.call(stdin, stdout, stderr, thread)
+    end
+
+    @pe.ping6('example.test', 2, 3, 4)
+
+    assert_equal(['ping6', '-c', '2', '-i', '3', 'example.test'], command)
+  ensure
+    RbConfig::CONFIG['host_os'] = original_os
+    Open3.define_singleton_method(:popen3, original_popen3)
+  end
+
+  test "ping6 succeeds without an exception when stderr is empty" do
+    stdin = StringIO.new
+    stdout = StringIO.new('64 bytes from ::1')
+    stderr = StringIO.new
+    status = Struct.new(:exitstatus).new(0)
+    thread = Struct.new(:value).new(status)
+    popen3 = Open3.method(:popen3)
+    nil_match = NilClass.instance_method(:=~) if NilClass.instance_methods(false).include?(:=~)
+    false_match = FalseClass.instance_method(:=~) if FalseClass.instance_methods(false).include?(:=~)
+
+    Open3.singleton_class.send(:define_method, :popen3) do |*args, &block|
+      block.call(stdin, stdout, stderr, thread)
+    end
+    [NilClass, FalseClass].each do |klass|
+      klass.send(:define_method, :=~) do |*args|
+        raise NoMethodError, "undefined method '=~' for #{self.inspect}"
+      end
+    end
+
+    assert_true(@pe.ping6('::1'))
+    assert_nil(@pe.exception)
+  ensure
+    Open3.singleton_class.send(:define_method, :popen3, popen3) if popen3
+    if nil_match
+      NilClass.send(:define_method, :=~, nil_match)
+    else
+      NilClass.send(:remove_method, :=~)
+    end
+    if false_match
+      FalseClass.send(:define_method, :=~, false_match)
+    else
+      FalseClass.send(:remove_method, :=~)
+    end
+  end
+
+  def teardown
+    @host  = nil
+    @bogus = nil
+    @pe    = nil
+    @bad   = nil
+  end
+end