ホーム › NetworkManagement.Rras › MPR_SERVER_EX1

MPR_SERVER_EX1

構造体

サイズx64: 248 バイト / x86: 180 バイト

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

フィールド

フィールド	型	サイズ	x64	x86	説明
Header	MPRAPI_OBJECT_HEADER	4	+0	+0	オブジェクトのリビジョン・種別・サイズを示すMPRAPI_OBJECT_HEADER。
fLanOnlyMode	DWORD	4	+4	+4	0以外ならサーバーがLAN専用モードであることを示す。
dwUpTime	DWORD	4	+8	+8	サーバーが稼働してからの経過時間(秒)。
dwTotalPorts	DWORD	4	+12	+12	サーバーが管理するポートの総数。
dwPortsInUse	DWORD	4	+16	+16	現在使用中のポートの数。
Reserved	DWORD	4	+20	+20	予約済み。0を設定する。
ConfigParams	MPRAPI_TUNNEL_CONFIG_PARAMS1	224/156	+24	+24	各トンネルプロトコル(GRE含む)の構成パラメータ群。

各言語での定義

#include <windows.h>

// MPRAPI_OBJECT_HEADER  (x64 4 / x86 4 バイト)
typedef struct MPRAPI_OBJECT_HEADER {
    BYTE revision;
    BYTE type;
    WORD size;
} MPRAPI_OBJECT_HEADER;

// CRYPT_INTEGER_BLOB  (x64 16 / x86 8 バイト)
typedef struct CRYPT_INTEGER_BLOB {
    DWORD cbData;
    BYTE* pbData;
} CRYPT_INTEGER_BLOB;

// IKEV2_TUNNEL_CONFIG_PARAMS4  (x64 104 / x86 64 バイト)
typedef struct IKEV2_TUNNEL_CONFIG_PARAMS4 {
    DWORD dwIdleTimeout;
    DWORD dwNetworkBlackoutTime;
    DWORD dwSaLifeTime;
    DWORD dwSaDataSizeForRenegotiation;
    DWORD dwConfigOptions;
    DWORD dwTotalCertificates;
    CRYPT_INTEGER_BLOB* certificateNames;
    CRYPT_INTEGER_BLOB machineCertificateName;
    DWORD dwEncryptionType;
    ROUTER_CUSTOM_IKEv2_POLICY0* customPolicy;
    DWORD dwTotalEkus;
    MPR_CERT_EKU* certificateEKUs;
    CRYPT_INTEGER_BLOB machineCertificateHash;
    DWORD dwMmSaLifeTime;
} IKEV2_TUNNEL_CONFIG_PARAMS4;

// IKEV2_CONFIG_PARAMS  (x64 120 / x86 76 バイト)
typedef struct IKEV2_CONFIG_PARAMS {
    DWORD dwNumPorts;
    DWORD dwPortFlags;
    DWORD dwTunnelConfigParamFlags;
    IKEV2_TUNNEL_CONFIG_PARAMS4 TunnelConfigParams;
} IKEV2_CONFIG_PARAMS;

// PPTP_CONFIG_PARAMS  (x64 8 / x86 8 バイト)
typedef struct PPTP_CONFIG_PARAMS {
    DWORD dwNumPorts;
    DWORD dwPortFlags;
} PPTP_CONFIG_PARAMS;

// L2TP_TUNNEL_CONFIG_PARAMS2  (x64 32 / x86 24 バイト)
typedef struct L2TP_TUNNEL_CONFIG_PARAMS2 {
    DWORD dwIdleTimeout;
    DWORD dwEncryptionType;
    DWORD dwSaLifeTime;
    DWORD dwSaDataSizeForRenegotiation;
    ROUTER_CUSTOM_IKEv2_POLICY0* customPolicy;
    DWORD dwMmSaLifeTime;
} L2TP_TUNNEL_CONFIG_PARAMS2;

// L2TP_CONFIG_PARAMS1  (x64 48 / x86 36 バイト)
typedef struct L2TP_CONFIG_PARAMS1 {
    DWORD dwNumPorts;
    DWORD dwPortFlags;
    DWORD dwTunnelConfigParamFlags;
    L2TP_TUNNEL_CONFIG_PARAMS2 TunnelConfigParams;
} L2TP_CONFIG_PARAMS1;

// SSTP_CERT_INFO  (x64 24 / x86 12 バイト)
typedef struct SSTP_CERT_INFO {
    BOOL isDefault;
    CRYPT_INTEGER_BLOB certBlob;
} SSTP_CERT_INFO;

// SSTP_CONFIG_PARAMS  (x64 40 / x86 28 バイト)
typedef struct SSTP_CONFIG_PARAMS {
    DWORD dwNumPorts;
    DWORD dwPortFlags;
    BOOL isUseHttps;
    DWORD certAlgorithm;
    SSTP_CERT_INFO sstpCertDetails;
} SSTP_CONFIG_PARAMS;

// GRE_CONFIG_PARAMS0  (x64 8 / x86 8 バイト)
typedef struct GRE_CONFIG_PARAMS0 {
    DWORD dwNumPorts;
    DWORD dwPortFlags;
} GRE_CONFIG_PARAMS0;

// MPRAPI_TUNNEL_CONFIG_PARAMS1  (x64 224 / x86 156 バイト)
typedef struct MPRAPI_TUNNEL_CONFIG_PARAMS1 {
    IKEV2_CONFIG_PARAMS IkeConfigParams;
    PPTP_CONFIG_PARAMS PptpConfigParams;
    L2TP_CONFIG_PARAMS1 L2tpConfigParams;
    SSTP_CONFIG_PARAMS SstpConfigParams;
    GRE_CONFIG_PARAMS0 GREConfigParams;
} MPRAPI_TUNNEL_CONFIG_PARAMS1;

// MPR_SERVER_EX1  (x64 248 / x86 180 バイト)
typedef struct MPR_SERVER_EX1 {
    MPRAPI_OBJECT_HEADER Header;
    DWORD fLanOnlyMode;
    DWORD dwUpTime;
    DWORD dwTotalPorts;
    DWORD dwPortsInUse;
    DWORD Reserved;
    MPRAPI_TUNNEL_CONFIG_PARAMS1 ConfigParams;
} MPR_SERVER_EX1;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MPRAPI_OBJECT_HEADER
{
    public byte revision;
    public byte type;
    public ushort size;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CRYPT_INTEGER_BLOB
{
    public uint cbData;
    public IntPtr pbData;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEV2_TUNNEL_CONFIG_PARAMS4
{
    public uint dwIdleTimeout;
    public uint dwNetworkBlackoutTime;
    public uint dwSaLifeTime;
    public uint dwSaDataSizeForRenegotiation;
    public uint dwConfigOptions;
    public uint dwTotalCertificates;
    public IntPtr certificateNames;
    public CRYPT_INTEGER_BLOB machineCertificateName;
    public uint dwEncryptionType;
    public IntPtr customPolicy;
    public uint dwTotalEkus;
    public IntPtr certificateEKUs;
    public CRYPT_INTEGER_BLOB machineCertificateHash;
    public uint dwMmSaLifeTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEV2_CONFIG_PARAMS
{
    public uint dwNumPorts;
    public uint dwPortFlags;
    public uint dwTunnelConfigParamFlags;
    public IKEV2_TUNNEL_CONFIG_PARAMS4 TunnelConfigParams;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PPTP_CONFIG_PARAMS
{
    public uint dwNumPorts;
    public uint dwPortFlags;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct L2TP_TUNNEL_CONFIG_PARAMS2
{
    public uint dwIdleTimeout;
    public uint dwEncryptionType;
    public uint dwSaLifeTime;
    public uint dwSaDataSizeForRenegotiation;
    public IntPtr customPolicy;
    public uint dwMmSaLifeTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct L2TP_CONFIG_PARAMS1
{
    public uint dwNumPorts;
    public uint dwPortFlags;
    public uint dwTunnelConfigParamFlags;
    public L2TP_TUNNEL_CONFIG_PARAMS2 TunnelConfigParams;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SSTP_CERT_INFO
{
    [MarshalAs(UnmanagedType.Bool)] public bool isDefault;
    public CRYPT_INTEGER_BLOB certBlob;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SSTP_CONFIG_PARAMS
{
    public uint dwNumPorts;
    public uint dwPortFlags;
    [MarshalAs(UnmanagedType.Bool)] public bool isUseHttps;
    public uint certAlgorithm;
    public SSTP_CERT_INFO sstpCertDetails;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GRE_CONFIG_PARAMS0
{
    public uint dwNumPorts;
    public uint dwPortFlags;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MPRAPI_TUNNEL_CONFIG_PARAMS1
{
    public IKEV2_CONFIG_PARAMS IkeConfigParams;
    public PPTP_CONFIG_PARAMS PptpConfigParams;
    public L2TP_CONFIG_PARAMS1 L2tpConfigParams;
    public SSTP_CONFIG_PARAMS SstpConfigParams;
    public GRE_CONFIG_PARAMS0 GREConfigParams;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MPR_SERVER_EX1
{
    public MPRAPI_OBJECT_HEADER Header;
    public uint fLanOnlyMode;
    public uint dwUpTime;
    public uint dwTotalPorts;
    public uint dwPortsInUse;
    public uint Reserved;
    public MPRAPI_TUNNEL_CONFIG_PARAMS1 ConfigParams;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MPRAPI_OBJECT_HEADER
    Public revision As Byte
    Public type As Byte
    Public size As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CRYPT_INTEGER_BLOB
    Public cbData As UInteger
    Public pbData As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEV2_TUNNEL_CONFIG_PARAMS4
    Public dwIdleTimeout As UInteger
    Public dwNetworkBlackoutTime As UInteger
    Public dwSaLifeTime As UInteger
    Public dwSaDataSizeForRenegotiation As UInteger
    Public dwConfigOptions As UInteger
    Public dwTotalCertificates As UInteger
    Public certificateNames As IntPtr
    Public machineCertificateName As CRYPT_INTEGER_BLOB
    Public dwEncryptionType As UInteger
    Public customPolicy As IntPtr
    Public dwTotalEkus As UInteger
    Public certificateEKUs As IntPtr
    Public machineCertificateHash As CRYPT_INTEGER_BLOB
    Public dwMmSaLifeTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEV2_CONFIG_PARAMS
    Public dwNumPorts As UInteger
    Public dwPortFlags As UInteger
    Public dwTunnelConfigParamFlags As UInteger
    Public TunnelConfigParams As IKEV2_TUNNEL_CONFIG_PARAMS4
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PPTP_CONFIG_PARAMS
    Public dwNumPorts As UInteger
    Public dwPortFlags As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure L2TP_TUNNEL_CONFIG_PARAMS2
    Public dwIdleTimeout As UInteger
    Public dwEncryptionType As UInteger
    Public dwSaLifeTime As UInteger
    Public dwSaDataSizeForRenegotiation As UInteger
    Public customPolicy As IntPtr
    Public dwMmSaLifeTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure L2TP_CONFIG_PARAMS1
    Public dwNumPorts As UInteger
    Public dwPortFlags As UInteger
    Public dwTunnelConfigParamFlags As UInteger
    Public TunnelConfigParams As L2TP_TUNNEL_CONFIG_PARAMS2
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SSTP_CERT_INFO
    <MarshalAs(UnmanagedType.Bool)> Public isDefault As Boolean
    Public certBlob As CRYPT_INTEGER_BLOB
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SSTP_CONFIG_PARAMS
    Public dwNumPorts As UInteger
    Public dwPortFlags As UInteger
    <MarshalAs(UnmanagedType.Bool)> Public isUseHttps As Boolean
    Public certAlgorithm As UInteger
    Public sstpCertDetails As SSTP_CERT_INFO
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GRE_CONFIG_PARAMS0
    Public dwNumPorts As UInteger
    Public dwPortFlags As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MPRAPI_TUNNEL_CONFIG_PARAMS1
    Public IkeConfigParams As IKEV2_CONFIG_PARAMS
    Public PptpConfigParams As PPTP_CONFIG_PARAMS
    Public L2tpConfigParams As L2TP_CONFIG_PARAMS1
    Public SstpConfigParams As SSTP_CONFIG_PARAMS
    Public GREConfigParams As GRE_CONFIG_PARAMS0
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MPR_SERVER_EX1
    Public Header As MPRAPI_OBJECT_HEADER
    Public fLanOnlyMode As UInteger
    Public dwUpTime As UInteger
    Public dwTotalPorts As UInteger
    Public dwPortsInUse As UInteger
    Public Reserved As UInteger
    Public ConfigParams As MPRAPI_TUNNEL_CONFIG_PARAMS1
End Structure

import ctypes
from ctypes import wintypes

class MPRAPI_OBJECT_HEADER(ctypes.Structure):
    _fields_ = [
        ("revision", ctypes.c_ubyte),
        ("type", ctypes.c_ubyte),
        ("size", ctypes.c_ushort),
    ]

class CRYPT_INTEGER_BLOB(ctypes.Structure):
    _fields_ = [
        ("cbData", wintypes.DWORD),
        ("pbData", ctypes.c_void_p),
    ]

class IKEV2_TUNNEL_CONFIG_PARAMS4(ctypes.Structure):
    _fields_ = [
        ("dwIdleTimeout", wintypes.DWORD),
        ("dwNetworkBlackoutTime", wintypes.DWORD),
        ("dwSaLifeTime", wintypes.DWORD),
        ("dwSaDataSizeForRenegotiation", wintypes.DWORD),
        ("dwConfigOptions", wintypes.DWORD),
        ("dwTotalCertificates", wintypes.DWORD),
        ("certificateNames", ctypes.c_void_p),
        ("machineCertificateName", CRYPT_INTEGER_BLOB),
        ("dwEncryptionType", wintypes.DWORD),
        ("customPolicy", ctypes.c_void_p),
        ("dwTotalEkus", wintypes.DWORD),
        ("certificateEKUs", ctypes.c_void_p),
        ("machineCertificateHash", CRYPT_INTEGER_BLOB),
        ("dwMmSaLifeTime", wintypes.DWORD),
    ]

class IKEV2_CONFIG_PARAMS(ctypes.Structure):
    _fields_ = [
        ("dwNumPorts", wintypes.DWORD),
        ("dwPortFlags", wintypes.DWORD),
        ("dwTunnelConfigParamFlags", wintypes.DWORD),
        ("TunnelConfigParams", IKEV2_TUNNEL_CONFIG_PARAMS4),
    ]

class PPTP_CONFIG_PARAMS(ctypes.Structure):
    _fields_ = [
        ("dwNumPorts", wintypes.DWORD),
        ("dwPortFlags", wintypes.DWORD),
    ]

class L2TP_TUNNEL_CONFIG_PARAMS2(ctypes.Structure):
    _fields_ = [
        ("dwIdleTimeout", wintypes.DWORD),
        ("dwEncryptionType", wintypes.DWORD),
        ("dwSaLifeTime", wintypes.DWORD),
        ("dwSaDataSizeForRenegotiation", wintypes.DWORD),
        ("customPolicy", ctypes.c_void_p),
        ("dwMmSaLifeTime", wintypes.DWORD),
    ]

class L2TP_CONFIG_PARAMS1(ctypes.Structure):
    _fields_ = [
        ("dwNumPorts", wintypes.DWORD),
        ("dwPortFlags", wintypes.DWORD),
        ("dwTunnelConfigParamFlags", wintypes.DWORD),
        ("TunnelConfigParams", L2TP_TUNNEL_CONFIG_PARAMS2),
    ]

class SSTP_CERT_INFO(ctypes.Structure):
    _fields_ = [
        ("isDefault", wintypes.BOOL),
        ("certBlob", CRYPT_INTEGER_BLOB),
    ]

class SSTP_CONFIG_PARAMS(ctypes.Structure):
    _fields_ = [
        ("dwNumPorts", wintypes.DWORD),
        ("dwPortFlags", wintypes.DWORD),
        ("isUseHttps", wintypes.BOOL),
        ("certAlgorithm", wintypes.DWORD),
        ("sstpCertDetails", SSTP_CERT_INFO),
    ]

class GRE_CONFIG_PARAMS0(ctypes.Structure):
    _fields_ = [
        ("dwNumPorts", wintypes.DWORD),
        ("dwPortFlags", wintypes.DWORD),
    ]

class MPRAPI_TUNNEL_CONFIG_PARAMS1(ctypes.Structure):
    _fields_ = [
        ("IkeConfigParams", IKEV2_CONFIG_PARAMS),
        ("PptpConfigParams", PPTP_CONFIG_PARAMS),
        ("L2tpConfigParams", L2TP_CONFIG_PARAMS1),
        ("SstpConfigParams", SSTP_CONFIG_PARAMS),
        ("GREConfigParams", GRE_CONFIG_PARAMS0),
    ]

class MPR_SERVER_EX1(ctypes.Structure):
    _fields_ = [
        ("Header", MPRAPI_OBJECT_HEADER),
        ("fLanOnlyMode", wintypes.DWORD),
        ("dwUpTime", wintypes.DWORD),
        ("dwTotalPorts", wintypes.DWORD),
        ("dwPortsInUse", wintypes.DWORD),
        ("Reserved", wintypes.DWORD),
        ("ConfigParams", MPRAPI_TUNNEL_CONFIG_PARAMS1),
    ]

#[repr(C)]
pub struct MPRAPI_OBJECT_HEADER {
    pub revision: u8,
    pub type: u8,
    pub size: u16,
}

#[repr(C)]
pub struct CRYPT_INTEGER_BLOB {
    pub cbData: u32,
    pub pbData: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct IKEV2_TUNNEL_CONFIG_PARAMS4 {
    pub dwIdleTimeout: u32,
    pub dwNetworkBlackoutTime: u32,
    pub dwSaLifeTime: u32,
    pub dwSaDataSizeForRenegotiation: u32,
    pub dwConfigOptions: u32,
    pub dwTotalCertificates: u32,
    pub certificateNames: *mut core::ffi::c_void,
    pub machineCertificateName: CRYPT_INTEGER_BLOB,
    pub dwEncryptionType: u32,
    pub customPolicy: *mut core::ffi::c_void,
    pub dwTotalEkus: u32,
    pub certificateEKUs: *mut core::ffi::c_void,
    pub machineCertificateHash: CRYPT_INTEGER_BLOB,
    pub dwMmSaLifeTime: u32,
}

#[repr(C)]
pub struct IKEV2_CONFIG_PARAMS {
    pub dwNumPorts: u32,
    pub dwPortFlags: u32,
    pub dwTunnelConfigParamFlags: u32,
    pub TunnelConfigParams: IKEV2_TUNNEL_CONFIG_PARAMS4,
}

#[repr(C)]
pub struct PPTP_CONFIG_PARAMS {
    pub dwNumPorts: u32,
    pub dwPortFlags: u32,
}

#[repr(C)]
pub struct L2TP_TUNNEL_CONFIG_PARAMS2 {
    pub dwIdleTimeout: u32,
    pub dwEncryptionType: u32,
    pub dwSaLifeTime: u32,
    pub dwSaDataSizeForRenegotiation: u32,
    pub customPolicy: *mut core::ffi::c_void,
    pub dwMmSaLifeTime: u32,
}

#[repr(C)]
pub struct L2TP_CONFIG_PARAMS1 {
    pub dwNumPorts: u32,
    pub dwPortFlags: u32,
    pub dwTunnelConfigParamFlags: u32,
    pub TunnelConfigParams: L2TP_TUNNEL_CONFIG_PARAMS2,
}

#[repr(C)]
pub struct SSTP_CERT_INFO {
    pub isDefault: i32,
    pub certBlob: CRYPT_INTEGER_BLOB,
}

#[repr(C)]
pub struct SSTP_CONFIG_PARAMS {
    pub dwNumPorts: u32,
    pub dwPortFlags: u32,
    pub isUseHttps: i32,
    pub certAlgorithm: u32,
    pub sstpCertDetails: SSTP_CERT_INFO,
}

#[repr(C)]
pub struct GRE_CONFIG_PARAMS0 {
    pub dwNumPorts: u32,
    pub dwPortFlags: u32,
}

#[repr(C)]
pub struct MPRAPI_TUNNEL_CONFIG_PARAMS1 {
    pub IkeConfigParams: IKEV2_CONFIG_PARAMS,
    pub PptpConfigParams: PPTP_CONFIG_PARAMS,
    pub L2tpConfigParams: L2TP_CONFIG_PARAMS1,
    pub SstpConfigParams: SSTP_CONFIG_PARAMS,
    pub GREConfigParams: GRE_CONFIG_PARAMS0,
}

#[repr(C)]
pub struct MPR_SERVER_EX1 {
    pub Header: MPRAPI_OBJECT_HEADER,
    pub fLanOnlyMode: u32,
    pub dwUpTime: u32,
    pub dwTotalPorts: u32,
    pub dwPortsInUse: u32,
    pub Reserved: u32,
    pub ConfigParams: MPRAPI_TUNNEL_CONFIG_PARAMS1,
}

import "golang.org/x/sys/windows"

type MPRAPI_OBJECT_HEADER struct {
	revision byte
	type byte
	size uint16
}

type CRYPT_INTEGER_BLOB struct {
	cbData uint32
	pbData uintptr
}

type IKEV2_TUNNEL_CONFIG_PARAMS4 struct {
	dwIdleTimeout uint32
	dwNetworkBlackoutTime uint32
	dwSaLifeTime uint32
	dwSaDataSizeForRenegotiation uint32
	dwConfigOptions uint32
	dwTotalCertificates uint32
	certificateNames uintptr
	machineCertificateName CRYPT_INTEGER_BLOB
	dwEncryptionType uint32
	customPolicy uintptr
	dwTotalEkus uint32
	certificateEKUs uintptr
	machineCertificateHash CRYPT_INTEGER_BLOB
	dwMmSaLifeTime uint32
}

type IKEV2_CONFIG_PARAMS struct {
	dwNumPorts uint32
	dwPortFlags uint32
	dwTunnelConfigParamFlags uint32
	TunnelConfigParams IKEV2_TUNNEL_CONFIG_PARAMS4
}

type PPTP_CONFIG_PARAMS struct {
	dwNumPorts uint32
	dwPortFlags uint32
}

type L2TP_TUNNEL_CONFIG_PARAMS2 struct {
	dwIdleTimeout uint32
	dwEncryptionType uint32
	dwSaLifeTime uint32
	dwSaDataSizeForRenegotiation uint32
	customPolicy uintptr
	dwMmSaLifeTime uint32
}

type L2TP_CONFIG_PARAMS1 struct {
	dwNumPorts uint32
	dwPortFlags uint32
	dwTunnelConfigParamFlags uint32
	TunnelConfigParams L2TP_TUNNEL_CONFIG_PARAMS2
}

type SSTP_CERT_INFO struct {
	isDefault int32
	certBlob CRYPT_INTEGER_BLOB
}

type SSTP_CONFIG_PARAMS struct {
	dwNumPorts uint32
	dwPortFlags uint32
	isUseHttps int32
	certAlgorithm uint32
	sstpCertDetails SSTP_CERT_INFO
}

type GRE_CONFIG_PARAMS0 struct {
	dwNumPorts uint32
	dwPortFlags uint32
}

type MPRAPI_TUNNEL_CONFIG_PARAMS1 struct {
	IkeConfigParams IKEV2_CONFIG_PARAMS
	PptpConfigParams PPTP_CONFIG_PARAMS
	L2tpConfigParams L2TP_CONFIG_PARAMS1
	SstpConfigParams SSTP_CONFIG_PARAMS
	GREConfigParams GRE_CONFIG_PARAMS0
}

type MPR_SERVER_EX1 struct {
	Header MPRAPI_OBJECT_HEADER
	fLanOnlyMode uint32
	dwUpTime uint32
	dwTotalPorts uint32
	dwPortsInUse uint32
	Reserved uint32
	ConfigParams MPRAPI_TUNNEL_CONFIG_PARAMS1
}

type
  MPRAPI_OBJECT_HEADER = record
    revision: Byte;
    type: Byte;
    size: Word;
  end;

  CRYPT_INTEGER_BLOB = record
    cbData: DWORD;
    pbData: Pointer;
  end;

  IKEV2_TUNNEL_CONFIG_PARAMS4 = record
    dwIdleTimeout: DWORD;
    dwNetworkBlackoutTime: DWORD;
    dwSaLifeTime: DWORD;
    dwSaDataSizeForRenegotiation: DWORD;
    dwConfigOptions: DWORD;
    dwTotalCertificates: DWORD;
    certificateNames: Pointer;
    machineCertificateName: CRYPT_INTEGER_BLOB;
    dwEncryptionType: DWORD;
    customPolicy: Pointer;
    dwTotalEkus: DWORD;
    certificateEKUs: Pointer;
    machineCertificateHash: CRYPT_INTEGER_BLOB;
    dwMmSaLifeTime: DWORD;
  end;

  IKEV2_CONFIG_PARAMS = record
    dwNumPorts: DWORD;
    dwPortFlags: DWORD;
    dwTunnelConfigParamFlags: DWORD;
    TunnelConfigParams: IKEV2_TUNNEL_CONFIG_PARAMS4;
  end;

  PPTP_CONFIG_PARAMS = record
    dwNumPorts: DWORD;
    dwPortFlags: DWORD;
  end;

  L2TP_TUNNEL_CONFIG_PARAMS2 = record
    dwIdleTimeout: DWORD;
    dwEncryptionType: DWORD;
    dwSaLifeTime: DWORD;
    dwSaDataSizeForRenegotiation: DWORD;
    customPolicy: Pointer;
    dwMmSaLifeTime: DWORD;
  end;

  L2TP_CONFIG_PARAMS1 = record
    dwNumPorts: DWORD;
    dwPortFlags: DWORD;
    dwTunnelConfigParamFlags: DWORD;
    TunnelConfigParams: L2TP_TUNNEL_CONFIG_PARAMS2;
  end;

  SSTP_CERT_INFO = record
    isDefault: BOOL;
    certBlob: CRYPT_INTEGER_BLOB;
  end;

  SSTP_CONFIG_PARAMS = record
    dwNumPorts: DWORD;
    dwPortFlags: DWORD;
    isUseHttps: BOOL;
    certAlgorithm: DWORD;
    sstpCertDetails: SSTP_CERT_INFO;
  end;

  GRE_CONFIG_PARAMS0 = record
    dwNumPorts: DWORD;
    dwPortFlags: DWORD;
  end;

  MPRAPI_TUNNEL_CONFIG_PARAMS1 = record
    IkeConfigParams: IKEV2_CONFIG_PARAMS;
    PptpConfigParams: PPTP_CONFIG_PARAMS;
    L2tpConfigParams: L2TP_CONFIG_PARAMS1;
    SstpConfigParams: SSTP_CONFIG_PARAMS;
    GREConfigParams: GRE_CONFIG_PARAMS0;
  end;

  MPR_SERVER_EX1 = record
    Header: MPRAPI_OBJECT_HEADER;
    fLanOnlyMode: DWORD;
    dwUpTime: DWORD;
    dwTotalPorts: DWORD;
    dwPortsInUse: DWORD;
    Reserved: DWORD;
    ConfigParams: MPRAPI_TUNNEL_CONFIG_PARAMS1;
  end;

const MPRAPI_OBJECT_HEADER = extern struct {
    revision: u8,
    type: u8,
    size: u16,
};

const CRYPT_INTEGER_BLOB = extern struct {
    cbData: u32,
    pbData: ?*anyopaque,
};

const IKEV2_TUNNEL_CONFIG_PARAMS4 = extern struct {
    dwIdleTimeout: u32,
    dwNetworkBlackoutTime: u32,
    dwSaLifeTime: u32,
    dwSaDataSizeForRenegotiation: u32,
    dwConfigOptions: u32,
    dwTotalCertificates: u32,
    certificateNames: ?*anyopaque,
    machineCertificateName: CRYPT_INTEGER_BLOB,
    dwEncryptionType: u32,
    customPolicy: ?*anyopaque,
    dwTotalEkus: u32,
    certificateEKUs: ?*anyopaque,
    machineCertificateHash: CRYPT_INTEGER_BLOB,
    dwMmSaLifeTime: u32,
};

const IKEV2_CONFIG_PARAMS = extern struct {
    dwNumPorts: u32,
    dwPortFlags: u32,
    dwTunnelConfigParamFlags: u32,
    TunnelConfigParams: IKEV2_TUNNEL_CONFIG_PARAMS4,
};

const PPTP_CONFIG_PARAMS = extern struct {
    dwNumPorts: u32,
    dwPortFlags: u32,
};

const L2TP_TUNNEL_CONFIG_PARAMS2 = extern struct {
    dwIdleTimeout: u32,
    dwEncryptionType: u32,
    dwSaLifeTime: u32,
    dwSaDataSizeForRenegotiation: u32,
    customPolicy: ?*anyopaque,
    dwMmSaLifeTime: u32,
};

const L2TP_CONFIG_PARAMS1 = extern struct {
    dwNumPorts: u32,
    dwPortFlags: u32,
    dwTunnelConfigParamFlags: u32,
    TunnelConfigParams: L2TP_TUNNEL_CONFIG_PARAMS2,
};

const SSTP_CERT_INFO = extern struct {
    isDefault: i32,
    certBlob: CRYPT_INTEGER_BLOB,
};

const SSTP_CONFIG_PARAMS = extern struct {
    dwNumPorts: u32,
    dwPortFlags: u32,
    isUseHttps: i32,
    certAlgorithm: u32,
    sstpCertDetails: SSTP_CERT_INFO,
};

const GRE_CONFIG_PARAMS0 = extern struct {
    dwNumPorts: u32,
    dwPortFlags: u32,
};

const MPRAPI_TUNNEL_CONFIG_PARAMS1 = extern struct {
    IkeConfigParams: IKEV2_CONFIG_PARAMS,
    PptpConfigParams: PPTP_CONFIG_PARAMS,
    L2tpConfigParams: L2TP_CONFIG_PARAMS1,
    SstpConfigParams: SSTP_CONFIG_PARAMS,
    GREConfigParams: GRE_CONFIG_PARAMS0,
};

const MPR_SERVER_EX1 = extern struct {
    Header: MPRAPI_OBJECT_HEADER,
    fLanOnlyMode: u32,
    dwUpTime: u32,
    dwTotalPorts: u32,
    dwPortsInUse: u32,
    Reserved: u32,
    ConfigParams: MPRAPI_TUNNEL_CONFIG_PARAMS1,
};

type
  MPRAPI_OBJECT_HEADER {.bycopy.} = object
    revision: uint8
    type: uint8
    size: uint16

  CRYPT_INTEGER_BLOB {.bycopy.} = object
    cbData: uint32
    pbData: pointer

  IKEV2_TUNNEL_CONFIG_PARAMS4 {.bycopy.} = object
    dwIdleTimeout: uint32
    dwNetworkBlackoutTime: uint32
    dwSaLifeTime: uint32
    dwSaDataSizeForRenegotiation: uint32
    dwConfigOptions: uint32
    dwTotalCertificates: uint32
    certificateNames: pointer
    machineCertificateName: CRYPT_INTEGER_BLOB
    dwEncryptionType: uint32
    customPolicy: pointer
    dwTotalEkus: uint32
    certificateEKUs: pointer
    machineCertificateHash: CRYPT_INTEGER_BLOB
    dwMmSaLifeTime: uint32

  IKEV2_CONFIG_PARAMS {.bycopy.} = object
    dwNumPorts: uint32
    dwPortFlags: uint32
    dwTunnelConfigParamFlags: uint32
    TunnelConfigParams: IKEV2_TUNNEL_CONFIG_PARAMS4

  PPTP_CONFIG_PARAMS {.bycopy.} = object
    dwNumPorts: uint32
    dwPortFlags: uint32

  L2TP_TUNNEL_CONFIG_PARAMS2 {.bycopy.} = object
    dwIdleTimeout: uint32
    dwEncryptionType: uint32
    dwSaLifeTime: uint32
    dwSaDataSizeForRenegotiation: uint32
    customPolicy: pointer
    dwMmSaLifeTime: uint32

  L2TP_CONFIG_PARAMS1 {.bycopy.} = object
    dwNumPorts: uint32
    dwPortFlags: uint32
    dwTunnelConfigParamFlags: uint32
    TunnelConfigParams: L2TP_TUNNEL_CONFIG_PARAMS2

  SSTP_CERT_INFO {.bycopy.} = object
    isDefault: int32
    certBlob: CRYPT_INTEGER_BLOB

  SSTP_CONFIG_PARAMS {.bycopy.} = object
    dwNumPorts: uint32
    dwPortFlags: uint32
    isUseHttps: int32
    certAlgorithm: uint32
    sstpCertDetails: SSTP_CERT_INFO

  GRE_CONFIG_PARAMS0 {.bycopy.} = object
    dwNumPorts: uint32
    dwPortFlags: uint32

  MPRAPI_TUNNEL_CONFIG_PARAMS1 {.bycopy.} = object
    IkeConfigParams: IKEV2_CONFIG_PARAMS
    PptpConfigParams: PPTP_CONFIG_PARAMS
    L2tpConfigParams: L2TP_CONFIG_PARAMS1
    SstpConfigParams: SSTP_CONFIG_PARAMS
    GREConfigParams: GRE_CONFIG_PARAMS0

  MPR_SERVER_EX1 {.bycopy.} = object
    Header: MPRAPI_OBJECT_HEADER
    fLanOnlyMode: uint32
    dwUpTime: uint32
    dwTotalPorts: uint32
    dwPortsInUse: uint32
    Reserved: uint32
    ConfigParams: MPRAPI_TUNNEL_CONFIG_PARAMS1

struct MPRAPI_OBJECT_HEADER
{
    ubyte revision;
    ubyte type;
    ushort size;
}

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct IKEV2_TUNNEL_CONFIG_PARAMS4
{
    uint dwIdleTimeout;
    uint dwNetworkBlackoutTime;
    uint dwSaLifeTime;
    uint dwSaDataSizeForRenegotiation;
    uint dwConfigOptions;
    uint dwTotalCertificates;
    void* certificateNames;
    CRYPT_INTEGER_BLOB machineCertificateName;
    uint dwEncryptionType;
    void* customPolicy;
    uint dwTotalEkus;
    void* certificateEKUs;
    CRYPT_INTEGER_BLOB machineCertificateHash;
    uint dwMmSaLifeTime;
}

struct IKEV2_CONFIG_PARAMS
{
    uint dwNumPorts;
    uint dwPortFlags;
    uint dwTunnelConfigParamFlags;
    IKEV2_TUNNEL_CONFIG_PARAMS4 TunnelConfigParams;
}

struct PPTP_CONFIG_PARAMS
{
    uint dwNumPorts;
    uint dwPortFlags;
}

struct L2TP_TUNNEL_CONFIG_PARAMS2
{
    uint dwIdleTimeout;
    uint dwEncryptionType;
    uint dwSaLifeTime;
    uint dwSaDataSizeForRenegotiation;
    void* customPolicy;
    uint dwMmSaLifeTime;
}

struct L2TP_CONFIG_PARAMS1
{
    uint dwNumPorts;
    uint dwPortFlags;
    uint dwTunnelConfigParamFlags;
    L2TP_TUNNEL_CONFIG_PARAMS2 TunnelConfigParams;
}

struct SSTP_CERT_INFO
{
    int isDefault;
    CRYPT_INTEGER_BLOB certBlob;
}

struct SSTP_CONFIG_PARAMS
{
    uint dwNumPorts;
    uint dwPortFlags;
    int isUseHttps;
    uint certAlgorithm;
    SSTP_CERT_INFO sstpCertDetails;
}

struct GRE_CONFIG_PARAMS0
{
    uint dwNumPorts;
    uint dwPortFlags;
}

struct MPRAPI_TUNNEL_CONFIG_PARAMS1
{
    IKEV2_CONFIG_PARAMS IkeConfigParams;
    PPTP_CONFIG_PARAMS PptpConfigParams;
    L2TP_CONFIG_PARAMS1 L2tpConfigParams;
    SSTP_CONFIG_PARAMS SstpConfigParams;
    GRE_CONFIG_PARAMS0 GREConfigParams;
}

struct MPR_SERVER_EX1
{
    MPRAPI_OBJECT_HEADER Header;
    uint fLanOnlyMode;
    uint dwUpTime;
    uint dwTotalPorts;
    uint dwPortsInUse;
    uint Reserved;
    MPRAPI_TUNNEL_CONFIG_PARAMS1 ConfigParams;
}

HSP用定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; MPR_SERVER_EX1 サイズ: 180 バイト(x86)
dim st, 45    ; 4byte整数×45(構造体サイズ 180 / 4 切り上げ)
; Header : MPRAPI_OBJECT_HEADER (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; fLanOnlyMode : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; dwUpTime : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; dwTotalPorts : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; dwPortsInUse : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; Reserved : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; ConfigParams : MPRAPI_TUNNEL_CONFIG_PARAMS1 (+24, 156byte)  varptr(st)+24 を基点に操作(156byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; MPR_SERVER_EX1 サイズ: 248 バイト(x64)
dim st, 62    ; 4byte整数×62(構造体サイズ 248 / 4 切り上げ)
; Header : MPRAPI_OBJECT_HEADER (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; fLanOnlyMode : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; dwUpTime : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; dwTotalPorts : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; dwPortsInUse : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; Reserved : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; ConfigParams : MPRAPI_TUNNEL_CONFIG_PARAMS1 (+24, 224byte)  varptr(st)+24 を基点に操作(224byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global MPRAPI_OBJECT_HEADER
    #field byte revision
    #field byte type
    #field short size
#endstruct

#defstruct global CRYPT_INTEGER_BLOB
    #field int cbData
    #field intptr pbData
#endstruct

#defstruct global IKEV2_TUNNEL_CONFIG_PARAMS4
    #field int dwIdleTimeout
    #field int dwNetworkBlackoutTime
    #field int dwSaLifeTime
    #field int dwSaDataSizeForRenegotiation
    #field int dwConfigOptions
    #field int dwTotalCertificates
    #field intptr certificateNames
    #field CRYPT_INTEGER_BLOB machineCertificateName
    #field int dwEncryptionType
    #field intptr customPolicy
    #field int dwTotalEkus
    #field intptr certificateEKUs
    #field CRYPT_INTEGER_BLOB machineCertificateHash
    #field int dwMmSaLifeTime
#endstruct

#defstruct global IKEV2_CONFIG_PARAMS
    #field int dwNumPorts
    #field int dwPortFlags
    #field int dwTunnelConfigParamFlags
    #field IKEV2_TUNNEL_CONFIG_PARAMS4 TunnelConfigParams
#endstruct

#defstruct global PPTP_CONFIG_PARAMS
    #field int dwNumPorts
    #field int dwPortFlags
#endstruct

#defstruct global L2TP_TUNNEL_CONFIG_PARAMS2
    #field int dwIdleTimeout
    #field int dwEncryptionType
    #field int dwSaLifeTime
    #field int dwSaDataSizeForRenegotiation
    #field intptr customPolicy
    #field int dwMmSaLifeTime
#endstruct

#defstruct global L2TP_CONFIG_PARAMS1
    #field int dwNumPorts
    #field int dwPortFlags
    #field int dwTunnelConfigParamFlags
    #field L2TP_TUNNEL_CONFIG_PARAMS2 TunnelConfigParams
#endstruct

#defstruct global SSTP_CERT_INFO
    #field bool isDefault
    #field CRYPT_INTEGER_BLOB certBlob
#endstruct

#defstruct global SSTP_CONFIG_PARAMS
    #field int dwNumPorts
    #field int dwPortFlags
    #field bool isUseHttps
    #field int certAlgorithm
    #field SSTP_CERT_INFO sstpCertDetails
#endstruct

#defstruct global GRE_CONFIG_PARAMS0
    #field int dwNumPorts
    #field int dwPortFlags
#endstruct

#defstruct global MPRAPI_TUNNEL_CONFIG_PARAMS1
    #field IKEV2_CONFIG_PARAMS IkeConfigParams
    #field PPTP_CONFIG_PARAMS PptpConfigParams
    #field L2TP_CONFIG_PARAMS1 L2tpConfigParams
    #field SSTP_CONFIG_PARAMS SstpConfigParams
    #field GRE_CONFIG_PARAMS0 GREConfigParams
#endstruct

#defstruct global MPR_SERVER_EX1
    #field MPRAPI_OBJECT_HEADER Header
    #field int fLanOnlyMode
    #field int dwUpTime
    #field int dwTotalPorts
    #field int dwPortsInUse
    #field int Reserved
    #field MPRAPI_TUNNEL_CONFIG_PARAMS1 ConfigParams
#endstruct

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

MPR_SERVER_EX1

フィールド

各言語での定義

HSP用 定義

HSP用定義