BACnetClient.cpp

/*
 * BACnetClient.cpp
 *
 *  Created on: 20.04.2018
 *      Author: Micha Mueller
 */

#include "BACnetClient.h"

//#include "client.h"
#include "bacnetTEMP/address.h"
#include "bacnetTEMP/apdu.h"
#include "bacnetTEMP/bacapp.h"
#include "bacnetTEMP/bactext.h"
#include "bacnetTEMP/datalink.h"
#include "bacnetTEMP/npdu.h"
#include "bacnetTEMP/reject.h"
#include "bacnetTEMP/rp.h"
#include "bacnetTEMP/tsm.h"

uint64_t BACnetClient::_presentValue;
uint8_t BACnetClient::_handlerTransmitBuffer[MAX_PDU];

BACnetClient::BACnetClient() {
	_strand = NULL;
	_invokeId = 0;
	_presentValue = 0;
	_timeout = 1000;
	_targetAddress = {0};
}

BACnetClient::~BACnetClient() {
	datalink_cleanup();
}

void BACnetClient::init(std::string interface, unsigned port, unsigned timeout, unsigned retries) {
	//compile BACnet stack with BACNET_ADDRESS_CACHE_FILE for initialization from file address_cache
	address_init();

	//setup datalink

//#if defined(BACDL_BIP)
    bip_set_port(port);
//#endif
	apdu_timeout_set(timeout);
	apdu_retries_set(retries);

    /* === Initialize the Datalink Here === */
    if (!datalink_init(&interface[0])) {
    	//TODO abort
        exit(1);
    }
    //end setup datalink

	//Device_Init(NULL); // Initializes Device Object; TODO do we need this?

    using namespace std::placeholders;	// for _1, _2, ...

	/* set the handler for all the services we don't implement
	   It is required to send the proper reject message... */
	apdu_set_unrecognized_service_handler_handler(unrecognizedServiceHandler);

	//NOTE: no handler for read property set even though it is required. We are no real BACnet device

	/* we only need to handle the data coming back from confirmed (read property) requests */
	apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_PROPERTY,	readPropertyAckHandler);

	/* handle any errors coming back */
	apdu_set_error_handler(SERVICE_CONFIRMED_READ_PROPERTY, errorHandler);
	apdu_set_abort_handler(abortHandler);
	apdu_set_reject_handler(rejectHandler);
}

uint64_t BACnetClient::readProperty(uint32_t deviceObjInstance, uint32_t objInstance, BACNET_OBJECT_TYPE objType, BACNET_PROPERTY_ID objProperty, int32_t objIndex) {
	//TODO better use readPropertyMultiple?

	uint16_t pdu_lenRec = 0;
	int pdu_lenSent		= 0;
	int bytes_sent		= 0;
	unsigned max_apdu 	= 0;
	_targetAddress	= {0};		//where message goes to
	BACNET_ADDRESS src	= {0}; 	//where response came from
	BACNET_ADDRESS myAddr = {0};//our address

	BACNET_READ_PROPERTY_DATA data;
	BACNET_NPDU_DATA npdu_data;

	uint8_t RecBuf[MAX_MPDU] = {0};

	if (!address_get_by_device(deviceObjInstance, &max_apdu, &_targetAddress)) {
		throw std::runtime_error("Address not found");
	}

	/*
	if (!_targetAddress) {
		throw std::runtime_error("Destination address empty");
	}
	*/

	/*
	if (!dcc_communication_enabled()) {
		throw std::runtime_error("Communication Control disabled");
	}
	*/

	if (!(_invokeId = tsm_next_free_invokeID())) {
		throw std::runtime_error("No TSM available");
	}

	/* encode the NPDU portion of the packet */
	datalink_get_my_address(&myAddr);
	npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
	pdu_lenSent = npdu_encode_pdu(&_handlerTransmitBuffer[0], &_targetAddress, &myAddr, &npdu_data);

	/* encode the APDU portion of the packet */
	data.object_type = objType;
	data.object_instance = objInstance;
	data.object_property = objProperty;
	data.array_index = objIndex;
	pdu_lenSent += rp_encode_apdu(&_handlerTransmitBuffer[pdu_lenSent], _invokeId, &data);
	/* will it fit in the sender?
	   note: if there is a bottleneck router in between
	   us and the destination, we won't know unless
	   we have a way to check for that and update the
	   max_apdu in the address binding table. */
	if ((uint16_t) pdu_lenSent < max_apdu) {
		tsm_set_confirmed_unsegmented_transaction(_invokeId, &_targetAddress, &npdu_data, &_handlerTransmitBuffer[0], (uint16_t) pdu_lenSent);
		bytes_sent = datalink_send_pdu(&_targetAddress, &npdu_data, &_handlerTransmitBuffer[0], pdu_lenSent);
		if (bytes_sent <= 0) {
			std::string errorMsg = strerror(errno);
			std::string str = "Failed to send ReadProperty Request ";
			throw std::runtime_error(str + errorMsg);
		}
	} else {
		tsm_free_invoke_id(_invokeId);
		_invokeId = 0;
		throw std::runtime_error("Failed to Send ReadProperty Request (exceeds destination maximum APDU)");
	}

	// returns 0 on timeout
	pdu_lenRec = datalink_receive(&src, &RecBuf[0], MAX_MPDU, _timeout);	//TODO use bip_receive?

	if (pdu_lenRec) {
	    int apdu_offset = 0;
	    BACNET_ADDRESS destRec = { 0 };
	    BACNET_NPDU_DATA npdu_dataRec = { 0 };

#ifdef DEBUG
	    LOG(debug) << "BACnet: Protocol Version = " << (unsigned) RecBuf[0];
#endif

		apdu_offset = npdu_decode(&RecBuf[0], &destRec, &src, &npdu_dataRec);
		if (npdu_data.network_layer_message) {
			/* network layer message received!  Handle it! */
			LOG(error) << "Network layer message received. Discarding";
		} else if ((apdu_offset > 0) && (apdu_offset <= pdu_lenRec)) {
			if ((destRec.net == 0) || (destRec.net == BACNET_BROADCAST_NETWORK)) {
				/* only handle the version that we know how to handle */
				/* and we are not a router, so ignore messages with
				   routing information cause they are not for us */
				if (!(destRec.net == BACNET_BROADCAST_NETWORK) && !((RecBuf[apdu_offset] & 0xF0) ==	PDU_TYPE_CONFIRMED_SERVICE_REQUEST)) {
					apdu_handler(&src, &RecBuf[apdu_offset], (uint16_t) (pdu_lenRec - apdu_offset));
				}
			}
		}
	} else {
		tsm_free_invoke_id(_invokeId);
		throw std::runtime_error("Timeout while waiting for response");
	}

	if (!tsm_invoke_id_free(_invokeId)) { //should be freed by apdu_handler on success
		tsm_free_invoke_id(_invokeId);
		throw std::runtime_error("Invoke ID was not freed");
	}

	return 0;
}


void BACnetClient::initializeStrand(boost::asio::io_service& io) {
	if (!_strand) {
		_strand = new boost::asio::io_service::strand(io);
	}
}

void BACnetClient::unrecognizedServiceHandler(uint8_t * service_request, uint16_t service_len, BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data) {
	boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
    int pdu_len = 0;
    int bytes_sent = 0;
    BACNET_NPDU_DATA npdu_data;
    BACNET_ADDRESS myAddress;

    (void) service_request;
    (void) service_len;

    /* encode the NPDU portion of the packet */
    datalink_get_my_address(&myAddress);
    npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
    pdu_len = npdu_encode_pdu(&_handlerTransmitBuffer[0], src, &myAddress, &npdu_data);
    /* encode the APDU portion of the packet */
    pdu_len += reject_encode_apdu(&_handlerTransmitBuffer[pdu_len], service_data->invoke_id, REJECT_REASON_UNRECOGNIZED_SERVICE);
    /* send the data */
    bytes_sent = datalink_send_pdu(src, &npdu_data, &_handlerTransmitBuffer[0], pdu_len);
    if (bytes_sent > 0) {
    	LOG(info) << "BACnet: Sent Reject";
    } else {
    	LOG(info) << "BACnet: Could not send Reject: " << strerror(errno);
    }
}

void BACnetClient::readPropertyAckHandler(uint8_t * service_request, uint16_t service_len, BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
{
	boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
    int serviceLen = 0;
    int appDataLen = 0;
	uint8_t *application_data;
	int application_data_len;
    BACNET_READ_PROPERTY_DATA data;
    BACNET_APPLICATION_DATA_VALUE value;        /* for decode value data */

    /*if (!(address_match(&_targetAddress, src) && (service_data->invoke_id == _invokeId))) {
    	throw std::runtime_error("Message not determined for us");
    }*/

	serviceLen = rp_ack_decode_service_request(service_request, service_len, &data);
	if (serviceLen <= 0) {
		throw std::runtime_error("Decode failed");
	}
   //     rp_ack_print_data(&data);

	application_data = data.application_data;
	application_data_len = data.application_data_len;
	appDataLen = bacapp_decode_application_data(application_data, (uint8_t) application_data_len, &value);

	//bacapp_print_value(stdout, &object_value);

	//TODO what kind of data is returned? which cases do we need to handle? fit they into uint64_t at all??
	switch (value.tag) {
		case BACNET_APPLICATION_TAG_NULL:
			LOG(trace) << "TAG_NULL";
			_presentValue = 0;
			break;
		case BACNET_APPLICATION_TAG_BOOLEAN:
			LOG(trace) << "TAG_BOOLEAN";
			_presentValue =	(value.type.Boolean) ? 1 : 0;
			break;
		case BACNET_APPLICATION_TAG_UNSIGNED_INT:
			LOG(trace) << "TAG_UNSIGNED_INT";
			_presentValue =	(unsigned long) value.type.Unsigned_Int;
			break;
		case BACNET_APPLICATION_TAG_SIGNED_INT:
			LOG(trace) << "TAG_SIGNED_INT";
			_presentValue =	(long) value.type.Signed_Int;
			break;
		case BACNET_APPLICATION_TAG_REAL:
			LOG(trace) << "TAG_REAL";
			_presentValue = (double) value.type.Real;
			break;
		case BACNET_APPLICATION_TAG_DOUBLE:
			LOG(trace) << "TAG_DOUBLE";
			_presentValue = value.type.Double;
			break;
		default:
			throw std::runtime_error("Value tag not supported");
			break;
	}
}

void BACnetClient::errorHandler(BACNET_ADDRESS * src, uint8_t invokeId, BACNET_ERROR_CLASS error_class, BACNET_ERROR_CODE error_code) {
	boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
	LOG(error) << "BACnet Error: " << bactext_error_class_name((int) error_class) << bactext_error_code_name((int) error_code);
}

void BACnetClient::abortHandler(BACNET_ADDRESS * src, uint8_t invokeId, uint8_t abort_reason, bool server) {
	boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
	LOG(error) << "BACnet Abort: " << bactext_abort_reason_name((int) abort_reason);
}

void BACnetClient::rejectHandler(BACNET_ADDRESS * src, uint8_t invokeId, uint8_t reject_reason) {
	boost::log::sources::severity_logger<boost::log::trivial::severity_level> lg;
	LOG(error) << "BACnet Reject: " << bactext_reject_reason_name((int) reject_reason);
}