| // Copyright 2016 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // +build darwin dragonfly freebsd netbsd openbsd |
| |
| package route |
| |
| import ( |
| "os" |
| "syscall" |
| "testing" |
| "time" |
| ) |
| |
| func TestFetchAndParseRIB(t *testing.T) { |
| for _, typ := range []RIBType{sysNET_RT_DUMP, sysNET_RT_IFLIST} { |
| var lastErr error |
| var ms []Message |
| for _, af := range []int{sysAF_UNSPEC, sysAF_INET, sysAF_INET6} { |
| rs, err := fetchAndParseRIB(af, typ) |
| if err != nil { |
| lastErr = err |
| continue |
| } |
| ms = append(ms, rs...) |
| } |
| if len(ms) == 0 && lastErr != nil { |
| t.Error(typ, lastErr) |
| continue |
| } |
| ss, err := msgs(ms).validate() |
| if err != nil { |
| t.Error(typ, err) |
| continue |
| } |
| for _, s := range ss { |
| t.Log(typ, s) |
| } |
| } |
| } |
| |
| var ( |
| rtmonSock int |
| rtmonErr error |
| ) |
| |
| func init() { |
| // We need to keep rtmonSock alive to avoid treading on |
| // recycled socket descriptors. |
| rtmonSock, rtmonErr = syscall.Socket(sysAF_ROUTE, sysSOCK_RAW, sysAF_UNSPEC) |
| } |
| |
| // TestMonitorAndParseRIB leaks a worker goroutine and a socket |
| // descriptor but that's intentional. |
| func TestMonitorAndParseRIB(t *testing.T) { |
| if testing.Short() || os.Getuid() != 0 { |
| t.Skip("must be root") |
| } |
| |
| if rtmonErr != nil { |
| t.Fatal(rtmonErr) |
| } |
| |
| // We suppose that using an IPv4 link-local address and the |
| // dot1Q ID for Token Ring and FDDI doesn't harm anyone. |
| pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"} |
| if err := pv.configure(1002); err != nil { |
| t.Skip(err) |
| } |
| if err := pv.setup(); err != nil { |
| t.Skip(err) |
| } |
| pv.teardown() |
| |
| go func() { |
| b := make([]byte, os.Getpagesize()) |
| for { |
| // There's no easy way to unblock this read |
| // call because the routing message exchange |
| // over routing socket is a connectionless |
| // message-oriented protocol, no control plane |
| // for signaling connectivity, and we cannot |
| // use the net package of standard library due |
| // to the lack of support for routing socket |
| // and circular dependency. |
| n, err := syscall.Read(rtmonSock, b) |
| if err != nil { |
| return |
| } |
| ms, err := ParseRIB(0, b[:n]) |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| ss, err := msgs(ms).validate() |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| for _, s := range ss { |
| t.Log(s) |
| } |
| } |
| }() |
| |
| for _, vid := range []int{1002, 1003, 1004, 1005} { |
| pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"} |
| if err := pv.configure(vid); err != nil { |
| t.Fatal(err) |
| } |
| if err := pv.setup(); err != nil { |
| t.Fatal(err) |
| } |
| time.Sleep(200 * time.Millisecond) |
| if err := pv.teardown(); err != nil { |
| t.Fatal(err) |
| } |
| time.Sleep(200 * time.Millisecond) |
| } |
| } |
| |
| func TestParseRIBWithFuzz(t *testing.T) { |
| for _, fuzz := range []string{ |
| "0\x00\x05\x050000000000000000" + |
| "00000000000000000000" + |
| "00000000000000000000" + |
| "00000000000000000000" + |
| "0000000000000\x02000000" + |
| "00000000", |
| "\x02\x00\x05\f0000000000000000" + |
| "0\x0200000000000000", |
| "\x02\x00\x05\x100000000000000\x1200" + |
| "0\x00\xff\x00", |
| "\x02\x00\x05\f0000000000000000" + |
| "0\x12000\x00\x02\x0000", |
| "\x00\x00\x00\x01\x00", |
| "00000", |
| } { |
| for typ := RIBType(0); typ < 256; typ++ { |
| ParseRIB(typ, []byte(fuzz)) |
| } |
| } |
| } |
| |
| func TestRouteMessage(t *testing.T) { |
| s, err := syscall.Socket(sysAF_ROUTE, sysSOCK_RAW, sysAF_UNSPEC) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer syscall.Close(s) |
| |
| var ms []RouteMessage |
| for _, af := range []int{sysAF_INET, sysAF_INET6} { |
| if _, err := fetchAndParseRIB(af, sysNET_RT_DUMP); err != nil { |
| t.Log(err) |
| continue |
| } |
| switch af { |
| case sysAF_INET: |
| ms = append(ms, []RouteMessage{ |
| { |
| Type: sysRTM_GET, |
| Addrs: []Addr{ |
| &Inet4Addr{IP: [4]byte{127, 0, 0, 1}}, |
| nil, |
| nil, |
| nil, |
| &LinkAddr{}, |
| &Inet4Addr{}, |
| nil, |
| &Inet4Addr{}, |
| }, |
| }, |
| { |
| Type: sysRTM_GET, |
| Addrs: []Addr{ |
| &Inet4Addr{IP: [4]byte{127, 0, 0, 1}}, |
| }, |
| }, |
| }...) |
| case sysAF_INET6: |
| ms = append(ms, []RouteMessage{ |
| { |
| Type: sysRTM_GET, |
| Addrs: []Addr{ |
| &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}}, |
| nil, |
| nil, |
| nil, |
| &LinkAddr{}, |
| &Inet6Addr{}, |
| nil, |
| &Inet6Addr{}, |
| }, |
| }, |
| { |
| Type: sysRTM_GET, |
| Addrs: []Addr{ |
| &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}}, |
| }, |
| }, |
| }...) |
| } |
| } |
| for i, m := range ms { |
| m.ID = uintptr(os.Getpid()) |
| m.Seq = i + 1 |
| wb, err := m.Marshal() |
| if err != nil { |
| t.Fatalf("%v: %v", m, err) |
| } |
| if _, err := syscall.Write(s, wb); err != nil { |
| t.Fatalf("%v: %v", m, err) |
| } |
| rb := make([]byte, os.Getpagesize()) |
| n, err := syscall.Read(s, rb) |
| if err != nil { |
| t.Fatalf("%v: %v", m, err) |
| } |
| rms, err := ParseRIB(0, rb[:n]) |
| if err != nil { |
| t.Fatalf("%v: %v", m, err) |
| } |
| for _, rm := range rms { |
| err := rm.(*RouteMessage).Err |
| if err != nil { |
| t.Errorf("%v: %v", m, err) |
| } |
| } |
| ss, err := msgs(rms).validate() |
| if err != nil { |
| t.Fatalf("%v: %v", m, err) |
| } |
| for _, s := range ss { |
| t.Log(s) |
| } |
| } |
| } |