/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
+ 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.
#include "vss.h"
static pthread_mutex_t vss_mutex = PTHREAD_MUTEX_INITIALIZER;
-static int enable_vss;
+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
+
+#if defined(HAVE_XATTR)
+const bool have_xattr = true;
+#else
+const bool have_xattr = false;
#endif
extern CLIENT *me; /* our client resource */
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);
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 */
{"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},
/* 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";
+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 OKrestore[] = "2000 OK restore\n";
static char OKsession[] = "2000 OK session\n";
static char OKstore[] = "2000 OK storage\n";
+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";
* 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 (optionnal)
+ * 8. SD/FD disconnects while SD despools data and attributes (optional)
* 9. FD runs ClientRunAfterJob
*/
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;
jcr->last_fname[0] = 0;
jcr->client_name = get_memory(strlen(my_name) + 1);
pm_strcpy(jcr->client_name, my_name);
+ 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;
/* Send termination status back to Dir */
dir->fsend(EndJob, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->ReadBytes, ed1),
- edit_uint64(jcr->JobBytes, ed2), jcr->Errors, jcr->VSS,
+ edit_uint64(jcr->JobBytes, ed2), jcr->JobErrors, jcr->VSS,
jcr->crypto.pki_encrypt);
Dmsg1(110, "End FD msg: %s\n", dir->msg);
}
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);
dir->fsend(BADjob);
- free_pool_memory(sd_auth_key);
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);
Mmsg(jcr->errmsg, "JobId=%d Job=%s", jcr->JobId, jcr->Job);
new_plugins(jcr); /* instantiate plugins for this jcr */
if (is_file) {
fileset->incexe->name_list.append(new_dlistString(fname));
} else {
- fileset->incexe->plugin_list.append(new_dlistString(fname));
+ 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;
}
} else {
type = M_INFO;
}
- Jmsg(jcr, type, 0, _("DIR and FD clocks differ by %d seconds, FD automatically compensating.\n"), adj);
+ Jmsg(jcr, type, 0, _("DIR and FD clocks differ by %lld seconds, FD automatically compensating.\n"), adj);
}
dir->signal(BNET_EOD);
- Dmsg2(100, "adj = %d since_time=%lld\n", (int)adj, since_time);
+ Dmsg2(100, "adj=%lld since_time=%lld\n", adj, since_time);
jcr->incremental = 1; /* set incremental or decremental backup */
jcr->mtime = since_time; /* set since time */
generate_plugin_event(jcr, bEventSince, (void *)(time_t)jcr->mtime);
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);
+}
+
/*
* Get address of storage daemon from Director
*
{
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);
- goto bail_out;
+ 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, me->heartbeat_interval,
- _("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);
return dir->fsend(OKstore);
bail_out:
- dir->fsend(BADcmd, "storage");
- return 0;
+ dir->fsend(BADcmd, "storage");
+ return 0;
}
}
#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->set_JobType(JT_BACKUP);
Dmsg1(100, "begin backup ff=%p\n", jcr->ff);
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 < (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; 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 {
Dmsg0(110, "Error in blast_data.\n");
} else {
set_jcr_job_status(jcr, JS_Terminated);
-
- 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 */
}
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);
}
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
sd->signal(BNET_TERMINATE);
bail_out:
+ bfree_and_null(jcr->where);
- if (jcr->Errors) {
+ if (jcr->JobErrors) {
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
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 */
}