/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
if (frameData.Length >= 5)
{
// Encoding type
TextEncodingType encType = (TextEncodingType)frameData[0];
// Language
char[] languageBytes = new char[COMMFrame.LanguageFieldLength];
Array.Copy(frameData, 1, languageBytes, 0, languageBytes.Length);
string languageStr = (new String(languageBytes)).ToUpper();
language = new EncodedString(LanguageEncodingType, languageStr);
// Text
byte[] textBytes = new byte[frameData.Length - 4];
Array.Copy(frameData, 4, textBytes, 0, textBytes.Length);
IList <EncodedString> strings = EncodedString.CreateStrings(encType, textBytes);
if (strings.Count >= 2)
{
description = strings[0];
base.EncodedText = strings[1];
SetEncodedStringSettings();
}
}
}
public ConnectPacketTest()
{
w = new Will(QoSLevel.AtLeastOnce, true, "Test Topic", new EncodedDataField(utf8.GetBytes("Will payload")));
auth = new Authentication("username", "password");
clientID = new EncodedString("Client ID");
cp = new ConnectPacket(clientID, w, auth, true, 5);
}
public static string EncodeValue(object value, SharpValueType valueType, char delimiter = '\0', bool quoteQuotes = false)
{
if (value == null)
{
return("");
}
if (value is DateTime)
{
return(EncodedString.TrimStandardDate((DateTime)value));
}
if (!(value is string))
{
return(value.ToString());
}
var result = value.ToString();
if (EncodedString.IsQuotedStringEncodingRequired(result, delimiter: delimiter, quoteQuotes: quoteQuotes))
{
return(EncodedString.EncodeQuotedString(result));
}
return(result);
}
private static byte[] GetMD5(EncodedString str)
{
using (MD5CryptoServiceProvider md5Provider = new MD5CryptoServiceProvider())
{
return(md5Provider.ComputeHash(str));
}
}
/// <summary>
/// Writes the header for this frame to a stream.
/// </summary>
/// <param name="stream">The stream to write to.</param>
/// <param name="version">The ID3v2 version to use in writing the frame.</param>
protected void WriteHeaderToStream(Stream stream, ID3Versions version)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if ((version & ID3Versions.V2) == ID3Versions.V2)
{
string frameIDString = FrameRegistry.GetFrameId(this.frameType, version);
if (frameIDString == null)
{
throw new UnsupportedVersionException(version);
}
EncodedString frameID = new EncodedString(TextEncodingType.ISO_8859_1, frameIDString);
frameID.IsTerminated = false;
frameID.HasEncodingTypePrepended = false;
frameID.WriteToStream(stream);
WriteFrameSize(stream, version);
WriteFlags(stream, version);
stream.Flush();
}
else
{
throw new UnsupportedVersionException(version);
}
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="frame">Frame to copy.</param>
protected internal UFIDFrame(UFIDFrame frame)
: base(frame)
{
this.ownerIdentifier = frame.ownerIdentifier.Copy();
this.identifier = new byte[frame.identifier.Length];
frame.identifier.CopyTo(this.identifier, 0);
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="frame">Frame to copy.</param>
protected internal PRIVFrame(PRIVFrame frame)
: base(frame)
{
this.ownerIdentifier = frame.ownerIdentifier.Copy();
this.privateData = new byte[frame.privateData.Length];
frame.privateData.CopyTo(this.privateData, 0);
}
/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
IList <EncodedString> strings = EncodedString.CreateStrings(frameData);
if (strings.Count >= 1)
{
text = strings[0]; //*** no support yet for multiple strings
SetEncodedStringSettings();
}
}
/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
if (frameData.Length > 0)
{
IList <EncodedString> strings =
EncodedString.CreateStrings(URLLinkFrame.UrlEncodingType, frameData);
url = strings[0]; // "If the text string is followed by a string
// termination, all the following information should be ignored and not be displayed."
SetEncodedStringSettings();
}
}
/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
IList <EncodedString> strings = EncodedString.CreateStrings(frameData);
if (strings.Count >= 2)
{
description = strings[0];
base.EncodedText = strings[1];
SetEncodedStringSettings();
}
}
public void Client_ID_encoded_correctly()
{
EncodedString clientID = "This is a client id";
IByteEncodable cp = new ConnectPayload(clientID);
EncodedString parsedEncodedString =
new EncodedString(
new MemoryStream(cp.Encode().ToArray()));
Assert.IsTrue(clientID == parsedEncodedString);
}
/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
IList <EncodedString> strings =
EncodedString.CreateStrings(TextEncodingType.ISO_8859_1, frameData, 1,
delegate(byte[] leftoverBytes) { Identifier = leftoverBytes; });
if (strings.Count == 1)
{
ownerIdentifier = strings[0];
SetEncodedStringSettings();
}
}
public void Password_encoded_when_provided()
{
EncodedString clientID = "ClientID";
Authentication auth = new Authentication("username", "TestPassword");
ConnectPayload cp = new ConnectPayload(clientID, null, auth);
IEnumerable <byte> encodedBytes = cp.Encode();
string password = utf8.GetString(encodedBytes.Skip(clientID.Length + 2)
.Skip(auth.Username.Length + 4)
.ToArray());
Assert.IsTrue(auth.Password == password);
}
public static string HashPassword(string password, string salt)
{
EncodedString encodedPassword = Encoding.UTF8.GetBytes(password);
EncodedString encodedSalt = Encoding.UTF8.GetBytes(salt);
string md5PasswordHash = MD5HashPassword(encodedPassword, encodedSalt);
byte[] md5PasswordHashBytes = Encoding.ASCII.GetBytes(md5PasswordHash);
using (SHA1CryptoServiceProvider sha1Provider = new SHA1CryptoServiceProvider())
{
byte[] sha1PasswordHashBytes = sha1Provider.ComputeHash(md5PasswordHashBytes);
return(BitConverter.ToString(sha1PasswordHashBytes).Replace("-", "").ToLower());
}
}
public void Topic_is_encoded_as_first_field()
{
EncodedString topicName = "Test/topic";
PublishVariableHeader variableHeader = new PublishVariableHeader(topicName);
byte[] encodedTopicNameBytes = variableHeader
.Encode()
.Take(
topicName.Encode().Count()).ToArray();
for (int i = 0; i < topicName.Encode().Count(); i++)
{
Assert.AreEqual(topicName.Encode().ToArray()[i], encodedTopicNameBytes[i]);
}
}
public void Username_encoded_when_provided()
{
EncodedString username = new EncodedString("username");
Authentication auth = new Authentication(username);
EncodedString clientID = "ClientID";
IByteEncodable cp = new ConnectPayload(clientID, null, auth);
IEnumerable <byte> encodedBytes = cp.Encode();
EncodedString encodedUsername =
new EncodedString(
new MemoryStream(
encodedBytes.Skip(clientID.Encode().Count()).ToArray()));
Assert.IsTrue(username == encodedUsername);
}
public void Will_msg_encoded_when_provided()
{
EncodedString clientID = new EncodedString("test 1");
EncodedString willTopic = new EncodedString("Will Topic");
EncodedDataField willMsg = new EncodedDataField(utf8.GetBytes("Will Message"));
Will w = new Will(QoSLevel.AtMostOnce, false, willTopic, willMsg);
IByteEncodable cp = new ConnectPayload(clientID, w);
IEnumerable <byte> encodedBytes = cp.Encode();
string encodedMsg = utf8.GetString(
new EncodedDataField(
encodedBytes.Skip(clientID.Length + 2)
.Skip(willTopic.Length + 4)
.ToArray()));
Assert.IsTrue(utf8.GetString(willMsg.Data.ToArray()) == encodedMsg);
}
/// <summary>
/// Parses the raw frame data.
/// </summary>
/// <param name="frameData">The raw frame data.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
protected override void ParseFrameData(byte[] frameData, ID3Versions version)
{
// "The URL is always encoded with ISO-8859-1." [ID3 Spec.]
// The description is encoded according to the Text Encoding field, but
// the URL is always ISO-8859-1. So, create one EncodedString dynamically
// (using the text encoding byte) and get the remainder back as byte[].
// Then pass this back through with the encoding specified as ISO-8859-1.
IList <EncodedString> strings = EncodedString.CreateStrings(frameData, 1,
delegate(byte[] leftoverBytes) {
byte[] urlBytes = leftoverBytes;
strings = EncodedString.CreateStrings(URLLinkFrame.UrlEncodingType, leftoverBytes);
base.EncodedUrl = strings[0];
});
description = strings[0];
SetEncodedStringSettings();
}
public void Will_topic_encoded_when_provided()
{
EncodedString willTopic = "Will Topic";
Will w =
new Will(
QoSLevel.AtMostOnce,
false, willTopic.Value,
new EncodedDataField(utf8.GetBytes("Will Message")));
EncodedString clientID = "test 1";
IByteEncodable cp = new ConnectPayload(clientID, w);
IEnumerable <byte> encodedBytes = cp.Encode();
EncodedString encodedTopic =
new EncodedString(
new MemoryStream(
encodedBytes.Skip(clientID.Encode().Count()).ToArray()));
Assert.IsTrue(willTopic == encodedTopic);
}
public void ExifEncodedStringTests(ExifTag tag)
{
foreach (object code in Enum.GetValues(typeof(EncodedString.CharacterCode)))
{
var charCode = (EncodedString.CharacterCode)code;
Assert.Equal(ExifEncodedStringHelpers.CharacterCodeBytesLength, ExifEncodedStringHelpers.GetCodeBytes(charCode).Length);
const string expectedText = "test string";
var expected = new EncodedString(charCode, expectedText);
ExifValue value = ExifValues.Create(tag);
Assert.False(value.TrySetValue(123));
Assert.True(value.TrySetValue(expected));
var typed = (ExifEncodedString)value;
Assert.Equal(expected, typed.Value);
Assert.Equal(expectedText, (string)typed.Value);
Assert.Equal(charCode, typed.Value.Code);
}
}
