git.sur5r.net Git - bacula/bacula/blob - bacula/src/win32/filed/plugins/exchange-fd.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2008-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  *  Written by James Harper, October 2008
  30  */
  31
  32 #include "exchange-fd.h"
  33
  34 /* Pointers to Bacula functions */
  35 bFuncs *bfuncs = NULL;
  36 bInfo  *binfo = NULL;
  37
  38 #define PLUGIN_LICENSE      "Bacula GPLv2"
  39 #define PLUGIN_AUTHOR       "James Harper"
  40 #define PLUGIN_DATE         "September 2008"
  41 #define PLUGIN_VERSION      "1"
  42 #define PLUGIN_DESCRIPTION  "Exchange Plugin"
  43
  44 static pInfo pluginInfo = {
  45    sizeof(pluginInfo),
  46    FD_PLUGIN_INTERFACE_VERSION,
  47    FD_PLUGIN_MAGIC,
  48    PLUGIN_LICENSE,
  49    PLUGIN_AUTHOR,
  50    PLUGIN_DATE,
  51    PLUGIN_VERSION,
  52    PLUGIN_DESCRIPTION,
  53 };
  54
  55 /* Forward referenced functions */
  56 static bRC newPlugin(bpContext *ctx);
  57 static bRC freePlugin(bpContext *ctx);
  58 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value);
  59 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value);
  60 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value);
  61 static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp);
  62 static bRC endBackupFile(bpContext *ctx);
  63 static bRC pluginIO(bpContext *ctx, struct io_pkt *io);
  64 static bRC startRestoreFile(bpContext *ctx, const char *cmd);
  65 static bRC endRestoreFile(bpContext *ctx);
  66 static bRC createFile(bpContext *ctx, struct restore_pkt *rp);
  67 static bRC setFileAttributes(bpContext *ctx, struct restore_pkt *rp);
  68
  69 static pFuncs pluginFuncs = {
  70    sizeof(pluginFuncs),
  71    FD_PLUGIN_INTERFACE_VERSION,
  72
  73    /* Entry points into plugin */
  74    newPlugin,                         /* new plugin instance */
  75    freePlugin,                        /* free plugin instance */
  76    getPluginValue,
  77    setPluginValue,
  78    handlePluginEvent,
  79    startBackupFile,
  80    endBackupFile,
  81    startRestoreFile,
  82    endRestoreFile,
  83    pluginIO,
  84    createFile,
  85    setFileAttributes
  86 };
  87
  88 extern "C" {
  89
  90 static char **
  91 splitString(char *string, char split, int maxParts, int *count)
  92 {
  93   char **RetVal;
  94   char *first;
  95   char *last;
  96
  97   //KdPrint((__DRIVER_NAME "     a\n"));
  98
  99   *count = 0;
 100
 101   RetVal = (char **)malloc((maxParts + 1) * sizeof(char *));
 102   last = string;
 103   do
 104   {
 105     if (*count == maxParts)
 106       break;
 107     first = last;
 108     for (last = first; *last != '\0' && *last != split; last++);
 109     RetVal[*count] = (char *)malloc(last - first + 1);
 110     strncpy(RetVal[*count], first, last - first);
 111     RetVal[*count][last - first] = 0;
 112     (*count)++;
 113     if (*last == split)
 114       last++;
 115   } while (*last != 0);
 116   RetVal[*count] = NULL;
 117   return RetVal;
 118 }
 119
 120 bRC DLL_IMP_EXP
 121 loadPlugin(bInfo *lbinfo, bFuncs *lbfuncs, pInfo **pinfo, pFuncs **pfuncs)
 122 {
 123         bRC retval;
 124         bfuncs = lbfuncs;                  /* set Bacula funct pointers */
 125         binfo  = lbinfo;
 126         *pinfo = &pluginInfo;
 127         *pfuncs = &pluginFuncs;
 128         retval = loadExchangeApi();
 129         if (retval != bRC_OK)
 130         {
 131                 printf("Cannot load Exchange DLL\n");
 132                 return retval;
 133         }
 134         return retval;
 135 }
 136
 137 bRC DLL_IMP_EXP
 138 unloadPlugin()
 139 {
 140         return bRC_OK;
 141 }
 142
 143 }
 144 /*
 145 void *
 146 b_malloc(const char *file, int lone, size_t size)
 147 {
 148         return NULL;
 149 }
 150
 151 void *
 152 sm_malloc(const char *file, int lone, size_t size)
 153 {
 154         return NULL;
 155 }
 156 */
 157
 158 static bRC newPlugin(bpContext *ctx)
 159 {
 160         exchange_fd_context_t *context;
 161         bRC retval = bRC_OK;
 162         DWORD size;
 163
 164         int JobId = 0;
 165         ctx->pContext = new exchange_fd_context_t;
 166         context = (exchange_fd_context_t *)ctx->pContext;
 167         context->bpContext = ctx;
 168         context->job_since = 0;
 169         context->notrunconfull_option = false;
 170         bfuncs->getBaculaValue(ctx, bVarJobId, (void *)&JobId);
 171         _DebugMessage(0, "newPlugin JobId=%d\n", JobId);
 172         bfuncs->registerBaculaEvents(ctx, 1, 2, 0);
 173         size = MAX_COMPUTERNAME_LENGTH + 1;
 174         context->computer_name = new WCHAR[size];
 175         GetComputerNameW(context->computer_name, &size);
 176         context->current_node = NULL;
 177         context->root_node = NULL;
 178         return retval;
 179 }
 180
 181 static bRC freePlugin(bpContext *ctx)
 182 {
 183         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 184         int JobId = 0;
 185         bfuncs->getBaculaValue(ctx, bVarJobId, (void *)&JobId);
 186         _DebugMessage(100, "freePlugin JobId=%d\n", JobId);
 187         delete context;
 188         return bRC_OK;
 189 }
 190
 191 static bRC getPluginValue(bpContext *ctx, pVariable var, void *value)
 192 {
 193         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 194         _DebugMessage(100, "getPluginValue var=%d\n", var);
 195         return bRC_OK;
 196 }
 197
 198 static bRC setPluginValue(bpContext *ctx, pVariable var, void *value)
 199 {
 200         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 201         _DebugMessage(100, "setPluginValue var=%d\n", var);
 202         return bRC_OK;
 203 }
 204
 205 static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value)
 206 {
 207         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 208         char *name;
 209         int i, intval;
 210         int accurate;
 211
 212         switch (event->eventType) {
 213         case bEventJobStart:
 214                 _DebugMessage(0, "JobStart=%s\n", (char *)value);
 215                 break;
 216         case bEventJobEnd:
 217                 _DebugMessage(0, "JobEnd\n");
 218                 break;
 219         case bEventStartBackupJob:
 220                 _DebugMessage(0, "BackupStart\n");
 221                 bfuncs->getBaculaValue(ctx, bVarAccurate, (void *)&accurate);
 222                 context->accurate = accurate;
 223                 context->job_type = JOB_TYPE_BACKUP;
 224                 // level should have been specified by now - check it
 225                 // if level is D or I, since should have been specified too
 226                 switch (context->job_level)
 227                 {
 228                 case 'F':
 229                         if (context->notrunconfull_option) {
 230                                 context->truncate_logs = false;
 231                         } else {
 232                                 context->truncate_logs = true;
 233                         }
 234                         break;
 235                 case 'D':
 236                         context->truncate_logs = false;
 237                         break;
 238                 case 'I':
 239                         context->truncate_logs = false;
 240                         break;
 241                 default:
 242                         _DebugMessage(0, "Invalid job level %c\n", context->job_level);
 243                         return bRC_Error;
 244                 }
 245                 break;
 246         case bEventEndBackupJob:
 247                 _DebugMessage(0, "BackupEnd\n");
 248                 break;
 249         case bEventLevel:
 250                 intval = (intptr_t)value;
 251                 _DebugMessage(0, "JobLevel=%c %d\n", intval, intval);
 252                 context->job_level = intval;
 253                 break;
 254         case bEventSince:
 255                 intval = (intptr_t)value;
 256                 _DebugMessage(0, "since=%d\n", intval);
 257                 context->job_since = (time_t)value;
 258                 break;
 259         case bEventStartRestoreJob:
 260                 _DebugMessage(0, "StartRestoreJob\n");
 261                 context->job_type = JOB_TYPE_RESTORE;
 262                 break;
 263         case bEventEndRestoreJob:
 264                 _DebugMessage(0, "EndRestoreJob\n");
 265                 break;
 266
 267         /* Plugin command e.g. plugin = <plugin-name>:<name-space>:command */
 268         case bEventRestoreCommand:
 269                 _DebugMessage(0, "restore\n"); // command=%s\n", (char *)value);
 270                 break;
 271
 272         case bEventBackupCommand:
 273                 {
 274                 _DebugMessage(0, "backup command=%s\n", (char *)value);
 275                 char *command = new char[strlen((char *)value)];
 276                 strcpy(command, (char *)value);
 277                 char *plugin_name = strtok((char *)command, ":");
 278                 char *path = strtok(NULL, ":");
 279                 char *option;
 280                 while ((option = strtok(NULL, ":")) != NULL)
 281                 {
 282                         _DebugMessage(100, "option %s\n", option);
 283                         if (stricmp(option, "notrunconfull") == 0)
 284                         {
 285                                 context->notrunconfull_option = true;
 286                         }
 287                         else
 288                         {
 289                                 _JobMessage(M_WARNING, "Unknown plugin option '%s'\n", option);
 290                         }
 291                 }
 292                 _DebugMessage(0, "name = %s\n", plugin_name);
 293                 _DebugMessage(0, "path = %s\n", path);
 294                 if (*path != '/')
 295                 {
 296                         _JobMessage(M_ERROR, "Path does not begin with a '/'\n");
 297                         return bRC_Error;
 298                 }
 299
 300                 for (i = 0; i < 6; i++)
 301                         context->path_bits[i] = NULL;
 302
 303                 char *path_bit = strtok(path, "/");
 304                 for (i = 0; path_bit != NULL && i < 6; i++)
 305                 {
 306                         context->path_bits[i] = new char[strlen(path_bit) + 1];
 307                         strcpy(context->path_bits[i], path_bit);
 308                         path_bit = strtok(NULL, "/");
 309                 }
 310
 311                 if (i < 2 || i > 4)
 312                 {
 313                         _JobMessage(M_ERROR, "Invalid plugin backup path\n");
 314                         return bRC_Error;
 315                 }
 316                 context->root_node = new root_node_t(context->path_bits[0]);
 317                 context->current_node = context->root_node;
 318
 319                 }
 320                 break;
 321
 322    default:
 323            _JobMessage(M_ERROR, "unknown event=%d\n", event->eventType);
 324    }
 325    bfuncs->getBaculaValue(ctx, bVarFDName, (void *)&name);
 326    return bRC_OK;
 327 }
 328
 329 static bRC
 330 startBackupFile(bpContext *ctx, struct save_pkt *sp)
 331 {
 332         bRC retval;
 333         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 334         node_t *current_node;
 335
 336         _DebugMessage(100, "startBackupFile, cmd = %s\n", sp->cmd);
 337         if (sp->pkt_size != sizeof(struct save_pkt) || sp->pkt_end != sizeof(struct save_pkt))
 338         {
 339                 _JobMessage(M_FATAL, "save_pkt size mismatch - sizeof(struct save_pkt) = %d, pkt_size = %d, pkt_end = %d\n", sizeof(struct save_pkt), sp->pkt_size, sp->pkt_end);
 340                 return bRC_Error;
 341         }
 342
 343         //context->root_node = new root_node_t(PLUGIN_PATH_PREFIX_BASE);
 344         //context->current_node = context->root_node;
 345         do {
 346                 current_node  = context->current_node;
 347                 retval = current_node->startBackupFile(context, sp);
 348                 if (retval == bRC_Seen)
 349                         endBackupFile(ctx);
 350         } while (current_node != context->current_node);
 351         _DebugMessage(100, "startBackupFile done - type = %d, fname = %s, retval = %d\n", sp->type, sp->fname, retval);
 352         return retval;
 353 }
 354
 355 static bRC endBackupFile(bpContext *ctx)
 356 {
 357         bRC retval;
 358         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 359         node_t *current_node;
 360
 361         _DebugMessage(100, "endBackupFile\n");
 362
 363         do {
 364                 current_node  = context->current_node;
 365                 retval = current_node->endBackupFile(context);
 366         } while (current_node != context->current_node);
 367         _DebugMessage(100, "endBackupFile done - retval = %d\n", retval);
 368         return retval;
 369 }
 370
 371 /*
 372  * Do actual I/O
 373  */
 374 static bRC pluginIO(bpContext *ctx, struct io_pkt *io)
 375 {
 376         bRC retval = bRC_OK;
 377         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 378
 379         if (io->pkt_size != sizeof(struct io_pkt) || io->pkt_end != sizeof(struct io_pkt))
 380         {
 381                 _JobMessage(M_ERROR, "io_pkt size mismatch - sizeof(struct io_pkt) = %d, pkt_size = %d, pkt_end = %d\n", sizeof(struct io_pkt), io->pkt_size, io->pkt_end);
 382         }
 383
 384         switch(io->func) {
 385         case IO_OPEN:
 386                 _DebugMessage(100, "IO_OPEN\n");
 387                 retval = context->current_node->pluginIoOpen(context, io);
 388                 break;
 389         case IO_READ:
 390                 //_DebugMessage(100, "IO_READ buf=%p len=%d\n", io->buf, io->count);
 391                 retval = context->current_node->pluginIoRead(context, io);
 392                 break;
 393         case IO_WRITE:
 394                 //_DebugMessage(100, "IO_WRITE buf=%p len=%d\n", io->buf, io->count);
 395                 retval = context->current_node->pluginIoWrite(context, io);
 396                 break;
 397         case IO_CLOSE:
 398                 _DebugMessage(100, "IO_CLOSE\n");
 399                 retval = context->current_node->pluginIoClose(context, io);
 400                 break;
 401         }
 402         return retval;
 403 }
 404
 405 static bRC startRestoreFile(bpContext *ctx, const char *cmd)
 406 {
 407         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 408         _DebugMessage(100, "startRestoreFile\n");
 409
 410         return bRC_OK;
 411 }
 412
 413 static bRC endRestoreFile(bpContext *ctx)
 414 {
 415         bRC retval;
 416         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 417         node_t *current_node;
 418
 419         _DebugMessage(100, "endRestoreFile\n");
 420
 421         do {
 422                 current_node  = context->current_node;
 423                 retval = current_node->endRestoreFile(context);
 424         } while (current_node != context->current_node);
 425         _DebugMessage(100, "endRestoreFile done - retval = %d\n", retval);
 426         return retval;
 427 }
 428
 429 static bRC createFile(bpContext *ctx, struct restore_pkt *rp)
 430 {
 431         bRC retval;
 432         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 433         node_t *current_node;
 434         char **path_bits;
 435         int count;
 436         int i;
 437
 438
 439         _DebugMessage(100, "createFile - type = %d, ofname = %s\n", rp->type, rp->ofname);
 440         if (rp->pkt_size != sizeof(struct restore_pkt) || rp->pkt_end != sizeof(struct restore_pkt))
 441         {
 442                 _JobMessage(M_ERROR, "restore_pkt size mismatch - sizeof(struct restore_pkt) = %d, pkt_size = %d, pkt_end = %d\n", sizeof(struct restore_pkt), rp->pkt_size, rp->pkt_end);
 443         }
 444
 445         for (i = 0; i < 6; i++)
 446         {
 447                 context->path_bits[i] = NULL;
 448         }
 449
 450         path_bits = splitString((char *)rp->ofname, '/', 7, &count);
 451
 452         _DebugMessage(100, "count = %d\n", count);
 453
 454         for (i = 1; i < count; i++)
 455         {
 456                 _DebugMessage(150, "%d = '%s'\n", i, path_bits[i]);
 457                 context->path_bits[i - 1] = path_bits[i];
 458         }
 459
 460         if (context->current_node == NULL)
 461         {
 462                 context->root_node = new root_node_t(context->path_bits[0]);
 463                 context->current_node = context->root_node;
 464         }
 465
 466         do {
 467                 current_node  = context->current_node;
 468                 retval = current_node->createFile(context, rp);
 469         } while (current_node != context->current_node);
 470         _DebugMessage(100, "createFile done - retval = %d\n", retval);
 471         return retval;
 472 }
 473
 474 static bRC setFileAttributes(bpContext *ctx, struct restore_pkt *rp)
 475 {
 476         exchange_fd_context_t *context = (exchange_fd_context_t *)ctx->pContext;
 477         _DebugMessage(100, "setFileAttributes\n");
 478         return bRC_OK;
 479 }