net-snmp2 0.3.0

data/lib/net/snmp/debug.rb

@@ -0,0 +1,54 @@
+module Net
+module SNMP
+module Debug
+  class << self
+    attr_accessor :logger
+  end
+
+  def debug(msg)
+    Debug.logger.debug msg if Debug.logger
+  end
+
+  def info(msg)
+    Debug.logger.info msg if Debug.logger
+  end
+
+  def warn(msg)
+    Debug.logger.warn msg if Debug.logger
+  end
+
+  def error(msg)
+    Debug.logger.error msg if Debug.logger
+  end
+
+  def fatal(msg)
+    Debug.logger.fatal msg if Debug.logger
+  end
+
+  def time(label, &block)
+    t_start = Time.now
+    block[]
+    t_end = Time.now
+    info "#{label}: #{(t_end - t_start)*1000}ms"
+  end
+
+  def print_packet(packet)
+    byte_string = (packet.kind_of?(Array) ? packet[0] : packet)
+
+    byte_array = byte_string.unpack("C*")
+    binary =  byte_array.map{|n| n.to_s(2).rjust(8, '0')}
+
+    puts " # | Decimal |  Hex  |  Binary  | Character"
+    puts "-------------------------------------------"
+
+    i = 0
+    prev = 0
+    byte_array.zip(binary).each do |byte, binary_string|
+      puts "#{i.to_s.ljust(5)}#{byte.to_s.ljust(10)}0x#{byte.to_s(16).ljust(6)}#{binary_string.ljust(11)}#{byte.chr}   #{'Sequence Length' if byte == 130 && prev == 48}"
+      prev = byte
+      i += 1
+    end
+  end
+end
+end
+end

data/lib/net/snmp/dispatcher.rb

@@ -0,0 +1,108 @@
+class Net::SNMP::Dispatcher
+  # A class with convenience methods for polling multiple open sessions
+  class << self
+    # Loop through all sessions, calling select on each.
+    def select(timeout = nil)
+      total = 0
+      t = timeout
+      t = nil if t == false
+      catch :got_data do
+        loop do
+          if Net::SNMP.thread_safe
+            Net::SNMP::Session.lock.synchronize {
+              Net::SNMP::Session.sessions.each do |k, sess|
+                total += sess.select(t)
+              end
+            }
+          else
+           Net::SNMP::Session.sessions.each do |k, sess|
+              total += sess.select(t)
+            end
+          end
+
+          throw :got_data if total > 0
+          throw :got_data unless timeout == false
+        end
+      end
+      total
+    end
+    alias :poll :select
+
+    # Start a poller loop.  Behavior depends upon whether
+    # you are running under eventmachine and whether fibers
+    # are available.
+    # +options+
+    # * :timeout Number of seconds to block on select. nil effects a poll.  false blocks forever (probably not what you want).
+    # * :sleep Number of seconds to sleep if no data is available.  Gives other fibers/threads a chance to run.
+    def run_loop(options = {})
+      if defined?(EM) && EM.reactor_running?
+        if defined?(Fiber)
+          fiber_loop(options)
+        else
+          em_loop(options)
+        end
+      else
+        thread_loop(options)
+      end
+    end
+
+    # Start a poller loop in a seperate thread.  You
+    # should first call Net::SNMP.thread_safe = true.
+    # +options+
+    # * :timeout Number of seconds to block on select. Will not block other threads.
+    # * :sleep Number of seconds to sleep if no data is available.  Allows other threads to run. Default 0.2
+    def thread_loop(options = {})
+      timeout = options[:timeout] || 0.2
+      sleep_time = options[:sleep] || 0.2
+      Thread.new do
+        loop do
+          num_ready = select(timeout)
+          if num_ready == 0
+            sleep(sleep_time) if sleep_time
+          end
+        end
+      end
+    end
+
+    # Start a loop in eventmachine (no fibers)
+    # +options+
+    # * :sleep Number of seconds to sleep if no data available.  So we don't peg the reactor. Default 0.2
+    def em_loop(options = {})
+      timeout = options[:timeout]
+      sleep_time = options[:sleep] || 0.2
+      myproc = Proc.new do
+        EM.next_tick do
+          while(true) do
+            num_ready = select(timeout)
+            break if num_ready == 0
+          end
+          EM.add_timer(sleep_time) do
+            myproc.call
+          end
+        end
+      end
+      myproc.call
+    end
+
+    # Start a loop using eventmachine and fibers
+    # +options+
+    # * :sleep Number of seconds to sleep if no data available, so we don't peg the reactor. Default 0.2
+    def fiber_loop(options = {})
+      timeout = options[:timeout]
+      sleep_time = options[:sleep] || 0.2
+      fib = Fiber.new {
+        loop do
+          num_handled = poll(timeout)
+          if num_handled == 0
+            f = Fiber.current
+            EM.add_timer(sleep_time) do
+              f.resume
+            end
+            Fiber.yield
+          end
+        end
+      }
+      fib.resume
+    end
+  end
+end

data/lib/net/snmp/error.rb

@@ -0,0 +1,29 @@
+module Net
+  module SNMP
+    class Error < RuntimeError
+      attr_accessor :status, :errno, :snmp_err, :snmp_msg
+      def initialize(opts = {})
+        @status = opts[:status]
+        @fiber = opts[:fiber]
+        if opts[:session]
+          @errno = opts[:session].errno
+          @snmp_err = opts[:session].snmp_err
+          @snmp_msg = opts[:session].error_message
+        end
+        print
+      end
+
+      def print
+        puts "SNMP Error: #{self.class.to_s}"
+        puts "message = #{message}"
+        puts "status = #{@status}"
+        puts "errno = #{@errno}"
+        puts "snmp_err = #{@snmp_err}"
+        puts "snmp_msg = #{@snmp_msg}"
+      end
+    end
+
+    class TimeoutError < Error
+    end
+  end
+end

data/lib/net/snmp/listener.rb

@@ -0,0 +1,76 @@
+require 'timeout'
+
+module Net::SNMP
+
+# Implements a generic listener for incoming SNMP packets
+
+  class Listener
+    include Debug
+
+    attr_accessor :port, :socket, :packet, :callback
+
+    def initialize
+      # Set by `stop` (probably in an INT signal handler) to
+      # indicate that the agent should stop
+      @killed = false
+    end
+
+    # Starts the listener's run loop
+    def start(port = 161, interval = 2, max_packet_size = 65_000)
+      @interval = interval
+      @socket = UDPSocket.new
+      @socket.bind("127.0.0.1", port)
+      @max_packet_size = max_packet_size
+      info "Listening on port #{port}"
+      run_loop
+    end
+    alias listen start
+    alias run start
+
+    # Stops the listener's run loop
+    def stop
+      @killed = true
+    end
+    alias kill stop
+
+    # Sets the handler for all incoming messages.
+    #
+    # The block provided will be called back for each message as follows:
+    #
+    #   block[message, from_address, from_port]
+    #
+    # Where
+    #
+    # - `message` is the parsed Net::SNMP::Message object
+    # - `from_address` is a string representing the address of the host sending the request
+    # - `from_port` is the port the host sent the request from
+    def on_message(&block)
+      @callback = block
+    end
+
+    private
+
+    def run_loop
+      packet = nil
+      loop {
+        begin
+          return if @killed
+          # TODO: Not exactly the most efficient solution...
+          timeout(@interval) do
+            @packet = @socket.recvfrom(@max_packet_size)
+          end
+          return if @killed
+          time "Message Processing" do
+            message = Message.parse(@packet)
+            @callback[message, @packet[1][3], @packet[1][1]] if @callback
+          end
+        rescue Timeout::Error => timeout
+          next
+        rescue StandardError => ex
+          error "Error in listener.\n#{ex}\n  #{ex.backtrace.join("\n  ")}"
+        end
+      }
+    end
+
+  end
+end

data/lib/net/snmp/message.rb

@@ -0,0 +1,142 @@
+module Net
+module SNMP
+class Message
+  include SNMP::Debug
+
+  def self.parse(packet)
+    Message.new(packet)
+  end
+
+  # Could have been an instance method, but a response pdu
+  # isn't really an intrinsic property of all messages. So,
+  # going with class method instead.
+  def self.response_pdu_for(message)
+    response_pdu = PDU.new(Constants::SNMP_MSG_RESPONSE)
+    response_pdu.reqid = message.pdu.reqid
+    response_pdu.version = message.version
+    response_pdu.community = message.pdu.community
+    response_pdu
+  end
+
+  attr_accessor :version, :community, :pdu, :version_ptr, :community_ptr
+
+  def version_name
+    case @version
+    when Constants::SNMP_VERSION_1
+      '1'
+    when Constants::SNMP_VERSION_2c
+      '2c'
+    when Constants::SNMP_VERSION_3
+      '3'
+    else
+      raise "Invalid SNMP version: #{@version}"
+    end
+  end
+
+  private
+
+  attr_accessor :type,
+    :length,
+    :data,
+    :cursor,
+    :bytes_remaining
+
+  def initialize(packet)
+    @version = nil
+    @version_ptr = FFI::MemoryPointer.new(:long, 1)
+    @community_ptr = FFI::MemoryPointer.new(:uchar, 100)
+    @packet = packet
+    @packet_length = packet[0].length
+    @type_ptr = FFI::MemoryPointer.new(:int, 1)
+    @data_ptr = FFI::MemoryPointer.new(:char, @packet_length)
+    @data_ptr.write_bytes(packet[0])
+    @cursor_ptr = @data_ptr
+    @bytes_remaining_ptr = FFI::MemoryPointer.new(:int, 1)
+    @bytes_remaining_ptr.write_bytes([@packet_length].pack("L"))
+    debug "MESSAGE INITIALIZED\n#{self}"
+    parse
+  end
+
+  def parse
+    parse_length
+    parse_version
+    parse_community
+    parse_pdu
+    self
+  end
+
+  def parse_length
+    @cursor_ptr = Net::SNMP::Wrapper.asn_parse_header(@data_ptr, @bytes_remaining_ptr, @type_ptr)
+    unless @type_ptr.read_int == 48
+      raise "Invalid SNMP packet. Message should start with a sequence declaration"
+    end
+    debug "MESSAGE SEQUENCE HEADER PARSED\n#{self}"
+  end
+
+  def parse_version
+    @cursor_ptr = Net::SNMP::Wrapper.asn_parse_int(
+      @cursor_ptr,
+      @bytes_remaining_ptr,
+      @type_ptr,
+      @version_ptr,
+      @version_ptr.total)
+
+    @version = @version_ptr.read_long
+    debug "VERSION NUMBER PARSED\n#{self}"
+  end
+
+  def parse_community
+    community_length_ptr = FFI::MemoryPointer.new(:size_t, 1)
+    community_length_ptr.write_int(@community_ptr.total)
+    @cursor_ptr = Net::SNMP::Wrapper.asn_parse_string(
+      @cursor_ptr,
+      @bytes_remaining_ptr,
+      @type_ptr,
+      @community_ptr,
+      community_length_ptr)
+
+    @community = @community_ptr.read_string
+    debug "COMMUNITY PARSED\n#{self}"
+  end
+
+  def parse_pdu
+    ###########################################
+    # Don't do this...
+    #
+    #    pdu_struct_ptr = Wrapper::SnmpPdu.new
+    #
+    # We do not want to own this pointer, or we can't call `snmp_free_pdu` on it,
+    # which happens in PDU#free. Instead, let the native library allocate it.
+    # Note that if we allocate any members for this pdu (like the enterprise oid string),
+    # We will have to free those ourselves before calling `snmp_free_pdu`.
+    #
+    # If the above is not done, segfaults start happening when one side tries
+    # to free memory malloc'ed by the other side. Possibly because the netsnmp.dll
+    # links to a different C Runtime library, which may have differences in malloc/free.
+    pdu_struct_ptr = Wrapper.snmp_pdu_create(0)
+    ###########################################
+
+    Net::SNMP::Wrapper.snmp_pdu_parse(pdu_struct_ptr, @cursor_ptr, @bytes_remaining_ptr)
+    @pdu = Net::SNMP::PDU.new(pdu_struct_ptr.pointer)
+    debug "PDU PARSED\n#{self}"
+  end
+
+  def to_s
+    <<-EOF
+    version(#{@version})
+    community(#{@community})
+    pdu
+      command(#{@pdu.command if @pdu})
+      varbinds (#{@pdu.varbinds.map{|v| "\n          #{v.oid.to_s} => #{v.value}" }.join('') if @pdu})
+    type(#{@type_ptr.read_int})
+    bytes_remaining(#{@bytes_remaining_ptr.read_int})
+    cursor @ #{@cursor_ptr.address}
+      Byte:  #{indices = []; (@bytes_remaining_ptr.read_int.times {|i| indices.push((i+1).to_s.rjust(2))}; indices.join ' ')}
+      Value: #{@cursor_ptr.get_bytes(0, @bytes_remaining_ptr.read_int).each_byte.map {|b| b.to_s(16).rjust(2, '0') }.join(' ')}
+    data @ #{@data_ptr.address}
+      #{@data_ptr.get_bytes(0, @packet_length).each_byte.map {|b| b.to_s(16).rjust(2, '0') }.join(' ')}
+    EOF
+  end
+end
+end
+end

data/lib/net/snmp/mib/mib.rb

@@ -0,0 +1,67 @@
+module Net
+  module SNMP
+    module MIB
+
+      # Configures the MIB directory search path (using add_mibdir ), sets up the internal
+      # MIB framework, and then loads the appropriate MIB modules (using netsnmp_read_module
+      # and  read_mib). It should be called before any other routine that manipulates
+      # or accesses the MIB tree (but after any additional add_mibdir calls).
+      def self.init
+        Wrapper.netsnmp_init_mib
+      end
+
+      # Read in all the MIB modules found on the MIB directory search list
+      def self.read_all_mibs
+        Wrapper.read_all_mibs
+      end
+
+      # Get an OID object representing the MIB node containing `oid`
+      # - `oid` argument may be a numerical oid, or the MIB name
+      def self.get_node(oid)
+        Node.get_node(oid)
+      end
+
+      # Get an OID object representing the MIB node containing `oid`
+      # - `oid` argument may be a numerical oid, or the MIB name
+      def self.[](oid)
+        Node.get_node(oid)
+      end
+
+      # Translates a numerical oid to it's MIB name, or a name to numerical oid
+      def self.translate(oid)
+        node = Node.get_node(oid)
+        if oid =~ /^[0-9.]*$/
+          # Node label + instance indexes from argument
+          "#{node.label}#{oid.sub(node.oid.to_s, "")}"
+        else
+          # Node OID + instance indexes from argument
+          "#{node.oid.to_s}#{oid.sub(node.label.to_s, "")}"
+        end
+      end
+
+      # Add the specified directory to the path of locations which are searched
+      # for files containing MIB modules. Note that this does not actually load
+      # the MIB modules located in that directory
+      def self.add_mibdir(dirname)
+        Wrapper.add_mibdir(dirname)
+      end
+
+      # Takes the name of a MIB module (which need not be the same as the name
+      # of the file that contains the module), locates this within the configured
+      # list of MIB directories, and loads the definitions from the module into
+      # the active MIB tree. It also loads any MIB modules listed in the IMPORTS
+      # clause of this module.
+      def self.read_module(name)
+        Wrapper.netsnmp_read_module(name)
+      end
+
+      # Similar to read_module, but takes the name of the file containing the MIB
+      # module. Note that this file need not be located within the MIB directory
+      # search list (although any modules listed in the IMPORTS clause do).
+      def self.read_mib(filename)
+        Wrapper.read_mib(filename)
+      end
+
+    end
+  end
+end