U/sgriffin/roptransport (#219)

stephenegriffin · web-flow · commit ff9b23e25c88 · 2025-08-26T18:43:46.000Z
* Fix roptransportsend parsing

* fix junk label

* uncommenting fix so it works

* better search on root nodes

* handle no root node selection better
diff --git a/MAPIInspector/Source/BlockParser/BlockJunk.cs b/MAPIInspector/Source/BlockParser/BlockJunk.cs
@@ -5,7 +5,7 @@ namespace BlockParser
     public class BlockJunk : BlockInteresting
     {
         public override Color BackColor => Color.Coral;
-        public override string InterestingLabel => "Exceptions found in this block";
+        public override string InterestingLabel => "Extra data found in this block";
 
         string Label;
         BlockBytes junkData;
diff --git a/MAPIInspector/Source/MAPIControl.Events.cs b/MAPIInspector/Source/MAPIControl.Events.cs
@@ -314,18 +314,20 @@ private void PerformSearch(bool searchUp, bool searchFrames)
             if (string.IsNullOrEmpty(searchText) || searchText == SearchDefaultText) return;
 
             FiddlerApplication.UI.SetStatusText($"Searching for {searchText}");
+            var includeRoot = false; // Don't include the currently selected node for a seach
             var startNode = mapiTreeView?.SelectedNode;
             if (startNode == null && mapiTreeView?.Nodes.Count > 0)
             {
                 startNode = mapiTreeView.Nodes[0];
+                includeRoot = true; // But if no node was selected, incude whatever node we start from
             }
 
             if (startNode != null)
             {
                 var nodes = mapiTreeView.Nodes;
                 TreeNode foundNode = searchUp
-                    ? FindPrevNode(nodes, startNode, searchText, !searchFrames)
-                    : FindNextNode(nodes, startNode, searchText, !searchFrames);
+                    ? FindPrevNode(nodes, startNode, searchText, !searchFrames, includeRoot)
+                    : FindNextNode(nodes, startNode, searchText, !searchFrames, includeRoot);
 
                 if (foundNode != null)
                 {
@@ -338,6 +340,7 @@ private void PerformSearch(bool searchUp, bool searchFrames)
 
             if (searchFrames)
             {
+                includeRoot = true; // Now that we're searching new frames, always include the root node in our search
                 var currentSession = Inspector.session;
                 while (currentSession != null)
                 {
@@ -348,8 +351,8 @@ private void PerformSearch(bool searchUp, bool searchFrames)
                     var node = BaseStructure.AddBlock(parseResult, false);
                     rootNode.Nodes.Add(node);
                     var foundMatch = searchUp
-                        ? FindPrevNode(rootNode.Nodes, node, searchText, true)
-                        : FindNextNode(rootNode.Nodes, node, searchText, true);
+                        ? FindPrevNode(rootNode.Nodes, node, searchText, true, includeRoot)
+                        : FindNextNode(rootNode.Nodes, node, searchText, true, includeRoot);
                     if (foundMatch != null)
                     {
                         FiddlerApplication.UI.SelectSessionsMatchingCriteria(s => s.id == nextSession.id);
@@ -365,63 +368,84 @@ private void PerformSearch(bool searchUp, bool searchFrames)
         }
 
         // Find next node (downwards, wraps around)
-        private TreeNode FindNextNode(TreeNodeCollection nodes, TreeNode startNode, string searchText, bool wrap)
+        private TreeNode FindNextNode(TreeNodeCollection nodes, TreeNode startNode, string searchText, bool wrap, bool matchStartNode)
         {
-            bool foundStart = false;
-            TreeNode firstMatch = null;
-            foreach (var node in FlattenNodes(nodes))
+            var allNodes = FlattenNodes(nodes);
+            int startIndex = 0;
+            for (int i = 0; i < allNodes.Count; i++)
             {
-                if (node == startNode)
+                if (allNodes[i] == startNode)
                 {
-                    foundStart = true;
-                    continue;
+                    startIndex = i;
+                    break;
                 }
-
-                if (GetNodeText(node).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
+            }
+            // Search from startNode (inclusive/exclusive) to end
+            int first = matchStartNode ? startIndex : startIndex + 1;
+            for (int i = first; i < allNodes.Count; i++)
+            {
+                if (GetNodeText(allNodes[i]).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
+                    return allNodes[i];
+            }
+            // If wrap is enabled, search from beginning up to startNode (exclusive)
+            if (wrap)
+            {
+                for (int i = 0; i < startIndex; i++)
                 {
-                    if (foundStart)
-                        return node;
-                    if (firstMatch == null)
-                        firstMatch = node;
+                    if (GetNodeText(allNodes[i]).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
+                        return allNodes[i];
                 }
             }
-
-            return wrap ? firstMatch : null;
+            return null;
         }
 
         // Find previous node (upwards, wraps around)
-        private TreeNode FindPrevNode(TreeNodeCollection nodes, TreeNode startNode, string searchText, bool wrap)
+        private TreeNode FindPrevNode(TreeNodeCollection nodes, TreeNode startNode, string searchText, bool wrap, bool matchStartNode)
         {
-            TreeNode lastMatch = null;
-            foreach (var node in FlattenNodes(nodes))
+            var allNodes = FlattenNodes(nodes);
+            int startIndex = 0;
+            for (int i = 0; i < allNodes.Count; i++)
             {
-                if (node == startNode)
+                if (allNodes[i] == startNode)
+                {
+                    startIndex = i;
                     break;
-                if (GetNodeText(node).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
-                    lastMatch = node;
+                }
             }
-
-            if (lastMatch == null && wrap)
+            // Search backwards from startNode (inclusive/exclusive) to beginning
+            int first = matchStartNode ? startIndex : startIndex - 1;
+            for (int i = first; i >= 0; i--)
             {
-                foreach (var node in FlattenNodes(nodes))
+                if (GetNodeText(allNodes[i]).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
+                    return allNodes[i];
+            }
+            // If wrap is enabled, search from end down to startNode (exclusive)
+            if (wrap)
+            {
+                for (int i = allNodes.Count - 1; i > startIndex; i--)
                 {
-                    if (GetNodeText(node).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
-                        lastMatch = node;
+                    if (GetNodeText(allNodes[i]).IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
+                        return allNodes[i];
                 }
             }
-
-            return lastMatch;
+            return null;
         }
 
-        // Helper: flatten all nodes in tree (preorder)
-        private System.Collections.Generic.IEnumerable<TreeNode> FlattenNodes(TreeNodeCollection nodes)
+        // Helper: flatten all nodes in tree (preorder) and return as a list
+        private System.Collections.Generic.List<TreeNode> FlattenNodes(TreeNodeCollection nodes)
         {
-            foreach (TreeNode node in nodes)
+            var result = new System.Collections.Generic.List<TreeNode>();
+            var stack = new System.Collections.Generic.Stack<TreeNode>();
+            for (int i = nodes.Count - 1; i >= 0; i--)
+                stack.Push(nodes[i]);
+            while (stack.Count > 0)
             {
-                yield return node;
-                foreach (var child in FlattenNodes(node.Nodes))
-                    yield return child;
+                var node = stack.Pop();
+                result.Add(node);
+                for (int i = node.Nodes.Count - 1; i >= 0; i--)
+                    stack.Push(node.Nodes[i]);
             }
+            return result;
         }
 
         private void AttachHexBoxKeyboardHandler(Be.Windows.Forms.HexBox hexBox)
diff --git a/MAPIInspector/Source/Parsers/MSOXCFOLD/rops/RopCopyFolderResponse.cs b/MAPIInspector/Source/Parsers/MSOXCFOLD/rops/RopCopyFolderResponse.cs
@@ -41,7 +41,6 @@ protected override void Parse()
             RopId = ParseT<RopIdType>();
             SourceHandleIndex = ParseT<byte>();
             ReturnValue = ParseT<ErrorCodes>();
-            //ParseT<ErrorCodes>();
             if ((AdditionalErrorCodes)ReturnValue.Data == AdditionalErrorCodes.NullDestinationObject)
             {
                 DestHandleIndex = ParseT<uint>();
diff --git a/MAPIInspector/Source/Parsers/MSOXCFOLD/rops/RopCreateFolderResponse.cs b/MAPIInspector/Source/Parsers/MSOXCFOLD/rops/RopCreateFolderResponse.cs
@@ -67,7 +67,6 @@ protected override void Parse()
             RopId = ParseT<RopIdType>();
             OutputHandleIndex = ParseT<byte>();
             ReturnValue = ParseT<ErrorCodes>();
-
             if (ReturnValue == ErrorCodes.Success)
             {
                 FolderId = Parse<FolderID>();
diff --git a/MAPIInspector/Source/Parsers/MSOXCROPS/rops/RopTransportSendResponse.cs b/MAPIInspector/Source/Parsers/MSOXCROPS/rops/RopTransportSendResponse.cs
@@ -4,8 +4,9 @@
 namespace MAPIInspector.Parsers
 {
     /// <summary>
-    /// [MS-OXCROPS] 2.2.7.6 RopTransportSend
-    /// A class indicates the RopTransportSend ROP Response Buffer.
+    /// [MS-OXCROPS] 2.2.7.6.2 RopTransportSend ROP Success Response Buffer
+    /// [MS-OXCROPS] 2.2.7.6.3 RopTransportSend ROP Failure Response Buffer
+    /// /// A class indicates the RopTransportSend ROP Response Buffer.
     /// </summary>
     public class RopTransportSendResponse : Block
     {
@@ -46,8 +47,7 @@ protected override void Parse()
         {
             RopId = ParseT<RopIdType>();
             InputHandleIndex = ParseT<byte>();
-            this.AddError(ReturnValue, "ReturnValue");
-
+            ReturnValue = ParseT<ErrorCodes>();
             if (ReturnValue == ErrorCodes.Success)
             {
                 NoPropertiesReturned = ParseT<byte>();

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace BlockParser`
`5`	`5`	`public class BlockJunk : BlockInteresting`
`6`	`6`	`{`
`7`	`7`	`public override Color BackColor => Color.Coral;`
`8`		`- public override string InterestingLabel => "Exceptions found in this block";`
	`8`	`+ public override string InterestingLabel => "Extra data found in this block";`
`9`	`9`
`10`	`10`	`string Label;`
`11`	`11`	`BlockBytes junkData;`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ protected override void Parse()`
`41`	`41`	`RopId = ParseT<RopIdType>();`
`42`	`42`	`SourceHandleIndex = ParseT<byte>();`
`43`	`43`	`ReturnValue = ParseT<ErrorCodes>();`
`44`		`- //ParseT<ErrorCodes>();`
`45`	`44`	`if ((AdditionalErrorCodes)ReturnValue.Data == AdditionalErrorCodes.NullDestinationObject)`
`46`	`45`	`{`
`47`	`46`	`DestHandleIndex = ParseT<uint>();`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,6 @@ protected override void Parse()`
`67`	`67`	`RopId = ParseT<RopIdType>();`
`68`	`68`	`OutputHandleIndex = ParseT<byte>();`
`69`	`69`	`ReturnValue = ParseT<ErrorCodes>();`
`70`		`-`
`71`	`70`	`if (ReturnValue == ErrorCodes.Success)`
`72`	`71`	`{`
`73`	`72`	`FolderId = Parse<FolderID>();`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,9 @@`
`4`	`4`	`namespace MAPIInspector.Parsers`
`5`	`5`	`{`
`6`	`6`	`/// <summary>`
`7`		`- /// [MS-OXCROPS] 2.2.7.6 RopTransportSend`
`8`		`- /// A class indicates the RopTransportSend ROP Response Buffer.`
	`7`	`+ /// [MS-OXCROPS] 2.2.7.6.2 RopTransportSend ROP Success Response Buffer`
	`8`	`+ /// [MS-OXCROPS] 2.2.7.6.3 RopTransportSend ROP Failure Response Buffer`
	`9`	`+ /// /// A class indicates the RopTransportSend ROP Response Buffer.`
`9`	`10`	`/// </summary>`
`10`	`11`	`public class RopTransportSendResponse : Block`
`11`	`12`	`{`
`@@ -46,8 +47,7 @@ protected override void Parse()`
`46`	`47`	`{`
`47`	`48`	`RopId = ParseT<RopIdType>();`
`48`	`49`	`InputHandleIndex = ParseT<byte>();`
`49`		`- this.AddError(ReturnValue, "ReturnValue");`
`50`		`-`
	`50`	`+ ReturnValue = ParseT<ErrorCodes>();`
`51`	`51`	`if (ReturnValue == ErrorCodes.Success)`
`52`	`52`	`{`
`53`	`53`	`NoPropertiesReturned = ParseT<byte>();`