netsnmp 0.0.0

data/lib/netsnmp/core/structures.rb

@@ -0,0 +1,167 @@
+module NETSNMP::Core
+  # Maps to the relevant netsnmp C library structs. 
+  module Structures
+    extend FFI::Library
+    typedef :u_long, :oid
+
+    callback(:snmp_callback, [ :int, :pointer, :int, :pointer, :pointer ], :int)
+    callback(:netsnmp_callback, [ :int, :pointer, :int, :pointer, :pointer ], :int)
+
+    class SessionList < FFI::Struct
+      layout(
+        :next, :pointer,
+        :session, :pointer,
+        :transport, :pointer,
+        :internal, :pointer
+      )
+    end
+
+    class Transport < FFI::Struct
+      layout(
+        :domain, :pointer,
+        :domain_length, :int,
+        :local, :pointer,
+        :local_length, :int,
+        :remote, :pointer,
+        :remote_length, :int,
+        :sock, :int,
+        :flags, :u_int, 
+        :data, :pointer,
+        :data_length, :int,
+        :msgMaxSize, :size_t,
+        :base_transport, :pointer
+      )
+    end
+
+    class Session < FFI::Struct
+      layout(
+        :version, :long,
+        :retries, :int,
+        :timeout, :long,
+        :flags, :u_long,
+        :subsession, :pointer,
+        :next, :pointer,
+        :peername, :pointer,
+        :remote_port, :u_short,
+        :localname, :pointer,
+        :local_port, :u_short,
+        :authenticator, callback([ :pointer, :pointer, :pointer, :uint ], :pointer),
+        :callback, :netsnmp_callback,
+        :callback_magic, :pointer,
+        :s_errno, :int,
+        :s_snmp_errno, :int,
+        :sessid, :long,
+        :community, :pointer,
+        :community_len, :size_t,
+        :rcvMsgMaxSize, :size_t,
+        :sndMsgMaxSize, :size_t,
+        :isAuthoritative, :u_char,
+        :contextEngineID, :pointer,
+        :contextEngineIDLen, :size_t,
+        :engineBoots, :u_int,
+        :engineTime, :u_int,
+        :contextName, :pointer,
+        :contextNameLen, :size_t,
+        :securityEngineID, :pointer,
+        :securityEngineIDLen, :size_t,
+        :securityName, :pointer,
+        :securityNameLen, :size_t,
+        :securityAuthProto, :pointer,
+        :securityAuthProtoLen, :size_t,
+        :securityAuthKey, [:u_char, 32],
+        :securityAuthKeyLen, :size_t,
+        :securityAuthLocalKey, :pointer,
+        :securityAuthLocalKeyLen, :size_t,
+        :securityPrivProto, :pointer,
+        :securityPrivProtoLen, :size_t,
+        :securityPrivKey, [:u_char, 32],
+        :securityPrivKeyLen, :size_t,
+        :securityPrivLocalKey, :pointer,
+        :securityPrivLocalKeyLen, :size_t,
+        :securityModel, :int,
+        :securityLevel, :int,
+        :paramName, :pointer,
+        :securityInfo, :pointer,
+        :myvoid, :pointer
+      )
+    end
+
+    class Vardata < FFI::Union
+      layout(
+        :integer, :pointer,
+        :string, :pointer,
+        :objid, :pointer,
+        :bitstring, :pointer,
+        :counter64, :pointer,
+        :float, :pointer,
+        :double, :pointer
+      )
+    end
+
+    class VariableList < FFI::Struct
+      layout(
+        :next_variable, :pointer,#VariableList.typed_pointer,
+        :name, :pointer,
+        :name_length, :size_t,
+        :type, :u_char,
+        :val, Vardata,
+        :val_len, :size_t,
+        :name_loc, [:oid, Constants::MAX_OID_LEN],
+        :buf, [:u_char, 40],
+        :data, :pointer,
+        :dataFreeHook, callback([ :pointer ], :void),
+        :index, :int
+      )
+    end
+
+
+    class PDU < FFI::Struct
+      layout(
+         :version, :long,
+         :command, :int,
+         :reqid, :long,
+         :msgid, :long,
+         :transid, :long,
+         :sessid, :long,
+         :errstat, :long,
+         :errindex, :long,
+         :time, :u_long,
+         :flags, :u_long,
+         :securityModel, :int,
+         :securityLevel, :int,
+         :msgParseModel, :int,
+         :transport_data, :pointer,
+         :transport_data_length, :int,
+         :tDomain, :pointer,
+         :tDomainLen, :size_t,
+         :variables, :pointer,
+         :community, :pointer,
+         :community_len, :size_t,
+         :enterprise, :pointer,
+         :enterprise_length, :size_t,
+         :trap_type, :long,
+         :specific_type, :long,
+         :agent_addr, [:uchar, 4],
+         :contextEngineID, :pointer,
+         :contextEngineIDLen, :size_t,
+         :contextName, :pointer,
+         :contextNameLen, :size_t,
+         :securityEngineID, :pointer,
+         :securityEngineIDLen, :size_t,
+         :securityName, :pointer,
+         :securityNameLen, :size_t,
+         :priority, :int,
+         :range_subid, :int,
+         :securityStateRef, :pointer
+      )
+    end
+
+    class Counter64 < FFI::Struct
+      layout(
+        :high, :u_long,
+        :low, :u_long
+      )
+    end
+
+  end
+end

data/lib/netsnmp/core/utilities.rb

@@ -0,0 +1,13 @@
+module NETSNMP::Core
+
+  def self.version
+    LibSNMP.netsnmp_get_version
+  end
+
+
+  # Do not support versions lower than 5.5, as they're mostly buggy.
+  if version < "5.5"
+    raise LoadError, "The netsnmp version #{version} is incompatible with this version of ffi-netsnmp-core"
+  end
+
+end

data/lib/netsnmp/errors.rb

@@ -0,0 +1,8 @@
+module NETSNMP
+  Error = Class.new(StandardError)
+  ConnectionFailed = Class.new(Error)
+  AuthenticationFailed = Class.new(Error)
+
+  SendError = Class.new(Error)
+  ReceiveError = Class.new(Error)
+end

data/lib/netsnmp/handlers/celluloid.rb

@@ -0,0 +1,27 @@
+require 'netsnmp'
+module NETSNMP
+  module Celluloid 
+    class Client < ::NETSNMP::Client
+
+      def initialize(*args)
+        @session = Celluloid::Session.new(*args)
+        super
+      end
+
+    end
+
+    class Session < ::NETSNMP::Session
+      def wait_readable
+        return super unless ::Celluloid::IO.evented?
+        ::Celluloid::IO.wait_readable(transport)
+        [[transport]]
+      end
+
+      def wait_writable
+        return super unless ::Celluloid::IO.evented?
+        ::Celluloid::IO.wait_writable(transport)
+        [[],[transport]]
+      end
+    end
+  end
+end

data/lib/netsnmp/handlers/em.rb

@@ -0,0 +1,56 @@
+require 'netsnmp'
+module NETSNMP
+  module EM
+    class Client < ::NETSNMP::Client
+
+      def initialize(*args)
+        @session = EM::Session.new(*args)
+        super
+      end
+
+    end
+
+    class Session < ::NETSNMP::Session
+      module Watcher
+        def initialize(client, deferable)
+          @client = client
+          @deferable = deferable
+          @is_watching = true
+        end
+
+        def notify_readable
+          detach
+          begin
+            operation = nil
+            @client.__send__ :async_read
+            result = @client.__send__ :handle_response
+          rescue => e
+            @deferable.fail(e)
+          else
+            @deferable.succeed(result)
+          end
+        end
+
+        def watching?
+          @is_watching
+        end
+
+        def unbind
+          @is_watching = false
+        end
+      end
+
+      def send(pdu)
+        if ::EM.reactor_running?
+          write(pdu)
+          deferable = ::EM::DefaultDeferrable.new
+          watch = ::EM.watch(transport.fileno, Watcher, self, deferable)
+          watch.notify_readable = true
+          ::EM::Synchrony.sync deferable
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/netsnmp/oid.rb

@@ -0,0 +1,94 @@
+module NETSNMP
+  # Abstracts the OID structure
+  #
+  class OID
+    Error = Class.new(Error)
+    OIDREGEX = /^[\d\.]*$/
+
+    class << self
+
+      # @return [Integer] the default oid size in bytes
+      def default_size
+        @default_size ||= Core::Inline.oid_size
+      end
+  
+      # @param [FFI::Pointer] pointer the pointer to the beginning ot the memory octet
+      # @param [Integer] length the length of the oid
+      # @return [String] the oid code (ex: "1.2.4.56.3.4.5"...)
+      #
+      def read_pointer(pointer, length)
+        pointer.__send__(:"read_array_of_uint#{default_size * 8}", length).join('.')
+      end
+  
+      # @see read_pointer
+      # @return [OID] an OID object initialized from a code read from memory
+      #
+      def from_pointer(pointer, length)
+        new(read_pointer(pointer, length))
+      end
+
+    end
+
+    attr_reader :code
+
+    # @param [String] code the oid code 
+    #
+    def initialize(code)
+      @struct = FFI::MemoryPointer.new(OID::default_size * Core::Constants::MAX_OID_LEN)
+      @length_pointer = FFI::MemoryPointer.new(:size_t)
+      @length_pointer.write_int(Core::Constants::MAX_OID_LEN)
+      existing_oid = case code
+        when OIDREGEX then Core::LibSNMP.read_objid(code, @struct, @length_pointer)
+        else Core::LibSNMP.get_node(code, @struct, @length_pointer)
+      end
+      raise Error, "unsupported oid: #{code}" if existing_oid.zero?
+    end
+
+    # @return [String] the oid code
+    # 
+    def code ; @code ||= OID.read_pointer(pointer, length) ; end 
+    
+    # @return [String] the pointer to the structure 
+    # 
+    def pointer ; @struct ; end
+
+    # @return [Integer] length of the oid 
+    #     
+    def length ; @length_pointer.read_int ; end
+
+    # @return [Integer] size of the oid 
+    #     
+    def size ; length * NETSNMP::OID.default_size ; end
+
+    def to_s ; code ; end
+
+    # @param [OID, String] child oid another oid
+    # @return [true, false] whether the given OID belongs to the sub-tree
+    #
+    def parent_of?(child_oid)
+      child_code = child_oid.is_a?(OID) ? child_oid.code : child_oid
+      child_code.start_with?(code)
+    end
+  end
+
+  # SNMP v3-relevant OIDs
+
+  class MD5OID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.1.2") ; end
+  end
+  class SHA1OID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.1.3") ; end
+  end
+  class NoAuthOID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.1.1") ; end
+  end
+  class AESOID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.2.4") ; end
+  end
+  class DESOID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.2.2") ; end
+  end
+  class NoPrivOID < OID
+    def initialize ; super("1.3.6.1.6.3.10.1.2.1") ; end
+  end 
+end

data/lib/netsnmp/pdu.rb

@@ -0,0 +1,105 @@
+require 'forwardable'
+module NETSNMP
+  # Abstracts the PDU base structure into a ruby object. It gives access to its varbinds.
+  #
+  class PDU
+    extend Forwardable 
+
+    Error = Class.new(Error)
+    class << self
+      # factory method that abstracts initialization of the pdu types that the library supports.
+      # 
+      # @param [Symbol] type the type of pdu structure to build
+      # @return [RequestPDU] a fully-formed request pdu
+      # 
+      def build(type, *args)
+        case type
+          when :get       then RequestPDU.new(Core::Constants::SNMP_MSG_GET, *args)
+          when :getnext   then RequestPDU.new(Core::Constants::SNMP_MSG_GETNEXT, *args)
+          when :getbulk   then RequestPDU.new(Core::Constants::SNMP_MSG_GETBULK, *args)
+          when :set       then RequestPDU.new(Core::Constants::SNMP_MSG_SET, *args)
+          when :response  then ResponsePDU.new(Core::Constants::SNMP_MSG_RESPONSE, *args)
+          else raise Error, "#{type} is not supported as type"
+        end
+      end
+    end
+
+    attr_reader :struct, :varbinds
+
+    def_delegators :@struct, :[], :[]=, :pointer
+
+    # @param [FFI::Pointer] the pointer to the initialized structure
+    #
+    def initialize(pointer)
+      @struct = Core::Structures::PDU.new(pointer)
+      @varbinds = []
+    end
+
+
+  end
+
+  # Abstracts the request PDU
+  # Main characteristic is that it has a write-only API, in that you can add varbinds to it.
+  #
+  class RequestPDU < PDU
+    def initialize(type)
+      pointer = Core::LibSNMP.snmp_pdu_create(type)
+      super(pointer)
+    end
+
+    # Adds a request varbind to the pdu
+    # 
+    # @param [OID] oid a valid oid
+    # @param [Hash] options additional request varbind options
+    # @option options [Object] :value the value for the oid
+    def add_varbind(oid, **options)
+      @varbinds << RequestVarbind.new(self, oid, options[:value], options)
+    end
+    alias_method :<<, :add_varbind
+  end
+
+  # Abstracts the response PDU
+  # Main characteristic is: it reads the values on initialization (because the response structure
+  # is at some point free'd). It is therefore a read-only entity
+  #
+  class ResponsePDU < PDU
+
+    # @param [FFI::Pointer] the pointer to the response pdu structure
+    #
+    # @note it loads the variable as well.
+    # 
+    def initialize(pointer)
+      super
+      load_variables
+    end
+
+    # @return [String] the concatenation of the varbind values (usually, it's only one)
+    # 
+    def value
+      case @varbinds.size
+        when 0 then nil
+        when 1 then @varbinds.first.value
+        else 
+          # assume that they're all strings
+          @varbinds.map(&:value).join(' ')
+      end  
+    end
+
+    private
+
+    # loads the C-level structure variables into ruby ResponseVarbind objects, 
+    # and store them as state in {{@varbinds}} 
+    def load_variables
+      variable = @struct[:variables]
+      unless variable.null?
+        @varbinds << ResponseVarbind.new(variable)
+        variable = Core::Structures::VariableList.new(variable)
+        while( !(variable = variable[:next_variable]).null? )
+          variable = Core::Structures::VariableList.new(variable)
+          @varbinds << ResponseVarbind.new(variable.pointer)
+        end
+      end
+    end
+
+  end
+end