LockingPointer.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_SECURITY_LOCKINGPOINTER_H
#define SQUID_SRC_SECURITY_LOCKINGPOINTER_H
 
#include "base/Assure.h"
#include "base/HardFun.h"
 
#if USE_OPENSSL
#include "compat/openssl.h"
#if HAVE_OPENSSL_CRYPTO_H
#include <openssl/crypto.h>
#endif
 
// Macro to be used to define the C++ wrapper function of a sk_*_pop_free
// openssl family functions. The C++ function suffixed with the _free_wrapper
// extension
#define sk_free_wrapper(sk_object, argument, freefunction) \
        extern "C++" inline void sk_object ## _free_wrapper(argument a) { \
            sk_object ## _pop_free(a, freefunction); \
        }
 
#endif /* USE_OPENSSL */
 
// Macro to be used to define the C++ equivalent function of an extern "C"
// function. The C++ function suffixed with the _cpp extension
#define CtoCpp1(function, argument) \
        extern "C++" inline void function ## _cpp(argument a) { \
            function(a); \
        }
 
namespace Security
{
 
inline bool nilFunction(const void *) { return false; }
typedef HardFun<bool, const void *, nilFunction> NilFunctor;
 
template <typename T, void (*UnLocker)(T *t), class Locker = NilFunctor>
class LockingPointer
{
public:
    typedef Security::LockingPointer<T, UnLocker, Locker> SelfType;
 
    constexpr LockingPointer(): raw(nullptr) {}
 
    constexpr LockingPointer(std::nullptr_t): raw(nullptr) {}
 
    explicit LockingPointer(T *t): raw(nullptr) {
        // de-optimized for clarity about non-locking
        resetWithoutLocking(t);
    }
 
    ~LockingPointer() { unlock(); }
 
    // copy semantics are okay only when adding a lock reference
    LockingPointer(const SelfType &o) : raw(nullptr) {
        resetAndLock(o.get());
    }
    const SelfType &operator =(const SelfType &o) {
        resetAndLock(o.get());
        return *this;
    }
 
    LockingPointer(SelfType &&o) : raw(nullptr) {
        resetWithoutLocking(o.release());
    }
    SelfType &operator =(SelfType &&o) {
        if (o.get() != raw)
            resetWithoutLocking(o.release());
        return *this;
    }
 
    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 { Assure(raw); return *raw; }
    T *operator ->() const { return raw; }
 
    T *get() const { return raw; }
 
    void resetWithoutLocking(T *t) {
        unlock();
        raw = t;
    }
 
    void resetAndLock(T *t) {
        if (t != get()) {
            resetWithoutLocking(t);
            lock(t);
        }
    }
 
    void reset() { unlock(); }
 
    T *release() {
        T *ret = raw;
        raw = nullptr;
        return ret;
    }
 
private:
    void lock(T *t) {
        if (t) {
            Locker doLock;
            doLock(t);
        }
    }
 
    void unlock() {
        if (raw) {
            UnLocker(raw);
            raw = nullptr;
        }
    }
 
    T *raw;
};
 
} // namespace Security
 
#endif /* SQUID_SRC_SECURITY_LOCKINGPOINTER_H */