public TransferPartial(OpTransfer transfer) { Created = transfer.Created; Details = transfer.Details; Target = transfer.Target; BitCount = transfer.LocalBitfield.Length; Bitfield = transfer.LocalBitfield; InternalSize = transfer.InternalSize; ChunkSize = transfer.ChunkSize; }
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 FileDetails Decode(byte[] data) { G2Header root = new G2Header(data); if (!G2Protocol.ReadPacket(root)) { return(null); } if (root.Name != TransferPacket.Params) { return(null); } return(FileDetails.Decode(root)); }
public static TransferPartial Decode(G2Header root) { TransferPartial partial = new TransferPartial(); G2Header child = new G2Header(root.Data); while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD) { if (!G2Protocol.ReadPayload(child)) { continue; } switch (child.Name) { case Packet_Created: partial.Created = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos)); break; case Packet_Details: partial.Details = FileDetails.Decode(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize)); break; case Packet_Target: partial.Target = BitConverter.ToUInt64(child.Data, child.PayloadPos); break; case Packet_BitCount: partial.BitCount = CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Bitfield: partial.Bitfield = Utilities.ToBitArray(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize), partial.BitCount); break; case Packet_InternalSize: partial.InternalSize = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_ChunkSize: partial.ChunkSize = CompactNum.ToInt32(child.Data, child.PayloadPos, child.PayloadSize); break; } } return(partial); }
public override bool Equals(object obj) { FileDetails compare = obj as FileDetails; if (obj == null) { return(false); } if (compare.Service == Service && compare.DataType == DataType && Utilities.MemCompare(compare.Hash, Hash) && compare.Size == Size && Utilities.MemCompare(compare.Extra, Extra)) { return(true); } return(false); }
public static FileDetails Decode(G2Header root) { FileDetails packet = new FileDetails(); 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: packet.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_DataType: packet.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Hash: packet.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Size: packet.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Extra: packet.Extra = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize); break; } } return(packet); }
public static FileDetails Decode(G2Header root) { FileDetails packet = new FileDetails(); 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: packet.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_DataType: packet.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Hash: packet.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Size: packet.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize); break; case Packet_Extra: packet.Extra = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize); break; } } return packet; }
public TransferPartial(OpTransfer transfer) { Created = transfer.Created; Details = transfer.Details; Target = transfer.Target; BitCount = transfer.LocalBitfield.Length; Bitfield = transfer.LocalBitfield; InternalSize = transfer.InternalSize; ChunkSize = transfer.ChunkSize; }
string Transfers_PublicRequest(ulong key, FileDetails details) { ShareCollection collection; if (!Collections.SafeTryGetValue(key, out collection)) return null; if (collection.Size != details.Size || !Utilities.MemCompare(collection.Hash, details.Hash)) return null; return GetPublicPath(collection); }
bool Transfers_FileSearch(ulong key, FileDetails details) { if (details.Extra == null || details.Extra.Length < 8) return false; OpPost post = GetPost(key, PostUID.FromBytes(details.Extra, 0)); if (post != null && details.Size == post.Header.FileSize && Utilities.MemCompare(details.Hash, post.Header.FileHash)) return true; return false; }
void DownloadPost(SignedData signed, PostHeader header) { if (!Utilities.CheckSignedData(header.Source, signed.Data, signed.Signature)) return; FileDetails details = new FileDetails(ServiceID, 0, header.FileHash, header.FileSize, new PostUID(header).ToBytes()); Core.Transfers.StartDownload(header.TargetID, details, GetPostPath(header), new EndDownloadHandler(EndDownload), new object[] { signed, header }); }
public void DownloadFile(ulong id, StorageFile file) { // called from hash thread if (Core.InvokeRequired) { Core.RunInCoreAsync(delegate() { DownloadFile(id, file); }); return; } // if file still processing return if (file.Hash == null) return; FileDetails details = new FileDetails(ServiceID, FileTypeData, file.Hash, file.Size, null); Core.Transfers.StartDownload(id, details, GetFilePath(file.HashID), new EndDownloadHandler(EndDownloadFile), new object[] { file }); }
string Transfers_FileRequest(ulong key, FileDetails details) { if (details.Extra == null || details.Extra.Length < 8) return null; OpPost post = GetPost(key, PostUID.FromBytes(details.Extra, 0)); if (post != null && details.Size == post.Header.FileSize && Utilities.MemCompare(details.Hash, post.Header.FileHash)) return GetPostPath(post.Header); return null; }
string Transfers_FileRequest(ulong key, FileDetails details) { OpVersionedFile vfile = GetFile(key); if (vfile != null) if (details.Size == vfile.Header.FileSize && Utilities.MemCompare(details.Hash, vfile.Header.FileHash)) return GetFilePath(vfile.Header); return null; }
private void ReceivePublicDetails(RudpSession session, ShareCollection file) { ShareCollection collection; if (!Collections.SafeTryGetValue(session.UserID, out collection)) return; collection.Key = file.Key; collection.Size = file.Size; collection.Hash = file.Hash; foreach (DhtClient done in collection.ToRequest.Where(t => t.ClientID == session.ClientID).ToArray()) collection.ToRequest.Remove(done); FileDetails details = new FileDetails(ServiceID, DataTypePublic, file.Hash, file.Size, null); object[] args = new object[] { collection, (object) session.ClientID }; DhtClient client = new DhtClient(session.UserID, session.ClientID); OpTransfer transfer = Core.Transfers.StartDownload(client.UserID, details, GetPublicPath(collection), new EndDownloadHandler(CollectionDownloadFinished), args); transfer.AddPeer(client); transfer.DoSearch = false; collection.Status = "Starting List Download"; }
bool Transfers_FileSearch(ulong key, FileDetails details) { UpdateInfo signed = Core.Context.SignedUpdate; return (signed != null && signed.Loaded && signed.Size == details.Size && Utilities.MemCompare(signed.Hash, details.Hash)); }
private void StartDownload(ulong target) { FileDetails details = new FileDetails(ServiceID, 0, Core.Context.SignedUpdate.Hash, Core.Context.SignedUpdate.Size, null); Core.Transfers.StartDownload(target, details, LookupConfig.UpdatePath, new EndDownloadHandler(DownloadFinished), null); }
bool Transfers_FileSearch(ulong key, FileDetails details) { bool found = false; Local.Files.LockReading(() => { if (Local.Files.Any(f => f.Size == details.Size && Utilities.MemCompare(f.Hash, details.Hash))) found = true; }); return found; }
string Transfers_FileRequest(ulong key, FileDetails details) { SharedFile share = null; Local.Files.LockReading(() => { share = Local.Files.Where(f => f.Size == details.Size && Utilities.MemCompare(f.Hash, details.Hash)).FirstOrDefault(); }); if (share != null && share.Completed) return GetFilePath(share); return null; }
private OpTransfer StartTransfer(DhtClient client, SharedFile file) { FileDetails details = new FileDetails(ServiceID, DataTypeShare, file.Hash, file.Size, null); object[] args = new object[] { file }; OpTransfer transfer = Core.Transfers.StartDownload(client.UserID, details, GetFilePath(file), new EndDownloadHandler(FileDownloadFinished), args); transfer.AddPeer(client); file.TransferStatus = "Starting download from " + Core.GetName(client.UserID); return transfer; }
string Transfers_FileRequest(ulong key, FileDetails details) { UpdateInfo signed = Core.Context.SignedUpdate; if (signed != null && signed.Loaded && signed.Size == details.Size && Utilities.MemCompare(signed.Hash, details.Hash)) { string sharePath = Core.User.TempPath + Path.DirectorySeparatorChar + signed.TempName; // cannot share from deops root directory because when new update.dat is downloaded the old one // cant be replaced if it is locked up by the transfer service if (!File.Exists(sharePath)) File.Copy(LookupConfig.UpdatePath, sharePath, true); return sharePath; } return null; }
bool Transfers_PublicSearch(ulong key, FileDetails details) { // shouldnt be called, transfer starts directly Debug.Assert(false); return false; }
private void Download(SignedData signed, VersionedFileHeader header) { if (!Utilities.CheckSignedData(header.Key, signed.Data, signed.Signature)) { Debug.Assert(false); return; } FileDetails details = new FileDetails(Service, DataType, header.FileHash, header.FileSize, null); Core.Transfers.StartDownload(header.KeyID, details, GetFilePath(header), new EndDownloadHandler(EndDownload), new object[] { signed, header } ); }
string Transfers_DataFileRequest(ulong key, FileDetails details) { ulong hashID = BitConverter.ToUInt64(details.Hash, 0); OpFile file = null; if (FileMap.SafeTryGetValue(hashID, out file)) if (details.Size == file.Size && Utilities.MemCompare(details.Hash, file.Hash)) return GetFilePath(hashID); return null; }
bool Transfers_FileSearch(ulong key, FileDetails details) { OpVersionedFile vfile = GetFile(key); if (vfile != null) if (details.Size == vfile.Header.FileSize && Utilities.MemCompare(details.Hash, vfile.Header.FileHash)) return true; return false; }
bool Transfers_DataFileSearch(ulong key, FileDetails details) { ulong hashID = BitConverter.ToUInt64(details.Hash, 0); OpFile file = null; if (FileMap.SafeTryGetValue(hashID, out file)) if (details.Size == file.Size && Utilities.MemCompare(details.Hash, file.Hash)) return true; return false; }