dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Changes from r2160 broke microcontroller ports compiles. Reverting until fixed.

Browse Source
This commit is contained in:
skarg
2011-12-07 03:16:57 +00:00
parent 0f54598505
commit 4c78ada0ed
2 changed files with 126 additions and 433 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bacnet-stack/include/bacapp.h
-6
View File
@@ -203,12 +203,6 @@ extern "C" {
#endif #endif
#endif #endif
bool bacapp_extract_value(
char **out_string,
char *out_string_end,
size_t *str_len,
BACNET_OBJECT_PROPERTY_VALUE * object_value);
#ifdef BACAPP_PRINT_ENABLED #ifdef BACAPP_PRINT_ENABLED
bool bacapp_parse_application_data( bool bacapp_parse_application_data(
BACNET_APPLICATION_TAG tag_number, BACNET_APPLICATION_TAG tag_number,
bacnet-stack/src/bacapp.c
+126 -427
View File
@@ -936,19 +936,9 @@ int bacapp_data_len(
return total_len; return total_len;
} }
/* Extract the value into a string #ifdef BACAPP_PRINT_ENABLED
* Inputs: out_string - ptr to address of the buffer to append the extracted bool bacapp_print_value(
* value. If NULL, don't store anything, but still FILE * stream,
* return the size of the intended output.
* out_string_end - the address of the end of the buffer plus one
* object_value - ptr to BACnet object property value to process
* Outputs: str_len - ptr to the size of the extracted string
* Return: True if extract was successful, false otherwise.
*/
bool bacapp_extract_value(
char **out_string,
char *out_string_end,
size_t *str_len,
BACNET_OBJECT_PROPERTY_VALUE * object_value) BACNET_OBJECT_PROPERTY_VALUE * object_value)
{ {
bool status = true; /*return value */ bool status = true; /*return value */
@@ -958,9 +948,6 @@ bool bacapp_extract_value(
BACNET_APPLICATION_DATA_VALUE *value; BACNET_APPLICATION_DATA_VALUE *value;
BACNET_PROPERTY_ID property = PROP_ALL; BACNET_PROPERTY_ID property = PROP_ALL;
BACNET_OBJECT_TYPE object_type = MAX_BACNET_OBJECT_TYPE; BACNET_OBJECT_TYPE object_type = MAX_BACNET_OBJECT_TYPE;
char *extracted_value; /* to be allocated here temporarily */
char *p_extracted_value = NULL; /* pointer to the beginning of allocated block */
*str_len = 0; /* how large is the extracted string */
if (object_value && object_value->value) { if (object_value && object_value->value) {
value = object_value->value; value = object_value->value;
@@ -968,399 +955,181 @@ bool bacapp_extract_value(
object_type = object_value->object_type; object_type = object_value->object_type;
switch (value->tag) { switch (value->tag) {
case BACNET_APPLICATION_TAG_NULL: case BACNET_APPLICATION_TAG_NULL:
/* We can only have "Null" here */ fprintf(stream, "Null");
extracted_value = (char *)calloc(1, sizeof("Null"));
p_extracted_value = extracted_value;
if (extracted_value)
sprintf(extracted_value, "Null");
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_BOOLEAN: case BACNET_APPLICATION_TAG_BOOLEAN:
/* We can only have "FALSE" or "TRUE" here. Assume worst case */ fprintf(stream, "%s", value->type.Boolean ? "TRUE" : "FALSE");
extracted_value = (char *)calloc(1, sizeof("FALSE"));
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "FALSE");
if (value->type.Boolean)
sprintf(extracted_value, "TRUE");
}
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_UNSIGNED_INT: case BACNET_APPLICATION_TAG_UNSIGNED_INT:
/* %lu format should never exceed 32 characters */ fprintf(stream, "%lu",
extracted_value = (char *)calloc(1, 32); (unsigned long) value->type.Unsigned_Int);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%lu",
(unsigned long) value->type.Unsigned_Int);
}
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_SIGNED_INT: case BACNET_APPLICATION_TAG_SIGNED_INT:
/* %ld format should never exceed 32 characters */ fprintf(stream, "%ld", (long) value->type.Signed_Int);
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%ld", (long) value->type.Signed_Int);
}
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_REAL: case BACNET_APPLICATION_TAG_REAL:
/* %f format should never exceed 32 characters */ fprintf(stream, "%f", (double) value->type.Real);
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%f", (double) value->type.Real);
}
else
status = false;
break; break;
#if defined (BACAPP_DOUBLE) #if defined (BACAPP_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE: case BACNET_APPLICATION_TAG_DOUBLE:
/* %f format should never exceed 32 characters */ fprintf(stream, "%f", value->type.Double);
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%f", value->type.Double);
}
else
status = false;
break; break;
#endif #endif
case BACNET_APPLICATION_TAG_OCTET_STRING: case BACNET_APPLICATION_TAG_OCTET_STRING:
len = octetstring_length(&value->type.Octet_String); len = octetstring_length(&value->type.Octet_String);
octet_str = octetstring_value(&value->type.Octet_String);
extracted_value = (char *)calloc( for (i = 0; i < len; i++) {
2, /* 2 nibbles in a byte */ fprintf(stream, "%02X", *octet_str);
len + /* this many bytes of data*/ octet_str++;
1); /* space for NULL terminator*/ }
p_extracted_value = extracted_value;
if (extracted_value)
{
octet_str = octetstring_value(&value->type.Octet_String);
for (i = 0; i < len; i++) {
sprintf(extracted_value, "%02X", *octet_str);
octet_str++;
extracted_value += 2;
}
*extracted_value = '\0';
} else
status = false;
break; break;
case BACNET_APPLICATION_TAG_CHARACTER_STRING: case BACNET_APPLICATION_TAG_CHARACTER_STRING:
len = characterstring_length(&value->type.Character_String); len = characterstring_length(&value->type.Character_String);
char_str =
extracted_value = (char *)calloc( characterstring_value(&value->type.Character_String);
1, /* 1 char per byte of data */ fprintf(stream, "\"");
len + /* this many bytes of data */ for (i = 0; i < len; i++) {
3); /* quotes around the string, plus NULL term */ if (isprint(*((unsigned char *) char_str))) {
p_extracted_value = extracted_value; fprintf(stream, "%c", *char_str);
if (extracted_value) } else {
{ fprintf(stream, ".");
char_str = characterstring_value(&value->type.Character_String);
*extracted_value = '"';
extracted_value++;
for (i = 0; i < len; i++) {
if (isprint(*((unsigned char *) char_str))) {
*extracted_value = *char_str;
} else {
*extracted_value = '.';
}
char_str++;
extracted_value++;
} }
*extracted_value = '"'; char_str++;
extracted_value++;
*extracted_value = '\0';
} else {
status = false;
} }
fprintf(stream, "\"");
break; break;
case BACNET_APPLICATION_TAG_BIT_STRING: case BACNET_APPLICATION_TAG_BIT_STRING:
len = bitstring_bits_used(&value->type.Bit_String); len = bitstring_bits_used(&value->type.Bit_String);
fprintf(stream, "{");
/* For each bit, extract as 'true' or 'false'. Separate each bit for (i = 0; i < len; i++) {
* value with comma. Put curly braces around the bit string. fprintf(stream, "%s",
* Ensure to have space for NULL string terminator. bitstring_bit(&value->type.Bit_String,
*/ (uint8_t) i) ? "true" : "false");
extracted_value = (char *)calloc(1, if (i < len - 1)
len*(sizeof("false")-1) + // assume every bit will be false fprintf(stream, ",");
(len-1)*(sizeof(",")-1) + // separate every bit by comma
3); // open/close brace and NULL term
p_extracted_value = extracted_value;
if (extracted_value)
{
*extracted_value = '{';
extracted_value++;
for (i = 0; i < len; i++) {
sprintf(extracted_value, "%s",
bitstring_bit(&value->type.Bit_String,
(uint8_t) i) ? "true" : "false");
extracted_value += bitstring_bit(&value->type.Bit_String,
(uint8_t) i) ? sizeof("true")-1 : sizeof("false")-1;
if (i < len - 1)
{
*extracted_value = ',';
extracted_value++;
}
}
*extracted_value = '}';
extracted_value++;
*extracted_value = '\0';
} else {
status = false;
} }
fprintf(stream, "}");
break; break;
case BACNET_APPLICATION_TAG_ENUMERATED: case BACNET_APPLICATION_TAG_ENUMERATED:
switch (property) { switch (property) {
case PROP_OBJECT_TYPE: case PROP_OBJECT_TYPE:
// FIXME: this should really be a dynamic number based if (value->type.Enumerated < MAX_ASHRAE_OBJECT_TYPE) {
// on the longest string in bacnet_object_type_names fprintf(stream, "%s",
extracted_value = (char *)calloc(1, 64); bactext_object_type_name(value->type.
p_extracted_value = extracted_value; Enumerated));
if (extracted_value) } else if (value->type.Enumerated < 128) {
{ fprintf(stream, "reserved %lu",
if (value->type.Enumerated < MAX_ASHRAE_OBJECT_TYPE) { (unsigned long) value->type.Enumerated);
sprintf(extracted_value, "%s", } else {
bactext_object_type_name(value->type. fprintf(stream, "proprietary %lu",
Enumerated)); (unsigned long) value->type.Enumerated);
} else if (value->type.Enumerated < 128) {
sprintf(extracted_value, "reserved %lu",
(unsigned long) value->type.Enumerated);
} else {
sprintf(extracted_value, "proprietary %lu",
(unsigned long) value->type.Enumerated);
}
} }
else
status = false;
break; break;
case PROP_EVENT_STATE: case PROP_EVENT_STATE:
// FIXME: this should really be a dynamic number based fprintf(stream, "%s",
// on the longest string in bacnet_event_state_names bactext_event_state_name(value->type.Enumerated));
extracted_value = (char *)calloc(1, 16);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_event_state_name(value->type.Enumerated));
}
else
status = false;
break; break;
case PROP_UNITS: case PROP_UNITS:
// FIXME: this should really be a dynamic number based if (value->type.Enumerated < 256) {
// on the longest string in bacnet_engineering_unit_names fprintf(stream, "%s",
extracted_value = (char *)calloc(1, 64); bactext_engineering_unit_name(value->
p_extracted_value = extracted_value; type.Enumerated));
if (extracted_value) } else {
{ fprintf(stream, "proprietary %lu",
if (value->type.Enumerated < 256) { (unsigned long) value->type.Enumerated);
sprintf(extracted_value, "%s",
bactext_engineering_unit_name(value->
type.Enumerated));
} else {
sprintf(extracted_value, "proprietary %lu",
(unsigned long) value->type.Enumerated);
}
} }
else
status = false;
break; break;
case PROP_POLARITY: case PROP_POLARITY:
// FIXME: this should really be a dynamic number based fprintf(stream, "%s",
// on the longest string in bacnet_binary_polarity_names bactext_binary_polarity_name(value->
extracted_value = (char *)calloc(1, 8); type.Enumerated));
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_binary_polarity_name(value->
type.Enumerated));
}
else
status = false;
break; break;
case PROP_PRESENT_VALUE: case PROP_PRESENT_VALUE:
case PROP_RELINQUISH_DEFAULT: case PROP_RELINQUISH_DEFAULT:
// FIXME: this should really be a dynamic number based if (object_type < PROPRIETARY_BACNET_OBJECT_TYPE) {
// on the longest string in bacnet_binary_present_value_names fprintf(stream, "%s",
extracted_value = (char *)calloc(1, 16); bactext_binary_present_value_name(value->type.
p_extracted_value = extracted_value; Enumerated));
if (extracted_value) } else {
{ fprintf(stream, "%lu",
if (object_type < PROPRIETARY_BACNET_OBJECT_TYPE) {
sprintf(extracted_value, "%s",
bactext_binary_present_value_name(value->type.
Enumerated));
} else {
sprintf(extracted_value, "%lu",
(unsigned long) value->type.Enumerated);
}
}
else
status = false;
break;
case PROP_RELIABILITY:
// FIXME: this should really be a dynamic number based
// on the longest string in bacnet_reliability_names
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_reliability_name(value->type.Enumerated));
}
else
status = false;
break;
case PROP_SYSTEM_STATUS:
// FIXME: this should really be a dynamic number based
// on the longest string in bacnet_device_status_names
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_device_status_name(value->
type.Enumerated));
}
else
status = false;
break;
case PROP_SEGMENTATION_SUPPORTED:
// FIXME: this should really be a dynamic number based
// on the longest string in bacnet_segmentation_names
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_segmentation_name(value->type.Enumerated));
}
else
status = false;
break;
case PROP_NODE_TYPE:
// FIXME: this should really be a dynamic number based
// on the longest string in bacnet_node_type_names
extracted_value = (char *)calloc(1, 16);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%s",
bactext_node_type_name(value->type.Enumerated));
}
else
status = false;
break;
default:
/* %lu format should never exceed 32 characters */
extracted_value = (char *)calloc(1, 32);
p_extracted_value = extracted_value;
if (extracted_value)
{
sprintf(extracted_value, "%lu",
(unsigned long) value->type.Enumerated); (unsigned long) value->type.Enumerated);
} }
else break;
status = false; case PROP_RELIABILITY:
fprintf(stream, "%s",
bactext_reliability_name(value->type.Enumerated));
break;
case PROP_SYSTEM_STATUS:
fprintf(stream, "%s",
bactext_device_status_name(value->
type.Enumerated));
break;
case PROP_SEGMENTATION_SUPPORTED:
fprintf(stream, "%s",
bactext_segmentation_name(value->type.Enumerated));
break;
case PROP_NODE_TYPE:
fprintf(stream, "%s",
bactext_node_type_name(value->type.Enumerated));
break;
default:
fprintf(stream, "%lu",
(unsigned long) value->type.Enumerated);
break; break;
} }
break; break;
case BACNET_APPLICATION_TAG_DATE: case BACNET_APPLICATION_TAG_DATE:
// FIXME: this should really be a dynamic number based fprintf(stream, "%s, %s ",
// on the longest string in bacnet_day_of_week_names and bactext_day_of_week_name(value->type.Date.wday),
// bacnet_month_names bactext_month_name(value->type.Date.month));
extracted_value = (char *)calloc(1, 64); if (value->type.Date.day == 255) {
p_extracted_value = extracted_value; fprintf(stream, "(unspecified), ");
if (extracted_value) } else {
{ fprintf(stream, "%u, ", (unsigned) value->type.Date.day);
sprintf(extracted_value, "%s, %s ", }
bactext_day_of_week_name(value->type.Date.wday), if (value->type.Date.year == 2155) {
bactext_month_name(value->type.Date.month)); fprintf(stream, "(unspecified), ");
extracted_value += strlen(extracted_value); } else {
if (value->type.Date.day == 255) { fprintf(stream, "%u", (unsigned) value->type.Date.year);
sprintf(extracted_value, "(unspecified), ");
} else {
sprintf(extracted_value, "%u, ", (unsigned) value->type.Date.day);
}
extracted_value += strlen(extracted_value);
if (value->type.Date.year == 2155) {
sprintf(extracted_value, "(unspecified), ");
} else {
sprintf(extracted_value, "%u", (unsigned) value->type.Date.year);
}
} }
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_TIME: case BACNET_APPLICATION_TAG_TIME:
/* We can only have Time in HH:MM:SS.ss format here */ if (value->type.Time.hour == 255) {
extracted_value = (char *)calloc(1, sizeof("HH:MM:SS.ss")); fprintf(stream, "**:");
p_extracted_value = extracted_value; } else {
if (extracted_value) fprintf(stream, "%02u:", (unsigned) value->type.Time.hour);
{ }
if (value->type.Time.hour == 255) { if (value->type.Time.min == 255) {
sprintf(extracted_value, "**:"); fprintf(stream, "**:");
} else { } else {
sprintf(extracted_value, "%02u:", (unsigned) value->type.Time.hour); fprintf(stream, "%02u:", (unsigned) value->type.Time.min);
} }
extracted_value += 3; if (value->type.Time.sec == 255) {
if (value->type.Time.min == 255) { fprintf(stream, "**.");
sprintf(extracted_value, "**:"); } else {
} else { fprintf(stream, "%02u.", (unsigned) value->type.Time.sec);
sprintf(extracted_value, "%02u:", (unsigned) value->type.Time.min); }
} if (value->type.Time.hundredths == 255) {
extracted_value += 3; fprintf(stream, "**");
if (value->type.Time.sec == 255) { } else {
sprintf(extracted_value, "**."); fprintf(stream, "%02u",
} else { (unsigned) value->type.Time.hundredths);
sprintf(extracted_value, "%02u.", (unsigned) value->type.Time.sec);
}
extracted_value += 3;
if (value->type.Time.hundredths == 255) {
sprintf(extracted_value, "**");
} else {
sprintf(extracted_value, "%02u",
(unsigned) value->type.Time.hundredths);
}
} }
else
status = false;
break; break;
case BACNET_APPLICATION_TAG_OBJECT_ID: case BACNET_APPLICATION_TAG_OBJECT_ID:
// FIXME: this should really be a dynamic number based if (value->type.Object_Id.type < MAX_ASHRAE_OBJECT_TYPE) {
// on the longest string in bacnet_object_type_names fprintf(stream, "(%s, %lu)",
extracted_value = (char *)calloc(1, 64); bactext_object_type_name(value->type.Object_Id.type),
p_extracted_value = extracted_value; (unsigned long) value->type.Object_Id.instance);
if (extracted_value) } else if (value->type.Object_Id.type < 128) {
{ fprintf(stream, "(reserved %u, %lu)",
if (value->type.Object_Id.type < MAX_ASHRAE_OBJECT_TYPE) { (unsigned) value->type.Object_Id.type,
sprintf(extracted_value, "(%s, %lu)", (unsigned long) value->type.Object_Id.instance);
bactext_object_type_name(value->type.Object_Id.type), } else {
(unsigned long) value->type.Object_Id.instance); fprintf(stream, "(proprietary %u, %lu)",
} else if (value->type.Object_Id.type < 128) { (unsigned) value->type.Object_Id.type,
sprintf(extracted_value, "(reserved %u, %lu)", (unsigned long) value->type.Object_Id.instance);
(unsigned) value->type.Object_Id.type,
(unsigned long) value->type.Object_Id.instance);
} else {
sprintf(extracted_value, "(proprietary %u, %lu)",
(unsigned) value->type.Object_Id.type,
(unsigned long) value->type.Object_Id.instance);
}
} }
else
status = false;
break; break;
default: default:
status = false; status = false;
@@ -1368,76 +1137,6 @@ bool bacapp_extract_value(
} }
} }
if (status && p_extracted_value)
{
/* Update the size of the extracted strinig */
*str_len = strlen(p_extracted_value);
/* if there is space for the new chunk, append it to passed in string */
if (
out_string /* we were asked to store to output */
&& /* and */
(
*out_string + /* start of output string */
*str_len /* plus how much to output */
) <= /* does not put us past */
out_string_end /* the end of the string */
)
{
sprintf(*out_string, "%s", p_extracted_value);
*out_string += *str_len;
}
/* make sure to clean up after ourselves */
free(p_extracted_value);
}
return status;
}
#ifdef BACAPP_PRINT_ENABLED
/* Print the extracted value from the requested BACnet object property to the
* specified stream. If stream is NULL, do not print anything. If extraction
* failed, do not print anything. Return the status of the extraction.
*/
bool bacapp_print_value(
FILE * stream,
BACNET_OBJECT_PROPERTY_VALUE * object_value)
{
/* first, try to find out how large of a response there is */
size_t len;
bool status = bacapp_extract_value(
NULL,
NULL,
&len,
object_value);
if (status && len)
{
/* allocate the space needed to extract the response */
char *msg = (char *)calloc(1, len+1);
char *p_msg = msg;
if (msg)
{
status = bacapp_extract_value(
&msg,
msg+len,
&len,
object_value);
/* print to stream, if requested */
if (stream)
{
fprintf(stream, p_msg);
}
/* clean up */
free(p_msg);
} else
status = false;
}
return status; return status;
} }
#endif #endif