void DurRecoveryUnit::rollbackInnermostChanges() {
// TODO SERVER-15043 reduce logging at default verbosity after a burn-in period
invariant(_changes.size() <= size_t(std::numeric_limits<int>::max()));
const int rollbackTo = _startOfUncommittedChangesForLevel.back();
log() << " ***** ROLLING BACK " << (_changes.size() - rollbackTo) << " changes";
for (int i = _changes.size() - 1; i >= rollbackTo; i--) {
const type_info& type = typeid(*_changes[i]);
if (type != typeid(MemoryWrite)) {
log() << "CUSTOM ROLLBACK " << demangleName(type);
}
_changes[i]->rollback();
}
_changes.erase(_changes.begin() + rollbackTo, _changes.end());
if (inOutermostUnitOfWork()) {
// We just rolled back so we are now "clean" and don't need to roll back anymore.
invariant(_changes.empty());
_mustRollback = false;
}
else {
// Inner UOW rolled back, so outer must not commit. We can loosen this in the future,
// but that would require all StorageEngines to support rollback of nested transactions.
_mustRollback = true;
}
}
void WiredTigerRecoveryUnit::_abort() {
try {
bool notifyDone = !_prepareTimestamp.isNull();
if (_session && _isActive()) {
_txnClose(false);
}
_setState(State::kAborting);
if (MONGO_FAIL_POINT(WTAlwaysNotifyPrepareConflictWaiters)) {
notifyDone = true;
}
if (notifyDone) {
_sessionCache->notifyPreparedUnitOfWorkHasCommittedOrAborted();
}
for (Changes::const_reverse_iterator it = _changes.rbegin(), end = _changes.rend();
it != end;
++it) {
Change* change = it->get();
LOG(2) << "CUSTOM ROLLBACK " << redact(demangleName(typeid(*change)));
change->rollback();
}
_changes.clear();
} catch (...) {
std::terminate();
}
_setState(State::kInactive);
}
void run() {
long normal = TimingBase<M>::dotime( BSON( "x" << 5 ),
BSON( "x" << 5 ) );
long all = TimingBase<M>::dotime( BSON( "x" << BSON( "$all" << BSON_ARRAY( 5 ) ) ),
BSON( "x" << 5 ) );
cout << "AllTiming " << demangleName(typeid(M))
<< " normal: " << normal << " all: " << all << endl;
}
Status exceptionToStatus() {
try {
throw;
} catch (const DBException& ex) {
return ex.toStatus();
} catch (const std::exception& ex) {
return Status(ErrorCodes::UnknownError,
str::stream() << "Caught std::exception of type " << demangleName(typeid(ex))
<< ": " << ex.what());
} catch (const boost::exception& ex) {
return Status(ErrorCodes::UnknownError,
str::stream() << "Caught boost::exception of type "
<< demangleName(typeid(ex)) << ": "
<< boost::diagnostic_information(ex));
} catch (...) {
severe() << "Caught unknown exception in exceptionToStatus()";
std::terminate();
}
}
bool demangleName(const char *mangled, std::string& unmangled)
{
static const size_t max_size = 1024;
char result[max_size];
if(demangleName(mangled, result, max_size))
{
unmangled = result;
return true;
}
return false;
}
void EphemeralForTestRecoveryUnit::abortUnitOfWork() {
try {
for (Changes::reverse_iterator it = _changes.rbegin(), end = _changes.rend(); it != end;
++it) {
ChangePtr change = *it;
LOG(2) << "CUSTOM ROLLBACK " << demangleName(typeid(*change));
change->rollback();
}
_changes.clear();
} catch (...) {
std::terminate();
}
}
void threadRun( MessagingPort * inPort) {
TicketHolderReleaser connTicketReleaser( &connTicketHolder );
assert( inPort );
setThreadName( "conn" );
auto_ptr<MessagingPort> p( inPort );
string otherSide;
Message m;
try {
otherSide = p->farEnd.toString();
while ( 1 ) {
m.reset();
p->clearCounters();
if ( ! p->recv(m) ) {
if( !cmdLine.quiet )
log() << "end connection " << otherSide << endl;
p->shutdown();
break;
}
handler->process( m , p.get() );
networkCounter.hit( p->getBytesIn() , p->getBytesOut() );
}
}
catch ( const SocketException& ) {
log() << "unclean socket shutdown from: " << otherSide << endl;
}
catch ( const std::exception& e ) {
problem() << "uncaught exception (" << e.what() << ")(" << demangleName( typeid(e) ) <<") in PortMessageServer::threadRun, closing connection" << endl;
}
catch ( ... ) {
problem() << "uncaught exception in PortMessageServer::threadRun, closing connection" << endl;
}
handler->disconnected( p.get() );
}
void TerarkDbRecoveryUnit::_abort() {
try {
if (_active) {
_txnClose(false);
}
for (Changes::const_reverse_iterator it = _changes.rbegin(), end = _changes.rend();
it != end;
++it) {
Change* change = *it;
LOG(2) << "CUSTOM ROLLBACK " << demangleName(typeid(*change));
change->rollback();
}
_changes.clear();
invariant(!_active);
} catch (...) {
std::terminate();
}
}
void DurRecoveryUnit::rollbackInnermostChanges() {
// Using signed ints to avoid issues in loops below around index 0.
invariant(_changes.size() <= size_t(std::numeric_limits<int>::max()));
invariant(_writes.size() <= size_t(std::numeric_limits<int>::max()));
const int changesRollbackTo = _startOfUncommittedChangesForLevel.back().changeIndex;
const int writesRollbackTo = _startOfUncommittedChangesForLevel.back().writeIndex;
LOG(2) << " ***** ROLLING BACK " << (_writes.size() - writesRollbackTo) << " disk writes"
<< " and " << (_changes.size() - changesRollbackTo) << " custom changes";
// First rollback disk writes, then Changes. This matches behavior in other storage engines
// that either rollback a transaction or don't write a writebatch.
for (int i = _writes.size() - 1; i >= writesRollbackTo; i--) {
// TODO need to add these pages to our "dirty count" somehow.
_preimageBuffer.copy(_writes[i].addr, _writes[i].len, _writes[i].offset);
}
for (int i = _changes.size() - 1; i >= changesRollbackTo; i--) {
LOG(2) << "CUSTOM ROLLBACK " << demangleName(typeid(*_changes[i]));
_changes[i]->rollback();
}
_writes.erase(_writes.begin() + writesRollbackTo, _writes.end());
_changes.erase(_changes.begin() + changesRollbackTo, _changes.end());
if (inOutermostUnitOfWork()) {
// We just rolled back so we are now "clean" and don't need to roll back anymore.
invariant(_changes.empty());
invariant(_writes.empty());
_preimageBuffer.clear();
_mustRollback = false;
}
else {
// Inner UOW rolled back, so outer must not commit. We can loosen this in the future,
// but that would require all StorageEngines to support rollback of nested transactions.
_mustRollback = true;
}
}
/**
* Returns true if the operation can continue.
*/
bool handleError(OperationContext* txn,
const DBException& ex,
const ParsedWriteOp& wholeOp,
WriteResult* out) {
LastError::get(txn->getClient()).setLastError(ex.getCode(), ex.getInfo().msg);
auto& curOp = *CurOp::get(txn);
curOp.debug().exceptionInfo = ex.getInfo();
if (ErrorCodes::isInterruption(ErrorCodes::Error(ex.getCode()))) {
throw; // These have always failed the whole batch.
}
if (ErrorCodes::isStaleShardingError(ErrorCodes::Error(ex.getCode()))) {
auto staleConfigException = dynamic_cast<const SendStaleConfigException*>(&ex);
if (!staleConfigException) {
// We need to get extra info off of the SCE, but some common patterns can result in the
// exception being converted to a Status then rethrown as a UserException, losing the
// info we need. It would be a bug if this happens so we want to detect it in testing,
// but it isn't severe enough that we should bring down the server if it happens in
// production.
dassert(staleConfigException);
msgassertedNoTrace(35475,
str::stream()
<< "Got a StaleConfig error but exception was the wrong type: "
<< demangleName(typeid(ex)));
}
ShardingState::get(txn)
->onStaleShardVersion(txn, wholeOp.ns, staleConfigException->getVersionReceived());
out->staleConfigException =
stdx::make_unique<SendStaleConfigException>(*staleConfigException);
return false;
}
out->results.emplace_back(ex.toStatus());
return wholeOp.continueOnError;
}
bool CmdLine::store( int argc , char ** argv ,
boost::program_options::options_description& visible,
boost::program_options::options_description& hidden,
boost::program_options::positional_options_description& positional,
boost::program_options::variables_map ¶ms ) {
{
// setup binary name
cmdLine.binaryName = argv[0];
size_t i = cmdLine.binaryName.rfind( '/' );
if ( i != string::npos )
cmdLine.binaryName = cmdLine.binaryName.substr( i + 1 );
// setup cwd
char buffer[1024];
#ifdef _WIN32
verify( _getcwd( buffer , 1000 ) );
#else
verify( getcwd( buffer , 1000 ) );
#endif
cmdLine.cwd = buffer;
}
/* don't allow guessing - creates ambiguities when some options are
* prefixes of others. allow long disguises and don't allow guessing
* to get away with our vvvvvvv trick. */
int style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all;
all.add( visible );
all.add( hidden );
po::store( po::command_line_parser(argc, argv)
.options( all )
.positional( positional )
.style( style )
.run(),
params );
if ( params.count("config") ) {
ifstream f( params["config"].as<string>().c_str() );
if ( ! f.is_open() ) {
cout << "ERROR: could not read from config file" << endl << endl;
cout << visible << endl;
return false;
}
stringstream ss;
CmdLine::parseConfigFile( f, ss );
po::store( po::parse_config_file( ss , all ) , params );
f.close();
}
po::notify(params);
}
catch (po::error &e) {
cout << "error command line: " << e.what() << endl;
cout << "use --help for help" << endl;
//cout << visible << endl;
return false;
}
if (params.count("verbose")) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 12; s.append("v")) {
if (params.count(s)) {
logLevel = s.length();
}
}
if (params.count("quiet")) {
cmdLine.quiet = true;
}
if (params.count("traceExceptions")) {
DBException::traceExceptions = true;
}
if ( params.count( "maxConns" ) ) {
int newSize = params["maxConns"].as<int>();
if ( newSize < 5 ) {
out() << "maxConns has to be at least 5" << endl;
::_exit( EXIT_BADOPTIONS );
}
else if ( newSize >= 10000000 ) {
out() << "maxConns can't be greater than 10000000" << endl;
::_exit( EXIT_BADOPTIONS );
}
connTicketHolder.resize( newSize );
}
if (params.count("objcheck")) {
cmdLine.objcheck = true;
}
if (params.count("bind_ip")) {
// passing in wildcard is the same as default behavior; remove and warn
if ( cmdLine.bind_ip == "0.0.0.0" ) {
cout << "warning: bind_ip of 0.0.0.0 is unnecessary; listens on all ips by default" << endl;
cmdLine.bind_ip = "";
}
}
string logpath;
#ifndef _WIN32
if (params.count("unixSocketPrefix")) {
cmdLine.socket = params["unixSocketPrefix"].as<string>();
if (!fs::is_directory(cmdLine.socket)) {
cout << cmdLine.socket << " must be a directory" << endl;
::_exit(-1);
}
}
if (params.count("nounixsocket")) {
cmdLine.noUnixSocket = true;
}
if (params.count("fork") && !params.count("shutdown")) {
cmdLine.doFork = true;
if ( ! params.count( "logpath" ) && ! params.count( "syslog" ) ) {
cout << "--fork has to be used with --logpath or --syslog" << endl;
::_exit(EXIT_BADOPTIONS);
}
if ( params.count( "logpath" ) ) {
// test logpath
logpath = params["logpath"].as<string>();
verify( logpath.size() );
if ( logpath[0] != '/' ) {
logpath = cmdLine.cwd + "/" + logpath;
}
bool exists = boost::filesystem::exists( logpath );
FILE * test = fopen( logpath.c_str() , "a" );
if ( ! test ) {
cout << "can't open [" << logpath << "] for log file: " << errnoWithDescription() << endl;
::_exit(-1);
}
fclose( test );
// if we created a file, unlink it (to avoid confusing log rotation code)
if ( ! exists ) {
unlink( logpath.c_str() );
}
}
cout.flush();
cerr.flush();
cmdLine.parentProc = getpid();
// facilitate clean exit when child starts successfully
setupLaunchSignals();
pid_t c = fork();
if ( c ) {
int pstat;
waitpid(c, &pstat, 0);
if ( WIFEXITED(pstat) ) {
if ( ! WEXITSTATUS(pstat) ) {
cout << "child process started successfully, parent exiting" << endl;
}
_exit( WEXITSTATUS(pstat) );
}
_exit(50);
}
if ( chdir("/") < 0 ) {
cout << "Cant chdir() while forking server process: " << strerror(errno) << endl;
::_exit(-1);
}
setsid();
cmdLine.leaderProc = getpid();
pid_t c2 = fork();
if ( c2 ) {
int pstat;
cout << "forked process: " << c2 << endl;
waitpid(c2, &pstat, 0);
if ( WIFEXITED(pstat) ) {
_exit( WEXITSTATUS(pstat) );
}
_exit(51);
}
// stdout handled in initLogging
//fclose(stdout);
//freopen("/dev/null", "w", stdout);
fclose(stderr);
fclose(stdin);
FILE* f = freopen("/dev/null", "w", stderr);
if ( f == NULL ) {
cout << "Cant reassign stderr while forking server process: " << strerror(errno) << endl;
::_exit(-1);
}
f = freopen("/dev/null", "r", stdin);
if ( f == NULL ) {
cout << "Cant reassign stdin while forking server process: " << strerror(errno) << endl;
::_exit(-1);
}
}
setupSignals( true );
if (params.count("syslog")) {
StringBuilder sb;
sb << cmdLine.binaryName << "." << cmdLine.port;
Logstream::useSyslog( sb.str().c_str() );
}
#endif
if (params.count("logpath") && !params.count("shutdown")) {
if ( params.count("syslog") ) {
cout << "Cant use both a logpath and syslog " << endl;
::_exit(EXIT_BADOPTIONS);
}
if ( logpath.size() == 0 )
logpath = params["logpath"].as<string>();
uassert( 10033 , "logpath has to be non-zero" , logpath.size() );
initLogging( logpath , params.count( "logappend" ) );
}
if ( params.count("pidfilepath")) {
writePidFile( params["pidfilepath"].as<string>() );
}
if (params.count("keyFile")) {
const string f = params["keyFile"].as<string>();
if (!setUpSecurityKey(f)) {
// error message printed in setUpPrivateKey
::_exit(EXIT_BADOPTIONS);
}
cmdLine.keyFile = true;
noauth = false;
}
else {
cmdLine.keyFile = false;
}
#ifdef MONGO_SSL
if (params.count("sslOnNormalPorts") ) {
cmdLine.sslOnNormalPorts = true;
if ( cmdLine.sslPEMKeyPassword.size() == 0 ) {
log() << "need sslPEMKeyPassword" << endl;
::_exit(EXIT_BADOPTIONS);
}
if ( cmdLine.sslPEMKeyFile.size() == 0 ) {
log() << "need sslPEMKeyFile" << endl;
::_exit(EXIT_BADOPTIONS);
}
cmdLine.sslServerManager = new SSLManager( false );
if ( ! cmdLine.sslServerManager->setupPEM( cmdLine.sslPEMKeyFile , cmdLine.sslPEMKeyPassword ) ) {
::_exit(EXIT_BADOPTIONS);
}
}
else if ( cmdLine.sslPEMKeyFile.size() || cmdLine.sslPEMKeyPassword.size() ) {
log() << "need to enable sslOnNormalPorts" << endl;
::_exit(EXIT_BADOPTIONS);
}
#endif
{
BSONObjBuilder b;
for (po::variables_map::const_iterator it(params.begin()), end(params.end()); it != end; it++){
if (!it->second.defaulted()){
const string& key = it->first;
const po::variable_value& value = it->second;
const type_info& type = value.value().type();
if (type == typeid(string)){
if (value.as<string>().empty())
b.appendBool(key, true); // boost po uses empty string for flags like --quiet
else {
if ( key == "servicePassword" || key == "sslPEMKeyPassword" ) {
b.append( key, "<password>" );
}
else {
b.append( key, value.as<string>() );
}
}
}
else if (type == typeid(int))
b.append(key, value.as<int>());
else if (type == typeid(double))
b.append(key, value.as<double>());
else if (type == typeid(bool))
b.appendBool(key, value.as<bool>());
else if (type == typeid(long))
b.appendNumber(key, (long long)value.as<long>());
else if (type == typeid(unsigned))
b.appendNumber(key, (long long)value.as<unsigned>());
else if (type == typeid(unsigned long long))
b.appendNumber(key, (long long)value.as<unsigned long long>());
else if (type == typeid(vector<string>))
b.append(key, value.as<vector<string> >());
else
b.append(key, "UNKNOWN TYPE: " + demangleName(type));
}
}
parsedOpts = b.obj();
}
{
BSONArrayBuilder b;
for (int i=0; i < argc; i++) {
b << argv[i];
if ( mongoutils::str::equals(argv[i], "--sslPEMKeyPassword")
|| mongoutils::str::equals(argv[i], "-sslPEMKeyPassword")
|| mongoutils::str::equals(argv[i], "--servicePassword")
|| mongoutils::str::equals(argv[i], "-servicePassword")) {
b << "<password>";
i++;
// hide password from ps output
char* arg = argv[i];
while (*arg) {
*arg++ = 'x';
}
}
}
argvArray = b.arr();
}
return true;
}
bool CmdLine::store( const std::vector<std::string>& argv,
boost::program_options::options_description& visible,
boost::program_options::options_description& hidden,
boost::program_options::positional_options_description& positional,
boost::program_options::variables_map ¶ms ) {
if (argv.empty())
return false;
{
// setup binary name
cmdLine.binaryName = argv[0];
size_t i = cmdLine.binaryName.rfind( '/' );
if ( i != string::npos )
cmdLine.binaryName = cmdLine.binaryName.substr( i + 1 );
// setup cwd
char buffer[1024];
#ifdef _WIN32
verify( _getcwd( buffer , 1000 ) );
#else
verify( getcwd( buffer , 1000 ) );
#endif
cmdLine.cwd = buffer;
}
/* don't allow guessing - creates ambiguities when some options are
* prefixes of others. allow long disguises and don't allow guessing
* to get away with our vvvvvvv trick. */
int style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all;
all.add( visible );
all.add( hidden );
po::store( po::command_line_parser(std::vector<std::string>(argv.begin() + 1,
argv.end()))
.options( all )
.positional( positional )
.style( style )
.run(),
params );
if ( params.count("config") ) {
ifstream f( params["config"].as<string>().c_str() );
if ( ! f.is_open() ) {
cout << "ERROR: could not read from config file" << endl << endl;
cout << visible << endl;
return false;
}
stringstream ss;
CmdLine::parseConfigFile( f, ss );
po::store( po::parse_config_file( ss , all ) , params );
f.close();
}
po::notify(params);
}
catch (po::error &e) {
cout << "error command line: " << e.what() << endl;
cout << "use --help for help" << endl;
//cout << visible << endl;
return false;
}
{
BSONArrayBuilder b;
std::vector<std::string> censoredArgv = argv;
censor(&censoredArgv);
for (size_t i=0; i < censoredArgv.size(); i++) {
b << censoredArgv[i];
}
argvArray = b.arr();
}
{
BSONObjBuilder b;
for (po::variables_map::const_iterator it(params.begin()), end(params.end()); it != end; it++){
if (!it->second.defaulted()){
const string& key = it->first;
const po::variable_value& value = it->second;
const type_info& type = value.value().type();
if (type == typeid(string)){
if (value.as<string>().empty())
b.appendBool(key, true); // boost po uses empty string for flags like --quiet
else {
if ( _isPasswordArgument(key.c_str()) ) {
b.append( key, "<password>" );
}
else {
b.append( key, value.as<string>() );
}
}
}
else if (type == typeid(int))
b.append(key, value.as<int>());
else if (type == typeid(double))
b.append(key, value.as<double>());
else if (type == typeid(bool))
b.appendBool(key, value.as<bool>());
else if (type == typeid(long))
b.appendNumber(key, (long long)value.as<long>());
else if (type == typeid(unsigned))
b.appendNumber(key, (long long)value.as<unsigned>());
else if (type == typeid(unsigned long long))
b.appendNumber(key, (long long)value.as<unsigned long long>());
else if (type == typeid(vector<string>))
b.append(key, value.as<vector<string> >());
else
b.append(key, "UNKNOWN TYPE: " + demangleName(type));
}
}
parsedOpts = b.obj();
}
if (params.count("verbose")) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 12; s.append("v")) {
if (params.count(s)) {
logLevel = s.length();
}
}
if (params.count("quiet")) {
cmdLine.quiet = true;
}
if (params.count("traceExceptions")) {
DBException::traceExceptions = true;
}
if (params.count("maxConns")) {
cmdLine.maxConns = params["maxConns"].as<int>();
if ( cmdLine.maxConns < 5 ) {
out() << "maxConns has to be at least 5" << endl;
return false;
}
else if ( cmdLine.maxConns > MAX_MAX_CONN ) {
out() << "maxConns can't be greater than " << MAX_MAX_CONN << endl;
return false;
}
}
if (params.count("objcheck")) {
cmdLine.objcheck = true;
}
if (params.count("noobjcheck")) {
if (params.count("objcheck")) {
out() << "can't have both --objcheck and --noobjcheck" << endl;
return false;
}
cmdLine.objcheck = false;
}
if (params.count("bind_ip")) {
// passing in wildcard is the same as default behavior; remove and warn
if ( cmdLine.bind_ip == "0.0.0.0" ) {
cout << "warning: bind_ip of 0.0.0.0 is unnecessary; listens on all ips by default" << endl;
cmdLine.bind_ip = "";
}
}
#ifndef _WIN32
if (params.count("unixSocketPrefix")) {
cmdLine.socket = params["unixSocketPrefix"].as<string>();
}
if (params.count("nounixsocket")) {
cmdLine.noUnixSocket = true;
}
if (params.count("fork") && !params.count("shutdown")) {
cmdLine.doFork = true;
}
#endif // _WIN32
if (params.count("logpath")) {
cmdLine.logpath = params["logpath"].as<string>();
if (cmdLine.logpath.empty()) {
cout << "logpath cannot be empty if supplied" << endl;
return false;
}
}
cmdLine.logWithSyslog = params.count("syslog");
cmdLine.logAppend = params.count("logappend");
if (!cmdLine.logpath.empty() && cmdLine.logWithSyslog) {
cout << "Cant use both a logpath and syslog " << endl;
return false;
}
if (cmdLine.doFork && cmdLine.logpath.empty() && !cmdLine.logWithSyslog) {
cout << "--fork has to be used with --logpath or --syslog" << endl;
return false;
}
if (params.count("keyFile")) {
cmdLine.keyFile = params["keyFile"].as<string>();
}
if ( params.count("pidfilepath")) {
cmdLine.pidFile = params["pidfilepath"].as<string>();
}
if (params.count("setParameter")) {
std::vector<std::string> parameters =
params["setParameter"].as<std::vector<std::string> >();
for (size_t i = 0, length = parameters.size(); i < length; ++i) {
std::string name;
std::string value;
if (!mongoutils::str::splitOn(parameters[i], '=', name, value)) {
cout << "Illegal option assignment: \"" << parameters[i] << "\"" << endl;
return false;
}
ServerParameter* parameter = mapFindWithDefault(
ServerParameterSet::getGlobal()->getMap(),
name,
static_cast<ServerParameter*>(NULL));
if (NULL == parameter) {
cout << "Illegal --option parameter: \"" << name << "\"" << endl;
return false;
}
Status status = parameter->setFromString(value);
if (!status.isOK()) {
cout << "Bad value for parameter \"" << name << "\": " << status.reason()
<< endl;
return false;
}
}
}
#ifdef MONGO_SSL
if (params.count("sslWeakCertificateValidation")) {
cmdLine.sslWeakCertificateValidation = true;
}
if (params.count("sslOnNormalPorts")) {
cmdLine.sslOnNormalPorts = true;
if ( cmdLine.sslPEMKeyFile.size() == 0 ) {
log() << "need sslPEMKeyFile" << endl;
return false;
}
if (cmdLine.sslWeakCertificateValidation &&
cmdLine.sslCAFile.empty()) {
log() << "need sslCAFile with sslWeakCertificateValidation" << endl;
return false;
}
}
else if (cmdLine.sslPEMKeyFile.size() ||
cmdLine.sslPEMKeyPassword.size() ||
cmdLine.sslCAFile.size() ||
cmdLine.sslCRLFile.size() ||
cmdLine.sslWeakCertificateValidation) {
log() << "need to enable sslOnNormalPorts" << endl;
return false;
}
#endif
return true;
}