/* decode the service request only */
int whohas_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_WHO_HAS_DATA * data)
{
int len = 0;
uint8_t tag_number = 0;
uint32_t len_value = 0;
uint32_t decoded_value = 0; /* for decoding */
uint16_t decoded_type = 0; /* for decoding */
if (apdu_len && data) {
/* optional limits - must be used as a pair */
if (decode_is_context_tag(&apdu[len], 0)) {
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE)
data->low_limit = decoded_value;
if (!decode_is_context_tag(&apdu[len], 1))
return -1;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE)
data->high_limit = decoded_value;
} else {
data->low_limit = -1;
data->high_limit = -1;
}
/* object id */
if (decode_is_context_tag(&apdu[len], 2)) {
data->object_name = false;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
len +=
decode_object_id(&apdu[len], &decoded_type,
&data->object.identifier.instance);
data->object.identifier.type = decoded_type;
}
/* object name */
else if (decode_is_context_tag(&apdu[len], 3)) {
data->object_name = true;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
len +=
decode_character_string(&apdu[len], len_value,
&data->object.name);
}
/* missing required parameters */
else
return -1;
}
return len;
}
/* decode the service request only */
int whois_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
int32_t * pLow_limit,
int32_t * pHigh_limit)
{
int len = 0;
uint8_t tag_number = 0;
uint32_t len_value = 0;
uint32_t decoded_value = 0;
/* optional limits - must be used as a pair */
if (apdu_len) {
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number != 0)
return -1;
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE) {
if (pLow_limit)
*pLow_limit = decoded_value;
}
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number != 1)
return -1;
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE) {
if (pHigh_limit)
*pHigh_limit = decoded_value;
}
}
return len;
}
void ProcessPTA(
BACNET_PRIVATE_TRANSFER_DATA * data)
{
int iLen; /* Index to current location in data */
uint32_t uiErrorCode;
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
iLen = 0;
/* Error code is returned for read and write operations */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&uiErrorCode);
if (data->serviceNumber == MY_SVC_READ) { /* Read I/O block so should be full block of data or error */
/* Decode the error type and if necessary block number and then fetch the info */
if (uiErrorCode == MY_ERR_OK) {
/* Block Number */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
cBlockNumber = (char) ulTemp;
DecodeBlock(cBlockNumber, &data->serviceParameters[iLen]);
} else { /* Read error */
printf("Private Transfer read operation returned error code: %u\n",
uiErrorCode);
return;
}
} else { /* Write I/O block - should just be an OK type message */
printf("Private Transfer write operation returned error code: %u\n",
uiErrorCode);
}
}
/* decode the service request only */
int whois_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
int32_t * pLow_limit,
int32_t * pHigh_limit)
{
unsigned int len = 0;
uint8_t tag_number = 0;
uint32_t len_value = 0;
uint32_t decoded_value = 0;
/* optional limits - must be used as a pair */
if (apdu_len) {
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number != 0) {
return BACNET_STATUS_ERROR;
}
if (apdu_len > (unsigned)len) {
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE) {
if (pLow_limit) {
*pLow_limit = decoded_value;
}
}
if (apdu_len > (unsigned)len) {
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number != 1) {
return BACNET_STATUS_ERROR;
}
if (apdu_len > (unsigned)len) {
len += decode_unsigned(&apdu[len], len_value, &decoded_value);
if (decoded_value <= BACNET_MAX_INSTANCE) {
if (pHigh_limit) {
*pHigh_limit = decoded_value;
}
}
} else {
return BACNET_STATUS_ERROR;
}
} else {
return BACNET_STATUS_ERROR;
}
} else {
return BACNET_STATUS_ERROR;
}
} else {
if (pLow_limit) {
*pLow_limit = -1;
}
if (pHigh_limit) {
*pHigh_limit = -1;
}
len = 0;
}
return (int)len;
}
void
decode_cookie(DBusMessageIter *iter, int *err, cookie_t *pval)
{
unsigned tmp = 0;
decode_unsigned(iter, err, &tmp);
*pval = tmp;
}
int rp_ack_decode_service_request(
uint8_t * apdu,
int apdu_len, /* total length of the apdu */
BACNET_READ_PROPERTY_DATA * rpdata)
{
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
int tag_len = 0; /* length of tag decode */
int len = 0; /* total length of decodes */
uint16_t object = 0; /* object type */
uint32_t property = 0; /* for decoding */
uint32_t array_value = 0; /* for decoding */
memset(prop_name,0,100);
/* FIXME: check apdu_len against the len during decode */
/* Tag 0: Object ID */
if (!decode_is_context_tag(&apdu[0], 0))
return -1;
len = 1;
len += decode_object_id(&apdu[len], &object, &rpdata->object_instance);
rpdata->object_type = (BACNET_OBJECT_TYPE) object;
/* Tag 1: Property ID */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value_type);
if (tag_number != 1)
return -1;
len += decode_enumerated(&apdu[len], len_value_type, &property);
rpdata->object_property = (BACNET_PROPERTY_ID) property;
if(rpdata->object_property < PROP_EGRESS_ACTIVE)
strcpy_s(prop_name,100,bacnet_property_names[rpdata->object_property ].pString);
/* Tag 2: Optional Array Index */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value_type);
if (tag_number == 2) {
len += tag_len;
len += decode_unsigned(&apdu[len], len_value_type, &array_value);
rpdata->array_index = array_value;
} else
rpdata->array_index = BACNET_ARRAY_ALL;
/* Tag 3: opening context tag */
if (decode_is_opening_tag_number(&apdu[len], 3)) {
/* a tag number of 3 is not extended so only one octet */
len++;
/* don't decode the application tag number or its data here */
rpdata->application_data = &apdu[len];
rpdata->application_data_len = apdu_len - len - 1 /*closing tag */ ;
/* len includes the data and the closing tag */
len = apdu_len;
} else {
return -1;
}
return len;
}
void
decode_action(DBusMessageIter *iter, int *err, alarm_action_t *act)
{
decode_unsigned (iter, err, &act->flags);
decode_dstring (iter, err, &act->label);
decode_dstring (iter, err, &act->exec_command);
decode_dstring (iter, err, &act->dbus_interface);
decode_dstring (iter, err, &act->dbus_service);
decode_dstring (iter, err, &act->dbus_path);
decode_dstring (iter, err, &act->dbus_name);
decode_dstring (iter, err, &act->dbus_args);
}
int rpm_ack_decode_object_property(
uint8_t * apdu,
unsigned apdu_len,
BACNET_PROPERTY_ID * object_property,
uint32_t * array_index)
{
unsigned len = 0;
unsigned tag_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint32_t property = 0; /* for decoding */
uint32_t array_value = 0; /* for decoding */
/* check for valid pointers */
if (apdu && apdu_len && object_property && array_index) {
/* Tag 2: propertyIdentifier */
if (!IS_CONTEXT_SPECIFIC(apdu[len]))
return -1;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number != 2)
return -1;
len += decode_enumerated(&apdu[len], len_value_type, &property);
if (object_property)
*object_property = (BACNET_PROPERTY_ID) property;
/* Tag 3: Optional propertyArrayIndex */
if ((len < apdu_len) && IS_CONTEXT_SPECIFIC(apdu[len]) &&
(!IS_CLOSING_TAG(apdu[len]))) {
tag_len =
(unsigned) decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number == 3) {
len += tag_len;
len +=
decode_unsigned(&apdu[len], len_value_type, &array_value);
*array_index = array_value;
} else {
*array_index = BACNET_ARRAY_ALL;
}
} else {
*array_index = BACNET_ARRAY_ALL;
}
}
return (int) len;
}
static void ProcessPT(
BACNET_PRIVATE_TRANSFER_DATA * data)
{
int iLen; /* Index to current location in data */
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsTemp;
iLen = 0;
/* Decode the block number */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
/* Bail out early if wrong type */
/* and signal unexpected error */
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
cBlockNumber = (char) ulTemp;
if (cBlockNumber < MY_MAX_BLOCK) {
if (data->serviceNumber == MY_SVC_READ) {
/* Read Response is an unsigned int with
0 for success or a non 0 error code
For a successful read the 0 success
code is followed by the block number
and then the block contents which
consist of 2 unsigned ints (in 0 to 255
range as they are really chars) a single
precision real and a string which
will be up to 32 chars + a nul */
iLen = 0;
/* Signal success */
iLen += encode_application_unsigned(&IOBufferPT[iLen], MY_ERR_OK);
/* Followed by the block number */
iLen +=
encode_application_unsigned(&IOBufferPT[iLen], cBlockNumber);
/* And Then the block contents */
iLen +=
encode_application_unsigned(&IOBufferPT[iLen],
MyData[(int8_t) cBlockNumber].cMyByte1);
iLen +=
encode_application_unsigned(&IOBufferPT[iLen],
MyData[(int8_t) cBlockNumber].cMyByte2);
iLen +=
encode_application_real(&IOBufferPT[iLen],
MyData[(int8_t) cBlockNumber].fMyReal);
characterstring_init_ansi(&bsTemp,
(char *) MyData[(int8_t) cBlockNumber].sMyString);
iLen +=
encode_application_character_string(&IOBufferPT[iLen],
&bsTemp);
} else {
/* Write operation */
/* Write block consists of the block number
followed by the block contents as
described above for the read operation.
The returned result is an unsigned
response which is 0 for success and
a non 0 error code otherwise. */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
MyData[(int8_t) cBlockNumber].cMyByte1 = (char) ulTemp;
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
MyData[(int8_t) cBlockNumber].cMyByte2 = (char) ulTemp;
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_real(&data->serviceParameters[iLen],
&MyData[(int8_t) cBlockNumber].fMyReal);
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING) {
data->serviceParametersLen = 0;
return;
}
decode_character_string(&data->serviceParameters[iLen],
len_value_type, &bsTemp);
/* Only copy as much as we can accept */
strncpy((char *) MyData[(int8_t) cBlockNumber].sMyString,
characterstring_value(&bsTemp), MY_MAX_STR);
/* Make sure it is nul terminated */
MyData[(int8_t) cBlockNumber].sMyString[MY_MAX_STR] = '\0';
/* Signal success */
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_OK);
}
} else {
/* Signal bad index */
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_BAD_INDEX);
}
data->serviceParametersLen = iLen;
data->serviceParameters = IOBufferPT;
}
/* decode the service request only */
int arf_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;
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 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);
/* requestedOctetCount */
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.stream.requestedOctetCount);
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);
/* RecordCount */
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);
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 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;
}
int bacapp_decode_property_state(
uint8_t * apdu,
BACNET_PROPERTY_STATE * value)
{
int len = 0;
uint32_t len_value_type;
int section_length;
uint32_t enumValue;
section_length =
decode_tag_number_and_value(&apdu[len], (uint8_t *) & value->tag,
&len_value_type);
if (-1 == section_length) {
return -1;
}
len += section_length;
switch (value->tag) {
case BOOLEAN_VALUE:
value->state.booleanValue = decode_boolean(len_value_type);
break;
case BINARY_VALUE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.binaryValue = (BACNET_BINARY_PV) enumValue;
break;
case EVENT_TYPE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.eventType = (BACNET_EVENT_TYPE) enumValue;
break;
case POLARITY:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.polarity = (BACNET_POLARITY) enumValue;
break;
case PROGRAM_CHANGE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.programChange = (BACNET_PROGRAM_REQUEST) enumValue;
break;
case PROGRAM_STATE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.programState = (BACNET_PROGRAM_STATE) enumValue;
break;
case REASON_FOR_HALT:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.programError = (BACNET_PROGRAM_ERROR) enumValue;
break;
case RELIABILITY:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.reliability = (BACNET_RELIABILITY) enumValue;
break;
case STATE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.state = (BACNET_EVENT_STATE) enumValue;
break;
case SYSTEM_STATUS:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.systemStatus = (BACNET_DEVICE_STATUS) enumValue;
break;
case UNITS:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.units = (BACNET_ENGINEERING_UNITS) enumValue;
break;
case UNSIGNED_VALUE:
if (-1 == (section_length =
decode_unsigned(&apdu[len], len_value_type,
&value->state.unsignedValue))) {
return -1;
}
break;
case LIFE_SAFETY_MODE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.lifeSafetyMode = (BACNET_LIFE_SAFETY_MODE) enumValue;
break;
case LIFE_SAFETY_STATE:
if (-1 == (section_length =
decode_enumerated(&apdu[len], len_value_type,
&enumValue))) {
return -1;
}
value->state.lifeSafetyState =
(BACNET_LIFE_SAFETY_STATE) enumValue;
break;
default:
return -1;
}
len += section_length;
return len;
}
void DecodeBlock(
char cBlockNum,
uint8_t * pData)
{
int iLen;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsName;
DATABLOCK Response;
iLen = 0;
if (cBlockNum >= MY_MAX_BLOCK)
return;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte1 = (char) ulTemp;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte2 = (char) ulTemp;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL)
return;
iLen += decode_real(&pData[iLen], &Response.fMyReal);
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING)
return;
iLen += decode_character_string(&pData[iLen], len_value_type, &bsName);
strncpy(Response.sMyString, characterstring_value(&bsName), MY_MAX_STR);
Response.sMyString[MY_MAX_STR] = '\0'; /* Make sure it is nul terminated */
printf("Private Transfer Read Block Response\n");
printf("Data Block: %d\n", (int) cBlockNum);
printf(" First Byte : %d\n", (int) Response.cMyByte1);
printf(" Second Byte : %d\n", (int) Response.cMyByte2);
printf(" Real : %f\n", Response.fMyReal);
printf(" String : %s\n\n", Response.sMyString);
}
/* BACnetPropertyReference ::= SEQUENCE {
propertyIdentifier [0] BACnetPropertyIdentifier,
propertyArrayIndex [1] Unsigned OPTIONAL
--used only with array datatype
-- if omitted with an array the entire array is referenced
}
*/
int rpm_decode_object_property(
uint8_t * apdu,
unsigned apdu_len,
BACNET_RPM_DATA * rpmdata)
{
unsigned len = 0;
unsigned option_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint32_t property = 0; /* for decoding */
uint32_t array_value = 0; /* for decoding */
/* check for valid pointers */
if (apdu && apdu_len && rpmdata) {
/* Tag 0: propertyIdentifier */
if (!IS_CONTEXT_SPECIFIC(apdu[len])) {
rpmdata->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number != 0) {
rpmdata->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
/* Should be at least the unsigned value + 1 tag left */
if ((len + len_value_type) >= apdu_len) {
rpmdata->error_code = ERROR_CODE_REJECT_MISSING_REQUIRED_PARAMETER;
return BACNET_STATUS_REJECT;
}
len += decode_enumerated(&apdu[len], len_value_type, &property);
rpmdata->object_property = (BACNET_PROPERTY_ID) property;
/* Assume most probable outcome */
rpmdata->array_index = BACNET_ARRAY_ALL;
/* Tag 1: Optional propertyArrayIndex */
if (IS_CONTEXT_SPECIFIC(apdu[len]) && !IS_CLOSING_TAG(apdu[len])) {
option_len =
(unsigned) decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number == 1) {
len += option_len;
/* Should be at least the unsigned array index + 1 tag left */
if ((len + len_value_type) >= apdu_len) {
rpmdata->error_code =
ERROR_CODE_REJECT_MISSING_REQUIRED_PARAMETER;
return BACNET_STATUS_REJECT;
}
len +=
decode_unsigned(&apdu[len], len_value_type, &array_value);
rpmdata->array_index = array_value;
}
}
}
return (int) len;
}
/* FIXME: there could be various error messages returned
using unique values less than zero */
int wp_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_WRITE_PROPERTY_DATA * wpdata)
{
int len = 0;
int tag_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint16_t type = 0; /* for decoding */
uint32_t property = 0; /* for decoding */
uint32_t unsigned_value = 0;
int i = 0; /* loop counter */
/* check for value pointers */
if (apdu_len && wpdata) {
/* Tag 0: Object ID */
if (!decode_is_context_tag(&apdu[len++], 0))
return -1;
len += decode_object_id(&apdu[len], &type, &wpdata->object_instance);
wpdata->object_type = (BACNET_OBJECT_TYPE) type;
/* Tag 1: Property ID */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number != 1)
return -1;
len += decode_enumerated(&apdu[len], len_value_type, &property);
wpdata->object_property = (BACNET_PROPERTY_ID) property;
/* Tag 2: Optional Array Index */
/* note: decode without incrementing len so we can check for opening tag */
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number == 2) {
len += tag_len;
len +=
decode_unsigned(&apdu[len], len_value_type, &unsigned_value);
wpdata->array_index = unsigned_value;
} else
wpdata->array_index = BACNET_ARRAY_ALL;
/* Tag 3: opening context tag */
if (!decode_is_opening_tag_number(&apdu[len], 3))
return -1;
/* determine the length of the data blob */
wpdata->application_data_len =
bacapp_data_len(&apdu[len], apdu_len - len,
(BACNET_PROPERTY_ID) property);
/* a tag number of 3 is not extended so only one octet */
len++;
/* copy the data from the APDU */
for (i = 0; i < wpdata->application_data_len; i++) {
wpdata->application_data[i] = apdu[len + i];
}
/* add on the data length */
len += wpdata->application_data_len;
if (!decode_is_closing_tag_number(&apdu[len], 3))
return -2;
/* a tag number of 3 is not extended so only one octet */
len++;
/* Tag 4: optional Priority - assumed MAX if not explicitly set */
wpdata->priority = BACNET_MAX_PRIORITY;
if ((unsigned) len < apdu_len) {
tag_len =
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number == 4) {
len += tag_len;
len =
decode_unsigned(&apdu[len], len_value_type,
&unsigned_value);
if ((unsigned_value >= BACNET_MIN_PRIORITY)
&& (unsigned_value <= BACNET_MAX_PRIORITY)) {
wpdata->priority = (uint8_t) unsigned_value;
} else
return -5;
}
}
}
return len;
}
/**
* Decodes from bytes into the lighting-command structure
*
* @param apdu - buffer to hold the bytes
* @param apdu_max_len - number of bytes in the buffer to decode
* @param value - lighting command value to place the decoded values
*
* @return number of bytes encoded
*/
int lighting_command_decode(
uint8_t * apdu,
unsigned apdu_max_len,
BACNET_LIGHTING_COMMAND * data)
{
int len = 0;
int apdu_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint32_t unsigned_value = 0;
float real_value = 0.0;
unused_var(apdu_max_len);
/* check for value pointers */
if (apdu_max_len && data) {
/* Tag 0: operation */
if (!decode_is_context_tag(&apdu[apdu_len], 0))
return BACNET_STATUS_ERROR;
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len =
decode_enumerated(&apdu[apdu_len], len_value_type, &unsigned_value);
if (len > 0) {
data->operation = unsigned_value;
}
apdu_len += len;
/* Tag 1: target-level - OPTIONAL */
if (decode_is_context_tag(&apdu[apdu_len], 1)) {
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len = decode_real(&apdu[apdu_len], &real_value);
data->target_level = real_value;
apdu_len += len;
data->use_target_level = true;
} else {
data->use_target_level = false;
}
/* Tag 2: ramp-rate - OPTIONAL */
if (decode_is_context_tag(&apdu[apdu_len], 2)) {
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len = decode_real(&apdu[apdu_len], &real_value);
data->ramp_rate = real_value;
data->use_ramp_rate = true;
} else {
data->use_ramp_rate = false;
}
/* Tag 3: step-increment - OPTIONAL */
if (decode_is_context_tag(&apdu[apdu_len], 3)) {
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len = decode_real(&apdu[apdu_len], &real_value);
data->step_increment = real_value;
data->use_step_increment = true;
} else {
data->use_step_increment = false;
}
/* Tag 4: fade-time - OPTIONAL */
if (decode_is_context_tag(&apdu[apdu_len], 4)) {
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len = decode_unsigned(&apdu[apdu_len], len_value_type,
&unsigned_value);
data->fade_time = unsigned_value;
data->use_fade_time = true;
} else {
data->use_fade_time = false;
}
/* Tag 5: priority - OPTIONAL */
if (decode_is_context_tag(&apdu[apdu_len], 4)) {
len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += len;
len = decode_unsigned(&apdu[apdu_len], len_value_type,
&unsigned_value);
data->priority = unsigned_value;
data->use_priority = true;
} else {
data->use_priority = false;
}
}
return len;
}
void
decode_event(DBusMessageIter *iter, int *err, alarm_event_t *eve)
{
size_t action_cnt = 0;
size_t recurrence_cnt = 0;
alarm_event_del_actions(eve);
alarm_event_del_recurrences(eve);
decode_cookie (iter, err, &eve->ALARMD_PRIVATE(cookie));
decode_time (iter, err, &eve->ALARMD_PRIVATE(trigger));
decode_dstring (iter, err, &eve->title);
decode_dstring (iter, err, &eve->message);
decode_dstring (iter, err, &eve->sound);
decode_dstring (iter, err, &eve->icon);
decode_unsigned (iter, err, &eve->flags);
decode_dstring (iter, err, &eve->alarm_appid);
decode_time (iter, err, &eve->alarm_time);
decode_tm (iter, err, &eve->alarm_tm);
decode_dstring (iter, err, &eve->alarm_tz);
decode_time (iter, err, &eve->recur_secs);
decode_int (iter, err, &eve->recur_count);
decode_time (iter, err, &eve->snooze_secs);
decode_time (iter, err, &eve->snooze_total);
decode_size (iter, err, &action_cnt);
decode_int (iter, err, &eve->response);
/* - - - - - - - - - - - - - - - - - - - *
* action table
* - - - - - - - - - - - - - - - - - - - */
alarm_action_t *act = alarm_event_add_actions(eve, action_cnt);
for( size_t i = 0; i < action_cnt; ++i )
{
decode_action(iter, err, &act[i]);
}
/* - - - - - - - - - - - - - - - - - - - *
* recurrence table
* - - - - - - - - - - - - - - - - - - - */
decode_size (iter, err, &recurrence_cnt);
alarm_recur_t *rec = alarm_event_add_recurrences(eve, recurrence_cnt);
for( size_t i = 0; i < recurrence_cnt; ++i )
{
decode_recur(iter, err, &rec[i]);
}
/* - - - - - - - - - - - - - - - - - - - *
* attribute table sent by libalarm >= 1.0.4
* - - - - - - - - - - - - - - - - - - - */
if( !decode_eom_p(iter, err) )
{
size_t count = 0;
decode_size (iter, err, &count);
for( size_t i = 0; i < count; ++i )
{
alarm_attr_t *att = alarm_event_add_attr(eve, "\x7f");
decode_attr(iter, err, att);
}
}
}
int wpm_decode_object_property(
uint8_t * apdu,
uint16_t apdu_len,
BACNET_WRITE_PROPERTY_DATA * wp_data)
{
uint8_t tag_number = 0;
uint32_t len_value = 0;
uint32_t ulVal = 0;
int len = 0, i = 0;
if ((apdu) && (apdu_len) && (wp_data)) {
wp_data->array_index = BACNET_ARRAY_ALL;
wp_data->priority = BACNET_MAX_PRIORITY;
wp_data->application_data_len = 0;
/* tag 0 - Property Identifier */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number == 0) {
len += decode_enumerated(&apdu[len], len_value, &ulVal);
wp_data->object_property = ulVal;
} else {
wp_data->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
/* tag 1 - Property Array Index - optional */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number == 1) {
len += decode_unsigned(&apdu[len], len_value, &ulVal);
wp_data->array_index = ulVal;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
}
/* tag 2 - Property Value */
if ((tag_number == 2) && (decode_is_opening_tag(&apdu[len - 1]))) {
len--;
wp_data->application_data_len =
bacapp_data_len(&apdu[len], (unsigned) (apdu_len - len),
wp_data->object_property);
len++;
/* copy application data */
for (i = 0; i < wp_data->application_data_len; i++) {
wp_data->application_data[i] = apdu[len + i];
}
len += wp_data->application_data_len;
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value);
/* closing tag 2 */
if ((tag_number != 2) && (decode_is_closing_tag(&apdu[len - 1]))) {
wp_data->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
} else {
wp_data->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
/* tag 3 - Priority - optional */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number == 3) {
len += decode_unsigned(&apdu[len], len_value, &ulVal);
wp_data->priority = ulVal;
} else
len--;
} else {
wp_data->error_code = ERROR_CODE_REJECT_MISSING_REQUIRED_PARAMETER;
return BACNET_STATUS_REJECT;
}
return len;
}
/* decode the service request only */
int rp_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_READ_PROPERTY_DATA * rpdata)
{
unsigned len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint16_t type = 0; /* for decoding */
uint32_t property = 0; /* for decoding */
uint32_t array_value = 0; /* for decoding */
/* check for value pointers */
if (rpdata != NULL) {
/* Must have at least 2 tags, an object id and a property identifier
* of at least 1 byte in length to have any chance of parsing */
if (apdu_len < 7) {
rpdata->error_code = ERROR_CODE_REJECT_MISSING_REQUIRED_PARAMETER;
return BACNET_STATUS_REJECT;
}
/* Tag 0: Object ID */
if (!decode_is_context_tag(&apdu[len++], 0)) {
rpdata->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
len += decode_object_id(&apdu[len], &type, &rpdata->object_instance);
rpdata->object_type = (BACNET_OBJECT_TYPE) type;
/* Tag 1: Property ID */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if (tag_number != 1) {
rpdata->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
len += decode_enumerated(&apdu[len], len_value_type, &property);
rpdata->object_property = (BACNET_PROPERTY_ID) property;
/* Tag 2: Optional Array Index */
if (len < apdu_len) {
len +=
decode_tag_number_and_value(&apdu[len], &tag_number,
&len_value_type);
if ((tag_number == 2) && (len < apdu_len)) {
len +=
decode_unsigned(&apdu[len], len_value_type, &array_value);
rpdata->array_index = array_value;
} else {
rpdata->error_code = ERROR_CODE_REJECT_INVALID_TAG;
return BACNET_STATUS_REJECT;
}
} else
rpdata->array_index = BACNET_ARRAY_ALL;
}
if (len < apdu_len) {
/* If something left over now, we have an invalid request */
rpdata->error_code = ERROR_CODE_REJECT_TOO_MANY_ARGUMENTS;
return BACNET_STATUS_REJECT;
}
return (int) len;
}
