2 Bacula® - The Network Backup Solution
4 Copyright (C) 2007-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation, which is
11 listed in the file LICENSE.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Main program to test loading and running Bacula plugins.
30 * Destined to become Bacula pluginloader, ...
32 * Kern Sibbald, October 2007
37 const int dbglvl = 50;
39 const char *plugin_type = "-fd.dll";
41 const char *plugin_type = "-fd.so";
44 extern int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level);
46 /* Function pointers to be set here */
47 extern DLL_IMP_EXP int (*plugin_bopen)(BFILE *bfd, const char *fname, int flags, mode_t mode);
48 extern DLL_IMP_EXP int (*plugin_bclose)(BFILE *bfd);
49 extern DLL_IMP_EXP ssize_t (*plugin_bread)(BFILE *bfd, void *buf, size_t count);
50 extern DLL_IMP_EXP ssize_t (*plugin_bwrite)(BFILE *bfd, void *buf, size_t count);
51 extern DLL_IMP_EXP boffset_t (*plugin_blseek)(BFILE *bfd, boffset_t offset, int whence);
54 /* Forward referenced functions */
55 static bRC baculaGetValue(bpContext *ctx, bVariable var, void *value);
56 static bRC baculaSetValue(bpContext *ctx, bVariable var, void *value);
57 static bRC baculaRegisterEvents(bpContext *ctx, ...);
58 static bRC baculaJobMsg(bpContext *ctx, const char *file, int line,
59 int type, time_t mtime, const char *fmt, ...);
60 static bRC baculaDebugMsg(bpContext *ctx, const char *file, int line,
61 int level, const char *fmt, ...);
63 static int my_plugin_bopen(BFILE *bfd, const char *fname, int flags, mode_t mode);
64 static int my_plugin_bclose(BFILE *bfd);
65 static ssize_t my_plugin_bread(BFILE *bfd, void *buf, size_t count);
66 static ssize_t my_plugin_bwrite(BFILE *bfd, void *buf, size_t count);
67 static boffset_t my_plugin_blseek(BFILE *bfd, boffset_t offset, int whence);
71 static bInfo binfo = {
73 FD_PLUGIN_INTERFACE_VERSION
76 /* Bacula entry points */
77 static bFuncs bfuncs = {
79 FD_PLUGIN_INTERFACE_VERSION,
89 * Create a plugin event
91 void generate_plugin_event(JCR *jcr, bEventType eventType, void *value)
97 if (!plugin_list || !jcr->plugin_ctx_list) {
98 return; /* Return if no plugins loaded */
101 bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
102 event.eventType = eventType;
104 Dmsg2(dbglvl, "plugin_ctx=%p JobId=%d\n", jcr->plugin_ctx_list, jcr->JobId);
106 /* Pass event to every plugin */
107 foreach_alist(plugin, plugin_list) {
109 rc = plug_func(plugin)->handlePluginEvent(&plugin_ctx_list[i++], &event, value);
119 * Sequence of calls for a backup:
120 * 1. plugin_save() here is called with ff_pkt
121 * 2. we find the plugin requested on the command string
122 * 3. we generate a bEventBackupCommand event to the specified plugin
123 * and pass it the command string.
124 * 4. we make a startPluginBackup call to the plugin, which gives
125 * us the data we need in save_pkt
126 * 5. we call Bacula's save_file() subroutine to save the specified
127 * file. The plugin will be called at pluginIO() to supply the
130 * Sequence of calls for restore:
131 * See subroutine plugin_name_stream() below.
133 int plugin_save(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
139 char *cmd = ff_pkt->top_fname;
143 if (!plugin_list || !jcr->plugin_ctx_list) {
144 return 1; /* Return if no plugins loaded */
147 jcr->cmd_plugin = true;
148 bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
149 event.eventType = bEventBackupCommand;
151 /* Handle plugin command here backup */
152 Dmsg1(dbglvl, "plugin cmd=%s\n", cmd);
153 if (!(p = strchr(cmd, ':'))) {
154 Jmsg1(jcr, M_ERROR, 0, "Malformed plugin command: %s\n", cmd);
162 foreach_alist(plugin, plugin_list) {
163 Dmsg3(dbglvl, "plugin=%s cmd=%s len=%d\n", plugin->file, cmd, len);
164 if (strncmp(plugin->file, cmd, len) != 0) {
168 Dmsg1(dbglvl, "Command plugin = %s\n", cmd);
169 /* Send the backup command to the right plugin*/
170 if (plug_func(plugin)->handlePluginEvent(&plugin_ctx_list[i], &event, cmd) != bRC_OK) {
173 /* Loop getting filenames to backup then saving them */
174 while (!job_canceled(jcr)) {
175 memset(&sp, 0, sizeof(sp));
176 sp.pkt_size = sizeof(sp);
177 sp.pkt_end = sizeof(sp);
180 Dmsg3(dbglvl, "startBackup st_size=%p st_blocks=%p sp=%p\n", &sp.statp.st_size, &sp.statp.st_blocks,
182 /* Get the file save parameters */
183 if (plug_func(plugin)->startBackupFile(&plugin_ctx_list[i], &sp) != bRC_OK) {
186 if (sp.type == 0 || sp.fname == NULL) {
187 Jmsg1(jcr, M_FATAL, 0, _("Command plugin \"%s\" returned bad startBackupFile packet.\n"),
191 jcr->plugin_ctx = &plugin_ctx_list[i];
192 jcr->plugin = plugin;
193 jcr->plugin_sp = &sp;
195 ff_pkt->fname = sp.fname;
196 ff_pkt->type = sp.type;
197 memcpy(&ff_pkt->statp, &sp.statp, sizeof(ff_pkt->statp));
198 Dmsg1(dbglvl, "Save_file: file=%s\n", ff_pkt->fname);
199 save_file(jcr, ff_pkt, true);
200 bRC rc = plug_func(plugin)->endBackupFile(&plugin_ctx_list[i]);
201 if (rc == bRC_More) {
207 Jmsg1(jcr, M_ERROR, 0, "Command plugin \"%s\" not found.\n", cmd);
210 jcr->cmd_plugin = false;
215 * Send plugin name start/end record to SD
217 bool send_plugin_name(JCR *jcr, BSOCK *sd, bool start)
220 struct save_pkt *sp = (struct save_pkt *)jcr->plugin_sp;
222 Dmsg1(dbglvl, "send_plugin_name=%s\n", sp->cmd);
223 /* Send stream header */
224 if (!sd->fsend("%ld %d 0", jcr->JobFiles+1, STREAM_PLUGIN_NAME)) {
225 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
229 Dmsg1(000, "send: %s\n", sd->msg);
232 /* Send data -- not much */
233 stat = sd->fsend("%ld 1 %d %s%c", jcr->JobFiles+1, sp->portable, sp->cmd, 0);
235 /* Send end of data */
236 stat = sd->fsend("0 0");
239 Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
243 Dmsg1(dbglvl, "send: %s\n", sd->msg);
244 sd->signal(BNET_EOD); /* indicate end of plugin name data */
249 * Plugin name stream found during restore. The record passed in
250 * argument name was generated in send_plugin_name() above.
252 void plugin_name_stream(JCR *jcr, char *name)
256 bool start, portable;
260 bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
261 if (!plugin_ctx_list) {
265 Dmsg1(dbglvl, "Read plugin stream string=%s\n", name);
266 skip_nonspaces(&p); /* skip over jcr->JobFiles */
270 /* Start of plugin data */
271 skip_nonspaces(&p); /* skip start/end flag */
273 portable = *p == '1';
274 skip_nonspaces(&p); /* skip portable flag */
279 * End of plugin data, notify plugin, then clear flags
281 plugin = (Plugin *)jcr->plugin;
282 plug_func(plugin)->endRestoreFile((bpContext *)jcr->plugin_ctx);
283 jcr->plugin_ctx = NULL;
289 * After this point, we are dealing with a restore start
292 Dmsg1(dbglvl, "plugin restore cmd=%s\n", cmd);
293 if (!(p = strchr(cmd, ':'))) {
294 Jmsg1(jcr, M_ERROR, 0, "Malformed plugin command: %s\n", cmd);
303 * Search for correct plugin as specified on the command
305 foreach_alist(plugin, plugin_list) {
307 Dmsg3(dbglvl, "plugin=%s cmd=%s len=%d\n", plugin->file, cmd, len);
308 if (strncmp(plugin->file, cmd, len) != 0) {
312 Dmsg1(dbglvl, "Restore Command plugin = %s\n", cmd);
313 event.eventType = bEventRestoreCommand;
314 if (plug_func(plugin)->handlePluginEvent(&plugin_ctx_list[i],
315 &event, cmd) != bRC_OK) {
318 jcr->plugin_ctx = &plugin_ctx_list[i];
319 jcr->plugin = plugin;
327 * Tell the plugin to create the file. Return values are
330 * CF_SKIP -- skip processing this file
331 * CF_EXTRACT -- extract the file (i.e.call i/o routines)
332 * CF_CREATED -- created, but no content to extract (typically directories)
335 int plugin_create_file(JCR *jcr, ATTR *attr, BFILE *bfd, int replace)
337 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
338 Plugin *plugin = (Plugin *)jcr->plugin;
339 struct restore_pkt rp;
342 if (!set_cmd_plugin(bfd, jcr)) {
345 rp.pkt_size = sizeof(rp);
346 rp.pkt_end = sizeof(rp);
347 rp.stream = attr->stream;
348 rp.data_stream = attr->data_stream;
349 rp.type = attr->type;
350 rp.file_index = attr->file_index;
351 rp.LinkFI = attr->LinkFI;
353 rp.statp = attr->statp; /* structure assignment */
354 rp.attrEx = attr->attrEx;
355 rp.ofname = attr->ofname;
356 rp.olname = attr->olname;
357 rp.where = jcr->where;
358 rp.RegexWhere = jcr->RegexWhere;
359 rp.replace = jcr->replace;
360 if (plug_func(plugin)->createFile(plugin_ctx, &rp) != bRC_OK) {
363 io.pkt_size = sizeof(io);
364 io.pkt_end = sizeof(io);
368 io.mode = 0777 & attr->statp.st_mode;
370 if (plug_func(plugin)->pluginIO(plugin_ctx, &io) != bRC_OK) {
377 * Reset the file attributes after all file I/O is done -- this allows
378 * the previous access time/dates to be set properly, and it also allows
379 * us to properly set directory permissions.
381 bool plugin_set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
387 * This entry point is called internally by Bacula to ensure
388 * that the plugin IO calls come into this code.
390 void load_fd_plugins(const char *plugin_dir)
395 Dmsg0(dbglvl, "plugin dir is NULL\n");
399 plugin_list = New(alist(10, not_owned_by_alist));
400 if (!load_plugins((void *)&binfo, (void *)&bfuncs, plugin_dir, plugin_type)) {
401 /* Either none found, or some error */
402 if (plugin_list->size() == 0) {
405 Dmsg0(dbglvl, "No plugins loaded\n");
410 /* Plug entry points called from findlib */
411 plugin_bopen = my_plugin_bopen;
412 plugin_bclose = my_plugin_bclose;
413 plugin_bread = my_plugin_bread;
414 plugin_bwrite = my_plugin_bwrite;
415 plugin_blseek = my_plugin_blseek;
416 foreach_alist(plugin, plugin_list) {
417 Jmsg(NULL, M_INFO, 0, _("Loaded plugin: %s\n"), plugin->file);
418 Dmsg1(dbglvl, "Loaded plugin: %s\n", plugin->file);
424 * Create a new instance of each plugin for this Job
425 * Note, plugin_list can exist but jcr->plugin_ctx_list can
426 * be NULL if no plugins were loaded.
428 void new_plugins(JCR *jcr)
434 Dmsg0(dbglvl, "plugin list is NULL\n");
438 int num = plugin_list->size();
441 Dmsg0(dbglvl, "No plugins loaded\n");
445 jcr->plugin_ctx_list = (void *)malloc(sizeof(bpContext) * num);
447 bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
448 Dmsg2(dbglvl, "Instantiate plugin_ctx=%p JobId=%d\n", plugin_ctx_list, jcr->JobId);
449 foreach_alist(plugin, plugin_list) {
450 /* Start a new instance of each plugin */
451 plugin_ctx_list[i].bContext = (void *)jcr;
452 plugin_ctx_list[i].pContext = NULL;
453 plug_func(plugin)->newPlugin(&plugin_ctx_list[i++]);
458 * Free the plugin instances for this Job
460 void free_plugins(JCR *jcr)
465 if (!plugin_list || !jcr->plugin_ctx_list) {
466 return; /* no plugins, nothing to do */
469 bpContext *plugin_ctx_list = (bpContext *)jcr->plugin_ctx_list;
470 Dmsg2(dbglvl, "Free instance plugin_ctx=%p JobId=%d\n", plugin_ctx_list, jcr->JobId);
471 foreach_alist(plugin, plugin_list) {
472 /* Free the plugin instance */
473 plug_func(plugin)->freePlugin(&plugin_ctx_list[i++]);
475 free(plugin_ctx_list);
476 jcr->plugin_ctx_list = NULL;
479 static int my_plugin_bopen(BFILE *bfd, const char *fname, int flags, mode_t mode)
482 Plugin *plugin = (Plugin *)jcr->plugin;
483 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
485 Dmsg0(dbglvl, "plugin_bopen\n");
486 io.pkt_size = sizeof(io);
487 io.pkt_end = sizeof(io);
496 plug_func(plugin)->pluginIO(plugin_ctx, &io);
497 bfd->berrno = io.io_errno;
499 errno = b_errno_win32;
502 bfd->lerror = io.lerror;
507 static int my_plugin_bclose(BFILE *bfd)
510 Plugin *plugin = (Plugin *)jcr->plugin;
511 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
513 Dmsg0(dbglvl, "plugin_bclose\n");
514 io.pkt_size = sizeof(io);
515 io.pkt_end = sizeof(io);
521 plug_func(plugin)->pluginIO(plugin_ctx, &io);
522 bfd->berrno = io.io_errno;
524 errno = b_errno_win32;
527 bfd->lerror = io.lerror;
532 static ssize_t my_plugin_bread(BFILE *bfd, void *buf, size_t count)
535 Plugin *plugin = (Plugin *)jcr->plugin;
536 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
538 Dmsg0(dbglvl, "plugin_bread\n");
539 io.pkt_size = sizeof(io);
540 io.pkt_end = sizeof(io);
543 io.buf = (char *)buf;
546 plug_func(plugin)->pluginIO(plugin_ctx, &io);
547 bfd->berrno = io.io_errno;
549 errno = b_errno_win32;
552 bfd->lerror = io.lerror;
554 return (ssize_t)io.status;
557 static ssize_t my_plugin_bwrite(BFILE *bfd, void *buf, size_t count)
560 Plugin *plugin = (Plugin *)jcr->plugin;
561 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
563 Dmsg0(dbglvl, "plugin_bwrite\n");
564 io.pkt_size = sizeof(io);
565 io.pkt_end = sizeof(io);
568 io.buf = (char *)buf;
571 plug_func(plugin)->pluginIO(plugin_ctx, &io);
572 bfd->berrno = io.io_errno;
574 errno = b_errno_win32;
577 bfd->lerror = io.lerror;
579 return (ssize_t)io.status;
582 static boffset_t my_plugin_blseek(BFILE *bfd, boffset_t offset, int whence)
585 Plugin *plugin = (Plugin *)jcr->plugin;
586 bpContext *plugin_ctx = (bpContext *)jcr->plugin_ctx;
588 Dmsg0(dbglvl, "plugin_bseek\n");
589 io.pkt_size = sizeof(io);
590 io.pkt_end = sizeof(io);
596 plug_func(plugin)->pluginIO(plugin_ctx, &io);
597 bfd->berrno = io.io_errno;
599 errno = b_errno_win32;
602 bfd->lerror = io.lerror;
604 return (boffset_t)io.offset;
607 /* ==============================================================
609 * Callbacks from the plugin
611 * ==============================================================
613 static bRC baculaGetValue(bpContext *ctx, bVariable var, void *value)
615 JCR *jcr = (JCR *)(ctx->bContext);
616 // Dmsg1(dbglvl, "bacula: baculaGetValue var=%d\n", var);
620 // Dmsg1(dbglvl, "Bacula: jcr=%p\n", jcr);
623 *((int *)value) = jcr->JobId;
624 Dmsg1(dbglvl, "Bacula: return bVarJobId=%d\n", jcr->JobId);
627 *((char **)value) = my_name;
628 Dmsg1(dbglvl, "Bacula: return my_name=%s\n", my_name);
641 static bRC baculaSetValue(bpContext *ctx, bVariable var, void *value)
643 Dmsg1(dbglvl, "bacula: baculaSetValue var=%d\n", var);
647 static bRC baculaRegisterEvents(bpContext *ctx, ...)
653 while ((event = va_arg(args, uint32_t))) {
654 Dmsg1(dbglvl, "Plugin wants event=%u\n", event);
660 static bRC baculaJobMsg(bpContext *ctx, const char *file, int line,
661 int type, time_t mtime, const char *fmt, ...)
665 JCR *jcr = (JCR *)(ctx->bContext);
667 va_start(arg_ptr, fmt);
668 bvsnprintf(buf, sizeof(buf), fmt, arg_ptr);
670 Jmsg(jcr, type, mtime, "%s", buf);
674 static bRC baculaDebugMsg(bpContext *ctx, const char *file, int line,
675 int level, const char *fmt, ...)
680 va_start(arg_ptr, fmt);
681 bvsnprintf(buf, sizeof(buf), fmt, arg_ptr);
683 d_msg(file, line, level, "%s", buf);
689 int (*plugin_bopen)(JCR *jcr, const char *fname, int flags, mode_t mode) = NULL;
690 int (*plugin_bclose)(JCR *jcr) = NULL;
691 ssize_t (*plugin_bread)(JCR *jcr, void *buf, size_t count) = NULL;
692 ssize_t (*plugin_bwrite)(JCR *jcr, void *buf, size_t count) = NULL;
693 boffset_t (*plugin_blseek)(JCR *jcr, boffset_t offset, int whence) = NULL;
695 int save_file(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
700 bool set_cmd_plugin(BFILE *bfd, JCR *jcr)
705 int main(int argc, char *argv[])
707 char plugin_dir[1000];
712 strcpy(my_name, "test-fd");
714 getcwd(plugin_dir, sizeof(plugin_dir)-1);
715 load_fd_plugins(plugin_dir);
723 generate_plugin_event(jcr1, bEventJobStart, (void *)"Start Job 1");
724 generate_plugin_event(jcr1, bEventJobEnd);
725 generate_plugin_event(jcr2, bEventJobStart, (void *)"Start Job 2");
727 generate_plugin_event(jcr2, bEventJobEnd);
732 Dmsg0(dbglvl, "bacula: OK ...\n");
738 #endif /* TEST_PROGRAM */