func TestMessageV1(t *testing.T) {
pdu := snmpgo.NewPdu(snmpgo.V2c, snmpgo.GetRequest)
msg := snmpgo.ToMessageV1(snmpgo.NewMessage(snmpgo.V2c, pdu))
b, _ := pdu.Marshal()
msg.SetPduBytes(b)
msg.Community = []byte("MyCommunity")
expBuf := []byte{
0x30, 0x1d, 0x02, 0x01, 0x01, 0x04, 0x0b, 0x4d, 0x79, 0x43, 0x6f,
0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0xa0, 0x0b, 0x02, 0x01,
0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x30, 0x00,
}
buf, err := msg.Marshal()
if err != nil {
t.Fatal("Marshal() : %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
expStr := `{"Version": "2c", "Community": "MyCommunity", ` +
`"Pdu": {"Type": "GetRequest", "RequestId": "0", "ErrorStatus": ` +
`"NoError", "ErrorIndex": "0", "VarBinds": []}}`
m := snmpgo.NewMessage(snmpgo.V2c, pdu)
rest, err := m.Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != m.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, m.String())
}
}
// RFC3414 A.3
func TestPasswordToKey(t *testing.T) {
password := "******"
engineId := []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
}
expBuf := []byte{
0x52, 0x6f, 0x5e, 0xed, 0x9f, 0xcc, 0xe2, 0x6f,
0x89, 0x64, 0xc2, 0x93, 0x07, 0x87, 0xd8, 0x2b,
}
key := snmpgo.PasswordToKey(snmpgo.Md5, password, engineId)
if !bytes.Equal(expBuf, key) {
t.Errorf("passwordToKey(Md5) - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(key, " "))
}
expBuf = []byte{
0x66, 0x95, 0xfe, 0xbc, 0x92, 0x88, 0xe3, 0x62, 0x82, 0x23,
0x5f, 0xc7, 0x15, 0x1f, 0x12, 0x84, 0x97, 0xb3, 0x8f, 0x3f,
}
key = snmpgo.PasswordToKey(snmpgo.Sha, password, engineId)
if !bytes.Equal(expBuf, key) {
t.Errorf("passwordToKey(Aes) - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(key, " "))
}
}
func TestMessageV3(t *testing.T) {
pdu := snmpgo.NewPdu(snmpgo.V3, snmpgo.GetRequest)
msg := snmpgo.ToMessageV3(snmpgo.NewMessage(snmpgo.V3, pdu))
b, _ := pdu.Marshal()
msg.SetPduBytes(b)
msg.MessageId = 123
msg.MessageMaxSize = 321
msg.SetReportable(true)
msg.SetPrivacy(true)
msg.SetAuthentication(true)
msg.SecurityModel = 3
msg.AuthEngineId = []byte{0x80, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}
msg.AuthEngineBoots = 456
msg.AuthEngineTime = 654
msg.UserName = []byte("User")
msg.AuthParameter = []byte{0xaa, 0xbb, 0xcc}
msg.PrivParameter = []byte{0xdd, 0xee, 0xff}
expBuf := []byte{
0x30, 0x4b, 0x02, 0x01, 0x03, 0x30, 0x0d, 0x02, 0x01, 0x7b,
0x02, 0x02, 0x01, 0x41, 0x04, 0x01, 0x07, 0x02, 0x01, 0x03,
0x04, 0x24, 0x30, 0x22, 0x04, 0x08, 0x80, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x02, 0x02, 0x01, 0xc8, 0x02, 0x02, 0x02, 0x8e, 0x04, 0x04, 0x55, 0x73, 0x65, 0x72,
0x04, 0x03, 0xaa, 0xbb, 0xcc, 0x04, 0x03, 0xdd, 0xee, 0xff,
0x30, 0x11, 0x04, 0x00, 0x04, 0x00, 0xa0, 0x0b, 0x02, 0x01,
0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x30, 0x00,
}
buf, err := msg.Marshal()
if err != nil {
t.Fatal("Marshal() : %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
expStr := `{"Version": "3", "GlobalData": {"MessageId": "123", "MessageMaxSize": "321", ` +
`"MessageFlags": "apr", "SecurityModel": "USM"}, "SecurityParameter": ` +
`{"AuthEngineId": "8001020304050607", "AuthEngineBoots": "456", ` +
`"AuthEngineTime": "654", "UserName": "******", "AuthParameter": "aa:bb:cc", ` +
`"PrivParameter": "dd:ee:ff"}, "Pdu": {"Type": "GetRequest", "RequestId": "0", ` +
`"ErrorStatus": "NoError", "ErrorIndex": "0", "ContextEngineId": "", ` +
`"ContextName": "", "VarBinds": []}}`
m := snmpgo.NewMessage(snmpgo.V3, pdu)
rest, err := m.Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != m.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, m.String())
}
}
func TestScopedPdu(t *testing.T) {
pdu := snmpgo.NewPdu(snmpgo.V3, snmpgo.GetRequest)
pdu.SetRequestId(123)
pdu.SetErrorStatus(snmpgo.TooBig)
pdu.SetErrorIndex(2)
sp := pdu.(*snmpgo.ScopedPdu)
sp.ContextEngineId = []byte{0x80, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}
sp.ContextName = []byte("MyContext")
oid, _ := snmpgo.NewOid("1.3.6.1.2.1.1.1.0")
pdu.AppendVarBind(oid, snmpgo.NewOctetString([]byte("MyHost")))
oid, _ = snmpgo.NewOid("1.3.6.1.2.1.1.2.0")
pdu.AppendVarBind(oid, snmpgo.NewNull())
oid, _ = snmpgo.NewOid("1.3.6.1.2.1.1.3.0")
pdu.AppendVarBind(oid, snmpgo.NewTimeTicks(uint32(11111)))
expBuf := []byte{
0x30, 0x54, 0x04, 0x08, 0x80, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x04, 0x09, 0x4d, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
0xa0, 0x3d, 0x02, 0x01, 0x7b, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02,
0x30, 0x32, 0x30, 0x12, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x02, 0x01,
0x01, 0x01, 0x00, 0x04, 0x06, 0x4d, 0x79, 0x48, 0x6f, 0x73, 0x74,
0x30, 0x0c, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x02, 0x01, 0x01, 0x02,
0x00, 0x05, 0x00, 0x30, 0x0e, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x02,
0x01, 0x01, 0x03, 0x00, 0x43, 0x02, 0x2b, 0x67,
}
buf, err := pdu.Marshal()
if err != nil {
t.Fatal("Marshal() : %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
expStr := `{"Type": "GetRequest", "RequestId": "123", ` +
`"ErrorStatus": "TooBig", "ErrorIndex": "2", ` +
`"ContextEngineId": "8001020304050607", "ContextName": "MyContext", ` +
`"VarBinds": [` +
`{"Oid": "1.3.6.1.2.1.1.1.0", "Variable": {"Type": "OctetString", "Value": "MyHost"}}, ` +
`{"Oid": "1.3.6.1.2.1.1.2.0", "Variable": {"Type": "Null", "Value": ""}}, ` +
`{"Oid": "1.3.6.1.2.1.1.3.0", "Variable": {"Type": "TimeTicks", "Value": "11111"}}]}`
var w snmpgo.ScopedPdu
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestOid(t *testing.T) {
expStr := "1.3.6.1.2.1.1.1.0"
expBuf := []byte{0x06, 0x08, 0x2b, 0x06, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00}
var v snmpgo.Variable
v, err := snmpgo.NewOid(expStr)
if err != nil {
t.Errorf("NewOid : %v", err)
}
_, err = v.BigInt()
if err == nil {
t.Errorf("Failed to call BigInt()")
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual[%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.Oid
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestCounter64(t *testing.T) {
expInt := uint64(18446744073709551615)
expStr := "18446744073709551615"
expBuf := []byte{0x46, 0x09, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
var v snmpgo.Variable = snmpgo.NewCounter64(expInt)
big, err := v.BigInt()
if err != nil {
t.Errorf("Failed to call BigInt(): %v", err)
}
if expInt != big.Uint64() {
t.Errorf("BigInt() - expected [%d], actual [%d]", expInt, big.Int64())
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual [%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.Counter64
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestTimeTicks(t *testing.T) {
expInt := int64(4294967295)
expStr := "4294967295"
expBuf := []byte{0x43, 0x05, 0x00, 0xff, 0xff, 0xff, 0xff}
var v snmpgo.Variable = snmpgo.NewTimeTicks(uint32(expInt))
big, err := v.BigInt()
if err != nil {
t.Errorf("Failed to call BigInt(): %v", err)
}
if expInt != big.Int64() {
t.Errorf("BigInt() - expected [%d], actual [%d]", expInt, big.Int64())
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual [%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.TimeTicks
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestIpaddress(t *testing.T) {
expStr := "192.168.1.1"
expInt := int64(3232235777)
expBuf := []byte{0x40, 0x04, 0xc0, 0xa8, 0x01, 0x01}
var v snmpgo.Variable = snmpgo.NewIpaddress(0xc0, 0xa8, 0x01, 0x01)
big, err := v.BigInt()
if err != nil {
t.Errorf("Failed to call BigInt(): %v", err)
}
if expInt != big.Int64() {
t.Errorf("BigInt() - expected [%d], actual [%d]", expInt, big.Int64())
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual[%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.Ipaddress
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestEndOfMibView(t *testing.T) {
expStr := ""
expBuf := []byte{0x82, 0x00}
var v snmpgo.Variable = snmpgo.NewEndOfMibView()
_, err := v.BigInt()
if err == nil {
t.Errorf("Failed to call BigInt()")
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual[%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.EndOfMibView
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestOpaque(t *testing.T) {
expStr := "54:65:73:74"
expBuf := []byte{0x44, 0x04, 0x54, 0x65, 0x73, 0x74}
var v snmpgo.Variable = snmpgo.NewOpaque(expBuf[2:])
_, err := v.BigInt()
if err == nil {
t.Errorf("Failed to call BigInt()")
}
if expStr != v.String() {
t.Errorf("String() - expected [%s], actual[%s]", expStr, v.String())
}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal(): %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
var w snmpgo.Opaque
rest, err := (&w).Unmarshal(buf)
if len(rest) != 0 || err != nil {
t.Errorf("Unmarshal() - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() - expected [%s], actual [%s]", expStr, w.String())
}
buf = append(buf, 0x00)
rest, err = (&w).Unmarshal(buf)
if len(rest) != 1 || err != nil {
t.Errorf("Unmarshal() with rest - len[%d] err[%v]", len(rest), err)
}
if expStr != w.String() {
t.Errorf("Unmarshal() with rest - expected [%s], actual [%s]", expStr, w.String())
}
}
func TestVarBind(t *testing.T) {
var v snmpgo.VarBind
oid, _ := snmpgo.NewOid("1.3.6.1.2.1.1.1.0")
v = snmpgo.VarBind{Oid: oid}
v.Variable = snmpgo.NewInteger(-2147483648)
testVarBind(t, &v,
`{"Oid": "1.3.6.1.2.1.1.1.0", "Variable": {"Type": "Integer", "Value": "-2147483648"}}`)
v.Variable = snmpgo.NewOctetString([]byte("MyHost"))
testVarBind(t, &v,
`{"Oid": "1.3.6.1.2.1.1.1.0", "Variable": {"Type": "OctetString", "Value": "MyHost"}}`)
v.Variable = snmpgo.NewNull()
testVarBind(t, &v, `{"Oid": "1.3.6.1.2.1.1.1.0", "Variable": {"Type": "Null", "Value": ""}}`)
v.Variable = snmpgo.NewCounter32(uint32(4294967295))
testVarBind(t, &v,
`{"Oid": "1.3.6.1.2.1.1.1.0", "Variable": {"Type": "Counter32", "Value": "4294967295"}}`)
v.Variable = snmpgo.NewCounter64(uint64(18446744073709551615))
testVarBind(t, &v, `{"Oid": "1.3.6.1.2.1.1.1.0", `+
`"Variable": {"Type": "Counter64", "Value": "18446744073709551615"}}`)
expBuf := []byte{0x30, 0x00}
v = snmpgo.VarBind{}
buf, err := v.Marshal()
if err != nil {
t.Errorf("Marshal() : %v", err)
}
if !bytes.Equal(expBuf, buf) {
t.Errorf("Marshal() - expected [%s], actual [%s]",
snmpgo.ToHexStr(expBuf, " "), snmpgo.ToHexStr(buf, " "))
}
buf = []byte{0x00, 0x00}
_, err = (&v).Unmarshal(buf)
if err == nil {
t.Errorf("Unmarshal() : can not validation")
}
}