Check bad subjects and queues on subscribe, fixes #84

Signed-off-by: Derek Collison <derek@nats.io>

nats.go

@@ -80,6 +80,7 @@ var (
 	ErrBadSubscription        = errors.New("nats: invalid subscription")
 	ErrTypeSubscription       = errors.New("nats: invalid subscription type")
 	ErrBadSubject             = errors.New("nats: invalid subject")
+	ErrBadQueueName           = errors.New("nats: invalid queue name")
 	ErrSlowConsumer           = errors.New("nats: slow consumer, messages dropped")
 	ErrTimeout                = errors.New("nats: timeout")
 	ErrBadTimeout             = errors.New("nats: timeout invalid")
@@ -2824,11 +2825,37 @@ func (nc *Conn) QueueSubscribeSyncWithChan(subj, queue string, ch chan *Msg) (*S
 	return nc.subscribe(subj, queue, nil, ch, false)
 }
 
+// badSubject will do quick test on whether a subject is acceptable.
+// Spaces are not allowed and all tokens should be > 0 in len.
+func badSubject(subj string) bool {
+	if strings.ContainsAny(subj, " \t\r\n") {
+		return true
+	}
+	tokens := strings.Split(subj, ".")
+	for _, t := range tokens {
+		if len(t) == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// badQueue will check a queue name for whitespace.
+func badQueue(qname string) bool {
+	return strings.ContainsAny(qname, " \t\r\n")
+}
+
 // subscribe is the internal subscribe function that indicates interest in a subject.
 func (nc *Conn) subscribe(subj, queue string, cb MsgHandler, ch chan *Msg, isSync bool) (*Subscription, error) {
 	if nc == nil {
 		return nil, ErrInvalidConnection
 	}
+	if badSubject(subj) {
+		return nil, ErrBadSubject
+	}
+	if queue != "" && badQueue(queue) {
+		return nil, ErrBadQueueName
+	}
 	nc.mu.Lock()
 	// ok here, but defer is generally expensive
 	defer nc.mu.Unlock()

nats_test.go

@@ -1750,6 +1750,33 @@ func TestSubscribeSyncRace(t *testing.T) {
 	}
 }
 
+func TestBadSubjectsAndQueueNames(t *testing.T) {
+	s := RunServerOnPort(TEST_PORT)
+	defer s.Shutdown()
+
+	nc, err := Connect(fmt.Sprintf("127.0.0.1:%d", TEST_PORT))
+	if err != nil {
+		t.Fatalf("Error connecting: %v", err)
+	}
+	defer nc.Close()
+
+	// Make sure we get errors on bad subjects (spaces, etc)
+	// We want the client to protect the user.
+	badSubs := []string{"foo bar", "foo..bar", ".foo", "bar.baz.", "baz\t.foo"}
+	for _, subj := range badSubs {
+		if _, err := nc.SubscribeSync(subj); err != ErrBadSubject {
+			t.Fatalf("Expected an error of ErrBadSubject for %q, got %v", subj, err)
+		}
+	}
+
+	badQueues := []string{"foo group", "group\t1", "g1\r\n2"}
+	for _, q := range badQueues {
+		if _, err := nc.QueueSubscribeSync("foo", q); err != ErrBadQueueName {
+			t.Fatalf("Expected an error of ErrBadQueueName for %q, got %v", q, err)
+		}
+	}
+}
+
 func BenchmarkNextMsgNoTimeout(b *testing.B) {
 	s := RunServerOnPort(TEST_PORT)
 	defer s.Shutdown()