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