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);
}
int
unassemble_ipmi_lan_pkt (const void *pkt,
unsigned int pkt_len,
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,
fiid_obj_t obj_lan_msg_trlr,
unsigned int flags)
{
uint8_t authentication_type;
unsigned int indx = 0;
unsigned int obj_cmd_len;
int obj_lan_msg_trlr_len, len;
uint64_t val;
unsigned int flags_mask = (IPMI_INTERFACE_FLAGS_NO_LEGAL_CHECK);
if (!pkt
|| !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)
|| !fiid_obj_valid (obj_lan_msg_trlr)
|| (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_rs) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_lan_msg_trlr, tmpl_lan_msg_trlr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
indx = 0;
if (fiid_obj_clear (obj_rmcp_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
if (fiid_obj_clear (obj_lan_session_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
return (-1);
}
if (fiid_obj_clear (obj_lan_msg_hdr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_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_lan_msg_trlr) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_trlr);
return (-1);
}
if ((len = fiid_obj_set_all (obj_rmcp_hdr, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_rmcp_hdr);
return (-1);
}
indx += len;
if (pkt_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((len = fiid_obj_set_block (obj_lan_session_hdr,
"authentication_type",
"session_id",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
return (-1);
}
indx += len;
if (FIID_OBJ_GET (obj_lan_session_hdr,
"authentication_type",
&val) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
return (-1);
}
authentication_type = val;
if (!IPMI_1_5_AUTHENTICATION_TYPE_VALID (authentication_type))
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if (authentication_type != IPMI_AUTHENTICATION_TYPE_NONE)
{
if ((len = fiid_obj_set_data (obj_lan_session_hdr,
"authentication_code",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
return (-1);
}
indx += len;
if (pkt_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
}
if ((len = fiid_obj_set_data (obj_lan_session_hdr,
"ipmi_msg_len",
pkt + indx,
pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_session_hdr);
return (-1);
}
indx += len;
if (pkt_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((len = fiid_obj_set_all (obj_lan_msg_hdr, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_hdr);
return (-1);
}
indx += len;
if (pkt_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((obj_lan_msg_trlr_len = fiid_template_len_bytes (tmpl_lan_msg_trlr)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if ((pkt_len - indx) <= obj_lan_msg_trlr_len)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
obj_cmd_len = (pkt_len - indx) - obj_lan_msg_trlr_len;
if ((len = fiid_obj_set_all (obj_cmd, pkt + indx, obj_cmd_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
indx += len;
if (pkt_len <= indx)
{
/* cannot parse packet */
ERR_TRACE ("malformed packet", EINVAL);
return (0);
}
if ((len = fiid_obj_set_all (obj_lan_msg_trlr, pkt + indx, pkt_len - indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_lan_msg_trlr);
return (-1);
}
indx += len;
if (FIID_OBJ_PACKET_VALID (obj_rmcp_hdr) == 1
&& FIID_OBJ_PACKET_VALID (obj_lan_session_hdr) == 1
&& FIID_OBJ_PACKET_VALID (obj_lan_msg_hdr) == 1
&& ((flags & IPMI_INTERFACE_FLAGS_NO_LEGAL_CHECK) || FIID_OBJ_PACKET_SUFFICIENT (obj_cmd) == 1)
&& FIID_OBJ_PACKET_VALID (obj_lan_msg_trlr) == 1)
return (1);
return (0);
}
/* return (1) - is oem intel node manager, fully parsed
* return (0) - is not oem intel node manager
* return (-1) - error
*/
int
ipmi_sdr_oem_parse_intel_node_manager (ipmi_sdr_ctx_t ctx,
const void *sdr_record,
unsigned int sdr_record_len,
uint8_t *nm_device_slave_address,
uint8_t *sensor_owner_lun,
uint8_t *channel_number,
uint8_t *nm_health_event_sensor_number,
uint8_t *nm_exception_event_sensor_number,
uint8_t *nm_operational_capabilities_sensor_number,
uint8_t *nm_alert_threshold_exceeded_sensor_number)
{
uint8_t sdr_record_buf[IPMI_SDR_MAX_RECORD_LENGTH];
int sdr_record_buf_len;
fiid_obj_t obj_oem_record = NULL;
int expected_record_len;
void *sdr_record_to_use;
unsigned int sdr_record_len_to_use;
uint64_t val;
int rv = -1;
if (!ctx || ctx->magic != IPMI_SDR_CTX_MAGIC)
{
ERR_TRACE (ipmi_sdr_ctx_errormsg (ctx), ipmi_sdr_ctx_errnum (ctx));
return (-1);
}
if (!sdr_record || !sdr_record_len)
{
if (ctx->operation == IPMI_SDR_OPERATION_READ_CACHE
&& !sdr_record
&& !sdr_record_len)
{
if ((sdr_record_buf_len = ipmi_sdr_cache_record_read (ctx,
sdr_record_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
SDR_SET_INTERNAL_ERRNUM (ctx);
return (-1);
}
sdr_record_to_use = sdr_record_buf;
sdr_record_len_to_use = sdr_record_buf_len;
}
else
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_PARAMETERS);
return (-1);
}
}
else
{
sdr_record_to_use = (void *)sdr_record;
sdr_record_len_to_use = sdr_record_len;
}
if ((expected_record_len = fiid_template_len_bytes (tmpl_sdr_oem_intel_node_manager_record)) < 0)
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if (sdr_record_len_to_use < expected_record_len)
{
rv = 0;
goto cleanup;
}
if (!(obj_oem_record = fiid_obj_create (tmpl_sdr_oem_intel_node_manager_record)))
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if (fiid_obj_set_all (obj_oem_record,
sdr_record_to_use,
expected_record_len) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
/* achu: Node Manager documentation states that OEM ID in the
* SDR record should be Intel's, but I've seen motherboards w/o
* it, so don't bother checking.
*/
if (FIID_OBJ_GET (obj_oem_record,
"record_subtype",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
if (val != IPMI_SDR_OEM_INTEL_NODE_MANAGER_RECORD_SUBTYPE_NM_DISCOVERY)
{
rv = 0;
goto cleanup;
}
if (FIID_OBJ_GET (obj_oem_record,
"version_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
if (val != IPMI_SDR_OEM_INTEL_NODE_MANAGER_DISCOVERY_VERSION)
{
rv = 0;
goto cleanup;
}
if (nm_device_slave_address)
{
if (FIID_OBJ_GET (obj_oem_record,
"nm_device_slave_address",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*nm_device_slave_address) = val;
}
if (sensor_owner_lun)
{
if (FIID_OBJ_GET (obj_oem_record,
"sensor_owner_lun",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*sensor_owner_lun) = val;
}
if (channel_number)
{
if (FIID_OBJ_GET (obj_oem_record,
"channel_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*channel_number) = val;
}
if (nm_health_event_sensor_number)
{
if (FIID_OBJ_GET (obj_oem_record,
"nm_health_event_sensor_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*nm_health_event_sensor_number) = val;
}
if (nm_exception_event_sensor_number)
{
if (FIID_OBJ_GET (obj_oem_record,
"nm_exception_event_sensor_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*nm_exception_event_sensor_number) = val;
}
if (nm_operational_capabilities_sensor_number)
{
if (FIID_OBJ_GET (obj_oem_record,
"nm_operational_capabilities_sensor_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*nm_operational_capabilities_sensor_number) = val;
}
if (nm_alert_threshold_exceeded_sensor_number)
{
if (FIID_OBJ_GET (obj_oem_record,
"nm_alert_threshold_exceeded_sensor_number",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_oem_record);
goto cleanup;
}
(*nm_alert_threshold_exceeded_sensor_number) = val;
}
sdr_check_read_status (ctx);
rv = 1;
ctx->errnum = IPMI_SDR_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_oem_record);
return (rv);
}
static int
_sdr_cache_get_record (ipmi_sdr_ctx_t ctx,
ipmi_ctx_t ipmi_ctx,
uint16_t record_id,
void *record_buf,
unsigned int record_buf_len,
uint16_t *reservation_id,
uint16_t *next_record_id)
{
fiid_obj_t obj_cmd_rs = NULL;
fiid_obj_t obj_sdr_record_header = NULL;
int sdr_record_header_length = 0;
int sdr_record_len = 0;
unsigned int record_length = 0;
int rv = -1;
unsigned int bytes_to_read = IPMI_SDR_CACHE_BYTES_TO_READ_START;
unsigned int offset_into_record = 0;
unsigned int reservation_id_retry_count = 0;
uint8_t temp_record_buf[IPMI_SDR_MAX_RECORD_LENGTH];
uint64_t val;
assert (ctx);
assert (ctx->magic == IPMI_SDR_CTX_MAGIC);
assert (ipmi_ctx);
assert (record_buf);
assert (record_buf_len);
assert (reservation_id);
assert (next_record_id);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_sdr_rs)))
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_sdr_record_header = fiid_obj_create (tmpl_sdr_record_header)))
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if ((sdr_record_header_length = fiid_template_len_bytes (tmpl_sdr_record_header)) < 0)
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
/* achu:
*
* Many motherboards now allow you to read the full SDR record, try
* that first. If it fails for any reason, bail and try to read via
* partial reads.
*/
reservation_id_retry_count = 0;
while (!offset_into_record)
{
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
0,
IPMI_SDR_READ_ENTIRE_RECORD_BYTES_TO_READ,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE)
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
}
goto partial_read;
}
if ((sdr_record_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
temp_record_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
/* Assume this is an "IPMI Error", fall through to partial reads */
if (sdr_record_len < sdr_record_header_length)
goto partial_read;
/*
* IPMI Workaround (achu)
*
* Discovered on Xyratex HB-F8-SRAY
*
* For some reason reading the entire SDR record (with
* IPMI_SDR_READ_ENTIRE_RECORD_BYTES_TO_READ) the response
* returns fewer bytes than the actual length of the record.
* However, when reading with partial reads things ultimately
* succeed. If we notice the length is off, we fall out and do
* a partial read.
*/
if ((((uint8_t)temp_record_buf[IPMI_SDR_RECORD_LENGTH_INDEX]) + IPMI_SDR_RECORD_HEADER_LENGTH) > sdr_record_len)
goto partial_read;
if (sdr_record_len > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"next_record_id",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
*next_record_id = val;
memcpy (record_buf, temp_record_buf, sdr_record_len);
offset_into_record += sdr_record_len;
goto out;
}
partial_read:
reservation_id_retry_count = 0;
while (!record_length)
{
uint8_t record_header_buf[IPMI_SDR_MAX_RECORD_LENGTH];
int sdr_record_header_len;
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
0,
sdr_record_header_length,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_BAD_COMPLETION_CODE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
else
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
}
if ((sdr_record_header_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
record_header_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
if (sdr_record_header_len < sdr_record_header_length)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
if (fiid_obj_set_all (obj_sdr_record_header,
record_header_buf,
sdr_record_header_len) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_sdr_record_header);
goto cleanup;
}
if (FIID_OBJ_GET (obj_sdr_record_header,
"record_length",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_sdr_record_header);
goto cleanup;
}
if (sdr_record_header_len > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
/* copy header into buf */
memcpy (record_buf, record_header_buf, sdr_record_header_len);
offset_into_record += sdr_record_header_len;
record_length = val + sdr_record_header_length;
}
if (record_length > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"next_record_id",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
*next_record_id = val;
reservation_id_retry_count = 0;
while (offset_into_record < record_length)
{
int record_data_len;
if ((record_length - offset_into_record) < bytes_to_read)
bytes_to_read = record_length - offset_into_record;
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
offset_into_record,
bytes_to_read,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_BAD_COMPLETION_CODE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
else
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
else if ((comp_code == IPMI_COMP_CODE_CANNOT_RETURN_REQUESTED_NUMBER_OF_BYTES
|| comp_code == IPMI_COMP_CODE_UNSPECIFIED_ERROR)
&& bytes_to_read > sdr_record_header_length)
{
bytes_to_read -= IPMI_SDR_CACHE_BYTES_TO_READ_DECREMENT;
if (bytes_to_read < sdr_record_header_length)
bytes_to_read = sdr_record_header_length;
continue;
}
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
}
if ((record_data_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
record_buf + offset_into_record,
record_buf_len - offset_into_record)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
offset_into_record += record_data_len;
}
out:
rv = offset_into_record;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
fiid_obj_destroy (obj_sdr_record_header);
return (rv);
}
static int
_ipmi_lan_pkt_rq_min_size (uint8_t authentication_type, fiid_obj_t obj_cmd)
{
unsigned int msg_len = 0;
int len;
assert (IPMI_1_5_AUTHENTICATION_TYPE_VALID (authentication_type) && fiid_obj_valid (obj_cmd));
if ((len = fiid_template_len_bytes (tmpl_rmcp_hdr)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
msg_len += len;
if ((len = fiid_template_len_bytes (tmpl_lan_msg_hdr_rq)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
msg_len += len;
if ((len = fiid_template_len_bytes (tmpl_lan_msg_trlr)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
msg_len += len;
if ((len = fiid_template_block_len_bytes (tmpl_lan_session_hdr,
"authentication_type",
"session_id")) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
msg_len += len;
if (authentication_type == IPMI_AUTHENTICATION_TYPE_MD2
|| authentication_type == IPMI_AUTHENTICATION_TYPE_MD5
|| authentication_type == IPMI_AUTHENTICATION_TYPE_STRAIGHT_PASSWORD_KEY
|| authentication_type == IPMI_AUTHENTICATION_TYPE_OEM_PROP)
msg_len += IPMI_1_5_MAX_PASSWORD_LENGTH;
if ((len = fiid_template_field_len_bytes (tmpl_lan_session_hdr, "ipmi_msg_len")) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
msg_len += len;
if ((len = fiid_obj_len_bytes (obj_cmd)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_cmd);
return (-1);
}
msg_len += len;
return (msg_len);
}
static int
_ssif_cmd_read (ipmi_ctx_t ctx,
uint8_t cmd,
uint8_t group_extension,
fiid_obj_t obj_cmd_rs)
{
uint8_t *pkt = NULL;
unsigned int pkt_len;
int hdr_len, cmd_len, read_len;
fiid_field_t *tmpl = NULL;
int ret, rv = -1;
unsigned int intf_flags = IPMI_INTERFACE_FLAGS_DEFAULT;
assert (ctx
&& ctx->magic == IPMI_CTX_MAGIC
&& fiid_obj_valid (obj_cmd_rs));
if (ctx->flags & IPMI_FLAGS_NO_LEGAL_CHECK)
intf_flags |= IPMI_INTERFACE_FLAGS_NO_LEGAL_CHECK;
if ((hdr_len = fiid_template_len_bytes (tmpl_hdr_kcs)) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(tmpl = fiid_obj_template (obj_cmd_rs)))
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
if ((cmd_len = fiid_template_len_bytes (tmpl)) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
pkt_len = hdr_len + cmd_len;
if (!(pkt = malloc (pkt_len)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
memset (pkt, '\0', pkt_len);
if ((read_len = ipmi_ssif_read (ctx->io.inband.ssif_ctx, pkt, pkt_len)) < 0)
{
API_SSIF_ERRNUM_TO_API_ERRNUM (ctx, ipmi_ssif_ctx_errnum (ctx->io.inband.ssif_ctx));
goto cleanup;
}
if (!read_len)
{
API_SET_ERRNUM (ctx, IPMI_ERR_SYSTEM_ERROR);
goto cleanup;
}
if (ctx->flags & IPMI_FLAGS_DEBUG_DUMP && read_len)
_api_ssif_dump_rs (ctx,
pkt,
read_len,
cmd,
ctx->target.net_fn,
group_extension,
obj_cmd_rs);
if ((ret = unassemble_ipmi_kcs_pkt (pkt,
read_len,
ctx->io.inband.rs.obj_hdr,
obj_cmd_rs,
intf_flags)) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
/* IPMI didn't return enough data back to you */
if (!ret)
{
API_SET_ERRNUM (ctx, IPMI_ERR_IPMI_ERROR);
goto cleanup;
}
rv = 0;
cleanup:
free (pkt);
fiid_template_free (tmpl);
return (rv);
}
static int
_ssif_cmd_write (ipmi_ctx_t ctx,
uint8_t cmd,
uint8_t group_extension,
fiid_obj_t obj_cmd_rq)
{
uint8_t *pkt = NULL;
unsigned int pkt_len;
int hdr_len, cmd_len, send_len;
int rv = -1;
assert (ctx
&& ctx->magic == IPMI_CTX_MAGIC
&& fiid_obj_valid (obj_cmd_rq));
if ((hdr_len = fiid_template_len_bytes (tmpl_hdr_kcs)) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if ((cmd_len = fiid_obj_len_bytes (obj_cmd_rq)) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rq);
goto cleanup;
}
pkt_len = hdr_len + cmd_len;
if (!(pkt = malloc (pkt_len)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
memset (pkt, '\0', pkt_len);
if (fill_hdr_ipmi_kcs (ctx->target.lun,
ctx->target.net_fn,
ctx->io.inband.rq.obj_hdr) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if ((send_len = assemble_ipmi_kcs_pkt (ctx->io.inband.rq.obj_hdr,
obj_cmd_rq,
pkt,
pkt_len,
IPMI_INTERFACE_FLAGS_DEFAULT)) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (ctx->flags & IPMI_FLAGS_DEBUG_DUMP && send_len)
_api_ssif_dump_rq (ctx,
pkt,
send_len,
cmd,
ctx->target.net_fn,
group_extension,
obj_cmd_rq);
if (ipmi_ssif_write (ctx->io.inband.ssif_ctx, pkt, send_len) < 0)
{
API_SSIF_ERRNUM_TO_API_ERRNUM (ctx, ipmi_ssif_ctx_errnum (ctx->io.inband.ssif_ctx));
goto cleanup;
}
rv = 0;
cleanup:
free (pkt);
return (rv);
}
static int
_ipmi_kcs_cmd_read (ipmi_kcs_ctx_t ctx,
fiid_obj_t obj_cmd_rs)
{
uint8_t *pkt = NULL;
unsigned int pkt_len;
int hdr_len, cmd_len, read_len, ret, rv = -1;
fiid_obj_t obj_hdr = NULL;
fiid_field_t *tmpl = NULL;
assert (ctx);
assert (ctx->magic == IPMI_KCS_CTX_MAGIC);
assert (fiid_obj_valid (obj_cmd_rs));
if ((hdr_len = fiid_template_len_bytes (tmpl_hdr_kcs)) < 0)
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(tmpl = fiid_obj_template (obj_cmd_rs)))
{
KCS_FIID_OBJECT_ERROR_TO_KCS_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
if ((cmd_len = fiid_template_len_bytes (tmpl)) < 0)
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_hdr = fiid_obj_create (tmpl_hdr_kcs)))
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
pkt_len = hdr_len + cmd_len;
if (!(pkt = (uint8_t *)malloc (pkt_len)))
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_OUT_OF_MEMORY);
goto cleanup;
}
if ((read_len = ipmi_kcs_read (ctx,
pkt,
pkt_len)) < 0)
goto cleanup;
if (!read_len)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_SYSTEM_ERROR);
goto cleanup;
}
if ((ret = unassemble_ipmi_kcs_pkt (pkt,
read_len,
obj_hdr,
obj_cmd_rs,
IPMI_INTERFACE_FLAGS_DEFAULT)) < 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_INTERNAL_ERROR);
goto cleanup;
}
/* IPMI didn't return enough data back to you */
if (!ret)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_IPMI_ERROR);
goto cleanup;
}
rv = 0;
cleanup:
fiid_template_free (tmpl);
fiid_obj_destroy (obj_hdr);
free (pkt);
return (rv);
}
static int
_ipmi_kcs_cmd_write (ipmi_kcs_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq)
{
uint8_t *pkt = NULL;
unsigned int pkt_len;
int hdr_len, cmd_len, rv = -1;
fiid_obj_t obj_hdr = NULL;
assert (ctx);
assert (ctx->magic == IPMI_KCS_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);
if ((hdr_len = fiid_template_len_bytes (tmpl_hdr_kcs)) < 0)
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
if ((cmd_len = fiid_obj_len_bytes (obj_cmd_rq)) < 0)
{
KCS_FIID_OBJECT_ERROR_TO_KCS_ERRNUM (ctx, obj_cmd_rq);
goto cleanup;
}
if (!(obj_hdr = fiid_obj_create (tmpl_hdr_kcs)))
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
pkt_len = hdr_len + cmd_len;
if (!(pkt = (uint8_t *)malloc (pkt_len)))
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_OUT_OF_MEMORY);
goto cleanup;
}
if (fill_hdr_ipmi_kcs (lun,
net_fn,
obj_hdr) < 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (assemble_ipmi_kcs_pkt (obj_hdr,
obj_cmd_rq,
pkt,
pkt_len,
IPMI_INTERFACE_FLAGS_DEFAULT) < 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (ipmi_kcs_write (ctx, pkt, pkt_len) < 0)
goto cleanup;
rv = 0;
cleanup:
fiid_obj_destroy (obj_hdr);
free (pkt);
return (rv);
}
int
debug_dump_ipmb (int fd,
const char *prefix,
const uint8_t *ipmb_buf,
unsigned int ipmb_buf_len,
fiid_template_t tmpl_ipmb_msg_hdr,
fiid_template_t tmpl_ipmb_cmd)
{
char *ipmb_msg_hdr =
"IPMB Message Header:\n"
"--------------------";
char *ipmb_cmd_hdr =
"IPMB Message Data:\n"
"------------------";
char *ipmb_msg_trlr_hdr =
"IPMB Message Trailer:\n"
"---------------------";
char *ipmb_unexpected_hdr =
"IPMB Unexpected Data:\n"
"---------------------";
fiid_obj_t obj_ipmb_msg_hdr = NULL;
fiid_obj_t obj_ipmb_cmd = NULL;
fiid_obj_t obj_ipmb_msg_trlr = NULL;
fiid_obj_t obj_ipmb_unexpected_data = NULL;
int obj_ipmb_msg_trlr_len = 0;
unsigned int obj_ipmb_cmd_len = 0;
int ipmb_hdr_len = 0;
int ipmb_cmd_len = 0;
int ipmb_trlr_len = 0;
int len;
unsigned int ipmb_indx = 0;
int rv = -1;
assert (ipmb_buf);
assert (ipmb_buf_len);
assert (tmpl_ipmb_msg_hdr);
assert (tmpl_ipmb_cmd);
if (!(obj_ipmb_msg_hdr = fiid_obj_create (tmpl_ipmb_msg_hdr)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
if (!(obj_ipmb_cmd = fiid_obj_create (tmpl_ipmb_cmd)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
if (!(obj_ipmb_msg_trlr = fiid_obj_create (tmpl_ipmb_msg_trlr)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
if ((obj_ipmb_msg_trlr_len = fiid_template_len_bytes (tmpl_ipmb_msg_trlr)) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
if ((ipmb_hdr_len = fiid_obj_set_all (obj_ipmb_msg_hdr,
ipmb_buf,
ipmb_buf_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
goto cleanup;
}
ipmb_indx += ipmb_hdr_len;
if (ipmi_obj_dump (fd,
prefix,
ipmb_msg_hdr,
NULL,
obj_ipmb_msg_hdr) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
if (ipmb_buf_len <= ipmb_indx)
{
rv = 0;
goto cleanup;
}
if ((ipmb_buf_len - ipmb_hdr_len) <= obj_ipmb_msg_trlr_len)
goto dump_ipmb_extra;
obj_ipmb_cmd_len = (ipmb_buf_len - ipmb_hdr_len) - obj_ipmb_msg_trlr_len;
if ((ipmb_cmd_len = fiid_obj_set_all (obj_ipmb_cmd,
ipmb_buf + ipmb_hdr_len,
obj_ipmb_cmd_len)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_cmd);
goto cleanup;
}
ipmb_indx += ipmb_cmd_len;
if (ipmi_obj_dump (fd,
prefix,
ipmb_cmd_hdr,
NULL,
obj_ipmb_cmd) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
if (ipmb_buf_len <= ipmb_indx)
{
rv = 0;
goto cleanup;
}
if ((ipmb_trlr_len = fiid_obj_set_all (obj_ipmb_msg_trlr,
ipmb_buf + ipmb_hdr_len + ipmb_cmd_len,
(ipmb_buf_len - ipmb_hdr_len - ipmb_cmd_len))) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_trlr);
goto cleanup;
}
ipmb_indx += ipmb_trlr_len;
if (ipmi_obj_dump (fd,
prefix,
ipmb_msg_trlr_hdr,
NULL,
obj_ipmb_msg_trlr) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
/* Dump IPMB unexpected stuff */
dump_ipmb_extra:
if ((ipmb_buf_len - ipmb_indx) > 0)
{
if (!(obj_ipmb_unexpected_data = fiid_obj_create (tmpl_unexpected_data)))
{
ERRNO_TRACE (errno);
goto cleanup;
}
if ((len = fiid_obj_set_all (obj_ipmb_unexpected_data,
ipmb_buf + ipmb_indx,
ipmb_buf_len - ipmb_indx)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_unexpected_data);
goto cleanup;
}
ipmb_indx += len;
if (ipmi_obj_dump (fd,
prefix,
ipmb_unexpected_hdr,
NULL,
obj_ipmb_unexpected_data) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_ipmb_msg_hdr);
fiid_obj_destroy (obj_ipmb_cmd);
fiid_obj_destroy (obj_ipmb_msg_trlr);
fiid_obj_destroy (obj_ipmb_unexpected_data);
return (rv);
}
