Merge pull request #79 from progaudi/add-fixstr-length-evaluation

Add fixstr length evaluation to converter
progaudi · Sep 21, 2018 · 7cfad8f · 7cfad8f
2 parents 8a1bdf5 + d5f5b37
commit 7cfad8f
Show file tree

Hide file tree

Showing 6 changed files with 296 additions and 11 deletions.
diff --git a/.azure/publish.yml b/.azure/publish.yml
@@ -11,13 +11,14 @@ steps:
       versioningScheme: byEnvVar
       versionEnvVar: NugetPackageVersion
       arguments: -c Release /property:PackageOutputPath=$(Build.ArtifactStagingDirectory)
-  - task: NuGetCommand@2
-    displayName: push nuget packages
-    inputs:
-      command: push
-      packagesToPush: '$(Build.ArtifactStagingDirectory)/*.nupkg'
-      nuGetFeedType: external
-      publishFeedCredentials: api.nuget.org
+  - ${{ if ne(variables['Build.Reason'], 'PullRequest') }}:
+    - task: NuGetCommand@2
+      displayName: push nuget packages
+      inputs:
+        command: push
+        packagesToPush: '$(Build.ArtifactStagingDirectory)/*.nupkg'
+        nuGetFeedType: external
+        publishFeedCredentials: api.nuget.org
   - task: PublishBuildArtifacts@1
     inputs:
       pathtoPublish: '$(Build.ArtifactStagingDirectory)'

diff --git a/src/msgpack.light/Converters/BinaryConverter.cs b/src/msgpack.light/Converters/BinaryConverter.cs
@@ -4,8 +4,15 @@ namespace ProGaudi.MsgPack.Light.Converters
 {
     internal class BinaryConverter : IMsgPackConverter<byte[]>
     {
+        private readonly bool _compatibilityMode;
+
         private MsgPackContext _context;
 
+        public BinaryConverter(bool compatibilityMode)
+        {
+            _compatibilityMode = compatibilityMode;
+        }
+
         public void Initialize(MsgPackContext context)
         {
             _context = context;
@@ -19,7 +26,15 @@ public void Write(byte[] value, IMsgPackWriter writer)
                 return;
             }
 
-            WriteBinaryHeaderAndLength((uint)value.Length, writer);
+            var valueLength = (uint) value.Length;
+            if (_compatibilityMode)
+            {
+                WriteStringHeaderAndLength(valueLength, writer);
+            }
+            else
+            {
+                WriteBinaryHeaderAndLength(valueLength, writer);
+            }
 
             writer.Write(value);
         }
@@ -47,8 +62,40 @@ public byte[] Read(IMsgPackReader reader)
                     length = NumberConverter.ReadUInt32(reader);
                     break;
 
+                case DataTypes.Str8:
+                    if (_compatibilityMode)
+                        length = NumberConverter.ReadUInt8(reader);
+                    else
+                        throw ExceptionUtils.CantReadStringAsBinary();
+                    break;
+
+                case DataTypes.Str16:
+                    if (_compatibilityMode)
+                        length = NumberConverter.ReadUInt16(reader);
+                    else
+                        throw ExceptionUtils.CantReadStringAsBinary();
+                    break;
+
+                case DataTypes.Str32:
+                    if (_compatibilityMode)
+                        length = NumberConverter.ReadUInt32(reader);
+                    else
+                        throw ExceptionUtils.CantReadStringAsBinary();
+                    break;
+
                 default:
-                    throw ExceptionUtils.BadTypeException(type, DataTypes.Bin8, DataTypes.Bin16, DataTypes.Bin32, DataTypes.Null);
+                    if ((type & DataTypes.FixStr) == DataTypes.FixStr)
+                    {
+                        if (_compatibilityMode)
+                            length = (uint)(type & ~DataTypes.FixStr);
+                        else
+                            throw ExceptionUtils.CantReadStringAsBinary();
+                    }
+                    else
+                    {
+                        throw ExceptionUtils.BadTypeException(type, DataTypes.Bin8, DataTypes.Bin16, DataTypes.Bin32, DataTypes.Null);
+                    }
+                    break;
             }
 
             var segment = reader.ReadBytes(length);
@@ -75,5 +122,25 @@ private void WriteBinaryHeaderAndLength(uint length, IMsgPackWriter writer)
                 NumberConverter.WriteUIntValue(length, writer);
             }
         }
+
+        private void WriteStringHeaderAndLength(uint length, IMsgPackWriter writer)
+        {
+            if (length <= 31)
+            {
+                writer.Write((byte)(((byte)DataTypes.FixStr + length) % 256));
+                return;
+            }
+
+            if (length <= ushort.MaxValue)
+            {
+                writer.Write(DataTypes.Str16);
+                NumberConverter.WriteUShortValue((ushort)length, writer);
+            }
+            else
+            {
+                writer.Write(DataTypes.Str32);
+                NumberConverter.WriteUIntValue((uint)length, writer);
+            }
+        }
     }
 }
diff --git a/src/msgpack.light/ExceptionUtils.cs b/src/msgpack.light/ExceptionUtils.cs
@@ -14,6 +14,11 @@ public static Exception BadTypeException(DataTypes actual, params DataTypes[] ex
             return new SerializationException($"Got {actual:G} (0x{actual:X}), while expecting one of these: {String.Join(", ", expectedCodes)}");
         }
 
+        public static Exception CantReadStringAsBinary()
+        {
+            return new SerializationException($"Reading a string as a byte array is disabled. Set MsgPackContext.BinaryCompatibilityMode property to true to enable it");
+        }
+
         public static Exception NotEnoughBytes(uint actual, uint expected)
         {
             return new SerializationException($"Expected {expected} bytes, got {actual} bytes.");

diff --git a/src/msgpack.light/MsgPackContext.cs b/src/msgpack.light/MsgPackContext.cs
@@ -23,7 +23,7 @@ public class MsgPackContext
 
         private readonly Dictionary<Type, Func<object>> _objectActivators = new Dictionary<Type, Func<object>>();
 
-        public MsgPackContext(bool strictParseOfFloat = false, bool convertEnumsAsStrings = true)
+        public MsgPackContext(bool strictParseOfFloat = false, bool convertEnumsAsStrings = true, bool binaryCompatibilityMode = false)
         {
             _convertEnumsAsStrings = convertEnumsAsStrings;
             var numberConverter = new NumberConverter(strictParseOfFloat);
@@ -32,7 +32,7 @@ public MsgPackContext(bool strictParseOfFloat = false, bool convertEnumsAsString
                 {typeof(MsgPackToken), new MsgPackTokenConverter()},
                 {typeof (bool), new BoolConverter()},
                 {typeof (string), new StringConverter()},
-                {typeof (byte[]), new BinaryConverter()},
+                {typeof (byte[]), new BinaryConverter(binaryCompatibilityMode)},
                 {typeof (float), numberConverter},
                 {typeof (double), numberConverter},
                 {typeof (byte), numberConverter},

diff --git a/tests/msgpack.light.tests/Reader/Binary.cs b/tests/msgpack.light.tests/Reader/Binary.cs
@@ -1,3 +1,5 @@
+using System.Runtime.Serialization;
+
 using Shouldly;
 
 using Xunit;
@@ -88,5 +90,133 @@ public void Test(byte[] value, byte[] data)
             var token = Helpers.CheckTokenDeserialization(data);
             ((byte[])token).ShouldBe(value);
         }
+
+        [Theory]
+        [InlineData(new byte[] {160})]
+        [InlineData(new byte[] {161, 1})]
+        [InlineData(new byte[]
+        {
+            218, 1, 44,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+        })]
+        public void FailToReadOldBinary(byte[] data)
+        {
+            var e = Should.Throw<SerializationException>(() => MsgPackSerializer.Deserialize<byte[]>(data));
+            e.Message.ShouldBe("Reading a string as a byte array is disabled. Set MsgPackContext.BinaryCompatibilityMode property to true to enable it");
+        }
+
+        [Theory]
+        [InlineData(new byte[0], new byte[] {160})]
+        [InlineData(new byte[] {1}, new byte[] {161, 1})]
+        [InlineData(new byte[]
+        {
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+        },
+            new byte[]
+        {
+            218, 1, 44,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+        })]
+        public void ReadOldBinary(byte[] value, byte[] data)
+        {
+            var context = new MsgPackContext(binaryCompatibilityMode: true);
+            var result = Should.NotThrow(() => MsgPackSerializer.Deserialize<byte[]>(data, context));
+            result.ShouldBe(value);
+        }
     }
 }
diff --git a/tests/msgpack.light.tests/Writer/Binary.cs b/tests/msgpack.light.tests/Writer/Binary.cs
@@ -87,5 +87,87 @@ public void Test(byte[] value, byte[] data)
 
             ((MsgPackToken)value).RawBytes.ShouldBe(data);
         }
+
+        [Theory]
+        [InlineData(new byte[0], new byte[] {160})]
+        [InlineData(new byte[] {1}, new byte[] {161, 1})]
+        [InlineData(new byte[]
+        {
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+        },
+            new byte[]
+        {
+            218, 1, 44,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+        })]
+        public void WriteOldBinary(byte[] value, byte[] data)
+        {
+            var context = new MsgPackContext(binaryCompatibilityMode: true);
+            var result = Should.NotThrow(() => MsgPackSerializer.Serialize(value, context));
+            result.ShouldBe(data);
+        }
     }
 }