folly::ssl::detail Namespace Reference

Classes
class	SSLSessionImpl

Functions
static std::map< int, LockType > &	lockTypes ()
void	setLockTypes (std::map< int, LockType > inLockTypes)
bool	isSSLLockDisabled (int lockId)
static std::unique_ptr< SSLLock[]> &	locks ()
static void	callbackLocking (int mode, int n, const char *, int)
static unsigned long	callbackThreadID ()
static CRYPTO_dynlock_value *	dyn_create (const char *, int)
static void	dyn_lock (int mode, struct CRYPTO_dynlock_value *lock, const char *, int)
static void	dyn_destroy (struct CRYPTO_dynlock_value *lock, const char *, int)
void	installThreadingLocks ()
void	cleanupThreadingLocks ()

Function Documentation

static void folly::ssl::detail::callbackLocking ( int  mode, int  n, const char *  , int    )

static

Definition at line 123 of file OpenSSLThreading.cpp.

References locks().

Referenced by installThreadingLocks().

                                                               {
  if (mode & CRYPTO_LOCK) {
    locks()[size_t(n)].lock(mode & CRYPTO_READ);
  } else {
    locks()[size_t(n)].unlock(mode & CRYPTO_READ);
  }
}

static unsigned long folly::ssl::detail::callbackThreadID ( )

static

Definition at line 131 of file OpenSSLThreading.cpp.

References folly::getCurrentThreadID().

Referenced by installThreadingLocks().

                                        {
  return static_cast<unsigned long>(folly::getCurrentThreadID());
}

void folly::ssl::detail::cleanupThreadingLocks

(

)

Definition at line 168 of file OpenSSLThreading.cpp.

References locks().

Referenced by folly::portability::ssl::OPENSSL_cleanup().

                             {
  CRYPTO_set_id_callback(nullptr);
  CRYPTO_set_locking_callback(nullptr);
  CRYPTO_set_dynlock_create_callback(nullptr);
  CRYPTO_set_dynlock_lock_callback(nullptr);
  CRYPTO_set_dynlock_destroy_callback(nullptr);
  locks().reset();
}

static CRYPTO_dynlock_value* folly::ssl::detail::dyn_create ( const char *  , int    )

static

Definition at line 135 of file OpenSSLThreading.cpp.

Referenced by installThreadingLocks().

                                                          {
  return new CRYPTO_dynlock_value;
}

static void folly::ssl::detail::dyn_destroy ( struct CRYPTO_dynlock_value *  lock, const char *  , int    )

static

Definition at line 150 of file OpenSSLThreading.cpp.

References folly::detail::lock().

Referenced by installThreadingLocks().

                                                                             {
  delete lock;
}

static void folly::ssl::detail::dyn_lock ( int  mode, struct CRYPTO_dynlock_value *  lock, const char *  , int    )

static

Definition at line 140 of file OpenSSLThreading.cpp.

References CRYPTO_dynlock_value::mutex.

Referenced by installThreadingLocks().

                                                                        {
  if (lock != nullptr) {
    if (mode & CRYPTO_LOCK) {
      lock->mutex.lock();
    } else {
      lock->mutex.unlock();
    }
  }
}

void folly::ssl::detail::installThreadingLocks

(

)

Definition at line 154 of file OpenSSLThreading.cpp.

References callbackLocking(), callbackThreadID(), dyn_create(), dyn_destroy(), dyn_lock(), locks(), and lockTypes().

Referenced by folly::portability::ssl::OPENSSL_init_ssl().

                             {
  // static locking
  locks() = std::make_unique<SSLLock[]>(size_t(CRYPTO_num_locks()));
  for (auto it : lockTypes()) {
    locks()[size_t(it.first)].lockType = it.second;
  }
  CRYPTO_set_id_callback(callbackThreadID);
  CRYPTO_set_locking_callback(callbackLocking);
  // dynamic locking
  CRYPTO_set_dynlock_create_callback(dyn_create);
  CRYPTO_set_dynlock_lock_callback(dyn_lock);
  CRYPTO_set_dynlock_destroy_callback(dyn_destroy);
}

bool folly::ssl::detail::isSSLLockDisabled

(

int

lockId

)

Definition at line 64 of file OpenSSLThreading.cpp.

References folly::SpinLock::lock(), folly::detail::lock(), lockType, lockTypes(), CRYPTO_dynlock_value::mutex, fizz::detail::read(), sharedMutex, spinLock, and folly::SpinLock::unlock().

Referenced by folly::ssl::isLockDisabled().

                                   {
  const auto& sslLocks = lockTypes();
  const auto it = sslLocks.find(lockId);
  return it != sslLocks.end() && it->second == LockType::NONE;
}

static std::unique_ptr<SSLLock[]>& folly::ssl::detail::locks ( )

static

Definition at line 118 of file OpenSSLThreading.cpp.

Referenced by callbackLocking(), cleanupThreadingLocks(), installThreadingLocks(), folly::lock(), runContended(), runFairness(), runPingPong(), and folly::TEST().

                                         {
  static auto locksInst = new std::unique_ptr<SSLLock[]>();
  return *locksInst;
}

static std::map<int, LockType>& folly::ssl::detail::lockTypes ( )

static

Definition at line 50 of file OpenSSLThreading.cpp.

Referenced by installThreadingLocks(), isSSLLockDisabled(), and setLockTypes().

                                          {
  static auto lockTypesInst = new std::map<int, LockType>();
  return *lockTypesInst;
}

void folly::ssl::detail::setLockTypes

(

std::map< int, LockType >

inLockTypes

)

Definition at line 55 of file OpenSSLThreading.cpp.

References folly::INFO, and lockTypes().

Referenced by folly::ssl::setLockTypes(), and folly::ssl::setLockTypesAndInit().

                                                     {
#if FOLLY_SSL_DETAIL_OPENSSL_IS_110
  LOG(INFO) << "setLockTypes() is unsupported on OpenSSL >= 1.1.0. "
            << "OpenSSL now uses platform native mutexes";
#endif

  lockTypes() = inLockTypes;
}