EvtSubscribe

関数

イベントログのイベントをサブスクライブする。

DLLwevtapi.dll呼出規約winapiSetLastErrorあり対応OSWindows Vista 以降

シグネチャ

// wevtapi.dll
#include <windows.h>

EVT_HANDLE EvtSubscribe(
    EVT_HANDLE Session,   // optional
    HANDLE SignalEvent,   // optional
    LPCWSTR ChannelPath,   // optional
    LPCWSTR Query,   // optional
    EVT_HANDLE Bookmark,   // optional
    void* Context,   // optional
    EVT_SUBSCRIBE_CALLBACK Callback,   // optional
    DWORD Flags
);

パラメーター

名前	型	方向	説明
Session	EVT_HANDLE	inoptional	EvtOpenSession 関数が返すリモートセッションのハンドルです。ローカルコンピューター上のイベントをサブスクライブする場合は NULL を設定します。
SignalEvent	HANDLE	inoptional	クエリ条件に一致する新しいイベントが利用可能になったときに、サービスがシグナルを送るイベントオブジェクトのハンドルです。Callback パラメーターが NULL でない場合、このパラメーターは NULL でなければなりません。
ChannelPath	LPCWSTR	inoptional	サブスクライブするイベントを含む Admin または Operational チャネルの名前です(Analytic または Debug チャネルはサブスクライブできません)。Query パラメーターに XPath クエリを含む場合、このパスは必須です。Query パラメーターに構造化 XML クエリを含む場合、このパスは無視されます。
Query	LPCWSTR	inoptional	サブスクリプションサービスが返すイベントの種類を指定するクエリです。XPath 1.0 クエリまたは構造化 XML クエリを指定できます。XPath に 20 を超える式が含まれる場合は、構造化 XML クエリを使用してください。すべてのイベントを受信するには、このパラメーターを NULL または "*" に設定します。
Bookmark	EVT_HANDLE	inoptional	サブスクリプションの開始位置を識別するブックマークのハンドルです。ブックマークハンドルを取得するには、EvtCreateBookmark 関数を呼び出します。Flags パラメーターに EvtSubscribeStartAfterBookmark フラグが含まれる場合、このパラメーターを設定する必要があります。それ以外の場合は NULL を指定します。
Context	void*	inoptional	イベントを配信するたびに、サブスクリプションサービスが指定されたコールバックに渡す、呼び出し元が定義したコンテキスト値です。
Callback	EVT_SUBSCRIBE_CALLBACK	inoptional	サブスクリプションイベントを受信する EVT_SUBSCRIBE_CALLBACK コールバック関数へのポインターです。SignalEvent パラメーターが NULL でない場合、このパラメーターは NULL でなければなりません。
Flags	DWORD	in	イベントのサブスクライブを開始するタイミングを指定する 1 つ以上のフラグです。たとえば、EvtSubscribeStartAtOldestRecord を指定すると、サービスはクエリ条件に一致する現在および将来のすべてのイベントを取得します。一方、EvtSubscribeToFutureEvents を指定すると、サービスはクエリ条件に一致する将来のイベントのみを返します。指定可能な値については、EVT_SUBSCRIBE_FLAGS 列挙型を参照してください。

戻り値の型: EVT_HANDLE

公式ドキュメント

指定したクエリ条件に一致する、チャネルまたはログファイルの現在および将来のイベントを受信するサブスクリプションを作成します。

戻り値

成功した場合はサブスクリプションのハンドルを返します。それ以外の場合は NULL を返します。この関数が NULL を返した場合は、GetLastError 関数を呼び出してエラーコードを取得してください。処理が完了したら、サブスクリプションハンドルを指定して EvtClose 関数を呼び出す必要があります。

解説(Remarks)

サブスクリプションをキャンセルするには、返されたサブスクリプションハンドルを EvtClose 関数に渡します。

サブスクリプションには、ポーリングモデルとプッシュモデルの 2 つのモデルがあります。プッシュモデルでは、サブスクリプションコールバックを実装し、Callback パラメーターにその実装を設定します。サービスは、クエリ条件に一致する各イベントに対して(またはエラーが発生した場合に)コールバックを呼び出します。

ポーリングモデルでは、サービスがシグナルを送るイベントオブジェクトを作成します。シグナルが送られると、サブスクリプションハンドルを使用して EvtNext 関数を呼び出し、イベントを列挙します。列挙した各イベントに対して EvtClose 関数を呼び出す必要があります。その後、オブジェクトをリセットし、サービスが再びシグナルを送るのを待ちます。この処理は、サブスクリプションをキャンセルするまで繰り返されます。

例

この関数の使用方法を示す例については、Subscribing to Events を参照してください。

出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

// wevtapi.dll
#include <windows.h>

EVT_HANDLE EvtSubscribe(
    EVT_HANDLE Session,   // optional
    HANDLE SignalEvent,   // optional
    LPCWSTR ChannelPath,   // optional
    LPCWSTR Query,   // optional
    EVT_HANDLE Bookmark,   // optional
    void* Context,   // optional
    EVT_SUBSCRIBE_CALLBACK Callback,   // optional
    DWORD Flags
);

[DllImport("wevtapi.dll", SetLastError = true, ExactSpelling = true)]
static extern IntPtr EvtSubscribe(
    IntPtr Session,   // EVT_HANDLE optional
    IntPtr SignalEvent,   // HANDLE optional
    [MarshalAs(UnmanagedType.LPWStr)] string ChannelPath,   // LPCWSTR optional
    [MarshalAs(UnmanagedType.LPWStr)] string Query,   // LPCWSTR optional
    IntPtr Bookmark,   // EVT_HANDLE optional
    IntPtr Context,   // void* optional
    IntPtr Callback,   // EVT_SUBSCRIBE_CALLBACK optional
    uint Flags   // DWORD
);

<DllImport("wevtapi.dll", SetLastError:=True, ExactSpelling:=True)>
Public Shared Function EvtSubscribe(
    Session As IntPtr,   ' EVT_HANDLE optional
    SignalEvent As IntPtr,   ' HANDLE optional
    <MarshalAs(UnmanagedType.LPWStr)> ChannelPath As String,   ' LPCWSTR optional
    <MarshalAs(UnmanagedType.LPWStr)> Query As String,   ' LPCWSTR optional
    Bookmark As IntPtr,   ' EVT_HANDLE optional
    Context As IntPtr,   ' void* optional
    Callback As IntPtr,   ' EVT_SUBSCRIBE_CALLBACK optional
    Flags As UInteger   ' DWORD
) As IntPtr
End Function

' Session : EVT_HANDLE optional
' SignalEvent : HANDLE optional
' ChannelPath : LPCWSTR optional
' Query : LPCWSTR optional
' Bookmark : EVT_HANDLE optional
' Context : void* optional
' Callback : EVT_SUBSCRIBE_CALLBACK optional
' Flags : DWORD
Declare PtrSafe Function EvtSubscribe Lib "wevtapi" ( _
    ByVal Session As LongPtr, _
    ByVal SignalEvent As LongPtr, _
    ByVal ChannelPath As LongPtr, _
    ByVal Query As LongPtr, _
    ByVal Bookmark As LongPtr, _
    ByVal Context As LongPtr, _
    ByVal Callback As LongPtr, _
    ByVal Flags As Long) As LongPtr
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。

import ctypes
from ctypes import wintypes

EvtSubscribe = ctypes.windll.wevtapi.EvtSubscribe
EvtSubscribe.restype = ctypes.c_ssize_t
EvtSubscribe.argtypes = [
    ctypes.c_ssize_t,  # Session : EVT_HANDLE optional
    wintypes.HANDLE,  # SignalEvent : HANDLE optional
    wintypes.LPCWSTR,  # ChannelPath : LPCWSTR optional
    wintypes.LPCWSTR,  # Query : LPCWSTR optional
    ctypes.c_ssize_t,  # Bookmark : EVT_HANDLE optional
    ctypes.POINTER(None),  # Context : void* optional
    ctypes.c_void_p,  # Callback : EVT_SUBSCRIBE_CALLBACK optional
    wintypes.DWORD,  # Flags : DWORD
]
# GetLastError: use ctypes.GetLastError() (or ctypes.WinDLL(use_last_error=True))

require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('wevtapi.dll')
EvtSubscribe = Fiddle::Function.new(
  lib['EvtSubscribe'],
  [
    Fiddle::TYPE_INTPTR_T,  # Session : EVT_HANDLE optional
    Fiddle::TYPE_VOIDP,  # SignalEvent : HANDLE optional
    Fiddle::TYPE_VOIDP,  # ChannelPath : LPCWSTR optional
    Fiddle::TYPE_VOIDP,  # Query : LPCWSTR optional
    Fiddle::TYPE_INTPTR_T,  # Bookmark : EVT_HANDLE optional
    Fiddle::TYPE_VOIDP,  # Context : void* optional
    Fiddle::TYPE_VOIDP,  # Callback : EVT_SUBSCRIBE_CALLBACK optional
    -Fiddle::TYPE_INT,  # Flags : DWORD
  ],
  Fiddle::TYPE_INTPTR_T)

#[link(name = "wevtapi")]
extern "system" {
    fn EvtSubscribe(
        Session: isize,  // EVT_HANDLE optional
        SignalEvent: *mut core::ffi::c_void,  // HANDLE optional
        ChannelPath: *const u16,  // LPCWSTR optional
        Query: *const u16,  // LPCWSTR optional
        Bookmark: isize,  // EVT_HANDLE optional
        Context: *mut (),  // void* optional
        Callback: *const core::ffi::c_void,  // EVT_SUBSCRIBE_CALLBACK optional
        Flags: u32  // DWORD
    ) -> isize;
}
// crates: windows-sys provides ready-made bindings for this API.

$sig = @"
[DllImport("wevtapi.dll", SetLastError = true)]
public static extern IntPtr EvtSubscribe(IntPtr Session, IntPtr SignalEvent, [MarshalAs(UnmanagedType.LPWStr)] string ChannelPath, [MarshalAs(UnmanagedType.LPWStr)] string Query, IntPtr Bookmark, IntPtr Context, IntPtr Callback, uint Flags);
"@
$api = Add-Type -MemberDefinition $sig -Name 'wevtapi_EvtSubscribe' -Namespace Win32 -PassThru
# $api::EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)

#uselib "wevtapi.dll"
#func global EvtSubscribe "EvtSubscribe" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; EvtSubscribe Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags   ; 戻り値は stat
; Session : EVT_HANDLE optional -> "sptr"
; SignalEvent : HANDLE optional -> "sptr"
; ChannelPath : LPCWSTR optional -> "sptr"
; Query : LPCWSTR optional -> "sptr"
; Bookmark : EVT_HANDLE optional -> "sptr"
; Context : void* optional -> "sptr"
; Callback : EVT_SUBSCRIBE_CALLBACK optional -> "sptr"
; Flags : DWORD -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。

#uselib "wevtapi.dll"
#cfunc global EvtSubscribe "EvtSubscribe" sptr, sptr, wstr, wstr, sptr, sptr, sptr, int
; res = EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
; Session : EVT_HANDLE optional -> "sptr"
; SignalEvent : HANDLE optional -> "sptr"
; ChannelPath : LPCWSTR optional -> "wstr"
; Query : LPCWSTR optional -> "wstr"
; Bookmark : EVT_HANDLE optional -> "sptr"
; Context : void* optional -> "sptr"
; Callback : EVT_SUBSCRIBE_CALLBACK optional -> "sptr"
; Flags : DWORD -> "int"

; EVT_HANDLE EvtSubscribe(EVT_HANDLE Session, HANDLE SignalEvent, LPCWSTR ChannelPath, LPCWSTR Query, EVT_HANDLE Bookmark, void* Context, EVT_SUBSCRIBE_CALLBACK Callback, DWORD Flags)
#uselib "wevtapi.dll"
#cfunc global EvtSubscribe "EvtSubscribe" intptr, intptr, wstr, wstr, intptr, intptr, intptr, int
; res = EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
; Session : EVT_HANDLE optional -> "intptr"
; SignalEvent : HANDLE optional -> "intptr"
; ChannelPath : LPCWSTR optional -> "wstr"
; Query : LPCWSTR optional -> "wstr"
; Bookmark : EVT_HANDLE optional -> "intptr"
; Context : void* optional -> "intptr"
; Callback : EVT_SUBSCRIBE_CALLBACK optional -> "intptr"
; Flags : DWORD -> "int"

import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	wevtapi = windows.NewLazySystemDLL("wevtapi.dll")
	procEvtSubscribe = wevtapi.NewProc("EvtSubscribe")
)

// Session (EVT_HANDLE optional), SignalEvent (HANDLE optional), ChannelPath (LPCWSTR optional), Query (LPCWSTR optional), Bookmark (EVT_HANDLE optional), Context (void* optional), Callback (EVT_SUBSCRIBE_CALLBACK optional), Flags (DWORD)
r1, _, err := procEvtSubscribe.Call(
	uintptr(Session),
	uintptr(SignalEvent),
	uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(ChannelPath))),
	uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(Query))),
	uintptr(Bookmark),
	uintptr(Context),
	uintptr(Callback),
	uintptr(Flags),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // EVT_HANDLE

function EvtSubscribe(
  Session: NativeInt;   // EVT_HANDLE optional
  SignalEvent: THandle;   // HANDLE optional
  ChannelPath: PWideChar;   // LPCWSTR optional
  Query: PWideChar;   // LPCWSTR optional
  Bookmark: NativeInt;   // EVT_HANDLE optional
  Context: Pointer;   // void* optional
  Callback: Pointer;   // EVT_SUBSCRIBE_CALLBACK optional
  Flags: DWORD   // DWORD
): NativeInt; stdcall;
  external 'wevtapi.dll' name 'EvtSubscribe';

result := DllCall("wevtapi\EvtSubscribe"
    , "Ptr", Session   ; EVT_HANDLE optional
    , "Ptr", SignalEvent   ; HANDLE optional
    , "WStr", ChannelPath   ; LPCWSTR optional
    , "WStr", Query   ; LPCWSTR optional
    , "Ptr", Bookmark   ; EVT_HANDLE optional
    , "Ptr", Context   ; void* optional
    , "Ptr", Callback   ; EVT_SUBSCRIBE_CALLBACK optional
    , "UInt", Flags   ; DWORD
    , "Ptr")   ; return: EVT_HANDLE

●EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags) = DLL("wevtapi.dll", "int EvtSubscribe(int, void*, char*, char*, int, void*, void*, dword)")
# 呼び出し: EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
# Session : EVT_HANDLE optional -> "int"
# SignalEvent : HANDLE optional -> "void*"
# ChannelPath : LPCWSTR optional -> "char*"
# Query : LPCWSTR optional -> "char*"
# Bookmark : EVT_HANDLE optional -> "int"
# Context : void* optional -> "void*"
# Callback : EVT_SUBSCRIBE_CALLBACK optional -> "void*"
# Flags : DWORD -> "dword"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。

const std = @import("std");

extern "wevtapi" fn EvtSubscribe(
    Session: isize, // EVT_HANDLE optional
    SignalEvent: ?*anyopaque, // HANDLE optional
    ChannelPath: [*c]const u16, // LPCWSTR optional
    Query: [*c]const u16, // LPCWSTR optional
    Bookmark: isize, // EVT_HANDLE optional
    Context: ?*anyopaque, // void* optional
    Callback: ?*anyopaque, // EVT_SUBSCRIBE_CALLBACK optional
    Flags: u32 // DWORD
) callconv(std.os.windows.WINAPI) isize;

proc EvtSubscribe(
    Session: int,  # EVT_HANDLE optional
    SignalEvent: pointer,  # HANDLE optional
    ChannelPath: WideCString,  # LPCWSTR optional
    Query: WideCString,  # LPCWSTR optional
    Bookmark: int,  # EVT_HANDLE optional
    Context: pointer,  # void* optional
    Callback: pointer,  # EVT_SUBSCRIBE_CALLBACK optional
    Flags: uint32  # DWORD
): int {.importc: "EvtSubscribe", stdcall, dynlib: "wevtapi.dll".}

pragma(lib, "wevtapi");
extern(Windows)
ptrdiff_t EvtSubscribe(
    ptrdiff_t Session,   // EVT_HANDLE optional
    void* SignalEvent,   // HANDLE optional
    const(wchar)* ChannelPath,   // LPCWSTR optional
    const(wchar)* Query,   // LPCWSTR optional
    ptrdiff_t Bookmark,   // EVT_HANDLE optional
    void* Context,   // void* optional
    void* Callback,   // EVT_SUBSCRIBE_CALLBACK optional
    uint Flags   // DWORD
);

ccall((:EvtSubscribe, "wevtapi.dll"), stdcall, Int,
      (Int, Ptr{Cvoid}, Cwstring, Cwstring, Int, Ptr{Cvoid}, Ptr{Cvoid}, UInt32),
      Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
# Session : EVT_HANDLE optional -> Int
# SignalEvent : HANDLE optional -> Ptr{Cvoid}
# ChannelPath : LPCWSTR optional -> Cwstring
# Query : LPCWSTR optional -> Cwstring
# Bookmark : EVT_HANDLE optional -> Int
# Context : void* optional -> Ptr{Cvoid}
# Callback : EVT_SUBSCRIBE_CALLBACK optional -> Ptr{Cvoid}
# Flags : DWORD -> UInt32
# stdcall は 32bit のみ意味を持つ(x64 では無視)。

local ffi = require("ffi")
ffi.cdef[[
intptr_t EvtSubscribe(
    intptr_t Session,
    void* SignalEvent,
    const uint16_t* ChannelPath,
    const uint16_t* Query,
    intptr_t Bookmark,
    void* Context,
    void* Callback,
    uint32_t Flags);
]]
local wevtapi = ffi.load("wevtapi")
-- wevtapi.EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
-- Session : EVT_HANDLE optional
-- SignalEvent : HANDLE optional
-- ChannelPath : LPCWSTR optional
-- Query : LPCWSTR optional
-- Bookmark : EVT_HANDLE optional
-- Context : void* optional
-- Callback : EVT_SUBSCRIBE_CALLBACK optional
-- Flags : DWORD
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。

const koffi = require('koffi');
const lib = koffi.load('wevtapi.dll');
const EvtSubscribe = lib.func('__stdcall', 'EvtSubscribe', 'intptr_t', ['intptr_t', 'void *', 'str16', 'str16', 'intptr_t', 'void *', 'void *', 'uint32_t']);
// EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
// Session : EVT_HANDLE optional -> 'intptr_t'
// SignalEvent : HANDLE optional -> 'void *'
// ChannelPath : LPCWSTR optional -> 'str16'
// Query : LPCWSTR optional -> 'str16'
// Bookmark : EVT_HANDLE optional -> 'intptr_t'
// Context : void* optional -> 'void *'
// Callback : EVT_SUBSCRIBE_CALLBACK optional -> 'void *'
// Flags : DWORD -> 'uint32_t'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
// コールバック(関数ポインタ)は koffi.proto/koffi.register で型を定義して渡す(素の void* では JS 関数を渡せない)。

const lib = Deno.dlopen("wevtapi.dll", {
  EvtSubscribe: { parameters: ["isize", "pointer", "buffer", "buffer", "isize", "pointer", "pointer", "u32"], result: "isize" },
});
// lib.symbols.EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags)
// Session : EVT_HANDLE optional -> "isize"
// SignalEvent : HANDLE optional -> "pointer"
// ChannelPath : LPCWSTR optional -> "buffer"
// Query : LPCWSTR optional -> "buffer"
// Bookmark : EVT_HANDLE optional -> "isize"
// Context : void* optional -> "pointer"
// Callback : EVT_SUBSCRIBE_CALLBACK optional -> "pointer"
// Flags : DWORD -> "u32"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。

<?php
$ffi = FFI::cdef(<<<C
intptr_t EvtSubscribe(
    intptr_t Session,
    void* SignalEvent,
    const uint16_t* ChannelPath,
    const uint16_t* Query,
    intptr_t Bookmark,
    void* Context,
    void* Callback,
    uint32_t Flags);
C, "wevtapi.dll");
// $ffi->EvtSubscribe(Session, SignalEvent, ChannelPath, Query, Bookmark, Context, Callback, Flags);
// Session : EVT_HANDLE optional
// SignalEvent : HANDLE optional
// ChannelPath : LPCWSTR optional
// Query : LPCWSTR optional
// Bookmark : EVT_HANDLE optional
// Context : void* optional
// Callback : EVT_SUBSCRIBE_CALLBACK optional
// Flags : DWORD
// 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
// WINAPI(stdcall): x64 では呼出規約が統一されるため問題なし。x86 では __stdcall 対応のラッパが必要な場合あり。

import com.sun.jna.*;
import com.sun.jna.ptr.*;
import com.sun.jna.win32.StdCallLibrary;
import com.sun.jna.win32.W32APIOptions;

public interface Wevtapi extends StdCallLibrary {
    Wevtapi INSTANCE = Native.load("wevtapi", Wevtapi.class);
    long EvtSubscribe(
        long Session,   // EVT_HANDLE optional
        Pointer SignalEvent,   // HANDLE optional
        WString ChannelPath,   // LPCWSTR optional
        WString Query,   // LPCWSTR optional
        long Bookmark,   // EVT_HANDLE optional
        Pointer Context,   // void* optional
        Callback Callback,   // EVT_SUBSCRIBE_CALLBACK optional
        int Flags   // DWORD
    );
}

@[Link("wevtapi")]
lib Libwevtapi
  fun EvtSubscribe = EvtSubscribe(
    Session : LibC::SSizeT,   # EVT_HANDLE optional
    SignalEvent : Void*,   # HANDLE optional
    ChannelPath : UInt16*,   # LPCWSTR optional
    Query : UInt16*,   # LPCWSTR optional
    Bookmark : LibC::SSizeT,   # EVT_HANDLE optional
    Context : Void*,   # void* optional
    Callback : Void*,   # EVT_SUBSCRIBE_CALLBACK optional
    Flags : UInt32   # DWORD
  ) : LibC::SSizeT
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。

import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef EvtSubscribeNative = IntPtr Function(IntPtr, Pointer<Void>, Pointer<Utf16>, Pointer<Utf16>, IntPtr, Pointer<Void>, Pointer<Void>, Uint32);
typedef EvtSubscribeDart = int Function(int, Pointer<Void>, Pointer<Utf16>, Pointer<Utf16>, int, Pointer<Void>, Pointer<Void>, int);
final EvtSubscribe = DynamicLibrary.open('wevtapi.dll')
    .lookupFunction<EvtSubscribeNative, EvtSubscribeDart>('EvtSubscribe');
// Session : EVT_HANDLE optional -> IntPtr
// SignalEvent : HANDLE optional -> Pointer<Void>
// ChannelPath : LPCWSTR optional -> Pointer<Utf16>
// Query : LPCWSTR optional -> Pointer<Utf16>
// Bookmark : EVT_HANDLE optional -> IntPtr
// Context : void* optional -> Pointer<Void>
// Callback : EVT_SUBSCRIBE_CALLBACK optional -> Pointer<Void>
// Flags : DWORD -> Uint32
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。

{$mode objfpc}{$H+}
function EvtSubscribe(
  Session: NativeInt;   // EVT_HANDLE optional
  SignalEvent: THandle;   // HANDLE optional
  ChannelPath: PWideChar;   // LPCWSTR optional
  Query: PWideChar;   // LPCWSTR optional
  Bookmark: NativeInt;   // EVT_HANDLE optional
  Context: Pointer;   // void* optional
  Callback: Pointer;   // EVT_SUBSCRIBE_CALLBACK optional
  Flags: DWORD   // DWORD
): NativeInt; stdcall;
  external 'wevtapi.dll' name 'EvtSubscribe';

import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "EvtSubscribe"
  c_EvtSubscribe :: CIntPtr -> Ptr () -> CWString -> CWString -> CIntPtr -> Ptr () -> Ptr () -> Word32 -> IO CIntPtr
-- Session : EVT_HANDLE optional -> CIntPtr
-- SignalEvent : HANDLE optional -> Ptr ()
-- ChannelPath : LPCWSTR optional -> CWString
-- Query : LPCWSTR optional -> CWString
-- Bookmark : EVT_HANDLE optional -> CIntPtr
-- Context : void* optional -> Ptr ()
-- Callback : EVT_SUBSCRIBE_CALLBACK optional -> Ptr ()
-- Flags : DWORD -> Word32
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。

open Ctypes
open Foreign

let evtsubscribe =
  foreign "EvtSubscribe"
    (intptr_t @-> (ptr void) @-> (ptr uint16_t) @-> (ptr uint16_t) @-> intptr_t @-> (ptr void) @-> (ptr void) @-> uint32_t @-> returning intptr_t)
(* Session : EVT_HANDLE optional -> intptr_t *)
(* SignalEvent : HANDLE optional -> (ptr void) *)
(* ChannelPath : LPCWSTR optional -> (ptr uint16_t) *)
(* Query : LPCWSTR optional -> (ptr uint16_t) *)
(* Bookmark : EVT_HANDLE optional -> intptr_t *)
(* Context : void* optional -> (ptr void) *)
(* Callback : EVT_SUBSCRIBE_CALLBACK optional -> (ptr void) *)
(* Flags : DWORD -> uint32_t *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)

(cffi:define-foreign-library wevtapi (t "wevtapi.dll"))
(cffi:use-foreign-library wevtapi)

(cffi:defcfun ("EvtSubscribe" evt-subscribe :convention :stdcall) :int64
  (session :int64)   ; EVT_HANDLE optional
  (signal-event :pointer)   ; HANDLE optional
  (channel-path (:string :encoding :utf-16le))   ; LPCWSTR optional
  (query (:string :encoding :utf-16le))   ; LPCWSTR optional
  (bookmark :int64)   ; EVT_HANDLE optional
  (context :pointer)   ; void* optional
  (callback :pointer)   ; EVT_SUBSCRIBE_CALLBACK optional
  (flags :uint32))   ; DWORD
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。

use Win32::API;
my $EvtSubscribe = Win32::API::More->new('wevtapi',
    'LPARAM EvtSubscribe(LPARAM Session, HANDLE SignalEvent, LPCWSTR ChannelPath, LPCWSTR Query, LPARAM Bookmark, LPVOID Context, LPVOID Callback, DWORD Flags)');
# my $ret = $EvtSubscribe->Call($Session, $SignalEvent, $ChannelPath, $Query, $Bookmark, $Context, $Callback, $Flags);
# Session : EVT_HANDLE optional -> LPARAM
# SignalEvent : HANDLE optional -> HANDLE
# ChannelPath : LPCWSTR optional -> LPCWSTR
# Query : LPCWSTR optional -> LPCWSTR
# Bookmark : EVT_HANDLE optional -> LPARAM
# Context : void* optional -> LPVOID
# Callback : EVT_SUBSCRIBE_CALLBACK optional -> LPVOID
# Flags : DWORD -> DWORD
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。
# コールバック(関数ポインタ)は Perl sub を直接渡せません。Win32::API::Callback を使用してください。