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

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