This commit was manufactured by cvs2svn to create tag 'IPMITOOL_1_8_5'.

update version
update email address to remove sun.com
2025-07-01 02:03:50 +00:00 · 2006-01-15 20:46:14 +00:00 · 2006-01-15 20:46:13 +00:00 · 2006-01-15 20:46:00 +00:00 · 2006-01-15 20:39:26 +00:00 · 2006-01-15 20:25:23 +00:00
74 changed files with 15046 additions and 3178 deletions
--- a/ipmitool/ChangeLog
+++ b/ipmitool/ChangeLog
@ -1,3 +1,32 @@
+version 1.8.3
+	* Add support for 'sel readraw' and 'sel writeraw' commands.
+	* Add support for entering NetFn as a string for RAW commands.
+	* Add support for appending distro tag to integrated RPM builds.
+	* Fix LAN parameter printing to handle Invalid Data Field response
+	without errors.
+	* Add 5ms delay to IPMIv2 SOL retry packets
+	* IPMIv2 interface will now correctly set session privilege level
+	to requested level after session is opened.
+
+version 1.8.2 (released May 18 2005)
+	* Fix FRU reading for large (>255 bytes) areas.
+	* Overhaul to ipmievd to support SEL polling in addition to OpenIPMI.
+	* Fix LAN parameter segfault when no Ciphers supported by BMC.
+	* Fix IPMIv2 support on Intel v2 BMCs (use -o intelplus).
+	* Separate option parsing code from main ipmitool source file.
+	* Add raw I2C support with IPMI Master Read-Write command.
+	* Add support for new 'sdr elist' extended output format.
+	* Add support for listing sensors by type with 'sdr type' command.
+	* Add support for new 'sel elist' extended output format that
+	  cross-references events with sensors.
+	* Add support for sending dynamically generated platform events
+	  based on existing sensor information.
+	* New '-S' argument to read local SDR cache created with 'sdr dump'.
+	* Updated manpage for ipmitool and ipmievd.
+
+version 1.8.1
+	* ipmievd installs in /usr/sbin
+
 version 1.8.0
 	* Fix IPMIv2.0 issues
 	* Fix chassis boot parameter support
--- a/ipmitool/configure.in
+++ b/ipmitool/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.0])
+AM_INIT_AUTOMAKE([ipmitool], [1.8.5])
 AM_CONFIG_HEADER(config.h)
 AC_CONFIG_SRCDIR([src/ipmitool.c])
 AC_PREREQ(2.50)
@ -18,7 +18,7 @@ AC_CHECK_PROG([RPMBUILD], [rpmbuild], [rpmbuild], [rpm])
 AC_CHECK_PROG([SED], [sed], [sed])

 AC_HEADER_STDC
-AC_CHECK_HEADERS([stdlib.h string.h sys/ioctl.h sys/stat.h unistd.h])
+AC_CHECK_HEADERS([stdlib.h string.h sys/ioctl.h sys/stat.h unistd.h paths.h termios.h])
 AC_CHECK_HEADERS([arpa/inet.h fcntl.h netdb.h netinet/in.h sys/socket.h])
 AC_CHECK_HEADERS([sys/byteorder.h byteswap.h])

@ -51,6 +51,8 @@ if test "x$exec_prefix" = "xNONE"; then
  exec_prefix="$prefix"
 fi

+enable_all_options=yes
+
 dnl set some things so we build with GNU tools on Solaris
 case "$host_os" in
 solaris*)
@ -69,8 +71,9 @@ solaris*)
 	fi
 	enable_intf_imb=no
 	enable_intf_open=no
-	enable_ipmievd=no
+	enable_intf_lipmi=no
 	enable_ipmishell=no
+	enable_all_options=no
 	;;
 *cygwin*)
 	# disable the linux and solaris-specific interfaces
@ -78,7 +81,6 @@ solaris*)
 	enable_intf_open=no
 	enable_intf_lipmi=no
 	enable_intf_bmc=no
-	enable_ipmievd=no
 	enable_ipmishell=no
 	;;
 *darwin*)
@ -87,7 +89,6 @@ solaris*)
 	enable_intf_open=no
 	enable_intf_lipmi=no
 	enable_intf_bmc=no
-	enable_ipmived=no
 	enable_ipmishell=no
 	;;
 esac
@ -97,6 +98,15 @@ AC_SUBST(OS, $host_os)
 AC_SUBST(PSTAMP, $host)
 AC_SUBST(BASEDIR, $prefix)

+dnl allow solaris builds to include all options
+AC_ARG_ENABLE([solaris-opt],
+	[AC_HELP_STRING([--enable-solaris-opt],
+			[enable all options for Solaris [default=no]])],
+	[], [enable_solaris_opt=no])
+if test "x$enable_all_options" = "xyes" || test "x$enable_solaris_opt" = "xyes"; then
+   AC_DEFINE(ENABLE_ALL_OPTIONS, [1], [Define to 1 to enable all command line options.])
+fi
+
 dnl check for OpenSSL functionality
 AC_ARG_ENABLE([internal-md5],
 	[AC_HELP_STRING([--enable-internal-md5],
@ -184,6 +194,12 @@ AC_CHECK_HEADER([linux/ipmi.h],
 	[Define to 1 if you have the <linux/ipmi.h> header file.])],
 	[echo "** Unable to find OpenIPMI header files.  Using internal version."])

+dnl set RPM distro tag for use in RPM name
+AC_ARG_WITH([rpm-distro],
+	[AC_HELP_STRING([--with-rpm-distro=DISTRO],
+			[set Linux distribution tag for use in RPM version string])],
+	[AC_SUBST(DISTRO, $with_rpm_distro)])
+
 dnl enable Linux OpenIPMI interface
 AC_ARG_ENABLE([intf-open],
 	[AC_HELP_STRING([--enable-intf-open],
@ -257,29 +273,20 @@ AC_ARG_ENABLE([ipmishell],
 			[enable IPMI shell interface [default=yes]])],
 	[], [enable_ipmishell=yes])
 if test "x$enable_ipmishell" = "xyes"; then
-	AC_SEARCH_LIBS([readline], [readline], [have_readline=yes])
+	AC_SEARCH_LIBS([tgetent], [readline ncurses curses termcap])
 	AC_SEARCH_LIBS([initscr], [curses ncurses], [have_curses=yes])
+	AC_SEARCH_LIBS([readline], [readline edit], [have_readline=yes])
 	if test "x$have_curses" = "xyes" && test "x$have_readline" = "xyes"; then
 		AC_DEFINE(HAVE_READLINE, [1], [Define to 1 if readline present.])
 	fi
 fi

-dnl enable IPMI Event Daemon
-AC_ARG_ENABLE([ipmievd],
-	[AC_HELP_STRING([--enable-ipmievd],
-			[enable IPMI Event daemon [default=auto]])],
-	[], [enable_ipmievd=yes])
-AM_CONDITIONAL(IPMIEVD, [test "x$enable_ipmievd" = "xyes"])
-if test "x$enable_ipmievd" = "xyes"; then
-    AC_SUBST(IPMIEVD_BIN, [ipmievd])
-fi
-
 dnl Enable -Wall -Werror
 AC_ARG_ENABLE([buildcheck],
 	[AC_HELP_STRING([--enable-buildcheck],
 			[enable -Wall -Werror for build testing [default=no]])],
 	[if test "x$enable_buildcheck" != "xno"; then
-	    CFLAGS="$CFLAGS -Wall -Werror"
+	    CFLAGS="$CFLAGS -Wall -Werror -Wpointer-arith -Wstrict-prototypes"
 	fi], [])

 AC_SUBST(CFLAGS)
@ -291,6 +298,7 @@ AC_CONFIG_FILES([Makefile
 		control/Makefile
 		control/pkginfo
 		control/prototype
+		control/rpmmacros
 		control/ipmitool.spec
 		lib/Makefile
 		include/Makefile
@ -318,6 +326,6 @@ AC_MSG_RESULT([  bmc     : $enable_intf_bmc])
 AC_MSG_RESULT([  lipmi   : $enable_intf_lipmi])
 AC_MSG_RESULT([])
 AC_MSG_RESULT([Extra tools])
-AC_MSG_RESULT([  ipmievd : $enable_ipmievd])
+AC_MSG_RESULT([  ipmievd : yes])
 AC_MSG_RESULT([])

--- a/ipmitool/contrib/Makefile.am
+++ b/ipmitool/contrib/Makefile.am
@ -34,7 +34,8 @@

 MAINTAINERCLEANFILES	= Makefile.in

-dist_pkgdata_DATA	= bmclanconf README \
-	ipmi.init.basic ipmi.init.redhat \
+dist_pkgdata_DATA	= README
+
+dist_pkgdata_SCRIPTS	= bmclanconf ipmi.init.basic ipmi.init.redhat \
 	collect_data.sh create_rrds.sh create_webpage_compact.sh create_webpage.sh

--- a/ipmitool/contrib/ipmi.init.redhat
+++ b/ipmitool/contrib/ipmi.init.redhat
@ -48,6 +48,12 @@ start() {
 	# this failure.
 	grep -q ipmidev /proc/devices || RETVAL=1

+	# remove old device file always
+	# in case ipmi gets assigned new dynamic major number from kernel
+	if [ -c /dev/ipmi0 ]; then
+	    rm -f /dev/ipmi0
+	fi
+
 	# Check if the device file exists and create if not.
 	if [ ! -c /dev/ipmi0 ] && [ $RETVAL -eq 0 ]
 	then
--- a/ipmitool/control/Makefile.am
+++ b/ipmitool/control/Makefile.am
@ -34,8 +34,8 @@

 MAINTAINERCLEANFILES	= Makefile.in

-EXTRA_DIST		= pkginfo.in prototype.in ipmitool.spec.in \
-			  rpmrc rpmmacros
+EXTRA_DIST		= pkginfo.in prototype.in \
+			  ipmitool.spec.in rpmmacros.in rpmrc

-dist-hook: pkginfo prototype
+dist-hook: pkginfo prototype rpmmacros

--- a/ipmitool/control/ipmitool.spec.in
+++ b/ipmitool/control/ipmitool.spec.in
@ -32,8 +32,10 @@ fi

 %build
 ./configure --with-kerneldir \
+	--with-rpm-distro=@DISTRO@ \
 	--prefix=%{_prefix} \
 	--bindir=%{_bindir} \
+	--sbindir=%{_sbindir} \
 	--datadir=%{_datadir} \
 	--includedir=%{_includedir} \
 	--libdir=%{_libdir} \
@ -53,11 +55,43 @@ rm -rf $RPM_BUILD_DIR/ipmitool-@VERSION@
 %files
 %defattr(-,root,root)
 %{_bindir}/*
+%{_sbindir}/*
 %{_datadir}/ipmitool/*
 %doc %{_mandir}/man1/*
+%doc %{_mandir}/man8/*
 %doc %{_datadir}/doc/ipmitool/*

 %changelog
+* Sat Jan 14, 2006 <duncan@iceblink.org>  1.8.5-1
+ - Raise privilege level after creating IPMIv2 session
+ - Add support for settable SOL escape character with -e option
+ - Add support for Kg BMC key for IPMIv2 authentication with -k option
+ - Add support for Tyan IPMIv1.5 SOL with tsol command
+ - Add support for PICMG devices
+ - Add support for OEM SEL event parsing
+ - Add support for command bridging over lan and lanplus interfaces
+ - New 'chassis selftest' command
+ - Many bufxies and patches from contributors
+
+* Wed May 18 2005 <duncan@iceblink.org>  1.8.2-1
+ - Fix FRU reading for large (>255 bytes) areas.
+ - Overhaul to ipmievd to support SEL polling in addition to OpenIPMI.
+ - Fix LAN parameter segfault when no Ciphers supported by BMC.
+ - Fix IPMIv2 support on Intel v2 BMCs (use -o intelplus).
+ - Separate option parsing code from main ipmitool source file.
+ - Add raw I2C support with IPMI Master Read-Write command.
+ - Add support for new 'sdr elist' extended output format.
+ - Add support for listing sensors by type with 'sdr type' command.
+ - Add support for new 'sel elist' extended output format that
+   cross-references events with sensors.
+ - Add support for sending dynamically generated platform events
+   based on existing sensor information.
+ - New '-S' argument to read local SDR cache created with 'sdr dump'.
+ - Updated manpage for ipmitool and ipmievd.
+
+* Wed Apr 06 2005 <duncan@iceblink.org>  1.8.1-1
+ - Install ipmievd into /usr/sbin
+
 * Wed Mar 16 2005 <duncan@iceblink.org>  1.8.0-1
 - Fix IPMIv2.0 issues
 - Fix chassis boot parameter support
--- a/ipmitool/control/pkginfo.in
+++ b/ipmitool/control/pkginfo.in
@ -4,7 +4,7 @@ ARCH="@ARCH@"
 VERSION="@VERSION@"
 CATEGORY="system"
 VENDOR="Duncan Laurie"
-EMAIL="duncan@sun.com"
+EMAIL="duncan@iceblink.org"
 PSTAMP="@PSTAMP@"
 BASEDIR="@BASEDIR@"
 CLASSES="none"
--- a/ipmitool/control/prototype.in
+++ b/ipmitool/control/prototype.in
@ -1,7 +1,12 @@
 i pkginfo
 d none bin ? ? ?
 f none bin/@PACKAGE@=../src/@PACKAGE@ 0755 root bin
+d none sbin ? ? ?
+f none sbin/ipmievd=../src/ipmievd 0755 root bin
 d none share ? ? ?
 d none share/man ? ? ?
 d none share/man/man1 ? ? ?
 f none share/man/man1/@PACKAGE@.1=../doc/@PACKAGE@.1 0644 root bin
+d none share/man/man8 ? ? ?
+f none share/man/man8/ipmievd.8=../doc/ipmievd.8 0644 root bin
+
--- a/ipmitool/control/rpmmacros.in
+++ b/ipmitool/control/rpmmacros.in
@ -6,6 +6,7 @@
 %_buildroot	%{_topdir}/%{_tmppath}/%{name}-%{version}-root
 %_rpmdir	%{_topdir}/RPMS
 %_srcrpmdir	%{_topdir}/SRPMS
+%_distro	@DISTRO@
 %_rpmfilename	%%{NAME}-%%{VERSION}-%%{RELEASE}.%%{ARCH}.rpm
 %packager	duncan@iceblink.org
 %distribution	Sourceforge Build
--- a/ipmitool/control/rpmrc
+++ b/ipmitool/control/rpmrc
@ -1 +1,8 @@
 macrofiles: /usr/lib/rpm/macros:/usr/lib/rpm/%{_target}/macros:/etc/rpm/macros.specspo:/etc/rpm/macros:/etc/rpm/%{_target}/macros:%(echo $CONFIGDIR)/rpmmacros
+
+buildarchtranslate: athlon: i386
+buildarchtranslate: i686: i386
+buildarchtranslate: i586: i386
+buildarchtranslate: i486: i386
+buildarchtranslate: i386: i386
+
--- a/ipmitool/debian/README.Debian
+++ b/ipmitool/debian/README.Debian
@ -0,0 +1,5 @@
+For more information about setting up your Debian system with IPMI
+please see the excellent howto by Tim Small:
+
+http://buttersideup.com/docs/howto/IPMI_on_Debian.html
+
--- a/ipmitool/debian/changelog
+++ b/ipmitool/debian/changelog
@ -1,3 +1,53 @@
+ipmitool (1.8.2-1) unstable; urgency=low
+
+  * New upstream release.
+    -  Fix FRU reading for large (>255 bytes) areas.
+    -  Overhaul to ipmievd to support SEL polling in addition to OpenIPMI.
+    -  Fix LAN parameter segfault when no Ciphers supported by
+       BMC. (Closes: #306806)
+    -  Fix IPMIv2 support on Intel v2 BMCs (use -o intelplus).
+    -  Separate option parsing code from main ipmitool source file.
+    -  Add raw I2C support with IPMI Master Read-Write command.
+    -  Add support for new 'sdr elist' extended output format.
+    -  Add support for listing sensors by type with 'sdr type' command.
+    -  Add support for new 'sel elist' extended output format that
+       cross-references events with sensors.
+    -  Add support for sending dynamically generated platform events
+       based on existing sensor information.
+    -  New '-S' argument to read local SDR cache created with 'sdr dump'.
+    -  Updated manpage for ipmitool and ipmievd. (Closes: #306894)
+  * Correct the upstream URL in debian/changelog to the current one.
+  * Suggest package openipmi. (Closes: #305629)
+  * Add debian/watch file to detect new source versions.
+
+ -- Petter Reinholdtsen <pere@debian.org>  Sun,  5 Jun 2005 10:29:18 +0200
+
+ipmitool (1.8.1-1) unstable; urgency=low
+
+  * New upstream release.
+  * Install ipmievd into /usr/sbin/.
+
+ -- Petter Reinholdtsen <pere@debian.org>  Thu,  7 Apr 2005 01:18:44 +0200
+
+ipmitool (1.8.0-1) unstable; urgency=low
+
+  * Initial upload into Debian, based on the upstream build
+    rules. (Closes: #299924)
+  * Convert debian/changelog to UTF-8.
+  * Change section from 'contrib' to 'utils'.
+  * Build-depend on debhelper (>> 4.0.0) to match the rules file.
+  * Set Standards-version to 3.6.1.
+  * Make sure binary dependency is properly generated.
+  * Add long description, copied from the project README.
+  * Drop useless provides 'ipmitool', as the package is called 'ipmitool'.
+  * Don't install the COPYING file, as the license text already is
+    included in debian/copyright.
+  * Remove unused parts of the rules file.
+  * Correct clean target in rules file, to use 'distclean' and remove
+    configure-stamp not bogus config-stamp.
+
+ -- Petter Reinholdtsen <pere@debian.org>  Sun,  3 Apr 2005 20:52:02 +0200
+
 ipmitool (1.8.0) unstable; urgency=low

  * Fix IPMIv2.0 issues
@ -12,7 +62,7 @@ ipmitool (1.7.1) unstable; urgency=low
    for interface detection and new STREAMS message-based interface).

 -- Seth Goldberg <sethmeisterg@hotmail.com>  Mon, Mar 7 2005 18:03:00 -0800
-	
+
 ipmitool (1.7.0) unstable; urgency=low

  * Propogate errors correctly so exit status will be useful
@ -70,7 +120,7 @@ ipmitool (1.5.9) unstable; urgency=low
  * Add configure option for changing binary to ipmiadm for Solaris
  * Fix compile problem on Solaris 8

- -- Duncan Laurie <duncan@sun.com>  Sat, 27 Mar 2004 00:11:37 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Sat, 27 Mar 2004 00:11:37 -0700

 ipmitool (1.5.8) unstable; urgency=low

@ -84,7 +134,7 @@ ipmitool (1.5.8) unstable; urgency=low
  * Add support for Linux kernel panic messages in SEL output
  * Add support for type 3 SDR records

- -- Duncan Laurie <duncan@sun.com>  Tue, 27 Jan 2004 16:23:25 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Tue, 27 Jan 2004 16:23:25 -0700

 ipmitool (1.5.7) unstable; urgency=low

@ -93,49 +143,49 @@ ipmitool (1.5.7) unstable; urgency=low
  * better handling of SDR printing
  * contrib scripts for creating rrdtool graphs

- -- Duncan Laurie <duncan@sun.com>  Mon,  5 Jan 2004 17:29:50 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Mon,  5 Jan 2004 17:29:50 -0700

 ipmitool (1.5.6) unstable; urgency=low

  * Fix SEL event decoding for generic events
  * Handle empty SEL gracefully when doing "sel list"
  * Fix sdr handling of sensors that do not return a reading
-  * Fix for CSV display of sensor readings/units from Fredrik <EFBFBD>hrn
+  * Fix for CSV display of sensor readings/units from Fredrik Öhrn

- -- Duncan Laurie <duncan@sun.com>  Thu,  4 Dec 2003 14:47:19 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Thu,  4 Dec 2003 14:47:19 -0700

 ipmitool (1.5.5) unstable; urgency=low

  * Add -U option for setting LAN username
  * Fix -v usage for plugin interfaces

- -- Duncan Laurie <duncan@sun.com>  Tue, 25 Nov 2003 15:10:48 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Tue, 25 Nov 2003 15:10:48 -0700

 ipmitool (1.5.4) unstable; urgency=low

  * Put interface plugin API into library
  * Fix ipmievd

- -- Duncan Laurie <duncan@sun.com>  Fri, 14 Nov 2003 15:16:34 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Fri, 14 Nov 2003 15:16:34 -0700

 ipmitool (1.5.3) unstable; urgency=low

  * Add -g option to work with grizzly bmc

- -- Duncan Laurie <duncan@sun.com>  Mon,  3 Nov 2003 18:04:07 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Mon,  3 Nov 2003 18:04:07 -0700

 ipmitool (1.5.2) unstable; urgency=low

  * add support for setting gratuitous arp interval 

- -- Duncan Laurie <duncan@sun.com>  Fri, 24 Oct 2003 11:00:00 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Fri, 24 Oct 2003 11:00:00 -0700

 ipmitool (1.5.1) unstable; urgency=low

  * better SEL support
  * fix display bug in SDR list

- -- Duncan Laurie <duncan@sun.com>  Wed,  8 Oct 2003 17:28:51 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Wed,  8 Oct 2003 17:28:51 -0700

 ipmitool (1.5.0) unstable; urgency=low

@ -143,24 +193,24 @@ ipmitool (1.5.0) unstable; urgency=low
  * add Intel IMB driver support
  * use autoconf/automake/libtool

- -- Duncan Laurie <duncan@sun.com>  Fri,  5 Sep 2003 11:57:32 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Fri,  5 Sep 2003 11:57:32 -0700

 ipmitool (1.2-1) unstable; urgency=low

  * New command line option parsing
  * More chassis commands supported

- -- Duncan Laurie <duncan@sun.com>  Wed,  2 Apr 2003 17:44:17 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Wed,  2 Apr 2003 17:44:17 -0700

 ipmitool (1.1-1) unstable; urgency=low

  * Minor fixes.

- -- Duncan Laurie <duncan@sun.com>  Tue,  1 Apr 2003 14:31:10 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Tue,  1 Apr 2003 14:31:10 -0700

 ipmitool (1.0-1) unstable; urgency=low

  * Initial Release.

- -- Duncan Laurie <duncan@sun.com>  Sun, 30 Mar 2003 21:30:46 -0700
+ -- Duncan Laurie <duncan@iceblink.org>  Sun, 30 Mar 2003 21:30:46 -0700

--- a/ipmitool/debian/control
+++ b/ipmitool/debian/control
@ -1,12 +1,28 @@
 Source: ipmitool
-Section: contrib
+Section: utils
 Priority: optional
-Maintainer: Duncan Laurie <duncan@iceblink.org>
-Build-Depends: debhelper (>> 3.0.0)
-Standards-Version: 3.5.8
+Maintainer: Petter Reinholdtsen <pere@debian.org>
+Uploaders: Duncan Laurie <duncan@iceblink.org>
+Build-Depends: debhelper (>> 4.0.0),
+Standards-Version: 3.6.1

 Package: ipmitool
 Architecture: i386 amd64
-Provides: ipmitool
-Description: Utility for IPMI control with kernel driver or LAN interface
+Depends: ${shlibs:Depends}
+Suggest: openipmi
+Description: utility for IPMI control with kernel driver or LAN interface
+ A utility for managing and configuring devices that support the
+ Intelligent Platform Management Interface.  IPMI is an open standard
+ for monitoring, logging, recovery, inventory, and control of hardware
+ that is implemented independent of the main CPU, BIOS, and OS.  The
+ service processor (or Baseboard Management Controller, BMC) is the
+ brain behind platform management and its primary purpose is to handle
+ the autonomous sensor monitoring and event logging features.
+ .
+ The ipmitool program provides a simple command-line interface to this
+ BMC.  It features the ability to read the sensor data repository
+ (SDR) and print sensor values, display the contents of the System
+ Event Log (SEL), print Field Replaceable Unit (FRU) inventory
+ information, read and set LAN configuration parameters, and perform
+ remote chassis power control.

--- a/ipmitool/debian/copyright
+++ b/ipmitool/debian/copyright
@ -1,7 +1,10 @@
-ipmitool
-Duncan Laurie <duncan@sun.com>
-http://www.iceblink.org/ipmitool/
+This package was debianized by Duncan Laurie before
+2003-11-18 17:55:21 +0100.

+It was downloaded from <URL:http://ipmitool.sourceforge.net/>
+
+Upstream Author: Duncan Laurie <duncan@iceblink.org>
+  
 Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.

 Redistribution and use in source and binary forms, with or without
@ -35,4 +38,3 @@ EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 You acknowledge that this software is not designed or intended for use
 in the design, construction, operation or maintenance of any nuclear
 facility.
-
--- a/ipmitool/debian/dirs
+++ b/ipmitool/debian/dirs
@ -1,3 +1,4 @@
 usr/bin
+usr/sbin
 usr/share/ipmitool
 usr/share/doc/ipmitool
--- a/ipmitool/debian/docs
+++ b/ipmitool/debian/docs
@ -1,4 +1,2 @@
 README
-COPYING
 AUTHORS
-ChangeLog
--- a/ipmitool/debian/rules
+++ b/ipmitool/debian/rules
@ -41,10 +41,10 @@ build-indep-stamp: configure-stamp
 clean:
 	dh_testdir
 	dh_testroot
-	rm -f build-arch-stamp build-indep-stamp config-stamp
+	rm -f build-arch-stamp build-indep-stamp configure-stamp

 # Add here commands to clean up after the build process.
-	-$(MAKE) clean
+	-$(MAKE) distclean

 	dh_clean

@ -71,6 +71,17 @@ install-arch:
 # debian/tmp.
 	$(MAKE) install DESTDIR=$(CURDIR)/debian/ipmitool

+	# No need to have two copies of the license text in the package.
+	$(RM) $(CURDIR)/debian/ipmitool/usr/share/doc/ipmitool/COPYING
+
+	# Move upstream changelog to correct filename.
+	mv $(CURDIR)/debian/ipmitool/usr/share/doc/ipmitool/ChangeLog \
+	  $(CURDIR)/debian/ipmitool/usr/share/doc/ipmitool/changelog
+
+	# Compress to avoid lintian warning.  Not sure why dh_compress
+	# isn't fixing this.
+	gzip -9 $(CURDIR)/debian/ipmitool/usr/share/doc/ipmitool/changelog
+
 #	dh_movefiles -a
 # Must not depend on anything. This is to be called by
 # binary-arch/binary-multi
@ -78,27 +89,15 @@ install-arch:
 binary-common:
 	dh_testdir
 	dh_testroot
-#	dh_installdebconf	
 	dh_installdocs
-#	dh_installexamples
-#	dh_installmenu
-#	dh_installemacsen
-#	dh_installpam
-#	dh_installinit
-#	dh_installcron
-#	dh_installmanpages
-#	dh_installinfo
-#	dh_undocumented
-#	dh_installchangelogs 
+	dh_installchangelogs 
 	dh_link
 	dh_strip
 	dh_compress 
 	dh_fixperms
-# You may want to make some executables suid here.
-#	dh_suidregister
 	dh_makeshlibs
+	dh_shlibdeps
 	dh_installdeb
-#	dh_perl
 	dh_gencontrol
 	dh_md5sums
 	dh_builddeb
--- a/ipmitool/debian/watch
+++ b/ipmitool/debian/watch
@ -0,0 +1,6 @@
+# Rename this file to "watch" and then you can run the "uscan" command
+# to check for upstream updates and more.
+# Site          Directory               Pattern                 Version Script
+version=2
+http://heanet.dl.sourceforge.net/sourceforge/ipmitool/ipmitool-(.*).tar.bz2
+# debian uupdate
--- a/ipmitool/doc/Makefile.am
+++ b/ipmitool/doc/Makefile.am
@ -34,7 +34,7 @@

 MAINTAINERCLEANFILES	= Makefile.in

-man_MANS		= ipmitool.1
+man_MANS		= ipmitool.1 ipmievd.8

 EXTRA_DIST		= $(man_MANS)

--- a/ipmitool/doc/ipmievd.8
+++ b/ipmitool/doc/ipmievd.8
@ -0,0 +1,208 @@
+.TH "ipmievd" "8" "" "Duncan Laurie" ""
+.SH "NAME"
+ipmievd \- IPMI event daemon for sending events to syslog
+.SH "SYNOPSIS"
+ipmievd [\fB\-c\fR|\fB\-h\fR|\fB\-v\fR|\fB\-V\fR]
+\fB\-I\fR \fIopen\fP <\fIopen\fR | \fIsel\fR> [<\fIoption\fP>]
+
+ipmievd [\fB\-c\fR|\fB\-h\fR|\fB\-v\fR|\fB\-V\fR]
+\fB\-I\fR \fIlan\fP \fB\-H\fR <\fIhostname\fP>
+        [\fB\-p\fR <\fIport\fP>]
+        [\fB\-U\fR <\fIusername\fP>]
+        [\fB\-A\fR <\fIauthtype\fP>]
+        [\fB\-L\fR <\fIprivlvl\fP>]
+        [\fB\-a\fR|\fB\-E\fR|\fB\-P\fR|\fB\-f\fR <\fIpassword\fP>]
+        [\fB\-o\fR <\fIoemtype\fP>]
+        \fIsel\fP [<\fIoption\fP>]
+
+ipmievd [\fB\-c\fR|\fB\-h\fR|\fB\-v\fR|\fB\-V\fR]
+\fB\-I\fR \fIlanplus\fP \fB\-H\fR <\fIhostname\fP>
+        [\fB\-p\fR <\fIport\fP>]
+        [\fB\-U\fR <\fIusername\fP>]
+        [\fB\-L\fR <\fIprivlvl\fP>]
+        [\fB\-a\fR|\fB\-E\fR|\fB\-P\fR|\fB\-f\fR <\fIpassword\fP>]
+        [\fB\-o\fR <\fIoemtype\fP>]
+        [\fB\-C\fR <\fIciphersuite\fP>]
+        \fIsel\fR [<\fIoption\fP>]
+.SH "DESCRIPTION"
+\fBipmievd\fP is a daemon which will listen for events from the
+BMC that are being sent to the SEL and also log those messages to
+syslog.  It is able to run in one of two modes: either using the
+Event Message Buffer and asynchronous event notification from the
+OpenIPMI kernel driver or actively polling the contents of the
+SEL for new events.  Upon receipt of an event via either mechanism
+it will be logged to syslog with the \fILOG_LOCAL4\fP facility.
+
+It is based on the \fBipmitool\fR utility and shares the same IPMI
+interface support and session setup options.  Please see the
+\fBipmitool\fR manpage for more information on supported IPMI
+interfaces.
+.SH "OPTIONS"
+.TP 
+\fB\-a\fR
+Prompt for the remote server password.
+.TP 
+\fB\-A\fR <\fIauthtype\fP>
+Specify an authentication type to use during IPMIv1.5 \fIlan\fP
+session activation.  Supported types are NONE, PASSWORD, MD5, or OEM.
+.TP 
+\fB\-c\fR
+Present output in CSV (comma separated variable) format.  
+This is not available with all commands.
+.TP 
+\fB\-C\fR <\fIciphersuite\fP>
+The remote server authentication, integrity, and encryption algorithms
+to use for IPMIv2 \fIlanplus\fP connections.  See table 22\-19 in the
+IPMIv2 specification.  The default is 3 which specifies RAKP\-HMAC\-SHA1 
+authentication, HMAC\-SHA1\-96 integrity, and AES\-CBC\-128 encryption algorightms.
+.TP 
+\fB\-E\fR
+The remote server password is specified by the environment
+variable \fIIPMI_PASSWORD\fP.
+.TP 
+\fB\-f\fR <\fIpassword_file\fP>
+Specifies a file containing the remote server password. If this
+option is absent, or if password_file is empty, the password
+will default to NULL.
+.TP 
+\fB\-h\fR
+Get basic usage help from the command line.
+.TP 
+\fB\-H\fR <\fIaddress\fP>
+Remote server address, can be IP address or hostname.  This 
+option is required for \fIlan\fP and \fIlanplus\fP interfaces.
+.TP 
+\fB\-I\fR <\fIinterface\fP>
+Selects IPMI interface to use.  Supported interfaces that are
+compiled in are visible in the usage help output.
+.TP 
+\fB\-L\fR <\fIprivlvl\fP>
+Force session privilege level.  Can be CALLBACK, USER,
+OPERATOR, ADMIN. Default is ADMIN.
+.TP 
+\fB\-m\fR <\fIlocal_address\fP>
+Set the local IPMB address.  The default is 0x20 and there
+should be no need to change it for normal operation.
+.TP 
+\fB\-o\fR <\fIoemtype\fP>
+Select OEM type to support.  This usually involves minor hacks
+in place in the code to work around quirks in various BMCs from
+various manufacturers.  Use \fI\-o list\fP to see a list of
+current supported OEM types.
+.TP 
+\fB\-p\fR <\fIport\fP>
+Remote server UDP port to connect to.  Default is 623.
+.TP 
+\fB\-P\fR <\fIpassword\fP>
+Remote server password is specified on the command line.
+If supported it will be obscured in the process list. 
+\fBNote!\fR Specifying the password as a command line
+option is not recommended.
+.TP 
+\fB\-S\fR <\fIsdr_cache_file\fP>
+Use local file for remote SDR cache.  Using a local SDR cache
+can drastically increase performance for commands that require
+knowledge of the entire SDR to perform their function.
+.TP 
+\fB\-t\fR <\fItarget_address\fP>
+Bridge IPMI requests to the remote target address.
+.TP 
+\fB\-U\fR <\fIusername\fP>
+Remote server username, default is NULL user.
+.TP 
+\fB\-v\fR
+Increase verbose output level.  This option may be specified
+multiple times to increase the level of debug output.  If given
+three times you will get hexdumps of all incoming and
+outgoing packets.
+.TP 
+\fB\-V\fR
+Display version information.
+
+.LP 
+If no password method is specified then ipmievd will prompt the
+user for a password. If no password is entered at the prompt,
+the remote server password will default to NULL.
+.SH "COMMANDS"
+.TP 
+\fIhelp\fP
+This can be used to get command\-line help.  It may also be
+placed at the end of commands to get option usage help.
+
+> ipmievd help
+.br 
+Commands:
+    open    Use OpenIPMI for asyncronous notification of events
+    sel     Poll SEL for notification of events
+
+.TP 
+\fIopen\fP
+This command starts ipmievd with the OpenIPMI event watching
+mechanism which relies on the Event Message Buffer feature of
+IPMI.  This requires a properly installed and configured
+OpenIPMI driver on Linux and is only valid to be run through
+the \fIopen\fP interface.  See the \fBipmitool\fR manpage
+and associated documentation for more information on setting
+up the OpenIPMI driver.
+
+\fBNote\fR: Some BMC do not support the Event Message Buffer
+required for this command.  Other BMCs claim to support it but
+do not actually deliver events to it.  If this is the case please
+use the \fIsel\fP method.
+
+.RS
+.TP 
+\fIdaemon\fP
+Launch process as a daemon and reparent to init process.
+All messages will be sent to syslog.  This is the default action.
+.TP 
+\fInodaemon\fP
+Do NOT become a daemon, instead log all messages to stderr.
+.RE
+
+.TP 
+\fIsel\fP
+This command starts ipmievd with the SEL Polling event watching
+mechanism.  This will poll the SEL periodically to determine if
+new events have been logged.  This command should work with all
+BMCs and is capable of using the LAN interface as well to monitor
+a remote system and log its events to a local syslog.
+
+.RS
+.TP 
+\fIdaemon\fP
+Launch process as a daemon and reparent to init process.
+All messages will be sent to syslog.  This is the default action.
+.TP 
+\fInodaemon\fP
+Do NOT become a daemon, instead log all messages to stderr.
+.TP 
+\fItimeout\fP=<\fBseconds\fR>
+Time between checks for SEL polling method.  Default is 10 seconds.
+.RE
+.SH "EXAMPLES"
+.TP 
+\fIExample 1\fP: Daemon process watching OpenIPMI for events
+
+> ipmievd \-I open open daemon
+.TP 
+\fIExample 2\fP: Local non\-daemon process checking remote SEL every 30 seconds
+
+> ipmievd \-I lan \-H 1.2.3.4 \-f passfile sel nodaemon timeout=30
+.br 
+Reading Sensors...
+.br 
+Waiting for Events...
+.br 
+.SH "AUTHOR"
+Duncan Laurie <duncan@iceblink.org>
+.SH "SEE ALSO"
+.TP 
+IPMItool Homepage
+http://ipmitool.sourceforge.net
+.TP 
+Intelligent Platform Management Interface Specification
+http://www.intel.com/design/servers/ipmi
+.TP 
+OpenIPMI Homepage
+http://openipmi.sourceforge.net
--- a/ipmitool/doc/ipmitool.1
+++ b/ipmitool/doc/ipmitool.1
--- a/ipmitool/include/ipmitool/Makefile.am
+++ b/ipmitool/include/ipmitool/Makefile.am
@ -39,5 +39,6 @@ noinst_HEADERS = log.h bswap.h helper.h ipmi.h ipmi_intf.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 \
 	ipmi_strings.h ipmi_constants.h ipmi_user.h ipmi_pef.h \
-	ipmi_oem.h ipmi_isol.h
+	ipmi_oem.h ipmi_isol.h ipmi_sunoem.h ipmi_picmg.h \
+	ipmi_fwum.h ipmi_main.h ipmi_tsol.h

--- a/ipmitool/include/ipmitool/helper.h
+++ b/ipmitool/include/ipmitool/helper.h
@ -40,6 +40,7 @@
 #include <sys/types.h>
 #include <inttypes.h>
 #include <stdio.h>
+#include <string.h>

 struct valstr {
 	uint16_t val;
@ -47,6 +48,9 @@ struct valstr {
 };
 const char * val2str(uint16_t val, const struct valstr * vs);
 uint16_t str2val(const char * str, const struct valstr * vs);
+void print_valstr(const struct valstr * vs, const char * title, int loglevel);
+void print_valstr_2col(const struct valstr * vs, const char * title, int loglevel);
+

 uint16_t buf2short(uint8_t * buf);
 uint32_t buf2long(uint8_t * buf);
@ -54,6 +58,7 @@ const char * buf2str(uint8_t * buf, int len);
 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(void);

 #define ipmi_open_file_read(file)	ipmi_open_file(file, 0)
 #define ipmi_open_file_write(file)	ipmi_open_file(file, 1)
@ -62,4 +67,16 @@ FILE * ipmi_open_file(const char * file, int rw);
 # define __min(a, b)  ((a) < (b) ? (a) : (b))
 #endif

+#ifndef __max
+# define __max(a, b)  ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef __minlen
+# define __minlen(a, b) ({ int x=strlen(a); int y=strlen(b); (x < y) ? x : y;})
+#endif
+
+#ifndef __maxlen
+# define __maxlen(a, b) ({ int x=strlen(a); int y=strlen(b); (x > y) ? x : y;})
+#endif
+
 #endif /* IPMI_HELPER_H */
--- a/ipmitool/include/ipmitool/ipmi.h
+++ b/ipmitool/include/ipmitool/ipmi.h
@ -57,13 +57,13 @@
 #define IPMI_PAYLOAD_TYPE_RAKP_3             0x14
 #define IPMI_PAYLOAD_TYPE_RAKP_4             0x15

-
 extern int verbose;
 extern int csv_output;

 struct ipmi_rq {
 	struct {
-		uint8_t netfn;
+		uint8_t netfn:6;
+		uint8_t lun:2;
 		uint8_t cmd;
 		uint8_t target_cmd;
 		uint16_t data_len;
@ -71,50 +71,49 @@ struct ipmi_rq {
 	} msg;
 };

-
 /*
 * This is what the sendrcv_v2() function would take as an argument. The common case
 * is for payload_type to be IPMI_PAYLOAD_TYPE_IPMI.
 */
 struct ipmi_v2_payload {
 	uint16_t payload_length;
-	uint8_t  payload_type;
+	uint8_t payload_type;

 	union {

 		struct {
-			uint8_t    rq_seq;
-			struct ipmi_rq * request;
+			uint8_t rq_seq;
+			struct ipmi_rq *request;
 		} ipmi_request;

 		struct {
-			uint8_t	rs_seq;
-			struct ipmi_rs * response;
+			uint8_t rs_seq;
+			struct ipmi_rs *response;
 		} ipmi_response;

 		/* Only used internally by the lanplus interface */
 		struct {
-			uint8_t * request;
+			uint8_t *request;
 		} open_session_request;

 		/* Only used internally by the lanplus interface */
 		struct {
-			uint8_t * message;
+			uint8_t *message;
 		} rakp_1_message;

 		/* Only used internally by the lanplus interface */
 		struct {
-			uint8_t * message;
+			uint8_t *message;
 		} rakp_2_message;

 		/* Only used internally by the lanplus interface */
 		struct {
-			uint8_t * message;
+			uint8_t *message;
 		} rakp_3_message;

 		/* Only used internally by the lanplus interface */
 		struct {
-			uint8_t * message;
+			uint8_t *message;
 		} rakp_4_message;

 		struct {
@ -123,32 +122,27 @@ struct ipmi_v2_payload {
 			uint8_t packet_sequence_number;
 			uint8_t acked_packet_number;
 			uint8_t accepted_character_count;
-			uint8_t is_nack;              /* bool */
-			uint8_t assert_ring_wor;      /* bool */
-			uint8_t generate_break;       /* bool */
-			uint8_t deassert_cts;         /* bool */
-			uint8_t deassert_dcd_dsr;     /* bool */
-			uint8_t flush_inbound;        /* bool */
-			uint8_t flush_outbound;       /* bool */
+			uint8_t is_nack;	/* bool */
+			uint8_t assert_ring_wor;	/* bool */
+			uint8_t generate_break;	/* bool */
+			uint8_t deassert_cts;	/* bool */
+			uint8_t deassert_dcd_dsr;	/* bool */
+			uint8_t flush_inbound;	/* bool */
+			uint8_t flush_outbound;	/* bool */
 		} sol_packet;

 	} payload;
 };

-
-
 struct ipmi_rq_entry {
 	struct ipmi_rq req;
-	struct ipmi_intf * intf;
+	struct ipmi_intf *intf;
 	uint8_t rq_seq;
-	uint8_t * msg_data;
+	uint8_t *msg_data;
 	int msg_len;
-	struct ipmi_rq_entry * next;
+	struct ipmi_rq_entry *next;
 };

-
-
-
 struct ipmi_rs {
 	uint8_t ccode;
 	uint8_t data[IPMI_BUF_SIZE];
@ -167,19 +161,18 @@ struct ipmi_rs {
 	} msg;

 	struct {
-		uint8_t  authtype;
-		uint32_t       seq;
-		uint32_t       id;
-		uint8_t  bEncrypted;     /* IPMI v2 only */
-		uint8_t  bAuthenticated; /* IPMI v2 only */
-		uint8_t  payloadtype;    /* IPMI v2 only */
+		uint8_t authtype;
+		uint32_t seq;
+		uint32_t id;
+		uint8_t bEncrypted;	/* IPMI v2 only */
+		uint8_t bAuthenticated;	/* IPMI v2 only */
+		uint8_t payloadtype;	/* IPMI v2 only */
 		/* This is the total length of the payload or
 		   IPMI message.  IPMI v2.0 requires this to
 		   be 2 bytes.  Not really used for much. */
 		uint16_t msglen;
 	} session;

-
 	/*
 	 * A union of the different possible payload meta-data
 	 */
@ -197,8 +190,8 @@ struct ipmi_rs {
 			uint8_t message_tag;
 			uint8_t rakp_return_code;
 			uint8_t max_priv_level;
-			uint32_t  console_id;
-			uint32_t  bmc_id;
+			uint32_t console_id;
+			uint32_t bmc_id;
 			uint8_t auth_alg;
 			uint8_t integrity_alg;
 			uint8_t crypt_alg;
@ -206,33 +199,31 @@ struct ipmi_rs {
 		struct {
 			uint8_t message_tag;
 			uint8_t rakp_return_code;
-			uint32_t  console_id;
-			uint8_t bmc_rand[16]; /* Random number generated by the BMC */
+			uint32_t console_id;
+			uint8_t bmc_rand[16];	/* Random number generated by the BMC */
 			uint8_t bmc_guid[16];
 			uint8_t key_exchange_auth_code[20];
 		} rakp2_message;
 		struct {
 			uint8_t message_tag;
 			uint8_t rakp_return_code;
-			uint32_t  console_id;
+			uint32_t console_id;
 			uint8_t integrity_check_value[20];
 		} rakp4_message;
 		struct {
 			uint8_t packet_sequence_number;
 			uint8_t acked_packet_number;
 			uint8_t accepted_character_count;
-			uint8_t is_nack;              /* bool */
-			uint8_t transfer_unavailable; /* bool */
-			uint8_t sol_inactive;         /* bool */
-			uint8_t transmit_overrun;     /* bool */
-			uint8_t break_detected;       /* bool */
+			uint8_t is_nack;	/* bool */
+			uint8_t transfer_unavailable;	/* bool */
+			uint8_t sol_inactive;	/* bool */
+			uint8_t transmit_overrun;	/* bool */
+			uint8_t break_detected;	/* bool */
 		} sol_packet;
-			
+
 	} payload;
 };

-
-
 #define IPMI_NETFN_CHASSIS		0x0
 #define IPMI_NETFN_BRIDGE		0x2
 #define IPMI_NETFN_SE			0x4
@ -240,11 +231,13 @@ struct ipmi_rs {
 #define IPMI_NETFN_FIRMWARE		0x8
 #define IPMI_NETFN_STORAGE		0xa
 #define IPMI_NETFN_TRANSPORT		0xc
+#define IPMI_NETFN_PICMG		0x2C
 #define IPMI_NETFN_ISOL			0x34
+#define IPMI_NETFN_TSOL			0x30

 #define IPMI_BMC_SLAVE_ADDR		0x20
 #define IPMI_REMOTE_SWID		0x81

 extern const struct valstr completion_code_vals[];

-#endif /* IPMI_H */
+#endif				/* IPMI_H */
--- a/ipmitool/include/ipmitool/ipmi_chassis.h
+++ b/ipmitool/include/ipmitool/ipmi_chassis.h
@ -51,6 +51,9 @@
 #define IPMI_CHASSIS_POLICY_PREVIOUS	0x1
 #define IPMI_CHASSIS_POLICY_ALWAYS_OFF	0x0

-int ipmi_chassis_main(struct ipmi_intf *, int, char **);
+int ipmi_chassis_power_status(struct ipmi_intf * intf);
+int ipmi_chassis_power_control(struct ipmi_intf * intf, uint8_t ctl);
+int ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv);
+int ipmi_power_main(struct ipmi_intf * intf, int argc, char ** argv);

 #endif /*IPMI_CHASSIS_H*/
--- a/ipmitool/include/ipmitool/ipmi_constants.h
+++ b/ipmitool/include/ipmitool/ipmi_constants.h
@ -82,7 +82,7 @@
 #define IPMI_SET_IN_PROGRESS_COMMIT_WRITE 0x02

 #define IPMI_CHANNEL_MEDIUM_RESERVED	0x0
-#define IPMI_CHANNEL_MEDIUM_IPMB	0x1
+#define IPMI_CHANNEL_MEDIUM_IPMB_I2C	0x1
 #define IPMI_CHANNEL_MEDIUM_ICMB_1	0x2
 #define IPMI_CHANNEL_MEDIUM_ICMB_09	0x3
 #define IPMI_CHANNEL_MEDIUM_LAN		0x4
@ -95,6 +95,18 @@
 #define IPMI_CHANNEL_MEDIUM_USB_2	0xb
 #define IPMI_CHANNEL_MEDIUM_SYSTEM	0xc

+#define IPMI_CHASSIS_CTL_POWER_DOWN	0x0
+#define IPMI_CHASSIS_CTL_POWER_UP	0x1
+#define IPMI_CHASSIS_CTL_POWER_CYCLE	0x2
+#define IPMI_CHASSIS_CTL_HARD_RESET	0x3
+#define IPMI_CHASSIS_CTL_PULSE_DIAG	0x4
+#define IPMI_CHASSIS_CTL_ACPI_SOFT	0x5
+
+#define IPMI_CHASSIS_POLICY_NO_CHANGE	0x3
+#define IPMI_CHASSIS_POLICY_ALWAYS_ON	0x2
+#define IPMI_CHASSIS_POLICY_PREVIOUS	0x1
+#define IPMI_CHASSIS_POLICY_ALWAYS_OFF	0x0
+
 /* From table 13-17 of the IPMI v2 specification */
 #define IPMI_AUTH_RAKP_NONE         0x00
 #define IPMI_AUTH_RAKP_HMAC_SHA1    0x01
--- a/ipmitool/include/ipmitool/ipmi_event.h
+++ b/ipmitool/include/ipmitool/ipmi_event.h
@ -42,6 +42,23 @@
 #endif
 #include <ipmitool/ipmi.h>

+#define EVENT_DIR_ASSERT	0
+#define EVENT_DIR_DEASSERT	1
+
+struct platform_event_msg {
+	uint8_t evm_rev;
+	uint8_t sensor_type;
+	uint8_t sensor_num;
+#if WORDS_BIGENDIAN
+	uint8_t event_dir  : 1;
+	uint8_t event_type : 7;
+#else
+	uint8_t event_type : 7;
+	uint8_t event_dir  : 1;
+#endif
+	uint8_t event_data[3];
+} __attribute__((packed));
+
 int  ipmi_event_main(struct ipmi_intf *, int, char **);

 #endif /*IPMI_EVENT_H*/
--- a/ipmitool/include/ipmitool/ipmi_fru.h
+++ b/ipmitool/include/ipmitool/ipmi_fru.h
@ -66,7 +66,7 @@ enum {

 struct fru_info {
 	uint16_t size;
-	uint8_t access : 1;
+	uint8_t access:1;
 } __attribute__ ((packed));

 struct fru_header {
@ -86,8 +86,8 @@ struct fru_area_chassis {
 	uint8_t area_ver;
 	uint8_t type;
 	uint16_t area_len;
-	char * part;
-	char * serial;
+	char *part;
+	char *serial;
 };

 struct fru_area_board {
@ -95,24 +95,24 @@ struct fru_area_board {
 	uint8_t lang;
 	uint16_t area_len;
 	uint32_t mfg_date_time;
-	char * mfg;
-	char * prod;
-	char * serial;
-	char * part;
-	char * fru;
+	char *mfg;
+	char *prod;
+	char *serial;
+	char *part;
+	char *fru;
 };

 struct fru_area_product {
 	uint8_t area_ver;
 	uint8_t lang;
 	uint16_t area_len;
-	char * mfg;
-	char * name;
-	char * part;
-	char * version;
-	char * serial;
-	char * asset;
-	char * fru;
+	char *mfg;
+	char *name;
+	char *part;
+	char *version;
+	char *serial;
+	char *asset;
+	char *fru;
 };

 struct fru_multirec_header {
@ -122,6 +122,7 @@ struct fru_multirec_header {
 #define FRU_RECORD_TYPE_MANAGEMENT_ACCESS 0x03
 #define FRU_RECORD_TYPE_BASE_COMPATIBILITY 0x04
 #define FRU_RECORD_TYPE_EXTENDED_COMPATIBILITY 0x05
+#define FRU_RECORD_TYPE_PICMG_EXTENSION	0xc0
 	uint8_t type;
 	uint8_t format;
 	uint8_t len;
@ -133,59 +134,58 @@ struct fru_multirec_powersupply {
 #if WORDS_BIGENDIAN
 	uint16_t capacity;
 #else
-	uint16_t capacity		: 12;
-	uint16_t __reserved1	: 4;
+	uint16_t capacity:12;
+	uint16_t __reserved1:4;
 #endif
 	uint16_t peak_va;
-	uint8_t  inrush_current;
-	uint8_t  inrush_interval;
+	uint8_t inrush_current;
+	uint8_t inrush_interval;
 	uint16_t lowend_input1;
 	uint16_t highend_input1;
 	uint16_t lowend_input2;
 	uint16_t highend_input2;
-	uint8_t  lowend_freq;
-	uint8_t  highend_freq;
-	uint8_t  dropout_tolerance;
+	uint8_t lowend_freq;
+	uint8_t highend_freq;
+	uint8_t dropout_tolerance;
 #if WORDS_BIGENDIAN
-	uint8_t  __reserved2	: 3;
-	uint8_t  tach		: 1;
-	uint8_t  hotswap		: 1;
-	uint8_t  autoswitch	: 1;
-	uint8_t  pfc		: 1;
-	uint8_t  predictive_fail	: 1;
+	uint8_t __reserved2:3;
+	uint8_t tach:1;
+	uint8_t hotswap:1;
+	uint8_t autoswitch:1;
+	uint8_t pfc:1;
+	uint8_t predictive_fail:1;
 #else
-	uint8_t  predictive_fail	: 1;
-	uint8_t  pfc		: 1;
-	uint8_t  autoswitch	: 1;
-	uint8_t  hotswap		: 1;
-	uint8_t  tach		: 1;
-	uint8_t  __reserved2	: 3;
+	uint8_t predictive_fail:1;
+	uint8_t pfc:1;
+	uint8_t autoswitch:1;
+	uint8_t hotswap:1;
+	uint8_t tach:1;
+	uint8_t __reserved2:3;
 #endif
 	uint16_t peak_cap_ht;
 #if WORDS_BIGENDIAN
-	uint8_t  combined_voltage1 : 4;
-	uint8_t  combined_voltage2 : 4;
+	uint8_t combined_voltage1:4;
+	uint8_t combined_voltage2:4;
 #else
-	uint8_t  combined_voltage2 : 4;
-	uint8_t  combined_voltage1 : 4;
+	uint8_t combined_voltage2:4;
+	uint8_t combined_voltage1:4;
 #endif
 	uint16_t combined_capacity;
-	uint8_t  rps_threshold;
+	uint8_t rps_threshold;
 } __attribute__ ((packed));

-static const char * combined_voltage_desc[] __attribute__((unused)) = {
-	"12 V", "-12 V", "5 V", "3.3 V"
-};
+static const char *combined_voltage_desc[] __attribute__ ((unused)) = {
+"12 V", "-12 V", "5 V", "3.3 V"};

 struct fru_multirec_dcoutput {
 #if WORDS_BIGENDIAN
-	uint8_t  standby		: 1;
-	uint8_t  __reserved	: 3;
-	uint8_t  output_number	: 4;
+	uint8_t standby:1;
+	uint8_t __reserved:3;
+	uint8_t output_number:4;
 #else
-	uint8_t  output_number	: 4;
-	uint8_t  __reserved	: 3;
-	uint8_t  standby		: 1;
+	uint8_t output_number:4;
+	uint8_t __reserved:3;
+	uint8_t standby:1;
 #endif
 	short nominal_voltage;
 	short max_neg_dev;
@ -197,11 +197,11 @@ struct fru_multirec_dcoutput {

 struct fru_multirec_dcload {
 #if WORDS_BIGENDIAN
-	uint8_t  __reserved	: 4;
-	uint8_t  output_number	: 4;
+	uint8_t __reserved:4;
+	uint8_t output_number:4;
 #else
-	uint8_t  output_number	: 4;
-	uint8_t  __reserved	: 4;
+	uint8_t output_number:4;
+	uint8_t __reserved:4;
 #endif
 	short nominal_voltage;
 	short min_voltage;
@ -211,18 +211,112 @@ struct fru_multirec_dcload {
 	uint16_t max_current;
 } __attribute__ ((packed));

-static const char * chassis_type_desc[] __attribute__((unused)) = {
-	"Unspecified", "Other", "Unknown",
-	"Desktop", "Low Profile Desktop", "Pizza Box",
-	"Mini Tower", "Tower",
-	"Portable", "LapTop", "Notebook", "Hand Held", "Docking Station",
-	"All in One", "Sub Notebook", "Space-saving", "Lunch Box",
-	"Main Server Chassis", "Expansion Chassis", "SubChassis",
-	"Bus Expansion Chassis", "Peripheral Chassis", "RAID Chassis",
-	"Rack Mount Chassis"
-};
+struct fru_multirec_picmgext_header {
+	unsigned char mfg_id[3];
+#define FRU_PICMG_BACKPLANE_P2P			0x04
+#define FRU_PICMG_ADDRESS_TABLE			0x10
+#define FRU_PICMG_SHELF_POWER_DIST		0x11
+#define FRU_PICMG_SHELF_ACTIVATION		0x12
+#define FRU_PICMG_SHMC_IP_CONN			0x13
+#define FRU_PICMG_BOARD_P2P				0x14
+#define FRU_AMC_CURRENT					0x16
+#define FRU_AMC_ACTIVATION				0x17
+#define FRU_AMC_CARRIER_P2P				0x18
+#define FRU_AMC_P2P						0x19
+#define FRU_AMC_CARRIER_INFO			0x1a
+	unsigned char record_id;
+	unsigned char record_version;
+} __attribute__ ((packed));

-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);
+struct fru_picmgext_guid {
+	unsigned char guid[16];
+} __attribute__ ((packed));

-#endif /* IPMI_FRU_H */
+struct fru_picmgext_link_desc {
+#ifndef WORDS_BIGENDIAN
+	unsigned int designator:12;
+#define FRU_PICMGEXT_LINK_TYPE_BASE					0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET		0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND	0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR			0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE					0x05
+	unsigned int type:8;
+	unsigned int ext:4;
+	unsigned int grouping:8;
+#else
+	unsigned int grouping:8;
+	unsigned int ext:4;
+#define FRU_PICMGEXT_LINK_TYPE_BASE					0x01
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET		0x02
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND	0x03
+#define FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR			0x04
+#define FRU_PICMGEXT_LINK_TYPE_PCIE					0x05
+	unsigned int type:8;
+	unsigned int designator:12;
+#endif
+} __attribute__ ((packed));
+
+struct fru_picmgext_chn_desc {
+#ifndef WORDS_BIGENDIAN
+	unsigned char remote_slot:8;
+	unsigned char remote_chn:5;
+	unsigned char local_chn:5;
+	unsigned char:6;
+#else
+	unsigned char:6;
+	unsigned char local_chn:5;
+	unsigned char remote_chn:5;
+	unsigned char remote_slot:8;
+#endif
+} __attribute__ ((packed));
+
+struct fru_picmgext_slot_desc {
+	unsigned char chan_type;
+	unsigned char slot_addr;
+	unsigned char chn_count;
+} __attribute__ ((packed));
+
+#define FRU_PICMGEXT_DESIGN_IF_BASE				0x00
+#define FRU_PICMGEXT_DESIGN_IF_FABRIC			0x01
+#define FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL	0x02
+#define FRU_PICMGEXT_DESIGN_IF_RESERVED			0x03
+
+struct fru_picmgext_activation_record {
+	unsigned char ibmb_addr;
+	unsigned char max_module_curr;
+	unsigned char reserved;
+} __attribute__ ((packed));
+
+struct fru_picmgext_carrier_p2p_record {
+	unsigned char resource_id;
+	unsigned char p2p_count;
+} __attribute__ ((packed));
+
+struct fru_picmgext_carrier_p2p_descriptor {
+#ifndef WORDS_BIGENDIAN
+	unsigned char remote_resource_id;
+	unsigned short remote_port:5;
+	unsigned short local_port:5;
+	unsigned short reserved:6;
+#else
+	unsigned short reserved:6;
+	unsigned short local_port:5;
+	unsigned short remote_port:5;
+	unsigned char remote_resource_id;
+#endif
+} __attribute__ ((packed));
+
+static const char *chassis_type_desc[] __attribute__ ((unused)) = {
+"Unspecified", "Other", "Unknown",
+	    "Desktop", "Low Profile Desktop", "Pizza Box",
+	    "Mini Tower", "Tower",
+	    "Portable", "LapTop", "Notebook", "Hand Held",
+	    "Docking Station", "All in One", "Sub Notebook",
+	    "Space-saving", "Lunch Box", "Main Server Chassis",
+	    "Expansion Chassis", "SubChassis", "Bus Expansion Chassis",
+	    "Peripheral Chassis", "RAID Chassis", "Rack Mount Chassis"};
+
+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);
+
+#endif				/* IPMI_FRU_H */
--- a/ipmitool/include/ipmitool/ipmi_fwum.h
+++ b/ipmitool/include/ipmitool/ipmi_fwum.h
@ -0,0 +1,46 @@
+/*
+ * 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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#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 */
--- a/ipmitool/include/ipmitool/ipmi_intf.h
+++ b/ipmitool/include/ipmitool/ipmi_intf.h
@ -68,7 +68,7 @@ enum LANPLUS_SESSION_STATE {

 struct ipmi_session {
 	uint8_t hostname[64];
-	uint8_t username[16];
+	uint8_t username[17];
 	uint8_t authcode[IPMI_AUTHCODE_BUFFER_SIZE + 1];
 	uint8_t challenge[16];
 	uint8_t authtype;
@ -82,9 +82,11 @@ struct ipmi_session {
 	uint8_t authextra;
 	uint8_t privlvl;
 	uint8_t cipher_suite_id;
+	char sol_escape_char;
 	int password;
 	int port;
 	int active;
+	int retry;

 	uint32_t session_id;
 	uint32_t in_seq;
@ -148,17 +150,32 @@ struct ipmi_session {
 	} sol_data;
 };

+struct ipmi_cmd {
+	int (*func)(struct ipmi_intf * intf, int argc, char ** argv);
+	const char * name;
+	const char * desc;
+};
+
+struct ipmi_intf_support {
+	const char * name;
+	int supported;
+};
+
 struct ipmi_intf {
 	char name[16];
 	char desc[128];
 	int fd;
 	int opened;
 	int abort;
+	int noanswer;

 	struct ipmi_session * session;
 	struct ipmi_oem_handle * oem;
+	struct ipmi_cmd * cmdlist;
 	uint32_t my_addr;
 	uint32_t target_addr;
+	uint8_t target_lun;
+	uint8_t target_channel;

 	int (*setup)(struct ipmi_intf * intf);
 	int (*open)(struct ipmi_intf * intf);
@ -171,15 +188,19 @@ struct ipmi_intf {
 };

 struct ipmi_intf * ipmi_intf_load(char * name);
-void ipmi_intf_print(void);
+void ipmi_intf_print(struct ipmi_intf_support * intflist);

 void ipmi_intf_session_set_hostname(struct ipmi_intf * intf, char * hostname);
 void ipmi_intf_session_set_username(struct ipmi_intf * intf, char * username);
 void ipmi_intf_session_set_password(struct ipmi_intf * intf, char * password);
 void ipmi_intf_session_set_privlvl(struct ipmi_intf * intf, uint8_t privlvl);
 void ipmi_intf_session_set_cipher_suite_id(struct ipmi_intf * intf, uint8_t cipher_suite_id);
+void ipmi_intf_session_set_sol_escape_char(struct ipmi_intf * intf, char sol_escape_char);
+void ipmi_intf_session_set_kgkey(struct ipmi_intf * intf, char * kgkey);
 void ipmi_intf_session_set_port(struct ipmi_intf * intf, int port);
 void ipmi_intf_session_set_authtype(struct ipmi_intf * intf, uint8_t authtype);
+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);

 #endif /* IPMI_INTF_H */
--- a/ipmitool/include/ipmitool/ipmi_lanp.h
+++ b/ipmitool/include/ipmitool/ipmi_lanp.h
@ -46,7 +46,7 @@
 # define IPMI_LAN_SUSPEND_ARP_GRAT (1)
 #define IPMI_LAN_GET_STAT	0x04

-#define IPMI_CHANNEL_NUMBER_MAX	0xd
+#define IPMI_CHANNEL_NUMBER_MAX	0xe

 #define IPMI_LANP_TIMEOUT		3
 #define IPMI_LANP_RETRIES		10
--- a/ipmitool/include/ipmitool/ipmi_main.h
+++ b/ipmitool/include/ipmitool/ipmi_main.h
@ -0,0 +1,46 @@
+/*
+ * 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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#ifndef IPMI_MAIN_H
+#define IPMI_MAIN_H
+
+#include <ipmitool/ipmi_intf.h>
+
+int ipmi_main(int argc, char ** argv, struct ipmi_cmd * cmdlist, struct ipmi_intf_support * intflist);
+void ipmi_cmd_print(struct ipmi_cmd * cmdlist);
+int ipmi_cmd_run(struct ipmi_intf * intf, char * name, int argc, char ** argv);
+
+#endif /* IPMI_MAIN_H */
--- a/ipmitool/include/ipmitool/ipmi_mc.h
+++ b/ipmitool/include/ipmitool/ipmi_mc.h
@ -39,13 +39,13 @@

 #include <ipmitool/ipmi.h>

-#define BMC_GET_DEVICE_ID		0x01
-#define BMC_COLD_RESET			0x02
-#define BMC_WARM_RESET			0x03
-#define BMC_GET_SELF_TEST		0x04
-#define BMC_SET_GLOBAL_ENABLES		0x2e
-#define BMC_GET_GLOBAL_ENABLES		0x2f
-#define BMC_GET_GUID			0x37
+#define BMC_GET_DEVICE_ID	0x01
+#define BMC_COLD_RESET		0x02
+#define BMC_WARM_RESET		0x03
+#define BMC_GET_SELF_TEST	0x04
+#define BMC_SET_GLOBAL_ENABLES	0x2e
+#define BMC_GET_GLOBAL_ENABLES	0x2f
+#define BMC_GET_GUID		0x37

 int ipmi_mc_main(struct ipmi_intf *, int, char **);

@ -65,15 +65,15 @@ struct ipm_devid_rsp {
 	uint8_t aux_fw_rev[4];
 } __attribute__ ((packed));

-#define IPM_DEV_DEVICE_ID_SDR_MASK     (0x80) /* 1 = provides SDRs      */
-#define IPM_DEV_DEVICE_ID_REV_MASK     (0x07) /* BCD-enoded             */
+#define IPM_DEV_DEVICE_ID_SDR_MASK     (0x80)	/* 1 = provides SDRs      */
+#define IPM_DEV_DEVICE_ID_REV_MASK     (0x07)	/* BCD-enoded             */

-#define IPM_DEV_FWREV1_AVAIL_MASK      (0x80) /* 0 = normal operation   */
-#define IPM_DEV_FWREV1_MAJOR_MASK      (0x3f) /* Major rev, BCD-encoded */
+#define IPM_DEV_FWREV1_AVAIL_MASK      (0x80)	/* 0 = normal operation   */
+#define IPM_DEV_FWREV1_MAJOR_MASK      (0x3f)	/* Major rev, BCD-encoded */

-#define IPM_DEV_IPMI_VER_MAJOR_MASK    (0x0F) /* Major rev, BCD-encoded */
-#define IPM_DEV_IPMI_VER_MINOR_MASK    (0xF0) /* Minor rev, BCD-encoded */
-#define IPM_DEV_IPMI_VER_MINOR_SHIFT   (4)    /* Minor rev shift        */
+#define IPM_DEV_IPMI_VER_MAJOR_MASK    (0x0F)	/* Major rev, BCD-encoded */
+#define IPM_DEV_IPMI_VER_MINOR_MASK    (0xF0)	/* Minor rev, BCD-encoded */
+#define IPM_DEV_IPMI_VER_MINOR_SHIFT   (4)	/* Minor rev shift        */
 #define IPM_DEV_IPMI_VERSION_MAJOR(x) \
 	(x & IPM_DEV_IPMI_VER_MAJOR_MASK)
 #define IPM_DEV_IPMI_VERSION_MINOR(x) \
@ -82,6 +82,26 @@ struct ipm_devid_rsp {
 #define IPM_DEV_MANUFACTURER_ID(x) \
 	((uint32_t) ((x[2] & 0x0F) << 16 | x[1] << 8 | x[0]))

-#define IPM_DEV_ADTL_SUPPORT_BITS      (8) 
+#define IPM_DEV_ADTL_SUPPORT_BITS      (8)

-#endif /*IPMI_MC_H*/
+struct ipm_selftest_rsp {
+	unsigned char code;
+	unsigned char test;
+} __attribute__ ((packed));
+
+#define IPM_SFT_CODE_OK			0x55
+#define IPM_SFT_CODE_NOT_IMPLEMENTED	0x56
+#define IPM_SFT_CODE_DEV_CORRUPTED	0x57
+#define IPM_SFT_CODE_FATAL_ERROR	0x58
+#define IPM_SFT_CODE_RESERVED		0xff
+
+#define IPM_SELFTEST_SEL_ERROR		0x80
+#define IPM_SELFTEST_SDR_ERROR		0x40
+#define IPM_SELFTEST_FRU_ERROR		0x20
+#define IPM_SELFTEST_IPMB_ERROR		0x10
+#define IPM_SELFTEST_SDRR_EMPTY		0x08
+#define IPM_SELFTEST_INTERNAL_USE	0x04
+#define IPM_SELFTEST_FW_BOOTBLOCK	0x02
+#define IPM_SELFTEST_FW_CORRUPTED	0x01
+
+#endif				/*IPMI_MC_H */
--- a/ipmitool/include/ipmitool/ipmi_picmg.h
+++ b/ipmitool/include/ipmitool/ipmi_picmg.h
@ -0,0 +1,75 @@
+
+/*
+	(C) Kontron
+*/
+
+#ifndef _IPMI_PICMG_H_
+#define _IPMI_PICMG_H_
+
+#include <ipmitool/ipmi.h>
+
+/* PICMG commands */
+#define PICMG_GET_PICMG_PROPERTIES_CMD			0x00
+#define PICMG_GET_ADDRESS_INFO_CMD 				0x01
+#define PICMG_GET_SHELF_ADDRESS_INFO_CMD		0x02
+#define PICMG_SET_SHELF_ADDRESS_INFO_CMD		0x03
+#define PICMG_FRU_CONTROL_CMD					0x04
+#define PICMG_GET_FRU_LED_PROPERTIES_CMD		0x05
+#define PICMG_GET_LED_COLOR_CAPABILITIES_CMD 	0x06
+#define PICMG_SET_FRU_LED_STATE_CMD				0x07
+#define PICMG_GET_FRU_LED_STATE_CMD				0x08
+#define PICMG_SET_IPMB_CMD						0x09
+#define PICMG_SET_FRU_POLICY_CMD				0x0A
+#define PICMG_GET_FRU_POLICY_CMD				0x0B
+#define PICMG_FRU_ACTIVATION_CMD				0x0C
+#define PICMG_GET_DEVICE_LOCATOR_RECORD_CMD		0x0D
+#define PICMG_SET_PORT_STATE_CMD				0x0E
+#define PICMG_GET_PORT_STATE_CMD				0x0F
+#define PICMG_COMPUTE_POWER_PROPERTIES_CMD		0x10
+#define PICMG_SET_POWER_LEVEL_CMD				0x11
+#define PICMG_GET_POWER_LEVEL_CMD				0x12
+#define PICMG_RENEGOTIATE_POWER_CMD				0x13
+#define PICMG_GET_FAN_SPEED_PROPERTIES_CMD		0x14
+#define PICMG_SET_FAN_LEVEL_CMD					0x15
+#define PICMG_GET_FAN_LEVEL_CMD					0x16
+#define PICMG_BUSED_RESOURCE_CMD				0x17
+
+/* Site Types */
+#define PICMG_ATCA_BOARD		0x00
+#define PICMG_POWER_ENTRY		0x01
+#define PICMG_SHELF_FRU			0x02
+#define PICMG_DEDICATED_SHMC 	0x03
+#define PICMG_FAN_TRAY			0x04
+#define PICMG_FAN_FILTER_TRAY	0x05
+#define PICMG_ALARM				0x06
+#define PICMG_AMC				0x07
+#define PICMG_PMC				0x08
+#define PICMG_RTM				0x09
+
+
+
+struct picmg_set_fru_activation_cmd {
+	unsigned char	picmg_id;     	/* always 0*/
+	unsigned char	fru_id;      	/* threshold setting mask */
+	unsigned char	fru_state;		/* fru activation/deactivation */
+} __attribute__ ((packed));
+
+
+
+/* the LED color capabilities */
+static unsigned char* led_color_str[] = {
+	"reserved",
+	"BLUE",
+	"RED",
+	"GREEN",
+	"AMBER",
+	"ORANGE",
+	"WHITE",
+	"reserved"
+};
+
+
+
+int ipmi_picmg_main (struct ipmi_intf * intf, int argc, char ** argv);
+
+#endif
--- a/ipmitool/include/ipmitool/ipmi_raw.h
+++ b/ipmitool/include/ipmitool/ipmi_raw.h
@ -40,5 +40,7 @@
 #include <ipmitool/ipmi.h>

 int ipmi_raw_main(struct ipmi_intf * intf, int argc, char ** argv);
+struct ipmi_rs * ipmi_master_write_read(struct ipmi_intf * intf, uint8_t addr, uint8_t * wdata, uint8_t wsize, uint8_t rsize);
+int ipmi_rawi2c_main(struct ipmi_intf * intf, int argc, char ** argv);

 #endif /* IPMI_RAW_H */
--- a/ipmitool/include/ipmitool/ipmi_sdr.h
+++ b/ipmitool/include/ipmitool/ipmi_sdr.h
--- a/ipmitool/include/ipmitool/ipmi_sel.h
+++ b/ipmitool/include/ipmitool/ipmi_sel.h
@ -39,6 +39,7 @@

 #include <inttypes.h>
 #include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_sdr.h>

 #define IPMI_CMD_GET_SEL_INFO		0x40
 #define IPMI_CMD_GET_SEL_ALLOC_INFO	0x41
@ -67,43 +68,52 @@ struct sel_get_rq {
 	uint8_t	length;
 } __attribute__ ((packed));

-struct sel_event_record {
-	uint16_t	record_id;
-	uint8_t	record_type;
+struct standard_spec_sel_rec{
 	uint32_t	timestamp;
 	uint16_t	gen_id;
 	uint8_t	evm_rev;
 	uint8_t	sensor_type;
 	uint8_t	sensor_num;
+#if WORDS_BIGENDIAN
+	uint8_t	event_dir  : 1;
+	uint8_t	event_type : 7;
+#else
 	uint8_t	event_type : 7;
 	uint8_t	event_dir  : 1;
+#endif
 #define DATA_BYTE2_SPECIFIED_MASK 0xc0    /* event_data[0] bit mask */
 #define DATA_BYTE3_SPECIFIED_MASK 0x30    /* event_data[0] bit mask */
 #define EVENT_OFFSET_MASK         0x0f    /* event_data[0] bit mask */
 	uint8_t	event_data[3];
-} __attribute__ ((packed));
+};

-struct sel_oem_record_ts {
-	uint16_t	next_id;
+#define SEL_OEM_TS_DATA_LEN		6
+#define SEL_OEM_NOTS_DATA_LEN		13
+struct oem_ts_spec_sel_rec{
+	uint32_t timestamp;
+	uint8_t manf_id[3];
+	uint8_t	oem_defined[SEL_OEM_TS_DATA_LEN];
+};
+
+struct oem_nots_spec_sel_rec{
+	uint8_t oem_defined[SEL_OEM_NOTS_DATA_LEN];
+};
+
+struct sel_event_record {
 	uint16_t	record_id;
 	uint8_t	record_type;
-	uint32_t	timestamp;
-	uint8_t	mfg_id[3];
-	uint8_t	oem_defined[6];
-} __attribute__ ((packed));
-
-struct sel_oem_record_nots {
-	uint16_t	next_id;
-	uint16_t	record_id;
-	uint8_t	record_type;
-	uint8_t	oem_defined[13];
+	union{
+		struct standard_spec_sel_rec standard_type;
+		struct oem_ts_spec_sel_rec oem_ts_type;
+		struct oem_nots_spec_sel_rec oem_nots_type;
+	} sel_type;
 } __attribute__ ((packed));

 struct ipmi_event_sensor_types {
 	uint8_t	code;
 	uint8_t	offset;
 #define ALL_OFFSETS_SPECIFIED  0xff
-        uint8_t   data;
+	uint8_t   data;
 	uint8_t	class;
 	const char	* type;
 	const char	* desc;
@ -111,18 +121,18 @@ struct ipmi_event_sensor_types {

 static struct ipmi_event_sensor_types generic_event_types[] __attribute__((unused)) = {
 	/* Threshold Based States */
-	{ 0x01, 0x00, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-critical - going low" },
-	{ 0x01, 0x01, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-critical - going high" },
-	{ 0x01, 0x02, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Critical - going low" },
-	{ 0x01, 0x03, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Critical - going high" },
-	{ 0x01, 0x04, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-recoverable - going low" },
-	{ 0x01, 0x05, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-recoverable - going high" },
-	{ 0x01, 0x06, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-critical - going low" },
-	{ 0x01, 0x07, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-critical - going high" },
-	{ 0x01, 0x08, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Critical - going low" },
-	{ 0x01, 0x09, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Critical - going high" },
-	{ 0x01, 0x0a, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-recoverable - going low" },
-	{ 0x01, 0x0b, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-recoverable - going high" },
+	{ 0x01, 0x00, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-critical going low " },
+	{ 0x01, 0x01, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-critical going high" },
+	{ 0x01, 0x02, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Critical going low " },
+	{ 0x01, 0x03, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Critical going high" },
+	{ 0x01, 0x04, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-recoverable going low " },
+	{ 0x01, 0x05, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Lower Non-recoverable going high" },
+	{ 0x01, 0x06, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-critical going low " },
+	{ 0x01, 0x07, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-critical going high" },
+	{ 0x01, 0x08, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Critical going low " },
+	{ 0x01, 0x09, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Critical going high" },
+	{ 0x01, 0x0a, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-recoverable going low " },
+	{ 0x01, 0x0b, 0xff, IPMI_EVENT_CLASS_THRESHOLD, "Threshold", "Upper Non-recoverable going high" },
 	/* DMI-based "usage state" States */
 	{ 0x02, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Usage State", "Transition to Idle" },
 	{ 0x02, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Usage State", "Transition to Active" },
@ -147,8 +157,8 @@ static struct ipmi_event_sensor_types generic_event_types[] __attribute__((unuse
 	{ 0x07, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Severity State", "Monitor" },
 	{ 0x07, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Severity State", "Informational" },
 	/* Availability Status States */
-	{ 0x08, 0x00, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Removed/Absent" },
-	{ 0x08, 0x01, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Inserted/Present" },
+	{ 0x08, 0x00, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Absent" },
+	{ 0x08, 0x01, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Present" },
 	{ 0x09, 0x00, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Disabled" },
 	{ 0x09, 0x01, 0xff, IPMI_EVENT_CLASS_DIGITAL, "Availability State",  "Device Enabled" },
 	{ 0x0a, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Availability State", "Transition to Running" },
@ -190,7 +200,7 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x05, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "I/O Card area intrusion" },
 	{ 0x05, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "Processor area intrusion" },
 	{ 0x05, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "System unplugged from LAN" },
-	{ 0x05, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "Unauthorized dock/undock" },
+	{ 0x05, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "Unauthorized dock" },
 	{ 0x05, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Physical Security", "FAN area intrusion" },

 	{ 0x06, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Platform Security", "Front Panel Lockout violation attempted" },
@ -210,6 +220,7 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x07, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Processor", "Presence detected" },
 	{ 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" },

 	{ 0x08, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Presence detected" },
 	{ 0x08, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Failure detected" },
@ -217,6 +228,10 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x08, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Power Supply AC lost" },
 	{ 0x08, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "AC lost or out-of-range" },
 	{ 0x08, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "AC out-of-range, but present" },
+	{ 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, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Supply", "Config Error" },

 	{ 0x09, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Unit", "Power off/down" },
 	{ 0x09, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Power Unit", "Power cycle" },
@ -236,31 +251,108 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x0c, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Memory Scrub Failed" },
 	{ 0x0c, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Memory Device Disabled" },
 	{ 0x0c, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Correctable ECC logging limit reached" },
+	{ 0x0c, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Memory", "Presence Detected" },
+	{ 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" },
+
+	{ 0x0d, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Drive Present" },
+	{ 0x0d, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Drive Fault" },
+	{ 0x0d, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Predictive Failure" },
+	{ 0x0d, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Hot Spare" },
+	{ 0x0d, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Parity Check In Progress" },
+	{ 0x0d, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "In Critical Array" },
+	{ 0x0d, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "In Failed Array" },
+	{ 0x0d, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Rebuild In Progress" },
+	{ 0x0d, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", "Rebuild Aborted" },

-	{ 0x0d, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Drive Slot", NULL },
 	{ 0x0e, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "POST Memory Resize", NULL },

-	{ 0x0f, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Error" },
-	{ 0x0f, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Hang" },
-	{ 0x0f, 0x02, 0x00, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Progress 1" },
-	{ 0x0f, 0x02, 0x01, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Progress 2" },
-	{ 0x0f, 0x02, 0x02, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Progress 3" },
-	{ 0x0f, 0x02, 0x03, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Progress 4" },
-	{ 0x0f, 0x02, 0x04, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "Progress 5" },
-	{ 0x0f, 0x02, 0x13, IPMI_EVENT_CLASS_DISCRETE, "System Firmware", "System Boot Initiated" },
+	{ 0x0f, 0x00, 0x00, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unspecified" },
+	{ 0x0f, 0x00, 0x01, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "No system memory installed" },
+	{ 0x0f, 0x00, 0x02, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "No usable system memory" },
+	{ 0x0f, 0x00, 0x03, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable IDE device failure" },
+	{ 0x0f, 0x00, 0x04, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable system-board failure" },
+	{ 0x0f, 0x00, 0x05, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable diskette failure" },
+	{ 0x0f, 0x00, 0x06, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable hard-disk controller failure" },
+	{ 0x0f, 0x00, 0x07, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable PS/2 or USB keyboard failure" },
+	{ 0x0f, 0x00, 0x08, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Removable boot media not found" },
+	{ 0x0f, 0x00, 0x09, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unrecoverable video controller failure" },
+	{ 0x0f, 0x00, 0x0a, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "No video device selected" },
+	{ 0x0f, 0x00, 0x0b, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "BIOS corruption detected" },
+	{ 0x0f, 0x00, 0x0c, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "CPU voltage mismatch" },
+	{ 0x0f, 0x00, 0x0d, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "CPU speed mismatch failure" },
+	{ 0x0f, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Error", "Unknown Error" },
+
+	{ 0x0f, 0x01, 0x00, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Unspecified" },
+	{ 0x0f, 0x01, 0x01, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Memory initialization" },
+	{ 0x0f, 0x01, 0x02, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Hard-disk initialization" },
+	{ 0x0f, 0x01, 0x03, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Secondary CPU Initialization" },
+	{ 0x0f, 0x01, 0x04, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "User authentication" },
+	{ 0x0f, 0x01, 0x05, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "User-initiated system setup" },
+	{ 0x0f, 0x01, 0x06, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "USB resource configuration" },
+	{ 0x0f, 0x01, 0x07, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "PCI resource configuration" },
+	{ 0x0f, 0x01, 0x08, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Option ROM initialization" },
+	{ 0x0f, 0x01, 0x09, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Video initialization" },
+	{ 0x0f, 0x01, 0x0a, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Cache initialization" },
+	{ 0x0f, 0x01, 0x0b, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "SMBus initialization" },
+	{ 0x0f, 0x01, 0x0c, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Keyboard controller initialization" },
+	{ 0x0f, 0x01, 0x0d, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Management controller initialization" },
+	{ 0x0f, 0x01, 0x0e, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Docking station attachment" },
+	{ 0x0f, 0x01, 0x0f, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Enabling docking station" },
+	{ 0x0f, 0x01, 0x10, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Docking station ejection" },
+	{ 0x0f, 0x01, 0x11, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Disabling docking station" },
+	{ 0x0f, 0x01, 0x12, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Calling operating system wake-up vector" },
+	{ 0x0f, 0x01, 0x13, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "System boot initiated" },
+	{ 0x0f, 0x01, 0x14, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Motherboard initialization" },
+	{ 0x0f, 0x01, 0x15, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "reserved" },
+	{ 0x0f, 0x01, 0x16, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Floppy initialization" },
+	{ 0x0f, 0x01, 0x17, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Keyboard test" },
+	{ 0x0f, 0x01, 0x18, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Pointing device test" },
+	{ 0x0f, 0x01, 0x19, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Primary CPU initialization" },
+	{ 0x0f, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Hang", "Unknown Hang" },
+
+	{ 0x0f, 0x02, 0x00, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Unspecified" },
+	{ 0x0f, 0x02, 0x01, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Memory initialization" },
+	{ 0x0f, 0x02, 0x02, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Hard-disk initialization" },
+	{ 0x0f, 0x02, 0x03, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Secondary CPU Initialization" },
+	{ 0x0f, 0x02, 0x04, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "User authentication" },
+	{ 0x0f, 0x02, 0x05, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "User-initiated system setup" },
+	{ 0x0f, 0x02, 0x06, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "USB resource configuration" },
+	{ 0x0f, 0x02, 0x07, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "PCI resource configuration" },
+	{ 0x0f, 0x02, 0x08, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Option ROM initialization" },
+	{ 0x0f, 0x02, 0x09, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Video initialization" },
+	{ 0x0f, 0x02, 0x0a, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Cache initialization" },
+	{ 0x0f, 0x02, 0x0b, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "SMBus initialization" },
+	{ 0x0f, 0x02, 0x0c, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Keyboard controller initialization" },
+	{ 0x0f, 0x02, 0x0d, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Management controller initialization" },
+	{ 0x0f, 0x02, 0x0e, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Docking station attachment" },
+	{ 0x0f, 0x02, 0x0f, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Enabling docking station" },
+	{ 0x0f, 0x02, 0x10, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Docking station ejection" },
+	{ 0x0f, 0x02, 0x11, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Disabling docking station" },
+	{ 0x0f, 0x02, 0x12, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Calling operating system wake-up vector" },
+	{ 0x0f, 0x02, 0x13, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "System boot initiated" },
+	{ 0x0f, 0x02, 0x14, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Motherboard initialization" },
+	{ 0x0f, 0x02, 0x15, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "reserved" },
+	{ 0x0f, 0x02, 0x16, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Floppy initialization" },
+	{ 0x0f, 0x02, 0x17, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Keyboard test" },
+	{ 0x0f, 0x02, 0x18, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Pointing device test" },
+	{ 0x0f, 0x02, 0x19, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Primary CPU initialization" },
+	{ 0x0f, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Firmware Progress", "Unknown Progress" },

 	{ 0x10, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "Correctable memory error logging disabled" },
 	{ 0x10, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "Event logging disabled" },
 	{ 0x10, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "Log area reset/cleared" },
 	{ 0x10, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "All event logging disabled" },
 	{ 0x10, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "Log full" },
+	{ 0x10, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Event Logging Disabled", "Log almost full" },

 	{ 0x11, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "BIOS Reset" },
 	{ 0x11, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS Reset" },
 	{ 0x11, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS Shut Down" },
 	{ 0x11, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS Power Down" },
 	{ 0x11, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS Power Cycle" },
-	{ 0x11, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS NMI/diag Interrupt" },
+	{ 0x11, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS NMI/Diag Interrupt" },
 	{ 0x11, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS Expired" },
 	{ 0x11, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Watchdog 1", "OS pre-timeout Interrupt" },

@ -269,9 +361,9 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x12, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Event", "Undetermined system hardware failure" },
 	{ 0x12, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Event", "Entry added to auxiliary log" },
 	{ 0x12, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Event", "PEF Action" },
-	{ 0x12, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Event", "Timestamp Clock Sync." },
+	{ 0x12, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Event", "Timestamp Clock Sync" },

-	{ 0x13, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Front Panel NMI" },
+	{ 0x13, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "NMI/Diag Interrupt" },
 	{ 0x13, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Bus Timeout" },
 	{ 0x13, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "I/O Channel check NMI" },
 	{ 0x13, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Software NMI" },
@ -281,10 +373,13 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x13, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Critical Interrupt", "Bus Correctable error" },
 	{ 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" },

 	{ 0x14, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "Power Button pressed" },
 	{ 0x14, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "Sleep Button pressed" },
 	{ 0x14, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "Reset Button pressed" },
+	{ 0x14, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "FRU Latch" },
+	{ 0x14, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Button", "FRU Service" },

 	{ 0x15, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Module/Board", NULL },
 	{ 0x16, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Microcontroller/Coprocessor", NULL },
@ -292,7 +387,10 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x18, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Chassis", NULL },
 	{ 0x19, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Chip Set", NULL },
 	{ 0x1a, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Other FRU", NULL },
-	{ 0x1b, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Cable/Interconnect", NULL },
+
+	{ 0x1b, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Cable/Interconnect", "Connected" },
+	{ 0x1b, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Cable/Interconnect", "Config Error" },
+
 	{ 0x1c, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Terminator", NULL },

 	{ 0x1d, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "Initiated by power up" },
@ -300,6 +398,9 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x1d, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "Initiated by warm reset" },
 	{ 0x1d, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "User requested PXE boot" },
 	{ 0x1d, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "Automatic boot to diagnostic" },
+	{ 0x1d, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "OS initiated hard reset" },
+	{ 0x1d, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "OS initiated warm reset" },
+	{ 0x1d, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System Boot Initiated", "System Restart" },

 	{ 0x1e, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Boot Error", "No bootable media" },
 	{ 0x1e, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Boot Error", "Non-bootable disk in drive" },
@ -315,18 +416,23 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 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" },

-	{ 0x20, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Critical Stop", "Stop during OS load/init" },
-	{ 0x20, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Critical Stop", "Run-time stop" },
+	{ 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" },
+	{ 0x20, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "OS graceful stop" },
+	{ 0x20, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "OS graceful shutdown" },
+	{ 0x20, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "PEF initiated soft shutdown" },
+	{ 0x20, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "OS Stop/Shutdown", "Agent not responding" },

-	{ 0x21, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Fault Status asserted" },
-	{ 0x21, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Identify Status asserted" },
-	{ 0x21, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Device installed/attached" },
-	{ 0x21, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Ready for device installation" },
-	{ 0x21, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Ready for device removal" },
-	{ 0x21, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Slot Power is off" },
-	{ 0x21, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Device removal request" },
-	{ 0x21, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Interlock asserted" },
-	{ 0x21, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Slot is disabled" },
+	{ 0x21, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Fault Status" },
+	{ 0x21, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Identify Status" },
+	{ 0x21, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Device Installed" },
+	{ 0x21, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Ready for Device Installation" },
+	{ 0x21, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Ready for Device Removal" },
+	{ 0x21, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Slot Power is Off" },
+	{ 0x21, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Device Removal Request" },
+	{ 0x21, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Interlock" },
+	{ 0x21, 0x08, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Slot is Disabled" },
+	{ 0x21, 0x09, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Slot/Connector", "Spare Device" },

 	{ 0x22, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System ACPI Power State", "S0/G0: working" },
 	{ 0x22, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "System ACPI Power State", "S1: sleeping with system hw & processor context maintained" },
@ -371,18 +477,77 @@ static struct ipmi_event_sensor_types sensor_specific_types[] __attribute__((unu
 	{ 0x28, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Management Subsystem Health", "Controller access degraded or unavailable" },
 	{ 0x28, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Management Subsystem Health", "Management controller off-line" },
 	{ 0x28, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Management Subsystem Health", "Management controller unavailable" },
+	{ 0x28, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Management Subsystem Health", "Sensor failure" },
+	{ 0x28, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Management Subsystem Health", "FRU failure" },

 	{ 0x29, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Battery", "Low" },
 	{ 0x29, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Battery", "Failed" },
 	{ 0x29, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Battery", "Presence Detected" },

+	{ 0x2b, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Hardware change detected" },
+	{ 0x2b, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Firmware or software change detected" },
+	{ 0x2b, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Hardware incompatibility detected" },
+	{ 0x2b, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Firmware or software incompatibility detected" },
+	{ 0x2b, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Invalid or unsupported hardware version" },
+	{ 0x2b, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Invalid or unsupported firmware or software version" },
+	{ 0x2b, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Hardware change success" },
+	{ 0x2b, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Version Change", "Firmware or software change success" },
+
+	{ 0x2c, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Not Installed" },
+	{ 0x2c, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Inactive" },
+	{ 0x2c, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Activation Requested" },
+	{ 0x2c, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Activation in Progress" },
+	{ 0x2c, 0x04, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Active" },
+	{ 0x2c, 0x05, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Deactivation Requested" },
+	{ 0x2c, 0x06, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Deactivation in Progress" },
+	{ 0x2c, 0x07, 0xff, IPMI_EVENT_CLASS_DISCRETE, "FRU State", "Communication lost" },
+
+ 	{ 0xF0, 0x00, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M0" },
+ 	{ 0xF0, 0x01, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M1" },
+ 	{ 0xF0, 0x02, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M2" },
+ 	{ 0xF0, 0x03, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M3" },
+ 	{ 0xF0, 0x04, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M4" },
+ 	{ 0xF0, 0x05, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M5" },
+ 	{ 0xF0, 0x06, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M6" },
+ 	{ 0xF0, 0x06, 0xFF, IPMI_EVENT_CLASS_DISCRETE, "FRU Hot Swap", "Transition to M7" },
+ 
+ 	{ 0xF1, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "IPMB-0 Status", "IPMB-A disabled, IPMB-B disabled" },
+ 	{ 0xF1, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "IPMB-0 Status", "IPMB-A enabled, IPMB-B disabled" },
+ 	{ 0xF1, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "IPMB-0 Status", "IPMB-A disabled, IPMB-B enabled" },
+ 	{ 0xF1, 0x03, 0xff, IPMI_EVENT_CLASS_DISCRETE, "IPMB-0 Status", "IPMB-A enabled, IPMP-B enabled" },
+ 
+ 	{ 0xF2, 0x00, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Module Hot Swap", "Module Handle Closed" },
+ 	{ 0xF2, 0x01, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Module Hot Swap", "Module Handle Opened" },
+ 	{ 0xF2, 0x02, 0xff, IPMI_EVENT_CLASS_DISCRETE, "Module Hot Swap", "Quiesced" },
+
+	{ 0xC0, 0x00, 0xff, 0x00, "OEM", NULL },
+
 	{ 0x00, 0x00, 0x00, 0x00, NULL, NULL },
 };

+
+/* These values are IANA numbers */
+typedef enum IPMI_OEM {
+    IPMI_OEM_UNKNOWN    = 0,
+    IPMI_OEM_SUN        = 42,
+    IPMI_OEM_INTEL      = 343,
+    IPMI_OEM_TYAN       = 6653,
+    IPMI_OEM_NEWISYS    = 9237,
+    IPMI_OEM_SUPERMICRO = 10876,
+    IPMI_OEM_KONTRON    = 15000,
+} IPMI_OEM;
+
 int ipmi_sel_main(struct ipmi_intf *, int, char **);
-void ipmi_sel_print_std_entry(struct sel_event_record * evt);
-void ipmi_sel_print_std_entry_verbose(struct sel_event_record * evt);
-void ipmi_get_event_desc(struct sel_event_record * rec, char ** desc);
+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);
+void ipmi_sel_print_extended_entry(struct ipmi_intf * intf, struct sel_event_record * evt);
+void ipmi_sel_print_extended_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt);
+void ipmi_get_event_desc(struct ipmi_intf * intf, struct sel_event_record * rec, char ** desc);
 const char * ipmi_sel_get_sensor_type(uint8_t code);
+const char * ipmi_sel_get_sensor_type_offset(uint8_t code, uint8_t offset);
+uint16_t ipmi_sel_get_std_entry(struct ipmi_intf * intf, uint16_t id, struct sel_event_record * evt);
+char * get_newisys_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec);
+IPMI_OEM ipmi_get_oem(struct ipmi_intf * intf);
+char * ipmi_get_oem_desc(struct ipmi_intf * intf, struct sel_event_record * rec);

 #endif /* IPMI_SEL_H */
--- a/ipmitool/include/ipmitool/ipmi_sensor.h
+++ b/ipmitool/include/ipmitool/ipmi_sensor.h
@ -42,13 +42,6 @@
 #include <ipmitool/ipmi.h>
 #include <ipmitool/ipmi_sdr.h>

-/* ipmi sensor commands */
-#define GET_SENSOR_READING      0x2d
-#define GET_SENSOR_FACTORS      0x23
-#define SET_SENSOR_THRESHOLDS   0x26
-#define GET_SENSOR_THRESHOLDS   0x27
-#define GET_SENSOR_TYPE         0x2f
-
 /* threshold specification bits for analog sensors for get sensor threshold command 
 * and set sensor threshold command 
 */
--- a/ipmitool/include/ipmitool/ipmi_sol.h
+++ b/ipmitool/include/ipmitool/ipmi_sol.h
@ -39,6 +39,7 @@

 #include <ipmitool/ipmi.h>

+#define SOL_ESCAPE_CHARACTER_DEFAULT        '~'

 #define IPMI_SOL_SERIAL_ALERT_MASK_SUCCEED  0x08
 #define IPMI_SOL_SERIAL_ALERT_MASK_DEFERRED 0x04
--- a/ipmitool/include/ipmitool/ipmi_strings.h
+++ b/ipmitool/include/ipmitool/ipmi_strings.h
@ -42,7 +42,7 @@
 extern const struct valstr completion_code_vals[];
 extern const struct valstr entity_id_vals[];
 extern const struct valstr entity_device_type_vals[];
-
+extern const struct valstr ipmi_netfn_vals[];
 extern const struct valstr ipmi_channel_activity_type_vals[];
 extern const struct valstr ipmi_privlvl_vals[];
 extern const struct valstr impi_bit_rate_vals[];
@ -51,9 +51,11 @@ extern const struct valstr ipmi_authtype_session_vals[];
 extern const struct valstr ipmi_authtype_vals[];
 extern const struct valstr ipmi_channel_protocol_vals[];
 extern const struct valstr ipmi_channel_medium_vals[];
+extern const struct valstr ipmi_chassis_power_control_vals[];
 extern const struct valstr ipmi_auth_algorithms[];
 extern const struct valstr ipmi_integrity_algorithms[];
 extern const struct valstr ipmi_encryption_algorithms[];
+extern const struct valstr ipmi_oem_info[];


 #endif /*IPMI_STRINGS_H*/
--- a/ipmitool/include/ipmitool/ipmi_sunoem.h
+++ b/ipmitool/include/ipmitool/ipmi_sunoem.h
@ -0,0 +1,61 @@
+/*
+ * 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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#ifndef IPMI_SUNOEM_H
+#define IPMI_SUNOEM_H
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_sdr.h>
+
+#define IPMI_NETFN_SUNOEM		0x2e
+
+#define IPMI_SUNOEM_SET_SSH_KEY		0x01
+#define IPMI_SUNOEM_DEL_SSH_KEY		0x02
+#define IPMI_SUNOEM_GET_HEALTH_STATUS	0x10
+#define IPMI_SUNOEM_SET_FAN_SPEED	0x20
+#define IPMI_SUNOEM_LED_GET		0x21
+#define IPMI_SUNOEM_LED_SET		0x22
+
+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*/
+
--- a/ipmitool/include/ipmitool/ipmi_tsol.h
+++ b/ipmitool/include/ipmitool/ipmi_tsol.h
@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2005 Tyan Computer Corp.  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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#ifndef IPMI_TSOL_H
+#define IPMI_TSOL_H
+
+#include <ipmitool/ipmi.h>
+
+#define IPMI_TSOL_CMD_SENDKEY	0x03
+#define IPMI_TSOL_CMD_START	0x06
+#define IPMI_TSOL_CMD_STOP	0x02
+
+#define IPMI_TSOL_DEF_PORT	6230
+
+int ipmi_tsol_main(struct ipmi_intf *, int, char **);
+
+#endif /* IPMI_TSOL_H */
--- a/ipmitool/lib/Makefile.am
+++ b/ipmitool/lib/Makefile.am
@ -36,11 +36,13 @@ INCLUDES			= -I$(top_srcdir)/include
 MAINTAINERCLEANFILES		= Makefile.in

 noinst_LTLIBRARIES		= libipmitool.la
-libipmitool_la_SOURCES		= helper.c ipmi_sdr.c ipmi_sel.c ipmi_sol.c ipmi_pef.c \
-				  ipmi_lanp.c ipmi_fru.c ipmi_chassis.c ipmi_mc.c log.c \
-				  dimm_spd.c ipmi_sensor.c ipmi_channel.c ipmi_event.c \
-				  ipmi_session.c ipmi_strings.c ipmi_user.c ipmi_raw.c \
-				  ipmi_oem.c ipmi_isol.c
+libipmitool_la_SOURCES	= helper.c ipmi_sdr.c ipmi_sel.c ipmi_sol.c ipmi_pef.c \
+				  ipmi_lanp.c ipmi_fru.c ipmi_chassis.c ipmi_mc.c log.c            \
+				  dimm_spd.c ipmi_sensor.c ipmi_channel.c ipmi_event.c             \
+				  ipmi_session.c ipmi_strings.c ipmi_user.c ipmi_raw.c             \
+				  ipmi_oem.c ipmi_isol.c ipmi_sunoem.c ipmi_fwum.c ipmi_picmg.c    \
+				  ipmi_main.c ipmi_tsol.c
+
 libipmitool_la_LDFLAGS		= -export-dynamic
 libipmitool_la_LIBADD		= -lm
 libipmitool_la_DEPENDENCIES	= 
--- a/ipmitool/lib/helper.c
+++ b/ipmitool/lib/helper.c
@ -34,18 +34,28 @@
 * facility.
 */

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>  /* For TIOCNOTTY */
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <inttypes.h>
 #include <signal.h>
 #include <string.h>
 #include <strings.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>

+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef HAVE_PATHS_H
+# include <paths.h>  /* For _PATH_TTY */
+#endif
+
 #include <ipmitool/helper.h>
 #include <ipmitool/log.h>

@ -101,12 +111,11 @@ void printbuf(const uint8_t * buf, int len, const char * desc)
 const char * val2str(uint16_t val, const struct valstr *vs)
 {
 	static char un_str[16];
-	int i = 0;
+	int i;

-	while (vs[i].str != NULL) {
+	for (i = 0; vs[i].str != NULL; i++) {
 		if (vs[i].val == val)
 			return vs[i].str;
-		i++;
 	}

 	memset(un_str, 0, 16);
@ -117,15 +126,111 @@ const char * val2str(uint16_t val, const struct valstr *vs)

 uint16_t str2val(const char *str, const struct valstr *vs)
 {
-	int i = 0;
+	int i;

-	while (vs[i].str != NULL) {
-		if (!strncasecmp(vs[i].str, str, strlen(str)))
+	for (i = 0; vs[i].str != NULL; i++) {
+		if (strncasecmp(vs[i].str, str, __maxlen(str, vs[i].str)) == 0)
 			return vs[i].val;
-		i++;
 	}

-	return 0;
+	return vs[i].val;
+}
+
+/* print_valstr  -  print value string list to log or stdout
+ *
+ * @vs:		value string list to print
+ * @title:	name of this value string list
+ * @loglevel:	what log level to print, -1 for stdout
+ */
+void
+print_valstr(const struct valstr * vs, const char * title, int loglevel)
+{
+	int i;
+
+	if (vs == NULL)
+		return;
+
+	if (title != NULL) {
+		if (loglevel < 0)
+			printf("\n%s:\n\n");
+		else
+			lprintf(loglevel, "\n%s:\n", title);
+	}
+
+	if (loglevel < 0) {
+		printf("  VALUE\tHEX\tSTRING\n");
+		printf("==============================================\n");
+	} else {
+		lprintf(loglevel, "  VAL\tHEX\tSTRING");
+		lprintf(loglevel, "==============================================");
+	}
+
+	for (i = 0; vs[i].str != NULL; i++) {
+		if (loglevel < 0) {
+			if (vs[i].val < 256)
+				printf("  %d\t0x%02x\t%s\n", vs[i].val, vs[i].val, vs[i].str);
+			else
+				printf("  %d\t0x%04x\t%s\n", vs[i].val, vs[i].val, vs[i].str);
+		} else {
+			if (vs[i].val < 256)
+				lprintf(loglevel, "  %d\t0x%02x\t%s", vs[i].val, vs[i].val, vs[i].str);
+			else
+				lprintf(loglevel, "  %d\t0x%04x\t%s", vs[i].val, vs[i].val, vs[i].str);
+		}
+	}
+
+	if (loglevel < 0)
+		printf("\n");
+	else
+		lprintf(loglevel, "");
+}
+
+/* print_valstr_2col  -  print value string list in two columns to log or stdout
+ *
+ * @vs:		value string list to print
+ * @title:	name of this value string list
+ * @loglevel:	what log level to print, -1 for stdout
+ */
+void
+print_valstr_2col(const struct valstr * vs, const char * title, int loglevel)
+{
+	int i;
+
+	if (vs == NULL)
+		return;
+
+	if (title != NULL) {
+		if (loglevel < 0)
+			printf("\n%s:\n\n");
+		else
+			lprintf(loglevel, "\n%s:\n", title);
+	}
+
+	for (i = 0; vs[i].str != NULL; i++) {
+		if (vs[i+1].str == NULL) {
+			/* last one */
+			if (loglevel < 0) {
+				printf("  %4d  %-32s\n", vs[i].val, vs[i].str);
+			} else {
+				lprintf(loglevel, "  %4d  %-32s\n", vs[i].val, vs[i].str);
+			}
+		}
+		else {
+			if (loglevel < 0) {
+				printf("  %4d  %-32s    %4d  %-32s\n",
+				       vs[i].val, vs[i].str, vs[i+1].val, vs[i+1].str);
+			} else {
+				lprintf(loglevel, "  %4d  %-32s    %4d  %-32s\n",
+					vs[i].val, vs[i].str, vs[i+1].val, vs[i+1].str);
+			}
+			i++;
+		}
+	}
+
+	if (loglevel < 0)
+		printf("\n");
+	else
+		lprintf(loglevel, "");
 }

 /* ipmi_csum  -  calculate an ipmi checksum
@ -228,3 +333,66 @@ ipmi_open_file(const char * file, int rw)
 	return fp;
 }

+void
+ipmi_start_daemon(void)
+{
+	pid_t pid;
+	int fd;
+#ifdef SIGHUP
+	sigset_t sighup;
+#endif
+
+	/* if we are started from init no need to become daemon */
+	if (getppid() == 1)
+		return;
+
+#ifdef SIGHUP
+	sigemptyset(&sighup);
+	sigaddset(&sighup, SIGHUP);
+	if (sigprocmask(SIG_UNBLOCK, &sighup, NULL) < 0)
+		fprintf(stderr, "ERROR: could not unblock SIGHUP signal\n");
+	signal(SIGHUP, SIG_IGN);
+#endif
+#ifdef SIGTTOU
+	signal(SIGTTOU, SIG_IGN);
+#endif
+#ifdef SIGTTIN
+	signal(SIGTTIN, SIG_IGN);
+#endif
+#ifdef SIGQUIT
+	signal(SIGQUIT, SIG_IGN);
+#endif
+#ifdef SIGTSTP
+	signal(SIGTSTP, SIG_IGN);
+#endif
+
+	pid = (pid_t) fork();
+	if (pid < 0 || pid > 0)
+		exit(0);
+	
+#if defined(SIGTSTP) && defined(TIOCNOTTY)
+	if (setpgid(0, getpid()) == -1)
+		exit(1);
+	if ((fd = open(_PATH_TTY, O_RDWR)) >= 0) {
+		ioctl(fd, TIOCNOTTY, NULL);
+		close(fd);
+	}
+#else
+	if (setpgrp() == -1)
+		exit(1);
+	pid = (pid_t) fork();
+	if (pid < 0 || pid > 0)
+		exit(0);
+#endif
+
+	chdir("/");
+	umask(0);
+
+	for (fd=0; fd<64; fd++)
+		close(fd);
+
+	open("/dev/null", O_RDWR);
+	dup(0);
+	dup(0);
+}
+
--- a/ipmitool/lib/ipmi_channel.c
+++ b/ipmitool/lib/ipmi_channel.c
@ -1,4 +1,4 @@
-/*
+/* -*-mode: C; indent-tabs-mode: t; -*-
 * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
@ -193,6 +193,7 @@ ipmi_get_channel_info(struct ipmi_intf * intf, uint8_t channel)
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
 	uint8_t rqdata[2];
+	uint8_t medium;
 	struct get_channel_info_rsp   channel_info;
 	struct get_channel_access_rsp channel_access;

@ -249,6 +250,12 @@ ipmi_get_channel_info(struct ipmi_intf * intf, uint8_t channel)
 		   channel_info.vendor_id[2] << 16);


+	/* only proceed if this is LAN channel */
+	medium = ipmi_get_channel_medium(intf, channel);
+	if (medium != IPMI_CHANNEL_MEDIUM_LAN &&
+	    medium != IPMI_CHANNEL_MEDIUM_LAN_OTHER) {
+		return 0;
+	}

 	memset(&req, 0, sizeof(req));
 	rqdata[0] = channel & 0xf;
@ -475,6 +482,7 @@ ipmi_set_user_access(struct ipmi_intf * intf, int argc, char ** argv)

 	memcpy(&user_access, rsp->data, sizeof(struct get_user_access_rsp));

+	memset(&set_access, 0, sizeof(set_access));
 	set_access.change_bits = 1;
 	set_access.callin_callback = user_access.callin_callback;
 	set_access.link_auth = user_access.link_auth;
@ -544,7 +552,6 @@ iana_string(uint32_t iana)

 static int
 ipmi_get_channel_cipher_suites(struct ipmi_intf * intf,
-			       const char * which,
 			       const char * payload_type,
 			       uint8_t channel)
 {
@ -571,7 +578,7 @@ ipmi_get_channel_cipher_suites(struct ipmi_intf * intf,

 	rqdata[0] = channel;
 	rqdata[1] = ((strncmp(payload_type, "ipmi", 4) == 0)? 0: 1);
-	rqdata[2] = ((strncmp(which, "all", 3) == 0)? 0x80: 0);
+	rqdata[2] = 0x80; // Always ask for cipher suite format

 	rsp = intf->sendrecv(intf, &req);
 	if (rsp == NULL) {
@ -744,9 +751,11 @@ ipmi_get_channel_medium(struct ipmi_intf * intf, uint8_t channel)
 		return -1;
 	}
 	if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Get Channel Info command failed: %s",
+		if (rsp->ccode == 0xcc)
+			return IPMI_CHANNEL_MEDIUM_RESERVED;
+		lprintf(LOG_INFO, "Get Channel Info command failed: %s",
 		       val2str(rsp->ccode, completion_code_vals));
-		return -1;
+		return IPMI_CHANNEL_MEDIUM_RESERVED;
 	}

 	memcpy(&info, rsp->data, sizeof(struct get_channel_info_rsp));
@ -771,7 +780,7 @@ printf_channel_usage()
 	lprintf(LOG_NOTICE, "                  setaccess <channel number> "
 		"<user id> [callin=on|off] [ipmi=on|off] [link=on|off] [privilege=level]");
 	lprintf(LOG_NOTICE, "                  info      [channel number]");
-	lprintf(LOG_NOTICE, "                  getciphers <all | supported> <ipmi | sol> [channel]\n");
+	lprintf(LOG_NOTICE, "                  getciphers <ipmi | sol> [channel]\n");
 	lprintf(LOG_NOTICE, "Possible privilege levels are:");
 	lprintf(LOG_NOTICE, "   1   Callback level");
 	lprintf(LOG_NOTICE, "   2   User level");
@ -828,21 +837,19 @@ ipmi_channel_main(struct ipmi_intf * intf, int argc, char ** argv)
 		}
 	}

-	// it channel getciphers <all | supported> <ipmi | sol> [channel] 
+	// it channel getciphers <ipmi | sol> [channel] 
 	else if (strncmp(argv[0], "getciphers", 10) == 0)
 	{
-		if ((argc < 3) || (argc > 4)                                         ||
-		    (strncmp(argv[1], "all", 3) && strncmp(argv[1], "supported", 9)) ||
-		    (strncmp(argv[2], "ipmi", 4) && strncmp(argv[2], "sol",  3)))
+		if ((argc < 2) || (argc > 3)  ||
+		    (strncmp(argv[1], "ipmi", 4) && strncmp(argv[1], "sol",  3)))
 			printf_channel_usage();
 		else
 		{
 			uint8_t ch = 0xe;
 			if (argc == 4)
-				ch = (uint8_t)strtol(argv[3], NULL, 0);
+				ch = (uint8_t)strtol(argv[2], NULL, 0);
 			retval = ipmi_get_channel_cipher_suites(intf,
-								argv[1], // all | supported
-								argv[2], // ipmi | sol
+								argv[1], // ipmi | sol
 								ch);
 		}
 	}
--- a/ipmitool/lib/ipmi_chassis.c
+++ b/ipmitool/lib/ipmi_chassis.c
@ -42,11 +42,12 @@
 #include <ipmitool/ipmi.h>
 #include <ipmitool/log.h>
 #include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_strings.h>
 #include <ipmitool/ipmi_chassis.h>

 extern int verbose;

-static int
+int
 ipmi_chassis_power_status(struct ipmi_intf * intf)
 {
 	struct ipmi_rs * rsp;
@ -68,22 +69,23 @@ ipmi_chassis_power_status(struct ipmi_intf * intf)
 		return -1;
 	}

-	printf("Chassis Power is %s\n", (rsp->data[0] & 0x1) ? "on" : "off");
+	return rsp->data[0] & 1;
+}
+
+static int
+ipmi_chassis_print_power_status(struct ipmi_intf * intf)
+{
+	int ps = ipmi_chassis_power_status(intf);
+
+	if (ps < 0)
+		return -1;
+
+	printf("Chassis Power is %s\n", ps ? "on" : "off");

 	return 0;
 }

-static const struct valstr ipmi_chassis_power_control_vals[] = {
-	{ 0x00, "Down/Off" },
-	{ 0x01, "Up/On" },
-	{ 0x02, "Cycle" },
-	{ 0x03, "Reset" },
-	{ 0x04, "Pulse" },
-	{ 0x05, "Soft" },
-	{ 0x00, NULL },
-};
-
-static int
+int
 ipmi_chassis_power_control(struct ipmi_intf * intf, uint8_t ctl)
 {
 	struct ipmi_rs * rsp;
@ -111,8 +113,10 @@ ipmi_chassis_power_control(struct ipmi_intf * intf, uint8_t ctl)
 	printf("Chassis Power Control: %s\n",
 	       val2str(ctl, ipmi_chassis_power_control_vals));

+#if 0	/* this can cause sessions to hang around after power commands */
 	/* sessions often get lost when changing chassis power */
 	intf->abort = 1;
+#endif

 	return 0;
 }
@ -356,6 +360,75 @@ ipmi_chassis_status(struct ipmi_intf * intf)
 	return 0;
 }

+
+static int
+ipmi_chassis_selftest(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_APP;
+	req.msg.cmd = 0x4;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error sending Get Self Test command");
+		return -1;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Error sending Get Self Test command: %s",
+			val2str(rsp->ccode, completion_code_vals));
+		return -1;
+	}
+
+	printf("Self Test Results    : ");
+	switch (rsp->data[0]) {
+	case 0x55:
+		printf("passed\n");
+		break;
+
+	case 0x56:
+		printf("not implemented\n");
+		break;
+
+	case 0x57:
+	{
+		int i;
+		const struct valstr broken_dev_vals[] = {
+			{ 0, "firmware corrupted" },
+			{ 1, "boot block corrupted" },
+			{ 2, "FRU Internal Use Area corrupted" },
+			{ 3, "SDR Repository empty" },
+			{ 4, "IPMB not responding" },
+			{ 5, "cannot access BMC FRU" },
+			{ 6, "cannot access SDR Repository" },
+			{ 7, "cannot access SEL Device" },
+			{ 0xff, NULL },
+		};
+		printf("device error\n");
+		for (i=0; i<8; i++) {
+			if (rsp->data[1] & (1<<i)) {
+				printf("                       [%s]\n",
+				       val2str(i, broken_dev_vals));
+			}
+		}
+	}
+	break;
+
+	case 0x58:
+		printf("Fatal hardware error: %02xh\n", rsp->data[1]);
+		break;
+
+	default:
+		printf("Device-specific failure %02xh:%02xh\n",
+		       rsp->data[0], rsp->data[1]);
+		break;
+	}
+
+	return 0;
+}
+
 static int
 ipmi_chassis_set_bootparam(struct ipmi_intf * intf, uint8_t param, uint8_t * data, int len)
 {
@ -431,16 +504,11 @@ ipmi_chassis_get_bootparam(struct ipmi_intf * intf, char * arg)
 }

 static int
-ipmi_chassis_set_bootdev(struct ipmi_intf * intf, char * arg)
+ipmi_chassis_set_bootdev(struct ipmi_intf * intf, char * arg, int clearcmos)
 {
 	uint8_t flags[5];
 	int rc = 0;

-	if (arg == NULL) {
-		lprintf(LOG_ERR, "No argument supplied");
-		return -1;
-	}
-
 	memset(flags, 0, 5);
 	flags[0] = 0x01;
 	flags[1] = 0x01;
@ -449,8 +517,12 @@ ipmi_chassis_set_bootdev(struct ipmi_intf * intf, char * arg)
 		return -1;

 	memset(flags, 0, 5);
-	if (strncmp(arg, "pxe", 3) == 0 ||
-	    strncmp(arg, "force_pxe", 9) == 0)
+	if (arg == NULL)
+		flags[1] = 0x00;
+	else if (strncmp(arg, "none", 4) == 0)
+		flags[1] = 0x00;
+	else if (strncmp(arg, "pxe", 3) == 0 ||
+		 strncmp(arg, "force_pxe", 9) == 0)
 		flags[1] = 0x04;
 	else if (strncmp(arg, "disk", 4) == 0 ||
 		 strncmp(arg, "force_disk", 10) == 0)
@ -475,6 +547,9 @@ ipmi_chassis_set_bootdev(struct ipmi_intf * intf, char * arg)
 		return -1;
 	}

+	if (clearcmos)
+		flags[1] |= 0x80;
+
 	/* set flag valid bit */
 	flags[0] = 0x80;
 	rc = ipmi_chassis_set_bootparam(intf, 5, flags, 5);
@ -535,17 +610,55 @@ ipmi_chassis_power_policy(struct ipmi_intf * intf, uint8_t policy)
 	return 0;
 }

+int
+ipmi_power_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int rc = 0;
+	uint8_t ctl = 0;
+
+	if ((argc < 1) || (strncmp(argv[0], "help", 4) == 0)) {
+		lprintf(LOG_NOTICE, "chassis power Commands: status, on, off, cycle, reset, diag, soft");
+		return 0;
+	}
+	if (strncmp(argv[0], "status", 6) == 0) {
+		rc = ipmi_chassis_print_power_status(intf);
+		return rc;
+	}
+	if ((strncmp(argv[0], "up", 2) == 0) || (strncmp(argv[0], "on", 2) == 0))
+		ctl = IPMI_CHASSIS_CTL_POWER_UP;
+	else if ((strncmp(argv[0], "down", 4) == 0) || (strncmp(argv[0], "off", 3) == 0))
+		ctl = IPMI_CHASSIS_CTL_POWER_DOWN;
+	else if (strncmp(argv[0], "cycle", 5) == 0)
+		ctl = IPMI_CHASSIS_CTL_POWER_CYCLE;
+	else if (strncmp(argv[0], "reset", 5) == 0)
+		ctl = IPMI_CHASSIS_CTL_HARD_RESET;
+	else if (strncmp(argv[0], "diag", 4) == 0)
+		ctl = IPMI_CHASSIS_CTL_PULSE_DIAG;
+	else if ((strncmp(argv[0], "acpi", 4) == 0) || (strncmp(argv[0], "soft", 4) == 0))
+		ctl = IPMI_CHASSIS_CTL_ACPI_SOFT;
+	else {
+		lprintf(LOG_ERR, "Invalid chassis power command: %s", argv[0]);
+		return -1;
+	}
+
+	rc = ipmi_chassis_power_control(intf, ctl);
+	return rc;
+}
+
 int
 ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 {
 	int rc = 0;

 	if ((argc == 0) || (strncmp(argv[0], "help", 4) == 0)) {
-		lprintf(LOG_NOTICE, "Chassis Commands:  status, power, identify, policy, restart_cause, poh, bootdev");
+		lprintf(LOG_NOTICE, "Chassis Commands:  status, power, identify, policy, restart_cause, poh, bootdev, selftest");
 	}
 	else if (strncmp(argv[0], "status", 6) == 0) {
 		rc = ipmi_chassis_status(intf);
 	}
+	else if (strncmp(argv[0], "selftest", 8) == 0) {
+		rc = ipmi_chassis_selftest(intf);
+	}
 	else if (strncmp(argv[0], "power", 5) == 0) {
 		uint8_t ctl = 0;

@ -554,7 +667,7 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 			return 0;
 		}
 		if (strncmp(argv[1], "status", 6) == 0) {
-			rc = ipmi_chassis_power_status(intf);
+			rc = ipmi_chassis_print_power_status(intf);
 			return rc;
 		}
 		if ((strncmp(argv[1], "up", 2) == 0) || (strncmp(argv[1], "on", 2) == 0))
@ -639,7 +752,7 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 					lprintf(LOG_NOTICE, "bootparam set <option> [value ...]");
 				} else {
 					if (strncmp(argv[2], "bootflag", 8) == 0)
-						rc = ipmi_chassis_set_bootdev(intf, argv[3]);
+						rc = ipmi_chassis_set_bootdev(intf, argv[3], 0);
 					else
 						lprintf(LOG_NOTICE, "bootparam set <option> [value ...]");
 				}
@ -650,7 +763,8 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 	}
 	else if (strncmp(argv[0], "bootdev", 7) == 0) {
 		if ((argc < 2) || (strncmp(argv[1], "help", 4) == 0)) {
-			lprintf(LOG_NOTICE, "bootdev <device>");
+			lprintf(LOG_NOTICE, "bootdev <device> [clear-cmos=yes|no]");
+			lprintf(LOG_NOTICE, "  none  : Do not change boot device order");
 			lprintf(LOG_NOTICE, "  pxe   : Force PXE boot");
 			lprintf(LOG_NOTICE, "  disk  : Force boot from default Hard-drive");
 			lprintf(LOG_NOTICE, "  safe  : Force boot from default Hard-drive, request Safe Mode");
@ -658,7 +772,16 @@ ipmi_chassis_main(struct ipmi_intf * intf, int argc, char ** argv)
 			lprintf(LOG_NOTICE, "  cdrom : Force boot from CD/DVD");
 			lprintf(LOG_NOTICE, "  bios  : Force boot into BIOS Setup");
 		} else {
-			rc = ipmi_chassis_set_bootdev(intf, argv[1]);
+			if (argc < 3)
+				rc = ipmi_chassis_set_bootdev(intf, argv[1], 0);
+			else if (strncmp(argv[2], "clear-cmos=", 11) == 0) {
+				if (strncmp(argv[2]+11, "yes", 3) == 0)
+					rc = ipmi_chassis_set_bootdev(intf, argv[1], 1);
+				else 
+					rc = ipmi_chassis_set_bootdev(intf, argv[1], 0);
+			}
+			else
+				rc = ipmi_chassis_set_bootdev(intf, argv[1], 0);
 		}
 	}
 	else {
--- a/ipmitool/lib/ipmi_event.c
+++ b/ipmitool/lib/ipmi_event.c
@ -53,15 +53,42 @@
 #include <ipmitool/ipmi_sel.h>
 #include <ipmitool/ipmi_strings.h>
 #include <ipmitool/ipmi_channel.h>
+#include <ipmitool/ipmi_event.h>
+#include <ipmitool/ipmi_sdr.h>
+

 static int
-ipmi_send_platform_event(struct ipmi_intf * intf, int num)
+ipmi_event_msg_print(struct ipmi_intf * intf, struct platform_event_msg * pmsg)
+{
+	struct sel_event_record sel_event;
+
+	memset(&sel_event, 0, sizeof(struct sel_event_record));
+
+	sel_event.record_id = 0;
+	sel_event.sel_type.standard_type.gen_id = 2;
+
+	sel_event.sel_type.standard_type.evm_rev        = pmsg->evm_rev;
+	sel_event.sel_type.standard_type.sensor_type    = pmsg->sensor_type;
+	sel_event.sel_type.standard_type.sensor_num     = pmsg->sensor_num;
+	sel_event.sel_type.standard_type.event_type     = pmsg->event_type;
+	sel_event.sel_type.standard_type.event_dir      = pmsg->event_dir;
+	sel_event.sel_type.standard_type.event_data[0]  = pmsg->event_data[0];
+	sel_event.sel_type.standard_type.event_data[1]  = pmsg->event_data[1];
+	sel_event.sel_type.standard_type.event_data[2]  = pmsg->event_data[2];
+	
+	if (verbose)
+		ipmi_sel_print_extended_entry_verbose(intf, &sel_event);
+	else
+		ipmi_sel_print_extended_entry(intf, &sel_event);
+}
+
+static int
+ipmi_send_platform_event(struct ipmi_intf * intf, struct platform_event_msg * emsg)
 {
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
 	uint8_t rqdata[8];
 	uint8_t chmed;
-	int p = 0;

 	memset(&req, 0, sizeof(req));
 	memset(rqdata, 0, 8);
@ -69,53 +96,20 @@ ipmi_send_platform_event(struct ipmi_intf * intf, int num)
 	req.msg.netfn = IPMI_NETFN_SE;
 	req.msg.cmd = 0x02;
 	req.msg.data = rqdata;
-	req.msg.data_len = 7;

 	chmed = ipmi_current_channel_medium(intf);
 	if (chmed == IPMI_CHANNEL_MEDIUM_SYSTEM) {
 		/* system interface, need extra generator ID */
 		req.msg.data_len = 8;
-		rqdata[p++] = 0x20;
+		rqdata[0] = 0x20;
+		memcpy(rqdata+1, emsg, sizeof(struct platform_event_msg));
+	}
+	else {
+		req.msg.data_len = 7;
+		memcpy(rqdata, emsg, sizeof(struct platform_event_msg));
 	}

-	/* IPMB/LAN/etc */
-	switch (num) {
-	case 1:			/* temperature */
-		printf("Sending SAMPLE event: Temperature - "
-		       "Upper Critical - Going High\n");
-		rqdata[p++] = 0x04;	/* EvMRev */
-		rqdata[p++] = 0x01;	/* Sensor Type */
-		rqdata[p++] = 0x30;	/* Sensor # */
-		rqdata[p++] = 0x01;	/* Event Dir / Event Type */
-		rqdata[p++] = 0x59;	/* Event Data 1 */
-		rqdata[p++] = 0x00;	/* Event Data 2 */
-		rqdata[p++] = 0x00;	/* Event Data 3 */
-		break;
-	case 2:			/* voltage error */
-		printf("Sending SAMPLE event: Voltage Threshold - "
-		       "Lower Critical - Going Low\n");
-		rqdata[p++] = 0x04;	/* EvMRev */
-		rqdata[p++] = 0x02;	/* Sensor Type */
-		rqdata[p++] = 0x60;	/* Sensor # */
-		rqdata[p++] = 0x01;	/* Event Dir / Event Type */
-		rqdata[p++] = 0x52;	/* Event Data 1 */
-		rqdata[p++] = 0x00;	/* Event Data 2 */
-		rqdata[p++] = 0x00;	/* Event Data 3 */
-		break;
-	case 3:			/* correctable ECC */
-		printf("Sending SAMPLE event: Memory - Correctable ECC\n");
-		rqdata[p++] = 0x04;	/* EvMRev */
-		rqdata[p++] = 0x0c;	/* Sensor Type */
-		rqdata[p++] = 0x53;	/* Sensor # */
-		rqdata[p++] = 0x6f;	/* Event Dir / Event Type */
-		rqdata[p++] = 0x00;	/* Event Data 1 */
-		rqdata[p++] = 0x00;	/* Event Data 2 */
-		rqdata[p++] = 0x00;	/* Event Data 3 */
-		break;
-	default:
-		lprintf(LOG_ERR, "Invalid event number: %d", num);
-		return -1;
-	}
+	ipmi_event_msg_print(intf, emsg);

 	rsp = intf->sendrecv(intf, &req);
 	if (rsp == NULL) {
@ -131,6 +125,358 @@ ipmi_send_platform_event(struct ipmi_intf * intf, int num)
 	return 0;
 }

+#define EVENT_THRESH_STATE_LNC_LO	0
+#define EVENT_THRESH_STATE_LNC_HI	1
+#define EVENT_THRESH_STATE_LCR_LO	2
+#define EVENT_THRESH_STATE_LCR_HI	3
+#define EVENT_THRESH_STATE_LNR_LO	4
+#define EVENT_THRESH_STATE_LNR_HI	5
+#define EVENT_THRESH_STATE_UNC_LO	6
+#define EVENT_THRESH_STATE_UNC_HI	7
+#define EVENT_THRESH_STATE_UCR_LO	8
+#define EVENT_THRESH_STATE_UCR_HI	9
+#define EVENT_THRESH_STATE_UNR_LO	10
+#define EVENT_THRESH_STATE_UNR_HI	11
+
+static const struct valstr ipmi_event_thresh_lo[] = {
+	{ EVENT_THRESH_STATE_LNC_LO, "lnc" },
+	{ EVENT_THRESH_STATE_LCR_LO, "lcr" },
+	{ EVENT_THRESH_STATE_LNR_LO, "lnr" },
+	{ EVENT_THRESH_STATE_UNC_LO, "unc" },
+	{ EVENT_THRESH_STATE_UCR_LO, "ucr" },
+	{ EVENT_THRESH_STATE_UNR_LO, "unr" },
+	{ 0, NULL  },
+};
+static const struct valstr ipmi_event_thresh_hi[] = {
+	{ EVENT_THRESH_STATE_LNC_HI, "lnc" },
+	{ EVENT_THRESH_STATE_LCR_HI, "lcr" },
+	{ EVENT_THRESH_STATE_LNR_HI, "lnr" },
+	{ EVENT_THRESH_STATE_UNC_HI, "unc" },
+	{ EVENT_THRESH_STATE_UCR_HI, "ucr" },
+	{ EVENT_THRESH_STATE_UNR_HI, "unr" },
+	{ 0, NULL  },
+};
+
+static int
+ipmi_send_platform_event_num(struct ipmi_intf * intf, int num)
+{
+	struct platform_event_msg emsg;
+
+	memset(&emsg, 0, sizeof(struct platform_event_msg));
+
+	/* IPMB/LAN/etc */
+	switch (num) {
+	case 1:			/* temperature */
+		printf("Sending SAMPLE event: Temperature - "
+		       "Upper Critical - Going High\n");
+		emsg.evm_rev       = 0x04;
+		emsg.sensor_type   = 0x01;
+		emsg.sensor_num    = 0x30;
+		emsg.event_dir     = EVENT_DIR_ASSERT;
+		emsg.event_type    = 0x01;
+		emsg.event_data[0] = EVENT_THRESH_STATE_UCR_HI;
+		emsg.event_data[1] = 0xff;
+		emsg.event_data[2] = 0xff;
+		break;
+	case 2:			/* voltage error */
+		printf("Sending SAMPLE event: Voltage Threshold - "
+		       "Lower Critical - Going Low\n");
+		emsg.evm_rev       = 0x04;
+		emsg.sensor_type   = 0x02;
+		emsg.sensor_num    = 0x60;
+		emsg.event_dir     = EVENT_DIR_ASSERT;
+		emsg.event_type    = 0x01;
+		emsg.event_data[0] = EVENT_THRESH_STATE_LCR_LO;
+		emsg.event_data[1] = 0xff;
+		emsg.event_data[2] = 0xff;
+		break;
+	case 3:			/* correctable ECC */
+		printf("Sending SAMPLE event: Memory - Correctable ECC\n");
+		emsg.evm_rev       = 0x04;
+		emsg.sensor_type   = 0x0c;
+		emsg.sensor_num    = 0x53;
+		emsg.event_dir     = EVENT_DIR_ASSERT;
+		emsg.event_type    = 0x6f;
+		emsg.event_data[0] = 0x00;
+		emsg.event_data[1] = 0xff;
+		emsg.event_data[2] = 0xff;
+		break;
+	default:
+		lprintf(LOG_ERR, "Invalid event number: %d", num);
+		return -1;
+	}
+
+	return ipmi_send_platform_event(intf, &emsg);
+}
+
+static int
+ipmi_event_find_offset(uint8_t code,
+		       struct ipmi_event_sensor_types * evt,
+		       char * desc)
+{
+	if (desc == NULL || code == 0)
+		return 0x00;
+
+	while (evt->type) {
+		if (evt->code == code && evt->desc != NULL &&
+		    strncasecmp(desc, evt->desc, __maxlen(desc, evt->desc)) == 0)
+			return evt->offset;
+		evt++;
+	}
+
+	lprintf(LOG_WARN, "Unable to find matching event offset for '%s'", desc);
+	return -1;
+}
+
+static void
+print_sensor_states(uint8_t sensor_type, uint8_t event_type)
+{
+	printf("Sensor States: \n  ");
+	ipmi_sdr_print_discrete_state_mini("\n  ", sensor_type,
+					   event_type, 0xff, 0xff);
+	printf("\n");
+}
+
+
+static int
+ipmi_event_fromsensor(struct ipmi_intf * intf, char * id, char * state, char * evdir)
+{
+	struct ipmi_rs * rsp;
+	struct sdr_record_list * sdr;
+	struct platform_event_msg emsg;
+	int off;
+
+	if (id == NULL) {
+		lprintf(LOG_ERR, "No sensor ID supplied");
+		return -1;
+	}
+
+	memset(&emsg, 0, sizeof(struct platform_event_msg));
+	emsg.evm_rev = 0x04;
+
+	if (evdir == NULL)
+		emsg.event_dir = EVENT_DIR_ASSERT;
+	else if (strncasecmp(evdir, "assert", 6) == 0)
+		emsg.event_dir = EVENT_DIR_ASSERT;
+	else if (strncasecmp(evdir, "deassert", 8) == 0)
+		emsg.event_dir = EVENT_DIR_DEASSERT;
+	else {
+		lprintf(LOG_ERR, "Invalid event direction %s.  Must be 'assert' or 'deassert'", evdir);
+		return -1;
+	}
+
+	printf("Finding sensor %s... ", id);
+	sdr = ipmi_sdr_find_sdr_byid(intf, id);
+	if (sdr == NULL) {
+		printf("not found!\n");
+		return -1;
+	}
+	printf("ok\n");
+
+	switch (sdr->type)
+	{
+	case SDR_RECORD_TYPE_FULL_SENSOR:
+
+		emsg.sensor_type   = sdr->record.full->sensor.type;
+		emsg.sensor_num    = sdr->record.full->keys.sensor_num;
+		emsg.event_type    = sdr->record.full->event_type;
+		break;
+
+	case SDR_RECORD_TYPE_COMPACT_SENSOR:
+
+		emsg.sensor_type = sdr->record.compact->sensor.type;
+		emsg.sensor_num  = sdr->record.compact->keys.sensor_num;
+		emsg.event_type  = sdr->record.compact->event_type;
+		break;
+
+	default:
+		lprintf(LOG_ERR, "Unknown sensor type for id '%s'", id);
+		return -1;
+	}
+
+	emsg.event_data[1] = 0xff;
+	emsg.event_data[2] = 0xff;
+
+	switch (emsg.event_type)
+	{
+	/*
+	 * Threshold Class
+	 */
+	case 1:
+	{
+		int dir = 0;
+		int hilo = 0;
+		off = 1;
+
+		if (state == NULL || strncasecmp(state, "list", 4) == 0) {
+			printf("Sensor States:\n");
+			printf("  lnr : Lower Non-Recoverable \n");
+			printf("  lcr : Lower Critical\n");
+			printf("  lnc : Lower Non-Critical\n");
+			printf("  unc : Upper Non-Critical\n");
+			printf("  ucr : Upper Critical\n");
+			printf("  unr : Upper Non-Recoverable\n");
+			return -1;
+		}
+
+		if (0 != strncasecmp(state, "lnr", 3) &&
+		    0 != strncasecmp(state, "lcr", 3) &&
+		    0 != strncasecmp(state, "lnc", 3) &&
+		    0 != strncasecmp(state, "unc", 3) &&
+		    0 != strncasecmp(state, "ucr", 3) &&
+		    0 != strncasecmp(state, "unr", 3))
+		{
+			lprintf(LOG_ERR, "Invalid threshold identifier %s", state);
+			return -1;
+		}
+
+		if (state[0] == 'u')
+			hilo = 1;
+		else
+			hilo = 0;
+
+		if (emsg.event_dir == EVENT_DIR_ASSERT)
+			dir = hilo;
+		else
+			dir = !hilo;
+
+		if ((emsg.event_dir == EVENT_DIR_ASSERT   && hilo == 1) ||
+		    (emsg.event_dir == EVENT_DIR_DEASSERT && hilo == 0))
+			emsg.event_data[0] = (uint8_t)(str2val(state, ipmi_event_thresh_hi) & 0xf);
+		else if ((emsg.event_dir == EVENT_DIR_ASSERT   && hilo == 0) ||
+			 (emsg.event_dir == EVENT_DIR_DEASSERT && hilo == 1))
+			emsg.event_data[0] = (uint8_t)(str2val(state, ipmi_event_thresh_lo) & 0xf);
+		else {
+			lprintf(LOG_ERR, "Invalid Event\n");
+			return -1;
+		}
+
+		rsp = ipmi_sdr_get_sensor_thresholds(intf, emsg.sensor_num);
+
+		if (rsp != NULL && rsp->ccode == 0) {
+
+			/* threshold reading */
+			emsg.event_data[2] = rsp->data[(emsg.event_data[0] / 2) + 1];
+
+			rsp = ipmi_sdr_get_sensor_hysteresis(intf, emsg.sensor_num);
+			if (rsp != NULL && rsp->ccode == 0)
+				off = dir ? rsp->data[0] : rsp->data[1];
+			if (off <= 0)
+				off = 1;
+
+			/* trigger reading */
+			if (dir) {
+				if ((emsg.event_data[2] + off) > 0xff)
+					emsg.event_data[1] = 0xff;
+				else
+					emsg.event_data[1] = emsg.event_data[2] + off;
+			}
+			else {
+				if ((emsg.event_data[2] - off) < 0)
+					emsg.event_data[1] = 0;
+				else
+					emsg.event_data[1] = emsg.event_data[2] - off;
+			}
+
+			/* trigger in byte 2, threshold in byte 3 */
+			emsg.event_data[0] |= 0x50;
+		}
+	}
+	break;
+
+	/*
+	 * Digital Discrete
+	 */
+	case 3: case 4: case 5: case 6: case 8: case 9:
+	{
+		int x;
+		const char * digi_on[] = { "present", "assert", "limit",
+					   "fail", "yes", "on", "up" };
+		const char * digi_off[] = { "absent", "deassert", "nolimit",
+					    "nofail", "no", "off", "down" };
+		/* 
+		 * print list of available states for this sensor
+		 */
+		if (state == NULL || strncasecmp(state, "list", 4) == 0) {
+			print_sensor_states(emsg.sensor_type, emsg.event_type);
+			printf("Sensor State Shortcuts:\n");
+			for (x = 0; x < sizeof(digi_on)/sizeof(*digi_on); x++) {
+				printf("  %-9s  %-9s\n", digi_on[x], digi_off[x]);
+			}
+			return 0;
+		}
+
+		off = 0;
+		for (x = 0; x < sizeof(digi_on)/sizeof(*digi_on); x++) {
+			if (strncasecmp(state, digi_on[x], strlen(digi_on[x])) == 0) {
+				emsg.event_data[0] = 1;
+				off = 1;
+				break;
+			}
+			else if (strncasecmp(state, digi_off[x], strlen(digi_off[x])) == 0) {
+				emsg.event_data[0] = 0;
+				off = 1;
+				break;
+			}
+		}
+		if (off == 0) {
+			off = ipmi_event_find_offset(
+				emsg.event_type, generic_event_types, state);
+			if (off < 0)
+				return -1;
+			emsg.event_data[0] = off;
+		}
+	}
+	break;
+
+	/*
+	 * Generic Discrete
+	 */
+	case 2: case 7: case 10: case 11: case 12:
+	{
+		/* 
+		 * print list of available states for this sensor
+		 */
+		if (state == NULL || strncasecmp(state, "list", 4) == 0) {
+			print_sensor_states(emsg.sensor_type, emsg.event_type);
+			return 0;
+		}
+		off = ipmi_event_find_offset(
+			emsg.event_type, generic_event_types, state);
+		if (off < 0)
+			return -1;
+		emsg.event_data[0] = off;
+	}
+	break;
+		
+	/*
+	 * Sensor-Specific Discrete
+	 */
+	case 0x6f:
+	{
+		/* 
+		 * print list of available states for this sensor
+		 */
+		if (state == NULL || strncasecmp(state, "list", 4) == 0) {
+			print_sensor_states(emsg.sensor_type, emsg.event_type);
+			return 0;
+		}
+		off = ipmi_event_find_offset(
+			emsg.sensor_type, sensor_specific_types, state);
+		if (off < 0)
+			return -1;
+		emsg.event_data[0] = off;
+	}
+	break;
+
+	default:
+		return -1;
+
+	}
+
+	return ipmi_send_platform_event(intf, &emsg);
+}
+
 static int
 ipmi_event_fromfile(struct ipmi_intf * intf, char * file)
 {
@ -210,19 +556,19 @@ ipmi_event_fromfile(struct ipmi_intf * intf, char * file)

 		memset(&sel_event, 0, sizeof(struct sel_event_record));
 		sel_event.record_id = 0;
-		sel_event.gen_id = 2;
+		sel_event.sel_type.standard_type.gen_id = 2;

 		j = (chmed == IPMI_CHANNEL_MEDIUM_SYSTEM) ? 1 : 0;
-		sel_event.evm_rev = rqdata[j++];
-		sel_event.sensor_type = rqdata[j++];
-		sel_event.sensor_num = rqdata[j++];
-		sel_event.event_type = rqdata[j] & 0x7f;
-		sel_event.event_dir = (rqdata[j++] & 0x80) >> 7;
-		sel_event.event_data[0] = rqdata[j++];
-		sel_event.event_data[1] = rqdata[j++];
-		sel_event.event_data[2] = rqdata[j++];
+		sel_event.sel_type.standard_type.evm_rev = rqdata[j++];
+		sel_event.sel_type.standard_type.sensor_type = rqdata[j++];
+		sel_event.sel_type.standard_type.sensor_num = rqdata[j++];
+		sel_event.sel_type.standard_type.event_type = rqdata[j] & 0x7f;
+		sel_event.sel_type.standard_type.event_dir = (rqdata[j++] & 0x80) >> 7;
+		sel_event.sel_type.standard_type.event_data[0] = rqdata[j++];
+		sel_event.sel_type.standard_type.event_data[1] = rqdata[j++];
+		sel_event.sel_type.standard_type.event_data[2] = rqdata[j++];

-		ipmi_sel_print_std_entry(&sel_event);
+		ipmi_sel_print_std_entry(intf, &sel_event);
 		
 		rsp = intf->sendrecv(intf, &req);
 		if (rsp == NULL) {
@ -240,33 +586,56 @@ ipmi_event_fromfile(struct ipmi_intf * intf, char * file)
 	return rc;
 }

+static void
+ipmi_event_usage(void)
+{
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "usage: event <num>");
+	lprintf(LOG_NOTICE, "   Send generic test events");
+	lprintf(LOG_NOTICE, "   1 : Temperature - Upper Critical - Going High");
+	lprintf(LOG_NOTICE, "   2 : Voltage Threshold - Lower Critical - Going Low");
+	lprintf(LOG_NOTICE, "   3 : Memory - Correctable ECC");
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "usage: event file <filename>");
+	lprintf(LOG_NOTICE, "   Read and generate events from file");
+	lprintf(LOG_NOTICE, "   Use the 'sel save' command to generate from SEL");
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "usage: event <sensorid> <state> [event_dir]");
+	lprintf(LOG_NOTICE, "   sensorid  : Sensor ID to use for event data");
+	lprintf(LOG_NOTICE, "   state     : Sensor state, use 'list' to see possible states for sensor");
+	lprintf(LOG_NOTICE, "   event_dir : assert, deassert [default=assert]");
+	lprintf(LOG_NOTICE, "");
+}
+
 int
 ipmi_event_main(struct ipmi_intf * intf, int argc, char ** argv)
 {
-	uint8_t c;
 	int rc = 0;

 	if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
-		lprintf(LOG_NOTICE, "usage: event <num>");
-		lprintf(LOG_NOTICE, "   1 : Temperature - Upper Critical - Going High");
-		lprintf(LOG_NOTICE, "   2 : Voltage Threshold - Lower Critical - Going Low");
-		lprintf(LOG_NOTICE, "   3 : Memory - Correctable ECC");
-		lprintf(LOG_NOTICE, "usage: event file <filename>");
-		lprintf(LOG_NOTICE, "   Will read list of events from file");
+		ipmi_event_usage();
 		return 0;
 	}
-
 	if (strncmp(argv[0], "file", 4) == 0) {
 		if (argc < 2) {
-			lprintf(LOG_NOTICE, "usage: event file <filename>\n");
-			rc = -1;
-		} else {
-			rc = ipmi_event_fromfile(intf, argv[1]);
+			ipmi_event_usage();
+			return 0;
 		}
-	} else {
-		c = (uint8_t)strtol(argv[0], NULL, 0);
-		rc = ipmi_send_platform_event(intf, c);
+		return ipmi_event_fromfile(intf, argv[1]);
 	}
+	if (strlen(argv[0]) == 1) {
+		switch (argv[0][0]) {
+		case '1': return ipmi_send_platform_event_num(intf, 1);
+		case '2': return ipmi_send_platform_event_num(intf, 2);
+		case '3': return ipmi_send_platform_event_num(intf, 3);
+		}
+	}
+	if (argc < 2)
+		rc = ipmi_event_fromsensor(intf, argv[0], NULL, NULL);
+	else if (argc < 3)
+		rc = ipmi_event_fromsensor(intf, argv[0], argv[1], NULL);
+	else
+		rc = ipmi_event_fromsensor(intf, argv[0], argv[1], argv[2]);

 	return rc;
 }
--- a/ipmitool/lib/ipmi_fru.c
+++ b/ipmitool/lib/ipmi_fru.c
--- a/ipmitool/lib/ipmi_fwum.c
+++ b/ipmitool/lib/ipmi_fwum.c
--- a/ipmitool/lib/ipmi_lanp.c
+++ b/ipmitool/lib/ipmi_lanp.c
--- a/ipmitool/lib/ipmi_main.c
+++ b/ipmitool/lib/ipmi_main.c
@ -0,0 +1,616 @@
+/*
+ * 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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include <ipmitool/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_session.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_sel.h>
+#include <ipmitool/ipmi_fru.h>
+#include <ipmitool/ipmi_sol.h>
+#include <ipmitool/ipmi_isol.h>
+#include <ipmitool/ipmi_lanp.h>
+#include <ipmitool/ipmi_chassis.h>
+#include <ipmitool/ipmi_mc.h>
+#include <ipmitool/ipmi_sensor.h>
+#include <ipmitool/ipmi_channel.h>
+#include <ipmitool/ipmi_session.h>
+#include <ipmitool/ipmi_event.h>
+#include <ipmitool/ipmi_user.h>
+#include <ipmitool/ipmi_raw.h>
+#include <ipmitool/ipmi_pef.h>
+#include <ipmitool/ipmi_oem.h>
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef ENABLE_ALL_OPTIONS
+# define OPTION_STRING	"I:hVvcgsEao:H:P:f:U:p:C:L:A:t:m:S:l:b:e:k:"
+#else
+# define OPTION_STRING	"I:hVvcH:f:U:p:S:"
+#endif
+
+extern int verbose;
+extern int csv_output;
+extern const struct valstr ipmi_privlvl_vals[];
+extern const struct valstr ipmi_authtype_session_vals[];
+
+/* defined in ipmishell.c */
+#ifdef HAVE_READLINE
+extern int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv);
+#endif
+extern int ipmi_set_main(struct ipmi_intf * intf, int argc, char ** argv);
+extern int ipmi_exec_main(struct ipmi_intf * intf, int argc, char ** argv);
+
+
+/* ipmi_password_file_read  -  Open file and read password from it
+ *
+ * @filename:	file name to read from
+ *
+ * returns pointer to allocated buffer containing password
+ *   (caller is expected to free when finished)
+ * returns NULL on error
+ */
+static char *
+ipmi_password_file_read(char * filename)
+{
+	FILE * fp;
+	char * pass = NULL;
+	int l;
+
+	pass = malloc(16);
+	if (pass == NULL) {
+		lprintf(LOG_ERR, "ipmitool: malloc failure");
+		return NULL;
+	}
+
+	fp = ipmi_open_file_read((const char *)filename);
+	if (fp == NULL) {
+		lprintf(LOG_ERR, "Unable to open password file %s",
+			filename);
+		return NULL;
+	}
+
+	/* read in id */
+	if (fgets(pass, 16, fp) == NULL) {
+		lprintf(LOG_ERR, "Unable to read password from file %s",
+			filename);
+		fclose(fp);
+		return NULL;
+	}
+
+ 	/* remove trailing whitespace */
+	l = strcspn(pass, " \r\n\t");
+	if (l > 0) {
+		pass[l] = '\0';
+	}
+
+	fclose(fp);
+	return pass;
+}
+
+
+/*
+ * Print all the commands in the above table to stderr
+ * used for help text on command line and shell
+ */
+void
+ipmi_cmd_print(struct ipmi_cmd * cmdlist)
+{
+	struct ipmi_cmd * cmd;
+	int hdr = 0;
+
+	if (cmdlist == NULL)
+		return;
+	for (cmd=cmdlist; cmd->func != NULL; cmd++) {
+		if (cmd->desc == NULL)
+			continue;
+		if (hdr == 0) {
+			lprintf(LOG_NOTICE, "Commands:");
+			hdr = 1;
+		}
+		lprintf(LOG_NOTICE, "\t%-12s  %s", cmd->name, cmd->desc);
+	}
+	lprintf(LOG_NOTICE, "");
+}
+
+/* ipmi_cmd_run - run a command from list based on parameters
+ *                called from main()
+ *
+ *                1. iterate through ipmi_cmd_list matching on name
+ *                2. call func() for that command
+ *
+ * @intf:	ipmi interface
+ * @name:	command name
+ * @argc:	command argument count
+ * @argv:	command argument list
+ *
+ * returns value from func() of that commnad if found
+ * returns -1 if command is not found
+ */
+int
+ipmi_cmd_run(struct ipmi_intf * intf, char * name, int argc, char ** argv)
+{
+	struct ipmi_cmd * cmd = intf->cmdlist;
+
+	/* hook to run a default command if nothing specified */
+	if (name == NULL) {
+		if (cmd->func == NULL || cmd->name == NULL)
+			return -1;
+		else if (strncmp(cmd->name, "default", 7) == 0)
+			return cmd->func(intf, 0, NULL);
+		else {
+			lprintf(LOG_ERR, "No command provided!");
+			ipmi_cmd_print(intf->cmdlist);
+			return -1;
+		}
+	}
+
+	for (cmd=intf->cmdlist; cmd->func != NULL; cmd++) {
+		if (strncmp(name, cmd->name, __maxlen(cmd->name, name)) == 0)
+			break;
+	}
+	if (cmd->func == NULL) {
+		cmd = intf->cmdlist;
+		if (strncmp(cmd->name, "default", 7) == 0)
+			return cmd->func(intf, argc+1, argv-1);
+		lprintf(LOG_ERR, "Invalid command: %s", name);
+		ipmi_cmd_print(intf->cmdlist);
+		return -1;
+	}
+	return cmd->func(intf, argc, argv);
+}
+
+static void
+ipmi_option_usage(const char * progname, struct ipmi_cmd * cmdlist, struct ipmi_intf_support * intflist)
+{
+	lprintf(LOG_NOTICE, "%s version %s\n", progname, VERSION);
+	lprintf(LOG_NOTICE, "usage: %s [options...] <command>\n", progname);
+	lprintf(LOG_NOTICE, "       -h             This help");
+	lprintf(LOG_NOTICE, "       -V             Show version information");
+	lprintf(LOG_NOTICE, "       -v             Verbose (can use multiple times)");
+	lprintf(LOG_NOTICE, "       -c             Display output in comma separated format");
+	lprintf(LOG_NOTICE, "       -I intf        Interface to use");
+	lprintf(LOG_NOTICE, "       -H hostname    Remote host name for LAN interface");
+	lprintf(LOG_NOTICE, "       -p port        Remote RMCP port [default=623]");
+	lprintf(LOG_NOTICE, "       -U username    Remote session username");
+	lprintf(LOG_NOTICE, "       -f file        Read remote session password from file");
+	lprintf(LOG_NOTICE, "       -S sdr         Use local file for remote SDR cache");
+#ifdef ENABLE_ALL_OPTIONS
+	lprintf(LOG_NOTICE, "       -a             Prompt for remote password");
+	lprintf(LOG_NOTICE, "       -e char        Set SOL escape character");
+	lprintf(LOG_NOTICE, "       -C ciphersuite Cipher suite to be used by lanplus interface");
+	lprintf(LOG_NOTICE, "       -k key         Use Kg key for IPMIv2 authentication");
+	lprintf(LOG_NOTICE, "       -L level       Remote session privilege level [default=ADMINISTRATOR]");
+	lprintf(LOG_NOTICE, "       -A authtype    Force use of auth type NONE, PASSWORD, MD2, MD5 or OEM");
+	lprintf(LOG_NOTICE, "       -P password    Remote session password");
+	lprintf(LOG_NOTICE, "       -E             Read password from IPMI_PASSWORD environment variable");
+	lprintf(LOG_NOTICE, "       -m address     Set local IPMB address");
+	lprintf(LOG_NOTICE, "       -b channel     Set destination channel for bridged request");
+	lprintf(LOG_NOTICE, "       -l lun         Set destination lun for raw commands");
+	lprintf(LOG_NOTICE, "       -t address     Bridge request to remote target address");
+	lprintf(LOG_NOTICE, "       -o oemtype     Setup for OEM (use 'list' to see available OEM types)");
+#endif
+	lprintf(LOG_NOTICE, "");
+
+	ipmi_intf_print(intflist);
+
+	if (cmdlist != NULL)
+		ipmi_cmd_print(cmdlist);
+}
+
+
+/* ipmi_parse_options  -  helper function to handle parsing command line options
+ *
+ * @argc:	count of options
+ * @argv:	list of options
+ * @cmdlist:	list of supported commands
+ * @intflist:	list of supported interfaces
+ *
+ * returns 0 on success
+ * returns -1 on error
+ */
+int
+ipmi_main(int argc, char ** argv,
+	  struct ipmi_cmd * cmdlist,
+	  struct ipmi_intf_support * intflist)
+{
+	struct ipmi_intf * intf = NULL;
+	struct ipmi_intf_support * sup;
+	int privlvl = 0;
+	uint8_t target_addr = 0;
+	uint8_t target_channel = 0;
+	uint8_t target_lun     = 0;
+	uint8_t my_addr = 0;
+	int authtype = -1;
+	char * tmp = NULL;
+	char * hostname = NULL;
+	char * username = NULL;
+	char * password = NULL;
+	char * intfname = NULL;
+	char * progname = NULL;
+	char * oemtype  = NULL;
+	char * sdrcache = NULL;
+	char * kgkey    = NULL;
+	int port = 0;
+	int cipher_suite_id = 3; /* See table 22-19 of the IPMIv2 spec */
+	int argflag, i, found;
+	int rc = -1;
+	char sol_escape_char = SOL_ESCAPE_CHARACTER_DEFAULT;
+
+	/* save program name */
+	progname = strrchr(argv[0], '/');
+	progname = ((progname == NULL) ? argv[0] : progname+1);
+
+	while ((argflag = getopt(argc, (char **)argv, OPTION_STRING)) != -1)
+	{
+		switch (argflag) {
+		case 'I':
+			intfname = strdup(optarg);
+			if (intfname == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			if (intflist != NULL) {
+				found = 0;
+				for (sup=intflist; sup->name != NULL; sup++) {
+					if (strncmp(sup->name, intfname, strlen(intfname)) == 0 &&
+					    strncmp(sup->name, intfname, strlen(sup->name)) == 0 &&
+					    sup->supported == 1)
+						found = 1;
+				}
+				if (!found) {
+					lprintf(LOG_ERR, "Interface %s not supported", intfname);
+					goto out_free;
+				}
+			}
+			break;
+		case 'h':
+			ipmi_option_usage(progname, cmdlist, intflist);
+			rc = 0;
+			goto out_free;
+			break;
+		case 'V':
+			printf("%s version %s\n", progname, VERSION);
+			rc = 0;
+			goto out_free;
+			break;
+		case 'p':
+			port = atoi(optarg);
+			break;
+		case 'C':
+			cipher_suite_id = atoi(optarg);
+			break;
+		case 'v':
+			verbose++;
+			break;
+		case 'c':
+			csv_output = 1;
+			break;
+		case 'H':
+			hostname = strdup(optarg);
+			if (hostname == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			break;
+		case 'f':
+			if (password)
+				free(password);
+			password = ipmi_password_file_read(optarg);
+			if (password == NULL)
+				lprintf(LOG_ERR, "Unable to read password "
+					"from file %s", optarg);
+			break;
+		case 'a':
+#ifdef HAVE_GETPASSPHRASE
+			tmp = getpassphrase("Password: ");
+#else
+			tmp = getpass("Password: ");
+#endif
+			if (tmp != NULL) {
+				if (password)
+					free(password);
+				password = strdup(tmp);
+				if (password == NULL) {
+					lprintf(LOG_ERR, "%s: malloc failure", progname);
+					goto out_free;
+				}
+			}
+			break;
+		case 'k':
+			kgkey = strdup(optarg);
+			if (kgkey == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			break;
+		case 'U':
+			username = strdup(optarg);
+			if (username == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			break;
+		case 'S':
+			sdrcache = strdup(optarg);
+			if (sdrcache == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			break;
+#ifdef ENABLE_ALL_OPTIONS
+		case 'o':
+			oemtype = strdup(optarg);
+			if (oemtype == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+			if (strncmp(oemtype, "list", 4) == 0 ||
+			    strncmp(oemtype, "help", 4) == 0) {
+				ipmi_oem_print();
+				goto out_free;
+			}
+			break;
+		case 'g':
+			/* backwards compatible oem hack */
+			oemtype = strdup("intelwv2");
+			break;
+		case 's':
+			/* backwards compatible oem hack */
+			oemtype = strdup("supermicro");
+			break;
+		case 'P':
+			if (password)
+				free(password);
+			password = strdup(optarg);
+			if (password == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+
+			/* Prevent password snooping with ps */
+			i = strlen(optarg);
+			memset(optarg, 'X', i);
+			break;
+		case 'E':
+			if ((tmp = getenv("IPMITOOL_PASSWORD")))
+			{
+				if (password)
+					free(password);
+				password = strdup(tmp);
+				if (password == NULL) {
+					lprintf(LOG_ERR, "%s: malloc failure", progname);
+					goto out_free;
+				}
+			}
+			else if ((tmp = getenv("IPMI_PASSWORD")))
+			{
+				if (password)
+					free(password);
+				password = strdup(tmp);
+				if (password == NULL) {
+					lprintf(LOG_ERR, "%s: malloc failure", progname);
+					goto out_free;
+				}
+			}
+			else {
+				lprintf(LOG_WARN, "Unable to read password from environment");
+			}
+			break;
+		case 'L':
+			privlvl = str2val(optarg, ipmi_privlvl_vals);
+			if (privlvl == 0xFF)
+				lprintf(LOG_WARN, "Invalid privilege level %s", optarg);
+			break;
+		case 'A':
+			authtype = str2val(optarg, ipmi_authtype_session_vals);
+			break;
+		case 't':
+			target_addr = (uint8_t)strtol(optarg, NULL, 0);
+			break;
+		case 'b':
+			target_channel = (uint8_t)strtol(optarg, NULL, 0);
+			break;
+		case 'l':
+			target_lun = (uint8_t)strtol(optarg, NULL, 0);
+			break;
+		case 'm':
+			my_addr = (uint8_t)strtol(optarg, NULL, 0);
+			break;
+		case 'e':
+			sol_escape_char = optarg[0];
+			break;
+#endif
+		default:
+			ipmi_option_usage(progname, cmdlist, intflist);
+			goto out_free;
+		}
+	}
+
+	/* check for command before doing anything */
+	if (argc-optind > 0 &&
+	    strncmp(argv[optind], "help", 4) == 0) {
+		ipmi_cmd_print(cmdlist);
+		rc = 0;
+		goto out_free;
+	}
+
+	/*
+	 * If the user has specified a hostname (-H option)
+	 * then this is a remote access session.
+	 *
+	 * If no password was specified by any other method
+	 * and the authtype was not explicitly set to NONE
+	 * then prompt the user.
+	 */
+	if (hostname != NULL && password == NULL &&
+	    (authtype != IPMI_SESSION_AUTHTYPE_NONE || authtype < 0)) {
+#ifdef HAVE_GETPASSPHRASE
+		tmp = getpassphrase("Password: ");
+#else
+		tmp = getpass("Password: ");
+#endif
+		if (tmp != NULL) {
+			password = strdup(tmp);
+			if (password == NULL) {
+				lprintf(LOG_ERR, "%s: malloc failure", progname);
+				goto out_free;
+			}
+		}
+	}
+
+	/* if no interface was specified but a
+	 * hostname was then use LAN by default
+	 * otherwise the default is hardcoded
+	 * to use the first entry in the list
+	 */
+	if (intfname == NULL && hostname != NULL) {
+		intfname = strdup("lan");
+		if (intfname == NULL) {
+			lprintf(LOG_ERR, "%s: malloc failure", progname);
+			goto out_free;
+		}
+	}
+
+	/* load interface */
+	intf = ipmi_intf_load(intfname);
+	if (intf == NULL) {
+		lprintf(LOG_ERR, "Error loading interface %s", intfname);
+		goto out_free;
+	}
+
+	/* setup log */
+	log_init(progname, 0, verbose);
+
+	/* run OEM setup if found */
+	if (oemtype != NULL &&
+	    ipmi_oem_setup(intf, oemtype) < 0) {
+		lprintf(LOG_ERR, "OEM setup for \"%s\" failed", oemtype);
+		goto out_free;
+	}
+
+	/* set session variables */
+	if (hostname != NULL)
+		ipmi_intf_session_set_hostname(intf, hostname);
+	if (username != NULL)
+		ipmi_intf_session_set_username(intf, username);
+	if (password != NULL)
+		ipmi_intf_session_set_password(intf, password);
+	if (kgkey != NULL)
+		ipmi_intf_session_set_kgkey(intf, kgkey);
+	if (port > 0)
+		ipmi_intf_session_set_port(intf, port);
+	if (authtype >= 0)
+		ipmi_intf_session_set_authtype(intf, (uint8_t)authtype);
+	if (privlvl > 0)
+		ipmi_intf_session_set_privlvl(intf, (uint8_t)privlvl);
+	else
+		ipmi_intf_session_set_privlvl(intf,
+		      IPMI_SESSION_PRIV_ADMIN);	/* default */
+
+	ipmi_intf_session_set_sol_escape_char(intf, sol_escape_char);
+	ipmi_intf_session_set_cipher_suite_id(intf, cipher_suite_id);
+
+	/* setup destination lun if given */
+	intf->target_lun = target_lun ;
+
+	/* setup destination channel if given */
+	intf->target_channel = target_channel ;
+
+	/* setup IPMB local and target address if given */
+	intf->my_addr = my_addr ? : IPMI_BMC_SLAVE_ADDR;
+	if (target_addr > 0) {
+		/* need to open the interface first */
+		if (intf->open != NULL)
+			intf->open(intf);
+		intf->target_addr = target_addr;
+		/* must be admin level to do this over lan */
+		ipmi_intf_session_set_privlvl(intf, IPMI_SESSION_PRIV_ADMIN);
+	}
+
+	/* parse local SDR cache if given */
+	if (sdrcache != NULL) {
+		ipmi_sdr_list_cache_fromfile(intf, sdrcache);
+	}
+
+	intf->cmdlist = cmdlist;
+
+	/* now we finally run the command */
+	if (argc-optind > 0)
+		rc = ipmi_cmd_run(intf, argv[optind], argc-optind-1, &(argv[optind+1]));
+	else
+		rc = ipmi_cmd_run(intf, NULL, 0, NULL);
+
+	/* clean repository caches */
+	ipmi_cleanup(intf);
+
+	/* call interface close function if available */
+	if (intf->opened > 0 && intf->close != NULL)
+		intf->close(intf);
+
+ out_free:
+	log_halt();
+
+	if (intfname != NULL)
+		free(intfname);
+	if (hostname != NULL)
+		free(hostname);
+	if (username != NULL)
+		free(username);
+	if (password != NULL)
+		free(password);
+	if (oemtype != NULL)
+		free(oemtype);
+
+	return rc;
+}
--- a/ipmitool/lib/ipmi_mc.c
+++ b/ipmitool/lib/ipmi_mc.c
@ -37,9 +37,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <time.h>

 #include <ipmitool/helper.h>
 #include <ipmitool/log.h>
+#include <ipmitool/bswap.h>
 #include <ipmitool/ipmi.h>
 #include <ipmitool/ipmi_intf.h>
 #include <ipmitool/ipmi_mc.h>
@ -63,21 +65,23 @@ ipmi_mc_reset(struct ipmi_intf * intf, int cmd)
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;

+	intf->open(intf);
+
 	memset(&req, 0, sizeof(req));
 	req.msg.netfn = IPMI_NETFN_APP;
 	req.msg.cmd = cmd;
 	req.msg.data_len = 0;

+	if (cmd == BMC_COLD_RESET)
+		intf->noanswer = 1;
+
 	rsp = intf->sendrecv(intf, &req);
-	if (rsp == NULL) {
-		lprintf(LOG_ERR, "Reset command failed");
-		return -1;
-	}
-	if (rsp->ccode > 0) {
-		lprintf(LOG_ERR, "Reset command failed: %s",
-			val2str(rsp->ccode, completion_code_vals));
-		return -1;
-	}
+
+	if (cmd == BMC_COLD_RESET)
+		intf->abort = 1;
+
+	printf("Sent %s reset command to MC\n",
+	       (cmd == BMC_WARM_RESET) ? "warm" : "cold");

 	return 0;
 }
@ -150,12 +154,13 @@ struct bitfield_data mc_enables_bf[] = {
 };

 static void
-printf_mc_usage()
+printf_mc_usage(void)
 {
 	struct bitfield_data * bf;
 	printf("MC Commands:\n");
 	printf("  reset <warm|cold>\n");
 	printf("  info\n");
+	printf("  selftest\n");
 	printf("  getenables\n");
 	printf("  setenables <option=on|off> ...\n");

@ -342,7 +347,11 @@ ipmi_mc_get_deviceid(struct ipmi_intf * intf)
 		IPM_DEV_IPMI_VERSION_MAJOR(devid->ipmi_version),
 		IPM_DEV_IPMI_VERSION_MINOR(devid->ipmi_version));
 	printf("Manufacturer ID           : %lu\n",
-		(long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id));
+           (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id));
+   printf("Manufacturer Name         : %s\n",
+            val2str( (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id), 
+            ipmi_oem_info) );
+
 	printf("Product ID                : %u (0x%02x%02x)\n",
 		buf2short((uint8_t *)(devid->product_id)),
 		devid->product_id[1], devid->product_id[0]);
@ -368,6 +377,15 @@ ipmi_mc_get_deviceid(struct ipmi_intf * intf)
 	return 0;
 }

+struct ipmi_guid {
+	uint32_t  time_low;	/* timestamp low field */
+	uint16_t  time_mid;	/* timestamp middle field */
+	uint16_t  time_hi_and_version; /* timestamp high field and version number */
+	uint8_t   clock_seq_hi_variant;/* clock sequence high field and variant */
+	uint8_t   clock_seq_low; /* clock sequence low field */
+	uint8_t   node[6];	/* node */
+} __attribute__((packed));
+
 /* ipmi_mc_get_guid  -  print this MC GUID
 *
 * @intf:	ipmi interface
@ -380,6 +398,7 @@ ipmi_mc_get_guid(struct ipmi_intf * intf)
 {
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
+	struct ipmi_guid guid;

 	memset(&req, 0, sizeof(req));
 	req.msg.netfn = IPMI_NETFN_APP;
@ -396,11 +415,116 @@ ipmi_mc_get_guid(struct ipmi_intf * intf)
 		return -1;
 	}

-	printf("System GUID: %s\n", buf2str(rsp->data, rsp->data_len));
+	if (rsp->data_len == sizeof(struct ipmi_guid)) {
+		uint8_t tbuf[40];
+		time_t s;
+		memset(tbuf, 0, 40);
+		memset(&guid, 0, sizeof(struct ipmi_guid));
+		memcpy(&guid, rsp->data, rsp->data_len);
+
+		printf("System GUID  : %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x\n",
+		       guid.time_low, guid.time_mid, guid.time_hi_and_version,
+		       guid.clock_seq_hi_variant << 8 | guid.clock_seq_low,
+		       guid.node[5], guid.node[4], guid.node[3],
+		       guid.node[2], guid.node[1], guid.node[0]);
+
+		s = (time_t)BSWAP_32(guid.time_low);
+		strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s));
+		printf("Timestamp    : %s\n", tbuf);
+	}
+	else {
+		lprintf(LOG_ERR, "Invalid GUID length %d", rsp->data_len);
+	}

 	return 0;
 }

+/* ipmi_mc_get_selftest -  returns and print selftest results
+ *
+ * @intf:	ipmi interface
+ */
+static int ipmi_mc_get_selftest(struct ipmi_intf * intf)
+{
+   int rv = 0;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct ipm_selftest_rsp *sft_res;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_APP;
+	req.msg.cmd = BMC_GET_SELF_TEST;
+	req.msg.data_len = 0;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (!rsp) {
+		lprintf(LOG_ERR, "No response from devices\n"); 
+		return -1;
+	}
+	if (rsp->ccode) {
+	   lprintf(LOG_ERR, "Bad response: (%s)",
+	                                 val2str(rsp->ccode, completion_code_vals));
+		return -1;
+	}
+
+	sft_res = (struct ipm_selftest_rsp *) rsp->data;
+
+	if (sft_res->code == IPM_SFT_CODE_OK) {
+		printf("Selftest: passed\n");
+		rv = 0;
+	}
+
+	else if (sft_res->code == IPM_SFT_CODE_NOT_IMPLEMENTED) {
+		printf("Selftest: not implemented\n");
+		rv = -1;
+	}
+
+	else if (sft_res->code == IPM_SFT_CODE_DEV_CORRUPTED) {
+		printf("Selftest: device corrupted\n");
+		rv = -1;
+
+		if (sft_res->test & IPM_SELFTEST_SEL_ERROR) {
+			printf(" -> SEL device not accessible\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_SDR_ERROR) {
+			printf(" -> SDR repository not accesible\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_FRU_ERROR) {
+			printf("FRU device not accessible\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_IPMB_ERROR) {
+			printf("IPMB signal lines do not respond\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_SDRR_EMPTY) {
+			printf("SDR repository empty\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_INTERNAL_USE) {
+			printf("Internal Use Area corrupted\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_FW_BOOTBLOCK) {
+			printf("Controller update boot block corrupted\n");
+		}
+		if (sft_res->test & IPM_SELFTEST_FW_CORRUPTED) {
+			printf("controller operational firmware corrupted\n");
+		}
+	}
+	else if (sft_res->code == IPM_SFT_CODE_FATAL_ERROR) {
+		printf("Selftest     : fatal error\n");
+		printf("Failure code : %02x\n", sft_res->test);
+		rv = -1;
+	}
+	else if (sft_res->code == IPM_SFT_CODE_RESERVED) {
+		printf("Selftest: N/A");
+		rv = -1;
+	}
+	else {
+		printf("Selttest     : device specific\n");
+		printf("Failure code : %02x\n", sft_res->test);
+		rv = 0;
+	}
+
+	return rv;
+}
+
 /* ipmi_mc_main  -  top-level handler for MC functions
 *
 * @intf:	ipmi interface
@ -444,6 +568,9 @@ ipmi_mc_main(struct ipmi_intf * intf, int argc, char ** argv)
 	else if (strncmp(argv[0], "setenables", 10) == 0) {
 		rc = ipmi_mc_set_enables(intf, argc-1, &(argv[1]));
 	}
+   else if (!strncmp(argv[0], "selftest", 8)) {
+		rc = ipmi_mc_get_selftest(intf);
+	}

 	return rc;
 }
--- a/ipmitool/lib/ipmi_oem.c
+++ b/ipmitool/lib/ipmi_oem.c
@ -56,7 +56,10 @@ static struct ipmi_oem_handle ipmi_oem_list[] = {
 		name:	"intelplus",
 		desc:	"Intel IPMI 2.0 BMC with RMCP+ communication support",
 	},
-
+	{
+		name:   "icts",
+		desc:   "IPMI 2.0 ICTS compliance support",
+	},
 	{ 0 },
 };

--- a/ipmitool/lib/ipmi_pef.c
+++ b/ipmitool/lib/ipmi_pef.c
@ -285,8 +285,8 @@ ipmi_pef_print_lan_dest(struct ipmi_intf * intf, uint8_t ch, uint8_t dest)
 		return;
 	}
 	tbl_size = (rsp->data[1] & PEF_LAN_DEST_TABLE_SIZE_MASK);
-	if (!dest || tbl_size == 0)	/* LAN alerting not supported */
-		return;
+	//if (tbl_size == 0 || dest == 0)	/* LAN alerting not supported */
+	//	return;

 	lsel.id = PEF_LAN_CFGPARM_ID_DESTTYPE;
 	lsel.set = dest;
@ -690,7 +690,7 @@ ipmi_pef_list_policies(struct ipmi_intf * intf)

 			if (ptmp->entry.alert_string_key & PEF_POLICY_EVENT_SPECIFIC) {
 				ipmi_pef_print_str("Event-specific", "true");
-				continue;
+//				continue;
 			}			
 			wrk = ptmp->entry.chan_dest;

@ -771,6 +771,15 @@ ipmi_pef_get_status(struct ipmi_intf * intf)
 		return;
 	}
 	ipmi_pef_print_flags(&pef_b2s_control, P_ABLE, rsp->data[1]);
+
+	psel.id = PEF_CFGPARM_ID_PEF_ACTION;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "PEF action");
+	if (!rsp) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"PEF action");
+		return;
+	}
+	ipmi_pef_print_flags(&pef_b2s_actions, P_ACTV, rsp->data[1]);
 }

 static void
--- a/ipmitool/lib/ipmi_picmg.c
+++ b/ipmitool/lib/ipmi_picmg.c
@ -0,0 +1,747 @@
+
+/*
+	(C) Kontron
+
+*/
+
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_picmg.h>
+#include <ipmitool/ipmi_fru.h>		/* for access to link descriptor defines */
+
+
+int 
+ipmi_picmg_help (void)
+{
+	printf(" properties     - get PICMG properties\n");
+	printf(" addrinfo       - get address information\n");
+	printf(" activate       - activate a FRU\n");
+	printf(" deactivate     - deactivate a FRU\n");
+	printf(" policy get     - get the FRU activation policy\n");
+	printf(" policy set     - set the FRU activation policy\n");
+	printf(" portstate get  - get port state \n");
+	printf(" portstate set  - set port state \n");
+	printf(" led prop       - get led properties\n");
+	printf(" led cap        - get led color capabilities\n");
+	printf(" led state get  - get led state\n");
+	printf(" led state set  - set led state\n");
+	printf(" power get      - get power level info\n");
+	printf(" power set      - set power level\n");
+}
+
+int
+ipmi_picmg_getaddr(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	unsigned char msg_data;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = PICMG_GET_ADDRESS_INFO_CMD;
+	req.msg.data = &msg_data;
+	req.msg.data_len = 1;
+	msg_data = 0;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (!rsp  || rsp->ccode) {
+		printf("Error getting address information\n");
+		return -1;
+	}
+
+	printf("Hardware Address : 0x%02x\n", rsp->data[1]);
+	printf("IPMB-0 Address   : 0x%02x\n", rsp->data[2]);
+	printf("FRU ID           : 0x%02x\n", rsp->data[4]);
+	printf("Site ID          : 0x%02x\n", rsp->data[5]);
+
+	printf("Site Type        : ");
+	switch (rsp->data[6]) {
+	case PICMG_ATCA_BOARD:
+		printf("ATCA board\n");
+		break;
+	case PICMG_POWER_ENTRY:
+		printf("Power Entry Module\n");
+		break;
+	case PICMG_SHELF_FRU:
+		printf("Shelf FRU\n");
+		break;
+	case PICMG_DEDICATED_SHMC:
+		printf("Dedicated Shelf Manager\n");
+		break;
+	case PICMG_FAN_TRAY:
+		printf("Fan Tray\n");
+		break;
+	case PICMG_FAN_FILTER_TRAY:
+		printf("Fan Filter Tray\n");
+		break;
+	case PICMG_ALARM:
+		printf("Alarm module\n");
+		break;
+	case PICMG_AMC:
+		printf("AMC\n");
+		break;
+	case PICMG_PMC:
+	 	printf("PMC\n");
+	 	break;
+	 case PICMG_RTM:
+	 	printf("RTM\n");
+		break;
+	default:
+		if (rsp->data[6] >= 0xc0 && rsp->data[6] <= 0xcf) {
+			printf("OEM\n");
+		} else {
+			printf("unknown\n");
+		}
+	}
+
+	return 0;
+}
+
+int
+ipmi_picmg_properties(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	unsigned char msg_data;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn    = IPMI_NETFN_PICMG;
+	req.msg.cmd      = PICMG_GET_PICMG_PROPERTIES_CMD;
+	req.msg.data     = &msg_data;
+	req.msg.data_len = 1;
+	msg_data = 0;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (!rsp  || rsp->ccode) {
+		printf("Error getting address information\n");
+		return -1;
+	}
+
+	printf("PICMG identifier   : 0x%02x\n", rsp->data[0]);
+	printf("PICMG Ext. Version : %i.%i\n",  rsp->data[1]&0x0f, (rsp->data[1]&0xf0) >> 4);
+	printf("Max FRU Device ID  : 0x%02x\n", rsp->data[2]);
+	printf("FRU Device ID      : 0x%02x\n", rsp->data[3]);
+}
+
+
+
+#define PICMG_FRU_DEACTIVATE	(unsigned char) 0x00
+#define PICMG_FRU_ACTIVATE    	(unsigned char) 0x01
+
+int
+ipmi_picmg_fru_activation(struct ipmi_intf * intf, int argc, char ** argv, unsigned char state)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	struct picmg_set_fru_activation_cmd cmd;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn    = IPMI_NETFN_PICMG;
+	req.msg.cmd      = PICMG_FRU_ACTIVATION_CMD;
+	req.msg.data     = (unsigned char*) &cmd;
+	req.msg.data_len = 3;
+
+	cmd.picmg_id  = 0;								/* PICMG identifier */
+	cmd.fru_id    = (unsigned char) atoi(argv[0]);	/* FRU ID 			*/
+	cmd.fru_state = state;
+
+	rsp = intf->sendrecv(intf, &req);
+
+	if (!rsp  || rsp->ccode) {
+		printf("Error activation/deactivation of FRU\n");
+		return -1;
+	}
+	if (rsp->data[0] != 0x00) {
+		printf("Error\n");
+	}
+
+	return 0;
+}
+
+
+int
+ipmi_picmg_fru_activation_policy_get(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	unsigned char msg_data[4];
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn    = IPMI_NETFN_PICMG;
+	req.msg.cmd      = PICMG_GET_FRU_POLICY_CMD;
+	req.msg.data     = msg_data;
+	req.msg.data_len = 2;
+
+	msg_data[0] = 0;								/* PICMG identifier */
+	msg_data[1] = (unsigned char) atoi(argv[0]);	/* FRU ID 			*/
+
+
+	rsp = intf->sendrecv(intf, &req);
+
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+
+	printf("Activation Policy for FRU %x: ", atoi(argv[0]) );
+	printf(" %s\n",(*(rsp->data+3)&0x01 == 0x01)?"is locked":"is not locked");
+
+	return 0;
+}
+
+int
+ipmi_picmg_portstate_get(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	unsigned char msg_data[4];
+
+	struct fru_picmgext_link_desc* d; /* descriptor pointer for rec. data */
+
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn    = IPMI_NETFN_PICMG;
+	req.msg.cmd      = PICMG_GET_PORT_STATE_CMD;
+	req.msg.data     = msg_data;
+	req.msg.data_len = 2;
+
+	msg_data[0] = 0x00;						/* PICMG identifier */
+	msg_data[1] = (atoi(argv[0]) & 0x3)<<6;	/* interface      */
+	msg_data[1] |= (atoi(argv[1]) & 0x3F);	/* channel number */
+
+	rsp = intf->sendrecv(intf, &req);
+
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+
+	if (rsp->data_len == 6) {
+		d = (struct fru_picmgext_link_desc *) &(rsp->data[1]);
+
+		printf("      Link Grouping ID:     0x%02x\n", d->grouping);
+		printf("      Link Type Extension:  0x%02x\n", d->ext);
+		printf("      Link Type:            ");
+		if (d->type == 0 || d->type == 0xff)
+		{
+			printf("Reserved\n");
+		}
+		else if (d->type >= 0x06 && d->type <= 0xef)
+		{
+			printf("Reserved\n");
+		}
+		else if (d->type >= 0xf0 && d->type <= 0xfe)
+		{
+			printf("OEM GUID Definition\n");
+		}
+		else
+		{
+			switch (d->type)
+			{
+				case FRU_PICMGEXT_LINK_TYPE_BASE:
+					printf("PICMG 3.0 Base Interface 10/100/1000\n");
+					break;
+				case FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET:
+					printf("PICMG 3.1 Ethernet Fabric Interface\n");
+					break;
+				case FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND:
+					printf("PICMG 3.2 Infiniband Fabric Interface\n");
+					break;
+				case FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR:
+					printf("PICMG 3.3 Star Fabric Interface\n");
+					break;
+				case  FRU_PICMGEXT_LINK_TYPE_PCIE:
+					printf("PCI Express Fabric Interface\n");
+				default:
+					printf("Invalid\n");
+			}
+		}
+		printf("      Link Designator:      0x%03x\n", d->designator);
+		printf("        Port Flag:            0x%02x\n", d->designator >> 8);
+		printf("        Interface:            ");
+			switch ((d->designator & 0xff) >> 6)
+			{
+				case FRU_PICMGEXT_DESIGN_IF_BASE:
+					printf("Base Interface\n");
+					break;
+				case FRU_PICMGEXT_DESIGN_IF_FABRIC:
+					printf("Fabric Interface\n");
+					break;
+				case FRU_PICMGEXT_DESIGN_IF_UPDATE_CHANNEL:
+					printf("Update Channel\n");
+					break;
+				case FRU_PICMGEXT_DESIGN_IF_RESERVED:
+					printf("Reserved\n");
+				default:
+					printf("Invalid");
+			}
+		printf("        Channel Number:       0x%02x\n", d->designator & 0x1f);
+		printf("\n");
+		printf("        STATE: %s\n", rsp->data[5] == 0x01?"enabled":"disabled");
+	}
+
+
+	return 0;
+}
+
+int
+ipmi_picmg_portstate_set(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	unsigned char msg_data[6];
+	struct fru_picmgext_link_desc* d;
+
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn    = IPMI_NETFN_PICMG;
+	req.msg.cmd      = PICMG_SET_PORT_STATE_CMD;
+	req.msg.data     = msg_data;
+	req.msg.data_len = 6;
+
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+
+	d = (struct fru_picmgext_link_desc*) &(msg_data[1]);
+
+	d->designator = (unsigned char) (atoi(argv[0]) & 0x1F);        /* channel   */
+	d->designator = (unsigned char) ((atoi(argv[1]) & 0x03) << 6); /* interface */
+	d->designator = (unsigned char) ((atoi(argv[2]) & 0x03) << 8); /* port      */
+
+	d->type       = (unsigned char) (atoi(argv[3]) & 0xFF);       /* link type */
+	d->ext        = (unsigned char) (atoi(argv[4]) & 0x03);       /* type ext  */
+	d->grouping   = (unsigned char) (atoi(argv[5]) & 0xFF);       /* type ext  */
+
+	msg_data[5]   = (unsigned char) (atoi(argv[6]) & 0x01);       /* en/dis */
+
+	rsp = intf->sendrecv(intf, &req);
+
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+ipmi_picmg_get_led_properties(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	
+	unsigned char msg_data[6];
+	
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd   = PICMG_GET_FRU_LED_PROPERTIES_CMD;
+	req.msg.data  = msg_data;
+	req.msg.data_len = 2;
+	
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+	msg_data[1] = atoi(argv[0]);						/* FRU-ID */
+	
+	rsp = intf->sendrecv(intf, &req);
+	
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+	
+	printf("General Status LED Properties:  0x%2x\n\r", rsp->data[1] );	
+	printf("App. Specific  LED Count:       0x%2x\n\r", rsp->data[2] );	
+	
+	return 0;
+}
+
+int
+ipmi_picmg_get_led_capabilities(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int i;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	
+	unsigned char msg_data[6];
+	
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd   = PICMG_GET_LED_COLOR_CAPABILITIES_CMD;
+	req.msg.data  = msg_data;
+	req.msg.data_len = 3;
+	
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+	msg_data[1] = atoi(argv[0]);						/* FRU-ID */
+	msg_data[2] = atoi(argv[1]);						/* LED-ID */
+	
+	
+	rsp = intf->sendrecv(intf, &req);
+	
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+	
+	printf("LED Color Capabilities: ", rsp->data[1] );	
+	for ( i=0 ; i<8 ; i++ ) {
+		if ( rsp->data[1] & (0x01 << i) ) {
+			printf("%s, ", led_color_str[ i ]);
+		}
+	}
+	printf("\n\r");
+	
+	printf("Default LED Color in\n\r");
+	printf("      LOCAL control:  %s\n\r", led_color_str[ rsp->data[2] ] );	
+	printf("      OVERRIDE state: %s\n\r", led_color_str[ rsp->data[3] ] );
+	
+	return 0;
+}
+
+int
+ipmi_picmg_get_led_state(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int i;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	
+	unsigned char msg_data[6];
+	
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd   = PICMG_GET_FRU_LED_STATE_CMD;
+	req.msg.data  = msg_data;
+	req.msg.data_len = 3;
+	
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+	msg_data[1] = atoi(argv[0]);						/* FRU-ID */
+	msg_data[2] = atoi(argv[1]);						/* LED-ID */
+	
+	
+	rsp = intf->sendrecv(intf, &req);
+	
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+	
+	printf("LED states:                   %x\n\r", rsp->data[1] );
+	printf("  Local Control function:     %x\n\r", rsp->data[2] );
+	printf("  Local Control On-Duration:  %x\n\r", rsp->data[3] );
+	printf("  Local Control Color:        %s\n\r", led_color_str[ rsp->data[4] ]);
+	
+	/* override state or lamp test */
+	if (rsp->data[1] == 0x01) {
+		printf("  Override function:     %x\n\r", rsp->data[5] );
+		printf("  Override On-Duration:  %x\n\r", rsp->data[6] );
+		printf("  Override Color:        %s\n\r", led_color_str[ rsp->data[7] ]);
+		
+	}else if (rsp->data[1] == 0x03) {
+		printf("  Override function:     %x\n\r", rsp->data[5] );
+		printf("  Override On-Duration:  %x\n\r", rsp->data[6] );
+		printf("  Override Color:        %s\n\r", led_color_str[ rsp->data[7] ]);
+		printf("  Lamp test duration:    %x\n\r", rsp->data[8] );
+	}
+	
+	return 0;
+}
+
+int
+ipmi_picmg_set_led_state(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int i;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	
+	unsigned char msg_data[6];
+	
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd   = PICMG_SET_FRU_LED_STATE_CMD;
+	req.msg.data  = msg_data;
+	req.msg.data_len = 6;
+	
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+	msg_data[1] = atoi(argv[0]);						/* FRU-ID           */
+	msg_data[2] = atoi(argv[1]);						/* LED-ID           */
+	msg_data[3] = atoi(argv[2]);						/* LED function     */
+	msg_data[4] = atoi(argv[3]);						/* LED on duration  */
+	msg_data[5] = atoi(argv[4]);						/* LED color        */
+	
+	rsp = intf->sendrecv(intf, &req);
+	
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+	
+		
+	return 0;
+}
+
+int
+ipmi_picmg_get_power_level(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int i;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	
+	unsigned char msg_data[6];
+	
+	memset(&req, 0, sizeof(req));
+
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd   = PICMG_GET_POWER_LEVEL_CMD;
+	req.msg.data  = msg_data;
+	req.msg.data_len = 3;
+	
+	msg_data[0] = 0x00;	        						/* PICMG identifier */
+	msg_data[1] = atoi(argv[0]);						/* FRU-ID           */
+	msg_data[2] = atoi(argv[1]);						/* Power type       */
+	
+	
+	rsp = intf->sendrecv(intf, &req);
+	
+	if (!rsp) {
+		printf("no response\n");
+		return -1;
+	}
+
+	if (rsp->ccode) {
+		printf("returned CC code 0x%02x\n", rsp->ccode);
+		return -1;
+	}
+	
+	printf("Dynamic Power Configuration: %s\n", (rsp->data[1]&0x80)==0x80?"enabled":"disabled" );
+	printf("Actual Power Level:          %i\n", (rsp->data[1] & 0xf));
+	printf("Delay to stable Power:       %i\n", rsp->data[2]);
+	printf("Power Multiplier:            %i\n", rsp->data[3]);
+	
+	
+	for ( i = 1; i+3 < rsp->data_len ; i++ ) {
+		printf("   Power Draw %i:            %i\n", i, rsp->data[i+3]);
+	}
+	return 0;
+}
+
+int
+ipmi_picmg_main (struct ipmi_intf * intf, int argc, char ** argv)
+{
+   int rc;
+
+	if (argc == 0 || (!strncmp(argv[0], "help", 4))) {
+		ipmi_picmg_help();
+		return 0;
+	}
+
+	/* address info command */
+	else if (!strncmp(argv[0], "addrinfo", 8)) {
+		rc = ipmi_picmg_getaddr(intf);
+	}
+	
+	/* picmg properties command */
+	else if (!strncmp(argv[0], "properties", 10)) {
+		rc = ipmi_picmg_properties(intf);
+	}
+
+	/* fru activation command */
+	else if (!strncmp(argv[0], "activate", 8)) {
+		if (argc > 1) {
+			rc = ipmi_picmg_fru_activation(intf, argc-1, &(argv[1]), PICMG_FRU_ACTIVATE);
+		}
+		else {
+			printf("specify the FRU to activate\n");
+			return -1;
+		}
+	}
+
+	/* fru deactivation command */
+	else if (!strncmp(argv[0], "deactivate", 10)) {
+		if (argc > 1) {
+			rc = ipmi_picmg_fru_activation(intf, argc-1, &(argv[1]), PICMG_FRU_DEACTIVATE);
+		}else {
+			printf("specify the FRU to deactivate\n");
+			return -1;
+		}
+	}
+
+	/* activation policy command */
+	else if (!strncmp(argv[0], "policy", 6)) {
+		if (argc > 2) {
+			if (!strncmp(argv[1], "get", 3)) {
+				rc = ipmi_picmg_fru_activation_policy_get(intf, argc-1, &(argv[2]));
+			}
+			else if (!strncmp(argv[1], "set", 6)) {
+				printf("tbd\n");
+				return -1;
+			}
+			else {
+				printf("specify fru\n");
+				return -1;
+			}
+		}else {
+			printf("wrong parameters\n");
+			return -1;
+		}
+	}
+
+	/* portstate command */
+	else if (!strncmp(argv[0], "portstate", 9)) {
+		if (argc > 2) {
+			if (!strncmp(argv[1], "get", 3)) {
+				rc = ipmi_picmg_portstate_get(intf, argc-1, &(argv[2]));
+			}
+
+			else {
+				printf("portstate get <intf><chn>\n");
+			}
+		}
+
+		else if (!strncmp(argv[1], "set", 3)) {
+			if (argc > 5) {
+				rc = ipmi_picmg_portstate_set(intf, argc-1, &(argv[2]));
+			}
+			else {
+				printf("portstate set <chn><intf><port><type><typeext><group><en|dis>\n");
+				return -1;
+			}
+		}
+		else {
+			printf("<set>|<get>\n");
+			return -1;
+		}
+	}
+	
+	/* ATCA led commands */
+	else if (!strncmp(argv[0], "led", 3)) {
+		if (argc > 1) {
+			if (!strncmp(argv[1], "prop", 4)) {
+				if (argc > 2) {
+					rc = ipmi_picmg_get_led_properties(intf, argc-1, &(argv[2]));	
+				}
+				else {
+					printf("led prop <FRU-ID>\n");
+				}
+			}
+			else if (!strncmp(argv[1], "cap", 3)) {
+				if (argc > 3) {
+					rc = ipmi_picmg_get_led_capabilities(intf, argc-1, &(argv[2]));	
+				}
+				else {
+					printf("led cap <FRU-ID> <LED-ID>\n");
+				}
+			}
+			else if (!strncmp(argv[1], "get", 3)) {
+				if (argc > 3) {
+					rc = ipmi_picmg_get_led_state(intf, argc-1, &(argv[2]));	
+				}
+				else {
+					printf("led get <FRU-ID> <LED-ID>\n");
+				}
+			}
+			else if (!strncmp(argv[1], "set", 3)) {
+				if (argc > 6) {
+					rc = ipmi_picmg_set_led_state(intf, argc-1, &(argv[2]));	
+				}
+				else {
+					printf("led set <FRU-ID> <LED-ID> <function> <duration> <color>\n");
+					printf("   <FRU-ID>\n");
+					printf("   <LED-ID>\n"); 
+					printf("   <function>  0:       LED OFF override\n");
+					printf("               1 - 250: LED blinking override (off duration)\n");
+					printf("               251:     LED Lamp Test\n");
+					printf("               252:     LED restore to local control\n");
+					printf("               255:     LED ON override\n");
+					printf("   <duration>  1 - 127: LED Lamp Test / on duration\n");
+					printf("   <color>     \n");
+				}
+			}
+			else {
+				printf("prop | cap | get | set\n");
+			}
+		}
+	}
+	/* power commands */
+	else if (!strncmp(argv[0], "power", 5)) {
+		if (argc > 1) {
+			if (!strncmp(argv[1], "get", 3)) {
+				if (argc > 3) {
+					rc = ipmi_picmg_get_power_level(intf, argc-1, &(argv[2]));
+				}
+				else {
+					printf("power get <FRI-ID> <type>\n");
+					printf("   <type>   0 : steady state powert draw levels\n");
+					printf("            1 : desired steady state draw levels\n");
+					printf("            2 : early power draw levels\n");
+					printf("            3 : desired early levels\n");
+					
+					return -1;
+				}
+			}
+			else if (!strncmp(argv[1], "set", 3)) {
+				if (argc > 5) {
+					printf("not implemented yet\n");
+				}
+				else {
+					return -1;
+				}
+			}
+			else {
+				printf("<set>|<get>\n");
+				return -1;
+			}
+		}
+		else {
+			printf("<set>|<get>\n");  
+			return -1;
+		}
+	}
+
+	else {
+		
+		ipmi_picmg_help();
+		return -1;
+	}
+	
+	return rc;
+
+}
--- a/ipmitool/lib/ipmi_raw.c
+++ b/ipmitool/lib/ipmi_raw.c
@ -43,19 +43,190 @@
 #include <ipmitool/helper.h>
 #include <ipmitool/ipmi_intf.h>
 #include <ipmitool/ipmi_raw.h>
+#include <ipmitool/ipmi_strings.h>
+
+#define IPMI_I2C_MASTER_MAX_SIZE	0x40
+
+/* ipmi_master_write_read  -  Perform I2C write/read transactions
+ *
+ * This function performs an I2C master write-read function through
+ * IPMI interface.  It has a maximum transfer size of 32 bytes.
+ *
+ * @intf:	ipmi interface
+ * @addr:	i2c slave address
+ * @wdata:	data to write
+ * @wsize:	length of data to write (max 64 bytes)
+ * @rsize:	length of data to read (max 64 bytes)
+ *
+ * Returns pointer to IPMI Response
+ */
+struct ipmi_rs *
+ipmi_master_write_read(struct ipmi_intf * intf, uint8_t addr, uint8_t * wdata, uint8_t wsize, uint8_t rsize)
+{
+	struct ipmi_rq req;
+	struct ipmi_rs * rsp;
+	uint8_t rqdata[IPMI_I2C_MASTER_MAX_SIZE + 3];
+
+	if (rsize > IPMI_I2C_MASTER_MAX_SIZE) {
+		lprintf(LOG_ERR, "Master Write-Read: Too many bytes (%d) to read", rsize);
+		return NULL;
+	}
+	if (wsize > IPMI_I2C_MASTER_MAX_SIZE) {
+		lprintf(LOG_ERR, "Master Write-Read: Too many bytes (%d) to write", wsize);
+		return NULL;
+	}
+
+	memset(&req, 0, sizeof(struct ipmi_rq));
+	req.msg.netfn = IPMI_NETFN_APP;
+	req.msg.cmd = 0x52;	/* master write-read */
+	req.msg.data = rqdata;
+	req.msg.data_len = 3;
+
+	memset(rqdata, 0, IPMI_I2C_MASTER_MAX_SIZE + 3);
+	rqdata[0] = 0x00;	/* channel number, bus id, bus type */
+	rqdata[1] = addr;	/* slave address */
+	rqdata[2] = rsize;      /* number of bytes to read */
+
+	if (wsize > 0) {
+		/* copy in data to write */
+		memcpy(rqdata+3, wdata, wsize);
+		req.msg.data_len += wsize;
+		lprintf(LOG_DEBUG, "Writing %d bytes to i2cdev %02Xh", wsize, addr);
+	}
+
+	if (rsize > 0) {
+		lprintf(LOG_DEBUG, "Reading %d bytes from i2cdev %02Xh", rsize, addr);
+	}
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "I2C Master Write-Read command failed");
+		return NULL;
+	}
+	else if (rsp->ccode > 0) {
+		switch (rsp->ccode) {
+		case 0x81:
+			lprintf(LOG_ERR, "I2C Master Write-Read command failed: Lost Arbitration");
+			break;
+		case 0x82:
+			lprintf(LOG_ERR, "I2C Master Write-Read command failed: Bus Error");
+			break;
+		case 0x83:
+			lprintf(LOG_ERR, "I2C Master Write-Read command failed: NAK on Write");
+			break;
+		case 0x84:
+			lprintf(LOG_ERR, "I2C Master Write-Read command failed: Truncated Read");
+			break;
+		default:
+			lprintf(LOG_ERR, "I2C Master Write-Read command failed: %s",
+				val2str(rsp->ccode, completion_code_vals));
+			break;
+		}
+		return NULL;
+	}
+
+	return rsp;
+}
+
+static void rawi2c_usage(void)
+{
+	lprintf(LOG_NOTICE, "usage: i2c <i2caddr> <read bytes> [write data]");
+}
+
+int
+ipmi_rawi2c_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_rs * rsp;
+	uint8_t wdata[IPMI_I2C_MASTER_MAX_SIZE];
+	uint8_t i2caddr = 0;
+	uint8_t rsize = 0;
+	uint8_t wsize = 0;
+	int i;
+
+	if (argc < 2 || strncmp(argv[0], "help", 4) == 0) {
+		rawi2c_usage();
+		return 0;
+	}
+	else if (argc-2 > IPMI_I2C_MASTER_MAX_SIZE) {
+		lprintf(LOG_ERR, "Raw command input limit (%d bytes) exceeded",
+			IPMI_I2C_MASTER_MAX_SIZE);
+		return -1;
+	}
+
+	i2caddr = (uint8_t)strtoul(argv[0], NULL, 0);
+	rsize = (uint8_t)strtoul(argv[1], NULL, 0);
+
+	if (i2caddr == 0) {
+		lprintf(LOG_ERR, "Invalid I2C address 0");
+		rawi2c_usage();
+		return -1;
+	}
+
+	memset(wdata, 0, IPMI_I2C_MASTER_MAX_SIZE);
+	for (i=2; i<argc; i++) {
+		uint8_t val = (uint8_t)strtol(argv[i], NULL, 0);
+		wdata[i-2] = val;
+		wsize++;
+	}
+
+	lprintf(LOG_INFO, "RAW I2C REQ (i2caddr=%x readbytes=%d writebytes=%d)",
+		i2caddr, rsize, wsize);
+	printbuf(wdata, wsize, "WRITE DATA");
+
+	rsp = ipmi_master_write_read(intf, i2caddr, wdata, wsize, rsize);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Unable to perform I2C Master Write-Read");
+		return -1;
+	}
+
+	if (wsize > 0) {
+		if (verbose || rsize == 0)
+			printf("Wrote %d bytes to I2C device %02Xh\n", wsize, i2caddr);
+	}
+
+	if (rsize > 0) {
+		if (verbose || wsize == 0)
+			printf("Read %d bytes from I2C device %02Xh\n", rsp->data_len, i2caddr);
+
+		/* print the raw response buffer */
+		for (i=0; i<rsp->data_len; i++) {
+			if (((i%16) == 0) && (i != 0))
+				printf("\n");
+			printf(" %2.2x", rsp->data[i]);
+		}
+		printf("\n");
+
+		if (rsp->data_len <= 4) {
+			uint32_t bit;
+			int j;
+			for (i = 0; i < rsp->data_len; i++) {
+				for (j = 1, bit = 0x80; bit > 0; bit /= 2, j++) {
+					printf("%s", (rsp->data[i] & bit) ? "1" : "0");
+				}
+				printf(" ");
+			}
+			printf("\n");
+		}
+	}
+
+	return 0;
+}

 int
 ipmi_raw_main(struct ipmi_intf * intf, int argc, char ** argv)
 {
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
-	uint8_t netfn, cmd;
+	uint8_t netfn, cmd, lun;
 	int i;
+	unsigned long ufn;

 	uint8_t data[256];

 	if (argc < 2 || strncmp(argv[0], "help", 4) == 0) {
 		lprintf(LOG_NOTICE, "RAW Commands:  raw <netfn> <cmd> [data]");
+		print_valstr(ipmi_netfn_vals, "Network Function Codes", LOG_NOTICE);
+		lprintf(LOG_NOTICE, "(can also use raw hex values)");
 		return -1;
 	}
 	else if (argc > sizeof(data))
@ -64,12 +235,21 @@ ipmi_raw_main(struct ipmi_intf * intf, int argc, char ** argv)
 		return -1;
 	}

-	netfn = (uint8_t)strtol(argv[0], NULL, 0);
+	ipmi_intf_session_set_timeout(intf, 15);
+	ipmi_intf_session_set_retry(intf, 1);
+
+	lun = intf->target_lun;
+	netfn = str2val(argv[0], ipmi_netfn_vals);
+	if (netfn == 0xff) {
+		netfn = (uint8_t)strtol(argv[0], NULL, 0);
+	}
+
 	cmd = (uint8_t)strtol(argv[1], NULL, 0);

 	memset(data, 0, sizeof(data));
 	memset(&req, 0, sizeof(req));
 	req.msg.netfn = netfn;
+	req.msg.lun = lun;	
 	req.msg.cmd = cmd;
 	req.msg.data = data;

@ -79,8 +259,10 @@ ipmi_raw_main(struct ipmi_intf * intf, int argc, char ** argv)
 		req.msg.data_len++;
 	}

-	lprintf(LOG_INFO, "RAW REQ (netfn=0x%x cmd=0x%x data_len=%d)",
-		req.msg.netfn, req.msg.cmd, req.msg.data_len);
+	lprintf(LOG_INFO, 
+           "RAW REQ (channel=0x%x netfn=0x%x lun=0x%x cmd=0x%x data_len=%d)",
+           intf->target_channel & 0x0f, req.msg.netfn,req.msg.lun , 
+           req.msg.cmd, req.msg.data_len);

 	printbuf(req.msg.data, req.msg.data_len, "RAW REQUEST");

@ -88,14 +270,14 @@ ipmi_raw_main(struct ipmi_intf * intf, int argc, char ** argv)

 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Unable to send RAW command "
-			"(netfn=0x%x cmd=0x%x)",
-			req.msg.netfn, req.msg.cmd);
+			"(channel=0x%x netfn=0x%x lun=0x%x cmd=0x%x)",
+			intf->target_channel & 0x0f, req.msg.netfn, req.msg.lun, req.msg.cmd);
 		return -1;
 	}
 	if (rsp->ccode > 0) {
 		lprintf(LOG_ERR, "Unable to send RAW command "
-			"(netfn=0x%x cmd=0x%x rsp=0x%x): %s",
-			req.msg.netfn, req.msg.cmd, rsp->ccode,
+			"(channel=0x%x netfn=0x%x lun=0x%x cmd=0x%x rsp=0x%x): %s",
+			intf->target_channel & 0x0f, req.msg.netfn, req.msg.lun, req.msg.cmd, rsp->ccode,
 			val2str(rsp->ccode, completion_code_vals));
 		return -1;
 	}
--- a/ipmitool/lib/ipmi_sdr.c
+++ b/ipmitool/lib/ipmi_sdr.c
--- a/ipmitool/lib/ipmi_sel.c
+++ b/ipmitool/lib/ipmi_sel.c
--- a/ipmitool/lib/ipmi_sensor.c
+++ b/ipmitool/lib/ipmi_sensor.c
@ -51,32 +51,16 @@ extern int verbose;

 static
 struct ipmi_rs *
-ipmi_sensor_get_sensor_thresholds(struct ipmi_intf * intf, uint8_t sensor)
-{
-	struct ipmi_rq req;
-
-	memset(&req, 0, sizeof(req));
-	req.msg.netfn = IPMI_NETFN_SE;
-	req.msg.cmd = GET_SENSOR_THRESHOLDS;
-	req.msg.data = &sensor;
-	req.msg.data_len = sizeof(sensor);
-
-	return intf->sendrecv(intf, &req);
-}
-
-static
-struct ipmi_rs *
-ipmi_sensor_set_sensor_thresholds(struct ipmi_intf * intf, 
-                                  uint8_t sensor,
-                                  uint8_t threshold,
-                                  uint8_t setting)
+ipmi_sensor_set_sensor_thresholds(struct ipmi_intf *intf,
+				  uint8_t sensor,
+				  uint8_t threshold, uint8_t setting)
 {
 	struct ipmi_rq req;
 	static struct sensor_set_thresh_rq set_thresh_rq;

-	memset(&set_thresh_rq, 0, sizeof(set_thresh_rq));
+	memset(&set_thresh_rq, 0, sizeof (set_thresh_rq));
 	set_thresh_rq.sensor_num = sensor;
-	set_thresh_rq.set_mask   = threshold;
+	set_thresh_rq.set_mask = threshold;
 	if (threshold == UPPER_NON_RECOV_SPECIFIED)
 		set_thresh_rq.upper_non_recov = setting;
 	else if (threshold == UPPER_CRIT_SPECIFIED)
@ -92,35 +76,37 @@ ipmi_sensor_set_sensor_thresholds(struct ipmi_intf * intf,
 	else
 		return NULL;

-	memset(&req, 0, sizeof(req));
+	memset(&req, 0, sizeof (req));
 	req.msg.netfn = IPMI_NETFN_SE;
 	req.msg.cmd = SET_SENSOR_THRESHOLDS;
-	req.msg.data = (uint8_t *)&set_thresh_rq;
-	req.msg.data_len = sizeof(set_thresh_rq);
+	req.msg.data = (uint8_t *) & set_thresh_rq;
+	req.msg.data_len = sizeof (set_thresh_rq);

 	return intf->sendrecv(intf, &req);
 }

 static int
-ipmi_sensor_print_full_discrete(struct ipmi_intf * intf,
-                                struct sdr_record_full_sensor * sensor)
+ipmi_sensor_print_full_discrete(struct ipmi_intf *intf,
+				struct sdr_record_full_sensor *sensor)
 {
 	char id[17];
-	char * unitstr = "discrete";
-	int validread=1;
+	char *unitstr = "discrete";
+	int validread = 1;
 	uint8_t val = 0;
-	struct ipmi_rs * rsp;
+	struct ipmi_rs *rsp;

 	if (sensor == NULL)
 		return -1;

-	memset(id, 0, sizeof(id));
+	memset(id, 0, sizeof (id));
 	memcpy(id, sensor->id_string, 16);

 	/*
 	 * Get current reading
 	 */
-	rsp = ipmi_sdr_get_sensor_reading(intf, sensor->keys.sensor_num);
+	rsp = ipmi_sdr_get_sensor_reading_ipmb(intf,
+					       sensor->keys.sensor_num,
+					       sensor->keys.owner_id);
 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Error reading sensor %s (#%02x)",
 			id, sensor->keys.sensor_num);
@ -132,12 +118,9 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf,
 		val = rsp->data[0];
 	}

-	if (csv_output)
-	{
+	if (csv_output) {
 		/* NOT IMPLEMENTED */
-	}
-	else
-	{
+	} else {
 		if (verbose == 0) {
 			/* output format
 			 *   id value units status thresholds....
@ -146,16 +129,12 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf,
 			if (validread) {
 				printf("| 0x%-8x | %-10s | 0x%02x%02x",
 				       val,
-				       unitstr,
-				       rsp->data[2],
-				       rsp->data[3]);
+				       unitstr, rsp->data[2], rsp->data[3]);
 			} else {
 				printf("| %-10s | %-10s | %-6s",
-				       "na",
-				       unitstr,
-				       "na");
+				       "na", unitstr, "na");
 			}
-			printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", 
+			printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s",
 			       "na", "na", "na", "na", "na", "na");

 			printf("\n");
@ -164,11 +143,14 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf,
 			       id, sensor->keys.sensor_num);
 			printf(" Entity ID             : %d.%d\n",
 			       sensor->entity.id, sensor->entity.instance);
-			printf(" Sensor Type (Discrete): %s\n", 
-			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.type));
-			ipmi_sdr_print_discrete_state(sensor->sensor.type,
+			printf(" Sensor Type (Discrete): %s\n",
+			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.
+							     type));
+			ipmi_sdr_print_discrete_state("States Asserted",
+						      sensor->sensor.type,
 						      sensor->event_type,
-						      rsp->data[2]);
+						      rsp->data[2],
+						      rsp->data[3]);
 			printf("\n");
 		}
 	}
@ -177,23 +159,23 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf,
 }

 static int
-ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
-                              struct sdr_record_full_sensor * sensor)
+ipmi_sensor_print_full_analog(struct ipmi_intf *intf,
+			      struct sdr_record_full_sensor *sensor)
 {
 	char unitstr[16], id[17];
-	int i=0, validread=1, thresh_available = 1;
+	int i = 0, validread = 1, thresh_available = 1;
 	double val = 0.0;
-	struct ipmi_rs * rsp;
-	char * status = NULL;
+	struct ipmi_rs *rsp;
+	char *status = NULL;

 	if (sensor == NULL)
 		return -1;

-	memset(id, 0, sizeof(id));
+	memset(id, 0, sizeof (id));
 	memcpy(id, sensor->id_string, 16);

 	/* only handle linear and linearized sensors (for now) */
-	if (sensor->linearization>=SDR_SENSOR_L_NONLINEAR) {
+	if (sensor->linearization >= SDR_SENSOR_L_NONLINEAR) {
 		printf("sensor %s non-linear!\n", id);
 		return -1;
 	}
@ -201,7 +183,9 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
 	/*
 	 * Get current reading
 	 */
-	rsp = ipmi_sdr_get_sensor_reading(intf, sensor->keys.sensor_num);
+	rsp = ipmi_sdr_get_sensor_reading_ipmb(intf,
+					       sensor->keys.sensor_num,
+					       sensor->keys.owner_id);
 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Error reading sensor %s (#%02x)",
 			id, sensor->keys.sensor_num);
@ -211,30 +195,29 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
 	} else {
 		/* convert RAW reading into units */
 		val = (rsp->data[0] > 0)
-			? sdr_convert_sensor_reading(sensor, rsp->data[0])
-			: 0;
-		status = (char*)ipmi_sdr_get_status(rsp->data[2]);
+		    ? sdr_convert_sensor_reading(sensor, rsp->data[0])
+		    : 0;
+		status = (char *) ipmi_sdr_get_status(sensor, rsp->data[2]);
 	}

 	/*
 	 * Figure out units
 	 */
-	memset(unitstr, 0, sizeof(unitstr));
-	switch (sensor->unit.modifier)
-	{
-        case 2:
-		i += snprintf(unitstr, sizeof(unitstr), "%s * %s",
+	memset(unitstr, 0, sizeof (unitstr));
+	switch (sensor->unit.modifier) {
+	case 2:
+		i += snprintf(unitstr, sizeof (unitstr), "%s * %s",
 			      unit_desc[sensor->unit.type.base],
 			      unit_desc[sensor->unit.type.modifier]);
 		break;
-        case 1:
-		i += snprintf(unitstr, sizeof(unitstr), "%s/%s",
+	case 1:
+		i += snprintf(unitstr, sizeof (unitstr), "%s/%s",
 			      unit_desc[sensor->unit.type.base],
 			      unit_desc[sensor->unit.type.modifier]);
 		break;
-        case 0:
-        default:
-		i += snprintf(unitstr, sizeof(unitstr), "%s",
+	case 0:
+	default:
+		i += snprintf(unitstr, sizeof (unitstr), "%s",
 			      unit_desc[sensor->unit.type.base]);
 		break;
 	}
@ -242,18 +225,14 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
 	/*
 	 * Get sensor thresholds
 	 */
-	rsp = ipmi_sensor_get_sensor_thresholds(intf, sensor->keys.sensor_num);
+	rsp = ipmi_sdr_get_sensor_thresholds(intf, sensor->keys.sensor_num);
 	if (rsp == NULL)
 		thresh_available = 0;

-	if (csv_output)
-	{
+	if (csv_output) {
 		/* NOT IPMLEMENTED */
-	}
-	else
-	{
-		if (verbose == 0)
-		{
+	} else {
+		if (verbose == 0) {
 			/* output format
 			 *   id value units status thresholds....
 			 */
@ -265,102 +244,145 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
 				printf("| %-10s | %-10s | %-6s",
 				       "na", unitstr, "na");
 			}
-			if (thresh_available)
-			{
-				if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) 
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[3])); 
+			if (thresh_available) {
+				if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[3]));
 				else
 					printf("| %-10s", "na");
-				if (rsp->data[0] & LOWER_CRIT_SPECIFIED)      
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[2])); 
+				if (rsp->data[0] & LOWER_CRIT_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[2]));
 				else
 					printf("| %-10s", "na");
-				if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)  
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[1])); 
+				if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[1]));
 				else
 					printf("| %-10s", "na");
-				if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED)  
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[4])); 
+				if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[4]));
 				else
 					printf("| %-10s", "na");
-				if (rsp->data[0] & UPPER_CRIT_SPECIFIED)      
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[5])); 
+				if (rsp->data[0] & UPPER_CRIT_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[5]));
 				else
 					printf("| %-10s", "na");
-				if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) 
-					printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[6])); 
+				if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED)
+					printf("| %-10.3f",
+					       sdr_convert_sensor_reading
+					       (sensor, rsp->data[6]));
 				else
 					printf("| %-10s", "na");
-			}
-			else
-			{
-				printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", 
-				       "na", "na", "na", "na", "na", "na");
+			} else {
+				printf
+				    ("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s",
+				     "na", "na", "na", "na", "na", "na");
 			}

 			printf("\n");
-		}
-		else
-		{
+		} else {
 			printf("Sensor ID              : %s (0x%x)\n",
 			       id, sensor->keys.sensor_num);

 			printf(" Entity ID             : %d.%d\n",
 			       sensor->entity.id, sensor->entity.instance);

-			printf(" Sensor Type (Analog)  : %s\n", 
-			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.type));
+			printf(" Sensor Type (Analog)  : %s\n",
+			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.
+							     type));

 			printf(" Sensor Reading        : ");
 			if (validread) {
 				uint16_t raw_tol = __TO_TOL(sensor->mtol);
-				double tol = sdr_convert_sensor_reading(sensor, raw_tol * 2);
+				double tol =
+				    sdr_convert_sensor_reading(sensor,
+							       raw_tol * 2);
 				printf("%.*f (+/- %.*f) %s\n",
-				       (val==(int)val) ? 0 : 3, 
-				       val, 
-				       (tol==(int)tol) ? 0 : 3, 
-				       tol, 
+				       (val == (int) val) ? 0 : 3, val,
+				       (tol == (int) tol) ? 0 : 3, tol,
 				       unitstr);
-				printf(" Status                : %s\n", status ? : "");
+				printf(" Status                : %s\n",
+				       status ? : "");

-				if (thresh_available)
-				{
-					if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) 
-						printf(" Lower Non-Recoverable : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[3])); 
+				if (thresh_available) {
+					if (rsp->
+					    data[0] & LOWER_NON_RECOV_SPECIFIED)
+						printf
+						    (" Lower Non-Recoverable : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[3]));
 					else
-						printf(" Lower Non-Recoverable : na\n");
-					if (rsp->data[0] & LOWER_CRIT_SPECIFIED)      
-						printf(" Lower Critical        : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[2])); 
+						printf
+						    (" Lower Non-Recoverable : na\n");
+					if (rsp->data[0] & LOWER_CRIT_SPECIFIED)
+						printf
+						    (" Lower Critical        : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[2]));
 					else
-						printf(" Lower Critical        : na\n");
-					if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)  
-						printf(" Lower Non-Critical    : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[1])); 
+						printf
+						    (" Lower Critical        : na\n");
+					if (rsp->
+					    data[0] & LOWER_NON_CRIT_SPECIFIED)
+						printf
+						    (" Lower Non-Critical    : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[1]));
 					else
-						printf(" Lower Non-Critical    : na\n");
-					if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED)  
-						printf(" Upper Non-Critical    : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[4])); 
+						printf
+						    (" Lower Non-Critical    : na\n");
+					if (rsp->
+					    data[0] & UPPER_NON_CRIT_SPECIFIED)
+						printf
+						    (" Upper Non-Critical    : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[4]));
 					else
-						printf(" Upper Non-Critical    : na\n");
-					if (rsp->data[0] & UPPER_CRIT_SPECIFIED)      
-						printf(" Upper Critical        : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[5])); 
+						printf
+						    (" Upper Non-Critical    : na\n");
+					if (rsp->data[0] & UPPER_CRIT_SPECIFIED)
+						printf
+						    (" Upper Critical        : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[5]));
 					else
-						printf(" Upper Critical        : na\n");
-					if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) 
-						printf(" Upper Non-Recoverable : %.3f\n",
-						       sdr_convert_sensor_reading(sensor, rsp->data[6])); 
+						printf
+						    (" Upper Critical        : na\n");
+					if (rsp->
+					    data[0] & UPPER_NON_RECOV_SPECIFIED)
+						printf
+						    (" Upper Non-Recoverable : %.3f\n",
+						     sdr_convert_sensor_reading
+						     (sensor, rsp->data[6]));
 					else
-						printf(" Upper Non-Recoverable : na\n");
+						printf
+						    (" Upper Non-Recoverable : na\n");
 				}
-			}
-			else
-			{
+			} else {
 				printf("Not Present\n");
 			}
+
+			ipmi_sdr_print_sensor_event_status(intf,
+							   sensor->keys.
+							   sensor_num,
+							   sensor->sensor.type,
+							   sensor->event_type,
+							   ANALOG_SENSOR);
+			ipmi_sdr_print_sensor_event_enable(intf,
+							   sensor->keys.
+							   sensor_num,
+							   sensor->sensor.type,
+							   sensor->event_type,
+							   ANALOG_SENSOR);
+
 			printf("\n");
 		}
 	}
@ -369,8 +391,8 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf,
 }

 int
-ipmi_sensor_print_full(struct ipmi_intf * intf,
-                       struct sdr_record_full_sensor * sensor)
+ipmi_sensor_print_full(struct ipmi_intf *intf,
+		       struct sdr_record_full_sensor *sensor)
 {
 	if (sensor->unit.analog != 3)
 		return ipmi_sensor_print_full_analog(intf, sensor);
@ -379,25 +401,27 @@ ipmi_sensor_print_full(struct ipmi_intf * intf,
 }

 int
-ipmi_sensor_print_compact(struct ipmi_intf * intf,
-                          struct sdr_record_compact_sensor * sensor)
+ipmi_sensor_print_compact(struct ipmi_intf *intf,
+			  struct sdr_record_compact_sensor *sensor)
 {
 	char id[17];
-	char * unitstr = "discrete";
+	char *unitstr = "discrete";
 	int validread = 1;
 	uint8_t val = 0;
-	struct ipmi_rs * rsp;
+	struct ipmi_rs *rsp;

 	if (sensor == NULL)
 		return -1;

-	memset(id, 0, sizeof(id));
+	memset(id, 0, sizeof (id));
 	memcpy(id, sensor->id_string, 16);

 	/*
 	 * Get current reading
 	 */
-	rsp = ipmi_sdr_get_sensor_reading(intf, sensor->keys.sensor_num);
+	rsp = ipmi_sdr_get_sensor_reading_ipmb(intf,
+					       sensor->keys.sensor_num,
+					       sensor->keys.owner_id);
 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Error reading sensor %s (#%02x)",
 			id, sensor->keys.sensor_num);
@ -409,14 +433,10 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf,
 		val = rsp->data[0];
 	}

-	if (csv_output)
-	{
+	if (csv_output) {
 		/* NOT IMPLEMENTED */
-	}
-	else
-	{
-		if (!verbose)
-		{
+	} else {
+		if (!verbose) {
 			/* output format
 			 *   id value units status thresholds....
 			 */
@ -431,19 +451,22 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf,
 				       "na", unitstr, "na");
 			}

-			printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", 
+			printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s",
 			       "na", "na", "na", "na", "na", "na");
 			printf("\n");
-		}
-		else
-		{
+		} else {
 			printf("Sensor ID              : %s (0x%x)\n",
 			       id, sensor->keys.sensor_num);
 			printf(" Entity ID             : %d.%d\n",
 			       sensor->entity.id, sensor->entity.instance);
-			printf(" Sensor Type (Discrete): %s\n", 
-			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.type));
-			ipmi_sdr_print_discrete_state(sensor->sensor.type, sensor->event_type, rsp->data[2]);
+			printf(" Sensor Type (Discrete): %s\n",
+			       ipmi_sdr_get_sensor_type_desc(sensor->sensor.
+							     type));
+			ipmi_sdr_print_discrete_state("States Asserted",
+						      sensor->sensor.type,
+						      sensor->event_type,
+						      rsp->data[2],
+						      rsp->data[3]);
 			printf("\n");
 		}
 	}
@ -452,10 +475,10 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf,
 }

 static int
-ipmi_sensor_list(struct ipmi_intf * intf)
+ipmi_sensor_list(struct ipmi_intf *intf)
 {
-	struct sdr_get_rs * header;
-	struct ipmi_sdr_iterator * itr;
+	struct sdr_get_rs *header;
+	struct ipmi_sdr_iterator *itr;
 	int rc = 0;

 	lprintf(LOG_DEBUG, "Querying SDR for sensor list");
@ -466,30 +489,34 @@ ipmi_sensor_list(struct ipmi_intf * intf)
 		return -1;
 	}

-	while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL)
-	{
+	while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) {
 		int r = 0;
-		uint8_t * rec;
+		uint8_t *rec;

 		rec = ipmi_sdr_get_record(intf, header, itr);
-		if (rec == NULL)
+		if (rec == NULL) {
+			lprintf(LOG_DEBUG, "rec == NULL");
 			continue;
+		}

-		switch(header->type)
-		{
+		switch (header->type) {
 		case SDR_RECORD_TYPE_FULL_SENSOR:
 			r = ipmi_sensor_print_full(intf,
-				(struct sdr_record_full_sensor *)rec);
+						   (struct
+						    sdr_record_full_sensor *)
+						   rec);
 			break;
 		case SDR_RECORD_TYPE_COMPACT_SENSOR:
 			r = ipmi_sensor_print_compact(intf,
-				(struct sdr_record_compact_sensor *)rec);
+						      (struct
+						       sdr_record_compact_sensor
+						       *) rec);
 			break;
 		}
 		free(rec);

 		/* save any errors */
-		rc = (r == 0) ? rc : r; 
+		rc = (r == 0) ? rc : r;
 	}

 	ipmi_sdr_end(intf, itr);
@ -498,80 +525,22 @@ ipmi_sensor_list(struct ipmi_intf * intf)
 }

 static const struct valstr threshold_vals[] = {
-	{ UPPER_NON_RECOV_SPECIFIED,	"Upper Non-Recoverable" },
-	{ UPPER_CRIT_SPECIFIED,		"Upper Critical" },
-	{ UPPER_NON_CRIT_SPECIFIED,	"Upper Non-Critical" },
-	{ LOWER_NON_RECOV_SPECIFIED,	"Lower Non-Recoverable" },
-	{ LOWER_CRIT_SPECIFIED,		"Lower Critical" },
-	{ LOWER_NON_CRIT_SPECIFIED,	"Lower Non-Critical" },
-	{ 0x00,				NULL },
+	{UPPER_NON_RECOV_SPECIFIED, "Upper Non-Recoverable"},
+	{UPPER_CRIT_SPECIFIED, "Upper Critical"},
+	{UPPER_NON_CRIT_SPECIFIED, "Upper Non-Critical"},
+	{LOWER_NON_RECOV_SPECIFIED, "Lower Non-Recoverable"},
+	{LOWER_CRIT_SPECIFIED, "Lower Critical"},
+	{LOWER_NON_CRIT_SPECIFIED, "Lower Non-Critical"},
+	{0x00, NULL},
 };

 static int
-ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv)
+__ipmi_sensor_set_threshold(struct ipmi_intf *intf,
+			    uint8_t num, uint8_t mask, uint8_t setting)
 {
-	char * id, * thresh;
-	uint8_t settingMask;
-	double setting;
-	struct sdr_record_list * sdr;
-	struct ipmi_rs * rsp;
+	struct ipmi_rs *rsp;

-	if (argc < 3 || strncmp(argv[0], "help", 4) == 0)
-	{
-		lprintf(LOG_NOTICE, "sensor thresh <id> <threshold> <setting>");
-		lprintf(LOG_NOTICE, "   id        : name of the sensor for which threshold is to be set");
-		lprintf(LOG_NOTICE, "   threshold : which threshold to set");
-		lprintf(LOG_NOTICE, "                 unr = upper non-recoverable");
-		lprintf(LOG_NOTICE, "                 ucr = upper critical");
-		lprintf(LOG_NOTICE, "                 unc = upper non-critical");
-		lprintf(LOG_NOTICE, "                 lnc = lower non-critical");
-		lprintf(LOG_NOTICE, "                 lcr = lower critical");
-		lprintf(LOG_NOTICE, "                 lnr = lower non-recoverable");
-		lprintf(LOG_NOTICE, "   setting   : the value to set the threshold to");
-		return 0;
-	}
-
-	id = argv[0];
-	thresh = argv[1];
-	setting = (double)atof(argv[2]);
-	if (strncmp(thresh, "unr", 3) == 0)
-		settingMask = UPPER_NON_RECOV_SPECIFIED;
-	else if (strncmp(thresh, "ucr", 3) == 0)
-		settingMask = UPPER_CRIT_SPECIFIED;
-	else if (strncmp(thresh, "unc", 3) == 0)
-		settingMask = UPPER_NON_CRIT_SPECIFIED;
-	else if (strncmp(thresh, "lnc", 3) == 0)
-		settingMask = LOWER_NON_CRIT_SPECIFIED;
-	else if (strncmp(thresh, "lcr", 3) == 0)
-		settingMask = LOWER_CRIT_SPECIFIED;
-	else if (strncmp(thresh, "lnr", 3) == 0)
-		settingMask = LOWER_NON_RECOV_SPECIFIED;
-	else {
-		lprintf(LOG_ERR, "Valid threshold not specified!");
-		return -1;
-	}
-
-	printf("Locating sensor record...\n");
-
-	/* lookup by sensor name */
-	sdr = ipmi_sdr_find_sdr_byid(intf, id);
-	if (sdr == NULL) {
-		lprintf(LOG_ERR, "Sensor data record not found!");
-		return -1;
-	}
-
-	if (sdr->type != SDR_RECORD_TYPE_FULL_SENSOR) {
-		lprintf(LOG_ERR, "Invalid sensor type %02x", sdr->type);
-		return -1;
-	}
-
-	printf("Setting sensor \"%s\" %s threshold to %.3f\n",
-	       sdr->record.full->id_string,
-	       val2str(settingMask, threshold_vals), setting);
-
-	rsp = ipmi_sensor_set_sensor_thresholds(intf, 
-		sdr->record.full->keys.sensor_num, settingMask,
-		sdr_convert_sensor_value_to_raw(sdr->record.full, setting));
+	rsp = ipmi_sensor_set_sensor_thresholds(intf, num, mask, setting);

 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Error setting threshold");
@ -587,9 +556,185 @@ ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv)
 }

 static int
-ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv)
+ipmi_sensor_set_threshold(struct ipmi_intf *intf, int argc, char **argv)
 {
-	struct sdr_record_list * sdr;
+	char *id, *thresh;
+	uint8_t settingMask = 0;
+	double setting1 = 0.0, setting2 = 0.0, setting3 = 0.0;
+	int allUpper = 0, allLower = 0;
+	int ret = 0;
+
+	struct sdr_record_list *sdr;
+
+	if (argc < 3 || strncmp(argv[0], "help", 4) == 0) {
+		lprintf(LOG_NOTICE, "sensor thresh <id> <threshold> <setting>");
+		lprintf(LOG_NOTICE,
+			"   id        : name of the sensor for which threshold is to be set");
+		lprintf(LOG_NOTICE, "   threshold : which threshold to set");
+		lprintf(LOG_NOTICE,
+			"                 unr = upper non-recoverable");
+		lprintf(LOG_NOTICE, "                 ucr = upper critical");
+		lprintf(LOG_NOTICE,
+			"                 unc = upper non-critical");
+		lprintf(LOG_NOTICE,
+			"                 lnc = lower non-critical");
+		lprintf(LOG_NOTICE, "                 lcr = lower critical");
+		lprintf(LOG_NOTICE,
+			"                 lnr = lower non-recoverable");
+		lprintf(LOG_NOTICE,
+			"   setting   : the value to set the threshold to");
+		lprintf(LOG_NOTICE, "");
+		lprintf(LOG_NOTICE,
+			"sensor thresh <id> lower <lnr> <lcr> <lnc>");
+		lprintf(LOG_NOTICE,
+			"   Set all lower thresholds at the same time");
+		lprintf(LOG_NOTICE, "");
+		lprintf(LOG_NOTICE,
+			"sensor thresh <id> upper <unc> <ucr> <unr>");
+		lprintf(LOG_NOTICE,
+			"   Set all upper thresholds at the same time");
+		lprintf(LOG_NOTICE, "");
+		return 0;
+	}
+
+	id = argv[0];
+	thresh = argv[1];
+
+	if (strncmp(thresh, "upper", 5) == 0) {
+		if (argc < 5) {
+			lprintf(LOG_ERR,
+				"usage: sensor thresh <id> upper <unc> <ucr> <unr>");
+			return -1;
+		}
+		allUpper = 1;
+		setting1 = (double) strtod(argv[2], NULL);
+		setting2 = (double) strtod(argv[3], NULL);
+		setting3 = (double) strtod(argv[4], NULL);
+	} else if (strncmp(thresh, "lower", 5) == 0) {
+		if (argc < 5) {
+			lprintf(LOG_ERR,
+				"usage: sensor thresh <id> lower <unc> <ucr> <unr>");
+			return -1;
+		}
+		allLower = 1;
+		setting1 = (double) strtod(argv[2], NULL);
+		setting2 = (double) strtod(argv[3], NULL);
+		setting3 = (double) strtod(argv[4], NULL);
+	} else {
+		setting1 = (double) atof(argv[2]);
+		if (strncmp(thresh, "unr", 3) == 0)
+			settingMask = UPPER_NON_RECOV_SPECIFIED;
+		else if (strncmp(thresh, "ucr", 3) == 0)
+			settingMask = UPPER_CRIT_SPECIFIED;
+		else if (strncmp(thresh, "unc", 3) == 0)
+			settingMask = UPPER_NON_CRIT_SPECIFIED;
+		else if (strncmp(thresh, "lnc", 3) == 0)
+			settingMask = LOWER_NON_CRIT_SPECIFIED;
+		else if (strncmp(thresh, "lcr", 3) == 0)
+			settingMask = LOWER_CRIT_SPECIFIED;
+		else if (strncmp(thresh, "lnr", 3) == 0)
+			settingMask = LOWER_NON_RECOV_SPECIFIED;
+		else {
+			lprintf(LOG_ERR,
+				"Valid threshold '%s' for sensor '%s' not specified!",
+				thresh, id);
+			return -1;
+		}
+	}
+
+	printf("Locating sensor record '%s'...\n", id);
+
+	/* lookup by sensor name */
+	sdr = ipmi_sdr_find_sdr_byid(intf, id);
+	if (sdr == NULL) {
+		lprintf(LOG_ERR, "Sensor data record not found!");
+		return -1;
+	}
+
+	if (sdr->type != SDR_RECORD_TYPE_FULL_SENSOR) {
+		lprintf(LOG_ERR, "Invalid sensor type %02x", sdr->type);
+		return -1;
+	}
+
+	if (allUpper) {
+		settingMask = UPPER_NON_CRIT_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting1);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting1));
+
+		settingMask = UPPER_CRIT_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting2);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting2));
+
+		settingMask = UPPER_NON_RECOV_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting3);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting3));
+	} else if (allLower) {
+		settingMask = LOWER_NON_RECOV_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting1);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting1));
+
+		settingMask = LOWER_CRIT_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting2);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting2));
+
+		settingMask = LOWER_NON_CRIT_SPECIFIED;
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting3);
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting3));
+	} else {
+		printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+		       sdr->record.full->id_string,
+		       val2str(settingMask, threshold_vals), setting1);
+
+		ret = __ipmi_sensor_set_threshold(intf,
+						  sdr->record.full->keys.
+						  sensor_num, settingMask,
+						  sdr_convert_sensor_value_to_raw
+						  (sdr->record.full, setting1));
+	}
+
+	return ret;
+}
+
+static int
+ipmi_sensor_get(struct ipmi_intf *intf, int argc, char **argv)
+{
+	struct sdr_record_list *sdr;
 	int i, v;
 	int rc = 0;

@ -601,7 +746,7 @@ ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv)
 	printf("Locating sensor record...\n");

 	/* lookup by sensor name */
-	for (i=0; i<argc; i++) {
+	for (i = 0; i < argc; i++) {
 		int r = 0;

 		sdr = ipmi_sdr_find_sdr_byid(intf, argv[i]);
@ -620,16 +765,22 @@ ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv)
 			r = ipmi_sensor_print_full(intf, sdr->record.full);
 			break;
 		case SDR_RECORD_TYPE_COMPACT_SENSOR:
-			r = ipmi_sensor_print_compact(intf, sdr->record.compact);
+			r = ipmi_sensor_print_compact(intf,
+						      sdr->record.compact);
 			break;
 		case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
-			r = ipmi_sdr_print_sensor_eventonly(intf, sdr->record.eventonly);
+			r = ipmi_sdr_print_sensor_eventonly(intf,
+							    sdr->record.
+							    eventonly);
 			break;
 		case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR:
-			r = ipmi_sdr_print_sensor_fru_locator(intf, sdr->record.fruloc);
+			r = ipmi_sdr_print_sensor_fru_locator(intf,
+							      sdr->record.
+							      fruloc);
 			break;
 		case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR:
-			r = ipmi_sdr_print_sensor_mc_locator(intf, sdr->record.mcloc);
+			r = ipmi_sdr_print_sensor_mc_locator(intf,
+							     sdr->record.mcloc);
 			break;
 		}
 		verbose = v;
@ -642,28 +793,22 @@ ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv)
 }

 int
-ipmi_sensor_main(struct ipmi_intf * intf, int argc, char ** argv)
+ipmi_sensor_main(struct ipmi_intf *intf, int argc, char **argv)
 {
 	int rc = 0;

 	if (argc == 0) {
 		rc = ipmi_sensor_list(intf);
-	}
-	else if (strncmp(argv[0], "help", 4) == 0) {
+	} else if (strncmp(argv[0], "help", 4) == 0) {
 		lprintf(LOG_NOTICE, "Sensor Commands:  list thresh get");
-	}
-	else if (strncmp(argv[0], "list", 4) == 0) {
+	} else if (strncmp(argv[0], "list", 4) == 0) {
 		rc = ipmi_sensor_list(intf);
-	}
-	else if (strncmp(argv[0], "thresh", 5) == 0) {
-		rc = ipmi_sensor_set_threshold(intf, argc-1, &argv[1]);
-	}
-	else if (strncmp(argv[0], "get", 3) == 0) {
-		rc = ipmi_sensor_get(intf, argc-1, &argv[1]);
-	}
-	else {
-		lprintf(LOG_ERR, "Invalid sensor command: %s",
-			argv[0]);
+	} else if (strncmp(argv[0], "thresh", 5) == 0) {
+		rc = ipmi_sensor_set_threshold(intf, argc - 1, &argv[1]);
+	} else if (strncmp(argv[0], "get", 3) == 0) {
+		rc = ipmi_sensor_get(intf, argc - 1, &argv[1]);
+	} else {
+		lprintf(LOG_ERR, "Invalid sensor command: %s", argv[0]);
 		rc = -1;
 	}

--- a/ipmitool/lib/ipmi_session.c
+++ b/ipmitool/lib/ipmi_session.c
@ -399,8 +399,8 @@ ipmi_get_session_info(struct ipmi_intf         * intf,



-void
-printf_session_usage()
+static void
+printf_session_usage(void)
 {
 	lprintf(LOG_NOTICE, "Session Commands: info <active | all | id 0xnnnnnnnn | handle 0xnn>");
 }
--- a/ipmitool/lib/ipmi_sol.c
+++ b/ipmitool/lib/ipmi_sol.c
@ -67,8 +67,6 @@
 #define SOL_PARAMETER_SOL_PAYLOAD_CHANNEL       0x07
 #define SOL_PARAMETER_SOL_PAYLOAD_PORT          0x08

-#define SOL_ESCAPE_CHARACTER                    '~'
-
 const struct valstr sol_parameter_vals[] = {
 	{ SOL_PARAMETER_SET_IN_PROGRESS,           "Set In Progress (0)" },
 	{ SOL_PARAMETER_SOL_ENABLE,                "Enable (1)" },
@ -102,6 +100,7 @@ ipmi_get_sol_info(
 	struct ipmi_rq req;
 	uint8_t data[4];	

+   memset(&req, 0, sizeof(req)); 
 	req.msg.netfn    = IPMI_NETFN_TRANSPORT;
 	req.msg.cmd      = IMPI_GET_SOL_CONFIG_PARAMETERS;
 	req.msg.data_len = 4;
@ -547,6 +546,7 @@ ipmi_sol_set_param(struct ipmi_intf * intf,
 	uint8_t    data[4];	 
 	int              bGuarded = 1; /* Use set-in-progress indicator? */

+   memset(&req, 0, sizeof(req));
 	req.msg.netfn    = IPMI_NETFN_TRANSPORT;           /* 0x0c */ 
 	req.msg.cmd      = IMPI_SET_SOL_CONFIG_PARAMETERS; /* 0x21 */
 	req.msg.data     = data;
@ -769,7 +769,7 @@ ipmi_sol_set_param(struct ipmi_intf * intf,

 		req.msg.data_len = 4;
 		data[1] = SOL_PARAMETER_SOL_RETRY;
-		data[2] = (uint8_t)strtol(value, NULL, 0) & 0x03;
+		data[2] = (uint8_t)strtol(value, NULL, 0) & 0x07;

 		/* We need other values to complete the request */
 		if (ipmi_get_sol_info(intf, channel, &params))
@ -1045,8 +1045,8 @@ suspendSelf(int bRestoreTty)
 *
 * Send some useful documentation to the user
 */
-void
-printSolEscapeSequences()
+static void
+printSolEscapeSequences(struct ipmi_intf * intf)
 {
 	printf(
 		   "%c?\r\n\
@ -1058,14 +1058,14 @@ printSolEscapeSequences()
 	%c?  - this message\r\n\
 	%c%c  - send the escape character by typing it twice\r\n\
 	(Note that escapes are only recognized immediately after newline.)\r\n",
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER,
-		   SOL_ESCAPE_CHARACTER);
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char,
+		   intf->session->sol_escape_char);
 }


@ -1100,6 +1100,7 @@ ipmi_sol_deactivate(struct ipmi_intf * intf)
 	struct ipmi_rq   req;
 	uint8_t    data[6];	 

+   memset(&req, 0, sizeof(req));
 	req.msg.netfn    = IPMI_NETFN_APP;
 	req.msg.cmd      = IPMI_DEACTIVATE_PAYLOAD;
 	req.msg.data_len = 6;
@ -1155,7 +1156,7 @@ static int
 processSolUserInput(
 					struct ipmi_intf * intf,
 					uint8_t    * input,
-					uint16_t     buffer_length)
+					uint16_t   buffer_length)
 {
 	static int escape_pending = 0;
 	static int last_was_cr    = 1;
@ -1183,38 +1184,44 @@ processSolUserInput(
 			 */
 			switch (ch) {
 			case '.':
-				printf("%c. [terminated ipmitool]\r\n", SOL_ESCAPE_CHARACTER);
+				printf("%c. [terminated ipmitool]\r\n",
+				       intf->session->sol_escape_char);
 				retval = 1;
 				break;
+
 			case 'Z' - 64:
-				printf("%c^Z [suspend ipmitool]\r\n", SOL_ESCAPE_CHARACTER);
+				printf("%c^Z [suspend ipmitool]\r\n",
+				       intf->session->sol_escape_char);
 				suspendSelf(1); /* Restore tty back to raw */
 				continue;

 			case 'X' - 64:
-				printf("%c^Z [suspend ipmitool]\r\n", SOL_ESCAPE_CHARACTER);
+				printf("%c^Z [suspend ipmitool]\r\n",
+				       intf->session->sol_escape_char);
 				suspendSelf(0); /* Don't restore to raw mode */
 				continue;

 			case 'B':
-				printf("%cb [send break]\r\n", SOL_ESCAPE_CHARACTER);
+				printf("%cb [send break]\r\n",
+				       intf->session->sol_escape_char);
 				sendBreak(intf);
 				continue;

 			case '?':
-				printSolEscapeSequences();
+				printSolEscapeSequences(intf);
 				continue;
+
 			default:
-				if (ch != SOL_ESCAPE_CHARACTER)
+				if (ch != intf->session->sol_escape_char)
 					v2_payload.payload.sol_packet.data[length++] =
-						SOL_ESCAPE_CHARACTER;
+						intf->session->sol_escape_char;
 				v2_payload.payload.sol_packet.data[length++] = ch;
 			}
 		}

 		else
 		{
-			if (last_was_cr && (ch == SOL_ESCAPE_CHARACTER)) {
+			if (last_was_cr && (ch == intf->session->sol_escape_char)) {
 				escape_pending = 1;
 				continue;
 			}
@ -1410,6 +1417,7 @@ ipmi_sol_activate(struct ipmi_intf * intf)
 	intf->session->sol_data.sol_input_handler = output;


+	memset(&req, 0, sizeof(req));
 	req.msg.netfn    = IPMI_NETFN_APP;
 	req.msg.cmd      = IPMI_ACTIVATE_PAYLOAD;
 	req.msg.data_len = 6;
@ -1497,15 +1505,25 @@ ipmi_sol_activate(struct ipmi_intf * intf)
 	intf->session->timeout = 3;


+	/* NOTE: the spec does allow for SOL traffic to be sent on
+	 * a different port.  we do not yet support that feature. */
 	if (intf->session->sol_data.port != intf->session->port)
 	{
-		lprintf(LOG_ERR, "Error: BMC requests SOL session on different port");
-		return -1;
+		/* try byteswapping port in case BMC sent it incorrectly */
+		uint16_t portswap = BSWAP_16(intf->session->sol_data.port);
+
+		if (portswap == intf->session->port) {
+			intf->session->sol_data.port = portswap;
+		}
+		else {
+			lprintf(LOG_ERR, "Error: BMC requests SOL session on different port");
+			return -1;
+		}
 	}
 	

 	printf("[SOL Session operational.  Use %c? for help]\r\n",
-		   SOL_ESCAPE_CHARACTER);
+	       intf->session->sol_escape_char);


 	/*
@ -1528,8 +1546,8 @@ ipmi_sol_activate(struct ipmi_intf * intf)
 /*
 * print_sol_usage
 */
-void
-print_sol_usage()
+static void
+print_sol_usage(void)
 {
 	lprintf(LOG_NOTICE, "SOL Commands: info [<channel number>]");
 	lprintf(LOG_NOTICE, "              set <parameter> <value> [channel]");
@ -1542,8 +1560,8 @@ print_sol_usage()
 /*
 * print_sol_set_usage
 */
-void
-print_sol_set_usage()
+static void
+print_sol_set_usage(void)
 {
 	lprintf(LOG_NOTICE, "\nSOL set parameters and values: \n");
  	lprintf(LOG_NOTICE, "  set-in-progress             set-complete | "
--- a/ipmitool/lib/ipmi_strings.c
+++ b/ipmitool/lib/ipmi_strings.c
@ -38,7 +38,30 @@
 #include <ipmitool/ipmi_strings.h>
 #include <ipmitool/ipmi_constants.h>
 #include <ipmitool/ipmi_sensor.h>
+#include <ipmitool/ipmi_sel.h>  /* for IPMI_OEM */

+const struct valstr ipmi_oem_info[] = {
+
+   { IPMI_OEM_UNKNOWN,    "Unknown" },
+   { IPMI_OEM_SUN,        "Sun Microsystems" },
+   { IPMI_OEM_INTEL,      "Intel Corporation" },
+   { IPMI_OEM_TYAN,       "Tyan Computer Corporation" },
+   { IPMI_OEM_NEWISYS,    "Newisys" },
+   { IPMI_OEM_SUPERMICRO, "Supermicro" },
+   { IPMI_OEM_KONTRON,    "Kontron" },
+   { 0xffff , NULL },
+};
+
+const struct valstr ipmi_netfn_vals[] = {
+	{ IPMI_NETFN_CHASSIS,	"Chassis" },
+	{ IPMI_NETFN_BRIDGE,	"Bridge" },
+	{ IPMI_NETFN_SE,	"SensorEvent" },
+	{ IPMI_NETFN_APP,	"Application" },
+	{ IPMI_NETFN_FIRMWARE,	"Firmware" },
+	{ IPMI_NETFN_STORAGE,	"Storage" },
+	{ IPMI_NETFN_TRANSPORT,	"Transport" },
+	{ 0xff,			NULL },
+};

 /*
 * From table 26-4 of the IPMI v2 specification
@ -69,7 +92,7 @@ const struct valstr ipmi_privlvl_vals[] = {
 	{ IPMI_SESSION_PRIV_ADMIN,	    "ADMINISTRATOR" },
 	{ IPMI_SESSION_PRIV_OEM,    	"OEM" },
 	{ 0xF,	        		    	"NO ACCESS" },
-	{ 0,			             	NULL },
+	{ 0xFF,			             	NULL },
 };


@ -87,7 +110,7 @@ const struct valstr ipmi_authtype_session_vals[] = {
 	{ IPMI_SESSION_AUTHTYPE_MD5,      "MD5" },
 	{ IPMI_SESSION_AUTHTYPE_PASSWORD, "PASSWORD" },
 	{ IPMI_SESSION_AUTHTYPE_OEM,      "OEM" },
-	{ 0,                               NULL },
+	{ 0xFF,                           NULL },
 };


@ -142,6 +165,18 @@ const struct valstr entity_id_vals[] = {
 	{ 0x26, "Remote Management Device" },
 	{ 0x27, "External Environment" },
 	{ 0x28, "Battery" },
+    { 0x29, "Processing Blade" },
+    { 0x2A, "Connectivity Switch" },
+    { 0x2B, "Processor/Memory Module" },
+    { 0x2C, "I/O Module" },
+    { 0x2D, "Processor/IO Module" },
+    { 0x2E, "Management Controller Firmware" },
+    { 0x2F, "IPMI Channel" },
+    { 0x30, "PCI Bus" },
+    { 0x31, "PCI Express Bus" },
+    { 0x32, "SCSI Bus (parallel)" },
+    { 0x33, "SATA/SAS Bus" },
+    { 0x34, "Processor/Front-Side Bus" },
 	{ 0x00, NULL },
 };

@ -211,7 +246,7 @@ const struct valstr ipmi_channel_protocol_vals[] = {

 const struct valstr ipmi_channel_medium_vals[] = {
 	{ IPMI_CHANNEL_MEDIUM_RESERVED,	"reserved" },
-	{ IPMI_CHANNEL_MEDIUM_IPMB,	"IPMB (I2C)" },
+	{ IPMI_CHANNEL_MEDIUM_IPMB_I2C,	"IPMB (I2C)" },
 	{ IPMI_CHANNEL_MEDIUM_ICMB_1,	"ICMB v1.0" },
 	{ IPMI_CHANNEL_MEDIUM_ICMB_09,	"ICMB v0.9" },
 	{ IPMI_CHANNEL_MEDIUM_LAN,	"802.3 LAN" },
@ -254,6 +289,16 @@ const struct valstr completion_code_vals[] = {
 	{ 0x00, NULL }
 };

+const struct valstr ipmi_chassis_power_control_vals[] = {
+	{ IPMI_CHASSIS_CTL_POWER_DOWN,   "Down/Off" },
+	{ IPMI_CHASSIS_CTL_POWER_UP,     "Up/On" },
+	{ IPMI_CHASSIS_CTL_POWER_CYCLE,  "Cycle" },
+	{ IPMI_CHASSIS_CTL_HARD_RESET,   "Reset" },
+	{ IPMI_CHASSIS_CTL_PULSE_DIAG,   "Diag" },
+	{ IPMI_CHASSIS_CTL_ACPI_SOFT,    "Soft" },
+	{ 0x00, NULL },
+};
+
 const struct valstr ipmi_auth_algorithms[] = {
 	{ IPMI_AUTH_RAKP_NONE,      "none"      },
 	{ IPMI_AUTH_RAKP_HMAC_SHA1, "hmac_sha1" },
--- a/ipmitool/lib/ipmi_sunoem.c
+++ b/ipmitool/lib/ipmi_sunoem.c
@ -0,0 +1,794 @@
+/*
+ * 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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#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" },
+	{ 0, 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 },
+};
+
+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, "      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);
+	}
+	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[5];
+
+	if (dev == NULL)
+		return NULL;
+
+	rqdata[0] = dev->dev_slave_addr;
+	rqdata[1] = ledtype;
+	rqdata[2] = dev->dev_access_addr;
+	rqdata[3] = dev->oem;
+	rqdata[4] = 0;
+
+	req.msg.netfn = IPMI_NETFN_SUNOEM;
+	req.msg.cmd = IPMI_SUNOEM_LED_GET;
+	req.msg.data = rqdata;
+	req.msg.data_len = 5;
+		
+	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[7];
+
+	if (dev == NULL)
+		return NULL;
+
+	rqdata[0] = dev->dev_slave_addr;
+	rqdata[1] = ledtype;
+	rqdata[2] = dev->dev_access_addr;
+	rqdata[3] = dev->oem;
+	rqdata[4] = ledmode;
+	rqdata[5] = 0;
+	rqdata[6] = 0;
+
+	req.msg.netfn = IPMI_NETFN_SUNOEM;
+	req.msg.cmd = IPMI_SUNOEM_LED_SET;
+	req.msg.data = rqdata;
+	req.msg.data_len = 7;
+		
+	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
+ */
+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 = 0;
+	int i;
+
+	/* 
+	 * sunoem led get <id> [type]
+	 */
+
+	if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
+		lprintf(LOG_NOTICE, "usage: sunoem led get <id> [type]");
+		return 0;
+	}
+
+	if (argc > 1) {
+		ledtype = str2val(argv[1], sunoem_led_type_vals);
+	}
+
+	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
+ *
+ *
+ * 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 = 0;
+	int i;
+
+	/* 
+	 * sunoem led 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 (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);
+		fseek(fp, r, SEEK_SET);
+		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 = 0;
+
+	if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
+		ipmi_sunoem_usage();
+		return 0;
+	}
+
+	if (strncmp(argv[0], "fan", 3) == 0) {
+		uint8_t pct;
+		if (argc < 2) {
+			ipmi_sunoem_usage();
+			return -1;
+		}
+		else if (strncmp(argv[1], "speed", 5) == 0) {
+			if (argc < 3) {
+				ipmi_sunoem_usage();
+				return -1;
+			}
+			pct = (uint8_t)strtol(argv[2], NULL, 0);
+			rc = ipmi_sunoem_fan_speed(intf, pct);
+		}
+		else {
+			ipmi_sunoem_usage();
+			return -1;
+		}
+	}
+
+	if (strncmp(argv[0], "led", 3) == 0) {
+		if (argc < 2) {
+			ipmi_sunoem_usage();
+			return -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;
+		}
+	}
+
+	if (strncmp(argv[0], "sshkey", 6) == 0) {
+		if (argc < 2) {
+			ipmi_sunoem_usage();
+			return -1;
+		}
+		else if (strncmp(argv[1], "del", 3) == 0) {
+			uint8_t uid;
+			if (argc < 3) {
+				ipmi_sunoem_usage();
+				return -1;
+			}
+			uid = (uint8_t)strtoul(argv[2], NULL, 0);
+			rc = ipmi_sunoem_sshkey_del(intf, uid);
+		}
+		else if (strncmp(argv[1], "set", 3) == 0) {
+			uint8_t uid;
+			if (argc < 4) {
+				ipmi_sunoem_usage();
+				return -1;
+			}
+			uid = (uint8_t)strtoul(argv[2], NULL, 0);
+			rc = ipmi_sunoem_sshkey_set(intf, uid, argv[3]);
+		}
+	}
+
+	return rc;
+}
--- a/ipmitool/lib/ipmi_tsol.c
+++ b/ipmitool/lib/ipmi_tsol.c
@ -0,0 +1,596 @@
+/*
+ * Copyright (c) 2005 Tyan Computer Corp.  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.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/poll.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <signal.h>
+
+#include <sys/select.h>
+#include <sys/time.h>
+        
+#ifdef __linux__
+# include <linux/termios.h>
+#else
+# include <sys/termios.h>
+#endif
+
+#include <ipmitool/log.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_tsol.h>
+#include <ipmitool/ipmi_strings.h>
+#include <ipmitool/bswap.h>
+
+#include <config.h>
+
+static struct timeval _start_keepalive;
+static struct termios _saved_tio;
+static struct winsize _saved_winsize;
+static int _in_raw_mode = 0;
+static int _altterm = 0;
+
+static int
+ipmi_tsol_command(struct ipmi_intf * intf, char *recvip, int port, unsigned char cmd)
+{
+        struct ipmi_rs *rsp;
+        struct ipmi_rq	req;
+        unsigned char	data[6];
+	unsigned	ip1, ip2, ip3, ip4;
+	uint16_t	portin;
+
+#if WORDS_BIGENDIAN
+	portin = BSWAP_16(port);
+#else
+	portin = port;
+#endif
+
+        if (sscanf(recvip, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) != 4) {
+                lprintf(LOG_ERR, "Invalid IP address: %s", recvip);
+                return -1;
+        }
+
+        req.msg.netfn    = IPMI_NETFN_TSOL;
+        req.msg.cmd      = cmd;
+        req.msg.data_len = 6;
+        req.msg.data     = data;
+
+	memset(data, 0, sizeof(data));
+        data[0] = ip1;  
+        data[1] = ip2;                    
+        data[2] = ip3;
+        data[3] = ip4;
+        data[4] = (portin & 0xff00) >> 8;
+        data[5] = (portin & 0xff);
+
+        rsp = intf->sendrecv(intf, &req);
+        if (rsp == NULL) {
+		lprintf(LOG_ERR, "Unable to perform TSOL command");
+                return -1;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Unable to perform TSOL command: %s",
+			val2str(rsp->ccode, completion_code_vals));
+		return -1;
+        }
+
+        return 0;
+}
+
+static int
+ipmi_tsol_start(struct ipmi_intf * intf, char *recvip, int port)
+{
+	return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_START);
+}
+
+static int
+ipmi_tsol_stop(struct ipmi_intf * intf, char *recvip, int port)
+{
+        return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_STOP);
+}
+
+static int                      
+ipmi_tsol_send_keystroke(struct ipmi_intf * intf, char *buff, int length)
+{                               
+        struct ipmi_rs * rsp;
+        struct ipmi_rq   req;
+        unsigned char    data[16];
+	static unsigned char keyseq = 0;
+                        
+        req.msg.netfn    = IPMI_NETFN_TSOL;
+        req.msg.cmd      = IPMI_TSOL_CMD_SENDKEY;
+        req.msg.data_len = length + 2;
+        req.msg.data     = data;
+
+	memset(data, 0, sizeof(data));
+        data[0] = length + 1;
+	memcpy(data + 1, buff, length);
+	data[length + 1] = keyseq++;
+                
+        rsp = intf->sendrecv(intf, &req);
+        if (rsp == NULL) {
+		lprintf(LOG_ERR, "Unable to send keystroke");
+                return -1;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Unable to send keystroke: %s",
+			val2str(rsp->ccode, completion_code_vals));
+		return -1;
+        }
+
+        return length;
+} 
+
+static int
+tsol_keepalive(struct ipmi_intf * intf)
+{
+        struct timeval end;
+        
+        gettimeofday(&end, 0);
+
+        if (end.tv_sec - _start_keepalive.tv_sec <= 30)
+                return 0;
+
+        intf->keepalive(intf);
+
+	gettimeofday(&_start_keepalive, 0);
+
+        return 0;
+}
+
+static void
+print_escape_seq(struct ipmi_intf *intf)
+{
+	lprintf(LOG_NOTICE,
+		"       %c.  - terminate connection\r\n"
+		"       %c^Z - suspend ipmitool\r\n"
+		"       %c^X - suspend ipmitool, but don't restore tty on restart\r\n"
+		"       %c?  - this message\r\n"
+		"       %c%c  - send the escape character by typing it twice\r\n"
+		"       (Note that escapes are only recognized immediately after newline.)\r",
+		intf->session->sol_escape_char,
+		intf->session->sol_escape_char,
+		intf->session->sol_escape_char,
+		intf->session->sol_escape_char,
+		intf->session->sol_escape_char,
+		intf->session->sol_escape_char);
+}
+
+static int
+leave_raw_mode(void)
+{
+	if (!_in_raw_mode)
+		return -1;
+	else if (tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio) == -1)
+		lperror(LOG_ERR, "tcsetattr(stdin)");
+	else if (tcsetattr(fileno(stdout), TCSADRAIN, &_saved_tio) == -1)
+		lperror(LOG_ERR, "tcsetattr(stdout)");
+	else
+		_in_raw_mode = 0;
+
+	return 0;
+}
+
+static int
+enter_raw_mode(void)
+{
+	struct termios tio;
+
+	if (tcgetattr(fileno(stdout), &_saved_tio) < 0) {
+		lperror(LOG_ERR, "tcgetattr failed");
+		return -1;
+	}
+
+	tio = _saved_tio;
+
+	if (_altterm) {
+		tio.c_iflag &= (ISTRIP | IGNBRK );
+		tio.c_cflag &= ~(CSIZE | PARENB | IXON | IXOFF | IXANY);
+		tio.c_cflag |= (CS8 |CREAD) | (IXON|IXOFF|IXANY);
+		tio.c_lflag &= 0;
+		tio.c_cc[VMIN] = 1;
+		tio.c_cc[VTIME] = 0;
+	} else {
+		tio.c_iflag |= IGNPAR;
+		tio.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
+		tio.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL | IEXTEN);
+		tio.c_oflag &= ~OPOST;
+		tio.c_cc[VMIN] = 1;
+		tio.c_cc[VTIME] = 0;
+	}
+
+	if (tcsetattr(fileno(stdin), TCSADRAIN, &tio) < 0)
+		lperror(LOG_ERR, "tcsetattr(stdin)");
+	else if (tcsetattr(fileno(stdout), TCSADRAIN, &tio) < 0)
+		lperror(LOG_ERR, "tcsetattr(stdout)");
+	else
+		_in_raw_mode = 1;
+
+	return 0;
+}
+
+static void
+suspend_self(int restore_tty)
+{
+	leave_raw_mode();
+
+	kill(getpid(), SIGTSTP);
+
+	if (restore_tty)
+		enter_raw_mode();
+}
+
+static int
+do_inbuf_actions(struct ipmi_intf *intf, char *in_buff, int len)
+{
+	static int in_esc = 0;
+	static int last_was_cr = 1;
+	int i;
+
+	for(i = 0; i < len ;) {
+		if (!in_esc) {
+			if (last_was_cr &&
+			    (in_buff[i] == intf->session->sol_escape_char)) {
+				in_esc = 1;
+				memmove(in_buff, in_buff + 1, len - i - 1);
+				len--;
+				continue;
+			}
+		}
+		if (in_esc) {
+			if (in_buff[i] == intf->session->sol_escape_char) {
+				in_esc = 0;
+				i++;
+				continue;
+			}
+
+			switch (in_buff[i]) {
+			case '.':
+				printf("%c. [terminated ipmitool]\r\n",
+				       intf->session->sol_escape_char);
+				return -1;
+
+			case 'Z' - 64:
+				printf("%c^Z [suspend ipmitool]\r\n",
+				       intf->session->sol_escape_char);
+				suspend_self(1); /* Restore tty back to raw */
+				break;
+
+			case 'X' - 64:
+				printf("%c^X [suspend ipmitool]\r\n",
+				       intf->session->sol_escape_char);
+				suspend_self(0); /* Don't restore to raw mode */
+				break;
+
+			case '?':
+				printf("%c? [ipmitool help]\r\n",
+				       intf->session->sol_escape_char);
+				print_escape_seq(intf);
+				break;
+			}
+
+			memmove(in_buff, in_buff + 1, len - i - 1);
+			len--;
+			in_esc = 0;
+
+			continue;
+		}
+
+		last_was_cr = (in_buff[i] == '\r' || in_buff[i] == '\n');
+
+		i++;
+	}
+
+	return len;
+}
+
+
+static void
+do_terminal_cleanup(void)
+{
+	if (_saved_winsize.ws_row > 0 && _saved_winsize.ws_col > 0)
+		ioctl(fileno(stdout), TIOCSWINSZ, &_saved_winsize);
+
+	leave_raw_mode();
+
+	if (errno)
+		lprintf(LOG_ERR, "Exiting due to error %d -> %s",
+			errno, strerror(errno));
+}
+
+static void
+set_terminal_size(int rows, int cols)
+{
+	struct winsize winsize;
+
+	if (rows <= 0 || cols <= 0)
+		return;
+
+	/* save initial winsize */
+	ioctl(fileno(stdout), TIOCGWINSZ, &_saved_winsize);
+
+	/* set new winsize */
+	winsize.ws_row = rows;
+	winsize.ws_col = cols;
+	ioctl(fileno(stdout), TIOCSWINSZ, &winsize);
+}
+
+static void
+print_tsol_usage(void)
+{
+	struct winsize winsize;
+	
+	lprintf(LOG_NOTICE, "Usage: tsol [recvip] [port=NUM] [ro|rw] [rows=NUM] [cols=NUM] [altterm]");
+	lprintf(LOG_NOTICE, "       recvip       Receiver IP Address             [default=local]");
+	lprintf(LOG_NOTICE, "       port=NUM     Receiver UDP Port               [default=%d]",
+		IPMI_TSOL_DEF_PORT);
+	lprintf(LOG_NOTICE, "       ro|rw        Set Read-Only or Read-Write     [default=rw]");
+
+	ioctl(fileno(stdout), TIOCGWINSZ, &winsize);
+	lprintf(LOG_NOTICE, "       rows=NUM     Set terminal rows               [default=%d]",
+		winsize.ws_row);
+	lprintf(LOG_NOTICE, "       cols=NUM     Set terminal columns            [default=%d]",
+		winsize.ws_col);
+
+	lprintf(LOG_NOTICE, "       altterm      Alternate terminal setup        [default=off]");
+}
+
+int
+ipmi_tsol_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct pollfd fds_wait[3], fds_data_wait[3], *fds;
+	struct sockaddr_in sin, myaddr;
+	socklen_t mylen;
+	char recvip_c[] = "0.0.0.0";
+	char *recvip = NULL;
+	char out_buff[IPMI_BUF_SIZE * 8], in_buff[IPMI_BUF_SIZE];
+	char buff[IPMI_BUF_SIZE + 4];
+	int fd_socket, result, i;
+	int out_buff_fill, in_buff_fill;
+	int ip1, ip2, ip3, ip4;
+	int read_only = 0, rows = 0, cols = 0;
+	int port = IPMI_TSOL_DEF_PORT;
+
+	if (strlen(intf->name) == 3 && strncmp(intf->name, "lan", 3) != 0) {
+		lprintf(LOG_ERR, "Error: Tyan SOL is only available over lan interface");
+		return -1;
+	}
+
+	for (i = 0; i<argc; i++) {
+		if (sscanf(argv[i], "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) == 4)
+			recvip = strdup(argv[i]);
+		else if (sscanf(argv[i], "port=%d", &ip1) == 1)
+			port = ip1;
+		else if (sscanf(argv[i], "rows=%d", &ip1) == 1)
+			rows = ip1;
+		else if (sscanf(argv[i], "cols=%d", &ip1) == 1)
+			cols = ip1;
+		else if (strlen(argv[i]) == 2 && strncmp(argv[i], "ro", 2) == 0)
+			read_only = 1;
+		else if (strlen(argv[i]) == 2 && strncmp(argv[i], "rw", 2) == 0)
+			read_only = 0;
+		else if (strlen(argv[i]) == 7 && strncmp(argv[i], "altterm", 7) == 0)
+			_altterm = 1;
+		else if (strlen(argv[i]) == 4 && strncmp(argv[i], "help", 4) == 0) {
+			print_tsol_usage();
+			return 0;
+		}
+		else {
+			print_tsol_usage();
+			return 0;
+		}
+	}
+
+	/* create udp socket to receive the packet */	
+	memset(&sin, 0, sizeof(sin));
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons(port);
+
+#ifdef __CYGWIN__
+	result = inet_aton((const char *)intf->session->hostname,
+			   &intf->session->addr.sin_addr);
+#else
+	result = inet_pton(AF_INET, (const char *)intf->session->hostname,
+			   &intf->session->addr.sin_addr);
+#endif
+
+	if (result <= 0) {
+		struct hostent *host = gethostbyname((const char *)intf->session->hostname);
+		if (host == NULL ) {
+			lprintf(LOG_ERR, "Address lookup for %s failed",
+				intf->session->hostname);
+			return -1;
+		}
+		intf->session->addr.sin_family = host->h_addrtype;
+		memcpy(&intf->session->addr.sin_addr, host->h_addr, host->h_length);
+	}
+
+	fd_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (fd_socket < 0) {
+		lprintf(LOG_ERR, "Can't open port %d", port);
+		return -1;
+	}
+	bind(fd_socket, (struct sockaddr *)&sin, sizeof(sin));
+
+	/*
+	 * retrieve local IP address if not supplied on command line
+	 */
+	if (recvip == NULL) {
+		result = intf->open(intf);	/* must connect first */
+		if (result < 0)
+			return -1;
+
+		mylen = sizeof(myaddr);
+		if (getsockname(intf->fd, (struct sockaddr *)&myaddr, &mylen) < 0) {
+			lperror(LOG_ERR, "getsockname failed");
+			return -1;
+		}
+
+		recvip = inet_ntoa(myaddr.sin_addr);
+		if (recvip == NULL) {
+			lprintf(LOG_ERR, "Unable to find local IP address");
+			return -1;
+		}
+	}
+
+	printf("[Starting %sSOL with receiving address %s:%d]\r\n",
+	       read_only ? "Read-only " : "", recvip, port);
+
+	set_terminal_size(rows, cols);
+	enter_raw_mode();
+
+	/*
+	 * talk to smdc to start Console redirect - IP address and port as parameter 
+	 * ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x06 0xC0 0xA8 0xA8 0x78 0x1A 0x0A
+	 */
+	result = ipmi_tsol_start(intf, recvip, port);
+        if (result < 0) {
+		lprintf(LOG_ERR, "Error starting SOL");
+                return -1;
+        }
+
+	printf("[SOL Session operational.  Use %c? for help]\r\n",
+	       intf->session->sol_escape_char);
+
+	gettimeofday(&_start_keepalive, 0);	
+
+	fds_wait[0].fd = fd_socket;
+	fds_wait[0].events = POLLIN;
+	fds_wait[0].revents = 0;
+	fds_wait[1].fd = fileno(stdin);
+	fds_wait[1].events = POLLIN;
+	fds_wait[1].revents = 0;
+	fds_wait[2].fd = -1;
+	fds_wait[2].events = 0;
+	fds_wait[2].revents = 0;
+	
+	fds_data_wait[0].fd = fd_socket;
+	fds_data_wait[0].events = POLLIN | POLLOUT;
+	fds_data_wait[0].revents = 0;
+	fds_data_wait[1].fd = fileno(stdin);
+	fds_data_wait[1].events = POLLIN;
+	fds_data_wait[1].revents = 0;
+	fds_data_wait[2].fd = fileno(stdout);
+	fds_data_wait[2].events = POLLOUT;
+	fds_data_wait[2].revents = 0;
+	
+	out_buff_fill = 0;
+	in_buff_fill = 0;
+	fds = fds_wait;
+	
+	for (;;) {
+		result = poll(fds, 3, 15*1000);
+		if (result < 0)
+			break;
+
+		/* send keepalive packet */
+		tsol_keepalive(intf);
+
+		if ((fds[0].revents & POLLIN) && (sizeof(out_buff) > out_buff_fill)){
+			socklen_t sin_len = sizeof(sin);
+			result = recvfrom(fd_socket, buff, sizeof(out_buff) - out_buff_fill + 4, 0,
+					  (struct sockaddr *)&sin, &sin_len);
+
+			/* read the data from udp socket, skip some bytes in the head */
+			if((result - 4) > 0 ){
+				int length = result - 4;
+#if 1
+		 		length = (unsigned char)buff[2] & 0xff;
+			       	length *= 256;
+				length += ((unsigned char)buff[3] & 0xff);
+				if ((length <= 0) || (length > (result - 4)))
+			              length = result - 4;
+#endif
+				memcpy(out_buff + out_buff_fill, buff + 4, length);
+				out_buff_fill += length;
+			}
+		}
+		if ((fds[1].revents & POLLIN) && (sizeof(in_buff) > in_buff_fill)) {
+			result = read(fileno(stdin), in_buff + in_buff_fill,
+				      sizeof(in_buff) - in_buff_fill); // read from keyboard
+			if (result > 0) {
+				int bytes;
+				bytes = do_inbuf_actions(intf, in_buff + in_buff_fill, result);
+				if(bytes < 0) {
+					result = ipmi_tsol_stop(intf, recvip, port);
+					do_terminal_cleanup();
+					return result;
+				}
+				if (read_only) 
+					bytes = 0;
+				in_buff_fill += bytes;
+			}
+		}
+		if ((fds[2].revents & POLLOUT) && out_buff_fill) {
+			result = write(fileno(stdout), out_buff, out_buff_fill); // to screen
+			if (result > 0) {
+				out_buff_fill -= result;
+				if (out_buff_fill) {
+					memmove(out_buff, out_buff + result, out_buff_fill);
+				}
+			}
+		}
+		if ((fds[0].revents & POLLOUT) && in_buff_fill) {
+			/*
+			 * translate key and send that to SMDC using IPMI 
+			 * ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x03 0x04 0x1B 0x5B 0x43
+			 */
+			result = ipmi_tsol_send_keystroke(intf, in_buff, __min(in_buff_fill,14));
+			if (result > 0) {
+				gettimeofday(&_start_keepalive, 0);
+				in_buff_fill -= result;
+				if (in_buff_fill) {
+					memmove(in_buff, in_buff + result, in_buff_fill);
+				}
+			}
+		}
+		fds = (in_buff_fill || out_buff_fill )? 
+			fds_data_wait : fds_wait;
+	}
+	
+	return 0;
+}
--- a/ipmitool/lib/ipmi_user.c
+++ b/ipmitool/lib/ipmi_user.c
@ -142,6 +142,8 @@ ipmi_get_user_name(
 	struct ipmi_rq	       req;
 	uint8_t	       msg_data[1];

+	memset(user_name, 0, 17);
+
 	memset(&req, 0, sizeof(req));
 	req.msg.netfn    = IPMI_NETFN_APP;	   /* 0x06 */
 	req.msg.cmd	     = IPMI_GET_USER_NAME; /* 0x45 */
@ -158,6 +160,8 @@ ipmi_get_user_name(
 		return -1;
 	}
 	if (rsp->ccode > 0) {
+		if (rsp->ccode == 0xcc)
+			return 0;
 		lprintf(LOG_ERR, "Get User Name command failed (user %d): %s",
 			user_id, val2str(rsp->ccode, completion_code_vals));
 		return -1;
@ -345,6 +349,47 @@ ipmi_user_set_username(
 }
 	

+static int
+ipmi_user_set_userpriv(
+		       struct ipmi_intf * intf,
+             uint8_t	  channel,
+		       uint8_t	  user_id,
+		       const unsigned char	privLevel)
+{
+	struct ipmi_rs	     * rsp;
+	struct ipmi_rq	       req;
+	uint8_t	       msg_data[17];
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn    = IPMI_NETFN_APP;	     /* 0x06 */
+	req.msg.cmd	     = IPMI_SET_USER_ACCESS;   /* 0x43 */
+	req.msg.data     = msg_data;
+	req.msg.data_len = 3;
+
+
+	/* The channel number will remain constant throughout this function */
+	msg_data[0] = (channel   & 0x0f); /* Do not change any bytes */
+	msg_data[1] = (user_id   & 0x3f);
+	msg_data[2] = (privLevel & 0x0f);
+
+	rsp = intf->sendrecv(intf, &req);
+
+	if (rsp == NULL) 
+   {
+		lprintf(LOG_ERR, "Set Privilege Level command failed (user %d)",
+			user_id);
+		return -1;
+	}
+	if (rsp->ccode > 0) 
+   {
+		lprintf(LOG_ERR, "Set Privilege Level command failed (user %d)",
+			user_id);
+		return -1;
+	}
+
+	return 0;
+}
+

 /*
 * ipmi_user_set_password
@ -450,8 +495,8 @@ ipmi_user_test_password(
 /*
 * print_user_usage
 */
-void
-print_user_usage()
+static void
+print_user_usage(void)
 {
 	lprintf(LOG_NOTICE, "User Commands: summary [<channel number>]");
 	lprintf(LOG_NOTICE, "		   list	   [<channel number>]");
@ -459,6 +504,7 @@ print_user_usage()
 	lprintf(LOG_NOTICE, "		   set password <user id> [<password>]");
 	lprintf(LOG_NOTICE, "		   disable	<user id>");
 	lprintf(LOG_NOTICE, "		   enable	<user id>");
+	lprintf(LOG_NOTICE, "		   priv  	<user id> <privile level> [<channel number>]");
 	lprintf(LOG_NOTICE, "		   test		<user id> <16|20> [<password]>\n");
 }

@ -700,8 +746,40 @@ ipmi_user_main(struct ipmi_intf * intf, int argc, char ** argv)
 			print_user_usage();
 			return -1;
 		}
-	}
+
+	}
+
+	else if (strncmp(argv[0], "priv", 4) == 0)
+	{
+   	uint8_t user_id;
+   	uint8_t priv_level;
+   	uint8_t channel = 0x0e; /* Use channel running on */
+
+		if (
+            (argc != 3) &&
+            (argc != 4)
+         )
+		
+
+      if (argc == 4)
+      {
+         channel = (uint8_t)strtol(argv[3], NULL, 0);
+         channel = (channel & 0x0f);
+		}
+      
+      user_id = (uint8_t)strtol(argv[1], NULL, 0);
+
+		priv_level = (uint8_t)strtol(argv[2], NULL, 0);
+      priv_level = (priv_level & 0x0f);
+
+		if (user_id == 0)
+		{
+			lprintf(LOG_ERR, "Invalid user ID: %d", user_id);
+			return -1;
+		}

+		retval = ipmi_user_set_userpriv(intf,channel,user_id,priv_level);
+   }

 	/*
 	 * Disable / Enable
--- a/ipmitool/src/Makefile.am
+++ b/ipmitool/src/Makefile.am
@ -40,12 +40,8 @@ MAINTAINERCLEANFILES	= Makefile.in
 ipmitool_SOURCES	= ipmitool.c ipmishell.c
 ipmitool_LDADD		= $(top_builddir)/lib/libipmitool.la plugins/libintf.la

-if IPMIEVD
 ipmievd_SOURCES		= ipmievd.c
 ipmievd_LDADD		= $(top_builddir)/lib/libipmitool.la plugins/libintf.la
-endif

-EXTRA_DIST		= ipmievd.c
-
-bin_PROGRAMS		= ipmitool @IPMIEVD_BIN@
-EXTRA_PROGRAMS		= ipmitool ipmievd
+bin_PROGRAMS		= ipmitool
+sbin_PROGRAMS		= ipmievd
--- a/ipmitool/src/ipmievd.c
+++ b/ipmitool/src/ipmievd.c
@ -44,94 +44,258 @@
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/poll.h>

 #ifdef __FreeBSD__
-#include <signal.h>
-#include <paths.h>
+# include <signal.h>
+# include <paths.h>
 #endif

 #include <config.h>

-#ifdef HAVE_OPENIPMI_H
-# include <linux/ipmi.h>
-#else
-# include "plugins/open/open.h"
-#endif
+#ifdef IPMI_INTF_OPEN
+# ifdef HAVE_OPENIPMI_H
+#  include <linux/compiler.h>
+#  include <linux/ipmi.h>
+#  include <sys/poll.h>
+# else /* HAVE_OPENIPMI_H */
+#  include "plugins/open/open.h"
+#  include <sys/poll.h>
+# endif	/* HAVE_OPENIPMI_H */
+#endif /* IPMI_INTF_OPEN */

 #include <ipmitool/helper.h>
 #include <ipmitool/log.h>
 #include <ipmitool/ipmi.h>
 #include <ipmitool/ipmi_intf.h>
 #include <ipmitool/ipmi_sel.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_strings.h>
+#include <ipmitool/ipmi_main.h>

-extern int errno;
+/* global variables */
 int verbose = 0;
 int csv_output = 0;
+uint16_t selwatch_count = 0;	/* number of entries in the SEL */
+uint16_t selwatch_lastid = 0;	/* current last entry in the SEL */
+int selwatch_timeout = 10;	/* default to 10 seconds */

-static void daemonize(void)
+/* event interface definition */
+struct ipmi_event_intf {
+	char name[16];
+	char desc[128];
+	int (*setup)(struct ipmi_event_intf * eintf);
+	int (*wait)(struct ipmi_event_intf * eintf);
+	int (*read)(struct ipmi_event_intf * eintf);
+	int (*check)(struct ipmi_event_intf * eintf);
+	void (*log)(struct ipmi_event_intf * eintf, struct sel_event_record * evt);
+	struct ipmi_intf * intf;
+};
+
+static void log_event(struct ipmi_event_intf * eintf, struct sel_event_record * evt);
+
+/* ~~~~~~~~~~~~~~~~~~~~~~ openipmi ~~~~~~~~~~~~~~~~~~~~ */
+#ifdef IPMI_INTF_OPEN
+static int openipmi_setup(struct ipmi_event_intf * eintf);
+static int openipmi_wait(struct ipmi_event_intf * eintf);
+static int openipmi_read(struct ipmi_event_intf * eintf);
+static struct ipmi_event_intf openipmi_event_intf = {
+	name:	"open",
+	desc:	"OpenIPMI asyncronous notification of events",
+	setup:	openipmi_setup,
+	wait:	openipmi_wait,
+	read:	openipmi_read,
+	log:	log_event,
+};
+#endif
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+/* ~~~~~~~~~~~~~~~~~~~~~~ selwatch ~~~~~~~~~~~~~~~~~~~~ */
+static int selwatch_setup(struct ipmi_event_intf * eintf);
+static int selwatch_wait(struct ipmi_event_intf * eintf);
+static int selwatch_read(struct ipmi_event_intf * eintf);
+static int selwatch_check(struct ipmi_event_intf * eintf);
+static struct ipmi_event_intf selwatch_event_intf = {
+	name:	"sel",
+	desc:	"Poll SEL for notification of events",
+	setup:	selwatch_setup,
+	wait:	selwatch_wait,
+	read:	selwatch_read,
+	check:	selwatch_check,
+	log:	log_event,
+};
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+struct ipmi_event_intf * ipmi_event_intf_table[] = {
+#ifdef IPMI_INTF_OPEN
+	&openipmi_event_intf,
+#endif
+	&selwatch_event_intf,
+	NULL
+};
+
+/*************************************************************************/
+
+static void
+ipmievd_usage(void)
 {
-	pid_t pid;
-	int fd;
-#ifdef SIGHUP
-	sigset_t sighup;
-#endif
-
-	/* if we are started from init no need to become daemon */
-	if (getppid() == 1)
-		return;
-
-#ifdef SIGHUP
-	sigemptyset(&sighup);
-	sigaddset(&sighup, SIGHUP);
-	if (sigprocmask(SIG_UNBLOCK, &sighup, NULL) < 0)
-		fprintf(stderr, "ERROR: could not unblock SIGHUP signal\n");
-	signal(SIGHUP, SIG_IGN);
-#endif
-#ifdef SIGTTOU
-	signal(SIGTTOU, SIG_IGN);
-#endif
-#ifdef SIGTTIN
-	signal(SIGTTIN, SIG_IGN);
-#endif
-#ifdef SIGQUIT
-	signal(SIGQUIT, SIG_IGN);
-#endif
-#ifdef SIGTSTP
-	signal(SIGTSTP, SIG_IGN);
-#endif
-
-	pid = (pid_t) fork();
-	if (pid < 0 || pid > 0)
-		exit(0);
-	
-#if defined(SIGTSTP) && defined(TIOCNOTTY)
-	if (setpgid(0, getpid()) == -1)
-		exit(1);
-	if ((fd = open(_PATH_TTY, O_RDWR)) >= 0) {
-		ioctl(fd, TIOCNOTTY, NULL);
-		close(fd);
-	}
-#else
-	if (setpgrp() == -1)
-		exit(1);
-	pid = (pid_t) fork();
-	if (pid < 0 || pid > 0)
-		exit(0);
-#endif
-
-	chdir("/");
-	umask(0);
-
-	for (fd=0; fd<64; fd++)
-		close(fd);
-
-	open("/dev/null", O_RDWR);
-	dup(0);
-	dup(0);
+	lprintf(LOG_NOTICE, "Options:");
+	lprintf(LOG_NOTICE, "\ttimeout=#     Time between checks for SEL polling method [default=10]");
+	lprintf(LOG_NOTICE, "\tdaemon        Become a daemon [default]");
+	lprintf(LOG_NOTICE, "\tnodaemon      Do NOT become a daemon");
 }

-static int enable_event_msg_buffer(struct ipmi_intf * intf)
+/* ipmi_intf_load  -  Load an event interface from the 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
+ */
+static struct ipmi_event_intf *
+ipmi_event_intf_load(char * name)
+{
+	struct ipmi_event_intf ** intf;
+	struct ipmi_event_intf * i;
+
+	if (name == NULL) {
+		i = ipmi_event_intf_table[0];
+		return i;
+	}
+
+	for (intf = ipmi_event_intf_table;
+	     ((intf != NULL) && (*intf != NULL));
+	     intf++) {
+		i = *intf;
+		if (strncmp(name, i->name, strlen(name)) == 0) {
+			return i;
+		}
+	}
+
+	return NULL;
+}
+
+static void
+log_event(struct ipmi_event_intf * eintf, struct sel_event_record * evt)
+{
+	char *desc;
+	const char *type;
+	struct sdr_record_list * sdr;
+	struct ipmi_intf * intf = eintf->intf;
+	float trigger_reading = 0.0;
+	float threshold_reading = 0.0;
+
+	if (evt == NULL)
+		return;
+
+	if (evt->record_type == 0xf0) {
+		lprintf(LOG_ALERT, "Linux kernel panic: %.11s", (char *) evt + 5);
+		return;
+	}
+	else if (evt->record_type >= 0xc0) {
+		lprintf(LOG_NOTICE, "IPMI Event OEM Record %02x", evt->record_type);
+		return;
+	}
+
+	type = ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0]);
+	ipmi_get_event_desc(intf, evt, &desc);
+
+	sdr = ipmi_sdr_find_sdr_bynumtype(intf, evt->sel_type.standard_type.sensor_num, evt->sel_type.standard_type.sensor_type);
+	if (sdr == NULL) {
+		/* could not find matching SDR record */
+		if (desc) {
+			lprintf(LOG_NOTICE, "%s sensor - %s",
+				type, desc);
+			free(desc);
+		} else {
+			lprintf(LOG_NOTICE, "%s sensor %02x",
+				type, evt->sel_type.standard_type.sensor_num);
+		}
+		return;
+	}
+
+	switch (sdr->type) {
+	case SDR_RECORD_TYPE_FULL_SENSOR:
+		if (evt->sel_type.standard_type.event_type == 1) {
+			/*
+			 * Threshold Event
+			 */
+
+			/* trigger reading in event data byte 2 */
+			if (((evt->sel_type.standard_type.event_data[0] >> 6) & 3) == 1) {
+				trigger_reading = sdr_convert_sensor_reading(
+					sdr->record.full, evt->sel_type.standard_type.event_data[1]);
+			}
+
+			/* trigger threshold in event data byte 3 */
+			if (((evt->sel_type.standard_type.event_data[0] >> 4) & 3) == 1) {
+				threshold_reading = sdr_convert_sensor_reading(
+					sdr->record.full, evt->sel_type.standard_type.event_data[2]);
+			}
+
+			lprintf(LOG_NOTICE, "%s sensor %s %s (Reading %.*f %s Threshold %.*f %s)",
+				type,
+				sdr->record.full->id_string,
+				desc ? : "",
+				(trigger_reading==(int)trigger_reading) ? 0 : 2,
+				trigger_reading,
+				((evt->sel_type.standard_type.event_data[0] & 0xf) % 2) ? ">" : "<",
+				(threshold_reading==(int)threshold_reading) ? 0 : 2,
+				threshold_reading,
+				ipmi_sdr_get_unit_string(sdr->record.full->unit.modifier,
+							 sdr->record.full->unit.type.base,
+							 sdr->record.full->unit.type.modifier));
+		}
+		else if ((evt->sel_type.standard_type.event_type >= 0x2 && evt->sel_type.standard_type.event_type <= 0xc) ||
+			 (evt->sel_type.standard_type.event_type == 0x6f)) {
+			/*
+			 * Discrete Event
+			 */
+			lprintf(LOG_NOTICE, "%s sensor %s %s",
+				type, sdr->record.full->id_string, desc ? : "");
+			if (((evt->sel_type.standard_type.event_data[0] >> 6) & 3) == 1) {
+				/* previous state and/or severity in event data byte 2 */
+			}
+		}
+		else if (evt->sel_type.standard_type.event_type >= 0x70 && evt->sel_type.standard_type.event_type <= 0x7f) {
+			/*
+			 * OEM Event
+			 */
+			lprintf(LOG_NOTICE, "%s sensor %s %s",
+				type, sdr->record.full->id_string, desc ? : "");
+		}
+		break;
+
+	case SDR_RECORD_TYPE_COMPACT_SENSOR:
+		if (evt->sel_type.standard_type.event_type == 0x6f) {
+			lprintf(LOG_NOTICE, "%s sensor %s - %s %s",
+				type, sdr->record.compact->id_string,
+				desc ? : "",
+				evt->sel_type.standard_type.event_dir ? "Deasserted" : "Asserted");
+		} else {
+			lprintf(LOG_NOTICE, "%s sensor %s - %s",
+				type, sdr->record.compact->id_string, desc ? : "");
+		}
+		break;
+
+	default:
+		lprintf(LOG_NOTICE, "%s sensor - %s",
+			type, evt->sel_type.standard_type.sensor_num, desc ? : "");
+		break;
+	}
+
+	if (desc)
+		free(desc);
+}
+/*************************************************************************/
+
+
+/*************************************************************************/
+/**                         OpenIPMI Functions                          **/
+/*************************************************************************/
+#ifdef IPMI_INTF_OPEN
+static int
+openipmi_enable_event_msg_buffer(struct ipmi_intf * intf)
 {
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
@ -143,9 +307,13 @@ static int enable_event_msg_buffer(struct ipmi_intf * intf)
 	req.msg.cmd = 0x2f;	/* Get BMC Global Enables */

 	rsp = intf->sendrecv(intf, &req);
-	if (!rsp || rsp->ccode) {
-		lprintf(LOG_WARNING, "Get BMC Global Enables command filed [ccode %02x]",
-		       rsp ? rsp->ccode : 0);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Get BMC Global Enables command failed");
+		return -1;
+	}
+	else if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Get BMC Global Enables command failed: %s",
+		       val2str(rsp->ccode, completion_code_vals));
 		return -1;
 	}

@ -155,9 +323,13 @@ static int enable_event_msg_buffer(struct ipmi_intf * intf)
 	req.msg.data_len = 1;

 	rsp = intf->sendrecv(intf, &req);
-	if (!rsp || rsp->ccode) {
-		lprintf(LOG_WARNING, "Set BMC Global Enables command failed [ccode %02x]",
-		       rsp ? rsp->ccode : 0);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Set BMC Global Enables command failed");
+		return -1;
+	}
+	else if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Set BMC Global Enables command failed: %s",
+			val2str(rsp->ccode, completion_code_vals));
 		return -1;
 	}

@ -166,29 +338,33 @@ static int enable_event_msg_buffer(struct ipmi_intf * intf)
 	return 0;
 }

-static void log_event(struct sel_event_record * evt)
+static int
+openipmi_setup(struct ipmi_event_intf * eintf)
 {
-	char *desc;
+	int i, r;

-	if (!evt)
-		return;
-
-	if (evt->record_type == 0xf0)
-		lprintf(LOG_ALERT, "Linux kernel panic: %.11s", (char *) evt + 5);
-	else if (evt->record_type >= 0xc0)
-		lprintf(LOG_NOTICE, "IPMI Event OEM Record %02x", evt->record_type);
-	else {
-		ipmi_get_event_desc(evt, &desc);
-		if (desc) {
-			lprintf(LOG_NOTICE, "%s Sensor %02x - %s",
-				ipmi_sel_get_sensor_type(evt->sensor_type),
-				evt->sensor_num, desc);
-			free(desc);
-		}
+	/* enable event message buffer */
+	lprintf(LOG_DEBUG, "Enabling event message buffer");
+	r = openipmi_enable_event_msg_buffer(eintf->intf);
+	if (r < 0) {
+		lprintf(LOG_ERR, "Could not enable event message buffer");
+		return -1;
 	}
+
+	/* enable OpenIPMI event receiver */
+	lprintf(LOG_DEBUG, "Enabling event receiver");
+	i = 1;
+	r = ioctl(eintf->intf->fd, IPMICTL_SET_GETS_EVENTS_CMD, &i);
+	if (r != 0) {
+		lperror(LOG_ERR, "Could not enable event receiver");
+		return -1;
+	}
+
+	return 0;
 }

-static void read_event(struct ipmi_intf * intf)
+static int
+openipmi_read(struct ipmi_event_intf * eintf)
 {
 	struct ipmi_addr addr;
 	struct ipmi_recv recv;
@ -200,127 +376,46 @@ static void read_event(struct ipmi_intf * intf)
 	recv.msg.data = data;
 	recv.msg.data_len = sizeof(data);

-	rv = ioctl(intf->fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv);
+	rv = ioctl(eintf->intf->fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv);
 	if (rv < 0) {
 		switch (errno) {
 		case EINTR:
-			return; /* abort */
+			return 0; /* abort */
 		case EMSGSIZE:
 			recv.msg.data_len = sizeof(data); /* truncated */
 			break;
 		default:
 			lperror(LOG_ERR, "Unable to receive IPMI message");
-			return;
+			return -1;
 		}
 	}

 	if (!recv.msg.data || recv.msg.data_len == 0) {
 		lprintf(LOG_ERR, "No data in event");
-		return;
+		return -1;
 	}
 	if (recv.recv_type != IPMI_ASYNC_EVENT_RECV_TYPE) {
 		lprintf(LOG_ERR, "Type %x is not an event", recv.recv_type);
-		return;
+		return -1;
 	}

 	lprintf(LOG_DEBUG, "netfn:%x cmd:%x ccode:%d",
 	    recv.msg.netfn, recv.msg.cmd, recv.msg.data[0]);

-	log_event((struct sel_event_record *)recv.msg.data);
+	eintf->log(eintf, (struct sel_event_record *)recv.msg.data);
+
+	return 0;
 }

-static int do_exit(struct ipmi_intf * intf, int rv)
+static int
+openipmi_wait(struct ipmi_event_intf * eintf)
 {
-	if (intf)
-		intf->close(intf);
-	log_halt();
-	exit(rv);
-}
-
-static void usage(void)
-{
-	fprintf(stderr, "usage: ipmievd [-hvd]\n");
-	fprintf(stderr, "\n");
-	fprintf(stderr, "       -h        This help\n");
-	fprintf(stderr, "       -v        Verbose (can use multiple times)\n");
-	fprintf(stderr, "       -s        Do NOT daemonize\n");
-	fprintf(stderr, "\n");
-}
-
-int main(int argc, char ** argv)
-{
-	struct ipmi_intf * intf;
-	int r, a;
-	int i = 1;
-	int daemon = 1;
 	struct pollfd pfd;
-
-	/* make sure we have UID 0 */
-	if (geteuid() || getuid()) {
-		fprintf(stderr, "Inadequate privledges\n");
-		do_exit(NULL, EXIT_FAILURE);
-	}
-
-	while ((a = getopt(argc, (char **)argv, "hvs")) != -1) {
-		switch (a) {
-		case 'h':
-			usage();
-			do_exit(NULL, EXIT_SUCCESS);
-			break;
-		case 'v':
-			verbose++;
-			break;
-		case 's':
-			daemon = 0;
-			break;
-		default:
-			usage();
-			do_exit(NULL, EXIT_FAILURE);
-		}
-	}
-
-	if (daemon)
-		daemonize();
-
-	log_init("ipmievd", daemon, verbose);
-
-	/* load interface */
-	lprintf(LOG_DEBUG, "Loading OpenIPMI interface");
-	intf = ipmi_intf_load("open");
-	if (!intf) {
-		lprintf(LOG_ERR, "Unable to load OpenIPMI interface");
-		do_exit(NULL, EXIT_FAILURE);
-	}
-
-	/* open connection to openipmi device */
-	lprintf(LOG_DEBUG, "Connecting to OpenIPMI device");
-	r = intf->open(intf);
-	if (r < 0) {
-		lprintf(LOG_ERR, "Unable to open OpenIPMI device");
-		do_exit(NULL, EXIT_FAILURE);
-	}
-
-	/* enable event message buffer */
-	lprintf(LOG_DEBUG, "Enabling event message buffer");
-	r = enable_event_msg_buffer(intf);
-	if (r < 0) {
-		lprintf(LOG_ERR, "Could not enable event message buffer");
-		do_exit(intf, EXIT_FAILURE);
-	}
-
-	/* enable OpenIPMI event receiver */
-	lprintf(LOG_DEBUG, "Enabling event receiver");
-	r = ioctl(intf->fd, IPMICTL_SET_GETS_EVENTS_CMD, &i);
-	if (r != 0) {
-		lperror(LOG_ERR, "Could not enable event receiver");
-		do_exit(intf, EXIT_FAILURE);
-	}
-
-	lprintf(LOG_NOTICE, "Waiting for events...");
+	int r;

 	for (;;) {
-		pfd.fd = intf->fd;	/* wait on openipmi device */
-		pfd.events = POLLIN;	/* wait for input */
+		pfd.fd = eintf->intf->fd; /* wait on openipmi device */
+		pfd.events = POLLIN;      /* wait for input */
 		r = poll(&pfd, 1, -1);

 		switch (r) {
@ -329,14 +424,284 @@ int main(int argc, char ** argv)
 			break;
 		case -1:
 			lperror(LOG_CRIT, "Unable to read from IPMI device");
-			do_exit(intf, EXIT_FAILURE);
-			break;
+			return -1;
 		default:
-			if (pfd.revents && POLLIN)
-				read_event(intf);
+			if (pfd.revents & POLLIN)
+				eintf->read(eintf);
 		}
 	}

-	lprintf(LOG_DEBUG, "Shutting down...");
-	do_exit(intf, EXIT_SUCCESS);
+	return 0;
+}
+#endif /* IPMI_INTF_OPEN */
+/*************************************************************************/
+
+
+/*************************************************************************/
+/**                         SEL Watch Functions                         **/
+/*************************************************************************/
+static uint16_t
+selwatch_get_count(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_STORAGE;
+	req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Get SEL Info command failed");
+		return 0;
+	}
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Get SEL Info command failed: %s",
+		       val2str(rsp->ccode, completion_code_vals));
+		return 0;
+	}
+
+	lprintf(LOG_DEBUG, "SEL count is %d", buf2short(rsp->data+1));
+	return buf2short(rsp->data+1);
+}
+
+static uint16_t
+selwatch_get_lastid(struct ipmi_intf * intf)
+{
+	int next_id = 0;
+	uint16_t curr_id = 0;
+	struct sel_event_record evt;
+
+	if (selwatch_count == 0)
+		return 0;
+
+	while (next_id != 0xffff) {
+		curr_id = next_id;
+		lprintf(LOG_DEBUG, "SEL Next ID: %04x", curr_id);
+
+		next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
+		if (next_id < 0)
+			break;
+		if (next_id == 0) {
+			/*
+			 * usually next_id of zero means end but
+			 * retry because some hardware has quirks
+			 * and will return 0 randomly.
+			 */
+			next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
+			if (next_id <= 0)
+				break;
+		}
+	}
+
+	lprintf(LOG_DEBUG, "SEL lastid is %04x", curr_id);
+
+	return curr_id;
+}
+
+static int
+selwatch_setup(struct ipmi_event_intf * eintf)
+{
+	/* save current sel record count */
+	selwatch_count = selwatch_get_count(eintf->intf);
+	lprintf(LOG_DEBUG, "Current SEL count is %d", selwatch_count);
+
+	/* save current last record ID */
+	selwatch_lastid = selwatch_get_lastid(eintf->intf);
+	lprintf(LOG_DEBUG, "Current SEL lastid is %04x", selwatch_lastid);
+
+	return 0;
+}
+
+/* selwatch_check  -  check for waiting events
+ *
+ * this is done by reading sel info and comparing
+ * the sel count value to what we currently know
+ */
+static int
+selwatch_check(struct ipmi_event_intf * eintf)
+{
+	uint16_t old_count = selwatch_count;
+	selwatch_count = selwatch_get_count(eintf->intf);
+	if (selwatch_count == 0) {
+		lprintf(LOG_DEBUG, "SEL count is 0 (old=%d), resetting lastid to 0", old_count);
+		selwatch_lastid = 0;
+	} else if (selwatch_count < old_count) {
+		selwatch_lastid = selwatch_get_lastid(eintf->intf);
+		lprintf(LOG_DEBUG, "SEL count lowered, new SEL lastid is %04x", selwatch_lastid);
+	}
+	return (selwatch_count > old_count);
+}
+
+static int
+selwatch_read(struct ipmi_event_intf * eintf)
+{
+	uint16_t curr_id = 0;
+	int next_id = selwatch_lastid;
+	struct sel_event_record evt;
+
+	if (selwatch_count == 0)
+		return -1;
+
+	while (next_id != 0xffff) {
+		curr_id = next_id;
+		lprintf(LOG_DEBUG, "SEL Read ID: %04x", curr_id);
+
+		next_id = ipmi_sel_get_std_entry(eintf->intf, curr_id, &evt);
+		if (next_id < 0)
+			break;
+		if (next_id == 0) {
+			/*
+			 * usually next_id of zero means end but
+			 * retry because some hardware has quirks
+			 * and will return 0 randomly.
+			 */
+			next_id = ipmi_sel_get_std_entry(eintf->intf, curr_id, &evt);
+			if (next_id <= 0)
+				break;
+		}
+
+		if (curr_id != selwatch_lastid)
+			eintf->log(eintf, &evt);
+		else if (curr_id == 0)
+			eintf->log(eintf, &evt);
+	}
+
+	selwatch_lastid = curr_id;
+	return 0;
+}
+
+static int
+selwatch_wait(struct ipmi_event_intf * eintf)
+{
+	for (;;) {
+		if (eintf->check(eintf) > 0) {
+			lprintf(LOG_DEBUG, "New Events");
+			eintf->read(eintf);
+		}
+		sleep(selwatch_timeout);
+	}
+}
+/*************************************************************************/
+
+int
+ipmievd_main(struct ipmi_event_intf * eintf, int argc, char ** argv)
+{
+	int i, rc;
+	int daemon = 1;
+
+	for (i = 0; i < argc; i++) {
+		if (strncasecmp(argv[i], "help", 4) == 0) {
+			ipmievd_usage();
+			return 0;
+		}
+		if (strncasecmp(argv[i], "daemon", 6) == 0) {
+			daemon = 1;
+		}
+		else if (strncasecmp(argv[i], "nodaemon", 8) == 0) {
+			daemon = 0;
+		}
+		else if (strncasecmp(argv[i], "daemon=", 7) == 0) {
+			if (strncasecmp(argv[i]+7, "on", 2) == 0 ||
+			    strncasecmp(argv[i]+7, "yes", 3) == 0)
+				daemon = 1;
+			else if (strncasecmp(argv[i]+7, "off", 3) == 0 ||
+				 strncasecmp(argv[i]+7, "no", 2) == 0)
+				daemon = 0;
+		}
+		else if (strncasecmp(argv[i], "timeout=", 8) == 0) {
+			selwatch_timeout = strtoul(argv[i]+8, NULL, 0);
+		}
+	}
+
+	if (daemon)
+		ipmi_start_daemon();
+
+	log_halt();
+	log_init("ipmievd", daemon, verbose);
+
+	/* generate SDR cache for fast lookups */
+	lprintf(LOG_NOTICE, "Reading sensors...");
+	ipmi_sdr_list_cache(eintf->intf);
+	lprintf(LOG_DEBUG, "Sensors cached");
+
+	/* call event handler setup routine */
+	if (eintf->setup != NULL) {
+		rc = eintf->setup(eintf);
+		if (rc < 0) {
+			lprintf(LOG_ERR, "Error setting up Event Interface %s", eintf->name);
+			return -1;
+		}
+	}
+
+	lprintf(LOG_NOTICE, "Waiting for events...");
+
+	/* now launch event wait loop */
+	if (eintf->wait != NULL) {
+		rc = eintf->wait(eintf);
+		if (rc < 0) {
+			lprintf(LOG_ERR, "Error waiting for events!");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+ipmievd_sel_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_event_intf * eintf;
+
+	eintf = ipmi_event_intf_load("sel");
+	if (eintf == NULL) {
+		lprintf(LOG_ERR, "Unable to load event interface");
+		return -1;
+	}
+
+	eintf->intf = intf;
+
+	return ipmievd_main(eintf, argc, argv);
+}
+
+int
+ipmievd_open_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	struct ipmi_event_intf * eintf;
+
+	/* only one interface works for this */
+	if (strncmp(intf->name, "open", 4) != 0) {
+		lprintf(LOG_ERR, "Invalid Interface for OpenIPMI Event Handler: %s", intf->name);
+		return -1;
+	}
+
+	eintf = ipmi_event_intf_load("open");
+	if (eintf == NULL) {
+		lprintf(LOG_ERR, "Unable to load event interface");
+		return -1;
+	}
+
+	eintf->intf = intf;
+
+	return ipmievd_main(eintf, argc, argv);
+}
+
+struct ipmi_cmd ipmievd_cmd_list[] = {
+#ifdef IPMI_INTF_OPEN
+	{ ipmievd_open_main,	"open",   "Use OpenIPMI for asyncronous notification of events" },
+#endif
+	{ ipmievd_sel_main,	"sel",    "Poll SEL for notification of events" },
+	{ NULL }
+};
+
+int main(int argc, char ** argv)
+{
+	int rc;
+
+	rc = ipmi_main(argc, argv, ipmievd_cmd_list, NULL);
+
+	if (rc < 0)
+		exit(EXIT_FAILURE);
+	else
+		exit(EXIT_SUCCESS);
 }
--- a/ipmitool/src/ipmishell.c
+++ b/ipmitool/src/ipmishell.c
@ -46,6 +46,7 @@
 #include <ipmitool/ipmi.h>
 #include <ipmitool/ipmi_intf.h>
 #include <ipmitool/ipmi_session.h>
+#include <ipmitool/ipmi_main.h>

 #ifdef HAVE_CONFIG_H
 # include <config.h>
@ -54,9 +55,6 @@
 #define EXEC_BUF_SIZE	1024
 #define EXEC_ARG_SIZE	32

-extern void ipmi_cmd_print(void);
-extern int ipmi_cmd_run(struct ipmi_intf * intf, char * name, int argc, char ** argv);
-
 extern const struct valstr ipmi_privlvl_vals[];
 extern const struct valstr ipmi_authtype_session_vals[];

@ -98,7 +96,7 @@ static int rl_event_keepalive(void)

 int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)
 {
-	char *pbuf, **ap, *__argv[20];
+	char *ptr, *pbuf, **ap, *__argv[20];
 	int __argc, rc=0;

 	rl_readline_name = "ipmitool";
@ -113,8 +111,9 @@ int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)
 		shell_intf = intf;
 		rl_event_hook = rl_event_keepalive;
 #if defined(RL_READLINE_VERSION) && RL_READLINE_VERSION >= 0x0402
-		/* set to 1 second */
-		rl_set_keyboard_input_timeout(1000*1000);
+		/* There is a bug in readline 4.2 and later (at least on FreeBSD):
+		 * timeout equal or greater than 1 second causes an infinite loop. */
+		rl_set_keyboard_input_timeout(1000 * 1000 - 1);
 #endif
 	}

@ -130,7 +129,7 @@ int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)
 		}
 		if (strncmp(pbuf, "help", 4) == 0 ||
 		    strncmp(pbuf, "?", 1) == 0) {
-			ipmi_cmd_print();
+			ipmi_cmd_print(intf->cmdlist);
 			free(pbuf);
 			continue;
 		}
@ -138,6 +137,28 @@ int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)
 		/* for the all-important up arrow :) */
 		add_history(pbuf);
 		
+		/* change "" and '' with spaces in the middle to ~ */
+		ptr = pbuf;
+		while (*ptr != '\0') {
+			if (*ptr == '"') {
+				ptr++;
+				while (*ptr != '"') {
+					if (isspace(*ptr))
+						*ptr = '~';
+					ptr++;
+				}
+			}
+			if (*ptr == '\'') {
+				ptr++;
+				while (*ptr != '\'') {
+					if (isspace(*ptr))
+						*ptr = '~';
+					ptr++;
+				}
+			}
+			ptr++;
+		}
+
 		__argc = 0;
 		ap = __argv;

@ -145,6 +166,27 @@ int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)
 		     *ap != NULL;
 		     *ap = strtok(NULL, " \t")) {
 			__argc++;
+
+			ptr = *ap;
+			if (*ptr == '\'') {
+				memmove(ptr, ptr+1, strlen(ptr));
+				while (*ptr != '\'') {
+					if (*ptr == '~')
+						*ptr = ' ';
+					ptr++;
+				}
+				*ptr = '\0';
+			}
+			if (*ptr == '"') {
+				memmove(ptr, ptr+1, strlen(ptr));
+				while (*ptr != '"') {
+					if (*ptr == '~')
+						*ptr = ' ';
+					ptr++;
+				}
+				*ptr = '\0';
+			}
+
 			if (**ap != '\0') {
 				if (++ap >= &__argv[20])
 					break;
@ -173,6 +215,16 @@ ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv)

 #endif /* HAVE_READLINE */

+int ipmi_echo_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+	int i;
+
+	for (i=0; i<argc; i++) {
+		printf("%s ", argv[i]);
+	}
+	printf("\n");
+}
+
 static void
 ipmi_set_usage(void)
 {
@ -232,7 +284,7 @@ int ipmi_set_main(struct ipmi_intf * intf, int argc, char ** argv)
 	else if (strncmp(argv[0], "authtype", 8) == 0) {
 		int authtype;
 		authtype = str2val(argv[1], ipmi_authtype_session_vals);
-		if (authtype < 0) {
+		if (authtype == 0xFF) {
 			lprintf(LOG_ERR, "Invalid authtype: %s", argv[1]);
 		} else {
 			ipmi_intf_session_set_authtype(intf, authtype);
@ -243,7 +295,7 @@ int ipmi_set_main(struct ipmi_intf * intf, int argc, char ** argv)
 	else if (strncmp(argv[0], "privlvl", 7) == 0) {
 		int privlvl;
 		privlvl = str2val(argv[1], ipmi_privlvl_vals);
-		if (privlvl < 0) {
+		if (privlvl == 0xFF) {
 			lprintf(LOG_ERR, "Invalid privilege level: %s", argv[1]);
 		} else {
 			ipmi_intf_session_set_privlvl(intf, privlvl);
@ -301,8 +353,7 @@ int ipmi_exec_main(struct ipmi_intf * intf, int argc, char ** argv)
 		else
 			ptr = buf + strlen(buf);

-		/* change "" and '' with spaces in the middle to ~
-		 * this is really ugly but I'm in a hurry */
+		/* change "" and '' with spaces in the middle to ~ */
 		ptr = buf;
 		while (*ptr != '\0') {
 			if (*ptr == '"') {
--- a/ipmitool/src/ipmitool.c
+++ b/ipmitool/src/ipmitool.c
@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2004 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright (c) 2005 Sun Microsystems, Inc.  All Rights Reserved.
 * Use is subject to license terms.
 */

@ -37,23 +37,16 @@
 * facility.
 */

-#include <stdio.h>
-#include <unistd.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-
-#include <ipmitool/helper.h>
-#include <ipmitool/log.h>
 #include <ipmitool/ipmi.h>
 #include <ipmitool/ipmi_intf.h>
-#include <ipmitool/ipmi_session.h>
+#include <ipmitool/ipmi_main.h>
+
 #include <ipmitool/ipmi_sdr.h>
 #include <ipmitool/ipmi_sel.h>
 #include <ipmitool/ipmi_fru.h>
 #include <ipmitool/ipmi_sol.h>
 #include <ipmitool/ipmi_isol.h>
+#include <ipmitool/ipmi_tsol.h>
 #include <ipmitool/ipmi_lanp.h>
 #include <ipmitool/ipmi_chassis.h>
 #include <ipmitool/ipmi_mc.h>
@ -65,38 +58,31 @@
 #include <ipmitool/ipmi_raw.h>
 #include <ipmitool/ipmi_pef.h>
 #include <ipmitool/ipmi_oem.h>
+#include <ipmitool/ipmi_sunoem.h>
+#include <ipmitool/ipmi_fwum.h>
+#include <ipmitool/ipmi_picmg.h>

 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif

-#ifdef __sun
-# define OPTION_STRING	"I:hVvcH:f:U:p:"
-#else
-# define OPTION_STRING	"I:hVvcgsEao:H:P:f:U:p:C:L:A:t:m:"
+#ifdef HAVE_READLINE
+extern int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv);
 #endif
+extern int ipmi_echo_main(struct ipmi_intf * intf, int argc, char ** argv);
+extern int ipmi_set_main(struct ipmi_intf * intf, int argc, char ** argv);
+extern int ipmi_exec_main(struct ipmi_intf * intf, int argc, char ** argv);
+

 int csv_output = 0;
 int verbose = 0;

-extern const struct valstr ipmi_privlvl_vals[];
-extern const struct valstr ipmi_authtype_session_vals[];
-
-/* defined in ipmishell.c */
-#ifdef HAVE_READLINE
-extern int ipmi_shell_main(struct ipmi_intf * intf, int argc, char ** argv);
-#endif
-extern int ipmi_set_main(struct ipmi_intf * intf, int argc, char ** argv);
-extern int ipmi_exec_main(struct ipmi_intf * intf, int argc, char ** argv);
-
-struct ipmi_cmd {
-	int (*func)(struct ipmi_intf * intf, int argc, char ** argv);
-	const char * name;
-	const char * desc;
-} ipmi_cmd_list[] = {
+struct ipmi_cmd ipmitool_cmd_list[] = {
 	{ ipmi_raw_main,     "raw",     "Send a RAW IPMI request and print response" },
+	{ ipmi_rawi2c_main,  "i2c",     "Send an I2C Master Write-Read command and print response" },
 	{ ipmi_lanp_main,    "lan",     "Configure LAN Channels" },
 	{ ipmi_chassis_main, "chassis", "Get chassis status and set power state" },
+	{ ipmi_power_main,   "power",   "Shortcut to chassis power commands" },
 	{ ipmi_event_main,   "event",   "Send pre-defined events to MC" },
 	{ ipmi_mc_main,      "mc",      "Management Controller status and global enables" },
 	{ ipmi_mc_main,      "bmc",     NULL },	/* for backwards compatibility */
@ -105,445 +91,33 @@ struct ipmi_cmd {
 	{ ipmi_fru_main,     "fru",     "Print built-in FRU and scan SDR for FRU locators" },
 	{ ipmi_sel_main,     "sel",     "Print System Event Log (SEL)" },
 	{ ipmi_pef_main,     "pef",     "Configure Platform Event Filtering (PEF)" },
-	{ ipmi_sol_main,     "sol",     "Configure IPMIv2.0 Serial-over-LAN" },
+	{ ipmi_sol_main,     "sol",     "Configure and connect IPMIv2.0 Serial-over-LAN" },
+	{ ipmi_tsol_main,    "tsol",    "Configure and connect with Tyan IPMIv1.5 Serial-over-LAN" },
 	{ ipmi_isol_main,    "isol",    "Configure IPMIv1.5 Serial-over-LAN" },
 	{ ipmi_user_main,    "user",    "Configure Management Controller users" },
 	{ ipmi_channel_main, "channel", "Configure Management Controller channels" },
 	{ ipmi_session_main, "session", "Print session information" },
+	{ ipmi_sunoem_main,  "sunoem",  "OEM Commands for Sun servers" },
+	{ ipmi_picmg_main,   "picmg",   "Run a PICMG/ATCA extended cmd"},
+	{ ipmi_fwum_main,    "fwum",	"Update IPMC using Kontron OEM Firmware Update Manager" },
 #ifdef HAVE_READLINE
 	{ ipmi_shell_main,   "shell",   "Launch interactive IPMI shell" },
 #endif
 	{ ipmi_exec_main,    "exec",    "Run list of commands from file" },
 	{ ipmi_set_main,     "set",     "Set runtime variable for shell and exec" },
+	{ ipmi_echo_main,    "echo",    NULL }, /* for echoing lines to stdout in scripts */
 	{ NULL },
 };

-/*
- * Print all the commands in the above table to stderr
- * used for help text on command line and shell
- */
-void
-ipmi_cmd_print(void)
-{
-	struct ipmi_cmd * cmd;
-	lprintf(LOG_NOTICE, "Commands:");
-	for (cmd=ipmi_cmd_list; cmd->func != NULL; cmd++) {
-		if (cmd->desc == NULL)
-			continue;
-		lprintf(LOG_NOTICE, "\t%-12s %s", cmd->name, cmd->desc);
-	}
-	lprintf(LOG_NOTICE, "");
-}
-
-/* ipmi_cmd_run - run a command from list based on parameters
- *                called from main()
- *
- *                1. iterate through ipmi_cmd_list matching on name
- *                2. call func() for that command
- *
- * @intf:	ipmi interface
- * @name:	command name
- * @argc:	command argument count
- * @argv:	command argument list
- *
- * returns value from func() of that commnad if found
- * returns -1 if command is not found
- */
-int
-ipmi_cmd_run(struct ipmi_intf * intf, char * name, int argc, char ** argv)
-{
-	struct ipmi_cmd * cmd;
-
-	for (cmd=ipmi_cmd_list; cmd->func != NULL; cmd++) {
-		if (strncmp(name, cmd->name, strlen(cmd->name)) == 0)
-			break;
-	}
-	if (cmd->func == NULL) {
-		lprintf(LOG_ERR, "Invalid command: %s", name);
-		return -1;
-	}
-	return cmd->func(intf, argc, argv);
-}
-
-/* ipmitool_usage  -  print usage help
- */
-static void
-ipmitool_usage(void)
-{
-	lprintf(LOG_NOTICE, "ipmitool version %s\n", VERSION);
-	lprintf(LOG_NOTICE, "usage: ipmitool [options...] <command>\n");
-	lprintf(LOG_NOTICE, "       -h             This help");
-	lprintf(LOG_NOTICE, "       -V             Show version information");
-	lprintf(LOG_NOTICE, "       -v             Verbose (can use multiple times)");
-	lprintf(LOG_NOTICE, "       -c             Display output in comma separated format");
-	lprintf(LOG_NOTICE, "       -I intf        Interface to use");
-	lprintf(LOG_NOTICE, "       -H hostname    Remote host name for LAN interface");
-	lprintf(LOG_NOTICE, "       -p port        Remote RMCP port [default=623]");
-	lprintf(LOG_NOTICE, "       -U username    Remote session username");
-	lprintf(LOG_NOTICE, "       -f file        Read remote session password from file");
-	lprintf(LOG_NOTICE, "       -C ciphersuite Cipher suite to be used by lanplus interface");
-#ifndef __sun
-	lprintf(LOG_NOTICE, "       -L level       Remote session privilege level [default=USER]");
-	lprintf(LOG_NOTICE, "       -A authtype    Force use of auth type NONE, PASSWORD, MD2, MD5 or OEM");
-	lprintf(LOG_NOTICE, "       -P password    Remote session password");
-	lprintf(LOG_NOTICE, "       -a             Prompt for remote password");
-	lprintf(LOG_NOTICE, "       -E             Read password from IPMI_PASSWORD environment variable");
-	lprintf(LOG_NOTICE, "       -m address     Set local IPMB address");
-	lprintf(LOG_NOTICE, "       -t address     Bridge request to remote target address");
-	lprintf(LOG_NOTICE, "       -o oemtype     Setup for OEM (use 'list' to see available OEM types)");
-#endif
-	lprintf(LOG_NOTICE, "");
-	ipmi_intf_print();
-	ipmi_cmd_print();
-}
-
-/* ipmi_password_file_read  -  Open file and read password from it
- *
- * @filename:	file name to read from
- *
- * returns pointer to allocated buffer containing password
- *   (caller is expected to free when finished)
- * returns NULL on error
- */
-static char *
-ipmi_password_file_read(char * filename)
-{
-	FILE * fp;
-	char * pass = NULL;
-	int l;
-
-	pass = malloc(16);
-	if (pass == NULL) {
-		lprintf(LOG_ERR, "ipmitool: malloc failure");
-		return NULL;
-	}
-
-	fp = ipmi_open_file_read((const char *)filename);
-	if (fp == NULL) {
-		lprintf(LOG_ERR, "Unable to open password file %s",
-			filename);
-		return NULL;
-	}
-
-	/* read in id */
-	if (fgets(pass, 16, fp) == NULL) {
-		lprintf(LOG_ERR, "Unable to read password from file %s",
-			filename);
-		fclose(fp);
-		return NULL;
-	}
-
- 	/* remove trailing whitespace */
-	l = strcspn(pass, " \r\n\t");
-	if (l > 0) {
-		pass[l] = '\0';
-	}
-
-	fclose(fp);
-	return pass;
-}
-
-
 int
 main(int argc, char ** argv)
 {
-	struct ipmi_intf * intf = NULL;
-	uint8_t privlvl = 0;
-	uint8_t target_addr = 0;
-	uint8_t my_addr = 0;
-	int authtype = -1;
-	char * tmp = NULL;
-	char * hostname = NULL;
-	char * username = NULL;
-	char * password = NULL;
-	char * intfname = NULL;
-	char * progname = NULL;
-	char * oemtype  = NULL;
-	int port = 0;
-	int cipher_suite_id = 3; /* See table 22-19 of the IPMIv2 spec */
-	int argflag, i;
-	int rc = -1;
+	int rc;

-	/* save program name */
-	progname = strrchr(argv[0], '/');
-	progname = ((progname == NULL) ? argv[0] : progname);
+	rc = ipmi_main(argc, argv, ipmitool_cmd_list, NULL);

-	while ((argflag = getopt(argc, (char **)argv, OPTION_STRING)) != -1)
-	{
-		switch (argflag) {
-		case 'I':
-			intfname = strdup(optarg);
-			if (intfname == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-			break;
-		case 'h':
-			ipmitool_usage();
-			rc = 0;
-			goto out_free;
-			break;
-		case 'V':
-			printf("%s version %s\n", progname, VERSION);
-			rc = 0;
-			goto out_free;
-			break;
-		case 'p':
-			port = atoi(optarg);
-			break;
-		case 'C':
-			cipher_suite_id = atoi(optarg);
-			break;
-		case 'v':
-			verbose++;
-			break;
-		case 'c':
-			csv_output = 1;
-			break;
-		case 'H':
-			hostname = strdup(optarg);
-			if (hostname == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-			break;
-		case 'f':
-			if (password)
-				free(password);
-			password = ipmi_password_file_read(optarg);
-			if (password == NULL)
-				lprintf(LOG_ERR, "Unable to read password "
-					"from file %s", optarg);
-			break;
-		case 'a':
-#ifdef HAVE_GETPASSPHRASE
-			tmp = getpassphrase("Password: ");
-#else
-			tmp = getpass("Password: ");
-#endif
-			if (tmp != NULL) {
-				if (password)
-					free(password);
-				password = strdup(tmp);
-				if (password == NULL) {
-					lprintf(LOG_ERR, "ipmitool: malloc failure");
-					goto out_free;
-				}
-			}
-			break;
-		case 'U':
-			username = strdup(optarg);
-			if (username == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-			break;
-#ifndef __sun		/* some options not enabled on solaris yet */
-		case 'o':
-			oemtype = strdup(optarg);
-			if (oemtype == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-			if (strncmp(oemtype, "list", 4) == 0) {
-				ipmi_oem_print();
-				goto out_free;
-			}
-			break;
-		case 'g':
-			/* backwards compatible oem hack */
-			oemtype = strdup("intelwv2");
-			break;
-		case 's':
-			/* backwards compatible oem hack */
-			oemtype = strdup("supermicro");
-			break;
-		case 'P':
-			if (password)
-				free(password);
-			password = strdup(optarg);
-			if (password == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-
-			/* Prevent password snooping with ps */
-			i = strlen(optarg);
-			memset(optarg, 'X', i);
-			break;
-		case 'E':
-			if ((tmp = getenv("IPMITOOL_PASSWORD")))
-			{
-				if (password)
-					free(password);
-				password = strdup(tmp);
-				if (password == NULL) {
-					lprintf(LOG_ERR, "ipmitool: malloc failure");
-					goto out_free;
-				}
-			}
-			else if ((tmp = getenv("IPMI_PASSWORD")))
-			{
-				if (password)
-					free(password);
-				password = strdup(tmp);
-				if (password == NULL) {
-					lprintf(LOG_ERR, "ipmitool: malloc failure");
-					goto out_free;
-				}
-			}
-			else {
-				lprintf(LOG_WARN, "Unable to read password from environment");
-			}
-			break;
-		case 'L':
-			privlvl = (uint8_t)str2val(optarg, ipmi_privlvl_vals);
-			if (!privlvl)
-				lprintf(LOG_WARN, "Invalid privilege level %s", optarg);
-			break;
-		case 'A':
-			authtype = (int)str2val(optarg, ipmi_authtype_session_vals);
-			break;
-		case 't':
-			target_addr = (uint8_t)strtol(optarg, NULL, 0);
-			break;
-		case 'm':
-			my_addr = (uint8_t)strtol(optarg, NULL, 0);
-			break;
-#endif
-		default:
-			ipmitool_usage();
-			goto out_free;
-		}
-	}
-
-	/* check for command before doing anything */
-	if (argc-optind <= 0) {
-		lprintf(LOG_ERR, "No command provided!");
-		ipmitool_usage();
-		goto out_free;
-	}
-	if (strncmp(argv[optind], "help", 4) == 0) {
-		ipmi_cmd_print();
-		rc = 0;
-		goto out_free;
-	}
-
-
-
-	/*
-	 * If the user has specified a hostname (-H option)
-	 * then this is a remote access session.
-	 *
-	 * If no password was specified by any other method
-	 * and the authtype was not explicitly set to NONE
-	 * then prompt the user.
-	 */
-	if (hostname != NULL && password == NULL &&
-	    (authtype != IPMI_SESSION_AUTHTYPE_NONE || authtype < 0)) {
-#ifdef HAVE_GETPASSPHRASE
-		tmp = getpassphrase("Password: ");
-#else
-		tmp = getpass("Password: ");
-#endif
-		if (tmp != NULL) {
-			password = strdup(tmp);
-			if (password == NULL) {
-				lprintf(LOG_ERR, "ipmitool: malloc failure");
-				goto out_free;
-			}
-		}
-	}
-
-	/* if no interface was specified but a
-	 * hostname was then use LAN by default
-	 * otherwise the default is hardcoded
-	 * to use the first entry in the list
-	 */
-	if (intfname == NULL && hostname != NULL) {
-		intfname = strdup("lan");
-		if (intfname == NULL) {
-			lprintf(LOG_ERR, "ipmitool: malloc failure");
-			goto out_free;
-		}
-	}
-
-	/* load interface */
-	intf = ipmi_intf_load(intfname);
-	if (intf == NULL) {
-		lprintf(LOG_ERR, "Error loading interface %s", intfname);
-		goto out_free;
-	}
-
-	/* setup log */
-	log_init(progname, 0, verbose);
-
-	/* run OEM setup if found */
-	if (oemtype != NULL &&
-	    ipmi_oem_setup(intf, oemtype) < 0) {
-		lprintf(LOG_ERR, "OEM setup for \"%s\" failed", oemtype);
-		goto out_free;
-	}
-
-	/* set session variables */
-	if (hostname != NULL)
-		ipmi_intf_session_set_hostname(intf, hostname);
-	if (username != NULL)
-		ipmi_intf_session_set_username(intf, username);
-	if (password != NULL)
-		ipmi_intf_session_set_password(intf, password);
-	if (port > 0)
-		ipmi_intf_session_set_port(intf, port);
-	if (authtype >= 0)
-		ipmi_intf_session_set_authtype(intf, (uint8_t)authtype);
-	if (privlvl > 0)
-		ipmi_intf_session_set_privlvl(intf, privlvl);
-	else
-		ipmi_intf_session_set_privlvl(intf,
-		      IPMI_SESSION_PRIV_ADMIN);	/* default */
-
-	ipmi_intf_session_set_cipher_suite_id(intf, cipher_suite_id);
-
-	/* setup IPMB local and target address if given */
-	intf->my_addr = my_addr ? : IPMI_BMC_SLAVE_ADDR;
-	if (target_addr > 0) {
-		/* need to open the interface first */
-		if (intf->open != NULL)
-			intf->open(intf);
-		intf->target_addr = target_addr;
-		/* must be admin level to do this over lan */
-		ipmi_intf_session_set_privlvl(intf, IPMI_SESSION_PRIV_ADMIN);
-	}
-
-	/* now we finally run the command */
-	rc = ipmi_cmd_run(intf,
-			  argv[optind],
-			  argc-optind-1,
-			  &(argv[optind+1]));
-
-	/* clean repository caches */
-	ipmi_cleanup(intf);
-
-	/* call interface close function if available */
-	if (intf->opened > 0 && intf->close != NULL)
-		intf->close(intf);
-
- out_free:
-	log_halt();
-
-	if (intfname != NULL)
-		free(intfname);
-	if (hostname != NULL)
-		free(hostname);
-	if (username != NULL)
-		free(username);
-	if (password != NULL)
-		free(password);
-	if (oemtype != NULL)
-		free(oemtype);
-
-	if (rc >= 0)
-		exit(EXIT_SUCCESS);
-	else
+	if (rc < 0)
 		exit(EXIT_FAILURE);
+	else
+		exit(EXIT_SUCCESS);
 }
--- a/ipmitool/src/plugins/ipmi_intf.c
+++ b/ipmitool/src/plugins/ipmi_intf.c
@ -89,15 +89,30 @@ struct ipmi_intf * ipmi_intf_table[] = {
 *
 * no meaningful return code
 */
-void ipmi_intf_print(void)
+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++) {
-		lprintf(LOG_NOTICE, "\t%-12s %s %s",
+
+		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;
@ -165,7 +180,7 @@ ipmi_intf_session_set_username(struct ipmi_intf * intf, char * username)
 	if (intf->session == NULL)
 		return;

-	memset(intf->session->username, 0, 16);
+	memset(intf->session->username, 0, 17);

 	if (username == NULL)
 		return;
@ -209,6 +224,30 @@ ipmi_intf_session_set_cipher_suite_id(struct ipmi_intf * intf, uint8_t cipher_su
 	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)
 {
@ -227,6 +266,24 @@ ipmi_intf_session_set_authtype(struct ipmi_intf * intf, uint8_t authtype)
 	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)
 {
--- a/ipmitool/src/plugins/lan/lan.c
+++ b/ipmitool/src/plugins/lan/lan.c
@ -75,6 +75,8 @@ static struct ipmi_rq_entry * ipmi_req_entries_tail;

 extern int verbose;

+static uint8_t bridgePossible = 0; 
+
 static sigjmp_buf jmpbuf;

 static int ipmi_lan_send_packet(struct ipmi_intf * intf, uint8_t * data, int data_len);
@ -134,7 +136,7 @@ ipmi_req_lookup_entry(uint8_t seq, uint8_t cmd)
 {
 	struct ipmi_rq_entry * e = ipmi_req_entries;
 	while (e && (e->rq_seq != seq || e->req.msg.cmd != cmd)) {
-		if (e == e->next)
+		if (e->next == NULL || e == e->next)
 			return NULL;
 		e = e->next;
 	}
@ -183,10 +185,16 @@ ipmi_req_clear_entries(void)
 	while (e) {
 		lprintf(LOG_DEBUG+3, "cleared list entry seq=0x%02x cmd=0x%02x",
 			e->rq_seq, e->req.msg.cmd);
-		p = e->next;
-		free(e);
-		e = p;
+		if (e->next != NULL) {
+			p = e->next;
+			free(e);
+			e = p;
+		} else {
+			free(e);
+			break;
+		}
 	}
+	ipmi_req_entries = NULL;
 }

 static int
@ -223,7 +231,7 @@ struct ipmi_rs * ipmi_lan_recv_packet(struct ipmi_intf * intf)
 		return NULL;
 	}

-	alarm(IPMI_LAN_TIMEOUT);
+	alarm(intf->session->timeout);
 	rc = recv(intf->fd, &rsp.data, IPMI_BUF_SIZE, 0);
 	alarm(0);

@ -238,7 +246,7 @@ struct ipmi_rs * ipmi_lan_recv_packet(struct ipmi_intf * intf)
 	 * response is read before the connection refused is returned)
 	 */
 	if (rc < 0) {
-		alarm(IPMI_LAN_TIMEOUT);
+		alarm(intf->session->timeout);
 		rc = recv(intf->fd, &rsp.data, IPMI_BUF_SIZE, 0);
 		alarm(0);
 		if (rc < 0) {
@ -392,6 +400,14 @@ ipmi_lan_poll_recv(struct ipmi_intf * intf)
 	struct ipmi_rs * rsp;
 	struct ipmi_rq_entry * entry;
 	int x=0, rv;
+   uint8_t ourAddress = intf->my_addr;
+   
+   if(ourAddress == 0)
+   {
+      ourAddress = IPMI_BMC_SLAVE_ADDR;
+   }
+   
+

 	rsp = ipmi_lan_recv_packet(intf);

@ -470,16 +486,29 @@ ipmi_lan_poll_recv(struct ipmi_intf * intf)
 					      rsp->payload.ipmi_response.cmd);
 		if (entry) {
 			lprintf(LOG_DEBUG+2, "IPMI Request Match found");
-			if (intf->target_addr != IPMI_BMC_SLAVE_ADDR) {
-				if (rsp->data_len)
-					lprintf(LOG_DEBUG+1, "Bridged cmd %02x resp: %s",
-						rsp->payload.ipmi_response.cmd,
-						buf2str(&rsp->data[x],rsp->data_len));
+         if (
+               (intf->target_addr != ourAddress) &&
+               (bridgePossible)
+            )
+         {
+				if(
+               (rsp->data_len) &&
+               (rsp->payload.ipmi_response.cmd != 0x34)
+              )
+				{
+      			printbuf(
+                        &rsp->data[x], 
+                        (rsp->data_len-x),
+                        "bridge command response");
+				}
 				/* bridged command: lose extra header */
 				if (rsp->payload.ipmi_response.cmd == 0x34) {
+               if( rsp->data_len == 38 )
+               {
 					entry->req.msg.cmd = entry->req.msg.target_cmd;
 					rsp = ipmi_lan_recv_packet(intf);
 					continue;
+               }
 				} else {
 					//x += sizeof(rsp->payload.ipmi_response);
 					if (rsp->data[x-1] != 0)
@ -553,6 +582,13 @@ ipmi_lan_build_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	struct ipmi_rq_entry * entry;
 	struct ipmi_session * s = intf->session;
 	static int curr_seq = 0;
+   uint8_t ourAddress = intf->my_addr;
+   uint8_t bridgedRequest = 0;
+   
+   if(ourAddress == 0)
+   {
+      ourAddress = IPMI_BMC_SLAVE_ADDR;
+   }

 	if (curr_seq >= 64)
 		curr_seq = 0;
@ -593,15 +629,22 @@ ipmi_lan_build_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	}

 	/* message length */
-	if (intf->target_addr == IPMI_BMC_SLAVE_ADDR) {
+	if (
+         (intf->target_addr == ourAddress) ||
+         (!bridgePossible)
+      )
+   {
 		msg[len++] = req->msg.data_len + 7;
 		cs = mp = len;
 	}
-	else {
+	else 
+   {
 		/* bridged request: encapsulate w/in Send Message */
+      bridgedRequest = 1;
 		msg[len++] = req->msg.data_len + 15;
 		cs = mp = len;
 		msg[len++] = IPMI_BMC_SLAVE_ADDR;
+
 		msg[len++] = IPMI_NETFN_APP << 2;
 		tmp = len - cs;
 		msg[len++] = ipmi_csum(msg+cs, tmp);
@ -611,7 +654,7 @@ ipmi_lan_build_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 		msg[len++] = 0x34;			/* Send Message rqst */
 		entry->req.msg.target_cmd = entry->req.msg.cmd;	/* Save target command */
 		entry->req.msg.cmd = 0x34;		/* (fixup request entry) */
-		msg[len++] = 0x40;			/* Track request, Channel=IPMB */
+		msg[len++] = (0x40|intf->target_channel); /* Track request*/
 		cs = len;
 	}

@ -621,8 +664,11 @@ ipmi_lan_build_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	tmp = len - cs;
 	msg[len++] = ipmi_csum(msg+cs, tmp);
 	cs = len;
+   if (!bridgedRequest)
 	msg[len++] = IPMI_REMOTE_SWID;

+   else  /* Bridged message */
+   	msg[len++] = intf->my_addr;
 	entry->rq_seq = curr_seq++;
 	msg[len++] = entry->rq_seq << 2;
 	msg[len++] = req->msg.cmd;
@ -652,11 +698,13 @@ ipmi_lan_build_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	msg[len++] = ipmi_csum(msg+cs, tmp);

 	/* bridged request: 2nd checksum */
-	if (intf->target_addr != IPMI_BMC_SLAVE_ADDR) {
+	if (bridgedRequest) 
+   {
 		tmp = len - cs2;
 		msg[len++] = ipmi_csum(msg+cs2, tmp);
 	}

+
 	if (s->active) {
 		/*
 		 * s->authcode is already copied to msg+ap but some
@ -691,7 +739,7 @@ struct ipmi_rs *
 ipmi_lan_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 {
 	struct ipmi_rq_entry * entry;
-	struct ipmi_rs * rsp;
+	struct ipmi_rs * rsp = NULL;
 	int try = 0;

 	if (intf->opened == 0 && intf->open != NULL) {
@ -712,6 +760,10 @@ ipmi_lan_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 			continue;
 		}

+		/* if we are set to noanswer we do not expect response */
+		if (intf->noanswer)
+			break;
+
 		if (ipmi_oem_active(intf, "intelwv2"))
 			ipmi_lan_thump(intf);

@ -722,7 +774,7 @@ ipmi_lan_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 			break;

 		usleep(5000);
-		if (++try >= IPMI_LAN_RETRY) {
+		if (++try >= intf->session->retry) {
 			lprintf(LOG_DEBUG, "  No response from remote controller");
 			break;
 		}
@ -1139,6 +1191,8 @@ ipmi_activate_session_cmd(struct ipmi_intf * intf)
 		return -1;
 	}

+   bridgePossible = 1;
+   
 	lprintf(LOG_DEBUG, "\nSession Activated");
 	lprintf(LOG_DEBUG, "  Auth Type       : %s",
 		val2str(rsp->data[0], ipmi_authtype_session_vals));
@ -1160,6 +1214,7 @@ ipmi_set_session_privlvl_cmd(struct ipmi_intf * intf)
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
 	uint8_t privlvl = intf->session->privlvl;
+   uint8_t backupBridgePossible = bridgePossible;

 	if (privlvl <= IPMI_SESSION_PRIV_USER)
 		return 0;	/* no need to set higher */
@ -1170,7 +1225,12 @@ ipmi_set_session_privlvl_cmd(struct ipmi_intf * intf)
 	req.msg.data		= &privlvl;
 	req.msg.data_len	= 1;

+   bridgePossible = 0;
+
 	rsp = intf->sendrecv(intf, &req);
+   
+   bridgePossible = backupBridgePossible;
+
 	if (rsp == NULL) {
 		lprintf(LOG_ERR, "Set Session Privilege Level to %s failed",
 			val2str(privlvl, ipmi_privlvl_vals));
@ -1181,7 +1241,8 @@ ipmi_set_session_privlvl_cmd(struct ipmi_intf * intf)

 	if (rsp->ccode > 0) {
 		lprintf(LOG_ERR, "Set Session Privilege Level to %s failed: %s",
-			val2str(privlvl, ipmi_privlvl_vals));
+			val2str(privlvl, ipmi_privlvl_vals),
+			val2str(rsp->ccode, completion_code_vals));
 		return -1;
 	}

@ -1203,6 +1264,7 @@ ipmi_close_session_cmd(struct ipmi_intf * intf)
 		return -1;

 	intf->target_addr = IPMI_BMC_SLAVE_ADDR;
+   bridgePossible = 0;  /* Not a bridge message */

 	memcpy(&msg_data, &session_id, 4);

@ -1285,12 +1347,12 @@ ipmi_lan_activate_session(struct ipmi_intf * intf)
 	if (rc < 0)
 		goto fail;

+	intf->abort = 0;
+
 	rc = ipmi_set_session_privlvl_cmd(intf);
 	if (rc < 0)
 		goto fail;

-	intf->abort = 0;
-
 	return 0;

 fail:
@ -1331,6 +1393,10 @@ int ipmi_lan_open(struct ipmi_intf * intf)
 		s->port = IPMI_LAN_PORT;
 	if (s->privlvl == 0)
 		s->privlvl = IPMI_SESSION_PRIV_ADMIN;
+	if (s->timeout == 0)
+		s->timeout = IPMI_LAN_TIMEOUT;
+	if (s->retry == 0)
+		s->retry = IPMI_LAN_RETRY;

 	if (s->hostname == NULL || strlen(s->hostname) == 0) {
 		lprintf(LOG_ERR, "No hostname specified!");
--- a/ipmitool/src/plugins/lanplus/lanplus.c
+++ b/ipmitool/src/plugins/lanplus/lanplus.c
@ -92,10 +92,14 @@ static struct ipmi_rs * ipmi_lanplus_send_ipmi_cmd(struct ipmi_intf * intf, stru
 static struct ipmi_rs * ipmi_lanplus_send_payload(struct ipmi_intf * intf,
 												  struct ipmi_v2_payload * payload);
 static void getIpmiPayloadWireRep(
+						 		  struct ipmi_intf       * intf,
+						 		  struct ipmi_v2_payload * payload,  /* in  */
 								  uint8_t  * out,
 								  struct ipmi_rq * req,
-								  uint8_t    rq_seq);
+								  uint8_t    rq_seq,
+					 			  uint8_t curr_seq);
 static void getSolPayloadWireRep(
+						 		  struct ipmi_intf       * intf,
 								 uint8_t          * msg,
 								 struct ipmi_v2_payload * payload);
 static void read_open_session_response(struct ipmi_rs * rsp, int offset);
@ -117,6 +121,7 @@ static void ack_sol_packet(
 						   struct ipmi_intf * intf,
 						   struct ipmi_rs * rsp);

+static uint8_t bridgePossible = 0; 

 struct ipmi_intf ipmi_lanplus_intf = {
 	name:		"lanplus",
@ -285,6 +290,36 @@ static const struct valstr plus_payload_types_vals[] = {
 	{ 0x00, NULL },
 };

+
+static struct ipmi_rq_entry *
+ipmi_req_add_entry(struct ipmi_intf * intf, struct ipmi_rq * req, uint8_t req_seq)
+{
+	struct ipmi_rq_entry * e;
+
+	e = malloc(sizeof(struct ipmi_rq_entry));
+	if (e == NULL) {
+		lprintf(LOG_ERR, "ipmitool: malloc failure");
+		return NULL;
+	}
+
+	memset(e, 0, sizeof(struct ipmi_rq_entry));
+	memcpy(&e->req, req, sizeof(struct ipmi_rq));
+
+	e->intf = intf;
+   e->rq_seq = req_seq;
+
+	if (ipmi_req_entries == NULL)
+		ipmi_req_entries = e;
+	else
+		ipmi_req_entries_tail->next = e;
+
+	ipmi_req_entries_tail = e;
+	lprintf(LOG_DEBUG+3, "added list entry seq=0x%02x cmd=0x%02x",
+		e->rq_seq, e->req.msg.cmd);
+	return e;
+}
+
+
 static struct ipmi_rq_entry *
 ipmi_req_lookup_entry(uint8_t seq, uint8_t cmd)
 {
@ -309,8 +344,8 @@ ipmi_req_remove_entry(uint8_t seq, uint8_t cmd)
 		e = e->next;
 	}
 	if (e) {
-		if (verbose > 3)
-			printf("removed list entry seq=0x%02x cmd=0x%02x\n", seq, cmd);
+		lprintf(LOG_DEBUG+3, "removed list entry seq=0x%02x cmd=0x%02x",
+			seq, cmd);
 		p->next = (p->next == e->next) ? NULL : e->next;
 		if (ipmi_req_entries == e) {
 			if (ipmi_req_entries != p)
@ -324,6 +359,7 @@ ipmi_req_remove_entry(uint8_t seq, uint8_t cmd)
 			else
 				ipmi_req_entries_tail = NULL;
 		}
+		
 		if (e->msg_data)
 			free(e->msg_data);
 		free(e);
@ -337,9 +373,8 @@ ipmi_req_clear_entries(void)

 	e = ipmi_req_entries;
 	while (e) {
-		if (verbose > 3)
-			printf("cleared list entry seq=0x%02x cmd=0x%02x\n",
-			       e->rq_seq, e->req.msg.cmd);
+		lprintf(LOG_DEBUG+3, "cleared list entry seq=0x%02x cmd=0x%02x",
+			e->rq_seq, e->req.msg.cmd);
 		p = e->next;
 		free(e);
 		e = p;
@ -554,6 +589,13 @@ ipmi_lan_poll_recv(struct ipmi_intf * intf)
 	int offset, rv;
 	uint16_t payload_size;

+   uint8_t ourAddress = intf->my_addr;
+   
+   if(ourAddress == 0)
+   {
+      ourAddress = IPMI_BMC_SLAVE_ADDR;
+   }
+
 	rsp = ipmi_lan_recv_packet(intf);

 	/*
@ -672,6 +714,37 @@ ipmi_lan_poll_recv(struct ipmi_intf * intf)
 										  rsp->payload.ipmi_response.cmd);
 			if (entry != NULL) {
 				lprintf(LOG_DEBUG+2, "IPMI Request Match found");
+            if (
+                  (intf->target_addr != ourAddress) &&
+                  (bridgePossible)
+               )
+            {
+				   if(
+                  (rsp->data_len) &&
+                  (rsp->payload.ipmi_response.cmd != 0x34)
+                 )
+				   {
+      			   printbuf(
+                           &rsp->data[offset], 
+                           (rsp->data_len-offset),
+                           "bridge command response");
+				   }
+				   /* bridged command: lose extra header */
+				   if (rsp->payload.ipmi_response.cmd == 0x34) {
+                  if( rsp->data_len == 38 )
+                  {
+					   entry->req.msg.cmd = entry->req.msg.target_cmd;
+					   rsp = ipmi_lan_recv_packet(intf);
+					   continue;
+                  }
+				   } else {
+					   //x += sizeof(rsp->payload.ipmi_response);
+					   if (rsp->data[offset-1] != 0)
+						   lprintf(LOG_DEBUG, "WARNING: Bridged "
+							   "cmd ccode = 0x%02x",
+						          rsp->data[offset-1]);
+				   }
+			   }
 				ipmi_req_remove_entry(rsp->payload.ipmi_response.rq_seq,
 									  rsp->payload.ipmi_response.cmd);
 			} else {
@ -1254,48 +1327,104 @@ void read_sol_packet(struct ipmi_rs * rsp, int * offset)
 * param rq_seq [in] is the IPMI command sequence number.
 */
 void getIpmiPayloadWireRep(
+						   struct ipmi_intf       * intf,  /* in out */
+						   struct ipmi_v2_payload * payload,  /* in  */
 						   uint8_t  * msg,
 						   struct ipmi_rq * req,
-						   uint8_t    rq_seq)
+						   uint8_t    rq_seq,
+						   uint8_t curr_seq)
 {
-	int cs, mp, tmp, i;
+	int cs, /*mp,*/ tmp, len;

-	i = 0;
+	int cs2 = 0;
+
+   uint8_t ourAddress = intf->my_addr;
+   uint8_t bridgedRequest = 0;
+
+   if(ourAddress == 0)
+   {
+      ourAddress = IPMI_BMC_SLAVE_ADDR;
+   }
+
+	len = 0;

 	/* IPMI Message Header -- Figure 13-4 of the IPMI v2.0 spec */
-	cs = mp = i,
+   if (
+         (intf->target_addr == ourAddress) ||
+         (!bridgePossible)
+      )
+   {
+		cs = len;
+	}
+   else 
+   {
+		/* bridged request: encapsulate w/in Send Message */
+      bridgedRequest = 1;
+
+		cs = len;
+
+ 		msg[len++] = IPMI_BMC_SLAVE_ADDR;
+
+		msg[len++] = IPMI_NETFN_APP << 2;
+		tmp = len - cs;
+		msg[len++] = ipmi_csum(msg+cs, tmp);
+		cs2 = len;
+		msg[len++] = IPMI_REMOTE_SWID;
+		msg[len++] = curr_seq << 2;
+		msg[len++] = 0x34;			/* Send Message rqst */
+#if 0  /* From lan.c example */
+		entry->req.msg.target_cmd = entry->req.msg.cmd;	/* Save target command */
+		entry->req.msg.cmd = 0x34;		/* (fixup request entry) */
+#endif
+		msg[len++] = (0x40|intf->target_channel); /* Track request*/
+
+   	payload->payload_length += 7;
+
+		cs = len;
+	}

 	/* rsAddr */
-	msg[i++] = IPMI_BMC_SLAVE_ADDR; 
+	msg[len++] = intf->target_addr; /* IPMI_BMC_SLAVE_ADDR; */

 	/* net Fn */
-	msg[i++] = req->msg.netfn << 2;
-	tmp = i - cs;
+	msg[len++] = req->msg.netfn << 2;
+	tmp = len - cs;

 	/* checkSum */
-	msg[i++] = ipmi_csum(msg+cs, tmp);
-	cs = i;
+	msg[len++] = ipmi_csum(msg+cs, tmp);
+	cs = len;

 	/* rqAddr */
-	msg[i++] = IPMI_REMOTE_SWID;
+   if (!bridgedRequest)
+      msg[len++] = IPMI_REMOTE_SWID;
+   else  /* Bridged message */
+      msg[len++] = intf->my_addr;

 	/* rqSeq / rqLUN */
-	msg[i++] = rq_seq << 2;
+	msg[len++] = rq_seq << 2;

 	/* cmd */
-	msg[i++] = req->msg.cmd;
+	msg[len++] = req->msg.cmd;

 	/* message data */
 	if (req->msg.data_len) {
-		memcpy(msg + i,
+		memcpy(msg + len,
 			   req->msg.data,
 			   req->msg.data_len);
-		i += req->msg.data_len;
+		len += req->msg.data_len;
 	}

 	/* second checksum */
-	tmp = i - cs;
-	msg[i++] = ipmi_csum(msg+cs, tmp);
+	tmp = len - cs;
+	msg[len++] = ipmi_csum(msg+cs, tmp);
+   
+   	/* bridged request: 2nd checksum */
+	if (bridgedRequest) 
+   {
+		tmp = len - cs2;
+		msg[len++] = ipmi_csum(msg+cs2, tmp);
+   	payload->payload_length += 1;
+   }
 }


@ -1307,6 +1436,7 @@ void getIpmiPayloadWireRep(
 * param payload [in] holds the v2 payload with our SOL data
 */
 void getSolPayloadWireRep(
+						  struct ipmi_intf       * intf,  /* in out */
 						  uint8_t          * msg,     /* output */
 						  struct ipmi_v2_payload * payload) /* input */
 {
@ -1379,7 +1509,8 @@ ipmi_lanplus_build_v2x_msg(
 						   struct ipmi_intf       * intf,     /* in  */
 						   struct ipmi_v2_payload * payload,  /* in  */
 						   int                    * msg_len,  /* out */
-						   uint8_t         ** msg_data) /* out */
+						   uint8_t         ** msg_data, /* out */
+						   uint8_t curr_seq)
 {
 	uint32_t session_trailer_length = 0;
 	struct ipmi_session * session = intf->session;
@ -1399,7 +1530,7 @@ ipmi_lanplus_build_v2x_msg(
 		sizeof(rmcp)                +  // RMCP Header (4)
 		10                          +  // IPMI Session Header
 		2                           +  // Message length
-		IPMI_MAX_PAYLOAD_SIZE       +  // The actual payload
+		payload->payload_length     +  // The actual payload
 		IPMI_MAX_INTEGRITY_PAD_SIZE +  // Integrity Pad
 		1                           +  // Pad Length
 		1                           +  // Next Header
@ -1476,13 +1607,17 @@ ipmi_lanplus_build_v2x_msg(
 	switch (payload->payload_type)
 	{
 	case IPMI_PAYLOAD_TYPE_IPMI:
-		getIpmiPayloadWireRep(msg + IPMI_LANPLUS_OFFSET_PAYLOAD,
+		getIpmiPayloadWireRep(intf,
+                       payload,  /* in  */
+							  msg + IPMI_LANPLUS_OFFSET_PAYLOAD,
 							  payload->payload.ipmi_request.request,
-							  payload->payload.ipmi_request.rq_seq);
+							  payload->payload.ipmi_request.rq_seq,
+                       curr_seq);
 		break;

 	case IPMI_PAYLOAD_TYPE_SOL: 
-		getSolPayloadWireRep(msg + IPMI_LANPLUS_OFFSET_PAYLOAD,
+		getSolPayloadWireRep(intf,
+							 msg + IPMI_LANPLUS_OFFSET_PAYLOAD,
 							 payload);
 		len += payload->payload_length;

@ -1515,6 +1650,7 @@ ipmi_lanplus_build_v2x_msg(
 	default:
 		lprintf(LOG_ERR, "unsupported payload type 0x%x",
 			payload->payload_type);
+		free(msg);
 		assert(0);
 		break;
 	}
@ -1565,13 +1701,20 @@ ipmi_lanplus_build_v2x_msg(
 		 * Determine the required integrity pad length.  We have to make the
 		 * data range covered by the authcode a multiple of 4.
 		 */
-		uint32_t length_before_authcode =
-			12                          + /* the stuff before the payload */
-			payload->payload_length     +
-			1                           + /* pad length field  */
-			1;                            /* next header field */
+		uint32_t length_before_authcode;
+
+		if (ipmi_oem_active(intf, "icts")) {
+			length_before_authcode =
+				12                          + /* the stuff before the payload */
+				payload->payload_length;
+		} else {
+			length_before_authcode =
+				12                          + /* the stuff before the payload */
+				payload->payload_length     +
+				1                           + /* pad length field  */
+				1;                            /* next header field */
+		}

-		
 		if (length_before_authcode % 4)
 			integrity_pad_size = 4 - (length_before_authcode % 4);
 							  
@ -1661,31 +1804,15 @@ ipmi_lanplus_build_v2x_ipmi_cmd(
 	 * representation far below.
 	 */
 	static uint8_t curr_seq = 0;
+   
+   curr_seq += 1;
+   
 	if (curr_seq >= 64)
 		curr_seq = 0;
-	
-	entry = malloc(sizeof(struct ipmi_rq_entry));
-	if (entry == NULL) {
-		lprintf(LOG_ERR, "ipmitool: malloc failure");
+
+	entry = ipmi_req_add_entry(intf, req, curr_seq);
+	if (entry == NULL)
 		return NULL;
-	}
-	memset(entry, 0, sizeof(struct ipmi_rq_entry));
-	memcpy(&entry->req, req, sizeof(struct ipmi_rq));
-
-	entry->intf = intf;
-	entry->rq_seq = curr_seq;
-
-	// Factor out
-	if (!ipmi_req_entries)
-		ipmi_req_entries = entry;
-	else
-		ipmi_req_entries_tail->next = entry;
-	ipmi_req_entries_tail = entry;
-
-
-	lprintf(LOG_DEBUG+3, "added list entry seq=0x%02x cmd=0x%02x\n",
-		curr_seq, req->msg.cmd);
-

 	// Build our payload
 	v2_payload.payload_type                 = IPMI_PAYLOAD_TYPE_IPMI;
@ -1696,7 +1823,8 @@ ipmi_lanplus_build_v2x_ipmi_cmd(
 	ipmi_lanplus_build_v2x_msg(intf,                // in 
 							   &v2_payload,         // in 
 							   &(entry->msg_len),   // out
-							   &(entry->msg_data)); // out
+							   &(entry->msg_data),  // out
+                        curr_seq); // in

 	return entry;
 }
@ -1748,23 +1876,9 @@ ipmi_lanplus_build_v15_ipmi_cmd(
 	struct ipmi_session  * session = intf->session;
 	struct ipmi_rq_entry * entry;

-	entry = malloc(sizeof(struct ipmi_rq_entry));
-	if (entry == NULL) {
-		lprintf(LOG_ERR, "ipmitool: malloc failure");
+	entry = ipmi_req_add_entry(intf, req, 0);
+	if (entry == NULL)
 		return NULL;
-	}
-	memset(entry, 0, sizeof(struct ipmi_rq_entry));
-	memcpy(&entry->req, req, sizeof(struct ipmi_rq));
-
-	entry->intf = intf;
-
-	// Can be factored out
-	if (!ipmi_req_entries)
-		ipmi_req_entries = entry;
-	else
-		ipmi_req_entries_tail->next = entry;
-
-	ipmi_req_entries_tail = entry;

 	len = req->msg.data_len + 21;

@ -1961,7 +2075,8 @@ ipmi_lanplus_send_payload(
 		ipmi_lanplus_build_v2x_msg(intf,        /* in  */
 								   payload,     /* in  */
 								   &msg_length, /* out */
-								   &msg_data);  /* out */
+								   &msg_data,   /* out */
+                           0);  /* irrelevant for this msg*/

 	}

@ -1974,7 +2089,8 @@ ipmi_lanplus_send_payload(
 		ipmi_lanplus_build_v2x_msg(intf,        /* in  */
 								   payload,     /* in  */
 								   &msg_length, /* out */
-								   &msg_data);  /* out */
+								   &msg_data,   /* out */
+                           0);  /* irrelevant for this msg*/

 	}

@ -1987,7 +2103,8 @@ ipmi_lanplus_send_payload(
 		ipmi_lanplus_build_v2x_msg(intf,        /* in  */
 								   payload,     /* in  */
 								   &msg_length, /* out */
-								   &msg_data);  /* out */
+								   &msg_data,   /* out */
+                           0);  /* irrelevant for this msg*/

 	}

@ -1999,7 +2116,8 @@ ipmi_lanplus_send_payload(
 		ipmi_lanplus_build_v2x_msg(intf,        /* in  */
 								   payload,     /* in  */
 								   &msg_length, /* out */
-								   &msg_data);  /* out */
+								   &msg_data,   /* out */
+                           0);  /* irrelevant for this msg*/
 	}

 	else
@ -2010,7 +2128,7 @@ ipmi_lanplus_send_payload(
 	}


-	while (try < IPMI_LAN_RETRY) {
+	while (try < session->retry) {


 		if (ipmi_lan_send_packet(intf, msg_data, msg_length) < 0) {
@ -2018,6 +2136,10 @@ ipmi_lanplus_send_payload(
 			return NULL;
 		}

+		/* if we are set to noanswer we do not expect response */
+		if (intf->noanswer)
+			break;
+
 		usleep(100); 			/* Not sure what this is for */

 		/* Remember our connection state */
@ -2086,16 +2208,22 @@ ipmi_lanplus_send_payload(
 			if (rsp)
 				break;

-			usleep(5000);
 		}

+		usleep(5000);
+
 		try++;
 	}

 	
 	/* IPMI messages are deleted under ipmi_lan_poll_recv() */
-	if (payload->payload_type == IPMI_PAYLOAD_TYPE_SOL)
+	switch (payload->payload_type) {
+	case IPMI_PAYLOAD_TYPE_RMCP_OPEN_REQUEST:
+	case IPMI_PAYLOAD_TYPE_RAKP_1:
+	case IPMI_PAYLOAD_TYPE_RAKP_3:
 		free(msg_data);
+		break;
+	}

 	return rsp;
 }
@ -2403,6 +2531,11 @@ ipmi_get_auth_capabilities_cmd(
 	struct ipmi_rs * rsp;
 	struct ipmi_rq req;
 	uint8_t msg_data[2];
+   uint8_t backupBridgePossible;
+
+   backupBridgePossible = bridgePossible;
+
+   bridgePossible = 0;

 	msg_data[0] = IPMI_LAN_CHANNEL_E | 0x80; // Ask for IPMI v2 data as well
 	msg_data[1] = intf->session->privlvl;
@ -2440,6 +2573,7 @@ ipmi_get_auth_capabilities_cmd(
 		   rsp->data,
 		   sizeof(struct get_channel_auth_cap_rsp));

+   bridgePossible = backupBridgePossible;

 	return 0;
 }
@ -2453,10 +2587,14 @@ impi_close_session_cmd(struct ipmi_intf * intf)
 	struct ipmi_rq req;
 	uint8_t msg_data[4];
 	uint32_t bmc_session_lsbf;
+   uint8_t backupBridgePossible;

 	if (intf->session->v2_data.session_state != LANPLUS_STATE_ACTIVE)
 		return -1;

+   backupBridgePossible = bridgePossible;
+
+   bridgePossible = 0;

 	bmc_session_lsbf = intf->session->v2_data.bmc_id;
 	#if WORDS_BIGENDIAN
@ -2495,6 +2633,7 @@ impi_close_session_cmd(struct ipmi_intf * intf)
 	lprintf(LOG_DEBUG, "Closed Session %08lx\n",
 		(long)intf->session->v2_data.bmc_id);

+   bridgePossible = backupBridgePossible;
 	return 0;
 }

@ -2528,7 +2667,10 @@ ipmi_lanplus_open_session(struct ipmi_intf * intf)
 	memset(msg, 0, IPMI_OPEN_SESSION_REQUEST_SIZE);

 	msg[0] = 0; /* Message tag */
-	msg[1] = 0; /* Give us highest privlg level based on supported algorithms */
+	if (ipmi_oem_active(intf, "intelplus") || session->privlvl != IPMI_SESSION_PRIV_ADMIN)
+		msg[1] = session->privlvl;
+	else
+		msg[1] = 0; /* Give us highest privlg level based on supported algorithms */
 	msg[2] = 0; /* reserved */
 	msg[3] = 0; /* reserved */

@ -2547,6 +2689,7 @@ ipmi_lanplus_open_session(struct ipmi_intf * intf)
 	{
 		lprintf(LOG_WARNING, "Unsupported cipher suite ID : %d\n",
 				session->cipher_suite_id);
+		free(msg);
 		return -1;
 	}

@ -2594,6 +2737,7 @@ ipmi_lanplus_open_session(struct ipmi_intf * intf)

 	rsp = ipmi_lanplus_send_payload(intf, &v2_payload);

+	free(msg);

 	if (verbose)
 		lanplus_dump_open_session_response(rsp);
@ -2723,6 +2867,7 @@ ipmi_lanplus_rakp1(struct ipmi_intf * intf)
 		// ERROR;
 		lprintf(LOG_ERR, "ERROR generating random number "
 			"in ipmi_lanplus_rakp1");
+		free(msg);
 		return 1;
 	}
 	memcpy(msg + 8, session->v2_data.console_rand, 16);
@ -2753,6 +2898,7 @@ ipmi_lanplus_rakp1(struct ipmi_intf * intf)
 		lprintf(LOG_ERR, "ERROR: user name too long.  "
 			"(Exceeds %d characters)",
 			IPMI_MAX_USER_NAME_LENGTH);
+		free(msg);
 		return 1;
 	}
 	memcpy(msg + 28, session->username, msg[27]);
@ -2764,6 +2910,8 @@ ipmi_lanplus_rakp1(struct ipmi_intf * intf)

 	rsp = ipmi_lanplus_send_payload(intf, &v2_payload);

+	free(msg);
+
 	if (rsp == NULL)
 	{
 		lprintf(LOG_INFO, "> Error: no response from RAKP 1 message");
@ -2790,7 +2938,8 @@ ipmi_lanplus_rakp1(struct ipmi_intf * intf)
 		memcpy(session->v2_data.bmc_rand, rsp->payload.rakp2_message.bmc_rand, 16);
 		memcpy(session->v2_data.bmc_guid, rsp->payload.rakp2_message.bmc_guid, 16);

-		printbuf(session->v2_data.bmc_rand, 16, "bmc_rand");
+		if (verbose > 2)
+			printbuf(session->v2_data.bmc_rand, 16, "bmc_rand");

 		/*
 		 * It is at this point that we have to decode the random number and determine
@ -2883,6 +3032,7 @@ ipmi_lanplus_rakp3(struct ipmi_intf * intf)
 		{
 			/* Error */
 			lprintf(LOG_INFO, "> Error generating RAKP 3 authcode");
+			free(msg);
 			return 1;
 		}
 		else
@ -2896,18 +3046,21 @@ ipmi_lanplus_rakp3(struct ipmi_intf * intf)
 		{
 			/* Error */
 			lprintf(LOG_INFO, "> Error generating session integrity key");
+			free(msg);
 			return 1;
 		}
 		else if (lanplus_generate_k1(session))
 		{
 			/* Error */
 			lprintf(LOG_INFO, "> Error generating K1 key");
+			free(msg);
 			return 1;
 		}
 		else if (lanplus_generate_k2(session))
 		{
 			/* Error */
 			lprintf(LOG_INFO, "> Error generating K1 key");
+			free(msg);
 			return 1;
 		}
 	}
@ -2915,6 +3068,8 @@ ipmi_lanplus_rakp3(struct ipmi_intf * intf)

 	rsp = ipmi_lanplus_send_payload(intf, &v2_payload);

+	free(msg);
+
 	if (session->v2_data.rakp2_return_code != IPMI_RAKP_STATUS_NO_ERRORS)
 	{
 		/*
@ -2994,6 +3149,51 @@ ipmi_lanplus_close(struct ipmi_intf * intf)



+static int
+ipmi_set_session_privlvl_cmd(struct ipmi_intf * intf)
+{
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+   uint8_t backupBridgePossible;
+	uint8_t privlvl = intf->session->privlvl;
+
+	if (privlvl <= IPMI_SESSION_PRIV_USER)
+		return 0;	/* no need to set higher */
+
+   backupBridgePossible = bridgePossible;
+
+   bridgePossible = 0;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn		= IPMI_NETFN_APP;
+	req.msg.cmd		= 0x3b;
+	req.msg.data		= &privlvl;
+	req.msg.data_len	= 1;
+
+	rsp = intf->sendrecv(intf, &req);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Set Session Privilege Level to %s failed",
+			val2str(privlvl, ipmi_privlvl_vals));
+		return -1;
+	}
+	if (verbose > 2)
+		printbuf(rsp->data, rsp->data_len, "set_session_privlvl");
+
+	if (rsp->ccode > 0) {
+		lprintf(LOG_ERR, "Set Session Privilege Level to %s failed: %s",
+			val2str(privlvl, ipmi_privlvl_vals),
+			val2str(rsp->ccode, completion_code_vals));
+		return -1;
+	}
+
+	lprintf(LOG_DEBUG, "Set Session Privilege Level to %s\n",
+		val2str(rsp->data[0], ipmi_privlvl_vals));
+
+   bridgePossible = backupBridgePossible;
+
+	return 0;
+}
+
 /**
 * ipmi_lanplus_open
 */
@ -3014,7 +3214,11 @@ ipmi_lanplus_open(struct ipmi_intf * intf)
 	if (!session->port)
 		session->port = IPMI_LANPLUS_PORT;
 	if (!session->privlvl)
-		session->privlvl = IPMI_SESSION_PRIV_USER;
+		session->privlvl = IPMI_SESSION_PRIV_ADMIN;
+	if (!session->timeout)
+		session->timeout = IPMI_LAN_TIMEOUT;
+	if (!session->retry)
+		session->retry = IPMI_LAN_RETRY;

 	if (session->hostname == NULL || strlen(session->hostname) == 0) {
 		lprintf(LOG_ERR, "No hostname specified!");
@ -3034,8 +3238,9 @@ ipmi_lanplus_open(struct ipmi_intf * intf)
 	//session->sol_data.last_received_sequence_number = 0;
 	//session->sol_data.last_received_byte_count      = 0;
 	memset(session->v2_data.sik, 0, IPMI_SIK_BUFFER_SIZE);
-	memset(session->v2_data.kg,  0, IPMI_KG_BUFFER_SIZE);
-	session->timeout = IPMI_LAN_TIMEOUT;
+
+	/* Kg is set in ipmi_intf */
+	//memset(session->v2_data.kg,  0, IPMI_KG_BUFFER_SIZE);


 	/* open port to BMC */
@ -3142,6 +3347,12 @@ ipmi_lanplus_open(struct ipmi_intf * intf)

 	lprintf(LOG_DEBUG, "IPMIv2 / RMCP+ SESSION OPENED SUCCESSFULLY\n");

+   bridgePossible = 1;
+	
+	rc = ipmi_set_session_privlvl_cmd(intf);
+	if (rc < 0)
+		goto fail;
+
 	return intf->fd;

 fail:
@ -3152,7 +3363,7 @@ ipmi_lanplus_open(struct ipmi_intf * intf)



-void test_crypt1()
+void test_crypt1(void)
 {
 	uint8_t key[]  =
 		{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
@ -3201,7 +3412,7 @@ void test_crypt1()



-void test_crypt2()
+void test_crypt2(void)
 {
 	uint8_t key[]  =
 		{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
--- a/ipmitool/src/plugins/lanplus/lanplus_crypt.c
+++ b/ipmitool/src/plugins/lanplus/lanplus_crypt.c
@ -528,13 +528,10 @@ int lanplus_generate_sik(struct ipmi_session * session)
 	{
 		/* We will be hashing with Kg */
 		/*
-		 * TODO: Section 13.31 of the IPMI v2 spec describes the SIK creation
-		 * using Kg.  It specifies that Kg should not be truncated, but I
-		 * do not know what is meant by that.
+		 * Section 13.31 of the IPMI v2 spec describes the SIK creation
+		 * using Kg.  It specifies that Kg should not be truncated.
+		 * Kg is set in ipmi_intf.
 		 */
-		lprintf(LOG_ERR, "lanplus_generate_sik: We dont yet support hashing with Kg");
-		assert(0);
-
 		input_key        = session->v2_data.kg;
 	}
 	else
--- a/ipmitool/src/plugins/open/open.c
+++ b/ipmitool/src/plugins/open/open.c
@ -52,6 +52,7 @@
 #include <config.h>

 #ifdef HAVE_OPENIPMI_H
+# include <linux/compiler.h>
 # include <linux/ipmi.h>
 #else
 # include "open.h"
@ -59,21 +60,32 @@

 extern int verbose;

-#define IPMI_OPENIPMI_DEV	"/dev/ipmi0"
+#define IPMI_OPENIPMI_DEV		"/dev/ipmi0"
 #define IPMI_OPENIPMI_DEVFS	"/dev/ipmi/0"
+#define IPMI_OPENIPMI_DEVFS2	"/dev/ipmidev/0"

 static int
 ipmi_openipmi_open(struct ipmi_intf * intf)
 {
 	int i = 0;
+#ifdef INCLUDE_PICMG_GET_DEVICE_LOCATOR
+	struct ipmi_rq req;
+	struct ipmi_rs *rsp;
+	char msg_data;
+#endif

 	intf->fd = open(IPMI_OPENIPMI_DEV, O_RDWR);

 	if (intf->fd < 0) {
 		intf->fd = open(IPMI_OPENIPMI_DEVFS, O_RDWR);
-		lperror(LOG_ERR, "Could not open device at %s or %s",
-			IPMI_OPENIPMI_DEV, IPMI_OPENIPMI_DEVFS);
-		return -1;
+		if (intf->fd < 0) {
+			intf->fd = open(IPMI_OPENIPMI_DEVFS2, O_RDWR);
+		}
+		if (intf->fd < 0) {
+			lperror(LOG_ERR, "Could not open device at %s or %s or %s",
+			IPMI_OPENIPMI_DEV, IPMI_OPENIPMI_DEVFS , IPMI_OPENIPMI_DEVFS2);
+			return -1;
+		}
 	}

 	if (ioctl(intf->fd, IPMICTL_SET_GETS_EVENTS_CMD, &i) < 0) {
@ -90,9 +102,36 @@ ipmi_openipmi_open(struct ipmi_intf * intf)
 		lprintf(LOG_DEBUG, "Set IPMB address to 0x%x",
 			intf->my_addr);
 	}
-
 	intf->opened = 1;

+#ifdef INCLUDE_PICMG_GET_DEVICE_LOCATOR
+	/* PICMG hack to set right IPMB address, 
+      we might want to do GetPICMGProperties first.
+
+      In any case, on a server board or a non-picmg IpmC blade , this code 
+      will not have any adverse side effect
+   */
+	if ( (intf->my_addr == IPMI_BMC_SLAVE_ADDR) ) {
+		lprintf(LOG_DEBUG, "Running PICMG GetDeviceLocator" );
+		memset(&req, 0, sizeof(req));
+		req.msg.netfn = IPMI_NETFN_PICMG;
+		req.msg.cmd = 0x01;
+      msg_data    = 0x00;
+		req.msg.data = &msg_data; 
+		req.msg.data_len = 1;
+		msg_data = 0;
+
+		rsp = intf->sendrecv(intf, &req);
+		if (rsp) {
+         if ( !rsp->ccode ) {
+            intf->my_addr = rsp->data[2];
+            intf->target_addr = intf->my_addr;
+				lprintf(LOG_DEBUG, "Discovered IPMB address = 0x%x", intf->my_addr);
+			}
+		}
+	}
+#endif
+
 	return intf->fd;
 }

@ -118,6 +157,7 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	};
 	struct ipmi_ipmb_addr ipmb_addr = {
 		addr_type:	IPMI_IPMB_ADDR_TYPE,
+		channel:	intf->target_channel & 0x0f,
 	};
 	struct ipmi_req _req;
 	static struct ipmi_rs rsp;
@ -152,6 +192,7 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 		/* otherwise use system interface */
 		lprintf(LOG_DEBUG+2, "Sending request to "
 			"System Interface");
+      bmc_addr.lun = req->msg.lun;
 		_req.addr = (char *) &bmc_addr;
 		_req.addr_len = sizeof(bmc_addr);
 	}
@ -171,6 +212,9 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
 	 * wait for and retrieve response
 	 */

+	if (intf->noanswer)
+		return NULL;
+
 	FD_ZERO(&rset);
 	FD_SET(intf->fd, &rset);