internal ZipArchiveEntry(ZipArchive archive, string entryName)
{
this._archive = archive;
this._originallyInArchive = false;
this._diskNumberStart = 0;
this._versionToExtract = ZipVersionNeededValues.Default;
this._generalPurposeBitFlag = (ZipArchiveEntry.BitFlagValues) 0;
this.CompressionMethod = ZipArchiveEntry.CompressionMethodValues.Deflate;
this._lastModified = DateTimeOffset.Now;
this._compressedSize = (long)0;
this._uncompressedSize = (long)0;
this._externalFileAttr = 0;
this._offsetOfLocalHeader = (long)0;
this._storedOffsetOfCompressedData = null;
this._crc32 = 0;
this._compressedBytes = null;
this._storedUncompressedData = null;
this._currentlyOpenForWrite = false;
this._everOpenedForWrite = false;
this._outstandingWriteStream = null;
this.FullName = entryName;
this._cdUnknownExtraFields = null;
this._lhUnknownExtraFields = null;
this._fileComment = null;
this._compressionLevel = null;
if ((int)this._storedEntryNameBytes.Length > 65535)
{
throw new ArgumentException(Messages.EntryNamesTooLong);
}
if (this._archive.Mode == ZipArchiveMode.Create)
{
this._archive.AcquireArchiveStream(this);
}
}
private ZipArchiveEntry DoCreateEntry(string entryName, CompressionLevel?compressionLevel)
{
Contract.Ensures(Contract.Result <ZipArchiveEntry>() != null);
if (entryName == null)
{
throw new ArgumentNullException(nameof(entryName));
}
if (string.IsNullOrEmpty(entryName))
{
throw new ArgumentException(SR.CannotBeEmpty, nameof(entryName));
}
if (_mode == ZipArchiveMode.Read)
{
throw new NotSupportedException(SR.CreateInReadMode);
}
ThrowIfDisposed();
ZipArchiveEntry entry = compressionLevel.HasValue
? new ZipArchiveEntry(this, entryName, compressionLevel.Value)
: new ZipArchiveEntry(this, entryName);
AddEntry(entry);
return(entry);
}
private ZipArchiveEntry DoCreateEntry(string entryName, CompressionLevel?compressionLevel)
{
if (entryName == null)
{
throw new ArgumentNullException(nameof(entryName));
}
if (string.IsNullOrEmpty(entryName))
{
throw new ArgumentException(SR.CannotBeEmpty, nameof(entryName));
}
if (_mode == ZipArchiveMode.Read)
{
throw new NotSupportedException(SR.CreateInReadMode);
}
if (_entriesDictionary.ContainsKey(entryName))
{
throw new InvalidOperationException(string.Format(SR.EntryNameAlreadyExists, entryName));
}
ThrowIfDisposed();
ZipArchiveEntry entry = compressionLevel.HasValue ?
new ZipArchiveEntry(this, entryName, compressionLevel.Value) :
new ZipArchiveEntry(this, entryName);
AddEntry(entry);
return(entry);
}
public static HttpContextServerCallContext CreateServerCallContext(
HttpContext?httpContext = null,
List <ICompressionProvider>?compressionProviders = null,
string?responseCompressionAlgorithm = null,
CompressionLevel?responseCompressionLevel = null,
int?maxSendMessageSize = null,
int?maxReceiveMessageSize = null,
ILogger?logger = null,
bool initialize = true)
{
var options = CreateMethodOptions(
compressionProviders,
responseCompressionAlgorithm,
responseCompressionLevel,
maxSendMessageSize,
maxReceiveMessageSize);
var context = new HttpContextServerCallContext(
httpContext ?? new DefaultHttpContext(),
options,
typeof(object),
typeof(object),
logger ?? NullLogger.Instance);
if (initialize)
{
context.Initialize();
}
return(context);
}
private static IDeflater CreateDeflater(CompressionLevel?compressionLevel)
{
// The deflator type (zlib or managed) is normally determined by s_deflatorType,
// which is initialized by the provider based on what's available on the system.
// But for testing purposes, we sometimes want to override this, forcing
// compression/decompression to use a particular type.
WorkerType deflatorType = s_deflaterType;
#if DEBUG
if (s_forcedTestingDeflaterType != WorkerType.Unknown)
{
deflatorType = s_forcedTestingDeflaterType;
}
#endif
if (deflatorType == WorkerType.ZLib)
{
return(compressionLevel.HasValue ?
new DeflaterZLib(compressionLevel.Value) :
new DeflaterZLib());
}
else
{
Debug.Assert(deflatorType == WorkerType.Managed);
return(new DeflaterManaged());
}
}
private ZipArchiveEntry DoCreateEntry(string entryName, CompressionLevel?compressionLevel)
{
if (entryName == null)
{
throw new ArgumentNullException(nameof(entryName));
}
if (string.IsNullOrEmpty(entryName))
{
throw new ArgumentException(nameof(entryName));
}
if (_mode == ZipArchiveMode.Read)
{
throw new NotSupportedException();
}
ThrowIfDisposed();
ZipArchiveEntry entry = compressionLevel.HasValue ?
new ZipArchiveEntry(this, entryName, compressionLevel.Value) :
new ZipArchiveEntry(this, entryName);
AddEntry(entry);
return(entry);
}
public byte[] Compress(string src, CompressionLevel?compressionLevel = null)
{
if (string.IsNullOrEmpty(src))
{
return(null);
}
var byteArray = Encoding.UTF8.GetBytes(src);
var byteArrayLength = byteArray.Length;
byte[] zip;
using (var ms = new MemoryStream())
{
using (var zs = GetGZipStream(ms, CompressionMode.Compress, compressionLevel))
{
zs.Write(byteArray, 0, byteArrayLength);
zs.Close();
zip = ms.ToArray();
}
}
if (zip.Length <= 0)
{
return(null);
}
var sizeArray = BitConverter.GetBytes(byteArrayLength);
var buffer = new List <byte>(sizeArray);
buffer.AddRange(zip);
return(buffer.ToArray());
}
private static void DoCreateFromDirectory(String sourceDirectoryName, String destinationArchiveFileName,
CompressionLevel?compressionLevel, Boolean includeBaseDirectory,
Encoding entryNameEncoding)
{
// Rely on Path.GetFullPath for validation of sourceDirectoryName and destinationArchive
// Checking of compressionLevel is passed down to DeflateStream and the IDeflater implementation
// as it is a pluggable component that completely encapsulates the meaning of compressionLevel.
sourceDirectoryName = Path.GetFullPath(sourceDirectoryName);
destinationArchiveFileName = Path.GetFullPath(destinationArchiveFileName);
using (ZipArchive archive = Open(destinationArchiveFileName, ZipArchiveMode.Create, entryNameEncoding))
{
bool directoryIsEmpty = true;
//add files and directories
DirectoryInfo di = new DirectoryInfo(sourceDirectoryName);
string basePath = di.FullName;
if (includeBaseDirectory && di.Parent != null)
{
basePath = di.Parent.FullName;
}
foreach (FileSystemInfo file in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
{
directoryIsEmpty = false;
Int32 entryNameLength = file.FullName.Length - basePath.Length;
Debug.Assert(entryNameLength > 0);
String entryName = EntryFromPath(file.FullName, basePath.Length, entryNameLength);
if (file is FileInfo)
{
// Create entry for file:
ZipFileExtensions.DoCreateEntryFromFile(archive, file.FullName, entryName, compressionLevel);
}
else
{
// Entry marking an empty dir:
DirectoryInfo possiblyEmpty = file as DirectoryInfo;
if (possiblyEmpty != null && IsDirEmpty(possiblyEmpty))
{
// FullName never returns a directory separator character on the end,
// but Zip archives require it to specify an explicit directory:
archive.CreateEntry(entryName + PathSeparator);
}
}
} // foreach
// If no entries create an empty root directory entry:
if (includeBaseDirectory && directoryIsEmpty)
{
archive.CreateEntry(EntryFromPath(di.Name, 0, di.Name.Length) + PathSeparator);
}
} // using
} // DoCreateFromDirectory
internal ZipArchiveEntry(ZipArchive archive, ZipCentralDirectoryFileHeader cd)
{
this._archive = archive;
this._originallyInArchive = true;
this._diskNumberStart = cd.DiskNumberStart;
this._versionToExtract = (ZipVersionNeededValues)cd.VersionNeededToExtract;
this._generalPurposeBitFlag = (ZipArchiveEntry.BitFlagValues)cd.GeneralPurposeBitFlag;
this.CompressionMethod = (ZipArchiveEntry.CompressionMethodValues)cd.CompressionMethod;
this._lastModified = new DateTimeOffset(ZipHelper.DosTimeToDateTime(cd.LastModified));
this._compressedSize = cd.CompressedSize;
this._uncompressedSize = cd.UncompressedSize;
this._externalFileAttr = cd.ExternalFileAttributes;
this._offsetOfLocalHeader = cd.RelativeOffsetOfLocalHeader;
this._storedOffsetOfCompressedData = null;
this._crc32 = cd.Crc32;
this._compressedBytes = null;
this._storedUncompressedData = null;
this._currentlyOpenForWrite = false;
this._everOpenedForWrite = false;
this._outstandingWriteStream = null;
this.FullName = this.DecodeEntryName(cd.Filename);
this._lhUnknownExtraFields = null;
this._cdUnknownExtraFields = cd.ExtraFields;
this._fileComment = cd.FileComment;
this._compressionLevel = null;
}
private MethodOptions(
Dictionary <string, ICompressionProvider> compressionProviders,
InterceptorCollection interceptors,
int?maxSendMessageSize,
int?maxReceiveMessageSize,
bool?enableDetailedErrors,
string?responseCompressionAlgorithm,
CompressionLevel?responseCompressionLevel)
{
CompressionProviders = compressionProviders;
Interceptors = interceptors;
HasInterceptors = interceptors.Count > 0;
MaxSendMessageSize = maxSendMessageSize;
MaxReceiveMessageSize = maxReceiveMessageSize;
EnableDetailedErrors = enableDetailedErrors;
ResponseCompressionAlgorithm = responseCompressionAlgorithm;
ResponseCompressionLevel = responseCompressionLevel;
if (ResponseCompressionAlgorithm != null)
{
if (!CompressionProviders.TryGetValue(ResponseCompressionAlgorithm, out var _))
{
throw new InvalidOperationException($"The configured response compression algorithm '{ResponseCompressionAlgorithm}' does not have a matching compression provider.");
}
}
}
private ZipArchiveEntry DoCreateEntry(String entryName, CompressionLevel?compressionLevel)
{
//Contract.Ensures(Contract.Result<ZipArchiveEntry>() != null);
// Checking of compressionLevel is passed down to DeflateStream and the IDeflater implementation
// as it is a pugable component that completely encapsulates the meaning of compressionLevel.
if (entryName == null)
{
throw new ArgumentNullException("entryName");
}
if (String.IsNullOrEmpty(entryName))
{
throw new ArgumentException(SR.CannotBeEmpty, "entryName");
}
if (_mode == ZipArchiveMode.Read)
{
throw new NotSupportedException(SR.CreateInReadMode);
}
ThrowIfDisposed();
ZipArchiveEntry entry = compressionLevel.HasValue
? new ZipArchiveEntry(this, entryName, compressionLevel.Value)
: new ZipArchiveEntry(this, entryName);
AddEntry(entry);
return(entry);
}
internal static ZipArchiveEntry DoCreateEntryFromFile(
ZipArchive destination,
string sourceFileName,
string entryName,
CompressionLevel?compressionLevel)
{
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if (sourceFileName == null)
{
throw new ArgumentNullException(nameof(sourceFileName));
}
if (entryName == null)
{
throw new ArgumentNullException(nameof(entryName));
}
using (Stream stream = (Stream)File.Open(sourceFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
ZipArchiveEntry zipArchiveEntry = compressionLevel.HasValue ? destination.CreateEntry(entryName, compressionLevel.Value) : destination.CreateEntry(entryName);
DateTime dateTime = File.GetLastWriteTime(sourceFileName);
if (dateTime.Year < 1980 || dateTime.Year > 2107)
{
dateTime = new DateTime(1980, 1, 1, 0, 0, 0);
}
zipArchiveEntry.LastWriteTime = (DateTimeOffset)dateTime;
using (Stream destination1 = zipArchiveEntry.Open())
stream.CopyTo(destination1);
return(zipArchiveEntry);
}
}
//Initializes, attaches it to archive
internal ZipArchiveEntry(ZipArchive archive, ZipCentralDirectoryFileHeader cd, CompressionLevel compressionLevel)
: this(archive, cd)
{
// Checking of compressionLevel is passed down to DeflateStream and the IDeflater implementation
// as it is a pugable component that completely encapsulates the meaning of compressionLevel.
_compressionLevel = compressionLevel;
}
/// <summary>
/// Create a new compression stream.
/// </summary>
/// <param name="stream">The stream that compressed data is written to.</param>
/// <param name="compressionLevel">The compression level.</param>
/// <returns>A stream used to compress data.</returns>
public Stream CreateCompressionStream(Stream stream, CompressionLevel?compressionLevel)
{
// As described in RFC 2616, the deflate content-coding is actually
// the "zlib" format (RFC 1950) in combination with the "deflate"
// compression algrithm (RFC 1951). So while potentially
// counterintuitive based on naming, this needs to use ZLibStream
// rather than DeflateStream.
return(new ZLibStream(stream, compressionLevel ?? _defaultCompressionLevel));
}
public ImageOptions(CompressionLevel?compressionLevel, ImageDimensions dimensions)
{
if (dimensions == null)
{
throw new ArgumentNullException("dimensions");
}
_compressionLevel = compressionLevel;
_dimensions = dimensions;
}
/// <summary>
/// Add Sentry Serilog Sink.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration .<seealso cref="LoggerSinkConfiguration"/></param>
/// <param name="dsn">The Sentry DSN. <seealso cref="SentryOptions.Dsn"/></param>
/// <param name="minimumEventLevel">Minimum log level to send an event. <seealso cref="SentrySerilogOptions.MinimumEventLevel"/></param>
/// <param name="minimumBreadcrumbLevel">Minimum log level to record a breadcrumb. <seealso cref="SentrySerilogOptions.MinimumBreadcrumbLevel"/></param>
/// <param name="formatProvider">The Serilog format provider. <seealso cref="IFormatProvider"/></param>
/// <param name="textFormatter">The Serilog text formatter. <seealso cref="ITextFormatter"/></param>
/// <param name="sendDefaultPii">Whether to include default Personal Identifiable information. <seealso cref="SentryOptions.SendDefaultPii"/></param>
/// <param name="isEnvironmentUser">Whether to report the <see cref="System.Environment.UserName"/> as the User affected in the event. <seealso cref="SentryOptions.IsEnvironmentUser"/></param>
/// <param name="serverName">Gets or sets the name of the server running the application. <seealso cref="SentryOptions.ServerName"/></param>
/// <param name="attachStackTrace">Whether to send the stack trace of a event captured without an exception. <seealso cref="SentryOptions.AttachStacktrace"/></param>
/// <param name="maxBreadcrumbs">Gets or sets the maximum breadcrumbs. <seealso cref="SentryOptions.MaxBreadcrumbs"/></param>
/// <param name="sampleRate">The rate to sample events. <seealso cref="SentryOptions.SampleRate"/></param>
/// <param name="release">The release version of the application. <seealso cref="SentryOptions.Release"/></param>
/// <param name="environment">The environment the application is running. <seealso cref="SentryOptions.Environment"/></param>
/// <param name="maxQueueItems">The maximum number of events to keep while the worker attempts to send them. <seealso cref="SentryOptions.MaxQueueItems"/></param>
/// <param name="shutdownTimeout">How long to wait for events to be sent before shutdown. <seealso cref="SentryOptions.ShutdownTimeout"/></param>
/// <param name="decompressionMethods">Decompression methods accepted. <seealso cref="SentryOptions.DecompressionMethods"/></param>
/// <param name="requestBodyCompressionLevel">The level of which to compress the <see cref="SentryEvent"/> before sending to Sentry. <seealso cref="SentryOptions.RequestBodyCompressionLevel"/></param>
/// <param name="requestBodyCompressionBuffered">Whether the body compression is buffered and the request 'Content-Length' known in advance. <seealso cref="SentryOptions.RequestBodyCompressionBuffered"/></param>
/// <param name="debug">Whether to log diagnostics messages. <seealso cref="SentryOptions.Debug"/></param>
/// <param name="diagnosticLevel">The diagnostics level to be used. <seealso cref="SentryOptions.DiagnosticLevel"/></param>
/// <param name="reportAssemblies">Whether or not to include referenced assemblies in each event sent to sentry. Defaults to <see langword="true"/>. <seealso cref="SentryOptions.ReportAssemblies"/></param>
/// <param name="deduplicateMode">What modes to use for event automatic de-duplication. <seealso cref="SentryOptions.DeduplicateMode"/></param>
/// <param name="initializeSdk">Whether to initialize this SDK through this integration. <seealso cref="SentrySerilogOptions.InitializeSdk"/></param>
/// <param name="defaultTags">Defaults tags to add to all events. <seealso cref="SentryOptions.DefaultTags"/></param>
/// <returns><see cref="LoggerConfiguration"/></returns>
/// <example>This sample shows how each item may be set from within a configuration file:
/// <code>
/// {
/// "Serilog": {
/// "Using": [
/// "Serilog",
/// "Sentry",
/// ],
/// "WriteTo": [{
/// "Name": "Sentry",
/// "Args": {
/// "dsn": "https://[email protected]",
/// "minimumBreadcrumbLevel": "Verbose",
/// "minimumEventLevel": "Error",
/// "outputTemplate": "{Timestamp:o} [{Level:u3}] ({Application}/{MachineName}/{ThreadId}) {Message}{NewLine}{Exception}"///
/// "sendDefaultPii": false,
/// "isEnvironmentUser": false,
/// "serverName": "MyServerName",
/// "attachStackTrace": false,
/// "maxBreadcrumbs": 20,
/// "sampleRate": 0.5,
/// "release": "0.0.1",
/// "environment": "staging",
/// "maxQueueItems": 100,
/// "shutdownTimeout": "00:00:05",
/// "decompressionMethods": "GZip",
/// "requestBodyCompressionLevel": "NoCompression",
/// "requestBodyCompressionBuffered": false,
/// "debug": false,
/// "diagnosticLevel": "Debug",
/// "reportAssemblies": false,
/// "deduplicateMode": "All",
/// "initializeSdk": true,
/// "defaultTags": {
/// "key-1", "value-1",
/// "key-2", "value-2"
/// }
/// }
/// }
/// ]
/// }
/// }
/// </code>
/// </example>
public static LoggerConfiguration Sentry(
this LoggerSinkConfiguration loggerConfiguration,
string?dsn = null,
LogEventLevel minimumBreadcrumbLevel = LogEventLevel.Information,
LogEventLevel minimumEventLevel = LogEventLevel.Error,
IFormatProvider?formatProvider = null,
ITextFormatter?textFormatter = null,
bool?sendDefaultPii = null,
bool?isEnvironmentUser = null,
string?serverName = null,
bool?attachStackTrace = null,
int?maxBreadcrumbs = null,
float?sampleRate = null,
string?release = null,
string?environment = null,
int?maxQueueItems = null,
TimeSpan?shutdownTimeout = null,
DecompressionMethods?decompressionMethods = null,
CompressionLevel?requestBodyCompressionLevel = null,
bool?requestBodyCompressionBuffered = null,
bool?debug = null,
SentryLevel?diagnosticLevel = null,
bool?reportAssemblies = null,
DeduplicateMode?deduplicateMode = null,
bool?initializeSdk = null,
Dictionary <string, string>?defaultTags = null)
{
return(loggerConfiguration.Sentry(o => ConfigureSentrySerilogOptions(o,
dsn,
minimumEventLevel,
minimumBreadcrumbLevel,
formatProvider,
textFormatter,
sendDefaultPii,
isEnvironmentUser,
serverName,
attachStackTrace,
maxBreadcrumbs,
sampleRate,
release,
environment,
maxQueueItems,
shutdownTimeout,
decompressionMethods,
requestBodyCompressionLevel,
requestBodyCompressionBuffered,
debug,
diagnosticLevel,
reportAssemblies,
deduplicateMode,
initializeSdk,
defaultTags)));
}
public string Decompress(byte[] src, CompressionLevel?compressionLevel = null)
{
if (src == null)
{
return(null);
}
var srcLength = src.Length;
if (srcLength == 0)
{
return(null);
}
const int intSize = sizeof(int);
if (srcLength <= intSize)
{
return(null);
}
var zip = new byte[srcLength - intSize];
Array.Copy(src, intSize, zip, 0, zip.Length);
var unzipLength = BitConverter.ToInt32(src, 0);
if (unzipLength <= 0)
{
throw new ArgumentOutOfRangeException(nameof(unzipLength), "zip lenght must be greater than 0");
}
var unzip = new byte[unzipLength];
using (var ms = new MemoryStream(zip))
{
using (var zs = GetGZipStream(ms, CompressionMode.Decompress, compressionLevel))
{
unzipLength = zs.Read(unzip, 0, unzipLength);
if (unzipLength <= 0)
{
return(null);
}
zs.Close();
}
}
var result = Encoding.UTF8.GetString(unzip);
return(result);
}
/// <summary>
/// Creates method options by merging together the settings the specificed <see cref="GrpcServiceOptions"/> collection.
/// The <see cref="GrpcServiceOptions"/> should be ordered with items arranged in ascending order of precedence.
/// When interceptors from multiple options are merged together they will be executed in reverse order of precendence.
/// </summary>
/// <param name="serviceOptions">A collection of <see cref="GrpcServiceOptions"/> instances, arranged in ascending order of precedence.</param>
/// <returns>A new <see cref="MethodOptions"/> instanced with settings merged from specifid <see cref="GrpcServiceOptions"/> collection.</returns>
public static MethodOptions Create(IEnumerable <GrpcServiceOptions> serviceOptions)
{
// This is required to get ensure that service methods without any explicit configuration
// will continue to get the global configuration options
var resolvedCompressionProviders = new Dictionary <string, ICompressionProvider>(StringComparer.Ordinal);
var tempInterceptors = new List <InterceptorRegistration>();
int? maxSendMessageSize = null;
var maxSendMessageSizeConfigured = false;
int? maxReceiveMessageSize = GrpcServiceOptionsSetup.DefaultReceiveMaxMessageSize;
var maxReceiveMessageSizeConfigured = false;
bool? enableDetailedErrors = null;
string? responseCompressionAlgorithm = null;
CompressionLevel?responseCompressionLevel = null;
foreach (var options in serviceOptions.Reverse())
{
AddCompressionProviders(resolvedCompressionProviders, options.CompressionProviders);
tempInterceptors.InsertRange(0, options.Interceptors);
if (!maxSendMessageSizeConfigured && options._maxSendMessageSizeConfigured)
{
maxSendMessageSize = options.MaxSendMessageSize;
maxSendMessageSizeConfigured = true;
}
if (!maxReceiveMessageSizeConfigured && options._maxReceiveMessageSizeConfigured)
{
maxReceiveMessageSize = options.MaxReceiveMessageSize;
maxReceiveMessageSizeConfigured = true;
}
enableDetailedErrors ??= options.EnableDetailedErrors;
responseCompressionAlgorithm ??= options.ResponseCompressionAlgorithm;
responseCompressionLevel ??= options.ResponseCompressionLevel;
}
var interceptors = new InterceptorCollection();
interceptors.AddRange(tempInterceptors);
return(new MethodOptions
(
compressionProviders: resolvedCompressionProviders,
interceptors: interceptors,
maxSendMessageSize: maxSendMessageSize,
maxReceiveMessageSize: maxReceiveMessageSize,
enableDetailedErrors: enableDetailedErrors,
responseCompressionAlgorithm: responseCompressionAlgorithm,
responseCompressionLevel: responseCompressionLevel
));
}
// Initializes new entry
internal ZipArchiveEntry(ZipArchive archive, string entryName)
{
_archive = archive;
_originallyInArchive = false;
_diskNumberStart = 0;
_versionMadeByPlatform = CurrentZipPlatform;
_versionMadeBySpecification = ZipVersionNeededValues.Default;
_versionToExtract = ZipVersionNeededValues.Default; // this must happen before following two assignment
_generalPurposeBitFlag = 0;
CompressionMethod = CompressionMethodValues.Deflate;
_lastModified = DateTimeOffset.Now;
_compressedSize = 0; // we don't know these yet
_uncompressedSize = 0;
_externalFileAttr = 0;
_offsetOfLocalHeader = 0;
_storedOffsetOfCompressedData = null;
_crc32 = 0;
_compressedBytes = null;
_storedUncompressedData = null;
_currentlyOpenForWrite = false;
_everOpenedForWrite = false;
_outstandingWriteStream = null;
FullName = entryName;
_cdUnknownExtraFields = null;
_lhUnknownExtraFields = null;
_fileComment = null;
_compressionLevel = null;
if (_storedEntryNameBytes.Length > ushort.MaxValue)
{
throw new ArgumentException();
}
// grab the stream if we're in create mode
if (_archive.Mode == ZipArchiveMode.Create)
{
_archive.AcquireArchiveStream(this);
}
}
public static void ZLibCompress(Stream stream, Stream targetStream, CompressionLevel?level = null)
{
using (var zs = new ZLIBStream(targetStream, level ?? CompressionLevel.Optimal, true)) {
int bytesLeidos = 0;
byte[] buffer = new byte[1024];
stream.Seek(0, SeekOrigin.Begin);
while ((bytesLeidos = stream.Read(buffer, 0, buffer.Length)) > 0)
{
zs.Write(buffer, 0, bytesLeidos);
}
}
using (var bw = new BinaryWriter(targetStream))
bw.Write((uint)stream.Length);
}
private static IDeflater CreateDeflater(CompressionLevel?compressionLevel)
{
switch (GetDeflaterType())
{
case WorkerType.Managed:
return(new DeflaterManaged());
default:
// We do not expect this to ever be thrown.
// But this is better practice than returning null.
#if NETFX_CORE
throw new Exception("Program entered an unexpected state.");
#else
throw new SystemException("Program entered an unexpected state.");
#endif
}
}
protected ImageOptions GenerateImageOptions(
ImageConfiguration configuration,
Imaging.ImageFormat imageFormat,
ImageDimensions imageDimensions)
{
CompressionLevel?compressionLevel = null;
if (CanUseImageFormatCompression(configuration) && !configuration.HasEmbeddedImage)
{
compressionLevel = configuration.Compression.Level;
}
else if (configuration.HasEmbeddedImage && imageFormat.SupportsCompression)
{
compressionLevel = CompressionLevel.Standard;
}
return(new ImageOptions(compressionLevel, imageDimensions));
}
public static MethodOptions CreateMethodOptions(
List <ICompressionProvider>?compressionProviders = null,
string?responseCompressionAlgorithm = null,
CompressionLevel?responseCompressionLevel = null,
int?maxSendMessageSize = null,
int?maxReceiveMessageSize = null,
InterceptorCollection?interceptors = null)
{
var serviceOptions = new GrpcServiceOptions();
serviceOptions.CompressionProviders = compressionProviders ?? new List <ICompressionProvider>();
serviceOptions.Interceptors.AddRange(interceptors ?? new InterceptorCollection());
serviceOptions.MaxSendMessageSize = maxSendMessageSize;
serviceOptions.MaxReceiveMessageSize = maxReceiveMessageSize;
serviceOptions.ResponseCompressionAlgorithm = responseCompressionAlgorithm;
serviceOptions.ResponseCompressionLevel = responseCompressionLevel;
return(MethodOptions.Create(new[] { serviceOptions }));
}
internal static byte[] CompressMessage(string compressionEncoding, CompressionLevel?compressionLevel, List <ICompressionProvider> compressionProviders, byte[] messageData)
{
foreach (var compressionProvider in compressionProviders)
{
if (string.Equals(compressionEncoding, compressionProvider.EncodingName, StringComparison.Ordinal))
{
var output = new MemoryStream();
using (var compressionStream = compressionProvider.CreateCompressionStream(output, compressionLevel))
{
compressionStream.Write(messageData, 0, messageData.Length);
}
return(output.ToArray());
}
}
// Should never reach here
throw new InvalidOperationException($"Could not find compression provider for '{compressionEncoding}'.");
}
private ZipArchiveEntry DoCreateEntry(string entryName, CompressionLevel?compressionLevel)
{
if (entryName == null)
{
throw new ArgumentNullException("entryName");
}
if (string.IsNullOrEmpty(entryName))
{
throw new ArgumentException(Messages.CannotBeEmpty, "entryName");
}
if (this._mode == ZipArchiveMode.Read)
{
throw new NotSupportedException(Messages.CreateInReadMode);
}
this.ThrowIfDisposed();
ZipArchiveEntry zipArchiveEntry = (compressionLevel.HasValue ? new ZipArchiveEntry(this, entryName, compressionLevel.Value) : new ZipArchiveEntry(this, entryName));
this.AddEntry(zipArchiveEntry);
return(zipArchiveEntry);
}
public static MethodContext CreateMethodContext(
Dictionary <string, ICompressionProvider>?compressionProviders = null,
string?responseCompressionAlgorithm = null,
CompressionLevel?responseCompressionLevel = null,
int?maxSendMessageSize = null,
int?maxReceiveMessageSize = null,
InterceptorCollection?interceptors = null)
{
return(new MethodContext
(
requestType: typeof(object),
responseType: typeof(object),
compressionProviders: compressionProviders ?? new Dictionary <string, ICompressionProvider>(),
interceptors: interceptors ?? new InterceptorCollection(),
maxSendMessageSize: maxSendMessageSize,
maxReceiveMessageSize: maxReceiveMessageSize,
enableDetailedErrors: null,
responseCompressionAlgorithm: responseCompressionAlgorithm,
responseCompressionLevel: responseCompressionLevel
));
}
private void CopyEntries(ArcArchive inputArchive, ArcArchive outputArchive, IProgress?progress)
{
foreach (var inputEntry in inputArchive.GetEntries())
{
progress?.SetMessage(inputEntry.Name);
CompressionLevel?compressionLevel = PreserveStore && (int)inputEntry.EntryType == 1
? CompressionLevel.NoCompression
: (CompressionLevel?)null;
var outputEntry = outputArchive.CreateEntry(inputEntry.Name);
{
using var inputStream = inputEntry.Open();
using var outputStream = outputEntry.OpenWrite(compressionLevel);
CopyStream(inputStream, outputStream, progress);
}
outputEntry.Timestamp = inputEntry.Timestamp;
}
}
private Stream GetCompressionStream(Stream innerStream, CompressionType compressionType,
CompressionMode compressionMode, CompressionLevel?compressionLevel)
{
switch (compressionType)
{
case CompressionType.Gzip:
switch (compressionMode)
{
case CompressionMode.Compress:
return(compressionLevel == null
? new GZipStream(innerStream, CompressionMode.Compress)
: new GZipStream(innerStream, compressionLevel.Value, true));
case CompressionMode.Decompress:
return(new GZipStream(innerStream, CompressionMode.Decompress, true));
default:
throw new ArgumentOutOfRangeException(nameof(compressionMode), compressionMode, null);
}
case CompressionType.Deflate:
switch (compressionMode)
{
case CompressionMode.Compress:
return(compressionLevel == null
? new DeflateStream(innerStream, CompressionMode.Compress)
: new DeflateStream(innerStream, compressionLevel.Value, true));
case CompressionMode.Decompress:
return(new DeflateStream(innerStream, CompressionMode.Decompress, true));
default:
throw new ArgumentOutOfRangeException(nameof(compressionMode), compressionMode, null);
}
default:
throw new ArgumentOutOfRangeException(nameof(compressionType), compressionType, null);
}
}
private static IDeflater CreateDeflater(CompressionLevel?compressionLevel)
{
switch (GetDeflaterType())
{
case WorkerType.Managed:
return(new DeflaterManaged());
case WorkerType.ZLib:
if (compressionLevel.HasValue)
{
return(new DeflaterZLib(compressionLevel.Value));
}
else
{
return(new DeflaterZLib());
}
default:
// We do not expect this to ever be thrown.
// But this is better practice than returning null.
throw new SystemException("Program entered an unexpected state.");
}
}
private byte[] CompressInternal(byte[] data, CompressionType compressionType,
CompressionLevel?compressionLevel)
{
if (compressionType == CompressionType.None)
{
return(data);
}
if (data.Length == 0)
{
return(new byte[0]);
}
using (var memStream = new MemoryStream())
{
var compressionStream = GetCompressionStream(memStream, compressionType, CompressionMode.Compress,
compressionLevel);
using (compressionStream)
{
compressionStream.Write(data, 0, data.Length);
}
return(memStream.ToArray());
}
}
// Initializes, attaches it to archive
internal ReadOnlyZipArchiveEntry(ReadOnlyZipArchive archive, ZipCentralDirectoryFileHeader cd)
{
_archive = archive;
_originallyInArchive = true;
_diskNumberStart = cd.DiskNumberStart;
_versionMadeByPlatform = ( ZipVersionMadeByPlatform )cd.VersionMadeByCompatibility;
_versionMadeBySpecification = ( ZipVersionNeededValues )cd.VersionMadeBySpecification;
_versionToExtract = ( ZipVersionNeededValues )cd.VersionNeededToExtract;
_generalPurposeBitFlag = ( BitFlagValues )cd.GeneralPurposeBitFlag;
CompressionMethod = ( CompressionMethodValues )cd.CompressionMethod;
_lastModified = new DateTimeOffset(ZipHelper.DosTimeToDateTime(cd.LastModified));
_compressedSize = cd.CompressedSize;
_uncompressedSize = cd.UncompressedSize;
_externalFileAttr = cd.ExternalFileAttributes;
_offsetOfLocalHeader = cd.RelativeOffsetOfLocalHeader;
// we don't know this yet: should be _offsetOfLocalHeader + 30 + _storedEntryNameBytes.Length + extrafieldlength
// but entryname/extra length could be different in LH
_storedOffsetOfCompressedData = null;
_crc32 = cd.Crc32;
_compressedBytes = null;
_storedUncompressedData = null;
_currentlyOpenForWrite = false;
_everOpenedForWrite = false;
_outstandingWriteStream = null;
FullName = DecodeEntryName(cd.Filename);
_lhUnknownExtraFields = null;
// the cd should have these as null if we aren't in Update mode
_cdUnknownExtraFields = cd.ExtraFields;
_fileComment = cd.FileComment;
_compressionLevel = null;
}
//Initializes new entry
internal ZipArchiveEntry(ZipArchive archive, String entryName, CompressionLevel compressionLevel)
: this(archive, entryName)
{
// Checking of compressionLevel is passed down to DeflateStream and the IDeflater implementation
// as it is a pugable component that completely encapsulates the meaning of compressionLevel.
_compressionLevel = compressionLevel;
}
//Initializes, attaches it to archive
internal ZipArchiveEntry(ZipArchive archive, ZipCentralDirectoryFileHeader cd)
{
_archive = archive;
_originallyInArchive = true;
_diskNumberStart = cd.DiskNumberStart;
_versionMadeByPlatform = (ZipVersionMadeByPlatform)cd.VersionMadeByCompatibility;
_versionMadeBySpecification = (ZipVersionNeededValues)cd.VersionMadeBySpecification;
_versionToExtract = (ZipVersionNeededValues)cd.VersionNeededToExtract;
_generalPurposeBitFlag = (BitFlagValues)cd.GeneralPurposeBitFlag;
CompressionMethod = (CompressionMethodValues)cd.CompressionMethod;
_lastModified = new DateTimeOffset(ZipHelper.DosTimeToDateTime(cd.LastModified));
_compressedSize = cd.CompressedSize;
_uncompressedSize = cd.UncompressedSize;
_offsetOfLocalHeader = cd.RelativeOffsetOfLocalHeader;
/* we don't know this yet: should be _offsetOfLocalHeader + 30 + _storedEntryNameBytes.Length + extrafieldlength
* but entryname/extra length could be different in LH
*/
_storedOffsetOfCompressedData = null;
_crc32 = cd.Crc32;
_compressedBytes = null;
_storedUncompressedData = null;
_currentlyOpenForWrite = false;
_everOpenedForWrite = false;
_outstandingWriteStream = null;
FullName = DecodeEntryName(cd.Filename);
_lhUnknownExtraFields = null;
//the cd should have these as null if we aren't in Update mode
_cdUnknownExtraFields = cd.ExtraFields;
_fileComment = cd.FileComment;
_compressionLevel = null;
}
//Initializes, attaches it to archive
internal ZipArchiveEntry(ZipArchive archive, ZipCentralDirectoryFileHeader cd, CompressionLevel compressionLevel)
: this(archive, cd)
{
_compressionLevel = compressionLevel;
}
//Initializes new entry
internal ZipArchiveEntry(ZipArchive archive, String entryName)
{
_archive = archive;
_originallyInArchive = false;
_diskNumberStart = 0;
_versionMadeByPlatform = CurrentZipPlatform;
_versionMadeBySpecification = ZipVersionNeededValues.Default;
_versionToExtract = ZipVersionNeededValues.Default; //this must happen before following two assignment
_generalPurposeBitFlag = 0;
CompressionMethod = CompressionMethodValues.Deflate;
_lastModified = DateTimeOffset.Now;
_compressedSize = 0; //we don't know these yet
_uncompressedSize = 0;
_offsetOfLocalHeader = 0;
_storedOffsetOfCompressedData = null;
_crc32 = 0;
_compressedBytes = null;
_storedUncompressedData = null;
_currentlyOpenForWrite = false;
_everOpenedForWrite = false;
_outstandingWriteStream = null;
FullName = entryName;
_cdUnknownExtraFields = null;
_lhUnknownExtraFields = null;
_fileComment = null;
_compressionLevel = null;
if (_storedEntryNameBytes.Length > UInt16.MaxValue)
throw new ArgumentException(SR.EntryNamesTooLong);
//grab the stream if we're in create mode
if (_archive.Mode == ZipArchiveMode.Create)
{
_archive.AcquireArchiveStream(this);
}
}
//Initializes new entry
internal ZipArchiveEntry(ZipArchive archive, String entryName, CompressionLevel compressionLevel)
: this(archive, entryName)
{
_compressionLevel = compressionLevel;
}
