git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/fd_cmds.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-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 and included
  11    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  * This file handles commands from the File daemon.
  30  *
  31  *  Kern Sibbald, MM
  32  *
  33  * We get here because the Director has initiated a Job with
  34  *  the Storage daemon, then done the same with the File daemon,
  35  *  then when the Storage daemon receives a proper connection from
  36  *  the File daemon, control is passed here to handle the
  37  *  subsequent File daemon commands.
  38  *
  39  *   Version $Id$
  40  *
  41  */
  42
  43 #include "bacula.h"
  44 #include "stored.h"
  45
  46 /* Imported variables */
  47 extern STORES *me;
  48
  49 /* Static variables */
  50 static char ferrmsg[]      = "3900 Invalid command\n";
  51
  52 /* Imported functions */
  53 extern bool do_append_data(JCR *jcr);
  54 extern bool do_read_data(JCR *jcr);
  55
  56 /* Forward referenced FD commands */
  57 static bool append_open_session(JCR *jcr);
  58 static bool append_close_session(JCR *jcr);
  59 static bool append_data_cmd(JCR *jcr);
  60 static bool append_end_session(JCR *jcr);
  61 static bool read_open_session(JCR *jcr);
  62 static bool read_data_cmd(JCR *jcr);
  63 static bool read_close_session(JCR *jcr);
  64 static bool bootstrap_cmd(JCR *jcr);
  65
  66 /* Exported function */
  67 bool get_bootstrap_file(JCR *jcr, BSOCK *bs);
  68
  69 struct s_cmds {
  70    const char *cmd;
  71    bool (*func)(JCR *jcr);
  72 };
  73
  74 /*
  75  * The following are the recognized commands from the File daemon
  76  */
  77 static struct s_cmds fd_cmds[] = {
  78    {"append open",  append_open_session},
  79    {"append data",  append_data_cmd},
  80    {"append end",   append_end_session},
  81    {"append close", append_close_session},
  82    {"read open",    read_open_session},
  83    {"read data",    read_data_cmd},
  84    {"read close",   read_close_session},
  85    {"bootstrap",    bootstrap_cmd},
  86    {NULL,           NULL}                  /* list terminator */
  87 };
  88
  89 /* Commands from the File daemon that require additional scanning */
  90 static char read_open[]       = "read open session = %127s %ld %ld %ld %ld %ld %ld\n";
  91
  92 /* Responses sent to the File daemon */
  93 static char NO_open[]         = "3901 Error session already open\n";
  94 static char NOT_opened[]      = "3902 Error session not opened\n";
  95 static char OK_end[]          = "3000 OK end\n";
  96 static char OK_close[]        = "3000 OK close Status = %d\n";
  97 static char OK_open[]         = "3000 OK open ticket = %d\n";
  98 static char ERROR_append[]    = "3903 Error append data\n";
  99 static char OK_bootstrap[]    = "3000 OK bootstrap\n";
 100 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
 101
 102 /* Information sent to the Director */
 103 static char Job_start[] = "3010 Job %s start\n";
 104 char Job_end[]   =
 105    "3099 Job %s end JobStatus=%d JobFiles=%d JobBytes=%s JobErrors=%u\n";
 106
 107 /*
 108  * Run a File daemon Job -- File daemon already authorized
 109  *  Director sends us this command.
 110  *
 111  * Basic task here is:
 112  * - Read a command from the File daemon
 113  * - Execute it
 114  *
 115  */
 116 void run_job(JCR *jcr)
 117 {
 118    BSOCK *dir = jcr->dir_bsock;
 119    char ec1[30];
 120
 121    dir->set_jcr(jcr);
 122    Dmsg1(120, "Start run Job=%s\n", jcr->Job);
 123    dir->fsend(Job_start, jcr->Job);
 124    jcr->start_time = time(NULL);
 125    jcr->run_time = jcr->start_time;
 126    set_jcr_job_status(jcr, JS_Running);
 127    dir_send_job_status(jcr);          /* update director */
 128    do_fd_commands(jcr);
 129    jcr->end_time = time(NULL);
 130    dequeue_messages(jcr);             /* send any queued messages */
 131    set_jcr_job_status(jcr, JS_Terminated);
 132    generate_daemon_event(jcr, "JobEnd");
 133    dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
 134       edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
 135    dir->signal(BNET_EOD);             /* send EOD to Director daemon */
 136    return;
 137 }
 138
 139 /*
 140  * Now talk to the FD and do what he says
 141  */
 142 void do_fd_commands(JCR *jcr)
 143 {
 144    int i;
 145    bool found, quit;
 146    BSOCK *fd = jcr->file_bsock;
 147
 148    fd->set_jcr(jcr);
 149    for (quit=false; !quit;) {
 150       int stat;
 151
 152       /* Read command coming from the File daemon */
 153       stat = fd->recv();
 154       if (is_bnet_stop(fd)) {         /* hardeof or error */
 155          break;                       /* connection terminated */
 156       }
 157       if (stat <= 0) {
 158          continue;                    /* ignore signals and zero length msgs */
 159       }
 160       Dmsg1(110, "<filed: %s", fd->msg);
 161       found = false;
 162       for (i=0; fd_cmds[i].cmd; i++) {
 163          if (strncmp(fd_cmds[i].cmd, fd->msg, strlen(fd_cmds[i].cmd)) == 0) {
 164             found = true;               /* indicate command found */
 165             if (!fd_cmds[i].func(jcr) || job_canceled(jcr)) {    /* do command */
 166                set_jcr_job_status(jcr, JS_ErrorTerminated);
 167                quit = true;
 168             }
 169             break;
 170          }
 171       }
 172       if (!found) {                   /* command not found */
 173          Dmsg1(110, "<filed: Command not found: %s\n", fd->msg);
 174          fd->fsend(ferrmsg);
 175          break;
 176       }
 177    }
 178    fd->signal(BNET_TERMINATE);        /* signal to FD job is done */
 179 }
 180
 181 /*
 182  *   Append Data command
 183  *     Open Data Channel and receive Data for archiving
 184  *     Write the Data to the archive device
 185  */
 186 static bool append_data_cmd(JCR *jcr)
 187 {
 188    BSOCK *fd = jcr->file_bsock;
 189
 190    Dmsg1(120, "Append data: %s", fd->msg);
 191    if (jcr->session_opened) {
 192       Dmsg1(110, "<bfiled: %s", fd->msg);
 193       jcr->set_JobType(JT_BACKUP);
 194       if (do_append_data(jcr)) {
 195          return true;
 196       } else {
 197          bnet_suppress_error_messages(fd, 1); /* ignore errors at this point */
 198          fd->fsend(ERROR_append);
 199       }
 200    } else {
 201       fd->fsend(NOT_opened);
 202    }
 203    return false;
 204 }
 205
 206 static bool append_end_session(JCR *jcr)
 207 {
 208    BSOCK *fd = jcr->file_bsock;
 209
 210    Dmsg1(120, "store<file: %s", fd->msg);
 211    if (!jcr->session_opened) {
 212       fd->fsend(NOT_opened);
 213       return false;
 214    }
 215    return fd->fsend(OK_end);
 216 }
 217
 218
 219 /*
 220  * Append Open session command
 221  *
 222  */
 223 static bool append_open_session(JCR *jcr)
 224 {
 225    BSOCK *fd = jcr->file_bsock;
 226
 227    Dmsg1(120, "Append open session: %s", fd->msg);
 228    if (jcr->session_opened) {
 229       fd->fsend(NO_open);
 230       return false;
 231    }
 232
 233    jcr->session_opened = true;
 234
 235    /* Send "Ticket" to File Daemon */
 236    fd->fsend(OK_open, jcr->VolSessionId);
 237    Dmsg1(110, ">filed: %s", fd->msg);
 238
 239    return true;
 240 }
 241
 242 /*
 243  *   Append Close session command
 244  *      Close the append session and send back Statistics
 245  *         (need to fix statistics)
 246  */
 247 static bool append_close_session(JCR *jcr)
 248 {
 249    BSOCK *fd = jcr->file_bsock;
 250
 251    Dmsg1(120, "<filed: %s", fd->msg);
 252    if (!jcr->session_opened) {
 253       fd->fsend(NOT_opened);
 254       return false;
 255    }
 256    /* Send final statistics to File daemon */
 257    fd->fsend(OK_close, jcr->JobStatus);
 258    Dmsg1(120, ">filed: %s", fd->msg);
 259
 260    fd->signal(BNET_EOD);              /* send EOD to File daemon */
 261
 262    jcr->session_opened = false;
 263    return true;
 264 }
 265
 266 /*
 267  *   Read Data command
 268  *     Open Data Channel, read the data from
 269  *     the archive device and send to File
 270  *     daemon.
 271  */
 272 static bool read_data_cmd(JCR *jcr)
 273 {
 274    BSOCK *fd = jcr->file_bsock;
 275
 276    Dmsg1(120, "Read data: %s", fd->msg);
 277    if (jcr->session_opened) {
 278       Dmsg1(120, "<bfiled: %s", fd->msg);
 279       return do_read_data(jcr);
 280    } else {
 281       fd->fsend(NOT_opened);
 282       return false;
 283    }
 284 }
 285
 286 /*
 287  * Read Open session command
 288  *
 289  *  We need to scan for the parameters of the job
 290  *    to be restored.
 291  */
 292 static bool read_open_session(JCR *jcr)
 293 {
 294    BSOCK *fd = jcr->file_bsock;
 295
 296    Dmsg1(120, "%s\n", fd->msg);
 297    if (jcr->session_opened) {
 298       fd->fsend(NO_open);
 299       return false;
 300    }
 301
 302    if (sscanf(fd->msg, read_open, jcr->read_dcr->VolumeName, &jcr->read_VolSessionId,
 303          &jcr->read_VolSessionTime, &jcr->read_StartFile, &jcr->read_EndFile,
 304          &jcr->read_StartBlock, &jcr->read_EndBlock) == 7) {
 305       if (jcr->session_opened) {
 306          fd->fsend(NOT_opened);
 307          return false;
 308       }
 309       Dmsg4(100, "read_open_session got: JobId=%d Vol=%s VolSessId=%ld VolSessT=%ld\n",
 310          jcr->JobId, jcr->read_dcr->VolumeName, jcr->read_VolSessionId,
 311          jcr->read_VolSessionTime);
 312       Dmsg4(100, "  StartF=%ld EndF=%ld StartB=%ld EndB=%ld\n",
 313          jcr->read_StartFile, jcr->read_EndFile, jcr->read_StartBlock,
 314          jcr->read_EndBlock);
 315    }
 316
 317    jcr->session_opened = true;
 318    jcr->set_JobType(JT_RESTORE);
 319
 320    /* Send "Ticket" to File Daemon */
 321    fd->fsend(OK_open, jcr->VolSessionId);
 322    Dmsg1(110, ">filed: %s", fd->msg);
 323
 324    return true;
 325 }
 326
 327 static bool bootstrap_cmd(JCR *jcr)
 328 {
 329    return get_bootstrap_file(jcr, jcr->file_bsock);
 330 }
 331
 332 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
 333 static uint32_t bsr_uniq = 0;
 334
 335 bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
 336 {
 337    POOLMEM *fname = get_pool_memory(PM_FNAME);
 338    FILE *bs;
 339    bool ok = false;
 340
 341    if (jcr->RestoreBootstrap) {
 342       unlink(jcr->RestoreBootstrap);
 343       free_pool_memory(jcr->RestoreBootstrap);
 344    }
 345    P(bsr_mutex);
 346    bsr_uniq++;
 347    Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
 348       jcr->Job, bsr_uniq);
 349    V(bsr_mutex);
 350    Dmsg1(400, "bootstrap=%s\n", fname);
 351    jcr->RestoreBootstrap = fname;
 352    bs = fopen(fname, "a+b");           /* create file */
 353    if (!bs) {
 354       berrno be;
 355       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
 356          jcr->RestoreBootstrap, be.bstrerror());
 357       goto bail_out;
 358    }
 359    Dmsg0(10, "=== Bootstrap file ===\n");
 360    while (sock->recv() >= 0) {
 361        Dmsg1(10, "%s", sock->msg);
 362        fputs(sock->msg, bs);
 363    }
 364    fclose(bs);
 365    Dmsg0(10, "=== end bootstrap file ===\n");
 366    jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
 367    if (!jcr->bsr) {
 368       Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
 369       goto bail_out;
 370    }
 371    if (debug_level >= 10) {
 372       dump_bsr(jcr->bsr, true);
 373    }
 374    ok = true;
 375
 376 bail_out:
 377    unlink(jcr->RestoreBootstrap);
 378    free_pool_memory(jcr->RestoreBootstrap);
 379    jcr->RestoreBootstrap = NULL;
 380    if (!ok) {
 381       sock->fsend(ERROR_bootstrap);
 382       return false;
 383    }
 384    return sock->fsend(OK_bootstrap);
 385 }
 386
 387
 388 /*
 389  *   Read Close session command
 390  *      Close the read session
 391  */
 392 static bool read_close_session(JCR *jcr)
 393 {
 394    BSOCK *fd = jcr->file_bsock;
 395
 396    Dmsg1(120, "Read close session: %s\n", fd->msg);
 397    if (!jcr->session_opened) {
 398       fd->fsend(NOT_opened);
 399       return false;
 400    }
 401    /* Send final close msg to File daemon */
 402    fd->fsend(OK_close, jcr->JobStatus);
 403    Dmsg1(160, ">filed: %s\n", fd->msg);
 404
 405    fd->signal(BNET_EOD);            /* send EOD to File daemon */
 406
 407    jcr->session_opened = false;
 408    return true;
 409 }