meshnet

type DNSManager interface {
	// Resolver returns a net.Resolver that can be used to resolve DNS names.
	Resolver() *net.Resolver
	// AddServers adds the given dns servers to the system configuration.
	AddServers(ctx context.Context, servers []netip.AddrPort) error
	// AddSearchDomains adds the given search domains to the system configuration.
	AddSearchDomains(ctx context.Context, domains []string) error
	// RefreshServers checks which peers in the database are offering DNS
	// and updates the system configuration accordingly.
	RefreshServers(ctx context.Context) error
}

type GraphWalk struct {
	Graph        types.PeerGraph
	Networking   networking.Networking
	AdjacencyMap types.AdjacencyMap
	SourceNode   types.NodeID
	TargetNode   *types.MeshNode
	AllowedIPs   []string
	LocalRoutes  []netip.Prefix
	Routes       []Route
	Visited      map[types.NodeID]struct{}
	Depth        int
}

type Manager interface {
	transport.Dialer

	// Start starts the network manager.
	Start(ctx context.Context, opts StartOptions) error
	// InNetwork returns true if the given address is in the network of this interface.
	InNetwork(addr netip.Addr) bool
	// NetworkV4 returns the current IPv4 network. The returned value may be invalid.
	NetworkV4() netip.Prefix
	// NetworkV6 returns the current IPv6 network, even if it is disabled.
	NetworkV6() netip.Prefix
	// StartMasquerade ensures that masquerading is enabled.
	StartMasquerade(ctx context.Context) error
	// DNS returns the DNS server manager. The DNS server manager is only
	// available after Start has been called.
	DNS() DNSManager
	// Peers return the peer manager.
	Peers() PeerManager
	// Firewall returns the firewall.
	// The firewall is only available after Start has been called.
	Firewall() firewall.Firewall
	// WireGuard returns the wireguard interface.
	// The wireguard interface is only available after Start has been called.
	WireGuard() wireguard.Interface
	// Close closes the network manager and cleans up any resources.
	Close(ctx context.Context) error
}

type Options struct {
	// NetNs is the network namespace to use for the wireguard interface.
	// This is only used on Linux.
	NetNs string
	// InterfaceName is the name of the wireguard interface.
	InterfaceName string
	// ForceReplace is whether to force replace the wireguard interface.
	ForceReplace bool
	// ListenPort is the port to use for wireguard.
	ListenPort int
	// Modprobe is whether to attempt to load the wireguard kernel module.
	Modprobe bool
	// PersistentKeepAlive is the persistent keepalive to use for wireguard.
	PersistentKeepAlive time.Duration
	// ForceTUN is whether to force the use of TUN.
	ForceTUN bool
	// MTU is the MTU to use for the wireguard interface.
	MTU int
	// RecordMetrics is whether to enable metrics recording.
	RecordMetrics bool
	// RecordMetricsInterval is the interval to use for recording metrics.
	RecordMetricsInterval time.Duration
	// StoragePort is the port being used for the storage provider.
	StoragePort int
	// GRPCPort is the port being used for gRPC.
	GRPCPort int
	// ZoneAwarenessID is the zone awareness ID.
	ZoneAwarenessID string
	// Credentials are the dial options to use when calling peer nodes.
	Credentials []grpc.DialOption
	// LocalDNSAddr is a local network address service MeshDNS.
	LocalDNSAddr netip.AddrPort
	// DisableIPv4 disables IPv4 on the interface.
	DisableIPv4 bool
	// DisableIPv6 disables IPv6 on the interface.
	DisableIPv6 bool
	// DisableFullTunnel will ignore routes for a default gateway.
	DisableFullTunnel bool
	// IgnoreRoutes are additional routes to ignore.
	IgnoreRoutes []netip.Prefix
	// Relays are options for when presented with the need to negotiate
	// p2p data channels.
	Relays RelayOptions
}

type PeerFilterFunc func(types.MeshNode) bool

type PeerManager interface {
	// AddPeer adds a peer to the wireguard interface. IceServers is optional
	// and provides a hint of mesh nodes that provide WebRTC signaling if
	// required.
	Add(ctx context.Context, peer *v1.WireGuardPeer, iceServers []string) error
	// RefreshPeers walks all peers against the provided list and makes sure
	// they are up to date.
	Refresh(ctx context.Context, peers []*v1.WireGuardPeer) error
	// Sync is like refresh but uses the storage to get the list of peers.
	Sync(ctx context.Context) error
	// Resolver returns a resolver backed by the storage
	// of this instance.
	Resolver() PeerResolver
}

type PeerResolver interface {
	// NodeIDResolver returns a resolver that resolves node addresses by node ID.
	NodeIDResolver() transport.NodeIDResolver
	// FeatureResolver returns a resolver that resolves node addresses by feature.
	FeatureResolver(filterFn ...PeerFilterFunc) transport.FeatureResolver
}

type RelayOptions struct {
	// Host are the options for a libp2p host.
	Host libp2p.HostOptions
}

type Route struct {
	CIDR  netip.Prefix
	Depth int
}

type StartOptions struct {
	// Key is the wireguard key to use for the node.
	Key crypto.PrivateKey
	// AddressV4 is the IPv4 address to use for the node.
	AddressV4 netip.Prefix
	// AddressV6 is the IPv6 address to use for the node.
	AddressV6 netip.Prefix
	// NetworkV4 is the IPv4 network to use for the node.
	NetworkV4 netip.Prefix
	// NetworkV6 is the IPv6 network to use for the node.
	NetworkV6 netip.Prefix
}

type WalkedPeer struct {
	*v1.WireGuardPeer
	Routes []Route
}