route

type Addr ¶

type Addr interface {
	// Family returns an address family.
	Family() int
}

An Addr represents an address associated with packet routing.

type DefaultAddr ¶

type DefaultAddr struct {
	Raw []byte // raw format of address
	// contains filtered or unexported fields
}

A DefaultAddr represents an address of various operating system-specific features.

func (a *DefaultAddr) Family() int

type Inet4Addr ¶

type Inet4Addr struct {
	IP [4]byte // IP address
}

An Inet4Addr represents an internet address for IPv4.

func (a *Inet4Addr) Family() int

type Inet6Addr ¶

type Inet6Addr struct {
	IP     [16]byte // IP address
	ZoneID int      // zone identifier
}

An Inet6Addr represents an internet address for IPv6.

func (a *Inet6Addr) Family() int

type InterfaceAddrMessage ¶

type InterfaceAddrMessage struct {
	Version int    // message version
	Type    int    // message type
	Flags   int    // interface flags
	Index   int    // interface index
	Addrs   []Addr // addresses
	// contains filtered or unexported fields
}

An InterfaceAddrMessage represents an interface address message.

func (m *InterfaceAddrMessage) Sys() []Sys

type InterfaceAnnounceMessage ¶

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
	// contains filtered or unexported fields
}

An InterfaceAnnounceMessage represents an interface announcement message.

func (m *InterfaceAnnounceMessage) Sys() []Sys

type InterfaceMessage ¶

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
	// contains filtered or unexported fields
}

An InterfaceMessage represents an interface message.

func (m *InterfaceMessage) Sys() []Sys

type InterfaceMetrics ¶

type InterfaceMetrics struct {
	Type int // interface type
	MTU  int // maximum transmission unit
}

InterfaceMetrics represents interface metrics.

func (imx *InterfaceMetrics) SysType() SysType

type InterfaceMulticastAddrMessage ¶

type InterfaceMulticastAddrMessage struct {
	Version int    // message version
	Type    int    // message type
	Flags   int    // interface flags
	Index   int    // interface index
	Addrs   []Addr // addresses
	// contains filtered or unexported fields
}

An InterfaceMulticastAddrMessage represents an interface multicast address message.

func (m *InterfaceMulticastAddrMessage) Sys() []Sys

type LinkAddr ¶

type LinkAddr struct {
	Index int    // interface index when attached
	Name  string // interface name when attached
	Addr  []byte // link-layer address when attached
}

A LinkAddr represents a link-layer address.

func (a *LinkAddr) Family() int

type Message ¶

type Message interface {
	// Sys returns operating system-specific information.
	Sys() []Sys
}

A Message represents a routing message.

func ParseRIB(typ RIBType, b []byte) ([]Message, error)

type RIBType ¶

type RIBType int

A RIBType represents a type of routing information base.

const (
	RIBTypeRoute     RIBType = syscall.NET_RT_DUMP
	RIBTypeInterface RIBType = syscall.NET_RT_IFLIST
)

type RouteMessage ¶

type RouteMessage struct {
	Version int     // message version
	Type    int     // message type
	Flags   int     // route flags
	Index   int     // interface index when attached
	ID      uintptr // sender's identifier; usually process ID
	Seq     int     // sequence number
	Err     error   // error on requested operation
	Addrs   []Addr  // addresses
	// contains filtered or unexported fields
}

A RouteMessage represents a message conveying an address prefix, a nexthop address and an output interface.

Unlike other messages, this message can be used to query adjacency information for the given address prefix, to add a new route, and to delete or modify the existing route from the routing information base inside the kernel by writing and reading route messages on a routing socket.

For the manipulation of routing information, the route message must contain appropriate fields that include:

Version       = <must be specified>
Type          = <must be specified>
Flags         = <must be specified>
Index         = <must be specified if necessary>
ID            = <must be specified>
Seq           = <must be specified>
Addrs         = <must be specified>

The Type field specifies a type of manipulation, the Flags field specifies a class of target information and the Addrs field specifies target information like the following:

route.RouteMessage{
	Version: RTM_VERSION,
	Type: RTM_GET,
	Flags: RTF_UP | RTF_HOST,
	ID: uintptr(os.Getpid()),
	Seq: 1,
	Addrs: []route.Addrs{
		RTAX_DST: &route.Inet4Addr{ ... },
		RTAX_IFP: &route.LinkAddr{ ... },
		RTAX_BRD: &route.Inet4Addr{ ... },
	},
}

The values for the above fields depend on the implementation of each operating system.

The Err field on a response message contains an error value on the requested operation. If non-nil, the requested operation is failed.

func (m *RouteMessage) Marshal() ([]byte, error)

func (m *RouteMessage) Sys() []Sys

type RouteMetrics ¶

type RouteMetrics struct {
	PathMTU int // path maximum transmission unit
}

RouteMetrics represents route metrics.

func (rmx *RouteMetrics) SysType() SysType

type Sys ¶

type Sys interface {
	// SysType returns a type of operating system-specific
	// information.
	SysType() SysType
}

A Sys reprensents operating system-specific information.

type SysType ¶

type SysType int

A SysType represents a type of operating system-specific information.

const (
	SysMetrics SysType = iota
	SysStats
)