RPC_MESSAGE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_MESSAGE
{
    public IntPtr Handle;
    public uint DataRepresentation;
    public IntPtr Buffer;
    public uint BufferLength;
    public uint ProcNum;
    public IntPtr TransferSyntax;
    public IntPtr RpcInterfaceInformation;
    public IntPtr ReservedForRuntime;
    public IntPtr ManagerEpv;
    public IntPtr ImportContext;
    public uint RpcFlags;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_MESSAGE
    Public Handle As IntPtr
    Public DataRepresentation As UInteger
    Public Buffer As IntPtr
    Public BufferLength As UInteger
    Public ProcNum As UInteger
    Public TransferSyntax As IntPtr
    Public RpcInterfaceInformation As IntPtr
    Public ReservedForRuntime As IntPtr
    Public ManagerEpv As IntPtr
    Public ImportContext As IntPtr
    Public RpcFlags As UInteger
End Structure

import ctypes
from ctypes import wintypes

class RPC_MESSAGE(ctypes.Structure):
    _fields_ = [
        ("Handle", ctypes.c_void_p),
        ("DataRepresentation", wintypes.DWORD),
        ("Buffer", ctypes.c_void_p),
        ("BufferLength", wintypes.DWORD),
        ("ProcNum", wintypes.DWORD),
        ("TransferSyntax", ctypes.c_void_p),
        ("RpcInterfaceInformation", ctypes.c_void_p),
        ("ReservedForRuntime", ctypes.c_void_p),
        ("ManagerEpv", ctypes.c_void_p),
        ("ImportContext", ctypes.c_void_p),
        ("RpcFlags", wintypes.DWORD),
    ]

#[repr(C)]
pub struct RPC_MESSAGE {
    pub Handle: *mut core::ffi::c_void,
    pub DataRepresentation: u32,
    pub Buffer: *mut core::ffi::c_void,
    pub BufferLength: u32,
    pub ProcNum: u32,
    pub TransferSyntax: *mut core::ffi::c_void,
    pub RpcInterfaceInformation: *mut core::ffi::c_void,
    pub ReservedForRuntime: *mut core::ffi::c_void,
    pub ManagerEpv: *mut core::ffi::c_void,
    pub ImportContext: *mut core::ffi::c_void,
    pub RpcFlags: u32,
}

import "golang.org/x/sys/windows"

type RPC_MESSAGE struct {
	Handle uintptr
	DataRepresentation uint32
	Buffer uintptr
	BufferLength uint32
	ProcNum uint32
	TransferSyntax uintptr
	RpcInterfaceInformation uintptr
	ReservedForRuntime uintptr
	ManagerEpv uintptr
	ImportContext uintptr
	RpcFlags uint32
}

type
  RPC_MESSAGE = record
    Handle: Pointer;
    DataRepresentation: DWORD;
    Buffer: Pointer;
    BufferLength: DWORD;
    ProcNum: DWORD;
    TransferSyntax: Pointer;
    RpcInterfaceInformation: Pointer;
    ReservedForRuntime: Pointer;
    ManagerEpv: Pointer;
    ImportContext: Pointer;
    RpcFlags: DWORD;
  end;

const RPC_MESSAGE = extern struct {
    Handle: ?*anyopaque,
    DataRepresentation: u32,
    Buffer: ?*anyopaque,
    BufferLength: u32,
    ProcNum: u32,
    TransferSyntax: ?*anyopaque,
    RpcInterfaceInformation: ?*anyopaque,
    ReservedForRuntime: ?*anyopaque,
    ManagerEpv: ?*anyopaque,
    ImportContext: ?*anyopaque,
    RpcFlags: u32,
};

type
  RPC_MESSAGE {.bycopy.} = object
    Handle: pointer
    DataRepresentation: uint32
    Buffer: pointer
    BufferLength: uint32
    ProcNum: uint32
    TransferSyntax: pointer
    RpcInterfaceInformation: pointer
    ReservedForRuntime: pointer
    ManagerEpv: pointer
    ImportContext: pointer
    RpcFlags: uint32

struct RPC_MESSAGE
{
    void* Handle;
    uint DataRepresentation;
    void* Buffer;
    uint BufferLength;
    uint ProcNum;
    void* TransferSyntax;
    void* RpcInterfaceInformation;
    void* ReservedForRuntime;
    void* ManagerEpv;
    void* ImportContext;
    uint RpcFlags;
}