osmith/wireshark
1
0
Fork 0
forked from osmocom/wireshark
Code Pull requests Releases Wiki Activity
wireshark/epan/dissectors/packet-bacapp.h
Jaap Keuter b002a79472 From Steve Karg: 
Attached is a patch that fixes bug 1670 and related issues.
For the BACnet GetEventInformation-ACK request dissector:
1. Corrected BitString decoding for acknowledgedTransitions and eventEnable.
2. Corrected the ability to decode more than one event.
3. Grouped each item of the sequence using subtrees.  Added more informative
text to Priority and Timestamp.
4. Corrected eventState to use BACnetEventState enumeration instead of
BACnetEventStateFilter.

svn path=/trunk/; revision=22262
2007-07-06 22:36:58 +00:00

2078 lines
53 KiB
C
Raw Blame History

/* 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
* @param label
* @return modified offset
*/
static guint
fTimeStamp (tvbuff_t *tvb, proto_tree *tree, guint offset, const gchar *label);
/**
* 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__ */
View git blame Copy permalink