Migrate TidyPointer to std::unique_ptr

diff --git a/src/base/TidyPointer.h b/src/base/TidyPointer.h
index 50b21e2a09760fd304c196243f370e1f7c4ac9a8..7b2866d60fdc906af274c24f19fb2d7fb630dee4 100644 (file)
--- a/src/base/TidyPointer.h
+++ b/src/base/TidyPointer.h
@@ -9,61 +9,19 @@
 #ifndef SQUID_BASE_TIDYPOINTER_H
 #define SQUID_BASE_TIDYPOINTER_H
 
-/**
- * A pointer that deletes the object it points to when the pointer's owner or
- * context is gone. Similar to std::unique_ptr but without confusing assignment
- * and with a customizable cleanup method. Prevents memory leaks in
- * the presence of exceptions and processing short cuts.
-*/
-template <typename T, void (*DeAllocator)(T *t)> class TidyPointer
-{
-public:
-    /// Delete callback.
-    typedef void DCB (T *t);
-    TidyPointer(T *t = NULL)
-        :   raw(t) {}
-public:
-    bool operator !() const { return !raw; }
-    explicit operator bool() const { return raw; }
-    /// Returns raw and possibly NULL pointer
-    T *get() const { return raw; }
+#include <memory>
 
-    /// Reset raw pointer - delete last one and save new one.
-    void reset(T *t) {
-        deletePointer();
-        raw = t;
-    }
+#define TidyPointer std::unique_ptr
 
-    /// Forget the raw pointer without freeing it. Become a nil pointer.
-    T *release() {
-        T *ret = raw;
-        raw = NULL;
-        return ret;
-    }
-    /// Deallocate raw pointer.
-    ~TidyPointer() {
-        deletePointer();
-    }
-private:
-    /// Forbidden copy constructor.
-    TidyPointer(TidyPointer<T, DeAllocator> const &);
-    /// Forbidden assigment operator.
-    TidyPointer <T, DeAllocator> & operator = (TidyPointer<T, DeAllocator> const &);
-    /// Deallocate raw pointer. Become a nil pointer.
-    void deletePointer() {
-        if (raw) {
-            DeAllocator(raw);
+// Macro to be used to define the C++ equivalent functor of an extern "C"
+// function. The C++ functor is suffixed with the _cpp extension
+#define CtoCppDtor(function, argument_type) \
+        struct function ## _cpp { \
+            void operator()(argument_type a) { function(a); } \
         }
-        raw = NULL;
-    }
-    T *raw; ///< pointer to T object or NULL
-};
 
-/// DeAllocator for pointers that need free(3) from the std C library
-template<typename T> void tidyFree(T *p)
-{
-    xfree(p);
-}
+/// DeAllocator functor for pointers that need free(3) from the std C library
+CtoCppDtor(xfree, char *);
 
 #endif // SQUID_BASE_TIDYPOINTER_H
 

diff --git a/src/security/Session.h b/src/security/Session.h
index bf48a78c4a3f547b46a0d68ad1e6d4cfe4ae01c2..8c60efb517397659e800f4d998be8164d37fcbfb 100644 (file)
--- a/src/security/Session.h
+++ b/src/security/Session.h
@@ -33,7 +33,7 @@ typedef LockingPointer<SSL, Security::SSL_free_cpp, CRYPTO_LOCK_SSL> SessionPoin
 
 #elif USE_GNUTLS
 typedef gnutls_session_t SessionPtr;
-CtoCpp1(gnutls_deinit, gnutls_session_t);
+CtoCppDtor(gnutls_deinit, gnutls_session_t);
 // TODO: Convert to Locking pointer.
 // Locks can be implemented attaching locks counter to gnutls_session_t
 // objects using the gnutls_session_set_ptr()/gnutls_session_get_ptr ()
@@ -43,7 +43,8 @@ typedef TidyPointer<struct gnutls_session_int, Security::gnutls_deinit_cpp> Sess
 #else
 // use void* so we can check against NULL
 typedef void* SessionPtr;
-typedef TidyPointer<void, nullptr> SessionPointer;
+// use nullptr_t so default_delete works
+typedef TidyPointer<nullptr_t> SessionPointer;
 
 #endif
 

diff --git a/src/security/forward.h b/src/security/forward.h
index 54d6b06fb34fccf967cdc2ace88a7fd46dce1110..c903c6b64d1ce22a95528cef2c81e15ba9b7bd0a 100644 (file)
--- a/src/security/forward.h
+++ b/src/security/forward.h
@@ -19,6 +19,16 @@
 #endif
 #include <list>
 
+#if USE_OPENSSL
+// Macro to be used to define the C++ wrapper functor of the sk_*_pop_free
+// OpenSSL family of functions. The C++ functor is suffixed with the _free_wrapper
+// extension
+#define sk_dtor_wrapper(sk_object, argument_type, freefunction) \
+        struct sk_object ## _free_wrapper { \
+            void operator()(argument_type a) { sk_object ## _pop_free(a, freefunction); } \
+        }
+#endif /* USE_OPENSSL */
+
 /* flags a SSL connection can be configured with */
 #define SSL_FLAG_NO_DEFAULT_CA      (1<<0)
 #define SSL_FLAG_DELAYED_AUTH       (1<<1)

diff --git a/src/ssl/gadgets.h b/src/ssl/gadgets.h
index cbd40b3d83d4d58c07e01f3d82219111bc18ad8f..ab9b5317707babd30f7cf7c8f89deed9110933c3 100644 (file)
--- a/src/ssl/gadgets.h
+++ b/src/ssl/gadgets.h
@@ -39,52 +39,51 @@ typedef SSL_METHOD * ContextMethod;
 #endif
 
 /**
- \ingroup SslCrtdSslAPI
- * TidyPointer typedefs for  common SSL objects
+ * TidyPointer typedefs for common SSL objects
  */
-sk_free_wrapper(sk_X509, STACK_OF(X509) *, X509_free)
+sk_dtor_wrapper(sk_X509, STACK_OF(X509) *, X509_free);
 typedef TidyPointer<STACK_OF(X509), sk_X509_free_wrapper> X509_STACK_Pointer;
 
 CtoCpp1(EVP_PKEY_free, EVP_PKEY *)
 typedef Security::LockingPointer<EVP_PKEY, EVP_PKEY_free_cpp, CRYPTO_LOCK_EVP_PKEY> EVP_PKEY_Pointer;
 
-CtoCpp1(BN_free, BIGNUM *)
+CtoCppDtor(BN_free, BIGNUM *);
 typedef TidyPointer<BIGNUM, BN_free_cpp> BIGNUM_Pointer;
 
-CtoCpp1(BIO_free, BIO *)
+CtoCppDtor(BIO_free, BIO *);
 typedef TidyPointer<BIO, BIO_free_cpp> BIO_Pointer;
 
-CtoCpp1(ASN1_INTEGER_free, ASN1_INTEGER *)
+CtoCppDtor(ASN1_INTEGER_free, ASN1_INTEGER *);
 typedef TidyPointer<ASN1_INTEGER, ASN1_INTEGER_free_cpp> ASN1_INT_Pointer;
 
-CtoCpp1(ASN1_OCTET_STRING_free, ASN1_OCTET_STRING *)
+CtoCppDtor(ASN1_OCTET_STRING_free, ASN1_OCTET_STRING *);
 typedef TidyPointer<ASN1_OCTET_STRING, ASN1_OCTET_STRING_free_cpp> ASN1_OCTET_STRING_Pointer;
 
-CtoCpp1(TXT_DB_free, TXT_DB *)
+CtoCppDtor(TXT_DB_free, TXT_DB *);
 typedef TidyPointer<TXT_DB, TXT_DB_free_cpp> TXT_DB_Pointer;
 
-CtoCpp1(X509_NAME_free, X509_NAME *)
+CtoCppDtor(X509_NAME_free, X509_NAME *);
 typedef TidyPointer<X509_NAME, X509_NAME_free_cpp> X509_NAME_Pointer;
 
-CtoCpp1(RSA_free, RSA *)
+CtoCppDtor(RSA_free, RSA *);
 typedef TidyPointer<RSA, RSA_free_cpp> RSA_Pointer;
 
-CtoCpp1(X509_REQ_free, X509_REQ *)
+CtoCppDtor(X509_REQ_free, X509_REQ *);
 typedef TidyPointer<X509_REQ, X509_REQ_free_cpp> X509_REQ_Pointer;
 
-sk_free_wrapper(sk_X509_NAME, STACK_OF(X509_NAME) *, X509_NAME_free)
+sk_dtor_wrapper(sk_X509_NAME, STACK_OF(X509_NAME) *, X509_NAME_free);
 typedef TidyPointer<STACK_OF(X509_NAME), sk_X509_NAME_free_wrapper> X509_NAME_STACK_Pointer;
 
-CtoCpp1(AUTHORITY_KEYID_free, AUTHORITY_KEYID *)
+CtoCppDtor(AUTHORITY_KEYID_free, AUTHORITY_KEYID *);
 typedef TidyPointer<AUTHORITY_KEYID, AUTHORITY_KEYID_free_cpp> AUTHORITY_KEYID_Pointer;
 
-sk_free_wrapper(sk_GENERAL_NAME, STACK_OF(GENERAL_NAME) *, GENERAL_NAME_free)
+sk_dtor_wrapper(sk_GENERAL_NAME, STACK_OF(GENERAL_NAME) *, GENERAL_NAME_free);
 typedef TidyPointer<STACK_OF(GENERAL_NAME), sk_GENERAL_NAME_free_wrapper> GENERAL_NAME_STACK_Pointer;
 
-CtoCpp1(GENERAL_NAME_free, GENERAL_NAME *)
+CtoCppDtor(GENERAL_NAME_free, GENERAL_NAME *);
 typedef TidyPointer<GENERAL_NAME, GENERAL_NAME_free_cpp> GENERAL_NAME_Pointer;
 
-CtoCpp1(X509_EXTENSION_free, X509_EXTENSION *)
+CtoCppDtor(X509_EXTENSION_free, X509_EXTENSION *);
 typedef TidyPointer<X509_EXTENSION, X509_EXTENSION_free_cpp> X509_EXTENSION_Pointer;
 
 /**