linker/cmonitor/plugins/tunnel/compact/CompactSelfHost.cs

using cmonitor.plugins.tunnel.messenger;
using cmonitor.plugins.tunnel.server;
using cmonitor.server;
using common.libs.extends;
using MemoryPack;
using System.Net;
using System.Net.Sockets;

namespace cmonitor.plugins.tunnel.compact
{
    public sealed class CompactSelfHost : ICompact
    {
        public string Name => "self";

        private readonly TcpServer tcpServer;
        private readonly MessengerSender messengerSender;

        public CompactSelfHost(TcpServer tcpServer, MessengerSender messengerSender)
        {
            this.tcpServer = tcpServer;
            this.messengerSender = messengerSender;
        }

        public async Task<TunnelCompactIPEndPoint> GetTcpExternalIPAsync(IPEndPoint server)
        {
            Socket socket = new Socket(server.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            socket.Reuse(true);
            socket.IPv6Only(server.AddressFamily, false);
            await socket.ConnectAsync(server).WaitAsync(TimeSpan.FromSeconds(5));

            IConnection connection = tcpServer.BindReceive(socket);
            MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap { Connection = connection, MessengerId = (ushort)TunnelMessengerIds.ExternalIP });

            if (resp.Code != MessageResponeCodes.OK) return null;

            IPEndPoint local = socket.LocalEndPoint as IPEndPoint;
            connection.Disponse();
            TunnelExternalIPInfo tunnelExternalIPInfo = MemoryPackSerializer.Deserialize<TunnelExternalIPInfo>(resp.Data.Span);

            return new TunnelCompactIPEndPoint { Local = local, Remote = tunnelExternalIPInfo.ExternalIP };
        }

        public async Task<TunnelCompactIPEndPoint> GetUdpExternalIPAsync(IPEndPoint server)
        {
            return null;
            /*
            using UdpClient udpClient = new UdpClient();
            udpClient.Client.Reuse(true);
            await udpClient.SendAsync(new byte[1] { 0 }, server);
            var result = await udpClient.ReceiveAsync().WaitAsync(TimeSpan.FromSeconds(5));
            if (result.Buffer.Length == 0)
            {
                return null;
            }

            TunnelExternalIPInfo tunnelExternalIPInfo = MemoryPackSerializer.Deserialize<TunnelExternalIPInfo>(result.Buffer);

            return new TunnelCompactIPEndPoint { Local = udpClient.Client.LocalEndPoint as IPEndPoint, Remote = tunnelExternalIPInfo.ExternalIP };
            */
        }
    }
}