/* packet-bacapp.h * Routines for BACnet (APDU) dissection * Copyright 2004, Herbert Lischka , Berlin * * $Id$ * * Wireshark - Network traffic analyzer * By Gerald Combs * 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 #endif #endif #include #include #include #include #include #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’ = 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__ */