From dfcc4c7408626434fd766da468c1d1d1e5fc76bd Mon Sep 17 00:00:00 2001 From: Mike Cremer <8211507+MCPC10@users.noreply.github.com> Date: Sun, 24 Jan 2021 12:16:32 +0100 Subject: [PATCH 1/3] Added WString support --- S7.Net.UnitTest/TypeTests/S7StringTests.cs | 2 +- S7.Net.UnitTest/TypeTests/S7WStringTests.cs | 134 ++++++++++++++++++++ S7.Net/Enums.cs | 5 + S7.Net/PLCHelpers.cs | 2 + S7.Net/Protocol/Serialization.cs | 16 ++- S7.Net/Types/S7String.cs | 4 +- S7.Net/Types/S7WString.cs | 72 +++++++++++ 7 files changed, 226 insertions(+), 9 deletions(-) create mode 100644 S7.Net.UnitTest/TypeTests/S7WStringTests.cs create mode 100644 S7.Net/Types/S7WString.cs diff --git a/S7.Net.UnitTest/TypeTests/S7StringTests.cs b/S7.Net.UnitTest/TypeTests/S7StringTests.cs index 0bc8ef9..e1cdc91 100644 --- a/S7.Net.UnitTest/TypeTests/S7StringTests.cs +++ b/S7.Net.UnitTest/TypeTests/S7StringTests.cs @@ -100,7 +100,7 @@ namespace S7.Net.UnitTest.TypeTests } [TestMethod] - public void WriteAbcWithStringLargetThanReservedLength() + public void WriteAbcWithStringLargerThanReservedLength() { Assert.ThrowsException(() => S7String.ToByteArray("Abc", 2)); } diff --git a/S7.Net.UnitTest/TypeTests/S7WStringTests.cs b/S7.Net.UnitTest/TypeTests/S7WStringTests.cs new file mode 100644 index 0000000..877777c --- /dev/null +++ b/S7.Net.UnitTest/TypeTests/S7WStringTests.cs @@ -0,0 +1,134 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using S7.Net.Types; +using System; + +namespace S7.Net.UnitTest.TypeTests +{ + [TestClass] + public class S7WStringTests + { + [TestMethod] + public void ReadEmptyStringWithZeroLength() + { + AssertFromByteArrayEquals("", 0, 0 , 0, 0); + } + + [TestMethod] + public void ReadEmptyStringWithOneCharLength() + { + AssertFromByteArrayEquals("", 0, 1, 0, 0, 0, 0); + } + + [TestMethod] + public void ReadEmptyStringWithOneCharGarbage() + { + + AssertFromByteArrayEquals("", 0, 1, 0, 0, 0x00, 0x41); + } + + [TestMethod] + public void ReadMalformedStringTooShort() + { + Assert.ThrowsException(() => AssertFromByteArrayEquals("", 0, 1)); + } + + [TestMethod] + public void ReadMalformedStringSizeLargerThanCapacity() + { + Assert.ThrowsException(() => S7WString.FromByteArray(new byte[] { 0, 3, 0, 5, 0, 0x00, 0x41, 0x00, 0x41, 0x00, 0x41})); + } + + [TestMethod] + public void ReadMalformedStringCapacityTooLarge() + { + Assert.ThrowsException(() => AssertToByteArrayAndBackEquals("", 20000, 0)); + } + + [TestMethod] + public void ReadA() + { + AssertFromByteArrayEquals("A", 0, 1, 0, 1, 0x00, 0x41); + } + + [TestMethod] + public void ReadAbc() + { + AssertFromByteArrayEquals("Abc", 0, 3, 0, 3, 0x00, 0x41, 0x00, 0x62, 0x00, 0x63); + } + + [TestMethod] + public void WriteNullWithReservedLengthZero() + { + Assert.ThrowsException(() => AssertToByteArrayAndBackEquals(null, 0, 0, 0, 0, 0)); + } + + [TestMethod] + public void WriteEmptyStringWithReservedLengthZero() + { + AssertToByteArrayAndBackEquals("", 0, 0, 0, 0, 0); + } + + [TestMethod] + public void WriteAWithReservedLengthZero() + { + AssertToByteArrayAndBackEquals("", 0, 0, 0, 0, 0); + } + + [TestMethod] + public void WriteNullWithReservedLengthOne() + { + Assert.ThrowsException(() => AssertToByteArrayAndBackEquals(null, 1, 0, 1 , 0, 0)); + } + + [TestMethod] + public void WriteEmptyStringWithReservedLengthOne() + { + AssertToByteArrayAndBackEquals("", 1, 0, 1, 0, 0, 0, 0); + } + + [TestMethod] + public void WriteAWithReservedLengthOne() + { + AssertToByteArrayAndBackEquals("A", 1, 0, 1, 0, 1, 0x00, 0x41); + } + + [TestMethod] + public void WriteAWithReservedLengthTwo() + { + AssertToByteArrayAndBackEquals("A", 2, 0, 2, 0, 1, 0x00, 0x41, 0, 0); + } + + [TestMethod] + public void WriteAbcWithStringLargerThanReservedLength() + { + Assert.ThrowsException(() => S7WString.ToByteArray("Abc", 2)); + } + + [TestMethod] + public void WriteAbcWithReservedLengthThree() + { + AssertToByteArrayAndBackEquals("Abc", 3, 0, 3, 0, 3, 0x00, 0x41, 0x00, 0x62, 0x00, 0x63); + } + + [TestMethod] + public void WriteAbcWithReservedLengthFour() + { + AssertToByteArrayAndBackEquals("Abc", 4, 0, 4, 0, 3, 0x00, 0x41, 0x00, 0x62, 0x00, 0x63, 0 , 0); + } + + private static void AssertFromByteArrayEquals(string expected, params byte[] bytes) + { + var convertedString = S7WString.FromByteArray(bytes); + Assert.AreEqual(expected, convertedString); + } + + + private static void AssertToByteArrayAndBackEquals(string value, int reservedLength, params byte[] expected) + { + var convertedData = S7WString.ToByteArray(value, reservedLength); + CollectionAssert.AreEqual(expected, convertedData); + var convertedBack = S7WString.FromByteArray(convertedData); + Assert.AreEqual(value, convertedBack); + } + } +} diff --git a/S7.Net/Enums.cs b/S7.Net/Enums.cs index c523ad7..436d94b 100644 --- a/S7.Net/Enums.cs +++ b/S7.Net/Enums.cs @@ -178,6 +178,11 @@ /// S7String, + /// + /// S7 WString variable type (variable) + /// + S7WString, + /// /// Timer variable type /// diff --git a/S7.Net/PLCHelpers.cs b/S7.Net/PLCHelpers.cs index 1668e08..4c4f8ac 100644 --- a/S7.Net/PLCHelpers.cs +++ b/S7.Net/PLCHelpers.cs @@ -125,6 +125,8 @@ namespace S7.Net return Types.String.FromByteArray(bytes); case VarType.S7String: return S7String.FromByteArray(bytes); + case VarType.S7WString: + return S7WString.FromByteArray(bytes); case VarType.Timer: if (varCount == 1) diff --git a/S7.Net/Protocol/Serialization.cs b/S7.Net/Protocol/Serialization.cs index ceecaa6..3d114b6 100644 --- a/S7.Net/Protocol/Serialization.cs +++ b/S7.Net/Protocol/Serialization.cs @@ -17,10 +17,14 @@ namespace S7.Net.Protocol { throw new Exception($"DataItem.Value is null, cannot serialize. StartAddr={dataItem.StartByteAdr} VarType={dataItem.VarType}"); } + if (dataItem.Value is string s) - return dataItem.VarType == VarType.S7String - ? S7String.ToByteArray(s, dataItem.Count) - : Types.String.ToByteArray(s, dataItem.Count); + return dataItem.VarType switch + { + VarType.S7String => S7String.ToByteArray(s, dataItem.Count), + VarType.S7WString => S7WString.ToByteArray(s, dataItem.Count), + _ => Types.String.ToByteArray(s, dataItem.Count) + }; return SerializeValue(dataItem.Value); } @@ -46,7 +50,7 @@ namespace S7.Net.Protocol case "Double": return Types.LReal.ToByteArray((double)value); case "DateTime": - return Types.DateTime.ToByteArray((System.DateTime) value); + return Types.DateTime.ToByteArray((System.DateTime)value); case "Byte[]": return (byte[])value; case "Int16[]": @@ -64,10 +68,10 @@ namespace S7.Net.Protocol case "String": // Hack: This is backwards compatible with the old code, but functionally it's broken // if the consumer does not pay attention to string length. - var stringVal = (string) value; + var stringVal = (string)value; return Types.String.ToByteArray(stringVal, stringVal.Length); case "DateTime[]": - return Types.DateTime.ToByteArray((System.DateTime[]) value); + return Types.DateTime.ToByteArray((System.DateTime[])value); case "DateTimeLong[]": return Types.DateTimeLong.ToByteArray((System.DateTime[])value); default: diff --git a/S7.Net/Types/S7String.cs b/S7.Net/Types/S7String.cs index 6210e53..11554d7 100644 --- a/S7.Net/Types/S7String.cs +++ b/S7.Net/Types/S7String.cs @@ -45,7 +45,7 @@ namespace S7.Net.Types /// Converts a to S7 string with 2-byte header. /// /// The string to convert to byte array. - /// The length (in bytes) allocated in PLC for string excluding header. + /// The length (in characters) allocated in PLC for the string. /// A containing the string header and string value with a maximum length of + 2. public static byte[] ToByteArray(string value, int reservedLength) { @@ -54,7 +54,7 @@ namespace S7.Net.Types throw new ArgumentNullException(nameof(value)); } - if (reservedLength > byte.MaxValue) throw new ArgumentException($"The maximum string length supported is {byte.MaxValue}."); + if (reservedLength >= byte.MaxValue) throw new ArgumentException($"The maximum string length supported is {byte.MaxValue}."); var bytes = Encoding.ASCII.GetBytes(value); if (bytes.Length > reservedLength) throw new ArgumentException($"The provided string length ({bytes.Length} is larger than the specified reserved length ({reservedLength})."); diff --git a/S7.Net/Types/S7WString.cs b/S7.Net/Types/S7WString.cs new file mode 100644 index 0000000..c310870 --- /dev/null +++ b/S7.Net/Types/S7WString.cs @@ -0,0 +1,72 @@ +using System; +using System.Text; + +namespace S7.Net.Types +{ + /// + /// Contains the methods to convert from S7 wstrings to C# strings + /// An S7 WString has a preceding 4 byte header containing its capacity and length + /// + public static class S7WString + { + /// + /// Converts S7 bytes to a string + /// + /// + /// + public static string FromByteArray(byte[] bytes) + { + if (bytes.Length < 4) + { + throw new PlcException(ErrorCode.ReadData, "Malformed S7 WString / too short"); + } + + int size = ((bytes[0] << 8) & 0xFF) | (bytes[1] & 0xFF); + int length = ((bytes[2] << 8) & 0xFF) | (bytes[3] & 0xFF); + + if (length > size) + { + throw new PlcException(ErrorCode.ReadData, "Malformed S7 WString / length larger than capacity"); + } + + try + { + return Encoding.BigEndianUnicode.GetString(bytes, 4, length * 2); + } + catch (Exception e) + { + throw new PlcException(ErrorCode.ReadData, + $"Failed to parse {VarType.S7WString} from data. Following fields were read: size: '{size}', actual length: '{length}', total number of bytes (including header): '{bytes.Length}'.", + e); + } + + } + + /// + /// Converts a to S7 wstring with 4-byte header. + /// + /// The string to convert to byte array. + /// The length (in characters) allocated in PLC for the string. + /// A containing the string header and string value with a maximum length of + 4. + public static byte[] ToByteArray(string value, int reservedLength) + { + if (value is null) + { + throw new ArgumentNullException(nameof(value)); + } + + if (reservedLength > 16382) throw new ArgumentException("The maximum string length supported is 16382."); + + var buffer = new byte[4 + reservedLength * 2]; + buffer[0] = (byte)((reservedLength >> 8) & 0xFF); + buffer[1] = (byte)(reservedLength & 0xFF); + buffer[2] = (byte)((value.Length >> 8) & 0xFF); + buffer[3] = (byte)(value.Length & 0xFF); + + var stringLength = Encoding.BigEndianUnicode.GetBytes(value, 0, value.Length, buffer, 4) / 2; + if (stringLength > reservedLength) throw new ArgumentException($"The provided string length ({stringLength} is larger than the specified reserved length ({reservedLength})."); + + return buffer; + } + } +} From 9b89acfb91edc1b229eff06286fd43885027ac83 Mon Sep 17 00:00:00 2001 From: Mike Cremer <8211507+MCPC10@users.noreply.github.com> Date: Mon, 25 Jan 2021 21:42:08 +0100 Subject: [PATCH 2/3] Removed unnecessary bitwise and's --- S7.Net/Types/S7WString.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/S7.Net/Types/S7WString.cs b/S7.Net/Types/S7WString.cs index c310870..8d8aabf 100644 --- a/S7.Net/Types/S7WString.cs +++ b/S7.Net/Types/S7WString.cs @@ -21,8 +21,8 @@ namespace S7.Net.Types throw new PlcException(ErrorCode.ReadData, "Malformed S7 WString / too short"); } - int size = ((bytes[0] << 8) & 0xFF) | (bytes[1] & 0xFF); - int length = ((bytes[2] << 8) & 0xFF) | (bytes[3] & 0xFF); + int size = (bytes[0] << 8) | bytes[1]; + int length = (bytes[2] << 8) | bytes[3]; if (length > size) { From 926d74f1d227802e2e4b1a777d5c22305662ef19 Mon Sep 17 00:00:00 2001 From: Mike Cremer <8211507+MCPC10@users.noreply.github.com> Date: Wed, 27 Jan 2021 17:55:16 +0100 Subject: [PATCH 3/3] Fixed length check and corresponding message for S7String --- S7.Net/Types/S7String.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/S7.Net/Types/S7String.cs b/S7.Net/Types/S7String.cs index 11554d7..5bc383e 100644 --- a/S7.Net/Types/S7String.cs +++ b/S7.Net/Types/S7String.cs @@ -54,7 +54,7 @@ namespace S7.Net.Types throw new ArgumentNullException(nameof(value)); } - if (reservedLength >= byte.MaxValue) throw new ArgumentException($"The maximum string length supported is {byte.MaxValue}."); + if (reservedLength > 254) throw new ArgumentException($"The maximum string length supported is 254."); var bytes = Encoding.ASCII.GetBytes(value); if (bytes.Length > reservedLength) throw new ArgumentException($"The provided string length ({bytes.Length} is larger than the specified reserved length ({reservedLength}).");