FIXED_INFO_W2KSP1

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IP_ADDRESS_STRING
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public sbyte[] String;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IP_ADDR_STRING
{
    public IntPtr Next;
    public IP_ADDRESS_STRING IpAddress;
    public IP_ADDRESS_STRING IpMask;
    public uint Context;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FIXED_INFO_W2KSP1
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 132)] public sbyte[] HostName;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 132)] public sbyte[] DomainName;
    public IntPtr CurrentDnsServer;
    public IP_ADDR_STRING DnsServerList;
    public uint NodeType;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)] public sbyte[] ScopeId;
    public uint EnableRouting;
    public uint EnableProxy;
    public uint EnableDns;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IP_ADDRESS_STRING
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public String() As SByte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IP_ADDR_STRING
    Public Next As IntPtr
    Public IpAddress As IP_ADDRESS_STRING
    Public IpMask As IP_ADDRESS_STRING
    Public Context As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FIXED_INFO_W2KSP1
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=132)> Public HostName() As SByte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=132)> Public DomainName() As SByte
    Public CurrentDnsServer As IntPtr
    Public DnsServerList As IP_ADDR_STRING
    Public NodeType As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=260)> Public ScopeId() As SByte
    Public EnableRouting As UInteger
    Public EnableProxy As UInteger
    Public EnableDns As UInteger
End Structure

import ctypes
from ctypes import wintypes

class IP_ADDRESS_STRING(ctypes.Structure):
    _fields_ = [
        ("String", ctypes.c_byte * 16),
    ]

class IP_ADDR_STRING(ctypes.Structure):
    _fields_ = [
        ("Next", ctypes.c_void_p),
        ("IpAddress", IP_ADDRESS_STRING),
        ("IpMask", IP_ADDRESS_STRING),
        ("Context", wintypes.DWORD),
    ]

class FIXED_INFO_W2KSP1(ctypes.Structure):
    _fields_ = [
        ("HostName", ctypes.c_byte * 132),
        ("DomainName", ctypes.c_byte * 132),
        ("CurrentDnsServer", ctypes.c_void_p),
        ("DnsServerList", IP_ADDR_STRING),
        ("NodeType", wintypes.DWORD),
        ("ScopeId", ctypes.c_byte * 260),
        ("EnableRouting", wintypes.DWORD),
        ("EnableProxy", wintypes.DWORD),
        ("EnableDns", wintypes.DWORD),
    ]

#[repr(C)]
pub struct IP_ADDRESS_STRING {
    pub String: [i8; 16],
}

#[repr(C)]
pub struct IP_ADDR_STRING {
    pub Next: *mut core::ffi::c_void,
    pub IpAddress: IP_ADDRESS_STRING,
    pub IpMask: IP_ADDRESS_STRING,
    pub Context: u32,
}

#[repr(C)]
pub struct FIXED_INFO_W2KSP1 {
    pub HostName: [i8; 132],
    pub DomainName: [i8; 132],
    pub CurrentDnsServer: *mut core::ffi::c_void,
    pub DnsServerList: IP_ADDR_STRING,
    pub NodeType: u32,
    pub ScopeId: [i8; 260],
    pub EnableRouting: u32,
    pub EnableProxy: u32,
    pub EnableDns: u32,
}

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

type IP_ADDRESS_STRING struct {
	String [16]int8
}

type IP_ADDR_STRING struct {
	Next uintptr
	IpAddress IP_ADDRESS_STRING
	IpMask IP_ADDRESS_STRING
	Context uint32
}

type FIXED_INFO_W2KSP1 struct {
	HostName [132]int8
	DomainName [132]int8
	CurrentDnsServer uintptr
	DnsServerList IP_ADDR_STRING
	NodeType uint32
	ScopeId [260]int8
	EnableRouting uint32
	EnableProxy uint32
	EnableDns uint32
}

type
  IP_ADDRESS_STRING = record
    String: array[0..15] of Shortint;
  end;

  IP_ADDR_STRING = record
    Next: Pointer;
    IpAddress: IP_ADDRESS_STRING;
    IpMask: IP_ADDRESS_STRING;
    Context: DWORD;
  end;

  FIXED_INFO_W2KSP1 = record
    HostName: array[0..131] of Shortint;
    DomainName: array[0..131] of Shortint;
    CurrentDnsServer: Pointer;
    DnsServerList: IP_ADDR_STRING;
    NodeType: DWORD;
    ScopeId: array[0..259] of Shortint;
    EnableRouting: DWORD;
    EnableProxy: DWORD;
    EnableDns: DWORD;
  end;

const IP_ADDRESS_STRING = extern struct {
    String: [16]i8,
};

const IP_ADDR_STRING = extern struct {
    Next: ?*anyopaque,
    IpAddress: IP_ADDRESS_STRING,
    IpMask: IP_ADDRESS_STRING,
    Context: u32,
};

const FIXED_INFO_W2KSP1 = extern struct {
    HostName: [132]i8,
    DomainName: [132]i8,
    CurrentDnsServer: ?*anyopaque,
    DnsServerList: IP_ADDR_STRING,
    NodeType: u32,
    ScopeId: [260]i8,
    EnableRouting: u32,
    EnableProxy: u32,
    EnableDns: u32,
};

type
  IP_ADDRESS_STRING {.bycopy.} = object
    String: array[16, int8]

  IP_ADDR_STRING {.bycopy.} = object
    Next: pointer
    IpAddress: IP_ADDRESS_STRING
    IpMask: IP_ADDRESS_STRING
    Context: uint32

  FIXED_INFO_W2KSP1 {.bycopy.} = object
    HostName: array[132, int8]
    DomainName: array[132, int8]
    CurrentDnsServer: pointer
    DnsServerList: IP_ADDR_STRING
    NodeType: uint32
    ScopeId: array[260, int8]
    EnableRouting: uint32
    EnableProxy: uint32
    EnableDns: uint32

struct IP_ADDRESS_STRING
{
    byte[16] String;
}

struct IP_ADDR_STRING
{
    void* Next;
    IP_ADDRESS_STRING IpAddress;
    IP_ADDRESS_STRING IpMask;
    uint Context;
}

struct FIXED_INFO_W2KSP1
{
    byte[132] HostName;
    byte[132] DomainName;
    void* CurrentDnsServer;
    IP_ADDR_STRING DnsServerList;
    uint NodeType;
    byte[260] ScopeId;
    uint EnableRouting;
    uint EnableProxy;
    uint EnableDns;
}