/*

 * 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.

 */

#define _BSD_SOURCE

#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_strings.h>

#include <ipmitool/ipmi_channel.h>

#include <ipmitool/ipmi_event.h>

#include <ipmitool/ipmi_sdr.h>

static void

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;

	memset(&req, 0, sizeof(req));

	memset(rqdata, 0, 8);

	req.msg.netfn = IPMI_NETFN_SE;

	req.msg.cmd = 0x02;

	req.msg.data = rqdata;

	chmed = ipmi_current_channel_medium(intf);

	if (chmed == IPMI_CHANNEL_MEDIUM_SYSTEM) {

		/* system interface, need extra generator ID */

		req.msg.data_len = 8;

		rqdata[0] = 0x41;   // As per Fig. 29-2 and Table 5-4

		memcpy(rqdata+1, emsg, sizeof(struct platform_event_msg));

	}

	else {

		req.msg.data_len = 7;

		memcpy(rqdata, emsg, sizeof(struct platform_event_msg));

	}

	ipmi_event_msg_print(intf, emsg);

	rsp = intf->sendrecv(intf, &req;;

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Platform Event Message command failed");

		return -1;

	}

	else if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Platform Event Message command failed: %s",

			val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	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(struct ipmi_intf *intf, uint8_t sensor_type, uint8_t event_type, char *desc)

{

	const struct ipmi_event_sensor_types *evt;

	if (desc == NULL || sensor_type == 0  || event_type == 0) {

		return 0x00;

	}

	for (evt = ipmi_get_first_event_sensor_type(intf, sensor_type, event_type);

			evt != NULL; evt = ipmi_get_next_event_sensor_type(evt)) {

		if (evt->desc != NULL &&

			strncasecmp(desc, evt->desc, __maxlen(desc, evt->desc)) == 0) {

			return evt->offset;

		}

	}

	lprintf(LOG_WARN, "Unable to find matching event offset for '%s'", desc);

	return -1;

}

static void

print_sensor_states(struct ipmi_intf *intf, uint8_t sensor_type, uint8_t event_type)

{

	ipmi_sdr_print_discrete_state_mini(intf,

			"Sensor States: \n  ", "\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;

	uint8_t target, lun, channel;

	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:

	case SDR_RECORD_TYPE_COMPACT_SENSOR:

		emsg.sensor_type   = sdr->record.common->sensor.type;

		emsg.sensor_num    = sdr->record.common->keys.sensor_num;

		emsg.event_type    = sdr->record.common->event_type;

		target    = sdr->record.common->keys.owner_id;

		lun    = sdr->record.common->keys.lun;

		channel = sdr->record.common->keys.channel;

		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");

			return -1;

		}

		rsp = ipmi_sdr_get_sensor_thresholds(intf, emsg.sensor_num,

							target, lun, channel);

		if (rsp == NULL) {

			lprintf(LOG_ERR,

					"Command Get Sensor Thresholds failed: invalid response.");

			return (-1);

		} else if (rsp->ccode != 0) {

			lprintf(LOG_ERR, "Command Get Sensor Thresholds failed: %s",

					val2str(rsp->ccode, completion_code_vals));

			return (-1);

		}

		/* threshold reading */

		emsg.event_data[2] = rsp->data[(emsg.event_data[0] / 2) + 1];

		rsp = ipmi_sdr_get_sensor_hysteresis(intf, emsg.sensor_num,

							target, lun, channel);

		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(intf, 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(intf,

				emsg.sensor_type, emsg.event_type, 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(intf, emsg.sensor_type, emsg.event_type);

			return 0;

		}

		off = ipmi_event_find_offset(intf,

			emsg.sensor_type, emsg.event_type, 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(intf, emsg.sensor_type, emsg.event_type);

			return 0;

		}

		off = ipmi_event_find_offset(intf,

			emsg.sensor_type, emsg.event_type, 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)

{

	FILE * fp;

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	struct sel_event_record sel_event;

	uint8_t rqdata[8];

	char buf[1024];

	char * ptr, * tok;

	int i, j;

	uint8_t chmed;

	int rc = 0;

	if (file == NULL)

		return -1;

	memset(rqdata, 0, 8);

	/* setup Platform Event Message command */

	memset(&req, 0, sizeof(req));

	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 */

		rqdata[0] = 0x41;   // As per Fig. 29-2 and Table 5-4

		req.msg.data_len = 8;

	}

	fp = ipmi_open_file_read(file);

	if (fp == NULL)

		return -1;

	while (feof(fp) == 0) {

		if (fgets(buf, 1024, fp) == NULL)

			continue;

		/* clip off optional comment tail indicated by # */

		ptr = strchr(buf, '#');

		if (ptr)

			*ptr = '\0';

		else

			ptr = buf + strlen(buf);

		/* clip off trailing and leading whitespace */

		ptr--;

		while (isspace((int)*ptr) && ptr >= buf)

			*ptr-- = '\0';

		ptr = buf;

		while (isspace((int)*ptr))

			ptr++;

		if (strlen(ptr) == 0)

			continue;

		/* parse the event, 7 bytes with optional comment */

		/* 0x00 0x00 0x00 0x00 0x00 0x00 0x00 # event */

		i = 0;

		tok = strtok(ptr, " ");

		while (tok) {

			if (i == 7)

				break;

			j = i++;

			if (chmed == IPMI_CHANNEL_MEDIUM_SYSTEM)

				j++;

			rqdata[j] = (uint8_t)strtol(tok, NULL, 0);

			tok = strtok(NULL, " ");

		}

		if (i < 7) {

			lprintf(LOG_ERR, "Invalid Event: %s",

			       buf2str(rqdata, sizeof(rqdata)));

			continue;

		}

		memset(&sel_event, 0, sizeof(struct sel_event_record));

		sel_event.record_id = 0;

		sel_event.sel_type.standard_type.gen_id = 2;

		j = (chmed == IPMI_CHANNEL_MEDIUM_SYSTEM) ? 1 : 0;

		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(intf, &sel_event);

		rsp = intf->sendrecv(intf, &req;;

		if (rsp == NULL) {

			lprintf(LOG_ERR, "Platform Event Message command failed");

			rc = -1;

		}

		else if (rsp->ccode > 0) {

			lprintf(LOG_ERR, "Platform Event Message command failed: %s",

				val2str(rsp->ccode, completion_code_vals));

			rc = -1;

		}

	}

	fclose(fp);

	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 string 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)

{

	int rc = 0;

	if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {

		ipmi_event_usage();

		return 0;

	}

	if (strncmp(argv[0], "file", 4) == 0) {

		if (argc < 2) {

			ipmi_event_usage();

			return 0;

		}

		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;

}