public DateTime ValueAsDateTime()
{
long seconds = 0;
if (_Length == 1)
{
seconds = _Value[0];
}
else if (_Length == 2)
{
seconds = NetworkByteOrderConverter.ToInt16(_Value, 0);
}
else if (_Length == 3)
{
byte[] buffer = new byte[4];
Buffer.BlockCopy(_Value, 0, buffer, 1, 3);
seconds = NetworkByteOrderConverter.ToInt32(buffer, 0);
}
else if (_Length == 4)
{
seconds = NetworkByteOrderConverter.ToInt32(_Value, 0);
}
else if (_Length == 8)
{
seconds = NetworkByteOrderConverter.ToInt64(_Value, 0);
}
else
{
throw new InvalidCastException();
}
return(_Epoch.AddSeconds(seconds));
}
public long ValueAsInt64()
{
long result;
if (_Length == 1)
{
result = _Value[0];
}
else if (_Length == 2)
{
result = NetworkByteOrderConverter.ToInt16(_Value, 0);
}
else if (_Length == 4)
{
result = NetworkByteOrderConverter.ToInt32(_Value, 0);
}
else if (_Length == 8)
{
result = NetworkByteOrderConverter.ToInt64(_Value, 0);
}
else
{
throw new InvalidCastException();
}
return(result);
}
public void Write(TTlvTypeIdentifier typeIdentifier, ushort identifier, short value)
{
if ((value > 127) || (value < -128)) //16Bit length
{
WriteType(typeIdentifier, identifier, 2);
NetworkByteOrderConverter.WriteInt16(_Stream, (short)value);
}
else
{
WriteType(typeIdentifier, identifier, 1);
_Stream.WriteByte((byte)value);
}
}
public static IPCRequest Deserialise(Stream stream)
{
IPCRequest result = new IPCRequest();
int length = NetworkByteOrderConverter.ToInt32(stream);
byte[] buffer = new byte[length];
stream.Read(buffer, 0, length);
result.Method = Encoding.UTF8.GetString(buffer);
result.RequestNumber = NetworkByteOrderConverter.ToInt32(stream);
stream.CopyTo(result._Payload);
result._Payload.Position = 0;
return(result);
}
public byte[] Serialise()
{
MemoryStream result = new MemoryStream(4096);
byte[] buffer = Encoding.UTF8.GetBytes(Method);
NetworkByteOrderConverter.WriteInt32(result, (int)(buffer.Length + 8 + _Payload.Length));
NetworkByteOrderConverter.WriteInt32(result, buffer.Length);
result.Write(buffer, 0, buffer.Length);
NetworkByteOrderConverter.WriteInt32(result, RequestNumber);
_Payload.Position = 0;
_Payload.CopyTo(result);
return(result.ToArray());
}
public short ValueAsInt16()
{
short result;
if (_Length == 1)
{
result = _Value[0];
}
else if (_Length == 2)
{
result = NetworkByteOrderConverter.ToInt16(_Value, 0);
}
else
{
throw new InvalidCastException();
}
return(result);
}
public void Write(TTlvTypeIdentifier typeIdentifier, ushort identifier, long value)
{
if ((value > int.MaxValue) || (value < int.MinValue))
{
WriteType(typeIdentifier, identifier, 8);
NetworkByteOrderConverter.WriteInt64(_Stream, value);
}
else if ((value > short.MaxValue) || (value < short.MinValue)) //32Bit length
{
WriteType(typeIdentifier, identifier, 4);
NetworkByteOrderConverter.WriteInt32(_Stream, (int)value);
}
else if ((value > 127) || (value < -128)) //16Bit length
{
WriteType(typeIdentifier, identifier, 2);
NetworkByteOrderConverter.WriteInt16(_Stream, (short)value);
}
else
{
WriteType(typeIdentifier, identifier, 1);
_Stream.WriteByte((byte)value);
}
}
private void ProcessRequest(Socket client, IPCRequest request)
{
byte[] response = new byte[4];
try
{
if (string.Compare(request.Method, "CancelObserveObject", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
bool useReset = request.ReadBoolean();
_ServerAPI.CancelObserveObject(clientID, objectDefinitionID, instanceID, useReset);
}
else if (string.Compare(request.Method, "CancelObserveObjectProperty", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Guid propertyDefinitionID = request.ReadGuid();
bool useReset = request.ReadBoolean();
_ServerAPI.CancelObserveObjectProperty(clientID, objectDefinitionID, instanceID, propertyDefinitionID, useReset);
}
else if (string.Compare(request.Method, "CancelObserveObjects", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
bool useReset = request.ReadBoolean();
_ServerAPI.CancelObserveObjects(clientID, objectDefinitionID, useReset);
}
else if (string.Compare(request.Method, "DeleteClient", true) == 0)
{
Guid clientID = request.ReadGuid();
_ServerAPI.DeleteClient(clientID);
}
else if (string.Compare(request.Method, "ExecuteResource", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Guid propertyDefinitionID = request.ReadGuid();
bool success = _ServerAPI.ExecuteResource(clientID, objectDefinitionID, instanceID, propertyDefinitionID);
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
IPCHelper.Write(data, success);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
if (string.Compare(request.Method, "GetClients", true) == 0)
{
List <Client> clients = _ServerAPI.GetClients();
if (clients != null)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
IPCHelper.Write(data, clients.Count);
foreach (Client item in clients)
{
item.Serialise(data);
}
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "GetDeviceConnectedStatus", true) == 0)
{
Guid clientID = request.ReadGuid();
DeviceConnectedStatus responseObject = _ServerAPI.GetDeviceConnectedStatus(clientID);
if (responseObject != null)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
responseObject.Serialise(data);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "GetObject", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Model.Object responseObject = _ServerAPI.GetObject(clientID, objectDefinitionID, instanceID);
if (responseObject != null)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
responseObject.Serialise(data);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "GetObjectProperty", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Guid propertyDefinitionID = request.ReadGuid();
Property responseProperty = _ServerAPI.GetObjectProperty(clientID, objectDefinitionID, instanceID, propertyDefinitionID);
if (responseProperty != null)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
responseProperty.Serialise(data);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "GetObjects", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
List <Model.Object> responseObjects = _ServerAPI.GetObjects(clientID, objectDefinitionID);
if (responseObjects != null)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
foreach (Model.Object responseObject in responseObjects)
{
responseObject.Serialise(data);
}
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "ObserveObject", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
_ServerAPI.ObserveObject(clientID, objectDefinitionID, instanceID);
}
else if (string.Compare(request.Method, "ObserveObjectProperty", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Guid propertyDefinitionID = request.ReadGuid();
_ServerAPI.ObserveObjectProperty(clientID, objectDefinitionID, instanceID, propertyDefinitionID);
}
else if (string.Compare(request.Method, "ObserveObjects", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
_ServerAPI.ObserveObjects(clientID, objectDefinitionID);
}
else if (string.Compare(request.Method, "SaveObject", true) == 0)
{
Guid clientID = request.ReadGuid();
Model.Object item = Model.Object.Deserialise(request.Payload);
TObjectState state = (TObjectState)request.ReadInt32();
string responseID = _ServerAPI.SaveObject(clientID, item, state);
if (responseID != null)
{
MemoryStream data = new MemoryStream(4096);
byte[] buffer = Encoding.UTF8.GetBytes(responseID);
NetworkByteOrderConverter.WriteInt32(data, (int)(buffer.Length + 4));
NetworkByteOrderConverter.WriteInt32(data, buffer.Length);
data.Write(buffer, 0, buffer.Length);
response = data.ToArray();
}
}
else if (string.Compare(request.Method, "SaveObjectProperty", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Property property = Property.Deserialise(request.Payload);
TObjectState state = (TObjectState)request.ReadInt32();
_ServerAPI.SaveObjectProperty(clientID, objectDefinitionID, instanceID, property, state);
}
else if (string.Compare(request.Method, "SetDataFormat", true) == 0)
{
TDataFormat dataFormat = (TDataFormat)request.ReadInt32();
_ServerAPI.SetDataFormat(dataFormat);
}
else if (string.Compare(request.Method, "SetNotificationParameters", true) == 0)
{
Guid clientID = request.ReadGuid();
Guid objectDefinitionID = request.ReadGuid();
string instanceID = request.ReadString();
Guid propertyDefinitionID = request.ReadGuid();
NotificationParameters notificationParameters = NotificationParameters.Deserialise(request.Payload);
bool success = _ServerAPI.SetNotificationParameters(clientID, objectDefinitionID, instanceID, propertyDefinitionID, notificationParameters);
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
IPCHelper.Write(data, success);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, (int)data.Length - 4);
response = data.ToArray();
}
}
catch (Exception ex)
{
MemoryStream data = new MemoryStream(4096);
data.Position = 4;
IPCHelper.Write(data, ex.GetType().AssemblyQualifiedName);
IPCHelper.Write(data, ex.Message);
data.Position = 0;
NetworkByteOrderConverter.WriteInt32(data, -((int)data.Length - 4));
response = data.ToArray();
}
client.Send(response, SocketFlags.None);
}
private void DoReceiveCallback(IAsyncResult asyncResult)
{
ReceiveStateObject stateObject = asyncResult.AsyncState as ReceiveStateObject;
try
{
int readCount = stateObject.Client.EndReceive(asyncResult);
bool continueReceive = true;
if (readCount > 0)
{
stateObject.Data.Write(stateObject.Buffer, 0, readCount);
if ((stateObject.RequestLength == 0) && (stateObject.Data.Length > 4))
{
long position = stateObject.Data.Position;
stateObject.Data.Position = 0;
stateObject.RequestLength = NetworkByteOrderConverter.ToInt32(stateObject.Data) + 4;
stateObject.Data.Position = position;
}
if (stateObject.RequestLength == stateObject.Data.Position)
{
stateObject.Data.Position = 4;
IPCRequest request = IPCRequest.Deserialise(stateObject.Data);
ThreadPool.QueueUserWorkItem(new WaitCallback((s) => { ProcessRequest(stateObject.Client, request); }));
stateObject.Data.Position = 0;
stateObject.Data.SetLength(0);
stateObject.RequestLength = 0;
}
}
else
{
if (stateObject.Client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < stateObject.Client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
SocketError socketError;
stateObject.Client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, new AsyncCallback(DoReceiveCallback), stateObject);
}
else
{
stateObject.Client.Close();
}
}
#pragma warning disable 0168
catch (Exception ex)
#pragma warning restore 0168
{
stateObject.Client.Close();
}
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
ReceiveStateObject stateObject = asyncResult.AsyncState as ReceiveStateObject;
try
{
int readCount = stateObject.Client.EndReceive(asyncResult);
bool continueReceive = true;
if (readCount > 0)
{
stateObject.Data.Write(stateObject.Buffer, 0, readCount);
if ((stateObject.RequestLength == 0) && (stateObject.Data.Length >= 4))
{
long position = stateObject.Data.Position;
stateObject.Data.Position = 0;
int requestLength = NetworkByteOrderConverter.ToInt32(stateObject.Data);
stateObject.RequestLength = Math.Abs(requestLength) + 4;
stateObject.Error = requestLength < 0;
stateObject.Data.Position = position;
}
if (stateObject.RequestLength == stateObject.Data.Position)
{
_ErrorResponse = stateObject.Error;
_ResponseBytes = new byte[stateObject.RequestLength - 4];
stateObject.Data.Position = 4;
stateObject.Data.Read(_ResponseBytes, 0, _ResponseBytes.Length);
stateObject.Data.Position = 0;
stateObject.Data.SetLength(0);
stateObject.RequestLength = 0;
_ResponseWaitHandle.Set();
}
}
else
{
if (stateObject.Client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < stateObject.Client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
SocketError socketError;
stateObject.Client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
}
else
{
_Connected = false;
_ResponseWaitHandle.Set();
stateObject.Client.Close();
}
}
#pragma warning disable 168
catch (Exception ex)
#pragma warning restore 168
{
_Connected = false;
_ResponseWaitHandle.Set();
stateObject.Client.Close();
}
}
public bool Read()
{
_TlvRecord = null;
try
{
int type = _Stream.ReadByte();
if (type == -1)
{
throw new EndOfStreamException();
}
TTlvTypeIdentifier typeIdentifier;
ushort identifier;
uint length;
byte[] value = null;
if ((type & TlvConstant.RESOURCE_WITH_VALUE) == TlvConstant.RESOURCE_WITH_VALUE)
{
typeIdentifier = TTlvTypeIdentifier.ResourceWithValue;
}
else if ((type & TlvConstant.MULTIPLE_RESOURCES) == TlvConstant.MULTIPLE_RESOURCES)
{
typeIdentifier = TTlvTypeIdentifier.MultipleResources;
}
else if ((type & TlvConstant.RESOURCE_INSTANCE) == TlvConstant.RESOURCE_INSTANCE)
{
typeIdentifier = TTlvTypeIdentifier.ResourceInstance;
}
else
{
typeIdentifier = TTlvTypeIdentifier.ObjectInstance;
}
bool identifier16Bits = ((type & TlvConstant.IDENTIFIER_16BITS) == TlvConstant.IDENTIFIER_16BITS);
if (identifier16Bits)
{
identifier = NetworkByteOrderConverter.ToUInt16(_Stream);
}
else
{
int readByte = _Stream.ReadByte();
if (readByte == -1)
{
throw new EndOfStreamException();
}
identifier = (ushort)readByte;
}
if ((type & TlvConstant.LENGTH_24BIT) == TlvConstant.LENGTH_24BIT)
{
length = NetworkByteOrderConverter.ToUInt24(_Stream);;
}
else if ((type & TlvConstant.LENGTH_16BIT) == TlvConstant.LENGTH_16BIT)
{
length = NetworkByteOrderConverter.ToUInt16(_Stream);
}
else if ((type & TlvConstant.LENGTH_8BIT) == TlvConstant.LENGTH_8BIT)
{
int readByte = _Stream.ReadByte();
if (readByte == -1)
{
throw new EndOfStreamException();
}
length = (uint)readByte;
}
else //3Bit length
{
length = (uint)(type & 0x7);
}
value = new byte[length];
int read = _Stream.Read(value, 0, (int)length);
if (read != (int)length)
{
throw new EndOfStreamException();
}
_TlvRecord = new TlvRecord()
{
TypeIdentifier = typeIdentifier, Identifier = identifier, Length = length, Value = value
};
}
catch (EndOfStreamException)
{
}
return(_TlvRecord != null);
}
public void WriteType(TTlvTypeIdentifier typeIdentifier, ushort identifier, int length)
{
int type = 0;
byte[] tlvHeader = null;
int headerLength = 2;
switch (typeIdentifier)
{
case TTlvTypeIdentifier.NotSet:
break;
case TTlvTypeIdentifier.ObjectInstance:
break;
case TTlvTypeIdentifier.ResourceWithValue:
type = type | TlvConstant.RESOURCE_WITH_VALUE;
break;
case TTlvTypeIdentifier.MultipleResources:
type = type | TlvConstant.MULTIPLE_RESOURCES;
break;
case TTlvTypeIdentifier.ResourceInstance:
type = type | TlvConstant.RESOURCE_INSTANCE;
break;
default:
break;
}
if (identifier > byte.MaxValue)
{
type = type | TlvConstant.IDENTIFIER_16BITS;
headerLength += 1;
}
if (length > ushort.MaxValue)
{
type = type | TlvConstant.LENGTH_24BIT;
headerLength += 3;
}
else if (length > byte.MaxValue)
{
type = type | TlvConstant.LENGTH_16BIT;
headerLength += 2;
}
else if (length > 7)
{
type = type | TlvConstant.LENGTH_8BIT;
headerLength += 1;
}
else
{
type = type | (int)length;
}
tlvHeader = new byte[headerLength];
tlvHeader[0] = (byte)type;
int lengthOffset = 2;
if (identifier > byte.MaxValue)
{
NetworkByteOrderConverter.WriteUInt16(tlvHeader, 1, identifier);
lengthOffset = 3;
}
else
{
tlvHeader[1] = (byte)identifier;
}
if (length > ushort.MaxValue) //24Bit length
{
NetworkByteOrderConverter.WriteUInt24(tlvHeader, lengthOffset, (uint)length);
}
else if (length > byte.MaxValue) //16Bit length
{
NetworkByteOrderConverter.WriteUInt16(tlvHeader, lengthOffset, (ushort)length);
}
else if (length > 7) //8Bit length
{
tlvHeader[lengthOffset] = (byte)length;
}
_Stream.Write(tlvHeader, 0, headerLength);
}
