net-ping 1.3.3-x86-mingw32

data/examples/example_pingexternal.rb

@@ -0,0 +1,16 @@
+########################################################################
+# example_pingexternal.rb
+#
+# A short sample program demonstrating an external ping. You can run
+# this program via the example:external task. Modify as you see fit.
+########################################################################
+require 'net/ping'
+
+good = 'www.rubyforge.org'
+bad  = 'foo.bar.baz'
+
+p1 = Net::Ping::External.new(good)
+p p1.ping?
+
+p2 = Net::Ping::External.new(bad)
+p p2.ping?

data/examples/example_pinghttp.rb

@@ -0,0 +1,22 @@
+########################################################################
+# example_pinghttp.rb
+#
+# A short sample program demonstrating an http ping. You can run
+# this program via the example:http task. Modify as you see fit.
+########################################################################
+require 'net/ping'
+
+good = 'http://www.google.com/index.html'
+bad  = 'http://www.ruby-lang.org/index.html'
+
+puts "== Good ping, no redirect"
+
+p1 = Net::Ping::HTTP.new(good)
+p p1.ping?
+
+puts "== Bad ping"
+
+p2 = Net::Ping::HTTP.new(bad)
+p p2.ping?
+p p2.warning
+p p2.exception

data/examples/example_pingtcp.rb

@@ -0,0 +1,16 @@
+########################################################################
+# example_pingtcp.rb
+#
+# A short sample program demonstrating a tcp ping. You can run
+# this program via the example:tcp task. Modify as you see fit.
+########################################################################
+require 'net/ping'
+
+good = 'www.google.com'
+bad  = 'foo.bar.baz'
+
+p1 = Net::Ping::TCP.new(good, 'http')
+p p1.ping?
+
+p2 = Net::Ping::TCP.new(bad)
+p p2.ping?

data/examples/example_pingudp.rb

@@ -0,0 +1,12 @@
+########################################################################
+# example_pingudp.rb
+#
+# A short sample program demonstrating a UDP ping. You can run
+# this program via the example:udp task. Modify as you see fit.
+########################################################################
+require 'net/ping'
+
+host = 'www.google.com'
+
+u = Net::Ping::UDP.new(host)
+p u.ping?

data/lib/net/ping.rb

@@ -0,0 +1,17 @@
+# 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 File.join(File.dirname(__FILE__), 'ping/tcp')
+require File.join(File.dirname(__FILE__), 'ping/udp')
+require File.join(File.dirname(__FILE__), 'ping/icmp')
+require File.join(File.dirname(__FILE__), 'ping/external')
+require File.join(File.dirname(__FILE__), 'ping/http')
+
+if Config::CONFIG['host_os'] =~ /msdos|mswin|cygwin|mingw|win32/i &&
+  JAVA_PLATFORM != 'java'
+then
+  require File.join(File.dirname(__FILE__), 'ping/wmi')
+end

data/lib/net/ping/external.rb

@@ -0,0 +1,126 @@
+require 'rbconfig'
+require File.join(File.dirname(__FILE__), 'ping')
+
+if Config::CONFIG['host_os'] =~ /mswin|win32|msdos|cygwin|mingw/i &&
+  RUBY_PLATFORM != 'java'
+then
+  if RUBY_VERSION.to_f < 1.9
+    require 'win32/open3'
+  end
+  require 'windows/console'
+else
+  require 'open3'            
+end
+
+# The Net module serves as a namespace only.
+module Net
+
+  # The Ping::External class encapsulates methods for external (system) pings.
+  class Ping::External < Ping
+
+    CWINDOWS = Config::CONFIG['host_os'] =~ /mswin|win32|msdos|cygwin|mingw/i &&
+      RUBY_PLATFORM != 'java'
+      
+    if CWINDOWS
+      include Windows::Console
+    end 
+   
+    # Pings the host using your system's ping utility and checks for any
+    # errors or warnings. Returns true if successful, or false if not.
+    # 
+    # If the ping failed then the Ping::External#exception method should
+    # contain a string indicating what went wrong. If the ping succeeded then
+    # the Ping::External#warning method may or may not contain a value.
+    # 
+    def ping(host = @host)
+      super(host)
+
+      input, output, error = ""
+      pstring = "ping "
+      bool    = false
+      orig_cp = nil
+       
+      case Config::CONFIG['host_os']
+        when /linux|bsd|osx|mach|darwin/i
+          pstring += "-c 1 #{host}"
+        when /solaris|sunos/i
+          pstring += "#{host} 1"
+        when /hpux/i
+          pstring += "#{host} -n 1"
+        when /win32|windows|msdos|mswin|cygwin|mingw/i
+          if RUBY_PLATFORM != 'java'
+            orig_cp = GetConsoleCP()
+            SetConsoleCP(437) if orig_cp != 437 # United States
+          end
+          pstring += "-n 1 #{host}"
+        else
+          pstring += "#{host}"
+      end
+       
+      start_time = Time.now
+       
+      begin
+        err = nil
+
+        Timeout.timeout(@timeout){
+          input, output, error = Open3.popen3(pstring)
+          err = error.gets # Can't chomp yet, might be nil
+        }
+
+        input.close
+        error.close
+
+        if CWINDOWS && GetConsoleCP() != orig_cp
+          SetConsoleCP(orig_cp)
+        end
+      
+        unless err.nil?
+          if err =~ /warning/i
+            @warning = err.chomp
+            bool = true
+          else
+            @exception = err.chomp
+          end
+        # The "no answer" response goes to stdout, not stderr, so check it
+        else
+          lines = output.readlines
+          output.close
+          if lines.nil? || lines.empty?
+            bool = true
+          else
+            regexp = /
+              no\ answer|
+              host\ unreachable|
+              could\ not\ find\ host|
+              request\ timed\ out|
+              100%\ packet\ loss
+            /ix
+
+            lines.each{ |line|
+              if regexp.match(line)
+                @exception = line.chomp
+                break
+              end
+            }
+
+            bool = true unless @exception
+          end
+        end
+      rescue Exception => error
+        @exception = error.message 
+      ensure
+        input.close if input && !input.closed?
+        error.close if error && !error.closed?
+        output.close if output && !output.closed?
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+
+      bool
+    end
+
+    alias ping? ping
+    alias pingecho ping
+  end
+end

data/lib/net/ping/http.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), 'ping')
+require 'net/http'
+require 'uri'
+require 'rbconfig'
+
+# Force non-blocking Socket.getaddrinfo on Unix systems. Do not use on
+# Windows because it (ironically) causes blocking problems.
+unless Config::CONFIG['host_os'] =~ /mswin|win32|msdos|cygwin|mingw/i
+  require 'resolv-replace'
+end
+
+# The Net module serves as a namespace only.
+module Net
+   
+  # The Ping::HTTP class encapsulates methods for HTTP pings.
+  class Ping::HTTP < Ping
+      
+    # By default an http ping will follow a redirect and give you the result
+    # of the final URI.  If this value is set to false, then it will not
+    # follow a redirect and will return false immediately on a redirect.
+    # 
+    attr_accessor :follow_redirect
+      
+    # Creates and returns a new Ping::HTTP object.  Note that the default
+    # port for Ping::HTTP is 80.
+    # 
+    def initialize(uri=nil, port=80, timeout=5)
+      @follow_redirect = true
+      super(uri, port, timeout)
+    end
+
+    # Looks for an HTTP response from the URI passed to the constructor.
+    # If the result is a kind of Net::HTTPSuccess then the ping was
+    # successful and true is returned.  Otherwise, false is returned
+    # and the Ping::HTTP#exception method should contain a string
+    # indicating what went wrong.
+    # 
+    # If the HTTP#follow_redirect accessor is set to true (which it is
+    # by default) and a redirect occurs during the ping, then the
+    # HTTP#warning attribute is set to the redirect message, but the
+    # return result is still true. If it's set to false then a redirect
+    # response is considered a failed ping.
+    #
+    # If no file or path is specified in the URI, then '/' is assumed.
+    # 
+    def ping(host = @host)
+      super(host)
+      bool = false
+      uri = URI.parse(host)
+
+      start_time = Time.now
+
+      begin
+        response = nil
+        uri_path = uri.path.empty? ? '/' : uri.path
+        Timeout.timeout(@timeout){
+          response = Net::HTTP.get_response(uri.host, uri_path, @port)
+        }
+      rescue Exception => err
+        @exception = err.message
+      else
+        if response.is_a?(Net::HTTPSuccess)
+          bool = true
+        else
+          if @follow_redirect
+            @warning = response.message
+                
+            while response.is_a?(Net::HTTPRedirection)
+              redirect = URI.parse(response['location']) 
+              redirect = uri + redirect if redirect.relative?                     
+              response = Net::HTTP.get_response(redirect.host, redirect.path, @port)
+            end
+                  
+            if response.is_a?(Net::HTTPSuccess)
+              bool = true
+            else
+              @warning = nil
+              @exception = response.message
+            end
+          else
+            @exception = response.message
+          end
+        end
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+
+      bool
+    end
+
+    alias ping? ping
+    alias pingecho ping
+    alias follow_redirect? follow_redirect
+    alias uri host
+    alias uri= host=
+  end
+end

data/lib/net/ping/icmp.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), 'ping')
+
+# The Net module serves as a namespace only.
+module Net
+
+   # The Net::Ping::ICMP class encapsulates an icmp ping.
+   class Ping::ICMP < Ping   
+      ICMP_ECHOREPLY = 0 # Echo reply
+      ICMP_ECHO      = 8 # Echo request
+      ICMP_SUBCODE   = 0
+      
+      # You cannot set or change the port value. A value of 0 is always
+      # used internally for ICMP pings.
+      #
+      undef_method :port=
+
+      # Returns the data size, i.e. number of bytes sent on the ping. The
+      # default size is 56.
+      #
+      attr_reader :data_size
+
+      # Creates and returns a new Ping::ICMP object.  This is similar to its
+      # superclass constructor, but must be created with root privileges (on
+      # UNIX systems), and the port value is ignored.
+      #
+      def initialize(host=nil, port=nil, timeout=5)
+         raise 'requires root privileges' if Process.euid > 0
+
+         @seq = 0
+         @bind_port = 0
+         @bind_host = nil
+         @data_size = 56
+         @data = ''
+
+         0.upto(@data_size){ |n| @data << (n % 256).chr }
+
+         @pid  = Process.pid & 0xffff
+
+         super(host, port, timeout)
+         @port = nil # This value is not used in ICMP pings.
+      end
+
+      # Sets the number of bytes sent in the ping method.
+      #
+      def data_size=(size)
+         @data_size = size
+         @data = ''
+         0.upto(size){ |n| @data << (n % 256).chr }
+      end
+
+      # Associates the local end of the socket connection with the given
+      # +host+ and +port+.  The default port is 0.
+      #
+      def bind(host, port = 0)
+         @bind_host = host
+         @bind_port = port
+      end
+      
+      # Pings the +host+ specified in this method or in the constructor.  If a
+      # host was not specified either here or in the constructor, an
+      # ArgumentError is raised.
+      #
+      def ping(host = @host)
+         super(host)
+         bool = false
+
+         socket = Socket.new(
+            Socket::PF_INET,
+            Socket::SOCK_RAW,
+            Socket::IPPROTO_ICMP
+         )
+
+         if @bind_host
+            saddr = Socket.pack_sockaddr_in(@bind_port, @bind_host)
+            socket.bind(saddr)
+         end
+         
+         @seq = (@seq + 1) % 65536
+         pstring = 'C2 n3 A' << @data_size.to_s
+         timeout = @timeout
+
+         checksum = 0
+         msg = [ICMP_ECHO, ICMP_SUBCODE, checksum, @pid, @seq, @data].pack(pstring)
+         checksum = checksum(msg)
+         msg = [ICMP_ECHO, ICMP_SUBCODE, checksum, @pid, @seq, @data].pack(pstring)
+
+         begin
+            saddr = Socket.pack_sockaddr_in(0, host)
+         rescue Exception
+            socket.close unless socket.closed?
+	         return bool
+         end
+         
+         start_time = Time.now
+
+         socket.send(msg, 0, saddr) # Send the message
+
+         begin
+            Timeout.timeout(@timeout){
+               io_array = select([socket], nil, nil, timeout)
+
+               if io_array.nil? || io_array[0].empty?
+                  return false
+               end
+
+               pid = nil
+               seq = nil
+
+               data, sender  = socket.recvfrom(1500)
+               port, host    = Socket.unpack_sockaddr_in(sender)
+               type, subcode = data[20, 2].unpack('C2')
+
+               case type
+                  when ICMP_ECHOREPLY
+                     if data.length >= 28
+                        pid, seq = data[24, 4].unpack('n3')
+                     end
+                  else
+                     if data.length > 56
+                        pid, seq = data[52, 4].unpack('n3')
+                     end
+               end
+
+               if pid == @pid && seq == @seq && type == ICMP_ECHOREPLY
+                  bool = true
+               end
+            }
+         rescue Exception => err
+            @exception = err
+         ensure
+            socket.close if socket
+         end
+         
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         return bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+
+      private
+
+      # Perform a checksum on the message.  This is the sum of all the short
+      # words and it folds the high order bits into the low order bits.
+      #
+      def checksum(msg)
+         length    = msg.length
+         num_short = length / 2
+         check     = 0
+
+         msg.unpack("n#{num_short}").each do |short|
+            check += short
+         end
+
+         if length % 2 > 0
+            check += msg[length-1, 1].unpack('C').first << 8
+         end
+
+         check = (check >> 16) + (check & 0xffff)
+         return (~((check >> 16) + check) & 0xffff)
+      end   
+   end
+end