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 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 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 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 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 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 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 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 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 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 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 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 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 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());
}
}
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 msg = protocol.WritePacket(null, IMPacket.Message, null);
protocol.WritePacket(msg, Packet_Text, UTF8Encoding.UTF8.GetBytes(Text));
protocol.WritePacket(msg, Packet_Format, CompactNum.GetBytes((int)Format));
if (TargetID != 0)
{
protocol.WritePacket(msg, Packet_TargetID, BitConverter.GetBytes(TargetID));
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame stop = protocol.WritePacket(null, TransferPacket.Stop, null);
protocol.WritePacket(stop, Packet_FileID, BitConverter.GetBytes(FileID));
protocol.WritePacket(stop, Packet_StartByte, CompactNum.GetBytes(StartByte));
protocol.WritePacket(stop, Packet_Index, CompactNum.GetBytes(Index));
if (Retry)
{
protocol.WritePacket(stop, Packet_Retry, null);
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame tr = protocol.WritePacket(null, TransferPacket.Request, null);
protocol.WritePacket(tr, Packet_FileID, BitConverter.GetBytes(FileID));
protocol.WritePacket(tr, Packet_ChunkIndex, CompactNum.GetBytes(ChunkIndex));
protocol.WritePacket(tr, Packet_StartByte, CompactNum.GetBytes(StartByte));
protocol.WritePacket(tr, Packet_EndByte, CompactNum.GetBytes(EndByte));
if (GetBitfield)
{
protocol.WritePacket(tr, Packet_GetBitfield, null);
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
byte[] details = Details.Encode(protocol); // prevent protocol conflict
lock (protocol.WriteSection)
{
G2Frame partial = protocol.WritePacket(null, TransferPacket.Partial, null);
protocol.WritePacket(partial, Packet_Created, BitConverter.GetBytes(Created.ToBinary()));
protocol.WritePacket(partial, Packet_Details, details);
protocol.WritePacket(partial, Packet_Target, BitConverter.GetBytes(Target));
protocol.WritePacket(partial, Packet_BitCount, CompactNum.GetBytes(BitCount));
protocol.WritePacket(partial, Packet_Bitfield, Bitfield.ToBytes());
protocol.WritePacket(partial, Packet_InternalSize, CompactNum.GetBytes(InternalSize));
protocol.WritePacket(partial, Packet_ChunkSize, CompactNum.GetBytes(ChunkSize));
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame chat = protocol.WritePacket(null, ChatPacket.Data, null);
protocol.WritePacket(chat, Packet_ID, BitConverter.GetBytes(ProjectID));
protocol.WritePacket(chat, Packet_Kind, BitConverter.GetBytes((int)Kind));
protocol.WritePacket(chat, Packet_RoomID, BitConverter.GetBytes(RoomID));
if (Text.Length > 0)
{
protocol.WritePacket(chat, Packet_Text, UTF8Encoding.UTF8.GetBytes(Text));
protocol.WritePacket(chat, Packet_Format, CompactNum.GetBytes((int)Format));
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame req = protocol.WritePacket(null, NetworkPacket.StoreRequest, null);
Source.WritePacket(protocol, req, Packet_Source);
protocol.WritePacket(req, Packet_Key, BitConverter.GetBytes(Key));
protocol.WritePacket(req, Packet_Service, CompactNum.GetBytes(Service));
protocol.WritePacket(req, Packet_DataType, CompactNum.GetBytes(DataType));
protocol.WritePacket(req, Packet_Data, Data);
protocol.WritePacket(req, Packet_TTL, BitConverter.GetBytes(TTL));
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
public byte[] ToBytes()
{
byte[] sByte = CompactNum.GetBytes(Service);
byte[] dByte = CompactNum.GetBytes(DataType);
byte control = (byte)(sByte.Length << 3);
control |= (byte)dByte.Length;
int size = 1 + sByte.Length + dByte.Length + Tag.Length;
byte[] data = new byte[size];
data[0] = control;
sByte.CopyTo(data, 1);
dByte.CopyTo(data, 1 + sByte.Length);
Tag.CopyTo(data, 1 + sByte.Length + dByte.Length);
return(data);
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame header = protocol.WritePacket(null, DataPacket.VersionedFile, null);
protocol.WritePacket(header, Packet_Key, Key);
protocol.WritePacket(header, Packet_Version, CompactNum.GetBytes(Version));
if (FileHash != null)
{
protocol.WritePacket(header, Packet_FileHash, FileHash);
protocol.WritePacket(header, Packet_FileSize, CompactNum.GetBytes(FileSize));
protocol.WritePacket(header, Packet_FileKey, FileKey);
}
protocol.WritePacket(header, Packet_Extra, Extra);
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame loc = protocol.WritePacket(null, LocationPacket.Data, null);
protocol.WritePacket(loc, Packet_Key, Key);
Source.WritePacket(protocol, loc, Packet_Source);
protocol.WritePacket(loc, Packet_IP, IP.GetAddressBytes());
protocol.WritePacket(loc, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(loc, Packet_Place, UTF8Encoding.UTF8.GetBytes(Place));
protocol.WritePacket(loc, Packet_Version, CompactNum.GetBytes(Version));
protocol.WritePacket(loc, Packet_GMTOffset, BitConverter.GetBytes(GmtOffset));
protocol.WritePacket(loc, Packet_Away, BitConverter.GetBytes(Away));
protocol.WritePacket(loc, Packet_AwayMsg, UTF8Encoding.UTF8.GetBytes(AwayMessage));
foreach (DhtAddress proxy in Proxies)
{
proxy.WritePacket(protocol, loc, Packet_Proxies);
}
foreach (PatchTag tag in Tags)
{
protocol.WritePacket(loc, Packet_Tag, tag.ToBytes());
}
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 override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame file = protocol.WritePacket(null, StoragePacket.File, null);
protocol.WritePacket(file, Packet_UID, BitConverter.GetBytes(UID));
protocol.WritePacket(file, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name));
protocol.WritePacket(file, Packet_Date, BitConverter.GetBytes(Date.ToBinary()));
StorageFlags netFlags = Flags & ~(StorageFlags.Unlocked); // allow modified for working
protocol.WritePacket(file, Packet_Flags, BitConverter.GetBytes((ushort)netFlags));
protocol.WritePacket(file, Packet_Revs, BitConverter.GetBytes(Revs));
protocol.WritePacket(file, Packet_Integrated, BitConverter.GetBytes(IntegratedID));
protocol.WritePacket(file, Packet_Size, CompactNum.GetBytes(Size));
protocol.WritePacket(file, Packet_Hash, Hash);
protocol.WritePacket(file, Packet_FileKey, FileKey);
protocol.WritePacket(file, Packet_InternalSize, CompactNum.GetBytes(InternalSize));
protocol.WritePacket(file, Packet_InternalHash, InternalHash);
byte[] scopefield = new byte[10];
foreach (ulong id in Scope.Keys)
{
BitConverter.GetBytes(id).CopyTo(scopefield, 0);
BitConverter.GetBytes(Scope[id]).CopyTo(scopefield, 8);
protocol.WritePacket(file, Packet_Scope, scopefield);
}
if (Note != null)
{
protocol.WritePacket(file, Packet_Note, UTF8Encoding.UTF8.GetBytes(Note));
}
return(protocol.WriteFinish());
}
}
public override byte[] Encode(G2Protocol protocol)
{
lock (protocol.WriteSection)
{
G2Frame req = protocol.WritePacket(null, NetworkPacket.SearchRequest, null);
Source.WritePacket(protocol, req, Packet_Source);
protocol.WritePacket(req, Packet_Nodes, BitConverter.GetBytes(Nodes));
protocol.WritePacket(req, Packet_SearchID, BitConverter.GetBytes(SearchID));
protocol.WritePacket(req, Packet_Target, BitConverter.GetBytes(TargetID));
protocol.WritePacket(req, Packet_Service, CompactNum.GetBytes(Service));
protocol.WritePacket(req, Packet_DataType, CompactNum.GetBytes(DataType));
protocol.WritePacket(req, Packet_Parameters, Parameters);
if (EndProxySearch)
{
protocol.WritePacket(req, Packet_EndSearch, BitConverter.GetBytes(true));
}
InternalData = protocol.WriteFinish();
return(base.Encode(protocol));
}
}
