SERVICE_ADDRESSES

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SERVICE_ADDRESS
{
    public uint dwAddressType;
    public uint dwAddressFlags;
    public uint dwAddressLength;
    public uint dwPrincipalLength;
    public IntPtr lpAddress;
    public IntPtr lpPrincipal;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SERVICE_ADDRESSES
{
    public uint dwAddressCount;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public SERVICE_ADDRESS[] Addresses;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SERVICE_ADDRESS
    Public dwAddressType As UInteger
    Public dwAddressFlags As UInteger
    Public dwAddressLength As UInteger
    Public dwPrincipalLength As UInteger
    Public lpAddress As IntPtr
    Public lpPrincipal As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SERVICE_ADDRESSES
    Public dwAddressCount As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Addresses() As SERVICE_ADDRESS
End Structure

import ctypes
from ctypes import wintypes

class SERVICE_ADDRESS(ctypes.Structure):
    _fields_ = [
        ("dwAddressType", wintypes.DWORD),
        ("dwAddressFlags", wintypes.DWORD),
        ("dwAddressLength", wintypes.DWORD),
        ("dwPrincipalLength", wintypes.DWORD),
        ("lpAddress", ctypes.c_void_p),
        ("lpPrincipal", ctypes.c_void_p),
    ]

class SERVICE_ADDRESSES(ctypes.Structure):
    _fields_ = [
        ("dwAddressCount", wintypes.DWORD),
        ("Addresses", SERVICE_ADDRESS * 1),
    ]

#[repr(C)]
pub struct SERVICE_ADDRESS {
    pub dwAddressType: u32,
    pub dwAddressFlags: u32,
    pub dwAddressLength: u32,
    pub dwPrincipalLength: u32,
    pub lpAddress: *mut core::ffi::c_void,
    pub lpPrincipal: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SERVICE_ADDRESSES {
    pub dwAddressCount: u32,
    pub Addresses: [SERVICE_ADDRESS; 1],
}

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

type SERVICE_ADDRESS struct {
	dwAddressType uint32
	dwAddressFlags uint32
	dwAddressLength uint32
	dwPrincipalLength uint32
	lpAddress uintptr
	lpPrincipal uintptr
}

type SERVICE_ADDRESSES struct {
	dwAddressCount uint32
	Addresses [1]SERVICE_ADDRESS
}

type
  SERVICE_ADDRESS = record
    dwAddressType: DWORD;
    dwAddressFlags: DWORD;
    dwAddressLength: DWORD;
    dwPrincipalLength: DWORD;
    lpAddress: Pointer;
    lpPrincipal: Pointer;
  end;

  SERVICE_ADDRESSES = record
    dwAddressCount: DWORD;
    Addresses: array[0..0] of SERVICE_ADDRESS;
  end;

const SERVICE_ADDRESS = extern struct {
    dwAddressType: u32,
    dwAddressFlags: u32,
    dwAddressLength: u32,
    dwPrincipalLength: u32,
    lpAddress: ?*anyopaque,
    lpPrincipal: ?*anyopaque,
};

const SERVICE_ADDRESSES = extern struct {
    dwAddressCount: u32,
    Addresses: [1]SERVICE_ADDRESS,
};

type
  SERVICE_ADDRESS {.bycopy.} = object
    dwAddressType: uint32
    dwAddressFlags: uint32
    dwAddressLength: uint32
    dwPrincipalLength: uint32
    lpAddress: pointer
    lpPrincipal: pointer

  SERVICE_ADDRESSES {.bycopy.} = object
    dwAddressCount: uint32
    Addresses: array[1, SERVICE_ADDRESS]

struct SERVICE_ADDRESS
{
    uint dwAddressType;
    uint dwAddressFlags;
    uint dwAddressLength;
    uint dwPrincipalLength;
    void* lpAddress;
    void* lpPrincipal;
}

struct SERVICE_ADDRESSES
{
    uint dwAddressCount;
    SERVICE_ADDRESS[1] Addresses;
}