mib.c

wm PNE 3.3 source code, running at more than vxworks6.x version.

LEAF_COMS(icmpin_amasks_leaf, icmpin_amasks_crs, "icmpInAddrMasks", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_InAddrMasks, 0, 0xff, 0xff);

LEAF_COMS(icmpin_amaskreps_leaf, icmpin_amaskreps_crs,
	  "icmpInAddrMaskReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_InAddrMaskReps, 0, 0xff, 0xff);

LEAF_COMS(icmpout_msgs_leaf, icmpout_msgs_crs, "icmpOutMsgs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutMsgs, 0, 0xff, 0xff);

LEAF_COMS(icmpout_errors_leaf, icmpout_errors_crs, "icmpOutErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutErrors, 0, 0xff, 0xff);

LEAF_COMS(icmpout_dstunreach_leaf, icmpout_dstunreach_crs,
	  "icmpOutDestUnreachs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutDestUnreachs, 0, 0xff, 0xff);

LEAF_COMS(icmpout_timex_leaf, icmpout_timex_crs,
	  "icmpOutTimeExcds", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutTimeExcds, 0, 0xff, 0xff);

LEAF_COMS(icmpout_parmprobs_leaf, icmpout_parmprobs_crs,
	  "icmpOutParmProbs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutParmProbs, 0, 0xff, 0xff);

LEAF_COMS(icmpout_srcqnch_leaf, icmpout_srcqnch_crs,
	  "icmpOutSrcQuenchs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutSrcQuenchs, 0, 0xff, 0xff);

LEAF_COMS(icmpout_redirs_leaf, icmpout_redirs_crs,
	  "icmpOutRedirects", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutRedirects, 0, 0xff, 0xff);

LEAF_COMS(icmpout_echos_leaf, icmpout_echos_crs, "icmpOutEchos", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutEchos, 0, 0xff, 0xff);

LEAF_COMS(icmpout_echoreps_leaf, icmpout_echoreps_crs,
	  "icmpOutEchoReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutEchoReps, 0, 0xff, 0xff);

LEAF_COMS(icmpout_tstmps_leaf, icmpout_tstmps_crs,
	  "icmpOutTimestamps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutTimestamps, 0, 0xff, 0xff);

LEAF_COMS(icmpout_tstmpreps_leaf, icmpout_tstmpreps_crs,
	  "icmpOutTimestampReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutTimestampReps, 0, 0xff, 0xff);

LEAF_COMS(icmpout_amasks_leaf, icmpout_amasks_crs,
	  "icmpOutAddrMasks", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutAddrMasks, 0, 0xff, 0xff);

LEAF_COMS(icmpout_amaskreps_leaf, icmpout_amaskreps_crs,
	  "icmpOutAddrMaskReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &icmp_stats.icmp_OutAddrMaskReps, 0, 0xff, 0xff);

/* The ICMP node */
STATIC
MIBARC_T	icmp_arcs[] = {ARC(1, icmpin_msgs_leaf),
			       ARC(2, icmpin_errors_leaf),
			       ARC(3, icmpin_dstunreach_leaf),
			       ARC(4, icmpin_timex_leaf),
			       ARC(5, icmpin_parmprobs_leaf),
			       ARC(6, icmpin_srcqnch_leaf),
			       ARC(7, icmpin_redirs_leaf),
			       ARC(8, icmpin_echos_leaf),
			       ARC(9, icmpin_echoreps_leaf),
			       ARC(10, icmpin_tstmps_leaf),
			       ARC(11, icmpin_tstmpreps_leaf),
			       ARC(12, icmpin_amasks_leaf),
			       ARC(13, icmpin_amaskreps_leaf),
			       ARC(14, icmpout_msgs_leaf),
			       ARC(15, icmpout_errors_leaf),
			       ARC(16, icmpout_dstunreach_leaf),
			       ARC(17, icmpout_timex_leaf),
			       ARC(18, icmpout_parmprobs_leaf),
			       ARC(19, icmpout_srcqnch_leaf),
			       ARC(20, icmpout_redirs_leaf),
			       ARC(21, icmpout_echos_leaf),
			       ARC(22, icmpout_echoreps_leaf),
			       ARC(23, icmpout_tstmps_leaf),
			       ARC(24, icmpout_tstmpreps_leaf),
			       ARC(25, icmpout_amasks_leaf),
			       ARC(26, icmpout_amaskreps_leaf),
			       END_OF_ARC_LIST};
STATIC
MIBNODE_T	icmp_node = NODE("icmp", icmp_arcs);

/**********************************************************************
	THE TCP GROUP
 **********************************************************************/
/* The TCP node */

LEAF_COMS(tcprtoalgorithm_leaf, tcprtoalgorithm_crs,
	  "tcpRtoAlgorithm", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &tcp_stats.tcp_RtoAlg, 0, 0xff, 0xff);

LEAF_COMS(tcprtomin_leaf, tcprtomin_crs, "tcpRtoMin", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &tcp_stats.tcp_RtoMin, 0, 0xff, 0xff);

LEAF_COMS(tcprtomax_leaf, tcprtomax_crs, "tcpRtoMax", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &tcp_stats.tcp_RtoMax, 0, 0xff, 0xff);

LEAF_COMS(tcpmaxconn_leaf, tcpmaxconn_crs, "tcpMaxConn", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &tcp_stats.tcp_MaxConn, 0, 0xff, 0xff);

LEAF_COMS(tcpactiveopens_leaf, tcpactiveopens_crs,
	  "tcpActiveOpens", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_ActiveOpens, 0, 0xff, 0xff);

LEAF_COMS(tcppassiveopens_leaf, tcppassiveopens_crs,
	  "tcpPassiveOpens", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_PassiveOpens, 0, 0xff, 0xff);

LEAF_COMS(tcpattemptfails_leaf, tcpattemptfails_crs,
	  "tcpAttemptFails", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_AttemptFails, 0, 0xff, 0xff);

LEAF_COMS(tcpestabresets_leaf, tcpestabresets_crs,
	  "tcpEstabResets", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_EstabResets, 0, 0xff, 0xff);

LEAF_COMS(tcpcurrestab_leaf, tcpcurrestab_crs, "tcpCurrEstab", VT_GAUGE,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &tcp_stats.tcp_CurrEstab, 0, 0xff, 0xff);

LEAF_COMS(tcpinsegs_leaf, tcpinsegs_crs, "tcpInSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_InSegs, 0, 0xff, 0xff);

LEAF_COMS(tcpoutsegs_leaf, tcpoutsegs_crs, "tcpOutSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_OutSegs, 0, 0xff, 0xff);

LEAF_COMS(tcpretranssegs_leaf, tcpretranssegs_crs,
	  "tcpRetransSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &tcp_stats.tcp_RetransSegs, 0, 0xff, 0xff);

/* The TCP Connection Table */

LEAF_COMS(tcpconnstate_leaf, tcpconnstate_crs, "tcpConnState", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test, tcptable_getint, null_set_proc, tcptable_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(tcpconnlocaladdress_leaf, tcpconnlocaladdress_crs,
	  "tcpConnLocalAddress", VT_IPADDRESS,
	  READ_ACCESS, 0, tcptable_test, tcptable_getipaddr,
	  null_set_proc, tcptable_next,
	  dummystr, 0, 0xff, 0xff);

LEAF_COMS(tcpconnlocalport_leaf, tcpconnlocalport_crs,
	  "tcpConnLocalPort", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test, tcptable_getint, null_set_proc, tcptable_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(tcpconnremaddress_leaf, tcpconnremaddress_crs,
	  "tcpConnRemAddress", VT_IPADDRESS,
	  READ_ACCESS, 0, tcptable_test, tcptable_getipaddr,
	  null_set_proc, tcptable_next,
	  dummystr, 0, 0xff, 0xff);

LEAF_COMS(tcpconnremport_leaf, tcpconnremport_crs,
	  "tcpConnRemPort", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test, tcptable_getint, null_set_proc, tcptable_next,
	  &dummyval, 0, 0xff, 0xff);

STATIC
MIBARC_T	tcpconnentry_arcs[] = {ARC(1, tcpconnstate_leaf),
				       ARC(2, tcpconnlocaladdress_leaf),
				       ARC(3, tcpconnlocalport_leaf),
				       ARC(4, tcpconnremaddress_leaf),
				       ARC(5, tcpconnremport_leaf),
				       END_OF_ARC_LIST};
STATIC
MIBNODE_T	tcpconnentry_node = NODE("tcpConnEntry",
					 tcpconnentry_arcs);

STATIC
MIBARC_T	tcpconntable_arcs[] = {ARC(1, tcpconnentry_node),
					END_OF_ARC_LIST};
STATIC
MIBNODE_T	tcpconntable_node = NODE("tcpConnTable",
					 tcpconntable_arcs);

STATIC
MIBARC_T	tcp_arcs[] = {ARC(1, tcprtoalgorithm_leaf),
			      ARC(2, tcprtomin_leaf),
			      ARC(3, tcprtomax_leaf),
			      ARC(4, tcpmaxconn_leaf),
			      ARC(5, tcpactiveopens_leaf),
			      ARC(6, tcppassiveopens_leaf),
			      ARC(7, tcpattemptfails_leaf),
			      ARC(8, tcpestabresets_leaf),
			      ARC(9, tcpcurrestab_leaf),
			      ARC(10, tcpinsegs_leaf),
			      ARC(11, tcpoutsegs_leaf),
			      ARC(12, tcpretranssegs_leaf),
			      ARC(13, tcpconntable_node),
			      END_OF_ARC_LIST};
STATIC
MIBNODE_T	tcp_node = NODE("tcp", tcp_arcs);

/**********************************************************************
	THE UDP GROUP
 **********************************************************************/
/* The UDP node */

LEAF_COMS(udpindatagrams_leaf, udpindatagrams_crs,
	  "udpInDatagrams", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &udp_stats.udp_InDatagrams, 0, 0xff, 0xff);

LEAF_COMS(udpnoports_leaf, udpnoports_crs, "udpNoPorts", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &udp_stats.udp_NoPorts, 0, 0xff, 0xff);

LEAF_COMS(udpinerrors_leaf, udpinerrors_crs, "udpInErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &udp_stats.udp_InErrors, 0, 0xff, 0xff);

LEAF_COMS(udpoutdatagrams_leaf, udpoutdatagrams_crs,
	  "udpOutDatagrams", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_uint, null_set_proc, std_next,
	  &udp_stats.udp_OutDatagrams, 0, 0xff, 0xff);

STATIC
MIBARC_T	udp_arcs[] = {ARC(1, udpindatagrams_leaf),
			      ARC(2, udpnoports_leaf),
			      ARC(3, udpinerrors_leaf),
			      ARC(4, udpoutdatagrams_leaf),
			      END_OF_ARC_LIST};
STATIC
MIBNODE_T	udp_node = NODE("udp", udp_arcs);

/**********************************************************************
	THE EGP GROUP
 **********************************************************************/
/* The EGP node */

#if defined(EGP_GROUP)

LEAF_COMS(egpinmsgs_leaf, egpinmsgs_crs, "egpInMsgs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(egpinerrors_leaf, egpinerrors_crs, "egpInErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(egpoutmsgs_leaf, egpoutmsgs_crs, "egpOutMsgs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(egpouterrors_leaf, egpouterrors_crs, "egpOutErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &dummyval, 0, 0xff, 0xff);

/* The EGP Neighbor Table */

LEAF_COMS(egpneighstate_leaf, egpneighstate_crs, "egpNeighState", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &dummyval, 0, 0xff, 0xff);

LEAF_COMS(egpneighaddr_leaf, egpneighaddr_crs, "egpNeighAddr",
	  VT_IPADDRESS, READ_ACCESS, 0, SNMP_NULLPROC, SNMP_NULLPROC,
          SNMP_NULLPROC, SNMP_NULLPROC, dummystr, 0, 0xff, 0xff);

STATIC
MIBARC_T	egpneighentry_arcs[] = {ARC(1, egpneighstate_leaf),
					ARC(2, egpneighaddr_leaf),
				        END_OF_ARC_LIST};
STATIC
MIBNODE_T	egpneighentry_node = NODE("egpNeighEntry",
					  egpneighentry_arcs);

STATIC
MIBARC_T	egpneightable_arcs[] = {ARC(1, egpneighentry_node),
					END_OF_ARC_LIST};
STATIC
MIBNODE_T	egpneightable_node = NODE("egpNeighTable",
					  egpneightable_arcs);

STATIC
MIBARC_T	egp_arcs[] = {ARC(1, egpinmsgs_leaf),
			      ARC(2, egpinerrors_leaf),
			      ARC(3, egpoutmsgs_leaf),
			      ARC(4, egpouterrors_leaf),
			      ARC(5, egpneightable_node),
			      END_OF_ARC_LIST};
STATIC
MIBNODE_T	egp_node = NODE("egp", egp_arcs);
#endif

/**********************************************************************
	A TEST GROUP, NOT IN ANY MIB
 **********************************************************************/

LEAF_COMS(testint0_leaf, testint0_crs, "testint0", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &test_int0, 0, 0xff, 0xff);

LEAF_COMS(testint1p_leaf, testint1p_crs, "testint1p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &test_int1p, 0, 0xff, 0xff);

LEAF_COMS(testint2p_leaf, testint2p_crs, "testint2p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &test_int2p, 0, 0xff, 0xff);

LEAF_COMS(testint3p_leaf, testint3p_crs, "testint3p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &test_int3p, 0, 0xff, 0xff);

LEAF_COMS(testint4p_leaf, testint4p_crs, "testint4p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,
	  &test_int4p, 0, 0xff, 0xff);

LEAF_COMS(testint1n_leaf, testint1n_crs, "testint1n", VT_NUMBER,
	  READ_ACCESS, 0, it_exists, get_int, null_set_proc, std_next,