net-snmp2 0.3.0

data/lib/net/snmp/trap_handler/trap_handler.rb

@@ -0,0 +1,42 @@
+module Net::SNMP
+  class TrapHandler
+    include Net::SNMP::Debug
+    extend Forwardable
+
+    attr_accessor :listener, :v1_handler, :v2_handler, :message, :pdu
+    def_delegators :listener, :start, :run, :listen, :stop, :kill
+
+    def self.listen(port = 162, interval = 2, max_packet_size = 65_000, &block)
+      self.new
+    end
+
+    def initialize(&block)
+      @listener = Net::SNMP::Listener.new
+      @listener.on_message(&method(:process_trap))
+      self.instance_eval(&block)
+    end
+
+    private
+
+    def process_trap(message, from_address, from_port)
+      if message.pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP
+        handler = V1TrapDsl.new(message)
+        handler.instance_eval(&v1_handler)
+      elsif message.pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP2
+        handler = V2TrapDsl.new(message)
+        handler.instance_eval(&v2_handler)
+      else
+        warn "Trap handler receive invalid command: #{message.pdu.command}"
+      end
+      message.pdu.free
+    end
+
+    def v1(&handler)
+      @v1_handler = handler
+    end
+
+    def v2(&handler)
+      @v2_handler = handler
+    end
+  end
+end

data/lib/net/snmp/trap_handler/v1_trap_dsl.rb

@@ -0,0 +1,44 @@
+module Net::SNMP
+  class V1TrapDsl
+    include Debug
+
+    attr_accessor :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def pdu
+      message.pdu
+    end
+
+    def enterprise
+      pdu.enterprise
+    end
+    alias enterprise_oid enterprise
+
+    def trap_type
+      pdu.trap_type
+    end
+    alias general_trap_type trap_type
+
+    def specific_type
+      pdu.specific_type
+    end
+    alias specific_trap_type specific_type
+
+    def agent_addr
+      pdu.agent_addr
+    end
+    alias agent_address agent_addr
+
+    def uptime
+      pdu.uptime
+    end
+
+    def varbinds
+      pdu.varbinds
+    end
+
+  end
+end

data/lib/net/snmp/trap_handler/v2_trap_dsl.rb

@@ -0,0 +1,38 @@
+module Net::SNMP
+  class V2TrapDsl
+    include Debug
+
+    attr_accessor :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def pdu
+      message.pdu
+    end
+
+    def oid
+      vb = varbinds.find{|vb| vb.oid.to_s == Constants::OID_SNMP_TRAP_OID}
+      if vb
+        vb.value
+      else
+        nil
+      end
+    end
+    alias trap_oid oid
+
+    def uptime
+      vb = varbinds.find{|vb| vb.oid.to_s == Constants::OID_SYS_UP_TIME_INSTANCE}
+      if vb
+        vb.value
+      else
+        nil
+      end
+    end
+
+    def varbinds
+      pdu.varbinds
+    end
+  end
+end

data/lib/net/snmp/trap_session.rb

@@ -0,0 +1,92 @@
+module Net
+  module SNMP
+    class TrapSession < Session
+      # == Represents a session for sending SNMP traps
+
+      # +options+
+      # * :peername The address where the trap will be sent
+      # * :port     The port where the trap will be sent (default = 162)
+      def initialize(options = {})
+        # Unless the port was supplied in the peername...
+        unless options[:peername][":"]
+          # ...default to standard trap port
+          options[:port] ||= 162
+        end
+
+        super(options)
+      end
+
+      # Send an SNMPv1 trap
+      #
+      # Options
+      #
+      # - enterprise: The Oid of the enterprise
+      # - trap_type:  The generic trap type.
+      # - specific_type: The specific trap type
+      # - uptime: The uptime for this agent
+      def trap(options = {})
+        pdu = PDU.new(Constants::SNMP_MSG_TRAP)
+        options[:enterprise] ||= '1.3.6.1.4.1.3.1.1'
+        pdu.enterprise = OID.new(options[:enterprise].to_s)
+        pdu.trap_type = options[:trap_type].to_i || 1  # need to check all these defaults
+        pdu.specific_type = options[:specific_type].to_i || 0
+        pdu.time = options[:uptime].to_i || 1
+        pdu.agent_addr = options[:agent_addr] || '127.0.0.1'
+        if options[:varbinds]
+          options[:varbinds].each do |vb|
+            pdu.add_varbind(vb)
+          end
+        end
+        result = send_pdu(pdu)
+        pdu.free
+        result
+      end
+
+      # Send an SNMPv2 trap
+      # +options
+      # * :oid The Oid of the trap
+      # * :varbinds A list of Varbind objects to send with the trap
+      #
+      # TODO: You can only send v1 traps on a v1 session, and same for v2.
+      # So, we could always have the client call `trap` and just do the right
+      # thing based on the session.
+      def trap_v2(options = {})
+        if options[:oid].kind_of?(String)
+          options[:oid] = Net::SNMP::OID.new(options[:oid])
+        end
+        pdu = PDU.new(Constants::SNMP_MSG_TRAP2)
+        build_trap_pdu(pdu, options)
+        result = send_pdu(pdu)
+        pdu.free
+        result
+      end
+
+      # Send an SNMPv2 inform.  Can accept a callback to execute on confirmation of the inform
+      # +options
+      # * :oid The OID of the inform
+      # * :varbinds A list of Varbind objects to send with the inform
+      def inform(options = {}, &callback)
+        if options[:oid].kind_of?(String)
+          options[:oid] = Net::SNMP::OID.new(options[:oid])
+        end
+        pdu = PDU.new(Constants::SNMP_MSG_INFORM)
+        build_trap_pdu(pdu, options)
+        result = send_pdu(pdu, &callback)
+        pdu.free
+        result
+      end
+
+      private
+      def build_trap_pdu(pdu, options = {})
+        options[:uptime] ||= 1
+        pdu.add_varbind(:oid => OID.new('sysUpTime.0'), :type => Constants::ASN_TIMETICKS, :value => options[:uptime].to_i)
+        pdu.add_varbind(:oid => OID.new('snmpTrapOID.0'), :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

data/lib/net/snmp/utility.rb

@@ -0,0 +1,10 @@
+module Net::SNMP::Utility
+  def self.oid_lex_cmp(a,b)
+    [a,b].each do |i|
+      i.sub!(/^\./,'')
+      i.gsub!(/ /, '.0')
+      i.replace(i.split('.').map(&:to_i).pack('N*'))
+    end
+    a <=> b
+  end
+end

data/lib/net/snmp/varbind.rb

@@ -0,0 +1,57 @@
+module Net::SNMP
+  class Varbind
+    # == Represents an SNMP Variable Binding
+
+    attr_accessor :struct
+
+    def initialize(ptr = nil)
+      @struct = Net::SNMP::Wrapper::VariableList.new(ptr)
+    end
+
+    def self.from_pointer(ptr)
+      new(ptr)
+    end
+
+    # Returns the data type of the varbind
+    def object_type
+      @struct.type
+    end
+    alias type object_type
+
+    # Returns the OID associated with the varbind
+    def oid
+      @oid ||= OID.from_pointer(@struct.name, @struct.name_length)
+    end
+
+    # Returns the value of the varbind
+    def value
+      case object_type
+      when Constants::ASN_OCTET_STR, Constants::ASN_OPAQUE
+        struct.val[:string].read_string(struct.val_len)
+      when Constants::ASN_INTEGER
+        struct.val[:integer].read_long
+      when Constants::ASN_UINTEGER, Constants::ASN_TIMETICKS,  Constants::ASN_COUNTER, Constants::ASN_GAUGE
+        struct.val[:integer].read_ulong
+      when Constants::ASN_IPADDRESS
+        struct.val[:objid].read_string(struct.val_len).unpack('CCCC').join(".")
+      when Constants::ASN_NULL
+        nil
+      when Constants::ASN_OBJECT_ID
+        Net::SNMP::OID.from_pointer(struct.val[:objid], struct.val_len / OID.oid_size)
+      when Constants::ASN_COUNTER64
+        counter = Wrapper::Counter64.new(struct.val[:counter64])
+        counter.high * 2^32 + counter.low
+      when Constants::ASN_BIT_STR
+        # XXX not sure what to do here.  Is this obsolete?
+      when Constants::SNMP_ENDOFMIBVIEW
+        :endofmibview
+      when Constants::SNMP_NOSUCHOBJECT
+        :nosuchobject
+      when Constants::SNMP_NOSUCHINSTANCE
+        :nosuchinstance
+      else
+        raise Net::SNMP::Error.new, "Unknown value type #{object_type}"
+      end
+    end
+  end
+end

data/lib/net/snmp/version.rb

@@ -0,0 +1,5 @@
+module Net
+  module SNMP
+    VERSION = "0.3.0"
+  end
+end

data/lib/net/snmp/wrapper.rb

@@ -0,0 +1,450 @@
+module Net
+module SNMP
+module Wrapper
+  extend NiceFFI::Library
+  ffi_lib ["libnetsnmp", "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
+
+  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
+
+  class VariableList < NiceFFI::Struct
+    layout(
+      :next_variable, VariableList.typed_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
+
+  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
+
+  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 EnumList < NiceFFI::Struct
+    layout(
+      :next, EnumList.typed_pointer,
+      :value, :int,
+      :label, :pointer
+    )
+  end
+
+  class IndexList < NiceFFI::Struct
+    layout(
+      :next, :pointer,
+      :ilabel, :pointer,
+      :isimplied, :char
+    )
+  end
+
+  class ModuleImport < NiceFFI::Struct
+    layout(
+      :label, :pointer, # The descriptor being imported (pointer to string)
+      :modid, :int # The module id
+    )
+  end
+
+  class Module < NiceFFI::Struct
+    layout(
+      :name, :pointer, # The module's name (pointer to string)
+      :file, :pointer, # The file containing the module (pointer to string)
+      :imports, ModuleImport.typed_pointer, # List of descriptors being imported
+      :no_imports, :int, # The length of the imports array
+      :modid, :int, # The index number of this module
+      :next, Module.typed_pointer # Linked list pointer
+    )
+  end
+
+  class Tree < NiceFFI::Struct
+    layout(
+      :child_list, Tree.typed_pointer,
+      :next_peer, Tree.typed_pointer,
+      :next, Tree.typed_pointer,
+      :parent, :pointer,
+      :label, :string,
+      :subid, :u_long,
+      :modid, :int,
+      :number_modules, :int,  # Length of module_list array
+      :module_list, :pointer, # Array of modids (pointer to int)
+      :tc_index, :int,
+      :type, :int,
+      :access, :int,
+      :status, :int,
+      :enums, EnumList.typed_pointer,
+      :ranges, :pointer,
+      :indexes, IndexList.typed_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
+    )
+  end
+
+  # Some of these functions/variables are not available on windows.
+  # (At least with my current setup.) Simple SNMP manager example
+  # seems to work fine without them, so just log and ignore for now.
+  class << self
+    include Net::SNMP::Debug
+    alias af attach_function
+    def attach_function(*args)
+      af(*args)
+    rescue Exception => ex
+      debug ex.message
+    end
+  end
+
+  attach_function :snmp_clone_pdu, [ :pointer ], :pointer
+  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 :netsnmp_transport_open_client, [:string, :pointer], :pointer
+  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 ], SnmpSession.typed_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, :snmp_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,[:string, :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 :generate_Ku, [:pointer, :int, :string, :int, :pointer, :pointer], :int
+
+  # MIB functions
+  attach_function :netsnmp_init_mib, [], :void
+  attach_function :read_all_mibs, [], :void
+  attach_function :add_mibdir, [:string], :int
+  attach_function :read_mib, [:string], Tree.typed_pointer
+  attach_function :netsnmp_read_module, [:string], Tree.typed_pointer
+  attach_function :snmp_set_save_descriptions, [:int], :void
+
+  attach_function :get_tree_head, [], Tree.typed_pointer
+  attach_function :get_tree, [:pointer, :int, :pointer], Tree.typed_pointer
+
+  # struct module  *find_module(int modid);
+  attach_function :find_module, [:int], Module.typed_pointer
+
+  # Trap functions
+  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
+
+module FFI
+  module LibC
+    extend FFI::Library
+    ffi_lib 'c'
+
+    typedef :pointer, :FILE
+    typedef :uint32, :in_addr_t
+    typedef :uint16, :in_port_t
+
+    class Timeval < FFI::Struct
+      layout :tv_sec, :time_t,
+             :tv_usec, :suseconds_t
+    end
+
+    # Some of these functions/variables are not available on windows.
+    # (At least with my current setup.) Simple SNMP manager example
+    # seems to work fine without them, so just log and ignore for now.
+    class << self
+      include Net::SNMP::Debug
+      alias af attach_function
+      def attach_function(*args)
+        af(*args)
+      rescue Exception => ex
+        debug ex.message
+      end
+
+      alias av attach_variable
+      def attach_variable(*args)
+        av(*args)
+      rescue Exception => ex
+        debug ex.message
+      end
+    end
+
+    # Standard IO functions
+    #@blocking = true  # some undocumented voodoo that tells the next attach_function to release the GIL
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :calloc, [:size_t, :size_t], :pointer
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+    attach_function :free, [:pointer], :void
+    #attach_variable :errno, :int
+
+    ffi_lib ['Ws2_32.dll'] if (ENV['OS'] =~ /windows/i)
+    attach_function :select, [:int, :pointer, :pointer, :pointer, :pointer], :int
+  end
+end