![Anders Broman](/assets/img/avatar_default.png)
numerous changes, most notably: 1) BACnetStatusFlags is bit string, not enum, in NotificationParameters 2) Fixes many places where enclosing context tags were not handled properly. 3) Simplify tag decoding logic. Change to explicit decoding in many instances rather than read tags in a loop and do a switch based on tag number. Looping ignores out-of-order and other types of tagging errors. svn path=/trunk/; revision=19410
2077 lines
53 KiB
C
2077 lines
53 KiB
C
/* packet-bacapp.h
|
||
* Routines for BACnet (APDU) dissection
|
||
* Copyright 2004, Herbert Lischka <lischka@kieback-peter.de>, Berlin
|
||
*
|
||
* $Id$
|
||
*
|
||
* Wireshark - Network traffic analyzer
|
||
* By Gerald Combs <gerald@wireshark.org>
|
||
* Copyright 1998 Gerald Combs
|
||
*
|
||
* Copied from README.developer,v 1.23
|
||
*
|
||
* 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.
|
||
*/
|
||
|
||
#ifndef __BACAPP_H__
|
||
#define __BACAPP_H__
|
||
|
||
#ifdef HAVE_CONFIG_H
|
||
# include "config.h"
|
||
#if HAVE_ICONV
|
||
#include <iconv.h>
|
||
#endif
|
||
#endif
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#include <glib.h>
|
||
|
||
#include <epan/packet.h>
|
||
|
||
#ifndef min
|
||
#define min(a,b) (((a)<(b))?(a):(b))
|
||
#endif
|
||
|
||
#ifndef max
|
||
#define max(a,b) (((a)>(b))?(a):(b))
|
||
#endif
|
||
|
||
#ifndef FAULT
|
||
#define FAULT proto_tree_add_text(subtree, tvb, offset, tvb_length(tvb) - offset, "something is going wrong here !!"); \
|
||
offset = tvb_length(tvb);
|
||
#endif
|
||
|
||
#ifndef false
|
||
#define false 0
|
||
#endif
|
||
#ifndef true
|
||
#define true 1
|
||
#endif
|
||
|
||
/* BACnet PDU Types */
|
||
#define BACAPP_TYPE_CONFIRMED_SERVICE_REQUEST 0
|
||
#define BACAPP_TYPE_UNCONFIRMED_SERVICE_REQUEST 1
|
||
#define BACAPP_TYPE_SIMPLE_ACK 2
|
||
#define BACAPP_TYPE_COMPLEX_ACK 3
|
||
#define BACAPP_TYPE_SEGMENT_ACK 4
|
||
#define BACAPP_TYPE_ERROR 5
|
||
#define BACAPP_TYPE_REJECT 6
|
||
#define BACAPP_TYPE_ABORT 7
|
||
#define MAX_BACAPP_TYPE 8
|
||
|
||
#define BACAPP_SEGMENTED_REQUEST 0x08
|
||
#define BACAPP_MORE_SEGMENTS 0x04
|
||
#define BACAPP_SEGMENTED_RESPONSE 0x02
|
||
#define BACAPP_SEGMENT_NAK 0x02
|
||
#define BACAPP_SENT_BY 0x01
|
||
|
||
|
||
/**
|
||
* dissect_bacapp ::= CHOICE {
|
||
* confirmed-request-PDU [0] BACnet-Confirmed-Request-PDU,
|
||
* unconfirmed-request-PDU [1] BACnet-Unconfirmed-Request-PDU,
|
||
* simpleACK-PDU [2] BACnet-SimpleACK-PDU,
|
||
* complexACK-PDU [3] BACnet-ComplexACK-PDU,
|
||
* segmentACK-PDU [4] BACnet-SegmentACK-PDU,
|
||
* error-PDU [5] BACnet-Error-PDU,
|
||
* reject-PDU [6] BACnet-Reject-PDU,
|
||
* abort-PDU [7] BACnet-Abort-PDU
|
||
* }
|
||
* @param tvb
|
||
* @param pinfo
|
||
* @param tree
|
||
*/
|
||
void
|
||
dissect_bacapp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
|
||
|
||
/**
|
||
* ConfirmedRequest-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 0 for this PDU Type
|
||
* segmentedMessage [1] BOOLEAN,
|
||
* moreFollows [2] BOOLEAN,
|
||
* segmented-response-accepted [3] BOOLEAN,
|
||
* reserved [4] Unsigned (0..3), -- must be set zero
|
||
* max-segments-accepted [5] Unsigned (0..7), -- as per 20.1.2.4
|
||
* max-APDU-length-accepted [5] Unsigned (0..15), -- as per 20.1.2.5
|
||
* invokeID [6] Unsigned (0..255),
|
||
* sequence-number [7] Unsigned (0..255) OPTIONAL, -- only if segmented msg
|
||
* proposed-window-size [8] Unsigned (0..127) OPTIONAL, -- only if segmented msg
|
||
* service-choice [9] BACnetConfirmedServiceChoice,
|
||
* service-request [10] BACnet-Confirmed-Service-Request OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param pinfo
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedRequestPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param ack - indocates whether working on request or ack
|
||
* @param svc - output variable to return service choice
|
||
* @param tt - output varable to return service choice item
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fStartConfirmed(tvbuff_t *tvb, proto_tree *tree, guint offset, guint8 ack,
|
||
gint *svc, proto_item **tt);
|
||
|
||
/**
|
||
* Unconfirmed-Request-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 1 for this PDU type
|
||
* reserved [1] Unsigned (0..15), -- must be set zero
|
||
* service-choice [2] BACnetUnconfirmedServiceChoice,
|
||
* service-request [3] BACnetUnconfirmedServiceRequest -- Context-specific tags 0..3 are NOT used in header encoding
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedRequestPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* SimpleACK-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 2 for this PDU type
|
||
* reserved [1] Unsigned (0..15), -- must be set zero
|
||
* invokeID [2] Unsigned (0..255),
|
||
* service-ACK-choice [3] BACnetUnconfirmedServiceChoice -- Context-specific tags 0..3 are NOT used in header encoding
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSimpleAckPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ComplexACK-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 3 for this PDU Type
|
||
* segmentedMessage [1] BOOLEAN,
|
||
* moreFollows [2] BOOLEAN,
|
||
* reserved [3] Unsigned (0..3), -- must be set zero
|
||
* invokeID [4] Unsigned (0..255),
|
||
* sequence-number [5] Unsigned (0..255) OPTIONAL, -- only if segmented msg
|
||
* proposed-window-size [6] Unsigned (0..127) OPTIONAL, -- only if segmented msg
|
||
* service-ACK-choice [7] BACnetConfirmedServiceChoice,
|
||
* service-ACK [8] BACnet-Confirmed-Service-Request -- Context-specific tags 0..8 are NOT used in header encoding
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fComplexAckPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* SegmentACK-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 4 for this PDU Type
|
||
* reserved [1] Unsigned (0..3), -- must be set zero
|
||
* negative-ACK [2] BOOLEAN,
|
||
* server [3] BOOLEAN,
|
||
* original-invokeID [4] Unsigned (0..255),
|
||
* sequence-number [5] Unsigned (0..255),
|
||
* actual-window-size [6] Unsigned (0..127)
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSegmentAckPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Error-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 5 for this PDU Type
|
||
* reserved [1] Unsigned (0..3), -- must be set zero
|
||
* original-invokeID [2] Unsigned (0..255),
|
||
* error-choice [3] BACnetConfirmedServiceChoice,
|
||
* error [4] BACnet-Error
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fErrorPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Reject-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 6 for this PDU Type
|
||
* reserved [1] Unsigned (0..3), -- must be set zero
|
||
* original-invokeID [2] Unsigned (0..255),
|
||
* reject-reason [3] BACnetRejectReason
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fRejectPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Abort-PDU ::= SEQUENCE {
|
||
* pdu-type [0] Unsigned (0..15), -- 7 for this PDU Type
|
||
* reserved [1] Unsigned (0..3), -- must be set zero
|
||
* server [2] BOOLEAN,
|
||
* original-invokeID [3] Unsigned (0..255),
|
||
* abort-reason [4] BACnetAbortReason
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAbortPDU(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* 20.2.4, adds the label with max 64Bit unsigned Integer Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnsignedTag (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* 20.2.5, adds the label with max 64Bit signed Integer Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSignedTag (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* 20.2.8, adds the label with Octet String to tree; if lvt == 0 then lvt = restOfFrame
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @param lvt length of String
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fOctetString (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label, guint32 lvt);
|
||
|
||
/**
|
||
* 20.2.12, adds the label with Date Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDate (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* 20.2.13, adds the label with Time Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fTime (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* 20.2.14, adds Object Identifier to tree
|
||
* use BIG ENDIAN: Bits 31..22 Object Type, Bits 21..0 Instance Number
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fObjectIdentifier (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnet-Confirmed-Service-Request ::= CHOICE {
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param service_choice
|
||
* @return offset
|
||
*/
|
||
static guint
|
||
fConfirmedServiceRequest (tvbuff_t *tvb, proto_tree *tree, guint offset, gint service_choice);
|
||
|
||
/**
|
||
* BACnet-Confirmed-Service-ACK ::= CHOICE {
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param service_choice
|
||
* @return offset
|
||
*/
|
||
static guint
|
||
fConfirmedServiceAck (tvbuff_t *tvb, proto_tree *tree, guint offset, gint service_choice);
|
||
|
||
/**
|
||
* AcknowledgeAlarm-Request ::= SEQUENCE {
|
||
* acknowledgingProcessIdentifier [0] Unsigned32,
|
||
* eventObjectIdentifier [1] BACnetObjectIdentifer,
|
||
* eventStateAcknowledge [2] BACnetEventState,
|
||
* timeStamp [3] BACnetTimeStamp,
|
||
* acknowledgementSource [4] Character String,
|
||
* timeOfAcknowledgement [5] BACnetTimeStamp
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAcknowledgeAlarmRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedCOVNotification-Request ::= SEQUENCE {
|
||
* subscriberProcessIdentifier [0] Unsigned32,
|
||
* initiatingDeviceIdentifier [1] BACnetObjectIdentifer,
|
||
* monitoredObjectIdentifier [2] BACnetObjectIdentifer,
|
||
* timeRemaining [3] unsigned,
|
||
* listOfValues [4] SEQUENCE OF BACnetPropertyValues
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedCOVNotificationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedEventNotification-Request ::= SEQUENCE {
|
||
* ProcessIdentifier [0] Unsigned32,
|
||
* initiatingDeviceIdentifier [1] BACnetObjectIdentifer,
|
||
* eventObjectIdentifier [2] BACnetObjectIdentifer,
|
||
* timeStamp [3] BACnetTimeStamp,
|
||
* notificationClass [4] unsigned,
|
||
* priority [5] unsigned8,
|
||
* eventType [6] BACnetEventType,
|
||
* messageText [7] CharacterString OPTIONAL,
|
||
* notifyType [8] BACnetNotifyType,
|
||
* ackRequired [9] BOOLEAN OPTIONAL,
|
||
* fromState [10] BACnetEventState OPTIONAL,
|
||
* toState [11] BACnetEventState,
|
||
* eventValues [12] BACnetNotificationParameters OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedEventNotificationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* GetAlarmSummary-ACK ::= SEQUENCE OF SEQUENCE {
|
||
* objectIdentifier BACnetObjectIdentifer,
|
||
* alarmState BACnetEventState,
|
||
* acknowledgedTransitions BACnetEventTransitionBits
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fGetAlarmSummaryAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* GetEnrollmentSummary-Request ::= SEQUENCE {
|
||
* acknowledgmentFilter [0] ENUMERATED {
|
||
* all (0),
|
||
* acked (1),
|
||
* not-acked (2)
|
||
* },
|
||
* enrollmentFilter [1] BACnetRecipientProcess OPTIONAL,
|
||
* eventStateFilter [2] ENUMERATED {
|
||
* offnormal (0),
|
||
* fault (1),
|
||
* normal (2),
|
||
* all (3),
|
||
* active (4)
|
||
* },
|
||
* eventTypeFilter [3] BACnetEventType OPTIONAL,
|
||
* priorityFilter [4] SEQUENCE {
|
||
* minPriority [0] Unsigned8,
|
||
* maxPriority [1] Unsigned8
|
||
* } OPTIONAL,
|
||
* notificationClassFilter [5] Unsigned OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fGetEnrollmentSummaryRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* GetEnrollmentSummary-ACK ::= SEQUENCE OF SEQUENCE {
|
||
* objectIdentifier BACnetObjectIdentifer,
|
||
* eventType BACnetEventType,
|
||
* eventState BACnetEventState,
|
||
* priority Unsigned8,
|
||
* notificationClass Unsigned OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fGetEnrollmentSummaryAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* GetEventInformation-Request ::= SEQUENCE {
|
||
* lastReceivedObjectIdentifier [0] BACnetObjectIdentifer
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fGetEventInformationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* GetEventInformation-ACK ::= SEQUENCE {
|
||
* listOfEventSummaries [0] listOfEventSummaries,
|
||
* moreEvents [1] BOOLEAN
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fGetEventInformationACK (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* LifeSafetyOperation-Request ::= SEQUENCE {
|
||
* requestingProcessIdentifier [0] Unsigned32
|
||
* requestingSource [1] CharacterString
|
||
* request [2] BACnetLifeSafetyOperation
|
||
* objectIdentifier [3] BACnetObjectIdentifier OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fLifeSafetyOperationRequest(tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* SubscribeCOV-Request ::= SEQUENCE {
|
||
* subscriberProcessIdentifier [0] Unsigned32
|
||
* monitoredObjectIdentifier [1] BACnetObjectIdentifier
|
||
* issueConfirmedNotifications [2] BOOLEAN OPTIONAL
|
||
* lifetime [3] Unsigned OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @param src
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSubscribeCOVRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* SubscribeCOVProperty-Request ::= SEQUENCE {
|
||
* subscriberProcessIdentifier [0] Unsigned32
|
||
* monitoredObjectIdentifier [1] BACnetObjectIdentifier
|
||
* issueConfirmedNotifications [2] BOOLEAN OPTIONAL
|
||
* lifetime [3] Unsigned OPTIONAL
|
||
* monitoredPropertyIdentifier [4] BACnetPropertyReference OPTIONAL
|
||
* covIncrement [5] Unsigned OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSubscribeCOVPropertyRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* AtomicReadFile-Request ::= SEQUENCE {
|
||
* fileIdentifier BACnetObjectIdentifier,
|
||
* accessMethod CHOICE {
|
||
* streamAccess [0] SEQUENCE {
|
||
* fileStartPosition INTEGER,
|
||
* requestedOctetCount Unsigned
|
||
* },
|
||
* recordAccess [1] SEQUENCE {
|
||
* fileStartRecord INTEGER,
|
||
* requestedRecordCount Unsigned
|
||
* }
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAtomicReadFileRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* AtomicWriteFile-ACK ::= SEQUENCE {
|
||
* endOfFile BOOLEAN,
|
||
* accessMethod CHOICE {
|
||
* streamAccess [0] SEQUENCE {
|
||
* fileStartPosition INTEGER,
|
||
* fileData OCTET STRING
|
||
* },
|
||
* recordAccess [1] SEQUENCE {
|
||
* fileStartRecord INTEGER,
|
||
* returnedRecordCount Unsigned,
|
||
* fileRecordData SEQUENCE OF OCTET STRING
|
||
* }
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAtomicReadFileAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* AtomicWriteFile-Request ::= SEQUENCE {
|
||
* fileIdentifier BACnetObjectIdentifier,
|
||
* accessMethod CHOICE {
|
||
* streamAccess [0] SEQUENCE {
|
||
* fileStartPosition INTEGER,
|
||
* fileData OCTET STRING
|
||
* },
|
||
* recordAccess [1] SEQUENCE {
|
||
* fileStartRecord INTEGER,
|
||
* recordCount Unsigned,
|
||
* fileRecordData SEQUENCE OF OCTET STRING
|
||
* }
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAtomicWriteFileRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* AtomicWriteFile-ACK ::= SEQUENCE {
|
||
* fileStartPosition [0] INTEGER,
|
||
* fileStartRecord [1] INTEGER,
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAtomicWriteFileAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* AddListElement-Request ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* listOfElements [3] ABSTRACT-SYNTAX.&Type
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAddListElementRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* CreateObject-Request ::= SEQUENCE {
|
||
* objectSpecifier [0] ObjectSpecifier,
|
||
* listOfInitialValues [1] SEQUENCE OF BACnetPropertyValue OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fCreateObjectRequest(tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
/**
|
||
* CreateObject-Request ::= BACnetObjectIdentifier
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fCreateObjectAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* DeleteObject-Request ::= SEQUENCE {
|
||
* ObjectIdentifier BACnetObjectIdentifer
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDeleteObjectRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadProperty-Request ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadPropertyRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadProperty-ACK ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* propertyValue [3] ABSTRACT-SYNTAX.&Type
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadPropertyAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadPropertyConditional-Request ::= SEQUENCE {
|
||
* objectSelectionCriteria [0] objectSelectionCriteria,
|
||
* listOfPropertyReferences [1] SEQUENCE OF BACnetPropertyReference OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadPropertyConditionalRequest(tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
/**
|
||
* ReadPropertyConditional-ACK ::= SEQUENCE {
|
||
* listOfPReadAccessResults SEQUENCE OF ReadAccessResult OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadPropertyConditionalAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadPropertyMultiple-Request ::= SEQUENCE {
|
||
* listOfReadAccessSpecs SEQUENCE OF ReadAccessSpecification
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return offset modified
|
||
*/
|
||
static guint
|
||
fReadPropertyMultipleRequest(tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
/**
|
||
* ReadPropertyMultiple-Ack ::= SEQUENCE {
|
||
* listOfReadAccessResults SEQUENCE OF ReadAccessResult
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return offset modified
|
||
*/
|
||
static guint
|
||
fReadPropertyMultipleAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadRange-Request ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* range CHOICE {
|
||
* byPosition [3] SEQUENCE {
|
||
* referencedIndex Unsigned,
|
||
* count INTEGER
|
||
* },
|
||
* byTime [4] SEQUENCE {
|
||
* referenceTime BACnetDateTime,
|
||
* count INTEGER
|
||
* },
|
||
* timeRange [5] SEQUENCE {
|
||
* beginningTime BACnetDateTime,
|
||
* endingTime BACnetDateTime
|
||
* },
|
||
* } OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadRangeRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* 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
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadRangeAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* RemoveListElement-Request ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* listOfElements [3] ABSTRACT-SYNTAX.&Type
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fRemoveListElementRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* WriteProperty-Request ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* propertyValue [3] ABSTRACT-SYNTAX.&Type
|
||
* priority [4] Unsigned8 (1..16) OPTIONAL --used only when property is commandable
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWritePropertyRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* WritePropertyMultiple-Request ::= SEQUENCE {
|
||
* listOfWriteAccessSpecifications SEQUENCE OF WriteAccessSpecification
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWritePropertyMultipleRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* DeviceCommunicationControl-Request ::= SEQUENCE {
|
||
* timeDuration [0] Unsigned16 OPTIONAL,
|
||
* enable-disable [1] ENUMERATED {
|
||
* enable (0),
|
||
* disable (1)
|
||
* },
|
||
* password [2] CharacterString (SIZE(1..20)) OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDeviceCommunicationControlRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedPrivateTransfer-Request ::= SEQUENCE {
|
||
* vendorID [0] Unsigned,
|
||
* serviceNumber [1] Unsigned,
|
||
* serviceParameters [2] ABSTRACT-SYNTAX.&Type OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedPrivateTransferRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedPrivateTransfer-ACK ::= SEQUENCE {
|
||
* vendorID [0] Unsigned,
|
||
* serviceNumber [1] Unsigned,
|
||
* resultBlock [2] ABSTRACT-SYNTAX.&Type OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedPrivateTransferAck(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedTextMessage-Request ::= SEQUENCE {
|
||
* textMessageSourceDevice [0] BACnetObjectIdentifier,
|
||
* messageClass [1] CHOICE {
|
||
* numeric [0] Unsigned,
|
||
* character [1] CharacterString
|
||
* } OPTIONAL,
|
||
* messagePriority [2] ENUMERATED {
|
||
* normal (0),
|
||
* urgent (1)
|
||
* },
|
||
* message [3] CharacterString
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedTextMessageRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReinitializeDevice-Request ::= SEQUENCE {
|
||
* reinitializedStateOfDevice [0] ENUMERATED {
|
||
* coldstart (0),
|
||
* warmstart (1),
|
||
* startbackup (2),
|
||
* endbackup (3),
|
||
* startrestore (4),
|
||
* endrestore (5),
|
||
* abortrestor (6)
|
||
* },
|
||
* password [1] CharacterString (SIZE(1..20)) OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReinitializeDeviceRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTOpen-Request ::= SEQUENCE {
|
||
* vtClass BACnetVTClass,
|
||
* localVTSessionIdentifier Unsigned8
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVtOpenRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTOpen-ACK ::= SEQUENCE {
|
||
* remoteVTSessionIdentifier Unsigned8
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVtOpenAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTClose-Request ::= SEQUENCE {
|
||
* listOfRemoteVTSessionIdentifiers SEQUENCE OF Unsigned8
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVtCloseRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTData-Request ::= SEQUENCE {
|
||
* vtSessionIdentifier Unsigned8,
|
||
* vtNewData OCTET STRING,
|
||
* vtDataFlag Unsigned (0..1)
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVtDataRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTData-ACK ::= SEQUENCE {
|
||
* allNewDataAccepted [0] BOOLEAN,
|
||
* acceptedOctetCount [1] Unsigned OPTIONAL -- present only if allNewDataAccepted = FALSE
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVtDataAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Authenticate-Request ::= SEQUENCE {
|
||
* pseudoRandomNumber [0] Unsigned32,
|
||
* excpectedInvokeID [1] Unsigned8 OPTIONAL,
|
||
* operatorName [2] CharacterString OPTIONAL,
|
||
* operatorPassword [3] CharacterString (SIZE(1..20)) OPTIONAL,
|
||
* startEncypheredSession [4] BOOLEAN OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAuthenticateRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Authenticate-ACK ::= SEQUENCE {
|
||
* modifiedRandomNumber Unsigned32,
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAuthenticateAck (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* RequestKey-Request ::= SEQUENCE {
|
||
* requestingDeviceIdentifier BACnetObjectIdentifier,
|
||
* requestingDeviceAddress BACnetAddress,
|
||
* remoteDeviceIdentifier BACnetObjectIdentifier,
|
||
* remoteDeviceAddress BACnetAddress
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fRequestKeyRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Unconfirmed-Service-Request ::= CHOICE {
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param service_choice
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedServiceRequest (tvbuff_t *tvb, proto_tree *tree, guint offset, gint service_choice);
|
||
|
||
/**
|
||
* UnconfirmedCOVNotification-Request ::= SEQUENCE {
|
||
* subscriberProcessIdentifier [0] Unsigned32,
|
||
* initiatingDeviceIdentifier [1] BACnetObjectIdentifer,
|
||
* monitoredObjectIdentifier [2] BACnetObjectIdentifer,
|
||
* timeRemaining [3] unsigned,
|
||
* listOfValues [4] SEQUENCE OF BACnetPropertyValues
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedCOVNotificationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* UnconfirmedEventNotification-Request ::= SEQUENCE {
|
||
* ProcessIdentifier [0] Unsigned32,
|
||
* initiatingDeviceIdentifier [1] BACnetObjectIdentifer,
|
||
* eventObjectIdentifier [2] BACnetObjectIdentifer,
|
||
* timeStamp [3] BACnetTimeStamp,
|
||
* notificationClass [4] unsigned,
|
||
* priority [5] unsigned8,
|
||
* eventType [6] BACnetEventType,
|
||
* messageText [7] CharacterString OPTIONAL,
|
||
* notifyType [8] BACnetNotifyType,
|
||
* ackRequired [9] BOOLEAN OPTIONAL,
|
||
* fromState [10] BACnetEventState OPTIONAL,
|
||
* toState [11] BACnetEventState,
|
||
* eventValues [12] BACnetNotificationParameters OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedEventNotificationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* I-Am-Request ::= SEQUENCE {
|
||
* aAmDeviceIdentifier BACnetObjectIdentifier,
|
||
* maxAPDULengthAccepted Unsigned,
|
||
* segmentationSupported BACnetSegmentation,
|
||
* vendorID Unsigned
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fIAmRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
|
||
/**
|
||
* I-Have-Request ::= SEQUENCE {
|
||
* deviceIdentifier BACnetObjectIdentifier,
|
||
* objectIdentifier BACnetObjectIdentifier,
|
||
* objectName CharacterString
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fIHaveRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* UnconfirmedPrivateTransfer-Request ::= SEQUENCE {
|
||
* vendorID [0] Unsigned,
|
||
* serviceNumber [1] Unsigned,
|
||
* serviceParameters [2] ABSTRACT-SYNTAX.&Type OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedPrivateTransferRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* UnconfirmedTextMessage-Request ::= SEQUENCE {
|
||
* textMessageSourceDevice [0] BACnetObjectIdentifier,
|
||
* messageClass [1] CHOICE {
|
||
* numeric [0] Unsigned,
|
||
* character [1] CharacterString
|
||
* } OPTIONAL,
|
||
* messagePriority [2] ENUMERATED {
|
||
* normal (0),
|
||
* urgent (1)
|
||
* },
|
||
* message [3] CharacterString
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUnconfirmedTextMessageRequest(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* TimeSynchronization-Request ::= SEQUENCE {
|
||
* BACnetDateTime
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fTimeSynchronizationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* UTCTimeSynchronization-Request ::= SEQUENCE {
|
||
* BACnetDateTime
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fUTCTimeSynchronizationRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Who-Has-Request ::= SEQUENCE {
|
||
* limits SEQUENCE {
|
||
* deviceInstanceRangeLowLimit [0] Unsigned (0..4194303),
|
||
* deviceInstanceRangeHighLimit [1] Unsigned (0..4194303)
|
||
* } OPTIONAL,
|
||
* object CHOICE {
|
||
* objectIdentifier [2] BACnetObjectIdentifier,
|
||
* objectName [3] CharacterString
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWhoHas (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Who-Is-Request ::= SEQUENCE {
|
||
* deviceInstanceRangeLowLimit [0] Unsigned (0..4194303) OPTIONAL, -- must be used as a pair, see 16.9,
|
||
* deviceInstanceRangeHighLimit [0] Unsigned (0..4194303) OPTIONAL, -- must be used as a pair, see 16.9,
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWhoIsRequest (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnet-Error ::= CHOICE {
|
||
* addListElement [8] ChangeList-Error,
|
||
* removeListElement [9] ChangeList-Error,
|
||
* writePropertyMultiple [16] WritePropertyMultiple-Error,
|
||
* confirmedPrivatTransfer [18] ConfirmedPrivateTransfer-Error,
|
||
* vtClose [22] VTClose-Error,
|
||
* readRange [26] ObjectAccessService-Error
|
||
* [default] Error
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param service
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fBACnetError(tvbuff_t *tvb, proto_tree *tree, guint offset, guint service);
|
||
|
||
/**
|
||
* Dissect a BACnetError in a context tag
|
||
*
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint fContextTaggedError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ChangeList-Error ::= SEQUENCE {
|
||
* errorType [0] Error,
|
||
* firstFailedElementNumber [1] Unsigned
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fChangeListError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* CreateObject-Error ::= SEQUENCE {
|
||
* errorType [0] Error,
|
||
* firstFailedElementNumber [1] Unsigned
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fCreateObjectError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ConfirmedPrivateTransfer-Error ::= SEQUENCE {
|
||
* errorType [0] Error,
|
||
* vendorID [1] Unsigned,
|
||
* serviceNumber [2] Unsigned,
|
||
* errorParameters [3] ABSTRACT-SYNTAX.&Type OPTIONAL
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fConfirmedPrivateTransferError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* WritePropertyMultiple-Error ::= SEQUENCE {
|
||
* errorType [0] Error,
|
||
* firstFailedWriteAttempt [1] Unsigned
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWritePropertyMultipleError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* VTClose-Error ::= SEQUENCE {
|
||
* errorType [0] Error,
|
||
* listOfVTSessionIdentifiers [1] SEQUENCE OF Unsigned8 OPTIONAL
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVTCloseError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnet Application Types chapter 20.2.1
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fApplicationTypes (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* BACnetActionCommand ::= SEQUENCE {
|
||
* deviceIdentifier [0] BACnetObjectIdentifier OPTIONAL,
|
||
* objectIdentifier [1] BACnetObjectIdentifier,
|
||
* propertyIdentifier [2] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [3] Unsigned OPTIONAL, -- used only with array datatype
|
||
* propertyValue [4] ABSTRACT-SYNTAX.&Type,
|
||
* priority [5] Unsigned (1..16) OPTIONAL, -- used only when property is commandable
|
||
* postDelay [6] Unsigned OPTIONAL,
|
||
* quitOnFailure [7] BOOLEAN,
|
||
* writeSuccessful [8] BOOLEAN
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fActionCommand (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetActionList ::= SEQUENCE {
|
||
* action [0] SEQUENCE of BACnetActionCommand
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fActionList (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/** BACnetAddress ::= SEQUENCE {
|
||
* network-number Unsigned16, -- A value 0 indicates the local network
|
||
* mac-address OCTET STRING -- A string of length 0 indicates a broadcast
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAddress (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetAddressBinding ::= SEQUENCE {
|
||
* deviceObjectID BACnetObjectIdentifier
|
||
* deviceAddress BacnetAddress
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fAddressBinding (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetCalendaryEntry ::= CHOICE {
|
||
* date [0] Date,
|
||
* dateRange [1] BACnetDateRange,
|
||
* weekNDay [2] BacnetWeekNday
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fCalendaryEntry (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetClientCOV ::= CHOICE {
|
||
* real-increment REAL,
|
||
* default-increment NULL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fClientCOV (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetDailySchedule ::= SEQUENCE {
|
||
* day-schedule [0] SENQUENCE OF BACnetTimeValue
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDailySchedule (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetWeeklySchedule ::= SEQUENCE {
|
||
* week-schedule SENQUENCE SIZE (7) OF BACnetDailySchedule
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWeeklySchedule (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetDateRange ::= SEQUENCE {
|
||
* StartDate Date,
|
||
* EndDate Date
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDateRange (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetDateTime ::= SEQUENCE {
|
||
* date Date,
|
||
* time Time
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param label
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDateTime (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetDestination ::= SEQUENCE {
|
||
* validDays BACnetDaysOfWeek,
|
||
* fromTime Time,
|
||
* toTime Time,
|
||
* recipient BACnetRecipient,
|
||
* processIdentifier Unsigned32,
|
||
* issueConfirmedNotifications BOOLEAN,
|
||
* transitions BACnetEventTransitionBits
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDestination (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetDeviceObjectPropertyReference ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigend OPTIONAL,
|
||
* deviceIdentifier [3] BACnetObjectIdentifier OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDeviceObjectPropertyReference (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetDeviceObjectReference ::= SEQUENCE {
|
||
* deviceIdentifier [0] BACnetObjectIdentifier OPTIONAL,
|
||
* objectIdentifier [1] BACnetObjectIdentifier
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fDeviceObjectReference (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetEventParameter ::= CHOICE {
|
||
* change-of-bitstring [0] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* bitmask [1] BIT STRING,
|
||
* list-of-bitstring-values [2] SEQUENCE OF BIT STRING
|
||
* },
|
||
* change-of-state [1] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* list-of-values [1] SEQUENCE OF BACnetPropertyStates
|
||
* },
|
||
* change-of-value [2] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* cov-criteria [1] CHOICE {
|
||
* bitmask [0] BIT STRING,
|
||
* referenced-property-increment [1] REAL
|
||
* }
|
||
* },
|
||
* command-failure [3] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* feedback-property-reference [1] BACnetDeviceObjectPropertyReference
|
||
* },
|
||
* floating-limit [4] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* setpoint-reference [1] BACnetDeviceObjectPropertyReference,
|
||
* low-diff-limit [2] REAL,
|
||
* high-diff-limit [3] REAL,
|
||
* deadband [4] REAL
|
||
* },
|
||
* out-of-range [5] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* low-limit [1] REAL,
|
||
* high-limit [2] REAL,
|
||
* deadband [3] REAL
|
||
* },
|
||
* buffer-ready [7] SEQUENCE {
|
||
* notification-threshold [0] Unsigned,
|
||
* previous-notification-count [1] Unsigned32
|
||
* }
|
||
* change-of-life-safety [8] SEQUENCE {
|
||
* time-delay [0] Unsigned,
|
||
* list-of-life-safety-alarm-values [1] SEQUENCE OF BACnetLifeSafetyState,
|
||
* list-of-alarm-values [2] SEQUENCE OF BACnetLifeSafetyState,
|
||
* mode-property-reference [3] BACnetDeviceObjectPropertyReference
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fEventParameter (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetLogRecord ::= SEQUENCE {
|
||
* timestamp [0] BACnetDateTime,
|
||
* logDatum [1] CHOICE {
|
||
* log-status [0] BACnetLogStatus,
|
||
* boolean-value [1] BOOLEAN,
|
||
* real-value [2] REAL,
|
||
* enum-value [3] ENUMERATED, -- Optionally limited to 32 bits
|
||
* unsigned-value [4] Unsigned, -- Optionally limited to 32 bits
|
||
* signed-value [5] INTEGER, -- Optionally limited to 32 bits
|
||
* bitstring-value [6] BIT STRING,-- Optionally limited to 32 bits
|
||
* null-value [7] NULL,
|
||
* failure [8] Error,
|
||
* time-change [9] REAL,
|
||
* any-value [10] ABSTRACT-SYNTAX.&Type -- Optional
|
||
* }
|
||
* statusFlags [2] BACnetStatusFlags OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fLogRecord (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetNotificationParameters ::= CHOICE {
|
||
* change-of-bitstring [0] SEQUENCE {
|
||
* referenced-bitstring [0] BIT STRING,
|
||
* status-flags [1] BACnetStatusFlags
|
||
* },
|
||
* change-of-state [1] SEQUENCE {
|
||
* new-state [0] BACnetPropertyStatus,
|
||
* status-flags [1] BACnetStatusFlags
|
||
* },
|
||
* change-of-value [2] SEQUENCE {
|
||
* new-value [0] CHOICE {
|
||
* changed-bits [0] BIT STRING,
|
||
* changed-value [1] REAL
|
||
* },
|
||
* status-flags [1] BACnetStatusFlags
|
||
* },
|
||
* command-failure [3] SEQUENCE {
|
||
* command-value [0] ABSTRACT-SYNTAX.&Type, -- depends on ref property
|
||
* status-flags [1] BACnetStatusFlags
|
||
* feedback-value [2] ABSTRACT-SYNTAX.&Type -- depends on ref property
|
||
* },
|
||
* floating-limit [4] SEQUENCE {
|
||
* reference-value [0] REAL,
|
||
* status-flags [1] BACnetStatusFlags
|
||
* setpoint-value [2] REAL,
|
||
* error-limit [3] REAL
|
||
* },
|
||
* out-of-range [5] SEQUENCE {
|
||
* exceeding-value [0] REAL,
|
||
* status-flags [1] BACnetStatusFlags
|
||
* deadband [2] REAL,
|
||
* exceeded-limit [0] REAL
|
||
* },
|
||
* complex-event-type [6] SEQUENCE OF BACnetPropertyValue,
|
||
* buffer-ready [7] SEQUENCE {
|
||
* buffer-device [0] BACnetObjectIdentifier,
|
||
* buffer-object [1] BACnetObjectIdentifier
|
||
* previous-notification [2] BACnetDateTime,
|
||
* current-notification [3] BACnetDateTime
|
||
* },
|
||
* change-of-life-safety [8] SEQUENCE {
|
||
* new-state [0] BACnetLifeSafetyState,
|
||
* new-mode [1] BACnetLifeSafetyState
|
||
* status-flags [2] BACnetStatusFlags,
|
||
* operation-expected [3] BACnetLifeSafetyOperation
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fNotificationParameters (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetObjectPropertyReference ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fBACnetObjectPropertyReference (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetObjectPropertyValue ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* propertyIdentifier [1] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [2] Unsigned OPTIONAL, -- used only with array datatype
|
||
* -- if omitted with an array the entire array is referenced
|
||
* value [3] ABSTRACT-SYNTAX.&Type, --any datatype appropriate for the specified property
|
||
* priority [4] Unsigned (1..16) OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fObjectPropertyValue (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetPriorityArray ::= SEQUENCE SIZE (16) OF BACnetPriorityValue
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fPriorityArray (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
static guint
|
||
fPropertyReference (tvbuff_t *tvb, proto_tree *tree, guint offset, guint8 tagoffset, guint8 list);
|
||
|
||
/**
|
||
* BACnetPropertyReference ::= SEQUENCE {
|
||
* propertyIdentifier [0] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [1] Unsigned OPTIONAL, -- used only with array datatype
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fBACnetPropertyReference (tvbuff_t *tvb, proto_tree *tree, guint offset, guint8 list);
|
||
|
||
static guint
|
||
fBACnetObjectPropertyReference (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetPropertyValue ::= SEQUENCE {
|
||
* PropertyIdentifier [0] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [1] Unsigned OPTIONAL, -- used only with array datatypes
|
||
* -- if omitted with an array the entire array is referenced
|
||
* value [2] ABSTRACT-SYNTAX.&Type, -- any datatype appropriate for the specified property
|
||
* priority [3] Unsigned (1..16) OPTIONAL -- used only when property is commandable
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fBACnetPropertyValue (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
static guint
|
||
fPropertyValue (tvbuff_t *tvb, proto_tree *tree, guint offset, guint8 tagoffset);
|
||
|
||
/**
|
||
* BACnet Application PDUs chapter 21
|
||
* BACnetRecipient::= CHOICE {
|
||
* device [0] BACnetObjectIdentifier
|
||
* address [1] BACnetAddress
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fRecipient (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnet Application PDUs chapter 21
|
||
* BACnetRecipientProcess::= SEQUENCE {
|
||
* recipient [0] BACnetRecipient
|
||
* processID [1] Unsigned32
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fRecipientProcess (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetSessionKey ::= SEQUENCE {
|
||
* sessionKey OCTET STRING (SIZE(8)), -- 56 bits for key, 8 bits for checksum
|
||
* peerAddress BACnetAddress
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
* @todo check if checksum is displayed correctly
|
||
*/
|
||
static guint
|
||
fSessionKey (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetSetpointReference ::= SEQUENCE {
|
||
* sessionKey [0] BACnetObjectPropertyReference OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSetpointReference (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetSpecialEvent ::= SEQUENCE {
|
||
* period CHOICE {
|
||
* calendarEntry [0] BACnetCalendarEntry,
|
||
* calendarRefernce [1] BACnetObjectIdentifier
|
||
* },
|
||
* listOfTimeValues [2] SEQUENCE OF BACnetTimeValue,
|
||
* eventPriority [3] Unsigned (1..16)
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSpecialEvent (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetTimeStamp ::= CHOICE {
|
||
* time [0] Time,
|
||
* sequenceNumber [1] Unsigned (0..65535),
|
||
* dateTime [2] BACnetDateTime
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fTimeStamp (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* BACnetTimeValue ::= SEQUENCE {
|
||
* time Time,
|
||
* value ABSTRACT-SYNTAX.&Type -- any primitive datatype, complex types cannot be decoded
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fTimeValue (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
#if 0
|
||
/**
|
||
* BACnetVTSession ::= SEQUENCE {
|
||
* local-vtSessionID Unsigned8,
|
||
* remote-vtSessionID Unsigned8,
|
||
* remote-vtAddress BACnetAddress
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fVTSession (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
#endif
|
||
|
||
/**
|
||
* BACnetWeekNDay ::= OCTET STRING (SIZE (3))
|
||
* -- first octet month (1..12) January = 1, X'FF' = any month
|
||
* -- second octet weekOfMonth where: 1 = days numbered 1-7
|
||
* -- 2 = days numbered 8-14
|
||
* -- 3 = days numbered 15-21
|
||
* -- 4 = days numbered 22-28
|
||
* -- 5 = days numbered 29-31
|
||
* -- 6 = last 7 days of this month
|
||
* -- X<>FF<46> = any week of this month
|
||
* -- third octet dayOfWeek (1..7) where 1 = Monday
|
||
* -- 7 = Sunday
|
||
* -- X'FF' = any day of week
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWeekNDay (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadAccessResult ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* listOfResults [1] SEQUENCE OF SEQUENCE {
|
||
* propertyIdentifier [2] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [3] Unsigned OPTIONAL, -- used only with array datatype if omitted with an array the entire array is referenced
|
||
* readResult CHOICE {
|
||
* propertyValue [4] ABSTRACT-SYNTAX.&Type,
|
||
* propertyAccessError [5] Error
|
||
* }
|
||
* } OPTIONAL
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadAccessResult (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* ReadAccessSpecification ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* listOfPropertyReferences [1] SEQUENCE OF BACnetPropertyReference
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fReadAccessSpecification (tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
/**
|
||
* WriteAccessSpecification ::= SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* listOfProperty [1] SEQUENCE OF BACnetPropertyValue
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fWriteAccessSpecification (tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
|
||
/********************************************************* Helper functions *******************************************/
|
||
|
||
/**
|
||
* extracts the tag number from the tag header.
|
||
* @param tvb "TestyVirtualBuffer"
|
||
* @param offset in actual tvb
|
||
* @return Tag Number corresponding to BACnet 20.2.1.2 Tag Number
|
||
*/
|
||
static guint
|
||
fTagNo (tvbuff_t *tvb, guint offset);
|
||
|
||
/**
|
||
* splits Tag Header coresponding to 20.2.1 General Rules For BACnet Tags
|
||
* @param tvb = "TestyVirtualBuffer"
|
||
* @param offset = offset in actual tvb
|
||
* @return tag_no BACnet 20.2.1.2 Tag Number
|
||
* @return class_tag BACnet 20.2.1.1 Class
|
||
* @return lvt BACnet 20.2.1.3 Length/Value/Type
|
||
* @return offs = length of this header
|
||
*/
|
||
|
||
static guint
|
||
fTagHeader (tvbuff_t *tvb, guint offset, guint8 *tag_no, guint8* class_tag, guint32 *lvt);
|
||
|
||
|
||
/**
|
||
* adds processID with max 32Bit unsigned Integer Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fProcessId (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* adds timeSpan with max 32Bit unsigned Integer Value to tree
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fTimeSpan (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* BACnet Application PDUs chapter 21
|
||
* BACnetPropertyIdentifier::= ENUMERATED {
|
||
* @see bacapp_property_identifier
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @param tt returnvalue of this item
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fPropertyIdentifier (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* listOfEventSummaries ::= SEQUENCE OF SEQUENCE {
|
||
* objectIdentifier [0] BACnetObjectIdentifier,
|
||
* eventState [1] BACnetEventState,
|
||
* acknowledgedTransitions [2] BACnetEventTransitionBits,
|
||
* eventTimeStamps [3] SEQURNCE SIZE (3) OF BACnetTimeStamps,
|
||
* notifyType [4] BACnetNotifyType,
|
||
* eventEnable [5] BACnetEventTransitionBits,
|
||
* eventPriorities [6] SEQUENCE SIZE (3) OF Unsigned
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
flistOfEventSummaries (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* SelectionCriteria ::= SEQUENCE {
|
||
* propertyIdentifier [0] BACnetPropertyIdentifier,
|
||
* propertyArrayIndex [1] Unsigned OPTIONAL, -- used only with array datatype
|
||
* relationSpecifier [2] ENUMERATED { bacapp_relationSpecifier },
|
||
* comparisonValue [3] ABSTRACT-SYNTAX.&Type
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fSelectionCriteria (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* objectSelectionCriteria ::= SEQUENCE {
|
||
* selectionLogic [0] ENUMERATED { bacapp_selectionLogic },
|
||
* listOfSelectionCriteria [1] SelectionCriteria
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fObjectSelectionCriteria (tvbuff_t *tvb, proto_tree *subtree, guint offset);
|
||
|
||
/**
|
||
* BACnet-Error ::= SEQUENCE {
|
||
* error-class ENUMERATED {},
|
||
* error-code ENUMERATED {}
|
||
* }
|
||
* }
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
*/
|
||
static guint
|
||
fError(tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* Generic handler for context tagged values. Mostly for handling
|
||
* vendor-defined properties and services.
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
* @todo beautify this ugly construct
|
||
*/
|
||
static guint
|
||
fContextTaggedValue(tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
|
||
|
||
/**
|
||
* realizes some ABSTRACT-SYNTAX.&Type
|
||
* @param tvb
|
||
* @param tree
|
||
* @param offset
|
||
* @return modified offset
|
||
* @todo beautify this ugly construct
|
||
*/
|
||
static guint
|
||
fAbstractSyntaxNType (tvbuff_t *tvb, proto_tree *tree, guint offset);
|
||
|
||
/**
|
||
* register_bacapp
|
||
*/
|
||
void
|
||
proto_register_bacapp(void);
|
||
|
||
/**
|
||
* proto_reg_handoff_bacapp
|
||
*/
|
||
void
|
||
proto_reg_handoff_bacapp(void);
|
||
|
||
/**
|
||
* converts XXX coded strings to UTF-8 if iconv is allowed
|
||
* else 'in' is copied to 'out'
|
||
* @param in -- pointer to string
|
||
* @param inbytesleft
|
||
* @param out -- pointer to string
|
||
* @param outbytesleft
|
||
* @param fromcoding
|
||
* @return count of modified characters of returned string, -1 for errors
|
||
*/
|
||
guint32
|
||
fConvertXXXtoUTF8(const guint8 *in, size_t *inbytesleft,guint8 *out, size_t *outbytesleft, const gchar *fromcoding);
|
||
|
||
#endif /* __BACAPP_H__ */
|
||
|
||
|