2 Bacula® - The Network Backup Solution
4 Copyright (C) 2002-2010 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 three of the GNU Affero 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 Affero 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
45 /* Imported functions */
46 extern void print_bsr(UAContext *ua, RBSR *bsr);
50 /* Forward referenced functions */
51 static int last_full_handler(void *ctx, int num_fields, char **row);
52 static int jobid_handler(void *ctx, int num_fields, char **row);
53 static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx);
54 static int fileset_handler(void *ctx, int num_fields, char **row);
55 static void free_name_list(NAME_LIST *name_list);
56 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date);
57 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx);
58 static void free_rx(RESTORE_CTX *rx);
59 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *fname);
60 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row);
61 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
63 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
65 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir);
66 static int get_client_name(UAContext *ua, RESTORE_CTX *rx);
67 static int get_restore_client_name(UAContext *ua, RESTORE_CTX &rx);
68 static bool get_date(UAContext *ua, char *date, int date_len);
69 static int restore_count_handler(void *ctx, int num_fields, char **row);
70 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table);
71 static void get_and_display_basejobs(UAContext *ua, RESTORE_CTX *rx);
77 int restore_cmd(UAContext *ua, const char *cmd)
79 RESTORE_CTX rx; /* restore context */
84 char *escaped_bsr_name = NULL;
85 char *escaped_where_name = NULL;
86 char *strip_prefix, *add_prefix, *add_suffix, *regexp;
87 strip_prefix = add_prefix = add_suffix = regexp = NULL;
89 memset(&rx, 0, sizeof(rx));
90 rx.path = get_pool_memory(PM_FNAME);
91 rx.fname = get_pool_memory(PM_FNAME);
92 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, "comment");
100 rx.comment = ua->argv[i];
101 if (!is_comment_legal(ua, rx.comment)) {
106 i = find_arg_with_value(ua, "where");
108 rx.where = ua->argv[i];
111 i = find_arg_with_value(ua, "strip_prefix");
113 strip_prefix = ua->argv[i];
116 i = find_arg_with_value(ua, "add_prefix");
118 add_prefix = ua->argv[i];
121 i = find_arg_with_value(ua, "add_suffix");
123 add_suffix = ua->argv[i];
126 i = find_arg_with_value(ua, "regexwhere");
128 rx.RegexWhere = ua->argv[i];
131 if (strip_prefix || add_suffix || add_prefix) {
132 int len = bregexp_get_build_where_size(strip_prefix, add_prefix, add_suffix);
133 regexp = (char *)bmalloc(len * sizeof(char));
135 bregexp_build_where(regexp, len, strip_prefix, add_prefix, add_suffix);
136 rx.RegexWhere = regexp;
139 /* TODO: add acl for regexwhere ? */
142 if (!acl_access_ok(ua, Where_ACL, rx.RegexWhere)) {
143 ua->error_msg(_("\"RegexWhere\" specification not authorized.\n"));
149 if (!acl_access_ok(ua, Where_ACL, rx.where)) {
150 ua->error_msg(_("\"where\" specification not authorized.\n"));
155 if (!open_client_db(ua)) {
159 /* Ensure there is at least one Restore Job */
161 foreach_res(job, R_JOB) {
162 if (job->JobType == JT_RESTORE) {
163 if (!rx.restore_job) {
164 rx.restore_job = job;
170 if (!rx.restore_jobs) {
172 "No Restore Job Resource found in bacula-dir.conf.\n"
173 "You must create at least one before running this command.\n"));
178 * Request user to select JobIds or files by various different methods
179 * last 20 jobs, where File saved, most recent backup, ...
180 * In the end, a list of files are pumped into
183 switch (user_select_jobids_or_files(ua, &rx)) {
186 case 1: /* selected by jobid */
187 get_and_display_basejobs(ua, &rx);
188 if (!build_directory_tree(ua, &rx)) {
189 ua->send_msg(_("Restore not done.\n"));
193 case 2: /* selected by filename, no tree needed */
199 if (!complete_bsr(ua, rx.bsr)) { /* find Vol, SessId, SessTime from JobIds */
200 ua->error_msg(_("Unable to construct a valid BSR. Cannot continue.\n"));
203 if (!(rx.selected_files = write_bsr_file(ua, rx))) {
204 ua->warning_msg(_("No files selected to be restored.\n"));
207 display_bsr_info(ua, rx); /* display vols needed, etc */
209 if (rx.selected_files==1) {
210 ua->info_msg(_("\n1 file selected to be restored.\n\n"));
212 ua->info_msg(_("\n%s files selected to be restored.\n\n"),
213 edit_uint64_with_commas(rx.selected_files, ed1));
216 ua->warning_msg(_("No files selected to be restored.\n"));
220 if (rx.restore_jobs == 1) {
221 job = rx.restore_job;
223 job = select_restore_job_resource(ua);
229 get_client_name(ua, &rx);
230 if (!rx.ClientName) {
231 ua->error_msg(_("No Client resource found!\n"));
234 get_restore_client_name(ua, rx);
236 escaped_bsr_name = escape_filename(jcr->RestoreBootstrap);
239 "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
240 " bootstrap=\"%s\" files=%u catalog=\"%s\"",
241 job->name(), rx.ClientName, rx.RestoreClientName,
242 rx.store?rx.store->name():"",
243 escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
244 rx.selected_files, ua->catalog->name());
246 /* Build run command */
249 escaped_where_name = escape_filename(rx.RegexWhere);
250 Mmsg(buf, " regexwhere=\"%s\"",
251 escaped_where_name ? escaped_where_name : rx.RegexWhere);
253 } else if (rx.where) {
254 escaped_where_name = escape_filename(rx.where);
255 Mmsg(buf," where=\"%s\"",
256 escaped_where_name ? escaped_where_name : rx.where);
258 pm_strcat(ua->cmd, buf);
261 Mmsg(buf, " comment=\"%s\"", rx.comment);
262 pm_strcat(ua->cmd, buf);
265 if (escaped_bsr_name != NULL) {
266 bfree(escaped_bsr_name);
269 if (escaped_where_name != NULL) {
270 bfree(escaped_where_name);
277 if (find_arg(ua, NT_("yes")) > 0) {
278 pm_strcat(ua->cmd, " yes"); /* pass it on to the run command */
280 Dmsg1(200, "Submitting: %s\n", ua->cmd);
281 /* Transfer jobids to jcr to for picking up restore objects */
282 jcr->JobIds = rx.JobIds;
285 run_cmd(ua, ua->cmd);
290 if (escaped_bsr_name != NULL) {
291 bfree(escaped_bsr_name);
294 if (escaped_where_name != NULL) {
295 bfree(escaped_where_name);
308 * Fill the rx->BaseJobIds and display the list
310 static void get_and_display_basejobs(UAContext *ua, RESTORE_CTX *rx)
314 if (!db_get_used_base_jobids(ua->jcr, ua->db, rx->JobIds, &jobids)) {
315 ua->warning_msg("%s", db_strerror(ua->db));
320 Mmsg(q, uar_print_jobs, jobids.list);
321 ua->send_msg(_("The restore will use the following job(s) as Base\n"));
322 db_list_sql_query(ua->jcr, ua->db, q.c_str(), prtit, ua, 1, HORZ_LIST);
324 pm_strcpy(rx->BaseJobIds, jobids.list);
327 static void free_rx(RESTORE_CTX *rx)
331 free_and_null_pool_memory(rx->JobIds);
332 free_and_null_pool_memory(rx->BaseJobIds);
333 free_and_null_pool_memory(rx->fname);
334 free_and_null_pool_memory(rx->path);
335 free_and_null_pool_memory(rx->query);
336 free_name_list(&rx->name_list);
339 static bool has_value(UAContext *ua, int i)
342 ua->error_msg(_("Missing value for keyword: %s\n"), ua->argk[i]);
349 * This gets the client name from which the backup was made
351 static int get_client_name(UAContext *ua, RESTORE_CTX *rx)
353 /* If no client name specified yet, get it now */
354 if (!rx->ClientName[0]) {
356 /* try command line argument */
357 int i = find_arg_with_value(ua, NT_("client"));
359 i = find_arg_with_value(ua, NT_("backupclient"));
362 if (!has_value(ua, i)) {
365 bstrncpy(rx->ClientName, ua->argv[i], sizeof(rx->ClientName));
368 memset(&cr, 0, sizeof(cr));
369 if (!get_client_dbr(ua, &cr)) {
372 bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
378 * This is where we pick up a client name to restore to.
380 static int get_restore_client_name(UAContext *ua, RESTORE_CTX &rx)
382 /* Start with same name as backup client */
383 bstrncpy(rx.RestoreClientName, rx.ClientName, sizeof(rx.RestoreClientName));
385 /* try command line argument */
386 int i = find_arg_with_value(ua, NT_("restoreclient"));
388 if (!has_value(ua, i)) {
391 bstrncpy(rx.RestoreClientName, ua->argv[i], sizeof(rx.RestoreClientName));
400 * The first step in the restore process is for the user to
401 * select a list of JobIds from which he will subsequently
402 * select which files are to be restored.
404 * Returns: 2 if filename list made
405 * 1 if jobid list made
408 static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
411 char date[MAX_TIME_LENGTH];
412 bool have_date = false;
413 /* Include current second if using current time */
414 utime_t now = time(NULL) + 1;
416 JOB_DBR jr = { (JobId_t)-1 };
419 const char *list[] = {
420 _("List last 20 Jobs run"),
421 _("List Jobs where a given File is saved"),
422 _("Enter list of comma separated JobIds to select"),
423 _("Enter SQL list command"),
424 _("Select the most recent backup for a client"),
425 _("Select backup for a client before a specified time"),
426 _("Enter a list of files to restore"),
427 _("Enter a list of files to restore before a specified time"),
428 _("Find the JobIds of the most recent backup for a client"),
429 _("Find the JobIds for a backup for a client before a specified time"),
430 _("Enter a list of directories to restore for found JobIds"),
431 _("Select full restore to a specified Job date"),
436 /* These keywords are handled in a for loop */
446 /* The keyword below are handled by individual arg lookups */
452 "bootstrap", /* 13 */
454 "strip_prefix", /* 15 */
455 "add_prefix", /* 16 */
456 "add_suffix", /* 17 */
457 "regexwhere", /* 18 */
458 "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 == '.') {
727 return 0; /* nothing entered, return */
730 bstrutime(date, sizeof(date), now);
732 if (!get_client_name(ua, rx)) {
735 ua->send_msg(_("Enter full directory names or start the name\n"
736 "with a < to indicate it is a filename containing a list\n"
737 "of directories and terminate them with a blank line.\n"));
739 if (!get_cmd(ua, _("Enter directory name: "))) {
742 len = strlen(ua->cmd);
746 /* Add trailing slash to end of directory names */
747 if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
748 strcat(ua->cmd, "/");
750 insert_one_file_or_dir(ua, rx, date, true);
754 case 11: /* Choose a jobid and select jobs */
755 if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
756 !is_an_integer(ua->cmd))
761 memset(&jr, 0, sizeof(JOB_DBR));
762 jr.JobId = str_to_int64(ua->cmd);
763 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
764 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
765 ua->cmd, db_strerror(ua->db));
768 ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
770 jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
771 if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
774 pm_strcpy(rx->JobIds, jobids.list);
775 Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
777 case 12: /* Cancel or quit */
782 memset(&jr, 0, sizeof(JOB_DBR));
783 POOLMEM *JobIds = get_pool_memory(PM_FNAME);
787 * Find total number of files to be restored, and filter the JobId
788 * list to contain only ones permitted by the ACL conditions.
790 for (p=rx->JobIds; ; ) {
792 int stat = get_next_jobid_from_list(&p, &JobId);
794 ua->error_msg(_("Invalid JobId in list.\n"));
795 free_pool_memory(JobIds);
801 if (jr.JobId == JobId) {
802 continue; /* duplicate of last JobId */
804 memset(&jr, 0, sizeof(JOB_DBR));
806 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
807 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
808 edit_int64(JobId, ed1), db_strerror(ua->db));
809 free_pool_memory(JobIds);
812 if (!acl_access_ok(ua, Job_ACL, jr.Name)) {
813 ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
814 edit_int64(JobId, ed1), jr.Name);
818 pm_strcat(JobIds, ",");
820 pm_strcat(JobIds, edit_int64(JobId, ed1));
821 rx->TotalFiles += jr.JobFiles;
823 free_pool_memory(rx->JobIds);
824 rx->JobIds = JobIds; /* Set ACL filtered list */
825 if (*rx->JobIds == 0) {
826 ua->warning_msg(_("No Jobs selected.\n"));
830 if (strchr(rx->JobIds,',')) {
831 ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
833 ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
841 static bool get_date(UAContext *ua, char *date, int date_len)
843 ua->send_msg(_("The restored files will the most current backup\n"
844 "BEFORE the date you specify below.\n\n"));
846 if (!get_cmd(ua, _("Enter date as YYYY-MM-DD HH:MM:SS :"))) {
849 if (str_to_utime(ua->cmd) != 0) {
852 ua->error_msg(_("Improper date format.\n"));
854 bstrncpy(date, ua->cmd, date_len);
859 * Insert a single file, or read a list of files from a file
861 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir)
871 if ((ffd = fopen(p, "rb")) == NULL) {
873 ua->error_msg(_("Cannot open file %s: ERR=%s\n"),
877 while (fgets(file, sizeof(file), ffd)) {
880 if (!insert_dir_into_findex_list(ua, rx, file, date)) {
881 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
884 if (!insert_file_into_findex_list(ua, rx, file, date)) {
885 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
893 insert_table_into_findex_list(ua, rx, p);
897 insert_dir_into_findex_list(ua, rx, ua->cmd, date);
899 insert_file_into_findex_list(ua, rx, ua->cmd, date);
906 * For a given file (path+filename), split into path and file, then
907 * lookup the most recent backup in the catalog to get the JobId
908 * and FileIndex, then insert them into the findex list.
910 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
913 strip_trailing_newline(file);
914 split_path_and_filename(ua, rx, file);
915 if (*rx->JobIds == 0) {
916 Mmsg(rx->query, uar_jobid_fileindex, date, rx->path, rx->fname,
919 Mmsg(rx->query, uar_jobids_fileindex, rx->JobIds, date,
920 rx->path, rx->fname, rx->ClientName);
923 /* Find and insert jobid and File Index */
924 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
925 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
926 rx->query, db_strerror(ua->db));
929 ua->error_msg(_("No database record found for: %s\n"), file);
930 // ua->error_msg("Query=%s\n", rx->query);
937 * For a given path lookup the most recent backup in the catalog
938 * to get the JobId and FileIndexes of all files in that directory.
940 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
943 strip_trailing_junk(dir);
944 if (*rx->JobIds == 0) {
945 ua->error_msg(_("No JobId specified cannot continue.\n"));
948 Mmsg(rx->query, uar_jobid_fileindex_from_dir[db_type], rx->JobIds, dir, rx->ClientName);
951 /* Find and insert jobid and File Index */
952 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
953 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
954 rx->query, db_strerror(ua->db));
957 ua->error_msg(_("No database record found for: %s\n"), dir);
964 * Get the JobId and FileIndexes of all files in the specified table
966 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table)
968 strip_trailing_junk(table);
969 Mmsg(rx->query, uar_jobid_fileindex_from_table, table);
972 /* Find and insert jobid and File Index */
973 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
974 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
975 rx->query, db_strerror(ua->db));
978 ua->error_msg(_("No table found: %s\n"), table);
984 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
988 /* Find path without the filename.
989 * I.e. everything after the last / is a "filename".
990 * OK, maybe it is a directory name, but we treat it like
991 * a filename. If we don't find a / then the whole name
992 * must be a path name (e.g. c:).
994 for (p=f=name; *p; p++) {
995 if (IsPathSeparator(*p)) {
996 f = p; /* set pos of last slash */
999 if (IsPathSeparator(*f)) { /* did we find a slash? */
1000 f++; /* yes, point to filename */
1001 } else { /* no, whole thing must be path name */
1005 /* If filename doesn't exist (i.e. root directory), we
1006 * simply create a blank name consisting of a single
1007 * space. This makes handling zero length filenames
1012 rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
1013 db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
1021 rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
1022 db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
1028 Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
1031 static bool ask_for_fileregex(UAContext *ua, RESTORE_CTX *rx)
1033 if (find_arg(ua, NT_("all")) >= 0) { /* if user enters all on command line */
1034 return true; /* select everything */
1036 ua->send_msg(_("\n\nFor one or more of the JobIds selected, no files were found,\n"
1037 "so file selection is not possible.\n"
1038 "Most likely your retention policy pruned the files.\n"));
1039 if (get_yesno(ua, _("\nDo you want to restore all the files? (yes|no): "))) {
1040 if (ua->pint32_val == 1)
1042 while (get_cmd(ua, _("\nRegexp matching files to restore? (empty to abort): "))) {
1043 if (ua->cmd[0] == '\0') {
1046 regex_t *fileregex_re = NULL;
1048 char errmsg[500] = "";
1050 fileregex_re = (regex_t *)bmalloc(sizeof(regex_t));
1051 rc = regcomp(fileregex_re, ua->cmd, REG_EXTENDED|REG_NOSUB);
1053 regerror(rc, fileregex_re, errmsg, sizeof(errmsg));
1055 regfree(fileregex_re);
1058 ua->send_msg(_("Regex compile error: %s\n"), errmsg);
1060 rx->bsr->fileregex = bstrdup(ua->cmd);
1069 /* Walk on the delta_list of a TREE_NODE item and insert all parts
1070 * TODO: Optimize for bootstrap creation, remove recursion
1071 * 6 -> 5 -> 4 -> 3 -> 2 -> 1 -> 0
1073 * 0, 1, 2, 3, 4, 5, 6
1075 static void add_delta_list_findex(RESTORE_CTX *rx, struct delta_list *lst)
1081 add_delta_list_findex(rx, lst->next);
1083 add_findex(rx->bsr, lst->JobId, lst->FileIndex);
1086 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx)
1089 JobId_t JobId, last_JobId;
1094 memset(&tree, 0, sizeof(TREE_CTX));
1096 * Build the directory tree containing JobIds user selected
1098 tree.root = new_tree(rx->TotalFiles);
1103 * For display purposes, the same JobId, with different volumes may
1104 * appear more than once, however, we only insert it once.
1107 tree.FileEstimate = 0;
1108 if (get_next_jobid_from_list(&p, &JobId) > 0) {
1109 /* Use first JobId as estimate of the number of files to restore */
1110 Mmsg(rx->query, uar_count_files, edit_int64(JobId, ed1));
1111 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1112 ua->error_msg("%s\n", db_strerror(ua->db));
1115 /* Add about 25% more than this job for over estimate */
1116 tree.FileEstimate = rx->JobId + (rx->JobId >> 2);
1117 tree.DeltaCount = rx->JobId/50; /* print 50 ticks */
1121 ua->info_msg(_("\nBuilding directory tree for JobId(s) %s ... "),
1124 #define new_get_file_list
1125 #ifdef new_get_file_list
1126 if (!db_get_file_list(ua->jcr, ua->db,
1127 rx->JobIds, false /* do not use md5 */,
1128 true /* get delta */,
1129 insert_tree_handler, (void *)&tree))
1131 ua->error_msg("%s", db_strerror(ua->db));
1133 if (*rx->BaseJobIds) {
1134 pm_strcat(rx->JobIds, ",");
1135 pm_strcat(rx->JobIds, rx->BaseJobIds);
1138 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1141 if (JobId == last_JobId) {
1142 continue; /* eliminate duplicate JobIds */
1146 * Find files for this JobId and insert them in the tree
1148 Mmsg(rx->query, uar_sel_files, edit_int64(JobId, ed1));
1149 if (!db_sql_query(ua->db, rx->query, insert_tree_handler, (void *)&tree)) {
1150 ua->error_msg("%s", db_strerror(ua->db));
1155 * Look at the first JobId on the list (presumably the oldest) and
1156 * if it is marked purged, don't do the manual selection because
1157 * the Job was pruned, so the tree is incomplete.
1159 if (tree.FileCount != 0) {
1160 /* Find out if any Job is purged */
1161 Mmsg(rx->query, "SELECT SUM(PurgedFiles) FROM Job WHERE JobId IN (%s)", rx->JobIds);
1162 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1163 ua->error_msg("%s\n", db_strerror(ua->db));
1165 /* rx->JobId is the PurgedFiles flag */
1166 if (rx->found && rx->JobId > 0) {
1167 tree.FileCount = 0; /* set count to zero, no tree selection */
1170 if (tree.FileCount == 0) {
1171 OK = ask_for_fileregex(ua, rx);
1174 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1175 if (JobId == last_JobId) {
1176 continue; /* eliminate duplicate JobIds */
1178 add_findex_all(rx->bsr, JobId);
1184 ua->info_msg(_("\n%s files inserted into the tree and marked for extraction.\n"),
1185 edit_uint64_with_commas(tree.FileCount, ec1));
1187 ua->info_msg(_("\n%s files inserted into the tree.\n"),
1188 edit_uint64_with_commas(tree.FileCount, ec1));
1191 if (find_arg(ua, NT_("done")) < 0) {
1192 /* Let the user interact in selecting which files to restore */
1193 OK = user_select_files_from_tree(&tree);
1197 * Walk down through the tree finding all files marked to be
1198 * extracted making a bootstrap file.
1201 for (TREE_NODE *node=first_tree_node(tree.root); node; node=next_tree_node(node)) {
1202 Dmsg2(400, "FI=%d node=0x%x\n", node->FileIndex, node);
1203 if (node->extract || node->extract_dir) {
1204 Dmsg3(400, "JobId=%lld type=%d FI=%d\n", (uint64_t)node->JobId, node->type, node->FileIndex);
1205 /* TODO: optimize bsr insertion when jobid are non sorted */
1206 add_delta_list_findex(rx, node->delta_list);
1207 add_findex(rx->bsr, node->JobId, node->FileIndex);
1208 if (node->extract && node->type != TN_NEWDIR) {
1209 rx->selected_files++; /* count only saved files */
1216 free_tree(tree.root); /* free the directory tree */
1222 * This routine is used to get the current backup or a backup
1223 * before the specified date.
1225 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date)
1230 char fileset_name[MAX_NAME_LENGTH];
1231 char ed1[50], ed2[50];
1232 char pool_select[MAX_NAME_LENGTH];
1235 /* Create temp tables */
1236 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1237 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1238 if (!db_sql_query(ua->db, uar_create_temp[db_type], NULL, NULL)) {
1239 ua->error_msg("%s\n", db_strerror(ua->db));
1241 if (!db_sql_query(ua->db, uar_create_temp1[db_type], NULL, NULL)) {
1242 ua->error_msg("%s\n", db_strerror(ua->db));
1245 * Select Client from the Catalog
1247 memset(&cr, 0, sizeof(cr));
1248 if (!get_client_dbr(ua, &cr)) {
1251 bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
1256 memset(&fsr, 0, sizeof(fsr));
1257 i = find_arg_with_value(ua, "FileSet");
1259 bstrncpy(fsr.FileSet, ua->argv[i], sizeof(fsr.FileSet));
1260 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1261 ua->error_msg(_("Error getting FileSet \"%s\": ERR=%s\n"), fsr.FileSet,
1262 db_strerror(ua->db));
1266 if (i < 0) { /* fileset not found */
1267 edit_int64(cr.ClientId, ed1);
1268 Mmsg(rx->query, uar_sel_fileset, ed1, ed1);
1269 start_prompt(ua, _("The defined FileSet resources are:\n"));
1270 if (!db_sql_query(ua->db, rx->query, fileset_handler, (void *)ua)) {
1271 ua->error_msg("%s\n", db_strerror(ua->db));
1273 if (do_prompt(ua, _("FileSet"), _("Select FileSet resource"),
1274 fileset_name, sizeof(fileset_name)) < 0) {
1275 ua->error_msg(_("No FileSet found for client \"%s\".\n"), cr.Name);
1279 bstrncpy(fsr.FileSet, fileset_name, sizeof(fsr.FileSet));
1280 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1281 ua->warning_msg(_("Error getting FileSet record: %s\n"), db_strerror(ua->db));
1282 ua->send_msg(_("This probably means you modified the FileSet.\n"
1283 "Continuing anyway.\n"));
1287 /* If Pool specified, add PoolId specification */
1291 memset(&pr, 0, sizeof(pr));
1292 bstrncpy(pr.Name, rx->pool->name(), sizeof(pr.Name));
1293 if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
1294 bsnprintf(pool_select, sizeof(pool_select), "AND Media.PoolId=%s ",
1295 edit_int64(pr.PoolId, ed1));
1297 ua->warning_msg(_("Pool \"%s\" not found, using any pool.\n"), pr.Name);
1301 /* Find JobId of last Full backup for this client, fileset */
1302 edit_int64(cr.ClientId, ed1);
1303 Mmsg(rx->query, uar_last_full, ed1, ed1, date, fsr.FileSet,
1305 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1306 ua->error_msg("%s\n", db_strerror(ua->db));
1310 /* Find all Volumes used by that JobId */
1311 if (!db_sql_query(ua->db, uar_full, NULL, NULL)) {
1312 ua->error_msg("%s\n", db_strerror(ua->db));
1316 /* Note, this is needed because I don't seem to get the callback
1317 * from the call just above.
1320 if (!db_sql_query(ua->db, uar_sel_all_temp1, last_full_handler, (void *)rx)) {
1321 ua->warning_msg("%s\n", db_strerror(ua->db));
1323 if (rx->JobTDate == 0) {
1324 ua->error_msg(_("No Full backup before %s found.\n"), date);
1328 /* Now find most recent Differental Job after Full save, if any */
1329 Mmsg(rx->query, uar_dif, edit_uint64(rx->JobTDate, ed1), date,
1330 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1331 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1332 ua->warning_msg("%s\n", db_strerror(ua->db));
1334 /* Now update JobTDate to look into Differental, if any */
1336 if (!db_sql_query(ua->db, uar_sel_all_temp, last_full_handler, (void *)rx)) {
1337 ua->warning_msg("%s\n", db_strerror(ua->db));
1339 if (rx->JobTDate == 0) {
1340 ua->error_msg(_("No Full backup before %s found.\n"), date);
1344 /* Now find all Incremental Jobs after Full/dif save */
1345 Mmsg(rx->query, uar_inc, edit_uint64(rx->JobTDate, ed1), date,
1346 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1347 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1348 ua->warning_msg("%s\n", db_strerror(ua->db));
1351 /* Get the JobIds from that list */
1352 rx->last_jobid[0] = rx->JobIds[0] = 0;
1354 if (!db_sql_query(ua->db, uar_sel_jobid_temp, jobid_handler, (void *)rx)) {
1355 ua->warning_msg("%s\n", db_strerror(ua->db));
1358 if (rx->JobIds[0] != 0) {
1359 if (find_arg(ua, NT_("copies")) > 0) {
1360 /* Display a list of all copies */
1361 db_list_copies_records(ua->jcr, ua->db, 0, rx->JobIds,
1362 prtit, ua, HORZ_LIST);
1364 /* Display a list of Jobs selected for this restore */
1365 db_list_sql_query(ua->jcr, ua->db, uar_list_temp, prtit, ua, 1,HORZ_LIST);
1369 ua->warning_msg(_("No jobs found.\n"));
1373 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1374 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1378 static int restore_count_handler(void *ctx, int num_fields, char **row)
1380 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1381 rx->JobId = str_to_int64(row[0]);
1387 * Callback handler to get JobId and FileIndex for files
1388 * can insert more than one depending on the caller.
1390 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row)
1392 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1394 Dmsg2(200, "JobId=%s FileIndex=%s\n", row[0], row[1]);
1395 rx->JobId = str_to_int64(row[0]);
1396 add_findex(rx->bsr, rx->JobId, str_to_int64(row[1]));
1398 rx->selected_files++;
1403 * Callback handler make list of JobIds
1405 static int jobid_handler(void *ctx, int num_fields, char **row)
1407 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1409 if (strcmp(rx->last_jobid, row[0]) == 0) {
1410 return 0; /* duplicate id */
1412 bstrncpy(rx->last_jobid, row[0], sizeof(rx->last_jobid));
1413 if (rx->JobIds[0] != 0) {
1414 pm_strcat(rx->JobIds, ",");
1416 pm_strcat(rx->JobIds, row[0]);
1422 * Callback handler to pickup last Full backup JobTDate
1424 static int last_full_handler(void *ctx, int num_fields, char **row)
1426 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1428 rx->JobTDate = str_to_int64(row[1]);
1433 * Callback handler build FileSet name prompt list
1435 static int fileset_handler(void *ctx, int num_fields, char **row)
1437 /* row[0] = FileSet (name) */
1439 add_prompt((UAContext *)ctx, row[0]);
1445 * Free names in the list
1447 static void free_name_list(NAME_LIST *name_list)
1449 for (int i=0; i < name_list->num_ids; i++) {
1450 free(name_list->name[i]);
1452 bfree_and_null(name_list->name);
1453 name_list->max_ids = 0;
1454 name_list->num_ids = 0;
1457 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType)
1462 Dmsg1(200, "Already have store=%s\n", rx.store->name());
1466 * Try looking up Storage by name
1469 foreach_res(store, R_STORAGE) {
1470 if (strcmp(Storage, store->name()) == 0) {
1471 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1480 /* Check if an explicit storage resource is given */
1482 int i = find_arg_with_value(ua, "storage");
1484 store = (STORE *)GetResWithName(R_STORAGE, ua->argv[i]);
1485 if (store && !acl_access_ok(ua, Storage_ACL, store->name())) {
1489 if (store && (store != rx.store)) {
1490 ua->info_msg(_("Warning default storage overridden by \"%s\" on command line.\n"),
1493 Dmsg1(200, "Set store=%s\n", rx.store->name());
1498 /* If no storage resource, try to find one from MediaType */
1501 foreach_res(store, R_STORAGE) {
1502 if (strcmp(MediaType, store->media_type) == 0) {
1503 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1505 Dmsg1(200, "Set store=%s\n", rx.store->name());
1506 ua->warning_msg(_("Storage \"%s\" not found, using Storage \"%s\" from MediaType \"%s\".\n"),
1507 Storage, store->name(), MediaType);
1514 ua->warning_msg(_("\nUnable to find Storage resource for\n"
1515 "MediaType \"%s\", needed by the Jobs you selected.\n"), MediaType);
1518 /* Take command line arg, or ask user if none */
1519 rx.store = get_storage_resource(ua, false /* don't use default */);
1521 Dmsg1(200, "Set store=%s\n", rx.store->name());