Check for subject and queue name validity

NATS.Client/Conn.cs

@@ -3238,9 +3238,13 @@ private void disableSubChannelPooling()
         internal AsyncSubscription subscribeAsync(string subject, string queue,
             EventHandler<MsgHandlerEventArgs> handler)
         {
-            if (string.IsNullOrWhiteSpace(subject))
+            if (!Subscription.IsValidSubject(subject))
             {
-                throw new NATSBadSubscriptionException();
+                throw new NATSBadSubscriptionException("Invalid subject.");
+            }
+            if (queue != null && !Subscription.IsValidQueueGroupName(queue))
+            {
+                throw new NATSBadSubscriptionException("Invalid queue group name.");
             }
 
             AsyncSubscription s = null;
@@ -3272,9 +3276,13 @@ internal AsyncSubscription subscribeAsync(string subject, string queue,
         // function that indicates interest in a subject.
         private SyncSubscription subscribeSync(string subject, string queue)
         {
-            if (string.IsNullOrWhiteSpace(subject))
+            if (!Subscription.IsValidSubject(subject))
             {
-                throw new NATSBadSubscriptionException();
+                throw new NATSBadSubscriptionException("Invalid subject.");
+            }
+            if (queue != null && !Subscription.IsValidQueueGroupName(queue))
+            {
+                throw new NATSBadSubscriptionException("Invalid queue group name.");
             }
 
             SyncSubscription s = null;

NATS.Client/Exceptions.cs

@@ -122,7 +122,8 @@ internal NATSMaxMessagesException() : base("Maximum number of messages have been
     /// </summary>
     public class NATSBadSubscriptionException : NATSException
     {
-        internal NATSBadSubscriptionException() : base("Subcription is not valid.") { }
+        internal NATSBadSubscriptionException() : base("Subscription is not valid.") { }
+        internal NATSBadSubscriptionException(string s) : base("s") { }
     }
 
     /// <summary>

NATS.Client/Subscription.cs

@@ -648,6 +648,50 @@ public long Dropped
             }
         }
 
+        #region validation
+
+        static private readonly char[] invalidSubjectChars = { '\r', '\n', '\t', ' '};
+
+        private static bool IsValidTokenOrQName(string value)
+        {
+            return (!string.IsNullOrEmpty(value) && value.LastIndexOfAny(invalidSubjectChars) < 0);
+        }
+
+        /// <summary>
+        /// Checks if a subject is valid.
+        /// </summary>
+        /// <param name="subject">The subject to check</param>
+        /// <returns>true if valid, false otherwise.</returns>
+        static public bool IsValidSubject(string subject)
+        {
+            if (!IsValidTokenOrQName(subject))
+            {
+                return false;
+            }
+
+            string[] tokens = subject.Split('.');
+            foreach (string t in tokens)
+            {
+                if (t.Length == 0)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Checks if the queue group name is valid.
+        /// </summary>
+        /// <param name="queueGroup"></param>
+        /// <returns>true is the queue group name is valid, false otherwise.</returns>
+        static public bool IsValidQueueGroupName(string queueGroup)
+        {
+            return IsValidTokenOrQName(queueGroup);
+        }
+
+        #endregion
+
     }  // Subscription
 
 }

NATSUnitTests/UnitTestSub.cs

@@ -182,8 +182,8 @@ public void TestSlowSubscriber()
                             }
                             catch (Exception)
                             {
-                            // ignore
-                        }
+                                // ignore
+                            }
 
                             s.NextMessage();
                         });
@@ -282,12 +282,12 @@ public void TestAsyncErrHandler()
                                 Assert.True(args.Subscription == s);
                                 Assert.Contains("Slow", args.Error);
 
-                            // release the subscriber
-                            Monitor.Pulse(subLock);
+                                // release the subscriber
+                                Monitor.Pulse(subLock);
                             }
 
-                        // release the test
-                        lock (testLock) { Monitor.Pulse(testLock); }
+                            // release the test
+                            lock (testLock) { Monitor.Pulse(testLock); }
                         };
 
                         bool blockedOnSubscriber = false;
@@ -332,7 +332,7 @@ public void TestAsyncErrHandler()
         [Fact]
         public void TestAsyncSubscriberStarvation()
         {
-           AutoResetEvent ev = new AutoResetEvent(false);
+            AutoResetEvent ev = new AutoResetEvent(false);
 
             using (new NATSServer())
             {
@@ -894,7 +894,7 @@ public void TestSubDelTaskCountReconnect()
 
             var opts = utils.DefaultTestOptions;
             opts.SubscriberDeliveryTaskCount = 2;
-            opts.DisconnectedEventHandler = (obj, args) => { disconnected = true;};
+            opts.DisconnectedEventHandler = (obj, args) => { disconnected = true; };
             opts.ReconnectedEventHandler = (obj, args) => { reconnectEv.Set(); };
 
             using (var server = new NATSServer())
@@ -992,6 +992,54 @@ public void TestSubDelTaskCountWithSyncSub()
                 }
             }
         }
-	}
+
+        static readonly string[] invalidSubjects = { "foo bar", "foo..bar", ".foo", "bar.baz.", "baz\t.foo" };
+        static readonly string[] invalidQNames = { "foo group", "group\t1", "g1\r\n2" };
+
+        [Fact]
+        public void TestSubscriptionValidationAPI()
+        {
+            Assert.True(Subscription.IsValidSubject("foo"));
+            Assert.True(Subscription.IsValidSubject("foo.bar"));
+
+            foreach (string s in invalidSubjects)
+            {
+                Assert.False(Subscription.IsValidSubject(s));
+            }
+
+            foreach (string s in invalidQNames)
+            {
+                Assert.False(Subscription.IsValidQueueGroupName(s));
+            }
+        }
+
+        [Fact]
+        public void TestInvalidSubjects()
+        {
+            EventHandler<MsgHandlerEventArgs> mh = (obj, args) => { /* NOOP */ };
+            using (new NATSServer())
+            {
+                var c = utils.DefaultTestConnection;
+
+                foreach (string s in invalidSubjects)
+                {
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeSync(s));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeSync(s, "qgroup"));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync(s));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync(s, mh));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync(s, "qgroup"));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync(s, "qgroup", mh));
+                }
+
+                foreach (string s in invalidQNames)
+                {
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeSync("subject", s));
+
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync("subject", s));
+                    Assert.Throws<NATSBadSubscriptionException>(() => c.SubscribeAsync("subject", s, mh));
+                }
+            }
+        }
+    }
 }