net-snmp2 0.3.0 → 0.3.1

data/lib/net/snmp/message.rb

@@ -7,18 +7,13 @@ class Message
     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
+  attr_accessor :version,
+    :community,
+    :pdu,
+    :version_ptr,
+    :community_ptr,
+    :source_address,
+    :source_port
 
   def version_name
     case @version
@@ -33,14 +28,6 @@ class Message
     end
   end
 
-  private
-
-  attr_accessor :type,
-    :length,
-    :data,
-    :cursor,
-    :bytes_remaining
-
   def initialize(packet)
     @version = nil
     @version_ptr = FFI::MemoryPointer.new(:long, 1)
@@ -53,10 +40,50 @@ class Message
     @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}"
+    @source_address = @packet[1][3]
+    @source_port = @packet[1][1]
+    #debug "MESSAGE INITIALIZED\n#{self}"
     parse
   end
 
+  # Sends the given PDU back to the origin of this message.
+  # The origin is the same address and port that the message was
+  # received from.
+  def respond(response_pdu)
+    Session.open(peername: source_address, port: source_port, version: version_name) do |sess|
+      sess.send_pdu(response_pdu)
+    end
+  end
+
+  # Sends a response PDU to the source of the message with all of the same
+  # varbinds. (Useful for sets & informs, where this is how you indicate success)
+  def echo
+    response_pdu = make_response_pdu
+    pdu.varbinds.each do |vb|
+      response_pdu.add_varbind(oid: vb.oid, type: vb.type, value: vb.value)
+    end
+    respond(response_pdu)
+  end
+
+  # Constructs a PDU for responding to this message.
+  # This makes sure the PDU has the right request ID, version,
+  # and community set.
+  def make_response_pdu
+    response_pdu = PDU.new(Constants::SNMP_MSG_RESPONSE)
+    response_pdu.reqid = pdu.reqid
+    response_pdu.version = version
+    response_pdu.community = pdu.community
+    response_pdu
+  end
+
+  private
+
+  attr_accessor :type,
+    :length,
+    :data,
+    :cursor,
+    :bytes_remaining
+
   def parse
     parse_length
     parse_version
@@ -70,7 +97,7 @@ class Message
     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}"
+    #debug "MESSAGE SEQUENCE HEADER PARSED\n#{self}"
   end
 
   def parse_version
@@ -82,7 +109,7 @@ class Message
       @version_ptr.total)
 
     @version = @version_ptr.read_long
-    debug "VERSION NUMBER PARSED\n#{self}"
+    #debug "VERSION NUMBER PARSED\n#{self}"
   end
 
   def parse_community
@@ -96,7 +123,7 @@ class Message
       community_length_ptr)
 
     @community = @community_ptr.read_string
-    debug "COMMUNITY PARSED\n#{self}"
+    #debug "COMMUNITY PARSED\n#{self}"
   end
 
   def parse_pdu
@@ -118,7 +145,7 @@ class Message
 
     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}"
+    #debug "PDU PARSED\n#{self}"
   end
 
   def to_s

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

@@ -35,7 +35,8 @@ module Net
           "#{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, "")}"
+          # (Regex ensures the module qualifier is also removed, if present)
+          "#{node.oid.to_s}#{oid.sub(%r[.*#{node.label.to_s}], "")}"
         end
       end
 

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

@@ -5,7 +5,7 @@ module Net::SNMP
     class Node
       include Debug
       extend Forwardable
-      attr_accessor :struct, :is_in_mib
+      attr_accessor :struct
       def_delegators :struct, :label, :type, :access, :status, :modid, :subid
 
       class << self

data/lib/net/snmp/oid.rb

@@ -26,7 +26,9 @@ module Net
           length_ptr.write_int(oid_ptr.total)
 
           Wrapper.read_objid('1.1', oid_ptr, length_ptr)
-          oid_str = oid_ptr.read_array_of_uint8(oid_ptr.total).map{|byte| byte.to_s(2).rjust(8, '0') }.join('')
+          oid_str = oid_ptr.read_array_of_uint8(oid_ptr.total).map { |byte|
+            byte.to_s(2).rjust(8, '0')
+          }.join('')
 
           @oid_size = (oid_str[/10*1/].length - 1) / 8
         else
@@ -50,7 +52,8 @@ module Net
         unless @sub_id_bit_width
           @sub_id_bit_width = OID.oid_size * 8
         end
-        buffer.send("write_array_of_uint#{@sub_id_bit_width}", self.to_s.split('.').map{ |subid| subid.to_i })
+        subids = self.to_s.split('.').map{ |subid| subid.to_i }
+        buffer.send("write_array_of_uint#{@sub_id_bit_width}", subids)
       end
 
       def initialize(oid)

data/lib/net/snmp/pdu.rb

@@ -57,7 +57,9 @@ module Net
       def enterprise=(oid)
         @i_own_enterprise = true
         oid = OID.new(oid) if oid.kind_of?(String)
-        @struct.enterprise = FFI::LibC.calloc(oid.length, OID.oid_size)
+        # save own reference to enterprise in case we need to free it
+        @enterprise_ptr = FFI::LibC.calloc(oid.length, OID.oid_size)
+        @struct.enterprise = @enterprise_ptr
         oid.write_to_buffer(@struct.enterprise)
         @struct.enterprise_length = oid.length
       end
@@ -201,22 +203,25 @@ module Net
       end
 
       # Free the pdu
-      # Segfaults at the moment - most of the time, anyway.
-      # This is troublesome...
       def free
-        # HACK
-        # snmp_free_pdu segfaults intermittently when freeing the enterprise
-        # oid if we've allocated it. Can't figure out why. For now, freeing it manually
-        # before calling snmp_free_pdu does the trick
+        free_own_memory
+        Wrapper.snmp_free_pdu(@struct.pointer) unless @struct.pointer.null?
+      end
+
+      # malloc'ing memory on one side of the FFI barrier and freeing it
+      # on the other side is unreliable (causing intermittent segfaults).
+      # So, this function free's any memory allocated on the ruby side
+      # for this PDU.
+      def free_own_memory
         if @i_own_enterprise
-          FFI::LibC.free(@struct.enterprise) unless @struct.enterprise.null?
+          FFI::LibC.free(@enterprise_ptr) unless @enterprise_ptr.null?
           @struct.enterprise = FFI::Pointer::NULL
         end
-        Wrapper.snmp_free_pdu(@struct.pointer)
       end
 
       def print
-        puts "PDU"
+        puts "== PDU =="
+        puts "Command: #{command}"
         if command == Constants::SNMP_MSG_TRAP
             puts " - Enterprise: #{enterprise}"
             puts " - Trap Type: #{trap_type}"

data/lib/net/snmp/repl/manager_repl.rb

@@ -28,11 +28,13 @@ EOF
     end
 
     # Adds a session for managing options[:peername] to the sessions list.
+    #
     # - Note that all requests are sent to all active sessions, and their
     #   responses are all displayed under their peername.
     # - You may close a session by calling `close(peername)`
     #
     # Arguments
+    #
     # - options: A Hash or String object
     #   + As a Hash, accepts the following keys
     #     - peername: ADDRESS_OF_AGENT
@@ -40,11 +42,12 @@ EOF
     #     - version:  '1'|'2c'|'3' (defaults to '2c')
     #   + As a string, implies the peername, with the version defaulting to '2c'
     #
-    # Examples:
-    #  manage('192.168.1.5')
-    #  manage('192.168.1.5:162')
-    #  manage(peername: '192.168.1.5', port: 161, version '2c')
-    #  manage(peername: '192.168.1.5:161', version '2c')
+    # Examples
+    #
+    #   manage('192.168.1.5')
+    #   manage('192.168.1.5:162')
+    #   manage(peername: '192.168.1.5', port: 161, version '2c')
+    #   manage(peername: '192.168.1.5:161', version '2c')
     def manage(options)
       options = {:peername => options} if options.kind_of?(String)
       sessions << Session.open(options)
@@ -54,11 +57,13 @@ EOF
     # Close the session with the given `peername`
     #
     # Arguments
+    #
     # - peername: May be a string, matching the peername, or an index.
     #   Run the `peer` command to see indexes & peernames for
     #   all active sessions
     #
-    # Example:
+    # Example
+    #
     #   [7] net-snmp2> peers
     #
     #   Currently Managing
@@ -117,6 +122,7 @@ EOF
     # Translates a numerical oid to it's MIB name, or a name to numerical oid
     #
     # Arguments
+    #
     # - oid: Either a string, as the numerical OID or MIB variable name,
     #        or an OID object
     def translate(oid)
@@ -126,6 +132,7 @@ EOF
     # Prints a description of a MIB variable
     #
     # Arguments
+    #
     # - oid: May be either a numeric OID, or MIB variable name
     def describe(oid)
       nodes = [MIB[oid]]
@@ -135,6 +142,7 @@ EOF
     # Prints a description of a the MIB subtree starting at root `oid`
     #
     # Arguments
+    #
     # - oid: May be either a numeric OID, or MIB variable name
     def describe_tree(oid)
       root = MIB[oid]
@@ -145,6 +153,7 @@ EOF
     # Issue an SNMP GET Request to all active peers
     #
     # Arguments
+    #
     # - oids: A single oid, or an array of oids
     def get(oids, options = {})
       each_session do |session|
@@ -158,6 +167,7 @@ EOF
     # Issue an SNMP GETNEXT Request to all active peers
     #
     # Arguments
+    #
     # - oids: A single oid, or an array of oids
     def get_next(oids, options = {})
       each_session do |session|
@@ -171,6 +181,7 @@ EOF
     # Issue an SNMP GETBULK Request to all active peers
     #
     # Arguments
+    #
     # - oids: A single oid, or an array of oids
     # - options: A Hash accepting the typical options keys for a request, plus
     #  + non_repeaters: The number of non-repeated oids in the request
@@ -188,6 +199,7 @@ EOF
     # Performs a walk on all active peers for each oid provided
     #
     # Arguments
+    #
     # - oids: A single oid, or an array of oids
     def walk(oids, options = {})
       each_session do |session|
@@ -201,10 +213,11 @@ EOF
     # Issue an SNMP Set Request to all active peers
     #
     # Arguments
+    #
     # - varbinds: An single varbind, or an array of varbinds, each of which may be
     #   + An Array of length 3 `[oid, type, value]`
     #   + An Array of length 2 `[oid, value]`
-    #   + Or a Hash `{oid: oid, type: type, value: value}`
+    #   + A Hash `{oid: oid, type: type, value: value}`
     #     * Hash syntax is the same as supported by PDU.add_varbind
     #     * If type is not supplied, it is infered by the value
     def set(varbinds, options = {})

data/lib/net/snmp/session.rb

@@ -88,7 +88,6 @@ module Net
         else
           Constants::SNMP_VERSION_1
         end
-        debug "setting timeout = #{@timeout} retries = #{@retries}"
         @sess.timeout = @timeout * 1000000
         @sess.retries = @retries
 
@@ -164,7 +163,6 @@ module Net
             end
           end
         end
-        # General callback just takes the pdu, calls the session callback if any, then the request specific callback.
 
         @struct = Wrapper.snmp_sess_open(@sess.pointer)
       end
@@ -172,13 +170,13 @@ module Net
       # Close the snmp session and free associated resources.
       def close
         if Net::SNMP.thread_safe
-          self.class.lock.synchronize {
+          Session.lock.synchronize {
             Wrapper.snmp_sess_close(@struct)
-            self.class.sessions.delete(self.sessid)
+            Session.sessions.delete(self.sessid)
           }
         else
           Wrapper.snmp_sess_close(@struct)
-          self.class.sessions.delete(self.sessid)
+          Session.sessions.delete(self.sessid)
         end
       end
 
@@ -281,42 +279,38 @@ module Net
       # the number of seconds to block.
       # Returns the number of file descriptors handled.
       def select(timeout = nil)
-          if @fdset
-            # Re-use the same fd set buffer to avoid
-            # multiple allocation overhead.
-            @fdset.clear
-          else
-            # 8K should be plenty of space
-            @fdset = FFI::MemoryPointer.new(1024 * 8)
-          end
+        unless @fdset
+          # 8K should be plenty of space
+          @fdset = FFI::MemoryPointer.new(1024 * 8)
+        end
 
-          num_fds = FFI::MemoryPointer.new(:int)
-          tv_sec = timeout ? timeout.round : 0
-          tv_usec = timeout ? (timeout - timeout.round) * 1000000 : 0
-          tval = Wrapper::TimeVal.new(:tv_sec => tv_sec, :tv_usec => tv_usec)
-          block = FFI::MemoryPointer.new(:int)
-          if timeout.nil?
-            block.write_int(0)
-          else
-            block.write_int(1)
-          end
+        @fdset.clear
 
-          Wrapper.snmp_sess_select_info(@struct, num_fds, @fdset, tval.pointer, block )
-          tv = (timeout == false ? nil : tval)
-          #debug "Calling select #{Time.now}"
-          num_ready = FFI::LibC.select(num_fds.read_int, @fdset, nil, nil, tv)
-          #debug "Done select #{Time.now}"
-          if num_ready > 0
-            Wrapper.snmp_sess_read(@struct, @fdset)
-          elsif num_ready == 0
-            Wrapper.snmp_sess_timeout(@struct)
-          elsif num_ready == -1
-            # error.  check snmp_error?
-            error("select")
-          else
-            error("wtf is wrong with select?")
-          end
-          num_ready
+        num_fds = FFI::MemoryPointer.new(:int)
+        tv_sec = timeout ? timeout.round : 0
+        tv_usec = timeout ? (timeout - timeout.round) * 1000000 : 0
+        tval = Wrapper::TimeVal.new(:tv_sec => tv_sec, :tv_usec => tv_usec)
+        block = FFI::MemoryPointer.new(:int)
+        if timeout.nil?
+          block.write_int(0)
+        else
+          block.write_int(1)
+        end
+
+        Wrapper.snmp_sess_select_info(@struct, num_fds, @fdset, tval.pointer, block )
+        tv = (timeout == false ? nil : tval)
+        num_ready = FFI::LibC.select(num_fds.read_int, @fdset, nil, nil, tv)
+        if num_ready > 0
+          Wrapper.snmp_sess_read(@struct, @fdset)
+        elsif num_ready == 0
+          Wrapper.snmp_sess_timeout(@struct)
+        elsif num_ready == -1
+          # error.  check snmp_error?
+          error("select")
+        else
+          error("wtf is wrong with select?")
+        end
+        num_ready
       end
 
       alias :poll :select
@@ -352,7 +346,7 @@ module Net
             # So we remove it and resend all the rest
             if pdu.error? && pdu.errindex == i + 1
               oidlist.pop  # remove the bad oid
-              debug "caught error"
+              debug "Error on: #{pdu.varbinds[pdu.errindex - 1].oid}"
               if pdu.varbinds.size > i+1
                 # recram rest of oids on list
                 ((i+1)..pdu.varbinds.size).each do |j|
@@ -373,7 +367,6 @@ module Net
         all_results
       end
 
-
       # Given a list of columns (e.g ['ifIndex', 'ifDescr'], will return a hash with
       # the indexes as keys and hashes as values.
       #   puts sess.get_columns(['ifIndex', 'ifDescr']).inspect
@@ -435,13 +428,19 @@ module Net
       #   rescue Net::SNMP::Error => e
       #     puts e.message
       #   end
-      def send_pdu(pdu, options = {},  &callback)
+      def send_pdu(pdu, options = {}, &callback)
         if options[:blocking]
           return send_pdu_blocking(pdu)
         end
+
+        debug "Sending: " do
+          pdu.print
+        end
+
         if block_given?
+          debug "Setting callback for reqid #{pdu.reqid}"
           @requests[pdu.reqid] = callback
-          debug "calling async_send"
+          debug "Calling snmp_sess_async_send"
           if Wrapper.snmp_sess_async_send(@struct, pdu.pointer, sess_callback, nil) == 0
             error("snmp_get async failed")
           end
@@ -469,6 +468,36 @@ module Net
             send_pdu_blocking(pdu)
           end
         end
+
+        # if block_given?
+        #   debug "Setting callback for reqid #{pdu.reqid}"
+        #   @requests[pdu.reqid] = callback
+        #   debug "Calling snmp_sess_async_send"
+        #   if Wrapper.snmp_sess_async_send(@struct, pdu.pointer, sess_callback, nil) == 0
+        #     error("snmp_get async failed")
+        #   end
+        #   nil
+        # elsif defined?(EM) && EM.reactor_running? && defined?(Fiber)
+        #   f = Fiber.current
+        #   send_pdu pdu do | op, response_pdu |
+        #     f.resume([op, response_pdu])
+        #   end
+        #   op, result = Fiber.yield
+        #   case op
+        #     when :timeout
+        #       raise TimeoutError.new, "timeout"
+        #     when :send_failed
+        #       error "send failed"
+        #     when :success
+        #       result
+        #     when :connect, :disconnect
+        #       nil   #does this ever happen?
+        #     else
+        #       error "unknown operation #{op}"
+        #   end
+        # else
+        #   send_pdu_blocking(pdu)
+        # end
       end
 
       def send_pdu_blocking(pdu)
@@ -477,7 +506,8 @@ module Net
           # Since we don't expect a response, the native net-snmp lib is going to free this
           # pdu for us. Polite, though this may be, it causes intermittent segfaults when freeing
           # memory malloc'ed by ruby. So, clone the pdu into a new memory buffer,
-          # and pass that along.
+          # and pass that along. The clone is then freed by the native lib. The sent
+          # pdu must be freed by the caller.
           clone = Wrapper.snmp_clone_pdu(pdu.struct)
           status = Wrapper.snmp_sess_send(@struct, clone)
           if status == 0
@@ -518,7 +548,7 @@ module Net
 
       def sess_callback
         @sess_callback ||= FFI::Function.new(:int, [:int, :pointer, :int, :pointer, :pointer]) do |operation, session, reqid, pdu_ptr, magic|
-          debug "in callback #{operation.inspect} #{session.inspect}"
+          debug "in sess_callback #{operation.inspect} #{session.inspect}"
           op = case operation
             when Constants::NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE
               :success
@@ -536,6 +566,9 @@ module Net
 
           if @requests[reqid]
             pdu = PDU.new(pdu_ptr)
+            debug "Received:" do
+              pdu.print
+            end
             callback_return = @requests[reqid].call(op, pdu)
             @requests.delete(reqid)
             callback_return == false ? 0 : 1 #if callback returns false (failure), pass it on.  otherwise return 1 (success)