2 Bacula® - The Network Backup Solution
4 Copyright (C) 2002-2009 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Bacula Director -- User Agent Database restore Command
31 * Creates a bootstrap file for restoring files and
32 * starts the restore job.
34 * Tree handling routines split into ua_tree.c July MMIII.
35 * BSR (bootstrap record) handling routines split into
38 * Kern Sibbald, July MMII
47 /* Imported functions */
48 extern void print_bsr(UAContext *ua, RBSR *bsr);
52 /* Forward referenced functions */
53 static int last_full_handler(void *ctx, int num_fields, char **row);
54 static int jobid_handler(void *ctx, int num_fields, char **row);
55 static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx);
56 static int fileset_handler(void *ctx, int num_fields, char **row);
57 static void free_name_list(NAME_LIST *name_list);
58 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date);
59 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx);
60 static void free_rx(RESTORE_CTX *rx);
61 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *fname);
62 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row);
63 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
65 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
67 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir);
68 static int get_client_name(UAContext *ua, RESTORE_CTX *rx);
69 static int get_restore_client_name(UAContext *ua, RESTORE_CTX &rx);
70 static int get_date(UAContext *ua, char *date, int date_len);
71 static int restore_count_handler(void *ctx, int num_fields, char **row);
72 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table);
73 static void get_and_display_basejobs(UAContext *ua, RESTORE_CTX *rx);
79 int restore_cmd(UAContext *ua, const char *cmd)
81 RESTORE_CTX rx; /* restore context */
85 char *escaped_bsr_name = NULL;
86 char *escaped_where_name = NULL;
87 char *strip_prefix, *add_prefix, *add_suffix, *regexp;
88 strip_prefix = add_prefix = add_suffix = regexp = NULL;
90 memset(&rx, 0, sizeof(rx));
91 rx.path = get_pool_memory(PM_FNAME);
92 rx.fname = get_pool_memory(PM_FNAME);
93 rx.JobIds = get_pool_memory(PM_FNAME);
94 rx.BaseJobIds = get_pool_memory(PM_FNAME);
95 rx.query = get_pool_memory(PM_FNAME);
98 i = find_arg_with_value(ua, "where");
100 rx.where = ua->argv[i];
103 i = find_arg_with_value(ua, "strip_prefix");
105 strip_prefix = ua->argv[i];
108 i = find_arg_with_value(ua, "add_prefix");
110 add_prefix = ua->argv[i];
113 i = find_arg_with_value(ua, "add_suffix");
115 add_suffix = ua->argv[i];
118 i = find_arg_with_value(ua, "regexwhere");
120 rx.RegexWhere = ua->argv[i];
123 if (strip_prefix || add_suffix || add_prefix) {
124 int len = bregexp_get_build_where_size(strip_prefix, add_prefix, add_suffix);
125 regexp = (char *)bmalloc(len * sizeof(char));
127 bregexp_build_where(regexp, len, strip_prefix, add_prefix, add_suffix);
128 rx.RegexWhere = regexp;
131 /* TODO: add acl for regexwhere ? */
134 if (!acl_access_ok(ua, Where_ACL, rx.RegexWhere)) {
135 ua->error_msg(_("\"RegexWhere\" specification not authorized.\n"));
141 if (!acl_access_ok(ua, Where_ACL, rx.where)) {
142 ua->error_msg(_("\"where\" specification not authorized.\n"));
147 if (!open_client_db(ua)) {
151 /* Ensure there is at least one Restore Job */
153 foreach_res(job, R_JOB) {
154 if (job->JobType == JT_RESTORE) {
155 if (!rx.restore_job) {
156 rx.restore_job = job;
162 if (!rx.restore_jobs) {
164 "No Restore Job Resource found in bacula-dir.conf.\n"
165 "You must create at least one before running this command.\n"));
170 * Request user to select JobIds or files by various different methods
171 * last 20 jobs, where File saved, most recent backup, ...
172 * In the end, a list of files are pumped into
175 switch (user_select_jobids_or_files(ua, &rx)) {
178 case 1: /* selected by jobid */
179 get_and_display_basejobs(ua, &rx);
180 if (!build_directory_tree(ua, &rx)) {
181 ua->send_msg(_("Restore not done.\n"));
185 case 2: /* selected by filename, no tree needed */
190 uint32_t selected_files;
192 if (!complete_bsr(ua, rx.bsr)) { /* find Vol, SessId, SessTime from JobIds */
193 ua->error_msg(_("Unable to construct a valid BSR. Cannot continue.\n"));
196 if (!(selected_files = write_bsr_file(ua, rx))) {
197 ua->warning_msg(_("No files selected to be restored.\n"));
200 display_bsr_info(ua, rx); /* display vols needed, etc */
202 /* If no count of files, use bsr generated value (often wrong) */
203 if (rx.selected_files == 0) {
204 rx.selected_files = selected_files;
206 if (rx.selected_files==1) {
207 ua->info_msg(_("\n1 file selected to be restored.\n\n"));
210 ua->info_msg(_("\n%s files selected to be restored.\n\n"),
211 edit_uint64_with_commas(rx.selected_files, ed1));
214 ua->warning_msg(_("No files selected to be restored.\n"));
218 if (rx.restore_jobs == 1) {
219 job = rx.restore_job;
221 job = select_restore_job_resource(ua);
227 get_client_name(ua, &rx);
228 if (!rx.ClientName) {
229 ua->error_msg(_("No Client resource found!\n"));
232 get_restore_client_name(ua, rx);
234 escaped_bsr_name = escape_filename(jcr->RestoreBootstrap);
236 /* Build run command */
238 escaped_where_name = escape_filename(rx.RegexWhere);
240 "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
241 " bootstrap=\"%s\" regexwhere=\"%s\" files=%u catalog=\"%s\"",
242 job->name(), rx.ClientName, rx.RestoreClientName,
243 rx.store?rx.store->name():"",
244 escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
245 escaped_where_name ? escaped_where_name : rx.RegexWhere,
246 rx.selected_files, ua->catalog->name());
248 } else if (rx.where) {
249 escaped_where_name = escape_filename(rx.where);
251 "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
252 " bootstrap=\"%s\" where=\"%s\" files=%u catalog=\"%s\"",
253 job->name(), rx.ClientName, rx.RestoreClientName,
254 rx.store?rx.store->name():"",
255 escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
256 escaped_where_name ? escaped_where_name : rx.where,
257 rx.selected_files, ua->catalog->name());
261 "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
262 " bootstrap=\"%s\" files=%u catalog=\"%s\"",
263 job->name(), rx.ClientName, rx.RestoreClientName,
264 rx.store?rx.store->name():"",
265 escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
266 rx.selected_files, ua->catalog->name());
269 if (escaped_bsr_name != NULL) {
270 bfree(escaped_bsr_name);
273 if (escaped_where_name != NULL) {
274 bfree(escaped_where_name);
281 if (find_arg(ua, NT_("yes")) > 0) {
282 pm_strcat(ua->cmd, " yes"); /* pass it on to the run command */
284 Dmsg1(200, "Submitting: %s\n", ua->cmd);
286 run_cmd(ua, ua->cmd);
291 if (escaped_bsr_name != NULL) {
292 bfree(escaped_bsr_name);
295 if (escaped_where_name != NULL) {
296 bfree(escaped_where_name);
309 * Fill the rx->BaseJobIds and display the list
311 static void get_and_display_basejobs(UAContext *ua, RESTORE_CTX *rx)
315 if (!db_get_used_base_jobids(ua->jcr, ua->db, rx->JobIds, &jobids)) {
316 ua->warning_msg("%s", db_strerror(ua->db));
321 Mmsg(q, uar_print_jobs, jobids.list);
322 ua->send_msg(_("The restore will use the following job(s) as Base\n"));
323 db_list_sql_query(ua->jcr, ua->db, q.c_str(), prtit, ua, 1, HORZ_LIST);
325 pm_strcpy(rx->BaseJobIds, jobids.list);
328 static void free_rx(RESTORE_CTX *rx)
332 free_and_null_pool_memory(rx->JobIds);
333 free_and_null_pool_memory(rx->BaseJobIds);
334 free_and_null_pool_memory(rx->fname);
335 free_and_null_pool_memory(rx->path);
336 free_and_null_pool_memory(rx->query);
337 free_name_list(&rx->name_list);
340 static bool has_value(UAContext *ua, int i)
343 ua->error_msg(_("Missing value for keyword: %s\n"), ua->argk[i]);
350 * This gets the client name from which the backup was made
352 static int get_client_name(UAContext *ua, RESTORE_CTX *rx)
354 /* If no client name specified yet, get it now */
355 if (!rx->ClientName[0]) {
357 /* try command line argument */
358 int i = find_arg_with_value(ua, NT_("client"));
360 i = find_arg_with_value(ua, NT_("backupclient"));
363 if (!has_value(ua, i)) {
366 bstrncpy(rx->ClientName, ua->argv[i], sizeof(rx->ClientName));
369 memset(&cr, 0, sizeof(cr));
370 if (!get_client_dbr(ua, &cr)) {
373 bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
379 * This is where we pick up a client name to restore to.
381 static int get_restore_client_name(UAContext *ua, RESTORE_CTX &rx)
383 /* Start with same name as backup client */
384 bstrncpy(rx.RestoreClientName, rx.ClientName, sizeof(rx.RestoreClientName));
386 /* try command line argument */
387 int i = find_arg_with_value(ua, NT_("restoreclient"));
389 if (!has_value(ua, i)) {
392 bstrncpy(rx.RestoreClientName, ua->argv[i], sizeof(rx.RestoreClientName));
401 * The first step in the restore process is for the user to
402 * select a list of JobIds from which he will subsequently
403 * select which files are to be restored.
405 * Returns: 2 if filename list made
406 * 1 if jobid list made
409 static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
412 char date[MAX_TIME_LENGTH];
413 bool have_date = false;
414 /* Include current second if using current time */
415 utime_t now = time(NULL) + 1;
417 JOB_DBR jr = { (JobId_t)-1 };
420 const char *list[] = {
421 _("List last 20 Jobs run"),
422 _("List Jobs where a given File is saved"),
423 _("Enter list of comma separated JobIds to select"),
424 _("Enter SQL list command"),
425 _("Select the most recent backup for a client"),
426 _("Select backup for a client before a specified time"),
427 _("Enter a list of files to restore"),
428 _("Enter a list of files to restore before a specified time"),
429 _("Find the JobIds of the most recent backup for a client"),
430 _("Find the JobIds for a backup for a client before a specified time"),
431 _("Enter a list of directories to restore for found JobIds"),
432 _("Select full restore to a specified Job date"),
437 /* These keywords are handled in a for loop */
447 /* The keyword below are handled by individual arg lookups */
453 "bootstrap", /* 13 */
455 "strip_prefix", /* 15 */
456 "add_prefix", /* 16 */
457 "add_suffix", /* 17 */
458 "regexwhere", /* 18 */
459 "restoreclient", /* 19 */
466 for (i=1; i<ua->argc; i++) { /* loop through arguments */
467 bool found_kw = false;
468 for (j=0; kw[j]; j++) { /* loop through keywords */
469 if (strcasecmp(kw[j], ua->argk[i]) == 0) {
475 ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
478 /* Found keyword in kw[] list, process it */
481 if (!has_value(ua, i)) {
484 if (*rx->JobIds != 0) {
485 pm_strcat(rx->JobIds, ",");
487 pm_strcat(rx->JobIds, ua->argv[i]);
490 case 1: /* current */
492 * Note, we add one second here just to include any job
493 * that may have finished within the current second,
494 * which happens a lot in scripting small jobs.
496 bstrutime(date, sizeof(date), now);
500 if (have_date || !has_value(ua, i)) {
503 if (str_to_utime(ua->argv[i]) == 0) {
504 ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
507 bstrncpy(date, ua->argv[i], sizeof(date));
512 if (!has_value(ua, i)) {
516 bstrutime(date, sizeof(date), now);
518 if (!get_client_name(ua, rx)) {
521 pm_strcpy(ua->cmd, ua->argv[i]);
522 insert_one_file_or_dir(ua, rx, date, j==4);
526 bstrutime(date, sizeof(date), now);
528 if (!select_backups_before_date(ua, rx, date)) {
533 case 6: /* pool specified */
534 if (!has_value(ua, i)) {
537 rx->pool = (POOL *)GetResWithName(R_POOL, ua->argv[i]);
539 ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
542 if (!acl_access_ok(ua, Pool_ACL, ua->argv[i])) {
544 ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
548 case 7: /* all specified */
552 * All keywords 7 or greater are ignored or handled by a select prompt
560 ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
561 "to be restored. You will be presented several methods\n"
562 "of specifying the JobIds. Then you will be allowed to\n"
563 "select which files from those JobIds are to be restored.\n\n"));
566 /* If choice not already made above, prompt */
573 start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
574 for (int i=0; list[i]; i++) {
575 add_prompt(ua, list[i]);
578 switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
579 case -1: /* error or cancel */
581 case 0: /* list last 20 Jobs run */
582 if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
583 ua->error_msg(_("SQL query not authorized.\n"));
586 gui_save = ua->jcr->gui;
588 db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, prtit, ua, 1, HORZ_LIST);
589 ua->jcr->gui = gui_save;
592 case 1: /* list where a file is saved */
593 if (!get_client_name(ua, rx)) {
596 if (!get_cmd(ua, _("Enter Filename (no path):"))) {
599 len = strlen(ua->cmd);
600 fname = (char *)malloc(len * 2 + 1);
601 db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
602 Mmsg(rx->query, uar_file[db_type], rx->ClientName, fname);
604 gui_save = ua->jcr->gui;
606 db_list_sql_query(ua->jcr, ua->db, rx->query, prtit, ua, 1, HORZ_LIST);
607 ua->jcr->gui = gui_save;
610 case 2: /* enter a list of JobIds */
611 if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
614 pm_strcpy(rx->JobIds, ua->cmd);
616 case 3: /* Enter an SQL list command */
617 if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
618 ua->error_msg(_("SQL query not authorized.\n"));
621 if (!get_cmd(ua, _("Enter SQL list command: "))) {
624 gui_save = ua->jcr->gui;
626 db_list_sql_query(ua->jcr, ua->db, ua->cmd, prtit, ua, 1, HORZ_LIST);
627 ua->jcr->gui = gui_save;
630 case 4: /* Select the most recent backups */
632 bstrutime(date, sizeof(date), now);
634 if (!select_backups_before_date(ua, rx, date)) {
638 case 5: /* select backup at specified time */
640 if (!get_date(ua, date, sizeof(date))) {
644 if (!select_backups_before_date(ua, rx, date)) {
648 case 6: /* Enter files */
650 bstrutime(date, sizeof(date), now);
652 if (!get_client_name(ua, rx)) {
655 ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
656 "containing a list of file names with paths, and terminate\n"
657 "them with a blank line.\n"));
659 if (!get_cmd(ua, _("Enter full filename: "))) {
662 len = strlen(ua->cmd);
666 insert_one_file_or_dir(ua, rx, date, false);
669 case 7: /* enter files backed up before specified time */
671 if (!get_date(ua, date, sizeof(date))) {
675 if (!get_client_name(ua, rx)) {
678 ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
679 "containing a list of file names with paths, and terminate\n"
680 "them with a blank line.\n"));
682 if (!get_cmd(ua, _("Enter full filename: "))) {
685 len = strlen(ua->cmd);
689 insert_one_file_or_dir(ua, rx, date, false);
693 case 8: /* Find JobIds for current backup */
695 bstrutime(date, sizeof(date), now);
697 if (!select_backups_before_date(ua, rx, date)) {
703 case 9: /* Find JobIds for give date */
705 if (!get_date(ua, date, sizeof(date))) {
709 if (!select_backups_before_date(ua, rx, date)) {
715 case 10: /* Enter directories */
716 if (*rx->JobIds != 0) {
717 ua->send_msg(_("You have already selected the following JobIds: %s\n"),
719 } else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
720 if (*rx->JobIds != 0 && *ua->cmd) {
721 pm_strcat(rx->JobIds, ",");
723 pm_strcat(rx->JobIds, ua->cmd);
725 if (*rx->JobIds == 0 || *rx->JobIds == '.') {
726 return 0; /* nothing entered, return */
729 bstrutime(date, sizeof(date), now);
731 if (!get_client_name(ua, rx)) {
734 ua->send_msg(_("Enter full directory names or start the name\n"
735 "with a < to indicate it is a filename containing a list\n"
736 "of directories and terminate them with a blank line.\n"));
738 if (!get_cmd(ua, _("Enter directory name: "))) {
741 len = strlen(ua->cmd);
745 /* Add trailing slash to end of directory names */
746 if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
747 strcat(ua->cmd, "/");
749 insert_one_file_or_dir(ua, rx, date, true);
753 case 11: /* Choose a jobid and select jobs */
754 if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
755 !is_an_integer(ua->cmd))
760 memset(&jr, 0, sizeof(JOB_DBR));
761 jr.JobId = str_to_int64(ua->cmd);
762 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
763 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
764 ua->cmd, db_strerror(ua->db));
767 ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
769 jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
770 if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
773 pm_strcpy(rx->JobIds, jobids.list);
774 Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
776 case 12: /* Cancel or quit */
781 memset(&jr, 0, sizeof(JOB_DBR));
782 POOLMEM *JobIds = get_pool_memory(PM_FNAME);
786 * Find total number of files to be restored, and filter the JobId
787 * list to contain only ones permitted by the ACL conditions.
789 for (p=rx->JobIds; ; ) {
791 int stat = get_next_jobid_from_list(&p, &JobId);
793 ua->error_msg(_("Invalid JobId in list.\n"));
794 free_pool_memory(JobIds);
800 if (jr.JobId == JobId) {
801 continue; /* duplicate of last JobId */
803 memset(&jr, 0, sizeof(JOB_DBR));
805 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
806 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
807 edit_int64(JobId, ed1), db_strerror(ua->db));
808 free_pool_memory(JobIds);
811 if (!acl_access_ok(ua, Job_ACL, jr.Name)) {
812 ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
813 edit_int64(JobId, ed1), jr.Name);
817 pm_strcat(JobIds, ",");
819 pm_strcat(JobIds, edit_int64(JobId, ed1));
820 rx->TotalFiles += jr.JobFiles;
822 free_pool_memory(rx->JobIds);
823 rx->JobIds = JobIds; /* Set ACL filtered list */
824 if (*rx->JobIds == 0) {
825 ua->warning_msg(_("No Jobs selected.\n"));
829 if (strchr(rx->JobIds,',')) {
830 ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
832 ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
840 static int get_date(UAContext *ua, char *date, int date_len)
842 ua->send_msg(_("The restored files will the most current backup\n"
843 "BEFORE the date you specify below.\n\n"));
845 if (!get_cmd(ua, _("Enter date as YYYY-MM-DD HH:MM:SS :"))) {
848 if (str_to_utime(ua->cmd) != 0) {
851 ua->error_msg(_("Improper date format.\n"));
853 bstrncpy(date, ua->cmd, date_len);
858 * Insert a single file, or read a list of files from a file
860 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir)
870 if ((ffd = fopen(p, "rb")) == NULL) {
872 ua->error_msg(_("Cannot open file %s: ERR=%s\n"),
876 while (fgets(file, sizeof(file), ffd)) {
879 if (!insert_dir_into_findex_list(ua, rx, file, date)) {
880 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
883 if (!insert_file_into_findex_list(ua, rx, file, date)) {
884 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
892 insert_table_into_findex_list(ua, rx, p);
896 insert_dir_into_findex_list(ua, rx, ua->cmd, date);
898 insert_file_into_findex_list(ua, rx, ua->cmd, date);
905 * For a given file (path+filename), split into path and file, then
906 * lookup the most recent backup in the catalog to get the JobId
907 * and FileIndex, then insert them into the findex list.
909 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
912 strip_trailing_newline(file);
913 split_path_and_filename(ua, rx, file);
914 if (*rx->JobIds == 0) {
915 Mmsg(rx->query, uar_jobid_fileindex, date, rx->path, rx->fname,
918 Mmsg(rx->query, uar_jobids_fileindex, rx->JobIds, date,
919 rx->path, rx->fname, rx->ClientName);
922 /* Find and insert jobid and File Index */
923 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
924 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
925 rx->query, db_strerror(ua->db));
928 ua->error_msg(_("No database record found for: %s\n"), file);
929 // ua->error_msg("Query=%s\n", rx->query);
936 * For a given path lookup the most recent backup in the catalog
937 * to get the JobId and FileIndexes of all files in that directory.
939 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
942 strip_trailing_junk(dir);
943 if (*rx->JobIds == 0) {
944 ua->error_msg(_("No JobId specified cannot continue.\n"));
947 Mmsg(rx->query, uar_jobid_fileindex_from_dir[db_type], rx->JobIds, dir, rx->ClientName);
950 /* Find and insert jobid and File Index */
951 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
952 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
953 rx->query, db_strerror(ua->db));
956 ua->error_msg(_("No database record found for: %s\n"), dir);
963 * Get the JobId and FileIndexes of all files in the specified table
965 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table)
967 strip_trailing_junk(table);
968 Mmsg(rx->query, uar_jobid_fileindex_from_table, table);
971 /* Find and insert jobid and File Index */
972 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
973 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
974 rx->query, db_strerror(ua->db));
977 ua->error_msg(_("No table found: %s\n"), table);
983 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
987 /* Find path without the filename.
988 * I.e. everything after the last / is a "filename".
989 * OK, maybe it is a directory name, but we treat it like
990 * a filename. If we don't find a / then the whole name
991 * must be a path name (e.g. c:).
993 for (p=f=name; *p; p++) {
994 if (IsPathSeparator(*p)) {
995 f = p; /* set pos of last slash */
998 if (IsPathSeparator(*f)) { /* did we find a slash? */
999 f++; /* yes, point to filename */
1000 } else { /* no, whole thing must be path name */
1004 /* If filename doesn't exist (i.e. root directory), we
1005 * simply create a blank name consisting of a single
1006 * space. This makes handling zero length filenames
1011 rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
1012 db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
1020 rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
1021 db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
1027 Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
1030 static bool ask_for_fileregex(UAContext *ua, RESTORE_CTX *rx)
1032 if (find_arg(ua, NT_("all")) >= 0) { /* if user enters all on command line */
1033 return true; /* select everything */
1035 ua->send_msg(_("\n\nFor one or more of the JobIds selected, no files were found,\n"
1036 "so file selection is not possible.\n"
1037 "Most likely your retention policy pruned the files.\n"));
1038 if (get_yesno(ua, _("\nDo you want to restore all the files? (yes|no): "))) {
1039 if (ua->pint32_val == 1)
1041 while (get_cmd(ua, _("\nRegexp matching files to restore? (empty to abort): "))) {
1042 if (ua->cmd[0] == '\0') {
1045 regex_t *fileregex_re = NULL;
1047 char errmsg[500] = "";
1049 fileregex_re = (regex_t *)bmalloc(sizeof(regex_t));
1050 rc = regcomp(fileregex_re, ua->cmd, REG_EXTENDED|REG_NOSUB);
1052 regerror(rc, fileregex_re, errmsg, sizeof(errmsg));
1054 regfree(fileregex_re);
1057 ua->send_msg(_("Regex compile error: %s\n"), errmsg);
1059 rx->bsr->fileregex = bstrdup(ua->cmd);
1068 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx)
1071 JobId_t JobId, last_JobId;
1076 memset(&tree, 0, sizeof(TREE_CTX));
1078 * Build the directory tree containing JobIds user selected
1080 tree.root = new_tree(rx->TotalFiles);
1085 * For display purposes, the same JobId, with different volumes may
1086 * appear more than once, however, we only insert it once.
1089 tree.FileEstimate = 0;
1090 if (get_next_jobid_from_list(&p, &JobId) > 0) {
1091 /* Use first JobId as estimate of the number of files to restore */
1092 Mmsg(rx->query, uar_count_files, edit_int64(JobId, ed1));
1093 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1094 ua->error_msg("%s\n", db_strerror(ua->db));
1097 /* Add about 25% more than this job for over estimate */
1098 tree.FileEstimate = rx->JobId + (rx->JobId >> 2);
1099 tree.DeltaCount = rx->JobId/50; /* print 50 ticks */
1103 ua->info_msg(_("\nBuilding directory tree for JobId(s) %s ... "),
1106 #define new_get_file_list
1107 #ifdef new_get_file_list
1108 if (!db_get_file_list(ua->jcr, ua->db, rx->JobIds, insert_tree_handler, (void *)&tree)) {
1109 ua->error_msg("%s", db_strerror(ua->db));
1111 if (*rx->BaseJobIds) {
1112 pm_strcat(rx->JobIds, ",");
1113 pm_strcat(rx->JobIds, rx->BaseJobIds);
1116 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1119 if (JobId == last_JobId) {
1120 continue; /* eliminate duplicate JobIds */
1124 * Find files for this JobId and insert them in the tree
1126 Mmsg(rx->query, uar_sel_files, edit_int64(JobId, ed1));
1127 if (!db_sql_query(ua->db, rx->query, insert_tree_handler, (void *)&tree)) {
1128 ua->error_msg("%s", db_strerror(ua->db));
1133 * Look at the first JobId on the list (presumably the oldest) and
1134 * if it is marked purged, don't do the manual selection because
1135 * the Job was pruned, so the tree is incomplete.
1137 if (tree.FileCount != 0) {
1138 /* Find out if any Job is purged */
1139 Mmsg(rx->query, "SELECT SUM(PurgedFiles) FROM Job WHERE JobId IN (%s)", rx->JobIds);
1140 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1141 ua->error_msg("%s\n", db_strerror(ua->db));
1143 /* rx->JobId is the PurgedFiles flag */
1144 if (rx->found && rx->JobId > 0) {
1145 tree.FileCount = 0; /* set count to zero, no tree selection */
1148 if (tree.FileCount == 0) {
1149 OK = ask_for_fileregex(ua, rx);
1152 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1153 if (JobId == last_JobId) {
1154 continue; /* eliminate duplicate JobIds */
1156 add_findex_all(rx->bsr, JobId);
1162 ua->info_msg(_("\n%s files inserted into the tree and marked for extraction.\n"),
1163 edit_uint64_with_commas(tree.FileCount, ec1));
1165 ua->info_msg(_("\n%s files inserted into the tree.\n"),
1166 edit_uint64_with_commas(tree.FileCount, ec1));
1169 if (find_arg(ua, NT_("done")) < 0) {
1170 /* Let the user interact in selecting which files to restore */
1171 OK = user_select_files_from_tree(&tree);
1175 * Walk down through the tree finding all files marked to be
1176 * extracted making a bootstrap file.
1179 for (TREE_NODE *node=first_tree_node(tree.root); node; node=next_tree_node(node)) {
1180 Dmsg2(400, "FI=%d node=0x%x\n", node->FileIndex, node);
1181 if (node->extract || node->extract_dir) {
1182 Dmsg3(400, "JobId=%lld type=%d FI=%d\n", (uint64_t)node->JobId, node->type, node->FileIndex);
1183 add_findex(rx->bsr, node->JobId, node->FileIndex);
1184 if (node->extract && node->type != TN_NEWDIR) {
1185 rx->selected_files++; /* count only saved files */
1192 free_tree(tree.root); /* free the directory tree */
1198 * This routine is used to get the current backup or a backup
1199 * before the specified date.
1201 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date)
1206 char fileset_name[MAX_NAME_LENGTH];
1207 char ed1[50], ed2[50];
1208 char pool_select[MAX_NAME_LENGTH];
1211 /* Create temp tables */
1212 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1213 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1214 if (!db_sql_query(ua->db, uar_create_temp[db_type], NULL, NULL)) {
1215 ua->error_msg("%s\n", db_strerror(ua->db));
1217 if (!db_sql_query(ua->db, uar_create_temp1[db_type], NULL, NULL)) {
1218 ua->error_msg("%s\n", db_strerror(ua->db));
1221 * Select Client from the Catalog
1223 memset(&cr, 0, sizeof(cr));
1224 if (!get_client_dbr(ua, &cr)) {
1227 bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
1232 memset(&fsr, 0, sizeof(fsr));
1233 i = find_arg_with_value(ua, "FileSet");
1235 bstrncpy(fsr.FileSet, ua->argv[i], sizeof(fsr.FileSet));
1236 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1237 ua->error_msg(_("Error getting FileSet \"%s\": ERR=%s\n"), fsr.FileSet,
1238 db_strerror(ua->db));
1242 if (i < 0) { /* fileset not found */
1243 edit_int64(cr.ClientId, ed1);
1244 Mmsg(rx->query, uar_sel_fileset, ed1, ed1);
1245 start_prompt(ua, _("The defined FileSet resources are:\n"));
1246 if (!db_sql_query(ua->db, rx->query, fileset_handler, (void *)ua)) {
1247 ua->error_msg("%s\n", db_strerror(ua->db));
1249 if (do_prompt(ua, _("FileSet"), _("Select FileSet resource"),
1250 fileset_name, sizeof(fileset_name)) < 0) {
1251 ua->error_msg(_("No FileSet found for client \"%s\".\n"), cr.Name);
1255 bstrncpy(fsr.FileSet, fileset_name, sizeof(fsr.FileSet));
1256 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1257 ua->warning_msg(_("Error getting FileSet record: %s\n"), db_strerror(ua->db));
1258 ua->send_msg(_("This probably means you modified the FileSet.\n"
1259 "Continuing anyway.\n"));
1263 /* If Pool specified, add PoolId specification */
1267 memset(&pr, 0, sizeof(pr));
1268 bstrncpy(pr.Name, rx->pool->name(), sizeof(pr.Name));
1269 if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
1270 bsnprintf(pool_select, sizeof(pool_select), "AND Media.PoolId=%s ",
1271 edit_int64(pr.PoolId, ed1));
1273 ua->warning_msg(_("Pool \"%s\" not found, using any pool.\n"), pr.Name);
1277 /* Find JobId of last Full backup for this client, fileset */
1278 edit_int64(cr.ClientId, ed1);
1279 Mmsg(rx->query, uar_last_full, ed1, ed1, date, fsr.FileSet,
1281 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1282 ua->error_msg("%s\n", db_strerror(ua->db));
1286 /* Find all Volumes used by that JobId */
1287 if (!db_sql_query(ua->db, uar_full, NULL, NULL)) {
1288 ua->error_msg("%s\n", db_strerror(ua->db));
1292 /* Note, this is needed because I don't seem to get the callback
1293 * from the call just above.
1296 if (!db_sql_query(ua->db, uar_sel_all_temp1, last_full_handler, (void *)rx)) {
1297 ua->warning_msg("%s\n", db_strerror(ua->db));
1299 if (rx->JobTDate == 0) {
1300 ua->error_msg(_("No Full backup before %s found.\n"), date);
1304 /* Now find most recent Differental Job after Full save, if any */
1305 Mmsg(rx->query, uar_dif, edit_uint64(rx->JobTDate, ed1), date,
1306 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1307 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1308 ua->warning_msg("%s\n", db_strerror(ua->db));
1310 /* Now update JobTDate to look into Differental, if any */
1312 if (!db_sql_query(ua->db, uar_sel_all_temp, last_full_handler, (void *)rx)) {
1313 ua->warning_msg("%s\n", db_strerror(ua->db));
1315 if (rx->JobTDate == 0) {
1316 ua->error_msg(_("No Full backup before %s found.\n"), date);
1320 /* Now find all Incremental Jobs after Full/dif save */
1321 Mmsg(rx->query, uar_inc, edit_uint64(rx->JobTDate, ed1), date,
1322 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1323 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1324 ua->warning_msg("%s\n", db_strerror(ua->db));
1327 /* Get the JobIds from that list */
1328 rx->last_jobid[0] = rx->JobIds[0] = 0;
1330 if (!db_sql_query(ua->db, uar_sel_jobid_temp, jobid_handler, (void *)rx)) {
1331 ua->warning_msg("%s\n", db_strerror(ua->db));
1334 if (rx->JobIds[0] != 0) {
1335 if (find_arg(ua, NT_("copies")) > 0) {
1336 /* Display a list of all copies */
1337 db_list_copies_records(ua->jcr, ua->db, 0, rx->JobIds,
1338 prtit, ua, HORZ_LIST);
1340 /* Display a list of Jobs selected for this restore */
1341 db_list_sql_query(ua->jcr, ua->db, uar_list_temp, prtit, ua, 1,HORZ_LIST);
1345 ua->warning_msg(_("No jobs found.\n"));
1349 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1350 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1354 static int restore_count_handler(void *ctx, int num_fields, char **row)
1356 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1357 rx->JobId = str_to_int64(row[0]);
1363 * Callback handler to get JobId and FileIndex for files
1364 * can insert more than one depending on the caller.
1366 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row)
1368 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1370 Dmsg2(200, "JobId=%s FileIndex=%s\n", row[0], row[1]);
1371 rx->JobId = str_to_int64(row[0]);
1372 add_findex(rx->bsr, rx->JobId, str_to_int64(row[1]));
1374 rx->selected_files++;
1379 * Callback handler make list of JobIds
1381 static int jobid_handler(void *ctx, int num_fields, char **row)
1383 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1385 if (strcmp(rx->last_jobid, row[0]) == 0) {
1386 return 0; /* duplicate id */
1388 bstrncpy(rx->last_jobid, row[0], sizeof(rx->last_jobid));
1389 if (rx->JobIds[0] != 0) {
1390 pm_strcat(rx->JobIds, ",");
1392 pm_strcat(rx->JobIds, row[0]);
1398 * Callback handler to pickup last Full backup JobTDate
1400 static int last_full_handler(void *ctx, int num_fields, char **row)
1402 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1404 rx->JobTDate = str_to_int64(row[1]);
1409 * Callback handler build FileSet name prompt list
1411 static int fileset_handler(void *ctx, int num_fields, char **row)
1413 /* row[0] = FileSet (name) */
1415 add_prompt((UAContext *)ctx, row[0]);
1421 * Free names in the list
1423 static void free_name_list(NAME_LIST *name_list)
1425 for (int i=0; i < name_list->num_ids; i++) {
1426 free(name_list->name[i]);
1428 bfree_and_null(name_list->name);
1429 name_list->max_ids = 0;
1430 name_list->num_ids = 0;
1433 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType)
1438 Dmsg1(200, "Already have store=%s\n", rx.store->name());
1442 * Try looking up Storage by name
1445 foreach_res(store, R_STORAGE) {
1446 if (strcmp(Storage, store->name()) == 0) {
1447 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1456 /* Check if an explicit storage resource is given */
1458 int i = find_arg_with_value(ua, "storage");
1460 store = (STORE *)GetResWithName(R_STORAGE, ua->argv[i]);
1461 if (store && !acl_access_ok(ua, Storage_ACL, store->name())) {
1465 if (store && (store != rx.store)) {
1466 ua->info_msg(_("Warning default storage overridden by \"%s\" on command line.\n"),
1469 Dmsg1(200, "Set store=%s\n", rx.store->name());
1474 /* If no storage resource, try to find one from MediaType */
1477 foreach_res(store, R_STORAGE) {
1478 if (strcmp(MediaType, store->media_type) == 0) {
1479 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1481 Dmsg1(200, "Set store=%s\n", rx.store->name());
1482 ua->warning_msg(_("Storage \"%s\" not found, using Storage \"%s\" from MediaType \"%s\".\n"),
1483 Storage, store->name(), MediaType);
1490 ua->warning_msg(_("\nUnable to find Storage resource for\n"
1491 "MediaType \"%s\", needed by the Jobs you selected.\n"), MediaType);
1494 /* Take command line arg, or ask user if none */
1495 rx.store = get_storage_resource(ua, false /* don't use default */);
1497 Dmsg1(200, "Set store=%s\n", rx.store->name());