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)
313 rx->BaseJobIds[0] = '\0';
315 if (!db_get_used_base_jobids(ua->jcr, ua->db, rx->JobIds, rx->BaseJobIds)) {
316 ua->warning_msg("%s", db_strerror(ua->db));
319 if (*rx->BaseJobIds) {
321 Mmsg(q, uar_print_jobs, rx->BaseJobIds);
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);
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 JobId"),
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 */
465 for (i=1; i<ua->argc; i++) { /* loop through arguments */
466 bool found_kw = false;
467 for (j=0; kw[j]; j++) { /* loop through keywords */
468 if (strcasecmp(kw[j], ua->argk[i]) == 0) {
474 ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
477 /* Found keyword in kw[] list, process it */
480 if (!has_value(ua, i)) {
483 if (*rx->JobIds != 0) {
484 pm_strcat(rx->JobIds, ",");
486 pm_strcat(rx->JobIds, ua->argv[i]);
489 case 1: /* current */
491 * Note, we add one second here just to include any job
492 * that may have finished within the current second,
493 * which happens a lot in scripting small jobs.
495 bstrutime(date, sizeof(date), now);
499 if (have_date || !has_value(ua, i)) {
502 if (str_to_utime(ua->argv[i]) == 0) {
503 ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
506 bstrncpy(date, ua->argv[i], sizeof(date));
511 if (!has_value(ua, i)) {
515 bstrutime(date, sizeof(date), now);
517 if (!get_client_name(ua, rx)) {
520 pm_strcpy(ua->cmd, ua->argv[i]);
521 insert_one_file_or_dir(ua, rx, date, j==4);
525 bstrutime(date, sizeof(date), now);
527 if (!select_backups_before_date(ua, rx, date)) {
532 case 6: /* pool specified */
533 if (!has_value(ua, i)) {
536 rx->pool = (POOL *)GetResWithName(R_POOL, ua->argv[i]);
538 ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
541 if (!acl_access_ok(ua, Pool_ACL, ua->argv[i])) {
543 ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
547 case 7: /* all specified */
551 * All keywords 7 or greater are ignored or handled by a select prompt
559 ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
560 "to be restored. You will be presented several methods\n"
561 "of specifying the JobIds. Then you will be allowed to\n"
562 "select which files from those JobIds are to be restored.\n\n"));
565 /* If choice not already made above, prompt */
572 start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
573 for (int i=0; list[i]; i++) {
574 add_prompt(ua, list[i]);
577 switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
578 case -1: /* error or cancel */
580 case 0: /* list last 20 Jobs run */
581 if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
582 ua->error_msg(_("SQL query not authorized.\n"));
585 gui_save = ua->jcr->gui;
587 db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, prtit, ua, 1, HORZ_LIST);
588 ua->jcr->gui = gui_save;
591 case 1: /* list where a file is saved */
592 if (!get_client_name(ua, rx)) {
595 if (!get_cmd(ua, _("Enter Filename (no path):"))) {
598 len = strlen(ua->cmd);
599 fname = (char *)malloc(len * 2 + 1);
600 db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
601 Mmsg(rx->query, uar_file[db_type], rx->ClientName, fname);
603 gui_save = ua->jcr->gui;
605 db_list_sql_query(ua->jcr, ua->db, rx->query, prtit, ua, 1, HORZ_LIST);
606 ua->jcr->gui = gui_save;
609 case 2: /* enter a list of JobIds */
610 if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
613 pm_strcpy(rx->JobIds, ua->cmd);
615 case 3: /* Enter an SQL list command */
616 if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
617 ua->error_msg(_("SQL query not authorized.\n"));
620 if (!get_cmd(ua, _("Enter SQL list command: "))) {
623 gui_save = ua->jcr->gui;
625 db_list_sql_query(ua->jcr, ua->db, ua->cmd, prtit, ua, 1, HORZ_LIST);
626 ua->jcr->gui = gui_save;
629 case 4: /* Select the most recent backups */
631 bstrutime(date, sizeof(date), now);
633 if (!select_backups_before_date(ua, rx, date)) {
637 case 5: /* select backup at specified time */
639 if (!get_date(ua, date, sizeof(date))) {
643 if (!select_backups_before_date(ua, rx, date)) {
647 case 6: /* Enter files */
649 bstrutime(date, sizeof(date), now);
651 if (!get_client_name(ua, rx)) {
654 ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
655 "containing a list of file names with paths, and terminate\n"
656 "them with a blank line.\n"));
658 if (!get_cmd(ua, _("Enter full filename: "))) {
661 len = strlen(ua->cmd);
665 insert_one_file_or_dir(ua, rx, date, false);
668 case 7: /* enter files backed up before specified time */
670 if (!get_date(ua, date, sizeof(date))) {
674 if (!get_client_name(ua, rx)) {
677 ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
678 "containing a list of file names with paths, and terminate\n"
679 "them with a blank line.\n"));
681 if (!get_cmd(ua, _("Enter full filename: "))) {
684 len = strlen(ua->cmd);
688 insert_one_file_or_dir(ua, rx, date, false);
692 case 8: /* Find JobIds for current backup */
694 bstrutime(date, sizeof(date), now);
696 if (!select_backups_before_date(ua, rx, date)) {
702 case 9: /* Find JobIds for give date */
704 if (!get_date(ua, date, sizeof(date))) {
708 if (!select_backups_before_date(ua, rx, date)) {
714 case 10: /* Enter directories */
715 if (*rx->JobIds != 0) {
716 ua->send_msg(_("You have already selected the following JobIds: %s\n"),
718 } else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
719 if (*rx->JobIds != 0 && *ua->cmd) {
720 pm_strcat(rx->JobIds, ",");
722 pm_strcat(rx->JobIds, ua->cmd);
724 if (*rx->JobIds == 0 || *rx->JobIds == '.') {
725 return 0; /* nothing entered, return */
728 bstrutime(date, sizeof(date), now);
730 if (!get_client_name(ua, rx)) {
733 ua->send_msg(_("Enter full directory names or start the name\n"
734 "with a < to indicate it is a filename containing a list\n"
735 "of directories and terminate them with a blank line.\n"));
737 if (!get_cmd(ua, _("Enter directory name: "))) {
740 len = strlen(ua->cmd);
744 /* Add trailing slash to end of directory names */
745 if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
746 strcat(ua->cmd, "/");
748 insert_one_file_or_dir(ua, rx, date, true);
752 case 11: /* Choose a jobid and select jobs */
753 if (!get_cmd(ua, _("Enter JobId to restore: ")) ||
754 !is_an_integer(ua->cmd))
759 memset(&jr, 0, sizeof(JOB_DBR));
760 jr.JobId = str_to_int64(ua->cmd);
761 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
762 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
763 ua->cmd, db_strerror(ua->db));
766 jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
767 if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
770 pm_strcpy(rx->JobIds, jobids.list);
771 Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
773 case 12: /* Cancel or quit */
778 memset(&jr, 0, sizeof(JOB_DBR));
779 POOLMEM *JobIds = get_pool_memory(PM_FNAME);
783 * Find total number of files to be restored, and filter the JobId
784 * list to contain only ones permitted by the ACL conditions.
786 for (p=rx->JobIds; ; ) {
788 int stat = get_next_jobid_from_list(&p, &JobId);
790 ua->error_msg(_("Invalid JobId in list.\n"));
791 free_pool_memory(JobIds);
797 if (jr.JobId == JobId) {
798 continue; /* duplicate of last JobId */
800 memset(&jr, 0, sizeof(JOB_DBR));
802 if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
803 ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
804 edit_int64(JobId, ed1), db_strerror(ua->db));
805 free_pool_memory(JobIds);
808 if (!acl_access_ok(ua, Job_ACL, jr.Name)) {
809 ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
810 edit_int64(JobId, ed1), jr.Name);
814 pm_strcat(JobIds, ",");
816 pm_strcat(JobIds, edit_int64(JobId, ed1));
817 rx->TotalFiles += jr.JobFiles;
819 free_pool_memory(rx->JobIds);
820 rx->JobIds = JobIds; /* Set ACL filtered list */
821 if (*rx->JobIds == 0) {
822 ua->warning_msg(_("No Jobs selected.\n"));
826 if (strchr(rx->JobIds,',')) {
827 ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
829 ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
837 static int get_date(UAContext *ua, char *date, int date_len)
839 ua->send_msg(_("The restored files will the most current backup\n"
840 "BEFORE the date you specify below.\n\n"));
842 if (!get_cmd(ua, _("Enter date as YYYY-MM-DD HH:MM:SS :"))) {
845 if (str_to_utime(ua->cmd) != 0) {
848 ua->error_msg(_("Improper date format.\n"));
850 bstrncpy(date, ua->cmd, date_len);
855 * Insert a single file, or read a list of files from a file
857 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir)
867 if ((ffd = fopen(p, "rb")) == NULL) {
869 ua->error_msg(_("Cannot open file %s: ERR=%s\n"),
873 while (fgets(file, sizeof(file), ffd)) {
876 if (!insert_dir_into_findex_list(ua, rx, file, date)) {
877 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
880 if (!insert_file_into_findex_list(ua, rx, file, date)) {
881 ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
889 insert_table_into_findex_list(ua, rx, p);
893 insert_dir_into_findex_list(ua, rx, ua->cmd, date);
895 insert_file_into_findex_list(ua, rx, ua->cmd, date);
902 * For a given file (path+filename), split into path and file, then
903 * lookup the most recent backup in the catalog to get the JobId
904 * and FileIndex, then insert them into the findex list.
906 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
909 strip_trailing_newline(file);
910 split_path_and_filename(ua, rx, file);
911 if (*rx->JobIds == 0) {
912 Mmsg(rx->query, uar_jobid_fileindex, date, rx->path, rx->fname,
915 Mmsg(rx->query, uar_jobids_fileindex, rx->JobIds, date,
916 rx->path, rx->fname, rx->ClientName);
919 /* Find and insert jobid and File Index */
920 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
921 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
922 rx->query, db_strerror(ua->db));
925 ua->error_msg(_("No database record found for: %s\n"), file);
926 // ua->error_msg("Query=%s\n", rx->query);
933 * For a given path lookup the most recent backup in the catalog
934 * to get the JobId and FileIndexes of all files in that directory.
936 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
939 strip_trailing_junk(dir);
940 if (*rx->JobIds == 0) {
941 ua->error_msg(_("No JobId specified cannot continue.\n"));
944 Mmsg(rx->query, uar_jobid_fileindex_from_dir[db_type], rx->JobIds, dir, rx->ClientName);
947 /* Find and insert jobid and File Index */
948 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
949 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
950 rx->query, db_strerror(ua->db));
953 ua->error_msg(_("No database record found for: %s\n"), dir);
960 * Get the JobId and FileIndexes of all files in the specified table
962 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table)
964 strip_trailing_junk(table);
965 Mmsg(rx->query, uar_jobid_fileindex_from_table, table);
968 /* Find and insert jobid and File Index */
969 if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
970 ua->error_msg(_("Query failed: %s. ERR=%s\n"),
971 rx->query, db_strerror(ua->db));
974 ua->error_msg(_("No table found: %s\n"), table);
980 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
984 /* Find path without the filename.
985 * I.e. everything after the last / is a "filename".
986 * OK, maybe it is a directory name, but we treat it like
987 * a filename. If we don't find a / then the whole name
988 * must be a path name (e.g. c:).
990 for (p=f=name; *p; p++) {
991 if (IsPathSeparator(*p)) {
992 f = p; /* set pos of last slash */
995 if (IsPathSeparator(*f)) { /* did we find a slash? */
996 f++; /* yes, point to filename */
997 } else { /* no, whole thing must be path name */
1001 /* If filename doesn't exist (i.e. root directory), we
1002 * simply create a blank name consisting of a single
1003 * space. This makes handling zero length filenames
1008 rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
1009 db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
1017 rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
1018 db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
1024 Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
1027 static bool ask_for_fileregex(UAContext *ua, RESTORE_CTX *rx)
1029 if (find_arg(ua, NT_("all")) >= 0) { /* if user enters all on command line */
1030 return true; /* select everything */
1032 ua->send_msg(_("\n\nFor one or more of the JobIds selected, no files were found,\n"
1033 "so file selection is not possible.\n"
1034 "Most likely your retention policy pruned the files.\n"));
1035 if (get_yesno(ua, _("\nDo you want to restore all the files? (yes|no): "))) {
1036 if (ua->pint32_val == 1)
1038 while (get_cmd(ua, _("\nRegexp matching files to restore? (empty to abort): "))) {
1039 if (ua->cmd[0] == '\0') {
1042 regex_t *fileregex_re = NULL;
1044 char errmsg[500] = "";
1046 fileregex_re = (regex_t *)bmalloc(sizeof(regex_t));
1047 rc = regcomp(fileregex_re, ua->cmd, REG_EXTENDED|REG_NOSUB);
1049 regerror(rc, fileregex_re, errmsg, sizeof(errmsg));
1051 regfree(fileregex_re);
1054 ua->send_msg(_("Regex compile error: %s\n"), errmsg);
1056 rx->bsr->fileregex = bstrdup(ua->cmd);
1065 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx)
1068 JobId_t JobId, last_JobId;
1073 memset(&tree, 0, sizeof(TREE_CTX));
1075 * Build the directory tree containing JobIds user selected
1077 tree.root = new_tree(rx->TotalFiles);
1082 * For display purposes, the same JobId, with different volumes may
1083 * appear more than once, however, we only insert it once.
1086 tree.FileEstimate = 0;
1087 if (get_next_jobid_from_list(&p, &JobId) > 0) {
1088 /* Use first JobId as estimate of the number of files to restore */
1089 Mmsg(rx->query, uar_count_files, edit_int64(JobId, ed1));
1090 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1091 ua->error_msg("%s\n", db_strerror(ua->db));
1094 /* Add about 25% more than this job for over estimate */
1095 tree.FileEstimate = rx->JobId + (rx->JobId >> 2);
1096 tree.DeltaCount = rx->JobId/50; /* print 50 ticks */
1100 ua->info_msg(_("\nBuilding directory tree for JobId(s) %s ... "),
1103 #define new_get_file_list
1104 #ifdef new_get_file_list
1105 if (!db_get_file_list(ua->jcr, ua->db, rx->JobIds, insert_tree_handler, (void *)&tree)) {
1106 ua->error_msg("%s", db_strerror(ua->db));
1108 if (*rx->BaseJobIds) {
1109 pm_strcat(rx->JobIds, ",");
1110 pm_strcat(rx->JobIds, rx->BaseJobIds);
1113 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1116 if (JobId == last_JobId) {
1117 continue; /* eliminate duplicate JobIds */
1121 * Find files for this JobId and insert them in the tree
1123 Mmsg(rx->query, uar_sel_files, edit_int64(JobId, ed1));
1124 if (!db_sql_query(ua->db, rx->query, insert_tree_handler, (void *)&tree)) {
1125 ua->error_msg("%s", db_strerror(ua->db));
1130 * Look at the first JobId on the list (presumably the oldest) and
1131 * if it is marked purged, don't do the manual selection because
1132 * the Job was pruned, so the tree is incomplete.
1134 if (tree.FileCount != 0) {
1135 /* Find out if any Job is purged */
1136 Mmsg(rx->query, "SELECT SUM(PurgedFiles) FROM Job WHERE JobId IN (%s)", rx->JobIds);
1137 if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1138 ua->error_msg("%s\n", db_strerror(ua->db));
1140 /* rx->JobId is the PurgedFiles flag */
1141 if (rx->found && rx->JobId > 0) {
1142 tree.FileCount = 0; /* set count to zero, no tree selection */
1145 if (tree.FileCount == 0) {
1146 OK = ask_for_fileregex(ua, rx);
1149 for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1150 if (JobId == last_JobId) {
1151 continue; /* eliminate duplicate JobIds */
1153 add_findex_all(rx->bsr, JobId);
1159 ua->info_msg(_("\n%s files inserted into the tree and marked for extraction.\n"),
1160 edit_uint64_with_commas(tree.FileCount, ec1));
1162 ua->info_msg(_("\n%s files inserted into the tree.\n"),
1163 edit_uint64_with_commas(tree.FileCount, ec1));
1166 if (find_arg(ua, NT_("done")) < 0) {
1167 /* Let the user interact in selecting which files to restore */
1168 OK = user_select_files_from_tree(&tree);
1172 * Walk down through the tree finding all files marked to be
1173 * extracted making a bootstrap file.
1176 for (TREE_NODE *node=first_tree_node(tree.root); node; node=next_tree_node(node)) {
1177 Dmsg2(400, "FI=%d node=0x%x\n", node->FileIndex, node);
1178 if (node->extract || node->extract_dir) {
1179 Dmsg3(400, "JobId=%lld type=%d FI=%d\n", (uint64_t)node->JobId, node->type, node->FileIndex);
1180 add_findex(rx->bsr, node->JobId, node->FileIndex);
1181 if (node->extract && node->type != TN_NEWDIR) {
1182 rx->selected_files++; /* count only saved files */
1189 free_tree(tree.root); /* free the directory tree */
1195 * This routine is used to get the current backup or a backup
1196 * before the specified date.
1198 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date)
1203 char fileset_name[MAX_NAME_LENGTH];
1204 char ed1[50], ed2[50];
1205 char pool_select[MAX_NAME_LENGTH];
1208 /* Create temp tables */
1209 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1210 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1211 if (!db_sql_query(ua->db, uar_create_temp[db_type], NULL, NULL)) {
1212 ua->error_msg("%s\n", db_strerror(ua->db));
1214 if (!db_sql_query(ua->db, uar_create_temp1[db_type], NULL, NULL)) {
1215 ua->error_msg("%s\n", db_strerror(ua->db));
1218 * Select Client from the Catalog
1220 memset(&cr, 0, sizeof(cr));
1221 if (!get_client_dbr(ua, &cr)) {
1224 bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
1229 memset(&fsr, 0, sizeof(fsr));
1230 i = find_arg_with_value(ua, "FileSet");
1232 bstrncpy(fsr.FileSet, ua->argv[i], sizeof(fsr.FileSet));
1233 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1234 ua->error_msg(_("Error getting FileSet \"%s\": ERR=%s\n"), fsr.FileSet,
1235 db_strerror(ua->db));
1239 if (i < 0) { /* fileset not found */
1240 edit_int64(cr.ClientId, ed1);
1241 Mmsg(rx->query, uar_sel_fileset, ed1, ed1);
1242 start_prompt(ua, _("The defined FileSet resources are:\n"));
1243 if (!db_sql_query(ua->db, rx->query, fileset_handler, (void *)ua)) {
1244 ua->error_msg("%s\n", db_strerror(ua->db));
1246 if (do_prompt(ua, _("FileSet"), _("Select FileSet resource"),
1247 fileset_name, sizeof(fileset_name)) < 0) {
1248 ua->error_msg(_("No FileSet found for client \"%s\".\n"), cr.Name);
1252 bstrncpy(fsr.FileSet, fileset_name, sizeof(fsr.FileSet));
1253 if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1254 ua->warning_msg(_("Error getting FileSet record: %s\n"), db_strerror(ua->db));
1255 ua->send_msg(_("This probably means you modified the FileSet.\n"
1256 "Continuing anyway.\n"));
1260 /* If Pool specified, add PoolId specification */
1264 memset(&pr, 0, sizeof(pr));
1265 bstrncpy(pr.Name, rx->pool->name(), sizeof(pr.Name));
1266 if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
1267 bsnprintf(pool_select, sizeof(pool_select), "AND Media.PoolId=%s ",
1268 edit_int64(pr.PoolId, ed1));
1270 ua->warning_msg(_("Pool \"%s\" not found, using any pool.\n"), pr.Name);
1274 /* Find JobId of last Full backup for this client, fileset */
1275 edit_int64(cr.ClientId, ed1);
1276 Mmsg(rx->query, uar_last_full, ed1, ed1, date, fsr.FileSet,
1278 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1279 ua->error_msg("%s\n", db_strerror(ua->db));
1283 /* Find all Volumes used by that JobId */
1284 if (!db_sql_query(ua->db, uar_full, NULL, NULL)) {
1285 ua->error_msg("%s\n", db_strerror(ua->db));
1289 /* Note, this is needed because I don't seem to get the callback
1290 * from the call just above.
1293 if (!db_sql_query(ua->db, uar_sel_all_temp1, last_full_handler, (void *)rx)) {
1294 ua->warning_msg("%s\n", db_strerror(ua->db));
1296 if (rx->JobTDate == 0) {
1297 ua->error_msg(_("No Full backup before %s found.\n"), date);
1301 /* Now find most recent Differental Job after Full save, if any */
1302 Mmsg(rx->query, uar_dif, edit_uint64(rx->JobTDate, ed1), date,
1303 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1304 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1305 ua->warning_msg("%s\n", db_strerror(ua->db));
1307 /* Now update JobTDate to look into Differental, if any */
1309 if (!db_sql_query(ua->db, uar_sel_all_temp, last_full_handler, (void *)rx)) {
1310 ua->warning_msg("%s\n", db_strerror(ua->db));
1312 if (rx->JobTDate == 0) {
1313 ua->error_msg(_("No Full backup before %s found.\n"), date);
1317 /* Now find all Incremental Jobs after Full/dif save */
1318 Mmsg(rx->query, uar_inc, edit_uint64(rx->JobTDate, ed1), date,
1319 edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1320 if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1321 ua->warning_msg("%s\n", db_strerror(ua->db));
1324 /* Get the JobIds from that list */
1325 rx->last_jobid[0] = rx->JobIds[0] = 0;
1327 if (!db_sql_query(ua->db, uar_sel_jobid_temp, jobid_handler, (void *)rx)) {
1328 ua->warning_msg("%s\n", db_strerror(ua->db));
1331 if (rx->JobIds[0] != 0) {
1332 if (find_arg(ua, NT_("copies")) > 0) {
1333 /* Display a list of all copies */
1334 db_list_copies_records(ua->jcr, ua->db, 0, rx->JobIds,
1335 prtit, ua, HORZ_LIST);
1337 /* Display a list of Jobs selected for this restore */
1338 db_list_sql_query(ua->jcr, ua->db, uar_list_temp, prtit, ua, 1,HORZ_LIST);
1342 ua->warning_msg(_("No jobs found.\n"));
1346 db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1347 db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1351 static int restore_count_handler(void *ctx, int num_fields, char **row)
1353 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1354 rx->JobId = str_to_int64(row[0]);
1360 * Callback handler to get JobId and FileIndex for files
1361 * can insert more than one depending on the caller.
1363 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row)
1365 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1367 Dmsg2(200, "JobId=%s FileIndex=%s\n", row[0], row[1]);
1368 rx->JobId = str_to_int64(row[0]);
1369 add_findex(rx->bsr, rx->JobId, str_to_int64(row[1]));
1371 rx->selected_files++;
1376 * Callback handler make list of JobIds
1378 static int jobid_handler(void *ctx, int num_fields, char **row)
1380 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1382 if (strcmp(rx->last_jobid, row[0]) == 0) {
1383 return 0; /* duplicate id */
1385 bstrncpy(rx->last_jobid, row[0], sizeof(rx->last_jobid));
1386 if (rx->JobIds[0] != 0) {
1387 pm_strcat(rx->JobIds, ",");
1389 pm_strcat(rx->JobIds, row[0]);
1395 * Callback handler to pickup last Full backup JobTDate
1397 static int last_full_handler(void *ctx, int num_fields, char **row)
1399 RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1401 rx->JobTDate = str_to_int64(row[1]);
1406 * Callback handler build FileSet name prompt list
1408 static int fileset_handler(void *ctx, int num_fields, char **row)
1410 /* row[0] = FileSet (name) */
1412 add_prompt((UAContext *)ctx, row[0]);
1418 * Free names in the list
1420 static void free_name_list(NAME_LIST *name_list)
1422 for (int i=0; i < name_list->num_ids; i++) {
1423 free(name_list->name[i]);
1425 bfree_and_null(name_list->name);
1426 name_list->max_ids = 0;
1427 name_list->num_ids = 0;
1430 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType)
1435 Dmsg1(200, "Already have store=%s\n", rx.store->name());
1439 * Try looking up Storage by name
1442 foreach_res(store, R_STORAGE) {
1443 if (strcmp(Storage, store->name()) == 0) {
1444 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1453 /* Check if an explicit storage resource is given */
1455 int i = find_arg_with_value(ua, "storage");
1457 store = (STORE *)GetResWithName(R_STORAGE, ua->argv[i]);
1458 if (store && !acl_access_ok(ua, Storage_ACL, store->name())) {
1462 if (store && (store != rx.store)) {
1463 ua->info_msg(_("Warning default storage overridden by \"%s\" on command line.\n"),
1466 Dmsg1(200, "Set store=%s\n", rx.store->name());
1471 /* If no storage resource, try to find one from MediaType */
1474 foreach_res(store, R_STORAGE) {
1475 if (strcmp(MediaType, store->media_type) == 0) {
1476 if (acl_access_ok(ua, Storage_ACL, store->name())) {
1478 Dmsg1(200, "Set store=%s\n", rx.store->name());
1479 ua->warning_msg(_("Storage \"%s\" not found, using Storage \"%s\" from MediaType \"%s\".\n"),
1480 Storage, store->name(), MediaType);
1487 ua->warning_msg(_("\nUnable to find Storage resource for\n"
1488 "MediaType \"%s\", needed by the Jobs you selected.\n"), MediaType);
1491 /* Take command line arg, or ask user if none */
1492 rx.store = get_storage_resource(ua, false /* don't use default */);
1494 Dmsg1(200, "Set store=%s\n", rx.store->name());