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