2 Bacula(R) - The Network Backup Solution
4 Copyright (C) 2000-2017 Kern Sibbald
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.
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.
14 This notice must be preserved when any source code is
15 conveyed and/or propagated.
17 Bacula(R) is a registered trademark of Kern Sibbald.
20 * Catalog DB Interface class
22 * Written by Kern E. Sibbald
29 * These enums can be used to build queries that respects
30 * Bacula Restricted Consoles.
43 DB_ACL_LAST /* Keep last */
46 /* Turn the num to a bit field */
47 #define DB_ACL_BIT(x) (1<<x)
49 class BDB: public SMARTALLOC {
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_key; /* path name to the key file */
65 char *m_db_ssl_cert; /* path name to the certificate file */
66 char *m_db_ssl_ca; /* path name to the certificate authority file */
67 char *m_db_ssl_capath; /* path name to a directory that contains trusted SSL CA certificates in PEM format */
68 char *m_db_ssl_cipher; /* a list of permissible ciphers to use for SSL encryption */
69 bool m_disabled_batch_insert; /* explicitly disabled batch insert mode ? */
70 bool m_dedicated; /* is this connection dedicated? */
71 bool m_use_fatal_jmsg; /* use Jmsg(M_FATAL) after bad queries? */
72 bool m_connected; /* connection made to db */
73 bool m_have_batch_insert; /* have batch insert support ? */
76 int m_status; /* status */
77 int m_num_rows; /* number of rows returned by last query */
78 int m_num_fields; /* number of fields returned by last query */
79 int m_rows_size; /* size of malloced rows */
80 int m_fields_size; /* size of malloced fields */
81 int m_row_number; /* row number from xx_data_seek */
82 int m_field_number; /* field number from sql_field_seek */
83 SQL_ROW m_rows; /* defined rows */
84 SQL_FIELD *m_fields; /* defined fields */
85 bool m_allow_transactions; /* transactions allowed */
86 bool m_transaction; /* transaction started */
88 POOLMEM *cached_path; /* cached path name */
89 POOLMEM *cmd; /* SQL command string */
90 POOLMEM *errmsg; /* nicely edited error message */
91 POOLMEM *esc_name; /* Escaped file name */
92 POOLMEM *esc_obj; /* Escaped restore object */
93 POOLMEM *esc_path; /* Escaped path name */
94 POOLMEM *fname; /* Filename only */
95 POOLMEM *path; /* Path only */
96 POOLMEM *acl_where; /* Buffer for the ACL where part */
97 POOLMEM *acl_join; /* Buffer for the ACL join part */
98 uint32_t cached_path_id; /* cached path id */
99 int cached_path_len; /* length of cached path */
100 int changes; /* changes during transaction */
101 int fnl; /* file name length */
102 int pnl; /* path name length */
104 POOLMEM *acls[DB_ACL_LAST]; /* ACLs */
109 const char *get_db_name(void) { return m_db_name; };
110 const char *get_db_user(void) { return m_db_user; };
111 const bool is_connected(void) { return m_connected; };
112 const bool is_dedicated(void) { return m_dedicated; };
113 bool use_fatal_jmsg(void) { return m_use_fatal_jmsg; };
114 const bool batch_insert_available(void) { return m_have_batch_insert; };
115 void set_use_fatal_jmsg(bool val) { m_use_fatal_jmsg = val; };
116 void increment_refcount(void) { m_ref_count++; };
117 const int bdb_get_type_index(void) { return m_db_type; };
118 const char *bdb_get_engine_name(void);
120 BDB *bdb_clone_database_connection(JCR *jcr, bool mult_db_connections);
121 bool bdb_match_database(const char *db_driver, const char *db_name,
122 const char *bdb_address, int db_port);
123 bool bdb_sql_query(const char *query, int flags=0);
124 void bdb_lock(const char *file=__FILE__, int line=__LINE__);
125 void bdb_unlock(const char *file=__FILE__, int line=__LINE__);
126 void print_lock_info(FILE *fp);
129 bool UpdateDB(JCR *jcr, char *cmd, bool can_be_empty, const char *file=__FILE__, int line=__LINE__);
130 bool InsertDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
131 bool QueryDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
132 int DeleteDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
133 char *bdb_strerror() { return errmsg; };
134 bool bdb_check_version(JCR *jcr);
135 bool bdb_check_settings(JCR *jcr, int64_t *starttime, int val1, int64_t val2);
136 bool bdb_open_batch_connexion(JCR *jcr);
137 bool bdb_check_max_connections(JCR *jcr, uint32_t max_concurrent_jobs);
139 /* Acl parts for various SQL commands */
140 void free_acl(); /* Used internally, free acls tab */
141 void init_acl(); /* Used internally, initialize acls tab */
142 /* Take a alist of strings and turn it to an escaped sql IN () list */
143 char *escape_acl_list(JCR *jcr, POOLMEM **escape_list, alist *lst);
145 /* Used during the initialization, the UA code can call this function
146 * foreach kind of ACL
148 void set_acl(JCR *jcr, DB_ACL_t type, alist *lst, alist *lst2=NULL);
150 /* Get the SQL string that corresponds to the Console ACL for Pool, Job,
153 const char *get_acl(DB_ACL_t type, bool where);
155 /* Get the SQL string that corresponds to multiple ACLs (with DB_ACL_BIT) */
156 char *get_acls(int type, bool where);
158 /* Get the JOIN SQL string for various tables (with DB_ACL_BIT) */
159 char *get_acl_join_filter(int tables);
162 int bdb_delete_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
163 int bdb_delete_media_record(JCR *jcr, MEDIA_DBR *mr);
164 int bdb_purge_media_record(JCR *jcr, MEDIA_DBR *mr);
165 int bdb_delete_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
168 bool bdb_find_last_job_end_time(JCR *jcr, JOB_DBR *jr, POOLMEM **etime, char *job);
169 bool bdb_find_last_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job, int JobLevel);
170 bool bdb_find_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job);
171 bool bdb_find_last_jobid(JCR *jcr, const char *Name, JOB_DBR *jr);
172 int bdb_find_next_volume(JCR *jcr, int index, bool InChanger, MEDIA_DBR *mr);
173 bool bdb_find_failed_job_since(JCR *jcr, JOB_DBR *jr, POOLMEM *stime, int &JobLevel);
176 int bdb_create_path_record(JCR *jcr, ATTR_DBR *ar);
177 bool bdb_create_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
178 bool bdb_create_job_record(JCR *jcr, JOB_DBR *jr);
179 int bdb_create_media_record(JCR *jcr, MEDIA_DBR *media_dbr);
180 int bdb_create_client_record(JCR *jcr, CLIENT_DBR *cr);
181 bool bdb_create_fileset_record(JCR *jcr, FILESET_DBR *fsr);
182 bool bdb_create_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
183 bool bdb_create_jobmedia_record(JCR *jcr, JOBMEDIA_DBR *jr);
184 int bdb_create_counter_record(JCR *jcr, COUNTER_DBR *cr);
185 bool bdb_create_device_record(JCR *jcr, DEVICE_DBR *dr);
186 bool bdb_create_storage_record(JCR *jcr, STORAGE_DBR *sr);
187 bool bdb_create_mediatype_record(JCR *jcr, MEDIATYPE_DBR *mr);
188 bool bdb_create_attributes_record(JCR *jcr, ATTR_DBR *ar);
189 bool bdb_create_restore_object_record(JCR *jcr, ROBJECT_DBR *ar);
190 bool bdb_create_base_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
191 bool bdb_commit_base_file_attributes_record(JCR *jcr);
192 bool bdb_create_base_file_list(JCR *jcr, char *jobids);
193 bool bdb_create_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
194 int bdb_create_file_record(JCR *jcr, ATTR_DBR *ar);
195 int bdb_create_filename_record(JCR *jcr, ATTR_DBR *ar);
196 bool bdb_create_batch_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
199 bool bdb_get_file_record(JCR *jcr, JOB_DBR *jr, FILE_DBR *fdbr);
200 bool bdb_get_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
201 bool bdb_get_volume_jobids(JCR *jcr,
202 MEDIA_DBR *mr, db_list_ctx *lst);
203 bool bdb_get_base_file_list(JCR *jcr, bool use_md5,
204 DB_RESULT_HANDLER *result_handler,void *ctx);
205 int bdb_get_filename_record(JCR *jcr);
206 int bdb_get_path_record(JCR *jcr);
207 bool bdb_get_pool_record(JCR *jcr, POOL_DBR *pdbr);
208 bool bdb_get_pool_numvols(JCR *jcr, POOL_DBR *pdbr);
209 int bdb_get_client_record(JCR *jcr, CLIENT_DBR *cr);
210 bool bdb_get_job_record(JCR *jcr, JOB_DBR *jr);
211 int bdb_get_job_volume_names(JCR *jcr, JobId_t JobId, POOLMEM **VolumeNames);
212 bool bdb_get_file_attributes_record(JCR *jcr, char *fname, JOB_DBR *jr, FILE_DBR *fdbr);
213 int bdb_get_fileset_record(JCR *jcr, FILESET_DBR *fsr);
214 bool bdb_get_media_record(JCR *jcr, MEDIA_DBR *mr);
215 int bdb_get_num_media_records(JCR *jcr);
216 int bdb_get_num_pool_records(JCR *jcr);
217 int bdb_get_pool_ids(JCR *jcr, int *num_ids, DBId_t **ids);
218 int bdb_get_client_ids(JCR *jcr, int *num_ids, DBId_t **ids);
219 bool bdb_get_media_ids(JCR *jcr, MEDIA_DBR *mr, int *num_ids, uint32_t **ids);
220 int bdb_get_job_volume_parameters(JCR *jcr, JobId_t JobId, VOL_PARAMS **VolParams);
221 bool bdb_get_counter_record(JCR *jcr, COUNTER_DBR *cr);
222 bool bdb_get_query_dbids(JCR *jcr, POOL_MEM &query, dbid_list &ids);
223 bool bdb_get_file_list(JCR *jcr, char *jobids,
224 bool use_md5, bool use_delta,
225 DB_RESULT_HANDLER *result_handler, void *ctx);
226 bool bdb_get_base_jobid(JCR *jcr, JOB_DBR *jr, JobId_t *jobid);
227 bool bdb_get_accurate_jobids(JCR *jcr, JOB_DBR *jr, db_list_ctx *jobids);
228 bool bdb_get_used_base_jobids(JCR *jcr, POOLMEM *jobids, db_list_ctx *result);
229 bool bdb_get_restoreobject_record(JCR *jcr, ROBJECT_DBR *rr);
230 bool bdb_get_job_statistics(JCR *jcr, JOB_DBR *jr);
233 void bdb_list_pool_records(JCR *jcr, POOL_DBR *pr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
234 alist *bdb_list_job_records(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
235 void bdb_list_job_totals(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
236 void bdb_list_files_for_job(JCR *jcr, uint32_t jobid, int deleted, DB_LIST_HANDLER sendit, void *ctx);
237 void bdb_list_media_records(JCR *jcr, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
238 void bdb_list_jobmedia_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
239 void bdb_list_joblog_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
240 int bdb_list_sql_query(JCR *jcr, const char *query, DB_LIST_HANDLER *sendit, void *ctx, int verbose, e_list_type type);
241 void bdb_list_client_records(JCR *jcr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
242 void bdb_list_copies_records(JCR *jcr, uint32_t limit, char *jobids, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
243 void bdb_list_base_files_for_job(JCR *jcr, JobId_t jobid, DB_LIST_HANDLER *sendit, void *ctx);
244 void bdb_list_restore_objects(JCR *jcr, ROBJECT_DBR *rr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
245 void bdb_list_snapshot_records(JCR *jcr, SNAPSHOT_DBR *sdbr,
246 DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
250 bool bdb_update_job_start_record(JCR *jcr, JOB_DBR *jr);
251 int bdb_update_job_end_record(JCR *jcr, JOB_DBR *jr);
252 int bdb_update_client_record(JCR *jcr, CLIENT_DBR *cr);
253 int bdb_update_pool_record(JCR *jcr, POOL_DBR *pr);
254 bool bdb_update_storage_record(JCR *jcr, STORAGE_DBR *sr);
255 int bdb_update_media_record(JCR *jcr, MEDIA_DBR *mr);
256 int bdb_update_media_defaults(JCR *jcr, MEDIA_DBR *mr);
257 int bdb_update_counter_record(JCR *jcr, COUNTER_DBR *cr);
258 int bdb_add_digest_to_file_record(JCR *jcr, FileId_t FileId, char *digest, int type);
259 int bdb_mark_file_record(JCR *jcr, FileId_t FileId, JobId_t JobId);
260 void bdb_make_inchanger_unique(JCR *jcr, MEDIA_DBR *mr);
261 int bdb_update_stats(JCR *jcr, utime_t age);
262 bool bdb_update_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
264 /* Pure virtual low level methods */
265 virtual void bdb_escape_string(JCR *jcr, char *snew, char *old, int len) = 0;
266 virtual char *bdb_escape_object(JCR *jcr, char *old, int len) = 0;
267 virtual void bdb_unescape_object(JCR *jcr, char *from, int32_t expected_len,
268 POOLMEM **dest, int32_t *len) = 0;
269 virtual bool bdb_open_database(JCR *jcr) = 0;
270 virtual void bdb_close_database(JCR *jcr) = 0;
271 virtual void bdb_start_transaction(JCR *jcr) = 0;
272 virtual void bdb_end_transaction(JCR *jcr) = 0;
273 virtual bool bdb_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx) = 0;
274 virtual void bdb_thread_cleanup(void) = 0;
276 /* By default, we use bdb_sql_query */
277 virtual bool bdb_big_sql_query(const char *query,
278 DB_RESULT_HANDLER *result_handler, void *ctx) {
279 return bdb_sql_query(query, result_handler, ctx);
283 #ifdef CATS_PRIVATE_DBI
284 int sql_num_rows(void) { return m_num_rows; };
285 void sql_field_seek(int field) { m_field_number = field; };
286 int sql_num_fields(void) { return m_num_fields; };
287 virtual void sql_free_result(void) = 0;
288 virtual SQL_ROW sql_fetch_row(void) = 0;
289 virtual bool sql_query(const char *query, int flags=0) = 0;
290 virtual const char *sql_strerror(void) = 0;
291 virtual void sql_data_seek(int row) = 0;
292 virtual int sql_affected_rows(void) = 0;
293 virtual uint64_t sql_insert_autokey_record(const char *query, const char *table_name) = 0;
294 virtual SQL_FIELD *sql_fetch_field(void) = 0;
295 virtual bool sql_field_is_not_null(int field_type) = 0;
296 virtual bool sql_field_is_numeric(int field_type) = 0;
297 virtual bool sql_batch_start(JCR *jcr) = 0;
298 virtual bool sql_batch_end(JCR *jcr, const char *error) = 0;
299 virtual bool sql_batch_insert(JCR *jcr, ATTR_DBR *ar) = 0;
303 #endif /* __Bbdb_H_ */