ホーム › Networking.HttpServer › HTTP_REQUEST_V1
HTTP_REQUEST_V1
構造体サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。
フィールド
| フィールド | 型 | サイズ | x64 | x86 | 説明 |
|---|---|---|---|---|---|
| Flags | DWORD | 4 | +0 | +0 | 要求に関するフラグである。HTTP_REQUEST_FLAG_*のビット集合を保持する。 |
| ConnectionId | ULONGLONG | 8 | +8 | +8 | 要求が属する接続を識別するID(64ビット)である。 |
| RequestId | ULONGLONG | 8 | +16 | +16 | 要求を一意に識別するID(64ビット)である。応答送信時に指定する。 |
| UrlContext | ULONGLONG | 8 | +24 | +24 | URLグループ登録時に関連付けたコンテキスト値(64ビット)である。 |
| Version | HTTP_VERSION | 4 | +32 | +32 | 要求のHTTPバージョンを示すHTTP_VERSIONである。 |
| Verb | HTTP_VERB | 4 | +36 | +36 | 要求のHTTPメソッドを示すHTTP_VERB列挙値である。 |
| UnknownVerbLength | WORD | 2 | +40 | +40 | pUnknownVerbのバイト長(WORD)である。 |
| RawUrlLength | WORD | 2 | +42 | +42 | pRawUrlのバイト長(WORD)である。 |
| pUnknownVerb | LPSTR | 8/4 | +48 | +44 | 既知でないメソッド名を示すANSI文字列ポインターである。 |
| pRawUrl | LPSTR | 8/4 | +56 | +48 | 正規化前の生の要求URLを示すANSI文字列ポインターである。 |
| CookedUrl | HTTP_COOKED_URL | 40/24 | +64 | +52 | 正規化済みURL情報を示すHTTP_COOKED_URLである。 |
| Address | HTTP_TRANSPORT_ADDRESS | 16/8 | +104 | +76 | 接続のローカル/リモートアドレスを示すHTTP_TRANSPORT_ADDRESSである。 |
| Headers | HTTP_REQUEST_HEADERS | 688/344 | +120 | +84 | 要求ヘッダー一式を示すHTTP_REQUEST_HEADERSである。 |
| BytesReceived | ULONGLONG | 8 | +808 | +432 | これまでに受信した要求のバイト数(64ビット)である。 |
| EntityChunkCount | WORD | 2 | +816 | +440 | pEntityChunks配列に含まれるエンティティチャンクの数(WORD)である。 |
| pEntityChunks | HTTP_DATA_CHUNK* | 8/4 | +824 | +444 | 要求本文のエンティティチャンクHTTP_DATA_CHUNK配列へのポインターである。 |
| RawConnectionId | ULONGLONG | 8 | +832 | +448 | SSL等の生の接続を識別するID(64ビット)である。 |
| pSslInfo | HTTP_SSL_INFO* | 8/4 | +840 | +456 | SSL接続情報HTTP_SSL_INFOへのポインターである。非SSL時はNULL。 |
各言語での定義
#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;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 Structureimport 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: pointerstruct 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;
}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_V1 サイズ: 464 バイト(x86)
dim st, 116 ; 4byte整数×116(構造体サイズ 464 / 4 切り上げ)
; Flags : DWORD (+0, 4byte) st.0 = 値 / 値 = st.0 (lpoke/lpeek も可)
; ConnectionId : ULONGLONG (+8, 8byte) qpoke st,8,値 / qpeek(st,8) ※IronHSPのみ。3.7/3.8は lpoke st,8,下位 : lpoke st,12,上位
; RequestId : ULONGLONG (+16, 8byte) qpoke st,16,値 / qpeek(st,16) ※IronHSPのみ。3.7/3.8は lpoke st,16,下位 : lpoke st,20,上位
; UrlContext : ULONGLONG (+24, 8byte) qpoke st,24,値 / qpeek(st,24) ※IronHSPのみ。3.7/3.8は lpoke st,24,下位 : lpoke st,28,上位
; Version : HTTP_VERSION (+32, 4byte) varptr(st)+32 を基点に操作(4byte:入れ子/配列)
; Verb : HTTP_VERB (+36, 4byte) st.9 = 値 / 値 = st.9 (lpoke/lpeek も可)
; UnknownVerbLength : WORD (+40, 2byte) wpoke st,40,値 / 値 = wpeek(st,40)
; RawUrlLength : WORD (+42, 2byte) wpoke st,42,値 / 値 = wpeek(st,42)
; pUnknownVerb : LPSTR (+44, 4byte) st.11 = 値 / 値 = st.11 (lpoke/lpeek も可)
; pRawUrl : LPSTR (+48, 4byte) st.12 = 値 / 値 = st.12 (lpoke/lpeek も可)
; CookedUrl : HTTP_COOKED_URL (+52, 24byte) varptr(st)+52 を基点に操作(24byte:入れ子/配列)
; Address : HTTP_TRANSPORT_ADDRESS (+76, 8byte) varptr(st)+76 を基点に操作(8byte:入れ子/配列)
; Headers : HTTP_REQUEST_HEADERS (+84, 344byte) varptr(st)+84 を基点に操作(344byte:入れ子/配列)
; BytesReceived : ULONGLONG (+432, 8byte) qpoke st,432,値 / qpeek(st,432) ※IronHSPのみ。3.7/3.8は lpoke st,432,下位 : lpoke st,436,上位
; EntityChunkCount : WORD (+440, 2byte) wpoke st,440,値 / 値 = wpeek(st,440)
; pEntityChunks : HTTP_DATA_CHUNK* (+444, 4byte) varptr(st)+444 を基点に操作(4byte:入れ子/配列)
; RawConnectionId : ULONGLONG (+448, 8byte) qpoke st,448,値 / qpeek(st,448) ※IronHSPのみ。3.7/3.8は lpoke st,448,下位 : lpoke st,452,上位
; pSslInfo : HTTP_SSL_INFO* (+456, 4byte) varptr(st)+456 を基点に操作(4byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; HTTP_REQUEST_V1 サイズ: 848 バイト(x64)
dim st, 212 ; 4byte整数×212(構造体サイズ 848 / 4 切り上げ)
; Flags : DWORD (+0, 4byte) st.0 = 値 / 値 = st.0 (lpoke/lpeek も可)
; ConnectionId : ULONGLONG (+8, 8byte) qpoke st,8,値 / qpeek(st,8) ※IronHSPのみ。3.7/3.8は lpoke st,8,下位 : lpoke st,12,上位
; RequestId : ULONGLONG (+16, 8byte) qpoke st,16,値 / qpeek(st,16) ※IronHSPのみ。3.7/3.8は lpoke st,16,下位 : lpoke st,20,上位
; UrlContext : ULONGLONG (+24, 8byte) qpoke st,24,値 / qpeek(st,24) ※IronHSPのみ。3.7/3.8は lpoke st,24,下位 : lpoke st,28,上位
; Version : HTTP_VERSION (+32, 4byte) varptr(st)+32 を基点に操作(4byte:入れ子/配列)
; Verb : HTTP_VERB (+36, 4byte) st.9 = 値 / 値 = st.9 (lpoke/lpeek も可)
; UnknownVerbLength : WORD (+40, 2byte) wpoke st,40,値 / 値 = wpeek(st,40)
; RawUrlLength : WORD (+42, 2byte) wpoke st,42,値 / 値 = wpeek(st,42)
; pUnknownVerb : LPSTR (+48, 8byte) qpoke st,48,値 / qpeek(st,48) ※IronHSPのみ。3.7/3.8は lpoke st,48,下位 : lpoke st,52,上位
; pRawUrl : LPSTR (+56, 8byte) qpoke st,56,値 / qpeek(st,56) ※IronHSPのみ。3.7/3.8は lpoke st,56,下位 : lpoke st,60,上位
; CookedUrl : HTTP_COOKED_URL (+64, 40byte) varptr(st)+64 を基点に操作(40byte:入れ子/配列)
; Address : HTTP_TRANSPORT_ADDRESS (+104, 16byte) varptr(st)+104 を基点に操作(16byte:入れ子/配列)
; Headers : HTTP_REQUEST_HEADERS (+120, 688byte) varptr(st)+120 を基点に操作(688byte:入れ子/配列)
; BytesReceived : ULONGLONG (+808, 8byte) qpoke st,808,値 / qpeek(st,808) ※IronHSPのみ。3.7/3.8は lpoke st,808,下位 : lpoke st,812,上位
; EntityChunkCount : WORD (+816, 2byte) wpoke st,816,値 / 値 = wpeek(st,816)
; pEntityChunks : HTTP_DATA_CHUNK* (+824, 8byte) varptr(st)+824 を基点に操作(8byte:入れ子/配列)
; RawConnectionId : ULONGLONG (+832, 8byte) qpoke st,832,値 / qpeek(st,832) ※IronHSPのみ。3.7/3.8は lpoke st,832,下位 : lpoke st,836,上位
; pSslInfo : HTTP_SSL_INFO* (+840, 8byte) varptr(st)+840 を基点に操作(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
stdim st, HTTP_REQUEST_V1 ; NSTRUCT 変数を確保
st->Flags = 100
mes "Flags=" + st->Flags