SERVER-10699 Minor clean-up of NamespaceString.

3 files changed, 63 insertions, 36 deletions

diff --git a/src/mongo/db/namespace_string-inl.h b/src/mongo/db/namespace_string-inl.h
index 6ca88f8aa76..2883434d2c7 100644
--- a/src/mongo/db/namespace_string-inl.h
+++ b/src/mongo/db/namespace_string-inl.h
@@ -20,19 +20,19 @@
 namespace mongo {
 
     inline StringData NamespaceString::db() const {
-        return _dotIndex == string::npos ?
+        return _dotIndex == std::string::npos ?
             StringData() :
             StringData( _ns.c_str(), _dotIndex );
     }
 
     inline StringData NamespaceString::coll() const {
-        return _dotIndex == string::npos ?
+        return _dotIndex == std::string::npos ?
             StringData() :
             StringData( _ns.c_str() + _dotIndex + 1, _ns.size() - 1 - _dotIndex );
     }
 
     inline bool NamespaceString::normal(const StringData& ns) {
-        if ( ns.find( '$' ) == string::npos )
+        if ( ns.find( '$' ) == std::string::npos )
             return true;
         return oplog(ns);
     }
@@ -42,28 +42,42 @@ namespace mongo {
     }
 
     inline bool NamespaceString::special(const StringData& ns) {
-        return !normal(ns) || ns.find( ".system." ) != string::npos;
+        return !normal(ns) || ns.substr(ns.find('.')).startsWith(".system.");
     }
 
-    inline bool NamespaceString::validDBName( const StringData& dbin ) {
-        // XXX
-        string db = dbin.toString();
-
+    inline bool NamespaceString::validDBName( const StringData& db ) {
         if ( db.size() == 0 || db.size() > 64 )
             return false;
+
+        for (StringData::const_iterator iter = db.begin(), end = db.end(); iter != end; ++iter) {
+            switch (*iter) {
+            case '\0':
+            case '/':
+            case '\\':
+            case '.':
+            case ' ':
+            case '"':
+                return false;
 #ifdef _WIN32
-        // We prohibit all FAT32-disallowed characters on Windows
-        size_t good = strcspn( db.c_str() , "/\\. \"*<>:|?" );
-#else
-        // For non-Windows platforms we are much more lenient
-        size_t good = strcspn( db.c_str() , "/\\. \"" );
+            // We prohibit all FAT32-disallowed characters on Windows
+            case '*':
+            case '<':
+            case '>':
+            case ':':
+            case '|':
+            case '?':
+                return false;
 #endif
-        return good == db.size();
+            default:
+                continue;
+            }
+        }
+        return true;
     }
 
     inline bool NamespaceString::validCollectionName(const StringData& ns){
         size_t idx = ns.find( '.' );
-        if ( idx == string::npos )
+        if ( idx == std::string::npos )
             return false;
 
         if ( idx + 1 >= ns.size() )
@@ -72,12 +86,13 @@ namespace mongo {
         return normal( ns );
     }
 
+    inline NamespaceString::NamespaceString() : _ns(), _dotIndex(0) {}
     inline NamespaceString::NamespaceString( const StringData& nsIn ) {
         _ns = nsIn.toString(); // copy to our buffer
         _dotIndex = _ns.find( '.' );
     }
 
-    inline int nsDBHash( const string& ns ) {
+    inline int nsDBHash( const std::string& ns ) {
         int hash = 7;
         for ( size_t i = 0; i < ns.size(); i++ ) {
             if ( ns[i] == '.' )
@@ -88,7 +103,7 @@ namespace mongo {
         return hash;
     }
 
-    inline bool nsDBEquals( const string& a, const string& b ) {
+    inline bool nsDBEquals( const std::string& a, const std::string& b ) {
         for ( size_t i = 0; i < a.size(); i++ ) {
 
             if ( a[i] == '.' ) {
@@ -121,12 +136,12 @@ namespace mongo {
     }
 
     /* future : this doesn't need to be an inline. */
-    inline string NamespaceString::getSisterNS( const StringData& local ) const {
+    inline std::string NamespaceString::getSisterNS( const StringData& local ) const {
         verify( local.size() && local[0] != '.' );
         return db().toString() + "." + local.toString();
     }
 
-    inline string NamespaceString::getSystemIndexesCollection() const {
+    inline std::string NamespaceString::getSystemIndexesCollection() const {
         return db().toString() + ".system.indexes";
     }
 
diff --git a/src/mongo/db/namespace_string.h b/src/mongo/db/namespace_string.h
index 450be678e36..9e04ccb35b7 100644
--- a/src/mongo/db/namespace_string.h
+++ b/src/mongo/db/namespace_string.h
@@ -25,8 +25,6 @@
 
 namespace mongo {
 
-    using std::string;
-
     /* in the mongo source code, "client" means "database". */
 
     const size_t MaxDatabaseNameLen = 128; // max str len for the db name, including null char
@@ -37,15 +35,16 @@ namespace mongo {
     */
     class NamespaceString {
     public:
+        NamespaceString();
         NamespaceString( const StringData& ns );
 
         StringData db() const;
         StringData coll() const;
 
-        const string& ns() const { return _ns; }
+        const std::string& ns() const { return _ns; }
 
-        operator string() const { return _ns; }
-        string toString() const { return _ns; }
+        operator std::string() const { return _ns; }
+        std::string toString() const { return _ns; }
 
         size_t size() const { return _ns.size(); }
 
@@ -60,20 +59,20 @@ namespace mongo {
          */
         bool isValid() const { return validDBName( db() ) && !coll().empty(); }
 
-        bool operator==( const string& nsIn ) const { return nsIn == _ns; }
+        bool operator==( const std::string& nsIn ) const { return nsIn == _ns; }
         bool operator==( const NamespaceString& nsIn ) const { return nsIn._ns == _ns; }
 
-        bool operator!=( const string& nsIn ) const { return nsIn != _ns; }
+        bool operator!=( const std::string& nsIn ) const { return nsIn != _ns; }
         bool operator!=( const NamespaceString& nsIn ) const { return nsIn._ns != _ns; }
 
         bool operator<( const NamespaceString& rhs ) const { return _ns < rhs._ns; }
 
         /** ( foo.bar ).getSisterNS( "blah" ) == foo.blah
          */
-        string getSisterNS( const StringData& local ) const;
+        std::string getSisterNS( const StringData& local ) const;
 
         // @return db() + ".system.indexes"
-        string getSystemIndexesCollection() const;
+        std::string getSystemIndexesCollection() const;
 
         /**
          * @return true if ns is 'normal'.  A "$" is used for namespaces holding index data,
@@ -118,7 +117,7 @@ namespace mongo {
 
     private:
 
-        string _ns;
+        std::string _ns;
         size_t _dotIndex;
     };
 
@@ -126,7 +125,7 @@ namespace mongo {
     // "database.a.b.c" -> "database"
     inline StringData nsToDatabaseSubstring( const StringData& ns ) {
         size_t i = ns.find( '.' );
-        if ( i == string::npos ) {
+        if ( i == std::string::npos ) {
             massert(10078, "nsToDatabase: ns too long", ns.size() < MaxDatabaseNameLen );
             return ns;
         }
@@ -141,14 +140,14 @@ namespace mongo {
     }
 
     // TODO: make this return a StringData
-    inline string nsToDatabase(const StringData& ns) {
+    inline std::string nsToDatabase(const StringData& ns) {
         return nsToDatabaseSubstring( ns ).toString();
     }
 
     // "database.a.b.c" -> "a.b.c"
     inline StringData nsToCollectionSubstring( const StringData& ns ) {
         size_t i = ns.find( '.' );
-        massert(16886, "nsToCollectionSubstring: no .", i != string::npos );
+        massert(16886, "nsToCollectionSubstring: no .", i != std::string::npos );
         return ns.substr( i + 1 );
     }
 
@@ -163,18 +162,18 @@ namespace mongo {
     /**
      * this can change, do not store on disk
      */
-    int nsDBHash( const string& ns );
+    int nsDBHash( const std::string& ns );
 
-    bool nsDBEquals( const string& a, const string& b );
+    bool nsDBEquals( const std::string& a, const std::string& b );
 
     struct NamespaceDBHash {
-        int operator()( const string& ns ) const {
+        int operator()( const std::string& ns ) const {
             return nsDBHash( ns );
         }
     };
 
     struct NamespaceDBEquals {
-        bool operator()( const string& a, const string& b ) const {
+        bool operator()( const std::string& a, const std::string& b ) const {
             return nsDBEquals( a, b );
         }
     };
diff --git a/src/mongo/db/namespace_string_test.cpp b/src/mongo/db/namespace_string_test.cpp
index 7a9314c6cae..f361018e541 100644
--- a/src/mongo/db/namespace_string_test.cpp
+++ b/src/mongo/db/namespace_string_test.cpp
@@ -47,6 +47,8 @@ namespace mongo {
         ASSERT( NamespaceString::special( "a.$.b" ) );
         ASSERT( NamespaceString::special( "a.system.foo" ) );
         ASSERT( !NamespaceString::special( "a.foo" ) );
+        ASSERT( !NamespaceString::special( "a.foo.system.bar" ) );
+        ASSERT( !NamespaceString::special( "a.systemfoo" ) );
     }
 
     TEST( NamespaceStringTest, DatabaseValidNames ) {
@@ -54,6 +56,17 @@ namespace mongo {
         ASSERT( !NamespaceString::validDBName( "foo/bar" ) );
         ASSERT( !NamespaceString::validDBName( "foo bar" ) );
         ASSERT( !NamespaceString::validDBName( "foo.bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo.bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo\\bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo\"bar" ) );
+#ifdef _WIN32
+        ASSERT( !NamespaceString::validDBName( "foo*bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo<bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo>bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo:bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo|bar" ) );
+        ASSERT( !NamespaceString::validDBName( "foo?bar" ) );
+#endif
 
         ASSERT( NamespaceString::normal( "asdads" ) );
         ASSERT( !NamespaceString::normal( "asda$ds" ) );