public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame ack = protocol.WritePacket(null, TransferPacket.Ack, null);
protocol.WritePacket(ack, Packet_FileID, BitConverter.GetBytes(FileID));
protocol.WritePacket(ack, Packet_StartByte, CompactNum.GetBytes(StartByte));
if (Uninitialized)
{
protocol.WritePacket(ack, Packet_Uninitialized, null);
}
if (Error)
{
protocol.WritePacket(ack, Packet_Error, null);
}
if (Bitfield != null)
{
protocol.WritePacket(ack, Packet_Bitfield, Bitfield);
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame pong = protocol.WritePacket(null, TransferPacket.Pong, null);
protocol.WritePacket(pong, Packet_FileID, BitConverter.GetBytes(FileID));
protocol.WritePacket(pong, Packet_Timeout, CompactNum.GetBytes(Timeout));
protocol.WritePacket(pong, Packet_Status, CompactNum.GetBytes((int)Status));
if (Error)
{
protocol.WritePacket(pong, Packet_Error, null);
}
if (InternalSize != 0)
{
protocol.WritePacket(pong, Packet_InternalSize, CompactNum.GetBytes(InternalSize));
protocol.WritePacket(pong, Packet_ChunkSize, CompactNum.GetBytes(ChunkSize));
protocol.WritePacket(pong, Packet_BitCount, CompactNum.GetBytes(BitCount));
}
foreach (DhtClient client in Alts.Keys)
{
G2Frame alt = protocol.WritePacket(pong, Packet_AltClient, client.ToBytes());
foreach (DhtAddress address in Alts[client])
{
address.WritePacket(protocol, alt, Packet_AltAddress);
}
}
return(protocol.WriteFinish());
}
}
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);
}
public override byte[] Encode(G2Protocol protocol)
{
byte[] details = Details.Encode(protocol); // prevent protocol conflict
lock (protocol.WriteSection)
{
G2Frame ping = protocol.WritePacket(null, TransferPacket.Ping, null);
protocol.WritePacket(ping, Packet_Target, BitConverter.GetBytes(Target));
protocol.WritePacket(ping, Packet_Details, details);
protocol.WritePacket(ping, Packet_Status, BitConverter.GetBytes((int)Status));
if (MissingDepth >= 0)
{
protocol.WritePacket(ping, Packet_MissingDepth, CompactNum.GetBytes(MissingDepth));
}
if (RequestInfo)
{
protocol.WritePacket(ping, Packet_RequestInfo, null);
}
if (RequestAlts)
{
protocol.WritePacket(ping, Packet_RequestAlts, null);
}
if (BitfieldUpdated)
{
protocol.WritePacket(ping, Packet_BitfieldUpdated, null);
}
return(protocol.WriteFinish());
}
}
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.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 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 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 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 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 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 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());
}
}
void LocalSync_TagReceived(ulong user, byte[] tag)
{
if (tag.Length == 0)
{
return;
}
uint version = 0;
OpVersionedFile file = GetFile(user);
if (file != null)
{
version = CompactNum.ToUInt32(tag, 0, tag.Length);
// version old, so we need the latest localSync file
// wont cause loop because localsync's fileAquired will only fire on new version of localSync
if (version < file.Header.Version)
{
Core.Sync.Research(user);
}
}
// if newer file on network, or this node is in our cache area, find it
if ((file != null && version > file.Header.Version) ||
(file == null && ((!GlobalIM && Network.Routing.InCacheArea(user)) ||
(GlobalIM && Core.Buddies.BuddyList.SafeContainsKey(user)))))
{
StartSearch(user, version); // this could be called from a patch given to another user, direct connect not gauranteed
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame ping = protocol.WritePacket(null, LocationPacket.Ping, null);
protocol.WritePacket(ping, Packet_RemoteVersion, CompactNum.GetBytes(RemoteVersion));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame packet = protocol.WritePacket(null, VoicePacket.Audio, Audio);
protocol.WritePacket(packet, Packet_FrameSize, CompactNum.GetBytes(FrameSize));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame header = protocol.WritePacket(null, ProfilePacket.Attachment, null);
protocol.WritePacket(header, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(header, Packet_Size, CompactNum.GetBytes(Size));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame temp = protocol.WritePacket(null, TempPacket.Data, null);
protocol.WritePacket(temp, Packet_TTL, CompactNum.GetBytes(TTL));
protocol.WritePacket(temp, Packet_Data, Data);
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame file = protocol.WritePacket(null, BoardPacket.PostFile, null);
protocol.WritePacket(file, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(file, Packet_Size, CompactNum.GetBytes(Size));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame packet = protocol.WritePacket(null, CommPacket.Data, null);
protocol.WritePacket(packet, Packet_Service, CompactNum.GetBytes(Service));
protocol.WritePacket(packet, Packet_DataType, CompactNum.GetBytes(DataType));
protocol.WritePacket(packet, Packet_Data, Data);
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame td = protocol.WritePacket(null, TransferPacket.Data, Block);
protocol.WritePacket(td, Packet_FileID, BitConverter.GetBytes(FileID));
protocol.WritePacket(td, Packet_StartByte, CompactNum.GetBytes(StartByte));
protocol.WritePacket(td, Packet_Index, CompactNum.GetBytes(Index));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame root = protocol.WritePacket(null, SharePacket.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());
}
}
public static TransferPing Decode(G2Header root)
{
TransferPing ping = new TransferPing();
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (child.Name == Packet_RequestInfo)
{
ping.RequestInfo = true;
}
if (child.Name == Packet_RequestAlts)
{
ping.RequestAlts = true;
}
if (child.Name == Packet_BitfieldUpdated)
{
ping.BitfieldUpdated = true;
}
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Target:
ping.Target = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Details:
ping.Details = FileDetails.Decode(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
case Packet_Status:
ping.Status = (TransferStatus)BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_MissingDepth:
ping.MissingDepth = CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(ping);
}
public static SearchReq Decode(G2ReceivedPacket packet)
{
SearchReq req = new SearchReq();
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:
req.Source = DhtSource.ReadPacket(child);
break;
case Packet_SearchID:
req.SearchID = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_Target:
req.TargetID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Service:
req.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DataType:
req.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Parameters:
req.Parameters = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Nodes:
req.Nodes = BitConverter.ToBoolean(child.Data, child.PayloadPos);
break;
case Packet_EndSearch:
req.EndProxySearch = true;
break;
}
}
return(req);
}
void Search_Local(ulong key, byte[] parameters, List <byte[]> results)
{
uint version = CompactNum.ToUInt32(parameters, 0, parameters.Length);
// if local version equal to or greater, send back signed packet
if (Core.Context.SignedUpdate == null ||
!Core.Context.SignedUpdate.Loaded ||
Core.Context.SignedUpdate.SequentialVersion < version)
{
return;
}
results.Add(Core.Context.SignedUpdate.Encode(Core.Network.Protocol));
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame info = protocol.WritePacket(null, BoardPacket.PostInfo, null);
protocol.WritePacket(info, Packet_Subject, UTF8Encoding.UTF8.GetBytes(Subject));
protocol.WritePacket(info, Packet_Format, CompactNum.GetBytes((int)Format));
protocol.WritePacket(info, Packet_Quip, UTF8Encoding.UTF8.GetBytes(Quip));
protocol.WritePacket(info, Packet_Unique, BitConverter.GetBytes(Unique));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame packet = protocol.WritePacket(null, TransferPacket.Params, null);
protocol.WritePacket(packet, Packet_Service, CompactNum.GetBytes(Service));
protocol.WritePacket(packet, Packet_DataType, CompactNum.GetBytes(DataType));
protocol.WritePacket(packet, Packet_Hash, Hash);
protocol.WritePacket(packet, Packet_Size, CompactNum.GetBytes(Size));
protocol.WritePacket(packet, Packet_Extra, Extra);
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame notify = protocol.WritePacket(null, LocationPacket.Notify, SignedLocation);
protocol.WritePacket(notify, Packet_Timeout, CompactNum.GetBytes(Timeout));
if (GoingOffline)
{
protocol.WritePacket(notify, Packet_GoingOffline, null);
}
return(protocol.WriteFinish());
}
}
/*
#if DEBUG
* void SignNewUpdate()
* {
* // Network update only uses sequential version
* // release betas with higher sequential version
* // auto-update requires a signed sequential version, so betas can be safely relesaed
*
* Core.UserMessage("Signing Update");
*
* try
* {
* UpdateInfo info = new UpdateInfo();
*
* info.Name = "DeOps_13.exe";
* //info.DottedVersion = "1.1.3";
*
* // want to prevent infinite update loop, ensure the seq verison in the intaller, and the
* // signed seq version in the update are equal
* info.SequentialVersion = Core.Context.LocalSeqVersion;
*
* info.Notes = "";
* info.Notes += "Fixed stupid bug\r\n";
*
* RijndaelManaged crypt = new RijndaelManaged();
* crypt.Key = Utilities.GenerateKey(Core.StrongRndGen, 256);
* info.Key = crypt.Key;
*
* string source = "..\\Protected\\DeOps.exe";
* string final = Path.Combine(Application.StartupPath, "update.dat");
*
* string tempPath = Core.GetTempPath();
* Utilities.EncryptTagFile(source, tempPath, crypt, Core.Network.Protocol, ref info.Hash, ref info.Size);
*
* // function to encrypt given file
* using (FileStream stream = File.OpenRead(tempPath))
* {
* info.Beginning = new byte[64];
* stream.Read(info.Beginning, 0, info.Beginning.Length);
* }
*
* // test
* //Utilities.DecryptTagFile(tempPath, "..\\Protected\\check.exe", crypt.Key, null);
*
* File.Copy(tempPath, final, true);
* File.Delete(tempPath);
*
* // sign
* info.SignUpdate(Core.Network.Protocol);
*
* // test
* byte[] test = info.Encode(Core.Network.Protocol);
* Debug.Assert(test.Length < 1024);
*
* G2Header root = new G2Header(test);
* Debug.Assert(G2Protocol.ReadPacket(root));
* Debug.Assert(UpdateInfo.Decode(root) != null);
*
* // set
* Core.Context.SignedUpdate = info;
*
* // write bootstrap
* LookupConfig.WriteUpdateInfo(Core);
*
* Core.UserMessage("Sign Update Success");
*
* Process.Start("explorer.exe", Application.StartupPath);
* Debug.Assert(false);
* }
* catch (Exception ex)
* {
* Core.UserMessage(ex.Message);
* }
*
* Application.Exit();
* }
#endif*/
public void NewVersion(uint version, ulong user)
{
// if need to get new signed info
if (Core.Context.SignedUpdate == null || Core.Context.SignedUpdate.SequentialVersion < version)
{
byte[] parameters = CompactNum.GetBytes(version);
Core.Network.Searches.Start(user, "Update Search", ServiceID, 0, parameters, Search_Found);
}
// else if just need file
else if (!Core.Context.SignedUpdate.Loaded)
{
StartDownload(user);
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame info = protocol.WritePacket(null, MailPacket.MailInfo, null);
protocol.WritePacket(info, Packet_Subject, UTF8Encoding.UTF8.GetBytes(Subject));
protocol.WritePacket(info, Packet_Format, CompactNum.GetBytes((int)Format));
protocol.WritePacket(info, Packet_Quip, UTF8Encoding.UTF8.GetBytes(Quip));
protocol.WritePacket(info, Packet_Date, BitConverter.GetBytes(Date.ToBinary()));
protocol.WritePacket(info, Packet_Attachments, BitConverter.GetBytes(Attachments));
protocol.WritePacket(info, Packet_Unique, Unique);
return(protocol.WriteFinish());
}
}
