/*
Bacula® - The Network Backup Solution
- Copyright (C) 2007-2009 Free Software Foundation Europe e.V.
+ Copyright (C) 2007-2010 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.
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
*/
-/*
+/**
* Main program to test loading and running Bacula plugins.
* Destined to become Bacula pluginloader, ...
*
static void *baculaMalloc(bpContext *ctx, const char *file, int line,
size_t size);
static void baculaFree(bpContext *ctx, const char *file, int line, void *mem);
+static bRC baculaAddExclude(bpContext *ctx, const char *file);
+static bool is_plugin_compatible(Plugin *plugin);
/*
* These will be plugged into the global pointer structure for
baculaJobMsg,
baculaDebugMsg,
baculaMalloc,
- baculaFree
+ baculaFree,
+ baculaAddExclude
};
/*
JCR *jcr; /* jcr for plugin */
bRC rc; /* last return code */
bool disabled; /* set if plugin disabled */
+ findFILESET *fileset; /* pointer to exclude files */
};
static bool is_plugin_disabled(JCR *jcr)
}
-/*
+/**
* Create a plugin event
*/
void generate_plugin_event(JCR *jcr, bEventType eventType, void *value)
Plugin *plugin;
int i = 0;
- if (!plugin_list || !jcr || !jcr->plugin_ctx_list) {
+ if (!plugin_list || !jcr || !jcr->plugin_ctx_list || job_canceled(jcr)) {
return; /* Return if no plugins loaded */
}
return;
}
-/*
+/**
* Check if file was seen for accurate
*/
bool plugin_check_file(JCR *jcr, char *fname)
{
Plugin *plugin;
- bool ok = false;
+ int rc = bRC_OK;
int i = 0;
- if (!plugin_list || !jcr || !jcr->plugin_ctx_list) {
+ if (!plugin_list || !jcr || !jcr->plugin_ctx_list || job_canceled(jcr)) {
return false; /* Return if no plugins loaded */
}
if (plug_func(plugin)->checkFile == NULL) {
continue;
}
- ok = plug_func(plugin)->checkFile(jcr->plugin_ctx, fname);
- if (ok) {
+ rc = plug_func(plugin)->checkFile(jcr->plugin_ctx, fname);
+ if (rc == bRC_Seen) {
break;
}
}
jcr->plugin = NULL;
jcr->plugin_ctx = NULL;
- return ok;
+ return rc == bRC_Seen;
}
-/*
+/**
* Sequence of calls for a backup:
* 1. plugin_save() here is called with ff_pkt
* 2. we find the plugin requested on the command string
char *cmd = ff_pkt->top_fname;
struct save_pkt sp;
bEvent event;
+ POOL_MEM fname(PM_FNAME);
+ POOL_MEM link(PM_FNAME);
- if (!plugin_list || !jcr->plugin_ctx_list) {
+ if (!plugin_list || !jcr->plugin_ctx_list || job_canceled(jcr)) {
+ Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" not loaded.\n", cmd);
return 1; /* Return if no plugins loaded */
}
}
jcr->plugin_sp = &sp;
ff_pkt = jcr->ff;
- ff_pkt->fname = sp.fname;
- ff_pkt->link = sp.link;
+ /*
+ * Copy fname and link because save_file() zaps them. This
+ * avoids zaping the plugin's strings.
+ */
+ pm_strcpy(fname, sp.fname);
+ pm_strcpy(link, sp.link);
+ ff_pkt->fname = fname.c_str();
+ ff_pkt->link = link.c_str();
ff_pkt->type = sp.type;
memcpy(&ff_pkt->statp, &sp.statp, sizeof(ff_pkt->statp));
- Dmsg1(dbglvl, "Save_file: file=%s\n", ff_pkt->fname);
+ Dmsg1(dbglvl, "Save_file: file=%s\n", fname.c_str());
save_file(jcr, ff_pkt, true);
bRC rc = plug_func(plugin)->endBackupFile(jcr->plugin_ctx);
+ if (rc == bRC_More || rc == bRC_OK) {
+ accurate_mark_file_as_seen(jcr, fname.c_str());
+ }
if (rc == bRC_More) {
continue;
}
}
goto bail_out;
}
- Jmsg1(jcr, M_ERROR, 0, "Command plugin \"%s\" not found.\n", cmd);
+ Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" not found.\n", cmd);
bail_out:
jcr->cmd_plugin = false;
return 1;
}
-/*
+/**
* Send plugin name start/end record to SD
*/
bool send_plugin_name(JCR *jcr, BSOCK *sd, bool start)
Jmsg0(jcr, M_FATAL, 0, _("Plugin save packet not found.\n"));
return false;
}
+ if (job_canceled(jcr)) {
+ return false;
+ }
if (start) {
index++; /* JobFiles not incremented yet */
return true;
}
-/*
+/**
* Plugin name stream found during restore. The record passed in
* argument name was generated in send_plugin_name() above.
*
return start;
}
-/*
+/**
* Tell the plugin to create the file. Return values are
+ * This is called only during Restore
*
* CF_ERROR -- error
* CF_SKIP -- skip processing this file
int flags;
int rc;
- if (!plugin || !plugin_ctx || !set_cmd_plugin(bfd, jcr)) {
+ if (!plugin || !plugin_ctx || !set_cmd_plugin(bfd, jcr) || job_canceled(jcr)) {
return CF_ERROR;
}
rp.pkt_size = sizeof(rp);
return CF_EXTRACT;
}
-/*
+/**
* Reset the file attributes after all file I/O is done -- this allows
* the previous access time/dates to be set properly, and it also allows
* us to properly set directory permissions.
+ * Not currently Implemented.
*/
bool plugin_set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
{
return true;
}
+/*
+ * Print to file the plugin info.
+ */
void dump_fd_plugin(Plugin *plugin, FILE *fp)
{
if (!plugin) {
return ;
}
- pInfo *info = (pInfo *) plugin->pinfo;
+ pInfo *info = (pInfo *)plugin->pinfo;
fprintf(fp, "\tversion=%d\n", info->version);
fprintf(fp, "\tdate=%s\n", NPRTB(info->plugin_date));
fprintf(fp, "\tmagic=%s\n", NPRTB(info->plugin_magic));
fprintf(fp, "\tdescription=%s\n", NPRTB(info->plugin_description));
}
-/*
+/**
* This entry point is called internally by Bacula to ensure
* that the plugin IO calls come into this code.
*/
}
plugin_list = New(alist(10, not_owned_by_alist));
- if (!load_plugins((void *)&binfo, (void *)&bfuncs, plugin_dir, plugin_type)) {
+ if (!load_plugins((void *)&binfo, (void *)&bfuncs, plugin_dir, plugin_type,
+ is_plugin_compatible)) {
/* Either none found, or some error */
if (plugin_list->size() == 0) {
delete plugin_list;
plugin_bread = my_plugin_bread;
plugin_bwrite = my_plugin_bwrite;
plugin_blseek = my_plugin_blseek;
+
+ /*
+ * Verify that the plugin is acceptable, and print information
+ * about it.
+ */
foreach_alist(plugin, plugin_list) {
Jmsg(NULL, M_INFO, 0, _("Loaded plugin: %s\n"), plugin->file);
Dmsg1(dbglvl, "Loaded plugin: %s\n", plugin->file);
-
}
dbg_plugin_add_hook(dump_fd_plugin);
}
-/*
+/**
+ * Check if a plugin is compatible. Called by the load_plugin function
+ * to allow us to verify the plugin.
+ */
+static bool is_plugin_compatible(Plugin *plugin)
+{
+ pInfo *info = (pInfo *)plugin->pinfo;
+ Dmsg0(50, "is_plugin_compatible called\n");
+ if (debug_level >= 50) {
+ dump_fd_plugin(plugin, stdin);
+ }
+ if (strcmp(info->plugin_magic, FD_PLUGIN_MAGIC) != 0) {
+ Jmsg(NULL, M_ERROR, 0, _("Plugin magic wrong. Plugin=%s wanted=%s got=%s\n"),
+ plugin->file, FD_PLUGIN_MAGIC, info->plugin_magic);
+ Dmsg3(50, "Plugin magic wrong. Plugin=%s wanted=%s got=%s\n",
+ plugin->file, FD_PLUGIN_MAGIC, info->plugin_magic);
+
+ return false;
+ }
+ if (info->version != FD_PLUGIN_INTERFACE_VERSION) {
+ Jmsg(NULL, M_ERROR, 0, _("Plugin version incorrect. Plugin=%s wanted=%d got=%d\n"),
+ plugin->file, FD_PLUGIN_INTERFACE_VERSION, info->version);
+ Dmsg3(50, "Plugin version incorrect. Plugin=%s wanted=%d got=%d\n",
+ plugin->file, FD_PLUGIN_INTERFACE_VERSION, info->version);
+ return false;
+ }
+ if (strcmp(info->plugin_license, "Bacula GPLv2") != 0 &&
+ strcmp(info->plugin_license, "GPLv2") != 0) {
+ Jmsg(NULL, M_ERROR, 0, _("Plugin license incompatible. Plugin=%s license=%s\n"),
+ plugin->file, info->plugin_license);
+ Dmsg2(50, "Plugin license incompatible. Plugin=%s license=%s\n",
+ plugin->file, info->plugin_license);
+ return false;
+ }
+
+ return true;
+}
+
+
+/**
* Create a new instance of each plugin for this Job
* Note, plugin_list can exist but jcr->plugin_ctx_list can
* be NULL if no plugins were loaded.
Dmsg0(dbglvl, "plugin list is NULL\n");
return;
}
+ if (job_canceled(jcr)) {
+ return;
+ }
int num = plugin_list->size();
}
}
-/*
+/**
* Free the plugin instances for this Job
*/
void free_plugins(JCR *jcr)
struct io_pkt io;
Dmsg1(dbglvl, "plugin_bopen flags=%x\n", flags);
+ if (!plugin || !jcr->plugin_ctx) {
+ return 0;
+ }
io.pkt_size = sizeof(io);
io.pkt_end = sizeof(io);
io.func = IO_OPEN;
JCR *jcr = bfd->jcr;
Plugin *plugin = (Plugin *)jcr->plugin;
struct io_pkt io;
+
Dmsg0(dbglvl, "===== plugin_bclose\n");
+ if (!plugin || !jcr->plugin_ctx) {
+ return 0;
+ }
io.pkt_size = sizeof(io);
io.pkt_end = sizeof(io);
io.func = IO_CLOSE;
JCR *jcr = bfd->jcr;
Plugin *plugin = (Plugin *)jcr->plugin;
struct io_pkt io;
+
Dmsg0(dbglvl, "plugin_bread\n");
+ if (!plugin || !jcr->plugin_ctx) {
+ return 0;
+ }
io.pkt_size = sizeof(io);
io.pkt_end = sizeof(io);
io.func = IO_READ;
JCR *jcr = bfd->jcr;
Plugin *plugin = (Plugin *)jcr->plugin;
struct io_pkt io;
+
Dmsg0(dbglvl, "plugin_bwrite\n");
+ if (!plugin || !jcr->plugin_ctx) {
+ return 0;
+ }
io.pkt_size = sizeof(io);
io.pkt_end = sizeof(io);
io.func = IO_WRITE;
JCR *jcr = bfd->jcr;
Plugin *plugin = (Plugin *)jcr->plugin;
struct io_pkt io;
+
Dmsg0(dbglvl, "plugin_bseek\n");
+ if (!plugin || !jcr->plugin_ctx) {
+ return 0;
+ }
io.pkt_size = sizeof(io);
io.pkt_end = sizeof(io);
io.func = IO_SEEK;
if (!value || !ctx) {
return bRC_Error;
}
- jcr = ((bacula_ctx *)ctx->bContext)->jcr;
// Dmsg1(dbglvl, "bacula: baculaGetValue var=%d\n", var);
jcr = ((bacula_ctx *)ctx->bContext)->jcr;
if (!jcr) {
Dmsg1(dbglvl, "Bacula: return my_name=%s\n", my_name);
break;
case bVarLevel:
- *((int *)value) = jcr->get_JobLevel();
- Dmsg1(dbglvl, "Bacula: return bVarJobLevel=%d\n", jcr->get_JobLevel());
+ *((int *)value) = jcr->getJobLevel();
+ Dmsg1(dbglvl, "Bacula: return bVarJobLevel=%d\n", jcr->getJobLevel());
break;
case bVarType:
- *((int *)value) = jcr->get_JobType();
- Dmsg1(dbglvl, "Bacula: return bVarJobType=%d\n", jcr->get_JobType());
+ *((int *)value) = jcr->getJobType();
+ Dmsg1(dbglvl, "Bacula: return bVarJobType=%d\n", jcr->getJobType());
break;
case bVarClient:
*((char **)value) = jcr->client_name;
break;
case bVarFileSeen:
break; /* a write only variable, ignore read request */
+ case bVarVssObject:
+#ifdef HAVE_WIN32
+ if (g_pVSSClient) {
+ *(void **)value = g_pVSSClient->GetVssObject();
+ break;
+ }
+#endif
+ return bRC_Error;
}
return bRC_OK;
}
if (!value || !ctx) {
return bRC_Error;
}
- jcr = ((bacula_ctx *)ctx->bContext)->jcr;
// Dmsg1(dbglvl, "bacula: baculaGetValue var=%d\n", var);
jcr = ((bacula_ctx *)ctx->bContext)->jcr;
if (!jcr) {
#endif
}
+/**
+ * Let the plugin define files/directories to be excluded
+ * from the main backup.
+ */
+static bRC baculaAddExclude(bpContext *ctx, const char *file)
+{
+ JCR *jcr;
+ bacula_ctx *bctx;
+ if (ctx) {
+ return bRC_Error;
+ }
+ if (!file) {
+ return bRC_Error;
+ }
+ bctx = (bacula_ctx *)ctx->bContext;
+ if (!bctx) {
+ return bRC_Error;
+ }
+ jcr = bctx->jcr;
+ if (!jcr) {
+ return bRC_Error;
+ }
+ if (!bctx->fileset) {
+ bctx->fileset = new_exclude(jcr);
+ }
+ add_file_to_fileset(jcr, file, bctx->fileset, true);
+ return bRC_OK;
+}
#ifdef TEST_PROGRAM