Win32 API 日本語リファレンス
ホーム › NetworkManagement.Dns › DNS_ADDR_ARRAY

DNS_ADDR_ARRAY

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 96 バイト / x86: 96 バイトパッキング1

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド型サイズx64x86説明
MaxCountDWORD4+0+0AddrArrayが収容可能な最大アドレス数を示す。
AddrCountDWORD4+4+4AddrArrayに実際に格納されているアドレス数を示す。
TagDWORD4+8+8用途を識別するためのタグ値。予約的に使用される。
FamilyWORD2+12+12格納アドレスのアドレスファミリを示す。AF_INETまたはAF_INET6。
WordReservedWORD2+14+14予約フィールド。使用されない。
FlagsDWORD4+16+16配列全体に適用されるフラグ値を保持する。
MatchFlagDWORD4+20+20アドレス照合動作を制御するフラグ値を保持する。
Reserved1DWORD4+24+24予約フィールド。使用されない。
Reserved2DWORD4+28+28予約フィールド。使用されない。
AddrArrayDNS_ADDR64+32+32DNS_ADDR要素を格納する可変長配列の先頭。

各言語での定義

#include <windows.h>

// DNS_ADDR  (x64 64 / x86 64 バイト)
typedef struct DNS_ADDR {
    CHAR MaxSa[32];
    _Data_e__Union Data;
} DNS_ADDR;

// DNS_ADDR_ARRAY  (x64 96 / x86 96 バイト)
#pragma pack(push, 1)
typedef struct DNS_ADDR_ARRAY {
    DWORD MaxCount;
    DWORD AddrCount;
    DWORD Tag;
    WORD Family;
    WORD WordReserved;
    DWORD Flags;
    DWORD MatchFlag;
    DWORD Reserved1;
    DWORD Reserved2;
    DNS_ADDR AddrArray[1];
} DNS_ADDR_ARRAY;
#pragma pack(pop)
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DNS_ADDR
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public sbyte[] MaxSa;
    public _Data_e__Union Data;
}

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct DNS_ADDR_ARRAY
{
    public uint MaxCount;
    public uint AddrCount;
    public uint Tag;
    public ushort Family;
    public ushort WordReserved;
    public uint Flags;
    public uint MatchFlag;
    public uint Reserved1;
    public uint Reserved2;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public DNS_ADDR[] AddrArray;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DNS_ADDR
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public MaxSa() As SByte
    Public Data As _Data_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure DNS_ADDR_ARRAY
    Public MaxCount As UInteger
    Public AddrCount As UInteger
    Public Tag As UInteger
    Public Family As UShort
    Public WordReserved As UShort
    Public Flags As UInteger
    Public MatchFlag As UInteger
    Public Reserved1 As UInteger
    Public Reserved2 As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public AddrArray() As DNS_ADDR
End Structure
import ctypes
from ctypes import wintypes

class DNS_ADDR(ctypes.Structure):
    _fields_ = [
        ("MaxSa", ctypes.c_byte * 32),
        ("Data", _Data_e__Union),
    ]

class DNS_ADDR_ARRAY(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("MaxCount", wintypes.DWORD),
        ("AddrCount", wintypes.DWORD),
        ("Tag", wintypes.DWORD),
        ("Family", ctypes.c_ushort),
        ("WordReserved", ctypes.c_ushort),
        ("Flags", wintypes.DWORD),
        ("MatchFlag", wintypes.DWORD),
        ("Reserved1", wintypes.DWORD),
        ("Reserved2", wintypes.DWORD),
        ("AddrArray", DNS_ADDR * 1),
    ]
#[repr(C)]
pub struct DNS_ADDR {
    pub MaxSa: [i8; 32],
    pub Data: _Data_e__Union,
}

#[repr(C, packed(1))]
pub struct DNS_ADDR_ARRAY {
    pub MaxCount: u32,
    pub AddrCount: u32,
    pub Tag: u32,
    pub Family: u16,
    pub WordReserved: u16,
    pub Flags: u32,
    pub MatchFlag: u32,
    pub Reserved1: u32,
    pub Reserved2: u32,
    pub AddrArray: [DNS_ADDR; 1],
}
import "golang.org/x/sys/windows"

type DNS_ADDR struct {
	MaxSa [32]int8
	Data _Data_e__Union
}

type DNS_ADDR_ARRAY struct {
	MaxCount uint32
	AddrCount uint32
	Tag uint32
	Family uint16
	WordReserved uint16
	Flags uint32
	MatchFlag uint32
	Reserved1 uint32
	Reserved2 uint32
	AddrArray [1]DNS_ADDR
}
type
  DNS_ADDR = record
    MaxSa: array[0..31] of Shortint;
    Data: _Data_e__Union;
  end;

  DNS_ADDR_ARRAY = packed record
    MaxCount: DWORD;
    AddrCount: DWORD;
    Tag: DWORD;
    Family: Word;
    WordReserved: Word;
    Flags: DWORD;
    MatchFlag: DWORD;
    Reserved1: DWORD;
    Reserved2: DWORD;
    AddrArray: array[0..0] of DNS_ADDR;
  end;
const DNS_ADDR = extern struct {
    MaxSa: [32]i8,
    Data: _Data_e__Union,
};

const DNS_ADDR_ARRAY = extern struct {
    MaxCount: u32,
    AddrCount: u32,
    Tag: u32,
    Family: u16,
    WordReserved: u16,
    Flags: u32,
    MatchFlag: u32,
    Reserved1: u32,
    Reserved2: u32,
    AddrArray: [1]DNS_ADDR,
};
type
  DNS_ADDR {.bycopy.} = object
    MaxSa: array[32, int8]
    Data: _Data_e__Union

  DNS_ADDR_ARRAY {.packed.} = object
    MaxCount: uint32
    AddrCount: uint32
    Tag: uint32
    Family: uint16
    WordReserved: uint16
    Flags: uint32
    MatchFlag: uint32
    Reserved1: uint32
    Reserved2: uint32
    AddrArray: array[1, DNS_ADDR]
struct DNS_ADDR
{
    byte[32] MaxSa;
    _Data_e__Union Data;
}

align(1)
struct DNS_ADDR_ARRAY
{
    uint MaxCount;
    uint AddrCount;
    uint Tag;
    ushort Family;
    ushort WordReserved;
    uint Flags;
    uint MatchFlag;
    uint Reserved1;
    uint Reserved2;
    DNS_ADDR[1] AddrArray;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; DNS_ADDR_ARRAY サイズ: 96 バイト(x64)
dim st, 24    ; 4byte整数×24(構造体サイズ 96 / 4 切り上げ)
; MaxCount : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; AddrCount : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; Tag : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; Family : WORD (+12, 2byte)  wpoke st,12,値  /  値 = wpeek(st,12)
; WordReserved : WORD (+14, 2byte)  wpoke st,14,値  /  値 = wpeek(st,14)
; Flags : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; MatchFlag : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; Reserved1 : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; Reserved2 : DWORD (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; AddrArray : DNS_ADDR (+32, 64byte)  varptr(st)+32 を基点に操作(64byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global DNS_ADDR
    #field byte MaxSa 32
    #field byte Data 32
#endstruct

#defstruct global DNS_ADDR_ARRAY, pack=1
    #field int MaxCount
    #field int AddrCount
    #field int Tag
    #field short Family
    #field short WordReserved
    #field int Flags
    #field int MatchFlag
    #field int Reserved1
    #field int Reserved2
    #field DNS_ADDR AddrArray 1
#endstruct

stdim st, DNS_ADDR_ARRAY        ; NSTRUCT 変数を確保
st->MaxCount = 100
mes "MaxCount=" + st->MaxCount