public BoardService(OpCore core ) { Core = core; Network = Core.Network; Protocol = Network.Protocol; Store = Network.Store; Trust = Core.Trust; Core.SecondTimerEvent += Core_SecondTimer; Core.MinuteTimerEvent += Core_MinuteTimer; Network.CoreStatusChange += new StatusChange(Network_StatusChange); Store.StoreEvent[ServiceID, 0] += new StoreHandler(Store_Local); Store.ReplicateEvent[ServiceID, 0] += new ReplicateHandler(Store_Replicate); Store.PatchEvent[ServiceID, 0] += new PatchHandler(Store_Patch); Network.Searches.SearchEvent[ServiceID, 0] += new SearchRequestHandler(Search_Local); Core.Transfers.FileSearch[ServiceID, 0] += new FileSearchHandler(Transfers_FileSearch); Core.Transfers.FileRequest[ServiceID, 0] += new FileRequestHandler(Transfers_FileRequest); if (Core.Sim != null) PruneSize = 16; LocalFileKey = Core.User.Settings.FileKey; BoardPath = Core.User.RootPath + Path.DirectorySeparatorChar + "Data" + Path.DirectorySeparatorChar + ServiceID.ToString(); if (!Directory.Exists(BoardPath)) Directory.CreateDirectory(BoardPath); // get available board header targets string[] directories = Directory.GetDirectories(BoardPath); SortedDictionary<ulong, ulong> targets = new SortedDictionary<ulong, ulong>(); // key distance to self, value target foreach (string path in directories) { string dir = Path.GetFileName(path); // gets dir name ulong id = BitConverter.ToUInt64(Utilities.FromBase64String(dir), 0); targets[Core.UserID ^ id] = id; } // load closest targets int loaded = 0; foreach (ulong id in targets.Values) { LoadHeader(id); loaded++; if (loaded == PruneSize) break; } Loading = false; }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { protocol.WritePacket(null, IMPacket.Alive, null); 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 packet = protocol.WritePacket(null, VoicePacket.Audio, Audio); protocol.WritePacket(packet, Packet_FrameSize, CompactNum.GetBytes(FrameSize)); return protocol.WriteFinish(); } }
public PacketStream(Stream stream, G2Protocol protocol, FileAccess access) { ParentStream = stream; Protocol = protocol; Access = access; if (access == FileAccess.Read) { ReadBuffer = new byte[4096]; // break/resume relies on 4kb buffer } }
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 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 ack = protocol.WritePacket(null, MailPacket.Ack, null); protocol.WritePacket(ack, Packet_MailID, MailID); protocol.WritePacket(ack, Packet_Source, Source); protocol.WritePacket(ack, Packet_Target, Target); protocol.WritePacket(ack, Packet_TargetVersion, BitConverter.GetBytes(TargetVersion)); protocol.WritePacket(ack, Packet_SourceVersion, BitConverter.GetBytes(SourceVersion)); 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(); } }
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 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 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 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(); } }
public TaggedStream(string path, G2Protocol protocol, ProcessTagsHandler processTags) : base(path, FileMode.Open, FileAccess.Read, FileShare.Read) { Init(path, protocol, processTags); }
public virtual byte[] Encode(G2Protocol protocol) { return(null); }
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(); } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { // signals start of encryption if (Start) protocol.WritePacket(null, CommPacket.CryptStart, null); // padding for encrypted block else protocol.WritePacket(null, CommPacket.CryptPadding, Padding); 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 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; }
// initializing lookup network (from the settings of a loaded operation) public OpCore(DeOpsContext context) { Context = context; Sim = context.Sim; StartTime = TimeNow; GuiProtocol = new G2Protocol(); Network = new DhtNetwork(this, true); // for each core, re-load the lookup cache items Context.Cores.LockReading(() => { foreach (OpCore core in Context.Cores) core.User.Load(LoadModeType.LookupCache); }); ServiceBandwidth[DhtServiceID] = new BandwidthLog(RecordBandwidthSeconds); // get cache from all loaded cores AddService(new LookupService(this)); if (Sim != null) Sim.Internet.RegisterAddress(this); CoreThread = new Thread(RunCore); CoreThread.Name = "Lookup Thread"; if (Sim == null || Sim.Internet.TestCoreThread) CoreThread.Start(); }
// initializing operation network public OpCore(DeOpsContext context, string userPath, string pass) { Context = context; Sim = context.Sim; StartTime = TimeNow; GuiProtocol = new G2Protocol(); User = new OpUser(userPath, pass, this); User.Load(LoadModeType.Settings); Network = new DhtNetwork(this, false); TunnelID = (ushort)RndGen.Next(1, ushort.MaxValue); Test test = new Test(); // should be empty unless running a test User.Load(LoadModeType.AllCaches); // delete data dirs if frsh start indicated if (Sim != null && Sim.Internet.FreshStart) for (int service = 1; service < 20; service++ ) // 0 is temp folder, cleared on startup { string dirpath = User.RootPath + Path.DirectorySeparatorChar + "Data" + Path.DirectorySeparatorChar + service.ToString(); if (Directory.Exists(dirpath)) Directory.Delete(dirpath, true); } if (Sim != null) KeyMax = 32; Context.KnownServices[DhtServiceID] = "Dht"; ServiceBandwidth[DhtServiceID] = new BandwidthLog(RecordBandwidthSeconds); // permanent - order is important here AddService(new TransferService(this)); AddService(new LocationService(this)); AddService(new LocalSync(this)); AddService(new BuddyService(this)); AddService(new UpdateService(this)); if (!User.Settings.GlobalIM) AddService(new TrustService(this)); // optional AddService(new IMService(this)); AddService(new ChatService(this)); AddService(new ShareService(this)); if (Type.GetType("Mono.Runtime") == null) AddService(new VoiceService(this)); if (!User.Settings.GlobalIM) { AddService(new ProfileService(this)); AddService(new MailService(this)); AddService(new BoardService(this)); AddService(new PlanService(this)); AddService(new StorageService(this)); } if (Sim != null) Sim.Internet.RegisterAddress(this); CoreThread = new Thread(RunCore); CoreThread.Name = User.Settings.Operation + " Thread"; if (Sim == null || Sim.Internet.TestCoreThread) CoreThread.Start(); #if DEBUG DebugWindowsActive = true; #endif }
void Init(string path, G2Protocol protocol, ProcessTagsHandler processTags) { Seek(-8, SeekOrigin.End); byte[] sizeBytes = new byte[8]; Read(sizeBytes, 0, sizeBytes.Length); long fileSize = BitConverter.ToInt64(sizeBytes, 0); if (processTags != null) { // read public packets Seek(fileSize, SeekOrigin.Begin); PacketStream stream = new PacketStream(this, protocol, FileAccess.Read); // dont need to close packetStream processTags.Invoke(stream); } // set public size down here so reading packet stream works without mixing up true file lenght InternalSize = fileSize; // set back to the beginning of the file Seek(0, SeekOrigin.Begin); }
public static void EncryptTagFile(string source, string destination, RijndaelManaged crypt, G2Protocol protocol, ref byte[] hash, ref long size) { const int bufferSize = 1024 * 16; byte[] buffer = new byte[bufferSize]; using (IVCryptoStream stream = IVCryptoStream.Save(destination, crypt.Key, crypt.IV)) { using (FileStream localfile = File.OpenRead(source)) { int read = bufferSize; while (read == bufferSize) { read = localfile.Read(buffer, 0, bufferSize); stream.Write(buffer, 0, read); } } stream.FlushFinalBlock(); } HashTagFile(destination, protocol, ref hash, ref size); }
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 static void HashTagFile(string path, G2Protocol protocol, ref byte[] hash, ref long size) { using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.Read)) { // record size of file long originalSize = file.Length; // sha hash 128k chunks of file SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider(); int read = 0; int chunkSize = 128; // 128kb chunks int chunkBytes = chunkSize * 1024; int buffSize = file.Length > chunkBytes ? chunkBytes : (int)file.Length; byte[] chunk = new byte[buffSize]; List<byte[]> hashes = new List<byte[]>(); read = 1; while (read > 0) { read = file.Read(chunk, 0, buffSize); if (read > 0) hashes.Add(sha.ComputeHash(chunk, 0, read)); } // write packets - 200 sub-hashes per packet int writePos = 0; int hashesLeft = hashes.Count; while (hashesLeft > 0) { int writeCount = (hashesLeft > 100) ? 100 : hashesLeft; hashesLeft -= writeCount; SubHashPacket packet = new SubHashPacket(); packet.ChunkSize = chunkSize; packet.TotalCount = hashes.Count; packet.SubHashes = new byte[20 * writeCount]; for (int i = 0; i < writeCount; i++) hashes[writePos++].CopyTo(packet.SubHashes, 20 * i); byte[] encoded = packet.Encode(protocol); file.Write(encoded, 0, encoded.Length); } // write null - end packets file.WriteByte(0); // attach original size to end of file byte[] sizeBytes = BitConverter.GetBytes(originalSize); file.Write(sizeBytes, 0, sizeBytes.Length); // sha1 hash tagged file file.Seek(0, SeekOrigin.Begin); hash = sha.ComputeHash(file); size = file.Length; } }
public override byte[] Encode(G2Protocol protocol) { lock (protocol.WriteSection) { G2Frame kr = protocol.WritePacket(null, CommPacket.KeyRequest, null); if (Encryption != null) { protocol.WritePacket(kr, Packet_Encryption, UTF8Encoding.UTF8.GetBytes(Encryption)); protocol.WritePacket(kr, Packet_Key, Key); protocol.WritePacket(kr, Packet_IV, IV); } return protocol.WriteFinish(); } }
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 update = protocol.WritePacket(null, CommPacket.ProxyUpdate, null); Proxy.WritePacket(protocol, update, Packet_Proxy); return protocol.WriteFinish(); } }
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 TaggedStream(string path, G2Protocol protocol) : base(path, FileMode.Open, FileAccess.Read, FileShare.Read) { Init(path, protocol, null); }
public PacketsForm(DhtNetwork network) { // // Required for Windows Form Designer support // InitializeComponent(); Network = network; Protocol = new G2Protocol(); Text = "Packets (" + Network.GetLabel() + ")"; RefreshView(); Network.UpdatePacketLog += AsyncUpdateLog; }
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(); } }