private void AcceptTcpConnectionAsync(object parameter)
{
Socket tcpListener = parameter as Socket;
try
{
do
{
Socket socket = tcpListener.Accept();
try
{
socket.NoDelay = true;
socket.SendTimeout = SOCKET_SEND_TIMEOUT;
socket.ReceiveTimeout = SOCKET_RECV_TIMEOUT;
IPEndPoint remotePeerEP = socket.RemoteEndPoint as IPEndPoint;
if (NetUtilities.IsIPv4MappedIPv6Address(remotePeerEP.Address))
{
remotePeerEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remotePeerEP.Address), remotePeerEP.Port);
}
ThreadPool.QueueUserWorkItem(AcceptConnectionInitiateProtocolAsync, new object[] { new NetworkStream(socket, true), remotePeerEP });
}
catch
{ }
}while (true);
}
catch
{ }
}
private void ReadResponsePacketsAsync(object parameter)
{
Socket udpClient = parameter as Socket;
EndPoint remoteEP;
FixMemoryStream recvStream = new FixMemoryStream(BUFFER_MAX_SIZE);
byte[] bufferRecv = recvStream.Buffer;
int bytesRecv;
if (udpClient.AddressFamily == AddressFamily.InterNetwork)
{
remoteEP = new IPEndPoint(IPAddress.Any, 0);
}
else
{
remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
}
try
{
while (true)
{
bytesRecv = udpClient.ReceiveFrom(bufferRecv, ref remoteEP);
if (bytesRecv > 0)
{
recvStream.SetLength(bytesRecv);
recvStream.Position = 0;
IPEndPoint remoteNodeEP = remoteEP as IPEndPoint;
if (NetUtilities.IsIPv4MappedIPv6Address(remoteNodeEP.Address))
{
remoteNodeEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remoteNodeEP.Address), remoteNodeEP.Port);
}
try
{
DhtRpcPacket response = new DhtRpcPacket(recvStream, remoteNodeEP.Address);
ProcessPacket(response);
}
catch
{ }
}
}
}
catch (Exception ex)
{
Debug.Write("DhtClient.ReadResponsePacketsAsync", ex);
}
}
private void RecvDataAsync(object parameter)
{
Socket udpListener = parameter as Socket;
EndPoint remoteEP = null;
FixMemoryStream dataRecv = new FixMemoryStream(BUFFER_MAX_SIZE);
int bytesRecv;
if (udpListener.AddressFamily == AddressFamily.InterNetwork)
{
remoteEP = new IPEndPoint(IPAddress.Any, 0);
}
else
{
remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
}
try
{
while (true)
{
//receive message from remote
bytesRecv = udpListener.ReceiveFrom(dataRecv.Buffer, ref remoteEP);
if (bytesRecv > 0)
{
IPAddress peerIP = (remoteEP as IPEndPoint).Address;
if (NetUtilities.IsIPv4MappedIPv6Address(peerIP))
{
peerIP = NetUtilities.ConvertFromIPv4MappedIPv6Address(peerIP);
}
dataRecv.Position = 0;
dataRecv.SetLength(bytesRecv);
try
{
ReceivedPacket(new DiscoveryPacket(dataRecv), peerIP);
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listner.RecvDataAsync", ex);
}
}
}
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listner.RecvDataAsync", ex);
}
}
public Connection MakeVirtualConnection(Connection viaConnection, IPEndPoint remotePeerEP)
{
if (NetUtilities.IsIPv4MappedIPv6Address(remotePeerEP.Address))
{
remotePeerEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remotePeerEP.Address), remotePeerEP.Port);
}
//prevent multiple virtual connection requests to same remote end-point
lock (_makeVirtualConnectionList)
{
if (_makeVirtualConnectionList.ContainsKey(remotePeerEP))
{
throw new BitChatException("Connection attempt for end-point already in progress.");
}
_makeVirtualConnectionList.Add(remotePeerEP, null);
}
try
{
//check if self
if (remotePeerEP.Equals(this.ExternalEndPoint))
{
throw new IOException("Cannot connect to remote port: self connection.");
}
//check existing connection
Connection existingConnection = GetExistingConnection(remotePeerEP);
if (existingConnection != null)
{
return(existingConnection);
}
//create tunnel via proxy peer
Stream proxyNetworkStream = viaConnection.RequestProxyTunnel(remotePeerEP);
//make new connection protocol begins
return(MakeConnectionInitiateProtocol(proxyNetworkStream, remotePeerEP));
}
finally
{
lock (_makeVirtualConnectionList)
{
_makeVirtualConnectionList.Remove(remotePeerEP);
}
}
}
public void Write(IPEndPoint ep, string message)
{
string ipInfo;
if (ep == null)
{
ipInfo = "";
}
else if (NetUtilities.IsIPv4MappedIPv6Address(ep.Address))
{
ipInfo = "[" + NetUtilities.ConvertFromIPv4MappedIPv6Address(ep.Address).ToString() + ":" + ep.Port + "] ";
}
else
{
ipInfo = "[" + ep.ToString() + "] ";
}
Write(ipInfo + message);
}
public Connection MakeConnection(IPEndPoint remotePeerEP)
{
if (NetUtilities.IsIPv4MappedIPv6Address(remotePeerEP.Address))
{
remotePeerEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remotePeerEP.Address), remotePeerEP.Port);
}
//prevent multiple connection requests to same remote end-point
lock (_makeConnectionList)
{
if (_makeConnectionList.ContainsKey(remotePeerEP))
{
throw new BitChatException("Connection attempt for end-point already in progress.");
}
_makeConnectionList.Add(remotePeerEP, null);
}
try
{
//check if self
if (remotePeerEP.Equals(this.ExternalEndPoint))
{
throw new IOException("Cannot connect to remote port: self connection.");
}
//check existing connection
Connection existingConnection = GetExistingConnection(remotePeerEP);
if (existingConnection != null)
{
return(existingConnection);
}
try
{
//try new tcp connection
Socket client;
if (_profile.Proxy != null)
{
switch (_profile.Proxy.Type)
{
case NetProxyType.Http:
client = _profile.Proxy.HttpProxy.Connect(remotePeerEP);
break;
case NetProxyType.Socks5:
using (SocksConnectRequestHandler requestHandler = _profile.Proxy.SocksProxy.Connect(remotePeerEP))
{
client = requestHandler.GetSocket();
}
break;
default:
throw new NotSupportedException("Proxy type not supported.");
}
}
else
{
client = new Socket(remotePeerEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
client.Connect(remotePeerEP);
}
client.NoDelay = true;
client.SendTimeout = SOCKET_SEND_TIMEOUT;
client.ReceiveTimeout = SOCKET_RECV_TIMEOUT;
return(MakeConnectionInitiateProtocol(new NetworkStream(client, true), remotePeerEP));
}
catch (SocketException)
{
//try virtual connection
return(MakeVirtualConnection(remotePeerEP));
}
}
finally
{
lock (_makeConnectionList)
{
_makeConnectionList.Remove(remotePeerEP);
}
}
}
private void ReadQueryPacketsAsync(object parameter)
{
Socket udpListener = parameter as Socket;
EndPoint remoteEP;
FixMemoryStream recvBufferStream = new FixMemoryStream(BUFFER_MAX_SIZE);
FixMemoryStream sendBufferStream = new FixMemoryStream(BUFFER_MAX_SIZE);
int bytesRecv;
if (udpListener.AddressFamily == AddressFamily.InterNetwork)
{
remoteEP = new IPEndPoint(IPAddress.Any, 0);
}
else
{
remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
}
try
{
while (true)
{
bytesRecv = udpListener.ReceiveFrom(recvBufferStream.Buffer, ref remoteEP);
if (bytesRecv > 0)
{
recvBufferStream.Position = 0;
recvBufferStream.SetLength(bytesRecv);
IPEndPoint remoteNodeEP = remoteEP as IPEndPoint;
if (NetUtilities.IsIPv4MappedIPv6Address(remoteNodeEP.Address))
{
remoteNodeEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remoteNodeEP.Address), remoteNodeEP.Port);
}
try
{
DhtRpcPacket request = new DhtRpcPacket(recvBufferStream, remoteNodeEP.Address);
DhtRpcPacket response = ProcessPacket(request);
//send response
if (response != null)
{
sendBufferStream.Position = 0;
response.WriteTo(sendBufferStream);
udpListener.SendTo(sendBufferStream.Buffer, 0, (int)sendBufferStream.Position, SocketFlags.None, remoteEP);
}
//if contact doesnt exists then add contact else update last seen time
KBucket closestBucket = _routingTable.FindClosestBucket(request.SourceNode.NodeID);
NodeContact contact = closestBucket.FindContactInCurrentBucket(request.SourceNode.NodeID);
if (contact == null)
{
//check if the closest bucket can accomodate another contact
if (!closestBucket.IsCurrentBucketFull(true))
{
ThreadPool.QueueUserWorkItem(AddContactAfterPingAsync, request.SourceNode);
}
}
else
{
contact.UpdateLastSeenTime();
}
}
catch
{ }
}
}
}
catch (Exception ex)
{
Debug.Write("DhtClient.ReadQueryPacketsAsync", ex);
}
}
