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

NetGroupEnum

関数
サーバー上のグローバルグループを列挙する。
DLLNETAPI32.dll呼出規約winapi対応OSWindows 2000 以降

シグネチャ

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

DWORD NetGroupEnum(
    LPCWSTR servername,   // optional
    DWORD level,
    BYTE** bufptr,
    DWORD prefmaxlen,
    DWORD* entriesread,
    DWORD* totalentries,
    UINT_PTR* resume_handle   // optional
);

パラメーター

名前方向説明
servernameLPCWSTRinoptional関数を実行するリモート サーバーの DNS 名または NetBIOS 名を指定する定数文字列へのポインターです。このパラメーターが NULL の場合は、ローカル コンピューターが使用されます。
levelDWORDin

データの情報レベルを指定します。このパラメーターには、次のいずれかの値を指定できます。

意味
0
グローバル グループ名を返します。bufptr パラメーターは GROUP_INFO_0 構造体の配列を指します。
1
グローバル グループ名とコメントを返します。bufptr パラメーターは GROUP_INFO_1 構造体の配列を指します。
2
グローバル グループに関する詳細情報を返します。bufptr パラメーターは GROUP_INFO_2 構造体の配列を指します。Windows XP 以降では、代わりに GROUP_INFO_3 を使用することをお勧めします。
3
グローバル グループに関する詳細情報を返します。bufptr パラメーターは GROUP_INFO_3 構造体の配列を指します。

Windows 2000: このレベルはサポートされていません。

bufptrBYTE**out

グローバル グループ情報構造体を受け取るバッファーへのポインターです。このデータの形式は level パラメーターの値によって異なります。

このバッファーのメモリはシステムによって割り当てられます。メモリを解放するには NetApiBufferFree 関数を呼び出す必要があります。関数が ERROR_MORE_DATA で失敗した場合でも、バッファーを解放する必要があることに注意してください。

prefmaxlenDWORDin返されるデータの推奨最大長をバイト単位で指定します。MAX_PREFERRED_LENGTH を指定すると、関数はデータを保持するために必要な量のメモリを割り当てます。このパラメーターに別の値を指定すると、関数が返すバイト数を制限できます。すべてのエントリを保持するにはバッファー サイズが不足している場合、関数は ERROR_MORE_DATA を返します。詳細については、 Network Management Function Buffers および Network Management Function Buffer Lengths を参照してください。
entriesreadDWORD*out実際に列挙された要素の数を受け取る値へのポインターです。
totalentriesDWORD*out現在の再開位置から列挙できたエントリの総数を受け取る値へのポインターです。エントリの総数はあくまで目安です。エントリの正確な数を判定する方法の詳細については、次の「解説」セクションを参照してください。
resume_handleUINT_PTR*inoutoptionalグローバル グループの列挙を続行するために使用される再開ハンドルを格納する変数へのポインターです。このハンドルは最初の呼び出しではゼロにし、以降の呼び出しでは変更しないでください。このパラメーターが NULL の場合、再開ハンドルは格納されません。

戻り値の型: DWORD

公式ドキュメント

NetGroupEnum 関数は、セキュリティ データベース(セキュリティ アカウント マネージャー (SAM) データベース、ドメイン コントローラーの場合は Active Directory)内の各グローバル グループに関する情報を取得します。

戻り値

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

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

戻り値 説明
ERROR_ACCESS_DENIED
ユーザーには、要求された情報へのアクセス権がありません。
NERR_InvalidComputer
コンピューター名が無効です。
ERROR_MORE_DATA
さらに多くのエントリが利用可能です。すべてのエントリを受け取るのに十分な大きさのバッファーを指定してください。

解説(Remarks)

Active Directory 向けにプログラミングを行う場合、ネットワーク管理グループ関数を呼び出すことで実現できるのと同じ機能を、特定の Active Directory Service Interface (ADSI) メソッドを呼び出すことで実現できる場合があります。詳細については、 IADsGroup を参照してください。

Active Directory を実行しているドメイン コントローラー上でこの関数を呼び出した場合、アクセスは セキュリティ保護可能なオブジェクト のアクセス制御リスト (ACL) に基づいて許可または拒否されます。既定の ACL では、すべての認証済みユーザーと「Pre-Windows 2000 互換アクセス」グループのメンバーが情報を表示できます。メンバー サーバーまたはワークステーション上でこの関数を呼び出した場合は、すべての認証済みユーザーが情報を表示できます。これらのプラットフォームでの匿名アクセスおよび匿名アクセスの制限に関する情報については、 Security Requirements for the Network Management Functions を参照してください。ACL、ACE、およびアクセス トークンの詳細については、 Access Control Model を参照してください。

この関数は、呼び出し元が Read アクセス権を持つ情報のみを返します。呼び出し元は、Domain オブジェクトに対する List Contents アクセス権、および System コンテナー内にある SAM Server オブジェクトに対する Enumerate Entire SAM Domain アクセス権を持っている必要があります。

グループの正確な総数を判定するには、ツリー全体を列挙する必要がありますが、これはコストの高い操作になる場合があります。ツリー全体を列挙するには、resume_handle パラメーターを使用して連続した呼び出しで列挙を続行し、entriesread パラメーターを使用してグループの総数を累積します。アプリケーションがドメイン コントローラーと通信している場合は、この種のデータをより効率的に取得するために ADSI LDAP Provider の使用を検討してください。ADSI LDAP Provider は、さまざまな ADSI インターフェイスをサポートする一連の ADSI オブジェクトを実装します。詳細については、 ADSI Service Providers を参照してください。

ユーザー アカウント名は 20 文字、グループ名は 256 文字に制限されています。さらに、アカウント名はピリオドで終了できず、カンマや次の印刷可能文字を含めることはできません: ", /, , [, ], :, |, <, >, +, =, ;, ?, *。また、名前には範囲 1~31 の文字(印刷不可能な文字)を含めることもできません。

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

各言語での呼び出し定義

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

DWORD NetGroupEnum(
    LPCWSTR servername,   // optional
    DWORD level,
    BYTE** bufptr,
    DWORD prefmaxlen,
    DWORD* entriesread,
    DWORD* totalentries,
    UINT_PTR* resume_handle   // optional
);
[DllImport("NETAPI32.dll", ExactSpelling = true)]
static extern uint NetGroupEnum(
    [MarshalAs(UnmanagedType.LPWStr)] string servername,   // LPCWSTR optional
    uint level,   // DWORD
    IntPtr bufptr,   // BYTE** out
    uint prefmaxlen,   // DWORD
    out uint entriesread,   // DWORD* out
    out uint totalentries,   // DWORD* out
    IntPtr resume_handle   // UINT_PTR* optional, in/out
);
<DllImport("NETAPI32.dll", ExactSpelling:=True)>
Public Shared Function NetGroupEnum(
    <MarshalAs(UnmanagedType.LPWStr)> servername As String,   ' LPCWSTR optional
    level As UInteger,   ' DWORD
    bufptr As IntPtr,   ' BYTE** out
    prefmaxlen As UInteger,   ' DWORD
    <Out> ByRef entriesread As UInteger,   ' DWORD* out
    <Out> ByRef totalentries As UInteger,   ' DWORD* out
    resume_handle As IntPtr   ' UINT_PTR* optional, in/out
) As UInteger
End Function
' servername : LPCWSTR optional
' level : DWORD
' bufptr : BYTE** out
' prefmaxlen : DWORD
' entriesread : DWORD* out
' totalentries : DWORD* out
' resume_handle : UINT_PTR* optional, in/out
Declare PtrSafe Function NetGroupEnum Lib "netapi32" ( _
    ByVal servername As LongPtr, _
    ByVal level As Long, _
    ByVal bufptr As LongPtr, _
    ByVal prefmaxlen As Long, _
    ByRef entriesread As Long, _
    ByRef totalentries As Long, _
    ByVal resume_handle As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。
import ctypes
from ctypes import wintypes

NetGroupEnum = ctypes.windll.netapi32.NetGroupEnum
NetGroupEnum.restype = wintypes.DWORD
NetGroupEnum.argtypes = [
    wintypes.LPCWSTR,  # servername : LPCWSTR optional
    wintypes.DWORD,  # level : DWORD
    ctypes.c_void_p,  # bufptr : BYTE** out
    wintypes.DWORD,  # prefmaxlen : DWORD
    ctypes.POINTER(wintypes.DWORD),  # entriesread : DWORD* out
    ctypes.POINTER(wintypes.DWORD),  # totalentries : DWORD* out
    ctypes.POINTER(ctypes.c_size_t),  # resume_handle : UINT_PTR* optional, in/out
]
require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('NETAPI32.dll')
NetGroupEnum = Fiddle::Function.new(
  lib['NetGroupEnum'],
  [
    Fiddle::TYPE_VOIDP,  # servername : LPCWSTR optional
    -Fiddle::TYPE_INT,  # level : DWORD
    Fiddle::TYPE_VOIDP,  # bufptr : BYTE** out
    -Fiddle::TYPE_INT,  # prefmaxlen : DWORD
    Fiddle::TYPE_VOIDP,  # entriesread : DWORD* out
    Fiddle::TYPE_VOIDP,  # totalentries : DWORD* out
    Fiddle::TYPE_VOIDP,  # resume_handle : UINT_PTR* optional, in/out
  ],
  -Fiddle::TYPE_INT)
#[link(name = "netapi32")]
extern "system" {
    fn NetGroupEnum(
        servername: *const u16,  // LPCWSTR optional
        level: u32,  // DWORD
        bufptr: *mut *mut u8,  // BYTE** out
        prefmaxlen: u32,  // DWORD
        entriesread: *mut u32,  // DWORD* out
        totalentries: *mut u32,  // DWORD* out
        resume_handle: *mut usize  // UINT_PTR* optional, in/out
    ) -> u32;
}
// crates: windows-sys provides ready-made bindings for this API.
$sig = @"
[DllImport("NETAPI32.dll")]
public static extern uint NetGroupEnum([MarshalAs(UnmanagedType.LPWStr)] string servername, uint level, IntPtr bufptr, uint prefmaxlen, out uint entriesread, out uint totalentries, IntPtr resume_handle);
"@
$api = Add-Type -MemberDefinition $sig -Name 'NETAPI32_NetGroupEnum' -Namespace Win32 -PassThru
# $api::NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
#uselib "NETAPI32.dll"
#func global NetGroupEnum "NetGroupEnum" sptr, sptr, sptr, sptr, sptr, sptr, sptr
; NetGroupEnum servername, level, varptr(bufptr), prefmaxlen, varptr(entriesread), varptr(totalentries), varptr(resume_handle)   ; 戻り値は stat
; servername : LPCWSTR optional -> "sptr"
; level : DWORD -> "sptr"
; bufptr : BYTE** out -> "sptr"
; prefmaxlen : DWORD -> "sptr"
; entriesread : DWORD* out -> "sptr"
; totalentries : DWORD* out -> "sptr"
; resume_handle : UINT_PTR* optional, in/out -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。
出力引数:
#uselib "NETAPI32.dll"
#cfunc global NetGroupEnum "NetGroupEnum" wstr, int, var, int, var, var, var
; res = NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
; servername : LPCWSTR optional -> "wstr"
; level : DWORD -> "int"
; bufptr : BYTE** out -> "var"
; prefmaxlen : DWORD -> "int"
; entriesread : DWORD* out -> "var"
; totalentries : DWORD* out -> "var"
; resume_handle : UINT_PTR* optional, in/out -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
出力引数:
; DWORD NetGroupEnum(LPCWSTR servername, DWORD level, BYTE** bufptr, DWORD prefmaxlen, DWORD* entriesread, DWORD* totalentries, UINT_PTR* resume_handle)
#uselib "NETAPI32.dll"
#cfunc global NetGroupEnum "NetGroupEnum" wstr, int, var, int, var, var, var
; res = NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
; servername : LPCWSTR optional -> "wstr"
; level : DWORD -> "int"
; bufptr : BYTE** out -> "var"
; prefmaxlen : DWORD -> "int"
; entriesread : DWORD* out -> "var"
; totalentries : DWORD* out -> "var"
; resume_handle : UINT_PTR* optional, in/out -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。
import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	netapi32 = windows.NewLazySystemDLL("NETAPI32.dll")
	procNetGroupEnum = netapi32.NewProc("NetGroupEnum")
)

// servername (LPCWSTR optional), level (DWORD), bufptr (BYTE** out), prefmaxlen (DWORD), entriesread (DWORD* out), totalentries (DWORD* out), resume_handle (UINT_PTR* optional, in/out)
r1, _, err := procNetGroupEnum.Call(
	uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(servername))),
	uintptr(level),
	uintptr(bufptr),
	uintptr(prefmaxlen),
	uintptr(entriesread),
	uintptr(totalentries),
	uintptr(resume_handle),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // DWORD
function NetGroupEnum(
  servername: PWideChar;   // LPCWSTR optional
  level: DWORD;   // DWORD
  bufptr: Pointer;   // BYTE** out
  prefmaxlen: DWORD;   // DWORD
  entriesread: Pointer;   // DWORD* out
  totalentries: Pointer;   // DWORD* out
  resume_handle: Pointer   // UINT_PTR* optional, in/out
): DWORD; stdcall;
  external 'NETAPI32.dll' name 'NetGroupEnum';
result := DllCall("NETAPI32\NetGroupEnum"
    , "WStr", servername   ; LPCWSTR optional
    , "UInt", level   ; DWORD
    , "Ptr", bufptr   ; BYTE** out
    , "UInt", prefmaxlen   ; DWORD
    , "Ptr", entriesread   ; DWORD* out
    , "Ptr", totalentries   ; DWORD* out
    , "Ptr", resume_handle   ; UINT_PTR* optional, in/out
    , "UInt")   ; return: DWORD
●NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle) = DLL("NETAPI32.dll", "dword NetGroupEnum(char*, dword, void*, dword, void*, void*, void*)")
# 呼び出し: NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
# servername : LPCWSTR optional -> "char*"
# level : DWORD -> "dword"
# bufptr : BYTE** out -> "void*"
# prefmaxlen : DWORD -> "dword"
# entriesread : DWORD* out -> "void*"
# totalentries : DWORD* out -> "void*"
# resume_handle : UINT_PTR* optional, in/out -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。
const std = @import("std");

extern "netapi32" fn NetGroupEnum(
    servername: [*c]const u16, // LPCWSTR optional
    level: u32, // DWORD
    bufptr: [*c][*c]u8, // BYTE** out
    prefmaxlen: u32, // DWORD
    entriesread: [*c]u32, // DWORD* out
    totalentries: [*c]u32, // DWORD* out
    resume_handle: [*c]usize // UINT_PTR* optional, in/out
) callconv(std.os.windows.WINAPI) u32;
proc NetGroupEnum(
    servername: WideCString,  # LPCWSTR optional
    level: uint32,  # DWORD
    bufptr: ptr uint8,  # BYTE** out
    prefmaxlen: uint32,  # DWORD
    entriesread: ptr uint32,  # DWORD* out
    totalentries: ptr uint32,  # DWORD* out
    resume_handle: ptr uint  # UINT_PTR* optional, in/out
): uint32 {.importc: "NetGroupEnum", stdcall, dynlib: "NETAPI32.dll".}
pragma(lib, "netapi32");
extern(Windows)
uint NetGroupEnum(
    const(wchar)* servername,   // LPCWSTR optional
    uint level,   // DWORD
    ubyte** bufptr,   // BYTE** out
    uint prefmaxlen,   // DWORD
    uint* entriesread,   // DWORD* out
    uint* totalentries,   // DWORD* out
    size_t* resume_handle   // UINT_PTR* optional, in/out
);
ccall((:NetGroupEnum, "NETAPI32.dll"), stdcall, UInt32,
      (Cwstring, UInt32, Ptr{UInt8}, UInt32, Ptr{UInt32}, Ptr{UInt32}, Ptr{Csize_t}),
      servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
# servername : LPCWSTR optional -> Cwstring
# level : DWORD -> UInt32
# bufptr : BYTE** out -> Ptr{UInt8}
# prefmaxlen : DWORD -> UInt32
# entriesread : DWORD* out -> Ptr{UInt32}
# totalentries : DWORD* out -> Ptr{UInt32}
# resume_handle : UINT_PTR* optional, in/out -> Ptr{Csize_t}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。
local ffi = require("ffi")
ffi.cdef[[
uint32_t NetGroupEnum(
    const uint16_t* servername,
    uint32_t level,
    uint8_t** bufptr,
    uint32_t prefmaxlen,
    uint32_t* entriesread,
    uint32_t* totalentries,
    uintptr_t* resume_handle);
]]
local netapi32 = ffi.load("netapi32")
-- netapi32.NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
-- servername : LPCWSTR optional
-- level : DWORD
-- bufptr : BYTE** out
-- prefmaxlen : DWORD
-- entriesread : DWORD* out
-- totalentries : DWORD* out
-- resume_handle : UINT_PTR* optional, in/out
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
const koffi = require('koffi');
const lib = koffi.load('NETAPI32.dll');
const NetGroupEnum = lib.func('__stdcall', 'NetGroupEnum', 'uint32_t', ['str16', 'uint32_t', 'uint8_t *', 'uint32_t', 'uint32_t *', 'uint32_t *', 'uintptr_t *']);
// NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
// servername : LPCWSTR optional -> 'str16'
// level : DWORD -> 'uint32_t'
// bufptr : BYTE** out -> 'uint8_t *'
// prefmaxlen : DWORD -> 'uint32_t'
// entriesread : DWORD* out -> 'uint32_t *'
// totalentries : DWORD* out -> 'uint32_t *'
// resume_handle : UINT_PTR* optional, in/out -> 'uintptr_t *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
const lib = Deno.dlopen("NETAPI32.dll", {
  NetGroupEnum: { parameters: ["buffer", "u32", "pointer", "u32", "pointer", "pointer", "pointer"], result: "u32" },
});
// lib.symbols.NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
// servername : LPCWSTR optional -> "buffer"
// level : DWORD -> "u32"
// bufptr : BYTE** out -> "pointer"
// prefmaxlen : DWORD -> "u32"
// entriesread : DWORD* out -> "pointer"
// totalentries : DWORD* out -> "pointer"
// resume_handle : UINT_PTR* optional, in/out -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。
<?php
$ffi = FFI::cdef(<<<C
uint32_t NetGroupEnum(
    const uint16_t* servername,
    uint32_t level,
    uint8_t** bufptr,
    uint32_t prefmaxlen,
    uint32_t* entriesread,
    uint32_t* totalentries,
    size_t* resume_handle);
C, "NETAPI32.dll");
// $ffi->NetGroupEnum(servername, level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
// servername : LPCWSTR optional
// level : DWORD
// bufptr : BYTE** out
// prefmaxlen : DWORD
// entriesread : DWORD* out
// totalentries : DWORD* out
// resume_handle : UINT_PTR* optional, in/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 Netapi32 extends StdCallLibrary {
    Netapi32 INSTANCE = Native.load("netapi32", Netapi32.class);
    int NetGroupEnum(
        WString servername,   // LPCWSTR optional
        int level,   // DWORD
        Pointer bufptr,   // BYTE** out
        int prefmaxlen,   // DWORD
        IntByReference entriesread,   // DWORD* out
        IntByReference totalentries,   // DWORD* out
        LongByReference resume_handle   // UINT_PTR* optional, in/out
    );
}
@[Link("netapi32")]
lib LibNETAPI32
  fun NetGroupEnum = NetGroupEnum(
    servername : UInt16*,   # LPCWSTR optional
    level : UInt32,   # DWORD
    bufptr : UInt8**,   # BYTE** out
    prefmaxlen : UInt32,   # DWORD
    entriesread : UInt32*,   # DWORD* out
    totalentries : UInt32*,   # DWORD* out
    resume_handle : LibC::SizeT*   # UINT_PTR* optional, in/out
  ) : UInt32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。
import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef NetGroupEnumNative = Uint32 Function(Pointer<Utf16>, Uint32, Pointer<Uint8>, Uint32, Pointer<Uint32>, Pointer<Uint32>, Pointer<UintPtr>);
typedef NetGroupEnumDart = int Function(Pointer<Utf16>, int, Pointer<Uint8>, int, Pointer<Uint32>, Pointer<Uint32>, Pointer<UintPtr>);
final NetGroupEnum = DynamicLibrary.open('NETAPI32.dll')
    .lookupFunction<NetGroupEnumNative, NetGroupEnumDart>('NetGroupEnum');
// servername : LPCWSTR optional -> Pointer<Utf16>
// level : DWORD -> Uint32
// bufptr : BYTE** out -> Pointer<Uint8>
// prefmaxlen : DWORD -> Uint32
// entriesread : DWORD* out -> Pointer<Uint32>
// totalentries : DWORD* out -> Pointer<Uint32>
// resume_handle : UINT_PTR* optional, in/out -> Pointer<UintPtr>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。
{$mode objfpc}{$H+}
function NetGroupEnum(
  servername: PWideChar;   // LPCWSTR optional
  level: DWORD;   // DWORD
  bufptr: Pointer;   // BYTE** out
  prefmaxlen: DWORD;   // DWORD
  entriesread: Pointer;   // DWORD* out
  totalentries: Pointer;   // DWORD* out
  resume_handle: Pointer   // UINT_PTR* optional, in/out
): DWORD; stdcall;
  external 'NETAPI32.dll' name 'NetGroupEnum';
import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "NetGroupEnum"
  c_NetGroupEnum :: CWString -> Word32 -> Ptr Word8 -> Word32 -> Ptr Word32 -> Ptr Word32 -> Ptr CUIntPtr -> IO Word32
-- servername : LPCWSTR optional -> CWString
-- level : DWORD -> Word32
-- bufptr : BYTE** out -> Ptr Word8
-- prefmaxlen : DWORD -> Word32
-- entriesread : DWORD* out -> Ptr Word32
-- totalentries : DWORD* out -> Ptr Word32
-- resume_handle : UINT_PTR* optional, in/out -> Ptr CUIntPtr
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。
open Ctypes
open Foreign

let netgroupenum =
  foreign "NetGroupEnum"
    ((ptr uint16_t) @-> uint32_t @-> (ptr uint8_t) @-> uint32_t @-> (ptr uint32_t) @-> (ptr uint32_t) @-> (ptr size_t) @-> returning uint32_t)
(* servername : LPCWSTR optional -> (ptr uint16_t) *)
(* level : DWORD -> uint32_t *)
(* bufptr : BYTE** out -> (ptr uint8_t) *)
(* prefmaxlen : DWORD -> uint32_t *)
(* entriesread : DWORD* out -> (ptr uint32_t) *)
(* totalentries : DWORD* out -> (ptr uint32_t) *)
(* resume_handle : UINT_PTR* optional, in/out -> (ptr size_t) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)
(cffi:define-foreign-library netapi32 (t "NETAPI32.dll"))
(cffi:use-foreign-library netapi32)

(cffi:defcfun ("NetGroupEnum" net-group-enum :convention :stdcall) :uint32
  (servername (:string :encoding :utf-16le))   ; LPCWSTR optional
  (level :uint32)   ; DWORD
  (bufptr :pointer)   ; BYTE** out
  (prefmaxlen :uint32)   ; DWORD
  (entriesread :pointer)   ; DWORD* out
  (totalentries :pointer)   ; DWORD* out
  (resume-handle :pointer))   ; UINT_PTR* optional, in/out
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。
use Win32::API;
my $NetGroupEnum = Win32::API::More->new('NETAPI32',
    'DWORD NetGroupEnum(LPCWSTR servername, DWORD level, LPVOID bufptr, DWORD prefmaxlen, LPVOID entriesread, LPVOID totalentries, LPVOID resume_handle)');
# my $ret = $NetGroupEnum->Call($servername, $level, $bufptr, $prefmaxlen, $entriesread, $totalentries, $resume_handle);
# servername : LPCWSTR optional -> LPCWSTR
# level : DWORD -> DWORD
# bufptr : BYTE** out -> LPVOID
# prefmaxlen : DWORD -> DWORD
# entriesread : DWORD* out -> LPVOID
# totalentries : DWORD* out -> LPVOID
# resume_handle : UINT_PTR* optional, in/out -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。

関連項目

公式の関連項目