--- a/usr/src/cmd/picl/plugins/common/devtree/picldevtree.c	Sat Mar 31 14:17:25 2007 -0700
+++ b/usr/src/cmd/picl/plugins/common/devtree/picldevtree.c	Sat Mar 31 18:24:05 2007 -0700
@@ -19,7 +19,7 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -3212,6 +3212,9 @@
 	if (strcmp(mach_name, "sun4u") == 0) {
 		builtin_map_ptr = sun4u_map;
 		builtin_map_size = sizeof (sun4u_map) / sizeof (builtin_map_t);
+	} else if (strcmp(mach_name, "sun4v") == 0) {
+		builtin_map_ptr = sun4u_map;
+		builtin_map_size = sizeof (sun4u_map) / sizeof (builtin_map_t);
 	} else if (strcmp(mach_name, "i86pc") == 0) {
 		builtin_map_ptr = i86pc_map;
 		builtin_map_size = sizeof (i86pc_map) / sizeof (builtin_map_t);

--- a/usr/src/cmd/picl/plugins/inc/picldefs.h	Sat Mar 31 14:17:25 2007 -0700
+++ b/usr/src/cmd/picl/plugins/inc/picldefs.h	Sat Mar 31 18:24:05 2007 -0700
@@ -20,7 +20,7 @@
  */
 
 /*
- * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -110,6 +110,27 @@
 #define	PICL_CLASS_CHASSIS_SERIAL_NUM	"chassis-serial-number"
 
 /*
+ * Sun4v platforms do not create /frutree; instead they create
+ * the /physical-platform subtree. The following is the list of
+ * additional PICL classes that may be present in /physical-platform
+ */
+#define	PICL_CLASS_ALARM		"alarm"
+#define	PICL_CLASS_BACKPLANE		"backplane"
+#define	PICL_CLASS_BATTERY		"battery"
+#define	PICL_CLASS_CHASSIS		"chassis"
+#define	PICL_CLASS_CONTAINER		"container"
+#define	PICL_CLASS_MODULE		"module"
+#define	PICL_CLASS_OTHER		"other"
+#define	PICL_CLASS_POWERSUPPLY		"power-supply"
+#define	PICL_CLASS_RPM_INDICATOR	"rpm-indicator"
+#define	PICL_CLASS_RPM_SENSOR		"rpm-sensor"
+#define	PICL_CLASS_PRESENCE_INDICATOR	"presence-indicator"
+#define	PICL_CLASS_INDICATOR		"indicator"
+#define	PICL_CLASS_SENSOR		"sensor"
+#define	PICL_CLASS_STACK		"stack"
+#define	PICL_CLASS_UNKNOWN		"unknown"
+
+/*
  * Solaris driver property names
  */
 #define	PICL_PROP_INSTANCE		"instance"
@@ -203,6 +224,25 @@
 #define	PICL_UNITADDR_LEN_MAX		256
 
 /*
+ * Additional PICL properties for Sun4v platforms
+ */
+#define	PICL_PROP_BATTERY_STATUS		"BatteryStatus"
+#define	PICL_PROP_EXPECTED			"Expected"
+#define	PICL_PROP_FW_REVISION			"FW-version"
+#define	PICL_PROP_HW_REVISION			"HW-version"
+#define	PICL_PROP_IS_REPLACEABLE		"Replaceable"
+#define	PICL_PROP_IS_HOT_SWAPPABLE		"HotSwappable"
+#define	PICL_PROP_IS_FRU			"FRU"
+#define	PICL_PROP_PHYS_DESCRIPTION		"Description"
+#define	PICL_PROP_SPEED				"Speed"
+#define	PICL_PROP_MFG_NAME			"MfgName"
+#define	PICL_PROP_MODEL_NAME			"ModelName"
+#define	PICL_PROP_SENSOR_VALUE			"SensorValue"
+#define	PICL_PROP_BASE_UNITS			"BaseUnits"
+#define	PICL_PROP_EXPONENT			"Exponent"
+#define	PICL_PROP_RATE_UNITS			"RateUnits"
+
+/*
  * Various threshold property names
  */
 #define	PICL_PROP_LOW_POWER_OFF			"LowPowerOffThreshold"

--- a/usr/src/cmd/picl/plugins/sun4v/Makefile	Sat Mar 31 14:17:25 2007 -0700
+++ b/usr/src/cmd/picl/plugins/sun4v/Makefile	Sat Mar 31 18:24:05 2007 -0700
@@ -2,9 +2,8 @@
 # CDDL HEADER START
 #
 # The contents of this file are subject to the terms of the
-# Common Development and Distribution License, Version 1.0 only
-# (the "License").  You may not use this file except in compliance
-# with the License.
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
 #
 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 # or http://www.opensolaris.org/os/licensing.
@@ -19,27 +18,35 @@
 #
 # CDDL HEADER END
 #
+
 #
-# Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
+# ident	"%Z%%M%	%I%	%E% SMI"
+#
+
 #
 # cmd/picl/plugins/sun4v/Makefile
 #
 
-SUBDIRS= mdesc ontario
+SUBDIRS= lib .WAIT snmp .WAIT mdesc pri ontario
+
+MSGSUBDIRS=	snmp
 
 all :=		TARGET= all
 install :=	TARGET= install
 clean :=	TARGET= clean
 clobber :=	TARGET= clobber
 lint :=		TARGET= lint
+_msg :=		TARGET= _msg
 
 .KEEP_STATE:
 
 all install clean clobber lint : $(SUBDIRS)
 
+_msg:	$(MSGSUBDIRS)
+
 $(SUBDIRS): FRC
 	@cd $@; pwd; $(MAKE) $(TARGET)
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/include/libpiclsnmp.h	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,60 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_LIBPICLSNMP_H
+#define	_LIBPICLSNMP_H
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Opaque picl snmp handle
+ */
+typedef void	*picl_snmphdl_t;
+
+/*
+ * Exported interfaces
+ */
+extern picl_snmphdl_t snmp_init(void);
+extern void snmp_fini(picl_snmphdl_t);
+
+extern int snmp_reinit(picl_snmphdl_t hdl, int clr_linkreset);
+extern void snmp_register_group(picl_snmphdl_t, char *, int, int);
+
+extern int snmp_get_int(picl_snmphdl_t, char *, int, int *, int *);
+extern int snmp_get_str(picl_snmphdl_t, char *, int, char **, int *);
+extern int snmp_get_bitstr(picl_snmphdl_t, char *, int, uchar_t **,
+	    uint_t *, int *);
+extern int snmp_get_nextrow(picl_snmphdl_t, char *, int, int *, int *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _LIBPICLSNMP_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/include/picloids.h	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,355 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_PICLOIDS_H
+#define	_PICLOIDS_H
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * IETF OIDs (not all are used by PICL)
+ */
+#define	OID_ISO				"1"
+#define	OID_ORG				OID_ISO ".3"
+#define	OID_DOD				OID_ORG ".6"
+#define	OID_INTERNET			OID_DOD ".1"
+
+#define	OID_PRIVATE			OID_INTERNET ".4"
+#define	OID_ENTERPRISES			OID_PRIVATE ".1"
+#define	OID_SUN				OID_ENTERPRISES ".42"
+
+#define	OID_MGMT			OID_INTERNET ".2"
+#define	OID_MIB2			OID_MGMT ".1"
+#define	OID_entityMIB			OID_MIB2 ".47"
+#define	OID_entityMIBObjects		OID_entityMIB ".1"
+
+#define	OID_entityPhysical		OID_entityMIBObjects ".1"
+#define	OID_entPhysicalTable		OID_entityPhysical ".1"
+#define	OID_entPhysicalEntry		OID_entPhysicalTable ".1"
+
+#define	OID_entPhysicalIndex		OID_entPhysicalEntry ".1"
+#define	OID_entPhysicalDescr		OID_entPhysicalEntry ".2"
+#define	OID_entPhysicalVendorType	OID_entPhysicalEntry ".3"
+#define	OID_entPhysicalContainedIn	OID_entPhysicalEntry ".4"
+#define	OID_entPhysicalClass		OID_entPhysicalEntry ".5"
+#define	OID_entPhysicalParentRelPos	OID_entPhysicalEntry ".6"
+#define	OID_entPhysicalName		OID_entPhysicalEntry ".7"
+#define	OID_entPhysicalHardwareRev	OID_entPhysicalEntry ".8"
+#define	OID_entPhysicalFirmwareRev	OID_entPhysicalEntry ".9"
+#define	OID_entPhysicalSoftwareRev	OID_entPhysicalEntry ".10"
+#define	OID_entPhysicalSerialNum	OID_entPhysicalEntry ".11"
+#define	OID_entPhysicalMfgName		OID_entPhysicalEntry ".12"
+#define	OID_entPhysicalModelName	OID_entPhysicalEntry ".13"
+#define	OID_entPhysicalAlias		OID_entPhysicalEntry ".14"
+#define	OID_entPhysicalAssetID		OID_entPhysicalEntry ".15"
+#define	OID_entPhysicalIsFRU		OID_entPhysicalEntry ".16"
+
+/*
+ * Conceptual row change time for handling hotplug/hotswap events
+ */
+#define	OID_entityGeneral		OID_entityMIBObjects ".4"
+#define	OID_entLastChangeTime		OID_entityGeneral ".1"
+
+/*
+ * Sun Platform MIB OIDs used by PICL
+ */
+#define	OID_products			OID_SUN ".2"
+#define	OID_sunFire			OID_products ".70"
+#define	OID_sunPlatMIB			OID_sunFire ".101"
+#define	OID_sunPlatMIBObjects		OID_sunPlatMIB ".1"
+#define	OID_sunPlatMIBPhysicalObjects	OID_sunPlatMIBObjects ".1"
+
+/*
+ * Equipment Table
+ */
+#define	OID_sunPlatEquipmentTable	OID_sunPlatMIBPhysicalObjects ".2"
+#define	OID_sunPlatEquipmentEntry	OID_sunPlatEquipmentTable ".1"
+#define	OID_sunPlatEquipmentOperationalState	\
+					OID_sunPlatEquipmentEntry ".2"
+
+/*
+ * Equipment Holder Table
+ */
+#define	OID_sunPlatEquipmentHolderTable	OID_sunPlatMIBPhysicalObjects ".3"
+#define	OID_sunPlatEquipmentHolderEntry	OID_sunPlatEquipmentHolderTable ".1"
+#define	OID_sunPlatEquipmentHolderAcceptableTypes	\
+					OID_sunPlatEquipmentHolderEntry ".2"
+
+/*
+ * Circuit Pack Table
+ */
+#define	OID_sunPlatCircuitPackTable	OID_sunPlatMIBPhysicalObjects ".4"
+#define	OID_sunPlatCircuitPackEntry	OID_sunPlatCircuitPackTable ".1"
+#define	OID_sunPlatCircuitPackReplaceable	\
+					OID_sunPlatCircuitPackEntry ".3"
+#define	OID_sunPlatCircuitPackHotSwappable	\
+					OID_sunPlatCircuitPackEntry ".4"
+
+/*
+ * Physical Class Table
+ */
+#define	OID_sunPlatPhysicalTable	OID_sunPlatMIBPhysicalObjects ".5"
+#define	OID_sunPlatPhysicalEntry	OID_sunPlatPhysicalTable ".1"
+#define	OID_sunPlatPhysicalClass	OID_sunPlatPhysicalEntry ".1"
+
+/*
+ * Sensor Table
+ */
+#define	OID_sunPlatSensorTable		OID_sunPlatMIBPhysicalObjects ".6"
+#define	OID_sunPlatSensorEntry		OID_sunPlatSensorTable ".1"
+#define	OID_sunPlatSensorClass		OID_sunPlatSensorEntry ".1"
+#define	OID_sunPlatSensorType		OID_sunPlatSensorEntry ".2"
+
+/*
+ * Binary Sensor Table
+ */
+#define	OID_sunPlatBinarySensorTable	OID_sunPlatMIBPhysicalObjects ".7"
+#define	OID_sunPlatBinarySensorEntry	OID_sunPlatBinarySensorTable ".1"
+
+#define	OID_sunPlatBinarySensorCurrent	OID_sunPlatBinarySensorEntry ".1"
+#define	OID_sunPlatBinarySensorExpected	OID_sunPlatBinarySensorEntry ".2"
+#define	OID_sunPlatBinarySensorInterpretTrue	\
+					OID_sunPlatBinarySensorEntry ".3"
+#define	OID_sunPlatBinarySensorInterpretFalse	\
+					OID_sunPlatBinarySensorEntry ".4"
+
+/*
+ * Numeric Sensor Table
+ */
+#define	OID_sunPlatNumericSensorTable	OID_sunPlatMIBPhysicalObjects ".8"
+#define	OID_sunPlatNumericSensorEntry	OID_sunPlatNumericSensorTable ".1"
+#define	OID_sunPlatNumericSensorCurrent	OID_sunPlatNumericSensorEntry ".4"
+#define	OID_sunPlatNumericSensorBaseUnits	\
+					OID_sunPlatNumericSensorEntry ".1"
+#define	OID_sunPlatNumericSensorExponent	\
+					OID_sunPlatNumericSensorEntry ".2"
+#define	OID_sunPlatNumericSensorRateUnits	\
+					OID_sunPlatNumericSensorEntry ".3"
+#define	OID_sunPlatNumericSensorLowerThresholdNonCritical	\
+					OID_sunPlatNumericSensorEntry ".8"
+#define	OID_sunPlatNumericSensorUpperThresholdNonCritical	\
+					OID_sunPlatNumericSensorEntry ".9"
+#define	OID_sunPlatNumericSensorLowerThresholdCritical	\
+					OID_sunPlatNumericSensorEntry ".10"
+#define	OID_sunPlatNumericSensorUpperThresholdCritical	\
+					OID_sunPlatNumericSensorEntry ".11"
+#define	OID_sunPlatNumericSensorLowerThresholdFatal	\
+					OID_sunPlatNumericSensorEntry ".12"
+#define	OID_sunPlatNumericSensorUpperThresholdFatal	\
+					OID_sunPlatNumericSensorEntry ".13"
+#define	OID_sunPlatNumericSensorEnabledThresholds	\
+					OID_sunPlatNumericSensorEntry ".15"
+
+/*
+ * Alarm Table
+ */
+#define	OID_sunPlatAlarmTable		OID_sunPlatMIBPhysicalObjects ".12"
+#define	OID_sunPlatAlarmEntry		OID_sunPlatAlarmTable ".1"
+#define	OID_sunPlatAlarmType		OID_sunPlatAlarmEntry ".1"
+#define	OID_sunPlatAlarmState		OID_sunPlatAlarmEntry ".2"
+
+/*
+ * Power Supply Table
+ */
+#define	OID_sunPlatPowerSupplyTable	OID_sunPlatMIBPhysicalObjects ".14"
+#define	OID_sunPlatPowerSupplyEntry	OID_sunPlatPowerSupplyTable ".1"
+#define	OID_sunPlatPowerSupplyClass	OID_sunPlatPowerSupplyEntry ".1"
+
+/*
+ * Battery Table
+ */
+#define	OID_sunPlatBatteryTable		OID_sunPlatMIBPhysicalObjects ".15"
+#define	OID_sunPlatBatteryEntry		OID_sunPlatBatteryTable ".1"
+#define	OID_sunPlatBatteryStatus	OID_sunPlatBatteryEntry ".1"
+
+/*
+ * Integer enumeration classes used by PICL
+ */
+typedef enum {
+	ST_TRUE = 1,
+	ST_FALSE = 2
+} snmp_truthval_t;
+
+/*
+ * Note that the truth values could be much longer than the length
+ * of the strings "true" or "false", since we actuallly interpret them
+ * using InterpretTrue and InterpretFalse values in the MIB. Currently
+ * we limit them to be 32 (see MAX_TRUTHVAL_LEN definition below)
+ */
+#define	STR_ST_TRUE	"true"
+#define	STR_ST_FALSE	"false"
+
+/* entPhysicalClass */
+typedef enum {
+	SPC_OTHER = 1,
+	SPC_UNKNOWN = 2,
+	SPC_CHASSIS = 3,
+	SPC_BACKPLANE = 4,
+	SPC_CONTAINER = 5,
+	SPC_POWERSUPPLY = 6,
+	SPC_FAN = 7,
+	SPC_SENSOR = 8,
+	SPC_MODULE = 9,
+	SPC_PORT = 10,
+	SPC_STACK = 11
+} snmp_physical_class_t;
+
+/* sunPlatEquipmentOperationalState */
+typedef enum {
+	SSOS_DISABLED = 1,
+	SSOS_ENABLED = 2
+} snmp_sunplat_op_state_t;
+
+/*
+ * Update MAX_OPSTATE_LEN below if these strings are changed
+ */
+#define	STR_SSOS_DISABLED	"disabled"
+#define	STR_SSOS_ENABLED	"enabled"
+
+/* sunPlatPhysicalClass */
+typedef enum {
+	SSPC_OTHER = 1,
+	SSPC_ALARM = 2,
+	SSPC_WATCHDOG = 3
+} snmp_sunplat_phys_class_t;
+
+/* sunPlatSensorClass */
+typedef enum {
+	SSSC_BINARY = 1,
+	SSSC_NUMERIC = 2,
+	SSSC_DISCRETE = 3
+} snmp_sunplat_sensor_class_t;
+
+/* sunPlatSensorType */
+typedef enum {
+	SSST_OTHER = 1,
+	SSST_UNKNOWN = 2,
+	SSST_TEMPERATURE = 3,
+	SSST_VOLTAGE = 4,
+	SSST_CURRENT = 5,
+	SSST_TACHOMETER = 6,
+	SSST_COUNTER = 7,
+	SSST_SWITCH = 8,
+	SSST_LOCK = 9,
+	SSST_HUMIDITY = 10,
+	SSST_SMOKE_DETECTION = 11,
+	SSST_PRESENCE = 12,
+	SSST_AIRFLOW = 13
+} snmp_sunplat_sensor_type_t;
+
+/* sunPlatAlarmType */
+typedef enum {
+	SSAT_OTHER = 1,
+	SSAT_AUDIBLE = 2,
+	SSAT_VISIBLE = 3,
+	SSAT_MOTION = 4,
+	SSAT_SWITCH = 5
+} snmp_sunplat_alarm_type_t;
+
+/* sunPlatAlarmState */
+typedef enum {
+	SSAS_UNKNOWN = 1,
+	SSAS_OFF = 2,
+	SSAS_STEADY = 3,
+	SSAS_ALTERNATING = 4
+} snmp_sunplat_alarm_state_t;
+
+/*
+ * Update MAX_ALARMSTATE_LEN below if these strings are changed
+ */
+#define	STR_SSAS_UNKNOWN	"unknown"
+#define	STR_SSAS_OFF		"off"
+#define	STR_SSAS_STEADY		"steady"
+#define	STR_SSAS_ALTERNATING	"alternating"
+
+/*
+ * Bit masks for the sunPlatNumericSensorEnabledThresholds
+ */
+#define	LOWER_NON_CRITICAL	0x80
+#define	UPPER_NON_CRITICAL	0x40
+#define	LOWER_CRITICAL		0x20
+#define	UPPER_CRITICAL		0x10
+#define	LOWER_FATAL		0x08
+#define	UPPER_FATAL		0x04
+
+/*
+ * sunPlatPowerSupplyClass
+ */
+typedef enum {
+	SSPSC_OTHER = 1,
+	SSPSC_POWERSUPPLY = 2,
+	SSPSC_BATTERY = 3
+} snmp_sunplat_power_supply_class_t;
+
+/*
+ * sunPlatBatteryStatus
+ */
+typedef enum {
+	SSBS_OTHER = 1,
+	SSBS_UNKNOWN = 2,
+	SSBS_FULLYCHARGED = 3,
+	SSBS_LOW = 4,
+	SSBS_CRITICAL = 5,
+	SSBS_CHARGING = 6,
+	SSBS_CHARGING_AND_LOW = 7,
+	SSBS_CHARGING_AND_HIGH = 8,
+	SSBS_CHARGING_AND_CRITICAL = 9,
+	SSBS_UNDEFINED = 10,
+	SSBS_PARTIALLY_CHARGED = 11
+} snmp_sunplat_battery_status_t;
+
+/*
+ * Update MAX_BATTERYSTATUS_LEN below if these strings are changed
+ */
+#define	STR_SSBS_OTHER			"Other"
+#define	STR_SSBS_UNKNOWN		"Unknown"
+#define	STR_SSBS_FULLYCHARGED		"Fully Charged"
+#define	STR_SSBS_LOW			"Low"
+#define	STR_SSBS_CRITICAL		"Critical"
+#define	STR_SSBS_CHARGING		"Charging"
+#define	STR_SSBS_CHARGING_AND_LOW	"Charging and Low"
+#define	STR_SSBS_CHARGING_AND_HIGH	"Charging and High"
+#define	STR_SSBS_CHARGING_AND_CRITICAL	"Charging and Critical"
+#define	STR_SSBS_UNDEFINED		"Undefined"
+#define	STR_SSBS_PARTIALLY_CHARGED	"Partially Charged"
+
+/*
+ * Max limits of all volatiles
+ */
+#define	MAX_OPSTATE_LEN			10
+#define	MAX_ALARMSTATE_LEN		12
+#define	MAX_TRUTHVAL_LEN		32
+#define	MAX_BATTERYSTATUS_LEN		32
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _PICLOIDS_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/Makefile	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,48 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+#
+
+#
+# cmd/picl/plugins/sun4v/lib/Makefile
+#
+
+SUBDIRS=	snmp .WAIT
+
+all :=		TARGET= all
+install :=	TARGET= install
+clean :=	TARGET= clean
+clobber :=	TARGET= clobber
+lint :=		TARGET= lint
+
+.KEEP_STATE:
+
+all install clean clobber lint : $(SUBDIRS)
+
+$(SUBDIRS): FRC
+	@cd $@; pwd; $(MAKE) $(TARGET)
+
+FRC:

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/Makefile	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,108 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+#
+
+#
+# cmd/picl/plugins/sun4v/lib/snmp/Makefile
+#
+
+LIBRARY=	libpiclsnmp.a
+VERS=		.1
+OBJECTS=	snmplib.o pdu.o asn1.o debug.o
+
+# include library definitions
+include $(SRC)/Makefile.psm
+include $(SRC)/lib/Makefile.lib
+
+ROOT_PLATFORM = $(USR_PLAT_DIR)/sun4v
+
+include $(SRC)/cmd/picl/plugins/Makefile.com
+
+SRCS=		$(OBJECTS:%.o=%.c)
+
+LIBS=		$(DYNLIB)
+
+ROOTLIBDIR      = $(ROOT_PLATFORM)/lib
+ROOTLIBDIR      := OWNER = root
+ROOTLIBDIR      := GROUP = sys
+
+CLEANFILES=	$(LINTOUT) $(LINTLIB)
+CLOBBERFILES += $(LIBLINKS)
+
+CPPFLAGS +=	-I. -I../../include -I$(SRC)/uts/sun4v
+CPPFLAGS +=	-D_REENTRANT
+
+#
+# Be careful when enabling SNMP_DEBUG; the debug log can quickly grow
+# very very large. Never run cycle stress test with SNMP_DEBUG enabled!
+#
+#CPPFLAGS +=	-DSNMP_DEBUG
+
+#
+# Do NOT uncomment the following two lines, unless you want to test
+# the behavior of the library with an SNMP agent over network.
+#
+#CPPFLAGS +=	-DUSE_SOCKETS
+#LDLIBS +=	-lsocket -lnsl
+
+CFLAGS +=	$(CCVERBOSE) -DBIG_ENDIAN
+LDLIBS +=	-lc -lnvpair
+
+# It's OK not to build debug.c except when SNMP_DEBUG is enabled.
+# Don't let lint complain about it.
+#
+ALWAYS_LINT_DEFS +=	-erroff=E_EMPTY_TRANSLATION_UNIT
+
+.KEEP_STATE:
+
+
+SUBDIRS=
+
+all :=		TARGET= all
+install :=	TARGET= install
+clean :=	TARGET= clean
+clobber :=	TARGET= clobber
+lint :=		TARGET= lint
+
+all:  $(DYNLIB) $(LIBLINKS)
+
+install:	$(ROOTLIBDIR) all $(ROOTLIBS) $(ROOTLINKS)
+
+$(LIBLINKS):	FRC
+	$(RM) $@; $(SYMLINK) $(DYNLIB) $@
+
+# include library targets
+include $(SRC)/cmd/picl/plugins/Makefile.targ
+include $(SRC)/lib/Makefile.targ
+
+lint :
+	$(LINT.c) -m $(SRCS)
+
+$(SUBDIRS): FRC
+	@cd $@; pwd; $(MAKE) $(TARGET)
+
+FRC:

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/asn1.c	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,760 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ * ASN.1 encoding related routines
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include "asn1.h"
+#include "pdu.h"
+#include "debug.h"
+
+/*
+ * This routine builds a 'SEQUENCE OF' ASN.1 object in the buffer
+ * using the 'id' and 'length' supplied. This is probably the place
+ * where using "reverse" asn encoding will help.
+ */
+uchar_t *
+asn_build_sequence(uchar_t *buf, size_t *bufsz_p, uchar_t id, size_t length)
+{
+	/*
+	 * When rebuilding sequence (which we do many times), we'll
+	 * simply pass NULL to bufsz_p to skip the error check.
+	 */
+	if ((bufsz_p) && (*bufsz_p < 4))
+		return (NULL);
+
+	buf[0] = id;
+	buf[1] = (uchar_t)(ASN_LONG_LEN | 0x02);	/* following 2 octets */
+	buf[2] = (uchar_t)((length >> 8) & 0xff);
+	buf[3] = (uchar_t)(length & 0xff);
+
+	if (bufsz_p)
+		*bufsz_p -= 4;
+
+	LOGASNSEQ(buf, 4);
+
+	return (buf + 4);
+}
+
+/*
+ * The next two routines, asn_build_header() and asn_build_length(), build
+ * the header and length for an arbitrary object type into the buffer. The
+ * length of the object is encoded using as few length octets as possible.
+ */
+uchar_t *
+asn_build_header(uchar_t *buf, size_t *bufsz_p, uchar_t id, size_t length)
+{
+	if (*bufsz_p < 1)
+		return (NULL);
+
+	buf[0] = id;
+	(*bufsz_p)--;
+
+	return (asn_build_length(buf + 1, bufsz_p, length));
+}
+uchar_t *
+asn_build_length(uchar_t *buf, size_t *bufsz_p, size_t length)
+{
+	if (length < 0x80) {
+		if (*bufsz_p < 1)
+			return (NULL);
+		buf[0] = (uchar_t)length;
+		(*bufsz_p)--;
+
+		LOGASNLENGTH(buf, 1);
+
+		return (buf + 1);
+
+	} else if (length <= 0xFF) {
+		if (*bufsz_p < 2)
+			return (NULL);
+		buf[0] = (uchar_t)(ASN_LONG_LEN | 0x01);
+		buf[1] = (uchar_t)length;
+		*bufsz_p -= 2;
+
+		LOGASNLENGTH(buf, 2);
+
+		return (buf + 2);
+
+	} else {
+		if (*bufsz_p < 3)
+			return (NULL);
+
+		buf[0] = (uchar_t)(ASN_LONG_LEN | 0x02);
+		buf[1] = (uchar_t)((length >> 8) & 0xff);
+		buf[2] = (uchar_t)(length & 0xff);
+		*bufsz_p -= 3;
+
+		LOGASNLENGTH(buf, 3);
+
+		return (buf + 3);
+	}
+}
+/*
+ * Builds an ASN.1 encoded integer in the buffer using as few octets
+ * as possible.
+ */
+uchar_t *
+asn_build_int(uchar_t *buf, size_t *bufsz_p, uchar_t id, int val)
+{
+	uint_t	uival;
+	int	ival, i;
+	short	sval;
+	char	cval;
+
+	size_t	valsz;
+	uchar_t	*p, *valp;
+
+	/*
+	 * We need to "pack" the integer before sending it, so determine
+	 * the minimum number of bytes in which we can pack the integer
+	 */
+	uival = ((uint_t)val >> BUILD_INT_SHIFT) & BUILD_INT_MASK;
+	ival = val;
+	sval = (short)val;	/* yes, loss of data intended */
+	cval = (char)val;	/* yes, loss of data intended */
+
+	if (val == (int)cval)
+		valsz = 1;
+	else if (val == (int)sval)
+		valsz = 2;
+	else if (uival == BUILD_INT_MASK || uival == 0)
+		valsz = 3;
+	else
+		valsz = 4;
+
+	/*
+	 * Prepare the ASN.1 header for the integer
+	 */
+	if ((p = asn_build_header(buf, bufsz_p, id, valsz)) == NULL)
+		return (NULL);
+
+	/*
+	 * If we have enough space left, encode the integer
+	 */
+	if (*bufsz_p < valsz)
+		return (NULL);
+	else {
+		valp = (uchar_t *)&ival;
+		for (i = 0; i < valsz; i++)
+			p[i] = valp[sizeof (int) - valsz + i];
+
+		*bufsz_p -= valsz;
+
+		LOGASNINT(buf, p + valsz - buf);
+
+		return (p + valsz);
+	}
+}
+/*
+ * Builds an ASN.1 encoded octet string in the buffer. The source string
+ * need not be null-terminated.
+ */
+uchar_t *
+asn_build_string(uchar_t *buf, size_t *bufsz_p, uchar_t id, uchar_t *str,
+    size_t slen)
+{
+	uchar_t	*p;
+
+	if ((p = asn_build_header(buf, bufsz_p, id, slen)) == NULL)
+		return (NULL);
+
+	if (*bufsz_p < slen)
+		return (NULL);
+	else {
+	    if (str) {
+		    (void) memcpy(p, str, slen);
+	    } else {
+		    (void) memset(p, 0, slen);
+	    }
+
+	    *bufsz_p -= slen;
+
+	    LOGASNOCTSTR(buf, p + slen - buf);
+
+	    return (p + slen);
+	}
+}
+
+/*
+ * Builds an Object Identifier into the buffer according to the OID
+ * packing and encoding rules.
+ */
+uchar_t *
+asn_build_objid(uchar_t *buf, size_t *bufsz_p, uchar_t id, void *oidp,
+    size_t n_subids)
+{
+	oid	*objid = oidp;
+	size_t	oid_asnlen;
+	oid	subid, first_subid;
+	uchar_t	subid_len[MAX_SUBIDS_IN_OID];
+	uchar_t	*p;
+	int	i, ndx;
+
+	/*
+	 * Eliminate invalid cases
+	 */
+	if (n_subids < MIN_SUBIDS_IN_OID || n_subids > MAX_SUBIDS_IN_OID)
+		return (NULL);
+	if ((objid[0] > 2) || (objid[0] < 2 && objid[1] >= 40))
+		return (NULL);
+
+	/*
+	 * The BER encoding rule for the ASN.1 Object Identifier states
+	 * that after packing the first two subids into one, each subsequent
+	 * component is considered as the next subid. Each subidentifier is
+	 * then encoded as a non-negative integer using as few 7-bit blocks
+	 * as possible. The blocks are packed in octets with the first bit of
+	 * each octet equal to 1, except for the last octet of each subid.
+	 */
+	oid_asnlen = 0;
+	for (i = 0, ndx = 0; i < n_subids; i++, ndx++) {
+		if (i == 0) {
+			/*
+			 * The packing formula for the first two subids
+			 * of an OID is given by Z = (X * 40) + Y
+			 */
+			subid = objid[0] * 40 + objid[1];
+			first_subid = subid;
+			i++;	/* done with both subids 0 and 1 */
+		} else {
+			subid = objid[i];
+		}
+
+		if (subid < (oid) 0x80)
+			subid_len[ndx] = 1;
+		else if (subid < (oid) 0x4000)
+			subid_len[ndx] = 2;
+		else if (subid < (oid) 0x200000)
+			subid_len[ndx] = 3;
+		else if (subid < (oid) 0x10000000)
+			subid_len[ndx] = 4;
+		else {
+			subid_len[ndx] = 5;
+		}
+
+		oid_asnlen += subid_len[ndx];
+	}
+
+	if ((p = asn_build_header(buf, bufsz_p, id, oid_asnlen)) == NULL)
+		return (NULL);
+
+	if (*bufsz_p < oid_asnlen)
+		return (NULL);
+
+	/*
+	 * Store the encoded OID
+	 */
+	for (i = 0, ndx = 0; i < n_subids; i++, ndx++) {
+		if (i == 0) {
+			subid = first_subid;
+			i++;
+		} else {
+			subid = objid[i];
+		}
+
+		switch (subid_len[ndx]) {
+		case 1:
+			*p++ = (uchar_t)subid;
+			break;
+
+		case 2:
+			*p++ = (uchar_t)((subid >> 7) | 0x80);
+			*p++ = (uchar_t)(subid & 0x7f);
+			break;
+
+		case 3:
+			*p++ = (uchar_t)((subid >> 14) | 0x80);
+			*p++ = (uchar_t)(((subid >> 7) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(subid & 0x7f);
+			break;
+
+		case 4:
+			*p++ = (uchar_t)((subid >> 21) | 0x80);
+			*p++ = (uchar_t)(((subid >> 14) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(((subid >> 7) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(subid & 0x7f);
+			break;
+
+		case 5:
+			*p++ = (uchar_t)((subid >> 28) | 0x80);
+			*p++ = (uchar_t)(((subid >> 21) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(((subid >> 14) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(((subid >> 7) & 0x7f) | 0x80);
+			*p++ = (uchar_t)(subid & 0x7f);
+			break;
+		}
+	}
+
+	*bufsz_p -= oid_asnlen;
+
+	LOGASNOID(buf, p - buf);
+
+	return (p);
+}
+/*
+ * Build an ASN_NULL object val into the request packet
+ */
+uchar_t *
+asn_build_null(uchar_t *buf, size_t *bufsz_p, uchar_t id)
+{
+	uchar_t	*p;
+
+	p = asn_build_header(buf, bufsz_p, id, 0);
+
+	LOGASNNULL(buf, p - buf);
+
+	return (p);
+}
+
+
+
+/*
+ * This routine parses a 'SEQUENCE OF' object header from the input
+ * buffer stream. If the identifier tag (made up of class, constructed
+ * type and data type tag) does not match the expected identifier tag,
+ * returns failure.
+ */
+uchar_t *
+asn_parse_sequence(uchar_t *buf, size_t *bufsz_p, uchar_t exp_id)
+{
+	uchar_t	*p;
+	uchar_t	id;
+
+	if ((p = asn_parse_header(buf, bufsz_p, &id)) == NULL)
+		return (NULL);
+
+	if (id != exp_id)
+		return (NULL);
+
+	return (p);
+}
+/*
+ * Return the type identifier of the ASN object via 'id'
+ */
+uchar_t *
+asn_parse_header(uchar_t *buf, size_t *bufsz_p, uchar_t *id)
+{
+	uchar_t	*p;
+	size_t	asnobj_len, hdrlen;
+
+	/*
+	 * Objects with extension tag type are not supported
+	 */
+	if ((buf[0] & ASN_EXT_TAG) == ASN_EXT_TAG)
+		return (NULL);
+
+	/*
+	 * Parse the length field of the ASN object in the header
+	 */
+	if ((p = asn_parse_length(buf + 1, &asnobj_len)) == NULL)
+		return (NULL);
+
+	/*
+	 * Check if the rest of the msg packet is big enough for the
+	 * full length of the object
+	 */
+	hdrlen = p - buf;
+	if (*bufsz_p < (asnobj_len + hdrlen))
+		return (NULL);
+
+	*id = buf[0];
+	*bufsz_p -= hdrlen;
+
+	return (p);
+}
+/*
+ * This routine parses the length of the object as specified in its
+ * header. The 'Indefinite' form of representing length is not supported.
+ */
+uchar_t *
+asn_parse_length(uchar_t *buf, size_t *asnobj_len_p)
+{
+	uchar_t	*p;
+	int	n_length_octets;
+
+	/*
+	 * First, check for the short-definite form. Length of
+	 * the object is simply the least significant 7-bits of
+	 * the first byte.
+	 */
+	if ((buf[0] & ASN_LONG_LEN) == 0) {
+		*asnobj_len_p = (size_t)buf[0];
+		return (buf + 1);
+	}
+
+	/*
+	 * Then, eliminate the indefinite form. The ASN_LONG_LEN
+	 * bit of the first byte will be set and the least significant
+	 * 7-bites of that byte will be zeros.
+	 */
+	if (buf[0] == (uchar_t)ASN_LONG_LEN)
+		return (NULL);
+
+	/*
+	 * Then, eliminate the long-definite case when the number of
+	 * follow-up octets is more than what the size var can hold.
+	 */
+	n_length_octets = buf[0] & ~ASN_LONG_LEN;
+	if (n_length_octets > sizeof (*asnobj_len_p))
+		return (NULL);
+
+	/*
+	 * Finally gather the length
+	 */
+	p = buf + 1;
+	*asnobj_len_p = 0;
+	while (n_length_octets--) {
+		*asnobj_len_p <<= 8;
+		*asnobj_len_p |= *p++;
+	}
+
+	return (p);
+}
+/*
+ * Parses an integer out of the input buffer
+ */
+uchar_t *
+asn_parse_int(uchar_t *buf, size_t *bufsz_p, int *ival)
+{
+	size_t	asnobj_len, hdrlen;
+	uchar_t	int_id;
+	uchar_t	*p;
+
+	int_id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER;
+	if (buf[0] != int_id)
+		return (NULL);
+
+	/*
+	 * Read in the length of the object; Note that integers are
+	 * "packed" when sent from agent to manager and vice-versa,
+	 * so the size of the object could be less than sizeof (int).
+	 */
+	if ((p = asn_parse_length(buf + 1, &asnobj_len)) == NULL)
+		return (NULL);
+
+	/*
+	 * Is there sufficient space left in the packet to read the integer ?
+	 */
+	hdrlen = p - buf;
+	if (*bufsz_p < (hdrlen + asnobj_len))
+		return (NULL);
+
+	/*
+	 * Update space left in the buffer after the integer is read
+	 */
+	*bufsz_p -= (hdrlen + asnobj_len);
+
+	/*
+	 * Read in the integer value
+	 */
+	*ival = (*p & ASN_BIT8) ? -1 : 0;
+	while (asnobj_len--) {
+		*ival <<= 8;
+		*ival |= *p++;
+	}
+
+	return (p);
+}
+/*
+ * Parses an unsigned integer out of the input buffer
+ */
+uchar_t *
+asn_parse_uint(uchar_t *buf, size_t *bufsz_p, uint_t *uival)
+{
+	size_t	asnobj_len, hdrlen;
+	uchar_t	*p;
+
+	if ((buf[0] != ASN_COUNTER) && (buf[0] != ASN_TIMETICKS))
+		return (NULL);
+
+	/*
+	 * Read in the length of the object. Integers are sent the same
+	 * way unsigned integers are sent.  Except that, if the MSB was 1
+	 * in the unsigned int value, a null-byte is attached to the front.
+	 * Otherwise, packing rules are the same as for integer values.
+	 */
+	if ((p = asn_parse_length(buf + 1, &asnobj_len)) == NULL)
+		return (NULL);
+
+	/*
+	 * Is there sufficient space left in the packet to read in the value ?
+	 */
+	hdrlen = p - buf;
+	if (*bufsz_p < (hdrlen + asnobj_len))
+		return (NULL);
+
+	/*
+	 * Update space left in the buffer after the uint is read
+	 */
+	*bufsz_p -= (hdrlen + asnobj_len);
+
+	/*
+	 * Read in the unsigned integer (this should never get
+	 * initialized to ~0 if it was sent right)
+	 */
+	*uival = (*p & ASN_BIT8) ? ~0 : 0;
+	while (asnobj_len--) {
+		*uival <<= 8;
+		*uival |= *p++;
+	}
+
+	return (p);
+}
+/*
+ * Parses a string (ASN_OCTET_STR or ASN_BIT_STR) out of the input buffer.
+ * The memory for the string is allocated inside the routine and must be
+ * freed by the caller when it is no longer needed. If the string type is
+ * ASN_OCTET_STR, the returned string is null-terminated, and the returned
+ * length indicates the strlen value. If the string type is ASN_BIT_STR,
+ * the returned string is not null-terminated, and the returned length
+ * indicates the number of bytes.
+ */
+uchar_t *
+asn_parse_string(uchar_t *buf, size_t *bufsz_p, uchar_t **str_p, size_t *slen)
+{
+	uchar_t	*p;
+	uchar_t	id1, id2;
+	size_t	asnobj_len, hdrlen;
+
+	/*
+	 * Octet and bit strings are supported
+	 */
+	id1 = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR;
+	id2 = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_BIT_STR;
+	if ((buf[0] != id1) && (buf[0] != id2))
+		return (NULL);
+
+	/*
+	 * Parse out the length of the object and verify source buf sz
+	 */
+	if ((p = asn_parse_length(buf + 1, &asnobj_len)) == NULL)
+		return (NULL);
+
+	hdrlen = p - buf;
+	if (*bufsz_p < (hdrlen + asnobj_len))
+		return (NULL);
+
+	/*
+	 * Allocate for and copy out the string
+	 */
+	if ((*str_p = (uchar_t *)calloc(1, asnobj_len + 1)) == NULL)
+		return (NULL);
+
+	(void) memcpy(*str_p, p, asnobj_len);
+
+	/*
+	 * Terminate the octet string with a null
+	 */
+	if (buf[0] == id1) {
+		(*str_p)[asnobj_len] = 0;
+	}
+
+	/*
+	 * Update pointers and return
+	 */
+	*slen = asnobj_len;
+	*bufsz_p -= (hdrlen + asnobj_len);
+
+	return (p + asnobj_len);
+}
+/*
+ * Parses an object identifier out of the input packet buffer. Space for
+ * the oid object is allocated within this routine and must be freed by the
+ * caller when no longer needed.
+ */
+uchar_t *
+asn_parse_objid(uchar_t *msg, size_t *varsz_p, void *oidp, size_t *n_subids)
+{
+	oid	**objid_p = oidp;
+	oid	*objid;
+	uchar_t	*p;
+	size_t	hdrlen, asnobj_len;
+	oid	subid;
+	int	i, ndx;
+	uchar_t	exp_id;
+
+	/*
+	 * Check id
+	 */
+	exp_id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID;
+	if (msg[0] != exp_id)
+		return (NULL);
+
+	/*
+	 * Read object length
+	 */
+	if ((p = asn_parse_length(msg + 1, &asnobj_len)) == NULL)
+		return (NULL);
+
+	/*
+	 * Check space in input message
+	 */
+	hdrlen = p - msg;
+	if (*varsz_p < (hdrlen + asnobj_len))
+		return (NULL);
+
+	/*
+	 * Since the OID subidentifiers are packed in 7-bit blocks with
+	 * MSB set to 1 for all but the last octet, the number of subids
+	 * is simply the number of octets with MSB equal to 0, plus 1
+	 * (since the first two subids were packed into one subid and have
+	 * to be expanded back to two).
+	 */
+	*n_subids = 1;
+	for (i = 0; i < asnobj_len; i++) {
+		if ((p[i] & ASN_BIT8) == 0)
+			(*n_subids)++;
+	}
+
+	/*
+	 * Now allocate for the oid and parse the OID into it
+	 */
+	if ((objid = (oid *) calloc(1, (*n_subids) * sizeof (oid))) == NULL)
+		return (NULL);
+
+	ndx = 1;	/* start from 1 to allow for unpacking later */
+	subid = 0;
+	for (i = 0; i < asnobj_len; i++) {
+		subid = subid << 7;
+		subid |= (p[i] & ~ASN_BIT8);
+
+		if ((p[i] & ASN_BIT8) == 0) {
+			objid[ndx] = subid;
+			ndx++;
+			subid = 0;
+		}
+	}
+
+	/*
+	 * Now unpack the first two subids from the subid at index 1.
+	 */
+	if (objid[1] < 40) {
+		objid[0] = 0;
+	} else if (objid[1] < 80) {
+		objid[0] = 1;
+		objid[1] -= 40;
+	} else {
+		objid[0] = 2;
+		objid[1] -= 80;
+	}
+
+	*objid_p = objid;
+	*varsz_p -= (hdrlen + asnobj_len);
+
+	return (msg + hdrlen + asnobj_len);
+}
+/*
+ * Parses the value of an OID object out of the input message buffer.
+ * Only type tags less than ASN_EXT_TAG (0x1f) are supported.
+ */
+uchar_t *
+asn_parse_objval(uchar_t *msg, size_t *varsz_p, void *varlistp)
+{
+	pdu_varlist_t	*vp = varlistp;
+	uchar_t	*p;
+	size_t	n_subids;
+	size_t	hdrlen, asnobj_len;
+
+	vp->type = msg[0] & ASN_EXT_TAG;
+	if (vp->type == ASN_EXT_TAG)
+		return (NULL);
+
+	/*
+	 * Currently we handle ASN_INTEGER, ASN_OCTET_STR, ASN_BIT_STR
+	 * and ASN_TIMETICKS types.
+	 */
+	switch (msg[0]) {
+	case ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER:
+		vp->val.iptr = (int *)calloc(1, sizeof (int));
+		if (vp->val.iptr == NULL)
+			return (NULL);
+
+		if ((p = asn_parse_int(msg, varsz_p, vp->val.iptr)) == NULL) {
+			free(vp->val.iptr);
+			return (NULL);
+		}
+		vp->val_len = sizeof (int);
+		break;
+
+	case ASN_COUNTER:
+	case ASN_TIMETICKS:
+		vp->val.uiptr = (uint_t *)calloc(1, sizeof (uint_t));
+		if (vp->val.uiptr == NULL)
+			return (NULL);
+
+		if ((p = asn_parse_uint(msg, varsz_p, vp->val.uiptr)) == NULL) {
+			free(vp->val.uiptr);
+			return (NULL);
+		}
+		vp->val_len = sizeof (uint_t);
+		vp->type = msg[0];
+		break;
+
+	case ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR:
+	case ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_BIT_STR:
+		p = asn_parse_string(msg, varsz_p, &vp->val.str, &vp->val_len);
+		if (p == NULL)
+			return (NULL);
+		break;
+
+	case ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID:
+		p = asn_parse_objid(msg, varsz_p, &vp->val.objid, &n_subids);
+		if (p == NULL)
+			return (NULL);
+		vp->val_len = n_subids * sizeof (oid);
+		break;
+
+	case ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_NULL:
+	case SNMP_NOSUCHOBJECT:
+	case SNMP_NOSUCHINSTANCE:
+	case SNMP_ENDOFMIBVIEW:
+	default:
+		p = asn_parse_length(msg + 1, &asnobj_len);
+		if (p == NULL)
+			return (NULL);
+
+		hdrlen = p - msg;
+		if (*varsz_p < (hdrlen + asnobj_len))
+			return (NULL);
+
+		vp->type = msg[0];
+		vp->val_len = asnobj_len;
+
+		*varsz_p -= (hdrlen + asnobj_len);
+		p += asnobj_len;
+		break;
+	}
+
+	return (p);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/asn1.h	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,154 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_ASN1_H
+#define	_ASN1_H
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * ASN.1 values are encoded as octet strings based on the use of a
+ * Type-Length-Value (TLV) structure. The Type indicates the ASN.1
+ * type, the class of the type, and whether the encoding is primitive
+ * or constructed. The Length indicates the length of the actual value
+ * representation and the Value represents the value as a string
+ * of octets.
+ *
+ *              +------------+--------+----------+
+ *              | Identifier | Length | Contents |
+ *              +------------+--------+----------+
+ *
+ * The encoding of the Identifier field is shown below (for tags less than 31):
+ *
+ *              +-------+-----+------------+
+ *              | Class | P/C | Tag number |
+ *              +-------+-----+------------+
+ *          Bit   7   6    5   4  3  2  1  0
+ *
+ * The class field specifies one of four classes, the P/C bit specifies
+ * whether this is a primitive/constructed encoding and the tag number
+ * distinguishes one data type from another within the class.
+ */
+
+/*
+ * Identifier classes
+ */
+#define	ASN_UNIVERSAL		((uchar_t)0x00)
+#define	ASN_APPLICATION		((uchar_t)0x40)
+#define	ASN_CONTEXT		((uchar_t)0x80)
+#define	ASN_PRIVATE		((uchar_t)0xc0)
+
+/*
+ * Encoding type
+ */
+#define	ASN_PRIMITIVE		((uchar_t)0x00)
+#define	ASN_CONSTRUCTOR		((uchar_t)0x20)
+
+/*
+ * Tag numbers for the Universal class of ASN.1 values
+ */
+#define	ASN_BOOLEAN		((uchar_t)0x01)
+#define	ASN_INTEGER		((uchar_t)0x02)
+#define	ASN_BIT_STR		((uchar_t)0x03)
+#define	ASN_OCTET_STR		((uchar_t)0x04)
+#define	ASN_NULL		((uchar_t)0x05)
+#define	ASN_OBJECT_ID		((uchar_t)0x06)
+#define	ASN_SEQUENCE		((uchar_t)0x10)
+#define	ASN_SET			((uchar_t)0x11)
+
+/*
+ * ASN Extension Tag in the identifier
+ */
+#define	ASN_EXT_TAG		((uchar_t)0x1f)
+
+/*
+ * Application class ASN.1 identifiers
+ */
+#define	ASN_COUNTER	(ASN_APPLICATION | ASN_PRIMITIVE | (uchar_t)0x01)
+#define	ASN_TIMETICKS	(ASN_APPLICATION | ASN_PRIMITIVE | (uchar_t)0x03)
+
+/*
+ * The Length field in the TLV structure described above is represented
+ * in many ways depending on the value.
+ *
+ * If the length is less than 128, the length field consists of a
+ * single octet beginning with a zero.
+ *
+ *                        +---+-----------+
+ *                        | 0 | Length(L) |
+ *                        +---+-----------+
+ *
+ * If the length is greater than 127, the first octet of the length field
+ * contains a seven-bit integer that specifies the number of additional
+ * length octets and the additional octets specify the actual length.
+ *
+ *              <-- one octet --><----- K octets ----->
+ *              +---------------+---------------------+
+ *              |  1  |    K    |      Length(L)      |
+ *              +---------------+---------------------+
+ *
+ */
+#define	ASN_LONG_LEN	((uchar_t)0x80)
+#define	ASN_BIT8	((uchar_t)0x80)
+
+/*
+ * Some parts of the code assumes a few things -- big-endian ordering,
+ * sizeof int, etc. to simplify things.
+ */
+#define	BUILD_INT_SHIFT	23
+#define	BUILD_INT_MASK	0x1ff
+
+/*
+ * Exported ASN.1 encoding related interfaces (only exported within
+ * snmplib, we need to do ld versioning to limit the scope of these to
+ * within snmplib).
+ */
+uchar_t	*asn_build_sequence(uchar_t *, size_t *, uchar_t, size_t);
+uchar_t	*asn_build_header(uchar_t *, size_t *, uchar_t, size_t);
+uchar_t	*asn_build_length(uchar_t *, size_t *, size_t);
+uchar_t	*asn_build_int(uchar_t *, size_t *, uchar_t, int);
+uchar_t	*asn_build_string(uchar_t *, size_t *, uchar_t, uchar_t *, size_t);
+uchar_t	*asn_build_objid(uchar_t *, size_t *, uchar_t, void *, size_t);
+uchar_t	*asn_build_null(uchar_t *, size_t *, uchar_t);
+
+uchar_t	*asn_parse_sequence(uchar_t *, size_t *, uchar_t);
+uchar_t	*asn_parse_header(uchar_t *, size_t *, uchar_t *);
+uchar_t	*asn_parse_length(uchar_t *, size_t *);
+uchar_t	*asn_parse_int(uchar_t *, size_t *, int *);
+uchar_t *asn_parse_uint(uchar_t *, size_t *, uint_t *);
+uchar_t	*asn_parse_string(uchar_t *, size_t *, uchar_t **, size_t *);
+uchar_t	*asn_parse_objid(uchar_t *, size_t *, void *, size_t *);
+uchar_t	*asn_parse_objval(uchar_t *, size_t *, void *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ASN1_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/debug.c	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,616 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef SNMP_DEBUG
+
+/*
+ * Debug routines
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <thread.h>
+#include <synch.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include "asn1.h"
+#include "pdu.h"
+#include "snmplib.h"
+#include "debug.h"
+
+/*
+ * Buffer and line limits
+ */
+#define	SNMP_DBLOCK_SZ		4096
+#define	SNMP_DMAX_LINE		80
+#define	SNMP_NCHARS_IN_A_ROW	16
+
+/*
+ * Debug flags
+ */
+#define	SNMP_DEBUG_CMD		0x01
+#define	SNMP_DEBUG_VAR		0x02
+#define	SNMP_DEBUG_PDU		0x04
+#define	SNMP_DEBUG_ASN		0x08
+#define	SNMP_DEBUG_PKT		0x10
+#define	SNMP_DEBUG_IO		0x20
+
+#define	SNMP_DEBUG_DEFAULT	0x15	/* cmd, pdu, pkt */
+#define	SNMP_DEBUG_EXTENDED	0x35	/* cmd, pdu, pkt, io */
+#define	SNMP_DEBUG_ALL		0x3f
+
+/*
+ * Formatting aids
+ */
+#define	SNMP_DCMD_INDENT	2
+#define	SNMP_DVAR_INDENT	4
+#define	SNMP_DPDU_INDENT	6
+#define	SNMP_DASN_INDENT	8
+#define	SNMP_DPKT_INDENT	10
+#define	SNMP_DIO_INDENT		12
+
+#define	SNMP_DHDR_PREFIX	(const char *)" ___ "
+#define	SNMP_DHDR_SUFFIX	(const char *)" ___"
+#define	SNMP_DTEXT_PREFIX	(const char *)"| "
+
+/*
+ * All debug vars are protected by a single lock
+ */
+static mutex_t	snmp_dbuf_lock;				/* debug lock */
+static uint16_t	snmp_debug_flag = SNMP_DEBUG_EXTENDED;	/* debug flags */
+static char	*snmp_dbuf = NULL;			/* the debug buffer */
+static char	*snmp_dbuf_curp = NULL;			/* current dbuf index */
+static char	*snmp_dbuf_tail = NULL;			/* current dbuf tail */
+static int	snmp_dbuf_sz = 0;			/* current dbuf size */
+static int	snmp_dbuf_overflow = 0;			/* no more memory */
+static char	snmp_lbuf[SNMP_DMAX_LINE];		/* scratch space */
+
+/*
+ * Key-to-string
+ */
+typedef struct {
+	int	key;
+	char	*str;
+} snmp_key_to_str_t;
+
+static snmp_key_to_str_t snmp_cmds[] = {
+	{ SNMP_MSG_GET, "SNMP_MSG_GET" },
+	{ SNMP_MSG_GETNEXT, "SNMP_MSG_GETNEXT" },
+	{ SNMP_MSG_RESPONSE, "SNMP_MSG_RESPONSE" },
+	{ SNMP_MSG_SET, "SNMP_MSG_SET" },
+	{ SNMP_MSG_TRAP, "SNMP_MSG_TRAP" },
+	{ SNMP_MSG_GETBULK, "SNMP_MSG_GETBULK" },
+	{ SNMP_MSG_INFORM, "SNMP_MSG_INFORM" },
+	{ SNMP_MSG_TRAP2, "SNMP_MSG_TRAP2" },
+	{ SNMP_MSG_REPORT, "SNMP_MSG_REPORT" }
+};
+
+static snmp_key_to_str_t snmp_vartypes[] = {
+	{ ASN_BOOLEAN, "ASN_BOOLEAN" },
+	{ ASN_INTEGER, "ASN_INTEGER" },
+	{ ASN_BIT_STR, "ASN_BIT_STR" },
+	{ ASN_OCTET_STR, "ASN_OCTET_STR" },
+	{ ASN_NULL, "ASN_NULL" },
+	{ ASN_OBJECT_ID, "ASN_OBJECT_ID" },
+	{ ASN_SEQUENCE, "ASN_SEQUENCE" }
+};
+
+static snmp_key_to_str_t snmp_asnencodings[] = {
+	{ SNMP_DASN_SEQUENCE, "ASN SEQUENCE" },
+	{ SNMP_DASN_LENGTH, "ASN LENGTH" },
+	{ SNMP_DASN_INT, "ASN INT" },
+	{ SNMP_DASN_OCTET_STR, "ASN OCTET STR" },
+	{ SNMP_DASN_OID, "ASN OBJECT ID" },
+	{ SNMP_DASN_NULL, "ASN NULL" }
+};
+
+static char *debug_tags[] = {
+	"SNMP Command Request",
+	"Null Var",
+	"Response Var",
+	"Request PDU",
+	"Response PDU",
+	"Request Packet",
+	"Response Packet",
+	"WRITE",
+	"IOCTL",
+	"READ",
+	"SENDTO",
+	"RECVFROM"
+};
+static const int n_tags = sizeof (debug_tags) / sizeof (char *);
+
+/*
+ * Helpers
+ */
+static char	*snmp_cmdstr_lookup(int cmd);
+static char	*snmp_vtypestr_lookup(int vtype);
+static char	*snmp_asnencoding_lookup(int asnkey);
+static void	snmp_get_dumpchars(uchar_t *abuf, uchar_t *p, int nchars);
+static void	snmp_log_append(char *bufp);
+static void	snmp_dbuf_realloc(void);
+
+void
+snmp_debug_init(void)
+{
+	(void) mutex_init(&snmp_dbuf_lock, USYNC_THREAD, NULL);
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+	snmp_dbuf_realloc();
+	if (snmp_dbuf == NULL)
+		snmp_debug_flag = 0;	/* really tragic */
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_cmd(uint_t tag, int cmd, int n_oids, char *oidstr, int row)
+{
+	char	*cmdstr;
+	int	i;
+
+	if (oidstr == NULL)
+		return;
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_CMD) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	snmp_log_append("\n");
+
+	if (tag < n_tags) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
+		    SNMP_DCMD_INDENT, ' ', SNMP_DHDR_PREFIX,
+		    debug_tags[tag], SNMP_DHDR_SUFFIX);
+		snmp_log_append(snmp_lbuf);
+	}
+
+	if ((cmdstr = snmp_cmdstr_lookup(cmd)) == NULL) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sCMD=%#x\n",
+		    SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX, cmd);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s\n",
+		    SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX, cmdstr);
+	}
+	snmp_log_append(snmp_lbuf);
+
+	for (i = 0; i < n_oids; i++) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s  %s.%d\n",
+		    SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX,
+		    oidstr, row);
+		snmp_log_append(snmp_lbuf);
+
+		oidstr += strlen(oidstr) + 1;
+	}
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_var(uint_t tag, pdu_varlist_t *vp)
+{
+	char	*vts;
+
+	if (vp == NULL)
+		return;
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_VAR) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	snmp_log_append("\n");
+
+	if (tag < n_tags) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
+		    SNMP_DVAR_INDENT, ' ', SNMP_DHDR_PREFIX,
+		    debug_tags[tag], SNMP_DHDR_SUFFIX);
+		snmp_log_append(snmp_lbuf);
+	}
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%snextvar = %#x\n",
+	    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->nextvar);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sname = %#x\n",
+	    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->name);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sname_len = %u\n",
+	    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->name_len);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sval.ptr = %#x\n",
+	    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->val.str);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sval_len = %u\n",
+	    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->val_len);
+	snmp_log_append(snmp_lbuf);
+
+	if ((vts = snmp_vtypestr_lookup(vp->type)) == NULL) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%stype = %#x\n",
+		    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->type);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%stype = %s\n",
+		    SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vts);
+	}
+	snmp_log_append(snmp_lbuf);
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_pdu(uint_t tag, snmp_pdu_t *pdu)
+{
+	char	*cmdstr;
+
+	if (pdu == NULL)
+		return;
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_PDU) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	snmp_log_append("\n");
+
+	if (tag < n_tags) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
+		    SNMP_DPDU_INDENT, ' ', SNMP_DHDR_PREFIX,
+		    debug_tags[tag], SNMP_DHDR_SUFFIX);
+		snmp_log_append(snmp_lbuf);
+	}
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sversion = %d\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->version);
+	snmp_log_append(snmp_lbuf);
+
+	if (pdu->community) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%scommunity = %s\n", SNMP_DPDU_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, pdu->community);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%scommunity = %#x\n", SNMP_DPDU_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, pdu->community);
+	}
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%scommunity_len = %u\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->community_len);
+	snmp_log_append(snmp_lbuf);
+
+	if ((cmdstr = snmp_cmdstr_lookup(pdu->command)) == NULL) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%scommand = %#x\n", SNMP_DPDU_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, pdu->command);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%scommand = %s\n", SNMP_DPDU_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, cmdstr);
+	}
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreqid = %d\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reqid);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+	    "%*c%serrstat = %#x (non-repeaters)\n", SNMP_DPDU_INDENT, ' ',
+	    SNMP_DTEXT_PREFIX, pdu->errstat);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+	    "%*c%serrindex = %u (max-reps)\n", SNMP_DPDU_INDENT, ' ',
+	    SNMP_DTEXT_PREFIX, pdu->errindex);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%svars = %#x\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->vars);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreq_pkt = %#x\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->req_pkt);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreq_pktsz = %u\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->req_pktsz);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreply_pkt = %#x\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reply_pkt);
+	snmp_log_append(snmp_lbuf);
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreply_pktsz = %u\n",
+	    SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reply_pktsz);
+	snmp_log_append(snmp_lbuf);
+
+	snmp_log_append("\n");
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_asn(int key, uchar_t *pkt, size_t pktsz)
+{
+	char	*p, *asnstr;
+	int	i, len;
+	size_t	nrows, nrem;
+
+	if (pkt == NULL)
+		return;
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_ASN) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	if ((asnstr = snmp_asnencoding_lookup(key)) == NULL) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sASNKEY=%#x\n",
+		    SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX, key);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s\n",
+		    SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX, asnstr);
+	}
+	snmp_log_append(snmp_lbuf);
+
+	nrows = pktsz / 16;
+	for (i = 0; i < nrows; i++) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s  "
+		    "%02x %02x %02x %02x %02x %02x %02x %02x "
+		    "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+		    SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX,
+		    pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5],
+		    pkt[6], pkt[7], pkt[8], pkt[9], pkt[10], pkt[11],
+		    pkt[12], pkt[13], pkt[14], pkt[15]);
+
+		pkt += 16;
+		snmp_log_append(snmp_lbuf);
+	}
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s ",
+	    SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX);
+
+	p = snmp_lbuf + SNMP_DASN_INDENT + strlen(SNMP_DTEXT_PREFIX) + 1;
+	len = SNMP_DMAX_LINE - SNMP_DASN_INDENT - strlen(SNMP_DTEXT_PREFIX) - 1;
+
+	nrem = pktsz % 16;
+	for (i = 0; i < nrem; i++) {
+		(void) snprintf(p, len, " %02x", pkt[i]);
+
+		p += 3;
+		len -= 3;
+	}
+	(void) snprintf(p, len, "\n");
+	snmp_log_append(snmp_lbuf);
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_pkt(uint_t tag, uchar_t *pkt, size_t pktsz)
+{
+	uchar_t	ascii[SNMP_NCHARS_IN_A_ROW + 1];
+	uchar_t	*p = pkt;
+	char	*bufp;
+	int	nrows, nrem;
+	int	i, len;
+
+	if (pkt == NULL)
+		return;
+
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_PKT) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	snmp_log_append("\n");
+
+	if (tag < n_tags) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
+		    SNMP_DPKT_INDENT, ' ',
+		    SNMP_DHDR_PREFIX, debug_tags[tag], SNMP_DHDR_SUFFIX);
+		snmp_log_append(snmp_lbuf);
+	}
+
+	nrows = pktsz / SNMP_NCHARS_IN_A_ROW;
+	nrem = pktsz % SNMP_NCHARS_IN_A_ROW;
+
+	for (i = 0; i < nrows; i++) {
+		snmp_get_dumpchars(ascii, p, SNMP_NCHARS_IN_A_ROW);
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s"
+		    "%02x %02x %02x %02x %02x %02x %02x %02x "
+		    "%02x %02x %02x %02x %02x %02x %02x %02x "
+		    "%s\n",
+		    SNMP_DPKT_INDENT, ' ', SNMP_DTEXT_PREFIX,
+		    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
+		    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15],
+		    ascii);
+		p += 16;
+
+		snmp_log_append(snmp_lbuf);
+	}
+
+	(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s",
+	    SNMP_DPKT_INDENT, ' ', SNMP_DTEXT_PREFIX);
+
+	snmp_get_dumpchars(ascii, p, nrem);
+
+	bufp = snmp_lbuf + SNMP_DPKT_INDENT + strlen(SNMP_DTEXT_PREFIX);
+	len = SNMP_DMAX_LINE - SNMP_DPKT_INDENT + strlen(SNMP_DTEXT_PREFIX);
+	for (i = 0; i < 16; i++) {
+		if (i < nrem)
+			(void) snprintf(bufp, len, "%02x ", p[i]);
+		else
+			(void) snprintf(bufp, len, "   ");
+
+		bufp += 3;
+		len -= 3;
+	}
+	(void) snprintf(bufp, len, "%s\n", ascii);
+	snmp_log_append(snmp_lbuf);
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+void
+snmp_log_io(uint_t tag, int a1, uint_t a2, uint_t a3)
+{
+	(void) mutex_lock(&snmp_dbuf_lock);
+
+	if ((snmp_debug_flag & SNMP_DEBUG_IO) == 0) {
+		(void) mutex_unlock(&snmp_dbuf_lock);
+		return;
+	}
+
+	snmp_log_append("\n");
+
+	if (tag < n_tags) {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%s%s(%d, %#x, %#x)\n", SNMP_DIO_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, debug_tags[tag], a1, a2, a3);
+	} else {
+		(void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
+		    "%*c%s%#x(%d, %#x, %#x)\n", SNMP_DIO_INDENT, ' ',
+		    SNMP_DTEXT_PREFIX, tag, a1, a2, a3);
+	}
+
+	snmp_log_append(snmp_lbuf);
+
+	(void) mutex_unlock(&snmp_dbuf_lock);
+}
+
+static char *
+snmp_cmdstr_lookup(int cmd)
+{
+	int	nelem = sizeof (snmp_cmds) / sizeof (snmp_key_to_str_t);
+	int	i;
+
+	for (i = 0; i < nelem; i++) {
+		if (snmp_cmds[i].key == cmd)
+			return (snmp_cmds[i].str);
+	}
+
+	return (NULL);
+}
+
+static char *
+snmp_vtypestr_lookup(int vtype)
+{
+	int	nelem = sizeof (snmp_vartypes) / sizeof (snmp_key_to_str_t);
+	int	i;
+
+	for (i = 0; i < nelem; i++) {
+		if (snmp_vartypes[i].key == vtype)
+			return (snmp_vartypes[i].str);
+	}
+
+	return (NULL);
+}
+
+static char *
+snmp_asnencoding_lookup(int asnkey)
+{
+	int	nelem = sizeof (snmp_asnencodings) / sizeof (snmp_key_to_str_t);
+	int	i;
+
+	for (i = 0; i < nelem; i++) {
+		if (snmp_asnencodings[i].key == asnkey)
+			return (snmp_asnencodings[i].str);
+	}
+
+	return (NULL);
+}
+
+static void
+snmp_get_dumpchars(uchar_t *abuf, uchar_t *p, int nchars)
+{
+	int	i;
+
+	if (nchars > SNMP_NCHARS_IN_A_ROW)
+		nchars = SNMP_NCHARS_IN_A_ROW;
+
+	abuf[nchars] = 0;
+	for (i = 0; i < nchars; i++)
+		abuf[i] = isprint(p[i]) ? p[i] : '.';
+}
+
+static void
+snmp_log_append(char *bufp)
+{
+	int	len;
+
+	len = strlen(bufp);
+	if ((snmp_dbuf_curp + len) >= snmp_dbuf_tail)
+		snmp_dbuf_realloc();
+
+	(void) strcpy(snmp_dbuf_curp, bufp);
+
+	snmp_dbuf_curp += len;
+}
+
+static void
+snmp_dbuf_realloc(void)
+{
+	char	*p;
+	size_t	offset = 0;
+	size_t	count;
+
+	count = snmp_dbuf_sz + SNMP_DBLOCK_SZ;
+	if ((p = (char *)calloc(count, 1)) == NULL) {
+		snmp_dbuf_overflow++;
+		snmp_dbuf_curp = snmp_dbuf;
+		return;
+	}
+
+	if (snmp_dbuf) {
+		offset = snmp_dbuf_curp - snmp_dbuf;
+		(void) memcpy(p, snmp_dbuf, snmp_dbuf_sz);
+		free(snmp_dbuf);
+	}
+
+	snmp_dbuf = p;
+	snmp_dbuf_sz += SNMP_DBLOCK_SZ;
+
+	snmp_dbuf_curp = snmp_dbuf + offset;
+	snmp_dbuf_tail = snmp_dbuf + snmp_dbuf_sz;
+}
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/debug.h	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,144 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_DEBUG_H
+#define	_DEBUG_H
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef SNMP_DEBUG
+
+/*
+ * ASN Debugging keys
+ */
+#define	SNMP_DASN_SEQUENCE	1
+#define	SNMP_DASN_LENGTH	2
+#define	SNMP_DASN_INT		3
+#define	SNMP_DASN_OCTET_STR	4
+#define	SNMP_DASN_OID		5
+#define	SNMP_DASN_NULL		6
+
+/*
+ * Debug tags
+ */
+#define	TAG_CMD_REQUEST		0
+#define	TAG_NULL_VAR		1
+#define	TAG_RESPONSE_VAR	2
+#define	TAG_REQUEST_PDU		3
+#define	TAG_RESPONSE_PDU	4
+#define	TAG_REQUEST_PKT		5
+#define	TAG_RESPONSE_PKT	6
+#define	TAG_WRITE		7
+#define	TAG_IOCTL		8
+#define	TAG_READ		9
+#define	TAG_SENDTO		10
+#define	TAG_RECVFROM		11
+
+/*
+ * Debug macros
+ */
+#define	LOGINIT() \
+	snmp_debug_init()
+
+#define	LOGGET(tag, prefix, row) \
+	snmp_log_cmd(tag, SNMP_MSG_GET, 1, prefix, row)
+
+#define	LOGBULK(tag, n_oids, oidstrs, row) \
+	snmp_log_cmd(tag, SNMP_MSG_GETBULK, n_oids, oidstrs, row)
+
+#define	LOGNEXT(tag, prefix, row) \
+	snmp_log_cmd(tag, SNMP_MSG_GETNEXT, 1, prefix, row)
+
+#define	LOGVAR(tag, vp) \
+	snmp_log_var(tag, vp)
+
+#define	LOGPDU(tag, pdu) \
+	snmp_log_pdu(tag, pdu)
+
+#define	LOGASNSEQ(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_SEQUENCE, pkt, pktsz)
+
+#define	LOGASNLENGTH(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_LENGTH, pkt, pktsz)
+
+#define	LOGASNINT(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_INT, pkt, pktsz)
+
+#define	LOGASNOCTSTR(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_OCTET_STR, pkt, pktsz)
+
+#define	LOGASNOID(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_OID, pkt, pktsz)
+
+#define	LOGASNNULL(pkt, pktsz) \
+	snmp_log_asn(SNMP_DASN_NULL, pkt, pktsz)
+
+#define	LOGPKT(tag, pkt, sz) \
+	snmp_log_pkt(tag, pkt, sz)
+
+#define	LOGIO(tag, a1, a2, a3) \
+	snmp_log_io(tag, (int)a1, (uint_t)a2, (uint_t)a3)
+
+/*
+ * Exported debug interfaces
+ */
+extern void	snmp_debug_init(void);
+extern void	snmp_log_cmd(uint_t tag, int cmd, int n_oids,
+		    char *oidstr, int row);
+extern void	snmp_log_var(uint_t tag, pdu_varlist_t *vp);
+extern void	snmp_log_pdu(uint_t tag, snmp_pdu_t *pdu);
+extern void	snmp_log_asn(int key, uchar_t *pkt, size_t pktsz);
+extern void	snmp_log_pkt(uint_t tag, uchar_t *pkt, size_t pktsz);
+extern void	snmp_log_io(uint_t tag, int a1, uint_t a2, uint_t a3);
+
+#else /* SNMP_DEBUG */
+
+#define	LOGINIT()
+#define	LOGGET(tag, prefix, row)
+#define	LOGBULK(tag, n_oids, oidstrs, row)
+#define	LOGNEXT(tag, prefix, row)
+#define	LOGVAR(tag, vp)
+#define	LOGPDU(tag, pdu)
+#define	LOGASNSEQ(pkt, pktsz)
+#define	LOGASNLENGTH(pkt, pktsz)
+#define	LOGASNINT(pkt, pktsz)
+#define	LOGASNOCTSTR(pkt, pktsz)
+#define	LOGASNOID(pkt, pktsz)
+#define	LOGASNNULL(pkt, pktsz)
+#define	LOGPKT(tag, pkt, sz)
+#define	LOGIO(tag, a1, a2, a3)
+
+#endif /* SNMP_DEBUG */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _DEBUG_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/pdu.c	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,668 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ * SNMP PDU and packet transport related routines
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include "asn1.h"
+#include "pdu.h"
+#include "debug.h"
+
+/*
+ * Static declarations
+ */
+static int	snmp_add_null_vars(snmp_pdu_t *, char *, int, int);
+static oid	*snmp_oidstr_to_oid(int, char *, int, size_t *);
+static uchar_t	*snmp_build_pdu(snmp_pdu_t *, uchar_t *, size_t *);
+static uchar_t	*snmp_build_variable(uchar_t *, size_t *, oid *, size_t,
+		    uchar_t, void *, size_t);
+static uchar_t	*snmp_parse_pdu(int, uchar_t *, size_t *, snmp_pdu_t *);
+static uchar_t	*snmp_parse_variable(uchar_t *, size_t *, pdu_varlist_t *);
+
+/*
+ * Allocates and creates a PDU for the specified SNMP command. Currently
+ * only SNMP_MSG_GET, SNMP_MSG_GETNEXT and SNMP_MSG_GETBULK are supported
+ */
+snmp_pdu_t *
+snmp_create_pdu(int cmd, int max_reps, char *oidstrs, int n_oids, int row)
+{
+	snmp_pdu_t	*pdu;
+
+	if ((cmd != SNMP_MSG_GET) && (cmd != SNMP_MSG_GETNEXT) &&
+	    (cmd != SNMP_MSG_GETBULK)) {
+		return (NULL);
+	}
+
+	pdu = (snmp_pdu_t *)calloc(1, sizeof (snmp_pdu_t));
+	if (pdu == NULL)
+		return (NULL);
+
+	if (cmd == SNMP_MSG_GET || cmd == SNMP_MSG_GETNEXT) {
+		pdu->version = SNMP_VERSION_1;
+		pdu->errstat = 0;
+		pdu->errindex = 0;
+	} else if (cmd == SNMP_MSG_GETBULK) {
+		pdu->version = SNMP_VERSION_2c;
+		pdu->non_repeaters = 0;
+		pdu->max_repetitions = max_reps ?
+		    max_reps : SNMP_DEF_MAX_REPETITIONS;
+	}
+
+	pdu->command = cmd;
+	pdu->reqid = snmp_get_reqid();
+	pdu->community = (uchar_t *)SNMP_DEF_COMMUNITY;
+	pdu->community_len = SNMP_DEF_COMMUNITY_LEN;
+
+	if (snmp_add_null_vars(pdu, oidstrs, n_oids, row) < 0) {
+		free((void *) pdu);
+		return (NULL);
+	}
+
+	pdu->req_pkt = NULL;
+	pdu->req_pktsz = 0;
+	pdu->reply_pkt = NULL;
+	pdu->reply_pktsz = 0;
+
+	return (pdu);
+}
+
+/*
+ * Builds a complete ASN.1 encoded snmp message packet out of the PDU.
+ * Currently the maximum request packet is limited to SNMP_DEF_PKTBUF_SZ.
+ * Since we only send SNMP_MSG_GET, SNMP_MSG_GETNEXT and SNMP_MSG_GETBULK,
+ * as long as the number of bulk oids are not *too* many, we're safe with
+ * this limit (the typical packet size of a bulk request of 10 vars is
+ * around 250 bytes).
+ */
+int
+snmp_make_packet(snmp_pdu_t *pdu)
+{
+	uchar_t	*buf, *p;
+	uchar_t	*msg_seq_end;
+	uchar_t id;
+	size_t	bufsz = SNMP_DEF_PKTBUF_SZ;
+	size_t	seqlen;
+
+	if ((buf = (uchar_t *)calloc(1, SNMP_DEF_PKTBUF_SZ)) == NULL)
+		return (-1);
+
+	/*
+	 * Let's start with the ASN sequence tag. Set the length
+	 * to 0 initially and fill it up once the message packetizing
+	 * is complete.
+	 */
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_build_sequence(buf, &bufsz, id, 0)) == NULL) {
+		free((void *) buf);
+		return (-1);
+	}
+	msg_seq_end = p;
+
+	/*
+	 * Store the version
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER;
+	if ((p = asn_build_int(p, &bufsz, id, pdu->version)) == NULL) {
+		free((void *) buf);
+		return (-1);
+	}
+
+	/*
+	 * Store the community string
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR;
+	p = asn_build_string(p, &bufsz, id, pdu->community, pdu->community_len);
+	if (p == NULL) {
+		free((void *) buf);
+		return (-1);
+	}
+
+	/*
+	 * Build the PDU
+	 */
+	if ((p = snmp_build_pdu(pdu, p, &bufsz)) == NULL) {
+		free((void *) buf);
+		return (-1);
+	}
+
+	/*
+	 * Complete the message pkt by updating the message sequence length
+	 */
+	seqlen = p - msg_seq_end;
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	(void) asn_build_sequence(buf, NULL, id, seqlen);
+
+	/*
+	 * Calculate packet size and return
+	 */
+	pdu->req_pkt = buf;
+	pdu->req_pktsz = p - buf;
+
+	return (0);
+}
+
+/*
+ * Makes a PDU out of a reply packet. The reply message is parsed
+ * and if the reqid of the incoming packet does not match the reqid
+ * we're waiting for, an error is returned. The PDU is allocated
+ * inside this routine and must be freed by the caller once it is no
+ * longer needed.
+ */
+snmp_pdu_t *
+snmp_parse_reply(int reqid, uchar_t *reply_pkt, size_t reply_pktsz)
+{
+	snmp_pdu_t	*reply_pdu;
+	uchar_t		*p;
+	size_t		msgsz = reply_pktsz;
+	uchar_t		exp_id;
+
+	reply_pdu = (snmp_pdu_t *)calloc(1, sizeof (snmp_pdu_t));
+	if (reply_pdu == NULL)
+		return (NULL);
+
+	/*
+	 * Try to parse the ASN sequence out of the beginning of the reply
+	 * packet. If we don't find a sequence at the beginning, something's
+	 * wrong.
+	 */
+	exp_id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_parse_sequence(reply_pkt, &msgsz, exp_id)) == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (NULL);
+	}
+
+	/*
+	 * Now try to parse the version out of the packet
+	 */
+	if ((p = asn_parse_int(p, &msgsz, &reply_pdu->version)) == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (NULL);
+	}
+	if ((reply_pdu->version != SNMP_VERSION_1) &&
+	    (reply_pdu->version != SNMP_VERSION_2c)) {
+		snmp_free_pdu(reply_pdu);
+		return (NULL);
+	}
+
+	/*
+	 * Parse the community string (space allocated by asn_parse_string)
+	 */
+	p = asn_parse_string(p, &msgsz, &reply_pdu->community,
+	    &reply_pdu->community_len);
+	if (p == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (NULL);
+	}
+
+	/*
+	 * Parse the PDU part of the message
+	 */
+	if ((p = snmp_parse_pdu(reqid, p, &msgsz, reply_pdu)) == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (NULL);
+	}
+
+	return (reply_pdu);
+}
+
+
+/*
+ * Convert the OID strings into the standard PDU oid form (sequence of
+ * integer subids) and add them to the PDU's variable list. Note that
+ * this is used only for preparing the request messages (GET, GETNEXT
+ * and GETBULK), so the values of the variables are always null.
+ */
+static int
+snmp_add_null_vars(snmp_pdu_t *pdu, char *oidstrs, int n_oids, int row)
+{
+	pdu_varlist_t	*vp, *prev;
+	pdu_varlist_t	*varblock_p;
+	char	*p;
+	int	i;
+
+	/*
+	 * It's much easier to allocate for all variables in one go,
+	 * so we can release it quickly if there's any failure.
+	 */
+	varblock_p = (pdu_varlist_t *)calloc(n_oids, sizeof (pdu_varlist_t));
+	if (varblock_p == NULL)
+		return (-1);
+
+	prev = NULL;
+	p = oidstrs;
+	vp = varblock_p;
+	for (i = 0; i < n_oids; i++) {
+		vp->name = snmp_oidstr_to_oid(pdu->command,
+		    p, row, &vp->name_len);
+		if (vp->name == NULL) {
+			free((void *) varblock_p);
+			return (-1);
+		}
+		vp->val.str = NULL;
+		vp->val_len = 0;
+		vp->type = ASN_NULL;
+		vp->nextvar = vp + 1;
+
+		LOGVAR(TAG_NULL_VAR, vp);
+
+		prev = vp;
+		p += strlen(p) + 1;
+		vp++;
+	}
+	prev->nextvar = NULL;
+
+	/*
+	 * append the varlist to the PDU
+	 */
+	if (pdu->vars == NULL)
+		pdu->vars = varblock_p;
+	else {
+		for (vp = pdu->vars; vp->nextvar; vp = vp->nextvar)
+			;
+		vp->nextvar = varblock_p;
+	}
+
+	return (0);
+}
+/*
+ * Some assumptions are in place here to eliminate unnecessary complexity.
+ * All OID strings passed are assumed to be in the numeric string form, have
+ * no leading/trailing '.' or spaces. Since PICL plugin is currently the
+ * only customer, this is quite reasonable.
+ */
+static oid *
+snmp_oidstr_to_oid(int cmd, char *oidstr, int row, size_t *n_subids)
+{
+	int	i, count;
+	char	*p, *q;
+	char	*oidstr_dup;
+	oid	*objid;
+
+	if ((oidstr == NULL) || (n_subids == NULL))
+		return (NULL);
+
+	for (count = 1, p = oidstr; p; count++, p++) {
+		if ((p = strchr(p, '.')) == NULL)
+			break;
+	}
+
+	/*
+	 * Add one more to count for 'row'. Need special processing
+	 * for SNMP_MSG_GETNEXT and SNMP_MSG_GETBULK requests; see
+	 * comment below.
+	 */
+	if ((cmd == SNMP_MSG_GET) || (cmd == SNMP_MSG_GETBULK && row > 0) ||
+	    (cmd == SNMP_MSG_GETNEXT && row >= 0)) {
+		count++;
+	}
+
+	if ((oidstr_dup = strdup(oidstr)) == NULL)
+		return (NULL);
+
+	objid = (oid *) calloc(count, sizeof (oid));
+	if (objid == NULL) {
+		free((void *) p);
+		return (NULL);
+	}
+
+	p = oidstr_dup;
+	for (i = 0; i < count - 1; i++) {
+		if (q = strchr(p, '.'))
+			*q = 0;
+		objid[i] = (oid) strtoul(p, NULL, 10);
+		p = q + 1;
+	}
+
+	/*
+	 * For SNMP_MSG_GET, the leaf subid will simply be the row#.
+	 *
+	 * For SNMP_MSG_GETBULK, if the row# passed is greater than 0,
+	 * we pass 'row-1' as the leaf subid, to include the item that
+	 * is of interest to us. If the row# is less than or equal to 0,
+	 * we will simply ignore it and pass only the prefix part of the
+	 * oidstr. For this case, our count would have been 1 less than
+	 * usual, and we are yet to save the last subid.
+	 *
+	 * For SNMP_MSG_GETNEXT, if the row# passed is less than 0,
+	 * we'll simply ignore it and pass only the prefix part of the
+	 * oidstr. For this case, our count would have been 1 less than
+	 * usual, and we are yet to save the last subid. If the row#
+	 * passed is greater than or equal to 0, we'll simply pass it
+	 * verbatim, as the leaf subid.
+	 */
+	switch (cmd) {
+	case SNMP_MSG_GET:
+		objid[i] = (oid) row;
+		break;
+
+	case SNMP_MSG_GETBULK:
+		if (row > 0)
+			objid[i] = (oid) (row - 1);
+		else
+			objid[i] = (oid) strtoul(p, NULL, 10);
+		break;
+
+	case SNMP_MSG_GETNEXT:
+		if (row < 0)
+			objid[i] = (oid) strtoul(p, NULL, 10);
+		else
+			objid[i] = (oid) row;
+		break;
+	}
+
+	*n_subids = count;
+
+	free((void *) oidstr_dup);
+
+	return (objid);
+}
+
+/*
+ * Builds the PDU part of the snmp message packet.
+ */
+static uchar_t *
+snmp_build_pdu(snmp_pdu_t *pdu, uchar_t *buf, size_t *bufsz_p)
+{
+	uchar_t	*p;
+	uchar_t	*pdu_seq_begin, *pdu_seq_end;
+	uchar_t	*varlist_seq_begin, *varlist_seq_end;
+	uchar_t	id;
+	size_t	seqlen;
+	pdu_varlist_t	*vp;
+
+	/*
+	 * Build ASN sequence for the PDU command (length will be
+	 * updated later once the entire command is completely formed)
+	 */
+	pdu_seq_begin = buf;
+	p = asn_build_sequence(buf, bufsz_p, (uchar_t)pdu->command, 0);
+	if (p == NULL)
+		return (NULL);
+	pdu_seq_end = p;
+
+	/*
+	 * Build the request id
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER;
+	if ((p = asn_build_int(p, bufsz_p, id, pdu->reqid)) == NULL)
+		return (NULL);
+
+	/*
+	 * Build the non-repeaters and max-repetitions for SNMP_MSG_GETBULK
+	 * (same as error status and error index for other message types)
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER;
+	if ((p = asn_build_int(p, bufsz_p, id, pdu->non_repeaters)) == NULL)
+		return (NULL);
+
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER;
+	if ((p = asn_build_int(p, bufsz_p, id, pdu->max_repetitions)) == NULL)
+		return (NULL);
+
+	/*
+	 * Build ASN sequence for the variables list (update length
+	 * after building the varlist)
+	 */
+	varlist_seq_begin = p;
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_build_sequence(p, bufsz_p, id, 0)) == NULL)
+		return (NULL);
+	varlist_seq_end = p;
+
+	/*
+	 * Build the variables list
+	 */
+	for (vp = pdu->vars; vp; vp = vp->nextvar) {
+		p = snmp_build_variable(p, bufsz_p, vp->name, vp->name_len,
+		    vp->type, vp->val.str, vp->val_len);
+		if (p == NULL)
+			return (NULL);
+	}
+
+	/*
+	 * Now update the varlist sequence length
+	 */
+	seqlen = p - varlist_seq_end;
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	(void) asn_build_sequence(varlist_seq_begin, NULL, id, seqlen);
+
+	/*
+	 * And finally, update the length for the PDU sequence
+	 */
+	seqlen = p - pdu_seq_end;
+	(void) asn_build_sequence(pdu_seq_begin, NULL, (uchar_t)pdu->command,
+	    seqlen);
+
+	return (p);
+}
+
+/*
+ * Builds an object variable into the snmp message packet. Although the
+ * code is here to build variables of basic types such as integer, object id
+ * and strings, the only type of variable we ever send via snmp request
+ * messages is the ASN_NULL type.
+ */
+static uchar_t *
+snmp_build_variable(uchar_t *buf, size_t *bufsz_p, oid *name, size_t name_len,
+    uchar_t val_type, void *val, size_t val_len)
+{
+	uchar_t	*p, *varseq_end;
+	size_t	seqlen;
+	uchar_t	id;
+
+	/*
+	 * Each variable binding is in turn defined as a 'SEQUENCE of' by
+	 * the SNMP PDU format, so we'll prepare the sequence and fill up
+	 * the length later. Sigh!
+	 */
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_build_sequence(buf, bufsz_p, id, 0)) == NULL)
+		return (NULL);
+	varseq_end = p;
+
+	/*
+	 * Build the object id
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID;
+	if ((p = asn_build_objid(p, bufsz_p, id, name, name_len)) == NULL)
+		return (NULL);
+
+	/*
+	 * Currently we only ever build ASN_NULL vars while sending requests,
+	 * since we support only SNMP_MSG_GET, SNMP_MSG_GETNEXT and
+	 * SNMP_MSG_GETBULK.
+	 */
+	id = ASN_UNIVERSAL | ASN_PRIMITIVE | val_type;
+	switch (val_type) {
+	case ASN_INTEGER:
+		p = asn_build_int(p, bufsz_p, id, *((int *)val));
+		if (p == NULL)
+			return (NULL);
+		break;
+
+	case ASN_OBJECT_ID:
+		p = asn_build_objid(p, bufsz_p, id, val,
+		    val_len / sizeof (oid));
+		if (p == NULL)
+			return (NULL);
+		break;
+
+	case ASN_OCTET_STR:
+		p = asn_build_string(p, bufsz_p, id, (uchar_t *)val, val_len);
+		if (p == NULL)
+			return (NULL);
+		break;
+
+	case ASN_NULL:
+		if ((p = asn_build_null(p, bufsz_p, id)) == NULL)
+			return (NULL);
+		break;
+
+	default:
+		return (NULL);
+	}
+
+	/*
+	 * Rebuild the variable sequence length
+	 */
+	seqlen = p - varseq_end;
+	id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	(void) asn_build_sequence(buf, NULL, id, seqlen);
+
+	return (p);
+}
+
+/*
+ * Parse the PDU portion of the incoming snmp message into the reply_pdu.
+ * Space for all structure members are allocated as needed and must be freed
+ * by the caller when these are no longer needed.
+ */
+static uchar_t *
+snmp_parse_pdu(int reqid, uchar_t *msg, size_t *msgsz_p, snmp_pdu_t *reply_pdu)
+{
+	uchar_t	*p;
+	uchar_t	id, exp_id;
+	pdu_varlist_t	*newvp, *vp = NULL;
+
+	/*
+	 * Parse the PDU header out of the message
+	 */
+	if ((p = asn_parse_header(msg, msgsz_p, &id)) == NULL)
+		return (NULL);
+	if (id != SNMP_MSG_RESPONSE && id != SNMP_MSG_REPORT)
+		return (NULL);
+	reply_pdu->command = (int)id;
+
+	/*
+	 * Parse the request id and verify that this is the response
+	 * we're expecting.
+	 */
+	if ((p = asn_parse_int(p, msgsz_p, &reply_pdu->reqid)) == NULL)
+		return (NULL);
+	if (reply_pdu->reqid != reqid)
+		return (NULL);
+
+	/*
+	 * Parse the error-status and error-index values
+	 */
+	if ((p = asn_parse_int(p, msgsz_p, &reply_pdu->errstat)) == NULL)
+		return (NULL);
+	if ((p = asn_parse_int(p, msgsz_p, &reply_pdu->errindex)) == NULL)
+		return (NULL);
+
+	/*
+	 * Parse the header for the variables list sequence.
+	 */
+	exp_id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_parse_sequence(p, msgsz_p, exp_id)) == NULL)
+		return (NULL);
+
+	while (((int)*msgsz_p) > 0) {
+		if ((newvp = calloc(1, sizeof (pdu_varlist_t))) == NULL)
+			return (NULL);
+
+		if (vp == NULL)
+			reply_pdu->vars = newvp;
+		else
+			vp->nextvar = newvp;
+
+		vp = newvp;
+		if ((p = snmp_parse_variable(p, msgsz_p, vp)) == NULL)
+			return (NULL);
+
+		LOGVAR(TAG_RESPONSE_VAR, vp);
+	}
+
+	return (p);
+}
+
+/*
+ * Allocate and parse the next variable into the varlist
+ */
+static uchar_t *
+snmp_parse_variable(uchar_t *msg, size_t *msgsz_p, pdu_varlist_t *vp)
+{
+	uchar_t	*p;
+	uchar_t	exp_id;
+
+	/*
+	 * Parse this variable's sequence
+	 */
+	exp_id = ASN_UNIVERSAL | ASN_CONSTRUCTOR | ASN_SEQUENCE;
+	if ((p = asn_parse_sequence(msg, msgsz_p, exp_id)) == NULL)
+		return (NULL);
+
+	/*
+	 * Parse the variable's object identifier
+	 */
+	p = asn_parse_objid(p, msgsz_p, &vp->name, &vp->name_len);
+	if (p == NULL)
+		return (NULL);
+
+	/*
+	 * Parse the object's value
+	 */
+	if ((p = asn_parse_objval(p, msgsz_p, vp)) == NULL)
+		return (NULL);
+
+	return (p);
+}
+
+void
+snmp_free_pdu(snmp_pdu_t *pdu)
+{
+	pdu_varlist_t *vp, *nxt;
+
+	if (pdu) {
+		if (pdu->community)
+			free((void *) pdu->community);
+
+		for (vp = pdu->vars; vp; vp = nxt) {
+			nxt = vp->nextvar;
+
+			if (vp->name)
+				free((void *) vp->name);
+			if (vp->val.str)
+				free((void *) vp->val.str);
+			free((void *) vp);
+		}
+
+		if (pdu->req_pkt)
+			free((void *) pdu->req_pkt);
+
+		if (pdu->reply_pkt)
+			free((void *) pdu->reply_pkt);
+
+		free((void *) pdu);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/pdu.h	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,159 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_PDU_H
+#define	_PDU_H
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef uint_t	oid;
+
+/*
+ * SNMP PDU variable list
+ */
+typedef struct pdu_varlist {
+	struct pdu_varlist *nextvar;
+	oid	*name;
+	size_t	name_len;		/* number of subids in the name */
+	union {
+		uint_t	*uiptr;		/* unused except while parsing */
+		int	*iptr;
+		uchar_t	*str;
+		oid	*objid;
+	} val;
+	size_t	val_len;		/* in bytes even if val is objid */
+	uchar_t	type;
+} pdu_varlist_t;
+
+/*
+ * Essential snmp message/PDU fields
+ */
+typedef struct snmp_pdu {
+	int	version;
+	uchar_t	*community;
+	size_t	community_len;
+	int	command;
+	int	reqid;
+	int	errstat;	/* shared with non-repeaters for GETBULK */
+	int	errindex;	/* shared with max-repetitions for GETBULK */
+	pdu_varlist_t	*vars;
+
+	uchar_t	*req_pkt;	/* not really part of PDU */
+	size_t	req_pktsz;	/* not really part of PDU */
+	uchar_t	*reply_pkt;	/* not really part of PDU */
+	size_t	reply_pktsz;	/* not really part of PDU */
+} snmp_pdu_t;
+#define	non_repeaters	errstat
+#define	max_repetitions	errindex
+
+/*
+ * Supported SNMP versions
+ */
+#define	SNMP_VERSION_1		0
+#define	SNMP_VERSION_2c		1
+
+/*
+ * Community strings for supported PDUs
+ */
+#define	SNMP_DEF_COMMUNITY	"public"
+#define	SNMP_DEF_COMMUNITY_LEN	6
+
+/*
+ * PDU types (not all are supported)
+ */
+#define	SNMP_MSG_GET		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x0)
+#define	SNMP_MSG_GETNEXT	(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x1)
+#define	SNMP_MSG_RESPONSE	(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x2)
+#define	SNMP_MSG_SET		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x3)
+#define	SNMP_MSG_TRAP		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x4)
+#define	SNMP_MSG_GETBULK	(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x5)
+#define	SNMP_MSG_INFORM		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x6)
+#define	SNMP_MSG_TRAP2		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x7)
+#define	SNMP_MSG_REPORT		(ASN_CONTEXT | ASN_CONSTRUCTOR | (uchar_t)0x8)
+
+/*
+ * Exception values (not all are supported)
+ */
+#define	SNMP_NOSUCHOBJECT	(ASN_CONTEXT | ASN_PRIMITIVE | (uchar_t)0x0)
+#define	SNMP_NOSUCHINSTANCE	(ASN_CONTEXT | ASN_PRIMITIVE | (uchar_t)0x1)
+#define	SNMP_ENDOFMIBVIEW	(ASN_CONTEXT | ASN_PRIMITIVE | (uchar_t)0x2)
+
+/*
+ * Error codes (not all are supported)
+ */
+#define	SNMP_ERR_NOERROR		(0)
+#define	SNMP_ERR_TOOBIG			(1)
+#define	SNMP_ERR_NOSUCHNAME		(2)
+#define	SNMP_ERR_BADVALUE		(3)
+#define	SNMP_ERR_READONLY		(4)
+#define	SNMP_ERR_GENERR			(5)
+#define	SNMP_ERR_NOACCESS		(6)
+#define	SNMP_ERR_WRONGTYPE		(7)
+#define	SNMP_ERR_WRONGLENGTH		(8)
+#define	SNMP_ERR_WRONGENCODING		(9)
+#define	SNMP_ERR_WRONGVALUE		(10)
+#define	SNMP_ERR_NOCREATION		(11)
+#define	SNMP_ERR_INCONSISTENTVALUE	(12)
+#define	SNMP_ERR_RESOURCEUNAVAILABLE	(13)
+#define	SNMP_ERR_COMMITFAILED		(14)
+#define	SNMP_ERR_UNDOFAILED		(15)
+#define	SNMP_ERR_AUTHORIZATIONERROR	(16)
+#define	SNMP_ERR_NOTWRITABLE		(17)
+#define	SNMP_ERR_INCONSISTENTNAME	(18)
+
+/*
+ * Default values
+ */
+#define	SNMP_DEF_NON_REPEATERS		0
+#define	SNMP_DEF_MAX_REPETITIONS	25
+#define	SNMP_DEF_PKTBUF_SZ		2048
+#define	SNMP_PKTBUF_BLKSZ		1024
+#define	SNMP_MAX_ERR    		18
+#define	MIN_SUBIDS_IN_OID		2
+#define	MAX_SUBIDS_IN_OID		128
+
+/*
+ * Exported interfaces used by other parts of snmplib
+ */
+snmp_pdu_t	*snmp_create_pdu(int, int, char *, int, int);
+int		snmp_make_packet(snmp_pdu_t *);
+snmp_pdu_t	*snmp_parse_reply(int, uchar_t *, size_t);
+void		snmp_free_pdu(snmp_pdu_t *);
+
+/*
+ * Imported from elsewhere
+ */
+int		snmp_get_reqid(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _PDU_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/picl/plugins/sun4v/lib/snmp/snmplib.c	Sat Mar 31 18:24:05 2007 -0700
@@ -0,0 +1,1245 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ * The snmp library helps to prepare the PDUs and communicate with
+ * the snmp agent on the SP side via the ds_snmp driver.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <thread.h>
+#include <synch.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <libnvpair.h>
+#include <sys/ds_snmp.h>
+
+#include "libpiclsnmp.h"
+#include "snmplib.h"
+#include "asn1.h"
+#include "pdu.h"
+#include "debug.h"
+
+#pragma init(libpiclsnmp_init)		/* need this in .init */
+
+/*
+ * Data from the MIB is fetched based on the hints about object
+ * groups received from (possibly many threads in) the application.
+ * However, the fetched data is kept in a common cache for use across
+ * all threads, so even a GETBULK is issued only when absolutely
+ * necessary.
+ *
+ * Note that locking is not fine grained (there's no locking per row)
+ * since we don't expect too many MT consumers right away.
+ *
+ */
+static mutex_t	mibcache_lock;
+static nvlist_t	**mibcache = NULL;
+static uint_t	n_mibcache_rows = 0;
+
+static mutex_t snmp_reqid_lock;
+static int snmp_reqid = 1;
+
+#ifdef SNMP_DEBUG
+uint_t snmp_nsends = 0;
+uint_t snmp_sentbytes = 0;
+uint_t snmp_nrecvs = 0;
+uint_t snmp_rcvdbytes = 0;
+#endif
+
+#ifdef USE_SOCKETS
+#define	SNMP_DEFAULT_PORT	161
+#define	SNMP_MAX_RECV_PKTSZ	(64 * 1024)
+#endif
+
+/*
+ * Static function declarations
+ */
+static void	libpiclsnmp_init(void);
+
+static int	lookup_int(char *, int, int *, int);
+static int	lookup_str(char *, int, char **, int);
+static int	lookup_bitstr(char *, int, uchar_t **, uint_t *, int);
+
+static oidgroup_t *locate_oid_group(struct picl_snmphdl *, char *);
+static int	search_oid_in_group(char *, char *, int);
+
+static snmp_pdu_t *fetch_single(struct picl_snmphdl *, char *, int, int *);
+static snmp_pdu_t *fetch_next(struct picl_snmphdl *, char *, int, int *);
+static void	fetch_bulk(struct picl_snmphdl *, char *, int, int, int, int *);
+static int	fetch_single_str(struct picl_snmphdl *, char *, int,
+		    char **, int *);
+static int	fetch_single_int(struct picl_snmphdl *, char *, int,
+		    int *, int *);
+static int	fetch_single_bitstr(struct picl_snmphdl *, char *, int,
+		    uchar_t **, uint_t *, int *);
+
+static int	snmp_send_request(struct picl_snmphdl *, snmp_pdu_t *, int *);
+static int	snmp_recv_reply(struct picl_snmphdl *, snmp_pdu_t *, int *);
+
+static int	mibcache_realloc(int);
+static void	mibcache_populate(snmp_pdu_t *, int);
+static char	*oid_to_oidstr(oid *, size_t);
+
+
+static void
+libpiclsnmp_init(void)
+{
+	(void) mutex_init(&mibcache_lock, USYNC_THREAD, NULL);
+	if (mibcache_realloc(0) < 0)
+		(void) mutex_destroy(&mibcache_lock);
+
+	(void) mutex_init(&snmp_reqid_lock, USYNC_THREAD, NULL);
+
+	LOGINIT();
+}
+
+picl_snmphdl_t
+snmp_init()
+{
+	struct picl_snmphdl	*smd;
+#ifdef USE_SOCKETS
+	int	sbuf = (1 << 15);	/* 16K */
+	int	rbuf = (1 << 17);	/* 64K */
+	char	*snmp_agent_addr;
+#endif
+
+	smd = (struct picl_snmphdl *)calloc(1, sizeof (struct picl_snmphdl));
+	if (smd == NULL)
+		return (NULL);
+
+#ifdef USE_SOCKETS
+	if ((snmp_agent_addr = getenv("SNMP_AGENT_IPADDR")) == NULL)
+		return (NULL);
+
+	if ((smd->fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
+		return (NULL);
+
+	(void) setsockopt(smd->fd, SOL_SOCKET, SO_SNDBUF, &sbuf, sizeof (int));
+	(void) setsockopt(smd->fd, SOL_SOCKET, SO_RCVBUF, &rbuf, sizeof (int));
+
+	memset(&smd->agent_addr, 0, sizeof (struct sockaddr_in));
+	smd->agent_addr.sin_family = AF_INET;
+	smd->agent_addr.sin_port = htons(SNMP_DEFAULT_PORT);
+	smd->agent_addr.sin_addr.s_addr = inet_addr(snmp_agent_addr);
+#else
+	smd->fd = open(DS_SNMP_DRIVER, O_RDWR);
+	if (smd->fd < 0) {
+		free(smd);
+		return (NULL);
+	}
+#endif
+
+	return ((picl_snmphdl_t)smd);
+}
+
+void
+snmp_fini(picl_snmphdl_t hdl)
+{
+	struct picl_snmphdl	*smd = (struct picl_snmphdl *)hdl;
+
+	if (smd) {
+		if (smd->fd >= 0) {
+			(void) close(smd->fd);
+		}
+		free(smd);
+	}
+}
+
+int
+snmp_reinit(picl_snmphdl_t hdl, int clr_linkreset)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	nvlist_t *nvl;
+	int i;
+
+	(void) mutex_lock(&mibcache_lock);
+
+	for (i = 0; i < n_mibcache_rows; i++) {
+		if ((nvl = mibcache[i]) != NULL)
+			nvlist_free(nvl);
+	}
+
+	n_mibcache_rows = 0;
+	if (mibcache) {
+		free(mibcache);
+		mibcache = NULL;
+	}
+
+	(void) mutex_unlock(&mibcache_lock);
+
+	if (clr_linkreset) {
+		if (smd == NULL || smd->fd < 0)
+			return (-1);
+		else
+			return (ioctl(smd->fd, DSSNMP_CLRLNKRESET, NULL));
+	}
+
+	return (0);
+}
+
+void
+snmp_register_group(picl_snmphdl_t hdl, char *oidstrs, int n_oids, int is_vol)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	oidgroup_t	*oidg;
+	oidgroup_t	*curr, *prev;
+	char		*p;
+	int		i, sz;
+
+	/*
+	 * Allocate a new oidgroup_t
+	 */
+	oidg = (oidgroup_t *)calloc(1, sizeof (struct oidgroup));
+	if (oidg == NULL)
+		return;
+
+	/*
+	 * Determine how much space is required to register this group
+	 */
+	sz = 0;
+	p = oidstrs;
+	for (i = 0; i < n_oids; i++) {
+		sz += strlen(p) + 1;
+		p = oidstrs + sz;
+	}
+
+	/*
+	 * Create this oid group
+	 */
+	if ((p = (char *)malloc(sz)) == NULL) {
+		free((void *) oidg);
+		return;
+	}
+
+	(void) memcpy(p, oidstrs, sz);
+
+	oidg->next = NULL;
+	oidg->oidstrs = p;
+	oidg->n_oids = n_oids;
+	oidg->is_volatile = is_vol;
+
+	/*
+	 * Link it to the tail of the list of oid groups
+	 */
+	for (prev = NULL, curr = smd->group; curr; curr = curr->next)
+		prev = curr;
+
+	if (prev == NULL)
+		smd->group = oidg;
+	else
+		prev->next = oidg;
+}
+
+/*
+ * snmp_get_int() takes in an OID and returns the integer value
+ * of the object referenced in the passed arg. It returns 0 on
+ * success and -1 on failure.
+ */
+int
+snmp_get_int(picl_snmphdl_t hdl, char *prefix, int row, int *val,
+    int *snmp_syserr)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	oidgroup_t	*grp;
+	int	ret;
+	int	err = 0;
+
+	if (smd == NULL || prefix == NULL || val == NULL)
+		return (-1);
+
+	/*
+	 * If this item should not be cached, fetch it directly from
+	 * the agent using fetch_single_xxx()
+	 */
+	if ((grp = locate_oid_group(smd, prefix)) == NULL) {
+		ret = fetch_single_int(smd, prefix, row, val, &err);
+
+		if (snmp_syserr)
+			*snmp_syserr = err;
+
+		return (ret);
+	}
+
+	/*
+	 * is it in the cache ?
+	 */
+	if (lookup_int(prefix, row, val, grp->is_volatile) == 0)
+		return (0);
+
+	/*
+	 * fetch it from the agent and populate the cache
+	 */
+	fetch_bulk(smd, grp->oidstrs, grp->n_oids, row, grp->is_volatile, &err);
+	if (snmp_syserr)
+		*snmp_syserr = err;
+
+	/*
+	 * look it up again and return it
+	 */
+	if (lookup_int(prefix, row, val, grp->is_volatile) < 0)
+		return (-1);
+
+	return (0);
+}
+
+/*
+ * snmp_get_str() takes in an OID and returns the string value
+ * of the object referenced in the passed arg. Memory for the string
+ * is allocated within snmp_get_str() and is expected to be freed by
+ * the caller when it is no longer needed. The function returns 0
+ * on success and -1 on failure.
+ */
+int
+snmp_get_str(picl_snmphdl_t hdl, char *prefix, int row, char **strp,
+    int *snmp_syserr)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	oidgroup_t	*grp;
+	char	*val;
+	int	ret;
+	int	err = 0;
+
+	if (smd == NULL || prefix == NULL || strp == NULL)
+		return (-1);
+
+	/*
+	 * Check if this item is cacheable or not. If not, call
+	 * fetch_single_* to get it directly from the agent
+	 */
+	if ((grp = locate_oid_group(smd, prefix)) == NULL) {
+		ret = fetch_single_str(smd, prefix, row, strp, &err);
+
+		if (snmp_syserr)
+			*snmp_syserr = err;
+
+		return (ret);
+	}
+
+	/*
+	 * See if it's in the cache already
+	 */
+	if (lookup_str(prefix, row, &val, grp->is_volatile) == 0) {
+		if ((*strp = strdup(val)) == NULL)
+			return (-1);
+		else
+			return (0);
+	}
+
+	/*
+	 * Fetch it from the agent and populate cache
+	 */
+	fetch_bulk(smd, grp->oidstrs, grp->n_oids, row, grp->is_volatile, &err);
+	if (snmp_syserr)
+		*snmp_syserr = err;
+
+	/*
+	 * Retry lookup
+	 */
+	if (lookup_str(prefix, row, &val, grp->is_volatile) < 0)
+		return (-1);
+
+
+	if ((*strp = strdup(val)) == NULL)
+		return (-1);
+	else
+		return (0);
+}
+
+/*
+ * snmp_get_bitstr() takes in an OID and returns the bit string value
+ * of the object referenced in the passed args. Memory for the bitstring
+ * is allocated within the function and is expected to be freed by
+ * the caller when it is no longer needed. The function returns 0
+ * on success and -1 on failure.
+ */
+int
+snmp_get_bitstr(picl_snmphdl_t hdl, char *prefix, int row, uchar_t **bitstrp,
+    uint_t *nbytes, int *snmp_syserr)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	oidgroup_t	*grp;
+	uchar_t	*val;
+	int	ret;
+	int	err = 0;
+
+	if (smd == NULL || prefix == NULL || bitstrp == NULL || nbytes == NULL)
+		return (-1);
+
+	/*
+	 * Check if this item is cacheable or not. If not, call
+	 * fetch_single_* to get it directly from the agent
+	 */
+	if ((grp = locate_oid_group(smd, prefix)) == NULL) {
+		ret = fetch_single_bitstr(smd, prefix, row, bitstrp,
+		    nbytes, &err);
+
+		if (snmp_syserr)
+			*snmp_syserr = err;
+
+		return (ret);
+	}
+
+	/*
+	 * See if it's in the cache already
+	 */
+	if (lookup_bitstr(prefix, row, &val, nbytes, grp->is_volatile) == 0) {
+		if ((*bitstrp = (uchar_t *)calloc(*nbytes, 1)) == NULL)
+			return (-1);
+		(void) memcpy(*bitstrp, (const void *)val, *nbytes);
+		return (0);
+	}
+
+	/*
+	 * Fetch it from the agent and populate cache
+	 */
+	fetch_bulk(smd, grp->oidstrs, grp->n_oids, row, grp->is_volatile, &err);
+	if (snmp_syserr)
+		*snmp_syserr = err;
+
+	/*
+	 * Retry lookup
+	 */
+	if (lookup_bitstr(prefix, row, &val, nbytes, grp->is_volatile) < 0)
+		return (-1);
+
+	if ((*bitstrp = (uchar_t *)calloc(*nbytes, 1)) == NULL)
+		return (-1);
+	(void) memcpy(*bitstrp, (const void *)val, *nbytes);
+
+	return (0);
+}
+
+/*
+ * snmp_get_nextrow() is similar in operation to SNMP_GETNEXT, but
+ * only just. In particular, this is only expected to return the next
+ * valid row number for the same object, not its value. Since we don't
+ * have any other means, we use this to determine the number of rows
+ * in the table (and the valid ones). This function returns 0 on success
+ * and -1 on failure.
+ */
+int
+snmp_get_nextrow(picl_snmphdl_t hdl, char *prefix, int row, int *nextrow,
+    int *snmp_syserr)
+{
+	struct picl_snmphdl *smd = (struct picl_snmphdl *)hdl;
+	snmp_pdu_t *reply_pdu;
+	pdu_varlist_t *vp;
+	char	*nxt_oidstr;
+	int	err = 0;
+
+	if (smd == NULL || prefix == NULL || nextrow == NULL)
+		return (-1);
+
+	/*
+	 * The get_nextrow results should *never* go into any cache,
+	 * since these relationships are dynamically discovered each time.
+	 */
+	if ((reply_pdu = fetch_next(smd, prefix, row, &err)) == NULL) {
+		if (snmp_syserr)
+			*snmp_syserr = err;
+
+		return (-1);
+	}
+
+	/*
+	 * We are not concerned about the "value" of the lexicographically
+	 * next object; we only care about the name of that object and
+	 * its row number (and whether such an object exists or not).
+	 */
+	vp = reply_pdu->vars;
+	if (vp == NULL || vp->name == NULL || vp->type == SNMP_NOSUCHOBJECT ||
+	    vp->type == SNMP_NOSUCHINSTANCE || vp->type == SNMP_ENDOFMIBVIEW) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+	if ((nxt_oidstr = oid_to_oidstr(vp->name, vp->name_len - 1)) == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+	if (strcmp(nxt_oidstr, prefix) != 0) {
+		free(nxt_oidstr);
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+
+	/*
+	 * Ok, so we've got an oid that's simply the next valid row of the
+	 * passed on object, return this row number.
+	 */
+	*nextrow = (vp->name)[vp->name_len-1];
+
+	free(nxt_oidstr);
+	snmp_free_pdu(reply_pdu);
+
+	return (0);
+}
+
+/*
+ * Request ids for snmp messages to the agent are sequenced here.
+ */
+int
+snmp_get_reqid(void)
+{
+	int	ret;
+
+	(void) mutex_lock(&snmp_reqid_lock);
+
+	ret = snmp_reqid++;
+
+	(void) mutex_unlock(&snmp_reqid_lock);
+
+	return (ret);
+}
+
+static int
+lookup_int(char *prefix, int row, int *valp, int is_vol)
+{
+	int32_t	*val_arr;
+	uint_t	nelem;
+	struct timeval tv;
+	int	elapsed;
+
+	(void) mutex_lock(&mibcache_lock);
+
+	if (row >= n_mibcache_rows) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	if (mibcache[row] == NULL) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	/*
+	 * If this is a volatile property, we should be searching
+	 * for an integer-timestamp pair
+	 */
+	if (is_vol) {
+		if (nvlist_lookup_int32_array(mibcache[row], prefix,
+		    &val_arr, &nelem) != 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		if (nelem != 2 || val_arr[1] < 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		if (gettimeofday(&tv, NULL) < 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		elapsed = tv.tv_sec - val_arr[1];
+		if (elapsed < 0 || elapsed > MAX_INCACHE_TIME) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+
+		*valp = (int)val_arr[0];
+	} else {
+		if (nvlist_lookup_int32(mibcache[row], prefix, valp) != 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+	}
+
+	(void) mutex_unlock(&mibcache_lock);
+
+	return (0);
+}
+
+static int
+lookup_str(char *prefix, int row, char **valp, int is_vol)
+{
+	char	**val_arr;
+	uint_t	nelem;
+	struct timeval tv;
+	int	elapsed;
+
+	(void) mutex_lock(&mibcache_lock);
+
+	if (row >= n_mibcache_rows) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	if (mibcache[row] == NULL) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	/*
+	 * If this is a volatile property, we should be searching
+	 * for a string-timestamp pair
+	 */
+	if (is_vol) {
+		if (nvlist_lookup_string_array(mibcache[row], prefix,
+		    &val_arr, &nelem) != 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		if (nelem != 2 || atoi(val_arr[1]) <= 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		if (gettimeofday(&tv, NULL) < 0) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+		elapsed = tv.tv_sec - atoi(val_arr[1]);
+		if (elapsed < 0 || elapsed > MAX_INCACHE_TIME) {
+			(void) mutex_unlock(&mibcache_lock);
+			return (-1);
+		}
+
+		*valp = val_arr[0];
+	} else {
+	    if (nvlist_lookup_string(mibcache[row], prefix, valp) != 0) {
+		    (void) mutex_unlock(&mibcache_lock);
+		    return (-1);
+	    }
+	}
+
+	(void) mutex_unlock(&mibcache_lock);
+
+	return (0);
+}
+
+static int
+lookup_bitstr(char *prefix, int row, uchar_t **valp, uint_t *nelem, int is_vol)
+{
+	(void) mutex_lock(&mibcache_lock);
+
+	if (row >= n_mibcache_rows) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	if (mibcache[row] == NULL) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	/*
+	 * We don't support volatile bit string values yet. The nvlist
+	 * functions don't support bitstring arrays like they do charstring
+	 * arrays, so we would need to do things in a convoluted way,
+	 * probably by attaching the timestamp as part of the byte array
+	 * itself. However, the need for volatile bitstrings isn't there
+	 * yet, to justify the effort.
+	 */
+	if (is_vol) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	if (nvlist_lookup_byte_array(mibcache[row], prefix, valp, nelem) != 0) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	(void) mutex_unlock(&mibcache_lock);
+
+	return (0);
+}
+
+static int
+search_oid_in_group(char *prefix, char *oidstrs, int n_oids)
+{
+	char	*p;
+	int	i;
+
+	p = oidstrs;
+	for (i = 0; i < n_oids; i++) {
+		if (strcmp(p, prefix) == 0)
+			return (0);
+
+		p += strlen(p) + 1;
+	}
+
+	return (-1);
+}
+
+static oidgroup_t *
+locate_oid_group(struct picl_snmphdl *smd, char *prefix)
+{
+	oidgroup_t	*grp;
+
+	if (smd == NULL)
+		return (NULL);
+
+	if (smd->group == NULL)
+		return (NULL);
+
+	for (grp = smd->group; grp; grp = grp->next) {
+		if (search_oid_in_group(prefix, grp->oidstrs,
+		    grp->n_oids) == 0) {
+			return (grp);
+		}
+	}
+
+	return (NULL);
+}
+
+static int
+fetch_single_int(struct picl_snmphdl *smd, char *prefix, int row, int *ival,
+    int *snmp_syserr)
+{
+	snmp_pdu_t *reply_pdu;
+	pdu_varlist_t *vp;
+
+	if ((reply_pdu = fetch_single(smd, prefix, row, snmp_syserr)) == NULL)
+		return (-1);
+
+	/*
+	 * Note that we don't make any distinction between unsigned int
+	 * value and signed int value at this point, since we provide
+	 * only snmp_get_int() at the higher level. While it is possible
+	 * to provide an entirely separate interface such as snmp_get_uint(),
+	 * that's quite unnecessary, because we don't do any interpretation
+	 * of the received value. Besides, the sizes of int and uint are
+	 * the same and the sizes of all pointers are the same (so val.iptr
+	 * would be the same as val.uiptr in pdu_varlist_t). If/when we
+	 * violate any of these assumptions, it will be time to add
+	 * snmp_get_uint().
+	 */
+	vp = reply_pdu->vars;
+	if (vp == NULL || vp->val.iptr == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+
+	*ival = *(vp->val.iptr);
+
+	snmp_free_pdu(reply_pdu);
+
+	return (0);
+}
+
+static int
+fetch_single_str(struct picl_snmphdl *smd, char *prefix, int row, char **valp,
+    int *snmp_syserr)
+{
+	snmp_pdu_t *reply_pdu;
+	pdu_varlist_t *vp;
+
+	if ((reply_pdu = fetch_single(smd, prefix, row, snmp_syserr)) == NULL)
+		return (-1);
+
+	vp = reply_pdu->vars;
+	if (vp == NULL || vp->val.str == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+
+	*valp = strdup((const char *)(vp->val.str));
+
+	snmp_free_pdu(reply_pdu);
+
+	return (0);
+}
+
+static int
+fetch_single_bitstr(struct picl_snmphdl *smd, char *prefix, int row,
+    uchar_t **valp, uint_t *nelem, int *snmp_syserr)
+{
+	snmp_pdu_t *reply_pdu;
+	pdu_varlist_t *vp;
+
+	if ((reply_pdu = fetch_single(smd, prefix, row, snmp_syserr)) == NULL)
+		return (-1);
+
+	vp = reply_pdu->vars;
+	if (vp == NULL || vp->val.str == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+
+	if ((*valp = (uchar_t *)calloc(vp->val_len, 1)) == NULL) {
+		snmp_free_pdu(reply_pdu);
+		return (-1);
+	}
+
+	*nelem = vp->val_len;
+	(void) memcpy(*valp, (const void *)(vp->val.str),
+	    (size_t)(vp->val_len));
+
+	snmp_free_pdu(reply_pdu);
+
+	return (0);
+}
+
+static snmp_pdu_t *
+fetch_single(struct picl_snmphdl *smd, char *prefix, int row, int *snmp_syserr)
+{
+	snmp_pdu_t	*pdu, *reply_pdu;
+
+	LOGGET(TAG_CMD_REQUEST, prefix, row);
+
+	if ((pdu = snmp_create_pdu(SNMP_MSG_GET, 0, prefix, 1, row)) == NULL)
+		return (NULL);
+
+	LOGPDU(TAG_REQUEST_PDU, pdu);
+
+	if (snmp_make_packet(pdu) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	LOGPKT(TAG_REQUEST_PKT, pdu->req_pkt, pdu->req_pktsz);
+
+	if (snmp_send_request(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	if (snmp_recv_reply(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	LOGPKT(TAG_RESPONSE_PKT, pdu->reply_pkt, pdu->reply_pktsz);
+
+	reply_pdu = snmp_parse_reply(pdu->reqid, pdu->reply_pkt,
+	    pdu->reply_pktsz);
+
+	LOGPDU(TAG_RESPONSE_PDU, reply_pdu);
+
+	snmp_free_pdu(pdu);
+
+	return (reply_pdu);
+}
+
+static void
+fetch_bulk(struct picl_snmphdl *smd, char *oidstrs, int n_oids,
+    int row, int is_vol, int *snmp_syserr)
+{
+	snmp_pdu_t	*pdu, *reply_pdu;
+	int		max_reps;
+
+	LOGBULK(TAG_CMD_REQUEST, n_oids, oidstrs, row);
+
+	/*
+	 * If we're fetching volatile properties using BULKGET, don't
+	 * venture to get multiple rows (passing max_reps=0 will make
+	 * snmp_create_pdu() fetch SNMP_DEF_MAX_REPETITIONS rows)
+	 */
+	max_reps = is_vol ? 1 : 0;
+
+	pdu = snmp_create_pdu(SNMP_MSG_GETBULK, max_reps, oidstrs, n_oids, row);
+	if (pdu == NULL)
+		return;
+
+	LOGPDU(TAG_REQUEST_PDU, pdu);
+
+	/*
+	 * Make an ASN.1 encoded packet from the PDU information
+	 */
+	if (snmp_make_packet(pdu) < 0) {
+		snmp_free_pdu(pdu);
+		return;
+	}
+
+	LOGPKT(TAG_REQUEST_PKT, pdu->req_pkt, pdu->req_pktsz);
+
+	/*
+	 * Send the request packet to the agent
+	 */
+	if (snmp_send_request(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return;
+	}
+
+	/*
+	 * Receive response from the agent into the reply packet buffer
+	 * in the request PDU
+	 */
+	if (snmp_recv_reply(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return;
+	}
+
+	LOGPKT(TAG_RESPONSE_PKT, pdu->reply_pkt, pdu->reply_pktsz);
+
+	/*
+	 * Parse the reply, validate the response and create a
+	 * reply-PDU out of the information. Populate the mibcache
+	 * with the received values.
+	 */
+	reply_pdu = snmp_parse_reply(pdu->reqid, pdu->reply_pkt,
+	    pdu->reply_pktsz);
+	if (reply_pdu) {
+		LOGPDU(TAG_RESPONSE_PDU, reply_pdu);
+
+		if (reply_pdu->errstat == SNMP_ERR_NOERROR)
+			mibcache_populate(reply_pdu, is_vol);
+
+		snmp_free_pdu(reply_pdu);
+	}
+
+	snmp_free_pdu(pdu);
+}
+
+static snmp_pdu_t *
+fetch_next(struct picl_snmphdl *smd, char *prefix, int row, int *snmp_syserr)
+{
+	snmp_pdu_t	*pdu, *reply_pdu;
+
+	LOGNEXT(TAG_CMD_REQUEST, prefix, row);
+
+	pdu = snmp_create_pdu(SNMP_MSG_GETNEXT, 0, prefix, 1, row);
+	if (pdu == NULL)
+		return (NULL);
+
+	LOGPDU(TAG_REQUEST_PDU, pdu);
+
+	if (snmp_make_packet(pdu) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	LOGPKT(TAG_REQUEST_PKT, pdu->req_pkt, pdu->req_pktsz);
+
+	if (snmp_send_request(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	if (snmp_recv_reply(smd, pdu, snmp_syserr) < 0) {
+		snmp_free_pdu(pdu);
+		return (NULL);
+	}
+
+	LOGPKT(TAG_RESPONSE_PKT, pdu->reply_pkt, pdu->reply_pktsz);
+
+	reply_pdu = snmp_parse_reply(pdu->reqid, pdu->reply_pkt,
+	    pdu->reply_pktsz);
+
+	LOGPDU(TAG_RESPONSE_PDU, reply_pdu);
+
+	snmp_free_pdu(pdu);
+
+	return (reply_pdu);
+}
+
+static int
+snmp_send_request(struct picl_snmphdl *smd, snmp_pdu_t *pdu, int *snmp_syserr)
+{
+	extern int	errno;
+#ifdef USE_SOCKETS
+	int		ret;
+#endif
+
+	if (smd->fd < 0)
+		return (-1);
+
+	if (pdu == NULL || pdu->req_pkt == NULL)
+		return (-1);
+
+#ifdef USE_SOCKETS
+	ret = -1;
+	while (ret < 0) {
+		LOGIO(TAG_SENDTO, smd->fd, pdu->req_pkt, pdu->req_pktsz);
+
+		ret = sendto(smd->fd, pdu->req_pkt, pdu->req_pktsz, 0,
+		    (struct sockaddr *)&smd->agent_addr,
+		    sizeof (struct sockaddr));
+		if (ret < 0 && errno != EINTR) {
+			return (-1);
+		}
+	}
+#else
+	LOGIO(TAG_WRITE, smd->fd, pdu->req_pkt, pdu->req_pktsz);
+
+	if (write(smd->fd, pdu->req_pkt, pdu->req_pktsz) < 0) {
+		if (snmp_syserr)
+			*snmp_syserr = errno;
+		return (-1);
+	}
+#endif
+
+#ifdef SNMP_DEBUG
+	snmp_nsends++;
+	snmp_sentbytes += pdu->req_pktsz;
+#endif
+
+	return (0);
+}
+
+static int
+snmp_recv_reply(struct picl_snmphdl *smd, snmp_pdu_t *pdu, int *snmp_syserr)
+{
+	struct dssnmp_info	snmp_info;
+	size_t	pktsz;
+	uchar_t	*pkt;
+	extern int errno;
+#ifdef USE_SOCKETS
+	struct sockaddr_in 	from;
+	int	fromlen;
+	ssize_t	msgsz;
+#endif
+
+	if (smd->fd < 0 || pdu == NULL)
+		return (-1);
+
+#ifdef USE_SOCKETS
+	if ((pkt = (uchar_t *)calloc(1, SNMP_MAX_RECV_PKTSZ)) == NULL)
+		return (-1);
+
+	fromlen = sizeof (struct sockaddr_in);
+
+	LOGIO(TAG_RECVFROM, smd->fd, pkt, SNMP_MAX_RECV_PKTSZ);
+
+	msgsz = recvfrom(smd->fd, pkt, SNMP_MAX_RECV_PKTSZ, 0,
+	    (struct sockaddr *)&from, &fromlen);
+	if (msgsz  < 0 || msgsz >= SNMP_MAX_RECV_PKTSZ) {
+		free(pkt);
+		return (-1);
+	}
+
+	pktsz = (size_t)msgsz;
+#else
+	LOGIO(TAG_IOCTL, smd->fd, DSSNMP_GETINFO, &snmp_info);
+
+	/*
+	 * The ioctl will block until we have snmp data available
+	 */
+	if (ioctl(smd->fd, DSSNMP_GETINFO, &snmp_info) < 0) {
+		if (snmp_syserr)
+			*snmp_syserr = errno;
+		return (-1);
+	}
+
+	pktsz = snmp_info.size;
+	if ((pkt = (uchar_t *)calloc(1, pktsz)) == NULL)
+		return (-1);
+
+	LOGIO(TAG_READ, smd->fd, pkt, pktsz);
+
+	if (read(smd->fd, pkt, pktsz) < 0) {
+		free(pkt);
+		if (snmp_syserr)
+			*snmp_syserr = errno;
+		return (-1);
+	}
+#endif
+
+	pdu->reply_pkt = pkt;
+	pdu->reply_pktsz = pktsz;
+
+#ifdef SNMP_DEBUG
+	snmp_nrecvs++;
+	snmp_rcvdbytes += pktsz;
+#endif
+
+	return (0);
+}
+
+static int
+mibcache_realloc(int hint)
+{
+	uint_t		count = (uint_t)hint;
+	nvlist_t	**p;
+
+	if (hint < 0)
+		return (-1);
+
+	(void) mutex_lock(&mibcache_lock);
+
+	if (hint < n_mibcache_rows) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (0);
+	}
+
+	count =  ((count >> MIBCACHE_BLK_SHIFT) + 1) << MIBCACHE_BLK_SHIFT;
+
+	p = (nvlist_t **)calloc(count, sizeof (nvlist_t *));
+	if (p == NULL) {
+		(void) mutex_unlock(&mibcache_lock);
+		return (-1);
+	}
+
+	if (mibcache) {
+		(void) memcpy((void *) p, (void *) mibcache,
+		    n_mibcache_rows * sizeof (nvlist_t *));
+		free((void *) mibcache);
+	}
+
+	mibcache = p;
+	n_mibcache_rows = count;
+
+	(void) mutex_unlock(&mibcache_lock);
+
+	return (0);
+}
+
+
+/*
+ * Scan each variable in the returned PDU's bindings and populate
+ * the cache appropriately
+ */
+static void
+mibcache_populate(snmp_pdu_t *pdu, int is_vol)
+{
+	pdu_varlist_t	*vp;
+	int		row, ret;
+	char		*oidstr;
+	struct timeval	tv;
+	int		tod;	/* in secs */
+	char		tod_str[MAX_INT_LEN];
+	int		ival_arr[2];
+	char		*sval_arr[2];
+
+	/*
+	 * If we're populating volatile properties, we also store a
+	 * timestamp with each property value. When we lookup, we
+	 * check the current time against this timestamp to determine
+	 * if we need to refetch the value or not (refetch if it has
+	 * been in for far too long).
+	 */
+	if (is_vol) {
+		if (gettimeofday(&tv, NULL) < 0)
+			tod = -1;
+		else
+			tod = (int)tv.tv_sec;
+
+		tod_str[0] = 0;
+		(void) snprintf(tod_str, MAX_INT_LEN, "%d", tod);
+
+		ival_arr[1] = tod;
+		sval_arr[1] = (char *)tod_str;
+	}
+
+	for (vp = pdu->vars; vp; vp = vp->nextvar) {
+		if (vp->type != ASN_INTEGER && vp->type != ASN_OCTET_STR &&
+		    vp->type != ASN_BIT_STR) {
+			continue;
+		}
+
+		if (vp->name == NULL || vp->val.str == NULL)
+			continue;
+
+		row = (vp->name)[vp->name_len-1];
+
+		(void) mutex_lock(&mibcache_lock);
+
+		if (row >= n_mibcache_rows) {
+			(void) mutex_unlock(&mibcache_lock);
+			if (mibcache_realloc(row) < 0)
+				continue;
+			(void) mutex_lock(&mibcache_lock);
+		}
+		ret = 0;
+		if (mibcache[row] == NULL)
+			ret = nvlist_alloc(&mibcache[row], NV_UNIQUE_NAME, 0);
+
+		(void) mutex_unlock(&mibcache_lock);
+
+		if (ret != 0)
+			continue;
+
+		/*
+		 * Convert the standard OID form into an oid string that
+		 * we can use as the key to lookup. Since we only search
+		 * by the prefix (mibcache is really an array of nvlist_t
+		 * pointers), ignore the leaf subid.
+		 */
+		oidstr = oid_to_oidstr(vp->name, vp->name_len - 1);
+		if (oidstr == NULL)
+			continue;
+
+		(void) mutex_lock(&mibcache_lock);
+
+		if (vp->type == ASN_INTEGER) {
+			if (is_vol) {
+				ival_arr[0] = *(vp->val.iptr);
+				(void) nvlist_add_int32_array(mibcache[row],
+				    oidstr, ival_arr, 2);
+			} else {
+				nvlist_add_int32(mibcache[row],
+				    oidstr, *(vp->val.iptr));
+			}
+
+		} else if (vp->type == ASN_OCTET_STR) {
+			if (is_vol) {
+				sval_arr[0] = (char *)vp->val.str;
+				(void) nvlist_add_string_array(mibcache[row],
+				    oidstr, sval_arr, 2);
+			} else {
+				(void) nvlist_add_string(mibcache[row],
+				    oidstr, (const char *)(vp->val.str));
+			}
+		} else if (vp->type == ASN_BIT_STR) {
+			/*
+			 * We don't support yet bit string objects that are
+			 * volatile values.
+			 */
+			if (!is_vol) {
+				(void) nvlist_add_byte_array(mibcache[row],
+				    oidstr, (uchar_t *)(vp->val.str),
+				    (uint_t)vp->val_len);
+			}
+		}
+		(void) mutex_unlock(&mibcache_lock);
+
+		free(oidstr);
+	}
+}
+
+static char *
+oid_to_oidstr(oid *objid, size_t n_subids)
+{
+	char	*oidstr;
+	char	subid_str[MAX_INT_LEN];
+	int	i, isize;
+
+	/*
+	 * ugly, but for now this will have to do.
+	 */
+	oidstr = (char *)calloc(1, MAX_INT_LEN * n_subids);
+
+	for (i = 0; i < n_subids; i++) {
+		(void) memset(subid_str, 0, MAX_INT_LEN);
+		isize = snprintf(subid_str, MAX_INT_LEN, "%d", objid[i]);
+		if (isize >= MAX_INT_LEN)
+			return (NULL);
+
+		(void) strcat(oidstr, subid_str);
+		if (i < (n_subids - 1))
+			(void) strcat(oidstr, ".");
+	}
+
+	return (oidstr);
+}