HTTP_LOGGING_INFO

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_PROPERTY_FLAGS
{
    public uint _bitfield;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_LOGGING_INFO
{
    public HTTP_PROPERTY_FLAGS Flags;
    public uint LoggingFlags;
    public IntPtr SoftwareName;
    public ushort SoftwareNameLength;
    public ushort DirectoryNameLength;
    public IntPtr DirectoryName;
    public int Format;
    public uint Fields;
    public IntPtr pExtFields;
    public ushort NumOfExtFields;
    public ushort MaxRecordSize;
    public int RolloverType;
    public uint RolloverSize;
    public IntPtr pSecurityDescriptor;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_PROPERTY_FLAGS
    Public _bitfield As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_LOGGING_INFO
    Public Flags As HTTP_PROPERTY_FLAGS
    Public LoggingFlags As UInteger
    Public SoftwareName As IntPtr
    Public SoftwareNameLength As UShort
    Public DirectoryNameLength As UShort
    Public DirectoryName As IntPtr
    Public Format As Integer
    Public Fields As UInteger
    Public pExtFields As IntPtr
    Public NumOfExtFields As UShort
    Public MaxRecordSize As UShort
    Public RolloverType As Integer
    Public RolloverSize As UInteger
    Public pSecurityDescriptor As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class HTTP_PROPERTY_FLAGS(ctypes.Structure):
    _fields_ = [
        ("_bitfield", wintypes.DWORD),
    ]

class HTTP_LOGGING_INFO(ctypes.Structure):
    _fields_ = [
        ("Flags", HTTP_PROPERTY_FLAGS),
        ("LoggingFlags", wintypes.DWORD),
        ("SoftwareName", ctypes.c_void_p),
        ("SoftwareNameLength", ctypes.c_ushort),
        ("DirectoryNameLength", ctypes.c_ushort),
        ("DirectoryName", ctypes.c_void_p),
        ("Format", ctypes.c_int),
        ("Fields", wintypes.DWORD),
        ("pExtFields", ctypes.c_void_p),
        ("NumOfExtFields", ctypes.c_ushort),
        ("MaxRecordSize", ctypes.c_ushort),
        ("RolloverType", ctypes.c_int),
        ("RolloverSize", wintypes.DWORD),
        ("pSecurityDescriptor", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct HTTP_PROPERTY_FLAGS {
    pub _bitfield: u32,
}

#[repr(C)]
pub struct HTTP_LOGGING_INFO {
    pub Flags: HTTP_PROPERTY_FLAGS,
    pub LoggingFlags: u32,
    pub SoftwareName: *mut core::ffi::c_void,
    pub SoftwareNameLength: u16,
    pub DirectoryNameLength: u16,
    pub DirectoryName: *mut core::ffi::c_void,
    pub Format: i32,
    pub Fields: u32,
    pub pExtFields: *mut core::ffi::c_void,
    pub NumOfExtFields: u16,
    pub MaxRecordSize: u16,
    pub RolloverType: i32,
    pub RolloverSize: u32,
    pub pSecurityDescriptor: *mut core::ffi::c_void,
}

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

type HTTP_PROPERTY_FLAGS struct {
	_bitfield uint32
}

type HTTP_LOGGING_INFO struct {
	Flags HTTP_PROPERTY_FLAGS
	LoggingFlags uint32
	SoftwareName uintptr
	SoftwareNameLength uint16
	DirectoryNameLength uint16
	DirectoryName uintptr
	Format int32
	Fields uint32
	pExtFields uintptr
	NumOfExtFields uint16
	MaxRecordSize uint16
	RolloverType int32
	RolloverSize uint32
	pSecurityDescriptor uintptr
}

type
  HTTP_PROPERTY_FLAGS = record
    _bitfield: DWORD;
  end;

  HTTP_LOGGING_INFO = record
    Flags: HTTP_PROPERTY_FLAGS;
    LoggingFlags: DWORD;
    SoftwareName: Pointer;
    SoftwareNameLength: Word;
    DirectoryNameLength: Word;
    DirectoryName: Pointer;
    Format: Integer;
    Fields: DWORD;
    pExtFields: Pointer;
    NumOfExtFields: Word;
    MaxRecordSize: Word;
    RolloverType: Integer;
    RolloverSize: DWORD;
    pSecurityDescriptor: Pointer;
  end;

const HTTP_PROPERTY_FLAGS = extern struct {
    _bitfield: u32,
};

const HTTP_LOGGING_INFO = extern struct {
    Flags: HTTP_PROPERTY_FLAGS,
    LoggingFlags: u32,
    SoftwareName: ?*anyopaque,
    SoftwareNameLength: u16,
    DirectoryNameLength: u16,
    DirectoryName: ?*anyopaque,
    Format: i32,
    Fields: u32,
    pExtFields: ?*anyopaque,
    NumOfExtFields: u16,
    MaxRecordSize: u16,
    RolloverType: i32,
    RolloverSize: u32,
    pSecurityDescriptor: ?*anyopaque,
};

type
  HTTP_PROPERTY_FLAGS {.bycopy.} = object
    _bitfield: uint32

  HTTP_LOGGING_INFO {.bycopy.} = object
    Flags: HTTP_PROPERTY_FLAGS
    LoggingFlags: uint32
    SoftwareName: pointer
    SoftwareNameLength: uint16
    DirectoryNameLength: uint16
    DirectoryName: pointer
    Format: int32
    Fields: uint32
    pExtFields: pointer
    NumOfExtFields: uint16
    MaxRecordSize: uint16
    RolloverType: int32
    RolloverSize: uint32
    pSecurityDescriptor: pointer

struct HTTP_PROPERTY_FLAGS
{
    uint _bitfield;
}

struct HTTP_LOGGING_INFO
{
    HTTP_PROPERTY_FLAGS Flags;
    uint LoggingFlags;
    void* SoftwareName;
    ushort SoftwareNameLength;
    ushort DirectoryNameLength;
    void* DirectoryName;
    int Format;
    uint Fields;
    void* pExtFields;
    ushort NumOfExtFields;
    ushort MaxRecordSize;
    int RolloverType;
    uint RolloverSize;
    void* pSecurityDescriptor;
}