First Commmit

protocol/tailscale/status.go

@@ -0,0 +1,105 @@
+//go:build with_gvisor
+
+package tailscale
+
+import (
+	"context"
+	"slices"
+
+	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/tailscale/ipn"
+	"github.com/sagernet/tailscale/ipn/ipnstate"
+)
+
+var _ adapter.TailscaleEndpoint = (*Endpoint)(nil)
+
+func (t *Endpoint) SubscribeTailscaleStatus(ctx context.Context, fn func(*adapter.TailscaleEndpointStatus)) error {
+	localBackend := t.server.ExportLocalBackend()
+	sendStatus := func() {
+		status := localBackend.Status()
+		fn(convertTailscaleStatus(status))
+	}
+	sendStatus()
+	localBackend.WatchNotifications(ctx, ipn.NotifyInitialState|ipn.NotifyInitialNetMap|ipn.NotifyRateLimit, nil, func(roNotify *ipn.Notify) (keepGoing bool) {
+		select {
+		case <-ctx.Done():
+			return false
+		default:
+		}
+		if roNotify.State != nil || roNotify.NetMap != nil || roNotify.BrowseToURL != nil {
+			sendStatus()
+		}
+		return true
+	})
+	return ctx.Err()
+}
+
+func convertTailscaleStatus(status *ipnstate.Status) *adapter.TailscaleEndpointStatus {
+	result := &adapter.TailscaleEndpointStatus{
+		BackendState: status.BackendState,
+		AuthURL:      status.AuthURL,
+	}
+	if status.CurrentTailnet != nil {
+		result.NetworkName = status.CurrentTailnet.Name
+		result.MagicDNSSuffix = status.CurrentTailnet.MagicDNSSuffix
+	}
+	if status.Self != nil {
+		result.Self = convertTailscalePeer(status.Self)
+	}
+	groupIndex := make(map[int64]*adapter.TailscaleUserGroup)
+	for _, peerKey := range status.Peers() {
+		peer := status.Peer[peerKey]
+		userID := int64(peer.UserID)
+		group, loaded := groupIndex[userID]
+		if !loaded {
+			group = &adapter.TailscaleUserGroup{
+				UserID: userID,
+			}
+			if profile, hasProfile := status.User[peer.UserID]; hasProfile {
+				group.LoginName = profile.LoginName
+				group.DisplayName = profile.DisplayName
+				group.ProfilePicURL = profile.ProfilePicURL
+			}
+			groupIndex[userID] = group
+			result.UserGroups = append(result.UserGroups, group)
+		}
+		group.Peers = append(group.Peers, convertTailscalePeer(peer))
+	}
+	for _, group := range result.UserGroups {
+		slices.SortStableFunc(group.Peers, func(a, b *adapter.TailscalePeer) int {
+			if a.Online != b.Online {
+				if a.Online {
+					return -1
+				}
+				return 1
+			}
+			return 0
+		})
+	}
+	return result
+}
+
+func convertTailscalePeer(peer *ipnstate.PeerStatus) *adapter.TailscalePeer {
+	ips := make([]string, len(peer.TailscaleIPs))
+	for i, ip := range peer.TailscaleIPs {
+		ips[i] = ip.String()
+	}
+	var keyExpiry int64
+	if peer.KeyExpiry != nil {
+		keyExpiry = peer.KeyExpiry.Unix()
+	}
+	return &adapter.TailscalePeer{
+		HostName:       peer.HostName,
+		DNSName:        peer.DNSName,
+		OS:             peer.OS,
+		TailscaleIPs:   ips,
+		Online:         peer.Online,
+		ExitNode:       peer.ExitNode,
+		ExitNodeOption: peer.ExitNodeOption,
+		Active:         peer.Active,
+		RxBytes:        peer.RxBytes,
+		TxBytes:        peer.TxBytes,
+		UserID:         int64(peer.UserID),
+		KeyExpiry:      keyExpiry,
+	}
+}