net-snmp 0.1.7 → 0.2.0

data/lib/net/snmp/error.rb

@@ -1,22 +1,30 @@
 module Net
   module SNMP
     class Error < RuntimeError
-      #attr :status, :errno, :snmp_err, :snmp_msg
-      
+      attr_accessor :status, :errno, :snmp_err, :snmp_msg
       def initialize(opts = {})
         @status = opts[:status]
+        @fiber = opts[:fiber]
         if opts[:session]
-          errno_ptr = FFI::MemoryPointer.new(:int)
-          snmp_err_ptr = FFI::MemoryPointer.new(:int)
-          msg_ptr = FFI::MemoryPointer.new(:pointer)
-          Wrapper.snmp_error(opts[:session].pointer, errno_ptr, snmp_err_ptr, msg_ptr)
-
-          @errno = errno_ptr.read_int
-          @snmp_err = snmp_err_ptr.read_int
-          @snmp_msg = msg_ptr.read_pointer.read_string
+          @errno = opts[:session].errno
+          @snmp_err = opts[:session].snmp_err
+          @snmp_msg = opts[:session].error_message
         end
+
+      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/inline.rb

@@ -5,21 +5,11 @@ module Net
 
       inline do |builder|
         builder.include "sys/select.h"
-        builder.include "stdio.h"
-        builder.library "netsnmp"
+        #builder.include "stdio.h"
+        #builder.library "netsnmp"
         builder.c %q{
-          int snmp_process_callbacks() {
-            int fds = 0, block = 1;
-            fd_set fdset;
-            struct timeval timeout;
-            FD_ZERO(&fdset);
-            snmp_select_info(&fds, &fdset, &timeout, &block);
-            fds = select(fds, &fdset, 0,0, block ? 0 : &timeout);
-            if(fds) {
-              snmp_read(&fdset);
-            } else {
-              snmp_timeout();
-            }
+          int fd_setsize() {
+            return(FD_SETSIZE);
           }
         }
 

data/lib/net/snmp/oid.rb

@@ -2,12 +2,15 @@ module Net
   module SNMP
     class OID
       attr_reader :oid, :pointer, :length_pointer
+
+      def from_pointer(ptr, len)
+        
+      end
       def initialize(oid)
         @oid = oid
         @pointer = FFI::MemoryPointer.new(:ulong, 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)
@@ -22,8 +25,9 @@ module Net
       end
 
       def size
-        @length_pointer.read_int
+        @length_pointer.read_int * 8 # XXX 8 = sizeof(oid) on my system.  Not sure if it's different on others
       end
+
       def oid
         @oid
       end

data/lib/net/snmp/pdu.rb

@@ -1,15 +1,25 @@
 module Net 
   module SNMP
     class PDU
+      # == Represents an SNMP PDU
+      #
+      #  Wrapper around netsnmp_pdu.
+      # * +varbinds+ returns a list of variable bindings
+      # * +errstat+ returns the error code.  See constants.rb
+      # * +errindex+ returns the index of the varbind causing the error.
       extend Forwardable
-      attr_accessor :struct, :varbinds, :callback
+      include Net::SNMP::Debug
+      attr_accessor :struct, :varbinds, :callback, :command
       def_delegators :struct, :pointer
 
-      def initialize(arg)
+      # 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 arg
+        case pdu_type
         when FFI::Pointer
-          @struct = Wrapper::SnmpPdu.new(arg)
+          @struct = Wrapper::SnmpPdu.new(pdu_type)
+          @command = @struct.command
           v = @struct[:variables]
           if v
             @varbinds << Varbind.from_pointer(v)
@@ -19,9 +29,10 @@ module Net
             @varbinds << Varbind.from_pointer(v)
           end
         when Fixnum
-          @struct = Wrapper.snmp_pdu_create(arg)
+          @struct = Wrapper.snmp_pdu_create(pdu_type)
+          @command = pdu_type
         else
-          raise "invalid type"
+          raise Error.new, "invalid pdu type"
         end
       end
 
@@ -65,12 +76,20 @@ module Net
         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)
+        #puts "adding varbind #{options.inspect}"
         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
@@ -78,39 +97,59 @@ module Net
         end
 
         value = options[:value]
-        value_len = case options[:value]
-          when String
-            options[:value].length
-          when nil
+        value_len = case options[:type]
+          when Constants::ASN_NULL
             0
           else
             options[:value].size
         end
 
-
-        if value.respond_to?(:pointer)
-          value = value.pointer
+        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
+            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?(Net::SNMP::OID) ? options[:oid] : Net::SNMP::OID.new(options[:oid])
-        oid = Net::SNMP::OID.new(options[:oid])
+        oid = options[:oid].kind_of?(Net::SNMP::OID) ? options[:oid] : Net::SNMP::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)
         #Wrapper.print_varbind(varbind.struct)
         varbinds << varbind
       end
-      
+
+      # Returns true if pdu is in error
       def error?
-        errstat != 0
+        self.errstat != 0
       end
-      
+
+      # A descriptive error message
       def error_message
-        Wrapper::snmp_errstring(errstat)
+        Wrapper::snmp_errstring(self.errstat)
       end
 
+      # Free the pdu
       def free
         Wrapper.snmp_free_pdu(@struct.pointer)
       end
+
+      def print
+        puts pdu.inspect
+      end
     end
   end
 end

data/lib/net/snmp/session.rb

@@ -4,7 +4,11 @@ require 'pp'
 module Net
   module SNMP
     class Session
+      # == SNMP Session
+      #
+      # Provides API for interacting with a host with snmp
       extend Forwardable
+      include Net::SNMP::Debug
       attr_accessor :struct, :callback, :requests, :peername, :community
       attr_reader :version
       def_delegator :@struct, :pointer
@@ -14,17 +18,34 @@ module Net
 
       class << self
         attr_accessor :sessions, :lock
+
+        # Open a new session.  Accepts a block which yields the session.
+        #
+        #   Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :community => 'public') do |sess|
+        #     pdu = sess.get(["sysDescr.0"])
+        #     pdu.print
+        #   end
+        # Options:
+        # * +peername+ - hostname
+        # * +community+ - snmp community string.  Default is public
+        # * +version+ - snmp version.  Possible values include 1, '2c', and 3. Default is 1.
+        # * +timeout+ - snmp timeout in seconds
+        # * +retries+ - snmp retries.  default = 5
+        # Returns:
+        # Net::SNMP::Session
+
         def open(options = {})
           #puts "building session"
           session = new(options)
-          @lock.synchronize {
-            @sessions[session.sessid] = session
-          }
-          #puts "done building"
+          if Net::SNMP::thread_safe
+            Net::SNMP::Session.lock.synchronize {
+              Net::SNMP::Session.sessions[session.sessid] = session
+            }
+          else
+            Net::SNMP::Session.sessions[session.sessid] = session
+          end
           if block_given?
-            #puts "calling block"
             yield session
-
           end
           session
         end
@@ -32,13 +53,15 @@ module Net
 
       def initialize(options = {})
         #puts "in initialize"
+        @timeout = options[:timeout] || 1
+        @retries = options[:retries] || 5
         @requests = {}
         @peername = options[:peername] || 'localhost'
+        @peername = "#{@peername}:#{options[:port]}" if options[:port]
         @community = options[:community] || "public"
         options[:community_len] = @community.length
         @version = options[:version] || 1
         options[:version] ||= Constants::SNMP_VERSION_1
-        @callback = options[:callback]
         @version = options[:version] || 1
         #self.class.sessions << self
         @sess = Wrapper::SnmpSession.new(nil)
@@ -47,6 +70,7 @@ module Net
         @sess.community = FFI::MemoryPointer.from_string(@community)
         @sess.community_len = @community.length
         @sess.peername = FFI::MemoryPointer.from_string(@peername)
+        #@sess.remote_port = options[:port] || 162
         @sess.version = case options[:version].to_s
         when '1'
           Constants::SNMP_VERSION_1
@@ -57,23 +81,19 @@ module Net
         else
           Constants::SNMP_VERSION_1
         end
+        debug "setting timeout = #{@timeout} retries = #{@retries}"
+        @sess.timeout = @timeout * 1000000
+        @sess.retries = @retries
 
-        if options[:timeout]
-          @sess.timeout = options[:timeout] * 1000000
-        end
-        if options[:retries]
-          @sess.retries = options[:retries]
-        end
         if @sess.version == Constants::SNMP_VERSION_3
           @sess.securityLevel = options[:security_level] || Constants::SNMP_SEC_LEVEL_NOAUTH
-
           @sess.securityAuthProto = case options[:auth_protocol]
               when :sha1
-                Net::SNMP::OID.new("1.3.6.1.6.3.10.1.1.3").pointer
+                OID.new("1.3.6.1.6.3.10.1.1.3").pointer
               when :md5
-                Net::SNMP::OID.new("1.3.6.1.6.3.10.1.1.2").pointer
+                OID.new("1.3.6.1.6.3.10.1.1.2").pointer
               when nil
-                Net::SNMP::OID.new("1.3.6.1.6.3.10.1.1.1").pointer
+                OID.new("1.3.6.1.6.3.10.1.1.1").pointer
           end
           
           @sess.securityAuthProtoLen = 10
@@ -97,32 +117,28 @@ module Net
           end
         end
         # General callback just takes the pdu, calls the session callback if any, then the request specific callback.
-        @sess.callback = lambda do |operation, session, reqid, pdu_ptr, magic|
-          #puts "callback is #{callback.inspect}"
-          #callback.call(operation, reqid, pdu, magic) if callback
 
-          if @requests[reqid]
-            pdu = Net::SNMP::PDU.new(pdu_ptr)
-            @requests[reqid].call(pdu)
-            @requests.delete(reqid)
-          end
-          0
-        end
         @struct = Wrapper.snmp_sess_open(@sess.pointer)
-        #@handle = Wrapper.snmp_sess_open(@sess.pointer)
-        #@struct = Wrapper.snmp_sess_session(@handle)
       end
 
 
+      # Close the snmp session and free associated resources.
       def close
-        Net::SNMP::Session.lock.synchronize {
+        if Net::SNMP.thread_safe
+          self.class.lock.synchronize {
+            Wrapper.snmp_sess_close(@struct)
+            self.class.sessions.delete(self.sessid)
+          }
+        else
           Wrapper.snmp_sess_close(@struct)
-          Net::SNMP::Session.sessions.delete(self.sessid)
-        }
+          self.class.sessions.delete(self.sessid)
+        end
       end
 
-      def get(oidlist, options = {}, &block)
-        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GET)
+      # Issue an SNMP GET Request.
+      # See #send_pdu
+      def get(oidlist, &block)
+        pdu = PDU.new(Constants::SNMP_MSG_GET)
         oidlist = [oidlist] unless oidlist.kind_of?(Array)
         oidlist.each do |oid|
           pdu.add_varbind(:oid => oid)
@@ -130,8 +146,10 @@ module Net
         send_pdu(pdu, &block)
       end
 
-      def get_next(oidlist, options = {}, &block)
-        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GETNEXT)
+      # Issue an SNMP GETNEXT Request
+      # See #send_pdu
+      def get_next(oidlist, &block)
+        pdu = PDU.new(Constants::SNMP_MSG_GETNEXT)
         oidlist = [oidlist] unless oidlist.kind_of?(Array)
         oidlist.each do |oid|
           pdu.add_varbind(:oid => oid)
@@ -139,8 +157,10 @@ module Net
         send_pdu(pdu, &block)
       end
 
+      # Issue an SNMP GETBULK Request
+      # See #send_pdu
       def get_bulk(oidlist, options = {}, &block)
-        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GETBULK)
+        pdu = PDU.new(Constants::SNMP_MSG_GETBULK)
         oidlist = [oidlist] unless oidlist.kind_of?(Array)
         oidlist.each do |oid|
           pdu.add_varbind(:oid => oid)
@@ -151,9 +171,10 @@ module Net
       end
 
 
-
-      def set(oidlist, options = {}, &block)
-        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_SET)
+      # Issue an SNMP Set Request
+      # See #send_pdu
+      def set(oidlist, &block)
+        pdu = PDU.new(Constants::SNMP_MSG_SET)
         oidlist.each do |oid|
           pdu.add_varbind(:oid => oid[0], :type => oid[1], :value => oid[2])
         end
@@ -169,187 +190,260 @@ module Net
       end
 
 
-      # XXX This needs work.  Need to use getbulk for speed, guess maxrepeaters, etc..
-      # Also need to figure out how we can tell column names from something like ifTable
-      # instead of ifEntry.  Needs to handle errors, there are probably offset problems
-      # in cases of bad data, and various other problems.  Also need to add async support.
-      # Maybe return a hash with index as key?
-      def get_table(table_name, options = {})
-        column_names = options[:columns] || Net::SNMP::MIB::Node.get_node(table_name).children.collect {|c| c.label }
-        results = []
-
-        first_result = get_next(column_names)
-        oidlist = []
-        good_column_names = []
-        row = {}
-
-        first_result.varbinds.each_with_index do |vb, idx|
-          oid = vb.oid
-          if oid.label[0..column_names[idx].length - 1] == column_names[idx]
-            oidlist << oid.label
-            good_column_names << column_names[idx]
-            row[column_names[idx]] = vb.value
-          end
-        end
-        results << row
 
-        catch :break_main_loop do
-          while(result = get_next(oidlist))
-            oidlist = []
-            row = {}
-            result.varbinds.each_with_index do |vb, idx|
-              #puts "got #{vb.oid.label} #{vb.value.inspect}, type = #{vb.object_type}"
-              row[good_column_names[idx]] = vb.value
-              oidlist << vb.oid.label
-              if vb.oid.label[0..good_column_names[idx].length - 1] != good_column_names[idx]
-                throw :break_main_loop
-              end
-            end
-            results << row
-          end
-        end
-        results
-      end
-      
 
       def default_max_repeaters
         # We could do something based on transport here.  25 seems safe
         25
       end
 
-      def get_columns(columns, options = {})
-        column_oids = columns.map {|c| Net::SNMP::OID.new(c)}
-        options[:max_repetitions] ||= default_max_repeaters / columns.size
-        results = {}
-        if version == 1
-        else
-          while(result = get_bulk(columns, options))
-            result.varbinds.each do |vb|
-              match = column_oids.select {|c| vb.oid.oid =~ /^#{c.oid}/ }
-            end
-          end
 
-        end
-      end
 
-      def error(msg)
-        Wrapper.snmp_perror(msg)
-        Wrapper.snmp_sess_perror(msg, @sess.pointer)
-        
-        #Wrapper.print_session(self.struct)
-        raise Net::SNMP::Error.new({:session => self}), msg
+      # Raise a NET::SNMP::Error with the session attached
+      def error(msg, options = {})
+        #Wrapper.snmp_sess_perror(msg, @sess.pointer)
+        raise Error.new({:session => self}.merge(options)), msg
       end
       
 
-      def trap(options = {})
-        pdu = PDU.new(Constants::SNMP_MSG_TRAP)
-        options[:enterprise] ||= '1.3.6.1.4.1.3.1.1'  # uh, just send netsnmp enterprise i guess
-        pdu.enterprise = OID.new(options[:enterprise])
-        pdu.trap_type = options[:trap_type] || 1  # need to check all these defaults
-        pdu.specific_type = options[:specific_type] || 0
-        pdu.time = 1    # put what here?
-        send_pdu(pdu)
-        true
-      end
-
-
-      def trap_v2(options = {})
-        pdu = PDU.new(Constants::SNMP_MSG_TRAP2)
-        build_trap_pdu(pdu, options)
-        send_pdu(pdu)
-      end
-
-      def inform(options = {}, &block)
-        pdu = PDU.new(Constants::SNMP_MSG_INFORM)
-        build_trap_pdu(pdu, options)
-        send_pdu(pdu, &block)
-      end
-
-      def poll(timeout = nil)
-        
-          fdset = Net::SNMP::Wrapper.get_fd_set
+      # Check the session for SNMP responses from asynchronous SNMP requests
+      # This method will check for new responses and call the associated
+      # response callbacks.
+      # +timeout+  A timeout of nil indicates a poll and will return immediately.
+      # A value of false will block until data is available.  Otherwise, pass
+      # the number of seconds to block.
+      # Returns the number of file descriptors handled.
+      def select(timeout = nil)
+          fdset = FFI::MemoryPointer.new(:pointer, Net::SNMP::Inline.fd_setsize / 8)
           num_fds = FFI::MemoryPointer.new(:int)
           tv_sec = timeout ? timeout.round : 0
           tv_usec = timeout ? (timeout - timeout.round) * 1000000 : 0
-          tval = Net::SNMP::Wrapper::TimeVal.new(:tv_sec => tv_sec, :tv_usec => tv_usec)
+          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
-          #puts "calling snmp_select_info"
-          num = Net::SNMP::Wrapper.snmp_sess_select_info(@struct, num_fds, fdset, tval.pointer, block )
-          num_ready = 0
-          #puts "block = #{block.read_int}"
-
-          #puts "numready = #{num_fds.read_int}"
-          #puts "tv = #{tval[:tv_sec]} #{tval[:tv_usec]}"
-          #puts "timeout = #{timeout}"
+
+          Wrapper.snmp_sess_select_info(@struct, num_fds, fdset, tval.pointer, block )
           tv = (timeout == false ? nil : tval)
-          #puts "calling select"
-          #puts "tv = #{tv.inspect}"
-          #puts "calling select with #{num_fds.read_int}"
-          #num_ready = RubyWrapper.rb_thread_select(num_fds.read_int, fdset, nil, nil, tv)
-          num_ready = Net::SNMP::Wrapper.select(num_fds.read_int, fdset, nil, nil, tv)
-          #puts "done select.  num_ready = #{num_ready}"
+          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
-            Net::SNMP::Wrapper.snmp_sess_read(@struct, fdset)
+            Wrapper.snmp_sess_read(@struct, fdset)
           elsif num_ready == 0
-            # timeout.  do something here?  or just return 0?
+            Wrapper.snmp_sess_timeout(@struct)
           elsif num_ready == -1
             # error.  check snmp_error?
+            error("select")
           else
-            # uhhh
+            error("wtf is wrong with select?")
           end
-          #puts "done snmp_read"
           num_ready
       end
 
-      private
-      def send_pdu(pdu, &block)
+      alias :poll :select
+
+
+
+      # Send a PDU
+      # +pdu+  The Net::SNMP::PDU object to send.  Usually created by Session.get, Session.getnext, etc.
+      # +callback+ An optional callback.  It should take two parameters, status and response_pdu.
+      # If no +callback+ is given, the call will block until the response is available and will return
+      # the response pdu.  If an error occurs, a Net::SNMP::Error will be thrown.
+      # If +callback+ is passed, the PDU will be sent and +send_pdu+ will return immediately.  You must
+      # then call Session.select to invoke the callback.  This is usually done in some sort of event loop.
+      # See Net::SNMP::Dispatcher.
+      #
+      # If you're running inside eventmachine and have fibers (ruby 1.9, jruby, etc), sychronous calls will
+      # actually run asynchronously behind the scenes.  Just run Net::SNMP::Dispatcher.fiber_loop in your
+      # reactor.
+      #
+      #   pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GET)
+      #   pdu.add_varbind(:oid => 'sysDescr.0')
+      #   session.send_pdu(pdu) do |status, pdu|
+      #     if status == :success
+      #       pdu.print
+      #     elsif status == :timeout
+      #       puts "Timed Out"
+      #     else
+      #       puts "A problem occurred"
+      #     end
+      #   end
+      #   session.select(false)  #block until data is ready.  Callback will be called.
+      #   begin
+      #     result = session.send_pdu(pdu)
+      #     puts result.inspect
+      #   rescue Net::SNMP::Error => e
+      #     puts e.message
+      #   end
+      def send_pdu(pdu, &callback)
         #puts "send_pdu #{Fiber.current.inspect}"
-        if defined?(EM) && EM.reactor_running? && !block_given?
-          #puts "REACTORRUNNING"
-          f = Fiber.current
-
-          send_pdu pdu do | response |
-            f.resume(response)
+        if block_given?
+          @requests[pdu.reqid] = callback
+          puts "calling async_send"
+          if Wrapper.snmp_sess_async_send(@struct, pdu.pointer, sess_callback, nil) == 0
+            error("snmp_get async failed")
           end
-          Fiber.yield
+          #pdu.free
+          nil
         else
-          if block
-            @requests[pdu.reqid] = block
-            if (status = Net::SNMP::Wrapper.snmp_sess_send(@struct, pdu.pointer)) == 0
-              error("snmp_get async failed")
+          if 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
-            #pdu.free
-            nil
           else
             response_ptr = FFI::MemoryPointer.new(:pointer)
-            #Net::SNMP::Wrapper.print_session(@struct)
-            #Net::SNMP::Wrapper.print_pdu(pdu.struct)
-            #if pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP
-            #  status = Net::SNMP::Wrapper.snmp_sess_send(@struct, pdu.pointer) == 1 ? 0 : 1
-            #else
-              status = Net::SNMP::Wrapper.snmp_sess_synch_response(@struct, pdu.pointer, response_ptr)
-            #end
-            #pdu.free  #causing segfaults
-            if status != 0
-              error("snmp_get failed #{status}")
+            if [Constants::SNMP_MSG_TRAP, Constants::SNMP_MSG_TRAP2].include?(pdu.command)
+              status = Wrapper.snmp_sess_send(@struct, pdu.pointer)
+              if status == 0
+                error("snmp_sess_send")
+              end
             else
-              #Net::SNMP::Wrapper.print_pdu(Net::SNMP::Wrapper::SnmpPdu.new(response_ptr.read_pointer))
-              #if pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP
-                Net::SNMP::PDU.new(response_ptr.read_pointer)
-              #else
-              #  1
-              #end
-              
+              status = Wrapper.snmp_sess_synch_response(@struct, pdu.pointer, response_ptr)
+              unless status == Constants::STAT_SUCCESS
+                error("snmp_sess_synch_response", :status => status)
+              end
             end
+            if [Constants::SNMP_MSG_TRAP, Constants::SNMP_MSG_TRAP2].include?(pdu.command)
+              1
+            else
+              PDU.new(response_ptr.read_pointer)
+            end
+          end
+        end
+      end
+
+      def errno
+        get_error
+        @errno
+      end
+
+      # The SNMP Session error code
+      def snmp_err
+        get_error
+        @snmp_err
+      end
+
+      # The SNMP Session error message
+      def error_message
+        get_error
+        @snmp_msg
+      end
+      
+      private
+      def sess_callback
+        @sess_callback ||= FFI::Function.new(:int, [:int, :pointer, :int, :pointer, :pointer]) do |operation, session, reqid, pdu_ptr, magic|
+          #puts "in callback #{operation.inspect} #{session.inspect}"
+          op = case operation
+            when Constants::NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE
+              :success
+            when Constants::NETSNMP_CALLBACK_OP_TIMED_OUT
+              :timeout
+            when Constants::NETSNMP_CALLBACK_OP_SEND_FAILED
+              :send_failed
+            when Constants::NETSNMP_CALLBACK_OP_CONNECT
+              :connect
+            when Constants::NETSNMP_CALLBACK_OP_DISCONNECT
+              :disconnect
+            else
+              error "Invalid PDU Operation"
+          end
+
+          if @requests[reqid]
+            pdu = PDU.new(pdu_ptr)
+            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)
+          else
+            0# Do what here?  Can this happen?  Maybe request timed out and was deleted?
           end
         end
       end
+      def get_error
+          errno_ptr = FFI::MemoryPointer.new(:int)
+          snmp_err_ptr = FFI::MemoryPointer.new(:int)
+          msg_ptr = FFI::MemoryPointer.new(:pointer)
+          Wrapper.snmp_sess_error(@struct.pointer, errno_ptr, snmp_err_ptr, msg_ptr)
+          @errno = errno_ptr.read_int
+          @snmp_err = snmp_err_ptr.read_int
+          @snmp_msg = msg_ptr.read_pointer.read_string
+      end
+
+      public
+      # XXX This needs work.  Need to use getbulk for speed, guess maxrepeaters, etc..
+      # Also need to figure out how we can tell column names from something like ifTable
+      # instead of ifEntry.  Needs to handle errors, there are probably offset problems
+      # in cases of bad data, and various other problems.  Also need to add async support.
+      # Maybe return a hash with index as key?
+      def get_table(table_name, options = {})
+        column_names = options[:columns] || MIB::Node.get_node(table_name).children.collect {|c| c.label }
+        results = []
+
+#        repeat_count = if @version.to_s == '1' || options[:no_getbulk]
+#            1
+#          elsif options[:repeat_count]
+#            options[:repeat_count]
+#          else
+#            (1000 / 36 / (column_names.size + 1)).to_i
+#        end
+#
+#        res = if @version.to_s != '1' && !options[:no_getbulk]
+#          get_bulk(column_names, :max_repetitions => repeat_count)
+#        else
+#          get_next(column_names)
+#        end
+
+
+        first_result = get_next(column_names)
+        oidlist = []
+        good_column_names = []
+        row = {}
+
+        first_result.varbinds.each_with_index do |vb, idx|
+          oid = vb.oid
+          if oid.label[0..column_names[idx].length - 1] == column_names[idx]
+            oidlist << oid.label
+            good_column_names << column_names[idx]
+            row[column_names[idx]] = vb.value
+          end
+        end
+        results << row
+
+        catch :break_main_loop do
+          while(result = get_next(oidlist))
+            oidlist = []
+            row = {}
+            result.varbinds.each_with_index do |vb, idx|
+              #puts "got #{vb.oid.label} #{vb.value.inspect}, type = #{vb.object_type}"
+              row[good_column_names[idx]] = vb.value
+              oidlist << vb.oid.label
+              if vb.oid.label[0..good_column_names[idx].length - 1] != good_column_names[idx]
+                throw :break_main_loop
+              end
+            end
+            results << row
+          end
+        end
+        results
+      end
+
 
 #      def get_entries_cb(pdu, columns, options)
 #        cache = {}
@@ -372,22 +466,8 @@ module Net
 #          end
 #        end
 #      end
-
-
-
-
-
-      def build_trap_pdu(pdu, options = {})
-        pdu.add_varbind(:oid => OID.new('sysUpTime'), :type => Constants::ASN_TIMETICKS, :value => 0)
-        pdu.add_varbind(:oid => OID.new('snmpTrapOID'), :type => Constants::ASN_OBJECT_ID, :value => options[:oid])
-        if options[:varbinds]
-          options[:varbinds].each do |vb|
-            pdu.add_varbind(vb)
-          end
-        end
-      end
-
-
     end
   end
 end
+
+