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
package netsnmp
6

7
import (
8
	"encoding/base64"
9
	"flag"
10
	"fmt"
11
	"math"
12
	"net"
13
	"os"
14
	"path/filepath"
15
	"testing"
16
	"time"
17

18
	"github.com/google/go-cmp/cmp"
19
	"github.com/google/gopacket"
20
	"github.com/google/gopacket/layers"
21
	"github.com/google/gopacket/pcapgo"
22
	"github.com/gosnmp/gosnmp"
23
)
24

25
var (
26
	rec  = flag.Bool("rec", false, "record and use net-snmp expected outputs, else use recorded values [if true requires libsnmp/cgo]. ")
27
	pcap = flag.String("pcap", "", "dir to put exp and got data as pcap files, no pcaps made if blank.")
28
)
29

30
func TestPDU(t *testing.T) {
31
	flag.Parse()
32

33
	if isPlayback() {
34
		t.Log("playback mode enabled")
35
	}
36

37
	recdir := filepath.Join("testdata", t.Name())
38
	if *rec && !isPlayback() {
39
		if err := os.MkdirAll(recdir, 0755); err != nil {
40
			t.Fatalf("error creating record dir: %s", err)
41
		}
42
	} else if *rec {
43
		t.Fatal("record mode requires `-tags netsnmp` and libsnmpd installed")
44
	}
45

46
	pcapdir := ""
47
	if *pcap != "" {
48
		pcapdir = filepath.Join(*pcap, t.Name())
49
		if err := os.MkdirAll(pcapdir, 0755); err != nil {
50
			t.Fatalf("error creating pcap dir: %s", err)
51
		}
52
	}
53

54
	tstpdus := []gosnmp.SnmpPDU{
55
		{
56
			Name:  ".1.3.6.1.2.1.1.7.0",
57
			Type:  gosnmp.Integer,
58
			Value: 104,
59
		},
60
		{
61
			Name:  ".1.3.6.1.2.1.2.2.1.10.1",
62
			Type:  gosnmp.Counter32,
63
			Value: uint32(271070065),
64
		},
65
		{
66
			Name:  ".1.3.6.1.2.1.2.2.1.5.1",
67
			Type:  gosnmp.Gauge32,
68
			Value: uint32(math.MaxUint32),
69
		},
70
		{
71
			Name:  ".1.3.6.1.2.1.1.4.0",
72
			Type:  gosnmp.OctetString,
73
			Value: []byte("Administrator"),
74
		},
75
		{
76
			Name:  ".1.3.6.1.2.1.4.21.1.1.127.0.0.1",
77
			Type:  gosnmp.IPAddress,
78
			Value: "127.0.0.1",
79
		},
80
		{
81
			Name:  ".1.3.6.1.4.1.6574.4.2.12.1.0",
82
			Type:  gosnmp.OpaqueFloat,
83
			Value: float32(10.0),
84
		},
85
		{
86
			Name:  ".1.3.6.1.4.1.6574.4.2.12.1.1",
87
			Type:  gosnmp.OpaqueFloat,
88
			Value: float32(0.0),
89
		},
90
		{
91
			Name:  ".1.3.6.1.4.1.6574.4.2.12.2.0",
92
			Type:  gosnmp.OpaqueDouble,
93
			Value: float64(10.0),
94
		},
95
		{
96
			Name:  ".1.3.6.1.4.1.6574.4.2.12.2.1",
97
			Type:  gosnmp.OpaqueDouble,
98
			Value: float64(0.0),
99
		},
100
		{
101
			Name:  ".1.3.6.1.2.1.2.2.1.10.1",
102
			Type:  gosnmp.Counter32,
103
			Value: uint32(271070065),
104
		},
105
		{
106
			Name:  ".1.3.6.1.2.1.1.3.0",
107
			Type:  gosnmp.TimeTicks,
108
			Value: uint32(318870100),
109
		},
110
		{
111
			Name:  ".1.3.6.1.2.1.1.3.1",
112
			Type:  gosnmp.Uinteger32,
113
			Value: uint32(math.MaxInt32),
114
		},
115
		{
116
			Name:  ".1.3.6.1.2.1.1.3.2",
117
			Type:  gosnmp.Counter64,
118
			Value: uint64(math.MaxInt64),
119
		},
120
	}
121
	sess := gosnmp.Default
122
	sess.Version = gosnmp.Version2c
123

124
	for i, tstpdu := range tstpdus {
125
		tname := fmt.Sprintf("test%d_PDU%s", i, tstpdu.Type.String())
126
		t.Run(tname, func(t *testing.T) {
127
			fname := filepath.Join(recdir, tname+"_pkt.b64")
128

129
			pdus := []gosnmp.SnmpPDU{tstpdu}
130
			pkt := sess.MkSnmpPacket(gosnmp.SetRequest, pdus, 0, 0)
131
			pkt.RequestID++
132

133
			exp, err := netSnmpPduPkt(fname, pdus[0], sess, pkt.RequestID, testing.Verbose())
134
			if err != nil {
135
				t.Fatal(err)
136
			}
137

138
			if *rec {
139
				pktrec := base64.StdEncoding.EncodeToString(exp)
140
				if err = os.WriteFile(fname, []byte(pktrec), 0600); err != nil {
141
					t.Logf("error writing record file: %s", err)
142
				}
143
			}
144

145
			got, err := pkt.MarshalMsg()
146
			if err != nil {
147
				t.Fatal(err)
148
			}
149

150
			if *pcap != "" {
151
				savePcap(t, filepath.Join(pcapdir, tname), exp, got)
152
			}
153

154
			if diff := cmp.Diff(exp, got); diff != "" {
155
				t.Fatalf("\ngot(%d): %q\nexp(%d): %q\ndiff:\n%s", len(got), got, len(exp), exp, diff)
156
			}
157
		})
158
	}
159
}
160

161
func writePcap(fn string, payload []byte) error {
162
	fn += ".pcap"
163

164
	f, err := os.OpenFile(fn, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
165
	if err != nil {
166
		return err
167
	}
168
	defer f.Close()
169

170
	l3 := &layers.IPv4{
171
		SrcIP:    net.ParseIP("192.168.2.1"),
172
		DstIP:    net.ParseIP("192.168.2.2"),
173
		Protocol: layers.IPProtocolUDP,
174
		Version:  4,
175
	}
176
	l4 := &layers.UDP{
177
		SrcPort: 161,
178
		DstPort: 161,
179
	}
180
	err = l4.SetNetworkLayerForChecksum(l3)
181
	if err != nil {
182
		return err
183
	}
184

185
	buf := gopacket.NewSerializeBuffer()
186
	err = gopacket.SerializeLayers(
187
		buf,
188
		gopacket.SerializeOptions{
189
			ComputeChecksums: true,
190
			FixLengths:       true,
191
		},
192
		l3,
193
		l4,
194
		gopacket.Payload(payload),
195
	)
196
	if err != nil {
197
		return err
198
	}
199

200
	pkt := gopacket.NewPacket(buf.Bytes(),
201
		layers.LinkTypeIPv4,
202
		gopacket.Default)
203

204
	w := pcapgo.NewWriter(f)
205
	err = w.WriteFileHeader(1600, layers.LinkTypeIPv4)
206
	if err != nil {
207
		return err
208
	}
209

210
	err = w.WritePacket(gopacket.CaptureInfo{
211
		Timestamp:     time.Now(),
212
		CaptureLength: len(pkt.Data()),
213
		Length:        len(pkt.Data()),
214
	}, pkt.Data())
215
	if err != nil {
216
		return err
217
	}
218

219
	return nil
220
}
221

222
func savePcap(t *testing.T, fp string, exp, got []byte) {
223
	err := writePcap(fp+"_exp", exp)
224
	if err != nil {
225
		t.Logf("error saving exp pcap: %s", err.Error())
226
	}
227
	err = writePcap(fp+"_got", got)
228
	if err != nil {
229
		t.Logf("error saving got pcap: %s", err.Error())
230
	}
231
}
232