/*

 * Copyright (c) 2016 Pentair Technical Products. All right 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 Pentair Technical Products 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL

 * PENTAIR TECHNICAL SOLUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#include <ipmitool/helper.h>

#include <ipmitool/ipmi_cc.h>

#include <ipmitool/ipmi_cfgp.h>

#include <ipmitool/ipmi_lanp.h>

#include <ipmitool/ipmi_lanp6.h>

#include <ipmitool/log.h>

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <arpa/inet.h>

/*

 * LAN6 command values.

 */

enum {

	LANP_CMD_SAVE,

	LANP_CMD_SET,

	LANP_CMD_PRINT,

	LANP_CMD_LOCK,

	LANP_CMD_COMMIT,

	LANP_CMD_DISCARD,

	LANP_CMD_HELP,

	LANP_CMD_ANY = 0xFF

};

/*

 * Generic LAN configuration parameters.

 */

const struct ipmi_lanp generic_lanp6[] = {

	{ 0,	"Set In Progress", 1 },

	{ 50,	"IPv6/IPv4 Support", 1 },

	{ 51,	"IPv6/IPv4 Addressing Enables", 1 },

	{ 52,	"IPv6 Header Traffic Class", 1 },

	{ 53,	"IPv6 Header Static Hop Limit", 1 },

	{ 54,	"IPv6 Header Flow Label", 3 },

	{ 55,	"IPv6 Status", 3 },

	{ 56,	"IPv6 Static Address", 20 },

	{ 57,	"IPv6 DHCPv6 Static DUID Storage Length", 1 },

	{ 58,	"IPv6 DHCPv6 Static DUID", 18 },

	{ 59,	"IPv6 Dynamic Address", 20 },

	{ 60,	"IPv6 DHCPv6 Dynamic DUID Storage Length", 1 },

	{ 61,	"IPv6 DHCPv6 Dynamic DUID", 18 },

	{ 62,	"IPv6 DHCPv6 Timing Configuration Support", 1 },

	{ 63,	"IPv6 DHCPv6 Timing Configuration", 18 },

	{ 64,	"IPv6 Router Address Configuration Control", 1 },

	{ 65,	"IPv6 Static Router 1 IP Address", 16 },

	{ 66,	"IPv6 Static Router 1 MAC Address", 6 },

	{ 67,	"IPv6 Static Router 1 Prefix Length", 1 },

	{ 68,	"IPv6 Static Router 1 Prefix Value", 16 },

	{ 69,	"IPv6 Static Router 2 IP Address", 16 },

	{ 70,	"IPv6 Static Router 2 MAC Address", 6 },

	{ 71,	"IPv6 Static Router 2 Prefix Length", 1 },

	{ 72,	"IPv6 Static Router 2 Prefix Value", 16 },

	{ 73,	"IPv6 Number of Dynamic Router Info Sets", 1 },

	{ 74,	"IPv6 Dynamic Router Info IP Address", 17 },

	{ 75,	"IPv6 Dynamic Router Info MAC Address", 7 },

	{ 76,	"IPv6 Dynamic Router Info Prefix Length", 2 },

	{ 77,	"IPv6 Dynamic Router Info Prefix Value", 17 },

	{ 78,	"IPv6 Dynamic Router Received Hop Limit", 1 },

	{ 79,	"IPv6 ND/SLAAC Timing Configuration Support", 1 },

	{ 80,	"IPv6 ND/SLAAC Timing Configuration", 18 },

	{ 0,	NULL, 0 }

};

/*

 * Set/Get LAN Configuration Parameters

 * command-specific completion codes.

 */

const struct valstr lanp_cc_vals[] = {

	{ 0x80, "Parameter not supported" },

	{ 0x81, "Set already in progress" },

	{ 0x82, "Parameter is read-only" },

	{ 0x83, "Write-only parameter" },

	{ 0x00, NULL }

};

/*

 * IPv6/IPv4 Addressing Enables.

 */

const struct valstr ip6_enable_vals[] = {

	{ 0, "ipv4" },

	{ 1, "ipv6" },

	{ 2, "both" },

	{ 0xFF, NULL }

};

/*

 * Enable/Disable a static address.

 */

const struct valstr ip6_addr_enable_vals[] = {

	{ 0x00, "disable" },

	{ 0x80, "enable" },

	{ 0xFF, NULL }

};

/*

 * IPv6 address source values.

 */

const struct valstr ip6_addr_sources[] = {

	{ 0, "static" },

	{ 1, "SLAAC" },

	{ 2, "DHCPv6" },

	{ 0, NULL }

};

/*

 * IPv6 address status values.

 */

const struct valstr ip6_addr_statuses[] = {

	{ 0, "active" },

	{ 1, "disabled" },

	{ 2, "pending" },

	{ 3, "failed" },

	{ 4, "deprecated" },

	{ 5, "invalid" },

	{ 0xFF, NULL }

};

/*

 * DHCPv6 DUID type values.

 */

const struct valstr ip6_duid_types[] = {

	{ 0, "unknown" },

	{ 1, "DUID-LLT" },

	{ 2, "DUID-EN" },

	{ 3, "DUID-LL" },

	{ 0xFF, NULL }

};

/*

 * Timing Configuration support values.

 */

const struct valstr ip6_cfg_sup_vals[] = {

	{ 0, "not supported" },

	{ 1, "global" },

	{ 2, "per interface" },

	{ 0xFF, NULL }

};

/*

 * Router Address Configuration Control values.

 */

const struct valstr ip6_rtr_configs[] = {

	{ 1, "static" },

	{ 2, "dynamic" },

	{ 3, "both" },

	{ 0xFF, NULL }

};

const struct valstr ip6_command_vals[] = {

	{ LANP_CMD_SET,		"set" },

	{ LANP_CMD_SAVE,	"save" },

	{ LANP_CMD_PRINT,	"print" },

	{ LANP_CMD_LOCK,	"lock" },

	{ LANP_CMD_COMMIT,	"commit" },

	{ LANP_CMD_DISCARD,	"discard" },

	{ LANP_CMD_HELP,	"help" },

	{ LANP_CMD_ANY,		NULL }

};

static const struct ipmi_cfgp lan_cfgp[] = {

	{ .name = "support", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_SUPPORT

	},

	{ .name = "enables", .format = "{ipv4|ipv6|both}", .size = 1,

		.access = CFGP_RDWR,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_ENABLES

	},

	{ .name = "traffic_class", .format = "<value>", .size = 1,

		.access = CFGP_RDWR,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_TRAFFIC_CLASS

	},

	{ .name = "static_hops", .format = "<value>", .size = 1,

		.access = CFGP_RDWR,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATIC_HOPS

	},

	{ .name = "flow_label", .format = "<value>", .size = 3,

		.access = CFGP_RDWR,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_FLOW_LABEL

	},

	{ .name = "status", .format = NULL, .size = 3,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATUS

	},

	{ .name = "static_addr",

		.format = "{enable|disable} <addr> <pfx_len>", .size = 20,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATIC_ADDR

	},

	{ .name = "static_duid_stg", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATIC_DUID_STG

	},

	{ .name = "static_duid", .format = "<data>", .size = 18,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 0, .has_blocks = 1, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATIC_DUID

	},

	{ .name = "dynamic_addr", .format = NULL, .size = 20,

		.access = CFGP_RDONLY,

		.is_set = 1, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DYNAMIC_ADDR

	},

	{ .name = "dynamic_duid_stg", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DYNAMIC_DUID_STG

	},

	{ .name = "dynamic_duid", .format = "<data>", .size = 18,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 0, .has_blocks = 1, .first_block = 0,

		.specific = IPMI_LANP_IP6_DYNAMIC_DUID

	},

	{ .name = "dhcp6_cfg_sup", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DHCP6_CFG_SUP

	},

	{ .name = "dhcp6_cfg", .format = "<data> <data>", .size = 36,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DHCP6_CFG

	},

	{ .name = "rtr_cfg", .format = "{static|dynamic|both}", .size = 1,

		.access = CFGP_RDWR,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_ROUTER_CFG

	},

	{ .name = "static_rtr",

		.format = "<addr> <macaddr> <prefix> <prefix_len>", .size = 43,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 1, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_STATIC_RTR1_ADDR

	},

	{ .name = "num_dynamic_rtrs", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_NUM_DYNAMIC_RTRS

	},

	{ .name = "dynamic_rtr", .format = NULL, .size = 43,

		.access = CFGP_RDONLY,

		.is_set = 1, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DYNAMIC_RTR_ADDR

	},

	{ .name = "dynamic_hops", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_DYNAMIC_HOPS

	},

	{ .name = "ndslaac_cfg_sup", .format = NULL, .size = 1,

		.access = CFGP_RDONLY,

		.is_set = 0, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_NDSLAAC_CFG_SUP

	},

	{ .name = "ndslaac_cfg", .format = "<data>", .size = 18,

		.access = CFGP_RDWR,

		.is_set = 1, .first_set = 0, .has_blocks = 0, .first_block = 0,

		.specific = IPMI_LANP_IP6_NDSLAAC_CFG

	}

};

/*

 * Lookup LAN parameter descriptor by parameter selector.

 */

const struct ipmi_lanp *

lookup_lanp(int param)

{

	const struct ipmi_lanp *p = generic_lanp6;

	while (p->name) {

		if (p->selector == param) {

			return p;

		}

		p++;

	}

	return NULL;

}

/*

 * Print request error.

 */

static int

ipmi_lanp_err(const struct ipmi_rs *rsp, const struct ipmi_lanp *p,

		const char *action, int quiet)

{

	const char *reason;

	char cc_msg[10];

	int log_level = LOG_ERR;

	int err;

	if (rsp == NULL) {

		reason = "No response";

		err = -1;

	} else {

		err = rsp->ccode;

		if (quiet == 1

			&& (rsp->ccode == 0x80

			|| rsp->ccode == IPMI_CC_PARAM_OUT_OF_RANGE

			|| rsp->ccode == IPMI_CC_INV_DATA_FIELD_IN_REQ)) {

			/* be quiet */

			return err;

		}

		if (rsp->ccode >= 0xC0) {

			/* browse for generic completion codes */

			reason = val2str(rsp->ccode, completion_code_vals);

		} else {

			/* browse for command-specific completion codes first */

			reason = val2str(rsp->ccode, lanp_cc_vals);

		}

		if (reason == NULL) {

			/* print completion code value */

			snprintf(cc_msg, sizeof(cc_msg), "CC=%02x", rsp->ccode);

			reason = cc_msg;

		}

		if (rsp->ccode == IPMI_CC_OK) {

			log_level = LOG_DEBUG;

		}

	}

	lprintf(log_level, "Failed to %s %s: %s", action, p->name, reason);

	return err;

}

/*

 * Get dynamic OEM LAN configuration parameter from BMC.

 * Dynamic in this context is when the base for OEM LAN parameters

 * is not known apriori.

 */

int

ipmi_get_dynamic_oem_lanp(void *priv, const struct ipmi_lanp *param,

		int oem_base, int set_selector, int block_selector,

		void *data, int quiet)

{

	struct ipmi_lanp_priv *lp = priv;

	struct ipmi_rs *rsp;

	struct ipmi_rq req;

	uint8_t req_data[4];

	int length;

	if (!priv || !param || !data) {

		return -1;

	}

	req_data[0] = lp->channel;

	req_data[1] = param->selector + oem_base;

	req_data[2] = set_selector;

	req_data[3] = block_selector;

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

	req.msg.netfn    = IPMI_NETFN_TRANSPORT;

	req.msg.cmd      = 2;

	req.msg.data     = req_data;

	req.msg.data_len = 4;

	lprintf(LOG_INFO, "Getting parameter '%s' set %d block %d",

		param->name, set_selector, block_selector);

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

	if (rsp == NULL || rsp->ccode) {

		return ipmi_lanp_err(rsp, param, "get", quiet);

	}

	memset(data, 0, param->size);

	if (rsp->data_len - 1 < param->size) {

		length = rsp->data_len - 1;

	} else {

		length = param->size;

	}

	if (length) {

		memcpy(data, rsp->data + 1, length);

	}

	return 0;

}

/*

 * Get generic LAN configuration parameter.

 */

int

ipmi_get_lanp(void *priv, int param_selector, int set_selector,

		int block_selector, void *data, int quiet)

{

	return ipmi_get_dynamic_oem_lanp(priv, lookup_lanp(param_selector), 0,

			set_selector, block_selector, data, quiet);

}

/*

 * Set dynamic OEM LAN configuration parameter to BMC.

 * Dynamic in this context is when the base for OEM LAN parameters

 * is not known apriori.

 */

int

ipmi_set_dynamic_oem_lanp(void *priv, const struct ipmi_lanp *param,

		int base, const void *data)

{

	struct ipmi_lanp_priv *lp = priv;

	struct ipmi_rs *rsp;

	struct ipmi_rq req;

	uint8_t req_data[32];

	if (!priv || !param || !data) {

		return -1;

	}

	/* fill the first two bytes */

	req_data[0] = lp->channel;

	req_data[1] = param->selector + base;

	/* fill the rest data */

	memcpy(&req_data[2], data, param->size);

	/* fill request */

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

	req.msg.netfn    = IPMI_NETFN_TRANSPORT;

	req.msg.cmd      = 1;

	req.msg.data     = req_data;

	req.msg.data_len = param->size + 2;

	lprintf(LOG_INFO, "Setting parameter '%s'", param->name);

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

	if (rsp == NULL || rsp->ccode) {

		return ipmi_lanp_err(rsp, param, "set", 0);

	}

	return 0;

}

/*

 * Set generic LAN configuration parameter.

 */

int

ipmi_set_lanp(void *priv, int param_selector, const void *data)

{

	return ipmi_set_dynamic_oem_lanp(priv, lookup_lanp(param_selector),

		0, data);

}

static int

lanp_parse_cfgp(const struct ipmi_cfgp *p, int set, int block,

		int argc, const char *argv[], unsigned char *data)

{

	unsigned int v;

	if (argc == 0) {

		return -1;

	}

	switch(p->specific) {

	case IPMI_LANP_IP6_ENABLES:

		data[0] = str2val(argv[0], ip6_enable_vals);

		if (data[0] == 0xFF) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	case IPMI_LANP_IP6_FLOW_LABEL:

		if (str2uint(argv[0], &v)) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		data[0] = (v >> 16) & 0x0F;

		data[1] = (v >> 8) & 0xFF;

		data[2] = v & 0xFF;

		break;

	case IPMI_LANP_IP6_STATUS:

		if (argc < 3) {

			return -1;

		}

		if (str2uchar(argv[0], &data[0])

				|| str2uchar(argv[1], &data[1])

				|| str2uchar(argv[2], &data[2])) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	case IPMI_LANP_IP6_STATIC_ADDR:

	case IPMI_LANP_IP6_DYNAMIC_ADDR:

		if (argc < 3) {

			return -1;

		}

		data[0] = set;

		if (p->specific == IPMI_LANP_IP6_STATIC_ADDR) {

			data[1] = str2val(argv[0], ip6_addr_enable_vals);

		} else {

			data[1] = str2val(argv[0], ip6_addr_sources);

		}

		if (data[1] == 0xFF) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		if (inet_pton(AF_INET6, argv[1], &data[2]) != 1) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		if (str2uchar(argv[2], &data[18])) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		if (argc >= 4) {

			data[19] = str2val(argv[3], ip6_addr_statuses);

		}

		break;

	case IPMI_LANP_IP6_STATIC_DUID:

	case IPMI_LANP_IP6_DYNAMIC_DUID:

	case IPMI_LANP_IP6_NDSLAAC_CFG:

		data[0] = set;

		data[1] = block;

		if (ipmi_parse_hex(argv[0], &data[2], 16) < 0) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	case IPMI_LANP_IP6_DHCP6_CFG:

		data[0] = set;

		data[1] = 0;

		data[18] = set;

		data[19] = 1;

		if (ipmi_parse_hex(argv[0], &data[2], 16) < 0

			|| (argc > 1 &&

			    ipmi_parse_hex(argv[1], &data[20], 6) < 0)) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	case IPMI_LANP_IP6_ROUTER_CFG:

		data[0] = str2val(argv[0], ip6_rtr_configs);

		if (data[0] == 0xFF) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	case IPMI_LANP_IP6_STATIC_RTR1_ADDR:

		if (set > 2) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

	case IPMI_LANP_IP6_DYNAMIC_RTR_ADDR:

		if (argc < 4) {

			return -1;

		}

		/*

		 * Data is stored in the following way:

		 *  0: <set> <addr1>...<addr16>

		 * 17: <set> <mac1>...<mac6>

		 * 24: <set> <pfxlen>

		 * 26: <set> <pfx1>...<pfx16>

		 */

		data[0] = data[17] = data[24] = data[26] = set;

		if (inet_pton(AF_INET6, argv[0], &data[1]) != 1

				|| str2mac(argv[1], &data[18])

				|| inet_pton(AF_INET6, argv[2], &data[27]) != 1

				|| str2uchar(argv[3], &data[25])) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

		break;

	default:

		if (str2uchar(argv[0], &data[0])) {

			lprintf(LOG_ERR, "invalid value");

			return -1;

		}

	}

	return 0;

}

static int

lanp_set_cfgp(void *priv, const struct ipmi_cfgp *p, const unsigned char *data)

{

	int ret;

	int param = p->specific;

	int off = 0;

	switch(param) {

	case IPMI_LANP_IP6_DHCP6_CFG:

		ret = ipmi_set_lanp(priv, param, &data[0]);

		if (ret == 0) {

			ret = ipmi_set_lanp(priv, param, &data[18]);

		}

		break;

	case IPMI_LANP_IP6_STATIC_RTR1_ADDR:

		if (data[0] == 2) {

			param = IPMI_LANP_IP6_STATIC_RTR2_ADDR;

		}

		off = 1;

	case IPMI_LANP_IP6_DYNAMIC_RTR_ADDR:

		ret = ipmi_set_lanp(priv, param, &data[0 + off]);

		if (ret == 0) {

			ret = ipmi_set_lanp(priv, param + 1, &data[17 + off]);

		}

		if (ret == 0) {

			ret = ipmi_set_lanp(priv, param + 2, &data[24 + off]);

		}

		if (ret == 0) {

			ret = ipmi_set_lanp(priv, param + 3, &data[26 + off]);

		}

		break;

	default:

		ret = ipmi_set_lanp(priv, param, data);

	}

	return ret;

}

static int

lanp_get_cfgp(void *priv, const struct ipmi_cfgp *p,

		int set, int block,  unsigned char *data, int quiet)

{

	int ret;

	int param = p->specific;

	int off = 0;

	switch(param) {

	case IPMI_LANP_IP6_DHCP6_CFG:

		ret = ipmi_get_lanp(priv, param, set, 0, &data[0], quiet);

		if (ret == 0) {

			ret = ipmi_get_lanp(priv, param, set,

				1, &data[18], quiet);

		}

		break;

	case IPMI_LANP_IP6_STATIC_RTR1_ADDR:

		if (set > 2) {

			return -1;

		}

		if (set == 2) {

			param = IPMI_LANP_IP6_STATIC_RTR2_ADDR;

		}

		set = 0;

		off = 1;

		data[0] = data[17] = data[24] = data[26] = set;

	case IPMI_LANP_IP6_DYNAMIC_RTR_ADDR:

		ret = ipmi_get_lanp(priv, param, set, block,

			&data[0 + off], quiet);

		if (ret == 0) {

			ret = ipmi_get_lanp(priv, param + 1, set, block,

				&data[17 + off], 0);

		}

		if (ret == 0) {

			ret = ipmi_get_lanp(priv, param + 2, set, block,

				&data[24 + off], 0);

		}

		if (ret == 0) {

			ret = ipmi_get_lanp(priv, param + 3, set, block,

				&data[26 + off], 0);

		}

		break;

	default:

		ret = ipmi_get_lanp(priv, param, set, block, data, quiet);

	}

	return ret;

}

static int

lanp_save_cfgp(const struct ipmi_cfgp *p, const unsigned char *data, FILE *file)

{

	char addr[INET6_ADDRSTRLEN];

	char pfx[INET6_ADDRSTRLEN];

	const char *src;

	switch(p->specific) {

	case IPMI_LANP_IP6_ENABLES:

		fputs(val2str(data[0], ip6_enable_vals), file);

		break;

	case IPMI_LANP_IP6_FLOW_LABEL:

		fprintf(file, "0x%xd", (data[0] << 16 ) | (data[1] << 8) | data[2]);

		break;

	case IPMI_LANP_IP6_STATUS:

		fprintf(file, "%d %d %d", data[0], data[1], data[2]);

		break;

	case IPMI_LANP_IP6_STATIC_ADDR:

	case IPMI_LANP_IP6_DYNAMIC_ADDR:

		if (p->specific == IPMI_LANP_IP6_STATIC_ADDR) {

			src = val2str(data[1], ip6_addr_enable_vals);

		} else {

			src = val2str(data[1], ip6_addr_sources);

		}

		fprintf(file, "%s %s %d %s", src,

				inet_ntop(AF_INET6, &data[2], addr, sizeof(addr)),

				data[18], val2str(data[19], ip6_addr_statuses));

		break;

	case IPMI_LANP_IP6_STATIC_DUID:

	case IPMI_LANP_IP6_DYNAMIC_DUID:

	case IPMI_LANP_IP6_NDSLAAC_CFG:

		fprintf(file, "%s", buf2str(&data[2], 16));

		break;

	case IPMI_LANP_IP6_DHCP6_CFG:

		fprintf(file, "%s", buf2str(&data[2], 16));

		fprintf(file, " %s", buf2str(&data[20], 6));

		break;

	case IPMI_LANP_IP6_ROUTER_CFG:

		fputs(val2str(data[0], ip6_rtr_configs), file);

		break;

	case IPMI_LANP_IP6_STATIC_RTR1_ADDR:

	case IPMI_LANP_IP6_DYNAMIC_RTR_ADDR:

		fprintf(file, "%s %s %s %d",

				inet_ntop(AF_INET6, &data[1], addr, sizeof(addr)),

				mac2str(&data[18]),

				inet_ntop(AF_INET6, &data[27], pfx, sizeof(pfx)), data[25]);

		break;

	default:

		fprintf(file, "%d", data[0]);

	}

	return 0;

}

static int

lanp_print_cfgp(const struct ipmi_cfgp *p,

		int set, int block, const unsigned char *data, FILE *file)

{

	char addr[INET6_ADDRSTRLEN];

	char pfx[INET6_ADDRSTRLEN];

	const char *pname;

	const struct ipmi_lanp *lanp = lookup_lanp(p->specific);

	if (!lanp || !p || !file || !data || !lanp->name) {

		return -1;

	}

	pname = lanp->name;

	switch(p->specific) {

	case IPMI_LANP_IP6_SUPPORT:

		fprintf(file, "%s:\n"

				"    IPv6 only: %s\n"

				"    IPv4 and IPv6: %s\n"

				"    IPv6 Destination Addresses for LAN alerting: %s\n",

				pname,

				data[0] & 1 ? "yes" : "no",

				data[0] & 2 ? "yes" : "no",

				data[0] & 4 ? "yes" : "no");

		break;

	case IPMI_LANP_IP6_ENABLES:

		fprintf(file, "%s: %s\n",

				pname, val2str(data[0], ip6_enable_vals));

		break;

	case IPMI_LANP_IP6_FLOW_LABEL:

		fprintf(file, "%s: %d\n",

				pname, (data[0] << 16 ) | (data[1] << 8) | data[2]);

		break;

	case IPMI_LANP_IP6_STATUS:

		fprintf(file, "%s:\n"

				"    Static address max:  %d\n"

				"    Dynamic address max: %d\n"

				"    DHCPv6 support:      %s\n"

				"    SLAAC support:       %s\n",

				pname,

				data[0], data[1],

				(data[2] & 1) ? "yes" : "no",

				(data[2] & 2) ? "yes" : "no");

		break;

	case IPMI_LANP_IP6_STATIC_ADDR:

		fprintf(file, "%s %d:\n"

				"    Enabled:        %s\n"

				"    Address:        %s/%d\n"

				"    Status:         %s\n",

				pname, set,

				(data[1] & 0x80) ? "yes" : "no",

				inet_ntop(AF_INET6, &data[2], addr, sizeof(addr)),

				data[18], val2str(data[19] & 0xF, ip6_addr_statuses));

		break;

	case IPMI_LANP_IP6_DYNAMIC_ADDR:

		fprintf(file, "%s %d:\n"

				"    Source/Type:    %s\n"

				"    Address:        %s/%d\n"

				"    Status:         %s\n",

				pname, set,

				val2str(data[1] & 0xF, ip6_addr_sources),

				inet_ntop(AF_INET6, &data[2], addr, sizeof(addr)),

				data[18], val2str(data[19] & 0xF, ip6_addr_statuses));

		break;

	case IPMI_LANP_IP6_STATIC_DUID:

	case IPMI_LANP_IP6_DYNAMIC_DUID:

		if (block == 0) {

			fprintf(file, "%s %d:\n"

				"    Length:   %d\n"

				"    Type:     %s\n",

				pname, set, data[2],

				val2str((data[3] << 8) + data[4], ip6_duid_types));

		}

		fprintf(file, "    %s\n", buf2str(&data[2], 16));

		break;

	case IPMI_LANP_IP6_DHCP6_CFG_SUP:

	case IPMI_LANP_IP6_NDSLAAC_CFG_SUP:

		fprintf(file, "%s: %s\n",

				pname, val2str(data[0], ip6_cfg_sup_vals));

		break;