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