Win32 API 日本語リファレンス
ホーム › NetworkManagement.IpHelper › DisableMediaSense

DisableMediaSense

関数
メディアセンス(ケーブル接続検知)機能を無効にする。
DLLIPHLPAPI.dll呼出規約winapi対応OSWindows XP 以降
📘 Microsoft Learn (日本語) · English

シグネチャ

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

DWORD DisableMediaSense(
    HANDLE* pHandle,
    OVERLAPPED* pOverLapped
);

パラメーター

名前型方向説明
pHandleHANDLE*out

ハンドルを格納するために使用される変数へのポインター。pOverlapped パラメーターが NULL でない場合、この変数は IP ドライバーを呼び出してメディアセンス機能を無効化するために必要なハンドルを内部的に格納するために使用されます。

アプリケーションはこの変数が指す値を使用しないでください。このハンドルは内部使用のためのものであり、クローズしないでください。

pOverLappedOVERLAPPED*inOVERLAPPED 構造体へのポインター。hEvent メンバーを除き、この構造体のすべてのメンバーはゼロに設定する必要があります。hEvent メンバーには、有効なイベントオブジェクトへのハンドルが必要です。このイベントオブジェクトの作成には CreateEvent 関数を使用してください。

戻り値の型: DWORD

公式ドキュメント

DisableMediaSense 関数は、ローカルコンピューター上の TCP/IP スタックのメディアセンス機能を無効化します。

戻り値

関数が成功した場合、戻り値は NO_ERROR です。

関数が失敗した場合、戻り値は次のいずれかのエラーコードになります。

戻り値コード 説明
ERROR_INVALID_PARAMETER
 無効なパラメーターが関数に渡されました。このエラーは、pOverlapped パラメーターが不正なポインターである場合に返されます。
ERROR_IO_PENDING
 操作が進行中です。この値は、DisableMediaSense の非同期呼び出しが成功した場合に返されます。
ERROR_OPEN_FAILED
 pHandle パラメーターが指すハンドルが無効でした。
ERROR_NOT_SUPPORTED
 要求はサポートされていません。
その他
 返されたエラーのメッセージ文字列を取得するには FormatMessage を使用してください。

解説(Remarks)

pHandle または pOverlapped パラメーターが NULL の場合、DisableMediaSense 関数は同期的に実行されます。

pHandle と pOverlapped パラメーターの両方が NULL でない場合、DisableMediaSense 関数は pOverlapped パラメーターが指す OVERLAPPED 構造体を使用して非同期的に実行されます。

DisableMediaSense 関数は、後で RestoreMediaSense 関数が呼び出されてメディアセンス機能が復元されるまで完了しません。それまでの間、I/O 要求パケット (IRP) はキューに入れられたままになります。あるいは、DisableMediaSense を呼び出したプロセスが終了すると、IRP はキャンセルされ、メディアセンス機能を再び復元するキャンセルルーチンが呼び出されます。

DisableMediaSense を同期的に呼び出すには、アプリケーションはこの呼び出し用に別のスレッドを作成する必要があります。そうしないと、IRP の完了を待ち続け、関数がブロックされます。

DisableMediaSense を非同期的に呼び出すには、アプリケーションは OVERLAPPED 構造体を割り当てる必要があります。hEvent メンバーを除き、この構造体のすべてのメンバーはゼロに設定する必要があります。hEvent メンバーには、有効なイベントオブジェクトへのハンドルが必要です。このイベントの作成には CreateEvent 関数を使用してください。非同期的に呼び出された場合、DisableMediaSense は常に ERROR_IO_PENDING を返します。IRP は、後で RestoreMediaSense が呼び出された場合にのみ完了します。 イベントオブジェクトへのハンドルが不要になったら、CloseHandle 関数を使用してハンドルをクローズしてください。プロセスが終了すると、システムはハンドルを自動的にクローズします。イベントオブジェクトは、最後のハンドルがクローズされたときに破棄されます。

Windows Server 2003 および Windows XP では、TCP/IP スタックは、基盤となるネットワークインターフェイスからのメディアセンス切断イベントに応答して、インターフェイス上のすべての IP アドレスを削除するというポリシーを実装しています。ローカルコンピューターが接続されているネットワークスイッチまたはハブの電源が切れたり、ネットワークケーブルが切断されたりすると、ネットワークインターフェイスは切断イベントを通知します。ネットワークインターフェイスに関連付けられた IP 構成情報は失われます。その結果、TCP/IP スタックは切断されたインターフェイスを隠すポリシーを実装しており、これらのインターフェイスとそれに関連付けられた IP アドレスは IP helper を通じて取得される構成情報に表示されなくなります。このポリシーにより、一部のアプリケーションは、ネットワークインターフェイスがシステムから削除されたのではなく単に切断されただけであることを容易に検出できなくなります。

この動作は、ローカルクライアントコンピューターが IP 構成情報のために DHCP サーバーへの DHCP 要求を使用している場合、通常は影響を与えません。しかし、サーバーコンピューター、特にクラスターの一部として使用されるコンピューターには深刻な影響を与える可能性があります。これらのケースでは、DisableMediaSense 関数を使用してメディアセンス機能を一時的に無効化できます。その後の任意の時点で、RestoreMediaSense 関数を呼び出してメディアセンス機能を復元します。

次のレジストリ設定は、DisableMediaSense および RestoreMediaSense 関数に関連しています。

System\CurrentControlSet\Services\Tcpip\Parameters\DisableDHCPMediaSense

Windows には内部フラグがあり、マシンの初回起動時にこのレジストリキーが存在する場合に設定されます。同じ内部フラグは、DisableMediaSense および RestoreMediaSense を呼び出すことによっても設定およびリセットされます。ただし、レジストリ設定の場合は、変更を反映させるためにマシンを再起動する必要があります。

Windows Vista 以降の TCP/IP スタックは、切断イベントが発生したときに切断されたインターフェイスを隠さないように変更されました。そのため、Windows Vista 以降では、DisableMediaSense および RestoreMediaSense 関数は何も行わず、常に NO_ERROR を返します。

使用例

次の例は、DisableMediaSense および RestoreMediaSense 関数を非同期的に呼び出す方法を示しています。このサンプルは、DisableMediaSense および RestoreMediaSense 関数が有用な動作を行う Windows Server 2003 および Windows XP でのみ役立ちます。

このサンプルは、まず DisableMediaSense 関数を呼び出し、ユーザーがネットワークケーブルを切断できるよう 60 秒間スリープし、IP アドレステーブルを取得してテーブル内の IP アドレスエントリの一部のメンバーを出力し、RestoreMediaSense 関数を呼び出し、再び IP アドレステーブルを取得して、テーブル内の IP アドレスエントリの一部のメンバーを出力します。メディアセンス機能を無効化した影響は、IP アドレステーブルエントリの違いに見て取ることができます。

DisableMediaSense および RestoreMediaSense 関数を同期的に呼び出す方法を示す例については、RestoreMediaSense 関数のリファレンスを参照してください。

#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")

#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

/* Note: could also use malloc() and free() */

int __cdecl main()
{

    int i;

    /* Variables used by GetIpAddrTable */
    PMIB_IPADDRTABLE pIPAddrTable;
    DWORD dwSize = 0;
    DWORD dwRetVal = 0;
    IN_ADDR IPAddr;

    /* Variables used to return error message */
    LPVOID lpMsgBuf;

    // Variables to call DisableMediaSense
    //  and RestoreMediaSense asynchronously
    HANDLE IpDriverHandle = INVALID_HANDLE_VALUE;
    OVERLAPPED Overlapped;
    HANDLE DriverHandle;
    DWORD dwEnableCount = 0;

    memset(&Overlapped, 0, sizeof (Overlapped));
    Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    dwRetVal = DisableMediaSense(&DriverHandle, &Overlapped);
    if (dwRetVal != ERROR_IO_PENDING) {
        printf("DisableMediaSense failed with error %d\n", dwRetVal);
        exit(1);
    } else {
        printf(" === DisableMediaSense called ===\n\n");
        // Sleep for 60 seconds so we can disconnect a cable
        Sleep(60000);
    }

    // Before calling AddIPAddress we use GetIpAddrTable to get
    // an adapter to which we can add the IP.
    pIPAddrTable = (MIB_IPADDRTABLE *) MALLOC(sizeof (MIB_IPADDRTABLE));

    if (pIPAddrTable) {
        // Make an initial call to GetIpAddrTable to get the
        // necessary size into the dwSize variable
        if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) ==
            ERROR_INSUFFICIENT_BUFFER) {
            FREE(pIPAddrTable);
            pIPAddrTable = (MIB_IPADDRTABLE *) MALLOC(dwSize);

        }
        if (pIPAddrTable == NULL) {
            printf("Memory allocation failed for GetIpAddrTable\n");
            exit(1);
        }
    }
    // Make a second call to GetIpAddrTable to get the
    // actual data we want
    if ((dwRetVal = GetIpAddrTable(pIPAddrTable, &dwSize, 0)) != NO_ERROR) {
        printf("GetIpAddrTable failed with error %d\n", dwRetVal);
        if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 
                    NULL, 
                    dwRetVal, 
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                    (LPTSTR) & lpMsgBuf, 0, NULL)) {
            printf("\tError: %s", lpMsgBuf);
            LocalFree(lpMsgBuf);
        }
        exit(1);
    }

    printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
    for (i = 0; i < (int) pIPAddrTable->dwNumEntries; i++) {
        printf("\n\tInterface Index[%d]:\t%ld\n", i,
               pIPAddrTable->table[i].dwIndex);
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
        printf("\tIP Address[%d]:     \t%s\n", i, inet_ntoa(IPAddr));
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
        printf("\tSubnet Mask[%d]:    \t%s\n", i, inet_ntoa(IPAddr));
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
        printf("\tBroadCast[%d]:      \t%s (%ld%)\n", i, inet_ntoa(IPAddr),
               pIPAddrTable->table[i].dwBCastAddr);
        printf("\tReassembly size[%d]:\t%ld\n", i,
               pIPAddrTable->table[i].dwReasmSize);
        printf("\tType and State[%d]:", i);
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_PRIMARY)
            printf("\tPrimary IP Address");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DYNAMIC)
            printf("\tDynamic IP Address");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DISCONNECTED)
            printf("\tAddress is on disconnected interface");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DELETED)
            printf("\tAddress is being deleted");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_TRANSIENT)
            printf("\tTransient address");
        printf("\n");
    }

    // Call RestoreMediaSense asynchronously to enable mediasense
    dwRetVal = RestoreMediaSense(&Overlapped, &dwEnableCount);
    if (dwRetVal && dwRetVal != ERROR_IO_PENDING) {
        printf("RestoreMediaSense failed with error %d\n", dwRetVal);
        exit(1);
    } else {
        printf(" === RestoreMediaSense called ===\n");
        printf("  EnableCount returned was %ld\n\n", dwEnableCount);
    }

    if (pIPAddrTable) {
        // Make an initial call to GetIpAddrTable to get the
        // necessary size into the dwSize variable
        if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) ==
            ERROR_INSUFFICIENT_BUFFER) {
            FREE(pIPAddrTable);
            pIPAddrTable = (MIB_IPADDRTABLE *) MALLOC(dwSize);

        }
        if (pIPAddrTable == NULL) {
            printf("Memory allocation failed for GetIpAddrTable\n");
            exit(1);
        }
    }
    // Make a second call to GetIpAddrTable to get the
    // actual data we want
    if ((dwRetVal = GetIpAddrTable(pIPAddrTable, &dwSize, 0)) != NO_ERROR) {
        printf("GetIpAddrTable failed with error %d\n", dwRetVal);
        if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 
                    NULL, dwRetVal, 
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  // Default language
                    (LPTSTR) & lpMsgBuf, 0, NULL)) {
            printf("\tError: %s", lpMsgBuf);
            LocalFree(lpMsgBuf);
        }
        exit(1);
    }

    printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
    for (i = 0; i < (int) pIPAddrTable->dwNumEntries; i++) {
        printf("\n\tInterface Index[%d]:\t%ld\n", i,
               pIPAddrTable->table[i].dwIndex);
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
        printf("\tIP Address[%d]:     \t%s\n", i, inet_ntoa(IPAddr));
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
        printf("\tSubnet Mask[%d]:    \t%s\n", i, inet_ntoa(IPAddr));
        IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
        printf("\tBroadCast[%d]:      \t%s (%ld%)\n", i, inet_ntoa(IPAddr),
               pIPAddrTable->table[i].dwBCastAddr);
        printf("\tReassembly size[%d]:\t%ld\n", i,
               pIPAddrTable->table[i].dwReasmSize);
        printf("\tType and State[%d]:", i);
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_PRIMARY)
            printf("\tPrimary IP Address");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DYNAMIC)
            printf("\tDynamic IP Address");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DISCONNECTED)
            printf("\tAddress is on disconnected interface");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_DELETED)
            printf("\tAddress is being deleted");
        if (pIPAddrTable->table[i].wType & MIB_IPADDR_TRANSIENT)
            printf("\tTransient address");
        printf("\n");
    }

    if (pIPAddrTable) {
        FREE(pIPAddrTable);
        pIPAddrTable = NULL;
    }

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

各言語での呼び出し定義

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

DWORD DisableMediaSense(
    HANDLE* pHandle,
    OVERLAPPED* pOverLapped
);
[DllImport("IPHLPAPI.dll", ExactSpelling = true)]
static extern uint DisableMediaSense(
    IntPtr pHandle,   // HANDLE* out
    IntPtr pOverLapped   // OVERLAPPED*
);
<DllImport("IPHLPAPI.dll", ExactSpelling:=True)>
Public Shared Function DisableMediaSense(
    pHandle As IntPtr,   ' HANDLE* out
    pOverLapped As IntPtr   ' OVERLAPPED*
) As UInteger
End Function
' pHandle : HANDLE* out
' pOverLapped : OVERLAPPED*
Declare PtrSafe Function DisableMediaSense Lib "iphlpapi" ( _
    ByVal pHandle As LongPtr, _
    ByVal pOverLapped As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

DisableMediaSense = ctypes.windll.iphlpapi.DisableMediaSense
DisableMediaSense.restype = wintypes.DWORD
DisableMediaSense.argtypes = [
    ctypes.c_void_p,  # pHandle : HANDLE* out
    ctypes.c_void_p,  # pOverLapped : OVERLAPPED*
]
require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('IPHLPAPI.dll')
DisableMediaSense = Fiddle::Function.new(
  lib['DisableMediaSense'],
  [
    Fiddle::TYPE_VOIDP,  # pHandle : HANDLE* out
    Fiddle::TYPE_VOIDP,  # pOverLapped : OVERLAPPED*
  ],
  -Fiddle::TYPE_INT)
#[link(name = "iphlpapi")]
extern "system" {
    fn DisableMediaSense(
        pHandle: *mut *mut core::ffi::c_void,  // HANDLE* out
        pOverLapped: *mut OVERLAPPED  // OVERLAPPED*
    ) -> u32;
}
// crates: windows-sys provides ready-made bindings for this API.
$sig = @"
[DllImport("IPHLPAPI.dll")]
public static extern uint DisableMediaSense(IntPtr pHandle, IntPtr pOverLapped);
"@
$api = Add-Type -MemberDefinition $sig -Name 'IPHLPAPI_DisableMediaSense' -Namespace Win32 -PassThru
# $api::DisableMediaSense(pHandle, pOverLapped)
#uselib "IPHLPAPI.dll"
#func global DisableMediaSense "DisableMediaSense" sptr, sptr
; DisableMediaSense pHandle, varptr(pOverLapped)   ; 戻り値は stat
; pHandle : HANDLE* out -> "sptr"
; pOverLapped : OVERLAPPED* -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。
出力引数: 
#uselib "IPHLPAPI.dll"
#cfunc global DisableMediaSense "DisableMediaSense" sptr, var
; res = DisableMediaSense(pHandle, pOverLapped)
; pHandle : HANDLE* out -> "sptr"
; pOverLapped : OVERLAPPED* -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
出力引数: 
; DWORD DisableMediaSense(HANDLE* pHandle, OVERLAPPED* pOverLapped)
#uselib "IPHLPAPI.dll"
#cfunc global DisableMediaSense "DisableMediaSense" intptr, var
; res = DisableMediaSense(pHandle, pOverLapped)
; pHandle : HANDLE* out -> "intptr"
; pOverLapped : OVERLAPPED* -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	iphlpapi = windows.NewLazySystemDLL("IPHLPAPI.dll")
	procDisableMediaSense = iphlpapi.NewProc("DisableMediaSense")
)

// pHandle (HANDLE* out), pOverLapped (OVERLAPPED*)
r1, _, err := procDisableMediaSense.Call(
	uintptr(pHandle),
	uintptr(pOverLapped),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // DWORD
function DisableMediaSense(
  pHandle: Pointer;   // HANDLE* out
  pOverLapped: Pointer   // OVERLAPPED*
): DWORD; stdcall;
  external 'IPHLPAPI.dll' name 'DisableMediaSense';
result := DllCall("IPHLPAPI\DisableMediaSense"
    , "Ptr", pHandle   ; HANDLE* out
    , "Ptr", pOverLapped   ; OVERLAPPED*
    , "UInt")   ; return: DWORD
●DisableMediaSense(pHandle, pOverLapped) = DLL("IPHLPAPI.dll", "dword DisableMediaSense(void*, void*)")
# 呼び出し: DisableMediaSense(pHandle, pOverLapped)
# pHandle : HANDLE* out -> "void*"
# pOverLapped : OVERLAPPED* -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "iphlpapi" fn DisableMediaSense(
    pHandle: ?*anyopaque, // HANDLE* out
    pOverLapped: [*c]OVERLAPPED // OVERLAPPED*
) callconv(std.os.windows.WINAPI) u32;
proc DisableMediaSense(
    pHandle: pointer,  # HANDLE* out
    pOverLapped: ptr OVERLAPPED  # OVERLAPPED*
): uint32 {.importc: "DisableMediaSense", stdcall, dynlib: "IPHLPAPI.dll".}
pragma(lib, "iphlpapi");
extern(Windows)
uint DisableMediaSense(
    void* pHandle,   // HANDLE* out
    OVERLAPPED* pOverLapped   // OVERLAPPED*
);
ccall((:DisableMediaSense, "IPHLPAPI.dll"), stdcall, UInt32,
      (Ptr{Cvoid}, Ptr{OVERLAPPED}),
      pHandle, pOverLapped)
# pHandle : HANDLE* out -> Ptr{Cvoid}
# pOverLapped : OVERLAPPED* -> Ptr{OVERLAPPED}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
uint32_t DisableMediaSense(
    void* pHandle,
    void* pOverLapped);
]]
local iphlpapi = ffi.load("iphlpapi")
-- iphlpapi.DisableMediaSense(pHandle, pOverLapped)
-- pHandle : HANDLE* out
-- pOverLapped : OVERLAPPED*
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('IPHLPAPI.dll');
const DisableMediaSense = lib.func('__stdcall', 'DisableMediaSense', 'uint32_t', ['void *', 'void *']);
// DisableMediaSense(pHandle, pOverLapped)
// pHandle : HANDLE* out -> 'void *'
// pOverLapped : OVERLAPPED* -> 'void *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
const lib = Deno.dlopen("IPHLPAPI.dll", {
  DisableMediaSense: { parameters: ["pointer", "pointer"], result: "u32" },
});
// lib.symbols.DisableMediaSense(pHandle, pOverLapped)
// pHandle : HANDLE* out -> "pointer"
// pOverLapped : OVERLAPPED* -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
uint32_t DisableMediaSense(
    void* pHandle,
    void* pOverLapped);
C, "IPHLPAPI.dll");
// $ffi->DisableMediaSense(pHandle, pOverLapped);
// pHandle : HANDLE* out
// pOverLapped : OVERLAPPED*
// 構造体/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 Iphlpapi extends StdCallLibrary {
    Iphlpapi INSTANCE = Native.load("iphlpapi", Iphlpapi.class);
    int DisableMediaSense(
        Pointer pHandle,   // HANDLE* out
        Pointer pOverLapped   // OVERLAPPED*
    );
}
@[Link("iphlpapi")]
lib LibIPHLPAPI
  fun DisableMediaSense = DisableMediaSense(
    pHandle : Void*,   # HANDLE* out
    pOverLapped : OVERLAPPED*   # OVERLAPPED*
  ) : UInt32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef DisableMediaSenseNative = Uint32 Function(Pointer<Void>, Pointer<Void>);
typedef DisableMediaSenseDart = int Function(Pointer<Void>, Pointer<Void>);
final DisableMediaSense = DynamicLibrary.open('IPHLPAPI.dll')
    .lookupFunction<DisableMediaSenseNative, DisableMediaSenseDart>('DisableMediaSense');
// pHandle : HANDLE* out -> Pointer<Void>
// pOverLapped : OVERLAPPED* -> Pointer<Void>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function DisableMediaSense(
  pHandle: Pointer;   // HANDLE* out
  pOverLapped: Pointer   // OVERLAPPED*
): DWORD; stdcall;
  external 'IPHLPAPI.dll' name 'DisableMediaSense';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "DisableMediaSense"
  c_DisableMediaSense :: Ptr () -> Ptr () -> IO Word32
-- pHandle : HANDLE* out -> Ptr ()
-- pOverLapped : OVERLAPPED* -> Ptr ()
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
open Ctypes
open Foreign

let disablemediasense =
  foreign "DisableMediaSense"
    ((ptr void) @-> (ptr void) @-> returning uint32_t)
(* pHandle : HANDLE* out -> (ptr void) *)
(* pOverLapped : OVERLAPPED* -> (ptr void) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library iphlpapi (t "IPHLPAPI.dll"))
(cffi:use-foreign-library iphlpapi)

(cffi:defcfun ("DisableMediaSense" disable-media-sense :convention :stdcall) :uint32
  (p-handle :pointer)   ; HANDLE* out
  (p-over-lapped :pointer))   ; OVERLAPPED*
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $DisableMediaSense = Win32::API::More->new('IPHLPAPI',
    'DWORD DisableMediaSense(HANDLE pHandle, LPVOID pOverLapped)');
# my $ret = $DisableMediaSense->Call($pHandle, $pOverLapped);
# pHandle : HANDLE* out -> HANDLE
# pOverLapped : OVERLAPPED* -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。

関連項目

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