- blocksize recognition code.
For 1.29 release:
+- Zap sd_auth_key after use
- Priority job to go to top of list.
- Add Bar code reading capabilities (new mtx-changer)
- Add include list to end of chain in findlib
/*
- Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
+ Copyright (C) 2000-2003 Kern Sibbald and John Walker
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
}
}
Dmsg0(200, "db_open first time\n");
- mdb = (B_DB *) malloc(sizeof(B_DB));
+ mdb = (B_DB *)malloc(sizeof(B_DB));
memset(mdb, 0, sizeof(B_DB));
Dmsg0(200, "DB struct init\n");
mdb->db_name = bstrdup(db_name);
qinsert(&db_list, &mdb->bq); /* put db in list */
Dmsg0(200, "Done db_open_database()\n");
mdb->cfd = -1;
- mdb->jcr = jcr;
V(mutex);
return mdb;
}
* which are returned in the errmsg
*/
int
-db_open_database(B_DB *mdb)
+db_open_database(void *jcr, B_DB *mdb)
{
char *dbf;
int fd, badctl;
return 1;
}
-void db_close_database(B_DB *mdb)
+void db_close_database(void *jcr, B_DB *mdb)
{
P(mutex);
mdb->ref_count--;
* much more efficient. Usually started when inserting
* file attributes.
*/
-void db_start_transaction(B_DB *mdb)
+void db_start_transaction(void *jcr, B_DB *mdb)
{
}
-void db_end_transaction(B_DB *mdb)
+void db_end_transaction(void *jcr, B_DB *mdb)
{
}
uint32_t cached_path_id; /* cached path id */
int transaction; /* transaction started */
int changes; /* changes during transaction */
- void *jcr; /* JCR or NULL */
POOLMEM *fname; /* Filename only */
POOLMEM *path; /* Path only */
POOLMEM *esc_name; /* Escaped file/path name */
int cached_path_len; /* length of cached path */
uint32_t cached_path_id;
int changes; /* changes made to db */
- void *jcr; /* JCR or NULL */
POOLMEM *fname; /* Filename only */
POOLMEM *path; /* Path only */
POOLMEM *esc_name; /* Escaped file/path name */
POOLMEM *cached_path;
int cached_path_len; /* length of cached path */
uint32_t cached_path_id;
- void *jcr; /* JCR or NULL */
} B_DB;
#endif /* HAVE_MYSQL */
#endif /* HAVE_SQLITE */
/* Use for better error location printing */
-#define UPDATE_DB(db, cmd) UpdateDB(__FILE__, __LINE__, db, cmd)
-#define INSERT_DB(db, cmd) InsertDB(__FILE__, __LINE__, db, cmd)
-#define QUERY_DB(db, cmd) QueryDB(__FILE__, __LINE__, db, cmd)
-#define DELETE_DB(db, cmd) DeleteDB(__FILE__, __LINE__, db, cmd)
+#define UPDATE_DB(jcr, db, cmd) UpdateDB(__FILE__, __LINE__, jcr, db, cmd)
+#define INSERT_DB(jcr, db, cmd) InsertDB(__FILE__, __LINE__, jcr, db, cmd)
+#define QUERY_DB(jcr, db, cmd) QueryDB(__FILE__, __LINE__, jcr, db, cmd)
+#define DELETE_DB(jcr, db, cmd) DeleteDB(__FILE__, __LINE__, jcr, db, cmd)
#else /* not __SQL_C */
mdb->path = get_pool_memory(PM_FNAME);
mdb->esc_name = get_pool_memory(PM_FNAME);
qinsert(&db_list, &mdb->bq); /* put db in list */
- mdb->jcr = jcr;
V(mutex);
return mdb;
}
* which are returned in the errmsg
*/
int
-db_open_database(B_DB *mdb)
+db_open_database(void *jcr, B_DB *mdb)
{
int errstat;
return 0;
}
- if (!check_tables_version(mdb)) {
+ if (!check_tables_version(jcr, mdb)) {
V(mutex);
return 0;
}
}
void
-db_close_database(B_DB *mdb)
+db_close_database(void *jcr, B_DB *mdb)
{
P(mutex);
mdb->ref_count--;
* For MySQL, NULL causes the auto-increment value
* to be updated.
*/
-int db_next_index(B_DB *mdb, char *table, char *index)
+int db_next_index(void *jcr, B_DB *mdb, char *table, char *index)
{
strcpy(index, "NULL");
return 1;
/* sql.c */
B_DB *db_init_database(void *jcr, char *db_name, char *db_user, char *db_password);
-int db_open_database(B_DB *db);
-void db_close_database(B_DB *db);
+int db_open_database(void *jcr, B_DB *db);
+void db_close_database(void *jcr, B_DB *db);
void db_escape_string(char *snew, char *old, int len);
char *db_strerror(B_DB *mdb);
-int get_sql_record_max(B_DB *mdb);
-int db_next_index(B_DB *mdb, char *table, char *index);
+int get_sql_record_max(void *jcr, B_DB *mdb);
+int db_next_index(void *jcr, B_DB *mdb, char *table, char *index);
int db_sql_query(B_DB *mdb, char *cmd, DB_RESULT_HANDLER *result_handler, void *ctx);
-int check_tables_version(B_DB *mdb);
+int check_tables_version(void *jcr, B_DB *mdb);
void _db_unlock(char *file, int line, B_DB *mdb);
void _db_lock(char *file, int line, B_DB *mdb);
-void db_start_transaction(B_DB *mdb);
-void db_end_transaction(B_DB *mdb);
+void db_start_transaction(void *jcr, B_DB *mdb);
+void db_end_transaction(void *jcr, B_DB *mdb);
/* create.c */
-int db_create_file_attributes_record(B_DB *mdb, ATTR_DBR *ar);
-int db_create_job_record(B_DB *db, JOB_DBR *jr);
-int db_create_media_record(B_DB *db, MEDIA_DBR *media_dbr);
-int db_create_client_record(B_DB *db, CLIENT_DBR *cr);
-int db_create_fileset_record(B_DB *db, FILESET_DBR *fsr);
-int db_create_pool_record(B_DB *db, POOL_DBR *pool_dbr);
-int db_create_jobmedia_record(B_DB *mdb, JOBMEDIA_DBR *jr);
+int db_create_file_attributes_record(void *jcr, B_DB *mdb, ATTR_DBR *ar);
+int db_create_job_record(void *jcr, B_DB *db, JOB_DBR *jr);
+int db_create_media_record(void *jcr, B_DB *db, MEDIA_DBR *media_dbr);
+int db_create_client_record(void *jcr, B_DB *db, CLIENT_DBR *cr);
+int db_create_fileset_record(void *jcr, B_DB *db, FILESET_DBR *fsr);
+int db_create_pool_record(void *jcr, B_DB *db, POOL_DBR *pool_dbr);
+int db_create_jobmedia_record(void *jcr, B_DB *mdb, JOBMEDIA_DBR *jr);
/* delete.c */
-int db_delete_pool_record(B_DB *db, POOL_DBR *pool_dbr);
-int db_delete_media_record(B_DB *mdb, MEDIA_DBR *mr);
+int db_delete_pool_record(void *jcr, B_DB *db, POOL_DBR *pool_dbr);
+int db_delete_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr);
/* find.c */
-int db_find_job_start_time(B_DB *mdb, JOB_DBR *jr, POOLMEM **stime);
-int db_find_last_jobid(B_DB *mdb, JOB_DBR *jr);
-int db_find_next_volume(B_DB *mdb, int index, MEDIA_DBR *mr);
+int db_find_job_start_time(void *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM **stime);
+int db_find_last_jobid(void *jcr, B_DB *mdb, JOB_DBR *jr);
+int db_find_next_volume(void *jcr, B_DB *mdb, int index, MEDIA_DBR *mr);
/* get.c */
-int db_get_pool_record(B_DB *db, POOL_DBR *pdbr);
-int db_get_client_record(B_DB *mdb, CLIENT_DBR *cr);
-int db_get_job_record(B_DB *mdb, JOB_DBR *jr);
-int db_get_job_volume_names(B_DB *mdb, uint32_t JobId, POOLMEM **VolumeNames);
-int db_get_file_attributes_record(B_DB *mdb, char *fname, FILE_DBR *fdbr);
-int db_get_fileset_record(B_DB *mdb, FILESET_DBR *fsr);
-int db_get_media_record(B_DB *mdb, MEDIA_DBR *mr);
-int db_get_num_media_records(B_DB *mdb);
-int db_get_num_pool_records(B_DB *mdb);
-int db_get_pool_ids(B_DB *mdb, int *num_ids, uint32_t **ids);
-int db_get_client_ids(B_DB *mdb, int *num_ids, uint32_t **ids);
-int db_get_media_ids(B_DB *mdb, int *num_ids, uint32_t **ids);
-int db_get_job_volume_parameters(B_DB *mdb, uint32_t JobId, VOL_PARAMS **VolParams);
-int db_get_client_record(B_DB *mdb, CLIENT_DBR *cdbr);
+int db_get_pool_record(void *jcr, B_DB *db, POOL_DBR *pdbr);
+int db_get_client_record(void *jcr, B_DB *mdb, CLIENT_DBR *cr);
+int db_get_job_record(void *jcr, B_DB *mdb, JOB_DBR *jr);
+int db_get_job_volume_names(void *jcr, B_DB *mdb, uint32_t JobId, POOLMEM **VolumeNames);
+int db_get_file_attributes_record(void *jcr, B_DB *mdb, char *fname, FILE_DBR *fdbr);
+int db_get_fileset_record(void *jcr, B_DB *mdb, FILESET_DBR *fsr);
+int db_get_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr);
+int db_get_num_media_records(void *jcr, B_DB *mdb);
+int db_get_num_pool_records(void *jcr, B_DB *mdb);
+int db_get_pool_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t **ids);
+int db_get_client_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t **ids);
+int db_get_media_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t **ids);
+int db_get_job_volume_parameters(void *jcr, B_DB *mdb, uint32_t JobId, VOL_PARAMS **VolParams);
+int db_get_client_record(void *jcr, B_DB *mdb, CLIENT_DBR *cdbr);
/* list.c */
-void db_list_pool_records(B_DB *db, DB_LIST_HANDLER sendit, void *ctx);
-void db_list_job_records(B_DB *db, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
-void db_list_job_totals(B_DB *db, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
-void db_list_files_for_job(B_DB *db, uint32_t jobid, DB_LIST_HANDLER sendit, void *ctx);
-void db_list_media_records(B_DB *mdb, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx);
-void db_list_jobmedia_records(B_DB *mdb, uint32_t JobId, DB_LIST_HANDLER *sendit, void *ctx);
-int db_list_sql_query(B_DB *mdb, char *query, DB_LIST_HANDLER *sendit, void *ctx, int verbose);
-void db_list_client_records(B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx);
+void db_list_pool_records(void *jcr, B_DB *db, DB_LIST_HANDLER sendit, void *ctx);
+void db_list_job_records(void *jcr, B_DB *db, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
+void db_list_job_totals(void *jcr, B_DB *db, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
+void db_list_files_for_job(void *jcr, B_DB *db, uint32_t jobid, DB_LIST_HANDLER sendit, void *ctx);
+void db_list_media_records(void *jcr, B_DB *mdb, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx);
+void db_list_jobmedia_records(void *jcr, B_DB *mdb, uint32_t JobId, DB_LIST_HANDLER *sendit, void *ctx);
+int db_list_sql_query(void *jcr, B_DB *mdb, char *query, DB_LIST_HANDLER *sendit, void *ctx, int verbose);
+void db_list_client_records(void *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx);
/* update.c */
-int db_update_job_start_record(B_DB *db, JOB_DBR *jr);
-int db_update_job_end_record(B_DB *db, JOB_DBR *jr);
-int db_update_pool_record(B_DB *db, POOL_DBR *pr);
-int db_update_media_record(B_DB *db, MEDIA_DBR *mr);
-int db_add_MD5_to_file_record(B_DB *mdb, FileId_t FileId, char *MD5);
-int db_mark_file_record(B_DB *mdb, FileId_t FileId, JobId_t JobId);
+int db_update_job_start_record(void *jcr, B_DB *db, JOB_DBR *jr);
+int db_update_job_end_record(void *jcr, B_DB *db, JOB_DBR *jr);
+int db_update_pool_record(void *jcr, B_DB *db, POOL_DBR *pr);
+int db_update_media_record(void *jcr, B_DB *db, MEDIA_DBR *mr);
+int db_add_MD5_to_file_record(void *jcr, B_DB *mdb, FileId_t FileId, char *MD5);
+int db_mark_file_record(void *jcr, B_DB *mdb, FileId_t FileId, JobId_t JobId);
#endif /* __SQL_PROTOS_H */
* calling subroutine sets and clears the mutex
*/
-/* Check that the tables conrrespond to the version we want */
-int check_tables_version(B_DB *mdb)
+/* Check that the tables correspond to the version we want */
+int check_tables_version(void *jcr, B_DB *mdb)
{
uint32_t version;
char *query = "SELECT VersionId FROM Version";
if (version != BDB_VERSION) {
Mmsg(&mdb->errmsg, "Version error for database \"%s\". Wanted %d, got %d\n",
mdb->db_name, BDB_VERSION, version);
- Jmsg(mdb->jcr, M_FATAL, 0, mdb->errmsg);
+ Jmsg(jcr, M_FATAL, 0, "%s", mdb->errmsg);
return 0;
}
return 1;
/* Utility routine for queries */
int
-QueryDB(char *file, int line, B_DB *mdb, char *cmd)
+QueryDB(char *file, int line, void *jcr, B_DB *mdb, char *cmd)
{
if (sql_query(mdb, cmd)) {
m_msg(file, line, &mdb->errmsg, _("query %s failed:\n%s\n"), cmd, sql_strerror(mdb));
- j_msg(file, line, mdb->jcr, M_FATAL, 0, mdb->errmsg);
+ j_msg(file, line, jcr, M_FATAL, 0, "%s", mdb->errmsg);
return 0;
}
mdb->result = sql_store_result(mdb);
* 1 on success
*/
int
-InsertDB(char *file, int line, B_DB *mdb, char *cmd)
+InsertDB(char *file, int line, void *jcr, B_DB *mdb, char *cmd)
{
if (sql_query(mdb, cmd)) {
m_msg(file, line, &mdb->errmsg, _("insert %s failed:\n%s\n"), cmd, sql_strerror(mdb));
- j_msg(file, line, mdb->jcr, M_FATAL, 0, mdb->errmsg);
+ j_msg(file, line, jcr, M_FATAL, 0, "%s", mdb->errmsg);
return 0;
}
if (mdb->have_insert_id) {
* 1 on success
*/
int
-UpdateDB(char *file, int line, B_DB *mdb, char *cmd)
+UpdateDB(char *file, int line, void *jcr, B_DB *mdb, char *cmd)
{
if (sql_query(mdb, cmd)) {
m_msg(file, line, &mdb->errmsg, _("update %s failed:\n%s\n"), cmd, sql_strerror(mdb));
- j_msg(file, line, mdb->jcr, M_ERROR, 0, mdb->errmsg);
- j_msg(file, line, mdb->jcr, M_ERROR, 0, "%s\n", cmd);
+ j_msg(file, line, jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ j_msg(file, line, jcr, M_ERROR, 0, "%s\n", cmd);
return 0;
}
mdb->num_rows = sql_affected_rows(mdb);
* n number of rows affected
*/
int
-DeleteDB(char *file, int line, B_DB *mdb, char *cmd)
+DeleteDB(char *file, int line, void *jcr, B_DB *mdb, char *cmd)
{
if (sql_query(mdb, cmd)) {
m_msg(file, line, &mdb->errmsg, _("delete %s failed:\n%s\n"), cmd, sql_strerror(mdb));
- j_msg(file, line, mdb->jcr, M_ERROR, 0, mdb->errmsg);
+ j_msg(file, line, jcr, M_ERROR, 0, "%s", mdb->errmsg);
return -1;
}
mdb->changes++;
* Returns: -1 on failure
* count on success
*/
-int get_sql_record_max(B_DB *mdb)
+int get_sql_record_max(void *jcr, B_DB *mdb)
{
SQL_ROW row;
int stat = 0;
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
stat = -1;
{
int errstat;
if ((errstat=rwl_writelock(&mdb->lock)) != 0) {
- j_msg(file, line, mdb->jcr, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
+ e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
strerror(errstat));
}
}
{
int errstat;
if ((errstat=rwl_writeunlock(&mdb->lock)) != 0) {
- j_msg(file, line, mdb->jcr, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
+ e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
strerror(errstat));
}
}
* much more efficient. Usually started when inserting
* file attributes.
*/
-void db_start_transaction(B_DB *mdb)
+void db_start_transaction(void *jcr, B_DB *mdb)
{
#ifdef xAVE_SQLITE
db_lock(mdb);
/* Allow only 10,000 changes per transaction */
if (mdb->transaction && mdb->changes > 10000) {
- db_end_transaction(mdb);
+ db_end_transaction(jcr, mdb);
}
if (!mdb->transaction) {
my_sqlite_query(mdb, "BEGIN"); /* begin transaction */
}
-void db_end_transaction(B_DB *mdb)
+void db_end_transaction(void *jcr, B_DB *mdb)
{
#ifdef xAVE_SQLITE
db_lock(mdb);
* and filename parts. They are returned in pool memory
* in the mdb structure.
*/
-void split_path_and_filename(B_DB *mdb, char *fname)
+void split_path_and_filename(void *jcr, B_DB *mdb, char *fname)
{
char *p, *f;
mdb->path[mdb->pnl] = 0;
} else {
Mmsg1(&mdb->errmsg, _("Path length is zero. File=%s\n"), fname);
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
mdb->path[0] = ' ';
mdb->path[1] = 0;
mdb->pnl = 1;
*/
/* Forward referenced subroutines */
-static int db_create_file_record(B_DB *mdb, ATTR_DBR *ar);
-static int db_create_filename_record(B_DB *mdb, ATTR_DBR *ar);
-static int db_create_path_record(B_DB *mdb, ATTR_DBR *ar);
+static int db_create_file_record(void *jcr, B_DB *mdb, ATTR_DBR *ar);
+static int db_create_filename_record(void *jcr, B_DB *mdb, ATTR_DBR *ar);
+static int db_create_path_record(void *jcr, B_DB *mdb, ATTR_DBR *ar);
/* Imported subroutines */
extern void print_dashes(B_DB *mdb);
extern void print_result(B_DB *mdb);
-extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
-extern int InsertDB(char *file, int line, B_DB *db, char *select_cmd);
-extern void split_path_and_filename(B_DB *mdb, char *fname);
+extern int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
+extern int InsertDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
+extern void split_path_and_filename(void *jcr, B_DB *mdb, char *fname);
/* Create a new record for the Job
* 1 on success
*/
int
-db_create_job_record(B_DB *mdb, JOB_DBR *jr)
+db_create_job_record(void *jcr, B_DB *mdb, JOB_DBR *jr)
{
char dt[MAX_TIME_LENGTH];
time_t stime;
JobTDate = (utime_t)stime;
db_lock(mdb);
- if (!db_next_index(mdb, "Job", JobId)) {
+ if (!db_next_index(jcr, mdb, "Job", JobId)) {
jr->JobId = 0;
db_unlock(mdb);
return 0;
JobId, jr->Job, jr->Name, (char)(jr->Type), (char)(jr->Level),
(char)(jr->JobStatus), dt, edit_uint64(JobTDate, ed1));
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create DB Job record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
jr->JobId = 0;
* 1 on success
*/
int
-db_create_jobmedia_record(B_DB *mdb, JOBMEDIA_DBR *jm)
+db_create_jobmedia_record(void *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
{
int stat;
JobId=%d AND MediaId=%d", jm->JobId, jm->MediaId);
Dmsg0(30, mdb->cmd);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 0) {
Mmsg0(&mdb->errmsg, _("Create JobMedia failed. Record already exists.\n"));
jm->StartFile, jm->EndFile, jm->StartBlock, jm->EndBlock);
Dmsg0(30, mdb->cmd);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create db JobMedia record %s failed. ERR=%s\n"), mdb->cmd,
sql_strerror(mdb));
stat = 0;
* 1 on success
*/
int
-db_create_pool_record(B_DB *mdb, POOL_DBR *pr)
+db_create_pool_record(void *jcr, B_DB *mdb, POOL_DBR *pr)
{
int stat;
char ed1[30], ed2[30], ed3[50];
Mmsg(&mdb->cmd, "SELECT PoolId,Name FROM Pool WHERE Name='%s'", pr->Name);
Dmsg1(200, "selectpool: %s\n", mdb->cmd);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
edit_uint64(pr->MaxVolBytes, ed3),
pr->PoolType, pr->LabelFormat);
Dmsg1(200, "Create Pool: %s\n", mdb->cmd);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create db Pool record %s failed: ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
pr->PoolId = 0;
* 1 on success
*/
int
-db_create_media_record(B_DB *mdb, MEDIA_DBR *mr)
+db_create_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
{
int stat;
char ed1[30], ed2[30], ed3[30], ed4[30];
mr->VolumeName);
Dmsg1(110, "selectpool: %s\n", mdb->cmd);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 0) {
Mmsg1(&mdb->errmsg, _("Media record %s already exists\n"), mr->VolumeName);
mr->Slot);
Dmsg1(500, "Create Volume: %s\n", mdb->cmd);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create DB Media record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
stat = 0;
* Returns: 0 on failure
* 1 on success with id in cr->ClientId
*/
-int db_create_client_record(B_DB *mdb, CLIENT_DBR *cr)
+int db_create_client_record(void *jcr, B_DB *mdb, CLIENT_DBR *cr)
{
SQL_ROW row;
int stat;
Mmsg(&mdb->cmd, "SELECT ClientId,Uname FROM Client WHERE Name='%s'", cr->Name);
cr->ClientId = 0;
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
/* If more than one, report error, but return first row */
if (mdb->num_rows > 1) {
Mmsg1(&mdb->errmsg, _("More than one Client!: %d\n"), (int)(mdb->num_rows));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
}
if (mdb->num_rows >= 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching Client row: %s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
sql_free_result(mdb);
db_unlock(mdb);
return 0;
edit_uint64(cr->FileRetention, ed1),
edit_uint64(cr->JobRetention, ed2));
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create DB Client record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
cr->ClientId = 0;
stat = 0;
} else {
* Returns: 0 on failure
* 1 on success with FileSetId in record
*/
-int db_create_fileset_record(B_DB *mdb, FILESET_DBR *fsr)
+int db_create_fileset_record(void *jcr, B_DB *mdb, FILESET_DBR *fsr)
{
SQL_ROW row;
int stat;
FileSet='%s' and MD5='%s'", fsr->FileSet, fsr->MD5);
fsr->FileSetId = 0;
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
Mmsg1(&mdb->errmsg, _("More than one FileSet!: %d\n"), (int)(mdb->num_rows));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
}
if (mdb->num_rows >= 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching FileSet row: ERR=%s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
sql_free_result(mdb);
db_unlock(mdb);
return 0;
Mmsg(&mdb->cmd, "INSERT INTO FileSet (FileSet, MD5) VALUES \
('%s', '%s')", fsr->FileSet, fsr->MD5);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create DB FileSet record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
fsr->FileSetId = 0;
stat = 0;
} else {
* how many times it occurs. This is this subroutine, we separate
* the file and the path and create three database records.
*/
-int db_create_file_attributes_record(B_DB *mdb, ATTR_DBR *ar)
+int db_create_file_attributes_record(void *jcr, B_DB *mdb, ATTR_DBR *ar)
{
Dmsg1(100, "Fname=%s\n", ar->fname);
*/
if (!(ar->Stream == STREAM_UNIX_ATTRIBUTES || ar->Stream == STREAM_WIN32_ATTRIBUTES)) {
Mmsg0(&mdb->errmsg, _("Attempt to put non-attributes into catalog\n"));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
return 0;
}
db_lock(mdb);
- split_path_and_filename(mdb, ar->fname);
+ split_path_and_filename(jcr, mdb, ar->fname);
- if (!db_create_filename_record(mdb, ar)) {
+ if (!db_create_filename_record(jcr, mdb, ar)) {
db_unlock(mdb);
return 0;
}
Dmsg1(100, "db_create_filename_record: %s\n", mdb->esc_name);
- if (!db_create_path_record(mdb, ar)) {
+ if (!db_create_path_record(jcr, mdb, ar)) {
db_unlock(mdb);
return 0;
}
Dmsg1(100, "db_create_path_record\n", mdb->esc_name);
/* Now create master File record */
- if (!db_create_file_record(mdb, ar)) {
+ if (!db_create_file_record(jcr, mdb, ar)) {
db_unlock(mdb);
return 0;
}
* This is the master File entry containing the attributes.
* The filename and path records have already been created.
*/
-static int db_create_file_record(B_DB *mdb, ATTR_DBR *ar)
+static int db_create_file_record(void *jcr, B_DB *mdb, ATTR_DBR *ar)
{
int stat;
ar->FileIndex, ar->JobId, ar->PathId, ar->FilenameId,
ar->attr);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create db File record %s failed. ERR=%s"),
mdb->cmd, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
ar->FileId = 0;
stat = 0;
} else {
}
/* Create a Unique record for the Path -- no duplicates */
-static int db_create_path_record(B_DB *mdb, ATTR_DBR *ar)
+static int db_create_path_record(void *jcr, B_DB *mdb, ATTR_DBR *ar)
{
SQL_ROW row;
int stat;
Mmsg(&mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
edit_uint64(mdb->num_rows, ed1), mdb->path);
- sm_check(__FILE__, __LINE__, True);
- Jmsg(mdb->jcr, M_WARNING, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
}
/* Even if there are multiple paths, take the first one */
if (mdb->num_rows >= 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
sql_free_result(mdb);
ar->PathId = 0;
ASSERT(ar->PathId);
Mmsg(&mdb->cmd, "INSERT INTO Path (Path) VALUES ('%s')", mdb->esc_name);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create db Path record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
ar->PathId = 0;
stat = 0;
} else {
}
/* Create a Unique record for the filename -- no duplicates */
-static int db_create_filename_record(B_DB *mdb, ATTR_DBR *ar)
+static int db_create_filename_record(void *jcr, B_DB *mdb, ATTR_DBR *ar)
{
SQL_ROW row;
mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
db_escape_string(mdb->esc_name, mdb->fname, mdb->fnl);
- sm_check(__FILE__, __LINE__, True);
Mmsg(&mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
Mmsg2(&mdb->errmsg, _("More than one Filename! %s for file: %s\n"),
edit_uint64(mdb->num_rows, ed1), mdb->fname);
- Jmsg(mdb->jcr, M_WARNING, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
}
if (mdb->num_rows >= 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg2(&mdb->errmsg, _("Error fetching row for file=%s: ERR=%s\n"),
mdb->fname, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
ar->FilenameId = 0;
} else {
ar->FilenameId = atoi(row[0]);
Mmsg(&mdb->cmd, "INSERT INTO Filename (Name) VALUES ('%s')", mdb->esc_name);
- if (!INSERT_DB(mdb, mdb->cmd)) {
+ if (!INSERT_DB(jcr, mdb, mdb->cmd)) {
Mmsg2(&mdb->errmsg, _("Create db Filename record %s failed. ERR=%s\n"),
mdb->cmd, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
ar->FilenameId = 0;
} else {
ar->FilenameId = sql_insert_id(mdb);
/* Imported subroutines */
extern void print_dashes(B_DB *mdb);
extern void print_result(B_DB *mdb);
-extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
-extern int DeleteDB(char *file, int line, B_DB *db, char *delete_cmd);
+extern int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
+extern int DeleteDB(char *file, int line, void *jcr, B_DB *db, char *delete_cmd);
/*
* Delete Pool record, must also delete all associated
* NumVols = number of Media records deleted
*/
int
-db_delete_pool_record(B_DB *mdb, POOL_DBR *pr)
+db_delete_pool_record(void *jcr, B_DB *mdb, POOL_DBR *pr)
{
SQL_ROW row;
pr->PoolId = pr->NumVols = 0;
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
Mmsg(&mdb->cmd,
"DELETE FROM Media WHERE Media.PoolId = %d", pr->PoolId);
- pr->NumVols = DELETE_DB(mdb, mdb->cmd);
+ pr->NumVols = DELETE_DB(jcr, mdb, mdb->cmd);
Dmsg1(200, "Deleted %d Media records\n", pr->NumVols);
/* Delete Pool */
Mmsg(&mdb->cmd,
"DELETE FROM Pool WHERE Pool.PoolId = %d", pr->PoolId);
- pr->PoolId = DELETE_DB(mdb, mdb->cmd);
+ pr->PoolId = DELETE_DB(jcr, mdb, mdb->cmd);
Dmsg1(200, "Deleted %d Pool records\n", pr->PoolId);
db_unlock(mdb);
/* Delete Media record and all records that
* are associated with it.
*/
-int db_delete_media_record(B_DB *mdb, MEDIA_DBR *mr)
+int db_delete_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
{
- if (mr->MediaId == 0 && !db_get_media_record(mdb, mr)) {
+ if (mr->MediaId == 0 && !db_get_media_record(jcr, mdb, mr)) {
return 0;
}
/* Delete associated records */
* media record itself. But the media status
* is changed to "Purged".
*/
-int db_purge_media_record(B_DB *mdb, MEDIA_DBR *mr)
+int db_purge_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
{
- if (mr->MediaId == 0 && !db_get_media_record(mdb, mr)) {
+ if (mr->MediaId == 0 && !db_get_media_record(jcr, mdb, mr)) {
return 0;
}
/* Delete associated records */
/* Mark Volume as purged */
strcpy(mr->VolStatus, "Purged");
- if (!db_update_media_record(mdb, mr)) {
+ if (!db_update_media_record(jcr, mdb, mr)) {
return 0;
}
/* Imported subroutines */
extern void print_result(B_DB *mdb);
-extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
+extern int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
/*
* Find job start time. Used to find last full save
* 1 on success, jr is unchanged, but stime is set
*/
int
-db_find_job_start_time(B_DB *mdb, JOB_DBR *jr, POOLMEM **stime)
+db_find_job_start_time(void *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM **stime)
{
SQL_ROW row;
int JobId;
return 0;
}
Dmsg1(100, "Submitting: %s\n", mdb->cmd);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
Mmsg1(&mdb->errmsg, _("Query error for start time request: %s\n"), mdb->cmd);
db_unlock(mdb);
return 0;
Dmsg1(100, "Submitting: %s\n", mdb->cmd);
Mmsg(&mdb->cmd, "SELECT StartTime FROM Job WHERE Job.JobId=%d", JobId);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
Mmsg1(&mdb->errmsg, _("Query error for start time request: %s\n"), mdb->cmd);
db_unlock(mdb);
return 0;
* 0 on failure
*/
int
-db_find_last_jobid(B_DB *mdb, JOB_DBR *jr)
+db_find_last_jobid(void *jcr, B_DB *mdb, JOB_DBR *jr)
{
SQL_ROW row;
return 0;
}
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return 0;
}
* numrows on success
*/
int
-db_find_next_volume(B_DB *mdb, int item, MEDIA_DBR *mr)
+db_find_next_volume(void *jcr, B_DB *mdb, int item, MEDIA_DBR *mr)
{
SQL_ROW row;
int numrows;
FROM Media WHERE PoolId=%d AND MediaType='%s' AND VolStatus='%s' \
ORDER BY MediaId", mr->PoolId, mr->MediaType, mr->VolStatus);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return 0;
}
*/
/* Forward referenced functions */
-static int db_get_file_record(B_DB *mdb, FILE_DBR *fdbr);
-static int db_get_filename_record(B_DB *mdb);
-static int db_get_path_record(B_DB *mdb);
+static int db_get_file_record(void *jcr, B_DB *mdb, FILE_DBR *fdbr);
+static int db_get_filename_record(void *jcr, B_DB *mdb);
+static int db_get_path_record(void *jcr, B_DB *mdb);
/* Imported subroutines */
extern void print_result(B_DB *mdb);
-extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
-extern void split_path_and_filename(B_DB *mdb, char *fname);
+extern int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
+extern void split_path_and_filename(void *jcr, B_DB *mdb, char *fname);
* Returns: 0 on failure
* 1 on success with the File record in FILE_DBR
*/
-int db_get_file_attributes_record(B_DB *mdb, char *fname, FILE_DBR *fdbr)
+int db_get_file_attributes_record(void *jcr, B_DB *mdb, char *fname, FILE_DBR *fdbr)
{
int stat;
Dmsg1(20, "Enter get_file_from_catalog fname=%s \n", fname);
db_lock(mdb);
- split_path_and_filename(mdb, fname);
+ split_path_and_filename(jcr, mdb, fname);
- fdbr->FilenameId = db_get_filename_record(mdb);
+ fdbr->FilenameId = db_get_filename_record(jcr, mdb);
- fdbr->PathId = db_get_path_record(mdb);
+ fdbr->PathId = db_get_path_record(jcr, mdb);
- stat = db_get_file_record(mdb, fdbr);
+ stat = db_get_file_record(jcr, mdb, fdbr);
db_unlock(mdb);
* "normal" if a new file is found during Verify.
*/
static
-int db_get_file_record(B_DB *mdb, FILE_DBR *fdbr)
+int db_get_file_record(void *jcr, B_DB *mdb, FILE_DBR *fdbr)
{
SQL_ROW row;
int stat = 0;
Dmsg1(100, "Query=%s\n", mdb->cmd);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
Dmsg1(050, "get_file_record num_rows=%d\n", (int)mdb->num_rows);
*
* DO NOT use Jmsg in this routine (see notes for get_file_record)
*/
-static int db_get_filename_record(B_DB *mdb)
+static int db_get_filename_record(void *jcr, B_DB *mdb)
{
SQL_ROW row;
int FilenameId = 0;
mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->fnl+2);
db_escape_string(mdb->esc_name, mdb->fname, mdb->fnl);
- sm_check(__FILE__, __LINE__, True);
Mmsg(&mdb->cmd, "SELECT FilenameId FROM Filename WHERE Name='%s'", mdb->esc_name);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
char ed1[30];
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
Mmsg2(&mdb->errmsg, _("More than one Filename!: %s for file: %s\n"),
edit_uint64(mdb->num_rows, ed1), mdb->fname);
- Jmsg(mdb->jcr, M_WARNING, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
}
if (mdb->num_rows >= 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
*
* DO NOT use Jmsg in this routine (see notes for get_file_record)
*/
-static int db_get_path_record(B_DB *mdb)
+static int db_get_path_record(void *jcr, B_DB *mdb)
{
SQL_ROW row;
uint32_t PathId = 0;
mdb->esc_name = check_pool_memory_size(mdb->esc_name, 2*mdb->pnl+2);
db_escape_string(mdb->esc_name, mdb->path, mdb->pnl);
- sm_check(__FILE__, __LINE__, True);
if (mdb->cached_path_id != 0 && mdb->cached_path_len == mdb->pnl &&
strcmp(mdb->cached_path, mdb->path) == 0) {
Mmsg(&mdb->cmd, "SELECT PathId FROM Path WHERE Path='%s'", mdb->esc_name);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
char ed1[30];
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
Mmsg2(&mdb->errmsg, _("More than one Path!: %s for path: %s\n"),
edit_uint64(mdb->num_rows, ed1), mdb->path);
- Jmsg(mdb->jcr, M_WARNING, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_WARNING, 0, "%s", mdb->errmsg);
}
/* Even if there are multiple paths, take the first one */
if (mdb->num_rows >= 1) {
* Returns: 0 on failure
* 1 on success
*/
-int db_get_job_record(B_DB *mdb, JOB_DBR *jr)
+int db_get_job_record(void *jcr, B_DB *mdb, JOB_DBR *jr)
{
SQL_ROW row;
FROM Job WHERE JobId=%u", jr->JobId);
}
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return 0; /* failed */
}
*
* Returns: number of volumes on success
*/
-int db_get_job_volume_names(B_DB *mdb, uint32_t JobId, POOLMEM **VolumeNames)
+int db_get_job_volume_names(void *jcr, B_DB *mdb, uint32_t JobId, POOLMEM **VolumeNames)
{
SQL_ROW row;
int stat = 0;
Dmsg1(130, "VolNam=%s\n", mdb->cmd);
*VolumeNames[0] = 0;
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
Dmsg1(130, "Num rows=%d\n", mdb->num_rows);
if (mdb->num_rows <= 0) {
for (i=0; i < stat; i++) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg2(&mdb->errmsg, _("Error fetching row %d: ERR=%s\n"), i, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
stat = 0;
break;
} else {
*
* Returns: number of volumes on success
*/
-int db_get_job_volume_parameters(B_DB *mdb, uint32_t JobId, VOL_PARAMS **VolParams)
+int db_get_job_volume_parameters(void *jcr, B_DB *mdb, uint32_t JobId, VOL_PARAMS **VolParams)
{
SQL_ROW row;
int stat = 0;
" AND JobMedia.MediaId=Media.MediaId", JobId);
Dmsg1(130, "VolNam=%s\n", mdb->cmd);
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
Dmsg1(130, "Num rows=%d\n", mdb->num_rows);
if (mdb->num_rows <= 0) {
for (i=0; i < stat; i++) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg2(&mdb->errmsg, _("Error fetching row %d: ERR=%s\n"), i, sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
stat = 0;
break;
} else {
* Returns: -1 on failure
* number on success
*/
-int db_get_num_pool_records(B_DB *mdb)
+int db_get_num_pool_records(void *jcr, B_DB *mdb)
{
int stat = 0;
db_lock(mdb);
Mmsg(&mdb->cmd, "SELECT count(*) from Pool");
- stat = get_sql_record_max(mdb);
+ stat = get_sql_record_max(jcr, mdb);
db_unlock(mdb);
return stat;
}
* Returns 0: on failure
* 1: on success
*/
-int db_get_pool_ids(B_DB *mdb, int *num_ids, uint32_t *ids[])
+int db_get_pool_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
{
SQL_ROW row;
int stat = 0;
db_lock(mdb);
*ids = NULL;
Mmsg(&mdb->cmd, "SELECT PoolId FROM Pool");
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
*num_ids = sql_num_rows(mdb);
if (*num_ids > 0) {
id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
stat = 1;
} else {
Mmsg(&mdb->errmsg, _("Pool id select failed: ERR=%s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
stat = 0;
}
db_unlock(mdb);
* Returns 0: on failure
* 1: on success
*/
-int db_get_client_ids(B_DB *mdb, int *num_ids, uint32_t *ids[])
+int db_get_client_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
{
SQL_ROW row;
int stat = 0;
db_lock(mdb);
*ids = NULL;
Mmsg(&mdb->cmd, "SELECT ClientId FROM Client");
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
*num_ids = sql_num_rows(mdb);
if (*num_ids > 0) {
id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
stat = 1;
} else {
Mmsg(&mdb->errmsg, _("Client id select failed: ERR=%s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
stat = 0;
}
db_unlock(mdb);
* Returns: 0 on failure
* id on success
*/
-int db_get_pool_record(B_DB *mdb, POOL_DBR *pdbr)
+int db_get_pool_record(void *jcr, B_DB *mdb, POOL_DBR *pdbr)
{
SQL_ROW row;
int stat = 0;
MaxVolBytes,PoolType,LabelFormat FROM Pool WHERE Pool.Name='%s'", pdbr->Name);
}
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
Mmsg1(&mdb->errmsg, _("More than one Pool!: %s\n"),
edit_uint64(mdb->num_rows, ed1));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else if (mdb->num_rows == 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else {
pdbr->PoolId = str_to_int64(row[0]);
bstrncpy(pdbr->Name, row[1]!=NULL?row[1]:"", sizeof(pdbr->Name));
* Returns: 0 on failure
* 1 on success
*/
-int db_get_client_record(B_DB *mdb, CLIENT_DBR *cdbr)
+int db_get_client_record(void *jcr, B_DB *mdb, CLIENT_DBR *cdbr)
{
SQL_ROW row;
int stat = 0;
"FROM Client WHERE Client.Name='%s'", cdbr->Name);
}
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
Mmsg1(&mdb->errmsg, _("More than one Client!: %s\n"),
edit_uint64(mdb->num_rows, ed1));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else if (mdb->num_rows == 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else {
cdbr->ClientId = str_to_int64(row[0]);
bstrncpy(cdbr->Name, row[1]!=NULL?row[1]:"", sizeof(cdbr->Name));
* Returns: 0 on failure
* id on success
*/
-int db_get_fileset_record(B_DB *mdb, FILESET_DBR *fsr)
+int db_get_fileset_record(void *jcr, B_DB *mdb, FILESET_DBR *fsr)
{
SQL_ROW row;
int stat = 0;
"WHERE FileSet='%s'", fsr->FileSet);
}
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
* Returns: -1 on failure
* number on success
*/
-int db_get_num_media_records(B_DB *mdb)
+int db_get_num_media_records(void *jcr, B_DB *mdb)
{
int stat = 0;
db_lock(mdb);
Mmsg(&mdb->cmd, "SELECT count(*) from Media");
- stat = get_sql_record_max(mdb);
+ stat = get_sql_record_max(jcr, mdb);
db_unlock(mdb);
return stat;
}
* Returns 0: on failure
* 1: on success
*/
-int db_get_media_ids(B_DB *mdb, int *num_ids, uint32_t *ids[])
+int db_get_media_ids(void *jcr, B_DB *mdb, int *num_ids, uint32_t *ids[])
{
SQL_ROW row;
int stat = 0;
db_lock(mdb);
*ids = NULL;
Mmsg(&mdb->cmd, "SELECT MediaId FROM Media");
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
*num_ids = sql_num_rows(mdb);
if (*num_ids > 0) {
id = (uint32_t *)malloc(*num_ids * sizeof(uint32_t));
stat = 1;
} else {
Mmsg(&mdb->errmsg, _("Media id select failed: ERR=%s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
stat = 0;
}
db_unlock(mdb);
* Returns: 0 on failure
* id on success
*/
-int db_get_media_record(B_DB *mdb, MEDIA_DBR *mr)
+int db_get_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
{
SQL_ROW row;
int stat = 0;
db_lock(mdb);
if (mr->MediaId == 0 && mr->VolumeName[0] == 0) {
Mmsg(&mdb->cmd, "SELECT count(*) from Media");
- mr->MediaId = get_sql_record_max(mdb);
+ mr->MediaId = get_sql_record_max(jcr, mdb);
db_unlock(mdb);
return 1;
}
FROM Media WHERE VolumeName='%s'", mr->VolumeName);
}
- if (QUERY_DB(mdb, mdb->cmd)) {
+ if (QUERY_DB(jcr, mdb, mdb->cmd)) {
mdb->num_rows = sql_num_rows(mdb);
if (mdb->num_rows > 1) {
char ed1[30];
Mmsg1(&mdb->errmsg, _("More than one Volume!: %s\n"),
edit_uint64(mdb->num_rows, ed1));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else if (mdb->num_rows == 1) {
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("error fetching row: %s\n"), sql_strerror(mdb));
- Jmsg(mdb->jcr, M_ERROR, 0, "%s", mdb->errmsg);
+ Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
} else {
/* return values */
mr->MediaId = str_to_int64(row[0]);
/* Imported subroutines */
extern void list_result(B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx);
-extern int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
+extern int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
/*
* Submit general SQL query
*/
-int db_list_sql_query(B_DB *mdb, char *query, DB_LIST_HANDLER *sendit, void *ctx,
- int verbose)
+int db_list_sql_query(void *jcr, B_DB *mdb, char *query, DB_LIST_HANDLER *sendit,
+ void *ctx, int verbose)
{
db_lock(mdb);
if (sql_query(mdb, query) != 0) {
}
void
-db_list_pool_records(B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_pool_records(void *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
{
Mmsg(&mdb->cmd, "SELECT PoolId,Name,NumVols,MaxVols,PoolType,LabelFormat "
"FROM Pool ORDER BY PoolId");
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
}
void
-db_list_client_records(B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_client_records(void *jcr, B_DB *mdb, DB_LIST_HANDLER *sendit, void *ctx)
{
Mmsg(&mdb->cmd, "SELECT ClientId,Name,FileRetention,JobRetention "
"FROM Client ORDER BY ClientId");
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
void
-db_list_media_records(B_DB *mdb, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_media_records(void *jcr, B_DB *mdb, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx)
{
Mmsg(&mdb->cmd, "SELECT MediaId,VolumeName,MediaType,VolStatus,\
VolBytes,LastWritten,VolRetention,Recycle,Slot \
FROM Media WHERE Media.PoolId=%u ORDER BY MediaId", mdbr->PoolId);
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
db_unlock(mdb);
}
-void db_list_jobmedia_records(B_DB *mdb, uint32_t JobId, DB_LIST_HANDLER *sendit, void *ctx)
+void db_list_jobmedia_records(void *jcr, B_DB *mdb, uint32_t JobId, DB_LIST_HANDLER *sendit, void *ctx)
{
if (JobId > 0) { /* do by JobId */
Mmsg(&mdb->cmd, "SELECT JobId, Media.VolumeName, FirstIndex, LastIndex \
}
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
* only the job with the specified id.
*/
void
-db_list_job_records(B_DB *mdb, JOB_DBR *jr, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_job_records(void *jcr, B_DB *mdb, JOB_DBR *jr, DB_LIST_HANDLER *sendit, void *ctx)
{
if (jr->JobId == 0 && jr->Job[0] == 0) {
Mmsg(&mdb->cmd,
}
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
*
*/
void
-db_list_job_totals(B_DB *mdb, JOB_DBR *jr, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_job_totals(void *jcr, B_DB *mdb, JOB_DBR *jr, DB_LIST_HANDLER *sendit, void *ctx)
{
db_lock(mdb);
Mmsg(&mdb->cmd, "SELECT count(*) AS Jobs, sum(JobFiles) \
AS Files, sum(JobBytes) AS Bytes, Name AS Job FROM Job GROUP BY Name");
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
Mmsg(&mdb->cmd, "SELECT count(*) AS Jobs,sum(JobFiles) \
AS Files,sum(JobBytes) As Bytes FROM Job");
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
void
-db_list_files_for_job(B_DB *mdb, uint32_t jobid, DB_LIST_HANDLER *sendit, void *ctx)
+db_list_files_for_job(void *jcr, B_DB *mdb, uint32_t jobid, DB_LIST_HANDLER *sendit, void *ctx)
{
Mmsg(&mdb->cmd, "SELECT Path.Path,Filename.Name FROM File,\
jobid);
db_lock(mdb);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return;
}
/* Imported subroutines */
extern void print_result(B_DB *mdb);
-extern int UpdateDB(char *file, int line, B_DB *db, char *update_cmd);
+extern int UpdateDB(char *file, int line, void *jcr, B_DB *db, char *update_cmd);
/* -----------------------------------------------------------------------
*
*/
/* Update the attributes record by adding the MD5 signature */
int
-db_add_MD5_to_file_record(B_DB *mdb, FileId_t FileId, char *MD5)
+db_add_MD5_to_file_record(void *jcr, B_DB *mdb, FileId_t FileId, char *MD5)
{
int stat;
db_lock(mdb);
Mmsg(&mdb->cmd, "UPDATE File SET MD5='%s' WHERE FileId=%u", MD5, FileId);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return stat;
}
/* Mark the file record as being visited during database
* verify compare. Stuff JobId into MarkedId field
*/
-int db_mark_file_record(B_DB *mdb, FileId_t FileId, JobId_t JobId)
+int db_mark_file_record(void *jcr, B_DB *mdb, FileId_t FileId, JobId_t JobId)
{
int stat;
db_lock(mdb);
Mmsg(&mdb->cmd, "UPDATE File SET MarkId=%u WHERE FileId=%u", JobId, FileId);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return stat;
}
* 1 on success
*/
int
-db_update_job_start_record(B_DB *mdb, JOB_DBR *jr)
+db_update_job_start_record(void *jcr, B_DB *mdb, JOB_DBR *jr)
{
char dt[MAX_TIME_LENGTH];
time_t stime;
Mmsg(&mdb->cmd, "UPDATE Job SET Level='%c', StartTime='%s', \
ClientId=%u, JobTDate=%s WHERE JobId=%u",
(char)(jr->Level), dt, jr->ClientId, edit_uint64(JobTDate, ed1), jr->JobId);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
mdb->changes = 0;
return stat;
* 1 on success
*/
int
-db_update_job_end_record(B_DB *mdb, JOB_DBR *jr)
+db_update_job_end_record(void *jcr, B_DB *mdb, JOB_DBR *jr)
{
char dt[MAX_TIME_LENGTH];
time_t ttime;
jr->JobFiles, jr->JobErrors, jr->VolSessionId, jr->VolSessionTime,
jr->PoolId, jr->FileSetId, edit_uint64(JobTDate, ed2), jr->JobId);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return stat;
}
int
-db_update_pool_record(B_DB *mdb, POOL_DBR *pr)
+db_update_pool_record(void *jcr, B_DB *mdb, POOL_DBR *pr)
{
int stat;
char ed1[50], ed2[50], ed3[50];
pr->Recycle, pr->AutoPrune,
pr->LabelFormat, pr->PoolId);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return stat;
}
* numrows on success
*/
int
-db_update_media_record(B_DB *mdb, MEDIA_DBR *mr)
+db_update_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
{
char dt[MAX_TIME_LENGTH];
time_t ttime;
strftime(dt, sizeof(dt), "%Y-%m-%d %T", &tm);
Mmsg(&mdb->cmd, "UPDATE Media SET FirstWritten='%s'\
WHERE VolumeName='%s'", dt, mr->VolumeName);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
Dmsg1(400, "Firstwritten stat=%d\n", stat);
}
edit_uint64(mr->MaxVolBytes, ed2), dt,
mr->VolStatus, mr->Slot, mr->VolumeName);
- sm_check(__FILE__, __LINE__, True);
-
Dmsg1(400, "%s\n", mdb->cmd);
- stat = UPDATE_DB(mdb, mdb->cmd);
+ stat = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return stat;
}
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-int QueryDB(char *file, int line, B_DB *db, char *select_cmd);
+int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
/*
mdb->path = get_pool_memory(PM_FNAME);
mdb->esc_name = get_pool_memory(PM_FNAME);
qinsert(&db_list, &mdb->bq); /* put db in list */
- mdb->jcr = jcr;
V(mutex);
return mdb;
}
* which are returned in the errmsg
*/
int
-db_open_database(B_DB *mdb)
+db_open_database(void *jcr, B_DB *mdb)
{
char *db_name;
int len;
return 0;
}
free(db_name);
- if (!check_tables_version(mdb)) {
+ if (!check_tables_version(jcr, mdb)) {
V(mutex);
return 0;
}
}
void
-db_close_database(B_DB *mdb)
+db_close_database(void *jcr, B_DB *mdb)
{
P(mutex);
mdb->ref_count--;
* Return the next unique index (auto-increment) for
* the given table. Return 0 on error.
*/
-int db_next_index(B_DB *mdb, char *table, char *index)
+int db_next_index(void *jcr, B_DB *mdb, char *table, char *index)
{
SQL_ROW row;
Mmsg(&mdb->cmd,
"SELECT id FROM NextId WHERE TableName=\"%s\"", table);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
Mmsg(&mdb->errmsg, _("next_index query error: ERR=%s\n"), sql_strerror(mdb));
db_unlock(mdb);
return 0;
Mmsg(&mdb->cmd,
"UPDATE NextId SET id=id+1 WHERE TableName=\"%s\"", table);
- if (!QUERY_DB(mdb, mdb->cmd)) {
+ if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
Mmsg(&mdb->errmsg, _("next_index update error: ERR=%s\n"), sql_strerror(mdb));
db_unlock(mdb);
return 0;
db_lock(jcr->db);
pr.PoolId = jcr->PoolId;
- if (!db_get_pool_record(jcr->db, &pr) || !db_get_media_ids(jcr->db, &num_ids, &ids)) {
+ if (!db_get_pool_record(jcr, jcr->db, &pr) || !db_get_media_ids(jcr, jcr->db, &num_ids, &ids)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
goto bail_out;
}
for (i=0; i<num_ids; i++) {
mr.MediaId = ids[i];
- if (!db_get_media_record(jcr->db, &mr)) {
+ if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
continue;
}
} else {
Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 signature not found.\n"));
}
- if (!db_create_fileset_record(jcr->db, &fsr)) {
+ if (!db_create_fileset_record(jcr, jcr->db, &fsr)) {
Jmsg(jcr, M_ERROR, 0, _("Could not create FileSet record. ERR=%s\n"),
db_strerror(jcr->db));
goto bail_out;
case L_INCREMENTAL:
/* Look up start time of last job */
jcr->jr.JobId = 0;
- if (!db_find_job_start_time(jcr->db, &jcr->jr, &jcr->stime)) {
+ if (!db_find_job_start_time(jcr, jcr->db, &jcr->jr, &jcr->stime)) {
Jmsg(jcr, M_INFO, 0, _("Last FULL backup time not found. Doing FULL backup.\n"));
jcr->JobLevel = jcr->jr.Level = L_FULL;
} else {
jcr->jr.JobId = jcr->JobId;
jcr->jr.StartTime = jcr->start_time;
- if (!db_update_job_start_record(jcr->db, &jcr->jr)) {
+ if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
goto bail_out;
}
*/
memset(&pr, 0, sizeof(pr));
strcpy(pr.Name, jcr->pool->hdr.name);
- while (!db_get_pool_record(jcr->db, &pr)) { /* get by Name */
+ while (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */
/* Try to create the pool */
- if (create_pool(jcr->db, jcr->pool) < 0) {
+ if (create_pool(jcr, jcr->db, jcr->pool) < 0) {
Jmsg(jcr, M_FATAL, 0, _("Pool %s not in database. %s"), pr.Name,
db_strerror(jcr->db));
goto bail_out;
update_job_end_record(jcr); /* update database */
- if (!db_get_job_record(jcr->db, &jcr->jr)) {
+ if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting job record for stats: %s"),
db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
strcpy(mr.VolumeName, jcr->VolumeName);
- if (!db_get_media_record(jcr->db, &mr)) {
+ if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Media record for stats: %s"),
db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
fd = fopen(fname, jcr->JobLevel==L_FULL?"w+":"a+");
}
if (fd) {
- VolCount = db_get_job_volume_parameters(jcr->db, jcr->JobId,
+ VolCount = db_get_job_volume_parameters(jcr, jcr->db, jcr->JobId,
&VolParams);
if (VolCount == 0) {
Jmsg(jcr, M_ERROR, 0, _("Could not get Job Volume Parameters. ERR=%s\n"),
} else {
kbps = (double)jcr->jr.JobBytes / (1000 * RunTime);
}
- if (!db_get_job_volume_names(jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
+ if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
/*
* Note, if the job has erred, most likely it did not write any
* tape, so suppress this "error" message since in that case
*/
next_volume:
strcpy(mr.VolStatus, "Append"); /* want only appendable volumes */
- ok = db_find_next_volume(jcr->db, index, &mr);
+ ok = db_find_next_volume(jcr, jcr->db, index, &mr);
Dmsg1(200, "catreq after find_next_vol ok=%d\n", ok);
if (!ok) {
/* Well, try finding recycled tapes */
Jmsg(jcr, M_INFO, 0, _("Max configured use duration exceeded. "
"Marking Volume \"%s\" as Used.\n"), mr.VolumeName);
strcpy(mr.VolStatus, "Used"); /* yes, mark as used */
- if (!db_update_media_record(jcr->db, &mr)) {
+ if (!db_update_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_ERROR, 0, _("Catalog error updating Media record. %s"),
db_strerror(jcr->db));
} else if (retry++ < 200) { /* sanity check */
* Find the Volume
*/
unbash_spaces(mr.VolumeName);
- if (db_get_media_record(jcr->db, &mr)) {
+ if (db_get_media_record(jcr, jcr->db, &mr)) {
int VolSuitable = 0;
jcr->MediaId = mr.MediaId;
Dmsg1(120, "VolumeInfo MediaId=%d\n", jcr->MediaId);
&sdmr.Slot, &relabel) == 14) {
bstrncpy(mr.VolumeName, sdmr.VolumeName, sizeof(mr.VolumeName)); /* copy Volume name */
- if (!db_get_media_record(jcr->db, &mr)) {
+ if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_ERROR, 0, _("Unable to get Media record for Volume %s: ERR=%s\n"),
mr.VolumeName, db_strerror(jcr->db));
bnet_fsend(bs, "1991 Catalog Request failed: %s", db_strerror(jcr->db));
}
Dmsg2(200, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
- if (db_update_media_record(jcr->db, &mr)) {
+ if (db_update_media_record(jcr, jcr->db, &mr)) {
bnet_fsend(bs, OK_update);
Dmsg0(190, "send OK\n");
} else {
jm.MediaId = jcr->MediaId;
Dmsg6(100, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
- if (!db_create_jobmedia_record(jcr->db, &jm)) {
+ if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
Jmsg(jcr, M_ERROR, 0, _("Catalog error creating JobMedia record. %s"),
db_strerror(jcr->db));
bnet_fsend(bs, "1991 Update JobMedia error\n");
if (!jcr->pool->catalog_files) {
return;
}
- db_start_transaction(jcr->db); /* start transaction if not already open */
+ db_start_transaction(jcr, jcr->db); /* start transaction if not already open */
skip_nonspaces(&p); /* UpdCat */
skip_spaces(&p);
skip_nonspaces(&p); /* Job=nnn */
Dmsg2(111, "dird<filed: stream=%d %s\n", Stream, fname);
Dmsg1(120, "dird<filed: attr=%s\n", attr);
- if (!db_create_file_attributes_record(jcr->db, &ar)) {
+ if (!db_create_file_attributes_record(jcr, jcr->db, &ar)) {
Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
}
/* Save values for MD5 update */
char MD5buf[50]; /* 24 bytes should be enough */
bin_to_base64(MD5buf, fname, 16);
Dmsg2(190, "MD5len=%d MD5=%s\n", strlen(MD5buf), MD5buf);
- if (!db_add_MD5_to_file_record(jcr->db, jcr->FileId, MD5buf)) {
+ if (!db_add_MD5_to_file_record(jcr, jcr->db, jcr->FileId, MD5buf)) {
Jmsg(jcr, M_ERROR, 0, _("Catalog error updating MD5. %s"),
db_strerror(jcr->db));
}
*/
db = db_init_database(NULL, catalog->db_name, catalog->db_user,
catalog->db_password);
- if (!db_open_database(db)) {
+ if (!db_open_database(NULL, db)) {
Jmsg(NULL, M_FATAL, 0, "%s", db_strerror(db));
} else {
/* If a pool is defined for this job, create the pool DB
* record if it is not already created.
*/
if (job->pool) {
- create_pool(db, job->pool);
+ create_pool(NULL, db, job->pool);
}
- db_close_database(db);
+ db_close_database(NULL, db);
}
} else {
Dmsg2(111, "dird<filed: stream=%d %s\n", stream, jcr->fname);
Dmsg1(120, "dird<filed: attr=%s\n", attr);
- if (!db_create_file_attributes_record(jcr->db, &ar)) {
+ if (!db_create_file_attributes_record(jcr, jcr->db, &ar)) {
Jmsg1(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_Error);
continue;
}
db_escape_string(MD5, Opts_MD5, strlen(Opts_MD5));
Dmsg2(120, "MD5len=%d MD5=%s\n", strlen(MD5), MD5);
- if (!db_add_MD5_to_file_record(jcr->db, jcr->FileId, MD5)) {
+ if (!db_add_MD5_to_file_record(jcr, jcr->db, jcr->FileId, MD5)) {
Jmsg1(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_Error);
}
{
int stat, errstat;
+ sm_check(__FILE__, __LINE__, True);
init_msg(jcr, jcr->messages);
create_unique_job_name(jcr, jcr->job->hdr.name);
jcr->jr.SchedTime = jcr->sched_time;
Dmsg0(50, "Open database\n");
jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user,
jcr->catalog->db_password);
- if (!db_open_database(jcr->db)) {
+ if (!db_open_database(jcr, jcr->db)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
- db_close_database(jcr->db);
+ db_close_database(jcr, jcr->db);
set_jcr_job_status(jcr, JS_ErrorTerminated);
free_jcr(jcr);
return;
* Create Job record
*/
jcr->jr.JobStatus = jcr->JobStatus;
- if (!db_create_job_record(jcr->db, &jcr->jr)) {
+ if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
- db_close_database(jcr->db);
+ db_close_database(jcr, jcr->db);
set_jcr_job_status(jcr, JS_ErrorTerminated);
free_jcr(jcr);
return;
JCR *jcr = (JCR *)arg;
time(&now);
+ sm_check(__FILE__, __LINE__, True);
Dmsg0(100, "=====Start Job=========\n");
jcr->start_time = now; /* set the real start time */
Dmsg0(50, "Before free jcr\n");
free_jcr(jcr);
Dmsg0(50, "======== End Job ==========\n");
+ sm_check(__FILE__, __LINE__, True);
}
/*
}
jcr->client_name = get_memory(strlen(jcr->client->hdr.name) + 1);
strcpy(jcr->client_name, jcr->client->hdr.name);
- if (!db_create_client_record(jcr->db, &cr)) {
+ if (!db_create_client_record(jcr, jcr->db, &cr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. %s"),
db_strerror(jcr->db));
return 0;
jcr->jr.JobBytes = jcr->JobBytes;
jcr->jr.VolSessionId = jcr->VolSessionId;
jcr->jr.VolSessionTime = jcr->VolSessionTime;
- if (!db_update_job_end_record(jcr->db, &jcr->jr)) {
+ if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"),
db_strerror(jcr->db));
}
}
if (jcr->db) {
Dmsg0(200, "Close DB\n");
- db_close_database(jcr->db);
+ db_close_database(jcr, jcr->db);
}
if (jcr->RestoreWhere) {
free(jcr->RestoreWhere);
{
JCR *jcr = (JCR *)arg;
Dmsg0(200, "End msg_thread\n");
- db_end_transaction(jcr->db); /* terminate any open transaction */
+ db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
P(jcr->mutex);
jcr->msg_thread_done = TRUE;
pthread_cond_broadcast(&jcr->term_wait); /* wakeup any waiting threads */
/* See if we can create a new Volume */
pr.PoolId = jcr->PoolId;
- if (db_get_pool_record(jcr->db, &pr) && pr.LabelFormat[0] &&
+ if (db_get_pool_record(jcr, jcr->db, &pr) && pr.LabelFormat[0] &&
pr.LabelFormat[0] != '*') {
if (pr.MaxVols == 0 || pr.NumVols < pr.MaxVols) {
set_pool_dbr_defaults_in_media_dbr(mr, &pr);
}
strcat(name, "%04d");
sprintf(mr->VolumeName, name, ++pr.NumVols);
- if (db_create_media_record(jcr->db, mr) &&
- db_update_pool_record(jcr->db, &pr) == 1) {
+ if (db_create_media_record(jcr, jcr->db, mr) &&
+ db_update_pool_record(jcr, jcr->db, &pr) == 1) {
Dmsg1(90, "Created new Volume=%s\n", mr->VolumeName);
return 1;
} else {
/* fd_cmds.c */
extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
- int max_retry_time, int verbose);
+ int max_retry_time, int verbose);
extern int send_include_list(JCR *jcr);
extern int send_exclude_list(JCR *jcr);
extern int get_attributes_and_put_in_catalog(JCR *jcr);
extern int get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
- char *link, char *attr, int stream);
+ char *link, char *attr, int stream);
/* job.c */
extern void set_jcr_defaults(JCR *jcr, JOB *job);
/* msgchan.c */
extern int connect_to_storage_daemon(JCR *jcr, int retry_interval,
- int max_retry_time, int verbose);
+ int max_retry_time, int verbose);
extern int start_storage_daemon_job(JCR *jcr);
extern int start_storage_daemon_message_thread(JCR *jcr);
extern int32_t bget_msg(BSOCK *bs, int type);
extern int newVolume(JCR *jcr, MEDIA_DBR *mr);
/* ua_cmd.c */
-extern int create_pool(B_DB *db, POOL *pool);
+extern int create_pool(JCR *jcr, B_DB *db, POOL *pool);
extern void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr);
int find_recycled_volume(JCR *jcr, MEDIA_DBR *mr)
{
strcpy(mr->VolStatus, "Recycle");
- if (db_find_next_volume(jcr->db, 1, mr)) {
+ if (db_find_next_volume(jcr, jcr->db, 1, mr)) {
jcr->MediaId = mr->MediaId;
Dmsg1(20, "Find_next_vol MediaId=%d\n", jcr->MediaId);
strcpy(jcr->VolumeName, mr->VolumeName);
Dmsg1(100, "Oldest mediaid=%d\n", oldest.MediaId);
if (oldest.MediaId != 0) {
mr->MediaId = oldest.MediaId;
- if (db_get_media_record(jcr->db, mr)) {
+ if (db_get_media_record(jcr, jcr->db, mr)) {
strcpy(mr->VolStatus, "Recycle");
- if (db_update_media_record(jcr->db, mr)) {
+ if (db_update_media_record(jcr, jcr->db, mr)) {
Jmsg(jcr, M_INFO, 0, "Recycled volume %s\n", mr->VolumeName);
Dmsg1(100, "Exit 1 recycle_a_volume Vol=%s\n", mr->VolumeName);
return 1;
memset(&rjr, 0, sizeof(rjr));
jcr->jr.Level = 'F'; /* Full restore */
jcr->jr.StartTime = jcr->start_time;
- if (!db_update_job_start_record(jcr->db, &jcr->jr)) {
+ if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
restore_cleanup(jcr, JS_ErrorTerminated);
return 0;
} else {
rjr.JobId = jcr->job->RestoreJobId; /* specified by Job Resource */
}
- if (!db_get_job_record(jcr->db, &rjr)) {
+ if (!db_get_job_record(jcr, jcr->db, &rjr)) {
Jmsg2(jcr, M_FATAL, 0, _("Cannot get job record id=%d %s"), rjr.JobId,
db_strerror(jcr->db));
restore_cleanup(jcr, JS_ErrorTerminated);
* Now find the Volumes we will need for the Restore
*/
jcr->VolumeName[0] = 0;
- if (!db_get_job_volume_names(jcr->db, rjr.JobId, &jcr->VolumeName) ||
+ if (!db_get_job_volume_names(jcr, jcr->db, rjr.JobId, &jcr->VolumeName) ||
jcr->VolumeName[0] == 0) {
Jmsg(jcr, M_FATAL, 0, _("Cannot find Volume Name for restore Job %d. %s"),
rjr.JobId, db_strerror(jcr->db));
jcr = new_jcr(sizeof(JCR), dird_free_jcr);
ASSERT(job);
- sm_check(__FILE__, __LINE__, False);
set_jcr_defaults(jcr, job);
if (run->level) {
jcr->JobLevel = run->level; /* override run level */
sprintf(mr.VolumeName, name, i);
mr.Slot = slot++;
Dmsg1(200, "Create Volume %s\n", mr.VolumeName);
- if (!db_create_media_record(ua->db, &mr)) {
+ if (!db_create_media_record(ua->jcr, ua->db, &mr)) {
bsendmsg(ua, db_strerror(ua->db));
return 1;
}
}
pr.NumVols += num;
Dmsg0(200, "Update pool record.\n");
- if (db_update_pool_record(ua->db, &pr) != 1) {
+ if (db_update_pool_record(ua->jcr, ua->db, &pr) != 1) {
bsendmsg(ua, db_strerror(ua->db));
return 1;
}
* 1 record created
*/
-int create_pool(B_DB *db, POOL *pool)
+int create_pool(JCR *jcr, B_DB *db, POOL *pool)
{
POOL_DBR pr;
strcpy(pr.Name, pool->hdr.name);
- if (db_get_pool_record(db, &pr)) {
+ if (db_get_pool_record(jcr, db, &pr)) {
return 0; /* exists */
}
set_pooldbr_from_poolres(&pr, pool, 1);
- if (!db_create_pool_record(db, &pr)) {
+ if (!db_create_pool_record(jcr, db, &pr)) {
return -1; /* error */
}
return 1;
return 1;
}
- switch (create_pool(ua->db, pool)) {
+ switch (create_pool(ua->jcr, ua->db, pool)) {
case 0:
bsendmsg(ua, _("Error: Pool %s already exists.\n\
Use update to change it.\n"), pool->hdr.name);
}
for (int done=0; !done; ) {
- if (!db_get_media_record(ua->db, &mr)) {
+ if (!db_get_media_record(ua->jcr, ua->db, &mr)) {
if (mr.MediaId != 0) {
bsendmsg(ua, _("Volume record for MediaId %d not found.\n"), mr.MediaId);
} else {
bsendmsg(ua, _("Invalid number, it must be 0 or greater\n"));
break;
}
+ if (VolFiles != (int)(mr.VolFiles + 1)) {
+ bsendmsg(ua, _("Normally, you should only increase Volume Files by one!\n"));
+ if (!get_cmd(ua, _("Continue? (yes/no): ")) ||
+ strcasecmp(ua->cmd, "yes") != 0) {
+ break;
+ }
+ }
query = get_pool_memory(PM_MESSAGE);
Mmsg(&query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%u",
VolFiles, mr.MediaId);
set_pooldbr_from_poolres(&pr, pool, 0); /* update */
- id = db_update_pool_record(ua->db, &pr);
+ id = db_update_pool_record(ua->jcr, ua->db, &pr);
if (id <= 0) {
bsendmsg(ua, _("db_update_pool_record returned %d. ERR=%s\n"),
id, db_strerror(ua->db));
return 1;
}
if (strcasecmp(ua->cmd, _("yes")) == 0) {
- db_delete_media_record(ua->db, &mr);
+ db_delete_media_record(ua->jcr, ua->db, &mr);
}
return 1;
}
return 1;
}
if (strcasecmp(ua->cmd, _("yes")) == 0) {
- db_delete_pool_record(ua->db, &pr);
+ db_delete_pool_record(ua->jcr, ua->db, &pr);
}
return 1;
}
memset(&mr, 0, sizeof(mr));
strcpy(mr.VolumeName, ua->cmd);
- if (db_get_media_record(ua->db, &mr)) {
+ if (db_get_media_record(ua->jcr, ua->db, &mr)) {
bsendmsg(ua, _("Media record for Volume %s already exists.\n"),
mr.VolumeName);
return 1;
mr.LabelDate = time(NULL);
if (ok) {
set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
- if (db_create_media_record(ua->db, &mr)) {
+ if (db_create_media_record(ua->jcr, ua->db, &mr)) {
bsendmsg(ua, _("Media record for Volume=%s successfully created.\n"),
mr.VolumeName);
if (ua->automount) {
ua->catalog = (CAT *)GetNextRes(R_CATALOG, NULL);
UnlockRes();
if (!ua->catalog) {
- bnet_fsend(ua->UA_sock, _("Could not find a Catalog resource\n"));
+ bsendmsg(ua, _("Could not find a Catalog resource\n"));
return 0;
} else {
- bnet_fsend(ua->UA_sock, _("Using default Catalog name=%s DB=%s\n"),
+ bsendmsg(ua, _("Using default Catalog name=%s DB=%s\n"),
ua->catalog->hdr.name, ua->catalog->db_name);
}
}
Dmsg0(150, "Open database\n");
- ua->db = db_init_database(NULL, ua->catalog->db_name, ua->catalog->db_user,
+ ua->db = db_init_database(ua->jcr, ua->catalog->db_name, ua->catalog->db_user,
ua->catalog->db_password);
- if (!db_open_database(ua->db)) {
- bnet_fsend(ua->UA_sock, _("Could not open DB %s: ERR=%s"),
+ if (!db_open_database(ua->jcr, ua->db)) {
+ bsendmsg(ua, _("Could not open DB %s: ERR=%s"),
ua->catalog->db_name, db_strerror(ua->db));
close_db(ua);
return 0;
void close_db(UAContext *ua)
{
if (ua->db) {
- db_close_database(ua->db);
+ db_close_database(ua->jcr, ua->db);
}
ua->db = NULL;
ua->jcr->db = NULL;
for (i=1; i<ua->argc; i++) {
/* List JOBS */
if (strcasecmp(ua->argk[i], _("jobs")) == 0) {
- db_list_job_records(ua->db, &jr, prtit, ua);
+ db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua);
/* List JOBTOTALS */
} else if (strcasecmp(ua->argk[i], _("jobtotals")) == 0) {
- db_list_job_totals(ua->db, &jr, prtit, ua);
+ db_list_job_totals(ua->jcr, ua->db, &jr, prtit, ua);
/* List JOBID */
} else if (strcasecmp(ua->argk[i], _("jobid")) == 0) {
jobid = atoi(ua->argv[i]);
if (jobid > 0) {
jr.JobId = jobid;
- db_list_job_records(ua->db, &jr, prtit, ua);
+ db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua);
}
}
} else if (strcasecmp(ua->argk[i], _("job")) == 0 && ua->argv[i]) {
bstrncpy(jr.Job, ua->argv[i], MAX_NAME_LENGTH);
jr.JobId = 0;
- db_list_job_records(ua->db, &jr, prtit, ua);
+ db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua);
/* List FILES */
} else if (strcasecmp(ua->argk[i], _("files")) == 0) {
if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
- db_get_job_record(ua->db, &jr);
+ db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
jobid = atoi(ua->argv[j]);
continue;
}
if (jobid > 0) {
- db_list_files_for_job(ua->db, jobid, prtit, ua);
+ db_list_files_for_job(ua->jcr, ua->db, jobid, prtit, ua);
}
}
if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
- db_get_job_record(ua->db, &jr);
+ db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
jobid = atoi(ua->argv[j]);
} else {
continue;
}
- db_list_jobmedia_records(ua->db, jobid, prtit, ua);
+ db_list_jobmedia_records(ua->jcr, ua->db, jobid, prtit, ua);
done = TRUE;
}
if (!done) {
/* List for all jobs (jobid=0) */
- db_list_jobmedia_records(ua->db, 0, prtit, ua);
+ db_list_jobmedia_records(ua->jcr, ua->db, 0, prtit, ua);
}
/* List POOLS */
} else if (strcasecmp(ua->argk[i], _("pools")) == 0) {
- db_list_pool_records(ua->db, prtit, ua);
+ db_list_pool_records(ua->jcr, ua->db, prtit, ua);
} else if (strcasecmp(ua->argk[i], _("clients")) == 0) {
- db_list_client_records(ua->db, prtit, ua);
+ db_list_client_records(ua->jcr, ua->db, prtit, ua);
/* List MEDIA or VOLUMES */
if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
- db_get_job_record(ua->db, &jr);
+ db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
jobid = atoi(ua->argv[j]);
continue;
}
VolumeName = get_pool_memory(PM_FNAME);
- n = db_get_job_volume_names(ua->db, jobid, &VolumeName);
+ n = db_get_job_volume_names(ua->jcr, ua->db, jobid, &VolumeName);
bsendmsg(ua, _("Jobid %d used %d Volume(s): %s\n"), jobid, n, VolumeName);
free_pool_memory(VolumeName);
done = TRUE;
return 1;
}
mr.PoolId = pr.PoolId;
- db_list_media_records(ua->db, &mr, prtit, ua);
+ db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua);
}
} else {
bsendmsg(ua, _("Unknown list keyword: %s\n"), NPRT(ua->argk[i]));
memset(&cr, 0, sizeof(cr));
memset(&del, 0, sizeof(del));
strcpy(cr.Name, client->hdr.name);
- if (!db_create_client_record(ua->db, &cr)) {
+ if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
db_unlock(ua->db);
return 0;
}
memset(&cr, 0, sizeof(cr));
memset(&del, 0, sizeof(del));
strcpy(cr.Name, client->hdr.name);
- if (!db_create_client_record(ua->db, &cr)) {
+ if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
db_unlock(ua->db);
return 0;
}
(int)(now-period));
for (i=0; i < del.num_ids; i++) {
jr.JobId = del.JobId[i];
- if (!db_get_job_record(ua->db, &jr)) {
+ if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
continue;
}
Dmsg2(200, "Looking at %s JobTdate=%d\n", jr.Job, (int)jr.JobTDate);
memset(&del, 0, sizeof(del));
strcpy(cr.Name, client->hdr.name);
- if (!db_create_client_record(ua->db, &cr)) {
+ if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
return 0;
}
memset(&del, 0, sizeof(del));
strcpy(cr.Name, client->hdr.name);
- if (!db_create_client_record(ua->db, &cr)) {
+ if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
return 0;
}
strcmp(mr->VolStatus, "Full") == 0 ||
strcmp(mr->VolStatus, "Used") == 0) {
strcpy(mr->VolStatus, "Purged");
- if (!db_update_media_record(ua->db, mr)) {
+ if (!db_update_media_record(ua->jcr, ua->db, mr)) {
if (ua->verbose) {
bsendmsg(ua, "%s", db_strerror(ua->db));
}
*/
/*
- Copyright (C) 2002 Kern Sibbald and John Walker
+ Copyright (C) 2002-2003 Kern Sibbald and John Walker
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
case -1: /* error */
return 0;
case 0: /* list last 20 Jobs run */
- db_list_sql_query(ua->db, uar_list_jobs, prtit, ua, 1);
+ db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, prtit, ua, 1);
done = 0;
break;
case 1: /* list where a file is saved */
}
query = get_pool_memory(PM_MESSAGE);
Mmsg(&query, uar_file, ua->cmd);
- db_list_sql_query(ua->db, query, prtit, ua, 1);
+ db_list_sql_query(ua->jcr, ua->db, query, prtit, ua, 1);
free_pool_memory(query);
done = 0;
break;
if (!get_cmd(ua, _("Enter SQL list command: "))) {
return 0;
}
- db_list_sql_query(ua->db, ua->cmd, prtit, ua, 1);
+ db_list_sql_query(ua->jcr, ua->db, ua->cmd, prtit, ua, 1);
done = 0;
break;
case 4: /* Select the most recent backups */
return 0;
}
fsr.FileSetId = atoi(fileset_name); /* Id is first part of name */
- if (!db_get_fileset_record(ua->db, &fsr)) {
- bsendmsg(ua, "Error getting FileSet record: %s\n", db_strerror(ua->db));
+ if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
+ bsendmsg(ua, _("Error getting FileSet record: %s\n"), db_strerror(ua->db));
bsendmsg(ua, _("This probably means you modified the FileSet.\n"
"Continuing anyway.\n"));
}
bsendmsg(ua, "%s\n", db_strerror(ua->db));
}
free_pool_memory(query);
- db_list_sql_query(ua->db, uar_list_temp, prtit, ua, 1);
+ db_list_sql_query(ua->jcr, ua->db, uar_list_temp, prtit, ua, 1);
if (!db_sql_query(ua->db, uar_sel_jobid_temp, jobid_handler, (void *)ji)) {
bsendmsg(ua, "%s\n", db_strerror(ua->db));
break;
}
jr.JobId = JobId;
- if (!db_get_job_record(ua->db, &jr)) {
+ if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
bsendmsg(ua, _("Unable to get Job record. ERR=%s\n"), db_strerror(ua->db));
return 0;
}
if (bsr) {
memset(&jr, 0, sizeof(jr));
jr.JobId = bsr->JobId;
- if (!db_get_job_record(ua->db, &jr)) {
+ if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
bsendmsg(ua, _("Unable to get Job record. ERR=%s\n"), db_strerror(ua->db));
return 0;
}
bsr->VolSessionId = jr.VolSessionId;
bsr->VolSessionTime = jr.VolSessionTime;
- if ((bsr->VolCount=db_get_job_volume_parameters(ua->db, bsr->JobId,
+ if ((bsr->VolCount=db_get_job_volume_parameters(ua->jcr, ua->db, bsr->JobId,
&(bsr->VolParams))) == 0) {
bsendmsg(ua, _("Unable to get Job Volume Parameters. ERR=%s\n"), db_strerror(ua->db));
if (bsr->VolParams) {
tree_getpath(node, cwd, sizeof(cwd));
fdbr.FileId = 0;
fdbr.JobId = node->JobId;
- if (db_get_file_attributes_record(ua->db, cwd, &fdbr)) {
+ if (db_get_file_attributes_record(ua->jcr, ua->db, cwd, &fdbr)) {
decode_stat(fdbr.LStat, &statp); /* decode stat pkt */
ls_output(buf, cwd, &statp);
bsendmsg(ua, "%s\n", buf);
int i;
if (cr->Name[0]) { /* If name already supplied */
- if (db_get_client_record(ua->db, cr)) {
+ if (db_get_client_record(ua->jcr, ua->db, cr)) {
return 1;
}
bsendmsg(ua, _("Could not find Client %s: ERR=%s"), cr->Name, db_strerror(ua->db));
for (i=1; i<ua->argc; i++) {
if (strcasecmp(ua->argk[i], _("client")) == 0 && ua->argv[i]) {
bstrncpy(cr->Name, ua->argv[i], sizeof(cr->Name));
- if (!db_get_client_record(ua->db, cr)) {
+ if (!db_get_client_record(ua->jcr, ua->db, cr)) {
bsendmsg(ua, _("Could not find Client %s: ERR=%s"), ua->argv[i],
db_strerror(ua->db));
cr->ClientId = 0;
cr->ClientId = 0;
- if (!db_get_client_ids(ua->db, &num_clients, &ids)) {
+ if (!db_get_client_ids(ua->jcr, ua->db, &num_clients, &ids)) {
bsendmsg(ua, _("Error obtaining client ids. ERR=%s\n"), db_strerror(ua->db));
return 0;
}
start_prompt(ua, _("Defined Clients:\n"));
for (i=0; i < num_clients; i++) {
ocr.ClientId = ids[i];
- if (!db_get_client_record(ua->db, &ocr)) {
+ if (!db_get_client_record(ua->jcr, ua->db, &ocr)) {
continue;
}
add_prompt(ua, ocr.Name);
memset(&ocr, 0, sizeof(ocr));
bstrncpy(ocr.Name, name, sizeof(ocr.Name));
- if (!db_get_client_record(ua->db, &ocr)) {
+ if (!db_get_client_record(ua->jcr, ua->db, &ocr)) {
bsendmsg(ua, _("Could not find Client %s: ERR=%s"), name, db_strerror(ua->db));
return 0;
}
int i;
if (pr->Name[0]) { /* If name already supplied */
- if (db_get_pool_record(ua->db, pr)) {
+ if (db_get_pool_record(ua->jcr, ua->db, pr)) {
return pr->PoolId;
}
bsendmsg(ua, _("Could not find Pool %s: ERR=%s"), pr->Name, db_strerror(ua->db));
for (i=1; i<ua->argc; i++) {
if (strcasecmp(ua->argk[i], _("pool")) == 0 && ua->argv[i]) {
bstrncpy(pr->Name, ua->argv[i], sizeof(pr->Name));
- if (!db_get_pool_record(ua->db, pr)) {
+ if (!db_get_pool_record(ua->jcr, ua->db, pr)) {
bsendmsg(ua, _("Could not find Pool %s: ERR=%s"), ua->argv[i],
db_strerror(ua->db));
pr->PoolId = 0;
pr->PoolId = 0;
- if (!db_get_pool_ids(ua->db, &num_pools, &ids)) {
+ if (!db_get_pool_ids(ua->jcr, ua->db, &num_pools, &ids)) {
bsendmsg(ua, _("Error obtaining pool ids. ERR=%s\n"), db_strerror(ua->db));
return 0;
}
start_prompt(ua, _("Defined Pools:\n"));
for (i=0; i < num_pools; i++) {
opr.PoolId = ids[i];
- if (!db_get_pool_record(ua->db, &opr)) {
+ if (!db_get_pool_record(ua->jcr, ua->db, &opr)) {
continue;
}
add_prompt(ua, opr.Name);
memset(&opr, 0, sizeof(opr));
bstrncpy(opr.Name, name, sizeof(opr.Name));
- if (!db_get_pool_record(ua->db, &opr)) {
+ if (!db_get_pool_record(ua->jcr, ua->db, &opr)) {
bsendmsg(ua, _("Could not find Pool %s: ERR=%s"), name, db_strerror(ua->db));
return 0;
}
bstrncpy(mr->VolumeName, ua->argv[i], sizeof(mr->VolumeName));
}
if (mr->VolumeName[0] == 0) {
- db_list_media_records(ua->db, mr, prtit, ua);
+ db_list_media_records(ua->jcr, ua->db, mr, prtit, ua);
if (!get_cmd(ua, _("Enter MediaId or Volume name: "))) {
return 0;
}
}
}
- if (!db_get_media_record(ua->db, mr)) {
+ if (!db_get_media_record(ua->jcr, ua->db, mr)) {
bsendmsg(ua, "%s", db_strerror(ua->db));
return 0;
}
*/
int select_job_dbr(UAContext *ua, JOB_DBR *jr)
{
- db_list_job_records(ua->db, jr, prtit, ua);
+ db_list_job_records(ua->jcr, ua->db, jr, prtit, ua);
if (!get_cmd(ua, _("Enter the JobId to select: "))) {
return 0;
}
jr->JobId = atoi(ua->cmd);
- if (!db_get_job_record(ua->db, jr)) {
+ if (!db_get_job_record(ua->jcr, ua->db, jr)) {
bsendmsg(ua, "%s", db_strerror(ua->db));
return 0;
}
} else {
continue;
}
- if (!db_get_job_record(ua->db, jr)) {
+ if (!db_get_job_record(ua->jcr, ua->db, jr)) {
bsendmsg(ua, _("Could not find Job %s: ERR=%s"), ua->argv[i],
db_strerror(ua->db));
jr->JobId = 0;
*/
if (jcr->JobLevel == L_VERIFY_CATALOG || jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG) {
memcpy(&jr, &(jcr->jr), sizeof(jr));
- if (!db_find_last_jobid(jcr->db, &jr)) {
+ if (!db_find_last_jobid(jcr, jcr->db, &jr)) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
jcr->jr.JobId = jcr->JobId;
jcr->jr.StartTime = jcr->start_time;
jcr->jr.Level = jcr->JobLevel;
- if (!db_update_job_start_record(jcr->db, &jcr->jr)) {
+ if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
goto bail_out;
}
if (jcr->JobLevel == L_VERIFY_CATALOG || jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG) {
memset(&jr, 0, sizeof(jr));
jr.JobId = JobId;
- if (!db_get_job_record(jcr->db, &jr)) {
+ if (!db_get_job_record(jcr, jcr->db, &jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record. %s"), db_strerror(jcr->db));
goto bail_out;
}
* Now find the Volumes we will need for the Verify
*/
jcr->VolumeName[0] = 0;
- if (!db_get_job_volume_names(jcr->db, jr.JobId, &jcr->VolumeName) ||
+ if (!db_get_job_volume_names(jcr, jcr->db, jr.JobId, &jcr->VolumeName) ||
jcr->VolumeName[0] == 0) {
Jmsg(jcr, M_FATAL, 0, _("Cannot find Volume Name for verify JobId=%d. %s"),
jr.JobId, db_strerror(jcr->db));
* Find equivalent record in the database
*/
fdbr.FileId = 0;
- if (!db_get_file_attributes_record(jcr->db, jcr->fname, &fdbr)) {
+ if (!db_get_file_attributes_record(jcr, jcr->db, jcr->fname, &fdbr)) {
Jmsg(jcr, M_INFO, 0, _("New file: %s\n"), jcr->fname);
Dmsg1(020, _("File not in catalog: %s\n"), jcr->fname);
stat = JS_Differences;
* mark file record as visited by stuffing the
* current JobId, which is unique, into the MarkId field.
*/
- db_mark_file_record(jcr->db, fdbr.FileId, jcr->JobId);
+ db_mark_file_record(jcr, jcr->db, fdbr.FileId, jcr->JobId);
}
Dmsg3(400, "Found %s in catalog. inx=%d Opts=%s\n", jcr->fname,
int i;
status = readdir_r(directory, entry, &result);
- sm_check(__FILE__, __LINE__, False);
Dmsg3(200, "readdir stat=%d result=%x name=%s\n", status, result,
entry->d_name);
if (status != 0 || result == NULL) {
*q++ = *p++;
}
*q = 0;
- sm_check(__FILE__, __LINE__, False);
if (!file_is_excluded(ff_pkt, link)) {
rtn_stat = find_one_file(jcr, ff_pkt, handle_file, pkt, link, our_device, 0);
}
{
struct abufhead *buf;
- sm_check(fname, lineno, True);
if (pool > PM_MAX) {
Emsg2(M_ABORT, 0, "MemPool index %d larger than max %d\n", pool, PM_MAX);
}
struct abufhead *buf;
int pool = 0;
- sm_check(fname, lineno, True);
if ((buf = (struct abufhead *) sm_malloc(fname, lineno, size+HEAD_SIZE)) == NULL) {
Emsg1(M_ABORT, 0, "Out of memory requesting %d bytes\n", size);
}
{
char *cp = (char *)obuf;
- sm_check(fname, lineno, False);
ASSERT(obuf);
cp -= HEAD_SIZE;
return ((struct abufhead *)cp)->ablen;
void *buf;
int pool;
- sm_check(fname, lineno, False);
ASSERT(obuf);
P(mutex);
cp -= HEAD_SIZE;
buf = sm_realloc(fname, lineno, cp, size+HEAD_SIZE);
- sm_check(fname, lineno, True);
if (buf == NULL) {
V(mutex);
Emsg1(M_ABORT, 0, "Out of memory requesting %d bytes\n", size);
pool_ctl[pool].max_size = size;
}
V(mutex);
- sm_check(fname, lineno, False);
return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
}
POOLMEM *sm_check_pool_memory_size(char *fname, int lineno, POOLMEM *obuf, size_t size)
{
- sm_check(fname, lineno, False);
ASSERT(obuf);
if (size <= sizeof_pool_memory(obuf)) {
return obuf;
struct abufhead *buf;
int pool;
- sm_check(fname, lineno, True);
ASSERT(obuf);
P(mutex);
buf = (struct abufhead *)((char *)obuf - HEAD_SIZE);
struct abufhead *buf;
int pool;
- sm_check(__FILE__, __LINE__, False);
ASSERT(obuf);
P(mutex);
buf = (struct abufhead *)((char *)obuf - HEAD_SIZE);
* Check if we have a message destination defined.
* We always report M_ABORT and M_ERROR_TERM
*/
-
- /* There is an apparent compiler bug with the following if
- * statement, so the set_jcr... is simply a noop to reload
- * registers.
- */
- set_jcr_job_status(jcr, jcr->JobStatus);
if (msgs && (type != M_ABORT && type != M_ERROR_TERM) &&
!bit_is_set(type, msgs->send_msg)) {
return; /* no destination */
buf += HEAD_SIZE; /* Increment to user data start */
V(mutex);
}
- sm_check(fname, lineno, True);
Dmsg4(1150, "smalloc %d at %x from %s:%d\n", nbytes, buf, fname, lineno);
return (void *)buf;
}
char *cp = (char *) fp;
struct b_queue *qp;
- sm_check(__FILE__, __LINE__, True);
if (cp == NULL) {
Emsg2(M_ABORT, 0, "Attempt to free NULL called from %s:%d\n", file, line);
}
char *cp = (char *) ptr;
Dmsg4(400, "sm_realloc %s:%d 0x%x %d\n", fname, lineno, ptr, size);
- sm_check(fname, lineno, True);
if (size <= 0) {
e_msg(fname, lineno, M_ABORT, 0, "sm_realloc size: %d\n", size);
}
sm_free(__FILE__, __LINE__, ptr);
}
Dmsg4(150, "sm_realloc %d at %x from %s:%d\n", size, buf, fname, lineno);
- sm_check(fname, lineno, True);
return buf;
}
/* Tell File daemon to send data */
bnet_fsend(fd_sock, OK_data);
- sm_check(__FILE__, __LINE__, False);
-
if (!jcr->no_attributes && jcr->spool_attributes) {
open_spool_file(jcr, jcr->dir_bsock);
}
free_block(block);
return 0;
}
- sm_check(__FILE__, __LINE__, False);
-
Dmsg0(100, "Just after acquire_device_for_append\n");
/*
* Write Begin Session Record
ok = FALSE;
}
- sm_check(__FILE__, __LINE__, False);
-
memset(&rec, 0, sizeof(rec));
/*
ok = FALSE;
break;
}
- sm_check(__FILE__, __LINE__, False);
ds->msg[ds->msglen] = 0;
if (sscanf(ds->msg, "%ld %ld %100s", &file_index, &stream, info) != 3) {
Jmsg1(jcr, M_FATAL, 0, _("Malformed data header from FD: %s\n"), ds->msg);
/* Read data stream from the File daemon.
* The data stream is just raw bytes
*/
- sm_check(__FILE__, __LINE__, False);
while ((n=bget_msg(ds)) > 0 && !job_cancelled(jcr)) {
- sm_check(__FILE__, __LINE__, False);
rec.VolSessionId = jcr->VolSessionId;
rec.VolSessionTime = jcr->VolSessionTime;
rec.FileIndex = file_index;
break;
}
}
- sm_check(__FILE__, __LINE__, False);
if (!ok) {
Dmsg0(400, "Not OK\n");
break;
jcr->dir_bsock->spool = 0;
}
}
- sm_check(__FILE__, __LINE__, False);
}
if (is_bnet_error(ds)) {
Jmsg1(jcr, M_FATAL, 0, _("Network error on data channel. ERR=%s\n"),
* We probably need a new flag that says "Do not attempt
* to write because there is no tape".
*/
- sm_check(__FILE__, __LINE__, False);
Dmsg0(90, "Write_end_session_label()\n");
/* Create Job status for end of session label */
if ((db=db_init_database(NULL, db_name, db_user, db_password)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bacula database\n"));
}
- if (!db_open_database(db)) {
+ if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
/* Check Pool info */
strcpy(pr.Name, dev->VolHdr.PoolName);
strcpy(pr.PoolType, dev->VolHdr.PoolType);
- if (db_get_pool_record(db, &pr)) {
+ if (db_get_pool_record(bjcr, db, &pr)) {
if (verbose) {
Pmsg1(000, _("Pool record for %s found in DB.\n"), pr.Name);
}
memset(&mr, 0, sizeof(mr));
strcpy(mr.VolumeName, dev->VolHdr.VolName);
mr.PoolId = pr.PoolId;
- if (db_get_media_record(db, &mr)) {
+ if (db_get_media_record(bjcr, db, &mr)) {
if (verbose) {
Pmsg1(000, _("Media record for %s found in DB.\n"), mr.VolumeName);
}
unser_session_label(&label, rec);
memset(&jr, 0, sizeof(jr));
jr.JobId = label.JobId;
- if (db_get_job_record(db, &jr)) {
+ if (db_get_job_record(bjcr, db, &jr)) {
/* Job record already exists in DB */
update_db = 0; /* don't change db in create_job_record */
if (verbose) {
jr.JobTDate = (utime_t)mjcr->start_time;
jr.ClientId = mjcr->ClientId;
free_jcr(mjcr);
- if (!db_update_job_end_record(db, &jr)) {
+ if (!db_update_job_end_record(bjcr, db, &jr)) {
Pmsg1(0, _("Could not update job record. ERR=%s\n"), db_strerror(db));
}
}
}
fr.JobId = mjcr->JobId;
fr.FileId = 0;
- if (db_get_file_attributes_record(db, fname, &fr)) {
+ if (db_get_file_attributes_record(bjcr, db, fname, &fr)) {
if (verbose > 1) {
Pmsg1(000, _("File record already exists for: %s\n"), fname);
}
return 1;
}
- if (!db_create_file_attributes_record(db, &ar)) {
+ if (!db_create_file_attributes_record(bjcr, db, &ar)) {
Pmsg1(0, _("Could not create File Attributes record. ERR=%s\n"), db_strerror(db));
return 0;
}
return 1;
}
- if (!db_create_media_record(db, mr)) {
+ if (!db_create_media_record(bjcr, db, mr)) {
Pmsg1(0, _("Could not create media record. ERR=%s\n"), db_strerror(db));
return 0;
}
- if (!db_update_media_record(db, mr)) {
+ if (!db_update_media_record(bjcr, db, mr)) {
Pmsg1(0, _("Could not update media record. ERR=%s\n"), db_strerror(db));
return 0;
}
}
mr->LastWritten = lasttime;
- if (!db_update_media_record(db, mr)) {
+ if (!db_update_media_record(bjcr, db, mr)) {
Pmsg1(0, _("Could not update media record. ERR=%s\n"), db_strerror(db));
return 0;
}
if (!update_db) {
return 1;
}
- if (!db_create_pool_record(db, pr)) {
+ if (!db_create_pool_record(bjcr, db, pr)) {
Pmsg1(0, _("Could not create pool record. ERR=%s\n"), db_strerror(db));
return 0;
}
if (!update_db) {
return 1;
}
- if (!db_create_client_record(db, cr)) {
+ if (!db_create_client_record(bjcr, db, cr)) {
Pmsg1(0, _("Could not create Client record. ERR=%s\n"), db_strerror(db));
return 0;
}
fsr->MD5[0] = ' '; /* Equivalent to nothing */
fsr->MD5[1] = 0;
}
- if (db_get_fileset_record(db, fsr)) {
+ if (db_get_fileset_record(bjcr, db, fsr)) {
if (verbose) {
Pmsg1(000, _("Fileset \"%s\" already exists.\n"), fsr->FileSet);
}
} else {
- if (!db_create_fileset_record(db, fsr)) {
+ if (!db_create_fileset_record(bjcr, db, fsr)) {
Pmsg2(0, _("Could not create FileSet record \"%s\". ERR=%s\n"),
fsr->FileSet, db_strerror(db));
return 0;
}
/* This creates the bare essentials */
- if (!db_create_job_record(db, jr)) {
+ if (!db_create_job_record(bjcr, db, jr)) {
Pmsg1(0, _("Could not create JobId record. ERR=%s\n"), db_strerror(db));
return mjcr;
}
/* This adds the client, StartTime, JobTDate, ... */
- if (!db_update_job_start_record(db, jr)) {
+ if (!db_update_job_start_record(bjcr, db, jr)) {
Pmsg1(0, _("Could not update job start record. ERR=%s\n"), db_strerror(db));
return mjcr;
}
return 1;
}
- if (!db_update_job_end_record(db, jr)) {
+ if (!db_update_job_end_record(bjcr, db, jr)) {
Pmsg2(0, _("Could not update JobId=%u record. ERR=%s\n"), jr->JobId, db_strerror(db));
free_jcr(mjcr);
return 0;
return 1;
}
- if (!db_create_jobmedia_record(db, &jmr)) {
+ if (!db_create_jobmedia_record(bjcr, db, &jmr)) {
Pmsg1(0, _("Could not create JobMedia record. ERR=%s\n"), db_strerror(db));
return 0;
}
return 1;
}
- if (!db_add_MD5_to_file_record(db, mjcr->FileId, MD5buf)) {
+ if (!db_add_MD5_to_file_record(bjcr, db, mjcr->FileId, MD5buf)) {
Pmsg1(0, _("Could not add MD5 to File record. ERR=%s\n"), db_strerror(db));
free_jcr(mjcr);
return 0;
ser_declare;
uint32_t remlen;
- sm_check(__FILE__, __LINE__, False);
remlen = block->buf_len - block->binbuf;
ASSERT(block->binbuf == (uint32_t) (block->bufp - block->buf));
rec->remainder = rec->data_len;
} else {
rec->remainder = rec->data_len + WRITE_RECHDR_LENGTH;
- sm_check(__FILE__, __LINE__, False);
return 0;
}
} else {
remlen -= WRITE_RECHDR_LENGTH;
}
if (remlen == 0) {
- sm_check(__FILE__, __LINE__, False);
return 0; /* partial transfer */
}
} else {
memcpy(block->bufp, rec->data+rec->data_len-rec->remainder,
remlen);
-#ifdef SMCHECK
+#ifdef xxxxxSMCHECK
if (!sm_check_rtn(__FILE__, __LINE__, False)) {
/* We damaged a buffer */
Dmsg6(0, "Damaged block FI=%s SessId=%d Strm=%s len=%d\n\
}
}
rec->remainder = 0; /* did whole transfer */
- sm_check(__FILE__, __LINE__, False);
return 1;
}
/* Open database */
db = db_init_database(NULL, db_name, user, password);
- if (!db_open_database(db)) {
+ if (!db_open_database(NULL, db)) {
Emsg1(M_FATAL, 0, "%s", db_strerror(db));
}
do_interactive_mode();
}
- db_close_database(db);
+ db_close_database(NULL, db);
close_msg(NULL);
term_msg();
return 0;
projects / bacula / bacula / commitdiff