CXX-274 Backport server r2.6.3..r2.6.4 changes

Author: acmorrow

SConstruct

@@ -223,6 +223,7 @@ add_option( "no-glibc-check" , "don't check for new versions of glibc" , 0 , Fal
 add_option( "mm", "use main memory instead of memory mapped files" , 0 , True )
 add_option( "asio" , "Use Asynchronous IO (NOT READY YET)" , 0 , True )
 add_option( "ssl" , "Enable SSL" , 0 , True )
+add_option( "ssl-fips-capability", "Enable the ability to activate FIPS 140-2 mode", 0, True );
 
 # library choices
 add_option( "usev8" , "use v8 for javascript" , 0 , True )
@@ -909,6 +910,8 @@ if has_option( "ssl" ):
     else:
         env.Append( LIBS=["ssl"] )
         env.Append( LIBS=["crypto"] )
+    if has_option("ssl-fips-capability"):
+        env.Append( CPPDEFINES=["MONGO_SSL_FIPS"] )
 
 try:
     umask = os.umask(022)

src/SConscript.client

@@ -207,6 +207,7 @@ clientHeaders = [
     'mongo/platform/float_utils.h',
     'mongo/platform/hash_namespace.h',
     'mongo/platform/process_id.h',
+    'mongo/platform/random.h',
     'mongo/platform/unordered_map.h',
     'mongo/platform/windows_basic.h',
     'mongo/util/allocator.h',

src/mongo/SConscript

@@ -40,6 +40,7 @@ unittests = [
     'client/dbclient_rs_test',
     'client/scoped_db_conn_test',
     'client/replica_set_monitor_test',
+    'db/dbmessage_test',
     'dbtests/jsobjtests',
     'dbtests/jsontests',
     'dbtests/mock_dbclient_conn_test',

src/mongo/base/error_codes.err

@@ -85,6 +85,8 @@ error_code("NoProgressMade", 82)
 error_code("RemoteResultsUnavailable", 83)
 error_code("IndexOptionsConflict", 85 )
 error_code("IndexKeySpecsConflict", 86 )
+error_code("OutdatedClient", 101)
+error_code("IncompatibleAuditMetadata", 102)
 
 # Non-sequential error codes (for compatibility only)
 error_code("NetworkTimeout", 89)

src/mongo/bson/bson-inl.h

@@ -737,11 +737,16 @@ namespace mongo {
             s << __oid() << "')";
             break;
         case BinData:
-            s << "BinData";
-            if (full) {
+            s << "BinData(" << binDataType() << ", ";
+            {
                 int len;
-                const char* data = binDataClean(len);
-                s << '(' << binDataType() << ", " << toHex(data, len) << ')';
+                const char *data = binDataClean(len);
+                if ( !full && len > 80 ) {
+                    s << toHex(data, 70) << "...)";
+                }
+                else {
+                    s << toHex(data, len) << ")";
+                }
             }
             break;
         case Timestamp:

src/mongo/client/dbclient.cpp

@@ -546,7 +546,25 @@ namespace mongo {
         return mongo::createPasswordDigest(username, clearTextPassword);
     }
 
+    namespace {
+        class RunCommandHookOverrideGuard {
+            MONGO_DISALLOW_COPYING(RunCommandHookOverrideGuard);
+        public:
+            RunCommandHookOverrideGuard(DBClientWithCommands* cli,
+                                        const DBClientWithCommands::RunCommandHookFunc& hookFunc)
+                : _cli(cli), _oldHookFunc(cli->getRunCommandHook()) {
+                cli->setRunCommandHook(hookFunc);
+            }
+            ~RunCommandHookOverrideGuard() {
+                _cli->setRunCommandHook(_oldHookFunc);
+            }
+        private:
+            DBClientWithCommands* const _cli;
+            DBClientWithCommands::RunCommandHookFunc const _oldHookFunc;
+        };
+    }  // namespace
     void DBClientWithCommands::_auth(const BSONObj& params) {
+        RunCommandHookOverrideGuard hookGuard(this, RunCommandHookFunc());
         std::string mechanism;
 
         uassertStatusOK(bsonExtractStringField(params,

src/mongo/client/dbclient_rs.cpp

@@ -144,9 +144,15 @@ namespace {
     // --------------------------------
 
     const size_t DBClientReplicaSet::MAX_RETRY = 3;
-
-    DBClientReplicaSet::DBClientReplicaSet( const string& name , const vector<HostAndPort>& servers, double so_timeout )
-        : _setName( name ), _so_timeout( so_timeout ) {
+    int DBClientReplicaSet::reevaluatePercentage = 0;
+
+    DBClientReplicaSet::DBClientReplicaSet(
+            const string& name,
+            const vector<HostAndPort>& servers,
+            double so_timeout):
+                _setName(name),
+                _so_timeout(so_timeout),
+                _nodeSelectOracle(static_cast<int64_t>(time(0))) {
         ReplicaSetMonitor::createIfNeeded( name, set<HostAndPort>(servers.begin(), servers.end()) );
     }
 
@@ -647,7 +653,7 @@ namespace {
 
     DBClientConnection* DBClientReplicaSet::selectNodeUsingTags(
             shared_ptr<ReadPreferenceSetting> readPref) {
-        if (checkLastHost(readPref.get())) {
+        if (!shouldReevaluate() && checkLastHost(readPref.get())) {
 
             LOG( 3 ) << "dbclient_rs selecting compatible last used node " << _lastSlaveOkHost
                                 << endl;
@@ -973,6 +979,14 @@ namespace {
         _lastSlaveOkConn.reset();
     }
 
+    bool DBClientReplicaSet::shouldReevaluate() {
+        if (_nodeSelectOracle.nextInt32(100) < reevaluatePercentage) {
+            return true;
+        }
+
+        return false;
+    }
+
     // trying to optimize for the common dont-care-about-tags case.
     static const BSONArray tagsMatchesAll = BSON_ARRAY(BSONObj());
     TagSet::TagSet() : _tags(tagsMatchesAll) {}

src/mongo/client/dbclient_rs.h

@@ -22,6 +22,7 @@
 
 #include "mongo/client/dbclientinterface.h"
 #include "mongo/client/export_macros.h"
+#include "mongo/platform/random.h"
 #include "mongo/util/net/hostandport.h"
 
 namespace mongo {
@@ -45,6 +46,12 @@ namespace mongo {
         using DBClientBase::update;
         using DBClientBase::remove;
 
+        // For internal use only. The desired probability for reevaluating node
+        // selection given a read preference, expressed in percentage. Any value
+        // less than 0 will be treated as 0% and any value greater than 100 will
+        // be treated as 100%.
+        static int reevaluatePercentage;
+
         /** Call connect() after constructing. autoReconnect is always on for DBClientReplicaSet connections. */
         DBClientReplicaSet( const string& name , const vector<HostAndPort>& servers, double so_timeout=0 );
         virtual ~DBClientReplicaSet();
@@ -212,6 +219,13 @@ namespace mongo {
         // Throws a DBException if the monitor doesn't exist and there isn't a cached seed to use.
         ReplicaSetMonitorPtr _getMonitor() const;
 
+        /**
+         * Returns true if this connection should re-evaluate the node selection for
+         * a given read preference, regardless of it's compatibility with the currently
+         * cached connection.
+         */
+        bool shouldReevaluate();
+
         string _setName;
 
         HostAndPort _masterHost;
@@ -237,6 +251,11 @@ namespace mongo {
         // not sure if/how we should handle
         std::map<string, BSONObj> _auths; // dbName -> auth parameters
 
+        // For v2.6 only.
+        // Random generator to be used to determine whether this connection object
+        // should re-evaluate node selection from scratch.
+        PseudoRandom _nodeSelectOracle;
+
     protected:
 
         /**

src/mongo/db/dbmessage.cpp

@@ -53,6 +53,107 @@ namespace mongo {
         return ss.str();
     }
 
+    DbMessage::DbMessage(const Message& msg) : _msg(msg), _nsStart(NULL), _mark(NULL), _nsLen(0) {
+        // for received messages, Message has only one buffer
+        _theEnd = _msg.singleData()->_data + _msg.singleData()->dataLen();
+        _nextjsobj = _msg.singleData()->_data;
+
+        _reserved = readAndAdvance<int>();
+
+        // Read packet for NS
+        if (messageShouldHaveNs()) {
+
+            // Limit = buffer size of message -
+            //        (first int4 in message which is either flags or a zero constant)
+            size_t limit = _msg.singleData()->dataLen() - sizeof(int);
+
+            _nsStart = _nextjsobj;
+            _nsLen = strnlen(_nsStart, limit);
+
+            // Validate there is room for a null byte in the buffer
+            // Strings can be zero length
+            uassert(18633, "Failed to parse ns string", _nsLen <= (limit - 1));
+
+            _nextjsobj += _nsLen + 1; // skip namespace + null
+        }
+    }
+
+    const char * DbMessage::getns() const {
+        verify(messageShouldHaveNs());
+        return _nsStart;
+    }
+
+    int DbMessage::getQueryNToReturn() const {
+        verify(messageShouldHaveNs());
+        const char* p = _nsStart + _nsLen + 1;
+        checkRead<int>(p, 2);
+
+        return ((reinterpret_cast<const int*>(p)))[1];
+    }
+
+    int DbMessage::pullInt() {
+        return readAndAdvance<int>();
+    }
+
+    long long DbMessage::pullInt64() {
+        return readAndAdvance<long long>();
+    }
+
+    const long long* DbMessage::getArray(size_t count) const {
+        checkRead<long long>(_nextjsobj, count);
+        return reinterpret_cast<const long long*>(_nextjsobj);
+    }
+
+    BSONObj DbMessage::nextJsObj() {
+        massert(10304,
+            "Client Error: Remaining data too small for BSON object",
+            _nextjsobj != NULL && _theEnd - _nextjsobj >= 5);
+
+        if (serverGlobalParams.objcheck) {
+            Status status = validateBSON(_nextjsobj, _theEnd - _nextjsobj);
+            massert(10307,
+                str::stream() << "Client Error: bad object in message: " << status.reason(),
+                status.isOK());
+        }
+
+        BSONObj js(_nextjsobj);
+        verify(js.objsize() >= 5);
+        verify(js.objsize() <= (_theEnd - _nextjsobj));
+
+        _nextjsobj += js.objsize();
+        if (_nextjsobj >= _theEnd)
+            _nextjsobj = NULL;
+        return js;
+    }
+
+    void DbMessage::markReset(const char * toMark = NULL) {
+        if (toMark == NULL) {
+            toMark = _mark;
+        }
+
+        verify(toMark);
+        _nextjsobj = toMark;
+    }
+
+    template<typename T>
+    void DbMessage::checkRead(const char* start, size_t count) const {
+        if ((_theEnd - start) < static_cast<int>(sizeof(T) * count)) {
+            uassert(18634, "Not enough data to read", false);
+        }
+    }
+
+    template<typename T>
+    T DbMessage::read() const {
+        checkRead<T>(_nextjsobj, 1);
+
+        return *(reinterpret_cast<const T*>(_nextjsobj));
+    }
+
+    template<typename T> T DbMessage::readAndAdvance() {
+        T t = read<T>();
+        _nextjsobj += sizeof(T);
+        return t;
+    }
 
     void replyToQuery(int queryResultFlags,
                       AbstractMessagingPort* p, Message& requestMsg,