static bool create_bootstrap_file(JCR *jcr, char *jobids)
{
RESTORE_CTX rx;
UAContext *ua;
memset(&rx, 0, sizeof(rx));
rx.bsr = new_bsr();
ua = new_ua_context(jcr);
rx.JobIds = jobids;
if (!db_open_batch_connection(jcr, jcr->db)) {
Jmsg0(jcr, M_FATAL, 0, "Can't get batch sql connexion");
return false;
}
if (!db_get_file_list(jcr, jcr->db_batch, jobids, false /* don't use md5 */,
true /* use delta */,
insert_bootstrap_handler, (void *)rx.bsr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db_batch));
}
complete_bsr(ua, rx.bsr);
jcr->ExpectedFiles = write_bsr_file(ua, rx);
if (debug_level >= 10) {
Dmsg1(000, "Found %d files to consolidate.\n", jcr->ExpectedFiles);
}
if (jcr->ExpectedFiles == 0) {
free_ua_context(ua);
free_bsr(rx.bsr);
return false;
}
free_ua_context(ua);
free_bsr(rx.bsr);
return true;
}
/*********************************************************************
*
* Parse Bootstrap file
*
*/
BSR *parse_bsr(JCR *jcr, char *fname)
{
LEX *lc = NULL;
int token, i;
BSR *root_bsr = new_bsr();
BSR *bsr = root_bsr;
Dmsg1(300, "Enter parse_bsf %s\n", fname);
if ((lc = lex_open_file(lc, fname, s_err)) == NULL) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Cannot open bootstrap file %s: %s\n"),
fname, be.bstrerror());
}
lc->caller_ctx = (void *)jcr;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg1(300, "parse got token=%s\n", lex_tok_to_str(token));
if (token == T_EOL) {
continue;
}
for (i=0; items[i].name; i++) {
if (strcasecmp(items[i].name, lc->str) == 0) {
token = lex_get_token(lc, T_ALL);
Dmsg1 (300, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
scan_err1(lc, "expected an equals, got: %s", lc->str);
bsr = NULL;
break;
}
Dmsg1(300, "calling handler for %s\n", items[i].name);
/* Call item handler */
bsr = items[i].handler(lc, bsr);
i = -1;
break;
}
}
if (i >= 0) {
Dmsg1(300, "Keyword = %s\n", lc->str);
scan_err1(lc, "Keyword %s not found", lc->str);
bsr = NULL;
break;
}
if (!bsr) {
break;
}
}
lc = lex_close_file(lc);
Dmsg0(300, "Leave parse_bsf()\n");
if (!bsr) {
free_bsr(root_bsr);
root_bsr = NULL;
}
if (root_bsr) {
root_bsr->use_fast_rejection = is_fast_rejection_ok(root_bsr);
root_bsr->use_positioning = is_positioning_ok(root_bsr);
}
for (bsr=root_bsr; bsr; bsr=bsr->next) {
bsr->root = root_bsr;
}
return root_bsr;
}
/*
* Add all possible FileIndexes to the list of BootStrap records.
* Here we are only dealing with JobId's and the FileIndexes
* associated with those JobIds.
*/
void add_findex_all(RBSR *bsr, uint32_t JobId)
{
RBSR *nbsr;
RBSR_FINDEX *fi;
if (bsr->fi == NULL) { /* if no FI add one */
/*
* This is the first FileIndex item in the chain
*/
bsr->fi = new_findex();
bsr->JobId = JobId;
bsr->fi->findex = 1;
bsr->fi->findex2 = INT32_MAX;
return;
}
/*
* Walk down list of bsrs until we find the JobId
*/
if (bsr->JobId != JobId) {
for (nbsr = bsr->next; nbsr; nbsr = nbsr->next) {
if (nbsr->JobId == JobId) {
bsr = nbsr;
break;
}
}
if (!nbsr) { /* Must add new JobId */
/*
* Add new JobId at end of chain
*/
for (nbsr = bsr; nbsr->next; nbsr = nbsr->next)
{ }
nbsr->next = new_bsr();
nbsr->next->JobId = JobId;
/*
* If we use regexp to restore, set it for each jobid
*/
if (bsr->fileregex) {
nbsr->next->fileregex = bstrdup(bsr->fileregex);
}
nbsr->next->fi = new_findex();
nbsr->next->fi->findex = 1;
nbsr->next->fi->findex2 = INT32_MAX;
return;
}
}
/*
* At this point, bsr points to bsr containing this JobId,
* and we are sure that there is at least one fi record.
*/
fi = bsr->fi;
fi->findex = 1;
fi->findex2 = INT32_MAX;
return;
}
static BSR *store_vol(LEX *lc, BSR *bsr)
{
int token;
BSR_VOLUME *volume;
char *p, *n;
token = lex_get_token(lc, T_STRING);
if (token == T_ERROR) {
return NULL;
}
if (bsr->volume) {
bsr->next = new_bsr();
bsr->next->prev = bsr;
bsr = bsr->next;
}
/* This may actually be more than one volume separated by a |
* If so, separate them.
*/
for (p=lc->str; p && *p; ) {
n = strchr(p, '|');
if (n) {
*n++ = 0;
}
volume = (BSR_VOLUME *)malloc(sizeof(BSR_VOLUME));
memset(volume, 0, sizeof(BSR_VOLUME));
bstrncpy(volume->VolumeName, p, sizeof(volume->VolumeName));
/*
* Add it to the end of the volume chain
*/
if (!bsr->volume) {
bsr->volume = volume;
} else {
BSR_VOLUME *bc = bsr->volume;
for ( ;bc->next; bc=bc->next)
{ }
bc->next = volume;
}
p = n;
}
return bsr;
}
/*
* 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;
}
/*
* Add a FileIndex to the list of BootStrap records.
* Here we are only dealing with JobId's and the FileIndexes
* associated with those JobIds.
*
* We expect that JobId, FileIndex are sorted ascending.
*/
void add_findex(RBSR *bsr, uint32_t JobId, int32_t findex)
{
RBSR *nbsr;
RBSR_FINDEX *fi, *lfi;
if (findex == 0) {
return; /* probably a dummy directory */
}
if (bsr->fi == NULL) { /* if no FI add one */
/*
* This is the first FileIndex item in the chain
*/
bsr->fi = new_findex();
bsr->JobId = JobId;
bsr->fi->findex = findex;
bsr->fi->findex2 = findex;
return;
}
/*
* Walk down list of bsrs until we find the JobId
*/
if (bsr->JobId != JobId) {
for (nbsr = bsr->next; nbsr; nbsr = nbsr->next) {
if (nbsr->JobId == JobId) {
bsr = nbsr;
break;
}
}
if (!nbsr) { /* Must add new JobId */
/*
* Add new JobId at end of chain
*/
for (nbsr = bsr; nbsr->next; nbsr = nbsr->next)
{ }
nbsr->next = new_bsr();
nbsr->next->JobId = JobId;
nbsr->next->fi = new_findex();
nbsr->next->fi->findex = findex;
nbsr->next->fi->findex2 = findex;
return;
}
}
/*
* At this point, bsr points to bsr containing this JobId,
* and we are sure that there is at least one fi record.
*/
lfi = fi = bsr->fi;
/*
* Check if this findex is a duplicate.
*/
if (findex >= fi->findex && findex <= fi->findex2) {
return;
}
/*
* Check if this findex is smaller than first item
*/
if (findex < fi->findex) {
if ((findex + 1) == fi->findex) {
fi->findex = findex; /* extend down */
return;
}
fi = new_findex(); /* yes, insert before first item */
fi->findex = findex;
fi->findex2 = findex;
fi->next = lfi;
bsr->fi = fi;
return;
}
/*
* Walk down fi chain and find where to insert insert new FileIndex
*/
while (fi) {
/*
* Check if this findex is a duplicate.
*/
if (findex >= fi->findex && findex <= fi->findex2) {
return;
}
if (findex == (fi->findex2 + 1)) { /* extend up */
RBSR_FINDEX *nfi;
fi->findex2 = findex;
/*
* If the following record contains one higher, merge its
* file index by extending it up.
*/
if (fi->next && ((findex + 1) == fi->next->findex)) {
nfi = fi->next;
fi->findex2 = nfi->findex2;
fi->next = nfi->next;
free(nfi);
}
return;
}
if (findex < fi->findex) { /* add before */
if ((findex + 1) == fi->findex) {
fi->findex = findex;
return;
}
break;
}
lfi = fi;
fi = fi->next;
}
/*
* Add to last place found
*/
fi = new_findex();
fi->findex = findex;
fi->findex2 = findex;
fi->next = lfi->next;
lfi->next = fi;
return;
}
