mirror of
https://github.com/restic/restic.git
synced 2024-08-26 22:27:22 +02:00
240 lines
5.1 KiB
Go
240 lines
5.1 KiB
Go
// 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)
|
|
}
|
|
}
|
|
}
|