krakatoa-icmp4em 0.0.3

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "eventmachine", ">= 1.0.0.beta.4"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.1.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "simplecov"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    eventmachine (1.0.0.beta.4)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    multi_json (1.1.0)
+    rake (0.9.2.2)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
+    simplecov (0.6.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.1.0)
+  eventmachine (>= 1.0.0.beta.4)
+  jeweler (~> 1.6.4)
+  shoulda
+  simplecov

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "krakatoa-icmp4em"
+  gem.homepage = "http://github.com/krakatoa/icmp4em"
+  gem.license = "MIT"
+  gem.summary = %Q{Asynchronous implementation of ICMP ping over EventMachine}
+  gem.description = %Q{Asynchronous implementation of ICMP ping using EventMachine. Can be used to ping many hosts at once in a non-blocking fashion, with callbacks for success, timeout, and host failure/recovery based on specified threshold numbers.}
+  gem.email = "krakatoa1987@gmail.com"
+  gem.authors = ["Jake Douglas", "Fernando Alonso"]
+  gem.add_dependency "eventmachine", ">= 1.0.0.beta.4"
+  gem.require_paths = ["lib"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+#  test.libs << 'test'
+#  test.pattern = 'test/**/test_*.rb'
+#  test.verbose = true
+#  test.rcov_opts << '--exclude "gems/*"'
+#end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bliss #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/examples/simple_example.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'icmp4em'
+
+# This is an example of non-stateful usage. Only the callbacks provided in on_success and on_expire are used,
+# and the object does not keep track of up/down or execute callbacks on_failure/on_recovery.
+# The data string can be set to anything, as long as the total packet size is less than MTU of the network.
+
+pings = []
+pings << ICMP4EM::ICMPv4.new("google.com")
+pings << ICMP4EM::ICMPv4.new("slashdot.org")
+pings << ICMP4EM::ICMPv4.new("10.99.99.99") # host that will not respond.
+
+Signal.trap("INT") { EventMachine::stop_event_loop }
+
+EM.run {
+  pings.each do |ping| 
+    ping.data = "bar of foozz"
+    ping.on_success {|host, seq, latency| puts "SUCCESS from #{host}, sequence number #{seq}, Latency #{latency}ms"}
+    ping.on_expire {|host, seq, exception| puts "FAILURE from #{host}, sequence number #{seq}, Reason: #{exception.to_s}"}
+    ping.schedule
+  end
+}

data/examples/stateful_example.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'icmp4em'
+
+# This example shows stateful usage, which tracks up/down state of the host based on consecutive number
+# of successful or failing pings specified in failures_required and recoveries_required. Hosts start in
+# 'up' state.
+
+pings = []
+pings << ICMP4EM::ICMPv4.new("google.com", :stateful => true)
+pings << ICMP4EM::ICMPv4.new("10.1.0.175", :stateful => true) # host that will not respond.
+
+Signal.trap("INT") { EventMachine::stop_event_loop }
+
+EM.run {
+  pings.each do |ping| 
+    ping.on_success {|host, seq, latency, count_to_recovery| puts "SUCCESS from #{host}, sequence number #{seq}, Latency #{latency}ms, Recovering in #{count_to_recovery} more"}
+    ping.on_expire {|host, seq, exception, count_to_failure| puts "FAILURE from #{host}, sequence number #{seq}, Reason: #{exception.to_s}, Failing in #{count_to_failure} more"}
+    ping.on_failure {|host| puts "HOST STATE WENT TO DOWN: #{host} at #{Time.now}"}
+    ping.on_recovery {|host| puts "HOST STATE WENT TO UP: #{host} at #{Time.now}"}
+    ping.schedule
+  end
+}

data/krakatoa-icmp4em.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "krakatoa-icmp4em"
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jake Douglas", "Fernando Alonso"]
+  s.date = "2012-03-23"
+  s.description = "Asynchronous implementation of ICMP ping using EventMachine. Can be used to ping many hosts at once in a non-blocking fashion, with callbacks for success, timeout, and host failure/recovery based on specified threshold numbers."
+  s.email = "krakatoa1987@gmail.com"
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README",
+    "Rakefile",
+    "VERSION",
+    "examples/simple_example.rb",
+    "examples/stateful_example.rb",
+    "krakatoa-icmp4em.gemspec",
+    "lib/icmp4em.rb",
+    "lib/icmp4em/common.rb",
+    "lib/icmp4em/handler.rb",
+    "lib/icmp4em/icmpv4.rb"
+  ]
+  s.homepage = "http://github.com/krakatoa/icmp4em"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Asynchronous implementation of ICMP ping over EventMachine"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, [">= 1.0.0.beta.4"])
+  end
+end
+

data/lib/icmp4em.rb

@@ -0,0 +1,6 @@
+$:.unshift File.expand_path(File.dirname(File.expand_path(__FILE__)))
+require 'eventmachine'
+require 'socket'
+require 'icmp4em/common'
+require 'icmp4em/handler'
+require 'icmp4em/icmpv4'

data/lib/icmp4em/common.rb

@@ -0,0 +1,140 @@
+module ICMP4EM
+
+  class Timeout < Exception; end;
+
+  module Common
+
+    ICMP_ECHOREPLY = 0
+    ICMP_ECHO      = 8
+    ICMP_SUBCODE   = 0
+
+    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.
+    # (This method was stolen directly from net-ping - yaki)
+    def generate_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
+
+  module HostCommon
+
+    # Set failure callback. The provided Proc or block will be called and yielded the host and sequence number, whenever the failure count exceeds the defined threshold.
+    def on_failure(proc = nil, &block)
+      @failure = proc || block unless proc.nil? and block.nil?
+      @failure
+    end
+
+    # Set recovery callback. The provided Proc or block will be called and yielded the host and sequence number, whenever the recovery count exceeds the defined threshold.
+    def on_recovery(proc = nil, &block)
+      @recovery = proc || block unless proc.nil? and block.nil?
+      @recovery
+    end
+
+    # Set success callback. This will be called and yielded the host, sequence number, and latency every time a ping returns successfully.
+    def on_success(proc = nil, &block)
+      @success = proc || block unless proc.nil? and block.nil?
+      @success
+    end
+
+    # Set 'expiry' callback. This will be called and yielded the host, sequence number, and Exception every time a ping fails. 
+    # This is not just for timeouts! This can be triggered by failure of the ping for any reason.
+    def on_expire(proc = nil, &block)
+      @expiry = proc || block unless proc.nil? and block.nil?
+      @expiry
+    end
+
+    # Set the number of consecutive 'failure' pings required to switch host state to 'down' and trigger failure callback, assuming the host is up.
+    def failures_required=(failures)
+      @failures_required = failures
+    end
+    
+    # Set the number of consecutive 'recovery' pings required to switch host state to 'up' and trigger recovery callback, assuming the host is down.
+    def recoveries_required=(recoveries)
+      @recoveries_required = recoveries
+    end
+    
+    private
+
+    def success(seq, latency)      
+      if @success
+        if @stateful
+          count_to_recover = @up ? 0 : @recoveries_required - @failcount.abs
+          @success.call(@host, seq, latency, count_to_recover)
+        else
+          @success.call(@host, seq, latency)
+        end
+      end
+    end
+
+    def expiry(seq, reason)
+      if @expiry
+        if @stateful
+          count_to_fail = @up ? @failures_required - @failcount : 0
+          @expiry.call(@host, seq, reason, count_to_fail)
+        else
+          @expiry.call(@host, seq, reason)
+        end
+      end
+    end
+
+    # Executes specified failure callback, passing the host to the block.
+    def fail
+      @failure.call(@host) if @failure
+      @up = false
+    end
+
+    # Executes specified recovery callback, passing the host to the block.
+    def recover
+      @recovery.call(@host) if @recovery
+      @up = true
+    end
+
+    # Trigger failure/recovery if either threshold is exceeded...
+    def check_for_fail_or_recover
+      if @failcount > 0
+        fail if @failcount >= @failures_required && @up
+      elsif @failcount <= -1
+        recover if @failcount.abs >= @recoveries_required && !@up
+      end
+    end
+
+    # Adjusts the failure counter after each ping. The failure counter is incremented positively to count failures,
+    # and decremented into negative numbers to indicate successful pings towards recovery after a failure.
+    # This is an awful mess..just like the rest of this file.
+    def adjust_failure_count(direction)
+      if direction == :down
+        if @failcount > -1 
+          @failcount += 1
+        elsif @failcount <= -1 
+          @failcount = 1
+        end
+      elsif direction == :up && !@up
+        if @failcount > 0
+          @failcount = -1
+        elsif @failcount <= -1
+          @failcount -= 1
+        end
+      else
+        @failcount = 0
+      end
+    end
+
+  end
+
+end

data/lib/icmp4em/handler.rb

@@ -0,0 +1,53 @@
+module ICMP4EM
+
+  module Handler
+    
+    include Common
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def notify_readable
+      receive(@socket)
+    end
+    
+    def unbind
+      @socket.close if @socket
+    end
+    
+    private
+
+    def receive(socket)
+      # The data was available now
+      time = Time.now
+      # Get data
+      host, data = read_socket(socket)
+      # Rebuild message array
+      msg = data[20,30].unpack("C2 n3 A*")
+      # Verify the packet type is echo reply and verify integrity against the checksum it provided
+      return unless msg.first == ICMP_ECHOREPLY && verify_checksum?(msg)
+      # Find which object it is supposed to go to
+      recipient = ICMPv4.instances[msg[3]]
+      # Send time and seq number to recipient object
+      recipient.send(:receive, msg[4], time) unless recipient.nil?
+    end
+
+    def read_socket(socket)
+      # Recieve a common MTU, 1500 bytes.
+      data, sender = socket.recvfrom(1500)
+      # Get the host in case we want to use that later.
+      host = Socket.unpack_sockaddr_in(sender).last
+      [host, data]
+    end
+    
+    def verify_checksum?(ary)
+      cs = ary[2]
+      ary_copy = ary.dup
+      ary_copy[2] = 0
+      cs == generate_checksum(ary_copy.pack("C2 n3 A*"))
+    end
+
+  end
+
+end

data/lib/icmp4em/icmpv4.rb

@@ -0,0 +1,174 @@
+module ICMP4EM
+
+  class ICMPv4
+
+    include Common
+    include HostCommon
+    
+    @instances = {}
+    @recvsocket = nil
+    
+    class << self
+      
+      attr_reader :instances
+      attr_accessor :recvsocket, :handler
+      
+    end
+    
+    attr_accessor :bind_host, :interval, :threshold, :timeout, :data, :block
+    attr_reader :id, :failures_required, :recoveries_required, :seq
+
+    # Create a new ICMP object (host). This takes a host and an optional hash of options for modifying the behavior. They are:
+    # * :bind_host
+    # Bind the socket to this address. The operating system will figure this out on it's own unless you need to set it for a special situation.
+    # * :timeout
+    # Timeout, in seconds, before the ping is considered expired and the appropriate callbacks are executed. This should be a numeric class.
+    # * :block
+    # True or false, default is false. True enables a blocking receive mode, for when accurate latency measurement is important. Due to the nature
+    # of event loop architecture, a noticable delay in latency can be added when other things are going on in the reactor.
+    # * :interval
+    # Interval, in seconds, for how often the ping should be sent. Should be a numeric class.
+    # * :stateful
+    # True or false, default is false. Indicates whether or not this ping object should keep track of it's successes and failures and execute
+    # the on_failure/on_recovery callbacks when the specified limits are hit.
+    # * :failures_required
+    # Indicates how many consequtive failures are required to switch to the 'failed' state and execute the on_failure callback. Applies only when :stateful => true
+    # * :recoveries_required
+    # Indicates how many consequtive successes are required to switch to the 'recovered' state and execute the on_recovery callback. Applies only when :stateful => true
+    def initialize(host, options = {})
+      raise 'requires root privileges' if Process.euid > 0
+      @host = host
+      @ipv4_sockaddr = Socket.pack_sockaddr_in(0, @host)
+      @interval   =   options[:interval] || 1
+      @timeout    =   options[:timeout] || 1
+      @stateful   =   options[:stateful] || false
+      @bind_host  =   options[:bind_host] || nil
+      @block      =   options[:block] || false
+      @recoveries_required = options[:recoveries_required] || 5
+      @failures_required   = options[:failures_required] || 5
+      @up = true
+      @waiting = {}
+      set_id
+      @seq, @failcount = 0, 0
+      @data = "Ping from EventMachine"
+    end
+    
+    # This must be called when the object will no longer be used, to remove 
+    # the object from the class variable hash that is searched for recipients when
+    # an ICMP echo comes in. Also cancels the periodic timer. Better way to do this whole thing?...
+    def stop
+      @ptimer.cancel if @ptimer
+      self.class.instances[@id] = nil
+    end
+
+    # Send the echo request to @host and add sequence number to the waiting queue.
+    def ping
+      raise "EM not running" unless EM.reactor_running?
+      init_handler if self.class.recvsocket.nil?
+      @seq = ping_send
+      if @block
+        blocking_receive
+      else
+        EM.add_timer(@timeout) { self.send(:expire, @seq, Timeout.new("Ping timed out")) } unless @timeout == 0
+      end
+      @seq
+    end
+
+    # Uses a periodic timer to ping the host at @interval.
+    def schedule
+      raise "EM not running" unless EM.reactor_running?
+      @ptimer = EM::PeriodicTimer.new(@interval) { self.ping }
+    end
+
+    private
+
+    # Expire a sequence number from the waiting queue.
+    # Should only be called by the timer setup in #ping or the rescue Exception in #ping_send.
+    def expire(seq, exception = nil)
+      waiting = @waiting[seq]
+      if waiting
+        @waiting[seq] = nil
+        adjust_failure_count(:down) if @stateful
+        expiry(seq, exception)
+        check_for_fail_or_recover if @stateful
+      end
+    end
+
+    # Should only be called by the Handler. Passes the receive time and sequence number.
+    def receive(seq, time)
+      waiting = @waiting[seq]
+      if waiting
+        latency = (time - waiting) * 1000
+        adjust_failure_count(:up) if @stateful
+        success(seq, latency)
+        check_for_fail_or_recover if @stateful
+        @waiting[seq] = nil
+      end
+    end
+
+    # Construct and send the ICMP echo request packet.
+    def ping_send
+      seq = (@seq + 1) % 65536
+
+      socket = self.class.recvsocket
+
+      # Generate msg with checksum
+      msg = [ICMP_ECHO, ICMP_SUBCODE, 0, @id, seq, @data].pack("C2 n3 A*")
+      msg[2..3] = [generate_checksum(msg)].pack('n')
+      
+      # Enqueue so we can expire properly if there is an exception raised during #send
+      @waiting[seq] = Time.now
+      
+      begin
+        # Fire it off
+        socket.send(msg, 0, @ipv4_sockaddr)
+        # Re-enqueue AFTER sendto() returns. This ensures we aren't adding latency if the socket blocks.
+        @waiting[seq] = Time.now
+        # Return sequence number to caller
+        seq
+      rescue Exception => err
+        expire(seq, err)
+        seq
+      end
+    end
+
+    # Initialize the receiving socket and handler for incoming ICMP packets.
+    def init_handler
+      self.class.recvsocket = Socket.new(
+      Socket::PF_INET,
+      Socket::SOCK_RAW,
+      Socket::IPPROTO_ICMP
+      )
+      if @bind_host
+        saddr = Socket.pack_sockaddr_in(0, @bind_host)
+        self.class.recvsocket.bind(saddr)
+      end
+      self.class.handler = EM.watch self.class.recvsocket, Handler, self.class.recvsocket
+      self.class.handler.notify_readable = true
+    end
+
+    # Sets the instance id to a unique 16 bit integer so it can fit inside relevent the ICMP field.
+    # Also adds self to the pool so that incoming messages that it requested can be delivered.
+    def set_id
+      while @id.nil?
+        id = rand(65535)
+        unless self.class.instances[id]
+          @id = id
+          self.class.instances[@id] = self
+        end
+      end
+    end
+    
+    def blocking_receive
+      r = select([self.class.recvsocket], nil, nil, @timeout)
+      
+      if r and r.first.include?(self.class.recvsocket)
+        self.class.handler.notify_readable
+      else
+        expire(@seq, Timeout.new("Ping timed out"))
+      end
+    end
+
+  end
+  
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: krakatoa-icmp4em
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Jake Douglas
+- Fernando Alonso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &27867940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *27867940
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &27867460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27867460
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &27866980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *27866980
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &27866500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *27866500
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &27866020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27866020
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &27865540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *27865540
+description: Asynchronous implementation of ICMP ping using EventMachine. Can be used
+  to ping many hosts at once in a non-blocking fashion, with callbacks for success,
+  timeout, and host failure/recovery based on specified threshold numbers.
+email: krakatoa1987@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- VERSION
+- examples/simple_example.rb
+- examples/stateful_example.rb
+- krakatoa-icmp4em.gemspec
+- lib/icmp4em.rb
+- lib/icmp4em/common.rb
+- lib/icmp4em/handler.rb
+- lib/icmp4em/icmpv4.rb
+homepage: http://github.com/krakatoa/icmp4em
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 701688465436271762
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Asynchronous implementation of ICMP ping over EventMachine
+test_files: []