_DnsRecordOptA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DNS_HEADER_EXT
{
    public ushort _bitfield;
    public byte chRcode;
    public byte chVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _DnsRecordOptA
{
    public IntPtr pNext;
    public IntPtr pName;
    public ushort wType;
    public ushort wDataLength;
    public _Flags_e__Union Flags;
    public DNS_HEADER_EXT ExtHeader;
    public ushort wPayloadSize;
    public ushort wReserved;
    public _Data_e__Union Data;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DNS_HEADER_EXT
    Public _bitfield As UShort
    Public chRcode As Byte
    Public chVersion As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure _DnsRecordOptA
    Public pNext As IntPtr
    Public pName As IntPtr
    Public wType As UShort
    Public wDataLength As UShort
    Public Flags As _Flags_e__Union
    Public ExtHeader As DNS_HEADER_EXT
    Public wPayloadSize As UShort
    Public wReserved As UShort
    Public Data As _Data_e__Union
End Structure

import ctypes
from ctypes import wintypes

class DNS_HEADER_EXT(ctypes.Structure):
    _fields_ = [
        ("_bitfield", ctypes.c_ushort),
        ("chRcode", ctypes.c_ubyte),
        ("chVersion", ctypes.c_ubyte),
    ]

class _DnsRecordOptA(ctypes.Structure):
    _fields_ = [
        ("pNext", ctypes.c_void_p),
        ("pName", ctypes.c_void_p),
        ("wType", ctypes.c_ushort),
        ("wDataLength", ctypes.c_ushort),
        ("Flags", _Flags_e__Union),
        ("ExtHeader", DNS_HEADER_EXT),
        ("wPayloadSize", ctypes.c_ushort),
        ("wReserved", ctypes.c_ushort),
        ("Data", _Data_e__Union),
    ]

#[repr(C)]
pub struct DNS_HEADER_EXT {
    pub _bitfield: u16,
    pub chRcode: u8,
    pub chVersion: u8,
}

#[repr(C)]
pub struct _DnsRecordOptA {
    pub pNext: *mut core::ffi::c_void,
    pub pName: *mut core::ffi::c_void,
    pub wType: u16,
    pub wDataLength: u16,
    pub Flags: _Flags_e__Union,
    pub ExtHeader: DNS_HEADER_EXT,
    pub wPayloadSize: u16,
    pub wReserved: u16,
    pub Data: _Data_e__Union,
}

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

type DNS_HEADER_EXT struct {
	_bitfield uint16
	chRcode byte
	chVersion byte
}

type _DnsRecordOptA struct {
	pNext uintptr
	pName uintptr
	wType uint16
	wDataLength uint16
	Flags _Flags_e__Union
	ExtHeader DNS_HEADER_EXT
	wPayloadSize uint16
	wReserved uint16
	Data _Data_e__Union
}

type
  DNS_HEADER_EXT = record
    _bitfield: Word;
    chRcode: Byte;
    chVersion: Byte;
  end;

  _DnsRecordOptA = record
    pNext: Pointer;
    pName: Pointer;
    wType: Word;
    wDataLength: Word;
    Flags: _Flags_e__Union;
    ExtHeader: DNS_HEADER_EXT;
    wPayloadSize: Word;
    wReserved: Word;
    Data: _Data_e__Union;
  end;

const DNS_HEADER_EXT = extern struct {
    _bitfield: u16,
    chRcode: u8,
    chVersion: u8,
};

const _DnsRecordOptA = extern struct {
    pNext: ?*anyopaque,
    pName: ?*anyopaque,
    wType: u16,
    wDataLength: u16,
    Flags: _Flags_e__Union,
    ExtHeader: DNS_HEADER_EXT,
    wPayloadSize: u16,
    wReserved: u16,
    Data: _Data_e__Union,
};

type
  DNS_HEADER_EXT {.bycopy.} = object
    _bitfield: uint16
    chRcode: uint8
    chVersion: uint8

  _DnsRecordOptA {.bycopy.} = object
    pNext: pointer
    pName: pointer
    wType: uint16
    wDataLength: uint16
    Flags: _Flags_e__Union
    ExtHeader: DNS_HEADER_EXT
    wPayloadSize: uint16
    wReserved: uint16
    Data: _Data_e__Union

struct DNS_HEADER_EXT
{
    ushort _bitfield;
    ubyte chRcode;
    ubyte chVersion;
}

struct _DnsRecordOptA
{
    void* pNext;
    void* pName;
    ushort wType;
    ushort wDataLength;
    _Flags_e__Union Flags;
    DNS_HEADER_EXT ExtHeader;
    ushort wPayloadSize;
    ushort wReserved;
    _Data_e__Union Data;
}