net

type Device interface {
	// BringUp brings the Device up. If it is already up,
	// BringUp is a no-op.
	BringUp() error
	// BringDown brings the Device down. If it is already down,
	// BringDown is a no-op.
	BringDown() error
	// IsUp returns true if the Device is up.
	IsUp() bool

	// MTU returns the device's maximum transmission unit,
	// or 0 if no MTU is set.
	MTU() int
}

type DeviceSet struct {
	// contains filtered or unexported fields
}

type EtherType uint16

type EthernetDevice struct {
	// contains filtered or unexported fields
}

type EthernetInterface interface {
	// BringUp brings the interface up. If it is already up,
	// BringUp is a no-op.
	BringUp() error
	// BringDown brings the interface down. If it is already down,
	// BringDown is a no-op.
	BringDown() error
	// IsUp returns true if the interface is up.
	IsUp() bool

	// MAC returns the interface's MAC address, if any.
	MAC() (ok bool, mac MAC)
	// SetMAC sets the interface's MAC address. It is an error
	// to call SetMAC with the broadcast MAC, or while the
	// interface is up.
	SetMAC(mac MAC) error

	// MTU returns the interface's MTU. If no MTU is set, MTU will return 0.
	MTU() int
	// SetMTU sets the interface's MTU. It is an error to set
	// an MTU of 0 or to call SetMTU while the interface is up.
	SetMTU(mtu uint64) error

	// RegisterCallback registers f as the function to be called
	// when a new Ethernet frame arrives. It overwrites any
	// previously-registered callbacks. If f is nil, incoming
	// Ethernet frames will be dropped.
	//
	// If the interface has its MAC set, only Ethernet frames
	// whose destination MAC is equal to the interface's MAC or
	// is the broadcast MAC will be returned.
	//
	// RegisterCallback can only be called while the interface
	// is down.
	RegisterCallback(f func(b []byte, src, dst MAC, et EtherType))
	// WriteFrame writes an Ethernet frame with the payload b.
	// b is expected to contain space preceding the payload itself
	// for the Ethernet header, which WriteFrame is responsible
	// for writing. If the interface has an MTU set, and len(b)
	// is larger than that MTU plus the length of an Ethernet header,
	// the frame will not be written, and instead WriteFrame will
	// return an MTU error (see IsMTU).
	//
	// If the destination MAC is the broadcast MAC, the frame will
	// be broadcast to all devices on the local Ethernet network.
	//
	// If a MAC address has been set, that will be used as the
	// frame's source MAC. Otherwise, WriteFrame will return an error.
	WriteFrame(b []byte, dst MAC, et EtherType) (n int, err error)
	// WriteFrameSrc is like WriteFrame, but allows the source MAC
	// address to be set explicitly.
	WriteFrameSrc(b []byte, src, dst MAC, et EtherType) (n int, err error)
}

type IP interface {
	// IPVersion is the IP's version - 4 or 6.
	IPVersion() int
	// contains filtered or unexported methods
}

type IPHost struct {
	IPv4Host
	IPv6Host
}

type IPProtocol uint8

type IPSubnet interface {
	// IPVersion returns the subnet's IP version - 4 or 6.
	IPVersion() int
	// contains filtered or unexported methods
}

type IPv4 [4]byte

type IPv4Device interface {
	Device

	// IPv4 returns the device's IPv4 address and network mask
	// if they have been set.
	IPv4() (addr, netmask IPv4, ok bool)
	// SetIPv4 sets the device's IPv4 address and network mask,
	// returning any error encountered. SetIPv4 can only be
	// called when the device is down.
	SetIPv4(addr, netmask IPv4) error
	// UnsetIPv4 unsets the device's IPv4 address and network
	// mask, returning any error encountered. UnsetIPv4 can
	// only be called when the device is down.
	UnsetIPv4() error

	// RegisterIPv4Callback registers f as the function
	// to be called when a new IPv4 packet arrives. It
	// overwrites any previously-registered callbacks.
	// If f is nil, incoming IPv4 packets will be dropped.
	RegisterIPv4Callback(f func([]byte))
	// WriteToIPv4 is like Device's WriteTo,
	// but for IPv4 only.
	WriteToIPv4(b []byte, dst IPv4) (n int, err error)
}

type IPv4DeviceRoute struct {
	Subnet IPv4Subnet
	Device IPv4Device
}

type IPv4Host interface {
	AddIPv4Device(dev IPv4Device)
	RemoveIPv4Device(dev IPv4Device)
	RegisterIPv4Callback(f func(b []byte, src, dst IPv4), proto IPProtocol)
	AddIPv4Route(subnet IPv4Subnet, nexthop IPv4)
	AddIPv4DeviceRoute(subnet IPv4Subnet, dev IPv4Device)
	IPv4Routes() []IPv4Route
	IPv4DeviceRoutes() []IPv4DeviceRoute
	SetForwarding(on bool)
	Forwarding() bool
	WriteToIPv4(b []byte, addr IPv4, proto IPProtocol) (n int, err error)

	// SetTTL sets the TTL for all outoing packets. If ttl is 0, a default TTL
	// will be used.
	SetTTL(ttl uint8)

	// GetConfigCopyIPv4 returns an IPv4Host which is simply a wrapper around
	// the original host, but which allows setting configuration values
	// without setting those values on the original host. In particular, all
	// methods except for SetTTL operate directly on the original host.
	GetConfigCopyIPv4() IPv4Host
}

type IPv4Route struct {
	Subnet  IPv4Subnet
	Nexthop IPv4
}

type IPv4Subnet struct {
	Addr    IPv4
	Netmask IPv4
}

type IPv6 [16]byte

type IPv6Device interface {
	Device

	// IPv6 returns the device's IPv6 address and network mask
	// if they have been set.
	IPv6() (addr, netmask IPv6, ok bool)
	// SetIPv6 sets the device's IPv6 address and network mask,
	// returning any error encountered. SetIPv6 can only be
	// called when the device is down.
	SetIPv6(addr, netmask IPv6) error
	// UnsetIPv6 unsets the device's IPv6 address and network
	// mask, returning any error encountered. UnsetIPv6 can
	// only be called when the device is down.
	UnsetIPv6() error

	// RegisterIPv6Callback registers f as the function
	// to be called when a new IPv4 packet arrives. It
	// overwrites any previously-registered callbacks.
	// If f is nil, incoming IPv4 packets will be dropped.
	RegisterIPv6Callback(f func([]byte))
	// WriteToIPv6 is like Device's WriteTo,
	// but for IPv6 only.
	WriteToIPv6(b []byte, dst IPv6) (n int, err error)
}

type IPv6DeviceRoute struct {
	Subnet IPv6Subnet
	Device IPv6Device
}

type IPv6Host interface {
	AddIPv6Device(dev IPv6Device)
	RemoveIPv6Device(dev IPv6Device)
	RegisterIPv6Callback(f func(b []byte, src, dst IPv6), proto IPProtocol)
	AddIPv6Route(subnet IPv6Subnet, nexthop IPv6)
	AddIPv6DeviceRoute(subnet IPv6Subnet, dev IPv6Device)
	IPv6Routes() []IPv6Route
	IPv6DeviceRoutes() []IPv6DeviceRoute
	SetForwarding(on bool)
	Forwarding() bool
	WriteToIPv6(b []byte, addr IPv6, proto IPProtocol) (n int, err error)

	// SetTTL sets the TTL for all outoing packets. If ttl is 0, a default TTL
	// will be used.
	SetTTL(ttl uint8)

	// GetConfigCopyIPv6 returns an IPv6Host which is simply a wrapper around
	// the original host, but which allows setting configuration values
	// without setting those values on the original host. In particular, all
	// methods except for SetTTL operate directly on the original host.
	GetConfigCopyIPv6() IPv6Host
}

type IPv6Route struct {
	Subnet  IPv6Subnet
	Nexthop IPv6
}

type IPv6Subnet struct {
	Addr    IPv6
	Netmask IPv6
}

type MAC [6]byte

type UDPIPv4Device struct {
	// contains filtered or unexported fields
}

type UDPIPv6Device struct {
	// contains filtered or unexported fields
}