Add hpm2.h to list of distributed include files

max_inbound_payload_size, max_outbound_payload_size and port are
assembled byte by byte using shifts. This works correctly in both
little and big endian and doing a subsequent byte swap is wrong.

To highlight this issue I dumped the values on a big endian machine:

max_inbound_payload_size 51200
max_outbound_payload_size 51200
port 28418

And after this fix:

max_inbound_payload_size 200
max_outbound_payload_size 200
port 623

Signed-off-by: Zdenek Styblik <stybla@turnovfree.net>

AUTHORS

@@ -2,3 +2,4 @@ Duncan Laurie <duncan@iceblink.org>
 Fredrik Öhrn <ohrn@chl.chalmers.se>
 Jon Cassorla <jon.cassorla@newisys.com>
 Jeremy Ellington <jeremy@jeremye.net>
+Petter Reinholdtsen <pere@hungry.com>

ChangeLog

@@ -1,3 +1,41 @@
+version 1.8.14 2014-03-28
+	* ID: 299 - openipmi plugin writes zero to wrong byte
+	* ID: 301 - Add OS/Hypervisor installation status events
+	* ID: 298 - fix LANplus retry
+	* ID: 295 - inform user if SOL session disconnected
+	* ID: 297 - don't print-out SEL entry if ID not present
+	* ID: 296 - Fix PSD size decoding
+	* ID: 293 - Use of uninitialized variable in ipmi_main()
+	* ID: 278 - Error in sol looptest
+	* ID: 290 - ipmi_sol.c needs a clean-up
+	* ID: 85 - Supermicro memory ECC error display
+	* ID: 290 - ipmi_sol.c needs a clean-up
+	* ID: 286 - Open session retries hit assert in ipmi_lanplus_send_payload
+	* ID: 285 - Fix SEGV in ipmi_lanplus_open_session
+	* ID: 284 - Fix SEGV in ipmi_main
+	* ID: 283 - ipmi_intf_socket_connect fails with IPv4 hosts
+	* ID: 46 -  ipmi_fwum needs some re-work
+	* ID: 50 - ipmi_hpmfwupg needs a clean up
+	* ID: 279 - ipmitool sdr list broken
+	* ID: 44 - dummy interface support - fake-ipmistack project
+	* ID: 48 - Remove hard-coded FRU inventory access length restriction
+	* ID: 276 - HPM.1 upgrade combined patch
+	* ID: 90 - Add options to chassis bootparam set bootflag
+	* ID: 292 -Properly handle plugin non-zero target adddress with -t
+	* Numerous Fixes based on running Coverity
+	* Use TIOCFLUSH if TCFLSH is missing to get the serial plugin building on Hurd.
+	* Disable imb and open plugins by default on Hurd.  The platform lack the required kernel support.
+	* Change serial plugin to only try to disable the IUCLC serial line flag on platforms supporting it.  Fixes build problem on Hurd and FreeBSD.
+	* Add support for enabling/disabling PEF policy entries
+	* PA: 83 -  Revised IPv6 patch
+	* FR: 24 -  Exchange OS Name Hostname BMC URL during startup
+	* Incorect byteswap in SOL maximum payload
+	* Fix build error in HPM.2 code
+	* ID: 300 - new sunoem functionality
+	* ID: 144 - Fix 'dcmi power set_limit action <value>'
+	* ID: 302 - HPM.2 long message support
+	* Add new SEL entries for ipmi 2.0 rev 1.1
+
 version 1.8.13 2013-09-09
 	* ID: 3611905 - Direct Serial Basic/Terminal Mode Interface drivers
 	* ID: 3577766 - configure's knobs and switches don't work

README

@@ -410,3 +410,5 @@ http://www.intel.com/design/servers/ipmi/spec.htm
 OpenIPMI project: Linux IPMI kernel driver and userland library
 http://openipmi.sourceforge.net
 
+IPMItool commit archive
+https://lists.sourceforge.net/lists/listinfo/ipmitool-cvs

configure.in

@@ -3,7 +3,7 @@ dnl autoconf for ipmitool
 dnl
 AC_INIT([src/ipmitool.c])
 AC_CANONICAL_SYSTEM
-AM_INIT_AUTOMAKE([ipmitool], [1.8.13-cvs])
+AM_INIT_AUTOMAKE([ipmitool], [1.8.14-cvs])
 AM_CONFIG_HEADER(config.h)
 AC_CONFIG_SRCDIR([src/ipmitool.c])
 AC_PREREQ(2.50)
@@ -29,7 +29,7 @@ AC_C_BIGENDIAN
 AC_FUNC_MALLOC
 AC_FUNC_SELECT_ARGTYPES
 AC_FUNC_STRTOD
-AC_CHECK_FUNCS([alarm gethostbyname socket select])
+AC_CHECK_FUNCS([alarm gethostbyname getaddrinfo getifaddrs socket select])
 AC_CHECK_FUNCS([memmove memset strchr strdup strerror])
 AC_CHECK_FUNCS([getpassphrase])
 
@@ -39,6 +39,8 @@ AM_PROG_LIBTOOL
 LIBTOOL="$LIBTOOL --silent"
 
 AC_SEARCH_LIBS([gethostbyname], [nsl])
+AC_SEARCH_LIBS([getaddrinfo], [nsl])
+AC_SEARCH_LIBS([getifaddrs], [nsl])
 AC_SEARCH_LIBS([socket], [socket], [],
 	[AC_CHECK_LIB([nsl], [socket],
 		[LIBS="$LIBS -lsocket -lnsl"], [], [-lsocket])])
@@ -60,6 +62,7 @@ xenable_intf_imb=yes
 xenable_intf_open=yes
 xenable_intf_lipmi=yes
 #xenable_intf_serial=yes
+xenable_intf_dummy=no
 xenable_all_options=yes
 xenable_ipmishell=yes
 
@@ -106,6 +109,11 @@ solaris*)
 	xenable_intf_bmc=no
 	xenable_intf_open=no
 	;;
+gnu*)
+	# disable the linux and solaris-specific interfaces on Hurd
+	xenable_intf_imb=no
+	xenable_intf_open=no
+	;;
 esac
 
 AC_SUBST(ARCH, $host_cpu)
@@ -503,6 +511,18 @@ if test "x$xenable_intf_bmc" = "xyes"; then
 	IPMITOOL_INTF_LIB="$IPMITOOL_INTF_LIB bmc/libintf_bmc.la"
 fi
 
+dnl enable Dummy interface for testing
+AC_ARG_ENABLE([intf-dummy],
+	[AC_HELP_STRING([--enable-intf-dummy],
+			[enable Dummy(test) interface [default=no]])],
+	[xenable_intf_dummy=$enableval], [xenable_intf_dummy=no])
+if test "x$xenable_intf_dummy" = "xyes"; then
+	AC_DEFINE(IPMI_INTF_DUMMY, [1], [Define to 1 to enable Dummy interface.])
+	AC_SUBST(INTF_DUMMY, [dummy])
+	AC_SUBST(INTF_DUMMY_LIB, [libintf_dummy.la])
+	IPMITOOL_INTF_LIB="$IPMITOOL_INTF_LIB dummy/libintf_dummy.la"
+fi
+
 AC_SUBST(IPMITOOL_INTF_LIB)
 
 if test "x$xenable_ipmishell" = "xyes"; then
@@ -602,7 +622,8 @@ AC_CONFIG_FILES([Makefile
 		src/plugins/imb/Makefile
 		src/plugins/bmc/Makefile
 		src/plugins/lipmi/Makefile
-		src/plugins/serial/Makefile])
+		src/plugins/serial/Makefile
+		src/plugins/dummy/Makefile])
 
 AC_OUTPUT
 
@@ -618,6 +639,7 @@ AC_MSG_RESULT([  imb     : $xenable_intf_imb])
 AC_MSG_RESULT([  bmc     : $xenable_intf_bmc])
 AC_MSG_RESULT([  lipmi   : $xenable_intf_lipmi])
 AC_MSG_RESULT([  serial  : $xenable_intf_serial])
+AC_MSG_RESULT([  dummy   : $xenable_intf_dummy])
 AC_MSG_RESULT([])
 AC_MSG_RESULT([Extra tools])
 AC_MSG_RESULT([  ipmievd   : yes])

contrib/Makefile.am

@@ -34,6 +34,8 @@ dist_pkgdata_DATA = oem_ibm_sel_map
 
 EXTRA_DIST = README \
 	bmclanconf ipmi.init.basic ipmi.init.redhat \
+	exchange-bmc-os-info.init.redhat exchange-bmc-os-info.service.redhat \
+	exchange-bmc-os-info.sysconf \
 	ipmievd.init.redhat ipmievd.init.suse ipmievd.init.debian \
 	collect_data.sh create_rrds.sh create_webpage_compact.sh create_webpage.sh \
 	bmc-snmp-proxy bmc-snmp-proxy.service bmc-snmp-proxy.sysconf

contrib/exchange-bmc-os-info.init.redhat

@@ -0,0 +1,326 @@
+#!/bin/sh
+#############################################################################
+#
+# exchange-bmc-os-info: Set OS and BMC (Baseboard Management Controller)
+#			 parameters during system startup.
+#
+# version:	0.72
+#
+# Authors:	Charles Rose <charles_rose@dell.com>
+#		Jordan Hargrave <jordan_hargrave@dell.com>
+#
+# Description:  Script to set OS information in the BMC; fetch BMC IP/URL
+#		and set in the OS for use by other scripts/user.
+#
+#		BMC IP and URL are made available in /var/run/bmc-info
+#
+#		Example to launch BMC web-interface:
+#		# . /var/run/bmc-info
+#		# xdg-open $BMC_URL
+#
+#		See here for details:
+#		https://fedoraproject.org/wiki/Features/AgentFreeManagement
+#
+# OEM Specific: OEM specific ipmi commands go in:
+#		'oem_set_os_version' and 'oem_get_bmc_url'
+#############################################################################
+#
+# chkconfig: 345 99 00
+# description: Set OS name, hostname in BMC; make BMC IP/URL available in OS
+# processname: exchange-bmc-os-info
+# config:      /etc/sysconfig/exchange-bmc-os-info
+#
+### BEGIN INIT INFO
+# Provides:          exchange-bmc-os-info
+# Required-Start:    ipmi
+# Default-Start:     3 4 5
+# Default-Stop:      0 1 2 6
+
+
+#############################################################################
+# GLOBALS
+#############################################################################
+CONFIGFILE=/etc/sysconfig/exchange-bmc-os-info
+IPMI_TOOL=/usr/bin/ipmitool
+BMC_INFO=/var/run/bmc-info
+
+# BMC Manufacturer ID used in 'oem_set_os_version' and 'oem_get_bmc_url'
+DELL="674"
+#OTHER_OEM="123"
+
+# Defaults for ${CONFIGFILE}
+SET_OS_INFO="yes"
+RESET_OS_INFO="no"
+SET_BMC_INFO="yes"
+
+# getsysinfo and setsysinfo commands
+IPMI_SET_SYSINFO="${IPMI_TOOL} mc setsysinfo"
+IPMI_GET_SYSINFO="${IPMI_TOOL} mc getsysinfo"
+#############################################################################
+SCRIPT_NAME=$(basename $0)
+
+# source config
+[ -r ${CONFIGFILE} ] && . ${CONFIGFILE}
+
+RETVAL=0
+
+if [ -f /bin/gettext.sh ]; then
+	GETTEXT=1
+	. /bin/gettext.sh
+	OUTPUT="eval_gettext"
+else
+	GETTEXT=0
+	OUTPUT="echo"
+fi
+
+#############################################################################
+# Get Vendor ID of BMC for use in 'oem_set_os_version' and 'oem_get_bmc_url'
+#
+get_bmc_vendor_id()
+{
+	BMC_VENDOR=$(${IPMI_TOOL} mc info 2>/dev/null | \
+		sed -n "s#^Manufacturer ID.*: ##p")
+	[ -z "${BMC_VENDOR}" ] && RETVAL=4
+}
+
+check_ipmitool()
+{
+	if [ -x ${IPMI_TOOL} ]; then
+	# v1.8.12 plus patches are required for set/getsysinfo support
+	# http://sourceforge.net/mailarchive/message.php?msg_id=29647222
+		[ ! ${IPMI_GET_SYSINFO} >/dev/null 2>&1 ] && \
+			RETVAL=3
+	else
+		RETVAL=2
+	fi
+}
+
+bmc_exists()
+{
+	check_ipmitool
+	[ $RETVAL -eq 0 ] && get_bmc_vendor_id
+	return $RETVAL
+}
+#############################################################################
+
+get_os_info()
+{
+	OS_HOSTNAME=$(hostname)
+	KERNEL_VERSION=$(uname -r -m)
+
+	if  [ -e /etc/lsb-release ] ; then
+		. /etc/lsb-release
+		NAME=${DISTRIB_ID}
+		VERSION="${DISTRIB_RELEASE} ${DISTRIB_CODENAME}"
+	fi
+
+	# we prefer systemd's /etc/os-release over other sources
+	[ -e /etc/os-release ] && . /etc/os-release
+
+	OS_NAME=${NAME}
+	OS_VERSION="${VERSION} kernel ${KERNEL_VERSION}"
+}
+
+oem_set_os_version()
+{
+	# OS Version setting is not standard yet
+	# we need per vendor oem commands
+	case "${BMC_VENDOR}" in
+		$DELL) ${IPMI_SET_SYSINFO} delloem_os_version \
+				"${OS_VERSION}" > /dev/null 2>&1
+			return $?
+			;;
+# Add OEM specific commands.
+# Example:
+#		$OTHER_OEM) ${IPMI_SET_SYSINFO} otheroem_os_version \
+#				"${OS_VERSION}" > /dev/null 2>&1
+#			return $?
+#			;;
+		*) 	return 0
+			;;
+	esac
+}
+
+set_os_info()
+{
+	# Set and reset OS info in the BMC
+	if [ "$1" = "reset" ]; then
+		OS_NAME=""
+		OS_HOSTNAME=""
+		OS_VERSION=""
+	fi
+
+	${IPMI_SET_SYSINFO} os_name "${OS_NAME}" >/dev/null 2>&1 \
+		|| RETVAL=6
+	${IPMI_SET_SYSINFO} primary_os_name "${OS_NAME}" >/dev/null 2>&1 \
+		|| RETVAL=6
+	${IPMI_SET_SYSINFO} system_name "${OS_HOSTNAME}" >/dev/null 2>&1 \
+		|| RETVAL=6
+	oem_set_os_version || RETVAL=6
+}
+
+#############################################################################
+valid_url()
+{
+	url="(https?|http)://[a-z0-9-]+(\.[a-z0-9-]+)+([/?].*)?"
+	printf -- "%s" "${TMP_URL}"| grep -Eq "^${url}"
+	return $?
+}
+
+oem_get_bmc_url()
+{
+	# BMC URL is not standard yet
+	# we need per vendor oem commands
+	case "$BMC_VENDOR" in
+		$DELL)	TMP_URL=$(${IPMI_GET_SYSINFO} delloem_url 2> /dev/null)
+				;;
+# Add OEM specific commands
+# Example:
+#		$OTHER_OEM)
+#			TMP_URL=$(${IPMI_GET_SYSINFO} otheroem_url 2> /dev/null)
+#				;;
+		*)  TMP_URL=""	;;
+	esac
+
+	valid_url && BMC_URL=${TMP_URL} || BMC_URL=""
+}
+
+valid_ip()
+{
+	#Thanks to mkyong.com
+	octet="([01]?[[:digit:]][[:digit:]]?|2[0-4][[:digit:]]|25[0-5])"
+
+	printf -- "%s" "${TMP_IPv4}"| grep -Eq "^${octet}\\.${octet}\\.${octet}\\.${octet}$"
+	return $?
+}
+
+get_bmc_ip()
+{
+	#Thanks to http://ingvar.blog.redpill-linpro.com
+	for CHANNEL in `seq 1 14`
+	do
+		[ $(${IPMI_TOOL} lan print ${CHANNEL} 2>/dev/null \
+			| grep -q "^Set") ] || break
+	done
+
+	# Get BMC_IPv4 and BMC_URL from BMC
+	TMP_IPv4=$(${IPMI_TOOL} lan print ${CHANNEL} 2>/dev/null \
+			| sed -n "s#^IP Address  .*: ##p")
+
+	valid_ip && BMC_IPv4=${TMP_IPv4} || BMC_IPv4=""
+}
+
+get_bmc_info()
+{
+	get_bmc_ip
+	if [ -z "${BMC_IPv4}" ] || [ "${BMC_IPv4}" = "0.0.0.0" ]; then
+		BMC_IPv4=""
+		RETVAL=5
+	else
+		# URL makes sense only if there is an IP
+		oem_get_bmc_url
+	fi
+}
+
+set_bmc_info()
+{
+	if [ ! $(touch "${BMC_INFO}" && chmod 600 "${BMC_INFO}") ]; then
+		printf "BMC_IPv4=%s\n" "${BMC_IPv4}" > "${BMC_INFO}"
+		[ -n "${BMC_URL}" ] && \
+			printf "BMC_URL=%s\n" "${BMC_URL}" >> "${BMC_INFO}"
+	else
+		RETVAL=5
+	fi
+}
+
+unset_bmc_info()
+{
+	[ -f ${BMC_INFO} ] && rm -f ${BMC_INFO} > /dev/null 2>&1
+}
+
+#############################################################################
+start()
+{
+	if bmc_exists; then
+		[ "${SET_OS_INFO}" = "yes" ] && \
+			get_os_info && set_os_info
+
+		if [ "${SET_BMC_INFO}" = "yes" ]; then
+			get_bmc_info
+			if [ ${RETVAL} -eq 0 ]; then
+				set_bmc_info
+			fi
+		fi
+	fi
+}
+
+#############################################################################
+stop()
+{
+	if bmc_exists; then
+		# reset OS info while system reboots
+		# aids with debugging OS boot-up issues
+		if [ "${RESET_OS_INFO}" = "yes" ]; then
+			set_os_info reset
+		fi
+		unset_bmc_info
+	fi
+}
+
+#############################################################################
+restart()
+{
+	stop
+	[ $RETVAL -eq 0 ] && start
+}
+
+#############################################################################
+status()
+{
+	[ -r ${BMC_INFO} ] && \
+		grep -q "BMC_IPv4" "${BMC_INFO}" >/dev/null 1>&2 && \
+			BMC_STATUS="ok" || BMC_STATUS="inactive"
+	${OUTPUT} "${SCRIPT_NAME}: ${BMC_STATUS}" 1>&2
+	[ ${GETTEXT} -eq 1 ] && echo
+}
+
+#############################################################################
+usage()
+{
+	${OUTPUT} "Usage: ${SCRIPT_NAME} {start|stop|restart|status}" 1>&2
+	[ ${GETTEXT} -eq 1 ] && echo
+	RETVAL=1
+}
+
+#############################################################################
+# MAIN
+#############################################################################
+case "$1" in
+	start) start ;;
+	stop)  stop ;;
+	restart) restart ;;
+	status)	status ;;
+	*) usage ;;
+esac
+
+case "$RETVAL" in
+	0|1) ;;
+	2) ${OUTPUT} "${SCRIPT_NAME}: ipmitool(1) not found." 1>&2 ;;
+	3) ${OUTPUT} "${SCRIPT_NAME}: this version of ipmitool does not support getsysinfo." 1>&2 ;;
+	4) ${OUTPUT} "${SCRIPT_NAME}: failed to communicate with BMC." 1>&2 ;;
+	5) ${OUTPUT} "${SCRIPT_NAME}: failed to set OS information in BMC." 1>&2 ;;
+	6) ${OUTPUT} "${SCRIPT_NAME}: failed to get BMC information." 1>&2 ;;
+	*) ${OUTPUT} "${SCRIPT_NAME}: unexpected error." 1>&2 ;;
+esac
+
+if [ ${RETVAL} -gt 1 ]; then
+	${OUTPUT} " Return code: ${RETVAL}" 1>&2
+	[ ${GETTEXT} -eq 1 ] && echo
+fi
+
+
+exit ${RETVAL}
+
+#############################################################################
+# end of file
+#############################################################################

contrib/exchange-bmc-os-info.service.redhat

@@ -0,0 +1,13 @@
+[Unit]
+Description=Exchange Information between BMC and OS
+After=ipmi.service network.target
+Requires=ipmi.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/libexec/exchange-bmc-os-info start
+ExecStop=/usr/libexec/exchange-bmc-os-info stop
+
+[Install]
+WantedBy=multi-user.target

contrib/exchange-bmc-os-info.sysconf

@@ -0,0 +1,26 @@
+# exchange-bmc-os-info
+#
+# Config file to control Exchange of information between
+# the OS and Service Processor/Baseboard Management Controller (BMC)
+#
+# See here for details
+#    https://fedoraproject.org/wiki/Features/AgentFreeManagement
+
+### Set OS Info in BMC/Service Processor ###
+# Name: SET_OS_INFO
+# Description: Set OS Name, Version and Hostname in the Service Processor (BMC)
+# Default: yes
+SET_OS_INFO="yes"
+
+### Reset OS Info in BMC/Service Processor ###
+# Name: RESET_OS_INFO
+# Description: Reset OS Name, Version and Hostname in the Service Processor (BMC).
+# 		Useful when the OS Name/Hostname should be empty on reboot
+# Default: no
+RESET_OS_INFO="no"
+
+### Set BMC/Service Processor Info in OS ###
+# Name; SET_BMC_INFO
+# Description: Set IP Address and URL of Service Processor/BMC in /run/bmc-info
+# Default: yes
+SET_BMC_INFO="yes"

doc/ipmitool.1

@@ -2309,14 +2309,16 @@ Get boot parameter. Currently supported values for <\fBparam #\fR> are:
 .br 
 
 .TP 
-\fIset\fP <\fBoption\fR> [\fBvalue ...\fR]
+\fIset\fP <\fBdevice\fR> [<\fIoptions\fP=\fBhelp,...\fR>]
 .br 
 
-Set boot parameter.
+Set boot device parameter used for next boot.  Various options may be used
+to change when the the next boot device is cleared.
+Run \fI"options=help"\fP for a list of available bootparam set device options.
 
 .RS
 .TP 
-Currently supported values for \fB<option>\fR are:
+Currently supported bootparam \fBdevice\fR settings are:
 .TP 
 \fIforce_pxe\fP
 .br 
@@ -2348,6 +2350,37 @@ Force boot from CD/DVD
 
 Force boot into BIOS setup
 
+.RE
+.RS
+.TP 
+Currently supported bootparam \fBoptions\fR settings are associated with BMC Boot Valid Bit Clearing and are as follows:   Any option can be prefixed with "no-" to invert the sense of the operation.
+.TP 
+\fIPEF\fP
+.br 
+
+Clear valid bit on reset/power cycle caused by PEF
+.TP 
+\fItimeout\fP
+.br 
+
+Automatically clear boot flag valid bit if Chassis Control command is
+not received within 60 seconds.
+.TP 
+\fIwatchdog\fP
+.br 
+
+Clear valid bit on reset/power cycle caused by watchdog timeout
+.TP 
+\fIreset\fP
+.br 
+
+Clear valid bit on push button reset / soft-reset
+.TP 
+\fIpower\fP
+.br 
+
+Clear valid bit on power up via power push button or wake event
+
 .RE
 .RE
 .RE

include/ipmitool/Makefile.am

@@ -30,7 +30,7 @@
 
 MAINTAINERCLEANFILES = Makefile.in
 
-noinst_HEADERS = log.h bswap.h helper.h ipmi.h ipmi_cc.h ipmi_intf.h \
+noinst_HEADERS = log.h bswap.h hpm2.h helper.h ipmi.h ipmi_cc.h ipmi_intf.h \
 	ipmi_chassis.h ipmi_entity.h ipmi_fru.h ipmi_hpmfwupg.h ipmi_lanp.h \
 	ipmi_sdr.h ipmi_sel.h ipmi_sol.h ipmi_mc.h ipmi_raw.h \
 	ipmi_channel.h ipmi_sensor.h ipmi_event.h ipmi_session.h \

include/ipmitool/helper.h

@@ -99,6 +99,7 @@ void printbuf(const uint8_t * buf, int len, const char * desc);
 uint8_t ipmi_csum(uint8_t * d, int s);
 FILE * ipmi_open_file(const char * file, int rw);
 void ipmi_start_daemon(struct ipmi_intf *intf);
+uint16_t ipmi_get_oem_id(struct ipmi_intf *intf);
 
 #define ipmi_open_file_read(file)	ipmi_open_file(file, 0)
 #define ipmi_open_file_write(file)	ipmi_open_file(file, 1)

include/ipmitool/hpm2.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2012 Pigeon Point Systems.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Pigeon Point Systems nor the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * PIGEON POINT SYSTEMS ("PPS") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
+ * PPS OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF PPS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <stdint.h>
+#include <ipmitool/ipmi_intf.h>
+
+/* Global HPM.2 defines */
+#define HPM2_REVISION		0x01
+#define HPM3_REVISION		0x01
+#define HPM2_LAN_PARAMS_REV	0x01
+#define HPM2_SOL_PARAMS_REV	0x01
+#define HPM3_LAN_PARAMS_REV	0x01
+
+/* HPM.2 capabilities */
+#define HPM2_CAPS_SOL_EXTENSION		0x01
+#define HPM2_CAPS_PACKET_TRACE		0x02
+#define HPM2_CAPS_EXT_MANAGEMENT	0x04
+#define HPM2_CAPS_VERSION_SENSOR	0x08
+#define HPM2_CAPS_DYNAMIC_SESSIONS	0x10
+
+#if HAVE_PRAGMA_PACK
+# pragma pack(push, 1)
+#endif
+
+/* HPM.2 LAN attach capabilities */
+struct hpm2_lan_attach_capabilities {
+	uint8_t hpm2_revision_id;
+	uint16_t lan_channel_mask;
+	uint8_t hpm2_caps;
+	uint8_t hpm2_lan_params_start;
+	uint8_t hpm2_lan_params_rev;
+	uint8_t hpm2_sol_params_start;
+	uint8_t hpm2_sol_params_rev;
+} ATTRIBUTE_PACKING;
+
+/* HPM.2 LAN channel capabilities */
+struct hpm2_lan_channel_capabilities {
+	uint8_t capabilities;
+	uint8_t attach_type;
+	uint8_t bandwidth_class;
+	uint16_t max_inbound_pld_size;
+	uint16_t max_outbound_pld_size;
+} ATTRIBUTE_PACKING;
+
+#if HAVE_PRAGMA_PACK
+# pragma pack(pop)
+#endif
+
+/* HPM.2 command assignments */
+#define HPM2_GET_LAN_ATTACH_CAPABILITIES	0x3E
+
+extern int hpm2_get_capabilities(struct ipmi_intf * intf,
+		struct hpm2_lan_attach_capabilities * caps);
+extern int hpm2_get_lan_channel_capabilities(struct ipmi_intf * intf,
+		uint8_t hpm2_lan_params_start,
+		struct hpm2_lan_channel_capabilities * caps);
+extern int hpm2_detect_max_payload_size(struct ipmi_intf * intf);

include/ipmitool/ipmi.h

@@ -281,7 +281,8 @@ typedef enum IPMI_OEM {
      IPMI_OEM_KONTRON    = 15000,
      IPMI_OEM_PPS        = 16394,
      IPMI_OEM_AMI        = 20974,
-     IPMI_OEM_NOKIA_SIEMENS_NETWORKS = 28458
+     IPMI_OEM_NOKIA_SIEMENS_NETWORKS = 28458,
+     IPMI_OEM_SUPERMICRO_47488 = 47488
 } IPMI_OEM;
 
 extern const struct valstr completion_code_vals[];

include/ipmitool/ipmi_fru.h

@@ -63,6 +63,8 @@ enum {
 struct fru_info {
 	uint16_t size;
 	uint8_t access:1;
+	uint8_t max_read_size;
+	uint8_t max_write_size;
 };
 
 #ifdef HAVE_PRAGMA_PACK
@@ -70,6 +72,7 @@ struct fru_info {
 #endif
 struct fru_header {
 	uint8_t version;
+	union {
 		struct {
 			uint8_t internal;
 			uint8_t chassis;
@@ -77,6 +80,8 @@ struct fru_header {
 			uint8_t product;
 			uint8_t multi;
 		} offset;
+		uint8_t offsets[5];
+	};
 	uint8_t pad;
 	uint8_t checksum;
 }ATTRIBUTE_PACKING;
@@ -598,6 +603,20 @@ static const char * chassis_type_desc[] __attribute__((unused)) = {
 	    "AdvancedTCA", "Blade", "Blade Enclosure"
 };
 
+typedef struct ipmi_fru_bloc {
+	struct ipmi_fru_bloc * next;
+	uint16_t start;
+	uint16_t size;
+	uint8_t  blocId[32];
+} t_ipmi_fru_bloc;
+
+static const char *section_id[4] = {
+	"Internal Use Section",
+	"Chassis Section",
+	"Board Section",
+	"Product Section"
+};
+
 int ipmi_fru_main(struct ipmi_intf *intf, int argc, char **argv);
 int ipmi_fru_print(struct ipmi_intf *intf, struct sdr_record_fru_locator *fru);
 

include/ipmitool/ipmi_fwum.h

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_KFWUM_H
+# define IPMI_KFWUM_H
+
+#include <inttypes.h>
+#include <ipmitool/ipmi.h>
+
+/* KFWUM Version */
+# define VER_MAJOR        1
+# define VER_MINOR        3
+/* Minimum size (IPMB/IOL/old protocol) */
+# define KFWUM_SMALL_BUFFER     32
+/* Maximum size on KCS interface */
+# define KFWUM_BIG_BUFFER       32
+# define MAX_BUFFER_SIZE          1024*16
+
+/* 3 address + 1 size + 1 checksum + 1 command */
+# define KFWUM_OLD_CMD_OVERHEAD 6
+/* 1 sequence + 1 size + 1 checksum + 1 command */
+# define KFWUM_NEW_CMD_OVERHEAD 4
+# define KFWUM_PAGE_SIZE        256
+
+# define FWUM_SAVE_FIRMWARE_NO_RESPONSE_LIMIT 6
+# define FWUM_MAX_UPLOAD_RETRY 6
+
+# define TRACE_LOG_CHUNK_COUNT 7
+# define TRACE_LOG_CHUNK_SIZE  7
+# define TRACE_LOG_ATT_COUNT   3
+
+# define IN_FIRMWARE_INFO_OFFSET_LOCATION           0x5a0
+# define IN_FIRMWARE_INFO_SIZE                      20
+# define IN_FIRMWARE_INFO_OFFSET_FILE_SIZE          0
+# define IN_FIRMWARE_INFO_OFFSET_CHECKSUM           4
+# define IN_FIRMWARE_INFO_OFFSET_BOARD_ID           6
+# define IN_FIRMWARE_INFO_OFFSET_DEVICE_ID          8
+# define IN_FIRMWARE_INFO_OFFSET_TABLE_VERSION      9
+# define IN_FIRMWARE_INFO_OFFSET_IMPLEMENT_REV      10
+# define IN_FIRMWARE_INFO_OFFSET_VER_MAJOROR      11
+# define IN_FIRMWARE_INFO_OFFSET_VER_MINORSUB     12
+# define IN_FIRMWARE_INFO_OFFSET_SDR_REV            13
+# define IN_FIRMWARE_INFO_OFFSET_IANA0              14
+# define IN_FIRMWARE_INFO_OFFSET_IANA1              15
+# define IN_FIRMWARE_INFO_OFFSET_IANA2              16
+
+# define KWUM_GET_BYTE_AT_OFFSET(pBuffer,os)            pBuffer[os]
+
+int ipmi_fwum_main(struct ipmi_intf *, int, char **);
+
+typedef enum eKFWUM_BoardList
+{
+	KFWUM_BOARD_KONTRON_UNKNOWN = 0,
+	KFWUM_BOARD_KONTRON_5002 = 5002,
+} tKFWUM_BoardList;
+
+typedef struct sKFWUM_BoardInfo
+{
+	tKFWUM_BoardList boardId;
+	IPMI_OEM  iana;
+} tKFWUM_BoardInfo;
+
+typedef enum eKFWUM_DownloadType
+{
+	KFWUM_DOWNLOAD_TYPE_ADDRESS = 0,
+	KFWUM_DOWNLOAD_TYPE_SEQUENCE,
+} tKFWUM_DownloadType;
+
+typedef enum eKFWUM_DownloadBuffferType
+{
+	KFWUM_SMALL_BUFFER_TYPE = 0,
+	KFUMW_BIG_BUFFER_TYPE
+} tKFWUM_DownloadBuffferType;
+
+typedef struct sKFWUM_InFirmwareInfo
+{
+	unsigned long   fileSize;
+	unsigned short  checksum;
+	unsigned short  sumToRemoveFromChecksum;
+	/* Since the checksum is added in the bin
+	 * after the checksum is calculated, we
+	 * need to remove the each byte value.  This
+	 * byte will contain the addition of both bytes
+	 */
+	tKFWUM_BoardList boardId;
+	unsigned char   deviceId;
+	unsigned char   tableVers;
+	unsigned char   implRev;
+	unsigned char   versMajor;
+	unsigned char   versMinor;
+	unsigned char   versSubMinor;
+	unsigned char   sdrRev;
+	IPMI_OEM iana;
+} tKFWUM_InFirmwareInfo;
+
+typedef struct sKFWUM_SaveFirmwareInfo
+{
+	tKFWUM_DownloadType downloadType;
+	unsigned char       bufferSize;
+	unsigned char       overheadSize;
+} tKFWUM_SaveFirmwareInfo;
+
+/* COMMANDS */
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumGetInfoResp {
+	unsigned char protocolRevision;
+	unsigned char controllerDeviceId;
+	struct {
+		unsigned char mode:1;
+		unsigned char seqAdd:1;
+		unsigned char res : 6;
+	} byte;
+	unsigned char firmRev1;
+	unsigned char firmRev2;
+	unsigned char numBank;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumGetStatusResp {
+	unsigned char bankState;
+	unsigned char firmLengthLSB;
+	unsigned char firmLengthMid;
+	unsigned char firmLengthMSB;
+	unsigned char firmRev1;
+	unsigned char firmRev2;
+	unsigned char firmRev3;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumManualRollbackReq {
+	unsigned char type;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumStartFirmwareDownloadReq {
+	unsigned char lengthLSB;
+	unsigned char lengthMid;
+	unsigned char lengthMSB;
+	unsigned char paddingLSB;
+	unsigned char paddingMSB;
+	unsigned char useSequence;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumStartFirmwareDownloadResp {
+	unsigned char bank;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumSaveFirmwareAddressReq
+{
+	unsigned char addressLSB;
+	unsigned char addressMid;
+	unsigned char addressMSB;
+	unsigned char numBytes;
+	unsigned char txBuf[KFWUM_SMALL_BUFFER-KFWUM_OLD_CMD_OVERHEAD];
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumSaveFirmwareSequenceReq
+{
+	unsigned char sequenceNumber;
+	unsigned char txBuf[KFWUM_BIG_BUFFER];
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(1)
+# endif
+struct KfwumFinishFirmwareDownloadReq {
+	unsigned char versionMaj;
+	unsigned char versionMinSub;
+	unsigned char versionSdr;
+	unsigned char reserved;
+} ATTRIBUTE_PACKING;
+# ifdef HAVE_PRAGMA_PACK
+#  pragma pack(0)
+# endif
+
+#endif /* IPMI_KFWUM_H */

include/ipmitool/ipmi_hpmfwupg.h

@@ -0,0 +1,808 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef IPMI_HPMFWUPG_H
+#define IPMI_HPMFWUPG_H
+
+#include <inttypes.h>
+#include <ipmitool/ipmi.h>
+
+int ipmi_hpmfwupg_main(struct ipmi_intf *, int, char **);
+
+/* Agent version */
+#define HPMFWUPG_VERSION_MAJOR    1
+#define HPMFWUPG_VERSION_MINOR    0
+#define HPMFWUPG_VERSION_SUBMINOR 9
+
+/* HPM.1 FIRMWARE UPGRADE COMMANDS (part of PICMG) */
+#define HPMFWUPG_GET_TARGET_UPG_CAPABILITIES 0x2E
+#define HPMFWUPG_GET_COMPONENT_PROPERTIES    0x2F
+#define HPMFWUPG_ABORT_UPGRADE               0x30
+#define HPMFWUPG_INITIATE_UPGRADE_ACTION     0x31
+#define HPMFWUPG_UPLOAD_FIRMWARE_BLOCK       0x32
+#define HPMFWUPG_FINISH_FIRMWARE_UPLOAD      0x33
+#define HPMFWUPG_GET_UPGRADE_STATUS          0x34
+#define HPMFWUPG_ACTIVATE_FIRMWARE           0x35
+#define HPMFWUPG_QUERY_SELFTEST_RESULT       0x36
+#define HPMFWUPG_QUERY_ROLLBACK_STATUS       0x37
+#define HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK    0x38
+
+/*  HPM.1 SPECIFIC COMPLETION CODES */
+#define HPMFWUPG_ROLLBACK_COMPLETED   0x00
+#define HPMFWUPG_COMMAND_IN_PROGRESS  0x80
+#define HPMFWUPG_NOT_SUPPORTED        0x81
+#define HPMFWUPG_SIZE_MISMATCH        0x81
+#define HPMFWUPG_ROLLBACK_FAILURE     0x81
+#define HPMFWUPG_INV_COMP_MASK        0x81
+#define HPMFWUPG__ABORT_FAILURE       0x81
+#define HPMFWUPG_INV_COMP_ID          0x82
+#define HPMFWUPG_INT_CHECKSUM_ERROR   0x82
+#define HPMFWUPG_INV_UPLOAD_MODE      0x82
+#define HPMFWUPG_ROLLBACK_OVERRIDE    0x82
+#define HPMFWUPG_INV_COMP_PROP        0x83
+#define HPMFWUPG_FW_MISMATCH          0x83
+#define HPMFWUPG_ROLLBACK_DENIED      0x83
+
+/*
+ * This error code is used as a temporary PATCH to
+ * the latest Open ipmi driver.  This PATCH
+ * will be removed once a new Open IPMI driver is released.
+ * (Buggy version = 39)
+ */
+#define ENABLE_OPENIPMI_V39_PATCH
+
+#ifdef ENABLE_OPENIPMI_V39_PATCH
+# define RETRY_COUNT_MAX 3
+static int errorCount;
+# define HPMFWUPG_IS_RETRYABLE(error)                                          \
+ ((((error==0x83)||(error==0x82)||(error==0x80)) && (errorCount++<RETRY_COUNT_MAX))?TRUE:FALSE)
+#else
+# define HPMFWUPG_IS_RETRYABLE(error) FALSE
+#endif
+
+/* HPM FIRMWARE UPGRADE GENERAL DEFINITIONS */
+#define HPMFWUPG_PICMG_IDENTIFIER         0
+#define HPMFWUPG_VERSION_SIZE             6
+#define HPMFWUPG_DESC_STRING_LENGTH       12
+#define HPMFWUPG_DEFAULT_INACCESS_TIMEOUT 60 /* sec */
+#define HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT  60 /* sec */
+#define HPMFWUPG_MD5_SIGNATURE_LENGTH     16
+
+/* Component IDs */
+typedef enum eHpmfwupgComponentId {
+	HPMFWUPG_COMPONENT_ID_0 = 0,
+	HPMFWUPG_COMPONENT_ID_1,
+	HPMFWUPG_COMPONENT_ID_2,
+	HPMFWUPG_COMPONENT_ID_3,
+	HPMFWUPG_COMPONENT_ID_4,
+	HPMFWUPG_COMPONENT_ID_5,
+	HPMFWUPG_COMPONENT_ID_6,
+	HPMFWUPG_COMPONENT_ID_7,
+	HPMFWUPG_COMPONENT_ID_MAX
+} tHpmfwupgComponentId;
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgComponentBitMask {
+	union {
+		unsigned char byte;
+		struct {
+#ifdef WORDS_BIGENDIAN
+			unsigned char component7 : 1;
+			unsigned char component6 : 1;
+			unsigned char component5 : 1;
+			unsigned char component4 : 1;
+			unsigned char component3 : 1;
+			unsigned char component2 : 1;
+			unsigned char component1 : 1;
+			unsigned char component0 : 1;
+#else
+			unsigned char component0 : 1;
+			unsigned char component1 : 1;
+			unsigned char component2 : 1;
+			unsigned char component3 : 1;
+			unsigned char component4 : 1;
+			unsigned char component5 : 1;
+			unsigned char component6 : 1;
+			unsigned char component7 : 1;
+#endif
+		} ATTRIBUTE_PACKING bitField;
+	} ATTRIBUTE_PACKING ComponentBits;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+
+static const int HPMFWUPG_SUCCESS = 0;
+static const int HPMFWUPG_ERROR = -1;
+/* Upload firmware specific error codes */
+static const int HPMFWUPG_UPLOAD_BLOCK_LENGTH = 1;
+static const int HPMFWUPG_UPLOAD_RETRY = 2;
+
+
+/* TARGET UPGRADE CAPABILITIES DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesResp {
+	unsigned char picmgId;
+	unsigned char hpmVersion;
+	union {
+		unsigned char byte;
+		struct {
+#if WORDS_BIGENDIAN
+			unsigned char fwUpgUndesirable    : 1;
+			unsigned char autRollbackOverride : 1;
+			unsigned char ipmcDegradedDurinUpg: 1;
+			unsigned char deferActivation     : 1;
+			unsigned char servAffectDuringUpg : 1;
+			unsigned char manualRollback      : 1;
+			unsigned char autRollback         : 1;
+			unsigned char ipmcSelftestCap     : 1;
+#else
+			unsigned char ipmcSelftestCap     : 1;
+			unsigned char autRollback         : 1;
+			unsigned char manualRollback      : 1;
+			unsigned char servAffectDuringUpg : 1;
+			unsigned char deferActivation     : 1;
+			unsigned char ipmcDegradedDurinUpg: 1;
+			unsigned char autRollbackOverride : 1;
+			unsigned char fwUpgUndesirable    : 1;
+#endif
+		} ATTRIBUTE_PACKING bitField;
+	} ATTRIBUTE_PACKING GlobalCapabilities;
+	unsigned char upgradeTimeout;
+	unsigned char selftestTimeout;
+	unsigned char rollbackTimeout;
+	unsigned char inaccessTimeout;
+	struct HpmfwupgComponentBitMask componentsPresent;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetTargetUpgCapabilitiesCtx {
+	struct HpmfwupgGetTargetUpgCapabilitiesReq req;
+	struct HpmfwupgGetTargetUpgCapabilitiesResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* COMPONENT PROPERTIES DEFINITIONS */
+typedef enum eHpmfwupgCompPropertiesSelect {
+	HPMFWUPG_COMP_GEN_PROPERTIES = 0,
+	HPMFWUPG_COMP_CURRENT_VERSION,
+	HPMFWUPG_COMP_DESCRIPTION_STRING,
+	HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION,
+	HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION,
+	HPMFWUPG_COMP_RESERVED,
+	HPMFWUPG_COMP_OEM_PROPERTIES = 192
+} tHpmfwupgCompPropertiesSelect;
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesReq {
+	unsigned char picmgId;
+	unsigned char componentId;
+	unsigned char selector;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetGeneralPropResp {
+	unsigned char picmgId;
+	union {
+		unsigned char byte;
+		struct {
+#if WORDS_BIGENDIAN
+			unsigned char reserved           : 2;
+			unsigned char payloadColdReset   : 1;
+			unsigned char deferredActivation : 1;
+			unsigned char comparisonSupport  : 1;
+			unsigned char preparationSupport : 1;
+			unsigned char rollbackBackup     : 2;
+#else
+			unsigned char rollbackBackup     : 2;
+			unsigned char preparationSupport : 1;
+			unsigned char comparisonSupport  : 1;
+			unsigned char deferredActivation : 1;
+			unsigned char payloadColdReset   : 1;
+			unsigned char reserved           : 2;
+#endif
+		} ATTRIBUTE_PACKING bitfield;
+	} ATTRIBUTE_PACKING GeneralCompProperties;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetCurrentVersionResp {
+	unsigned char picmgId;
+	unsigned char currentVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetDescStringResp {
+	unsigned char picmgId;
+	char descString[HPMFWUPG_DESC_STRING_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetRollbackFwVersionResp {
+	unsigned char picmgId;
+	unsigned char rollbackFwVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetDeferredFwVersionResp {
+	unsigned char picmgId;
+	unsigned char deferredFwVersion[HPMFWUPG_VERSION_SIZE];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* GetComponentProperties - OEM properties (192) */
+#define HPMFWUPG_OEM_LENGTH 4
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetOemProperties {
+	unsigned char picmgId;
+	unsigned char oemRspData[HPMFWUPG_OEM_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesResp {
+	union {
+		struct HpmfwupgGetGeneralPropResp       generalPropResp;
+		struct HpmfwupgGetCurrentVersionResp    currentVersionResp;
+		struct HpmfwupgGetDescStringResp        descStringResp;
+		struct HpmfwupgGetRollbackFwVersionResp rollbackFwVersionResp;
+		struct HpmfwupgGetDeferredFwVersionResp deferredFwVersionResp;
+		struct HpmfwupgGetOemProperties         oemProperties;
+	} ATTRIBUTE_PACKING Response;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetComponentPropertiesCtx {
+	struct HpmfwupgGetComponentPropertiesReq  req;
+	struct HpmfwupgGetComponentPropertiesResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/*  ABORT UPGRADE DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgAbortUpgradeCtx {
+	struct HpmfwupgAbortUpgradeReq  req;
+	struct HpmfwupgAbortUpgradeResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* UPGRADE ACTIONS DEFINITIONS */
+typedef enum eHpmfwupgUpgradeAction {
+	HPMFWUPG_UPGRADE_ACTION_BACKUP = 0,
+	HPMFWUPG_UPGRADE_ACTION_PREPARE,
+	HPMFWUPG_UPGRADE_ACTION_UPGRADE,
+	HPMFWUPG_UPGRADE_ACTION_COMPARE,
+	HPMFWUPG_UPGRADE_ACTION_INVALID = 0xff
+}  tHpmfwupgUpgradeAction;
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionReq {
+	unsigned char picmgId;
+	struct HpmfwupgComponentBitMask componentsMask;
+	unsigned char upgradeAction;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgInitiateUpgradeActionCtx {
+	struct HpmfwupgInitiateUpgradeActionReq  req;
+	struct HpmfwupgInitiateUpgradeActionResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* UPLOAD FIRMWARE BLOCK DEFINITIONS */
+#define HPMFWUPG_SEND_DATA_COUNT_KCS   30
+#define HPMFWUPG_SEND_DATA_COUNT_LAN   25
+#define HPMFWUPG_SEND_DATA_COUNT_IPMB  26
+#define HPMFWUPG_SEND_DATA_COUNT_IPMBL 26
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockReq {
+	unsigned char picmgId;
+	unsigned char blockNumber;
+	unsigned char data[0];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgUploadFirmwareBlockCtx {
+	struct HpmfwupgUploadFirmwareBlockReq * req;
+	struct HpmfwupgUploadFirmwareBlockResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* FINISH FIRMWARE UPLOAD DEFINITIONS */
+#define HPMFWUPG_IMAGE_SIZE_BYTE_COUNT 4
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadReq {
+	unsigned char picmgId;
+	unsigned char componentId;
+	unsigned char imageLength[HPMFWUPG_IMAGE_SIZE_BYTE_COUNT];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgFinishFirmwareUploadCtx {
+	struct HpmfwupgFinishFirmwareUploadReq  req;
+	struct HpmfwupgFinishFirmwareUploadResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* ACTIVATE FW DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareReq {
+	unsigned char picmgId;
+	unsigned char rollback_override;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgActivateFirmwareCtx {
+	struct HpmfwupgActivateFirmwareReq  req;
+	struct HpmfwupgActivateFirmwareResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* GET UPGRADE STATUS DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusResp {
+	unsigned char picmgId;
+	unsigned char cmdInProcess;
+	unsigned char lastCmdCompCode;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgGetUpgradeStatusCtx {
+	struct HpmfwupgGetUpgradeStatusReq  req;
+	struct HpmfwupgGetUpgradeStatusResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* MANUAL FW ROLLBACK DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgManualFirmwareRollbackReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgManualFirmwareRollbackResp {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+struct HpmfwupgManualFirmwareRollbackCtx {
+	struct HpmfwupgManualFirmwareRollbackReq  req;
+	struct HpmfwupgManualFirmwareRollbackResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* QUERY ROLLBACK STATUS DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusResp {
+	unsigned char picmgId;
+	struct HpmfwupgComponentBitMask rollbackComp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgQueryRollbackStatusCtx {
+	struct HpmfwupgQueryRollbackStatusReq  req;
+	struct HpmfwupgQueryRollbackStatusResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* QUERY SELF TEST RESULT DEFINITIONS */
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct  HpmfwupgQuerySelftestResultReq {
+	unsigned char picmgId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct  HpmfwupgQuerySelftestResultResp {
+	unsigned char picmgId;
+	unsigned char result1;
+	unsigned char result2;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgQuerySelftestResultCtx {
+	struct HpmfwupgQuerySelftestResultReq  req;
+	struct HpmfwupgQuerySelftestResultResp resp;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+/* HPM.1 IMAGE DEFINITIONS */
+#define HPMFWUPG_HEADER_SIGNATURE_LENGTH 8
+#define HPMFWUPG_MANUFATURER_ID_LENGTH   3
+#define HPMFWUPG_PRODUCT_ID_LENGTH       2
+#define HPMFWUPG_TIME_LENGTH             4
+#define HPMFWUPG_TIMEOUT_LENGTH          1
+#define HPMFWUPG_COMP_REVISION_LENGTH    2
+#define HPMFWUPG_FIRM_REVISION_LENGTH    6
+#define HPMFWUPG_IMAGE_HEADER_VERSION    0
+#define HPMFWUPG_IMAGE_SIGNATURE "PICMGFWU"
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+struct HpmfwupgImageHeader {
+	char           signature[HPMFWUPG_HEADER_SIGNATURE_LENGTH];
+	unsigned char  formatVersion;
+	unsigned char  deviceId;
+	unsigned char  manId[HPMFWUPG_MANUFATURER_ID_LENGTH];
+	unsigned char  prodId[HPMFWUPG_PRODUCT_ID_LENGTH];
+	unsigned char  time[HPMFWUPG_TIME_LENGTH];
+	union {
+		struct {
+#if WORDS_BIGENDIAN
+			unsigned char imageSelfTest   : 1;
+			unsigned char autRollback     : 1;
+			unsigned char manRollback     : 1;
+			unsigned char servAffected    : 1;
+			unsigned char reserved        : 4;
+#else
+			unsigned char reserved        : 4;
+			unsigned char servAffected    : 1;
+			unsigned char manRollback     : 1;
+			unsigned char autRollback     : 1;
+			unsigned char imageSelfTest   : 1;
+#endif
+		} ATTRIBUTE_PACKING bitField;
+		unsigned char byte;
+	}ATTRIBUTE_PACKING imageCapabilities;
+	struct HpmfwupgComponentBitMask components;
+	unsigned char  selfTestTimeout;
+	unsigned char  rollbackTimeout;
+	unsigned char  inaccessTimeout;
+	unsigned char  compRevision[HPMFWUPG_COMP_REVISION_LENGTH];
+	unsigned char  firmRevision[HPMFWUPG_FIRM_REVISION_LENGTH];
+	unsigned short oemDataLength;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#define HPMFWUPG_DESCRIPTION_LENGTH   21
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgActionRecord {
+	unsigned char  actionType;
+	struct HpmfwupgComponentBitMask components;
+	unsigned char  checksum;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#define HPMFWUPG_FIRMWARE_SIZE_LENGTH 4
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgFirmwareImage {
+	unsigned char version[HPMFWUPG_FIRM_REVISION_LENGTH];
+	char          desc[HPMFWUPG_DESCRIPTION_LENGTH];
+	unsigned char length[HPMFWUPG_FIRMWARE_SIZE_LENGTH];
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(1)
+#endif
+struct HpmfwupgUpgradeCtx {
+	struct HpmfwupgComponentBitMask compUpdateMask;
+	unsigned int   imageSize;
+	unsigned char* pImageData;
+	unsigned char  componentId;
+	struct HpmfwupgGetTargetUpgCapabilitiesResp targetCap;
+	struct HpmfwupgGetGeneralPropResp genCompProp[HPMFWUPG_COMPONENT_ID_MAX];
+	struct ipm_devid_rsp devId;
+} ATTRIBUTE_PACKING;
+#ifdef HAVE_PRAGMA_PACK
+# pragma pack(0)
+#endif
+
+typedef enum eHpmfwupgActionType {
+	HPMFWUPG_ACTION_BACKUP_COMPONENTS = 0,
+	HPMFWUPG_ACTION_PREPARE_COMPONENTS,
+	HPMFWUPG_ACTION_UPLOAD_FIRMWARE,
+	HPMFWUPG_ACTION_RESERVED = 0xFF
+} tHpmfwupgActionType;
+
+/* FUNCTIONS PROTOTYPES */
+#define HPMFWUPG_MAJORMINOR_VERSION_SIZE        2
+
+/* Options added for user to check the version and to view both the FILE and
+ * TARGET Version
+ */
+#define VIEW_MODE                     0x01
+#define DEBUG_MODE                    0x02
+#define FORCE_MODE                    0x04
+#define COMPARE_MODE                  0x08
+
+typedef struct _VERSIONINFO {
+	unsigned char componentId;
+	unsigned char targetMajor;
+	unsigned char targetMinor;
+	unsigned char targetAux[4];
+	unsigned char rollbackMajor;
+	unsigned char rollbackMinor;
+	unsigned char rollbackAux[4];
+	unsigned char deferredMajor;
+	unsigned char deferredMinor;
+	unsigned char deferredAux[4];
+	unsigned char imageMajor;
+	unsigned char imageMinor;
+	unsigned char imageAux[4];
+	unsigned char coldResetRequired;
+	unsigned char rollbackSupported;
+	char descString[HPMFWUPG_DESC_STRING_LENGTH + 1];
+}VERSIONINFO, *PVERSIONINFO;
+
+VERSIONINFO gVersionInfo[HPMFWUPG_COMPONENT_ID_MAX];
+
+#define TARGET_VER (0x01)
+#define ROLLBACK_VER (0x02)
+#define IMAGE_VER (0x04)
+
+#endif /* IPMI_KFWUM_H */

include/ipmitool/ipmi_intf.h

@@ -89,8 +89,9 @@ struct ipmi_session {
 	uint32_t out_seq;
 	uint32_t timeout;
 
-	struct sockaddr_in addr;
+	struct sockaddr_storage addr;
 	socklen_t addrlen;
+	int ai_family; /* Protocol family for socket.  */
 
 	/*
 	 * This struct holds state data specific to IPMI v2 / RMCP+ sessions
@@ -179,7 +180,8 @@ struct ipmi_intf {
 	uint8_t target_channel;
 	uint32_t transit_addr;
 	uint8_t transit_channel;
-	uint8_t channel_buf_size;
+	uint16_t max_request_data_size;
+	uint16_t max_response_data_size;
 
 	uint8_t devnum;
 
@@ -192,6 +194,8 @@ struct ipmi_intf {
 	struct ipmi_rs *(*send_sol)(struct ipmi_intf * intf, struct ipmi_v2_payload * payload);
 	int (*keepalive)(struct ipmi_intf * intf);
 	int (*set_my_addr)(struct ipmi_intf * intf, uint8_t addr);
+	void (*set_max_request_data_size)(struct ipmi_intf * intf, uint16_t size);
+	void (*set_max_response_data_size)(struct ipmi_intf * intf, uint16_t size);
 };
 
 struct ipmi_intf * ipmi_intf_load(char * name);
@@ -211,4 +215,7 @@ void ipmi_intf_session_set_timeout(struct ipmi_intf * intf, uint32_t timeout);
 void ipmi_intf_session_set_retry(struct ipmi_intf * intf, int retry);
 void ipmi_cleanup(struct ipmi_intf * intf);
 
+#if defined(IPMI_INTF_LAN) || defined (IPMI_INTF_LANPLUS)
+int  ipmi_intf_socket_connect(struct ipmi_intf * intf);
+#endif
 #endif /* IPMI_INTF_H */

include/ipmitool/ipmi_sel.h

@@ -107,6 +107,7 @@ struct standard_spec_sel_rec{
 #define	SENSOR_TYPE_OEM_NFATAL_ERROR	0xC2
 #define	SENSOR_TYPE_OEM_FATAL_ERROR	0xC3
 #define SENSOR_TYPE_TXT_CMD_ERROR	0x20
+#define SENSOR_TYPE_SUPERMICRO_OEM 0xD0
 /* End of Macro for DELL Specific */
 #define SEL_OEM_TS_DATA_LEN		6
 #define SEL_OEM_NOTS_DATA_LEN		13
@@ -326,6 +327,8 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x07, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Disabled" },
 	{ 0x07, 0x09, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Terminator presence detected" },
 	{ 0x07, 0x0a, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Throttled" },
+	{ 0x07, 0x0b, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Uncorrectable machine check exception" },
+	{ 0x07, 0x0c, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Correctable machine check error" },
 
 	{ 0x08, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Presence detected" },
 	{ 0x08, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Failure detected" },
@@ -336,7 +339,10 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x08, 0x06, 0x00, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error: Vendor Mismatch" },
 	{ 0x08, 0x06, 0x01, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error: Revision Mismatch" },
 	{ 0x08, 0x06, 0x02, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error: Processor Missing" },
+	{ 0x08, 0x06, 0x03, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error: Power Supply Rating Mismatch" },
+	{ 0x08, 0x06, 0x04, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error: Voltage Rating Mismatch" },
 	{ 0x08, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error" },
+	{ 0x08, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Power Supply Inactive" },
 
 	{ 0x09, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Unit", "Power off/down" },
 	{ 0x09, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Unit", "Power cycle" },
@@ -360,6 +366,7 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x0c, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Configuration Error" },
 	{ 0x0c, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Spare" },
 	{ 0x0c, 0x09, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Throttled" },
+	{ 0x0c, 0x0a, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Critical Overtemperature" },
 
 	{ 0x0d, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Drive Present" },
 	{ 0x0d, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Drive Fault" },
@@ -479,6 +486,7 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x13, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Bus Uncorrectable error" },
 	{ 0x13, 0x09, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Fatal NMI" },
 	{ 0x13, 0x0a, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Bus Fatal Error" },
+	{ 0x13, 0x0b, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Bus Degraded" },
 
 	{ 0x14, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "Power Button pressed" },
 	{ 0x14, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "Sleep Button pressed" },
@@ -491,6 +499,7 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x17, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Add-in Card", NULL },
 	{ 0x18, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Chassis", NULL },
 	{ 0x19, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Chip Set", NULL },
+	{ 0x19, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Chip Set", "Thermal Trip" },
 	{ 0x1a, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Other FRU", NULL },
 
 	{ 0x1b, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Cable/Interconnect", "Connected" },
@@ -520,6 +529,10 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x1f, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "CD-ROM boot completed" },
 	{ 0x1f, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "ROM boot completed" },
 	{ 0x1f, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "boot completed - device not specified" },
+	{ 0x1f, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "Installation started" },
+	{ 0x1f, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "Installation completed" },
+	{ 0x1f, 0x09, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "Installation aborted" },
+	{ 0x1f, 0x0a, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Boot", "Installation failed" },
 
 	{ 0x20, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "Error during system startup" },
 	{ 0x20, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "Run-time critical stop" },
@@ -676,6 +689,56 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x00, 0x00, 0x00, 0x00, NULL, NULL },
 };
 
+static uint16_t supermicro_x9dal[] = {
+		0x0635
+};
+
+static uint16_t supermicro_x9db[] = {
+		0x0733, 0x0722, 0x0703, 0x0721, 0x0716, 0x0637
+};
+
+static uint16_t supermicro_x9sb[] = {
+		0x0651
+};
+
+static uint16_t supermicro_x9[] = {
+		0x0635, 0x0733, 0x0722, 0x0703, 0x0721, 0x0716, 0x0637, 0x0651
+};
+
+static uint16_t supermicro_b8[] = {
+		0x000A, 0x061c, 0x0620, 0x0101, 0x061f, 0x0612, 0x061e
+};
+
+static uint16_t supermicro_h8[] = {
+		0xa111, 0x0408, 0x0811, 0x1411, 0x0911, 0x1211, 0x1011, 0xcd11, 0x1111, 0xbe11, 0xce11, 0xbd11,
+		0xbc11, 0xa911, 0xaa11, 0xbd11, 0xcb11, 0xad11, 0xa811, 0xac11, 0xaf11, 0xa511, 0xa011, 0x1611,
+		0x2511, 0xbf11, 0x1511, 0x2211, 0x2411, 0x1911, 0xab11, 0xd011, 0xae11, 0xca11, 0x0409, 0xa211,
+		0xa311, 0x1311, 0xba11, 0xa711, 0xd111, 0x1711, 0xcf11, 0x2011, 0x1811
+};
+
+static uint16_t supermicro_p8[] = {
+		0x6480, 0x7380, 0x6280, 0x7480, 0x5980
+};
+
+static uint16_t supermicro_x8[] = {
+		0xa880, 0x0403, 0x0100, 0x0601, 0x0001, 0x0404, 0x0606, 0x0608, 0x0632, 0x0400, 0x0401, 0x0006,
+		0x040a, 0xf280, 0x060f, 0x0609, 0x0008, 0x0613, 0x061b, 0x0007, 0x0600, 0x060c, 0x060d, 0x0614,
+		0x060c, 0x0003, 0x040b, 0x0621, 0x0610, 0x0638, 0xf380, 0x060b, 0x040d, 0x0605, 0x062d, 0x060e,
+		0x061a, 0xf580, 0x062e, 0x0009
+};
+
+static uint16_t supermicro_X8[] = {
+		0x000A, 0x061c, 0x0620, 0x0101, 0x061f, 0x0612, 0x061e, 0xa111, 0x0408, 0x0811, 0x1411, 0x0911,
+		0x1211, 0x1011, 0xcd11, 0x1111, 0xbe11, 0xce11, 0xbd11, 0xbc11, 0xa911, 0xaa11, 0xbd11, 0xcb11,
+		0xad11, 0xa811, 0xac11, 0xaf11, 0xa511, 0xa011, 0x1611, 0x2511, 0xbf11, 0x1511, 0x2211, 0x2411,
+		0x1911, 0xab11, 0xd011, 0xae11, 0xca11, 0x0409, 0xa211, 0xa311, 0x1311, 0xba11, 0xa711, 0xd111,
+		0x1711, 0xcf11, 0x2011, 0x1811, 0x6480, 0x7380, 0x6280, 0x7480, 0x5980, 0xa880, 0x0403, 0x0100,
+		0x0601, 0x0001, 0x0404, 0x0606, 0x0608, 0x0632, 0x0400, 0x0401, 0x0006, 0x040a, 0xf280, 0x060f,
+		0x0609, 0x0008, 0x0613, 0x061b, 0x0007, 0x0600, 0x060c, 0x060d, 0x0614, 0x060c, 0x0003, 0x040b,
+		0x0621, 0x0610, 0x0638, 0xf380, 0x060b, 0x040d, 0x0605, 0x062d, 0x060e, 0x061a, 0xf580, 0x062e,
+		0x0009
+};
+
 int ipmi_sel_main(struct ipmi_intf *, int, char **);
 void ipmi_sel_print_std_entry(struct ipmi_intf * intf, struct sel_event_record * evt);
 void ipmi_sel_print_std_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt);

include/ipmitool/ipmi_sunoem.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -44,14 +44,30 @@
 #define IPMI_SUNOEM_SET_SSH_KEY				0x01
 #define IPMI_SUNOEM_DEL_SSH_KEY				0x02
 #define IPMI_SUNOEM_GET_HEALTH_STATUS			0x10
+#define IPMI_SUNOEM_CLI					0x19
 #define IPMI_SUNOEM_SET_FAN_SPEED			0x20
 #define IPMI_SUNOEM_LED_GET				0x21
 #define IPMI_SUNOEM_LED_SET				0x22
+#define IPMI_SUNOEM_ECHO				0x23
+#define IPMI_SUNOEM_VERSION				0x24
+#define IPMI_SUNOEM_NACNAME				0x29
+#define IPMI_SUNOEM_GETVAL				0x2A
+#define IPMI_SUNOEM_SETVAL				0x2C
+#define IPMI_SUNOEM_SENSOR_SET				0x3A
+#define IPMI_SUNOEM_SET_FAN_MODE			0x41
+#define IPMI_SUNOEM_CORE_TUNNEL                         0x44
+
+/*
+ * Error codes of sunoem functions
+ */
+typedef enum {
+	SUNOEM_EC_SUCCESS            = 0,
+	SUNOEM_EC_INVALID_ARG        = 1,
+	SUNOEM_EC_BMC_NOT_RESPONDING = 2,
+	SUNOEM_EC_BMC_CCODE_NONZERO  = 3
+} sunoem_ec_t;
 
 int ipmi_sunoem_main(struct ipmi_intf *, int, char **);
 
-struct ipmi_rs * sunoem_led_get(struct ipmi_intf * intf, struct sdr_record_generic_locator * dev, int ledtype);
-struct ipmi_rs * sunoem_led_set(struct ipmi_intf * intf, struct sdr_record_generic_locator * dev, int ledtype, int ledmode);
-
 #endif /*IPMI_SUNOEM_H*/
 

ipmitool/include/ipmitool/ipmi_fwum.h

@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * Redistribution of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 
- * Redistribution in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind.
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
- * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
- * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
- * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
- * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
- * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
- * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
- * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-
-#ifndef IPMI_KFWUM_H
-#define IPMI_KFWUM_H
-
-#include <inttypes.h>
-#include <ipmitool/ipmi.h>
-
-
-int ipmi_fwum_main(struct ipmi_intf *, int, char **);
-
-#endif /* IPMI_KFWUM_H */

ipmitool/include/ipmitool/ipmi_hpmfwupg.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * Redistribution of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 
- * Redistribution in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind.
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
- * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
- * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
- * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
- * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
- * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
- * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
- * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-
-#ifndef IPMI_HPMFWUPG_H
-#define IPMI_HPMFWUPG_H
-
-#include <inttypes.h>
-#include <ipmitool/ipmi.h>
-
-int ipmi_hpmfwupg_main(struct ipmi_intf *, int, char **);
-
-#endif /* IPMI_KFWUM_H */

ipmitool/lib/ipmi_sunoem.c

@@ -1,859 +0,0 @@
-/*
- * Copyright (c) 2005 Sun Microsystems, Inc.  All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * Redistribution of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 
- * Redistribution in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind.
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
- * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
- * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
- * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
- * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
- * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
- * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
- * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <errno.h>
-#include <unistd.h>
-#include <signal.h>
-#include <ctype.h>
-
-#include <ipmitool/ipmi.h>
-#include <ipmitool/ipmi_intf.h>
-#include <ipmitool/helper.h>
-#include <ipmitool/log.h>
-#include <ipmitool/ipmi_sel.h>
-#include <ipmitool/ipmi_sdr.h>
-#include <ipmitool/ipmi_strings.h>
-#include <ipmitool/ipmi_channel.h>
-#include <ipmitool/ipmi_sunoem.h>
-#include <ipmitool/ipmi_raw.h>
-
-static const struct valstr sunoem_led_type_vals[] = {
-	{ 0, "OK2RM" },
-	{ 1, "SERVICE" },
-	{ 2, "ACT" },
-	{ 3, "LOCATE" },
-	{ 0xFF, NULL },
-};
-
-static const struct valstr sunoem_led_mode_vals[] = {
-	{ 0, "OFF" },
-	{ 1, "ON" },
-	{ 2, "STANDBY" },
-	{ 3, "SLOW" },
-	{ 4, "FAST" },
-	{ 0xFF, NULL },
-};
-static const struct valstr sunoem_led_mode_optvals[] = {
-	{ 0, "STEADY_OFF" },
-	{ 1, "STEADY_ON" },
-	{ 2, "STANDBY_BLINK" },
-	{ 3, "SLOW_BLINK" },
-	{ 4, "FAST_BLINK" },
-	{ 0xFF, NULL },
-};
-
-int is_sbcmd = 0;
-
-static void
-ipmi_sunoem_usage(void)
-{
-	lprintf(LOG_NOTICE, "usage: sunoem <command> [option...]");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   fan speed <0-100>");
-	lprintf(LOG_NOTICE, "      Set system fan speed (PWM duty cycle)");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   sshkey set <userid> <id_rsa.pub>");
-	lprintf(LOG_NOTICE, "      Set ssh key for a userid into authorized_keys,");
-	lprintf(LOG_NOTICE, "      view users with 'user list' command.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   sshkey del <userid>");
-	lprintf(LOG_NOTICE, "      Delete ssh key for userid from authorized_keys,");
-	lprintf(LOG_NOTICE, "      view users with 'user list' command.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   led get <sensorid> [ledtype]");
-	lprintf(LOG_NOTICE,
-			"      Read status of LED found in Generic Device Locator.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   led set <sensorid> <ledmode> [ledtype]");
-	lprintf(LOG_NOTICE,
-			"      Set mode of LED found in Generic Device Locator.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   sbled get <sensorid> [ledtype]");
-	lprintf(LOG_NOTICE,
-			"      Read status of LED found in Generic Device Locator");
-	lprintf(LOG_NOTICE, "      for Sun Blade Modular Systems.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "   sbled set <sensorid> <ledmode> [ledtype]");
-	lprintf(LOG_NOTICE, "      Set mode of LED found in Generic Device Locator");
-	lprintf(LOG_NOTICE, "      for Sun Blade Modular Systems.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE,
-			"      Use 'sdr list generic' command to get list of Generic");
-	lprintf(LOG_NOTICE, "      Devices that are controllable LEDs.");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "      Required SIS LED Mode:");
-	lprintf(LOG_NOTICE, "         OFF          Off");
-	lprintf(LOG_NOTICE, "         ON           Steady On");
-	lprintf(LOG_NOTICE, "         STANDBY      100ms on 2900ms off blink rate");
-	lprintf(LOG_NOTICE, "         SLOW         1HZ blink rate");
-	lprintf(LOG_NOTICE, "         FAST         4HZ blink rate");
-	lprintf(LOG_NOTICE, "");
-	lprintf(LOG_NOTICE, "      Optional SIS LED Type:");
-	lprintf(LOG_NOTICE, "         OK2RM        OK to Remove");
-	lprintf(LOG_NOTICE, "         SERVICE      Service Required");
-	lprintf(LOG_NOTICE, "         ACT          Activity");
-	lprintf(LOG_NOTICE, "         LOCATE       Locate");
-	lprintf(LOG_NOTICE, "");
-}
-
-/* 
- * IPMI Request Data: 1 byte
- *
- * [byte 0]  FanSpeed    Fan speed as percentage
- */
-static int
-ipmi_sunoem_fan_speed(struct ipmi_intf * intf, uint8_t speed)
-{
-	struct ipmi_rs * rsp;
-	struct ipmi_rq req;
-
-	/* 
-	 * sunoem fan speed <percent>
-	 */
-
-	if (speed > 100) {
-		lprintf(LOG_NOTICE, "Invalid fan speed: %d", speed);
-		return -1;
-	}
-
-	req.msg.netfn = IPMI_NETFN_SUNOEM;
-	req.msg.cmd = IPMI_SUNOEM_SET_FAN_SPEED;
-	req.msg.data = &speed;
-	req.msg.data_len = 1;
-		
-	rsp = intf->sendrecv(intf, &req);
-	if (rsp == NULL) {
-		lprintf(LOG_ERR, "Sun OEM Set Fan Speed command failed");
-		return -1;
-	}
-	else if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Sun OEM Set Fan Speed command failed: %s",
-			val2str(rsp->ccode, completion_code_vals));
-		return -1;
-	}
-
-	printf("Set Fan speed to %d%%\n", speed);
-
-	return 0;
-}
-
-static void
-__sdr_list_empty(struct sdr_record_list * head)
-{
-	struct sdr_record_list * e, * f;
-	for (e = head; e != NULL; e = f) {
-		f = e->next;
-		free(e);
-		e = NULL;
-	}
-	head = NULL;
-}
-
-static void
-led_print(const char * name, uint8_t state)
-{
-	if (csv_output)
-		printf("%s,%s\n", name, val2str(state, sunoem_led_mode_vals));
-	else
-		printf("%-16s | %s\n", name, val2str(state, sunoem_led_mode_vals));
-}
-
-struct ipmi_rs *
-sunoem_led_get(struct ipmi_intf * intf,
-		 struct sdr_record_generic_locator * dev,
-		 int ledtype)
-{
-	struct ipmi_rs * rsp;
-	struct ipmi_rq req;
-	uint8_t rqdata[7];
-	int rqdata_len = 5;
-
-	if (dev == NULL)
-		return NULL;
-
-	rqdata[0] = dev->dev_slave_addr;
-	if (ledtype == 0xFF)
-		rqdata[1] = dev->oem;
-	else
-		rqdata[1] = ledtype;
-	rqdata[2] = dev->dev_access_addr;
-	rqdata[3] = dev->oem;
-	if (is_sbcmd) {
-		rqdata[4] = dev->entity.id;
-		rqdata[5] = dev->entity.instance;
-		rqdata[6] = 0;
-		rqdata_len = 7;
-	}
-	else {
-		rqdata[4] = 0;
-	}
-
-	req.msg.netfn = IPMI_NETFN_SUNOEM;
-	req.msg.cmd = IPMI_SUNOEM_LED_GET;
-	req.msg.lun = dev->lun;
-	req.msg.data = rqdata;
-	req.msg.data_len = rqdata_len;
-		
-	rsp = intf->sendrecv(intf, &req);
-	if (rsp == NULL) {
-		lprintf(LOG_ERR, "Sun OEM Get LED command failed");
-		return NULL;
-	}
-	else if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Sun OEM Get LED command failed: %s",
-			val2str(rsp->ccode, completion_code_vals));
-		return NULL;
-	}
-
-	return rsp;
-}
-
-struct ipmi_rs *
-sunoem_led_set(struct ipmi_intf * intf,
-		 struct sdr_record_generic_locator * dev,
-		 int ledtype, int ledmode)
-{
-	struct ipmi_rs * rsp;
-	struct ipmi_rq req;
-	uint8_t rqdata[9];
-	int rqdata_len = 7;
-
-	if (dev == NULL)
-		return NULL;
-
-	rqdata[0] = dev->dev_slave_addr;
-	if (ledtype == 0xFF)
-		rqdata[1] = dev->oem;
-	else
-		rqdata[1] = ledtype;
-	rqdata[2] = dev->dev_access_addr;
-	rqdata[3] = dev->oem;
-	rqdata[4] = ledmode;
-	if (is_sbcmd) {
-		rqdata[5] = dev->entity.id;
-		rqdata[6] = dev->entity.instance;
-		rqdata[7] = 0;
-		rqdata[8] = 0;
-		rqdata_len = 9;
-	}
-	else {
-		rqdata[5] = 0;
-		rqdata[6] = 0;
-	}
-
-	req.msg.netfn = IPMI_NETFN_SUNOEM;
-	req.msg.cmd = IPMI_SUNOEM_LED_SET;
-	req.msg.lun = dev->lun;
-	req.msg.data = rqdata;
-	req.msg.data_len = rqdata_len;
-		
-	rsp = intf->sendrecv(intf, &req);
-	if (rsp == NULL) {
-		lprintf(LOG_ERR, "Sun OEM Set LED command failed");
-		return NULL;
-	}
-	else if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Sun OEM Set LED command failed: %s",
-			val2str(rsp->ccode, completion_code_vals));
-		return NULL;
-	}
-
-	return rsp;
-}
-
-static void
-sunoem_led_get_byentity(struct ipmi_intf * intf, uint8_t entity_id,
-			  uint8_t entity_inst, int ledtype)
-{
-	struct ipmi_rs * rsp;
-	struct sdr_record_list *elist, *e;
-	struct entity_id entity;
-
-	if (entity_id == 0)
-		return;
-
-	/* lookup sdrs with this entity */
-	memset(&entity, 0, sizeof(struct entity_id));
-	entity.id = entity_id;
-	entity.instance = entity_inst;
-
-	elist = ipmi_sdr_find_sdr_byentity(intf, &entity);
-
-	/* for each generic sensor set its led state */
-	for (e = elist; e != NULL; e = e->next) {
-		if (e->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
-			continue;
-		rsp = sunoem_led_get(intf, e->record.genloc, ledtype);
-		if (rsp && rsp->data_len == 1) {
-			led_print((const char *)e->record.genloc->id_string, rsp->data[0]);
-		}
-	}
-
-	__sdr_list_empty(elist);
-}
-
-static void
-sunoem_led_set_byentity(struct ipmi_intf * intf, uint8_t entity_id,
-			  uint8_t entity_inst, int ledtype, int ledmode)
-{
-	struct ipmi_rs * rsp;
-	struct sdr_record_list *elist, *e;
-	struct entity_id entity;
-
-	if (entity_id == 0)
-		return;
-
-	/* lookup sdrs with this entity */
-	memset(&entity, 0, sizeof(struct entity_id));
-	entity.id = entity_id;
-	entity.instance = entity_inst;
-
-	elist = ipmi_sdr_find_sdr_byentity(intf, &entity);
-
-	/* for each generic sensor set its led state */
-	for (e = elist; e != NULL; e = e->next) {
-		if (e->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
-			continue;
-		rsp = sunoem_led_set(intf, e->record.genloc, ledtype, ledmode);
-		if (rsp && rsp->data_len == 0) {
-			led_print((const char *)e->record.genloc->id_string, ledmode);
-		}
-	}
-
-	__sdr_list_empty(elist);
-}
-
-/* 
- * IPMI Request Data: 5 bytes
- *
- * [byte 0]  devAddr     Value from the "Device Slave Address" field in
- *                       LED's Generic Device Locator record in the SDR
- * [byte 1]  led         LED Type: OK2RM, ACT, LOCATE, SERVICE
- * [byte 2]  ctrlrAddr   Controller address; value from the "Device
- *                       Access Address" field, 0x20 if the LED is local
- * [byte 3]  hwInfo      The OEM field from the SDR record
- * [byte 4]  force       1 = directly access the device
- *                       0 = go thru its controller
- *                       Ignored if LED is local
- * 
- * The format below is for Sun Blade Modular systems only
- * [byte 4]  entityID    The entityID field from the SDR record
- * [byte 5]  entityIns   The entityIns field from the SDR record
- * [byte 6]  force       1 = directly access the device
- *                       0 = go thru its controller
- *                       Ignored if LED is local
- */
-static int
-ipmi_sunoem_led_get(struct ipmi_intf * intf,  int argc, char ** argv)
-{
-	struct ipmi_rs * rsp;
-	struct sdr_record_list *sdr;
-	struct sdr_record_list *alist, *a;
-	struct sdr_record_entity_assoc *assoc;
-	int ledtype = 0xFF;
-	int i;
-
-	/* 
-	 * sunoem led/sbled get <id> [type]
-	 */
-
-	if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
-		ipmi_sunoem_usage();
-		return 0;
-	}
-
-	if (argc > 1) {
-		ledtype = str2val(argv[1], sunoem_led_type_vals);
-		if (ledtype == 0xFF) 
-			lprintf(LOG_ERR, "Unknow ledtype, will use data from the SDR oem field");
-	}
-
-	if (strncasecmp(argv[0], "all", 3) == 0) {
-		/* do all generic sensors */
-		alist = ipmi_sdr_find_sdr_bytype(intf,
-				SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR);
-		for (a = alist; a != NULL; a = a->next) {
-			if (a->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
-				continue;
-			if (a->record.genloc->entity.logical)
-				continue;
-			rsp = sunoem_led_get(intf, a->record.genloc, ledtype);
-			if (rsp && rsp->data_len == 1) {
-				led_print((const char *)a->record.genloc->id_string, rsp->data[0]);
-			}
-		}
-		__sdr_list_empty(alist);
-		return 0;
-	}
-
-	/* look up generic device locator record in SDR */
-	sdr = ipmi_sdr_find_sdr_byid(intf, argv[0]);
-
-	if (sdr == NULL) {
-		lprintf(LOG_ERR, "No Sensor Data Record found for %s", argv[0]);
-		return -1;
-	}
-
-	if (sdr->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {
-		lprintf(LOG_ERR, "Invalid SDR type %d", sdr->type);
-		return -1;
-	}
-
-	if (!sdr->record.genloc->entity.logical) {
-		/*
-		 * handle physical entity
-		 */
-		rsp = sunoem_led_get(intf, sdr->record.genloc, ledtype);
-		if (rsp && rsp->data_len == 1) {
-			led_print((const char *)sdr->record.genloc->id_string, rsp->data[0]);
-		}
-		return 0;
-	}
-
-	/* 
-	 * handle logical entity for LED grouping
-	 */
-
-	lprintf(LOG_INFO, "LED %s is logical device", argv[0]);
-
-	/* get entity assoc records */
-	alist = ipmi_sdr_find_sdr_bytype(intf, SDR_RECORD_TYPE_ENTITY_ASSOC);
-	for (a = alist; a != NULL; a = a->next) {
-		if (a->type != SDR_RECORD_TYPE_ENTITY_ASSOC)
-			continue;
-		assoc = a->record.entassoc;
-		if (assoc == NULL)
-			continue;
-
-		/* check that the entity id/instance matches our generic record */
-		if (assoc->entity.id != sdr->record.genloc->entity.id ||
-		    assoc->entity.instance != sdr->record.genloc->entity.instance)
-			continue;
-
-		if (assoc->flags.isrange) {
-			/*
-			 * handle ranged entity associations
-			 *
-			 * the test for non-zero entity id is handled in
-			 * sunoem_led_get_byentity()
-			 */
-
-			/* first range set - id 1 and 2 must be equal */
-			if (assoc->entity_id_1 == assoc->entity_id_2)
-				for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)
-					sunoem_led_get_byentity(intf, assoc->entity_id_1, i, ledtype);
-
-			/* second range set - id 3 and 4 must be equal */
-			if (assoc->entity_id_3 == assoc->entity_id_4)
-				for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)
-					sunoem_led_get_byentity(intf, assoc->entity_id_3, i, ledtype);
-		}
-		else {
-			/*
-			 * handle entity list
-			 */
-			sunoem_led_get_byentity(intf, assoc->entity_id_1,
-						assoc->entity_inst_1, ledtype);
-			sunoem_led_get_byentity(intf, assoc->entity_id_2,
-						assoc->entity_inst_2, ledtype);
-			sunoem_led_get_byentity(intf, assoc->entity_id_3,
-						assoc->entity_inst_3, ledtype);
-			sunoem_led_get_byentity(intf, assoc->entity_id_4,
-						assoc->entity_inst_4, ledtype);
-		}
-	}
-
-	__sdr_list_empty(alist);
-
-	return 0;
-}
-
-/* 
- * IPMI Request Data: 7 bytes
- *
- * [byte 0]  devAddr     Value from the "Device Slave Address" field in
- *                       LED's Generic Device Locator record in the SDR
- * [byte 1]  led         LED Type: OK2RM, ACT, LOCATE, SERVICE
- * [byte 2]  ctrlrAddr   Controller address; value from the "Device
- *                       Access Address" field, 0x20 if the LED is local
- * [byte 3]  hwInfo      The OEM field from the SDR record
- * [byte 4]  mode        LED Mode: OFF, ON, STANDBY, SLOW, FAST
- * [byte 5]  force       TRUE - directly access the device
- *                       FALSE - go thru its controller
- *                       Ignored if LED is local
- * [byte 6]  role        Used by BMC for authorization purposes
- *
- * The format below is for Sun Blade Modular systems only
- * [byte 5]  entityID    The entityID field from the SDR record
- * [byte 6]  entityIns   The entityIns field from the SDR record
- * [byte 7]  force       TRUE - directly access the device
- *                       FALSE - go thru its controller
- *                       Ignored if LED is local
- * [byte 8]  role        Used by BMC for authorization purposes
- *
- *
- * IPMI Response Data: 1 byte
- * 
- * [byte 0]  mode     LED Mode: OFF, ON, STANDBY, SLOW, FAST
- */
-
-static int
-ipmi_sunoem_led_set(struct ipmi_intf * intf,  int argc, char ** argv)
-{
-	struct ipmi_rs * rsp;
-	struct sdr_record_list *sdr;
-	struct sdr_record_list *alist, *a;
-	struct sdr_record_entity_assoc *assoc;
-	int ledmode;
-	int ledtype = 0xFF;
-	int i;
-
-	/* 
-	 * sunoem led/sbled set <id> <mode> [type]
-	 */
-
-	if (argc < 2 || strncmp(argv[0], "help", 4) == 0) {
-		ipmi_sunoem_usage();
-		return 0;
-	}
-
-	ledmode = str2val(argv[1], sunoem_led_mode_vals);
-	if (ledmode == 0xFF) {
-		ledmode = str2val(argv[1], sunoem_led_mode_optvals);
-		if (ledmode == 0xFF) {
-			lprintf(LOG_NOTICE, "Invalid LED Mode: %s", argv[1]);
-			return -1;
-		}
-	}
-
-	if (argc > 3) {
-		ledtype = str2val(argv[2], sunoem_led_type_vals);
-		if (ledtype == 0xFF) 
-			lprintf(LOG_ERR, "Unknow ledtype, will use data from the SDR oem field");
-	}
-
-	if (strncasecmp(argv[0], "all", 3) == 0) {
-		/* do all generic sensors */
-		alist = ipmi_sdr_find_sdr_bytype(intf,
-				SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR);
-		for (a = alist; a != NULL; a = a->next) {
-			if (a->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)
-				continue;
-			if (a->record.genloc->entity.logical)
-				continue;
-			rsp = sunoem_led_set(intf, a->record.genloc, ledtype, ledmode);
-			if (rsp && rsp->ccode == 0) {
-				led_print((const char *)a->record.genloc->id_string, ledmode);
-			}
-		}
-		__sdr_list_empty(alist);
-		return 0;
-	}
-
-	/* look up generic device locator records in SDR */
-	sdr = ipmi_sdr_find_sdr_byid(intf, argv[0]);
-
-	if (sdr == NULL) {
-		lprintf(LOG_ERR, "No Sensor Data Record found for %s",
-			argv[0]);
-		return -1;
-	}
-
-	if (sdr->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {
-		lprintf(LOG_ERR, "Invalid SDR type %d", sdr->type);
-		return -1;
-	}
-
-	if (!sdr->record.genloc->entity.logical) {
-		/*
-		 * handle physical entity
-		 */
-		rsp = sunoem_led_set(intf, sdr->record.genloc, ledtype, ledmode);
-		if (rsp && rsp->ccode == 0) {
-			led_print(argv[0], ledmode);
-		}
-		return 0;
-	}
-
-	/* 
-	 * handle logical entity for LED grouping
-	 */
-
-	lprintf(LOG_INFO, "LED %s is logical device", argv[0]);
-
-	/* get entity assoc records */
-	alist = ipmi_sdr_find_sdr_bytype(intf, SDR_RECORD_TYPE_ENTITY_ASSOC);
-	for (a = alist; a != NULL; a = a->next) {
-		if (a->type != SDR_RECORD_TYPE_ENTITY_ASSOC)
-			continue;
-		assoc = a->record.entassoc;
-		if (assoc == NULL)
-			continue;
-
-		/* check that the entity id/instance matches our generic record */
-		if (assoc->entity.id != sdr->record.genloc->entity.id ||
-		    assoc->entity.instance != sdr->record.genloc->entity.instance)
-			continue;
-
-		if (assoc->flags.isrange) {
-			/*
-			 * handle ranged entity associations
-			 *
-			 * the test for non-zero entity id is handled in
-			 * sunoem_led_get_byentity()
-			 */
-
-			/* first range set - id 1 and 2 must be equal */
-			if (assoc->entity_id_1 == assoc->entity_id_2)
-				for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)
-					sunoem_led_set_byentity(intf, assoc->entity_id_1, i, ledtype,
-							ledmode);
-
-			/* second range set - id 3 and 4 must be equal */
-			if (assoc->entity_id_3 == assoc->entity_id_4)
-				for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)
-					sunoem_led_set_byentity(intf, assoc->entity_id_3, i, ledtype,
-							ledmode);
-		}
-		else {
-			/*
-			 * handle entity list
-			 */
-			sunoem_led_set_byentity(intf, assoc->entity_id_1,
-						assoc->entity_inst_1, ledtype, ledmode);
-			sunoem_led_set_byentity(intf, assoc->entity_id_2,
-						assoc->entity_inst_2, ledtype, ledmode);
-			sunoem_led_set_byentity(intf, assoc->entity_id_3,
-						assoc->entity_inst_3, ledtype, ledmode);
-			sunoem_led_set_byentity(intf, assoc->entity_id_4,
-						assoc->entity_inst_4, ledtype, ledmode);
-		}
-	}
-
-	__sdr_list_empty(alist);
-
-	return 0;
-}
-
-static int
-ipmi_sunoem_sshkey_del(struct ipmi_intf * intf, uint8_t uid)
-{
-	struct ipmi_rs * rsp;
-	struct ipmi_rq req;
-
-	memset(&req, 0, sizeof(struct ipmi_rq));
-	req.msg.netfn = IPMI_NETFN_SUNOEM;
-	req.msg.cmd = IPMI_SUNOEM_DEL_SSH_KEY;
-	req.msg.data = &uid;
-	req.msg.data_len = 1;
-
-	rsp = intf->sendrecv(intf, &req);
-	if (rsp == NULL) {
-		lprintf(LOG_ERR, "Unable to delete ssh key for UID %d", uid);
-		return -1;
-	}
-	else if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Unable to delete ssh key for UID %d: %s", uid,
-			val2str(rsp->ccode, completion_code_vals));
-		return -1;
-	}
-
-	printf("Deleted SSH key for user id %d\n", uid);
-	return 0;
-}
-
-#define SSHKEY_BLOCK_SIZE	64
-static int
-ipmi_sunoem_sshkey_set(struct ipmi_intf * intf, uint8_t uid, char * ifile)
-{
-	struct ipmi_rs * rsp;
-	struct ipmi_rq req;
-	FILE * fp;
-	int count;
-	uint16_t i_size, r, size;
-	uint8_t wbuf[SSHKEY_BLOCK_SIZE + 3];
-
-	if (ifile == NULL) {
-		lprintf(LOG_ERR, "Invalid or misisng input filename");
-		return -1;
-	}
-
-	fp = ipmi_open_file_read(ifile);
-	if (fp == NULL) {
-		lprintf(LOG_ERR, "Unable to open file %s for reading", ifile);
-		return -1;
-	}
-
-	printf("Setting SSH key for user id %d...", uid);
-
-	memset(&req, 0, sizeof(struct ipmi_rq));
-	req.msg.netfn = IPMI_NETFN_SUNOEM;
-	req.msg.cmd = IPMI_SUNOEM_SET_SSH_KEY;
-	req.msg.data = wbuf;
-
-	fseek(fp, 0, SEEK_END);
-	size = ftell(fp);
-	fseek(fp, 0, SEEK_SET);
-
-	for (r = 0; r < size; r += i_size) {
-		i_size = size - r;
-		if (i_size > SSHKEY_BLOCK_SIZE)
-			i_size = SSHKEY_BLOCK_SIZE;
-
-		memset(wbuf, 0, SSHKEY_BLOCK_SIZE);
-		if (-1 == fseek(fp, r, SEEK_SET)) {
-			lprintf(LOG_ERR, "Seek error %s. %s", ifile, strerror(errno));
-			return -1;
-		}
-		count = fread(wbuf+3, 1, i_size, fp);
-		if (count != i_size) {
-			lprintf(LOG_ERR, "Unable to read %d bytes from file %s", i_size, ifile);
-			fclose(fp);
-			return -1;
-		}
-
-		printf(".");
-		fflush(stdout);
-
-		wbuf[0] = uid;
-		if ((r + SSHKEY_BLOCK_SIZE) >= size)
-			wbuf[1] = 0xff;
-		else
-			wbuf[1] = (uint8_t)(r / SSHKEY_BLOCK_SIZE);
-		wbuf[2] = i_size;
-		req.msg.data_len = i_size + 3;
-
-		rsp = intf->sendrecv(intf, &req);
-		if (rsp == NULL) {
-			lprintf(LOG_ERR, "Unable to set ssh key for UID %d", uid);
-			break;
-		}
-	}
-
-	printf("done\n");
-
-	fclose(fp);
-	return 0;
-}
-
-
-int
-ipmi_sunoem_main(struct ipmi_intf * intf, int argc, char ** argv)
-{
-	int rc = (-1);
-
-	if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
-		ipmi_sunoem_usage();
-		return 0;
-	}
-
-	if (strncmp(argv[0], "fan", 3) == 0) {
-		if (argc == 3 && strncmp(argv[1], "speed", 5) == 0) {
-			uint8_t pct = 0;
-			if (str2uchar(argv[2], &pct) != 0 || pct > 100) {
-				lprintf(LOG_ERR, "Fan speed is limited to range <0..100>.");
-				return (-1);
-			}
-			rc = ipmi_sunoem_fan_speed(intf, pct);
-		}
-		else {
-			ipmi_sunoem_usage();
-			return (-1);
-		}
-	}
-	else if ((strncmp(argv[0], "led", 3) == 0)
-			|| (strncmp(argv[0], "sbled", 5) == 0)) {
-		if (argc < 2) {
-			ipmi_sunoem_usage();
-			return (-1);
-		}
-		if (strncmp(argv[0], "sbled", 5) == 0) {
-			is_sbcmd = 1;
-		}
-		if (strncmp(argv[1], "get", 3) == 0) {
-			if (argc < 3) {
-				char * arg[] = { "all" };
-				rc = ipmi_sunoem_led_get(intf, 1, arg);
-			}
-			else {
-				rc = ipmi_sunoem_led_get(intf, argc-2, &(argv[2]));
-			}
-		}
-		else if (strncmp(argv[1], "set", 3) == 0) {
-			if (argc < 4) {
-				ipmi_sunoem_usage();
-				return (-1);
-			}
-			rc = ipmi_sunoem_led_set(intf, argc-2, &(argv[2]));
-		}
-		else {
-			ipmi_sunoem_usage();
-			return (-1);
-		}
-	}
-	else if (strncmp(argv[0], "sshkey", 6) == 0) {
-		uint8_t uid = 0;
-		if (argc < 3) {
-			ipmi_sunoem_usage();
-			return (-1);
-		}
-
-		if (str2uchar(argv[2], &uid) != 0 || uid < 1 || uid > 63) {
-			lprintf(LOG_ERR, "User ID is limited to range <1..63>.");
-			return (-1);
-		}
-
-		if (strncmp(argv[1], "del", 3) == 0) {
-			rc = ipmi_sunoem_sshkey_del(intf, uid);
-		}
-		else if (argc == 4 && strncmp(argv[1], "set", 3) == 0) {
-			rc = ipmi_sunoem_sshkey_set(intf, uid, argv[3]);
-		}
-		else {
-			ipmi_sunoem_usage();
-			return (-1);
-		}
-	}
-	else {
-		ipmi_sunoem_usage();
-		return (-1);
-	}
-
-	return rc;
-}

ipmitool/src/plugins/ipmi_intf.c

@@ -1,317 +0,0 @@
-/*
- * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * Redistribution of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 
- * Redistribution in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind.
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
- * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
- * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
- * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
- * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
- * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
- * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
- * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#if defined(HAVE_CONFIG_H)
-# include <config.h>
-#endif
-#include <ipmitool/ipmi_intf.h>
-#include <ipmitool/ipmi.h>
-#include <ipmitool/ipmi_sdr.h>
-#include <ipmitool/log.h>
-
-#ifdef IPMI_INTF_OPEN
-extern struct ipmi_intf ipmi_open_intf;
-#endif
-#ifdef IPMI_INTF_IMB
-extern struct ipmi_intf ipmi_imb_intf;
-#endif
-#ifdef IPMI_INTF_LIPMI
-extern struct ipmi_intf ipmi_lipmi_intf;
-#endif
-#ifdef IPMI_INTF_BMC
-extern struct ipmi_intf ipmi_bmc_intf;
-#endif
-#ifdef IPMI_INTF_LAN
-extern struct ipmi_intf ipmi_lan_intf;
-#endif
-#ifdef IPMI_INTF_LANPLUS
-extern struct ipmi_intf ipmi_lanplus_intf;
-#endif
-#ifdef IPMI_INTF_FREE
-extern struct ipmi_intf ipmi_free_intf;
-#endif
-#ifdef IPMI_INTF_SERIAL
-extern struct ipmi_intf ipmi_serial_term_intf;
-extern struct ipmi_intf ipmi_serial_bm_intf;
-#endif
-
-struct ipmi_intf * ipmi_intf_table[] = {
-#ifdef IPMI_INTF_OPEN
-	&ipmi_open_intf,
-#endif
-#ifdef IPMI_INTF_IMB
-	&ipmi_imb_intf,
-#endif
-#ifdef IPMI_INTF_LIPMI
-	&ipmi_lipmi_intf,
-#endif
-#ifdef IPMI_INTF_BMC
-	&ipmi_bmc_intf,
-#endif
-#ifdef IPMI_INTF_LAN
-	&ipmi_lan_intf,
-#endif
-#ifdef IPMI_INTF_LANPLUS
-	&ipmi_lanplus_intf,
-#endif
-#ifdef IPMI_INTF_FREE
-	&ipmi_free_intf,
-#endif
-#ifdef IPMI_INTF_SERIAL
-	&ipmi_serial_term_intf,
-	&ipmi_serial_bm_intf,
-#endif
-	NULL
-};
-
-/* ipmi_intf_print  -  Print list of interfaces
- *
- * no meaningful return code
- */
-void ipmi_intf_print(struct ipmi_intf_support * intflist)
-{
-	struct ipmi_intf ** intf;
-	struct ipmi_intf_support * sup;
-	int def = 1;
-	int found;
-
-	lprintf(LOG_NOTICE, "Interfaces:");
-
-	for (intf = ipmi_intf_table; intf && *intf; intf++) {
-
-		if (intflist != NULL) {
-			found = 0;
-			for (sup=intflist; sup->name != NULL; sup++) {
-				if (strncmp(sup->name, (*intf)->name, strlen(sup->name)) == 0 &&
-				    strncmp(sup->name, (*intf)->name, strlen((*intf)->name)) == 0 &&
-				    sup->supported == 1)
-					found = 1;
-			}
-			if (found == 0)
-				continue;
-		}
-
-		lprintf(LOG_NOTICE, "\t%-12s  %s %s",
-			(*intf)->name, (*intf)->desc,
-			def ? "[default]" : "");
-		def = 0;
-	}
-	lprintf(LOG_NOTICE, "");
-}
-
-/* ipmi_intf_load  -  Load an interface from the interface table above
- *                    If no interface name is given return first entry
- *
- * @name:	interface name to try and load
- *
- * returns pointer to inteface structure if found
- * returns NULL on error
- */
-struct ipmi_intf * ipmi_intf_load(char * name)
-{
-	struct ipmi_intf ** intf;
-	struct ipmi_intf * i;
-
-	if (name == NULL) {
-		i = ipmi_intf_table[0];
-		if (i->setup != NULL && (i->setup(i) < 0)) {
-			lprintf(LOG_ERR, "Unable to setup "
-				"interface %s", name);
-			return NULL;
-		}
-		return i;
-	}
-
-	for (intf = ipmi_intf_table;
-	     ((intf != NULL) && (*intf != NULL));
-	     intf++) {
-		i = *intf;
-		if (strncmp(name, i->name, strlen(name)) == 0) {
-			if (i->setup != NULL && (i->setup(i) < 0)) {
-				lprintf(LOG_ERR, "Unable to setup "
-					"interface %s", name);
-				return NULL;
-			}
-			return i;
-		}
-	}
-
-	return NULL;
-}
-
-void
-ipmi_intf_session_set_hostname(struct ipmi_intf * intf, char * hostname)
-{
-	if (intf->session == NULL)
-		return;
-
-	memset(intf->session->hostname, 0, 16);
-
-	if (hostname != NULL) {
-		memcpy(intf->session->hostname, hostname,
-		       __min(strlen(hostname), 64));
-	}
-}
-
-void
-ipmi_intf_session_set_username(struct ipmi_intf * intf, char * username)
-{
-	if (intf->session == NULL)
-		return;
-
-	memset(intf->session->username, 0, 17);
-
-	if (username == NULL)
-		return;
-
-	memcpy(intf->session->username, username, __min(strlen(username), 16));
-}
-
-void
-ipmi_intf_session_set_password(struct ipmi_intf * intf, char * password)
-{
-	if (intf->session == NULL)
-		return;
-
-	memset(intf->session->authcode, 0, IPMI_AUTHCODE_BUFFER_SIZE);
-
-	if (password == NULL) {
-		intf->session->password = 0;
-		return;
-	}
-
-	intf->session->password = 1;
-	memcpy(intf->session->authcode, password,
-	       __min(strlen(password), IPMI_AUTHCODE_BUFFER_SIZE));
-}
-
-void
-ipmi_intf_session_set_privlvl(struct ipmi_intf * intf, uint8_t level)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->privlvl = level;
-}
-
-void
-ipmi_intf_session_set_lookupbit(struct ipmi_intf * intf, uint8_t lookupbit)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->v2_data.lookupbit = lookupbit;
-}
-
-void
-ipmi_intf_session_set_cipher_suite_id(struct ipmi_intf * intf, uint8_t cipher_suite_id)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->cipher_suite_id = cipher_suite_id;
-}
-
-void
-ipmi_intf_session_set_sol_escape_char(struct ipmi_intf * intf, char sol_escape_char)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->sol_escape_char = sol_escape_char;
-}
-
-void
-ipmi_intf_session_set_kgkey(struct ipmi_intf * intf, char * kgkey)
-{
-	if (intf->session == NULL)
-		return;
-
-	memset(intf->session->v2_data.kg, 0, IPMI_KG_BUFFER_SIZE);
-
-	if (kgkey == NULL)
-		return;
-
-	memcpy(intf->session->v2_data.kg, kgkey, 
-	       __min(strlen(kgkey), IPMI_KG_BUFFER_SIZE));
-}
-
-void
-ipmi_intf_session_set_port(struct ipmi_intf * intf, int port)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->port = port;
-}
-
-void
-ipmi_intf_session_set_authtype(struct ipmi_intf * intf, uint8_t authtype)
-{
-	if (intf->session == NULL)
-		return;
-
-	/* clear password field if authtype NONE specified */
-	if (authtype == IPMI_SESSION_AUTHTYPE_NONE) {
-		memset(intf->session->authcode, 0, IPMI_AUTHCODE_BUFFER_SIZE);
-		intf->session->password = 0;
-	}
-
-	intf->session->authtype_set = authtype;
-}
-
-void
-ipmi_intf_session_set_timeout(struct ipmi_intf * intf, uint32_t timeout)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->timeout = timeout;
-}
-
-void
-ipmi_intf_session_set_retry(struct ipmi_intf * intf, int retry)
-{
-	if (intf->session == NULL)
-		return;
-
-	intf->session->retry = retry;
-}
-
-void
-ipmi_cleanup(struct ipmi_intf * intf)
-{
-	ipmi_sdr_list_empty(intf);
-}

lib/Makefile.am

@@ -39,7 +39,7 @@ libipmitool_la_SOURCES	= helper.c ipmi_sdr.c ipmi_sel.c ipmi_sol.c ipmi_pef.c \
 				  ipmi_oem.c ipmi_isol.c ipmi_sunoem.c ipmi_fwum.c ipmi_picmg.c    \
 				  ipmi_main.c ipmi_tsol.c ipmi_firewall.c ipmi_kontronoem.c        \
 				  ipmi_hpmfwupg.c ipmi_sdradd.c ipmi_ekanalyzer.c ipmi_gendev.c    \
-				  ipmi_ime.c ipmi_delloem.c ipmi_dcmi.c \
+				  ipmi_ime.c ipmi_delloem.c ipmi_dcmi.c hpm2.c \
 				  ../src/plugins/lan/md5.c ../src/plugins/lan/md5.h
 
 libipmitool_la_LDFLAGS		= -export-dynamic

lib/dimm_spd.c

@@ -719,7 +719,8 @@ const struct valstr jedec_id5_vals[] = {
 int
 ipmi_spd_print(uint8_t *spd_data, int len)
 {
-	int size;
+	int k = 0;
+	int ii = 0;
 
 	if (len < 92)
 		return -1; /* we need first 91 bytes to do our thing */
@@ -802,8 +803,15 @@ ipmi_spd_print(uint8_t *spd_data, int len)
 	}
 	else
 	{
-		size = spd_data[5] * (spd_data[31] << 2);
+		ii = (spd_data[3] & 0x0f) + (spd_data[4] & 0x0f) - 17;
-		printf(" Memory Size           : %d MB\n", size);
+		k = ((spd_data[5] & 0x7) + 1) * spd_data[17];
+
+		if(ii > 0 && ii <= 12 && k > 0) {
+			printf(" Memory Size           : %d MB\n", ((1 << ii) * k));
+		} else {
+			printf(" Memory Size    INVALID: %d, %d, %d, %d\n", spd_data[3],
+					spd_data[4], spd_data[5], spd_data[17]);
+		}
 		printf(" Voltage Intf          : %s\n",
 		val2str(spd_data[8], spd_voltage_vals));
 		printf(" Error Detect/Cor      : %s\n",

lib/helper.c

@@ -44,6 +44,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <assert.h>
 
 #if HAVE_CONFIG_H
 # include <config.h>
@@ -663,9 +664,10 @@ ipmi_start_daemon(struct ipmi_intf *intf)
 			close(fd);
 	}
 
-	open("/dev/null", O_RDWR);
+	fd = open("/dev/null", O_RDWR);
-	dup(0);
+	assert(0 == fd);
-	dup(0);
+	dup(fd);
+	dup(fd);
 }
 
 /* is_fru_id - wrapper for str-2-int FRU ID conversion. Message is printed
@@ -756,3 +758,32 @@ is_ipmi_user_id(const char *argv_ptr, uint8_t *ipmi_uid_ptr)
 			IPMI_UID_MIN, IPMI_UID_MAX);
 	return (-1);
 }
+
+uint16_t
+ipmi_get_oem_id(struct ipmi_intf *intf)
+{
+	/* Execute a Get Board ID command to determine the board */
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	uint16_t oem_id;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TSOL;
+	req.msg.cmd   = 0x21;
+	req.msg.data_len = 0;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Get Board ID command failed");
+		return 0;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Get Board ID command failed: %#x %s",
+			rsp->ccode, val2str(rsp->ccode, completion_code_vals));
+		return 0;
+	}
+	oem_id = rsp->data[0] | (rsp->data[1] << 8);
+	lprintf(LOG_DEBUG,"Board ID: %x", oem_id);
+
+	return oem_id;
+}

lib/hpm2.c

@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) 2012 Pigeon Point Systems.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Pigeon Point Systems nor the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * PIGEON POINT SYSTEMS ("PPS") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
+ * PPS OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF PPS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <ipmitool/hpm2.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/log.h>
+#include <ipmitool/bswap.h>
+
+#if HAVE_PRAGMA_PACK
+# pragma pack(push, 1)
+#endif
+
+/* HPM.x Get Capabilities request */
+struct hpmx_cmd_get_capabilities_rq {
+	uint8_t picmg_id;
+	uint8_t hpmx_id;
+} ATTRIBUTE_PACKING;
+
+/* HPM.2 Get Capabilities response */
+struct hpm2_cmd_get_capabilities_rp {
+	uint8_t picmg_id;
+	struct hpm2_lan_attach_capabilities caps;
+} ATTRIBUTE_PACKING;
+
+#if HAVE_PRAGMA_PACK
+# pragma pack(pop)
+#endif
+
+/* IPMI Get LAN Configuration Parameters command */
+#define IPMI_LAN_GET_CONFIG	0x02
+
+int hpm2_get_capabilities(struct ipmi_intf * intf,
+		struct hpm2_lan_attach_capabilities * caps)
+{
+	struct ipmi_rq req;
+	struct ipmi_rs * rsp;
+	struct hpmx_cmd_get_capabilities_rq rq;
+
+	/* reset result */
+	memset(caps, 0, sizeof(struct hpm2_lan_attach_capabilities));
+
+	/* prepare request */
+	rq.picmg_id = 0;
+	rq.hpmx_id = 2;
+
+	/* prepare request */
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPM2_GET_LAN_ATTACH_CAPABILITIES;
+	req.msg.data = (uint8_t *)&rq;
+	req.msg.data_len = sizeof(rq);
+
+
+	/* send */
+	rsp = intf->sendrecv(intf, &req);
+
+	if (!rsp) {
+		lprintf(LOG_NOTICE, "Error sending request.");
+		return -1;
+	}
+
+	if (rsp->ccode == 0xC1) {
+		lprintf(LOG_DEBUG, "IPM Controller is not HPM.2 compatible");
+		return rsp->ccode;
+	} else if (rsp->ccode) {
+		lprintf(LOG_NOTICE, "Get HPM.x Capabilities request failed,"
+				" compcode = %x", rsp->ccode);
+		return rsp->ccode;
+	}
+
+	/* check response length */
+	if (rsp->data_len < 2 || rsp->data_len > 10) {
+		lprintf(LOG_NOTICE, "Bad response length, len=%d", rsp->data_len);
+		return -1;
+	}
+
+	/* check HPM.x identifier */
+	if (rsp->data[1] != 2) {
+		lprintf(LOG_NOTICE, "Bad HPM.x ID, id=%d", rsp->data[1]);
+		return rsp->ccode;
+	}
+
+	/*
+	 * this hardly can happen, since completion code is already checked.
+	 * but check for safety
+	 */
+	if (rsp->data_len < 4) {
+		lprintf(LOG_NOTICE, "Bad response length, len=%d", rsp->data_len);
+		return -1;
+	}
+
+	/* copy HPM.2 capabilities */
+	memcpy(caps, rsp->data + 2, rsp->data_len - 2);
+
+#if WORDS_BIGENDIAN
+	/* swap bytes to convert from little-endian format */
+	caps->lan_channel_mask = BSWAP_16(caps->lan_channel_mask);
+#endif
+
+	/* check HPM.2 revision */
+	if (caps->hpm2_revision_id != HPM2_REVISION) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 revision, rev=%d",
+				caps->hpm2_revision_id);
+		return -1;
+	}
+
+	if (!caps->lan_channel_mask) {
+		return -1;
+	}
+
+	/* check response length */
+	if (rsp->data_len < 8) {
+		lprintf(LOG_NOTICE, "Bad response length, len=%d", rsp->data_len);
+		return -1;
+	}
+
+	/* check HPM.2 LAN parameters start */
+	if (caps->hpm2_lan_params_start < 0xC0) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 LAN params start, start=%x",
+				caps->hpm2_lan_params_start);
+		return -1;
+	}
+
+	/* check HPM.2 LAN parameters revision */
+	if (caps->hpm2_lan_params_rev != HPM2_LAN_PARAMS_REV) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 LAN params revision, rev=%d",
+				caps->hpm2_lan_params_rev);
+		return -1;
+	}
+
+	/* check for HPM.2 SOL extension */
+	if (!(caps->hpm2_caps & HPM2_CAPS_SOL_EXTENSION)) {
+		/* no further checks */
+		return 0;
+	}
+
+	/* check response length */
+	if (rsp->data_len < 10) {
+		lprintf(LOG_NOTICE, "Bad response length, len=%d", rsp->data_len);
+		return -1;
+	}
+
+	/* check HPM.2 SOL parameters start */
+	if (caps->hpm2_sol_params_start < 0xC0) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 SOL params start, start=%x",
+				caps->hpm2_sol_params_start);
+		return -1;
+	}
+
+	/* check HPM.2 SOL parameters revision */
+	if (caps->hpm2_sol_params_rev != HPM2_SOL_PARAMS_REV) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 SOL params revision, rev=%d",
+				caps->hpm2_sol_params_rev);
+		return -1;
+	}
+
+	return 0;
+}
+
+int hpm2_get_lan_channel_capabilities(struct ipmi_intf * intf,
+		uint8_t hpm2_lan_params_start,
+		struct hpm2_lan_channel_capabilities * caps)
+{
+	struct ipmi_rq req;
+	struct ipmi_rs * rsp;
+	uint8_t rq[4];
+
+	/* reset result */
+	memset(caps, 0, sizeof(struct hpm2_lan_channel_capabilities));
+
+	/* prepare request */
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TRANSPORT;
+	req.msg.cmd = IPMI_LAN_GET_CONFIG;
+	req.msg.data = (uint8_t *)&rq;
+	req.msg.data_len = sizeof(rq);
+
+	/* prepare request data */
+	rq[0] = 0xE;					/* sending channel */
+	rq[1] = hpm2_lan_params_start;	/* HPM.2 Channel Caps */
+	rq[2] = rq[3] = 0;
+
+	/* send */
+	rsp = intf->sendrecv(intf, &req);
+
+	if (rsp) {
+		lprintf(LOG_NOTICE, "Error sending request");
+		return -1;
+	}
+
+	if (rsp->ccode == 0x80) {
+		lprintf(LOG_DEBUG, "HPM.2 Channel Caps parameter is not supported");
+		return rsp->ccode;
+	} else if (rsp->ccode) {
+		lprintf(LOG_NOTICE, "Get LAN Configuration Parameters request failed,"
+				" compcode = %x", rsp->ccode);
+		return rsp->ccode;
+	}
+
+	/* check response length */
+	if (rsp->data_len != sizeof (struct hpm2_lan_channel_capabilities) + 1) {
+		lprintf(LOG_NOTICE, "Bad response length, len=%d", rsp->data_len);
+		return -1;
+	}
+
+	/* check parameter revision */
+	if (rsp->data[0] != HPM2_LAN_PARAMS_REV) {
+		lprintf(LOG_NOTICE, "Bad HPM.2 LAN parameter revision, rev=%d",
+				rsp->data[0]);
+		return -1;
+	}
+
+	/* copy parameter data */
+	memcpy(caps, &rsp->data[1], sizeof (struct hpm2_lan_channel_capabilities));
+
+#if WORDS_BIGENDIAN
+	/* swap bytes to convert from little-endian format */
+	caps->max_inbound_pld_size = BSWAP_16(caps->max_inbound_pld_size);
+	caps->max_outbound_pld_size = BSWAP_16(caps->max_outbound_pld_size);
+#endif
+
+	return 0;
+}
+
+int hpm2_detect_max_payload_size(struct ipmi_intf * intf)
+{
+	struct hpm2_lan_attach_capabilities attach_caps;
+	struct hpm2_lan_channel_capabilities channel_caps;
+	int err;
+
+	/* query HPM.2 support */
+	err = hpm2_get_capabilities(intf, &attach_caps);
+
+	/* check if HPM.2 is supported */
+	if (err != 0 || !attach_caps.lan_channel_mask) {
+		return err;
+	}
+
+	/* query channel capabilities */
+	err = hpm2_get_lan_channel_capabilities(intf,
+			attach_caps.hpm2_lan_params_start, &channel_caps);
+
+	/* check if succeeded */
+	if (err != 0) {
+		return err;
+	}
+
+	/* update request and response sizes */
+	ipmi_intf_set_max_request_data_size(intf,
+			channel_caps.max_inbound_pld_size - 7);
+	ipmi_intf_set_max_response_data_size(intf,
+			channel_caps.max_outbound_pld_size - 8);
+
+	/* print debug info */
+	lprintf(LOG_DEBUG, "Set maximum request size to %d\n"
+			"Set maximum response size to %d",
+			intf->max_request_data_size, intf->max_response_data_size);
+
+	return 0;
+}

lib/ipmi_chassis.c

@@ -754,6 +754,193 @@ ipmi_chassis_get_bootparam(struct ipmi_intf * intf, char * arg)
 	return 0;
 }
 
+static int
+get_bootparam_options(char *optstring,
+		unsigned char *set_flag, unsigned char *clr_flag)
+{
+	char *token;
+	char *saveptr = NULL;
+	int optionError = 0;
+	*set_flag = 0;
+	*clr_flag = 0;
+	static struct {
+		char *name;
+		unsigned char value;
+		char *desc;
+	} options[] = {
+	{"PEF",          0x10,
+	    "Clear valid bit on reset/power cycle cause by PEF"},
+	{"timeout",      0x08,
+	    "Automatically clear boot flag valid bit on timeout"},
+	{"watchdog",     0x04,
+	    "Clear valid bit on reset/power cycle cause by watchdog"},
+	{"reset",        0x02,
+	    "Clear valid bit on push button reset/soft reset"},
+	{"power", 0x01,
+	    "Clear valid bit on power up via power push button or wake event"},
+
+	{NULL}	/* End marker */
+	}, *op;
+
+	if (strncmp(optstring, "options=", 8) != 0) {
+		lprintf(LOG_ERR, "No options= keyword found \"%s\"", optstring);
+		return -1;
+	}
+	token = strtok_r(optstring + 8, ",", &saveptr);
+	while (token != NULL) {
+		int setbit = 0;
+		if (strcmp(token, "help") == 0) {
+			optionError = 1;
+			break;
+		}
+		if (strncmp(token, "no-", 3) == 0) {
+			setbit = 1;
+			token += 3;
+		}
+		for (op = options; op->name != NULL; ++op) {
+			if (strncmp(token, op->name, strlen(op->name)) == 0) {
+				if (setbit) {
+				    *set_flag |= op->value;
+				} else {
+				    *clr_flag |= op->value;
+				}
+				break;
+			}
+		}
+		if (op->name == NULL) {
+			/* Option not found */
+			optionError = 1;
+			if (setbit) {
+				token -=3;
+			}
+			lprintf(LOG_ERR, "Invalid option: %s", token);
+		}
+		token = strtok_r(NULL, ",", &saveptr);
+	}
+	if (optionError) {
+		lprintf(LOG_NOTICE, " Legal options are:");
+		lprintf(LOG_NOTICE, "  %-8s: print this message", "help");
+		for (op = options; op->name != NULL; ++op) {
+			lprintf(LOG_NOTICE, "  %-8s: %s", op->name, op->desc);
+		}
+		lprintf(LOG_NOTICE, " Any Option may be prepended with no-"
+				    " to invert sense of operation\n");
+		return (-1);
+	}
+	return (0);
+}
+
+static int
+ipmi_chassis_get_bootvalid(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	uint8_t msg_data[3];
+	uint8_t param_id = IPMI_CHASSIS_BOOTPARAM_FLAG_VALID;
+	memset(msg_data, 0, 3);
+
+	msg_data[0] = param_id & 0x7f;
+	msg_data[1] = 0;
+	msg_data[2] = 0;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_CHASSIS;
+	req.msg.cmd = 0x9;
+	req.msg.data = msg_data;
+	req.msg.data_len = 3;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR,
+			"Error Getting Chassis Boot Parameter %d", param_id);
+		return -1;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Get Chassis Boot Parameter %d failed: %s",
+			param_id, val2str(rsp->ccode, completion_code_vals));
+		return -1;
+	}
+
+	if (verbose > 2)
+		printbuf(rsp->data, rsp->data_len, "Boot Option");
+
+	return(rsp->data[2]);
+}
+
+static int
+ipmi_chassis_set_bootvalid(struct ipmi_intf *intf, uint8_t set_flag, uint8_t clr_flag)
+{
+	int bootvalid;
+	uint8_t flags[5];
+	int rc = 0;
+	int use_progress = 1;
+	uint8_t param_id = IPMI_CHASSIS_BOOTPARAM_FLAG_VALID;
+
+	if (use_progress) {
+		/* set set-in-progress flag */
+		memset(flags, 0, 5);
+		flags[0] = 0x01;
+		rc = ipmi_chassis_set_bootparam(intf,
+				IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS, flags, 1);
+		if (rc < 0)
+			use_progress = 0;
+	}
+
+	memset(flags, 0, 5);
+	flags[0] = 0x01;
+	flags[1] = 0x01;
+	rc = ipmi_chassis_set_bootparam(intf, IPMI_CHASSIS_BOOTPARAM_INFO_ACK,
+			flags, 2);
+
+	if (rc < 0) {
+		if (use_progress) {
+			/* set-in-progress = set-complete */
+			memset(flags, 0, 5);
+			ipmi_chassis_set_bootparam(intf,
+					IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS,
+					flags, 1);
+		}
+		return -1;
+	}
+
+	bootvalid = ipmi_chassis_get_bootvalid(intf);
+
+	if (bootvalid < 0) {
+		if (use_progress) {
+			/* set-in-progress = set-complete */
+			memset(flags, 0, 5);
+			ipmi_chassis_set_bootparam(intf,
+					IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS,
+					flags, 1);
+		}
+		return -1;
+	}
+	flags[0] = (bootvalid & ~clr_flag) | set_flag;
+
+	rc = ipmi_chassis_set_bootparam(intf, param_id, flags, 1);
+
+	if (rc == 0) {
+		if (use_progress) {
+			/* set-in-progress = commit-write */
+			memset(flags, 0, 5);
+			flags[0] = 0x02;
+			ipmi_chassis_set_bootparam(intf,
+					IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS,
+					flags, 1);
+		}
+	}
+
+	if (use_progress) {
+		/* set-in-progress = set-complete */
+		memset(flags, 0, 5);
+		ipmi_chassis_set_bootparam(intf,
+				IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS,
+				flags, 1);
+	}
+
+	return rc;
+}
+
 static int
 ipmi_chassis_set_bootdev(struct ipmi_intf * intf, char * arg, uint8_t *iflags)
 {
@@ -946,6 +1133,23 @@ ipmi_power_main(struct ipmi_intf * intf, int argc, char ** argv)
 	return rc;
 }
 
+void
+ipmi_chassis_set_bootflag_help()
+{
+	unsigned char set_flag;
+	unsigned char clr_flag;
+	lprintf(LOG_NOTICE, "bootparam set bootflag <device> [options=...]");
+	lprintf(LOG_NOTICE, " Legal devices are:");
+	lprintf(LOG_NOTICE, "  none        : No override");
+	lprintf(LOG_NOTICE, "  force_pxe   : Force PXE boot");
+	lprintf(LOG_NOTICE, "  force_disk  : Force boot from default Hard-drive");
+	lprintf(LOG_NOTICE, "  force_safe  : Force boot from default Hard-drive, request Safe Mode");
+	lprintf(LOG_NOTICE, "  force_diag  : Force boot from Diagnostic Partition");
+	lprintf(LOG_NOTICE, "  force_cdrom : Force boot from CD/DVD");
+	lprintf(LOG_NOTICE, "  force_bios  : Force boot into BIOS Setup");
+	get_bootparam_options("options=help", &set_flag, &clr_flag);
+}
+
 int
 ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 {
@@ -1036,26 +1240,27 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 	else if (strncmp(argv[0], "bootparam", 9) == 0) {
 		if ((argc < 3) || (strncmp(argv[1], "help", 4) == 0)) {
 			lprintf(LOG_NOTICE, "bootparam get <param #>");
-			lprintf(LOG_NOTICE, "bootparam set bootflag <flag>");
+		    ipmi_chassis_set_bootflag_help();
-			lprintf(LOG_NOTICE, "  force_pxe   : Force PXE boot");
-			lprintf(LOG_NOTICE, "  force_disk  : Force boot from default Hard-drive");
-			lprintf(LOG_NOTICE, "  force_safe  : Force boot from default Hard-drive, request Safe Mode");
-			lprintf(LOG_NOTICE, "  force_diag  : Force boot from Diagnostic Partition");
-			lprintf(LOG_NOTICE, "  force_cdrom : Force boot from CD/DVD");
-			lprintf(LOG_NOTICE, "  force_bios  : Force boot into BIOS Setup");
 		}
 		else {
 			if (strncmp(argv[1], "get", 3) == 0) {
 				rc = ipmi_chassis_get_bootparam(intf, argv[2]);
 			}
 			else if (strncmp(argv[1], "set", 3) == 0) {
-				if (argc < 4) {
+			    unsigned char set_flag=0;
-					lprintf(LOG_NOTICE, "bootparam set <option> [value ...]");
+			    unsigned char clr_flag=0;
+				if (strncmp(argv[2], "help", 4) == 0  ||
+						argc < 4 || (argc >= 4 &&
+							 strncmp(argv[2], "bootflag", 8) != 0)) {
+					ipmi_chassis_set_bootflag_help();
 				} else {
-					if (strncmp(argv[2], "bootflag", 8) == 0)
+					if (argc == 5) {
+						get_bootparam_options(argv[4], &set_flag, &clr_flag);
+					}
 					rc = ipmi_chassis_set_bootdev(intf, argv[3], NULL);
-					else
+					if (argc == 5 && (set_flag != 0 || clr_flag != 0)) {
-						lprintf(LOG_NOTICE, "bootparam set <option> [value ...]");
+						rc = ipmi_chassis_set_bootvalid(intf, set_flag, clr_flag);
+					}
 				}
 			}
 			else
@@ -1166,7 +1371,7 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 				token = strtok_r(NULL, ",", &saveptr);
 			}
 			if (optionError) {
-				lprintf(LOG_NOTICE, "Legal options are:");
+				lprintf(LOG_NOTICE, "Legal options settings are:");
 				lprintf(LOG_NOTICE, "\thelp:\tprint this message");
 				for (op = options; op->name != NULL; ++op) {
 					lprintf(LOG_NOTICE, "\t%s:\t%s", op->name, op->desc);

lib/ipmi_dcmi.c

@@ -187,18 +187,60 @@ const struct dcmi_cmd dcmi_pwrmgmt_vals[] = {
 
 /* set power limit commands */
 const struct dcmi_cmd dcmi_pwrmgmt_set_usage_vals[] = {
-	{ 0x00, "action", "    <sel_logging | power_off>" },
+	{ 0x00, "action", "    <no_action | sel_logging | power_off>" },
 	{ 0x01, "limit", "     <number in Watts>" },
 	{ 0x02, "correction", "<number in milliseconds>" },
 	{ 0x03, "sample", "    <number in seconds>" },
 	{ 0xFF, NULL, NULL }
 };
 
+/* power management/get action commands */
+const struct dcmi_cmd dcmi_pwrmgmt_get_action_vals[] = {
+	{ 0x00, "No Action", ""},
+	{ 0x01, "Hard Power Off & Log Event to SEL", ""},
+
+	{ 0x02, "OEM reserved (02h)", ""},
+	{ 0x03, "OEM reserved (03h)", ""},
+	{ 0x04, "OEM reserved (04h)", ""},
+	{ 0x05, "OEM reserved (05h)", ""},
+	{ 0x06, "OEM reserved (06h)", ""},
+	{ 0x07, "OEM reserved (07h)", ""},
+	{ 0x08, "OEM reserved (08h)", ""},
+	{ 0x09, "OEM reserved (09h)", ""},
+	{ 0x0a, "OEM reserved (0ah)", ""},
+	{ 0x0b, "OEM reserved (0bh)", ""},
+	{ 0x0c, "OEM reserved (0ch)", ""},
+	{ 0x0d, "OEM reserved (0dh)", ""},
+	{ 0x0e, "OEM reserved (0eh)", ""},
+	{ 0x0f, "OEM reserved (0fh)", ""},
+	{ 0x10, "OEM reserved (10h)", ""},
+
+	{ 0x11, "Log Event to SEL", ""},
+	{ 0xFF, NULL, NULL      }
+};
+
 /* power management/set action commands */
 const struct dcmi_cmd dcmi_pwrmgmt_action_vals[] = {
-	{ 0x00, "No Action", "" },
+	{ 0x00, "no_action",   "No Action"},
-	{ 0x01, "Hard Power Off & Log Event to SEL", "" },
+	{ 0x01, "power_off",   "Hard Power Off & Log Event to SEL"},
-	{ 0x11, "Log Event to SEL", ""  },
+	{ 0x11, "sel_logging", "Log Event to SEL"},
+
+	{ 0x02, "oem_02", "OEM reserved (02h)"},
+	{ 0x03, "oem_03", "OEM reserved (03h)"},
+	{ 0x04, "oem_04", "OEM reserved (04h)"},
+	{ 0x05, "oem_05", "OEM reserved (05h)"},
+	{ 0x06, "oem_06", "OEM reserved (06h)"},
+	{ 0x07, "oem_07", "OEM reserved (07h)"},
+	{ 0x08, "oem_08", "OEM reserved (08h)"},
+	{ 0x09, "oem_09", "OEM reserved (09h)"},
+	{ 0x0a, "oem_0a", "OEM reserved (0ah)"},
+	{ 0x0b, "oem_0b", "OEM reserved (0bh)"},
+	{ 0x0c, "oem_0c", "OEM reserved (0ch)"},
+	{ 0x0d, "oem_0d", "OEM reserved (0dh)"},
+	{ 0x0e, "oem_0e", "OEM reserved (0eh)"},
+	{ 0x0f, "oem_0f", "OEM reserved (0fh)"},
+	{ 0x10, "oem_10", "OEM reserved (10h)"},
+
 	{ 0xFF, NULL, NULL      }
 };
 
@@ -481,44 +523,14 @@ ipmi_dcmi_prnt_oobDiscover(struct ipmi_intf * intf)
 	intf->abort = 1;
 	intf->session->sol_data.sequence_number = 1;
 
-	/* open port to BMC */
+	if (ipmi_intf_socket_connect (intf)  == -1) {
-	memset(&s->addr, 0, sizeof(struct sockaddr_in));
+		lprintf(LOG_ERR, "Could not open socket!");
-	s->addr.sin_family = AF_INET;
-	s->addr.sin_port = htons(s->port);
-
-	rc = inet_pton(AF_INET, (const char *)s->hostname, &s->addr.sin_addr);
-	if (rc <= 0) {
-		struct hostent *host = gethostbyname((const char *)s->hostname);
-		if (host == NULL) {
-			lprintf(LOG_ERR, "Address lookup for %s failed",
-			s->hostname);
 		return -1;
 	}
-		if (host->h_addrtype != AF_INET) {
-			lprintf(LOG_ERR,
-					"Address lookup for %s failed. Got %s, expected IPv4 address.",
-					s->hostname,
-					(host->h_addrtype == AF_INET6) ? "IPv6" : "Unknown");
-			return (-1);
-		}
-		s->addr.sin_family = host->h_addrtype;
-		memcpy(&s->addr.sin_addr, host->h_addr, host->h_length);
-	}
 
-	lprintf(LOG_DEBUG, "IPMI LAN host %s port %d",
-			s->hostname, ntohs(s->addr.sin_port));
-
-	intf->fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if (intf->fd < 0) {
-		lperror(LOG_ERR, "Socket failed");
+		lperror(LOG_ERR, "Connect to %s failed",
-		return -1;
+			s->hostname);
-	}
-
-	/* connect to UDP socket so we get async errors */
-	rc = connect(intf->fd, (struct sockaddr *)&s->addr,
-			sizeof(struct sockaddr_in));
-	if (rc < 0) {
-		lperror(LOG_ERR, "Connect failed");
 		intf->close(intf);
 		return -1;
 	}
@@ -1455,7 +1467,7 @@ ipmi_dcmi_pwr_prnt_glimit(struct ipmi_intf * intf)
 			(realCc == 0) ?
 			"Power Limit Active" : "No Active Power Limit");
 	printf("    Exception actions:   %s\n",
-			val2str2(val.action, dcmi_pwrmgmt_action_vals));
+			val2str2(val.action, dcmi_pwrmgmt_get_action_vals));
 	printf("    Power Limit:         %i Watts\n", val.limit);
 	printf("    Correction time:     %i milliseconds\n", val.correction);
 	printf("    Sampling period:     %i seconds\n", val.sample);
@@ -1486,12 +1498,6 @@ ipmi_dcmi_pwr_slimit(struct ipmi_intf * intf, const char * option,
 	uint32_t lvalue = 0;
 	int i;
 
-	if (str2uint(value, &lvalue) != 0) {
-		lprintf(LOG_ERR, "Given %s '%s' is invalid.",
-				option, value);
-		return (-1);
-	}
-
 	rsp = ipmi_dcmi_pwr_glimit(intf); /* get the power limit settings */
 # if 0
 	{
@@ -1529,39 +1535,124 @@ ipmi_dcmi_pwr_slimit(struct ipmi_intf * intf, const char * option,
 	 * sample period in seconds *
 	 * val.sample = *(uint16_t*)(&rsp->data[12]);
 	 */
+	lprintf(LOG_INFO,
+			"DCMI IN  Limit=%d Correction=%d Action=%d Sample=%d\n",
+			val.limit, val.correction, val.action, val.sample);
 	switch (str2val2(option, dcmi_pwrmgmt_set_usage_vals)) {
 	case 0x00:
 		/* action */
 		switch (str2val2(value, dcmi_pwrmgmt_action_vals)) {
+		case 0x00:
+			/* no_action */
+			val.action = 0;
+			break;
 		case 0x01:
 			/* power_off */
 			val.action = 1;
 			break;
+		case 0x02: 
+			/* OEM reserved action */
+			val.action = 0x02;
+			break;
+		case 0x03: 
+			/* OEM reserved action */
+			val.action = 0x03;
+			break;
+		case 0x04:
+			/* OEM reserved action */
+			val.action = 0x04;
+			break;
+		case 0x05:
+			/* OEM reserved action */
+			val.action = 0x05;
+			break;
+		case 0x06:
+			/* OEM reserved action */
+			val.action = 0x06;
+			break;
+		case 0x07:
+			/* OEM reserved action */
+			val.action = 0x07;
+			break;
+		case 0x08:
+			/* OEM reserved action */
+			val.action = 0x08;
+			break;
+		case 0x09:
+			/* OEM reserved action */
+			val.action = 0x09;
+			break;
+		case 0x0a:
+			/* OEM reserved action */
+			val.action = 0x0a;
+			break;
+		case 0x0b:
+			/* OEM reserved action */
+			val.action = 0x0b;
+			break;
+		case 0x0c:
+			/* OEM reserved action */
+			val.action = 0x0c;
+			break;
+		case 0x0d:
+			/* OEM reserved action */
+			val.action = 0x0d;
+			break;
+		case 0x0e:
+			/* OEM reserved action */
+			val.action = 0x0e;
+			break;
+		case 0x0f:
+			/* OEM reserved action */
+			val.action = 0x0f;
+			break;
+		case 0x10:
+			/* OEM reserved action */
+			val.action = 0x10;
+			break;
 		case 0x11:
 			/* sel_logging*/
 			val.action = 0x11;
 			break;
 		case 0xFF:
 			/* error - not a string we knew what to do with */
+			lprintf(LOG_ERR, "Given %s '%s' is invalid.",
+					option, value);
 			return -1;
 		}
 		break;
 	case 0x01:
 		/* limit */
+		if (str2uint(value, &lvalue) != 0) {
+			lprintf(LOG_ERR, "Given %s '%s' is invalid.",
+					option, value);
+			return (-1);
+		}
 		val.limit = *(uint16_t*)(&lvalue);
 		break;
 	case 0x02:
 		/* correction */
+		if (str2uint(value, &lvalue) != 0) {
+			lprintf(LOG_ERR, "Given %s '%s' is invalid.",
+					option, value);
+			return (-1);
+		}
 		val.correction = *(uint32_t*)(&lvalue);
 		break;
 	case 0x03:
 		/* sample */
+		if (str2uint(value, &lvalue) != 0) {
+			lprintf(LOG_ERR, "Given %s '%s' is invalid.",
+					option, value);
+			return (-1);
+		}
 		val.sample = *(uint16_t*)(&lvalue);
 		break;
 	case 0xff:
 		/* no valid options */
 		return -1;
 	}
+	lprintf(LOG_INFO, "DCMI OUT Limit=%d Correction=%d Action=%d Sample=%d\n", val.limit, val.correction, val.action, val.sample);
 
 	msg_data[0] = val.grp_id; /* Group Extension Identification */
 	msg_data[1] = 0x00; /* reserved */
@@ -1726,6 +1817,10 @@ ipmi_dcmi_main(struct ipmi_intf * intf, int argc, char **argv)
 
 				/* action */
 				switch (str2val2(argv[2], dcmi_pwrmgmt_action_vals)) {
+				case 0x00:
+					/* no_action */
+					data[4] = 0x00;
+					break;
 				case 0x01:
 					/* power_off */
 					data[4] = 0x01;
@@ -1736,6 +1831,8 @@ ipmi_dcmi_main(struct ipmi_intf * intf, int argc, char **argv)
 					break;
 				case 0xFF:
 					/* error - not a string we knew what to do with */
+					lprintf(LOG_ERR, "Given Action '%s' is invalid.",
+							argv[2]);
 					return -1;
 				}
 				/* limit */

lib/ipmi_delloem.c

@@ -3232,7 +3232,7 @@ ipmi_get_avgpower_consmpt_history(struct ipmi_intf * intf,
 	if (verbose > 1) {
 		rdata = (void *)pavgpower;
 		printf("Average power consumption history data"
-				"       :%x %x %x %x %x %x %x\n\n",
+				"       :%x %x %x %x %x %x %x %x\n\n",
 				rdata[0], rdata[1], rdata[2], rdata[3],
 				rdata[4], rdata[5], rdata[6], rdata[7]);
 	}
@@ -3281,7 +3281,7 @@ ipmi_get_peakpower_consmpt_history(struct ipmi_intf * intf,
 		rdata = (void *)pstPeakpower;
 		printf("Peak power consmhistory  Data               : "
 				"%x %x %x %x %x %x %x %x %x %x\n   "
-				"%x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
+				"%x %x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
 				rdata[0], rdata[1], rdata[2], rdata[3],
 				rdata[4], rdata[5], rdata[6], rdata[7],
 				rdata[8], rdata[9], rdata[10], rdata[11],
@@ -3633,7 +3633,7 @@ ipmi_set_power_cap(struct ipmi_intf * intf, int unit, int val)
 	}
 	if (verbose > 1) {
 		rdata = (void *)&ipmipowercap;
-		printf("power cap  Data               :%x %x %x %x %x %x %x %x %x %x ",
+		printf("power cap  Data               :%x %x %x %x %x %x %x %x %x %x %x ",
 				rdata[1], rdata[2], rdata[3],
 				rdata[4], rdata[5], rdata[6], rdata[7],
 				rdata[8], rdata[9], rdata[10],rdata[11]);