.NET NORM Extension

src/dotnet/design/Mil/Navy/Nrl/Norm/NormApi.puml

@@ -56,7 +56,7 @@ class NormApi <<static>> {
     + {static} <<extern>> NormRequeueObject(sessionHandle:long, objectHandle:long) : bool
     + {static} <<extern>> NormStreamOpen(sessionHandle:long, bufferSize:long, infoPtr:nint, infoLen:int) : long
     + {static} <<extern>> NormStreamClose(streamHandle:long, graceful:bool) : void
-    <<internal>> {static} <<extern>> NormStreamWrite(streamHandle:long, buffer:nint, numBytes:int) : int
+    + <<unsafe>> {static} <<extern>> NormStreamWrite(streamHandle:long, buffer:byte*, numBytes:int) : int
     + {static} <<extern>> NormStreamFlush(streamHandle:long, eom:bool, flushMode:NormFlushMode) : void
     + {static} <<extern>> NormStreamSetAutoFlush(streamHandle:long, flushMode:NormFlushMode) : void
     + {static} <<extern>> NormStreamSetPushEnable(streamHandle:long, pushEnable:bool) : void
@@ -85,7 +85,7 @@ class NormApi <<static>> {
     + {static} <<extern>> NormNodeSetRepairBoundary(remoteSender:long, repairBoundary:NormRepairBoundary) : void
     + {static} <<extern>> NormSetDefaultRxRobustFactor(sessionHandle:long, robustFactor:int) : void
     + {static} <<extern>> NormNodeSetRxRobustFactor(remoteSender:long, robustFactor:int) : void
-    + {static} <<extern>> NormStreamRead(streamHandle:long, buffer:nint, numBytes:int) : bool
+    + <<unsafe>> {static} <<extern>> NormStreamRead(streamHandle:long, buffer:byte*, numBytes:int) : bool
     + {static} <<extern>> NormStreamSeekMsgStart(streamHandle:long) : bool
     + {static} <<extern>> NormStreamGetReadOffset(streamHandle:long) : long
     + {static} <<extern>> NormObjectGetType(objectHandle:long) : NormObjectType
@@ -97,14 +97,14 @@ class NormApi <<static>> {
     + {static} <<extern>> NormObjectCancel(objectHandle:long) : void
     + {static} <<extern>> NormObjectRetain(objectHandle:long) : void
     + {static} <<extern>> NormObjectRelease(objectHandle:long) : void
-    + {static} <<extern>> NormFileGetName(fileHandle:long, nameBuffer:nint, bufferLen:int) : bool
+    + <<unsafe>> {static} <<extern>> NormFileGetName(fileHandle:long, nameBuffer:sbyte*, bufferLen:int) : bool
     + {static} <<extern>> NormFileRename(fileHandle:long, fileName:string) : bool
     + {static} <<extern>> NormDataAccessData(objectHandle:long) : nint
     + {static} <<extern>> NormObjectGetSender(objectHandle:long) : long
     + {static} <<extern>> NormNodeGetId(nodeHandle:long) : long
-    + {static} <<extern>> NormNodeGetAddress(nodeHandle:long, addrBuffer:nint, bufferLen:int, port:int) : bool
+    + <<unsafe>> {static} <<extern>> NormNodeGetAddress(nodeHandle:long, addrBuffer:byte*, bufferLen:int, port:int) : bool
     + {static} <<extern>> NormNodeGetGrtt(nodeHandle:long) : double
-    + {static} <<extern>> NormNodeGetCommand(remoteSender:long, cmdBuffer:nint, buflen:int) : bool
+    + <<unsafe>> {static} <<extern>> NormNodeGetCommand(remoteSender:long, cmdBuffer:byte*, buflen:int) : bool
     + {static} <<extern>> NormNodeFreeBuffers(remoteSender:long) : void
     + {static} <<extern>> NormNodeRetain(nodeHandle:long) : void
     + {static} <<extern>> NormNodeRelease(nodeHandle:long) : void

src/dotnet/src/Mil.Navy.Nrl.Norm/NormApi.cs

@@ -591,7 +591,7 @@ public struct NormEvent
         /// <param name="numBytes">The numBytes parameter indicates the length of the data content.</param>
         /// <returns>This function returns the number of bytes of data successfully enqueued for NORM stream transmission.</returns>
         [DllImport(NORM_LIBRARY)]
-        internal static extern int NormStreamWrite(long streamHandle, nint buffer, int numBytes);
+        public unsafe static extern int NormStreamWrite(long streamHandle, byte* buffer, int numBytes);
 
         /// <summary>
         /// This function causes an immediate "flush" of the transmit stream specified by the streamHandle parameter.
@@ -895,7 +895,7 @@ public struct NormEvent
         /// <returns>This function normally returns a value of true. However, if a break in the integrity of the reliable received stream 
         /// occurs(or the stream has been ended by the sender), a value of false is returned to indicate the break. </returns>
         [DllImport(NORM_LIBRARY)]
-        public static extern bool NormStreamRead(long streamHandle, nint buffer, ref int numBytes);
+        public unsafe static extern bool NormStreamRead(long streamHandle, byte* buffer, ref int numBytes);
 
         /// <summary>
         /// This function advances the read offset of the receive stream referenced by the streamHandle parameter to align
@@ -1020,7 +1020,7 @@ public struct NormEvent
         /// does not refer to an object of type NORM_OBJECT_FILE.
         /// </returns>
         [DllImport(NORM_LIBRARY)]
-        public static extern bool NormFileGetName(long fileHandle, nint nameBuffer, int bufferLen);
+        public unsafe static extern bool NormFileGetName(long fileHandle, sbyte* nameBuffer, int bufferLen);
 
         /// <summary>
         /// This function renames the file used to store content for the NORM_OBJECT_FILE transport object specified by 
@@ -1081,7 +1081,7 @@ public struct NormEvent
         /// <param name="port">port number and/or specify a specific source address binding that is used for packet transmission.</param>
         /// <returns>A value of true is returned upon success and false upon failure. An invalid nodeHandle parameter value would lead to such failure.</returns>
         [DllImport(NORM_LIBRARY)]
-        public static extern bool NormNodeGetAddress(long nodeHandle, nint addrBuffer, ref int bufferLen, out int port);
+        public unsafe static extern bool NormNodeGetAddress(long nodeHandle, byte* addrBuffer, ref int bufferLen, out int port);
 
         /// <summary>
         /// This function retrieves the advertised estimate of group round-trip timing (GRTT) for the remote sender referenced by the given nodeHandle value.
@@ -1104,7 +1104,7 @@ public struct NormEvent
         /// either no command was available or the provided buffer size (buflen parameter) was inadequate.
         /// The value referenced by the buflen parameter is adjusted to indicate the actual command length (in bytes) upon return.</returns>
         [DllImport(NORM_LIBRARY)]
-        public static extern bool NormNodeGetCommand(long remoteSender, nint cmdBuffer, ref int buflen);
+        public unsafe static extern bool NormNodeGetCommand(long remoteSender, byte* cmdBuffer, ref int buflen);
 
         /// <summary>
         /// This function releases memory resources that were allocated for a remote sender. 

src/dotnet/src/Mil.Navy.Nrl.Norm/NormFile.cs

@@ -1,7 +1,4 @@
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace Mil.Navy.Nrl.Norm
+namespace Mil.Navy.Nrl.Norm
 {
     /// <summary>
     /// A transport object of type NORM_OBJECT_FILE.
@@ -29,16 +26,14 @@ public unsafe string Name
         {
             get
             {
-                var buffer = stackalloc byte[FILENAME_MAX];
-                var bufferPtr = (nint)buffer;
+                var buffer = stackalloc sbyte[FILENAME_MAX];
 
-                if (!NormFileGetName(_handle, bufferPtr, FILENAME_MAX))
+                if (!NormFileGetName(_handle, buffer, FILENAME_MAX))
                 {
                     throw new IOException("Failed to get file name");
                 }
-                var name = Marshal.PtrToStringAnsi(bufferPtr);
-
-                return name ?? string.Empty;
+
+                return new string(buffer);
             }
         }
 

src/dotnet/src/Mil.Navy.Nrl.Norm/NormNode.cs

@@ -1,5 +1,4 @@
 using System.Net;
-using System.Runtime.InteropServices;
 
 namespace Mil.Navy.Nrl.Norm
 {
@@ -48,9 +47,8 @@ public unsafe IPEndPoint Address
             {
                 var bufferLength = 256;
                 var buffer = stackalloc byte[bufferLength];
-                var addrBuffer = (nint)buffer;
 
-                if (!NormNodeGetAddress(_handle, addrBuffer, ref bufferLength, out int port))
+                if (!NormNodeGetAddress(_handle, buffer, ref bufferLength, out int port))
                 {
                     throw new IOException("Failed to get node address");
                 }
@@ -81,20 +79,17 @@ public int GetCommand(byte[] buffer, int offset, int length)
                 throw new ArgumentOutOfRangeException(nameof(length), "The length is out of range");
             }
 
-            var bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-
-            try
+            unsafe
             {
-                var bufferPtr = bufferHandle.AddrOfPinnedObject() + offset;
-                if (!NormNodeGetCommand(_handle, bufferPtr, ref length))
+                fixed (byte* bufferPtr = buffer)
                 {
-                    throw new IOException("Failed to get command");
+                    if (!NormNodeGetCommand(_handle, bufferPtr + offset, ref length))
+                    {
+                        throw new IOException("Failed to get command");
+                    }
                 }
-            } 
-            finally
-            {
-                bufferHandle.Free();
             }
+
             return length;
         }
 

src/dotnet/src/Mil.Navy.Nrl.Norm/NormStream.cs

@@ -1,6 +1,4 @@
-using System.Runtime.InteropServices;
-
-namespace Mil.Navy.Nrl.Norm
+namespace Mil.Navy.Nrl.Norm
 {
     /// <summary>
     /// A transport object of type NORM_OBJECT_STREAM.
@@ -59,16 +57,12 @@ public int Write(byte[] buffer, int offset, int length)
             }
 
             int numBytes;
-            var bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-
-            try
+            unsafe
             {
-                var bufferPtr = bufferHandle.AddrOfPinnedObject() + offset;
-                numBytes = NormStreamWrite(_handle, bufferPtr, length);
-            } 
-            finally
-            {
-                bufferHandle.Free();
+                fixed (byte* bufferPtr = buffer)
+                {
+                    numBytes = NormStreamWrite(_handle, bufferPtr + offset, length);
+                }
             }
 
             return numBytes;
@@ -158,20 +152,16 @@ public int Read(byte[] buffer, int offset, int length)
                 throw new ArgumentOutOfRangeException(nameof(length), "The length is out of range");
             }
 
-            var bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-
-            try
+            unsafe
             {
-                var bufferPtr = bufferHandle.AddrOfPinnedObject() + offset;
-                if (!NormStreamRead(_handle, bufferPtr, ref length))
+                fixed (byte* bufferPtr = buffer)
                 {
-                    length = -1;
+                    if (!NormStreamRead(_handle, bufferPtr + offset, ref length))
+                    {
+                        length = -1;
+                    }
                 }
             }
-            finally
-            {
-                bufferHandle.Free();
-            }
 
             return length;
         }