ホーム › Networking.HttpServer › HTTP_REQUEST_V2

HTTP_REQUEST_V2

構造体

サイズx64: 864 バイト / x86: 472 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド	型	サイズ	x64	x86	説明
Base	HTTP_REQUEST_V1	848/464	+0	+0	V1の要求情報を保持する基底のHTTP_REQUEST_V1である。
RequestInfoCount	WORD	2	+848	+464	pRequestInfo配列に含まれる追加要求情報の数(WORD)である。
pRequestInfo	HTTP_REQUEST_INFO*	8/4	+856	+468	追加の要求情報HTTP_REQUEST_INFO配列へのポインターである。

各言語での定義

#include <windows.h>

// HTTP_VERSION  (x64 4 / x86 4 バイト)
typedef struct HTTP_VERSION {
    WORD MajorVersion;
    WORD MinorVersion;
} HTTP_VERSION;

// HTTP_COOKED_URL  (x64 40 / x86 24 バイト)
typedef struct HTTP_COOKED_URL {
    WORD FullUrlLength;
    WORD HostLength;
    WORD AbsPathLength;
    WORD QueryStringLength;
    LPWSTR pFullUrl;
    LPWSTR pHost;
    LPWSTR pAbsPath;
    LPWSTR pQueryString;
} HTTP_COOKED_URL;

// HTTP_TRANSPORT_ADDRESS  (x64 16 / x86 8 バイト)
typedef struct HTTP_TRANSPORT_ADDRESS {
    SOCKADDR* pRemoteAddress;
    SOCKADDR* pLocalAddress;
} HTTP_TRANSPORT_ADDRESS;

// HTTP_KNOWN_HEADER  (x64 16 / x86 8 バイト)
typedef struct HTTP_KNOWN_HEADER {
    WORD RawValueLength;
    LPSTR pRawValue;
} HTTP_KNOWN_HEADER;

// HTTP_REQUEST_HEADERS  (x64 688 / x86 344 バイト)
typedef struct HTTP_REQUEST_HEADERS {
    WORD UnknownHeaderCount;
    HTTP_UNKNOWN_HEADER* pUnknownHeaders;
    WORD TrailerCount;
    HTTP_UNKNOWN_HEADER* pTrailers;
    HTTP_KNOWN_HEADER KnownHeaders[41];
} HTTP_REQUEST_HEADERS;

// HTTP_REQUEST_V1  (x64 848 / x86 464 バイト)
typedef struct HTTP_REQUEST_V1 {
    DWORD Flags;
    ULONGLONG ConnectionId;
    ULONGLONG RequestId;
    ULONGLONG UrlContext;
    HTTP_VERSION Version;
    HTTP_VERB Verb;
    WORD UnknownVerbLength;
    WORD RawUrlLength;
    LPSTR pUnknownVerb;
    LPSTR pRawUrl;
    HTTP_COOKED_URL CookedUrl;
    HTTP_TRANSPORT_ADDRESS Address;
    HTTP_REQUEST_HEADERS Headers;
    ULONGLONG BytesReceived;
    WORD EntityChunkCount;
    HTTP_DATA_CHUNK* pEntityChunks;
    ULONGLONG RawConnectionId;
    HTTP_SSL_INFO* pSslInfo;
} HTTP_REQUEST_V1;

// HTTP_REQUEST_V2  (x64 864 / x86 472 バイト)
typedef struct HTTP_REQUEST_V2 {
    HTTP_REQUEST_V1 Base;
    WORD RequestInfoCount;
    HTTP_REQUEST_INFO* pRequestInfo;
} HTTP_REQUEST_V2;

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;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HTTP_REQUEST_V2
{
    public HTTP_REQUEST_V1 Base;
    public ushort RequestInfoCount;
    public IntPtr pRequestInfo;
}

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

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HTTP_REQUEST_V2
    Public Base As HTTP_REQUEST_V1
    Public RequestInfoCount As UShort
    Public pRequestInfo 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),
    ]

class HTTP_REQUEST_V2(ctypes.Structure):
    _fields_ = [
        ("Base", HTTP_REQUEST_V1),
        ("RequestInfoCount", ctypes.c_ushort),
        ("pRequestInfo", 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,
}

#[repr(C)]
pub struct HTTP_REQUEST_V2 {
    pub Base: HTTP_REQUEST_V1,
    pub RequestInfoCount: u16,
    pub pRequestInfo: *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_REQUEST_V2 struct {
	Base HTTP_REQUEST_V1
	RequestInfoCount uint16
	pRequestInfo 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;

  HTTP_REQUEST_V2 = record
    Base: HTTP_REQUEST_V1;
    RequestInfoCount: Word;
    pRequestInfo: 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,
};

const HTTP_REQUEST_V2 = extern struct {
    Base: HTTP_REQUEST_V1,
    RequestInfoCount: u16,
    pRequestInfo: ?*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

  HTTP_REQUEST_V2 {.bycopy.} = object
    Base: HTTP_REQUEST_V1
    RequestInfoCount: uint16
    pRequestInfo: 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;
}

struct HTTP_REQUEST_V2
{
    HTTP_REQUEST_V1 Base;
    ushort RequestInfoCount;
    void* pRequestInfo;
}

HSP用定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; HTTP_REQUEST_V2 サイズ: 472 バイト(x86)
dim st, 118    ; 4byte整数×118(構造体サイズ 472 / 4 切り上げ)
; Base : HTTP_REQUEST_V1 (+0, 464byte)  varptr(st)+0 を基点に操作(464byte:入れ子/配列)
; RequestInfoCount : WORD (+464, 2byte)  wpoke st,464,値  /  値 = wpeek(st,464)
; pRequestInfo : HTTP_REQUEST_INFO* (+468, 4byte)  varptr(st)+468 を基点に操作(4byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; HTTP_REQUEST_V2 サイズ: 864 バイト(x64)
dim st, 216    ; 4byte整数×216(構造体サイズ 864 / 4 切り上げ)
; Base : HTTP_REQUEST_V1 (+0, 848byte)  varptr(st)+0 を基点に操作(848byte:入れ子/配列)
; RequestInfoCount : WORD (+848, 2byte)  wpoke st,848,値  /  値 = wpeek(st,848)
; pRequestInfo : HTTP_REQUEST_INFO* (+856, 8byte)  varptr(st)+856 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global HTTP_VERSION
    #field short MajorVersion
    #field short MinorVersion
#endstruct

#defstruct global HTTP_COOKED_URL
    #field short FullUrlLength
    #field short HostLength
    #field short AbsPathLength
    #field short QueryStringLength
    #field intptr pFullUrl
    #field intptr pHost
    #field intptr pAbsPath
    #field intptr pQueryString
#endstruct

#defstruct global HTTP_TRANSPORT_ADDRESS
    #field intptr pRemoteAddress
    #field intptr pLocalAddress
#endstruct

#defstruct global HTTP_KNOWN_HEADER
    #field short RawValueLength
    #field intptr pRawValue
#endstruct

#defstruct global HTTP_REQUEST_HEADERS
    #field short UnknownHeaderCount
    #field intptr pUnknownHeaders
    #field short TrailerCount
    #field intptr pTrailers
    #field HTTP_KNOWN_HEADER KnownHeaders 41
#endstruct

#defstruct global HTTP_REQUEST_V1
    #field int Flags
    #field int64 ConnectionId
    #field int64 RequestId
    #field int64 UrlContext
    #field HTTP_VERSION Version
    #field int Verb
    #field short UnknownVerbLength
    #field short RawUrlLength
    #field intptr pUnknownVerb
    #field intptr pRawUrl
    #field HTTP_COOKED_URL CookedUrl
    #field HTTP_TRANSPORT_ADDRESS Address
    #field HTTP_REQUEST_HEADERS Headers
    #field int64 BytesReceived
    #field short EntityChunkCount
    #field intptr pEntityChunks
    #field int64 RawConnectionId
    #field intptr pSslInfo
#endstruct

#defstruct global HTTP_REQUEST_V2
    #field HTTP_REQUEST_V1 Base
    #field short RequestInfoCount
    #field intptr pRequestInfo
#endstruct

stdim st, HTTP_REQUEST_V2        ; NSTRUCT 変数を確保
st->RequestInfoCount = 100
mes "RequestInfoCount=" + st->RequestInfoCount

HTTP_REQUEST_V2

フィールド

各言語での定義

HSP用 定義

HSP用定義