public void AddTask(ConnectionUDP conn, int sequence)
{
ResendItem resendItem = new ResendItem(conn, sequence);
resendItem.ResendTime = GetNewResendTime(conn);
TaskList.Add(resendItem);
}
public UDPOutputStream(ConnectionUDP conn)
{
Conn = conn;
DstHost = conn.DstHost;
DstPort = conn.DstPort;
MySender = conn.MySender;
}
public void RemoveConnection(ConnectionUDP conn)
{
lock (SynConnTable)
{
ConnTable.Remove(conn.ConnectId);
}
}
public void AddConnection(ConnectionUDP conn)
{
lock (SynConnTable)
{
ConnTable.Add(conn.ConnectId, conn);
}
}
public void RemoveConnection(ConnectionUDP conn)
{
lock (this)
{
ClosedTable.Add(conn.ConnectId);
ConnTable.Remove(conn.ConnectId);
}
}
public Receiver(ConnectionUDP conn)
{
Conn = conn;
Uis = new UDPInputStream(conn);
MySender = conn.MySender;
DstHost = conn.DstHost;
DstPort = conn.DstPort;
}
public Receiver(ConnectionUDP conn)
{
Conn = conn;
Uis = new UDPInputStream(conn);
MySender = conn.MySender;
DstHost = conn.DstHost;
DstPort = conn.DstPort;
}
public Sender(ConnectionUDP conn)
{
Conn = conn;
Uos = new UDPOutputStream(conn);
MyReceiver = conn.MyRecevier;
DstHost = conn.DstHost;
DstPort = conn.DstPort;
}
public void AddLastRead(ConnectionUDP conn)
{
lock (SynAck)
{
if (!TaskTable.ContainsKey(conn.ConnectId))
{
AckListTask ackListTask = new AckListTask(conn);
TaskTable.Add(conn.ConnectId, ackListTask);
}
}
}
long GetNewResendTime(ConnectionUDP conn)
{
int delayAdd = conn.MyClientControl.PingDelay +
(int)((float)conn.MyClientControl.PingDelay * RUDPConfig.ReSendDelay);
if (delayAdd < RUDPConfig.ReSendDelayMin)
{
delayAdd = RUDPConfig.ReSendDelayMin;
}
return(DateTimeExtensions.CurrentTimeMillis() + delayAdd);
}
public void AddAck(ConnectionUDP conn, int sequence)
{
lock (SynAck)
{
AckListTask ackListTask;
if (!TaskTable.ContainsKey(conn.ConnectId))
{
ackListTask = new AckListTask(conn);
TaskTable.Add(conn.ConnectId, ackListTask);
}
ackListTask = TaskTable[conn.ConnectId];
ackListTask.AddAck(sequence);
}
}
public ConnectionUDP GetConnection2(string dstHost, int dstPort, int connectId, int clientId)
{
ConnectionUDP conn = ConnTable[connectId];
if (conn == null)
{
ClientControl clientControl = MyClientManager.GetClientControl(clientId, dstHost, dstPort);
conn = new ConnectionUDP(this, dstHost, dstPort, 2, connectId, clientControl);
lock (this)
{
ConnTable.Add(connectId, conn);
}
clientControl.AddConnection(conn);
}
return(conn);
}
public void Close()
{
Closed = true;
MyRoute.MyClientManager.RemoveClient(ClientId);
lock (SynConnTable)
{
foreach (KeyValuePair <int, ConnectionUDP> connItem in ConnTable)
{
ConnectionUDP conn = connItem.Value;
if (conn != null)
{
Task.Factory.StartNew(() => {
conn.StopNow = true;
conn.Destory(true);
});
}
}
}
}
public AckListTask(ConnectionUDP conn)
{
Conn = conn;
}
public UDPInputStream(ConnectionUDP conn)
{
Conn = conn;
MyReceiver = conn.MyRecevier;
}
public void RemoveConnection(ConnectionUDP conn)
{
lock(this)
{
ClosedTable.Add(conn.ConnectId);
ConnTable.Remove(conn.ConnectId);
}
}
public ConnectionUDP GetConnection2(string dstHost, int dstPort, int connectId, int clientId)
{
ConnectionUDP conn = ConnTable[connectId];
if (conn == null)
{
ClientControl clientControl = MyClientManager.GetClientControl(clientId, dstHost, dstPort);
conn = new ConnectionUDP(this, dstHost, dstPort, 2, connectId, clientControl);
lock (this)
{
ConnTable.Add(connectId, conn);
}
clientControl.AddConnection(conn);
}
return conn;
}
public ResendItem(ConnectionUDP conn, int sequence)
{
Conn = conn;
Sequence = sequence;
}
public ResendItem(ConnectionUDP conn, int sequence)
{
Conn = conn;
Sequence = sequence;
}
public void OnSendDataPacket(ConnectionUDP conn)
{
}
public Route(int mode, int port = 150)
{
LocalClientId = Ran.Next();
Mode = mode;
if (mode == ClientMode)
{
MyUdpClient = new UdpClient();
}
else if (mode == ClientMode)
{
MyUdpClient = new UdpClient(port);
}
MyClientManager = new ClientManager(this);
Task.Factory.StartNew(() => {
while (true)
{
try
{
IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
byte[] data = MyUdpClient.Receive(ref RemoteIpEndPoint);
DatagramPacket datagramPacket = new DatagramPacket(data, data.Length);
PacketBuffer.Add(datagramPacket);
}
catch (Exception e)
{
Thread.Sleep(1);
continue;
}
}
});
Task.Factory.StartNew(() => {
while (true)
{
DatagramPacket datagramPacket = PacketBuffer.Take();
if (datagramPacket == null)
{
continue;
}
byte[] data = datagramPacket.Data;
if (data.Length < 4)
{
return;
}
int sType = PacketCheck.CheckSType(datagramPacket);
int connectId = BitConverter.ToInt32(data, 4);
int remoteClientId = BitConverter.ToInt32(data, 8);
if (ClosedTable.Contains(connectId) && connectId != 0)
{
continue;
}
ClientControl clientControl;
if (sType == PacketType.PingPacket || sType == PacketType.PingPacket2)
{
if (mode == ClientMode)
{
string key = datagramPacket.Host + ":" + datagramPacket.Port;
int simClientId = Math.Abs(key.GetHashCode());
clientControl = MyClientManager.GetClientControl(simClientId, datagramPacket.Host, datagramPacket.Port);
}
else if (mode == ServerMode)
{
clientControl = MyClientManager.GetClientControl(remoteClientId, datagramPacket.Host, datagramPacket.Port);
}
}
else
{
if (mode == ClientMode)
{
if (!SettedTable.Contains(remoteClientId))
{
string key = datagramPacket.Host + ":" + datagramPacket.Port;
int simClientId = Math.Abs(key.GetHashCode());
clientControl = MyClientManager.GetClientControl(simClientId, datagramPacket.Host, datagramPacket.Port);
if (clientControl.ClientIdReal == -1)
{
clientControl.ClientIdReal = remoteClientId;
}
else if (clientControl.ClientIdReal != remoteClientId)
{
clientControl.UpdateClientId(remoteClientId);
}
SettedTable.Add(remoteClientId);
}
}
else if (mode == ServerMode)
{
GetConnection2(datagramPacket.Host, datagramPacket.Port, connectId, remoteClientId);
}
ConnectionUDP conn = ConnTable[connectId];
if (conn != null)
{
conn.MyRecevier.OnReceivePacket(datagramPacket);
if (sType == PacketType.DataPacket)
{
TrafficEvent e = new TrafficEvent("", Ran.Next(), datagramPacket.Data.Length, TrafficEvent.Download);
FireEvent(e);
}
}
}
}
});
}
public AckListTask(ConnectionUDP conn)
{
Conn = conn;
}
