616 lines
20 KiB
C
616 lines
20 KiB
C
//============================================================================
|
|
// Copyright (c) 1995, Microsoft Corporation
|
|
//
|
|
// File: ipriprm.h
|
|
//
|
|
// History:
|
|
// Abolade Gbadegesin Aug-7-1995 Created.
|
|
//
|
|
// Contains type definitions and declarations for IP RIP,
|
|
// used by the IP Router Manager.
|
|
//============================================================================
|
|
|
|
#ifndef _IPRIPRM_H_
|
|
#define _IPRIPRM_H_
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// CONSTANT AND MACRO DECLARATIONS
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants identifying IPRIP's MIB tables
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_GLOBAL_STATS_ID 0
|
|
#define IPRIP_GLOBAL_CONFIG_ID 1
|
|
#define IPRIP_IF_STATS_ID 2
|
|
#define IPRIP_IF_CONFIG_ID 3
|
|
#define IPRIP_IF_BINDING_ID 4
|
|
#define IPRIP_PEER_STATS_ID 5
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants used for the field IPRIP_GLOBAL_CONFIG::GC_LoggingLevel
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_LOGGING_NONE 0
|
|
#define IPRIP_LOGGING_ERROR 1
|
|
#define IPRIP_LOGGING_WARN 2
|
|
#define IPRIP_LOGGING_INFO 3
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants used for the following fields:
|
|
// IPRIP_GLOBAL_CONFIG::GC_PeerFilterMode,
|
|
// IPRIP_IF_CONFIG::IC_AcceptFilterMode, and
|
|
// IPRIP_IF_CONFIG::IC_AnnounceFilterMode
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_FILTER_DISABLED 0
|
|
#define IPRIP_FILTER_INCLUDE 1
|
|
#define IPRIP_FILTER_EXCLUDE 2
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants used for the fields
|
|
// IPRIP_IF_STATS::IS_State, IPRIP_IF_CONFIG::IC_State and
|
|
// IPRIP_IF_BINDING::IB_State
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_STATE_ENABLED 0x00000001
|
|
#define IPRIP_STATE_BOUND 0x00000002
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constant for the field IPRIP_IF_CONFIG::IC_AuthenticationKey;
|
|
// defines maximum authentication key size
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_MAX_AUTHKEY_SIZE 16
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants used to construct the field IPRIP_IF_CONFIG::IC_ProtocolFlags
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_FLAG_ACCEPT_HOST_ROUTES 0x00000001
|
|
#define IPRIP_FLAG_ANNOUNCE_HOST_ROUTES 0x00000002
|
|
#define IPRIP_FLAG_ACCEPT_DEFAULT_ROUTES 0x00000004
|
|
#define IPRIP_FLAG_ANNOUNCE_DEFAULT_ROUTES 0x00000008
|
|
#define IPRIP_FLAG_SPLIT_HORIZON 0x00000010
|
|
#define IPRIP_FLAG_POISON_REVERSE 0x00000020
|
|
#define IPRIP_FLAG_GRACEFUL_SHUTDOWN 0x00000040
|
|
#define IPRIP_FLAG_TRIGGERED_UPDATES 0x00000080
|
|
#define IPRIP_FLAG_OVERWRITE_STATIC_ROUTES 0x00000100
|
|
#define IPRIP_FLAG_NO_SUBNET_SUMMARY 0x00000200
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants for the field IPRIP_IF_CONFIG::IC_UpdateMode
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_UPDATE_PERIODIC 0
|
|
#define IPRIP_UPDATE_DEMAND 1
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants for the field IPRIP_IF_CONFIG::IC_AcceptMode
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_ACCEPT_DISABLED 0
|
|
#define IPRIP_ACCEPT_RIP1 1
|
|
#define IPRIP_ACCEPT_RIP1_COMPAT 2
|
|
#define IPRIP_ACCEPT_RIP2 3
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants for the field IPRIP_IF_CONFIG::IC_AnnounceMode
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_ANNOUNCE_DISABLED 0
|
|
#define IPRIP_ANNOUNCE_RIP1 1
|
|
#define IPRIP_ANNOUNCE_RIP1_COMPAT 2
|
|
#define IPRIP_ANNOUNCE_RIP2 3
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants for the field IPRIP_IF_CONFIG::IC_AuthenticationType
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_AUTHTYPE_NONE 1
|
|
#define IPRIP_AUTHTYPE_SIMPLE_PASSWORD 2
|
|
#define IPRIP_AUTHTYPE_MD5 3
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// constants for the field IPRIP_IF_CONFIG::IC_UnicastPeerMode
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_PEER_DISABLED 0
|
|
#define IPRIP_PEER_ALSO 1
|
|
#define IPRIP_PEER_ONLY 2
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// macros for manipulating the variable length IPRIP_GLOBAL_CONFIG structure
|
|
//
|
|
// IPRIP_GLOBAL_CONFIG_SIZE computes the size of a global config struct
|
|
//
|
|
// IPRIP_GLOBAL_PEER_FILTER_TABLE computes the starting address
|
|
// of the series of peer IP addresses which comprise
|
|
// the peer filter table in a global config struct
|
|
//
|
|
// e.g.
|
|
// PIPRIP_GLOBAL_CONFIG pigcSource, pigcDest;
|
|
//
|
|
// pigcDest = malloc(IPRIP_GLOBAL_CONFIG_SIZE(pigcSource));
|
|
// memcpy(pigcDest, pigcSource, IPRIP_GLOBAL_CONFIG_SIZE(pigcSource));
|
|
//
|
|
// e.g.
|
|
// DWORD i, *pdwPeer;
|
|
// PIPRIP_GLOBAL_CONFIG pigc;
|
|
//
|
|
// pdwPeer = IPRIP_GLOBAL_PEER_FILTER_TABLE(pigc);
|
|
// for (i = 0; i < pigc->GC_PeerFilterCount; i++, pdwPeer++) {
|
|
// printf("%s\n", inet_ntoa(*(struct in_addr *)pdwPeer));
|
|
// }
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_GLOBAL_CONFIG_SIZE(cfg) \
|
|
(sizeof(IPRIP_GLOBAL_CONFIG) + \
|
|
(cfg)->GC_PeerFilterCount * sizeof(DWORD))
|
|
|
|
#define IPRIP_GLOBAL_PEER_FILTER_TABLE(cfg) ((PDWORD)((cfg) + 1))
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// macros used for manipulating the field IPRIP_IF_CONFIG::IC_ProtocolFlags;
|
|
//
|
|
// IPRIP_FLAG_ENABLE enables a flag in a config structure
|
|
//
|
|
// IPRIP_FLAG_DISABLE disables a flag in a config structure
|
|
//
|
|
// IPRIP_FLAG_IS_ENABLED evaluates to non-zero if a given flag is enabled
|
|
// in a config structure
|
|
//
|
|
// IPRIP_FLAG_IS_DISABLED evaluates to non-zero if a given flag is disabled
|
|
// in a config structure
|
|
//
|
|
// e.g.
|
|
// IPRIP_IF_CONFIG iic;
|
|
// IPRIP_FLAG_ENABLE(&iic, ACCEPT_HOST_ROUTES);
|
|
//
|
|
// e.g.
|
|
// IPRIP_IF_CONFIG iic;
|
|
// printf((IPRIP_FLAG_IS_ENABLED(&iic, SPLIT_HORIZON) ? "split" : ""));
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_FLAG_ENABLE(iic, flag) \
|
|
((iic)->IC_ProtocolFlags |= IPRIP_FLAG_ ## flag)
|
|
#define IPRIP_FLAG_DISABLE(iic, flag) \
|
|
((iic)->IC_ProtocolFlags &= ~ (IPRIP_FLAG_ ## flag))
|
|
#define IPRIP_FLAG_IS_ENABLED(iic, flag) \
|
|
((iic)->IC_ProtocolFlags & IPRIP_FLAG_ ## flag)
|
|
#define IPRIP_FLAG_IS_DISABLED(iic, flag) \
|
|
!IPRIP_FLAG_IS_ENABLED(iic, flag)
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// macros for manipulating the variable-length IPRIP_IF_CONFIG structure
|
|
//
|
|
// IPRIP_IF_CONFIG_SIZE computes the size of a config structure.
|
|
//
|
|
// IPRIP_IF_UNICAST_PEER_TABLE computes the starting address
|
|
// in a config struct of the series of IP addresses for peers
|
|
// to whom routes are to be sent by unicast.
|
|
//
|
|
// IPRIP_IF_CONFIG_ACCEPT_FILTER_TABLE computes the starting address
|
|
// of the series of route-acceptance filters in a config structure.
|
|
//
|
|
// IPRIP_IF_CONFIG_ANNOUNCE_FILTER_TABLE computes the starting address
|
|
// of the series of route-announcement filters in a config structure.
|
|
//
|
|
// e.g.
|
|
// PIPRIP_IF_CONFIG piicSource, piicDest;
|
|
//
|
|
// piicDest = malloc(IPRIP_IF_CONFIG_SIZE(piicSource));
|
|
// memcpy(piicDest, piicSource, IPRIP_IF_CONFIG_SIZE(piicSource));
|
|
//
|
|
// e.g.
|
|
// DWORD i, *pdwPeer;
|
|
// PIPRIP_IF_CONFIG piic;
|
|
//
|
|
// pdwPeer = IPRIP_IF_UNICAST_PEER_TABLE(piic);
|
|
// for (i = 0; i < piic->IC_UnicastPeerCount; i++) {
|
|
// printf("%s\n", inet_ntoa(*(struct in_addr *)pdwPeer));
|
|
// }
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_IF_CONFIG_SIZE(cfg) \
|
|
(sizeof(IPRIP_IF_CONFIG) + \
|
|
(cfg)->IC_UnicastPeerCount * sizeof(DWORD) + \
|
|
(cfg)->IC_AcceptFilterCount * sizeof(IPRIP_ROUTE_FILTER) + \
|
|
(cfg)->IC_AnnounceFilterCount * sizeof(IPRIP_ROUTE_FILTER))
|
|
|
|
#define IPRIP_IF_UNICAST_PEER_TABLE(cfg) ((PDWORD)((cfg) + 1))
|
|
|
|
#define IPRIP_IF_ACCEPT_FILTER_TABLE(cfg) \
|
|
((PIPRIP_ROUTE_FILTER)( \
|
|
IPRIP_IF_UNICAST_PEER_TABLE(cfg) + (cfg)->IC_UnicastPeerCount ))
|
|
|
|
#define IPRIP_IF_ANNOUNCE_FILTER_TABLE(cfg) \
|
|
((PIPRIP_ROUTE_FILTER)( \
|
|
IPRIP_IF_ACCEPT_FILTER_TABLE(cfg) + (cfg)->IC_AcceptFilterCount ))
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// macros for manipulating the variable-length IPRIP_IF_BINDING structure
|
|
//
|
|
// IPRIP_IF_BINDING_SIZE computes the size of a binding structure.
|
|
//
|
|
// IPRIP_IF_ADDRESS_TABLE computes the starting address in a binding struct
|
|
// of the series of IPRIP_IP_ADDRESS structures which are the bindings
|
|
// for the interface in question.
|
|
//
|
|
// e.g.
|
|
// PIPRIP_IF_BINDING piibSource, piibDest;
|
|
//
|
|
// piibDest = malloc(IPRIP_IF_BINDING_SIZE(piicSource));
|
|
// memcpy(piibDest, piicSource, IPRIP_IF_BINDING_SIZE(piicSource));
|
|
//
|
|
// e.g.
|
|
// DWORD i;
|
|
// PIPRIP_IF_BINDING piib;
|
|
// PIPRIP_IP_ADDRESS *pdwAddr;
|
|
//
|
|
// pdwAddr = IPRIP_IF_ADDRESS_TABLE(piib);
|
|
// for (i = 0; i < piib->IB_AddrCount; i++) {
|
|
// printf("%s-", inet_ntoa(*(struct in_addr *)&pdwAddr->IA_Address));
|
|
// printf("%s\n", inet_ntoa(*(struct in_addr *)&pdwAddr->IA_Netmask));
|
|
// }
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define IPRIP_IF_BINDING_SIZE(bind) \
|
|
(sizeof(IPRIP_IF_BINDING) + \
|
|
(bind)->IB_AddrCount * sizeof(IPRIP_IP_ADDRESS))
|
|
|
|
#define IPRIP_IF_ADDRESS_TABLE(bind) ((PIPRIP_IP_ADDRESS)((bind) + 1))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// STRUCTURE DEFINITIONS
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_GLOBAL_STATS
|
|
//
|
|
// This MIB entry stores global statistics for IPRIP;
|
|
// There is only one instance, so this entry has no index.
|
|
//
|
|
// This structure is read-only.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_GLOBAL_STATS {
|
|
|
|
DWORD GS_SystemRouteChanges;
|
|
DWORD GS_TotalResponsesSent;
|
|
|
|
} IPRIP_GLOBAL_STATS, *PIPRIP_GLOBAL_STATS;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_GLOBAL_CONFIG
|
|
//
|
|
// This MIB entry stores global configuration for IPRIP
|
|
// There is only one instance, so this entry has no index.
|
|
//
|
|
// THIS STRUCTURE IS VARIABLE LENGTH:
|
|
//
|
|
// after the base structure comes an array of GC_PeerFilterCount DWORDs,
|
|
// each of which contains an IP address which is a peer which will be
|
|
// accepted or rejected depending on the value of GC_PeerFilterMode.
|
|
//
|
|
// Thus, if GC_PeerFilterMode is IPRIP_FILTER_EXCLUDE, routes will be
|
|
// rejected which come from the routers whose addresses are in the peer array,
|
|
// and all other routers will be accepted.
|
|
//
|
|
// Likewise, if GC_PeerFilterMode is IPRIP_FILTER_INCLUDE, routes will
|
|
// be only be accepted if they are from the routers in the peer array.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_GLOBAL_CONFIG {
|
|
|
|
DWORD GC_LoggingLevel;
|
|
DWORD GC_MaxRecvQueueSize;
|
|
DWORD GC_MaxSendQueueSize;
|
|
DWORD GC_MinTriggeredUpdateInterval;
|
|
DWORD GC_PeerFilterMode;
|
|
DWORD GC_PeerFilterCount;
|
|
|
|
} IPRIP_GLOBAL_CONFIG, *PIPRIP_GLOBAL_CONFIG;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_IF_STATS
|
|
//
|
|
// This MIB entry stores per-interface statistics for IPRIP.
|
|
//
|
|
// This structure is read-only.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_IF_STATS {
|
|
|
|
DWORD IS_State;
|
|
DWORD IS_SendFailures;
|
|
DWORD IS_ReceiveFailures;
|
|
DWORD IS_RequestsSent;
|
|
DWORD IS_RequestsReceived;
|
|
DWORD IS_ResponsesSent;
|
|
DWORD IS_ResponsesReceived;
|
|
DWORD IS_BadResponsePacketsReceived;
|
|
DWORD IS_BadResponseEntriesReceived;
|
|
DWORD IS_TriggeredUpdatesSent;
|
|
|
|
} IPRIP_IF_STATS, *PIPRIP_IF_STATS;
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_IF_CONFIG
|
|
//
|
|
// This MIB entry describes per-interface configuration.
|
|
// All IP address fields must be in network order.
|
|
//
|
|
// Note:
|
|
// The field IC_State is read-only.
|
|
// The field IC_AuthenticationKey is write-only.
|
|
//
|
|
// THIS STRUCTURE IS VARIABLE LENGTH:
|
|
//
|
|
// after the base structure comes
|
|
//
|
|
// 1. the table of unicast peers configured for this interface,
|
|
// with each entry being a DWORD containing an IP address, where a
|
|
// unicast peer is a router to which updates will be unicast;
|
|
// if IC_UnicastPeerMode is IPRIP_PEER_ONLY, RIP packets will only
|
|
// be sent to these peers; if IC_UnicastPeerMode is IPRIP_PEER_ALSO,
|
|
// RIP packets will be sent to these peers as well as being sent
|
|
// via broadcast/multicast.
|
|
//
|
|
// 2. the table of filters used to filter routes before accepting them,
|
|
// with each entry being of type IPRIP_ROUTE_FILTER.
|
|
// The use of these depends on the rule in IC_AcceptFilterMode. Thus
|
|
// if IC_AcceptFilterMode is IPRIP_FILTER_INCLUDE, these filters specify
|
|
// which routes to include, and all other routes are excluded.
|
|
//
|
|
// 3. the table of filters used to filter routes before announcing them,
|
|
// with each entry being of type IPRIP_ROUTE_FILTER;
|
|
// The use of these depend on the rule in IC_AnnounceFilterMode. Thus
|
|
// if IC_AnnounceFilterMode is IPRIP_FILTER_INCLUDE, these filters
|
|
// specify which routes to include, and all other routes are excluded.
|
|
//
|
|
// IC_UnicastPeerCount, IC_AcceptFilterCount, and IC_AnnounceFilterCount
|
|
// give the counts of entries in each of the above tables.
|
|
//
|
|
// If the interface type is PERMANENT, then routing information will
|
|
// be broadcast AND sent by unicast to the routers in the unicast peer table.
|
|
// Otherwise, routing information will only be unicast to the routers in the
|
|
// unicast peer table.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_IF_CONFIG {
|
|
|
|
DWORD IC_State;
|
|
DWORD IC_Metric;
|
|
DWORD IC_UpdateMode;
|
|
DWORD IC_AcceptMode;
|
|
DWORD IC_AnnounceMode;
|
|
DWORD IC_ProtocolFlags;
|
|
DWORD IC_RouteExpirationInterval;
|
|
DWORD IC_RouteRemovalInterval;
|
|
DWORD IC_FullUpdateInterval;
|
|
DWORD IC_AuthenticationType;
|
|
BYTE IC_AuthenticationKey[IPRIP_MAX_AUTHKEY_SIZE];
|
|
WORD IC_RouteTag;
|
|
DWORD IC_UnicastPeerMode;
|
|
DWORD IC_AcceptFilterMode;
|
|
DWORD IC_AnnounceFilterMode;
|
|
DWORD IC_UnicastPeerCount;
|
|
DWORD IC_AcceptFilterCount;
|
|
DWORD IC_AnnounceFilterCount;
|
|
|
|
} IPRIP_IF_CONFIG, *PIPRIP_IF_CONFIG;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_ROUTE_FILTER
|
|
//
|
|
// This is used for per-interface filters in the structure IPRIP_IF_CONFIG
|
|
//
|
|
// Each filter describes an instance of the default filter action;
|
|
// if the default accept filter action is IPRIP_FILTER_INCLUDE,
|
|
// then each of the accept filters in the filter table will be treated
|
|
// as an inclusion range. If an interface's default announce filter action is
|
|
// IPRIP_FILTER_EXCLUDE, then each of that interface's announce filters
|
|
// will be treated as an exclusion range.
|
|
//
|
|
// Both the low and high IP addresses must be in network order.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_ROUTE_FILTER {
|
|
|
|
DWORD RF_LoAddress;
|
|
DWORD RF_HiAddress;
|
|
|
|
} IPRIP_ROUTE_FILTER, *PIPRIP_ROUTE_FILTER;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_IF_BINDING
|
|
//
|
|
// This MIB entry contains the table of IP addresses to which each interface
|
|
// is bound.
|
|
// All IP addresses are in network order.
|
|
//
|
|
// THIS STRUCTURE IS VARIABLE LENGTH:
|
|
//
|
|
// The base structure contains of the field IB_AddrCount, which gives
|
|
// the number of IP addresses to which the indexed interface is bound.
|
|
// The IP addresses themselves follow the base structure, and are given
|
|
// as IPRIP_IP_ADDRESS structures.
|
|
//
|
|
// This MIB entry is read-only.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_IF_BINDING {
|
|
|
|
DWORD IB_State;
|
|
DWORD IB_AddrCount;
|
|
|
|
} IPRIP_IF_BINDING, *PIPRIP_IF_BINDING;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_IP_ADDRESS
|
|
//
|
|
// This structure is used for storing interface bindings.
|
|
// A series of structures of this type follows the IPRIP_IF_BINDING
|
|
// structure (described above).
|
|
//
|
|
// Both fields are IP address fields in network-order.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_IP_ADDRESS {
|
|
|
|
DWORD IA_Address;
|
|
DWORD IA_Netmask;
|
|
|
|
} IPRIP_IP_ADDRESS, *PIPRIP_IP_ADDRESS;
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_PEER_STATS
|
|
//
|
|
// This MIB entry describes statistics kept about neighboring routers.
|
|
// All IP addresses are in network order.
|
|
//
|
|
// This structure is read-only.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_PEER_STATS {
|
|
|
|
DWORD PS_LastPeerRouteTag;
|
|
DWORD PS_LastPeerUpdateTickCount;
|
|
DWORD PS_LastPeerUpdateVersion;
|
|
DWORD PS_BadResponsePacketsFromPeer;
|
|
DWORD PS_BadResponseEntriesFromPeer;
|
|
|
|
} IPRIP_PEER_STATS, *PIPRIP_PEER_STATS;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_MIB_SET_INPUT_DATA
|
|
//
|
|
// This is passed as input data for MibSet.
|
|
// Note that only global config and interface config can be set.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_MIB_SET_INPUT_DATA {
|
|
|
|
DWORD IMSID_TypeID;
|
|
DWORD IMSID_IfIndex;
|
|
DWORD IMSID_BufferSize;
|
|
BYTE IMSID_Buffer[1];
|
|
|
|
} IPRIP_MIB_SET_INPUT_DATA, *PIPRIP_MIB_SET_INPUT_DATA;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_MIB_GET_INPUT_DATA
|
|
//
|
|
// This is passed as input data for MibGet, MibGetFirst, MibGetNext.
|
|
// All tables are readable.
|
|
// These and all other IP addresses must be in network order.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_MIB_GET_INPUT_DATA {
|
|
|
|
DWORD IMGID_TypeID;
|
|
union {
|
|
DWORD IMGID_IfIndex;
|
|
DWORD IMGID_PeerAddress;
|
|
};
|
|
|
|
} IPRIP_MIB_GET_INPUT_DATA, *PIPRIP_MIB_GET_INPUT_DATA;
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// struct: IPRIP_MIB_GET_OUTPUT_DATA
|
|
//
|
|
// This is written into the output data by MibGet, MibGetFirst, MibGetNext.
|
|
// Note that at the end of a table MibGetNext wraps to the next table,
|
|
// and therefore the value IMGOD_TypeID should be examined to see the
|
|
// type of the data returned in the output buffer.
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _IPRIP_MIB_GET_OUTPUT_DATA {
|
|
|
|
DWORD IMGOD_TypeID;
|
|
union {
|
|
DWORD IMGOD_IfIndex;
|
|
DWORD IMGOD_PeerAddress;
|
|
};
|
|
BYTE IMGOD_Buffer[1];
|
|
|
|
} IPRIP_MIB_GET_OUTPUT_DATA, *PIPRIP_MIB_GET_OUTPUT_DATA;
|
|
|
|
|
|
#endif // _IPRIPRM_H_
|
|
|