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;
}