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       char ed1[50], ed2[50];
1027       /*
1028        * Sync clocks by polling him for the time. We take
1029        *   10 samples of his time throwing out the first two.
1030        */
1031       for (int i=0; i<10; i++) {
1032          bt_start = get_current_btime();
1033          bnet_sig(dir, BNET_BTIME);   /* poll for time */
1034          if (bnet_recv(dir) <= 0) {   /* get response */
1035             goto bail_out;
1036          }
1037          if (sscanf(dir->msg, "btime %s", buf) != 1) {
1038             goto bail_out;
1039          }
1040          if (i < 2) {                 /* toss first two results */
1041             continue;
1042          }
1043          his_time = str_to_uint64(buf);
1044          rt = get_current_btime() - bt_start; /* compute round trip time */
1045          bt_adj -= his_time - bt_start - rt/2;
1046          Dmsg2(200, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
1047       }
1048
1049       bt_adj = bt_adj / 8;            /* compute average time */
1050       Dmsg2(100, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
1051       adj = btime_to_utime(bt_adj);
1052       since_time += adj;              /* adjust for clock difference */
1053       if (adj != 0) {
1054          Jmsg(jcr, M_INFO, 0, _("DIR and FD clocks differ by %d seconds, FD automatically adjusting.\n"), adj);
1055       }
1056       bnet_sig(dir, BNET_EOD);
1057
1058       Dmsg2(100, "adj = %d since_time=%d\n", (int)adj, (int)since_time);
1059       jcr->incremental = 1;           /* set incremental or decremental backup */
1060       jcr->mtime = (time_t)since_time; /* set since time */
1061    } else {
1062       Jmsg1(jcr, M_FATAL, 0, _("Unknown backup level: %s\n"), level);
1063       free_memory(level);
1064       return 0;
1065    }
1066    free_memory(level);
1067    if (buf) {
1068       free_memory(buf);
1069    }
1070    return bnet_fsend(dir, OKlevel);
1071
1072 bail_out:
1073    pm_strcpy(jcr->errmsg, dir->msg);
1074    Jmsg1(jcr, M_FATAL, 0, _("Bad level command: %s\n"), jcr->errmsg);
1075    free_memory(level);
1076    if (buf) {
1077       free_memory(buf);
1078    }
1079    return 0;
1080 }
1081
1082 /*
1083  * Get session parameters from Director -- this is for a Restore command
1084  */
1085 static int session_cmd(JCR *jcr)
1086 {
1087    BSOCK *dir = jcr->dir_bsock;
1088
1089    Dmsg1(100, "SessionCmd: %s", dir->msg);
1090    if (sscanf(dir->msg, sessioncmd, jcr->VolumeName,
1091               &jcr->VolSessionId, &jcr->VolSessionTime,
1092               &jcr->StartFile, &jcr->EndFile,
1093               &jcr->StartBlock, &jcr->EndBlock) != 7) {
1094       pm_strcpy(jcr->errmsg, dir->msg);
1095       Jmsg(jcr, M_FATAL, 0, _("Bad session command: %s"), jcr->errmsg);
1096       return 0;
1097    }
1098
1099    return bnet_fsend(dir, OKsession);
1100 }
1101
1102 /*
1103  * Get address of storage daemon from Director
1104  *
1105  */
1106 static int storage_cmd(JCR *jcr)
1107 {
1108    int stored_port;                /* storage daemon port */
1109    int enable_ssl;                 /* enable ssl to sd */
1110    BSOCK *dir = jcr->dir_bsock;
1111    BSOCK *sd;                         /* storage daemon bsock */
1112
1113    Dmsg1(100, "StorageCmd: %s", dir->msg);
1114    if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port, &enable_ssl) != 3) {
1115       pm_strcpy(jcr->errmsg, dir->msg);
1116       Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), jcr->errmsg);
1117       return 0;
1118    }
1119    Dmsg3(110, "Open storage: %s:%d ssl=%d\n", jcr->stored_addr, stored_port, enable_ssl);
1120    /* Open command communications with Storage daemon */
1121    /* Try to connect for 1 hour at 10 second intervals */
1122    sd = bnet_connect(jcr, 10, (int)me->SDConnectTimeout, _("Storage daemon"),
1123                      jcr->stored_addr, NULL, stored_port, 1);
1124    if (sd == NULL) {
1125       Jmsg(jcr, M_FATAL, 0, _("Failed to connect to Storage daemon: %s:%d\n"),
1126           jcr->stored_addr, stored_port);
1127       Dmsg2(100, "Failed to connect to Storage daemon: %s:%d\n",
1128           jcr->stored_addr, stored_port);
1129       return 0;
1130    }
1131    Dmsg0(110, "Connection OK to SD.\n");
1132
1133    jcr->store_bsock = sd;
1134
1135    bnet_fsend(sd, "Hello Start Job %s\n", jcr->Job);
1136    if (!authenticate_storagedaemon(jcr)) {
1137       Jmsg(jcr, M_FATAL, 0, _("Failed to authenticate Storage daemon.\n"));
1138       return 0;
1139    }
1140    Dmsg0(110, "Authenticated with SD.\n");
1141
1142    /* Send OK to Director */
1143    return bnet_fsend(dir, OKstore);
1144 }
1145
1146
1147 /*
1148  * Do a backup. For now, we handle only Full and Incremental.
1149  */
1150 static int backup_cmd(JCR *jcr)
1151 {
1152    BSOCK *dir = jcr->dir_bsock;
1153    BSOCK *sd = jcr->store_bsock;
1154    int ok = 0;
1155    int SDJobStatus;
1156    char ed1[50], ed2[50];
1157
1158    set_jcr_job_status(jcr, JS_Blocked);
1159    jcr->JobType = JT_BACKUP;
1160    Dmsg1(100, "begin backup ff=%p\n", jcr->ff);
1161
1162    if (sd == NULL) {
1163       Jmsg(jcr, M_FATAL, 0, _("Cannot contact Storage daemon\n"));
1164       goto cleanup;
1165    }
1166
1167    bnet_fsend(dir, OKbackup);
1168    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1169
1170    /*
1171     * Send Append Open Session to Storage daemon
1172     */
1173    bnet_fsend(sd, append_open);
1174    Dmsg1(110, ">stored: %s", sd->msg);
1175    /*
1176     * Expect to receive back the Ticket number
1177     */
1178    if (bget_msg(sd) >= 0) {
1179       Dmsg1(110, "<stored: %s", sd->msg);
1180       if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) {
1181          Jmsg(jcr, M_FATAL, 0, _("Bad response to append open: %s\n"), sd->msg);
1182          goto cleanup;
1183       }
1184       Dmsg1(110, "Got Ticket=%d\n", jcr->Ticket);
1185    } else {
1186       Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to open command\n"));
1187       goto cleanup;
1188    }
1189
1190    /*
1191     * Send Append data command to Storage daemon
1192     */
1193    bnet_fsend(sd, append_data, jcr->Ticket);
1194    Dmsg1(110, ">stored: %s", sd->msg);
1195
1196    /*
1197     * Expect to get OK data
1198     */
1199    Dmsg1(110, "<stored: %s", sd->msg);
1200    if (!response(jcr, sd, OK_data, "Append Data")) {
1201       goto cleanup;
1202    }
1203
1204    generate_daemon_event(jcr, "JobStart");
1205
1206 #ifdef WIN32_VSS
1207    /* START VSS ON WIN 32 */
1208    if (g_pVSSClient && enable_vss) {
1209       /* Run only one at a time */
1210       P(vss_mutex);
1211       if (g_pVSSClient->InitializeForBackup()) {
1212          /* tell vss which drives to snapshot */
1213          char szWinDriveLetters[27];
1214          if (get_win32_driveletters(jcr->ff, szWinDriveLetters)) {
1215             Jmsg(jcr, M_INFO, 0, _("Generate VSS snapshots. Driver=\"%s\", Drive(s)=\"%s\"\n"), g_pVSSClient->GetDriverName(), szWinDriveLetters);
1216             if (!g_pVSSClient->CreateSnapshots(szWinDriveLetters)) {
1217                berrno be;
1218                Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshots failed. ERR=%s\n"),
1219                   be.strerror());
1220             } else {
1221                /* tell user if snapshot creation of a specific drive failed */
1222                size_t i;
1223                for (i=0; i<strlen (szWinDriveLetters); i++) {
1224                   if (islower(szWinDriveLetters[i])) {
1225                      Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshot of drive \"%c:\\\" failed\n"), szWinDriveLetters[i]);
1226                   }
1227                }
1228                /* inform user about writer states */
1229                for (i=0; i<g_pVSSClient->GetWriterCount(); i++) {
1230                   int msg_type = M_INFO;
1231                   if (g_pVSSClient->GetWriterState(i) < 0) {
1232                      msg_type = M_WARNING;
1233                   }
1234                   Jmsg(jcr, msg_type, 0, _("VSS Writer: %s\n"), g_pVSSClient->GetWriterInfo(i));
1235                }
1236             }
1237          } else {
1238             Jmsg(jcr, M_INFO, 0, _("No drive letters found for generating VSS snapshots.\n"));
1239          }
1240       } else {
1241          Jmsg(jcr, M_WARNING, 0, _("VSS was not initialized properly. VSS support is disabled.\n"));
1242       }
1243    }
1244 #endif
1245
1246    /*
1247     * Send Files to Storage daemon
1248     */
1249    Dmsg1(110, "begin blast ff=%p\n", (FF_PKT *)jcr->ff);
1250    if (!blast_data_to_storage_daemon(jcr, NULL)) {
1251       set_jcr_job_status(jcr, JS_ErrorTerminated);
1252       bnet_suppress_error_messages(sd, 1);
1253       bget_msg(sd);                   /* Read final response from append_data */
1254       Dmsg0(110, "Error in blast_data.\n");
1255    } else {
1256       set_jcr_job_status(jcr, JS_Terminated);
1257       if (jcr->JobStatus != JS_Terminated) {
1258          bnet_suppress_error_messages(sd, 1);
1259          goto cleanup;                /* bail out now */
1260       }
1261       /*
1262        * Expect to get response to append_data from Storage daemon
1263        */
1264       if (!response(jcr, sd, OK_append, "Append Data")) {
1265          set_jcr_job_status(jcr, JS_ErrorTerminated);
1266          goto cleanup;
1267       }
1268
1269       /*
1270        * Send Append End Data to Storage daemon
1271        */
1272       bnet_fsend(sd, append_end, jcr->Ticket);
1273       /* Get end OK */
1274       if (!response(jcr, sd, OK_end, "Append End")) {
1275          set_jcr_job_status(jcr, JS_ErrorTerminated);
1276          goto cleanup;
1277       }
1278
1279       /*
1280        * Send Append Close to Storage daemon
1281        */
1282       bnet_fsend(sd, append_close, jcr->Ticket);
1283       while (bget_msg(sd) >= 0) {    /* stop on signal or error */
1284          if (sscanf(sd->msg, OK_close, &SDJobStatus) == 1) {
1285             ok = 1;
1286             Dmsg2(200, "SDJobStatus = %d %c\n", SDJobStatus, (char)SDJobStatus);
1287          }
1288       }
1289       if (!ok) {
1290          Jmsg(jcr, M_FATAL, 0, _("Append Close with SD failed.\n"));
1291          goto cleanup;
1292       }
1293       if (SDJobStatus != JS_Terminated) {
1294          Jmsg(jcr, M_FATAL, 0, _("Bad status %d returned from Storage Daemon.\n"),
1295             SDJobStatus);
1296       }
1297    }
1298
1299 cleanup:
1300 #ifdef WIN32_VSS
1301    /* STOP VSS ON WIN 32 */
1302    /* tell vss to close the backup session */
1303    if (g_pVSSClient && enable_vss) {
1304       g_pVSSClient->CloseBackup();
1305       V(vss_mutex);
1306    }
1307 #endif
1308
1309    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1310       edit_uint64(jcr->ReadBytes, ed1),
1311       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1312    Dmsg1(110, "End FD msg: %s\n", dir->msg);
1313
1314    return 0;                          /* return and stop command loop */
1315 }
1316
1317 /*
1318  * Do a Verify for Director
1319  *
1320  */
1321 static int verify_cmd(JCR *jcr)
1322 {
1323    BSOCK *dir = jcr->dir_bsock;
1324    BSOCK *sd  = jcr->store_bsock;
1325    char level[100], ed1[50], ed2[50];
1326
1327    jcr->JobType = JT_VERIFY;
1328    if (sscanf(dir->msg, verifycmd, level) != 1) {
1329       bnet_fsend(dir, _("2994 Bad verify command: %s\n"), dir->msg);
1330       return 0;
1331    }
1332
1333    if (strcasecmp(level, "init") == 0) {
1334       jcr->JobLevel = L_VERIFY_INIT;
1335    } else if (strcasecmp(level, "catalog") == 0){
1336       jcr->JobLevel = L_VERIFY_CATALOG;
1337    } else if (strcasecmp(level, "volume") == 0){
1338       jcr->JobLevel = L_VERIFY_VOLUME_TO_CATALOG;
1339    } else if (strcasecmp(level, "data") == 0){
1340       jcr->JobLevel = L_VERIFY_DATA;
1341    } else if (strcasecmp(level, "disk_to_catalog") == 0) {
1342       jcr->JobLevel = L_VERIFY_DISK_TO_CATALOG;
1343    } else {
1344       bnet_fsend(dir, _("2994 Bad verify level: %s\n"), dir->msg);
1345       return 0;
1346    }
1347
1348    bnet_fsend(dir, OKverify);
1349
1350    generate_daemon_event(jcr, "JobStart");
1351
1352    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1353
1354    switch (jcr->JobLevel) {
1355    case L_VERIFY_INIT:
1356    case L_VERIFY_CATALOG:
1357       do_verify(jcr);
1358       break;
1359    case L_VERIFY_VOLUME_TO_CATALOG:
1360       if (!open_sd_read_session(jcr)) {
1361          return 0;
1362       }
1363       start_dir_heartbeat(jcr);
1364       do_verify_volume(jcr);
1365       stop_dir_heartbeat(jcr);
1366       /*
1367        * Send Close session command to Storage daemon
1368        */
1369       bnet_fsend(sd, read_close, jcr->Ticket);
1370       Dmsg1(130, "bfiled>stored: %s", sd->msg);
1371
1372       /* ****FIXME**** check response */
1373       bget_msg(sd);                      /* get OK */
1374
1375       /* Inform Storage daemon that we are done */
1376       bnet_sig(sd, BNET_TERMINATE);
1377
1378       break;
1379    case L_VERIFY_DISK_TO_CATALOG:
1380       do_verify(jcr);
1381       break;
1382    default:
1383       bnet_fsend(dir, _("2994 Bad verify level: %s\n"), dir->msg);
1384       return 0;
1385    }
1386
1387    bnet_sig(dir, BNET_EOD);
1388
1389    /* Send termination status back to Dir */
1390    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1391       edit_uint64(jcr->ReadBytes, ed1),
1392       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1393
1394    /* Inform Director that we are done */
1395    bnet_sig(dir, BNET_TERMINATE);
1396    return 0;                          /* return and terminate command loop */
1397 }
1398
1399 /*
1400  * Do a Restore for Director
1401  *
1402  */
1403 static int restore_cmd(JCR *jcr)
1404 {
1405    BSOCK *dir = jcr->dir_bsock;
1406    BSOCK *sd = jcr->store_bsock;
1407    POOLMEM *where;
1408    int prefix_links;
1409    char replace;
1410    char ed1[50], ed2[50];
1411
1412    /*
1413     * Scan WHERE (base directory for restore) from command
1414     */
1415    Dmsg0(150, "restore command\n");
1416    /* Pickup where string */
1417    where = get_memory(dir->msglen+1);
1418    *where = 0;
1419
1420    if (sscanf(dir->msg, restorecmd, &replace, &prefix_links, where) != 3) {
1421       if (sscanf(dir->msg, restorecmd1, &replace, &prefix_links) != 2) {
1422          pm_strcpy(jcr->errmsg, dir->msg);
1423          Jmsg(jcr, M_FATAL, 0, _("Bad replace command. CMD=%s\n"), jcr->errmsg);
1424          return 0;
1425       }
1426       *where = 0;
1427    }
1428    /* Turn / into nothing */
1429    if (where[0] == '/' && where[1] == 0) {
1430       where[0] = 0;
1431    }
1432
1433    Dmsg2(150, "Got replace %c, where=%s\n", replace, where);
1434    unbash_spaces(where);
1435    jcr->where = bstrdup(where);
1436    free_pool_memory(where);
1437    jcr->replace = replace;
1438    jcr->prefix_links = prefix_links;
1439
1440    bnet_fsend(dir, OKrestore);
1441    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1442
1443    jcr->JobType = JT_RESTORE;
1444
1445    set_jcr_job_status(jcr, JS_Blocked);
1446
1447    if (!open_sd_read_session(jcr)) {
1448       set_jcr_job_status(jcr, JS_ErrorTerminated);
1449       goto bail_out;
1450    }
1451
1452    set_jcr_job_status(jcr, JS_Running);
1453
1454    /*
1455     * Do restore of files and data
1456     */
1457    start_dir_heartbeat(jcr);
1458    generate_daemon_event(jcr, "JobStart");
1459    do_restore(jcr);
1460    stop_dir_heartbeat(jcr);
1461
1462    set_jcr_job_status(jcr, JS_Terminated);
1463    if (jcr->JobStatus != JS_Terminated) {
1464       bnet_suppress_error_messages(sd, 1);
1465    }
1466
1467    /*
1468     * Send Close session command to Storage daemon
1469     */
1470    bnet_fsend(sd, read_close, jcr->Ticket);
1471    Dmsg1(130, "bfiled>stored: %s", sd->msg);
1472
1473    bget_msg(sd);                      /* get OK */
1474
1475    /* Inform Storage daemon that we are done */
1476    bnet_sig(sd, BNET_TERMINATE);
1477
1478 bail_out:
1479
1480    if (jcr->Errors) {
1481       set_jcr_job_status(jcr, JS_ErrorTerminated);
1482    }
1483    /* Send termination status back to Dir */
1484    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1485       edit_uint64(jcr->ReadBytes, ed1),
1486       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1487
1488    /* Inform Director that we are done */
1489    bnet_sig(dir, BNET_TERMINATE);
1490
1491    Dmsg0(130, "Done in job.c\n");
1492    return 0;                          /* return and terminate command loop */
1493 }
1494
1495 static int open_sd_read_session(JCR *jcr)
1496 {
1497    BSOCK *sd = jcr->store_bsock;
1498
1499    if (!sd) {
1500       Jmsg(jcr, M_FATAL, 0, _("Improper calling sequence.\n"));
1501       return 0;
1502    }
1503    Dmsg4(120, "VolSessId=%ld VolsessT=%ld SF=%ld EF=%ld\n",
1504       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile);
1505    Dmsg2(120, "JobId=%d vol=%s\n", jcr->JobId, "DummyVolume");
1506    /*
1507     * Open Read Session with Storage daemon
1508     */
1509    bnet_fsend(sd, read_open, jcr->VolumeName,
1510       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile,
1511       jcr->StartBlock, jcr->EndBlock);
1512    Dmsg1(110, ">stored: %s", sd->msg);
1513
1514    /*
1515     * Get ticket number
1516     */
1517    if (bget_msg(sd) >= 0) {
1518       Dmsg1(110, "bfiled<stored: %s", sd->msg);
1519       if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) {
1520          Jmsg(jcr, M_FATAL, 0, _("Bad response to SD read open: %s\n"), sd->msg);
1521          return 0;
1522       }
1523       Dmsg1(110, "bfiled: got Ticket=%d\n", jcr->Ticket);
1524    } else {
1525       Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to read open command\n"));
1526       return 0;
1527    }
1528
1529    if (!send_bootstrap_file(jcr)) {
1530       return 0;
1531    }
1532
1533    /*
1534     * Start read of data with Storage daemon
1535     */
1536    bnet_fsend(sd, read_data, jcr->Ticket);
1537    Dmsg1(110, ">stored: %s", sd->msg);
1538
1539    /*
1540     * Get OK data
1541     */
1542    if (!response(jcr, sd, OK_data, "Read Data")) {
1543       return 0;
1544    }
1545    return 1;
1546 }
1547
1548 /*
1549  * Destroy the Job Control Record and associated
1550  * resources (sockets).
1551  */
1552 static void filed_free_jcr(JCR *jcr)
1553 {
1554    if (jcr->store_bsock) {
1555       bnet_close(jcr->store_bsock);
1556    }
1557    free_bootstrap(jcr);
1558    if (jcr->last_fname) {
1559       free_pool_memory(jcr->last_fname);
1560    }
1561    if (jcr->RunAfterJob) {
1562       free_pool_memory(jcr->RunAfterJob);
1563    }
1564
1565
1566    return;
1567 }
1568
1569 /*
1570  * Get response from Storage daemon to a command we
1571  * sent. Check that the response is OK.
1572  *
1573  *  Returns: 0 on failure
1574  *           1 on success
1575  */
1576 int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd)
1577 {
1578    if (sd->errors) {
1579       return 0;
1580    }
1581    if (bget_msg(sd) > 0) {
1582       Dmsg0(110, sd->msg);
1583       if (strcmp(sd->msg, resp) == 0) {
1584          return 1;
1585       }
1586    }
1587    if (job_canceled(jcr)) {
1588       return 0;                       /* if canceled avoid useless error messages */
1589    }
1590    if (is_bnet_error(sd)) {
1591       Jmsg2(jcr, M_FATAL, 0, _("Comm error with SD. bad response to %s. ERR=%s\n"),
1592          cmd, bnet_strerror(sd));
1593    } else {
1594       Jmsg3(jcr, M_FATAL, 0, _("Bad response to %s command. Wanted %s, got %s\n"),
1595          cmd, resp, sd->msg);
1596    }
1597    return 0;
1598 }
1599
1600 static int send_bootstrap_file(JCR *jcr)
1601 {
1602    FILE *bs;
1603    char buf[2000];
1604    BSOCK *sd = jcr->store_bsock;
1605    const char *bootstrap = "bootstrap\n";
1606    int stat = 0;
1607
1608    Dmsg1(400, "send_bootstrap_file: %s\n", jcr->RestoreBootstrap);
1609    if (!jcr->RestoreBootstrap) {
1610       return 1;
1611    }
1612    bs = fopen(jcr->RestoreBootstrap, "r");
1613    if (!bs) {
1614       berrno be;
1615       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"),
1616          jcr->RestoreBootstrap, be.strerror());
1617       set_jcr_job_status(jcr, JS_ErrorTerminated);
1618       goto bail_out;
1619    }
1620    sd->msglen = pm_strcpy(sd->msg, bootstrap);
1621    bnet_send(sd);
1622    while (fgets(buf, sizeof(buf), bs)) {
1623       sd->msglen = Mmsg(sd->msg, "%s", buf);
1624       bnet_send(sd);
1625    }
1626    bnet_sig(sd, BNET_EOD);
1627    fclose(bs);
1628    if (!response(jcr, sd, OKSDbootstrap, "Bootstrap")) {
1629       set_jcr_job_status(jcr, JS_ErrorTerminated);
1630       goto bail_out;
1631    }
1632    stat = 1;
1633
1634 bail_out:
1635    free_bootstrap(jcr);
1636    return stat;
1637 }