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-2008 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 John Walker.
  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  * Sample Plugin program
  30  *
  31  *  Kern Sibbald, October 2007
  32  *
  33  */
  34 #include <stdio.h>
  35 #include "fd-plugins.h"
  36
  37 #undef malloc
  38 #undef free
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 #define PLUGIN_LICENSE      "GPL"
  45 #define PLUGIN_AUTHOR       "Kern Sibbald"
  46 #define PLUGIN_DATE         "January 2008"
  47 #define PLUGIN_VERSION      "1"
  48 #define PLUGIN_DESCRIPTION  "Test File Daemon Plugin"
  49
  50 /* Forward referenced functions */
  51 static bRC newPlugin(bpContext *ctx);
  52 static bRC freePlugin(bpContext *ctx);
  53 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value);
  54 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value);
  55 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value);
  56 static bRC startPluginBackup(bpContext *ctx, struct save_pkt *sp);
  57 static bRC pluginIO(bpContext *ctx, struct io_pkt *io);
  58
  59
  60 /* Pointers to Bacula functions */
  61 static bFuncs *bfuncs = NULL;
  62 static bInfo  *binfo = NULL;
  63
  64 static pInfo pluginInfo = {
  65    sizeof(pluginInfo),
  66    PLUGIN_INTERFACE_VERSION,
  67    PLUGIN_MAGIC,
  68    PLUGIN_LICENSE,
  69    PLUGIN_AUTHOR,
  70    PLUGIN_DATE,
  71    PLUGIN_VERSION,
  72    PLUGIN_DESCRIPTION,
  73 };
  74
  75 static pFuncs pluginFuncs = {
  76    sizeof(pluginFuncs),
  77    PLUGIN_INTERFACE_VERSION,
  78
  79    /* Entry points into plugin */
  80    newPlugin,                         /* new plugin instance */
  81    freePlugin,                        /* free plugin instance */
  82    getPluginValue,
  83    setPluginValue,
  84    handlePluginEvent,
  85    startPluginBackup,
  86    pluginIO
  87 };
  88
  89 struct plugin_ctx {
  90    int record;
  91 };
  92
  93 bRC loadPlugin(bInfo *lbinfo, bFuncs *lbfuncs, pInfo **pinfo, pFuncs **pfuncs)
  94 {
  95    bfuncs = lbfuncs;                  /* set Bacula funct pointers */
  96    binfo  = lbinfo;
  97    printf("bpipe-fd: Loaded: size=%d version=%d\n", bfuncs->size, bfuncs->version);
  98
  99    *pinfo  = &pluginInfo;             /* return pointer to our info */
 100    *pfuncs = &pluginFuncs;            /* return pointer to our functions */
 101
 102    return bRC_OK;
 103 }
 104
 105 bRC unloadPlugin()
 106 {
 107    printf("bpipe-fd: Unloaded\n");
 108    return bRC_OK;
 109 }
 110
 111 static bRC newPlugin(bpContext *ctx)
 112 {
 113    struct plugin_ctx *p_ctx = (struct plugin_ctx *)malloc(sizeof(struct plugin_ctx));
 114
 115    p_ctx->record = -1;
 116    ctx->pContext = (void *)p_ctx;        /* set our context pointer */
 117    return bRC_OK;
 118 }
 119
 120 static bRC freePlugin(bpContext *ctx)
 121 {
 122    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 123    free(p_ctx);
 124    return bRC_OK;
 125 }
 126
 127 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value)
 128 {
 129    return bRC_OK;
 130 }
 131
 132 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value)
 133 {
 134    return bRC_OK;
 135 }
 136
 137 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value)
 138 {
 139    char *name;
 140
 141    switch (event->eventType) {
 142    case bEventJobStart:
 143       printf("bpipe-fd: JobStart=%s\n", (char *)value);
 144       break;
 145    case bEventJobEnd:
 146       printf("bpipe-fd: JobEnd\n");
 147       break;
 148    case bEventBackupStart:
 149       printf("bpipe-fd: BackupStart\n");
 150       break;
 151    case bEventBackupEnd:
 152       printf("bpipe-fd: BackupEnd\n");
 153       break;
 154    case bEventLevel:
 155       printf("bpipe-fd: JobLevel=%c %d\n", (int)value, (int)value);
 156       break;
 157    case bEventSince:
 158       printf("bpipe-fd: since=%d\n", (int)value);
 159       break;
 160
 161    /* Plugin command e.g. plugin = <plugin-name>:<name-space>:command */
 162    case bEventPluginCommand:
 163       printf("bpipe-fd: command=%s\n", (char *)value);
 164       break;
 165
 166    default:
 167       printf("bpipe-fd: unknown event=%d\n", event->eventType);
 168    }
 169    bfuncs->getBaculaValue(ctx, bVarFDName, (void *)&name);
 170 // printf("FD Name=%s\n", name);
 171 // bfuncs->JobMessage(ctx, __FILE__, __LINE__, 1, 0, "JobMesssage message");
 172 // bfuncs->DebugMessage(ctx, __FILE__, __LINE__, 1, "DebugMesssage message");
 173    return bRC_OK;
 174 }
 175
 176 static bRC startPluginBackup(bpContext *ctx, struct save_pkt *sp)
 177 {
 178    static char *fname = (char *)"/BPIPE/test.txt";
 179    time_t now = time(NULL);
 180    sp->fname = fname;
 181    sp->statp.st_mode = 0700;
 182    sp->statp.st_ctime = now;
 183    sp->statp.st_mtime = now;
 184    sp->statp.st_atime = now;
 185    sp->statp.st_size = 100;
 186    sp->statp.st_blksize = 4096;
 187    sp->statp.st_blocks = 1;
 188    printf("bpipe-fd: startPluginBackup\n");
 189    return bRC_OK;
 190 }
 191
 192 /*
 193  * Do actual I/O
 194  */
 195 static bRC pluginIO(bpContext *ctx, struct io_pkt *io)
 196 {
 197    struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
 198
 199    io->status = 0;
 200    io->io_errno = 0;
 201    switch(io->func) {
 202    case IO_OPEN:
 203       p_ctx->record = 0;
 204       printf("bpipe-fd: IO_OPEN\n");
 205       break;
 206    case IO_READ:
 207       printf("bpipe-fd: IO_READ buf=%p len=%d\n", io->buf, io->count);
 208       if (p_ctx->record == 0) {
 209          strcpy(io->buf, "This is a test string.\n");
 210          io->status = strlen(io->buf);
 211          p_ctx->record = 1;
 212          return bRC_OK;
 213       }
 214       io->status = 0;
 215       break;
 216    case IO_WRITE:
 217       printf("bpipe-fd: IO_WRITE buf=%p len=%d\n", io->buf, io->count);
 218       break;
 219    case IO_CLOSE:
 220       printf("bpipe-fd: IO_CLOSE\n");
 221       break;
 222    }
 223    return bRC_OK;
 224 }
 225
 226 #ifdef __cplusplus
 227 }
 228 #endif