Merge tag 'upstream/1.8.14'

Upstream version 1.8.14

1 files changed, 890 insertions, 0 deletions

diff --git a/lib/ipmi_pef.c b/lib/ipmi_pef.c
new file mode 100644
index 0000000..154bf40
--- /dev/null
+++ b/lib/ipmi_pef.c
@@ -0,0 +1,890 @@
+/*
+ * Copyright (c) 2004 Dell Computers.  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 Dell Computers, 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.
+ * DELL COMPUTERS ("DELL") 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
+ * DELL 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 DELL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <string.h>
+#include <math.h>
+#include <time.h>
+
+#include <ipmitool/bswap.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_pef.h>
+
+extern int verbose;
+/*
+// common kywd/value printf() templates
+*/
+static const char * pef_fld_fmts[][2] = {
+	{"%-*s : %u\n",          " | %u"},			/* F_DEC: unsigned value */
+	{"%-*s : %d\n",          " | %d"},			/* F_INT: signed value   */
+	{"%-*s : %s\n",          " | %s"},			/* F_STR: string value   */
+	{"%-*s : 0x%x\n",        " | 0x%x"},		/* F_HEX: "N hex digits" */
+	{"%-*s : 0x%04x\n",      " | 0x%04x"},		/* F_2XD: "2 hex digits" */
+	{"%-*s : 0x%02x\n",      " | 0x%02x"},		/* F_1XD: "1 hex digit"  */
+	{"%-*s : %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
+	     " | %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"},
+};
+typedef enum {
+	F_DEC,
+	F_INT,
+	F_STR,
+	F_HEX,
+	F_2XD,
+	F_1XD,
+	F_UID,
+} fmt_e;
+#define KYWD_LENGTH 24
+static int first_field = 1;
+
+static const char * pef_flag_fmts[][3] = {
+	{"",          "false",  "true"},
+	{"supported", "un",         ""},
+	{"active",    "in",         ""},
+	{"abled",     "dis",      "en"},
+};
+static const char * listitem[] =	{" | %s", ",%s", "%s"};
+
+const char * 
+ipmi_pef_bit_desc(struct bit_desc_map * map, uint32_t value)
+{	/*
+	// return description/text label(s) for the given value.
+	//  NB: uses a static buffer
+	*/
+	static char buf[128];
+	char * p;
+	struct desc_map * pmap;
+	uint32_t match, index;
+	
+	*(p = buf) = '\0';
+	index = 2;
+	for (pmap=map->desc_maps; pmap && pmap->desc; pmap++) {
+		if (map->desc_map_type == BIT_DESC_MAP_LIST)
+			match = (value == pmap->mask);
+		else
+			match = ((value & pmap->mask) == pmap->mask);
+
+		if (match) {
+			sprintf(p, listitem[index], pmap->desc);
+			p = strchr(p, '\0');
+			if (map->desc_map_type != BIT_DESC_MAP_ALL)
+				break;
+			index = 1;
+		}
+	}
+	if (p == buf)
+		return("None");
+
+	return((const char *)buf);
+}
+
+void
+ipmi_pef_print_flags(struct bit_desc_map * map, flg_e type, uint32_t val)
+{	/*
+	// print features/flags, using val (a bitmask), according to map.
+	// observe the verbose flag, and print any labels, etc. based on type
+	*/
+	struct desc_map * pmap;
+	uint32_t maskval, index;
+
+	index = 0;
+	for (pmap=map->desc_maps; pmap && pmap->desc; pmap++) {
+		maskval = (val & pmap->mask);
+		if (verbose)
+			printf("%-*s : %s%s\n", KYWD_LENGTH, 
+				ipmi_pef_bit_desc(map, pmap->mask),
+				pef_flag_fmts[type][1 + (maskval != 0)],
+				pef_flag_fmts[type][0]);
+		else if (maskval != 0) {
+			printf(listitem[index], ipmi_pef_bit_desc(map, maskval));
+			index = 1;
+		}
+	}
+}
+
+static void
+ipmi_pef_print_field(const char * fmt[2], const char * label, unsigned long val)
+{	/*
+	// print a 'field' (observes 'verbose' flag)
+	*/
+	if (verbose)
+		printf(fmt[0], KYWD_LENGTH, label, val);
+	else if (first_field)
+		printf(&fmt[1][2], val);	/* skip field separator */
+	else
+		printf(fmt[1], val);
+
+	first_field = 0;
+}
+
+void
+ipmi_pef_print_dec(const char * text, uint32_t val)
+{	/* unsigned */
+	ipmi_pef_print_field(pef_fld_fmts[F_DEC], text, val);
+}
+
+void
+ipmi_pef_print_int(const char * text, uint32_t val)
+{	/* signed */
+	ipmi_pef_print_field(pef_fld_fmts[F_INT], text, val);
+}
+
+void
+ipmi_pef_print_hex(const char * text, uint32_t val)
+{	/* hex */
+	ipmi_pef_print_field(pef_fld_fmts[F_HEX], text, val);
+}
+
+void 
+ipmi_pef_print_str(const char * text, const char * val)
+{	/* string */
+	ipmi_pef_print_field(pef_fld_fmts[F_STR], text, (unsigned long)val);
+}
+
+void 
+ipmi_pef_print_2xd(const char * text, uint8_t u1, uint8_t u2)
+{	/* 2 hex digits */
+	uint32_t val = ((u1 << 8) + u2) & 0xffff;
+	ipmi_pef_print_field(pef_fld_fmts[F_2XD], text, val);
+}
+
+void 
+ipmi_pef_print_1xd(const char * text, uint32_t val)
+{	/* 1 hex digit */
+	ipmi_pef_print_field(pef_fld_fmts[F_1XD], text, val);
+}
+
+static struct ipmi_rs * 
+ipmi_pef_msg_exchange(struct ipmi_intf * intf, struct ipmi_rq * req, char * txt)
+{	/*
+	// common IPMItool rqst/resp handling
+	*/
+	struct ipmi_rs * rsp = intf->sendrecv(intf, req);
+	if (!rsp) {
+		return(NULL);
+	} else if (rsp->ccode == 0x80)	{
+		return(NULL);   /* Do not output error, just unsupported parameters */
+	} else if (rsp->ccode) {
+		lprintf(LOG_ERR, " **Error %x in '%s' command", rsp->ccode, txt);
+		return(NULL);
+	}
+	if (verbose > 2) {
+		printbuf(rsp->data, rsp->data_len, txt);
+	}
+	return(rsp);
+}
+
+static uint8_t
+ipmi_pef_get_policy_table(struct ipmi_intf * intf,
+									struct pef_cfgparm_policy_table_entry ** table)
+{	/*
+	// get the PEF policy table: allocate space, fillin, and return its size 
+	//  NB: the caller must free the returned area (when returned size > 0)
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_cfgparm_selector psel;
+	struct pef_cfgparm_policy_table_entry * ptbl, * ptmp;
+	uint32_t i;
+	uint8_t tbl_size;
+
+	memset(&psel, 0, sizeof(psel));
+	psel.id = PEF_CFGPARM_ID_PEF_ALERT_POLICY_TABLE_SIZE;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CONFIG_PARMS;
+	req.msg.data = (uint8_t *)&psel;
+	req.msg.data_len = sizeof(psel);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert policy table size");
+	if (!rsp)
+		return(0);
+	tbl_size = (rsp->data[1] & PEF_POLICY_TABLE_SIZE_MASK);
+	i = (tbl_size * sizeof(struct pef_cfgparm_policy_table_entry));
+	if (!i
+	|| (ptbl = (struct pef_cfgparm_policy_table_entry *)malloc(i)) == NULL)
+		return(0);
+
+	memset(&psel, 0, sizeof(psel));
+	psel.id = PEF_CFGPARM_ID_PEF_ALERT_POLICY_TABLE_ENTRY;
+	for (ptmp=ptbl, i=1; i<=tbl_size; i++) {
+		psel.set = (i & PEF_POLICY_TABLE_ID_MASK);
+		rsp = ipmi_pef_msg_exchange(intf, &req, "Alert policy table entry");
+		if (!rsp
+		|| i != (rsp->data[1] & PEF_POLICY_TABLE_ID_MASK)) {
+			lprintf(LOG_ERR, " **Error retrieving %s",
+				"Alert policy table entry");
+			free(ptbl);
+			ptbl = NULL;
+			tbl_size = 0;
+			break;
+		}
+		memcpy(ptmp, &rsp->data[1], sizeof(*ptmp));
+		ptmp++;
+	}
+
+	*table = ptbl;
+	return(tbl_size);
+}
+
+static void
+ipmi_pef_print_lan_dest(struct ipmi_intf * intf, uint8_t ch, uint8_t dest)
+{	/*
+	// print LAN alert destination info
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_lan_cfgparm_selector lsel;
+	struct pef_lan_cfgparm_dest_type * ptype;
+	struct pef_lan_cfgparm_dest_info * pinfo;
+	char buf[32];
+	uint8_t tbl_size, dsttype, timeout, retries;
+
+	memset(&lsel, 0, sizeof(lsel));
+	lsel.id = PEF_LAN_CFGPARM_ID_DEST_COUNT;
+	lsel.ch = ch;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TRANSPORT;
+	req.msg.cmd = IPMI_CMD_LAN_GET_CONFIG;
+	req.msg.data = (uint8_t *)&lsel;
+	req.msg.data_len = sizeof(lsel);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert destination count");
+	if (!rsp) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Alert destination count");
+		return;
+	}
+	tbl_size = (rsp->data[1] & PEF_LAN_DEST_TABLE_SIZE_MASK);
+	//if (tbl_size == 0 || dest == 0)	/* LAN alerting not supported */
+	//	return;
+
+	lsel.id = PEF_LAN_CFGPARM_ID_DESTTYPE;
+	lsel.set = dest;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert destination type");
+	if (!rsp || rsp->data[1] != lsel.set) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Alert destination type");
+		return;
+	}
+	ptype = (struct pef_lan_cfgparm_dest_type *)&rsp->data[1];
+	dsttype = (ptype->dest_type & PEF_LAN_DEST_TYPE_MASK);
+	timeout = ptype->alert_timeout;
+	retries = (ptype->retries & PEF_LAN_RETRIES_MASK);
+	ipmi_pef_print_str("Alert destination type", 
+				ipmi_pef_bit_desc(&pef_b2s_lan_desttype, dsttype));
+	if (dsttype == PEF_LAN_DEST_TYPE_PET) {
+		lsel.id = PEF_LAN_CFGPARM_ID_PET_COMMUNITY;
+		lsel.set = 0;
+		rsp = ipmi_pef_msg_exchange(intf, &req, "PET community");
+		if (!rsp)
+			lprintf(LOG_ERR, " **Error retrieving %s",
+				"PET community");
+		else {
+			rsp->data[19] = '\0';
+			ipmi_pef_print_str("PET Community", (const char *)&rsp->data[1]);
+		}
+	}
+	ipmi_pef_print_dec("ACK timeout/retry (secs)", timeout);
+	ipmi_pef_print_dec("Retries", retries);
+
+	lsel.id = PEF_LAN_CFGPARM_ID_DESTADDR;
+	lsel.set = dest;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert destination info");
+	if (!rsp || rsp->data[1] != lsel.set)
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Alert destination info");
+	else {
+		pinfo = (struct pef_lan_cfgparm_dest_info *)&rsp->data[1];
+		sprintf(buf, "%u.%u.%u.%u", 
+					pinfo->ip[0], pinfo->ip[1], pinfo->ip[2], pinfo->ip[3]);
+		ipmi_pef_print_str("IP address", buf);
+
+		sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x", 
+					pinfo->mac[0], pinfo->mac[1], pinfo->mac[2], 
+					pinfo->mac[3], pinfo->mac[4], pinfo->mac[5]);
+		ipmi_pef_print_str("MAC address", buf);
+	}
+}
+
+static void
+ipmi_pef_print_serial_dest_dial(struct ipmi_intf * intf, char * label,
+											struct pef_serial_cfgparm_selector * ssel)
+{	/*
+	// print a dial string
+	*/
+#define BLOCK_SIZE 16
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_serial_cfgparm_selector tmp;
+	char * p, strval[(6 * BLOCK_SIZE) + 1];
+
+	memset(&tmp, 0, sizeof(tmp));
+	tmp.id = PEF_SERIAL_CFGPARM_ID_DEST_DIAL_STRING_COUNT;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TRANSPORT;
+	req.msg.cmd = IPMI_CMD_SERIAL_GET_CONFIG;
+	req.msg.data = (uint8_t *)&tmp;
+	req.msg.data_len = sizeof(tmp);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Dial string count");
+	if (!rsp || (rsp->data[1] & PEF_SERIAL_DIAL_STRING_COUNT_MASK) == 0)
+		return;	/* sssh, not supported */
+
+	memcpy(&tmp, ssel, sizeof(tmp));
+	tmp.id = PEF_SERIAL_CFGPARM_ID_DEST_DIAL_STRING;
+	tmp.block = 1;
+	memset(strval, 0, sizeof(strval));
+	p = strval;
+	for (;;) {
+		rsp = ipmi_pef_msg_exchange(intf, &req, label);
+		if (!rsp
+		|| (rsp->data[1] != ssel->id)
+		|| (rsp->data[2] != tmp.block)) {
+			lprintf(LOG_ERR, " **Error retrieving %s", label);
+			return;
+		}
+		memcpy(p, &rsp->data[3], BLOCK_SIZE);
+		if (strchr(p, '\0') <= (p + BLOCK_SIZE))
+			break;
+		if ((p += BLOCK_SIZE) >= &strval[sizeof(strval)-1])
+			break;
+		tmp.block++;
+	}
+
+	ipmi_pef_print_str(label, strval);
+#undef BLOCK_SIZE
+}
+
+static void
+ipmi_pef_print_serial_dest_tap(struct ipmi_intf * intf,
+											struct pef_serial_cfgparm_selector * ssel)
+{	/*
+	// print TAP destination info
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_serial_cfgparm_selector tmp;
+	struct pef_serial_cfgparm_tap_svc_settings * pset;
+	uint8_t dialstr_id, setting_id;
+
+	memset(&tmp, 0, sizeof(tmp));
+	tmp.id = PEF_SERIAL_CFGPARM_ID_TAP_ACCT_COUNT;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TRANSPORT;
+	req.msg.cmd = IPMI_CMD_SERIAL_GET_CONFIG;
+	req.msg.data = (uint8_t *)&tmp;
+	req.msg.data_len = sizeof(tmp);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Number of TAP accounts");
+	if (!rsp || (rsp->data[1] & PEF_SERIAL_TAP_ACCT_COUNT_MASK) == 0)
+		return;	/* sssh, not supported */
+
+	memcpy(&tmp, ssel, sizeof(tmp));
+	tmp.id = PEF_SERIAL_CFGPARM_ID_TAP_ACCT_INFO;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "TAP account info");
+	if (!rsp || (rsp->data[1] != tmp.set)) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"TAP account info");
+		return;
+	}
+	dialstr_id = (rsp->data[2] & PEF_SERIAL_TAP_ACCT_INFO_DIAL_STRING_ID_MASK);
+	dialstr_id >>= PEF_SERIAL_TAP_ACCT_INFO_DIAL_STRING_ID_SHIFT;
+	setting_id = (rsp->data[2] & PEF_SERIAL_TAP_ACCT_INFO_SVC_SETTINGS_ID_MASK);
+	tmp.set = dialstr_id;
+	ipmi_pef_print_serial_dest_dial(intf, "TAP Dial string", &tmp);
+
+	tmp.set = setting_id;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "TAP service settings");
+	if (!rsp || (rsp->data[1] != tmp.set)) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"TAP service settings");
+		return;
+	}
+	pset = (struct pef_serial_cfgparm_tap_svc_settings *)&rsp->data[1];
+	ipmi_pef_print_str("TAP confirmation",  
+		ipmi_pef_bit_desc(&pef_b2s_tap_svc_confirm, pset->confirmation_flags));
+
+	/* TODO : additional TAP settings? */
+}
+
+static void
+ipmi_pef_print_serial_dest_ppp(struct ipmi_intf * intf, 
+											struct pef_serial_cfgparm_selector * ssel)
+{	/*
+	// print PPP destination info
+	*/
+
+	/* TODO */
+}
+
+static void
+ipmi_pef_print_serial_dest_callback(struct ipmi_intf * intf,
+												struct pef_serial_cfgparm_selector * ssel)
+{	/*
+	// print callback destination info
+	*/
+
+	/* TODO */
+}
+
+static void
+ipmi_pef_print_serial_dest(struct ipmi_intf * intf, uint8_t ch, uint8_t dest)
+{	/*
+	// print Serial/PPP alert destination info
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_serial_cfgparm_selector ssel;
+	uint8_t tbl_size, wrk;
+	struct pef_serial_cfgparm_dest_info * pinfo;
+
+	memset(&ssel, 0, sizeof(ssel));
+	ssel.id = PEF_SERIAL_CFGPARM_ID_DEST_COUNT;
+	ssel.ch = ch;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_TRANSPORT;
+	req.msg.cmd = IPMI_CMD_SERIAL_GET_CONFIG;
+	req.msg.data = (uint8_t *)&ssel;
+	req.msg.data_len = sizeof(ssel);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert destination count");
+	if (!rsp) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Alert destination count");
+		return;
+	}
+	tbl_size = (rsp->data[1] & PEF_SERIAL_DEST_TABLE_SIZE_MASK);
+	if (!dest || tbl_size == 0)	/* Page alerting not supported */
+		return;
+
+	ssel.id = PEF_SERIAL_CFGPARM_ID_DESTINFO;
+	ssel.set = dest;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Alert destination info");
+	if (!rsp || rsp->data[1] != ssel.set)
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Alert destination info");
+	else {
+		pinfo = (struct pef_serial_cfgparm_dest_info *)rsp->data;
+		wrk = (pinfo->dest_type & PEF_SERIAL_DEST_TYPE_MASK);
+		ipmi_pef_print_str("Alert destination type", 
+					ipmi_pef_bit_desc(&pef_b2s_serial_desttype, wrk));
+		ipmi_pef_print_dec("ACK timeout (secs)",
+					pinfo->alert_timeout);
+		ipmi_pef_print_dec("Retries",
+					(pinfo->retries & PEF_SERIAL_RETRIES_MASK));
+		switch (wrk) {
+			case PEF_SERIAL_DEST_TYPE_DIAL:
+				ipmi_pef_print_serial_dest_dial(intf, "Serial dial string", &ssel);
+				break;
+			case PEF_SERIAL_DEST_TYPE_TAP:
+				ipmi_pef_print_serial_dest_tap(intf, &ssel);
+				break;
+			case PEF_SERIAL_DEST_TYPE_PPP:
+				ipmi_pef_print_serial_dest_ppp(intf, &ssel);
+				break;
+			case PEF_SERIAL_DEST_TYPE_BASIC_CALLBACK:
+			case PEF_SERIAL_DEST_TYPE_PPP_CALLBACK:
+				ipmi_pef_print_serial_dest_callback(intf, &ssel);
+				break;
+		}
+	}
+}
+
+static void
+ipmi_pef_print_dest(struct ipmi_intf * intf, uint8_t ch, uint8_t dest)
+{	/*
+	// print generic alert destination info
+	*/
+	ipmi_pef_print_dec("Destination ID", dest);
+}
+
+void
+ipmi_pef_print_event_info(struct pef_cfgparm_filter_table_entry * pef, char * buf)
+{	/*
+	//  print PEF entry Event info: class, severity, trigger, etc.
+	*/
+	static char * classes[] = {"Discrete", "Threshold", "OEM"};
+	uint16_t offmask;
+	char * p;
+	int i;
+	uint8_t t;
+
+	ipmi_pef_print_str("Event severity", 
+				ipmi_pef_bit_desc(&pef_b2s_severities, pef->entry.severity));
+
+	t = pef->entry.event_trigger;
+	if (t == PEF_EVENT_TRIGGER_THRESHOLD)
+		i = 1;
+	else if (t > PEF_EVENT_TRIGGER_SENSOR_SPECIFIC)
+		i = 2;
+	else
+		i = 0;
+	ipmi_pef_print_str("Event class", classes[i]);
+
+	offmask = ((pef->entry.event_data_1_offset_mask[1] << 8)
+	          + pef->entry.event_data_1_offset_mask[0]);
+
+	if (offmask == 0xffff || t == PEF_EVENT_TRIGGER_MATCH_ANY)
+		strcpy(buf, "Any");
+	else if (t == PEF_EVENT_TRIGGER_UNSPECIFIED)
+		strcpy(buf, "Unspecified");
+	else if (t == PEF_EVENT_TRIGGER_SENSOR_SPECIFIC)
+		strcpy(buf, "Sensor-specific");
+	else if (t > PEF_EVENT_TRIGGER_SENSOR_SPECIFIC)
+		strcpy(buf, "OEM");
+	else {
+		sprintf(buf, "(0x%02x/0x%04x)", t, offmask);
+		p = strchr(buf, '\0');
+		for (i=0; i<PEF_B2S_GENERIC_ER_ENTRIES; i++) {
+			if (offmask & 1) {
+				if ((t-1) >= PEF_B2S_GENERIC_ER_ENTRIES) {
+					sprintf(p, ", Unrecognized event trigger");
+				} else {
+					sprintf(p, ",%s", ipmi_pef_bit_desc(pef_b2s_generic_ER[t-1], i));
+				}
+				p = strchr(p, '\0');
+			}
+			offmask >>= 1;
+		}
+	}
+
+	ipmi_pef_print_str("Event trigger(s)", buf);
+}
+
+static void
+ipmi_pef_print_entry(struct ipmi_rs * rsp, uint8_t id,
+							struct pef_cfgparm_filter_table_entry * pef)
+{	/*
+	// print a PEF table entry
+	*/
+	uint8_t wrk, set;
+	char buf[128];
+
+	ipmi_pef_print_dec("PEF table entry", id);
+
+	wrk = !!(pef->entry.config & PEF_CONFIG_ENABLED);
+	sprintf(buf, "%sactive", (wrk ? "" : "in"));
+	if (pef->entry.config & PEF_CONFIG_PRECONFIGURED)
+		strcat(buf, ", pre-configured");
+
+	ipmi_pef_print_str("Status", buf);
+
+	if (wrk != 0) {
+		ipmi_pef_print_1xd("Version", rsp->data[0]);
+		ipmi_pef_print_str("Sensor type",
+					ipmi_pef_bit_desc(&pef_b2s_sensortypes, pef->entry.sensor_type));
+
+		if (pef->entry.sensor_number == PEF_SENSOR_NUMBER_MATCH_ANY)
+			ipmi_pef_print_str("Sensor number", "Any");
+		else
+			ipmi_pef_print_dec("Sensor number", pef->entry.sensor_number);
+
+		ipmi_pef_print_event_info(pef, buf);
+		ipmi_pef_print_str("Action",
+					ipmi_pef_bit_desc(&pef_b2s_actions, pef->entry.action));
+
+		if (pef->entry.action & PEF_ACTION_ALERT) {
+			set = (pef->entry.policy_number & PEF_POLICY_NUMBER_MASK);
+			ipmi_pef_print_int("Policy set", set);
+		}
+	}
+}
+
+static void
+ipmi_pef_list_entries(struct ipmi_intf * intf)
+{	/*
+	// list all PEF table entries
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_cfgparm_selector psel;
+	struct pef_cfgparm_filter_table_entry * pcfg;
+	uint32_t i;
+	uint8_t max_filters;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CAPABILITIES;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "PEF capabilities");
+	if (!rsp
+	|| (max_filters = ((struct pef_capabilities *)rsp->data)->tblsize) == 0)
+		return;	/* sssh, not supported */
+
+	memset(&psel, 0, sizeof(psel));
+	psel.id = PEF_CFGPARM_ID_PEF_FILTER_TABLE_ENTRY;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CONFIG_PARMS;
+	req.msg.data = (uint8_t *)&psel;
+	req.msg.data_len = sizeof(psel);
+	for (i=1; i<=max_filters; i++) {
+		if (i > 1)
+			printf("\n");
+		psel.set = (i & PEF_FILTER_TABLE_ID_MASK);
+		rsp = ipmi_pef_msg_exchange(intf, &req, "PEF table entry");
+		if (!rsp
+		|| (psel.set != (rsp->data[1] & PEF_FILTER_TABLE_ID_MASK))) {
+			lprintf(LOG_ERR, " **Error retrieving %s",
+				"PEF table entry");
+			continue;
+		}
+		pcfg = (struct pef_cfgparm_filter_table_entry *)&rsp->data[1];
+		first_field = 1;
+		ipmi_pef_print_entry(rsp, psel.set, pcfg);
+	}
+}
+
+static void
+ipmi_pef_list_policies(struct ipmi_intf * intf)
+{	/*
+	// list PEF alert policies
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_cfgparm_policy_table_entry * ptbl = NULL;
+	struct pef_cfgparm_policy_table_entry * ptmp = NULL;
+	uint32_t i;
+	uint8_t wrk, ch, medium, tbl_size;
+
+	tbl_size = ipmi_pef_get_policy_table(intf, &ptbl);
+	if (!tbl_size) {
+		if (!ptbl) {
+			free(ptbl);
+			ptbl = NULL;
+		}
+		return;
+	}
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_APP;
+	req.msg.cmd = IPMI_CMD_GET_CHANNEL_INFO;
+	req.msg.data = &ch;
+	req.msg.data_len = sizeof(ch);
+	for (ptmp=ptbl, i=1; i<=tbl_size; i++, ptmp++) {
+		if ((ptmp->entry.policy & PEF_POLICY_ENABLED) == PEF_POLICY_ENABLED) {
+			if (i > 1)
+				printf("\n");
+			first_field = 1;
+			ipmi_pef_print_dec("Alert policy table entry",
+						(ptmp->data1 & PEF_POLICY_TABLE_ID_MASK));
+			ipmi_pef_print_dec("Policy set",
+						(ptmp->entry.policy & PEF_POLICY_ID_MASK) >> PEF_POLICY_ID_SHIFT);
+			ipmi_pef_print_str("Policy entry rule",
+						ipmi_pef_bit_desc(&pef_b2s_policies, (ptmp->entry.policy & PEF_POLICY_FLAGS_MASK)));
+
+			if (ptmp->entry.alert_string_key & PEF_POLICY_EVENT_SPECIFIC) {
+				ipmi_pef_print_str("Event-specific", "true");
+//				continue;
+			}			
+			wrk = ptmp->entry.chan_dest;
+
+			/* channel/description */
+			ch = (wrk & PEF_POLICY_CHANNEL_MASK) >> PEF_POLICY_CHANNEL_SHIFT;
+			rsp = ipmi_pef_msg_exchange(intf, &req, "Channel info");
+			if (!rsp || rsp->data[0] != ch) {
+				lprintf(LOG_ERR, " **Error retrieving %s",
+					"Channel info");
+				continue;
+			}
+			medium = rsp->data[1];
+			ipmi_pef_print_dec("Channel number", ch);
+			ipmi_pef_print_str("Channel medium",
+						ipmi_pef_bit_desc(&pef_b2s_ch_medium, medium));
+
+			/* destination/description */
+			wrk &= PEF_POLICY_DESTINATION_MASK;
+			switch (medium) {
+				case PEF_CH_MEDIUM_TYPE_LAN:
+					ipmi_pef_print_lan_dest(intf, ch, wrk);
+					break;
+				case PEF_CH_MEDIUM_TYPE_SERIAL:
+					ipmi_pef_print_serial_dest(intf, ch, wrk);
+					break;
+				default:
+					ipmi_pef_print_dest(intf, ch, wrk);
+					break;
+			}
+		}
+	}
+	free(ptbl);
+	ptbl = NULL;
+}
+
+static void
+ipmi_pef_get_status(struct ipmi_intf * intf)
+{	/*
+	// report the PEF status
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_cfgparm_selector psel;
+	char tbuf[40];
+	uint32_t timei;
+	time_t ts;
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_LAST_PROCESSED_EVT_ID;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "Last S/W processed ID");
+	if (!rsp) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"Last S/W processed ID");
+		return;
+	}
+	memcpy(&timei, rsp->data, sizeof(timei));
+#if WORDS_BIGENDIAN
+	timei = BSWAP_32(timei);
+#endif
+	ts = (time_t)timei;
+
+	strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", gmtime(&ts));
+
+	ipmi_pef_print_str("Last SEL addition", tbuf);
+	ipmi_pef_print_2xd("Last SEL record ID", rsp->data[5], rsp->data[4]);
+	ipmi_pef_print_2xd("Last S/W processed ID", rsp->data[7], rsp->data[6]);
+	ipmi_pef_print_2xd("Last BMC processed ID", rsp->data[9], rsp->data[8]);
+
+	memset(&psel, 0, sizeof(psel));
+	psel.id = PEF_CFGPARM_ID_PEF_CONTROL;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CONFIG_PARMS;
+	req.msg.data = (uint8_t *)&psel;
+	req.msg.data_len = sizeof(psel);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "PEF control");
+	if (!rsp) {
+		lprintf(LOG_ERR, " **Error retrieving %s",
+			"PEF control");
+		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
+ipmi_pef_get_info(struct ipmi_intf * intf)
+{	/*
+	// report PEF capabilities + System GUID
+	*/
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	struct pef_capabilities * pcap;
+	struct pef_cfgparm_selector psel;
+	struct pef_cfgparm_policy_table_entry * ptbl = NULL;
+	uint8_t * uid;
+	uint8_t actions, tbl_size;
+
+	tbl_size = ipmi_pef_get_policy_table(intf, &ptbl);
+	if (!ptbl) {
+		free(ptbl);
+		ptbl = NULL;
+	}
+
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CAPABILITIES;
+	rsp = ipmi_pef_msg_exchange(intf, &req, "PEF capabilities");
+	if (!rsp)
+		return;
+	pcap = (struct pef_capabilities *)rsp->data;
+
+	ipmi_pef_print_1xd("Version", pcap->version);
+	ipmi_pef_print_dec("PEF table size", pcap->tblsize);
+	ipmi_pef_print_dec("Alert policy table size", tbl_size);
+	actions = pcap->actions;
+
+	memset(&psel, 0, sizeof(psel));
+	psel.id = PEF_CFGPARM_ID_SYSTEM_GUID;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_SE;
+	req.msg.cmd = IPMI_CMD_GET_PEF_CONFIG_PARMS;
+	req.msg.data = (uint8_t *)&psel;
+	req.msg.data_len = sizeof(psel);
+	rsp = ipmi_pef_msg_exchange(intf, &req, "System GUID");
+	uid = NULL;
+	if (rsp && (rsp->data[1] & PEF_SYSTEM_GUID_USED_IN_PET))
+		uid = &rsp->data[2];
+	else {
+		memset(&req, 0, sizeof(req));
+		req.msg.netfn = IPMI_NETFN_APP;
+		req.msg.cmd = IPMI_CMD_GET_SYSTEM_GUID;
+		rsp = ipmi_pef_msg_exchange(intf, &req, "System GUID");
+		if (rsp)
+			uid = &rsp->data[0];
+	}
+	if (uid) {		/* got GUID? */
+		if (verbose)
+			printf(pef_fld_fmts[F_UID][0], KYWD_LENGTH, "System GUID",
+					uid[0], uid[1], uid[2], uid[3], uid[4], uid[5], uid[6], uid[7],
+					uid[8], uid[9], uid[10],uid[11],uid[12],uid[13],uid[14],uid[15]);
+		else
+			printf(pef_fld_fmts[F_UID][1],
+					uid[0], uid[1], uid[2], uid[3], uid[4], uid[5], uid[6], uid[7],
+					uid[8], uid[9], uid[10],uid[11],uid[12],uid[13],uid[14],uid[15]);
+	}
+	ipmi_pef_print_flags(&pef_b2s_actions, P_SUPP, actions);
+}
+
+int ipmi_pef_main(struct ipmi_intf * intf, int argc, char ** argv)
+{	/*
+	// PEF subcommand handling
+	*/
+	int help = 0;
+    int rc = 0;
+
+	if (!argc || !strncmp(argv[0], "info", 4))
+		ipmi_pef_get_info(intf);
+	else if (!strncmp(argv[0], "help", 4))
+		help = 1;
+	else if (!strncmp(argv[0], "status", 6))
+		ipmi_pef_get_status(intf);
+	else if (!strncmp(argv[0], "policy", 6))
+		ipmi_pef_list_policies(intf);
+	else if (!strncmp(argv[0], "list", 4))
+		ipmi_pef_list_entries(intf);
+	else {
+		help = 1;
+        rc   = -1;
+		lprintf(LOG_ERR, "Invalid PEF command: '%s'\n", argv[0]);
+	}
+
+	if (help)
+		lprintf(LOG_NOTICE, "PEF commands: info status policy list");
+	else if (!verbose)
+		printf("\n");
+
+	return rc;
+}