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

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