EXTENSION_CONTROL_BLOCK

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct EXTENSION_CONTROL_BLOCK
{
    public uint cbSize;
    public uint dwVersion;
    public IntPtr ConnID;
    public uint dwHttpStatusCode;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)] public sbyte[] lpszLogData;
    public IntPtr lpszMethod;
    public IntPtr lpszQueryString;
    public IntPtr lpszPathInfo;
    public IntPtr lpszPathTranslated;
    public uint cbTotalBytes;
    public uint cbAvailable;
    public IntPtr lpbData;
    public IntPtr lpszContentType;
    public IntPtr GetServerVariable;
    public IntPtr WriteClient;
    public IntPtr ReadClient;
    public IntPtr ServerSupportFunction;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure EXTENSION_CONTROL_BLOCK
    Public cbSize As UInteger
    Public dwVersion As UInteger
    Public ConnID As IntPtr
    Public dwHttpStatusCode As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=80)> Public lpszLogData() As SByte
    Public lpszMethod As IntPtr
    Public lpszQueryString As IntPtr
    Public lpszPathInfo As IntPtr
    Public lpszPathTranslated As IntPtr
    Public cbTotalBytes As UInteger
    Public cbAvailable As UInteger
    Public lpbData As IntPtr
    Public lpszContentType As IntPtr
    Public GetServerVariable As IntPtr
    Public WriteClient As IntPtr
    Public ReadClient As IntPtr
    Public ServerSupportFunction As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class EXTENSION_CONTROL_BLOCK(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("dwVersion", wintypes.DWORD),
        ("ConnID", ctypes.c_void_p),
        ("dwHttpStatusCode", wintypes.DWORD),
        ("lpszLogData", ctypes.c_byte * 80),
        ("lpszMethod", ctypes.c_void_p),
        ("lpszQueryString", ctypes.c_void_p),
        ("lpszPathInfo", ctypes.c_void_p),
        ("lpszPathTranslated", ctypes.c_void_p),
        ("cbTotalBytes", wintypes.DWORD),
        ("cbAvailable", wintypes.DWORD),
        ("lpbData", ctypes.c_void_p),
        ("lpszContentType", ctypes.c_void_p),
        ("GetServerVariable", ctypes.c_void_p),
        ("WriteClient", ctypes.c_void_p),
        ("ReadClient", ctypes.c_void_p),
        ("ServerSupportFunction", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct EXTENSION_CONTROL_BLOCK {
    pub cbSize: u32,
    pub dwVersion: u32,
    pub ConnID: *mut core::ffi::c_void,
    pub dwHttpStatusCode: u32,
    pub lpszLogData: [i8; 80],
    pub lpszMethod: *mut core::ffi::c_void,
    pub lpszQueryString: *mut core::ffi::c_void,
    pub lpszPathInfo: *mut core::ffi::c_void,
    pub lpszPathTranslated: *mut core::ffi::c_void,
    pub cbTotalBytes: u32,
    pub cbAvailable: u32,
    pub lpbData: *mut core::ffi::c_void,
    pub lpszContentType: *mut core::ffi::c_void,
    pub GetServerVariable: *mut core::ffi::c_void,
    pub WriteClient: *mut core::ffi::c_void,
    pub ReadClient: *mut core::ffi::c_void,
    pub ServerSupportFunction: *mut core::ffi::c_void,
}

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

type EXTENSION_CONTROL_BLOCK struct {
	cbSize uint32
	dwVersion uint32
	ConnID uintptr
	dwHttpStatusCode uint32
	lpszLogData [80]int8
	lpszMethod uintptr
	lpszQueryString uintptr
	lpszPathInfo uintptr
	lpszPathTranslated uintptr
	cbTotalBytes uint32
	cbAvailable uint32
	lpbData uintptr
	lpszContentType uintptr
	GetServerVariable uintptr
	WriteClient uintptr
	ReadClient uintptr
	ServerSupportFunction uintptr
}

type
  EXTENSION_CONTROL_BLOCK = record
    cbSize: DWORD;
    dwVersion: DWORD;
    ConnID: Pointer;
    dwHttpStatusCode: DWORD;
    lpszLogData: array[0..79] of Shortint;
    lpszMethod: Pointer;
    lpszQueryString: Pointer;
    lpszPathInfo: Pointer;
    lpszPathTranslated: Pointer;
    cbTotalBytes: DWORD;
    cbAvailable: DWORD;
    lpbData: Pointer;
    lpszContentType: Pointer;
    GetServerVariable: Pointer;
    WriteClient: Pointer;
    ReadClient: Pointer;
    ServerSupportFunction: Pointer;
  end;

const EXTENSION_CONTROL_BLOCK = extern struct {
    cbSize: u32,
    dwVersion: u32,
    ConnID: ?*anyopaque,
    dwHttpStatusCode: u32,
    lpszLogData: [80]i8,
    lpszMethod: ?*anyopaque,
    lpszQueryString: ?*anyopaque,
    lpszPathInfo: ?*anyopaque,
    lpszPathTranslated: ?*anyopaque,
    cbTotalBytes: u32,
    cbAvailable: u32,
    lpbData: ?*anyopaque,
    lpszContentType: ?*anyopaque,
    GetServerVariable: ?*anyopaque,
    WriteClient: ?*anyopaque,
    ReadClient: ?*anyopaque,
    ServerSupportFunction: ?*anyopaque,
};

type
  EXTENSION_CONTROL_BLOCK {.bycopy.} = object
    cbSize: uint32
    dwVersion: uint32
    ConnID: pointer
    dwHttpStatusCode: uint32
    lpszLogData: array[80, int8]
    lpszMethod: pointer
    lpszQueryString: pointer
    lpszPathInfo: pointer
    lpszPathTranslated: pointer
    cbTotalBytes: uint32
    cbAvailable: uint32
    lpbData: pointer
    lpszContentType: pointer
    GetServerVariable: pointer
    WriteClient: pointer
    ReadClient: pointer
    ServerSupportFunction: pointer

struct EXTENSION_CONTROL_BLOCK
{
    uint cbSize;
    uint dwVersion;
    void* ConnID;
    uint dwHttpStatusCode;
    byte[80] lpszLogData;
    void* lpszMethod;
    void* lpszQueryString;
    void* lpszPathInfo;
    void* lpszPathTranslated;
    uint cbTotalBytes;
    uint cbAvailable;
    void* lpbData;
    void* lpszContentType;
    void* GetServerVariable;
    void* WriteClient;
    void* ReadClient;
    void* ServerSupportFunction;
}