ENUMERATION_BUFFER

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct TC_GEN_FILTER
{
    public ushort AddressType;
    public uint PatternSize;
    public IntPtr Pattern;
    public IntPtr Mask;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ENUMERATION_BUFFER
{
    public uint Length;
    public uint OwnerProcessId;
    public ushort FlowNameLength;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string FlowName;
    public IntPtr pFlow;
    public uint NumberOfFilters;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public TC_GEN_FILTER[] GenericFilter;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure TC_GEN_FILTER
    Public AddressType As UShort
    Public PatternSize As UInteger
    Public Pattern As IntPtr
    Public Mask As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ENUMERATION_BUFFER
    Public Length As UInteger
    Public OwnerProcessId As UInteger
    Public FlowNameLength As UShort
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public FlowName As String
    Public pFlow As IntPtr
    Public NumberOfFilters As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public GenericFilter() As TC_GEN_FILTER
End Structure

import ctypes
from ctypes import wintypes

class TC_GEN_FILTER(ctypes.Structure):
    _fields_ = [
        ("AddressType", ctypes.c_ushort),
        ("PatternSize", wintypes.DWORD),
        ("Pattern", ctypes.c_void_p),
        ("Mask", ctypes.c_void_p),
    ]

class ENUMERATION_BUFFER(ctypes.Structure):
    _fields_ = [
        ("Length", wintypes.DWORD),
        ("OwnerProcessId", wintypes.DWORD),
        ("FlowNameLength", ctypes.c_ushort),
        ("FlowName", ctypes.c_wchar * 256),
        ("pFlow", ctypes.c_void_p),
        ("NumberOfFilters", wintypes.DWORD),
        ("GenericFilter", TC_GEN_FILTER * 1),
    ]

#[repr(C)]
pub struct TC_GEN_FILTER {
    pub AddressType: u16,
    pub PatternSize: u32,
    pub Pattern: *mut core::ffi::c_void,
    pub Mask: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct ENUMERATION_BUFFER {
    pub Length: u32,
    pub OwnerProcessId: u32,
    pub FlowNameLength: u16,
    pub FlowName: [u16; 256],
    pub pFlow: *mut core::ffi::c_void,
    pub NumberOfFilters: u32,
    pub GenericFilter: [TC_GEN_FILTER; 1],
}

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

type TC_GEN_FILTER struct {
	AddressType uint16
	PatternSize uint32
	Pattern uintptr
	Mask uintptr
}

type ENUMERATION_BUFFER struct {
	Length uint32
	OwnerProcessId uint32
	FlowNameLength uint16
	FlowName [256]uint16
	pFlow uintptr
	NumberOfFilters uint32
	GenericFilter [1]TC_GEN_FILTER
}

type
  TC_GEN_FILTER = record
    AddressType: Word;
    PatternSize: DWORD;
    Pattern: Pointer;
    Mask: Pointer;
  end;

  ENUMERATION_BUFFER = record
    Length: DWORD;
    OwnerProcessId: DWORD;
    FlowNameLength: Word;
    FlowName: array[0..255] of WideChar;
    pFlow: Pointer;
    NumberOfFilters: DWORD;
    GenericFilter: array[0..0] of TC_GEN_FILTER;
  end;

const TC_GEN_FILTER = extern struct {
    AddressType: u16,
    PatternSize: u32,
    Pattern: ?*anyopaque,
    Mask: ?*anyopaque,
};

const ENUMERATION_BUFFER = extern struct {
    Length: u32,
    OwnerProcessId: u32,
    FlowNameLength: u16,
    FlowName: [256]u16,
    pFlow: ?*anyopaque,
    NumberOfFilters: u32,
    GenericFilter: [1]TC_GEN_FILTER,
};

type
  TC_GEN_FILTER {.bycopy.} = object
    AddressType: uint16
    PatternSize: uint32
    Pattern: pointer
    Mask: pointer

  ENUMERATION_BUFFER {.bycopy.} = object
    Length: uint32
    OwnerProcessId: uint32
    FlowNameLength: uint16
    FlowName: array[256, uint16]
    pFlow: pointer
    NumberOfFilters: uint32
    GenericFilter: array[1, TC_GEN_FILTER]

struct TC_GEN_FILTER
{
    ushort AddressType;
    uint PatternSize;
    void* Pattern;
    void* Mask;
}

struct ENUMERATION_BUFFER
{
    uint Length;
    uint OwnerProcessId;
    ushort FlowNameLength;
    wchar[256] FlowName;
    void* pFlow;
    uint NumberOfFilters;
    TC_GEN_FILTER[1] GenericFilter;
}