CSHARP-788: Strengthen checks for nulls in CStrings.

Author: Robert Stam

MongoDB.Bson/IO/BsonBuffer.cs

@@ -554,6 +554,14 @@ public void WriteBytes(byte[] value)
         /// <param name="value">A string.</param>
         public void WriteCString(UTF8Encoding encoding, string value)
         {
+            if (value == null)
+            {
+                throw new ArgumentNullException("value");
+            }
+            if (value.IndexOf('\0') != -1)
+            {
+                throw new ArgumentException("CStrings cannot contain nulls.", "value");
+            }
             ThrowIfDisposed();
 
             var maxLength = encoding.GetMaxByteCount(value.Length) + 1;

MongoDB.Bson/IO/BsonWriter.cs

@@ -495,6 +495,14 @@ public void WriteMinKey(string name)
         /// <param name="name">The name of the element.</param>
         public virtual void WriteName(string name)
         {
+            if (name == null)
+            {
+                throw new ArgumentNullException("name");
+            }
+            if (name.IndexOf('\0') != -1)
+            {
+                throw new ArgumentException("Element names cannot contain nulls.", "name");
+            }
             if (_disposed) { throw new ObjectDisposedException(this.GetType().Name); }
             if (_state != BsonWriterState.Name)
             {

MongoDB.Bson/Serialization/BsonMemberMap.cs

@@ -374,6 +374,10 @@ public BsonMemberMap SetElementName(string elementName)
             {
                 throw new ArgumentNullException("elementName");
             }
+            if (elementName.IndexOf('\0') != -1)
+            {
+                throw new ArgumentException("Element names cannot contain nulls.", "elementName");
+            }
             if (_frozen) { ThrowFrozenException(); }
 
             _elementName = elementName;

MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs

@@ -39,6 +39,14 @@ public abstract class StandardDiscriminatorConvention : IDiscriminatorConvention
         /// <param name="elementName">The element name.</param>
         protected StandardDiscriminatorConvention(string elementName)
         {
+            if (elementName == null)
+            {
+                throw new ArgumentNullException("elementName");
+            }
+            if (elementName.IndexOf('\0') != -1)
+            {
+                throw new ArgumentException("Element names cannot contain nulls.", "elementName");
+            }
             _elementName = elementName;
         }
 

MongoDB.BsonUnitTests/IO/BsonBufferTests.cs

@@ -13,9 +13,11 @@
 * limitations under the License.
 */
 
+using System;
 using System.IO;
 using System.Text;
 using MongoDB.Bson;
+using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using NUnit.Framework;
 
@@ -127,5 +129,23 @@ public void TestReadStringTwoCharactersDecoderException()
             Assert.AreEqual(15, bytes.Length);
             var ex = Assert.Throws<DecoderFallbackException>(() => { BsonSerializer.Deserialize<BsonDocument>(bytes); });
         }
+
+        [Test]
+        public void TestWriteCStringThrowsWhenValueContainsNulls()
+        {
+            using (var bsonBuffer = new BsonBuffer())
+            {
+                Assert.Throws<ArgumentException>(() => { bsonBuffer.WriteCString((UTF8Encoding)Encoding.UTF8, "a\0b"); });
+            }
+        }
+
+        [Test]
+        public void TestWriteCStringThrowsWhenValueIsNull()
+        {
+            using (var bsonBuffer = new BsonBuffer())
+            {
+                Assert.Throws<ArgumentNullException>(() => { bsonBuffer.WriteCString((UTF8Encoding)Encoding.UTF8, null); });
+            }
+        }
     }
 }

MongoDB.BsonUnitTests/IO/BsonWriterTests.cs

@@ -0,0 +1,43 @@
+/* Copyright 2010-2013 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using MongoDB.Bson.IO;
+using NUnit.Framework;
+
+namespace MongoDB.BsonUnitTests.IO
+{
+    [TestFixture]
+    public class BsonWriterTests
+    {
+        [Test]
+        public void TestWriteNameThrowsWhenValueContainsNulls()
+        {
+            using (var bsonWriter = BsonWriter.Create(BsonBinaryWriterSettings.Defaults))
+            {
+                Assert.Throws<ArgumentException>(() => { bsonWriter.WriteName("a\0b"); });
+            }
+        }
+
+        [Test]
+        public void TestWriteNameThrowsWhenValueIsNull()
+        {
+            using (var bsonWriter = BsonWriter.Create(BsonBinaryWriterSettings.Defaults))
+            {
+                Assert.Throws<ArgumentNullException>(() => { bsonWriter.WriteName(null); });
+            }
+        }
+    }
+}

MongoDB.BsonUnitTests/MongoDB.BsonUnitTests.csproj

@@ -81,6 +81,7 @@
     </Compile>
     <Compile Include="BsonExtensionMethodsTests.cs" />
     <Compile Include="BsonUtilsTests.cs" />
+    <Compile Include="IO\BsonWriterTests.cs" />
     <Compile Include="IO\ByteArrayBufferTests.cs" />
     <Compile Include="IO\MultiChunkBufferTests.cs" />
     <Compile Include="Jira\CSharp728Tests.cs" />
@@ -118,6 +119,7 @@
     <Compile Include="Serialization\Conventions\NamedIdConventionsTests.cs" />
     <Compile Include="Serialization\Conventions\PropertyFinderConventionsTests.cs" />
     <Compile Include="Serialization\Conventions\ReadWriteMemberFinderConventionsTests.cs" />
+    <Compile Include="Serialization\Conventions\StandardDiscriminatorConventionTests.cs" />
     <Compile Include="Serialization\Conventions\StringObjectIdGeneratorConventionsTests.cs" />
     <Compile Include="Serialization\IdGenerators\AscendingGuidGeneratorTests.cs" />
     <Compile Include="Serialization\IdGenerators\CombGuidGeneratorTests.cs" />

MongoDB.BsonUnitTests/Serialization/BsonMemberMapTests.cs

@@ -13,6 +13,7 @@
 * limitations under the License.
 */
 
+using System;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.IdGenerators;
@@ -68,6 +69,22 @@ public void TestIsReadOnlyPropertyOfAField()
             Assert.IsFalse(memberMap.IsReadOnly);
         }
 
+        [Test]
+        public void TestSetElementNameThrowsWhenElementNameContainsNulls()
+        {
+            var classMap = new BsonClassMap<TestClass>(cm => cm.AutoMap());
+            var memberMap = classMap.GetMemberMap("Property");
+            Assert.Throws<ArgumentException>(() => { memberMap.SetElementName("a\0b"); });
+        }
+
+        [Test]
+        public void TestSetElementNameThrowsWhenElementNameIsNull()
+        {
+            var classMap = new BsonClassMap<TestClass>(cm => cm.AutoMap());
+            var memberMap = classMap.GetMemberMap("Property");
+            Assert.Throws<ArgumentNullException>(() => { memberMap.SetElementName(null); });
+        }
+
         [Test]
         public void TestSettingAField()
         {

MongoDB.BsonUnitTests/Serialization/Conventions/StandardDiscriminatorConventionTests.cs

@@ -0,0 +1,37 @@
+/* Copyright 2010-2013 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using MongoDB.Bson.Serialization.Conventions;
+using NUnit.Framework;
+
+namespace MongoDB.BsonUnitTests.Serialization.Conventions
+{
+    [TestFixture]
+    public class StandardDiscriminatorConventionTests
+    {
+        [Test]
+        public void TestConstructorThrowsWhenElementNameContainsNulls()
+        {
+            Assert.Throws<ArgumentException>(() => { var discriminatorConvention = new ScalarDiscriminatorConvention("a\0b"); });
+        }
+
+        [Test]
+        public void TestConstructorThrowsWhenElementNameIsNull()
+        {
+            Assert.Throws<ArgumentNullException>(() => { var discriminatorConvention = new ScalarDiscriminatorConvention(null); });
+        }
+    }
+}