diff options
author | Jörg Frings-Fürst <debian@jff-webhosting.net> | 2014-07-23 15:03:00 +0200 |
---|---|---|
committer | Jörg Frings-Fürst <debian@jff-webhosting.net> | 2014-07-23 15:03:00 +0200 |
commit | b32d92e890caac903491116e9d817aa780c0323b (patch) | |
tree | 5a135c37eaa9ac94772819a28ce5beedd18e5c4a /src/plugins/open/open.c | |
parent | c3445516ecd58e97de483cf4b7fafcc1104890d7 (diff) |
Imported Upstream version 1.8.14upstream/1.8.14
Diffstat (limited to 'src/plugins/open/open.c')
-rw-r--r-- | src/plugins/open/open.c | 439 |
1 files changed, 439 insertions, 0 deletions
diff --git a/src/plugins/open/open.c b/src/plugins/open/open.c new file mode 100644 index 0000000..92b6f37 --- /dev/null +++ b/src/plugins/open/open.c @@ -0,0 +1,439 @@ +/* + * 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. + */ + +#include <stdio.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> + +#include <ipmitool/ipmi.h> +#include <ipmitool/ipmi_intf.h> +#include <ipmitool/helper.h> +#include <ipmitool/log.h> + +#if defined(HAVE_CONFIG_H) +# include <config.h> +#endif + +#if defined(HAVE_SYS_IOCCOM_H) +# include <sys/ioccom.h> +#endif + +#if defined(HAVE_OPENIPMI_H) +# if defined(HAVE_LINUX_COMPILER_H) +# include <linux/compiler.h> +# endif +# include <linux/ipmi.h> +#elif defined(HAVE_FREEBSD_IPMI_H) +/* FreeBSD OpenIPMI-compatible header */ +# include <sys/ipmi.h> +#else +# include "open.h" +#endif + +/** + * Maximum input message size for KCS/SMIC is 40 with 2 utility bytes and + * 38 bytes of data. + * Maximum input message size for BT is 42 with 4 utility bytes and + * 38 bytes of data. + */ +#define IPMI_OPENIPMI_MAX_RQ_DATA_SIZE 38 + +/** + * Maximum output message size for KCS/SMIC is 38 with 2 utility bytes, a byte + * for completion code and 35 bytes of data. + * Maximum output message size for BT is 40 with 4 utility bytes, a byte + * for completion code and 35 bytes of data. + */ +#define IPMI_OPENIPMI_MAX_RS_DATA_SIZE 35 + +extern int verbose; + +static int +ipmi_openipmi_open(struct ipmi_intf * intf) +{ + int i = 0; + + char ipmi_dev[16]; + char ipmi_devfs[16]; + char ipmi_devfs2[16]; + int devnum = 0; + + devnum = intf->devnum; + + sprintf(ipmi_dev, "/dev/ipmi%d", devnum); + sprintf(ipmi_devfs, "/dev/ipmi/%d", devnum); + sprintf(ipmi_devfs2, "/dev/ipmidev/%d", devnum); + lprintf(LOG_DEBUG, "Using ipmi device %d", devnum); + + intf->fd = open(ipmi_dev, O_RDWR); + + if (intf->fd < 0) { + intf->fd = open(ipmi_devfs, O_RDWR); + if (intf->fd < 0) { + intf->fd = open(ipmi_devfs2, O_RDWR); + } + if (intf->fd < 0) { + lperror(LOG_ERR, "Could not open device at %s or %s or %s", + ipmi_dev, ipmi_devfs , ipmi_devfs2); + return -1; + } + } + + if (ioctl(intf->fd, IPMICTL_SET_GETS_EVENTS_CMD, &i) < 0) { + lperror(LOG_ERR, "Could not enable event receiver"); + return -1; + } + + intf->opened = 1; + + /* This is never set to 0, the default is IPMI_BMC_SLAVE_ADDR */ + if (intf->my_addr != 0) { + if (intf->set_my_addr(intf, intf->my_addr) < 0) { + lperror(LOG_ERR, "Could not set IPMB address"); + return -1; + } + lprintf(LOG_DEBUG, "Set IPMB address to 0x%x", + intf->my_addr ); + } + + intf->manufacturer_id = ipmi_get_oem(intf); + return intf->fd; +} +static int +ipmi_openipmi_set_my_addr(struct ipmi_intf *intf, uint8_t addr) +{ + unsigned int a = addr; + if (ioctl(intf->fd, IPMICTL_SET_MY_ADDRESS_CMD, &a) < 0) { + lperror(LOG_ERR, "Could not set IPMB address"); + return -1; + } + intf->my_addr = addr; + return 0; +} + +static void +ipmi_openipmi_close(struct ipmi_intf * intf) +{ + if (intf->fd >= 0) { + close(intf->fd); + intf->fd = -1; + } + + intf->opened = 0; + intf->manufacturer_id = IPMI_OEM_UNKNOWN; +} + +static struct ipmi_rs * +ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req) +{ + struct ipmi_recv recv; + struct ipmi_addr addr; + struct ipmi_system_interface_addr bmc_addr = { + addr_type: IPMI_SYSTEM_INTERFACE_ADDR_TYPE, + channel: IPMI_BMC_CHANNEL, + }; + struct ipmi_ipmb_addr ipmb_addr = { + addr_type: IPMI_IPMB_ADDR_TYPE, + }; + struct ipmi_req _req; + static struct ipmi_rs rsp; + static int curr_seq = 0; + fd_set rset; + + uint8_t * data = NULL; + int data_len = 0; + + + if (intf == NULL || req == NULL) + return NULL; + + ipmb_addr.channel = intf->target_channel & 0x0f; + + if (intf->opened == 0 && intf->open != NULL) + if (intf->open(intf) < 0) + return NULL; + + if (verbose > 2) + printbuf(req->msg.data, req->msg.data_len, + "OpenIPMI Request Message"); + + /* + * setup and send message + */ + + memset(&_req, 0, sizeof(struct ipmi_req)); + + if (intf->target_addr != 0 && + intf->target_addr != intf->my_addr) { + /* use IPMB address if needed */ + ipmb_addr.slave_addr = intf->target_addr; + ipmb_addr.lun = req->msg.lun; + lprintf(LOG_DEBUG, "Sending request 0x%x to " + "IPMB target @ 0x%x:0x%x (from 0x%x)", + req->msg.cmd, + intf->target_addr,intf->target_channel, intf->my_addr); + + if(intf->transit_addr != 0 && intf->transit_addr != intf->my_addr) { + uint8_t index = 0; + + lprintf(LOG_DEBUG, "Encapsulating data sent to " + "end target [0x%02x,0x%02x] using transit [0x%02x,0x%02x] from 0x%x ", + (0x40 | intf->target_channel), + intf->target_addr, + intf->transit_channel, + intf->transit_addr, + intf->my_addr + ); + + /* Convert Message to 'Send Message' */ + /* Supplied req : req , internal req : _req */ + + if (verbose > 4) { + fprintf(stderr, "Converting message:\n"); + fprintf(stderr, " netfn = 0x%x\n", req->msg.netfn ); + fprintf(stderr, " cmd = 0x%x\n", req->msg.cmd); + if (recv.msg.data && recv.msg.data_len) { + fprintf(stderr, " data_len = %d\n", req->msg.data_len); + fprintf(stderr, " data = %s\n", + buf2str(req->msg.data,req->msg.data_len)); + } + } + + /* Modify target address to use 'transit' instead */ + ipmb_addr.slave_addr = intf->transit_addr; + ipmb_addr.channel = intf->transit_channel; + + /* FIXME backup "My address" */ + data_len = req->msg.data_len + 8; + data = malloc(data_len); + if (data == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + return NULL; + } + + memset(data, 0, data_len); + + data[index++] = (0x40|intf->target_channel); + data[index++] = intf->target_addr; + data[index++] = ( req->msg.netfn << 2 ) | req->msg.lun ; + data[index++] = ipmi_csum(data+1, 2); + data[index++] = 0xFF; /* normally 0x20 , overwritten by IPMC */ + data[index++] = ( (0) << 2) | 0 ; /* FIXME */ + data[index++] = req->msg.cmd; + memcpy( (data+index) , req->msg.data, req->msg.data_len); + index += req->msg.data_len; + data[index++] = ipmi_csum( (data+4),(req->msg.data_len + 3) ); + + if (verbose > 4) { + fprintf(stderr, "Encapsulated message:\n"); + fprintf(stderr, " netfn = 0x%x\n", IPMI_NETFN_APP ); + fprintf(stderr, " cmd = 0x%x\n", 0x34 ); + if (data && data_len) { + fprintf(stderr, " data_len = %d\n", data_len); + fprintf(stderr, " data = %s\n", + buf2str(data,data_len)); + } + } + } + _req.addr = (unsigned char *) &ipmb_addr; + _req.addr_len = sizeof(ipmb_addr); + } else { + /* otherwise use system interface */ + lprintf(LOG_DEBUG+2, "Sending request 0x%x to " + "System Interface", req->msg.cmd); + bmc_addr.lun = req->msg.lun; + _req.addr = (unsigned char *) &bmc_addr; + _req.addr_len = sizeof(bmc_addr); + } + + _req.msgid = curr_seq++; + + /* In case of a bridge request */ + if( data != NULL && data_len != 0 ) { + _req.msg.data = data; + _req.msg.data_len = data_len; + _req.msg.netfn = IPMI_NETFN_APP; + _req.msg.cmd = 0x34; + + } else { + _req.msg.data = req->msg.data; + _req.msg.data_len = req->msg.data_len; + _req.msg.netfn = req->msg.netfn; + _req.msg.cmd = req->msg.cmd; + } + + if (ioctl(intf->fd, IPMICTL_SEND_COMMAND, &_req) < 0) { + lperror(LOG_ERR, "Unable to send command"); + if (data != NULL) { + free(data); + data = NULL; + } + return NULL; + } + + /* + * wait for and retrieve response + */ + + if (intf->noanswer) { + if (data != NULL) { + free(data); + data = NULL; + } + return NULL; + } + + FD_ZERO(&rset); + FD_SET(intf->fd, &rset); + + if (select(intf->fd+1, &rset, NULL, NULL, NULL) < 0) { + lperror(LOG_ERR, "I/O Error"); + if (data != NULL) { + free(data); + data = NULL; + } + return NULL; + } + if (FD_ISSET(intf->fd, &rset) == 0) { + lprintf(LOG_ERR, "No data available"); + if (data != NULL) { + free(data); + data = NULL; + } + return NULL; + } + + recv.addr = (unsigned char *) &addr; + recv.addr_len = sizeof(addr); + recv.msg.data = rsp.data; + recv.msg.data_len = sizeof(rsp.data); + + /* get data */ + if (ioctl(intf->fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv) < 0) { + lperror(LOG_ERR, "Error receiving message"); + if (errno != EMSGSIZE) { + if (data != NULL) { + free(data); + data = NULL; + } + return NULL; + } + } + + if (verbose > 4) { + fprintf(stderr, "Got message:"); + fprintf(stderr, " type = %d\n", recv.recv_type); + fprintf(stderr, " channel = 0x%x\n", addr.channel); + fprintf(stderr, " msgid = %ld\n", recv.msgid); + fprintf(stderr, " netfn = 0x%x\n", recv.msg.netfn); + fprintf(stderr, " cmd = 0x%x\n", recv.msg.cmd); + if (recv.msg.data && recv.msg.data_len) { + fprintf(stderr, " data_len = %d\n", recv.msg.data_len); + fprintf(stderr, " data = %s\n", + buf2str(recv.msg.data, recv.msg.data_len)); + } + } + + if(intf->transit_addr != 0 && intf->transit_addr != intf->my_addr) { + uint8_t index = 0; + + /* ipmb_addr.transit_slave_addr = intf->transit_addr; */ + lprintf(LOG_DEBUG, "Decapsulating data received from transit " + "IPMB target @ 0x%x", intf->transit_addr); + + /* comp code */ + /* Check data */ + + if( recv.msg.data[0] == 0 ) { + recv.msg.netfn = recv.msg.data[2] >> 2; + recv.msg.cmd = recv.msg.data[6]; + + recv.msg.data = memmove(recv.msg.data ,recv.msg.data+7 , recv.msg.data_len - 7); + recv.msg.data_len -=8; + + if (verbose > 4) { + fprintf(stderr, "Decapsulated message:\n"); + fprintf(stderr, " netfn = 0x%x\n", recv.msg.netfn ); + fprintf(stderr, " cmd = 0x%x\n", recv.msg.cmd); + if (recv.msg.data && recv.msg.data_len) { + fprintf(stderr, " data_len = %d\n", recv.msg.data_len); + fprintf(stderr, " data = %s\n", + buf2str(recv.msg.data,recv.msg.data_len)); + } + } + } + } + + /* save completion code */ + rsp.ccode = recv.msg.data[0]; + rsp.data_len = recv.msg.data_len - 1; + + /* save response data for caller */ + if (rsp.ccode == 0 && rsp.data_len > 0) { + memmove(rsp.data, rsp.data + 1, rsp.data_len); + rsp.data[rsp.data_len] = 0; + } + + if (data != NULL) { + free(data); + data = NULL; + } + + return &rsp; +} + +int ipmi_openipmi_setup(struct ipmi_intf * intf) +{ + /* set default payload size */ + intf->max_request_data_size = IPMI_OPENIPMI_MAX_RQ_DATA_SIZE; + intf->max_response_data_size = IPMI_OPENIPMI_MAX_RS_DATA_SIZE; + + return 0; +} + +struct ipmi_intf ipmi_open_intf = { + name: "open", + desc: "Linux OpenIPMI Interface", + setup: ipmi_openipmi_setup, + open: ipmi_openipmi_open, + close: ipmi_openipmi_close, + sendrecv: ipmi_openipmi_send_cmd, + set_my_addr: ipmi_openipmi_set_my_addr, + my_addr: IPMI_BMC_SLAVE_ADDR, + target_addr: 0, /* init so -m local_addr does not cause bridging */ +}; |