git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/ua_restore.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2002-2009 Free Software Foundation Europe e.V.
   5
   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
  11    in the file LICENSE.
  12
  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.
  17
  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
  21    02110-1301, USA.
  22
  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.
  27 */
  28 /*
  29  *
  30  *   Bacula Director -- User Agent Database restore Command
  31  *      Creates a bootstrap file for restoring files and
  32  *      starts the restore job.
  33  *
  34  *      Tree handling routines split into ua_tree.c July MMIII.
  35  *      BSR (bootstrap record) handling routines split into
  36  *        bsr.c July MMIII
  37  *
  38  *     Kern Sibbald, July MMII
  39  *
  40  *   Version $Id$
  41  */
  42
  43
  44 #include "bacula.h"
  45 #include "dird.h"
  46
  47 /* Imported functions */
  48 extern void print_bsr(UAContext *ua, RBSR *bsr);
  49
  50
  51
  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,
  64                                          char *date);
  65 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
  66                                         char *date);
  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
  74 /*
  75  *   Restore files
  76  *
  77  */
  78 int restore_cmd(UAContext *ua, const char *cmd)
  79 {
  80    RESTORE_CTX rx;                    /* restore context */
  81    JOB *job;
  82    int i;
  83    JCR *jcr = ua->jcr;
  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;
  88
  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);
  93    rx.query = get_pool_memory(PM_FNAME);
  94    rx.bsr = new_bsr();
  95
  96    i = find_arg_with_value(ua, "where");
  97    if (i >= 0) {
  98       rx.where = ua->argv[i];
  99    }
 100
 101    i = find_arg_with_value(ua, "strip_prefix");
 102    if (i >= 0) {
 103       strip_prefix = ua->argv[i];
 104    }
 105
 106    i = find_arg_with_value(ua, "add_prefix");
 107    if (i >= 0) {
 108       add_prefix = ua->argv[i];
 109    }
 110
 111    i = find_arg_with_value(ua, "add_suffix");
 112    if (i >= 0) {
 113       add_suffix = ua->argv[i];
 114    }
 115
 116    i = find_arg_with_value(ua, "regexwhere");
 117    if (i >= 0) {
 118       rx.RegexWhere = ua->argv[i];
 119    }
 120
 121    if (strip_prefix || add_suffix || add_prefix) {
 122       int len = bregexp_get_build_where_size(strip_prefix, add_prefix, add_suffix);
 123       regexp = (char *)bmalloc(len * sizeof(char));
 124
 125       bregexp_build_where(regexp, len, strip_prefix, add_prefix, add_suffix);
 126       rx.RegexWhere = regexp;
 127    }
 128
 129    /* TODO: add acl for regexwhere ? */
 130
 131    if (rx.RegexWhere) {
 132       if (!acl_access_ok(ua, Where_ACL, rx.RegexWhere)) {
 133          ua->error_msg(_("\"RegexWhere\" specification not authorized.\n"));
 134          goto bail_out;
 135       }
 136    }
 137
 138    if (rx.where) {
 139       if (!acl_access_ok(ua, Where_ACL, rx.where)) {
 140          ua->error_msg(_("\"where\" specification not authorized.\n"));
 141          goto bail_out;
 142       }
 143    }
 144
 145    if (!open_client_db(ua)) {
 146       goto bail_out;
 147    }
 148
 149    /* Ensure there is at least one Restore Job */
 150    LockRes();
 151    foreach_res(job, R_JOB) {
 152       if (job->JobType == JT_RESTORE) {
 153          if (!rx.restore_job) {
 154             rx.restore_job = job;
 155          }
 156          rx.restore_jobs++;
 157       }
 158    }
 159    UnlockRes();
 160    if (!rx.restore_jobs) {
 161       ua->error_msg(_(
 162          "No Restore Job Resource found in bacula-dir.conf.\n"
 163          "You must create at least one before running this command.\n"));
 164       goto bail_out;
 165    }
 166
 167    /*
 168     * Request user to select JobIds or files by various different methods
 169     *  last 20 jobs, where File saved, most recent backup, ...
 170     *  In the end, a list of files are pumped into
 171     *  add_findex()
 172     */
 173    switch (user_select_jobids_or_files(ua, &rx)) {
 174    case 0:                            /* error */
 175       goto bail_out;
 176    case 1:                            /* selected by jobid */
 177       if (!build_directory_tree(ua, &rx)) {
 178          ua->send_msg(_("Restore not done.\n"));
 179          goto bail_out;
 180       }
 181       break;
 182    case 2:                            /* selected by filename, no tree needed */
 183       break;
 184    }
 185
 186    if (rx.bsr->JobId) {
 187       uint32_t selected_files;
 188       char ed1[50];
 189       if (!complete_bsr(ua, rx.bsr)) {   /* find Vol, SessId, SessTime from JobIds */
 190          ua->error_msg(_("Unable to construct a valid BSR. Cannot continue.\n"));
 191          goto bail_out;
 192       }
 193       if (!(selected_files = write_bsr_file(ua, rx))) {
 194          ua->warning_msg(_("No files selected to be restored.\n"));
 195          goto bail_out;
 196       }
 197       display_bsr_info(ua, rx);          /* display vols needed, etc */
 198
 199       /* If no count of files, use bsr generated value (often wrong) */
 200       if (rx.selected_files == 0) {
 201          rx.selected_files = selected_files;
 202       }
 203       if (rx.selected_files==1) {
 204          ua->info_msg(_("\n1 file selected to be restored.\n\n"));
 205       }
 206       else {
 207          ua->info_msg(_("\n%s files selected to be restored.\n\n"),
 208             edit_uint64_with_commas(rx.selected_files, ed1));
 209       }
 210    } else {
 211       ua->warning_msg(_("No files selected to be restored.\n"));
 212       goto bail_out;
 213    }
 214
 215    if (rx.restore_jobs == 1) {
 216       job = rx.restore_job;
 217    } else {
 218       job = select_restore_job_resource(ua);
 219    }
 220    if (!job) {
 221       goto bail_out;
 222    }
 223
 224    get_client_name(ua, &rx);
 225    if (!rx.ClientName) {
 226       ua->error_msg(_("No Client resource found!\n"));
 227       goto bail_out;
 228    }
 229    get_restore_client_name(ua, rx);
 230
 231    escaped_bsr_name = escape_filename(jcr->RestoreBootstrap);
 232
 233    /* Build run command */
 234    if (rx.RegexWhere) {
 235       escaped_where_name = escape_filename(rx.RegexWhere);
 236       Mmsg(ua->cmd,
 237           "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
 238           " bootstrap=\"%s\" regexwhere=\"%s\" files=%u catalog=\"%s\"",
 239           job->name(), rx.ClientName, rx.RestoreClientName,
 240           rx.store?rx.store->name():"",
 241           escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
 242           escaped_where_name ? escaped_where_name : rx.RegexWhere,
 243           rx.selected_files, ua->catalog->name());
 244
 245    } else if (rx.where) {
 246       escaped_where_name = escape_filename(rx.where);
 247       Mmsg(ua->cmd,
 248           "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
 249           " bootstrap=\"%s\" where=\"%s\" files=%u catalog=\"%s\"",
 250           job->name(), rx.ClientName, rx.RestoreClientName,
 251           rx.store?rx.store->name():"",
 252           escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
 253           escaped_where_name ? escaped_where_name : rx.where,
 254           rx.selected_files, ua->catalog->name());
 255
 256    } else {
 257       Mmsg(ua->cmd,
 258           "run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
 259           " bootstrap=\"%s\" files=%u catalog=\"%s\"",
 260           job->name(), rx.ClientName, rx.RestoreClientName,
 261           rx.store?rx.store->name():"",
 262           escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
 263           rx.selected_files, ua->catalog->name());
 264    }
 265
 266    if (escaped_bsr_name != NULL) {
 267       bfree(escaped_bsr_name);
 268    }
 269
 270    if (escaped_where_name != NULL) {
 271       bfree(escaped_where_name);
 272    }
 273
 274    if (regexp) {
 275       bfree(regexp);
 276    }
 277
 278    if (find_arg(ua, NT_("yes")) > 0) {
 279       pm_strcat(ua->cmd, " yes");    /* pass it on to the run command */
 280    }
 281    Dmsg1(200, "Submitting: %s\n", ua->cmd);
 282    parse_ua_args(ua);
 283    run_cmd(ua, ua->cmd);
 284    free_rx(&rx);
 285    return 1;
 286
 287 bail_out:
 288    if (escaped_bsr_name != NULL) {
 289       bfree(escaped_bsr_name);
 290    }
 291
 292    if (escaped_where_name != NULL) {
 293       bfree(escaped_where_name);
 294    }
 295
 296    if (regexp) {
 297       bfree(regexp);
 298    }
 299
 300    free_rx(&rx);
 301    return 0;
 302
 303 }
 304
 305 static void free_rx(RESTORE_CTX *rx)
 306 {
 307    free_bsr(rx->bsr);
 308    rx->bsr = NULL;
 309    if (rx->JobIds) {
 310       free_pool_memory(rx->JobIds);
 311       rx->JobIds = NULL;
 312    }
 313    if (rx->fname) {
 314       free_pool_memory(rx->fname);
 315       rx->fname = NULL;
 316    }
 317    if (rx->path) {
 318       free_pool_memory(rx->path);
 319       rx->path = NULL;
 320    }
 321    if (rx->query) {
 322       free_pool_memory(rx->query);
 323       rx->query = NULL;
 324    }
 325    free_name_list(&rx->name_list);
 326 }
 327
 328 static bool has_value(UAContext *ua, int i)
 329 {
 330    if (!ua->argv[i]) {
 331       ua->error_msg(_("Missing value for keyword: %s\n"), ua->argk[i]);
 332       return false;
 333    }
 334    return true;
 335 }
 336
 337 /*
 338  * This gets the client name from which the backup was made
 339  */
 340 static int get_client_name(UAContext *ua, RESTORE_CTX *rx)
 341 {
 342    /* If no client name specified yet, get it now */
 343    if (!rx->ClientName[0]) {
 344       CLIENT_DBR cr;
 345       /* try command line argument */
 346       int i = find_arg_with_value(ua, NT_("client"));
 347       if (i < 0) {
 348          i = find_arg_with_value(ua, NT_("backupclient"));
 349       }
 350       if (i >= 0) {
 351          if (!has_value(ua, i)) {
 352             return 0;
 353          }
 354          bstrncpy(rx->ClientName, ua->argv[i], sizeof(rx->ClientName));
 355          return 1;
 356       }
 357       memset(&cr, 0, sizeof(cr));
 358       if (!get_client_dbr(ua, &cr)) {
 359          return 0;
 360       }
 361       bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
 362    }
 363    return 1;
 364 }
 365
 366 /*
 367  * This is where we pick up a client name to restore to.
 368  */
 369 static int get_restore_client_name(UAContext *ua, RESTORE_CTX &rx)
 370 {
 371    /* Start with same name as backup client */
 372    bstrncpy(rx.RestoreClientName, rx.ClientName, sizeof(rx.RestoreClientName));
 373
 374    /* try command line argument */
 375    int i = find_arg_with_value(ua, NT_("restoreclient"));
 376    if (i >= 0) {
 377       if (!has_value(ua, i)) {
 378          return 0;
 379       }
 380       bstrncpy(rx.RestoreClientName, ua->argv[i], sizeof(rx.RestoreClientName));
 381       return 1;
 382    }
 383    return 1;
 384 }
 385
 386
 387
 388 /*
 389  * The first step in the restore process is for the user to
 390  *  select a list of JobIds from which he will subsequently
 391  *  select which files are to be restored.
 392  *
 393  *  Returns:  2  if filename list made
 394  *            1  if jobid list made
 395  *            0  on error
 396  */
 397 static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
 398 {
 399    char *p;
 400    char date[MAX_TIME_LENGTH];
 401    bool have_date = false;
 402    /* Include current second if using current time */
 403    utime_t now = time(NULL) + 1;
 404    JobId_t JobId;
 405    JOB_DBR jr = { (JobId_t)-1 };
 406    bool done = false;
 407    int i, j;
 408    const char *list[] = {
 409       _("List last 20 Jobs run"),
 410       _("List Jobs where a given File is saved"),
 411       _("Enter list of comma separated JobIds to select"),
 412       _("Enter SQL list command"),
 413       _("Select the most recent backup for a client"),
 414       _("Select backup for a client before a specified time"),
 415       _("Enter a list of files to restore"),
 416       _("Enter a list of files to restore before a specified time"),
 417       _("Find the JobIds of the most recent backup for a client"),
 418       _("Find the JobIds for a backup for a client before a specified time"),
 419       _("Enter a list of directories to restore for found JobIds"),
 420       _("Select full restore to a specified Job date"),
 421       _("Cancel"),
 422       NULL };
 423
 424    const char *kw[] = {
 425        /* These keywords are handled in a for loop */
 426       "jobid",       /* 0 */
 427       "current",     /* 1 */
 428       "before",      /* 2 */
 429       "file",        /* 3 */
 430       "directory",   /* 4 */
 431       "select",      /* 5 */
 432       "pool",        /* 6 */
 433       "all",         /* 7 */
 434
 435       /* The keyword below are handled by individual arg lookups */
 436       "client",       /* 8 */
 437       "storage",      /* 9 */
 438       "fileset",      /* 10 */
 439       "where",        /* 11 */
 440       "yes",          /* 12 */
 441       "bootstrap",    /* 13 */
 442       "done",         /* 14 */
 443       "strip_prefix", /* 15 */
 444       "add_prefix",   /* 16 */
 445       "add_suffix",   /* 17 */
 446       "regexwhere",   /* 18 */
 447       "restoreclient", /* 19 */
 448       "copies",        /* 20 */
 449       NULL
 450    };
 451
 452    *rx->JobIds = 0;
 453
 454    for (i=1; i<ua->argc; i++) {       /* loop through arguments */
 455       bool found_kw = false;
 456       for (j=0; kw[j]; j++) {         /* loop through keywords */
 457          if (strcasecmp(kw[j], ua->argk[i]) == 0) {
 458             found_kw = true;
 459             break;
 460          }
 461       }
 462       if (!found_kw) {
 463          ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
 464          return 0;
 465       }
 466       /* Found keyword in kw[] list, process it */
 467       switch (j) {
 468       case 0:                            /* jobid */
 469          if (!has_value(ua, i)) {
 470             return 0;
 471          }
 472          if (*rx->JobIds != 0) {
 473             pm_strcat(rx->JobIds, ",");
 474          }
 475          pm_strcat(rx->JobIds, ua->argv[i]);
 476          done = true;
 477          break;
 478       case 1:                            /* current */
 479          /*
 480           * Note, we add one second here just to include any job
 481           *  that may have finished within the current second,
 482           *  which happens a lot in scripting small jobs.
 483           */
 484          bstrutime(date, sizeof(date), now);
 485          have_date = true;
 486          break;
 487       case 2:                            /* before */
 488          if (have_date || !has_value(ua, i)) {
 489             return 0;
 490          }
 491          if (str_to_utime(ua->argv[i]) == 0) {
 492             ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
 493             return 0;
 494          }
 495          bstrncpy(date, ua->argv[i], sizeof(date));
 496          have_date = true;
 497          break;
 498       case 3:                            /* file */
 499       case 4:                            /* dir */
 500          if (!has_value(ua, i)) {
 501             return 0;
 502          }
 503          if (!have_date) {
 504             bstrutime(date, sizeof(date), now);
 505          }
 506          if (!get_client_name(ua, rx)) {
 507             return 0;
 508          }
 509          pm_strcpy(ua->cmd, ua->argv[i]);
 510          insert_one_file_or_dir(ua, rx, date, j==4);
 511          return 2;
 512       case 5:                            /* select */
 513          if (!have_date) {
 514             bstrutime(date, sizeof(date), now);
 515          }
 516          if (!select_backups_before_date(ua, rx, date)) {
 517             return 0;
 518          }
 519          done = true;
 520          break;
 521       case 6:                            /* pool specified */
 522          if (!has_value(ua, i)) {
 523             return 0;
 524          }
 525          rx->pool = (POOL *)GetResWithName(R_POOL, ua->argv[i]);
 526          if (!rx->pool) {
 527             ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
 528             return 0;
 529          }
 530          if (!acl_access_ok(ua, Pool_ACL, ua->argv[i])) {
 531             rx->pool = NULL;
 532             ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
 533             return 0;
 534          }
 535          break;
 536       case 7:                         /* all specified */
 537          rx->all = true;
 538          break;
 539       /*
 540        * All keywords 7 or greater are ignored or handled by a select prompt
 541        */
 542       default:
 543          break;
 544       }
 545    }
 546
 547    if (!done) {
 548       ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
 549                   "to be restored. You will be presented several methods\n"
 550                   "of specifying the JobIds. Then you will be allowed to\n"
 551                   "select which files from those JobIds are to be restored.\n\n"));
 552    }
 553
 554    /* If choice not already made above, prompt */
 555    for ( ; !done; ) {
 556       char *fname;
 557       int len;
 558       bool gui_save;
 559       db_list_ctx jobids;
 560
 561       start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
 562       for (int i=0; list[i]; i++) {
 563          add_prompt(ua, list[i]);
 564       }
 565       done = true;
 566       switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
 567       case -1:                        /* error or cancel */
 568          return 0;
 569       case 0:                         /* list last 20 Jobs run */
 570          if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
 571             ua->error_msg(_("SQL query not authorized.\n"));
 572             return 0;
 573          }
 574          gui_save = ua->jcr->gui;
 575          ua->jcr->gui = true;
 576          db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, prtit, ua, 1, HORZ_LIST);
 577          ua->jcr->gui = gui_save;
 578          done = false;
 579          break;
 580       case 1:                         /* list where a file is saved */
 581          if (!get_client_name(ua, rx)) {
 582             return 0;
 583          }
 584          if (!get_cmd(ua, _("Enter Filename (no path):"))) {
 585             return 0;
 586          }
 587          len = strlen(ua->cmd);
 588          fname = (char *)malloc(len * 2 + 1);
 589          db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
 590          Mmsg(rx->query, uar_file[db_type], rx->ClientName, fname);
 591          free(fname);
 592          gui_save = ua->jcr->gui;
 593          ua->jcr->gui = true;
 594          db_list_sql_query(ua->jcr, ua->db, rx->query, prtit, ua, 1, HORZ_LIST);
 595          ua->jcr->gui = gui_save;
 596          done = false;
 597          break;
 598       case 2:                         /* enter a list of JobIds */
 599          if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
 600             return 0;
 601          }
 602          pm_strcpy(rx->JobIds, ua->cmd);
 603          break;
 604       case 3:                         /* Enter an SQL list command */
 605          if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), 8)) {
 606             ua->error_msg(_("SQL query not authorized.\n"));
 607             return 0;
 608          }
 609          if (!get_cmd(ua, _("Enter SQL list command: "))) {
 610             return 0;
 611          }
 612          gui_save = ua->jcr->gui;
 613          ua->jcr->gui = true;
 614          db_list_sql_query(ua->jcr, ua->db, ua->cmd, prtit, ua, 1, HORZ_LIST);
 615          ua->jcr->gui = gui_save;
 616          done = false;
 617          break;
 618       case 4:                         /* Select the most recent backups */
 619          if (!have_date) {
 620             bstrutime(date, sizeof(date), now);
 621          }
 622          if (!select_backups_before_date(ua, rx, date)) {
 623             return 0;
 624          }
 625          break;
 626       case 5:                         /* select backup at specified time */
 627          if (!have_date) {
 628             if (!get_date(ua, date, sizeof(date))) {
 629                return 0;
 630             }
 631          }
 632          if (!select_backups_before_date(ua, rx, date)) {
 633             return 0;
 634          }
 635          break;
 636       case 6:                         /* Enter files */
 637          if (!have_date) {
 638             bstrutime(date, sizeof(date), now);
 639          }
 640          if (!get_client_name(ua, rx)) {
 641             return 0;
 642          }
 643          ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
 644                         "containing a list of file names with paths, and terminate\n"
 645                         "them with a blank line.\n"));
 646          for ( ;; ) {
 647             if (!get_cmd(ua, _("Enter full filename: "))) {
 648                return 0;
 649             }
 650             len = strlen(ua->cmd);
 651             if (len == 0) {
 652                break;
 653             }
 654             insert_one_file_or_dir(ua, rx, date, false);
 655          }
 656          return 2;
 657        case 7:                        /* enter files backed up before specified time */
 658          if (!have_date) {
 659             if (!get_date(ua, date, sizeof(date))) {
 660                return 0;
 661             }
 662          }
 663          if (!get_client_name(ua, rx)) {
 664             return 0;
 665          }
 666          ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
 667                         "containing a list of file names with paths, and terminate\n"
 668                         "them with a blank line.\n"));
 669          for ( ;; ) {
 670             if (!get_cmd(ua, _("Enter full filename: "))) {
 671                return 0;
 672             }
 673             len = strlen(ua->cmd);
 674             if (len == 0) {
 675                break;
 676             }
 677             insert_one_file_or_dir(ua, rx, date, false);
 678          }
 679          return 2;
 680
 681       case 8:                         /* Find JobIds for current backup */
 682          if (!have_date) {
 683             bstrutime(date, sizeof(date), now);
 684          }
 685          if (!select_backups_before_date(ua, rx, date)) {
 686             return 0;
 687          }
 688          done = false;
 689          break;
 690
 691       case 9:                         /* Find JobIds for give date */
 692          if (!have_date) {
 693             if (!get_date(ua, date, sizeof(date))) {
 694                return 0;
 695             }
 696          }
 697          if (!select_backups_before_date(ua, rx, date)) {
 698             return 0;
 699          }
 700          done = false;
 701          break;
 702
 703       case 10:                        /* Enter directories */
 704          if (*rx->JobIds != 0) {
 705             ua->send_msg(_("You have already selected the following JobIds: %s\n"),
 706                rx->JobIds);
 707          } else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
 708             if (*rx->JobIds != 0 && *ua->cmd) {
 709                pm_strcat(rx->JobIds, ",");
 710             }
 711             pm_strcat(rx->JobIds, ua->cmd);
 712          }
 713          if (*rx->JobIds == 0 || *rx->JobIds == '.') {
 714             return 0;                 /* nothing entered, return */
 715          }
 716          if (!have_date) {
 717             bstrutime(date, sizeof(date), now);
 718          }
 719          if (!get_client_name(ua, rx)) {
 720             return 0;
 721          }
 722          ua->send_msg(_("Enter full directory names or start the name\n"
 723                         "with a < to indicate it is a filename containing a list\n"
 724                         "of directories and terminate them with a blank line.\n"));
 725          for ( ;; ) {
 726             if (!get_cmd(ua, _("Enter directory name: "))) {
 727                return 0;
 728             }
 729             len = strlen(ua->cmd);
 730             if (len == 0) {
 731                break;
 732             }
 733             /* Add trailing slash to end of directory names */
 734             if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
 735                strcat(ua->cmd, "/");
 736             }
 737             insert_one_file_or_dir(ua, rx, date, true);
 738          }
 739          return 2;
 740
 741       case 11:                        /* Choose a jobid and select jobs */
 742          if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
 743              !is_an_integer(ua->cmd))
 744          {
 745             return 0;
 746          }
 747
 748          memset(&jr, 0, sizeof(JOB_DBR));
 749          jr.JobId = str_to_int64(ua->cmd);
 750          if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
 751             ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
 752                           ua->cmd, db_strerror(ua->db));
 753             return 0;
 754          }
 755          ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
 756                       jr.cStartTime);
 757          jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
 758          if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
 759             return 0;
 760          }
 761          pm_strcpy(rx->JobIds, jobids.list);
 762          Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
 763          break;
 764       case 12:                        /* Cancel or quit */
 765          return 0;
 766       }
 767    }
 768
 769    memset(&jr, 0, sizeof(JOB_DBR));
 770    POOLMEM *JobIds = get_pool_memory(PM_FNAME);
 771    *JobIds = 0;
 772    rx->TotalFiles = 0;
 773    /*
 774     * Find total number of files to be restored, and filter the JobId
 775     *  list to contain only ones permitted by the ACL conditions.
 776     */
 777    for (p=rx->JobIds; ; ) {
 778       char ed1[50];
 779       int stat = get_next_jobid_from_list(&p, &JobId);
 780       if (stat < 0) {
 781          ua->error_msg(_("Invalid JobId in list.\n"));
 782          free_pool_memory(JobIds);
 783          return 0;
 784       }
 785       if (stat == 0) {
 786          break;
 787       }
 788       if (jr.JobId == JobId) {
 789          continue;                    /* duplicate of last JobId */
 790       }
 791       memset(&jr, 0, sizeof(JOB_DBR));
 792       jr.JobId = JobId;
 793       if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
 794          ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
 795             edit_int64(JobId, ed1), db_strerror(ua->db));
 796          free_pool_memory(JobIds);
 797          return 0;
 798       }
 799       if (!acl_access_ok(ua, Job_ACL, jr.Name)) {
 800          ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
 801             edit_int64(JobId, ed1), jr.Name);
 802          continue;
 803       }
 804       if (*JobIds != 0) {
 805          pm_strcat(JobIds, ",");
 806       }
 807       pm_strcat(JobIds, edit_int64(JobId, ed1));
 808       rx->TotalFiles += jr.JobFiles;
 809    }
 810    free_pool_memory(rx->JobIds);
 811    rx->JobIds = JobIds;               /* Set ACL filtered list */
 812    if (*rx->JobIds == 0) {
 813       ua->warning_msg(_("No Jobs selected.\n"));
 814       return 0;
 815    }
 816    if (strchr(rx->JobIds,',')) {
 817       ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
 818    } else {
 819       ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
 820    }
 821    return 1;
 822 }
 823
 824 /*
 825  * Get date from user
 826  */
 827 static int get_date(UAContext *ua, char *date, int date_len)
 828 {
 829    ua->send_msg(_("The restored files will the most current backup\n"
 830                   "BEFORE the date you specify below.\n\n"));
 831    for ( ;; ) {
 832       if (!get_cmd(ua, _("Enter date as YYYY-MM-DD HH:MM:SS :"))) {
 833          return 0;
 834       }
 835       if (str_to_utime(ua->cmd) != 0) {
 836          break;
 837       }
 838       ua->error_msg(_("Improper date format.\n"));
 839    }
 840    bstrncpy(date, ua->cmd, date_len);
 841    return 1;
 842 }
 843
 844 /*
 845  * Insert a single file, or read a list of files from a file
 846  */
 847 static void insert_one_file_or_dir(UAContext *ua, RESTORE_CTX *rx, char *date, bool dir)
 848 {
 849    FILE *ffd;
 850    char file[5000];
 851    char *p = ua->cmd;
 852    int line = 0;
 853
 854    switch (*p) {
 855    case '<':
 856       p++;
 857       if ((ffd = fopen(p, "rb")) == NULL) {
 858          berrno be;
 859          ua->error_msg(_("Cannot open file %s: ERR=%s\n"),
 860             p, be.bstrerror());
 861          break;
 862       }
 863       while (fgets(file, sizeof(file), ffd)) {
 864          line++;
 865          if (dir) {
 866             if (!insert_dir_into_findex_list(ua, rx, file, date)) {
 867                ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
 868             }
 869          } else {
 870             if (!insert_file_into_findex_list(ua, rx, file, date)) {
 871                ua->error_msg(_("Error occurred on line %d of file \"%s\"\n"), line, p);
 872             }
 873          }
 874       }
 875       fclose(ffd);
 876       break;
 877    case '?':
 878       p++;
 879       insert_table_into_findex_list(ua, rx, p);
 880       break;
 881    default:
 882       if (dir) {
 883          insert_dir_into_findex_list(ua, rx, ua->cmd, date);
 884       } else {
 885          insert_file_into_findex_list(ua, rx, ua->cmd, date);
 886       }
 887       break;
 888    }
 889 }
 890
 891 /*
 892  * For a given file (path+filename), split into path and file, then
 893  *   lookup the most recent backup in the catalog to get the JobId
 894  *   and FileIndex, then insert them into the findex list.
 895  */
 896 static bool insert_file_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *file,
 897                                         char *date)
 898 {
 899    strip_trailing_newline(file);
 900    split_path_and_filename(ua, rx, file);
 901    if (*rx->JobIds == 0) {
 902       Mmsg(rx->query, uar_jobid_fileindex, date, rx->path, rx->fname,
 903            rx->ClientName);
 904    } else {
 905       Mmsg(rx->query, uar_jobids_fileindex, rx->JobIds, date,
 906            rx->path, rx->fname, rx->ClientName);
 907    }
 908    rx->found = false;
 909    /* Find and insert jobid and File Index */
 910    if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
 911       ua->error_msg(_("Query failed: %s. ERR=%s\n"),
 912          rx->query, db_strerror(ua->db));
 913    }
 914    if (!rx->found) {
 915       ua->error_msg(_("No database record found for: %s\n"), file);
 916 //    ua->error_msg("Query=%s\n", rx->query);
 917       return true;
 918    }
 919    return true;
 920 }
 921
 922 /*
 923  * For a given path lookup the most recent backup in the catalog
 924  * to get the JobId and FileIndexes of all files in that directory.
 925  */
 926 static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
 927                                         char *date)
 928 {
 929    strip_trailing_junk(dir);
 930    if (*rx->JobIds == 0) {
 931       ua->error_msg(_("No JobId specified cannot continue.\n"));
 932       return false;
 933    } else {
 934       Mmsg(rx->query, uar_jobid_fileindex_from_dir[db_type], rx->JobIds, dir, rx->ClientName);
 935    }
 936    rx->found = false;
 937    /* Find and insert jobid and File Index */
 938    if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
 939       ua->error_msg(_("Query failed: %s. ERR=%s\n"),
 940          rx->query, db_strerror(ua->db));
 941    }
 942    if (!rx->found) {
 943       ua->error_msg(_("No database record found for: %s\n"), dir);
 944       return true;
 945    }
 946    return true;
 947 }
 948
 949 /*
 950  * Get the JobId and FileIndexes of all files in the specified table
 951  */
 952 static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table)
 953 {
 954    strip_trailing_junk(table);
 955    Mmsg(rx->query, uar_jobid_fileindex_from_table, table);
 956
 957    rx->found = false;
 958    /* Find and insert jobid and File Index */
 959    if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
 960       ua->error_msg(_("Query failed: %s. ERR=%s\n"),
 961          rx->query, db_strerror(ua->db));
 962    }
 963    if (!rx->found) {
 964       ua->error_msg(_("No table found: %s\n"), table);
 965       return true;
 966    }
 967    return true;
 968 }
 969
 970 static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
 971 {
 972    char *p, *f;
 973
 974    /* Find path without the filename.
 975     * I.e. everything after the last / is a "filename".
 976     * OK, maybe it is a directory name, but we treat it like
 977     * a filename. If we don't find a / then the whole name
 978     * must be a path name (e.g. c:).
 979     */
 980    for (p=f=name; *p; p++) {
 981       if (IsPathSeparator(*p)) {
 982          f = p;                       /* set pos of last slash */
 983       }
 984    }
 985    if (IsPathSeparator(*f)) {         /* did we find a slash? */
 986       f++;                            /* yes, point to filename */
 987    } else {                           /* no, whole thing must be path name */
 988       f = p;
 989    }
 990
 991    /* If filename doesn't exist (i.e. root directory), we
 992     * simply create a blank name consisting of a single
 993     * space. This makes handling zero length filenames
 994     * easier.
 995     */
 996    rx->fnl = p - f;
 997    if (rx->fnl > 0) {
 998       rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
 999       db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
1000    } else {
1001       rx->fname[0] = 0;
1002       rx->fnl = 0;
1003    }
1004
1005    rx->pnl = f - name;
1006    if (rx->pnl > 0) {
1007       rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
1008       db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
1009    } else {
1010       rx->path[0] = 0;
1011       rx->pnl = 0;
1012    }
1013
1014    Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
1015 }
1016
1017 static bool ask_for_fileregex(UAContext *ua, RESTORE_CTX *rx)
1018 {
1019    if (find_arg(ua, NT_("all")) >= 0) {  /* if user enters all on command line */
1020       return true;                       /* select everything */
1021    }
1022    ua->send_msg(_("\n\nFor one or more of the JobIds selected, no files were found,\n"
1023                  "so file selection is not possible.\n"
1024                  "Most likely your retention policy pruned the files.\n"));
1025    if (get_yesno(ua, _("\nDo you want to restore all the files? (yes|no): "))) {
1026       if (ua->pint32_val == 1)
1027          return true;
1028       while (get_cmd(ua, _("\nRegexp matching files to restore? (empty to abort): "))) {
1029          if (ua->cmd[0] == '\0') {
1030             break;
1031          } else {
1032             regex_t *fileregex_re = NULL;
1033             int rc;
1034             char errmsg[500] = "";
1035
1036             fileregex_re = (regex_t *)bmalloc(sizeof(regex_t));
1037             rc = regcomp(fileregex_re, ua->cmd, REG_EXTENDED|REG_NOSUB);
1038             if (rc != 0) {
1039                regerror(rc, fileregex_re, errmsg, sizeof(errmsg));
1040             }
1041             regfree(fileregex_re);
1042             free(fileregex_re);
1043             if (*errmsg) {
1044                ua->send_msg(_("Regex compile error: %s\n"), errmsg);
1045             } else {
1046                rx->bsr->fileregex = bstrdup(ua->cmd);
1047                return true;
1048             }
1049          }
1050       }
1051    }
1052    return false;
1053 }
1054
1055 static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx)
1056 {
1057    TREE_CTX tree;
1058    JobId_t JobId, last_JobId;
1059    char *p;
1060    bool OK = true;
1061    char ed1[50];
1062
1063    memset(&tree, 0, sizeof(TREE_CTX));
1064    /*
1065     * Build the directory tree containing JobIds user selected
1066     */
1067    tree.root = new_tree(rx->TotalFiles);
1068    tree.ua = ua;
1069    tree.all = rx->all;
1070    last_JobId = 0;
1071    /*
1072     * For display purposes, the same JobId, with different volumes may
1073     * appear more than once, however, we only insert it once.
1074     */
1075    p = rx->JobIds;
1076    tree.FileEstimate = 0;
1077    if (get_next_jobid_from_list(&p, &JobId) > 0) {
1078       /* Use first JobId as estimate of the number of files to restore */
1079       Mmsg(rx->query, uar_count_files, edit_int64(JobId, ed1));
1080       if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1081          ua->error_msg("%s\n", db_strerror(ua->db));
1082       }
1083       if (rx->found) {
1084          /* Add about 25% more than this job for over estimate */
1085          tree.FileEstimate = rx->JobId + (rx->JobId >> 2);
1086          tree.DeltaCount = rx->JobId/50; /* print 50 ticks */
1087       }
1088    }
1089
1090    ua->info_msg(_("\nBuilding directory tree for JobId(s) %s ...  "),
1091                 rx->JobIds);
1092
1093 #define new_get_file_list
1094 #ifdef new_get_file_list
1095    if (!db_get_file_list(ua->jcr, ua->db, rx->JobIds, insert_tree_handler, (void *)&tree)) {
1096       ua->error_msg("%s", db_strerror(ua->db));
1097    }
1098 #else
1099    for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1100       char ed1[50];
1101
1102       if (JobId == last_JobId) {
1103          continue;                    /* eliminate duplicate JobIds */
1104       }
1105       last_JobId = JobId;
1106       /*
1107        * Find files for this JobId and insert them in the tree
1108        */
1109       Mmsg(rx->query, uar_sel_files, edit_int64(JobId, ed1));
1110       if (!db_sql_query(ua->db, rx->query, insert_tree_handler, (void *)&tree)) {
1111          ua->error_msg("%s", db_strerror(ua->db));
1112       }
1113    }
1114 #endif
1115    /*
1116     * Look at the first JobId on the list (presumably the oldest) and
1117     *  if it is marked purged, don't do the manual selection because
1118     *  the Job was pruned, so the tree is incomplete.
1119     */
1120    if (tree.FileCount != 0) {
1121       /* Find out if any Job is purged */
1122       Mmsg(rx->query, "SELECT SUM(PurgedFiles) FROM Job WHERE JobId IN (%s)", rx->JobIds);
1123       if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
1124          ua->error_msg("%s\n", db_strerror(ua->db));
1125       }
1126       /* rx->JobId is the PurgedFiles flag */
1127       if (rx->found && rx->JobId > 0) {
1128          tree.FileCount = 0;           /* set count to zero, no tree selection */
1129       }
1130    }
1131    if (tree.FileCount == 0) {
1132       OK = ask_for_fileregex(ua, rx);
1133       if (OK) {
1134          last_JobId = 0;
1135          for (p=rx->JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
1136              if (JobId == last_JobId) {
1137                 continue;                    /* eliminate duplicate JobIds */
1138              }
1139              add_findex_all(rx->bsr, JobId);
1140          }
1141       }
1142    } else {
1143       char ec1[50];
1144       if (tree.all) {
1145          ua->info_msg(_("\n%s files inserted into the tree and marked for extraction.\n"),
1146                       edit_uint64_with_commas(tree.FileCount, ec1));
1147       } else {
1148          ua->info_msg(_("\n%s files inserted into the tree.\n"),
1149                       edit_uint64_with_commas(tree.FileCount, ec1));
1150       }
1151
1152       if (find_arg(ua, NT_("done")) < 0) {
1153          /* Let the user interact in selecting which files to restore */
1154          OK = user_select_files_from_tree(&tree);
1155       }
1156
1157       /*
1158        * Walk down through the tree finding all files marked to be
1159        *  extracted making a bootstrap file.
1160        */
1161       if (OK) {
1162          for (TREE_NODE *node=first_tree_node(tree.root); node; node=next_tree_node(node)) {
1163             Dmsg2(400, "FI=%d node=0x%x\n", node->FileIndex, node);
1164             if (node->extract || node->extract_dir) {
1165                Dmsg2(400, "type=%d FI=%d\n", node->type, node->FileIndex);
1166                add_findex(rx->bsr, node->JobId, node->FileIndex);
1167                if (node->extract && node->type != TN_NEWDIR) {
1168                   rx->selected_files++;  /* count only saved files */
1169                }
1170             }
1171          }
1172       }
1173    }
1174
1175    free_tree(tree.root);              /* free the directory tree */
1176    return OK;
1177 }
1178
1179
1180 /*
1181  * This routine is used to get the current backup or a backup
1182  *   before the specified date.
1183  */
1184 static bool select_backups_before_date(UAContext *ua, RESTORE_CTX *rx, char *date)
1185 {
1186    bool ok = false;
1187    FILESET_DBR fsr;
1188    CLIENT_DBR cr;
1189    char fileset_name[MAX_NAME_LENGTH];
1190    char ed1[50], ed2[50];
1191    char pool_select[MAX_NAME_LENGTH];
1192    int i;
1193
1194    /* Create temp tables */
1195    db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1196    db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1197    if (!db_sql_query(ua->db, uar_create_temp[db_type], NULL, NULL)) {
1198       ua->error_msg("%s\n", db_strerror(ua->db));
1199    }
1200    if (!db_sql_query(ua->db, uar_create_temp1[db_type], NULL, NULL)) {
1201       ua->error_msg("%s\n", db_strerror(ua->db));
1202    }
1203    /*
1204     * Select Client from the Catalog
1205     */
1206    memset(&cr, 0, sizeof(cr));
1207    if (!get_client_dbr(ua, &cr)) {
1208       goto bail_out;
1209    }
1210    bstrncpy(rx->ClientName, cr.Name, sizeof(rx->ClientName));
1211
1212    /*
1213     * Get FileSet
1214     */
1215    memset(&fsr, 0, sizeof(fsr));
1216    i = find_arg_with_value(ua, "FileSet");
1217    if (i >= 0) {
1218       bstrncpy(fsr.FileSet, ua->argv[i], sizeof(fsr.FileSet));
1219       if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1220          ua->error_msg(_("Error getting FileSet \"%s\": ERR=%s\n"), fsr.FileSet,
1221             db_strerror(ua->db));
1222          i = -1;
1223       }
1224    }
1225    if (i < 0) {                       /* fileset not found */
1226       edit_int64(cr.ClientId, ed1);
1227       Mmsg(rx->query, uar_sel_fileset, ed1, ed1);
1228       start_prompt(ua, _("The defined FileSet resources are:\n"));
1229       if (!db_sql_query(ua->db, rx->query, fileset_handler, (void *)ua)) {
1230          ua->error_msg("%s\n", db_strerror(ua->db));
1231       }
1232       if (do_prompt(ua, _("FileSet"), _("Select FileSet resource"),
1233                  fileset_name, sizeof(fileset_name)) < 0) {
1234          ua->error_msg(_("No FileSet found for client \"%s\".\n"), cr.Name);
1235          goto bail_out;
1236       }
1237
1238       bstrncpy(fsr.FileSet, fileset_name, sizeof(fsr.FileSet));
1239       if (!db_get_fileset_record(ua->jcr, ua->db, &fsr)) {
1240          ua->warning_msg(_("Error getting FileSet record: %s\n"), db_strerror(ua->db));
1241          ua->send_msg(_("This probably means you modified the FileSet.\n"
1242                      "Continuing anyway.\n"));
1243       }
1244    }
1245
1246    /* If Pool specified, add PoolId specification */
1247    pool_select[0] = 0;
1248    if (rx->pool) {
1249       POOL_DBR pr;
1250       memset(&pr, 0, sizeof(pr));
1251       bstrncpy(pr.Name, rx->pool->name(), sizeof(pr.Name));
1252       if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
1253          bsnprintf(pool_select, sizeof(pool_select), "AND Media.PoolId=%s ",
1254             edit_int64(pr.PoolId, ed1));
1255       } else {
1256          ua->warning_msg(_("Pool \"%s\" not found, using any pool.\n"), pr.Name);
1257       }
1258    }
1259
1260    /* Find JobId of last Full backup for this client, fileset */
1261    edit_int64(cr.ClientId, ed1);
1262    Mmsg(rx->query, uar_last_full, ed1, ed1, date, fsr.FileSet,
1263          pool_select);
1264    if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1265       ua->error_msg("%s\n", db_strerror(ua->db));
1266       goto bail_out;
1267    }
1268
1269    /* Find all Volumes used by that JobId */
1270    if (!db_sql_query(ua->db, uar_full, NULL, NULL)) {
1271       ua->error_msg("%s\n", db_strerror(ua->db));
1272       goto bail_out;
1273    }
1274
1275    /* Note, this is needed because I don't seem to get the callback
1276     * from the call just above.
1277     */
1278    rx->JobTDate = 0;
1279    if (!db_sql_query(ua->db, uar_sel_all_temp1, last_full_handler, (void *)rx)) {
1280       ua->warning_msg("%s\n", db_strerror(ua->db));
1281    }
1282    if (rx->JobTDate == 0) {
1283       ua->error_msg(_("No Full backup before %s found.\n"), date);
1284       goto bail_out;
1285    }
1286
1287    /* Now find most recent Differental Job after Full save, if any */
1288    Mmsg(rx->query, uar_dif, edit_uint64(rx->JobTDate, ed1), date,
1289         edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1290    if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1291       ua->warning_msg("%s\n", db_strerror(ua->db));
1292    }
1293    /* Now update JobTDate to look into Differental, if any */
1294    rx->JobTDate = 0;
1295    if (!db_sql_query(ua->db, uar_sel_all_temp, last_full_handler, (void *)rx)) {
1296       ua->warning_msg("%s\n", db_strerror(ua->db));
1297    }
1298    if (rx->JobTDate == 0) {
1299       ua->error_msg(_("No Full backup before %s found.\n"), date);
1300       goto bail_out;
1301    }
1302
1303    /* Now find all Incremental Jobs after Full/dif save */
1304    Mmsg(rx->query, uar_inc, edit_uint64(rx->JobTDate, ed1), date,
1305         edit_int64(cr.ClientId, ed2), fsr.FileSet, pool_select);
1306    if (!db_sql_query(ua->db, rx->query, NULL, NULL)) {
1307       ua->warning_msg("%s\n", db_strerror(ua->db));
1308    }
1309
1310    /* Get the JobIds from that list */
1311    rx->JobIds[0] = 0;
1312    rx->last_jobid[0] = 0;
1313    if (!db_sql_query(ua->db, uar_sel_jobid_temp, jobid_handler, (void *)rx)) {
1314       ua->warning_msg("%s\n", db_strerror(ua->db));
1315    }
1316
1317    if (rx->JobIds[0] != 0) {
1318       if (find_arg(ua, NT_("copies")) > 0) {
1319          /* Display a list of all copies */
1320          db_list_copies_records(ua->jcr, ua->db, 0, rx->JobIds,
1321                                 prtit, ua, HORZ_LIST);
1322       }
1323       /* Display a list of Jobs selected for this restore */
1324       db_list_sql_query(ua->jcr, ua->db, uar_list_temp, prtit, ua, 1, HORZ_LIST);
1325       ok = true;
1326    } else {
1327       ua->warning_msg(_("No jobs found.\n"));
1328    }
1329
1330 bail_out:
1331    db_sql_query(ua->db, uar_del_temp, NULL, NULL);
1332    db_sql_query(ua->db, uar_del_temp1, NULL, NULL);
1333    return ok;
1334 }
1335
1336 static int restore_count_handler(void *ctx, int num_fields, char **row)
1337 {
1338    RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1339    rx->JobId = str_to_int64(row[0]);
1340    rx->found = true;
1341    return 0;
1342 }
1343
1344 /*
1345  * Callback handler to get JobId and FileIndex for files
1346  *   can insert more than one depending on the caller.
1347  */
1348 static int jobid_fileindex_handler(void *ctx, int num_fields, char **row)
1349 {
1350    RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1351
1352    Dmsg2(200, "JobId=%s FileIndex=%s\n", row[0], row[1]);
1353    rx->JobId = str_to_int64(row[0]);
1354    add_findex(rx->bsr, rx->JobId, str_to_int64(row[1]));
1355    rx->found = true;
1356    rx->selected_files++;
1357    return 0;
1358 }
1359
1360 /*
1361  * Callback handler make list of JobIds
1362  */
1363 static int jobid_handler(void *ctx, int num_fields, char **row)
1364 {
1365    RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1366
1367    if (strcmp(rx->last_jobid, row[0]) == 0) {
1368       return 0;                       /* duplicate id */
1369    }
1370    bstrncpy(rx->last_jobid, row[0], sizeof(rx->last_jobid));
1371    if (rx->JobIds[0] != 0) {
1372       pm_strcat(rx->JobIds, ",");
1373    }
1374    pm_strcat(rx->JobIds, row[0]);
1375    return 0;
1376 }
1377
1378
1379 /*
1380  * Callback handler to pickup last Full backup JobTDate
1381  */
1382 static int last_full_handler(void *ctx, int num_fields, char **row)
1383 {
1384    RESTORE_CTX *rx = (RESTORE_CTX *)ctx;
1385
1386    rx->JobTDate = str_to_int64(row[1]);
1387    return 0;
1388 }
1389
1390 /*
1391  * Callback handler build FileSet name prompt list
1392  */
1393 static int fileset_handler(void *ctx, int num_fields, char **row)
1394 {
1395    /* row[0] = FileSet (name) */
1396    if (row[0]) {
1397       add_prompt((UAContext *)ctx, row[0]);
1398    }
1399    return 0;
1400 }
1401
1402 /*
1403  * Free names in the list
1404  */
1405 static void free_name_list(NAME_LIST *name_list)
1406 {
1407    for (int i=0; i < name_list->num_ids; i++) {
1408       free(name_list->name[i]);
1409    }
1410    if (name_list->name) {
1411       free(name_list->name);
1412       name_list->name = NULL;
1413    }
1414    name_list->max_ids = 0;
1415    name_list->num_ids = 0;
1416 }
1417
1418 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType)
1419 {
1420    STORE *store;
1421
1422    if (rx.store) {
1423       Dmsg1(200, "Already have store=%s\n", rx.store->name());
1424       return;
1425    }
1426    /*
1427     * Try looking up Storage by name
1428     */
1429    LockRes();
1430    foreach_res(store, R_STORAGE) {
1431       if (strcmp(Storage, store->name()) == 0) {
1432          if (acl_access_ok(ua, Storage_ACL, store->name())) {
1433             rx.store = store;
1434          }
1435          break;
1436       }
1437    }
1438    UnlockRes();
1439
1440    if (rx.store) {
1441       /* Check if an explicit storage resource is given */
1442       store = NULL;
1443       int i = find_arg_with_value(ua, "storage");
1444       if (i > 0) {
1445          store = (STORE *)GetResWithName(R_STORAGE, ua->argv[i]);
1446          if (store && !acl_access_ok(ua, Storage_ACL, store->name())) {
1447             store = NULL;
1448          }
1449       }
1450       if (store && (store != rx.store)) {
1451          ua->info_msg(_("Warning default storage overridden by \"%s\" on command line.\n"),
1452             store->name());
1453          rx.store = store;
1454          Dmsg1(200, "Set store=%s\n", rx.store->name());
1455       }
1456       return;
1457    }
1458
1459    /* If no storage resource, try to find one from MediaType */
1460    if (!rx.store) {
1461       LockRes();
1462       foreach_res(store, R_STORAGE) {
1463          if (strcmp(MediaType, store->media_type) == 0) {
1464             if (acl_access_ok(ua, Storage_ACL, store->name())) {
1465                rx.store = store;
1466                Dmsg1(200, "Set store=%s\n", rx.store->name());
1467                ua->warning_msg(_("Storage \"%s\" not found, using Storage \"%s\" from MediaType \"%s\".\n"),
1468                   Storage, store->name(), MediaType);
1469             }
1470             UnlockRes();
1471             return;
1472          }
1473       }
1474       UnlockRes();
1475       ua->warning_msg(_("\nUnable to find Storage resource for\n"
1476          "MediaType \"%s\", needed by the Jobs you selected.\n"), MediaType);
1477    }
1478
1479    /* Take command line arg, or ask user if none */
1480    rx.store = get_storage_resource(ua, false /* don't use default */);
1481    if (rx.store) {
1482       Dmsg1(200, "Set store=%s\n", rx.store->name());
1483    }
1484
1485 }