Win32 API 日本語リファレンス
ホーム › Security.ExtensibleAuthenticationProtocol › EapHostPeerBeginSession

EapHostPeerBeginSession

関数
EAP認証セッションを開始する。
DLLeappprxy.dll呼出規約winapi対応OSWindows Vista 以降
📘 Microsoft Learn (日本語) · English

シグネチャ

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

DWORD EapHostPeerBeginSession(
    DWORD dwFlags,
    EAP_METHOD_TYPE eapType,
    const EAP_ATTRIBUTES* pAttributeArray,
    HANDLE hTokenImpersonateUser,
    DWORD dwSizeofConnectionData,
    const BYTE* pConnectionData,
    DWORD dwSizeofUserData,
    const BYTE* pUserData,
    DWORD dwMaxSendPacketSize,
    const GUID* pConnectionId,   // optional
    NotificationHandler func,   // optional
    void* pContextData,   // optional
    DWORD* pSessionId,
    EAP_ERROR** ppEapError
);

パラメーター

名前型方向説明
dwFlagsDWORDin新しい EAP 認証セッションの動作を記述する EAP フラグ の組み合わせです。
eapTypeEAP_METHOD_TYPEinこのセッションで使用する EAP 認証の種類を指定する EAP_METHOD_TYPE 構造体です。
pAttributeArrayEAP_ATTRIBUTES*in認証対象のエンティティの EAP 属性を指定する EapAttributes 構造体へのポインターです。
hTokenImpersonateUserHANDLEinこのセッションで使用するユーザー偽装トークンのハンドルです。
dwSizeofConnectionDataDWORDinpConnectionData で指定した接続データバッファーのサイズ (バイト単位) です。
pConnectionDataBYTE*in認証に使用する構成を記述します。NULL の接続データも有効と見なされます。メソッドは既定の構成で動作する必要があります。
dwSizeofUserDataDWORDinpUserData で指定したユーザーデータバッファーのサイズ (バイト単位) です。
pUserDataBYTE*in

EapPeerGetIdentity 関数から返されたユーザーデータを含む、不透明なユーザーデータ BLOB を格納したバイトバッファーへのポインターです。ユーザーデータには、認証に使用する資格情報や証明書が含まれることがあります。pUserData は NULL でもかまいません。NULL ポインターの解釈はメソッドの実装によって異なります。ユーザーデータは、認証に使用されるユーザーまたはコンピューターの資格情報で構成されます。通常、ユーザーデータは構成データに依存します。

dwflags に EAP_FLAG_PREFER_ALT_CREDENTIALS が指定されている場合、pConnectionData に渡された構成データが別の資格情報取得方法を要求していても、EapPeerBeginSession に渡された資格情報が他のあらゆる資格情報取得方法よりも優先されます。EapPeerBeginSession への資格情報の受け渡しが失敗した場合、EAPHost はメソッド固有の資格情報取得に切り替えます。この場合、資格情報はたとえばファイル、Windows ログイン、証明書ストアなどから取得されることがあります。

既定の資格情報と代替の資格情報は、いずれも EAP メソッドの作成者が定義します。たとえば EAP-MSCHAPv2 の場合、既定の資格情報は winlogon から取得される Windows 資格情報であり、代替の資格情報は pUserData に渡される資格情報 (ユーザー名、パスワード、ドメイン) です。

dwMaxSendPacketSizeDWORDinセッション中に送信できる EAP パケットの最大サイズ (バイト単位) です。
pConnectionIdGUID*inoptionalサプリカントの認証が行われる論理ネットワークインターフェイスを一意に識別する GUID 値へのポインターです。NAP のヘルス状態の変化後にサプリカントが再認証を求める場合は、一意の GUID を指定する必要があります。 トンネリングメソッドが内部メソッドを開始するためにこの関数を呼び出す場合、このパラメーターは NULL にする必要があります。pConnectionId パラメーターが NULL の場合、func パラメーターと pContextData パラメーターは無視されます。
funcNotificationHandlerinoptional

再認証が必要になったときに EAPHost がサプリカントへ通知するために使用するコールバックを提供する、NotificationHandler 関数ポインターです。

関数ハンドラーが NULL の場合、pContextData パラメーターは無視されます。また、関数ハンドラーが NULL であることは、呼び出し元が EAP 検疫強制クライアント (QEC) からの SoH 変更通知を必要としていないことも意味します。

次のコードは NotificationHandler コールバックの呼び出し例を示します。

func(*pConnectionId, pContextData);
pContextDatavoid*inoptionalfunc が呼び出されたときにサプリカントが接続に関連付ける、再認証コンテキストデータへのポインターです。このパラメーターは NULL でもかまいません。
pSessionIdDWORD*outEAPHost サーバー上のこの EAP 認証セッションを一意に識別するハンドルを格納する EAP_SESSIONID 構造体へのポインターです。
ppEapErrorEAP_ERROR**outEAP_ERROR 構造体のアドレスへのポインターです。この関数を呼び出す前に、アドレスを NULL に設定してください。エラーデータが利用可能な場合は、この関数呼び出しの実行中に発生したエラーを格納する EAP_ERROR 構造体のアドレスへのポインターが返されます。エラーデータの使用後は、EapHostPeerFreeEapError を呼び出してこのメモリを解放してください。

戻り値の型: DWORD

公式ドキュメント

EAP 認証セッションを開始します。

解説(Remarks)

EAPHost サプリカントが NAP に参加している場合、サプリカントはネットワークのヘルス状態の変化に応答します。その状態が変化した場合、サプリカントは次のようにして再認証セッションを開始する必要があります。

再認証セッションを確立するための EapHostPeerBeginSession の呼び出しは、func パラメーターで指定され、ヘルス状態が変化したときに呼び出されるコールバックから行うことができます。このコールバック関数は、GUID に関連付けられたネットワーク認証を解除して再認証するようサプリカントに指示します。

EapHostPeerBeginSession は接続を登録するための有効な GUID を提供できるため、接続を複数のセッションにまたがって維持できます。EapHostPeerEndSession を呼び出しても、終了するのは現在のセッションだけです。GUID による登録は終了しないため、EapHostPeerBeginSession による元の登録はそのまま保持されます。したがって、その登録は複数のセッションにわたって有効です。

注意 接続の登録とは、有効な GUID と有効なコールバック関数ポインターを指定することを指します。
出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

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

DWORD EapHostPeerBeginSession(
    DWORD dwFlags,
    EAP_METHOD_TYPE eapType,
    const EAP_ATTRIBUTES* pAttributeArray,
    HANDLE hTokenImpersonateUser,
    DWORD dwSizeofConnectionData,
    const BYTE* pConnectionData,
    DWORD dwSizeofUserData,
    const BYTE* pUserData,
    DWORD dwMaxSendPacketSize,
    const GUID* pConnectionId,   // optional
    NotificationHandler func,   // optional
    void* pContextData,   // optional
    DWORD* pSessionId,
    EAP_ERROR** ppEapError
);
[DllImport("eappprxy.dll", ExactSpelling = true)]
static extern uint EapHostPeerBeginSession(
    uint dwFlags,   // DWORD
    EAP_METHOD_TYPE eapType,   // EAP_METHOD_TYPE
    IntPtr pAttributeArray,   // EAP_ATTRIBUTES*
    IntPtr hTokenImpersonateUser,   // HANDLE
    uint dwSizeofConnectionData,   // DWORD
    IntPtr pConnectionData,   // BYTE*
    uint dwSizeofUserData,   // DWORD
    IntPtr pUserData,   // BYTE*
    uint dwMaxSendPacketSize,   // DWORD
    IntPtr pConnectionId,   // GUID* optional
    IntPtr func,   // NotificationHandler optional
    IntPtr pContextData,   // void* optional
    out uint pSessionId,   // DWORD* out
    IntPtr ppEapError   // EAP_ERROR** out
);
<DllImport("eappprxy.dll", ExactSpelling:=True)>
Public Shared Function EapHostPeerBeginSession(
    dwFlags As UInteger,   ' DWORD
    eapType As EAP_METHOD_TYPE,   ' EAP_METHOD_TYPE
    pAttributeArray As IntPtr,   ' EAP_ATTRIBUTES*
    hTokenImpersonateUser As IntPtr,   ' HANDLE
    dwSizeofConnectionData As UInteger,   ' DWORD
    pConnectionData As IntPtr,   ' BYTE*
    dwSizeofUserData As UInteger,   ' DWORD
    pUserData As IntPtr,   ' BYTE*
    dwMaxSendPacketSize As UInteger,   ' DWORD
    pConnectionId As IntPtr,   ' GUID* optional
    func As IntPtr,   ' NotificationHandler optional
    pContextData As IntPtr,   ' void* optional
    <Out> ByRef pSessionId As UInteger,   ' DWORD* out
    ppEapError As IntPtr   ' EAP_ERROR** out
) As UInteger
End Function
' dwFlags : DWORD
' eapType : EAP_METHOD_TYPE
' pAttributeArray : EAP_ATTRIBUTES*
' hTokenImpersonateUser : HANDLE
' dwSizeofConnectionData : DWORD
' pConnectionData : BYTE*
' dwSizeofUserData : DWORD
' pUserData : BYTE*
' dwMaxSendPacketSize : DWORD
' pConnectionId : GUID* optional
' func : NotificationHandler optional
' pContextData : void* optional
' pSessionId : DWORD* out
' ppEapError : EAP_ERROR** out
Declare PtrSafe Function EapHostPeerBeginSession Lib "eappprxy" ( _
    ByVal dwFlags As Long, _
    ByVal eapType As LongPtr, _
    ByVal pAttributeArray As LongPtr, _
    ByVal hTokenImpersonateUser As LongPtr, _
    ByVal dwSizeofConnectionData As Long, _
    ByVal pConnectionData As LongPtr, _
    ByVal dwSizeofUserData As Long, _
    ByVal pUserData As LongPtr, _
    ByVal dwMaxSendPacketSize As Long, _
    ByVal pConnectionId As LongPtr, _
    ByVal func As LongPtr, _
    ByVal pContextData As LongPtr, _
    ByRef pSessionId As Long, _
    ByVal ppEapError As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

EapHostPeerBeginSession = ctypes.windll.eappprxy.EapHostPeerBeginSession
EapHostPeerBeginSession.restype = wintypes.DWORD
EapHostPeerBeginSession.argtypes = [
    wintypes.DWORD,  # dwFlags : DWORD
    EAP_METHOD_TYPE,  # eapType : EAP_METHOD_TYPE
    ctypes.c_void_p,  # pAttributeArray : EAP_ATTRIBUTES*
    wintypes.HANDLE,  # hTokenImpersonateUser : HANDLE
    wintypes.DWORD,  # dwSizeofConnectionData : DWORD
    ctypes.POINTER(ctypes.c_ubyte),  # pConnectionData : BYTE*
    wintypes.DWORD,  # dwSizeofUserData : DWORD
    ctypes.POINTER(ctypes.c_ubyte),  # pUserData : BYTE*
    wintypes.DWORD,  # dwMaxSendPacketSize : DWORD
    ctypes.c_void_p,  # pConnectionId : GUID* optional
    ctypes.c_void_p,  # func : NotificationHandler optional
    ctypes.POINTER(None),  # pContextData : void* optional
    ctypes.POINTER(wintypes.DWORD),  # pSessionId : DWORD* out
    ctypes.c_void_p,  # ppEapError : EAP_ERROR** out
]
require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('eappprxy.dll')
EapHostPeerBeginSession = Fiddle::Function.new(
  lib['EapHostPeerBeginSession'],
  [
    -Fiddle::TYPE_INT,  # dwFlags : DWORD
    Fiddle::TYPE_VOIDP,  # eapType : EAP_METHOD_TYPE
    Fiddle::TYPE_VOIDP,  # pAttributeArray : EAP_ATTRIBUTES*
    Fiddle::TYPE_VOIDP,  # hTokenImpersonateUser : HANDLE
    -Fiddle::TYPE_INT,  # dwSizeofConnectionData : DWORD
    Fiddle::TYPE_VOIDP,  # pConnectionData : BYTE*
    -Fiddle::TYPE_INT,  # dwSizeofUserData : DWORD
    Fiddle::TYPE_VOIDP,  # pUserData : BYTE*
    -Fiddle::TYPE_INT,  # dwMaxSendPacketSize : DWORD
    Fiddle::TYPE_VOIDP,  # pConnectionId : GUID* optional
    Fiddle::TYPE_VOIDP,  # func : NotificationHandler optional
    Fiddle::TYPE_VOIDP,  # pContextData : void* optional
    Fiddle::TYPE_VOIDP,  # pSessionId : DWORD* out
    Fiddle::TYPE_VOIDP,  # ppEapError : EAP_ERROR** out
  ],
  -Fiddle::TYPE_INT)
#[link(name = "eappprxy")]
extern "system" {
    fn EapHostPeerBeginSession(
        dwFlags: u32,  // DWORD
        eapType: EAP_METHOD_TYPE,  // EAP_METHOD_TYPE
        pAttributeArray: *const EAP_ATTRIBUTES,  // EAP_ATTRIBUTES*
        hTokenImpersonateUser: *mut core::ffi::c_void,  // HANDLE
        dwSizeofConnectionData: u32,  // DWORD
        pConnectionData: *const u8,  // BYTE*
        dwSizeofUserData: u32,  // DWORD
        pUserData: *const u8,  // BYTE*
        dwMaxSendPacketSize: u32,  // DWORD
        pConnectionId: *const GUID,  // GUID* optional
        func: *const core::ffi::c_void,  // NotificationHandler optional
        pContextData: *mut (),  // void* optional
        pSessionId: *mut u32,  // DWORD* out
        ppEapError: *mut *mut EAP_ERROR  // EAP_ERROR** out
    ) -> u32;
}
// crates: windows-sys provides ready-made bindings for this API.
$sig = @"
[DllImport("eappprxy.dll")]
public static extern uint EapHostPeerBeginSession(uint dwFlags, EAP_METHOD_TYPE eapType, IntPtr pAttributeArray, IntPtr hTokenImpersonateUser, uint dwSizeofConnectionData, IntPtr pConnectionData, uint dwSizeofUserData, IntPtr pUserData, uint dwMaxSendPacketSize, IntPtr pConnectionId, IntPtr func, IntPtr pContextData, out uint pSessionId, IntPtr ppEapError);
"@
$api = Add-Type -MemberDefinition $sig -Name 'eappprxy_EapHostPeerBeginSession' -Namespace Win32 -PassThru
# $api::EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
#uselib "eappprxy.dll"
#func global EapHostPeerBeginSession "EapHostPeerBeginSession" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; EapHostPeerBeginSession dwFlags, eapType, varptr(pAttributeArray), hTokenImpersonateUser, dwSizeofConnectionData, varptr(pConnectionData), dwSizeofUserData, varptr(pUserData), dwMaxSendPacketSize, varptr(pConnectionId), func, pContextData, varptr(pSessionId), varptr(ppEapError)   ; 戻り値は stat
; dwFlags : DWORD -> "sptr"
; eapType : EAP_METHOD_TYPE -> "sptr"
; pAttributeArray : EAP_ATTRIBUTES* -> "sptr"
; hTokenImpersonateUser : HANDLE -> "sptr"
; dwSizeofConnectionData : DWORD -> "sptr"
; pConnectionData : BYTE* -> "sptr"
; dwSizeofUserData : DWORD -> "sptr"
; pUserData : BYTE* -> "sptr"
; dwMaxSendPacketSize : DWORD -> "sptr"
; pConnectionId : GUID* optional -> "sptr"
; func : NotificationHandler optional -> "sptr"
; pContextData : void* optional -> "sptr"
; pSessionId : DWORD* out -> "sptr"
; ppEapError : EAP_ERROR** out -> "sptr"
; ※値渡し構造体は直接渡せません。intにパック、または var で構造体変数を渡してください。
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。
出力引数: 
#uselib "eappprxy.dll"
#cfunc global EapHostPeerBeginSession "EapHostPeerBeginSession" int, int, var, sptr, int, var, int, var, int, var, sptr, sptr, var, var
; res = EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
; dwFlags : DWORD -> "int"
; eapType : EAP_METHOD_TYPE -> "int"
; pAttributeArray : EAP_ATTRIBUTES* -> "var"
; hTokenImpersonateUser : HANDLE -> "sptr"
; dwSizeofConnectionData : DWORD -> "int"
; pConnectionData : BYTE* -> "var"
; dwSizeofUserData : DWORD -> "int"
; pUserData : BYTE* -> "var"
; dwMaxSendPacketSize : DWORD -> "int"
; pConnectionId : GUID* optional -> "var"
; func : NotificationHandler optional -> "sptr"
; pContextData : void* optional -> "sptr"
; pSessionId : DWORD* out -> "var"
; ppEapError : EAP_ERROR** out -> "var"
; ※値渡し構造体は直接渡せません。intにパック、または var で構造体変数を渡してください。
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
出力引数: 
; DWORD EapHostPeerBeginSession(DWORD dwFlags, EAP_METHOD_TYPE eapType, EAP_ATTRIBUTES* pAttributeArray, HANDLE hTokenImpersonateUser, DWORD dwSizeofConnectionData, BYTE* pConnectionData, DWORD dwSizeofUserData, BYTE* pUserData, DWORD dwMaxSendPacketSize, GUID* pConnectionId, NotificationHandler func, void* pContextData, DWORD* pSessionId, EAP_ERROR** ppEapError)
#uselib "eappprxy.dll"
#cfunc global EapHostPeerBeginSession "EapHostPeerBeginSession" int, int, var, intptr, int, var, int, var, int, var, intptr, intptr, var, var
; res = EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
; dwFlags : DWORD -> "int"
; eapType : EAP_METHOD_TYPE -> "int"
; pAttributeArray : EAP_ATTRIBUTES* -> "var"
; hTokenImpersonateUser : HANDLE -> "intptr"
; dwSizeofConnectionData : DWORD -> "int"
; pConnectionData : BYTE* -> "var"
; dwSizeofUserData : DWORD -> "int"
; pUserData : BYTE* -> "var"
; dwMaxSendPacketSize : DWORD -> "int"
; pConnectionId : GUID* optional -> "var"
; func : NotificationHandler optional -> "intptr"
; pContextData : void* optional -> "intptr"
; pSessionId : DWORD* out -> "var"
; ppEapError : EAP_ERROR** out -> "var"
; ※値渡し構造体は直接渡せません。intにパック、または var で構造体変数を渡してください。
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	eappprxy = windows.NewLazySystemDLL("eappprxy.dll")
	procEapHostPeerBeginSession = eappprxy.NewProc("EapHostPeerBeginSession")
)

// dwFlags (DWORD), eapType (EAP_METHOD_TYPE), pAttributeArray (EAP_ATTRIBUTES*), hTokenImpersonateUser (HANDLE), dwSizeofConnectionData (DWORD), pConnectionData (BYTE*), dwSizeofUserData (DWORD), pUserData (BYTE*), dwMaxSendPacketSize (DWORD), pConnectionId (GUID* optional), func (NotificationHandler optional), pContextData (void* optional), pSessionId (DWORD* out), ppEapError (EAP_ERROR** out)
r1, _, err := procEapHostPeerBeginSession.Call(
	uintptr(dwFlags),
	uintptr(eapType),
	uintptr(pAttributeArray),
	uintptr(hTokenImpersonateUser),
	uintptr(dwSizeofConnectionData),
	uintptr(pConnectionData),
	uintptr(dwSizeofUserData),
	uintptr(pUserData),
	uintptr(dwMaxSendPacketSize),
	uintptr(pConnectionId),
	uintptr(func),
	uintptr(pContextData),
	uintptr(pSessionId),
	uintptr(ppEapError),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // DWORD
function EapHostPeerBeginSession(
  dwFlags: DWORD;   // DWORD
  eapType: EAP_METHOD_TYPE;   // EAP_METHOD_TYPE
  pAttributeArray: Pointer;   // EAP_ATTRIBUTES*
  hTokenImpersonateUser: THandle;   // HANDLE
  dwSizeofConnectionData: DWORD;   // DWORD
  pConnectionData: Pointer;   // BYTE*
  dwSizeofUserData: DWORD;   // DWORD
  pUserData: Pointer;   // BYTE*
  dwMaxSendPacketSize: DWORD;   // DWORD
  pConnectionId: PGUID;   // GUID* optional
  func: Pointer;   // NotificationHandler optional
  pContextData: Pointer;   // void* optional
  pSessionId: Pointer;   // DWORD* out
  ppEapError: Pointer   // EAP_ERROR** out
): DWORD; stdcall;
  external 'eappprxy.dll' name 'EapHostPeerBeginSession';
result := DllCall("eappprxy\EapHostPeerBeginSession"
    , "UInt", dwFlags   ; DWORD
    , "Ptr", eapType   ; EAP_METHOD_TYPE
    , "Ptr", pAttributeArray   ; EAP_ATTRIBUTES*
    , "Ptr", hTokenImpersonateUser   ; HANDLE
    , "UInt", dwSizeofConnectionData   ; DWORD
    , "Ptr", pConnectionData   ; BYTE*
    , "UInt", dwSizeofUserData   ; DWORD
    , "Ptr", pUserData   ; BYTE*
    , "UInt", dwMaxSendPacketSize   ; DWORD
    , "Ptr", pConnectionId   ; GUID* optional
    , "Ptr", func   ; NotificationHandler optional
    , "Ptr", pContextData   ; void* optional
    , "Ptr", pSessionId   ; DWORD* out
    , "Ptr", ppEapError   ; EAP_ERROR** out
    , "UInt")   ; return: DWORD
●EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError) = DLL("eappprxy.dll", "dword EapHostPeerBeginSession(dword, void*, void*, void*, dword, void*, dword, void*, dword, void*, void*, void*, void*, void*)")
# 呼び出し: EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
# dwFlags : DWORD -> "dword"
# eapType : EAP_METHOD_TYPE -> "void*"
# pAttributeArray : EAP_ATTRIBUTES* -> "void*"
# hTokenImpersonateUser : HANDLE -> "void*"
# dwSizeofConnectionData : DWORD -> "dword"
# pConnectionData : BYTE* -> "void*"
# dwSizeofUserData : DWORD -> "dword"
# pUserData : BYTE* -> "void*"
# dwMaxSendPacketSize : DWORD -> "dword"
# pConnectionId : GUID* optional -> "void*"
# func : NotificationHandler optional -> "void*"
# pContextData : void* optional -> "void*"
# pSessionId : DWORD* out -> "void*"
# ppEapError : EAP_ERROR** out -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "eappprxy" fn EapHostPeerBeginSession(
    dwFlags: u32, // DWORD
    eapType: EAP_METHOD_TYPE, // EAP_METHOD_TYPE
    pAttributeArray: [*c]EAP_ATTRIBUTES, // EAP_ATTRIBUTES*
    hTokenImpersonateUser: ?*anyopaque, // HANDLE
    dwSizeofConnectionData: u32, // DWORD
    pConnectionData: [*c]u8, // BYTE*
    dwSizeofUserData: u32, // DWORD
    pUserData: [*c]u8, // BYTE*
    dwMaxSendPacketSize: u32, // DWORD
    pConnectionId: [*c]GUID, // GUID* optional
    func: ?*anyopaque, // NotificationHandler optional
    pContextData: ?*anyopaque, // void* optional
    pSessionId: [*c]u32, // DWORD* out
    ppEapError: [*c][*c]EAP_ERROR // EAP_ERROR** out
) callconv(std.os.windows.WINAPI) u32;
proc EapHostPeerBeginSession(
    dwFlags: uint32,  # DWORD
    eapType: EAP_METHOD_TYPE,  # EAP_METHOD_TYPE
    pAttributeArray: ptr EAP_ATTRIBUTES,  # EAP_ATTRIBUTES*
    hTokenImpersonateUser: pointer,  # HANDLE
    dwSizeofConnectionData: uint32,  # DWORD
    pConnectionData: ptr uint8,  # BYTE*
    dwSizeofUserData: uint32,  # DWORD
    pUserData: ptr uint8,  # BYTE*
    dwMaxSendPacketSize: uint32,  # DWORD
    pConnectionId: ptr GUID,  # GUID* optional
    `func`: pointer,  # NotificationHandler optional
    pContextData: pointer,  # void* optional
    pSessionId: ptr uint32,  # DWORD* out
    ppEapError: ptr EAP_ERROR  # EAP_ERROR** out
): uint32 {.importc: "EapHostPeerBeginSession", stdcall, dynlib: "eappprxy.dll".}
pragma(lib, "eappprxy");
extern(Windows)
uint EapHostPeerBeginSession(
    uint dwFlags,   // DWORD
    EAP_METHOD_TYPE eapType,   // EAP_METHOD_TYPE
    EAP_ATTRIBUTES* pAttributeArray,   // EAP_ATTRIBUTES*
    void* hTokenImpersonateUser,   // HANDLE
    uint dwSizeofConnectionData,   // DWORD
    ubyte* pConnectionData,   // BYTE*
    uint dwSizeofUserData,   // DWORD
    ubyte* pUserData,   // BYTE*
    uint dwMaxSendPacketSize,   // DWORD
    GUID* pConnectionId,   // GUID* optional
    void* func,   // NotificationHandler optional
    void* pContextData,   // void* optional
    uint* pSessionId,   // DWORD* out
    EAP_ERROR** ppEapError   // EAP_ERROR** out
);
ccall((:EapHostPeerBeginSession, "eappprxy.dll"), stdcall, UInt32,
      (UInt32, EAP_METHOD_TYPE, Ptr{EAP_ATTRIBUTES}, Ptr{Cvoid}, UInt32, Ptr{UInt8}, UInt32, Ptr{UInt8}, UInt32, Ptr{GUID}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{UInt32}, Ptr{EAP_ERROR}),
      dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
# dwFlags : DWORD -> UInt32
# eapType : EAP_METHOD_TYPE -> EAP_METHOD_TYPE
# pAttributeArray : EAP_ATTRIBUTES* -> Ptr{EAP_ATTRIBUTES}
# hTokenImpersonateUser : HANDLE -> Ptr{Cvoid}
# dwSizeofConnectionData : DWORD -> UInt32
# pConnectionData : BYTE* -> Ptr{UInt8}
# dwSizeofUserData : DWORD -> UInt32
# pUserData : BYTE* -> Ptr{UInt8}
# dwMaxSendPacketSize : DWORD -> UInt32
# pConnectionId : GUID* optional -> Ptr{GUID}
# func : NotificationHandler optional -> Ptr{Cvoid}
# pContextData : void* optional -> Ptr{Cvoid}
# pSessionId : DWORD* out -> Ptr{UInt32}
# ppEapError : EAP_ERROR** out -> Ptr{EAP_ERROR}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
uint32_t EapHostPeerBeginSession(
    uint32_t dwFlags,
    EAP_METHOD_TYPE eapType,
    void* pAttributeArray,
    void* hTokenImpersonateUser,
    uint32_t dwSizeofConnectionData,
    uint8_t* pConnectionData,
    uint32_t dwSizeofUserData,
    uint8_t* pUserData,
    uint32_t dwMaxSendPacketSize,
    void* pConnectionId,
    void* func,
    void* pContextData,
    uint32_t* pSessionId,
    void* ppEapError);
]]
local eappprxy = ffi.load("eappprxy")
-- eappprxy.EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
-- dwFlags : DWORD
-- eapType : EAP_METHOD_TYPE
-- pAttributeArray : EAP_ATTRIBUTES*
-- hTokenImpersonateUser : HANDLE
-- dwSizeofConnectionData : DWORD
-- pConnectionData : BYTE*
-- dwSizeofUserData : DWORD
-- pUserData : BYTE*
-- dwMaxSendPacketSize : DWORD
-- pConnectionId : GUID* optional
-- func : NotificationHandler optional
-- pContextData : void* optional
-- pSessionId : DWORD* out
-- ppEapError : EAP_ERROR** out
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('eappprxy.dll');
const EapHostPeerBeginSession = lib.func('__stdcall', 'EapHostPeerBeginSession', 'uint32_t', ['uint32_t', 'EAP_METHOD_TYPE', 'void *', 'void *', 'uint32_t', 'uint8_t *', 'uint32_t', 'uint8_t *', 'uint32_t', 'void *', 'void *', 'void *', 'uint32_t *', 'void *']);
// EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
// dwFlags : DWORD -> 'uint32_t'
// eapType : EAP_METHOD_TYPE -> 'EAP_METHOD_TYPE'
// pAttributeArray : EAP_ATTRIBUTES* -> 'void *'
// hTokenImpersonateUser : HANDLE -> 'void *'
// dwSizeofConnectionData : DWORD -> 'uint32_t'
// pConnectionData : BYTE* -> 'uint8_t *'
// dwSizeofUserData : DWORD -> 'uint32_t'
// pUserData : BYTE* -> 'uint8_t *'
// dwMaxSendPacketSize : DWORD -> 'uint32_t'
// pConnectionId : GUID* optional -> 'void *'
// func : NotificationHandler optional -> 'void *'
// pContextData : void* optional -> 'void *'
// pSessionId : DWORD* out -> 'uint32_t *'
// ppEapError : EAP_ERROR** out -> 'void *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
// コールバック(関数ポインタ)は koffi.proto/koffi.register で型を定義して渡す(素の void* では JS 関数を渡せない)。
const lib = Deno.dlopen("eappprxy.dll", {
  EapHostPeerBeginSession: { parameters: ["u32", "buffer", "pointer", "pointer", "u32", "pointer", "u32", "pointer", "u32", "pointer", "pointer", "pointer", "pointer", "pointer"], result: "u32" },
});
// lib.symbols.EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError)
// dwFlags : DWORD -> "u32"
// eapType : EAP_METHOD_TYPE -> "buffer"
// pAttributeArray : EAP_ATTRIBUTES* -> "pointer"
// hTokenImpersonateUser : HANDLE -> "pointer"
// dwSizeofConnectionData : DWORD -> "u32"
// pConnectionData : BYTE* -> "pointer"
// dwSizeofUserData : DWORD -> "u32"
// pUserData : BYTE* -> "pointer"
// dwMaxSendPacketSize : DWORD -> "u32"
// pConnectionId : GUID* optional -> "pointer"
// func : NotificationHandler optional -> "pointer"
// pContextData : void* optional -> "pointer"
// pSessionId : DWORD* out -> "pointer"
// ppEapError : EAP_ERROR** out -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
uint32_t EapHostPeerBeginSession(
    uint32_t dwFlags,
    EAP_METHOD_TYPE eapType,
    void* pAttributeArray,
    void* hTokenImpersonateUser,
    uint32_t dwSizeofConnectionData,
    uint8_t* pConnectionData,
    uint32_t dwSizeofUserData,
    uint8_t* pUserData,
    uint32_t dwMaxSendPacketSize,
    void* pConnectionId,
    void* func,
    void* pContextData,
    uint32_t* pSessionId,
    void* ppEapError);
C, "eappprxy.dll");
// $ffi->EapHostPeerBeginSession(dwFlags, eapType, pAttributeArray, hTokenImpersonateUser, dwSizeofConnectionData, pConnectionData, dwSizeofUserData, pUserData, dwMaxSendPacketSize, pConnectionId, func, pContextData, pSessionId, ppEapError);
// dwFlags : DWORD
// eapType : EAP_METHOD_TYPE
// pAttributeArray : EAP_ATTRIBUTES*
// hTokenImpersonateUser : HANDLE
// dwSizeofConnectionData : DWORD
// pConnectionData : BYTE*
// dwSizeofUserData : DWORD
// pUserData : BYTE*
// dwMaxSendPacketSize : DWORD
// pConnectionId : GUID* optional
// func : NotificationHandler optional
// pContextData : void* optional
// pSessionId : DWORD* out
// ppEapError : EAP_ERROR** out
// 構造体/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 Eappprxy extends StdCallLibrary {
    Eappprxy INSTANCE = Native.load("eappprxy", Eappprxy.class);
    int EapHostPeerBeginSession(
        int dwFlags,   // DWORD
        EAP_METHOD_TYPE /* extends Structure (by value) */ eapType,   // EAP_METHOD_TYPE
        Pointer pAttributeArray,   // EAP_ATTRIBUTES*
        Pointer hTokenImpersonateUser,   // HANDLE
        int dwSizeofConnectionData,   // DWORD
        byte[] pConnectionData,   // BYTE*
        int dwSizeofUserData,   // DWORD
        byte[] pUserData,   // BYTE*
        int dwMaxSendPacketSize,   // DWORD
        Pointer pConnectionId,   // GUID* optional
        Callback func,   // NotificationHandler optional
        Pointer pContextData,   // void* optional
        IntByReference pSessionId,   // DWORD* out
        Pointer ppEapError   // EAP_ERROR** out
    );
}
@[Link("eappprxy")]
lib Libeappprxy
  fun EapHostPeerBeginSession = EapHostPeerBeginSession(
    dwFlags : UInt32,   # DWORD
    eapType : EAP_METHOD_TYPE,   # EAP_METHOD_TYPE
    pAttributeArray : EAP_ATTRIBUTES*,   # EAP_ATTRIBUTES*
    hTokenImpersonateUser : Void*,   # HANDLE
    dwSizeofConnectionData : UInt32,   # DWORD
    pConnectionData : UInt8*,   # BYTE*
    dwSizeofUserData : UInt32,   # DWORD
    pUserData : UInt8*,   # BYTE*
    dwMaxSendPacketSize : UInt32,   # DWORD
    pConnectionId : GUID*,   # GUID* optional
    func : Void*,   # NotificationHandler optional
    pContextData : Void*,   # void* optional
    pSessionId : UInt32*,   # DWORD* out
    ppEapError : EAP_ERROR**   # EAP_ERROR** out
  ) : UInt32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef EapHostPeerBeginSessionNative = Uint32 Function(Uint32, EAP_METHOD_TYPE, Pointer<Void>, Pointer<Void>, Uint32, Pointer<Uint8>, Uint32, Pointer<Uint8>, Uint32, Pointer<Void>, Pointer<Void>, Pointer<Void>, Pointer<Uint32>, Pointer<Void>);
typedef EapHostPeerBeginSessionDart = int Function(int, int, Pointer<Void>, Pointer<Void>, int, Pointer<Uint8>, int, Pointer<Uint8>, int, Pointer<Void>, Pointer<Void>, Pointer<Void>, Pointer<Uint32>, Pointer<Void>);
final EapHostPeerBeginSession = DynamicLibrary.open('eappprxy.dll')
    .lookupFunction<EapHostPeerBeginSessionNative, EapHostPeerBeginSessionDart>('EapHostPeerBeginSession');
// dwFlags : DWORD -> Uint32
// eapType : EAP_METHOD_TYPE -> EAP_METHOD_TYPE
// pAttributeArray : EAP_ATTRIBUTES* -> Pointer<Void>
// hTokenImpersonateUser : HANDLE -> Pointer<Void>
// dwSizeofConnectionData : DWORD -> Uint32
// pConnectionData : BYTE* -> Pointer<Uint8>
// dwSizeofUserData : DWORD -> Uint32
// pUserData : BYTE* -> Pointer<Uint8>
// dwMaxSendPacketSize : DWORD -> Uint32
// pConnectionId : GUID* optional -> Pointer<Void>
// func : NotificationHandler optional -> Pointer<Void>
// pContextData : void* optional -> Pointer<Void>
// pSessionId : DWORD* out -> Pointer<Uint32>
// ppEapError : EAP_ERROR** out -> Pointer<Void>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function EapHostPeerBeginSession(
  dwFlags: DWORD;   // DWORD
  eapType: EAP_METHOD_TYPE;   // EAP_METHOD_TYPE
  pAttributeArray: Pointer;   // EAP_ATTRIBUTES*
  hTokenImpersonateUser: THandle;   // HANDLE
  dwSizeofConnectionData: DWORD;   // DWORD
  pConnectionData: Pointer;   // BYTE*
  dwSizeofUserData: DWORD;   // DWORD
  pUserData: Pointer;   // BYTE*
  dwMaxSendPacketSize: DWORD;   // DWORD
  pConnectionId: PGUID;   // GUID* optional
  func: Pointer;   // NotificationHandler optional
  pContextData: Pointer;   // void* optional
  pSessionId: Pointer;   // DWORD* out
  ppEapError: Pointer   // EAP_ERROR** out
): DWORD; stdcall;
  external 'eappprxy.dll' name 'EapHostPeerBeginSession';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "EapHostPeerBeginSession"
  c_EapHostPeerBeginSession :: Word32 -> EAP_METHOD_TYPE -> Ptr () -> Ptr () -> Word32 -> Ptr Word8 -> Word32 -> Ptr Word8 -> Word32 -> Ptr () -> Ptr () -> Ptr () -> Ptr Word32 -> Ptr () -> IO Word32
-- dwFlags : DWORD -> Word32
-- eapType : EAP_METHOD_TYPE -> EAP_METHOD_TYPE
-- pAttributeArray : EAP_ATTRIBUTES* -> Ptr ()
-- hTokenImpersonateUser : HANDLE -> Ptr ()
-- dwSizeofConnectionData : DWORD -> Word32
-- pConnectionData : BYTE* -> Ptr Word8
-- dwSizeofUserData : DWORD -> Word32
-- pUserData : BYTE* -> Ptr Word8
-- dwMaxSendPacketSize : DWORD -> Word32
-- pConnectionId : GUID* optional -> Ptr ()
-- func : NotificationHandler optional -> Ptr ()
-- pContextData : void* optional -> Ptr ()
-- pSessionId : DWORD* out -> Ptr Word32
-- ppEapError : EAP_ERROR** out -> Ptr ()
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
-- ※値渡し構造体は GHC FFI で直接渡せません。Ptr で渡すラッパ(C側)経由にしてください。
open Ctypes
open Foreign

let eaphostpeerbeginsession =
  foreign "EapHostPeerBeginSession"
    (uint32_t @-> EAP_METHOD_TYPE @-> (ptr void) @-> (ptr void) @-> uint32_t @-> (ptr uint8_t) @-> uint32_t @-> (ptr uint8_t) @-> uint32_t @-> (ptr void) @-> (ptr void) @-> (ptr void) @-> (ptr uint32_t) @-> (ptr void) @-> returning uint32_t)
(* dwFlags : DWORD -> uint32_t *)
(* eapType : EAP_METHOD_TYPE -> EAP_METHOD_TYPE *)
(* pAttributeArray : EAP_ATTRIBUTES* -> (ptr void) *)
(* hTokenImpersonateUser : HANDLE -> (ptr void) *)
(* dwSizeofConnectionData : DWORD -> uint32_t *)
(* pConnectionData : BYTE* -> (ptr uint8_t) *)
(* dwSizeofUserData : DWORD -> uint32_t *)
(* pUserData : BYTE* -> (ptr uint8_t) *)
(* dwMaxSendPacketSize : DWORD -> uint32_t *)
(* pConnectionId : GUID* optional -> (ptr void) *)
(* func : NotificationHandler optional -> (ptr void) *)
(* pContextData : void* optional -> (ptr void) *)
(* pSessionId : DWORD* out -> (ptr uint32_t) *)
(* ppEapError : EAP_ERROR** out -> (ptr void) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library eappprxy (t "eappprxy.dll"))
(cffi:use-foreign-library eappprxy)

(cffi:defcfun ("EapHostPeerBeginSession" eap-host-peer-begin-session :convention :stdcall) :uint32
  (dw-flags :uint32)   ; DWORD
  (eap-type (:struct eap-method-type))   ; EAP_METHOD_TYPE
  (p-attribute-array :pointer)   ; EAP_ATTRIBUTES*
  (h-token-impersonate-user :pointer)   ; HANDLE
  (dw-sizeof-connection-data :uint32)   ; DWORD
  (p-connection-data :pointer)   ; BYTE*
  (dw-sizeof-user-data :uint32)   ; DWORD
  (p-user-data :pointer)   ; BYTE*
  (dw-max-send-packet-size :uint32)   ; DWORD
  (p-connection-id :pointer)   ; GUID* optional
  (func :pointer)   ; NotificationHandler optional
  (p-context-data :pointer)   ; void* optional
  (p-session-id :pointer)   ; DWORD* out
  (pp-eap-error :pointer))   ; EAP_ERROR** out
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $EapHostPeerBeginSession = Win32::API::More->new('eappprxy',
    'DWORD EapHostPeerBeginSession(DWORD dwFlags, LPVOID eapType, LPVOID pAttributeArray, HANDLE hTokenImpersonateUser, DWORD dwSizeofConnectionData, LPVOID pConnectionData, DWORD dwSizeofUserData, LPVOID pUserData, DWORD dwMaxSendPacketSize, LPVOID pConnectionId, LPVOID func, LPVOID pContextData, LPVOID pSessionId, LPVOID ppEapError)');
# my $ret = $EapHostPeerBeginSession->Call($dwFlags, $eapType, $pAttributeArray, $hTokenImpersonateUser, $dwSizeofConnectionData, $pConnectionData, $dwSizeofUserData, $pUserData, $dwMaxSendPacketSize, $pConnectionId, $func, $pContextData, $pSessionId, $ppEapError);
# dwFlags : DWORD -> DWORD
# eapType : EAP_METHOD_TYPE -> LPVOID
# pAttributeArray : EAP_ATTRIBUTES* -> LPVOID
# hTokenImpersonateUser : HANDLE -> HANDLE
# dwSizeofConnectionData : DWORD -> DWORD
# pConnectionData : BYTE* -> LPVOID
# dwSizeofUserData : DWORD -> DWORD
# pUserData : BYTE* -> LPVOID
# dwMaxSendPacketSize : DWORD -> DWORD
# pConnectionId : GUID* optional -> LPVOID
# func : NotificationHandler optional -> LPVOID
# pContextData : void* optional -> LPVOID
# pSessionId : DWORD* out -> LPVOID
# ppEapError : EAP_ERROR** out -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。
# コールバック(関数ポインタ)は Perl sub を直接渡せません。Win32::API::Callback を使用してください。

関連項目

公式の関連項目
使用する型