/*
Bacula® - The Network Backup Solution
- Copyright (C) 2007-2010 Free Software Foundation Europe e.V.
+ Copyright (C) 2007-2012 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.
extern CLIENT *me;
extern DLL_IMP_EXP char *exepath;
+extern DLL_IMP_EXP char *version;
+extern DLL_IMP_EXP char *dist_name;
+extern DLL_IMP_EXP int beef;
const int dbglvl = 150;
#ifdef HAVE_WIN32
static bRC baculaAddWild(bpContext *ctx, const char *item, int type);
static bRC baculaNewOptions(bpContext *ctx);
static bRC baculaNewInclude(bpContext *ctx);
+static bRC baculaNewPreInclude(bpContext *ctx);
static bool is_plugin_compatible(Plugin *plugin);
static bool get_plugin_name(JCR *jcr, char *cmd, int *ret);
static bRC baculaCheckChanges(bpContext *ctx, struct save_pkt *sp);
baculaAddWild,
baculaNewOptions,
baculaNewInclude,
+ baculaNewPreInclude,
baculaCheckChanges
};
return true;
}
b_ctx = (bacula_ctx *)plugin_ctx->bContext;
+ if (!b_ctx) {
+ return true;
+ }
return b_ctx->disabled;
}
}
/**
- * Create a plugin event
- * When receiving bEventCancelCommand, this function is called by an other thread.
+ * Create a plugin event When receiving bEventCancelCommand, this function is
+ * called by an other thread.
*/
void generate_plugin_event(JCR *jcr, bEventType eventType, void *value)
{
bpContext *plugin_ctx;
bEvent event;
Plugin *plugin;
- int i = 0;
+ int i;
char *name = NULL;
int len = 0;
bool call_if_canceled = false;
- bRC rc;
+ restore_object_pkt *rop;
- if (!plugin_list || !jcr || !jcr->plugin_ctx_list) {
+ if (!bplugin_list || !jcr || !jcr->plugin_ctx_list) {
return; /* Return if no plugins loaded */
}
*/
switch(eventType) {
case bEventPluginCommand:
+ case bEventOptionPlugin:
name = (char *)value;
if (!get_plugin_name(jcr, name, &len)) {
return;
}
+ break;
+ case bEventRestoreObject:
+ /* After all RestoreObject, we have it one more time with value=NULL */
+ if (value) {
+ /* Some RestoreObjects may not have a plugin name */
+ rop = (restore_object_pkt *)value;
+ if (*rop->plugin_name) {
+ name = rop->plugin_name;
+ get_plugin_name(jcr, name, &len);
+ }
+ }
+
break;
case bEventEndBackupJob:
case bEventEndVerifyJob:
call_if_canceled = true;
break;
+ case bEventStartRestoreJob:
+ foreach_alist_index(i, plugin, bplugin_list) {
+ plugin->restoreFileStarted = false;
+ plugin->createFileCalled = false;
+ }
+ break;
case bEventEndRestoreJob:
call_if_canceled = true;
if (jcr->plugin && jcr->plugin->restoreFileStarted) {
plug_func(jcr->plugin)->endRestoreFile(jcr->plugin_ctx);
+ }
+ if (jcr->plugin) {
jcr->plugin->restoreFileStarted = false;
+ jcr->plugin->createFileCalled = false;
}
break;
default:
* Pass event to every plugin (except if name is set). If name
* is set, we pass it only to the plugin with that name.
*/
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
if (name && !for_this_plug(plugin, name, len)) {
- i++;
continue;
}
- plugin_ctx = &plugin_ctx_list[i++];
+ plugin_ctx = &plugin_ctx_list[i];
if (is_plugin_disabled(plugin_ctx)) {
continue;
}
- rc = plug_func(plugin)->handlePluginEvent(plugin_ctx, &event, value);
- if (rc != bRC_OK) {
- break;
- }
+ plug_func(plugin)->handlePluginEvent(plugin_ctx, &event, value);
}
return;
}
{
Plugin *plugin;
int rc = bRC_OK;
- int i = 0;
+ int i;
- if (!plugin_list || !jcr || !jcr->plugin_ctx_list || jcr->is_job_canceled()) {
+ if (!bplugin_list || !jcr || !jcr->plugin_ctx_list || jcr->is_job_canceled()) {
return false; /* Return if no plugins loaded */
}
Dmsg2(dbglvl, "plugin_ctx=%p JobId=%d\n", jcr->plugin_ctx_list, jcr->JobId);
/* Pass event to every plugin */
- foreach_alist(plugin, plugin_list) {
- jcr->plugin_ctx = &plugin_ctx_list[i++];
+ foreach_alist_index(i, plugin, bplugin_list) {
+ jcr->plugin_ctx = &plugin_ctx_list[i];
jcr->plugin = plugin;
if (is_plugin_disabled(jcr)) {
continue;
return true;
}
+
+static void update_ff_pkt(FF_PKT *ff_pkt, struct save_pkt *sp)
+{
+ ff_pkt->no_read = sp->no_read;
+ ff_pkt->delta_seq = sp->delta_seq;
+ if (sp->flags & FO_DELTA) {
+ ff_pkt->flags |= FO_DELTA;
+ ff_pkt->delta_seq++; /* make new delta sequence number */
+ } else {
+ ff_pkt->flags &= ~FO_DELTA; /* clean delta sequence number */
+ ff_pkt->delta_seq = 0;
+ }
+
+ if (sp->flags & FO_OFFSETS) {
+ ff_pkt->flags |= FO_OFFSETS;
+ }
+ if (sp->flags & FO_PORTABLE_DATA) {
+ ff_pkt->flags |= FO_PORTABLE_DATA;
+ }
+ ff_pkt->flags |= FO_PLUGIN; /* data from plugin */
+}
+
+/* Ask to a Option Plugin what to do with the current file */
+bRC plugin_option_handle_file(JCR *jcr, FF_PKT *ff_pkt, struct save_pkt *sp)
+{
+ Plugin *plugin;
+ bRC ret = bRC_Error;
+ char *cmd = ff_pkt->plugin;
+ int len;
+ int i=0;
+ bEvent event;
+ event.eventType = bEventHandleBackupFile;
+
+ bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
+ memset(sp, 0, sizeof(struct save_pkt));
+ sp->pkt_size = sp->pkt_end = sizeof(struct save_pkt);
+ sp->portable = true;
+ sp->cmd = cmd;
+ sp->link = ff_pkt->link;
+ sp->cmd = ff_pkt->plugin;
+ sp->statp = ff_pkt->statp;
+ sp->fname = ff_pkt->fname;
+ sp->delta_seq = ff_pkt->delta_seq;
+ sp->accurate_found = ff_pkt->accurate_found;
+
+ if (!bplugin_list || !jcr->plugin_ctx_list || jcr->is_job_canceled()) {
+ Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" requested, but is not loaded.\n", cmd);
+ goto bail_out; /* Return if no plugins loaded */
+ }
+
+ if (!get_plugin_name(jcr, cmd, &len)) {
+ goto bail_out;
+ }
+
+ /* Note, we stop the loop on the first plugin that matches the name */
+ foreach_alist_index(i, plugin, bplugin_list) {
+ Dmsg4(dbglvl, "plugin=%s plen=%d cmd=%s len=%d\n", plugin->file, plugin->file_len, cmd, len);
+ if (!for_this_plug(plugin, cmd, len)) {
+ continue;
+ }
+
+ if (is_plugin_disabled(&plugin_ctx_list[i])) {
+ goto bail_out;
+ }
+
+ ret = plug_func(plugin)->handlePluginEvent(&plugin_ctx_list[i],
+ &event, sp);
+
+ /* TODO: would be better to set this in save_file() */
+ if (ret == bRC_OK) {
+ jcr->opt_plugin = true;
+ jcr->plugin = plugin;
+ jcr->plugin_sp = sp; /* Unset sp in save_file */
+ jcr->plugin_ctx = &plugin_ctx_list[i];
+
+ update_ff_pkt(ff_pkt, sp);
+ }
+
+ goto bail_out;
+ } /* end foreach loop */
+bail_out:
+ return ret;
+}
+
/**
* Sequence of calls for a backup:
* 1. plugin_save() here is called with ff_pkt
int plugin_save(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
{
Plugin *plugin;
- int i = 0;
+ int i;
int len;
char *cmd = ff_pkt->top_fname;
struct save_pkt sp;
POOL_MEM fname(PM_FNAME);
POOL_MEM link(PM_FNAME);
- if (!plugin_list || !jcr->plugin_ctx_list || jcr->is_job_canceled()) {
+ if (!bplugin_list || !jcr->plugin_ctx_list || jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" requested, but is not loaded.\n", cmd);
return 1; /* Return if no plugins loaded */
}
}
/* Note, we stop the loop on the first plugin that matches the name */
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
Dmsg4(dbglvl, "plugin=%s plen=%d cmd=%s len=%d\n", plugin->file, plugin->file_len, cmd, len);
if (!for_this_plug(plugin, cmd, len)) {
- i++;
continue;
}
/*
* avoids zaping the plugin's strings.
*/
ff_pkt->type = sp.type;
- if (sp.type == FT_RESTORE_FIRST) {
+ if (IS_FT_OBJECT(sp.type)) {
if (!sp.object_name) {
Jmsg1(jcr, M_FATAL, 0, _("Command plugin \"%s\": no object_name in startBackupFile packet.\n"),
cmd);
}
pm_strcpy(fname, sp.fname);
pm_strcpy(link, sp.link);
+
+
ff_pkt->fname = fname.c_str();
ff_pkt->link = link.c_str();
- ff_pkt->delta_seq = sp.delta_seq;
- if (sp.flags & FO_DELTA) {
- ff_pkt->flags |= FO_DELTA;
- ff_pkt->delta_seq++; /* make new delta sequence number */
- } else {
- ff_pkt->flags &= ~FO_DELTA; /* clean delta sequence number */
- ff_pkt->delta_seq = 0;
- }
- if (sp.flags & FO_OFFSETS) {
- ff_pkt->flags |= FO_OFFSETS;
- }
- if (sp.flags & FO_PORTABLE_DATA) {
- ff_pkt->flags |= FO_PORTABLE_DATA;
- }
- ff_pkt->flags |= FO_PLUGIN; /* data from plugin */
+ update_ff_pkt(ff_pkt, &sp);
}
memcpy(&ff_pkt->statp, &sp.statp, sizeof(ff_pkt->statp));
return 1;
}
+
+/**
+ * Sequence of calls for a estimate:
+ * 1. plugin_estimate() here is called with ff_pkt
+ * 2. we find the plugin requested on the command string
+ * 3. we generate a bEventEstimateCommand event to the specified plugin
+ * and pass it the command string.
+ * 4. we make a startPluginBackup call to the plugin, which gives
+ * us the data we need in save_pkt
+ *
+ */
+int plugin_estimate(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
+{
+ Plugin *plugin;
+ int len;
+ int i;
+ char *cmd = ff_pkt->top_fname;
+ struct save_pkt sp;
+ bEvent event;
+ POOL_MEM fname(PM_FNAME);
+ POOL_MEM link(PM_FNAME);
+ ATTR attr;
+
+ if (!bplugin_list || !jcr->plugin_ctx_list) {
+ Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" requested, but is not loaded.\n", cmd);
+ return 1; /* Return if no plugins loaded */
+ }
+
+ jcr->cmd_plugin = true;
+ bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
+ event.eventType = bEventEstimateCommand;
+
+ if (!get_plugin_name(jcr, cmd, &len)) {
+ goto bail_out;
+ }
+
+ /* Note, we stop the loop on the first plugin that matches the name */
+ foreach_alist_index(i, plugin, bplugin_list) {
+ Dmsg4(dbglvl, "plugin=%s plen=%d cmd=%s len=%d\n", plugin->file, plugin->file_len, cmd, len);
+ if (!for_this_plug(plugin, cmd, len)) {
+ continue;
+ }
+ /*
+ * We put the current plugin pointer, and the plugin context
+ * into the jcr, because during save_file(), the plugin
+ * will be called many times and these values are needed.
+ */
+ jcr->plugin_ctx = &plugin_ctx_list[i];
+ jcr->plugin = plugin;
+ if (is_plugin_disabled(jcr)) {
+ goto bail_out;
+ }
+
+ Dmsg1(dbglvl, "Command plugin = %s\n", cmd);
+ /* Send the backup command to the right plugin*/
+ if (plug_func(plugin)->handlePluginEvent(jcr->plugin_ctx, &event, cmd) != bRC_OK) {
+ goto bail_out;
+ }
+ /* Loop getting filenames to backup then saving them */
+ while (!jcr->is_job_canceled()) {
+ memset(&sp, 0, sizeof(sp));
+ sp.pkt_size = sizeof(sp);
+ sp.pkt_end = sizeof(sp);
+ sp.portable = true;
+ sp.flags = 0;
+ sp.cmd = cmd;
+ Dmsg3(dbglvl, "startBackup st_size=%p st_blocks=%p sp=%p\n", &sp.statp.st_size, &sp.statp.st_blocks,
+ &sp);
+ /* Get the file save parameters. I.e. the stat pkt ... */
+ if (plug_func(plugin)->startBackupFile(jcr->plugin_ctx, &sp) != bRC_OK) {
+ goto bail_out;
+ }
+ if (sp.type == 0) {
+ Jmsg1(jcr, M_FATAL, 0, _("Command plugin \"%s\": no type in startBackupFile packet.\n"),
+ cmd);
+ goto bail_out;
+ }
+
+ if (!IS_FT_OBJECT(sp.type)) {
+ if (!sp.fname) {
+ Jmsg1(jcr, M_FATAL, 0, _("Command plugin \"%s\": no fname in startBackupFile packet.\n"),
+ cmd);
+ goto bail_out;
+ }
+
+ jcr->num_files_examined++;
+ jcr->JobFiles++; /* increment number of files seen */
+
+ if (sp.type != FT_LNKSAVED && S_ISREG(sp.statp.st_mode)) {
+ if (sp.statp.st_size > 0) {
+ jcr->JobBytes += sp.statp.st_size;
+ }
+ }
+
+ if (jcr->listing) {
+ memcpy(&attr.statp, &sp.statp, sizeof(struct stat));
+ attr.type = sp.type;
+ attr.ofname = (POOLMEM *)sp.fname;
+ attr.olname = (POOLMEM *)sp.link;
+ print_ls_output(jcr, &attr);
+ }
+ }
+
+ Dmsg2(dbglvl, "startBackup returned type=%d, fname=%s\n", sp.type, sp.fname);
+ if (sp.object) {
+ Dmsg2(dbglvl, "index=%d object=%s\n", sp.index, sp.object);
+ }
+ bRC rc = plug_func(plugin)->endBackupFile(jcr->plugin_ctx);
+ if (rc == bRC_More || rc == bRC_OK) {
+ accurate_mark_file_as_seen(jcr, sp.fname);
+ }
+ if (rc == bRC_More) {
+ continue;
+ }
+ goto bail_out;
+ } /* end while loop */
+ goto bail_out;
+ } /* end loop over all plugins */
+ Jmsg1(jcr, M_FATAL, 0, "Command plugin \"%s\" not found.\n", cmd);
+
+bail_out:
+ jcr->cmd_plugin = false;
+ jcr->plugin = NULL;
+ jcr->plugin_ctx = NULL;
+ return 1;
+}
+
/**
* Send plugin name start/end record to SD
*/
stat = sd->fsend("%ld 1 %d %s%c", index, sp->portable, sp->cmd, 0);
} else {
/* Send end of data */
- stat = sd->fsend("0 0");
+ stat = sd->fsend("%ld 0", jcr->JobFiles);
}
if (!stat) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
{
char *p = name;
char *cmd;
- bool start, portable;
+ bool start;
Plugin *plugin;
int len;
- int i = 0;
+ int i;
bpContext *plugin_ctx_list = jcr->plugin_ctx_list;
Dmsg1(dbglvl, "Read plugin stream string=%s\n", name);
/* Start of plugin data */
skip_nonspaces(&p); /* skip start/end flag */
skip_spaces(&p);
- portable = *p == '1';
+// portable = *p == '1';
skip_nonspaces(&p); /* skip portable flag */
skip_spaces(&p);
cmd = p;
Dmsg2(dbglvl, "End plugin data plugin=%p ctx=%p\n", jcr->plugin, jcr->plugin_ctx);
if (jcr->plugin && jcr->plugin->restoreFileStarted) {
plug_func(jcr->plugin)->endRestoreFile(jcr->plugin_ctx);
+ }
+ if (jcr->plugin) {
jcr->plugin->restoreFileStarted = false;
+ jcr->plugin->createFileCalled = false;
}
jcr->plugin_ctx = NULL;
jcr->plugin = NULL;
/*
* Search for correct plugin as specified on the command
*/
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
bEvent event;
Dmsg3(dbglvl, "plugin=%s cmd=%s len=%d\n", plugin->file, cmd, len);
if (!for_this_plug(plugin, cmd, len)) {
- i++;
continue;
}
jcr->plugin_ctx = &plugin_ctx_list[i];
if (is_plugin_disabled(jcr)) {
goto bail_out;
}
- Dmsg1(dbglvl, "Restore Command plugin = %s\n", cmd);
+ Dmsg1(000, "Restore Command plugin = %s\n", cmd);
event.eventType = bEventRestoreCommand;
if (plug_func(plugin)->handlePluginEvent(jcr->plugin_ctx,
&event, cmd) != bRC_OK) {
goto bail_out;
}
- /* ***FIXME**** check error code */
if (plugin->restoreFileStarted) {
- plug_func(jcr->plugin)->endRestoreFile(jcr->plugin_ctx);
+ Jmsg2(jcr, M_FATAL, 0, "Unbalanced call to startRestoreFile. plugin=%s cmd=%s\n", plugin->file, cmd);
+ plugin->restoreFileStarted = false;
+ goto bail_out;
+ }
+ if (plug_func(plugin)->startRestoreFile(jcr->plugin_ctx, cmd) == bRC_OK) {
+ plugin->restoreFileStarted = true;
}
- plug_func(plugin)->startRestoreFile((bpContext *)jcr->plugin_ctx, cmd);
- plugin->restoreFileStarted = true;
goto bail_out;
}
Jmsg1(jcr, M_WARNING, 0, _("Plugin=%s not found.\n"), cmd);
if (rp.attrEx) {
Dmsg1(dbglvl, "attrEx=\"%s\"\n", rp.attrEx);
}
+ if (!plugin->restoreFileStarted || plugin->createFileCalled) {
+ Jmsg0(jcr, M_FATAL, 0, "Unbalanced call to createFile\n");
+ plugin->createFileCalled = false;
+ return CF_ERROR;
+ }
rc = plug_func(plugin)->createFile(plugin_ctx, &rp);
if (rc != bRC_OK) {
Qmsg2(jcr, M_ERROR, 0, _("Plugin createFile call failed. Stat=%d file=%s\n"),
rc, attr->ofname);
return CF_ERROR;
}
+ if (rp.create_status == CF_CORE) {
+ return CF_CORE; /* Let Bacula core handle the file creation */
+ }
if (rp.create_status == CF_SKIP) {
return CF_SKIP;
}
void load_fd_plugins(const char *plugin_dir)
{
Plugin *plugin;
+ int i;
if (!plugin_dir) {
Dmsg0(dbglvl, "plugin dir is NULL\n");
return;
}
- plugin_list = New(alist(10, not_owned_by_alist));
+ bplugin_list = New(alist(10, not_owned_by_alist));
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_list = NULL;
+ if (bplugin_list->size() == 0) {
+ delete bplugin_list;
+ bplugin_list = NULL;
Dmsg0(dbglvl, "No plugins loaded\n");
return;
}
* Verify that the plugin is acceptable, and print information
* about it.
*/
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
Jmsg(NULL, M_INFO, 0, _("Loaded plugin: %s\n"), plugin->file);
Dmsg1(dbglvl, "Loaded plugin: %s\n", plugin->file);
}
plugin->file, info->plugin_license);
return false;
}
+ if (info->size != sizeof(pInfo)) {
+ Jmsg(NULL, M_ERROR, 0,
+ _("Plugin size incorrect. Plugin=%s wanted=%d got=%d\n"),
+ plugin->file, sizeof(pInfo), info->size);
+ 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
+ * Note, bplugin_list can exist but jcr->plugin_ctx_list can
* be NULL if no plugins were loaded.
*/
void new_plugins(JCR *jcr)
{
Plugin *plugin;
- int i = 0;
+ int i;
- if (!plugin_list) {
+ if (!bplugin_list) {
Dmsg0(dbglvl, "plugin list is NULL\n");
return;
}
- if (jcr->is_job_canceled() || jcr->JobId == 0) {
+ if (jcr->is_job_canceled()) {
return;
}
- int num = plugin_list->size();
+ int num = bplugin_list->size();
if (num == 0) {
Dmsg0(dbglvl, "No plugins loaded\n");
bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
Dmsg2(dbglvl, "Instantiate plugin_ctx=%p JobId=%d\n", plugin_ctx_list, jcr->JobId);
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
/* Start a new instance of each plugin */
bacula_ctx *b_ctx = (bacula_ctx *)malloc(sizeof(bacula_ctx));
memset(b_ctx, 0, sizeof(bacula_ctx));
b_ctx->jcr = jcr;
plugin_ctx_list[i].bContext = (void *)b_ctx; /* Bacula private context */
plugin_ctx_list[i].pContext = NULL;
- if (plug_func(plugin)->newPlugin(&plugin_ctx_list[i++]) != bRC_OK) {
+ if (plug_func(plugin)->newPlugin(&plugin_ctx_list[i]) != bRC_OK) {
b_ctx->disabled = true;
}
}
void free_plugins(JCR *jcr)
{
Plugin *plugin;
- int i = 0;
+ int i;
- if (!plugin_list || !jcr->plugin_ctx_list) {
+ if (!bplugin_list || !jcr->plugin_ctx_list) {
return; /* no plugins, nothing to do */
}
bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
Dmsg2(dbglvl, "Free instance plugin_ctx=%p JobId=%d\n", plugin_ctx_list, jcr->JobId);
- foreach_alist(plugin, plugin_list) {
+ foreach_alist_index(i, plugin, bplugin_list) {
/* Free the plugin instance */
plug_func(plugin)->freePlugin(&plugin_ctx_list[i]);
- free(plugin_ctx_list[i++].bContext); /* free Bacula private context */
+ free(plugin_ctx_list[i].bContext); /* free Bacula private context */
}
free(plugin_ctx_list);
jcr->plugin_ctx_list = NULL;
case bVarExePath:
*(char **)value = exepath;
break;
+ case bVarVersion:
+ *(char **)value = version;
+ break;
+ case bVarDistName:
+ *(char **)value = dist_name;
+ break;
+ case bVarBEEF:
+ *((int *)value) = beef;
+ break;
default:
break;
}
*((char **)value) = jcr->Job;
Dmsg1(dbglvl, "Bacula: return Job name=%s\n", jcr->Job);
break;
+ case bVarPrevJobName:
+ *((char **)value) = jcr->PrevJob;
+ Dmsg1(dbglvl, "Bacula: return Previous Job name=%s\n", jcr->PrevJob);
+ break;
case bVarJobStatus:
*((int *)value) = jcr->JobStatus;
Dmsg1(dbglvl, "Bacula: return bVarJobStatus=%d\n", jcr->JobStatus);
case bVarRegexWhere:
*(char **)value = jcr->RegexWhere;
break;
-
case bVarFDName: /* get warning with g++ if we missed one */
case bVarWorkingDir:
case bVarExePath:
+ case bVarVersion:
+ case bVarDistName:
+ case bVarBEEF:
+ case bVarPrefixLinks:
break;
}
return bRC_OK;
if (!file) {
return bRC_Error;
}
- if (!bctx->include) {
- bctx->include = new_preinclude(jcr);
- new_options(jcr, bctx->include);
+ /* Not right time to add include */
+ if (!(jcr->ff && jcr->ff->fileset && jcr->ff->fileset->incexe)) {
+ return bRC_Error;
+ }
+ if (!bctx->include) {
+ bctx->include = jcr->ff->fileset->incexe;
}
set_incexe(jcr, bctx->include);
add_file_to_fileset(jcr, file, true);
return bRC_OK;
}
+static bRC baculaNewPreInclude(bpContext *ctx)
+{
+ JCR *jcr;
+ bacula_ctx *bctx;
+ if (!is_ctx_good(ctx, jcr, bctx)) {
+ return bRC_Error;
+ }
+
+ bctx->include = new_preinclude(jcr);
+ new_options(jcr, bctx->include);
+ set_incexe(jcr, bctx->include);
+
+ return bRC_OK;
+}
/*
* Check if a file have to be backuped using Accurate code
* plugin
*/
sp->delta_seq = ff_pkt->delta_seq;
+ sp->accurate_found = ff_pkt->accurate_found;
bail_out:
Dmsg1(100, "checkChanges=%i\n", ret);