diff options
Diffstat (limited to 'lib/ipmi_lanp6.c')
| -rw-r--r-- | lib/ipmi_lanp6.c | 1240 |
1 files changed, 1240 insertions, 0 deletions
diff --git a/lib/ipmi_lanp6.c b/lib/ipmi_lanp6.c new file mode 100644 index 0000000..bbffb89 --- /dev/null +++ b/lib/ipmi_lanp6.c @@ -0,0 +1,1240 @@ +/* + * 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; + + case IPMI_LANP_IP6_DHCP6_CFG: + fprintf(file, "%s %d:\n", pname, set); + + fprintf(file, + " SOL_MAX_DELAY: %d\n" + " SOL_TIMEOUT: %d\n" + " SOL_MAX_RT: %d\n" + " REQ_TIMEOUT: %d\n" + " REQ_MAX_RT: %d\n" + " REQ_MAX_RC: %d\n" + " CNF_MAX_DELAY: %d\n" + " CNF_TIMEOUT: %d\n" + " CNF_MAX_RT: %d\n" + " CNF_MAX_RD: %d\n" + " REN_TIMEOUT: %d\n" + " REN_MAX_RT: %d\n" + " REB_TIMEOUT: %d\n" + " REB_MAX_RT: %d\n" + " INF_MAX_DELAY: %d\n" + " INF_TIMEOUT: %d\n" + " INF_MAX_RT: %d\n" + " REL_TIMEOUT: %d\n" + " REL_MAX_RC: %d\n" + " DEC_TIMEOUT: %d\n" + " DEC_MAX_RC: %d\n" + " HOP_COUNT_LIMIT: %d\n", + data[2], data[3], data[4], data[5], + data[6], data[7], data[8], data[9], + data[10], data[11], data[12], data[13], + data[14], data[15], data[16], data[17], + data[20], data[21], data[22], data[23], + data[24], data[25]); + break; + + case IPMI_LANP_IP6_ROUTER_CFG: + fprintf(file, "%s:\n" + " Enable static router address: %s\n" + " Enable dynamic router address: %s\n", + pname, + (data[0] & 1) ? "yes" : "no", + (data[0] & 2) ? "yes" : "no"); + break; + + case IPMI_LANP_IP6_STATIC_RTR1_ADDR: + case IPMI_LANP_IP6_DYNAMIC_RTR_ADDR: + if (p->specific == IPMI_LANP_IP6_STATIC_RTR1_ADDR) { + pname = "IPv6 Static Router"; + } else { + pname = "IPv6 Dynamic Router"; + } + + fprintf(file, "%s %d:\n" + " Address: %s\n" + " MAC: %s\n" + " Prefix: %s/%d\n", + pname, set, + inet_ntop(AF_INET6, &data[1], addr, sizeof(addr)), + mac2str(&data[18]), + inet_ntop(AF_INET6, &data[27], pfx, sizeof(pfx)), data[25]); + break; + + case IPMI_LANP_IP6_NDSLAAC_CFG: + fprintf(file, "%s %d:\n" + " MAX_RTR_SOLICITATION_DELAY: %d\n" + " RTR_SOLICITATION_INTERVAL: %d\n" + " MAX_RTR_SOLICITATIONS: %d\n" + " DupAddrDetectTransmits: %d\n" + " MAX_MULTICAST_SOLICIT: %d\n" + " MAX_UNICAST_SOLICIT: %d\n" + " MAX_ANYCAST_DELAY_TIME: %d\n" + " MAX_NEIGHBOR_ADVERTISEMENT: %d\n" + " REACHABLE_TIME: %d\n" + " RETRANS_TIMER: %d\n" + " DELAY_FIRST_PROBE_TIME: %d\n" + " MAX_RANDOM_FACTOR: %d\n" + " MIN_RANDOM_FACTOR: %d\n", + pname, set, + data[2], data[3], data[4], data[5], + data[6], data[7], data[8], data[9], + data[10], data[11], data[12], data[13], + data[14]); + break; + + default: + fprintf(file, "%s: %d\n", pname, data[0]); + } + + return 0; +} + +static int +lanp_ip6_cfgp(void *priv, const struct ipmi_cfgp *p, + const struct ipmi_cfgp_action *action, unsigned char *data) +{ + switch (action->type) { + case CFGP_PARSE: + return lanp_parse_cfgp(p, action->set, action->block, + action->argc, action->argv, data); + + case CFGP_GET: + return lanp_get_cfgp(priv, p, action->set, action->block, + data, action->quiet); + + case CFGP_SET: + return lanp_set_cfgp(priv, p, data); + + case CFGP_SAVE: + return lanp_save_cfgp(p, data, action->file); + + case CFGP_PRINT: + return lanp_print_cfgp(p, action->set, action->block, + data, action->file); + + default: + return -1; + } + + return 0; +} + +static void lanp_print_usage(int cmd) +{ + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_HELP) { + printf(" help [command]\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_SAVE) { + printf(" save <channel> [<parameter> [<set_sel> [<block_sel>]]]\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_SET) { + printf(" set <channel> [nolock] <parameter> [<set_sel> [<block_sel>]] <values...>\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_PRINT) { + printf(" print <channel> [<parameter> [<set_sel> [<block_sel>]]]\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_LOCK) { + printf(" lock <channel>\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_COMMIT) { + printf(" commit <channel>\n"); + } + if (cmd == LANP_CMD_ANY || cmd == LANP_CMD_DISCARD) { + printf(" discard <channel>\n"); + } + if (cmd == LANP_CMD_SAVE + || cmd == LANP_CMD_PRINT + || cmd == LANP_CMD_SET) { + printf("\n available parameters:\n"); + /* 'save' shall use 'write' filter, since it outputs a block + * of 'set's */ + ipmi_cfgp_usage(lan_cfgp, + sizeof(lan_cfgp)/sizeof(lan_cfgp[0]), + cmd != LANP_CMD_PRINT); + } +} + +static int +lanp_lock(struct ipmi_lanp_priv *lp) +{ + unsigned char byte = 1; + + return ipmi_set_lanp(lp, 0, &byte); +} + +static int +lanp_discard(struct ipmi_lanp_priv *lp) +{ + unsigned char byte = 0; + + return ipmi_set_lanp(lp, 0, &byte); +} + +static int +lanp_commit(struct ipmi_lanp_priv *lp) +{ + unsigned char byte = 2; + int ret; + + ret = ipmi_set_lanp(lp, 0, &byte); + if (ret == 0) { + ret = lanp_discard(lp); + } + + return ret; +} + +int +ipmi_lan6_main(struct ipmi_intf *intf, int argc, char **argv) +{ + struct ipmi_cfgp_ctx ctx; + struct ipmi_cfgp_sel sel; + struct ipmi_lanp_priv lp; + int cmd; + int chan; + int nolock = 0; + int ret; + + if (argc == 0) { + lanp_print_usage(LANP_CMD_ANY); + return 0; + } + + cmd = str2val(argv[0], ip6_command_vals); + if (cmd == LANP_CMD_ANY) { + lanp_print_usage(cmd); + return -1; + } + + if (cmd == LANP_CMD_HELP) { + if (argc == 1) { + cmd = LANP_CMD_ANY; + } else { + cmd = str2val(argv[1], ip6_command_vals); + } + + lanp_print_usage(cmd); + return 0; + } + + /* + * the rest commands expect channel number + * with the exception of 'get' and 'print' + */ + if (argc == 1) { + if (cmd == LANP_CMD_SAVE || cmd == LANP_CMD_PRINT) { + chan = find_lan_channel(intf, 1); + if (chan == 0) { + lprintf(LOG_ERR, "No LAN channel found"); + return -1; + } + } else { + lanp_print_usage(cmd); + return -1; + } + + argc -= 1; + argv += 1; + } else { + if (str2int(argv[1], &chan) != 0) { + lprintf(LOG_ERR, "Invalid channel: %s", argv[1]); + return -1; + } + + argc -= 2; + argv += 2; + + if (cmd == LANP_CMD_SET) { + if (argc && !strcasecmp(argv[0], "nolock")) { + nolock = 1; + + argc -= 1; + argv += 1; + } + } + + } + + lp.intf = intf; + lp.channel = chan; + + /* + * lock/commit/discard commands do not require parsing + * of parameter selection + */ + + switch (cmd) { + case LANP_CMD_LOCK: + lprintf(LOG_NOTICE, "Lock parameter(s)..."); + return lanp_lock(&lp); + + case LANP_CMD_COMMIT: + lprintf(LOG_NOTICE, "Commit parameter(s)..."); + return lanp_commit(&lp); + + case LANP_CMD_DISCARD: + lprintf(LOG_NOTICE, "Discard parameter(s)..."); + return lanp_discard(&lp); + } + + /* + * initialize configuration context and parse parameter selection + */ + + ipmi_cfgp_init(&ctx, lan_cfgp, + sizeof(lan_cfgp)/sizeof(lan_cfgp[0]), "lan6 set nolock", + lanp_ip6_cfgp, &lp); + + ret = ipmi_cfgp_parse_sel(&ctx, argc, (const char **)argv, &sel); + if (ret == -1) { + lanp_print_usage(cmd); + ipmi_cfgp_uninit(&ctx); + return -1; + } + + argc -= ret; + argv += ret; + + /* + * handle the rest commands + */ + + switch (cmd) { + case LANP_CMD_SAVE: + case LANP_CMD_PRINT: + lprintf(LOG_NOTICE, "Getting parameter(s)..."); + + ret = ipmi_cfgp_get(&ctx, &sel); + if (ret != 0) { + break; + } + + if (cmd == LANP_CMD_SAVE) { + static char cmd[20]; + FILE *out = stdout; + snprintf(cmd, sizeof(cmd) - 1, "lan6 set %d nolock", + lp.channel); + cmd[sizeof(cmd) - 1] = '\0'; + ctx.cmdname = cmd; + fprintf(out, "lan6 lock %d\n", lp.channel); + ret = ipmi_cfgp_save(&ctx, &sel, out); + fprintf(out, "lan6 commit %d\nlan6 discard %d\nexit\n", + lp.channel, lp.channel); + } else { + ret = ipmi_cfgp_print(&ctx, &sel, stdout); + } + break; + + case LANP_CMD_SET: + ret = ipmi_cfgp_parse_data(&ctx, &sel, argc, + (const char **)argv); + if (ret != 0) { + break; + } + + lprintf(LOG_NOTICE, "Setting parameter(s)..."); + + if (!nolock) { + ret = lanp_lock(&lp); + if (ret != 0) { + break; + } + } + + ret = ipmi_cfgp_set(&ctx, &sel); + if (!nolock) { + if (ret == 0) { + ret = lanp_commit(&lp); + } else { + lanp_discard(&lp); + } + } + break; + } + + /* + * free allocated memory + */ + ipmi_cfgp_uninit(&ctx); + + return ret; +} |