Unable to process LTTng trace on .NET 6.0 (#103)

* Fix for breaking change in .NET 6.0 that broke LTTng parser - Partial and zero-byte reads in DeflateStream - https://learn.microsoft.com/en-us/dotnet/core/compatibility/core-libraries/6.0/partial-byte-reads-in-streams

* Upgrade to Antlr runtime 4.11.1 in hopes it fixed this issue (it didn't). Also fixes build failure during upgrade per kaby76/Antlr4BuildTasks#31

* Upgrade all other Nugets as well

Author: ivberg

CtfPlayback/CtfPlayback.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
-	<Version>1.2.2</Version>
+	<Version>1.2.3</Version>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <Authors>Microsoft</Authors>
     <Company>Microsoft Corp.</Company>
@@ -40,7 +40,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Antlr4.Runtime.Standard" Version="4.9.3" GeneratePathProperty="true" />
+    <PackageReference Include="Antlr4.Runtime.Standard" Version="4.11.1" GeneratePathProperty="true" />
   </ItemGroup>
 
   <ItemGroup>

CtfPlayback/Helpers/StreamExts.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+
+namespace CtfPlayback.Helpers
+{
+    internal static class StreamExts
+    {
+        /// <summary>
+        /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
+        /// Keeps behavior of pre .NET 6.0 code which reads until count is reached or EOF
+        /// .NET 6.0 breaking change - https://learn.microsoft.com/en-us/dotnet/core/compatibility/core-libraries/6.0/partial-byte-reads-in-streams - bytes read can be less than what was requested
+        /// </summary>
+        /// <param name="stream">The stream to read from</param>
+        /// <param name="buffer">
+        /// An array of bytes. When this method returns, the buffer contains the specified
+        ///     byte array with the values between offset and (offset + count - 1) replaced by
+        ///     the bytes read from the current source.
+        /// </param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The number of bytes to be read from the current stream.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be zero (0) if the end of the stream has been reached.</returns>
+        public static int ReadUntilBytesRequested(this Stream stream, byte[] buffer, int offset, int count)
+        {
+            int read = stream.Read(buffer, offset, count);
+            if (read == 0)
+            {
+                return 0;
+            }
+
+            if (read != count) // .NET 6.0 breaking change - https://learn.microsoft.com/en-us/dotnet/core/compatibility/core-libraries/6.0/partial-byte-reads-in-streams - bytes read can be less than what was requested
+            {
+                while (read < buffer.Length) // Keep reading until we fill up our buffer to the count
+                {
+                    int tmpBytesRead = stream.Read(buffer.AsSpan().Slice(read));
+                    if (tmpBytesRead == 0) break;
+                    read += tmpBytesRead;
+                }
+            }
+
+            return read;
+        }
+    }
+}

CtfPlayback/Metadata/AntlrParser/CtfAntlrMetadataParser.cs

@@ -7,8 +7,8 @@
 using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Tree;
+using CtfPlayback.Helpers;
 using CtfPlayback.Metadata.Interfaces;
-using CtfReader.Metadata.AntlrParser;
 
 namespace CtfPlayback.Metadata.AntlrParser
 {
@@ -68,7 +68,9 @@ public ICtfMetadata Parse(Stream metadataStream)
         /// <param name="metadataStream">Metadata stream</param>
         /// <returns>String representation of the metadata</returns>
         private unsafe string GetMetadata(Stream metadataStream)
-        {
+        {
+            // See https://diamon.org/ctf/#spec7.1
+
             byte[] headerBuffer = new byte[Marshal.SizeOf(typeof(MetadataPacketHeader))];
             byte[] buffer = null;
 
@@ -81,8 +83,9 @@ private unsafe string GetMetadata(Stream metadataStream)
             var sb = new StringBuilder();
 
             while (true)
-            {
-                if (metadataStream.Read(headerBuffer, 0, headerBuffer.Length) != headerBuffer.Length)
+            {
+                int bytesRead = metadataStream.ReadUntilBytesRequested(headerBuffer, 0, headerBuffer.Length);
+                if (bytesRead == 0)
                 {
                     break;
                 }
@@ -95,7 +98,7 @@ private unsafe string GetMetadata(Stream metadataStream)
 
                 // todo:check the endianness based on the magic number
 
-                if (header.Magic == 0x75d11d57) // CTF: Magic Header for binary metadata streams
+                if (header.Magic == 0x75d11d57) // CTF: Magic Header for binary metadata streams // 1976638807
                 {
                     int packetSize = (int) header.PacketSize / 8 - headerBuffer.Length;
 
@@ -104,19 +107,19 @@ private unsafe string GetMetadata(Stream metadataStream)
                         buffer = new byte[packetSize];
                     }
 
-                    int read = metadataStream.Read(buffer, 0, packetSize);
+                    int read = metadataStream.ReadUntilBytesRequested(buffer, 0, packetSize);
                     if (read == 0)
                     {
-                        break;
+                        throw new InvalidDataException($"Metadata stream seems to be corrupt. We read 0 bytes when we expected packetSize:{packetSize} bytes.");
                     }
 
                     int contentSize = (int) header.ContentSize / 8 - headerBuffer.Length;
-                    if (contentSize < read)
-                    {
-                        read = contentSize;
-                    }
-
-                    string result = Encoding.ASCII.GetString(buffer, 0, read);
+                    if (read < contentSize)
+                    {
+                        throw new InvalidDataException($"Metadata stream seems to be corrupt. We read {read} packetSize bytes but the header says there should be {contentSize} bytes.");
+                    }
+
+                    string result = Encoding.ASCII.GetString(buffer, 0, contentSize);
 
                     sb.Append(result);
                 }
@@ -141,7 +144,7 @@ private unsafe string GetMetadata(Stream metadataStream)
                     }
                 }
             }
-
+            
             return sb.ToString();
         }
 

CtfPlayback/Metadata/AntlrParser/Generated/CtfBaseListener.cs

@@ -1,16 +1,14 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     ANTLR Version: 4.7.2
+//     ANTLR Version: 4.11.1
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-// Generated from Ctf.g4 by ANTLR 4.7.2
+// Generated from Ctf.g4 by ANTLR 4.11.1
 
 // Unreachable code detected
 #pragma warning disable 0162
@@ -33,7 +31,8 @@
 /// which can be extended to create a listener which only needs to handle a subset
 /// of the available methods.
 /// </summary>
-[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")]
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.11.1")]
+[System.Diagnostics.DebuggerNonUserCode]
 [System.CLSCompliant(false)]
 public partial class CtfBaseListener : ICtfListener {
 	/// <summary>