net-snmp 0.1.0

data/lib/net/snmp/oid.rb

@@ -0,0 +1,39 @@
+module Net
+  module SNMP
+    class OID
+      def initialize(oid)
+        @oid = oid
+        @oid_ptr = FFI::MemoryPointer.new(:ulong, Constants::MAX_OID_LEN)
+        @oid_len_ptr = FFI::MemoryPointer.new(:size_t)
+        @oid_len_ptr.write_int(Constants::MAX_OID_LEN)
+
+        if @oid =~ /^[\d\.]*$/
+          if Wrapper.read_objid(@oid, @oid_ptr, @oid_len_ptr) == 0
+            Wrapper.snmp_perror(@oid)
+          end
+        else
+          if Wrapper.get_node(@oid, @oid_ptr, @oid_len_ptr) == 0
+            Wrapper.snmp_perror(@oid)
+          end
+        end
+
+      end
+
+      def oid
+        @oid
+      end
+
+      def c_oid
+        @oid_ptr.read_array_of_long(@oid_len_ptr.read_int).join(".")
+      end
+
+      def pointer
+        @oid_ptr
+      end
+      def length_pointer
+        @oid_len_ptr
+      end
+
+    end
+  end
+end

data/lib/net/snmp/pdu.rb

@@ -0,0 +1,80 @@
+module Net
+  module SNMP
+    class PDU
+      extend Forwardable
+      attr_accessor :struct, :varbinds, :callback
+      def_delegators :struct, :reqid, :pointer, :errstat, :errindex, :non_repeaters=
+
+      def initialize(arg)
+        @varbinds = []
+        case arg
+        when FFI::Pointer
+          @struct = Wrapper::SnmpPdu.new(arg)
+          v = @struct[:variables]
+          if v
+            @varbinds << Varbind.from_pointer(v)
+          end
+
+          while( !(v = Wrapper::VariableList.new(v).next_variable).null? )
+            @varbinds << Varbind.from_pointer(v)
+          end
+        when Fixnum
+          @struct = Wrapper.snmp_pdu_create(arg)
+        else
+          raise "invalid type"
+        end
+      end
+
+       # For getbulk requests, repeaters and maxreps are stored in errstat and errindex
+        def non_repeaters=(nr)
+          @struct.errstat = nr
+        end
+        def non_repeaters
+          @struct.errstat
+        end
+        def max_repetitions=(mr)
+          @struct.errindex = mr
+        end
+        def max_repetitions
+          @struct.errindex
+        end
+
+
+      def add_varbind(options)
+
+        options[:type] ||= case options[:value]
+        when String
+          Constants::ASN_OCTET_STR
+        when nil
+          Constants::ASN_NULL
+        else
+          raise "Unknown value type"
+        end
+
+        value_len = case options[:value]
+        when String
+          options[:value].length
+        else
+          0
+        end
+
+
+        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], options[:value], value_len)
+        varbind = Varbind.new(var_ptr)
+        #Wrapper.print_varbind(varbind.struct)
+        varbinds << varbind
+      end
+      
+      def error?
+        errstat != 0
+      end
+      
+      def error_message
+        Wrapper::snmp_errstring(errstat)
+      end
+
+    end
+  end
+end

data/lib/net/snmp/session.rb

@@ -0,0 +1,223 @@
+require 'forwardable'
+require 'pp'
+module Net
+  module SNMP
+    class Session
+      extend Forwardable
+      attr_accessor :struct, :callback
+      def_delegator :@struct, :pointer
+      @sessions = []
+      @requests = {}
+      class << self
+        attr_accessor :sessions, :requests
+        def open(options)
+          session = new(options)
+          if block_given?
+            yield session
+          end
+          session
+        end
+      end
+
+      def initialize(options)
+        options[:community] ||= "public"
+        options[:community_len] = options[:community].length
+        options[:version] ||= Constants::SNMP_VERSION_1
+        @callback = options[:callback]
+        @requests = {}
+        self.class.sessions << self
+        @sess = Wrapper::SnmpSession.new(nil)
+        Wrapper.snmp_sess_init(@sess.pointer)
+        #options.each_pair {|k,v| ptr.send("#{k}=", v)}
+        @sess.community = FFI::MemoryPointer.from_string(options[:community])
+        @sess.community_len = options[:community].length
+        @sess.peername = FFI::MemoryPointer.from_string(options[:peername])
+        @sess.version = case options[:version].to_s
+        when '1'
+          Constants::SNMP_VERSION_1
+        when '2', '2c'
+          Constants::SNMP_VERSION_2c
+        when '3'
+          Constants::SNMP_VERSION_3
+        else
+          Constants::SNMP_VERSION_1
+        end
+
+
+        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
+
+          oid = Net::SNMP::OID.new("1.3.6.1.6.3.10.1.1.2")
+          @sess.securityAuthProto = case options[:auth_protocol]
+              when :sha1
+                Net::SNMP::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
+              when nil
+                Net::SNMP::OID.new("1.3.6.1.6.3.10.1.1.1").pointer
+          end
+          
+          @sess.securityAuthProtoLen = 10
+          @sess.securityAuthKeyLen = Constants::USM_AUTH_KU_LEN
+
+          if options[:context]
+            @sess.contextName = FFI::MemoryPointer.from_string(options[:context])
+            @sess.contextNameLen = options[:context].length
+
+          end
+
+          if options[:username]
+            @sess.securityName = FFI::MemoryPointer.from_string(options[:username])
+            @sess.securityNameLen = options[:username].length
+          end
+          auth_len_ptr = FFI::MemoryPointer.new(:size_t)
+          auth_len_ptr.write_int(Constants::USM_AUTH_KU_LEN)
+          key_result = Wrapper.generate_Ku(@sess.securityAuthProto, @sess.securityAuthProtoLen, options[:password], options[:password].length, @sess.securityAuthKey, auth_len_ptr)
+          @sess.securityAuthKeyLen = auth_len_ptr.read_int
+          unless key_result == Constants::SNMPERR_SUCCESS
+            Wrapper.snmp_perror("netsnmp")
+          end
+
+        end
+        
+        
+        @sess.callback = lambda do |operation, session, reqid, pdu_ptr, magic|
+          pdu = Net::SNMP::PDU.new(pdu_ptr)
+          run_callbacks(operation, reqid, pdu, magic)
+          0
+        end
+
+        @struct = Wrapper.snmp_open(@sess.pointer)
+        #@handle = Wrapper.snmp_sess_open(@sess.pointer)
+        #@struct = Wrapper.snmp_sess_session(@handle)
+      end
+
+     
+
+      def run_callbacks(operation, reqid, pdu, magic)
+        callback.call(operation, reqid, pdu, magic) if callback
+        if self.class.requests[reqid]
+          self.class.requests[reqid].call(pdu)
+          self.class.requests.delete(reqid)
+        end        
+      end
+
+
+
+
+#
+
+      def get(oidlist, options = {}, &block)
+        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GET)
+        oidlist = [oidlist] unless oidlist.kind_of?(Array)
+        oidlist.each do |oid|
+          pdu.add_varbind(:oid => oid)
+        end
+        send_pdu(pdu, &block)
+      end
+
+      def get_next(oidlist, options = {}, &block)
+        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GETNEXT)
+        oidlist = [oidlist] unless oidlist.kind_of?(Array)
+        oidlist.each do |oid|
+          pdu.add_varbind(:oid => oid)
+        end
+        send_pdu(pdu, &block)
+      end
+
+      def get_bulk(oidlist, options = {}, &block)
+        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_GETBULK)
+        oidlist = [oidlist] unless oidlist.kind_of?(Array)
+        oidlist.each do |oid|
+          pdu.add_varbind(:oid => oid)
+        end
+        pdu.non_repeaters = options[:non_repeaters] || 0
+        pdu.max_repetitions = options[:max_repetitions] || 10
+        send_pdu(pdu,&block)
+      end
+
+
+
+      def set(oidlist, options = {}, &block)
+        pdu = Net::SNMP::PDU.new(Constants::SNMP_MSG_SET)
+        oidlist.each do |oid|
+          pdu.add_varbind(:oid => oid[0], :type => oid[1], :value => oid[2])
+        end
+        send_pdu(pdu, &block)
+      end
+
+
+      
+      
+      def error(msg)
+        Wrapper.snmp_perror("snmp_error")
+        Wrapper.snmp_sess_perror( "snmp_error", @sess.pointer)
+        #Wrapper.print_session(self.struct)
+        raise Net::SNMP::Error.new({:session => self}), msg
+      end
+      
+#      def dispatcher
+#          fdset = Net::SNMP::Wrapper.get_fd_set
+#          num_fds = FFI::MemoryPointer.new(:int)
+#          tval = Net::SNMP::Wrapper::TimeVal.new
+#          block = FFI::MemoryPointer.new(:int)
+#          block.write_int(0)
+#
+#          # Note..  for some reason, snmp_sess_select_info changes block to be 1.
+#          Net::SNMP::Wrapper.snmp_sess_select_info(@handle, num_fds, fdset, tval.pointer, block )
+#          if num_fds.read_int > 0
+#            zero = Wrapper::TimeVal.new(:tv_sec => 0, :tv_usec => 0)
+#            #Wrapper.print_timeval(zero)
+#
+#            num_ready = Net::SNMP::Wrapper.select(num_fds.read_int, fdset, nil, nil, zero.pointer)
+#            Net::SNMP::Wrapper.snmp_sess_read(@handle, fdset)
+#          end
+#      end
+
+
+      private
+      def send_pdu(pdu, &block)
+
+
+        if defined?(EM) && EM.reactor_running? && !block_given?
+          f = Fiber.current
+
+          send_pdu pdu do | response |
+            f.resume(response)
+          end
+          Fiber.yield
+        else
+          if block
+            self.class.requests[pdu.reqid] = block
+            if (status = Net::SNMP::Wrapper.snmp_send(@struct, pdu.pointer)) == 0
+              error("snmp_get async failed")
+            end
+            nil
+          else
+            response_ptr = FFI::MemoryPointer.new(:pointer)
+
+            #Net::SNMP::Wrapper.print_session(@struct)
+            #Net::SNMP::Wrapper.print_pdu(pdu.struct)
+            status = Wrapper.snmp_synch_response(@struct, pdu.pointer, response_ptr)
+
+            if status != 0
+              error("snmp_get failed #{status}")
+            else
+              #Net::SNMP::Wrapper.print_pdu(Net::SNMP::Wrapper::SnmpPdu.new(response_ptr.read_pointer))
+              Net::SNMP::PDU.new(response_ptr.read_pointer)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/net/snmp/varbind.rb

@@ -0,0 +1,36 @@
+module Net
+  module SNMP
+    class Varbind
+      attr_accessor :struct
+      
+      def initialize(ptr)
+        @struct = Net::SNMP::Wrapper::VariableList.new(ptr)
+      end
+      
+      def self.from_pointer(ptr)
+        new(ptr)
+      end
+      
+      def object_type
+        @struct.type
+      end
+      
+      def oid
+        @struct.name.read_array_of_long(@struct.name_length).join(".")
+      end
+      
+      def name
+        oid
+      end
+
+      def value
+        case object_type
+        when Constants::ASN_OCTET_STR
+          struct.val[:string].read_string(struct.val_len)
+        when Constants::ASN_INTEGER, Net::SNMP::ASN_COUNTER
+          struct.val[:integer].read_int
+        end
+      end
+    end
+  end
+end

data/lib/net/snmp/version.rb

@@ -0,0 +1,5 @@
+module Net
+  module Snmp
+    VERSION = "0.1.0"
+  end
+end

data/lib/net/snmp/wrapper.rb

@@ -0,0 +1,382 @@
+module Net
+module SNMP
+module Wrapper
+  extend NiceFFI::Library
+  ffi_lib "/opt/local/lib/libnetsnmp.dylib"
+  #ffi_lib "netsnmp"
+  typedef :u_long, :oid
+
+  class Counter64 < NiceFFI::Struct
+    layout(
+           :high, :u_long,
+           :low, :u_long
+    )
+  end
+  
+  class TimeVal < NiceFFI::Struct
+    layout(:tv_sec, :long, :tv_usec, :long)
+  end
+  def self.print_timeval(tv)
+    puts "tv_sec = #{tv.tv_sec}, tv_usec = #{tv.tv_usec} "
+  end
+
+  
+  class NetsnmpVardata < FFI::Union
+    layout(
+           :integer, :pointer,
+           :string, :pointer,
+           :objid, :pointer,
+           :bitstring, :pointer,
+           :counter64, :pointer,
+           :float, :pointer,
+           :double, :pointer
+    )
+  end
+
+  def self.print_varbind(v)
+    puts "---------------------VARBIND------------------------"
+    puts %{
+      name_length #{v.name_length}
+      name #{v.name.read_array_of_long(v.name_length).join(".")}
+      type = #{v.type}
+
+    }
+  end
+ # puts "Vardata size = #{NetsnmpVardata.size}"
+  class VariableList < NiceFFI::Struct
+    layout(
+           :next_variable, :pointer,
+           :name, :pointer,
+           :name_length, :size_t,
+           :type, :u_char,
+           :val, NetsnmpVardata,
+           :val_len, :size_t,
+           :name_loc, [:oid, Net::SNMP::MAX_OID_LEN],
+           :buf, [:u_char, 40],
+           :data, :pointer,
+           :dataFreeHook, callback([ :pointer ], :void),
+           :index, :int
+    )  
+  end
+  
+  #puts "VariableList size = #{VariableList.size}"
+
+  def self.print_pdu(p)
+    puts "--------------PDU---------------"
+    puts %{
+      version = #{p.version}
+      command = #{p.command}
+      errstat = #{p.errstat}
+      errindex = #{p.errindex}
+    }
+    v = p.variables.pointer
+    puts "-----VARIABLES------"
+    while !v.null? do
+      var = VariableList.new v
+      print_varbind(var)
+      v = var.next_variable
+    end
+    
+  end
+  class SnmpPdu < NiceFFI::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, VariableList.typed_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
+ # puts "snmppdu size = #{SnmpPdu.size}"
+  callback(:snmp_callback, [ :int, :pointer, :int, :pointer, :pointer ], :int)
+  callback(:netsnmp_callback, [ :int, :pointer, :int, :pointer, :pointer ], :int)
+  def self.print_session(s)
+    puts "-------------------SESSION---------------------"
+    puts %{
+      peername = #{s.peername.read_string}
+      community = #{s.community.read_string(s.community_len)}
+      s_errno = #{s.s_errno}
+      s_snmp_errno = #{s.s_snmp_errno}
+      securityAuthKey = #{s.securityAuthKey.to_ptr.read_string}
+
+    }
+  end
+  class SnmpSession < NiceFFI::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 Tree < NiceFFI::Struct
+    layout(
+      :child_list, :pointer,
+      :next_peer, :pointer,
+      :next, :pointer,
+      :parent, :pointer,
+      :label, :string,
+      :subid, :u_long,
+      :modid, :int,
+      :number_modules, :int,
+      :module_list, :pointer,
+      :tc_index, :int,
+      :type, :int,
+      :access, :int,
+      :status, :int,
+      :enums, :pointer,
+      :ranges, :pointer,
+      :indexes, :pointer,
+      :augments, :pointer,
+      :varbinds, :pointer,
+      :hint, :pointer,
+      :units, :pointer,
+      :printomat, callback([:pointer, :pointer, :pointer, :int, :pointer, :pointer, :pointer, :pointer], :int),
+      :printer, callback([:pointer, :pointer, :pointer, :pointer, :pointer], :void),
+      :description, :pointer,
+      :reference, :pointer,
+      :reported, :int,
+      :defaultValue, :pointer
+    )
+      # struct tree    *child_list;     /* list of children of this node */
+      # struct tree    *next_peer;      /* Next node in list of peers */
+      # struct tree    *next;   /* Next node in hashed list of names */
+      # struct tree    *parent;
+      # char           *label;  /* This node's textual name */
+      # u_long          subid;  /* This node's integer subidentifier */
+      # int             modid;  /* The module containing this node */
+      # int             number_modules;
+      # int            *module_list;    /* To handle multiple modules */
+      # int             tc_index;       /* index into tclist (-1 if NA) */
+      # int             type;   /* This node's object type */
+      # int             access; /* This nodes access */
+      # int             status; /* This nodes status */
+      # struct enum_list *enums;        /* (optional) list of enumerated integers */
+      # struct range_list *ranges;
+      # struct index_list *indexes;
+      # char           *augments;
+      # struct varbind_list *varbinds;
+      # char           *hint;
+      # char           *units;
+      # int             (*printomat) (u_char **, size_t *, size_t *, int,
+      #                               const netsnmp_variable_list *,
+      #                               const struct enum_list *, const char *,
+      #                               const char *);
+      # void            (*printer) (char *, const netsnmp_variable_list *, const struct enum_list *, const char *, const char *);   /* Value printing function */
+      # char           *description;    /* description (a quoted string) */
+      # char           *reference;    /* references (a quoted string) */
+      # int             reported;       /* 1=report started in print_subtree... */
+      # char           *defaultValue;
+  end
+  attach_function :init_mib, [], :void
+  attach_function :read_all_mibs, [], :void
+  attach_function :get_tree_head, [], Tree.typed_pointer
+  attach_function :get_tree, [:pointer, :int, :pointer], Tree.typed_pointer
+
+
+#  puts "snmp_session size = #{SnmpSession.size}"
+  attach_function :snmp_open, [ :pointer ], SnmpSession.typed_pointer
+  attach_function :snmp_errstring, [:int], :string
+  attach_function :snmp_close, [ :pointer ], :int
+  attach_function :snmp_close_sessions, [  ], :int
+  attach_function :snmp_send, [ :pointer, :pointer ], :int
+  attach_function :snmp_async_send, [ :pointer, :pointer, :netsnmp_callback, :pointer ], :int
+  attach_function :snmp_read, [ :pointer ], :void
+  attach_function :snmp_free_pdu, [ :pointer ], :void
+  attach_function :snmp_free_var, [ :pointer ], :void
+  attach_function :snmp_free_varbind, [ :pointer ], :void
+  attach_function :snmp_select_info, [ :pointer, :pointer, :pointer, :pointer ], :int
+  attach_function :snmp_timeout, [  ], :void
+
+  attach_function :snmp_get_next_msgid, [  ], :long
+  attach_function :snmp_get_next_reqid, [  ], :long
+  attach_function :snmp_get_next_sessid, [  ], :long
+  attach_function :snmp_get_next_transid, [  ], :long
+  attach_function :snmp_oid_compare, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :snmp_oid_ncompare, [ :pointer, :uint, :pointer, :uint, :uint ], :int
+  attach_function :snmp_oidtree_compare, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :snmp_oidsubtree_compare, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :netsnmp_oid_compare_ll, [ :pointer, :uint, :pointer, :uint, :pointer ], :int
+  attach_function :netsnmp_oid_equals, [ :pointer, :uint, :pointer, :uint ], :int
+#  attach_function :netsnmp_oid_tree_equals, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :netsnmp_oid_is_subtree, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :netsnmp_oid_find_prefix, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :init_snmp, [ :string ], :void
+  attach_function :snmp_pdu_build, [ :pointer, :pointer, :pointer ], :pointer
+  attach_function :snmpv3_parse, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :int
+  attach_function :snmpv3_packet_build, [ :pointer, :pointer, :pointer, :pointer, :pointer, :uint ], :int
+#  attach_function :snmpv3_packet_rbuild, [ :pointer, :pointer, :pointer, :pointer, :pointer, :uint ], :int
+  attach_function :snmpv3_make_report, [ :pointer, :int ], :int
+  attach_function :snmpv3_get_report_type, [ :pointer ], :int
+  attach_function :snmp_pdu_parse, [ :pointer, :pointer, :pointer ], :int
+  attach_function :snmpv3_scopedPDU_parse, [ :pointer, :pointer, :pointer ], :pointer
+  attach_function :snmp_store, [ :string ], :void
+  attach_function :snmp_shutdown, [ :string ], :void
+  attach_function :snmp_pdu_add_variable, [ :pointer, :pointer, :uint, :u_char, :pointer, :size_t ], :pointer
+  attach_function :snmp_varlist_add_variable, [ :pointer, :pointer, :uint, :u_char, :pointer, :uint ], :pointer
+  attach_function :snmp_add_var, [ :pointer, :pointer, :uint, :char, :string ], :int
+  attach_function :snmp_duplicate_objid, [ :pointer, :uint ], :pointer
+  attach_function :snmp_increment_statistic, [ :int ], :u_int
+  attach_function :snmp_increment_statistic_by, [ :int, :int ], :u_int
+  attach_function :snmp_get_statistic, [ :int ], :u_int
+  attach_function :snmp_init_statistics, [  ], :void
+  attach_function :create_user_from_session, [ :pointer ], :int
+ # attach_function :snmp_get_fd_for_session, [ :pointer ], :int
+  attach_function :snmp_open_ex, [ :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :uint ], :int), callback([ :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :uint ], :int) ], :pointer
+  attach_function :snmp_set_do_debugging, [ :int ], :void
+  attach_function :snmp_get_do_debugging, [  ], :int
+  attach_function :snmp_error, [ :pointer, :pointer, :pointer, :pointer ], :void
+  attach_function :snmp_sess_init, [ :pointer ], :void
+  attach_function :snmp_sess_open, [ :pointer ], :pointer
+  attach_function :snmp_sess_pointer, [ :pointer ], :pointer
+  attach_function :snmp_sess_session, [ :pointer ], SnmpSession.typed_pointer
+  attach_function :snmp_sess_transport, [ :pointer ], :pointer
+  attach_function :snmp_sess_transport_set, [ :pointer, :pointer ], :void
+  attach_function :snmp_sess_add_ex, [ :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :uint ], :int), callback([ :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :uint ], :int), callback([ :pointer, :pointer, :uint ], :pointer) ], :pointer
+  attach_function :snmp_sess_add, [ :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :int ], :int) ], :pointer
+  attach_function :snmp_add, [ :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :int ], :int) ], :pointer
+  attach_function :snmp_add_full, [ :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :uint ], :int), callback([ :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :uint ], :int), callback([ :pointer, :pointer, :uint ], :pointer) ], :pointer
+  attach_function :snmp_sess_send, [ :pointer, :pointer ], :int
+  attach_function :snmp_sess_async_send, [ :pointer, :pointer, :netsnmp_callback, :pointer ], :int
+  attach_function :snmp_sess_select_info, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :int
+  attach_function :snmp_sess_read, [ :pointer, :pointer ], :int
+  attach_function :snmp_sess_timeout, [ :pointer ], :void
+  attach_function :snmp_sess_close, [ :pointer ], :int
+  attach_function :snmp_sess_error, [ :pointer, :pointer, :pointer, :pointer ], :void
+  attach_function :netsnmp_sess_log_error, [ :int, :string, :pointer ], :void
+  attach_function :snmp_sess_perror, [ :string, :pointer ], :void
+  attach_function :snmp_pdu_type, [ :int ], :string
+
+
+  
+  attach_function :asn_check_packet, [ :pointer, :uint ], :int
+  attach_function :asn_parse_int, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_build_int, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_unsigned_int, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_build_unsigned_int, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_string, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :pointer
+  attach_function :asn_build_string, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_header, [ :pointer, :pointer, :pointer ], :pointer
+  attach_function :asn_parse_sequence, [ :pointer, :pointer, :pointer, :u_char, :string ], :pointer
+  attach_function :asn_build_header, [ :pointer, :pointer, :u_char, :uint ], :pointer
+  attach_function :asn_build_sequence, [ :pointer, :pointer, :u_char, :uint ], :pointer
+  attach_function :asn_parse_length, [ :pointer, :pointer ], :pointer
+  attach_function :asn_build_length, [ :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_parse_objid, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :pointer
+  attach_function :asn_build_objid, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_null, [ :pointer, :pointer, :pointer ], :pointer
+  attach_function :asn_build_null, [ :pointer, :pointer, :u_char ], :pointer
+  attach_function :asn_parse_bitstring, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :pointer
+  attach_function :asn_build_bitstring, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_unsigned_int64, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_build_unsigned_int64, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_signed_int64, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_build_signed_int64, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_build_float, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_float, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+  attach_function :asn_build_double, [ :pointer, :pointer, :u_char, :pointer, :uint ], :pointer
+  attach_function :asn_parse_double, [ :pointer, :pointer, :pointer, :pointer, :uint ], :pointer
+
+  attach_function :snmp_pdu_create, [:int], SnmpPdu.typed_pointer
+  attach_function :get_node, [:pointer, :pointer, :pointer], :int
+  attach_function :read_objid, [:string, :pointer, :pointer], :int
+  attach_function :snmp_add_null_var, [:pointer, :pointer, :size_t], :pointer
+  attach_function :snmp_sess_synch_response, [:pointer, :pointer, :pointer], :int
+  attach_function :snmp_synch_response, [:pointer, :pointer, :pointer], :int
+  attach_function :snmp_parse_oid, [:string, :pointer, :pointer], :pointer
+  attach_function :snmp_api_errstring, [ :int ], :string
+  attach_function :snmp_perror, [ :string ], :void
+  attach_function :snmp_set_detail, [ :string ], :void
+  
+  attach_function :snmp_select_info, [:pointer, :pointer, :pointer, :pointer], :int
+  attach_function :select, [:int, :pointer, :pointer, :pointer, :pointer], :int
+  attach_function :snmp_read, [:pointer], :void
+  attach_function :generate_Ku, [:pointer, :int, :string, :int, :pointer, :pointer], :int
+  #attach_function :send_easy_trap, [:int, :int], :void
+  #attach_function :send_trap_vars, [:int, :int, :pointer], :void
+  #attach_function :send_v2trap, [:pointer], :void
+
+  def self.get_fd_set
+    FFI::MemoryPointer.new(:pointer, 128)
+  end
+  
+
+end
+end
+end