NatTypeTester/STUN/Client/StunClient5389UDP.cs

using Microsoft;
using STUN.Enums;
using STUN.Messages;
using STUN.Proxy;
using STUN.StunResult;
using STUN.Utils;
using System;
using System.Buffers;
using System.Diagnostics;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace STUN.Client
{
	/// <summary>
	/// https://tools.ietf.org/html/rfc5389#section-7.2.1
	/// https://tools.ietf.org/html/rfc5780#section-4.2
	/// </summary>
	public class StunClient5389UDP : IDisposable
	{
		public IPEndPoint LocalEndPoint => Proxy.LocalEndPoint;

		public TimeSpan Timeout
		{
			get => Proxy.Timeout;
			set => Proxy.Timeout = value;
		}

		protected readonly IPAddress Server;
		protected readonly ushort Port;

		protected IPEndPoint RemoteEndPoint => new(Server, Port);

		protected readonly IUdpProxy Proxy;

		public StunResult5389 Status { get; } = new();

		public StunClient5389UDP(IPAddress server, ushort port = 3478, IPEndPoint? local = null, IUdpProxy? proxy = null)
		{
			Requires.NotNull(server, nameof(server));
			Requires.Argument(port > 0, nameof(port), @"Port value must be >= 1 !");

			Proxy = proxy ?? new NoneUdpProxy(local);

			Server = server;
			Port = port;

			Timeout = TimeSpan.FromSeconds(3);
			Status.LocalEndPoint = local;
		}

		public async Task QueryAsync()
		{
			try
			{
				Status.Reset();
				using var cts = new CancellationTokenSource(Timeout);
				await Proxy.ConnectAsync(cts.Token);

				await FilteringBehaviorTestBaseAsync(cts.Token);
				if (Status.BindingTestResult != BindingTestResult.Success
					|| Status.FilteringBehavior == FilteringBehavior.UnsupportedServer
				)
				{
					return;
				}

				if (Equals(Status.PublicEndPoint, Status.LocalEndPoint))
				{
					Status.MappingBehavior = MappingBehavior.Direct;
					return;
				}

				// MappingBehaviorTest test II
				var (success2, result2) = await MappingBehaviorTestBase2Async(cts.Token);
				if (!success2)
				{
					return;
				}

				// MappingBehaviorTest test III
				await MappingBehaviorTestBase3Async(result2, cts.Token);
			}
			finally
			{
				await Proxy.DisconnectAsync();
			}
		}

		public async Task BindingTestAsync()
		{
			try
			{
				Status.Reset();
				using var cts = new CancellationTokenSource(Timeout);
				await Proxy.ConnectAsync(cts.Token);
				await BindingTestInternalAsync(cts.Token);
			}
			finally
			{
				await Proxy.DisconnectAsync();
			}
		}

		private async Task BindingTestInternalAsync(CancellationToken token)
		{
			Status.Clone(await BindingTestBaseAsync(RemoteEndPoint, token));
		}

		private async Task<StunResult5389> BindingTestBaseAsync(IPEndPoint remote, CancellationToken token)
		{
			var result = new StunResult5389();
			var test = new StunMessage5389 { StunMessageType = StunMessageType.BindingRequest };
			var (response1, _, local1) = await TestAsync(test, remote, remote, token);
			var mappedAddress1 = response1.GetXorMappedAddressAttribute();
			var otherAddress = response1.GetOtherAddressAttribute();
			var local = local1 is null ? null : new IPEndPoint(local1, LocalEndPoint.Port);

			if (response1 is null)
			{
				result.BindingTestResult = BindingTestResult.Fail;
			}
			else if (mappedAddress1 is null)
			{
				result.BindingTestResult = BindingTestResult.UnsupportedServer;
			}
			else
			{
				result.BindingTestResult = BindingTestResult.Success;
			}

			result.LocalEndPoint = local;
			result.PublicEndPoint = mappedAddress1;
			result.OtherEndPoint = otherAddress;

			return result;
		}

		public async Task MappingBehaviorTestAsync()
		{
			try
			{
				Status.Reset();
				using var cts = new CancellationTokenSource(Timeout);
				await Proxy.ConnectAsync(cts.Token);

				// test I
				await BindingTestInternalAsync(cts.Token);
				if (Status.BindingTestResult != BindingTestResult.Success)
				{
					return;
				}

				if (Status.OtherEndPoint is null
					|| Equals(Status.OtherEndPoint.Address, RemoteEndPoint.Address)
					|| Status.OtherEndPoint.Port == RemoteEndPoint.Port)
				{
					Status.MappingBehavior = MappingBehavior.UnsupportedServer;
					return;
				}

				if (Equals(Status.PublicEndPoint, Status.LocalEndPoint))
				{
					Status.MappingBehavior = MappingBehavior.Direct;
					return;
				}

				// test II
				var (success2, result2) = await MappingBehaviorTestBase2Async(cts.Token);
				if (!success2)
				{
					return;
				}

				// test III
				await MappingBehaviorTestBase3Async(result2, cts.Token);
			}
			finally
			{
				await Proxy.DisconnectAsync();
			}
		}

		private async Task<(bool, StunResult5389)> MappingBehaviorTestBase2Async(CancellationToken token)
		{
			var result2 = await BindingTestBaseAsync(new IPEndPoint(Status.OtherEndPoint!.Address, RemoteEndPoint.Port), token);
			if (result2.BindingTestResult != BindingTestResult.Success)
			{
				Status.MappingBehavior = MappingBehavior.Fail;
				return (false, result2);
			}

			if (Equals(result2.PublicEndPoint, Status.PublicEndPoint))
			{
				Status.MappingBehavior = MappingBehavior.EndpointIndependent;
				return (false, result2);
			}

			return (true, result2);
		}

		private async Task MappingBehaviorTestBase3Async(StunResult5389 result2, CancellationToken token)
		{
			var result3 = await BindingTestBaseAsync(Status.OtherEndPoint!, token);
			if (result3.BindingTestResult != BindingTestResult.Success)
			{
				Status.MappingBehavior = MappingBehavior.Fail;
				return;
			}

			Status.MappingBehavior = Equals(result3.PublicEndPoint, result2.PublicEndPoint) ? MappingBehavior.AddressDependent : MappingBehavior.AddressAndPortDependent;
		}

		private async Task FilteringBehaviorTestBaseAsync(CancellationToken token)
		{
			// test I
			await BindingTestInternalAsync(token);
			if (Status.BindingTestResult != BindingTestResult.Success)
			{
				return;
			}

			if (Status.OtherEndPoint is null
				|| Equals(Status.OtherEndPoint.Address, RemoteEndPoint.Address)
				|| Status.OtherEndPoint.Port == RemoteEndPoint.Port)
			{
				Status.FilteringBehavior = FilteringBehavior.UnsupportedServer;
				return;
			}

			// test II
			var test2 = new StunMessage5389
			{
				StunMessageType = StunMessageType.BindingRequest,
				Attributes = new[] { AttributeExtensions.BuildChangeRequest(true, true) }
			};
			var (response2, _, _) = await TestAsync(test2, RemoteEndPoint, Status.OtherEndPoint, token);

			if (response2 is not null)
			{
				Status.FilteringBehavior = FilteringBehavior.EndpointIndependent;
				return;
			}

			// test III
			var test3 = new StunMessage5389
			{
				StunMessageType = StunMessageType.BindingRequest,
				Attributes = new[] { AttributeExtensions.BuildChangeRequest(false, true) }
			};
			var (response3, remote3, _) = await TestAsync(test3, RemoteEndPoint, RemoteEndPoint, token);

			if (response3 is null || remote3 is null)
			{
				Status.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
				return;
			}

			if (Equals(remote3.Address, RemoteEndPoint.Address) && remote3.Port != RemoteEndPoint.Port)
			{
				Status.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
			}
			else
			{
				Status.FilteringBehavior = FilteringBehavior.UnsupportedServer;
			}
		}

		public async Task FilteringBehaviorTestAsync()
		{
			try
			{
				Status.Reset();
				using var cts = new CancellationTokenSource(Timeout);
				await Proxy.ConnectAsync(cts.Token);
				await FilteringBehaviorTestBaseAsync(cts.Token);
			}
			finally
			{
				await Proxy.DisconnectAsync();
			}
		}

		private async Task<(StunMessage5389?, IPEndPoint?, IPAddress?)> TestAsync(StunMessage5389 sendMessage, IPEndPoint remote, IPEndPoint receive, CancellationToken token)
		{
			try
			{
				using var memoryOwner = MemoryPool<byte>.Shared.Rent(ushort.MaxValue);
				var sendBuffer = memoryOwner.Memory;
				var length = sendMessage.WriteTo(sendBuffer.Span);
				//var t = DateTime.Now;

				// Simple retransmissions
				//https://tools.ietf.org/html/rfc3489#section-9.3
				//while (t + TimeSpan.FromSeconds(3) > DateTime.Now)
				{
					try
					{
						var (receive1, ipe, local) = await Proxy.ReceiveAsync(sendBuffer[..length], remote, receive, token);

						var message = new StunMessage5389();
						if (message.TryParse(receive1) &&
							message.IsSameTransaction(sendMessage))
						{
							return (message, ipe, local);
						}
					}
					catch (Exception ex)
					{
						Debug.WriteLine(ex);
					}
				}
			}
			catch (Exception ex)
			{
				Debug.WriteLine(ex);
			}

			return (null, null, null);
		}

		public void Dispose()
		{
			Proxy.Dispose();
		}
	}
}