int
decode_pdn_address (
PdnAddress * pdnaddress,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER (iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER (len - decoded, ielen);
pdnaddress->pdntypevalue = *(buffer + decoded) & 0x7;
decoded++;
if ((decode_result = decode_octet_string (&pdnaddress->pdnaddressinformation, ielen - 1, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if NAS_DEBUG
dump_pdn_address_xml (pdnaddress, iei);
#endif
return decoded;
}
int decode_lcs_client_identity(LcsClientIdentity *lcsclientidentity, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER(len - decoded, ielen);
if ((decode_result = decode_octet_string(&lcsclientidentity->lcsclientidentityvalue, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if defined (NAS_DEBUG)
dump_lcs_client_identity_xml(lcsclientidentity, iei);
#endif
return decoded;
}
int
decode_authentication_parameter_autn (
AuthenticationParameterAutn * authenticationparameterautn,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER (iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER (len - decoded, ielen);
if ((decode_result = decode_octet_string (&authenticationparameterautn->autn, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if NAS_DEBUG
dump_authentication_parameter_autn_xml (authenticationparameterautn, iei);
#endif
return decoded;
}
int
decode_ms_network_capability (
MsNetworkCapability * msnetworkcapability,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER (iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER (len - decoded, ielen);
if ((decode_result = decode_octet_string (&msnetworkcapability->msnetworkcapabilityvalue, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if NAS_DEBUG
dump_ms_network_capability_xml (msnetworkcapability, iei);
#endif
return decoded;
}
int decode_esm_message_container(EsmMessageContainer *esmmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
int decode_result;
uint16_t ielen;
LOG_FUNC_IN;
if (iei > 0) {
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
DECODE_LENGTH_U16(buffer + decoded, ielen, decoded);
CHECK_LENGTH_DECODER(len - decoded, ielen);
if ((decode_result = decode_octet_string(&esmmessagecontainer->esmmessagecontainercontents, ielen, buffer + decoded, len - decoded)) < 0) {
LOG_FUNC_RETURN(decode_result);
} else {
decoded += decode_result;
}
#if defined (NAS_DEBUG)
dump_esm_message_container_xml(esmmessagecontainer, iei);
#endif
LOG_FUNC_RETURN(decoded);
}
int decode_authentication_failure_parameter(AuthenticationFailureParameter *authenticationfailureparameter, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER(len - decoded, ielen);
if ((decode_result = decode_octet_string(&authenticationfailureparameter->auts, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if defined (NAS_DEBUG)
dump_authentication_failure_parameter_xml(authenticationfailureparameter, iei);
#endif
return decoded;
}
int
decode_p_tmsi_signature (
PTmsiSignature * ptmsisignature,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
int decoded = 0;
int decode_result;
uint8_t ielen = 3;
if (iei > 0) {
CHECK_IEI_DECODER (iei, *buffer);
decoded++;
}
if ((decode_result = decode_octet_string (&ptmsisignature->ptmsisignaturevalue, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if NAS_DEBUG
dump_p_tmsi_signature_xml (ptmsisignature, iei);
#endif
return decoded;
}
int decode_nas_message_container(NasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0) {
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER(len - decoded, ielen);
if ((decode_result = decode_octet_string(&nasmessagecontainer->nasmessagecontainercontents, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if defined (NAS_DEBUG)
dump_nas_message_container_xml(nasmessagecontainer, iei);
#endif
return decoded;
}
int decode_authentication_parameter_rand(AuthenticationParameterRand *authenticationparameterrand, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
uint8_t ielen = 16;
int decode_result;
if (iei > 0)
{
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
if ((decode_result = decode_octet_string(&authenticationparameterrand->rand, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if defined (NAS_DEBUG)
dump_authentication_parameter_rand_xml(authenticationparameterrand, iei);
#endif
return decoded;
}
int decode_cli(Cli *cli, uint8_t iei, uint8_t *buffer, uint32_t len)
{
int decoded = 0;
uint8_t ielen = 0;
int decode_result;
if (iei > 0)
{
CHECK_IEI_DECODER(iei, *buffer);
decoded++;
}
ielen = *(buffer + decoded);
decoded++;
CHECK_LENGTH_DECODER(len - decoded, ielen);
if ((decode_result = decode_octet_string(&cli->clivalue, ielen, buffer + decoded, len - decoded)) < 0)
return decode_result;
else
decoded += decode_result;
#if defined (NAS_DEBUG)
dump_cli_xml(cli, iei);
#endif
return decoded;
}
/**
* Initializes a given METRIC_RTSA attribute from stream content.
*
* \param rtsa the METRIC_RTSA.
* \param attr_id the METRIC_RTSA's attribute ID.
* \param stream the value of METRIC_RTSA's attribute.
* \param data_entry output parameter to describe data value
*
* \return \b 1, if the METRIC_RTSA's attribute is properly modified; \b 0 otherwise.
*
*/
int dimutil_fill_rtsa_attr(struct RTSA *rtsa, OID_Type attr_id,
ByteStreamReader *stream, DataEntry *data_entry)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_TIME_PD_SAMP:
rtsa->sample_period = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_sample_period(data_entry,
"Sample-Period",
rtsa->sample_period);
break;
case MDC_ATTR_SIMP_SA_OBS_VAL:
del_octet_string(&rtsa->simple_sa_observed_value);
decode_octet_string(stream, &(rtsa->simple_sa_observed_value), &error);
if (error) {
result = 0;
break;
}
data_set_simple_sa_observed_value(data_entry,
"Simple-Sa-Observed-Value",
&(rtsa->simple_sa_observed_value));
break;
case MDC_ATTR_SCALE_SPECN_I8:
del_scalerangespec8(&rtsa->scale_and_range_specification_8);
decode_scalerangespec8(stream,
&(rtsa->scale_and_range_specification_8),
&error);
if (error) {
result = 0;
break;
}
data_set_scale_and_range_specification_8(data_entry,
"Scale-and-Range-Specification",
&(rtsa->scale_and_range_specification_8));
break;
case MDC_ATTR_SCALE_SPECN_I16:
del_scalerangespec16(&rtsa->scale_and_range_specification_16);
decode_scalerangespec16(stream,
&(rtsa->scale_and_range_specification_16),
&error);
if (error) {
result = 0;
break;
}
data_set_scale_and_range_specification_16(data_entry,
"Scale-and-Range-Specification",
&(rtsa->scale_and_range_specification_16));
break;
case MDC_ATTR_SCALE_SPECN_I32:
del_scalerangespec32(&rtsa->scale_and_range_specification_32);
decode_scalerangespec32(stream,
&(rtsa->scale_and_range_specification_32),
&error);
if (error) {
result = 0;
break;
}
data_set_scale_and_range_specification_32(data_entry,
"Scale-and-Range-Specification",
&(rtsa->scale_and_range_specification_32));
break;
case MDC_ATTR_SA_SPECN:
del_saspec(&rtsa->sa_specification);
decode_saspec(stream, &rtsa->sa_specification, &error);
if (error) {
result = 0;
break;
}
data_set_sa_specification(data_entry,
"Sa-Specification",
&(rtsa->sa_specification));
break;
default:
result = dimutil_fill_metric_attr(&rtsa->metric, attr_id, stream, data_entry);
break;
}
return result;
}
/**
* Initializes a given PMStore attribute with a stream content.
*
* \param pmstore the PMStore.
* \param attr_id the PMStore's attribute ID.
* \param stream the value of PMStore's attribute.
*
* \return \b 1, if the PMStore's attribute is properly modified; \b 0 otherwise.
*
*/
int pmstore_set_attribute(struct PMStore *pmstore, OID_Type attr_id, ByteStreamReader *stream)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_ID_HANDLE: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->handle = s;
break;
}
case MDC_ATTR_PM_STORE_CAPAB: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->pm_store_capab = s;
break;
}
case MDC_ATTR_METRIC_STORE_SAMPLE_ALG: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->store_sample_algorithm = s;
break;
}
case MDC_ATTR_METRIC_STORE_CAPAC_CNT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->store_capacity_count = s;
break;
}
case MDC_ATTR_METRIC_STORE_USAGE_CNT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->store_usage_count = s;
break;
}
case MDC_ATTR_OP_STAT: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->operational_state = s;
break;
}
case MDC_ATTR_PM_STORE_LABEL_STRING: {
octet_string s;
decode_octet_string(stream, &s, &error);
if (error) {
result = 0;
break;
}
del_octet_string(&pmstore->pm_store_label);
pmstore->pm_store_label = s;
break;
}
case MDC_ATTR_TIME_PD_SAMP: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->sample_period = s;
break;
}
case MDC_ATTR_NUM_SEG: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->number_of_segments = s;
break;
}
case MDC_ATTR_CLEAR_TIMEOUT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pmstore->clear_timeout = s;
break;
}
default:
// unknown attr, ignore
DEBUG("pmstore attr %d ignored", attr_id);
break;
}
return result;
}
/**
* Initializes a given PMSegment attribute with a stream content.
*
* \param pm_segment the PMSegment.
* \param attr_id the PMSegment's attribute ID.
* \param stream the value of PMSegment's attribute.
*
* \return \b 1, if the PMSegment's attribute is properly modified; \b 0 otherwise.
*
*/
static int pmstore_fill_segment_attr(struct PMSegment *pm_segment, OID_Type attr_id,
ByteStreamReader *stream)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_PM_SEG_MAP: {
PmSegmentEntryMap s;
decode_pmsegmententrymap(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->pm_segment_entry_map = s;
break;
}
case MDC_ATTR_PM_SEG_PERSON_ID: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->pm_seg_person_id = s;
break;
}
case MDC_ATTR_OP_STAT: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->operational_state = s;
break;
}
case MDC_ATTR_TIME_PD_SAMP: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->sample_period = s;
break;
}
case MDC_ATTR_PM_SEG_LABEL_STRING: {
octet_string s;
decode_octet_string(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->segment_label = s;
break;
}
case MDC_ATTR_TIME_START_SEG: {
AbsoluteTime s;
decode_absolutetime(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->segment_start_abs_time = s;
break;
}
case MDC_ATTR_TIME_END_SEG: {
AbsoluteTime s;
decode_absolutetime(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->segment_end_abs_time = s;
break;
}
case MDC_ATTR_TIME_ABS_ADJUST: {
AbsoluteTimeAdjust s;
decode_absolutetimeadjust(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->date_and_time_adjustment = s;
break;
}
case MDC_ATTR_SEG_USAGE_CNT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->segment_usage_count = s;
break;
}
case MDC_ATTR_SEG_STATS: {
SegmentStatistics s;
decode_segmentstatistics(stream, &s, &error);
if (error) {
result = 0;
break;
}
pm_segment->segment_statistics = s;
break;
}
case MDC_ATTR_CONFIRM_TIMEOUT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->confirm_timeout = s;
break;
}
case MDC_ATTR_TRANSFER_TIMEOUT: {
intu32 s = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
pm_segment->transfer_timeout = s;
break;
}
case MDC_ATTR_ID_INSTNO: {
intu16 s = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
if (pm_segment->instance_number != s) {
DEBUG("instance number mismatch %d x %d",
pm_segment->instance_number, s);
}
break;
}
default:
// unknown attr, ignore
DEBUG("segment info attr %d unknown", attr_id);
break;
}
return result;
}
int
decode_TransitedEncoding(const unsigned char *p, size_t len, TransitedEncoding *data, size_t *size)
{
size_t ret = 0, reallen;
size_t l;
int e;
memset(data, 0, sizeof(*data));
reallen = 0;
e = der_match_tag_and_length (p, len, ASN1_C_UNIV, CONS, UT_Sequence,&reallen, &l);
FORW;
{
int dce_fix;
if((dce_fix = fix_dce(reallen, &len)) < 0)
return ASN1_BAD_FORMAT;
{
size_t newlen, oldlen;
e = der_match_tag (p, len, ASN1_C_CONTEXT, CONS, 0, &l);
if (e)
return e;
else {
p += l;
len -= l;
ret += l;
e = der_get_length (p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
e = decode_integer(p, len, &(data)->tr_type, &l);
FORW;
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag (p, len, ASN1_C_CONTEXT, CONS, 1, &l);
if (e)
return e;
else {
p += l;
len -= l;
ret += l;
e = der_get_length (p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
e = decode_octet_string(p, len, &(data)->contents, &l);
FORW;
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}else
len = oldlen - newlen;
}
}
}
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}
}
if(size) *size = ret;
return 0;
fail:
free_TransitedEncoding(data);
return e;
}
/**
* Initializes a given PMStore attribute from stream content.
*
* \param pmstore the PMStore.
* \param attr_id the PMStore's attribute ID.
* \param stream the value of PMStore's attribute.
* \param data_entry output parameter to describe data value
*
* \return \b 1, if the PMStore's attribute is properly modified; \b 0 otherwise.
*
*/
int dimutil_fill_pmstore_attr(struct PMStore *pmstore, OID_Type attr_id,
ByteStreamReader *stream,
DataEntry *data_entry)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_ID_HANDLE:
pmstore->handle = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_handle(data_entry, "Handle", &pmstore->handle);
break;
case MDC_ATTR_PM_STORE_CAPAB:
pmstore->pm_store_capab = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu16(data_entry, "Capabilities", &pmstore->pm_store_capab);
break;
case MDC_ATTR_METRIC_STORE_SAMPLE_ALG:
pmstore->store_sample_algorithm = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu16(data_entry, "Store-Sample-Algorithm",
&pmstore->store_sample_algorithm);
break;
case MDC_ATTR_METRIC_STORE_CAPAC_CNT:
pmstore->store_capacity_count = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu32(data_entry, "Store-Capacity-Count",
&pmstore->store_capacity_count);
break;
case MDC_ATTR_METRIC_STORE_USAGE_CNT:
pmstore->store_usage_count = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu32(data_entry, "Store-Usage-Count",
&pmstore->store_usage_count);
break;
case MDC_ATTR_OP_STAT:
pmstore->operational_state = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu16(data_entry, "Operational-State",
&pmstore->operational_state);
break;
case MDC_ATTR_PM_STORE_LABEL_STRING:
del_octet_string(&pmstore->pm_store_label);
decode_octet_string(stream, &pmstore->pm_store_label, &error);
if (error) {
result = 0;
break;
}
data_set_label_string(data_entry, "PM-Store-Label",
&pmstore->pm_store_label);
break;
case MDC_ATTR_TIME_PD_SAMP:
pmstore->sample_period = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu32(data_entry, "Sample-Period",
&pmstore->sample_period);
break;
case MDC_ATTR_NUM_SEG:
pmstore->number_of_segments = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu16(data_entry, "Number-Of-Segments",
&pmstore->number_of_segments);
break;
case MDC_ATTR_CLEAR_TIMEOUT:
pmstore->clear_timeout = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu32(data_entry, "Clear-Timeout",
&pmstore->clear_timeout);
break;
default:
DEBUG("Can't fill pmstore attribute attribute id is %d", attr_id);
break;
}
return result;
}
/* decode the service request only */
int arf_ack_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ATOMIC_READ_FILE_DATA * data)
{
int len = 0;
int tag_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
/* check for value pointers */
if (apdu_len && data) {
len =
decode_tag_number_and_value(&apdu[0], &tag_number,
&len_value_type);
if (tag_number != BACNET_APPLICATION_TAG_BOOLEAN)
return -1;
data->endOfFile = decode_boolean(len_value_type);
if (decode_is_opening_tag_number(&apdu[len], 0)) {
data->access = FILE_STREAM_ACCESS;
/* a tag number is not extended so only one octet */
len++;
/* fileStartPosition */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_SIGNED_INT)
return -1;
len +=
decode_signed(&apdu[len], len_value_type,
&data->type.stream.fileStartPosition);
/* fileData */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_OCTET_STRING)
return -1;
len +=
decode_octet_string(&apdu[len], len_value_type,
&data->fileData);
if (!decode_is_closing_tag_number(&apdu[len], 0))
return -1;
/* a tag number is not extended so only one octet */
len++;
} else if (decode_is_opening_tag_number(&apdu[len], 1)) {
data->access = FILE_RECORD_ACCESS;
/* a tag number is not extended so only one octet */
len++;
/* fileStartRecord */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_SIGNED_INT)
return -1;
len +=
decode_signed(&apdu[len], len_value_type,
&data->type.record.fileStartRecord);
/* returnedRecordCount */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return -1;
len +=
decode_unsigned(&apdu[len], len_value_type,
&data->type.record.RecordCount);
/* fileData */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_OCTET_STRING)
return -1;
len +=
decode_octet_string(&apdu[len], len_value_type,
&data->fileData);
if (!decode_is_closing_tag_number(&apdu[len], 1))
return -1;
/* a tag number is not extended so only one octet */
len++;
} else
return -1;
}
return len;
}
/* decode the service request only */
int awf_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ATOMIC_WRITE_FILE_DATA * data)
{
int len = 0;
int tag_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
int32_t signed_value = 0;
uint32_t unsigned_value = 0;
uint16_t type = 0; /* for decoding */
/* check for value pointers */
if (apdu_len && data) {
len =
decode_tag_number_and_value(&apdu[0], &tag_number,
&len_value_type);
if (tag_number != BACNET_APPLICATION_TAG_OBJECT_ID)
return -1;
len += decode_object_id(&apdu[len], &type, &data->object_instance);
data->object_type = (BACNET_OBJECT_TYPE) type;
if (decode_is_opening_tag_number(&apdu[len], 0)) {
data->access = FILE_STREAM_ACCESS;
/* a tag number of 2 is not extended so only one octet */
len++;
/* fileStartPosition */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_SIGNED_INT)
return -1;
len += decode_signed(&apdu[len], len_value_type, &signed_value);
data->type.stream.fileStartPosition = signed_value;
/* fileData */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_OCTET_STRING)
return -1;
len +=
decode_octet_string(&apdu[len], len_value_type,
&data->fileData);
if (!decode_is_closing_tag_number(&apdu[len], 0))
return -1;
/* a tag number is not extended so only one octet */
len++;
} else if (decode_is_opening_tag_number(&apdu[len], 1)) {
data->access = FILE_RECORD_ACCESS;
/* a tag number is not extended so only one octet */
len++;
/* fileStartRecord */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_SIGNED_INT)
return -1;
len += decode_signed(&apdu[len], len_value_type, &signed_value);
data->type.record.fileStartRecord = signed_value;
/* returnedRecordCount */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return -1;
len +=
decode_unsigned(&apdu[len], len_value_type, &unsigned_value);
data->type.record.returnedRecordCount = unsigned_value;
/* fileData */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_OCTET_STRING)
return -1;
len +=
decode_octet_string(&apdu[len], len_value_type,
&data->fileData);
if (!decode_is_closing_tag_number(&apdu[len], 1))
return -1;
/* a tag number is not extended so only one octet */
len++;
} else
return -1;
}
return len;
}
/**
* Sets the specified attribute of an MDS instance.
*
* \param mds the mds.
* \param attribute a pointer to an attribute of an MDS instance.
*/
void mds_set_attribute(MDS *mds, AVA_Type *attribute)
{
int error = 0;
intu8 *value = attribute->attribute_value.value;
intu16 length = attribute->attribute_value.length;
switch (attribute->attribute_id) {
case MDC_ATTR_ID_HANDLE:
break;
case MDC_ATTR_SYS_TYPE: {
TYPE s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_type(stream, &s, &error);
if (!error) {
del_type(&mds->system_type);
mds->system_type = s;
}
free(stream);
}
break;
case MDC_ATTR_ID_MODEL: {
SystemModel s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_systemmodel(stream, &s, &error);
if (!error) {
del_systemmodel(&mds->system_model);
mds->system_model = s;
}
free(stream);
}
break;
case MDC_ATTR_SYS_ID: {
octet_string s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_octet_string(stream, &s, &error);
if (! error) {
del_octet_string(&mds->system_id);
mds->system_id = s;
}
free(stream);
}
break;
case MDC_ATTR_DEV_CONFIG_ID: {
ConfigId s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_configid(stream, &s, &error);
if (! error) {
del_configid(&mds->dev_configuration_id);
mds->dev_configuration_id = s;
}
free(stream);
}
break;
case MDC_ATTR_ATTRIBUTE_VAL_MAP: {
AttrValMap s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_attrvalmap(stream, &s, &error);
if (! error) {
del_attrvalmap(&mds->attribute_value_map);
mds->attribute_value_map = s;
}
free(stream);
}
break;
case MDC_ATTR_ID_PROD_SPECN: {
ProductionSpec s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_productionspec(stream, &s, &error);
if (! error) {
del_productionspec(&mds->production_specification);
mds->production_specification = s;
}
free(stream);
}
break;
case MDC_ATTR_MDS_TIME_INFO: {
MdsTimeInfo s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_mdstimeinfo(stream, &s, &error);
if (! error) {
del_mdstimeinfo(&mds->mds_time_info);
mds->mds_time_info = s;
}
free(stream);
}
break;
case MDC_ATTR_TIME_ABS: {
AbsoluteTime s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_absolutetime(stream, &s, &error);
if (! error) {
del_absolutetime(&mds->date_and_time);
mds->date_and_time = s;
}
free(stream);
}
break;
case MDC_ATTR_TIME_REL: {
RelativeTime s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
s = read_intu32(stream, &error);
if (! error) {
// del_relative_time not needed
mds->relative_time = s;
}
free(stream);
}
break;
case MDC_ATTR_TIME_REL_HI_RES: {
HighResRelativeTime s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_highresrelativetime(stream, &s, &error);
if (! error) {
del_highresrelativetime(&mds->hires_relative_time);
mds->hires_relative_time = s;
}
free(stream);
}
break;
case MDC_ATTR_TIME_ABS_ADJUST: {
AbsoluteTimeAdjust s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_absolutetimeadjust(stream, &s, &error);
if (! error) {
del_absolutetimeadjust(&mds->date_and_time_adjustment);
mds->date_and_time_adjustment = s;
}
free(stream);
}
break;
case MDC_ATTR_POWER_STAT: {
PowerStatus s;
// del not needed
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
s = read_intu16(stream, &error);
if (! error) {
mds->power_status = s;
}
free(stream);
}
break;
case MDC_ATTR_VAL_BATT_CHARGE: {
intu16 s;
// del not needed
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
s = read_intu16(stream, &error);
if (! error) {
mds->battery_level = s;
}
free(stream);
}
break;
case MDC_ATTR_TIME_BATT_REMAIN: {
BatMeasure s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_batmeasure(stream, &s, &error);
if (! error) {
del_batmeasure(&mds->remaining_battery_time);
mds->remaining_battery_time = s;
}
free(stream);
}
break;
case MDC_ATTR_REG_CERT_DATA_LIST: {
RegCertDataList s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_regcertdatalist(stream, &s, &error);
if (! error) {
del_regcertdatalist(&mds->reg_cert_data_list);
mds->reg_cert_data_list = s;
}
free(stream);
}
break;
case MDC_ATTR_SYS_TYPE_SPEC_LIST: {
TypeVerList s;
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
decode_typeverlist(stream, &s, &error);
if (! error) {
del_typeverlist(&mds->system_type_spec_list);
mds->system_type_spec_list = s;
}
free(stream);
}
break;
case MDC_ATTR_CONFIRM_TIMEOUT: {
RelativeTime s;
// del not needed
ByteStreamReader *stream = byte_stream_reader_instance(value, length);
s = read_intu32(stream, &error);
if (! error)
mds->confirm_timeout = s;
free(stream);
}
break;
default:
DEBUG("MDS attribute unknown: %d", attribute->attribute_id);
}
}
static int
decode_NegTokenInit(const unsigned char *p, size_t len, NegTokenInit * data, size_t * size)
{
size_t ret = 0, reallen;
size_t l;
int e;
memset(data, 0, sizeof(*data));
reallen = 0;
e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
FORW;
{
int dce_fix;
if ((dce_fix = fix_dce(reallen, &len)) < 0)
return ASN1_BAD_FORMAT;
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
if (e)
return e;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if ((dce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
FORW;
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
if (e)
(data)->reqFlags = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if ((dce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->reqFlags = malloc(sizeof(*(data)->reqFlags));
if ((data)->reqFlags == NULL)
return ENOMEM;
e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
FORW;
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
if (e)
(data)->mechToken = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if ((dce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->mechToken = malloc(sizeof(*(data)->mechToken));
if ((data)->mechToken == NULL)
return ENOMEM;
e = decode_octet_string(p, len, (data)->mechToken, &l);
FORW;
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
if (e)
(data)->mechListMIC = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if ((dce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
if ((data)->mechListMIC == NULL)
return ENOMEM;
e = decode_octet_string(p, len, (data)->mechListMIC, &l);
FORW;
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
}
}
if (size)
*size = ret;
return 0;
fail:
free_NegTokenInit(data);
return e;
}
int
decode_EncryptedData(const unsigned char *p, size_t len, EncryptedData *data, size_t *size)
{
size_t ret = 0, reallen;
size_t l;
int e;
memset(data, 0, sizeof(*data));
reallen = 0;
e = der_match_tag_and_length (p, len, ASN1_C_UNIV, CONS, UT_Sequence,&reallen, &l);
FORW;
{
int dce_fix;
if((dce_fix = fix_dce(reallen, &len)) < 0)
return ASN1_BAD_FORMAT;
{
size_t newlen, oldlen;
e = der_match_tag (p, len, ASN1_C_CONTEXT, CONS, 0, &l);
if (e)
return e;
else {
p += l;
len -= l;
ret += l;
e = der_get_length (p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
e = decode_ENCTYPE(p, len, &(data)->etype, &l);
FORW;
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag (p, len, ASN1_C_CONTEXT, CONS, 1, &l);
if (e)
(data)->kvno = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length (p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
(data)->kvno = malloc(sizeof(*(data)->kvno));
if((data)->kvno == NULL) return ENOMEM;
e = decode_integer(p, len, (data)->kvno, &l);
FORW;
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag (p, len, ASN1_C_CONTEXT, CONS, 2, &l);
if (e)
return e;
else {
p += l;
len -= l;
ret += l;
e = der_get_length (p, len, &newlen, &l);
FORW;
{
int dce_fix;
oldlen = len;
if((dce_fix = fix_dce(newlen, &len)) < 0)return ASN1_BAD_FORMAT;
e = decode_octet_string(p, len, &(data)->cipher, &l);
FORW;
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}else
len = oldlen - newlen;
}
}
}
if(dce_fix){
e = der_match_tag_and_length (p, len, (Der_class)0, (Der_type)0, 0, &reallen, &l);
FORW;
}
}
if(size) *size = ret;
return 0;
fail:
free_EncryptedData(data);
return e;
}
/**
* Initializes a given Enumeration attribute from stream content.
*
* \param enumeration the Enumeration.
* \param attr_id the Enumeration attribute ID.
* \param stream the value of Enumeration's attribute.
* \param data_entry output parameter to describe data value
*
* \return \b 1, if the Enumeration's attribute is properly modified; \b 0 otherwise.
*
*/
int dimutil_fill_enumeration_attr(struct Enumeration *enumeration,
OID_Type attr_id, ByteStreamReader *stream, DataEntry *data_entry)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_ENUM_OBS_VAL_SIMP_OID:
enumeration->enum_observed_value_simple_OID = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_observed_value_simple_OID(data_entry,
"Enum-Observed-Value-Simple-OID",
enumeration->enum_observed_value_simple_OID);
dimutil_fill_data_entry_partition_ids(data_entry, enumeration);
DEBUG("ENUM ATTR: [type:%s, value:%d]" ,
"Enum-Observed-Value-Simple-OID",
enumeration->enum_observed_value_simple_OID);
DEBUG("ENUM ATTR: [type:%s, value:%d]", "Enum-Observed-Value-Simple-OID", enumeration->enum_observed_value_simple_OID);
break;
case MDC_ATTR_ENUM_OBS_VAL_SIMP_BIT_STR:
enumeration->enum_observed_value_simple_bit_str = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_observed_value_simple_bit_str(data_entry,
"Enum-Observed-Value-Simple-Bit-Str",
enumeration->enum_observed_value_simple_bit_str);
dimutil_fill_data_entry_partition_ids(data_entry, enumeration);
DEBUG("ENUM ATTR: [type:%s, value:%d]", "Enum-Observed-Value-Simple-Bit-Str", enumeration->enum_observed_value_simple_bit_str);
break;
case MDC_ATTR_ENUM_OBS_VAL_BASIC_BIT_STR:
enumeration->enum_observed_value_basic_bit_str = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_observed_value_basic_bit_str(data_entry,
"Enum-Observed-Value-Basic-Bit-Str",
enumeration->enum_observed_value_basic_bit_str);
dimutil_fill_data_entry_partition_ids(data_entry, enumeration);
DEBUG("ENUM ATTR: [type:%s, value:%d]", "Enum-Observed-Value-Basic-Bit-Str", enumeration->enum_observed_value_basic_bit_str);
break;
case MDC_ATTR_ENUM_OBS_VAL_SIMP_STR:
del_octet_string(&enumeration->enum_observed_value_simple_str);
decode_octet_string(stream,
&(enumeration->enum_observed_value_simple_str),
&error);
if (error) {
result = 0;
break;
}
data_set_observed_value_simple_str(data_entry,
"Enum-Observed-Value-Simple-Str",
&(enumeration->enum_observed_value_simple_str));
dimutil_fill_data_entry_partition_ids(data_entry, enumeration);
DEBUG("ENUM ATTR: [type:%s, value:octect_string]", "Enum-Observed-Value-Simple-Str");
break;
case MDC_ATTR_VAL_ENUM_OBS:
del_enumobsvalue(&enumeration->enum_observed_value);
decode_enumobsvalue(stream, &(enumeration->enum_observed_value),
&error);
if (error) {
result = 0;
break;
}
data_set_enum_observed_value(data_entry,
"Enum-Observed-Value",
&(enumeration->enum_observed_value));
dimutil_fill_data_entry_partition_ids(data_entry, enumeration);
DEBUG("ENUM ATTR: [type:%s, value:Enum-Observed-Value]", "Enum-Observed-Value");
break;
case MDC_ATTR_ENUM_OBS_VAL_PART:
enumeration->enum_observed_value_partition = read_intu16(
stream, NULL);
enumeration->use_nom_partition = 1;
data_set_value_partition(data_entry,
"Enum-Observed-Value-Partition",
enumeration->enum_observed_value_partition);
DEBUG("ENUM ATTR: [type:%s, value:%d]", "Enum-Observed-Value-Partition", enumeration->enum_observed_value_partition);
break;
default:
result = dimutil_fill_metric_attr(&enumeration->metric, attr_id, stream, data_entry);
break;
}
return result;
}
static int
decode_NegTokenResp(const unsigned char *p, size_t len, NegTokenResp * data, size_t * size)
{
size_t ret = 0, reallen;
size_t l;
int e;
memset(data, 0, sizeof(*data));
reallen = 0;
e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
FORW;
{
int dce_fix;
if ((dce_fix = fix_dce(reallen, &len)) < 0)
return ASN1_BAD_FORMAT;
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
if (e)
(data)->negState = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int mydce_fix;
oldlen = len;
if ((mydce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->negState = malloc(sizeof(*(data)->negState));
if ((data)->negState == NULL)
return ENOMEM;
e = decode_enumerated(p, len, (data)->negState, &l);
FORW;
if (mydce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
if (e)
(data)->supportedMech = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int mydce_fix;
oldlen = len;
if ((mydce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->supportedMech = malloc(sizeof(*(data)->supportedMech));
if ((data)->supportedMech == NULL)
return ENOMEM;
e = decode_MechType(p, len, (data)->supportedMech, &l);
FORW;
if (mydce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
if (e)
(data)->responseToken = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int mydce_fix;
oldlen = len;
if ((mydce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->responseToken = malloc(sizeof(*(data)->responseToken));
if ((data)->responseToken == NULL)
return ENOMEM;
e = decode_octet_string(p, len, (data)->responseToken, &l);
FORW;
if (mydce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
{
size_t newlen, oldlen;
e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
if (e)
(data)->mechListMIC = NULL;
else {
p += l;
len -= l;
ret += l;
e = der_get_length(p, len, &newlen, &l);
FORW;
{
int mydce_fix;
oldlen = len;
if ((mydce_fix = fix_dce(newlen, &len)) < 0)
return ASN1_BAD_FORMAT;
(data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
if ((data)->mechListMIC == NULL)
return ENOMEM;
e = decode_octet_string(p, len, (data)->mechListMIC, &l);
FORW;
if (mydce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
} else
len = oldlen - newlen;
}
}
}
if (dce_fix) {
e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
FORW;
}
}
if (size)
*size = ret;
return 0;
fail:
free_NegTokenResp(data);
return e;
}
/**
* Initializes a given Metric attribute from stream content.
*
* \param metric the Metric.
* \param attr_id the Metric's attribute ID.
* \param stream the value of Metric's attribute.
* \param data_entry output parameter to describe data value.
*
* \return \b 1, if the Metric's attribute is properly modified; \b 0 otherwise.
*
*/
int dimutil_fill_metric_attr(struct Metric *metric, OID_Type attr_id,
ByteStreamReader *stream, DataEntry *data_entry)
{
int result = 1;
int error = 0;
switch (attr_id) {
case MDC_ATTR_ID_HANDLE:
metric->handle = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_handle(data_entry, "Handle", &metric->handle);
break;
case MDC_ATTR_ID_TYPE:
del_type(&(metric->type));
decode_type(stream, &(metric->type), &error);
if (error) {
result = 0;
break;
}
data_set_type(data_entry, "Type", &metric->type);
break;
case MDC_ATTR_SUPPLEMENTAL_TYPES:
del_supplementaltypelist(&metric->supplemental_types);
decode_supplementaltypelist(stream,
&(metric->supplemental_types),
&error);
if (error) {
result = 0;
break;
}
data_set_attribute_supplemental_types(data_entry,
"Supplemental-Types",
&metric->supplemental_types);
break;
case MDC_ATTR_METRIC_SPEC_SMALL:
del_metricspecsmall(&metric->metric_spec_small);
decode_metricspecsmall(stream,
&(metric->metric_spec_small),
&error);
if (error) {
result = 0;
break;
}
data_set_attribute_metric_spec_small(data_entry, "Metric-Spec-Small",
&metric->metric_spec_small);
break;
case MDC_ATTR_METRIC_STRUCT_SMALL:
del_metricstructuresmall(&(metric->metric_structure_small));
decode_metricstructuresmall(stream,
&(metric->metric_structure_small),
&error);
if (error) {
result = 0;
break;
}
data_set_attribute_metric_structure_small(data_entry, "Metric-Structure-Small",
&metric->metric_structure_small);
break;
case MDC_ATTR_MSMT_STAT:
metric->measurement_status = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu16(data_entry, "Measurement-Status", &metric->measurement_status);
break;
case MDC_ATTR_ID_PHYSIO:
metric->metric_id = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
metric->use_metric_id_field = 1; // TRUE
data_set_oid_type(data_entry, "Metric-Id", &metric->metric_id);
break;
case MDC_ATTR_ID_PHYSIO_LIST:
del_metricidlist(&metric->metric_id_list);
decode_metricidlist(stream, &metric->metric_id_list, &error);
if (error) {
result = 0;
break;
}
data_set_metric_id_list(data_entry, "Metric-Id-List", &metric->metric_id_list);
break;
case MDC_ATTR_METRIC_ID_PART:
metric->metric_id_partition = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
metric->use_metric_id_partition_field = 1; // TRUE
data_set_intu16(data_entry, "Metric-Id-Partition", &metric->metric_id_partition);
break;
case MDC_ATTR_UNIT_CODE:
metric->unit_code = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_oid_type(data_entry, "Unit-Code", &metric->unit_code);
break;
case MDC_ATTR_ATTRIBUTE_VAL_MAP:
del_attrvalmap(&metric->attribute_value_map);
decode_attrvalmap(stream, &(metric->attribute_value_map), &error);
if (error) {
result = 0;
break;
}
data_set_attribute_value_map(data_entry, "Attribute-Value-Map",
&metric->attribute_value_map);
break;
case MDC_ATTR_SOURCE_HANDLE_REF:
metric->source_handle_reference = read_intu16(stream, &error);
if (error) {
result = 0;
break;
}
data_set_handle(data_entry, "Source-Handle-Reference", &metric->source_handle_reference);
break;
case MDC_ATTR_ID_LABEL_STRING:
del_octet_string(&metric->label_string);
decode_octet_string(stream, &(metric->label_string), &error);
if (error) {
result = 0;
break;
}
data_set_label_string(data_entry, "Label-String", &metric->label_string);
break;
case MDC_ATTR_UNIT_LABEL_STRING:
del_octet_string(&metric->unit_label_string);
decode_octet_string(stream, &(metric->unit_label_string), &error);
if (error) {
result = 0;
break;
}
data_set_label_string(data_entry, "Unit-LabelString", &metric->unit_label_string);
break;
case MDC_ATTR_TIME_STAMP_ABS:
del_absolutetime(&metric->absolute_time_stamp);
decode_absolutetime(stream, &(metric->absolute_time_stamp), &error);
if (error) {
result = 0;
break;
}
data_set_absolute_time(data_entry, "Absolute-Time-Stamp",
&metric->absolute_time_stamp);
break;
case MDC_ATTR_TIME_STAMP_REL:
metric->relative_time_stamp = read_intu32(stream, &error);
if (error) {
result = 0;
break;
}
data_set_intu32(data_entry, "Relative-Time-Stamp", &metric->relative_time_stamp);
break;
case MDC_ATTR_TIME_STAMP_REL_HI_RES:
del_highresrelativetime(&metric->hi_res_time_stamp);
decode_highresrelativetime(stream,
&(metric->hi_res_time_stamp),
&error);
if (error) {
result = 0;
break;
}
data_set_high_res_relative_time(data_entry, "HiRes-Time-Stamp", &metric->hi_res_time_stamp);
break;
case MDC_ATTR_TIME_PD_MSMT_ACTIVE:
metric->measure_active_period = read_float(stream, &error);
if (error) {
result = 0;
break;
}
data_set_float(data_entry, "Measure-Active-Period", &metric->measure_active_period);
break;
default:
DEBUG("Unrecognized metric attribute-id %d", attr_id);
break;
}
return result;
}
