certificate_db.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2018 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_SSL_CERTIFICATE_DB_H
#define SQUID_SSL_CERTIFICATE_DB_H

#include "ssl/gadgets.h"

#if HAVE_OPENSSL_OPENSSLV_H
#include <openssl/opensslv.h>
#endif
#include <string>

namespace Ssl
{
class Lock
{
public:
    explicit Lock(std::string const &filename); 
    ~Lock(); 
    void lock(); 
    void unlock(); 
    bool locked() const; 
    const char *name() const { return filename.c_str(); }
private:
    std::string filename;
#if _SQUID_WINDOWS_
    HANDLE hFile; 
#else
    int fd; 
#endif
};

class Locker
{
public:
    Locker(Lock &lock, const char  *aFileName, int lineNo);
    ~Locker();
private:
    bool weLocked; 
    Lock &lock; 
    const std::string fileName; 
    const int lineNo; 
};

#define Here __FILE__, __LINE__

class CertificateDb
{
public:
    enum Columns {
        cnlKey = 0, //< The key to use for storing/retrieving entries from DB.
        cnlExp_date,
        cnlRev_date,
        cnlSerial,
        cnlName,
        cnlNumber
    };

    class Row
    {
    public:
        Row();
        Row(char **row, size_t width);
        ~Row();
        void setValue(size_t number, char const * value); 
        char ** getRow(); 
        void reset(); 
    private:
        char **row; 
        size_t width; 
    };

    CertificateDb(std::string const & db_path, size_t aMax_db_size, size_t aFs_block_size);
    bool find(std::string const & key,  const Security::CertPointer &expectedOrig, Security::CertPointer & cert, Security::PrivateKeyPointer & pkey);
    bool purgeCert(std::string const & key);
    bool addCertAndPrivateKey(std::string const & useKey, const Security::CertPointer & cert, const Security::PrivateKeyPointer & pkey, const Security::CertPointer &orig);

    static void Create(std::string const & db_path);
    static void Check(std::string const & db_path, size_t max_db_size, size_t fs_block_size);
private:
    void load(); 
    void save(); 
    size_t size(); 
    void addSize(std::string const & filename);
    void subSize(std::string const & filename);
    size_t readSize(); 
    void writeSize(size_t db_size); 
    size_t getFileSize(std::string const & filename); 
    size_t rebuildSize(); 
    bool pure_find(std::string const & key, const Security::CertPointer & expectedOrig, Security::CertPointer & cert, Security::PrivateKeyPointer & pkey);

    void deleteRow(const char **row, int rowIndex); 
    bool deleteInvalidCertificate(); 
    bool deleteOldestCertificate(); 
    bool deleteByKey(std::string const & key); 
    bool hasRows() const; 

    static bool WriteEntry(const std::string &filename, const Security::CertPointer & cert, const Security::PrivateKeyPointer & pkey, const Security::CertPointer &orig);

    static bool ReadEntry(std::string filename, Security::CertPointer & cert, Security::PrivateKeyPointer & pkey, Security::CertPointer &orig);

    static void sq_TXT_DB_delete(TXT_DB *db, const char **row);
    static void sq_TXT_DB_delete_row(TXT_DB *db, int idx);

    static unsigned long index_serial_hash(const char **a);
    static int index_serial_cmp(const char **a, const char **b);
    static unsigned long index_name_hash(const char **a);
    static int index_name_cmp(const char **a, const char **b);

#if SQUID_USE_SSLLHASH_HACK
    static unsigned long index_serial_hash_LHASH_HASH(const void *a) {
        return index_serial_hash((const char **)a);
    }
    static int index_serial_cmp_LHASH_COMP(const void *arg1, const void *arg2) {
        return index_serial_cmp((const char **)arg1, (const char **)arg2);
    }
    static unsigned long index_name_hash_LHASH_HASH(const void *a) {
        return index_name_hash((const char **)a);
    }
    static int index_name_cmp_LHASH_COMP(const void *arg1, const void *arg2) {
        return index_name_cmp((const char **)arg1, (const char **)arg2);
    }
#else
    static IMPLEMENT_LHASH_HASH_FN(index_serial_hash,const char **)
    static IMPLEMENT_LHASH_COMP_FN(index_serial_cmp,const char **)
    static IMPLEMENT_LHASH_HASH_FN(index_name_hash,const char **)
    static IMPLEMENT_LHASH_COMP_FN(index_name_cmp,const char **)
#endif

    static const std::string db_file; 
    static const std::string cert_dir; 
    static const std::string size_file; 
    static const size_t min_db_size;

    const std::string db_path; 
    const std::string db_full; 
    const std::string cert_full; 
    const std::string size_full; 

    TXT_DB_Pointer db; 
    const size_t max_db_size; 
    const size_t fs_block_size; 
    mutable Lock dbLock;  
};

} // namespace Ssl
#endif // SQUID_SSL_CERTIFICATE_DB_H