net-ping 2.1.0-universal-linux

data/lib/net/ping/http.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(__FILE__), 'ping')
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'open-uri'
+
+# Force non-blocking Socket.getaddrinfo on Unix systems. Do not use on
+# Windows because it (ironically) causes blocking problems.
+unless File::ALT_SEPARATOR or RUBY_VERSION >= "1.9.3"
+  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
+
+    # The maximum number of redirects allowed. The default is 5.
+    attr_accessor :redirect_limit
+
+    # The user agent used for the HTTP request. The default is nil.
+    attr_accessor :user_agent
+
+    # OpenSSL certificate verification mode. The default is VERIFY_NONE.
+    attr_accessor :ssl_verify_mode
+
+    # Use GET request instead HEAD. The default is false.
+    attr_accessor :get_request
+
+    # was this ping proxied?
+    attr_accessor :proxied
+
+    # For unsuccessful requests that return a server error, it is
+    # useful to know the HTTP status code of the response.
+    attr_reader :code
+
+    # Creates and returns a new Ping::HTTP object. The default port is the
+    # port associated with the URI or 80. The default timeout is 5 seconds.
+    #
+    def initialize(uri=nil, port=nil, timeout=5)
+      @follow_redirect = true
+      @redirect_limit  = 5
+      @ssl_verify_mode = OpenSSL::SSL::VERIFY_NONE
+      @get_request     = false
+      @code            = nil
+
+      port ||= URI.parse(uri).port if uri
+      port ||= 80
+
+      @port = port
+
+      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.
+    # If no scheme is present in the URI, then 'http' is assumed.
+    #
+    def ping(host = @host)
+      super(host)
+      bool = false
+
+      # See https://bugs.ruby-lang.org/issues/8645
+      host = "http://#{host}" unless /\A(http(s)?:\/\/)/.match(host)
+
+      uri = URI.parse(host)
+
+      # A port provided here via the host argument overrides anything
+      # provided in constructor.
+      #
+      port = URI.split(host)[3] || URI.parse(host).port || @port
+      port = port.to_i
+
+      start_time = Time.now
+
+      response = do_ping(uri, port)
+
+      if response.is_a?(Net::HTTPSuccess)
+        bool = true
+      elsif redirect?(response) # Check code, HTTPRedirection does not always work
+        if @follow_redirect
+          @warning = response.message
+          rlimit   = 0
+
+          while redirect?(response)
+            if rlimit >= redirect_limit
+              @exception = "Redirect limit exceeded"
+              break
+            end
+            redirect = URI.parse(response['location'])
+            port = redirect.port
+            redirect = uri + redirect if redirect.relative?
+
+            start_time = Time.now
+            response = do_ping(redirect, port)
+            rlimit += 1
+          end
+
+          if response.is_a?(Net::HTTPSuccess)
+            bool = true
+          else
+            @warning   = nil
+            @exception ||= response.message
+          end
+
+        else
+          @exception = response.message
+        end
+      else
+        @exception ||= response.message
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+
+      bool
+    end
+
+    alias follow_redirect? follow_redirect
+    alias uri host
+    alias uri= host=
+
+    private
+
+    def redirect?(response)
+      response && response.code.to_i >= 300 && response.code.to_i < 400
+    end
+
+    def do_ping(uri, port)
+      response = nil
+      proxy = uri.find_proxy || URI.parse("")
+
+      begin
+        uri_path = uri.path.empty? ? '/' : uri.path
+
+        headers = {}
+        headers["User-Agent"] = user_agent if user_agent
+
+        http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new(uri.host, port)
+
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+
+        @proxied = http.proxy?
+
+        if @get_request == true
+          request = Net::HTTP::Get.new(uri_path, headers)
+        else
+          request = Net::HTTP::Head.new(uri_path, headers)
+        end
+
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = @ssl_verify_mode
+        end
+
+        response = http.start{ |h|
+          h.open_timeout = timeout
+          h.read_timeout = timeout
+          h.request(request)
+        }
+      rescue Exception => err
+        @exception = err.message
+      end
+
+      @code = response.code if response
+
+      response
+    end
+  end
+end

data/lib/net/ping/icmp.rb

@@ -0,0 +1,188 @@
+require File.join(File.dirname(__FILE__), 'ping')
+
+if File::ALT_SEPARATOR
+  require 'win32/security'
+end
+
+# 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)
+      begin
+        # If we have cap2, but not are root, or have net_raw, raise an error
+        require 'cap2'
+        current_process = Cap2.process
+        unless Process.euid == 0 \
+          || current_process.permitted?(:net_raw) \
+          && current_process.enabled?(:net_raw)
+          raise StandardError, 'requires root privileges or setcap net_raw'
+        end
+      rescue LoadError
+        # Without cap2, raise error if we are not root
+        unless Process.euid == 0
+          raise StandardError, 'requires root privileges or setcap net_raw'
+        end
+      end
+
+      if File::ALT_SEPARATOR
+        unless Win32::Security.elevated_security?
+          raise 'requires elevated security'
+        end
+      end
+
+      @seq = 0
+      @bind_port = 0
+      @bind_host = nil
+      @data_size = 56
+      @data = ''
+
+      0.upto(@data_size){ |n| @data << (n % 256).chr }
+
+      @ping_id = (Thread.current.object_id ^ 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, @ping_id, @seq, @data].pack(pstring)
+
+      checksum = checksum(msg)
+      msg = [ICMP_ECHO, ICMP_SUBCODE, checksum, @ping_id, @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){
+          while true
+            io_array = select([socket], nil, nil, timeout)
+
+            if io_array.nil? || io_array[0].empty?
+              raise Timeout::Error if io_array.nil?
+              return false
+            end
+
+            ping_id = nil
+            seq = nil
+
+            data = socket.recvfrom(1500).first
+            type = data[20, 2].unpack('C2').first
+
+            case type
+              when ICMP_ECHOREPLY
+                if data.length >= 28
+                  ping_id, seq = data[24, 4].unpack('n3')
+                end
+              else
+                if data.length > 56
+                  ping_id, seq = data[52, 4].unpack('n3')
+                end
+            end
+
+            if ping_id == @ping_id && seq == @seq && type == ICMP_ECHOREPLY
+              bool = true
+              break
+            end
+          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
+    end
+
+    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

data/lib/net/ping/ping.rb

@@ -0,0 +1,99 @@
+require 'socket'
+require 'timeout'
+
+require_relative 'version'
+
+# The Net module serves as a namespace only.
+#
+module Net
+
+   # The Ping class serves as an abstract base class for all other Ping class
+   # types. You should not instantiate this class directly.
+   #
+   class Ping
+      # 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
+         @duration  = nil
+      end
+
+      def ping6(host = @host)
+         raise ArgumentError, 'no host specified' unless host
+         @exception = nil
+         @warning   = nil
+         @duration  = nil
+      end
+ 
+      def ping?(host = @host)
+        !!ping(host)
+      end
+       
+      alias pingecho ping
+
+   end
+end

data/lib/net/ping/tcp.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'ping')
+
+# The Net module serves as a namespace only.
+module Net
+
+  # With a TCP ping simply try to open a connection. If we are successful,
+  # assume success. In either case close the connection to be polite.
+  #
+  class Ping::TCP < Ping
+    @@service_check = false
+
+    # Returns whether or not Errno::ECONNREFUSED is considered a successful
+    # ping. The default is false.
+    #
+    def self.service_check
+      @@service_check
+    end
+
+    # Sets whether or not an Errno::ECONNREFUSED should be considered a
+    # successful ping.
+    #
+    def self.service_check=(bool)
+      unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+        raise ArgumentError, 'argument must be true or false'
+      end
+      @@service_check = 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 successful, 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.service_check= method if you wish to change this behavior.
+    #
+    def ping(host=@host)
+      super(host)
+
+      bool = false
+
+      # Failure here most likely means bad host, so just bail.
+      begin
+        addr = Socket.getaddrinfo(host, port)
+      rescue SocketError => err
+        @exception = err
+        return false
+      end
+
+      begin
+        # Where addr[0][0] is likely AF_INET.
+        sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+
+        # This may not be entirely necessary
+        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+        start_time = Time.now
+
+        begin
+          # Where addr[0][3] is an IP address
+          sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+        rescue Errno::EINPROGRESS
+          # No-op, continue below
+        rescue Exception => err
+          # Something has gone horribly wrong
+          @exception = err
+          return false
+        end
+
+        resp = IO.select(nil, [sock], nil, timeout)
+
+        if resp.nil? # Assume ECONNREFUSED if nil
+          if @@service_check
+            bool = true
+          else
+            bool = false
+            @exception = Errno::ECONNREFUSED
+          end
+        else
+          sockopt = sock.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
+
+          if sockopt.int != 0
+            if @@service_check && sockopt.int == Errno::ECONNREFUSED::Errno
+              bool = true
+            else
+              bool = false
+              @exception = SystemCallError.new(sockopt.int)
+            end
+          else
+            bool = true
+          end
+        end
+      ensure
+        sock.close if sock
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+    end
+
+  
+    # Class method aliases. DEPRECATED.
+    class << self
+      alias econnrefused service_check
+      alias econnrefused= service_check=
+      alias ecr service_check
+      alias ecr= service_check=
+    end
+  end
+end

data/lib/net/ping/udp.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), 'ping')
+
+# The Net module serves as a namespace only.
+module Net
+
+  # The Ping::UDP class encapsulates methods for UDP pings.
+  class Ping::UDP < Ping
+    @@service_check = true
+      
+    # Returns whether or not the connect behavior should enforce remote
+    # service availability as well as reachability. The default is true.
+    #
+    def self.service_check
+      @@service_check
+    end
+      
+    # Set whether or not the connect behavior should enforce remote
+    # service availability as well as reachability. If set to false
+    # then Errno::ECONNREFUSED or Errno::ECONNRESET will be considered
+    # a successful ping, meaning no actual data handshaking is required.
+    # By default, if either of those errors occurs it is considered a failed
+    # ping.
+    #
+    def self.service_check=(bool)
+      unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+        raise ArgumentError, 'argument must be true or false'
+      end
+      @@service_check = bool         
+    end
+      
+    # The maximum data size that can be sent in a UDP ping.
+    MAX_DATA = 64
+      
+    # The data to send to the remote host. By default this is 'ping'.
+    # This should be MAX_DATA size characters or less.
+    # 
+    attr_reader :data
+      
+    # Creates and returns a new Ping::UDP object.  This is effectively
+    # identical to its superclass constructor.
+    # 
+    def initialize(host=nil, port=nil, timeout=5)
+      @data = 'ping'
+
+      super(host, port, timeout)
+
+      @bind_host = nil
+      @bind_port = nil
+    end
+      
+    # Sets the data string sent to the remote host. This value cannot have
+    # a size greater than MAX_DATA.
+    # 
+    def data=(string)
+       if string.size > MAX_DATA
+         err = "cannot set data string larger than #{MAX_DATA} characters"
+         raise ArgumentError, err
+       end
+         
+       @data = string
+    end
+
+    # Associates the local end of the UDP connection with the given +host+
+    # and +port+. This is essentially a wrapper for UDPSocket#bind.
+    #
+    def bind(host, port)
+      @bind_host = host
+      @bind_port = port
+    end
+
+    # Sends a simple text string to the host and checks the return string. If
+    # the string sent and the string returned are a match then the ping was
+    # successful and true is returned. Otherwise, false is returned.
+    #
+    def ping(host = @host)
+      super(host)
+
+      bool  = false
+      udp   = UDPSocket.open
+      array = []
+
+      if @bind_host
+        udp.bind(@bind_host, @bind_port)
+      end
+
+      start_time = Time.now
+
+      begin
+        Timeout.timeout(@timeout){
+          udp.connect(host, @port)
+          udp.send(@data, 0)
+          array = udp.recvfrom(MAX_DATA)
+        }
+      rescue Errno::ECONNREFUSED, Errno::ECONNRESET => err
+        if @@service_check
+          @exception = err
+        else
+          bool = true
+        end
+      rescue Exception => err
+        @exception = err
+      else
+        if array[0] == @data
+          bool = true
+        end
+      ensure
+        udp.close if udp
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+
+      bool
+    end
+
+  end
+end

data/lib/net/ping/version.rb

@@ -0,0 +1,6 @@
+module Net
+  class Ping
+    # The version of the net-ping library.
+    VERSION = '2.1.0'
+  end
+end