gosnmp: github.com/soniah/gosnmp Index | Files | Directories

package gosnmp

import "github.com/soniah/gosnmp"

Index

Package Files

asn1ber_string.go gosnmp.go helper.go interface.go marshal.go snmperror_string.go snmpv3authprotocol_string.go snmpv3privprotocol_string.go trap.go v3.go v3_testing_credentials.go v3_usm.go walk.go

Constants

const AsnExtensionID = 0x1F

AsnExtensionID mask to identify types > 30 in subsequent byte

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
)

Variables

var Default = &GoSNMP{
    Port:               161,
    Transport:          udp,
    Community:          "public",
    Version:            Version2c,
    Timeout:            time.Duration(2) * time.Second,
    Retries:            3,
    ExponentialTimeout: true,
    MaxOids:            MaxOids,
}

Default connection settings nolint:gochecknoglobals

func Check Uses

func Check(err error)

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

func Partition Uses

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 Uses

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 Uses

type Asn1BER byte

Asn1BER is the type of the SNMP PDU

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

Asn1BER's - http://www.ietf.org/rfc/rfc1442.txt

func (Asn1BER) String Uses

func (i Asn1BER) String() string

type BitStringValue Uses

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 Uses

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 Uses

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 GoSNMP Uses

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 port
    Port uint16

    // Transport is the transport protocol to use ("udp" or "tcp"); if unset "udp" will be used.
    Transport string

    // Community is an SNMP Community string
    Community string

    // Version is an SNMP Version
    Version SnmpVersion

    // Context allows for overall deadlines and cancellation
    Context context.Context

    // Timeout is the timeout for one SNMP request/response
    Timeout time.Duration

    // Set the number of retries to attempt
    Retries int

    // Double timeout in each retry
    ExponentialTimeout bool

    // 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 https://github.com/gosnmp/gosnmp/issues/100
    MaxRepetitions uint8

    // NonRepeaters sets the GETBULK max-repeaters used by BulkWalk*
    // (default: 0 as per RFC 1905)
    NonRepeaters int

    // netsnmp has '-C APPOPTS - set various application specific behaviours'
    //
    // - 'c: do not check returned OIDs are increasing' - use AppOpts = map[string]interface{"c":true} with
    //   Walk() or BulkWalk(). The library user needs to implement their own policy for terminating walks.
    // - 'p,i,I,t,E' -> pull requests welcome
    AppOpts map[string]interface{}

    // MsgFlags is an SNMPV3 MsgFlags
    MsgFlags SnmpV3MsgFlags

    // SecurityModel is an SNMPV3 Security Model
    SecurityModel SnmpV3SecurityModel

    // SecurityParameters is an SNMPV3 Security Model parameters 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 Uses

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 Uses

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. Caution: if you have set x.AppOpts to 'c', BulkWalkAll may loop indefinitely and cause an Out Of Memory - use BulkWalk instead.

func (*GoSNMP) Check Uses

func (x *GoSNMP) Check(err error)

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

func (*GoSNMP) Connect Uses

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. Neither will you know if the host is regularly disappearing and reappearing.

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

func (*GoSNMP) ConnectIPv4 Uses

func (x *GoSNMP) ConnectIPv4() error

ConnectIPv4 forces an IPv4-only connection

func (*GoSNMP) ConnectIPv6 Uses

func (x *GoSNMP) ConnectIPv6() error

ConnectIPv6 forces an IPv6-only connection

func (*GoSNMP) Get Uses

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

Get sends an SNMP GET request

func (*GoSNMP) GetBulk Uses

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 Uses

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

GetNext sends an SNMP GETNEXT request

func (*GoSNMP) SendTrap Uses

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.

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

func (*GoSNMP) Set Uses

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

Set sends an SNMP SET request

func (*GoSNMP) SetMsgID Uses

func (x *GoSNMP) SetMsgID(msgID uint32)

SetMsgID sets the base ID value for future messages

func (*GoSNMP) SetRequestID Uses

func (x *GoSNMP) SetRequestID(reqID uint32)

SetRequestID sets the base ID value for future requests

func (*GoSNMP) SnmpDecodePacket Uses

func (x *GoSNMP) SnmpDecodePacket(resp []byte) (*SnmpPacket, error)

SnmpDecodePacket exposes SNMP packet parsing to external callers. This is useful for processing traffic from other sources and building test harnesses.

func (*GoSNMP) SnmpEncodePacket Uses

func (x *GoSNMP) SnmpEncodePacket(pdutype PDUType, pdus []SnmpPDU, nonRepeaters uint8, maxRepetitions uint8) ([]byte, error)

SnmpEncodePacket exposes SNMP packet generation to external callers. This is useful for generating traffic for use over separate transport stacks and creating traffic samples for test purposes.

func (*GoSNMP) UnmarshalTrap Uses

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

UnmarshalTrap unpacks the SNMP Trap.

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

func (*GoSNMP) Walk Uses

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 Uses

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. Caution: if you have set x.AppOpts to 'c', WalkAll may loop indefinitely and cause an Out Of Memory - use Walk instead.

type Handler Uses

type Handler interface {
    // 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.
    Connect() error

    // ConnectIPv4 connects using IPv4
    ConnectIPv4() error

    // ConnectIPv6 connects using IPv6
    ConnectIPv6() error

    // Get sends an SNMP GET request
    Get(oids []string) (result *SnmpPacket, err error)

    // GetBulk sends an SNMP GETBULK request
    //
    // For maxRepetitions greater than 255, use BulkWalk() or BulkWalkAll()
    GetBulk(oids []string, nonRepeaters uint8, maxRepetitions uint8) (result *SnmpPacket, err error)

    // GetNext sends an SNMP GETNEXT request
    GetNext(oids []string) (result *SnmpPacket, err 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.
    Walk(rootOid string, walkFn WalkFunc) error

    // WalkAll is similar to Walk but returns a filled array of all values rather
    // than using a callback function to stream results.
    WalkAll(rootOid string) (results []SnmpPDU, err 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.
    BulkWalk(rootOid string, walkFn WalkFunc) error

    // BulkWalkAll is similar to BulkWalk but returns a filled array of all values
    // rather than using a callback function to stream results.
    BulkWalkAll(rootOid string) (results []SnmpPDU, 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.
    SendTrap(trap SnmpTrap) (result *SnmpPacket, err error)

    // UnmarshalTrap unpacks the SNMP Trap.
    UnmarshalTrap(trap []byte, useResponseSecurityParameters bool) (result *SnmpPacket)

    // Set sends an SNMP SET request
    Set(pdus []SnmpPDU) (result *SnmpPacket, err error)

    // Check makes checking errors easy, so they actually get a minimal check
    Check(err error)

    // Close closes the connection
    Close() error

    // Target gets the Target
    Target() string

    // SetTarget sets the Target
    SetTarget(target string)

    // Port gets the Port
    Port() uint16

    // SetPort sets the Port
    SetPort(port uint16)

    // Community gets the Community
    Community() string

    // SetCommunity sets the Community
    SetCommunity(community string)

    // Version gets the Version
    Version() SnmpVersion

    // SetVersion sets the Version
    SetVersion(version SnmpVersion)

    // Timeout gets the Timeout
    Timeout() time.Duration

    // SetTimeout sets the Timeout
    SetTimeout(timeout time.Duration)

    // Retries gets the Retries
    Retries() int

    // SetRetries sets the Retries
    SetRetries(retries int)

    // GetExponentialTimeout gets the ExponentialTimeout
    GetExponentialTimeout() bool

    // SetExponentialTimeout sets the ExponentialTimeout
    SetExponentialTimeout(value bool)

    // Logger gets the Logger
    Logger() Logger

    // SetLogger sets the Logger
    SetLogger(logger Logger)

    // MaxOids gets the MaxOids
    MaxOids() int

    // SetMaxOids sets the MaxOids
    SetMaxOids(maxOids int)

    // MaxRepetitions gets the maxRepetitions
    MaxRepetitions() uint8

    // SetMaxRepetitions sets the maxRepetitions
    SetMaxRepetitions(maxRepetitions uint8)

    // NonRepeaters gets the nonRepeaters
    NonRepeaters() int

    // SetNonRepeaters sets the nonRepeaters
    SetNonRepeaters(nonRepeaters int)

    // MsgFlags gets the MsgFlags
    MsgFlags() SnmpV3MsgFlags

    // SetMsgFlags sets the MsgFlags
    SetMsgFlags(msgFlags SnmpV3MsgFlags)

    // SecurityModel gets the SecurityModel
    SecurityModel() SnmpV3SecurityModel

    // SetSecurityModel sets the SecurityModel
    SetSecurityModel(securityModel SnmpV3SecurityModel)

    // SecurityParameters gets the SecurityParameters
    SecurityParameters() SnmpV3SecurityParameters

    // SetSecurityParameters sets the SecurityParameters
    SetSecurityParameters(securityParameters SnmpV3SecurityParameters)

    // ContextEngineID gets the ContextEngineID
    ContextEngineID() string

    // SetContextEngineID sets the ContextEngineID
    SetContextEngineID(contextEngineID string)

    // ContextName gets the ContextName
    ContextName() string

    // SetContextName sets the ContextName
    SetContextName(contextName string)
}

Handler is a GoSNMP interface

Handler is provided to assist with testing using mocks

func NewHandler Uses

func NewHandler() Handler

NewHandler creates a new Handler using gosnmp

type Logger Uses

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 Uses

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 Uses

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

func (SNMPError) String Uses

func (i SNMPError) String() string

type SnmpPDU Uses

type SnmpPDU struct {
    // Name is an oid in string format eg ".1.3.6.1.4.9.27"
    Name string

    // The type of the value eg Integer
    Type Asn1BER

    // The value to be set by the SNMP set, or the value when
    // sending a trap
    Value interface{}
}

SnmpPDU will be used when doing SNMP Set's

type SnmpPacket Uses

type SnmpPacket struct {
    Version            SnmpVersion
    MsgFlags           SnmpV3MsgFlags
    SecurityModel      SnmpV3SecurityModel
    SecurityParameters SnmpV3SecurityParameters // interface
    ContextEngineID    string
    ContextName        string
    Community          string
    PDUType            PDUType
    MsgID              uint32
    RequestID          uint32
    MsgMaxSize         uint32
    Error              SNMPError
    ErrorIndex         uint8
    NonRepeaters       uint8
    MaxRepetitions     uint8
    Variables          []SnmpPDU
    Logger             Logger // interface

    // v1 traps have a very different format from v2c and v3 traps.
    //
    // These fields are set via the SnmpTrap parameter to SendTrap().
    SnmpTrap
}

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

func (*SnmpPacket) Check Uses

func (packet *SnmpPacket) Check(err error)

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

func (*SnmpPacket) MarshalMsg Uses

func (packet *SnmpPacket) MarshalMsg() ([]byte, error)

MarshalMsg marshalls a snmp packet, ready for sending across the wire

type SnmpTrap Uses

type SnmpTrap struct {
    Variables []SnmpPDU

    // If true, the trap is an InformRequest, not a trap. This has no effect on
    // v1 traps, as Inform is not part of the v1 protocol.
    IsInform bool

    // 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 Uses

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
    SHA224 SnmpV3AuthProtocol = 4
    SHA256 SnmpV3AuthProtocol = 5
    SHA384 SnmpV3AuthProtocol = 6
    SHA512 SnmpV3AuthProtocol = 7
)

NoAuth, MD5, and SHA are implemented

func (SnmpV3AuthProtocol) HashType Uses

func (authProtocol SnmpV3AuthProtocol) HashType() crypto.Hash

HashType maps the AuthProtocol's hash type to an actual crypto.Hash object.

func (SnmpV3AuthProtocol) String Uses

func (authProtocol SnmpV3AuthProtocol) String() string

type SnmpV3MsgFlags Uses

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 Uses

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
    AES192  SnmpV3PrivProtocol = 4 // Blumenthal-AES192
    AES256  SnmpV3PrivProtocol = 5 // Blumenthal-AES256
    AES192C SnmpV3PrivProtocol = 6 // Reeder-AES192
    AES256C SnmpV3PrivProtocol = 7 // Reeder-AES256
)

NoPriv, DES implemented, AES planned Changed: AES192, AES256, AES192C, AES256C added

func (SnmpV3PrivProtocol) String Uses

func (i SnmpV3PrivProtocol) String() string

type SnmpV3SecurityModel Uses

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 Uses

type SnmpV3SecurityParameters interface {
    Log()
    Copy() SnmpV3SecurityParameters
    Description() string
    // contains filtered or unexported methods
}

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

type SnmpVersion Uses

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 Uses

func (s SnmpVersion) String() string

type TrapHandlerFunc Uses

type TrapHandlerFunc func(s *SnmpPacket, u *net.UDPAddr)

TrapHandlerFunc is a callback function type which receives SNMP Trap and Inform packets when they are received. If this callback is null, Trap and Inform PDUs will not be received (Inform responses will still be sent, however). This callback should not modify the contents of the SnmpPacket nor the UDPAddr passed to it, and it should copy out any values it wishes to use instead of retaining references in order to avoid memory fragmentation.

The general effect of received Trap and Inform packets do not differ for the receiver, and the response is handled by the caller of the handler, so there is no need for the application to handle Informs any different than Traps. Nonetheless, the packet's Type field can be examined to determine what type of event this is for e.g. statistics gathering functions, etc.

type TrapListener Uses

type TrapListener struct {
    sync.Mutex

    // Params is a reference to the TrapListener's "parent" GoSNMP instance.
    Params *GoSNMP

    // OnNewTrap handles incoming Trap and Inform PDUs.
    OnNewTrap TrapHandlerFunc
    // 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 Uses

func NewTrapListener() *TrapListener

NewTrapListener returns an initialized TrapListener.

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

func (*TrapListener) Close Uses

func (t *TrapListener) Close()

Close terminates the listening on TrapListener socket

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

func (*TrapListener) Listen Uses

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

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

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

func (*TrapListener) Listening Uses

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

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

NOTE: the trap code is currently unreliable when working with snmpv3 - pull requests welcome

type UsmSecurityParameters Uses

type UsmSecurityParameters struct {
    AuthoritativeEngineID    string
    AuthoritativeEngineBoots uint32
    AuthoritativeEngineTime  uint32
    UserName                 string
    AuthenticationParameters string
    PrivacyParameters        []byte

    AuthenticationProtocol SnmpV3AuthProtocol
    PrivacyProtocol        SnmpV3PrivProtocol

    AuthenticationPassphrase string
    PrivacyPassphrase        string

    SecretKey  []byte
    PrivacyKey []byte

    Logger Logger
    // contains filtered or unexported fields
}

UsmSecurityParameters is an implementation of SnmpV3SecurityParameters for the UserSecurityModel

func (*UsmSecurityParameters) Copy Uses

func (sp *UsmSecurityParameters) Copy() SnmpV3SecurityParameters

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

func (*UsmSecurityParameters) Description Uses

func (sp *UsmSecurityParameters) Description() string

Log logs security paramater information to the provided GoSNMP Logger

func (*UsmSecurityParameters) Log Uses

func (sp *UsmSecurityParameters) Log()

Log logs security paramater information to the provided GoSNMP Logger

type VarBind Uses

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

VarBind struct represents an SNMP Varbind.

type WalkFunc Uses

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.

Directories

PathSynopsis
mocksPackage mocks is a generated GoMock package.

Package gosnmp imports 32 packages (graph) and is imported by 123 packages. Updated 2020-11-21. Refresh now. Tools for package owners.