public static int SendtoAddress(DhtNetwork network, RudpAddress target, RudpPacket packet)
{
Debug.Assert(packet.Payload != null || packet.PacketType == RudpPacketType.LightAck);
int sentBytes = 0;
// same code used in rudpSocket
if (network.Core.Firewall != FirewallType.Blocked && target.LocalProxy == null)
{
sentBytes = network.SendPacket(target.Address, packet);
}
else if (target.Address.TunnelClient != null)
{
sentBytes = network.SendTunnelPacket(target.Address, packet);
}
else
{
packet.ToAddress = target.Address;
TcpConnect proxy = network.TcpControl.GetProxy(target.LocalProxy);
if (proxy != null)
{
sentBytes = proxy.SendPacket(packet);
}
else
{
sentBytes = network.TcpControl.SendRandomProxy(packet);
}
}
return(sentBytes);
}
public void Send_ProxyUpdate(TcpConnect tcp)
{
//crit handle special if tcp is global
ProxyUpdate update = new ProxyUpdate();
update.Proxy = new DhtAddress(tcp.RemoteIP, tcp);
Log("Sent Proxy Update (" + update.Proxy + ")");
SendPacket(update);
}
public void AddProxy(TcpConnect socket)
{
if (ProxyMap.ContainsKey(socket.RoutingID))
return;
ProxyMap[socket.RoutingID] = socket;
if (socket.Proxy == ProxyType.Server)
ProxyServers.Add(socket);
else
ProxyClients.Add(socket);
}
public void SendPacket(RudpPacket packet, RudpAddress target)
{
Debug.Assert(packet.Payload != null);
// sending syn to (tracked target) through (address target) udp / tcp
/*string log = "Sending " + tracked.Packet.PacketType.ToString();
* if (tracked.Packet.Ident != 0) log += ", ID " + tracked.Packet.Ident.ToString();
* log += " to " + Utilities.IDtoBin(tracked.Packet.TargetID).Substring(0, 10);
* log += " target address " + target.Address.ToString();*/
int sentBytes = 0;
// same code used in lightComm
if (Core.Firewall != FirewallType.Blocked && target.LocalProxy == null)
{
sentBytes = Network.SendPacket(target.Address, packet);
}
else if (target.Address.TunnelClient != null)
{
sentBytes = Network.SendTunnelPacket(target.Address, packet);
}
else
{
packet.ToAddress = target.Address;
TcpConnect proxy = Network.TcpControl.GetProxy(target.LocalProxy);
if (proxy != null)
{
sentBytes = proxy.SendPacket(packet);
}
else
{
sentBytes = Network.TcpControl.SendRandomProxy(packet);
}
//log += " proxied by local tcp";
}
Bandwidth.OutPerSec += sentBytes;
//Session.Log(log);
}
public void AddProxy(TcpConnect socket)
{
if (ProxyMap.ContainsKey(socket.RoutingID))
{
return;
}
ProxyMap[socket.RoutingID] = socket;
if (socket.Proxy == ProxyType.Server)
{
ProxyServers.Add(socket);
}
else
{
ProxyClients.Add(socket);
}
}
public TcpConnect OnAccept(Socket socket, IPEndPoint source)
{
TcpConnect inbound = new TcpConnect(this);
inbound.TcpSocket = socket;
inbound.RemoteIP = source.Address;
inbound.TcpPort = (ushort)source.Port; // zero if internet, actual value if sim
inbound.SetConnected();
// it's not until the host sends us traffic that we can send traffic back because we don't know
// connecting node's dhtID (and hence encryption key) until ping is sent
lock (SocketList)
SocketList.Add(inbound);
Network.UpdateLog("Tcp", "Accepted Connection from " + inbound.ToString());
return(inbound);
}
public void AnnounceProxy(TcpConnect tcp)
{
Debug.Assert(!Network.IsLookup);
// function run bewteen cores
if (Network.Core.InvokeRequired)
{
Network.Core.RunInCoreAsync(delegate() { AnnounceProxy(tcp); });
return;
}
foreach (RudpSession session in SessionMap.Values)
{
if (session.Status == SessionStatus.Active)
{
session.Send_ProxyUpdate(tcp);
}
}
}
void CheckProxies(ProxyType type, int max)
{
/*if (type == ProxyType.Server && Core.Sim.RealFirewall != FirewallType.Open)
* {
* int x = 0;
* // count number of connected servers, if too many break
* foreach (TcpConnect connection in SocketList)
* if (connection.Proxy == type)
* x++;
* if (x > 2)
* {
* int y = 0;
* y++;
* }
* }*/
TcpConnect furthest = null;
UInt64 distance = 0;
int count = 0;
lock (SocketList)
foreach (TcpConnect connection in SocketList)
{
if (connection.State == TcpState.Connected && connection.Proxy == type)
{
count++;
if ((connection.UserID ^ Network.Local.UserID) > distance)
{
distance = connection.UserID ^ Network.Local.UserID;
furthest = connection;
}
}
}
// greater than max, disconnect furthest
if (count > max && furthest != null)
{
furthest.CleanClose("Too many proxies, disconnecting furthest");
}
}
public void MakeOutbound(DhtAddress address, ushort tcpPort, string reason)
{
try
{
int connecting = 0;
// check if already connected
lock (SocketList)
foreach (TcpConnect socket in SocketList)
{
if (socket.State == TcpState.Connecting)
{
connecting++;
}
if (socket.State != TcpState.Closed &&
address.IP.Equals(socket.RemoteIP) &&
tcpPort == socket.TcpPort &&
socket.Outbound) // allows check firewall to work
{
return;
}
}
if (connecting > 6)
{
Debug.Assert(true);
return;
}
TcpConnect outbound = new TcpConnect(this, address, tcpPort);
Network.UpdateLog("Tcp", "Attempting Connection to " + address.ToString() + ":" + tcpPort.ToString() + " (" + reason + ")");
lock (SocketList)
SocketList.Add(outbound);
}
catch (Exception ex)
{
Network.UpdateLog("Exception", "TcpHandler::MakeOutbound: " + ex.Message);
}
}
public void AnnounceProxy(TcpConnect tcp)
{
Debug.Assert(!Network.IsLookup);
// function run bewteen cores
if (Network.Core.InvokeRequired)
{
Network.Core.RunInCoreAsync(delegate() { AnnounceProxy(tcp); });
return;
}
foreach (RudpSession session in SessionMap.Values)
if (session.Status == SessionStatus.Active)
session.Send_ProxyUpdate(tcp);
}
public void MakeOutbound( DhtAddress address, ushort tcpPort, string reason)
{
try
{
int connecting = 0;
// check if already connected
lock(SocketList)
foreach (TcpConnect socket in SocketList)
{
if (socket.State == TcpState.Connecting)
connecting++;
if (socket.State != TcpState.Closed &&
address.IP.Equals(socket.RemoteIP) &&
tcpPort == socket.TcpPort &&
socket.Outbound) // allows check firewall to work
return;
}
if (connecting > 6)
{
Debug.Assert(true);
return;
}
TcpConnect outbound = new TcpConnect(this, address, tcpPort);
Network.UpdateLog("Tcp", "Attempting Connection to " + address.ToString() + ":" + tcpPort.ToString() + " (" + reason + ")");
lock(SocketList)
SocketList.Add(outbound);
}
catch(Exception ex)
{
Network.UpdateLog("Exception", "TcpHandler::MakeOutbound: " + ex.Message);
}
}
public SimPacket(SimPacketType type, IPEndPoint source, byte[] packet, DhtNetwork dest, TcpConnect tcp, ulong id)
{
Type = type;
Source = source;
Packet = packet;
Dest = dest;
Tcp = tcp;
SenderID = id;
}
public int SendPacket(SimPacketType type, DhtNetwork network, byte[] packet, System.Net.IPEndPoint target, TcpConnect tcp)
{
if (type == SimPacketType.Tcp)
if (!TcpEndPoints.ContainsKey(target))
{
//this is what actually happens -> throw new Exception("Disconnected");
return -1;
}
if( !UdpEndPoints.ContainsKey(target) ||
!SimMap.ContainsKey(target.Address) ||
!SimMap.ContainsKey(network.Core.Sim.RealIP))
return 0;
DhtNetwork targetNet = (type == SimPacketType.Tcp) ? TcpEndPoints[target] : UdpEndPoints[target];
if (network.IsLookup != targetNet.IsLookup)
Debug.Assert(false);
IPEndPoint source = new IPEndPoint(network.Core.Sim.RealIP, 0);
source.Port = (type == SimPacketType.Udp) ? network.UdpControl.ListenPort : network.TcpControl.ListenPort;
SimInstance sourceInstance = SimMap[source.Address];
SimInstance destInstance = SimMap[target.Address];
if(packet != null)
sourceInstance.BytesSent += (ulong)packet.Length;
// tcp connection must be present to send tcp
if (type == SimPacketType.Tcp)
if( !TcpSourcetoDest.SafeContainsKey(tcp))
{
//this is what actually happens -> throw new Exception("Disconnected");
return -1;
}
// add destination to nat table
if (type == SimPacketType.Udp && sourceInstance.RealFirewall == FirewallType.NAT)
sourceInstance.NatTable[target] = true;
// if destination blocked drop udp / tcp connect requests
if (destInstance.RealFirewall == FirewallType.Blocked)
{
if (type == SimPacketType.Udp || type == SimPacketType.TcpConnect)
return 0;
}
// if destination natted drop udp (unless in nat table) / tcp connect requests
else if (destInstance.RealFirewall == FirewallType.NAT)
{
if (type == SimPacketType.TcpConnect)
return 0;
if (type == SimPacketType.Udp && !destInstance.NatTable.ContainsKey(source) )
return 0;
}
// randomly test tcp send buffer full
if(TestTcpFullBuffer)
if (type == SimPacketType.Tcp && packet.Length > 4 && RndGen.Next(2) == 1)
{
int newlength = packet.Length / 2;
byte[] newpacket = new byte[newlength];
Buffer.BlockCopy(packet, 0, newpacket, 0, newlength);
packet = newpacket;
}
if (packet != null && packet.Length == 0)
Debug.Assert(false, "Empty Packet");
int index = destInstance.ThreadIndex;
lock (OutPackets[index])
OutPackets[index].Add(new SimPacket(type, source, packet, targetNet, tcp, network.Local.UserID));
if (packet == null)
return 0;
return packet.Length;
}
public bool Activate()
{
// bootstrap search from routing
foreach(DhtContact contact in Network.Routing.Find(TargetID, 8))
Add(contact);
List<TcpConnect> sockets = null;
// if open send search to proxied nodes just for good measure, probably helps on very small networks
if (Core.Firewall == FirewallType.Open)
sockets = Network.TcpControl.ProxyClients;
// if natted send request to proxies for fresh nodes
if(Core.Firewall == FirewallType.NAT)
sockets = Network.TcpControl.ProxyServers;
if(sockets != null)
foreach (TcpConnect socket in sockets)
{
DhtContact contact = new DhtContact(socket, socket.RemoteIP);
Network.Searches.SendRequest(contact, TargetID, SearchID, Service, DataType, Parameters);
DhtLookup host = Add(socket.GetContact());
if (host != null)
host.Status = LookupStatus.Searching;
}
// if blocked send proxy search request to 1 proxy, record and wait
if (Core.Firewall == FirewallType.Blocked && !Network.UseLookupProxies)
{
// pick random proxy server
if (Network.TcpControl.ProxyServers.Count == 0)
return false;
ProxyTcp = Network.TcpControl.ProxyServers[Core.RndGen.Next(Network.TcpControl.ProxyServers.Count)];
Send_ProxySearchRequest();
}
return true;
}
public RudpAddress(DhtAddress address, TcpConnect proxy)
{
Address = address;
LocalProxy = new DhtClient(proxy);
}
public int SendRandomProxy(G2Packet packet)
{
TcpConnect socket = GetRandomProxy();
return((socket != null) ? socket.SendPacket(packet) : 0);
}
public TcpConnect OnAccept(Socket socket, IPEndPoint source)
{
TcpConnect inbound = new TcpConnect(this);
inbound.TcpSocket = socket;
inbound.RemoteIP = source.Address;
inbound.TcpPort = (ushort)source.Port; // zero if internet, actual value if sim
inbound.SetConnected();
// it's not until the host sends us traffic that we can send traffic back because we don't know
// connecting node's dhtID (and hence encryption key) until ping is sent
lock (SocketList)
SocketList.Add(inbound);
Network.UpdateLog("Tcp", "Accepted Connection from " + inbound.ToString());
return inbound;
}
public RudpAddress(DhtAddress address, TcpConnect proxy)
{
Address = address;
LocalProxy = new DhtClient(proxy);
}
