gosnmp

1
// Copyright 2012 The GoSNMP Authors. All rights reserved.  Use of this
2
// source code is governed by a BSD-style license that can be found in the
3
// LICENSE file.
4

5
//go:build all || helper
6
// +build all helper
7

8
package gosnmp
9

10
import (
11
	"encoding/base64"
12
	"testing"
13

14
	"github.com/stretchr/testify/assert"
15
)
16

17
// https://www.scadacore.com/tools/programming-calculators/online-hex-converter/ is useful
18

19
func TestParseObjectIdentifier(t *testing.T) {
20
	oid := []byte{43, 6, 1, 2, 1, 31, 1, 1, 1, 10, 143, 255, 255, 255, 127}
21
	expected := ".1.3.6.1.2.1.31.1.1.1.10.4294967295"
22

23
	buf, err := parseObjectIdentifier(oid)
24
	if err != nil {
25
		t.Errorf("parseObjectIdentifier(%v) want %s, error: %v", oid, expected, err)
26
	}
27
	result := string(buf)
28

29
	if string(result) != expected {
30
		t.Errorf("parseObjectIdentifier(%v) = %s, want %s", oid, result, expected)
31
	}
32
}
33

34
func TestParseObjectIdentifierWithOtherOid(t *testing.T) {
35
	oid := []byte{43, 6, 3, 30, 11, 1, 10}
36
	expected := ".1.3.6.3.30.11.1.10"
37
	buf, err := parseObjectIdentifier(oid)
38
	if err != nil {
39
		t.Errorf("parseObjectIdentifier(%v) want %s, error: %v", oid, expected, err)
40
	}
41
	result := string(buf)
42
	if string(result) != expected {
43
		t.Errorf("parseObjectIdentifier(%v) = %s, want %s", oid, result, expected)
44
	}
45
}
46

47
func BenchmarkParseObjectIdentifier(b *testing.B) {
48
	oid := []byte{43, 6, 3, 30, 11, 1, 10}
49
	for i := 0; i < b.N; i++ {
50
		parseObjectIdentifier(oid)
51
	}
52
}
53

54
func BenchmarkMarshalObjectIdentifier(b *testing.B) {
55
	oid := ".1.3.6.3.30.11.1.10"
56
	for i := 0; i < b.N; i++ {
57
		marshalObjectIdentifier(oid)
58
	}
59
}
60

61
type testsMarshalUint32T struct {
62
	value     uint32
63
	goodBytes []byte
64
}
65

66
var testsMarshalUint32 = []testsMarshalUint32T{
67
	{0, []byte{0x00}},
68
	{2, []byte{0x02}}, // 2
69
	{128, []byte{0x00, 0x80}},
70
	{257, []byte{0x01, 0x01}},                  // FF + 2
71
	{65537, []byte{0x01, 0x00, 0x01}},          // FFFF + 2
72
	{16777217, []byte{0x01, 0x00, 0x00, 0x01}}, // FFFFFF + 2
73
	{18542501, []byte{0x01, 0x1a, 0xef, 0xa5}},
74
	{2147483647, []byte{0x7f, 0xff, 0xff, 0xff}},
75
	{2147483648, []byte{0x00, 0x80, 0x00, 0x0, 0x0}},
76
}
77

78
func TestMarshalUint32(t *testing.T) {
79
	for i, test := range testsMarshalUint32 {
80
		result, err := marshalUint32(test.value)
81
		if err != nil {
82
			t.Errorf("%d: expected %0x got err %v", i, test.goodBytes, err)
83
		}
84
		if !checkByteEquality2(test.goodBytes, result) {
85
			t.Errorf("%d: expected %0x got %0x", i, test.goodBytes, result)
86
		}
87
	}
88
}
89

90
var testsMarshalInt32 = []struct {
91
	value     int
92
	goodBytes []byte
93
}{
94
	{0, []byte{0x00}},
95
	{2, []byte{0x02}}, // 2
96
	{128, []byte{0x00, 0x80}},
97
	{257, []byte{0x01, 0x01}},                  // FF + 2
98
	{65537, []byte{0x01, 0x00, 0x01}},          // FFFF + 2
99
	{16777217, []byte{0x01, 0x00, 0x00, 0x01}}, // FFFFFF + 2
100
	{2147483647, []byte{0x7f, 0xff, 0xff, 0xff}},
101
	{-2147483648, []byte{0x80, 0x00, 0x00, 0x00}},
102
	{-16777217, []byte{0xfe, 0xff, 0xff, 0xff}},
103
	{-16777216, []byte{0xff, 0x00, 0x00, 0x00}},
104
	{-65537, []byte{0xfe, 0xff, 0xff}},
105
	{-65536, []byte{0xff, 0x00, 0x00}},
106
	{-257, []byte{0xfe, 0xff}},
107
	{-256, []byte{0xff, 0x00}},
108
	{-2, []byte{0xfe}},
109
	{-1, []byte{0xff}},
110
}
111

112
func TestMarshalInt32(t *testing.T) {
113
	for _, aTest := range testsMarshalInt32 {
114
		result, err := marshalInt32(aTest.value)
115
		assert.NoErrorf(t, err, "value %d", aTest.value)
116
		assert.EqualValues(t, aTest.goodBytes, result, "bad marshalInt32()")
117
	}
118
}
119

120
func TestParseUint64(t *testing.T) {
121
	tests := []struct {
122
		data []byte
123
		n    uint64
124
	}{
125
		{[]byte{}, 0},
126
		{[]byte{0x00}, 0},
127
		{[]byte{0x01}, 1},
128
		{[]byte{0x01, 0x01}, 257},
129
		{[]byte{0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1e, 0xb3, 0xbf}, 18446744073694786495},
130
	}
131
	for _, test := range tests {
132
		if ret, err := parseUint64(test.data); err != nil || ret != test.n {
133
			t.Errorf("parseUint64(%v) = %d, %v want %d, <nil>", test.data, ret, err, test.n)
134
		}
135
	}
136
}
137

138
var testsInvalidSNMPResponses = []string{
139
	"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",
140
	"MBoCAQEEB3ByaXZhdGWiDAIESESkywIBBQIBAA==",
141
	"MEo=",
142
}
143

144
func TestInvalidSNMPResponses(t *testing.T) {
145

146
	g := &GoSNMP{
147
		Target:    "127.0.0.1",
148
		Port:      161,
149
		Community: "public",
150
		Version:   Version2c,
151
	}
152

153
	for i, test := range testsInvalidSNMPResponses {
154
		testBytes, _ := base64.StdEncoding.DecodeString(test)
155
		result, err := g.SnmpDecodePacket(testBytes)
156
		if err == nil {
157
			t.Errorf("#%d, failed to error %v", i, result)
158
		}
159
	}
160
}
161

162
func checkByteEquality2(a, b []byte) bool {
163

164
	if a == nil && b == nil {
165
		return true
166
	}
167

168
	if a == nil || b == nil {
169
		return false
170
	}
171

172
	if len(a) != len(b) {
173
		return false
174
	}
175

176
	for i := range a {
177
		if a[i] != b[i] {
178
			return false
179
		}
180
	}
181

182
	return true
183
}
184