/*
- * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
#ifndef SQUID_SRC_SECURITY_LOCKINGPOINTER_H
#define SQUID_SRC_SECURITY_LOCKINGPOINTER_H
+#include "base/HardFun.h"
+
#if USE_OPENSSL
#if HAVE_OPENSSL_CRYPTO_H
#include <openssl/crypto.h>
namespace Security
{
+inline bool nilFunction(const void *) { return false; }
+typedef HardFun<bool, const void *, nilFunction> NilFunctor;
+
/**
* A shared pointer to a reference-counting Object with library-specific
* absorption, locking, and unlocking implementations. The API largely
* Normally, reset() would lock(), but libraries like OpenSSL
* pre-lock objects before they are fed to LockingPointer, necessitating
* this resetWithoutLocking() customization hook.
- *
- * The lock() method increments Object's reference counter.
- *
- * The unlock() method decrements Object's reference counter and destroys
- * the object when the counter reaches zero.
*/
-template <typename T, void (*UnLocker)(T *t), int lockId>
+template <typename T, void (*UnLocker)(T *t), class Locker = NilFunctor>
class LockingPointer
{
public:
/// a helper label to simplify this objects API definitions below
- typedef LockingPointer<T, UnLocker, lockId> SelfType;
+ typedef Security::LockingPointer<T, UnLocker, Locker> SelfType;
/**
* Construct directly from a raw pointer.
* created one reference lock for the object pointed to.
* Our destructor will do the matching unlock.
*/
- explicit LockingPointer(T *t = nullptr): raw(t) {}
+ explicit LockingPointer(T *t = nullptr): raw(nullptr) {
+ // de-optimized for clarity about non-locking
+ resetWithoutLocking(t);
+ }
/// use the custom UnLocker to unlock any value still stored.
~LockingPointer() { unlock(); }
// copy semantics are okay only when adding a lock reference
- explicit LockingPointer(const SelfType &o) : raw(nullptr) { resetAndLock(o.get()); }
- SelfType &operator =(const SelfType & o) {
+ LockingPointer(const SelfType &o) : raw(nullptr) {
+ resetAndLock(o.get());
+ }
+ const SelfType &operator =(const SelfType &o) {
resetAndLock(o.get());
return *this;
}
- // move semantics are definitely okay, when possible
- explicit LockingPointer(SelfType &&) = default;
+ LockingPointer(SelfType &&o) : raw(nullptr) {
+ resetWithoutLocking(o.release());
+ }
SelfType &operator =(SelfType &&o) {
if (o.get() != raw)
resetWithoutLocking(o.release());
bool operator !() const { return !raw; }
explicit operator bool() const { return raw; }
+ bool operator ==(const SelfType &o) const { return (o.get() == raw); }
+ bool operator !=(const SelfType &o) const { return (o.get() != raw); }
+
+ T *operator ->() const { return raw; }
/// Returns raw and possibly nullptr pointer
T *get() const { return raw; }
}
}
+ /// Forget the raw pointer - unlock if any value was set. Become a nil pointer.
+ void reset() { unlock(); }
+
/// Forget the raw pointer without unlocking it. Become a nil pointer.
T *release() {
T *ret = raw;
}
private:
+ /// The lock() method increments Object's reference counter.
void lock(T *t) {
-#if USE_OPENSSL
- if (t)
- CRYPTO_add(&t->references, 1, lockId);
-#elif USE_GNUTLS
- // XXX: GnuTLS does not provide locking ?
-#else
- assert(false);
-#endif
+ if (t) {
+ Locker doLock;
+ doLock(t);
+ }
}
- /// Unlock the raw pointer. Become a nil pointer.
+ /// Become a nil pointer. Decrements any pointed-to Object's reference counter
+ /// using UnLocker which ideally destroys the object when the counter reaches zero.
void unlock() {
- if (raw)
+ if (raw) {
UnLocker(raw);
- raw = nullptr;
+ raw = nullptr;
+ }
}
- T *raw; ///< pointer to T object or nullptr
+ /**
+ * Normally, no other code will have this raw pointer.
+ *
+ * However, OpenSSL does some strange and not always consistent things.
+ * OpenSSL library may keep its own internal raw pointers and manage
+ * their reference counts independently, or it may not. This varies between
+ * API functions, though it is usually documented.
+ *
+ * This means the caller code needs to be carefuly written to use the correct
+ * reset method and avoid the raw-pointer constructor unless OpenSSL function
+ * producing the pointer is clearly documented as incrementing a lock for it.
+ */
+ T *raw;
};
} // namespace Security