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 ammended 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
  27 #ifdef WIN32_VSS
  28 #include "vss.h"
  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 = (FF_PKT *)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((FF_PKT *)jcr->ff);
 291    jcr->ff = NULL;
 292    Dmsg0(100, "Done with term_find_files\n");
 293    free_jcr(jcr);                     /* destroy JCR record */
 294    Dmsg0(100, "Done with free_jcr\n");
 295    return NULL;
 296 }
 297
 298 /*
 299  * Hello from Director he must identify himself and provide his
 300  *  password.
 301  */
 302 static int hello_cmd(JCR *jcr)
 303 {
 304    Dmsg0(120, "Calling Authenticate\n");
 305    if (!authenticate_director(jcr)) {
 306       return 0;
 307    }
 308    Dmsg0(120, "OK Authenticate\n");
 309    jcr->authenticated = true;
 310    return 1;
 311 }
 312
 313 /*
 314  * Cancel a Job
 315  */
 316 static int cancel_cmd(JCR *jcr)
 317 {
 318    BSOCK *dir = jcr->dir_bsock;
 319    char Job[MAX_NAME_LENGTH];
 320    JCR *cjcr;
 321
 322    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 323       if (!(cjcr=get_jcr_by_full_name(Job))) {
 324          bnet_fsend(dir, "2901 Job %s not found.\n", Job);
 325       } else {
 326          if (cjcr->store_bsock) {
 327             P(cjcr->mutex);
 328             cjcr->store_bsock->timed_out = 1;
 329             cjcr->store_bsock->terminated = 1;
 330 /*
 331  * #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
 332  */
 333 #if !defined(HAVE_CYGWIN)
 334             pthread_kill(cjcr->my_thread_id, TIMEOUT_SIGNAL);
 335 #endif
 336             V(cjcr->mutex);
 337          }
 338          set_jcr_job_status(cjcr, JS_Canceled);
 339          free_jcr(cjcr);
 340          bnet_fsend(dir, _("2001 Job %s marked to be canceled.\n"), Job);
 341       }
 342    } else {
 343       bnet_fsend(dir, _("2902 Error scanning cancel command.\n"));
 344    }
 345    bnet_sig(dir, BNET_EOD);
 346    return 1;
 347 }
 348
 349
 350 /*
 351  * Set debug level as requested by the Director
 352  *
 353  */
 354 static int setdebug_cmd(JCR *jcr)
 355 {
 356    BSOCK *dir = jcr->dir_bsock;
 357    int level, trace_flag;
 358
 359    Dmsg1(110, "setdebug_cmd: %s", dir->msg);
 360    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 361       pm_strcpy(jcr->errmsg, dir->msg);
 362       bnet_fsend(dir, "2991 Bad setdebug command: %s\n", jcr->errmsg);
 363       return 0;
 364    }
 365    debug_level = level;
 366    set_trace(trace_flag);
 367    return bnet_fsend(dir, OKsetdebug, level);
 368 }
 369
 370
 371 static int estimate_cmd(JCR *jcr)
 372 {
 373    BSOCK *dir = jcr->dir_bsock;
 374    char ed2[50];
 375
 376    if (sscanf(dir->msg, estimatecmd, &jcr->listing) != 1) {
 377       pm_strcpy(jcr->errmsg, dir->msg);
 378       Jmsg(jcr, M_FATAL, 0, _("Bad estimate command: %s"), jcr->errmsg);
 379       bnet_fsend(dir, "2992 Bad estimate command.\n");
 380       return 0;
 381    }
 382    make_estimate(jcr);
 383    bnet_fsend(dir, OKest, jcr->num_files_examined,
 384       edit_uint64_with_commas(jcr->JobBytes, ed2));
 385    bnet_sig(dir, BNET_EOD);
 386    return 1;
 387 }
 388
 389 /*
 390  * Get JobId and Storage Daemon Authorization key from Director
 391  */
 392 static int job_cmd(JCR *jcr)
 393 {
 394    BSOCK *dir = jcr->dir_bsock;
 395    POOLMEM *sd_auth_key;
 396
 397    sd_auth_key = get_memory(dir->msglen);
 398    if (sscanf(dir->msg, jobcmd,  &jcr->JobId, jcr->Job,
 399               &jcr->VolSessionId, &jcr->VolSessionTime,
 400               sd_auth_key) != 5) {
 401       pm_strcpy(jcr->errmsg, dir->msg);
 402       Jmsg(jcr, M_FATAL, 0, _("Bad Job Command: %s"), jcr->errmsg);
 403       bnet_fsend(dir, BADjob);
 404       free_pool_memory(sd_auth_key);
 405       return 0;
 406    }
 407    jcr->sd_auth_key = bstrdup(sd_auth_key);
 408    free_pool_memory(sd_auth_key);
 409    Dmsg2(120, "JobId=%d Auth=%s\n", jcr->JobId, jcr->sd_auth_key);
 410    return bnet_fsend(dir, OKjob, HOST_OS, DISTNAME, DISTVER);
 411 }
 412
 413 static int runbefore_cmd(JCR *jcr)
 414 {
 415    bool ok;
 416    BSOCK *dir = jcr->dir_bsock;
 417    POOLMEM *cmd = get_memory(dir->msglen+1);
 418
 419    Dmsg1(100, "runbefore_cmd: %s", dir->msg);
 420    if (sscanf(dir->msg, runbefore, cmd) != 1) {
 421       pm_strcpy(jcr->errmsg, dir->msg);
 422       Jmsg1(jcr, M_FATAL, 0, _("Bad RunBeforeJob command: %s\n"), jcr->errmsg);
 423       bnet_fsend(dir, "2905 Bad RunBeforeJob command.\n");
 424       free_memory(cmd);
 425       return 0;
 426    }
 427    unbash_spaces(cmd);
 428
 429    /* Run the command now */
 430    ok = run_cmd(jcr, cmd, "ClientRunBeforeJob");
 431    free_memory(cmd);
 432    if (ok) {
 433       bnet_fsend(dir, OKRunBefore);
 434       return 1;
 435    } else {
 436       bnet_fsend(dir, "2905 Bad RunBeforeJob command.\n");
 437       return 0;
 438    }
 439 }
 440
 441 static int runafter_cmd(JCR *jcr)
 442 {
 443    BSOCK *dir = jcr->dir_bsock;
 444    POOLMEM *msg = get_memory(dir->msglen+1);
 445
 446    Dmsg1(100, "runafter_cmd: %s", dir->msg);
 447    if (sscanf(dir->msg, runafter, msg) != 1) {
 448       pm_strcpy(jcr->errmsg, dir->msg);
 449       Jmsg1(jcr, M_FATAL, 0, _("Bad RunAfter command: %s\n"), jcr->errmsg);
 450       bnet_fsend(dir, "2905 Bad RunAfterJob command.\n");
 451       free_memory(msg);
 452       return 0;
 453    }
 454    unbash_spaces(msg);
 455    if (jcr->RunAfterJob) {
 456       free_pool_memory(jcr->RunAfterJob);
 457    }
 458    jcr->RunAfterJob = get_pool_memory(PM_FNAME);
 459    pm_strcpy(jcr->RunAfterJob, msg);
 460    free_pool_memory(msg);
 461    return bnet_fsend(dir, OKRunAfter);
 462 }
 463
 464 static bool run_cmd(JCR *jcr, char *cmd, const char *name)
 465 {
 466    POOLMEM *ecmd = get_pool_memory(PM_FNAME);
 467    int status;
 468    BPIPE *bpipe;
 469    char line[MAXSTRING];
 470
 471    ecmd = edit_job_codes(jcr, ecmd, cmd, "");
 472    bpipe = open_bpipe(ecmd, 0, "r");
 473    free_pool_memory(ecmd);
 474    if (bpipe == NULL) {
 475       berrno be;
 476       Jmsg(jcr, M_FATAL, 0, _("%s could not execute. ERR=%s\n"), name,
 477          be.strerror());
 478       return false;
 479    }
 480    while (fgets(line, sizeof(line), bpipe->rfd)) {
 481       int len = strlen(line);
 482       if (len > 0 && line[len-1] == '\n') {
 483          line[len-1] = 0;
 484       }
 485       Jmsg(jcr, M_INFO, 0, _("%s: %s\n"), name, line);
 486    }
 487    status = close_bpipe(bpipe);
 488    if (status != 0) {
 489       berrno be;
 490       Jmsg(jcr, M_FATAL, 0, _("%s returned non-zero status=%d. ERR=%s\n"), name,
 491          status, be.strerror(status));
 492       return false;
 493    }
 494    return true;
 495 }
 496
 497 static bool init_fileset(JCR *jcr)
 498 {
 499    FF_PKT *ff;
 500    findFILESET *fileset;
 501
 502    if (!jcr->ff) {
 503       return false;
 504    }
 505    ff = (FF_PKT *)jcr->ff;
 506    if (ff->fileset) {
 507       return false;
 508    }
 509    fileset = (findFILESET *)malloc(sizeof(findFILESET));
 510    memset(fileset, 0, sizeof(findFILESET));
 511    ff->fileset = fileset;
 512    fileset->state = state_none;
 513    fileset->include_list.init(1, true);
 514    fileset->exclude_list.init(1, true);
 515    return true;
 516 }
 517
 518 static findFOPTS *start_options(FF_PKT *ff)
 519 {
 520    int state = ff->fileset->state;
 521    findINCEXE *incexe = ff->fileset->incexe;
 522
 523    if (state != state_options) {
 524       ff->fileset->state = state_options;
 525       findFOPTS *fo = (findFOPTS *)malloc(sizeof(findFOPTS));
 526       memset(fo, 0, sizeof(findFOPTS));
 527       fo->regex.init(1, true);
 528       fo->regexdir.init(1, true);
 529       fo->regexfile.init(1, true);
 530       fo->wild.init(1, true);
 531       fo->wilddir.init(1, true);
 532       fo->wildfile.init(1, true);
 533       fo->base.init(1, true);
 534       fo->fstype.init(1, true);
 535       incexe->current_opts = fo;
 536       incexe->opts_list.append(fo);
 537    }
 538    return incexe->current_opts;
 539
 540 }
 541
 542 /*
 543  * Add fname to include/exclude fileset list. First check for
 544  * | and < and if necessary perform command.
 545  */
 546 static void add_file_to_fileset(JCR *jcr, const char *fname, findFILESET *fileset)
 547 {
 548    char *p;
 549    BPIPE *bpipe;
 550    POOLMEM *fn;
 551    FILE *ffd;
 552    char buf[1000];
 553    int ch;
 554    int stat;
 555
 556    p = (char *)fname;
 557    ch = (uint8_t)*p;
 558    switch (ch) {
 559    case '|':
 560       p++;                            /* skip over | */
 561       fn = get_pool_memory(PM_FNAME);
 562       fn = edit_job_codes(jcr, fn, p, "");
 563       bpipe = open_bpipe(fn, 0, "r");
 564       free_pool_memory(fn);
 565       if (!bpipe) {
 566          Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
 567             p, strerror(errno));
 568          return;
 569       }
 570       while (fgets(buf, sizeof(buf), bpipe->rfd)) {
 571          strip_trailing_junk(buf);
 572          fileset->incexe->name_list.append(bstrdup(buf));
 573       }
 574       if ((stat=close_bpipe(bpipe)) != 0) {
 575          Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. RtnStat=%d ERR=%s\n"),
 576             p, stat, strerror(errno));
 577          return;
 578       }
 579       break;
 580    case '<':
 581       Dmsg0(100, "Doing < include on client.\n");
 582       p++;                      /* skip over < */
 583       if ((ffd = fopen(p, "r")) == NULL) {
 584          berrno be;
 585          Jmsg(jcr, M_FATAL, 0, _("Cannot open FileSet input file: %s. ERR=%s\n"),
 586             p, be.strerror());
 587          return;
 588       }
 589       while (fgets(buf, sizeof(buf), ffd)) {
 590          strip_trailing_junk(buf);
 591          Dmsg1(100, "%s\n", buf);
 592          fileset->incexe->name_list.append(bstrdup(buf));
 593       }
 594       fclose(ffd);
 595       break;
 596    default:
 597       fileset->incexe->name_list.append(bstrdup(fname));
 598       break;
 599    }
 600 }
 601
 602
 603 static void add_fileset(JCR *jcr, const char *item)
 604 {
 605    FF_PKT *ff = (FF_PKT *)jcr->ff;
 606    findFILESET *fileset = ff->fileset;
 607    int state = fileset->state;
 608    findFOPTS *current_opts;
 609
 610    /* Get code, optional subcode, and position item past the dividing space */
 611    Dmsg1(100, "%s\n", item);
 612    int code = item[0];
 613    if (code != '\0') {
 614       ++item;
 615    }
 616    int subcode = ' ';               /* A space is always a valid subcode */
 617    if (item[0] != '\0' && item[0] != ' ') {
 618       subcode = item[0];
 619       ++item;
 620    }
 621    if (*item == ' ') {
 622       ++item;
 623    }
 624
 625    /* Skip all lines we receive after an error */
 626    if (state == state_error) {
 627       return;
 628    }
 629
 630    /*
 631     * The switch tests the code for validity.
 632     * The subcode is always good if it is a space, otherwise we must confirm.
 633     * We set state to state_error first assuming the subcode is invalid,
 634     * requiring state to be set in cases below that handle subcodes.
 635     */
 636    if (subcode != ' ') {
 637       state = state_error;
 638    }
 639    switch (code) {
 640    case 'I':
 641       /* New include */
 642       fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
 643       memset(fileset->incexe, 0, sizeof(findINCEXE));
 644       fileset->incexe->opts_list.init(1, true);
 645       fileset->incexe->name_list.init(1, true);
 646       fileset->include_list.append(fileset->incexe);
 647       break;
 648    case 'E':
 649       /* New exclude */
 650       fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
 651       memset(fileset->incexe, 0, sizeof(findINCEXE));
 652       fileset->incexe->opts_list.init(1, true);
 653       fileset->incexe->name_list.init(1, true);
 654       fileset->exclude_list.append(fileset->incexe);
 655       break;
 656    case 'N':
 657       state = state_none;
 658       break;
 659    case 'F':
 660       /* File item to either include/include list */
 661       state = state_include;
 662       add_file_to_fileset(jcr, item, fileset);
 663       break;
 664    case 'R':
 665       current_opts = start_options(ff);
 666       regex_t *preg;
 667       int rc;
 668       char prbuf[500];
 669       preg = (regex_t *)malloc(sizeof(regex_t));
 670       if (current_opts->flags & FO_IGNORECASE) {
 671          rc = regcomp(preg, item, REG_EXTENDED|REG_ICASE);
 672       } else {
 673          rc = regcomp(preg, item, REG_EXTENDED);
 674       }
 675       if (rc != 0) {
 676          regerror(rc, preg, prbuf, sizeof(prbuf));
 677          regfree(preg);
 678          free(preg);
 679          Jmsg(jcr, M_FATAL, 0, "REGEX %s compile error. ERR=%s\n", item, prbuf);
 680          state = state_error;
 681          break;
 682       }
 683       state = state_options;
 684       if (subcode == ' ') {
 685          current_opts->regex.append(preg);
 686       } else if (subcode == 'D') {
 687          current_opts->regexdir.append(preg);
 688       } else if (subcode == 'F') {
 689          current_opts->regexfile.append(preg);
 690       } else {
 691          state = state_error;
 692       }
 693       break;
 694    case 'B':
 695       current_opts = start_options(ff);
 696       current_opts->base.append(bstrdup(item));
 697       state = state_options;
 698       break;
 699    case 'X':
 700       current_opts = start_options(ff);
 701       current_opts->fstype.append(bstrdup(item));
 702       state = state_options;
 703       break;
 704    case 'W':
 705       current_opts = start_options(ff);
 706       state = state_options;
 707       if (subcode == ' ') {
 708          current_opts->wild.append(bstrdup(item));
 709       } else if (subcode == 'D') {
 710          current_opts->wilddir.append(bstrdup(item));
 711       } else if (subcode == 'F') {
 712          current_opts->wildfile.append(bstrdup(item));
 713       } else {
 714          state = state_error;
 715       }
 716       break;
 717    case 'O':
 718       current_opts = start_options(ff);
 719       set_options(current_opts, item);
 720       state = state_options;
 721       break;
 722    case 'D':
 723       current_opts = start_options(ff);
 724       current_opts->reader = bstrdup(item);
 725       state = state_options;
 726       break;
 727    case 'T':
 728       current_opts = start_options(ff);
 729       current_opts->writer = bstrdup(item);
 730       state = state_options;
 731       break;
 732    default:
 733       Jmsg(jcr, M_FATAL, 0, "Invalid FileSet command: %s\n", item);
 734       state = state_error;
 735       break;
 736    }
 737    ff->fileset->state = state;
 738 }
 739
 740 static bool term_fileset(JCR *jcr)
 741 {
 742    FF_PKT *ff = (FF_PKT *)jcr->ff;
 743    findFILESET *fileset = ff->fileset;
 744    int i, j, k;
 745
 746    for (i=0; i<fileset->include_list.size(); i++) {
 747       findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
 748       Dmsg0(400, "I\n");
 749       for (j=0; j<incexe->opts_list.size(); j++) {
 750          findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 751          for (k=0; k<fo->regex.size(); k++) {
 752             Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
 753          }
 754          for (k=0; k<fo->regexdir.size(); k++) {
 755             Dmsg1(400, "RD %s\n", (char *)fo->regexdir.get(k));
 756          }
 757          for (k=0; k<fo->regexfile.size(); k++) {
 758             Dmsg1(400, "RF %s\n", (char *)fo->regexfile.get(k));
 759          }
 760          for (k=0; k<fo->wild.size(); k++) {
 761             Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
 762          }
 763          for (k=0; k<fo->wilddir.size(); k++) {
 764             Dmsg1(400, "WD %s\n", (char *)fo->wilddir.get(k));
 765          }
 766          for (k=0; k<fo->wildfile.size(); k++) {
 767             Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k));
 768          }
 769          for (k=0; k<fo->base.size(); k++) {
 770             Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
 771          }
 772          for (k=0; k<fo->fstype.size(); k++) {
 773             Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k));
 774          }
 775          if (fo->reader) {
 776             Dmsg1(400, "D %s\n", fo->reader);
 777          }
 778          if (fo->writer) {
 779             Dmsg1(400, "T %s\n", fo->writer);
 780          }
 781       }
 782       for (j=0; j<incexe->name_list.size(); j++) {
 783          Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j));
 784       }
 785    }
 786    for (i=0; i<fileset->exclude_list.size(); i++) {
 787       findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
 788       Dmsg0(400, "E\n");
 789       for (j=0; j<incexe->opts_list.size(); j++) {
 790          findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 791          for (k=0; k<fo->regex.size(); k++) {
 792             Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
 793          }
 794          for (k=0; k<fo->regexdir.size(); k++) {
 795             Dmsg1(400, "RD %s\n", (char *)fo->regexdir.get(k));
 796          }
 797          for (k=0; k<fo->regexfile.size(); k++) {
 798             Dmsg1(400, "RF %s\n", (char *)fo->regexfile.get(k));
 799          }
 800          for (k=0; k<fo->wild.size(); k++) {
 801             Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
 802          }
 803          for (k=0; k<fo->wilddir.size(); k++) {
 804             Dmsg1(400, "WD %s\n", (char *)fo->wilddir.get(k));
 805          }
 806          for (k=0; k<fo->wildfile.size(); k++) {
 807             Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k));
 808          }
 809          for (k=0; k<fo->base.size(); k++) {
 810             Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
 811          }
 812          for (k=0; k<fo->fstype.size(); k++) {
 813             Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k));
 814          }
 815       }
 816       for (j=0; j<incexe->name_list.size(); j++) {
 817          Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j));
 818       }
 819    }
 820    return ff->fileset->state != state_error;
 821 }
 822
 823
 824 /*
 825  * As an optimization, we should do this during
 826  *  "compile" time in filed/job.c, and keep only a bit mask
 827  *  and the Verify options.
 828  */
 829 static void set_options(findFOPTS *fo, const char *opts)
 830 {
 831    int j;
 832    const char *p;
 833
 834    for (p=opts; *p; p++) {
 835       switch (*p) {
 836       case 'a':                 /* alway replace */
 837       case '0':                 /* no option */
 838          break;
 839       case 'e':
 840          fo->flags |= FO_EXCLUDE;
 841          break;
 842       case 'f':
 843          fo->flags |= FO_MULTIFS;
 844          break;
 845       case 'h':                 /* no recursion */
 846          fo->flags |= FO_NO_RECURSION;
 847          break;
 848       case 'H':                 /* no hard link handling */
 849          fo->flags |= FO_NO_HARDLINK;
 850          break;
 851       case 'i':
 852          fo->flags |= FO_IGNORECASE;
 853          break;
 854       case 'M':                 /* MD5 */
 855          fo->flags |= FO_MD5;
 856          break;
 857       case 'n':
 858          fo->flags |= FO_NOREPLACE;
 859          break;
 860       case 'p':                 /* use portable data format */
 861          fo->flags |= FO_PORTABLE;
 862          break;
 863       case 'R':                 /* Resource forks and Finder Info */
 864          fo->flags |= FO_HFSPLUS;
 865       case 'r':                 /* read fifo */
 866          fo->flags |= FO_READFIFO;
 867          break;
 868       case 'S':
 869          fo->flags |= FO_SHA1;
 870          break;
 871       case 's':
 872          fo->flags |= FO_SPARSE;
 873          break;
 874       case 'm':
 875          fo->flags |= FO_MTIMEONLY;
 876          break;
 877       case 'k':
 878          fo->flags |= FO_KEEPATIME;
 879          break;
 880       case 'A':
 881          fo->flags |= FO_ACL;
 882          break;
 883       case 'V':                  /* verify options */
 884          /* Copy Verify Options */
 885          for (j=0; *p && *p != ':'; p++) {
 886             fo->VerifyOpts[j] = *p;
 887             if (j < (int)sizeof(fo->VerifyOpts) - 1) {
 888                j++;
 889             }
 890          }
 891          fo->VerifyOpts[j] = 0;
 892          break;
 893       case 'w':
 894          fo->flags |= FO_IF_NEWER;
 895          break;
 896       case 'Z':                 /* gzip compression */
 897          fo->flags |= FO_GZIP;
 898          fo->GZIP_level = *++p - '0';
 899          Dmsg1(200, "Compression level=%d\n", fo->GZIP_level);
 900          break;
 901       default:
 902          Emsg1(M_ERROR, 0, "Unknown include/exclude option: %c\n", *p);
 903          break;
 904       }
 905    }
 906 }
 907
 908
 909 /*
 910  * Director is passing his Fileset
 911  */
 912 static int fileset_cmd(JCR *jcr)
 913 {
 914    BSOCK *dir = jcr->dir_bsock;
 915    int vss = 0;
 916
 917    sscanf(dir->msg, "fileset vss=%d", &vss);
 918    enable_vss = vss;
 919
 920    if (!init_fileset(jcr)) {
 921       return 0;
 922    }
 923    while (bnet_recv(dir) >= 0) {
 924       strip_trailing_junk(dir->msg);
 925       Dmsg1(400, "Fileset: %s\n", dir->msg);
 926       add_fileset(jcr, dir->msg);
 927    }
 928    if (!term_fileset(jcr)) {
 929       return 0;
 930    }
 931    return bnet_fsend(dir, OKinc);
 932 }
 933
 934
 935 /*
 936  * The Director sends us the bootstrap file, which
 937  *   we will in turn pass to the SD.
 938  */
 939 static int bootstrap_cmd(JCR *jcr)
 940 {
 941    BSOCK *dir = jcr->dir_bsock;
 942    POOLMEM *fname = get_pool_memory(PM_FNAME);
 943    FILE *bs;
 944
 945    if (jcr->RestoreBootstrap) {
 946       unlink(jcr->RestoreBootstrap);
 947       free_pool_memory(jcr->RestoreBootstrap);
 948    }
 949    Mmsg(fname, "%s/%s.%s.bootstrap", me->working_directory, me->hdr.name,
 950       jcr->Job);
 951    Dmsg1(400, "bootstrap=%s\n", fname);
 952    jcr->RestoreBootstrap = fname;
 953    bs = fopen(fname, "a+");           /* create file */
 954    if (!bs) {
 955       berrno be;
 956       /*
 957        * Suck up what he is sending to us so that he will then
 958        *   read our error message.
 959        */
 960       while (bnet_recv(dir) >= 0)
 961         {  }
 962
 963       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
 964          jcr->RestoreBootstrap, be.strerror());
 965       free_pool_memory(jcr->RestoreBootstrap);
 966       jcr->RestoreBootstrap = NULL;
 967       set_jcr_job_status(jcr, JS_ErrorTerminated);
 968       return 0;
 969    }
 970
 971    while (bnet_recv(dir) >= 0) {
 972        Dmsg1(200, "filed<dird: bootstrap file %s\n", dir->msg);
 973        fputs(dir->msg, bs);
 974    }
 975    fclose(bs);
 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", (FF_PKT *)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 == 1) {
1209       if (g_pVSSClient->InitializeForBackup()) {
1210          /* tell vss which drives to snapshot */
1211          char szWinDriveLetters[27];
1212          if (get_win32_driveletters((FF_PKT *)jcr->ff, szWinDriveLetters)) {
1213             Jmsg(jcr, M_INFO, 0, _("Generate VSS snapshots. Driver=\"%s\", Drive(s)=\"%s\"\n"), g_pVSSClient->GetDriverName(), szWinDriveLetters);
1214
1215             if (!g_pVSSClient->CreateSnapshots(szWinDriveLetters)) {
1216                   Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshots failed\n"));
1217             }
1218             else {
1219                /* tell user if snapshot creation of a specific drive failed */
1220                size_t i;
1221                for (i=0; i<strlen (szWinDriveLetters); i++) {
1222                   if (islower(szWinDriveLetters[i]))
1223                      Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshot of drive \"%c:\\\" failed\n"), szWinDriveLetters[i]);
1224                }
1225                /* inform user about writer states */
1226                for (i=0; i<g_pVSSClient->GetWriterCount(); i++) {
1227                   int msg_type = M_INFO;
1228                   if (g_pVSSClient->GetWriterState(i) < 0)
1229                      msg_type = M_WARNING;
1230
1231                   Jmsg(jcr, msg_type, 0, _("VSS Writer: %s\n"), g_pVSSClient->GetWriterInfo(i));
1232                }
1233             }
1234          }
1235       } else {
1236          Jmsg(jcr, M_WARNING, 0, _("VSS was not initialized properly. VSS support is disabled."));
1237       }
1238    }
1239 #endif
1240
1241    /*
1242     * Send Files to Storage daemon
1243     */
1244    Dmsg1(110, "begin blast ff=%p\n", (FF_PKT *)jcr->ff);
1245    if (!blast_data_to_storage_daemon(jcr, NULL)) {
1246       set_jcr_job_status(jcr, JS_ErrorTerminated);
1247       bnet_suppress_error_messages(sd, 1);
1248       bget_msg(sd);                   /* Read final response from append_data */
1249       Dmsg0(110, "Error in blast_data.\n");
1250    } else {
1251       set_jcr_job_status(jcr, JS_Terminated);
1252       if (jcr->JobStatus != JS_Terminated) {
1253          bnet_suppress_error_messages(sd, 1);
1254          goto cleanup;                /* bail out now */
1255       }
1256       /*
1257        * Expect to get response to append_data from Storage daemon
1258        */
1259       if (!response(jcr, sd, OK_append, "Append Data")) {
1260          set_jcr_job_status(jcr, JS_ErrorTerminated);
1261          goto cleanup;
1262       }
1263
1264       /*
1265        * Send Append End Data to Storage daemon
1266        */
1267       bnet_fsend(sd, append_end, jcr->Ticket);
1268       /* Get end OK */
1269       if (!response(jcr, sd, OK_end, "Append End")) {
1270          set_jcr_job_status(jcr, JS_ErrorTerminated);
1271          goto cleanup;
1272       }
1273
1274       /*
1275        * Send Append Close to Storage daemon
1276        */
1277       bnet_fsend(sd, append_close, jcr->Ticket);
1278       while (bget_msg(sd) >= 0) {    /* stop on signal or error */
1279          if (sscanf(sd->msg, OK_close, &SDJobStatus) == 1) {
1280             ok = 1;
1281             Dmsg2(200, "SDJobStatus = %d %c\n", SDJobStatus, (char)SDJobStatus);
1282          }
1283       }
1284       if (!ok) {
1285          Jmsg(jcr, M_FATAL, 0, _("Append Close with SD failed.\n"));
1286          goto cleanup;
1287       }
1288       if (SDJobStatus != JS_Terminated) {
1289          Jmsg(jcr, M_FATAL, 0, _("Bad status %d returned from Storage Daemon.\n"),
1290             SDJobStatus);
1291       }
1292    }
1293
1294 cleanup:
1295 #ifdef WIN32_VSS
1296    /* STOP VSS ON WIN 32 */
1297    /* tell vss to close the backup session */
1298    if (g_pVSSClient && enable_vss == 1)
1299       g_pVSSClient->CloseBackup();
1300 #endif
1301
1302    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1303       edit_uint64(jcr->ReadBytes, ed1),
1304       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1305    Dmsg1(110, "End FD msg: %s\n", dir->msg);
1306
1307    return 0;                          /* return and stop command loop */
1308 }
1309
1310 /*
1311  * Do a Verify for Director
1312  *
1313  */
1314 static int verify_cmd(JCR *jcr)
1315 {
1316    BSOCK *dir = jcr->dir_bsock;
1317    BSOCK *sd  = jcr->store_bsock;
1318    char level[100], ed1[50], ed2[50];
1319
1320    jcr->JobType = JT_VERIFY;
1321    if (sscanf(dir->msg, verifycmd, level) != 1) {
1322       bnet_fsend(dir, "2994 Bad verify command: %s\n", dir->msg);
1323       return 0;
1324    }
1325
1326    if (strcasecmp(level, "init") == 0) {
1327       jcr->JobLevel = L_VERIFY_INIT;
1328    } else if (strcasecmp(level, "catalog") == 0){
1329       jcr->JobLevel = L_VERIFY_CATALOG;
1330    } else if (strcasecmp(level, "volume") == 0){
1331       jcr->JobLevel = L_VERIFY_VOLUME_TO_CATALOG;
1332    } else if (strcasecmp(level, "data") == 0){
1333       jcr->JobLevel = L_VERIFY_DATA;
1334    } else if (strcasecmp(level, "disk_to_catalog") == 0) {
1335       jcr->JobLevel = L_VERIFY_DISK_TO_CATALOG;
1336    } else {
1337       bnet_fsend(dir, "2994 Bad verify level: %s\n", dir->msg);
1338       return 0;
1339    }
1340
1341    bnet_fsend(dir, OKverify);
1342
1343    generate_daemon_event(jcr, "JobStart");
1344
1345    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1346
1347    switch (jcr->JobLevel) {
1348    case L_VERIFY_INIT:
1349    case L_VERIFY_CATALOG:
1350       do_verify(jcr);
1351       break;
1352    case L_VERIFY_VOLUME_TO_CATALOG:
1353       if (!open_sd_read_session(jcr)) {
1354          return 0;
1355       }
1356       start_dir_heartbeat(jcr);
1357       do_verify_volume(jcr);
1358       stop_dir_heartbeat(jcr);
1359       /*
1360        * Send Close session command to Storage daemon
1361        */
1362       bnet_fsend(sd, read_close, jcr->Ticket);
1363       Dmsg1(130, "bfiled>stored: %s", sd->msg);
1364
1365       /* ****FIXME**** check response */
1366       bget_msg(sd);                      /* get OK */
1367
1368       /* Inform Storage daemon that we are done */
1369       bnet_sig(sd, BNET_TERMINATE);
1370
1371       break;
1372    case L_VERIFY_DISK_TO_CATALOG:
1373       do_verify(jcr);
1374       break;
1375    default:
1376       bnet_fsend(dir, "2994 Bad verify level: %s\n", dir->msg);
1377       return 0;
1378    }
1379
1380    bnet_sig(dir, BNET_EOD);
1381
1382    /* Send termination status back to Dir */
1383    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1384       edit_uint64(jcr->ReadBytes, ed1),
1385       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1386
1387    /* Inform Director that we are done */
1388    bnet_sig(dir, BNET_TERMINATE);
1389    return 0;                          /* return and terminate command loop */
1390 }
1391
1392 /*
1393  * Do a Restore for Director
1394  *
1395  */
1396 static int restore_cmd(JCR *jcr)
1397 {
1398    BSOCK *dir = jcr->dir_bsock;
1399    BSOCK *sd = jcr->store_bsock;
1400    POOLMEM *where;
1401    int prefix_links;
1402    char replace;
1403    char ed1[50], ed2[50];
1404
1405    /*
1406     * Scan WHERE (base directory for restore) from command
1407     */
1408    Dmsg0(150, "restore command\n");
1409    /* Pickup where string */
1410    where = get_memory(dir->msglen+1);
1411    *where = 0;
1412
1413    if (sscanf(dir->msg, restorecmd, &replace, &prefix_links, where) != 3) {
1414       if (sscanf(dir->msg, restorecmd1, &replace, &prefix_links) != 2) {
1415          pm_strcpy(jcr->errmsg, dir->msg);
1416          Jmsg(jcr, M_FATAL, 0, _("Bad replace command. CMD=%s\n"), jcr->errmsg);
1417          return 0;
1418       }
1419       *where = 0;
1420    }
1421    /* Turn / into nothing */
1422    if (where[0] == '/' && where[1] == 0) {
1423       where[0] = 0;
1424    }
1425
1426    Dmsg2(150, "Got replace %c, where=%s\n", replace, where);
1427    unbash_spaces(where);
1428    jcr->where = bstrdup(where);
1429    free_pool_memory(where);
1430    jcr->replace = replace;
1431    jcr->prefix_links = prefix_links;
1432
1433    bnet_fsend(dir, OKrestore);
1434    Dmsg1(110, "bfiled>dird: %s", dir->msg);
1435
1436    jcr->JobType = JT_RESTORE;
1437
1438    set_jcr_job_status(jcr, JS_Blocked);
1439
1440    if (!open_sd_read_session(jcr)) {
1441       set_jcr_job_status(jcr, JS_ErrorTerminated);
1442       goto bail_out;
1443    }
1444
1445    set_jcr_job_status(jcr, JS_Running);
1446
1447    /*
1448     * Do restore of files and data
1449     */
1450    start_dir_heartbeat(jcr);
1451    generate_daemon_event(jcr, "JobStart");
1452    do_restore(jcr);
1453    stop_dir_heartbeat(jcr);
1454
1455    set_jcr_job_status(jcr, JS_Terminated);
1456    if (jcr->JobStatus != JS_Terminated) {
1457       bnet_suppress_error_messages(sd, 1);
1458    }
1459
1460    /*
1461     * Send Close session command to Storage daemon
1462     */
1463    bnet_fsend(sd, read_close, jcr->Ticket);
1464    Dmsg1(130, "bfiled>stored: %s", sd->msg);
1465
1466    bget_msg(sd);                      /* get OK */
1467
1468    /* Inform Storage daemon that we are done */
1469    bnet_sig(sd, BNET_TERMINATE);
1470
1471 bail_out:
1472
1473    if (jcr->Errors) {
1474       set_jcr_job_status(jcr, JS_ErrorTerminated);
1475    }
1476    /* Send termination status back to Dir */
1477    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles,
1478       edit_uint64(jcr->ReadBytes, ed1),
1479       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);
1480
1481    /* Inform Director that we are done */
1482    bnet_sig(dir, BNET_TERMINATE);
1483
1484    Dmsg0(130, "Done in job.c\n");
1485    return 0;                          /* return and terminate command loop */
1486 }
1487
1488 static int open_sd_read_session(JCR *jcr)
1489 {
1490    BSOCK *sd = jcr->store_bsock;
1491
1492    if (!sd) {
1493       Jmsg(jcr, M_FATAL, 0, _("Improper calling sequence.\n"));
1494       return 0;
1495    }
1496    Dmsg4(120, "VolSessId=%ld VolsessT=%ld SF=%ld EF=%ld\n",
1497       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile);
1498    Dmsg2(120, "JobId=%d vol=%s\n", jcr->JobId, "DummyVolume");
1499    /*
1500     * Open Read Session with Storage daemon
1501     */
1502    bnet_fsend(sd, read_open, jcr->VolumeName,
1503       jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile,
1504       jcr->StartBlock, jcr->EndBlock);
1505    Dmsg1(110, ">stored: %s", sd->msg);
1506
1507    /*
1508     * Get ticket number
1509     */
1510    if (bget_msg(sd) >= 0) {
1511       Dmsg1(110, "bfiled<stored: %s", sd->msg);
1512       if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) {
1513          Jmsg(jcr, M_FATAL, 0, _("Bad response to SD read open: %s\n"), sd->msg);
1514          return 0;
1515       }
1516       Dmsg1(110, "bfiled: got Ticket=%d\n", jcr->Ticket);
1517    } else {
1518       Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to read open command\n"));
1519       return 0;
1520    }
1521
1522    if (!send_bootstrap_file(jcr)) {
1523       return 0;
1524    }
1525
1526    /*
1527     * Start read of data with Storage daemon
1528     */
1529    bnet_fsend(sd, read_data, jcr->Ticket);
1530    Dmsg1(110, ">stored: %s", sd->msg);
1531
1532    /*
1533     * Get OK data
1534     */
1535    if (!response(jcr, sd, OK_data, "Read Data")) {
1536       return 0;
1537    }
1538    return 1;
1539 }
1540
1541 /*
1542  * Destroy the Job Control Record and associated
1543  * resources (sockets).
1544  */
1545 static void filed_free_jcr(JCR *jcr)
1546 {
1547    if (jcr->store_bsock) {
1548       bnet_close(jcr->store_bsock);
1549    }
1550    if (jcr->RestoreBootstrap) {
1551       unlink(jcr->RestoreBootstrap);
1552       free_pool_memory(jcr->RestoreBootstrap);
1553       jcr->RestoreBootstrap = NULL;
1554    }
1555    if (jcr->last_fname) {
1556       free_pool_memory(jcr->last_fname);
1557    }
1558    if (jcr->RunAfterJob) {
1559       free_pool_memory(jcr->RunAfterJob);
1560    }
1561
1562
1563    return;
1564 }
1565
1566 /*
1567  * Get response from Storage daemon to a command we
1568  * sent. Check that the response is OK.
1569  *
1570  *  Returns: 0 on failure
1571  *           1 on success
1572  */
1573 int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd)
1574 {
1575    if (sd->errors) {
1576       return 0;
1577    }
1578    if (bget_msg(sd) > 0) {
1579       Dmsg0(110, sd->msg);
1580       if (strcmp(sd->msg, resp) == 0) {
1581          return 1;
1582       }
1583    }
1584    if (job_canceled(jcr)) {
1585       return 0;                       /* if canceled avoid useless error messages */
1586    }
1587    if (is_bnet_error(sd)) {
1588       Jmsg2(jcr, M_FATAL, 0, _("Comm error with SD. bad response to %s. ERR=%s\n"),
1589          cmd, bnet_strerror(sd));
1590    } else {
1591       Jmsg3(jcr, M_FATAL, 0, _("Bad response to %s command. Wanted %s, got %s\n"),
1592          cmd, resp, sd->msg);
1593    }
1594    return 0;
1595 }
1596
1597 static int send_bootstrap_file(JCR *jcr)
1598 {
1599    FILE *bs;
1600    char buf[2000];
1601    BSOCK *sd = jcr->store_bsock;
1602    const char *bootstrap = "bootstrap\n";
1603    int stat = 0;
1604
1605    Dmsg1(400, "send_bootstrap_file: %s\n", jcr->RestoreBootstrap);
1606    if (!jcr->RestoreBootstrap) {
1607       return 1;
1608    }
1609    bs = fopen(jcr->RestoreBootstrap, "r");
1610    if (!bs) {
1611       berrno be;
1612       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"),
1613          jcr->RestoreBootstrap, be.strerror());
1614       set_jcr_job_status(jcr, JS_ErrorTerminated);
1615       goto bail_out;
1616    }
1617    sd->msglen = pm_strcpy(sd->msg, bootstrap);
1618    bnet_send(sd);
1619    while (fgets(buf, sizeof(buf), bs)) {
1620       sd->msglen = Mmsg(sd->msg, "%s", buf);
1621       bnet_send(sd);
1622    }
1623    bnet_sig(sd, BNET_EOD);
1624    fclose(bs);
1625    if (!response(jcr, sd, OKSDbootstrap, "Bootstrap")) {
1626       set_jcr_job_status(jcr, JS_ErrorTerminated);
1627       goto bail_out;
1628    }
1629    stat = 1;
1630
1631 bail_out:
1632    if (jcr->RestoreBootstrap) {
1633       unlink(jcr->RestoreBootstrap);
1634       free_pool_memory(jcr->RestoreBootstrap);
1635       jcr->RestoreBootstrap = NULL;
1636    }
1637
1638    return stat;
1639 }