DOT11_DEFAULT_WEP_OFFLOAD

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DOT11_IV48_COUNTER
{
    public uint uIV32Counter;
    public ushort usIV16Counter;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DOT11_DEFAULT_WEP_OFFLOAD
{
    public uint uReserved;
    public IntPtr hOffloadContext;
    public IntPtr hOffload;
    public uint dwIndex;
    public int dot11OffloadType;
    public uint dwAlgorithm;
    public uint uFlags;
    public int dot11KeyDirection;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public byte[] ucMacAddress;
    public uint uNumOfRWsOnMe;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public DOT11_IV48_COUNTER[] dot11IV48Counters;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public ushort[] usDot11RWBitMaps;
    public ushort usKeyLength;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public byte[] ucKey;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DOT11_IV48_COUNTER
    Public uIV32Counter As UInteger
    Public usIV16Counter As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DOT11_DEFAULT_WEP_OFFLOAD
    Public uReserved As UInteger
    Public hOffloadContext As IntPtr
    Public hOffload As IntPtr
    Public dwIndex As UInteger
    Public dot11OffloadType As Integer
    Public dwAlgorithm As UInteger
    Public uFlags As UInteger
    Public dot11KeyDirection As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=6)> Public ucMacAddress() As Byte
    Public uNumOfRWsOnMe As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public dot11IV48Counters() As DOT11_IV48_COUNTER
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public usDot11RWBitMaps() As UShort
    Public usKeyLength As UShort
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public ucKey() As Byte
End Structure

import ctypes
from ctypes import wintypes

class DOT11_IV48_COUNTER(ctypes.Structure):
    _fields_ = [
        ("uIV32Counter", wintypes.DWORD),
        ("usIV16Counter", ctypes.c_ushort),
    ]

class DOT11_DEFAULT_WEP_OFFLOAD(ctypes.Structure):
    _fields_ = [
        ("uReserved", wintypes.DWORD),
        ("hOffloadContext", ctypes.c_void_p),
        ("hOffload", ctypes.c_void_p),
        ("dwIndex", wintypes.DWORD),
        ("dot11OffloadType", ctypes.c_int),
        ("dwAlgorithm", wintypes.DWORD),
        ("uFlags", wintypes.DWORD),
        ("dot11KeyDirection", ctypes.c_int),
        ("ucMacAddress", ctypes.c_ubyte * 6),
        ("uNumOfRWsOnMe", wintypes.DWORD),
        ("dot11IV48Counters", DOT11_IV48_COUNTER * 16),
        ("usDot11RWBitMaps", ctypes.c_ushort * 16),
        ("usKeyLength", ctypes.c_ushort),
        ("ucKey", ctypes.c_ubyte * 1),
    ]

#[repr(C)]
pub struct DOT11_IV48_COUNTER {
    pub uIV32Counter: u32,
    pub usIV16Counter: u16,
}

#[repr(C)]
pub struct DOT11_DEFAULT_WEP_OFFLOAD {
    pub uReserved: u32,
    pub hOffloadContext: *mut core::ffi::c_void,
    pub hOffload: *mut core::ffi::c_void,
    pub dwIndex: u32,
    pub dot11OffloadType: i32,
    pub dwAlgorithm: u32,
    pub uFlags: u32,
    pub dot11KeyDirection: i32,
    pub ucMacAddress: [u8; 6],
    pub uNumOfRWsOnMe: u32,
    pub dot11IV48Counters: [DOT11_IV48_COUNTER; 16],
    pub usDot11RWBitMaps: [u16; 16],
    pub usKeyLength: u16,
    pub ucKey: [u8; 1],
}

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

type DOT11_IV48_COUNTER struct {
	uIV32Counter uint32
	usIV16Counter uint16
}

type DOT11_DEFAULT_WEP_OFFLOAD struct {
	uReserved uint32
	hOffloadContext uintptr
	hOffload uintptr
	dwIndex uint32
	dot11OffloadType int32
	dwAlgorithm uint32
	uFlags uint32
	dot11KeyDirection int32
	ucMacAddress [6]byte
	uNumOfRWsOnMe uint32
	dot11IV48Counters [16]DOT11_IV48_COUNTER
	usDot11RWBitMaps [16]uint16
	usKeyLength uint16
	ucKey [1]byte
}

type
  DOT11_IV48_COUNTER = record
    uIV32Counter: DWORD;
    usIV16Counter: Word;
  end;

  DOT11_DEFAULT_WEP_OFFLOAD = record
    uReserved: DWORD;
    hOffloadContext: Pointer;
    hOffload: Pointer;
    dwIndex: DWORD;
    dot11OffloadType: Integer;
    dwAlgorithm: DWORD;
    uFlags: DWORD;
    dot11KeyDirection: Integer;
    ucMacAddress: array[0..5] of Byte;
    uNumOfRWsOnMe: DWORD;
    dot11IV48Counters: array[0..15] of DOT11_IV48_COUNTER;
    usDot11RWBitMaps: array[0..15] of Word;
    usKeyLength: Word;
    ucKey: array[0..0] of Byte;
  end;

const DOT11_IV48_COUNTER = extern struct {
    uIV32Counter: u32,
    usIV16Counter: u16,
};

const DOT11_DEFAULT_WEP_OFFLOAD = extern struct {
    uReserved: u32,
    hOffloadContext: ?*anyopaque,
    hOffload: ?*anyopaque,
    dwIndex: u32,
    dot11OffloadType: i32,
    dwAlgorithm: u32,
    uFlags: u32,
    dot11KeyDirection: i32,
    ucMacAddress: [6]u8,
    uNumOfRWsOnMe: u32,
    dot11IV48Counters: [16]DOT11_IV48_COUNTER,
    usDot11RWBitMaps: [16]u16,
    usKeyLength: u16,
    ucKey: [1]u8,
};

type
  DOT11_IV48_COUNTER {.bycopy.} = object
    uIV32Counter: uint32
    usIV16Counter: uint16

  DOT11_DEFAULT_WEP_OFFLOAD {.bycopy.} = object
    uReserved: uint32
    hOffloadContext: pointer
    hOffload: pointer
    dwIndex: uint32
    dot11OffloadType: int32
    dwAlgorithm: uint32
    uFlags: uint32
    dot11KeyDirection: int32
    ucMacAddress: array[6, uint8]
    uNumOfRWsOnMe: uint32
    dot11IV48Counters: array[16, DOT11_IV48_COUNTER]
    usDot11RWBitMaps: array[16, uint16]
    usKeyLength: uint16
    ucKey: array[1, uint8]

struct DOT11_IV48_COUNTER
{
    uint uIV32Counter;
    ushort usIV16Counter;
}

struct DOT11_DEFAULT_WEP_OFFLOAD
{
    uint uReserved;
    void* hOffloadContext;
    void* hOffload;
    uint dwIndex;
    int dot11OffloadType;
    uint dwAlgorithm;
    uint uFlags;
    int dot11KeyDirection;
    ubyte[6] ucMacAddress;
    uint uNumOfRWsOnMe;
    DOT11_IV48_COUNTER[16] dot11IV48Counters;
    ushort[16] usDot11RWBitMaps;
    ushort usKeyLength;
    ubyte[1] ucKey;
}