1 // Copyright 2016 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // +build darwin dragonfly freebsd netbsd openbsd
16 func TestFetchAndParseRIB(t *testing.T) {
17 for _, typ := range []RIBType{sysNET_RT_DUMP, sysNET_RT_IFLIST} {
20 for _, af := range []int{sysAF_UNSPEC, sysAF_INET, sysAF_INET6} {
21 rs, err := fetchAndParseRIB(af, typ)
26 ms = append(ms, rs...)
28 if len(ms) == 0 && lastErr != nil {
32 ss, err := msgs(ms).validate()
37 for _, s := range ss {
49 // We need to keep rtmonSock alive to avoid treading on
50 // recycled socket descriptors.
51 rtmonSock, rtmonErr = syscall.Socket(sysAF_ROUTE, sysSOCK_RAW, sysAF_UNSPEC)
54 // TestMonitorAndParseRIB leaks a worker goroutine and a socket
55 // descriptor but that's intentional.
56 func TestMonitorAndParseRIB(t *testing.T) {
57 if testing.Short() || os.Getuid() != 0 {
58 t.Skip("must be root")
65 // We suppose that using an IPv4 link-local address and the
66 // dot1Q ID for Token Ring and FDDI doesn't harm anyone.
67 pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"}
68 if err := pv.configure(1002); err != nil {
71 if err := pv.setup(); err != nil {
77 b := make([]byte, os.Getpagesize())
79 // There's no easy way to unblock this read
80 // call because the routing message exchange
81 // over routing socket is a connectionless
82 // message-oriented protocol, no control plane
83 // for signaling connectivity, and we cannot
84 // use the net package of standard library due
85 // to the lack of support for routing socket
86 // and circular dependency.
87 n, err := syscall.Read(rtmonSock, b)
91 ms, err := ParseRIB(0, b[:n])
96 ss, err := msgs(ms).validate()
101 for _, s := range ss {
107 for _, vid := range []int{1002, 1003, 1004, 1005} {
108 pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"}
109 if err := pv.configure(vid); err != nil {
112 if err := pv.setup(); err != nil {
115 time.Sleep(200 * time.Millisecond)
116 if err := pv.teardown(); err != nil {
119 time.Sleep(200 * time.Millisecond)
123 func TestParseRIBWithFuzz(t *testing.T) {
124 for _, fuzz := range []string{
125 "0\x00\x05\x050000000000000000" +
126 "00000000000000000000" +
127 "00000000000000000000" +
128 "00000000000000000000" +
129 "0000000000000\x02000000" +
131 "\x02\x00\x05\f0000000000000000" +
132 "0\x0200000000000000",
133 "\x02\x00\x05\x100000000000000\x1200" +
135 "\x02\x00\x05\f0000000000000000" +
136 "0\x12000\x00\x02\x0000",
137 "\x00\x00\x00\x01\x00",
140 for typ := RIBType(0); typ < 256; typ++ {
141 ParseRIB(typ, []byte(fuzz))
146 func TestRouteMessage(t *testing.T) {
147 s, err := syscall.Socket(sysAF_ROUTE, sysSOCK_RAW, sysAF_UNSPEC)
151 defer syscall.Close(s)
153 var ms []RouteMessage
154 for _, af := range []int{sysAF_INET, sysAF_INET6} {
155 if _, err := fetchAndParseRIB(af, sysNET_RT_DUMP); err != nil {
161 ms = append(ms, []RouteMessage{
165 &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
178 &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
183 ms = append(ms, []RouteMessage{
187 &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
200 &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
206 for i, m := range ms {
207 m.ID = uintptr(os.Getpid())
209 wb, err := m.Marshal()
211 t.Fatalf("%v: %v", m, err)
213 if _, err := syscall.Write(s, wb); err != nil {
214 t.Fatalf("%v: %v", m, err)
216 rb := make([]byte, os.Getpagesize())
217 n, err := syscall.Read(s, rb)
219 t.Fatalf("%v: %v", m, err)
221 rms, err := ParseRIB(0, rb[:n])
223 t.Fatalf("%v: %v", m, err)
225 for _, rm := range rms {
226 err := rm.(*RouteMessage).Err
228 t.Errorf("%v: %v", m, err)
231 ss, err := msgs(rms).validate()
233 t.Fatalf("%v: %v", m, err)
235 for _, s := range ss {