X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Ffiled%2Fjob.c;h=e41d7f270b73ce730874edf309d56cd11807c99c;hb=19ca7b5d5dc95153dca7691a67196bf3537209ef;hp=5b88dd67729646844273160c199592b49f5eccbf;hpb=d6f2e3af608879ac6b305246f896a6c25853069f;p=bacula%2Fbacula diff --git a/bacula/src/filed/job.c b/bacula/src/filed/job.c index 5b88dd6772..e41d7f270b 100644 --- a/bacula/src/filed/job.c +++ b/bacula/src/filed/job.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2009 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of Kern Sibbald. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * Bacula File Daemon Job processing * @@ -6,36 +33,39 @@ * Version $Id$ * */ -/* - Copyright (C) 2000-2006 Kern Sibbald - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as amended with additional clauses defined in the - file LICENSE in the main source directory. +#include "bacula.h" +#include "filed.h" + +#if defined(WIN32_VSS) +#include "vss.h" - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. +static pthread_mutex_t vss_mutex = PTHREAD_MUTEX_INITIALIZER; +static int enable_vss = 0; +#endif +/* + * As Windows saves ACLs as part of the standard backup stream + * we just pretend here that is has implicit acl support. */ +#if defined(HAVE_ACL) || defined(HAVE_WIN32) +const bool have_acl = true; +#else +const bool have_acl = false; +#endif -#include "bacula.h" -#include "filed.h" -#ifdef WIN32_VSS -#include "vss.h" -static pthread_mutex_t vss_mutex = PTHREAD_MUTEX_INITIALIZER; +#if defined(HAVE_XATTR) +const bool have_xattr = true; +#else +const bool have_xattr = false; #endif -extern char my_name[]; extern CLIENT *me; /* our client resource */ -int enable_vss = 0; /* set to use vss */ - /* Imported functions */ extern int status_cmd(JCR *jcr); extern int qstatus_cmd(JCR *jcr); +extern int accurate_cmd(JCR *jcr); /* Forward referenced functions */ static int backup_cmd(JCR *jcr); @@ -49,6 +79,7 @@ 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 end_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, const char *cmd); @@ -60,7 +91,7 @@ static int runbefore_cmd(JCR *jcr); static int runafter_cmd(JCR *jcr); static int runbeforenow_cmd(JCR *jcr); static void set_options(findFOPTS *fo, const char *opts); - +static void set_storage_auth_key(JCR *jcr, char *key); /* Exported functions */ @@ -83,6 +114,7 @@ static struct s_cmds cmds[] = { {"JobId=", job_cmd, 0}, {"level = ", level_cmd, 0}, {"restore", restore_cmd, 0}, + {"endrestore", end_restore_cmd, 0}, {"session", session_cmd, 0}, {"status", status_cmd, 1}, {".status", qstatus_cmd, 1}, @@ -93,24 +125,28 @@ static struct s_cmds cmds[] = { {"RunBeforeJob", runbefore_cmd, 0}, {"RunAfterJob", runafter_cmd, 0}, {"Run", runscript_cmd, 0}, + {"accurate", accurate_cmd, 0}, {NULL, NULL} /* list terminator */ }; /* Commands received from director that need scanning */ 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 storaddr[] = "storage address=%s port=%d ssl=%d Authorization=%100s"; +static char storaddr_v1[] = "storage address=%s port=%d ssl=%d"; static char sessioncmd[] = "session %127s %ld %ld %ld %ld %ld %ld\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"; -static char runscript[] = "Run OnSuccess=%u OnFailure=%u AbortOnError=%u When=%u Command=%s\n"; +static char restorecmdR[] = "restore replace=%c prelinks=%d regexwhere=%s\n"; +static char verifycmd[] = "verify level=%30s"; +static char estimatecmd[] = "estimate listing=%d"; +static char runbefore[] = "RunBeforeJob %s"; +static char runafter[] = "RunAfterJob %s"; +static char runscript[] = "Run OnSuccess=%d OnFailure=%d AbortOnError=%d When=%d Command=%s"; + /* Responses sent to Director */ static char errmsg[] = "2999 Invalid command\n"; static char no_auth[] = "2998 No Authorization\n"; -static char illegal_cmd[] = "2997 Illegal command for a Director with Monitor directive enabled\n"; +static char invalid_cmd[] = "2997 Invalid command for a Director with Monitor directive enabled.\n"; static char OKinc[] = "2000 OK include\n"; static char OKest[] = "2000 OK estimate files=%u bytes=%s\n"; static char OKlevel[] = "2000 OK level\n"; @@ -120,14 +156,17 @@ 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 %s,%s,%s"; +static char OKstoreend[] = "2000 OK storage end\n"; +static char OKjob[] = "2000 OK Job %s (%s) %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 EndJob[] = "2800 End Job TermCode=%d JobFiles=%u ReadBytes=%s" + " JobBytes=%s Errors=%u VSS=%d Encrypt=%d\n"; static char OKRunBefore[] = "2000 OK RunBefore\n"; static char OKRunBeforeNow[] = "2000 OK RunBeforeNow\n"; static char OKRunAfter[] = "2000 OK RunAfter\n"; static char OKRunScript[] = "2000 OK RunScript\n"; +static char BADcmd[] = "2902 Bad %s\n"; /* Responses received from Storage Daemon */ @@ -164,13 +203,30 @@ static char read_close[] = "read close session %d\n"; * Accept commands one at a time from the Director * and execute them. * + * Concerning ClientRunBefore/After, the sequence of events + * is rather critical. If they are not done in the right + * order one can easily get FD->SD timeouts if the script + * runs a long time. + * + * The current sequence of events is: + * 1. Dir starts job with FD + * 2. Dir connects to SD + * 3. Dir connects to FD + * 4. FD connects to SD + * 5. FD gets/runs ClientRunBeforeJob and sends ClientRunAfterJob + * 6. Dir sends include/exclude + * 7. FD sends data to SD + * 8. SD/FD disconnects while SD despools data and attributes (optional) + * 9. FD runs ClientRunAfterJob */ + void *handle_client_request(void *dirp) { int i; bool found, quit; JCR *jcr; BSOCK *dir = (BSOCK *)dirp; + const char jobname[12] = "*Director*"; jcr = new_jcr(sizeof(JCR), filed_free_jcr); /* create JCR */ jcr->dir_bsock = dir; @@ -181,20 +237,20 @@ void *handle_client_request(void *dirp) jcr->last_fname[0] = 0; jcr->client_name = get_memory(strlen(my_name) + 1); pm_strcpy(jcr->client_name, my_name); - jcr->pki_sign = me->pki_sign; - jcr->pki_encrypt = me->pki_encrypt; - jcr->pki_keypair = me->pki_keypair; - jcr->pki_signers = me->pki_signers; - jcr->pki_recipients = me->pki_recipients; - dir->jcr = jcr; + bstrncpy(jcr->Job, jobname, sizeof(jobname)); /* dummy */ + jcr->crypto.pki_sign = me->pki_sign; + jcr->crypto.pki_encrypt = me->pki_encrypt; + jcr->crypto.pki_keypair = me->pki_keypair; + jcr->crypto.pki_signers = me->pki_signers; + jcr->crypto.pki_recipients = me->pki_recipients; + dir->set_jcr(jcr); enable_backup_privileges(NULL, 1 /* ignore_errors */); /**********FIXME******* add command handler error code */ for (quit=false; !quit;) { - /* Read command */ - if (bnet_recv(dir) < 0) { + if (dir->recv() < 0) { break; /* connection terminated */ } dir->msg[dir->msglen] = 0; @@ -204,26 +260,26 @@ void *handle_client_request(void *dirp) if (strncmp(cmds[i].cmd, dir->msg, strlen(cmds[i].cmd)) == 0) { found = true; /* indicate command found */ if (!jcr->authenticated && cmds[i].func != hello_cmd) { - bnet_fsend(dir, no_auth); - bnet_sig(dir, BNET_EOD); + dir->fsend(no_auth); + dir->signal(BNET_EOD); break; } if ((jcr->authenticated) && (!cmds[i].monitoraccess) && (jcr->director->monitor)) { - Dmsg1(100, "Command %s illegal.\n", cmds[i].cmd); - bnet_fsend(dir, illegal_cmd); - bnet_sig(dir, BNET_EOD); + Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd); + dir->fsend(invalid_cmd); + dir->signal(BNET_EOD); break; } Dmsg1(100, "Executing %s command.\n", cmds[i].cmd); if (!cmds[i].func(jcr)) { /* do command */ quit = true; /* error or fully terminated, get out */ - Dmsg1(20, "Quit command loop. Canceled=%d\n", job_canceled(jcr)); + Dmsg1(100, "Quit command loop. Canceled=%d\n", job_canceled(jcr)); } break; } } if (!found) { /* command not found */ - bnet_fsend(dir, errmsg); + dir->fsend(errmsg); quit = true; break; } @@ -231,18 +287,31 @@ void *handle_client_request(void *dirp) /* Inform Storage daemon that we are done */ if (jcr->store_bsock) { - bnet_sig(jcr->store_bsock, BNET_TERMINATE); + jcr->store_bsock->signal(BNET_TERMINATE); } - /* run after job */ + /* Run the after job */ run_scripts(jcr, jcr->RunScripts, "ClientAfterJob"); + if (jcr->JobId) { /* send EndJob if running a job */ + char ed1[50], ed2[50]; + /* Send termination status back to Dir */ + dir->fsend(EndJob, jcr->JobStatus, jcr->JobFiles, + edit_uint64(jcr->ReadBytes, ed1), + edit_uint64(jcr->JobBytes, ed2), jcr->JobErrors, jcr->VSS, + jcr->crypto.pki_encrypt); + Dmsg1(110, "End FD msg: %s\n", dir->msg); + } + generate_daemon_event(jcr, "JobEnd"); + generate_plugin_event(jcr, bEventJobEnd); dequeue_messages(jcr); /* send any queued messages */ /* Inform Director that we are done */ - bnet_sig(dir, BNET_TERMINATE); + dir->signal(BNET_TERMINATE); + + free_plugins(jcr); /* release instantiated plugins */ /* Clean up fileset */ FF_PKT *ff = jcr->ff; @@ -257,23 +326,29 @@ void *handle_client_request(void *dirp) for (k=0; kregex.size(); k++) { regfree((regex_t *)fo->regex.get(k)); } + for (k=0; kregexdir.size(); k++) { + regfree((regex_t *)fo->regexdir.get(k)); + } + for (k=0; kregexfile.size(); k++) { + regfree((regex_t *)fo->regexfile.get(k)); + } fo->regex.destroy(); fo->regexdir.destroy(); fo->regexfile.destroy(); fo->wild.destroy(); fo->wilddir.destroy(); fo->wildfile.destroy(); + fo->wildbase.destroy(); fo->base.destroy(); fo->fstype.destroy(); - if (fo->reader) { - free(fo->reader); - } - if (fo->writer) { - free(fo->writer); + fo->drivetype.destroy(); + if (fo->ignoredir != NULL) { + free(fo->ignoredir); } } incexe->opts_list.destroy(); incexe->name_list.destroy(); + incexe->plugin_list.destroy(); } fileset->include_list.destroy(); @@ -288,11 +363,14 @@ void *handle_client_request(void *dirp) fo->wild.destroy(); fo->wilddir.destroy(); fo->wildfile.destroy(); + fo->wildbase.destroy(); fo->base.destroy(); fo->fstype.destroy(); + fo->drivetype.destroy(); } incexe->opts_list.destroy(); incexe->name_list.destroy(); + incexe->plugin_list.destroy(); } fileset->exclude_list.destroy(); free(fileset); @@ -304,6 +382,7 @@ void *handle_client_request(void *dirp) Dmsg0(100, "Done with term_find_files\n"); free_jcr(jcr); /* destroy JCR record */ Dmsg0(100, "Done with free_jcr\n"); + Dsm_check(1); return NULL; } @@ -333,21 +412,22 @@ static int cancel_cmd(JCR *jcr) if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) { if (!(cjcr=get_jcr_by_full_name(Job))) { - bnet_fsend(dir, _("2901 Job %s not found.\n"), Job); + dir->fsend(_("2901 Job %s not found.\n"), Job); } else { if (cjcr->store_bsock) { - cjcr->store_bsock->timed_out = 1; - cjcr->store_bsock->terminated = 1; + cjcr->store_bsock->set_timed_out(); + cjcr->store_bsock->set_terminated(); pthread_kill(cjcr->my_thread_id, TIMEOUT_SIGNAL); } + generate_plugin_event(cjcr, bEventCancelCommand, NULL); set_jcr_job_status(cjcr, JS_Canceled); free_jcr(cjcr); - bnet_fsend(dir, _("2001 Job %s marked to be canceled.\n"), Job); + dir->fsend(_("2001 Job %s marked to be canceled.\n"), Job); } } else { - bnet_fsend(dir, _("2902 Error scanning cancel command.\n")); + dir->fsend(_("2902 Error scanning cancel command.\n")); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return 1; } @@ -364,12 +444,12 @@ static int setdebug_cmd(JCR *jcr) Dmsg1(110, "setdebug_cmd: %s", 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); + dir->fsend(_("2991 Bad setdebug command: %s\n"), jcr->errmsg); return 0; } debug_level = level; set_trace(trace_flag); - return bnet_fsend(dir, OKsetdebug, level); + return dir->fsend(OKsetdebug, level); } @@ -381,13 +461,13 @@ static int estimate_cmd(JCR *jcr) 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")); + dir->fsend(_("2992 Bad estimate command.\n")); return 0; } make_estimate(jcr); - bnet_fsend(dir, OKest, jcr->num_files_examined, + dir->fsend(OKest, jcr->num_files_examined, edit_uint64_with_commas(jcr->JobBytes, ed2)); - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return 1; } @@ -397,22 +477,23 @@ static int estimate_cmd(JCR *jcr) static int job_cmd(JCR *jcr) { BSOCK *dir = jcr->dir_bsock; - POOLMEM *sd_auth_key; + POOL_MEM sd_auth_key(PM_MESSAGE); + sd_auth_key.check_size(dir->msglen); - sd_auth_key = get_memory(dir->msglen); if (sscanf(dir->msg, jobcmd, &jcr->JobId, jcr->Job, - &jcr->VolSessionId, &jcr->VolSessionTime, - sd_auth_key) != 5) { + &jcr->VolSessionId, &jcr->VolSessionTime, + sd_auth_key.c_str()) != 5) { pm_strcpy(jcr->errmsg, dir->msg); Jmsg(jcr, M_FATAL, 0, _("Bad Job Command: %s"), jcr->errmsg); - bnet_fsend(dir, BADjob); - free_pool_memory(sd_auth_key); + dir->fsend(BADjob); return 0; } - jcr->sd_auth_key = bstrdup(sd_auth_key); - free_pool_memory(sd_auth_key); + set_storage_auth_key(jcr, sd_auth_key.c_str()); Dmsg2(120, "JobId=%d Auth=%s\n", jcr->JobId, jcr->sd_auth_key); - return bnet_fsend(dir, OKjob, HOST_OS, DISTNAME, DISTVER); + Mmsg(jcr->errmsg, "JobId=%d Job=%s", jcr->JobId, jcr->Job); + new_plugins(jcr); /* instantiate plugins for this jcr */ + generate_plugin_event(jcr, bEventJobStart, (void *)jcr->errmsg); + return dir->fsend(OKjob, VERSION, LSMDATE, HOST_OS, DISTNAME, DISTVER); } static int runbefore_cmd(JCR *jcr) @@ -426,7 +507,7 @@ static int runbefore_cmd(JCR *jcr) 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")); + dir->fsend(_("2905 Bad RunBeforeJob command.\n")); free_memory(cmd); return 0; } @@ -441,10 +522,10 @@ static int runbefore_cmd(JCR *jcr) free_memory(cmd); if (ok) { - bnet_fsend(dir, OKRunBefore); + dir->fsend(OKRunBefore); return 1; } else { - bnet_fsend(dir, _("2905 Bad RunBeforeJob command.\n")); + dir->fsend(_("2905 Bad RunBeforeJob command.\n")); return 0; } } @@ -454,7 +535,15 @@ static int runbeforenow_cmd(JCR *jcr) BSOCK *dir = jcr->dir_bsock; run_scripts(jcr, jcr->RunScripts, "ClientBeforeJob"); - return bnet_fsend(dir, OKRunBeforeNow); + if (job_canceled(jcr)) { + dir->fsend(_("2905 Bad RunBeforeNow command.\n")); + Dmsg0(100, "Back from run_scripts ClientBeforeJob now: FAILED\n"); + return 0; + } else { + dir->fsend(OKRunBeforeNow); + Dmsg0(100, "Back from run_scripts ClientBeforeJob now: OK\n"); + return 1; + } } static int runafter_cmd(JCR *jcr) @@ -467,7 +556,7 @@ static int runafter_cmd(JCR *jcr) 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")); + dir->fsend(_("2905 Bad RunAfterJob command.\n")); free_memory(msg); return 0; } @@ -482,29 +571,34 @@ static int runafter_cmd(JCR *jcr) jcr->RunScripts->append(cmd); free_pool_memory(msg); - return bnet_fsend(dir, OKRunAfter); + return dir->fsend(OKRunAfter); } static int runscript_cmd(JCR *jcr) { BSOCK *dir = jcr->dir_bsock; POOLMEM *msg = get_memory(dir->msglen+1); + int on_success, on_failure, fail_on_error; RUNSCRIPT *cmd = new_runscript() ; Dmsg1(100, "runscript_cmd: '%s'\n", dir->msg); - if (sscanf(dir->msg, runscript, &cmd->on_success, - &cmd->on_failure, - &cmd->abort_on_error, + /* Note, we cannot sscanf into bools */ + if (sscanf(dir->msg, runscript, &on_success, + &on_failure, + &fail_on_error, &cmd->when, msg) != 5) { pm_strcpy(jcr->errmsg, dir->msg); Jmsg1(jcr, M_FATAL, 0, _("Bad RunScript command: %s\n"), jcr->errmsg); - bnet_fsend(dir, _("2905 Bad RunScript command.\n")); + dir->fsend(_("2905 Bad RunScript command.\n")); free_runscript(cmd); free_memory(msg); return 0; } + cmd->on_success = on_success; + cmd->on_failure = on_failure; + cmd->fail_on_error = fail_on_error; unbash_spaces(msg); cmd->set_command(msg); @@ -512,7 +606,7 @@ static int runscript_cmd(JCR *jcr) jcr->RunScripts->append(cmd); free_pool_memory(msg); - return bnet_fsend(dir, OKRunScript); + return dir->fsend(OKRunScript); } @@ -552,8 +646,10 @@ static findFOPTS *start_options(FF_PKT *ff) fo->wild.init(1, true); fo->wilddir.init(1, true); fo->wildfile.init(1, true); + fo->wildbase.init(1, true); fo->base.init(1, true); fo->fstype.init(1, true); + fo->drivetype.init(1, true); incexe->current_opts = fo; incexe->opts_list.append(fo); } @@ -565,7 +661,8 @@ static findFOPTS *start_options(FF_PKT *ff) * 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) +static void add_file_to_fileset(JCR *jcr, const char *fname, findFILESET *fileset, + bool is_file) { char *p; BPIPE *bpipe; @@ -583,40 +680,60 @@ static void add_file_to_fileset(JCR *jcr, const char *fname, findFILESET *filese 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) { + berrno be; Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"), - p, strerror(errno)); + p, be.bstrerror()); + free_pool_memory(fn); return; } + free_pool_memory(fn); while (fgets(buf, sizeof(buf), bpipe->rfd)) { strip_trailing_junk(buf); - fileset->incexe->name_list.append(bstrdup(buf)); + if (is_file) { + fileset->incexe->name_list.append(new_dlistString(buf)); + } else { + fileset->incexe->plugin_list.append(new_dlistString(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)); + berrno be; + Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. stat=%d: ERR=%s\n"), + p, be.code(stat), be.bstrerror(stat)); return; } break; case '<': - Dmsg0(100, "Doing < include on client.\n"); + Dmsg1(100, "Doing < of '%s' include on client.\n", p + 1); p++; /* skip over < */ if ((ffd = fopen(p, "rb")) == NULL) { berrno be; Jmsg(jcr, M_FATAL, 0, _("Cannot open FileSet input file: %s. ERR=%s\n"), - p, be.strerror()); + p, be.bstrerror()); return; } while (fgets(buf, sizeof(buf), ffd)) { strip_trailing_junk(buf); Dmsg1(100, "%s\n", buf); - fileset->incexe->name_list.append(bstrdup(buf)); + if (is_file) { + fileset->incexe->name_list.append(new_dlistString(buf)); + } else { + fileset->incexe->plugin_list.append(new_dlistString(buf)); + } } fclose(ffd); break; default: - fileset->incexe->name_list.append(bstrdup(fname)); + if (is_file) { + fileset->incexe->name_list.append(new_dlistString(fname)); + } else { + if (me->plugin_directory) { + fileset->incexe->plugin_list.append(new_dlistString(fname)); + } else { + Jmsg(jcr, M_FATAL, 0, _("Plugin Directory not defined. Cannot use plugin: \"%\"\n"), + fname); + } + } break; } } @@ -646,6 +763,7 @@ static void add_fileset(JCR *jcr, const char *item) /* Skip all lines we receive after an error */ if (state == state_error) { + Dmsg0(100, "State=error return\n"); return; } @@ -657,6 +775,7 @@ static void add_fileset(JCR *jcr, const char *item) */ if (subcode != ' ') { state = state_error; + Dmsg0(100, "Set state=error or double code.\n"); } switch (code) { case 'I': @@ -664,7 +783,8 @@ static void add_fileset(JCR *jcr, const char *item) 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->incexe->name_list.init(); /* for dlist; was 1,true for alist */ + fileset->incexe->plugin_list.init(); fileset->include_list.append(fileset->incexe); break; case 'E': @@ -672,16 +792,22 @@ static void add_fileset(JCR *jcr, const char *item) 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->incexe->name_list.init(); + fileset->incexe->plugin_list.init(); fileset->exclude_list.append(fileset->incexe); break; case 'N': state = state_none; break; case 'F': - /* File item to either include/include list */ + /* File item to include or exclude list */ state = state_include; - add_file_to_fileset(jcr, item, fileset); + add_file_to_fileset(jcr, item, fileset, true); + break; + case 'P': + /* Plugin item to include list */ + state = state_include; + add_file_to_fileset(jcr, item, fileset, false); break; case 'R': current_opts = start_options(ff); @@ -720,8 +846,14 @@ static void add_fileset(JCR *jcr, const char *item) break; case 'X': current_opts = start_options(ff); - current_opts->fstype.append(bstrdup(item)); state = state_options; + if (subcode == ' ') { + current_opts->fstype.append(bstrdup(item)); + } else if (subcode == 'D') { + current_opts->drivetype.append(bstrdup(item)); + } else { + state = state_error; + } break; case 'W': current_opts = start_options(ff); @@ -732,6 +864,8 @@ static void add_fileset(JCR *jcr, const char *item) current_opts->wilddir.append(bstrdup(item)); } else if (subcode == 'F') { current_opts->wildfile.append(bstrdup(item)); + } else if (subcode == 'B') { + current_opts->wildbase.append(bstrdup(item)); } else { state = state_error; } @@ -741,14 +875,19 @@ static void add_fileset(JCR *jcr, const char *item) set_options(current_opts, item); state = state_options; break; + case 'Z': + current_opts = start_options(ff); + current_opts->ignoredir = bstrdup(item); + state = state_options; + break; case 'D': current_opts = start_options(ff); - current_opts->reader = bstrdup(item); +// current_opts->reader = bstrdup(item); state = state_options; break; case 'T': current_opts = start_options(ff); - current_opts->writer = bstrdup(item); +// current_opts->writer = bstrdup(item); state = state_options; break; default: @@ -763,7 +902,7 @@ static bool term_fileset(JCR *jcr) { FF_PKT *ff = jcr->ff; -#ifdef xxx +#ifdef xxx_DEBUG_CODE findFILESET *fileset = ff->fileset; int i, j, k; @@ -790,21 +929,28 @@ static bool term_fileset(JCR *jcr) for (k=0; kwildfile.size(); k++) { Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k)); } + for (k=0; kwildbase.size(); k++) { + Dmsg1(400, "WB %s\n", (char *)fo->wildbase.get(k)); + } for (k=0; kbase.size(); k++) { Dmsg1(400, "B %s\n", (char *)fo->base.get(k)); } for (k=0; kfstype.size(); k++) { Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k)); } - if (fo->reader) { - Dmsg1(400, "D %s\n", fo->reader); + for (k=0; kdrivetype.size(); k++) { + Dmsg1(400, "XD %s\n", (char *)fo->drivetype.get(k)); } - if (fo->writer) { - Dmsg1(400, "T %s\n", fo->writer); + if (fo->ignoredir) { + Dmsg1(400, "Z %s\n", fo->ignoredir); } } - for (j=0; jname_list.size(); j++) { - Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j)); + dlistString *node; + foreach_dlist(node, &incexe->name_list) { + Dmsg1(400, "F %s\n", node->c_str()); + } + foreach_dlist(node, &incexe->plugin_list) { + Dmsg1(400, "P %s\n", node->c_str()); } } for (i=0; iexclude_list.size(); i++) { @@ -830,15 +976,25 @@ static bool term_fileset(JCR *jcr) for (k=0; kwildfile.size(); k++) { Dmsg1(400, "WF %s\n", (char *)fo->wildfile.get(k)); } + for (k=0; kwildbase.size(); k++) { + Dmsg1(400, "WB %s\n", (char *)fo->wildbase.get(k)); + } for (k=0; kbase.size(); k++) { Dmsg1(400, "B %s\n", (char *)fo->base.get(k)); } for (k=0; kfstype.size(); k++) { Dmsg1(400, "X %s\n", (char *)fo->fstype.get(k)); } + for (k=0; kdrivetype.size(); k++) { + Dmsg1(400, "XD %s\n", (char *)fo->drivetype.get(k)); + } + } + dlistString *node; + foreach_dlist(node, incexe->name_list) { + Dmsg1(400, "F %s\n", node->c_str()); } - for (j=0; jname_list.size(); j++) { - Dmsg1(400, "F %s\n", (char *)incexe->name_list.get(j)); + foreach_dlist(node, &incexe->plugin_list) { + Dmsg1(400, "P %s\n", node->c_str()); } } #endif @@ -855,6 +1011,12 @@ static void set_options(findFOPTS *fo, const char *opts) { int j; const char *p; + char strip[100]; + +// Commented out as it is not backward compatible - KES +#ifdef HAVE_WIN32 +// fo->flags |= FO_IGNORECASE; /* always ignorecase under windows */ +#endif for (p=opts; *p; p++) { switch (*p) { @@ -892,10 +1054,6 @@ static void set_options(findFOPTS *fo, const char *opts) break; case 'S': switch(*(p + 1)) { - case ' ': - /* Old director did not specify SHA variant */ - fo->flags |= FO_SHA1; - break; case '1': fo->flags |= FO_SHA1; p++; @@ -911,10 +1069,14 @@ static void set_options(findFOPTS *fo, const char *opts) break; #endif default: - /* Automatically downgrade to SHA-1 if an unsupported - * SHA variant is specified */ + /* + * If 2 or 3 is seen here, SHA2 is not configured, so + * eat the option, and drop back to SHA-1. + */ + if (p[1] == '2' || p[1] == '3') { + p++; + } fo->flags |= FO_SHA1; - p++; break; } break; @@ -940,17 +1102,52 @@ static void set_options(findFOPTS *fo, const char *opts) } fo->VerifyOpts[j] = 0; break; + case 'C': /* accurate options */ + /* Copy Accurate Options */ + for (j=0; *p && *p != ':'; p++) { + fo->AccurateOpts[j] = *p; + if (j < (int)sizeof(fo->AccurateOpts) - 1) { + j++; + } + } + fo->AccurateOpts[j] = 0; + break; + case 'P': /* strip path */ + /* Get integer */ + p++; /* skip P */ + for (j=0; *p && *p != ':'; p++) { + strip[j] = *p; + if (j < (int)sizeof(strip) - 1) { + j++; + } + } + strip[j] = 0; + fo->strip_path = atoi(strip); + fo->flags |= FO_STRIPPATH; + Dmsg2(100, "strip=%s strip_path=%d\n", strip, fo->strip_path); + break; case 'w': fo->flags |= FO_IF_NEWER; break; + case 'W': + fo->flags |= FO_ENHANCEDWILD; + break; case 'Z': /* gzip compression */ fo->flags |= FO_GZIP; fo->GZIP_level = *++p - '0'; - Dmsg1(200, "Compression level=%d\n", fo->GZIP_level); break; case 'K': fo->flags |= FO_NOATIME; break; + case 'c': + fo->flags |= FO_CHKCHANGES; + break; + case 'N': + fo->flags |= FO_HONOR_NODUMP; + break; + case 'X': + fo->flags |= FO_XATTR; + break; default: Emsg1(M_ERROR, 0, _("Unknown include/exclude option: %c\n"), *p); break; @@ -965,15 +1162,18 @@ static void set_options(findFOPTS *fo, const char *opts) static int fileset_cmd(JCR *jcr) { BSOCK *dir = jcr->dir_bsock; + +#if defined(WIN32_VSS) int vss = 0; sscanf(dir->msg, "fileset vss=%d", &vss); enable_vss = vss; +#endif if (!init_fileset(jcr)) { return 0; } - while (bnet_recv(dir) >= 0) { + while (dir->recv() >= 0) { strip_trailing_junk(dir->msg); Dmsg1(500, "Fileset: %s\n", dir->msg); add_fileset(jcr, dir->msg); @@ -981,7 +1181,7 @@ static int fileset_cmd(JCR *jcr) if (!term_fileset(jcr)) { return 0; } - return bnet_fsend(dir, OKinc); + return dir->fsend(OKinc); } static void free_bootstrap(JCR *jcr) @@ -994,6 +1194,9 @@ static void free_bootstrap(JCR *jcr) } +static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER; +static uint32_t bsr_uniq = 0; + /* * The Director sends us the bootstrap file, which * we will in turn pass to the SD. @@ -1005,28 +1208,31 @@ static int bootstrap_cmd(JCR *jcr) FILE *bs; free_bootstrap(jcr); - Mmsg(fname, "%s/%s.%s.bootstrap", me->working_directory, me->hdr.name, - jcr->Job); + P(bsr_mutex); + bsr_uniq++; + Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name, + jcr->Job, bsr_uniq); + V(bsr_mutex); Dmsg1(400, "bootstrap=%s\n", fname); jcr->RestoreBootstrap = fname; bs = fopen(fname, "a+b"); /* create file */ if (!bs) { berrno be; Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"), - jcr->RestoreBootstrap, be.strerror()); + jcr->RestoreBootstrap, be.bstrerror()); /* * Suck up what he is sending to us so that he will then * read our error message. */ - while (bnet_recv(dir) >= 0) + while (dir->recv() >= 0) { } free_bootstrap(jcr); set_jcr_job_status(jcr, JS_ErrorTerminated); return 0; } - while (bnet_recv(dir) >= 0) { - Dmsg1(200, "filedmsg); + while (dir->recv() >= 0) { + Dmsg1(200, "filedmsg); fputs(dir->msg, bs); } fclose(bs); @@ -1034,7 +1240,7 @@ static int bootstrap_cmd(JCR *jcr) * Note, do not free the bootstrap yet -- it needs to be * sent to the SD */ - return bnet_fsend(dir, OKbootstrap); + return dir->fsend(OKbootstrap); } @@ -1049,24 +1255,29 @@ static int level_cmd(JCR *jcr) int mtime_only; level = get_memory(dir->msglen+1); - Dmsg1(110, "level_cmd: %s", dir->msg); + Dmsg1(100, "level_cmd: %s", dir->msg); + + /* keep compatibility with older directors */ + if (strstr(dir->msg, "accurate")) { + jcr->accurate = true; + } if (sscanf(dir->msg, "level = %s ", level) != 1) { goto bail_out; } /* Base backup requested? */ if (strcmp(level, "base") == 0) { - jcr->JobLevel = L_BASE; + jcr->set_JobLevel(L_BASE); /* Full backup requested? */ } else if (strcmp(level, "full") == 0) { - jcr->JobLevel = L_FULL; - } else if (strcmp(level, "differential") == 0) { - jcr->JobLevel = L_DIFFERENTIAL; + jcr->set_JobLevel(L_FULL); + } else if (strstr(level, "differential")) { + jcr->set_JobLevel(L_DIFFERENTIAL); free_memory(level); return 1; - } else if (strcmp(level, "incremental") == 0) { - jcr->JobLevel = L_INCREMENTAL; + } else if (strstr(level, "incremental")) { + jcr->set_JobLevel(L_INCREMENTAL); free_memory(level); - return 1; + return 1; /* * We get his UTC since time, then sync the clocks and correct it * to agree with our clock. @@ -1075,15 +1286,15 @@ static int level_cmd(JCR *jcr) buf = get_memory(dir->msglen+1); utime_t since_time, adj; btime_t his_time, bt_start, rt=0, bt_adj=0; - if (jcr->JobLevel == L_NONE) { - jcr->JobLevel = L_SINCE; /* if no other job level set, do it now */ + if (jcr->get_JobLevel() == L_NONE) { + jcr->set_JobLevel(L_SINCE); /* if no other job level set, do it now */ } 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 */ - Dmsg1(100, "since_time=%d\n", (int)since_time); + Dmsg1(100, "since_time=%lld\n", since_time); char ed1[50], ed2[50]; /* * Sync clocks by polling him for the time. We take @@ -1091,8 +1302,8 @@ static int level_cmd(JCR *jcr) */ 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 */ + dir->signal(BNET_BTIME); /* poll for time */ + if (dir->recv() <= 0) { /* get response */ goto bail_out; } if (sscanf(dir->msg, "btime %s", buf) != 1) { @@ -1113,14 +1324,22 @@ static int level_cmd(JCR *jcr) 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, _("DIR and FD clocks differ by %d seconds, FD automatically adjusting.\n"), adj); + /* Don't notify if time within 3 seconds */ + if (adj > 3 || adj < -3) { + int type; + if (adj > 600 || adj < -600) { + type = M_WARNING; + } else { + type = M_INFO; + } + Jmsg(jcr, type, 0, _("DIR and FD clocks differ by %lld seconds, FD automatically compensating.\n"), adj); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); - Dmsg2(100, "adj = %d since_time=%d\n", (int)adj, (int)since_time); + Dmsg2(100, "adj=%lld since_time=%lld\n", adj, since_time); jcr->incremental = 1; /* set incremental or decremental backup */ - jcr->mtime = (time_t)since_time; /* set since time */ + jcr->mtime = since_time; /* set since time */ + generate_plugin_event(jcr, bEventSince, (void *)(time_t)jcr->mtime); } else { Jmsg1(jcr, M_FATAL, 0, _("Unknown backup level: %s\n"), level); free_memory(level); @@ -1130,7 +1349,8 @@ static int level_cmd(JCR *jcr) if (buf) { free_memory(buf); } - return bnet_fsend(dir, OKlevel); + generate_plugin_event(jcr, bEventLevel, (void *)jcr->get_JobLevel()); + return dir->fsend(OKlevel); bail_out: pm_strcpy(jcr->errmsg, dir->msg); @@ -1159,7 +1379,37 @@ static int session_cmd(JCR *jcr) return 0; } - return bnet_fsend(dir, OKsession); + return dir->fsend(OKsession); +} + +static void set_storage_auth_key(JCR *jcr, char *key) +{ + /* if no key don't update anything */ + if (!*key) { + return; + } + + /* We can be contacting multiple storage daemons. + * So, make sure that any old jcr->store_bsock is cleaned up. + */ + if (jcr->store_bsock) { + jcr->store_bsock->destroy(); + jcr->store_bsock = NULL; + } + + /* We can be contacting multiple storage daemons. + * So, make sure that any old jcr->sd_auth_key is cleaned up. + */ + if (jcr->sd_auth_key) { + /* If we already have a Authorization key, director can do multi + * storage restore + */ + Dmsg0(5, "set multi_restore=true\n"); + jcr->multi_restore = true; + bfree(jcr->sd_auth_key); + } + + jcr->sd_auth_key = bstrdup(key); } /* @@ -1170,45 +1420,69 @@ static int storage_cmd(JCR *jcr) { int stored_port; /* storage daemon port */ int enable_ssl; /* enable ssl to sd */ + POOL_MEM sd_auth_key(PM_MESSAGE); BSOCK *dir = jcr->dir_bsock; - BSOCK *sd; /* storage daemon bsock */ + BSOCK *sd = new_bsock(); /* storage daemon bsock */ + Dmsg1(100, "StorageCmd: %s", dir->msg); - if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port, &enable_ssl) != 3) { - pm_strcpy(jcr->errmsg, dir->msg); - Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), jcr->errmsg); - return 0; + sd_auth_key.check_size(dir->msglen); + if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port, + &enable_ssl, sd_auth_key.c_str()) != 4) + { + if (sscanf(dir->msg, storaddr_v1, &jcr->stored_addr, + &stored_port, &enable_ssl) != 3) + { + pm_strcpy(jcr->errmsg, dir->msg); + Jmsg(jcr, M_FATAL, 0, _("Bad storage command: %s"), jcr->errmsg); + goto bail_out; + } } - Dmsg3(110, "Open storage: %s:%d ssl=%d\n", jcr->stored_addr, stored_port, enable_ssl); + + set_storage_auth_key(jcr, sd_auth_key.c_str()); + + 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, (int)me->SDConnectTimeout, _("Storage daemon"), - jcr->stored_addr, NULL, stored_port, 1); + + sd->set_source_address(me->FDsrc_addr); + if (!sd->connect(jcr, 10, (int)me->SDConnectTimeout, me->heartbeat_interval, + _("Storage daemon"), jcr->stored_addr, NULL, stored_port, 1)) { + sd->destroy(); + sd = NULL; + } + 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; + goto bail_out; } Dmsg0(110, "Connection OK to SD.\n"); jcr->store_bsock = sd; - bnet_fsend(sd, "Hello Start Job %s\n", jcr->Job); + sd->fsend("Hello Start Job %s\n", jcr->Job); if (!authenticate_storagedaemon(jcr)) { Jmsg(jcr, M_FATAL, 0, _("Failed to authenticate Storage daemon.\n")); - return 0; + goto bail_out; } Dmsg0(110, "Authenticated with SD.\n"); /* Send OK to Director */ - return bnet_fsend(dir, OKstore); + return dir->fsend(OKstore); + +bail_out: + dir->fsend(BADcmd, "storage"); + return 0; + } /* - * Do a backup. For now, we handle only Full and Incremental. + * Do a backup. */ static int backup_cmd(JCR *jcr) { @@ -1216,36 +1490,48 @@ static int backup_cmd(JCR *jcr) BSOCK *sd = jcr->store_bsock; int ok = 0; int SDJobStatus; - char ed1[50], ed2[50]; -#ifdef WIN32_VSS +#if defined(WIN32_VSS) // capture state here, if client is backed up by multiple directors // and one enables vss and the other does not then enable_vss can change // between here and where its evaluated after the job completes. - bool bDoVSS = false; - - bDoVSS = g_pVSSClient && enable_vss; - if (bDoVSS) + jcr->VSS = g_pVSSClient && enable_vss; + if (jcr->VSS) { /* Run only one at a time */ P(vss_mutex); + } #endif + /* + * Validate some options given to the backup make sense for the compiled in + * options of this filed. + */ + if (jcr->ff->flags & FO_ACL && !have_acl) { + Jmsg(jcr, M_FATAL, 0, _("ACL support not configured for your machine.\n")); + goto cleanup; + } + if (jcr->ff->flags & FO_XATTR && !have_xattr) { + Jmsg(jcr, M_FATAL, 0, _("XATTR support not configured for your machine.\n")); + goto cleanup; + } + set_jcr_job_status(jcr, JS_Blocked); - jcr->JobType = JT_BACKUP; + jcr->set_JobType(JT_BACKUP); Dmsg1(100, "begin backup ff=%p\n", jcr->ff); if (sd == NULL) { Jmsg(jcr, M_FATAL, 0, _("Cannot contact Storage daemon\n")); + dir->fsend(BADcmd, "backup"); goto cleanup; } - bnet_fsend(dir, OKbackup); - Dmsg1(110, "bfiled>dird: %s", dir->msg); + dir->fsend(OKbackup); + Dmsg1(110, "filed>dird: %s", dir->msg); /* * Send Append Open Session to Storage daemon */ - bnet_fsend(sd, append_open); + sd->fsend(append_open); Dmsg1(110, ">stored: %s", sd->msg); /* * Expect to receive back the Ticket number @@ -1265,7 +1551,7 @@ static int backup_cmd(JCR *jcr) /* * Send Append data command to Storage daemon */ - bnet_fsend(sd, append_data, jcr->Ticket); + sd->fsend(append_data, jcr->Ticket); Dmsg1(110, ">stored: %s", sd->msg); /* @@ -1277,10 +1563,11 @@ static int backup_cmd(JCR *jcr) } generate_daemon_event(jcr, "JobStart"); + generate_plugin_event(jcr, bEventStartBackupJob); -#ifdef WIN32_VSS - /* START VSS ON WIN 32 */ - if (bDoVSS) { +#if defined(WIN32_VSS) + /* START VSS ON WIN32 */ + if (jcr->VSS) { if (g_pVSSClient->InitializeForBackup()) { /* tell vss which drives to snapshot */ char szWinDriveLetters[27]; @@ -1288,21 +1575,21 @@ static int backup_cmd(JCR *jcr) Jmsg(jcr, M_INFO, 0, _("Generate VSS snapshots. Driver=\"%s\", Drive(s)=\"%s\"\n"), g_pVSSClient->GetDriverName(), szWinDriveLetters); if (!g_pVSSClient->CreateSnapshots(szWinDriveLetters)) { Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshots failed.\n")); - jcr->Errors++; + jcr->JobErrors++; } else { /* tell user if snapshot creation of a specific drive failed */ int i; - for (i=0; i < strlen(szWinDriveLetters); i++) { + for (i=0; i < (int)strlen(szWinDriveLetters); i++) { if (islower(szWinDriveLetters[i])) { Jmsg(jcr, M_WARNING, 0, _("Generate VSS snapshot of drive \"%c:\\\" failed. VSS support is disabled on this drive.\n"), szWinDriveLetters[i]); - jcr->Errors++; + jcr->JobErrors++; } } /* inform user about writer states */ - for (i=0; iGetWriterCount(); i++) + for (i=0; i < (int)g_pVSSClient->GetWriterCount(); i++) if (g_pVSSClient->GetWriterState(i) < 1) { Jmsg(jcr, M_WARNING, 0, _("VSS Writer (PrepareForBackup): %s\n"), g_pVSSClient->GetWriterInfo(i)); - jcr->Errors++; + jcr->JobErrors++; } } } else { @@ -1310,8 +1597,9 @@ static int backup_cmd(JCR *jcr) } } else { berrno be; - Jmsg(jcr, M_WARNING, 0, _("VSS was not initialized properly. VSS support is disabled. ERR=%s\n"), be.strerror()); + Jmsg(jcr, M_WARNING, 0, _("VSS was not initialized properly. VSS support is disabled. ERR=%s\n"), be.bstrerror()); } + run_scripts(jcr, jcr->RunScripts, "ClientAfterVSS"); } #endif @@ -1326,11 +1614,8 @@ static int backup_cmd(JCR *jcr) Dmsg0(110, "Error in blast_data.\n"); } else { set_jcr_job_status(jcr, JS_Terminated); - - /* run shortly after end of data transmission */ - run_scripts(jcr, jcr->RunScripts, "ClientAfterJobShort"); - - if (jcr->JobStatus != JS_Terminated) { + /* Note, the above set status will not override an error */ + if (!(jcr->JobStatus == JS_Terminated || jcr->JobStatus == JS_Warnings)) { bnet_suppress_error_messages(sd, 1); goto cleanup; /* bail out now */ } @@ -1345,7 +1630,7 @@ static int backup_cmd(JCR *jcr) /* * Send Append End Data to Storage daemon */ - bnet_fsend(sd, append_end, jcr->Ticket); + sd->fsend(append_end, jcr->Ticket); /* Get end OK */ if (!response(jcr, sd, OK_end, "Append End")) { set_jcr_job_status(jcr, JS_ErrorTerminated); @@ -1355,7 +1640,7 @@ static int backup_cmd(JCR *jcr) /* * Send Append Close to Storage daemon */ - bnet_fsend(sd, append_close, jcr->Ticket); + sd->fsend(append_close, jcr->Ticket); while (bget_msg(sd) >= 0) { /* stop on signal or error */ if (sscanf(sd->msg, OK_close, &SDJobStatus) == 1) { ok = 1; @@ -1366,37 +1651,34 @@ static int backup_cmd(JCR *jcr) Jmsg(jcr, M_FATAL, 0, _("Append Close with SD failed.\n")); goto cleanup; } - if (SDJobStatus != JS_Terminated) { + if (!(SDJobStatus == JS_Terminated || SDJobStatus == JS_Warnings)) { Jmsg(jcr, M_FATAL, 0, _("Bad status %d returned from Storage Daemon.\n"), SDJobStatus); } } cleanup: -#ifdef WIN32_VSS - /* STOP VSS ON WIN 32 */ +#if defined(WIN32_VSS) + /* STOP VSS ON WIN32 */ /* tell vss to close the backup session */ - if (bDoVSS) { + if (jcr->VSS) { if (g_pVSSClient->CloseBackup()) { /* inform user about writer states */ for (int i=0; i<(int)g_pVSSClient->GetWriterCount(); i++) { int msg_type = M_INFO; if (g_pVSSClient->GetWriterState(i) < 1) { msg_type = M_WARNING; - jcr->Errors++; + jcr->JobErrors++; } Jmsg(jcr, msg_type, 0, _("VSS Writer (BackupComplete): %s\n"), g_pVSSClient->GetWriterInfo(i)); } } + Win32ConvCleanupCache(); V(vss_mutex); } #endif - 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); - + generate_plugin_event(jcr, bEventEndBackupJob); return 0; /* return and stop command loop */ } @@ -1408,36 +1690,38 @@ static int verify_cmd(JCR *jcr) { BSOCK *dir = jcr->dir_bsock; BSOCK *sd = jcr->store_bsock; - char level[100], ed1[50], ed2[50]; + char level[100]; - jcr->JobType = JT_VERIFY; + jcr->set_JobType(JT_VERIFY); if (sscanf(dir->msg, verifycmd, level) != 1) { - bnet_fsend(dir, _("2994 Bad verify command: %s\n"), dir->msg); + dir->fsend(_("2994 Bad verify command: %s\n"), dir->msg); return 0; } if (strcasecmp(level, "init") == 0) { - jcr->JobLevel = L_VERIFY_INIT; + jcr->set_JobLevel(L_VERIFY_INIT); } else if (strcasecmp(level, "catalog") == 0){ - jcr->JobLevel = L_VERIFY_CATALOG; + jcr->set_JobLevel(L_VERIFY_CATALOG); } else if (strcasecmp(level, "volume") == 0){ - jcr->JobLevel = L_VERIFY_VOLUME_TO_CATALOG; + jcr->set_JobLevel(L_VERIFY_VOLUME_TO_CATALOG); } else if (strcasecmp(level, "data") == 0){ - jcr->JobLevel = L_VERIFY_DATA; + jcr->set_JobLevel(L_VERIFY_DATA); } else if (strcasecmp(level, "disk_to_catalog") == 0) { - jcr->JobLevel = L_VERIFY_DISK_TO_CATALOG; + jcr->set_JobLevel(L_VERIFY_DISK_TO_CATALOG); } else { - bnet_fsend(dir, _("2994 Bad verify level: %s\n"), dir->msg); + dir->fsend(_("2994 Bad verify level: %s\n"), dir->msg); return 0; } - bnet_fsend(dir, OKverify); + dir->fsend(OKverify); generate_daemon_event(jcr, "JobStart"); + generate_plugin_event(jcr, bEventLevel, (void *)jcr->get_JobLevel()); + generate_plugin_event(jcr, bEventStartVerifyJob); - Dmsg1(110, "bfiled>dird: %s", dir->msg); + Dmsg1(110, "filed>dird: %s", dir->msg); - switch (jcr->JobLevel) { + switch (jcr->get_JobLevel()) { case L_VERIFY_INIT: case L_VERIFY_CATALOG: do_verify(jcr); @@ -1452,33 +1736,26 @@ static int verify_cmd(JCR *jcr) /* * Send Close session command to Storage daemon */ - bnet_fsend(sd, read_close, jcr->Ticket); - Dmsg1(130, "bfiled>stored: %s", sd->msg); + sd->fsend(read_close, jcr->Ticket); + Dmsg1(130, "filed>stored: %s", sd->msg); /* ****FIXME**** check response */ bget_msg(sd); /* get OK */ /* Inform Storage daemon that we are done */ - bnet_sig(sd, BNET_TERMINATE); + sd->signal(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); + dir->fsend(_("2994 Bad verify level: %s\n"), dir->msg); return 0; } - bnet_sig(dir, BNET_EOD); - - /* Send termination status back to Dir */ - bnet_fsend(dir, EndJob, jcr->JobStatus, jcr->JobFiles, - edit_uint64(jcr->ReadBytes, ed1), - edit_uint64(jcr->JobBytes, ed2), jcr->Errors); - - /* Inform Director that we are done */ - bnet_sig(dir, BNET_TERMINATE); + dir->signal(BNET_EOD); + generate_plugin_event(jcr, bEventEndVerifyJob); return 0; /* return and terminate command loop */ } @@ -1490,43 +1767,57 @@ static int restore_cmd(JCR *jcr) { BSOCK *dir = jcr->dir_bsock; BSOCK *sd = jcr->store_bsock; - POOLMEM *where; + POOLMEM *args; + bool use_regexwhere=false; int prefix_links; char replace; - char ed1[50], ed2[50]; /* * Scan WHERE (base directory for restore) from command */ Dmsg0(150, "restore command\n"); /* Pickup where string */ - where = get_memory(dir->msglen+1); - *where = 0; - - 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; + args = get_memory(dir->msglen+1); + *args = 0; + + if (sscanf(dir->msg, restorecmd, &replace, &prefix_links, args) != 3) { + if (sscanf(dir->msg, restorecmdR, &replace, &prefix_links, args) != 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; + } + *args = 0; } - *where = 0; + use_regexwhere = true; } /* Turn / into nothing */ - if (where[0] == '/' && where[1] == 0) { - where[0] = 0; + if (IsPathSeparator(args[0]) && args[1] == '\0') { + args[0] = '\0'; } - Dmsg2(150, "Got replace %c, where=%s\n", replace, where); - unbash_spaces(where); - jcr->where = bstrdup(where); - free_pool_memory(where); + Dmsg2(150, "Got replace %c, where=%s\n", replace, args); + unbash_spaces(args); + + if (use_regexwhere) { + jcr->where_bregexp = get_bregexps(args); + if (!jcr->where_bregexp) { + Jmsg(jcr, M_FATAL, 0, _("Bad where regexp. where=%s\n"), args); + free_pool_memory(args); + return 0; + } + } else { + jcr->where = bstrdup(args); + } + + free_pool_memory(args); jcr->replace = replace; jcr->prefix_links = prefix_links; - bnet_fsend(dir, OKrestore); - Dmsg1(110, "bfiled>dird: %s", dir->msg); + dir->fsend(OKrestore); + Dmsg1(110, "filed>dird: %s", dir->msg); - jcr->JobType = JT_RESTORE; + jcr->set_JobType(JT_RESTORE); set_jcr_job_status(jcr, JS_Blocked); @@ -1542,6 +1833,7 @@ static int restore_cmd(JCR *jcr) */ start_dir_heartbeat(jcr); generate_daemon_event(jcr, "JobStart"); + generate_plugin_event(jcr, bEventStartRestoreJob); do_restore(jcr); stop_dir_heartbeat(jcr); @@ -1553,28 +1845,39 @@ static int restore_cmd(JCR *jcr) /* * Send Close session command to Storage daemon */ - bnet_fsend(sd, read_close, jcr->Ticket); - Dmsg1(130, "bfiled>stored: %s", sd->msg); + sd->fsend(read_close, jcr->Ticket); + Dmsg1(130, "filed>stored: %s", sd->msg); bget_msg(sd); /* get OK */ /* Inform Storage daemon that we are done */ - bnet_sig(sd, BNET_TERMINATE); + sd->signal(BNET_TERMINATE); bail_out: + bfree_and_null(jcr->where); - if (jcr->Errors) { + if (jcr->JobErrors) { 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), - edit_uint64(jcr->JobBytes, ed2), jcr->Errors); - - /* Inform Director that we are done */ - bnet_sig(dir, BNET_TERMINATE); Dmsg0(130, "Done in job.c\n"); + + int ret; + if (jcr->multi_restore) { + dir->fsend(OKstoreend); + ret = 1; /* we continue the loop, waiting for next part */ + } else { + end_restore_cmd(jcr); + ret = 0; /* we stop here */ + } + + return ret; +} + +static int end_restore_cmd(JCR *jcr) +{ + Dmsg0(5, "end_restore_cmd\n"); + generate_plugin_event(jcr, bEventEndRestoreJob); return 0; /* return and terminate command loop */ } @@ -1592,7 +1895,7 @@ static int open_sd_read_session(JCR *jcr) /* * Open Read Session with Storage daemon */ - bnet_fsend(sd, read_open, "DummyVolume", + sd->fsend(read_open, "DummyVolume", jcr->VolSessionId, jcr->VolSessionTime, jcr->StartFile, jcr->EndFile, jcr->StartBlock, jcr->EndBlock); Dmsg1(110, ">stored: %s", sd->msg); @@ -1601,12 +1904,12 @@ static int open_sd_read_session(JCR *jcr) * Get ticket number */ if (bget_msg(sd) >= 0) { - Dmsg1(110, "bfiledmsg); + Dmsg1(110, "filedmsg); if (sscanf(sd->msg, OK_open, &jcr->Ticket) != 1) { Jmsg(jcr, M_FATAL, 0, _("Bad response to SD read open: %s\n"), sd->msg); return 0; } - Dmsg1(110, "bfiled: got Ticket=%d\n", jcr->Ticket); + Dmsg1(110, "filed: got Ticket=%d\n", jcr->Ticket); } else { Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to read open command\n")); return 0; @@ -1619,7 +1922,7 @@ static int open_sd_read_session(JCR *jcr) /* * Start read of data with Storage daemon */ - bnet_fsend(sd, read_data, jcr->Ticket); + sd->fsend(read_data, jcr->Ticket); Dmsg1(110, ">stored: %s", sd->msg); /* @@ -1638,7 +1941,7 @@ static int open_sd_read_session(JCR *jcr) static void filed_free_jcr(JCR *jcr) { if (jcr->store_bsock) { - bnet_close(jcr->store_bsock); + jcr->store_bsock->close(); } free_bootstrap(jcr); if (jcr->last_fname) { @@ -1647,6 +1950,9 @@ static void filed_free_jcr(JCR *jcr) free_runscripts(jcr->RunScripts); delete jcr->RunScripts; + if (jcr->JobId != 0) + write_state_file(me->working_directory, "bacula-fd", get_first_port_host_order(me->FDaddrs)); + return; } @@ -1697,17 +2003,17 @@ static int send_bootstrap_file(JCR *jcr) if (!bs) { berrno be; Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"), - jcr->RestoreBootstrap, be.strerror()); + jcr->RestoreBootstrap, be.bstrerror()); set_jcr_job_status(jcr, JS_ErrorTerminated); goto bail_out; } sd->msglen = pm_strcpy(sd->msg, bootstrap); - bnet_send(sd); + sd->send(); while (fgets(buf, sizeof(buf), bs)) { sd->msglen = Mmsg(sd->msg, "%s", buf); - bnet_send(sd); + sd->send(); } - bnet_sig(sd, BNET_EOD); + sd->signal(BNET_EOD); fclose(bs); if (!response(jcr, sd, OKSDbootstrap, "Bootstrap")) { set_jcr_job_status(jcr, JS_ErrorTerminated);