mib_asy.c

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

				   ARC(9, testint4n_leaf),
				   END_OF_ARC_LIST};
STATIC
MIBNODE_T	testint_node = NODE("testint", testint_arcs);

LEAF_ASYS(testcount0_leaf, "testcount0", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count0, 0, 0xff, 0xff);

LEAF_ASYS(testcount1_leaf, "testcount1", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count1, 0, 0xff, 0xff);

LEAF_ASYS(testcount2_leaf, "testcount2", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count2, 0, 0xff, 0xff);

LEAF_ASYS(testcount3_leaf, "testcount3", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count3, 0, 0xff, 0xff);

LEAF_ASYS(testcount4_leaf, "testcount4", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count4, 0, 0xff, 0xff);

LEAF_ASYS(testcount5_leaf, "testcount5", VT_COUNTER,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_count5, 0, 0xff, 0xff);

/* The count TEST node */
STATIC
MIBARC_T	testcount_arcs[] =  {ARC(1, testcount0_leaf),
				     ARC(2, testcount1_leaf),
				     ARC(3, testcount2_leaf),
				     ARC(4, testcount3_leaf),
				     ARC(5, testcount4_leaf),
				     ARC(6, testcount5_leaf),
				     END_OF_ARC_LIST};
STATIC
MIBNODE_T	testcount_node = NODE("testcount", testcount_arcs);

LEAF_ASYS(testgauge0_leaf, "testgauge0", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge0, 0, 0xff, 0xff);

LEAF_ASYS(testgauge1_leaf, "testgauge1", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge1, 0, 0xff, 0xff);

LEAF_ASYS(testgauge2_leaf, "testgauge2", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge2, 0, 0xff, 0xff);

LEAF_ASYS(testgauge3_leaf, "testgauge3", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge3, 0, 0xff, 0xff);

LEAF_ASYS(testgauge4_leaf, "testgauge4", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge4, 0, 0xff, 0xff);

LEAF_ASYS(testgauge5_leaf, "testgauge5", VT_GAUGE,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_gauge5, 0, 0xff, 0xff);

/* The gauge TEST node */
STATIC
MIBARC_T	testgauge_arcs[] = {ARC(1, testgauge0_leaf),
				    ARC(2, testgauge1_leaf),
				    ARC(3, testgauge2_leaf),
				    ARC(4, testgauge3_leaf),
				    ARC(5, testgauge4_leaf),
				    ARC(6, testgauge5_leaf),
				    END_OF_ARC_LIST};
STATIC
MIBNODE_T	testgauge_node = NODE("testgauge", testgauge_arcs);

LEAF_ASYS(testtime0_leaf, "testtime0", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time0, 0, 0xff, 0xff);

LEAF_ASYS(testtime1_leaf, "testtime1", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time1, 0, 0xff, 0xff);

LEAF_ASYS(testtime2_leaf, "testtime2", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time2, 0, 0xff, 0xff);

LEAF_ASYS(testtime3_leaf, "testtime3", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time3, 0, 0xff, 0xff);

LEAF_ASYS(testtime4_leaf, "testtime4", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time4, 0, 0xff, 0xff);

LEAF_ASYS(testtime5_leaf, "testtime5", VT_TIMETICKS,
	  READ_ACCESS, 0, it_exists_async, get_uint_async,
	  null_set_async, std_next_async,
	  &test_time5, 0, 0xff, 0xff);

/* The time TEST node */
STATIC
MIBARC_T	testtime_arcs[] = {ARC(1, testtime0_leaf),
				   ARC(2, testtime1_leaf),
				   ARC(3, testtime2_leaf),
				   ARC(4, testtime3_leaf),
				   ARC(5, testtime4_leaf),
				   ARC(6, testtime5_leaf),
				   END_OF_ARC_LIST};
STATIC
MIBNODE_T	testtime_node = NODE("testtime", testtime_arcs);

/* We only include the following variables if v2 types are installed */
#if (INSTALL_ENVOY_SNMP_VERSION_2 || INSTALL_ENVOY_SNMP_USE_V2_TYPES)
LEAF_ASYS(testbigc0_leaf, "testbigc0", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc0, 0, 0xff, 0xff);

LEAF_ASYS(testbigc1_leaf, "testbigc1", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc1, 0, 0xff, 0xff);

LEAF_ASYS(testbigc2_leaf, "testbigc2", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc2, 0, 0xff, 0xff);

LEAF_ASYS(testbigc3_leaf, "testbigc3", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc3, 0, 0xff, 0xff);

LEAF_ASYS(testbigc4_leaf, "testbigc4", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc4, 0, 0xff, 0xff);

LEAF_ASYS(testbigc51_leaf, "testbigc51", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc51, 0, 0xff, 0xff);

LEAF_ASYS(testbigc52_leaf, "testbigc52", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc52, 0, 0xff, 0xff);

LEAF_ASYS(testbigc6_leaf, "testbigc6", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc6, 0, 0xff, 0xff);

LEAF_ASYS(testbigc7_leaf, "testbigc7", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc7, 0, 0xff, 0xff);

LEAF_ASYS(testbigc8_leaf, "testbigc8", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc8, 0, 0xff, 0xff);

LEAF_ASYS(testbigc9_leaf, "testbigc9", VT_COUNTER64,
	  READ_ACCESS, 0, it_exists_async, get_ui64_async,
	  null_set_async, std_next_async,
	  &test_bigc9, 0, 0xff, 0xff);

/* The 64 bit count TEST node */
STATIC
MIBARC_T	testbigc_arcs[] = {ARC(1, testbigc0_leaf),
				   ARC(2, testbigc1_leaf),
				   ARC(3, testbigc2_leaf),
				   ARC(4, testbigc3_leaf),
				   ARC(5, testbigc4_leaf),
				   ARC(6, testbigc51_leaf),
				   ARC(7, testbigc52_leaf),
				   ARC(8, testbigc6_leaf),
				   ARC(9, testbigc7_leaf),
				   ARC(10, testbigc8_leaf),
				   ARC(11, testbigc9_leaf),
				   END_OF_ARC_LIST};
STATIC
MIBNODE_T	testbigc_node = NODE("testbigc", testbigc_arcs);
#endif /* (INSTALL_ENVOY_SNMP_VERSION_2 || INSTALL_ENVOY_SNMP_USE_V2_TYPES) */


LEAF_ASYS(teststr0_leaf, "teststring0", VT_STRING,
	  READ_ACCESS, 0, it_exists_async, get_string_async,
	  null_set_async, std_next_async,
	  (char *)&test_string0[0], 0, 0xff, 0xff);

LEAF_ASYS(teststr1_leaf, "teststring1", VT_STRING,
	  READ_ACCESS, 0, it_exists_async, get_string_async,
	  null_set_async, std_next_async,
	  (char *)&test_string1[0], 0, 0xff, 0xff);

/* The string TEST node */
STATIC
MIBARC_T	teststr_arcs[] = {ARC(1, teststr0_leaf),
				  ARC(2, teststr1_leaf),
				  END_OF_ARC_LIST};
STATIC
MIBNODE_T	teststr_node = NODE("teststr", teststr_arcs);


LEAF_ASYS(testipaddr0_leaf, "testipaddr0", VT_IPADDRESS,
	  READ_ACCESS, 0, it_exists_async, get_ip_address_async,
	  null_set_async, std_next_async,
	  (char *)&test_ipaddr0[0], 0, 0xff, 0xff);

LEAF_ASYS(testipaddr1_leaf, "testipaddr1", VT_IPADDRESS,
	  READ_ACCESS, 0, it_exists_async, get_ip_address_async,
	  null_set_async, std_next_async,
	  (char *)&test_ipaddr1[0], 0, 0xff, 0xff);

LEAF_ASYS(testipaddr2_leaf, "testipaddr2", VT_IPADDRESS,
	  READ_ACCESS, 0, it_exists_async, get_ip_address_async,
	  null_set_async, std_next_async,
	  (char *)&test_ipaddr2[0], 0, 0xff, 0xff);

/* The ipaddr TEST node */
STATIC
MIBARC_T	testipaddr_arcs[] = {ARC(1, testipaddr0_leaf),
				     ARC(2, testipaddr1_leaf),
       				     ARC(3, testipaddr2_leaf),
				     END_OF_ARC_LIST};
STATIC
MIBNODE_T	testipaddr_node = NODE("testipaddr", testipaddr_arcs);

				   
/* The TEST node */
STATIC
MIBARC_T	test_arcs[] = {ARC(1, testint_node),
			       ARC(3, testcount_node),
			       ARC(4, testgauge_node),
			       ARC(5, testtime_node),
/* We only include the following variables if v2 types are installed */
#if (INSTALL_ENVOY_SNMP_VERSION_2 || INSTALL_ENVOY_SNMP_USE_V2_TYPES)
			       ARC(6, testbigc_node),
#endif /* (INSTALL_ENVOY_SNMP_VERSION_2 || INSTALL_ENVOY_SNMP_USE_V2_TYPES) */
			       ARC(8, teststr_node),
			       ARC(9, testipaddr_node),
			       END_OF_ARC_LIST};
STATIC
MIBNODE_T	test_node = NODE("test", test_arcs);

/**********************************************************************
	HIGHER LEVEL COMPONENTS OF THE MIB TREE
 **********************************************************************/
/* The First MIB node */
STATIC
MIBARC_T	mib1_arcs[] = {ARC(MIB_SYSTEM, system_node),
			       ARC(MIB_INTERFACES, interfaces_node),
			       ARC(MIB_AT, at_node),
			       ARC(MIB_IP, ip_node),
			       ARC(MIB_ICMP, icmp_node),
			       ARC(MIB_TCP, tcp_node),
			       ARC(MIB_UDP, udp_node),
#if defined(EGP_GROUP)
			       ARC(MIB_EGP, egp_node),
#endif
			       END_OF_ARC_LIST};
STATIC
MIBNODE_T	mib1_node = NODE("mib", mib1_arcs);

/* The MGMT node */
STATIC
MIBARC_T	mgmt_arcs[] = {ARC(MIB_MIB1, mib1_node),
			       END_OF_ARC_LIST};
STATIC
MIBNODE_T	mgmt_node = NODE("mgmt", mgmt_arcs);

/* The Epilogue node */
STATIC
MIBARC_T	epilogue_arcs[] = {ARC(8, test_node),
			           END_OF_ARC_LIST};
STATIC
MIBNODE_T	epilogue_node = NODE("epilogue", epilogue_arcs);

/* The Enterprise node */
STATIC
MIBARC_T	enterprise_arcs[] = {
				    ARC(12, epilogue_node),
			            END_OF_ARC_LIST};
STATIC
MIBNODE_T	enterprise_node = NODE("enterprise", enterprise_arcs);

/* The PRIVATE node */
STATIC
MIBARC_T	private_arcs[] = {ARC(MIB_ENTERPRISE, enterprise_node),
			       END_OF_ARC_LIST};
STATIC
MIBNODE_T	private_node = NODE("private", private_arcs);

/* The Internet node */
STATIC
MIBARC_T	internet_arcs[] = {ARC(MIB_MGMT, mgmt_node),
				   ARC(MIB_PRIVATE, private_node),
				   END_OF_ARC_LIST};
STATIC
MIBNODE_T	internet_node = NODE("internet", internet_arcs);

/* The DoD node */
STATIC
MIBARC_T	dod_arcs[] = {ARC(MIB_INTERNET, internet_node),
			      END_OF_ARC_LIST};
STATIC
MIBNODE_T	dod_node = NODE("dod", dod_arcs);

/* The US International ORGinatization node */
STATIC
MIBARC_T	us_arcs[] = {ARC(MIB_DOD, dod_node),
			     END_OF_ARC_LIST};
STATIC
MIBNODE_T	us_node = NODE("org", us_arcs);

/* The ISO node */
STATIC
MIBARC_T	iso_arcs[] = {ARC(MIB_ORG, us_node),
			      END_OF_ARC_LIST};
STATIC
MIBNODE_T	iso_node = NODE("iso", iso_arcs);

/* Root of the MIB */
STATIC
MIBARC_T	rootarcs[] = {ARC(MIB_ISO, iso_node),
			       END_OF_ARC_LIST};
MIBNODE_T	mib_root_node = NODE("", rootarcs);