// Copyright (c) Tailscale Inc & contributors

// SPDX-License-Identifier: BSD-3-Clause

// Code generated by tailscale/cmd/viewer; DO NOT EDIT.

package tailcfg

import (

jsonv1 "encoding/json"

"errors"

"net/netip"

"time"

jsonv2 "github.com/go-json-experiment/json"

"github.com/go-json-experiment/json/jsontext"

"tailscale.com/types/dnstype"

"tailscale.com/types/key"

"tailscale.com/types/opt"

"tailscale.com/types/structs"

"tailscale.com/types/tkatype"

"tailscale.com/types/views"

)

//go:generate go run tailscale.com/cmd/cloner -clonefunc=true -type=User,Node,Hostinfo,NetInfo,Login,DNSConfig,RegisterResponse,RegisterResponseAuth,RegisterRequest,DERPHomeParams,DERPRegion,DERPMap,DERPNode,SSHRule,SSHAction,SSHPrincipal,ControlDialPlan,Location,UserProfile,VIPService,SSHPolicy

// View returns a read-only view of User.

func (p *User) View() UserView {

return UserView{ж: p}

}

// UserView provides a read-only view over User.

//

// Its methods should only be called if `Valid()` returns true.

type UserView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *User

}

// Valid reports whether v's underlying value is non-nil.

func (v UserView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v UserView) AsStruct() *User {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v UserView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v UserView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *UserView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x User

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *UserView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x User

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

func (v UserView) ID() UserID { return v.ж.ID }

// if non-empty overrides Login field

func (v UserView) DisplayName() string { return v.ж.DisplayName }

// if non-empty overrides Login field

func (v UserView) ProfilePicURL() string { return v.ж.ProfilePicURL }

func (v UserView) Created() time.Time { return v.ж.Created }

// A compilation failure here means this code must be regenerated, with the command at the top of this file.

var _UserViewNeedsRegeneration = User(struct {

ID UserID

DisplayName string

ProfilePicURL string

Created time.Time

}{})

// View returns a read-only view of Node.

func (p *Node) View() NodeView {

return NodeView{ж: p}

}

// NodeView provides a read-only view over Node.

//

// Its methods should only be called if `Valid()` returns true.

type NodeView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *Node

}

// Valid reports whether v's underlying value is non-nil.

func (v NodeView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v NodeView) AsStruct() *Node {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v NodeView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v NodeView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *NodeView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x Node

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *NodeView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x Node

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

func (v NodeView) ID() NodeID { return v.ж.ID }

func (v NodeView) StableID() StableNodeID { return v.ж.StableID }

// Name is the FQDN of the node.

// It is also the MagicDNS name for the node.

// It has a trailing dot.

// e.g. "host.tail-scale.ts.net."

func (v NodeView) Name() string { return v.ж.Name }

// User is the user who created the node. If ACL tags are in use for the

// node then it doesn't reflect the ACL identity that the node is running

// as.

func (v NodeView) User() UserID { return v.ж.User }

// Sharer, if non-zero, is the user who shared this node, if different than User.

func (v NodeView) Sharer() UserID { return v.ж.Sharer }

func (v NodeView) Key() key.NodePublic { return v.ж.Key }

// the zero value if this node does not expire

func (v NodeView) KeyExpiry() time.Time { return v.ж.KeyExpiry }

func (v NodeView) KeySignature() views.ByteSlice[tkatype.MarshaledSignature] {

return views.ByteSliceOf(v.ж.KeySignature)

}

func (v NodeView) Machine() key.MachinePublic { return v.ж.Machine }

func (v NodeView) DiscoKey() key.DiscoPublic { return v.ж.DiscoKey }

// Addresses are the IP addresses of this Node directly.

func (v NodeView) Addresses() views.Slice[netip.Prefix] { return views.SliceOf(v.ж.Addresses) }

// AllowedIPs are the IP ranges to route to this node.

//

// As of CapabilityVersion 112, this may be nil (null or undefined) on the wire

// to mean the same as Addresses. Internally, it is always filled in with

// its possibly-implicit value.

func (v NodeView) AllowedIPs() views.Slice[netip.Prefix] { return views.SliceOf(v.ж.AllowedIPs) }

// IP+port (public via STUN, and local LANs)

func (v NodeView) Endpoints() views.Slice[netip.AddrPort] { return views.SliceOf(v.ж.Endpoints) }

// LegacyDERPString is this node's home LegacyDERPString region ID integer, but shoved into an

// IP:port string for legacy reasons. The IP address is always "127.3.3.40"

// (a loopback address (127) followed by the digits over the letters DERP on

// a QWERTY keyboard (3.3.40)). The "port number" is the home LegacyDERPString region ID

// integer.

//

// Deprecated: HomeDERP has replaced this, but old servers might still send

// this field. See tailscale/tailscale#14636. Do not use this field in code

// other than in the upgradeNode func, which canonicalizes it to HomeDERP

// if it arrives as a LegacyDERPString string on the wire.

func (v NodeView) LegacyDERPString() string { return v.ж.LegacyDERPString }

// HomeDERP is the modern version of the DERP string field, with just an

// integer. The client advertises support for this as of capver 111.

//

// HomeDERP may be zero if not (yet) known, but ideally always be non-zero

// for magicsock connectivity to function normally.

func (v NodeView) HomeDERP() int { return v.ж.HomeDERP }

func (v NodeView) Hostinfo() HostinfoView { return v.ж.Hostinfo }

func (v NodeView) Created() time.Time { return v.ж.Created }

// if non-zero, the node's capability version; old servers might not send

func (v NodeView) Cap() CapabilityVersion { return v.ж.Cap }

// Tags are the list of ACL tags applied to this node.

// Tags take the form of `tag:<value>` where value starts

// with a letter and only contains alphanumerics and dashes `-`.

// Some valid tag examples:

//

// `tag:prod`

// `tag:database`

// `tag:lab-1`

func (v NodeView) Tags() views.Slice[string] { return views.SliceOf(v.ж.Tags) }

// PrimaryRoutes are the routes from AllowedIPs that this node

// is currently the primary subnet router for, as determined

// by the control plane. It does not include the self address

// values from Addresses that are in AllowedIPs.

func (v NodeView) PrimaryRoutes() views.Slice[netip.Prefix] { return views.SliceOf(v.ж.PrimaryRoutes) }

// LastSeen is when the node was last online. It is not

// updated when Online is true. It is nil if the current

// node doesn't have permission to know, or the node

// has never been online.

func (v NodeView) LastSeen() views.ValuePointer[time.Time] {

return views.ValuePointerOf(v.ж.LastSeen)

}

// Online is whether the node is currently connected to the

// coordination server. A value of nil means unknown, or the

// current node doesn't have permission to know.

func (v NodeView) Online() views.ValuePointer[bool] { return views.ValuePointerOf(v.ж.Online) }

// TODO(crawshaw): replace with MachineStatus

func (v NodeView) MachineAuthorized() bool { return v.ж.MachineAuthorized }

// Capabilities are capabilities that the node has.

// They're free-form strings, but should be in the form of URLs/URIs

// such as:

//

// "https://tailscale.com/cap/is-admin"

// "https://tailscale.com/cap/file-sharing"

//

// Deprecated: use CapMap instead. See https://github.com/tailscale/tailscale/issues/11508

func (v NodeView) Capabilities() views.Slice[NodeCapability] { return views.SliceOf(v.ж.Capabilities) }

// CapMap is a map of capabilities to their optional argument/data values.

//

// It is valid for a capability to not have any argument/data values; such

// capabilities can be tested for using the HasCap method. These type of

// capabilities are used to indicate that a node has a capability, but there

// is no additional data associated with it. These were previously

// represented by the Capabilities field, but can now be represented by

// CapMap with an empty value.

//

// See NodeCapability for more information on keys.

//

// Metadata about nodes can be transmitted in 3 ways:

// 1. MapResponse.Node.CapMap describes attributes that affect behavior for

// this node, such as which features have been enabled through the admin

// panel and any associated configuration details.

// 2. MapResponse.PacketFilter(s) describes access (both IP and application

// based) that should be granted to peers.

// 3. MapResponse.Peers[].CapMap describes attributes regarding a peer node,

// such as which features the peer supports or if that peer is preferred

// for a particular task vs other peers that could also be chosen.

func (v NodeView) CapMap() views.MapSlice[NodeCapability, RawMessage] {

return views.MapSliceOf(v.ж.CapMap)

}

// UnsignedPeerAPIOnly means that this node is not signed nor subject to TKA

// restrictions. However, in exchange for that privilege, it does not get

// network access. It can only access this node's peerapi, which may not let

// it do anything. It is the tailscaled client's job to double-check the

// MapResponse's PacketFilter to verify that its AllowedIPs will not be

// accepted by the packet filter.

func (v NodeView) UnsignedPeerAPIOnly() bool { return v.ж.UnsignedPeerAPIOnly }

// MagicDNS base name (for normal non-shared-in nodes), FQDN (without trailing dot, for shared-in nodes), or Hostname (if no MagicDNS)

func (v NodeView) ComputedName() string { return v.ж.ComputedName }

// either "ComputedName" or "ComputedName (computedHostIfDifferent)", if computedHostIfDifferent is set

func (v NodeView) ComputedNameWithHost() string { return v.ж.ComputedNameWithHost }

// DataPlaneAuditLogID is the per-node logtail ID used for data plane audit logging.

func (v NodeView) DataPlaneAuditLogID() string { return v.ж.DataPlaneAuditLogID }

// Expired is whether this node's key has expired. Control may send

// this; clients are only allowed to set this from false to true. On

// the client, this is calculated client-side based on a timestamp sent

// from control, to avoid clock skew issues.

func (v NodeView) Expired() bool { return v.ж.Expired }

// SelfNodeV4MasqAddrForThisPeer is the IPv4 that this peer knows the current node as.

// It may be empty if the peer knows the current node by its native

// IPv4 address.

// This field is only populated in a MapResponse for peers and not

// for the current node.

//

// If set, it should be used to masquerade traffic originating from the

// current node to this peer. The masquerade address is only relevant

// for this peer and not for other peers.

//

// This only applies to traffic originating from the current node to the

// peer or any of its subnets. Traffic originating from subnet routes will

// not be masqueraded (e.g. in case of --snat-subnet-routes).

func (v NodeView) SelfNodeV4MasqAddrForThisPeer() views.ValuePointer[netip.Addr] {

return views.ValuePointerOf(v.ж.SelfNodeV4MasqAddrForThisPeer)

}

// SelfNodeV6MasqAddrForThisPeer is the IPv6 that this peer knows the current node as.

// It may be empty if the peer knows the current node by its native

// IPv6 address.

// This field is only populated in a MapResponse for peers and not

// for the current node.

//

// If set, it should be used to masquerade traffic originating from the

// current node to this peer. The masquerade address is only relevant

// for this peer and not for other peers.

//

// This only applies to traffic originating from the current node to the

// peer or any of its subnets. Traffic originating from subnet routes will

// not be masqueraded (e.g. in case of --snat-subnet-routes).

func (v NodeView) SelfNodeV6MasqAddrForThisPeer() views.ValuePointer[netip.Addr] {

return views.ValuePointerOf(v.ж.SelfNodeV6MasqAddrForThisPeer)

}

// IsWireGuardOnly indicates that this is a non-Tailscale WireGuard peer, it

// is not expected to speak Disco or DERP, and it must have Endpoints in

// order to be reachable.

func (v NodeView) IsWireGuardOnly() bool { return v.ж.IsWireGuardOnly }

// IsJailed indicates that this node is jailed and should not be allowed

// initiate connections, however outbound connections to it should still be

// allowed.

func (v NodeView) IsJailed() bool { return v.ж.IsJailed }

// ExitNodeDNSResolvers is the list of DNS servers that should be used when this

// node is marked IsWireGuardOnly and being used as an exit node.

func (v NodeView) ExitNodeDNSResolvers() views.SliceView[*dnstype.Resolver, dnstype.ResolverView] {

return views.SliceOfViews[*dnstype.Resolver, dnstype.ResolverView](v.ж.ExitNodeDNSResolvers)

}

func (v NodeView) Equal(v2 NodeView) bool { return v.ж.Equal(v2.ж) }

// A compilation failure here means this code must be regenerated, with the command at the top of this file.

var _NodeViewNeedsRegeneration = Node(struct {

ID NodeID

StableID StableNodeID

Name string

User UserID

Sharer UserID

Key key.NodePublic

KeyExpiry time.Time

KeySignature tkatype.MarshaledSignature

Machine key.MachinePublic

DiscoKey key.DiscoPublic

Addresses []netip.Prefix

AllowedIPs []netip.Prefix

Endpoints []netip.AddrPort

LegacyDERPString string

HomeDERP int

Hostinfo HostinfoView

Created time.Time

Cap CapabilityVersion

Tags []string

PrimaryRoutes []netip.Prefix

LastSeen *time.Time

Online *bool

MachineAuthorized bool

Capabilities []NodeCapability

CapMap NodeCapMap

UnsignedPeerAPIOnly bool

ComputedName string

computedHostIfDifferent string

ComputedNameWithHost string

DataPlaneAuditLogID string

Expired bool

SelfNodeV4MasqAddrForThisPeer *netip.Addr

SelfNodeV6MasqAddrForThisPeer *netip.Addr

IsWireGuardOnly bool

IsJailed bool

ExitNodeDNSResolvers []*dnstype.Resolver

}{})

// View returns a read-only view of Hostinfo.

func (p *Hostinfo) View() HostinfoView {

return HostinfoView{ж: p}

}

// HostinfoView provides a read-only view over Hostinfo.

//

// Its methods should only be called if `Valid()` returns true.

type HostinfoView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *Hostinfo

}

// Valid reports whether v's underlying value is non-nil.

func (v HostinfoView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v HostinfoView) AsStruct() *Hostinfo {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v HostinfoView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v HostinfoView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *HostinfoView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x Hostinfo

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *HostinfoView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x Hostinfo

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// version of this code (in version.Long format)

func (v HostinfoView) IPNVersion() string { return v.ж.IPNVersion }

// logtail ID of frontend instance

func (v HostinfoView) FrontendLogID() string { return v.ж.FrontendLogID }

// logtail ID of backend instance

func (v HostinfoView) BackendLogID() string { return v.ж.BackendLogID }

// operating system the client runs on (a version.OS value)

func (v HostinfoView) OS() string { return v.ж.OS }

// OSVersion is the version of the OS, if available.

//

// For Android, it's like "10", "11", "12", etc. For iOS and macOS it's like

// "15.6.1" or "12.4.0". For Windows it's like "10.0.19044.1889". For

// FreeBSD it's like "12.3-STABLE".

//

// For Linux, prior to Tailscale 1.32, we jammed a bunch of fields into this

// string on Linux, like "Debian 10.4; kernel=xxx; container; env=kn" and so

// on. As of Tailscale 1.32, this is simply the kernel version on Linux, like

// "5.10.0-17-amd64".

func (v HostinfoView) OSVersion() string { return v.ж.OSVersion }

// best-effort whether the client is running in a container

func (v HostinfoView) Container() opt.Bool { return v.ж.Container }

// a hostinfo.EnvType in string form

func (v HostinfoView) Env() string { return v.ж.Env }

// "debian", "ubuntu", "nixos", ...

func (v HostinfoView) Distro() string { return v.ж.Distro }

// "20.04", ...

func (v HostinfoView) DistroVersion() string { return v.ж.DistroVersion }

// "jammy", "bullseye", ...

func (v HostinfoView) DistroCodeName() string { return v.ж.DistroCodeName }

// App is used to disambiguate Tailscale clients that run using tsnet.

func (v HostinfoView) App() string { return v.ж.App }

// if a desktop was detected on Linux

func (v HostinfoView) Desktop() opt.Bool { return v.ж.Desktop }

// Tailscale package to disambiguate ("choco", "appstore", etc; "" for unknown)

func (v HostinfoView) Package() string { return v.ж.Package }

// mobile phone model ("Pixel 3a", "iPhone12,3")

func (v HostinfoView) DeviceModel() string { return v.ж.DeviceModel }

// macOS/iOS APNs device token for notifications (and Android in the future)

func (v HostinfoView) PushDeviceToken() string { return v.ж.PushDeviceToken }

// name of the host the client runs on

func (v HostinfoView) Hostname() string { return v.ж.Hostname }

// indicates whether the host is blocking incoming connections

func (v HostinfoView) ShieldsUp() bool { return v.ж.ShieldsUp }

// indicates this node exists in netmap because it's owned by a shared-to user

func (v HostinfoView) ShareeNode() bool { return v.ж.ShareeNode }

// indicates that the user has opted out of sending logs and support

func (v HostinfoView) NoLogsNoSupport() bool { return v.ж.NoLogsNoSupport }

// WireIngress indicates that the node would like to be wired up server-side

// (DNS, etc) to be able to use Tailscale Funnel, even if it's not currently

// enabled. For example, the user might only use it for intermittent

// foreground CLI serve sessions, for which they'd like it to work right

// away, even if it's disabled most of the time. As an optimization, this is

// only sent if IngressEnabled is false, as IngressEnabled implies that this

// option is true.

func (v HostinfoView) WireIngress() bool { return v.ж.WireIngress }

// if the node has any funnel endpoint enabled

func (v HostinfoView) IngressEnabled() bool { return v.ж.IngressEnabled }

// indicates that the node has opted-in to admin-console-drive remote updates

func (v HostinfoView) AllowsUpdate() bool { return v.ж.AllowsUpdate }

// the current host's machine type (uname -m)

func (v HostinfoView) Machine() string { return v.ж.Machine }

// GOARCH value (of the built binary)

func (v HostinfoView) GoArch() string { return v.ж.GoArch }

// GOARM, GOAMD64, etc (of the built binary)

func (v HostinfoView) GoArchVar() string { return v.ж.GoArchVar }

// Go version binary was built with

func (v HostinfoView) GoVersion() string { return v.ж.GoVersion }

// set of IP ranges this client can route

func (v HostinfoView) RoutableIPs() views.Slice[netip.Prefix] { return views.SliceOf(v.ж.RoutableIPs) }

// set of ACL tags this node wants to claim

func (v HostinfoView) RequestTags() views.Slice[string] { return views.SliceOf(v.ж.RequestTags) }

// MAC address(es) to send Wake-on-LAN packets to wake this node (lowercase hex w/ colons)

func (v HostinfoView) WoLMACs() views.Slice[string] { return views.SliceOf(v.ж.WoLMACs) }

// services advertised by this machine

func (v HostinfoView) Services() views.Slice[Service] { return views.SliceOf(v.ж.Services) }

func (v HostinfoView) NetInfo() NetInfoView { return v.ж.NetInfo.View() }

// if advertised

func (v HostinfoView) SSH_HostKeys() views.Slice[string] { return views.SliceOf(v.ж.SSH_HostKeys) }

func (v HostinfoView) Cloud() string { return v.ж.Cloud }

// if the client is running in userspace (netstack) mode

func (v HostinfoView) Userspace() opt.Bool { return v.ж.Userspace }

// if the client's subnet router is running in userspace (netstack) mode

func (v HostinfoView) UserspaceRouter() opt.Bool { return v.ж.UserspaceRouter }

// if the client is running the app-connector service

func (v HostinfoView) AppConnector() opt.Bool { return v.ж.AppConnector }

// opaque hash of the most recent list of tailnet services, change in hash indicates config should be fetched via c2n

func (v HostinfoView) ServicesHash() string { return v.ж.ServicesHash }

// if the client is willing to relay traffic for other peers

func (v HostinfoView) PeerRelay() bool { return v.ж.PeerRelay }

// the client’s selected exit node, empty when unselected.

func (v HostinfoView) ExitNodeID() StableNodeID { return v.ж.ExitNodeID }

// Location represents geographical location data about a

// Tailscale host. Location is optional and only set if

// explicitly declared by a node.

func (v HostinfoView) Location() LocationView { return v.ж.Location.View() }

// TPM device metadata, if available

func (v HostinfoView) TPM() views.ValuePointer[TPMInfo] { return views.ValuePointerOf(v.ж.TPM) }

// StateEncrypted reports whether the node state is stored encrypted on

// disk. The actual mechanism is platform-specific:

// - Apple nodes use the Keychain

// - Linux and Windows nodes use the TPM

// - Android apps use EncryptedSharedPreferences

func (v HostinfoView) StateEncrypted() opt.Bool { return v.ж.StateEncrypted }

func (v HostinfoView) Equal(v2 HostinfoView) bool { return v.ж.Equal(v2.ж) }

// A compilation failure here means this code must be regenerated, with the command at the top of this file.

var _HostinfoViewNeedsRegeneration = Hostinfo(struct {

IPNVersion string

FrontendLogID string

BackendLogID string

OS string

OSVersion string

Container opt.Bool

Env string

Distro string

DistroVersion string

DistroCodeName string

App string

Desktop opt.Bool

Package string

DeviceModel string

PushDeviceToken string

Hostname string

ShieldsUp bool

ShareeNode bool

NoLogsNoSupport bool

WireIngress bool

IngressEnabled bool

AllowsUpdate bool

Machine string

GoArch string

GoArchVar string

GoVersion string

RoutableIPs []netip.Prefix

RequestTags []string

WoLMACs []string

Services []Service

NetInfo *NetInfo

SSH_HostKeys []string

Cloud string

Userspace opt.Bool

UserspaceRouter opt.Bool

AppConnector opt.Bool

ServicesHash string

PeerRelay bool

ExitNodeID StableNodeID

Location *Location

TPM *TPMInfo

StateEncrypted opt.Bool

}{})

// View returns a read-only view of NetInfo.

func (p *NetInfo) View() NetInfoView {

return NetInfoView{ж: p}

}

// NetInfoView provides a read-only view over NetInfo.

//

// Its methods should only be called if `Valid()` returns true.

type NetInfoView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *NetInfo

}

// Valid reports whether v's underlying value is non-nil.

func (v NetInfoView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v NetInfoView) AsStruct() *NetInfo {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v NetInfoView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v NetInfoView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *NetInfoView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x NetInfo

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *NetInfoView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x NetInfo

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// MappingVariesByDestIP says whether the host's NAT mappings

// vary based on the destination IP.

func (v NetInfoView) MappingVariesByDestIP() opt.Bool { return v.ж.MappingVariesByDestIP }

// WorkingIPv6 is whether the host has IPv6 internet connectivity.

func (v NetInfoView) WorkingIPv6() opt.Bool { return v.ж.WorkingIPv6 }

// OSHasIPv6 is whether the OS supports IPv6 at all, regardless of

// whether IPv6 internet connectivity is available.

func (v NetInfoView) OSHasIPv6() opt.Bool { return v.ж.OSHasIPv6 }

// WorkingUDP is whether the host has UDP internet connectivity.

func (v NetInfoView) WorkingUDP() opt.Bool { return v.ж.WorkingUDP }

// WorkingICMPv4 is whether ICMPv4 works.

// Empty means not checked.

func (v NetInfoView) WorkingICMPv4() opt.Bool { return v.ж.WorkingICMPv4 }

// HavePortMap is whether we have an existing portmap open

// (UPnP, PMP, or PCP).

func (v NetInfoView) HavePortMap() bool { return v.ж.HavePortMap }

// UPnP is whether UPnP appears present on the LAN.

// Empty means not checked.

func (v NetInfoView) UPnP() opt.Bool { return v.ж.UPnP }

// PMP is whether NAT-PMP appears present on the LAN.

// Empty means not checked.

func (v NetInfoView) PMP() opt.Bool { return v.ж.PMP }

// PCP is whether PCP appears present on the LAN.

// Empty means not checked.

func (v NetInfoView) PCP() opt.Bool { return v.ж.PCP }

// PreferredDERP is this node's preferred (home) DERP region ID.

// This is where the node expects to be contacted to begin a

// peer-to-peer connection. The node might be be temporarily

// connected to multiple DERP servers (to speak to other nodes

// that are located elsewhere) but PreferredDERP is the region ID

// that the node subscribes to traffic at.

// Zero means disconnected or unknown.

func (v NetInfoView) PreferredDERP() int { return v.ж.PreferredDERP }

// LinkType is the current link type, if known.

func (v NetInfoView) LinkType() string { return v.ж.LinkType }

// DERPLatency is the fastest recent time to reach various

// DERP STUN servers, in seconds. The map key is the

// "regionID-v4" or "-v6"; it was previously the DERP server's

// STUN host:port.

//

// This should only be updated rarely, or when there's a

// material change, as any change here also gets uploaded to

// the control plane.

func (v NetInfoView) DERPLatency() views.Map[string, float64] { return views.MapOf(v.ж.DERPLatency) }

// FirewallMode encodes both which firewall mode was selected and why.

// It is Linux-specific (at least as of 2023-08-19) and is meant to help

// debug iptables-vs-nftables issues. The string is of the form

// "{nft,ift}-REASON", like "nft-forced" or "ipt-default". Empty means

// either not Linux or a configuration in which the host firewall rules

// are not managed by tailscaled.

func (v NetInfoView) FirewallMode() string { return v.ж.FirewallMode }

func (v NetInfoView) String() string { return v.ж.String() }

// A compilation failure here means this code must be regenerated, with the command at the top of this file.

var _NetInfoViewNeedsRegeneration = NetInfo(struct {

MappingVariesByDestIP opt.Bool

WorkingIPv6 opt.Bool

OSHasIPv6 opt.Bool

WorkingUDP opt.Bool

WorkingICMPv4 opt.Bool

HavePortMap bool

UPnP opt.Bool

PMP opt.Bool

PCP opt.Bool

PreferredDERP int

LinkType string

DERPLatency map[string]float64

FirewallMode string

}{})

// View returns a read-only view of Login.

func (p *Login) View() LoginView {

return LoginView{ж: p}

}

// LoginView provides a read-only view over Login.

//

// Its methods should only be called if `Valid()` returns true.

type LoginView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *Login

}

// Valid reports whether v's underlying value is non-nil.

func (v LoginView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v LoginView) AsStruct() *Login {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v LoginView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v LoginView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *LoginView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x Login

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *LoginView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x Login

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// unused in the Tailscale client

func (v LoginView) ID() LoginID { return v.ж.ID }

// "google", "github", "okta_foo", etc.

func (v LoginView) Provider() string { return v.ж.Provider }

// an email address or "email-ish" string (like alice@github)

func (v LoginView) LoginName() string { return v.ж.LoginName }

// from the IdP

func (v LoginView) DisplayName() string { return v.ж.DisplayName }

// from the IdP

func (v LoginView) ProfilePicURL() string { return v.ж.ProfilePicURL }

// A compilation failure here means this code must be regenerated, with the command at the top of this file.

var _LoginViewNeedsRegeneration = Login(struct {

_ structs.Incomparable

ID LoginID

Provider string

LoginName string

DisplayName string

ProfilePicURL string

}{})

// View returns a read-only view of DNSConfig.

func (p *DNSConfig) View() DNSConfigView {

return DNSConfigView{ж: p}

}

// DNSConfigView provides a read-only view over DNSConfig.

//

// Its methods should only be called if `Valid()` returns true.

type DNSConfigView struct {

// ж is the underlying mutable value, named with a hard-to-type

// character that looks pointy like a pointer.

// It is named distinctively to make you think of how dangerous it is to escape

// to callers. You must not let callers be able to mutate it.

ж *DNSConfig

}

// Valid reports whether v's underlying value is non-nil.

func (v DNSConfigView) Valid() bool { return v.ж != nil }

// AsStruct returns a clone of the underlying value which aliases no memory with

// the original.

func (v DNSConfigView) AsStruct() *DNSConfig {

if v.ж == nil {

return nil

}

return v.ж.Clone()

}

// MarshalJSON implements [jsonv1.Marshaler].

func (v DNSConfigView) MarshalJSON() ([]byte, error) {

return jsonv1.Marshal(v.ж)

}

// MarshalJSONTo implements [jsonv2.MarshalerTo].

func (v DNSConfigView) MarshalJSONTo(enc *jsontext.Encoder) error {

return jsonv2.MarshalEncode(enc, v.ж)

}

// UnmarshalJSON implements [jsonv1.Unmarshaler].

func (v *DNSConfigView) UnmarshalJSON(b []byte) error {

if v.ж != nil {

return errors.New("already initialized")

}

if len(b) == 0 {

return nil

}

var x DNSConfig

if err := jsonv1.Unmarshal(b, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// UnmarshalJSONFrom implements [jsonv2.UnmarshalerFrom].

func (v *DNSConfigView) UnmarshalJSONFrom(dec *jsontext.Decoder) error {

if v.ж != nil {

return errors.New("already initialized")

}

var x DNSConfig

if err := jsonv2.UnmarshalDecode(dec, &x); err != nil {

return err

}

v.ж = &x

return nil

}

// Resolvers are the DNS resolvers to use, in order of preference.

func (v DNSConfigView) Resolvers() views.SliceView[*dnstype.Resolver, dnstype.ResolverView] {

return views.SliceOfViews[*dnstype.Resolver, dnstype.ResolverView](v.ж.Resolvers)

}

// Routes maps DNS name suffixes to a set of DNS resolvers to

// use. It is used to implement "split DNS" and other advanced DNS

// routing overlays.

//

// Map keys are fully-qualified DNS name suffixes; they may

// optionally contain a trailing dot but no leading dot.

//

// If the value is an empty slice, that means the suffix should still

// be handled by Tailscale's built-in resolver (100.100.100.100), such

// as for the purpose of handling ExtraRecords.

func (v DNSConfigView) Routes() views.MapFn[string, []*dnstype.Resolver, views.SliceView[*dnstype.Resolver, dnstype.ResolverView]] {