private void m_comm_OnAbort(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, byte invoke_id, byte reason, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Error = new Exception("Abort from device: " + reason);
}
}
private void m_comm_OnSimpleAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] data, int data_offset, int data_length)
{
if (invoke_id == m_wait_invoke_id)
{
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set();
}
}
public static void EncodeSegmentAck(EncodeBuffer buffer, BacnetPduTypes type, byte originalInvokeId, byte sequenceNumber, byte actualWindowSize)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = originalInvokeId;
buffer.buffer[buffer.offset++] = sequenceNumber;
buffer.buffer[buffer.offset++] = actualWindowSize;
}
public static void EncodeSegmentAck(EncodeBuffer buffer, BacnetPduTypes type, byte original_invoke_id, byte sequence_number, byte actual_window_size)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = original_invoke_id;
buffer.buffer[buffer.offset++] = sequence_number;
buffer.buffer[buffer.offset++] = actual_window_size;
}
private void m_comm_OnError(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetErrorClasses error_class, BacnetErrorCodes error_code, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Error = new Exception("Error from device: " + error_class + " - " + error_code);
}
}
private void m_comm_OnSegment(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetMaxSegments max_segments, BacnetMaxApdu max_adpu, byte sequence_number, bool first, bool more_follows, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Segmented = true;
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set();
}
}
public static int DecodeUnconfirmedServiceRequest(byte[] buffer, int offset, out BacnetPduTypes type, out BacnetUnconfirmedServices service)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
service = (BacnetUnconfirmedServices)buffer[offset++];
return(offset - org_offset);
}
private void OnAbort(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, byte invokeId, byte reason, byte[] buffer, int offset, int length)
{
if (invokeId != _waitInvokeId)
{
return;
}
Error = new Exception("Abort from device: " + reason);
}
private void OnSimpleAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invokeId, byte[] data, int dataOffset, int dataLength)
{
if (invokeId != _waitInvokeId)
{
return;
}
_waitHandle.Set();
}
private void OnError(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invokeId, BacnetErrorClasses errorClass, BacnetErrorCodes errorCode, byte[] buffer, int offset, int length)
{
if (invokeId != _waitInvokeId)
{
return;
}
Error = new Exception("Error from device: " + errorClass + " - " + errorCode);
}
public static int DecodeError(byte[] buffer, int offset, out BacnetPduTypes type, out BacnetConfirmedServices service, out byte invokeId)
{
var orgOffset = offset;
type = (BacnetPduTypes)buffer[offset++];
invokeId = buffer[offset++];
service = (BacnetConfirmedServices)buffer[offset++];
return(offset - orgOffset);
}
private void OnSegment(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invokeId, BacnetMaxSegments maxSegments, BacnetMaxAdpu maxAdpu, byte sequenceNumber, bool first, bool moreFollows, byte[] buffer, int offset, int length)
{
if (invokeId != _waitInvokeId)
{
return;
}
Segmented = true;
_waitHandle.Set();
}
public static int DecodeSimpleAck(byte[] buffer, int offset, out BacnetPduTypes type, out BacnetConfirmedServices service, out byte invoke_id)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
invoke_id = buffer[offset++];
service = (BacnetConfirmedServices)buffer[offset++];
return(offset - org_offset);
}
public static int DecodeAbort(byte[] buffer, int offset, out BacnetPduTypes type, out byte invoke_id, out byte reason)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
invoke_id = buffer[offset++];
reason = buffer[offset++];
return(offset - org_offset);
}
public static int DecodeSegmentAck(byte[] buffer, int offset, out BacnetPduTypes type, out byte originalInvokeId, out byte sequenceNumber, out byte actualWindowSize)
{
var orgOffset = offset;
type = (BacnetPduTypes)buffer[offset++];
originalInvokeId = buffer[offset++];
sequenceNumber = buffer[offset++];
actualWindowSize = buffer[offset++];
return(offset - orgOffset);
}
private static int DecodeAbortOrReject <TReason>(byte[] buffer, int offset,
out BacnetPduTypes type, out byte invokeId, out TReason reason)
{
var orgOffset = offset;
type = (BacnetPduTypes)buffer[offset++];
invokeId = buffer[offset++];
reason = (TReason)(dynamic)buffer[offset++];
return(offset - orgOffset);
}
public static int DecodeSegmentAck(byte[] buffer, int offset, out BacnetPduTypes type, out byte original_invoke_id, out byte sequence_number, out byte actual_window_size)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
original_invoke_id = buffer[offset++];
sequence_number = buffer[offset++];
actual_window_size = buffer[offset++];
return(offset - org_offset);
}
public static void EncodeConfirmedServiceRequest(EncodeBuffer buffer, BacnetPduTypes type, BacnetConfirmedServices service, BacnetMaxSegments max_segments, BacnetMaxApdu max_adpu, byte invoke_id, byte sequence_number, byte proposed_window_size)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = (byte)((byte)max_segments | (byte)max_adpu);
buffer.buffer[buffer.offset++] = invoke_id;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) > 0)
{
buffer.buffer[buffer.offset++] = sequence_number;
buffer.buffer[buffer.offset++] = proposed_window_size;
}
buffer.buffer[buffer.offset++] = (byte)service;
}
private void m_comm_OnComplexAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Segmented = false;
m_result = new byte[length];
if (length > 0)
{
Array.Copy(buffer, offset, m_result, 0, length);
}
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set(); //notify waiter even if segmented
}
}
public static int EncodeComplexAck(EncodeBuffer buffer, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte sequence_number, byte proposed_window_number)
{
int len = 3;
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = invoke_id;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) > 0)
{
buffer.buffer[buffer.offset++] = sequence_number;
buffer.buffer[buffer.offset++] = proposed_window_number;
len += 2;
}
buffer.buffer[buffer.offset++] = (byte)service;
return(len);
}
public static int DecodeComplexAck(byte[] buffer, int offset, out BacnetPduTypes type, out BacnetConfirmedServices service, out byte invoke_id, out byte sequence_number, out byte proposed_window_number)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
invoke_id = buffer[offset++];
sequence_number = 0;
proposed_window_number = 0;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) > 0)
{
sequence_number = buffer[offset++];
proposed_window_number = buffer[offset++];
}
service = (BacnetConfirmedServices)buffer[offset++];
return(offset - org_offset);
}
private void OnComplexAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invokeId, byte[] buffer, int offset, int length)
{
if (invokeId != _waitInvokeId)
{
return;
}
Segmented = false;
Result = new byte[length];
if (length > 0)
{
Array.Copy(buffer, offset, Result, 0, length);
}
//notify waiter even if segmented
_waitHandle.Set();
}
public static int GetDecodedInvokeId(byte[] buffer, int offset)
{
BacnetPduTypes type = GetDecodedType(buffer, offset);
switch (type & BacnetPduTypes.PDU_TYPE_MASK)
{
case BacnetPduTypes.PDU_TYPE_SIMPLE_ACK:
case BacnetPduTypes.PDU_TYPE_COMPLEX_ACK:
case BacnetPduTypes.PDU_TYPE_ERROR:
case BacnetPduTypes.PDU_TYPE_REJECT:
case BacnetPduTypes.PDU_TYPE_ABORT:
return(buffer[offset + 1]);
case BacnetPduTypes.PDU_TYPE_CONFIRMED_SERVICE_REQUEST:
return(buffer[offset + 2]);
default:
return(-1);
}
}
public static int DecodeConfirmedServiceRequest(byte[] buffer, int offset, out BacnetPduTypes type, out BacnetConfirmedServices service, out BacnetMaxSegments max_segments, out BacnetMaxApdu max_adpu, out byte invoke_id, out byte sequence_number, out byte proposed_window_number)
{
int org_offset = offset;
type = (BacnetPduTypes)buffer[offset++];
max_segments = (BacnetMaxSegments)(buffer[offset] & 0xF0);
max_adpu = (BacnetMaxApdu)(buffer[offset++] & 0x0F);
invoke_id = buffer[offset++];
sequence_number = 0;
proposed_window_number = 0;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) > 0)
{
sequence_number = buffer[offset++];
proposed_window_number = buffer[offset++];
}
service = (BacnetConfirmedServices)buffer[offset++];
return(offset - org_offset);
}
protected void ProcessError(BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("Error", null);
BacnetErrorClasses error_class;
BacnetErrorCodes error_code;
if (Services.DecodeError(buffer, offset, length, out error_class, out error_code) < 0)
Trace.TraceWarning("Couldn't decode Error");
if (OnError != null) OnError(this, adr, type, service, invoke_id, error_class, error_code, buffer, offset, length);
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessError: " + ex.Message);
}
}
protected void ProcessSegmentAck(BacnetAddress adr, BacnetPduTypes type, byte original_invoke_id, byte sequence_number, byte actual_window_size, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("SegmentAck", null);
if (OnSegmentAck != null) OnSegmentAck(this, adr, type, original_invoke_id, sequence_number, actual_window_size, buffer, offset, length);
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessSegmentAck: " + ex.Message);
}
}
private static void EncodeAbortOrReject(EncodeBuffer buffer, BacnetPduTypes type, byte invokeId, dynamic reason)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = invokeId;
buffer.buffer[buffer.offset++] = (byte)reason;
}
protected void ProcessSimpleAck(BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("SimpleAck", null);
if (OnSimpleAck != null) OnSimpleAck(this, adr, type, service, invoke_id, buffer, offset, length);
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessSimpleAck: " + ex.Message);
}
}
public static void SetDecodedType(byte[] buffer, int offset, BacnetPduTypes type)
{
buffer[offset] = (byte)type;
}
public static void EncodeUnconfirmedServiceRequest(EncodeBuffer buffer, BacnetPduTypes type, BacnetUnconfirmedServices service)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = (byte)service;
}
private void m_comm_OnSimpleAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] data, int data_offset, int data_length)
{
if (invoke_id == m_wait_invoke_id)
{
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set();
}
}
protected void ProcessUnconfirmedServiceRequest(BacnetAddress adr, BacnetPduTypes type, BacnetUnconfirmedServices service, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("UnconfirmedServiceRequest", null);
if (OnUnconfirmedServiceRequest != null) OnUnconfirmedServiceRequest(this, adr, type, service, buffer, offset, length);
if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_I_AM && OnIam != null)
{
uint device_id;
uint max_adpu;
BacnetSegmentations segmentation;
ushort vendor_id;
if (Services.DecodeIamBroadcast(buffer, offset, out device_id, out max_adpu, out segmentation, out vendor_id) >= 0)
OnIam(this, adr, device_id, max_adpu, segmentation, vendor_id);
else
Trace.TraceWarning("Couldn't decode IamBroadcast");
}
else if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_WHO_IS && OnWhoIs != null)
{
int low_limit;
int high_limit;
if (Services.DecodeWhoIsBroadcast(buffer, offset, length, out low_limit, out high_limit) >= 0)
OnWhoIs(this, adr, low_limit, high_limit);
else
Trace.TraceWarning("Couldn't decode WhoIsBroadcast");
}
else if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_COV_NOTIFICATION && OnCOVNotification != null)
{
uint subscriberProcessIdentifier;
BacnetObjectId initiatingDeviceIdentifier;
BacnetObjectId monitoredObjectIdentifier;
uint timeRemaining;
ICollection<BacnetPropertyValue> values;
if (Services.DecodeCOVNotifyUnconfirmed(buffer, offset, length, out subscriberProcessIdentifier, out initiatingDeviceIdentifier, out monitoredObjectIdentifier, out timeRemaining, out values) >= 0)
OnCOVNotification(this, adr, 0, subscriberProcessIdentifier, initiatingDeviceIdentifier, monitoredObjectIdentifier, timeRemaining, false, values, BacnetMaxSegments.MAX_SEG0);
else
Trace.TraceWarning("Couldn't decode COVNotifyUnconfirmed");
}
else if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_TIME_SYNCHRONIZATION && OnTimeSynchronize != null)
{
DateTime dateTime;
if (Services.DecodeTimeSync(buffer, offset, length, out dateTime) >= 0)
OnTimeSynchronize(this, adr, dateTime, false);
else
Trace.TraceWarning("Couldn't decode TimeSynchronize");
}
else if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_UTC_TIME_SYNCHRONIZATION && OnTimeSynchronize != null)
{
DateTime dateTime;
if (Services.DecodeTimeSync(buffer, offset, length, out dateTime) >= 0)
OnTimeSynchronize(this, adr, dateTime, true);
else
Trace.TraceWarning("Couldn't decode TimeSynchronize");
}
else if (service == BacnetUnconfirmedServices.SERVICE_UNCONFIRMED_EVENT_NOTIFICATION && OnEventNotify!=null) // F. Chaxel
{
BacnetEventNotificationData EventData;
if (Services.DecodeEventNotifyData(buffer, offset, length, out EventData) >= 0)
{
OnEventNotify(this, adr, EventData);
}
else
Trace.TraceWarning("Couldn't decode Event/Alarm Notification");
}
else
{
Trace.TraceWarning("Unconfirmed service not handled: " + service.ToString());
}
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessUnconfirmedServiceRequest: " + ex.Message);
}
}
/// <summary>
/// Also EncodeReject
/// </summary>
/// <param name="buffer"></param>
/// <param name="offset"></param>
/// <param name="type"></param>
/// <param name="invoke_id"></param>
/// <param name="reason"></param>
/// <returns></returns>
public static void EncodeAbort(EncodeBuffer buffer, BacnetPduTypes type, byte invoke_id, byte reason)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = invoke_id;
buffer.buffer[buffer.offset++] = reason;
}
private void m_comm_OnComplexAck(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Segmented = false;
m_result = new byte[length];
if (length > 0) Array.Copy(buffer, offset, m_result, 0, length);
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set(); //notify waiter even if segmented
}
}
private void ProcessSegment(BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetMaxSegments max_segments, BacnetMaxAdpu max_adpu, bool server, byte sequence_number, byte proposed_window_number, byte[] buffer, int offset, int length)
{
bool first = false;
if (sequence_number == 0 && m_last_sequence_number == 0)
{
first = true;
}
else
{
//send negative ack
if (sequence_number != (m_last_sequence_number + 1))
{
SegmentAckResponse(adr, true, server, invoke_id, m_last_sequence_number, proposed_window_number);
Trace.WriteLine("Segment sequence out of order", null);
return;
}
}
m_last_sequence_number = sequence_number;
bool more_follows = (type & BacnetPduTypes.MORE_FOLLOWS) == BacnetPduTypes.MORE_FOLLOWS;
if (!more_follows) m_last_sequence_number = 0; //reset last sequence_number
//send ACK
if ((sequence_number % proposed_window_number) == 0 || !more_follows)
{
if (m_force_window_size) proposed_window_number = m_proposed_window_size;
SegmentAckResponse(adr, false, server, invoke_id, sequence_number, proposed_window_number);
}
//Send on
if (OnSegment != null)
OnSegment(this, adr, type, service, invoke_id, max_segments, max_adpu, sequence_number, first, more_follows, buffer, offset, length);
//default segment assembly. We run this separately from the above handler, to make sure that it comes after!
if (m_default_segmentation_handling)
PerformDefaultSegmentHandling(this, adr, type, service, invoke_id, max_segments, max_adpu, sequence_number, first, more_follows, buffer, offset, length);
}
private void ProcessApdu(BacnetAddress adr, BacnetPduTypes type, byte[] buffer, int offset, int length)
{
switch (type & BacnetPduTypes.PDU_TYPE_MASK)
{
case BacnetPduTypes.PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST:
{
BacnetUnconfirmedServices service;
int apdu_header_len = APDU.DecodeUnconfirmedServiceRequest(buffer, offset, out type, out service);
offset += apdu_header_len;
length -= apdu_header_len;
ProcessUnconfirmedServiceRequest(adr, type, service, buffer, offset, length);
}
break;
case BacnetPduTypes.PDU_TYPE_SIMPLE_ACK:
{
BacnetConfirmedServices service;
byte invoke_id;
int apdu_header_len = APDU.DecodeSimpleAck(buffer, offset, out type, out service, out invoke_id);
offset += apdu_header_len;
length -= apdu_header_len;
ProcessSimpleAck(adr, type, service, invoke_id, buffer, offset, length);
}
break;
case BacnetPduTypes.PDU_TYPE_COMPLEX_ACK:
{
BacnetConfirmedServices service;
byte invoke_id;
byte sequence_number;
byte proposed_window_number;
int apdu_header_len = APDU.DecodeComplexAck(buffer, offset, out type, out service, out invoke_id, out sequence_number, out proposed_window_number);
offset += apdu_header_len;
length -= apdu_header_len;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) == 0) //don't process segmented messages here
{
ProcessComplexAck(adr, type, service, invoke_id, buffer, offset, length);
}
else
{
ProcessSegment(adr, type, service, invoke_id, BacnetMaxSegments.MAX_SEG0, BacnetMaxAdpu.MAX_APDU50, false, sequence_number, proposed_window_number, buffer, offset, length);
}
}
break;
case BacnetPduTypes.PDU_TYPE_SEGMENT_ACK:
{
byte original_invoke_id;
byte sequence_number;
byte actual_window_size;
int apdu_header_len = APDU.DecodeSegmentAck(buffer, offset, out type, out original_invoke_id, out sequence_number, out actual_window_size);
offset += apdu_header_len;
length -= apdu_header_len;
m_last_segment_ack.Set(adr, original_invoke_id, sequence_number, actual_window_size);
ProcessSegmentAck(adr, type, original_invoke_id, sequence_number, actual_window_size, buffer, offset, length);
}
break;
case BacnetPduTypes.PDU_TYPE_ERROR:
{
BacnetConfirmedServices service;
byte invoke_id;
int apdu_header_len = APDU.DecodeError(buffer, offset, out type, out service, out invoke_id);
offset += apdu_header_len;
length -= apdu_header_len;
ProcessError(adr, type, service, invoke_id, buffer, offset, length);
}
break;
case BacnetPduTypes.PDU_TYPE_REJECT:
case BacnetPduTypes.PDU_TYPE_ABORT:
{
byte invoke_id;
byte reason;
int apdu_header_len = APDU.DecodeAbort(buffer, offset, out type, out invoke_id, out reason);
offset += apdu_header_len;
length -= apdu_header_len;
ProcessAbort(adr, type, invoke_id, reason, buffer, offset, length);
}
break;
case BacnetPduTypes.PDU_TYPE_CONFIRMED_SERVICE_REQUEST:
{
BacnetConfirmedServices service;
BacnetMaxSegments max_segments;
BacnetMaxAdpu max_adpu;
byte invoke_id;
byte sequence_number;
byte proposed_window_number;
int apdu_header_len = APDU.DecodeConfirmedServiceRequest(buffer, offset, out type, out service, out max_segments, out max_adpu, out invoke_id, out sequence_number, out proposed_window_number);
offset += apdu_header_len;
length -= apdu_header_len;
if ((type & BacnetPduTypes.SEGMENTED_MESSAGE) == 0) //don't process segmented messages here
{
ProcessConfirmedServiceRequest(adr, type, service, max_segments, max_adpu, invoke_id, buffer, offset, length);
}
else
{
ProcessSegment(adr, type, service, invoke_id, max_segments, max_adpu, true, sequence_number, proposed_window_number, buffer, offset, length);
}
}
break;
default:
Trace.TraceWarning("Something else arrived: " + type);
break;
}
}
protected void ProcessConfirmedServiceRequest(BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, BacnetMaxSegments max_segments, BacnetMaxAdpu max_adpu, byte invoke_id, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("ConfirmedServiceRequest", null);
raw_buffer = buffer;
raw_length = length;
raw_offset = offset;
if (OnConfirmedServiceRequest != null)
OnConfirmedServiceRequest(this, adr, type, service, max_segments, max_adpu, invoke_id, buffer, offset, length);
//don't send segmented messages, if client don't want it
if ((type & BacnetPduTypes.SEGMENTED_RESPONSE_ACCEPTED) == 0)
max_segments = BacnetMaxSegments.MAX_SEG0;
if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROPERTY && OnReadPropertyRequest != null)
{
BacnetObjectId object_id;
BacnetPropertyReference property;
if (Services.DecodeReadProperty(buffer, offset, length, out object_id, out property) >= 0)
OnReadPropertyRequest(this, adr, invoke_id, object_id, property, max_segments);
else
Trace.TraceWarning("Couldn't decode DecodeReadProperty");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY && OnWritePropertyRequest != null)
{
BacnetObjectId object_id;
BacnetPropertyValue value;
if (Services.DecodeWriteProperty(buffer, offset, length, out object_id, out value) >= 0)
OnWritePropertyRequest(this, adr, invoke_id, object_id, value, max_segments);
else
Trace.TraceWarning("Couldn't decode DecodeWriteProperty");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROP_MULTIPLE && OnReadPropertyMultipleRequest != null)
{
IList<BacnetReadAccessSpecification> properties;
if (Services.DecodeReadPropertyMultiple(buffer, offset, length, out properties) >= 0)
OnReadPropertyMultipleRequest(this, adr, invoke_id, properties, max_segments);
else
Trace.TraceWarning("Couldn't decode DecodeReadPropertyMultiple");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROP_MULTIPLE && OnWritePropertyMultipleRequest != null)
{
BacnetObjectId object_id;
ICollection<BacnetPropertyValue> values;
if (Services.DecodeWritePropertyMultiple(buffer, offset, length, out object_id, out values) >= 0)
OnWritePropertyMultipleRequest(this, adr, invoke_id, object_id, values, max_segments);
else
Trace.TraceWarning("Couldn't decode DecodeWritePropertyMultiple");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_COV_NOTIFICATION && OnCOVNotification != null)
{
uint subscriberProcessIdentifier;
BacnetObjectId initiatingDeviceIdentifier;
BacnetObjectId monitoredObjectIdentifier;
uint timeRemaining;
ICollection<BacnetPropertyValue> values;
if (Services.DecodeCOVNotifyUnconfirmed(buffer, offset, length, out subscriberProcessIdentifier, out initiatingDeviceIdentifier, out monitoredObjectIdentifier, out timeRemaining, out values) >= 0)
OnCOVNotification(this, adr, invoke_id, subscriberProcessIdentifier, initiatingDeviceIdentifier, monitoredObjectIdentifier, timeRemaining, true, values, max_segments);
else
Trace.TraceWarning("Couldn't decode COVNotify");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_ATOMIC_WRITE_FILE && OnAtomicWriteFileRequest != null)
{
bool is_stream;
BacnetObjectId object_id;
int position;
uint block_count;
byte[][] blocks;
int[] counts;
if (Services.DecodeAtomicWriteFile(buffer, offset, length, out is_stream, out object_id, out position, out block_count, out blocks, out counts) >= 0)
OnAtomicWriteFileRequest(this, adr, invoke_id, is_stream, object_id, position, block_count, blocks, counts, max_segments);
else
Trace.TraceWarning("Couldn't decode AtomicWriteFile");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_ATOMIC_READ_FILE && OnAtomicReadFileRequest != null)
{
bool is_stream;
BacnetObjectId object_id;
int position;
uint count;
if (Services.DecodeAtomicReadFile(buffer, offset, length, out is_stream, out object_id, out position, out count) >= 0)
OnAtomicReadFileRequest(this, adr, invoke_id, is_stream, object_id, position, count, max_segments);
else
Trace.TraceWarning("Couldn't decode AtomicReadFile");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV && OnSubscribeCOV != null)
{
uint subscriberProcessIdentifier;
BacnetObjectId monitoredObjectIdentifier;
bool cancellationRequest;
bool issueConfirmedNotifications;
uint lifetime;
if (Services.DecodeSubscribeCOV(buffer, offset, length, out subscriberProcessIdentifier, out monitoredObjectIdentifier, out cancellationRequest, out issueConfirmedNotifications, out lifetime) >= 0)
OnSubscribeCOV(this, adr, invoke_id, subscriberProcessIdentifier, monitoredObjectIdentifier, cancellationRequest, issueConfirmedNotifications, lifetime, max_segments);
else
Trace.TraceWarning("Couldn't decode SubscribeCOV");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY && OnSubscribeCOVProperty != null)
{
uint subscriberProcessIdentifier;
BacnetObjectId monitoredObjectIdentifier;
BacnetPropertyReference monitoredProperty;
bool cancellationRequest;
bool issueConfirmedNotifications;
uint lifetime;
float covIncrement;
if (Services.DecodeSubscribeProperty(buffer, offset, length, out subscriberProcessIdentifier, out monitoredObjectIdentifier, out monitoredProperty, out cancellationRequest, out issueConfirmedNotifications, out lifetime, out covIncrement) >= 0)
OnSubscribeCOVProperty(this, adr, invoke_id, subscriberProcessIdentifier, monitoredObjectIdentifier, monitoredProperty, cancellationRequest, issueConfirmedNotifications, lifetime, covIncrement, max_segments);
else
Trace.TraceWarning("Couldn't decode SubscribeCOVProperty");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL && OnDeviceCommunicationControl != null)
{
uint timeDuration;
uint enable_disable;
string password;
if (Services.DecodeDeviceCommunicationControl(buffer, offset, length, out timeDuration, out enable_disable, out password) >= 0)
OnDeviceCommunicationControl(this, adr, invoke_id, timeDuration, enable_disable, password, max_segments);
else
Trace.TraceWarning("Couldn't decode DeviceCommunicationControl");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_REINITIALIZE_DEVICE && OnReinitializedDevice != null)
{
BacnetReinitializedStates state;
string password;
if (Services.DecodeReinitializeDevice(buffer, offset, length, out state, out password) >= 0)
OnReinitializedDevice(this, adr, invoke_id, state, password, max_segments);
else
Trace.TraceWarning("Couldn't decode ReinitializeDevice");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_EVENT_NOTIFICATION && OnEventNotify != null) // F. Chaxel
{
BacnetEventNotificationData EventData;
if (Services.DecodeEventNotifyData(buffer, offset, length, out EventData) >= 0)
{
OnEventNotify(this, adr, EventData);
}
else
Trace.TraceWarning("Couldn't decode Event/Alarm Notification");
}
else if (service == BacnetConfirmedServices.SERVICE_CONFIRMED_READ_RANGE && OnReadRange != null)
{
BacnetObjectId objectId;
BacnetPropertyReference property;
BacnetReadRangeRequestTypes requestType;
uint position;
DateTime time;
int count;
if (Services.DecodeReadRange(buffer, offset, length, out objectId, out property, out requestType, out position, out time, out count) >= 0)
{
OnReadRange(this, adr, invoke_id, objectId, property, requestType, position, time, count, max_segments);
}
else
Trace.TraceWarning("Couldn't decode ReadRange");
}
else
{
Trace.TraceWarning("Confirmed service not handled: " + service.ToString());
}
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessConfirmedServiceRequest: " + ex.Message);
}
}
public static void EncodeSimpleAck(EncodeBuffer buffer, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id)
{
buffer.buffer[buffer.offset++] = (byte)type;
buffer.buffer[buffer.offset++] = invoke_id;
buffer.buffer[buffer.offset++] = (byte)service;
}
protected void ProcessAbort(BacnetAddress adr, BacnetPduTypes type, byte invoke_id, byte reason, byte[] buffer, int offset, int length)
{
try
{
Trace.WriteLine("Abort", null);
if (OnAbort != null) OnAbort(this, adr, type, invoke_id, reason, buffer, offset, length);
}
catch (Exception ex)
{
Trace.TraceError("Error in ProcessAbort: " + ex.Message);
}
}
public static int DecodeReject(byte[] buffer, int offset, out BacnetPduTypes type,
out byte invokeId, out BacnetRejectReason reason)
{
return(DecodeAbortOrReject(buffer, offset, out type, out invokeId, out reason));
}
private void m_comm_OnAbort(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, byte invoke_id, byte reason, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Error = new Exception("Abort from device: " + reason);
}
}
private void m_comm_OnSegment(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetMaxSegments max_segments, BacnetMaxAdpu max_adpu, byte sequence_number, bool first, bool more_follows, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Segmented = true;
((System.Threading.ManualResetEvent)AsyncWaitHandle).Set();
}
}
/// <summary>
/// This is a simple handling that stores all segments in memory and assembles them when done
/// </summary>
private void PerformDefaultSegmentHandling(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetMaxSegments max_segments, BacnetMaxAdpu max_adpu, byte sequence_number, bool first, bool more_follows, byte[] buffer, int offset, int length)
{
if (first)
{
//clear any leftover segments
m_segments.Clear();
//copy buffer + encode new adpu header
type &= ~BacnetPduTypes.SEGMENTED_MESSAGE;
int adpu_header_len = 3;
if ((type & BacnetPduTypes.PDU_TYPE_MASK) == BacnetPduTypes.PDU_TYPE_CONFIRMED_SERVICE_REQUEST) adpu_header_len = 4;
byte[] copy = new byte[length + adpu_header_len];
Array.Copy(buffer, offset, copy, adpu_header_len, length);
if ((type & BacnetPduTypes.PDU_TYPE_MASK) == BacnetPduTypes.PDU_TYPE_CONFIRMED_SERVICE_REQUEST)
APDU.EncodeConfirmedServiceRequest(new EncodeBuffer(copy, 0), type, service, max_segments, max_adpu, invoke_id, 0, 0);
else
APDU.EncodeComplexAck(new EncodeBuffer(copy, 0), type, service, invoke_id, 0, 0);
m_segments.AddLast(copy); //doesn't include BVLC or NPDU
}
else
{
//copy only content part
byte[] copy = new byte[length];
Array.Copy(buffer, offset, copy, 0, copy.Length);
m_segments.AddLast(copy);
}
//process when finished
if (!more_follows)
{
//assemble whole part
byte[] apdu_buffer = AssembleSegments();
m_segments.Clear();
//process
ProcessApdu(adr, type, apdu_buffer, 0, apdu_buffer.Length);
}
}
private void m_comm_OnError(BacnetClient sender, BacnetAddress adr, BacnetPduTypes type, BacnetConfirmedServices service, byte invoke_id, BacnetErrorClasses error_class, BacnetErrorCodes error_code, byte[] buffer, int offset, int length)
{
if (invoke_id == m_wait_invoke_id)
{
Error = new Exception("Error from device: " + error_class + " - " + error_code);
}
}
