/* fill the items list with the output of the help command */
void get_arguments(const char *what)
{
regex_t preg;
POOLMEM *buf;
int rc;
init_items();
rc = regcomp(&preg, "(([a-z_]+=)|([a-z]+)( |$))", REG_EXTENDED);
if (rc != 0) {
return;
}
buf = get_pool_memory(PM_MESSAGE);
UA_sock->fsend(".help item=%s", what);
while (UA_sock->recv() > 0) {
strip_trailing_junk(UA_sock->msg);
match_kw(&preg, UA_sock->msg, UA_sock->msglen, &buf);
}
free_pool_memory(buf);
regfree(&preg);
}
/*
* Dump a buffer to a file in the working directory
* Needed to unserialise() a config
*/
bool ConfigFile::dump_string(const char *buf, int32_t len)
{
FILE *fp;
bool ret = false;
if (!out_fname) {
out_fname = get_pool_memory(PM_FNAME);
make_unique_filename(out_fname, (int)(intptr_t)this, (char*)"configfile");
}
fp = fopen(out_fname, "wb");
if (!fp) {
return ret;
}
if (fwrite(buf, len, 1, fp) == 1) {
ret = true;
}
fclose(fp);
return ret;
}
/*
* This routine is ONLY for resource names
* Store a name at specified address.
*/
static void store_name(LEX *lc, RES_ITEM *item, int index, int pass)
{
POOLMEM *msg = get_pool_memory(PM_EMSG);
URES *res_all = (URES *)my_config->m_res_all;
lex_get_token(lc, T_NAME);
if (!is_name_valid(lc->str, &msg)) {
scan_err1(lc, "%s\n", msg);
return;
}
free_pool_memory(msg);
/*
* Store the name both pass 1 and pass 2
*/
if (*(item->value)) {
scan_err2(lc, _("Attempt to redefine name \"%s\" to \"%s\"."),
*(item->value), lc->str);
return;
}
*(item->value) = bstrdup(lc->str);
scan_to_eol(lc);
set_bit(index, res_all->hdr.item_present);
}
static bool open_attr_spool_file(JCR *jcr, BSOCK *bs)
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
make_unique_spool_filename(jcr, &name, bs->m_fd);
bs->m_spool_fd = open(name, O_CREAT | O_TRUNC | O_RDWR | O_BINARY, 0640);
if (bs->m_spool_fd == -1) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name, be.bstrerror());
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
free_pool_memory(name);
return false;
}
P(mutex);
spool_stats.attr_jobs++;
V(mutex);
free_pool_memory(name);
return true;
}
static bool close_data_spool_file(DCR *dcr)
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
P(mutex);
spool_stats.data_jobs--;
spool_stats.total_data_jobs++;
if (spool_stats.data_size < dcr->job_spool_size) {
spool_stats.data_size = 0;
} else {
spool_stats.data_size -= dcr->job_spool_size;
}
dcr->job_spool_size = 0;
V(mutex);
make_unique_data_spool_filename(dcr, &name);
close(dcr->spool_fd);
dcr->spool_fd = -1;
dcr->spooling = false;
unlink(name);
Dmsg1(100, "Deleted spool file: %s\n", name);
free_pool_memory(name);
return true;
}
/* Dump the item table format to a text file (used by plugin) */
int ConfigFile::serialize(POOLMEM **buf)
{
int len;
POOLMEM *tmp;
if (!items) {
**buf = 0;
return 0;
}
len = Mmsg(buf, "# Plugin configuration file\n# Version %d\n", version);
tmp = get_pool_memory(PM_MESSAGE);
for (int i = 0; items[i].name; i++) {
if (items[i].comment) {
Mmsg(tmp, "OptPrompt=%s\n", items[i].comment);
pm_strcat(buf, tmp);
}
if (items[i].default_value) {
Mmsg(tmp, "OptDefault=%s\n", items[i].default_value);
pm_strcat(buf, tmp);
}
if (items[i].required) {
Mmsg(tmp, "OptRequired=yes\n");
pm_strcat(buf, tmp);
}
/* variable = @INT64@ */
Mmsg(tmp, "%s=%s\n\n",
items[i].name, ini_get_store_code(items[i].handler));
len = pm_strcat(buf, tmp);
}
free_pool_memory(tmp);
return len ;
}
bool close_attr_spool_file(JCR *jcr, BSOCK *bs)
{
POOLMEM *name;
char tbuf[100];
Dmsg1(100, "Close attr spool file at %s\n", bstrftimes(tbuf, sizeof(tbuf),
(utime_t)time(NULL)));
if (!bs->m_spool_fd) {
return true;
}
name = get_pool_memory(PM_MESSAGE);
P(mutex);
spool_stats.attr_jobs--;
spool_stats.total_attr_jobs++;
V(mutex);
make_unique_spool_filename(jcr, &name, bs->m_fd);
fclose(bs->m_spool_fd);
unlink(name);
free_pool_memory(name);
bs->m_spool_fd = NULL;
bs->clear_spooling();
return true;
}
int main (int argc, char *argv[])
{
int ch;
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
alist *backend_directories = NULL;
#endif
char *jobids = (char *)"1";
char *path=NULL, *client=NULL;
uint64_t limit=0;
bool clean=false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
Dmsg0(0, "Starting bvfs_test tool\n");
my_name_is(argc, argv, "bvfs_test");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "h:c:l:d:D:n:P:Su:vf:w:?j:p:f:T")) != -1) {
switch (ch) {
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'l':
limit = str_to_int64(optarg);
break;
case 'c':
client = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'p':
path = optarg;
break;
case 'f':
file = optarg;
break;
case 'j':
jobids = optarg;
break;
case 'T':
clean = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bvfs_test", sizeof(bjcr->Job));
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
backend_directories = New(alist(10, owned_by_alist));
backend_directories->append((char *)backend_directory);
db_set_backend_dirs(backend_directories);
#endif
if ((db = db_init_database(NULL, NULL, db_name, db_user, db_password, db_host, 0, NULL)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
Dmsg1(0, "db_type=%s\n", db_get_type(db));
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
if (clean) {
Pmsg0(0, "Clean old table\n");
db_sql_query(db, "DELETE FROM PathHierarchy", NULL, NULL);
db_sql_query(db, "UPDATE Job SET HasCache=0", NULL, NULL);
db_sql_query(db, "DELETE FROM PathVisibility", NULL, NULL);
bvfs_update_cache(bjcr, db);
}
Bvfs fs(bjcr, db);
fs.set_handler(result_handler, &fs);
fs.set_jobids(jobids);
fs.update_cache();
if (limit)
fs.set_limit(limit);
if (path) {
fs.ch_dir(path);
fs.ls_special_dirs();
fs.ls_dirs();
while (fs.ls_files()) {
fs.next_offset();
}
if (fnid && client) {
Pmsg0(0, "---------------------------------------------\n");
Pmsg1(0, "Getting file version for %s\n", file);
fs.get_all_file_versions(fs.get_pwd(), fnid, client);
}
exit (0);
}
Pmsg0(0, "list /\n");
fs.ch_dir("/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/\n");
fs.ch_dir("/tmp/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/regress/\n");
fs.ch_dir("/tmp/regress/");
fs.ls_special_dirs();
fs.ls_files();
fs.ls_dirs();
Pmsg0(0, "list /tmp/regress/build/\n");
fs.ch_dir("/tmp/regress/build/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
fs.get_all_file_versions(1, 347, "zog4-fd");
char p[200];
strcpy(p, "/tmp/toto/rep/");
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/toto/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
return 0;
}
/*
* Restore files
*/
bool restore_cmd(UAContext *ua, const char *cmd)
{
RESTORE_CTX rx; /* restore context */
POOL_MEM buf;
JOBRES *job;
int i;
JCR *jcr = ua->jcr;
char *escaped_bsr_name = NULL;
char *escaped_where_name = NULL;
char *strip_prefix, *add_prefix, *add_suffix, *regexp;
strip_prefix = add_prefix = add_suffix = regexp = NULL;
memset(&rx, 0, sizeof(rx));
rx.path = get_pool_memory(PM_FNAME);
rx.fname = get_pool_memory(PM_FNAME);
rx.JobIds = get_pool_memory(PM_FNAME);
rx.JobIds[0] = 0;
rx.BaseJobIds = get_pool_memory(PM_FNAME);
rx.query = get_pool_memory(PM_FNAME);
rx.bsr = new_bsr();
i = find_arg_with_value(ua, "comment");
if (i >= 0) {
rx.comment = ua->argv[i];
if (!is_comment_legal(ua, rx.comment)) {
goto bail_out;
}
}
i = find_arg_with_value(ua, "backupformat");
if (i >= 0) {
rx.backup_format = ua->argv[i];
}
i = find_arg_with_value(ua, "where");
if (i >= 0) {
rx.where = ua->argv[i];
}
i = find_arg_with_value(ua, "replace");
if (i >= 0) {
rx.replace = ua->argv[i];
}
i = find_arg_with_value(ua, "pluginoptions");
if (i >= 0) {
rx.plugin_options = ua->argv[i];
}
i = find_arg_with_value(ua, "strip_prefix");
if (i >= 0) {
strip_prefix = ua->argv[i];
}
i = find_arg_with_value(ua, "add_prefix");
if (i >= 0) {
add_prefix = ua->argv[i];
}
i = find_arg_with_value(ua, "add_suffix");
if (i >= 0) {
add_suffix = ua->argv[i];
}
i = find_arg_with_value(ua, "regexwhere");
if (i >= 0) {
rx.RegexWhere = ua->argv[i];
}
if (strip_prefix || add_suffix || add_prefix) {
int len = bregexp_get_build_where_size(strip_prefix, add_prefix, add_suffix);
regexp = (char *)bmalloc(len * sizeof(char));
bregexp_build_where(regexp, len, strip_prefix, add_prefix, add_suffix);
rx.RegexWhere = regexp;
}
/* TODO: add acl for regexwhere ? */
if (rx.RegexWhere) {
if (!acl_access_ok(ua, Where_ACL, rx.RegexWhere, true)) {
ua->error_msg(_("\"RegexWhere\" specification not authorized.\n"));
goto bail_out;
}
}
if (rx.where) {
if (!acl_access_ok(ua, Where_ACL, rx.where, true)) {
ua->error_msg(_("\"where\" specification not authorized.\n"));
goto bail_out;
}
}
if (!open_client_db(ua, true)) {
goto bail_out;
}
/* Ensure there is at least one Restore Job */
LockRes();
foreach_res(job, R_JOB) {
if (job->JobType == JT_RESTORE) {
if (!rx.restore_job) {
rx.restore_job = job;
}
rx.restore_jobs++;
}
}
UnlockRes();
if (!rx.restore_jobs) {
ua->error_msg(_(
"No Restore Job Resource found in bareos-dir.conf.\n"
"You must create at least one before running this command.\n"));
goto bail_out;
}
/*
* Request user to select JobIds or files by various different methods
* last 20 jobs, where File saved, most recent backup, ...
* In the end, a list of files are pumped into
* add_findex()
*/
switch (user_select_jobids_or_files(ua, &rx)) {
case 0: /* error */
goto bail_out;
case 1: /* selected by jobid */
get_and_display_basejobs(ua, &rx);
if (!build_directory_tree(ua, &rx)) {
ua->send_msg(_("Restore not done.\n"));
goto bail_out;
}
break;
case 2: /* selected by filename, no tree needed */
break;
}
if (rx.bsr->JobId) {
char ed1[50];
if (!complete_bsr(ua, rx.bsr)) { /* find Vol, SessId, SessTime from JobIds */
ua->error_msg(_("Unable to construct a valid BSR. Cannot continue.\n"));
goto bail_out;
}
if (!(rx.selected_files = write_bsr_file(ua, rx))) {
ua->warning_msg(_("No files selected to be restored.\n"));
goto bail_out;
}
display_bsr_info(ua, rx); /* display vols needed, etc */
if (rx.selected_files==1) {
ua->info_msg(_("\n1 file selected to be restored.\n\n"));
} else {
ua->info_msg(_("\n%s files selected to be restored.\n\n"),
edit_uint64_with_commas(rx.selected_files, ed1));
}
} else {
ua->warning_msg(_("No files selected to be restored.\n"));
goto bail_out;
}
if (rx.restore_jobs == 1) {
job = rx.restore_job;
} else {
job = get_restore_job(ua);
}
if (!job) {
goto bail_out;
}
if (!get_client_name(ua, &rx)) {
goto bail_out;
}
if (!rx.ClientName) {
ua->error_msg(_("No Client resource found!\n"));
goto bail_out;
}
if (!get_restore_client_name(ua, rx)) {
goto bail_out;
}
escaped_bsr_name = escape_filename(jcr->RestoreBootstrap);
Mmsg(ua->cmd,
"run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
" bootstrap=\"%s\" files=%u catalog=\"%s\"",
job->name(), rx.ClientName, rx.RestoreClientName,
rx.store?rx.store->name():"",
escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
rx.selected_files, ua->catalog->name());
/*
* Build run command
*/
if (rx.backup_format) {
Mmsg(buf, " backupformat=%s", rx.backup_format);
pm_strcat(ua->cmd, buf);
}
pm_strcpy(buf, "");
if (rx.RegexWhere) {
escaped_where_name = escape_filename(rx.RegexWhere);
Mmsg(buf, " regexwhere=\"%s\"",
escaped_where_name ? escaped_where_name : rx.RegexWhere);
} else if (rx.where) {
escaped_where_name = escape_filename(rx.where);
Mmsg(buf," where=\"%s\"",
escaped_where_name ? escaped_where_name : rx.where);
}
pm_strcat(ua->cmd, buf);
if (rx.replace) {
Mmsg(buf, " replace=%s", rx.replace);
pm_strcat(ua->cmd, buf);
}
if (rx.plugin_options) {
Mmsg(buf, " pluginoptions=%s", rx.plugin_options);
pm_strcat(ua->cmd, buf);
}
if (rx.comment) {
Mmsg(buf, " comment=\"%s\"", rx.comment);
pm_strcat(ua->cmd, buf);
}
if (escaped_bsr_name != NULL) {
bfree(escaped_bsr_name);
}
if (escaped_where_name != NULL) {
bfree(escaped_where_name);
}
if (regexp) {
bfree(regexp);
}
if (find_arg(ua, NT_("yes")) > 0) {
pm_strcat(ua->cmd, " yes"); /* pass it on to the run command */
}
Dmsg1(200, "Submitting: %s\n", ua->cmd);
/*
* Transfer jobids to jcr to for picking up restore objects
*/
jcr->JobIds = rx.JobIds;
rx.JobIds = NULL;
parse_ua_args(ua);
run_cmd(ua, ua->cmd);
free_rx(&rx);
garbage_collect_memory(); /* release unused memory */
return true;
bail_out:
if (escaped_bsr_name != NULL) {
bfree(escaped_bsr_name);
}
if (escaped_where_name != NULL) {
bfree(escaped_where_name);
}
if (regexp) {
bfree(regexp);
}
free_rx(&rx);
garbage_collect_memory(); /* release unused memory */
return false;
}
/*
* 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;
}
/*
* Update a media record -- allows you to change the
* Volume status. E.g. if you want Bacula to stop
* writing on the volume, set it to anything other
* than Append.
*/
static int update_volume(UAContext *ua)
{
MEDIA_DBR mr;
POOL *pool;
POOL_DBR pr;
POOLMEM *query;
POOL_MEM ret;
char buf[1000];
char ed1[130];
bool done = false;
int i;
const char *kw[] = {
NT_("VolStatus"), /* 0 */
NT_("VolRetention"), /* 1 */
NT_("VolUse"), /* 2 */
NT_("MaxVolJobs"), /* 3 */
NT_("MaxVolFiles"), /* 4 */
NT_("MaxVolBytes"), /* 5 */
NT_("Recycle"), /* 6 */
NT_("InChanger"), /* 7 */
NT_("Slot"), /* 8 */
NT_("Pool"), /* 9 */
NT_("FromPool"), /* 10 */
NT_("AllFromPool"), /* 11 !!! see below !!! */
NT_("Enabled"), /* 12 */
NT_("RecyclePool"), /* 13 */
NT_("ActionOnPurge"), /* 14 */
NULL };
#define AllFromPool 11 /* keep this updated with above */
for (i=0; kw[i]; i++) {
int j;
POOL_DBR pr;
if ((j=find_arg_with_value(ua, kw[i])) > 0) {
/* If all from pool don't select a media record */
if (i != AllFromPool && !select_media_dbr(ua, &mr)) {
return 0;
}
switch (i) {
case 0:
update_volstatus(ua, ua->argv[j], &mr);
break;
case 1:
update_volretention(ua, ua->argv[j], &mr);
break;
case 2:
update_voluseduration(ua, ua->argv[j], &mr);
break;
case 3:
update_volmaxjobs(ua, ua->argv[j], &mr);
break;
case 4:
update_volmaxfiles(ua, ua->argv[j], &mr);
break;
case 5:
update_volmaxbytes(ua, ua->argv[j], &mr);
break;
case 6:
update_volrecycle(ua, ua->argv[j], &mr);
break;
case 7:
update_volinchanger(ua, ua->argv[j], &mr);
break;
case 8:
update_volslot(ua, ua->argv[j], &mr);
break;
case 9:
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.PoolId;
if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
break;
}
update_vol_pool(ua, ua->argv[j], &mr, &pr);
break;
case 10:
update_vol_from_pool(ua, &mr);
return 1;
case 11:
update_all_vols_from_pool(ua, ua->argv[j]);
return 1;
case 12:
update_volenabled(ua, ua->argv[j], &mr);
break;
case 13:
update_vol_recyclepool(ua, ua->argv[j], &mr);
break;
case 14:
update_vol_actiononpurge(ua, ua->argv[j], &mr);
break;
}
done = true;
}
}
/* Allow user to simply update all volumes */
if (find_arg(ua, NT_("fromallpools")) > 0) {
update_all_vols(ua);
return 1;
}
for ( ; !done; ) {
start_prompt(ua, _("Parameters to modify:\n"));
add_prompt(ua, _("Volume Status")); /* 0 */
add_prompt(ua, _("Volume Retention Period")); /* 1 */
add_prompt(ua, _("Volume Use Duration")); /* 2 */
add_prompt(ua, _("Maximum Volume Jobs")); /* 3 */
add_prompt(ua, _("Maximum Volume Files")); /* 4 */
add_prompt(ua, _("Maximum Volume Bytes")); /* 5 */
add_prompt(ua, _("Recycle Flag")); /* 6 */
add_prompt(ua, _("Slot")); /* 7 */
add_prompt(ua, _("InChanger Flag")); /* 8 */
add_prompt(ua, _("Volume Files")); /* 9 */
add_prompt(ua, _("Pool")); /* 10 */
add_prompt(ua, _("Volume from Pool")); /* 11 */
add_prompt(ua, _("All Volumes from Pool")); /* 12 */
add_prompt(ua, _("All Volumes from all Pools")); /* 13 */
add_prompt(ua, _("Enabled")), /* 14 */
add_prompt(ua, _("RecyclePool")), /* 15 */
add_prompt(ua, _("Action On Purge")), /* 16 */
add_prompt(ua, _("Done")); /* 17 */
i = do_prompt(ua, "", _("Select parameter to modify"), NULL, 0);
/* For All Volumes, All Volumes from Pool, and Done, we don't need
* a Volume record */
if ( i != 12 && i != 13 && i != 17) {
if (!select_media_dbr(ua, &mr)) { /* Get Volume record */
return 0;
}
ua->info_msg(_("Updating Volume \"%s\"\n"), mr.VolumeName);
}
switch (i) {
case 0: /* Volume Status */
/* Modify Volume Status */
ua->info_msg(_("Current Volume status is: %s\n"), mr.VolStatus);
start_prompt(ua, _("Possible Values are:\n"));
add_prompt(ua, NT_("Append"));
add_prompt(ua, NT_("Archive"));
add_prompt(ua, NT_("Disabled"));
add_prompt(ua, NT_("Full"));
add_prompt(ua, NT_("Used"));
add_prompt(ua, NT_("Cleaning"));
if (strcmp(mr.VolStatus, NT_("Purged")) == 0) {
add_prompt(ua, NT_("Recycle"));
}
add_prompt(ua, NT_("Read-Only"));
if (do_prompt(ua, "", _("Choose new Volume Status"), ua->cmd, sizeof(mr.VolStatus)) < 0) {
return 1;
}
update_volstatus(ua, ua->cmd, &mr);
break;
case 1: /* Retention */
ua->info_msg(_("Current retention period is: %s\n"),
edit_utime(mr.VolRetention, ed1, sizeof(ed1)));
if (!get_cmd(ua, _("Enter Volume Retention period: "))) {
return 0;
}
update_volretention(ua, ua->cmd, &mr);
break;
case 2: /* Use Duration */
ua->info_msg(_("Current use duration is: %s\n"),
edit_utime(mr.VolUseDuration, ed1, sizeof(ed1)));
if (!get_cmd(ua, _("Enter Volume Use Duration: "))) {
return 0;
}
update_voluseduration(ua, ua->cmd, &mr);
break;
case 3: /* Max Jobs */
ua->info_msg(_("Current max jobs is: %u\n"), mr.MaxVolJobs);
if (!get_pint(ua, _("Enter new Maximum Jobs: "))) {
return 0;
}
update_volmaxjobs(ua, ua->cmd, &mr);
break;
case 4: /* Max Files */
ua->info_msg(_("Current max files is: %u\n"), mr.MaxVolFiles);
if (!get_pint(ua, _("Enter new Maximum Files: "))) {
return 0;
}
update_volmaxfiles(ua, ua->cmd, &mr);
break;
case 5: /* Max Bytes */
ua->info_msg(_("Current value is: %s\n"), edit_uint64(mr.MaxVolBytes, ed1));
if (!get_cmd(ua, _("Enter new Maximum Bytes: "))) {
return 0;
}
update_volmaxbytes(ua, ua->cmd, &mr);
break;
case 6: /* Recycle */
ua->info_msg(_("Current recycle flag is: %s\n"),
mr.Recycle==1?_("yes"):_("no"));
if (!get_yesno(ua, _("Enter new Recycle status: "))) {
return 0;
}
update_volrecycle(ua, ua->cmd, &mr);
break;
case 7: /* Slot */
ua->info_msg(_("Current Slot is: %d\n"), mr.Slot);
if (!get_pint(ua, _("Enter new Slot: "))) {
return 0;
}
update_volslot(ua, ua->cmd, &mr);
break;
case 8: /* InChanger */
ua->info_msg(_("Current InChanger flag is: %d\n"), mr.InChanger);
bsnprintf(buf, sizeof(buf), _("Set InChanger flag for Volume \"%s\": yes/no: "),
mr.VolumeName);
if (!get_yesno(ua, buf)) {
return 0;
}
mr.InChanger = ua->pint32_val;
/*
* Make sure to use db_update... rather than doing this directly,
* so that any Slot is handled correctly.
*/
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg(_("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
} else {
ua->info_msg(_("New InChanger flag is: %d\n"), mr.InChanger);
}
break;
case 9: /* Volume Files */
int32_t VolFiles;
ua->warning_msg(_("Warning changing Volume Files can result\n"
"in loss of data on your Volume\n\n"));
ua->info_msg(_("Current Volume Files is: %u\n"), mr.VolFiles);
if (!get_pint(ua, _("Enter new number of Files for Volume: "))) {
return 0;
}
VolFiles = ua->pint32_val;
if (VolFiles != (int)(mr.VolFiles + 1)) {
ua->warning_msg(_("Normally, you should only increase Volume Files by one!\n"));
if (!get_yesno(ua, _("Increase Volume Files? (yes/no): ")) || ua->pint32_val == 0) {
break;
}
}
query = get_pool_memory(PM_MESSAGE);
Mmsg(query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%s",
VolFiles, edit_int64(mr.MediaId, ed1));
if (!db_sql_query(ua->db, query, NULL, NULL)) {
ua->error_msg("%s", db_strerror(ua->db));
} else {
ua->info_msg(_("New Volume Files is: %u\n"), VolFiles);
}
free_pool_memory(query);
break;
case 10: /* Volume's Pool */
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.PoolId;
if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
return 0;
}
ua->info_msg(_("Current Pool is: %s\n"), pr.Name);
if (!get_cmd(ua, _("Enter new Pool name: "))) {
return 0;
}
update_vol_pool(ua, ua->cmd, &mr, &pr);
return 1;
case 11:
update_vol_from_pool(ua, &mr);
return 1;
case 12:
pool = select_pool_resource(ua);
if (pool) {
update_all_vols_from_pool(ua, pool->name());
}
return 1;
case 13:
update_all_vols(ua);
return 1;
case 14:
ua->info_msg(_("Current Enabled is: %d\n"), mr.Enabled);
if (!get_cmd(ua, _("Enter new Enabled: "))) {
return 0;
}
if (strcasecmp(ua->cmd, "yes") == 0 || strcasecmp(ua->cmd, "true") == 0) {
mr.Enabled = 1;
} else if (strcasecmp(ua->cmd, "no") == 0 || strcasecmp(ua->cmd, "false") == 0) {
mr.Enabled = 0;
} else if (strcasecmp(ua->cmd, "archived") == 0) {
mr.Enabled = 2;
} else {
mr.Enabled = atoi(ua->cmd);
}
update_volenabled(ua, ua->cmd, &mr);
break;
case 15:
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.RecyclePoolId;
if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
ua->info_msg(_("Current RecyclePool is: %s\n"), pr.Name);
} else {
ua->info_msg(_("No current RecyclePool\n"));
}
if (!select_pool_dbr(ua, &pr, NT_("recyclepool"))) {
return 0;
}
update_vol_recyclepool(ua, pr.Name, &mr);
return 1;
case 16:
pm_strcpy(ret, "");
ua->info_msg(_("Current ActionOnPurge is: %s\n"),
action_on_purge_to_string(mr.ActionOnPurge, ret));
if (!get_cmd(ua, _("Enter new ActionOnPurge (one of: Truncate, None): "))) {
return 0;
}
update_vol_actiononpurge(ua, ua->cmd, &mr);
break;
default: /* Done or error */
ua->info_msg(_("Selection terminated.\n"));
return 1;
}
}
return 1;
}
/*
* 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);
}
int main(int argc, char *const *argv)
{
int retval = 0;
int ch, kfd, length;
bool base64_transform = false,
clear_encryption = false,
drive_encryption_status = false,
generate_passphrase = false,
populate_cache = false,
set_encryption = false,
show_keydata = false,
volume_encryption_status = false,
wrapped_keys = false;
char *keyfile = NULL;
char *cache_file = NULL;
char *wrap_keyfile = NULL;
char keydata[64];
char wrapdata[64];
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
while ((ch = getopt(argc, argv, "bcd:eg:k:p:s:vw:?")) != -1) {
switch (ch) {
case 'b':
base64_transform = true;
break;
case 'c':
clear_encryption = true;
break;
case 'd':
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
break;
case 'e':
drive_encryption_status = true;
break;
case 'g':
generate_passphrase = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'k':
show_keydata = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'p':
populate_cache = true;
cache_file = bstrdup(optarg);
break;
case 's':
set_encryption = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'v':
volume_encryption_status = true;
break;
case 'w':
wrapped_keys = true;
wrap_keyfile = bstrdup(optarg);
break;
case '?':
default:
usage();
goto bail_out;
}
}
argc -= optind;
argv += optind;
if (!generate_passphrase && !show_keydata && !populate_cache && argc < 1) {
fprintf(stderr, _("Missing device_name argument for this option\n"));
usage();
retval = 1;
goto bail_out;
}
if (generate_passphrase && show_keydata) {
fprintf(stderr, _("Either use -g or -k not both\n"));
retval = 1;
goto bail_out;
}
if (clear_encryption && set_encryption) {
fprintf(stderr, _("Either use -c or -s not both\n"));
retval = 1;
goto bail_out;
}
if ((clear_encryption ||
set_encryption) &&
(drive_encryption_status ||
volume_encryption_status)) {
fprintf(stderr, _("Either set or clear the crypto key or ask for status not both\n"));
retval = 1;
goto bail_out;
}
if ((clear_encryption ||
set_encryption ||
drive_encryption_status ||
volume_encryption_status) &&
(generate_passphrase ||
show_keydata ||
populate_cache)) {
fprintf(stderr, _("Don't mix operations which are incompatible "
"e.g. generate/show vs set/clear etc.\n"));
retval = 1;
goto bail_out;
}
OSDependentInit();
init_msg(NULL, NULL);
if (populate_cache) {
char *VolumeName, *EncrKey;
char new_cache_entry[256];
/*
* Load any keys currently in the cache.
*/
read_crypto_cache(cache_file);
/*
* Read new entries from stdin and parse them to update
* the cache.
*/
fprintf(stdout, _("Enter cache entrie(s) (close with ^D): "));
fflush(stdout);
while (read(1, new_cache_entry, sizeof(new_cache_entry)) > 0) {
strip_trailing_junk(new_cache_entry);
/*
* Try to parse the entry.
*/
VolumeName = new_cache_entry;
EncrKey = strchr(new_cache_entry, '\t');
if (!EncrKey) {
break;
}
*EncrKey++ = '\0';
update_crypto_cache(VolumeName, EncrKey);
}
/*
* Write out the new cache entries.
*/
write_crypto_cache(cache_file);
goto bail_out;
}
memset(keydata, 0, sizeof(keydata));
memset(wrapdata, 0, sizeof(wrapdata));
if (wrapped_keys) {
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(wrap_keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Key Encryption Key: "));
fflush(stdout);
} else {
kfd = open(wrap_keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), wrap_keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, wrapdata, sizeof(wrapdata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(wrapdata);
Dmsg1(10, "Wrapped keydata = %s\n", wrapdata);
}
/*
* Generate a new passphrase allow it to be wrapped using the given wrapkey
* and base64 if specified or when wrapped.
*/
if (generate_passphrase) {
int cnt;
char *passphrase;
passphrase = generate_crypto_passphrase(DEFAULT_PASSPHRASE_LENGTH);
if (!passphrase) {
retval = 1;
goto bail_out;
}
Dmsg1(10, "Generated passphrase = %s\n", passphrase);
/*
* See if we need to wrap the passphrase.
*/
if (wrapped_keys) {
char *wrapped_passphrase;
length = DEFAULT_PASSPHRASE_LENGTH + 8;
wrapped_passphrase = (char *)malloc(length);
memset(wrapped_passphrase, 0, length);
aes_wrap((unsigned char *)wrapdata,
DEFAULT_PASSPHRASE_LENGTH / 8,
(unsigned char *)passphrase,
(unsigned char *)wrapped_passphrase);
free(passphrase);
passphrase = wrapped_passphrase;
} else {
length = DEFAULT_PASSPHRASE_LENGTH;
}
/*
* See where to write the key.
* - == stdout
*/
if (bstrcmp(keyfile, "-")) {
kfd = 1;
} else {
kfd = open(keyfile, O_WRONLY | O_CREAT, 0644);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
free(passphrase);
retval = 1;
goto bail_out;
}
}
if (base64_transform || wrapped_keys) {
cnt = bin_to_base64(keydata, sizeof(keydata), passphrase, length, true);
if (write(kfd, keydata, cnt) != cnt) {
fprintf(stderr, _("Failed to write %d bytes to keyfile %s\n"), cnt, keyfile);
}
} else {
cnt = DEFAULT_PASSPHRASE_LENGTH;
if (write(kfd, passphrase, cnt) != cnt) {
fprintf(stderr, _("Failed to write %d bytes to keyfile %s\n"), cnt, keyfile);
}
}
Dmsg1(10, "Keydata = %s\n", keydata);
if (kfd > 1) {
close(kfd);
} else {
write(kfd, "\n", 1);
}
free(passphrase);
goto bail_out;
}
if (show_keydata) {
char *passphrase;
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Encryption Key: "));
fflush(stdout);
} else {
kfd = open(keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, keydata, sizeof(keydata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(keydata);
Dmsg1(10, "Keydata = %s\n", keydata);
/*
* See if we need to unwrap the passphrase.
*/
if (wrapped_keys) {
char *wrapped_passphrase;
/*
* A wrapped key is base64 encoded after it was wrapped so first
* convert it from base64 to bin. As we first go from base64 to bin
* and the base64_to_bin has a check if the decoded string will fit
* we need to alocate some more bytes for the decoded buffer to be
* sure it will fit.
*/
length = DEFAULT_PASSPHRASE_LENGTH + 12;
wrapped_passphrase = (char *)malloc(length);
memset(wrapped_passphrase, 0, length);
if (base64_to_bin(wrapped_passphrase, length,
keydata, strlen(keydata)) == 0) {
fprintf(stderr,
_("Failed to base64 decode the keydata read from %s, aborting...\n"),
keyfile);
free(wrapped_passphrase);
goto bail_out;
}
length = DEFAULT_PASSPHRASE_LENGTH;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
if (aes_unwrap((unsigned char *)wrapdata,
length / 8,
(unsigned char *)wrapped_passphrase,
(unsigned char *)passphrase) == -1) {
fprintf(stderr,
_("Failed to aes unwrap the keydata read from %s using the wrap data from %s, aborting...\n"),
keyfile, wrap_keyfile);
free(wrapped_passphrase);
goto bail_out;
}
free(wrapped_passphrase);
} else {
if (base64_transform) {
/*
* As we first go from base64 to bin and the base64_to_bin has a check
* if the decoded string will fit we need to alocate some more bytes
* for the decoded buffer to be sure it will fit.
*/
length = DEFAULT_PASSPHRASE_LENGTH + 4;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
base64_to_bin(passphrase, length, keydata, strlen(keydata));
} else {
length = DEFAULT_PASSPHRASE_LENGTH;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
bstrncpy(passphrase, keydata, length);
}
}
Dmsg1(10, "Unwrapped passphrase = %s\n", passphrase);
fprintf(stdout, "%s\n", passphrase);
free(passphrase);
goto bail_out;
}
/*
* Clear the loaded encryption key of the given drive.
*/
if (clear_encryption) {
if (clear_scsi_encryption_key(-1, argv[0])) {
goto bail_out;
} else {
retval = 1;
goto bail_out;
}
}
/*
* Get the drive encryption status of the given drive.
*/
if (drive_encryption_status) {
POOLMEM *encryption_status = get_pool_memory(PM_MESSAGE);
if (get_scsi_drive_encryption_status(-1, argv[0], encryption_status, 0)) {
fprintf(stdout, "%s", encryption_status);
free_pool_memory(encryption_status);
} else {
retval = 1;
free_pool_memory(encryption_status);
goto bail_out;
}
}
/*
* Load a new encryption key onto the given drive.
*/
if (set_encryption) {
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Encryption Key (close with ^D): "));
fflush(stdout);
} else {
kfd = open(keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, keydata, sizeof(keydata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(keydata);
if (set_scsi_encryption_key(-1, argv[0], keydata)) {
goto bail_out;
} else {
retval = 1;
goto bail_out;
}
}
/*
* Get the volume encryption status of volume currently loaded in the given drive.
*/
if (volume_encryption_status) {
POOLMEM *encryption_status = get_pool_memory(PM_MESSAGE);
if (get_scsi_volume_encryption_status(-1, argv[0], encryption_status, 0)) {
fprintf(stdout, "%s", encryption_status);
free_pool_memory(encryption_status);
} else {
retval = 1;
free_pool_memory(encryption_status);
goto bail_out;
}
}
bail_out:
if (cache_file) {
free(cache_file);
}
if (keyfile) {
free(keyfile);
}
if (wrap_keyfile) {
free(wrap_keyfile);
}
exit(retval);
}
/*
* Remove old .spool files written by me from the working directory.
*/
static void cleanup_old_files()
{
DIR* dp;
struct dirent *entry, *result;
int rc, name_max;
int my_name_len = strlen(my_name);
int len = strlen(me->working_directory);
POOLMEM *cleanup = get_pool_memory(PM_MESSAGE);
POOLMEM *basename = get_pool_memory(PM_MESSAGE);
regex_t preg1;
char prbuf[500];
const int nmatch = 30;
regmatch_t pmatch[nmatch];
berrno be;
/* Look for .spool files but don't allow spaces */
const char *pat1 = "^[^ ]+\\.spool$";
/* Setup working directory prefix */
pm_strcpy(basename, me->working_directory);
if (len > 0 && !IsPathSeparator(me->working_directory[len-1])) {
pm_strcat(basename, "/");
}
/* Compile regex expressions */
rc = regcomp(&preg1, pat1, REG_EXTENDED);
if (rc != 0) {
regerror(rc, &preg1, prbuf, sizeof(prbuf));
Pmsg2(000, _("Could not compile regex pattern \"%s\" ERR=%s\n"),
pat1, prbuf);
goto get_out2;
}
name_max = pathconf(".", _PC_NAME_MAX);
if (name_max < 1024) {
name_max = 1024;
}
if (!(dp = opendir(me->working_directory))) {
berrno be;
Pmsg2(000, "Failed to open working dir %s for cleanup: ERR=%s\n",
me->working_directory, be.bstrerror());
goto get_out1;
}
entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
while (1) {
if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
break;
}
/* Exclude any name with ., .., not my_name or containing a space */
if (strcmp(result->d_name, ".") == 0 || strcmp(result->d_name, "..") == 0 ||
strncmp(result->d_name, my_name, my_name_len) != 0) {
Dmsg1(500, "Skipped: %s\n", result->d_name);
continue;
}
/* Unlink files that match regex */
if (regexec(&preg1, result->d_name, nmatch, pmatch, 0) == 0) {
pm_strcpy(cleanup, basename);
pm_strcat(cleanup, result->d_name);
Dmsg1(500, "Unlink: %s\n", cleanup);
unlink(cleanup);
}
}
free(entry);
closedir(dp);
get_out1:
regfree(&preg1);
get_out2:
free_pool_memory(cleanup);
free_pool_memory(basename);
}
/*
* NB! This routine locks the device, but if committing will
* not unlock it. If not committing, it will be unlocked.
*/
static bool despool_data(DCR *dcr, bool commit)
{
DEVICE *rdev;
DCR *rdcr;
bool ok = true;
DEV_BLOCK *block;
JCR *jcr = dcr->jcr;
int status;
char ec1[50];
BSOCK *dir = jcr->dir_bsock;
Dmsg0(100, "Despooling data\n");
if (jcr->dcr->job_spool_size == 0) {
Jmsg(jcr, M_WARNING, 0, _("Despooling zero bytes. Your disk is probably FULL!\n"));
}
/*
* Commit means that the job is done, so we commit, otherwise, we
* are despooling because of user spool size max or some error
* (e.g. filesystem full).
*/
if (commit) {
Jmsg(jcr, M_INFO, 0, _("Committing spooled data to Volume \"%s\". Despooling %s bytes ...\n"),
jcr->dcr->VolumeName,
edit_uint64_with_commas(jcr->dcr->job_spool_size, ec1));
jcr->setJobStatus(JS_DataCommitting);
} else {
Jmsg(jcr, M_INFO, 0, _("Writing spooled data to Volume. Despooling %s bytes ...\n"),
edit_uint64_with_commas(jcr->dcr->job_spool_size, ec1));
jcr->setJobStatus(JS_DataDespooling);
}
jcr->sendJobStatus(JS_DataDespooling);
dcr->despool_wait = true;
dcr->spooling = false;
/*
* We work with device blocked, but not locked so that other threads
* e.g. reservations can lock the device structure.
*/
dcr->dblock(BST_DESPOOLING);
dcr->despool_wait = false;
dcr->despooling = true;
/*
* This is really quite kludgy and should be fixed some time.
* We create a dev structure to read from the spool file
* in rdev and rdcr.
*/
rdev = (DEVICE *)malloc(sizeof(DEVICE));
memset(rdev, 0, sizeof(DEVICE));
rdev->dev_name = get_memory(strlen(spool_name)+1);
bstrncpy(rdev->dev_name, spool_name, sizeof_pool_memory(rdev->dev_name));
rdev->errmsg = get_pool_memory(PM_EMSG);
*rdev->errmsg = 0;
rdev->max_block_size = dcr->dev->max_block_size;
rdev->min_block_size = dcr->dev->min_block_size;
rdev->device = dcr->dev->device;
rdcr = dcr->get_new_spooling_dcr();
setup_new_dcr_device(jcr, rdcr, rdev, NULL);
rdcr->spool_fd = dcr->spool_fd;
block = dcr->block; /* save block */
dcr->block = rdcr->block; /* make read and write block the same */
Dmsg1(800, "read/write block size = %d\n", block->buf_len);
lseek(rdcr->spool_fd, 0, SEEK_SET); /* rewind */
#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
posix_fadvise(rdcr->spool_fd, 0, 0, POSIX_FADV_WILLNEED);
#endif
/* Add run time, to get current wait time */
int32_t despool_start = time(NULL) - jcr->run_time;
set_new_file_parameters(dcr);
while (ok) {
if (job_canceled(jcr)) {
ok = false;
break;
}
status = read_block_from_spool_file(rdcr);
if (status == RB_EOT) {
break;
} else if (status == RB_ERROR) {
ok = false;
break;
}
ok = dcr->write_block_to_device();
if (!ok) {
Jmsg2(jcr, M_FATAL, 0, _("Fatal append error on device %s: ERR=%s\n"),
dcr->dev->print_name(), dcr->dev->bstrerror());
Dmsg2(000, "Fatal append error on device %s: ERR=%s\n",
dcr->dev->print_name(), dcr->dev->bstrerror());
/* Force in case Incomplete set */
jcr->forceJobStatus(JS_FatalError);
}
Dmsg3(800, "Write block ok=%d FI=%d LI=%d\n", ok, block->FirstIndex, block->LastIndex);
}
/*
* If this Job is incomplete, we need to backup the FileIndex
* to the last correctly saved file so that the JobMedia
* LastIndex is correct.
*/
if (jcr->is_JobStatus(JS_Incomplete)) {
dcr->VolLastIndex = dir->get_FileIndex();
Dmsg1(100, "======= Set FI=%ld\n", dir->get_FileIndex());
}
if (!dcr->dir_create_jobmedia_record(false)) {
Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
dcr->getVolCatName(), jcr->Job);
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
}
/* Set new file/block parameters for current dcr */
set_new_file_parameters(dcr);
/*
* Subtracting run_time give us elapsed time - wait_time since
* we started despooling. Note, don't use time_t as it is 32 or 64
* bits depending on the OS and doesn't edit with %d
*/
int32_t despool_elapsed = time(NULL) - despool_start - jcr->run_time;
if (despool_elapsed <= 0) {
despool_elapsed = 1;
}
Jmsg(jcr, M_INFO, 0, _("Despooling elapsed time = %02d:%02d:%02d, Transfer rate = %s Bytes/second\n"),
despool_elapsed / 3600, despool_elapsed % 3600 / 60, despool_elapsed % 60,
edit_uint64_with_suffix(jcr->dcr->job_spool_size / despool_elapsed, ec1));
dcr->block = block; /* reset block */
lseek(rdcr->spool_fd, 0, SEEK_SET); /* rewind */
if (ftruncate(rdcr->spool_fd, 0) != 0) {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Ftruncate spool file failed: ERR=%s\n"), be.bstrerror());
/* Note, try continuing despite ftruncate problem */
}
P(mutex);
if (spool_stats.data_size < dcr->job_spool_size) {
spool_stats.data_size = 0;
} else {
spool_stats.data_size -= dcr->job_spool_size;
}
V(mutex);
P(dcr->dev->spool_mutex);
dcr->dev->spool_size -= dcr->job_spool_size;
dcr->job_spool_size = 0; /* zap size in input dcr */
V(dcr->dev->spool_mutex);
free_memory(rdev->dev_name);
free_pool_memory(rdev->errmsg);
/* Be careful to NULL the jcr and free rdev after free_dcr() */
rdcr->jcr = NULL;
rdcr->set_dev(NULL);
free_dcr(rdcr);
free(rdev);
dcr->spooling = true; /* turn on spooling again */
dcr->despooling = false;
/*
* Note, if committing we leave the device blocked. It will be removed in
* release_device();
*/
if (!commit) {
dcr->dev->dunblock();
}
jcr->sendJobStatus(JS_Running);
return ok;
}
/* Update the free space on the device */
bool DEVICE::update_freespace()
{
POOL_MEM ocmd(PM_FNAME);
POOLMEM* results;
char* icmd;
int timeout;
uint64_t free;
char ed1[50];
bool ok = false;
int status;
if (!is_dvd() || is_freespace_ok()) {
return true;
}
/* The device must be mounted in order to dvd-freespace to work */
mount(1);
Dsm_check(400);
icmd = device->free_space_command;
if (!icmd) {
free_space = 0;
free_space_errno = 0;
clear_freespace_ok(); /* No valid freespace */
clear_media();
Dmsg2(29, "ERROR: update_free_space_dev: free_space=%s, free_space_errno=%d (!icmd)\n",
edit_uint64(free_space, ed1), free_space_errno);
Mmsg(errmsg, _("No FreeSpace command defined.\n"));
return false;
}
edit_mount_codes(ocmd, icmd);
Dmsg1(29, "update_freespace: cmd=%s\n", ocmd.c_str());
results = get_pool_memory(PM_MESSAGE);
/* Try at most 3 times to get the free space on the device. This should perhaps be configurable. */
timeout = 3;
while (1) {
berrno be;
Dmsg1(20, "Run freespace prog=%s\n", ocmd.c_str());
status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results);
Dmsg2(500, "Freespace status=%d result=%s\n", status, results);
if (status == 0) {
free = str_to_int64(results);
Dmsg1(400, "Free space program run: Freespace=%s\n", results);
if (free >= 0) {
free_space = free;
free_space_errno = 0;
set_freespace_ok(); /* have valid freespace */
set_media();
Mmsg(errmsg, "");
ok = true;
break;
}
}
free_space = 0;
free_space_errno = EPIPE;
clear_freespace_ok(); /* no valid freespace */
Mmsg2(errmsg, _("Cannot run free space command. Results=%s ERR=%s\n"),
results, be.bstrerror(status));
if (--timeout > 0) {
Dmsg4(40, "Cannot get free space on device %s. free_space=%s, "
"free_space_errno=%d ERR=%s\n", print_name(),
edit_uint64(free_space, ed1), free_space_errno,
errmsg);
bmicrosleep(1, 0);
continue;
}
dev_errno = free_space_errno;
Dmsg4(40, "Cannot get free space on device %s. free_space=%s, "
"free_space_errno=%d ERR=%s\n",
print_name(), edit_uint64(free_space, ed1),
free_space_errno, errmsg);
break;
}
free_pool_memory(results);
Dmsg4(29, "leave update_freespace: free_space=%s freespace_ok=%d free_space_errno=%d have_media=%d\n",
edit_uint64(free_space, ed1), !!is_freespace_ok(), free_space_errno, !!have_media());
Dsm_check(400);
return ok;
}
/*
* See who is connecting and lookup the authentication information.
* First make him prove his identity and then prove our identity to the Remote daemon.
*/
static inline bool two_way_authenticate(int rcode, BSOCK *bs, JCR* jcr)
{
POOLMEM *dirname;
DIRRES *director = NULL;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true; /* require md5 compatible DIR */
bool auth_success = false;
alist *verify_list = NULL;
if (rcode != R_DIRECTOR) {
Dmsg1(dbglvl, "I only authenticate Directors, not %d\n", rcode);
Jmsg1(jcr, M_FATAL, 0, _("I only authenticate Directors, not %d\n"), rcode);
return 0;
}
/*
* Sanity check.
*/
if (bs->msglen < 25 || bs->msglen > 500) {
Dmsg2(dbglvl, "Bad Hello command from Director at %s. Len=%d.\n",
bs->who(), bs->msglen);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s. Len=%d.\n"),
bs->who(), bs->msglen);
return 0;
}
dirname = get_pool_memory(PM_MESSAGE);
dirname = check_pool_memory_size(dirname, bs->msglen);
if (sscanf(bs->msg, "Hello Director %127s calling", dirname) != 1) {
bs->msg[100] = 0;
Dmsg2(dbglvl, "Bad Hello command from Director at %s: %s\n",
bs->who(), bs->msg);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s: %s\n"),
bs->who(), bs->msg);
return 0;
}
director = NULL;
unbash_spaces(dirname);
foreach_res(director, rcode) {
if (bstrcmp(director->hdr.name, dirname)) {
break;
}
}
if (!director) {
Dmsg2(dbglvl, "Connection from unknown Director %s at %s rejected.\n",
dirname, bs->who());
Jmsg(jcr, M_FATAL, 0, _("Connection from unknown Director %s at %s rejected.\n"
"Please see %s for help.\n"),
dirname, bs->who(), MANUAL_AUTH_URL);
free_pool_memory(dirname);
return 0;
}
/*
* TLS Requirement
*/
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (director->tls_verify_peer) {
verify_list = director->tls_allowed_cns;
}
ASSERT(director->password.encoding == p_encoding_md5);
/*
* Timeout Hello after 10 mins
*/
btimer_t *tid = start_bsock_timer(bs, AUTH_TIMEOUT);
auth_success = cram_md5_challenge(bs, director->password.value, tls_local_need, compatible);
if (auth_success) {
auth_success = cram_md5_respond(bs, director->password.value, &tls_remote_need, &compatible);
if (!auth_success) {
Dmsg1(dbglvl, "cram_get_auth failed with %s\n", bs->who());
}
} else {
Dmsg1(dbglvl, "cram_auth failed with %s\n", bs->who());
}
if (!auth_success) {
Jmsg(jcr, M_FATAL, 0, _("Incorrect password given by Director.\n"
"Please see %s for help.\n"), MANUAL_AUTH_URL);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that the remote host is willing to meet our TLS requirements
*/
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not"
" advertize required TLS support.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that we are willing to meet the remote host's requirements
*/
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/*
* Engage TLS! Full Speed Ahead!
*/
if (!bnet_tls_server(director->tls_ctx, bs, verify_list)) {
Jmsg(jcr, M_FATAL, 0, _("TLS negotiation failed with DIR at \"%s:%d\"\n"),
bs->host(), bs->port());
auth_success = false;
goto auth_fatal;
}
if (director->tls_authenticate) { /* authenticate with tls only? */
bs->free_tls(); /* yes, shut it down */
}
}
auth_fatal:
stop_bsock_timer(tid);
free_pool_memory(dirname);
jcr->director = director;
return auth_success;
}
/*
* Start the backup of a specific file
*/
static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp)
{
struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
if (p_ctx->nb_obj == 0) {
sp->fname = (char *)"takeme.h";
Dmsg(ctx, dbglvl, "AcceptFile=%s = %d\n",
sp->fname, bfuncs->AcceptFile(ctx, sp));
sp->fname = (char *)"/path/to/excludeme.o";
Dmsg(ctx, dbglvl, "AcceptFile=%s = %d\n",
sp->fname, bfuncs->AcceptFile(ctx, sp));
sp->fname = (char *)"/path/to/excludeme.c";
Dmsg(ctx, dbglvl, "AcceptFile=%s = %d\n",
sp->fname, bfuncs->AcceptFile(ctx, sp));
}
if (p_ctx->nb_obj == 0) {
sp->object_name = (char *)"james.xml";
sp->object = (char *)"This is test data for the restore object. "
"garbage=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"\0secret";
sp->object_len = strlen(sp->object)+1+6+1; /* str + 0 + secret + 0 */
sp->type = FT_RESTORE_FIRST;
static int _nb=0;
POOLMEM *q = get_pool_memory(PM_FNAME);
char *working;
FILE *fp;
bfuncs->getBareosValue(ctx, bVarWorkingDir, &working);
Mmsg(q, "%s/torestore.%d", working, _nb++);
if ((fp = fopen(q, "w")) != NULL) {
fwrite(sp->object, sp->object_len, 1, fp);
fclose(fp);
}
free_pool_memory(q);
} else if (p_ctx->nb_obj == 1) {
ConfigFile ini;
p_ctx->buf = get_pool_memory(PM_BSOCK);
ini.register_items(test_items, sizeof(struct ini_items));
sp->object_name = (char*)INI_RESTORE_OBJECT_NAME;
sp->object_len = ini.serialize(p_ctx->buf);
sp->object = p_ctx->buf;
sp->type = FT_PLUGIN_CONFIG;
Dmsg(ctx, dbglvl, "RestoreOptions=<%s>\n", p_ctx->buf);
}
time_t now = time(NULL);
sp->index = ++p_ctx->nb_obj;
sp->statp.st_mode = 0700 | S_IFREG;
sp->statp.st_ctime = now;
sp->statp.st_mtime = now;
sp->statp.st_atime = now;
sp->statp.st_size = sp->object_len;
sp->statp.st_blksize = 4096;
sp->statp.st_blocks = 1;
Dmsg(ctx, dbglvl, "Creating RestoreObject len=%d oname=%s data=%.127s\n",
sp->object_len, sp->object_name, sp->object);
Dmsg(ctx, dbglvl,"test-plugin-fd: startBackupFile\n");
return bRC_OK;
}
/*
* Handle an event that was generated in Bareos
*/
static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value)
{
struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
restore_object_pkt *rop;
if (!p_ctx) {
return bRC_Error;
}
// char *name;
switch (event->eventType) {
case bEventJobStart:
Dmsg(ctx, dbglvl, "test-plugin-fd: JobStart=%s\n", (char *)value);
break;
case bEventEndFileSet:
/*
* End of Dir FileSet commands, now we can add excludes
*/
bfuncs->NewOptions(ctx);
bfuncs->AddWild(ctx, "*.c", ' ');
bfuncs->AddWild(ctx, "*.cpp", ' ');
bfuncs->AddOptions(ctx, "ei"); /* exclude, ignore case */
bfuncs->AddExclude(ctx, "/home/user/bareos/regress/README");
break;
case bEventRestoreObject: {
FILE *fp;
POOLMEM *q;
char *working;
static int _nb = 0;
printf("Plugin RestoreObject\n");
if (!value) {
Dmsg(ctx, dbglvl, "test-plugin-fd: End restore objects\n");
break;
}
rop = (restore_object_pkt *)value;
Dmsg(ctx, dbglvl, "Get RestoreObject len=%d JobId=%d oname=%s type=%d data=%.127s\n",
rop->object_len, rop->JobId, rop->object_name, rop->object_type, rop->object);
q = get_pool_memory(PM_FNAME);
bfuncs->getBareosValue(ctx, bVarWorkingDir, &working);
Mmsg(q, "%s/restore.%d", working, _nb++);
if ((fp = fopen(q, "w")) != NULL) {
fwrite(rop->object, rop->object_len, 1, fp);
fclose(fp);
}
free_pool_memory(q);
if (!strcmp(rop->object_name, INI_RESTORE_OBJECT_NAME)) {
ConfigFile ini;
if (!ini.dump_string(rop->object, rop->object_len)) {
break;
}
ini.register_items(test_items, sizeof(struct ini_items));
if (ini.parse(ini.out_fname)) {
Jmsg(ctx, M_INFO, "string1 = %s\n", ini.items[0].val.strval);
} else {
Jmsg(ctx, M_ERROR, "Can't parse config\n");
}
}
break;
}
case bEventEstimateCommand:
/* Fall-through wanted */
case bEventBackupCommand: {
/*
* Plugin command e.g. plugin = <plugin-name>:<name-space>:read command:write command
*/
char *p;
Dmsg(ctx, dbglvl, "test-plugin-fd: pluginEvent cmd=%s\n", (char *)value);
p_ctx->cmd = bstrdup((char *)value);
p = strchr(p_ctx->cmd, ':');
if (!p) {
Jmsg(ctx, M_FATAL, "Plugin terminator not found: %s\n", (char *)value);
Dmsg(ctx, dbglvl, "Plugin terminator not found: %s\n", (char *)value);
return bRC_Error;
}
*p++ = 0; /* terminate plugin */
p_ctx->fname = p;
p = strchr(p, ':');
if (!p) {
Jmsg(ctx, M_FATAL, "File terminator not found: %s\n", (char *)value);
Dmsg(ctx, dbglvl, "File terminator not found: %s\n", (char *)value);
return bRC_Error;
}
*p++ = 0; /* terminate file */
p_ctx->reader = p;
p = strchr(p, ':');
if (!p) {
Jmsg(ctx, M_FATAL, "Reader terminator not found: %s\n", (char *)value);
Dmsg(ctx, dbglvl, "Reader terminator not found: %s\n", (char *)value);
return bRC_Error;
}
*p++ = 0; /* terminate reader string */
p_ctx->writer = p;
Dmsg(ctx, dbglvl, "test-plugin-fd: plugin=%s fname=%s reader=%s writer=%s\n",
p_ctx->cmd, p_ctx->fname, p_ctx->reader, p_ctx->writer);
break;
}
case bEventComponentInfo:
Dmsg(ctx, dbglvl, "plugin: Component=%s\n", NPRT((char *)value));
break;
default:
Dmsg(ctx, dbglvl, "test-plugin-fd: unknown event=%d\n", event->eventType);
break;
}
return bRC_OK;
}
/*
* Create a Job Control Record and link it into JCR chain
* Returns newly allocated JCR
*
* Note, since each daemon has a different JCR, he passes
* us the size.
*/
JCR *new_jcr(int size, JCR_free_HANDLER *daemon_free_jcr)
{
JCR *jcr;
MQUEUE_ITEM *item = NULL;
struct sigaction sigtimer;
int status;
Dmsg0(dbglvl, "Enter new_jcr\n");
setup_tsd_key();
jcr = (JCR *)malloc(size);
memset(jcr, 0, size);
jcr->msg_queue = New(dlist(item, &item->link));
if ((status = pthread_mutex_init(&jcr->msg_queue_mutex, NULL)) != 0) {
berrno be;
Jmsg(NULL, M_ABORT, 0, _("Could not init msg_queue mutex. ERR=%s\n"),
be.bstrerror(status));
}
jcr->job_end_push.init(1, false);
jcr->sched_time = time(NULL);
jcr->initial_sched_time = jcr->sched_time;
jcr->daemon_free_jcr = daemon_free_jcr; /* plug daemon free routine */
jcr->init_mutex();
jcr->inc_use_count();
jcr->VolumeName = get_pool_memory(PM_FNAME);
jcr->VolumeName[0] = 0;
jcr->errmsg = get_pool_memory(PM_MESSAGE);
jcr->errmsg[0] = 0;
jcr->comment = get_pool_memory(PM_FNAME);
jcr->comment[0] = 0;
/*
* Setup some dummy values
*/
bstrncpy(jcr->Job, "*System*", sizeof(jcr->Job));
jcr->JobId = 0;
jcr->setJobType(JT_SYSTEM); /* internal job until defined */
jcr->setJobLevel(L_NONE);
jcr->setJobStatus(JS_Created); /* ready to run */
sigtimer.sa_flags = 0;
sigtimer.sa_handler = timeout_handler;
sigfillset(&sigtimer.sa_mask);
sigaction(TIMEOUT_SIGNAL, &sigtimer, NULL);
/*
* Locking jobs is a global lock that is needed
* so that the Director can stop new jobs from being
* added to the jcr chain while it processes a new
* conf file and does the job_end_push().
*/
lock_jobs();
lock_jcr_chain();
if (!jcrs) {
jcrs = New(dlist(jcr, &jcr->link));
}
jcrs->append(jcr);
unlock_jcr_chain();
unlock_jobs();
return jcr;
}
/*
* Verify attributes of the requested files on the Volume
*
*/
void do_verify_volume(JCR *jcr)
{
BSOCK *sd, *dir;
POOLMEM *fname; /* original file name */
POOLMEM *lname; /* link name */
int32_t stream;
uint32_t size;
uint32_t VolSessionId, VolSessionTime, file_index;
uint32_t record_file_index;
char digest[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
int type, stat;
sd = jcr->store_bsock;
if (!sd) {
Jmsg(jcr, M_FATAL, 0, _("Storage command not issued before Verify.\n"));
jcr->setJobStatus(JS_FatalError);
return;
}
dir = jcr->dir_bsock;
jcr->setJobStatus(JS_Running);
LockRes();
CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
UnlockRes();
uint32_t buf_size;
if (client) {
buf_size = client->max_network_buffer_size;
} else {
buf_size = 0; /* use default */
}
if (!sd->set_buffer_size(buf_size, BNET_SETBUF_WRITE)) {
jcr->setJobStatus(JS_FatalError);
return;
}
jcr->buf_size = sd->msglen;
fname = get_pool_memory(PM_FNAME);
lname = get_pool_memory(PM_FNAME);
/*
* Get a record from the Storage daemon
*/
while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
/*
* First we expect a Stream Record Header
*/
if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
&stream, &size) != 5) {
Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
goto bail_out;
}
Dmsg3(30, "Got hdr: FilInx=%d Stream=%d size=%d.\n", file_index, stream, size);
/*
* Now we expect the Stream Data
*/
if (bget_msg(sd) < 0) {
Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
goto bail_out;
}
if (size != ((uint32_t)sd->msglen)) {
Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"), sd->msglen, size);
goto bail_out;
}
Dmsg2(30, "Got stream data %s, len=%d\n", stream_to_ascii(stream), sd->msglen);
/* File Attributes stream */
switch (stream) {
case STREAM_UNIX_ATTRIBUTES:
case STREAM_UNIX_ATTRIBUTES_EX:
char *ap, *lp, *fp;
Dmsg0(400, "Stream=Unix Attributes.\n");
if ((int)sizeof_pool_memory(fname) < sd->msglen) {
fname = realloc_pool_memory(fname, sd->msglen + 1);
}
if ((int)sizeof_pool_memory(lname) < sd->msglen) {
lname = realloc_pool_memory(lname, sd->msglen + 1);
}
*fname = 0;
*lname = 0;
/*
* An Attributes record consists of:
* File_index
* Type (FT_types)
* Filename
* Attributes
* Link name (if file linked i.e. FT_LNK)
* Extended Attributes (if Win32)
*/
if (sscanf(sd->msg, "%d %d", &record_file_index, &type) != 2) {
Jmsg(jcr, M_FATAL, 0, _("Error scanning record header: %s\n"), sd->msg);
Dmsg0(0, "\nError scanning header\n");
goto bail_out;
}
Dmsg2(30, "Got Attr: FilInx=%d type=%d\n", record_file_index, type);
ap = sd->msg;
while (*ap++ != ' ') /* skip record file index */
;
while (*ap++ != ' ') /* skip type */
;
/* Save filename and position to attributes */
fp = fname;
while (*ap != 0) {
*fp++ = *ap++; /* copy filename to fname */
}
*fp = *ap++; /* terminate filename & point to attribs */
Dmsg2(100, "File=%s Attr=%s\n", fname, ap);
/* Skip to Link name */
if (type == FT_LNK || type == FT_LNKSAVED) {
lp = ap;
while (*lp++ != 0) {
;
}
pm_strcat(lname, lp); /* "save" link name */
} else {
*lname = 0;
}
jcr->lock();
jcr->JobFiles++;
jcr->num_files_examined++;
pm_strcpy(jcr->last_fname, fname); /* last file examined */
jcr->unlock();
/*
* Send file attributes to Director
* File_index
* Stream
* Verify Options
* Filename (full path)
* Encoded attributes
* Link name (if type==FT_LNK)
* For a directory, link is the same as fname, but with trailing
* slash. For a linked file, link is the link.
*/
/* Send file attributes to Director */
Dmsg2(200, "send ATTR inx=%d fname=%s\n", jcr->JobFiles, fname);
if (type == FT_LNK || type == FT_LNKSAVED) {
stat = dir->fsend("%d %d %s %s%c%s%c%s%c", jcr->JobFiles,
STREAM_UNIX_ATTRIBUTES, "pinsug5", fname,
0, ap, 0, lname, 0);
/* for a deleted record, we set fileindex=0 */
} else if (type == FT_DELETED) {
stat = dir->fsend("%d %d %s %s%c%s%c%c", 0,
STREAM_UNIX_ATTRIBUTES, "pinsug5", fname,
0, ap, 0, 0);
} else {
stat = dir->fsend("%d %d %s %s%c%s%c%c", jcr->JobFiles,
STREAM_UNIX_ATTRIBUTES, "pinsug5", fname,
0, ap, 0, 0);
}
Dmsg2(200, "bfiled>bdird: attribs len=%d: msg=%s\n", dir->msglen, dir->msg);
if (!stat) {
Jmsg(jcr, M_FATAL, 0, _("Network error in send to Director: ERR=%s\n"), dir->bstrerror());
goto bail_out;
}
break;
case STREAM_MD5_DIGEST:
bin_to_base64(digest, sizeof(digest), (char *)sd->msg, CRYPTO_DIGEST_MD5_SIZE, true);
Dmsg2(400, "send inx=%d MD5=%s\n", jcr->JobFiles, digest);
dir->fsend("%d %d %s *MD5-%d*", jcr->JobFiles, STREAM_MD5_DIGEST, digest,
jcr->JobFiles);
Dmsg2(20, "bfiled>bdird: MD5 len=%d: msg=%s\n", dir->msglen, dir->msg);
break;
case STREAM_SHA1_DIGEST:
bin_to_base64(digest, sizeof(digest), (char *)sd->msg, CRYPTO_DIGEST_SHA1_SIZE, true);
Dmsg2(400, "send inx=%d SHA1=%s\n", jcr->JobFiles, digest);
dir->fsend("%d %d %s *SHA1-%d*", jcr->JobFiles, STREAM_SHA1_DIGEST,
digest, jcr->JobFiles);
Dmsg2(20, "bfiled>bdird: SHA1 len=%d: msg=%s\n", dir->msglen, dir->msg);
break;
case STREAM_SHA256_DIGEST:
bin_to_base64(digest, sizeof(digest), (char *)sd->msg, CRYPTO_DIGEST_SHA256_SIZE, true);
Dmsg2(400, "send inx=%d SHA256=%s\n", jcr->JobFiles, digest);
dir->fsend("%d %d %s *SHA256-%d*", jcr->JobFiles, STREAM_SHA256_DIGEST,
digest, jcr->JobFiles);
Dmsg2(20, "bfiled>bdird: SHA256 len=%d: msg=%s\n", dir->msglen, dir->msg);
break;
case STREAM_SHA512_DIGEST:
bin_to_base64(digest, sizeof(digest), (char *)sd->msg, CRYPTO_DIGEST_SHA512_SIZE, true);
Dmsg2(400, "send inx=%d SHA512=%s\n", jcr->JobFiles, digest);
dir->fsend("%d %d %s *SHA512-%d*", jcr->JobFiles, STREAM_SHA512_DIGEST,
digest, jcr->JobFiles);
Dmsg2(20, "bfiled>bdird: SHA512 len=%d: msg=%s\n", dir->msglen, dir->msg);
break;
/*
* Restore stream object is counted, but not restored here
*/
case STREAM_RESTORE_OBJECT:
jcr->lock();
jcr->JobFiles++;
jcr->num_files_examined++;
jcr->unlock();
break;
/* Ignore everything else */
default:
break;
} /* end switch */
} /* end while bnet_get */
jcr->setJobStatus(JS_Terminated);
goto ok_out;
bail_out:
jcr->setJobStatus(JS_ErrorTerminated);
ok_out:
if (jcr->compress_buf) {
free(jcr->compress_buf);
jcr->compress_buf = NULL;
}
free_pool_memory(fname);
free_pool_memory(lname);
Dmsg2(050, "End Verify-Vol. Files=%d Bytes=%" lld "\n", jcr->JobFiles,
jcr->JobBytes);
}
/**
* Find all the requested files and send them
* to the Storage daemon.
*
* Note, we normally carry on a one-way
* conversation from this point on with the SD, simply blasting
* data to him. To properly know what is going on, we
* also run a "heartbeat" monitor which reads the socket and
* reacts accordingly (at the moment it has nothing to do
* except echo the heartbeat to the Director).
*/
bool blast_data_to_storage_daemon(JCR *jcr, char *addr, crypto_cipher_t cipher)
{
BSOCK *sd;
bool ok = true;
sd = jcr->store_bsock;
jcr->setJobStatus(JS_Running);
Dmsg1(300, "filed: opened data connection %d to stored\n", sd->m_fd);
LockRes();
CLIENTRES *client = (CLIENTRES *)GetNextRes(R_CLIENT, NULL);
UnlockRes();
uint32_t buf_size;
if (client) {
buf_size = client->max_network_buffer_size;
} else {
buf_size = 0; /* use default */
}
if (!sd->set_buffer_size(buf_size, BNET_SETBUF_WRITE)) {
jcr->setJobStatus(JS_ErrorTerminated);
Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
return false;
}
jcr->buf_size = sd->msglen;
if (!adjust_compression_buffers(jcr)) {
return false;
}
if (!crypto_session_start(jcr, cipher)) {
return false;
}
set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
/**
* In accurate mode, we overload the find_one check function
*/
if (jcr->accurate) {
set_find_changed_function((FF_PKT *)jcr->ff, accurate_check_file);
}
start_heartbeat_monitor(jcr);
if (have_acl) {
jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
memset(jcr->acl_data, 0, sizeof(acl_data_t));
jcr->acl_data->u.build = (acl_build_data_t *)malloc(sizeof(acl_build_data_t));
memset(jcr->acl_data->u.build, 0, sizeof(acl_build_data_t));
jcr->acl_data->u.build->content = get_pool_memory(PM_MESSAGE);
}
if (have_xattr) {
jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
memset(jcr->xattr_data, 0, sizeof(xattr_data_t));
jcr->xattr_data->u.build = (xattr_build_data_t *)malloc(sizeof(xattr_build_data_t));
memset(jcr->xattr_data->u.build, 0, sizeof(xattr_build_data_t));
jcr->xattr_data->u.build->content = get_pool_memory(PM_MESSAGE);
}
/**
* Subroutine save_file() is called for each file
*/
if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, plugin_save)) {
ok = false; /* error */
jcr->setJobStatus(JS_ErrorTerminated);
}
if (have_acl && jcr->acl_data->u.build->nr_errors > 0) {
Jmsg(jcr, M_WARNING, 0, _("Encountered %ld acl errors while doing backup\n"),
jcr->acl_data->u.build->nr_errors);
}
if (have_xattr && jcr->xattr_data->u.build->nr_errors > 0) {
Jmsg(jcr, M_WARNING, 0, _("Encountered %ld xattr errors while doing backup\n"),
jcr->xattr_data->u.build->nr_errors);
}
close_vss_backup_session(jcr);
accurate_finish(jcr); /* send deleted or base file list to SD */
stop_heartbeat_monitor(jcr);
sd->signal(BNET_EOD); /* end of sending data */
if (have_acl && jcr->acl_data) {
free_pool_memory(jcr->acl_data->u.build->content);
free(jcr->acl_data->u.build);
free(jcr->acl_data);
jcr->acl_data = NULL;
}
if (have_xattr && jcr->xattr_data) {
free_pool_memory(jcr->xattr_data->u.build->content);
free(jcr->xattr_data->u.build);
free(jcr->xattr_data);
jcr->xattr_data = NULL;
}
if (jcr->big_buf) {
free(jcr->big_buf);
jcr->big_buf = NULL;
}
cleanup_compression(jcr);
crypto_session_end(jcr);
Dmsg1(100, "end blast_data ok=%d\n", ok);
return ok;
}
/*
* Fill the fileWidget box with the contents of the current directory
*/
void restorePage::fillDirectory()
{
mainWin->waitEnter();
char modes[20], user[20], group[20], size[20], date[30];
char marked[10];
int pnl, fnl;
POOLMEM *file = get_pool_memory(PM_FNAME);
POOLMEM *path = get_pool_memory(PM_FNAME);
fileWidget->clear();
m_console->write_dir(m_conn, "dir", false);
QList<QTreeWidgetItem *> treeItemList;
QStringList item;
m_rx.setPattern("has no children\\.$");
bool first = true;
while (m_console->read(m_conn) > 0) {
char *p = m_console->msg(m_conn);
char *l;
strip_trailing_newline(p);
if (*p == '$' || !*p) { continue; }
if (first) {
if (m_rx.indexIn(QString(p)) != -1) { continue; }
first = false;
}
l = p;
skip_nonspaces(&p); /* permissions */
*p++ = 0;
bstrncpy(modes, l, sizeof(modes));
skip_spaces(&p);
skip_nonspaces(&p); /* link count */
*p++ = 0;
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* user */
*p++ = 0;
skip_spaces(&p);
bstrncpy(user, l, sizeof(user));
l = p;
skip_nonspaces(&p); /* group */
*p++ = 0;
bstrncpy(group, l, sizeof(group));
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* size */
*p++ = 0;
bstrncpy(size, l, sizeof(size));
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* date/time */
skip_spaces(&p);
skip_nonspaces(&p);
*p++ = 0;
bstrncpy(date, l, sizeof(date));
skip_spaces(&p);
if (*p == '*') {
bstrncpy(marked, "*", sizeof(marked));
p++;
} else {
bstrncpy(marked, " ", sizeof(marked));
}
split_path_and_filename(p, path, &pnl, file, &fnl);
item.clear();
item << "" << file << modes << user << group << size << date;
if (item[1].endsWith("/")) {
addDirectory(item[1]);
}
QTreeWidgetItem *ti = new QTreeWidgetItem((QTreeWidget *)0, item);
ti->setTextAlignment(5, Qt::AlignRight); /* right align size */
if (strcmp(marked, "*") == 0) {
ti->setIcon(0, QIcon(QString::fromUtf8(":images/check.png")));
ti->setData(0, Qt::UserRole, true);
} else {
ti->setIcon(0, QIcon(QString::fromUtf8(":images/unchecked.png")));
ti->setData(0, Qt::UserRole, false);
}
treeItemList.append(ti);
}
fileWidget->clear();
fileWidget->insertTopLevelItems(0, treeItemList);
for (int i=0; i<7; i++) {
fileWidget->resizeColumnToContents(i);
}
free_pool_memory(file);
free_pool_memory(path);
mainWin->waitExit();
}
bool B_ACCURATE_LMDB::init(JCR *jcr, uint32_t nbfile)
{
int result;
MDB_env *env;
size_t mapsize = 10485760;
if (!m_db_env) {
result = mdb_env_create(&env);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to create MDB environment: %s\n"), mdb_strerror(result));
return false;
}
if ((nbfile * AVG_NR_BYTES_PER_ENTRY) > mapsize) {
size_t pagesize;
#ifdef HAVE_GETPAGESIZE
pagesize = getpagesize();
#else
pagesize = B_PAGE_SIZE;
#endif
mapsize = (((nbfile * AVG_NR_BYTES_PER_ENTRY) / pagesize) + 1) * pagesize;
}
result = mdb_env_set_mapsize(env, mapsize);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to set MDB mapsize: %s\n"), mdb_strerror(result));
goto bail_out;
}
/*
* Explicitly set the number of readers to 1.
*/
result = mdb_env_set_maxreaders(env, 1);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to set MDB maxreaders: %s\n"), mdb_strerror(result));
goto bail_out;
}
Mmsg(m_lmdb_name, "%s/.accurate_lmdb.%d", me->working_directory, jcr->JobId);
result = mdb_env_open(env, m_lmdb_name, MDB_NOSUBDIR | MDB_NOLOCK | MDB_NOSYNC, 0600);
if (result) {
Jmsg2(jcr, M_FATAL, 0, _("Unable create LDMD database %s: %s\n"), m_lmdb_name, mdb_strerror(result));
goto bail_out;
}
result = mdb_txn_begin(env, NULL, 0, &m_db_rw_txn);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to start a write transaction: %s\n"), mdb_strerror(result));
goto bail_out;
}
result = mdb_dbi_open(m_db_rw_txn, NULL, MDB_CREATE, &m_db_dbi);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to open LMDB internal database: %s\n"), mdb_strerror(result));
mdb_txn_abort(m_db_rw_txn);
m_db_rw_txn = NULL;
goto bail_out;
}
m_db_env = env;
}
if (!m_pay_load) {
m_pay_load = get_pool_memory(PM_MESSAGE);
}
if (!m_lmdb_name) {
m_pay_load = get_pool_memory(PM_FNAME);
}
if (!m_seen_bitmap) {
m_seen_bitmap = (char *)malloc(nbytes_for_bits(nbfile));
clear_all_bits(nbfile, m_seen_bitmap);
}
return true;
bail_out:
if (env) {
mdb_env_close(env);
}
return false;
}
/**
* Set Extended File Attributes for Win32
*
* fname is the original filename
* ofile is the output filename (may be in a different directory)
*
* Returns: true on success
* false on failure
*/
static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
{
char *p = attr->attrEx;
int64_t val;
WIN32_FILE_ATTRIBUTE_DATA atts;
ULARGE_INTEGER li;
POOLMEM *win32_ofile;
/** if we have neither Win ansi nor wchar API, get out */
if (!(p_SetFileAttributesW || p_SetFileAttributesA)) {
return false;
}
if (!p || !*p) { /* we should have attributes */
Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", attr->ofname, ofd->fid);
if (is_bopen(ofd)) {
bclose(ofd);
}
return false;
} else {
Dmsg2(100, "Attribs %s = %s\n", attr->ofname, attr->attrEx);
}
p += from_base64(&val, p);
plug(atts.dwFileAttributes, val);
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftCreationTime.dwLowDateTime = li.LowPart;
atts.ftCreationTime.dwHighDateTime = li.HighPart;
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftLastAccessTime.dwLowDateTime = li.LowPart;
atts.ftLastAccessTime.dwHighDateTime = li.HighPart;
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftLastWriteTime.dwLowDateTime = li.LowPart;
atts.ftLastWriteTime.dwHighDateTime = li.HighPart;
p++;
p += from_base64(&val, p);
plug(atts.nFileSizeHigh, val);
p++;
p += from_base64(&val, p);
plug(atts.nFileSizeLow, val);
/** Convert to Windows path format */
win32_ofile = get_pool_memory(PM_FNAME);
unix_name_to_win32(&win32_ofile, attr->ofname);
/** At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */
if (!is_bopen(ofd)) {
Dmsg1(100, "File not open: %s\n", attr->ofname);
bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0); /* attempt to open the file */
}
if (is_bopen(ofd)) {
Dmsg1(100, "SetFileTime %s\n", attr->ofname);
if (!SetFileTime(bget_handle(ofd),
&atts.ftCreationTime,
&atts.ftLastAccessTime,
&atts.ftLastWriteTime)) {
win_error(jcr, "SetFileTime:", win32_ofile);
}
bclose(ofd);
}
Dmsg1(100, "SetFileAtts %s\n", attr->ofname);
if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
if (p_SetFileAttributesW) {
POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);
make_win32_path_UTF8_2_wchar(&pwszBuf, attr->ofname);
BOOL b=p_SetFileAttributesW((LPCWSTR)pwszBuf, atts.dwFileAttributes & SET_ATTRS);
free_pool_memory(pwszBuf);
if (!b)
win_error(jcr, "SetFileAttributesW:", win32_ofile);
}
else {
if (!p_SetFileAttributesA(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) {
win_error(jcr, "SetFileAttributesA:", win32_ofile);
}
}
}
free_pool_memory(win32_ofile);
return true;
}
/*
* Director requests us to start a job
* Basic tasks done here:
* - We pickup the JobId to be run from the Director.
* - We pickup the device, media, and pool from the Director
* - Wait for a connection from the File Daemon (FD)
* - Accept commands from the FD (i.e. run the job)
* - Return when the connection is terminated or
* there is an error.
*/
bool job_cmd(JCR *jcr)
{
int32_t JobId;
char auth_key[MAX_NAME_LENGTH];
char seed[MAX_NAME_LENGTH];
char spool_size[MAX_NAME_LENGTH];
BSOCK *dir = jcr->dir_bsock;
POOL_MEM job_name, client_name, job, fileset_name, fileset_md5, backup_format;
int32_t JobType, level, spool_attributes, no_attributes, spool_data;
int32_t PreferMountedVols, rerunning, protocol, dumplevel;
int status;
uint64_t quota = 0;
JCR *ojcr;
/*
* Get JobId and permissions from Director
*/
Dmsg1(100, "<dird: %s", dir->msg);
bstrncpy(spool_size, "0", sizeof(spool_size));
status = sscanf(dir->msg, jobcmd, &JobId, job.c_str(), job_name.c_str(),
client_name.c_str(), &JobType, &level, fileset_name.c_str(),
&no_attributes, &spool_attributes, fileset_md5.c_str(),
&spool_data, &PreferMountedVols, spool_size, &rerunning,
&jcr->VolSessionId, &jcr->VolSessionTime, "a, &protocol,
backup_format.c_str(), &dumplevel);
if (status != 20) {
pm_strcpy(jcr->errmsg, dir->msg);
dir->fsend(BAD_job, status, jcr->errmsg);
Dmsg1(100, ">dird: %s", dir->msg);
jcr->setJobStatus(JS_ErrorTerminated);
return false;
}
jcr->rerunning = (rerunning) ? true : false;
jcr->setJobProtocol(protocol);
Dmsg4(100, "rerunning=%d VolSesId=%d VolSesTime=%d Protocol=%d\n",
jcr->rerunning, jcr->VolSessionId, jcr->VolSessionTime, jcr->getJobProtocol());
/*
* Since this job could be rescheduled, we
* check to see if we have it already. If so
* free the old jcr and use the new one.
*/
ojcr = get_jcr_by_full_name(job.c_str());
if (ojcr && !ojcr->authenticated) {
Dmsg2(100, "Found ojcr=0x%x Job %s\n", (unsigned)(intptr_t)ojcr, job.c_str());
free_jcr(ojcr);
}
jcr->JobId = JobId;
Dmsg2(800, "Start JobId=%d %p\n", JobId, jcr);
/*
* If job rescheduled because previous was incomplete,
* the Resched flag is set and VolSessionId and VolSessionTime
* are given to us (same as restarted job).
*/
if (!jcr->rerunning) {
jcr->VolSessionId = newVolSessionId();
jcr->VolSessionTime = VolSessionTime;
}
bstrncpy(jcr->Job, job, sizeof(jcr->Job));
unbash_spaces(job_name);
jcr->job_name = get_pool_memory(PM_NAME);
pm_strcpy(jcr->job_name, job_name);
unbash_spaces(client_name);
jcr->client_name = get_pool_memory(PM_NAME);
pm_strcpy(jcr->client_name, client_name);
unbash_spaces(fileset_name);
jcr->fileset_name = get_pool_memory(PM_NAME);
pm_strcpy(jcr->fileset_name, fileset_name);
jcr->setJobType(JobType);
jcr->setJobLevel(level);
jcr->no_attributes = no_attributes;
jcr->spool_attributes = spool_attributes;
jcr->spool_data = spool_data;
jcr->spool_size = str_to_int64(spool_size);
jcr->fileset_md5 = get_pool_memory(PM_NAME);
pm_strcpy(jcr->fileset_md5, fileset_md5);
jcr->PreferMountedVols = PreferMountedVols;
jcr->RemainingQuota = quota;
unbash_spaces(backup_format);
jcr->backup_format = get_pool_memory(PM_NAME);
pm_strcpy(jcr->backup_format, backup_format);
jcr->DumpLevel = dumplevel;
jcr->authenticated = false;
Dmsg1(50, "Quota set as %llu\n", quota);
/*
* Pass back an authorization key for the File daemon
*/
bsnprintf(seed, sizeof(seed), "%p%d", jcr, JobId);
make_session_key(auth_key, seed, 1);
dir->fsend(OK_job, jcr->VolSessionId, jcr->VolSessionTime, auth_key);
Dmsg2(50, ">dird jid=%u: %s", (uint32_t)jcr->JobId, dir->msg);
jcr->sd_auth_key = bstrdup(auth_key);
memset(auth_key, 0, sizeof(auth_key));
dispatch_new_plugin_options(jcr);
generate_plugin_event(jcr, bsdEventJobStart, (void *)"JobStart");
return true;
}
/*
* See who is connecting and lookup the authentication information.
* First make him prove his identity and then prove our identity to the Remote daemon.
*/
static inline bool two_way_authenticate(int rcode, BSOCK *bs, JCR* jcr)
{
POOLMEM *dirname = get_pool_memory(PM_MESSAGE);
DIRRES *director = NULL;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true; /* Want md5 compatible DIR */
bool auth_success = false;
alist *verify_list = NULL;
btimer_t *tid = NULL;
if (rcode != R_DIRECTOR) {
Dmsg1(dbglvl, "I only authenticate directors, not %d\n", rcode);
Jmsg1(jcr, M_FATAL, 0, _("I only authenticate directors, not %d\n"), rcode);
goto auth_fatal;
}
if (bs->msglen < 25 || bs->msglen > 500) {
Dmsg2(dbglvl, "Bad Hello command from Director at %s. Len=%d.\n",
bs->who(), bs->msglen);
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s. Len=%d.\n"),
who, bs->msglen);
goto auth_fatal;
}
dirname = check_pool_memory_size(dirname, bs->msglen);
if (sscanf(bs->msg, "Hello Director %s calling", dirname) != 1) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
bs->msg[100] = 0;
Dmsg2(dbglvl, "Bad Hello command from Director at %s: %s\n",
bs->who(), bs->msg);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s: %s\n"),
who, bs->msg);
goto auth_fatal;
}
unbash_spaces(dirname);
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, dirname))
break;
}
if (!director) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Jmsg2(jcr, M_FATAL, 0, _("Connection from unknown Director %s at %s rejected.\n"),
dirname, who);
goto auth_fatal;
}
if (have_tls) {
/*
* TLS Requirement
*/
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (director->tls_verify_peer) {
verify_list = director->tls_allowed_cns;
}
}
/*
* Timeout Hello after 10 min
*/
tid = start_bsock_timer(bs, AUTH_TIMEOUT);
/*
* Sanity check.
*/
ASSERT(director->password.encoding == p_encoding_md5);
/*
* Challenge the director
*/
auth_success = cram_md5_challenge(bs, director->password.value, tls_local_need, compatible);
if (job_canceled(jcr)) {
auth_success = false;
goto auth_fatal; /* quick exit */
}
if (auth_success) {
auth_success = cram_md5_respond(bs, director->password.value, &tls_remote_need, &compatible);
if (!auth_success) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Dmsg1(dbglvl, "cram_get_auth failed for %s\n", who);
}
} else {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Dmsg1(dbglvl, "cram_auth failed for %s\n", who);
}
if (!auth_success) {
Emsg1(M_FATAL, 0, _("Incorrect password given by Director at %s.\n"),
bs->who());
goto auth_fatal;
}
/*
* Verify that the remote host is willing to meet our TLS requirements
*/
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not"
" advertize required TLS support.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that we are willing to meet the remote host's requirements
*/
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/*
* Engage TLS! Full Speed Ahead!
*/
if (!bnet_tls_server(director->tls_ctx, bs, verify_list)) {
Jmsg0(jcr, M_FATAL, 0, _("TLS negotiation failed.\n"));
auth_success = false;
goto auth_fatal;
}
if (director->tls_authenticate) { /* authentication only? */
bs->free_tls(); /* shutodown tls */
}
}
auth_fatal:
if (tid) {
stop_bsock_timer(tid);
tid = NULL;
}
free_pool_memory(dirname);
jcr->director = director;
/*
* Single thread all failures to avoid DOS
*/
if (!auth_success) {
P(mutex);
bmicrosleep(6, 0);
V(mutex);
}
return auth_success;
}
/*
* This job is done, so release the device. From a Unix standpoint,
* the device remains open.
*
* Note, if we were spooling, we may enter with the device blocked.
* We unblock at the end, only if it was us who blocked the
* device.
*
*/
bool release_device(DCR *dcr)
{
utime_t now;
JCR *jcr = dcr->jcr;
DEVICE *dev = dcr->dev;
bool ok = true;
char tbuf[100];
int was_blocked = BST_NOT_BLOCKED;
/*
* Capture job statistics now that we are done using this device.
*/
now = (utime_t)time(NULL);
update_job_statistics(jcr, now);
dev->Lock();
if (!dev->is_blocked()) {
block_device(dev, BST_RELEASING);
} else {
was_blocked = dev->blocked();
dev->set_blocked(BST_RELEASING);
}
lock_volumes();
Dmsg2(100, "release_device device %s is %s\n", dev->print_name(), dev->is_tape() ? "tape" : "disk");
/*
* If device is reserved, job never started, so release the reserve here
*/
dcr->clear_reserved();
if (dev->can_read()) {
VOLUME_CAT_INFO *vol = &dev->VolCatInfo;
dev->clear_read(); /* clear read bit */
Dmsg2(150, "dir_update_vol_info. label=%d Vol=%s\n",
dev->is_labeled(), vol->VolCatName);
if (dev->is_labeled() && vol->VolCatName[0] != 0) {
dcr->dir_update_volume_info(false, false); /* send Volume info to Director */
remove_read_volume(jcr, dcr->VolumeName);
volume_unused(dcr);
}
} else if (dev->num_writers > 0) {
/*
* Note if WEOT is set, we are at the end of the tape and may not be positioned correctly,
* so the job_media_record and update_vol_info have already been done,
* which means we skip them here.
*/
dev->num_writers--;
Dmsg1(100, "There are %d writers in release_device\n", dev->num_writers);
if (dev->is_labeled()) {
Dmsg2(200, "dir_create_jobmedia. Release vol=%s dev=%s\n",
dev->getVolCatName(), dev->print_name());
if (!dev->at_weot() && !dcr->dir_create_jobmedia_record(false)) {
Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
dcr->getVolCatName(), jcr->Job);
}
/*
* If no more writers, and no errors, and wrote something, write an EOF
*/
if (!dev->num_writers && dev->can_write() && dev->block_num > 0) {
dev->weof(1);
write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);
}
if (!dev->at_weot()) {
dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */
/*
* Note! do volume update before close, which zaps VolCatInfo
*/
dcr->dir_update_volume_info(false, false); /* send Volume info to Director */
Dmsg2(200, "dir_update_vol_info. Release vol=%s dev=%s\n",
dev->getVolCatName(), dev->print_name());
}
if (dev->num_writers == 0) { /* if not being used */
volume_unused(dcr); /* we obviously are not using the volume */
}
}
} else {
/*
* If we reach here, it is most likely because the job has failed,
* since the device is not in read mode and there are no writers.
* It was probably reserved.
*/
volume_unused(dcr);
}
Dmsg3(100, "%d writers, %d reserve, dev=%s\n", dev->num_writers, dev->num_reserved(), dev->print_name());
/*
* If no writers, close if file or !CAP_ALWAYS_OPEN
*/
if (dev->num_writers == 0 && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
dev->close(dcr);
free_volume(dev);
}
unlock_volumes();
/*
* Fire off Alert command and include any output
*/
if (!job_canceled(jcr)) {
if (!dcr->device->drive_tapealert_enabled && dcr->device->alert_command) {
int status = 1;
POOLMEM *alert, *line;
BPIPE *bpipe;
alert = get_pool_memory(PM_FNAME);
line = get_pool_memory(PM_FNAME);
alert = edit_device_codes(dcr, alert, dcr->device->alert_command, "");
/*
* Wait maximum 5 minutes
*/
bpipe = open_bpipe(alert, 60 * 5, "r");
if (bpipe) {
while (bfgets(line, bpipe->rfd)) {
Jmsg(jcr, M_ALERT, 0, _("Alert: %s"), line);
}
status = close_bpipe(bpipe);
} else {
status = errno;
}
if (status != 0) {
berrno be;
Jmsg(jcr, M_ALERT, 0, _("3997 Bad alert command: %s: ERR=%s.\n"), alert, be.bstrerror(status));
}
Dmsg1(400, "alert status=%d\n", status);
free_pool_memory(alert);
free_pool_memory(line);
} else {
/*
* If all reservations are cleared for this device raise an event that SD plugins can register to.
*/
if (dev->num_reserved() == 0) {
generate_plugin_event(jcr, bsdEventDeviceReleased, dcr);
}
}
}
pthread_cond_broadcast(&dev->wait_next_vol);
Dmsg2(100, "JobId=%u broadcast wait_device_release at %s\n",
(uint32_t)jcr->JobId, bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
release_device_cond();
/*
* If we are the thread that blocked the device, then unblock it
*/
if (pthread_equal(dev->no_wait_id, pthread_self())) {
dev->dunblock(true);
} else {
/*
* Otherwise, reset the prior block status and unlock
*/
dev->set_blocked(was_blocked);
dev->Unlock();
}
if (dcr->keep_dcr) {
detach_dcr_from_dev(dcr);
} else {
free_dcr(dcr);
}
Dmsg2(100, "Device %s released by JobId=%u\n", dev->print_name(), (uint32_t)jcr->JobId);
return ok;
}
/*
* Update File Attributes in the catalog with data read from
* the storage daemon spool file. We receive the filename and
* we try to read it.
*/
bool despool_attributes_from_file(JCR *jcr, const char *file)
{
bool retval = false;
int32_t pktsiz;
size_t nbytes;
ssize_t size = 0;
int32_t msglen; /* message length */
FILE *spool_fd = NULL;
POOLMEM *msg = get_pool_memory(PM_MESSAGE);
Dmsg0(100, "Begin despool_attributes_from_file\n");
if (jcr->is_job_canceled() || !jcr->res.pool->catalog_files || !jcr->db) {
goto bail_out; /* user disabled cataloging */
}
spool_fd = fopen(file, "rb");
if (!spool_fd) {
Dmsg0(100, "cancel despool_attributes_from_file\n");
/* send an error message */
goto bail_out;
}
#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
posix_fadvise(fileno(spool_fd), 0, 0, POSIX_FADV_WILLNEED);
#endif
while (fread((char *)&pktsiz, 1, sizeof(int32_t), spool_fd) == sizeof(int32_t)) {
size += sizeof(int32_t);
msglen = ntohl(pktsiz);
if (msglen > 0) {
if (msglen > (int32_t) sizeof_pool_memory(msg)) {
msg = realloc_pool_memory(msg, msglen + 1);
}
nbytes = fread(msg, 1, msglen, spool_fd);
if (nbytes != (size_t) msglen) {
berrno be;
Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
Qmsg1(jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
be.bstrerror());
goto bail_out;
}
size += nbytes;
}
if (!jcr->is_job_canceled()) {
update_attribute(jcr, msg, msglen);
if (jcr->is_job_canceled()) {
goto bail_out;
}
}
}
if (ferror(spool_fd)) {
berrno be;
Qmsg1(jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
be.bstrerror());
goto bail_out;
}
retval = true;
bail_out:
if (spool_fd) {
fclose(spool_fd);
}
if (jcr->is_job_canceled()) {
cancel_storage_daemon_job(jcr);
}
free_pool_memory(msg);
Dmsg1(100, "End despool_attributes_from_file retval=%i\n", retval);
return retval;
}
/* Store Messages Destination information */
void store_msgs(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token;
char *cmd;
POOLMEM *dest;
int dest_len;
Dmsg2(900, "store_msgs pass=%d code=%d\n", pass, item->code);
if (pass == 1) {
switch (item->code) {
case MD_STDOUT:
case MD_STDERR:
case MD_SYSLOG: /* syslog */
case MD_CONSOLE:
case MD_CATALOG:
scan_types(lc, (MSGS *)(item->value), item->code, NULL, NULL);
break;
case MD_OPERATOR: /* send to operator */
case MD_DIRECTOR: /* send to Director */
case MD_MAIL: /* mail */
case MD_MAIL_ON_ERROR: /* mail if Job errors */
case MD_MAIL_ON_SUCCESS: /* mail if Job succeeds */
if (item->code == MD_OPERATOR) {
cmd = res_all.res_msgs.operator_cmd;
} else {
cmd = res_all.res_msgs.mail_cmd;
}
dest = get_pool_memory(PM_MESSAGE);
dest[0] = 0;
dest_len = 0;
/* Pick up comma separated list of destinations */
for ( ;; ) {
token = lex_get_token(lc, T_NAME); /* scan destination */
dest = check_pool_memory_size(dest, dest_len + lc->str_len + 2);
if (dest[0] != 0) {
pm_strcat(dest, " "); /* separate multiple destinations with space */
dest_len++;
}
pm_strcat(dest, lc->str);
dest_len += lc->str_len;
Dmsg2(900, "store_msgs newdest=%s: dest=%s:\n", lc->str, NPRT(dest));
token = lex_get_token(lc, T_SKIP_EOL);
if (token == T_COMMA) {
continue; /* get another destination */
}
if (token != T_EQUALS) {
scan_err1(lc, _("expected an =, got: %s"), lc->str);
return;
}
break;
}
Dmsg1(900, "mail_cmd=%s\n", NPRT(cmd));
scan_types(lc, (MSGS *)(item->value), item->code, dest, cmd);
free_pool_memory(dest);
Dmsg0(900, "done with dest codes\n");
break;
case MD_FILE: /* file */
case MD_APPEND: /* append */
dest = get_pool_memory(PM_MESSAGE);
/* Pick up a single destination */
token = lex_get_token(lc, T_NAME); /* scan destination */
pm_strcpy(dest, lc->str);
dest_len = lc->str_len;
token = lex_get_token(lc, T_SKIP_EOL);
Dmsg1(900, "store_msgs dest=%s:\n", NPRT(dest));
if (token != T_EQUALS) {
scan_err1(lc, _("expected an =, got: %s"), lc->str);
return;
}
scan_types(lc, (MSGS *)(item->value), item->code, dest, NULL);
free_pool_memory(dest);
Dmsg0(900, "done with dest codes\n");
break;
default:
scan_err1(lc, _("Unknown item code: %d\n"), item->code);
return;
}
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
Dmsg0(900, "Done store_msgs\n");
}
