net-ping 1.1.1 → 1.2.0

data/lib/net/ping/external.rb

@@ -0,0 +1,92 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+   class Ping::External < Ping
+   
+      # Pings the host using your system's ping utility and checks for any
+      # errors or warnings.  Returns true if boolful, or false if not.
+      # 
+      # If false, then the Ping::External#exception method should contain a
+      # string indicating what went wrong.  If true, 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
+         
+         case RUBY_PLATFORM
+            when /linux|bsd/i
+               pstring += "-c 1 #{host}"
+            when /solaris|sunos/i
+               pstring += "#{host} 1"
+            when /hpux/i
+               pstring += "#{host} -n 1"
+            when /win32|windows|mswin/i
+               pstring += "-n 1 #{host}"
+            else
+               pstring += "#{host}"
+         end
+         
+         if RUBY_PLATFORM.match('mswin')
+            require 'win32/open3'
+         else
+            require 'open3'            
+         end
+
+         start_time = Time.now
+         
+         Timeout.timeout(@timeout){
+            input, output, error = Open3.popen3(pstring)
+         }
+
+         e = error.gets # Can't chomp yet, might be nil
+
+         input.close
+         error.close
+        
+         unless e.nil?
+            if e =~ /warning/i
+               @warning = e.chomp
+               bool = true
+            else
+               @exception = e.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
+               /ix
+               lines.each{ |e|
+                  if regexp.match(e)
+                     @exception = e.chomp
+                     break
+                  end
+               }
+               bool = true unless @exception
+            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
+   end
+
+   # Class alias for backwards compatibility.
+   PingExternal = Ping::External
+end

data/lib/net/ping/http.rb

@@ -0,0 +1,83 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+require 'net/http'
+require 'resolv-replace' # Force non-blocking Socket.getaddrinfo
+require 'uri'
+
+module Net
+   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
+      # boolful 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 false
+      # value is returned if a redirect occurs.
+      # 
+      def ping(host = @host)
+         super(host)
+         bool = false
+         uri = URI.parse(host)
+
+         start_time = Time.now
+
+         begin
+            response = nil
+            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
+                  bool = true if response.is_a?(Net::HTTPSuccess)   
+               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
+
+   # Class alias for backwards compatibility
+   PingHTTP = Ping::HTTP
+end

data/lib/net/ping/icmp.rb

@@ -0,0 +1,168 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+   class Ping::ICMP < Ping   
+      ICMP_ECHOREPLY = 0
+      ICMP_ECHO      = 8
+      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)
+
+         start_time = Time.now
+
+         begin
+            saddr = Socket.pack_sockaddr_in(0, host)
+         rescue Exception
+	         return bool
+         end
+
+         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') << 8
+         end
+
+         check = (check >> 16) + (check & 0xffff)
+         return (~((check >> 16) + check) & 0xffff)
+      end   
+
+      alias ping? ping
+      alias pingecho ping
+   end
+   
+   # Alias for consistency with other ping related classes
+   PingICMP = Ping::ICMP
+end

data/lib/net/ping/ping.rb

@@ -0,0 +1,81 @@
+require 'socket'
+require 'timeout'
+
+module Net
+   class Ping
+      VERSION = '1.2.0'
+
+      # The host to ping.  In the case of Ping::HTTP, this is the URI.
+      attr_accessor :host
+
+      # The port to ping.  This is set to the echo port (7) by default. The
+      # Ping::HTTP class defaults to port 80.
+      #
+      attr_accessor :port
+
+      # The maximum time a ping attempt is made.
+      attr_accessor :timeout
+
+      # If a ping fails, this value is set to the error that occurred which
+      # caused it to fail.
+      #
+      attr_reader :exception
+
+      # This value is set if a ping succeeds, but some other condition arose
+      # during the ping attempt which merits warning, e.g a redirect in the
+      # case of Ping::HTTP#ping.
+      #
+      attr_reader :warning
+
+      # The number of seconds (returned as a Float) that it took to ping
+      # the host. This is not a precise value, but rather a good estimate
+      # since there is a small amount of internal calculation that is added
+      # to the overall time.
+      #
+      attr_reader :duration
+
+      # The default constructor for the Net::Ping class.  Accepts an optional
+      # +host+, +port+ and +timeout+.  The port defaults to your echo port, or
+      # 7 if that happens to be undefined.  The default timeout is 5 seconds.
+      # 
+      # The host, although optional in the constructor, must be specified at
+      # some point before the Net::Ping#ping method is called, or else an
+      # ArgumentError will be raised.
+      #
+      # Yields +self+ in block context.
+      #
+      # This class is not meant to be instantiated directly.  It is strictly
+      # meant as an interface for subclasses.
+      #
+      def initialize(host=nil, port=nil, timeout=5)
+         @host      = host
+         @port      = port || Socket.getservbyname('echo') || 7
+         @timeout   = timeout
+         @exception = nil
+         @warning   = nil
+         @duration  = nil
+
+         yield self if block_given?
+      end
+      
+      # The default interface for the Net::Ping#ping method.  Each subclass
+      # should call super() before continuing with their own implementation in
+      # order to ensure that the @exception and @warning instance variables
+      # are reset.
+      #
+      # If +host+ is nil here, then it will use the host specified in the
+      # constructor.  If the +host+ is nil and there was no host specified
+      # in the constructor then an ArgumentError is raised.
+      #--
+      # The @duration should be set in the subclass' ping method.
+      #
+      def ping(host = @host)
+         raise ArgumentError, 'no host specified' unless host
+         @exception = nil
+         @warning   = nil
+      end
+      
+      alias ping? ping
+      alias pingecho ping
+   end
+end

data/lib/net/ping/tcp.rb

@@ -0,0 +1,84 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+
+   # With a TCP ping, simply try to open a connection.  If we are boolful,
+   # assume bool.  In either case, close the connection to be polite.
+   #
+   class Ping::TCP < Ping
+      @@econnrefused = false
+
+      # Returns whether or not Errno::ECONNREFUSED is considered a boolful
+      # ping.  The default is false.
+      # 
+      def self.econnrefused
+         @@econnrefused
+      end
+
+      # Sets whether or not an Errno::ECONNREFUSED should be considered a
+      # boolful ping.
+      # 
+      def self.econnrefused=(bool)
+         unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+            raise ArgumentError, 'argument must be true or false'
+         end
+         @@econnrefused = bool
+      end
+
+      # This method attempts to ping a host and port using a TCPSocket with
+      # the host, port and timeout values passed in the constructor.  Returns
+      # true if boolful, or false otherwise.
+      # 
+      # Note that, by default, an Errno::ECONNREFUSED return result will be
+      # considered a failed ping.  See the documentation for the
+      # Ping::TCP.econnrefused= method if you wish to change this behavior.
+      # 
+      def ping(host=@host)
+         super(host)
+
+         bool = false
+         tcp = nil
+         start_time = Time.now
+
+         begin
+            Timeout.timeout(@timeout){
+               begin
+                  tcp = TCPSocket.new(host, @port)
+               rescue Errno::ECONNREFUSED => err
+                  if @@econnrefused
+                     bool = true
+                  else
+                     @exception = err
+                  end
+               rescue Exception => err
+                  @exception = err
+               else
+                  bool = true
+               end
+            }
+         rescue Timeout::Error => err
+            @exception = err
+         ensure
+            tcp.close if tcp
+         end
+
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+      
+      # Class method aliases
+      class << self
+         alias ecr econnrefused
+         alias ecr= econnrefused=
+      end
+   end
+
+   # Class alias for backwards compatibility
+   PingTCP = Ping::TCP
+end