mib_asy.c

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

LEAF_ASYS(icmpout_redirs_leaf, "icmpOutRedirects", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutRedirects, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_echos_leaf, "icmpOutEchos", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutEchos, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_echoreps_leaf, "icmpOutEchoReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutEchoReps, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_tstmps_leaf, "icmpOutTimestamps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutTimestamps, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_tstmpreps_leaf, "icmpOutTimestampReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutTimestampReps, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_amasks_leaf, "icmpOutAddrMasks", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &icmp_stats.icmp_OutAddrMasks, 0, 0xff, 0xff);

LEAF_ASYS(icmpout_amaskreps_leaf, "icmpOutAddrMaskReps", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &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_ASYS(tcprtoalgorithm_leaf, "tcpRtoAlgorithm", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_RtoAlg, 0, 0xff, 0xff);

LEAF_ASYS(tcprtomin_leaf, "tcpRtoMin", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_RtoMin, 0, 0xff, 0xff);

LEAF_ASYS(tcprtomax_leaf, "tcpRtoMax", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_RtoMax, 0, 0xff, 0xff);

LEAF_ASYS(tcpmaxconn_leaf, "tcpMaxConn", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_MaxConn, 0, 0xff, 0xff);

LEAF_ASYS(tcpactiveopens_leaf, "tcpActiveOpens", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_ActiveOpens, 0, 0xff, 0xff);

LEAF_ASYS(tcppassiveopens_leaf, "tcpPassiveOpens", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_PassiveOpens, 0, 0xff, 0xff);

LEAF_ASYS(tcpattemptfails_leaf, "tcpAttemptFails", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_AttemptFails, 0, 0xff, 0xff);

LEAF_ASYS(tcpestabresets_leaf, "tcpEstabResets", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_EstabResets, 0, 0xff, 0xff);

LEAF_ASYS(tcpcurrestab_leaf, "tcpCurrEstab", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_CurrEstab, 0, 0xff, 0xff);

LEAF_ASYS(tcpinsegs_leaf, "tcpInSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_InSegs, 0, 0xff, 0xff);

LEAF_ASYS(tcpoutsegs_leaf, "tcpOutSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_OutSegs, 0, 0xff, 0xff);

LEAF_ASYS(tcpretranssegs_leaf, "tcpRetransSegs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &tcp_stats.tcp_RetransSegs, 0, 0xff, 0xff);

/* The TCP Connection Table */

LEAF_ASYS(tcpconnstate_leaf, "tcpConnState", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test_async, tcptable_get_async,
	  null_set_async, no_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(tcpconnlocaladdress_leaf, "tcpConnLocalAddress", VT_IPADDRESS,
	  READ_ACCESS, 0, tcptable_test_async, tcptable_get_async,
	  null_set_async, no_next_async,
	  dummystr, 0, 0xff, 0xff);

LEAF_ASYS(tcpconnlocalport_leaf, "tcpConnLocalPort", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test_async, tcptable_get_async,
	  null_set_async, no_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(tcpconnremaddress_leaf, "tcpConnRemAddress", VT_IPADDRESS,
	  READ_ACCESS, 0, tcptable_test_async, tcptable_get_async,
	  null_set_async, no_next_async,
	  dummystr, 0, 0xff, 0xff);

LEAF_ASYS(tcpconnremport_leaf, "tcpConnRemPort", VT_NUMBER,
	  READ_ACCESS, 0, tcptable_test_async, tcptable_get_async,
	  null_set_async, no_next_async,
	  &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_ASYS(udpindatagrams_leaf, "udpInDatagrams", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &udp_stats.udp_InDatagrams, 0, 0xff, 0xff);

LEAF_ASYS(udpnoports_leaf, "udpNoPorts", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &udp_stats.udp_NoPorts, 0, 0xff, 0xff);

LEAF_ASYS(udpinerrors_leaf, "udpInErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &udp_stats.udp_InErrors, 0, 0xff, 0xff);

LEAF_ASYS(udpoutdatagrams_leaf, "udpOutDatagrams", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &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_ASYS(egpinmsgs_leaf, "egpInMsgs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(egpinerrors_leaf, "egpInErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(egpoutmsgs_leaf, "egpOutMsgs", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(egpouterrors_leaf, "egpOutErrors", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &dummyval, 0, 0xff, 0xff);

/* The EGP Neighbor Table */

LEAF_ASYS(egpneighstate_leaf, "egpNeighState", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &dummyval, 0, 0xff, 0xff);

LEAF_ASYS(egpneighaddr_leaf, "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_ASYS(testint0_leaf, "testint0", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int0, 0, 0xff, 0xff);

LEAF_ASYS(testint1p_leaf, "testint1p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int1p, 0, 0xff, 0xff);

LEAF_ASYS(testint2p_leaf, "testint2p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int2p, 0, 0xff, 0xff);

LEAF_ASYS(testint3p_leaf, "testint3p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int3p, 0, 0xff, 0xff);

LEAF_ASYS(testint4p_leaf, "testint4p", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int4p, 0, 0xff, 0xff);

LEAF_ASYS(testint1n_leaf, "testint1n", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int1n, 0, 0xff, 0xff);

LEAF_ASYS(testint2n_leaf, "testint2n", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int2n, 0, 0xff, 0xff);

LEAF_ASYS(testint3n_leaf, "testint3n", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int3n, 0, 0xff, 0xff);

LEAF_ASYS(testint4n_leaf, "testint4n", VT_NUMBER,
	  READ_ACCESS, 0, it_exists_async, get_int_async,
	  null_set_async, std_next_async,
	  &test_int4n, 0, 0xff, 0xff);

/* The int TEST node */
STATIC
MIBARC_T	testint_arcs[] =  {ARC(1, testint0_leaf),
				   ARC(2, testint1p_leaf),
				   ARC(3, testint2p_leaf),
				   ARC(4, testint3p_leaf),
				   ARC(5, testint4p_leaf),
				   ARC(6, testint1n_leaf),
				   ARC(7, testint2n_leaf),
				   ARC(8, testint3n_leaf),