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

MIB_IPFORWARD_TABLE2

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 128 バイト / x86: 112 バイト

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

フィールド

フィールド型サイズx64x86説明
NumEntriesDWORD4+0+0Table配列に格納されたルートエントリの数を示す。
TableMIB_IPFORWARD_ROW2120/104+8+8IP転送ルート行(MIB_IPFORWARD_ROW2)の可変長配列である。

各言語での定義

#include <windows.h>

// NET_LUID_LH  (x64 8 / x86 8 バイト)
typedef struct NET_LUID_LH {
    ULONGLONG Value;
    _Info_e__Struct Info;
} NET_LUID_LH;

// IN_ADDR  (x64 8 / x86 4 バイト)
typedef struct IN_ADDR {
    _S_un_e__Union S_un;
} IN_ADDR;

// SOCKADDR_IN  (x64 24 / x86 16 バイト)
typedef struct SOCKADDR_IN {
    ADDRESS_FAMILY sin_family;
    WORD sin_port;
    IN_ADDR sin_addr;
    CHAR sin_zero[8];
} SOCKADDR_IN;

// IN6_ADDR  (x64 16 / x86 16 バイト)
typedef struct IN6_ADDR {
    _u_e__Union u;
} IN6_ADDR;

// SOCKADDR_IN6  (x64 32 / x86 28 バイト)
typedef struct SOCKADDR_IN6 {
    ADDRESS_FAMILY sin6_family;
    WORD sin6_port;
    DWORD sin6_flowinfo;
    IN6_ADDR sin6_addr;
    _Anonymous_e__Union Anonymous;
} SOCKADDR_IN6;

// SOCKADDR_INET  (x64 32 / x86 28 バイト)
typedef struct SOCKADDR_INET {
    SOCKADDR_IN Ipv4;
    SOCKADDR_IN6 Ipv6;
    ADDRESS_FAMILY si_family;
} SOCKADDR_INET;

// IP_ADDRESS_PREFIX  (x64 40 / x86 32 バイト)
typedef struct IP_ADDRESS_PREFIX {
    SOCKADDR_INET Prefix;
    BYTE PrefixLength;
} IP_ADDRESS_PREFIX;

// MIB_IPFORWARD_ROW2  (x64 120 / x86 104 バイト)
typedef struct MIB_IPFORWARD_ROW2 {
    NET_LUID_LH InterfaceLuid;
    DWORD InterfaceIndex;
    IP_ADDRESS_PREFIX DestinationPrefix;
    SOCKADDR_INET NextHop;
    BYTE SitePrefixLength;
    DWORD ValidLifetime;
    DWORD PreferredLifetime;
    DWORD Metric;
    NL_ROUTE_PROTOCOL Protocol;
    BOOLEAN Loopback;
    BOOLEAN AutoconfigureAddress;
    BOOLEAN Publish;
    BOOLEAN Immortal;
    DWORD Age;
    NL_ROUTE_ORIGIN Origin;
} MIB_IPFORWARD_ROW2;

// MIB_IPFORWARD_TABLE2  (x64 128 / x86 112 バイト)
typedef struct MIB_IPFORWARD_TABLE2 {
    DWORD NumEntries;
    MIB_IPFORWARD_ROW2 Table[1];
} MIB_IPFORWARD_TABLE2;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NET_LUID_LH
{
    public ulong Value;
    public _Info_e__Struct Info;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IN_ADDR
{
    public _S_un_e__Union S_un;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SOCKADDR_IN
{
    public ushort sin_family;
    public ushort sin_port;
    public IN_ADDR sin_addr;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public sbyte[] sin_zero;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IN6_ADDR
{
    public _u_e__Union u;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SOCKADDR_IN6
{
    public ushort sin6_family;
    public ushort sin6_port;
    public uint sin6_flowinfo;
    public IN6_ADDR sin6_addr;
    public _Anonymous_e__Union Anonymous;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SOCKADDR_INET
{
    public SOCKADDR_IN Ipv4;
    public SOCKADDR_IN6 Ipv6;
    public ushort si_family;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IP_ADDRESS_PREFIX
{
    public SOCKADDR_INET Prefix;
    public byte PrefixLength;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MIB_IPFORWARD_ROW2
{
    public NET_LUID_LH InterfaceLuid;
    public uint InterfaceIndex;
    public IP_ADDRESS_PREFIX DestinationPrefix;
    public SOCKADDR_INET NextHop;
    public byte SitePrefixLength;
    public uint ValidLifetime;
    public uint PreferredLifetime;
    public uint Metric;
    public int Protocol;
    [MarshalAs(UnmanagedType.U1)] public bool Loopback;
    [MarshalAs(UnmanagedType.U1)] public bool AutoconfigureAddress;
    [MarshalAs(UnmanagedType.U1)] public bool Publish;
    [MarshalAs(UnmanagedType.U1)] public bool Immortal;
    public uint Age;
    public int Origin;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MIB_IPFORWARD_TABLE2
{
    public uint NumEntries;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public MIB_IPFORWARD_ROW2[] Table;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NET_LUID_LH
    Public Value As ULong
    Public Info As _Info_e__Struct
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IN_ADDR
    Public S_un As _S_un_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SOCKADDR_IN
    Public sin_family As UShort
    Public sin_port As UShort
    Public sin_addr As IN_ADDR
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=8)> Public sin_zero() As SByte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IN6_ADDR
    Public u As _u_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SOCKADDR_IN6
    Public sin6_family As UShort
    Public sin6_port As UShort
    Public sin6_flowinfo As UInteger
    Public sin6_addr As IN6_ADDR
    Public Anonymous As _Anonymous_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SOCKADDR_INET
    Public Ipv4 As SOCKADDR_IN
    Public Ipv6 As SOCKADDR_IN6
    Public si_family As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IP_ADDRESS_PREFIX
    Public Prefix As SOCKADDR_INET
    Public PrefixLength As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MIB_IPFORWARD_ROW2
    Public InterfaceLuid As NET_LUID_LH
    Public InterfaceIndex As UInteger
    Public DestinationPrefix As IP_ADDRESS_PREFIX
    Public NextHop As SOCKADDR_INET
    Public SitePrefixLength As Byte
    Public ValidLifetime As UInteger
    Public PreferredLifetime As UInteger
    Public Metric As UInteger
    Public Protocol As Integer
    <MarshalAs(UnmanagedType.U1)> Public Loopback As Boolean
    <MarshalAs(UnmanagedType.U1)> Public AutoconfigureAddress As Boolean
    <MarshalAs(UnmanagedType.U1)> Public Publish As Boolean
    <MarshalAs(UnmanagedType.U1)> Public Immortal As Boolean
    Public Age As UInteger
    Public Origin As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MIB_IPFORWARD_TABLE2
    Public NumEntries As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Table() As MIB_IPFORWARD_ROW2
End Structure
import ctypes
from ctypes import wintypes

class NET_LUID_LH(ctypes.Structure):
    _fields_ = [
        ("Value", ctypes.c_ulonglong),
        ("Info", _Info_e__Struct),
    ]

class IN_ADDR(ctypes.Structure):
    _fields_ = [
        ("S_un", _S_un_e__Union),
    ]

class SOCKADDR_IN(ctypes.Structure):
    _fields_ = [
        ("sin_family", ctypes.c_ushort),
        ("sin_port", ctypes.c_ushort),
        ("sin_addr", IN_ADDR),
        ("sin_zero", ctypes.c_byte * 8),
    ]

class IN6_ADDR(ctypes.Structure):
    _fields_ = [
        ("u", _u_e__Union),
    ]

class SOCKADDR_IN6(ctypes.Structure):
    _fields_ = [
        ("sin6_family", ctypes.c_ushort),
        ("sin6_port", ctypes.c_ushort),
        ("sin6_flowinfo", wintypes.DWORD),
        ("sin6_addr", IN6_ADDR),
        ("Anonymous", _Anonymous_e__Union),
    ]

class SOCKADDR_INET(ctypes.Structure):
    _fields_ = [
        ("Ipv4", SOCKADDR_IN),
        ("Ipv6", SOCKADDR_IN6),
        ("si_family", ctypes.c_ushort),
    ]

class IP_ADDRESS_PREFIX(ctypes.Structure):
    _fields_ = [
        ("Prefix", SOCKADDR_INET),
        ("PrefixLength", ctypes.c_ubyte),
    ]

class MIB_IPFORWARD_ROW2(ctypes.Structure):
    _fields_ = [
        ("InterfaceLuid", NET_LUID_LH),
        ("InterfaceIndex", wintypes.DWORD),
        ("DestinationPrefix", IP_ADDRESS_PREFIX),
        ("NextHop", SOCKADDR_INET),
        ("SitePrefixLength", ctypes.c_ubyte),
        ("ValidLifetime", wintypes.DWORD),
        ("PreferredLifetime", wintypes.DWORD),
        ("Metric", wintypes.DWORD),
        ("Protocol", ctypes.c_int),
        ("Loopback", ctypes.c_byte),
        ("AutoconfigureAddress", ctypes.c_byte),
        ("Publish", ctypes.c_byte),
        ("Immortal", ctypes.c_byte),
        ("Age", wintypes.DWORD),
        ("Origin", ctypes.c_int),
    ]

class MIB_IPFORWARD_TABLE2(ctypes.Structure):
    _fields_ = [
        ("NumEntries", wintypes.DWORD),
        ("Table", MIB_IPFORWARD_ROW2 * 1),
    ]
#[repr(C)]
pub struct NET_LUID_LH {
    pub Value: u64,
    pub Info: _Info_e__Struct,
}

#[repr(C)]
pub struct IN_ADDR {
    pub S_un: _S_un_e__Union,
}

#[repr(C)]
pub struct SOCKADDR_IN {
    pub sin_family: u16,
    pub sin_port: u16,
    pub sin_addr: IN_ADDR,
    pub sin_zero: [i8; 8],
}

#[repr(C)]
pub struct IN6_ADDR {
    pub u: _u_e__Union,
}

#[repr(C)]
pub struct SOCKADDR_IN6 {
    pub sin6_family: u16,
    pub sin6_port: u16,
    pub sin6_flowinfo: u32,
    pub sin6_addr: IN6_ADDR,
    pub Anonymous: _Anonymous_e__Union,
}

#[repr(C)]
pub struct SOCKADDR_INET {
    pub Ipv4: SOCKADDR_IN,
    pub Ipv6: SOCKADDR_IN6,
    pub si_family: u16,
}

#[repr(C)]
pub struct IP_ADDRESS_PREFIX {
    pub Prefix: SOCKADDR_INET,
    pub PrefixLength: u8,
}

#[repr(C)]
pub struct MIB_IPFORWARD_ROW2 {
    pub InterfaceLuid: NET_LUID_LH,
    pub InterfaceIndex: u32,
    pub DestinationPrefix: IP_ADDRESS_PREFIX,
    pub NextHop: SOCKADDR_INET,
    pub SitePrefixLength: u8,
    pub ValidLifetime: u32,
    pub PreferredLifetime: u32,
    pub Metric: u32,
    pub Protocol: i32,
    pub Loopback: u8,
    pub AutoconfigureAddress: u8,
    pub Publish: u8,
    pub Immortal: u8,
    pub Age: u32,
    pub Origin: i32,
}

#[repr(C)]
pub struct MIB_IPFORWARD_TABLE2 {
    pub NumEntries: u32,
    pub Table: [MIB_IPFORWARD_ROW2; 1],
}
import "golang.org/x/sys/windows"

type NET_LUID_LH struct {
	Value uint64
	Info _Info_e__Struct
}

type IN_ADDR struct {
	S_un _S_un_e__Union
}

type SOCKADDR_IN struct {
	sin_family uint16
	sin_port uint16
	sin_addr IN_ADDR
	sin_zero [8]int8
}

type IN6_ADDR struct {
	u _u_e__Union
}

type SOCKADDR_IN6 struct {
	sin6_family uint16
	sin6_port uint16
	sin6_flowinfo uint32
	sin6_addr IN6_ADDR
	Anonymous _Anonymous_e__Union
}

type SOCKADDR_INET struct {
	Ipv4 SOCKADDR_IN
	Ipv6 SOCKADDR_IN6
	si_family uint16
}

type IP_ADDRESS_PREFIX struct {
	Prefix SOCKADDR_INET
	PrefixLength byte
}

type MIB_IPFORWARD_ROW2 struct {
	InterfaceLuid NET_LUID_LH
	InterfaceIndex uint32
	DestinationPrefix IP_ADDRESS_PREFIX
	NextHop SOCKADDR_INET
	SitePrefixLength byte
	ValidLifetime uint32
	PreferredLifetime uint32
	Metric uint32
	Protocol int32
	Loopback byte
	AutoconfigureAddress byte
	Publish byte
	Immortal byte
	Age uint32
	Origin int32
}

type MIB_IPFORWARD_TABLE2 struct {
	NumEntries uint32
	Table [1]MIB_IPFORWARD_ROW2
}
type
  NET_LUID_LH = record
    Value: UInt64;
    Info: _Info_e__Struct;
  end;

  IN_ADDR = record
    S_un: _S_un_e__Union;
  end;

  SOCKADDR_IN = record
    sin_family: Word;
    sin_port: Word;
    sin_addr: IN_ADDR;
    sin_zero: array[0..7] of Shortint;
  end;

  IN6_ADDR = record
    u: _u_e__Union;
  end;

  SOCKADDR_IN6 = record
    sin6_family: Word;
    sin6_port: Word;
    sin6_flowinfo: DWORD;
    sin6_addr: IN6_ADDR;
    Anonymous: _Anonymous_e__Union;
  end;

  SOCKADDR_INET = record
    Ipv4: SOCKADDR_IN;
    Ipv6: SOCKADDR_IN6;
    si_family: Word;
  end;

  IP_ADDRESS_PREFIX = record
    Prefix: SOCKADDR_INET;
    PrefixLength: Byte;
  end;

  MIB_IPFORWARD_ROW2 = record
    InterfaceLuid: NET_LUID_LH;
    InterfaceIndex: DWORD;
    DestinationPrefix: IP_ADDRESS_PREFIX;
    NextHop: SOCKADDR_INET;
    SitePrefixLength: Byte;
    ValidLifetime: DWORD;
    PreferredLifetime: DWORD;
    Metric: DWORD;
    Protocol: Integer;
    Loopback: ByteBool;
    AutoconfigureAddress: ByteBool;
    Publish: ByteBool;
    Immortal: ByteBool;
    Age: DWORD;
    Origin: Integer;
  end;

  MIB_IPFORWARD_TABLE2 = record
    NumEntries: DWORD;
    Table: array[0..0] of MIB_IPFORWARD_ROW2;
  end;
const NET_LUID_LH = extern struct {
    Value: u64,
    Info: _Info_e__Struct,
};

const IN_ADDR = extern struct {
    S_un: _S_un_e__Union,
};

const SOCKADDR_IN = extern struct {
    sin_family: u16,
    sin_port: u16,
    sin_addr: IN_ADDR,
    sin_zero: [8]i8,
};

const IN6_ADDR = extern struct {
    u: _u_e__Union,
};

const SOCKADDR_IN6 = extern struct {
    sin6_family: u16,
    sin6_port: u16,
    sin6_flowinfo: u32,
    sin6_addr: IN6_ADDR,
    Anonymous: _Anonymous_e__Union,
};

const SOCKADDR_INET = extern struct {
    Ipv4: SOCKADDR_IN,
    Ipv6: SOCKADDR_IN6,
    si_family: u16,
};

const IP_ADDRESS_PREFIX = extern struct {
    Prefix: SOCKADDR_INET,
    PrefixLength: u8,
};

const MIB_IPFORWARD_ROW2 = extern struct {
    InterfaceLuid: NET_LUID_LH,
    InterfaceIndex: u32,
    DestinationPrefix: IP_ADDRESS_PREFIX,
    NextHop: SOCKADDR_INET,
    SitePrefixLength: u8,
    ValidLifetime: u32,
    PreferredLifetime: u32,
    Metric: u32,
    Protocol: i32,
    Loopback: u8,
    AutoconfigureAddress: u8,
    Publish: u8,
    Immortal: u8,
    Age: u32,
    Origin: i32,
};

const MIB_IPFORWARD_TABLE2 = extern struct {
    NumEntries: u32,
    Table: [1]MIB_IPFORWARD_ROW2,
};
type
  NET_LUID_LH {.bycopy.} = object
    Value: uint64
    Info: _Info_e__Struct

  IN_ADDR {.bycopy.} = object
    S_un: _S_un_e__Union

  SOCKADDR_IN {.bycopy.} = object
    sin_family: uint16
    sin_port: uint16
    sin_addr: IN_ADDR
    sin_zero: array[8, int8]

  IN6_ADDR {.bycopy.} = object
    u: _u_e__Union

  SOCKADDR_IN6 {.bycopy.} = object
    sin6_family: uint16
    sin6_port: uint16
    sin6_flowinfo: uint32
    sin6_addr: IN6_ADDR
    Anonymous: _Anonymous_e__Union

  SOCKADDR_INET {.bycopy.} = object
    Ipv4: SOCKADDR_IN
    Ipv6: SOCKADDR_IN6
    si_family: uint16

  IP_ADDRESS_PREFIX {.bycopy.} = object
    Prefix: SOCKADDR_INET
    PrefixLength: uint8

  MIB_IPFORWARD_ROW2 {.bycopy.} = object
    InterfaceLuid: NET_LUID_LH
    InterfaceIndex: uint32
    DestinationPrefix: IP_ADDRESS_PREFIX
    NextHop: SOCKADDR_INET
    SitePrefixLength: uint8
    ValidLifetime: uint32
    PreferredLifetime: uint32
    Metric: uint32
    Protocol: int32
    Loopback: uint8
    AutoconfigureAddress: uint8
    Publish: uint8
    Immortal: uint8
    Age: uint32
    Origin: int32

  MIB_IPFORWARD_TABLE2 {.bycopy.} = object
    NumEntries: uint32
    Table: array[1, MIB_IPFORWARD_ROW2]
struct NET_LUID_LH
{
    ulong Value;
    _Info_e__Struct Info;
}

struct IN_ADDR
{
    _S_un_e__Union S_un;
}

struct SOCKADDR_IN
{
    ushort sin_family;
    ushort sin_port;
    IN_ADDR sin_addr;
    byte[8] sin_zero;
}

struct IN6_ADDR
{
    _u_e__Union u;
}

struct SOCKADDR_IN6
{
    ushort sin6_family;
    ushort sin6_port;
    uint sin6_flowinfo;
    IN6_ADDR sin6_addr;
    _Anonymous_e__Union Anonymous;
}

struct SOCKADDR_INET
{
    SOCKADDR_IN Ipv4;
    SOCKADDR_IN6 Ipv6;
    ushort si_family;
}

struct IP_ADDRESS_PREFIX
{
    SOCKADDR_INET Prefix;
    ubyte PrefixLength;
}

struct MIB_IPFORWARD_ROW2
{
    NET_LUID_LH InterfaceLuid;
    uint InterfaceIndex;
    IP_ADDRESS_PREFIX DestinationPrefix;
    SOCKADDR_INET NextHop;
    ubyte SitePrefixLength;
    uint ValidLifetime;
    uint PreferredLifetime;
    uint Metric;
    int Protocol;
    ubyte Loopback;
    ubyte AutoconfigureAddress;
    ubyte Publish;
    ubyte Immortal;
    uint Age;
    int Origin;
}

struct MIB_IPFORWARD_TABLE2
{
    uint NumEntries;
    MIB_IPFORWARD_ROW2[1] Table;
}

HSP用 定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; MIB_IPFORWARD_TABLE2 サイズ: 112 バイト(x86)
dim st, 28    ; 4byte整数×28(構造体サイズ 112 / 4 切り上げ)
; NumEntries : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; Table : MIB_IPFORWARD_ROW2 (+8, 104byte)  varptr(st)+8 を基点に操作(104byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; MIB_IPFORWARD_TABLE2 サイズ: 128 バイト(x64)
dim st, 32    ; 4byte整数×32(構造体サイズ 128 / 4 切り上げ)
; NumEntries : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; Table : MIB_IPFORWARD_ROW2 (+8, 120byte)  varptr(st)+8 を基点に操作(120byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global IP_ADDRESS_PREFIX
    #field byte Prefix 32
    #field byte PrefixLength
#endstruct

#defstruct global MIB_IPFORWARD_ROW2
    #field byte InterfaceLuid 8
    #field int InterfaceIndex
    #field IP_ADDRESS_PREFIX DestinationPrefix
    #field byte NextHop 32
    #field byte SitePrefixLength
    #field int ValidLifetime
    #field int PreferredLifetime
    #field int Metric
    #field int Protocol
    #field bool1 Loopback
    #field bool1 AutoconfigureAddress
    #field bool1 Publish
    #field bool1 Immortal
    #field int Age
    #field int Origin
#endstruct

#defstruct global MIB_IPFORWARD_TABLE2
    #field int NumEntries
    #field MIB_IPFORWARD_ROW2 Table 1
#endstruct

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