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

WSMAN_OPERATION_INFOEX

構造体
サイズx64: 104 バイト / x86: 52 バイト

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

フィールド

フィールド型サイズx64x86説明
fragmentWSMAN_FRAGMENT16/8+0+0操作対象のフラグメント情報。WSMAN_FRAGMENTで表す。
filterWSMAN_FILTER16/8+16+8操作に適用するフィルター。WSMAN_FILTERで表す。
selectorSetWSMAN_SELECTOR_SET16/8+32+16リソース特定用のセレクターセット。WSMAN_SELECTOR_SETで表す。
optionSetWSMAN_OPTION_SETEX32/16+48+24操作に渡す拡張オプションセット。WSMAN_OPTION_SETEXで表す。
versionDWORD4+80+40この構造体のバージョン。
uiLocaleLPWSTR8/4+88+44UIメッセージのロケール。LPWSTR型。NULL可。
dataLocaleLPWSTR8/4+96+48データのロケール。LPWSTR型。NULL可。

各言語での定義

#include <windows.h>

// WSMAN_FRAGMENT  (x64 16 / x86 8 バイト)
typedef struct WSMAN_FRAGMENT {
    LPWSTR path;
    LPWSTR dialect;
} WSMAN_FRAGMENT;

// WSMAN_FILTER  (x64 16 / x86 8 バイト)
typedef struct WSMAN_FILTER {
    LPWSTR filter;
    LPWSTR dialect;
} WSMAN_FILTER;

// WSMAN_SELECTOR_SET  (x64 16 / x86 8 バイト)
typedef struct WSMAN_SELECTOR_SET {
    DWORD numberKeys;
    WSMAN_KEY* keys;
} WSMAN_SELECTOR_SET;

// WSMAN_OPTION_SETEX  (x64 32 / x86 16 バイト)
typedef struct WSMAN_OPTION_SETEX {
    DWORD optionsCount;
    WSMAN_OPTION* options;
    BOOL optionsMustUnderstand;
    LPWSTR* optionTypes;
} WSMAN_OPTION_SETEX;

// WSMAN_OPERATION_INFOEX  (x64 104 / x86 52 バイト)
typedef struct WSMAN_OPERATION_INFOEX {
    WSMAN_FRAGMENT fragment;
    WSMAN_FILTER filter;
    WSMAN_SELECTOR_SET selectorSet;
    WSMAN_OPTION_SETEX optionSet;
    DWORD version;
    LPWSTR uiLocale;
    LPWSTR dataLocale;
} WSMAN_OPERATION_INFOEX;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WSMAN_FRAGMENT
{
    public IntPtr path;
    public IntPtr dialect;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WSMAN_FILTER
{
    public IntPtr filter;
    public IntPtr dialect;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WSMAN_SELECTOR_SET
{
    public uint numberKeys;
    public IntPtr keys;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WSMAN_OPTION_SETEX
{
    public uint optionsCount;
    public IntPtr options;
    [MarshalAs(UnmanagedType.Bool)] public bool optionsMustUnderstand;
    public IntPtr optionTypes;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WSMAN_OPERATION_INFOEX
{
    public WSMAN_FRAGMENT fragment;
    public WSMAN_FILTER filter;
    public WSMAN_SELECTOR_SET selectorSet;
    public WSMAN_OPTION_SETEX optionSet;
    public uint version;
    public IntPtr uiLocale;
    public IntPtr dataLocale;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WSMAN_FRAGMENT
    Public path As IntPtr
    Public dialect As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WSMAN_FILTER
    Public filter As IntPtr
    Public dialect As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WSMAN_SELECTOR_SET
    Public numberKeys As UInteger
    Public keys As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WSMAN_OPTION_SETEX
    Public optionsCount As UInteger
    Public options As IntPtr
    <MarshalAs(UnmanagedType.Bool)> Public optionsMustUnderstand As Boolean
    Public optionTypes As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WSMAN_OPERATION_INFOEX
    Public fragment As WSMAN_FRAGMENT
    Public filter As WSMAN_FILTER
    Public selectorSet As WSMAN_SELECTOR_SET
    Public optionSet As WSMAN_OPTION_SETEX
    Public version As UInteger
    Public uiLocale As IntPtr
    Public dataLocale As IntPtr
End Structure
import ctypes
from ctypes import wintypes

class WSMAN_FRAGMENT(ctypes.Structure):
    _fields_ = [
        ("path", ctypes.c_void_p),
        ("dialect", ctypes.c_void_p),
    ]

class WSMAN_FILTER(ctypes.Structure):
    _fields_ = [
        ("filter", ctypes.c_void_p),
        ("dialect", ctypes.c_void_p),
    ]

class WSMAN_SELECTOR_SET(ctypes.Structure):
    _fields_ = [
        ("numberKeys", wintypes.DWORD),
        ("keys", ctypes.c_void_p),
    ]

class WSMAN_OPTION_SETEX(ctypes.Structure):
    _fields_ = [
        ("optionsCount", wintypes.DWORD),
        ("options", ctypes.c_void_p),
        ("optionsMustUnderstand", wintypes.BOOL),
        ("optionTypes", ctypes.c_void_p),
    ]

class WSMAN_OPERATION_INFOEX(ctypes.Structure):
    _fields_ = [
        ("fragment", WSMAN_FRAGMENT),
        ("filter", WSMAN_FILTER),
        ("selectorSet", WSMAN_SELECTOR_SET),
        ("optionSet", WSMAN_OPTION_SETEX),
        ("version", wintypes.DWORD),
        ("uiLocale", ctypes.c_void_p),
        ("dataLocale", ctypes.c_void_p),
    ]
#[repr(C)]
pub struct WSMAN_FRAGMENT {
    pub path: *mut core::ffi::c_void,
    pub dialect: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WSMAN_FILTER {
    pub filter: *mut core::ffi::c_void,
    pub dialect: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WSMAN_SELECTOR_SET {
    pub numberKeys: u32,
    pub keys: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WSMAN_OPTION_SETEX {
    pub optionsCount: u32,
    pub options: *mut core::ffi::c_void,
    pub optionsMustUnderstand: i32,
    pub optionTypes: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct WSMAN_OPERATION_INFOEX {
    pub fragment: WSMAN_FRAGMENT,
    pub filter: WSMAN_FILTER,
    pub selectorSet: WSMAN_SELECTOR_SET,
    pub optionSet: WSMAN_OPTION_SETEX,
    pub version: u32,
    pub uiLocale: *mut core::ffi::c_void,
    pub dataLocale: *mut core::ffi::c_void,
}
import "golang.org/x/sys/windows"

type WSMAN_FRAGMENT struct {
	path uintptr
	dialect uintptr
}

type WSMAN_FILTER struct {
	filter uintptr
	dialect uintptr
}

type WSMAN_SELECTOR_SET struct {
	numberKeys uint32
	keys uintptr
}

type WSMAN_OPTION_SETEX struct {
	optionsCount uint32
	options uintptr
	optionsMustUnderstand int32
	optionTypes uintptr
}

type WSMAN_OPERATION_INFOEX struct {
	fragment WSMAN_FRAGMENT
	filter WSMAN_FILTER
	selectorSet WSMAN_SELECTOR_SET
	optionSet WSMAN_OPTION_SETEX
	version uint32
	uiLocale uintptr
	dataLocale uintptr
}
type
  WSMAN_FRAGMENT = record
    path: Pointer;
    dialect: Pointer;
  end;

  WSMAN_FILTER = record
    filter: Pointer;
    dialect: Pointer;
  end;

  WSMAN_SELECTOR_SET = record
    numberKeys: DWORD;
    keys: Pointer;
  end;

  WSMAN_OPTION_SETEX = record
    optionsCount: DWORD;
    options: Pointer;
    optionsMustUnderstand: BOOL;
    optionTypes: Pointer;
  end;

  WSMAN_OPERATION_INFOEX = record
    fragment: WSMAN_FRAGMENT;
    filter: WSMAN_FILTER;
    selectorSet: WSMAN_SELECTOR_SET;
    optionSet: WSMAN_OPTION_SETEX;
    version: DWORD;
    uiLocale: Pointer;
    dataLocale: Pointer;
  end;
const WSMAN_FRAGMENT = extern struct {
    path: ?*anyopaque,
    dialect: ?*anyopaque,
};

const WSMAN_FILTER = extern struct {
    filter: ?*anyopaque,
    dialect: ?*anyopaque,
};

const WSMAN_SELECTOR_SET = extern struct {
    numberKeys: u32,
    keys: ?*anyopaque,
};

const WSMAN_OPTION_SETEX = extern struct {
    optionsCount: u32,
    options: ?*anyopaque,
    optionsMustUnderstand: i32,
    optionTypes: ?*anyopaque,
};

const WSMAN_OPERATION_INFOEX = extern struct {
    fragment: WSMAN_FRAGMENT,
    filter: WSMAN_FILTER,
    selectorSet: WSMAN_SELECTOR_SET,
    optionSet: WSMAN_OPTION_SETEX,
    version: u32,
    uiLocale: ?*anyopaque,
    dataLocale: ?*anyopaque,
};
type
  WSMAN_FRAGMENT {.bycopy.} = object
    path: pointer
    dialect: pointer

  WSMAN_FILTER {.bycopy.} = object
    filter: pointer
    dialect: pointer

  WSMAN_SELECTOR_SET {.bycopy.} = object
    numberKeys: uint32
    keys: pointer

  WSMAN_OPTION_SETEX {.bycopy.} = object
    optionsCount: uint32
    options: pointer
    optionsMustUnderstand: int32
    optionTypes: pointer

  WSMAN_OPERATION_INFOEX {.bycopy.} = object
    fragment: WSMAN_FRAGMENT
    filter: WSMAN_FILTER
    selectorSet: WSMAN_SELECTOR_SET
    optionSet: WSMAN_OPTION_SETEX
    version: uint32
    uiLocale: pointer
    dataLocale: pointer
struct WSMAN_FRAGMENT
{
    void* path;
    void* dialect;
}

struct WSMAN_FILTER
{
    void* filter;
    void* dialect;
}

struct WSMAN_SELECTOR_SET
{
    uint numberKeys;
    void* keys;
}

struct WSMAN_OPTION_SETEX
{
    uint optionsCount;
    void* options;
    int optionsMustUnderstand;
    void* optionTypes;
}

struct WSMAN_OPERATION_INFOEX
{
    WSMAN_FRAGMENT fragment;
    WSMAN_FILTER filter;
    WSMAN_SELECTOR_SET selectorSet;
    WSMAN_OPTION_SETEX optionSet;
    uint version;
    void* uiLocale;
    void* dataLocale;
}

HSP用 定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; WSMAN_OPERATION_INFOEX サイズ: 52 バイト(x86)
dim st, 13    ; 4byte整数×13(構造体サイズ 52 / 4 切り上げ)
; fragment : WSMAN_FRAGMENT (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; filter : WSMAN_FILTER (+8, 8byte)  varptr(st)+8 を基点に操作(8byte:入れ子/配列)
; selectorSet : WSMAN_SELECTOR_SET (+16, 8byte)  varptr(st)+16 を基点に操作(8byte:入れ子/配列)
; optionSet : WSMAN_OPTION_SETEX (+24, 16byte)  varptr(st)+24 を基点に操作(16byte:入れ子/配列)
; version : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; uiLocale : LPWSTR (+44, 4byte)  st.11 = 値  /  値 = st.11   (lpoke/lpeek も可)
; dataLocale : LPWSTR (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; WSMAN_OPERATION_INFOEX サイズ: 104 バイト(x64)
dim st, 26    ; 4byte整数×26(構造体サイズ 104 / 4 切り上げ)
; fragment : WSMAN_FRAGMENT (+0, 16byte)  varptr(st)+0 を基点に操作(16byte:入れ子/配列)
; filter : WSMAN_FILTER (+16, 16byte)  varptr(st)+16 を基点に操作(16byte:入れ子/配列)
; selectorSet : WSMAN_SELECTOR_SET (+32, 16byte)  varptr(st)+32 を基点に操作(16byte:入れ子/配列)
; optionSet : WSMAN_OPTION_SETEX (+48, 32byte)  varptr(st)+48 を基点に操作(32byte:入れ子/配列)
; version : DWORD (+80, 4byte)  st.20 = 値  /  値 = st.20   (lpoke/lpeek も可)
; uiLocale : LPWSTR (+88, 8byte)  qpoke st,88,値 / qpeek(st,88)  ※IronHSPのみ。3.7/3.8は lpoke st,88,下位 : lpoke st,92,上位
; dataLocale : LPWSTR (+96, 8byte)  qpoke st,96,値 / qpeek(st,96)  ※IronHSPのみ。3.7/3.8は lpoke st,96,下位 : lpoke st,100,上位
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global WSMAN_FRAGMENT
    #field intptr path
    #field intptr dialect
#endstruct

#defstruct global WSMAN_FILTER
    #field intptr filter
    #field intptr dialect
#endstruct

#defstruct global WSMAN_SELECTOR_SET
    #field int numberKeys
    #field intptr keys
#endstruct

#defstruct global WSMAN_OPTION_SETEX
    #field int optionsCount
    #field intptr options
    #field bool optionsMustUnderstand
    #field intptr optionTypes
#endstruct

#defstruct global WSMAN_OPERATION_INFOEX
    #field WSMAN_FRAGMENT fragment
    #field WSMAN_FILTER filter
    #field WSMAN_SELECTOR_SET selectorSet
    #field WSMAN_OPTION_SETEX optionSet
    #field int version
    #field intptr uiLocale
    #field intptr dataLocale
#endstruct

stdim st, WSMAN_OPERATION_INFOEX        ; NSTRUCT 変数を確保
st->version = 100
mes "version=" + st->version