certificate_db.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_CERT_GENERATORS_FILE_CERTIFICATE_DB_H
#define SQUID_SRC_SECURITY_CERT_GENERATORS_FILE_CERTIFICATE_DB_H
 
#include "base/Here.h"
#include "ssl/gadgets.h"
 
#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 &, const SourceLocation &);
    ~Locker();
private:
    bool weLocked; 
    Lock &lock; 
 
    const SourceLocation caller;
};
 
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_SRC_SECURITY_CERT_GENERATORS_FILE_CERTIFICATE_DB_H */