Fix handling of arrays of pointers to structures.

Author: tyranid

NtApiDotNet/Ndr/Marshal/NdrMarshalBuffer.cs

@@ -88,6 +88,21 @@ private void WriteStringArray(string[] array, Action<string> writer, int count)
             }
         }
 
+        private void WriteStructPointerArray<T>(T?[] array, int count) where T : struct, INdrStructure
+        {
+            if (array == null)
+            {
+                array = new T?[0];
+            }
+
+            for (int i = 0; i < count; ++i)
+            {
+                INdrStructure value = i < array.Length ? array[i] : null;
+                WriteReferent(value);
+                _deferred_writes.Add(() => WriteStruct(value));
+            }
+        }
+
         private void WriteConformance(params int[] conformance)
         {
             if (_conformance_position.HasValue)
@@ -857,9 +872,18 @@ public void WriteVaryingStructArray<T>(T[] array, long variance) where T : struc
 
         public void WriteVaryingStructPointerArray<T>(T?[] array, long variance) where T : struct, INdrStructure
         {
+            // Offset.
+            WriteInt32(0);
+            // Actual Count
+            int var_int = (int)variance;
+            if (var_int < 0)
+            {
+                var_int = array.Length;
+            }
+            WriteInt32(var_int);
             using (var queue = _deferred_writes.Push())
             {
-                WriteVaryingArrayCallback(array, t => WriteReferent(t, x => WriteStructInternal(x)), variance);
+                WriteStructPointerArray(array, (int)variance);
             }
         }
 
@@ -987,9 +1011,16 @@ public void WriteConformantStructArray<T>(T[] array, long conformance) where T :
 
         public void WriteConformantStructPointerArray<T>(T?[] array, long conformance) where T : struct, INdrStructure
         {
+            int var_int = (int)conformance;
+            if (var_int < 0)
+            {
+                var_int = array?.Length ?? 0;
+            }
+            // Max Count
+            WriteConformance(var_int);
             using (var queue = _deferred_writes.Push())
             {
-                WriteConformantArrayCallback(array, t => WriteReferent(t, x => WriteStructInternal(x)), conformance);
+                WriteStructPointerArray(array, var_int);
             }
         }
 
@@ -1112,9 +1143,26 @@ public void WriteConformantVaryingStructArray<T>(T[] array, long conformance, lo
 
         public void WriteConformantVaryingStructPointerArray<T>(T?[] array, long conformance, long variance) where T : struct, INdrStructure
         {
+            // Max Count
+            int con_int = (int)conformance;
+            if (con_int < 0)
+            {
+                con_int = array.Length;
+            }
+            WriteConformance(con_int);
+
+            // Offset.
+            WriteInt32(0);
+            // Actual Count
+            int var_int = (int)variance;
+            if (var_int < 0)
+            {
+                var_int = array.Length;
+            }
+            WriteInt32(var_int);
             using (var queue = _deferred_writes.Push())
             {
-                WriteVaryingArrayCallback(array, t => WriteReferent(t, x => WriteStructInternal(x)), variance);
+                WriteStructPointerArray(array, (int)variance);
             }
         }
 

NtApiDotNet/Ndr/Marshal/NdrUnmarshalBuffer.cs

@@ -54,6 +54,25 @@ private string[] ReadStringArray(int[] refs, Func<string> reader)
             return ret;
         }
 
+        private T?[] ReadStructPointerArray<T>(int[] refs, bool full_pointer) where T : struct, INdrStructure
+        {
+            T?[] ret = new T?[refs.Length];
+            for (int i = 0; i < refs.Length; ++i)
+            {
+                if (refs[i] == 0)
+                {
+                    ret[i] = null;
+                }
+                else
+                {
+                    int pos = i;
+                    Func<T> unmarshal = ReadStruct<T>;
+                    _deferred_reads.Add(() => ret[pos] = full_pointer ? ReadFullPointer(refs[i], unmarshal) : unmarshal());
+                }
+            }
+            return ret;
+        }
+
         private bool SetupConformance(int dimensions)
         {
             if (_conformance_values == null)
@@ -437,7 +456,7 @@ public T[] ReadConformantArrayCallback<T>(Func<T> reader)
         {
             using (var queue = _deferred_reads.Push())
             {
-                return ReadConformantArrayCallback(() => ReadReferentValue(ReadStructInternal<T>, full_pointer));
+                return ReadStructPointerArray<T>(ReadConformantArrayCallback(ReadInt32), full_pointer);
             }
         }
 
@@ -539,7 +558,7 @@ public T[] ReadVaryingArrayCallback<T>(Func<T> reader)
         {
             using (var queue = _deferred_reads.Push())
             {
-                return ReadVaryingArrayCallback(() => ReadReferentValue(ReadStruct<T>, full_pointer));
+                return ReadStructPointerArray<T>(ReadVaryingArrayCallback(ReadInt32), full_pointer);
             }
         }
 
@@ -653,7 +672,7 @@ public T[] ReadConformantVaryingArrayCallback<T>(Func<T> reader)
         {
             using (var queue = _deferred_reads.Push())
             {
-                return ReadConformantVaryingArrayCallback(() => ReadReferentValue(ReadStructInternal<T>, full_pointer));
+                return ReadStructPointerArray<T>(ReadConformantVaryingArrayCallback(ReadInt32), full_pointer);
             }
         }