From a33c5aa5df48775143ad831b69ca656cd7adcca8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 4 Aug 2022 18:22:33 -0700
Subject: [PATCH] route: import syscall rather than golang.org/x/sys/unix

It happens that everything we need is already defined in syscall.
This avoids problems when this package is vendored into the
standard library.

For golang/go#54259

Change-Id: I86bfe44f20c9db2ecfdb8dbb2ef798391da2bfa6
Reviewed-on: https://go-review.googlesource.com/c/net/+/421425
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Ian Lance Taylor <iant@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
---
 route/address.go              | 35 ++++++++++----------
 route/address_darwin_test.go  |  5 ++-
 route/address_test.go         |  7 ++--
 route/interface_classic.go    |  9 +++--
 route/interface_freebsd.go    | 12 +++----
 route/interface_openbsd.go    |  8 ++---
 route/message_darwin_test.go  |  7 ++--
 route/message_freebsd_test.go | 15 ++++-----
 route/message_test.go         | 62 +++++++++++++++++------------------
 route/route.go                |  4 +--
 route/route_openbsd.go        |  4 +--
 route/route_test.go           | 25 +++++++-------
 route/sys.go                  |  5 ++-
 route/sys_darwin.go           | 38 ++++++++++-----------
 route/sys_dragonfly.go        | 32 +++++++++---------
 route/sys_freebsd.go          | 32 +++++++++---------
 route/sys_netbsd.go           | 28 ++++++++--------
 route/sys_openbsd.go          | 31 +++++++++---------
 18 files changed, 170 insertions(+), 189 deletions(-)

diff --git a/route/address.go b/route/address.go
index 930bdffb2e..5a3cc06549 100644
--- a/route/address.go
+++ b/route/address.go
@@ -9,8 +9,7 @@ package route
 
 import (
 	"runtime"
-
-	"golang.org/x/sys/unix"
+	"syscall"
 )
 
 // An Addr represents an address associated with packet routing.
@@ -27,7 +26,7 @@ type LinkAddr struct {
 }
 
 // Family implements the Family method of Addr interface.
-func (a *LinkAddr) Family() int { return unix.AF_LINK }
+func (a *LinkAddr) Family() int { return syscall.AF_LINK }
 
 func (a *LinkAddr) lenAndSpace() (int, int) {
 	l := 8 + len(a.Name) + len(a.Addr)
@@ -44,7 +43,7 @@ func (a *LinkAddr) marshal(b []byte) (int, error) {
 		return 0, errInvalidAddr
 	}
 	b[0] = byte(l)
-	b[1] = unix.AF_LINK
+	b[1] = syscall.AF_LINK
 	if a.Index > 0 {
 		nativeEndian.PutUint16(b[2:4], uint16(a.Index))
 	}
@@ -66,7 +65,7 @@ func parseLinkAddr(b []byte) (Addr, error) {
 	if len(b) < 8 {
 		return nil, errInvalidAddr
 	}
-	_, a, err := parseKernelLinkAddr(unix.AF_LINK, b[4:])
+	_, a, err := parseKernelLinkAddr(syscall.AF_LINK, b[4:])
 	if err != nil {
 		return nil, err
 	}
@@ -126,7 +125,7 @@ type Inet4Addr struct {
 }
 
 // Family implements the Family method of Addr interface.
-func (a *Inet4Addr) Family() int { return unix.AF_INET }
+func (a *Inet4Addr) Family() int { return syscall.AF_INET }
 
 func (a *Inet4Addr) lenAndSpace() (int, int) {
 	return sizeofSockaddrInet, roundup(sizeofSockaddrInet)
@@ -138,7 +137,7 @@ func (a *Inet4Addr) marshal(b []byte) (int, error) {
 		return 0, errShortBuffer
 	}
 	b[0] = byte(l)
-	b[1] = unix.AF_INET
+	b[1] = syscall.AF_INET
 	copy(b[4:8], a.IP[:])
 	return ll, nil
 }
@@ -150,7 +149,7 @@ type Inet6Addr struct {
 }
 
 // Family implements the Family method of Addr interface.
-func (a *Inet6Addr) Family() int { return unix.AF_INET6 }
+func (a *Inet6Addr) Family() int { return syscall.AF_INET6 }
 
 func (a *Inet6Addr) lenAndSpace() (int, int) {
 	return sizeofSockaddrInet6, roundup(sizeofSockaddrInet6)
@@ -162,7 +161,7 @@ func (a *Inet6Addr) marshal(b []byte) (int, error) {
 		return 0, errShortBuffer
 	}
 	b[0] = byte(l)
-	b[1] = unix.AF_INET6
+	b[1] = syscall.AF_INET6
 	copy(b[8:24], a.IP[:])
 	if a.ZoneID > 0 {
 		nativeEndian.PutUint32(b[24:28], uint32(a.ZoneID))
@@ -173,14 +172,14 @@ func (a *Inet6Addr) marshal(b []byte) (int, error) {
 // parseInetAddr parses b as an internet address for IPv4 or IPv6.
 func parseInetAddr(af int, b []byte) (Addr, error) {
 	switch af {
-	case unix.AF_INET:
+	case syscall.AF_INET:
 		if len(b) < sizeofSockaddrInet {
 			return nil, errInvalidAddr
 		}
 		a := &Inet4Addr{}
 		copy(a.IP[:], b[4:8])
 		return a, nil
-	case unix.AF_INET6:
+	case syscall.AF_INET6:
 		if len(b) < sizeofSockaddrInet6 {
 			return nil, errInvalidAddr
 		}
@@ -249,7 +248,7 @@ func parseKernelInetAddr(af int, b []byte) (int, Addr, error) {
 		a := &Inet6Addr{}
 		copy(a.IP[:], b[off6:off6+16])
 		return int(b[0]), a, nil
-	case af == unix.AF_INET6:
+	case af == syscall.AF_INET6:
 		a := &Inet6Addr{}
 		if l-1 < off6 {
 			copy(a.IP[:], b[1:l])
@@ -369,15 +368,15 @@ func marshalAddrs(b []byte, as []Addr) (uint, error) {
 }
 
 func parseAddrs(attrs uint, fn func(int, []byte) (int, Addr, error), b []byte) ([]Addr, error) {
-	var as [unix.RTAX_MAX]Addr
-	af := int(unix.AF_UNSPEC)
-	for i := uint(0); i < unix.RTAX_MAX && len(b) >= roundup(0); i++ {
+	var as [syscall.RTAX_MAX]Addr
+	af := int(syscall.AF_UNSPEC)
+	for i := uint(0); i < syscall.RTAX_MAX && len(b) >= roundup(0); i++ {
 		if attrs&(1<<i) == 0 {
 			continue
 		}
-		if i <= unix.RTAX_BRD {
+		if i <= syscall.RTAX_BRD {
 			switch b[1] {
-			case unix.AF_LINK:
+			case syscall.AF_LINK:
 				a, err := parseLinkAddr(b)
 				if err != nil {
 					return nil, err
@@ -388,7 +387,7 @@ func parseAddrs(attrs uint, fn func(int, []byte) (int, Addr, error), b []byte) (
 					return nil, errMessageTooShort
 				}
 				b = b[l:]
-			case unix.AF_INET, unix.AF_INET6:
+			case syscall.AF_INET, syscall.AF_INET6:
 				af = int(b[1])
 				a, err := parseInetAddr(af, b)
 				if err != nil {
diff --git a/route/address_darwin_test.go b/route/address_darwin_test.go
index d367e96ffd..b819183a78 100644
--- a/route/address_darwin_test.go
+++ b/route/address_darwin_test.go
@@ -6,9 +6,8 @@ package route
 
 import (
 	"reflect"
+	"syscall"
 	"testing"
-
-	"golang.org/x/sys/unix"
 )
 
 type parseAddrsOnDarwinTest struct {
@@ -20,7 +19,7 @@ type parseAddrsOnDarwinTest struct {
 
 var parseAddrsOnDarwinLittleEndianTests = []parseAddrsOnDarwinTest{
 	{
-		unix.RTA_DST | unix.RTA_GATEWAY | unix.RTA_NETMASK,
+		syscall.RTA_DST | syscall.RTA_GATEWAY | syscall.RTA_NETMASK,
 		parseKernelInetAddr,
 		[]byte{
 			0x10, 0x2, 0x0, 0x0, 0xc0, 0xa8, 0x56, 0x0,
diff --git a/route/address_test.go b/route/address_test.go
index fbc5838993..bd7db4a1f7 100644
--- a/route/address_test.go
+++ b/route/address_test.go
@@ -9,9 +9,8 @@ package route
 
 import (
 	"reflect"
+	"syscall"
 	"testing"
-
-	"golang.org/x/sys/unix"
 )
 
 type parseAddrsTest struct {
@@ -23,7 +22,7 @@ type parseAddrsTest struct {
 
 var parseAddrsLittleEndianTests = []parseAddrsTest{
 	{
-		unix.RTA_DST | unix.RTA_GATEWAY | unix.RTA_NETMASK | unix.RTA_BRD,
+		syscall.RTA_DST | syscall.RTA_GATEWAY | syscall.RTA_NETMASK | syscall.RTA_BRD,
 		parseKernelInetAddr,
 		[]byte{
 			0x38, 0x12, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0,
@@ -60,7 +59,7 @@ var parseAddrsLittleEndianTests = []parseAddrsTest{
 		},
 	},
 	{
-		unix.RTA_NETMASK | unix.RTA_IFP | unix.RTA_IFA,
+		syscall.RTA_NETMASK | syscall.RTA_IFP | syscall.RTA_IFA,
 		parseKernelInetAddr,
 		[]byte{
 			0x7, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0,
diff --git a/route/interface_classic.go b/route/interface_classic.go
index d1d8284a8f..903a196346 100644
--- a/route/interface_classic.go
+++ b/route/interface_classic.go
@@ -9,8 +9,7 @@ package route
 
 import (
 	"runtime"
-
-	"golang.org/x/sys/unix"
+	"syscall"
 )
 
 func (w *wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
@@ -22,13 +21,13 @@ func (w *wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error)
 		return nil, errInvalidMessage
 	}
 	attrs := uint(nativeEndian.Uint32(b[4:8]))
-	if attrs&unix.RTA_IFP == 0 {
+	if attrs&syscall.RTA_IFP == 0 {
 		return nil, nil
 	}
 	m := &InterfaceMessage{
 		Version: int(b[2]),
 		Type:    int(b[3]),
-		Addrs:   make([]Addr, unix.RTAX_MAX),
+		Addrs:   make([]Addr, syscall.RTAX_MAX),
 		Flags:   int(nativeEndian.Uint32(b[8:12])),
 		Index:   int(nativeEndian.Uint16(b[12:14])),
 		extOff:  w.extOff,
@@ -38,7 +37,7 @@ func (w *wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error)
 	if err != nil {
 		return nil, err
 	}
-	m.Addrs[unix.RTAX_IFP] = a
+	m.Addrs[syscall.RTAX_IFP] = a
 	m.Name = a.(*LinkAddr).Name
 	return m, nil
 }
diff --git a/route/interface_freebsd.go b/route/interface_freebsd.go
index 7e90b17d33..14d251c94f 100644
--- a/route/interface_freebsd.go
+++ b/route/interface_freebsd.go
@@ -4,11 +4,11 @@
 
 package route
 
-import "golang.org/x/sys/unix"
+import "syscall"
 
 func (w *wireFormat) parseInterfaceMessage(typ RIBType, b []byte) (Message, error) {
 	var extOff, bodyOff int
-	if typ == unix.NET_RT_IFLISTL {
+	if typ == syscall.NET_RT_IFLISTL {
 		if len(b) < 20 {
 			return nil, errMessageTooShort
 		}
@@ -26,7 +26,7 @@ func (w *wireFormat) parseInterfaceMessage(typ RIBType, b []byte) (Message, erro
 		return nil, errInvalidMessage
 	}
 	attrs := uint(nativeEndian.Uint32(b[4:8]))
-	if attrs&unix.RTA_IFP == 0 {
+	if attrs&syscall.RTA_IFP == 0 {
 		return nil, nil
 	}
 	m := &InterfaceMessage{
@@ -34,7 +34,7 @@ func (w *wireFormat) parseInterfaceMessage(typ RIBType, b []byte) (Message, erro
 		Type:    int(b[3]),
 		Flags:   int(nativeEndian.Uint32(b[8:12])),
 		Index:   int(nativeEndian.Uint16(b[12:14])),
-		Addrs:   make([]Addr, unix.RTAX_MAX),
+		Addrs:   make([]Addr, syscall.RTAX_MAX),
 		extOff:  extOff,
 		raw:     b[:l],
 	}
@@ -42,14 +42,14 @@ func (w *wireFormat) parseInterfaceMessage(typ RIBType, b []byte) (Message, erro
 	if err != nil {
 		return nil, err
 	}
-	m.Addrs[unix.RTAX_IFP] = a
+	m.Addrs[syscall.RTAX_IFP] = a
 	m.Name = a.(*LinkAddr).Name
 	return m, nil
 }
 
 func (w *wireFormat) parseInterfaceAddrMessage(typ RIBType, b []byte) (Message, error) {
 	var bodyOff int
-	if typ == unix.NET_RT_IFLISTL {
+	if typ == syscall.NET_RT_IFLISTL {
 		if len(b) < 24 {
 			return nil, errMessageTooShort
 		}
diff --git a/route/interface_openbsd.go b/route/interface_openbsd.go
index fe003e39de..d369409a72 100644
--- a/route/interface_openbsd.go
+++ b/route/interface_openbsd.go
@@ -4,7 +4,7 @@
 
 package route
 
-import "golang.org/x/sys/unix"
+import "syscall"
 
 func (*wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
 	if len(b) < 32 {
@@ -15,7 +15,7 @@ func (*wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
 		return nil, errInvalidMessage
 	}
 	attrs := uint(nativeEndian.Uint32(b[12:16]))
-	if attrs&unix.RTA_IFP == 0 {
+	if attrs&syscall.RTA_IFP == 0 {
 		return nil, nil
 	}
 	m := &InterfaceMessage{
@@ -23,7 +23,7 @@ func (*wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
 		Type:    int(b[3]),
 		Flags:   int(nativeEndian.Uint32(b[16:20])),
 		Index:   int(nativeEndian.Uint16(b[6:8])),
-		Addrs:   make([]Addr, unix.RTAX_MAX),
+		Addrs:   make([]Addr, syscall.RTAX_MAX),
 		raw:     b[:l],
 	}
 	ll := int(nativeEndian.Uint16(b[4:6]))
@@ -34,7 +34,7 @@ func (*wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
 	if err != nil {
 		return nil, err
 	}
-	m.Addrs[unix.RTAX_IFP] = a
+	m.Addrs[syscall.RTAX_IFP] = a
 	m.Name = a.(*LinkAddr).Name
 	return m, nil
 }
diff --git a/route/message_darwin_test.go b/route/message_darwin_test.go
index debe2e6b42..7d6a3c75e8 100644
--- a/route/message_darwin_test.go
+++ b/route/message_darwin_test.go
@@ -5,16 +5,15 @@
 package route
 
 import (
+	"syscall"
 	"testing"
-
-	"golang.org/x/sys/unix"
 )
 
 func TestFetchAndParseRIBOnDarwin(t *testing.T) {
-	for _, typ := range []RIBType{unix.NET_RT_FLAGS, unix.NET_RT_DUMP2, unix.NET_RT_IFLIST2} {
+	for _, typ := range []RIBType{syscall.NET_RT_FLAGS, syscall.NET_RT_DUMP2, syscall.NET_RT_IFLIST2} {
 		var lastErr error
 		var ms []Message
-		for _, af := range []int{unix.AF_UNSPEC, unix.AF_INET, unix.AF_INET6} {
+		for _, af := range []int{syscall.AF_UNSPEC, syscall.AF_INET, syscall.AF_INET6} {
 			rs, err := fetchAndParseRIB(af, typ)
 			if err != nil {
 				lastErr = err
diff --git a/route/message_freebsd_test.go b/route/message_freebsd_test.go
index 9f899c6991..62677c1e30 100644
--- a/route/message_freebsd_test.go
+++ b/route/message_freebsd_test.go
@@ -5,16 +5,15 @@
 package route
 
 import (
+	"syscall"
 	"testing"
-
-	"golang.org/x/sys/unix"
 )
 
 func TestFetchAndParseRIBOnFreeBSD(t *testing.T) {
-	for _, typ := range []RIBType{unix.NET_RT_IFMALIST} {
+	for _, typ := range []RIBType{syscall.NET_RT_IFMALIST} {
 		var lastErr error
 		var ms []Message
-		for _, af := range []int{unix.AF_UNSPEC, unix.AF_INET, unix.AF_INET6} {
+		for _, af := range []int{syscall.AF_UNSPEC, syscall.AF_INET, syscall.AF_INET6} {
 			rs, err := fetchAndParseRIB(af, typ)
 			if err != nil {
 				lastErr = err
@@ -38,7 +37,7 @@ func TestFetchAndParseRIBOnFreeBSD(t *testing.T) {
 }
 
 func TestFetchAndParseRIBOnFreeBSD10AndAbove(t *testing.T) {
-	if _, err := FetchRIB(unix.AF_UNSPEC, unix.NET_RT_IFLISTL, 0); err != nil {
+	if _, err := FetchRIB(syscall.AF_UNSPEC, syscall.NET_RT_IFLISTL, 0); err != nil {
 		t.Skip("NET_RT_IFLISTL not supported")
 	}
 	if compatFreeBSD32 {
@@ -51,12 +50,12 @@ func TestFetchAndParseRIBOnFreeBSD10AndAbove(t *testing.T) {
 		msgs []Message
 		ss   []string
 	}{
-		{typ: unix.NET_RT_IFLIST},
-		{typ: unix.NET_RT_IFLISTL},
+		{typ: syscall.NET_RT_IFLIST},
+		{typ: syscall.NET_RT_IFLISTL},
 	}
 	for i := range tests {
 		var lastErr error
-		for _, af := range []int{unix.AF_UNSPEC, unix.AF_INET, unix.AF_INET6} {
+		for _, af := range []int{syscall.AF_UNSPEC, syscall.AF_INET, syscall.AF_INET6} {
 			rs, err := fetchAndParseRIB(af, tests[i].typ)
 			if err != nil {
 				lastErr = err
diff --git a/route/message_test.go b/route/message_test.go
index 702d15a180..61927d62c0 100644
--- a/route/message_test.go
+++ b/route/message_test.go
@@ -12,15 +12,13 @@ import (
 	"syscall"
 	"testing"
 	"time"
-
-	"golang.org/x/sys/unix"
 )
 
 func TestFetchAndParseRIB(t *testing.T) {
-	for _, typ := range []RIBType{unix.NET_RT_DUMP, unix.NET_RT_IFLIST} {
+	for _, typ := range []RIBType{syscall.NET_RT_DUMP, syscall.NET_RT_IFLIST} {
 		var lastErr error
 		var ms []Message
-		for _, af := range []int{unix.AF_UNSPEC, unix.AF_INET, unix.AF_INET6} {
+		for _, af := range []int{syscall.AF_UNSPEC, syscall.AF_INET, syscall.AF_INET6} {
 			rs, err := fetchAndParseRIB(af, typ)
 			if err != nil {
 				lastErr = err
@@ -51,7 +49,7 @@ var (
 func init() {
 	// We need to keep rtmonSock alive to avoid treading on
 	// recycled socket descriptors.
-	rtmonSock, rtmonErr = syscall.Socket(unix.AF_ROUTE, unix.SOCK_RAW, unix.AF_UNSPEC)
+	rtmonSock, rtmonErr = syscall.Socket(syscall.AF_ROUTE, syscall.SOCK_RAW, syscall.AF_UNSPEC)
 }
 
 // TestMonitorAndParseRIB leaks a worker goroutine and a socket
@@ -147,60 +145,60 @@ func TestParseRIBWithFuzz(t *testing.T) {
 }
 
 func TestRouteMessage(t *testing.T) {
-	s, err := syscall.Socket(unix.AF_ROUTE, unix.SOCK_RAW, unix.AF_UNSPEC)
+	s, err := syscall.Socket(syscall.AF_ROUTE, syscall.SOCK_RAW, syscall.AF_UNSPEC)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer syscall.Close(s)
 
 	var ms []RouteMessage
-	for _, af := range []int{unix.AF_INET, unix.AF_INET6} {
-		if _, err := fetchAndParseRIB(af, unix.NET_RT_DUMP); err != nil {
+	for _, af := range []int{syscall.AF_INET, syscall.AF_INET6} {
+		if _, err := fetchAndParseRIB(af, syscall.NET_RT_DUMP); err != nil {
 			t.Log(err)
 			continue
 		}
 		switch af {
-		case unix.AF_INET:
+		case syscall.AF_INET:
 			ms = append(ms, []RouteMessage{
 				{
-					Type: unix.RTM_GET,
+					Type: syscall.RTM_GET,
 					Addrs: []Addr{
-						unix.RTAX_DST:     &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
-						unix.RTAX_GATEWAY: nil,
-						unix.RTAX_NETMASK: nil,
-						unix.RTAX_GENMASK: nil,
-						unix.RTAX_IFP:     &LinkAddr{},
-						unix.RTAX_IFA:     &Inet4Addr{},
-						unix.RTAX_AUTHOR:  nil,
-						unix.RTAX_BRD:     &Inet4Addr{},
+						syscall.RTAX_DST:     &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
+						syscall.RTAX_GATEWAY: nil,
+						syscall.RTAX_NETMASK: nil,
+						syscall.RTAX_GENMASK: nil,
+						syscall.RTAX_IFP:     &LinkAddr{},
+						syscall.RTAX_IFA:     &Inet4Addr{},
+						syscall.RTAX_AUTHOR:  nil,
+						syscall.RTAX_BRD:     &Inet4Addr{},
 					},
 				},
 				{
-					Type: unix.RTM_GET,
+					Type: syscall.RTM_GET,
 					Addrs: []Addr{
-						unix.RTAX_DST: &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
+						syscall.RTAX_DST: &Inet4Addr{IP: [4]byte{127, 0, 0, 1}},
 					},
 				},
 			}...)
-		case unix.AF_INET6:
+		case syscall.AF_INET6:
 			ms = append(ms, []RouteMessage{
 				{
-					Type: unix.RTM_GET,
+					Type: syscall.RTM_GET,
 					Addrs: []Addr{
-						unix.RTAX_DST:     &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
-						unix.RTAX_GATEWAY: nil,
-						unix.RTAX_NETMASK: nil,
-						unix.RTAX_GENMASK: nil,
-						unix.RTAX_IFP:     &LinkAddr{},
-						unix.RTAX_IFA:     &Inet6Addr{},
-						unix.RTAX_AUTHOR:  nil,
-						unix.RTAX_BRD:     &Inet6Addr{},
+						syscall.RTAX_DST:     &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+						syscall.RTAX_GATEWAY: nil,
+						syscall.RTAX_NETMASK: nil,
+						syscall.RTAX_GENMASK: nil,
+						syscall.RTAX_IFP:     &LinkAddr{},
+						syscall.RTAX_IFA:     &Inet6Addr{},
+						syscall.RTAX_AUTHOR:  nil,
+						syscall.RTAX_BRD:     &Inet6Addr{},
 					},
 				},
 				{
-					Type: unix.RTM_GET,
+					Type: syscall.RTM_GET,
 					Addrs: []Addr{
-						unix.RTAX_DST: &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+						syscall.RTAX_DST: &Inet6Addr{IP: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
 					},
 				},
 			}...)
diff --git a/route/route.go b/route/route.go
index b99cb8f8e8..3ab5bcdc01 100644
--- a/route/route.go
+++ b/route/route.go
@@ -17,8 +17,6 @@ import (
 	"errors"
 	"os"
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )
 
 var (
@@ -113,7 +111,7 @@ func FetchRIB(af int, typ RIBType, arg int) ([]byte, error) {
 	try := 0
 	for {
 		try++
-		mib := [6]int32{unix.CTL_NET, unix.AF_ROUTE, 0, int32(af), int32(typ), int32(arg)}
+		mib := [6]int32{syscall.CTL_NET, syscall.AF_ROUTE, 0, int32(af), int32(typ), int32(arg)}
 		n := uintptr(0)
 		if err := sysctl(mib[:], nil, &n, nil, 0); err != nil {
 			return nil, os.NewSyscallError("sysctl", err)
diff --git a/route/route_openbsd.go b/route/route_openbsd.go
index e834fd001b..f848fb1f24 100644
--- a/route/route_openbsd.go
+++ b/route/route_openbsd.go
@@ -6,8 +6,6 @@ package route
 
 import (
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )
 
 func (m *RouteMessage) marshal() ([]byte, error) {
@@ -15,7 +13,7 @@ func (m *RouteMessage) marshal() ([]byte, error) {
 	b := make([]byte, l)
 	nativeEndian.PutUint16(b[:2], uint16(l))
 	if m.Version == 0 {
-		b[2] = unix.RTM_VERSION
+		b[2] = syscall.RTM_VERSION
 	} else {
 		b[2] = byte(m.Version)
 	}
diff --git a/route/route_test.go b/route/route_test.go
index 7ade140234..55c8f23727 100644
--- a/route/route_test.go
+++ b/route/route_test.go
@@ -11,8 +11,7 @@ import (
 	"fmt"
 	"os/exec"
 	"runtime"
-
-	"golang.org/x/sys/unix"
+	"syscall"
 )
 
 func (m *RouteMessage) String() string {
@@ -178,13 +177,13 @@ type addrFamily int
 
 func (af addrFamily) String() string {
 	switch af {
-	case unix.AF_UNSPEC:
+	case syscall.AF_UNSPEC:
 		return "unspec"
-	case unix.AF_LINK:
+	case syscall.AF_LINK:
 		return "link"
-	case unix.AF_INET:
+	case syscall.AF_INET:
 		return "inet4"
-	case unix.AF_INET6:
+	case syscall.AF_INET6:
 		return "inet6"
 	default:
 		return fmt.Sprintf("%d", af)
@@ -283,24 +282,24 @@ func (as addrs) String() string {
 
 func (as addrs) match(attrs addrAttrs) error {
 	var ts addrAttrs
-	af := unix.AF_UNSPEC
+	af := syscall.AF_UNSPEC
 	for i := range as {
 		if as[i] != nil {
 			ts |= 1 << uint(i)
 		}
 		switch as[i].(type) {
 		case *Inet4Addr:
-			if af == unix.AF_UNSPEC {
-				af = unix.AF_INET
+			if af == syscall.AF_UNSPEC {
+				af = syscall.AF_INET
 			}
-			if af != unix.AF_INET {
+			if af != syscall.AF_INET {
 				return fmt.Errorf("got %v; want %v", addrs(as), addrFamily(af))
 			}
 		case *Inet6Addr:
-			if af == unix.AF_UNSPEC {
-				af = unix.AF_INET6
+			if af == syscall.AF_UNSPEC {
+				af = syscall.AF_INET6
 			}
-			if af != unix.AF_INET6 {
+			if af != syscall.AF_INET6 {
 				return fmt.Errorf("got %v; want %v", addrs(as), addrFamily(af))
 			}
 		}
diff --git a/route/sys.go b/route/sys.go
index 03e727a6ab..7c75574f18 100644
--- a/route/sys.go
+++ b/route/sys.go
@@ -8,9 +8,8 @@
 package route
 
 import (
+	"syscall"
 	"unsafe"
-
-	"golang.org/x/sys/unix"
 )
 
 var (
@@ -29,7 +28,7 @@ func init() {
 		nativeEndian = bigEndian
 	}
 	// might get overridden in probeRoutingStack
-	rtmVersion = unix.RTM_VERSION
+	rtmVersion = syscall.RTM_VERSION
 	kernelAlign, wireFormats = probeRoutingStack()
 }
 
diff --git a/route/sys_darwin.go b/route/sys_darwin.go
index b79d94a88a..c8c4eecb8e 100644
--- a/route/sys_darwin.go
+++ b/route/sys_darwin.go
@@ -4,11 +4,11 @@
 
 package route
 
-import "golang.org/x/sys/unix"
+import "syscall"
 
 func (typ RIBType) parseable() bool {
 	switch typ {
-	case unix.NET_RT_STAT, unix.NET_RT_TRASH:
+	case syscall.NET_RT_STAT, syscall.NET_RT_TRASH:
 		return false
 	default:
 		return true
@@ -68,22 +68,22 @@ func probeRoutingStack() (int, map[int]*wireFormat) {
 	ifmam2.parse = ifmam2.parseInterfaceMulticastAddrMessage
 	// Darwin kernels require 32-bit aligned access to routing facilities.
 	return 4, map[int]*wireFormat{
-		unix.RTM_ADD:       rtm,
-		unix.RTM_DELETE:    rtm,
-		unix.RTM_CHANGE:    rtm,
-		unix.RTM_GET:       rtm,
-		unix.RTM_LOSING:    rtm,
-		unix.RTM_REDIRECT:  rtm,
-		unix.RTM_MISS:      rtm,
-		unix.RTM_LOCK:      rtm,
-		unix.RTM_RESOLVE:   rtm,
-		unix.RTM_NEWADDR:   ifam,
-		unix.RTM_DELADDR:   ifam,
-		unix.RTM_IFINFO:    ifm,
-		unix.RTM_NEWMADDR:  ifmam,
-		unix.RTM_DELMADDR:  ifmam,
-		unix.RTM_IFINFO2:   ifm2,
-		unix.RTM_NEWMADDR2: ifmam2,
-		unix.RTM_GET2:      rtm2,
+		syscall.RTM_ADD:       rtm,
+		syscall.RTM_DELETE:    rtm,
+		syscall.RTM_CHANGE:    rtm,
+		syscall.RTM_GET:       rtm,
+		syscall.RTM_LOSING:    rtm,
+		syscall.RTM_REDIRECT:  rtm,
+		syscall.RTM_MISS:      rtm,
+		syscall.RTM_LOCK:      rtm,
+		syscall.RTM_RESOLVE:   rtm,
+		syscall.RTM_NEWADDR:   ifam,
+		syscall.RTM_DELADDR:   ifam,
+		syscall.RTM_IFINFO:    ifm,
+		syscall.RTM_NEWMADDR:  ifmam,
+		syscall.RTM_DELMADDR:  ifmam,
+		syscall.RTM_IFINFO2:   ifm2,
+		syscall.RTM_NEWMADDR2: ifmam2,
+		syscall.RTM_GET2:      rtm2,
 	}
 }
diff --git a/route/sys_dragonfly.go b/route/sys_dragonfly.go
index db53402df7..577fb16eb4 100644
--- a/route/sys_dragonfly.go
+++ b/route/sys_dragonfly.go
@@ -7,8 +7,6 @@ package route
 import (
 	"syscall"
 	"unsafe"
-
-	"golang.org/x/sys/unix"
 )
 
 func (typ RIBType) parseable() bool { return true }
@@ -71,20 +69,20 @@ func probeRoutingStack() (int, map[int]*wireFormat) {
 	}
 
 	return int(unsafe.Sizeof(p)), map[int]*wireFormat{
-		unix.RTM_ADD:        rtm,
-		unix.RTM_DELETE:     rtm,
-		unix.RTM_CHANGE:     rtm,
-		unix.RTM_GET:        rtm,
-		unix.RTM_LOSING:     rtm,
-		unix.RTM_REDIRECT:   rtm,
-		unix.RTM_MISS:       rtm,
-		unix.RTM_LOCK:       rtm,
-		unix.RTM_RESOLVE:    rtm,
-		unix.RTM_NEWADDR:    ifam,
-		unix.RTM_DELADDR:    ifam,
-		unix.RTM_IFINFO:     ifm,
-		unix.RTM_NEWMADDR:   ifmam,
-		unix.RTM_DELMADDR:   ifmam,
-		unix.RTM_IFANNOUNCE: ifanm,
+		syscall.RTM_ADD:        rtm,
+		syscall.RTM_DELETE:     rtm,
+		syscall.RTM_CHANGE:     rtm,
+		syscall.RTM_GET:        rtm,
+		syscall.RTM_LOSING:     rtm,
+		syscall.RTM_REDIRECT:   rtm,
+		syscall.RTM_MISS:       rtm,
+		syscall.RTM_LOCK:       rtm,
+		syscall.RTM_RESOLVE:    rtm,
+		syscall.RTM_NEWADDR:    ifam,
+		syscall.RTM_DELADDR:    ifam,
+		syscall.RTM_IFINFO:     ifm,
+		syscall.RTM_NEWMADDR:   ifmam,
+		syscall.RTM_DELMADDR:   ifmam,
+		syscall.RTM_IFANNOUNCE: ifanm,
 	}
 }
diff --git a/route/sys_freebsd.go b/route/sys_freebsd.go
index a9727decdd..0a66dcedb3 100644
--- a/route/sys_freebsd.go
+++ b/route/sys_freebsd.go
@@ -7,8 +7,6 @@ package route
 import (
 	"syscall"
 	"unsafe"
-
-	"golang.org/x/sys/unix"
 )
 
 func (typ RIBType) parseable() bool { return true }
@@ -143,20 +141,20 @@ func probeRoutingStack() (int, map[int]*wireFormat) {
 	ifmam.parse = ifmam.parseInterfaceMulticastAddrMessage
 	ifanm.parse = ifanm.parseInterfaceAnnounceMessage
 	return align, map[int]*wireFormat{
-		unix.RTM_ADD:        rtm,
-		unix.RTM_DELETE:     rtm,
-		unix.RTM_CHANGE:     rtm,
-		unix.RTM_GET:        rtm,
-		unix.RTM_LOSING:     rtm,
-		unix.RTM_REDIRECT:   rtm,
-		unix.RTM_MISS:       rtm,
-		unix.RTM_LOCK:       rtm,
-		unix.RTM_RESOLVE:    rtm,
-		unix.RTM_NEWADDR:    ifam,
-		unix.RTM_DELADDR:    ifam,
-		unix.RTM_IFINFO:     ifm,
-		unix.RTM_NEWMADDR:   ifmam,
-		unix.RTM_DELMADDR:   ifmam,
-		unix.RTM_IFANNOUNCE: ifanm,
+		syscall.RTM_ADD:        rtm,
+		syscall.RTM_DELETE:     rtm,
+		syscall.RTM_CHANGE:     rtm,
+		syscall.RTM_GET:        rtm,
+		syscall.RTM_LOSING:     rtm,
+		syscall.RTM_REDIRECT:   rtm,
+		syscall.RTM_MISS:       rtm,
+		syscall.RTM_LOCK:       rtm,
+		syscall.RTM_RESOLVE:    rtm,
+		syscall.RTM_NEWADDR:    ifam,
+		syscall.RTM_DELADDR:    ifam,
+		syscall.RTM_IFINFO:     ifm,
+		syscall.RTM_NEWMADDR:   ifmam,
+		syscall.RTM_DELMADDR:   ifmam,
+		syscall.RTM_IFANNOUNCE: ifanm,
 	}
 }
diff --git a/route/sys_netbsd.go b/route/sys_netbsd.go
index 23826c4d8f..be4460e13f 100644
--- a/route/sys_netbsd.go
+++ b/route/sys_netbsd.go
@@ -4,7 +4,7 @@
 
 package route
 
-import "golang.org/x/sys/unix"
+import "syscall"
 
 func (typ RIBType) parseable() bool { return true }
 
@@ -56,18 +56,18 @@ func probeRoutingStack() (int, map[int]*wireFormat) {
 	// NetBSD 6 and above kernels require 64-bit aligned access to
 	// routing facilities.
 	return 8, map[int]*wireFormat{
-		unix.RTM_ADD:        rtm,
-		unix.RTM_DELETE:     rtm,
-		unix.RTM_CHANGE:     rtm,
-		unix.RTM_GET:        rtm,
-		unix.RTM_LOSING:     rtm,
-		unix.RTM_REDIRECT:   rtm,
-		unix.RTM_MISS:       rtm,
-		unix.RTM_LOCK:       rtm,
-		unix.RTM_RESOLVE:    rtm,
-		unix.RTM_NEWADDR:    ifam,
-		unix.RTM_DELADDR:    ifam,
-		unix.RTM_IFANNOUNCE: ifanm,
-		unix.RTM_IFINFO:     ifm,
+		syscall.RTM_ADD:        rtm,
+		syscall.RTM_DELETE:     rtm,
+		syscall.RTM_CHANGE:     rtm,
+		syscall.RTM_GET:        rtm,
+		syscall.RTM_LOSING:     rtm,
+		syscall.RTM_REDIRECT:   rtm,
+		syscall.RTM_MISS:       rtm,
+		syscall.RTM_LOCK:       rtm,
+		syscall.RTM_RESOLVE:    rtm,
+		syscall.RTM_NEWADDR:    ifam,
+		syscall.RTM_DELADDR:    ifam,
+		syscall.RTM_IFANNOUNCE: ifanm,
+		syscall.RTM_IFINFO:     ifm,
 	}
 }
diff --git a/route/sys_openbsd.go b/route/sys_openbsd.go
index 21f1d3d6e5..7f4f93cbea 100644
--- a/route/sys_openbsd.go
+++ b/route/sys_openbsd.go
@@ -5,14 +5,13 @@
 package route
 
 import (
+	"syscall"
 	"unsafe"
-
-	"golang.org/x/sys/unix"
 )
 
 func (typ RIBType) parseable() bool {
 	switch typ {
-	case unix.NET_RT_STATS, unix.NET_RT_TABLE:
+	case syscall.NET_RT_STATS, syscall.NET_RT_TABLE:
 		return false
 	default:
 		return true
@@ -66,18 +65,18 @@ func probeRoutingStack() (int, map[int]*wireFormat) {
 	ifanm := &wireFormat{extOff: -1, bodyOff: -1}
 	ifanm.parse = ifanm.parseInterfaceAnnounceMessage
 	return int(unsafe.Sizeof(p)), map[int]*wireFormat{
-		unix.RTM_ADD:        rtm,
-		unix.RTM_DELETE:     rtm,
-		unix.RTM_CHANGE:     rtm,
-		unix.RTM_GET:        rtm,
-		unix.RTM_LOSING:     rtm,
-		unix.RTM_REDIRECT:   rtm,
-		unix.RTM_MISS:       rtm,
-		unix.RTM_RESOLVE:    rtm,
-		unix.RTM_NEWADDR:    ifam,
-		unix.RTM_DELADDR:    ifam,
-		unix.RTM_IFINFO:     ifm,
-		unix.RTM_IFANNOUNCE: ifanm,
-		unix.RTM_DESYNC:     rtm,
+		syscall.RTM_ADD:        rtm,
+		syscall.RTM_DELETE:     rtm,
+		syscall.RTM_CHANGE:     rtm,
+		syscall.RTM_GET:        rtm,
+		syscall.RTM_LOSING:     rtm,
+		syscall.RTM_REDIRECT:   rtm,
+		syscall.RTM_MISS:       rtm,
+		syscall.RTM_RESOLVE:    rtm,
+		syscall.RTM_NEWADDR:    ifam,
+		syscall.RTM_DELADDR:    ifam,
+		syscall.RTM_IFINFO:     ifm,
+		syscall.RTM_IFANNOUNCE: ifanm,
+		syscall.RTM_DESYNC:     rtm,
 	}
 }