1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
using System;
using System.Net;
using System.Threading.Tasks;
using Impostor.Api.Net.Messages;
namespace Impostor.Hazel
{
public enum HazelInternalErrors
{
SocketExceptionSend,
SocketExceptionReceive,
ReceivedZeroBytes,
PingsWithoutResponse,
ReliablePacketWithoutResponse,
ConnectionDisconnected
}
/// <summary>
/// Abstract base class for a <see cref="Connection"/> to a remote end point via a network protocol like TCP or UDP.
/// </summary>
/// <threadsafety static="true" instance="true"/>
public abstract class NetworkConnection : Connection
{
/// <summary>
/// An event that gives us a chance to send well-formed disconnect messages to clients when an internal disconnect happens.
/// </summary>
public Func<HazelInternalErrors, MessageWriter> OnInternalDisconnect;
/// <summary>
/// The remote end point of this connection.
/// </summary>
/// <remarks>
/// This is the end point of the other device given as an <see cref="System.Net.EndPoint"/> rather than a generic
/// <see cref="ConnectionEndPoint"/> as the base <see cref="Connection"/> does.
/// </remarks>
public IPEndPoint RemoteEndPoint { get; protected set; }
public long GetIP4Address()
{
if (IPMode == IPMode.IPv4)
{
return ((IPEndPoint)this.RemoteEndPoint).Address.Address;
}
else
{
var bytes = ((IPEndPoint)this.RemoteEndPoint).Address.GetAddressBytes();
return BitConverter.ToInt64(bytes, bytes.Length - 8);
}
}
/// <summary>
/// Sends a disconnect message to the end point.
/// </summary>
protected abstract ValueTask<bool> SendDisconnect(MessageWriter writer);
/// <summary>
/// Called when the socket has been disconnected at the remote host.
/// </summary>
protected async ValueTask DisconnectRemote(string reason, IMessageReader reader)
{
if (await SendDisconnect(null))
{
try
{
await InvokeDisconnected(reason, reader);
}
catch { }
}
this.Dispose();
}
/// <summary>
/// Called when socket is disconnected internally
/// </summary>
internal async ValueTask DisconnectInternal(HazelInternalErrors error, string reason)
{
var handler = this.OnInternalDisconnect;
if (handler != null)
{
MessageWriter messageToRemote = handler(error);
if (messageToRemote != null)
{
try
{
await Disconnect(reason, messageToRemote);
}
finally
{
messageToRemote.Recycle();
}
}
else
{
await Disconnect(reason);
}
}
else
{
await Disconnect(reason);
}
}
/// <summary>
/// Called when the socket has been disconnected locally.
/// </summary>
public override async ValueTask Disconnect(string reason, MessageWriter writer = null)
{
if (await SendDisconnect(writer))
{
try
{
await InvokeDisconnected(reason, null);
}
catch { }
}
this.Dispose();
}
}
}
|
