HTTP_REQUEST_V1

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_VERSION
{
    public ushort MajorVersion;
    public ushort MinorVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_COOKED_URL
{
    public ushort FullUrlLength;
    public ushort HostLength;
    public ushort AbsPathLength;
    public ushort QueryStringLength;
    public IntPtr pFullUrl;
    public IntPtr pHost;
    public IntPtr pAbsPath;
    public IntPtr pQueryString;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_TRANSPORT_ADDRESS
{
    public IntPtr pRemoteAddress;
    public IntPtr pLocalAddress;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_KNOWN_HEADER
{
    public ushort RawValueLength;
    public IntPtr pRawValue;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_REQUEST_HEADERS
{
    public ushort UnknownHeaderCount;
    public IntPtr pUnknownHeaders;
    public ushort TrailerCount;
    public IntPtr pTrailers;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 41)] public HTTP_KNOWN_HEADER[] KnownHeaders;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_REQUEST_V1
{
    public uint Flags;
    public ulong ConnectionId;
    public ulong RequestId;
    public ulong UrlContext;
    public HTTP_VERSION Version;
    public int Verb;
    public ushort UnknownVerbLength;
    public ushort RawUrlLength;
    public IntPtr pUnknownVerb;
    public IntPtr pRawUrl;
    public HTTP_COOKED_URL CookedUrl;
    public HTTP_TRANSPORT_ADDRESS Address;
    public HTTP_REQUEST_HEADERS Headers;
    public ulong BytesReceived;
    public ushort EntityChunkCount;
    public IntPtr pEntityChunks;
    public ulong RawConnectionId;
    public IntPtr pSslInfo;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_VERSION
    Public MajorVersion As UShort
    Public MinorVersion As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_COOKED_URL
    Public FullUrlLength As UShort
    Public HostLength As UShort
    Public AbsPathLength As UShort
    Public QueryStringLength As UShort
    Public pFullUrl As IntPtr
    Public pHost As IntPtr
    Public pAbsPath As IntPtr
    Public pQueryString As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_TRANSPORT_ADDRESS
    Public pRemoteAddress As IntPtr
    Public pLocalAddress As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_KNOWN_HEADER
    Public RawValueLength As UShort
    Public pRawValue As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_REQUEST_HEADERS
    Public UnknownHeaderCount As UShort
    Public pUnknownHeaders As IntPtr
    Public TrailerCount As UShort
    Public pTrailers As IntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=41)> Public KnownHeaders() As HTTP_KNOWN_HEADER
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_REQUEST_V1
    Public Flags As UInteger
    Public ConnectionId As ULong
    Public RequestId As ULong
    Public UrlContext As ULong
    Public Version As HTTP_VERSION
    Public Verb As Integer
    Public UnknownVerbLength As UShort
    Public RawUrlLength As UShort
    Public pUnknownVerb As IntPtr
    Public pRawUrl As IntPtr
    Public CookedUrl As HTTP_COOKED_URL
    Public Address As HTTP_TRANSPORT_ADDRESS
    Public Headers As HTTP_REQUEST_HEADERS
    Public BytesReceived As ULong
    Public EntityChunkCount As UShort
    Public pEntityChunks As IntPtr
    Public RawConnectionId As ULong
    Public pSslInfo As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class HTTP_VERSION(ctypes.Structure):
    _fields_ = [
        ("MajorVersion", ctypes.c_ushort),
        ("MinorVersion", ctypes.c_ushort),
    ]

class HTTP_COOKED_URL(ctypes.Structure):
    _fields_ = [
        ("FullUrlLength", ctypes.c_ushort),
        ("HostLength", ctypes.c_ushort),
        ("AbsPathLength", ctypes.c_ushort),
        ("QueryStringLength", ctypes.c_ushort),
        ("pFullUrl", ctypes.c_void_p),
        ("pHost", ctypes.c_void_p),
        ("pAbsPath", ctypes.c_void_p),
        ("pQueryString", ctypes.c_void_p),
    ]

class HTTP_TRANSPORT_ADDRESS(ctypes.Structure):
    _fields_ = [
        ("pRemoteAddress", ctypes.c_void_p),
        ("pLocalAddress", ctypes.c_void_p),
    ]

class HTTP_KNOWN_HEADER(ctypes.Structure):
    _fields_ = [
        ("RawValueLength", ctypes.c_ushort),
        ("pRawValue", ctypes.c_void_p),
    ]

class HTTP_REQUEST_HEADERS(ctypes.Structure):
    _fields_ = [
        ("UnknownHeaderCount", ctypes.c_ushort),
        ("pUnknownHeaders", ctypes.c_void_p),
        ("TrailerCount", ctypes.c_ushort),
        ("pTrailers", ctypes.c_void_p),
        ("KnownHeaders", HTTP_KNOWN_HEADER * 41),
    ]

class HTTP_REQUEST_V1(ctypes.Structure):
    _fields_ = [
        ("Flags", wintypes.DWORD),
        ("ConnectionId", ctypes.c_ulonglong),
        ("RequestId", ctypes.c_ulonglong),
        ("UrlContext", ctypes.c_ulonglong),
        ("Version", HTTP_VERSION),
        ("Verb", ctypes.c_int),
        ("UnknownVerbLength", ctypes.c_ushort),
        ("RawUrlLength", ctypes.c_ushort),
        ("pUnknownVerb", ctypes.c_void_p),
        ("pRawUrl", ctypes.c_void_p),
        ("CookedUrl", HTTP_COOKED_URL),
        ("Address", HTTP_TRANSPORT_ADDRESS),
        ("Headers", HTTP_REQUEST_HEADERS),
        ("BytesReceived", ctypes.c_ulonglong),
        ("EntityChunkCount", ctypes.c_ushort),
        ("pEntityChunks", ctypes.c_void_p),
        ("RawConnectionId", ctypes.c_ulonglong),
        ("pSslInfo", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct HTTP_VERSION {
    pub MajorVersion: u16,
    pub MinorVersion: u16,
}

#[repr(C)]
pub struct HTTP_COOKED_URL {
    pub FullUrlLength: u16,
    pub HostLength: u16,
    pub AbsPathLength: u16,
    pub QueryStringLength: u16,
    pub pFullUrl: *mut core::ffi::c_void,
    pub pHost: *mut core::ffi::c_void,
    pub pAbsPath: *mut core::ffi::c_void,
    pub pQueryString: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct HTTP_TRANSPORT_ADDRESS {
    pub pRemoteAddress: *mut core::ffi::c_void,
    pub pLocalAddress: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct HTTP_KNOWN_HEADER {
    pub RawValueLength: u16,
    pub pRawValue: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct HTTP_REQUEST_HEADERS {
    pub UnknownHeaderCount: u16,
    pub pUnknownHeaders: *mut core::ffi::c_void,
    pub TrailerCount: u16,
    pub pTrailers: *mut core::ffi::c_void,
    pub KnownHeaders: [HTTP_KNOWN_HEADER; 41],
}

#[repr(C)]
pub struct HTTP_REQUEST_V1 {
    pub Flags: u32,
    pub ConnectionId: u64,
    pub RequestId: u64,
    pub UrlContext: u64,
    pub Version: HTTP_VERSION,
    pub Verb: i32,
    pub UnknownVerbLength: u16,
    pub RawUrlLength: u16,
    pub pUnknownVerb: *mut core::ffi::c_void,
    pub pRawUrl: *mut core::ffi::c_void,
    pub CookedUrl: HTTP_COOKED_URL,
    pub Address: HTTP_TRANSPORT_ADDRESS,
    pub Headers: HTTP_REQUEST_HEADERS,
    pub BytesReceived: u64,
    pub EntityChunkCount: u16,
    pub pEntityChunks: *mut core::ffi::c_void,
    pub RawConnectionId: u64,
    pub pSslInfo: *mut core::ffi::c_void,
}

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

type HTTP_VERSION struct {
	MajorVersion uint16
	MinorVersion uint16
}

type HTTP_COOKED_URL struct {
	FullUrlLength uint16
	HostLength uint16
	AbsPathLength uint16
	QueryStringLength uint16
	pFullUrl uintptr
	pHost uintptr
	pAbsPath uintptr
	pQueryString uintptr
}

type HTTP_TRANSPORT_ADDRESS struct {
	pRemoteAddress uintptr
	pLocalAddress uintptr
}

type HTTP_KNOWN_HEADER struct {
	RawValueLength uint16
	pRawValue uintptr
}

type HTTP_REQUEST_HEADERS struct {
	UnknownHeaderCount uint16
	pUnknownHeaders uintptr
	TrailerCount uint16
	pTrailers uintptr
	KnownHeaders [41]HTTP_KNOWN_HEADER
}

type HTTP_REQUEST_V1 struct {
	Flags uint32
	ConnectionId uint64
	RequestId uint64
	UrlContext uint64
	Version HTTP_VERSION
	Verb int32
	UnknownVerbLength uint16
	RawUrlLength uint16
	pUnknownVerb uintptr
	pRawUrl uintptr
	CookedUrl HTTP_COOKED_URL
	Address HTTP_TRANSPORT_ADDRESS
	Headers HTTP_REQUEST_HEADERS
	BytesReceived uint64
	EntityChunkCount uint16
	pEntityChunks uintptr
	RawConnectionId uint64
	pSslInfo uintptr
}

type
  HTTP_VERSION = record
    MajorVersion: Word;
    MinorVersion: Word;
  end;

  HTTP_COOKED_URL = record
    FullUrlLength: Word;
    HostLength: Word;
    AbsPathLength: Word;
    QueryStringLength: Word;
    pFullUrl: Pointer;
    pHost: Pointer;
    pAbsPath: Pointer;
    pQueryString: Pointer;
  end;

  HTTP_TRANSPORT_ADDRESS = record
    pRemoteAddress: Pointer;
    pLocalAddress: Pointer;
  end;

  HTTP_KNOWN_HEADER = record
    RawValueLength: Word;
    pRawValue: Pointer;
  end;

  HTTP_REQUEST_HEADERS = record
    UnknownHeaderCount: Word;
    pUnknownHeaders: Pointer;
    TrailerCount: Word;
    pTrailers: Pointer;
    KnownHeaders: array[0..40] of HTTP_KNOWN_HEADER;
  end;

  HTTP_REQUEST_V1 = record
    Flags: DWORD;
    ConnectionId: UInt64;
    RequestId: UInt64;
    UrlContext: UInt64;
    Version: HTTP_VERSION;
    Verb: Integer;
    UnknownVerbLength: Word;
    RawUrlLength: Word;
    pUnknownVerb: Pointer;
    pRawUrl: Pointer;
    CookedUrl: HTTP_COOKED_URL;
    Address: HTTP_TRANSPORT_ADDRESS;
    Headers: HTTP_REQUEST_HEADERS;
    BytesReceived: UInt64;
    EntityChunkCount: Word;
    pEntityChunks: Pointer;
    RawConnectionId: UInt64;
    pSslInfo: Pointer;
  end;

const HTTP_VERSION = extern struct {
    MajorVersion: u16,
    MinorVersion: u16,
};

const HTTP_COOKED_URL = extern struct {
    FullUrlLength: u16,
    HostLength: u16,
    AbsPathLength: u16,
    QueryStringLength: u16,
    pFullUrl: ?*anyopaque,
    pHost: ?*anyopaque,
    pAbsPath: ?*anyopaque,
    pQueryString: ?*anyopaque,
};

const HTTP_TRANSPORT_ADDRESS = extern struct {
    pRemoteAddress: ?*anyopaque,
    pLocalAddress: ?*anyopaque,
};

const HTTP_KNOWN_HEADER = extern struct {
    RawValueLength: u16,
    pRawValue: ?*anyopaque,
};

const HTTP_REQUEST_HEADERS = extern struct {
    UnknownHeaderCount: u16,
    pUnknownHeaders: ?*anyopaque,
    TrailerCount: u16,
    pTrailers: ?*anyopaque,
    KnownHeaders: [41]HTTP_KNOWN_HEADER,
};

const HTTP_REQUEST_V1 = extern struct {
    Flags: u32,
    ConnectionId: u64,
    RequestId: u64,
    UrlContext: u64,
    Version: HTTP_VERSION,
    Verb: i32,
    UnknownVerbLength: u16,
    RawUrlLength: u16,
    pUnknownVerb: ?*anyopaque,
    pRawUrl: ?*anyopaque,
    CookedUrl: HTTP_COOKED_URL,
    Address: HTTP_TRANSPORT_ADDRESS,
    Headers: HTTP_REQUEST_HEADERS,
    BytesReceived: u64,
    EntityChunkCount: u16,
    pEntityChunks: ?*anyopaque,
    RawConnectionId: u64,
    pSslInfo: ?*anyopaque,
};

type
  HTTP_VERSION {.bycopy.} = object
    MajorVersion: uint16
    MinorVersion: uint16

  HTTP_COOKED_URL {.bycopy.} = object
    FullUrlLength: uint16
    HostLength: uint16
    AbsPathLength: uint16
    QueryStringLength: uint16
    pFullUrl: pointer
    pHost: pointer
    pAbsPath: pointer
    pQueryString: pointer

  HTTP_TRANSPORT_ADDRESS {.bycopy.} = object
    pRemoteAddress: pointer
    pLocalAddress: pointer

  HTTP_KNOWN_HEADER {.bycopy.} = object
    RawValueLength: uint16
    pRawValue: pointer

  HTTP_REQUEST_HEADERS {.bycopy.} = object
    UnknownHeaderCount: uint16
    pUnknownHeaders: pointer
    TrailerCount: uint16
    pTrailers: pointer
    KnownHeaders: array[41, HTTP_KNOWN_HEADER]

  HTTP_REQUEST_V1 {.bycopy.} = object
    Flags: uint32
    ConnectionId: uint64
    RequestId: uint64
    UrlContext: uint64
    Version: HTTP_VERSION
    Verb: int32
    UnknownVerbLength: uint16
    RawUrlLength: uint16
    pUnknownVerb: pointer
    pRawUrl: pointer
    CookedUrl: HTTP_COOKED_URL
    Address: HTTP_TRANSPORT_ADDRESS
    Headers: HTTP_REQUEST_HEADERS
    BytesReceived: uint64
    EntityChunkCount: uint16
    pEntityChunks: pointer
    RawConnectionId: uint64
    pSslInfo: pointer

struct HTTP_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct HTTP_COOKED_URL
{
    ushort FullUrlLength;
    ushort HostLength;
    ushort AbsPathLength;
    ushort QueryStringLength;
    void* pFullUrl;
    void* pHost;
    void* pAbsPath;
    void* pQueryString;
}

struct HTTP_TRANSPORT_ADDRESS
{
    void* pRemoteAddress;
    void* pLocalAddress;
}

struct HTTP_KNOWN_HEADER
{
    ushort RawValueLength;
    void* pRawValue;
}

struct HTTP_REQUEST_HEADERS
{
    ushort UnknownHeaderCount;
    void* pUnknownHeaders;
    ushort TrailerCount;
    void* pTrailers;
    HTTP_KNOWN_HEADER[41] KnownHeaders;
}

struct HTTP_REQUEST_V1
{
    uint Flags;
    ulong ConnectionId;
    ulong RequestId;
    ulong UrlContext;
    HTTP_VERSION Version;
    int Verb;
    ushort UnknownVerbLength;
    ushort RawUrlLength;
    void* pUnknownVerb;
    void* pRawUrl;
    HTTP_COOKED_URL CookedUrl;
    HTTP_TRANSPORT_ADDRESS Address;
    HTTP_REQUEST_HEADERS Headers;
    ulong BytesReceived;
    ushort EntityChunkCount;
    void* pEntityChunks;
    ulong RawConnectionId;
    void* pSslInfo;
}