int
api_inteldcmi_cmd_raw_ipmb (ipmi_ctx_t ctx,
const void *buf_rq,
unsigned int buf_rq_len,
void *buf_rs,
unsigned int buf_rs_len)
{
fiid_obj_t obj_cmd_rq = NULL;
fiid_obj_t obj_cmd_rs = NULL;
int len, rv = -1;
assert (ctx
&& ctx->magic == IPMI_CTX_MAGIC
&& ctx->type == IPMI_DEVICE_INTELDCMI
&& buf_rq
&& buf_rq_len
&& buf_rs
&& buf_rs_len);
if (!(obj_cmd_rq = fiid_obj_create (tmpl_inteldcmi_raw)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_cmd_rs = fiid_obj_create (tmpl_inteldcmi_raw)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fiid_obj_set_all (obj_cmd_rq,
buf_rq,
buf_rq_len) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rq);
goto cleanup;
}
if (api_inteldcmi_cmd_ipmb (ctx,
obj_cmd_rq,
obj_cmd_rs) < 0)
goto cleanup;
if ((len = fiid_obj_get_all (obj_cmd_rs,
buf_rs,
buf_rs_len)) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
rv = len;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
int
ipmi_sunbmc_cmd (ipmi_sunbmc_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
fiid_obj_t obj_cmd_rs)
{
if (!ctx || ctx->magic != IPMI_SUNBMC_CTX_MAGIC)
{
ERR_TRACE (ipmi_sunbmc_ctx_errormsg (ctx), ipmi_sunbmc_ctx_errnum (ctx));
return (-1);
}
if (!IPMI_BMC_LUN_VALID (lun)
|| !IPMI_NET_FN_RQ_VALID (net_fn)
|| !fiid_obj_valid (obj_cmd_rq)
|| !fiid_obj_valid (obj_cmd_rs)
|| fiid_obj_packet_valid (obj_cmd_rq) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_PARAMETERS);
return (-1);
}
if (!ctx->io_init)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_IO_NOT_INITIALIZED);
return (-1);
}
if (ctx->putmsg_intf)
{
if (_sunbmc_write (ctx,
lun,
net_fn,
obj_cmd_rq) < 0)
return (-1);
if (_sunbmc_read (ctx,
obj_cmd_rs) < 0)
return (-1);
}
else
{
#if defined(HAVE_SYS_STROPTS_H)
struct strioctl istr;
bmc_reqrsp_t reqrsp;
uint8_t rq_buf_temp[IPMI_SUNBMC_BUFLEN];
uint8_t rq_buf[IPMI_SUNBMC_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
uint8_t rs_buf[IPMI_SUNBMC_BUFLEN];
int len;
memset (&istr, '\0', sizeof (struct strioctl));
memset (&reqrsp, '\0', sizeof (bmc_reqrsp_t));
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_SUNBMC_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_SUNBMC_BUFLEN)) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
return (-1);
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
/* -1 b/c of cmd */
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
reqrsp.req.fn = net_fn;
reqrsp.req.lun = lun;
reqrsp.req.cmd = rq_cmd;
istr.ic_cmd = IOCTL_IPMI_KCS_ACTION;
istr.ic_timout = 0; /* spelled 'timout', not a typo */
istr.ic_len = sizeof (struct bmc_reqrsp);
istr.ic_dp = (char *)&reqrsp;
if (ioctl (ctx->device_fd,
I_STR,
&istr) < 0)
{
SUNBMC_ERRNO_TO_SUNBMC_ERRNUM (ctx, errno);
return (-1);
}
rs_buf[0] = reqrsp.rsp.cmd;
rs_buf[1] = reqrsp.rsp.ccode;
/* -2 b/c of cmd and ccode */
#if 0
/* achu: to remove warnings, IPMI_SUNBMC_BUFLEN > amount uint8_t can hold */
if (reqrsp.rsp.datalength >= (IPMI_SUNBMC_BUFLEN - 2))
reqrsp.rsp.datalength = IPMI_SUNBMC_BUFLEN - 2;
#endif
/* remove header data stuff in front we don't care about */
if (reqrsp.rsp.datalength > 3)
reqrsp.rsp.datalength -= 3;
else
reqrsp.rsp.datalength = 0;
memcpy (rs_buf + 2, reqrsp.rsp.data, reqrsp.rsp.datalength);
if (fiid_obj_set_all (obj_cmd_rs,
rs_buf,
reqrsp.rsp.datalength + 2) < 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
return (-1);
}
#else /* !defined(HAVE_SYS_STROPTS_H) */
/* otherwise, device is not supported */
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_DEVICE_NOT_SUPPORTED);
return (-1);
#endif /* !defined(HAVE_SYS_STROPTS_H) */
}
return (0);
}
static int
_sunbmc_write (ipmi_sunbmc_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq)
{
#if defined(HAVE_SYS_STROPTS_H)
struct strbuf sbuf;
bmc_msg_t *msg = NULL;
bmc_req_t *req = NULL;
unsigned int msg_len;
uint8_t rq_buf_temp[IPMI_SUNBMC_BUFLEN];
uint8_t rq_buf[IPMI_SUNBMC_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
int len;
#endif /* !defined(HAVE_SYS_STROPTS_H) */
int rv = -1;
assert (ctx);
assert (ctx->magic == IPMI_SUNBMC_CTX_MAGIC);
assert (IPMI_BMC_LUN_VALID (lun));
assert (IPMI_NET_FN_RQ_VALID (net_fn));
assert (fiid_obj_valid (obj_cmd_rq));
assert (fiid_obj_packet_valid (obj_cmd_rq) == 1);
assert (ctx->io_init);
assert (ctx->putmsg_intf);
#if defined(HAVE_SYS_STROPTS_H)
memset (&sbuf, '\0', sizeof (struct strbuf));
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_SUNBMC_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_SUNBMC_BUFLEN)) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
goto cleanup;
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
/* achu: see header for for how this is calculated */
msg_len = offsetof (bmc_msg_t, msg);
msg_len += sizeof (bmc_req_t);
msg_len += (rq_buf_len > SEND_MAX_PAYLOAD_SIZE) ? (rq_buf_len - SEND_MAX_PAYLOAD_SIZE) : 0;
if (!(msg = (bmc_msg_t *)malloc (msg_len)))
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_OUT_OF_MEMORY);
goto cleanup;
}
msg->m_type = BMC_MSG_REQUEST;
msg->m_id = ctx->putmsg_intf_msg_id;
req = (bmc_req_t *)&(msg->msg[0]);
req->fn = net_fn;
req->lun = lun;
req->cmd = rq_cmd;
req->datalength = rq_buf_len;
memcpy (req->data, rq_buf, rq_buf_len);
sbuf.len = msg_len;
sbuf.buf = (char *)msg;
if (putmsg (ctx->device_fd, NULL, &sbuf, 0) < 0)
{
SUNBMC_ERRNO_TO_SUNBMC_ERRNUM (ctx, errno);
goto cleanup;
}
#else /* !defined(HAVE_SYS_STROPTS_H) */
/* otherwise, device is not supported */
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_DEVICE_NOT_SUPPORTED);
goto cleanup;
#endif /* !(defined(HAVE_BMC_INTF_H) && defined(HAVE_SYS_STROPTS_H)) */
rv = 0;
cleanup:
#if defined(HAVE_SYS_STROPTS_H)
free (msg);
#endif /* !defined(HAVE_SYS_STROPTS_H) */
return (rv);
}
int
assemble_ipmi_ipmb_msg (fiid_obj_t obj_ipmb_msg_hdr,
fiid_obj_t obj_cmd,
fiid_obj_t obj_ipmb_msg,
unsigned int flags)
{
uint8_t buf[IPMB_MAX_LEN+1];
unsigned int indx = 0;
uint8_t *checksum_data_ptr = NULL;
unsigned int checksum_data_count = 0;
unsigned int required_len = 0;
fiid_obj_t obj_ipmb_msg_trlr = NULL;
uint8_t checksum;
int len, rv = -1;
unsigned int flags_mask = 0;
if (!fiid_obj_valid (obj_ipmb_msg_hdr)
|| !fiid_obj_valid (obj_cmd)
|| !fiid_obj_valid (obj_ipmb_msg)
|| (flags & ~flags_mask))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_ipmb_msg_hdr, tmpl_ipmb_msg_hdr_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_ipmb_msg, tmpl_ipmb_msg) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_ipmb_msg_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_cmd) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if ((len = fiid_template_len_bytes (tmpl_ipmb_msg_hdr_rq)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
required_len += len;
if ((len = fiid_obj_len_bytes (obj_cmd)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
required_len += len;
if ((len = fiid_template_len_bytes (tmpl_ipmb_msg_trlr)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
required_len += len;
if (IPMB_MAX_LEN < required_len)
{
SET_ERRNO (EMSGSIZE);
return (-1);
}
memset (buf, '\0', IPMB_MAX_LEN+1);
if ((len = fiid_obj_get_block (obj_ipmb_msg_hdr,
"rs_addr",
"checksum1",
buf + indx,
IPMB_MAX_LEN - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
goto cleanup;
}
indx += len;
checksum_data_ptr = (buf + indx);
if ((len = fiid_obj_get_block (obj_ipmb_msg_hdr,
"rq_addr",
"rq_seq",
buf + indx,
IPMB_MAX_LEN - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
goto cleanup;
}
indx += len;
checksum_data_count += len;
if ((len = fiid_obj_get_all (obj_cmd, buf + indx, IPMB_MAX_LEN - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
goto cleanup;
}
indx += len;
checksum_data_count += len;
if (!(obj_ipmb_msg_trlr = fiid_obj_create (tmpl_ipmb_msg_trlr)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
checksum = ipmi_checksum (checksum_data_ptr, checksum_data_count);
if (fiid_obj_set_all (obj_ipmb_msg_trlr, &checksum, sizeof (checksum)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_trlr);
goto cleanup;
}
if ((len = fiid_obj_get_all (obj_ipmb_msg_trlr, buf + indx, IPMB_MAX_LEN - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_trlr);
goto cleanup;
}
indx += len;
if ((len = fiid_obj_set_all (obj_ipmb_msg, buf, indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg);
goto cleanup;
}
rv = len;
cleanup:
fiid_obj_destroy (obj_ipmb_msg_trlr);
return (rv);
}
int
unassemble_ipmi_ipmb_msg (fiid_obj_t obj_ipmb_msg,
fiid_obj_t obj_ipmb_msg_hdr,
fiid_obj_t obj_cmd,
fiid_obj_t obj_ipmb_msg_trlr,
unsigned int flags)
{
uint8_t buf[IPMB_MAX_LEN+1];
int buf_len, obj_ipmb_msg_trlr_len, len;
unsigned int indx = 0;
unsigned int ipmb_msg_len;
unsigned int flags_mask = (IPMI_INTERFACE_FLAGS_NO_LEGAL_CHECK);
if (!fiid_obj_valid (obj_ipmb_msg)
|| !fiid_obj_valid (obj_ipmb_msg_hdr)
|| !fiid_obj_valid (obj_cmd)
|| !fiid_obj_valid (obj_ipmb_msg_trlr)
|| (flags & ~flags_mask))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_ipmb_msg_hdr, tmpl_ipmb_msg_hdr_rs) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_ipmb_msg_trlr, tmpl_ipmb_msg_trlr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
memset (buf, '\0', IPMB_MAX_LEN+1);
if ((buf_len = fiid_obj_get_all (obj_ipmb_msg, buf, IPMB_MAX_LEN)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg);
return (-1);
}
if (fiid_obj_clear (obj_ipmb_msg_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
return (-1);
}
if (fiid_obj_clear (obj_cmd) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if (fiid_obj_clear (obj_ipmb_msg_trlr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_trlr);
return (-1);
}
if ((len = fiid_obj_set_all (obj_ipmb_msg_hdr, buf + indx, buf_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
return (-1);
}
indx += len;
if (buf_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((obj_ipmb_msg_trlr_len = fiid_template_len_bytes (tmpl_ipmb_msg_trlr)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if ((buf_len - indx) <= obj_ipmb_msg_trlr_len)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
ipmb_msg_len = (buf_len - indx) - obj_ipmb_msg_trlr_len;
if ((len = fiid_obj_set_all (obj_cmd, buf + indx, ipmb_msg_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
indx += len;
if (buf_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((len = fiid_obj_set_all (obj_ipmb_msg_trlr, buf + indx, buf_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_trlr);
return (-1);
}
indx += len;
if (FIID_OBJ_PACKET_VALID (obj_ipmb_msg_hdr) == 1
&& ((flags & IPMI_INTERFACE_FLAGS_NO_LEGAL_CHECK) || FIID_OBJ_PACKET_SUFFICIENT (obj_cmd) == 1)
&& FIID_OBJ_PACKET_VALID (obj_ipmb_msg_trlr) == 1)
return (1);
return (0);
}
static int
_openipmi_write (ipmi_openipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t rs_addr,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
unsigned int is_ipmb)
{
uint8_t rq_buf_temp[IPMI_OPENIPMI_BUFLEN];
uint8_t rq_buf[IPMI_OPENIPMI_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
int len;
struct ipmi_system_interface_addr system_interface_addr;
struct ipmi_ipmb_addr ipmb_addr;
struct ipmi_req rq_packet;
assert (ctx);
assert (ctx->magic == IPMI_OPENIPMI_CTX_MAGIC);
assert (IPMI_CHANNEL_NUMBER_VALID (channel_number));
assert (IPMI_BMC_LUN_VALID (lun));
assert (IPMI_NET_FN_RQ_VALID (net_fn));
assert (fiid_obj_valid (obj_cmd_rq));
assert (fiid_obj_packet_valid (obj_cmd_rq) == 1);
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_OPENIPMI_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_OPENIPMI_BUFLEN)) <= 0)
{
OPENIPMI_SET_ERRNUM (ctx, IPMI_OPENIPMI_ERR_INTERNAL_ERROR);
return (-1);
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
/* -1 b/c of cmd */
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
if (!is_ipmb)
{
system_interface_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; /* openipmi macro */
system_interface_addr.channel = IPMI_CHANNEL_NUMBER_SYSTEM_INTERFACE; /* freeipmi macro */
system_interface_addr.lun = lun;
rq_packet.addr = (unsigned char *)&system_interface_addr;
rq_packet.addr_len = sizeof (struct ipmi_system_interface_addr);
}
else
{
ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; /* openipmi macro */
ipmb_addr.channel = channel_number;
ipmb_addr.slave_addr = rs_addr;
ipmb_addr.lun = lun;
rq_packet.addr = (unsigned char *)&ipmb_addr;
rq_packet.addr_len = sizeof (struct ipmi_ipmb_addr);
}
rq_packet.msgid = 0;
rq_packet.msg.netfn = net_fn;
rq_packet.msg.cmd = rq_cmd;
rq_packet.msg.data_len = rq_buf_len;
rq_packet.msg.data = rq_buf;
if (ioctl (ctx->device_fd,
IPMICTL_SEND_COMMAND,
&rq_packet) < 0)
{
OPENIPMI_ERRNO_TO_OPENIPMI_ERRNUM (ctx, errno);
return (-1);
}
return (0);
}
int
assemble_rmcp_pkt (fiid_obj_t obj_rmcp_hdr,
fiid_obj_t obj_cmd,
void *pkt,
unsigned int pkt_len,
unsigned int flags)
{
int obj_cmd_len, obj_rmcp_hdr_len;
unsigned int flags_mask = 0;
if (!fiid_obj_valid (obj_rmcp_hdr)
|| !fiid_obj_valid (obj_cmd)
|| !pkt
|| !pkt_len
|| (flags & ~flags_mask))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_rmcp_hdr, tmpl_rmcp_hdr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_rmcp_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_cmd) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if ((obj_rmcp_hdr_len = fiid_obj_len_bytes (obj_rmcp_hdr)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
if ((obj_cmd_len = fiid_obj_len_bytes (obj_cmd)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if (pkt_len < (obj_rmcp_hdr_len + obj_cmd_len))
{
SET_ERRNO (EMSGSIZE);
return (-1);
}
memset (pkt, '\0', pkt_len);
if ((obj_rmcp_hdr_len = fiid_obj_get_all (obj_rmcp_hdr,
pkt,
pkt_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
if ((obj_cmd_len = fiid_obj_get_all (obj_cmd,
pkt + obj_rmcp_hdr_len,
pkt_len - obj_rmcp_hdr_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
return (obj_rmcp_hdr_len + obj_cmd_len);
}
int
assemble_ipmi_lan_pkt (fiid_obj_t obj_rmcp_hdr,
fiid_obj_t obj_lan_session_hdr,
fiid_obj_t obj_lan_msg_hdr,
fiid_obj_t obj_cmd,
const void *authentication_code_data,
unsigned int authentication_code_data_len,
void *pkt,
unsigned int pkt_len,
unsigned int flags)
{
uint8_t authentication_type;
uint64_t val;
unsigned int indx = 0;
int required_len;
void *authentication_code_field_ptr = NULL;
void *checksum_data_ptr = NULL;
void *msg_data_ptr = NULL;
void *ipmi_msg_len_ptr = NULL;
unsigned int msg_data_count = 0;
unsigned int checksum_data_count = 0;
uint8_t ipmi_msg_len;
fiid_obj_t obj_lan_msg_trlr = NULL;
uint8_t pwbuf[IPMI_1_5_MAX_PASSWORD_LENGTH];
uint8_t checksum;
int len, rv = -1;
unsigned int flags_mask = 0;
if (!fiid_obj_valid (obj_rmcp_hdr)
|| !fiid_obj_valid (obj_lan_session_hdr)
|| !fiid_obj_valid (obj_lan_msg_hdr)
|| !fiid_obj_valid (obj_cmd)
|| (authentication_code_data && authentication_code_data_len > IPMI_1_5_MAX_PASSWORD_LENGTH)
|| !pkt
|| (flags & ~flags_mask))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_rmcp_hdr, tmpl_rmcp_hdr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_lan_session_hdr, tmpl_lan_session_hdr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_lan_msg_hdr, tmpl_lan_msg_hdr_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_rmcp_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
/*
* ipmi_msg_len is calculated in this function, so we can't use
* fiid_obj_packet_valid() on obj_lan_session_hdr b/c ipmi_msg_len
* is probably not set yet.
*/
if (FIID_OBJ_PACKET_VALID (obj_lan_msg_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_hdr);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_cmd) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if (FIID_OBJ_GET (obj_lan_session_hdr,
"authentication_type",
&val) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
authentication_type = val;
if (authentication_type != IPMI_AUTHENTICATION_TYPE_NONE
&& authentication_type != IPMI_AUTHENTICATION_TYPE_MD2
&& authentication_type != IPMI_AUTHENTICATION_TYPE_MD5
&& authentication_type != IPMI_AUTHENTICATION_TYPE_STRAIGHT_PASSWORD_KEY)
{
SET_ERRNO (EINVAL);
return (-1);
}
/* no need for overflow checks, handled w/ _ipmi_lan_pkt_rq_min_size check */
required_len = _ipmi_lan_pkt_rq_min_size (authentication_type, obj_cmd);
if (pkt_len < required_len)
{
SET_ERRNO (EMSGSIZE);
return (-1);
}
memset (pkt, 0, pkt_len);
if ((len = fiid_obj_get_all (obj_rmcp_hdr, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
goto cleanup;
}
indx += len;
if ((len = fiid_obj_get_block (obj_lan_session_hdr,
"authentication_type",
"session_id",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
goto cleanup;
}
indx += len;
/* authentication_code generated last. Save pointers for later calculation */
if (authentication_type != IPMI_AUTHENTICATION_TYPE_NONE)
{
authentication_code_field_ptr = (pkt + indx);
indx += IPMI_1_5_MAX_PASSWORD_LENGTH;
}
ipmi_msg_len_ptr = (pkt + indx);
if ((len = fiid_template_field_len_bytes (tmpl_lan_session_hdr, "ipmi_msg_len")) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
if (len != 1)
{
SET_ERRNO (EINVAL);
goto cleanup;
}
indx += len;
msg_data_ptr = (pkt + indx);
if ((len = fiid_obj_get_block (obj_lan_msg_hdr,
"rs_addr",
"checksum1",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_hdr);
goto cleanup;
}
indx += len;
msg_data_count += len;
checksum_data_ptr = (pkt + indx);
if ((len = fiid_obj_get_block (obj_lan_msg_hdr,
"rq_addr",
"rq_seq",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_hdr);
goto cleanup;
}
indx += len;
msg_data_count += len;
checksum_data_count += len;
if ((len = fiid_obj_get_all (obj_cmd, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
goto cleanup;
}
indx += len;
msg_data_count += len;
checksum_data_count += len;
if (!(obj_lan_msg_trlr = fiid_obj_create (tmpl_lan_msg_trlr)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
checksum = ipmi_checksum (checksum_data_ptr, checksum_data_count);
if (fiid_obj_set_all (obj_lan_msg_trlr, &checksum, sizeof (checksum)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_trlr);
goto cleanup;
}
if ((len = fiid_obj_get_all (obj_lan_msg_trlr, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_trlr);
goto cleanup;
}
indx += len;
msg_data_count += len;
/* ipmi_msg_len done after message length is computed */
ipmi_msg_len = msg_data_count;
memcpy (ipmi_msg_len_ptr,
&ipmi_msg_len,
sizeof (ipmi_msg_len));
/* Auth code must be done last, some authentication like md2 and md5
* require all fields, including checksums, to be calculated
* beforehand
*/
if (authentication_type != IPMI_AUTHENTICATION_TYPE_NONE)
{
int authentication_len;
memset (pwbuf, '\0', IPMI_1_5_MAX_PASSWORD_LENGTH);
if ((authentication_len = fiid_obj_field_len_bytes (obj_lan_session_hdr,
"authentication_code")) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
goto cleanup;
}
if (authentication_len)
{
if (fiid_obj_get_data (obj_lan_session_hdr,
"authentication_code",
pwbuf,
IPMI_1_5_MAX_PASSWORD_LENGTH) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
goto cleanup;
}
memcpy (authentication_code_field_ptr,
pwbuf,
IPMI_1_5_MAX_PASSWORD_LENGTH);
}
else
{
if (authentication_code_data)
memcpy (pwbuf,
authentication_code_data,
authentication_code_data_len);
if (authentication_type == IPMI_AUTHENTICATION_TYPE_STRAIGHT_PASSWORD_KEY)
{
memcpy (authentication_code_field_ptr,
pwbuf,
IPMI_1_5_MAX_PASSWORD_LENGTH);
}
else /* IPMI_AUTHENTICATION_TYPE_MD2 || IPMI_AUTHENTICATION_TYPE_MD5 */
{
uint8_t session_id_buf[1024];
uint8_t session_sequence_number_buf[1024];
int session_id_len, session_sequence_number_len;
if ((session_id_len = fiid_obj_get_data (obj_lan_session_hdr,
"session_id",
session_id_buf,
1024)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
goto cleanup;
}
if ((session_sequence_number_len = fiid_obj_get_data (obj_lan_session_hdr,
"session_sequence_number",
session_sequence_number_buf,
1024)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
goto cleanup;
}
if (authentication_type == IPMI_AUTHENTICATION_TYPE_MD2)
{
md2_t ctx;
uint8_t digest[MD2_DIGEST_LENGTH];
assert (IPMI_1_5_MAX_PASSWORD_LENGTH == MD2_DIGEST_LENGTH);
md2_init (&ctx);
md2_update_data (&ctx, pwbuf, IPMI_1_5_MAX_PASSWORD_LENGTH);
md2_update_data (&ctx, session_id_buf, session_id_len);
md2_update_data (&ctx, msg_data_ptr, msg_data_count);
md2_update_data (&ctx, session_sequence_number_buf, session_sequence_number_len);
md2_update_data (&ctx, pwbuf, IPMI_1_5_MAX_PASSWORD_LENGTH);
md2_finish (&ctx, digest, MD2_DIGEST_LENGTH);
md2_init (&ctx);
memcpy (authentication_code_field_ptr, digest, IPMI_1_5_MAX_PASSWORD_LENGTH);
secure_memset (digest, '\0', MD2_DIGEST_LENGTH);
}
else if (authentication_type == IPMI_AUTHENTICATION_TYPE_MD5)
{
md5_t ctx;
uint8_t digest[MD5_DIGEST_LENGTH];
assert (IPMI_1_5_MAX_PASSWORD_LENGTH == MD5_DIGEST_LENGTH);
md5_init (&ctx);
md5_update_data (&ctx, pwbuf, IPMI_1_5_MAX_PASSWORD_LENGTH);
md5_update_data (&ctx, session_id_buf, session_id_len);
md5_update_data (&ctx, msg_data_ptr, msg_data_count);
md5_update_data (&ctx, session_sequence_number_buf, session_sequence_number_len);
md5_update_data (&ctx, pwbuf, IPMI_1_5_MAX_PASSWORD_LENGTH);
md5_finish (&ctx, digest, MD5_DIGEST_LENGTH);
md5_init (&ctx);
memcpy (authentication_code_field_ptr, digest, IPMI_1_5_MAX_PASSWORD_LENGTH);
secure_memset (digest, '\0', MD5_DIGEST_LENGTH);
}
}
}
}
if (indx > INT_MAX)
{
SET_ERRNO (EMSGSIZE);
goto cleanup;
}
rv = indx;
cleanup:
if (rv < 0)
secure_memset (pkt, '\0', pkt_len);
fiid_obj_destroy (obj_lan_msg_trlr);
secure_memset (pwbuf, '\0', IPMI_1_5_MAX_PASSWORD_LENGTH);
return (rv);
}
static int
_api_ssif_ipmb_send (ipmi_ctx_t ctx,
fiid_obj_t obj_cmd_rq)
{
struct ipmi_ctx_target target_save;
uint8_t buf[IPMI_MAX_PKT_LEN];
fiid_obj_t obj_ipmb_msg_hdr_rq = NULL;
fiid_obj_t obj_ipmb_msg_rq = NULL;
fiid_obj_t obj_send_cmd_rs = NULL;
int len, ret, rv = -1;
assert (ctx
&& ctx->magic == IPMI_CTX_MAGIC
&& ctx->type == IPMI_DEVICE_SSIF
&& fiid_obj_valid (obj_cmd_rq)
&& fiid_obj_packet_valid (obj_cmd_rq) == 1);
if (!(obj_ipmb_msg_hdr_rq = fiid_obj_create (tmpl_ipmb_msg_hdr_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_ipmb_msg_rq = fiid_obj_create (tmpl_ipmb_msg)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_send_cmd_rs = fiid_obj_create (tmpl_cmd_send_message_rs)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_ipmb_msg_hdr (ctx->target.rs_addr,
ctx->target.net_fn,
ctx->target.lun,
IPMI_SLAVE_ADDRESS_BMC,
IPMI_BMC_IPMB_LUN_SMS_MSG_LUN,
ctx->io.inband.rq_seq,
obj_ipmb_msg_hdr_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (assemble_ipmi_ipmb_msg (obj_ipmb_msg_hdr_rq,
obj_cmd_rq,
obj_ipmb_msg_rq,
IPMI_INTERFACE_FLAGS_DEFAULT) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
memset (buf, '\0', IPMI_MAX_PKT_LEN);
if ((len = fiid_obj_get_all (obj_ipmb_msg_rq,
buf,
IPMI_MAX_PKT_LEN)) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_ipmb_msg_rq);
goto cleanup;
}
/* send_message will send to the BMC, so clear out target information */
memcpy (&target_save, &ctx->target, sizeof (target_save));
ctx->target.channel_number_is_set = 0;
ctx->target.rs_addr_is_set = 0;
ret = ipmi_cmd_send_message (ctx,
target_save.channel_number,
IPMI_SEND_MESSAGE_AUTHENTICATION_NOT_REQUIRED,
IPMI_SEND_MESSAGE_ENCRYPTION_NOT_REQUIRED,
IPMI_SEND_MESSAGE_TRACKING_OPERATION_NO_TRACKING,
buf,
len,
obj_send_cmd_rs);
/* restore target info */
memcpy (&ctx->target, &target_save, sizeof (target_save));
if (ret < 0)
{
/* assume these mean can't send message, bad slave address, etc. */
if (ipmi_check_completion_code (obj_send_cmd_rs, IPMI_COMP_CODE_SEND_MESSAGE_LOST_ARBITRATION) == 1
|| ipmi_check_completion_code (obj_send_cmd_rs, IPMI_COMP_CODE_SEND_MESSAGE_BUS_ERROR) == 1
|| ipmi_check_completion_code (obj_send_cmd_rs, IPMI_COMP_CODE_SEND_MESSAGE_NAK_ON_WRITE) == 1)
API_SET_ERRNUM (ctx, IPMI_ERR_MESSAGE_TIMEOUT);
else
API_BAD_RESPONSE_TO_API_ERRNUM (ctx, obj_send_cmd_rs);
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_ipmb_msg_hdr_rq);
fiid_obj_destroy (obj_ipmb_msg_rq);
fiid_obj_destroy (obj_send_cmd_rs);
return (rv);
}
int
assemble_ipmi_kcs_pkt (fiid_obj_t obj_kcs_hdr,
fiid_obj_t obj_cmd,
void *pkt,
unsigned int pkt_len,
unsigned int flags)
{
int obj_cmd_len, obj_kcs_hdr_len;
unsigned int utmp;
unsigned int flags_mask = 0;
if (!fiid_obj_valid (obj_kcs_hdr)
|| !fiid_obj_valid (obj_cmd)
|| !pkt
|| (flags & ~flags_mask))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_kcs_hdr, tmpl_hdr_kcs) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_kcs_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_kcs_hdr);
return (-1);
}
if (FIID_OBJ_PACKET_VALID (obj_cmd) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
if ((obj_kcs_hdr_len = fiid_obj_len_bytes (obj_kcs_hdr)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_kcs_hdr);
return (-1);
}
if ((obj_cmd_len = fiid_obj_len_bytes (obj_cmd)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
/* int overflow not possible here */
if (pkt_len < (obj_kcs_hdr_len + obj_cmd_len))
{
SET_ERRNO (EMSGSIZE);
return (-1);
}
memset (pkt, 0, pkt_len);
if ((obj_kcs_hdr_len = fiid_obj_get_all (obj_kcs_hdr,
pkt,
pkt_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_kcs_hdr);
return (-1);
}
if ((obj_cmd_len = fiid_obj_get_all (obj_cmd,
pkt + obj_kcs_hdr_len,
pkt_len - obj_kcs_hdr_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
utmp = obj_kcs_hdr_len + obj_cmd_len;
if (utmp > INT_MAX)
{
SET_ERRNO (EMSGSIZE);
return (-1);
}
return (obj_kcs_hdr_len + obj_cmd_len);
}
