FORK gosnmp

Build Status GoDoc

GoSNMP is an SNMP client library fully written in Go. It provides Get, GetNext, GetBulk, Walk, BulkWalk, Set and Traps. It supports IPv4 and IPv6, using SNMPv2c or SNMPv3.


soniah/gosnmp was originally based on alouca/gosnmp, but has been completely rewritten. Many thanks to Andreas Louca, other contributors ( and these project collaborators:

Sonia Hamilton,,


GoSNMP has the following SNMP functions:

  • Get (single or multiple OIDs)
  • GetNext
  • GetBulk
  • Walk - retrieves a subtree of values using GETNEXT.
  • BulkWalk - retrieves a subtree of values using GETBULK.
  • Set - supports Integers and OctetStrings.
  • SendTrap - send SNMP TRAPs.
  • Listen - act as an NMS for receiving TRAPs.

GoSNMP has the following helper functions:

  • ToBigInt - treat returned values as *big.Int
  • Partition - facilitates dividing up large slices of OIDs

soniah/gosnmp has completely diverged from alouca/gosnmp, your code will require modification in these (and other) locations:

  • the Get function has a different method signature
  • the NewGoSNMP function has been removed, use Connect instead (see Usage below). Connect uses the GoSNMP struct; gosnmp.Default is provided for you to build on.
  • GoSNMP no longer relies on alouca/gologger - you can use your logger if it conforms to the gosnmp.Logger interface; otherwise debugging will be discarded (/dev/null).
type Logger interface {
    Print(v ...interface{})
    Printf(format string, v ...interface{})

GoSNMP is still under development, therefore API's may change and bugs will be squashed. Test Driven Development is used - you can help by sending packet captures (see Packet Captures below). There may be more than one branch on github. master is safe to pull from, other branches unsafe as history may be rewritten.


Install via go get:

go get


See or your local go doc server for full documentation, as well as the examples.

godoc -http=:6060 &
$preferred_browser http://localhost:6060/pkg &


Here is code from examples/example.go, demonstrating how to use GoSNMP:

// Default is a pointer to a GoSNMP struct that contains sensible defaults
// eg port 161, community public, etc
g.Default.Target = ""
err := g.Default.Connect()
if err != nil {
    log.Fatalf("Connect() err: %v", err)
defer g.Default.Conn.Close()

oids := []string{"", ""}
result, err2 := g.Default.Get(oids) // Get() accepts up to g.MAX_OIDS
if err2 != nil {
    log.Fatalf("Get() err: %v", err2)

for i, variable := range result.Variables {
    fmt.Printf("%d: oid: %s ", i, variable.Name)

    // the Value of each variable returned by Get() implements
    // interface{}. You could do a type switch...
    switch variable.Type {
    case g.OctetString:
        bytes := variable.Value.([]byte)
        fmt.Printf("string: %s\n", string(bytes))
        // ... or often you're just interested in numeric values.
        // ToBigInt() will return the Value as a BigInt, for plugging
        // into your calculations.
        fmt.Printf("number: %d\n", g.ToBigInt(variable.Value))

Running this example gives the following output (from my printer):

% go run example.go
0: oid: string: Administrator
1: oid: number: 104

examples/example2.go is similar to example.go, however is uses a custom &GoSNMP rather than g.Default.

examples/walkexample.go demonstrates using BulkWalk.

examples/example3.go demonstrates SNMPv3

examples/trapserver.go demonstrates writing an SNMP v2c trap server


Rane's document SNMP: Simple? Network Management Protocol was useful for me when learning the SNMP protocol.

Please create an issue on Github with packet captures (upload capture to Google Drive, Dropbox, or similar) containing samples of missing BER types, or of any other bugs you find. If possible, please include 2 or 3 examples of the missing/faulty BER type.

The following BER types have been implemented:

  • 0x02 Integer
  • 0x04 OctetString
  • 0x06 ObjectIdentifier
  • 0x40 IPAddress (IPv4 & IPv6)
  • 0x41 Counter32
  • 0x42 Gauge32
  • 0x43 TimeTicks
  • 0x46 Counter64
  • 0x47 Uinteger32
  • 0x80 NoSuchObject
  • 0x81 NoSuchInstance
  • 0x82 EndOfMibView

The following (less common) BER types haven't been implemented, as I ran out of time or haven't been able to find example devices to query:

  • 0x00 EndOfContents
  • 0x01 Boolean
  • 0x03 BitString
  • 0x07 ObjectDescription
  • 0x44 Opaque
  • 0x45 NsapAddress

Packet Captures

Create your packet captures in the following way:

Expected output, obtained via an snmp command. For example:

% snmpget -On -v2c -c public \
. = INTEGER: 78
. = STRING: GigabitEthernet0
. = Gauge32: 4294967295

A packet capture, obtained while running the snmpget. For example:

sudo tcpdump -s 0 -i eth0 -w foo.pcap host and port 161

Running the Tests

Tests are grouped as follows:

  • Unit tests (validating data packing and marshalling):
    • marshal_test.go
    • misc_test.go
  • Public API consistency tests:
    • gosnmp_api_test.go
  • End-to-end integration tests:
    • generic_e2e_test.go

The generic end-to-end integration test generic_e2e_test.go should work against any SNMP MIB-2 compliant host (e.g. a router, NAS box, printer). To use, set the environment variables GOSNMP_TARGET & GOSNMP_PORT, for example:

export GOSNMP_PORT=161

To profile cpu usage:

go test -cpuprofile cpu.out
go test -c
go tool pprof gosnmp.test cpu.out

To profile memory usage:

go test -memprofile mem.out
go test -c
go tool pprof gosnmp.test mem.out

To check test coverage:

go get
go get
gocov test | gocov-html > gosnmp.html && firefox gosnmp.html &


Some parts of the code are borrowed by the Golang project (specifically some functions for unmarshaling BER responses), which are under the same terms and conditions as the Go language. The rest of the code is under a BSD license.

See the LICENSE file for more details.

The remaining code is Copyright 2012-2018 the GoSNMP Authors - see for a list of authors.

Expand ▾ Collapse ▴




View Source
const (
	EndOfContents     Asn1BER = 0x00
	UnknownType               = 0x00
	Boolean                   = 0x01
	Integer                   = 0x02
	BitString                 = 0x03
	OctetString               = 0x04
	Null                      = 0x05
	ObjectIdentifier          = 0x06
	ObjectDescription         = 0x07
	IPAddress                 = 0x40
	Counter32                 = 0x41
	Gauge32                   = 0x42
	TimeTicks                 = 0x43
	Opaque                    = 0x44
	NsapAddress               = 0x45
	Counter64                 = 0x46
	Uinteger32                = 0x47
	NoSuchObject              = 0x80
	NoSuchInstance            = 0x81
	EndOfMibView              = 0x82

    Asn1BER's -

    View Source
    const (
    	// MaxOids is the maximum number of OIDs permitted in a single call,
    	// otherwise error. MaxOids too high can cause remote devices to fail
    	// strangely. 60 seems to be a common value that works, but you will want
    	// to change this in the GoSNMP struct
    	MaxOids = 60


    View Source
    var Default = &GoSNMP{
    	Port:      161,
    	Community: "public",
    	Version:   Version2c,
    	Timeout:   time.Duration(2) * time.Second,
    	Retries:   3,
    	MaxOids:   MaxOids,

      Default connection settings


      func Check

      func Check(err error)

        Check makes checking errors easy, so they actually get a minimal check

        func Partition

        func Partition(currentPosition, partitionSize, sliceLength int) bool

          Partition - returns true when dividing a slice into partitionSize lengths, including last partition which may be smaller than partitionSize. This is useful when you have a large array of OIDs to run Get() on. See the tests for example usage.

          For example for a slice of 8 items to be broken into partitions of length 3, Partition returns true for the currentPosition having the following values:

          0 1 2 3 4 5 6 7

          T        T     T

          func ToBigInt

          func ToBigInt(value interface{}) *big.Int

            ToBigInt converts SnmpPDU.Value to big.Int, or returns a zero big.Int for non int-like types (eg strings).

            This is a convenience function to make working with SnmpPDU's easier - it reduces the need for type assertions. A big.Int is convenient, as SNMP can return int32, uint32, and uint64.


            type Asn1BER

            type Asn1BER byte

              Asn1BER is the type of the SNMP PDU

              type BitStringValue

              type BitStringValue struct {
              	Bytes     []byte // bits packed into bytes.
              	BitLength int    // length in bits.

                BitStringValue is the structure to use when you want an ASN.1 BIT STRING type. A bit string is padded up to the nearest byte in memory and the number of valid bits is recorded. Padding bits will be zero.

                func (BitStringValue) At

                func (b BitStringValue) At(i int) int

                  At returns the bit at the given index. If the index is out of range it returns false.

                  func (BitStringValue) RightAlign

                  func (b BitStringValue) RightAlign() []byte

                    RightAlign returns a slice where the padding bits are at the beginning. The slice may share memory with the BitString.

                    type Error

                    type Error struct {
                    	// contains filtered or unexported fields

                    func (Error) Error

                    func (e Error) Error() string

                    func (Error) Temporary

                    func (e Error) Temporary() bool

                    func (Error) Timeout

                    func (e Error) Timeout() bool

                    type GoSNMP

                    type GoSNMP struct {
                    	// Conn is net connection to use, typically established using GoSNMP.Connect()
                    	Conn net.Conn
                    	// Target is an ipv4 address
                    	Target string
                    	// Port is a udp port
                    	Port uint16
                    	// Community is an SNMP Community string
                    	Community string
                    	// Version is an SNMP Version
                    	Version SnmpVersion
                    	// Timeout is the timeout for the SNMP Query
                    	Timeout time.Duration
                    	// Set the number of retries to attempt within timeout.
                    	Retries int
                    	// Logger is the GoSNMP.Logger to use for debugging. If nil, debugging
                    	// output will be discarded (/dev/null). For verbose logging to stdout:
                    	// x.Logger = log.New(os.Stdout, "", 0)
                    	Logger Logger
                    	// MaxOids is the maximum number of oids allowed in a Get()
                    	// (default: MaxOids)
                    	MaxOids int
                    	// MaxRepetitions sets the GETBULK max-repetitions used by BulkWalk*
                    	// Unless MaxRepetitions is specified it will use defaultMaxRepetitions (50)
                    	// This may cause issues with some devices, if so set MaxRepetitions lower.
                    	// See comments in
                    	MaxRepetitions uint8
                    	// NonRepeaters sets the GETBULK max-repeaters used by BulkWalk*
                    	// (default: 0 as per RFC 1905)
                    	NonRepeaters int
                    	// MsgFlags is an SNMPV3 MsgFlags
                    	MsgFlags SnmpV3MsgFlags
                    	// SecurityModel is an SNMPV3 Security Model
                    	SecurityModel SnmpV3SecurityModel
                    	// SecurityParameters is an SNMPV3 Security Model paramaters struct
                    	SecurityParameters SnmpV3SecurityParameters
                    	// ContextEngineID is SNMPV3 ContextEngineID in ScopedPDU
                    	ContextEngineID string
                    	// ContextName is SNMPV3 ContextName in ScopedPDU
                    	ContextName string
                    	// contains filtered or unexported fields

                      GoSNMP represents GoSNMP library state

                      func (*GoSNMP) BulkWalk

                      func (x *GoSNMP) BulkWalk(rootOid string, walkFn WalkFunc) error

                        BulkWalk retrieves a subtree of values using GETBULK. As the tree is walked walkFn is called for each new value. The function immediately returns an error if either there is an underlaying SNMP error (e.g. GetBulk fails), or if walkFn returns an error.

                        func (*GoSNMP) BulkWalkAll

                        func (x *GoSNMP) BulkWalkAll(rootOid string) (results []SnmpPDU, err error)

                          BulkWalkAll is similar to BulkWalk but returns a filled array of all values rather than using a callback function to stream results.

                          func (*GoSNMP) Check

                          func (x *GoSNMP) Check(err error)

                            Check makes checking errors easy, so they actually get a minimal check

                            func (*GoSNMP) Connect

                            func (x *GoSNMP) Connect() error

                              Connect creates and opens a socket. Because UDP is a connectionless protocol, you won't know if the remote host is responding until you send packets. And if the host is regularly disappearing and reappearing, you won't know if you've only done a Connect().

                              For historical reasons (ie this is part of the public API), the method won't be renamed.

                              func (*GoSNMP) Get

                              func (x *GoSNMP) Get(oids []string) (result *SnmpPacket, err error)

                                Get sends an SNMP GET request

                                func (*GoSNMP) GetBulk

                                func (x *GoSNMP) GetBulk(oids []string, nonRepeaters uint8, maxRepetitions uint8) (result *SnmpPacket, err error)

                                  GetBulk sends an SNMP GETBULK request

                                  For maxRepetitions greater than 255, use BulkWalk() or BulkWalkAll()

                                  func (*GoSNMP) GetNext

                                  func (x *GoSNMP) GetNext(oids []string) (result *SnmpPacket, err error)

                                    GetNext sends an SNMP GETNEXT request

                                    func (*GoSNMP) SendTrap

                                    func (x *GoSNMP) SendTrap(trap SnmpTrap) (result *SnmpPacket, err error)

                                      SendTrap sends a SNMP Trap (v2c/v3 only)

                                      pdus[0] can a pdu of Type TimeTicks (with the desired uint32 epoch time). Otherwise a TimeTicks pdu will be prepended, with time set to now. This mirrors the behaviour of the Net-SNMP command-line tools.

                                      SendTrap doesn't wait for a return packet from the NMS (Network Management Station).

                                      See also Listen() and examples for creating an NMS.

                                      func (*GoSNMP) Set

                                      func (x *GoSNMP) Set(pdus []SnmpPDU) (result *SnmpPacket, err error)

                                        Set sends an SNMP SET request

                                        func (*GoSNMP) UnmarshalTrap

                                        func (x *GoSNMP) UnmarshalTrap(trap []byte) (result *SnmpPacket)

                                          UnmarshalTrap unpacks the SNMP Trap.

                                          func (*GoSNMP) Walk

                                          func (x *GoSNMP) Walk(rootOid string, walkFn WalkFunc) error

                                            Walk retrieves a subtree of values using GETNEXT - a request is made for each value, unlike BulkWalk which does this operation in batches. As the tree is walked walkFn is called for each new value. The function immediately returns an error if either there is an underlaying SNMP error (e.g. GetNext fails), or if walkFn returns an error.

                                            func (*GoSNMP) WalkAll

                                            func (x *GoSNMP) WalkAll(rootOid string) (results []SnmpPDU, err error)

                                              WalkAll is similar to Walk but returns a filled array of all values rather than using a callback function to stream results.

                                              type Logger

                                              type Logger interface {
                                              	Print(v ...interface{})
                                              	Printf(format string, v ...interface{})

                                                Logger is an interface used for debugging. Both Print and Printf have the same interfaces as Package Log in the std library. The Logger interface is small to give you flexibility in how you do your debugging.

                                                For verbose logging to stdout:

                                                gosnmp_logger = log.New(os.Stdout, "", 0)

                                                type PDUType

                                                type PDUType byte

                                                  PDUType describes which SNMP Protocol Data Unit is being sent.

                                                  const (
                                                  	Sequence       PDUType = 0x30
                                                  	GetRequest     PDUType = 0xa0
                                                  	GetNextRequest PDUType = 0xa1
                                                  	GetResponse    PDUType = 0xa2
                                                  	SetRequest     PDUType = 0xa3
                                                  	Trap           PDUType = 0xa4 // v1
                                                  	GetBulkRequest PDUType = 0xa5
                                                  	InformRequest  PDUType = 0xa6
                                                  	SNMPv2Trap     PDUType = 0xa7 // v2c, v3
                                                  	Report         PDUType = 0xa8

                                                    The currently supported PDUType's

                                                    type SNMPError

                                                    type SNMPError uint8

                                                      SNMPError is the type for standard SNMP errors.

                                                      const (
                                                      	NoError             SNMPError = iota // No error occurred. This code is also used in all request PDUs, since they have no error status to report.
                                                      	TooBig                               // The size of the Response-PDU would be too large to transport.
                                                      	NoSuchName                           // The name of a requested object was not found.
                                                      	BadValue                             // A value in the request didn't match the structure that the recipient of the request had for the object. For example, an object in the request was specified with an incorrect length or type.
                                                      	ReadOnly                             // An attempt was made to set a variable that has an Access value indicating that it is read-only.
                                                      	GenErr                               // An error occurred other than one indicated by a more specific error code in this table.
                                                      	NoAccess                             // Access was denied to the object for security reasons.
                                                      	WrongType                            // The object type in a variable binding is incorrect for the object.
                                                      	WrongLength                          // A variable binding specifies a length incorrect for the object.
                                                      	WrongEncoding                        // A variable binding specifies an encoding incorrect for the object.
                                                      	WrongValue                           // The value given in a variable binding is not possible for the object.
                                                      	NoCreation                           // A specified variable does not exist and cannot be created.
                                                      	InconsistentValue                    // A variable binding specifies a value that could be held by the variable but cannot be assigned to it at this time.
                                                      	ResourceUnavailable                  // An attempt to set a variable required a resource that is not available.
                                                      	CommitFailed                         // An attempt to set a particular variable failed.
                                                      	UndoFailed                           // An attempt to set a particular variable as part of a group of variables failed, and the attempt to then undo the setting of other variables was not successful.
                                                      	AuthorizationError                   // A problem occurred in authorization.
                                                      	NotWritable                          // The variable cannot be written or created.
                                                      	InconsistentName                     // The name in a variable binding specifies a variable that does not exist.

                                                        SNMP Errors

                                                        type SnmpPDU

                                                        type SnmpPDU struct {
                                                        	// Name is an oid in string format eg "."
                                                        	Name string `json:"name"`
                                                        	// The type of the value eg Integer
                                                        	Type Asn1BER `json:"type, string"`
                                                        	// The value to be set by the SNMP set, or the value when
                                                        	// sending a trap
                                                        	Value interface{} `json:"value"`
                                                        	// Logger implements the Logger interface
                                                        	Logger Logger `json:"-"`

                                                          SnmpPDU will be used when doing SNMP Set's

                                                          func (*SnmpPDU) Check

                                                          func (p *SnmpPDU) Check(err error)

                                                            Check makes checking errors easy, so they actually get a minimal check

                                                            type SnmpPacket

                                                            type SnmpPacket struct {
                                                            	Version            SnmpVersion
                                                            	MsgFlags           SnmpV3MsgFlags
                                                            	SecurityModel      SnmpV3SecurityModel
                                                            	SecurityParameters SnmpV3SecurityParameters
                                                            	ContextEngineID    string
                                                            	ContextName        string
                                                            	Community          string
                                                            	PDUType            PDUType
                                                            	MsgID              uint32
                                                            	RequestID          uint32
                                                            	Error              SNMPError
                                                            	ErrorIndex         uint8
                                                            	NonRepeaters       uint8
                                                            	MaxRepetitions     uint8
                                                            	Variables          []SnmpPDU
                                                            	Logger             Logger
                                                            	// v1 traps have a very different format from v2c and v3 traps.
                                                            	// These fields are set via the SnmpTrap parameter to SendTrap().

                                                              SnmpPacket struct represents the entire SNMP Message or Sequence at the application layer.

                                                              func (*SnmpPacket) Check

                                                              func (p *SnmpPacket) Check(err error)

                                                                Check makes checking errors easy, so they actually get a minimal check

                                                                type SnmpTrap

                                                                type SnmpTrap struct {
                                                                	Variables []SnmpPDU
                                                                	// These fields are required for SNMPV1 Trap Headers
                                                                	Enterprise   string
                                                                	AgentAddress string
                                                                	GenericTrap  int
                                                                	SpecificTrap int
                                                                	Timestamp    uint

                                                                  SnmpTrap is used to define a SNMP trap, and is passed into SendTrap

                                                                  type SnmpV3AuthProtocol

                                                                  type SnmpV3AuthProtocol uint8

                                                                    SnmpV3AuthProtocol describes the authentication protocol in use by an authenticated SnmpV3 connection.

                                                                    const (
                                                                    	NoAuth SnmpV3AuthProtocol = 1
                                                                    	MD5    SnmpV3AuthProtocol = 2
                                                                    	SHA    SnmpV3AuthProtocol = 3

                                                                      NoAuth, MD5, and SHA are implemented

                                                                      type SnmpV3MsgFlags

                                                                      type SnmpV3MsgFlags uint8

                                                                        SnmpV3MsgFlags contains various message flags to describe Authentication, Privacy, and whether a report PDU must be sent.

                                                                        const (
                                                                        	NoAuthNoPriv SnmpV3MsgFlags = 0x0 // No authentication, and no privacy
                                                                        	AuthNoPriv   SnmpV3MsgFlags = 0x1 // Authentication and no privacy
                                                                        	AuthPriv     SnmpV3MsgFlags = 0x3 // Authentication and privacy
                                                                        	Reportable   SnmpV3MsgFlags = 0x4 // Report PDU must be sent.

                                                                          Possible values of SnmpV3MsgFlags

                                                                          type SnmpV3PrivProtocol

                                                                          type SnmpV3PrivProtocol uint8

                                                                            SnmpV3PrivProtocol is the privacy protocol in use by an private SnmpV3 connection.

                                                                            const (
                                                                            	NoPriv SnmpV3PrivProtocol = 1
                                                                            	DES    SnmpV3PrivProtocol = 2
                                                                            	AES    SnmpV3PrivProtocol = 3

                                                                              NoPriv, DES implemented, AES planned

                                                                              type SnmpV3SecurityModel

                                                                              type SnmpV3SecurityModel uint8

                                                                                SnmpV3SecurityModel describes the security model used by a SnmpV3 connection

                                                                                const (
                                                                                	UserSecurityModel SnmpV3SecurityModel = 3

                                                                                  UserSecurityModel is the only SnmpV3SecurityModel currently implemented.

                                                                                  type SnmpV3SecurityParameters

                                                                                  type SnmpV3SecurityParameters interface {
                                                                                  	Copy() SnmpV3SecurityParameters
                                                                                  	// contains filtered or unexported methods

                                                                                    SnmpV3SecurityParameters is a generic interface type to contain various implementations of SnmpV3SecurityParameters

                                                                                    type SnmpVersion

                                                                                    type SnmpVersion uint8

                                                                                      SnmpVersion 1, 2c and 3 implemented

                                                                                      const (
                                                                                      	Version1  SnmpVersion = 0x0
                                                                                      	Version2c SnmpVersion = 0x1
                                                                                      	Version3  SnmpVersion = 0x3

                                                                                        SnmpVersion 1, 2c and 3 implemented

                                                                                        func (SnmpVersion) String

                                                                                        func (s SnmpVersion) String() string

                                                                                        type TrapListener

                                                                                        type TrapListener struct {
                                                                                        	OnNewTrap func(s *SnmpPacket, u *net.UDPAddr)
                                                                                        	Params    *GoSNMP
                                                                                        	// contains filtered or unexported fields

                                                                                          A TrapListener defines parameters for running a SNMP Trap receiver. nil values will be replaced by default values.

                                                                                          func NewTrapListener

                                                                                          func NewTrapListener() *TrapListener

                                                                                            NewTrapListener returns an initialized TrapListener.

                                                                                            func (*TrapListener) Close

                                                                                            func (t *TrapListener) Close()

                                                                                              Close terminates the listening on TrapListener socket

                                                                                              func (*TrapListener) Listen

                                                                                              func (t *TrapListener) Listen(addr string) (err error)

                                                                                                Listen listens on the UDP address addr and calls the OnNewTrap function specified in *TrapListener for every trap received.

                                                                                                func (*TrapListener) Listening

                                                                                                func (t *TrapListener) Listening() <-chan bool

                                                                                                  Listening returns a sentinel channel on which one can block until the listener is ready to receive requests.

                                                                                                  type UsmSecurityParameters

                                                                                                  type UsmSecurityParameters struct {
                                                                                                  	AuthoritativeEngineID    string
                                                                                                  	AuthoritativeEngineBoots uint32
                                                                                                  	AuthoritativeEngineTime  uint32
                                                                                                  	UserName                 string
                                                                                                  	AuthenticationParameters string
                                                                                                  	PrivacyParameters        []byte
                                                                                                  	AuthenticationProtocol SnmpV3AuthProtocol
                                                                                                  	PrivacyProtocol        SnmpV3PrivProtocol
                                                                                                  	AuthenticationPassphrase string
                                                                                                  	PrivacyPassphrase        string
                                                                                                  	Logger Logger
                                                                                                  	// contains filtered or unexported fields

                                                                                                    UsmSecurityParameters is an implementation of SnmpV3SecurityParameters for the UserSecurityModel

                                                                                                    func (*UsmSecurityParameters) Copy

                                                                                                      Copy method for UsmSecurityParameters used to copy a SnmpV3SecurityParameters without knowing it's implementation

                                                                                                      func (*UsmSecurityParameters) Log

                                                                                                      func (sp *UsmSecurityParameters) Log()

                                                                                                      type VarBind

                                                                                                      type VarBind struct {
                                                                                                      	Name  asn1.ObjectIdentifier
                                                                                                      	Value asn1.RawValue

                                                                                                        VarBind struct represents an SNMP Varbind.

                                                                                                        type WalkFunc

                                                                                                        type WalkFunc func(dataUnit SnmpPDU) error

                                                                                                          WalkFunc is the type of the function called for each data unit visited by the Walk function. If an error is returned processing stops.


                                                                                                          Path Synopsis
                                                                                                          This program demonstrates BulkWalk.
                                                                                                          This program demonstrates BulkWalk.