DHCPV4_FAILOVER_CLIENT_INFO

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 DHCPV4_FAILOVER_CLIENT_INFO
{
    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 SentPotExpTime;
    public uint AckPotExpTime;
    public uint RecvPotExpTime;
    public uint StartTime;
    public uint CltLastTransTime;
    public uint LastBndUpdTime;
    public uint BndMsgStatus;
    public IntPtr PolicyName;
    public byte Flags;
}

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 DHCPV4_FAILOVER_CLIENT_INFO
    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 SentPotExpTime As UInteger
    Public AckPotExpTime As UInteger
    Public RecvPotExpTime As UInteger
    Public StartTime As UInteger
    Public CltLastTransTime As UInteger
    Public LastBndUpdTime As UInteger
    Public BndMsgStatus As UInteger
    Public PolicyName As IntPtr
    Public Flags As Byte
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 DHCPV4_FAILOVER_CLIENT_INFO(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),
        ("SentPotExpTime", wintypes.DWORD),
        ("AckPotExpTime", wintypes.DWORD),
        ("RecvPotExpTime", wintypes.DWORD),
        ("StartTime", wintypes.DWORD),
        ("CltLastTransTime", wintypes.DWORD),
        ("LastBndUpdTime", wintypes.DWORD),
        ("BndMsgStatus", wintypes.DWORD),
        ("PolicyName", ctypes.c_void_p),
        ("Flags", ctypes.c_ubyte),
    ]

#[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 DHCPV4_FAILOVER_CLIENT_INFO {
    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 SentPotExpTime: u32,
    pub AckPotExpTime: u32,
    pub RecvPotExpTime: u32,
    pub StartTime: u32,
    pub CltLastTransTime: u32,
    pub LastBndUpdTime: u32,
    pub BndMsgStatus: u32,
    pub PolicyName: *mut core::ffi::c_void,
    pub Flags: u8,
}

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 DHCPV4_FAILOVER_CLIENT_INFO 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
	SentPotExpTime uint32
	AckPotExpTime uint32
	RecvPotExpTime uint32
	StartTime uint32
	CltLastTransTime uint32
	LastBndUpdTime uint32
	BndMsgStatus uint32
	PolicyName uintptr
	Flags byte
}

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;

  DHCPV4_FAILOVER_CLIENT_INFO = 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;
    SentPotExpTime: DWORD;
    AckPotExpTime: DWORD;
    RecvPotExpTime: DWORD;
    StartTime: DWORD;
    CltLastTransTime: DWORD;
    LastBndUpdTime: DWORD;
    BndMsgStatus: DWORD;
    PolicyName: Pointer;
    Flags: Byte;
  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 DHCPV4_FAILOVER_CLIENT_INFO = 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,
    SentPotExpTime: u32,
    AckPotExpTime: u32,
    RecvPotExpTime: u32,
    StartTime: u32,
    CltLastTransTime: u32,
    LastBndUpdTime: u32,
    BndMsgStatus: u32,
    PolicyName: ?*anyopaque,
    Flags: u8,
};

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

  DHCPV4_FAILOVER_CLIENT_INFO {.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
    SentPotExpTime: uint32
    AckPotExpTime: uint32
    RecvPotExpTime: uint32
    StartTime: uint32
    CltLastTransTime: uint32
    LastBndUpdTime: uint32
    BndMsgStatus: uint32
    PolicyName: pointer
    Flags: uint8

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 DHCPV4_FAILOVER_CLIENT_INFO
{
    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 SentPotExpTime;
    uint AckPotExpTime;
    uint RecvPotExpTime;
    uint StartTime;
    uint CltLastTransTime;
    uint LastBndUpdTime;
    uint BndMsgStatus;
    void* PolicyName;
    ubyte Flags;
}