public void FinishSearch(string reason)
{
Finished = true;
FinishReason = reason;
if (ProxyTcp != null)
{
if (ProxyTcp.Proxy == ProxyType.ClientBlocked)
{
SearchAck ack = new SearchAck();
ack.Source = Network.GetLocalSource();
ack.SearchID = SearchID;
foreach (DhtLookup lookup in LookupList)
{
ack.ContactList.Add(lookup.Contact);
}
}
SearchReq req = new SearchReq();
req.SearchID = SearchID;
req.EndProxySearch = true;
ProxyTcp.SendPacket(req);
}
if (DoneEvent != null)
{
DoneEvent.Invoke(this);
}
}
public void Receive_SearchAck(SearchAck ack, G2ReceivedPacket packet)
{
DhtContact source = new DhtContact(ack.Source, packet.Source.IP);
if (!CrawlMap.ContainsKey(source.RoutingID))
{
CrawlMap[source.RoutingID] = new CrawlNode(source);
}
foreach (DhtContact contact in ack.ContactList)
{
if (!CrawlMap.ContainsKey(contact.RoutingID))
{
CrawlMap[contact.RoutingID] = new CrawlNode(contact);
}
}
}
private void SendAck(G2ReceivedPacket packet, SearchReq request, SearchAck ack)
{
// if request came in tcp, send back tcp - scenario happens in these situations
// req u-> open t-> fw ack t-> open u-> remote
// fw req t-> open ack t-> fw
// fw1 req t-> open t-> fw2 ack t-> open t-> fw1
int bytesSent = 0;
if (packet.ReceivedTcp)
{
ack.ToAddress = packet.Source;
bytesSent = packet.Tcp.SendPacket(ack);
}
else
{
bytesSent = Network.SendPacket(packet.Source, ack);
}
Core.ServiceBandwidth[ack.Service].OutPerSec += bytesSent;
}
private void DrawGroup(Graphics buffer, Dictionary <ulong, Dictionary <ulong, PacketGroup> > TrafficGroup, bool tcp)
{
foreach (Dictionary <ulong, PacketGroup> destination in TrafficGroup.Values)
{
foreach (PacketGroup group in destination.Values)
{
if (!NodePoints.ContainsKey(group.SourceID) || !NodePoints.ContainsKey(group.DestID))
{
continue;
}
group.SetPoints(NodePoints[group.SourceID], NodePoints[group.DestID]);
TrafficPen.Width = 1;
group.LineSize = 200 + 20;
if (group.TotalSize > 200)
{
TrafficPen.Width = 2;
group.LineSize = 1000 + 100;
}
if (group.TotalSize > 1000)
{
TrafficPen.Width = 3;
group.LineSize = group.TotalSize + 500;
}
// calc break size
double breakSize = (group.LineSize - group.TotalSize) / (group.Packets.Count + 1);
double pos = breakSize;
Color bgColor = Color.WhiteSmoke;
//if (SelectedID != 0)
// bgColor = group.SourceID == SelectedID ? Color.LightCoral : Color.LightBlue;
//else
// bgColor = tcp ? Color.LightBlue : Color.WhiteSmoke;
TrafficPen.Color = bgColor;
buffer.DrawLine(TrafficPen, group.GetPoint(0), group.GetPoint(pos));
foreach (byte[] packet in group.Packets)
{
if (Sim.TestEncryption || Sim.TestTcpFullBuffer)
{
TrafficPen.Color = Legend.PicUnk.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos), group.GetPoint(pos + packet.Length));
}
else
{
G2Header root = new G2Header(packet);
G2Protocol.ReadPacket(root);
double controlLen = (root.InternalPos > 0) ? root.InternalPos - root.PacketPos : packet.Length;
// net packet
if (root.Name == RootPacket.Network)
{
TrafficPen.Color = Legend.PicNet.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos), group.GetPoint(pos + controlLen));
NetworkPacket netPacket = NetworkPacket.Decode(root);
G2Header internalRoot = new G2Header(netPacket.InternalData);
G2Protocol.ReadPacket(internalRoot);
G2ReceivedPacket recvedPacket = new G2ReceivedPacket();
recvedPacket.Root = internalRoot;
// draw internal
TrafficPen.Color = Legend.PicUnk.BackColor;
if (internalRoot.Name == NetworkPacket.SearchRequest)
{
SearchReq req = SearchReq.Decode(recvedPacket);
int paramLen = req.Parameters == null ? 10 : req.Parameters.Length;
TrafficPen.Color = Legend.PicSrchReq.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize - paramLen));
TrafficPen.Color = GetComponentColor(req.Service);
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen + internalRoot.PacketSize - paramLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize));
}
else if (internalRoot.Name == NetworkPacket.SearchAck)
{
SearchAck ack = SearchAck.Decode(recvedPacket);
int valLen = 10;
if (ack.ValueList.Count > 0)
{
valLen = 0;
foreach (byte[] val in ack.ValueList)
{
valLen += val.Length;
}
}
TrafficPen.Color = Legend.PicSrchAck.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize - valLen));
TrafficPen.Color = GetComponentColor(ack.Service);
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen + internalRoot.PacketSize - valLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize));
}
else if (internalRoot.Name == NetworkPacket.StoreRequest)
{
StoreReq req = StoreReq.Decode(recvedPacket);
int dataLen = req.Data == null ? 10 : req.Data.Length;
TrafficPen.Color = Legend.PicStore.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize - dataLen));
TrafficPen.Color = GetComponentColor(req.Service);
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen + internalRoot.PacketSize - dataLen), group.GetPoint(pos + controlLen + internalRoot.PacketSize));
}
else
{
if (internalRoot.Name == NetworkPacket.Ping)
{
TrafficPen.Color = Legend.PicPing.BackColor;
}
else if (internalRoot.Name == NetworkPacket.Pong)
{
TrafficPen.Color = Legend.PicPong.BackColor;
}
else if (internalRoot.Name == NetworkPacket.ProxyRequest)
{
TrafficPen.Color = Legend.PicPxyReq.BackColor;
}
else if (internalRoot.Name == NetworkPacket.ProxyAck)
{
TrafficPen.Color = Legend.PicPxyAck.BackColor;
}
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen), group.GetPoint(pos + packet.Length));
}
}
// comm packet
if (root.Name == RootPacket.Comm)
{
TrafficPen.Color = Legend.PicComm.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos), group.GetPoint(pos + controlLen));
TrafficPen.Color = Legend.PicUnk.BackColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos + controlLen), group.GetPoint(pos + packet.Length));
}
}
if (SelectedID != 0)
{
buffer.DrawString(group.TotalSize.ToString(), TahomaFont, BlackBrush, group.GetPoint(group.LineSize / 4));
}
pos += packet.Length;
TrafficPen.Color = bgColor;
buffer.DrawLine(TrafficPen, group.GetPoint(pos), group.GetPoint(pos + breakSize));
pos += breakSize;
}
}
}
}
public void ReceiveAck(G2ReceivedPacket packet)
{
SearchAck ack = SearchAck.Decode(packet);
// loopback
if (Network.Local.Equals(ack.Source))
{
return;
}
if (Core.ServiceBandwidth.ContainsKey(ack.Service))
{
Core.ServiceBandwidth[ack.Service].InPerSec += packet.Root.Data.Length;
}
if (ack.Source.Firewall == FirewallType.Open)
{
Routing.Add(new DhtContact(ack.Source, packet.Source.IP));
}
foreach (DhtContact contact in ack.ContactList)
{
Routing.Add(contact); // function calls back into seach system, adding closer nodes
}
// if response to initial pong or crawl
if (ack.SearchID == 0)
{
Core.RunInGuiThread(Network.CrawlerSearchAck, ack, packet);
return;
}
// mark searches as done
lock (Active)
foreach (DhtSearch search in Active)
{
if (search.SearchID == ack.SearchID)
{
foreach (DhtLookup lookup in search.LookupList)
{
if (lookup.Contact.UserID == ack.Source.UserID && lookup.Contact.ClientID == ack.Source.ClientID)
{
lookup.Status = LookupStatus.Done;
}
}
if (search.ProxyTcp != null && search.ProxyTcp.Proxy == ProxyType.ClientBlocked)
{
ack.FromAddress = packet.Source;
search.ProxyTcp.SendPacket(ack);
return;
}
foreach (byte[] value in ack.ValueList)
{
search.Found(value, packet.Source);
}
if (ack.Proxied)
{
search.Found(new DhtContact(ack.Source, packet.Source.IP), true);
}
if (!search.Finished && search.FoundValues.Count > search.TargetResults)
{
search.FinishSearch("Max Values Found");
}
}
}
}
public void ReceiveRequest(G2ReceivedPacket packet)
{
SearchReq request = SearchReq.Decode(packet);
// loopback
if (Network.Local.Equals(request.Source))
{
return;
}
if (Core.ServiceBandwidth.ContainsKey(request.Service))
{
Core.ServiceBandwidth[request.Service].InPerSec += packet.Root.Data.Length;
}
if (packet.ReceivedTcp && request.SearchID != 0)
{
// request from blocked node
if (packet.Tcp.Proxy == ProxyType.ClientBlocked)
{
int proxySearches = 0;
lock (Active)
foreach (DhtSearch search in Active)
{
if (search.ProxyTcp == packet.Tcp)
{
proxySearches++;
if (request.EndProxySearch && search.SearchID == request.SearchID)
{
search.FinishSearch("Proxied node finished search");
return;
}
}
}
if (proxySearches < MAX_SEARCHES)
{
DhtSearch search = new DhtSearch(this, request.TargetID, "Proxy", request.Service, request.DataType);
search.Parameters = request.Parameters;
search.ProxyTcp = packet.Tcp;
search.SearchID = request.SearchID;
search.Activate();
Active.Add(search);
search.Log("Active - Proxy Search");
}
// continue processing request and send local results
}
// request from proxy server
if (packet.Tcp.Proxy == ProxyType.Server && request.EndProxySearch)
{
lock (Active)
foreach (DhtSearch search in Active)
{
if (search.SearchID == request.SearchID)
{
if (!search.Finished)
{
search.FinishSearch("Server finished search");
}
}
}
}
}
if (request.Source.Firewall == FirewallType.Open)
{
Routing.Add(new DhtContact(request.Source, packet.Source.IP));
}
// forward to proxied nodes
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
{
// prevents incoming udp from proxy and being forwarded to same host tcp
if (socket != packet.Tcp && !(packet.Source.UserID == socket.UserID && packet.Source.ClientID == socket.ClientID))
{
request.FromAddress = packet.Source;
socket.SendPacket(request);
}
}
// send ack
bool sendNoResults = (request.SearchID != 0 || request.Service == Core.DhtServiceID) &&
(packet.ReceivedUdp || packet.Tunneled);
SearchAck ack = new SearchAck();
ack.Source = Network.GetLocalSource();
ack.SearchID = request.SearchID;
ack.Service = request.Service;
// search for connected proxy
if (Network.TcpControl.ProxyMap.Values.Any(p => p.UserID == request.TargetID))
{
ack.Proxied = true;
}
// only send nodes from proxy server routing table
if (request.Nodes && (packet.ReceivedUdp || packet.Tunneled))
{
ack.ContactList = Routing.Find(request.TargetID, 8);
}
// dont send an ack if behind a proxy server and no results
if (!SearchEvent.Contains(request.Service, request.DataType))
{
if (sendNoResults)
{
SendAck(packet, request, ack);
}
}
else
{
List <byte[]> results = new List <byte[]>();
SearchEvent[request.Service, request.DataType].Invoke(request.TargetID, request.Parameters, results);
// if nothing found, still send ack with closer contacts
if (results == null || results.Count == 0)
{
if (sendNoResults)
{
SendAck(packet, request, ack);
}
return;
}
// if a direct search
if (request.SearchID == 0)
{
foreach (byte[] value in results)
{
Network.Store.Send_StoreReq(packet.Source, packet.Tcp, new DataReq(null, request.TargetID, request.Service, request.DataType, value));
}
return;
}
// else send normal search results
int totalSize = 0;
foreach (byte[] data in results)
{
if (data.Length + totalSize > 1200)
{
SendAck(packet, request, ack);
ack.ValueList.Clear();
ack.ContactList.Clear(); // dont send twice
totalSize = 0;
}
ack.ValueList.Add(data);
totalSize += data.Length;
}
if (totalSize > 0)
{
SendAck(packet, request, ack);
}
}
}
public ListViewItem PackettoItem(PacketLogEntry logEntry)
{
// hash, protocol, direction, address, type, size
string hash = Utilities.BytestoHex(sha.ComputeHash(logEntry.Data), 0, 2, false);
string protocol = logEntry.Protocol.ToString();
// Network - Search / Search Req / Store ... - Component
// Comm - Data / Ack / Syn
// Rudp - Type - Component
string name = "?";
G2Header root = new G2Header(logEntry.Data);
if (G2Protocol.ReadPacket(root))
{
if (logEntry.Protocol == TransportProtocol.Rudp)
{
name = TransportProtocol.Rudp.ToString() + " - ";
name += GetVariableName(typeof(CommPacket), root.Name);
if (root.Name == CommPacket.Data)
{
CommData data = CommData.Decode(root);
name += " - " + Network.Core.GetServiceName(data.Service);
}
}
else
{
name = GetVariableName(typeof(RootPacket), root.Name) + " - ";
if (root.Name == RootPacket.Comm)
{
RudpPacket commPacket = RudpPacket.Decode(root);
name += GetVariableName(typeof(RudpPacketType), commPacket.PacketType);
}
if (root.Name == RootPacket.Network)
{
NetworkPacket netPacket = NetworkPacket.Decode(root);
G2Header internalRoot = new G2Header(netPacket.InternalData);
if (G2Protocol.ReadPacket(internalRoot))
{
name += GetVariableName(typeof(NetworkPacket), internalRoot.Name);
uint id = 0;
G2ReceivedPacket wrap = new G2ReceivedPacket();
wrap.Root = internalRoot;
// search request / search acks / stores have component types
if (internalRoot.Name == NetworkPacket.SearchRequest)
{
SearchReq req = SearchReq.Decode(wrap);
id = req.Service;
}
if (internalRoot.Name == NetworkPacket.SearchAck)
{
SearchAck ack = SearchAck.Decode(wrap);
id = ack.Service;
}
if (internalRoot.Name == NetworkPacket.StoreRequest)
{
StoreReq store = StoreReq.Decode(wrap);
id = store.Service;
}
if (id != 0)
{
name += " - " + Network.Core.GetServiceName(id); // GetVariableName(typeof(ServiceID), id);
}
}
}
}
}
string time = logEntry.Time.ToString("HH:mm:ss:ff");
string address = (logEntry.Address == null) ? "Broadcast" : logEntry.Address.ToString();
return(new PacketListViewItem(logEntry, new string[] { time, protocol, address, name, logEntry.Data.Length.ToString(), hash }, logEntry.Direction == DirectionType.In));
}
private void SendAck(G2ReceivedPacket packet, SearchReq request, SearchAck ack)
{
// if request came in tcp, send back tcp - scenario happens in these situations
// req u-> open t-> fw ack t-> open u-> remote
// fw req t-> open ack t-> fw
// fw1 req t-> open t-> fw2 ack t-> open t-> fw1
int bytesSent = 0;
if (packet.ReceivedTcp)
{
ack.ToAddress = packet.Source;
bytesSent = packet.Tcp.SendPacket(ack);
}
else
bytesSent = Network.SendPacket(packet.Source, ack);
Core.ServiceBandwidth[ack.Service].OutPerSec += bytesSent;
}
public void ReceiveRequest(G2ReceivedPacket packet)
{
SearchReq request = SearchReq.Decode(packet);
// loopback
if (Network.Local.Equals(request.Source))
return;
if (Core.ServiceBandwidth.ContainsKey(request.Service))
Core.ServiceBandwidth[request.Service].InPerSec += packet.Root.Data.Length;
if (packet.ReceivedTcp && request.SearchID != 0)
{
// request from blocked node
if (packet.Tcp.Proxy == ProxyType.ClientBlocked)
{
int proxySearches = 0;
lock (Active)
foreach (DhtSearch search in Active)
if (search.ProxyTcp == packet.Tcp)
{
proxySearches++;
if (request.EndProxySearch && search.SearchID == request.SearchID)
{
search.FinishSearch("Proxied node finished search");
return;
}
}
if (proxySearches < MAX_SEARCHES)
{
DhtSearch search = new DhtSearch(this, request.TargetID, "Proxy", request.Service, request.DataType);
search.Parameters = request.Parameters;
search.ProxyTcp = packet.Tcp;
search.SearchID = request.SearchID;
search.Activate();
Active.Add(search);
search.Log("Active - Proxy Search");
}
// continue processing request and send local results
}
// request from proxy server
if (packet.Tcp.Proxy == ProxyType.Server && request.EndProxySearch)
{
lock (Active)
foreach (DhtSearch search in Active)
if (search.SearchID == request.SearchID)
if( !search.Finished )
search.FinishSearch("Server finished search");
}
}
if (request.Source.Firewall == FirewallType.Open)
Routing.Add(new DhtContact(request.Source, packet.Source.IP));
// forward to proxied nodes
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
// prevents incoming udp from proxy and being forwarded to same host tcp
if(socket != packet.Tcp && !(packet.Source.UserID == socket.UserID && packet.Source.ClientID == socket.ClientID))
{
request.FromAddress = packet.Source;
socket.SendPacket(request);
}
// send ack
bool sendNoResults = (request.SearchID != 0 || request.Service == Core.DhtServiceID) &&
(packet.ReceivedUdp || packet.Tunneled);
SearchAck ack = new SearchAck();
ack.Source = Network.GetLocalSource();
ack.SearchID = request.SearchID;
ack.Service = request.Service;
// search for connected proxy
if (Network.TcpControl.ProxyMap.Values.Any(p => p.UserID == request.TargetID))
ack.Proxied = true;
// only send nodes from proxy server routing table
if (request.Nodes && (packet.ReceivedUdp || packet.Tunneled))
ack.ContactList = Routing.Find(request.TargetID, 8);
// dont send an ack if behind a proxy server and no results
if (!SearchEvent.Contains(request.Service, request.DataType))
{
if (sendNoResults)
SendAck(packet, request, ack);
}
else
{
List<byte[]> results = new List<byte[]>();
SearchEvent[request.Service, request.DataType].Invoke(request.TargetID, request.Parameters, results);
// if nothing found, still send ack with closer contacts
if (results == null || results.Count == 0)
{
if (sendNoResults)
SendAck(packet, request, ack);
return;
}
// if a direct search
if (request.SearchID == 0)
{
foreach(byte[] value in results)
Network.Store.Send_StoreReq(packet.Source, packet.Tcp, new DataReq(null, request.TargetID, request.Service, request.DataType, value));
return;
}
// else send normal search results
int totalSize = 0;
foreach (byte[] data in results)
{
if (data.Length + totalSize > 1200)
{
SendAck(packet, request, ack);
ack.ValueList.Clear();
ack.ContactList.Clear(); // dont send twice
totalSize = 0;
}
ack.ValueList.Add(data);
totalSize += data.Length;
}
if(totalSize > 0)
SendAck(packet, request, ack);
}
}
public void FinishSearch(string reason)
{
Finished = true;
FinishReason = reason;
if (ProxyTcp != null)
{
if (ProxyTcp.Proxy == ProxyType.ClientBlocked)
{
SearchAck ack = new SearchAck();
ack.Source = Network.GetLocalSource();
ack.SearchID = SearchID;
foreach (DhtLookup lookup in LookupList)
ack.ContactList.Add(lookup.Contact);
}
SearchReq req = new SearchReq();
req.SearchID = SearchID;
req.EndProxySearch = true;
ProxyTcp.SendPacket(req);
}
if(DoneEvent != null)
DoneEvent.Invoke(this);
}
public void Receive_SearchAck(SearchAck ack, G2ReceivedPacket packet)
{
DhtContact source = new DhtContact(ack.Source, packet.Source.IP);
if( !CrawlMap.ContainsKey(source.RoutingID) )
CrawlMap[source.RoutingID] = new CrawlNode(source);
foreach(DhtContact contact in ack.ContactList)
if (!CrawlMap.ContainsKey(contact.RoutingID))
CrawlMap[contact.RoutingID] = new CrawlNode(contact);
}
