/** * @file * @brief BACnet ReadRange-Request encode and decode helper functions * @author Peter Mc Shane * @author Steve Karg * @date 2009 * @copyright SPDX-License-Identifier: GPL-2.0-or-later WITH GCC-exception-2.0 */ #include /* BACnet Stack defines - first */ #include "bacnet/bacdef.h" /* BACnet Stack API */ #include "bacnet/bacdcode.h" #include "bacnet/readrange.h" /* * ReadRange-Request ::= SEQUENCE { * objectIdentifier [0] BACnetObjectIdentifier, * propertyIdentifier [1] BACnetPropertyIdentifier, * propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array * datatype range CHOICE { * byPosition [3] SEQUENCE { * referenceIndex Unsigned, * count INTEGER * }, * -- context tag 4 is deprecated * -- context tag 5 is deprecated * bySequenceNumber [6] SEQUENCE { * referenceIndex Unsigned, * count INTEGER * }, * byTime [7] SEQUENCE { * referenceTime BACnetDateTime, * count INTEGER * } * } OPTIONAL * } */ /** * @brief Encode ReadRange-Request APDU * @param apdu Pointer to the buffer, or NULL for length * @param data Pointer to the data to encode. * @return number of bytes encoded, or zero on error. */ int read_range_encode(uint8_t *apdu, const BACNET_READ_RANGE_DATA *data) { int len = 0; /* length of each encoding */ int apdu_len = 0; /* total length of the apdu, return value */ if (!data) { return 0; } /* objectIdentifier [0] BACnetObjectIdentifier */ len = encode_context_object_id( apdu, 0, data->object_type, data->object_instance); apdu_len += len; if (apdu) { apdu += len; } /* propertyIdentifier [1] BACnetPropertyIdentifier */ len = encode_context_enumerated(apdu, 1, data->object_property); apdu_len += len; if (apdu) { apdu += len; } /* propertyArrayIndex [2] Unsigned OPTIONAL */ if (data->array_index != BACNET_ARRAY_ALL) { len = encode_context_unsigned(apdu, 2, data->array_index); apdu_len += len; if (apdu) { apdu += len; } } switch (data->RequestType) { case RR_BY_POSITION: /* byPosition [3] SEQUENCE */ len = encode_opening_tag(apdu, 3); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_unsigned(apdu, data->Range.RefIndex); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_signed(apdu, data->Count); apdu_len += len; if (apdu) { apdu += len; } len = encode_closing_tag(apdu, 3); apdu_len += len; break; case RR_BY_SEQUENCE: /* bySequenceNumber [6] SEQUENCE */ len = encode_opening_tag(apdu, 6); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_unsigned(apdu, data->Range.RefSeqNum); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_signed(apdu, data->Count); apdu_len += len; if (apdu) { apdu += len; } len = encode_closing_tag(apdu, 6); apdu_len += len; break; case RR_BY_TIME: /* byTime [7] SEQUENCE */ len = encode_opening_tag(apdu, 7); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_date(apdu, &data->Range.RefTime.date); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_time(apdu, &data->Range.RefTime.time); apdu_len += len; if (apdu) { apdu += len; } len = encode_application_signed(apdu, data->Count); apdu_len += len; if (apdu) { apdu += len; } len = encode_closing_tag(apdu, 7); apdu_len += len; break; case RR_READ_ALL: /* read the whole list - omit the range parameter */ break; default: break; } return apdu_len; } /** * @brief Encode ReadRange-Request service APDU * @param apdu Pointer to the buffer for encoding into * @param apdu_size number of bytes available in the buffer * @param data Pointer to the service data used for encoding values * @return number of bytes encoded, or zero if unable to encode or too large */ size_t read_range_request_encode( uint8_t *apdu, size_t apdu_size, const BACNET_READ_RANGE_DATA *data) { size_t apdu_len = 0; /* total length of the apdu, return value */ apdu_len = read_range_encode(NULL, data); if (apdu_len > apdu_size) { apdu_len = 0; } else { apdu_len = read_range_encode(apdu, data); } return apdu_len; } /** * Build a ReadRange request packet. * * @param apdu Pointer to the APDU buffer. * @param invoke_id Invoke ID * @param rrdata Pointer to the data used for encoding. * * @return Bytes encoded. */ int rr_encode_apdu( uint8_t *apdu, uint8_t invoke_id, const BACNET_READ_RANGE_DATA *data) { int len = 0; /* length of each encoding */ int apdu_len = 0; /* total length of the apdu, return value */ if (apdu) { apdu[0] = PDU_TYPE_CONFIRMED_SERVICE_REQUEST; apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU); apdu[2] = invoke_id; apdu[3] = SERVICE_CONFIRMED_READ_RANGE; /* service choice */ } len = 4; apdu_len += len; if (apdu) { apdu += len; } len = read_range_encode(apdu, data); apdu_len += len; return apdu_len; } /** * Decode the received ReadRange request * * @param apdu Pointer to the APDU buffer. * @param apdu_size number of bytes in the APDU buffer. * @param data Pointer to the data filled while decoding. * @return Bytes decoded, or #BACNET_STATUS_ERROR */ int rr_decode_service_request( const uint8_t *apdu, unsigned apdu_size, BACNET_READ_RANGE_DATA *data) { int len = 0, apdu_len = 0; uint32_t value32 = 0; int32_t signed_value = 0; BACNET_OBJECT_TYPE object_type = OBJECT_NONE; uint32_t enum_value = 0; BACNET_UNSIGNED_INTEGER unsigned_value = 0; BACNET_DATE *bdate = NULL; BACNET_TIME *btime = NULL; /* check for value pointers */ if (!apdu) { return BACNET_STATUS_ERROR; } /* objectIdentifier [0] BACnetObjectIdentifier */ len = bacnet_object_id_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 0, &object_type, &value32); if (len > 0) { apdu_len += len; if (data) { data->object_type = object_type; data->object_instance = value32; } } else { return BACNET_STATUS_ERROR; } /* propertyIdentifier [1] BACnetPropertyIdentifier */ len = bacnet_enumerated_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 1, &enum_value); if (len > 0) { apdu_len += len; if (data) { data->object_property = (BACNET_PROPERTY_ID)enum_value; data->Overhead = RR_OVERHEAD; /* Start with the fixed overhead */ } } else { return BACNET_STATUS_ERROR; } /* propertyArrayIndex [2] Unsigned OPTIONAL */ len = bacnet_unsigned_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 2, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->array_index = (BACNET_ARRAY_INDEX)unsigned_value; data->Overhead += RR_INDEX_OVERHEAD; } } else if (len == 0) { /* OPTIONAL missing - skip adding len */ if (data) { data->array_index = BACNET_ARRAY_ALL; } } else { return BACNET_STATUS_ERROR; } if (bacnet_is_opening_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 3, &len)) { /* byPosition [3] SEQUENCE { referenceIndex Unsigned, count INTEGER } */ apdu_len += len; if (data) { data->RequestType = RR_BY_POSITION; } len = bacnet_unsigned_application_decode( &apdu[apdu_len], apdu_size - apdu_len, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->Range.RefIndex = (uint32_t)unsigned_value; } } else { return BACNET_STATUS_ERROR; } len = bacnet_signed_application_decode( &apdu[apdu_len], apdu_size - apdu_len, &signed_value); if (len > 0) { apdu_len += len; if (data) { data->Count = signed_value; } } else { return BACNET_STATUS_ERROR; } if (bacnet_is_closing_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 3, &len)) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } } else if (bacnet_is_opening_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 6, &len)) { /* bySequenceNumber [6] SEQUENCE { referenceIndex Unsigned, count INTEGER } */ apdu_len += len; if (data) { data->RequestType = RR_BY_SEQUENCE; } len = bacnet_unsigned_application_decode( &apdu[apdu_len], apdu_size - apdu_len, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->Range.RefSeqNum = (uint32_t)unsigned_value; data->Overhead += RR_1ST_SEQ_OVERHEAD; } } else { return BACNET_STATUS_ERROR; } len = bacnet_signed_application_decode( &apdu[apdu_len], apdu_size - apdu_len, &signed_value); if (len > 0) { apdu_len += len; if (data) { data->Count = signed_value; } } else { return BACNET_STATUS_ERROR; } if (bacnet_is_closing_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 6, &len)) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } } else if (bacnet_is_opening_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 7, &len)) { /* byTime [7] SEQUENCE { referenceTime BACnetDateTime, count INTEGER } */ apdu_len += len; if (data) { data->RequestType = RR_BY_TIME; bdate = &data->Range.RefTime.date; btime = &data->Range.RefTime.time; } len = bacnet_date_application_decode( &apdu[apdu_len], apdu_size - apdu_len, bdate); if (len > 0) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } len = bacnet_time_application_decode( &apdu[apdu_len], apdu_size - apdu_len, btime); if (len > 0) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } len = bacnet_signed_application_decode( &apdu[apdu_len], apdu_size - apdu_len, &signed_value); if (len > 0) { apdu_len += len; if (data) { data->Count = signed_value; } } else { return BACNET_STATUS_ERROR; } if (bacnet_is_closing_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 7, &len)) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } } else { /* OPTIONAL range missing - skip adding len */ if (data) { data->RequestType = RR_READ_ALL; } } return apdu_len; } /* * ReadRange-ACK ::= SEQUENCE { * objectIdentifier [0] BACnetObjectIdentifier, * propertyIdentifier [1] BACnetPropertyIdentifier, * propertyArrayIndex [2] Unsigned OPTIONAL, * -- used only with array datatype * resultFlags [3] BACnetResultFlags, * itemCount [4] Unsigned, * itemData [5] SEQUENCE OF ABSTRACT-SYNTAX.&TYPE, * firstSequenceNumber [6] Unsigned32 OPTIONAL * -- used only if 'Item Count' > 0 and * -- the request was either of type 'By Sequence Number' or 'By Time' * } */ /** * @brief Encode ReadRange-ACK service APDU * @param apdu Pointer to the buffer, or NULL for length * @param data Pointer to the data to encode. * @return number of bytes encoded, or zero on error. */ int readrange_ack_encode(uint8_t *apdu, const BACNET_READ_RANGE_DATA *data) { int apdu_len = 0; /* total length of the apdu, return value */ int len = 0; if (!data) { return 0; } len = encode_context_object_id( apdu, 0, data->object_type, data->object_instance); apdu_len += len; if (apdu) { apdu += len; } len = encode_context_enumerated(apdu, 1, data->object_property); apdu_len += len; if (apdu) { apdu += len; } /* context 2 array index is optional */ if (data->array_index != BACNET_ARRAY_ALL) { len = encode_context_unsigned(apdu, 2, data->array_index); apdu_len += len; if (apdu) { apdu += len; } } /* Context 3 BACnet Result Flags */ len = encode_context_bitstring(apdu, 3, &data->ResultFlags); apdu_len += len; if (apdu) { apdu += len; } /* Context 4 Item Count */ len = encode_context_unsigned(apdu, 4, data->ItemCount); apdu_len += len; if (apdu) { apdu += len; } /* Context 5 Property list - reading the standard it looks like an * empty list still requires an opening and closing tag as the * tagged parameter is not optional */ len = encode_opening_tag(apdu, 5); apdu_len += len; if (apdu) { apdu += len; } if (data->application_data_len > 0) { for (len = 0; len < data->application_data_len; len++) { if (apdu) { apdu[len] = data->application_data[len]; } } apdu_len += len; if (apdu) { apdu += len; } } len = encode_closing_tag(apdu, 5); apdu_len += len; if (apdu) { apdu += len; } if ((data->ItemCount != 0) && (data->RequestType != RR_BY_POSITION) && (data->RequestType != RR_READ_ALL)) { /* Context 6 Sequence number of first item */ len = encode_context_unsigned(apdu, 6, data->FirstSequence); apdu_len += len; } return apdu_len; } /** * @brief Encode the ReadRange-ACK service * @param apdu Pointer to the buffer for encoding into, or NULL for length * @param apdu_size number of bytes available in the buffer * @param data Pointer to the service data to be encoded * @return number of bytes encoded, or zero if unable to encode or too large */ size_t readrange_ack_service_encode( uint8_t *apdu, size_t apdu_size, const BACNET_READ_RANGE_DATA *data) { size_t apdu_len = 0; /* total length of the apdu, return value */ apdu_len = readrange_ack_encode(NULL, data); if (apdu_len > apdu_size) { apdu_len = 0; } else { apdu_len = readrange_ack_encode(apdu, data); } return apdu_len; } /** * Build a ReadRange response packet * * @param apdu Pointer to the buffer. * @param invoke_id original invoke id for request * @param data Pointer to the property data to be encoded * @return number of bytes encoded */ int rr_ack_encode_apdu( uint8_t *apdu, uint8_t invoke_id, const BACNET_READ_RANGE_DATA *data) { int apdu_len = 0; /* total length of the apdu, return value */ int len = 0; if (apdu) { apdu[0] = PDU_TYPE_COMPLEX_ACK; /* complex ACK service */ apdu[1] = invoke_id; /* original invoke id from request */ apdu[2] = SERVICE_CONFIRMED_READ_RANGE; /* service choice */ } len = 3; apdu_len += len; if (apdu) { apdu += len; } len = readrange_ack_encode(apdu, data); apdu_len += len; return apdu_len; } /** * Decode the received ReadRange response * * @param apdu Pointer to the APDU buffer. * @param apdu_size Number of bytes in the APDU buffer. * @param data Pointer to the data filled while decoding (can be NULL). * @return number of bytes decoded, or #BACNET_STATUS_ERROR */ int rr_ack_decode_service_request( uint8_t *apdu, int apdu_size, BACNET_READ_RANGE_DATA *data) { int apdu_len = 0; int len = 0; int data_len = 0; BACNET_OBJECT_TYPE object_type = OBJECT_NONE; uint32_t value32 = 0; BACNET_UNSIGNED_INTEGER unsigned_value; BACNET_BIT_STRING *bitstring = NULL; /* Check apdu_len against the len during decode. */ if (!apdu) { return BACNET_STATUS_ERROR; } /* objectIdentifier [0] BACnetObjectIdentifier */ len = bacnet_object_id_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 0, &object_type, &value32); if (len > 0) { apdu_len += len; if (data) { data->object_type = object_type; data->object_instance = value32; } } else { return BACNET_STATUS_ERROR; } /* propertyIdentifier [1] BACnetPropertyIdentifier */ len = bacnet_enumerated_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 1, &value32); if (len > 0) { apdu_len += len; if (data) { data->object_property = (BACNET_PROPERTY_ID)value32; } } else { return BACNET_STATUS_ERROR; } /* propertyArrayIndex [2] Unsigned OPTIONAL */ len = bacnet_unsigned_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 2, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->array_index = (BACNET_ARRAY_INDEX)unsigned_value; } } else if (len == 0) { /* OPTIONAL missing - skip adding len */ if (data) { data->array_index = BACNET_ARRAY_ALL; } } else { return BACNET_STATUS_ERROR; } /* resultFlags [3] BACnetResultFlags */ if (data) { bitstring = &data->ResultFlags; } len = bacnet_bitstring_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 3, bitstring); if (len > 0) { apdu_len += len; } else { return BACNET_STATUS_ERROR; } /* itemCount [4] Unsigned */ len = bacnet_unsigned_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 4, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->ItemCount = (uint32_t)unsigned_value; } } else { return BACNET_STATUS_ERROR; } /* itemData [5] SEQUENCE OF ABSTRACT-SYNTAX.&TYPE */ if (!bacnet_is_opening_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 5, &len)) { return BACNET_STATUS_ERROR; } /* determine the length of the data blob note: APDU must include the opening tag in order to find the matching closing tag */ data_len = bacnet_enclosed_data_length(&apdu[apdu_len], apdu_size - apdu_len); if (data_len == BACNET_STATUS_ERROR) { return BACNET_STATUS_ERROR; } /* count the opening tag number length AFTER getting the data length */ apdu_len += len; /* sanity check */ if (data_len > MAX_APDU) { /* not enough size in application_data to store the data chunk */ return BACNET_STATUS_ERROR; } else if (data) { /* don't decode the application tag number or its data here */ data->application_data = &apdu[apdu_len]; data->application_data_len = data_len; } apdu_len += data_len; if (!bacnet_is_closing_tag_number( &apdu[apdu_len], apdu_size - apdu_len, 5, &len)) { return BACNET_STATUS_ERROR; } /* count the closing tag number length */ apdu_len += len; /* firstSequenceNumber [6] Unsigned32 OPTIONAL -- used only if 'Item Count' > 0 and -- the request was either of type 'By Sequence Number' -- or 'By Time' */ if (apdu_len < apdu_size) { len = bacnet_unsigned_context_decode( &apdu[apdu_len], apdu_size - apdu_len, 6, &unsigned_value); if (len > 0) { apdu_len += len; if (data) { data->FirstSequence = (uint32_t)unsigned_value; } } else if (len == 0) { /* OPTIONAL missing - skip adding len */ if (data) { data->FirstSequence = 0; } } else { return BACNET_STATUS_ERROR; } } return apdu_len; } /** * @brief Encode a ReadRange-ACK by position request * @param data Pointer to the ReadRange data structure * @param encoder Function pointer to encode the record * @param item_count Number of items in the list 1..N * @param apdu Pointer to the buffer for encoding into * @param apdu_size Size of the buffer for encoding * @return number of bytes encoded, or zero if unable to encode or too large * @note This function encodes the ReadRange-ACK by position, encoding * the records starting from a specified position and returning as many * as will fit in the provided buffer. */ int readrange_ack_by_position_encode( BACNET_READ_RANGE_DATA *data, int (*encoder)(uint32_t object_instance, uint32_t item, uint8_t *apdu), uint32_t item_count, uint8_t *apdu, size_t apdu_size) { int apdu_len = 0; /* total length of the apdu, return value */ int len = 0; int32_t ref_index; uint32_t item = 0; uint32_t first_item = 0; uint32_t last_item = 0; if (data->RequestType == RR_READ_ALL) { /* * Read all the list or as much as will fit in the buffer by selecting * a range that covers the whole list and falling through to the next * section of code */ data->Count = item_count; data->Range.RefIndex = 1; /* Starting at the beginning */ } if (data->Count < 0) { /* negative count means work from index backwards */ /* * Convert from end index/negative count to * start index/positive count and then process as * normal. This assumes that the order to return items * is always first to last, if this is not true we will * have to handle this differently. * * Note: We need to be careful about how we convert these * values due to the mix of signed and unsigned types - don't * try to optimise the code unless you understand all the * implications of the data type conversions! */ /* pull out and convert to signed */ ref_index = data->Range.RefIndex; /* Adjust backwards, remember count is -ve */ ref_index += data->Count + 1; if (ref_index < 1) { /* if count is too much, return from 1 to start index */ data->Count = data->Range.RefIndex; data->Range.RefIndex = 1; } else { /* Otherwise adjust the start index and make count +ve */ data->Range.RefIndex = ref_index; data->Count = -data->Count; } } /* From here on in we only have a starting point and a positive count */ if (data->Range.RefIndex > item_count) { /* Nothing to return as we are past the end of the list */ return 0; } /* Index of last required entry */ last_item = data->Range.RefIndex + data->Count - 1; if (last_item > item_count) { /* Capped at end of list if necessary */ last_item = item_count; } /* note: item is 1..N */ item = data->Range.RefIndex; /* Record where we started from */ first_item = item; /* encode the list */ while (item <= last_item) { len = encoder(data->object_instance, item, NULL); if ((apdu_len + len) < apdu_size) { /* If we have space in the buffer, encode the item */ len = encoder(data->object_instance, item, apdu); apdu_len += len; if (apdu) { apdu += len; } data->ItemCount++; } else { /* No more space in the buffer, stop processing */ bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_MORE_ITEMS, true); break; } item++; } /* Set remaining result flags if necessary */ if (first_item == 1) { bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_FIRST_ITEM, true); } if (last_item == item_count) { bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_LAST_ITEM, true); } return apdu_len; } /** * @brief Encode a ReadRange-ACK by sequence request * @param data Pointer to the ReadRange data structure * @param encoder Function pointer to encode the record * @param item_count Number of items in the list 1..N * @param item_count_total Number of items that have ever been in the list * @param apdu Pointer to the buffer for encoding into * @param apdu_size Size of the buffer for encoding * @return number of bytes encoded, or zero if unable to encode or too large * @note This function encodes the ReadRange-ACK by sequence, * encoding the records starting from a specified sequence number * and returning as many as will fit in the provided buffer. */ int readrange_ack_by_sequence_encode( BACNET_READ_RANGE_DATA *data, int (*encoder)(uint32_t object_instance, uint32_t item, uint8_t *apdu), uint32_t item_count, uint32_t item_count_total, uint8_t *apdu, size_t apdu_size) { int apdu_len = 0; /* total length of the apdu, return value */ int len = 0; /* Current entry number */ uint32_t uiIndex = 0; /* Entry number we started encoding from */ uint32_t uiFirst = 0; /* Entry number we finished encoding on */ uint32_t uiLast = 0; /* Tracking sequence number when encoding */ uint32_t uiSequence = 0; /* Sequence number for 1st record in log */ uint32_t uiFirstSeq = 0; /* Starting Sequence number for request */ uint32_t uiBegin = 0; /* Ending Sequence number for request */ uint32_t uiEnd = 0; /* Has request sequence range spanned the max for uint32_t? */ bool bWrapReq = false; /* Has sequence range spanned the max for uint32_t? */ bool bWrapLog = false; /* Figure out the sequence number for the first record, last is * item_count_total */ uiFirstSeq = item_count_total - (item_count - 1); /* Calculate start and end sequence numbers from request */ if (data->Count < 0) { uiBegin = data->Range.RefSeqNum + data->Count + 1; uiEnd = data->Range.RefSeqNum; } else { uiBegin = data->Range.RefSeqNum; uiEnd = data->Range.RefSeqNum + data->Count - 1; } /* See if we have any wrap around situations */ if (uiBegin > uiEnd) { bWrapReq = true; } if (uiFirstSeq > item_count_total) { bWrapLog = true; } if ((bWrapReq == false) && (bWrapLog == false)) { /* Simple case no wraps */ /* If no overlap between request range and buffer contents bail out */ if ((uiEnd < uiFirstSeq) || (uiBegin > item_count_total)) { return (0); } /* Truncate range if necessary so it is guaranteed to lie * between the first and last sequence numbers in the buffer * inclusive. */ if (uiBegin < uiFirstSeq) { uiBegin = uiFirstSeq; } if (uiEnd > item_count_total) { uiEnd = item_count_total; } } else { /* There are wrap arounds to contend with */ /* First check for non overlap condition as it is common to all */ if ((uiBegin > item_count_total) && (uiEnd < uiFirstSeq)) { return (0); } if (bWrapLog == false) { /* Only request range wraps */ if (uiEnd < uiFirstSeq) { uiEnd = item_count_total; if (uiBegin < uiFirstSeq) { uiBegin = uiFirstSeq; } } else { uiBegin = uiFirstSeq; if (uiEnd > item_count_total) { uiEnd = item_count_total; } } } else if (bWrapReq == false) { /* Only log wraps */ if (uiBegin > item_count_total) { if (uiBegin > uiFirstSeq) { uiBegin = uiFirstSeq; } } else { if (uiEnd > item_count_total) { uiEnd = item_count_total; } } } else { /* Both wrap */ if (uiBegin < uiFirstSeq) { uiBegin = uiFirstSeq; } if (uiEnd > item_count_total) { uiEnd = item_count_total; } } } /* We now have a range that lies completely within the log buffer * and we need to figure out where that starts in the buffer. */ uiIndex = uiBegin - uiFirstSeq + 1; uiSequence = uiBegin; /* Record where we started from */ uiFirst = uiIndex; /* encode the list */ while (uiSequence != uiEnd + 1) { len = encoder(data->object_instance, uiIndex, NULL); if ((apdu_len + len) < apdu_size) { /* If we have space in the buffer, encode the item */ len = encoder(data->object_instance, uiIndex, apdu); apdu_len += len; if (apdu) { apdu += len; } data->ItemCount++; } else { /* No more space in the buffer, stop processing */ bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_MORE_ITEMS, true); break; } uiLast = uiIndex; /* Record the last entry encoded */ uiIndex++; /* and get ready for next one */ uiSequence++; } /* Set remaining result flags if necessary */ if (uiFirst == 1) { bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_FIRST_ITEM, true); } if (uiLast == item_count) { bitstring_set_bit(&data->ResultFlags, RESULT_FLAG_LAST_ITEM, true); } data->FirstSequence = uiBegin; return apdu_len; }