OfficeDev
diff --git a/‎.gitignore‎
Lines changed: 7 additions & 1 deletion b/‎.gitignore‎
Lines changed: 7 additions & 1 deletion
diff --git a/‎FSSHTTPWOPIInspector/Source/FSSHTTPandWOPIInspector.csproj‎
Lines changed: 9 additions & 1 deletion b/‎FSSHTTPWOPIInspector/Source/FSSHTTPandWOPIInspector.csproj‎
Lines changed: 9 additions & 1 deletion
diff --git a/‎FSSHTTPWOPIInspector/Test/WOPIautomation/WOPIautomation/WOPIautomation.csproj‎
Lines changed: 1 addition & 0 deletions b/‎FSSHTTPWOPIInspector/Test/WOPIautomation/WOPIautomation/WOPIautomation.csproj‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎MAPIInspector/Source/BlockParser/BinaryParser.cs‎
Lines changed: 188 additions & 0 deletions b/‎MAPIInspector/Source/BlockParser/BinaryParser.cs‎
Lines changed: 188 additions & 0 deletions
diff --git a/‎MAPIInspector/Source/BlockParser/Block.cs‎
Lines changed: 156 additions & 0 deletions b/‎MAPIInspector/Source/BlockParser/Block.cs‎
Lines changed: 156 additions & 0 deletions
@@ -13,4 +13,10 @@
 /FSSHTTPWOPIInspector/Test/WOPIautomation/WOPIautomation/obj/
 /MAPIInspector/Test/MAPIAutomationTest/.vs/
 /MAPIInspector/Test/MAPIAutomationTest/MAPIAutomationTest/bin/
-/MAPIInspector/Test/MAPIAutomationTest/MAPIAutomationTest/obj/
+/MAPIInspector/Test/MAPIAutomationTest/MAPIAutomationTest/obj/
+/MAPIInspector/Source/BlockParser/bin/
+/MAPIInspector/Source/BlockParser/obj/
+/MAPIInspector/Source/BlockParserTests/bin/
+/MAPIInspector/Source/BlockParserTests/obj/
+/MAPIInspector/Source/packages/
+/MAPIInspector/Source/TestResults/
@@ -10,8 +10,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>FSSHTTPandWOPIInspector</RootNamespace>
     <AssemblyName>FSSHTTPandWOPIFiddlerInspector</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
     <FileUpgradeFlags>
     </FileUpgradeFlags>
     <OldToolsVersion>3.5</OldToolsVersion>
@@ -36,6 +37,10 @@
     <SccLocalPath>SAK</SccLocalPath>
     <SccAuxPath>SAK</SccAuxPath>
     <SccProvider>SAK</SccProvider>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
   </PropertyGroup>
   <PropertyGroup>
     <FiddlerPath Condition="$(FiddlerPath) == '' AND Exists('$(LocalAppData)\Programs\Fiddler\Fiddler.exe')">$(LocalAppData)\Programs\Fiddler</FiddlerPath>
@@ -155,6 +160,9 @@
       <DependentUpon>FSSHTTPAndWOPIControl.cs</DependentUpon>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>start "CopyDLLs" /B /wait start xcopy "$(SolutionDir)$(OutDir)*.*" "$(FiddlerPath)\Inspectors" /Q /Y</PostBuildEvent>
 
@@ -10,6 +10,7 @@
     <AssemblyName>WOPIautomation</AssemblyName>
     <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
 
@@ -0,0 +1,188 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace BlockParser
+{
+    /// <summary>
+    /// Helper class for parsing binary data from a stream or buffer, 
+    /// providing safe access and offset management, including support for artificial caps.
+    /// </summary>
+    public class BinaryParser
+    {
+        /// <summary>
+        /// Gets whether the parser has reached the end of the buffer.
+        /// </summary>
+        public bool Empty => Offset == size;
+
+        /// <summary>
+        /// Gets or sets the current offset within the buffer.
+        /// </summary>
+        public int Offset { get; set; }
+
+        /// <summary>
+        /// Gets the number of bytes remaining from the current offset to the end of the buffer.
+        /// Returns 0 if the offset is out of bounds.
+        /// </summary>
+        public int RemainingBytes => Offset > size ? 0 : size - Offset;
+
+        private readonly byte[] bin;
+        private int size; // When uncapped, this is bin.Length. When capped, this is our artificial capped size.
+        private readonly Stack<int> sizes = new Stack<int>();
+
+        /// <summary>
+        /// Initializes a new, empty BinaryParser.
+        /// </summary>
+        public BinaryParser()
+        {
+            bin = Array.Empty<byte>();
+            size = 0;
+            Offset = 0;
+        }
+
+        /// <summary>
+        /// Initializes a BinaryParser with a byte array and a specified count.
+        /// If the array is longer than the count, only the first count bytes are used.
+        /// </summary>
+        /// <param name="cb">The number of bytes to use from the array.</param>
+        /// <param name="_bin">The byte array to parse.</param>
+        public BinaryParser(int cb, byte[] _bin)
+        {
+            if (_bin != null && cb > 0)
+            {
+                if (_bin.Length > cb)
+                {
+                    bin = new byte[cb];
+                    Buffer.BlockCopy(_bin, 0, bin, 0, cb);
+                }
+                else
+                {
+                    bin = new byte[_bin.Length];
+                    Buffer.BlockCopy(_bin, 0, bin, 0, _bin.Length);
+                }
+            }
+            else
+            {
+                bin = Array.Empty<byte>();
+            }
+
+            size = bin.Length;
+            Offset = 0;
+        }
+
+        /// <summary>
+        /// Initializes a BinaryParser with a byte array.
+        /// </summary>
+        /// <param name="_bin">The byte array to parse.</param>
+        public BinaryParser(byte[] _bin)
+        {
+            if (_bin != null)
+            {
+                bin = new byte[_bin.Length];
+                Buffer.BlockCopy(_bin, 0, bin, 0, _bin.Length);
+            }
+            else
+            {
+                bin = Array.Empty<byte>();
+            }
+
+            size = bin.Length;
+            Offset = 0;
+        }
+
+        /// <summary>
+        /// Advances the current offset by the specified number of bytes.
+        /// </summary>
+        /// <param name="cb">The number of bytes to advance.</param>
+        public void Advance(int cb) => Offset += cb;
+
+        /// <summary>
+        /// Resets the current offset to the beginning of the buffer.
+        /// </summary>
+        public void Rewind() => Offset = 0;
+
+        /// <summary>
+        /// Pushes a cap onto the size stack, limiting the accessible buffer size to the current offset plus the specified cap.
+        /// Used to temporarily restrict parsing to a subsection of the buffer.
+        /// </summary>
+        /// <param name="cap">The number of bytes to cap from the current offset.</param>
+        public void PushCap(int cap)
+        {
+            sizes.Push(size);
+            if (cap != 0 && Offset + cap < bin.Length)
+            {
+                size = Offset + cap;
+            }
+        }
+
+        /// <summary>
+        /// Pops the most recent cap from the size stack, restoring the previous accessible buffer size.
+        /// </summary>
+        public void PopCap()
+        {
+            if (sizes.Count == 0)
+            {
+                size = bin.Length;
+            }
+            else
+            {
+                size = sizes.Pop();
+            }
+        }
+
+        /// <summary>
+        /// Checks if the specified number of bytes can be read from the current offset without exceeding the buffer.
+        /// </summary>
+        /// <param name="cb">The number of bytes to check.</param>
+        /// <returns>True if the bytes can be read; otherwise, false.</returns>
+        public bool CheckSize(int cb) => cb <= RemainingBytes;
+
+        /// <summary>
+        /// Reads the specified number of bytes from the current offset in the binary stream.
+        /// Advances the offset by the number of bytes read.
+        /// If there are not enough bytes remaining, returns an empty array.
+        /// </summary>
+        /// <param name="cb">The number of bytes to read.</param>
+        /// <returns>
+        /// A byte array containing the bytes read, or an empty array if there are not enough bytes remaining.
+        /// </returns>
+        public byte[] ReadBytes(int cb)
+        {
+            if (CheckSize(cb))
+            {
+                byte[] bytes = new byte[cb];
+                Buffer.BlockCopy(bin, Offset, bytes, 0, cb);
+                Advance(cb);
+                return bytes;
+            }
+
+            return Array.Empty<byte>();
+        }
+
+        /// <summary>
+        /// Returns the entire binary stream as a hexadecimal string.
+        /// Only used for debugging purposes.
+        /// </summary>
+        /// <returns>A string representation of the binary data in hexadecimal format.</returns>
+        public string PeekBytes()
+        {
+            return Strings.BinToHexString(bin, bin.Length);
+        }
+
+        /// <summary>
+        /// Outputs a sample of bytes from the current offset in the binary stream to the debug output.
+        /// Only used for debugging purposes.
+        /// </summary>
+        /// <param name="cb">The number of bytes to output (default is 20).</param>
+        public void SampleBytes(int cb = 20)
+        {
+            var offset = Offset;
+            var length = Math.Min(cb, RemainingBytes);
+            var _data = ReadBytes(length);
+            var hex = Strings.BinToHexString(_data, 0);
+            var text = Strings.BinToTextStringA(_data, true);
+            Debug.WriteLine($"cb: 0x{length:X}={length} lpb: {hex}={text}");
+            Offset = offset;
+        }
+    }
+}
@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.IO;
+
+namespace BlockParser
+{
+    // TODO: Make use of these
+    public static class Constants
+    {
+        public const uint _MaxBytes = 0xFFFF;
+        public const uint _MaxDepth = 25;
+        public const uint _MaxEID = 500;
+        public const uint _MaxEntriesSmall = 500;
+        public const uint _MaxEntriesLarge = 1000;
+        public const uint _MaxEntriesExtraLarge = 1500;
+        public const uint _MaxEntriesEnormous = 10000;
+    }
+
+    public abstract partial class Block
+    {
+        public long Size { get; set; }
+        public long Offset { get; set; }
+        private string _text;
+        public string Text
+        {
+            get => _text;
+            set => _text = value ?? "";
+        }
+        public uint Source
+        {
+            get => _source;
+            set
+            {
+                _source = value;
+                foreach (var child in Children)
+                {
+                    child.Source = value;
+                }
+            }
+        }
+
+        public IReadOnlyList<Block> Children => children.AsReadOnly();
+        public bool IsHeader => Size == 0 && Offset == 0;
+        public bool HasData => !string.IsNullOrEmpty(Text) || Children.Count > 0;
+
+        protected BinaryParser parser;
+        public bool Parsed { get; protected set; } = false;
+        protected bool EnableJunk { get; set; } = true;
+        protected virtual bool UsePipes() => false;
+
+        private List<Block> children { get; } = new List<Block>();
+        private uint _source;
+
+        // Overrides
+        /// <summary>
+        /// When implemented in a derived class, parses the current block from the associated <see cref="BinaryParser"/>.
+        /// This method should set up the block's data and state based on the binary input.
+        /// </summary>
+        protected abstract void Parse();
+        /// <summary>
+        /// When overridden in a derived class, parses and adds any child blocks to this block, building a tree of blocks
+        /// No default implementation is provided, as this method is expected to be specific to the derived class's structure.
+        /// Do NOT attempt to parse data from the stream or parser here; that should be done in the <see cref="Parse"/> method.
+        /// </summary>
+        protected abstract void ParseBlocks();
+
+        public void ShiftOffset(long shift)
+        {
+            Offset += shift;
+            foreach (var child in Children)
+            {
+                child.ShiftOffset(shift);
+            }
+        }
+
+        public void Parse(BinaryParser parser, bool enableJunk = false) => Parse(parser, 0, enableJunk);
+
+        private void Parse(BinaryParser parser, int cbBin, bool enableJunk = false)
+        {
+            this.parser = parser;
+            parser.PushCap(cbBin);
+            EnableJunk = enableJunk;
+            EnsureParsed();
+            parser.PopCap();
+        }
+
+        protected void EnsureParsed()
+        {
+            if (!Parsed && parser != null && !parser.Empty)
+            {
+                Parsed = true; // parse can unset this if needed
+                Offset = parser.Offset;
+
+                // Parse and ParseBlocks are seperate so that if one throws an exception, the other can still
+                // run and we can still get the tree layout, even if the data parsing failed.
+                try
+                {
+                    Parse();
+                }
+                catch (System.Exception e)
+                {
+                    var typeName = e.GetType().FullName;
+                    if (typeName == "MAPIInspector.Parsers.MissingInformationException") throw e;
+                    if (typeName == "MAPIInspector.Parsers.MissingPartialInformationException") throw e;
+                    children.Add(BlockException.Create("Buffer Parsing Exception", e, Offset));
+                }
+
+                // Compute Size so ParseBlocks can use it
+                Size = parser.Offset - Offset;
+
+                try
+                {
+                    ParseBlocks();
+                }
+                catch (System.Exception e)
+                {
+                    children.Add(BlockException.Create("Tree Layout Exception", e, Offset));
+                }
+
+                if (HasData && EnableJunk && parser.RemainingBytes > 0)
+                {
+                    AddChild(ParseJunk("Unparsed data"));
+                }
+
+                // Recompute Size just in case ParseBlocks changed it
+                Size = parser.Offset - Offset;
+            }
+        }
+
+        // This is purely for testing now
+        public string FullString()
+        {
+            EnsureParsed();
+            var stringArray = ToStringsInternal();
+            var _stringBlock = Strings.TrimWhitespace(string.Join(string.Empty, stringArray));
+            _stringBlock = _stringBlock.Replace('\0', '.');
+            return _stringBlock;
+        }
+
+        public override string ToString() => Text;
+
+        private List<string> ToStringsInternal()
+        {
+            var strings = new List<string>(Children.Count + 1);
+            if (!string.IsNullOrEmpty(Text)) strings.Add(Text + "\r\n");
+
+            foreach (var child in Children)
+            {
+                var childStrings = child.ToStringsInternal();
+                if (!string.IsNullOrEmpty(Text)) childStrings = Strings.TabStrings(childStrings, UsePipes());
+                strings.AddRange(childStrings);
+            }
+
+            return strings;
+        }
+    }
+}