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