private static void HandleRead(GXDLMSSettings settings, GXDLMSServer server, byte type, GXByteBuffer data,
List <ValueEventArgs> list, List <ValueEventArgs> reads, List <ValueEventArgs> actions,
GXByteBuffer replyData, GXDLMSTranslatorStructure xml, Command cipheredCommand)
{
int sn = data.GetInt16();
if (xml != null)
{
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendStartTag(
TranslatorTags.VariableAccessSpecification);
}
else
{
sn &= 0xFFFF;
}
if (type == (byte)VariableAccessSpecification.ParameterisedAccess)
{
xml.AppendStartTag(Command.ReadRequest,
VariableAccessSpecification.ParameterisedAccess);
xml.AppendLine(
(int)Command.ReadRequest << 8
| (int)VariableAccessSpecification.VariableName,
"Value", xml.IntegerToHex(sn, 4));
xml.AppendLine(TranslatorTags.Selector, "Value",
xml.IntegerToHex(data.GetUInt8(), 2));
GXDataInfo di = new GXDataInfo();
di.xml = xml;
xml.AppendStartTag(TranslatorTags.Parameter);
GXCommon.GetData(settings, data, di);
xml.AppendEndTag(TranslatorTags.Parameter);
xml.AppendEndTag(Command.ReadRequest,
VariableAccessSpecification.ParameterisedAccess);
}
else
{
xml.AppendLine(
(int)Command.ReadRequest << 8
| (int)VariableAccessSpecification.VariableName,
"Value", xml.IntegerToHex(sn, 4));
}
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendEndTag(TranslatorTags.VariableAccessSpecification);
}
return;
}
GXSNInfo info = FindSNObject(server, sn & 0xFFFF);
ValueEventArgs e = new ValueEventArgs(server, info.Item, info.Index, 0, null);
e.action = info.IsAction;
if (type == (byte)VariableAccessSpecification.ParameterisedAccess)
{
e.Selector = data.GetUInt8();
GXDataInfo di = new GXDataInfo();
e.Parameters = GXCommon.GetData(settings, data, di);
}
//Return error if connection is not established.
if ((settings.Connected & ConnectionState.Hdlc) == 0 && cipheredCommand == Command.None && (!e.action || e.Target.ShortName != 0xFA00 || e.Index != 8))
{
replyData.Add(GXDLMSServer.GenerateConfirmedServiceError(ConfirmedServiceError.InitiateError,
ServiceError.Service, (byte)Service.Unsupported));
return;
}
if (e.Target is GXDLMSProfileGeneric && info.Index == 2)
{
e.RowToPdu = GXDLMS.RowsToPdu(settings, (GXDLMSProfileGeneric)e.Target);
}
list.Add(e);
if (!e.action && server.NotifyGetAttributeAccess(e) == AccessMode.NoAccess)
{
e.Error = ErrorCode.ReadWriteDenied;
}
else if (e.action && server.NotifyGetMethodAccess(e) == MethodAccessMode.NoAccess)
{
e.Error = ErrorCode.ReadWriteDenied;
}
else
{
if (e.action)
{
actions.Add(e);
}
else
{
reads.Add(e);
}
}
}
public GXDLMSException(int errCode)
: base(GXDLMS.GetDescription((ErrorCode)errCode))
{
ErrorCode = errCode;
}
///<summary>
/// Removes the HDLC frame from the packet, and returns COSEM data only.
///</summary>
///<param name="reply">
/// The received data from the device.
///</param>
///<param name="data">
/// Information from the received data.
///</param>
///<returns>
/// Is frame complete.
///</returns>
public bool GetData(GXByteBuffer reply, GXReplyData data)
{
return(GXDLMS.GetData(Settings, reply, data, null));
}
/// <summary>
/// Load XML commands from the file.
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public List <GXDLMSXmlMessage> Load(string fileName)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(File.ReadAllText(fileName));
List <GXDLMSXmlMessage> actions = new List <GXDLMSXmlMessage>();
foreach (XmlNode m1 in doc.ChildNodes)
{
if (m1.NodeType == XmlNodeType.Element)
{
foreach (XmlNode node in m1.ChildNodes)
{
if (node.NodeType == XmlNodeType.Element)
{
List <byte[]> messages = new List <byte[]>();
GXDLMSXmlSettings s = new GXDLMSXmlSettings(translator.OutputType, translator.Hex, translator.ShowStringAsHex, translator.tagsByName);;
s.settings.ClientAddress = Settings.ClientAddress;
s.settings.ServerAddress = Settings.ServerAddress;
GXByteBuffer reply = new GXByteBuffer(translator.XmlToPdu(node.OuterXml, s));
if (s.command == Command.Snrm)
{
messages.Add(reply.Array());
}
else if (s.command == Command.Ua)
{
Settings.Limits.MaxInfoTX = s.settings.Limits.MaxInfoTX;
Settings.Limits.MaxInfoRX = s.settings.Limits.MaxInfoRX;
Settings.Limits.WindowSizeRX = s.settings.Limits.WindowSizeRX;
Settings.Limits.WindowSizeTX = s.settings.Limits.WindowSizeTX;
messages.Add(reply.Array());
}
else if (s.command == Command.DisconnectRequest)
{
messages.Add(GXDLMS.GetHdlcFrame(Settings, (byte)Command.DisconnectRequest, reply));
}
else
{
while (reply.Position != reply.Size)
{
if (Settings.InterfaceType == Enums.InterfaceType.WRAPPER)
{
messages.Add(GXDLMS.GetWrapperFrame(Settings, reply));
}
else if (Settings.InterfaceType == Enums.InterfaceType.HDLC)
{
byte frame = 0;
if (s.command == Command.Aarq)
{
frame = 0x10;
}
else if (s.command == Command.Aare)
{
frame = 0x30;
}
else if (s.command == Command.EventNotification)
{
frame = 0x13;
}
messages.Add(GXDLMS.GetHdlcFrame(Settings, frame, reply));
if (reply.Position != reply.Size)
{
if (Settings.IsServer || s.command == Command.SetRequest)
{
frame = 0;
}
else
{
frame = Settings.NextSend(false);
}
}
}
else if (Settings.InterfaceType == Enums.InterfaceType.PDU)
{
messages.Add(reply.Array());
break;
}
else
{
throw new ArgumentOutOfRangeException("InterfaceType");
}
}
}
actions.Add(new GXDLMSXmlMessage(s.command, node, messages.ToArray()));
}
}
}
}
return(actions);
}
/// <summary>
/// Handle get request with list command.
/// </summary>
/// <param name="data">Received data.</param>
private static void GetRequestWithList(GXDLMSSettings settings, byte invokeID, GXDLMSServer server, GXByteBuffer data, GXByteBuffer replyData, GXDLMSTranslatorStructure xml)
{
ValueEventArgs e;
GXByteBuffer bb = new GXByteBuffer();
int pos;
int cnt = GXCommon.GetObjectCount(data);
GXCommon.SetObjectCount(cnt, bb);
List <ValueEventArgs> list = new List <ValueEventArgs>();
if (xml != null)
{
xml.AppendStartTag(TranslatorTags.AttributeDescriptorList, "Qty", xml.IntegerToHex(cnt, 2));
}
try
{
for (pos = 0; pos != cnt; ++pos)
{
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
short attributeIndex = data.GetUInt8();
// AccessSelection
int selection = data.GetUInt8();
int selector = 0;
object parameters = null;
if (selection != 0)
{
selector = data.GetUInt8();
GXDataInfo info = new GXDataInfo();
parameters = GXCommon.GetData(settings, data, info);
}
if (xml != null)
{
xml.AppendStartTag(TranslatorTags.AttributeDescriptorWithSelection);
xml.AppendStartTag(TranslatorTags.AttributeDescriptor);
xml.AppendComment(ci.ToString());
xml.AppendLine(TranslatorTags.ClassId, "Value", xml.IntegerToHex((int)ci, 4));
xml.AppendComment(GXCommon.ToLogicalName(ln));
xml.AppendLine(TranslatorTags.InstanceId, "Value", GXCommon.ToHex(ln, false));
xml.AppendLine(TranslatorTags.AttributeId, "Value", xml.IntegerToHex(attributeIndex, 2));
xml.AppendEndTag(TranslatorTags.AttributeDescriptor);
xml.AppendEndTag(TranslatorTags.AttributeDescriptorWithSelection);
}
else
{
GXDLMSObject obj = settings.Objects.FindByLN(ci, GXCommon.ToLogicalName(ln));
if (obj == null)
{
obj = server.NotifyFindObject(ci, 0, GXCommon.ToLogicalName(ln));
}
if (obj == null)
{
// "Access Error : Device reports a undefined object."
e = new ValueEventArgs(server, obj, attributeIndex, 0, 0);
e.Error = ErrorCode.UndefinedObject;
list.Add(e);
}
else
{
ValueEventArgs arg = new ValueEventArgs(server, obj, attributeIndex, selector, parameters);
arg.InvokeId = invokeID;
if (server.NotifyGetAttributeAccess(arg) == AccessMode.NoAccess)
{
//Read Write denied.
arg.Error = ErrorCode.ReadWriteDenied;
list.Add(arg);
}
else
{
list.Add(arg);
}
}
}
}
}
catch (Exception ex)
{
if (xml == null)
{
throw ex;
}
}
if (xml != null)
{
xml.AppendEndTag(TranslatorTags.AttributeDescriptorList);
return;
}
server.NotifyRead(list.ToArray());
object value;
pos = 0;
foreach (ValueEventArgs it in list)
{
try
{
if (it.Handled)
{
value = it.Value;
}
else
{
value = (it.Target as IGXDLMSBase).GetValue(settings, it);
}
bb.SetUInt8(it.Error);
if (it.ByteArray)
{
bb.Set((byte[])value);
}
else
{
GXDLMS.AppendData(settings, it.Target, it.Index, bb, value);
}
invokeID = (byte)it.InvokeId;
}
catch (Exception)
{
bb.SetUInt8((byte)ErrorCode.HardwareFault);
}
if (settings.Index != settings.Count)
{
server.transaction = new GXDLMSLongTransaction(list.ToArray(), Command.GetRequest, null);
}
++pos;
}
server.NotifyPostRead(list.ToArray());
GXDLMSLNParameters p = new GXDLMSLNParameters(settings, invokeID, Command.GetResponse, 3, null, bb, 0xFF);
GXDLMS.GetLNPdu(p, replyData);
}
/// <summary>
/// Handle read request.
/// </summary>
/// <param name="settings">DLMS settings.</param>
/// <param name="server">DLMS server.</param>
/// <param name="data">Received data.</param>
public static void HandleReadRequest(GXDLMSSettings settings, GXDLMSServer server, GXByteBuffer data, GXByteBuffer replyData, GXDLMSTranslatorStructure xml, Command cipheredCommand)
{
//Return error if connection is not established.
if (xml == null && (settings.Connected & ConnectionState.Hdlc) == 0 && cipheredCommand == Command.None)
{
replyData.Add(GXDLMSServer.GenerateConfirmedServiceError(ConfirmedServiceError.InitiateError,
ServiceError.Service, (byte)Service.Unsupported));
return;
}
GXByteBuffer bb = new GXByteBuffer();
int cnt = 0xFF;
byte type = 0;
List <ValueEventArgs> list = new List <ValueEventArgs>();
List <ValueEventArgs> reads = new List <ValueEventArgs>();
List <ValueEventArgs> actions = new List <ValueEventArgs>();
//If get next frame.
if (xml == null && data.Size == 0)
{
if (server.transaction != null)
{
return;
}
bb.Set(replyData);
replyData.Clear();
foreach (ValueEventArgs it in server.transaction.targets)
{
list.Add(it);
}
}
else
{
cnt = GXCommon.GetObjectCount(data);
if (xml != null)
{
xml.AppendStartTag(Command.ReadRequest, "Qty", xml.IntegerToHex(cnt, 2));
}
for (int pos = 0; pos != cnt; ++pos)
{
type = data.GetUInt8();
if (type == (byte)VariableAccessSpecification.VariableName ||
type == (byte)VariableAccessSpecification.ParameterisedAccess)
{
HandleRead(settings, server, type, data, list, reads, actions, replyData, xml, cipheredCommand);
}
else if (type == (byte)VariableAccessSpecification.BlockNumberAccess)
{
HandleReadBlockNumberAccess(settings, server, data, replyData, xml);
if (xml != null)
{
xml.AppendEndTag(Command.ReadRequest);
}
return;
}
else if (type == (byte)VariableAccessSpecification.ReadDataBlockAccess)
{
HandleReadDataBlockAccess(settings, server, Command.ReadResponse, data, cnt, replyData, xml, cipheredCommand);
if (xml != null)
{
xml.AppendEndTag(Command.ReadRequest);
}
return;
}
else
{
ReturnSNError(settings, server, Command.ReadResponse, ErrorCode.ReadWriteDenied, replyData);
if (xml != null)
{
xml.AppendEndTag(Command.ReadRequest);
}
return;
}
}
if (reads.Count != 0)
{
server.NotifyRead(reads.ToArray());
}
if (actions.Count != 0)
{
server.NotifyAction(actions.ToArray());
}
}
if (xml != null)
{
xml.AppendEndTag(Command.ReadRequest);
return;
}
byte requestType = (byte)GetReadData(settings, list.ToArray(), bb);
if (reads.Count != 0)
{
server.NotifyPostRead(reads.ToArray());
}
if (actions.Count != 0)
{
server.NotifyPostAction(actions.ToArray());
}
GXDLMSSNParameters p = new GXDLMSSNParameters(settings, Command.ReadResponse, list.Count, requestType, null, bb);
GXDLMS.GetSNPdu(p, replyData);
if (server.transaction == null && (bb.Size != bb.Position || settings.Count != settings.Index))
{
reads = new List <ValueEventArgs>();
foreach (var it in list)
{
reads.Add(it);
}
server.transaction = new GXDLMSLongTransaction(reads.ToArray(), Command.ReadRequest, bb);
}
else if (server.transaction != null)
{
replyData.Set(bb);
return;
}
}
///<summary>
/// Handles client request.
/// </summary>
///<param name="buff">
/// Received data from the client. </param>
///<returns>
///Response to the request. Response is null if request packet is not complete.
///</returns>
public virtual byte[] HandleRequest(byte[] buff, GXDLMSConnectionEventArgs connectionInfo)
{
if (buff == null || buff.Length == 0)
{
return(null);
}
if (!Initialized)
{
throw new Exception("Server not Initialized.");
}
try
{
receivedData.Set(buff);
bool first = Settings.ServerAddress == 0 && Settings.ClientAddress == 0;
GXDLMS.GetData(Settings, receivedData, info);
//If all data is not received yet.
if (!info.IsComplete)
{
return(null);
}
receivedData.Clear();
if (first)
{
// Check is data send to this server.
if (!IsTarget(Settings.ServerAddress,
Settings.ClientAddress))
{
info.Clear();
return(null);
}
}
//If client want next frame.
if ((info.MoreData & RequestTypes.Frame) == RequestTypes.Frame)
{
return(GXDLMS.GetHdlcFrame(Settings, Settings.ReceiverReady(), replyData));
}
//Update command if transaction and next frame is asked.
if (info.Command == Command.None)
{
if (transaction != null)
{
info.Command = transaction.command;
}
}
//Check inactivity time out.
if (hdlcSetup != null)
{
if (info.Command == Command.Snrm)
{
dataReceived = DateTime.Now;
}
else
{
int elapsed = (int)(DateTime.Now - dataReceived).TotalSeconds;
//If inactivity time out is elapsed.
if (elapsed >= hdlcSetup.InactivityTimeout)
{
Reset();
dataReceived = DateTime.MinValue;
return(null);
}
dataReceived = DateTime.Now;
}
}
byte[] reply = HandleCommand(info.Command, info.Data, connectionInfo);
info.Clear();
return(reply);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
if (info.Command != Command.None)
{
return(ReportError(info.Command, ErrorCode.HardwareFault));
}
else
{
Reset();
if (Settings.Connected)
{
Settings.Connected = false;
Disconnected(connectionInfo);
}
return(null);
}
}
}
/// <summary>
/// Load XML commands from the file.
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public byte[][] PduToMessages(GXDLMSXmlPdu pdu)
{
List <byte[]> messages = new List <byte[]>();
if (pdu.Command == Command.Snrm)
{
messages.Add(pdu.Data);
}
else if (pdu.Command == Command.Ua)
{
messages.Add(pdu.Data);
}
else if (pdu.Command == Command.DisconnectRequest)
{
messages.Add(GXDLMS.GetHdlcFrame(Settings, (byte)Command.DisconnectRequest, new GXByteBuffer(pdu.Data)));
}
else
{
GXByteBuffer reply;
if (Settings.InterfaceType == Enums.InterfaceType.WRAPPER)
{
reply = new GXByteBuffer(pdu.Data);
}
else
{
reply = new GXByteBuffer((UInt16)(3 + pdu.Data.Length));
reply.Set(GXCommon.LLCSendBytes);
reply.Set(pdu.Data);
}
while (reply.Position != reply.Size)
{
if (Settings.InterfaceType == Enums.InterfaceType.WRAPPER)
{
messages.Add(GXDLMS.GetWrapperFrame(Settings, reply));
}
else if (Settings.InterfaceType == Enums.InterfaceType.HDLC)
{
byte frame = 0;
if (pdu.Command == Command.Aarq)
{
frame = 0x10;
}
else if (pdu.Command == Command.Aare)
{
frame = 0x30;
}
else if (pdu.Command == Command.EventNotification)
{
frame = 0x13;
}
messages.Add(GXDLMS.GetHdlcFrame(Settings, frame, reply));
if (reply.Position != reply.Size)
{
if (Settings.IsServer || pdu.Command == Command.SetRequest ||
pdu.Command == Command.MethodRequest)
{
frame = 0;
}
else
{
frame = Settings.NextSend(false);
}
}
}
else if (Settings.InterfaceType == Enums.InterfaceType.PDU)
{
messages.Add(reply.Array());
break;
}
else
{
throw new ArgumentOutOfRangeException("InterfaceType");
}
}
}
return(messages.ToArray());
}
///<summary>
/// Handle write request.
///</summary>
public static void HandleWriteRequest(GXDLMSSettings settings, GXDLMSServer server, GXByteBuffer data,
GXByteBuffer replyData, GXDLMSTranslatorStructure xml, Command cipheredCommand)
{
short type;
object value;
// Get object count.
List <GXSNInfo> targets = new List <GXSNInfo>();
int cnt = GXCommon.GetObjectCount(data);
if (xml != null)
{
xml.AppendStartTag(Command.WriteRequest);
xml.AppendStartTag(
TranslatorTags.ListOfVariableAccessSpecification, "Qty",
xml.IntegerToHex(cnt, 2));
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendStartTag(
TranslatorTags.VariableAccessSpecification);
}
}
GXDataInfo di;
GXSNInfo info;
GXByteBuffer results = new GXByteBuffer((ushort)cnt);
for (int pos = 0; pos != cnt; ++pos)
{
type = data.GetUInt8();
if (type == (byte)VariableAccessSpecification.VariableName)
{
int sn = data.GetUInt16();
if (xml != null)
{
xml.AppendLine(
(int)Command.WriteRequest << 8
| type,
"Value", xml.IntegerToHex(sn, 4));
}
else
{
info = FindSNObject(server, sn);
targets.Add(info);
// If target is unknown.
if (info == null)
{
// Device reports a undefined object.
results.SetUInt8(ErrorCode.UndefinedObject);
}
else
{
results.SetUInt8(ErrorCode.Ok);
}
}
}
else if (type == (byte)VariableAccessSpecification.WriteDataBlockAccess)
{
//Return error if connection is not established.
if (xml == null && (settings.Connected & ConnectionState.Dlms) == 0 && cipheredCommand == Command.None)
{
replyData.Add(GXDLMSServer.GenerateConfirmedServiceError(ConfirmedServiceError.InitiateError,
ServiceError.Service, (byte)Service.Unsupported));
return;
}
HandleReadDataBlockAccess(settings, server, Command.WriteResponse, data, cnt, replyData, xml, cipheredCommand);
if (xml == null)
{
return;
}
}
else
{
// Device reports a HW error.
results.SetUInt8(ErrorCode.HardwareFault);
}
}
if (xml != null)
{
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendEndTag(TranslatorTags.VariableAccessSpecification);
}
xml.AppendEndTag(
TranslatorTags.ListOfVariableAccessSpecification);
}
// Get data count.
cnt = GXCommon.GetObjectCount(data);
di = new GXDataInfo();
di.xml = xml;
if (xml != null)
{
xml.AppendStartTag(TranslatorTags.ListOfData, "Qty", xml.IntegerToHex(cnt, 2));
}
for (int pos = 0; pos != cnt; ++pos)
{
di.Clear();
if (xml != null)
{
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendStartTag(Command.WriteRequest,
SingleReadResponse.Data);
}
value = GXCommon.GetData(settings, data, di);
if (!di.Complete)
{
value = GXCommon.ToHex(data.Data, false,
data.Position, data.Size - data.Position);
xml.AppendLine(
GXDLMS.DATA_TYPE_OFFSET + (int)di.Type,
"Value", value.ToString());
}
if (xml.OutputType == TranslatorOutputType.StandardXml)
{
xml.AppendEndTag(Command.WriteRequest, SingleReadResponse.Data);
}
}
else if (results.GetUInt8(pos) == 0)
{
bool access = true;
// If object has found.
GXSNInfo target = targets[pos];
value = GXCommon.GetData(settings, data, di);
ValueEventArgs e = new ValueEventArgs(server, target.Item, target.Index, 0, null);
if (target.IsAction)
{
MethodAccessMode am = server.NotifyGetMethodAccess(e);
// If action is denied.
if (am != MethodAccessMode.Access)
{
access = false;
}
}
else
{
if (value is byte[])
{
DataType dt = target.Item.GetDataType(target.Index);
if (dt != DataType.None && dt != DataType.OctetString)
{
value = GXDLMSClient.ChangeType((byte[])value, dt, settings.UseUtc2NormalTime);
}
}
AccessMode am = server.NotifyGetAttributeAccess(e);
// If write is denied.
if (am != AccessMode.Write && am != AccessMode.ReadWrite)
{
access = false;
}
}
if (access)
{
if (target.IsAction)
{
e.Parameters = value;
ValueEventArgs[] actions = new ValueEventArgs[] { e };
server.NotifyAction(actions);
if (!e.Handled)
{
byte[] reply = (target.Item as IGXDLMSBase).Invoke(settings, e);
server.NotifyPostAction(actions);
if (target.Item is GXDLMSAssociationShortName && target.Index == 8 && reply != null)
{
GXByteBuffer bb = new GXByteBuffer();
bb.SetUInt8((byte)DataType.OctetString);
bb.SetUInt8((byte)reply.Length);
bb.Set(reply);
GXDLMSSNParameters p = new GXDLMSSNParameters(settings, Command.ReadResponse, 1, 0, null, bb);
GXDLMS.GetSNPdu(p, replyData);
}
}
}
else
{
e.Value = value;
server.NotifyWrite(new ValueEventArgs[] { e });
if (e.Error != 0)
{
results.SetUInt8((byte)pos, (byte)e.Error);
}
else if (!e.Handled)
{
(target.Item as IGXDLMSBase).SetValue(settings, e);
server.NotifyPostWrite(new ValueEventArgs[] { e });
}
}
}
else
{
results.SetUInt8((byte)pos, (byte)ErrorCode.ReadWriteDenied);
}
}
}
if (xml != null)
{
xml.AppendEndTag(TranslatorTags.ListOfData);
xml.AppendEndTag(Command.WriteRequest);
return;
}
GenerateWriteResponse(settings, results, replyData);
}
///
///<summary>Handle read request.
/// </summary>
///<returns> Reply to the client. </returns>
///
private byte[][] HandleReadRequest()
{
GXByteBuffer data = Reply.Data;
short type;
object value = null;
GXByteBuffer bb = new GXByteBuffer();
int cnt = GXCommon.GetObjectCount(data);
GXCommon.SetObjectCount(cnt, bb);
GXSNInfo info;
for (int pos = 0; pos != cnt; ++pos)
{
type = data.GetUInt8();
// GetRequest normal
if (type == 2)
{
int sn = data.GetUInt16();
info = FindSNObject(sn);
if (!info.IsAction)
{
ValueEventArgs e = new ValueEventArgs(info.Item, info.Index, 0, null);
Read(e);
if (e.Handled)
{
value = e.Value;
}
else
{
value = (info.Item as IGXDLMSBase).GetValue(Settings, info.Index, 0, null);
}
// Set status.
bb.SetUInt8(0);
GXDLMS.AppedData(info.Item, info.Index, bb, value);
}
else
{
ValueEventArgs e = new ValueEventArgs(info.Item, info.Index, 0, null);
Action(e);
if (e.Handled)
{
value = e.Value;
}
else
{
value = ((IGXDLMSBase)info.Item).Invoke(Settings, info.Index, null);
}
// Set status.
bb.SetUInt8(0);
// Add value
bb.SetUInt8(GXCommon.GetValueType(value));
bb.Add(value);
}
}
else if (type == 2)
{
// Get request for next data block
throw new System.ArgumentException("TODO: Invalid Command.");
}
else if (type == 4)
{
// Parameterised access.
int sn = data.GetUInt16();
int selector = data.GetUInt8();
GXDataInfo di = new GXDataInfo();
object parameters = GXCommon.GetData(data, di);
info = FindSNObject(sn);
if (!info.IsAction)
{
ValueEventArgs e = new ValueEventArgs(info.Item, info.Index, 0, parameters);
Read(e);
if (e.Handled)
{
value = e.Value;
}
else
{
value = (info.Item as IGXDLMSBase).GetValue(Settings, info.Index, selector, parameters);
}
// Set status.
bb.SetUInt8(0);
GXDLMS.AppedData(info.Item, info.Index, bb, value);
}
else
{
ValueEventArgs e = new ValueEventArgs(info.Item, info.Index, 0, parameters);
e.Value = parameters;
Action(e);
if (e.Handled)
{
value = e.Value;
}
else
{
value = ((IGXDLMSBase)info.Item).Invoke(Settings, info.Index, parameters);
}
// Add value
bb.Add(value);
}
}
else
{
throw new System.ArgumentException("Invalid Command.");
}
}
return(GXDLMS.SplitPdu(Settings, Command.ReadResponse, 1, bb,
ErrorCode.Ok, DateTime.MinValue)[0]);
}
/// <summary>
/// Load XML commands from the file.
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public byte[][] PduToMessages(GXDLMSXmlPdu pdu)
{
List <byte[]> messages = new List <byte[]>();
if (pdu.Command == Command.Snrm)
{
messages.Add(pdu.Data);
}
else if (pdu.Command == Command.Ua)
{
messages.Add(pdu.Data);
}
else if (pdu.Command == Command.DisconnectRequest)
{
messages.Add(GXDLMS.GetHdlcFrame(Settings, (byte)Command.DisconnectRequest, new GXByteBuffer(pdu.Data)));
}
else
{
GXByteBuffer reply;
if (Settings.InterfaceType == InterfaceType.WRAPPER)
{
if (Ciphering.Security != Security.None)
{
GXDLMSLNParameters p = new GXDLMSLNParameters(this, Settings, 0, pdu.Command, 0x0, null, null, 0xff, Command.None);
reply = new GXByteBuffer(GXDLMS.Cipher0(p, pdu.Data));
}
else
{
reply = new GXByteBuffer(pdu.Data);
}
}
else
{
if (Ciphering.Security != Security.None)
{
GXDLMSLNParameters p = new GXDLMSLNParameters(this, Settings, 0, pdu.Command, 0x0, null, null, 0xff, Command.None);
byte[] tmp = GXDLMS.Cipher0(p, pdu.Data);
reply = new GXByteBuffer((UInt16)(3 + tmp.Length));
reply.Set(GXCommon.LLCSendBytes);
reply.Set(tmp);
}
else
{
reply = new GXByteBuffer((UInt16)(3 + pdu.Data.Length));
reply.Set(GXCommon.LLCSendBytes);
reply.Set(pdu.Data);
}
}
byte frame = 0;
while (reply.Position != reply.Size)
{
if (Settings.InterfaceType == Enums.InterfaceType.WRAPPER)
{
messages.Add(GXDLMS.GetWrapperFrame(Settings, pdu.Command, reply));
}
else if (GXDLMS.UseHdlc(Settings.InterfaceType))
{
if (pdu.Command == Command.Aarq)
{
frame = 0x10;
}
else if (pdu.Command == Command.Aare)
{
frame = 0x30;
}
else if (pdu.Command == Command.EventNotification)
{
frame = 0x13;
}
messages.Add(GXDLMS.GetHdlcFrame(Settings, frame, reply));
if (reply.Position != reply.Size)
{
frame = Settings.NextSend(false);
}
}
else if (Settings.InterfaceType == Enums.InterfaceType.PDU)
{
messages.Add(reply.Array());
break;
}
else
{
throw new ArgumentOutOfRangeException("InterfaceType");
}
}
}
return(messages.ToArray());
}
private byte[][] HandleGetRequest()
{
ErrorCode error = ErrorCode.Ok;
GXByteBuffer data = Reply.Data;
GXByteBuffer bb = new GXByteBuffer();
short type;
int index = 0;
object parameters = null;
// Get type.
type = data.GetUInt8();
// Get invoke ID and priority.
data.GetUInt8();
// GetRequest normal
if (type == 1)
{
Settings.ResetBlockIndex();
ServerReply.Index = 0;
parameters = null;
// CI
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
// Attribute Id
int attributeIndex = data.GetUInt8();
GXDLMSObject obj = Settings.Objects.FindByLN(ci, GXDLMSObject.ToLogicalName(ln));
if (obj == null)
{
obj = FindObject(ci, 0, GXDLMSObject.ToLogicalName(ln));
}
if (obj == null)
{
// "Access Error : Device reports a undefined object."
error = ErrorCode.UndefinedObject;
}
else
{
// AccessSelection
int selection = data.GetUInt8();
int selector = 0;
if (selection != 0)
{
selector = data.GetUInt8();
GXDataInfo info = new GXDataInfo();
parameters = GXCommon.GetData(data, info);
}
ValueEventArgs e = new ValueEventArgs(obj, attributeIndex, 0, parameters);
Read(e);
object value;
if (e.Handled)
{
value = e.Value;
}
else
{
value = (obj as IGXDLMSBase).GetValue(Settings, attributeIndex, selector, parameters);
}
GXDLMS.AppedData(obj, attributeIndex, bb, value);
}
ServerReply.ReplyMessages = GXDLMS.SplitPdu(Settings, Command.GetResponse, 1, bb, error, DateTime.MinValue);
}
else if (type == 2)
{
// Get request for next data block
// Get block index.
index = (int)data.GetUInt32();
if (index != Settings.BlockIndex + 1)
{
Debug.WriteLine("handleGetRequest failed. Invalid block number. " + Settings.BlockIndex + "/" + index);
ServerReply.ReplyMessages = GXDLMS.SplitPdu(Settings, Command.GetResponse, 1, bb,
ErrorCode.DataBlockNumberInvalid, DateTime.MinValue);
index = 0;
ServerReply.Index = index;
}
else
{
Settings.IncreaseBlockIndex();
index = ServerReply.Index + 1;
ServerReply.Index = index;
}
}
else if (type == 3)
{
// Get request with a list.
int cnt = GXCommon.GetObjectCount(data);
GXCommon.SetObjectCount(cnt, bb);
for (int pos = 0; pos != cnt; ++pos)
{
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
short attributeIndex = data.GetUInt8();
GXDLMSObject obj = Settings.Objects.FindByLN(ci, GXDLMSObject.ToLogicalName(ln));
if (obj == null)
{
obj = FindObject(ci, 0, GXDLMSObject.ToLogicalName(ln));
}
if (obj == null)
{
// "Access Error : Device reports a undefined object."
error = ErrorCode.UndefinedObject;
}
else
{
// AccessSelection
int selection = data.GetUInt8();
int selector = 0;
if (selection != 0)
{
selector = data.GetUInt8();
GXDataInfo info = new GXDataInfo();
parameters = GXCommon.GetData(data, info);
}
try
{
ValueEventArgs e = new ValueEventArgs(obj, attributeIndex, 0, parameters);
Read(e);
object value;
if (e.Handled)
{
value = e.Value;
}
else
{
value = (obj as IGXDLMSBase).GetValue(Settings, attributeIndex, selector, parameters);
}
bb.SetUInt8(ErrorCode.Ok);
GXDLMS.AppedData(obj, attributeIndex, bb, value);
}
catch (Exception)
{
bb.SetUInt8(1);
bb.SetUInt8(ErrorCode.HardwareFault);
}
}
}
ServerReply.ReplyMessages = GXDLMS.SplitPdu(Settings, Command.GetResponse, 3, bb, error, DateTime.MinValue);
}
else
{
Debug.WriteLine("handleGetRequest failed. Invalid command type.");
Settings.ResetBlockIndex();
// Access Error : Device reports a hardware fault.
ServerReply.ReplyMessages = GXDLMS.SplitPdu(Settings, Command.GetResponse, 1, bb, ErrorCode.HardwareFault, DateTime.MinValue);
}
ServerReply.Index = index;
return(ServerReply.ReplyMessages[index]);
}
///<summary>
///Handle set request.
///</summary>
///<returns>
///Reply to the client.
///</returns>
private byte[][] HandleSetRequest()
{
ErrorCode error = ErrorCode.Ok;
GXByteBuffer data = Reply.Data;
GXDataInfo info = new GXDataInfo();
GXByteBuffer bb = new GXByteBuffer();
// Get type.
short type = data.GetUInt8();
// Get invoke ID and priority.
data.GetUInt8();
// SetRequest normal
if (type == 1)
{
Settings.ResetBlockIndex();
ServerReply.Index = 0;
// CI
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
// Attribute index.
int index = data.GetUInt8();
// Get Access Selection.
data.GetUInt8();
object value = GXCommon.GetData(data, info);
GXDLMSObject obj = Settings.Objects.FindByLN(ci, GXDLMSObject.ToLogicalName(ln));
if (obj == null)
{
obj = FindObject(ci, 0, GXDLMSObject.ToLogicalName(ln));
}
// If target is unknown.
if (obj == null)
{
Debug.WriteLine("Undefined object.");
// Device reports a undefined object.
error = ErrorCode.UndefinedObject;
}
else
{
AccessMode am = obj.GetAccess(index);
// If write is denied.
if (am != AccessMode.Write && am != AccessMode.ReadWrite)
{
Debug.WriteLine("Read Write denied.");
error = ErrorCode.ReadWriteDenied;
}
else
{
try
{
if (value is byte[])
{
DataType dt = (obj as IGXDLMSBase).GetDataType(index);
if (dt != DataType.None)
{
value = GXDLMSClient.ChangeType((byte[])value, dt);
}
}
ValueEventArgs e = new ValueEventArgs(obj, index, 0, null);
Write(e);
if (!e.Handled)
{
(obj as IGXDLMSBase).SetValue(Settings, index, value);
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
error = ErrorCode.HardwareFault;
}
}
}
}
else
{
Debug.WriteLine("handleSetRequest failed. Unknown command.");
Settings.ResetBlockIndex();
error = ErrorCode.HardwareFault;
}
return(GXDLMS.SplitPdu(Settings, Command.SetResponse, 1, bb, error, DateTime.MinValue)[0]);
}
///<summary>
/// Handle write request.
///</summary>
///<param name="Reply">
/// Received data from the client.
/// </param>
///<returns>
/// Reply.
///</returns>
private byte[][] HandleWriteRequest()
{
GXByteBuffer data = Reply.Data;
short type;
object value;
// Get object count.
IList <GXSNInfo> targets = new List <GXSNInfo>();
int cnt = GXCommon.GetObjectCount(data);
GXByteBuffer results = new GXByteBuffer((ushort)cnt);
for (int pos = 0; pos != cnt; ++pos)
{
type = data.GetUInt8();
if (type == 2)
{
int sn = data.GetUInt16();
GXSNInfo info = FindSNObject(sn);
targets.Add(info);
// If target is unknown.
if (info == null)
{
// Device reports a undefined object.
results.SetUInt8(ErrorCode.UndefinedObject);
}
else
{
results.SetUInt8(ErrorCode.Ok);
}
}
else
{
// Device reports a HW error.
results.SetUInt8(ErrorCode.HardwareFault);
}
}
// Get data count.
cnt = GXCommon.GetObjectCount(data);
GXDataInfo di = new GXDataInfo();
for (int pos = 0; pos != cnt; ++pos)
{
if (results.GetUInt8(pos) == 0)
{
// If object has found.
GXSNInfo target = targets[pos];
value = GXCommon.GetData(data, di);
if (value is byte[])
{
DataType dt = target.Item.GetDataType(target.Index);
if (dt != DataType.None && dt != DataType.OctetString)
{
value = GXDLMSClient.ChangeType((byte[])value, dt);
}
}
di.Clear();
AccessMode am = target.Item.GetAccess(target.Index);
// If write is denied.
if (am != AccessMode.Write && am != AccessMode.ReadWrite)
{
results.SetUInt8((byte)pos, (byte)ErrorCode.ReadWriteDenied);
}
else
{
ValueEventArgs e = new ValueEventArgs(target.Item, target.Index, 0, null);
e.Value = value;
Write(e);
if (!e.Handled)
{
(target.Item as IGXDLMSBase).SetValue(Settings, target.Index, value);
}
}
}
}
GXByteBuffer bb = new GXByteBuffer((UInt16)(2 * cnt + 2));
GXCommon.SetObjectCount(cnt, bb);
byte ret;
for (int pos = 0; pos != cnt; ++pos)
{
ret = results.GetUInt8(pos);
// If meter returns error.
if (ret != 0)
{
bb.SetUInt8(1);
}
bb.SetUInt8(ret);
}
return(GXDLMS.SplitPdu(Settings, Command.WriteResponse, 1, bb, ErrorCode.Ok, DateTime.MinValue)[0]);
}
/// <summary>
/// Handle read Block in blocks.
/// </summary>
/// <param name="data">Received data.</param>
private static void HandleReadBlockNumberAccess(GXDLMSSettings settings, GXDLMSServer server, GXByteBuffer data, GXByteBuffer replyData, GXDLMSTranslatorStructure xml)
{
UInt16 blockNumber = data.GetUInt16();
if (xml != null)
{
xml.AppendStartTag(Command.ReadRequest, VariableAccessSpecification.BlockNumberAccess);
xml.AppendLine("<BlockNumber Value=\"" + xml.IntegerToHex(blockNumber, 4) + "\" />");
xml.AppendEndTag(Command.ReadRequest, VariableAccessSpecification.BlockNumberAccess);
return;
}
if (blockNumber != settings.BlockIndex)
{
GXByteBuffer bb = new GXByteBuffer();
Debug.WriteLine("handleReadRequest failed. Invalid block number. " + settings.BlockIndex + "/" + blockNumber);
bb.SetUInt8(ErrorCode.DataBlockNumberInvalid);
GXDLMS.GetSNPdu(new GXDLMSSNParameters(settings, Command.ReadResponse, 1, (byte)SingleReadResponse.DataAccessError, bb, null), replyData);
settings.ResetBlockIndex();
return;
}
if (settings.Index != settings.Count && server.transaction.data.Size < settings.MaxPduSize)
{
List <ValueEventArgs> reads = new List <ValueEventArgs>();
List <ValueEventArgs> actions = new List <ValueEventArgs>();
foreach (ValueEventArgs it in server.transaction.targets)
{
if (it.action)
{
actions.Add(it);
}
else
{
reads.Add(it);
}
}
if (reads.Count != 0)
{
server.NotifyRead(reads.ToArray());
}
if (actions.Count != 0)
{
server.NotifyAction(actions.ToArray());
}
GetReadData(settings, server.transaction.targets, server.transaction.data);
if (reads.Count != 0)
{
server.NotifyPostRead(reads.ToArray());
}
if (actions.Count != 0)
{
server.NotifyPostAction(actions.ToArray());
}
}
settings.IncreaseBlockIndex();
GXDLMSSNParameters p = new GXDLMSSNParameters(settings, Command.ReadResponse, 1,
(byte)SingleReadResponse.DataBlockResult, null, server.transaction.data);
p.multipleBlocks = true;
GXDLMS.GetSNPdu(p, replyData);
//If all data is sent.
if (server.transaction.data.Size == server.transaction.data.Position)
{
server.transaction = null;
settings.ResetBlockIndex();
}
else
{
server.transaction.data.Trim();
}
}
///<summary>
/// Handle action request.
///</summary>
public static void HandleMethodRequest(GXDLMSSettings settings, GXDLMSServer server, GXByteBuffer data, GXDLMSConnectionEventArgs connectionInfo, GXByteBuffer replyData, GXDLMSTranslatorStructure xml)
{
ErrorCode error = ErrorCode.Ok;
GXByteBuffer bb = new GXByteBuffer();
// Get type.
ActionRequestType type = (ActionRequestType)data.GetUInt8();
// Get invoke ID and priority.
byte invokeId = data.GetUInt8();
// CI
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
// Attribute Id
byte id = data.GetUInt8();
// Get parameters.
object parameters = null;
byte selection = data.GetUInt8();
if (xml != null)
{
xml.AppendStartTag(Command.MethodRequest);
if (type == ActionRequestType.Normal)
{
xml.AppendStartTag(Command.MethodRequest, ActionRequestType.Normal);
xml.AppendLine(TranslatorTags.InvokeId, "Value", xml.IntegerToHex(invokeId, 2));
AppendMethodDescriptor(xml, (int)ci, ln, id);
if (selection != 0)
{
//MethodInvocationParameters
xml.AppendStartTag(TranslatorTags.MethodInvocationParameters);
GXDataInfo di = new GXDataInfo();
di.xml = xml;
GXCommon.GetData(settings, data, di);
xml.AppendEndTag(TranslatorTags.MethodInvocationParameters);
}
xml.AppendEndTag(Command.MethodRequest, ActionRequestType.Normal);
}
xml.AppendEndTag(Command.MethodRequest);
return;
}
if (selection != 0)
{
GXDataInfo info = new GXDataInfo();
parameters = GXCommon.GetData(settings, data, info);
}
GXDLMSObject obj = settings.Objects.FindByLN(ci, GXCommon.ToLogicalName(ln));
if (!settings.Connected && (ci != ObjectType.AssociationLogicalName || id != 1))
{
replyData.Set(GXDLMSServer.GenerateConfirmedServiceError(ConfirmedServiceError.InitiateError,
ServiceError.Service, (byte)Service.Unsupported));
return;
}
if (obj == null)
{
obj = server.NotifyFindObject(ci, 0, GXCommon.ToLogicalName(ln));
}
if (obj == null)
{
// Device reports a undefined object.
error = ErrorCode.UndefinedObject;
}
else
{
ValueEventArgs e = new ValueEventArgs(server, obj, id, 0, parameters);
e.InvokeId = invokeId;
if (server.NotifyGetMethodAccess(e) == MethodAccessMode.NoAccess)
{
error = ErrorCode.ReadWriteDenied;
}
else
{
server.NotifyAction(new ValueEventArgs[] { e });
byte[] actionReply;
if (e.Handled)
{
actionReply = (byte[])e.Value;
}
else
{
actionReply = (obj as IGXDLMSBase).Invoke(settings, e);
server.NotifyPostAction(new ValueEventArgs[] { e });
}
//Set default action reply if not given.
if (actionReply != null && e.Error == 0)
{
//Add return parameters
bb.SetUInt8(1);
//Add parameters error code.
bb.SetUInt8(0);
GXCommon.SetData(settings, bb, GXCommon.GetValueType(actionReply), actionReply);
}
else
{
error = e.Error;
//Add return parameters
bb.SetUInt8(0);
}
}
invokeId = (byte)e.InvokeId;
}
GXDLMSLNParameters p = new GXDLMSLNParameters(settings, invokeId, Command.MethodResponse, 1, null, bb, (byte)error);
GXDLMS.GetLNPdu(p, replyData);
//If High level authentication fails.
if (!settings.Connected && obj is GXDLMSAssociationLogicalName && id == 1)
{
server.NotifyInvalidConnection(connectionInfo);
}
}
private static void HandleReadDataBlockAccess(
GXDLMSSettings settings, GXDLMSServer server,
Command command, GXByteBuffer data, int cnt, GXByteBuffer replyData, GXDLMSTranslatorStructure xml, Command cipheredCommand)
{
GXByteBuffer bb = new GXByteBuffer();
byte lastBlock = data.GetUInt8();
UInt16 blockNumber = data.GetUInt16();
if (xml != null)
{
if (command == Command.WriteResponse)
{
xml.AppendStartTag(TranslatorTags.WriteDataBlockAccess);
}
else
{
xml.AppendStartTag(TranslatorTags.ReadDataBlockAccess);
}
xml.AppendLine("<LastBlock Value=\"" + xml.IntegerToHex(lastBlock, 2) + "\" />");
xml.AppendLine("<BlockNumber Value=\"" + xml.IntegerToHex(blockNumber, 4) + "\" />");
if (command == Command.WriteResponse)
{
xml.AppendEndTag(TranslatorTags.WriteDataBlockAccess);
}
else
{
xml.AppendEndTag(TranslatorTags.ReadDataBlockAccess);
}
return;
}
if (blockNumber != settings.BlockIndex)
{
Debug.WriteLine("handleReadRequest failed. Invalid block number. " + settings.BlockIndex + "/" + blockNumber);
bb.SetUInt8(ErrorCode.DataBlockNumberInvalid);
GXDLMS.GetSNPdu(new GXDLMSSNParameters(settings, command, 1, (byte)SingleReadResponse.DataAccessError, bb, null), replyData);
settings.ResetBlockIndex();
return;
}
int count = 1;
byte type = (byte)DataType.OctetString;
if (command == Command.WriteResponse)
{
count = GXCommon.GetObjectCount(data);
type = data.GetUInt8();
}
int size = GXCommon.GetObjectCount(data);
int realSize = data.Size - data.Position;
if (count != 1 || type != (byte)DataType.OctetString || size != realSize)
{
Debug.WriteLine("handleGetRequest failed. Invalid block size.");
bb.SetUInt8(ErrorCode.DataBlockUnavailable);
GXDLMS.GetSNPdu(new GXDLMSSNParameters(settings, command, cnt, (byte)SingleReadResponse.DataAccessError, bb, null), replyData);
settings.ResetBlockIndex();
return;
}
if (server.transaction == null)
{
server.transaction = new GXDLMSLongTransaction(null, command, data);
}
else
{
server.transaction.data.Set(data);
}
if (lastBlock == 0)
{
bb.SetUInt16(blockNumber);
settings.IncreaseBlockIndex();
if (command == Command.ReadResponse)
{
type = (byte)SingleReadResponse.BlockNumber;
}
else
{
type = (byte)SingleWriteResponse.BlockNumber;
}
GXDLMS.GetSNPdu(new GXDLMSSNParameters(settings, command, cnt, type, null, bb), replyData);
return;
}
else
{
if (server.transaction != null)
{
data.Size = 0;
data.Set(server.transaction.data);
server.transaction = null;
}
if (command == Command.ReadResponse)
{
HandleReadRequest(settings, server, data, replyData, xml, cipheredCommand);
}
else
{
HandleWriteRequest(settings, server, data, replyData, xml, cipheredCommand);
}
settings.ResetBlockIndex();
}
}
/// <summary>
/// Handle get request normal command.
/// </summary>
/// <param name="data">Received data.</param>
private static void GetRequestNormal(GXDLMSSettings settings, byte invokeID, GXDLMSServer server, GXByteBuffer data, GXByteBuffer replyData, GXDLMSTranslatorStructure xml)
{
ValueEventArgs e = null;
GXByteBuffer bb = new GXByteBuffer();
// Get type.
ErrorCode status = ErrorCode.Ok;
settings.Count = settings.Index = 0;
settings.ResetBlockIndex();
// CI
ObjectType ci = (ObjectType)data.GetUInt16();
byte[] ln = new byte[6];
data.Get(ln);
// Attribute Id
byte attributeIndex = data.GetUInt8();
// AccessSelection
byte selection = data.GetUInt8();
byte selector = 0;
object parameters = null;
GXDataInfo info = new GXDataInfo();
if (selection != 0)
{
selector = data.GetUInt8();
}
if (xml != null)
{
AppendAttributeDescriptor(xml, (int)ci, ln, attributeIndex);
if (selection != 0)
{
info.xml = xml;
xml.AppendStartTag(TranslatorTags.AccessSelection);
xml.AppendLine(TranslatorTags.AccessSelector, "Value", xml.IntegerToHex(selector, 2));
xml.AppendStartTag(TranslatorTags.AccessParameters);
GXCommon.GetData(settings, data, info);
xml.AppendEndTag(TranslatorTags.AccessParameters);
xml.AppendEndTag(TranslatorTags.AccessSelection);
}
return;
}
if (selection != 0)
{
parameters = GXCommon.GetData(settings, data, info);
}
GXDLMSObject obj = settings.Objects.FindByLN(ci, GXCommon.ToLogicalName(ln));
if (obj == null)
{
obj = server.NotifyFindObject(ci, 0, GXCommon.ToLogicalName(ln));
}
e = new ValueEventArgs(server, obj, attributeIndex, selector, parameters);
if (obj == null)
{
// "Access Error : Device reports a undefined object."
status = ErrorCode.UndefinedObject;
}
else
{
e.InvokeId = invokeID;
if (server.NotifyGetAttributeAccess(e) == AccessMode.NoAccess)
{
//Read Write denied.
status = ErrorCode.ReadWriteDenied;
}
else
{
if (e.Target is GXDLMSProfileGeneric && attributeIndex == 2)
{
e.RowToPdu = GXDLMS.RowsToPdu(settings, (GXDLMSProfileGeneric)e.Target);
}
object value;
server.NotifyRead(new ValueEventArgs[] { e });
if (e.Handled)
{
value = e.Value;
}
else
{
settings.Count = e.RowEndIndex - e.RowBeginIndex;
value = (obj as IGXDLMSBase).GetValue(settings, e);
}
if (e.ByteArray)
{
bb.Set((byte[])value);
}
else
{
GXDLMS.AppendData(settings, obj, attributeIndex, bb, value);
}
server.NotifyPostRead(new ValueEventArgs[] { e });
status = e.Error;
}
}
GXDLMS.GetLNPdu(new GXDLMSLNParameters(settings, e.InvokeId, Command.GetResponse, 1, null, bb, (byte)status), replyData);
if (settings.Count != settings.Index || bb.Size != bb.Position)
{
server.transaction = new GXDLMSLongTransaction(new ValueEventArgs[] { e }, Command.GetRequest, bb);
}
}
/// <summary>
/// Initialize server.
/// </summary>
/// <remarks>
/// This must call after server objects are set.
/// </remarks>
public void Initialize()
{
bool association = false;
Initialized = true;
for (int pos = 0; pos != Items.Count; ++pos)
{
GXDLMSObject it = Items[pos];
if (this.UseLogicalNameReferencing &&
(string.IsNullOrEmpty(it.LogicalName) || it.LogicalName.Split('.').Length != 6))
{
throw new Exception("Invalid Logical Name.");
}
it.Start(this);
if (it is GXDLMSProfileGeneric)
{
GXDLMSProfileGeneric pg = it as GXDLMSProfileGeneric;
foreach (var obj in pg.CaptureObjects)
{
if (obj.Value.AttributeIndex < 1)
{
throw new Exception("Invalid attribute index. SelectedAttributeIndex is not set for " + obj.Key.Name);
}
}
}
else if (it is GXDLMSAssociationShortName && !this.UseLogicalNameReferencing)
{
if ((it as GXDLMSAssociationShortName).ObjectList.Count == 0)
{
(it as GXDLMSAssociationShortName).ObjectList.AddRange(this.Items);
}
association = true;
}
else if (it is GXDLMSAssociationLogicalName && this.UseLogicalNameReferencing)
{
if ((it as GXDLMSAssociationLogicalName).ObjectList.Count == 0)
{
(it as GXDLMSAssociationLogicalName).ObjectList.AddRange(this.Items);
}
association = true;
}
else if (it is GXDLMSHdlcSetup)
{
hdlcSetup = it as GXDLMSHdlcSetup;
}
else if (!(it is IGXDLMSBase))//Remove unsupported items.
{
Debug.WriteLine(it.ObjectType.ToString() + " not supported.");
Items.RemoveAt(pos);
--pos;
}
}
if (!association)
{
if (UseLogicalNameReferencing)
{
GXDLMSAssociationLogicalName it = new GXDLMSAssociationLogicalName();
it.ObjectList = this.Items;
Items.Add(it);
}
else
{
GXDLMSAssociationShortName it = new GXDLMSAssociationShortName();
it.ObjectList = this.Items;
Items.Add(it);
}
}
//Arrange items by Short Name.
int sn = 0xA0;
int offset, count;
if (!this.UseLogicalNameReferencing)
{
foreach (GXDLMSObject it in Items)
{
//Generate Short Name if not given.
if (it.ShortName == 0)
{
it.ShortName = (ushort)sn;
//Add method index addresses.
GXDLMS.GetActionInfo(it.ObjectType, out offset, out count);
if (count != 0)
{
sn += offset + (8 * count);
}
else //If there are no methods.
{
//Add attribute index addresses.
sn += 8 * (it as IGXDLMSBase).GetAttributeCount();
}
}
}
}
}
/// <summary>
/// Handle get request next data block command.
/// </summary>
/// <param name="data">Received data.</param>
private static void GetRequestNextDataBlock(GXDLMSSettings settings, byte invokeID, GXDLMSServer server, GXByteBuffer data, GXByteBuffer replyData, GXDLMSTranslatorStructure xml)
{
GXByteBuffer bb = new GXByteBuffer();
uint index;
// Get block index.
index = data.GetUInt32();
if (xml != null)
{
xml.AppendLine(TranslatorTags.BlockNumber, null, xml.IntegerToHex(index, 8));
return;
}
if (index != settings.BlockIndex)
{
Debug.WriteLine("handleGetRequest failed. Invalid block number. " + settings.BlockIndex + "/" + index);
GXDLMS.GetLNPdu(new GXDLMSLNParameters(settings, 0, Command.GetResponse, 2, null, bb, (byte)ErrorCode.DataBlockNumberInvalid), replyData);
}
else
{
settings.IncreaseBlockIndex();
GXDLMSLNParameters p = new GXDLMSLNParameters(settings, invokeID, Command.GetResponse, 2, null, bb, (byte)ErrorCode.Ok);
//If transaction is not in progress.
if (server.transaction == null)
{
p.status = (byte)ErrorCode.NoLongGetOrReadInProgress;
}
else
{
bb.Set(server.transaction.data);
bool moreData = settings.Index != settings.Count;
if (moreData)
{
//If there is multiple blocks on the buffer.
//This might happen when Max PDU size is very small.
if (bb.Size < settings.MaxPduSize)
{
foreach (ValueEventArgs arg in server.transaction.targets)
{
object value;
server.NotifyRead(new ValueEventArgs[] { arg });
if (arg.Handled)
{
value = arg.Value;
}
else
{
value = (arg.Target as IGXDLMSBase).GetValue(settings, arg);
}
//Add data.
if (arg.ByteArray)
{
bb.Set((byte[])value);
}
else
{
GXDLMS.AppendData(settings, arg.Target, arg.Index, bb, value);
}
}
moreData = settings.Index != settings.Count;
}
}
p.multipleBlocks = true;
GXDLMS.GetLNPdu(p, replyData);
if (moreData || bb.Size - bb.Position != 0)
{
server.transaction.data = bb;
}
else
{
server.transaction = null;
settings.ResetBlockIndex();
}
}
}
}
///<summary>
/// Handle received command.
///</summary>
private byte[] HandleCommand(Command cmd, GXByteBuffer data, GXDLMSConnectionEventArgs connectionInfo)
{
byte frame = 0;
switch (cmd)
{
case Command.AccessRequest:
GXDLMSLNCommandHandler.HandleAccessRequest(Settings, this, data, replyData, null);
break;
case Command.SetRequest:
GXDLMSLNCommandHandler.HandleSetRequest(Settings, this, data, replyData, null);
break;
case Command.WriteRequest:
GXDLMSSNCommandHandler.HandleWriteRequest(Settings, this, data, replyData, null);
break;
case Command.GetRequest:
if (data.Size != 0)
{
GXDLMSLNCommandHandler.HandleGetRequest(Settings, this, data, replyData, null);
}
break;
case Command.ReadRequest:
GXDLMSSNCommandHandler.HandleReadRequest(Settings, this, data, replyData, null);
break;
case Command.MethodRequest:
GXDLMSLNCommandHandler.HandleMethodRequest(Settings, this, data, connectionInfo, replyData, null);
break;
case Command.Snrm:
HandleSnrmRequest();
frame = (byte)Command.Ua;
break;
case Command.Aarq:
HandleAarqRequest(data, connectionInfo);
break;
case Command.ReleaseRequest:
case Command.DisconnectRequest:
GenerateDisconnectRequest();
Settings.Connected = false;
Disconnected(connectionInfo);
frame = (byte)Command.Ua;
break;
case Command.None:
//Get next frame.
break;
default:
Debug.WriteLine("Invalid command: " + (int)cmd);
break;
}
byte[] reply;
if (this.InterfaceType == Enums.InterfaceType.WRAPPER)
{
reply = GXDLMS.GetWrapperFrame(Settings, replyData);
}
else
{
reply = GXDLMS.GetHdlcFrame(Settings, frame, replyData);
}
return(reply);
}
public GXDLMSException(int errCode)
: base(GXDLMS.GetDescription((ErrorCode)errCode))
{
ErrorCode = errCode;
HelpLink = "https://www.gurux.fi/Gurux.DLMS.ErrorCodes#" + ErrorCode;
}
