From c3f87b3ad362a6d7aea620d2192d50116bbcd438 Mon Sep 17 00:00:00 2001 From: skarg Date: Mon, 13 Feb 2006 21:47:38 +0000 Subject: [PATCH] Created WhoHas service encoding, decoding, and unit test using Code:Blocks on Win32. --- bacnet-stack/whohas.c | 279 ++++++++++++++++++++++++++++++++++++++++ bacnet-stack/whohas.cbp | 92 +++++++++++++ bacnet-stack/whohas.h | 86 +++++++++++++ bacnet-stack/whohas.mak | 34 +++++ 4 files changed, 491 insertions(+) create mode 100644 bacnet-stack/whohas.c create mode 100644 bacnet-stack/whohas.cbp create mode 100644 bacnet-stack/whohas.h create mode 100644 bacnet-stack/whohas.mak diff --git a/bacnet-stack/whohas.c b/bacnet-stack/whohas.c new file mode 100644 index 00000000..d3c19184 --- /dev/null +++ b/bacnet-stack/whohas.c @@ -0,0 +1,279 @@ +/*####COPYRIGHTBEGIN#### + ------------------------------------------- + Copyright (C) 2006 Steve Karg + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + The Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA. + + As a special exception, if other files instantiate templates or + use macros or inline functions from this file, or you compile + this file and link it with other works to produce a work based + on this file, this file does not by itself cause the resulting + work to be covered by the GNU General Public License. However + the source code for this file must still be made available in + accordance with section (3) of the GNU General Public License. + + This exception does not invalidate any other reasons why a work + based on this file might be covered by the GNU General Public + License. + ------------------------------------------- +####COPYRIGHTEND####*/ +#include +#include "bacenum.h" +#include "bacdcode.h" +#include "bacdef.h" +#include "whohas.h" + +/* encode service - use -1 for limit for unlimited */ + +int whohas_encode_apdu( + uint8_t *apdu, + BACNET_WHO_HAS_DATA *data) +{ + int len = 0; // length of each encoding + int apdu_len = 0; // total length of the apdu, return value + + if (apdu && data) { + apdu[0] = PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST; + apdu[1] = SERVICE_UNCONFIRMED_WHO_IS; // service choice + apdu_len = 2; + // optional limits - must be used as a pair + if ((data->low_limit >= 0) && (data->low_limit <= BACNET_MAX_INSTANCE) && + (data->high_limit >= 0) && (data->high_limit <= BACNET_MAX_INSTANCE)) + { + len = encode_context_unsigned( + &apdu[apdu_len], + 0, + data->low_limit); + apdu_len += len; + len = encode_context_unsigned( + &apdu[apdu_len], + 1, + data->high_limit); + apdu_len += len; + } + if (data->object_name) + { + len = encode_context_character_string( + &apdu[apdu_len], + 3, + &data->object.name); + apdu_len += len; + } + else + { + len = encode_context_object_id( + &apdu[apdu_len], + 2, + data->object.identifier.type, + data->object.identifier.instance); + apdu_len += len; + } + } + + return apdu_len; +} + +// 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 */ + int 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; +} + +int whohas_decode_apdu( + uint8_t *apdu, + unsigned apdu_len, + BACNET_WHO_HAS_DATA *data) +{ + int len = 0; + + if (!apdu) + return -1; + // optional checking - most likely was already done prior to this call + if (apdu[0] != PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST) + return -1; + if (apdu[1] != SERVICE_UNCONFIRMED_WHO_IS) + return -1; + // optional limits - must be used as a pair + if (apdu_len > 2) + { + len = whohas_decode_service_request( + &apdu[2], + apdu_len - 2, + data); + } + + return len; +} + +#ifdef TEST +#include +#include +#include "ctest.h" + +void testWhoHasData(Test * pTest, BACNET_WHO_HAS_DATA *data) +{ + uint8_t apdu[480] = {0}; + int len = 0; + int apdu_len = 0; + BACNET_WHO_HAS_DATA test_data; + + len = whohas_encode_apdu( + &apdu[0], + data); + ct_test(pTest, len != 0); + apdu_len = len; + + len = whohas_decode_apdu( + &apdu[0], + apdu_len, + &test_data); + ct_test(pTest, len != -1); + ct_test(pTest, test_data.low_limit == data->low_limit); + ct_test(pTest, test_data.high_limit == data->high_limit); + ct_test(pTest, test_data.object_name == data->object_name); + /* Object ID */ + if (data->object_name == false) + { + ct_test(pTest, test_data.object.identifier.type == + data->object.identifier.type); + ct_test(pTest, test_data.object.identifier.instance == + data->object.identifier.instance); + } + /* Object Name */ + else + { + ct_test(pTest, characterstring_same( + &test_data.object.name,&data->object.name)); + } +} + +void testWhoHas(Test * pTest) +{ + BACNET_WHO_HAS_DATA data; + + data.low_limit = -1; + data.high_limit = -1; + data.object_name = false; + data.object.identifier.type = OBJECT_ANALOG_INPUT; + data.object.identifier.instance = 1; + testWhoHasData(pTest,&data); + + for ( + data.low_limit = 0; + data.low_limit <= BACNET_MAX_INSTANCE; + data.low_limit += (BACNET_MAX_INSTANCE/4)) + { + for ( + data.high_limit = 0; + data.high_limit <= BACNET_MAX_INSTANCE; + data.high_limit += (BACNET_MAX_INSTANCE/4)) + { + data.object_name = false; + for ( + data.object.identifier.type = OBJECT_ANALOG_INPUT; + data.object.identifier.type <= MAX_BACNET_OBJECT_TYPE; + data.object.identifier.type++) + { + for ( + data.object.identifier.instance = 1; + data.object.identifier.instance <= BACNET_MAX_INSTANCE; + data.object.identifier.instance <<= 1) + { + testWhoHasData(pTest,&data); + } + } + data.object_name = true; + characterstring_init_ansi( + &data.object.name,"patricia"); + testWhoHasData(pTest,&data); + } + } +} + +#ifdef TEST_WHOHAS +int main(void) +{ + Test *pTest; + bool rc; + + pTest = ct_create("BACnet Who-Has", NULL); + /* individual tests */ + rc = ct_addTestFunction(pTest, testWhoHas); + assert(rc); + + ct_setStream(pTest, stdout); + ct_run(pTest); + (void) ct_report(pTest); + ct_destroy(pTest); + + return 0; +} +#endif /* TEST_WHOIS */ +#endif /* TEST */ diff --git a/bacnet-stack/whohas.cbp b/bacnet-stack/whohas.cbp new file mode 100644 index 00000000..c9611b46 --- /dev/null +++ b/bacnet-stack/whohas.cbp @@ -0,0 +1,92 @@ + + + + + + + diff --git a/bacnet-stack/whohas.h b/bacnet-stack/whohas.h new file mode 100644 index 00000000..6645e591 --- /dev/null +++ b/bacnet-stack/whohas.h @@ -0,0 +1,86 @@ +/*####COPYRIGHTBEGIN#### + ------------------------------------------- + Copyright (C) 2006 Steve Karg + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + The Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA. + + As a special exception, if other files instantiate templates or + use macros or inline functions from this file, or you compile + this file and link it with other works to produce a work based + on this file, this file does not by itself cause the resulting + work to be covered by the GNU General Public License. However + the source code for this file must still be made available in + accordance with section (3) of the GNU General Public License. + + This exception does not invalidate any other reasons why a work + based on this file might be covered by the GNU General Public + License. + ------------------------------------------- +####COPYRIGHTEND####*/ +#ifndef WHOHAS_H +#define WHOHAS_H + +#include +#include +#include "bacstr.h" + +typedef struct BACnet_Who_Has_Data +{ + int32_t low_limit; /* deviceInstanceRange */ + int32_t high_limit; + bool object_name; /* true if a string */ + union + { + struct + { + BACNET_OBJECT_TYPE type; + uint32_t instance; + } identifier; + BACNET_CHARACTER_STRING name; + } object; +} BACNET_WHO_HAS_DATA; + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +// encode service - use -1 for limit if you want unlimited +int whohas_encode_apdu( + uint8_t *apdu, + BACNET_WHO_HAS_DATA *data); + +int whohas_decode_service_request( + uint8_t *apdu, + unsigned apdu_len, + BACNET_WHO_HAS_DATA *data); + +int whohas_decode_apdu( + uint8_t *apdu, + unsigned apdu_len, + BACNET_WHO_HAS_DATA *data); + +#ifdef TEST +#include "ctest.h" +void testWhoHas(Test * pTest); +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + diff --git a/bacnet-stack/whohas.mak b/bacnet-stack/whohas.mak new file mode 100644 index 00000000..180bad1a --- /dev/null +++ b/bacnet-stack/whohas.mak @@ -0,0 +1,34 @@ +#Makefile to build test case +CC = gcc +BASEDIR = . +#CFLAGS = -Wall -I. +# -g for debugging with gdb +#CFLAGS = -Wall -I. -g +CFLAGS = -Wall -I. -Itest -DTEST -DTEST_WHOHAS -g + +SRCS = bacdcode.c \ + bacstr.c \ + bigend.c \ + whohas.c \ + test/ctest.c + +OBJS = ${SRCS:.c=.o} + +TARGET = whohas + +all: ${TARGET} + +${TARGET}: ${OBJS} + ${CC} -o $@ ${OBJS} + +.c.o: + ${CC} -c ${CFLAGS} $*.c -o $@ + +depend: + rm -f .depend + ${CC} -MM ${CFLAGS} *.c >> .depend + +clean: + rm -rf core ${TARGET} $(OBJS) *.bak *.1 *.ini + +include: .depend