perso/syncthing-arm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vendor: Add dependencies for strelaypoolsrv

Browse Source
This commit is contained in:
Jakob Borg
2016-07-04 11:12:59 +02:00
parent 7d434aa9c4
commit 59370588dd
261 changed files with 118913 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
vendor/golang.org/x/net/route/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,27 @@
Copyright (c) 2009 The Go Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

269
vendor/golang.org/x/net/route/address.go generated vendored Normal file
View File

@@ -0,0 +1,269 @@
// 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 "runtime"
// An Addr represents an address associated with packet routing.
type Addr interface {
// Family returns an address family.
Family() int
}
// A LinkAddr represents a link-layer address.
type LinkAddr struct {
Index int // interface index when attached
Name string // interface name when attached
Addr []byte // link-layer address when attached
}
// Family implements the Family method of Addr interface.
func (a *LinkAddr) Family() int { return sysAF_LINK }
func parseLinkAddr(b []byte) (Addr, error) {
if len(b) < 8 {
return nil, errInvalidAddr
}
_, a, err := parseKernelLinkAddr(sysAF_LINK, b[4:])
if err != nil {
return nil, err
}
a.(*LinkAddr).Index = int(nativeEndian.Uint16(b[2:4]))
return a, nil
}
// parseKernelLinkAddr parses b as a link-layer address in
// conventional BSD kernel form.
func parseKernelLinkAddr(_ int, b []byte) (int, Addr, error) {
// The encoding looks like the following:
// +----------------------------+
// | Type (1 octet) |
// +----------------------------+
// | Name length (1 octet) |
// +----------------------------+
// | Address length (1 octet) |
// +----------------------------+
// | Selector length (1 octet) |
// +----------------------------+
// | Data (variable) |
// +----------------------------+
//
// On some platforms, all-bit-one of length field means "don't
// care".
nlen, alen, slen := int(b[1]), int(b[2]), int(b[3])
if nlen == 0xff {
nlen = 0
}
if alen == 0xff {
alen = 0
}
if slen == 0xff {
slen = 0
}
l := 4 + nlen + alen + slen
if len(b) < l {
return 0, nil, errInvalidAddr
}
data := b[4:]
var name string
var addr []byte
if nlen > 0 {
name = string(data[:nlen])
data = data[nlen:]
}
if alen > 0 {
addr = data[:alen]
data = data[alen:]
}
return l, &LinkAddr{Name: name, Addr: addr}, nil
}
// An Inet4Addr represents an internet address for IPv4.
type Inet4Addr struct {
IP [4]byte // IP address
}
// Family implements the Family method of Addr interface.
func (a *Inet4Addr) Family() int { return sysAF_INET }
// An Inet6Addr represents an internet address for IPv6.
type Inet6Addr struct {
IP [16]byte // IP address
ZoneID int // zone identifier
}
// Family implements the Family method of Addr interface.
func (a *Inet6Addr) Family() int { return sysAF_INET6 }
// parseInetAddr parses b as an internet address for IPv4 or IPv6.
func parseInetAddr(af int, b []byte) (Addr, error) {
switch af {
case sysAF_INET:
if len(b) < 16 {
return nil, errInvalidAddr
}
a := &Inet4Addr{}
copy(a.IP[:], b[4:8])
return a, nil
case sysAF_INET6:
if len(b) < 28 {
return nil, errInvalidAddr
}
a := &Inet6Addr{ZoneID: int(nativeEndian.Uint32(b[24:28]))}
copy(a.IP[:], b[8:24])
if a.IP[0] == 0xfe && a.IP[1]&0xc0 == 0x80 || a.IP[0] == 0xff && (a.IP[1]&0x0f == 0x01 || a.IP[1]&0x0f == 0x02) {
// KAME based IPv6 protocol stack usually
// embeds the interface index in the
// interface-local or link-local address as
// the kernel-internal form.
id := int(bigEndian.Uint16(a.IP[2:4]))
if id != 0 {
a.ZoneID = id
a.IP[2], a.IP[3] = 0, 0
}
}
return a, nil
default:
return nil, errInvalidAddr
}
}
// parseKernelInetAddr parses b as an internet address in conventional
// BSD kernel form.
func parseKernelInetAddr(af int, b []byte) (int, Addr, error) {
// The encoding looks similar to the NLRI encoding.
// +----------------------------+
// | Length (1 octet) |
// +----------------------------+
// | Address prefix (variable) |
// +----------------------------+
//
// The differences between the kernel form and the NLRI
// encoding are:
//
// - The length field of the kernel form indicates the prefix
// length in bytes, not in bits
//
// - In the kernel form, zero value of the length field
// doesn't mean 0.0.0.0/0 or ::/0
//
// - The kernel form appends leading bytes to the prefix field
// to make the <length, prefix> tuple to be conformed with
// the routing message boundary
l := int(b[0])
if runtime.GOOS == "darwin" {
// On Darwn, an address in the kernel form is also
// used as a message filler.
if l == 0 || len(b) > roundup(l) {
l = roundup(l)
}
} else {
l = roundup(l)
}
if len(b) < l {
return 0, nil, errInvalidAddr
}
// Don't reorder case expressions.
// The case expressions for IPv6 must come first.
const (
off4 = 4 // offset of in_addr
off6 = 8 // offset of in6_addr
)
switch {
case b[0] == 28: // size of sockaddr_in6
a := &Inet6Addr{}
copy(a.IP[:], b[off6:off6+16])
return int(b[0]), a, nil
case af == sysAF_INET6:
a := &Inet6Addr{}
if l-1 < off6 {
copy(a.IP[:], b[1:l])
} else {
copy(a.IP[:], b[l-off6:l])
}
return int(b[0]), a, nil
case b[0] == 16: // size of sockaddr_in
a := &Inet4Addr{}
copy(a.IP[:], b[off4:off4+4])
return int(b[0]), a, nil
default: // an old fashion, AF_UNSPEC or unknown means AF_INET
a := &Inet4Addr{}
if l-1 < off4 {
copy(a.IP[:], b[1:l])
} else {
copy(a.IP[:], b[l-off4:l])
}
return int(b[0]), a, nil
}
}
// A DefaultAddr represents an address of various operating
// system-specific features.
type DefaultAddr struct {
af int
Raw []byte // raw format of address
}
// Family implements the Family method of Addr interface.
func (a *DefaultAddr) Family() int { return a.af }
func parseDefaultAddr(b []byte) (Addr, error) {
if len(b) < 2 || len(b) < int(b[0]) {
return nil, errInvalidAddr
}
a := &DefaultAddr{af: int(b[1]), Raw: b[:b[0]]}
return a, nil
}
func parseAddrs(attrs uint, fn func(int, []byte) (int, Addr, error), b []byte) ([]Addr, error) {
var as [sysRTAX_MAX]Addr
af := int(sysAF_UNSPEC)
for i := uint(0); i < sysRTAX_MAX && len(b) >= roundup(0); i++ {
if attrs&(1<<i) == 0 {
continue
}
if i <= sysRTAX_BRD {
switch b[1] {
case sysAF_LINK:
a, err := parseLinkAddr(b)
if err != nil {
return nil, err
}
as[i] = a
b = b[roundup(int(b[0])):]
case sysAF_INET, sysAF_INET6:
af = int(b[1])
a, err := parseInetAddr(af, b)
if err != nil {
return nil, err
}
as[i] = a
b = b[roundup(int(b[0])):]
default:
l, a, err := fn(af, b)
if err != nil {
return nil, err
}
as[i] = a
ll := roundup(l)
if len(b) < ll {
b = b[l:]
} else {
b = b[ll:]
}
}
} else {
a, err := parseDefaultAddr(b)
if err != nil {
return nil, err
}
as[i] = a
b = b[roundup(int(b[0])):]
}
}
return as[:], nil
}

90
vendor/golang.org/x/net/route/binary.go generated vendored Normal file
View File

@@ -0,0 +1,90 @@
// 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
// This file contains duplicates of encoding/binary package.
//
// This package is supposed to be used by the net package of standard
// library. Therefore a package set used in the package must be the
// same as net package.
var (
littleEndian binaryLittleEndian
bigEndian binaryBigEndian
)
type binaryByteOrder interface {
Uint16([]byte) uint16
Uint32([]byte) uint32
PutUint16([]byte, uint16)
PutUint32([]byte, uint32)
Uint64([]byte) uint64
}
type binaryLittleEndian struct{}
func (binaryLittleEndian) Uint16(b []byte) uint16 {
_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
return uint16(b[0]) | uint16(b[1])<<8
}
func (binaryLittleEndian) PutUint16(b []byte, v uint16) {
_ = b[1] // early bounds check to guarantee safety of writes below
b[0] = byte(v)
b[1] = byte(v >> 8)
}
func (binaryLittleEndian) Uint32(b []byte) uint32 {
_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}
func (binaryLittleEndian) PutUint32(b []byte, v uint32) {
_ = b[3] // early bounds check to guarantee safety of writes below
b[0] = byte(v)
b[1] = byte(v >> 8)
b[2] = byte(v >> 16)
b[3] = byte(v >> 24)
}
func (binaryLittleEndian) Uint64(b []byte) uint64 {
_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
}
type binaryBigEndian struct{}
func (binaryBigEndian) Uint16(b []byte) uint16 {
_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
return uint16(b[1]) | uint16(b[0])<<8
}
func (binaryBigEndian) PutUint16(b []byte, v uint16) {
_ = b[1] // early bounds check to guarantee safety of writes below
b[0] = byte(v >> 8)
b[1] = byte(v)
}
func (binaryBigEndian) Uint32(b []byte) uint32 {
_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
}
func (binaryBigEndian) PutUint32(b []byte, v uint32) {
_ = b[3] // early bounds check to guarantee safety of writes below
b[0] = byte(v >> 24)
b[1] = byte(v >> 16)
b[2] = byte(v >> 8)
b[3] = byte(v)
}
func (binaryBigEndian) Uint64(b []byte) uint64 {
_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
}

106
vendor/golang.org/x/net/route/defs_darwin.go generated vendored Normal file
View File

@@ -0,0 +1,106 @@
// 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 ignore
package route
/*
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
*/
import "C"
const (
sysAF_UNSPEC = C.AF_UNSPEC
sysAF_INET = C.AF_INET
sysAF_ROUTE = C.AF_ROUTE
sysAF_LINK = C.AF_LINK
sysAF_INET6 = C.AF_INET6
sysNET_RT_DUMP = C.NET_RT_DUMP
sysNET_RT_FLAGS = C.NET_RT_FLAGS
sysNET_RT_IFLIST = C.NET_RT_IFLIST
sysNET_RT_STAT = C.NET_RT_STAT
sysNET_RT_TRASH = C.NET_RT_TRASH
sysNET_RT_IFLIST2 = C.NET_RT_IFLIST2
sysNET_RT_DUMP2 = C.NET_RT_DUMP2
sysNET_RT_MAXID = C.NET_RT_MAXID
)
const (
sysCTL_MAXNAME = C.CTL_MAXNAME
sysCTL_UNSPEC = C.CTL_UNSPEC
sysCTL_KERN = C.CTL_KERN
sysCTL_VM = C.CTL_VM
sysCTL_VFS = C.CTL_VFS
sysCTL_NET = C.CTL_NET
sysCTL_DEBUG = C.CTL_DEBUG
sysCTL_HW = C.CTL_HW
sysCTL_MACHDEP = C.CTL_MACHDEP
sysCTL_USER = C.CTL_USER
sysCTL_MAXID = C.CTL_MAXID
)
const (
sysRTM_VERSION = C.RTM_VERSION
sysRTM_ADD = C.RTM_ADD
sysRTM_DELETE = C.RTM_DELETE
sysRTM_CHANGE = C.RTM_CHANGE
sysRTM_GET = C.RTM_GET
sysRTM_LOSING = C.RTM_LOSING
sysRTM_REDIRECT = C.RTM_REDIRECT
sysRTM_MISS = C.RTM_MISS
sysRTM_LOCK = C.RTM_LOCK
sysRTM_OLDADD = C.RTM_OLDADD
sysRTM_OLDDEL = C.RTM_OLDDEL
sysRTM_RESOLVE = C.RTM_RESOLVE
sysRTM_NEWADDR = C.RTM_NEWADDR
sysRTM_DELADDR = C.RTM_DELADDR
sysRTM_IFINFO = C.RTM_IFINFO
sysRTM_NEWMADDR = C.RTM_NEWMADDR
sysRTM_DELMADDR = C.RTM_DELMADDR
sysRTM_IFINFO2 = C.RTM_IFINFO2
sysRTM_NEWMADDR2 = C.RTM_NEWMADDR2
sysRTM_GET2 = C.RTM_GET2
sysRTA_DST = C.RTA_DST
sysRTA_GATEWAY = C.RTA_GATEWAY
sysRTA_NETMASK = C.RTA_NETMASK
sysRTA_GENMASK = C.RTA_GENMASK
sysRTA_IFP = C.RTA_IFP
sysRTA_IFA = C.RTA_IFA
sysRTA_AUTHOR = C.RTA_AUTHOR
sysRTA_BRD = C.RTA_BRD
sysRTAX_DST = C.RTAX_DST
sysRTAX_GATEWAY = C.RTAX_GATEWAY
sysRTAX_NETMASK = C.RTAX_NETMASK
sysRTAX_GENMASK = C.RTAX_GENMASK
sysRTAX_IFP = C.RTAX_IFP
sysRTAX_IFA = C.RTAX_IFA
sysRTAX_AUTHOR = C.RTAX_AUTHOR
sysRTAX_BRD = C.RTAX_BRD
sysRTAX_MAX = C.RTAX_MAX
)
const (
sizeofIfMsghdrDarwin15 = C.sizeof_struct_if_msghdr
sizeofIfaMsghdrDarwin15 = C.sizeof_struct_ifa_msghdr
sizeofIfmaMsghdrDarwin15 = C.sizeof_struct_ifma_msghdr
sizeofIfMsghdr2Darwin15 = C.sizeof_struct_if_msghdr2
sizeofIfmaMsghdr2Darwin15 = C.sizeof_struct_ifma_msghdr2
sizeofIfDataDarwin15 = C.sizeof_struct_if_data
sizeofIfData64Darwin15 = C.sizeof_struct_if_data64
sizeofRtMsghdrDarwin15 = C.sizeof_struct_rt_msghdr
sizeofRtMsghdr2Darwin15 = C.sizeof_struct_rt_msghdr2
sizeofRtMetricsDarwin15 = C.sizeof_struct_rt_metrics
)

105
vendor/golang.org/x/net/route/defs_dragonfly.go generated vendored Normal file
View File

@@ -0,0 +1,105 @@
// 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 ignore
package route
/*
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
*/
import "C"
const (
sysAF_UNSPEC = C.AF_UNSPEC
sysAF_INET = C.AF_INET
sysAF_ROUTE = C.AF_ROUTE
sysAF_LINK = C.AF_LINK
sysAF_INET6 = C.AF_INET6
sysNET_RT_DUMP = C.NET_RT_DUMP
sysNET_RT_FLAGS = C.NET_RT_FLAGS
sysNET_RT_IFLIST = C.NET_RT_IFLIST
sysNET_RT_MAXID = C.NET_RT_MAXID
)
const (
sysCTL_MAXNAME = C.CTL_MAXNAME
sysCTL_UNSPEC = C.CTL_UNSPEC
sysCTL_KERN = C.CTL_KERN
sysCTL_VM = C.CTL_VM
sysCTL_VFS = C.CTL_VFS
sysCTL_NET = C.CTL_NET
sysCTL_DEBUG = C.CTL_DEBUG
sysCTL_HW = C.CTL_HW
sysCTL_MACHDEP = C.CTL_MACHDEP
sysCTL_USER = C.CTL_USER
sysCTL_P1003_1B = C.CTL_P1003_1B
sysCTL_LWKT = C.CTL_LWKT
sysCTL_MAXID = C.CTL_MAXID
)
const (
sysRTM_VERSION = C.RTM_VERSION
sysRTM_ADD = C.RTM_ADD
sysRTM_DELETE = C.RTM_DELETE
sysRTM_CHANGE = C.RTM_CHANGE
sysRTM_GET = C.RTM_GET
sysRTM_LOSING = C.RTM_LOSING
sysRTM_REDIRECT = C.RTM_REDIRECT
sysRTM_MISS = C.RTM_MISS
sysRTM_LOCK = C.RTM_LOCK
sysRTM_OLDADD = C.RTM_OLDADD
sysRTM_OLDDEL = C.RTM_OLDDEL
sysRTM_RESOLVE = C.RTM_RESOLVE
sysRTM_NEWADDR = C.RTM_NEWADDR
sysRTM_DELADDR = C.RTM_DELADDR
sysRTM_IFINFO = C.RTM_IFINFO
sysRTM_NEWMADDR = C.RTM_NEWMADDR
sysRTM_DELMADDR = C.RTM_DELMADDR
sysRTM_IFANNOUNCE = C.RTM_IFANNOUNCE
sysRTM_IEEE80211 = C.RTM_IEEE80211
sysRTA_DST = C.RTA_DST
sysRTA_GATEWAY = C.RTA_GATEWAY
sysRTA_NETMASK = C.RTA_NETMASK
sysRTA_GENMASK = C.RTA_GENMASK
sysRTA_IFP = C.RTA_IFP
sysRTA_IFA = C.RTA_IFA
sysRTA_AUTHOR = C.RTA_AUTHOR
sysRTA_BRD = C.RTA_BRD
sysRTA_MPLS1 = C.RTA_MPLS1
sysRTA_MPLS2 = C.RTA_MPLS2
sysRTA_MPLS3 = C.RTA_MPLS3
sysRTAX_DST = C.RTAX_DST
sysRTAX_GATEWAY = C.RTAX_GATEWAY
sysRTAX_NETMASK = C.RTAX_NETMASK
sysRTAX_GENMASK = C.RTAX_GENMASK
sysRTAX_IFP = C.RTAX_IFP
sysRTAX_IFA = C.RTAX_IFA
sysRTAX_AUTHOR = C.RTAX_AUTHOR
sysRTAX_BRD = C.RTAX_BRD
sysRTAX_MPLS1 = C.RTAX_MPLS1
sysRTAX_MPLS2 = C.RTAX_MPLS2
sysRTAX_MPLS3 = C.RTAX_MPLS3
sysRTAX_MAX = C.RTAX_MAX
)
const (
sizeofIfMsghdrDragonFlyBSD4 = C.sizeof_struct_if_msghdr
sizeofIfaMsghdrDragonFlyBSD4 = C.sizeof_struct_ifa_msghdr
sizeofIfmaMsghdrDragonFlyBSD4 = C.sizeof_struct_ifma_msghdr
sizeofIfAnnouncemsghdrDragonFlyBSD4 = C.sizeof_struct_if_announcemsghdr
sizeofRtMsghdrDragonFlyBSD4 = C.sizeof_struct_rt_msghdr
sizeofRtMetricsDragonFlyBSD4 = C.sizeof_struct_rt_metrics
)

329
vendor/golang.org/x/net/route/defs_freebsd.go generated vendored Normal file
View File

@@ -0,0 +1,329 @@
// 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 ignore
package route
/*
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
struct if_data_freebsd7 {
u_char ifi_type;
u_char ifi_physical;
u_char ifi_addrlen;
u_char ifi_hdrlen;
u_char ifi_link_state;
u_char ifi_spare_char1;
u_char ifi_spare_char2;
u_char ifi_datalen;
u_long ifi_mtu;
u_long ifi_metric;
u_long ifi_baudrate;
u_long ifi_ipackets;
u_long ifi_ierrors;
u_long ifi_opackets;
u_long ifi_oerrors;
u_long ifi_collisions;
u_long ifi_ibytes;
u_long ifi_obytes;
u_long ifi_imcasts;
u_long ifi_omcasts;
u_long ifi_iqdrops;
u_long ifi_noproto;
u_long ifi_hwassist;
time_t __ifi_epoch;
struct timeval __ifi_lastchange;
};
struct if_data_freebsd8 {
u_char ifi_type;
u_char ifi_physical;
u_char ifi_addrlen;
u_char ifi_hdrlen;
u_char ifi_link_state;
u_char ifi_spare_char1;
u_char ifi_spare_char2;
u_char ifi_datalen;
u_long ifi_mtu;
u_long ifi_metric;
u_long ifi_baudrate;
u_long ifi_ipackets;
u_long ifi_ierrors;
u_long ifi_opackets;
u_long ifi_oerrors;
u_long ifi_collisions;
u_long ifi_ibytes;
u_long ifi_obytes;
u_long ifi_imcasts;
u_long ifi_omcasts;
u_long ifi_iqdrops;
u_long ifi_noproto;
u_long ifi_hwassist;
time_t __ifi_epoch;
struct timeval __ifi_lastchange;
};
struct if_data_freebsd9 {
u_char ifi_type;
u_char ifi_physical;
u_char ifi_addrlen;
u_char ifi_hdrlen;
u_char ifi_link_state;
u_char ifi_spare_char1;
u_char ifi_spare_char2;
u_char ifi_datalen;
u_long ifi_mtu;
u_long ifi_metric;
u_long ifi_baudrate;
u_long ifi_ipackets;
u_long ifi_ierrors;
u_long ifi_opackets;
u_long ifi_oerrors;
u_long ifi_collisions;
u_long ifi_ibytes;
u_long ifi_obytes;
u_long ifi_imcasts;
u_long ifi_omcasts;
u_long ifi_iqdrops;
u_long ifi_noproto;
u_long ifi_hwassist;
time_t __ifi_epoch;
struct timeval __ifi_lastchange;
};
struct if_data_freebsd10 {
u_char ifi_type;
u_char ifi_physical;
u_char ifi_addrlen;
u_char ifi_hdrlen;
u_char ifi_link_state;
u_char ifi_vhid;
u_char ifi_baudrate_pf;
u_char ifi_datalen;
u_long ifi_mtu;
u_long ifi_metric;
u_long ifi_baudrate;
u_long ifi_ipackets;
u_long ifi_ierrors;
u_long ifi_opackets;
u_long ifi_oerrors;
u_long ifi_collisions;
u_long ifi_ibytes;
u_long ifi_obytes;
u_long ifi_imcasts;
u_long ifi_omcasts;
u_long ifi_iqdrops;
u_long ifi_noproto;
uint64_t ifi_hwassist;
time_t __ifi_epoch;
struct timeval __ifi_lastchange;
};
struct if_data_freebsd11 {
uint8_t ifi_type;
uint8_t ifi_physical;
uint8_t ifi_addrlen;
uint8_t ifi_hdrlen;
uint8_t ifi_link_state;
uint8_t ifi_vhid;
uint16_t ifi_datalen;
uint32_t ifi_mtu;
uint32_t ifi_metric;
uint64_t ifi_baudrate;
uint64_t ifi_ipackets;
uint64_t ifi_ierrors;
uint64_t ifi_opackets;
uint64_t ifi_oerrors;
uint64_t ifi_collisions;
uint64_t ifi_ibytes;
uint64_t ifi_obytes;
uint64_t ifi_imcasts;
uint64_t ifi_omcasts;
uint64_t ifi_iqdrops;
uint64_t ifi_oqdrops;
uint64_t ifi_noproto;
uint64_t ifi_hwassist;
union {
time_t tt;
uint64_t ph;
} __ifi_epoch;
union {
struct timeval tv;
struct {
uint64_t ph1;
uint64_t ph2;
} ph;
} __ifi_lastchange;
};
struct if_msghdr_freebsd7 {
u_short ifm_msglen;
u_char ifm_version;
u_char ifm_type;
int ifm_addrs;
int ifm_flags;
u_short ifm_index;
struct if_data_freebsd7 ifm_data;
};
struct if_msghdr_freebsd8 {
u_short ifm_msglen;
u_char ifm_version;
u_char ifm_type;
int ifm_addrs;
int ifm_flags;
u_short ifm_index;
struct if_data_freebsd8 ifm_data;
};
struct if_msghdr_freebsd9 {
u_short ifm_msglen;
u_char ifm_version;
u_char ifm_type;
int ifm_addrs;
int ifm_flags;
u_short ifm_index;
struct if_data_freebsd9 ifm_data;
};
struct if_msghdr_freebsd10 {
u_short ifm_msglen;
u_char ifm_version;
u_char ifm_type;
int ifm_addrs;
int ifm_flags;
u_short ifm_index;
struct if_data_freebsd10 ifm_data;
};
struct if_msghdr_freebsd11 {
u_short ifm_msglen;
u_char ifm_version;
u_char ifm_type;
int ifm_addrs;
int ifm_flags;
u_short ifm_index;
struct if_data_freebsd11 ifm_data;
};
*/
import "C"
const (
sysAF_UNSPEC = C.AF_UNSPEC
sysAF_INET = C.AF_INET
sysAF_ROUTE = C.AF_ROUTE
sysAF_LINK = C.AF_LINK
sysAF_INET6 = C.AF_INET6
sysNET_RT_DUMP = C.NET_RT_DUMP
sysNET_RT_FLAGS = C.NET_RT_FLAGS
sysNET_RT_IFLIST = C.NET_RT_IFLIST
sysNET_RT_IFMALIST = C.NET_RT_IFMALIST
sysNET_RT_IFLISTL = C.NET_RT_IFLISTL
)
const (
sysCTL_MAXNAME = C.CTL_MAXNAME
sysCTL_UNSPEC = C.CTL_UNSPEC
sysCTL_KERN = C.CTL_KERN
sysCTL_VM = C.CTL_VM
sysCTL_VFS = C.CTL_VFS
sysCTL_NET = C.CTL_NET
sysCTL_DEBUG = C.CTL_DEBUG
sysCTL_HW = C.CTL_HW
sysCTL_MACHDEP = C.CTL_MACHDEP
sysCTL_USER = C.CTL_USER
sysCTL_P1003_1B = C.CTL_P1003_1B
)
const (
sysRTM_VERSION = C.RTM_VERSION
sysRTM_ADD = C.RTM_ADD
sysRTM_DELETE = C.RTM_DELETE
sysRTM_CHANGE = C.RTM_CHANGE
sysRTM_GET = C.RTM_GET
sysRTM_LOSING = C.RTM_LOSING
sysRTM_REDIRECT = C.RTM_REDIRECT
sysRTM_MISS = C.RTM_MISS
sysRTM_LOCK = C.RTM_LOCK
sysRTM_RESOLVE = C.RTM_RESOLVE
sysRTM_NEWADDR = C.RTM_NEWADDR
sysRTM_DELADDR = C.RTM_DELADDR
sysRTM_IFINFO = C.RTM_IFINFO
sysRTM_NEWMADDR = C.RTM_NEWMADDR
sysRTM_DELMADDR = C.RTM_DELMADDR
sysRTM_IFANNOUNCE = C.RTM_IFANNOUNCE
sysRTM_IEEE80211 = C.RTM_IEEE80211
sysRTA_DST = C.RTA_DST
sysRTA_GATEWAY = C.RTA_GATEWAY
sysRTA_NETMASK = C.RTA_NETMASK
sysRTA_GENMASK = C.RTA_GENMASK
sysRTA_IFP = C.RTA_IFP
sysRTA_IFA = C.RTA_IFA
sysRTA_AUTHOR = C.RTA_AUTHOR
sysRTA_BRD = C.RTA_BRD
sysRTAX_DST = C.RTAX_DST
sysRTAX_GATEWAY = C.RTAX_GATEWAY
sysRTAX_NETMASK = C.RTAX_NETMASK
sysRTAX_GENMASK = C.RTAX_GENMASK
sysRTAX_IFP = C.RTAX_IFP
sysRTAX_IFA = C.RTAX_IFA
sysRTAX_AUTHOR = C.RTAX_AUTHOR
sysRTAX_BRD = C.RTAX_BRD
sysRTAX_MAX = C.RTAX_MAX
)
const (
sizeofIfMsghdrlFreeBSD10 = C.sizeof_struct_if_msghdrl
sizeofIfaMsghdrFreeBSD10 = C.sizeof_struct_ifa_msghdr
sizeofIfaMsghdrlFreeBSD10 = C.sizeof_struct_ifa_msghdrl
sizeofIfmaMsghdrFreeBSD10 = C.sizeof_struct_ifma_msghdr
sizeofIfAnnouncemsghdrFreeBSD10 = C.sizeof_struct_if_announcemsghdr
sizeofRtMsghdrFreeBSD10 = C.sizeof_struct_rt_msghdr
sizeofRtMetricsFreeBSD10 = C.sizeof_struct_rt_metrics
sizeofIfMsghdrFreeBSD7 = C.sizeof_struct_if_msghdr_freebsd7
sizeofIfMsghdrFreeBSD8 = C.sizeof_struct_if_msghdr_freebsd8
sizeofIfMsghdrFreeBSD9 = C.sizeof_struct_if_msghdr_freebsd9
sizeofIfMsghdrFreeBSD10 = C.sizeof_struct_if_msghdr_freebsd10
sizeofIfMsghdrFreeBSD11 = C.sizeof_struct_if_msghdr_freebsd11
sizeofIfDataFreeBSD7 = C.sizeof_struct_if_data_freebsd7
sizeofIfDataFreeBSD8 = C.sizeof_struct_if_data_freebsd8
sizeofIfDataFreeBSD9 = C.sizeof_struct_if_data_freebsd9
sizeofIfDataFreeBSD10 = C.sizeof_struct_if_data_freebsd10
sizeofIfDataFreeBSD11 = C.sizeof_struct_if_data_freebsd11
sizeofIfMsghdrlFreeBSD10Emu = C.sizeof_struct_if_msghdrl
sizeofIfaMsghdrFreeBSD10Emu = C.sizeof_struct_ifa_msghdr
sizeofIfaMsghdrlFreeBSD10Emu = C.sizeof_struct_ifa_msghdrl
sizeofIfmaMsghdrFreeBSD10Emu = C.sizeof_struct_ifma_msghdr
sizeofIfAnnouncemsghdrFreeBSD10Emu = C.sizeof_struct_if_announcemsghdr
sizeofRtMsghdrFreeBSD10Emu = C.sizeof_struct_rt_msghdr
sizeofRtMetricsFreeBSD10Emu = C.sizeof_struct_rt_metrics
sizeofIfMsghdrFreeBSD7Emu = C.sizeof_struct_if_msghdr_freebsd7
sizeofIfMsghdrFreeBSD8Emu = C.sizeof_struct_if_msghdr_freebsd8
sizeofIfMsghdrFreeBSD9Emu = C.sizeof_struct_if_msghdr_freebsd9
sizeofIfMsghdrFreeBSD10Emu = C.sizeof_struct_if_msghdr_freebsd10
sizeofIfMsghdrFreeBSD11Emu = C.sizeof_struct_if_msghdr_freebsd11
sizeofIfDataFreeBSD7Emu = C.sizeof_struct_if_data_freebsd7
sizeofIfDataFreeBSD8Emu = C.sizeof_struct_if_data_freebsd8
sizeofIfDataFreeBSD9Emu = C.sizeof_struct_if_data_freebsd9
sizeofIfDataFreeBSD10Emu = C.sizeof_struct_if_data_freebsd10
sizeofIfDataFreeBSD11Emu = C.sizeof_struct_if_data_freebsd11
)

104
vendor/golang.org/x/net/route/defs_netbsd.go generated vendored Normal file
View File

@@ -0,0 +1,104 @@
// 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 ignore
package route
/*
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
*/
import "C"
const (
sysAF_UNSPEC = C.AF_UNSPEC
sysAF_INET = C.AF_INET
sysAF_ROUTE = C.AF_ROUTE
sysAF_LINK = C.AF_LINK
sysAF_INET6 = C.AF_INET6
sysNET_RT_DUMP = C.NET_RT_DUMP
sysNET_RT_FLAGS = C.NET_RT_FLAGS
sysNET_RT_IFLIST = C.NET_RT_IFLIST
sysNET_RT_MAXID = C.NET_RT_MAXID
)
const (
sysCTL_MAXNAME = C.CTL_MAXNAME
sysCTL_UNSPEC = C.CTL_UNSPEC
sysCTL_KERN = C.CTL_KERN
sysCTL_VM = C.CTL_VM
sysCTL_VFS = C.CTL_VFS
sysCTL_NET = C.CTL_NET
sysCTL_DEBUG = C.CTL_DEBUG
sysCTL_HW = C.CTL_HW
sysCTL_MACHDEP = C.CTL_MACHDEP
sysCTL_USER = C.CTL_USER
sysCTL_DDB = C.CTL_DDB
sysCTL_PROC = C.CTL_PROC
sysCTL_VENDOR = C.CTL_VENDOR
sysCTL_EMUL = C.CTL_EMUL
sysCTL_SECURITY = C.CTL_SECURITY
sysCTL_MAXID = C.CTL_MAXID
)
const (
sysRTM_VERSION = C.RTM_VERSION
sysRTM_ADD = C.RTM_ADD
sysRTM_DELETE = C.RTM_DELETE
sysRTM_CHANGE = C.RTM_CHANGE
sysRTM_GET = C.RTM_GET
sysRTM_LOSING = C.RTM_LOSING
sysRTM_REDIRECT = C.RTM_REDIRECT
sysRTM_MISS = C.RTM_MISS
sysRTM_LOCK = C.RTM_LOCK
sysRTM_OLDADD = C.RTM_OLDADD
sysRTM_OLDDEL = C.RTM_OLDDEL
sysRTM_RESOLVE = C.RTM_RESOLVE
sysRTM_NEWADDR = C.RTM_NEWADDR
sysRTM_DELADDR = C.RTM_DELADDR
sysRTM_IFANNOUNCE = C.RTM_IFANNOUNCE
sysRTM_IEEE80211 = C.RTM_IEEE80211
sysRTM_SETGATE = C.RTM_SETGATE
sysRTM_LLINFO_UPD = C.RTM_LLINFO_UPD
sysRTM_IFINFO = C.RTM_IFINFO
sysRTM_CHGADDR = C.RTM_CHGADDR
sysRTA_DST = C.RTA_DST
sysRTA_GATEWAY = C.RTA_GATEWAY
sysRTA_NETMASK = C.RTA_NETMASK
sysRTA_GENMASK = C.RTA_GENMASK
sysRTA_IFP = C.RTA_IFP
sysRTA_IFA = C.RTA_IFA
sysRTA_AUTHOR = C.RTA_AUTHOR
sysRTA_BRD = C.RTA_BRD
sysRTA_TAG = C.RTA_TAG
sysRTAX_DST = C.RTAX_DST
sysRTAX_GATEWAY = C.RTAX_GATEWAY
sysRTAX_NETMASK = C.RTAX_NETMASK
sysRTAX_GENMASK = C.RTAX_GENMASK
sysRTAX_IFP = C.RTAX_IFP
sysRTAX_IFA = C.RTAX_IFA
sysRTAX_AUTHOR = C.RTAX_AUTHOR
sysRTAX_BRD = C.RTAX_BRD
sysRTAX_TAG = C.RTAX_TAG
sysRTAX_MAX = C.RTAX_MAX
)
const (
sizeofIfMsghdrNetBSD7 = C.sizeof_struct_if_msghdr
sizeofIfaMsghdrNetBSD7 = C.sizeof_struct_ifa_msghdr
sizeofIfAnnouncemsghdrNetBSD7 = C.sizeof_struct_if_announcemsghdr
sizeofRtMsghdrNetBSD7 = C.sizeof_struct_rt_msghdr
sizeofRtMetricsNetBSD7 = C.sizeof_struct_rt_metrics
)

93
vendor/golang.org/x/net/route/defs_openbsd.go generated vendored Normal file
View File

@@ -0,0 +1,93 @@
// 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 ignore
package route
/*
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
*/
import "C"
const (
sysAF_UNSPEC = C.AF_UNSPEC
sysAF_INET = C.AF_INET
sysAF_ROUTE = C.AF_ROUTE
sysAF_LINK = C.AF_LINK
sysAF_INET6 = C.AF_INET6
sysNET_RT_DUMP = C.NET_RT_DUMP
sysNET_RT_FLAGS = C.NET_RT_FLAGS
sysNET_RT_IFLIST = C.NET_RT_IFLIST
sysNET_RT_STATS = C.NET_RT_STATS
sysNET_RT_TABLE = C.NET_RT_TABLE
sysNET_RT_IFNAMES = C.NET_RT_IFNAMES
sysNET_RT_MAXID = C.NET_RT_MAXID
)
const (
sysCTL_MAXNAME = C.CTL_MAXNAME
sysCTL_UNSPEC = C.CTL_UNSPEC
sysCTL_KERN = C.CTL_KERN
sysCTL_VM = C.CTL_VM
sysCTL_FS = C.CTL_FS
sysCTL_NET = C.CTL_NET
sysCTL_DEBUG = C.CTL_DEBUG
sysCTL_HW = C.CTL_HW
sysCTL_MACHDEP = C.CTL_MACHDEP
sysCTL_DDB = C.CTL_DDB
sysCTL_VFS = C.CTL_VFS
sysCTL_MAXID = C.CTL_MAXID
)
const (
sysRTM_VERSION = C.RTM_VERSION
sysRTM_ADD = C.RTM_ADD
sysRTM_DELETE = C.RTM_DELETE
sysRTM_CHANGE = C.RTM_CHANGE
sysRTM_GET = C.RTM_GET
sysRTM_LOSING = C.RTM_LOSING
sysRTM_REDIRECT = C.RTM_REDIRECT
sysRTM_MISS = C.RTM_MISS
sysRTM_LOCK = C.RTM_LOCK
sysRTM_RESOLVE = C.RTM_RESOLVE
sysRTM_NEWADDR = C.RTM_NEWADDR
sysRTM_DELADDR = C.RTM_DELADDR
sysRTM_IFINFO = C.RTM_IFINFO
sysRTM_IFANNOUNCE = C.RTM_IFANNOUNCE
sysRTM_DESYNC = C.RTM_DESYNC
sysRTA_DST = C.RTA_DST
sysRTA_GATEWAY = C.RTA_GATEWAY
sysRTA_NETMASK = C.RTA_NETMASK
sysRTA_GENMASK = C.RTA_GENMASK
sysRTA_IFP = C.RTA_IFP
sysRTA_IFA = C.RTA_IFA
sysRTA_AUTHOR = C.RTA_AUTHOR
sysRTA_BRD = C.RTA_BRD
sysRTA_SRC = C.RTA_SRC
sysRTA_SRCMASK = C.RTA_SRCMASK
sysRTA_LABEL = C.RTA_LABEL
sysRTAX_DST = C.RTAX_DST
sysRTAX_GATEWAY = C.RTAX_GATEWAY
sysRTAX_NETMASK = C.RTAX_NETMASK
sysRTAX_GENMASK = C.RTAX_GENMASK
sysRTAX_IFP = C.RTAX_IFP
sysRTAX_IFA = C.RTAX_IFA
sysRTAX_AUTHOR = C.RTAX_AUTHOR
sysRTAX_BRD = C.RTAX_BRD
sysRTAX_SRC = C.RTAX_SRC
sysRTAX_SRCMASK = C.RTAX_SRCMASK
sysRTAX_LABEL = C.RTAX_LABEL
sysRTAX_MAX = C.RTAX_MAX
)

64
vendor/golang.org/x/net/route/interface.go generated vendored Normal file
View File

@@ -0,0 +1,64 @@
// 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
// An InterfaceMessage represents an interface message.
type InterfaceMessage struct {
Version int // message version
Type int // message type
Flags int // interface flags
Index int // interface index
Name string // interface name
Addrs []Addr // addresses
extOff int // offset of header extension
raw []byte // raw message
}
// An InterfaceAddrMessage represents an interface address message.
type InterfaceAddrMessage struct {
Version int // message version
Type int // message type
Flags int // interface flags
Index int // interface index
Addrs []Addr // addresses
raw []byte // raw message
}
// Sys implements the Sys method of Message interface.
func (m *InterfaceAddrMessage) Sys() []Sys { return nil }
// An InterfaceMulticastAddrMessage represents an interface multicast
// address message.
type InterfaceMulticastAddrMessage struct {
Version int // message version
Type int // messsage type
Flags int // interface flags
Index int // interface index
Addrs []Addr // addresses
raw []byte // raw message
}
// Sys implements the Sys method of Message interface.
func (m *InterfaceMulticastAddrMessage) Sys() []Sys { return nil }
// An InterfaceAnnounceMessage represents an interface announcement
// message.
type InterfaceAnnounceMessage struct {
Version int // message version
Type int // message type
Index int // interface index
Name string // interface name
What int // what type of announcement
raw []byte // raw message
}
// Sys implements the Sys method of Message interface.
func (m *InterfaceAnnounceMessage) Sys() []Sys { return nil }

32
vendor/golang.org/x/net/route/interface_announce.go generated vendored Normal file
View File

@@ -0,0 +1,32 @@
// 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 dragonfly freebsd netbsd
package route
func (w *wireFormat) parseInterfaceAnnounceMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &InterfaceAnnounceMessage{
Version: int(b[2]),
Type: int(b[3]),
Index: int(nativeEndian.Uint16(b[4:6])),
What: int(nativeEndian.Uint16(b[22:24])),
raw: b[:l],
}
for i := 0; i < 16; i++ {
if b[6+i] != 0 {
continue
}
m.Name = string(b[6 : 6+i])
break
}
return m, nil
}

66
vendor/golang.org/x/net/route/interface_classic.go generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// 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 netbsd
package route
import "runtime"
func (w *wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
attrs := uint(nativeEndian.Uint32(b[4:8]))
if attrs&sysRTA_IFP == 0 {
return nil, nil
}
m := &InterfaceMessage{
Version: int(b[2]),
Type: int(b[3]),
Addrs: make([]Addr, sysRTAX_MAX),
Flags: int(nativeEndian.Uint32(b[8:12])),
Index: int(nativeEndian.Uint16(b[12:14])),
extOff: w.extOff,
raw: b[:l],
}
a, err := parseLinkAddr(b[w.bodyOff:])
if err != nil {
return nil, err
}
m.Addrs[sysRTAX_IFP] = a
m.Name = a.(*LinkAddr).Name
return m, nil
}
func (w *wireFormat) parseInterfaceAddrMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &InterfaceAddrMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[8:12])),
raw: b[:l],
}
if runtime.GOOS == "netbsd" {
m.Index = int(nativeEndian.Uint16(b[16:18]))
} else {
m.Index = int(nativeEndian.Uint16(b[12:14]))
}
var err error
m.Addrs, err = parseAddrs(uint(nativeEndian.Uint32(b[4:8])), parseKernelInetAddr, b[w.bodyOff:])
if err != nil {
return nil, err
}
return m, nil
}

78
vendor/golang.org/x/net/route/interface_freebsd.go generated vendored Normal file
View File

@@ -0,0 +1,78 @@
// 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.
package route
func (w *wireFormat) parseInterfaceMessage(typ RIBType, b []byte) (Message, error) {
var extOff, bodyOff int
if typ == sysNET_RT_IFLISTL {
if len(b) < 20 {
return nil, errMessageTooShort
}
extOff = int(nativeEndian.Uint16(b[18:20]))
bodyOff = int(nativeEndian.Uint16(b[16:18]))
} else {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
extOff = w.extOff
bodyOff = w.bodyOff
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
attrs := uint(nativeEndian.Uint32(b[4:8]))
if attrs&sysRTA_IFP == 0 {
return nil, nil
}
m := &InterfaceMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[8:12])),
Index: int(nativeEndian.Uint16(b[12:14])),
Addrs: make([]Addr, sysRTAX_MAX),
extOff: extOff,
raw: b[:l],
}
a, err := parseLinkAddr(b[bodyOff:])
if err != nil {
return nil, err
}
m.Addrs[sysRTAX_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 == sysNET_RT_IFLISTL {
if len(b) < 24 {
return nil, errMessageTooShort
}
bodyOff = int(nativeEndian.Uint16(b[16:18]))
} else {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
bodyOff = w.bodyOff
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &InterfaceAddrMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[8:12])),
Index: int(nativeEndian.Uint16(b[12:14])),
raw: b[:l],
}
var err error
m.Addrs, err = parseAddrs(uint(nativeEndian.Uint32(b[4:8])), parseKernelInetAddr, b[bodyOff:])
if err != nil {
return nil, err
}
return m, nil
}

30
vendor/golang.org/x/net/route/interface_multicast.go generated vendored Normal file
View File

@@ -0,0 +1,30 @@
// 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
package route
func (w *wireFormat) parseInterfaceMulticastAddrMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &InterfaceMulticastAddrMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[8:12])),
Index: int(nativeEndian.Uint16(b[12:14])),
raw: b[:l],
}
var err error
m.Addrs, err = parseAddrs(uint(nativeEndian.Uint32(b[4:8])), parseKernelInetAddr, b[w.bodyOff:])
if err != nil {
return nil, err
}
return m, nil
}

83
vendor/golang.org/x/net/route/interface_openbsd.go generated vendored Normal file
View File

@@ -0,0 +1,83 @@
// 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.
package route
func (*wireFormat) parseInterfaceMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < 32 {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
attrs := uint(nativeEndian.Uint32(b[12:16]))
if attrs&sysRTA_IFP == 0 {
return nil, nil
}
m := &InterfaceMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[16:20])),
Index: int(nativeEndian.Uint16(b[6:8])),
Addrs: make([]Addr, sysRTAX_MAX),
raw: b[:l],
}
a, err := parseLinkAddr(b[int(nativeEndian.Uint16(b[4:6])):])
if err != nil {
return nil, err
}
m.Addrs[sysRTAX_IFP] = a
m.Name = a.(*LinkAddr).Name
return m, nil
}
func (*wireFormat) parseInterfaceAddrMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < 24 {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
bodyOff := int(nativeEndian.Uint16(b[4:6]))
m := &InterfaceAddrMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[12:16])),
Index: int(nativeEndian.Uint16(b[6:8])),
raw: b[:l],
}
var err error
m.Addrs, err = parseAddrs(uint(nativeEndian.Uint32(b[12:16])), parseKernelInetAddr, b[bodyOff:])
if err != nil {
return nil, err
}
return m, nil
}
func (*wireFormat) parseInterfaceAnnounceMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < 26 {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &InterfaceAnnounceMessage{
Version: int(b[2]),
Type: int(b[3]),
Index: int(nativeEndian.Uint16(b[6:8])),
What: int(nativeEndian.Uint16(b[8:10])),
raw: b[:l],
}
for i := 0; i < 16; i++ {
if b[10+i] != 0 {
continue
}
m.Name = string(b[10 : 10+i])
break
}
return m, nil
}

70
vendor/golang.org/x/net/route/message.go generated vendored Normal file
View File

@@ -0,0 +1,70 @@
// 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
// A Message represents a routing message.
//
// Note: This interface will be changed to support Marshal method in
// future version.
type Message interface {
// Sys returns operating system-specific information.
Sys() []Sys
}
// A Sys reprensents operating system-specific information.
type Sys interface {
// SysType returns a type of operating system-specific
// information.
SysType() SysType
}
// A SysType represents a type of operating system-specific
// information.
type SysType int
const (
SysMetrics SysType = iota
SysStats
)
// ParseRIB parses b as a routing information base and returns a list
// of routing messages.
func ParseRIB(typ RIBType, b []byte) ([]Message, error) {
if !typ.parseable() {
return nil, errUnsupportedMessage
}
var msgs []Message
nmsgs, nskips := 0, 0
for len(b) > 4 {
nmsgs++
l := int(nativeEndian.Uint16(b[:2]))
if b[2] != sysRTM_VERSION {
b = b[l:]
continue
}
mtyp := int(b[3])
if fn, ok := parseFns[mtyp]; !ok {
nskips++
} else {
m, err := fn(typ, b)
if err != nil {
return nil, err
}
if m == nil {
nskips++
} else {
msgs = append(msgs, m)
}
}
b = b[l:]
}
// We failed to parse any of the messages - version mismatch?
if nmsgs != len(msgs)+nskips {
return nil, errMessageMismatch
}
return msgs, nil
}

74
vendor/golang.org/x/net/route/route.go generated vendored Normal file
View File

@@ -0,0 +1,74 @@
// 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 provides basic functions for the manipulation of
// packet routing facilities on BSD variants.
//
// The package supports any version of Darwin, any version of
// DragonFly BSD, FreeBSD 7 through 11, NetBSD 6 and above, and
// OpenBSD 5.6 and above.
package route
import (
"errors"
"os"
"syscall"
)
var (
errUnsupportedMessage = errors.New("unsupported message")
errMessageMismatch = errors.New("message mismatch")
errMessageTooShort = errors.New("message too short")
errInvalidMessage = errors.New("invalid message")
errInvalidAddr = errors.New("invalid address")
)
// A RouteMessage represents a message conveying an address prefix, a
// nexthop address and an output interface.
type RouteMessage struct {
Version int // message version
Type int // message type
Flags int // route flags
Index int // interface index when atatched
Addrs []Addr // addresses
extOff int // offset of header extension
raw []byte // raw message
}
// A RIBType reprensents a type of routing information base.
type RIBType int
const (
RIBTypeRoute RIBType = syscall.NET_RT_DUMP
RIBTypeInterface RIBType = syscall.NET_RT_IFLIST
)
// FetchRIB fetches a routing information base from the operating
// system.
//
// The provided af must be an address family.
//
// The provided arg must be a RIBType-specific argument.
// When RIBType is related to routes, arg might be a set of route
// flags. When RIBType is related to network interfaces, arg might be
// an interface index or a set of interface flags. In most cases, zero
// means a wildcard.
func FetchRIB(af int, typ RIBType, arg int) ([]byte, error) {
mib := [6]int32{sysCTL_NET, sysAF_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)
}
if n == 0 {
return nil, nil
}
b := make([]byte, n)
if err := sysctl(mib[:], &b[0], &n, nil, 0); err != nil {
return nil, os.NewSyscallError("sysctl", err)
}
return b[:n], nil
}

31
vendor/golang.org/x/net/route/route_classic.go generated vendored Normal file
View File

@@ -0,0 +1,31 @@
// 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
package route
func (w *wireFormat) parseRouteMessage(typ RIBType, b []byte) (Message, error) {
if len(b) < w.bodyOff {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &RouteMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[8:12])),
Index: int(nativeEndian.Uint16(b[4:6])),
extOff: w.extOff,
raw: b[:l],
}
var err error
m.Addrs, err = parseAddrs(uint(nativeEndian.Uint32(b[12:16])), parseKernelInetAddr, b[w.bodyOff:])
if err != nil {
return nil, err
}
return m, nil
}

28
vendor/golang.org/x/net/route/route_openbsd.go generated vendored Normal file
View File

@@ -0,0 +1,28 @@
// 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.
package route
func (*wireFormat) parseRouteMessage(_ RIBType, b []byte) (Message, error) {
if len(b) < 40 {
return nil, errMessageTooShort
}
l := int(nativeEndian.Uint16(b[:2]))
if len(b) < l {
return nil, errInvalidMessage
}
m := &RouteMessage{
Version: int(b[2]),
Type: int(b[3]),
Flags: int(nativeEndian.Uint32(b[16:20])),
Index: int(nativeEndian.Uint16(b[6:8])),
raw: b[:l],
}
as, err := parseAddrs(uint(nativeEndian.Uint32(b[12:16])), parseKernelInetAddr, b[int(nativeEndian.Uint16(b[4:6])):])
if err != nil {
return nil, err
}
m.Addrs = as
return m, nil
}

40
vendor/golang.org/x/net/route/sys.go generated vendored Normal file
View File

@@ -0,0 +1,40 @@
// 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 "unsafe"
var (
nativeEndian binaryByteOrder
kernelAlign int
parseFns map[int]parseFn
)
func init() {
i := uint32(1)
b := (*[4]byte)(unsafe.Pointer(&i))
if b[0] == 1 {
nativeEndian = littleEndian
} else {
nativeEndian = bigEndian
}
kernelAlign, parseFns = probeRoutingStack()
}
func roundup(l int) int {
if l == 0 {
return kernelAlign
}
return (l + kernelAlign - 1) & ^(kernelAlign - 1)
}
type parseFn func(RIBType, []byte) (Message, error)
type wireFormat struct {
extOff int // offset of header extension
bodyOff int // offset of message body
}

80
vendor/golang.org/x/net/route/sys_darwin.go generated vendored Normal file
View File

@@ -0,0 +1,80 @@
// 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.
package route
func (typ RIBType) parseable() bool {
switch typ {
case sysNET_RT_STAT, sysNET_RT_TRASH:
return false
default:
return true
}
}
// A RouteMetrics represents route metrics.
type RouteMetrics struct {
PathMTU int // path maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint32(m.raw[m.extOff+4 : m.extOff+8])),
},
}
}
// A InterfaceMetrics represents interface metrics.
type InterfaceMetrics struct {
Type int // interface type
MTU int // maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (imx *InterfaceMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *InterfaceMessage) Sys() []Sys {
return []Sys{
&InterfaceMetrics{
Type: int(m.raw[m.extOff]),
MTU: int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
},
}
}
func probeRoutingStack() (int, map[int]parseFn) {
rtm := &wireFormat{extOff: 36, bodyOff: sizeofRtMsghdrDarwin15}
rtm2 := &wireFormat{extOff: 36, bodyOff: sizeofRtMsghdr2Darwin15}
ifm := &wireFormat{extOff: 16, bodyOff: sizeofIfMsghdrDarwin15}
ifm2 := &wireFormat{extOff: 32, bodyOff: sizeofIfMsghdr2Darwin15}
ifam := &wireFormat{extOff: sizeofIfaMsghdrDarwin15, bodyOff: sizeofIfaMsghdrDarwin15}
ifmam := &wireFormat{extOff: sizeofIfmaMsghdrDarwin15, bodyOff: sizeofIfmaMsghdrDarwin15}
ifmam2 := &wireFormat{extOff: sizeofIfmaMsghdr2Darwin15, bodyOff: sizeofIfmaMsghdr2Darwin15}
// Darwin kernels require 32-bit aligned access to routing facilities.
return 4, map[int]parseFn{
sysRTM_ADD: rtm.parseRouteMessage,
sysRTM_DELETE: rtm.parseRouteMessage,
sysRTM_CHANGE: rtm.parseRouteMessage,
sysRTM_GET: rtm.parseRouteMessage,
sysRTM_LOSING: rtm.parseRouteMessage,
sysRTM_REDIRECT: rtm.parseRouteMessage,
sysRTM_MISS: rtm.parseRouteMessage,
sysRTM_LOCK: rtm.parseRouteMessage,
sysRTM_RESOLVE: rtm.parseRouteMessage,
sysRTM_NEWADDR: ifam.parseInterfaceAddrMessage,
sysRTM_DELADDR: ifam.parseInterfaceAddrMessage,
sysRTM_IFINFO: ifm.parseInterfaceMessage,
sysRTM_NEWMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_DELMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_IFINFO2: ifm2.parseInterfaceMessage,
sysRTM_NEWMADDR2: ifmam2.parseInterfaceMulticastAddrMessage,
sysRTM_GET2: rtm2.parseRouteMessage,
}
}

71
vendor/golang.org/x/net/route/sys_dragonfly.go generated vendored Normal file
View File

@@ -0,0 +1,71 @@
// 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.
package route
import "unsafe"
func (typ RIBType) parseable() bool { return true }
// A RouteMetrics represents route metrics.
type RouteMetrics struct {
PathMTU int // path maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint64(m.raw[m.extOff+8 : m.extOff+16])),
},
}
}
// A InterfaceMetrics represents interface metrics.
type InterfaceMetrics struct {
Type int // interface type
MTU int // maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (imx *InterfaceMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *InterfaceMessage) Sys() []Sys {
return []Sys{
&InterfaceMetrics{
Type: int(m.raw[m.extOff]),
MTU: int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
},
}
}
func probeRoutingStack() (int, map[int]parseFn) {
var p uintptr
rtm := &wireFormat{extOff: 40, bodyOff: sizeofRtMsghdrDragonFlyBSD4}
ifm := &wireFormat{extOff: 16, bodyOff: sizeofIfMsghdrDragonFlyBSD4}
ifam := &wireFormat{extOff: sizeofIfaMsghdrDragonFlyBSD4, bodyOff: sizeofIfaMsghdrDragonFlyBSD4}
ifmam := &wireFormat{extOff: sizeofIfmaMsghdrDragonFlyBSD4, bodyOff: sizeofIfmaMsghdrDragonFlyBSD4}
ifanm := &wireFormat{extOff: sizeofIfAnnouncemsghdrDragonFlyBSD4, bodyOff: sizeofIfAnnouncemsghdrDragonFlyBSD4}
return int(unsafe.Sizeof(p)), map[int]parseFn{
sysRTM_ADD: rtm.parseRouteMessage,
sysRTM_DELETE: rtm.parseRouteMessage,
sysRTM_CHANGE: rtm.parseRouteMessage,
sysRTM_GET: rtm.parseRouteMessage,
sysRTM_LOSING: rtm.parseRouteMessage,
sysRTM_REDIRECT: rtm.parseRouteMessage,
sysRTM_MISS: rtm.parseRouteMessage,
sysRTM_LOCK: rtm.parseRouteMessage,
sysRTM_RESOLVE: rtm.parseRouteMessage,
sysRTM_NEWADDR: ifam.parseInterfaceAddrMessage,
sysRTM_DELADDR: ifam.parseInterfaceAddrMessage,
sysRTM_IFINFO: ifm.parseInterfaceMessage,
sysRTM_NEWMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_DELMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_IFANNOUNCE: ifanm.parseInterfaceAnnounceMessage,
}
}

150
vendor/golang.org/x/net/route/sys_freebsd.go generated vendored Normal file
View File

@@ -0,0 +1,150 @@
// 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.
package route
import (
"syscall"
"unsafe"
)
func (typ RIBType) parseable() bool { return true }
// A RouteMetrics represents route metrics.
type RouteMetrics struct {
PathMTU int // path maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
if kernelAlign == 8 {
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint64(m.raw[m.extOff+8 : m.extOff+16])),
},
}
}
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint32(m.raw[m.extOff+4 : m.extOff+8])),
},
}
}
// A InterfaceMetrics represents interface metrics.
type InterfaceMetrics struct {
Type int // interface type
MTU int // maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (imx *InterfaceMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *InterfaceMessage) Sys() []Sys {
return []Sys{
&InterfaceMetrics{
Type: int(m.raw[m.extOff]),
MTU: int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
},
}
}
func probeRoutingStack() (int, map[int]parseFn) {
var p uintptr
wordSize := int(unsafe.Sizeof(p))
align := int(unsafe.Sizeof(p))
// In the case of kern.supported_archs="amd64 i386", we need
// to know the underlying kernel's architecture because the
// alignment for routing facilities are set at the build time
// of the kernel.
conf, _ := syscall.Sysctl("kern.conftxt")
for i, j := 0, 0; j < len(conf); j++ {
if conf[j] != '\n' {
continue
}
s := conf[i:j]
i = j + 1
if len(s) > len("machine") && s[:len("machine")] == "machine" {
s = s[len("machine"):]
for k := 0; k < len(s); k++ {
if s[k] == ' ' || s[k] == '\t' {
s = s[1:]
}
break
}
if s == "amd64" {
align = 8
}
break
}
}
var rtm, ifm, ifam, ifmam, ifanm *wireFormat
if align != wordSize { // 386 emulation on amd64
rtm = &wireFormat{extOff: sizeofRtMsghdrFreeBSD10Emu - sizeofRtMetricsFreeBSD10Emu, bodyOff: sizeofRtMsghdrFreeBSD10Emu}
ifm = &wireFormat{extOff: 16}
ifam = &wireFormat{extOff: sizeofIfaMsghdrFreeBSD10Emu, bodyOff: sizeofIfaMsghdrFreeBSD10Emu}
ifmam = &wireFormat{extOff: sizeofIfmaMsghdrFreeBSD10Emu, bodyOff: sizeofIfmaMsghdrFreeBSD10Emu}
ifanm = &wireFormat{extOff: sizeofIfAnnouncemsghdrFreeBSD10Emu, bodyOff: sizeofIfAnnouncemsghdrFreeBSD10Emu}
} else {
rtm = &wireFormat{extOff: sizeofRtMsghdrFreeBSD10 - sizeofRtMetricsFreeBSD10, bodyOff: sizeofRtMsghdrFreeBSD10}
ifm = &wireFormat{extOff: 16}
ifam = &wireFormat{extOff: sizeofIfaMsghdrFreeBSD10, bodyOff: sizeofIfaMsghdrFreeBSD10}
ifmam = &wireFormat{extOff: sizeofIfmaMsghdrFreeBSD10, bodyOff: sizeofIfmaMsghdrFreeBSD10}
ifanm = &wireFormat{extOff: sizeofIfAnnouncemsghdrFreeBSD10, bodyOff: sizeofIfAnnouncemsghdrFreeBSD10}
}
rel, _ := syscall.SysctlUint32("kern.osreldate")
switch {
case rel < 800000:
if align != wordSize { // 386 emulation on amd64
ifm.bodyOff = sizeofIfMsghdrFreeBSD7Emu
} else {
ifm.bodyOff = sizeofIfMsghdrFreeBSD7
}
case 800000 <= rel && rel < 900000:
if align != wordSize { // 386 emulation on amd64
ifm.bodyOff = sizeofIfMsghdrFreeBSD8Emu
} else {
ifm.bodyOff = sizeofIfMsghdrFreeBSD8
}
case 900000 <= rel && rel < 1000000:
if align != wordSize { // 386 emulation on amd64
ifm.bodyOff = sizeofIfMsghdrFreeBSD9Emu
} else {
ifm.bodyOff = sizeofIfMsghdrFreeBSD9
}
case 1000000 <= rel && rel < 1100000:
if align != wordSize { // 386 emulation on amd64
ifm.bodyOff = sizeofIfMsghdrFreeBSD10Emu
} else {
ifm.bodyOff = sizeofIfMsghdrFreeBSD10
}
default:
if align != wordSize { // 386 emulation on amd64
ifm.bodyOff = sizeofIfMsghdrFreeBSD11Emu
} else {
ifm.bodyOff = sizeofIfMsghdrFreeBSD11
}
}
return align, map[int]parseFn{
sysRTM_ADD: rtm.parseRouteMessage,
sysRTM_DELETE: rtm.parseRouteMessage,
sysRTM_CHANGE: rtm.parseRouteMessage,
sysRTM_GET: rtm.parseRouteMessage,
sysRTM_LOSING: rtm.parseRouteMessage,
sysRTM_REDIRECT: rtm.parseRouteMessage,
sysRTM_MISS: rtm.parseRouteMessage,
sysRTM_LOCK: rtm.parseRouteMessage,
sysRTM_RESOLVE: rtm.parseRouteMessage,
sysRTM_NEWADDR: ifam.parseInterfaceAddrMessage,
sysRTM_DELADDR: ifam.parseInterfaceAddrMessage,
sysRTM_IFINFO: ifm.parseInterfaceMessage,
sysRTM_NEWMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_DELMADDR: ifmam.parseInterfaceMulticastAddrMessage,
sysRTM_IFANNOUNCE: ifanm.parseInterfaceAnnounceMessage,
}
}

67
vendor/golang.org/x/net/route/sys_netbsd.go generated vendored Normal file
View File

@@ -0,0 +1,67 @@
// 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.
package route
func (typ RIBType) parseable() bool { return true }
// A RouteMetrics represents route metrics.
type RouteMetrics struct {
PathMTU int // path maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint64(m.raw[m.extOff+8 : m.extOff+16])),
},
}
}
// A InterfaceMetrics represents interface metrics.
type InterfaceMetrics struct {
Type int // interface type
MTU int // maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (imx *InterfaceMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *InterfaceMessage) Sys() []Sys {
return []Sys{
&InterfaceMetrics{
Type: int(m.raw[m.extOff]),
MTU: int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
},
}
}
func probeRoutingStack() (int, map[int]parseFn) {
rtm := &wireFormat{extOff: 40, bodyOff: sizeofRtMsghdrNetBSD7}
ifm := &wireFormat{extOff: 16, bodyOff: sizeofIfMsghdrNetBSD7}
ifam := &wireFormat{extOff: sizeofIfaMsghdrNetBSD7, bodyOff: sizeofIfaMsghdrNetBSD7}
ifanm := &wireFormat{extOff: sizeofIfAnnouncemsghdrNetBSD7, bodyOff: sizeofIfAnnouncemsghdrNetBSD7}
// NetBSD 6 and above kernels require 64-bit aligned access to
// routing facilities.
return 8, map[int]parseFn{
sysRTM_ADD: rtm.parseRouteMessage,
sysRTM_DELETE: rtm.parseRouteMessage,
sysRTM_CHANGE: rtm.parseRouteMessage,
sysRTM_GET: rtm.parseRouteMessage,
sysRTM_LOSING: rtm.parseRouteMessage,
sysRTM_REDIRECT: rtm.parseRouteMessage,
sysRTM_MISS: rtm.parseRouteMessage,
sysRTM_LOCK: rtm.parseRouteMessage,
sysRTM_RESOLVE: rtm.parseRouteMessage,
sysRTM_NEWADDR: ifam.parseInterfaceAddrMessage,
sysRTM_DELADDR: ifam.parseInterfaceAddrMessage,
sysRTM_IFANNOUNCE: ifanm.parseInterfaceAnnounceMessage,
sysRTM_IFINFO: ifm.parseInterfaceMessage,
}
}

72
vendor/golang.org/x/net/route/sys_openbsd.go generated vendored Normal file
View File

@@ -0,0 +1,72 @@
// 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.
package route
import "unsafe"
func (typ RIBType) parseable() bool {
switch typ {
case sysNET_RT_STATS, sysNET_RT_TABLE:
return false
default:
return true
}
}
// A RouteMetrics represents route metrics.
type RouteMetrics struct {
PathMTU int // path maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
return []Sys{
&RouteMetrics{
PathMTU: int(nativeEndian.Uint32(m.raw[60:64])),
},
}
}
// A InterfaceMetrics represents interface metrics.
type InterfaceMetrics struct {
Type int // interface type
MTU int // maximum transmission unit
}
// SysType implements the SysType method of Sys interface.
func (imx *InterfaceMetrics) SysType() SysType { return SysMetrics }
// Sys implements the Sys method of Message interface.
func (m *InterfaceMessage) Sys() []Sys {
return []Sys{
&InterfaceMetrics{
Type: int(m.raw[24]),
MTU: int(nativeEndian.Uint32(m.raw[28:32])),
},
}
}
func probeRoutingStack() (int, map[int]parseFn) {
var p uintptr
nooff := &wireFormat{extOff: -1, bodyOff: -1}
return int(unsafe.Sizeof(p)), map[int]parseFn{
sysRTM_ADD: nooff.parseRouteMessage,
sysRTM_DELETE: nooff.parseRouteMessage,
sysRTM_CHANGE: nooff.parseRouteMessage,
sysRTM_GET: nooff.parseRouteMessage,
sysRTM_LOSING: nooff.parseRouteMessage,
sysRTM_REDIRECT: nooff.parseRouteMessage,
sysRTM_MISS: nooff.parseRouteMessage,
sysRTM_LOCK: nooff.parseRouteMessage,
sysRTM_RESOLVE: nooff.parseRouteMessage,
sysRTM_NEWADDR: nooff.parseInterfaceAddrMessage,
sysRTM_DELADDR: nooff.parseInterfaceAddrMessage,
sysRTM_IFINFO: nooff.parseInterfaceMessage,
sysRTM_IFANNOUNCE: nooff.parseInterfaceAnnounceMessage,
}
}

33
vendor/golang.org/x/net/route/syscall.go generated vendored Normal file
View File

@@ -0,0 +1,33 @@
// 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 (
"syscall"
"unsafe"
)
// TODO: replace with runtime.KeepAlive when available
//go:noescape
func keepAlive(p unsafe.Pointer)
var zero uintptr
func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
var p unsafe.Pointer
if len(mib) > 0 {
p = unsafe.Pointer(&mib[0])
} else {
p = unsafe.Pointer(&zero)
}
_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
keepAlive(p)
if errno != 0 {
return error(errno)
}
return nil
}

8
vendor/golang.org/x/net/route/syscall.s generated vendored Normal file
View File

@@ -0,0 +1,8 @@
// 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.
#include "textflag.h"
TEXT ·keepAlive(SB),NOSPLIT,$0
RET

93
vendor/golang.org/x/net/route/zsys_darwin.go generated vendored Normal file
View File

@@ -0,0 +1,93 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_darwin.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x1e
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_STAT = 0x4
sysNET_RT_TRASH = 0x5
sysNET_RT_IFLIST2 = 0x6
sysNET_RT_DUMP2 = 0x7
sysNET_RT_MAXID = 0xa
)
const (
sysCTL_MAXNAME = 0xc
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_MAXID = 0x9
)
const (
sysRTM_VERSION = 0x5
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_OLDADD = 0x9
sysRTM_OLDDEL = 0xa
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_NEWMADDR = 0xf
sysRTM_DELMADDR = 0x10
sysRTM_IFINFO2 = 0x12
sysRTM_NEWMADDR2 = 0x13
sysRTM_GET2 = 0x14
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_MAX = 0x8
)
const (
sizeofIfMsghdrDarwin15 = 0x70
sizeofIfaMsghdrDarwin15 = 0x14
sizeofIfmaMsghdrDarwin15 = 0x10
sizeofIfMsghdr2Darwin15 = 0xa0
sizeofIfmaMsghdr2Darwin15 = 0x14
sizeofIfDataDarwin15 = 0x60
sizeofIfData64Darwin15 = 0x80
sizeofRtMsghdrDarwin15 = 0x5c
sizeofRtMsghdr2Darwin15 = 0x5c
sizeofRtMetricsDarwin15 = 0x38
)

92
vendor/golang.org/x/net/route/zsys_dragonfly.go generated vendored Normal file
View File

@@ -0,0 +1,92 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_dragonfly.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x1c
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_MAXID = 0x4
)
const (
sysCTL_MAXNAME = 0xc
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_P1003_1B = 0x9
sysCTL_LWKT = 0xa
sysCTL_MAXID = 0xb
)
const (
sysRTM_VERSION = 0x6
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_OLDADD = 0x9
sysRTM_OLDDEL = 0xa
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_NEWMADDR = 0xf
sysRTM_DELMADDR = 0x10
sysRTM_IFANNOUNCE = 0x11
sysRTM_IEEE80211 = 0x12
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTA_MPLS1 = 0x100
sysRTA_MPLS2 = 0x200
sysRTA_MPLS3 = 0x400
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_MPLS1 = 0x8
sysRTAX_MPLS2 = 0x9
sysRTAX_MPLS3 = 0xa
sysRTAX_MAX = 0xb
)
const (
sizeofIfMsghdrDragonFlyBSD4 = 0xb0
sizeofIfaMsghdrDragonFlyBSD4 = 0x14
sizeofIfmaMsghdrDragonFlyBSD4 = 0x10
sizeofIfAnnouncemsghdrDragonFlyBSD4 = 0x18
sizeofRtMsghdrDragonFlyBSD4 = 0x98
sizeofRtMetricsDragonFlyBSD4 = 0x70
)

120
vendor/golang.org/x/net/route/zsys_freebsd_386.go generated vendored Normal file
View File

@@ -0,0 +1,120 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_freebsd.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x1c
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_IFMALIST = 0x4
sysNET_RT_IFLISTL = 0x5
)
const (
sysCTL_MAXNAME = 0x18
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_P1003_1B = 0x9
)
const (
sysRTM_VERSION = 0x5
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_NEWMADDR = 0xf
sysRTM_DELMADDR = 0x10
sysRTM_IFANNOUNCE = 0x11
sysRTM_IEEE80211 = 0x12
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_MAX = 0x8
)
const (
sizeofIfMsghdrlFreeBSD10 = 0x68
sizeofIfaMsghdrFreeBSD10 = 0x14
sizeofIfaMsghdrlFreeBSD10 = 0x6c
sizeofIfmaMsghdrFreeBSD10 = 0x10
sizeofIfAnnouncemsghdrFreeBSD10 = 0x18
sizeofRtMsghdrFreeBSD10 = 0x5c
sizeofRtMetricsFreeBSD10 = 0x38
sizeofIfMsghdrFreeBSD7 = 0x60
sizeofIfMsghdrFreeBSD8 = 0x60
sizeofIfMsghdrFreeBSD9 = 0x60
sizeofIfMsghdrFreeBSD10 = 0x64
sizeofIfMsghdrFreeBSD11 = 0xa8
sizeofIfDataFreeBSD7 = 0x50
sizeofIfDataFreeBSD8 = 0x50
sizeofIfDataFreeBSD9 = 0x50
sizeofIfDataFreeBSD10 = 0x54
sizeofIfDataFreeBSD11 = 0x98
// MODIFIED BY HAND FOR 386 EMULATION ON AMD64
// 386 EMULATION USES THE UNDERLYING RAW DATA LAYOUT
sizeofIfMsghdrlFreeBSD10Emu = 0xb0
sizeofIfaMsghdrFreeBSD10Emu = 0x14
sizeofIfaMsghdrlFreeBSD10Emu = 0xb0
sizeofIfmaMsghdrFreeBSD10Emu = 0x10
sizeofIfAnnouncemsghdrFreeBSD10Emu = 0x18
sizeofRtMsghdrFreeBSD10Emu = 0x98
sizeofRtMetricsFreeBSD10Emu = 0x70
sizeofIfMsghdrFreeBSD7Emu = 0xa8
sizeofIfMsghdrFreeBSD8Emu = 0xa8
sizeofIfMsghdrFreeBSD9Emu = 0xa8
sizeofIfMsghdrFreeBSD10Emu = 0xa8
sizeofIfMsghdrFreeBSD11Emu = 0xa8
sizeofIfDataFreeBSD7Emu = 0x98
sizeofIfDataFreeBSD8Emu = 0x98
sizeofIfDataFreeBSD9Emu = 0x98
sizeofIfDataFreeBSD10Emu = 0x98
sizeofIfDataFreeBSD11Emu = 0x98
)

117
vendor/golang.org/x/net/route/zsys_freebsd_amd64.go generated vendored Normal file
View File

@@ -0,0 +1,117 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_freebsd.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x1c
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_IFMALIST = 0x4
sysNET_RT_IFLISTL = 0x5
)
const (
sysCTL_MAXNAME = 0x18
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_P1003_1B = 0x9
)
const (
sysRTM_VERSION = 0x5
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_NEWMADDR = 0xf
sysRTM_DELMADDR = 0x10
sysRTM_IFANNOUNCE = 0x11
sysRTM_IEEE80211 = 0x12
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_MAX = 0x8
)
const (
sizeofIfMsghdrlFreeBSD10 = 0xb0
sizeofIfaMsghdrFreeBSD10 = 0x14
sizeofIfaMsghdrlFreeBSD10 = 0xb0
sizeofIfmaMsghdrFreeBSD10 = 0x10
sizeofIfAnnouncemsghdrFreeBSD10 = 0x18
sizeofRtMsghdrFreeBSD10 = 0x98
sizeofRtMetricsFreeBSD10 = 0x70
sizeofIfMsghdrFreeBSD7 = 0xa8
sizeofIfMsghdrFreeBSD8 = 0xa8
sizeofIfMsghdrFreeBSD9 = 0xa8
sizeofIfMsghdrFreeBSD10 = 0xa8
sizeofIfMsghdrFreeBSD11 = 0xa8
sizeofIfDataFreeBSD7 = 0x98
sizeofIfDataFreeBSD8 = 0x98
sizeofIfDataFreeBSD9 = 0x98
sizeofIfDataFreeBSD10 = 0x98
sizeofIfDataFreeBSD11 = 0x98
sizeofIfMsghdrlFreeBSD10Emu = 0xb0
sizeofIfaMsghdrFreeBSD10Emu = 0x14
sizeofIfaMsghdrlFreeBSD10Emu = 0xb0
sizeofIfmaMsghdrFreeBSD10Emu = 0x10
sizeofIfAnnouncemsghdrFreeBSD10Emu = 0x18
sizeofRtMsghdrFreeBSD10Emu = 0x98
sizeofRtMetricsFreeBSD10Emu = 0x70
sizeofIfMsghdrFreeBSD7Emu = 0xa8
sizeofIfMsghdrFreeBSD8Emu = 0xa8
sizeofIfMsghdrFreeBSD9Emu = 0xa8
sizeofIfMsghdrFreeBSD10Emu = 0xa8
sizeofIfMsghdrFreeBSD11Emu = 0xa8
sizeofIfDataFreeBSD7Emu = 0x98
sizeofIfDataFreeBSD8Emu = 0x98
sizeofIfDataFreeBSD9Emu = 0x98
sizeofIfDataFreeBSD10Emu = 0x98
sizeofIfDataFreeBSD11Emu = 0x98
)

117
vendor/golang.org/x/net/route/zsys_freebsd_arm.go generated vendored Normal file
View File

@@ -0,0 +1,117 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_freebsd.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x1c
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_IFMALIST = 0x4
sysNET_RT_IFLISTL = 0x5
)
const (
sysCTL_MAXNAME = 0x18
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_P1003_1B = 0x9
)
const (
sysRTM_VERSION = 0x5
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_NEWMADDR = 0xf
sysRTM_DELMADDR = 0x10
sysRTM_IFANNOUNCE = 0x11
sysRTM_IEEE80211 = 0x12
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_MAX = 0x8
)
const (
sizeofIfMsghdrlFreeBSD10 = 0x68
sizeofIfaMsghdrFreeBSD10 = 0x14
sizeofIfaMsghdrlFreeBSD10 = 0x6c
sizeofIfmaMsghdrFreeBSD10 = 0x10
sizeofIfAnnouncemsghdrFreeBSD10 = 0x18
sizeofRtMsghdrFreeBSD10 = 0x5c
sizeofRtMetricsFreeBSD10 = 0x38
sizeofIfMsghdrFreeBSD7 = 0x70
sizeofIfMsghdrFreeBSD8 = 0x70
sizeofIfMsghdrFreeBSD9 = 0x70
sizeofIfMsghdrFreeBSD10 = 0x70
sizeofIfMsghdrFreeBSD11 = 0xa8
sizeofIfDataFreeBSD7 = 0x60
sizeofIfDataFreeBSD8 = 0x60
sizeofIfDataFreeBSD9 = 0x60
sizeofIfDataFreeBSD10 = 0x60
sizeofIfDataFreeBSD11 = 0x98
sizeofIfMsghdrlFreeBSD10Emu = 0x68
sizeofIfaMsghdrFreeBSD10Emu = 0x14
sizeofIfaMsghdrlFreeBSD10Emu = 0x6c
sizeofIfmaMsghdrFreeBSD10Emu = 0x10
sizeofIfAnnouncemsghdrFreeBSD10Emu = 0x18
sizeofRtMsghdrFreeBSD10Emu = 0x5c
sizeofRtMetricsFreeBSD10Emu = 0x38
sizeofIfMsghdrFreeBSD7Emu = 0x70
sizeofIfMsghdrFreeBSD8Emu = 0x70
sizeofIfMsghdrFreeBSD9Emu = 0x70
sizeofIfMsghdrFreeBSD10Emu = 0x70
sizeofIfMsghdrFreeBSD11Emu = 0xa8
sizeofIfDataFreeBSD7Emu = 0x60
sizeofIfDataFreeBSD8Emu = 0x60
sizeofIfDataFreeBSD9Emu = 0x60
sizeofIfDataFreeBSD10Emu = 0x60
sizeofIfDataFreeBSD11Emu = 0x98
)

91
vendor/golang.org/x/net/route/zsys_netbsd.go generated vendored Normal file
View File

@@ -0,0 +1,91 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_netbsd.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x22
sysAF_LINK = 0x12
sysAF_INET6 = 0x18
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x5
sysNET_RT_MAXID = 0x6
)
const (
sysCTL_MAXNAME = 0xc
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_VFS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_USER = 0x8
sysCTL_DDB = 0x9
sysCTL_PROC = 0xa
sysCTL_VENDOR = 0xb
sysCTL_EMUL = 0xc
sysCTL_SECURITY = 0xd
sysCTL_MAXID = 0xe
)
const (
sysRTM_VERSION = 0x4
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_OLDADD = 0x9
sysRTM_OLDDEL = 0xa
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFANNOUNCE = 0x10
sysRTM_IEEE80211 = 0x11
sysRTM_SETGATE = 0x12
sysRTM_LLINFO_UPD = 0x13
sysRTM_IFINFO = 0x14
sysRTM_CHGADDR = 0x15
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTA_TAG = 0x100
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_TAG = 0x8
sysRTAX_MAX = 0x9
)
const (
sizeofIfMsghdrNetBSD7 = 0x98
sizeofIfaMsghdrNetBSD7 = 0x18
sizeofIfAnnouncemsghdrNetBSD7 = 0x18
sizeofRtMsghdrNetBSD7 = 0x78
sizeofRtMetricsNetBSD7 = 0x50
)

80
vendor/golang.org/x/net/route/zsys_openbsd.go generated vendored Normal file
View File

@@ -0,0 +1,80 @@
// Created by cgo -godefs - DO NOT EDIT
// cgo -godefs defs_openbsd.go
package route
const (
sysAF_UNSPEC = 0x0
sysAF_INET = 0x2
sysAF_ROUTE = 0x11
sysAF_LINK = 0x12
sysAF_INET6 = 0x18
sysNET_RT_DUMP = 0x1
sysNET_RT_FLAGS = 0x2
sysNET_RT_IFLIST = 0x3
sysNET_RT_STATS = 0x4
sysNET_RT_TABLE = 0x5
sysNET_RT_IFNAMES = 0x6
sysNET_RT_MAXID = 0x7
)
const (
sysCTL_MAXNAME = 0xc
sysCTL_UNSPEC = 0x0
sysCTL_KERN = 0x1
sysCTL_VM = 0x2
sysCTL_FS = 0x3
sysCTL_NET = 0x4
sysCTL_DEBUG = 0x5
sysCTL_HW = 0x6
sysCTL_MACHDEP = 0x7
sysCTL_DDB = 0x9
sysCTL_VFS = 0xa
sysCTL_MAXID = 0xb
)
const (
sysRTM_VERSION = 0x5
sysRTM_ADD = 0x1
sysRTM_DELETE = 0x2
sysRTM_CHANGE = 0x3
sysRTM_GET = 0x4
sysRTM_LOSING = 0x5
sysRTM_REDIRECT = 0x6
sysRTM_MISS = 0x7
sysRTM_LOCK = 0x8
sysRTM_RESOLVE = 0xb
sysRTM_NEWADDR = 0xc
sysRTM_DELADDR = 0xd
sysRTM_IFINFO = 0xe
sysRTM_IFANNOUNCE = 0xf
sysRTM_DESYNC = 0x10
sysRTA_DST = 0x1
sysRTA_GATEWAY = 0x2
sysRTA_NETMASK = 0x4
sysRTA_GENMASK = 0x8
sysRTA_IFP = 0x10
sysRTA_IFA = 0x20
sysRTA_AUTHOR = 0x40
sysRTA_BRD = 0x80
sysRTA_SRC = 0x100
sysRTA_SRCMASK = 0x200
sysRTA_LABEL = 0x400
sysRTAX_DST = 0x0
sysRTAX_GATEWAY = 0x1
sysRTAX_NETMASK = 0x2
sysRTAX_GENMASK = 0x3
sysRTAX_IFP = 0x4
sysRTAX_IFA = 0x5
sysRTAX_AUTHOR = 0x6
sysRTAX_BRD = 0x7
sysRTAX_SRC = 0x8
sysRTAX_SRCMASK = 0x9
sysRTAX_LABEL = 0xa
sysRTAX_MAX = 0xb
)