git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/filed.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2010 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  *  Bacula File Daemon
  30  *
  31  *    Kern Sibbald, March MM
  32  *
  33  */
  34
  35 #include "bacula.h"
  36 #include "filed.h"
  37
  38 #ifdef HAVE_PYTHON
  39
  40 #undef _POSIX_C_SOURCE
  41 #include <Python.h>
  42
  43 #include "lib/pythonlib.h"
  44
  45 /* Imported Functions */
  46 extern PyObject *job_getattr(PyObject *self, char *attrname);
  47 extern int job_setattr(PyObject *self, char *attrname, PyObject *value);
  48
  49 #endif /* HAVE_PYTHON */
  50
  51 /* Imported Functions */
  52 extern void *handle_client_request(void *dir_sock);
  53 extern bool parse_fd_config(CONFIG *config, const char *configfile, int exit_code);
  54
  55 /* Forward referenced functions */
  56 void terminate_filed(int sig);
  57 static bool check_resources();
  58
  59 /* Exported variables */
  60 CLIENT *me;                           /* my resource */
  61 bool no_signals = false;
  62 void *start_heap;
  63
  64 #define CONFIG_FILE "bacula-fd.conf" /* default config file */
  65
  66 char *configfile = NULL;
  67 static bool foreground = false;
  68 static workq_t dir_workq;             /* queue of work from Director */
  69 static pthread_t server_tid;
  70 static CONFIG *config;
  71
  72 static void usage()
  73 {
  74    fprintf(stderr, _(
  75 PROG_COPYRIGHT
  76 "\nVersion: %s (%s)\n\n"
  77 "Usage: bacula-fd [-f -s] [-c config_file] [-d debug_level]\n"
  78 "        -c <file>   use <file> as configuration file\n"
  79 "        -d <nn>     set debug level to <nn>\n"
  80 "        -dt         print a timestamp in debug output\n"
  81 "        -f          run in foreground (for debugging)\n"
  82 "        -g          groupid\n"
  83 "        -k          keep readall capabilities\n"
  84 "        -m          print kaboom output (for debugging)\n"
  85 "        -s          no signals (for debugging)\n"
  86 "        -t          test configuration file and exit\n"
  87 "        -u          userid\n"
  88 "        -v          verbose user messages\n"
  89 "        -?          print this message.\n"
  90 "\n"), 2000, VERSION, BDATE);
  91
  92    exit(1);
  93 }
  94
  95
  96 /*********************************************************************
  97  *
  98  *  Main Bacula Unix Client Program
  99  *
 100  */
 101 #if defined(HAVE_WIN32)
 102 #define main BaculaMain
 103 #endif
 104
 105 int main (int argc, char *argv[])
 106 {
 107    int ch;
 108    bool test_config = false;
 109    bool keep_readall_caps = false;
 110    char *uid = NULL;
 111    char *gid = NULL;
 112 #ifdef HAVE_PYTHON
 113    init_python_interpreter_args python_args;
 114 #endif /* HAVE_PYTHON */
 115
 116    start_heap = sbrk(0);
 117    setlocale(LC_ALL, "");
 118    bindtextdomain("bacula", LOCALEDIR);
 119    textdomain("bacula");
 120
 121    init_stack_dump();
 122    my_name_is(argc, argv, "bacula-fd");
 123    init_msg(NULL, NULL);
 124    daemon_start_time = time(NULL);
 125
 126    while ((ch = getopt(argc, argv, "c:d:fg:kmstu:v?")) != -1) {
 127       switch (ch) {
 128       case 'c':                    /* configuration file */
 129          if (configfile != NULL) {
 130             free(configfile);
 131          }
 132          configfile = bstrdup(optarg);
 133          break;
 134
 135       case 'd':                    /* debug level */
 136          if (*optarg == 't') {
 137             dbg_timestamp = true;
 138          } else {
 139             debug_level = atoi(optarg);
 140             if (debug_level <= 0) {
 141                debug_level = 1;
 142             }
 143          }
 144          break;
 145
 146       case 'f':                    /* run in foreground */
 147          foreground = true;
 148          break;
 149
 150       case 'g':                    /* set group */
 151          gid = optarg;
 152          break;
 153
 154       case 'k':
 155          keep_readall_caps = true;
 156          break;
 157
 158       case 'm':                    /* print kaboom output */
 159          prt_kaboom = true;
 160          break;
 161
 162       case 's':
 163          no_signals = true;
 164          break;
 165
 166       case 't':
 167          test_config = true;
 168          break;
 169
 170       case 'u':                    /* set userid */
 171          uid = optarg;
 172          break;
 173
 174       case 'v':                    /* verbose */
 175          verbose++;
 176          break;
 177
 178       case '?':
 179       default:
 180          usage();
 181
 182       }
 183    }
 184    argc -= optind;
 185    argv += optind;
 186
 187    if (argc) {
 188       if (configfile != NULL)
 189          free(configfile);
 190       configfile = bstrdup(*argv);
 191       argc--;
 192       argv++;
 193    }
 194    if (argc) {
 195       usage();
 196    }
 197
 198    if (!uid && keep_readall_caps) {
 199       Emsg0(M_ERROR_TERM, 0, _("-k option has no meaning without -u option.\n"));
 200    }
 201
 202    server_tid = pthread_self();
 203    if (!no_signals) {
 204       init_signals(terminate_filed);
 205    } else {
 206       /* This reduces the number of signals facilitating debugging */
 207       watchdog_sleep_time = 120;      /* long timeout for debugging */
 208    }
 209
 210    if (configfile == NULL) {
 211       configfile = bstrdup(CONFIG_FILE);
 212    }
 213
 214    config = new_config_parser();
 215    parse_fd_config(config, configfile, M_ERROR_TERM);
 216
 217    if (init_crypto() != 0) {
 218       Emsg0(M_ERROR, 0, _("Cryptography library initialization failed.\n"));
 219       terminate_filed(1);
 220    }
 221
 222    if (!check_resources()) {
 223       Emsg1(M_ERROR, 0, _("Please correct configuration file: %s\n"), configfile);
 224       terminate_filed(1);
 225    }
 226
 227    set_working_directory(me->working_directory);
 228
 229    if (test_config) {
 230       terminate_filed(0);
 231    }
 232
 233    if (!foreground) {
 234       daemon_start();
 235       init_stack_dump();              /* set new pid */
 236    }
 237
 238    set_thread_concurrency(me->MaxConcurrentJobs + 10);
 239    lmgr_init_thread(); /* initialize the lockmanager stack */
 240
 241    /* Maximum 1 daemon at a time */
 242    create_pid_file(me->pid_directory, "bacula-fd",
 243                    get_first_port_host_order(me->FDaddrs));
 244    read_state_file(me->working_directory, "bacula-fd",
 245                    get_first_port_host_order(me->FDaddrs));
 246
 247    load_fd_plugins(me->plugin_directory);
 248
 249    drop(uid, gid, keep_readall_caps);
 250
 251 #ifdef BOMB
 252    me += 1000000;
 253 #endif
 254
 255 #ifdef HAVE_PYTHON
 256    python_args.progname = me->hdr.name;
 257    python_args.scriptdir = me->scripts_directory;
 258    python_args.modulename = "FDStartUp";
 259    python_args.configfile = configfile;
 260    python_args.workingdir = me->working_directory;
 261    python_args.job_getattr = job_getattr;
 262    python_args.job_setattr = job_setattr;
 263
 264    init_python_interpreter(&python_args);
 265 #endif /* HAVE_PYTHON */
 266
 267    if (!no_signals) {
 268       start_watchdog();               /* start watchdog thread */
 269       init_jcr_subsystem();           /* start JCR watchdogs etc. */
 270    }
 271    server_tid = pthread_self();
 272
 273    /* Become server, and handle requests */
 274    IPADDR *p;
 275    foreach_dlist(p, me->FDaddrs) {
 276       Dmsg1(10, "filed: listening on port %d\n", p->get_port_host_order());
 277    }
 278    bnet_thread_server(me->FDaddrs, me->MaxConcurrentJobs, &dir_workq, handle_client_request);
 279
 280    terminate_filed(0);
 281    exit(0);                           /* should never get here */
 282 }
 283
 284 void terminate_filed(int sig)
 285 {
 286    static bool already_here = false;
 287
 288    if (already_here) {
 289       bmicrosleep(2, 0);              /* yield */
 290       exit(1);                        /* prevent loops */
 291    }
 292    already_here = true;
 293    debug_level = 0;                   /* turn off debug */
 294    stop_watchdog();
 295
 296    bnet_stop_thread_server(server_tid);
 297    generate_daemon_event(NULL, "Exit");
 298    unload_plugins();
 299    write_state_file(me->working_directory, "bacula-fd", get_first_port_host_order(me->FDaddrs));
 300    delete_pid_file(me->pid_directory, "bacula-fd", get_first_port_host_order(me->FDaddrs));
 301
 302    if (configfile != NULL) {
 303       free(configfile);
 304    }
 305
 306    if (debug_level > 0) {
 307       print_memory_pool_stats();
 308    }
 309    if (config) {
 310       config->free_resources();
 311       free(config);
 312       config = NULL;
 313    }
 314    term_msg();
 315    cleanup_crypto();
 316    close_memory_pool();               /* release free memory in pool */
 317    lmgr_cleanup_main();
 318    sm_dump(false);                    /* dump orphaned buffers */
 319    exit(sig);
 320 }
 321
 322 /*
 323 * Make a quick check to see that we have all the
 324 * resources needed.
 325 */
 326 static bool check_resources()
 327 {
 328    bool OK = true;
 329    DIRRES *director;
 330    bool need_tls;
 331
 332    LockRes();
 333
 334    me = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 335    if (!me) {
 336       Emsg1(M_FATAL, 0, _("No File daemon resource defined in %s\n"
 337             "Without that I don't know who I am :-(\n"), configfile);
 338       OK = false;
 339    } else {
 340       if (GetNextRes(R_CLIENT, (RES *) me) != NULL) {
 341          Emsg1(M_FATAL, 0, _("Only one Client resource permitted in %s\n"),
 342               configfile);
 343          OK = false;
 344       }
 345       my_name_is(0, NULL, me->hdr.name);
 346       if (!me->messages) {
 347          me->messages = (MSGS *)GetNextRes(R_MSGS, NULL);
 348          if (!me->messages) {
 349              Emsg1(M_FATAL, 0, _("No Messages resource defined in %s\n"), configfile);
 350              OK = false;
 351          }
 352       }
 353       /* tls_require implies tls_enable */
 354       if (me->tls_require) {
 355 #ifndef HAVE_TLS
 356          Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n"));
 357          OK = false;
 358 #else
 359          me->tls_enable = true;
 360 #endif
 361       }
 362       need_tls = me->tls_enable || me->tls_authenticate;
 363
 364       if ((!me->tls_ca_certfile && !me->tls_ca_certdir) && need_tls) {
 365          Emsg1(M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 366             " or \"TLS CA Certificate Dir\" are defined for File daemon in %s.\n"),
 367                             configfile);
 368         OK = false;
 369       }
 370
 371       /* If everything is well, attempt to initialize our per-resource TLS context */
 372       if (OK && (need_tls || me->tls_require)) {
 373          /* Initialize TLS context:
 374           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 375           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 376          me->tls_ctx = new_tls_context(me->tls_ca_certfile,
 377             me->tls_ca_certdir, me->tls_certfile, me->tls_keyfile,
 378             NULL, NULL, NULL, true);
 379
 380          if (!me->tls_ctx) {
 381             Emsg2(M_FATAL, 0, _("Failed to initialize TLS context for File daemon \"%s\" in %s.\n"),
 382                                 me->hdr.name, configfile);
 383             OK = false;
 384          }
 385       }
 386
 387       if (me->pki_encrypt || me->pki_sign) {
 388 #ifndef HAVE_CRYPTO
 389          Jmsg(NULL, M_FATAL, 0, _("PKI encryption/signing enabled but not compiled into Bacula.\n"));
 390          OK = false;
 391 #endif
 392       }
 393
 394       /* pki_encrypt implies pki_sign */
 395       if (me->pki_encrypt) {
 396          me->pki_sign = true;
 397       }
 398
 399       if ((me->pki_encrypt || me->pki_sign) && !me->pki_keypair_file) {
 400          Emsg2(M_FATAL, 0, _("\"PKI Key Pair\" must be defined for File"
 401             " daemon \"%s\" in %s if either \"PKI Sign\" or"
 402             " \"PKI Encrypt\" are enabled.\n"), me->hdr.name, configfile);
 403          OK = false;
 404       }
 405
 406       /* If everything is well, attempt to initialize our public/private keys */
 407       if (OK && (me->pki_encrypt || me->pki_sign)) {
 408          char *filepath;
 409          /* Load our keypair */
 410          me->pki_keypair = crypto_keypair_new();
 411          if (!me->pki_keypair) {
 412             Emsg0(M_FATAL, 0, _("Failed to allocate a new keypair object.\n"));
 413             OK = false;
 414          } else {
 415             if (!crypto_keypair_load_cert(me->pki_keypair, me->pki_keypair_file)) {
 416                Emsg2(M_FATAL, 0, _("Failed to load public certificate for File"
 417                      " daemon \"%s\" in %s.\n"), me->hdr.name, configfile);
 418                OK = false;
 419             }
 420
 421             if (!crypto_keypair_load_key(me->pki_keypair, me->pki_keypair_file, NULL, NULL)) {
 422                Emsg2(M_FATAL, 0, _("Failed to load private key for File"
 423                      " daemon \"%s\" in %s.\n"), me->hdr.name, configfile);
 424                OK = false;
 425             }
 426          }
 427
 428          /*
 429           * Trusted Signers. We're always trusted.
 430           */
 431          me->pki_signers = New(alist(10, not_owned_by_alist));
 432          if (me->pki_keypair) {
 433             me->pki_signers->append(crypto_keypair_dup(me->pki_keypair));
 434          }
 435
 436          /* If additional signing public keys have been specified, load them up */
 437          if (me->pki_signing_key_files) {
 438             foreach_alist(filepath, me->pki_signing_key_files) {
 439                X509_KEYPAIR *keypair;
 440
 441                keypair = crypto_keypair_new();
 442                if (!keypair) {
 443                   Emsg0(M_FATAL, 0, _("Failed to allocate a new keypair object.\n"));
 444                   OK = false;
 445                } else {
 446                   if (crypto_keypair_load_cert(keypair, filepath)) {
 447                      me->pki_signers->append(keypair);
 448
 449                      /* Attempt to load a private key, if available */
 450                      if (crypto_keypair_has_key(filepath)) {
 451                         if (!crypto_keypair_load_key(keypair, filepath, NULL, NULL)) {
 452                            Emsg3(M_FATAL, 0, _("Failed to load private key from file %s for File"
 453                               " daemon \"%s\" in %s.\n"), filepath, me->hdr.name, configfile);
 454                            OK = false;
 455                         }
 456                      }
 457
 458                   } else {
 459                      Emsg3(M_FATAL, 0, _("Failed to load trusted signer certificate"
 460                         " from file %s for File daemon \"%s\" in %s.\n"), filepath, me->hdr.name, configfile);
 461                      OK = false;
 462                   }
 463                }
 464             }
 465          }
 466
 467          /*
 468           * Crypto recipients. We're always included as a recipient.
 469           * The symmetric session key will be encrypted for each of these readers.
 470           */
 471          me->pki_recipients = New(alist(10, not_owned_by_alist));
 472          if (me->pki_keypair) {
 473             me->pki_recipients->append(crypto_keypair_dup(me->pki_keypair));
 474          }
 475
 476
 477          /* If additional keys have been specified, load them up */
 478          if (me->pki_master_key_files) {
 479             foreach_alist(filepath, me->pki_master_key_files) {
 480                X509_KEYPAIR *keypair;
 481
 482                keypair = crypto_keypair_new();
 483                if (!keypair) {
 484                   Emsg0(M_FATAL, 0, _("Failed to allocate a new keypair object.\n"));
 485                   OK = false;
 486                } else {
 487                   if (crypto_keypair_load_cert(keypair, filepath)) {
 488                      me->pki_recipients->append(keypair);
 489                   } else {
 490                      Emsg3(M_FATAL, 0, _("Failed to load master key certificate"
 491                         " from file %s for File daemon \"%s\" in %s.\n"), filepath, me->hdr.name, configfile);
 492                      OK = false;
 493                   }
 494                }
 495             }
 496          }
 497       }
 498    }
 499
 500
 501    /* Verify that a director record exists */
 502    LockRes();
 503    director = (DIRRES *)GetNextRes(R_DIRECTOR, NULL);
 504    UnlockRes();
 505    if (!director) {
 506       Emsg1(M_FATAL, 0, _("No Director resource defined in %s\n"),
 507             configfile);
 508       OK = false;
 509    }
 510
 511    foreach_res(director, R_DIRECTOR) {
 512       /* tls_require implies tls_enable */
 513       if (director->tls_require) {
 514 #ifndef HAVE_TLS
 515          Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n"));
 516          OK = false;
 517          continue;
 518 #else
 519          director->tls_enable = true;
 520 #endif
 521       }
 522       need_tls = director->tls_enable || director->tls_authenticate;
 523
 524       if (!director->tls_certfile && need_tls) {
 525          Emsg2(M_FATAL, 0, _("\"TLS Certificate\" file not defined for Director \"%s\" in %s.\n"),
 526                director->hdr.name, configfile);
 527          OK = false;
 528       }
 529
 530       if (!director->tls_keyfile && need_tls) {
 531          Emsg2(M_FATAL, 0, _("\"TLS Key\" file not defined for Director \"%s\" in %s.\n"),
 532                director->hdr.name, configfile);
 533          OK = false;
 534       }
 535
 536       if ((!director->tls_ca_certfile && !director->tls_ca_certdir) && need_tls && director->tls_verify_peer) {
 537          Emsg2(M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 538                              " or \"TLS CA Certificate Dir\" are defined for Director \"%s\" in %s."
 539                              " At least one CA certificate store is required"
 540                              " when using \"TLS Verify Peer\".\n"),
 541                              director->hdr.name, configfile);
 542          OK = false;
 543       }
 544
 545       /* If everything is well, attempt to initialize our per-resource TLS context */
 546       if (OK && (need_tls || director->tls_require)) {
 547          /* Initialize TLS context:
 548           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 549           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 550          director->tls_ctx = new_tls_context(director->tls_ca_certfile,
 551             director->tls_ca_certdir, director->tls_certfile,
 552             director->tls_keyfile, NULL, NULL, director->tls_dhfile,
 553             director->tls_verify_peer);
 554
 555          if (!director->tls_ctx) {
 556             Emsg2(M_FATAL, 0, _("Failed to initialize TLS context for Director \"%s\" in %s.\n"),
 557                                 director->hdr.name, configfile);
 558             OK = false;
 559          }
 560       }
 561    }
 562
 563    UnlockRes();
 564
 565    if (OK) {
 566       close_msg(NULL);                /* close temp message handler */
 567       init_msg(NULL, me->messages);   /* open user specified message handler */
 568    }
 569
 570    return OK;
 571 }