DHCP_CLIENT_INFO_EX

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DHCP_BINARY_DATA
{
    public uint DataLength;
    public IntPtr Data;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DATE_TIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DHCP_HOST_INFO
{
    public uint IpAddress;
    public IntPtr NetBiosName;
    public IntPtr HostName;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DHCP_CLIENT_INFO_EX
{
    public uint ClientIpAddress;
    public uint SubnetMask;
    public DHCP_BINARY_DATA ClientHardwareAddress;
    public IntPtr ClientName;
    public IntPtr ClientComment;
    public DATE_TIME ClientLeaseExpires;
    public DHCP_HOST_INFO OwnerHost;
    public byte bClientType;
    public byte AddressState;
    public int Status;
    public DATE_TIME ProbationEnds;
    [MarshalAs(UnmanagedType.Bool)] public bool QuarantineCapable;
    public uint FilterStatus;
    public IntPtr PolicyName;
    public IntPtr Properties;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DHCP_BINARY_DATA
    Public DataLength As UInteger
    Public Data As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DATE_TIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DHCP_HOST_INFO
    Public IpAddress As UInteger
    Public NetBiosName As IntPtr
    Public HostName As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DHCP_CLIENT_INFO_EX
    Public ClientIpAddress As UInteger
    Public SubnetMask As UInteger
    Public ClientHardwareAddress As DHCP_BINARY_DATA
    Public ClientName As IntPtr
    Public ClientComment As IntPtr
    Public ClientLeaseExpires As DATE_TIME
    Public OwnerHost As DHCP_HOST_INFO
    Public bClientType As Byte
    Public AddressState As Byte
    Public Status As Integer
    Public ProbationEnds As DATE_TIME
    <MarshalAs(UnmanagedType.Bool)> Public QuarantineCapable As Boolean
    Public FilterStatus As UInteger
    Public PolicyName As IntPtr
    Public Properties As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class DHCP_BINARY_DATA(ctypes.Structure):
    _fields_ = [
        ("DataLength", wintypes.DWORD),
        ("Data", ctypes.c_void_p),
    ]

class DATE_TIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class DHCP_HOST_INFO(ctypes.Structure):
    _fields_ = [
        ("IpAddress", wintypes.DWORD),
        ("NetBiosName", ctypes.c_void_p),
        ("HostName", ctypes.c_void_p),
    ]

class DHCP_CLIENT_INFO_EX(ctypes.Structure):
    _fields_ = [
        ("ClientIpAddress", wintypes.DWORD),
        ("SubnetMask", wintypes.DWORD),
        ("ClientHardwareAddress", DHCP_BINARY_DATA),
        ("ClientName", ctypes.c_void_p),
        ("ClientComment", ctypes.c_void_p),
        ("ClientLeaseExpires", DATE_TIME),
        ("OwnerHost", DHCP_HOST_INFO),
        ("bClientType", ctypes.c_ubyte),
        ("AddressState", ctypes.c_ubyte),
        ("Status", ctypes.c_int),
        ("ProbationEnds", DATE_TIME),
        ("QuarantineCapable", wintypes.BOOL),
        ("FilterStatus", wintypes.DWORD),
        ("PolicyName", ctypes.c_void_p),
        ("Properties", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct DHCP_BINARY_DATA {
    pub DataLength: u32,
    pub Data: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct DATE_TIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct DHCP_HOST_INFO {
    pub IpAddress: u32,
    pub NetBiosName: *mut core::ffi::c_void,
    pub HostName: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct DHCP_CLIENT_INFO_EX {
    pub ClientIpAddress: u32,
    pub SubnetMask: u32,
    pub ClientHardwareAddress: DHCP_BINARY_DATA,
    pub ClientName: *mut core::ffi::c_void,
    pub ClientComment: *mut core::ffi::c_void,
    pub ClientLeaseExpires: DATE_TIME,
    pub OwnerHost: DHCP_HOST_INFO,
    pub bClientType: u8,
    pub AddressState: u8,
    pub Status: i32,
    pub ProbationEnds: DATE_TIME,
    pub QuarantineCapable: i32,
    pub FilterStatus: u32,
    pub PolicyName: *mut core::ffi::c_void,
    pub Properties: *mut core::ffi::c_void,
}

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

type DHCP_BINARY_DATA struct {
	DataLength uint32
	Data uintptr
}

type DATE_TIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type DHCP_HOST_INFO struct {
	IpAddress uint32
	NetBiosName uintptr
	HostName uintptr
}

type DHCP_CLIENT_INFO_EX struct {
	ClientIpAddress uint32
	SubnetMask uint32
	ClientHardwareAddress DHCP_BINARY_DATA
	ClientName uintptr
	ClientComment uintptr
	ClientLeaseExpires DATE_TIME
	OwnerHost DHCP_HOST_INFO
	bClientType byte
	AddressState byte
	Status int32
	ProbationEnds DATE_TIME
	QuarantineCapable int32
	FilterStatus uint32
	PolicyName uintptr
	Properties uintptr
}

type
  DHCP_BINARY_DATA = record
    DataLength: DWORD;
    Data: Pointer;
  end;

  DATE_TIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  DHCP_HOST_INFO = record
    IpAddress: DWORD;
    NetBiosName: Pointer;
    HostName: Pointer;
  end;

  DHCP_CLIENT_INFO_EX = record
    ClientIpAddress: DWORD;
    SubnetMask: DWORD;
    ClientHardwareAddress: DHCP_BINARY_DATA;
    ClientName: Pointer;
    ClientComment: Pointer;
    ClientLeaseExpires: DATE_TIME;
    OwnerHost: DHCP_HOST_INFO;
    bClientType: Byte;
    AddressState: Byte;
    Status: Integer;
    ProbationEnds: DATE_TIME;
    QuarantineCapable: BOOL;
    FilterStatus: DWORD;
    PolicyName: Pointer;
    Properties: Pointer;
  end;

const DHCP_BINARY_DATA = extern struct {
    DataLength: u32,
    Data: ?*anyopaque,
};

const DATE_TIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const DHCP_HOST_INFO = extern struct {
    IpAddress: u32,
    NetBiosName: ?*anyopaque,
    HostName: ?*anyopaque,
};

const DHCP_CLIENT_INFO_EX = extern struct {
    ClientIpAddress: u32,
    SubnetMask: u32,
    ClientHardwareAddress: DHCP_BINARY_DATA,
    ClientName: ?*anyopaque,
    ClientComment: ?*anyopaque,
    ClientLeaseExpires: DATE_TIME,
    OwnerHost: DHCP_HOST_INFO,
    bClientType: u8,
    AddressState: u8,
    Status: i32,
    ProbationEnds: DATE_TIME,
    QuarantineCapable: i32,
    FilterStatus: u32,
    PolicyName: ?*anyopaque,
    Properties: ?*anyopaque,
};

type
  DHCP_BINARY_DATA {.bycopy.} = object
    DataLength: uint32
    Data: pointer

  DATE_TIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  DHCP_HOST_INFO {.bycopy.} = object
    IpAddress: uint32
    NetBiosName: pointer
    HostName: pointer

  DHCP_CLIENT_INFO_EX {.bycopy.} = object
    ClientIpAddress: uint32
    SubnetMask: uint32
    ClientHardwareAddress: DHCP_BINARY_DATA
    ClientName: pointer
    ClientComment: pointer
    ClientLeaseExpires: DATE_TIME
    OwnerHost: DHCP_HOST_INFO
    bClientType: uint8
    AddressState: uint8
    Status: int32
    ProbationEnds: DATE_TIME
    QuarantineCapable: int32
    FilterStatus: uint32
    PolicyName: pointer
    Properties: pointer

struct DHCP_BINARY_DATA
{
    uint DataLength;
    void* Data;
}

struct DATE_TIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct DHCP_HOST_INFO
{
    uint IpAddress;
    void* NetBiosName;
    void* HostName;
}

struct DHCP_CLIENT_INFO_EX
{
    uint ClientIpAddress;
    uint SubnetMask;
    DHCP_BINARY_DATA ClientHardwareAddress;
    void* ClientName;
    void* ClientComment;
    DATE_TIME ClientLeaseExpires;
    DHCP_HOST_INFO OwnerHost;
    ubyte bClientType;
    ubyte AddressState;
    int Status;
    DATE_TIME ProbationEnds;
    int QuarantineCapable;
    uint FilterStatus;
    void* PolicyName;
    void* Properties;
}