![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iprtrmib.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / include / microsoft / psdk|
Return to iprtrmib.h CVS log | Up to [Synchronet] / sbbs / include / microsoft / psdk |
1.1 root 1: /*++
2:
3: Copyright (c) Microsoft Corporation. All rights reserved.
4:
5: Module Name:
6:
7: iprtrmib.h
8:
9: Abstract:
10: This file contains:
11: o Definitions of the MIB_XX structures passed to and from the IP Router Manager
12: to query and set MIB variables handled by the IP Router Manager
13: o The #defines for the MIB variables IDs handled by the IP Router Manager
14: and made accessible by the MprAdminMIBXXX APIs
15: o The Routing PID of the IP Router Manager (as mentioned in ipinfoid.h)
16:
17: --*/
18:
19: #ifndef __ROUTING_IPRTRMIB_H__
20: #define __ROUTING_IPRTRMIB_H__
21:
22: #if _MSC_VER > 1000
23: #pragma once
24: #endif
25:
26: #if _MSC_VER >= 1200
27: #pragma warning(push)
28: #endif
29: #pragma warning(disable:4200)
30: #pragma warning(disable:4201)
31: #pragma warning(disable:4214)
32:
33: //////////////////////////////////////////////////////////////////////////////
34: // //
35: // Included to get the value of MAX_INTERFACE_NAME_LEN //
36: // //
37: //////////////////////////////////////////////////////////////////////////////
38:
39: #include <mprapi.h>
40:
41: //////////////////////////////////////////////////////////////////////////////
42: // //
43: // Included to get the necessary constants //
44: // //
45: //////////////////////////////////////////////////////////////////////////////
46:
47: #include <ipifcons.h>
48:
49: //////////////////////////////////////////////////////////////////////////////
50: // //
51: // This is the Id for IP Router Manager. The Router Manager handles //
52: // MIB-II, Forwarding MIB and some enterprise specific information. //
53: // Calls made with any other ID are passed on to the corresponding protocol //
54: // For example, an MprAdminMIBXXX call with a protocol ID of PID_IP and //
55: // a routing Id of 0xD will be sent to the IP Router Manager and then //
56: // forwarded to OSPF //
57: // This lives in the same number space as the protocol Ids of RIP, OSPF //
58: // etc, so any change made to it should be done keeping this in mind //
59: // //
60: //////////////////////////////////////////////////////////////////////////////
61:
62:
63: #define IPRTRMGR_PID 10000
64:
65: #ifndef ANY_SIZE
66:
67: #define ANY_SIZE 1
68:
69: #endif
70:
71: #define TCPIP_OWNING_MODULE_SIZE 16
72:
73: //////////////////////////////////////////////////////////////////////////////
74: // //
75: // The following #defines are the Ids of the MIB variables made accessible //
76: // to the user via MprAdminMIBXXX Apis. It will be noticed that these are //
77: // not the same as RFC 1213, since the MprAdminMIBXXX APIs work on rows and //
78: // groups instead of scalar variables //
79: // //
80: //////////////////////////////////////////////////////////////////////////////
81:
82:
83: #define IF_NUMBER 0
84: #define IF_TABLE (IF_NUMBER + 1)
85: #define IF_ROW (IF_TABLE + 1)
86: #define IP_STATS (IF_ROW + 1)
87: #define IP_ADDRTABLE (IP_STATS + 1)
88: #define IP_ADDRROW (IP_ADDRTABLE + 1)
89: #define IP_FORWARDNUMBER (IP_ADDRROW + 1)
90: #define IP_FORWARDTABLE (IP_FORWARDNUMBER + 1)
91: #define IP_FORWARDROW (IP_FORWARDTABLE + 1)
92: #define IP_NETTABLE (IP_FORWARDROW + 1)
93: #define IP_NETROW (IP_NETTABLE + 1)
94: #define ICMP_STATS (IP_NETROW + 1)
95: #define TCP_STATS (ICMP_STATS + 1)
96: #define TCP_TABLE (TCP_STATS + 1)
97: #define TCP_ROW (TCP_TABLE + 1)
98: #define UDP_STATS (TCP_ROW + 1)
99: #define UDP_TABLE (UDP_STATS + 1)
100: #define UDP_ROW (UDP_TABLE + 1)
101: #define MCAST_MFE (UDP_ROW + 1)
102: #define MCAST_MFE_STATS (MCAST_MFE + 1)
103: #define BEST_IF (MCAST_MFE_STATS + 1)
104: #define BEST_ROUTE (BEST_IF + 1)
105: #define PROXY_ARP (BEST_ROUTE + 1)
106: #define MCAST_IF_ENTRY (PROXY_ARP + 1)
107: #define MCAST_GLOBAL (MCAST_IF_ENTRY + 1)
108: #define IF_STATUS (MCAST_GLOBAL + 1)
109: #define MCAST_BOUNDARY (IF_STATUS + 1)
110: #define MCAST_SCOPE (MCAST_BOUNDARY + 1)
111: #define DEST_MATCHING (MCAST_SCOPE + 1)
112: #define DEST_LONGER (DEST_MATCHING + 1)
113: #define DEST_SHORTER (DEST_LONGER + 1)
114: #define ROUTE_MATCHING (DEST_SHORTER + 1)
115: #define ROUTE_LONGER (ROUTE_MATCHING + 1)
116: #define ROUTE_SHORTER (ROUTE_LONGER + 1)
117: #define ROUTE_STATE (ROUTE_SHORTER + 1)
118: #define MCAST_MFE_STATS_EX (ROUTE_STATE + 1)
119: #define IP6_STATS (MCAST_MFE_STATS_EX + 1)
120: #define UDP6_STATS (IP6_STATS + 1)
121: #define TCP6_STATS (UDP6_STATS + 1)
122:
123: #define NUMBER_OF_EXPORTED_VARIABLES (TCP6_STATS + 1)
124:
125:
126: //////////////////////////////////////////////////////////////////////////////
127: // //
128: // MIB_OPAQUE_QUERY is the structure filled in by the user to identify a //
129: // MIB variable //
130: // //
131: // dwVarId ID of MIB Variable (One of the Ids #defined above) //
132: // dwVarIndex Variable sized array containing the indices needed to //
133: // identify a variable. NOTE: Unlike SNMP we dont require that //
134: // a scalar variable be indexed by 0 //
135: // //
136: //////////////////////////////////////////////////////////////////////////////
137:
138: typedef struct _MIB_OPAQUE_QUERY
139: {
140: DWORD dwVarId;
141: DWORD rgdwVarIndex[ANY_SIZE];
142: }MIB_OPAQUE_QUERY, *PMIB_OPAQUE_QUERY;
143:
144: //////////////////////////////////////////////////////////////////////////////
145: // //
146: // The following are the structures which are filled in and returned to the //
147: // user when a query is made, OR are filled in BY THE USER when a set is //
148: // done //
149: // //
150: //////////////////////////////////////////////////////////////////////////////
151:
152: typedef struct _MIB_IFNUMBER
153: {
154: DWORD dwValue;
155: } MIB_IFNUMBER, *PMIB_IFNUMBER;
156:
157:
158: #define MAXLEN_IFDESCR 256
159: #define MAXLEN_PHYSADDR 8
160:
161: typedef struct _MIB_IFROW
162: {
163: WCHAR wszName[MAX_INTERFACE_NAME_LEN];
164: DWORD dwIndex;
165: DWORD dwType;
166: DWORD dwMtu;
167: DWORD dwSpeed;
168: DWORD dwPhysAddrLen;
169: BYTE bPhysAddr[MAXLEN_PHYSADDR];
170: DWORD dwAdminStatus;
171: DWORD dwOperStatus;
172: DWORD dwLastChange;
173: DWORD dwInOctets;
174: DWORD dwInUcastPkts;
175: DWORD dwInNUcastPkts;
176: DWORD dwInDiscards;
177: DWORD dwInErrors;
178: DWORD dwInUnknownProtos;
179: DWORD dwOutOctets;
180: DWORD dwOutUcastPkts;
181: DWORD dwOutNUcastPkts;
182: DWORD dwOutDiscards;
183: DWORD dwOutErrors;
184: DWORD dwOutQLen;
185: DWORD dwDescrLen;
186: BYTE bDescr[MAXLEN_IFDESCR];
187: } MIB_IFROW,*PMIB_IFROW;
188:
189: typedef struct _MIB_IFTABLE
190: {
191: DWORD dwNumEntries;
192: MIB_IFROW table[ANY_SIZE];
193: } MIB_IFTABLE, *PMIB_IFTABLE;
194:
195: #define SIZEOF_IFTABLE(X) (FIELD_OFFSET(MIB_IFTABLE,table[0]) + ((X) * sizeof(MIB_IFROW)) + ALIGN_SIZE)
196:
197: typedef struct _MIBICMPSTATS
198: {
199: DWORD dwMsgs;
200: DWORD dwErrors;
201: DWORD dwDestUnreachs;
202: DWORD dwTimeExcds;
203: DWORD dwParmProbs;
204: DWORD dwSrcQuenchs;
205: DWORD dwRedirects;
206: DWORD dwEchos;
207: DWORD dwEchoReps;
208: DWORD dwTimestamps;
209: DWORD dwTimestampReps;
210: DWORD dwAddrMasks;
211: DWORD dwAddrMaskReps;
212: } MIBICMPSTATS, *PMIBICMPSTATS;
213:
214: typedef struct _MIBICMPINFO
215: {
216: MIBICMPSTATS icmpInStats;
217: MIBICMPSTATS icmpOutStats;
218: } MIBICMPINFO;
219:
220: typedef struct _MIB_ICMP
221: {
222: MIBICMPINFO stats;
223: } MIB_ICMP,*PMIB_ICMP;
224:
225: //
226: // ICMPv6 Type Values from RFC 2292.
227: //
228: typedef enum {
229: ICMP6_DST_UNREACH = 1,
230: ICMP6_PACKET_TOO_BIG = 2,
231: ICMP6_TIME_EXCEEDED = 3,
232: ICMP6_PARAM_PROB = 4,
233: ICMP6_ECHO_REQUEST = 128,
234: ICMP6_ECHO_REPLY = 129,
235: ICMP6_MEMBERSHIP_QUERY = 130,
236: ICMP6_MEMBERSHIP_REPORT = 131,
237: ICMP6_MEMBERSHIP_REDUCTION = 132,
238: ND_ROUTER_SOLICIT = 133,
239: ND_ROUTER_ADVERT = 134,
240: ND_NEIGHBOR_SOLICIT = 135,
241: ND_NEIGHBOR_ADVERT = 136,
242: ND_REDIRECT = 137,
243: } ICMP6_TYPE, *PICMP6_TYPE;
244:
245: //
246: // There are no RFC-specified defines for ICMPv4 message types, so we try to
247: // use the ICMP6 values from RFC 2292 modified to be prefixed with ICMP4.
248: //
249: typedef enum {
250: ICMP4_ECHO_REPLY = 0, // Echo Reply
251: ICMP4_DST_UNREACH = 3, // Destination Unreachable
252: ICMP4_SOURCE_QUENCH = 4, // Source Quench
253: ICMP4_REDIRECT = 5, // Redirect
254: ICMP4_ECHO_REQUEST = 8, // Echo Request
255: ICMP4_ROUTER_ADVERT = 9, // Router Advertisement
256: ICMP4_ROUTER_SOLICIT = 10, // Router Solicitation
257: ICMP4_TIME_EXCEEDED = 11, // Time Exceeded
258: ICMP4_PARAM_PROB = 12, // Parameter Problem
259: ICMP4_TIMESTAMP_REQUEST = 13, // Timestamp Request
260: ICMP4_TIMESTAMP_REPLY = 14, // Timestamp Reply
261: ICMP4_MASK_REQUEST = 17, // Address Mask Request
262: ICMP4_MASK_REPLY = 18, // Address Mask Reply
263: } ICMP4_TYPE, *PICMP4_TYPE;
264:
265: typedef struct _MIBICMPSTATS_EX
266: {
267: DWORD dwMsgs;
268: DWORD dwErrors;
269: DWORD rgdwTypeCount[256];
270: } MIBICMPSTATS_EX, *PMIBICMPSTATS_EX;
271:
272: typedef struct _MIB_ICMP_EX
273: {
274: MIBICMPSTATS_EX icmpInStats;
275: MIBICMPSTATS_EX icmpOutStats;
276: } MIB_ICMP_EX,*PMIB_ICMP_EX;
277:
278: typedef struct _MIB_UDPSTATS
279: {
280: DWORD dwInDatagrams;
281: DWORD dwNoPorts;
282: DWORD dwInErrors;
283: DWORD dwOutDatagrams;
284: DWORD dwNumAddrs;
285: } MIB_UDPSTATS,*PMIB_UDPSTATS;
286:
287: typedef struct _MIB_UDPROW
288: {
289: DWORD dwLocalAddr;
290: DWORD dwLocalPort;
291: } MIB_UDPROW, *PMIB_UDPROW;
292:
293: typedef MIB_UDPROW MIB_UDPROW_BASIC, *PMIB_UDPROW_BASIC;
294:
295: typedef struct _MIB_UDPROW_OWNER_PID
296: {
297: DWORD dwLocalAddr;
298: DWORD dwLocalPort;
299: DWORD dwOwningPid;
300: } MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID;
301:
302: typedef struct _MIB_UDPROW_OWNER_MODULE
303: {
304: DWORD dwLocalAddr;
305: DWORD dwLocalPort;
306: DWORD dwOwningPid;
307: LARGE_INTEGER liCreateTimestamp;
308: union {
309: struct {
310: DWORD SpecificPortBind : 1;
311: };
312: DWORD dwFlags;
313: };
314: ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE];
315: } MIB_UDPROW_OWNER_MODULE, *PMIB_UDPROW_OWNER_MODULE;
316:
317: typedef struct _MIB_UDP6ROW_OWNER_PID
318: {
319: UCHAR ucLocalAddr[16];
320: DWORD dwLocalScopeId;
321: DWORD dwLocalPort;
322: DWORD dwOwningPid;
323: } MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID;
324:
325: typedef struct _MIB_UDP6ROW_OWNER_MODULE
326: {
327: UCHAR ucLocalAddr[16];
328: DWORD dwLocalScopeId;
329: DWORD dwLocalPort;
330: DWORD dwOwningPid;
331: LARGE_INTEGER liCreateTimestamp;
332: union {
333: struct {
334: DWORD SpecificPortBind : 1;
335: };
336: DWORD dwFlags;
337: };
338: ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE];
339: } MIB_UDP6ROW_OWNER_MODULE, *PMIB_UDP6ROW_OWNER_MODULE;
340:
341: typedef struct _MIB_UDPTABLE
342: {
343: DWORD dwNumEntries;
344: MIB_UDPROW table[ANY_SIZE];
345: } MIB_UDPTABLE, *PMIB_UDPTABLE;
346:
347: typedef MIB_UDPTABLE MIB_UDPTABLE_BASIC, *PMIB_UDPTABLE_BASIC;
348:
349: #define SIZEOF_UDPTABLE(X) (FIELD_OFFSET(MIB_UDPTABLE, table[0]) + ((X) * sizeof(MIB_UDPROW)) + ALIGN_SIZE)
350:
351: #define SIZEOF_UDPTABLE_BASIC(X) SIZEOF_UDPTABLE(X)
352:
353: typedef struct _MIB_UDPTABLE_OWNER_PID
354: {
355: DWORD dwNumEntries;
356: MIB_UDPROW_OWNER_PID table[ANY_SIZE];
357: } MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID;
358:
359: #define SIZEOF_UDPTABLE_OWNER_PID(X) (FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table[0]) + ((X) * sizeof(MIB_UDPROW_OWNER_PID)) + ALIGN_SIZE)
360:
361: typedef struct _MIB_UDPTABLE_OWNER_MODULE
362: {
363: DWORD dwNumEntries;
364: MIB_UDPROW_OWNER_MODULE table[ANY_SIZE];
365: } MIB_UDPTABLE_OWNER_MODULE, *PMIB_UDPTABLE_OWNER_MODULE;
366:
367: #define SIZEOF_UDPTABLE_OWNER_MODULE(X) (FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table[0]) + ((X) * sizeof(MIB_UDPROW_OWNER_MODULE)) + ALIGN_SIZE)
368:
369: typedef struct _MIB_UDP6TABLE_OWNER_PID
370: {
371: DWORD dwNumEntries;
372: MIB_UDP6ROW_OWNER_PID table[ANY_SIZE];
373: } MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID;
374:
375: #define SIZEOF_UDP6TABLE_OWNER_PID(X) (FIELD_OFFSET(MIB_UDP6TABLE_OWNER_PID, table[0]) + ((X) * sizeof(MIB_UDP6ROW_OWNER_PID)) + ALIGN_SIZE)
376:
377: typedef struct _MIB_UDP6TABLE_OWNER_MODULE
378: {
379: DWORD dwNumEntries;
380: MIB_UDP6ROW_OWNER_MODULE table[ANY_SIZE];
381: } MIB_UDP6TABLE_OWNER_MODULE, *PMIB_UDP6TABLE_OWNER_MODULE;
382:
383: #define SIZEOF_UDP6TABLE_OWNER_MODULE(X) (FIELD_OFFSET(MIB_UDP6TABLE_OWNER_MODULE, table[0]) + ((X) * sizeof(MIB_UDP6ROW_OWNER_MODULE)) + ALIGN_SIZE)
384:
385: typedef struct _MIB_TCPSTATS
386: {
387: DWORD dwRtoAlgorithm;
388: DWORD dwRtoMin;
389: DWORD dwRtoMax;
390: DWORD dwMaxConn;
391: DWORD dwActiveOpens;
392: DWORD dwPassiveOpens;
393: DWORD dwAttemptFails;
394: DWORD dwEstabResets;
395: DWORD dwCurrEstab;
396: DWORD dwInSegs;
397: DWORD dwOutSegs;
398: DWORD dwRetransSegs;
399: DWORD dwInErrs;
400: DWORD dwOutRsts;
401: DWORD dwNumConns;
402: } MIB_TCPSTATS, *PMIB_TCPSTATS;
403:
404: #define MIB_TCP_RTO_OTHER 1
405: #define MIB_TCP_RTO_CONSTANT 2
406: #define MIB_TCP_RTO_RSRE 3
407: #define MIB_TCP_RTO_VANJ 4
408:
409: #define MIB_TCP_MAXCONN_DYNAMIC (DWORD)-1
410:
411: typedef struct _MIB_TCPROW
412: {
413: DWORD dwState;
414: DWORD dwLocalAddr;
415: DWORD dwLocalPort;
416: DWORD dwRemoteAddr;
417: DWORD dwRemotePort;
418: } MIB_TCPROW, *PMIB_TCPROW;
419:
420: typedef MIB_TCPROW MIB_TCPROW_BASIC, *PMIB_TCPROW_BASIC;
421:
422: typedef struct _MIB_TCPROW_OWNER_PID
423: {
424: DWORD dwState;
425: DWORD dwLocalAddr;
426: DWORD dwLocalPort;
427: DWORD dwRemoteAddr;
428: DWORD dwRemotePort;
429: DWORD dwOwningPid;
430: } MIB_TCPROW_OWNER_PID, *PMIB_TCPROW_OWNER_PID;
431:
432:
433: typedef struct _MIB_TCPROW_OWNER_MODULE
434: {
435: DWORD dwState;
436: DWORD dwLocalAddr;
437: DWORD dwLocalPort;
438: DWORD dwRemoteAddr;
439: DWORD dwRemotePort;
440: DWORD dwOwningPid;
441: LARGE_INTEGER liCreateTimestamp;
442: ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE];
443: } MIB_TCPROW_OWNER_MODULE, *PMIB_TCPROW_OWNER_MODULE;
444:
445: typedef struct _MIB_TCP6ROW_OWNER_PID
446: {
447: UCHAR ucLocalAddr[16];
448: DWORD dwLocalScopeId;
449: DWORD dwLocalPort;
450: UCHAR ucRemoteAddr[16];
451: DWORD dwRemoteScopeId;
452: DWORD dwRemotePort;
453: DWORD dwState;
454: DWORD dwOwningPid;
455: } MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID;
456:
457: typedef struct _MIB_TCP6ROW_OWNER_MODULE
458: {
459: UCHAR ucLocalAddr[16];
460: DWORD dwLocalScopeId;
461: DWORD dwLocalPort;
462: UCHAR ucRemoteAddr[16];
463: DWORD dwRemoteScopeId;
464: DWORD dwRemotePort;
465: DWORD dwState;
466: DWORD dwOwningPid;
467: LARGE_INTEGER liCreateTimestamp;
468: ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE];
469: } MIB_TCP6ROW_OWNER_MODULE, *PMIB_TCP6ROW_OWNER_MODULE;
470:
471:
472: #define MIB_TCP_STATE_CLOSED 1
473: #define MIB_TCP_STATE_LISTEN 2
474: #define MIB_TCP_STATE_SYN_SENT 3
475: #define MIB_TCP_STATE_SYN_RCVD 4
476: #define MIB_TCP_STATE_ESTAB 5
477: #define MIB_TCP_STATE_FIN_WAIT1 6
478: #define MIB_TCP_STATE_FIN_WAIT2 7
479: #define MIB_TCP_STATE_CLOSE_WAIT 8
480: #define MIB_TCP_STATE_CLOSING 9
481: #define MIB_TCP_STATE_LAST_ACK 10
482: #define MIB_TCP_STATE_TIME_WAIT 11
483: #define MIB_TCP_STATE_DELETE_TCB 12
484:
485: typedef struct _MIB_TCPTABLE
486: {
487: DWORD dwNumEntries;
488: MIB_TCPROW table[ANY_SIZE];
489: } MIB_TCPTABLE, *PMIB_TCPTABLE;
490:
491: typedef MIB_TCPTABLE MIB_TCPTABLE_BASIC, *PMIB_TCPTABLE_BASIC;
492:
493: #define SIZEOF_TCPTABLE(X) (FIELD_OFFSET(MIB_TCPTABLE,table[0]) + ((X) * sizeof(MIB_TCPROW)) + ALIGN_SIZE)
494:
495: #define SIZEOF_TCPTABLE_BASIC(X) SIZEOF_TCPTABLE(X)
496:
497: typedef struct _MIB_TCPTABLE_OWNER_PID
498: {
499: DWORD dwNumEntries;
500: MIB_TCPROW_OWNER_PID table[ANY_SIZE];
501: } MIB_TCPTABLE_OWNER_PID, *PMIB_TCPTABLE_OWNER_PID;
502:
503: #define SIZEOF_TCPTABLE_OWNER_PID(X) (FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table[0]) + ((X) * sizeof(MIB_TCPROW_OWNER_PID)) + ALIGN_SIZE)
504:
505: typedef struct _MIB_TCPTABLE_OWNER_MODULE
506: {
507: DWORD dwNumEntries;
508: MIB_TCPROW_OWNER_MODULE table[ANY_SIZE];
509: } MIB_TCPTABLE_OWNER_MODULE, *PMIB_TCPTABLE_OWNER_MODULE;
510:
511: #define SIZEOF_TCPTABLE_OWNER_MODULE(X) (FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table[0]) + ((X) * sizeof(MIB_TCPROW_OWNER_MODULE)) + ALIGN_SIZE)
512:
513: typedef struct _MIB_TCP6TABLE_OWNER_PID
514: {
515: DWORD dwNumEntries;
516: MIB_TCP6ROW_OWNER_PID table[ANY_SIZE];
517: } MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID;
518:
519: #define SIZEOF_TCP6TABLE_OWNER_PID(X) (FIELD_OFFSET(MIB_TCP6TABLE_OWNER_PID, table[0]) + ((X) * sizeof(MIB_TCP6ROW_OWNER_PID)) + ALIGN_SIZE)
520:
521: typedef struct _MIB_TCP6TABLE_OWNER_MODULE
522: {
523: DWORD dwNumEntries;
524: MIB_TCP6ROW_OWNER_MODULE table[ANY_SIZE];
525: } MIB_TCP6TABLE_OWNER_MODULE, *PMIB_TCP6TABLE_OWNER_MODULE;
526:
527: #define SIZEOF_TCP6TABLE_OWNER_MODULE(X) (FIELD_OFFSET(MIB_TCP6TABLE_OWNER_MODULE, table[0]) + ((X) * sizeof(MIB_TCP6ROW_OWNER_PID)) + ALIGN_SIZE)
528:
529: //
530: // Flags that describe the health of TCPIP with respect to security/DOS.
531: //
532: #define MIB_SECURITY_TCP_SYN_ATTACK 0x00000001
533:
534: #define MIB_USE_CURRENT_TTL ((DWORD)-1)
535: #define MIB_USE_CURRENT_FORWARDING ((DWORD)-1)
536:
537: typedef struct _MIB_IPSTATS
538: {
539: DWORD dwForwarding;
540: DWORD dwDefaultTTL;
541: DWORD dwInReceives;
542: DWORD dwInHdrErrors;
543: DWORD dwInAddrErrors;
544: DWORD dwForwDatagrams;
545: DWORD dwInUnknownProtos;
546: DWORD dwInDiscards;
547: DWORD dwInDelivers;
548: DWORD dwOutRequests;
549: DWORD dwRoutingDiscards;
550: DWORD dwOutDiscards;
551: DWORD dwOutNoRoutes;
552: DWORD dwReasmTimeout;
553: DWORD dwReasmReqds;
554: DWORD dwReasmOks;
555: DWORD dwReasmFails;
556: DWORD dwFragOks;
557: DWORD dwFragFails;
558: DWORD dwFragCreates;
559: DWORD dwNumIf;
560: DWORD dwNumAddr;
561: DWORD dwNumRoutes;
562: } MIB_IPSTATS, *PMIB_IPSTATS;
563:
564: #define MIB_IP_FORWARDING 1
565: #define MIB_IP_NOT_FORWARDING 2
566:
567:
568: // Note: These addr types have dependency on ipdef.h
569:
570: #define MIB_IPADDR_PRIMARY 0x0001 // Primary ipaddr
571: #define MIB_IPADDR_DYNAMIC 0x0004 // Dynamic ipaddr
572: #define MIB_IPADDR_DISCONNECTED 0x0008 // Address is on disconnected interface
573: #define MIB_IPADDR_DELETED 0x0040 // Address being deleted
574: #define MIB_IPADDR_TRANSIENT 0x0080 // Transient address
575:
576:
577: typedef struct _MIB_IPADDRROW
578: {
579: DWORD dwAddr;
580: DWORD dwIndex;
581: DWORD dwMask;
582: DWORD dwBCastAddr;
583: DWORD dwReasmSize;
584: unsigned short unused1;
585: unsigned short wType;
586: } MIB_IPADDRROW, *PMIB_IPADDRROW;
587:
588: typedef struct _MIB_IPADDRTABLE
589: {
590: DWORD dwNumEntries;
591: MIB_IPADDRROW table[ANY_SIZE];
592: } MIB_IPADDRTABLE, *PMIB_IPADDRTABLE;
593:
594:
595: #define SIZEOF_IPADDRTABLE(X) (FIELD_OFFSET(MIB_IPADDRTABLE,table[0]) + ((X) * sizeof(MIB_IPADDRROW)) + ALIGN_SIZE)
596:
597:
598: typedef struct _MIB_IPFORWARDNUMBER
599: {
600: DWORD dwValue;
601: }MIB_IPFORWARDNUMBER,*PMIB_IPFORWARDNUMBER;
602:
603: typedef struct _MIB_IPFORWARDROW
604: {
605: DWORD dwForwardDest;
606: DWORD dwForwardMask;
607: DWORD dwForwardPolicy;
608: DWORD dwForwardNextHop;
609: DWORD dwForwardIfIndex;
610: DWORD dwForwardType;
611: DWORD dwForwardProto;
612: DWORD dwForwardAge;
613: DWORD dwForwardNextHopAS;
614: DWORD dwForwardMetric1;
615: DWORD dwForwardMetric2;
616: DWORD dwForwardMetric3;
617: DWORD dwForwardMetric4;
618: DWORD dwForwardMetric5;
619: }MIB_IPFORWARDROW, *PMIB_IPFORWARDROW;
620:
621: #define MIB_IPROUTE_TYPE_OTHER 1
622: #define MIB_IPROUTE_TYPE_INVALID 2
623: #define MIB_IPROUTE_TYPE_DIRECT 3
624: #define MIB_IPROUTE_TYPE_INDIRECT 4
625:
626: #define MIB_IPROUTE_METRIC_UNUSED (DWORD)-1
627:
628: //
629: // THESE MUST MATCH the ids in routprot.h
630: //
631:
632: #define MIB_IPPROTO_OTHER 1
633: #define MIB_IPPROTO_LOCAL 2
634: #define MIB_IPPROTO_NETMGMT 3
635: #define MIB_IPPROTO_ICMP 4
636: #define MIB_IPPROTO_EGP 5
637: #define MIB_IPPROTO_GGP 6
638: #define MIB_IPPROTO_HELLO 7
639: #define MIB_IPPROTO_RIP 8
640: #define MIB_IPPROTO_IS_IS 9
641: #define MIB_IPPROTO_ES_IS 10
642: #define MIB_IPPROTO_CISCO 11
643: #define MIB_IPPROTO_BBN 12
644: #define MIB_IPPROTO_OSPF 13
645: #define MIB_IPPROTO_BGP 14
646:
647: #define MIB_IPPROTO_NT_AUTOSTATIC 10002
648: #define MIB_IPPROTO_NT_STATIC 10006
649: #define MIB_IPPROTO_NT_STATIC_NON_DOD 10007
650:
651: typedef struct _MIB_IPFORWARDTABLE
652: {
653: DWORD dwNumEntries;
654: MIB_IPFORWARDROW table[ANY_SIZE];
655: }MIB_IPFORWARDTABLE, *PMIB_IPFORWARDTABLE;
656:
657:
658:
659:
660: #define SIZEOF_IPFORWARDTABLE(X) (FIELD_OFFSET(MIB_IPFORWARDTABLE,table[0]) + ((X) * sizeof(MIB_IPFORWARDROW)) + ALIGN_SIZE)
661:
662:
663: typedef struct _MIB_IPNETROW
664: {
665: DWORD dwIndex;
666: DWORD dwPhysAddrLen;
667: BYTE bPhysAddr[MAXLEN_PHYSADDR];
668: DWORD dwAddr;
669: DWORD dwType;
670: } MIB_IPNETROW, *PMIB_IPNETROW;
671:
672: #define MIB_IPNET_TYPE_OTHER 1
673: #define MIB_IPNET_TYPE_INVALID 2
674: #define MIB_IPNET_TYPE_DYNAMIC 3
675: #define MIB_IPNET_TYPE_STATIC 4
676:
677: typedef struct _MIB_IPNETTABLE
678: {
679: DWORD dwNumEntries;
680: MIB_IPNETROW table[ANY_SIZE];
681: } MIB_IPNETTABLE, *PMIB_IPNETTABLE;
682:
683: #define SIZEOF_IPNETTABLE(X) (FIELD_OFFSET(MIB_IPNETTABLE, table[0]) + ((X) * sizeof(MIB_IPNETROW)) + ALIGN_SIZE)
684:
685: typedef struct _MIB_IPMCAST_OIF
686: {
687: DWORD dwOutIfIndex;
688: DWORD dwNextHopAddr;
689: DWORD dwReserved;
690: DWORD dwReserved1;
691: }MIB_IPMCAST_OIF, *PMIB_IPMCAST_OIF;
692:
693: typedef struct _MIB_IPMCAST_MFE
694: {
695: DWORD dwGroup;
696: DWORD dwSource;
697: DWORD dwSrcMask;
698: DWORD dwUpStrmNgbr;
699: DWORD dwInIfIndex;
700: DWORD dwInIfProtocol;
701: DWORD dwRouteProtocol;
702: DWORD dwRouteNetwork;
703: DWORD dwRouteMask;
704: ULONG ulUpTime;
705: ULONG ulExpiryTime;
706: ULONG ulTimeOut;
707: ULONG ulNumOutIf;
708: DWORD fFlags;
709: DWORD dwReserved;
710: MIB_IPMCAST_OIF rgmioOutInfo[ANY_SIZE];
711: }MIB_IPMCAST_MFE, *PMIB_IPMCAST_MFE;
712:
713: typedef struct _MIB_MFE_TABLE
714: {
715: DWORD dwNumEntries;
716: MIB_IPMCAST_MFE table[ANY_SIZE];
717: }MIB_MFE_TABLE, *PMIB_MFE_TABLE;
718:
719:
720: #define SIZEOF_BASIC_MIB_MFE \
721: (ULONG)(FIELD_OFFSET(MIB_IPMCAST_MFE, rgmioOutInfo[0]))
722:
723: #define SIZEOF_MIB_MFE(X) \
724: (SIZEOF_BASIC_MIB_MFE + ((X) * sizeof(MIB_IPMCAST_OIF)))
725:
726:
727: typedef struct _MIB_IPMCAST_OIF_STATS
728: {
729: DWORD dwOutIfIndex;
730: DWORD dwNextHopAddr;
731: DWORD dwDialContext;
732: ULONG ulTtlTooLow;
733: ULONG ulFragNeeded;
734: ULONG ulOutPackets;
735: ULONG ulOutDiscards;
736: }MIB_IPMCAST_OIF_STATS, *PMIB_IPMCAST_OIF_STATS;
737:
738: typedef struct _MIB_IPMCAST_MFE_STATS
739: {
740: DWORD dwGroup;
741: DWORD dwSource;
742: DWORD dwSrcMask;
743: DWORD dwUpStrmNgbr;
744: DWORD dwInIfIndex;
745: DWORD dwInIfProtocol;
746: DWORD dwRouteProtocol;
747: DWORD dwRouteNetwork;
748: DWORD dwRouteMask;
749: ULONG ulUpTime;
750: ULONG ulExpiryTime;
751: ULONG ulNumOutIf;
752: ULONG ulInPkts;
753: ULONG ulInOctets;
754: ULONG ulPktsDifferentIf;
755: ULONG ulQueueOverflow;
756:
757: MIB_IPMCAST_OIF_STATS rgmiosOutStats[ANY_SIZE];
758: }MIB_IPMCAST_MFE_STATS, *PMIB_IPMCAST_MFE_STATS;
759:
760: typedef struct _MIB_MFE_STATS_TABLE
761: {
762: DWORD dwNumEntries;
763: MIB_IPMCAST_MFE_STATS table[ANY_SIZE];
764: }MIB_MFE_STATS_TABLE, *PMIB_MFE_STATS_TABLE;
765:
766: #define SIZEOF_BASIC_MIB_MFE_STATS \
767: (ULONG)(FIELD_OFFSET(MIB_IPMCAST_MFE_STATS, rgmiosOutStats[0]))
768:
769: #define SIZEOF_MIB_MFE_STATS(X) \
770: (SIZEOF_BASIC_MIB_MFE_STATS + ((X) * sizeof(MIB_IPMCAST_OIF_STATS)))
771:
772:
773: typedef struct _MIB_IPMCAST_MFE_STATS_EX
774: {
775: DWORD dwGroup;
776: DWORD dwSource;
777: DWORD dwSrcMask;
778: DWORD dwUpStrmNgbr;
779: DWORD dwInIfIndex;
780: DWORD dwInIfProtocol;
781: DWORD dwRouteProtocol;
782: DWORD dwRouteNetwork;
783: DWORD dwRouteMask;
784: ULONG ulUpTime;
785: ULONG ulExpiryTime;
786: ULONG ulNumOutIf;
787: ULONG ulInPkts;
788: ULONG ulInOctets;
789: ULONG ulPktsDifferentIf;
790: ULONG ulQueueOverflow;
791: ULONG ulUninitMfe;
792: ULONG ulNegativeMfe;
793: ULONG ulInDiscards;
794: ULONG ulInHdrErrors;
795: ULONG ulTotalOutPackets;
796:
797: MIB_IPMCAST_OIF_STATS rgmiosOutStats[ANY_SIZE];
798: }MIB_IPMCAST_MFE_STATS_EX, *PMIB_IPMCAST_MFE_STATS_EX;
799:
800: typedef struct _MIB_MFE_STATS_TABLE_EX
801: {
802: DWORD dwNumEntries;
803: MIB_IPMCAST_MFE_STATS_EX table[ANY_SIZE];
804: }MIB_MFE_STATS_TABLE_EX, *PMIB_MFE_STATS_TABLE_EX;
805:
806: #define SIZEOF_BASIC_MIB_MFE_STATS_EX \
807: (ULONG)(FIELD_OFFSET(MIB_IPMCAST_MFE_STATS_EX, rgmiosOutStats[0]))
808:
809: #define SIZEOF_MIB_MFE_STATS_EX(X) \
810: (SIZEOF_BASIC_MIB_MFE_STATS_EX + ((X) * sizeof(MIB_IPMCAST_OIF_STATS)))
811:
812:
813: typedef struct _MIB_IPMCAST_GLOBAL {
814: DWORD dwEnable;
815: }MIB_IPMCAST_GLOBAL, *PMIB_IPMCAST_GLOBAL;
816:
817: typedef struct _MIB_IPMCAST_IF_ENTRY
818: {
819: DWORD dwIfIndex;
820: DWORD dwTtl;
821: DWORD dwProtocol;
822: DWORD dwRateLimit;
823: ULONG ulInMcastOctets;
824: ULONG ulOutMcastOctets;
825: }MIB_IPMCAST_IF_ENTRY, *PMIB_IPMCAST_IF_ENTRY;
826:
827: typedef struct _MIB_IPMCAST_IF_TABLE
828: {
829: DWORD dwNumEntries;
830: MIB_IPMCAST_IF_ENTRY table[ANY_SIZE];
831: }MIB_IPMCAST_IF_TABLE, *PMIB_IPMCAST_IF_TABLE;
832:
833: #define SIZEOF_MCAST_IF_TABLE(X) (FIELD_OFFSET(MIB_IPMCAST_IF_TABLE,table[0]) + ((X) * sizeof(MIB_IPMCAST_IF_ENTRY)) + ALIGN_SIZE)
834:
835: typedef struct _MIB_IPMCAST_BOUNDARY
836: {
837: DWORD dwIfIndex;
838: DWORD dwGroupAddress;
839: DWORD dwGroupMask;
840: DWORD dwStatus;
841: }MIB_IPMCAST_BOUNDARY, *PMIB_IPMCAST_BOUNDARY;
842:
843: typedef struct _MIB_IPMCAST_BOUNDARY_TABLE
844: {
845: DWORD dwNumEntries;
846: MIB_IPMCAST_BOUNDARY table[ANY_SIZE];
847: }MIB_IPMCAST_BOUNDARY_TABLE, *PMIB_IPMCAST_BOUNDARY_TABLE;
848:
849: #define SIZEOF_BOUNDARY_TABLE(X) (FIELD_OFFSET(MIB_IPMCAST_BOUNDARY_TABLE,table[0]) + ((X) * sizeof(MIB_IPMCAST_BOUNDARY)) + ALIGN_SIZE)
850:
851: typedef struct {
852: DWORD dwGroupAddress;
853: DWORD dwGroupMask;
854: } MIB_BOUNDARYROW, *PMIB_BOUNDARYROW;
855:
856: // Structure matching what goes in the registry in a block of type
857: // IP_MCAST_LIMIT_INFO. This contains the fields of
858: // MIB_IPMCAST_IF_ENTRY which are configurable.
859:
860: typedef struct {
861: DWORD dwTtl;
862: DWORD dwRateLimit;
863: } MIB_MCAST_LIMIT_ROW, *PMIB_MCAST_LIMIT_ROW;
864:
865: #define MAX_SCOPE_NAME_LEN 255
866:
867: //
868: // Scope names are unicode. SNMP and MZAP use UTF-8 encoding.
869: //
870:
871: #define SN_UNICODE
872: typedef WCHAR SN_CHAR;
873: typedef SN_CHAR SCOPE_NAME_BUFFER[MAX_SCOPE_NAME_LEN+1], *SCOPE_NAME;
874:
875: typedef struct _MIB_IPMCAST_SCOPE
876: {
877: DWORD dwGroupAddress;
878: DWORD dwGroupMask;
879: SCOPE_NAME_BUFFER snNameBuffer;
880: DWORD dwStatus;
881: }MIB_IPMCAST_SCOPE, *PMIB_IPMCAST_SCOPE;
882:
883: typedef struct _MIB_IPDESTROW
884: {
885: #ifdef __cplusplus
886: MIB_IPFORWARDROW ForwardRow;
887: #else
888: MIB_IPFORWARDROW;
889: #endif
890:
891: DWORD dwForwardPreference;
892: DWORD dwForwardViewSet;
893: }MIB_IPDESTROW, *PMIB_IPDESTROW;
894:
895: typedef struct _MIB_IPDESTTABLE
896: {
897: DWORD dwNumEntries;
898: MIB_IPDESTROW table[ANY_SIZE];
899: }MIB_IPDESTTABLE, *PMIB_IPDESTTABLE;
900:
901: typedef struct _MIB_BEST_IF
902: {
903: DWORD dwDestAddr;
904: DWORD dwIfIndex;
905: }MIB_BEST_IF, *PMIB_BEST_IF;
906:
907: typedef struct _MIB_PROXYARP
908: {
909: DWORD dwAddress;
910: DWORD dwMask;
911: DWORD dwIfIndex;
912: }MIB_PROXYARP, *PMIB_PROXYARP;
913:
914: typedef struct _MIB_IFSTATUS
915: {
916: DWORD dwIfIndex;
917: DWORD dwAdminStatus;
918: DWORD dwOperationalStatus;
919: BOOL bMHbeatActive;
920: BOOL bMHbeatAlive;
921: }MIB_IFSTATUS, *PMIB_IFSTATUS;
922:
923: typedef struct _MIB_ROUTESTATE
924: {
925: BOOL bRoutesSetToStack;
926:
927: }MIB_ROUTESTATE, *PMIB_ROUTESTATE;
928:
929: //////////////////////////////////////////////////////////////////////////////
930: // //
931: // All the info passed to (SET/CREATE) and from (GET/GETNEXT/GETFIRST) //
932: // IP Router Manager is encapsulated in the following "discriminated" //
933: // union. To pass, say MIB_IFROW, use the following code //
934: // //
935: // PMIB_OPAQUE_INFO pInfo; //
936: // PMIB_IFROW pIfRow; //
937: // DWORD rgdwBuff[(MAX_MIB_OFFSET + sizeof(MIB_IFROW))/sizeof(DWORD) + 1]; //
938: // //
939: // pInfo = (PMIB_OPAQUE_INFO)rgdwBuffer; //
940: // pIfRow = (MIB_IFROW *)(pInfo->rgbyData); //
941: // //
942: // This can also be accomplished by using the following macro //
943: // //
944: // DEFINE_MIB_BUFFER(pInfo,MIB_IFROW, pIfRow); //
945: // //
946: //////////////////////////////////////////////////////////////////////////////
947:
948:
949: typedef struct _MIB_OPAQUE_INFO
950: {
951: DWORD dwId;
952:
953: union
954: {
955: ULONGLONG ullAlign;
956: BYTE rgbyData[1];
957: };
958:
959: }MIB_OPAQUE_INFO, *PMIB_OPAQUE_INFO;
960:
961: #define MAX_MIB_OFFSET 8
962:
963: #define MIB_INFO_SIZE(S) \
964: (MAX_MIB_OFFSET + sizeof(S))
965:
966: #define MIB_INFO_SIZE_IN_DWORDS(S) \
967: ((MIB_INFO_SIZE(S))/sizeof(DWORD) + 1)
968:
969: #define DEFINE_MIB_BUFFER(X,Y,Z) \
970: DWORD __rgdwBuff[MIB_INFO_SIZE_IN_DWORDS(Y)]; \
971: PMIB_OPAQUE_INFO X = (PMIB_OPAQUE_INFO)__rgdwBuff; \
972: Y * Z = (Y *)(X->rgbyData)
973:
974:
975: #define CAST_MIB_INFO(X,Y,Z) Z = (Y)(X->rgbyData)
976:
977: #if _MSC_VER >= 1200
978: #pragma warning(pop)
979: #else
980: #pragma warning(default:4200)
981: #pragma warning(default:4201)
982: #pragma warning(default:4214)
983: #endif
984:
985: #endif //__ROUTING_IPRTRMIB_H__
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.