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, 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 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 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 override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame folder = protocol.WritePacket(null, StoragePacket.Folder, null); protocol.WritePacket(folder, Packet_UID, BitConverter.GetBytes(UID)); protocol.WritePacket(folder, Packet_ParentUID, BitConverter.GetBytes(ParentUID)); protocol.WritePacket(folder, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name)); protocol.WritePacket(folder, Packet_Date, BitConverter.GetBytes(Date.ToBinary())); StorageFlags netFlags = Flags & ~(StorageFlags.Modified | StorageFlags.Unlocked); protocol.WritePacket(folder, Packet_Flags, BitConverter.GetBytes((ushort)netFlags)); if (Note != null) { protocol.WritePacket(folder, Packet_Note, UTF8Encoding.UTF8.GetBytes(Note)); } protocol.WritePacket(folder, Packet_Revs, BitConverter.GetBytes(Revs)); protocol.WritePacket(folder, Packet_Integrated, BitConverter.GetBytes(IntegratedID)); 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(folder, Packet_Scope, scopefield); } return(protocol.WriteFinish()); } }
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 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 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 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) { lock (protocol.WriteSection) { G2Frame user = protocol.WritePacket(null, IdentityPacket.UserInfo, Key); protocol.WritePacket(user, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name)); 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 root = protocol.WritePacket(null, StoragePacket.Root, null); protocol.WritePacket(root, Packet_Project, BitConverter.GetBytes(ProjectID)); return(protocol.WriteFinish()); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame sr = protocol.WritePacket(null, CommPacket.SessionRequest, null); protocol.WritePacket(sr, Packet_Key, EncryptedKey); return(protocol.WriteFinish()); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame sa = protocol.WritePacket(null, CommPacket.SessionAck, null); protocol.WritePacket(sa, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name)); return(protocol.WriteFinish()); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame ka = protocol.WritePacket(null, CommPacket.KeyAck, null); protocol.WritePacket(ka, Packet_Key, PublicKey); return(protocol.WriteFinish()); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame close = protocol.WritePacket(null, CommPacket.Close, null); protocol.WritePacket(close, Packet_Message, UTF8Encoding.UTF8.GetBytes(Reason)); return(protocol.WriteFinish()); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame signed = protocol.WritePacket(null, DataPacket.SignedData, null); protocol.WritePacket(signed, Packet_Signature, Signature); protocol.WritePacket(signed, Packet_Data, Data); 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 dest = protocol.WritePacket(null, MailPacket.MailDest, null); protocol.WritePacket(dest, Packet_Key, Key); protocol.WritePacket(dest, Packet_CC, BitConverter.GetBytes(CC)); return(protocol.WriteFinish()); } }
public static byte[] Encode(G2Protocol protocol, RSACryptoServiceProvider key, byte[] data) { lock (protocol.WriteSection) { G2Frame signed = protocol.WritePacket(null, DataPacket.SignedData, null); protocol.WritePacket(signed, Packet_Signature, key.SignData(data, new SHA1CryptoServiceProvider())); protocol.WritePacket(signed, Packet_Data, data); return(protocol.WriteFinish()); } }
public void WritePacket(G2Protocol protocol, G2Frame root, byte name) { byte[] payload = new byte[PAYLOAD_SIZE]; BitConverter.GetBytes(UserID).CopyTo(payload, 0); BitConverter.GetBytes(ClientID).CopyTo(payload, 8); BitConverter.GetBytes(UdpPort).CopyTo(payload, 10); G2Frame address = protocol.WritePacket(root, name, payload); protocol.WritePacket(address, Packet_IP, IP.GetAddressBytes()); }
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 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 project = protocol.WritePacket(null, TrustPacket.ProjectData, null); protocol.WritePacket(project, Packet_ID, BitConverter.GetBytes(ID)); protocol.WritePacket(project, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name)); protocol.WritePacket(project, Packet_UserName, UTF8Encoding.UTF8.GetBytes(UserName)); 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()); } }
// 100 chunks per packet - 10*200 = 2,000kb packets public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame subhash = protocol.WritePacket(null, FilePacket.SubHash, null); protocol.WritePacket(subhash, Packet_ChunkSize, BitConverter.GetBytes(ChunkSize)); protocol.WritePacket(subhash, Packet_TotalCount, BitConverter.GetBytes(TotalCount)); protocol.WritePacket(subhash, Packet_SubHashes, SubHashes); 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 header = protocol.WritePacket(null, ProfilePacket.Field, null); protocol.WritePacket(header, Packet_Type, BitConverter.GetBytes((byte)FieldType)); protocol.WritePacket(header, Packet_Name, UTF8Encoding.UTF8.GetBytes(Name)); protocol.WritePacket(header, Packet_Value, Value); return(protocol.WriteFinish()); } }
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.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(); } }
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(); } }