net-snmp2 0.3.0

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

@@ -0,0 +1,39 @@
+# Ruby api to the Wrapper::Module class (represents netsnmp's `struct module`)
+
+module Net::SNMP
+  class Module
+    extend Forwardable
+    def_delegators :struct, :modid, :no_imports
+
+    # Gets a module node by its id
+    def self.find(module_id)
+      if module_id < 0
+        nil
+      else
+        new(Wrapper.find_module(module_id))
+      end
+    end
+
+    def initialize(struct)
+      raise "Tried to initialize null module" if struct.null?
+      @struct = struct
+    end
+
+    def name
+      @struct.name.read_string
+    end
+
+    def file
+      @struct.file.read_string
+    end
+
+    def next
+      if @struct.next.null?
+        nil
+      else
+        self.class.new(@struct.next)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,122 @@
+# Ruby api to the Wrapper::Tree class (represents netsnmp's `struct tree`)
+
+module Net::SNMP
+  module MIB
+    class Node
+      include Debug
+      extend Forwardable
+      attr_accessor :struct, :is_in_mib
+      def_delegators :struct, :label, :type, :access, :status, :modid, :subid
+
+      class << self
+        include Debug
+        def get_node(oid)
+          if oid.kind_of?(String)
+            oid = OID.new(oid)
+          end
+          struct = Wrapper.get_tree(oid.pointer, oid.length_pointer.read_int, Wrapper.get_tree_head().pointer)
+          node = new(struct.pointer)
+          warn "OID #{oid.to_s} not found in MIB" unless node.in_mib?
+          node
+        end
+      end
+
+      def initialize(arg)
+        @oid = nil
+        @module = nil
+        case arg
+        when Wrapper::Tree
+          @struct = arg
+        when FFI::Pointer
+          @struct = Wrapper::Tree.new(arg)
+        else
+          raise "invalid type"
+        end
+      end
+
+      def exists_in_mib?
+        # The structure can be created without the oid actually
+        # existing in the mib, but the parent will be null.
+        # Of course, the parent is null for the root node as well,
+        # so ignore that case.
+        (!@struct.parent.null?) || oid.to_s == '1'
+      end
+      alias in_mib? exists_in_mib?
+
+      def module
+        unless @module
+          @module = Module.find(modid)
+        end
+        @module
+      end
+
+      def description
+        if @struct.description.null?
+          nil
+        else
+          @struct.description.read_string
+        end
+      end
+
+      def oid
+        return @oid if @oid
+        @oid = OID.new(label)
+      end
+
+      # actually seems like list is linked backward, so this will retrieve the previous oid numerically
+      def next
+        return nil if @struct.next.null?
+        self.class.new(@struct.next)
+      end
+
+      def next_peer
+        return nil if @struct.next_peer.null?
+        self.class.new(@struct.next_peer)
+      end
+
+      def parent
+        return nil if @struct.parent.null?
+        self.class.new(@struct.parent)
+      end
+
+      def children
+        return to_enum __method__ unless block_given?
+        return if @struct.child_list.null?
+        child = self.class.new(@struct.child_list)
+        yield child
+        while child = child.next_peer
+          yield child
+        end
+      end
+
+      # Depth-first traversal of all descendants
+      def descendants(&block)
+        return to_enum __method__ unless block_given?
+        return if @struct.child_list.null?
+        child = self.class.new(@struct.child_list)
+        block[child]
+        child.descendants(&block)
+        while child = child.next_peer
+          block[child]
+          child.descendants(&block)
+        end
+      end
+
+      def peers
+        return [] if oid.to_s == '1'
+        parent.children.reject { |n| n.oid.to_s == oid.to_s }
+      end
+      alias siblings peers
+
+      def enums
+        return to_enum __method__ unless block_given?
+        enum = struct.enums
+        while !enum.null?
+          yield({value: enum.value, label: enum.label.read_string})
+          enum = enum.next
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Net::SNMP::MIB
+  module Templates
+    DESCRIBE = '
+<% nodes.each do |node| -%>
+<%= node.module.nil? ? "" : "#{node.module.name}::" %><%= node.label %>
+  - oid:       <%= node.oid %>
+  - type:      <%= node.type %>
+  - file:      <%= node.module.file unless node.module.nil? %>
+  - descr:     <%= "\"#{node.description}\"" %>
+  - enums:     <%=
+  if !(node.enums.count == 0)
+    node.enums.map { |e| "#{e[:label]}(#{e[:value]})" }.join(", ")
+  else
+    "NONE"
+  end
+%>
+  - parent:    <%= "#{node.parent.label}(#{node.parent.oid})" unless node.parent.nil? %>
+  - peers:     <%= node.peers.map { |n| "#{n.label}(#{n.subid})"}.join(", ") %>
+  - next:      <%= node.next.oid unless node.next.nil? %>
+  - next_peer: <%= node.next_peer.oid unless node.next_peer.nil? %>
+  - children:  <%=
+  if node.children.count > 0
+    node.children.map { |n| "#{n.label}(#{n.subid})"}.join(", ")
+  else
+    "NONE"
+  end
+%>
+<% end -%>
+'.sub!("\n", "") # Remove leading newline
+
+    JSON = json_template = '
+[
+<% nodes.each_with_index { |node, index| -%>
+<%= ",\n" if index > 0 -%>
+  {
+    "name": "<%= node.module.nil? ? "" : "#{node.module.name}::" %><%= node.label %>",
+    "oid": "<%= node.oid %>",
+    "type": <%= node.type %>,
+<% if node.enums && node.enums.count > 0 -%>
+    "enums": { <%= node.enums.map { |enum| "\"#{enum[:label]}\": #{enum[:value]}" }.join(", ") %> },
+<% end -%>
+    "parent": <%= node.parent ? %Q["#{node.parent.oid}"] : "undefined" %>
+  }<% } -%>
+
+]
+'.sub!("\n", "")
+  end
+end

data/lib/net/snmp/oid.rb

@@ -0,0 +1,134 @@
+module Net
+  module SNMP
+    class OID
+      extend Debug
+      include Debug
+
+      attr_reader :oid, :pointer, :length_pointer
+      @oid_size = nil
+      @sub_id_bit_width = nil
+
+      def self.from_pointer(ptr, sub_id_count)
+        OID.new(OID.read_pointer(ptr, sub_id_count))
+      end
+
+      def self.oid_size
+        unless @oid_size
+          determine_oid_size
+        end
+        @oid_size
+      end
+
+      def self.determine_oid_size
+        if Net::SNMP.initialized?
+          oid_ptr = FFI::MemoryPointer.new(:ulong, 8)
+          length_ptr = FFI::MemoryPointer.new(:size_t, 1)
+          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_size = (oid_str[/10*1/].length - 1) / 8
+        else
+          @oid_size = FFI::MemoryPointer.new(:ulong).total
+          warn "SNMP not initialized\n" + <<-WARNING
+            Cannot determine OID sub-id size, assuming common case of sizeof(ulong)
+            On this platform, sizeof(ulong) = #{@oid_size} bytes
+            To avoid this warning, call `Net::SNMP.init`
+            WARNING
+        end
+      end
+
+      def self.read_pointer(pointer, sub_id_count)
+        unless @sub_id_bit_width
+          @sub_id_bit_width = OID.oid_size * 8
+        end
+        pointer.send("read_array_of_uint#{@sub_id_bit_width}", sub_id_count).join('.')
+      end
+
+      def write_to_buffer(buffer)
+        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 })
+      end
+
+      def initialize(oid)
+        @oid = oid
+        @pointer = FFI::MemoryPointer.new(Net::SNMP::OID.oid_size * Constants::MAX_OID_LEN)
+        @length_pointer = FFI::MemoryPointer.new(:size_t)
+        @length_pointer.write_int(Constants::MAX_OID_LEN)
+        if @oid =~ /^[\d\.]*$/
+          if Wrapper.read_objid(@oid, @pointer, @length_pointer) == 0
+            Wrapper.snmp_perror(@oid)
+          end
+        else
+          if Wrapper.get_node(@oid, @pointer, @length_pointer) == 0
+            raise "No such node: #{oid}"
+          end
+          @oid = to_s
+        end
+      end
+
+      def size
+        @length_pointer.read_int * Net::SNMP::OID.oid_size
+      end
+
+      def length
+        @length_pointer.read_int
+      end
+
+      def oid
+        @oid
+      end
+
+      def name
+        @oid
+      end
+
+      def to_s
+        OID.read_pointer(@pointer, length)
+      end
+
+      # Gets the MIB node corresponding to this OID.
+      # Note that if this OID represents a MIB node, like '1.3',
+      # then `oid.to_s == oid.node.oid.to_s`. However, if there
+      # are indices on this oid, then `oid.to_s.start_with?(oid.node.oid.to_s)`
+      def node
+        MIB::Node.get_node(oid)
+      end
+
+      # The instance index string
+      # Note that some MIB nodes specify the instance implicitly,
+      # like sysUpTimeInstance. So, this may be an empty string.
+      def index
+        # Strip the name
+        index = oid.sub(node.oid.name, '')
+        # Strip any leading dot
+        index.sub(/^\./, '')
+      end
+
+      # The label for the this OID. Includes any instance indexes.
+      def label
+        "#{node.label}#{index.length > 0 ? "." + index : ""}"
+      end
+
+      def <=>(o)
+        a = self._packed
+        b = o._packed
+        a <=> b
+      end
+
+      def _packed
+        i = self.to_s.dup
+        i.sub!(/^\./,'')
+        i.gsub!(/ /, '.0')
+        i.replace(i.split('.').map(&:to_i).pack('N*'))
+      end
+
+      def parent_of?(o)
+        o.to_s =~ /^#{self.to_s}\./
+      end
+    end
+  end
+end

data/lib/net/snmp/pdu.rb

@@ -0,0 +1,235 @@
+module Net
+  module SNMP
+    #  Wrapper around netsnmp_pdu.
+    class PDU
+      extend Forwardable
+      include Net::SNMP::Debug
+      attr_accessor :struct, :varbinds, :callback, :command
+      def_delegators :struct, :pointer
+
+      # Create a new PDU object.
+      # +pdu_type+  The type of the PDU.  For example, Net::SNMP::SNMP_MSG_GET.  See constants.rb
+      def initialize(pdu_type)
+        @varbinds = []
+        case pdu_type
+        when FFI::Pointer
+          @struct = Wrapper::SnmpPdu.new(pdu_type)
+          @command = @struct.command
+          v = @struct.variables
+          unless v.null?
+            @varbinds << Varbind.from_pointer(v)
+            while( !(v = v.next_variable).null? )
+              @varbinds << Varbind.from_pointer(v)
+            end
+          end
+        when Fixnum
+          @struct = Wrapper.snmp_pdu_create(pdu_type)
+          @command = pdu_type
+        else
+          raise Error.new, "invalid pdu type"
+        end
+      end
+
+      # Specifies the number of non-repeating, regular objects at the start of
+      # the variable list in the request.
+      # (For getbulk requests only, non-repeaters is stored in errstat location)
+      def non_repeaters
+        @struct.errstat
+      end
+
+      def non_repeaters=(nr)
+        @struct.errstat = nr
+      end
+
+      # The number of iterations in the table to be read for the repeating
+      # objects that follow the non-repeating objects.
+      # (For getbulk requests only, max-repititions are stored in errindex location)
+      def max_repetitions=(mr)
+        @struct.errindex = mr
+      end
+
+      def max_repetitions
+        @struct.errindex
+      end
+
+      # Sets the enterprise OID of this PDU
+      # (Valid for SNMPv1 traps only)
+      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)
+        oid.write_to_buffer(@struct.enterprise)
+        @struct.enterprise_length = oid.length
+      end
+
+      # The enterprise OID of this PDU
+      # (Valid for SNMPv1 traps only)
+      def enterprise
+        OID.from_pointer(@struct.enterprise, @struct.enterprise_length)
+      end
+
+      # Sets the address of the agent that sent this PDU
+      # (Valid for SNMPv1 traps only)
+      def agent_addr=(addr)
+        # @struct.agent_addr is a binary array of 4 characters,
+        # so pack the provided string into four bytes and we can assign it
+        @struct.agent_addr = addr.split('.').map{ |octet| octet.to_i }.pack("CCCC")
+      end
+
+      # The address of the agent that sent this PDU
+      # (Valid for SNMPv1 traps only)
+      def agent_addr
+        # @struct.agent_addr is a binary array of 4 characters,
+        # to_a converts this to a ruby array of Integers, then join get's us
+        # back to the string form
+        @struct.agent_addr.to_a.join('.')
+      end
+
+      # The uptime for the PDU
+      # (Only valid for SNMPv1 traps)
+      def uptime
+        @struct.time
+      end
+
+      # The uptime for the PDU
+      # (Only valid for SNMPv1 traps)
+      def uptime=(value)
+        @struct.time = value.to_i
+      end
+
+      # Returns true if pdu is in error
+      def error?
+        self.errstat != 0
+      end
+
+      # Sets the pdu errstat
+      def error=(value)
+        @struct.errstat = value
+      end
+      alias errstat= error=
+      alias error_status= error=
+
+      # Sets the error index
+      def error_index=(index)
+        @struct.errindex = index
+      end
+      alias errindex= error_index=
+
+      # A descriptive error message
+      def error_message
+        Wrapper::snmp_errstring(self.errstat)
+      end
+
+      # Tries to delegate missing methods to the underlying Wrapper::SnmpPdu object.
+      # If it does not respond to the method, calls super.
+      def method_missing(m, *args)
+        if @struct.respond_to?(m)
+          @struct.send(m, *args)
+        else
+          super
+        end
+      end
+
+      # Adds a variable binding to the pdu.
+      # Options:
+      # * +oid+ The SNMP OID
+      # * +type+ The data type.  Possible values include Net::SNMP::ASN_OCTET_STR, Net::SNMP::ASN_COUNTER, etc.  See constants.rb
+      # * +value+  The value of the varbind.  default is nil.
+      def add_varbind(options)
+        options[:type] ||= case options[:value]
+          when String
+            Constants::ASN_OCTET_STR
+          when Fixnum
+            Constants::ASN_INTEGER
+          when Net::SNMP::OID
+            Constants::ASN_OBJECT_ID
+          when nil
+            Constants::ASN_NULL
+          else
+            raise "Unknown value type"
+        end
+
+        value = options[:value]
+        value_len = case options[:type]
+        when Constants::ASN_NULL,
+            Constants::SNMP_NOSUCHOBJECT,
+            Constants::SNMP_NOSUCHINSTANCE,
+            Constants::SNMP_ENDOFMIBVIEW
+          0
+        else
+          options[:value].size
+        end
+
+        value = case options[:type]
+          when Constants::ASN_INTEGER,
+              Constants::ASN_GAUGE,
+              Constants::ASN_COUNTER,
+              Constants::ASN_TIMETICKS,
+              Constants::ASN_UNSIGNED
+            new_val = FFI::MemoryPointer.new(:long)
+            new_val.write_long(value)
+            new_val
+          when Constants::ASN_OCTET_STR,
+              Constants::ASN_BIT_STR,
+              Constants::ASN_OPAQUE
+            value
+          when Constants::ASN_IPADDRESS
+            # TODO
+          when Constants::ASN_OBJECT_ID
+            value.pointer
+          when Constants::ASN_NULL,
+              Constants::SNMP_NOSUCHOBJECT,
+              Constants::SNMP_NOSUCHINSTANCE,
+              Constants::SNMP_ENDOFMIBVIEW
+            nil
+          else
+            if value.respond_to?(:pointer)
+              value.pointer
+            else
+              raise Net::SNMP::Error.new, "Unknown variable type #{options[:type]}"
+            end
+        end
+
+        oid = options[:oid].kind_of?(OID) ? options[:oid] : OID.new(options[:oid])
+        var_ptr = Wrapper.snmp_pdu_add_variable(@struct.pointer, oid.pointer, oid.length_pointer.read_int, options[:type], value, value_len)
+        varbind = Varbind.new(var_ptr)
+        varbinds << varbind
+      end
+
+      def print_errors
+        puts "errstat = #{self.errstat}, index = #{self.errindex}, message = #{self.error_message}"
+      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
+        if @i_own_enterprise
+          FFI::LibC.free(@struct.enterprise) unless @struct.enterprise.null?
+          @struct.enterprise = FFI::Pointer::NULL
+        end
+        Wrapper.snmp_free_pdu(@struct.pointer)
+      end
+
+      def print
+        puts "PDU"
+        if command == Constants::SNMP_MSG_TRAP
+            puts " - Enterprise: #{enterprise}"
+            puts " - Trap Type: #{trap_type}"
+            puts " - Specific Type: #{specific_type}"
+            puts " - Agent Addr: #{agent_addr}"
+        end
+
+        puts " - Varbinds:"
+        varbinds.each do |v|
+          puts "   + #{MIB.translate(v.oid.to_s)}(#{v.oid}) = #{v.value}"
+        end
+      end
+
+    end
+  end
+end