]> git.sur5r.net Git - bacula/bacula/blobdiff - bacula/src/filed/job.c
- Add .status [current|last] command to filed and stored
[bacula/bacula] / bacula / src / filed / job.c
index 274bb7426df2196d247c38149de4d2ca1d251bef..86bdfab4bc818c0b10b265bf8877f414b537a5cb 100644 (file)
@@ -7,7 +7,7 @@
  *
  */
 /*
-   Copyright (C) 2000-2003 Kern Sibbald and John Walker
+   Copyright (C) 2000-2004 Kern Sibbald and John Walker
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
 
 #include "bacula.h"
 #include "filed.h"
-#include "host.h"
 
 extern char my_name[];
 extern CLIENT *me;                   /* our client resource */
                        
 /* Imported functions */
 extern int status_cmd(JCR *jcr);
-                                  
+extern int qstatus_cmd(JCR *jcr);
+
 /* Forward referenced functions */
 static int backup_cmd(JCR *jcr);
 static int bootstrap_cmd(JCR *jcr);
@@ -46,21 +46,26 @@ static int exclude_cmd(JCR *jcr);
 static int hello_cmd(JCR *jcr);
 static int job_cmd(JCR *jcr);
 static int include_cmd(JCR *jcr);
+static int fileset_cmd(JCR *jcr);
 static int level_cmd(JCR *jcr);
 static int verify_cmd(JCR *jcr);
 static int restore_cmd(JCR *jcr);
 static int storage_cmd(JCR *jcr);
 static int session_cmd(JCR *jcr);
-static int response(JCR *jcr, BSOCK *sd, char *resp, char *cmd);
+static int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd);
 static void filed_free_jcr(JCR *jcr);
 static int open_sd_read_session(JCR *jcr);
 static int send_bootstrap_file(JCR *jcr);
+static int runbefore_cmd(JCR *jcr);
+static int runafter_cmd(JCR *jcr);
+static int run_cmd(JCR *jcr, char *cmd, const char *name);
+static void set_options(findFOPTS *fo, const char *opts);
 
 
 /* Exported functions */
 
 struct s_cmds {
-   char *cmd;
+   const char *cmd;
    int (*func)(JCR *);
 };
 
@@ -68,21 +73,25 @@ struct s_cmds {
  * The following are the recognized commands from the Director. 
  */
 static struct s_cmds cmds[] = {
-   {"backup",   backup_cmd},
-   {"cancel",   cancel_cmd},
-   {"setdebug=", setdebug_cmd},
-   {"estimate", estimate_cmd},
-   {"exclude",  exclude_cmd},
-   {"Hello",    hello_cmd},
-   {"include",  include_cmd},
-   {"JobId=",   job_cmd},
-   {"level = ", level_cmd},
-   {"restore",  restore_cmd},
-   {"session",  session_cmd},
-   {"status",   status_cmd},
-   {"storage ", storage_cmd},
-   {"verify",   verify_cmd},
-   {"bootstrap",bootstrap_cmd},
+   {"backup",       backup_cmd},
+   {"cancel",       cancel_cmd},
+   {"setdebug=",    setdebug_cmd},
+   {"estimate",     estimate_cmd},
+   {"exclude",      exclude_cmd},
+   {"Hello",        hello_cmd},
+   {"include",      include_cmd},
+   {"fileset",      fileset_cmd},
+   {"JobId=",       job_cmd},
+   {"level = ",     level_cmd},
+   {"restore",      restore_cmd},
+   {"session",      session_cmd},
+   {"status",       status_cmd},
+   {".status",      qstatus_cmd},
+   {"storage ",     storage_cmd},
+   {"verify",       verify_cmd},
+   {"bootstrap",    bootstrap_cmd},
+   {"RunBeforeJob", runbefore_cmd},
+   {"RunAfterJob",  runafter_cmd},
    {NULL,      NULL}                  /* list terminator */
 };
 
@@ -90,15 +99,18 @@ static struct s_cmds cmds[] = {
 static char jobcmd[]      = "JobId=%d Job=%127s SDid=%d SDtime=%d Authorization=%100s";
 static char storaddr[]    = "storage address=%s port=%d ssl=%d\n";
 static char sessioncmd[]  = "session %127s %ld %ld %ld %ld %ld %ld\n";
-static char restorecmd[]  = "restore replace=%c where=%s\n";
-static char restorecmd1[] = "restore replace=%c where=\n";
+static char restorecmd[]  = "restore replace=%c prelinks=%d where=%s\n";
+static char restorecmd1[] = "restore replace=%c prelinks=%d where=\n";
 static char verifycmd[]   = "verify level=%30s\n";
+static char estimatecmd[] = "estimate listing=%d\n";
+static char runbefore[]   = "RunBeforeJob %s\n";
+static char runafter[]    = "RunAfterJob %s\n";
 
 /* Responses sent to Director */
 static char errmsg[]      = "2999 Invalid command\n";
 static char no_auth[]     = "2998 No Authorization\n";
 static char OKinc[]       = "2000 OK include\n";
-static char OKest[]       = "2000 OK estimate files=%ld bytes=%ld\n";
+static char OKest[]       = "2000 OK estimate files=%u bytes=%s\n";
 static char OKexc[]       = "2000 OK exclude\n";
 static char OKlevel[]     = "2000 OK level\n";
 static char OKbackup[]    = "2000 OK backup\n";
@@ -107,10 +119,12 @@ static char OKverify[]    = "2000 OK verify\n";
 static char OKrestore[]   = "2000 OK restore\n";
 static char OKsession[]   = "2000 OK session\n";
 static char OKstore[]     = "2000 OK storage\n";
-static char OKjob[]       = "2000 OK Job " FDHOST "," DISTNAME "," DISTVER;
+static char OKjob[]       = "2000 OK Job %s,%s,%s";
 static char OKsetdebug[]  = "2000 OK setdebug=%d\n";
 static char BADjob[]      = "2901 Bad Job\n";
 static char EndJob[]      = "2800 End Job TermCode=%d JobFiles=%u ReadBytes=%s JobBytes=%s Errors=%u\n";
+static char OKRunBefore[] = "2000 OK RunBefore\n";
+static char OKRunAfter[]  = "2000 OK RunAfter\n";
 
 /* Responses received from Storage Daemon */
 static char OK_end[]       = "3000 OK end\n";
@@ -149,7 +163,8 @@ static char read_close[]   = "read close session %d\n";
  */
 void *handle_client_request(void *dirp)
 {
-   int i, found, quit;
+   int i; 
+   bool found, quit;
    JCR *jcr;
    BSOCK *dir = (BSOCK *)dirp;
 
@@ -166,7 +181,7 @@ void *handle_client_request(void *dirp)
 
    /**********FIXME******* add command handler error code */
 
-   for (quit=0; !quit;) {
+   for (quit=false; !quit;) {
 
       /* Read command */
       if (bnet_recv(dir) < 0) {
@@ -174,24 +189,25 @@ void *handle_client_request(void *dirp)
       }
       dir->msg[dir->msglen] = 0;
       Dmsg1(100, "<dird: %s", dir->msg);
-      found = FALSE;
+      found = false;
       for (i=0; cmds[i].cmd; i++) {
         if (strncmp(cmds[i].cmd, dir->msg, strlen(cmds[i].cmd)) == 0) {
            if (!jcr->authenticated && cmds[i].func != hello_cmd) {
               bnet_fsend(dir, no_auth);
               break;
            }
-           found = TRUE;                /* indicate command found */
+           found = true;                /* indicate command found */
+            Dmsg1(100, "Executing %s command.\n", cmds[i].cmd);
            if (!cmds[i].func(jcr)) {    /* do command */
-              quit = TRUE;              /* error or fully terminated,  get out */
-               Dmsg0(20, "Command error or Job done.\n");
+              quit = true;              /* error or fully terminated,  get out */
+               Dmsg0(20, "Quit command loop due to command error or Job done.\n");
            }
            break;
         }
       }
       if (!found) {                  /* command not found */
         bnet_fsend(dir, errmsg);
-        quit = TRUE;
+        quit = true;
         break;
       }
    }
@@ -201,9 +217,56 @@ void *handle_client_request(void *dirp)
       bnet_sig(jcr->store_bsock, BNET_TERMINATE);
    }
 
+   if (jcr->RunAfterJob && !job_canceled(jcr)) {
+      run_cmd(jcr, jcr->RunAfterJob, "ClientRunAfterJob");
+   }
+
    /* Inform Director that we are done */
    bnet_sig(dir, BNET_TERMINATE);
 
+   /* Clean up fileset */
+   FF_PKT *ff = (FF_PKT *)jcr->ff;
+   findFILESET *fileset = ff->fileset;
+   if (fileset) {
+      int i, j, k;
+      /* Delete FileSet Include lists */
+      for (i=0; i<fileset->include_list.size(); i++) {
+        findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
+        for (j=0; j<incexe->opts_list.size(); j++) {
+           findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
+           for (k=0; k<fo->regex.size(); k++) {
+              regfree((regex_t *)fo->regex.get(k));
+           }
+           fo->regex.destroy();
+           fo->wild.destroy();
+           fo->base.destroy();
+           if (fo->reader) {
+              free(fo->reader);
+           }
+           if (fo->writer) {
+              free(fo->writer);
+           }
+        }
+        incexe->opts_list.destroy();
+        incexe->name_list.destroy();
+      }
+      fileset->include_list.destroy();
+
+      /* Delete FileSet Exclude lists */
+      for (i=0; i<fileset->exclude_list.size(); i++) {
+        findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
+        for (j=0; j<incexe->opts_list.size(); j++) {
+           findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
+           fo->regex.destroy();
+           fo->wild.destroy();
+           fo->base.destroy();
+        }
+        incexe->opts_list.destroy();
+        incexe->name_list.destroy();
+      }
+      fileset->exclude_list.destroy();
+      free(fileset);
+   }
    Dmsg0(100, "Calling term_find_files\n");
    term_find_files((FF_PKT *)jcr->ff);
    Dmsg0(100, "Done with term_find_files\n");
@@ -223,7 +286,7 @@ static int hello_cmd(JCR *jcr)
       return 0;
    }
    Dmsg0(120, "OK Authenticate\n");
-   jcr->authenticated = TRUE;
+   jcr->authenticated = true;
    return 1;
 }
 
@@ -240,12 +303,24 @@ static int cancel_cmd(JCR *jcr)
       if (!(cjcr=get_jcr_by_full_name(Job))) {
          bnet_fsend(dir, "2901 Job %s not found.\n", Job);
       } else {
+        if (cjcr->store_bsock) {
+           P(cjcr->mutex);
+           cjcr->store_bsock->timed_out = 1;
+           cjcr->store_bsock->terminated = 1;
+/* 
+ * #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
+ */
+#if !defined(HAVE_CYGWIN)
+           pthread_kill(cjcr->my_thread_id, TIMEOUT_SIGNAL);
+#endif
+           V(cjcr->mutex);
+        }
         set_jcr_job_status(cjcr, JS_Canceled);
         free_jcr(cjcr);
-         bnet_fsend(dir, "2001 Job %s marked to be canceled.\n", Job);
+         bnet_fsend(dir, _("2001 Job %s marked to be canceled.\n"), Job);
       }
    } else {
-      bnet_fsend(dir, "2902 Error scanning cancel command.\n");
+      bnet_fsend(dir, _("2902 Error scanning cancel command.\n"));
    }
    bnet_sig(dir, BNET_EOD);
    return 1;
@@ -259,14 +334,16 @@ static int cancel_cmd(JCR *jcr)
 static int setdebug_cmd(JCR *jcr)
 {
    BSOCK *dir = jcr->dir_bsock;
-   int level;
+   int level, trace_flag;
 
    Dmsg1(110, "setdebug_cmd: %s", dir->msg);
-   if (sscanf(dir->msg, "setdebug=%d", &level) != 1 || level < 0) {
-      bnet_fsend(dir, "2991 Bad setdebug command: %s\n", dir->msg);
+   if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      bnet_fsend(dir, "2991 Bad setdebug command: %s\n", jcr->errmsg);
       return 0;   
    }
    debug_level = level;
+   set_trace(trace_flag);
    return bnet_fsend(dir, OKsetdebug, level);
 }
 
@@ -274,8 +351,19 @@ static int setdebug_cmd(JCR *jcr)
 static int estimate_cmd(JCR *jcr)
 {
    BSOCK *dir = jcr->dir_bsock;
+   char ed2[50];
+
+   if (sscanf(dir->msg, estimatecmd, &jcr->listing) != 1) {
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg(jcr, M_FATAL, 0, _("Bad estimate command: %s"), jcr->errmsg);
+      bnet_fsend(dir, "2992 Bad estimate command.\n");
+      return 0;
+   }
    make_estimate(jcr);
-   return bnet_fsend(dir, OKest, jcr->num_files_examined, jcr->JobBytes);
+   bnet_fsend(dir, OKest, jcr->num_files_examined, 
+      edit_uint64_with_commas(jcr->JobBytes, ed2));
+   bnet_sig(dir, BNET_EOD);
+   return 1;
 }
 
 /*
@@ -290,33 +378,190 @@ static int job_cmd(JCR *jcr)
    if (sscanf(dir->msg, jobcmd,  &jcr->JobId, jcr->Job,  
              &jcr->VolSessionId, &jcr->VolSessionTime,
              sd_auth_key) != 5) {
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg(jcr, M_FATAL, 0, _("Bad Job Command: %s"), jcr->errmsg);
       bnet_fsend(dir, BADjob);
-      Jmsg(jcr, M_FATAL, 0, _("Bad Job Command: %s\n"), dir->msg);
       free_pool_memory(sd_auth_key);
       return 0;
    }
    jcr->sd_auth_key = bstrdup(sd_auth_key);
    free_pool_memory(sd_auth_key);
    Dmsg2(120, "JobId=%d Auth=%s\n", jcr->JobId, jcr->sd_auth_key);
-   return bnet_fsend(dir, OKjob);
+   return bnet_fsend(dir, OKjob, HOST_OS, DISTNAME, DISTVER);
 }
 
+static int runbefore_cmd(JCR *jcr)
+{
+   int stat;
+   BSOCK *dir = jcr->dir_bsock;
+   POOLMEM *cmd = get_memory(dir->msglen+1);
+
+   Dmsg1(100, "runbefore_cmd: %s", dir->msg);
+   if (sscanf(dir->msg, runbefore, cmd) != 1) {
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg1(jcr, M_FATAL, 0, _("Bad RunBeforeJob command: %s\n"), jcr->errmsg);
+      bnet_fsend(dir, "2905 Bad RunBeforeJob command.\n");
+      free_memory(cmd);
+      return 0;
+   }
+   unbash_spaces(cmd);
+
+   /* Run the command now */
+   stat = run_cmd(jcr, cmd, "ClientRunBeforeJob");
+   free_memory(cmd);
+   if (stat) {
+      bnet_fsend(dir, OKRunBefore);
+      return 1;
+   } else {
+      bnet_fsend(dir, "2905 Bad RunBeforeJob command.\n");
+      return 0;
+   }
+}
+
+static int runafter_cmd(JCR *jcr)
+{
+   BSOCK *dir = jcr->dir_bsock;
+   POOLMEM *msg = get_memory(dir->msglen+1);
+
+   Dmsg1(100, "runafter_cmd: %s", dir->msg);
+   if (sscanf(dir->msg, runafter, msg) != 1) {
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg1(jcr, M_FATAL, 0, _("Bad RunAfter command: %s\n"), jcr->errmsg);
+      bnet_fsend(dir, "2905 Bad RunAfterJob command.\n");
+      free_memory(msg);
+      return 0;
+   }
+   unbash_spaces(msg);
+   if (jcr->RunAfterJob) {
+      free_pool_memory(jcr->RunAfterJob);
+   }
+   jcr->RunAfterJob = get_pool_memory(PM_FNAME);
+   pm_strcpy(&jcr->RunAfterJob, msg);
+   free_pool_memory(msg);
+   return bnet_fsend(dir, OKRunAfter);
+}
+
+static int run_cmd(JCR *jcr, char *cmd, const char *name)
+{
+   POOLMEM *ecmd = get_pool_memory(PM_FNAME);
+   int status;
+   BPIPE *bpipe;
+   char line[MAXSTRING];
+   
+   ecmd = edit_job_codes(jcr, ecmd, cmd, "");
+   bpipe = open_bpipe(ecmd, 0, "r");
+   free_pool_memory(ecmd);
+   if (bpipe == NULL) {
+      Jmsg(jcr, M_FATAL, 0, _("%s could not execute\n"), name);
+      set_jcr_job_status(jcr, JS_FatalError);
+      return 0;
+   }
+   while (fgets(line, sizeof(line), bpipe->rfd)) {
+      Jmsg(jcr, M_INFO, 0, _("%s: %s"), name, line);
+   }
+   status = close_bpipe(bpipe);
+   if (status != 0) {
+      Jmsg(jcr, M_FATAL, 0, _("%s returned non-zero status=%d\n"), name,
+        status);
+      set_jcr_job_status(jcr, JS_FatalError);
+      return 0;
+   }
+   return 1;
+}
+
+
 #define INC_LIST 0
 #define EXC_LIST 1
 
 static void add_fname_to_list(JCR *jcr, char *fname, int list)
 {
-   char *p;  
-   if (list == INC_LIST) {
-      add_fname_to_include_list((FF_PKT *)jcr->ff, 1, fname);
-   } else {
-      /* Skip leading options -- currently ignored */
-      for (p=fname; *p && *p != ' '; p++)
-        { }
-      /* Skip spaces */
-      for ( ; *p && *p == ' '; p++)
-        { }
-      add_fname_to_exclude_list((FF_PKT *)jcr->ff, p);
+   char *p, *q;
+   BPIPE *bpipe;
+   POOLMEM *fn;
+   FILE *ffd;
+   char buf[1000];
+   int optlen;
+   int stat;
+
+   /* Skip leading options -- currently ignored */
+   for (p=fname; *p && *p != ' '; p++)
+      { }
+   /* Skip spaces, and q points to first space */
+   for (q=NULL; *p && *p == ' '; p++) {
+      if (!q) {
+        q = p;
+      }
+   }
+
+   switch (*p) {
+   case '|':
+      p++;                           /* skip over | */
+      fn = get_pool_memory(PM_FNAME);
+      fn = edit_job_codes(jcr, fn, p, "");
+      bpipe = open_bpipe(fn, 0, "r");
+      free_pool_memory(fn);
+      if (!bpipe) {
+         Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
+           p, strerror(errno));
+        return;
+      }
+      /* Copy File options */
+      if (list == INC_LIST) {
+        *q = 0;                      /* terminate options */
+        strcpy(buf, fname);
+         strcat(buf, " ");
+        optlen = strlen(buf);
+      } else {
+        optlen = 0;
+      }
+      while (fgets(buf+optlen, sizeof(buf)-optlen, bpipe->rfd)) {
+        strip_trailing_junk(buf);
+        if (list == INC_LIST) {
+           add_fname_to_include_list((FF_PKT *)jcr->ff, 1, buf);
+        } else {
+           add_fname_to_exclude_list((FF_PKT *)jcr->ff, buf);
+        }
+      }
+      if ((stat=close_bpipe(bpipe)) != 0) {
+         Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. RtnStat=%d ERR=%s\n"),
+           p, stat, strerror(errno));
+        return;
+      }
+      break;
+   case '<':
+      p++;                     /* skip over < */
+      if ((ffd = fopen(p, "r")) == NULL) {
+        berrno be;
+         Jmsg(jcr, M_FATAL, 0, _("Cannot open %s file: %s. ERR=%s\n"),
+            list==INC_LIST?"included":"excluded", p, be.strerror());
+        return;
+      }
+      /* Copy File options */
+      if (list == INC_LIST) {
+        *q = 0;                      /* terminate options */
+        strcpy(buf, fname);
+         strcat(buf, " ");
+        optlen = strlen(buf);
+      } else {
+        optlen = 0;
+      }
+      while (fgets(buf+optlen, sizeof(buf)-optlen, ffd)) {
+        strip_trailing_junk(buf);
+        if (list == INC_LIST) {
+           add_fname_to_include_list((FF_PKT *)jcr->ff, 1, buf);
+        } else {
+           add_fname_to_exclude_list((FF_PKT *)jcr->ff, buf);
+        }
+      }
+      fclose(ffd);
+      break;
+   default:
+      if (list == INC_LIST) {
+        add_fname_to_include_list((FF_PKT *)jcr->ff, 1, fname);
+      } else {
+        add_fname_to_exclude_list((FF_PKT *)jcr->ff, p);
+      }
+      break;
    }
 }
 
@@ -339,6 +584,345 @@ static int include_cmd(JCR *jcr)
    return bnet_fsend(dir, OKinc);
 }
 
+static bool init_fileset(JCR *jcr) 
+{
+   FF_PKT *ff;
+   findFILESET *fileset;
+
+   if (!jcr->ff) {     
+      return false;
+   }
+   ff = (FF_PKT *)jcr->ff;
+   if (ff->fileset) {
+      return false;
+   }
+   fileset = (findFILESET *)malloc(sizeof(findFILESET));
+   memset(fileset, 0, sizeof(findFILESET));
+   ff->fileset = fileset;
+   fileset->state = state_none;
+   fileset->include_list.init(1, true);
+   fileset->exclude_list.init(1, true);
+   return true;
+}
+
+static findFOPTS *start_options(FF_PKT *ff)
+{
+   int state = ff->fileset->state;
+   findINCEXE *incexe = ff->fileset->incexe;
+
+   if (state != state_options) {
+      ff->fileset->state = state_options;
+      findFOPTS *fo = (findFOPTS *)malloc(sizeof(findFOPTS));
+      memset(fo, 0, sizeof(findFOPTS));
+      fo->regex.init(1, true);
+      fo->wild.init(1, true);
+      fo->base.init(1, true);
+      incexe->current_opts = fo;
+      incexe->opts_list.append(fo);
+   }
+   return incexe->current_opts;
+
+}
+
+/*
+ * Add fname to include/exclude fileset list. First check for
+ * | and < and if necessary perform command.
+ */
+static void add_file_to_fileset(JCR *jcr, const char *fname, findFILESET *fileset)
+{
+   char *p;
+   BPIPE *bpipe;
+   POOLMEM *fn;
+   FILE *ffd;
+   char buf[1000];
+   int stat;
+
+   p = (char *)fname;
+   switch (*p) {
+   case '|':
+      p++;                           /* skip over | */
+      fn = get_pool_memory(PM_FNAME);
+      fn = edit_job_codes(jcr, fn, p, "");
+      bpipe = open_bpipe(fn, 0, "r");
+      free_pool_memory(fn);
+      if (!bpipe) {
+         Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
+           p, strerror(errno));
+        return;
+      }
+      while (fgets(buf, sizeof(buf), bpipe->rfd)) {
+        strip_trailing_junk(buf);
+        fileset->incexe->name_list.append(bstrdup(buf));
+      }
+      if ((stat=close_bpipe(bpipe)) != 0) {
+         Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. RtnStat=%d ERR=%s\n"),
+           p, stat, strerror(errno));
+        return;
+      }
+      break;
+   case '<':
+      p++;                     /* skip over < */
+      if ((ffd = fopen(p, "r")) == NULL) {
+        berrno be;
+         Jmsg(jcr, M_FATAL, 0, _("Cannot open FileSet input file: %s. ERR=%s\n"),
+           p, be.strerror());
+        return;
+      }
+      while (fgets(buf, sizeof(buf), ffd)) {
+        strip_trailing_junk(buf);
+        fileset->incexe->name_list.append(bstrdup(buf));
+      }
+      fclose(ffd);
+      break;
+   default:
+      fileset->incexe->name_list.append(bstrdup(fname));
+      break;
+   }
+}
+
+   
+static void add_fileset(JCR *jcr, const char *item)
+{
+   FF_PKT *ff = (FF_PKT *)jcr->ff;
+   findFILESET *fileset = ff->fileset;
+   int state = fileset->state;
+   findFOPTS *current_opts;
+
+   Dmsg1(100, "%s\n", item);
+   int code = item[0];
+   if (item[1] == ' ') {              /* If string follows */
+      item += 2;                     /* point to string */
+   }
+
+   if (state == state_error) {
+      return;
+   }
+   switch (code) {
+   case 'I':
+      /* New include */
+      fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
+      memset(fileset->incexe, 0, sizeof(findINCEXE));
+      fileset->incexe->opts_list.init(1, true);
+      fileset->incexe->name_list.init(1, true);
+      fileset->include_list.append(fileset->incexe);
+      break;
+   case 'E':
+      /* New exclude */
+      fileset->incexe = (findINCEXE *)malloc(sizeof(findINCEXE));
+      memset(fileset->incexe, 0, sizeof(findINCEXE));
+      fileset->incexe->opts_list.init(1, true);
+      fileset->incexe->name_list.init(1, true);
+      fileset->exclude_list.append(fileset->incexe);
+      break;
+   case 'N':
+      state = state_none;
+      break;
+   case 'F':
+      /* File item to either include/include list */
+      state = state_include;
+      add_file_to_fileset(jcr, item, fileset);
+      break;
+   case 'R':
+      current_opts = start_options(ff);
+      regex_t *preg;
+      int rc;
+      char prbuf[500];
+      preg = (regex_t *)malloc(sizeof(regex_t));
+      rc = regcomp(preg, item, REG_EXTENDED);
+      if (rc != 0) {
+        regerror(rc, preg, prbuf, sizeof(prbuf));
+        regfree(preg);
+        free(preg);
+         Jmsg(jcr, M_FATAL, 0, "REGEX %s compile error. ERR=%s\n", item, prbuf);
+        state = state_error;
+        break;
+      }
+      current_opts->regex.append(preg);
+      state = state_options;
+      break;
+   case 'B':
+      current_opts = start_options(ff);
+      current_opts->base.append(bstrdup(item));
+      state = state_options;
+      break;
+   case 'W':
+      current_opts = start_options(ff);
+      current_opts->wild.append(bstrdup(item));
+      state = state_options;
+      break;
+   case 'O':   
+      current_opts = start_options(ff);
+      set_options(current_opts, item);
+      state = state_options;
+      break;
+   case 'D':
+      current_opts = start_options(ff);
+      current_opts->reader = bstrdup(item);
+      state = state_options;
+      break;
+   case 'T':
+      current_opts = start_options(ff);
+      current_opts->writer = bstrdup(item);
+      state = state_options;
+      break;
+   default:
+      Jmsg(jcr, M_FATAL, 0, "Invalid FileSet command: %s\n", item);
+      state = state_error;
+      break;
+   }
+   ff->fileset->state = state;
+}
+
+static bool term_fileset(JCR *jcr)
+{
+   FF_PKT *ff = (FF_PKT *)jcr->ff;
+   findFILESET *fileset = ff->fileset;
+   int i, j, k;
+
+   for (i=0; i<fileset->include_list.size(); i++) {
+      findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
+      Dmsg0(400, "I\n");
+      for (j=0; j<incexe->opts_list.size(); j++) {
+        findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
+        for (k=0; k<fo->regex.size(); k++) {
+            Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
+        }
+        for (k=0; k<fo->wild.size(); k++) {
+            Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
+        }
+        for (k=0; k<fo->base.size(); k++) {
+            Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
+        }
+        if (fo->reader) {
+            Dmsg1(400, "D %s\n", fo->reader);
+        }
+        if (fo->writer) {
+            Dmsg1(400, "T %s\n", fo->writer);
+        }
+      }
+      for (j=0; j<incexe->name_list.size(); j++) {
+         Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j));
+      }
+   }
+   for (i=0; i<fileset->exclude_list.size(); i++) {
+      findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
+      Dmsg0(400, "E\n");
+      for (j=0; j<incexe->opts_list.size(); j++) {
+        findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
+        for (k=0; k<fo->regex.size(); k++) {
+            Dmsg1(400, "R %s\n", (char *)fo->regex.get(k));
+        }
+        for (k=0; k<fo->wild.size(); k++) {
+            Dmsg1(400, "W %s\n", (char *)fo->wild.get(k));
+        }
+        for (k=0; k<fo->base.size(); k++) {
+            Dmsg1(400, "B %s\n", (char *)fo->base.get(k));
+        }
+      }
+      for (j=0; j<incexe->name_list.size(); j++) {
+         Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j));
+      }
+   }
+   return ff->fileset->state != state_error;
+}
+
+
+/*
+ * As an optimization, we should do this during
+ *  "compile" time in filed/job.c, and keep only a bit mask
+ *  and the Verify options.
+ */
+static void set_options(findFOPTS *fo, const char *opts)
+{
+   int j;
+   const char *p;
+
+   for (p=opts; *p; p++) {
+      switch (*p) {
+      case 'a':                 /* alway replace */
+      case '0':                 /* no option */
+        break;
+      case 'e':
+        fo->flags |= FO_EXCLUDE;
+        break;
+      case 'f':
+        fo->flags |= FO_MULTIFS;
+        break;
+      case 'h':                 /* no recursion */
+        fo->flags |= FO_NO_RECURSION;
+        break;
+      case 'M':                 /* MD5 */
+        fo->flags |= FO_MD5;
+        break;
+      case 'n':
+        fo->flags |= FO_NOREPLACE;
+        break;
+      case 'p':                 /* use portable data format */
+        fo->flags |= FO_PORTABLE;
+        break;
+      case 'r':                 /* read fifo */
+        fo->flags |= FO_READFIFO;
+        break;
+      case 'S':
+        fo->flags |= FO_SHA1;
+        break;
+      case 's':
+        fo->flags |= FO_SPARSE;
+        break;
+      case 'm':
+        fo->flags |= FO_MTIMEONLY;
+        break;
+      case 'k':
+        fo->flags |= FO_KEEPATIME;
+        break;
+      case 'V':                  /* verify options */
+        /* Copy Verify Options */
+         for (j=0; *p && *p != ':'; p++) {
+           fo->VerifyOpts[j] = *p;
+           if (j < (int)sizeof(fo->VerifyOpts) - 1) {
+              j++;
+           }
+        }
+        fo->VerifyOpts[j] = 0;
+        break;
+      case 'w':
+        fo->flags |= FO_IF_NEWER;
+        break;
+      case 'Z':                 /* gzip compression */
+        fo->flags |= FO_GZIP;
+         fo->GZIP_level = *++p - '0';
+         Dmsg1(200, "Compression level=%d\n", fo->GZIP_level);
+        break;
+      default:
+         Emsg1(M_ERROR, 0, "Unknown include/exclude option: %c\n", *p);
+        break;
+      }
+   }
+} 
+
+
+/*
+ * Director is passing his Fileset   
+ */
+static int fileset_cmd(JCR *jcr)
+{
+   BSOCK *dir = jcr->dir_bsock;
+
+   if (!init_fileset(jcr)) {
+      return 0;
+   }
+   while (bnet_recv(dir) >= 0) {
+      strip_trailing_junk(dir->msg);
+      Dmsg1(400, "Fileset: %s\n", dir->msg);
+      add_fileset(jcr, dir->msg);
+   }
+   if (!term_fileset(jcr)) {
+      return 0;
+   }
+   return bnet_fsend(dir, OKinc);
+}
+
+
 /*
  * Get list of files to exclude from Director
  *
@@ -368,12 +952,13 @@ static int bootstrap_cmd(JCR *jcr)
       unlink(jcr->RestoreBootstrap);
       free_pool_memory(jcr->RestoreBootstrap);
    }
-   Mmsg(&fname, "%s/%s.%s.bootstrap", me->working_directory, me->hdr.name,
+   Mmsg(fname, "%s/%s.%s.bootstrap", me->working_directory, me->hdr.name,
       jcr->Job);
    Dmsg1(400, "bootstrap=%s\n", fname);
    jcr->RestoreBootstrap = fname;
    bs = fopen(fname, "a+");           /* create file */
    if (!bs) {
+      berrno be;
       /* 
        * Suck up what he is sending to us so that he will then
        *   read our error message.
@@ -382,7 +967,7 @@ static int bootstrap_cmd(JCR *jcr)
        {  }
 
       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
-        jcr->RestoreBootstrap, strerror(errno));
+        jcr->RestoreBootstrap, be.strerror());
       free_pool_memory(jcr->RestoreBootstrap);
       jcr->RestoreBootstrap = NULL;
       set_jcr_job_status(jcr, JS_ErrorTerminated);
@@ -406,7 +991,7 @@ static int bootstrap_cmd(JCR *jcr)
 static int level_cmd(JCR *jcr)
 {
    BSOCK *dir = jcr->dir_bsock;
-   POOLMEM *level;
+   POOLMEM *level, *buf = NULL;
    struct tm tm;
    time_t mtime;
    int mtime_only;
@@ -414,28 +999,25 @@ static int level_cmd(JCR *jcr)
    level = get_memory(dir->msglen+1);
    Dmsg1(110, "level_cmd: %s", dir->msg);
    if (sscanf(dir->msg, "level = %s ", level) != 1) {
-      Jmsg1(jcr, M_FATAL, 0, _("Bad level command: %s\n"), dir->msg);
-      free_memory(level);
-      return 0;
+      goto bail_out;
    }
    /* Base backup requested? */
    if (strcmp(level, "base") == 0) {
-      jcr->save_level = L_BASE;
+      jcr->JobLevel = L_BASE;
    /* Full backup requested? */ 
    } else if (strcmp(level, "full") == 0) {
-      jcr->save_level = L_FULL;
+      jcr->JobLevel = L_FULL;
    /* 
     * Backup requested since <date> <time>
     *  This form is also used for incremental and differential
+    *  This code is deprecated.  See since_utime for new code.
     */
    } else if (strcmp(level, "since") == 0) {
-      jcr->save_level = L_SINCE;
+      jcr->JobLevel = L_SINCE;
       if (sscanf(dir->msg, "level = since %d-%d-%d %d:%d:%d mtime_only=%d", 
                 &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
                 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &mtime_only) != 7) {
-         Jmsg1(jcr, M_FATAL, 0, _("Bad scan of date/time: %s\n"), dir->msg);
-        free_memory(level);
-        return 0;
+        goto bail_out;
       }
       tm.tm_year -= 1900;
       tm.tm_mon  -= 1;
@@ -445,14 +1027,74 @@ static int level_cmd(JCR *jcr)
       Dmsg2(100, "Got since time: %s mtime_only=%d\n", ctime(&mtime), mtime_only);
       jcr->incremental = 1;          /* set incremental or decremental backup */
       jcr->mtime = mtime;            /* set since time */
-      jcr->mtime_only = mtime_only;   /* and what to compare */
+   /*
+    * We get his UTC since time, then sync the clocks and correct it
+    *  to agree with our clock.
+    */
+   } else if (strcmp(level, "since_utime") == 0) {
+      buf = get_memory(dir->msglen+1);
+      utime_t since_time, adj;
+      btime_t his_time, bt_start, rt=0, bt_adj=0;
+      jcr->JobLevel = L_SINCE;
+      if (sscanf(dir->msg, "level = since_utime %s mtime_only=%d", 
+                buf, &mtime_only) != 2) { 
+        goto bail_out;
+      }
+      since_time = str_to_uint64(buf); /* this is the since time */
+      char ed1[50], ed2[50];
+      /* 
+       * Sync clocks by polling him for the time. We take       
+       *   10 samples of his time throwing out the first two.
+       */
+      for (int i=0; i<10; i++) {
+        bt_start = get_current_btime();
+        bnet_sig(dir, BNET_BTIME);   /* poll for time */
+        if (bnet_recv(dir) <= 0) {   /* get response */
+           goto bail_out;
+        }
+         if (sscanf(dir->msg, "btime %s", buf) != 1) {
+           goto bail_out;
+        }
+        if (i < 2) {                 /* toss first two results */
+           continue;
+        }
+        his_time = str_to_uint64(buf);
+        rt = get_current_btime() - bt_start; /* compute round trip time */
+        bt_adj -= his_time - bt_start - rt/2;
+         Dmsg2(200, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
+      }
+
+      bt_adj = bt_adj / 8;           /* compute average time */
+      Dmsg2(100, "rt=%s adj=%s\n", edit_uint64(rt, ed1), edit_uint64(bt_adj, ed2));
+      adj = btime_to_utime(bt_adj);
+      since_time += adj;             /* adjust for clock difference */
+      if (adj != 0) {
+         Jmsg(jcr, M_INFO, 0, _("Since time adjusted by %d seconds.\n"), adj);
+      }
+      bnet_sig(dir, BNET_EOD);
+
+      Dmsg2(100, "adj = %d since_time=%d\n", (int)adj, (int)since_time);
+      jcr->incremental = 1;          /* set incremental or decremental backup */
+      jcr->mtime = (time_t)since_time; /* set since time */
    } else {
       Jmsg1(jcr, M_FATAL, 0, "Unknown backup level: %s\n", level);
       free_memory(level);
       return 0;
    }
    free_memory(level);
+   if (buf) {
+      free_memory(buf);
+   }
    return bnet_fsend(dir, OKlevel);
+
+bail_out:
+   pm_strcpy(&jcr->errmsg, dir->msg);
+   Jmsg1(jcr, M_FATAL, 0, _("Bad level command: %s\n"), jcr->errmsg);
+   free_memory(level);
+   if (buf) {
+      free_memory(buf);
+   }
+   return 0;
 }
 
 /*
@@ -467,7 +1109,8 @@ static int session_cmd(JCR *jcr)
              &jcr->VolSessionId, &jcr->VolSessionTime,
              &jcr->StartFile, &jcr->EndFile, 
              &jcr->StartBlock, &jcr->EndBlock) != 7) {
-      Jmsg(jcr, M_FATAL, 0, "Bad session command: %s", dir->msg);
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg(jcr, M_FATAL, 0, "Bad session command: %s", jcr->errmsg);
       return 0;
    }
 
@@ -487,19 +1130,23 @@ static int storage_cmd(JCR *jcr)
 
    Dmsg1(100, "StorageCmd: %s", dir->msg);
    if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port, &enable_ssl) != 3) {
-      Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), dir->msg);
+      pm_strcpy(&jcr->errmsg, dir->msg);
+      Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), jcr->errmsg);
       return 0;
    }
    Dmsg3(110, "Open storage: %s:%d ssl=%d\n", jcr->stored_addr, stored_port, enable_ssl);
    /* Open command communications with Storage daemon */
    /* Try to connect for 1 hour at 10 second intervals */
-   sd = bnet_connect(jcr, 10, 3600, _("Storage daemon"), 
+   sd = bnet_connect(jcr, 10, (int)me->SDConnectTimeout, _("Storage daemon"), 
                     jcr->stored_addr, NULL, stored_port, 1);
    if (sd == NULL) {
       Jmsg(jcr, M_FATAL, 0, _("Failed to connect to Storage daemon: %s:%d\n"),
          jcr->stored_addr, stored_port);
+      Dmsg2(100, "Failed to connect to Storage daemon: %s:%d\n",
+         jcr->stored_addr, stored_port);
       return 0;
    }
+   Dmsg0(110, "Connection OK to SD.\n");
 
    jcr->store_bsock = sd;
 
@@ -579,6 +1226,7 @@ static int backup_cmd(JCR *jcr)
    if (!blast_data_to_storage_daemon(jcr, NULL)) {
       set_jcr_job_status(jcr, JS_ErrorTerminated);
       bnet_suppress_error_messages(sd, 1);
+      Dmsg0(110, "Error in blast_data.\n");
    } else {
       set_jcr_job_status(jcr, JS_Terminated);
       if (jcr->JobStatus != JS_Terminated) {
@@ -624,10 +1272,10 @@ static int backup_cmd(JCR *jcr)
    }
 
 cleanup:
-
    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles, 
       edit_uint64(jcr->ReadBytes, ed1), 
       edit_uint64(jcr->JobBytes, ed2), jcr->Errors);   
+   Dmsg1(110, "End FD msg: %s\n", dir->msg);
 
    return 0;                         /* return and stop command loop */
 }
@@ -655,6 +1303,8 @@ static int verify_cmd(JCR *jcr)
       jcr->JobLevel = L_VERIFY_VOLUME_TO_CATALOG;
    } else if (strcasecmp(level, "data") == 0){
       jcr->JobLevel = L_VERIFY_DATA;
+   } else if (strcasecmp(level, "disk_to_catalog") == 0) {
+      jcr->JobLevel = L_VERIFY_DISK_TO_CATALOG;
    } else {   
       bnet_fsend(dir, "2994 Bad verify level: %s\n", dir->msg);
       return 0;   
@@ -687,6 +1337,9 @@ static int verify_cmd(JCR *jcr)
       /* Inform Storage daemon that we are done */
       bnet_sig(sd, BNET_TERMINATE);
 
+      break;
+   case L_VERIFY_DISK_TO_CATALOG:
+      do_verify(jcr);
       break;
    default:
       bnet_fsend(dir, "2994 Bad verify level: %s\n", dir->msg);
@@ -714,6 +1367,7 @@ static int restore_cmd(JCR *jcr)
    BSOCK *dir = jcr->dir_bsock;
    BSOCK *sd = jcr->store_bsock;
    POOLMEM *where;
+   int prefix_links;
    char replace;
    char ed1[50], ed2[50];
 
@@ -725,9 +1379,10 @@ static int restore_cmd(JCR *jcr)
    where = get_memory(dir->msglen+1);
    *where = 0;
 
-   if (sscanf(dir->msg, restorecmd, &replace, where) != 2) {
-      if (sscanf(dir->msg, restorecmd1, &replace) != 1) {
-         Jmsg(jcr, M_FATAL, 0, _("Bad replace command. CMD=%s\n"), dir->msg);
+   if (sscanf(dir->msg, restorecmd, &replace, &prefix_links, where) != 3) {
+      if (sscanf(dir->msg, restorecmd1, &replace, &prefix_links) != 2) {
+        pm_strcpy(&jcr->errmsg, dir->msg);
+         Jmsg(jcr, M_FATAL, 0, _("Bad replace command. CMD=%s\n"), jcr->errmsg);
         return 0;
       }
       *where = 0;
@@ -739,8 +1394,10 @@ static int restore_cmd(JCR *jcr)
       
    Dmsg2(150, "Got replace %c, where=%s\n", replace, where);
    unbash_spaces(where);
-   jcr->where = where;
+   jcr->where = bstrdup(where);
+   free_pool_memory(where);
    jcr->replace = replace;
+   jcr->prefix_links = prefix_links;
 
    bnet_fsend(dir, OKrestore);
    Dmsg1(110, "bfiled>dird: %s", dir->msg);
@@ -780,6 +1437,9 @@ static int restore_cmd(JCR *jcr)
 
 bail_out:
 
+   if (jcr->Errors) {
+      set_jcr_job_status(jcr, JS_ErrorTerminated);
+   }
    /* Send termination status back to Dir */
    bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles, 
       edit_uint64(jcr->ReadBytes, ed1), 
@@ -854,16 +1514,19 @@ static void filed_free_jcr(JCR *jcr)
    if (jcr->store_bsock) {
       bnet_close(jcr->store_bsock);
    }
-   if (jcr->where) {
-      free_pool_memory(jcr->where);
-   }
    if (jcr->RestoreBootstrap) {
       unlink(jcr->RestoreBootstrap);
       free_pool_memory(jcr->RestoreBootstrap);
+      jcr->RestoreBootstrap = NULL;
    }
    if (jcr->last_fname) {
       free_pool_memory(jcr->last_fname);
    }
+   if (jcr->RunAfterJob) {
+      free_pool_memory(jcr->RunAfterJob);
+   }
+
+      
    return;
 }
 
@@ -874,19 +1537,20 @@ static void filed_free_jcr(JCR *jcr)
  *  Returns: 0 on failure
  *          1 on success
  */
-int response(JCR *jcr, BSOCK *sd, char *resp, char *cmd)
+int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd)
 {
-   int n;
-
    if (sd->errors) {
       return 0;
    }
-   if ((n = bget_msg(sd)) > 0) {
+   if (bget_msg(sd) > 0) {
       Dmsg0(110, sd->msg);
       if (strcmp(sd->msg, resp) == 0) {
         return 1;
       }
    } 
+   if (job_canceled(jcr)) {
+      return 0;                      /* if canceled avoid useless error messages */
+   }
    if (is_bnet_error(sd)) {
       Jmsg2(jcr, M_FATAL, 0, _("Comm error with SD. bad response to %s. ERR=%s\n"),
         cmd, bnet_strerror(sd));
@@ -902,7 +1566,8 @@ static int send_bootstrap_file(JCR *jcr)
    FILE *bs;
    char buf[2000];
    BSOCK *sd = jcr->store_bsock;
-   char *bootstrap = "bootstrap\n";
+   const char *bootstrap = "bootstrap\n";
+   int stat = 0;
 
    Dmsg1(400, "send_bootstrap_file: %s\n", jcr->RestoreBootstrap);
    if (!jcr->RestoreBootstrap) {
@@ -910,23 +1575,33 @@ static int send_bootstrap_file(JCR *jcr)
    }
    bs = fopen(jcr->RestoreBootstrap, "r");
    if (!bs) {
+      berrno be;
       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"), 
-        jcr->RestoreBootstrap, strerror(errno));
+        jcr->RestoreBootstrap, be.strerror());
       set_jcr_job_status(jcr, JS_ErrorTerminated);
-      return 0;
+      goto bail_out;
    }
-   strcpy(sd->msg, bootstrap); 
+   pm_strcpy(&sd->msg, bootstrap);  
    sd->msglen = strlen(sd->msg);
    bnet_send(sd);
    while (fgets(buf, sizeof(buf), bs)) {
-      sd->msglen = Mmsg(&sd->msg, "%s", buf);
+      sd->msglen = Mmsg(sd->msg, "%s", buf);
       bnet_send(sd);      
    }
    bnet_sig(sd, BNET_EOD);
    fclose(bs);
    if (!response(jcr, sd, OKSDbootstrap, "Bootstrap")) {
       set_jcr_job_status(jcr, JS_ErrorTerminated);
-      return 0;
+      goto bail_out;
    }
-   return 1;
+   stat = 1;
+
+bail_out:
+   if (jcr->RestoreBootstrap) {
+      unlink(jcr->RestoreBootstrap);
+      free_pool_memory(jcr->RestoreBootstrap);
+      jcr->RestoreBootstrap = NULL;
+   }
+
+   return stat;
 }