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 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 ReceivePacket(G2ReceivedPacket packet)
{
// Network packet
if (packet.Root.Name == RootPacket.Network)
{
NetworkPacket netPacket = NetworkPacket.Decode(packet.Root);
G2ReceivedPacket embedded = new G2ReceivedPacket();
embedded.Tcp = packet.Tcp;
embedded.Source = packet.Source;
embedded.Source.UserID = netPacket.SourceID;
embedded.Source.ClientID = netPacket.ClientID;
embedded.Root = new G2Header(netPacket.InternalData);
// from - received from proxy server
if (netPacket.FromAddress != null)
{
if (packet.ReceivedUdp)
{
throw new Exception("From tag set on packet received udp");
}
if (packet.Tcp.Proxy != ProxyType.Server)
{
throw new Exception("From tag (" + netPacket.FromAddress.ToString() + ") set on packet not received from server (" + packet.Tcp.ToString() + ")");
}
embedded.Source = new DhtContact(netPacket.FromAddress);
}
// to - received from proxied node, and not for us
if (netPacket.ToAddress != null &&
!(netPacket.ToAddress.UserID == Local.UserID && netPacket.ToAddress.ClientID == Local.ClientID))
{
if (packet.ReceivedUdp)
{
throw new Exception("To tag set on packet received udp");
}
if (packet.Tcp.Proxy == ProxyType.Server || packet.Tcp.Proxy == ProxyType.Unset)
{
throw new Exception("To tag set on packet received from server");
}
DhtAddress address = netPacket.ToAddress;
netPacket.ToAddress = null;
TcpConnect direct = TcpControl.GetProxy(address);
if (direct != null)
{
direct.SendPacket(netPacket);
}
else
{
UdpControl.SendTo(address, netPacket);
}
return;
}
// process
if (G2Protocol.ReadPacket(embedded.Root))
{
ReceiveNetworkPacket(embedded);
}
}
// Tunnel Packet
else if (packet.Root.Name == RootPacket.Tunnel)
{
// can only tunnel over lookup network
if (!IsLookup)
{
return;
}
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Tunnel, DirectionType.In, packet.Source, packet.Root.Data);
LogPacket(logEntry);
TunnelPacket tunnel = TunnelPacket.Decode(packet.Root);
// handle locally
if (tunnel.Target.Equals(Local))
{
Core.Context.Cores.LockReading(delegate()
{
foreach (OpCore core in Core.Context.Cores)
{
if (core.TunnelID == tunnel.Target.TunnelID)
{
core.Network.ReceiveTunnelPacket(packet, tunnel);
}
}
});
}
else if (tunnel.TargetServer != null)
{
TcpConnect direct = TcpControl.GetProxy(tunnel.Target);
// if directly connected add from and forwared
if (direct != null)
{
direct.SendPacket(tunnel);
}
// only forward udp if received over tcp from a proxied host
else if (tunnel.TargetServer != null && packet.ReceivedTcp && packet.Tcp.Proxy != ProxyType.Server)
{
UdpControl.SendTo(tunnel.TargetServer, tunnel);
}
}
}
// Communication Packet
else if (packet.Root.Name == RootPacket.Comm)
{
RudpPacket commPacket = RudpPacket.Decode(packet);
// received direct
packet.Source.UserID = commPacket.SenderID;
packet.Source.ClientID = commPacket.SenderClient;
// remote node is proxied
if (commPacket.RemoteProxy != null)
{
packet.Source = new DhtContact(commPacket.RemoteProxy);
}
// For local host
if (commPacket.TargetID == Local.UserID && commPacket.TargetClient == Local.ClientID)
{
ReceiveCommPacket(packet, commPacket);
return;
}
// Also Forward to appropriate node
TcpConnect socket = TcpControl.GetProxy(commPacket.TargetID, commPacket.TargetClient);
if (socket != null)
{
// forward to proxied node - strip TO flag, add from address
commPacket.ToAddress = null;
commPacket.RemoteProxy = packet.Source; // if remote proxy is null, then we are setting this to the packet's original source
socket.SendPacket(commPacket);
return;
}
// received from a proxied node, forward udp
if (packet.ReceivedTcp && commPacket.ToAddress != null)
{
DhtAddress target = commPacket.ToAddress;
commPacket.ToAddress = null; // strip TO flag
commPacket.RemoteProxy = new DhtAddress(Core.LocalIP, GetLocalSource());
UdpControl.SendTo(target, commPacket);
}
}
}
