PKIFCNGUtils.h

Go to the documentation of this file.

#if !defined(__PKIFCNGUTILS_H__)
#define __PKIFCNGUTILS_H__

template <typename T> class CleanupFunctor
{
public:
    virtual void operator()(T t) const = 0;
};

template <typename T> class HeapFreeFunctor : public CleanupFunctor<T>
{
public:
    void operator()(T t) const
    {
        HeapFree(GetProcessHeap(), 0, t);
    }
};

template <typename T> class LocalFreeFunctor : public CleanupFunctor<T>
{
public:
    void operator()(T t) const
    {
        LocalFree(t);
    }
};


template <typename T>
class PKIFScopedArray
{
public:
    explicit PKIFScopedArray(T* ptr)
        :m_ptr(ptr)
    {
    }
    ~PKIFScopedArray()
    {
        clear();
    }

    T * get() const
    {
        return m_ptr;
    }

    T & operator[](std::ptrdiff_t i) const
    {
        return m_ptr[i];
    }

    operator const T *() const
    {
        return m_ptr;
    }
    operator T *()
    {
        return m_ptr;
    }

    void clear()
    {
        if(m_ptr) {
            delete[] m_ptr;
        }
        m_ptr = 0;
    }

    T * assign(T * ptr)
    {
        T * rv = m_ptr;
        m_ptr = ptr;
        return rv;
    }

    void reset(T * ptr)
    {
        clear();
        m_ptr = ptr;
    }


    T * release()
    {
        T * rv = m_ptr;
        m_ptr = 0;
        return rv;
    }

private:
    T * m_ptr;
};

typedef PKIFScopedArray<char> pkif_char_array;
typedef PKIFScopedArray<unsigned char> pkif_byte_array;

template <typename T> class HandleGuard
{
public:
    explicit HandleGuard(T ptr=0)
        :m_ptr(ptr)
    {
    }
    virtual ~HandleGuard()
    {
    }

    virtual void clear() = 0;

    inline T get() const
    {
        return m_ptr;
    }
    
    inline T operator->() const
    {
        return m_ptr;
    }

    inline operator const T() const
    {
        return m_ptr;
    }

    inline operator T ()
    {
        return m_ptr;
    }

    inline T* operator&() const
    {
        return const_cast<T*>(&m_ptr);
    }

    T assign(T ptr)
    {
        T rv = m_ptr;
        m_ptr = ptr;
        return rv;
    }

    void reset(T ptr)
    {
        clear();
        assign(ptr);
    }

    T release()
    {
        T rv = m_ptr;
        m_ptr = 0;
        return rv;
    }

protected:
    T m_ptr;
};

template <typename T, typename R, R (__stdcall *cleanupFunc)(T)>
class CNGPtr : public HandleGuard<T>
{
public:
    explicit CNGPtr(T ptr = 0)
        :m_pCleanup(cleanupFunc)
    {
        m_ptr = ptr;
    }
    ~CNGPtr()
    {
        clear();
    }

    void clear()
    {
        if(m_ptr && m_pCleanup) {
            (*m_pCleanup)(m_ptr);
        }
        m_ptr = 0;
    }

private:
    
    R (__stdcall *m_pCleanup)(T);
};

template <typename T, typename R, typename F ,R (__stdcall *cleanupFunc)(T,F)>
class CNGFlagsPtr : public HandleGuard<T>
{
public:
    explicit CNGFlagsPtr(T ptr = 0,F flags = 0)
        :m_pCleanup(cleanupFunc),m_flags(flags)
    {
        m_ptr = ptr;
    }
    ~CNGFlagsPtr()
    {
        clear();
    }

    void clear()
    {
        if(m_ptr && m_pCleanup) {
            (*m_pCleanup)(m_ptr,m_flags);
        }
        m_ptr = 0;
    }

private:
    R (__stdcall *m_pCleanup)(T,F);
    F m_flags;
};



template <typename T>
class CNGPtrCF : public HandleGuard<T>
{
public:
    explicit CNGPtrCF(T ptr =0, CleanupFunctor<T> * cf = new LocalFreeFunctor<T>())
        :m_cf(cf)
    {
        assert(m_cf != 0);
        m_ptr = ptr;
    }
    ~CNGPtrCF()
    {
        clear();
    }

    void clear()
    {
        if(m_ptr) {
            (*m_cf)(m_ptr);
        }
        delete m_cf;
        m_ptr = 0;
    }

private:
    CleanupFunctor<T> * m_cf;
};

#define PKIFCNGPTR_DECLARE(s,f) typedef CNGPtr<s,LONG,f> s##_PKIF
#define PKIFCNGFLAGSPTR_DECLARE(s,f) typedef CNGFlagsPtr<s,LONG,ULONG,f> s##_PKIF
#define PKIFCAPI1PTR_DECLARE(s,f) typedef CNGPtr<s,BOOL,f> s##_PKIF
#define PKIFCAPI1FLAGSPTR_DECLARE(s,f) typedef CNGFlagsPtr<s,BOOL,DWORD,f> s##_PKIF
#define PKIFCNGPTR_DECLARE_CF(s) typedef CNGPtrCF<s> s##_PKIF

PKIFCNGPTR_DECLARE(NCRYPT_PROV_HANDLE,NCryptFreeObject);
PKIFCNGPTR_DECLARE(NCRYPT_KEY_HANDLE,NCryptFreeObject);
PKIFCNGPTR_DECLARE(BCRYPT_KEY_HANDLE,BCryptDestroyKey);
PKIFCNGPTR_DECLARE_CF(PCERT_PUBLIC_KEY_INFO);
PKIFCNGFLAGSPTR_DECLARE(BCRYPT_ALG_HANDLE,BCryptCloseAlgorithmProvider);

PKIFCAPI1FLAGSPTR_DECLARE(HCRYPTPROV,CryptReleaseContext);
PKIFCAPI1PTR_DECLARE(HCRYPTKEY,CryptDestroyKey);
PKIFCAPI1PTR_DECLARE(PCCERT_CONTEXT,CertFreeCertificateContext);

#endif