public static IPEndPoint Parse(Stream s) { byte[] address; byte[] port = new byte[2]; switch (s.ReadByte()) { case 0: address = new byte[4]; break; case 1: address = new byte[16]; break; case -1: throw new EndOfStreamException(); default: throw new NotSupportedException("AddressFamily not supported."); } OffsetStream.StreamRead(s, address, 0, address.Length); OffsetStream.StreamRead(s, port, 0, 2); return(new IPEndPoint(new IPAddress(address), BitConverter.ToUInt16(port, 0))); }
public void WriteTest() { // Write one block using (MemoryStream memstream = new MemoryStream()) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.AreEqual(0, memstream.Position); Assert.AreEqual(this.offset, offsetstream.Position); offsetstream.Write(this.content, 0, this.content.Length); Assert.AreEqual(this.content.Length + this.offset, offsetstream.Position); Assert.AreEqual(this.content, memstream.ToArray()); } // Write single bytes using (MemoryStream memstream = new MemoryStream()) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.AreEqual(0, memstream.Position); Assert.AreEqual(this.offset, offsetstream.Position); foreach (byte b in this.content) { offsetstream.WriteByte(b); } Assert.AreEqual(this.content.Length + this.offset, offsetstream.Position); Assert.AreEqual(this.content, memstream.ToArray()); } }
public async Task DownloadLogAsync(HttpListenerRequest request, HttpListenerResponse response, string logName, long limit) { string logFileName = logName + ".log"; using (FileStream fS = new FileStream(Path.Combine(ConvertToAbsolutePath(_logFolder), logFileName), FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { response.ContentType = "text/plain"; response.AddHeader("Content-Disposition", "attachment;filename=" + logFileName); if ((limit > fS.Length) || (limit < 1)) { limit = fS.Length; } OffsetStream oFS = new OffsetStream(fS, 0, limit); using (Stream s = WebService.GetOutputStream(request, response)) { await oFS.CopyToAsync(s); if (fS.Length > limit) { byte[] buffer = Encoding.UTF8.GetBytes("####___TRUNCATED___####"); s.Write(buffer, 0, buffer.Length); } } } }
public static void DownloadLog(HttpListenerResponse response, string logFile, long limit) { using (FileStream fS = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { response.ContentType = "text/plain"; response.AddHeader("Content-Disposition", "attachment;filename=" + Path.GetFileName(logFile)); if ((limit > fS.Length) || (limit < 1)) { limit = fS.Length; } OffsetStream oFS = new OffsetStream(fS, 0, limit); using (Stream s = response.OutputStream) { oFS.CopyTo(s); if (fS.Length > limit) { byte[] buffer = System.Text.Encoding.UTF8.GetBytes("####___TRUNCATED___####"); s.Write(buffer, 0, buffer.Length); } } } }
public SecureChannelPacket(Stream s) { _code = (SecureChannelCode)s.ReadByte(); if (_code == SecureChannelCode.None) { byte[] buffer = new byte[2]; OffsetStream.StreamRead(s, buffer, 0, 2); ushort dataLen = BitConverter.ToUInt16(buffer, 0); if (dataLen > 0) { _data = new byte[dataLen]; OffsetStream.StreamRead(s, _data, 0, _data.Length); } else { _data = new byte[] { }; } } else { throw new SecureChannelException(SecureChannelCode.RemoteError, null, null, "Error packet received from remote.", new SecureChannelException(_code, null, null)); } }
/// <summary> /// Obtains a stream which can be used to read and write a cache file's meta in realtime. /// The stream will be set up such that offsets in the stream correspond to meta pointers in the cache file. /// </summary> /// <param name="cacheFile">The cache file to get a stream for.</param> /// <returns>The stream if it was opened successfully, or null otherwise.</returns> public IStream GetMetaStream(ICacheFile cacheFile) { if (string.IsNullOrEmpty(ExecutableName)) { throw new InvalidOperationException("No gameExecutable value found in Engines.xml for engine " + _buildInfo.Name + "."); } if (_buildInfo.Poking == null) { throw new InvalidOperationException("No poking definitions found in Engines.xml for engine " + _buildInfo.Name + "."); } Process gameProcess = FindGameProcess(); if (gameProcess == null) { return(null); } string version = gameProcess.MainModule.FileVersionInfo.FileVersion; long pointer = _buildInfo.Poking.RetrievePointer(version); if (pointer == -1) { throw new InvalidOperationException("Game version " + version + " does not have a pointer defined in the Formats folder."); } var gameMemory = new ProcessMemoryStream(gameProcess); var mapInfo = new H2VistaMapPointerReader(gameMemory, pointer); long metaAddress; if (cacheFile.Type != CacheFileType.Shared) { metaAddress = mapInfo.CurrentMetaAddress; // The map isn't shared, so make sure the map names match if (mapInfo.MapName != cacheFile.InternalName) { gameMemory.Close(); return(null); } } else { metaAddress = mapInfo.SharedMetaAddress; // Make sure the shared and current map pointers are different, // or that the current map is the shared map if (mapInfo.MapType != CacheFileType.Shared && mapInfo.CurrentMetaAddress == mapInfo.SharedMetaAddress) { gameMemory.Close(); return(null); } } var metaStream = new OffsetStream(gameMemory, metaAddress - cacheFile.MetaArea.BasePointer); return(new EndianStream(metaStream, BitConverter.IsLittleEndian ? Endian.LittleEndian : Endian.BigEndian)); }
public void Encrypt(Stream clearText, Stream cipherText, int bufferSize = 128 * 1024) { using (CryptoStream cW = new CryptoStream(cipherText, _symAlgo.CreateEncryptor(), CryptoStreamMode.Write)) { OffsetStream.StreamCopy(clearText, cW, bufferSize); cW.FlushFinalBlock(); } }
public async Task WriteToTcpAsync(Stream s, MemoryStream sharedBuffer) { OffsetStream sharedBufferOffset = new OffsetStream(sharedBuffer); if ((_question.Count > 0) && (_question[0].Type == DnsResourceRecordType.AXFR)) { int iQD = 0; int iAN = 0; int QDCOUNT; int ANCOUNT; List <DnsDomainOffset> domainEntries = new List <DnsDomainOffset>(1); do { sharedBuffer.SetLength(0); sharedBufferOffset.Reset(2, 12, 12); QDCOUNT = 0; ANCOUNT = 0; domainEntries.Clear(); for (; iQD < _question.Count; iQD++, QDCOUNT++) { _question[iQD].WriteTo(sharedBufferOffset, domainEntries); } for (; iAN < _answer.Count; iAN++, ANCOUNT++) { _answer[iAN].WriteTo(sharedBufferOffset, domainEntries); if (sharedBuffer.Length >= 16384) { break; } } sharedBuffer.Position = 0; WriteUInt16NetworkOrder(Convert.ToUInt16(sharedBuffer.Length - 2), sharedBuffer); WriteHeaders(sharedBuffer, QDCOUNT, ANCOUNT, 0, 0); sharedBuffer.Position = 0; await sharedBuffer.CopyToAsync(s, 512); }while (iAN < _answer.Count); } else { sharedBuffer.SetLength(0); sharedBufferOffset.Reset(2, 0, 0); WriteDatagram(sharedBufferOffset); sharedBuffer.Position = 0; WriteUInt16NetworkOrder(Convert.ToUInt16(sharedBuffer.Length - 2), sharedBuffer); sharedBuffer.Position = 0; await sharedBuffer.CopyToAsync(s, 512); } }
/// <summary> /// Geats a stream for reading from the cabinet file. For use by subclasses. /// </summary> protected internal Stream GetCabinetReadStream() { Stream stream = this.fileInfo.OpenRead(); long offset = Cabinet.FindCabinetOffset(new DuplicateStream(stream)); if (offset > 0) { stream = new OffsetStream(stream, offset); } return(stream); }
public BinaryID(Stream s) { int length = s.ReadByte(); if (length < 0) { throw new EndOfStreamException(); } _id = new byte[length]; OffsetStream.StreamRead(s, _id, 0, length); }
public void SeekTest() { using (MemoryStream memstream = new MemoryStream(this.content)) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.True(offsetstream.CanSeek); Assert.AreEqual(memstream.CanSeek, offsetstream.CanSeek); Assert.AreEqual(memstream.Position + this.offset, offsetstream.Position); long pos = offsetstream.Seek(10, SeekOrigin.Begin); Assert.AreEqual(110, pos); Assert.AreEqual(10, memstream.Position); pos = offsetstream.Seek(0, SeekOrigin.End); Assert.AreEqual(offsetstream.Length, pos); Assert.AreEqual(memstream.Length, memstream.Position); pos = offsetstream.Seek(0, SeekOrigin.Current); Assert.AreEqual(offsetstream.Length, pos); Assert.AreEqual(memstream.Length, memstream.Position); offsetstream.Seek(10, SeekOrigin.Begin); pos = offsetstream.Seek(10, SeekOrigin.Current); Assert.AreEqual(this.offset + 20, pos); Assert.AreEqual(20, memstream.Position); // negative seek pos = offsetstream.Seek(-10, SeekOrigin.Current); Assert.AreEqual(this.offset + 10, pos); Assert.AreEqual(10, memstream.Position); pos = offsetstream.Seek(-10, SeekOrigin.Current); Assert.AreEqual(this.offset, pos); Assert.AreEqual(0, memstream.Position); // seek into illegal areas try { pos = offsetstream.Seek(-10, SeekOrigin.Current); Assert.Fail(); } catch (IOException) { } Assert.AreEqual(this.offset, pos); Assert.AreEqual(0, memstream.Position); } // Using an unseekable stream should return CanSeek = false var mockstream = new Mock <Stream>(); mockstream.SetupGet(s => s.CanSeek).Returns(false); using (OffsetStream offsetstream = new OffsetStream(mockstream.Object)) { Assert.False(offsetstream.CanSeek); } }
/// <summary> /// Obtains a stream which can be used to read and write a cache file's meta in realtime. /// The stream will be set up such that offsets in the stream correspond to meta pointers in the cache file. /// </summary> /// <param name="cacheFile">The cache file to get a stream for.</param> /// <returns>The stream if it was opened successfully, or null otherwise.</returns> public IStream GetMetaStream(ICacheFile cacheFile) { if (string.IsNullOrEmpty(_buildInfo.PokingExecutable)) { throw new InvalidOperationException("No gameExecutable value found in Engines.xml for engine " + _buildInfo.Name + "."); } if (_buildInfo.Poking == null) { throw new InvalidOperationException("No poking definitions found in Engines.xml for engine " + _buildInfo.Name + "."); } Process gameProcess = FindGameProcess(); if (gameProcess == null) { return(null); } string version = gameProcess.MainModule.FileVersionInfo.FileVersion; PokingInformation info = _buildInfo.Poking.RetrieveInformation(version); if (info == null) { throw new InvalidOperationException("Game version " + version + " does not have poking information defined in the Formats folder."); } if (!info.HeaderAddress.HasValue) { throw new NotImplementedException("First Generation poking requires a HeaderAddress value."); } if (!info.MagicAddress.HasValue) { throw new NotImplementedException("First Generation poking requires a MagicAddress value."); } var gameMemory = new ProcessMemoryStream(gameProcess); var mapInfo = new FirstGenMapPointerReader(gameMemory, _buildInfo, info); long metaAddress = mapInfo.CurrentCacheAddress; if (mapInfo.MapName != cacheFile.InternalName) { gameMemory.Close(); return(null); } var metaStream = new OffsetStream(gameMemory, metaAddress - cacheFile.MetaArea.BasePointer); return(new EndianStream(metaStream, BitConverter.IsLittleEndian ? Endian.LittleEndian : Endian.BigEndian)); }
public PeerInfo(Stream s) { byte[] buffer = new byte[s.ReadByte()]; OffsetStream.StreamRead(s, buffer, 0, buffer.Length); _peerEmail = Encoding.UTF8.GetString(buffer); int count = s.ReadByte(); _peerEPList = new List <IPEndPoint>(count); for (int i = 0; i < count; i++) { _peerEPList.Add(IPEndPointParser.Parse(s)); } }
public KeyExchange(Stream s) { byte[] buffer = new byte[2]; ushort length; OffsetStream.StreamRead(s, buffer, 0, 2); length = BitConverter.ToUInt16(buffer, 0); _publicKey = new byte[length]; OffsetStream.StreamRead(s, _publicKey, 0, length); OffsetStream.StreamRead(s, buffer, 0, 2); length = BitConverter.ToUInt16(buffer, 0); _signature = new byte[length]; OffsetStream.StreamRead(s, _signature, 0, length); }
public SharedFileMetaData(Stream s) { switch (s.ReadByte()) //version { case 1: int length; byte[] buffer = new byte[255]; length = s.ReadByte(); OffsetStream.StreamRead(s, buffer, 0, length); _fileName = Encoding.UTF8.GetString(buffer, 0, length); length = s.ReadByte(); OffsetStream.StreamRead(s, buffer, 0, length); _contentType = new ContentType(Encoding.UTF8.GetString(buffer, 0, length)); OffsetStream.StreamRead(s, buffer, 0, 8); _lastModified = _epoch.AddSeconds(BitConverter.ToInt64(buffer, 0)); OffsetStream.StreamRead(s, buffer, 0, 8); _fileSize = BitConverter.ToInt64(buffer, 0); OffsetStream.StreamRead(s, buffer, 0, 4); _blockSize = BitConverter.ToInt32(buffer, 0); length = s.ReadByte(); OffsetStream.StreamRead(s, buffer, 0, length); _hashAlgo = Encoding.ASCII.GetString(buffer, 0, length); int totalBlocks = Convert.ToInt32(Math.Ceiling(Convert.ToDouble((double)_fileSize / _blockSize))); _blockHash = new byte[totalBlocks][]; int hashLength = s.ReadByte(); for (int i = 0; i < totalBlocks; i++) { _blockHash[i] = new byte[hashLength]; OffsetStream.StreamRead(s, _blockHash[i], 0, hashLength); } _fileID = ComputeFileID(); break; default: throw new BitChatException("FileMetaData format version not supported."); } }
public void ReadTest() { // Read block byte[] buffer = new byte[this.contentLength]; using (MemoryStream memstream = new MemoryStream(this.content)) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.AreEqual(0, memstream.Position); Assert.AreEqual(this.offset, offsetstream.Position); int len = offsetstream.Read(buffer, 0, buffer.Length); Assert.AreEqual(this.contentLength, len); Assert.AreEqual(this.contentLength + this.offset, offsetstream.Position); Assert.AreEqual(this.content, buffer); len = offsetstream.Read(buffer, 0, buffer.Length); Assert.AreEqual(0, len); } }
public static byte[] ReadData(Stream s) { int dataLen = Convert.ToInt32(s.Length - s.Position); if (dataLen > 0) { byte[] buffer = new byte[dataLen]; OffsetStream.StreamRead(s, buffer, 0, dataLen); return(buffer); } else { return(new byte[] { }); } }
/// <summary> /// Uploads the file. /// Resumes an upload if the given localFileStream.Position is larger than zero. /// </summary> /// <returns> /// The new CMIS document. /// </returns> /// <param name='remoteDocument'> /// Remote document where the local content should be uploaded to. /// </param> /// <param name='localFileStream'> /// Local file stream. /// </param> /// <param name='status'> /// Transmission status where the uploader should report its uploading status. /// </param> /// <param name='hashAlg'> /// Hash alg which should be used to calculate a checksum over the uploaded content. /// </param> /// <param name='overwrite'> /// If true, the local content will overwrite the existing content. /// </param> /// <exception cref="CmisSync.Lib.Tasks.UploadFailedException"> /// Contains the last successful remote document state. This is needed for continue a failed upload. /// </exception> public override IDocument UploadFile(IDocument remoteDocument, Stream localFileStream, FileTransmissionEvent status, HashAlgorithm hashAlg, bool overwrite = true) { IDocument result = remoteDocument; for (long offset = localFileStream.Position; offset < localFileStream.Length; offset += this.ChunkSize) { bool isFirstChunk = offset == 0; bool isLastChunk = (offset + this.ChunkSize) >= localFileStream.Length; using (NonClosingHashStream hashstream = new NonClosingHashStream(localFileStream, hashAlg, CryptoStreamMode.Read)) using (ChunkedStream chunkstream = new ChunkedStream(hashstream, this.ChunkSize)) using (OffsetStream offsetstream = new OffsetStream(chunkstream, offset)) using (ProgressStream progressstream = new ProgressStream(offsetstream, status)) { status.Status.Length = localFileStream.Length; status.Status.ActualPosition = offset; chunkstream.ChunkPosition = offset; ContentStream contentStream = new ContentStream(); contentStream.FileName = remoteDocument.Name; contentStream.MimeType = Cmis.MimeType.GetMIMEType(remoteDocument.Name); if (isLastChunk) { contentStream.Length = localFileStream.Length - offset; } else { contentStream.Length = this.ChunkSize; } contentStream.Stream = progressstream; try { if (isFirstChunk && result.ContentStreamId != null && overwrite) { result.DeleteContentStream(true); } result.AppendContentStream(contentStream, isLastChunk, true); } catch (Exception e) { throw new UploadFailedException(e, result); } } } hashAlg.TransformFinalBlock(new byte[0], 0, 0); return(result); }
/// <summary> /// Geats a stream for writing to the cabinet file. For use by subclasses. /// </summary> protected internal Stream GetCabinetWriteStream() { Stream stream = this.fileInfo.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite); long offset = Cabinet.FindCabinetOffset(new DuplicateStream(stream)); // If this is not a cabinet file, append the cab to it. if (offset < 0) { offset = stream.Length; } if (offset > 0) { stream = new OffsetStream(stream, offset); } return(stream); }
/// <summary> /// Obtains a stream which can be used to read and write a cache file's meta in realtime. /// The stream will be set up such that offsets in the stream correspond to meta pointers in the cache file. /// </summary> /// <param name="cacheFile">The cache file to get a stream for.</param> /// <returns>The stream if it was opened successfully, or null otherwise.</returns> public override IStream GetMetaStream(ICacheFile cacheFile = null) { if (!CheckBuildInfo()) { return(null); } Process gameProcess = FindGameProcess(); if (gameProcess == null) { return(null); } PokingInformation info = RetrieveInformation(gameProcess); if (!info.HeaderPointer.HasValue && (!info.HeaderAddress.HasValue || !info.MagicAddress.HasValue)) { throw new NotImplementedException("Poking information is missing required values."); } var gameMemory = new ProcessModuleMemoryStream(gameProcess, _buildInfo.GameModule); var mapInfo = new ThirdGenMapPointerReader(gameMemory, _buildInfo, info); long metaMagic = mapInfo.CurrentCacheAddress; if (gameMemory.BaseModule == null) { return(null); } if (mapInfo.MapName != cacheFile.InternalName) { gameMemory.Close(); return(null); } if (metaMagic == 0) { return(null); } var metaStream = new OffsetStream(gameMemory, metaMagic); return(new EndianStream(metaStream, BitConverter.IsLittleEndian ? Endian.LittleEndian : Endian.BigEndian)); }
public DiscoveryPacket(Stream s) { switch (s.ReadByte()) { case 5: //query { byte[] bufferChallenge = new byte[32]; byte[] bufferHmac = new byte[32]; OffsetStream.StreamRead(s, bufferChallenge, 0, 32); OffsetStream.StreamRead(s, bufferHmac, 0, 32); _isResponse = false; _challenge = new BinaryNumber(bufferChallenge); _hmac = new BinaryNumber(bufferHmac); } break; case 6: //response { byte[] bufferServicePort = new byte[2]; byte[] bufferChallenge = new byte[32]; byte[] bufferHmac = new byte[32]; OffsetStream.StreamRead(s, bufferServicePort, 0, 2); OffsetStream.StreamRead(s, bufferChallenge, 0, 32); OffsetStream.StreamRead(s, bufferHmac, 0, 32); _isResponse = true; _servicePort = BitConverter.ToUInt16(bufferServicePort, 0); _challenge = new BinaryNumber(bufferChallenge); _hmac = new BinaryNumber(bufferHmac); } break; case -1: throw new EndOfStreamException(); default: throw new IOException("Invalid local discovery packet."); } }
/// <summary> /// Obtains a stream which can be used to read and write a cache file's meta in realtime. /// The stream will be set up such that offsets in the stream correspond to meta pointers in the cache file. /// </summary> /// <param name="cacheFile">The cache file to get a stream for.</param> /// <returns>The stream if it was opened successfully, or null otherwise.</returns> public IStream GetMetaStream(ICacheFile cacheFile) { Process gameProcess = FindGameProcess(); if (gameProcess == null) { return(null); } var gameMemory = new ProcessMemoryStream(gameProcess); var mapInfo = new H2VistaMapPointerReader(gameMemory); long metaAddress; if (cacheFile.Type != CacheFileType.Shared) { metaAddress = mapInfo.CurrentMetaAddress; // The map isn't shared, so make sure the map names match if (mapInfo.MapName != cacheFile.InternalName) { gameMemory.Close(); return(null); } } else { metaAddress = mapInfo.SharedMetaAddress; // Make sure the shared and current map pointers are different, // or that the current map is the shared map if (mapInfo.MapType != CacheFileType.Shared && mapInfo.CurrentMetaAddress == mapInfo.SharedMetaAddress) { gameMemory.Close(); return(null); } } var metaStream = new OffsetStream(gameMemory, metaAddress - cacheFile.MetaArea.BasePointer); return(new EndianStream(metaStream, BitConverter.IsLittleEndian ? Endian.LittleEndian : Endian.BigEndian)); }
internal void FeedReadBuffer(Stream s, int timeout) { int count = Convert.ToInt32(s.Length - s.Position); int readCount = _readBuffer.Length; while (count > 0) { lock (this) { if (_disposed) { throw new ObjectDisposedException("ChannelStream"); } if (_readBufferCount > 0) { if (!Monitor.Wait(this, timeout)) { throw new IOException("Channel FeedReadBuffer timed out."); } if (_readBufferCount > 0) { throw new IOException("Channel FeedReadBuffer failed. Buffer not empty."); } } if (count < readCount) { readCount = count; } OffsetStream.StreamRead(s, _readBuffer, 0, readCount); _readBufferOffset = 0; _readBufferCount = readCount; count -= readCount; Monitor.Pulse(this); } } }
public void LengthTest() { // static length test using (MemoryStream memstream = new MemoryStream(this.content)) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.AreEqual(this.offset + this.content.Length, offsetstream.Length); } // dynamic length test using (MemoryStream memstream = new MemoryStream()) using (OffsetStream offsetstream = new OffsetStream(memstream, this.offset)) { Assert.AreEqual(0, memstream.Length); Assert.AreEqual(this.offset, offsetstream.Length); offsetstream.SetLength(200); Assert.AreEqual(200, offsetstream.Length); Assert.AreEqual(200 - this.offset, memstream.Length); Assert.Throws <ArgumentOutOfRangeException>(() => offsetstream.SetLength(50)); Assert.AreEqual(200, offsetstream.Length); Assert.AreEqual(200 - this.offset, memstream.Length); } }
private List <string> ReadFileList(Stream s, TocEntry e) { var strings = new List <string>(); using (var os = new OffsetStream(s, e.offset + 2, e.uncompressedSize - 2)) using (var ds = new DeflateStream(os, CompressionMode.Decompress)) { var bytes = new byte[e.uncompressedSize]; ds.Read(bytes, 0, (int)e.uncompressedSize); using (var ms = new MemoryStream(bytes)) using (var textReader = new StreamReader(ms)) { while (!textReader.EndOfStream) { strings.Add(textReader.ReadLine()); } } } return(strings); }
private int DownloadNextChunk(IDocument remoteDocument, long offset, long remainingBytes, FileTransmissionEvent status, Stream outputstream, HashAlgorithm hashAlg) { lock (this.disposeLock) { if (this.disposed) { status.ReportProgress(new TransmissionProgressEventArgs() { Aborted = true }); throw new ObjectDisposedException(status.Path); } IContentStream contentStream = remoteDocument.GetContentStream(remoteDocument.ContentStreamId, offset, remainingBytes); status.ReportProgress(new TransmissionProgressEventArgs { Length = remoteDocument.ContentStreamLength, ActualPosition = offset, Resumed = offset > 0 }); using (Stream remoteStream = contentStream.Stream) using (ForwardReadingStream forwardstream = new ForwardReadingStream(remoteStream)) using (OffsetStream offsetstream = new OffsetStream(forwardstream, offset)) using (ProgressStream progress = new ProgressStream(offsetstream, status)) { byte[] buffer = new byte[8 * 1024]; int result = 0; int len; while ((len = progress.Read(buffer, 0, buffer.Length)) > 0) { outputstream.Write(buffer, 0, len); hashAlg.TransformBlock(buffer, 0, len, buffer, 0); result += len; outputstream.Flush(); } return(result); } } }
/// <summary> /// Writes your PKG to the given stream. /// Assumes exclusive use of the stream (writes are absolute, relative to 0) /// </summary> /// <param name="s"></param> /// <returns>Completed Pkg structure</returns> public Pkg Write(Stream s) { var pkg = BuildPkg(); var writer = new PkgWriter(s); // Write PFS first, to get stream length s.Position = (long)pkg.Header.pfs_image_offset; var pfsStream = new OffsetStream(s, s.Position); new PFS.PfsBuilder().BuildPfs(new PFS.PfsProperties { BlockSize = 65536, output = pfsStream, proj = project, projDir = projectDir, }); var align = s.Length % 65536; if (align != 0) { s.SetLength(s.Length + 65536 - align); } // TODO: Encrypt PFS (could also be done while writing image) // TODO: Generate hashes in Entries (body) // TODO: Calculate keys in entries (image key, etc) // Write body now because it will make calculating hashes easier. writer.WriteBody(pkg); CalcHeaderHashes(pkg, s); // Update header sizes now that we know how big things are... UpdateHeaderInfo(pkg, s.Length, pfsStream.Length); // Now write header s.Position = 0; writer.WritePkg(pkg); return(pkg); }
public void ResumeTest() { byte[] inputContent = new byte[100]; long offset = 100; using (Stream stream = new MemoryStream(inputContent)) using (OffsetStream offsetstream = new OffsetStream(stream, offset)) { FileTransmissionEvent transmissionEvent = new FileTransmissionEvent(this.transmissionType, this.filename); transmissionEvent.TransmissionStatus += delegate(object sender, TransmissionProgressEventArgs args) { if (args.ActualPosition != null && args.Percent != null) { this.position = (long)args.ActualPosition; this.percent = (double)args.Percent; } }; using (ProgressStream progress = new ProgressStream(offsetstream, transmissionEvent)) { progress.Seek(0, SeekOrigin.Begin); Assert.AreEqual(offset, this.position); Assert.AreEqual(50, this.percent); progress.Seek(10, SeekOrigin.Current); Assert.AreEqual(offset + 10, this.position); progress.Seek(0, SeekOrigin.End); Assert.AreEqual(100, this.percent); Assert.AreEqual(offset + inputContent.Length, this.position); progress.Seek(0, SeekOrigin.Begin); progress.WriteByte(0); Assert.AreEqual(offset + 1, this.position); Assert.AreEqual(50.5, this.percent); progress.WriteByte(0); Assert.AreEqual(offset + 2, this.position); Assert.AreEqual(51, this.percent); progress.Write(new byte[10], 0, 10); Assert.AreEqual(56, this.percent); } } }
public override Stream OpenArchiveWriteStream(int archiveNumber, string archiveName, bool truncate, CompressionEngine compressionEngine) { if (string.IsNullOrEmpty(archiveName)) { throw new ArgumentNullException("archiveName"); } string path = Path.Combine(Path.GetDirectoryName(ArchiveFiles[0]), archiveName); if (truncate) { if (!DictionaryStringMemoryStream.ContainsKey(path)) { DictionaryStringMemoryStream[path] = new MemoryStream(); } } Stream stream = DictionaryStringMemoryStream[path]; if (EnableOffsetOpen) { long num = compressionEngine.FindArchiveOffset(new DuplicateStream(stream)); if (num < 0L) { num = stream.Length; } if (num > 0L) { stream = new OffsetStream(stream, num); } stream.Seek(0L, SeekOrigin.Begin); } if (truncate) { stream.SetLength(0L); } return(stream); }
public override Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine) { if (archiveNumber >= ArchiveFiles.Count) { return(null); } string path = ArchiveFiles[archiveNumber]; Stream stream = DictionaryStringMemoryStream[path]; if (EnableOffsetOpen) { long num = compressionEngine.FindArchiveOffset(new DuplicateStream(stream)); if (num > 0L) { stream = new OffsetStream(stream, num); } else { stream.Seek(0L, SeekOrigin.Begin); } } return(stream); }
public static Extractor FromFile([NotNull] string path, [NotNull] string target, [CanBeNull] string mimeType = null, long startOffset = 0) { if (string.IsNullOrEmpty(mimeType)) mimeType = Archive.GuessMimeType(path); // MSI Extractor does not support Stream-based access if (mimeType == Archive.MimeTypeMsi) return new MsiExtractor(path, target); Stream stream = File.OpenRead(path); if (startOffset != 0) stream = new OffsetStream(stream, startOffset); try { return FromStream(stream, target, mimeType); } catch { stream.Dispose(); throw; } }