private void CompressString(string str)
        {
            MemoryStream memoryStream = new MemoryStream();
            CompressionMethod method = (CompressionMethod)Enum.Parse(typeof(CompressionMethod), CompressionMethods.SelectedValue.ToString(), false);
            CompressionSettings settins = null;
            switch (method)
            {
                case CompressionMethod.Stored:
                    settins = new StoreSettings();
                    break;
                case CompressionMethod.Deflate:
                    settins = new DeflateSettings();
                    break;
                case CompressionMethod.Lzma:
                    settins = new LzmaSettings();
                    break;
            }

            CompressedStream zipOutputStream = new CompressedStream(memoryStream, StreamOperationMode.Write, settins);
            StreamWriter writer = new StreamWriter(zipOutputStream);
            writer.Write(str);
            writer.Flush();

            CompressedText.Text = Convert.ToBase64String(memoryStream.ToArray());
        }
예제 #2
0
        public ImapReplayCommand(Encoding encoding, string command, byte[] response, bool compressed = false)
        {
            CommandBuffer = encoding.GetBytes(command);
            Compressed    = compressed;
            Response      = response;
            Encoding      = encoding;
            Command       = command;

            if (compressed)
            {
                using (var memory = new MemoryStream()) {
                    using (var compress = new CompressedStream(memory)) {
                        compress.Write(CommandBuffer, 0, CommandBuffer.Length);
                        compress.Flush();

                        CommandBuffer = memory.ToArray();
                    }
                }
            }
        }
예제 #3
0
        public static bool Compress(Stream sourceStream, Stream destinationStream)
        {
            sourceStream.Position      = 0;
            destinationStream.Position = 0;

            using (CompressedStream compStream = new CompressedStream(destinationStream, CompressionMethod.Deflated, CompressionLevel.Highest))
            {
                compStream.Transient = true;

                byte[] buffer = new byte[32768];

                int bytesRead = 0;

                while ((bytesRead = sourceStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    compStream.Write(buffer, 0, bytesRead);
                }
            }

            return(true);
        }
예제 #4
0
        public void TestReadWrite()
        {
            using (var stream = new CompressedStream(new DummyNetworkStream())) {
                string    command          = "A00000001 APPEND INBOX (\\Seen \\Draft) {4096+}\r\nFrom: Sample Sender <*****@*****.**>\r\nTo: Sample Recipient <*****@*****.**>\r\nSubject: This is a test message...\r\nDate: Mon, 22 Oct 2018 18:22:56 EDT\r\nMessage-Id: <*****@*****.**>\r\n\r\nTesting... 1. 2. 3.\r\nTesting.\r\nOver and out.\r\n";
                var       output           = Encoding.ASCII.GetBytes(command);
                const int compressedLength = 221;
                var       buffer           = new byte[1024];
                int       n;

                stream.Write(output, 0, output.Length);
                stream.Flush();

                Assert.AreEqual(compressedLength, stream.BaseStream.Position, "Compressed output length");

                stream.BaseStream.Position = 0;

                n = stream.Read(buffer, 0, buffer.Length);
                Assert.AreEqual(output.Length, n, "Decompressed input length");

                var text = Encoding.ASCII.GetString(buffer, 0, n);
                Assert.AreEqual(command, text);
            }
        }
예제 #5
0
        public void TestArgumentExceptions()
        {
            using (var stream = new CompressedStream(new DummyNetworkStream())) {
                var buffer = new byte[16];

                Assert.Throws <ArgumentNullException> (() => stream.Read(null, 0, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (() => stream.Read(buffer, -1, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (() => stream.Read(buffer, 0, -1));
                Assert.AreEqual(0, stream.Read(buffer, 0, 0));

                Assert.Throws <ArgumentNullException> (async() => await stream.ReadAsync(null, 0, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (async() => await stream.ReadAsync(buffer, -1, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (async() => await stream.ReadAsync(buffer, 0, -1));

                Assert.Throws <ArgumentNullException> (() => stream.Write(null, 0, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (() => stream.Write(buffer, -1, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (() => stream.Write(buffer, 0, -1));
                stream.Write(buffer, 0, 0);

                Assert.Throws <ArgumentNullException> (async() => await stream.WriteAsync(null, 0, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (async() => await stream.WriteAsync(buffer, -1, buffer.Length));
                Assert.Throws <ArgumentOutOfRangeException> (async() => await stream.WriteAsync(buffer, 0, -1));
            }
        }
예제 #6
0
        private void Decrypt(object obj)
        {
            try
            {
                using (Stream sourceStream = new MemoryStream())
                {
                    sourceStream.Write(this.bytes, 0, this.bytes.Length);
                    sourceStream.Seek(0, SeekOrigin.Begin);

                    DefaultEncryptionSettings encryptionSettings = new DefaultEncryptionSettings();
                    encryptionSettings.Password = this.DecryptionPassword ?? string.Empty;

                    using (CompressedStream compressedStream = new CompressedStream(sourceStream, StreamOperationMode.Read, new DeflateSettings(), false, encryptionSettings))
                    {
                        StreamReader reader = new StreamReader(compressedStream);
                        this.Output = reader.ReadToEnd();
                    }
                }
            }
            catch
            {
                this.Output = "Can not decompress with this password";
            }
        }
예제 #7
0
        private void WriteHeader(System.IO.Stream s, byte[] bytes)
        {
            // write the header info

            int i = 0;

            // signature
            bytes[i++] = (byte)(ZipEntrySignature & 0x000000FF);
            bytes[i++] = (byte)((ZipEntrySignature & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((ZipEntrySignature & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((ZipEntrySignature & 0xFF000000) >> 24);

            // version needed
            Int16 FixedVersionNeeded = 0x14; // from examining existing zip files

            bytes[i++] = (byte)(FixedVersionNeeded & 0x00FF);
            bytes[i++] = (byte)((FixedVersionNeeded & 0xFF00) >> 8);

            // bitfield
            Int16 BitField = 0x00; // from examining existing zip files

            bytes[i++] = (byte)(BitField & 0x00FF);
            bytes[i++] = (byte)((BitField & 0xFF00) >> 8);

            // compression method
            Int16 CompressionMethod = 0x08; // 0x08 = Deflate

            bytes[i++] = (byte)(CompressionMethod & 0x00FF);
            bytes[i++] = (byte)((CompressionMethod & 0xFF00) >> 8);

            // LastMod
            bytes[i++] = (byte)(_LastModDateTime & 0x000000FF);
            bytes[i++] = (byte)((_LastModDateTime & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_LastModDateTime & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_LastModDateTime & 0xFF000000) >> 24);

            // CRC32 (Int32)
            CRC32  crc32 = new CRC32();
            UInt32 crc   = 0;

            using (System.IO.Stream input = System.IO.File.OpenRead(FileName))
            {
                crc = crc32.GetCrc32AndCopy(input, CompressedStream);
            }
            CompressedStream.Close();  // to get the footer bytes written to the underlying stream

            bytes[i++] = (byte)(crc & 0x000000FF);
            bytes[i++] = (byte)((crc & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((crc & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((crc & 0xFF000000) >> 24);

            // CompressedSize (Int32)
            Int32  isz = (Int32)_UnderlyingMemoryStream.Length;
            UInt32 sz  = (UInt32)isz;

            bytes[i++] = (byte)(sz & 0x000000FF);
            bytes[i++] = (byte)((sz & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((sz & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((sz & 0xFF000000) >> 24);

            // UncompressedSize (Int32)
            if (_Debug)
            {
                System.Console.WriteLine("Uncompressed Size: {0}", crc32.TotalBytesRead);
            }
            bytes[i++] = (byte)(crc32.TotalBytesRead & 0x000000FF);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0xFF000000) >> 24);

            string internalFileName = IncludeDirectoryTree ? FileName : Path.GetFileName(FileName);

            // filename length (Int16)
            Int16 length = (Int16)internalFileName.Length;

            // see note below about TrimVolumeFromFullyQualifiedPaths.
            if ((TrimVolumeFromFullyQualifiedPaths) && (internalFileName[1] == ':') && (internalFileName[2] == '\\'))
            {
                length -= 3;
            }
            bytes[i++] = (byte)(length & 0x00FF);
            bytes[i++] = (byte)((length & 0xFF00) >> 8);

            // extra field length (short)
            Int16 ExtraFieldLength = 0x00;

            bytes[i++] = (byte)(ExtraFieldLength & 0x00FF);
            bytes[i++] = (byte)((ExtraFieldLength & 0xFF00) >> 8);

            // Tue, 27 Mar 2007  16:35

            // Creating a zip that contains entries with "fully qualified" pathnames
            // can result in a zip archive that is unreadable by Windows Explorer.
            // Such archives are valid according to other tools but not to explorer.
            // To avoid this, we can trim off the leading volume name and slash (eg
            // c:\) when creating (writing) a zip file.  We do this by default and we
            // leave the old behavior available with the
            // TrimVolumeFromFullyQualifiedPaths flag - set it to false to get the old
            // behavior.  It only affects zip creation.

            // actual filename
            char[] c = ((TrimVolumeFromFullyQualifiedPaths) && (internalFileName[1] == ':') && (internalFileName[2] == '\\')) ?
                       internalFileName.Substring(3).ToCharArray() : // trim off volume letter, colon, and slash
                       internalFileName.ToCharArray();


            int j = 0;

            if (_Debug)
            {
                System.Console.WriteLine("local header: writing filename, {0} chars", c.Length);
                System.Console.WriteLine("starting offset={0}", i);
            }
            for (j = 0; (j < c.Length) && (i + j < bytes.Length); j++)
            {
                bytes[i + j] = System.BitConverter.GetBytes(c[j])[0];
                if (_Debug)
                {
                    System.Console.Write(" {0:X2}", bytes[i + j]);
                }
            }
            if (_Debug)
            {
                System.Console.WriteLine();
            }

            i += j;

            // extra field (we always write nothing in this implementation)
            // ;;

            // remember the file offset of this header
            _RelativeOffsetOfHeader = (int)s.Length;


            if (_Debug)
            {
                System.Console.WriteLine("\nAll header data:");
                for (j = 0; j < i; j++)
                {
                    System.Console.Write(" {0:X2}", bytes[j]);
                }
                System.Console.WriteLine();
            }
            // finally, write the header to the stream
            s.Write(bytes, 0, i);

            // preserve this header data for use with the central directory structure.
            _header = new byte[i];
            if (_Debug)
            {
                System.Console.WriteLine("preserving header of {0} bytes", _header.Length);
            }
            for (j = 0; j < i; j++)
            {
                _header[j] = bytes[j];
            }
        }
예제 #8
0
        private static void DecoratorSection()
        {
            var stream = new CompressedStream(new EncryptedStream(new CloudStream()));

            stream.Write("1234-1234-1234-1234");
        }
예제 #9
0
            public override void Read(CPlugEntRecordData n, GameBoxReader r, GameBoxWriter unknownW)
            {
                Version          = r.ReadInt32();
                UncompressedSize = r.ReadInt32();
                CompressedSize   = r.ReadInt32();
                Data             = r.ReadBytes(CompressedSize);

                // ... WIP ...

                Task.Run(() =>
                {
                    using (var ms = new MemoryStream(Data))
                        using (var cs = new CompressedStream(ms, System.IO.Compression.CompressionMode.Decompress))
                            using (var gbxr = new GameBoxReader(cs))
                            {
                                var u01        = gbxr.ReadInt32();
                                var numSamples = gbxr.ReadInt32();
                                var objects    = gbxr.ReadArray <object>(i =>
                                {
                                    var nodeId = gbxr.ReadUInt32();
                                    Names.TryGetValue(nodeId, out string nodeName);

                                    return(new
                                    {
                                        id = nodeId,
                                        name = nodeName,
                                        rest = gbxr.ReadArray <int>(5)
                                    });
                                });

                                if (Version >= 2)
                                {
                                    var objcts2 = gbxr.ReadArray <object>(i =>
                                    {
                                        var u02 = gbxr.ReadInt32();
                                        var u03 = gbxr.ReadInt32();

                                        uint?clas       = null;
                                        string clasName = null;
                                        if (Version >= 4)
                                        {
                                            clas = gbxr.ReadUInt32();
                                            Names.TryGetValue(clas.Value, out clasName);
                                        }

                                        return(new object[]
                                        {
                                            u02,
                                            u03,
                                            clas,
                                            clasName
                                        });
                                    });
                                }

                                var u04 = gbxr.ReadByte();
                                var u05 = gbxr.ReadArray <int>(4);

                                if (Version >= 6)
                                {
                                    //var u06 = gbxr.ReadUInt32();
                                }

                                var u07 = gbxr.ReadByte();
                                var u08 = gbxr.ReadByte();
                                if (Version >= 2)
                                {
                                    var u09 = gbxr.ReadByte();
                                    var u10 = gbxr.ReadArray <int>(3);
                                    var u11 = gbxr.ReadByte();

                                    if (Version >= 3)
                                    {
                                        var u12 = gbxr.ReadByte();

                                        if (Version == 7)
                                        {
                                        }

                                        if (Version >= 8)
                                        {
                                            var u13 = gbxr.ReadInt32();
                                        }
                                    }
                                }

                                var u14 = gbxr.ReadArray <int>(5);
                            }
                });
            }
예제 #10
0
        internal async Task ListenAsync()
        {
            await Task.Yield();

            var buff    = new byte[BUFFER_SIZE];
            var buffseg = new ArraySegment <byte>(buff);

            byte[] resultbuff             = null;
            WebSocketReceiveResult result = null;
            SocketCloseEventArgs   close  = null;

            var token = Token;

            try
            {
                while (!token.IsCancellationRequested && Socket.State == WebSocketState.Open)
                {
                    using (var ms = new MemoryStream())
                    {
                        do
                        {
                            result = await Socket.ReceiveAsync(buffseg, token).ConfigureAwait(false);

                            if (result.MessageType == WebSocketMessageType.Close)
                            {
                                var cc = result.CloseStatus != null ? (int)result.CloseStatus.Value : -1;
                                close = new SocketCloseEventArgs(null)
                                {
                                    CloseCode = cc, CloseMessage = result.CloseStatusDescription
                                };
                            }
                            else
                            {
                                ms.Write(buff, 0, result.Count);
                            }
                        }while (!result.EndOfMessage);

                        resultbuff = ms.ToArray();
                    }

                    if (close != null)
                    {
                        break;
                    }

                    var resultstr = "";
                    if (result.MessageType == WebSocketMessageType.Binary)
                    {
                        if (resultbuff[0] == 0x78)
                        {
                            await CompressedStream.WriteAsync(resultbuff, 2, resultbuff.Length - 2).ConfigureAwait(false);
                        }
                        else
                        {
                            await CompressedStream.WriteAsync(resultbuff, 0, resultbuff.Length).ConfigureAwait(false);
                        }

                        await CompressedStream.FlushAsync().ConfigureAwait(false);

                        CompressedStream.Position = 0;

                        // partial credit to FiniteReality
                        // overall idea is their
                        // I tuned the finer details
                        // -Emzi
                        var sfix = BitConverter.ToUInt16(resultbuff, resultbuff.Length - 2);
                        if (sfix != ZLIB_STREAM_SUFFIX)
                        {
                            using (var zlib = new DeflateStream(CompressedStream, CompressionMode.Decompress, true))
                            {
                                await zlib.CopyToAsync(DecompressedStream).ConfigureAwait(false);
                            }
                        }
                        else
                        {
                            await StreamDecompressor.CopyToAsync(DecompressedStream).ConfigureAwait(false);
                        }

                        resultbuff = DecompressedStream.ToArray();
                        DecompressedStream.Position = 0;
                        DecompressedStream.SetLength(0);
                        CompressedStream.Position = 0;
                        CompressedStream.SetLength(0);
                    }

                    resultstr = UTF8.GetString(resultbuff, 0, resultbuff.Length);
                    await CallOnMessageAsync(resultstr).ConfigureAwait(false);
                }
            }
            catch (Exception e)
            {
                close = new SocketCloseEventArgs(null)
                {
                    CloseCode = -1, CloseMessage = e.Message
                };
            }

            await DisconnectAsync(close).ConfigureAwait(false);
        }
예제 #11
0
        private void WritePartition(string Name, string FilePath, Action <int, TimeSpan?> ProgressUpdateCallback, ProgressUpdater UpdaterPerSector, bool Compress = false)
        {
            Partition Target = GPT.Partitions.Find(p => string.Equals(p.Name, Name, StringComparison.CurrentCultureIgnoreCase));

            if (Target == null)
            {
                throw new ArgumentOutOfRangeException();
            }

            int FirstChunk = GetChunkIndexFromSectorIndex((int)Target.FirstSector);
            int LastChunk  = GetChunkIndexFromSectorIndex((int)Target.LastSector);

            ProgressUpdater Updater = UpdaterPerSector;

            if ((Updater == null) && (ProgressUpdateCallback != null))
            {
                Updater = new ProgressUpdater(Target.LastSector - Target.FirstSector + 1, ProgressUpdateCallback);
            }

            byte[] Buffer = new byte[ChunkSize];

            OpenFile();

            FileStream OutputFile = new(FilePath, FileMode.Create, FileAccess.Write);
            Stream     OutStream  = OutputFile;

            // We use gzip compression
            //
            // LZMA is about 60 times slower (compression is twice as good, but compressed size is already really small, so it doesnt matter much)
            // OutStream = new LZMACompressionStream(OutputFile, System.IO.Compression.CompressionMode.Compress, false);
            //
            // DeflateStream is a raw compression stream without recognizable header
            // Deflate has almost no performance penalty
            // OutStream = new DeflateStream(OutputFile, CompressionLevel.Optimal, false);
            //
            // GZip can be recognized. It always starts with 1F 8B 08 (1F 8B is the magic value, 08 is the Deflate compression method)
            // With GZip compression, dump time goes from 1m to 1m37s. So that doesnt matter much.
            if (Compress)
            {
                OutStream = new CompressedStream(OutputFile, (Target.LastSector - Target.FirstSector + 1) * 0x200);
            }

            for (int j = FirstChunk; j <= LastChunk; j++)
            {
                GetChunk(Buffer, j);

                int FirstSector = 0;
                int LastSector  = (ChunkSize / 0x200) - 1;

                if (j == FirstChunk)
                {
                    FirstSector = GetSectorNumberInChunkFromSectorIndex((int)Target.FirstSector);
                }

                if (j == LastChunk)
                {
                    LastSector = GetSectorNumberInChunkFromSectorIndex((int)Target.LastSector);
                }

                int Offset = FirstSector * 0x200;
                int Size   = (LastSector - FirstSector + 1) * 0x200;

                OutStream.Write(Buffer, Offset, Size);

                Updater?.IncreaseProgress((UInt64)(ChunkSize / 0x200));
            }

            OutStream.Close();

            CloseFile();
        }
        /// <summary>
        /// Connects to the WebSocket server.
        /// </summary>
        /// <param name="uri">The URI of the WebSocket server.</param>
        /// <param name="customHeaders">Custom headers to send with the request.</param>
        /// <returns></returns>
        public override Task ConnectAsync(Uri uri, IReadOnlyDictionary <string, string> customHeaders = null)
        {
            StreamDecompressor?.Dispose();
            CompressedStream?.Dispose();
            DecompressedStream?.Dispose();

            DecompressedStream = new MemoryStream();
            CompressedStream   = new MemoryStream();
            StreamDecompressor = new DeflateStream(CompressedStream, CompressionMode.Decompress);

            _socket = new ws4net.WebSocket(uri.ToString(), customHeaderItems: customHeaders?.ToList());
            if (Proxy != null) // f**k this, I ain't working with that shit
            {
                throw new NotImplementedException("Proxies are not supported on non-Microsoft WebSocket client implementations.");
            }

            _socket.Opened          += HandlerOpen;
            _socket.Closed          += HandlerClose;
            _socket.MessageReceived += HandlerMessage;
            _socket.DataReceived    += HandlerData;
            _socket.Error           += _socket_Error;
            _socket.Open();

            return(Task.FromResult <BaseWebSocketClient>(this));

            void HandlerOpen(object sender, s.EventArgs e)
            => _connect.InvokeAsync().ConfigureAwait(false).GetAwaiter().GetResult();

            void HandlerClose(object sender, s.EventArgs e)
            {
                if (e is ws4net.ClosedEventArgs ea)
                {
                    _disconnect.InvokeAsync(new SocketCloseEventArgs(null)
                    {
                        CloseCode = ea.Code, CloseMessage = ea.Reason
                    }).ConfigureAwait(false).GetAwaiter().GetResult();
                }
                else
                {
                    _disconnect.InvokeAsync(new SocketCloseEventArgs(null)
                    {
                        CloseCode = -1, CloseMessage = "unknown"
                    }).ConfigureAwait(false).GetAwaiter().GetResult();
                }
            }

            void HandlerMessage(object sender, ws4net.MessageReceivedEventArgs e)
            {
                _message.InvokeAsync(new SocketMessageEventArgs {
                    Message = e.Message
                }).ConfigureAwait(false).GetAwaiter().GetResult();
            }

            void HandlerData(object sender, ws4net.DataReceivedEventArgs e)
            {
                string msg;

                if (e.Data[0] == 0x78)
                {
                    CompressedStream.Write(e.Data, 2, e.Data.Length - 2);
                }
                else
                {
                    CompressedStream.Write(e.Data, 0, e.Data.Length);
                }
                CompressedStream.Flush();
                CompressedStream.Position = 0;

                // partial credit to FiniteReality
                // overall idea is his
                // I tuned the finer details
                // -Emzi
                var sfix = BitConverter.ToUInt16(e.Data, e.Data.Length - 2);

                if (sfix != ZLIB_STREAM_SUFFIX)
                {
                    using (var zlib = new DeflateStream(CompressedStream, CompressionMode.Decompress, true))
                        zlib.CopyTo(DecompressedStream);
                }
                else
                {
                    StreamDecompressor.CopyTo(DecompressedStream);
                }

                msg = UTF8.GetString(DecompressedStream.ToArray(), 0, (int)DecompressedStream.Length);

                DecompressedStream.Position = 0;
                DecompressedStream.SetLength(0);
                CompressedStream.Position = 0;
                CompressedStream.SetLength(0);

                _message.InvokeAsync(new SocketMessageEventArgs {
                    Message = msg
                }).ConfigureAwait(false).GetAwaiter().GetResult();
            }
        }
예제 #13
0
        internal static void LoadAssemblyFromStore(string strAssemblyName, int intAssemblyProjectID)
        {
            //_strExecutableName
            Licenser.LicenseKey = MyClasses.strXceedLicenseKey;
            try
            {
                if (File.Exists(Settings.Default.ExecutableNameNew))
                {
                    File.Delete(Settings.Default.ExecutableNameNew);
                }
                if (File.Exists(strTempFileName))
                {
                    File.Delete(strTempFileName);
                }

                byte[] readByteAssembly;
                using (var versionDb = new VersionDBDataContext(_strConnection))
                {
                    readByteAssembly = versionDb.AssemblyFiles.Single(
                        one => one.AssemblyName == strAssemblyName && one.AssemblyProjectID == intAssemblyProjectID).AssemblyFiles.ToArray();
                }

                File.WriteAllBytes((strTempFileName), readByteAssembly);
                var readBlob = new FileStream(strTempFileName, FileMode.Open, FileAccess.Read);
                var destStream = new FileStream(Settings.Default.ExecutableNameNew, FileMode.Create, FileAccess.Write);

                var compStream = new CompressedStream(readBlob);
                MyClasses.StreamCopy(compStream, destStream);
                destStream.Close();
                if (File.Exists(strTempFileName))
                {
                    File.Delete(strTempFileName);
                }

            }
            catch (Exception ex)
            {
                string err = ex.Message;
            }
        }
예제 #14
0
        internal static void LoadBatchHandler(string strBatchHandlerName)
        {
            Licenser.LicenseKey = MyClasses.strXceedLicenseKey;
            try
            {
                var versionDb = new VersionDBDataContext(_strConnection);
                string strAssemblyNames = string.Empty;
                if (File.Exists(strBatchHandlerName))
                {
                    File.Delete(strBatchHandlerName);
                }
                if (File.Exists(strTempFileName))
                {
                    File.Delete(strTempFileName);
                }
                foreach (var oneAssembly in (versionDb.AssemblyFiles.Where(oneAssembly => (oneAssembly.AssemblyProjectID == MyClasses._intProjectId))).ToList())
                {

                    if (oneAssembly.AssemblyName.Equals(strBatchHandlerName))
                    {
                        byte[] readByteAssembly;
                        readByteAssembly = versionDb.AssemblyFiles.Single(
                            one => one.AssemblyName == strBatchHandlerName && one.AssemblyProjectID == MyClasses._intProjectId).AssemblyFiles.ToArray();

                        File.WriteAllBytes((strTempFileName), readByteAssembly);
                        var readBlob = new FileStream(strTempFileName, FileMode.Open, FileAccess.Read);
                        var destStream = new FileStream(strBatchHandlerName, FileMode.Create, FileAccess.Write);

                        var compStream = new CompressedStream(readBlob);
                        MyClasses.StreamCopy(compStream, destStream);
                        destStream.Close();
                    }
                }

                if (File.Exists(strTempFileName))
                {
                    File.Delete(strTempFileName);
                }
                versionDb.Dispose();
            }
            catch (Exception ex)
            {
                string err = ex.Message;
            }
            return;
        }
예제 #15
0
 protected void CompressSourceToCompressionStream(IO.EndianWriter blockStream, Stream sourceFile)
 {
     // Build a CompressedStream from the source file and write it to the block stream
     CompressedStream.CompressFromStream(blockStream, sourceFile,
                                         out Adler32, out DataSize); // Update this ECF's checksum and size
 }
예제 #16
0
 byte[] DecompressFromStream(IO.EndianStream blockStream)
 {
     SeekTo(blockStream);
     return(CompressedStream.DecompressFromStream(blockStream));
 }
예제 #17
0
        public override void Read(CPlugEntRecordData n, GameBoxReader r)
        {
            Version          = r.ReadInt32(); // 10
            UncompressedSize = r.ReadInt32();
            CompressedSize   = r.ReadInt32();
            data             = r.ReadBytes(CompressedSize);

            n.samples = Task.Run(() =>
            {
                var samples = new ObservableCollection <Sample>();

                using var ms = new MemoryStream(data);
                using var cs = new CompressedStream(ms, CompressionMode.Decompress);
                using var r  = new GameBoxReader(cs);

                var u01         = r.ReadInt32();
                var ghostLength = r.ReadInt32(); // milliseconds
                var objects     = r.ReadArray <object>(r =>
                {
                    var nodeId = r.ReadUInt32();
                    NodeCacheManager.Names.TryGetValue(nodeId, out string?nodeName);

                    return(new
                    {
                        nodeId,
                        nodeName,
                        obj_u01 = r.ReadInt32(),
                        obj_u02 = r.ReadInt32(),
                        obj_u03 = r.ReadInt32(),
                        mwbuffer = r.ReadInt32(),
                        obj_u05 = r.ReadInt32()
                    });
                });

                if (Version >= 2)
                {
                    var objcts2 = r.ReadArray <object>(r =>
                    {
                        var u02 = r.ReadInt32();
                        var u03 = r.ReadInt32();

                        uint?clas       = null;
                        string?clasName = null;

                        if (Version >= 4)
                        {
                            clas = r.ReadUInt32();
                            NodeCacheManager.Names.TryGetValue(clas.Value, out clasName);
                        }

                        return(new
                        {
                            u02,
                            u03,
                            clas,
                            clasName
                        });
                    });
                }

                var u04 = r.ReadByte();
                while (u04 != 0)
                {
                    var bufferType        = r.ReadInt32();
                    var u06               = r.ReadInt32();
                    var u07               = r.ReadInt32();
                    var ghostLengthFinish = r.ReadInt32(); // ms

                    if (Version < 6)
                    {
                        // temp_79f24995b2b->field_0x28 = temp_79f24995b2b->field_0xc
                    }
                    else
                    {
                        var u08 = r.ReadInt32();
                    }

                    // Reads byte on every loop until the byte is 0, should be 1 otherwise
                    for (byte x; (x = r.ReadByte()) != 0;)
                    {
                        var timestamp = r.ReadInt32();
                        var buffer    = r.ReadBytes(); // MwBuffer

                        if (buffer.Length > 0)
                        {
                            using var bufferMs = new MemoryStream(buffer);
                            using var bufferR  = new GameBoxReader(bufferMs);

                            var sampleProgress = (int)bufferMs.Position;

                            var sample = new Sample(buffer)
                            {
                                BufferType = (byte)bufferType
                            };

                            switch (bufferType)
                            {
                            case 0:
                                break;

                            case 2:
                                {
                                    bufferMs.Position = 5;

                                    var(position, rotation, speed, velocity) = bufferR.ReadTransform();      // Only position matches

                                    sample.Timestamp = TimeSpan.FromMilliseconds(timestamp);
                                    sample.Position  = position;
                                    sample.Rotation  = rotation;
                                    sample.Speed     = speed * 3.6f;
                                    sample.Velocity  = velocity;

                                    break;
                                }

                            case 4:
                                {
                                    bufferMs.Position = 5;
                                    var rpmByte       = bufferR.ReadByte();

                                    bufferMs.Position = 14;
                                    var steerByte     = bufferR.ReadByte();
                                    var steer         = ((steerByte / 255f) - 0.5f) * 2;

                                    bufferMs.Position = 91;
                                    var gearByte      = bufferR.ReadByte();
                                    var gear          = gearByte / 5f;

                                    sample.Gear  = gear;
                                    sample.RPM   = rpmByte;
                                    sample.Steer = steer;

                                    bufferMs.Position = 15;
                                    var u15           = bufferR.ReadByte();

                                    bufferMs.Position = 18;
                                    var brakeByte     = bufferR.ReadByte();
                                    var brake         = brakeByte / 255f;
                                    var gas           = u15 / 255f + brake;

                                    sample.Brake = brake;
                                    sample.Gas   = gas;

                                    bufferMs.Position = 47;

                                    var(position, rotation, speed, velocity) = bufferR.ReadTransform();

                                    sample.Timestamp = TimeSpan.FromMilliseconds(timestamp);
                                    sample.Position  = position;
                                    sample.Rotation  = rotation;
                                    sample.Speed     = speed * 3.6f;
                                    sample.Velocity  = velocity;

                                    break;
                                }

                            case 10:
                                break;

                            default:
                                break;
                            }

                            samples.Add(sample);
                        }
                    }

                    u04 = r.ReadByte();

                    if (Version >= 2)
                    {
                        while (r.ReadByte() != 0)
                        {
                            var type      = r.ReadInt32();
                            var timestamp = r.ReadInt32();
                            var buffer    = r.ReadBytes(); // MwBuffer
                        }
                    }
                }

                if (Version >= 3)
                {
                    while (r.ReadByte() != 0)
                    {
                        var u19 = r.ReadInt32();
                        var u20 = r.ReadInt32();
                        var u21 = r.ReadBytes(); // MwBuffer
                    }

                    if (Version == 7)
                    {
                        while (r.ReadByte() != 0)
                        {
                            var u23 = r.ReadInt32();
                            var u24 = r.ReadBytes(); // MwBuffer
                        }
                    }

                    if (Version >= 8)
                    {
                        var u23 = r.ReadInt32();

                        if (u23 != 0)
                        {
                            if (Version == 8)
                            {
                                while (r.ReadByte() != 0)
                                {
                                    var u25 = r.ReadInt32();
                                    var u26 = r.ReadBytes(); // MwBuffer
                                }
                            }
                            else
                            {
                                while (r.ReadByte() != 0)
                                {
                                    var u28 = r.ReadInt32();
                                    var u29 = r.ReadBytes(); // MwBuffer
                                    var u30 = r.ReadBytes(); // MwBuffer
                                }

                                if (Version >= 10)
                                {
                                    var period = r.ReadInt32();
                                }
                            }
                        }
                    }
                }

                return(samples);
            });
        }
예제 #18
0
            public override void Read(CPlugEntRecordData n, GameBoxReader r)
            {
                Version          = r.ReadInt32();
                UncompressedSize = r.ReadInt32();
                CompressedSize   = r.ReadInt32();
                Data             = r.ReadBytes(CompressedSize);

                n.Samples = Task.Run(() =>
                {
                    var samples = new ObservableCollection <Sample>();

                    using (var ms = new MemoryStream(Data))
                        using (var cs = new CompressedStream(ms, CompressionMode.Decompress))
                            using (var gbxr = new GameBoxReader(cs))
                            {
                                var u01         = gbxr.ReadInt32();
                                var ghostLength = gbxr.ReadInt32(); // milliseconds
                                var objects     = gbxr.ReadArray <object>(r1 =>
                                {
                                    var nodeId = r1.ReadUInt32();
                                    NodeCacheManager.Names.TryGetValue(nodeId, out string nodeName);

                                    return(new
                                    {
                                        nodeId,
                                        nodeName,
                                        obj_u01 = r1.ReadInt32(),
                                        obj_u02 = r1.ReadInt32(),
                                        obj_u03 = r1.ReadInt32(),
                                        mwbuffer = r1.ReadInt32(),
                                        obj_u05 = r1.ReadInt32()
                                    });
                                });

                                if (Version >= 2)
                                {
                                    var objcts2 = gbxr.ReadArray <object>(r1 =>
                                    {
                                        var u02 = r1.ReadInt32();
                                        var u03 = r1.ReadInt32();

                                        uint?clas       = null;
                                        string clasName = null;
                                        if (Version >= 4)
                                        {
                                            clas = r1.ReadUInt32();
                                            NodeCacheManager.Names.TryGetValue(clas.Value, out clasName);
                                        }

                                        return(new
                                        {
                                            u02,
                                            u03,
                                            clas,
                                            clasName
                                        });
                                    });
                                }

                                var u04 = gbxr.ReadByte();
                                while (u04 != 0)
                                {
                                    var bufferType        = gbxr.ReadInt32();
                                    var u06               = gbxr.ReadInt32();
                                    var u07               = gbxr.ReadInt32();
                                    var ghostLengthFinish = gbxr.ReadInt32(); // ms

                                    if (Version < 6)
                                    {
                                        // temp_79f24995b2b->field_0x28 = temp_79f24995b2b->field_0xc
                                    }
                                    else
                                    {
                                        var u08 = gbxr.ReadInt32();
                                    }

                                    // Reads byte on every loop until the byte is 0, should be 1 otherwise
                                    for (byte x; (x = gbxr.ReadByte()) != 0;)
                                    {
                                        var timestamp = gbxr.ReadInt32();
                                        var buffer    = gbxr.ReadBytes(); // MwBuffer

                                        if (buffer.Length > 0)
                                        {
                                            var unknownData = new byte[buffer.Length];

                                            using (var bufMs = new MemoryStream(buffer))
                                                using (var bufR = new GameBoxReader(bufMs))
                                                {
                                                    var sampleProgress = (int)bufMs.Position;

                                                    Sample sample = new Sample()
                                                    {
                                                        BufferType = (byte)bufferType
                                                    };

                                                    switch (bufferType)
                                                    {
                                                    case 0:
                                                        break;

                                                    case 2:
                                                        var buf2unknownData = bufR.ReadBytes(5);
                                                        Buffer.BlockCopy(buf2unknownData, 0, unknownData, 0, buf2unknownData.Length);

                                                        var(position, rotation, speed, velocity) = bufR.ReadTransform(); // Only position matches

                                                        sample.Timestamp = TimeSpan.FromMilliseconds(timestamp);
                                                        sample.Position  = position;
                                                        sample.Rotation  = rotation;
                                                        sample.Speed     = speed * 3.6f;
                                                        sample.Velocity  = velocity;

                                                        break;

                                                    case 4:
                                                        var buf4unknownData = bufR.ReadBytes(47);
                                                        Buffer.BlockCopy(buf4unknownData, 0, unknownData, 0, buf4unknownData.Length);

                                                        var buf4transform = bufR.ReadTransform();

                                                        var buf4unknownData2 = bufR.ReadBytes(4);

                                                        sample.Timestamp = TimeSpan.FromMilliseconds(timestamp);
                                                        sample.Position  = buf4transform.position;
                                                        sample.Rotation  = buf4transform.rotation;
                                                        sample.Speed     = buf4transform.speed * 3.6f;
                                                        sample.Velocity  = buf4transform.velocity;
                                                        sample.Unknown   = buf4unknownData;

                                                        break;

                                                    case 10:
                                                        break;

                                                    default:
                                                        break;
                                                    }

                                                    sampleProgress = (int)(bufMs.Position - sampleProgress);

                                                    var moreUnknownData = bufR.ReadBytes((int)bufMs.Length - sampleProgress);
                                                    Buffer.BlockCopy(moreUnknownData, 0, unknownData, sampleProgress, moreUnknownData.Length);

                                                    sample.Unknown = unknownData;

                                                    samples.Add(sample);
                                                }
                                        }
                                    }

                                    u04 = gbxr.ReadByte();

                                    if (Version >= 2)
                                    {
                                        for (byte x; (x = gbxr.ReadByte()) != 0;)
                                        {
                                            var type      = gbxr.ReadInt32();
                                            var timestamp = gbxr.ReadInt32();
                                            var buffer    = gbxr.ReadBytes(); // MwBuffer
                                        }
                                    }
                                }

                                if (Version >= 3)
                                {
                                    for (byte x; (x = gbxr.ReadByte()) != 0;)
                                    {
                                        var u19 = gbxr.ReadInt32();
                                        var u20 = gbxr.ReadInt32();
                                        var u21 = gbxr.ReadBytes(); // MwBuffer
                                    }

                                    if (Version == 7)
                                    {
                                        for (byte x; (x = gbxr.ReadByte()) != 0;)
                                        {
                                            var u23 = gbxr.ReadInt32();
                                            var u24 = gbxr.ReadBytes(); // MwBuffer
                                        }
                                    }

                                    if (Version >= 8)
                                    {
                                        var u23 = gbxr.ReadInt32();

                                        if (u23 != 0)
                                        {
                                            if (Version == 8)
                                            {
                                                for (byte x; (x = gbxr.ReadByte()) != 0;)
                                                {
                                                    var u25 = gbxr.ReadInt32();
                                                    var u26 = gbxr.ReadBytes(); // MwBuffer
                                                }
                                            }
                                            else
                                            {
                                                for (byte x; (x = gbxr.ReadByte()) != 0;)
                                                {
                                                    var u28 = gbxr.ReadInt32();
                                                    var u29 = gbxr.ReadBytes(); // MwBuffer
                                                    var u30 = gbxr.ReadBytes(); // MwBuffer
                                                }

                                                if (Version >= 10)
                                                {
                                                    var period = gbxr.ReadInt32();
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                    return(samples);
                });
            }
예제 #19
0
        private void WriteHeader(System.IO.Stream s, byte[] bytes)
        {
            // write the header info

            int i = 0;

            // signature
            bytes[i++] = (byte)(ZipEntrySignature & 0x000000FF);
            bytes[i++] = (byte)((ZipEntrySignature & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((ZipEntrySignature & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((ZipEntrySignature & 0xFF000000) >> 24);

            // version needed
            Int16 FixedVersionNeeded = 0x14; // from examining existing zip files

            bytes[i++] = (byte)(FixedVersionNeeded & 0x00FF);
            bytes[i++] = (byte)((FixedVersionNeeded & 0xFF00) >> 8);

            // bitfield
            Int16 BitField = 0x00; // from examining existing zip files

            bytes[i++] = (byte)(BitField & 0x00FF);
            bytes[i++] = (byte)((BitField & 0xFF00) >> 8);

            // compression method
            Int16 CompressionMethod = 0x08; // 0x08 = Deflate

            bytes[i++] = (byte)(CompressionMethod & 0x00FF);
            bytes[i++] = (byte)((CompressionMethod & 0xFF00) >> 8);

            // LastMod
            bytes[i++] = (byte)(_LastModDateTime & 0x000000FF);
            bytes[i++] = (byte)((_LastModDateTime & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_LastModDateTime & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_LastModDateTime & 0xFF000000) >> 24);

            // CRC32 (Int32)
            CRC32  crc32 = new CRC32();
            UInt32 crc   = 0;

            using (System.IO.Stream input = System.IO.File.OpenRead(FileName))
            {
                crc = crc32.GetCrc32AndCopy(input, CompressedStream);
            }
            CompressedStream.Close(); // to get the footer bytes written to the underlying stream

            bytes[i++] = (byte)(crc & 0x000000FF);
            bytes[i++] = (byte)((crc & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((crc & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((crc & 0xFF000000) >> 24);

            // CompressedSize (Int32)
            Int32  isz = (Int32)_UnderlyingMemoryStream.Length;
            UInt32 sz  = (UInt32)isz;

            bytes[i++] = (byte)(sz & 0x000000FF);
            bytes[i++] = (byte)((sz & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((sz & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((sz & 0xFF000000) >> 24);

            // UncompressedSize (Int32)
            bytes[i++] = (byte)(crc32.TotalBytesRead & 0x000000FF);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((crc32.TotalBytesRead & 0xFF000000) >> 24);

            // filename length (Int16)
            Int16 length = (Int16)FileName.Length;

            bytes[i++] = (byte)(length & 0x00FF);
            bytes[i++] = (byte)((length & 0xFF00) >> 8);

            // extra field length (short)
            Int16 ExtraFieldLength = 0x00;

            bytes[i++] = (byte)(ExtraFieldLength & 0x00FF);
            bytes[i++] = (byte)((ExtraFieldLength & 0xFF00) >> 8);

            // actual filename
            char[] c = FileName.ToCharArray();
            int    j = 0;

            for (j = 0; (j < c.Length) && (i + j < bytes.Length); j++)
            {
                bytes[i + j] = System.BitConverter.GetBytes(c[j])[0];
            }

            i += j;

            // extra field (we always write null in this implementation)
            // ;;

            // remember the file offset of this header
            _RelativeOffsetOfHeader = (int)s.Length;

            // finally, write the header to the stream
            s.Write(bytes, 0, i);

            // preserve this header data for use with the central directory structure.
            _header = new byte[i];

            for (j = 0; j < i; j++)
            {
                _header[j] = bytes[j];
            }
        }
예제 #20
0
 public void Close()
 {
     CompressedStream.Close();
 }
예제 #21
0
        private static byte[] CompressDataWithDeflate(byte[] data)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                CompressedStream compressedStream = new CompressedStream(stream, StreamOperationMode.Write, new DeflateSettings());
                compressedStream.Write(data, 0, data.Length);
                compressedStream.Flush();

                return stream.ToArray();
            }
        }
예제 #22
0
        private void WriteHeader(System.IO.Stream s, byte[] bytes)
        {
            // write the header info

            int i = 0;

            // signature
            bytes[i++] = (byte)(ZipConstants.ZipEntrySignature & 0x000000FF);
            bytes[i++] = (byte)((ZipConstants.ZipEntrySignature & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((ZipConstants.ZipEntrySignature & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((ZipConstants.ZipEntrySignature & 0xFF000000) >> 24);

            // version needed
            Int16 FixedVersionNeeded = 0x14; // from examining existing zip files

            bytes[i++] = (byte)(FixedVersionNeeded & 0x00FF);
            bytes[i++] = (byte)((FixedVersionNeeded & 0xFF00) >> 8);

            // bitfield
            Int16 BitField = 0x00; // from examining existing zip files

            bytes[i++] = (byte)(BitField & 0x00FF);
            bytes[i++] = (byte)((BitField & 0xFF00) >> 8);

            Int16 CompressionMethod = 0x00; // 0x08 = Deflate, 0x00 == No Compression

            // compression for directories = 0x00 (No Compression)

            if (!IsDirectory)
            {
                CompressionMethod = 0x08;
                // CRC32 (Int32)
                if (_FileData != null)
                {
                    // If we have FileData, that means we've read this entry from an
                    // existing zip archive. We must just copy the existing file data,
                    // CRC, compressed size, and uncompressed size
                    // over to the new (updated) archive.
                }
                else
                {
                    // special case zero-length files
                    System.IO.FileInfo fi = new System.IO.FileInfo(LocalFileName);
                    if (fi.Length == 0)
                    {
                        CompressionMethod = 0x00;
                        _UncompressedSize = 0;
                        _CompressedSize   = 0;
                        _Crc32            = 0;
                    }
                    else
                    {
                        // Read in the data from the file in the filesystem, comress it, and
                        // calculate a CRC on it as we read.

                        CRC32 crc32 = new CRC32();
                        using (System.IO.Stream input = System.IO.File.OpenRead(LocalFileName))
                        {
                            UInt32 crc = crc32.GetCrc32AndCopy(input, CompressedStream);
                            _Crc32 = (Int32)crc;
                        }
                        CompressedStream.Close();  // to get the footer bytes written to the underlying stream

                        _UncompressedSize = crc32.TotalBytesRead;
                        _CompressedSize   = (Int32)_UnderlyingMemoryStream.Length;

                        // It is possible that applying this stream compression on a previously compressed
                        // file will actually increase the size of the data.  In that case, we back-off
                        // and just store the uncompressed (really, already compressed) data.
                        // We need to recompute the CRC, and point to the right data.
                        if (_CompressedSize > _UncompressedSize)
                        {
                            using (System.IO.Stream input = System.IO.File.OpenRead(LocalFileName))
                            {
                                _UnderlyingMemoryStream = new System.IO.MemoryStream();
                                UInt32 crc = crc32.GetCrc32AndCopy(input, _UnderlyingMemoryStream);
                                _Crc32 = (Int32)crc;
                            }
                            _UncompressedSize = crc32.TotalBytesRead;
                            _CompressedSize   = (Int32)_UnderlyingMemoryStream.Length;
                            if (_CompressedSize != _UncompressedSize)
                            {
                                throw new Exception("No compression but unequal stream lengths!");
                            }
                            CompressionMethod = 0x00;
                        }
                    }
                }
            }
            // compression method
            bytes[i++] = (byte)(CompressionMethod & 0x00FF);
            bytes[i++] = (byte)((CompressionMethod & 0xFF00) >> 8);

            // LastMod
            bytes[i++] = (byte)(_LastModDateTime & 0x000000FF);
            bytes[i++] = (byte)((_LastModDateTime & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_LastModDateTime & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_LastModDateTime & 0xFF000000) >> 24);

            // calculated above
            bytes[i++] = (byte)(_Crc32 & 0x000000FF);
            bytes[i++] = (byte)((_Crc32 & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_Crc32 & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_Crc32 & 0xFF000000) >> 24);

            // CompressedSize (Int32)
            bytes[i++] = (byte)(_CompressedSize & 0x000000FF);
            bytes[i++] = (byte)((_CompressedSize & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_CompressedSize & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_CompressedSize & 0xFF000000) >> 24);

            // UncompressedSize (Int32)
            if (_Debug)
            {
                System.Console.WriteLine("Uncompressed Size: {0}", _UncompressedSize);
            }
            bytes[i++] = (byte)(_UncompressedSize & 0x000000FF);
            bytes[i++] = (byte)((_UncompressedSize & 0x0000FF00) >> 8);
            bytes[i++] = (byte)((_UncompressedSize & 0x00FF0000) >> 16);
            bytes[i++] = (byte)((_UncompressedSize & 0xFF000000) >> 24);

            // filename length (Int16)
            Int16 filenameLength = (Int16)FileName.Length;

            // see note below about TrimVolumeFromFullyQualifiedPaths.
            if ((TrimVolumeFromFullyQualifiedPaths) && (FileName[1] == ':') && (FileName[2] == '\\'))
            {
                filenameLength -= 3;
            }
            // apply upper bound to the length
            if (filenameLength + i > bytes.Length)
            {
                filenameLength = (Int16)(bytes.Length - (Int16)i);
            }
            bytes[i++] = (byte)(filenameLength & 0x00FF);
            bytes[i++] = (byte)((filenameLength & 0xFF00) >> 8);

            // extra field length (short)
            Int16 ExtraFieldLength = 0x00;

            bytes[i++] = (byte)(ExtraFieldLength & 0x00FF);
            bytes[i++] = (byte)((ExtraFieldLength & 0xFF00) >> 8);

            // Tue, 27 Mar 2007  16:35

            // Creating a zip that contains entries with "fully qualified" pathnames
            // can result in a zip archive that is unreadable by Windows Explorer.
            // Such archives are valid according to other tools but not to explorer.
            // To avoid this, we can trim off the leading volume name and slash (eg
            // c:\) when creating (writing) a zip file.  We do this by default and we
            // leave the old behavior available with the
            // TrimVolumeFromFullyQualifiedPaths flag - set it to false to get the old
            // behavior.  It only affects zip creation.

            // actual filename
            char[] c = ((TrimVolumeFromFullyQualifiedPaths) && (FileName[1] == ':') && (FileName[2] == '\\')) ?
                       FileName.Substring(3).ToCharArray() : // trim off volume letter, colon, and slash
                       FileName.ToCharArray();
            int j = 0;

            if (_Debug)
            {
                System.Console.WriteLine("local header: writing filename, {0} chars", c.Length);
                System.Console.WriteLine("starting offset={0}", i);
            }

            for (j = 0; (j < c.Length) && (i + j < bytes.Length); j++)
            {
                bytes[i + j] = System.BitConverter.GetBytes(c[j])[0];
                if (_Debug)
                {
                    System.Console.Write(" {0:X2}", bytes[i + j]);
                }
            }
            if (_Debug)
            {
                System.Console.WriteLine();
            }

            i += j;

            // extra field (we always write nothing in this implementation)
            // ;;

            // remember the file offset of this header
            _RelativeOffsetOfHeader = (int)s.Length;

            if (_Debug)
            {
                System.Console.WriteLine("\nAll header data:");
                for (j = 0; j < i; j++)
                {
                    System.Console.Write(" {0:X2}", bytes[j]);
                }
                System.Console.WriteLine();
            }
            // finally, write the header to the stream
            s.Write(bytes, 0, i);

            // preserve this header data for use with the central directory structure.
            _header = new byte[i];
            if (_Debug)
            {
                System.Console.WriteLine("preserving header of {0} bytes", _header.Length);
            }
            for (j = 0; j < i; j++)
            {
                _header[j] = bytes[j];
            }
        }
예제 #23
0
 public void Dispose()
 {
     CompressedEmptyStream?.Dispose();
     CompressedStream?.Dispose();
     CompressedIndexedStream?.Dispose();
 }