ports

Documentation

Overview

Package ports provides PortManager that manages allocating, reserving and releasing ports.

Index

• Constants
• type BitFlags
  • func (f BitFlags) ToFlags() Flags
• type FlagCounter
  • func (c *FlagCounter) AddRef(flags BitFlags)
  • func (c FlagCounter) AllRefsHave(flags BitFlags) bool
  • func (c *FlagCounter) DropRef(flags BitFlags)
  • func (c FlagCounter) FlagRefs(flags BitFlags) int
  • func (c FlagCounter) IntersectionRefs() BitFlags
  • func (c FlagCounter) TotalRefs() int
• type Flags
  • func (f Flags) Bits() BitFlags
  • func (f Flags) Effective() Flags
  • func (f *Flags) StateFields() []string
  • func (f *Flags) StateLoad(stateSourceObject state.Source)
  • func (f *Flags) StateSave(stateSinkObject state.Sink)
  • func (f *Flags) StateTypeName() string
• type PortManager
  • func NewPortManager() *PortManager
  • func (s *PortManager) IsPortAvailable(networks []tcpip.NetworkProtocolNumber, ...) bool
  • func (s *PortManager) PickEphemeralPort(testPort func(p uint16) (bool, *tcpip.Error)) (port uint16, err *tcpip.Error)
  • func (s *PortManager) PickEphemeralPortStable(offset uint32, testPort func(p uint16) (bool, *tcpip.Error)) (port uint16, err *tcpip.Error)
  • func (s *PortManager) ReleasePort(networks []tcpip.NetworkProtocolNumber, ...)
  • func (s *PortManager) ReservePort(networks []tcpip.NetworkProtocolNumber, ...) (reservedPort uint16, err *tcpip.Error)
  • func (s *PortManager) ReserveTuple(networks []tcpip.NetworkProtocolNumber, ...) bool

Constants

const (
	// FirstEphemeral is the first ephemeral port.
	FirstEphemeral = 16000
)

Types

type BitFlags

type BitFlags uint32

BitFlags is a bitset representation of Flags.

const (
	// MostRecentFlag represents Flags.MostRecent.
	MostRecentFlag BitFlags = 1 << iota

	// LoadBalancedFlag represents Flags.LoadBalanced.
	LoadBalancedFlag

	// TupleOnlyFlag represents Flags.TupleOnly.
	TupleOnlyFlag

	// FlagMask is a bit mask for BitFlags.
	FlagMask = nextFlag - 1

	// MultiBindFlagMask contains the flags that allow binding the same
	// tuple multiple times.
	MultiBindFlagMask = MostRecentFlag | LoadBalancedFlag
)

func (BitFlags) ToFlags

func (f BitFlags) ToFlags() Flags

ToFlags converts the bitset into a Flags struct.

type FlagCounter

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

FlagCounter counts how many references each flag combination has.

func (*FlagCounter) AddRef

func (c *FlagCounter) AddRef(flags BitFlags)

AddRef increases the reference count for a specific flag combination.

func (FlagCounter) AllRefsHave

func (c FlagCounter) AllRefsHave(flags BitFlags) bool

AllRefsHave returns if all references have all specified flags.

func (*FlagCounter) DropRef

func (c *FlagCounter) DropRef(flags BitFlags)

DropRef decreases the reference count for a specific flag combination.

func (FlagCounter) FlagRefs

func (c FlagCounter) FlagRefs(flags BitFlags) int

FlagRefs returns the number of references with all specified flags.

func (FlagCounter) IntersectionRefs

func (c FlagCounter) IntersectionRefs() BitFlags

IntersectionRefs returns the set of flags shared by all references.

func (FlagCounter) TotalRefs

func (c FlagCounter) TotalRefs() int

TotalRefs calculates the total number of references for all flag combinations.

type Flags

type Flags struct {
	// MostRecent represents UDP SO_REUSEADDR.
	MostRecent bool

	// LoadBalanced indicates SO_REUSEPORT.
	//
	// LoadBalanced takes precidence over MostRecent.
	LoadBalanced bool

	// TupleOnly represents TCP SO_REUSEADDR.
	TupleOnly bool
}

Flags represents the type of port reservation.

+stateify savable

func (Flags) Bits

func (f Flags) Bits() BitFlags

Bits converts the Flags to their bitset form.

func (Flags) Effective

func (f Flags) Effective() Flags

Effective returns the effective behavior of a flag config.

func (*Flags) StateFields

func (f *Flags) StateFields() []string

func (*Flags) StateLoad

func (f *Flags) StateLoad(stateSourceObject state.Source)

func (*Flags) StateSave

func (f *Flags) StateSave(stateSinkObject state.Sink)

func (*Flags) StateTypeName

func (f *Flags) StateTypeName() string

type PortManager

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

PortManager manages allocating, reserving and releasing ports.

func NewPortManager

func NewPortManager() *PortManager

NewPortManager creates new PortManager.

func (*PortManager) IsPortAvailable

func (s *PortManager) IsPortAvailable(networks []tcpip.NetworkProtocolNumber, transport tcpip.TransportProtocolNumber, addr tcpip.Address, port uint16, flags Flags, bindToDevice tcpip.NICID, dest tcpip.FullAddress) bool

IsPortAvailable tests if the given port is available on all given protocols.

func (*PortManager) PickEphemeralPort

func (s *PortManager) PickEphemeralPort(testPort func(p uint16) (bool, *tcpip.Error)) (port uint16, err *tcpip.Error)

PickEphemeralPort randomly chooses a starting point and iterates over all possible ephemeral ports, allowing the caller to decide whether a given port is suitable for its needs, and stopping when a port is found or an error occurs.

func (*PortManager) PickEphemeralPortStable

func (s *PortManager) PickEphemeralPortStable(offset uint32, testPort func(p uint16) (bool, *tcpip.Error)) (port uint16, err *tcpip.Error)

PickEphemeralPortStable starts at the specified offset + s.portHint and iterates over all ephemeral ports, allowing the caller to decide whether a given port is suitable for its needs and stopping when a port is found or an error occurs.

func (*PortManager) ReleasePort

func (s *PortManager) ReleasePort(networks []tcpip.NetworkProtocolNumber, transport tcpip.TransportProtocolNumber, addr tcpip.Address, port uint16, flags Flags, bindToDevice tcpip.NICID, dest tcpip.FullAddress)

ReleasePort releases the reservation on a port/IP combination so that it can be reserved by other endpoints.

func (*PortManager) ReservePort

func (s *PortManager) ReservePort(networks []tcpip.NetworkProtocolNumber, transport tcpip.TransportProtocolNumber, addr tcpip.Address, port uint16, flags Flags, bindToDevice tcpip.NICID, dest tcpip.FullAddress, testPort func(port uint16) bool) (reservedPort uint16, err *tcpip.Error)

ReservePort marks a port/IP combination as reserved so that it cannot be reserved by another endpoint. If port is zero, ReservePort will search for an unreserved ephemeral port and reserve it, returning its value in the "port" return value.

An optional testPort closure can be passed in which if provided will be used to test if the picked port can be used. The function should return true if the port is safe to use, false otherwise.

func (*PortManager) ReserveTuple

func (s *PortManager) ReserveTuple(networks []tcpip.NetworkProtocolNumber, transport tcpip.TransportProtocolNumber, addr tcpip.Address, port uint16, flags Flags, bindToDevice tcpip.NICID, dest tcpip.FullAddress) bool

ReserveTuple adds a port reservation for the tuple on all given protocol.