git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/bdb.h

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2017 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  *  Catalog DB Interface class
  21  *
  22  *  Written by Kern E. Sibbald
  23  */
  24
  25 #ifndef __BDB_H_
  26 #define __BDB_H_ 1
  27
  28 /*
  29  * These enums can be used to build queries that respects
  30  * Bacula Restricted Consoles.
  31  */
  32 typedef enum
  33 {
  34    DB_ACL_JOB      = 1,
  35    DB_ACL_CLIENT,
  36    DB_ACL_STORAGE,
  37    DB_ACL_POOL,
  38    DB_ACL_FILESET,
  39    DB_ACL_RCLIENT,
  40    DB_ACL_BCLIENT,
  41    DB_ACL_PATH,
  42    DB_ACL_LOG,
  43    DB_ACL_LAST                  /* Keep last */
  44 } DB_ACL_t;
  45
  46 /* Turn the num to a bit field */
  47 #define DB_ACL_BIT(x) (1<<x)
  48
  49 class BDB: public SMARTALLOC {
  50 public:
  51    dlink m_link;                      /* queue control */
  52    brwlock_t m_lock;                  /* transaction lock */
  53    SQL_DRIVER m_db_driver_type;       /* driver type */
  54    SQL_DBTYPE m_db_type;              /* database type */
  55    char *m_db_name;                   /* database name */
  56    char *m_db_user;                   /* database user */
  57    char *m_db_address;                /* host name address */
  58    char *m_db_socket;                 /* socket for local access */
  59    char *m_db_password;               /* database password */
  60    char *m_db_driver;                 /* database driver */
  61    char *m_db_driverdir;              /* database driver dir */
  62    int m_ref_count;                   /* reference count */
  63    int m_db_port;                     /* port for host name address */
  64    char *m_db_ssl_mode;               /* security mode of the connection to the server */
  65    char *m_db_ssl_key;                /* path name to the key file */
  66    char *m_db_ssl_cert;               /* path name to the certificate file */
  67    char *m_db_ssl_ca;                 /* path name to the certificate authority file */
  68    char *m_db_ssl_capath;             /* path name to a directory that contains trusted SSL CA certificates in PEM format */
  69    char *m_db_ssl_cipher;             /* a list of permissible ciphers to use for SSL encryption */
  70    bool m_disabled_batch_insert;      /* explicitly disabled batch insert mode ? */
  71    bool m_dedicated;                  /* is this connection dedicated? */
  72    bool m_use_fatal_jmsg;             /* use Jmsg(M_FATAL) after bad queries? */
  73    bool m_connected;                  /* connection made to db */
  74    bool m_have_batch_insert;          /* have batch insert support ? */
  75
  76    /* Cats Internal */
  77    int m_status;                      /* status */
  78    int m_num_rows;                    /* number of rows returned by last query */
  79    int m_num_fields;                  /* number of fields returned by last query */
  80    int m_rows_size;                   /* size of malloced rows */
  81    int m_fields_size;                 /* size of malloced fields */
  82    int m_row_number;                  /* row number from xx_data_seek */
  83    int m_field_number;                /* field number from sql_field_seek */
  84    SQL_ROW m_rows;                    /* defined rows */
  85    SQL_FIELD *m_fields;               /* defined fields */
  86    bool m_allow_transactions;         /* transactions allowed */
  87    bool m_transaction;                /* transaction started */
  88
  89    POOLMEM *cached_path;              /* cached path name */
  90    POOLMEM *cmd;                      /* SQL command string */
  91    POOLMEM *errmsg;                   /* nicely edited error message */
  92    POOLMEM *esc_name;                 /* Escaped file name */
  93    POOLMEM *esc_obj;                  /* Escaped restore object */
  94    POOLMEM *esc_path;                 /* Escaped path name */
  95    POOLMEM *fname;                    /* Filename only */
  96    POOLMEM *path;                     /* Path only */
  97    POOLMEM *acl_where;                /* Buffer for the ACL where part */
  98    POOLMEM *acl_join;                 /* Buffer for the ACL join part */
  99    uint32_t cached_path_id;           /* cached path id */
 100    int cached_path_len;               /* length of cached path */
 101    int changes;                       /* changes during transaction */
 102    int fnl;                           /* file name length */
 103    int pnl;                           /* path name length */
 104
 105    POOLMEM *acls[DB_ACL_LAST];        /* ACLs */
 106
 107    /* methods */
 108    BDB();
 109    virtual ~BDB();
 110    const char *get_db_name(void) { return m_db_name; };
 111    const char *get_db_user(void) { return m_db_user; };
 112    const bool is_connected(void) { return m_connected; };
 113    const bool is_dedicated(void) { return m_dedicated; };
 114    bool use_fatal_jmsg(void) { return m_use_fatal_jmsg; };
 115    const bool batch_insert_available(void) { return m_have_batch_insert; };
 116    void set_use_fatal_jmsg(bool val) { m_use_fatal_jmsg = val; };
 117    void increment_refcount(void) { m_ref_count++; };
 118    const int bdb_get_type_index(void) { return m_db_type; };
 119    const char *bdb_get_engine_name(void);
 120
 121    BDB *bdb_clone_database_connection(JCR *jcr, bool mult_db_connections);
 122    bool bdb_match_database(const char *db_driver, const char *db_name,
 123             const char *bdb_address, int db_port);
 124    bool bdb_sql_query(const char *query, int flags=0);
 125    void bdb_lock(const char *file=__FILE__, int line=__LINE__);
 126    void bdb_unlock(const char *file=__FILE__, int line=__LINE__);
 127    void print_lock_info(FILE *fp);
 128
 129    /* sql.c */
 130    bool UpdateDB(JCR *jcr, char *cmd, bool can_be_empty, const char *file=__FILE__, int line=__LINE__);
 131    bool InsertDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 132    bool QueryDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 133    int  DeleteDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 134    char *bdb_strerror() { return errmsg; };
 135    bool bdb_check_version(JCR *jcr);
 136    bool bdb_check_settings(JCR *jcr, int64_t *starttime, int val1, int64_t val2);
 137    bool bdb_open_batch_connexion(JCR *jcr);
 138    bool bdb_check_max_connections(JCR *jcr, uint32_t max_concurrent_jobs);
 139
 140    /* Acl parts for various SQL commands */
 141    void  free_acl();             /* Used internally, free acls tab */
 142    void  init_acl();             /* Used internally, initialize acls tab */
 143    /* Take a alist of strings and turn it to an escaped sql IN () list  */
 144    char *escape_acl_list(JCR *jcr, POOLMEM **escape_list, alist *lst);
 145
 146    /* Used during the initialization, the UA code can call this function
 147     * foreach kind of ACL
 148     */
 149    void  set_acl(JCR *jcr, DB_ACL_t type, alist *lst, alist *lst2=NULL);
 150
 151    /* Get the SQL string that corresponds to the Console ACL for Pool, Job,
 152     * Client, ...
 153     */
 154    const char *get_acl(DB_ACL_t type, bool where);
 155
 156    /* Get the SQL string that corresponds to multiple ACLs (with DB_ACL_BIT) */
 157    char *get_acls(int type, bool where);
 158
 159    /* Get the JOIN SQL string for various tables (with DB_ACL_BIT) */
 160    char *get_acl_join_filter(int tables);
 161
 162    /* sql_delete.c */
 163    int bdb_delete_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
 164    int bdb_delete_media_record(JCR *jcr, MEDIA_DBR *mr);
 165    int bdb_purge_media_record(JCR *jcr, MEDIA_DBR *mr);
 166    int bdb_delete_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
 167
 168    /* sql_find.c */
 169    bool bdb_find_last_job_end_time(JCR *jcr, JOB_DBR *jr, POOLMEM **etime, char *job);
 170    bool bdb_find_last_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job, int JobLevel);
 171    bool bdb_find_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job);
 172    bool bdb_find_last_jobid(JCR *jcr, const char *Name, JOB_DBR *jr);
 173    int bdb_find_next_volume(JCR *jcr, int index, bool InChanger, MEDIA_DBR *mr);
 174    bool bdb_find_failed_job_since(JCR *jcr, JOB_DBR *jr, POOLMEM *stime, int &JobLevel);
 175
 176    /* sql_create.c */
 177    int bdb_create_path_record(JCR *jcr, ATTR_DBR *ar);
 178    bool bdb_create_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 179    bool bdb_create_job_record(JCR *jcr, JOB_DBR *jr);
 180    int bdb_create_media_record(JCR *jcr, MEDIA_DBR *media_dbr);
 181    int bdb_create_client_record(JCR *jcr, CLIENT_DBR *cr);
 182    bool bdb_create_fileset_record(JCR *jcr, FILESET_DBR *fsr);
 183    bool bdb_create_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
 184    bool bdb_create_jobmedia_record(JCR *jcr, JOBMEDIA_DBR *jr);
 185    int bdb_create_counter_record(JCR *jcr, COUNTER_DBR *cr);
 186    bool bdb_create_device_record(JCR *jcr, DEVICE_DBR *dr);
 187    bool bdb_create_storage_record(JCR *jcr, STORAGE_DBR *sr);
 188    bool bdb_create_mediatype_record(JCR *jcr, MEDIATYPE_DBR *mr);
 189    bool bdb_create_attributes_record(JCR *jcr, ATTR_DBR *ar);
 190    bool bdb_create_restore_object_record(JCR *jcr, ROBJECT_DBR *ar);
 191    bool bdb_create_base_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 192    bool bdb_commit_base_file_attributes_record(JCR *jcr);
 193    bool bdb_create_base_file_list(JCR *jcr, char *jobids);
 194    bool bdb_create_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
 195    int bdb_create_file_record(JCR *jcr, ATTR_DBR *ar);
 196    int bdb_create_filename_record(JCR *jcr, ATTR_DBR *ar);
 197    bool bdb_create_batch_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 198
 199    /* sql_get.c */
 200    bool bdb_get_file_record(JCR *jcr, JOB_DBR *jr, FILE_DBR *fdbr);
 201    bool bdb_get_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
 202    bool bdb_get_volume_jobids(JCR *jcr,
 203             MEDIA_DBR *mr, db_list_ctx *lst);
 204    bool bdb_get_base_file_list(JCR *jcr, bool use_md5,
 205             DB_RESULT_HANDLER *result_handler,void *ctx);
 206    int bdb_get_filename_record(JCR *jcr);
 207    int bdb_get_path_record(JCR *jcr);
 208    bool bdb_get_pool_record(JCR *jcr, POOL_DBR *pdbr);
 209    bool bdb_get_pool_numvols(JCR *jcr, POOL_DBR *pdbr);
 210    int bdb_get_client_record(JCR *jcr, CLIENT_DBR *cr);
 211    bool bdb_get_job_record(JCR *jcr, JOB_DBR *jr);
 212    int bdb_get_job_volume_names(JCR *jcr, JobId_t JobId, POOLMEM **VolumeNames);
 213    bool bdb_get_file_attributes_record(JCR *jcr, char *fname, JOB_DBR *jr, FILE_DBR *fdbr);
 214    int bdb_get_fileset_record(JCR *jcr, FILESET_DBR *fsr);
 215    bool bdb_get_media_record(JCR *jcr, MEDIA_DBR *mr);
 216    int bdb_get_num_media_records(JCR *jcr);
 217    int bdb_get_num_pool_records(JCR *jcr);
 218    int bdb_get_pool_ids(JCR *jcr, int *num_ids, DBId_t **ids);
 219    int bdb_get_client_ids(JCR *jcr, int *num_ids, DBId_t **ids);
 220    bool bdb_get_media_ids(JCR *jcr, MEDIA_DBR *mr, int *num_ids, uint32_t **ids);
 221    int  bdb_get_job_volume_parameters(JCR *jcr, JobId_t JobId, VOL_PARAMS **VolParams);
 222    bool bdb_get_counter_record(JCR *jcr, COUNTER_DBR *cr);
 223    bool bdb_get_query_dbids(JCR *jcr, POOL_MEM &query, dbid_list &ids);
 224    bool bdb_get_file_list(JCR *jcr, char *jobids,
 225             bool use_md5, bool use_delta,
 226             DB_RESULT_HANDLER *result_handler, void *ctx);
 227    bool bdb_get_base_jobid(JCR *jcr, JOB_DBR *jr, JobId_t *jobid);
 228    bool bdb_get_accurate_jobids(JCR *jcr, JOB_DBR *jr, db_list_ctx *jobids);
 229    bool bdb_get_used_base_jobids(JCR *jcr, POOLMEM *jobids, db_list_ctx *result);
 230    bool bdb_get_restoreobject_record(JCR *jcr, ROBJECT_DBR *rr);
 231    bool bdb_get_job_statistics(JCR *jcr, JOB_DBR *jr);
 232
 233 /* sql_list.c */
 234    void bdb_list_pool_records(JCR *jcr, POOL_DBR *pr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
 235    alist *bdb_list_job_records(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
 236    void bdb_list_job_totals(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
 237    void bdb_list_files_for_job(JCR *jcr, uint32_t jobid, int deleted, DB_LIST_HANDLER sendit, void *ctx);
 238    void bdb_list_media_records(JCR *jcr, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 239    void bdb_list_jobmedia_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 240    void bdb_list_joblog_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 241    int  bdb_list_sql_query(JCR *jcr, const char *query, DB_LIST_HANDLER *sendit, void *ctx, int verbose, e_list_type type);
 242    void bdb_list_client_records(JCR *jcr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 243    void bdb_list_copies_records(JCR *jcr, uint32_t limit, char *jobids, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 244    void bdb_list_base_files_for_job(JCR *jcr, JobId_t jobid, DB_LIST_HANDLER *sendit, void *ctx);
 245    void bdb_list_restore_objects(JCR *jcr, ROBJECT_DBR *rr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 246    void bdb_list_snapshot_records(JCR *jcr, SNAPSHOT_DBR *sdbr,
 247               DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 248
 249
 250    /* sql_update.c */
 251    bool bdb_update_job_start_record(JCR *jcr, JOB_DBR *jr);
 252    int  bdb_update_job_end_record(JCR *jcr, JOB_DBR *jr);
 253    int  bdb_update_client_record(JCR *jcr, CLIENT_DBR *cr);
 254    int  bdb_update_pool_record(JCR *jcr, POOL_DBR *pr);
 255    bool bdb_update_storage_record(JCR *jcr, STORAGE_DBR *sr);
 256    int  bdb_update_media_record(JCR *jcr, MEDIA_DBR *mr);
 257    int  bdb_update_media_defaults(JCR *jcr, MEDIA_DBR *mr);
 258    int  bdb_update_counter_record(JCR *jcr, COUNTER_DBR *cr);
 259    int  bdb_add_digest_to_file_record(JCR *jcr, FileId_t FileId, char *digest, int type);
 260    int  bdb_mark_file_record(JCR *jcr, FileId_t FileId, JobId_t JobId);
 261    void bdb_make_inchanger_unique(JCR *jcr, MEDIA_DBR *mr);
 262    int  bdb_update_stats(JCR *jcr, utime_t age);
 263    bool bdb_update_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
 264
 265    /* Pure virtual low level methods */
 266    virtual void bdb_escape_string(JCR *jcr, char *snew, char *old, int len) = 0;
 267    virtual char *bdb_escape_object(JCR *jcr, char *old, int len) = 0;
 268    virtual void bdb_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 269                    POOLMEM **dest, int32_t *len) = 0;
 270    virtual bool bdb_open_database(JCR *jcr) = 0;
 271    virtual void bdb_close_database(JCR *jcr) = 0;
 272    virtual void bdb_start_transaction(JCR *jcr) = 0;
 273    virtual void bdb_end_transaction(JCR *jcr) = 0;
 274    virtual bool bdb_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx) = 0;
 275    virtual void bdb_thread_cleanup(void) = 0;
 276
 277    /* By default, we use bdb_sql_query */
 278    virtual bool bdb_big_sql_query(const char *query,
 279                    DB_RESULT_HANDLER *result_handler, void *ctx) {
 280       return bdb_sql_query(query, result_handler, ctx);
 281    };
 282
 283    /* Cats Internal */
 284 #ifdef CATS_PRIVATE_DBI
 285    int sql_num_rows(void) { return m_num_rows; };
 286    void sql_field_seek(int field) { m_field_number = field; };
 287    int sql_num_fields(void) { return m_num_fields; };
 288    virtual void sql_free_result(void) = 0;
 289    virtual SQL_ROW sql_fetch_row(void) = 0;
 290    virtual bool sql_query(const char *query, int flags=0) = 0;
 291    virtual const char *sql_strerror(void) = 0;
 292    virtual void sql_data_seek(int row) = 0;
 293    virtual int sql_affected_rows(void) = 0;
 294    virtual uint64_t sql_insert_autokey_record(const char *query, const char *table_name) = 0;
 295    virtual SQL_FIELD *sql_fetch_field(void) = 0;
 296    virtual bool sql_field_is_not_null(int field_type) = 0;
 297    virtual bool sql_field_is_numeric(int field_type) = 0;
 298    virtual bool sql_batch_start(JCR *jcr) = 0;
 299    virtual bool sql_batch_end(JCR *jcr, const char *error) = 0;
 300    virtual bool sql_batch_insert(JCR *jcr, ATTR_DBR *ar) = 0;
 301 #endif
 302 };
 303
 304 #endif /* __Bbdb_H_ */