public static ProxyAck Decode(G2ReceivedPacket packet)
{
ProxyAck pa = new ProxyAck();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
switch (child.Name)
{
case Packet_Source:
if (G2Protocol.ReadPayload(child))
{
pa.Source = DhtSource.ReadPacket(child);
}
break;
case Packet_Accept:
pa.Accept = true;
break;
case Packet_Contacts:
if (G2Protocol.ReadPayload(child))
{
pa.ContactList.Add(DhtContact.ReadPacket(child));
}
break;
}
}
return(pa);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame bdy = protocol.WritePacket(null, RootPacket.Comm, Payload);
protocol.WritePacket(bdy, Packet_SenderDht, BitConverter.GetBytes(SenderID));
protocol.WritePacket(bdy, Packet_SenderClient, BitConverter.GetBytes(SenderClient));
protocol.WritePacket(bdy, Packet_TargetDht, BitConverter.GetBytes(TargetID));
protocol.WritePacket(bdy, Packet_TargetClient, BitConverter.GetBytes(TargetClient));
protocol.WritePacket(bdy, Packet_Type, BitConverter.GetBytes(PacketType));
protocol.WritePacket(bdy, Packet_ID, BitConverter.GetBytes(PeerID));
protocol.WritePacket(bdy, Packet_Seq, BitConverter.GetBytes(Sequence));
if (Ident != 0)
{
protocol.WritePacket(bdy, Packet_Ident, BitConverter.GetBytes(Ident));
}
if (ToAddress != null)
{
ToAddress.WritePacket(protocol, bdy, Packet_To);
}
if (RemoteProxy != null)
{
RemoteProxy.WritePacket(protocol, bdy, Packet_Proxy);
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame goal = protocol.WritePacket(null, PlanPacket.Goal, null);
protocol.WritePacket(goal, Packet_Ident, BitConverter.GetBytes(Ident));
protocol.WritePacket(goal, Packet_Project, BitConverter.GetBytes(Project));
protocol.WritePacket(goal, Packet_BranchUp, BitConverter.GetBytes(BranchUp));
protocol.WritePacket(goal, Packet_BranchDown, BitConverter.GetBytes(BranchDown));
protocol.WritePacket(goal, Packet_Title, UTF8Encoding.UTF8.GetBytes(Title));
protocol.WritePacket(goal, Packet_End, BitConverter.GetBytes(End.ToBinary()));
protocol.WritePacket(goal, Packet_Desc, UTF8Encoding.UTF8.GetBytes(Description));
protocol.WritePacket(goal, Packet_Person, BitConverter.GetBytes(Person));
protocol.WritePacket(goal, Packet_Archived, BitConverter.GetBytes(Archived));
protocol.WritePacket(goal, Packet_EstCompleted, BitConverter.GetBytes(EstCompleted));
protocol.WritePacket(goal, Packet_EstTotal, BitConverter.GetBytes(EstTotal));
return(protocol.WriteFinish());
}
}
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 static LargeDataPacket Decode(G2Header root)
{
LargeDataPacket packet = new LargeDataPacket(root.Name, 0, null);
// size packet
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
if (child.Name == Packet_Size)
{
packet.Size = BitConverter.ToInt32(child.Data, child.PayloadPos);
}
if (child.Name == Packet_Hash)
{
packet.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
}
return(packet);
}
public static InvitePackage OpenInvite(byte[] decrypted, G2Protocol protocol)
{
// if we get down here, opening invite was success
MemoryStream mem = new MemoryStream(decrypted);
PacketStream stream = new PacketStream(mem, protocol, FileAccess.Read);
InvitePackage package = new InvitePackage();
G2Header root = null;
while (stream.ReadPacket(ref root))
{
if (root.Name == InvitePacket.Info)
{
package.Info = OneWayInvite.Decode(root);
}
if (root.Name == InvitePacket.Contact)
{
package.Contacts.Add(DhtContact.ReadPacket(root));
}
if (root.Name == InvitePacket.WebCache)
{
package.Caches.Add(WebCache.Decode(root));
}
}
return(package);
}
public static OneWayInvite Decode(G2Header root)
{
OneWayInvite invite = new OneWayInvite();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_UserName:
invite.UserName = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_OpName:
invite.OpName = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_OpAccess:
invite.OpAccess = (AccessType)child.Data[child.PayloadPos];
break;
case Packet_OpID:
invite.OpID = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(invite);
}
public static SubHashPacket Decode(G2Header root)
{
SubHashPacket subhash = new SubHashPacket();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_ChunkSize:
subhash.ChunkSize = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_TotalCount:
subhash.TotalCount = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_SubHashes:
subhash.SubHashes = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(subhash);
}
// cant write local info (read) because post is re-transmitted
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame header = protocol.WritePacket(null, BoardPacket.PostHeader, null);
protocol.WritePacket(header, Packet_Source, Source);
protocol.WritePacket(header, Packet_Target, Target);
protocol.WritePacket(header, Packet_ProjectID, BitConverter.GetBytes(ProjectID));
protocol.WritePacket(header, Packet_PostID, BitConverter.GetBytes(PostID));
protocol.WritePacket(header, Packet_ParentID, BitConverter.GetBytes(ParentID));
protocol.WritePacket(header, Packet_Time, BitConverter.GetBytes(Time.ToBinary()));
protocol.WritePacket(header, Packet_Scope, new byte[] { (byte)Scope });
protocol.WritePacket(header, Packet_Version, BitConverter.GetBytes(Version));
protocol.WritePacket(header, Packet_EditTime, BitConverter.GetBytes(EditTime.ToBinary()));
protocol.WritePacket(header, Packet_Archived, BitConverter.GetBytes(Archived));
protocol.WritePacket(header, Packet_FileKey, FileKey);
protocol.WritePacket(header, Packet_FileHash, FileHash);
protocol.WritePacket(header, Packet_FileSize, BitConverter.GetBytes(FileSize));
protocol.WritePacket(header, Packet_FileStart, BitConverter.GetBytes(FileStart));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame invite = protocol.WritePacket(null, ChatPacket.Invite, null);
protocol.WritePacket(invite, Packet_RoomID, BitConverter.GetBytes(RoomID));
if (Host != null)
{
protocol.WritePacket(invite, Packet_Host, Host);
}
if (SignedInvite != null)
{
protocol.WritePacket(invite, Packet_SignedInvite, SignedInvite);
}
if (Title.Length > 0)
{
protocol.WritePacket(invite, Packet_Title, UTF8Encoding.UTF8.GetBytes(Title));
}
return(protocol.WriteFinish());
}
}
public static PostFile Decode(G2Header root)
{
PostFile file = new PostFile();
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 PostInfo Decode(G2Header root)
{
PostInfo info = new PostInfo();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Subject:
info.Subject = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Format:
info.Format = (TextFormat)CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Quip:
info.Quip = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Unique:
info.Unique = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
}
}
return(info);
}
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 TempData Decode(ulong target, byte[] data)
{
G2Header root = new G2Header(data);
G2Protocol.ReadPacket(root);
if (root.Name != TempPacket.Data)
{
return(null);
}
TempData temp = new TempData(target);
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_TTL:
temp.TTL = CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Data:
temp.Data = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(temp);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame ack = protocol.WritePacket(null, NetworkPacket.CrawlAck, null);
Source.WritePacket(protocol, ack, Packet_Source);
protocol.WritePacket(ack, Packet_Version, UTF8Encoding.UTF8.GetBytes(Version));
protocol.WritePacket(ack, Packet_Uptime, BitConverter.GetBytes(Uptime));
foreach (DhtContact proxy in ProxyServers)
{
proxy.WritePacket(protocol, ack, Packet_ProxyServers);
}
foreach (DhtContact proxy in ProxyClients)
{
proxy.WritePacket(protocol, ack, Packet_ProxyClients);
}
// network packet
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
public byte[] Encode(G2Protocol protocol, bool local)
{
lock (protocol.WriteSection)
{
G2Frame header = protocol.WritePacket(null, MailPacket.MailHeader, null);
protocol.WritePacket(header, Packet_Source, Source);
protocol.WritePacket(header, Packet_Target, Target);
protocol.WritePacket(header, Packet_FileKey, FileKey);
protocol.WritePacket(header, Packet_FileHash, FileHash);
protocol.WritePacket(header, Packet_FileSize, BitConverter.GetBytes(FileSize));
protocol.WritePacket(header, Packet_SourceVersion, BitConverter.GetBytes(SourceVersion));
protocol.WritePacket(header, Packet_TargetVersion, BitConverter.GetBytes(TargetVersion));
protocol.WritePacket(header, Packet_MailID, MailID);
protocol.WritePacket(header, Packet_ThreadID, BitConverter.GetBytes(ThreadID));
if (local)
{
protocol.WritePacket(header, Packet_LocalKey, LocalKey);
protocol.WritePacket(header, Packet_FileStart, BitConverter.GetBytes(FileStart));
protocol.WritePacket(header, Packet_Read, BitConverter.GetBytes(Read));
protocol.WritePacket(header, Packet_Received, BitConverter.GetBytes(Received.ToBinary()));
}
return(protocol.WriteFinish());
}
}
public static void DecryptTagFile(string source, string destination, byte[] key, OpCore core)
{
int bufferSize = 4096;
byte[] buffer = new byte[4096]; // needs to be 4k to packet stream break/resume work
string tempPath = (core != null) ? core.GetTempPath() : destination;
G2Protocol protocol = (core != null) ? core.Network.Protocol : new G2Protocol();
using (FileStream tempFile = new FileStream(tempPath, FileMode.Create))
using (TaggedStream encFile = new TaggedStream(source, protocol))
using (IVCryptoStream stream = IVCryptoStream.Load(encFile, key))
{
int read = bufferSize;
while (read == bufferSize)
{
read = stream.Read(buffer, 0, bufferSize);
tempFile.Write(buffer, 0, read);
}
}
// move to official path
if (core == null)
{
return;
}
File.Copy(tempPath, destination, true);
File.Delete(tempPath);
}
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 static ServiceData Decode(byte[] data)
{
G2Header root = new G2Header(data);
G2Protocol.ReadPacket(root);
if (root.Name != LocationPacket.Data)
{
return(null);
}
ServiceData packet = new ServiceData();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Date:
packet.Date = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos));
break;
case Packet_Tag:
packet.Tags.Add(PatchTag.FromBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
}
}
return(packet);
}
public byte[] EncodeLight(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame loc = protocol.WritePacket(null, LocationPacket.Data, null);
Source.WritePacket(protocol, loc, Packet_Source);
protocol.WritePacket(loc, Packet_IP, IP.GetAddressBytes());
foreach (DhtAddress proxy in Proxies)
{
proxy.WritePacket(protocol, loc, Packet_Proxies);
}
if (TunnelClient != null)
{
protocol.WritePacket(loc, Packet_TunnelClient, TunnelClient.ToBytes());
}
foreach (DhtAddress server in TunnelServers)
{
server.WritePacket(protocol, loc, Packet_TunnelServers);
}
return(protocol.WriteFinish());
}
}
public static ShareCollection Decode(G2Header header, ulong user)
{
ShareCollection root = new ShareCollection(user);
G2Header child = new G2Header(header.Data);
while (G2Protocol.ReadNextChild(header, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Hash:
root.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Size:
root.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Key:
root.Key = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(root);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame root = protocol.WritePacket(null, SharePacket.File, null);
protocol.WritePacket(root, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(root, Packet_Hash, Hash);
protocol.WritePacket(root, Packet_Size, CompactNum.GetBytes(Size));
protocol.WritePacket(root, Packet_FileKey, FileKey);
if (SaveLocal)
{
if (SystemPath != null)
{
protocol.WritePacket(root, Packet_SystemPath, UTF8Encoding.UTF8.GetBytes(SystemPath));
}
if (Public)
{
protocol.WritePacket(root, Packet_Public, null);
}
}
return(protocol.WriteFinish());
}
}
public static ProxyReq Decode(G2ReceivedPacket packet)
{
ProxyReq pr = new ProxyReq();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
switch (child.Name)
{
case Packet_Source:
if (G2Protocol.ReadPayload(child))
{
pr.SenderID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
}
break;
case Packet_Blocked:
pr.Type = ProxyType.ClientBlocked;
break;
case Packet_NAT:
pr.Type = ProxyType.ClientNAT;
break;
}
}
return(pr);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame po = protocol.WritePacket(null, NetworkPacket.Pong, null);
if (Source != null)
{
Source.WritePacket(protocol, po, Packet_Source);
}
if (RemoteIP != null)
{
protocol.WritePacket(po, Packet_RemoteIP, RemoteIP.GetAddressBytes());
}
if (Direct)
{
protocol.WritePacket(po, Packet_Direct, null);
}
if (Version != 0)
{
protocol.WritePacket(po, Packet_Version, CompactNum.GetBytes(Version));
}
// network packet
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame bye = protocol.WritePacket(null, NetworkPacket.Bye, null);
protocol.WritePacket(bye, Packet_Source, BitConverter.GetBytes(SenderID));
foreach (DhtContact contact in ContactList)
{
contact.WritePacket(protocol, bye, Packet_Contacts);
}
if (Message != null)
{
protocol.WritePacket(bye, Packet_Message, UTF8Encoding.UTF8.GetBytes(Message));
}
if (Reconnect)
{
protocol.WritePacket(bye, Packet_Reconnect, null);
}
// network packet
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
public static Ping Decode(G2ReceivedPacket packet)
{
Ping pi = new Ping();
if (G2Protocol.ReadPayload(packet.Root))
{
pi.Ident = BitConverter.ToUInt16(packet.Root.Data, packet.Root.PayloadPos);
}
G2Protocol.ResetPacket(packet.Root);
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_Source:
pi.Source = DhtSource.ReadPacket(child);
break;
case Packet_RemoteIP:
pi.RemoteIP = new IPAddress(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
}
}
return(pi);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame ack = protocol.WritePacket(null, NetworkPacket.SearchAck, null);
Source.WritePacket(protocol, ack, Packet_Source);
protocol.WritePacket(ack, Packet_SearchID, BitConverter.GetBytes(SearchID));
protocol.WritePacket(ack, Packet_Service, CompactNum.GetBytes(Service));
if (Proxied)
{
protocol.WritePacket(ack, Packet_Proxied, null);
}
foreach (DhtContact contact in ContactList)
{
contact.WritePacket(protocol, ack, Packet_Contacts);
}
foreach (byte[] value in ValueList)
{
protocol.WritePacket(ack, Packet_Values, value);
}
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
public static DhtAddress ReadPacket(G2Header root)
{
// read payload
DhtAddress address = new DhtAddress();
address.UserID = BitConverter.ToUInt64(root.Data, root.PayloadPos);
address.ClientID = BitConverter.ToUInt16(root.Data, root.PayloadPos + 8);
address.UdpPort = BitConverter.ToUInt16(root.Data, root.PayloadPos + 10);
// read packets
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_IP:
address.IP = new IPAddress(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
}
}
return(address);
}
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 Receive_Patch(DhtAddress source, byte[] data)
{
// invoke patch
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
if (root.Name == StorePacket.Patch)
{
PatchPacket packet = PatchPacket.Decode(root);
if (packet == null)
{
return;
}
foreach (PatchTag patch in packet.PatchData)
{
if (PatchEvent.Contains(patch.Service, patch.DataType))
{
PatchEvent[patch.Service, patch.DataType].Invoke(source, patch.Tag);
}
}
}
}
}
internal override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame root = protocol.WritePacket(null, SharingPacket.PublicRequest, null);
return protocol.WriteFinish();
}
}
internal override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame root = protocol.WritePacket(null, SharingPacket.File, null);
protocol.WritePacket(root, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(root, Packet_Hash, Hash);
protocol.WritePacket(root, Packet_Size, CompactNum.GetBytes(Size));
protocol.WritePacket(root, Packet_FileKey, FileKey);
if (SaveLocal)
{
if (SystemPath != null)
protocol.WritePacket(root, Packet_SystemPath, UTF8Encoding.UTF8.GetBytes(SystemPath));
if (Public)
protocol.WritePacket(root, Packet_Public, null);
}
return protocol.WriteFinish();
}
}
internal override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame root = protocol.WritePacket(null, SharingPacket.Collection, null);
protocol.WritePacket(root, Packet_Hash, Hash);
protocol.WritePacket(root, Packet_Size, CompactNum.GetBytes(Size));
protocol.WritePacket(root, Packet_Key, Key);
return protocol.WriteFinish();
}
}