func (msg *MessageV3) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return nil, err
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagSequence || !raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid MessageV3 object - Class [%02x], Tag [%02x] : [%s]",
raw.FullBytes[0], asn1.TagSequence, ToHexStr(b, " "))}
}
next := raw.Bytes
var version int
next, err = asn1.Unmarshal(next, &version)
if err != nil {
return
}
next, err = msg.globalDataV3.Unmarshal(next)
if err != nil {
return
}
next, err = msg.securityParameterV3.Unmarshal(next)
if err != nil {
return
}
msg.version = SnmpVersion(version)
msg.pduBytes = next
return
}
func (msg *MessageV1) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagSequence || !raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid MessageV1 object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(b, " "))}
}
next := raw.Bytes
var version int
next, err = asn1.Unmarshal(next, &version)
if err != nil {
return
}
var community []byte
next, err = asn1.Unmarshal(next, &community)
if err != nil {
return
}
msg.version = SnmpVersion(version)
msg.Community = community
msg.pduBytes = next
return
}
func (v *VariableBinding) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return nil, err
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagSequence || !raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid VariableBinding object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(b, " "))}
}
var oid Oid
next, err := (&oid).Unmarshal(raw.Bytes)
if err != nil {
return
}
variable, _, err := unmarshalVariable(next)
if err != nil {
return
}
v.Oid = oid
v.Variable = variable
return
}
func (sec *securityParameterV3) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagOctetString || raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid SecurityParameter object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(b, " "))}
}
_, err = asn1.Unmarshal(raw.Bytes, sec)
return
}
func decrypt(msg *MessageV3, proto PrivProtocol, key, privParam []byte) (err error) {
var raw asn1.RawValue
_, err = asn1.Unmarshal(msg.PduBytes(), &raw)
if err != nil {
return
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagOctetString || raw.IsCompound {
return asn1.StructuralError{fmt.Sprintf(
"Invalid encrypted PDU object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(msg.PduBytes(), " "))}
}
var dst []byte
switch proto {
case Des:
dst, err = DecryptDES(raw.Bytes, key, privParam)
case Aes:
dst, err = DecryptAES(
raw.Bytes, key, privParam, int32(msg.AuthEngineBoots), int32(msg.AuthEngineTime))
default:
err = errors.New("'" + fmt.Sprint(proto) + "' is unsupported crypto.")
}
if err == nil {
msg.SetPduBytes(dst)
}
return
}
func (v *Oid) Unmarshal(b []byte) (rest []byte, err error) {
var i asn1.ObjectIdentifier
rest, err = asn1.Unmarshal(b, &i)
if err == nil {
v.Value = []int(i)
}
return
}
func unmarshalEmpty(b []byte, tag byte) (rest []byte, err error) {
err = validateUnmarshal(b, tag)
if err != nil {
return nil, err
}
var raw asn1.RawValue
return asn1.Unmarshal(b, &raw)
}
func (pdu *ScopedPdu) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return nil, err
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagSequence || !raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid ScopedPud object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(b, " "))}
}
next := raw.Bytes
var contextEngineId []byte
next, err = asn1.Unmarshal(next, &contextEngineId)
if err != nil {
return
}
var contextName []byte
next, err = asn1.Unmarshal(next, &contextName)
if err != nil {
return
}
var pduV1 PduV1
_, err = (&pduV1).Unmarshal(next)
if err != nil {
return
}
pdu.ContextEngineId = contextEngineId
pdu.ContextName = contextName
pdu.PduV1 = pduV1
return
}
func unmarshalString(b []byte, tag byte, setter func([]byte)) (rest []byte, err error) {
err = validateUnmarshal(b, tag)
if err != nil {
return nil, err
}
temp := b[0]
b[0] = asn1.TagOctetString
var s []byte
rest, err = asn1.Unmarshal(b, &s)
if err == nil {
setter(s)
}
b[0] = temp
return
}
func unmarshalInt(b []byte, tag byte, setter func(*big.Int)) (rest []byte, err error) {
err = validateUnmarshal(b, tag)
if err != nil {
return nil, err
}
temp := b[0]
b[0] = asn1.TagInteger
var i *big.Int
rest, err = asn1.Unmarshal(b, &i)
if err == nil {
setter(i)
}
b[0] = temp
return
}
func (h *globalDataV3) Unmarshal(b []byte) (rest []byte, err error) {
return asn1.Unmarshal(b, h)
}
func unmarshalVariable(b []byte) (v Variable, rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return
}
switch raw.Class {
case asn1.ClassUniversal:
switch raw.Tag {
case asn1.TagInteger:
var u Integer
v = &u
case asn1.TagOctetString:
var u OctetString
v = &u
case asn1.TagNull:
var u Null
v = &u
case asn1.TagOID:
var u Oid
v = &u
}
case asn1.ClassApplication:
switch raw.Tag {
case asn1.TagIPAddress & tagMask:
var u Ipaddress
v = &u
case asn1.TagCounter32 & tagMask:
var u Counter32
v = &u
case asn1.TagGauge32 & tagMask:
var u Gauge32
v = &u
case asn1.TagTimeticks & tagMask:
var u TimeTicks
v = &u
case asn1.TagOpaque & tagMask:
var u Opaque
v = &u
case asn1.TagCounter64 & tagMask:
var u Counter64
v = &u
}
case asn1.ClassContextSpecific:
switch raw.Tag {
case asn1.TagNoSuchObject & tagMask:
var u NoSucheObject
v = &u
case asn1.TagNoSuchInstance & tagMask:
var u NoSucheInstance
v = &u
case asn1.TagEndOfMibView & tagMask:
var u EndOfMibView
v = &u
}
}
if v != nil {
rest, err = v.Unmarshal(b)
if err == nil {
return
}
} else {
err = asn1.StructuralError{fmt.Sprintf(
"Unknown ASN.1 object : %s", ToHexStr(b, " "))}
}
return nil, nil, err
}
func (v *Integer) Unmarshal(b []byte) (rest []byte, err error) {
return asn1.Unmarshal(b, &v.Value)
}
func (self *internal_pinger) serve() {
defer self.wait.Done()
cached := make([]byte, 4000)
for 1 == atomic.LoadInt32(&self.is_running) {
l, ra, err := self.conn.ReadFrom(cached)
if err != nil {
if strings.Contains(err.Error(), "No service is operating") { //Port Unreachable
continue
}
if strings.Contains(err.Error(), "forcibly closed by the remote host") { //Port Unreachable
continue
}
self.ch <- &PingResult{Error: fmt.Errorf("ReadFrom failed: %v, %v", ra, err)}
continue
}
recv_bytes := cached[:l]
var raw asn1.RawValue
if _, err = asn1.Unmarshal(recv_bytes, &raw); err != nil {
log.Printf("[snmp-pinger] Invalid Message object - %s : [%s]",
err.Error(), ToHexStr(recv_bytes, " "))
continue
}
if raw.Class != asn1.ClassUniversal || raw.Tag != asn1.TagSequence || !raw.IsCompound {
log.Printf("[snmp-pinger] Invalid Message object - Class [%02x], Tag [%02x] : [%s]",
raw.FullBytes[0], raw.Tag, ToHexStr(recv_bytes, " "))
continue
}
next := raw.Bytes
var version int
next, err = asn1.Unmarshal(next, &version)
if err != nil {
log.Printf("[snmp-pinger] Invalid Message object - %s : [%s]",
err.Error(), ToHexStr(recv_bytes, " "))
continue
}
if SnmpVersion(version) == V3 {
var managedId int
next, err = asn1.Unmarshal(next, &managedId)
if err != nil {
log.Printf("[snmp-pinger] Failed to Unmarshal message - %s : [%s]",
err.Error(), ToHexStr(recv_bytes, " "))
continue
}
self.ch <- &PingResult{Id: managedId, Addr: ra, Version: SnmpVersion(version), Timestamp: time.Now()}
} else {
pdu := &PduV1{}
recvMsg := &MessageV1{
version: SnmpVersion(version),
pdu: pdu,
}
_, err = recvMsg.Unmarshal(recv_bytes)
if err != nil {
log.Printf("[snmp-pinger] Failed to Unmarshal message - %s : [%s]",
err.Error(), ToHexStr(recv_bytes, " "))
continue
}
_, err = pdu.Unmarshal(recvMsg.PduBytes())
if err != nil {
log.Printf("[snmp-pinger] Failed to Unmarshal PDU - %s : [%s]",
err.Error(), ToHexStr(recv_bytes, " "))
continue
}
self.ch <- &PingResult{Id: pdu.RequestId(),
Addr: ra,
Version: SnmpVersion(version),
Community: string(recvMsg.Community),
Timestamp: time.Now()}
}
}
}
func (pdu *PduV1) Unmarshal(b []byte) (rest []byte, err error) {
var raw asn1.RawValue
rest, err = asn1.Unmarshal(b, &raw)
if err != nil {
return
}
if raw.Class != asn1.ClassContextSpecific || !raw.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid PDU object - Class [%02x], Tag [%02x] : [%s]",
raw.Class, raw.Tag, ToHexStr(b, " "))}
}
var requestId int
var errorStatus int
var errorIndex int
var enterprise Oid
var agentAddress Ipaddress
var genericTrap int
var specificTrap int
var timestamp asn1.BitString
next := raw.Bytes
// The protocol data unit of SNMP
// The PduV1 is used by SNMP V1 and V2c, other than the SNMP V1 Trap
//
// trap pdu
// +------------+--------------+------------+----------------+---------------+-------------+---------------------+
// | PDU Type | enterprise | agent addr | generic trap | specific trap | time stamp | variable bindings |
// +------------+--------------+------------+----------------+---------------+-------------+---------------------+
//
// reponse pdu
// +------------+--------------+----------------+---------------+----------------------+
// | PDU Type | request id | error status | error index | variable bindings |
// +------------+--------------+----------------+---------------+----------------------+
//
// request pdu
// +------------+--------------+----------------+---------------+----------------------+
// | PDU Type | request id | 0 | 0 | variable bindings |
// +------------+--------------+----------------+---------------+----------------------+
//
if Trap == PduType(raw.Tag) {
next, err = enterprise.Unmarshal(next)
if err != nil {
return
}
next, err = agentAddress.Unmarshal(next)
if err != nil {
return
}
next, err = asn1.Unmarshal(next, &genericTrap)
if err != nil {
return
}
next, err = asn1.Unmarshal(next, &specificTrap)
if err != nil {
return
}
var t asn1.RawValue
next, err = asn1.Unmarshal(next, &t)
if err != nil {
return
}
} else {
next, err = asn1.Unmarshal(next, &requestId)
if err != nil {
return
}
next, err = asn1.Unmarshal(next, &errorStatus)
if err != nil {
return
}
next, err = asn1.Unmarshal(next, &errorIndex)
if err != nil {
return
}
}
var VariableBindings asn1.RawValue
_, err = asn1.Unmarshal(next, &VariableBindings)
if err != nil {
return
}
if VariableBindings.Class != asn1.ClassUniversal || VariableBindings.Tag != asn1.TagSequence || !VariableBindings.IsCompound {
return nil, asn1.StructuralError{fmt.Sprintf(
"Invalid VariableBindings object - Class [%02x], Tag [%02x] : [%s]",
VariableBindings.Class, VariableBindings.Tag, ToHexStr(next, " "))}
}
next = VariableBindings.Bytes
for len(next) > 0 {
var variableBinding VariableBinding
next, err = variableBinding.Unmarshal(next)
if err != nil {
return
}
pdu.variableBindings = append(pdu.variableBindings, variableBinding)
}
pdu.pduType = PduType(raw.Tag)
pdu.requestId = requestId
pdu.errorStatus = ErrorStatus(errorStatus)
pdu.errorIndex = errorIndex
pdu.Enterprise = enterprise
pdu.AgentAddress = agentAddress
pdu.GenericTrap = genericTrap
pdu.SpecificTrap = specificTrap
pdu.Timestamp = timestamp
return
}
