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