RDR_CALLOUT_STATE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_VERSION
{
    public ushort MajorVersion;
    public ushort MinorVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_SYNTAX_IDENTIFIER
{
    public Guid SyntaxGUID;
    public RPC_VERSION SyntaxVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RDR_CALLOUT_STATE
{
    public int LastError;
    public IntPtr LastEEInfo;
    public int LastCalledStage;
    public IntPtr ServerName;
    public IntPtr ServerPort;
    public IntPtr RemoteUser;
    public IntPtr AuthType;
    public byte ResourceTypePresent;
    public byte SessionIdPresent;
    public byte InterfacePresent;
    public Guid ResourceType;
    public Guid SessionId;
    public RPC_SYNTAX_IDENTIFIER Interface;
    public IntPtr CertContext;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_VERSION
    Public MajorVersion As UShort
    Public MinorVersion As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_SYNTAX_IDENTIFIER
    Public SyntaxGUID As Guid
    Public SyntaxVersion As RPC_VERSION
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RDR_CALLOUT_STATE
    Public LastError As Integer
    Public LastEEInfo As IntPtr
    Public LastCalledStage As Integer
    Public ServerName As IntPtr
    Public ServerPort As IntPtr
    Public RemoteUser As IntPtr
    Public AuthType As IntPtr
    Public ResourceTypePresent As Byte
    Public SessionIdPresent As Byte
    Public InterfacePresent As Byte
    Public ResourceType As Guid
    Public SessionId As Guid
    Public Interface As RPC_SYNTAX_IDENTIFIER
    Public CertContext As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class RPC_VERSION(ctypes.Structure):
    _fields_ = [
        ("MajorVersion", ctypes.c_ushort),
        ("MinorVersion", ctypes.c_ushort),
    ]

class RPC_SYNTAX_IDENTIFIER(ctypes.Structure):
    _fields_ = [
        ("SyntaxGUID", GUID),
        ("SyntaxVersion", RPC_VERSION),
    ]

class RDR_CALLOUT_STATE(ctypes.Structure):
    _fields_ = [
        ("LastError", ctypes.c_int),
        ("LastEEInfo", ctypes.c_void_p),
        ("LastCalledStage", ctypes.c_int),
        ("ServerName", ctypes.c_void_p),
        ("ServerPort", ctypes.c_void_p),
        ("RemoteUser", ctypes.c_void_p),
        ("AuthType", ctypes.c_void_p),
        ("ResourceTypePresent", ctypes.c_ubyte),
        ("SessionIdPresent", ctypes.c_ubyte),
        ("InterfacePresent", ctypes.c_ubyte),
        ("ResourceType", GUID),
        ("SessionId", GUID),
        ("Interface", RPC_SYNTAX_IDENTIFIER),
        ("CertContext", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct RPC_VERSION {
    pub MajorVersion: u16,
    pub MinorVersion: u16,
}

#[repr(C)]
pub struct RPC_SYNTAX_IDENTIFIER {
    pub SyntaxGUID: GUID,
    pub SyntaxVersion: RPC_VERSION,
}

#[repr(C)]
pub struct RDR_CALLOUT_STATE {
    pub LastError: i32,
    pub LastEEInfo: *mut core::ffi::c_void,
    pub LastCalledStage: i32,
    pub ServerName: *mut core::ffi::c_void,
    pub ServerPort: *mut core::ffi::c_void,
    pub RemoteUser: *mut core::ffi::c_void,
    pub AuthType: *mut core::ffi::c_void,
    pub ResourceTypePresent: u8,
    pub SessionIdPresent: u8,
    pub InterfacePresent: u8,
    pub ResourceType: GUID,
    pub SessionId: GUID,
    pub Interface: RPC_SYNTAX_IDENTIFIER,
    pub CertContext: *mut core::ffi::c_void,
}

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

type RPC_VERSION struct {
	MajorVersion uint16
	MinorVersion uint16
}

type RPC_SYNTAX_IDENTIFIER struct {
	SyntaxGUID windows.GUID
	SyntaxVersion RPC_VERSION
}

type RDR_CALLOUT_STATE struct {
	LastError int32
	LastEEInfo uintptr
	LastCalledStage int32
	ServerName uintptr
	ServerPort uintptr
	RemoteUser uintptr
	AuthType uintptr
	ResourceTypePresent byte
	SessionIdPresent byte
	InterfacePresent byte
	ResourceType windows.GUID
	SessionId windows.GUID
	Interface RPC_SYNTAX_IDENTIFIER
	CertContext uintptr
}

type
  RPC_VERSION = record
    MajorVersion: Word;
    MinorVersion: Word;
  end;

  RPC_SYNTAX_IDENTIFIER = record
    SyntaxGUID: TGUID;
    SyntaxVersion: RPC_VERSION;
  end;

  RDR_CALLOUT_STATE = record
    LastError: Integer;
    LastEEInfo: Pointer;
    LastCalledStage: Integer;
    ServerName: Pointer;
    ServerPort: Pointer;
    RemoteUser: Pointer;
    AuthType: Pointer;
    ResourceTypePresent: Byte;
    SessionIdPresent: Byte;
    InterfacePresent: Byte;
    ResourceType: TGUID;
    SessionId: TGUID;
    Interface: RPC_SYNTAX_IDENTIFIER;
    CertContext: Pointer;
  end;

const RPC_VERSION = extern struct {
    MajorVersion: u16,
    MinorVersion: u16,
};

const RPC_SYNTAX_IDENTIFIER = extern struct {
    SyntaxGUID: GUID,
    SyntaxVersion: RPC_VERSION,
};

const RDR_CALLOUT_STATE = extern struct {
    LastError: i32,
    LastEEInfo: ?*anyopaque,
    LastCalledStage: i32,
    ServerName: ?*anyopaque,
    ServerPort: ?*anyopaque,
    RemoteUser: ?*anyopaque,
    AuthType: ?*anyopaque,
    ResourceTypePresent: u8,
    SessionIdPresent: u8,
    InterfacePresent: u8,
    ResourceType: GUID,
    SessionId: GUID,
    Interface: RPC_SYNTAX_IDENTIFIER,
    CertContext: ?*anyopaque,
};

type
  RPC_VERSION {.bycopy.} = object
    MajorVersion: uint16
    MinorVersion: uint16

  RPC_SYNTAX_IDENTIFIER {.bycopy.} = object
    SyntaxGUID: GUID
    SyntaxVersion: RPC_VERSION

  RDR_CALLOUT_STATE {.bycopy.} = object
    LastError: int32
    LastEEInfo: pointer
    LastCalledStage: int32
    ServerName: pointer
    ServerPort: pointer
    RemoteUser: pointer
    AuthType: pointer
    ResourceTypePresent: uint8
    SessionIdPresent: uint8
    InterfacePresent: uint8
    ResourceType: GUID
    SessionId: GUID
    Interface: RPC_SYNTAX_IDENTIFIER
    CertContext: pointer

struct RPC_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct RPC_SYNTAX_IDENTIFIER
{
    GUID SyntaxGUID;
    RPC_VERSION SyntaxVersion;
}

struct RDR_CALLOUT_STATE
{
    int LastError;
    void* LastEEInfo;
    int LastCalledStage;
    void* ServerName;
    void* ServerPort;
    void* RemoteUser;
    void* AuthType;
    ubyte ResourceTypePresent;
    ubyte SessionIdPresent;
    ubyte InterfacePresent;
    GUID ResourceType;
    GUID SessionId;
    RPC_SYNTAX_IDENTIFIER Interface;
    void* CertContext;
}