How to do memcpy in C# .Net CF with the following task

Question

Hi I am trying to convert the C/C++ Strcut to C# and how to fill the structure member with address of another structure in C#?

C/C++ Struct looks like:

         typedef struct _NDISUIO_QUERY_OID
         {
           NDIS_OID        Oid;
           PTCHAR          ptcDeviceName;  
           UCHAR           Data[sizeof(ULONG)];
         } NDISUIO_QUERY_OID, *PNDISUIO_QUERY_OID;

         typedef struct My_Struct
         {
           //les have 2 variables...  
            UINT    a;
            UINT    b;
         }My_STATS, *PMy_STATS;

         PNDISUIO_QUERY_OID     pQueryOid = NULL;

         pQueryOid = (PNDISUIO_QUERY_OID)malloc(sizeof(NDISUIO_QUERY_OID)+ sizeof(My_STATS)) ;

         PMy_STATS   Statistics;
          pQueryOid->Oid = ulOIDCode;//Required OID
      pQueryOid->ptcDeviceName = AUB_NAME;//REquired STRING

         memcpy(pQueryOid->Data, Statistics, sizeof(My_STATS));

My C# Struct is:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]

    public struct _NDISUIO_QUERY_OID
    {
        public uint        Oid;
        [MarshalAs(UnmanagedType.LPWStr)]
        public string          ptcDeviceName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = sizeof(uint))]
        public string Data;
    };

Problem: How to copy the Statistics structure to Data array in C#??

Thanks :)

Answer 1

Here's my implementation (FYI, the SDF contains all of this code and a lot more)

internal class NDISQueryOid
{
    protected const int NDISUIO_QUERY_OID_SIZE = 12;

    protected byte[] m_data;
    public int Size { get; private set; }

    public NDISQueryOid(byte[] data)
    {
        int extrasize = data.Length;
        Size = 8 + extrasize;
        m_data = new byte[Size];
        Buffer.BlockCopy(data, 0, m_data, DataOffset, data.Length);
    }

    public NDISQueryOid(int extrasize)
    {
       Size = NDISUIO_QUERY_OID_SIZE + extrasize;
        m_data = new byte[Size];
    }

    protected const int OidOffset = 0;
    public uint Oid
    {
        get { return BitConverter.ToUInt32(m_data, OidOffset); }
        set
        {
            byte[] bytes = BitConverter.GetBytes(value);
            Buffer.BlockCopy(bytes, 0, m_data, OidOffset, 4);
        }
    }

    protected const int ptcDeviceNameOffset = OidOffset + 4;
    public unsafe byte* ptcDeviceName
    {
        get
        {
            return (byte*)BitConverter.ToUInt32(m_data, ptcDeviceNameOffset);
        }
        set
        {
            byte[] bytes = BitConverter.GetBytes((UInt32)value);
            Buffer.BlockCopy(bytes, 0, m_data, ptcDeviceNameOffset, 4);
        }
    }

    protected const int DataOffset = ptcDeviceNameOffset + 4;
    public byte[] Data
    {
        get
        {
            byte[] b = new byte[Size - DataOffset];
            Array.Copy(m_data, DataOffset, b, 0, Size - DataOffset);
            return b;
        }
        set
        {
            Size = 8 + value.Length;
            m_data = new byte[Size];
            Buffer.BlockCopy(value, 0, m_data, DataOffset, value.Length);
        }
    }

    public byte[] getBytes()
    {
        return m_data;
    }

    public static implicit operator byte[](NDISQueryOid qoid)
    {
        return qoid.m_data;
    }
}

Note that in my usage, the NDIS IOCT takes in a pointer (most of my NDIS work is all done as unsafe) so you'd have to do some adjustment there.

So if, for example, you're querying the BSSID, I know the BSSID data is 36 bytes, so I'd create something like this:

var queryOID = new NDISQueryOid(36);

then allocate the name and call NDIS (the production code has a lot more checking than this):

byte[] nameBytes = System.Text.Encoding.Unicode.GetBytes(adapterName + '\0');

fixed (byte* pName = &nameBytes[0])
{
    queryOID.ptcDeviceName = pName;
    queryOID.Oid = (uint)oid;

    var bytes = queryOID.getBytes();
    ndis.DeviceIoControl(IOCTL_NDISUIO_QUERY_OID_VALUE, bytes, bytes);

    var result = new byte[queryOID.Data.Length];
    Buffer.BlockCopy(queryOID.Data, 0, result, 0, result.Length);
}

EDIT

So the result member above is a byte array of the "result" of the query. What it means and how you interpret it depends on what the OID you queried was. For example, if you were querying the currently connected SSID (i.e. NDIS_OID.SSID), then that comes back as a 4-byte length followed by the ASCII-encoded name, so you'd decipher it like this:

int len = BitConverter.ToInt32(data, 0);
if (len > 0)
{
    ssid = System.Text.Encoding.ASCII.GetString(data, 4, len);
}

But again, this is only for one specific OID. You have to handle every return case for every incoming OID you decide to support.

Answer 2

First you have the wrong translation of your C++ code: the C# equivalent of a C++ char[] is not a string, it's a byte[]. Once you have that, you just need to know, in general, how to copy a structure into a byte array. Here's a compilable example:

using System;
using System.Runtime.InteropServices;


    struct Dest
    {
        public byte[] Data;
    }

    struct Src
    {
        public GCHandle StringHandle;
        public long A;
        public long B;
    }

    class Program
    {
        static void Main()
        {
            Copy();
        }

        static void Copy()
        {
            var str = "Hello";
            var src = new Src { 
                A = 3, 
                B = 4, 
                StringHandle = GCHandle.Alloc(str, GCHandleType.Normal) 
            };
            var dst = new Dest();

            unsafe
            {
                Src* srcPtr = &src;
                dst.Data = new byte[sizeof(Src)];
                Marshal.Copy((IntPtr)srcPtr, dst.Data, 0, sizeof(Src));
            }

            // When you're sure no one can reference the string anymore
            // (Including by accessing the data you put in dst.Data!)
            src.StringHandle.Free();
        }

EDIT: added example of how to deal with reference types such as strings.

Answer 3

Safely, you can't. .NET enforces type safety, which means that you simply can't force a string to be a structure. However, you can look at the data instead of doing unsafe type casts (why are you storing two uints in a string in the first place? And marshalling it as unicode?

First, you'll have to make Data a byte array. It might be possible to do this with a string as well, but that's just adding encoding issues to the mix; if you can, use byte[] instead. Also, if you don't need to have different kinds of data inside (it seems so), you could simply put the two uint fields right inside the struct and it should work just fine:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _NDISUIO_QUERY_OID
{
    public uint Oid;
    [MarshalAs(UnmanagedType.LPWStr)]
    public string ptcDeviceName;
    public uint DataA;
    public uint DataB;
};

The second approach would use a const-sized byte array, long enough to hold the two uints:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _NDISUIO_QUERY_OID
{
    public uint Oid;
    [MarshalAs(UnmanagedType.LPWStr)]
    public string ptcDeviceName;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = sizeof(ulong))]
    public byte[] Data;
};

The first four bytes will be the first uint, the next will be the second.

And of course, you could also use a .NET struct the same way as in the original code - just make sure you use the correct datatype in _NDISUIO_QUERY_OID and it should work automagically.

One point to note though, it seems that the data returned isn't actually necessarily fixed-length. That is quite tricky and it basically means you'd have to deserialize the structure manually based on the pointer and length you get.