git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/job.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 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 plus additions
  11    that are listed 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 John Walker.
  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  *  Bacula File Daemon Job processing
  30  *
  31  *    Kern Sibbald, October MM
  32  *
  33  *   Version $Id$
  34  *
  35  */
  36
  37 #include "bacula.h"
  38 #include "filed.h"
  39
  40 #if defined(WIN32_VSS)
  41 #include "vss.h"
  42
  43 static pthread_mutex_t vss_mutex = PTHREAD_MUTEX_INITIALIZER;
  44 static int enable_vss;
  45 #endif
  46
  47 extern CLIENT *me;                    /* our client resource */
  48
  49 /* Imported functions */
  50 extern int status_cmd(JCR *jcr);
  51 extern int qstatus_cmd(JCR *jcr);
  52
  53 /* Forward referenced functions */
  54 static int backup_cmd(JCR *jcr);
  55 static int bootstrap_cmd(JCR *jcr);
  56 static int cancel_cmd(JCR *jcr);
  57 static int setdebug_cmd(JCR *jcr);
  58 static int estimate_cmd(JCR *jcr);
  59 static int hello_cmd(JCR *jcr);
  60 static int job_cmd(JCR *jcr);
  61 static int fileset_cmd(JCR *jcr);
  62 static int level_cmd(JCR *jcr);
  63 static int verify_cmd(JCR *jcr);
  64 static int restore_cmd(JCR *jcr);
  65 static int storage_cmd(JCR *jcr);
  66 static int session_cmd(JCR *jcr);
  67 static int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd);
  68 static void filed_free_jcr(JCR *jcr);
  69 static int open_sd_read_session(JCR *jcr);
  70 static int send_bootstrap_file(JCR *jcr);
  71 static int runscript_cmd(JCR *jcr);
  72 static int runbefore_cmd(JCR *jcr);
  73 static int runafter_cmd(JCR *jcr);
  74 static int runbeforenow_cmd(JCR *jcr);
  75 static void set_options(findFOPTS *fo, const char *opts);
  76
  77
  78 /* Exported functions */
  79
  80 struct s_cmds {
  81    const char *cmd;
  82    int (*func)(JCR *);
  83    int monitoraccess; /* specify if monitors have access to this function */
  84 };
  85
  86 /*
  87  * The following are the recognized commands from the Director.
  88  */
  89 static struct s_cmds cmds[] = {
  90    {"backup",       backup_cmd,    0},
  91    {"cancel",       cancel_cmd,    0},
  92    {"setdebug=",    setdebug_cmd,  0},
  93    {"estimate",     estimate_cmd,  0},
  94    {"Hello",        hello_cmd,     1},
  95    {"fileset",      fileset_cmd,   0},
  96    {"JobId=",       job_cmd,       0},
  97    {"level = ",     level_cmd,     0},
  98    {"restore",      restore_cmd,   0},
  99    {"session",      session_cmd,   0},
 100    {"status",       status_cmd,    1},
 101    {".status",      qstatus_cmd,   1},
 102    {"storage ",     storage_cmd,   0},
 103    {"verify",       verify_cmd,    0},
 104    {"bootstrap",    bootstrap_cmd, 0},
 105    {"RunBeforeNow", runbeforenow_cmd, 0},
 106    {"RunBeforeJob", runbefore_cmd, 0},
 107    {"RunAfterJob",  runafter_cmd,  0},
 108    {"Run",          runscript_cmd, 0},
 109    {NULL,       NULL}                  /* list terminator */
 110 };
 111
 112 /* Commands received from director that need scanning */
 113 static char jobcmd[]      = "JobId=%d Job=%127s SDid=%d SDtime=%d Authorization=%100s";
 114 static char storaddr[]    = "storage address=%s port=%d ssl=%d";
 115 static char sessioncmd[]  = "session %127s %ld %ld %ld %ld %ld %ld\n";
 116 static char restorecmd[]  = "restore replace=%c prelinks=%d where=%s\n";
 117 static char restorecmd1[] = "restore replace=%c prelinks=%d where=\n";
 118 static char restorecmdR[] = "restore replace=%c prelinks=%d regexwhere=%s\n";
 119 static char verifycmd[]   = "verify level=%30s";
 120 static char estimatecmd[] = "estimate listing=%d";
 121 static char runbefore[]   = "RunBeforeJob %s";
 122 static char runafter[]    = "RunAfterJob %s";
 123 static char runscript[]   = "Run OnSuccess=%d OnFailure=%d AbortOnError=%d When=%d Command=%s";
 124
 125 /* Responses sent to Director */
 126 static char errmsg[]      = "2999 Invalid command\n";
 127 static char no_auth[]     = "2998 No Authorization\n";
 128 static char invalid_cmd[] = "2997 Invalid command for a Director with Monitor directive enabled.\n";
 129 static char OKinc[]       = "2000 OK include\n";
 130 static char OKest[]       = "2000 OK estimate files=%u bytes=%s\n";
 131 static char OKlevel[]     = "2000 OK level\n";
 132 static char OKbackup[]    = "2000 OK backup\n";
 133 static char OKbootstrap[] = "2000 OK bootstrap\n";
 134 static char OKverify[]    = "2000 OK verify\n";
 135 static char OKrestore[]   = "2000 OK restore\n";
 136 static char OKsession[]   = "2000 OK session\n";
 137 static char OKstore[]     = "2000 OK storage\n";
 138 static char OKjob[]       = "2000 OK Job %s (%s) %s,%s,%s";
 139 static char OKsetdebug[]  = "2000 OK setdebug=%d\n";
 140 static char BADjob[]      = "2901 Bad Job\n";
 141 static char EndJob[]      = "2800 End Job TermCode=%d JobFiles=%u ReadBytes=%s"
 142                             " JobBytes=%s Errors=%u VSS=%d Encrypt=%d\n";
 143 static char OKRunBefore[] = "2000 OK RunBefore\n";
 144 static char OKRunBeforeNow[] = "2000 OK RunBeforeNow\n";
 145 static char OKRunAfter[]  = "2000 OK RunAfter\n";
 146 static char OKRunScript[] = "2000 OK RunScript\n";
 147
 148
 149 /* Responses received from Storage Daemon */
 150 static char OK_end[]       = "3000 OK end\n";
 151 static char OK_close[]     = "3000 OK close Status = %d\n";
 152 static char OK_open[]      = "3000 OK open ticket = %d\n";
 153 static char OK_data[]      = "3000 OK data\n";
 154 static char OK_append[]    = "3000 OK append data\n";
 155 static char OKSDbootstrap[]= "3000 OK bootstrap\n";
 156
 157
 158 /* Commands sent to Storage Daemon */
 159 static char append_open[]  = "append open session\n";
 160 static char append_data[]  = "append data %d\n";
 161 static char append_end[]   = "append end session %d\n";
 162 static char append_close[] = "append close session %d\n";
 163 static char read_open[]    = "read open session = %s %ld %ld %ld %ld %ld %ld\n";
 164 static char read_data[]    = "read data %d\n";
 165 static char read_close[]   = "read close session %d\n";
 166
 167 /*
 168  * Accept requests from a Director
 169  *
 170  * NOTE! We are running as a separate thread
 171  *
 172  * Send output one line
 173  * at a time followed by a zero length transmission.
 174  *
 175  * Return when the connection is terminated or there
 176  * is an error.
 177  *
 178  * Basic task here is:
 179  *   Authenticate Director (during Hello command).
 180  *   Accept commands one at a time from the Director
 181  *     and execute them.
 182  *
 183  * Concerning ClientRunBefore/After, the sequence of events
 184  * is rather critical. If they are not done in the right
 185  * order one can easily get FD->SD timeouts if the script
 186  * runs a long time.
 187  *
 188  * The current sequence of events is:
 189  *  1. Dir starts job with FD
 190  *  2. Dir connects to SD
 191  *  3. Dir connects to FD
 192  *  4. FD connects to SD
 193  *  5. FD gets/runs ClientRunBeforeJob and sends ClientRunAfterJob
 194  *  6. Dir sends include/exclude
 195  *  7. FD sends data to SD
 196  *  8. SD/FD disconnects while SD despools data and attributes (optionnal)
 197  *  9. FD runs ClientRunAfterJob
 198  */
 199
 200 void *handle_client_request(void *dirp)
 201 {
 202    int i;
 203    bool found, quit;
 204    JCR *jcr;
 205    BSOCK *dir = (BSOCK *)dirp;
 206
 207    jcr = new_jcr(sizeof(JCR), filed_free_jcr); /* create JCR */
 208    jcr->dir_bsock = dir;
 209    jcr->ff = init_find_files();
 210    jcr->start_time = time(NULL);
 211    jcr->RunScripts = New(alist(10, not_owned_by_alist));
 212    jcr->last_fname = get_pool_memory(PM_FNAME);
 213    jcr->last_fname[0] = 0;
 214    jcr->client_name = get_memory(strlen(my_name) + 1);
 215    pm_strcpy(jcr->client_name, my_name);
 216    jcr->pki_sign = me->pki_sign;
 217    jcr->pki_encrypt = me->pki_encrypt;
 218    jcr->pki_keypair = me->pki_keypair;
 219    jcr->pki_signers = me->pki_signers;
 220    jcr->pki_recipients = me->pki_recipients;
 221    dir->set_jcr(jcr);
 222    enable_backup_privileges(NULL, 1 /* ignore_errors */);
 223
 224    /**********FIXME******* add command handler error code */
 225
 226    for (quit=false; !quit;) {
 227
 228       /* Read command */
 229       if (bnet_recv(dir) < 0) {
 230          break;               /* connection terminated */
 231       }
 232       dir->msg[dir->msglen] = 0;
 233       Dmsg1(100, "<dird: %s", dir->msg);
 234       found = false;
 235       for (i=0; cmds[i].cmd; i++) {
 236          if (strncmp(cmds[i].cmd, dir->msg, strlen(cmds[i].cmd)) == 0) {
 237             found = true;         /* indicate command found */
 238             if (!jcr->authenticated && cmds[i].func != hello_cmd) {
 239                bnet_fsend(dir, no_auth);
 240                bnet_sig(dir, BNET_EOD);
 241                break;
 242             }
 243             if ((jcr->authenticated) && (!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 244                Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
 245                bnet_fsend(dir, invalid_cmd);
 246                bnet_sig(dir, BNET_EOD);
 247                break;
 248             }
 249             Dmsg1(100, "Executing %s command.\n", cmds[i].cmd);
 250             if (!cmds[i].func(jcr)) {         /* do command */
 251                quit = true;         /* error or fully terminated, get out */
 252                Dmsg1(20, "Quit command loop. Canceled=%d\n", job_canceled(jcr));
 253             }
 254             break;
 255          }
 256       }
 257       if (!found) {              /* command not found */
 258          bnet_fsend(dir, errmsg);
 259          quit = true;
 260          break;
 261       }
 262    }
 263
 264    /* Inform Storage daemon that we are done */
 265    if (jcr->store_bsock) {
 266       bnet_sig(jcr->store_bsock, BNET_TERMINATE);
 267    }
 268
 269    /* Run the after job */
 270    run_scripts(jcr, jcr->RunScripts, "ClientAfterJob");
 271
 272    generate_daemon_event(jcr, "JobEnd");
 273
 274    dequeue_messages(jcr);             /* send any queued messages */
 275
 276    /* Inform Director that we are done */
 277    bnet_sig(dir, BNET_TERMINATE);
 278
 279    /* Clean up fileset */
 280    FF_PKT *ff = jcr->ff;
 281    findFILESET *fileset = ff->fileset;
 282    if (fileset) {
 283       int i, j, k;
 284       /* Delete FileSet Include lists */
 285       for (i=0; i<fileset->include_list.size(); i++) {
 286          findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
 287          for (j=0; j<incexe->opts_list.size(); j++) {
 288             findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 289             for (k=0; k<fo->regex.size(); k++) {
 290                regfree((regex_t *)fo->regex.get(k));
 291             }
 292             fo->regex.destroy();
 293             fo->regexdir.destroy();
 294             fo->regexfile.destroy();
 295             fo->wild.destroy();
 296             fo->wilddir.destroy();
 297             fo->wildfile.destroy();
 298             fo->wildbase.destroy();
 299             fo->base.destroy();
 300             fo->fstype.destroy();
 301             fo->drivetype.destroy();
 302             if (fo->reader) {
 303                free(fo->reader);
 304             }
 305             if (fo->writer) {
 306                free(fo->writer);
 307             }
 308          }
 309          incexe->opts_list.destroy();
 310          incexe->name_list.destroy();
 311       }
 312       fileset->include_list.destroy();
 313
 314       /* Delete FileSet Exclude lists */
 315       for (i=0; i<fileset->exclude_list.size(); i++) {
 316          findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
 317          for (j=0; j<incexe->opts_list.size(); j++) {
 318             findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 319             fo->regex.destroy();
 320             fo->regexdir.destroy();
 321             fo->regexfile.destroy();
 322             fo->wild.destroy();
 323             fo->wilddir.destroy();
 324             fo->wildfile.destroy();
 325             fo->wildbase.destroy();
 326             fo->base.destroy();
 327             fo->fstype.destroy();
 328             fo->drivetype.destroy();
 329          }
 330          incexe->opts_list.destroy();
 331          incexe->name_list.destroy();
 332       }
 333       fileset->exclude_list.destroy();
 334       free(fileset);
 335    }
 336    ff->fileset = NULL;
 337    Dmsg0(100, "Calling term_find_files\n");
 338    term_find_files(jcr->ff);
 339    jcr->ff = NULL;
 340    Dmsg0(100, "Done with term_find_files\n");
 341    free_jcr(jcr);                     /* destroy JCR record */
 342    Dmsg0(100, "Done with free_jcr\n");
 343    Dsm_check(1);
 344    return NULL;
 345 }
 346
 347 /*
 348  * Hello from Director he must identify himself and provide his
 349  *  password.
 350  */
 351 static int hello_cmd(JCR *jcr)
 352 {
 353    Dmsg0(120, "Calling Authenticate\n");
 354    if (!authenticate_director(jcr)) {
 355       return 0;
 356    }
 357    Dmsg0(120, "OK Authenticate\n");
 358    jcr->authenticated = true;
 359    return 1;
 360 }
 361
 362 /*
 363  * Cancel a Job
 364  */
 365 static int cancel_cmd(JCR *jcr)
 366 {
 367    BSOCK *dir = jcr->dir_bsock;
 368    char Job[MAX_NAME_LENGTH];
 369    JCR *cjcr;
 370
 371    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 372       if (!(cjcr=get_jcr_by_full_name(Job))) {
 373          bnet_fsend(dir, _("2901 Job %s not found.\n"), Job);
 374       } else {
 375          if (cjcr->store_bsock) {
 376             cjcr->store_bsock->m_timed_out = 1;
 377             cjcr->store_bsock->m_terminated = 1;
 378             pthread_kill(cjcr->my_thread_id, TIMEOUT_SIGNAL);
 379          }
 380          set_jcr_job_status(cjcr, JS_Canceled);
 381          free_jcr(cjcr);
 382          bnet_fsend(dir, _("2001 Job %s marked to be canceled.\n"), Job);
 383       }
 384    } else {
 385       bnet_fsend(dir, _("2902 Error scanning cancel command.\n"));
 386    }
 387    bnet_sig(dir, BNET_EOD);
 388    return 1;
 389 }
 390
 391
 392 /*
 393  * Set debug level as requested by the Director
 394  *
 395  */
 396 static int setdebug_cmd(JCR *jcr)
 397 {
 398    BSOCK *dir = jcr->dir_bsock;
 399    int level, trace_flag;
 400
 401    Dmsg1(110, "setdebug_cmd: %s", dir->msg);
 402    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 403       pm_strcpy(jcr->errmsg, dir->msg);
 404       bnet_fsend(dir, _("2991 Bad setdebug command: %s\n"), jcr->errmsg);
 405       return 0;
 406    }
 407    debug_level = level;
 408    set_trace(trace_flag);
 409    return bnet_fsend(dir, OKsetdebug, level);
 410 }
 411
 412
 413 static int estimate_cmd(JCR *jcr)
 414 {
 415    BSOCK *dir = jcr->dir_bsock;
 416    char ed2[50];
 417
 418    if (sscanf(dir->msg, estimatecmd, &jcr->listing) != 1) {
 419       pm_strcpy(jcr->errmsg, dir->msg);
 420       Jmsg(jcr, M_FATAL, 0, _("Bad estimate command: %s"), jcr->errmsg);
 421       bnet_fsend(dir, _("2992 Bad estimate command.\n"));
 422       return 0;
 423    }
 424    make_estimate(jcr);
 425    bnet_fsend(dir, OKest, jcr->num_files_examined,
 426       edit_uint64_with_commas(jcr->JobBytes, ed2));
 427    bnet_sig(dir, BNET_EOD);
 428    return 1;
 429 }
 430
 431 /*
 432  * Get JobId and Storage Daemon Authorization key from Director
 433  */
 434 static int job_cmd(JCR *jcr)
 435 {
 436    BSOCK *dir = jcr->dir_bsock;
 437    POOLMEM *sd_auth_key;
 438
 439    sd_auth_key = get_memory(dir->msglen);
 440    if (sscanf(dir->msg, jobcmd,  &jcr->JobId, jcr->Job,
 441               &jcr->VolSessionId, &jcr->VolSessionTime,
 442               sd_auth_key) != 5) {
 443       pm_strcpy(jcr->errmsg, dir->msg);
 444       Jmsg(jcr, M_FATAL, 0, _("Bad Job Command: %s"), jcr->errmsg);
 445       bnet_fsend(dir, BADjob);
 446       free_pool_memory(sd_auth_key);
 447       return 0;
 448    }
 449    jcr->sd_auth_key = bstrdup(sd_auth_key);
 450    free_pool_memory(sd_auth_key);
 451    Dmsg2(120, "JobId=%d Auth=%s\n", jcr->JobId, jcr->sd_auth_key);
 452    return bnet_fsend(dir, OKjob, VERSION, LSMDATE, HOST_OS, DISTNAME, DISTVER);
 453 }
 454
 455 static int runbefore_cmd(JCR *jcr)
 456 {
 457    bool ok;
 458    BSOCK *dir = jcr->dir_bsock;
 459    POOLMEM *cmd = get_memory(dir->msglen+1);
 460    RUNSCRIPT *script;
 461
 462    Dmsg1(100, "runbefore_cmd: %s", dir->msg);
 463    if (sscanf(dir->msg, runbefore, cmd) != 1) {
 464       pm_strcpy(jcr->errmsg, dir->msg);
 465       Jmsg1(jcr, M_FATAL, 0, _("Bad RunBeforeJob command: %s\n"), jcr->errmsg);
 466       bnet_fsend(dir, _("2905 Bad RunBeforeJob command.\n"));
 467       free_memory(cmd);
 468       return 0;
 469    }
 470    unbash_spaces(cmd);
 471
 472    /* Run the command now */
 473    script = new_runscript();
 474    script->set_command(cmd);
 475    script->when = SCRIPT_Before;
 476    ok = script->run(jcr, "ClientRunBeforeJob");
 477    free_runscript(script);
 478
 479    free_memory(cmd);
 480    if (ok) {
 481       bnet_fsend(dir, OKRunBefore);
 482       return 1;
 483    } else {
 484       bnet_fsend(dir, _("2905 Bad RunBeforeJob command.\n"));
 485       return 0;
 486    }
 487 }
 488
 489 static int runbeforenow_cmd(JCR *jcr)
 490 {
 491    BSOCK *dir = jcr->dir_bsock;
 492
 493    run_scripts(jcr, jcr->RunScripts, "ClientBeforeJob");
 494    if (job_canceled(jcr)) {
 495       return  bnet_fsend(dir, _("2905 Bad RunBeforeNow command.\n"));
 496    } else {
 497       return  bnet_fsend(dir, OKRunBeforeNow);
 498    }
 499 }
 500
 501 static int runafter_cmd(JCR *jcr)
 502 {
 503    BSOCK *dir = jcr->dir_bsock;
 504    POOLMEM *msg = get_memory(dir->msglen+1);
 505    RUNSCRIPT *cmd;
 506
 507    Dmsg1(100, "runafter_cmd: %s", dir->msg);
 508    if (sscanf(dir->msg, runafter, msg) != 1) {
 509       pm_strcpy(jcr->errmsg, dir->msg);
 510       Jmsg1(jcr, M_FATAL, 0, _("Bad RunAfter command: %s\n"), jcr->errmsg);
 511       bnet_fsend(dir, _("2905 Bad RunAfterJob command.\n"));
 512       free_memory(msg);
 513       return 0;
 514    }
 515    unbash_spaces(msg);
 516
 517    cmd = new_runscript();
 518    cmd->set_command(msg);
 519    cmd->on_success = true;
 520    cmd->on_failure = false;
 521    cmd->when = SCRIPT_After;
 522
 523    jcr->RunScripts->append(cmd);
 524
 525    free_pool_memory(msg);
 526    return bnet_fsend(dir, OKRunAfter);
 527 }
 528
 529 static int runscript_cmd(JCR *jcr)
 530 {
 531    BSOCK *dir = jcr->dir_bsock;
 532    POOLMEM *msg = get_memory(dir->msglen+1);
 533    int on_success, on_failure, abort_on_error;
 534
 535    RUNSCRIPT *cmd = new_runscript() ;
 536
 537    Dmsg1(100, "runscript_cmd: '%s'\n", dir->msg);
 538    /* Note, we cannot sscanf into bools */
 539    if (sscanf(dir->msg, runscript, &on_success,
 540                                   &on_failure,
 541                                   &abort_on_error,
 542                                   &cmd->when,
 543                                   msg) != 5) {
 544       pm_strcpy(jcr->errmsg, dir->msg);
 545       Jmsg1(jcr, M_FATAL, 0, _("Bad RunScript command: %s\n"), jcr->errmsg);
 546       bnet_fsend(dir, _("2905 Bad RunScript command.\n"));
 547       free_runscript(cmd);
 548       free_memory(msg);
 549       return 0;
 550    }
 551    cmd->on_success = on_success;
 552    cmd->on_failure = on_failure;
 553    cmd->abort_on_error = abort_on_error;
 554    unbash_spaces(msg);
 555
 556    cmd->set_command(msg);
 557    cmd->debug();
 558    jcr->RunScripts->append(cmd);
 559
 560    free_pool_memory(msg);
 561    return bnet_fsend(dir, OKRunScript);
 562 }
 563
 564
 565 static bool init_fileset(JCR *jcr)
 566 {
 567    FF_PKT *ff;
 568    findFILESET *fileset;
 569
 570    if (!jcr->ff) {
 571       return false;
 572    }
 573    ff = jcr->ff;
 574    if (ff->fileset) {
 575       return false;
 576    }
 577    fileset = (findFILESET *)malloc(sizeof(findFILESET));
 578    memset(fileset, 0, sizeof(findFILESET));
 579    ff->fileset = fileset;
 580    fileset->state = state_none;
 581    fileset->include_list.init(1, true);
 582    fileset->exclude_list.init(1, true);
 583    return true;
 584 }
 585
 586 static findFOPTS *start_options(FF_PKT *ff)
 587 {
 588    int state = ff->fileset->state;
 589    findINCEXE *incexe = ff->fileset->incexe;
 590
 591    if (state != state_options) {
 592       ff->fileset->state = state_options;
 593       findFOPTS *fo = (findFOPTS *)malloc(sizeof(findFOPTS));
 594       memset(fo, 0, sizeof(findFOPTS));
 595       fo->regex.init(1, true);
 596       fo->regexdir.init(1, true);
 597       fo->regexfile.init(1, true);
 598       fo->wild.init(1, true);
 599       fo->wilddir.init(1, true);
 600       fo->wildfile.init(1, true);
 601       fo->wildbase.init(1, true);
 602       fo->base.init(1, true);
 603       fo->fstype.init(1, true);
 604       fo->drivetype.init(1, true);
 605       incexe->current_opts = fo;
 606       incexe->opts_list.append(fo);
 607    }
 608    return incexe->current_opts;
 609
 610 }
 611
 612 /*
 613  * Add fname to include/exclude fileset list. First check for
 614  * | and < and if necessary perform command.
 615  */
 616 static void add_file_to_fileset(JCR *jcr, const char *fname, findFILESET *fileset)
 617 {
 618    char *p;
 619    BPIPE *bpipe;
 620    POOLMEM *fn;
 621    FILE *ffd;
 622    char buf[1000];
 623    int ch;
 624    int stat;
 625
 626    p = (char *)fname;
 627    ch = (uint8_t)*p;
 628    switch (ch) {
 629    case '|':
 630       p++;                            /* skip over | */
 631       fn = get_pool_memory(PM_FNAME);
 632       fn = edit_job_codes(jcr, fn, p, "");
 633       bpipe = open_bpipe(fn, 0, "r");
 634       if (!bpipe) {
 635          berrno be;
 636          Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
 637             p, be.bstrerror());
 638          free_pool_memory(fn);
 639          return;
 640       }
 641       free_pool_memory(fn);
 642       while (fgets(buf, sizeof(buf), bpipe->rfd)) {
 643          strip_trailing_junk(buf);
 644          fileset->incexe->name_list.append(new_dlistString(buf));
 645       }
 646       if ((stat=close_bpipe(bpipe)) != 0) {
 647          berrno be;
 648          Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. stat=%d: ERR=%s\n"),
 649             p, be.code(stat), be.bstrerror(stat));
 650          return;
 651       }
 652       break;
 653    case '<':
 654       Dmsg0(100, "Doing < include on client.\n");
 655       p++;                      /* skip over < */
 656       if ((ffd = fopen(p, "rb")) == NULL) {
 657          berrno be;
 658          Jmsg(jcr, M_FATAL, 0, _("Cannot open FileSet input file: %s. ERR=%s\n"),
 659             p, be.bstrerror());
 660          return;
 661       }
 662       while (fgets(buf, sizeof(buf), ffd)) {
 663          strip_trailing_junk(buf);
 664          Dmsg1(100, "%s\n", buf);
 665          fileset->incexe->name_list.append(new_dlistString(buf));
 666       }
 667       fclose(ffd);
 668       break;
 669    default:
 670       fileset->incexe->name_list.append(new_dlistString(fname));
 671       break;
 672    }
 673 }
 674
 675
 676 static void add_fileset(JCR *jcr, const char *item)
 677 {
 678    FF_PKT *ff = jcr->ff;
 679    findFILESET *fileset = ff->fileset;
 680    int state = fileset->state;
 681    findFOPTS *current_opts;
 682
 683    /* Get code, optional subcode, and position item past the dividing space */
 684    Dmsg1(100, "%s\n", item);
 685    int code = item[0];
 686    if (code != '\0') {
 687       ++item;
 688    }
 689    int subcode = ' ';               /* A space is always a valid subcode */
 690    if (item[0] != '\0' && item[0] != ' ') {
 691       subcode = item[0];
 692       ++item;
 693    }
 694    if (*item == ' ') {
 695       ++item;
 696    }
 697
 698    /* Skip all lines we receive after an error */
 699    if (state == state_error) {
 700       Dmsg0(100, "State=error return\n");
 701       return;
 702    }
 703
 704    /*
 705     * The switch tests the code for validity.
 706     * The subcode is always good if it is a space, otherwise we must confirm.
 707     * We set state to state_error first assuming the subcode is invalid,
 708     * requiring state to be set in cases below that handle subcodes.
 709     */
 710    if (subcode != ' ') {
 711       state = state_error;
 712       Dmsg0(100, "Set state=error\n");
 713    }
 714    switch (code) {
 715    case 'I':
 716       /* New include */
 717       fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
 718       memset(fileset->incexe, 0, sizeof(findINCEXE));
 719       fileset->incexe->opts_list.init(1, true);
 720       fileset->incexe->name_list.init(); /* for dlist;  was 1,true for alist */
 721       fileset->include_list.append(fileset->incexe);
 722       break;
 723    case 'E':
 724       /* New exclude */
 725       fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
 726       memset(fileset->incexe, 0, sizeof(findINCEXE));
 727       fileset->incexe->opts_list.init(1, true);
 728       fileset->incexe->name_list.init();
 729       fileset->exclude_list.append(fileset->incexe);
 730       break;
 731    case 'N':
 732       state = state_none;
 733       break;
 734    case 'F':
 735       /* File item to either include/include list */
 736       state = state_include;
 737       add_file_to_fileset(jcr, item, fileset);
 738       break;
 739    case 'R':
 740       current_opts = start_options(ff);
 741       regex_t *preg;
 742       int rc;
 743       char prbuf[500];
 744       preg = (regex_t *)malloc(sizeof(regex_t));
 745       if (current_opts->flags & FO_IGNORECASE) {
 746          rc = regcomp(preg, item, REG_EXTENDED|REG_ICASE);
 747       } else {
 748          rc = regcomp(preg, item, REG_EXTENDED);
 749       }
 750       if (rc != 0) {
 751          regerror(rc, preg, prbuf, sizeof(prbuf));
 752          regfree(preg);
 753          free(preg);
 754          Jmsg(jcr, M_FATAL, 0, _("REGEX %s compile error. ERR=%s\n"), item, prbuf);
 755          state = state_error;
 756          break;
 757       }
 758       state = state_options;
 759       if (subcode == ' ') {
 760          current_opts->regex.append(preg);
 761       } else if (subcode == 'D') {
 762          current_opts->regexdir.append(preg);
 763       } else if (subcode == 'F') {
 764          current_opts->regexfile.append(preg);
 765       } else {
 766          state = state_error;
 767       }
 768       break;
 769    case 'B':
 770       current_opts = start_options(ff);
 771       current_opts->base.append(bstrdup(item));
 772       state = state_options;
 773       break;
 774    case 'X':
 775       current_opts = start_options(ff);
 776       state = state_options;
 777       if (subcode == ' ') {
 778          current_opts->fstype.append(bstrdup(item));
 779       } else if (subcode == 'D') {
 780          current_opts->drivetype.append(bstrdup(item));
 781       } else {
 782          state = state_error;
 783       }
 784       break;
 785    case 'W':
 786       current_opts = start_options(ff);
 787       state = state_options;
 788       if (subcode == ' ') {
 789          current_opts->wild.append(bstrdup(item));
 790       } else if (subcode == 'D') {
 791          current_opts->wilddir.append(bstrdup(item));
 792       } else if (subcode == 'F') {
 793          current_opts->wildfile.append(bstrdup(item));
 794       } else if (subcode == 'B') {
 795          current_opts->wildbase.append(bstrdup(item));
 796       } else {
 797          state = state_error;
 798       }
 799       break;
 800    case 'O':
 801       current_opts = start_options(ff);
 802       set_options(current_opts, item);
 803       state = state_options;
 804       break;
 805    case 'D':
 806       current_opts = start_options(ff);
 807       current_opts->reader = bstrdup(item);
 808       state = state_options;
 809       break;
 810    case 'T':
 811       current_opts = start_options(ff);
 812       current_opts->writer = bstrdup(item);
 813       state = state_options;
 814       break;
 815    default:
 816       Jmsg(jcr, M_FATAL, 0, _("Invalid FileSet command: %s\n"), item);
 817       state = state_error;
 818       break;
 819    }
 820    ff->fileset->state = state;
 821 }
 822
 823 static bool term_fileset(JCR *jcr)
 824 {
 825    FF_PKT *ff = jcr->ff;
 826
 827 #ifdef xxx
 828    findFILESET *fileset = ff->fileset;
 829    int i, j, k;
 830
 831    for (i=0; i<fileset->include_list.size(); i++) {
 832       findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
 833       Dmsg0(400, "I\n");
 834       for (j=0; j<incexe->opts_list.size(); j++) {
 835          findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 836          for (k=0; k<fo->regex.size(); k++) {
 837             Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
 838          }
 839          for (k=0; k<fo->regexdir.size(); k++) {
 840             Dmsg1(400, "RD %s\n", (char *)fo->regexdir.get(k));
 841          }
 842          for (k=0; k<fo->regexfile.size(); k++) {
 843             Dmsg1(400, "RF %s\n", (char *)fo->regexfile.get(k));
 844          }
 845          for (k=0; k<fo->wild.size(); k++) {
 846             Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
 847          }
 848          for (k=0; k<fo->wilddir.size(); k++) {
 849             Dmsg1(400, "WD %s\n", (char *)fo->wilddir.get(k));
 850          }
 851          for (k=0; k<fo->wildfile.size(); k++) {
 852             Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k));
 853          }
 854          for (k=0; k<fo->wildbase.size(); k++) {
 855             Dmsg1(400, "WB %s\n", (char *)fo->wildbase.get(k));
 856          }
 857          for (k=0; k<fo->base.size(); k++) {
 858             Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
 859          }
 860          for (k=0; k<fo->fstype.size(); k++) {
 861             Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k));
 862          }
 863          for (k=0; k<fo->drivetype.size(); k++) {
 864             Dmsg1(400, "XD %s\n", (char *)fo->drivetype.get(k));
 865          }
 866          if (fo->reader) {
 867             Dmsg1(400, "D %s\n", fo->reader);
 868          }
 869          if (fo->writer) {
 870             Dmsg1(400, "T %s\n", fo->writer);
 871          }
 872       }
 873       dlistString *node;
 874       foreach_dlist(node, &incexe->name_list) {
 875          Dmsg1(400, "F %s\n", node->c_str());
 876       }
 877    }
 878    for (i=0; i<fileset->exclude_list.size(); i++) {
 879       findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
 880       Dmsg0(400, "E\n");
 881       for (j=0; j<incexe->opts_list.size(); j++) {
 882          findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 883          for (k=0; k<fo->regex.size(); k++) {
 884             Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
 885          }
 886          for (k=0; k<fo->regexdir.size(); k++) {
 887             Dmsg1(400, "RD %s\n", (char *)fo->regexdir.get(k));
 888          }
 889          for (k=0; k<fo->regexfile.size(); k++) {
 890             Dmsg1(400, "RF %s\n", (char *)fo->regexfile.get(k));
 891          }
 892          for (k=0; k<fo->wild.size(); k++) {
 893             Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
 894          }
 895          for (k=0; k<fo->wilddir.size(); k++) {
 896             Dmsg1(400, "WD %s\n", (char *)fo->wilddir.get(k));
 897          }
 898          for (k=0; k<fo->wildfile.size(); k++) {
 899             Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k));
 900          }
 901          for (k=0; k<fo->wildbase.size(); k++) {
 902             Dmsg1(400, "WB %s\n", (char *)fo->wildbase.get(k));
 903          }
 904          for (k=0; k<fo->base.size(); k++) {
 905             Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
 906          }
 907          for (k=0; k<fo->fstype.size(); k++) {
 908             Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k));
 909          }
 910          for (k=0; k<fo->drivetype.size(); k++) {
 911             Dmsg1(400, "XD %s\n", (char *)fo->drivetype.get(k));
 912          }
 913       }
 914       dlistString *node;
 915       foreach_dlist(node, incexe->name_list) {
 916          Dmsg1(400, "F %s\n", node->c_str());
 917       }
 918    }
 919 #endif
 920    return ff->fileset->state != state_error;
 921 }
 922
 923
 924 /*
 925  * As an optimization, we should do this during
 926  *  "compile" time in filed/job.c, and keep only a bit mask
 927  *  and the Verify options.
 928  */
 929 static void set_options(findFOPTS *fo, const char *opts)
 930 {
 931    int j;
 932    const char *p;
 933    char strip[100];
 934
 935    for (p=opts; *p; p++) {
 936       switch (*p) {
 937       case 'a':                 /* alway replace */
 938       case '0':                 /* no option */
 939          break;
 940       case 'e':
 941          fo->flags |= FO_EXCLUDE;
 942          break;
 943       case 'f':
 944          fo->flags |= FO_MULTIFS;
 945          break;
 946       case 'h':                 /* no recursion */
 947          fo->flags |= FO_NO_RECURSION;
 948          break;
 949       case 'H':                 /* no hard link handling */
 950          fo->flags |= FO_NO_HARDLINK;
 951          break;
 952       case 'i':
 953          fo->flags |= FO_IGNORECASE;
 954          break;
 955       case 'M':                 /* MD5 */
 956          fo->flags |= FO_MD5;
 957          break;
 958       case 'n':
 959          fo->flags |= FO_NOREPLACE;
 960          break;
 961       case 'p':                 /* use portable data format */
 962          fo->flags |= FO_PORTABLE;
 963          break;
 964       case 'R':                 /* Resource forks and Finder Info */
 965          fo->flags |= FO_HFSPLUS;
 966       case 'r':                 /* read fifo */
 967          fo->flags |= FO_READFIFO;
 968          break;
 969       case 'S':
 970          switch(*(p + 1)) {
 971          case '1':
 972             fo->flags |= FO_SHA1;
 973             p++;
 974             break;
 975 #ifdef HAVE_SHA2
 976          case '2':
 977             fo->flags |= FO_SHA256;
 978             p++;
 979             break;
 980          case '3':
 981             fo->flags |= FO_SHA512;
 982             p++;
 983             break;
 984 #endif
 985          default:
 986             /*
 987              * If 2 or 3 is seen here, SHA2 is not configured, so
 988              *  eat the option, and drop back to SHA-1.
 989              */
 990             if (p[1] == '2' || p[1] == '3') {
 991                p++;
 992             }
 993             fo->flags |= FO_SHA1;
 994             break;
 995          }
 996          break;
 997       case 's':
 998          fo->flags |= FO_SPARSE;
 999          break;
1000       case 'm':
1001          fo->flags |= FO_MTIMEONLY;
1002          break;
1003       case 'k':
1004          fo->flags |= FO_KEEPATIME;
1005          break;
1006       case 'A':
1007          fo->flags |= FO_ACL;
1008          break;
1009       case 'V':                  /* verify options */
1010          /* Copy Verify Options */
1011          for (j=0; *p && *p != ':'; p++) {
1012             fo->VerifyOpts[j] = *p;
1013             if (j < (int)sizeof(fo->VerifyOpts) - 1) {
1014                j++;
1015             }
1016          }
1017          fo->VerifyOpts[j] = 0;
1018          break;
1019       case 'P':                  /* strip path */
1020          /* Get integer */
1021          p++;                    /* skip P */
1022          for (j=0; *p && *p != ':'; p++) {
1023             strip[j] = *p;
1024             if (j < (int)sizeof(strip) - 1) {
1025                j++;
1026             }
1027          }
1028          strip[j] = 0;
1029          fo->strip_path = atoi(strip);
1030          fo->flags |= FO_STRIPPATH;
1031          Dmsg2(100, "strip=%s strip_path=%d\n", strip, fo->strip_path);
1032          break;
1033       case 'w':
1034          fo->flags |= FO_IF_NEWER;
1035          break;
1036       case 'W':
1037          fo->flags |= FO_ENHANCEDWILD;
1038          break;
1039       case 'Z':                 /* gzip compression */
1040          fo->flags |= FO_GZIP;
1041          fo->GZIP_level = *++p - '0';
1042          break;
1043       case 'K':
1044          fo->flags |= FO_NOATIME;
1045          break;
1046       case 'c':
1047          fo->flags |= FO_CHKCHANGES;
1048          break;
1049       default:
1050          Emsg1(M_ERROR, 0, _("Unknown include/exclude option: %c\n"), *p);
1051          break;
1052       }
1053    }
1054 }
1055
1056
1057 /*
1058  * Director is passing his Fileset
1059  */
1060 static int fileset_cmd(JCR *jcr)
1061 {
1062    BSOCK *dir = jcr->dir_bsock;
1063
1064 #if defined(WIN32_VSS)
1065    int vss = 0;
1066
1067    sscanf(dir->msg, "fileset vss=%d", &vss);
1068    enable_vss = vss;
1069 #endif
1070
1071    if (!init_fileset(jcr)) {
1072       return 0;
1073    }
1074    while (bnet_recv(dir) >= 0) {
1075       strip_trailing_junk(dir->msg);
1076       Dmsg1(500, "Fileset: %s\n", dir->msg);
1077       add_fileset(jcr, dir->msg);
1078    }
1079    if (!term_fileset(jcr)) {
1080       return 0;
1081    }
1082    return bnet_fsend(dir, OKinc);
1083 }
1084
1085 static void free_bootstrap(JCR *jcr)
1086 {
1087    if (jcr->RestoreBootstrap) {
1088       unlink(jcr->RestoreBootstrap);
1089       free_pool_memory(jcr->RestoreBootstrap);
1090       jcr->RestoreBootstrap = NULL;
1091    }
1092 }
1093
1094
1095 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
1096 static uint32_t bsr_uniq = 0;
1097
1098 /*
1099  * The Director sends us the bootstrap file, which
1100  *   we will in turn pass to the SD.
1101  */
1102 static int bootstrap_cmd(JCR *jcr)
1103 {
1104    BSOCK *dir = jcr->dir_bsock;
1105    POOLMEM *fname = get_pool_memory(PM_FNAME);
1106    FILE *bs;
1107
1108    free_bootstrap(jcr);
1109    P(bsr_mutex);
1110    bsr_uniq++;
1111    Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
1112       jcr->Job, bsr_uniq);
1113    V(bsr_mutex);
1114    Dmsg1(400, "bootstrap=%s\n", fname);
1115    jcr->RestoreBootstrap = fname;
1116    bs = fopen(fname, "a+b");           /* create file */
1117    if (!bs) {
1118       berrno be;
1119       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
1120          jcr->RestoreBootstrap, be.bstrerror());
1121       /*
1122        * Suck up what he is sending to us so that he will then
1123        *   read our error message.
1124        */
1125       while (bnet_recv(dir) >= 0)
1126         {  }
1127       free_bootstrap(jcr);
1128       set_jcr_job_status(jcr, JS_ErrorTerminated);
1129       return 0;
1130    }
1131
1132    while (bnet_recv(dir) >= 0) {
1133        Dmsg1(200, "filed<dird: bootstrap file %s\n", dir->msg);
1134        fputs(dir->msg, bs);
1135    }
1136    fclose(bs);
1137    /*
1138     * Note, do not free the bootstrap yet -- it needs to be
1139     *  sent to the SD
1140     */
1141    return bnet_fsend(dir, OKbootstrap);
1142 }
1143
1144
1145 /*
1146  * Get backup level from Director
1147  *
1148  */
1149 static int level_cmd(JCR *jcr)
1150 {
1151    BSOCK *dir = jcr->dir_bsock;
1152    POOLMEM *level, *buf = NULL;
1153    int mtime_only;
1154
1155    level = get_memory(dir->msglen+1);
1156    Dmsg1(110, "level_cmd: %s", dir->msg);
1157    if (sscanf(dir->msg, "level = %s ", level) != 1) {
1158       goto bail_out;
1159    }
1160    /* Base backup requested? */
1161    if (strcmp(level, "base") == 0) {
1162       jcr->JobLevel = L_BASE;
1163    /* Full backup requested? */
1164    } else if (strcmp(level, "full") == 0) {
1165       jcr->JobLevel = L_FULL;
1166    } else if (strcmp(level, "differential") == 0) {
1167       jcr->JobLevel = L_DIFFERENTIAL;
1168       free_memory(level);
1169       return 1;
1170    } else if (strcmp(level, "incremental") == 0) {
1171       jcr->JobLevel = L_INCREMENTAL;
1172       free_memory(level);
1173       return 1;
1174    /*
1175     * We get his UTC since time, then sync the clocks and correct it
1176     *   to agree with our clock.
1177     */
1178    } else if (strcmp(level, "since_utime") == 0) {
1179       buf = get_memory(dir->msglen+1);
1180       utime_t since_time, adj;
1181       btime_t his_time, bt_start, rt=0, bt_adj=0;
1182       if (jcr->JobLevel == L_NONE) {
1183          jcr->JobLevel = L_SINCE;     /* if no other job level set, do it now */
1184       }
1185       if (sscanf(dir->msg, "level = since_utime %s mtime_only=%d",
1186                  buf, &mtime_only) != 2) {
1187          goto bail_out;
1188       }
1189       since_time = str_to_uint64(buf);  /* this is the since time */
1190       Dmsg1(100, "since_time=%d\n", (int)since_time);
1191       char ed1[50], ed2[50];
1192       /*
1193        * Sync clocks by polling him for the time. We take
1194        *   10 samples of his time throwing out the first two.
1195        */
1196       for (int i=0; i<10; i++) {
1197          bt_start = get_current_btime();
1198          bnet_sig(dir, BNET_BTIME);   /* poll for time */
1199          if (bnet_recv(dir) <= 0) {   /* get response */
1200             goto bail_out;
1201          }
1202          if (sscanf(dir->msg, "btime %s", buf) != 1) {
1203             goto bail_out;
1204          }
1205          if (i < 2) {                 /* toss first two results */
1206             continue;
1207          }
1208          his_time = str_to_uint64(buf);
1209          rt = get_current_btime() - bt_start; /* compute round trip time */
1210          Dmsg2(100, "Dirtime=%s FDtime=%s\n", edit_uint64(his_time, ed1),
1211                edit_uint64(bt_start, ed2));
1212          bt_adj +=  bt_start - his_time - rt/2;
1213          Dmsg2(100, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
1214       }
1215
1216       bt_adj = bt_adj / 8;            /* compute average time */
1217       Dmsg2(100, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
1218       adj = btime_to_utime(bt_adj);
1219       since_time += adj;              /* adjust for clock difference */
1220       if (adj != 0) {
1221          int type;
1222          if (adj > 600 || adj < -600) {
1223             type = M_WARNING;
1224          } else {
1225             type = M_INFO;
1226          }
1227          Jmsg(jcr, type, 0, _("DIR and FD clocks differ by %d seconds, FD automatically adjusting.\n"), adj);
1228       }
1229       bnet_sig(dir, BNET_EOD);
1230
1231       Dmsg2(100, "adj = %d since_time=%d\n", (int)adj, (int)since_time);
1232       jcr->incremental = 1;           /* set incremental or decremental backup */
1233       jcr->mtime = (time_t)since_time; /* set since time */
1234    } else {
1235       Jmsg1(jcr, M_FATAL, 0, _("Unknown backup level: %s\n"), level);
1236       free_memory(level);
1237       return 0;
1238    }
1239    free_memory(level);
1240    if (buf) {
1241       free_memory(buf);
1242    }
1243    return bnet_fsend(dir, OKlevel);
1244
1245 bail_out:
1246    pm_strcpy(jcr->errmsg, dir->msg);
1247    Jmsg1(jcr, M_FATAL, 0, _("Bad level command: %s\n"), jcr->errmsg);
1248    free_memory(level);
1249    if (buf) {
1250       free_memory(buf);
1251    }
1252    return 0;
1253 }
1254
1255 /*
1256  * Get session parameters from Director -- this is for a Restore command
1257  */
1258 static int session_cmd(JCR *jcr)
1259 {
1260    BSOCK *dir = jcr->dir_bsock;
1261
1262    Dmsg1(100, "SessionCmd: %s", dir->msg);
1263    if (sscanf(dir->msg, sessioncmd, jcr->VolumeName,
1264               &jcr->VolSessionId, &jcr->VolSessionTime,
1265               &jcr->StartFile, &jcr->EndFile,
1266               &jcr->StartBlock, &jcr->EndBlock) != 7) {
1267       pm_strcpy(jcr->errmsg, dir->msg);
1268       Jmsg(jcr, M_FATAL, 0, _("Bad session command: %s"), jcr->errmsg);
1269       return 0;
1270    }
1271
1272    return bnet_fsend(dir, OKsession);
1273 }
1274
1275 /*
1276  * Get address of storage daemon from Director
1277  *
1278  */
1279 static int storage_cmd(JCR *jcr)
1280 {
1281    int stored_port;                /* storage daemon port */
1282    int enable_ssl;                 /* enable ssl to sd */
1283    BSOCK *dir = jcr->dir_bsock;
1284    BSOCK *sd;                         /* storage daemon bsock */
1285
1286    Dmsg1(100, "StorageCmd: %s", dir->msg);
1287    if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port, &enable_ssl) != 3) {
1288       pm_strcpy(jcr->errmsg, dir->msg);
1289       Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), jcr->errmsg);
1290       return 0;
1291    }
1292    Dmsg3(110, "Open storage: %s:%d ssl=%d\n", jcr->stored_addr, stored_port, enable_ssl);
1293    /* Open command communications with Storage daemon */
1294    /* Try to connect for 1 hour at 10 second intervals */
1295    sd = bnet_connect(jcr, 10, (int)me->SDConnectTimeout, me->heartbeat_interval,
1296                       _("Storage daemon"), jcr->stored_addr, NULL, stored_port, 1);
1297    if (sd == NULL) {
1298       Jmsg(jcr, M_FATAL, 0, _("Failed to connect to Storage daemon: %s:%d\n"),
1299           jcr->stored_addr, stored_port);
1300       Dmsg2(100, "Failed to connect to Storage daemon: %s:%d\n",
1301           jcr->stored_addr, stored_port);
1302       return 0;
1303    }
1304    Dmsg0(110, "Connection OK to SD.\n");
1305
1306    jcr->store_bsock = sd;
1307
1308    bnet_fsend(sd, "Hello Start Job %s\n", jcr->Job);
1309    if (!authenticate_storagedaemon(jcr)) {
1310       Jmsg(jcr, M_FATAL, 0, _("Failed to authenticate Storage daemon.\n"));
1311       return 0;
1312    }
1313    Dmsg0(110, "Authenticated with SD.\n");
1314
1315    /* Send OK to Director */
1316    return bnet_fsend(dir, OKstore);
1317 }
1318
1319
1320 /*
1321  * Do a backup.
1322  */
1323 static int backup_cmd(JCR *jcr)
1324 {
1325    BSOCK *dir = jcr->dir_bsock;
1326    BSOCK *sd = jcr->store_bsock;
1327    int ok = 0;
1328    int SDJobStatus;
1329    char ed1[50], ed2[50];
1330    bool bDoVSS = false;
1331
1332 #if defined(WIN32_VSS)
1333    // capture state here, if client is backed up by multiple directors
1334    // and one enables vss and the other does not then enable_vss can change
1335    // between here and where its evaluated after the job completes.
1336    bDoVSS = g_pVSSClient && enable_vss;
1337    if (bDoVSS) {
1338       /* Run only one at a time */
1339       P(vss_mutex);
1340    }
1341 #endif
1342
1343    set_jcr_job_status(jcr, JS_Blocked);
1344    jcr->JobType = JT_BACKUP;
1345    Dmsg1(100, "begin backup ff=%p\n", jcr->ff);
1346
1347    if (sd == NULL) {
1348       Jmsg(jcr, M_FATAL, 0, _("Cannot contact Storage daemon\n"));
1349       goto cleanup;
1350    }
1351
1352    bnet_fsend(dir, OKbackup);
1353    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1354
1355    /*
1356     * Send Append Open Session to Storage daemon
1357     */
1358    bnet_fsend(sd, append_open);
1359    Dmsg1(110, ">stored: %s", sd->msg);
1360    /*
1361     * Expect to receive back the Ticket number
1362     */
1363    if (bget_msg(sd) >= 0) {
1364       Dmsg1(110, "<stored: %s", sd->msg);
1365       if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) {
1366          Jmsg(jcr, M_FATAL, 0, _("Bad response to append open: %s\n"), sd->msg);
1367          goto cleanup;
1368       }
1369       Dmsg1(110, "Got Ticket=%d\n", jcr->Ticket);
1370    } else {
1371       Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to open command\n"));
1372       goto cleanup;
1373    }
1374
1375    /*
1376     * Send Append data command to Storage daemon
1377     */
1378    bnet_fsend(sd, append_data, jcr->Ticket);
1379    Dmsg1(110, ">stored: %s", sd->msg);
1380
1381    /*
1382     * Expect to get OK data
1383     */
1384    Dmsg1(110, "<stored: %s", sd->msg);
1385    if (!response(jcr, sd, OK_data, "Append Data")) {
1386       goto cleanup;
1387    }
1388
1389    generate_daemon_event(jcr, "JobStart");
1390
1391 #if defined(WIN32_VSS)
1392    /* START VSS ON WIN 32 */
1393    if (bDoVSS) {
1394       if (g_pVSSClient->InitializeForBackup()) {
1395         /* tell vss which drives to snapshot */
1396         char szWinDriveLetters[27];
1397         if (get_win32_driveletters(jcr->ff, szWinDriveLetters)) {
1398             Jmsg(jcr, M_INFO, 0, _("Generate VSS snapshots. Driver=\"%s\", Drive(s)=\"%s\"\n"), g_pVSSClient->GetDriverName(), szWinDriveLetters);
1399             if (!g_pVSSClient->CreateSnapshots(szWinDriveLetters)) {
1400                Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshots failed.\n"));
1401                jcr->Errors++;
1402             } else {
1403                /* tell user if snapshot creation of a specific drive failed */
1404                int i;
1405                for (i=0; i < (int)strlen(szWinDriveLetters); i++) {
1406                   if (islower(szWinDriveLetters[i])) {
1407                      Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshot of drive \"%c:\\\" failed. VSS support is disabled on this drive.\n"), szWinDriveLetters[i]);
1408                      jcr->Errors++;
1409                   }
1410                }
1411                /* inform user about writer states */
1412                for (i=0; i < (int)g_pVSSClient->GetWriterCount(); i++)
1413                   if (g_pVSSClient->GetWriterState(i) < 1) {
1414                      Jmsg(jcr, M_WARNING, 0, _("VSS Writer (PrepareForBackup): %s\n"), g_pVSSClient->GetWriterInfo(i));
1415                      jcr->Errors++;
1416                   }
1417             }
1418         } else {
1419             Jmsg(jcr, M_INFO, 0, _("No drive letters found for generating VSS snapshots.\n"));
1420         }
1421       } else {
1422          berrno be;
1423          Jmsg(jcr, M_WARNING, 0, _("VSS was not initialized properly. VSS support is disabled. ERR=%s\n"), be.bstrerror());
1424       }
1425    }
1426 #endif
1427
1428    /*
1429     * Send Files to Storage daemon
1430     */
1431    Dmsg1(110, "begin blast ff=%p\n", (FF_PKT *)jcr->ff);
1432    if (!blast_data_to_storage_daemon(jcr, NULL)) {
1433       set_jcr_job_status(jcr, JS_ErrorTerminated);
1434       bnet_suppress_error_messages(sd, 1);
1435       bget_msg(sd);                   /* Read final response from append_data */
1436       Dmsg0(110, "Error in blast_data.\n");
1437    } else {
1438       set_jcr_job_status(jcr, JS_Terminated);
1439
1440       if (jcr->JobStatus != JS_Terminated) {
1441          bnet_suppress_error_messages(sd, 1);
1442          goto cleanup;                /* bail out now */
1443       }
1444       /*
1445        * Expect to get response to append_data from Storage daemon
1446        */
1447       if (!response(jcr, sd, OK_append, "Append Data")) {
1448          set_jcr_job_status(jcr, JS_ErrorTerminated);
1449          goto cleanup;
1450       }
1451
1452       /*
1453        * Send Append End Data to Storage daemon
1454        */
1455       bnet_fsend(sd, append_end, jcr->Ticket);
1456       /* Get end OK */
1457       if (!response(jcr, sd, OK_end, "Append End")) {
1458          set_jcr_job_status(jcr, JS_ErrorTerminated);
1459          goto cleanup;
1460       }
1461
1462       /*
1463        * Send Append Close to Storage daemon
1464        */
1465       bnet_fsend(sd, append_close, jcr->Ticket);
1466       while (bget_msg(sd) >= 0) {    /* stop on signal or error */
1467          if (sscanf(sd->msg, OK_close, &SDJobStatus) == 1) {
1468             ok = 1;
1469             Dmsg2(200, "SDJobStatus = %d %c\n", SDJobStatus, (char)SDJobStatus);
1470          }
1471       }
1472       if (!ok) {
1473          Jmsg(jcr, M_FATAL, 0, _("Append Close with SD failed.\n"));
1474          goto cleanup;
1475       }
1476       if (SDJobStatus != JS_Terminated) {
1477          Jmsg(jcr, M_FATAL, 0, _("Bad status %d returned from Storage Daemon.\n"),
1478             SDJobStatus);
1479       }
1480    }
1481
1482 cleanup:
1483 #if defined(WIN32_VSS)
1484    /* STOP VSS ON WIN 32 */
1485    /* tell vss to close the backup session */
1486    if (bDoVSS) {
1487       if (g_pVSSClient->CloseBackup()) {
1488          /* inform user about writer states */
1489          for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) {
1490             int msg_type = M_INFO;
1491             if (g_pVSSClient->GetWriterState(i) < 1) {
1492                msg_type = M_WARNING;
1493                jcr->Errors++;
1494             }
1495             Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i));
1496          }
1497       }
1498       V(vss_mutex);
1499    }
1500 #endif
1501
1502    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1503       edit_uint64(jcr->ReadBytes, ed1),
1504       edit_uint64(jcr->JobBytes, ed2), jcr->Errors, (int)bDoVSS,
1505       jcr->pki_encrypt);
1506    Dmsg1(110, "End FD msg: %s\n", dir->msg);
1507
1508    return 0;                          /* return and stop command loop */
1509 }
1510
1511 /*
1512  * Do a Verify for Director
1513  *
1514  */
1515 static int verify_cmd(JCR *jcr)
1516 {
1517    BSOCK *dir = jcr->dir_bsock;
1518    BSOCK *sd  = jcr->store_bsock;
1519    char level[100], ed1[50], ed2[50];
1520
1521    jcr->JobType = JT_VERIFY;
1522    if (sscanf(dir->msg, verifycmd, level) != 1) {
1523       bnet_fsend(dir, _("2994 Bad verify command: %s\n"), dir->msg);
1524       return 0;
1525    }
1526
1527    if (strcasecmp(level, "init") == 0) {
1528       jcr->JobLevel = L_VERIFY_INIT;
1529    } else if (strcasecmp(level, "catalog") == 0){
1530       jcr->JobLevel = L_VERIFY_CATALOG;
1531    } else if (strcasecmp(level, "volume") == 0){
1532       jcr->JobLevel = L_VERIFY_VOLUME_TO_CATALOG;
1533    } else if (strcasecmp(level, "data") == 0){
1534       jcr->JobLevel = L_VERIFY_DATA;
1535    } else if (strcasecmp(level, "disk_to_catalog") == 0) {
1536       jcr->JobLevel = L_VERIFY_DISK_TO_CATALOG;
1537    } else {
1538       bnet_fsend(dir, _("2994 Bad verify level: %s\n"), dir->msg);
1539       return 0;
1540    }
1541
1542    bnet_fsend(dir, OKverify);
1543
1544    generate_daemon_event(jcr, "JobStart");
1545
1546    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1547
1548    switch (jcr->JobLevel) {
1549    case L_VERIFY_INIT:
1550    case L_VERIFY_CATALOG:
1551       do_verify(jcr);
1552       break;
1553    case L_VERIFY_VOLUME_TO_CATALOG:
1554       if (!open_sd_read_session(jcr)) {
1555          return 0;
1556       }
1557       start_dir_heartbeat(jcr);
1558       do_verify_volume(jcr);
1559       stop_dir_heartbeat(jcr);
1560       /*
1561        * Send Close session command to Storage daemon
1562        */
1563       bnet_fsend(sd, read_close, jcr->Ticket);
1564       Dmsg1(130, "bfiled>stored: %s", sd->msg);
1565
1566       /* ****FIXME**** check response */
1567       bget_msg(sd);                      /* get OK */
1568
1569       /* Inform Storage daemon that we are done */
1570       bnet_sig(sd, BNET_TERMINATE);
1571
1572       break;
1573    case L_VERIFY_DISK_TO_CATALOG:
1574       do_verify(jcr);
1575       break;
1576    default:
1577       bnet_fsend(dir, _("2994 Bad verify level: %s\n"), dir->msg);
1578       return 0;
1579    }
1580
1581    bnet_sig(dir, BNET_EOD);
1582
1583    /* Send termination status back to Dir */
1584    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1585       edit_uint64(jcr->ReadBytes, ed1),
1586       edit_uint64(jcr->JobBytes, ed2), jcr->Errors, 0,
1587       jcr->pki_encrypt);
1588    Dmsg1(110, "End FD msg: %s\n", dir->msg);
1589
1590    /* Inform Director that we are done */
1591    bnet_sig(dir, BNET_TERMINATE);
1592    return 0;                          /* return and terminate command loop */
1593 }
1594
1595 /*
1596  * Do a Restore for Director
1597  *
1598  */
1599 static int restore_cmd(JCR *jcr)
1600 {
1601    BSOCK *dir = jcr->dir_bsock;
1602    BSOCK *sd = jcr->store_bsock;
1603    POOLMEM *args;
1604    bool use_regexwhere=false;
1605    int prefix_links;
1606    char replace;
1607    char ed1[50], ed2[50];
1608
1609    /*
1610     * Scan WHERE (base directory for restore) from command
1611     */
1612    Dmsg0(150, "restore command\n");
1613    /* Pickup where string */
1614    args = get_memory(dir->msglen+1);
1615    *args = 0;
1616
1617    if (sscanf(dir->msg, restorecmd, &replace, &prefix_links, args) != 3) {
1618       if (sscanf(dir->msg, restorecmdR, &replace, &prefix_links, args) != 3){
1619          if (sscanf(dir->msg, restorecmd1, &replace, &prefix_links) != 2) {
1620             pm_strcpy(jcr->errmsg, dir->msg);
1621             Jmsg(jcr, M_FATAL, 0, _("Bad replace command. CMD=%s\n"), jcr->errmsg);
1622             return 0;
1623          }
1624          *args = 0;
1625       }
1626       use_regexwhere = true;
1627    }
1628    /* Turn / into nothing */
1629    if (IsPathSeparator(args[0]) && args[1] == '\0') {
1630       args[0] = '\0';
1631    }
1632
1633    Dmsg2(150, "Got replace %c, where=%s\n", replace, args);
1634    unbash_spaces(args);
1635
1636    if (use_regexwhere) {
1637       jcr->where_bregexp = get_bregexps(args);
1638       if (!jcr->where_bregexp) {
1639          Jmsg(jcr, M_FATAL, 0, _("Bad where regexp. where=%s\n"), args);
1640          free_pool_memory(args);
1641          return 0;
1642       }
1643    } else {
1644       jcr->where = bstrdup(args);
1645    }
1646
1647    free_pool_memory(args);
1648    jcr->replace = replace;
1649    jcr->prefix_links = prefix_links;
1650
1651    bnet_fsend(dir, OKrestore);
1652    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1653
1654    jcr->JobType = JT_RESTORE;
1655
1656    set_jcr_job_status(jcr, JS_Blocked);
1657
1658    if (!open_sd_read_session(jcr)) {
1659       set_jcr_job_status(jcr, JS_ErrorTerminated);
1660       goto bail_out;
1661    }
1662
1663    set_jcr_job_status(jcr, JS_Running);
1664
1665    /*
1666     * Do restore of files and data
1667     */
1668    start_dir_heartbeat(jcr);
1669    generate_daemon_event(jcr, "JobStart");
1670    do_restore(jcr);
1671    stop_dir_heartbeat(jcr);
1672
1673    set_jcr_job_status(jcr, JS_Terminated);
1674    if (jcr->JobStatus != JS_Terminated) {
1675       bnet_suppress_error_messages(sd, 1);
1676    }
1677
1678    /*
1679     * Send Close session command to Storage daemon
1680     */
1681    bnet_fsend(sd, read_close, jcr->Ticket);
1682    Dmsg1(130, "bfiled>stored: %s", sd->msg);
1683
1684    bget_msg(sd);                      /* get OK */
1685
1686    /* Inform Storage daemon that we are done */
1687    bnet_sig(sd, BNET_TERMINATE);
1688
1689 bail_out:
1690
1691    if (jcr->Errors) {
1692       set_jcr_job_status(jcr, JS_ErrorTerminated);
1693    }
1694    /* Send termination status back to Dir */
1695    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1696       edit_uint64(jcr->ReadBytes, ed1),
1697       edit_uint64(jcr->JobBytes, ed2), jcr->Errors, 0,
1698       jcr->pki_encrypt);
1699    Dmsg1(110, "End FD msg: %s\n", dir->msg);
1700
1701    /* Inform Director that we are done */
1702    bnet_sig(dir, BNET_TERMINATE);
1703
1704    Dmsg0(130, "Done in job.c\n");
1705    return 0;                          /* return and terminate command loop */
1706 }
1707
1708 static int open_sd_read_session(JCR *jcr)
1709 {
1710    BSOCK *sd = jcr->store_bsock;
1711
1712    if (!sd) {
1713       Jmsg(jcr, M_FATAL, 0, _("Improper calling sequence.\n"));
1714       return 0;
1715    }
1716    Dmsg4(120, "VolSessId=%ld VolsessT=%ld SF=%ld EF=%ld\n",
1717       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile);
1718    Dmsg2(120, "JobId=%d vol=%s\n", jcr->JobId, "DummyVolume");
1719    /*
1720     * Open Read Session with Storage daemon
1721     */
1722    bnet_fsend(sd, read_open, "DummyVolume",
1723       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile,
1724       jcr->StartBlock, jcr->EndBlock);
1725    Dmsg1(110, ">stored: %s", sd->msg);
1726
1727    /*
1728     * Get ticket number
1729     */
1730    if (bget_msg(sd) >= 0) {
1731       Dmsg1(110, "bfiled<stored: %s", sd->msg);
1732       if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) {
1733          Jmsg(jcr, M_FATAL, 0, _("Bad response to SD read open: %s\n"), sd->msg);
1734          return 0;
1735       }
1736       Dmsg1(110, "bfiled: got Ticket=%d\n", jcr->Ticket);
1737    } else {
1738       Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to read open command\n"));
1739       return 0;
1740    }
1741
1742    if (!send_bootstrap_file(jcr)) {
1743       return 0;
1744    }
1745
1746    /*
1747     * Start read of data with Storage daemon
1748     */
1749    bnet_fsend(sd, read_data, jcr->Ticket);
1750    Dmsg1(110, ">stored: %s", sd->msg);
1751
1752    /*
1753     * Get OK data
1754     */
1755    if (!response(jcr, sd, OK_data, "Read Data")) {
1756       return 0;
1757    }
1758    return 1;
1759 }
1760
1761 /*
1762  * Destroy the Job Control Record and associated
1763  * resources (sockets).
1764  */
1765 static void filed_free_jcr(JCR *jcr)
1766 {
1767    if (jcr->store_bsock) {
1768       bnet_close(jcr->store_bsock);
1769    }
1770    free_bootstrap(jcr);
1771    if (jcr->last_fname) {
1772       free_pool_memory(jcr->last_fname);
1773    }
1774    free_runscripts(jcr->RunScripts);
1775    delete jcr->RunScripts;
1776
1777    return;
1778 }
1779
1780 /*
1781  * Get response from Storage daemon to a command we
1782  * sent. Check that the response is OK.
1783  *
1784  *  Returns: 0 on failure
1785  *           1 on success
1786  */
1787 int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd)
1788 {
1789    if (sd->errors) {
1790       return 0;
1791    }
1792    if (bget_msg(sd) > 0) {
1793       Dmsg0(110, sd->msg);
1794       if (strcmp(sd->msg, resp) == 0) {
1795          return 1;
1796       }
1797    }
1798    if (job_canceled(jcr)) {
1799       return 0;                       /* if canceled avoid useless error messages */
1800    }
1801    if (is_bnet_error(sd)) {
1802       Jmsg2(jcr, M_FATAL, 0, _("Comm error with SD. bad response to %s. ERR=%s\n"),
1803          cmd, bnet_strerror(sd));
1804    } else {
1805       Jmsg3(jcr, M_FATAL, 0, _("Bad response to %s command. Wanted %s, got %s\n"),
1806          cmd, resp, sd->msg);
1807    }
1808    return 0;
1809 }
1810
1811 static int send_bootstrap_file(JCR *jcr)
1812 {
1813    FILE *bs;
1814    char buf[2000];
1815    BSOCK *sd = jcr->store_bsock;
1816    const char *bootstrap = "bootstrap\n";
1817    int stat = 0;
1818
1819    Dmsg1(400, "send_bootstrap_file: %s\n", jcr->RestoreBootstrap);
1820    if (!jcr->RestoreBootstrap) {
1821       return 1;
1822    }
1823    bs = fopen(jcr->RestoreBootstrap, "rb");
1824    if (!bs) {
1825       berrno be;
1826       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"),
1827          jcr->RestoreBootstrap, be.bstrerror());
1828       set_jcr_job_status(jcr, JS_ErrorTerminated);
1829       goto bail_out;
1830    }
1831    sd->msglen = pm_strcpy(sd->msg, bootstrap);
1832    bnet_send(sd);
1833    while (fgets(buf, sizeof(buf), bs)) {
1834       sd->msglen = Mmsg(sd->msg, "%s", buf);
1835       bnet_send(sd);
1836    }
1837    bnet_sig(sd, BNET_EOD);
1838    fclose(bs);
1839    if (!response(jcr, sd, OKSDbootstrap, "Bootstrap")) {
1840       set_jcr_job_status(jcr, JS_ErrorTerminated);
1841       goto bail_out;
1842    }
1843    stat = 1;
1844
1845 bail_out:
1846    free_bootstrap(jcr);
1847    return stat;
1848 }