Win32 API 日本語リファレンス
ホーム › System.SystemServices › DRIVER_RUNTIME_REPORT

DRIVER_RUNTIME_REPORT

構造体
サイズx64: 96 バイト / x86: 76 バイト

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

フィールド

フィールド型サイズx64x86説明
HeaderRUNTIME_REPORT_HEADER8+0+0ランタイムレポート共通ヘッダー。
NumberOfDriversWORD2+8+8レポートに含まれるドライバエントリ数。
Flags_Flags_e__Union8/4+16+12レポート全体のフラグを保持する無名共用体。
DriverEntriesDRIVER_INFO_ENTRY72/60+24+16各ドライバの情報を持つDRIVER_INFO_ENTRY配列の先頭(可変長)。

共用体: _Flags_e__Union x64 8B / x86 4B

フィールド型サイズx64x86
Anonymous_Anonymous_e__Struct8/4+0+0
AsUInt16WORD2+0+0

各言語での定義

#include <windows.h>

// RUNTIME_REPORT_HEADER  (x64 8 / x86 8 バイト)
typedef struct RUNTIME_REPORT_HEADER {
    WORD ReportType;
    WORD Reserved;
    DWORD ReportSize;
} RUNTIME_REPORT_HEADER;

// DRIVER_INFO_ENTRY  (x64 72 / x86 60 バイト)
typedef struct DRIVER_INFO_ENTRY {
    CHAR InternalName[32];
    WORD ImageHashAlgorithm;
    WORD PublisherThumbprintHashAlgorithm;
    DWORD ImageHashOffset;
    DWORD PublisherThumbprintOffset;
    WORD LoadCount;
    WORD OemNameSize;
    DWORD OemNameOffset;
    _Flags_e__Union Flags;
    WORD Padding;
} DRIVER_INFO_ENTRY;

// DRIVER_RUNTIME_REPORT  (x64 96 / x86 76 バイト)
typedef struct DRIVER_RUNTIME_REPORT {
    RUNTIME_REPORT_HEADER Header;
    WORD NumberOfDrivers;
    _Flags_e__Union Flags;
    DRIVER_INFO_ENTRY DriverEntries[1];
} DRIVER_RUNTIME_REPORT;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RUNTIME_REPORT_HEADER
{
    public ushort ReportType;
    public ushort Reserved;
    public uint ReportSize;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DRIVER_INFO_ENTRY
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public sbyte[] InternalName;
    public ushort ImageHashAlgorithm;
    public ushort PublisherThumbprintHashAlgorithm;
    public uint ImageHashOffset;
    public uint PublisherThumbprintOffset;
    public ushort LoadCount;
    public ushort OemNameSize;
    public uint OemNameOffset;
    public _Flags_e__Union Flags;
    public ushort Padding;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DRIVER_RUNTIME_REPORT
{
    public RUNTIME_REPORT_HEADER Header;
    public ushort NumberOfDrivers;
    public _Flags_e__Union Flags;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public DRIVER_INFO_ENTRY[] DriverEntries;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RUNTIME_REPORT_HEADER
    Public ReportType As UShort
    Public Reserved As UShort
    Public ReportSize As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DRIVER_INFO_ENTRY
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public InternalName() As SByte
    Public ImageHashAlgorithm As UShort
    Public PublisherThumbprintHashAlgorithm As UShort
    Public ImageHashOffset As UInteger
    Public PublisherThumbprintOffset As UInteger
    Public LoadCount As UShort
    Public OemNameSize As UShort
    Public OemNameOffset As UInteger
    Public Flags As _Flags_e__Union
    Public Padding As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DRIVER_RUNTIME_REPORT
    Public Header As RUNTIME_REPORT_HEADER
    Public NumberOfDrivers As UShort
    Public Flags As _Flags_e__Union
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public DriverEntries() As DRIVER_INFO_ENTRY
End Structure
import ctypes
from ctypes import wintypes

class RUNTIME_REPORT_HEADER(ctypes.Structure):
    _fields_ = [
        ("ReportType", ctypes.c_ushort),
        ("Reserved", ctypes.c_ushort),
        ("ReportSize", wintypes.DWORD),
    ]

class DRIVER_INFO_ENTRY(ctypes.Structure):
    _fields_ = [
        ("InternalName", ctypes.c_byte * 32),
        ("ImageHashAlgorithm", ctypes.c_ushort),
        ("PublisherThumbprintHashAlgorithm", ctypes.c_ushort),
        ("ImageHashOffset", wintypes.DWORD),
        ("PublisherThumbprintOffset", wintypes.DWORD),
        ("LoadCount", ctypes.c_ushort),
        ("OemNameSize", ctypes.c_ushort),
        ("OemNameOffset", wintypes.DWORD),
        ("Flags", _Flags_e__Union),
        ("Padding", ctypes.c_ushort),
    ]

class DRIVER_RUNTIME_REPORT(ctypes.Structure):
    _fields_ = [
        ("Header", RUNTIME_REPORT_HEADER),
        ("NumberOfDrivers", ctypes.c_ushort),
        ("Flags", _Flags_e__Union),
        ("DriverEntries", DRIVER_INFO_ENTRY * 1),
    ]
#[repr(C)]
pub struct RUNTIME_REPORT_HEADER {
    pub ReportType: u16,
    pub Reserved: u16,
    pub ReportSize: u32,
}

#[repr(C)]
pub struct DRIVER_INFO_ENTRY {
    pub InternalName: [i8; 32],
    pub ImageHashAlgorithm: u16,
    pub PublisherThumbprintHashAlgorithm: u16,
    pub ImageHashOffset: u32,
    pub PublisherThumbprintOffset: u32,
    pub LoadCount: u16,
    pub OemNameSize: u16,
    pub OemNameOffset: u32,
    pub Flags: _Flags_e__Union,
    pub Padding: u16,
}

#[repr(C)]
pub struct DRIVER_RUNTIME_REPORT {
    pub Header: RUNTIME_REPORT_HEADER,
    pub NumberOfDrivers: u16,
    pub Flags: _Flags_e__Union,
    pub DriverEntries: [DRIVER_INFO_ENTRY; 1],
}
import "golang.org/x/sys/windows"

type RUNTIME_REPORT_HEADER struct {
	ReportType uint16
	Reserved uint16
	ReportSize uint32
}

type DRIVER_INFO_ENTRY struct {
	InternalName [32]int8
	ImageHashAlgorithm uint16
	PublisherThumbprintHashAlgorithm uint16
	ImageHashOffset uint32
	PublisherThumbprintOffset uint32
	LoadCount uint16
	OemNameSize uint16
	OemNameOffset uint32
	Flags _Flags_e__Union
	Padding uint16
}

type DRIVER_RUNTIME_REPORT struct {
	Header RUNTIME_REPORT_HEADER
	NumberOfDrivers uint16
	Flags _Flags_e__Union
	DriverEntries [1]DRIVER_INFO_ENTRY
}
type
  RUNTIME_REPORT_HEADER = record
    ReportType: Word;
    Reserved: Word;
    ReportSize: DWORD;
  end;

  DRIVER_INFO_ENTRY = record
    InternalName: array[0..31] of Shortint;
    ImageHashAlgorithm: Word;
    PublisherThumbprintHashAlgorithm: Word;
    ImageHashOffset: DWORD;
    PublisherThumbprintOffset: DWORD;
    LoadCount: Word;
    OemNameSize: Word;
    OemNameOffset: DWORD;
    Flags: _Flags_e__Union;
    Padding: Word;
  end;

  DRIVER_RUNTIME_REPORT = record
    Header: RUNTIME_REPORT_HEADER;
    NumberOfDrivers: Word;
    Flags: _Flags_e__Union;
    DriverEntries: array[0..0] of DRIVER_INFO_ENTRY;
  end;
const RUNTIME_REPORT_HEADER = extern struct {
    ReportType: u16,
    Reserved: u16,
    ReportSize: u32,
};

const DRIVER_INFO_ENTRY = extern struct {
    InternalName: [32]i8,
    ImageHashAlgorithm: u16,
    PublisherThumbprintHashAlgorithm: u16,
    ImageHashOffset: u32,
    PublisherThumbprintOffset: u32,
    LoadCount: u16,
    OemNameSize: u16,
    OemNameOffset: u32,
    Flags: _Flags_e__Union,
    Padding: u16,
};

const DRIVER_RUNTIME_REPORT = extern struct {
    Header: RUNTIME_REPORT_HEADER,
    NumberOfDrivers: u16,
    Flags: _Flags_e__Union,
    DriverEntries: [1]DRIVER_INFO_ENTRY,
};
type
  RUNTIME_REPORT_HEADER {.bycopy.} = object
    ReportType: uint16
    Reserved: uint16
    ReportSize: uint32

  DRIVER_INFO_ENTRY {.bycopy.} = object
    InternalName: array[32, int8]
    ImageHashAlgorithm: uint16
    PublisherThumbprintHashAlgorithm: uint16
    ImageHashOffset: uint32
    PublisherThumbprintOffset: uint32
    LoadCount: uint16
    OemNameSize: uint16
    OemNameOffset: uint32
    Flags: _Flags_e__Union
    Padding: uint16

  DRIVER_RUNTIME_REPORT {.bycopy.} = object
    Header: RUNTIME_REPORT_HEADER
    NumberOfDrivers: uint16
    Flags: _Flags_e__Union
    DriverEntries: array[1, DRIVER_INFO_ENTRY]
struct RUNTIME_REPORT_HEADER
{
    ushort ReportType;
    ushort Reserved;
    uint ReportSize;
}

struct DRIVER_INFO_ENTRY
{
    byte[32] InternalName;
    ushort ImageHashAlgorithm;
    ushort PublisherThumbprintHashAlgorithm;
    uint ImageHashOffset;
    uint PublisherThumbprintOffset;
    ushort LoadCount;
    ushort OemNameSize;
    uint OemNameOffset;
    _Flags_e__Union Flags;
    ushort Padding;
}

struct DRIVER_RUNTIME_REPORT
{
    RUNTIME_REPORT_HEADER Header;
    ushort NumberOfDrivers;
    _Flags_e__Union Flags;
    DRIVER_INFO_ENTRY[1] DriverEntries;
}

HSP用 定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; DRIVER_RUNTIME_REPORT サイズ: 76 バイト(x86)
dim st, 19    ; 4byte整数×19(構造体サイズ 76 / 4 切り上げ)
; Header : RUNTIME_REPORT_HEADER (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; NumberOfDrivers : WORD (+8, 2byte)  wpoke st,8,値  /  値 = wpeek(st,8)
; Flags : _Flags_e__Union (+12, 4byte)  varptr(st)+12 を基点に操作(4byte:入れ子/配列)
; DriverEntries : DRIVER_INFO_ENTRY (+16, 60byte)  varptr(st)+16 を基点に操作(60byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; DRIVER_RUNTIME_REPORT サイズ: 96 バイト(x64)
dim st, 24    ; 4byte整数×24(構造体サイズ 96 / 4 切り上げ)
; Header : RUNTIME_REPORT_HEADER (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; NumberOfDrivers : WORD (+8, 2byte)  wpoke st,8,値  /  値 = wpeek(st,8)
; Flags : _Flags_e__Union (+16, 8byte)  varptr(st)+16 を基点に操作(8byte:入れ子/配列)
; DriverEntries : DRIVER_INFO_ENTRY (+24, 72byte)  varptr(st)+24 を基点に操作(72byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global RUNTIME_REPORT_HEADER
    #field short ReportType
    #field short Reserved
    #field int ReportSize
#endstruct

#defstruct global DRIVER_INFO_ENTRY
    #field byte InternalName 32
    #field short ImageHashAlgorithm
    #field short PublisherThumbprintHashAlgorithm
    #field int ImageHashOffset
    #field int PublisherThumbprintOffset
    #field short LoadCount
    #field short OemNameSize
    #field int OemNameOffset
    #field byte Flags 8
    #field short Padding
#endstruct

#defstruct global DRIVER_RUNTIME_REPORT
    #field RUNTIME_REPORT_HEADER Header
    #field short NumberOfDrivers
    #field byte Flags 8
    #field DRIVER_INFO_ENTRY DriverEntries 1
#endstruct

stdim st, DRIVER_RUNTIME_REPORT        ; NSTRUCT 変数を確保
st->NumberOfDrivers = 100
mes "NumberOfDrivers=" + st->NumberOfDrivers
; ※union フィールドは byte 列で確保(NSTRUCT は union 非対応)。必要に応じ手動でアクセス。