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

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