public override void Serialise(TlvWriter writer)
{
if (_Package != null)
{
_Package.Serialise(writer);
}
if (_PackageURI != null)
{
_PackageURI.Serialise(writer);
}
if (_State != null)
{
_State.Serialise(writer);
}
if (_UpdateSupportedObjects != null)
{
_UpdateSupportedObjects.Serialise(writer);
}
if (_UpdateResult != null)
{
_UpdateResult.Serialise(writer);
}
if (_PackageName != null)
{
_PackageName.Serialise(writer);
}
if (_PackageVersion != null)
{
_PackageVersion.Serialise(writer);
}
}
public static ITlvTag GetCompositeTag(Type type, uint tagType, ITlvTag[] childTags)
{
RawTag raw;
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
foreach (ITlvTag tag in childTags)
{
writer.WriteTag(tag);
}
raw = new RawTag(tagType, false, false, ((MemoryStream)writer.BaseStream).ToArray());
}
object[] args = new object[] { raw };
ITlvTag value = (ITlvTag)Activator.CreateInstance(type, args);
// set _value inside CompositeTag
FieldInfo field = typeof(CompositeTag).GetField("_childTags", BindingFlags.Instance | BindingFlags.NonPublic);
if (field == null)
{
throw new Exception("Cannot find field '_value' inside CompositeTag class.");
}
field.SetValue(value, new List <ITlvTag>(childTags));
return(value);
}
public void WriteTo(Stream outputStream)
{
using (TlvWriter writer = new TlvWriter(outputStream))
{
writer.WriteTag(this);
}
}
public override void Serialise(TlvWriter writer)
{
if (_Latitude != null)
{
_Latitude.Serialise(writer);
}
if (_Longitude != null)
{
_Longitude.Serialise(writer);
}
if (_Altitude != null)
{
_Altitude.Serialise(writer);
}
if (_Uncertainty != null)
{
_Uncertainty.Serialise(writer);
}
if (_Velocity != null)
{
_Velocity.Serialise(writer);
}
if (_Timestamp != null)
{
_Timestamp.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
if (_ShortServerID != null)
{
_ShortServerID.Serialise(writer);
}
if (_Lifetime != null)
{
_Lifetime.Serialise(writer);
}
if (_DefaultMinimumPeriod != null)
{
_DefaultMinimumPeriod.Serialise(writer);
}
if (_DefaultMaximumPeriod != null)
{
_DefaultMaximumPeriod.Serialise(writer);
}
if (_DisableTimeout != null)
{
_DisableTimeout.Serialise(writer);
}
if (_NotificationStoringWhenDisabledorOffline != null)
{
_NotificationStoringWhenDisabledorOffline.Serialise(writer);
}
if (_Binding != null)
{
_Binding.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
if (_Property != null)
{
_Property.Serialise(writer);
}
if (_Group != null)
{
_Group.Serialise(writer);
}
if (_Description != null)
{
_Description.Serialise(writer);
}
if (_Attached != null)
{
_Attached.Serialise(writer);
}
if (_Enabled != null)
{
_Enabled.Serialise(writer);
}
if (_NotifyEn != null)
{
_NotifyEn.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
if (_SMSTxCounter != null)
{
_SMSTxCounter.Serialise(writer);
}
if (_SMSRxCounter != null)
{
_SMSRxCounter.Serialise(writer);
}
if (_TxData != null)
{
_TxData.Serialise(writer);
}
if (_RxData != null)
{
_RxData.Serialise(writer);
}
if (_MaxMessageSize != null)
{
_MaxMessageSize.Serialise(writer);
}
if (_AverageMessageSize != null)
{
_AverageMessageSize.Serialise(writer);
}
}
public void TestWriteTagShort()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.WriteTag(new RawTag(0x1, false, true, new byte[] { 0x0, 0x1, 0x2, 0x3 }));
CollectionAssert.AreEqual(new byte[] { 0x21, 0x4, 0x0, 0x1, 0x2, 0x3 }, ((MemoryStream)writer.BaseStream).ToArray(), "Writer should output correct byte array");
}
}
public void TestWriteNullTag()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.WriteTag(null);
CollectionAssert.AreEqual(new byte[] { }, ((MemoryStream)writer.BaseStream).ToArray(), "Writer should output correct byte array");
}
}
/// <summary>
/// Extend signature to publication.
/// </summary>
/// <param name="calendarHashChain">extended calendar hash chain</param>
/// <param name="publicationRecord">extended publication record</param>
/// <param name="signatureFactory">signature factory to be used when creating extended signature</param>
/// <returns>extended KSI signature</returns>
public IKsiSignature Extend(CalendarHashChain calendarHashChain, PublicationRecordInSignature publicationRecord, IKsiSignatureFactory signatureFactory = null)
{
Logger.Debug("Extending KSI signature.");
if (calendarHashChain == null)
{
throw new ArgumentNullException(nameof(calendarHashChain));
}
if (CalendarHashChain != null && !CalendarHashChain.AreRightLinksEqual(calendarHashChain))
{
throw new KsiException("Right links of signature calendar hash chain and extended calendar hash chain do not match");
}
if (publicationRecord == null)
{
publicationRecord = new PublicationRecordInSignature(false, false, calendarHashChain.PublicationData);
}
if (signatureFactory == null)
{
signatureFactory = new KsiSignatureFactory();
}
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
foreach (ITlvTag childTag in this)
{
switch (childTag.Type)
{
case Constants.CalendarHashChain.TagType:
case Constants.CalendarAuthenticationRecord.TagType:
case Constants.PublicationRecord.TagTypeInSignature:
break;
default:
writer.WriteTag(childTag);
break;
}
}
writer.WriteTag(calendarHashChain);
writer.WriteTag(publicationRecord);
try
{
IKsiSignature signature = signatureFactory.CreateByContent(((MemoryStream)writer.BaseStream).ToArray(), InputHash);
Logger.Debug("Extending KSI signature successful.");
return(signature);
}
catch (TlvException e)
{
Logger.Warn("Extending KSI signature failed: {0}", e);
throw;
}
}
}
public void TestWriteNullValue()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.WriteTag(new AllowNullValueTlvTag(0x1, false, false));
writer.WriteTag(new AllowNullValueTlvTag(0x257, true, true));
CollectionAssert.AreEqual(new byte[] { 0x1, 0x0, 0xe2, 0x57, 0x0 }, ((MemoryStream)writer.BaseStream).ToArray(), "Writer should output correct byte array");
}
}
/// <summary>
/// Calculate MAC and attach it to PDU.
/// </summary>
/// <param name="macAlgorithm">MAC algorithm</param>
/// <param name="key">hmac key</param>
/// <param name="header">KSI header</param>
/// <param name="payload">KSI payload</param>
public static ImprintTag GetMacTag(HashAlgorithm macAlgorithm, byte[] key, PduHeader header, PduPayload payload)
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.WriteTag(header);
writer.WriteTag(payload);
return(new ImprintTag(Constants.Pdu.MacTagType, false, false, CalculateMac(macAlgorithm, key, ((MemoryStream)writer.BaseStream).ToArray())));
}
}
public override void Serialise(TlvWriter writer)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ShortServerID, ShortServerID);
if (Lifetime > 0)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.Lifetime, Lifetime);
}
if (DefaultMinimumPeriod.HasValue)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.DefaultMinimumPeriod, DefaultMinimumPeriod.Value);
}
if (DefaultMaximumPeriod.HasValue)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.DefaultMaximumPeriod, DefaultMaximumPeriod.Value);
}
if (DisableTimeout.HasValue)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.DisableTimeout, DisableTimeout.Value);
}
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.NotificationStoringWhenOffline, NotificationStoringWhenOffline);
string binding = null;
switch (Binding)
{
case TBindingMode.NotSet:
break;
case TBindingMode.UDP:
binding = "U";
break;
case TBindingMode.QueuedUDP:
binding = "UQ";
break;
case TBindingMode.SMS:
binding = "S";
break;
case TBindingMode.QueuedSMS:
binding = "SQ";
break;
case TBindingMode.UDPSMS:
binding = "US";
break;
case TBindingMode.QueuedUDPSMS:
binding = "UQS";
break;
default:
break;
}
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.Binding, binding);
}
/// <summary>
/// Executes the GET method on the resource.
/// </summary>
/// <param name="Request">CoAP Request</param>
/// <param name="Response">CoAP Response</param>
/// <exception cref="CoapException">If an error occurred when processing the method.</exception>
public virtual void GET(CoapMessage Request, CoapResponse Response)
{
ILwm2mWriter Writer;
bool FromBootstrapServer = this.objInstance.Object.Client.IsFromBootstrapServer(Request);
if (this.id == 0 && !FromBootstrapServer)
{
Response.RST(CoapCode.Unauthorized);
return;
}
if (Request.Accept is null)
{
Writer = new TextWriter();
}
else if (Request.IsAcceptable(Tlv.ContentFormatCode))
{
Writer = new TlvWriter();
}
else if (Request.IsAcceptable(Json.ContentFormatCode))
{
Writer = new JsonWriter(this.objInstance.Path + "/");
}
else if (Request.IsAcceptable(CoAP.ContentFormats.PlainText.ContentFormatCode))
{
Writer = new TextWriter();
}
else if (Request.IsAcceptable(CoAP.ContentFormats.Binary.ContentFormatCode))
{
Writer = new OpaqueWriter();
}
else
{
Response.RST(CoapCode.NotAcceptable);
return;
}
if (this.OnBeforeGet != null)
{
try
{
this.OnBeforeGet.Invoke(this, new CoapRequestEventArgs(Request));
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
this.Write(Writer);
byte[] Payload = Writer.ToArray();
Response.Respond(CoapCode.Content, Payload, 64,
new CoapOptionContentFormat(Writer.ContentFormat));
}
/// <summary>
/// Executes the GET method on the resource.
/// </summary>
/// <param name="Request">CoAP Request</param>
/// <param name="Response">CoAP Response</param>
/// <exception cref="CoapException">If an error occurred when processing the method.</exception>
public virtual void GET(CoapMessage Request, CoapResponse Response)
{
ILwm2mWriter Writer;
bool FromBootstrapServer = this.obj.Client.IsFromBootstrapServer(Request);
if (this.id == 0 && !FromBootstrapServer)
{
Response.RST(CoapCode.Unauthorized);
return;
}
if (!string.IsNullOrEmpty(Request.SubPath))
{
Response.RST(CoapCode.NotFound);
return;
}
if (Request.IsAcceptable(Tlv.ContentFormatCode))
{
Writer = new TlvWriter();
}
else if (Request.IsAcceptable(Json.ContentFormatCode))
{
Writer = new JsonWriter(this.Path + "/");
}
else if (Request.IsAcceptable(CoAP.ContentFormats.CoreLinkFormat.ContentFormatCode))
{
StringBuilder Output = new StringBuilder();
this.EncodeObjectLinks(FromBootstrapServer, Output);
Response.Respond(CoapCode.Content, Encoding.UTF8.GetBytes(Output.ToString()), 64,
new CoapOptionContentFormat(CoAP.ContentFormats.CoreLinkFormat.ContentFormatCode));
return;
}
else
{
Response.RST(CoapCode.NotAcceptable);
return;
}
this.Export(Writer);
byte[] Payload = Writer.ToArray();
if (Payload.Length == 0)
{
Response.RST(CoapCode.NotFound);
}
else
{
Response.Respond(CoapCode.Content, Payload, 64,
new CoapOptionContentFormat(Writer.ContentFormat));
}
}
private byte[] SerialiseObject(ITlvSerialisable item)
{
byte[] result = null;
using (MemoryStream steam = new MemoryStream())
{
TlvWriter writer = new TlvWriter(steam);
item.Serialise(writer);
result = steam.ToArray();
}
return(result);
}
public void TestWriteTagWithTooLongType()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
ArgumentOutOfRangeException ex = Assert.Throws <ArgumentOutOfRangeException>(delegate
{
writer.WriteTag(new RawTag(0x2000, true, true, new byte[256]));
});
Assert.AreEqual("tag", ex.ParamName);
}
}
public void TestWriteTagWithTooLongData()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
ArgumentOutOfRangeException ex = Assert.Throws <ArgumentOutOfRangeException>(delegate
{
writer.WriteTag(new RawTag(0x1, true, true, new byte[ushort.MaxValue + 1]));
});
Assert.AreEqual("data", ex.ParamName);
}
}
/// <summary>
/// Calculate MAC value.
/// </summary>
/// <param name="macAlgorithm">MAC algorithm</param>
/// <param name="key">HMAC key</param>
private DataHash CalcMacValue(HashAlgorithm macAlgorithm, byte[] key)
{
MemoryStream stream = new MemoryStream();
using (TlvWriter writer = new TlvWriter(stream))
{
writer.WriteTag(this);
return(CalcMacValue(stream.ToArray(), macAlgorithm, key));
}
}
public override void Serialise(TlvWriter writer)
{
if (_LWM2MServerURI != null)
{
_LWM2MServerURI.Serialise(writer);
}
if (_BootstrapServer != null)
{
_BootstrapServer.Serialise(writer);
}
if (_SecurityMode != null)
{
_SecurityMode.Serialise(writer);
}
if (_PublicKeyorIdentity != null)
{
_PublicKeyorIdentity.Serialise(writer);
}
if (_ServerPublicKeyorIdentity != null)
{
_ServerPublicKeyorIdentity.Serialise(writer);
}
if (_SecretKey != null)
{
_SecretKey.Serialise(writer);
}
if (_SMSSecurityMode != null)
{
_SMSSecurityMode.Serialise(writer);
}
if (_SMSBindingKeyParameters != null)
{
_SMSBindingKeyParameters.Serialise(writer);
}
if (_SMSBindingSecretKeys != null)
{
_SMSBindingSecretKeys.Serialise(writer);
}
if (_LWM2MServerSMSNumber != null)
{
_LWM2MServerSMSNumber.Serialise(writer);
}
if (_ShortServerID != null)
{
_ShortServerID.Serialise(writer);
}
if (_ClientHoldOffTime != null)
{
_ClientHoldOffTime.Serialise(writer);
}
}
/// <summary>
/// Get signed bytes.
/// </summary>
/// <returns>signed bytes</returns>
public byte[] GetSignedBytes()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.Write(FileBeginningMagicBytes);
// get all but last tag
for (int i = 0; i < Count - 1; i++)
{
writer.WriteTag(this[i]);
}
return(((MemoryStream)writer.BaseStream).ToArray());
}
}
public void Serialise(TlvWriter writer, bool resourceInstance)
{
ushort identifier;
if (ushort.TryParse(Name, out identifier))
{
TTlvTypeIdentifier typeIdentifier = TTlvTypeIdentifier.ResourceWithValue;
if (resourceInstance)
{
typeIdentifier = TTlvTypeIdentifier.ResourceInstance;
}
writer.Write(typeIdentifier, identifier, Value);
}
}
public void TestWriteTagLongWithLongType()
{
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
writer.WriteTag(new RawTag(0x257, true, true, new byte[256]));
byte[] result = new byte[260];
result[0] = 0xe2;
result[1] = 0x57;
result[2] = 0x1;
result[3] = 0x0;
Array.Copy(new byte[256], 0, result, 4, 256);
CollectionAssert.AreEqual(result, ((MemoryStream)writer.BaseStream).ToArray(), "Writer should output correct byte array");
}
}
private byte[] SerialiseObject(ITlvSerialisable item, ushort objectInstanceID)
{
byte[] result = null;
using (MemoryStream steam = new MemoryStream())
{
TlvWriter writer = new TlvWriter(steam);
item.Serialise(writer);
byte[] objectTLV = steam.ToArray();
int length = (int)steam.Length;
steam.SetLength(0);
writer.WriteType(TTlvTypeIdentifier.ObjectInstance, objectInstanceID, length);
steam.Write(objectTLV, 0, length);
result = steam.ToArray();
}
return(result);
}
public override void Serialise(TlvWriter writer)
{
if (_DeviceID != null)
{
_DeviceID.Serialise(writer);
}
if (_ParentID != null)
{
_ParentID.Serialise(writer);
}
if (_DeviceType != null)
{
_DeviceType.Serialise(writer);
}
if (_Name != null)
{
_Name.Serialise(writer);
}
if (_Description != null)
{
_Description.Serialise(writer);
}
if (_FCAP != null)
{
_FCAP.Serialise(writer);
}
if (_TenantID != null)
{
_TenantID.Serialise(writer);
}
if (_TenantChallenge != null)
{
_TenantChallenge.Serialise(writer);
}
if (_HashIterations != null)
{
_HashIterations.Serialise(writer);
}
if (_TenantHash != null)
{
_TenantHash.Serialise(writer);
}
if (_Status != null)
{
_Status.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
if (_NetworkBearer != null)
{
_NetworkBearer.Serialise(writer);
}
if (_AvailableNetworkBearers != null)
{
_AvailableNetworkBearers.Serialise(writer);
}
if (_RadioSignalStrength != null)
{
_RadioSignalStrength.Serialise(writer);
}
if (_LinkQuality != null)
{
_LinkQuality.Serialise(writer);
}
if (_IPAddresses != null)
{
_IPAddresses.Serialise(writer);
}
if (_RouterIPAddresses != null)
{
_RouterIPAddresses.Serialise(writer);
}
if (_LinkUtilization != null)
{
_LinkUtilization.Serialise(writer);
}
if (_APNs != null)
{
_APNs.Serialise(writer);
}
if (_CellID != null)
{
_CellID.Serialise(writer);
}
if (_SMNC != null)
{
_SMNC.Serialise(writer);
}
if (_SMCC != null)
{
_SMCC.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
ushort identifier;
if (ushort.TryParse(Name, out identifier))
{
using (MemoryStream steam = new MemoryStream())
{
TlvWriter childWriter = new TlvWriter(steam);
foreach (IntegerResource item in this.Children)
{
item.Serialise(childWriter, true);
}
writer.Write(TTlvTypeIdentifier.MultipleResources, identifier, steam.ToArray());
}
}
}
public void Serialise(TlvWriter writer)
{
if (!string.IsNullOrEmpty(ServerURI))
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ServerURI, ServerURI);
}
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.BootstrapServer, BootstrapServer);
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.SecurityMode, (int)SecurityMode);
if (ClientPublicKey != null)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ClientPublicKey, ClientPublicKey);
}
if (ServerPublicKey != null)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ServerPublicKey, ServerPublicKey);
}
if (SecretKey != null)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.SecretKey, SecretKey);
}
if (SMSSecurityMode != TSMSSecurityMode.NotSet)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.SMSSecurityMode, (int)SMSSecurityMode);
}
if (SMSBindingKeyParameters != null)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.SMSBindingKeyParameters, SMSBindingKeyParameters);
}
if (SMSBindingSecretKeys != null)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.SMSBindingSecretKeys, SMSBindingSecretKeys);
}
if (ServerSMSNumber.HasValue)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ServerSMSNumber, ServerSMSNumber.Value);
}
if (ShortServerID > 0)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ShortServerID, ShortServerID);
}
if (ClientHoldOffTime.HasValue)
{
writer.Write(TTlvTypeIdentifier.ResourceWithValue, (ushort)ResourceID.ClientHoldOffTime, ClientHoldOffTime.Value);
}
}
public override void Serialise(TlvWriter writer)
{
if (_ObjectID != null)
{
_ObjectID.Serialise(writer);
}
if (_ObjectInstanceID != null)
{
_ObjectInstanceID.Serialise(writer);
}
if (_ACLs != null)
{
_ACLs.Serialise(writer);
}
if (_AccessControlOwner != null)
{
_AccessControlOwner.Serialise(writer);
}
}
public override void Serialise(TlvWriter writer)
{
if (_CommandID != null)
{
_CommandID.Serialise(writer);
}
if (_CommandTypeID != null)
{
_CommandTypeID.Serialise(writer);
}
if (_Status != null)
{
_Status.Serialise(writer);
}
if (_StatusCode != null)
{
_StatusCode.Serialise(writer);
}
if (_ParameterName != null)
{
_ParameterName.Serialise(writer);
}
if (_ParameterValue != null)
{
_ParameterValue.Serialise(writer);
}
if (_ResultContentType != null)
{
_ResultContentType.Serialise(writer);
}
if (_ResultContent != null)
{
_ResultContent.Serialise(writer);
}
if (_ErrorContentType != null)
{
_ErrorContentType.Serialise(writer);
}
if (_ErrorContent != null)
{
_ErrorContent.Serialise(writer);
}
}
