ホーム › NetworkManagement.WindowsFilteringPlatform › IPSEC_DOSP_OPTIONS0

IPSEC_DOSP_OPTIONS0

構造体

サイズx64: 136 バイト / x86: 116 バイト

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

フィールド

フィールド	型	サイズ	x64	x86	説明
stateIdleTimeoutSeconds	DWORD	4	+0	+0	状態エントリをアイドルで削除するまでの秒数。
perIPRateLimitQueueIdleTimeoutSeconds	DWORD	4	+4	+4	IP単位レート制限キューのアイドルタイムアウト秒数。
ipV6IPsecUnauthDscp	BYTE	1	+8	+8	未認証IPv6 IPsecトラフィックに付与するDSCP値。
ipV6IPsecUnauthRateLimitBytesPerSec	DWORD	4	+12	+12	未認証IPv6 IPsecの全体レート制限(バイト/秒)。
ipV6IPsecUnauthPerIPRateLimitBytesPerSec	DWORD	4	+16	+16	未認証IPv6 IPsecのIP単位レート制限(バイト/秒)。
ipV6IPsecAuthDscp	BYTE	1	+20	+20	認証済みIPv6 IPsecトラフィックに付与するDSCP値。
ipV6IPsecAuthRateLimitBytesPerSec	DWORD	4	+24	+24	認証済みIPv6 IPsecのレート制限(バイト/秒)。
icmpV6Dscp	BYTE	1	+28	+28	ICMPv6トラフィックに付与するDSCP値。
icmpV6RateLimitBytesPerSec	DWORD	4	+32	+32	ICMPv6のレート制限(バイト/秒)。
ipV6FilterExemptDscp	BYTE	1	+36	+36	フィルター免除IPv6トラフィックに付与するDSCP値。
ipV6FilterExemptRateLimitBytesPerSec	DWORD	4	+40	+40	フィルター免除IPv6のレート制限(バイト/秒)。
defBlockExemptDscp	BYTE	1	+44	+44	既定ブロック免除トラフィックに付与するDSCP値。
defBlockExemptRateLimitBytesPerSec	DWORD	4	+48	+48	既定ブロック免除のレート制限(バイト/秒)。
maxStateEntries	DWORD	4	+52	+52	保持できる状態エントリの最大数。
maxPerIPRateLimitQueues	DWORD	4	+56	+56	保持できるIP単位レート制限キューの最大数。
flags	IPSEC_DOSP_FLAGS	4	+60	+60	DoS防御の動作を制御するフラグ(IPSEC_DOSP_FLAGS)。
numPublicIFLuids	DWORD	4	+64	+64	publicIFLuids配列の要素数。
publicIFLuids	ULONGLONG*	8/4	+72	+68	公衆側インターフェイスのLUID配列へのポインター。
numInternalIFLuids	DWORD	4	+80	+72	internalIFLuids配列の要素数。
internalIFLuids	ULONGLONG*	8/4	+88	+76	内部側インターフェイスのLUID配列へのポインター。
publicV6AddrMask	FWP_V6_ADDR_AND_MASK	17	+96	+80	公衆側IPv6アドレスとマスク。
internalV6AddrMask	FWP_V6_ADDR_AND_MASK	17	+113	+97	内部側IPv6アドレスとマスク。

各言語での定義

#include <windows.h>

// FWP_V6_ADDR_AND_MASK  (x64 17 / x86 17 バイト)
typedef struct FWP_V6_ADDR_AND_MASK {
    BYTE addr[16];
    BYTE prefixLength;
} FWP_V6_ADDR_AND_MASK;

// IPSEC_DOSP_OPTIONS0  (x64 136 / x86 116 バイト)
typedef struct IPSEC_DOSP_OPTIONS0 {
    DWORD stateIdleTimeoutSeconds;
    DWORD perIPRateLimitQueueIdleTimeoutSeconds;
    BYTE ipV6IPsecUnauthDscp;
    DWORD ipV6IPsecUnauthRateLimitBytesPerSec;
    DWORD ipV6IPsecUnauthPerIPRateLimitBytesPerSec;
    BYTE ipV6IPsecAuthDscp;
    DWORD ipV6IPsecAuthRateLimitBytesPerSec;
    BYTE icmpV6Dscp;
    DWORD icmpV6RateLimitBytesPerSec;
    BYTE ipV6FilterExemptDscp;
    DWORD ipV6FilterExemptRateLimitBytesPerSec;
    BYTE defBlockExemptDscp;
    DWORD defBlockExemptRateLimitBytesPerSec;
    DWORD maxStateEntries;
    DWORD maxPerIPRateLimitQueues;
    IPSEC_DOSP_FLAGS flags;
    DWORD numPublicIFLuids;
    ULONGLONG* publicIFLuids;
    DWORD numInternalIFLuids;
    ULONGLONG* internalIFLuids;
    FWP_V6_ADDR_AND_MASK publicV6AddrMask;
    FWP_V6_ADDR_AND_MASK internalV6AddrMask;
} IPSEC_DOSP_OPTIONS0;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FWP_V6_ADDR_AND_MASK
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public byte[] addr;
    public byte prefixLength;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IPSEC_DOSP_OPTIONS0
{
    public uint stateIdleTimeoutSeconds;
    public uint perIPRateLimitQueueIdleTimeoutSeconds;
    public byte ipV6IPsecUnauthDscp;
    public uint ipV6IPsecUnauthRateLimitBytesPerSec;
    public uint ipV6IPsecUnauthPerIPRateLimitBytesPerSec;
    public byte ipV6IPsecAuthDscp;
    public uint ipV6IPsecAuthRateLimitBytesPerSec;
    public byte icmpV6Dscp;
    public uint icmpV6RateLimitBytesPerSec;
    public byte ipV6FilterExemptDscp;
    public uint ipV6FilterExemptRateLimitBytesPerSec;
    public byte defBlockExemptDscp;
    public uint defBlockExemptRateLimitBytesPerSec;
    public uint maxStateEntries;
    public uint maxPerIPRateLimitQueues;
    public uint flags;
    public uint numPublicIFLuids;
    public IntPtr publicIFLuids;
    public uint numInternalIFLuids;
    public IntPtr internalIFLuids;
    public FWP_V6_ADDR_AND_MASK publicV6AddrMask;
    public FWP_V6_ADDR_AND_MASK internalV6AddrMask;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FWP_V6_ADDR_AND_MASK
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public addr() As Byte
    Public prefixLength As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IPSEC_DOSP_OPTIONS0
    Public stateIdleTimeoutSeconds As UInteger
    Public perIPRateLimitQueueIdleTimeoutSeconds As UInteger
    Public ipV6IPsecUnauthDscp As Byte
    Public ipV6IPsecUnauthRateLimitBytesPerSec As UInteger
    Public ipV6IPsecUnauthPerIPRateLimitBytesPerSec As UInteger
    Public ipV6IPsecAuthDscp As Byte
    Public ipV6IPsecAuthRateLimitBytesPerSec As UInteger
    Public icmpV6Dscp As Byte
    Public icmpV6RateLimitBytesPerSec As UInteger
    Public ipV6FilterExemptDscp As Byte
    Public ipV6FilterExemptRateLimitBytesPerSec As UInteger
    Public defBlockExemptDscp As Byte
    Public defBlockExemptRateLimitBytesPerSec As UInteger
    Public maxStateEntries As UInteger
    Public maxPerIPRateLimitQueues As UInteger
    Public flags As UInteger
    Public numPublicIFLuids As UInteger
    Public publicIFLuids As IntPtr
    Public numInternalIFLuids As UInteger
    Public internalIFLuids As IntPtr
    Public publicV6AddrMask As FWP_V6_ADDR_AND_MASK
    Public internalV6AddrMask As FWP_V6_ADDR_AND_MASK
End Structure

import ctypes
from ctypes import wintypes

class FWP_V6_ADDR_AND_MASK(ctypes.Structure):
    _fields_ = [
        ("addr", ctypes.c_ubyte * 16),
        ("prefixLength", ctypes.c_ubyte),
    ]

class IPSEC_DOSP_OPTIONS0(ctypes.Structure):
    _fields_ = [
        ("stateIdleTimeoutSeconds", wintypes.DWORD),
        ("perIPRateLimitQueueIdleTimeoutSeconds", wintypes.DWORD),
        ("ipV6IPsecUnauthDscp", ctypes.c_ubyte),
        ("ipV6IPsecUnauthRateLimitBytesPerSec", wintypes.DWORD),
        ("ipV6IPsecUnauthPerIPRateLimitBytesPerSec", wintypes.DWORD),
        ("ipV6IPsecAuthDscp", ctypes.c_ubyte),
        ("ipV6IPsecAuthRateLimitBytesPerSec", wintypes.DWORD),
        ("icmpV6Dscp", ctypes.c_ubyte),
        ("icmpV6RateLimitBytesPerSec", wintypes.DWORD),
        ("ipV6FilterExemptDscp", ctypes.c_ubyte),
        ("ipV6FilterExemptRateLimitBytesPerSec", wintypes.DWORD),
        ("defBlockExemptDscp", ctypes.c_ubyte),
        ("defBlockExemptRateLimitBytesPerSec", wintypes.DWORD),
        ("maxStateEntries", wintypes.DWORD),
        ("maxPerIPRateLimitQueues", wintypes.DWORD),
        ("flags", wintypes.DWORD),
        ("numPublicIFLuids", wintypes.DWORD),
        ("publicIFLuids", ctypes.c_void_p),
        ("numInternalIFLuids", wintypes.DWORD),
        ("internalIFLuids", ctypes.c_void_p),
        ("publicV6AddrMask", FWP_V6_ADDR_AND_MASK),
        ("internalV6AddrMask", FWP_V6_ADDR_AND_MASK),
    ]

#[repr(C)]
pub struct FWP_V6_ADDR_AND_MASK {
    pub addr: [u8; 16],
    pub prefixLength: u8,
}

#[repr(C)]
pub struct IPSEC_DOSP_OPTIONS0 {
    pub stateIdleTimeoutSeconds: u32,
    pub perIPRateLimitQueueIdleTimeoutSeconds: u32,
    pub ipV6IPsecUnauthDscp: u8,
    pub ipV6IPsecUnauthRateLimitBytesPerSec: u32,
    pub ipV6IPsecUnauthPerIPRateLimitBytesPerSec: u32,
    pub ipV6IPsecAuthDscp: u8,
    pub ipV6IPsecAuthRateLimitBytesPerSec: u32,
    pub icmpV6Dscp: u8,
    pub icmpV6RateLimitBytesPerSec: u32,
    pub ipV6FilterExemptDscp: u8,
    pub ipV6FilterExemptRateLimitBytesPerSec: u32,
    pub defBlockExemptDscp: u8,
    pub defBlockExemptRateLimitBytesPerSec: u32,
    pub maxStateEntries: u32,
    pub maxPerIPRateLimitQueues: u32,
    pub flags: u32,
    pub numPublicIFLuids: u32,
    pub publicIFLuids: *mut core::ffi::c_void,
    pub numInternalIFLuids: u32,
    pub internalIFLuids: *mut core::ffi::c_void,
    pub publicV6AddrMask: FWP_V6_ADDR_AND_MASK,
    pub internalV6AddrMask: FWP_V6_ADDR_AND_MASK,
}

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

type FWP_V6_ADDR_AND_MASK struct {
	addr [16]byte
	prefixLength byte
}

type IPSEC_DOSP_OPTIONS0 struct {
	stateIdleTimeoutSeconds uint32
	perIPRateLimitQueueIdleTimeoutSeconds uint32
	ipV6IPsecUnauthDscp byte
	ipV6IPsecUnauthRateLimitBytesPerSec uint32
	ipV6IPsecUnauthPerIPRateLimitBytesPerSec uint32
	ipV6IPsecAuthDscp byte
	ipV6IPsecAuthRateLimitBytesPerSec uint32
	icmpV6Dscp byte
	icmpV6RateLimitBytesPerSec uint32
	ipV6FilterExemptDscp byte
	ipV6FilterExemptRateLimitBytesPerSec uint32
	defBlockExemptDscp byte
	defBlockExemptRateLimitBytesPerSec uint32
	maxStateEntries uint32
	maxPerIPRateLimitQueues uint32
	flags uint32
	numPublicIFLuids uint32
	publicIFLuids uintptr
	numInternalIFLuids uint32
	internalIFLuids uintptr
	publicV6AddrMask FWP_V6_ADDR_AND_MASK
	internalV6AddrMask FWP_V6_ADDR_AND_MASK
}

type
  FWP_V6_ADDR_AND_MASK = record
    addr: array[0..15] of Byte;
    prefixLength: Byte;
  end;

  IPSEC_DOSP_OPTIONS0 = record
    stateIdleTimeoutSeconds: DWORD;
    perIPRateLimitQueueIdleTimeoutSeconds: DWORD;
    ipV6IPsecUnauthDscp: Byte;
    ipV6IPsecUnauthRateLimitBytesPerSec: DWORD;
    ipV6IPsecUnauthPerIPRateLimitBytesPerSec: DWORD;
    ipV6IPsecAuthDscp: Byte;
    ipV6IPsecAuthRateLimitBytesPerSec: DWORD;
    icmpV6Dscp: Byte;
    icmpV6RateLimitBytesPerSec: DWORD;
    ipV6FilterExemptDscp: Byte;
    ipV6FilterExemptRateLimitBytesPerSec: DWORD;
    defBlockExemptDscp: Byte;
    defBlockExemptRateLimitBytesPerSec: DWORD;
    maxStateEntries: DWORD;
    maxPerIPRateLimitQueues: DWORD;
    flags: DWORD;
    numPublicIFLuids: DWORD;
    publicIFLuids: Pointer;
    numInternalIFLuids: DWORD;
    internalIFLuids: Pointer;
    publicV6AddrMask: FWP_V6_ADDR_AND_MASK;
    internalV6AddrMask: FWP_V6_ADDR_AND_MASK;
  end;

const FWP_V6_ADDR_AND_MASK = extern struct {
    addr: [16]u8,
    prefixLength: u8,
};

const IPSEC_DOSP_OPTIONS0 = extern struct {
    stateIdleTimeoutSeconds: u32,
    perIPRateLimitQueueIdleTimeoutSeconds: u32,
    ipV6IPsecUnauthDscp: u8,
    ipV6IPsecUnauthRateLimitBytesPerSec: u32,
    ipV6IPsecUnauthPerIPRateLimitBytesPerSec: u32,
    ipV6IPsecAuthDscp: u8,
    ipV6IPsecAuthRateLimitBytesPerSec: u32,
    icmpV6Dscp: u8,
    icmpV6RateLimitBytesPerSec: u32,
    ipV6FilterExemptDscp: u8,
    ipV6FilterExemptRateLimitBytesPerSec: u32,
    defBlockExemptDscp: u8,
    defBlockExemptRateLimitBytesPerSec: u32,
    maxStateEntries: u32,
    maxPerIPRateLimitQueues: u32,
    flags: u32,
    numPublicIFLuids: u32,
    publicIFLuids: ?*anyopaque,
    numInternalIFLuids: u32,
    internalIFLuids: ?*anyopaque,
    publicV6AddrMask: FWP_V6_ADDR_AND_MASK,
    internalV6AddrMask: FWP_V6_ADDR_AND_MASK,
};

type
  FWP_V6_ADDR_AND_MASK {.bycopy.} = object
    addr: array[16, uint8]
    prefixLength: uint8

  IPSEC_DOSP_OPTIONS0 {.bycopy.} = object
    stateIdleTimeoutSeconds: uint32
    perIPRateLimitQueueIdleTimeoutSeconds: uint32
    ipV6IPsecUnauthDscp: uint8
    ipV6IPsecUnauthRateLimitBytesPerSec: uint32
    ipV6IPsecUnauthPerIPRateLimitBytesPerSec: uint32
    ipV6IPsecAuthDscp: uint8
    ipV6IPsecAuthRateLimitBytesPerSec: uint32
    icmpV6Dscp: uint8
    icmpV6RateLimitBytesPerSec: uint32
    ipV6FilterExemptDscp: uint8
    ipV6FilterExemptRateLimitBytesPerSec: uint32
    defBlockExemptDscp: uint8
    defBlockExemptRateLimitBytesPerSec: uint32
    maxStateEntries: uint32
    maxPerIPRateLimitQueues: uint32
    flags: uint32
    numPublicIFLuids: uint32
    publicIFLuids: pointer
    numInternalIFLuids: uint32
    internalIFLuids: pointer
    publicV6AddrMask: FWP_V6_ADDR_AND_MASK
    internalV6AddrMask: FWP_V6_ADDR_AND_MASK

struct FWP_V6_ADDR_AND_MASK
{
    ubyte[16] addr;
    ubyte prefixLength;
}

struct IPSEC_DOSP_OPTIONS0
{
    uint stateIdleTimeoutSeconds;
    uint perIPRateLimitQueueIdleTimeoutSeconds;
    ubyte ipV6IPsecUnauthDscp;
    uint ipV6IPsecUnauthRateLimitBytesPerSec;
    uint ipV6IPsecUnauthPerIPRateLimitBytesPerSec;
    ubyte ipV6IPsecAuthDscp;
    uint ipV6IPsecAuthRateLimitBytesPerSec;
    ubyte icmpV6Dscp;
    uint icmpV6RateLimitBytesPerSec;
    ubyte ipV6FilterExemptDscp;
    uint ipV6FilterExemptRateLimitBytesPerSec;
    ubyte defBlockExemptDscp;
    uint defBlockExemptRateLimitBytesPerSec;
    uint maxStateEntries;
    uint maxPerIPRateLimitQueues;
    uint flags;
    uint numPublicIFLuids;
    void* publicIFLuids;
    uint numInternalIFLuids;
    void* internalIFLuids;
    FWP_V6_ADDR_AND_MASK publicV6AddrMask;
    FWP_V6_ADDR_AND_MASK internalV6AddrMask;
}

HSP用定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; IPSEC_DOSP_OPTIONS0 サイズ: 116 バイト(x86)
dim st, 29    ; 4byte整数×29(構造体サイズ 116 / 4 切り上げ)
; stateIdleTimeoutSeconds : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; perIPRateLimitQueueIdleTimeoutSeconds : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; ipV6IPsecUnauthDscp : BYTE (+8, 1byte)  poke st,8,値  /  値 = peek(st,8)
; ipV6IPsecUnauthRateLimitBytesPerSec : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; ipV6IPsecUnauthPerIPRateLimitBytesPerSec : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; ipV6IPsecAuthDscp : BYTE (+20, 1byte)  poke st,20,値  /  値 = peek(st,20)
; ipV6IPsecAuthRateLimitBytesPerSec : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; icmpV6Dscp : BYTE (+28, 1byte)  poke st,28,値  /  値 = peek(st,28)
; icmpV6RateLimitBytesPerSec : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; ipV6FilterExemptDscp : BYTE (+36, 1byte)  poke st,36,値  /  値 = peek(st,36)
; ipV6FilterExemptRateLimitBytesPerSec : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; defBlockExemptDscp : BYTE (+44, 1byte)  poke st,44,値  /  値 = peek(st,44)
; defBlockExemptRateLimitBytesPerSec : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; maxStateEntries : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; maxPerIPRateLimitQueues : DWORD (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; flags : IPSEC_DOSP_FLAGS (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; numPublicIFLuids : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; publicIFLuids : ULONGLONG* (+68, 4byte)  st.17 = 値  /  値 = st.17   (lpoke/lpeek も可)
; numInternalIFLuids : DWORD (+72, 4byte)  st.18 = 値  /  値 = st.18   (lpoke/lpeek も可)
; internalIFLuids : ULONGLONG* (+76, 4byte)  st.19 = 値  /  値 = st.19   (lpoke/lpeek も可)
; publicV6AddrMask : FWP_V6_ADDR_AND_MASK (+80, 17byte)  varptr(st)+80 を基点に操作(17byte:入れ子/配列)
; internalV6AddrMask : FWP_V6_ADDR_AND_MASK (+97, 17byte)  varptr(st)+97 を基点に操作(17byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; IPSEC_DOSP_OPTIONS0 サイズ: 136 バイト(x64)
dim st, 34    ; 4byte整数×34(構造体サイズ 136 / 4 切り上げ)
; stateIdleTimeoutSeconds : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; perIPRateLimitQueueIdleTimeoutSeconds : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; ipV6IPsecUnauthDscp : BYTE (+8, 1byte)  poke st,8,値  /  値 = peek(st,8)
; ipV6IPsecUnauthRateLimitBytesPerSec : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; ipV6IPsecUnauthPerIPRateLimitBytesPerSec : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; ipV6IPsecAuthDscp : BYTE (+20, 1byte)  poke st,20,値  /  値 = peek(st,20)
; ipV6IPsecAuthRateLimitBytesPerSec : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; icmpV6Dscp : BYTE (+28, 1byte)  poke st,28,値  /  値 = peek(st,28)
; icmpV6RateLimitBytesPerSec : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; ipV6FilterExemptDscp : BYTE (+36, 1byte)  poke st,36,値  /  値 = peek(st,36)
; ipV6FilterExemptRateLimitBytesPerSec : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; defBlockExemptDscp : BYTE (+44, 1byte)  poke st,44,値  /  値 = peek(st,44)
; defBlockExemptRateLimitBytesPerSec : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; maxStateEntries : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; maxPerIPRateLimitQueues : DWORD (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; flags : IPSEC_DOSP_FLAGS (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; numPublicIFLuids : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; publicIFLuids : ULONGLONG* (+72, 8byte)  qpoke st,72,値 / qpeek(st,72)  ※IronHSPのみ。3.7/3.8は lpoke st,72,下位 : lpoke st,76,上位
; numInternalIFLuids : DWORD (+80, 4byte)  st.20 = 値  /  値 = st.20   (lpoke/lpeek も可)
; internalIFLuids : ULONGLONG* (+88, 8byte)  qpoke st,88,値 / qpeek(st,88)  ※IronHSPのみ。3.7/3.8は lpoke st,88,下位 : lpoke st,92,上位
; publicV6AddrMask : FWP_V6_ADDR_AND_MASK (+96, 17byte)  varptr(st)+96 を基点に操作(17byte:入れ子/配列)
; internalV6AddrMask : FWP_V6_ADDR_AND_MASK (+113, 17byte)  varptr(st)+113 を基点に操作(17byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global FWP_V6_ADDR_AND_MASK
    #field byte addr 16
    #field byte prefixLength
#endstruct

#defstruct global IPSEC_DOSP_OPTIONS0
    #field int stateIdleTimeoutSeconds
    #field int perIPRateLimitQueueIdleTimeoutSeconds
    #field byte ipV6IPsecUnauthDscp
    #field int ipV6IPsecUnauthRateLimitBytesPerSec
    #field int ipV6IPsecUnauthPerIPRateLimitBytesPerSec
    #field byte ipV6IPsecAuthDscp
    #field int ipV6IPsecAuthRateLimitBytesPerSec
    #field byte icmpV6Dscp
    #field int icmpV6RateLimitBytesPerSec
    #field byte ipV6FilterExemptDscp
    #field int ipV6FilterExemptRateLimitBytesPerSec
    #field byte defBlockExemptDscp
    #field int defBlockExemptRateLimitBytesPerSec
    #field int maxStateEntries
    #field int maxPerIPRateLimitQueues
    #field int flags
    #field int numPublicIFLuids
    #field intptr publicIFLuids
    #field int numInternalIFLuids
    #field intptr internalIFLuids
    #field FWP_V6_ADDR_AND_MASK publicV6AddrMask
    #field FWP_V6_ADDR_AND_MASK internalV6AddrMask
#endstruct

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

IPSEC_DOSP_OPTIONS0

フィールド

各言語での定義

HSP用 定義

HSP用定義