/*
* Use pool and client specified by user to select jobs to prune
* returns add_from string to add in FROM clause
* add_where string to add in WHERE clause
*/
bool prune_set_filter(UAContext *ua, CLIENTRES *client, POOLRES *pool, utime_t period,
POOL_MEM *add_from, POOL_MEM *add_where)
{
utime_t now;
char ed1[50], ed2[MAX_ESCAPE_NAME_LENGTH];
POOL_MEM tmp(PM_MESSAGE);
now = (utime_t)time(NULL);
edit_int64(now - period, ed1);
Dmsg3(150, "now=%lld period=%lld JobTDate=%s\n", now, period, ed1);
Mmsg(tmp, " AND JobTDate < %s ", ed1);
pm_strcat(*add_where, tmp.c_str());
db_lock(ua->db);
if (client) {
db_escape_string(ua->jcr, ua->db, ed2,
client->name(), strlen(client->name()));
Mmsg(tmp, " AND Client.Name = '%s' ", ed2);
pm_strcat(*add_where, tmp.c_str());
pm_strcat(*add_from, " JOIN Client USING (ClientId) ");
}
if (pool) {
db_escape_string(ua->jcr, ua->db, ed2,
pool->name(), strlen(pool->name()));
Mmsg(tmp, " AND Pool.Name = '%s' ", ed2);
pm_strcat(*add_where, tmp.c_str());
/* Use ON() instead of USING for some old SQLite */
pm_strcat(*add_from, " JOIN Pool ON (Job.PoolId = Pool.PoolId) ");
}
Dmsg2(150, "f=%s w=%s\n", add_from->c_str(), add_where->c_str());
db_unlock(ua->db);
return true;
}
int printdbtype( lmgr_t * p_mgr, char *str, db_type_t type, const db_type_u * value_ptr )
{
char tmpstr[4096];
switch ( type )
{
case DB_ID:
/* convert id to str */
entry_id2pk( p_mgr, &value_ptr->val_id, FALSE, tmpstr );
return sprintf( str, DPK, tmpstr );
case DB_TEXT:
/* escape special characters in value */
db_escape_string( &p_mgr->conn, tmpstr, 4096, value_ptr->val_str );
return sprintf( str, "'%s'", tmpstr );
case DB_INT:
return sprintf( str, "%d", value_ptr->val_int );
case DB_UINT:
return sprintf( str, "%u", value_ptr->val_uint );
case DB_BIGINT:
return sprintf( str, "%lld", value_ptr->val_bigint );
case DB_BIGUINT:
return sprintf( str, "%llu", value_ptr->val_biguint );
case DB_BOOL:
if ( value_ptr->val_bool )
return sprintf( str, "1" );
else
return sprintf( str, "0" );
default:
DisplayLog( LVL_CRIT, LISTMGR_TAG, "Error: unknown type %d in %s", type, __FUNCTION__ );
return 0;
}
}
int lmgr_set_var(db_conn_t *pconn, const char *varname, const char *value)
{
GString *query;
int rc;
char escaped[1024];
/* delete var if value is NULL */
if (value == NULL)
{
query = g_string_new("DELETE FROM "VAR_TABLE" WHERE varname =");
g_string_append_printf(query, "'%s'", varname);
rc = db_exec_sql(pconn, query->str, NULL);
goto out;
}
else
query = g_string_new(NULL);
/* escape special characters in value */
rc = db_escape_string(pconn, escaped, sizeof(escaped), value);
if (rc != DB_SUCCESS)
goto out;
g_string_printf(query, "INSERT INTO "VAR_TABLE" (varname,value) VALUES ('%s','%s') "
"ON DUPLICATE KEY UPDATE value='%s'", varname, escaped, escaped);
rc = db_exec_sql(pconn, query->str, NULL);
out:
g_string_free(query, TRUE);
return rc;
}
static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
{
char *p, *f;
/* Find path without the filename.
* I.e. everything after the last / is a "filename".
* OK, maybe it is a directory name, but we treat it like
* a filename. If we don't find a / then the whole name
* must be a path name (e.g. c:).
*/
for (p=f=name; *p; p++) {
if (IsPathSeparator(*p)) {
f = p; /* set pos of last slash */
}
}
if (IsPathSeparator(*f)) { /* did we find a slash? */
f++; /* yes, point to filename */
} else { /* no, whole thing must be path name */
f = p;
}
/* If filename doesn't exist (i.e. root directory), we
* simply create a blank name consisting of a single
* space. This makes handling zero length filenames
* easier.
*/
rx->fnl = p - f;
if (rx->fnl > 0) {
rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
} else {
rx->fname[0] = 0;
rx->fnl = 0;
}
rx->pnl = f - name;
if (rx->pnl > 0) {
rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
} else {
rx->path[0] = 0;
rx->pnl = 0;
}
Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
}
/* Retrieve the FID from the database given the parent FID and the file name. */
int ListMgr_Get_FID_from_Path( lmgr_t * p_mgr, const entry_id_t * parent_fid,
const char *name, entry_id_t * fid)
{
result_handle_t result;
GString *req = NULL;
char escaped[RBH_NAME_MAX*2+1];
DEF_PK(pk);
int rc;
char *str_info[1];
int retry_status;
entry_id2pk(parent_fid, PTR_PK(pk));
db_escape_string(&p_mgr->conn, escaped, sizeof(escaped), name);
req = g_string_new("SELECT id FROM "DNAMES_TABLE" WHERE pkn=");
g_string_append_printf(req, HNAME_FMT, pk, escaped);
retry:
rc = db_exec_sql(&p_mgr->conn, req->str, &result);
retry_status = lmgr_delayed_retry(p_mgr, rc);
if (retry_status == 1)
goto retry;
else if (retry_status == 2) {
rc = DB_RBH_SIG_SHUTDOWN;
goto free_str;
} else if (rc)
goto free_str;
rc = db_next_record(&p_mgr->conn, &result, str_info, 1);
retry_status = lmgr_delayed_retry(p_mgr, rc);
if (retry_status == 1)
goto retry;
else if (retry_status == 2) {
rc = DB_RBH_SIG_SHUTDOWN;
goto free_res;
} else if (rc != DB_SUCCESS)
goto free_res;
rc = pk2entry_id(p_mgr, str_info[0], fid);
free_res:
db_result_free(&p_mgr->conn, &result);
free_str:
g_string_free(req, TRUE);
return rc;
}
/**
* Update NDMP level mapping
*
* Returns: false on failure
* true on success
*/
bool db_update_ndmp_level_mapping(JCR *jcr, B_DB *mdb, JOB_DBR *jr, char *filesystem, int level)
{
bool retval;
char ed1[50], ed2[50], ed3[50];
db_lock(mdb);
mdb->esc_name = check_pool_memory_size(mdb->esc_name, strlen(filesystem) * 2 + 1);
db_escape_string(jcr, mdb, mdb->esc_name, filesystem, strlen(filesystem));
Mmsg(mdb->cmd,
"UPDATE NDMPLevelMap SET DumpLevel='%s' WHERE "
"ClientId='%s' AND FileSetId='%s' AND FileSystem='%s'",
edit_uint64(level, ed1), edit_uint64(jr->ClientId, ed2),
edit_uint64(jr->FileSetId, ed3), mdb->esc_name);
retval = UPDATE_DB(jcr, mdb, mdb->cmd);
db_unlock(mdb);
return retval;
}
/*
* This allows the message handler to operate on the database by using a pointer
* to this function. The pointer is needed because the other daemons do not have
* access to the database. If the pointer is not defined (other daemons), then
* writing the database is disabled.
*/
static bool dir_db_log_insert(JCR *jcr, utime_t mtime, char *msg)
{
int length;
char ed1[50];
char dt[MAX_TIME_LENGTH];
POOL_MEM query(PM_MESSAGE),
esc_msg(PM_MESSAGE);
if (!jcr || !jcr->db || !jcr->db->is_connected()) {
return false;
}
length = strlen(msg) + 1;
esc_msg.check_size(length * 2 + 1);
db_escape_string(jcr, jcr->db, esc_msg.c_str(), msg, length);
bstrutime(dt, sizeof(dt), mtime);
Mmsg(query, "INSERT INTO Log (JobId, Time, LogText) VALUES (%s,'%s','%s')",
edit_int64(jcr->JobId, ed1), dt, esc_msg.c_str());
return db_sql_query(jcr->db, query.c_str());
}
/* Retrieve the FID from the database given the parent FID and the file name. */
int ListMgr_Get_FID_from_Path( lmgr_t * p_mgr, const entry_id_t * parent_fid,
const char *name, entry_id_t * fid)
{
result_handle_t result;
char query[4096];
char escaped[RBH_NAME_MAX*2];
DEF_PK(pk);
int rc;
char *str_info[1];
entry_id2pk(parent_fid, PTR_PK(pk));
db_escape_string(&p_mgr->conn, escaped, RBH_NAME_MAX*2, name);
sprintf(query, "SELECT id FROM "DNAMES_TABLE" WHERE pkn="HNAME_FMT,
pk, escaped);
retry:
rc = db_exec_sql(&p_mgr->conn, query, &result);
if (lmgr_delayed_retry(p_mgr, rc))
goto retry;
else if (rc)
return rc;
rc = db_next_record( &p_mgr->conn, &result, str_info, 1 );
if (lmgr_delayed_retry(p_mgr, rc))
goto retry;
else if (rc != DB_SUCCESS)
goto free_res;
rc = pk2entry_id(p_mgr, str_info[0], fid);
free_res:
db_result_free( &p_mgr->conn, &result );
return rc;
}
/*
* The first step in the restore process is for the user to
* select a list of JobIds from which he will subsequently
* select which files are to be restored.
*
* Returns: 2 if filename list made
* 1 if jobid list made
* 0 on error
*/
static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
{
char *p;
char date[MAX_TIME_LENGTH];
bool have_date = false;
/* Include current second if using current time */
utime_t now = time(NULL) + 1;
JobId_t JobId;
JOB_DBR jr = { (JobId_t)-1 };
bool done = false;
int i, j;
const char *list[] = {
_("List last 20 Jobs run"),
_("List Jobs where a given File is saved"),
_("Enter list of comma separated JobIds to select"),
_("Enter SQL list command"),
_("Select the most recent backup for a client"),
_("Select backup for a client before a specified time"),
_("Enter a list of files to restore"),
_("Enter a list of files to restore before a specified time"),
_("Find the JobIds of the most recent backup for a client"),
_("Find the JobIds for a backup for a client before a specified time"),
_("Enter a list of directories to restore for found JobIds"),
_("Select full restore to a specified Job date"),
_("Cancel"),
NULL
};
const char *kw[] = {
/*
* These keywords are handled in a for loop
*/
"jobid", /* 0 */
"current", /* 1 */
"before", /* 2 */
"file", /* 3 */
"directory", /* 4 */
"select", /* 5 */
"pool", /* 6 */
"all", /* 7 */
/*
* The keyword below are handled by individual arg lookups
*/
"client", /* 8 */
"storage", /* 9 */
"fileset", /* 10 */
"where", /* 11 */
"yes", /* 12 */
"bootstrap", /* 13 */
"done", /* 14 */
"strip_prefix", /* 15 */
"add_prefix", /* 16 */
"add_suffix", /* 17 */
"regexwhere", /* 18 */
"restoreclient", /* 19 */
"copies", /* 20 */
"comment", /* 21 */
"restorejob", /* 22 */
"replace", /* 23 */
"pluginoptions", /* 24 */
NULL
};
rx->JobIds[0] = 0;
for (i = 1; i<ua->argc; i++) { /* loop through arguments */
bool found_kw = false;
for (j = 0; kw[j]; j++) { /* loop through keywords */
if (bstrcasecmp(kw[j], ua->argk[i])) {
found_kw = true;
break;
}
}
if (!found_kw) {
ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
return 0;
}
/* Found keyword in kw[] list, process it */
switch (j) {
case 0: /* jobid */
if (!has_value(ua, i)) {
return 0;
}
if (*rx->JobIds != 0) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->argv[i]);
done = true;
break;
case 1: /* current */
/*
* Note, we add one second here just to include any job
* that may have finished within the current second,
* which happens a lot in scripting small jobs.
*/
bstrutime(date, sizeof(date), now);
have_date = true;
break;
case 2: /* before */
if (have_date || !has_value(ua, i)) {
return 0;
}
if (str_to_utime(ua->argv[i]) == 0) {
ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
return 0;
}
bstrncpy(date, ua->argv[i], sizeof(date));
have_date = true;
break;
case 3: /* file */
case 4: /* dir */
if (!has_value(ua, i)) {
return 0;
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
pm_strcpy(ua->cmd, ua->argv[i]);
insert_one_file_or_dir(ua, rx, date, j==4);
return 2;
case 5: /* select */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = true;
break;
case 6: /* pool specified */
if (!has_value(ua, i)) {
return 0;
}
rx->pool = (POOLRES *)GetResWithName(R_POOL, ua->argv[i]);
if (!rx->pool) {
ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
return 0;
}
if (!acl_access_ok(ua, Pool_ACL, ua->argv[i], true)) {
rx->pool = NULL;
ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
return 0;
}
break;
case 7: /* all specified */
rx->all = true;
break;
default:
/*
* All keywords 7 or greater are ignored or handled by a select prompt
*/
break;
}
}
if (!done) {
ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
"to be restored. You will be presented several methods\n"
"of specifying the JobIds. Then you will be allowed to\n"
"select which files from those JobIds are to be restored.\n\n"));
}
/* If choice not already made above, prompt */
for ( ; !done; ) {
char *fname;
int len;
bool gui_save;
db_list_ctx jobids;
start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
for (int i=0; list[i]; i++) {
add_prompt(ua, list[i]);
}
done = true;
switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
case -1: /* error or cancel */
return 0;
case 0: /* list last 20 Jobs run */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 1: /* list where a file is saved */
if (!get_client_name(ua, rx)) {
return 0;
}
if (!get_cmd(ua, _("Enter Filename (no path):"))) {
return 0;
}
len = strlen(ua->cmd);
fname = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
Mmsg(rx->query, uar_file[db_get_type_index(ua->db)], rx->ClientName, fname);
free(fname);
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, rx->query, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 2: /* enter a list of JobIds */
if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
return 0;
}
pm_strcpy(rx->JobIds, ua->cmd);
break;
case 3: /* Enter an SQL list command */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
if (!get_cmd(ua, _("Enter SQL list command: "))) {
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, ua->cmd, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 4: /* Select the most recent backups */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 5: /* select backup at specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 6: /* Enter files */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 7: /* enter files backed up before specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 8: /* Find JobIds for current backup */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 9: /* Find JobIds for give date */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 10: /* Enter directories */
if (*rx->JobIds != 0) {
ua->send_msg(_("You have already selected the following JobIds: %s\n"),
rx->JobIds);
} else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
if (*rx->JobIds != 0 && *ua->cmd) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->cmd);
}
if (*rx->JobIds == 0 || *rx->JobIds == '.') {
*rx->JobIds = 0;
return 0; /* nothing entered, return */
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter full directory names or start the name\n"
"with a < to indicate it is a filename containing a list\n"
"of directories and terminate them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter directory name: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
/* Add trailing slash to end of directory names */
if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
strcat(ua->cmd, "/");
}
insert_one_file_or_dir(ua, rx, date, true);
}
return 2;
case 11: /* Choose a jobid and select jobs */
if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
!is_an_integer(ua->cmd))
{
return 0;
}
memset(&jr, 0, sizeof(jr));
jr.JobId = str_to_int64(ua->cmd);
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->cmd, db_strerror(ua->db));
return 0;
}
ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
jr.cStartTime);
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
return 0;
}
pm_strcpy(rx->JobIds, jobids.list);
Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
break;
case 12: /* Cancel or quit */
return 0;
}
}
memset(&jr, 0, sizeof(jr));
POOLMEM *JobIds = get_pool_memory(PM_FNAME);
*JobIds = 0;
rx->TotalFiles = 0;
/*
* Find total number of files to be restored, and filter the JobId
* list to contain only ones permitted by the ACL conditions.
*/
for (p=rx->JobIds; ; ) {
char ed1[50];
int status = get_next_jobid_from_list(&p, &JobId);
if (status < 0) {
ua->error_msg(_("Invalid JobId in list.\n"));
free_pool_memory(JobIds);
return 0;
}
if (status == 0) {
break;
}
if (jr.JobId == JobId) {
continue; /* duplicate of last JobId */
}
memset(&jr, 0, sizeof(jr));
jr.JobId = JobId;
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
edit_int64(JobId, ed1), db_strerror(ua->db));
free_pool_memory(JobIds);
return 0;
}
if (!acl_access_ok(ua, Job_ACL, jr.Name, true)) {
ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
edit_int64(JobId, ed1), jr.Name);
continue;
}
if (*JobIds != 0) {
pm_strcat(JobIds, ",");
}
pm_strcat(JobIds, edit_int64(JobId, ed1));
rx->TotalFiles += jr.JobFiles;
}
free_pool_memory(rx->JobIds);
rx->JobIds = JobIds; /* Set ACL filtered list */
if (*rx->JobIds == 0) {
ua->warning_msg(_("No Jobs selected.\n"));
return 0;
}
if (strchr(rx->JobIds,',')) {
ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
} else {
ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
}
return true;
}
/*
* Prune Directory meta data records from the database.
*/
static bool prune_directory(UAContext *ua, CLIENTRES *client)
{
int i, len;
CLIENT_DBR cr;
char *prune_topdir = NULL;
POOL_MEM query(PM_MESSAGE),
temp(PM_MESSAGE);
bool recursive = false;
bool retval = false;
/*
* See if a client was selected.
*/
if (!client) {
if (!get_yesno(ua, _("No client restriction given really remove "
"directory for all clients (yes/no): ")) ||
ua->pint32_val == 0) {
if (!(client = get_client_resource(ua))) {
return false;
}
}
}
/*
* See if we need to recursively remove all directories under a certain path.
*/
recursive = find_arg(ua, NT_("recursive")) >= 0;
/*
* Get the directory to prune.
*/
i = find_arg_with_value(ua, NT_("directory"));
if (i >= 0) {
pm_strcpy(temp, ua->argv[i]);
} else {
if (recursive) {
if (!get_cmd(ua, _("Please enter the full path prefix to remove: "), false)) {
return false;
}
} else {
if (!get_cmd(ua, _("Please enter the full path to remove: "), false)) {
return false;
}
}
pm_strcpy(temp, ua->cmd);
}
/*
* See if the directory ends in a / and escape it for usage in a database query.
*/
len = strlen(temp.c_str());
if (*(temp.c_str() + len - 1) != '/') {
pm_strcat(temp, "/");
len++;
}
prune_topdir = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, prune_topdir, temp.c_str(), len);
/*
* Remove all files in particular directory.
*/
if (recursive) {
Mmsg(query, "DELETE FROM file WHERE pathid IN ("
"SELECT pathid FROM path "
"WHERE path LIKE '%s%%'"
")", prune_topdir);
} else {
Mmsg(query, "DELETE FROM file WHERE pathid IN ("
"SELECT pathid FROM path "
"WHERE path LIKE '%s'"
")", prune_topdir);
}
if (client) {
char ed1[50];
memset(&cr, 0, sizeof(cr));
bstrncpy(cr.Name, client->name(), sizeof(cr.Name));
if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
goto bail_out;
}
Mmsg(temp, " AND JobId IN ("
"SELECT JobId FROM Job "
"WHERE ClientId=%s"
")", edit_int64(cr.ClientId, ed1));
pm_strcat(query, temp.c_str());
}
db_lock(ua->db);
db_sql_query(ua->db, query.c_str());
db_unlock(ua->db);
/*
* If we removed the entries from the file table without limiting it to a
* certain client we created orphaned path entries as no one is referencing
* them anymore.
*/
if (!client) {
if (!get_yesno(ua, _("Cleanup orphaned path records (yes/no):")) ||
ua->pint32_val == 0) {
retval = true;
goto bail_out;
}
if (recursive) {
Mmsg(query, "DELETE FROM path "
"WHERE path LIKE '%s%%'", prune_topdir);
} else {
Mmsg(query, "DELETE FROM path "
"WHERE path LIKE '%s'", prune_topdir);
}
db_lock(ua->db);
db_sql_query(ua->db, query.c_str());
db_unlock(ua->db);
}
retval = true;
bail_out:
if (prune_topdir) {
free(prune_topdir);
}
return retval;
}
/*
* This routine is called only during a Verify
*/
void get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId)
{
BSOCK *fd;
int n, len;
FILE_DBR fdbr;
struct stat statf; /* file stat */
struct stat statc; /* catalog stat */
char buf[MAXSTRING];
POOLMEM *fname = get_pool_memory(PM_MESSAGE);
int do_Digest = CRYPTO_DIGEST_NONE;
int32_t file_index = 0;
memset(&fdbr, 0, sizeof(FILE_DBR));
fd = jcr->file_bsock;
fdbr.JobId = JobId;
jcr->FileIndex = 0;
Dmsg0(20, "bdird: waiting to receive file attributes\n");
/*
* Get Attributes and Signature from File daemon
* We expect:
* FileIndex
* Stream
* Options or Digest (MD5/SHA1)
* Filename
* Attributes
* Link name ???
*/
while ((n=bget_dirmsg(fd)) >= 0 && !job_canceled(jcr)) {
int32_t stream, full_stream;
char *attr, *p, *fn;
char Opts_Digest[MAXSTRING]; /* Verify Opts or MD5/SHA1 digest */
if (job_canceled(jcr)) {
free_pool_memory(fname);
return;
}
fname = check_pool_memory_size(fname, fd->msglen);
jcr->fname = check_pool_memory_size(jcr->fname, fd->msglen);
Dmsg1(200, "Atts+Digest=%s\n", fd->msg);
if ((len = sscanf(fd->msg, "%ld %d %100s", &file_index, &full_stream,
fname)) != 3) {
Jmsg3(jcr, M_FATAL, 0, _("bird<filed: bad attributes, expected 3 fields got %d\n"
" mslen=%d msg=%s\n"), len, fd->msglen, fd->msg);
free_pool_memory(fname);
return;
}
stream = full_stream & STREAMMASK_TYPE;
Dmsg4(30, "Got hdr: FilInx=%d FullStream=%d Stream=%d fname=%s.\n", file_index, full_stream, stream, fname);
/*
* We read the Options or Signature into fname
* to prevent overrun, now copy it to proper location.
*/
bstrncpy(Opts_Digest, fname, sizeof(Opts_Digest));
p = fd->msg;
skip_nonspaces(&p); /* skip FileIndex */
skip_spaces(&p);
skip_nonspaces(&p); /* skip Stream */
skip_spaces(&p);
skip_nonspaces(&p); /* skip Opts_Digest */
p++; /* skip space */
fn = fname;
while (*p != 0) {
*fn++ = *p++; /* copy filename */
}
*fn = *p++; /* term filename and point to attribs */
attr = p;
/*
* Got attributes stream, decode it
*/
if (stream == STREAM_UNIX_ATTRIBUTES || stream == STREAM_UNIX_ATTRIBUTES_EX) {
int32_t LinkFIf, LinkFIc;
Dmsg2(400, "file_index=%d attr=%s\n", file_index, attr);
jcr->JobFiles++;
jcr->FileIndex = file_index; /* remember attribute file_index */
jcr->previous_jr.FileIndex = file_index;
decode_stat(attr, &statf, sizeof(statf), &LinkFIf); /* decode file stat packet */
do_Digest = CRYPTO_DIGEST_NONE;
jcr->fn_printed = false;
pm_strcpy(jcr->fname, fname); /* move filename into JCR */
Dmsg2(040, "dird<filed: stream=%d %s\n", stream, jcr->fname);
Dmsg1(020, "dird<filed: attr=%s\n", attr);
/*
* Find equivalent record in the database
*/
fdbr.FileId = 0;
if (!db_get_file_attributes_record(jcr, jcr->db, jcr->fname,
&jcr->previous_jr, &fdbr)) {
Jmsg(jcr, M_INFO, 0, _("New file: %s\n"), jcr->fname);
Dmsg1(020, _("File not in catalog: %s\n"), jcr->fname);
jcr->setJobStatus(JS_Differences);
continue;
} else {
/*
* mark file record as visited by stuffing the
* current JobId, which is unique, into the MarkId field.
*/
db_mark_file_record(jcr, jcr->db, fdbr.FileId, jcr->JobId);
}
Dmsg3(400, "Found %s in catalog. inx=%d Opts=%s\n", jcr->fname,
file_index, Opts_Digest);
decode_stat(fdbr.LStat, &statc, sizeof(statc), &LinkFIc); /* decode catalog stat */
/*
* Loop over options supplied by user and verify the
* fields he requests.
*/
for (p=Opts_Digest; *p; p++) {
char ed1[30], ed2[30];
switch (*p) {
case 'i': /* compare INODEs */
if (statc.st_ino != statf.st_ino) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_ino differ. Cat: %s File: %s\n"),
edit_uint64((uint64_t)statc.st_ino, ed1),
edit_uint64((uint64_t)statf.st_ino, ed2));
jcr->setJobStatus(JS_Differences);
}
break;
case 'p': /* permissions bits */
if (statc.st_mode != statf.st_mode) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_mode differ. Cat: %x File: %x\n"),
(uint32_t)statc.st_mode, (uint32_t)statf.st_mode);
jcr->setJobStatus(JS_Differences);
}
break;
case 'n': /* number of links */
if (statc.st_nlink != statf.st_nlink) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_nlink differ. Cat: %d File: %d\n"),
(uint32_t)statc.st_nlink, (uint32_t)statf.st_nlink);
jcr->setJobStatus(JS_Differences);
}
break;
case 'u': /* user id */
if (statc.st_uid != statf.st_uid) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_uid differ. Cat: %u File: %u\n"),
(uint32_t)statc.st_uid, (uint32_t)statf.st_uid);
jcr->setJobStatus(JS_Differences);
}
break;
case 'g': /* group id */
if (statc.st_gid != statf.st_gid) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_gid differ. Cat: %u File: %u\n"),
(uint32_t)statc.st_gid, (uint32_t)statf.st_gid);
jcr->setJobStatus(JS_Differences);
}
break;
case 's': /* size */
if (statc.st_size != statf.st_size) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_size differ. Cat: %s File: %s\n"),
edit_uint64((uint64_t)statc.st_size, ed1),
edit_uint64((uint64_t)statf.st_size, ed2));
jcr->setJobStatus(JS_Differences);
}
break;
case 'a': /* access time */
if (statc.st_atime != statf.st_atime) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_atime differs\n"));
jcr->setJobStatus(JS_Differences);
}
break;
case 'm':
if (statc.st_mtime != statf.st_mtime) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_mtime differs\n"));
jcr->setJobStatus(JS_Differences);
}
break;
case 'c': /* ctime */
if (statc.st_ctime != statf.st_ctime) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_ctime differs\n"));
jcr->setJobStatus(JS_Differences);
}
break;
case 'd': /* file size decrease */
if (statc.st_size > statf.st_size) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" st_size decrease. Cat: %s File: %s\n"),
edit_uint64((uint64_t)statc.st_size, ed1),
edit_uint64((uint64_t)statf.st_size, ed2));
jcr->setJobStatus(JS_Differences);
}
break;
case '5': /* compare MD5 */
Dmsg1(500, "set Do_MD5 for %s\n", jcr->fname);
do_Digest = CRYPTO_DIGEST_MD5;
break;
case '1': /* compare SHA1 */
do_Digest = CRYPTO_DIGEST_SHA1;
break;
case ':':
case 'V':
default:
break;
}
}
/*
* Got Digest Signature from Storage daemon
* It came across in the Opts_Digest field.
*/
} else if (crypto_digest_stream_type(stream) != CRYPTO_DIGEST_NONE) {
Dmsg2(400, "stream=Digest inx=%d Digest=%s\n", file_index, Opts_Digest);
/*
* When ever we get a digest it MUST have been
* preceded by an attributes record, which sets attr_file_index
*/
if (jcr->FileIndex != (uint32_t)file_index) {
Jmsg2(jcr, M_FATAL, 0, _("MD5/SHA1 index %d not same as attributes %d\n"),
file_index, jcr->FileIndex);
free_pool_memory(fname);
return;
}
if (do_Digest != CRYPTO_DIGEST_NONE) {
db_escape_string(jcr, jcr->db, buf, Opts_Digest, strlen(Opts_Digest));
if (strcmp(buf, fdbr.Digest) != 0) {
prt_fname(jcr);
Jmsg(jcr, M_INFO, 0, _(" %s differs. File=%s Cat=%s\n"),
stream_to_ascii(stream), buf, fdbr.Digest);
jcr->setJobStatus(JS_Differences);
}
do_Digest = CRYPTO_DIGEST_NONE;
}
}
jcr->JobFiles = file_index;
}
if (fd->is_error()) {
berrno be;
Jmsg2(jcr, M_FATAL, 0, _("bdird<filed: bad attributes from filed n=%d : %s\n"),
n, be.bstrerror());
free_pool_memory(fname);
return;
}
/* Now find all the files that are missing -- i.e. all files in
* the database where the MarkId != current JobId
*/
jcr->fn_printed = false;
bsnprintf(buf, sizeof(buf),
"SELECT Path.Path,Filename.Name FROM File,Path,Filename "
"WHERE File.JobId=%d AND File.FileIndex > 0 "
"AND File.MarkId!=%d AND File.PathId=Path.PathId "
"AND File.FilenameId=Filename.FilenameId",
JobId, jcr->JobId);
/* missing_handler is called for each file found */
db_sql_query(jcr->db, buf, missing_handler, (void *)jcr);
if (jcr->fn_printed) {
jcr->setJobStatus(JS_Differences);
}
free_pool_memory(fname);
}
static POOLMEM *substitute_prompts(UAContext *ua,
POOLMEM *query, char **prompt, int nprompt)
{
char *p, *q, *o;
POOLMEM *new_query;
int i, n, len, olen;
char *subst[9];
if (nprompt == 0) {
return query;
}
for (i=0; i<9; i++) {
subst[i] = NULL;
}
new_query = get_pool_memory(PM_FNAME);
o = new_query;
for (q=query; (p=strchr(q, '%')); ) {
if (p) {
olen = o - new_query;
new_query = check_pool_memory_size(new_query, olen + p - q + 10);
o = new_query + olen;
while (q < p) { /* copy up to % */
*o++ = *q++;
}
p++;
switch (*p) {
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
n = (int)(*p) - (int)'1';
if (prompt[n]) {
if (!subst[n]) {
if (!get_cmd(ua, prompt[n])) {
q += 2;
break;
}
}
len = strlen(ua->cmd);
p = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, p, ua->cmd, len);
subst[n] = p;
olen = o - new_query;
new_query = check_pool_memory_size(new_query, olen + strlen(p) + 10);
o = new_query + olen;
while (*p) {
*o++ = *p++;
}
} else {
ua->error_msg(_("Warning prompt %d missing.\n"), n+1);
}
q += 2;
break;
case '%':
*o++ = '%';
q += 2;
break;
default:
*o++ = '%';
q++;
break;
}
}
}
olen = o - new_query;
new_query = check_pool_memory_size(new_query, olen + strlen(q) + 10);
o = new_query + olen;
while (*q) {
*o++ = *q++;
}
*o = 0;
for (i=0; i<9; i++) {
if (subst[i]) {
free(subst[i]);
}
}
free_pool_memory(query);
return new_query;
}