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

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