0.6.5: Prevent context release during compression/decompression if Dispose is not called

oleg-st · oleg-st · commit d1bcfeab1c95 · 2022-11-14T17:23:04.000+03:00
diff --git a/src/ZstdSharp/Compressor.cs b/src/ZstdSharp/Compressor.cs
@@ -11,6 +11,12 @@ public unsafe class Compressor : IDisposable
 
         private int level = DefaultCompressionLevel;
 
+        /*
+         * We have a finalizer that releases cctx (to prevent memory leaks if Disposed is not called),
+         * so we need to delay running the object's finalizer when dealing with cctx inside our methods.
+         * For this purpose we use GC.KeepAlive(this)
+         * For reference: https://devblogs.microsoft.com/oldnewthing/20100813-00/?p=13153
+         */
         private ZSTD_CCtx_s* cctx;
 
         public int Level
@@ -30,20 +36,22 @@ public void SetParameter(ZSTD_cParameter parameter, int value)
         {
             EnsureNotDisposed();
             Methods.ZSTD_CCtx_setParameter(cctx, parameter, value).EnsureZstdSuccess();
+            GC.KeepAlive(this);
         }
 
         public int GetParameter(ZSTD_cParameter parameter)
         {
             EnsureNotDisposed();
             int value;
             Methods.ZSTD_CCtx_getParameter(cctx, parameter, &value).EnsureZstdSuccess();
+            GC.KeepAlive(this);
             return value;
         }
 
         public void LoadDictionary(byte[] dict)
         {
             var dictReadOnlySpan = new ReadOnlySpan<byte>(dict);
-            this.LoadDictionary(dictReadOnlySpan);
+            LoadDictionary(dictReadOnlySpan);
         }
 
         public void LoadDictionary(ReadOnlySpan<byte> dict)
@@ -59,6 +67,7 @@ public void LoadDictionary(ReadOnlySpan<byte> dict)
                 fixed (byte* dictPtr = dict)
                     Methods.ZSTD_CCtx_loadDictionary(cctx, dictPtr, (nuint) dict.Length).EnsureZstdSuccess();
             }
+            GC.KeepAlive(this);
         }
 
         public Compressor(int level = DefaultCompressionLevel)
@@ -96,9 +105,13 @@ public int Wrap(ReadOnlySpan<byte> src, Span<byte> dest)
             EnsureNotDisposed();
             fixed (byte* srcPtr = src)
             fixed (byte* destPtr = dest)
-                return (int) Methods
+            {
+                var returnValue = (int) Methods
                     .ZSTD_compress2(cctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length)
                     .EnsureZstdSuccess();
+                GC.KeepAlive(this);
+                return returnValue;
+            }
         }
 
         public int Wrap(ArraySegment<byte> src, ArraySegment<byte> dest) 
@@ -118,6 +131,7 @@ public bool TryWrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)
             {
                 var returnValue =
                     Methods.ZSTD_compress2(cctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length);
+                GC.KeepAlive(this);
 
                 if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))
                 {
@@ -163,7 +177,9 @@ internal nuint CompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s ou
             fixed (ZSTD_inBuffer_s* inputPtr = &input)
             fixed (ZSTD_outBuffer_s* outputPtr = &output)
             {
-                return Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive).EnsureZstdSuccess();
+                var returnValue = Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive).EnsureZstdSuccess();
+                GC.KeepAlive(this);
+                return returnValue;
             }
         }
     }
diff --git a/src/ZstdSharp/Decompressor.cs b/src/ZstdSharp/Decompressor.cs
@@ -5,6 +5,12 @@ namespace ZstdSharp
 {
     public unsafe class Decompressor : IDisposable
     {
+        /*
+         * We have a finalizer that releases dctx (to prevent memory leaks if Disposed is not called),
+         * so we need to delay running the object's finalizer when dealing with dctx inside our methods.
+         * For this purpose we use GC.KeepAlive(this)
+         * For reference: https://devblogs.microsoft.com/oldnewthing/20100813-00/?p=13153
+         */
         private ZSTD_DCtx_s* dctx;
 
         public Decompressor()
@@ -23,13 +29,15 @@ public void SetParameter(ZSTD_dParameter parameter, int value)
         {
             EnsureNotDisposed();
             Methods.ZSTD_DCtx_setParameter(dctx, parameter, value).EnsureZstdSuccess();
+            GC.KeepAlive(this);
         }
 
         public int GetParameter(ZSTD_dParameter parameter)
         {
             EnsureNotDisposed();
             int value;
             Methods.ZSTD_DCtx_getParameter(dctx, parameter, &value).EnsureZstdSuccess();
+            GC.KeepAlive(this);
             return value;
         }
 
@@ -51,6 +59,7 @@ public void LoadDictionary(ReadOnlySpan<byte> dict)
                 fixed (byte* dictPtr = dict)
                     Methods.ZSTD_DCtx_loadDictionary(dctx, dictPtr, (nuint) dict.Length).EnsureZstdSuccess();
             }
+            GC.KeepAlive(this);
         }
 
         public static ulong GetDecompressedSize(ReadOnlySpan<byte> src)
@@ -88,9 +97,13 @@ public int Unwrap(ReadOnlySpan<byte> src, Span<byte> dest)
             EnsureNotDisposed();
             fixed (byte* srcPtr = src)
             fixed (byte* destPtr = dest)
-                return (int) Methods
+            {
+                var returnValue = (int) Methods
                     .ZSTD_decompressDCtx(dctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length)
                     .EnsureZstdSuccess();
+                GC.KeepAlive(this);
+                return returnValue;
+            }
         }
 
         public int Unwrap(byte[] src, int srcOffset, int srcLength, byte[] dst, int dstOffset, int dstLength)
@@ -107,6 +120,7 @@ public bool TryUnwrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)
             {
                 var returnValue =
                     Methods.ZSTD_decompressDCtx(dctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length);
+                GC.KeepAlive(this);
 
                 if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))
                 {
@@ -148,7 +162,9 @@ internal nuint DecompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s
             fixed (ZSTD_inBuffer_s* inputPtr = &input)
             fixed (ZSTD_outBuffer_s* outputPtr = &output)
             {
-                return Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr).EnsureZstdSuccess();
+                var returnValue = Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr).EnsureZstdSuccess();
+                GC.KeepAlive(this);
+                return returnValue;
             }
         }
     }
diff --git a/src/ZstdSharp/ZstdSharp.csproj b/src/ZstdSharp/ZstdSharp.csproj
@@ -14,7 +14,7 @@
     <PackageProjectUrl>https://github.com/oleg-st/ZstdSharp</PackageProjectUrl>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <PackageTags>zstd zstandard port compression</PackageTags>
-    <Version>0.6.4</Version>
+    <Version>0.6.5</Version>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,12 @@ public unsafe class Compressor : IDisposable`
`11`	`11`
`12`	`12`	`private int level = DefaultCompressionLevel;`
`13`	`13`
	`14`	`+ /*`
	`15`	`+ * We have a finalizer that releases cctx (to prevent memory leaks if Disposed is not called),`
	`16`	`+ * so we need to delay running the object's finalizer when dealing with cctx inside our methods.`
	`17`	`+ * For this purpose we use GC.KeepAlive(this)`
	`18`	`+ * For reference: https://devblogs.microsoft.com/oldnewthing/20100813-00/?p=13153`
	`19`	`+ */`
`14`	`20`	`private ZSTD_CCtx_s* cctx;`
`15`	`21`
`16`	`22`	`public int Level`
`@@ -30,20 +36,22 @@ public void SetParameter(ZSTD_cParameter parameter, int value)`
`30`	`36`	`{`
`31`	`37`	`EnsureNotDisposed();`
`32`	`38`	`Methods.ZSTD_CCtx_setParameter(cctx, parameter, value).EnsureZstdSuccess();`
	`39`	`+ GC.KeepAlive(this);`
`33`	`40`	`}`
`34`	`41`
`35`	`42`	`public int GetParameter(ZSTD_cParameter parameter)`
`36`	`43`	`{`
`37`	`44`	`EnsureNotDisposed();`
`38`	`45`	`int value;`
`39`	`46`	`Methods.ZSTD_CCtx_getParameter(cctx, parameter, &value).EnsureZstdSuccess();`
	`47`	`+ GC.KeepAlive(this);`
`40`	`48`	`return value;`
`41`	`49`	`}`
`42`	`50`
`43`	`51`	`public void LoadDictionary(byte[] dict)`
`44`	`52`	`{`
`45`	`53`	`var dictReadOnlySpan = new ReadOnlySpan<byte>(dict);`
`46`		`- this.LoadDictionary(dictReadOnlySpan);`
	`54`	`+ LoadDictionary(dictReadOnlySpan);`
`47`	`55`	`}`
`48`	`56`
`49`	`57`	`public void LoadDictionary(ReadOnlySpan<byte> dict)`
`@@ -59,6 +67,7 @@ public void LoadDictionary(ReadOnlySpan<byte> dict)`
`59`	`67`	`fixed (byte* dictPtr = dict)`
`60`	`68`	`Methods.ZSTD_CCtx_loadDictionary(cctx, dictPtr, (nuint) dict.Length).EnsureZstdSuccess();`
`61`	`69`	`}`
	`70`	`+ GC.KeepAlive(this);`
`62`	`71`	`}`
`63`	`72`
`64`	`73`	`public Compressor(int level = DefaultCompressionLevel)`
`@@ -96,9 +105,13 @@ public int Wrap(ReadOnlySpan<byte> src, Span<byte> dest)`
`96`	`105`	`EnsureNotDisposed();`
`97`	`106`	`fixed (byte* srcPtr = src)`
`98`	`107`	`fixed (byte* destPtr = dest)`
`99`		`- return (int) Methods`
	`108`	`+ {`
	`109`	`+ var returnValue = (int) Methods`
`100`	`110`	`.ZSTD_compress2(cctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length)`
`101`	`111`	`.EnsureZstdSuccess();`
	`112`	`+ GC.KeepAlive(this);`
	`113`	`+ return returnValue;`
	`114`	`+ }`
`102`	`115`	`}`
`103`	`116`
`104`	`117`	`public int Wrap(ArraySegment<byte> src, ArraySegment<byte> dest)`
`@@ -118,6 +131,7 @@ public bool TryWrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)`
`118`	`131`	`{`
`119`	`132`	`var returnValue =`
`120`	`133`	`Methods.ZSTD_compress2(cctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length);`
	`134`	`+ GC.KeepAlive(this);`
`121`	`135`
`122`	`136`	`if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))`
`123`	`137`	`{`
`@@ -163,7 +177,9 @@ internal nuint CompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s ou`
`163`	`177`	`fixed (ZSTD_inBuffer_s* inputPtr = &input)`
`164`	`178`	`fixed (ZSTD_outBuffer_s* outputPtr = &output)`
`165`	`179`	`{`
`166`		`- return Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive).EnsureZstdSuccess();`
	`180`	`+ var returnValue = Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive).EnsureZstdSuccess();`
	`181`	`+ GC.KeepAlive(this);`
	`182`	`+ return returnValue;`
`167`	`183`	`}`
`168`	`184`	`}`
`169`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,12 @@ namespace ZstdSharp`
`5`	`5`	`{`
`6`	`6`	`public unsafe class Decompressor : IDisposable`
`7`	`7`	`{`
	`8`	`+ /*`
	`9`	`+ * We have a finalizer that releases dctx (to prevent memory leaks if Disposed is not called),`
	`10`	`+ * so we need to delay running the object's finalizer when dealing with dctx inside our methods.`
	`11`	`+ * For this purpose we use GC.KeepAlive(this)`
	`12`	`+ * For reference: https://devblogs.microsoft.com/oldnewthing/20100813-00/?p=13153`
	`13`	`+ */`
`8`	`14`	`private ZSTD_DCtx_s* dctx;`
`9`	`15`
`10`	`16`	`public Decompressor()`
`@@ -23,13 +29,15 @@ public void SetParameter(ZSTD_dParameter parameter, int value)`
`23`	`29`	`{`
`24`	`30`	`EnsureNotDisposed();`
`25`	`31`	`Methods.ZSTD_DCtx_setParameter(dctx, parameter, value).EnsureZstdSuccess();`
	`32`	`+ GC.KeepAlive(this);`
`26`	`33`	`}`
`27`	`34`
`28`	`35`	`public int GetParameter(ZSTD_dParameter parameter)`
`29`	`36`	`{`
`30`	`37`	`EnsureNotDisposed();`
`31`	`38`	`int value;`
`32`	`39`	`Methods.ZSTD_DCtx_getParameter(dctx, parameter, &value).EnsureZstdSuccess();`
	`40`	`+ GC.KeepAlive(this);`
`33`	`41`	`return value;`
`34`	`42`	`}`
`35`	`43`
`@@ -51,6 +59,7 @@ public void LoadDictionary(ReadOnlySpan<byte> dict)`
`51`	`59`	`fixed (byte* dictPtr = dict)`
`52`	`60`	`Methods.ZSTD_DCtx_loadDictionary(dctx, dictPtr, (nuint) dict.Length).EnsureZstdSuccess();`
`53`	`61`	`}`
	`62`	`+ GC.KeepAlive(this);`
`54`	`63`	`}`
`55`	`64`
`56`	`65`	`public static ulong GetDecompressedSize(ReadOnlySpan<byte> src)`
`@@ -88,9 +97,13 @@ public int Unwrap(ReadOnlySpan<byte> src, Span<byte> dest)`
`88`	`97`	`EnsureNotDisposed();`
`89`	`98`	`fixed (byte* srcPtr = src)`
`90`	`99`	`fixed (byte* destPtr = dest)`
`91`		`- return (int) Methods`
	`100`	`+ {`
	`101`	`+ var returnValue = (int) Methods`
`92`	`102`	`.ZSTD_decompressDCtx(dctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length)`
`93`	`103`	`.EnsureZstdSuccess();`
	`104`	`+ GC.KeepAlive(this);`
	`105`	`+ return returnValue;`
	`106`	`+ }`
`94`	`107`	`}`
`95`	`108`
`96`	`109`	`public int Unwrap(byte[] src, int srcOffset, int srcLength, byte[] dst, int dstOffset, int dstLength)`
`@@ -107,6 +120,7 @@ public bool TryUnwrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)`
`107`	`120`	`{`
`108`	`121`	`var returnValue =`
`109`	`122`	`Methods.ZSTD_decompressDCtx(dctx, destPtr, (nuint) dest.Length, srcPtr, (nuint) src.Length);`
	`123`	`+ GC.KeepAlive(this);`
`110`	`124`
`111`	`125`	`if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))`
`112`	`126`	`{`
`@@ -148,7 +162,9 @@ internal nuint DecompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s`
`148`	`162`	`fixed (ZSTD_inBuffer_s* inputPtr = &input)`
`149`	`163`	`fixed (ZSTD_outBuffer_s* outputPtr = &output)`
`150`	`164`	`{`
`151`		`- return Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr).EnsureZstdSuccess();`
	`165`	`+ var returnValue = Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr).EnsureZstdSuccess();`
	`166`	`+ GC.KeepAlive(this);`
	`167`	`+ return returnValue;`
`152`	`168`	`}`
`153`	`169`	`}`
`154`	`170`	`}`