Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

nebula

package module

Go to main page

Versions in this module

v0

v0.24.1

Oct 17, 2024

v0.24.0

Oct 17, 2024

v0.0.26

Oct 25, 2024

v0.0.25

Oct 24, 2024

v0.0.24

Oct 21, 2024

v0.0.23

Oct 3, 2024

v0.0.22

Oct 3, 2024

v0.0.21

Sep 26, 2024

v0.0.20

Oct 3, 2024

v0.0.19

Sep 26, 2024

v0.0.18

Sep 26, 2024

v0.0.17

Sep 26, 2024

v0.0.16

Sep 26, 2024

v0.0.15

Sep 25, 2024

v0.0.14

Sep 25, 2024

v0.0.13

Sep 25, 2024

v0.0.12

Sep 25, 2024

v0.0.11

Sep 25, 2024

v0.0.10

Sep 24, 2024

v0.0.9

Sep 24, 2024

v0.0.8

Sep 24, 2024

v0.0.7

Sep 24, 2024

v0.0.6

Sep 24, 2024

v0.0.5

Sep 24, 2024

v0.0.4

Sep 24, 2024

v0.0.3

Sep 24, 2024

v0.0.2

Sep 24, 2024

Changes in this version

+ const DefaultForceRelays

+ const DefaultHandshakeRetries

+ const DefaultHandshakeTriggerBuffer

+ const DefaultHandshakeTryInterval

+ const DefaultUseRelays

+ const Established

+ const ForwardingType

+ const MaxHostInfosPerVpnIp

+ const MaxRemotes

+ const PeerRequested

+ const ReplayWindow

+ const Requested

+ const RoamingSuppressSeconds

+ const TerminalType

+ const Unknowntype

+ var ErrAlreadySeen = errors.New("already seen")

+ var ErrExistingHostInfo = errors.New("existing hostinfo")

+ var ErrHostNotKnown = errors.New("host not known")

+ var ErrIntOverflowNebula = fmt.Errorf("proto: integer overflow")

+ var ErrInvalidLengthNebula = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrInvalidLocalIP = errors.New("local IP is not in list of handled local IPs")

+ var ErrInvalidRemoteIP = errors.New("remote IP is not in remote certificate subnets")

+ var ErrLocalIndexCollision = errors.New("local index collision")

+ var ErrNoMatchingRule = errors.New("no matching rule in firewall table")

+ var ErrUnexpectedEndOfGroupNebula = fmt.Errorf("proto: unexpected end of group")

+ var NebulaControl_MessageType_name = map[int32]string

+ var NebulaControl_MessageType_value = map[string]int32

+ var NebulaMeta_MessageType_name = map[int32]string

+ var NebulaMeta_MessageType_value = map[string]int32

+ var NebulaPing_MessageType_name = map[int32]string

+ var NebulaPing_MessageType_value = map[string]int32

+ func AddFirewallRulesFromConfig(l *logrus.Logger, inbound bool, c *config.C, fw FirewallInterface) error

+ func AddRelay(l *logrus.Logger, relayHostInfo *HostInfo, hm *HostMap, vpnIp iputil.VpnIp, ...) (uint32, error)

+ func MigrateRelayUsed(dstHost, relayhost *HostInfo, log *logrus.Logger) error

+ func NewCalculatedRemotesFromConfig(c *config.C, k string) (*cidr.Tree4[[]*calculatedRemote], error)

+ func NewHostnameResults(ctx context.Context, l *logrus.Logger, d time.Duration, network string, ...) (*hostnamesResults, error)

+ func NewRelayManager(ctx context.Context, l *logrus.Logger, hostmap *HostMap, c *config.C) *relayManager

+ func NewUDPAddrFromLH4(ipp *Ip4AndPort) *udp.Addr

+ func NewUDPAddrFromLH6(ipp *Ip6AndPort) *udp.Addr

+ func RecombineCertAndValidate(h *noise.HandshakeState, rawCertBytes []byte, caPool *cert.NebulaCAPool) (*cert.NebulaCertificate, error)

+ type AllowList struct

+ func (al *AllowList) Allow(ip net.IP) bool

+ func (al *AllowList) AllowIpV4(ip iputil.VpnIp) bool

+ func (al *AllowList) AllowIpV6(hi, lo uint64) bool

+ type AllowListNameRule struct

+ Allow bool

+ Name *regexp.Regexp

+ type AvoidClient struct

+ func NewAvoidClient(token string, iface *Interface, hostmap *HostMap) *AvoidClient

+ func (s *AvoidClient) Action(ctx context.Context, req *avoid.ActionRequest) (*avoid.ConnectionInfo, error)

+ func (s *AvoidClient) HealthCheck(ctx context.Context, req *avoid.HealthRequest) (*avoid.HealthReply, error)

+ type Bits struct

+ func NewBits(bits uint64) *Bits

+ func (b *Bits) Check(l logrus.FieldLogger, i uint64) bool

+ func (b *Bits) Update(l *logrus.Logger, i uint64) bool

+ type Cache struct

+ Learned []*udp.Addr

+ Relay []*net.IP

+ Reported []*udp.Addr

+ type CacheMap map[string]*Cache

+ type CertState struct

+ Certificate *cert.NebulaCertificate

+ PrivateKey []byte

+ PublicKey []byte

+ RawCertificate []byte

+ RawCertificateNoKey []byte

+ type ConnectionState struct

+ H *noise.HandshakeState

+ func NewConnectionState(l *logrus.Logger, cipher string, certState *CertState, initiator bool, ...) *ConnectionState

+ func (cs *ConnectionState) MarshalJSON() ([]byte, error)

+ type Control struct

+ func Main(c *config.C, configTest bool, buildVersion string, logger *logrus.Logger, ...) (retcon *Control, reterr error)

+ func (c *Control) CloseAllTunnels(excludeLighthouses bool) (closed int)

+ func (c *Control) CloseTunnel(vpnIp iputil.VpnIp, localOnly bool) bool

+ func (c *Control) Context() context.Context

+ func (c *Control) Device() overlay.Device

+ func (c *Control) GetHostInfoByVpnIp(vpnIp iputil.VpnIp, pending bool) *ControlHostInfo

+ func (c *Control) ListHostmapHosts(pendingMap bool) []ControlHostInfo

+ func (c *Control) ListHostmapIndexes(pendingMap bool) []ControlHostInfo

+ func (c *Control) RebindUDPServer()

+ func (c *Control) SetRemoteForTunnel(vpnIp iputil.VpnIp, addr udp.Addr) *ControlHostInfo

+ func (c *Control) ShutdownBlock()

+ func (c *Control) Start()

+ func (c *Control) Stop()

+ type ControlHostInfo struct

+ Cert *cert.NebulaCertificate

+ CurrentRelaysThroughMe []iputil.VpnIp

+ CurrentRelaysToMe []iputil.VpnIp

+ CurrentRemote *udp.Addr

+ LocalIndex uint32

+ MessageCounter uint64

+ RemoteAddrs []*udp.Addr

+ RemoteIndex uint32

+ VpnIp net.IP

+ type EncWriter interface

+ Handshake func(vpnIp iputil.VpnIp)

+ SendMessageToHostInfo func(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, ...)

+ SendMessageToVpnIp func(t header.MessageType, st header.MessageSubType, vpnIp iputil.VpnIp, ...)

+ SendVia func(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool)

+ type Firewall struct

+ Conntrack *FirewallConntrack

+ DefaultTimeout time.Duration

+ InRules *FirewallTable

+ InSendReject bool

+ OutRules *FirewallTable

+ OutSendReject bool

+ TCPTimeout time.Duration

+ UDPTimeout time.Duration

+ func NewFirewall(l *logrus.Logger, tcpTimeout, UDPTimeout, defaultTimeout time.Duration, ...) *Firewall

+ func NewFirewallFromConfig(l *logrus.Logger, nc *cert.NebulaCertificate, c *config.C) (*Firewall, error)

+ func (f *Firewall) AddRule(incoming bool, proto uint8, startPort int32, endPort int32, groups []string, ...) error

+ func (f *Firewall) Destroy()

+ func (f *Firewall) Drop(fp firewall.Packet, incoming bool, h *HostInfo, caPool *cert.NebulaCAPool, ...) error

+ func (f *Firewall) EmitStats()

+ func (f *Firewall) GetRuleHash() string

+ func (f *Firewall) GetRuleHashFNV() uint32

+ func (f *Firewall) GetRuleHashes() string

+ type FirewallCA struct

+ Any *FirewallRule

+ CANames map[string]*FirewallRule

+ CAShas map[string]*FirewallRule

+ type FirewallConntrack struct

+ Conns map[firewall.Packet]*conn

+ TimerWheel *TimerWheel[firewall.Packet]

+ type FirewallInterface interface

+ AddRule func(incoming bool, proto uint8, startPort int32, endPort int32, groups []string, ...) error

+ type FirewallRule struct

+ Any *firewallLocalCIDR

+ CIDR *cidr.Tree4[*firewallLocalCIDR]

+ Groups []*firewallGroups

+ Hosts map[string]*firewallLocalCIDR

+ type FirewallTable struct

+ AnyProto firewallPort

+ ICMP firewallPort

+ TCP firewallPort

+ UDP firewallPort

+ type HandshakeConfig struct

+ type HandshakeHostInfo struct

+ type HandshakeManager struct

+ OutboundHandshakeTimer *LockingTimerWheel[iputil.VpnIp]

+ func NewHandshakeManager(l *logrus.Logger, mainHostMap *HostMap, lightHouse *LightHouse, ...) *HandshakeManager

+ func (c *HandshakeManager) CheckAndComplete(hostinfo *HostInfo, handshakePacket uint8, f *Interface) (*HostInfo, error)

+ func (c *HandshakeManager) DeleteHostInfo(hostinfo *HostInfo)

+ func (c *HandshakeManager) EmitStats()

+ func (c *HandshakeManager) ForEachIndex(f controlEach)

+ func (c *HandshakeManager) ForEachVpnIp(f controlEach)

+ func (c *HandshakeManager) GetPreferredRanges() []*net.IPNet

+ func (c *HandshakeManager) NextOutboundHandshakeTimerTick(now time.Time)

+ func (c *HandshakeManager) Run(ctx context.Context)

+ func (hm *HandshakeManager) Complete(hostinfo *HostInfo, f *Interface)

+ func (hm *HandshakeManager) GetOrHandshake(vpnIp iputil.VpnIp, cacheCb func(*HandshakeHostInfo)) (*HostInfo, bool)

+ func (hm *HandshakeManager) HandleIncoming(addr *udp.Addr, via *ViaSender, packet []byte, h *header.H)

+ func (hm *HandshakeManager) QueryIndex(index uint32) *HostInfo

+ func (hm *HandshakeManager) QueryVpnIp(vpnIp iputil.VpnIp) *HostInfo

+ func (hm *HandshakeManager) StartHandshake(vpnIp iputil.VpnIp, cacheCb func(*HandshakeHostInfo)) *HostInfo

+ type HostInfo struct

+ ConnectionState *ConnectionState

+ HandshakePacket map[uint8][]byte

+ func (i *HostInfo) CreateRemoteCIDR(c *cert.NebulaCertificate)

+ func (i *HostInfo) GetCert() *cert.NebulaCertificate

+ func (i *HostInfo) RecvErrorExceeded() bool

+ func (i *HostInfo) SetRemote(remote *udp.Addr)

+ func (i *HostInfo) SetRemoteIfPreferred(hm *HostMap, newRemote *udp.Addr) bool

+ func (i *HostInfo) TryPromoteBest(preferredRanges []*net.IPNet, ifce *Interface)

+ type HostMap struct

+ Hosts map[iputil.VpnIp]*HostInfo

+ Indexes map[uint32]*HostInfo

+ Relays map[uint32]*HostInfo

+ RemoteIndexes map[uint32]*HostInfo

+ func NewHostMapFromConfig(l *logrus.Logger, vpnCIDR *net.IPNet, c *config.C) *HostMap

+ func (hm *HostMap) DeleteHostInfo(hostinfo *HostInfo) bool

+ func (hm *HostMap) EmitStats()

+ func (hm *HostMap) ForEachIndex(f controlEach)

+ func (hm *HostMap) ForEachVpnIp(f controlEach)

+ func (hm *HostMap) GetPreferredRanges() []*net.IPNet

+ func (hm *HostMap) MakePrimary(hostinfo *HostInfo)

+ func (hm *HostMap) QueryIndex(index uint32) *HostInfo

+ func (hm *HostMap) QueryRelayIndex(index uint32) *HostInfo

+ func (hm *HostMap) QueryReverseIndex(index uint32) *HostInfo

+ func (hm *HostMap) QueryVpnIp(vpnIp iputil.VpnIp) *HostInfo

+ func (hm *HostMap) QueryVpnIpRelayFor(targetIp, relayHostIp iputil.VpnIp) (*HostInfo, *Relay, error)

+ func (hm *HostMap) RemoveRelay(localIdx uint32)

+ type Interface struct

+ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error)

+ func (f *Interface) Close() error

+ func (f *Interface) Handshake(vpnIp iputil.VpnIp)

+ func (f *Interface) RegisterConfigChangeCallbacks(c *config.C)

+ func (f *Interface) SendMessageToHostInfo(t header.MessageType, st header.MessageSubType, hi *HostInfo, ...)

+ func (f *Interface) SendMessageToVpnIp(t header.MessageType, st header.MessageSubType, vpnIp iputil.VpnIp, ...)

+ func (f *Interface) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool)

+ type InterfaceConfig struct

+ Cipher string

+ ConntrackCacheTimeout time.Duration

+ DropLocalBroadcast bool

+ DropMulticast bool

+ Firewall *Firewall

+ HandshakeManager *HandshakeManager

+ HostMap *HostMap

+ Inside overlay.Device

+ MessageMetrics *MessageMetrics

+ Outside udp.Conn

+ ServeDns bool

+ type Ip4AndPort struct

+ Ip uint32

+ Port uint32

+ func NewIp4AndPort(ip net.IP, port uint32) *Ip4AndPort

+ func NewIp4AndPortFromNetIP(ip netip.Addr, port uint16) *Ip4AndPort

+ func (*Ip4AndPort) Descriptor() ([]byte, []int)

+ func (*Ip4AndPort) ProtoMessage()

+ func (m *Ip4AndPort) GetIp() uint32

+ func (m *Ip4AndPort) GetPort() uint32

+ func (m *Ip4AndPort) Marshal() (dAtA []byte, err error)

+ func (m *Ip4AndPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *Ip4AndPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *Ip4AndPort) Reset()

+ func (m *Ip4AndPort) Size() (n int)

+ func (m *Ip4AndPort) String() string

+ func (m *Ip4AndPort) Unmarshal(dAtA []byte) error

+ func (m *Ip4AndPort) XXX_DiscardUnknown()

+ func (m *Ip4AndPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Ip4AndPort) XXX_Merge(src proto.Message)

+ func (m *Ip4AndPort) XXX_Size() int

+ func (m *Ip4AndPort) XXX_Unmarshal(b []byte) error

+ type Ip6AndPort struct

+ Hi uint64

+ Lo uint64

+ Port uint32

+ func NewIp6AndPort(ip net.IP, port uint32) *Ip6AndPort

+ func NewIp6AndPortFromNetIP(ip netip.Addr, port uint16) *Ip6AndPort

+ func (*Ip6AndPort) Descriptor() ([]byte, []int)

+ func (*Ip6AndPort) ProtoMessage()

+ func (m *Ip6AndPort) GetHi() uint64

+ func (m *Ip6AndPort) GetLo() uint64

+ func (m *Ip6AndPort) GetPort() uint32

+ func (m *Ip6AndPort) Marshal() (dAtA []byte, err error)

+ func (m *Ip6AndPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *Ip6AndPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *Ip6AndPort) Reset()

+ func (m *Ip6AndPort) Size() (n int)

+ func (m *Ip6AndPort) String() string

+ func (m *Ip6AndPort) Unmarshal(dAtA []byte) error

+ func (m *Ip6AndPort) XXX_DiscardUnknown()

+ func (m *Ip6AndPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Ip6AndPort) XXX_Merge(src proto.Message)

+ func (m *Ip6AndPort) XXX_Size() int

+ func (m *Ip6AndPort) XXX_Unmarshal(b []byte) error

+ type LightHouse struct

+ func NewLightHouseFromConfig(ctx context.Context, l *logrus.Logger, c *config.C, myVpnNet *net.IPNet, ...) (*LightHouse, error)

+ func (lh *LightHouse) DeleteVpnIp(vpnIp iputil.VpnIp)

+ func (lh *LightHouse) GetAdvertiseAddrs() []netIpAndPort

+ func (lh *LightHouse) GetLighthouses() map[iputil.VpnIp]struct{}

+ func (lh *LightHouse) GetLocalAllowList() *LocalAllowList

+ func (lh *LightHouse) GetRelaysForMe() []iputil.VpnIp

+ func (lh *LightHouse) GetRemoteAllowList() *RemoteAllowList

+ func (lh *LightHouse) GetStaticHostList() map[iputil.VpnIp]struct{}

+ func (lh *LightHouse) GetUpdateInterval() int64

+ func (lh *LightHouse) IsLighthouseIP(vpnIp iputil.VpnIp) bool

+ func (lh *LightHouse) NewRequestHandler() *LightHouseHandler

+ func (lh *LightHouse) Query(ip iputil.VpnIp) *RemoteList

+ func (lh *LightHouse) QueryCache(ip iputil.VpnIp) *RemoteList

+ func (lh *LightHouse) QueryServer(ip iputil.VpnIp)

+ func (lh *LightHouse) SendUpdate()

+ func (lh *LightHouse) StartUpdateWorker()

+ type LightHouseHandler struct

+ func (lhh *LightHouseHandler) HandleRequest(rAddr *udp.Addr, vpnIp iputil.VpnIp, p []byte, w EncWriter)

+ type LocalAllowList struct

+ AllowList *AllowList

+ func NewLocalAllowListFromConfig(c *config.C, k string) (*LocalAllowList, error)

+ func (al *LocalAllowList) Allow(ip net.IP) bool

+ func (al *LocalAllowList) AllowName(name string) bool

+ type LockingTimerWheel struct

+ func NewLockingTimerWheel[T any](min, max time.Duration) *LockingTimerWheel[T]

+ func (lw *LockingTimerWheel[T]) Add(v T, timeout time.Duration) *TimeoutItem[T]

+ func (lw *LockingTimerWheel[T]) Advance(now time.Time)

+ func (lw *LockingTimerWheel[T]) Purge() (T, bool)

+ type MessageMetrics struct

+ func (m *MessageMetrics) Rx(t header.MessageType, s header.MessageSubType, i int64)

+ func (m *MessageMetrics) Tx(t header.MessageType, s header.MessageSubType, i int64)

+ type NebulaCipherState struct

+ func NewNebulaCipherState(s *noise.CipherState) *NebulaCipherState

+ func (s *NebulaCipherState) DecryptDanger(out, ad, ciphertext []byte, n uint64, nb []byte) ([]byte, error)

+ func (s *NebulaCipherState) EncryptDanger(out, ad, plaintext []byte, n uint64, nb []byte) ([]byte, error)

+ func (s *NebulaCipherState) Overhead() int

+ type NebulaControl struct

+ InitiatorRelayIndex uint32

+ RelayFromIp uint32

+ RelayToIp uint32

+ ResponderRelayIndex uint32

+ Type NebulaControl_MessageType

+ func (*NebulaControl) Descriptor() ([]byte, []int)

+ func (*NebulaControl) ProtoMessage()

+ func (m *NebulaControl) GetInitiatorRelayIndex() uint32

+ func (m *NebulaControl) GetRelayFromIp() uint32

+ func (m *NebulaControl) GetRelayToIp() uint32

+ func (m *NebulaControl) GetResponderRelayIndex() uint32

+ func (m *NebulaControl) GetType() NebulaControl_MessageType

+ func (m *NebulaControl) Marshal() (dAtA []byte, err error)

+ func (m *NebulaControl) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaControl) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaControl) Reset()

+ func (m *NebulaControl) Size() (n int)

+ func (m *NebulaControl) String() string

+ func (m *NebulaControl) Unmarshal(dAtA []byte) error

+ func (m *NebulaControl) XXX_DiscardUnknown()

+ func (m *NebulaControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaControl) XXX_Merge(src proto.Message)

+ func (m *NebulaControl) XXX_Size() int

+ func (m *NebulaControl) XXX_Unmarshal(b []byte) error

+ type NebulaControl_MessageType int32

+ const NebulaControl_CreateRelayRequest

+ const NebulaControl_CreateRelayResponse

+ const NebulaControl_None

+ func (NebulaControl_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaControl_MessageType) String() string

+ type NebulaHandshake struct

+ Details *NebulaHandshakeDetails

+ Hmac []byte

+ func (*NebulaHandshake) Descriptor() ([]byte, []int)

+ func (*NebulaHandshake) ProtoMessage()

+ func (m *NebulaHandshake) GetDetails() *NebulaHandshakeDetails

+ func (m *NebulaHandshake) GetHmac() []byte

+ func (m *NebulaHandshake) Marshal() (dAtA []byte, err error)

+ func (m *NebulaHandshake) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaHandshake) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaHandshake) Reset()

+ func (m *NebulaHandshake) Size() (n int)

+ func (m *NebulaHandshake) String() string

+ func (m *NebulaHandshake) Unmarshal(dAtA []byte) error

+ func (m *NebulaHandshake) XXX_DiscardUnknown()

+ func (m *NebulaHandshake) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaHandshake) XXX_Merge(src proto.Message)

+ func (m *NebulaHandshake) XXX_Size() int

+ func (m *NebulaHandshake) XXX_Unmarshal(b []byte) error

+ type NebulaHandshakeDetails struct

+ Cert []byte

+ Cookie uint64

+ InitiatorIndex uint32

+ ResponderIndex uint32

+ Time uint64

+ func (*NebulaHandshakeDetails) Descriptor() ([]byte, []int)

+ func (*NebulaHandshakeDetails) ProtoMessage()

+ func (m *NebulaHandshakeDetails) GetCert() []byte

+ func (m *NebulaHandshakeDetails) GetCookie() uint64

+ func (m *NebulaHandshakeDetails) GetInitiatorIndex() uint32

+ func (m *NebulaHandshakeDetails) GetResponderIndex() uint32

+ func (m *NebulaHandshakeDetails) GetTime() uint64

+ func (m *NebulaHandshakeDetails) Marshal() (dAtA []byte, err error)

+ func (m *NebulaHandshakeDetails) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaHandshakeDetails) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaHandshakeDetails) Reset()

+ func (m *NebulaHandshakeDetails) Size() (n int)

+ func (m *NebulaHandshakeDetails) String() string

+ func (m *NebulaHandshakeDetails) Unmarshal(dAtA []byte) error

+ func (m *NebulaHandshakeDetails) XXX_DiscardUnknown()

+ func (m *NebulaHandshakeDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaHandshakeDetails) XXX_Merge(src proto.Message)

+ func (m *NebulaHandshakeDetails) XXX_Size() int

+ func (m *NebulaHandshakeDetails) XXX_Unmarshal(b []byte) error

+ type NebulaMeta struct

+ Details *NebulaMetaDetails

+ Type NebulaMeta_MessageType

+ func NewLhQueryByInt(VpnIp iputil.VpnIp) *NebulaMeta

+ func (*NebulaMeta) Descriptor() ([]byte, []int)

+ func (*NebulaMeta) ProtoMessage()

+ func (m *NebulaMeta) GetDetails() *NebulaMetaDetails

+ func (m *NebulaMeta) GetType() NebulaMeta_MessageType

+ func (m *NebulaMeta) Marshal() (dAtA []byte, err error)

+ func (m *NebulaMeta) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaMeta) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaMeta) Reset()

+ func (m *NebulaMeta) Size() (n int)

+ func (m *NebulaMeta) String() string

+ func (m *NebulaMeta) Unmarshal(dAtA []byte) error

+ func (m *NebulaMeta) XXX_DiscardUnknown()

+ func (m *NebulaMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaMeta) XXX_Merge(src proto.Message)

+ func (m *NebulaMeta) XXX_Size() int

+ func (m *NebulaMeta) XXX_Unmarshal(b []byte) error

+ type NebulaMetaDetails struct

+ Counter uint32

+ Ip4AndPorts []*Ip4AndPort

+ Ip6AndPorts []*Ip6AndPort

+ RelayVpnIp []uint32

+ VpnIp uint32

+ func (*NebulaMetaDetails) Descriptor() ([]byte, []int)

+ func (*NebulaMetaDetails) ProtoMessage()

+ func (m *NebulaMetaDetails) GetCounter() uint32

+ func (m *NebulaMetaDetails) GetIp4AndPorts() []*Ip4AndPort

+ func (m *NebulaMetaDetails) GetIp6AndPorts() []*Ip6AndPort

+ func (m *NebulaMetaDetails) GetRelayVpnIp() []uint32

+ func (m *NebulaMetaDetails) GetVpnIp() uint32

+ func (m *NebulaMetaDetails) Marshal() (dAtA []byte, err error)

+ func (m *NebulaMetaDetails) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaMetaDetails) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaMetaDetails) Reset()

+ func (m *NebulaMetaDetails) Size() (n int)

+ func (m *NebulaMetaDetails) String() string

+ func (m *NebulaMetaDetails) Unmarshal(dAtA []byte) error

+ func (m *NebulaMetaDetails) XXX_DiscardUnknown()

+ func (m *NebulaMetaDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaMetaDetails) XXX_Merge(src proto.Message)

+ func (m *NebulaMetaDetails) XXX_Size() int

+ func (m *NebulaMetaDetails) XXX_Unmarshal(b []byte) error

+ type NebulaMeta_MessageType int32

+ const NebulaMeta_HostMovedNotification

+ const NebulaMeta_HostPunchNotification

+ const NebulaMeta_HostQuery

+ const NebulaMeta_HostQueryReply

+ const NebulaMeta_HostUpdateNotification

+ const NebulaMeta_HostUpdateNotificationAck

+ const NebulaMeta_HostWhoami

+ const NebulaMeta_HostWhoamiReply

+ const NebulaMeta_None

+ const NebulaMeta_PathCheck

+ const NebulaMeta_PathCheckReply

+ func (NebulaMeta_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaMeta_MessageType) String() string

+ type NebulaPing struct

+ Time uint64

+ Type NebulaPing_MessageType

+ func (*NebulaPing) Descriptor() ([]byte, []int)

+ func (*NebulaPing) ProtoMessage()

+ func (m *NebulaPing) GetTime() uint64

+ func (m *NebulaPing) GetType() NebulaPing_MessageType

+ func (m *NebulaPing) Marshal() (dAtA []byte, err error)

+ func (m *NebulaPing) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaPing) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaPing) Reset()

+ func (m *NebulaPing) Size() (n int)

+ func (m *NebulaPing) String() string

+ func (m *NebulaPing) Unmarshal(dAtA []byte) error

+ func (m *NebulaPing) XXX_DiscardUnknown()

+ func (m *NebulaPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaPing) XXX_Merge(src proto.Message)

+ func (m *NebulaPing) XXX_Size() int

+ func (m *NebulaPing) XXX_Unmarshal(b []byte) error

+ type NebulaPing_MessageType int32

+ const NebulaPing_Ping

+ const NebulaPing_Reply

+ func (NebulaPing_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaPing_MessageType) String() string

+ type PKI struct

+ func NewPKIFromConfig(l *logrus.Logger, c *config.C) (*PKI, error)

+ func (p *PKI) GetCAPool() *cert.NebulaCAPool

+ func (p *PKI) GetCertState() *CertState

+ type Punchy struct

+ func NewPunchyFromConfig(l *logrus.Logger, c *config.C) *Punchy

+ func (p *Punchy) GetDelay() time.Duration

+ func (p *Punchy) GetPunch() bool

+ func (p *Punchy) GetRespond() bool

+ func (p *Punchy) GetRespondDelay() time.Duration

+ func (p *Punchy) GetTargetEverything() bool

+ type Relay struct

+ LocalIndex uint32

+ PeerIp iputil.VpnIp

+ RemoteIndex uint32

+ State int

+ Type int

+ type RelayState struct

+ func (rs *RelayState) CompleteRelayByIP(vpnIp iputil.VpnIp, remoteIdx uint32) bool

+ func (rs *RelayState) CompleteRelayByIdx(localIdx uint32, remoteIdx uint32) (*Relay, bool)

+ func (rs *RelayState) CopyAllRelayFor() []*Relay

+ func (rs *RelayState) CopyRelayForIdxs() []uint32

+ func (rs *RelayState) CopyRelayForIps() []iputil.VpnIp

+ func (rs *RelayState) CopyRelayIps() []iputil.VpnIp

+ func (rs *RelayState) DeleteRelay(ip iputil.VpnIp)

+ func (rs *RelayState) GetRelayForByIp(ip iputil.VpnIp) (*Relay, bool)

+ func (rs *RelayState) InsertRelay(ip iputil.VpnIp, idx uint32, r *Relay)

+ func (rs *RelayState) InsertRelayTo(ip iputil.VpnIp)

+ func (rs *RelayState) QueryRelayForByIdx(idx uint32) (*Relay, bool)

+ func (rs *RelayState) QueryRelayForByIp(vpnIp iputil.VpnIp) (*Relay, bool)

+ func (rs *RelayState) RemoveRelay(localIdx uint32) (iputil.VpnIp, bool)

+ type RemoteAllowList struct

+ AllowList *AllowList

+ func NewRemoteAllowListFromConfig(c *config.C, k, rangesKey string) (*RemoteAllowList, error)

+ func (al *RemoteAllowList) Allow(vpnIp iputil.VpnIp, ip net.IP) bool

+ func (al *RemoteAllowList) AllowIpV4(vpnIp iputil.VpnIp, ip iputil.VpnIp) bool

+ func (al *RemoteAllowList) AllowIpV6(vpnIp iputil.VpnIp, hi, lo uint64) bool

+ func (al *RemoteAllowList) AllowUnknownVpnIp(ip net.IP) bool

+ type RemoteList struct

+ func NewRemoteList(shouldAdd func(netip.Addr) bool) *RemoteList

+ func (r *RemoteList) BlockRemote(bad *udp.Addr)

+ func (r *RemoteList) CopyAddrs(preferredRanges []*net.IPNet) []*udp.Addr

+ func (r *RemoteList) CopyBlockedRemotes() []*udp.Addr

+ func (r *RemoteList) CopyCache() *CacheMap

+ func (r *RemoteList) ForEach(preferredRanges []*net.IPNet, forEach forEachFunc)

+ func (r *RemoteList) LearnRemote(ownerVpnIp iputil.VpnIp, addr *udp.Addr)

+ func (r *RemoteList) Len(preferredRanges []*net.IPNet) int

+ func (r *RemoteList) Rebuild(preferredRanges []*net.IPNet)

+ func (r *RemoteList) ResetBlockedRemotes()

+ type TimeoutItem struct

+ Item T

+ Next *TimeoutItem[T]

+ type TimeoutList struct

+ Head *TimeoutItem[T]

+ Tail *TimeoutItem[T]

+ type TimerWheel struct

+ func NewTimerWheel[T any](min, max time.Duration) *TimerWheel[T]

+ func (tw *TimerWheel[T]) Add(v T, timeout time.Duration) *TimeoutItem[T]

+ func (tw *TimerWheel[T]) Advance(now time.Time)

+ func (tw *TimerWheel[T]) Purge() (T, bool)

+ type UEClient struct

+ func (s *UEClient) Action(ctx context.Context, req *avoid.ActionRequest) (*avoid.ConnectionInfo, error)

+ func (s *UEClient) HealthCheck(ctx context.Context, req *avoid.HealthRequest) (*avoid.HealthReply, error)

+ type ViaSender struct