stack

package

Go to main page

Versions in this module

v0

v0.9.0

Sep 20, 2024

Changes in this version

+ type BridgeEndpoint struct

+ func NewBridgeEndpoint(mtu uint32) *BridgeEndpoint

+ func (b *BridgeEndpoint) ARPHardwareType() header.ARPHardwareType

+ func (b *BridgeEndpoint) AddHeader(pkt *PacketBuffer)

+ func (b *BridgeEndpoint) AddNIC(n *nic) tcpip.Error

+ func (b *BridgeEndpoint) Attach(dispatcher NetworkDispatcher)

+ func (b *BridgeEndpoint) Capabilities() LinkEndpointCapabilities

+ func (b *BridgeEndpoint) Close()

+ func (b *BridgeEndpoint) DelNIC(nic *nic) tcpip.Error

+ func (b *BridgeEndpoint) IsAttached() bool

+ func (b *BridgeEndpoint) LinkAddress() tcpip.LinkAddress

+ func (b *BridgeEndpoint) MTU() uint32

+ func (b *BridgeEndpoint) MaxHeaderLength() uint16

+ func (b *BridgeEndpoint) ParseHeader(*PacketBuffer) bool

+ func (b *BridgeEndpoint) SetLinkAddress(addr tcpip.LinkAddress)

+ func (b *BridgeEndpoint) SetMTU(mtu uint32)

+ func (b *BridgeEndpoint) SetOnCloseAction(func())

+ func (b *BridgeEndpoint) StateFields() []string

+ func (b *BridgeEndpoint) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (b *BridgeEndpoint) StateSave(stateSinkObject state.Sink)

+ func (b *BridgeEndpoint) StateTypeName() string

+ func (b *BridgeEndpoint) Wait()

+ func (b *BridgeEndpoint) WritePackets(pkts PacketBufferList) (int, tcpip.Error)

+ type CoordinatorNIC interface

+ AddNIC func(n *nic) tcpip.Error

+ DelNIC func(n *nic) tcpip.Error

type NetworkLinkEndpoint

+ Close func()

+ SetLinkAddress func(addr tcpip.LinkAddress)

+ SetMTU func(mtu uint32)

+ SetOnCloseAction func(func())

type Stack

+ func (s *Stack) GetNICByID(id tcpip.NICID) (*nic, tcpip.Error)

+ func (s *Stack) NextNICID() tcpip.NICID

+ func (s *Stack) ReplaceRoute(route tcpip.Route)

+ func (s *Stack) SetNICAddress(id tcpip.NICID, addr tcpip.LinkAddress) tcpip.Error

+ func (s *Stack) SetNICCoordinator(id tcpip.NICID, mid tcpip.NICID) tcpip.Error

+ func (s *Stack) SetNICMTU(id tcpip.NICID, mtu uint32) tcpip.Error

+ func (s *Stack) SetNICName(id tcpip.NICID, name string) tcpip.Error

+ func (s *Stack) SetNICStack(id tcpip.NICID, peer *Stack) (tcpip.NICID, tcpip.Error)

v0.8.0

Jun 9, 2024

v0.7.0

May 31, 2024

Changes in this version

type AcceptTarget

+ func (a *AcceptTarget) StateFields() []string

+ func (a *AcceptTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (a *AcceptTarget) StateSave(stateSinkObject state.Sink)

+ func (a *AcceptTarget) StateTypeName() string

type AddressLifetimes

+ func (lifetimes *AddressLifetimes) StateFields() []string

+ func (lifetimes *AddressLifetimes) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (lifetimes *AddressLifetimes) StateSave(stateSinkObject state.Sink)

+ func (lifetimes *AddressLifetimes) StateTypeName() string

type AddressableEndpointState

+ func (a *AddressableEndpointState) StateFields() []string

+ func (a *AddressableEndpointState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (a *AddressableEndpointState) StateSave(stateSinkObject state.Sink)

+ func (a *AddressableEndpointState) StateTypeName() string

type AddressableEndpointStateOptions

+ func (a *AddressableEndpointStateOptions) StateFields() []string

+ func (a *AddressableEndpointStateOptions) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (a *AddressableEndpointStateOptions) StateSave(stateSinkObject state.Sink)

+ func (a *AddressableEndpointStateOptions) StateTypeName() string

type DADConfigurations

+ func (c *DADConfigurations) StateFields() []string

+ func (c *DADConfigurations) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (c *DADConfigurations) StateSave(stateSinkObject state.Sink)

+ func (c *DADConfigurations) StateTypeName() string

type DNATTarget

+ func (rt *DNATTarget) StateFields() []string

+ func (rt *DNATTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (rt *DNATTarget) StateSave(stateSinkObject state.Sink)

+ func (rt *DNATTarget) StateTypeName() string

type DropTarget

+ func (d *DropTarget) StateFields() []string

+ func (d *DropTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (d *DropTarget) StateSave(stateSinkObject state.Sink)

+ func (d *DropTarget) StateTypeName() string

type ErrorTarget

+ func (e *ErrorTarget) StateFields() []string

+ func (e *ErrorTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (e *ErrorTarget) StateSave(stateSinkObject state.Sink)

+ func (e *ErrorTarget) StateTypeName() string

type ICMPRateLimiter

+ func (l *ICMPRateLimiter) StateFields() []string

+ func (l *ICMPRateLimiter) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (l *ICMPRateLimiter) StateSave(stateSinkObject state.Sink)

+ func (l *ICMPRateLimiter) StateTypeName() string

type MasqueradeTarget

+ func (mt *MasqueradeTarget) StateFields() []string

+ func (mt *MasqueradeTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (mt *MasqueradeTarget) StateSave(stateSinkObject state.Sink)

+ func (mt *MasqueradeTarget) StateTypeName() string

type NUDConfigurations

+ func (c *NUDConfigurations) StateFields() []string

+ func (c *NUDConfigurations) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (c *NUDConfigurations) StateSave(stateSinkObject state.Sink)

+ func (c *NUDConfigurations) StateTypeName() string

type NUDState

+ func (s *NUDState) StateFields() []string

+ func (s *NUDState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (s *NUDState) StateSave(stateSinkObject state.Sink)

+ func (s *NUDState) StateTypeName() string

type NetworkHeaderParams

+ DF bool

type PacketBufferList

+ func (pl *PacketBufferList) PopFront() *PacketBuffer

type RedirectTarget

+ func (rt *RedirectTarget) StateFields() []string

+ func (rt *RedirectTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (rt *RedirectTarget) StateSave(stateSinkObject state.Sink)

+ func (rt *RedirectTarget) StateTypeName() string

type RejectIPv4Target

+ func (rt *RejectIPv4Target) StateFields() []string

+ func (rt *RejectIPv4Target) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (rt *RejectIPv4Target) StateSave(stateSinkObject state.Sink)

+ func (rt *RejectIPv4Target) StateTypeName() string

type RejectIPv6Target

+ func (rt *RejectIPv6Target) StateFields() []string

+ func (rt *RejectIPv6Target) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (rt *RejectIPv6Target) StateSave(stateSinkObject state.Sink)

+ func (rt *RejectIPv6Target) StateTypeName() string

type ReturnTarget

+ func (r *ReturnTarget) StateFields() []string

+ func (r *ReturnTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (r *ReturnTarget) StateSave(stateSinkObject state.Sink)

+ func (r *ReturnTarget) StateTypeName() string

type SNATTarget

+ func (st *SNATTarget) StateFields() []string

+ func (st *SNATTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (st *SNATTarget) StateSave(stateSinkObject state.Sink)

+ func (st *SNATTarget) StateTypeName() string

type Stack

+ func (s *Stack) StateFields() []string

+ func (s *Stack) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (s *Stack) StateSave(stateSinkObject state.Sink)

+ func (s *Stack) StateTypeName() string

type TCPCubicState

+ CurrRTT time.Duration

+ EndSeq seqnum.Value

+ LastAck tcpip.MonotonicTime

+ LastRTT time.Duration

+ RoundStart tcpip.MonotonicTime

+ SampleCount uint

type UnicastSourceAndMulticastDestination

+ func (u *UnicastSourceAndMulticastDestination) StateFields() []string

+ func (u *UnicastSourceAndMulticastDestination) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (u *UnicastSourceAndMulticastDestination) StateSave(stateSinkObject state.Sink)

+ func (u *UnicastSourceAndMulticastDestination) StateTypeName() string

type UserChainTarget

+ func (u *UserChainTarget) StateFields() []string

+ func (u *UserChainTarget) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (u *UserChainTarget) StateSave(stateSinkObject state.Sink)

+ func (u *UserChainTarget) StateTypeName() string

v0.6.0

Apr 21, 2024

v0.5.0

Apr 21, 2024

v0.4.0

Apr 21, 2024

v0.3.0

Apr 21, 2024

Changes in this version

type PacketBuffer

+ ConnMark uint32

v0.2.2

Apr 20, 2024

v0.2.1

Apr 20, 2024

Changes in this version

type PacketBuffer

+ UserCookie uint32

v0.2.0

Apr 20, 2024

v0.1.0

Apr 17, 2024

Changes in this version

+ const CtxRestoreStack

+ const DefaultBufferSize

+ const DefaultMaxBufferSize

+ const DefaultTOS

+ const GVisorGSOMaxSize

+ const HookUnset

+ const MinBufferSize

+ const NeighborCacheSize

+ const PacketBufferStructSize

+ func BufferSince(h PacketHeader) buffer.Buffer

+ func MergeFragment(dst, frag *PacketBuffer)

+ func PayloadSince(h PacketHeader) *buffer.View

+ type AcceptTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (*AcceptTarget) Action(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

+ type AddressAssignmentState int

+ const AddressAssigned

+ const AddressDisabled

+ const AddressTentative

+ func (state AddressAssignmentState) String() string

+ type AddressConfigType int

+ const AddressConfigSlaac

+ const AddressConfigStatic

+ type AddressDispatcher interface

+ OnChanged func(AddressLifetimes, AddressAssignmentState)

+ OnRemoved func(AddressRemovalReason)

+ type AddressEndpoint interface

+ ConfigType func() AddressConfigType

+ Deprecated func() bool

+ GetKind func() AddressKind

+ Lifetimes func() AddressLifetimes

+ RegisterDispatcher func(AddressDispatcher)

+ SetDeprecated func(bool)

+ SetKind func(AddressKind)

+ SetLifetimes func(AddressLifetimes)

+ Temporary func() bool

+ type AddressKind int

+ const Permanent

+ const PermanentExpired

+ const PermanentTentative

+ const Temporary

+ func (k AddressKind) IsPermanent() bool

+ type AddressLifetimes struct

+ Deprecated bool

+ PreferredUntil tcpip.MonotonicTime

+ ValidUntil tcpip.MonotonicTime

+ type AddressProperties struct

+ ConfigType AddressConfigType

+ Disp AddressDispatcher

+ Lifetimes AddressLifetimes

+ PEB PrimaryEndpointBehavior

+ Temporary bool

+ type AddressRemovalReason int

+ const AddressRemovalDADFailed

+ const AddressRemovalInterfaceRemoved

+ const AddressRemovalInvalidated

+ const AddressRemovalManualAction

+ func (reason AddressRemovalReason) String() string

+ type AddressableEndpoint interface

+ AcquireAssignedAddress func(localAddr tcpip.Address, allowTemp bool, tempPEB PrimaryEndpointBehavior, ...) AddressEndpoint

+ AcquireOutgoingPrimaryAddress func(remoteAddr, srcHint tcpip.Address, allowExpired bool) AddressEndpoint

+ AddAndAcquirePermanentAddress func(addr tcpip.AddressWithPrefix, properties AddressProperties) (AddressEndpoint, tcpip.Error)

+ MainAddress func() tcpip.AddressWithPrefix

+ PermanentAddresses func() []tcpip.AddressWithPrefix

+ PrimaryAddresses func() []tcpip.AddressWithPrefix

+ RemovePermanentAddress func(addr tcpip.Address) tcpip.Error

+ SetLifetimes func(addr tcpip.Address, lifetimes AddressLifetimes) tcpip.Error

+ type AddressableEndpointState struct

+ func (a *AddressableEndpointState) AcquireAssignedAddress(localAddr tcpip.Address, allowTemp bool, tempPEB PrimaryEndpointBehavior, ...) AddressEndpoint

+ func (a *AddressableEndpointState) AcquireAssignedAddressOrMatching(localAddr tcpip.Address, f func(AddressEndpoint) bool, allowTemp bool, ...) AddressEndpoint

+ func (a *AddressableEndpointState) AcquireOutgoingPrimaryAddress(remoteAddr tcpip.Address, srcHint tcpip.Address, allowExpired bool) AddressEndpoint

+ func (a *AddressableEndpointState) AddAndAcquireAddress(addr tcpip.AddressWithPrefix, properties AddressProperties, kind AddressKind) (AddressEndpoint, tcpip.Error)

+ func (a *AddressableEndpointState) AddAndAcquirePermanentAddress(addr tcpip.AddressWithPrefix, properties AddressProperties) (AddressEndpoint, tcpip.Error)

+ func (a *AddressableEndpointState) AddAndAcquireTemporaryAddress(addr tcpip.AddressWithPrefix, peb PrimaryEndpointBehavior) (AddressEndpoint, tcpip.Error)

+ func (a *AddressableEndpointState) Cleanup()

+ func (a *AddressableEndpointState) ForEachEndpoint(f func(AddressEndpoint) bool)

+ func (a *AddressableEndpointState) ForEachPrimaryEndpoint(f func(AddressEndpoint) bool)

+ func (a *AddressableEndpointState) GetAddress(addr tcpip.Address) AddressEndpoint

+ func (a *AddressableEndpointState) Init(networkEndpoint NetworkEndpoint, options AddressableEndpointStateOptions)

+ func (a *AddressableEndpointState) MainAddress() tcpip.AddressWithPrefix

+ func (a *AddressableEndpointState) OnNetworkEndpointEnabledChanged()

+ func (a *AddressableEndpointState) PermanentAddresses() []tcpip.AddressWithPrefix

+ func (a *AddressableEndpointState) PrimaryAddresses() []tcpip.AddressWithPrefix

+ func (a *AddressableEndpointState) RemovePermanentAddress(addr tcpip.Address) tcpip.Error

+ func (a *AddressableEndpointState) RemovePermanentEndpoint(ep AddressEndpoint, reason AddressRemovalReason) tcpip.Error

+ func (a *AddressableEndpointState) SetDeprecated(addr tcpip.Address, deprecated bool) tcpip.Error

+ func (a *AddressableEndpointState) SetLifetimes(addr tcpip.Address, lifetimes AddressLifetimes) tcpip.Error

+ type AddressableEndpointStateOptions struct

+ HiddenWhileDisabled bool

+ type AssignableAddressEndpoint interface

+ AddressWithPrefix func() tcpip.AddressWithPrefix

+ DecRef func()

+ IsAssigned func(allowExpired bool) bool

+ Subnet func() tcpip.Subnet

+ TryIncRef func() bool

+ type ConnTrack struct

+ func (ct *ConnTrack) StateFields() []string

+ func (ct *ConnTrack) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (ct *ConnTrack) StateSave(stateSinkObject state.Sink)

+ func (ct *ConnTrack) StateTypeName() string

+ type DADAborted struct

+ type DADCheckAddressDisposition int

+ const DADAlreadyRunning

+ const DADDisabled

+ const DADStarting

+ type DADCompletionHandler func(DADResult)

+ type DADConfigurations struct

+ DupAddrDetectTransmits uint8

+ RetransmitTimer time.Duration

+ func DefaultDADConfigurations() DADConfigurations

+ func (c *DADConfigurations) Validate()

+ type DADDupAddrDetected struct

+ HolderLinkAddress tcpip.LinkAddress

+ type DADError struct

+ Err tcpip.Error

+ type DADResult interface

+ type DADSucceeded struct

+ type DNATTarget struct

+ Addr tcpip.Address

+ ChangeAddress bool

+ ChangePort bool

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ Port uint16

+ func (rt *DNATTarget) Action(pkt *PacketBuffer, hook Hook, r *Route, addressEP AddressableEndpoint) (RuleVerdict, int)

+ type DropTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (*DropTarget) Action(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

+ type DuplicateAddressDetector interface

+ CheckDuplicateAddress func(tcpip.Address, DADCompletionHandler) DADCheckAddressDisposition

+ DuplicateAddressProtocol func() tcpip.NetworkProtocolNumber

+ SetDADConfigurations func(c DADConfigurations)

+ type ErrorTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (*ErrorTarget) Action(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

+ type ForwardingNetworkEndpoint interface

+ Forwarding func() bool

+ SetForwarding func(bool) bool

+ type GSO struct

+ CsumOffset uint16

+ L3HdrLen uint16

+ MSS uint16

+ MaxSize uint32

+ NeedsCsum bool

+ Type GSOType

+ func (g *GSO) StateFields() []string

+ func (g *GSO) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (g *GSO) StateSave(stateSinkObject state.Sink)

+ func (g *GSO) StateTypeName() string

+ type GSOEndpoint interface

+ GSOMaxSize func() uint32

+ SupportedGSO func() SupportedGSO

+ type GSOType int

+ const GSOGvisor

+ const GSONone

+ const GSOTCPv4

+ const GSOTCPv6

+ func (g *GSOType) StateFields() []string

+ func (g *GSOType) StateTypeName() string

+ type GroupAddressableEndpoint interface

+ IsInGroup func(group tcpip.Address) bool

+ JoinGroup func(group tcpip.Address) tcpip.Error

+ LeaveGroup func(group tcpip.Address) tcpip.Error

+ type Hook uint

+ const Forward

+ const Input

+ const NumHooks

+ const Output

+ const Postrouting

+ const Prerouting

+ func (i Hook) String() string

+ type ICMPRateLimiter struct

+ func NewICMPRateLimiter(clock tcpip.Clock) *ICMPRateLimiter

+ func (l *ICMPRateLimiter) Allow() bool

+ func (l *ICMPRateLimiter) Burst() int

+ func (l *ICMPRateLimiter) Limit() rate.Limit

+ func (l *ICMPRateLimiter) SetBurst(burst int)

+ func (l *ICMPRateLimiter) SetLimit(limit rate.Limit)

+ type IPHeaderFilter struct

+ CheckProtocol bool

+ Dst tcpip.Address

+ DstInvert bool

+ DstMask tcpip.Address

+ InputInterface string

+ InputInterfaceInvert bool

+ InputInterfaceMask string

+ OutputInterface string

+ OutputInterfaceInvert bool

+ OutputInterfaceMask string

+ Protocol tcpip.TransportProtocolNumber

+ Src tcpip.Address

+ SrcInvert bool

+ SrcMask tcpip.Address

+ func EmptyFilter4() IPHeaderFilter

+ func EmptyFilter6() IPHeaderFilter

+ func (fl *IPHeaderFilter) StateFields() []string

+ func (fl *IPHeaderFilter) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (fl *IPHeaderFilter) StateSave(stateSinkObject state.Sink)

+ func (fl *IPHeaderFilter) StateTypeName() string

+ func (fl IPHeaderFilter) NetworkProtocol() tcpip.NetworkProtocolNumber

+ type IPNetworkEndpointStats interface

+ IPStats func() *tcpip.IPStats

+ type IPTables struct

+ func DefaultTables(clock tcpip.Clock, rand *rand.Rand) *IPTables

+ func (it *IPTables) CheckForward(pkt *PacketBuffer, inNicName, outNicName string) bool

+ func (it *IPTables) CheckInput(pkt *PacketBuffer, inNicName string) bool

+ func (it *IPTables) CheckOutput(pkt *PacketBuffer, r *Route, outNicName string) bool

+ func (it *IPTables) CheckPostrouting(pkt *PacketBuffer, r *Route, addressEP AddressableEndpoint, outNicName string) bool

+ func (it *IPTables) CheckPrerouting(pkt *PacketBuffer, addressEP AddressableEndpoint, inNicName string) bool

+ func (it *IPTables) ForceReplaceTable(id TableID, table Table, ipv6 bool)

+ func (it *IPTables) GetTable(id TableID, ipv6 bool) Table

+ func (it *IPTables) Modified() bool

+ func (it *IPTables) OriginalDst(epID TransportEndpointID, netProto tcpip.NetworkProtocolNumber, ...) (tcpip.Address, uint16, tcpip.Error)

+ func (it *IPTables) ReplaceTable(id TableID, table Table, ipv6 bool)

+ func (it *IPTables) StateFields() []string

+ func (it *IPTables) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (it *IPTables) StateSave(stateSinkObject state.Sink)

+ func (it *IPTables) StateTypeName() string

+ func (it *IPTables) VisitTargets(transform func(Target) Target)

+ type InjectableLinkEndpoint interface

+ InjectInbound func(protocol tcpip.NetworkProtocolNumber, pkt *PacketBuffer)

+ InjectOutbound func(dest tcpip.Address, packet *buffer.View) tcpip.Error

+ type LinkAddressResolver interface

+ LinkAddressProtocol func() tcpip.NetworkProtocolNumber

+ LinkAddressRequest func(targetAddr, localAddr tcpip.Address, remoteLinkAddr tcpip.LinkAddress) tcpip.Error

+ ResolveStaticAddress func(addr tcpip.Address) (tcpip.LinkAddress, bool)

+ type LinkEndpoint interface

+ type LinkEndpointCapabilities uint

+ const CapabilityDisconnectOk

+ const CapabilityLoopback

+ const CapabilityNone

+ const CapabilityRXChecksumOffload

+ const CapabilityResolutionRequired

+ const CapabilitySaveRestore

+ const CapabilityTXChecksumOffload

+ type LinkResolutionResult struct

+ Err tcpip.Error

+ LinkAddress tcpip.LinkAddress

+ type LinkResolvableNetworkEndpoint interface

+ HandleLinkResolutionFailure func(*PacketBuffer)

+ type LinkWriter interface

+ WritePackets func(PacketBufferList) (int, tcpip.Error)

+ type MasqueradeTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (mt *MasqueradeTarget) Action(pkt *PacketBuffer, hook Hook, r *Route, addressEP AddressableEndpoint) (RuleVerdict, int)

+ type Matcher interface

+ Match func(hook Hook, packet *PacketBuffer, ...) (matches bool, hotdrop bool)

+ type MulticastForwardingEventDispatcher interface

+ OnMissingRoute func(MulticastPacketContext)

+ OnUnexpectedInputInterface func(context MulticastPacketContext, expectedInputInterface tcpip.NICID)

+ type MulticastForwardingNetworkEndpoint interface

+ MulticastForwarding func() bool

+ SetMulticastForwarding func(bool) bool

+ type MulticastForwardingNetworkProtocol interface

+ AddMulticastRoute func(UnicastSourceAndMulticastDestination, MulticastRoute) tcpip.Error

+ DisableMulticastForwarding func()

+ EnableMulticastForwarding func(MulticastForwardingEventDispatcher) (bool, tcpip.Error)

+ MulticastRouteLastUsedTime func(UnicastSourceAndMulticastDestination) (tcpip.MonotonicTime, tcpip.Error)

+ RemoveMulticastRoute func(UnicastSourceAndMulticastDestination) tcpip.Error

+ type MulticastPacketContext struct

+ InputInterface tcpip.NICID

+ SourceAndDestination UnicastSourceAndMulticastDestination

+ type MulticastRoute struct

+ ExpectedInputInterface tcpip.NICID

+ OutgoingInterfaces []MulticastRouteOutgoingInterface

+ type MulticastRouteOutgoingInterface struct

+ ID tcpip.NICID

+ MinTTL uint8

+ type NDPEndpoint interface

+ InvalidateDefaultRouter func(tcpip.Address)

+ type NICContext any

+ type NICInfo struct

+ ARPHardwareType header.ARPHardwareType

+ Context NICContext

+ Flags NICStateFlags

+ Forwarding map[tcpip.NetworkProtocolNumber]bool

+ LinkAddress tcpip.LinkAddress

+ MTU uint32

+ MulticastForwarding map[tcpip.NetworkProtocolNumber]bool

+ Name string

+ NetworkStats map[tcpip.NetworkProtocolNumber]NetworkEndpointStats

+ ProtocolAddresses []tcpip.ProtocolAddress

+ Stats tcpip.NICStats

+ type NICOptions struct

+ Context NICContext

+ DeliverLinkPackets bool

+ Disabled bool

+ Name string

+ QDisc QueueingDiscipline

+ type NICStateFlags struct

+ Loopback bool

+ Promiscuous bool

+ Running bool

+ Up bool

+ type NUDConfigurations struct

+ BaseReachableTime time.Duration

+ DelayFirstProbeTime time.Duration

+ LearnBaseReachableTime bool

+ LearnRetransmitTimer bool

+ MaxAnycastDelayTime time.Duration

+ MaxMulticastProbes uint32

+ MaxRandomFactor float32

+ MaxReachabilityConfirmations uint32

+ MaxUnicastProbes uint32

+ MinRandomFactor float32

+ RetransmitTimer time.Duration

+ func DefaultNUDConfigurations() NUDConfigurations

+ type NUDDispatcher interface

+ OnNeighborAdded func(tcpip.NICID, NeighborEntry)

+ OnNeighborChanged func(tcpip.NICID, NeighborEntry)

+ OnNeighborRemoved func(tcpip.NICID, NeighborEntry)

+ type NUDState struct

+ func NewNUDState(c NUDConfigurations, clock tcpip.Clock, rng *rand.Rand) *NUDState

+ func (s *NUDState) Config() NUDConfigurations

+ func (s *NUDState) ReachableTime() time.Duration

+ func (s *NUDState) SetConfig(c NUDConfigurations)

+ type NeighborEntry struct

+ Addr tcpip.Address

+ LinkAddr tcpip.LinkAddress

+ State NeighborState

+ UpdatedAt tcpip.MonotonicTime

+ type NeighborState uint8

+ const Delay

+ const Incomplete

+ const Probe

+ const Reachable

+ const Stale

+ const Static

+ const Unknown

+ const Unreachable

+ func (i NeighborState) String() string

+ type NeighborStats struct

+ UnreachableEntryLookups *tcpip.StatCounter

+ type NetworkDispatcher interface

+ DeliverLinkPacket func(protocol tcpip.NetworkProtocolNumber, pkt *PacketBuffer)

+ DeliverNetworkPacket func(protocol tcpip.NetworkProtocolNumber, pkt *PacketBuffer)

+ type NetworkEndpoint interface

+ Close func()

+ DefaultTTL func() uint8

+ Disable func()

+ Enable func() tcpip.Error

+ Enabled func() bool

+ HandlePacket func(pkt *PacketBuffer)

+ MTU func() uint32

+ MaxHeaderLength func() uint16

+ NetworkProtocolNumber func() tcpip.NetworkProtocolNumber

+ Stats func() NetworkEndpointStats

+ WriteHeaderIncludedPacket func(r *Route, pkt *PacketBuffer) tcpip.Error

+ WritePacket func(r *Route, params NetworkHeaderParams, pkt *PacketBuffer) tcpip.Error

+ type NetworkEndpointID struct

+ LocalAddress tcpip.Address

+ type NetworkEndpointStats interface

+ IsNetworkEndpointStats func()

+ type NetworkHeaderParams struct

+ Protocol tcpip.TransportProtocolNumber

+ TOS uint8

+ TTL uint8

+ type NetworkInterface interface

+ CheckLocalAddress func(tcpip.NetworkProtocolNumber, tcpip.Address) bool

+ Enabled func() bool

+ HandleNeighborConfirmation func(tcpip.NetworkProtocolNumber, tcpip.Address, tcpip.LinkAddress, ...) tcpip.Error

+ HandleNeighborProbe func(tcpip.NetworkProtocolNumber, tcpip.Address, tcpip.LinkAddress) tcpip.Error

+ ID func() tcpip.NICID

+ IsLoopback func() bool

+ Name func() string

+ PrimaryAddress func(tcpip.NetworkProtocolNumber) (tcpip.AddressWithPrefix, tcpip.Error)

+ Promiscuous func() bool

+ Spoofing func() bool

+ WritePacket func(*Route, *PacketBuffer) tcpip.Error

+ WritePacketToRemote func(tcpip.LinkAddress, *PacketBuffer) tcpip.Error

+ type NetworkLinkEndpoint interface

+ ARPHardwareType func() header.ARPHardwareType

+ AddHeader func(*PacketBuffer)

+ Attach func(dispatcher NetworkDispatcher)

+ Capabilities func() LinkEndpointCapabilities

+ IsAttached func() bool

+ LinkAddress func() tcpip.LinkAddress

+ MTU func() uint32

+ MaxHeaderLength func() uint16

+ ParseHeader func(*PacketBuffer) bool

+ Wait func()

+ type NetworkPacketInfo struct

+ IsForwardedPacket bool

+ LocalAddressBroadcast bool

+ func (n *NetworkPacketInfo) StateFields() []string

+ func (n *NetworkPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (n *NetworkPacketInfo) StateSave(stateSinkObject state.Sink)

+ func (n *NetworkPacketInfo) StateTypeName() string

+ type NetworkProtocol interface

+ Close func()

+ MinimumPacketSize func() int

+ NewEndpoint func(nic NetworkInterface, dispatcher TransportDispatcher) NetworkEndpoint

+ Number func() tcpip.NetworkProtocolNumber

+ Option func(option tcpip.GettableNetworkProtocolOption) tcpip.Error

+ Parse func(pkt *PacketBuffer) (proto tcpip.TransportProtocolNumber, hasTransportHdr bool, ok bool)

+ ParseAddresses func(b []byte) (src, dst tcpip.Address)

+ SetOption func(option tcpip.SettableNetworkProtocolOption) tcpip.Error

+ Wait func()

+ type NetworkProtocolFactory func(*Stack) NetworkProtocol

+ type Options struct

+ AllowPacketEndpointWrite bool

+ Clock tcpip.Clock

+ DefaultIPTables func(clock tcpip.Clock, rand *rand.Rand) *IPTables

+ HandleLocal bool

+ IPTables *IPTables

+ NUDConfigs NUDConfigurations

+ NUDDisp NUDDispatcher

+ NetworkProtocols []NetworkProtocolFactory

+ RandSource rand.Source

+ RawFactory RawFactory

+ SecureRNG io.Reader

+ Stats tcpip.Stats

+ TransportProtocols []TransportProtocolFactory

+ UniqueID UniqueID

+ type PacketBuffer struct

+ EgressRoute RouteInfo

+ GSOOptions GSO

+ Hash uint32

+ NICID tcpip.NICID

+ NetworkPacketInfo NetworkPacketInfo

+ NetworkProtocolNumber tcpip.NetworkProtocolNumber

+ Owner tcpip.PacketOwner

+ PktType tcpip.PacketType

+ RXChecksumValidated bool

+ TransportProtocolNumber tcpip.TransportProtocolNumber

+ func NewPacketBuffer(opts PacketBufferOptions) *PacketBuffer

+ func (pk *PacketBuffer) AsSlices() [][]byte

+ func (pk *PacketBuffer) AsViewList() (buffer.ViewList, int)

+ func (pk *PacketBuffer) AvailableHeaderBytes() int

+ func (pk *PacketBuffer) Clone() *PacketBuffer

+ func (pk *PacketBuffer) CloneToInbound() *PacketBuffer

+ func (pk *PacketBuffer) Data() PacketData

+ func (pk *PacketBuffer) DecRef()

+ func (pk *PacketBuffer) DeepCopyForForwarding(reservedHeaderBytes int) *PacketBuffer

+ func (pk *PacketBuffer) HeaderSize() int

+ func (pk *PacketBuffer) ID() uintptr

+ func (pk *PacketBuffer) IncRef() *PacketBuffer

+ func (pk *PacketBuffer) LinkHeader() PacketHeader

+ func (pk *PacketBuffer) MemSize() int

+ func (pk *PacketBuffer) Network() header.Network

+ func (pk *PacketBuffer) NetworkHeader() PacketHeader

+ func (pk *PacketBuffer) ReserveHeaderBytes(reserved int)

+ func (pk *PacketBuffer) ReservedHeaderBytes() int

+ func (pk *PacketBuffer) Size() int

+ func (pk *PacketBuffer) StateFields() []string

+ func (pk *PacketBuffer) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (pk *PacketBuffer) StateSave(stateSinkObject state.Sink)

+ func (pk *PacketBuffer) StateTypeName() string

+ func (pk *PacketBuffer) ToBuffer() buffer.Buffer

+ func (pk *PacketBuffer) ToView() *buffer.View

+ func (pk *PacketBuffer) TransportHeader() PacketHeader

+ func (pk *PacketBuffer) VirtioNetHeader() PacketHeader

+ func (r *PacketBuffer) InitRefs()

+ func (r *PacketBuffer) LeakMessage() string

+ func (r *PacketBuffer) LogRefs() bool

+ func (r *PacketBuffer) ReadRefs() int64

+ func (r *PacketBuffer) RefType() string

+ func (r *PacketBuffer) TryIncRef() bool

+ type PacketBufferList struct

+ func (pl *PacketBufferList) AsSlice() []*PacketBuffer

+ func (pl *PacketBufferList) Len() int

+ func (pl *PacketBufferList) PushBack(pb *PacketBuffer)

+ func (pl *PacketBufferList) Reset()

+ func (pl *PacketBufferList) StateFields() []string

+ func (pl *PacketBufferList) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (pl *PacketBufferList) StateSave(stateSinkObject state.Sink)

+ func (pl *PacketBufferList) StateTypeName() string

+ func (pl PacketBufferList) DecRef()

+ type PacketBufferOptions struct

+ IsForwardedPacket bool

+ OnRelease func()

+ Payload buffer.Buffer

+ ReserveHeaderBytes int

+ type PacketData struct

+ func (d *PacketData) StateFields() []string

+ func (d *PacketData) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (d *PacketData) StateSave(stateSinkObject state.Sink)

+ func (d *PacketData) StateTypeName() string

+ func (d PacketData) AppendView(v *buffer.View)

+ func (d PacketData) AsRange() Range

+ func (d PacketData) CapLength(length int)

+ func (d PacketData) Checksum() uint16

+ func (d PacketData) ChecksumAtOffset(offset int) uint16

+ func (d PacketData) Consume(size int) ([]byte, bool)

+ func (d PacketData) Merge(oth PacketData)

+ func (d PacketData) MergeBuffer(b *buffer.Buffer)

+ func (d PacketData) PullUp(size int) (b []byte, ok bool)

+ func (d PacketData) ReadFrom(src *buffer.Buffer, count int) int

+ func (d PacketData) ReadFromPacketData(oth PacketData, count int)

+ func (d PacketData) ReadTo(dst io.Writer, peek bool) (int, error)

+ func (d PacketData) Size() int

+ func (d PacketData) ToBuffer() buffer.Buffer

+ func (d PacketData) TrimFront(count int)

+ type PacketEndpoint interface

+ HandlePacket func(nicID tcpip.NICID, netProto tcpip.NetworkProtocolNumber, pkt *PacketBuffer)

+ type PacketHeader struct

+ func (h PacketHeader) Consume(size int) (v []byte, consumed bool)

+ func (h PacketHeader) Push(size int) []byte

+ func (h PacketHeader) Slice() []byte

+ func (h PacketHeader) View() *buffer.View

+ type PacketLooping byte

+ const PacketLoop

+ const PacketOut

+ type ParseResult int

+ const ParsedOK

+ const TransportLayerParseError

+ const UnknownTransportProtocol

+ type PrimaryEndpointBehavior int

+ const CanBePrimaryEndpoint

+ const FirstPrimaryEndpoint

+ const NeverPrimaryEndpoint

+ func (peb PrimaryEndpointBehavior) String() string

+ type QueueingDiscipline interface

+ Close func()

+ WritePacket func(*PacketBuffer) tcpip.Error

+ type Range struct

+ func (r Range) Capped(max int) Range

+ func (r Range) Size() int

+ func (r Range) SubRange(off int) Range

+ func (r Range) ToSlice() []byte

+ func (r Range) ToView() *buffer.View

+ type RawFactory interface

+ NewPacketEndpoint func(stack *Stack, cooked bool, netProto tcpip.NetworkProtocolNumber, ...) (tcpip.Endpoint, tcpip.Error)

+ NewUnassociatedEndpoint func(stack *Stack, netProto tcpip.NetworkProtocolNumber, ...) (tcpip.Endpoint, tcpip.Error)

+ type RawTransportEndpoint interface

+ HandlePacket func(*PacketBuffer)

+ type RcvBufAutoTuneParams struct

+ CopiedBytes int

+ Disabled bool

+ MeasureTime tcpip.MonotonicTime

+ PrevCopiedBytes int

+ RTT time.Duration

+ RTTMeasureSeqNumber seqnum.Value

+ RTTMeasureTime tcpip.MonotonicTime

+ RTTVar time.Duration

+ RcvBufSize int

+ func (r *RcvBufAutoTuneParams) StateFields() []string

+ func (r *RcvBufAutoTuneParams) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (r *RcvBufAutoTuneParams) StateSave(stateSinkObject state.Sink)

+ func (r *RcvBufAutoTuneParams) StateTypeName() string

+ type ReachabilityConfirmationFlags struct

+ IsRouter bool

+ Override bool

+ Solicited bool

+ type ReceiveBufferSizeOption struct

+ Default int

+ Max int

+ Min int

+ type RedirectTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ Port uint16

+ func (rt *RedirectTarget) Action(pkt *PacketBuffer, hook Hook, r *Route, addressEP AddressableEndpoint) (RuleVerdict, int)

+ type RejectIPv4Target struct

+ Handler RejectIPv4WithHandler

+ RejectWith RejectIPv4WithICMPType

+ func (rt *RejectIPv4Target) Action(pkt *PacketBuffer, hook Hook, _ *Route, _ AddressableEndpoint) (RuleVerdict, int)

+ type RejectIPv4WithHandler interface

+ SendRejectionError func(pkt *PacketBuffer, rejectWith RejectIPv4WithICMPType, inputHook bool) tcpip.Error

+ type RejectIPv4WithICMPType int

+ const RejectIPv4WithICMPAdminProhibited

+ const RejectIPv4WithICMPHostProhibited

+ const RejectIPv4WithICMPHostUnreachable

+ const RejectIPv4WithICMPNetProhibited

+ const RejectIPv4WithICMPNetUnreachable

+ const RejectIPv4WithICMPPortUnreachable

+ type RejectIPv6Target struct

+ Handler RejectIPv6WithHandler

+ RejectWith RejectIPv6WithICMPType

+ func (rt *RejectIPv6Target) Action(pkt *PacketBuffer, hook Hook, _ *Route, _ AddressableEndpoint) (RuleVerdict, int)

+ type RejectIPv6WithHandler interface

+ SendRejectionError func(pkt *PacketBuffer, rejectWith RejectIPv6WithICMPType, forwardingHook bool) tcpip.Error

+ type RejectIPv6WithICMPType int

+ const RejectIPv6WithICMPAddrUnreachable

+ const RejectIPv6WithICMPAdminProhibited

+ const RejectIPv6WithICMPNoRoute

+ const RejectIPv6WithICMPPortUnreachable

+ type ResolvedFieldsResult struct

+ Err tcpip.Error

+ RouteInfo RouteInfo

+ type RestoredEndpoint interface

+ Restore func(*Stack)

+ type ResumableEndpoint interface

+ Resume func()

+ type ReturnTarget struct

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (*ReturnTarget) Action(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

+ type Route struct

+ func (r *Route) Acquire()

+ func (r *Route) ConfirmReachable()

+ func (r *Route) DefaultTTL() uint8

+ func (r *Route) Fields() RouteInfo

+ func (r *Route) GSOMaxSize() uint32

+ func (r *Route) HasDisconnectOkCapability() bool

+ func (r *Route) HasGVisorGSOCapability() bool

+ func (r *Route) HasHostGSOCapability() bool

+ func (r *Route) HasSaveRestoreCapability() bool

+ func (r *Route) IsOutboundBroadcast() bool

+ func (r *Route) IsResolutionRequired() bool

+ func (r *Route) LocalAddress() tcpip.Address

+ func (r *Route) LocalLinkAddress() tcpip.LinkAddress

+ func (r *Route) Loop() PacketLooping

+ func (r *Route) MTU() uint32

+ func (r *Route) MaxHeaderLength() uint16

+ func (r *Route) NICID() tcpip.NICID

+ func (r *Route) NetProto() tcpip.NetworkProtocolNumber

+ func (r *Route) NextHop() tcpip.Address

+ func (r *Route) OutgoingNIC() tcpip.NICID

+ func (r *Route) PseudoHeaderChecksum(protocol tcpip.TransportProtocolNumber, totalLen uint16) uint16

+ func (r *Route) Release()

+ func (r *Route) RemoteAddress() tcpip.Address

+ func (r *Route) RemoteLinkAddress() tcpip.LinkAddress

+ func (r *Route) RequiresTXTransportChecksum() bool

+ func (r *Route) ResolveWith(addr tcpip.LinkAddress)

+ func (r *Route) ResolvedFields(afterResolve func(ResolvedFieldsResult)) tcpip.Error

+ func (r *Route) Stack() *Stack

+ func (r *Route) Stats() tcpip.Stats

+ func (r *Route) WriteHeaderIncludedPacket(pkt *PacketBuffer) tcpip.Error

+ func (r *Route) WritePacket(params NetworkHeaderParams, pkt *PacketBuffer) tcpip.Error

+ type RouteInfo struct

+ RemoteLinkAddress tcpip.LinkAddress

+ func (r *RouteInfo) StateFields() []string

+ func (r *RouteInfo) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (r *RouteInfo) StateSave(stateSinkObject state.Sink)

+ func (r *RouteInfo) StateTypeName() string

+ type Rule struct

+ Filter IPHeaderFilter

+ Matchers []Matcher

+ Target Target

+ func (r *Rule) StateFields() []string

+ func (r *Rule) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (r *Rule) StateSave(stateSinkObject state.Sink)

+ func (r *Rule) StateTypeName() string

+ type RuleVerdict int

+ const RuleAccept

+ const RuleDrop

+ const RuleJump

+ const RuleReturn

+ type SNATTarget struct

+ Addr tcpip.Address

+ ChangeAddress bool

+ ChangePort bool

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ Port uint16

+ func (st *SNATTarget) Action(pkt *PacketBuffer, hook Hook, r *Route, _ AddressableEndpoint) (RuleVerdict, int)

+ type SendBufSizeProto interface

+ SendBufferSize func() tcpip.TCPSendBufferSizeRangeOption

+ type Stack struct

+ func New(opts Options) *Stack

+ func RestoreStackFromContext(ctx context.Context) *Stack

+ func (s *Stack) AddMulticastRoute(protocol tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) AddProtocolAddress(id tcpip.NICID, protocolAddress tcpip.ProtocolAddress, ...) tcpip.Error

+ func (s *Stack) AddRoute(route tcpip.Route)

+ func (s *Stack) AddStaticNeighbor(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber, addr tcpip.Address, ...) tcpip.Error

+ func (s *Stack) AddTCPProbe(probe TCPProbeFunc)

+ func (s *Stack) AllAddresses() map[tcpip.NICID][]tcpip.ProtocolAddress

+ func (s *Stack) AllowICMPMessage() bool

+ func (s *Stack) CheckDuplicateAddress(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber, addr tcpip.Address, ...) (DADCheckAddressDisposition, tcpip.Error)

+ func (s *Stack) CheckLocalAddress(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber, addr tcpip.Address) tcpip.NICID

+ func (s *Stack) CheckNIC(id tcpip.NICID) bool

+ func (s *Stack) CheckNetworkProtocol(protocol tcpip.NetworkProtocolNumber) bool

+ func (s *Stack) CheckRegisterTransportEndpoint(netProtos []tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) CleanupEndpoints() []TransportEndpoint

+ func (s *Stack) ClearNeighbors(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber) tcpip.Error

+ func (s *Stack) Clock() tcpip.Clock

+ func (s *Stack) Close()

+ func (s *Stack) CompleteTransportEndpointCleanup(ep TransportEndpoint)

+ func (s *Stack) CreateNIC(id tcpip.NICID, ep LinkEndpoint) tcpip.Error

+ func (s *Stack) CreateNICWithOptions(id tcpip.NICID, ep LinkEndpoint, opts NICOptions) tcpip.Error

+ func (s *Stack) Destroy()

+ func (s *Stack) DisableMulticastForwardingForProtocol(protocol tcpip.NetworkProtocolNumber) tcpip.Error

+ func (s *Stack) DisableNIC(id tcpip.NICID) tcpip.Error

+ func (s *Stack) EnableMulticastForwardingForProtocol(protocol tcpip.NetworkProtocolNumber, disp MulticastForwardingEventDispatcher) (bool, tcpip.Error)

+ func (s *Stack) EnableNIC(id tcpip.NICID) tcpip.Error

+ func (s *Stack) FindNICNameFromID(id tcpip.NICID) string

+ func (s *Stack) FindRoute(id tcpip.NICID, localAddr, remoteAddr tcpip.Address, ...) (*Route, tcpip.Error)

+ func (s *Stack) FindTransportEndpoint(netProto tcpip.NetworkProtocolNumber, transProto tcpip.TransportProtocolNumber, ...) TransportEndpoint

+ func (s *Stack) GetLinkAddress(nicID tcpip.NICID, addr, localAddr tcpip.Address, ...) tcpip.Error

+ func (s *Stack) GetLinkEndpointByName(name string) LinkEndpoint

+ func (s *Stack) GetMainNICAddress(id tcpip.NICID, protocol tcpip.NetworkProtocolNumber) (tcpip.AddressWithPrefix, tcpip.Error)

+ func (s *Stack) GetNetworkEndpoint(nicID tcpip.NICID, proto tcpip.NetworkProtocolNumber) (NetworkEndpoint, tcpip.Error)

+ func (s *Stack) GetRouteTable() []tcpip.Route

+ func (s *Stack) GetTCPProbe() TCPProbeFunc

+ func (s *Stack) HandleLocal() bool

+ func (s *Stack) HasNIC(id tcpip.NICID) bool

+ func (s *Stack) ICMPBurst() int

+ func (s *Stack) ICMPLimit() rate.Limit

+ func (s *Stack) IPTables() *IPTables

+ func (s *Stack) InsecureRNG() *rand.Rand

+ func (s *Stack) IsInGroup(nicID tcpip.NICID, multicastAddr tcpip.Address) (bool, tcpip.Error)

+ func (s *Stack) IsSubnetBroadcast(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber, addr tcpip.Address) bool

+ func (s *Stack) JoinGroup(protocol tcpip.NetworkProtocolNumber, nicID tcpip.NICID, ...) tcpip.Error

+ func (s *Stack) LeaveGroup(protocol tcpip.NetworkProtocolNumber, nicID tcpip.NICID, ...) tcpip.Error

+ func (s *Stack) MulticastRouteLastUsedTime(protocol tcpip.NetworkProtocolNumber, ...) (tcpip.MonotonicTime, tcpip.Error)

+ func (s *Stack) NICForwarding(id tcpip.NICID, protocol tcpip.NetworkProtocolNumber) (bool, tcpip.Error)

+ func (s *Stack) NICInfo() map[tcpip.NICID]NICInfo

+ func (s *Stack) NICMulticastForwarding(id tcpip.NICID, protocol tcpip.NetworkProtocolNumber) (bool, tcpip.Error)

+ func (s *Stack) NUDConfigurations(id tcpip.NICID, proto tcpip.NetworkProtocolNumber) (NUDConfigurations, tcpip.Error)

+ func (s *Stack) Neighbors(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber) ([]NeighborEntry, tcpip.Error)

+ func (s *Stack) NetworkProtocolInstance(num tcpip.NetworkProtocolNumber) NetworkProtocol

+ func (s *Stack) NetworkProtocolOption(network tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) NewEndpoint(transport tcpip.TransportProtocolNumber, network tcpip.NetworkProtocolNumber, ...) (tcpip.Endpoint, tcpip.Error)

+ func (s *Stack) NewPacketEndpoint(cooked bool, netProto tcpip.NetworkProtocolNumber, waiterQueue *waiter.Queue) (tcpip.Endpoint, tcpip.Error)

+ func (s *Stack) NewRawEndpoint(transport tcpip.TransportProtocolNumber, network tcpip.NetworkProtocolNumber, ...) (tcpip.Endpoint, tcpip.Error)

+ func (s *Stack) NewRouteForMulticast(nicID tcpip.NICID, remoteAddr tcpip.Address, ...) *Route

+ func (s *Stack) Option(option any) tcpip.Error

+ func (s *Stack) PacketEndpointWriteSupported() bool

+ func (s *Stack) ParsePacketBufferTransport(protocol tcpip.TransportProtocolNumber, pkt *PacketBuffer) ParseResult

+ func (s *Stack) Pause()

+ func (s *Stack) PortRange() (uint16, uint16)

+ func (s *Stack) RegisterPacketEndpoint(nicID tcpip.NICID, netProto tcpip.NetworkProtocolNumber, ep PacketEndpoint) tcpip.Error

+ func (s *Stack) RegisterRawTransportEndpoint(netProto tcpip.NetworkProtocolNumber, transProto tcpip.TransportProtocolNumber, ...) tcpip.Error

+ func (s *Stack) RegisterRestoredEndpoint(e RestoredEndpoint)

+ func (s *Stack) RegisterResumableEndpoint(e ResumableEndpoint)

+ func (s *Stack) RegisterTransportEndpoint(netProtos []tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) RegisteredEndpoints() []TransportEndpoint

+ func (s *Stack) RemoveAddress(id tcpip.NICID, addr tcpip.Address) tcpip.Error

+ func (s *Stack) RemoveMulticastRoute(protocol tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) RemoveNIC(id tcpip.NICID) tcpip.Error

+ func (s *Stack) RemoveNeighbor(nicID tcpip.NICID, protocol tcpip.NetworkProtocolNumber, addr tcpip.Address) tcpip.Error

+ func (s *Stack) RemoveRoutes(match func(tcpip.Route) bool)

+ func (s *Stack) RemoveTCPProbe()

+ func (s *Stack) Restore()

+ func (s *Stack) RestoreCleanupEndpoints(es []TransportEndpoint)

+ func (s *Stack) Resume()

+ func (s *Stack) SecureRNG() cryptorand.RNG

+ func (s *Stack) Seed() uint32

+ func (s *Stack) SetAddressLifetimes(id tcpip.NICID, addr tcpip.Address, lifetimes AddressLifetimes) tcpip.Error

+ func (s *Stack) SetForwardingDefaultAndAllNICs(protocol tcpip.NetworkProtocolNumber, enable bool) tcpip.Error

+ func (s *Stack) SetICMPBurst(burst int)

+ func (s *Stack) SetICMPLimit(newLimit rate.Limit)

+ func (s *Stack) SetNICForwarding(id tcpip.NICID, protocol tcpip.NetworkProtocolNumber, enable bool) (bool, tcpip.Error)

+ func (s *Stack) SetNICMulticastForwarding(id tcpip.NICID, protocol tcpip.NetworkProtocolNumber, enable bool) (bool, tcpip.Error)

+ func (s *Stack) SetNUDConfigurations(id tcpip.NICID, proto tcpip.NetworkProtocolNumber, c NUDConfigurations) tcpip.Error

+ func (s *Stack) SetNetworkProtocolOption(network tcpip.NetworkProtocolNumber, ...) tcpip.Error

+ func (s *Stack) SetOption(option any) tcpip.Error

+ func (s *Stack) SetPortRange(start uint16, end uint16) tcpip.Error

+ func (s *Stack) SetPromiscuousMode(nicID tcpip.NICID, enable bool) tcpip.Error

+ func (s *Stack) SetRouteTable(table []tcpip.Route)

+ func (s *Stack) SetSpoofing(nicID tcpip.NICID, enable bool) tcpip.Error

+ func (s *Stack) SetTransportProtocolHandler(p tcpip.TransportProtocolNumber, ...)

+ func (s *Stack) SetTransportProtocolOption(transport tcpip.TransportProtocolNumber, ...) tcpip.Error

+ func (s *Stack) StartTransportEndpointCleanup(netProtos []tcpip.NetworkProtocolNumber, ...)

+ func (s *Stack) Stats() tcpip.Stats

+ func (s *Stack) TCPSendBufferLimits() tcpip.TCPSendBufferSizeRangeOption

+ func (s *Stack) TransportProtocolInstance(num tcpip.TransportProtocolNumber) TransportProtocol

+ func (s *Stack) TransportProtocolOption(transport tcpip.TransportProtocolNumber, ...) tcpip.Error

+ func (s *Stack) UniqueID() uint64

+ func (s *Stack) UnregisterPacketEndpoint(nicID tcpip.NICID, netProto tcpip.NetworkProtocolNumber, ep PacketEndpoint)

+ func (s *Stack) UnregisterRawTransportEndpoint(netProto tcpip.NetworkProtocolNumber, transProto tcpip.TransportProtocolNumber, ...)

+ func (s *Stack) UnregisterTransportEndpoint(netProtos []tcpip.NetworkProtocolNumber, ...)

+ func (s *Stack) Wait()

+ func (s *Stack) WritePacketToRemote(nicID tcpip.NICID, remote tcpip.LinkAddress, ...) tcpip.Error

+ func (s *Stack) WriteRawPacket(nicID tcpip.NICID, proto tcpip.NetworkProtocolNumber, payload buffer.Buffer) tcpip.Error

+ type SupportedGSO int

+ const GSONotSupported

+ const GVisorGSOSupported

+ const HostGSOSupported

+ type TCPCubicState struct

+ Beta float64

+ C float64

+ K float64

+ T tcpip.MonotonicTime

+ TimeSinceLastCongestion time.Duration

+ WC float64

+ WEst float64

+ WLastMax float64

+ WMax float64

+ func (t *TCPCubicState) StateFields() []string

+ func (t *TCPCubicState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPCubicState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPCubicState) StateTypeName() string

+ type TCPEndpointID struct

+ LocalAddress tcpip.Address

+ LocalPort uint16

+ RemoteAddress tcpip.Address

+ RemotePort uint16

+ func (t *TCPEndpointID) StateFields() []string

+ func (t *TCPEndpointID) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPEndpointID) StateSave(stateSinkObject state.Sink)

+ func (t *TCPEndpointID) StateTypeName() string

+ type TCPEndpointState struct

+ ID TCPEndpointID

+ RcvBufState TCPRcvBufState

+ Receiver TCPReceiverState

+ SACK TCPSACKInfo

+ SegTime tcpip.MonotonicTime

+ Sender TCPSenderState

+ SndBufState TCPSndBufState

+ func (t *TCPEndpointState) StateFields() []string

+ func (t *TCPEndpointState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPEndpointState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPEndpointState) StateTypeName() string

+ type TCPEndpointStateInner struct

+ RecentTS uint32

+ SACKPermitted bool

+ SendTSOk bool

+ TSOffset tcp.TSOffset

+ func (t *TCPEndpointStateInner) StateFields() []string

+ func (t *TCPEndpointStateInner) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPEndpointStateInner) StateSave(stateSinkObject state.Sink)

+ func (t *TCPEndpointStateInner) StateTypeName() string

+ type TCPFastRecoveryState struct

+ Active bool

+ First seqnum.Value

+ HighRxt seqnum.Value

+ Last seqnum.Value

+ MaxCwnd int

+ RescueRxt seqnum.Value

+ func (t *TCPFastRecoveryState) StateFields() []string

+ func (t *TCPFastRecoveryState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPFastRecoveryState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPFastRecoveryState) StateTypeName() string

+ type TCPInvalidRateLimitOption time.Duration

+ type TCPProbeFunc func(s *TCPEndpointState)

+ type TCPRACKState struct

+ DSACKSeen bool

+ EndSequence seqnum.Value

+ FACK seqnum.Value

+ RTT time.Duration

+ RTTSeq seqnum.Value

+ ReoWnd time.Duration

+ ReoWndIncr uint8

+ ReoWndPersist int8

+ Reord bool

+ XmitTime tcpip.MonotonicTime

+ func (t *TCPRACKState) StateFields() []string

+ func (t *TCPRACKState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPRACKState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPRACKState) StateTypeName() string

+ type TCPRTTState struct

+ RTTVar time.Duration

+ SRTT time.Duration

+ SRTTInited bool

+ func (t *TCPRTTState) StateFields() []string

+ func (t *TCPRTTState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPRTTState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPRTTState) StateTypeName() string

+ type TCPRcvBufState struct

+ RcvAutoParams RcvBufAutoTuneParams

+ RcvBufUsed int

+ RcvClosed bool

+ func (t *TCPRcvBufState) StateFields() []string

+ func (t *TCPRcvBufState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPRcvBufState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPRcvBufState) StateTypeName() string

+ type TCPReceiverState struct

+ PendingBufUsed int

+ RcvAcc seqnum.Value

+ RcvNxt seqnum.Value

+ RcvWndScale uint8

+ func (t *TCPReceiverState) StateFields() []string

+ func (t *TCPReceiverState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPReceiverState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPReceiverState) StateTypeName() string

+ type TCPSACKInfo struct

+ Blocks []header.SACKBlock

+ MaxSACKED seqnum.Value

+ ReceivedBlocks []header.SACKBlock

+ func (t *TCPSACKInfo) StateFields() []string

+ func (t *TCPSACKInfo) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPSACKInfo) StateSave(stateSinkObject state.Sink)

+ func (t *TCPSACKInfo) StateTypeName() string

+ type TCPSenderState struct

+ Closed bool

+ Cubic TCPCubicState

+ DupAckCount int

+ FastRecovery TCPFastRecoveryState

+ LastSendTime tcpip.MonotonicTime

+ MaxPayloadSize int

+ MaxSentAck seqnum.Value

+ Outstanding int

+ RACKState TCPRACKState

+ RTO time.Duration

+ RTTMeasureSeqNum seqnum.Value

+ RTTMeasureTime tcpip.MonotonicTime

+ RTTState TCPRTTState

+ RetransmitTS uint32

+ SackedOut int

+ SndCAAckCount int

+ SndCwnd int

+ SndNxt seqnum.Value

+ SndUna seqnum.Value

+ SndWnd seqnum.Size

+ SndWndScale uint8

+ SpuriousRecovery bool

+ Ssthresh int

+ func (t *TCPSenderState) StateFields() []string

+ func (t *TCPSenderState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPSenderState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPSenderState) StateTypeName() string

+ type TCPSndBufState struct

+ AutoTuneSndBufDisabled atomicbitops.Uint32

+ PacketTooBigCount int

+ SndBufSize int

+ SndBufUsed int

+ SndClosed bool

+ SndMTU int

+ func (t *TCPSndBufState) StateFields() []string

+ func (t *TCPSndBufState) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TCPSndBufState) StateSave(stateSinkObject state.Sink)

+ func (t *TCPSndBufState) StateTypeName() string

+ type Table struct

+ BuiltinChains [NumHooks]int

+ Rules []Rule

+ Underflows [NumHooks]int

+ func EmptyFilterTable() Table

+ func EmptyNATTable() Table

+ func (table *Table) StateFields() []string

+ func (table *Table) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (table *Table) StateSave(stateSinkObject state.Sink)

+ func (table *Table) StateTypeName() string

+ func (table *Table) ValidHooks() uint32

+ type TableID int

+ const FilterID

+ const MangleID

+ const NATID

+ const NumTables

+ type Target interface

+ Action func(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

+ type TransportDispatcher interface

+ DeliverRawPacket func(tcpip.TransportProtocolNumber, *PacketBuffer)

+ DeliverTransportError func(local, remote tcpip.Address, _ tcpip.NetworkProtocolNumber, ...)

+ DeliverTransportPacket func(tcpip.TransportProtocolNumber, *PacketBuffer) TransportPacketDisposition

+ type TransportEndpoint interface

+ Abort func()

+ HandleError func(TransportError, *PacketBuffer)

+ HandlePacket func(TransportEndpointID, *PacketBuffer)

+ UniqueID func() uint64

+ Wait func()

+ type TransportEndpointID struct

+ LocalAddress tcpip.Address

+ LocalPort uint16

+ RemoteAddress tcpip.Address

+ RemotePort uint16

+ func (t *TransportEndpointID) StateFields() []string

+ func (t *TransportEndpointID) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TransportEndpointID) StateSave(stateSinkObject state.Sink)

+ func (t *TransportEndpointID) StateTypeName() string

+ type TransportEndpointInfo struct

+ BindAddr tcpip.Address

+ BindNICID tcpip.NICID

+ ID TransportEndpointID

+ NetProto tcpip.NetworkProtocolNumber

+ RegisterNICID tcpip.NICID

+ TransProto tcpip.TransportProtocolNumber

+ func (*TransportEndpointInfo) IsEndpointInfo()

+ func (t *TransportEndpointInfo) AddrNetProtoLocked(addr tcpip.FullAddress, v6only bool) (tcpip.FullAddress, tcpip.NetworkProtocolNumber, tcpip.Error)

+ func (t *TransportEndpointInfo) StateFields() []string

+ func (t *TransportEndpointInfo) StateLoad(ctx context.Context, stateSourceObject state.Source)

+ func (t *TransportEndpointInfo) StateSave(stateSinkObject state.Sink)

+ func (t *TransportEndpointInfo) StateTypeName() string

+ type TransportError interface

+ Kind func() TransportErrorKind

+ type TransportErrorKind int

+ const DestinationHostDownTransportError

+ const DestinationHostUnreachableTransportError

+ const DestinationNetworkUnreachableTransportError

+ const DestinationPortUnreachableTransportError

+ const DestinationProtoUnreachableTransportError

+ const PacketTooBigTransportError

+ const SourceHostIsolatedTransportError

+ const SourceRouteFailedTransportError

+ type TransportPacketDisposition int

+ const TransportPacketDestinationPortUnreachable

+ const TransportPacketHandled

+ const TransportPacketProtocolUnreachable

+ type TransportProtocol interface

+ Close func()

+ HandleUnknownDestinationPacket func(TransportEndpointID, *PacketBuffer) UnknownDestinationPacketDisposition

+ MinimumPacketSize func() int

+ NewEndpoint func(netProto tcpip.NetworkProtocolNumber, waitQueue *waiter.Queue) (tcpip.Endpoint, tcpip.Error)

+ NewRawEndpoint func(netProto tcpip.NetworkProtocolNumber, waitQueue *waiter.Queue) (tcpip.Endpoint, tcpip.Error)

+ Number func() tcpip.TransportProtocolNumber

+ Option func(option tcpip.GettableTransportProtocolOption) tcpip.Error

+ Parse func(pkt *PacketBuffer) (ok bool)

+ ParsePorts func(b []byte) (src, dst uint16, err tcpip.Error)

+ Pause func()

+ Resume func()

+ SetOption func(option tcpip.SettableTransportProtocolOption) tcpip.Error

+ Wait func()

+ type TransportProtocolFactory func(*Stack) TransportProtocol

+ type UnicastSourceAndMulticastDestination struct

+ Destination tcpip.Address

+ Source tcpip.Address

+ type UniqueID interface

+ UniqueID func() uint64

+ type UnknownDestinationPacketDisposition int

+ const UnknownDestinationPacketHandled

+ const UnknownDestinationPacketMalformed

+ const UnknownDestinationPacketUnhandled

+ type UserChainTarget struct

+ Name string

+ NetworkProtocol tcpip.NetworkProtocolNumber

+ func (*UserChainTarget) Action(*PacketBuffer, Hook, *Route, AddressableEndpoint) (RuleVerdict, int)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL