public static CachedIP Decode(G2Header root)
{
CachedIP saved = new CachedIP();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Contact:
saved.Contact = DhtContact.ReadPacket(child);
break;
case Packet_LastSeen:
saved.LastSeen = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos));
break;
case Packet_Bootstrap:
saved.Bootstrap = BitConverter.ToBoolean(child.Data, child.PayloadPos);
break;
}
}
saved.Contact.LastSeen = saved.LastSeen;
return saved;
}
public static bool ReadPayload(G2Header packet)
{
ResetPacket(packet);
G2Header child = new G2Header(packet.Data);
G2ReadResult streamStatus = G2ReadResult.PACKET_GOOD;
while (streamStatus == G2ReadResult.PACKET_GOOD)
{
streamStatus = ReadNextChild(packet, child);
}
if (streamStatus == G2ReadResult.STREAM_END)
{
if (packet.NextBytesLeft > 0)
{
packet.PayloadPos = packet.NextBytePos;
packet.PayloadSize = packet.NextBytesLeft;
return(true);
}
}
else if (packet.NextBytesLeft > 0)
{
// Payload Read Error
//m_pG2Comm->m_pCore->DebugLog("G2 Network", "Payload Read Error: " + HexDump(packet.Packet, packet.PacketSize));
}
return(false);
}
public static LinkData Decode(G2Header root)
{
LinkData link = new LinkData();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Project:
link.Project = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_Target:
link.Target = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
link.TargetID = Utilities.KeytoID(link.Target);
break;
case Packet_Uplink:
link.Uplink = BitConverter.ToBoolean(child.Data, child.PayloadPos);
break;
case Packet_Title:
link.Title = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return link;
}
public static MessageData Decode(G2Header root)
{
MessageData msg = new MessageData();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Text:
msg.Text = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Format:
msg.Format = (TextFormat)CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_TargetID:
msg.TargetID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
}
}
return msg;
}
public static AudioPacket Decode(G2Header root)
{
AudioPacket packet = new AudioPacket();
if (G2Protocol.ReadPayload(root))
packet.Audio = Utilities.ExtractBytes(root.Data, root.PayloadPos, root.PayloadSize);
G2Protocol.ResetPacket(root);
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_FrameSize:
packet.FrameSize = CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return packet;
}
public static ChatInvite Decode(G2Header root)
{
ChatInvite invite = new ChatInvite();
G2Protocol.ResetPacket(root);
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_RoomID:
invite.RoomID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Title:
invite.Title = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Host:
invite.Host = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_SignedInvite:
invite.SignedInvite = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return invite;
}
public static void ResetPacket(G2Header packet)
{
packet.NextBytePos = packet.InternalPos;
packet.NextBytesLeft = packet.InternalSize;
packet.PayloadPos = 0;
packet.PayloadSize = 0;
}
public static G2ReadResult ReadNextChild(G2Header root, G2Header child)
{
if (!root.HasChildren)
{
return(G2ReadResult.STREAM_END);
}
return(ReadNextPacket(child, ref root.NextBytePos, ref root.NextBytesLeft));
}
public static bool ReadPacket(G2Header root)
{
int start = 0;
int length = root.Data.Length;
if (G2ReadResult.PACKET_GOOD == ReadNextPacket(root, ref start, ref length))
{
return(true);
}
return(false);
}
public static StorageFile Decode(byte[] data)
{
G2Header root = new G2Header(data);
if (!G2Protocol.ReadPacket(root))
return null;
if (root.Name != StoragePacket.File)
return null;
return StorageFile.Decode(root);
}
public static FileDetails Decode(byte[] data)
{
G2Header root = new G2Header(data);
if (!G2Protocol.ReadPacket(root))
return null;
if (root.Name != TransferPacket.Params)
return null;
return FileDetails.Decode(root);
}
public static PlanBlock Decode(byte[] data)
{
G2Header root = new G2Header(data);
if (!G2Protocol.ReadPacket(root))
return null;
if (root.Name != PlanPacket.Block)
return null;
return PlanBlock.Decode(root);
}
public static CommClose Decode(G2ReceivedPacket packet)
{
CommClose close = new CommClose();
G2Header child = new G2Header(packet.Root.Data);
while( G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD )
{
if (child.Name == Packet_Message)
if( G2Protocol.ReadPayload(child) )
close.Reason = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
}
return close;
}
public static PlanBlock Decode(G2Header root)
{
PlanBlock block = new PlanBlock();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_ProjectID:
block.ProjectID = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_Title:
block.Title = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_StartTime:
block.StartTime = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos));
break;
case Packet_EndTime:
block.EndTime = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos));
break;
case Packet_Description:
block.Description = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Scope:
block.Scope = BitConverter.ToInt16(child.Data, child.PayloadPos);
break;
case Packet_Unique:
block.Unique = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
}
}
return block;
}
public static MailAck Decode(G2Header root)
{
MailAck ack = new MailAck();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_MailID:
ack.MailID = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Source:
ack.Source = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
ack.SourceID = Utilities.KeytoID(ack.Source);
break;
case Packet_Target:
ack.Target = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
ack.TargetID = Utilities.KeytoID(ack.Target);
break;
case Packet_TargetVersion:
ack.TargetVersion = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_SourceVersion:
ack.SourceVersion = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
}
}
return ack;
}
private bool ReadNext(G2Header root)
{
if (ReadSize > 0)
{
int prevStart = Start;
ReadStatus = G2Protocol.ReadNextPacket(root, ref Start, ref ReadSize);
ParentPos += (Start - prevStart);
if (ReadStatus == G2ReadResult.PACKET_GOOD)
{
return(true);
}
}
// hit the exact end of the buffer read in, signal to read the next buffer in
else
{
ReadStatus = G2ReadResult.PACKET_INCOMPLETE;
}
return(false);
}
public static FileDetails Decode(G2Header root)
{
FileDetails packet = new FileDetails();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Service:
packet.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DataType:
packet.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Hash:
packet.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Size:
packet.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Extra:
packet.Extra = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return packet;
}
public bool ReadPacket(ref G2Header root)
{
root = new G2Header(ReadBuffer);
// continue from left off, read another goo packete
if (ReadNext(root))
{
return(true);
}
if (ReadStatus != G2ReadResult.PACKET_INCOMPLETE)
{
return(false);
}
// re-align
if (ReadSize > 0)
{
Buffer.BlockCopy(ReadBuffer, Start, ReadBuffer, 0, ReadSize);
}
// incomplete, or just started, read some more from file
Start = 0;
int read = ParentStream.Read(ReadBuffer, ReadSize, ReadBuffer.Length - ReadSize);
Pos += read;
ReadSize += read;
if (ReadNext(root))
{
return(true);
}
return(false);
}
public static ProfileAttachment Decode(G2Header root)
{
ProfileAttachment file = new ProfileAttachment();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Name:
file.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Size:
file.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return file;
}
public static VersionedFileHeader Decode(G2Header root)
{
VersionedFileHeader header = new VersionedFileHeader();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Key:
header.Key = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
header.KeyID = Utilities.KeytoID(header.Key);
break;
case Packet_Version:
header.Version = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_FileHash:
header.FileHash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_FileSize:
header.FileSize = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_FileKey:
header.FileKey = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Extra:
header.Extra = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return header;
}
public static LocationPing Decode(G2Header root)
{
LocationPing ping = new LocationPing();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_RemoteVersion:
ping.RemoteVersion = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return ping;
}
public static LocationData Decode(byte[] data)
{
G2Header root = new G2Header(data);
G2Protocol.ReadPacket(root);
if (root.Name != LocationPacket.Data)
return null;
LocationData loc = new LocationData();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Key:
loc.Key = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
loc.UserID = Utilities.KeytoID(loc.Key);
break;
case Packet_Source:
loc.Source = DhtSource.ReadPacket(child);
loc.UserID = loc.Source.UserID; // encode light doesnt send full key
break;
case Packet_IP:
loc.IP = new IPAddress(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
case Packet_Proxies:
loc.Proxies.Add( DhtAddress.ReadPacket(child) );
break;
case Packet_Name:
loc.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Place:
loc.Place = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Version:
loc.Version = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_GMTOffset:
loc.GmtOffset = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_Away:
loc.Away = BitConverter.ToBoolean(child.Data, child.PayloadPos);
break;
case Packet_AwayMsg:
loc.AwayMessage = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Tag:
loc.Tags.Add(PatchTag.FromBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
case Packet_TunnelClient:
loc.TunnelClient = TunnelAddress.FromBytes(child.Data, child.PayloadPos);
break;
case Packet_TunnelServers:
loc.TunnelServers.Add(DhtAddress.ReadPacket(child));
break;
}
}
return loc;
}
public void LoadHeaders()
{
List<string> goodPaths = new List<string>();
try
{
goodPaths.Add(HeaderPath);
if (!File.Exists(HeaderPath))
return;
using (IVCryptoStream crypto = IVCryptoStream.Load(HeaderPath, LocalKey))
{
PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read);
G2Header root = null;
while (stream.ReadPacket(ref root))
if (root.Name == DataPacket.SignedData)
{
SignedData signed = SignedData.Decode(root);
G2Header embedded = new G2Header(signed.Data);
// figure out data contained
if (G2Protocol.ReadPacket(embedded))
if (embedded.Name == DataPacket.VersionedFile)
{
VersionedFileHeader header = VersionedFileHeader.Decode(embedded);
if(header.FileHash != null)
goodPaths.Add(GetFilePath(header));
Process_VersionedFile(null, signed, header);
}
}
}
// remove loose files
foreach (string testPath in Directory.GetFiles(CachePath))
if (!goodPaths.Contains(testPath))
try { File.Delete(testPath); }
catch { }
}
catch (Exception ex)
{
Core.Network.UpdateLog("VersionedFile", "Error loading data " + ex.Message);
}
}
void Store_Local(DataReq store)
{
// getting published to - search results - patch
SignedData signed = SignedData.Decode(store.Data);
if (signed == null)
return;
G2Header embedded = new G2Header(signed.Data);
// figure out data contained
if (G2Protocol.ReadPacket(embedded))
if (embedded.Name == DataPacket.VersionedFile)
Process_VersionedFile(store, signed, VersionedFileHeader.Decode(signed.Data));
}
public static G2ReadResult ReadNextPacket(G2Header packet, ref int readPos, ref int readSize)
{
if (readSize == 0)
{
return(G2ReadResult.PACKET_INCOMPLETE);
}
int beginPos = readPos;
int beginSize = readSize;
packet.PacketPos = readPos;
// Read Control Byte
byte control = Buffer.GetByte(packet.Data, readPos);
readPos += 1;
readSize -= 1;
if (control == 0)
{
return(G2ReadResult.STREAM_END);
}
byte lenLen = (byte)((control & 0xE0) >> 5); // 11100000
byte nameLen = (byte)((control & 0x18) >> 3); // 00011000
byte flags = (byte)(control & 0x07); // 00000111
bool bigEndian = (flags & 0x02) != 0;
bool isCompound = (flags & 0x04) != 0;
if (bigEndian)
{
return(G2ReadResult.PACKET_ERROR);
}
packet.HasChildren = isCompound;
// Read Packet Length
packet.InternalSize = 0;
if (lenLen != 0)
{
if (readSize < lenLen)
{
readPos = beginPos;
readSize = beginSize;
return(G2ReadResult.PACKET_INCOMPLETE);
}
byte[] lenData = new byte[8]; // create here because lenLen is less than 8 in size
Buffer.BlockCopy(packet.Data, readPos, lenData, 0, lenLen);
packet.InternalSize = BitConverter.ToInt32(lenData, 0); // only 4 bytes supported so far
Debug.Assert(MAX_FINAL_SIZE < G2_PACKET_BUFF);
if (packet.InternalSize < 0 || MAX_FINAL_SIZE < packet.InternalSize)
{
Debug.Assert(false);
return(G2ReadResult.PACKET_ERROR);
}
readPos += lenLen;
readSize -= lenLen;
}
// Read Packet Name
if (readSize < nameLen)
{
readPos = beginPos;
readSize = beginSize;
return(G2ReadResult.PACKET_INCOMPLETE);
}
if (nameLen != 1)
{
return(G2ReadResult.PACKET_ERROR);
}
/*if(packet.Name.Length + 1 + nameLen > MAX_NAME_SIZE - 1)
* {
* Debug.Assert(false);
* packet.Name = "ERROR";
* }
* else
* {
* packet.Name += "/" + StringEnc.GetString(packet.Data, readPos, nameLen);
* }*/
packet.Name = packet.Data[readPos];
readPos += nameLen;
readSize -= nameLen;
// Check if full packet length available in stream
if (readSize < packet.InternalSize)
{
readPos = beginPos;
readSize = beginSize;
return(G2ReadResult.PACKET_INCOMPLETE);
}
packet.InternalPos = (packet.InternalSize > 0) ? readPos : 0;
packet.NextBytePos = packet.InternalPos;
packet.NextBytesLeft = packet.InternalSize;
readPos += packet.InternalSize;
readSize -= packet.InternalSize;
packet.PacketSize = 1 + lenLen + nameLen + packet.InternalSize;
return(G2ReadResult.PACKET_GOOD);
}
public static ProfileField Decode(G2Header root)
{
ProfileField field = new ProfileField();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Type:
field.FieldType = (ProfileFieldType)child.Data[child.PayloadPos];
break;
case Packet_Name:
field.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Value:
field.Value = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return field;
}
public static SessionAck Decode(G2ReceivedPacket packet)
{
SessionAck sa = new SessionAck();
G2Header child = new G2Header(packet.Root.Data);
while( G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD )
{
if (child.Name == Packet_Name)
if (G2Protocol.ReadPayload(child))
sa.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
}
return sa;
}
public static SessionRequest Decode(G2ReceivedPacket packet)
{
SessionRequest sr = new SessionRequest();
G2Header child = new G2Header(packet.Root.Data);
while( G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD )
{
if (child.Name == Packet_Key)
if (G2Protocol.ReadPayload(child))
sr.EncryptedKey = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
return sr;
}
public static RudpPacket Decode(G2Header root)
{
RudpPacket gc = new RudpPacket();
if( G2Protocol.ReadPayload(root) )
gc.Payload = Utilities.ExtractBytes(root.Data, root.PayloadPos, root.PayloadSize);
G2Protocol.ResetPacket(root);
G2Header child = new G2Header(root.Data);
while( G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD )
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_SenderDht:
gc.SenderID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_SenderClient:
gc.SenderClient = BitConverter.ToUInt16(child.Data, child.PayloadPos);
break;
case Packet_TargetDht:
gc.TargetID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_TargetClient:
gc.TargetClient = BitConverter.ToUInt16(child.Data, child.PayloadPos);
break;
case Packet_Type:
gc.PacketType = child.Data[child.PayloadPos];
break;
case Packet_ID:
gc.PeerID = BitConverter.ToUInt16(child.Data, child.PayloadPos);
break;
case Packet_Seq:
gc.Sequence = (byte)child.Data[child.PayloadPos];
break;
case Packet_Ident:
gc.Ident = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_To:
gc.ToAddress = DhtAddress.ReadPacket(child);
break;
case Packet_Proxy:
gc.RemoteProxy = DhtAddress.ReadPacket(child);
break;
}
}
return gc;
}
public static ProxyUpdate Decode(G2ReceivedPacket packet)
{
ProxyUpdate update = new ProxyUpdate();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Proxy:
update.Proxy = DhtAddress.ReadPacket(child);
break;
}
}
return update;
}
public static VersionedFileHeader Decode(byte[] data)
{
G2Header root = new G2Header(data);
if (!G2Protocol.ReadPacket(root))
return null;
if (root.Name != DataPacket.VersionedFile)
return null;
return VersionedFileHeader.Decode(root);
}
public static KeyRequest Decode(G2ReceivedPacket packet)
{
KeyRequest kr = new KeyRequest();
G2Header child = new G2Header(packet.Root.Data);
while( G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD )
{
if (!G2Protocol.ReadPayload(child))
continue;
if (child.Name == Packet_Encryption)
kr.Encryption = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
else if (child.Name == Packet_Key)
kr.Key = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
else if (child.Name == Packet_IV)
kr.IV = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
return kr;
}
public void ReadChildren(G2Header rootPacket, TreeNode rootNode, Type packetType)
{
G2Header child = new G2Header(rootPacket.Data);
while( G2Protocol.ReadNextChild(rootPacket, child) == G2ReadResult.PACKET_GOOD )
{
string name = child.Name.ToString();
if (packetType != null)
name += " : " + GetVariableName(packetType, child.Name);
TreeNode childNode = rootNode.Nodes.Add(name);
if(G2Protocol.ReadPayload(child))
{
//childNode.Nodes.Add( "Payload Ascii: " + Utilities.BytestoAscii(childPacket.Data, childPacket.PayloadPos, childPacket.PayloadSize));
childNode.Nodes.Add(new DataNode(child.Data, child.PayloadPos, child.PayloadSize));
}
G2Protocol.ResetPacket(child);
ReadChildren(child, childNode, null);
}
}
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 );
}
public static CommData Decode(G2Header root)
{
CommData data = new CommData();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_Service:
data.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DataType:
data.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Data:
data.Data = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return data;
}
private void ListViewPackets_Click(object sender, System.EventArgs e)
{
if(ListViewPackets.SelectedItems.Count == 0)
return;
PacketListViewItem selected = (PacketListViewItem) ListViewPackets.SelectedItems[0];
// build tree
TreeViewPacket.Nodes.Clear();
G2Header root = new G2Header(selected.LogEntry.Data);
if (G2Protocol.ReadPacket(root))
{
if (selected.LogEntry.Protocol == TransportProtocol.Rudp)
{
string name = root.Name.ToString() + " : " + GetVariableName(typeof(CommPacket), root.Name);
TreeNode rootNode = TreeViewPacket.Nodes.Add(name);
if (G2Protocol.ReadPayload(root))
rootNode.Nodes.Add(new DataNode(root.Data, root.PayloadPos, root.PayloadSize));
G2Protocol.ResetPacket(root);
// get type
Type packetType = null;
switch (root.Name)
{
case CommPacket.SessionRequest:
packetType = typeof(SessionRequest);
break;
case CommPacket.SessionAck:
packetType = typeof(SessionAck);
break;
case CommPacket.KeyRequest:
packetType = typeof(KeyRequest);
break;
case CommPacket.KeyAck:
packetType = typeof(KeyAck);
break;
case CommPacket.Data:
packetType = typeof(CommData);
break;
case CommPacket.Close:
packetType = typeof(CommClose);
break;
}
ReadChildren(root, rootNode, packetType);
}
else
{
string name = root.Name.ToString() + " : " + GetVariableName(typeof(RootPacket), root.Name);
TreeNode rootNode = TreeViewPacket.Nodes.Add(name);
DataNode payloadNode = null;
if (G2Protocol.ReadPayload(root))
{
payloadNode = new DataNode(root.Data, root.PayloadPos, root.PayloadSize);
rootNode.Nodes.Add(payloadNode);
}
G2Protocol.ResetPacket(root);
if (root.Name == RootPacket.Comm)
{
ReadChildren(root, rootNode, typeof(RudpPacket));
}
if (root.Name == RootPacket.Tunnel)
{
ReadChildren(root, rootNode, typeof(RudpPacket));
}
if (root.Name == RootPacket.Network)
{
ReadChildren(root, rootNode, typeof(NetworkPacket));
G2Header payloadRoot = new G2Header(payloadNode.Data);
if (payloadNode.Data != null && G2Protocol.ReadPacket(payloadRoot))
{
name = payloadRoot.Name.ToString() + " : " + GetVariableName(typeof(NetworkPacket), payloadRoot.Name);
TreeNode netNode = payloadNode.Nodes.Add(name);
if (G2Protocol.ReadPayload(payloadRoot))
netNode.Nodes.Add(new DataNode(payloadRoot.Data, payloadRoot.PayloadPos, payloadRoot.PayloadSize));
G2Protocol.ResetPacket(payloadRoot);
Type packetType = null;
switch (payloadRoot.Name)
{
case NetworkPacket.SearchRequest:
packetType = typeof(SearchReq);
break;
case NetworkPacket.SearchAck:
packetType = typeof(SearchAck);
break;
case NetworkPacket.StoreRequest:
packetType = typeof(StoreReq);
break;
case NetworkPacket.Ping:
packetType = typeof(Ping);
break;
case NetworkPacket.Pong:
packetType = typeof(Pong);
break;
case NetworkPacket.Bye:
packetType = typeof(Bye);
break;
case NetworkPacket.ProxyRequest:
packetType = typeof(ProxyReq);
break;
case NetworkPacket.ProxyAck:
packetType = typeof(ProxyAck);
break;
case NetworkPacket.CrawlRequest:
packetType = typeof(CrawlRequest);
break;
case NetworkPacket.CrawlAck:
packetType = typeof(CrawlAck);
break;
}
ReadChildren(payloadRoot, netNode, packetType);
}
}
}
}
/*G2Header rootPacket = new G2Header(selected.LogEntry.Data);
int start = 0;
int size = selected.LogEntry.Data.Length;
if(G2ReadResult.PACKET_GOOD == Protocol.ReadNextPacket(rootPacket, ref start, ref size) )
{
TreeNode rootNode = TreeViewPacket.Nodes.Add( TrimName(rootPacket.Name.ToString()) );
if(G2Protocol.ReadPayload(rootPacket))
{
//rootNode.Nodes.Add( Utilities.BytestoAscii(rootPacket.Data, rootPacket.PayloadPos, rootPacket.PayloadSize));
rootNode.Nodes.Add( Utilities.BytestoHex(rootPacket.Data, rootPacket.PayloadPos, rootPacket.PayloadSize, true));
}
G2Protocol.ResetPacket(rootPacket);
ReadChildren(rootPacket, rootNode, null);
}*/
TreeViewPacket.ExpandAll();
}
public static KeyAck Decode(G2ReceivedPacket packet)
{
KeyAck ka = new KeyAck();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue ;
if (child.Name == Packet_Key)
ka.PublicKey = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
return ka;
}
