git.sur5r.net Git - bacula/bacula/blob - bacula/src/plugins/fd/bpipe-fd.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2007-2009 Free Software Foundation Europe e.V.
   5
   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.
  12
  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.
  17
  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
  21    02110-1301, USA.
  22
  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.
  27 */
  28 /*
  29  * A simple pipe plugin for the Bacula File Daemon
  30  *
  31  *  Kern Sibbald, October 2007
  32  *
  33  */
  34 #include "bacula.h"
  35 #include "fd_plugins.h"
  36
  37 #undef malloc
  38 #undef free
  39 #undef strdup
  40
  41 #define fi __FILE__
  42 #define li __LINE__
  43
  44 #ifdef __cplusplus
  45 extern "C" {
  46 #endif
  47
  48 static const int dbglvl = 150;
  49
  50 #define PLUGIN_LICENSE      "Bacula GPLv2"
  51 #define PLUGIN_AUTHOR       "Kern Sibbald"
  52 #define PLUGIN_DATE         "January 2008"
  53 #define PLUGIN_VERSION      "1"
  54 #define PLUGIN_DESCRIPTION  "Bacula Pipe File Daemon Plugin"
  55
  56 /* Forward referenced functions */
  57 static bRC newPlugin(bpContext *ctx);
  58 static bRC freePlugin(bpContext *ctx);
  59 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value);
  60 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value);
  61 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value);
  62 static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp);
  63 static bRC endBackupFile(bpContext *ctx);
  64 static bRC pluginIO(bpContext *ctx, struct io_pkt *io);
  65 static bRC startRestoreFile(bpContext *ctx, const char *cmd);
  66 static bRC endRestoreFile(bpContext *ctx);
  67 static bRC createFile(bpContext *ctx, struct restore_pkt *rp);
  68 static bRC setFileAttributes(bpContext *ctx, struct restore_pkt *rp);
  69
  70 static char *apply_rp_codes(struct plugin_ctx * p_ctx);
  71
  72 /* Pointers to Bacula functions */
  73 static bFuncs *bfuncs = NULL;
  74 static bInfo  *binfo = NULL;
  75
  76 /* Plugin Information block */
  77 static pInfo pluginInfo = {
  78    sizeof(pluginInfo),
  79    FD_PLUGIN_INTERFACE_VERSION,
  80    FD_PLUGIN_MAGIC,
  81    PLUGIN_LICENSE,
  82    PLUGIN_AUTHOR,
  83    PLUGIN_DATE,
  84    PLUGIN_VERSION,
  85    PLUGIN_DESCRIPTION,
  86 };
  87
  88 /* Plugin entry points for Bacula */
  89 static pFuncs pluginFuncs = {
  90    sizeof(pluginFuncs),
  91    FD_PLUGIN_INTERFACE_VERSION,
  92
  93    /* Entry points into plugin */
  94    newPlugin,                         /* new plugin instance */
  95    freePlugin,                        /* free plugin instance */
  96    getPluginValue,
  97    setPluginValue,
  98    handlePluginEvent,
  99    startBackupFile,
 100    endBackupFile,
 101    startRestoreFile,
 102    endRestoreFile,
 103    pluginIO,
 104    createFile,
 105    setFileAttributes
 106 };
 107
 108 /*
 109  * Plugin private context
 110  */
 111 struct plugin_ctx {
 112    boffset_t offset;
 113    FILE *fd;                          /* pipe file descriptor */
 114    bool backup;                       /* set for backup (not needed) */
 115    char *cmd;                         /* plugin command line */
 116    char *fname;                       /* filename to "backup/restore" */
 117    char *reader;                      /* reader program for backup */
 118    char *writer;                      /* writer program for backup */
 119
 120    char where[512];
 121    int replace;
 122 };
 123
 124 /*
 125  * loadPlugin() and unloadPlugin() are entry points that are
 126  *  exported, so Bacula can directly call these two entry points
 127  *  they are common to all Bacula plugins.
 128  */
 129 /*
 130  * External entry point called by Bacula to "load the plugin
 131  */
 132 bRC loadPlugin(bInfo *lbinfo, bFuncs *lbfuncs, pInfo **pinfo, pFuncs **pfuncs)
 133 {
 134    bfuncs = lbfuncs;                  /* set Bacula funct pointers */
 135    binfo  = lbinfo;
 136    *pinfo  = &pluginInfo;             /* return pointer to our info */
 137    *pfuncs = &pluginFuncs;            /* return pointer to our functions */
 138
 139    return bRC_OK;
 140 }
 141
 142 /*
 143  * External entry point to unload the plugin
 144  */
 145 bRC unloadPlugin()
 146 {
 147 // printf("bpipe-fd: Unloaded\n");
 148    return bRC_OK;
 149 }
 150
 151 /*
 152  * The following entry points are accessed through the function
 153  *   pointers we supplied to Bacula. Each plugin type (dir, fd, sd)
 154  *   has its own set of entry points that the plugin must define.
 155  */
 156 /*
 157  * Create a new instance of the plugin i.e. allocate our private storage
 158  */
 159 static bRC newPlugin(bpContext *ctx)
 160 {
 161    struct plugin_ctx *p_ctx = (struct plugin_ctx *)malloc(sizeof(struct plugin_ctx));
 162    if (!p_ctx) {
 163       return bRC_Error;
 164    }
 165    memset(p_ctx, 0, sizeof(struct plugin_ctx));
 166    ctx->pContext = (void *)p_ctx;        /* set our context pointer */
 167    return bRC_OK;
 168 }
 169
 170 /*
 171  * Free a plugin instance, i.e. release our private storage
 172  */
 173 static bRC freePlugin(bpContext *ctx)
 174 {
 175    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 176    if (p_ctx->cmd) {
 177       free(p_ctx->cmd);                  /* free any allocated command string */
 178    }
 179    free(p_ctx);                          /* free our private context */
 180    p_ctx = NULL;
 181    return bRC_OK;
 182 }
 183
 184 /*
 185  * Return some plugin value (none defined)
 186  */
 187 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value)
 188 {
 189    return bRC_OK;
 190 }
 191
 192 /*
 193  * Set a plugin value (none defined)
 194  */
 195 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value)
 196 {
 197    return bRC_OK;
 198 }
 199
 200 /*
 201  * Handle an event that was generated in Bacula
 202  */
 203 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value)
 204 {
 205    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 206 // char *name;
 207
 208    /*
 209     * Most events don't interest us so we ignore them.
 210     *   the printfs are so that plugin writers can enable them to see
 211     *   what is really going on.
 212     */
 213    switch (event->eventType) {
 214    case bEventJobStart:
 215       bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: JobStart=%s\n", (char *)value);
 216       break;
 217    case bEventJobEnd:
 218 //    printf("bpipe-fd: JobEnd\n");
 219       break;
 220    case bEventStartBackupJob:
 221 //    printf("bpipe-fd: StartBackupJob\n");
 222       break;
 223    case bEventEndBackupJob:
 224 //    printf("bpipe-fd: EndBackupJob\n");
 225       break;
 226    case bEventLevel:
 227 //    printf("bpipe-fd: JobLevel=%c %d\n", (int)value, (int)value);
 228       break;
 229    case bEventSince:
 230 //    printf("bpipe-fd: since=%d\n", (int)value);
 231       break;
 232
 233    case bEventStartRestoreJob:
 234 //    printf("bpipe-fd: StartRestoreJob\n");
 235       break;
 236
 237    case bEventEndRestoreJob:
 238 //    printf("bpipe-fd: EndRestoreJob\n");
 239       break;
 240
 241    /* Plugin command e.g. plugin = <plugin-name>:<name-space>:read command:write command */
 242    case bEventRestoreCommand:
 243 //    printf("bpipe-fd: EventRestoreCommand cmd=%s\n", (char *)value);
 244       /* Fall-through wanted */
 245    case bEventBackupCommand:
 246       char *p;
 247       bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: pluginEvent cmd=%s\n", (char *)value);
 248       p_ctx->cmd = strdup((char *)value);
 249       p = strchr(p_ctx->cmd, ':');
 250       if (!p) {
 251          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "Plugin terminator not found: %s\n", (char *)value);
 252          return bRC_Error;
 253       }
 254       *p++ = 0;           /* terminate plugin */
 255       p_ctx->fname = p;
 256       p = strchr(p, ':');
 257       if (!p) {
 258          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "File terminator not found: %s\n", (char *)value);
 259          return bRC_Error;
 260       }
 261       *p++ = 0;           /* terminate file */
 262       p_ctx->reader = p;
 263       p = strchr(p, ':');
 264       if (!p) {
 265          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "Reader terminator not found: %s\n", (char *)value);
 266          return bRC_Error;
 267       }
 268       *p++ = 0;           /* terminate reader string */
 269       p_ctx->writer = p;
 270 //    printf("bpipe-fd: plugin=%s fname=%s reader=%s writer=%s\n",
 271 //         p_ctx->cmd, p_ctx->fname, p_ctx->reader, p_ctx->writer);
 272       break;
 273
 274    default:
 275 //    printf("bpipe-fd: unknown event=%d\n", event->eventType);
 276       break;
 277    }
 278    return bRC_OK;
 279 }
 280
 281 /*
 282  * Start the backup of a specific file
 283  */
 284 static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp)
 285 {
 286    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 287    time_t now = time(NULL);
 288    sp->fname = p_ctx->fname;
 289    sp->type = FT_REG;
 290    sp->statp.st_mode = 0700 | S_IFREG;
 291    sp->statp.st_ctime = now;
 292    sp->statp.st_mtime = now;
 293    sp->statp.st_atime = now;
 294    sp->statp.st_size = -1;
 295    sp->statp.st_blksize = 4096;
 296    sp->statp.st_blocks = 1;
 297    p_ctx->backup = true;
 298 // printf("bpipe-fd: startBackupFile\n");
 299    return bRC_OK;
 300 }
 301
 302 /*
 303  * Done with backup of this file
 304  */
 305 static bRC endBackupFile(bpContext *ctx)
 306 {
 307    /*
 308     * We would return bRC_More if we wanted startBackupFile to be
 309     * called again to backup another file
 310     */
 311    return bRC_OK;
 312 }
 313
 314
 315 /*
 316  * Bacula is calling us to do the actual I/O
 317  */
 318 static bRC pluginIO(bpContext *ctx, struct io_pkt *io)
 319 {
 320    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 321
 322    io->status = 0;
 323    io->io_errno = 0;
 324    switch(io->func) {
 325    case IO_OPEN:
 326       bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: IO_OPEN\n");
 327       if (io->flags & (O_CREAT | O_WRONLY)) {
 328          char *writer_codes = apply_rp_codes(p_ctx);
 329
 330          p_ctx->fd = popen(writer_codes, "w");
 331          bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: IO_OPEN fd=%d writer=%s\n",
 332              p_ctx->fd, writer_codes);
 333          if (!p_ctx->fd) {
 334             io->io_errno = errno;
 335             bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0,
 336                "Open pipe writer=%s failed: ERR=%s\n", writer_codes, strerror(errno));
 337             if (writer_codes) {
 338                free(writer_codes);
 339             }
 340             return bRC_Error;
 341          }
 342          if (writer_codes) {
 343             free(writer_codes);
 344          }
 345       } else {
 346          p_ctx->fd = popen(p_ctx->reader, "r");
 347          bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: IO_OPEN fd=%p reader=%s\n",
 348             p_ctx->fd, p_ctx->reader);
 349          if (!p_ctx->fd) {
 350             io->io_errno = errno;
 351             bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0,
 352                "Open pipe reader=%s failed: ERR=%s\n", p_ctx->reader, strerror(errno));
 353             return bRC_Error;
 354          }
 355       }
 356       sleep(1);                 /* let pipe connect */
 357       break;
 358
 359    case IO_READ:
 360       if (!p_ctx->fd) {
 361          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "Logic error: NULL read FD\n");
 362          return bRC_Error;
 363       }
 364       io->status = fread(io->buf, 1, io->count, p_ctx->fd);
 365 //    bfuncs->DebugMessage(ctx, fi, li, dbglvl, "bpipe-fd: IO_READ buf=%p len=%d\n", io->buf, io->status);
 366       if (io->status == 0 && ferror(p_ctx->fd)) {
 367          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0,
 368             "Pipe read error: ERR=%s\n", strerror(errno));
 369          bfuncs->DebugMessage(ctx, fi, li, dbglvl,
 370             "Pipe read error: ERR=%s\n", strerror(errno));
 371          return bRC_Error;
 372       }
 373       break;
 374
 375    case IO_WRITE:
 376       if (!p_ctx->fd) {
 377          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "Logic error: NULL write FD\n");
 378          return bRC_Error;
 379       }
 380 //    printf("bpipe-fd: IO_WRITE fd=%p buf=%p len=%d\n", p_ctx->fd, io->buf, io->count);
 381       io->status = fwrite(io->buf, 1, io->count, p_ctx->fd);
 382 //    printf("bpipe-fd: IO_WRITE buf=%p len=%d\n", io->buf, io->status);
 383       if (io->status == 0 && ferror(p_ctx->fd)) {
 384          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0,
 385             "Pipe write error\n");
 386          bfuncs->DebugMessage(ctx, fi, li, dbglvl,
 387             "Pipe read error: ERR=%s\n", strerror(errno));
 388          return bRC_Error;
 389       }
 390       break;
 391
 392    case IO_CLOSE:
 393       if (!p_ctx->fd) {
 394          bfuncs->JobMessage(ctx, fi, li, M_FATAL, 0, "Logic error: NULL FD on bpipe close\n");
 395          return bRC_Error;
 396       }
 397       io->status = pclose(p_ctx->fd);
 398       break;
 399
 400    case IO_SEEK:
 401       io->offset = p_ctx->offset;
 402       break;
 403    }
 404    return bRC_OK;
 405 }
 406
 407 /*
 408  * Bacula is notifying us that a plugin name string was found, and
 409  *   passing us the plugin command, so we can prepare for a restore.
 410  */
 411 static bRC startRestoreFile(bpContext *ctx, const char *cmd)
 412 {
 413 // printf("bpipe-fd: startRestoreFile cmd=%s\n", cmd);
 414    return bRC_OK;
 415 }
 416
 417 /*
 418  * Bacula is notifying us that the plugin data has terminated, so
 419  *  the restore for this particular file is done.
 420  */
 421 static bRC endRestoreFile(bpContext *ctx)
 422 {
 423 // printf("bpipe-fd: endRestoreFile\n");
 424    return bRC_OK;
 425 }
 426
 427 /*
 428  * This is called during restore to create the file (if necessary)
 429  * We must return in rp->create_status:
 430  *
 431  *  CF_ERROR    -- error
 432  *  CF_SKIP     -- skip processing this file
 433  *  CF_EXTRACT  -- extract the file (i.e.call i/o routines)
 434  *  CF_CREATED  -- created, but no content to extract (typically directories)
 435  *
 436  */
 437 static bRC createFile(bpContext *ctx, struct restore_pkt *rp)
 438 {
 439 // printf("bpipe-fd: createFile\n");
 440    if (strlen(rp->where) > 512) {
 441       printf("Restore target dir too long. Restricting to first 512 bytes.\n");
 442    }
 443    strncpy(((struct plugin_ctx *)ctx->pContext)->where, rp->where, 513);
 444    ((struct plugin_ctx *)ctx->pContext)->replace = rp->replace;
 445    rp->create_status = CF_EXTRACT;
 446    return bRC_OK;
 447 }
 448
 449 /*
 450  * We will get here if the File is a directory after everything
 451  * is written in the directory.
 452  */
 453 static bRC setFileAttributes(bpContext *ctx, struct restore_pkt *rp)
 454 {
 455 // printf("bpipe-fd: setFileAttributes\n");
 456    return bRC_OK;
 457 }
 458
 459 /*************************************************************************
 460  * Apply codes in writer command:
 461  * %w -> "where"
 462  * %r -> "replace"
 463  *
 464  * Replace:
 465  * 'always' => 'a', chr(97)
 466  * 'ifnewer' => 'w', chr(119)
 467  * 'ifolder' => 'o', chr(111)
 468  * 'never' => 'n', chr(110)
 469  *
 470  * This function will allocate the required amount of memory with malloc.
 471  * Need to be free()d manually.
 472  * Inspired by edit_job_codes in lib/util.c
 473  */
 474
 475 static char *apply_rp_codes(struct plugin_ctx * p_ctx)
 476 {
 477    char *p, *q;
 478    const char *str;
 479    char add[10];
 480    int w_count = 0, r_count = 0;
 481    char *omsg;
 482
 483    char *imsg = p_ctx->writer;
 484
 485    if (!imsg) {
 486       return NULL;
 487    }
 488
 489    if ((p = imsg)) {
 490       while ((q = strstr(p, "%w"))) {
 491          w_count++;
 492          p=q+1;
 493       }
 494
 495       p = imsg;
 496       while ((q = strstr(p, "%r"))) {
 497          r_count++;
 498          p=q+1;
 499       }
 500    }
 501
 502    /* Required mem:
 503     * len(imsg)
 504     * + number of "where" codes * (len(where)-2)
 505     * - number of "replace" codes
 506     */
 507    omsg = (char*)malloc(strlen(imsg) + (w_count * (strlen(p_ctx->where)-2)) - r_count + 1);
 508    if (!omsg) {
 509       fprintf(stderr, "Out of memory.");
 510       return NULL;
 511    }
 512
 513    *omsg = 0;
 514    //printf("apply_rp_codes: %s\n", imsg);
 515    for (p=imsg; *p; p++) {
 516       if (*p == '%') {
 517          switch (*++p) {
 518          case '%':
 519             str = "%";
 520             break;
 521          case 'w':
 522              str = p_ctx->where;
 523              break;
 524          case 'r':
 525             snprintf(add, 2, "%c", p_ctx->replace);
 526             str = add;
 527             break;
 528          default:
 529             add[0] = '%';
 530             add[1] = *p;
 531             add[2] = 0;
 532             str = add;
 533             break;
 534          }
 535       } else {
 536          add[0] = *p;
 537          add[1] = 0;
 538          str = add;
 539       }
 540       //printf("add_str %s\n", str);
 541       strcat(omsg, str);
 542       //printf("omsg=%s\n", omsg);
 543    }
 544    return omsg;
 545 }
 546
 547
 548 #ifdef __cplusplus
 549 }
 550 #endif